avr-usb-162_Led.c

/*  Test program for Olimex AVR-USB-162 with AT90USB162 processor

 *  for application TIC (TimerIncrementClock)

 *  Blinks the led using a simple delay loop

 *    and add with Balkenanzeige

 *  Compile with AVRStudio+WinAVR (gcc V4.3.0, WinAVR20080610, AVR lib 1.6.2)

* 

*  Gerhard V0.2, 4.10.08

*    Erzeugung eines Array für low und high matrix für die Zeiten

*       1 bis 30

*    Zusätzlich kann dadurch eine oder mehrere LEDs zweimal ein-

*       geschaltet werden, für 5-er oder 6-er Markierung

*    Highside Matrix (C1-C5 an PB0, PB4-7 wird im ausgeschaltetem Zustand 

*       als Eingang und dadurch hochohmig geschaltet

*    Matrix umbenannt: A1-A5 (Anode) statt C1-C5 (column) und 

*       K1-K5 (Kathode) statt R1-R5 (row),da jetzt

*       da jetzt LED-Bargraph statt LED-Matrix

*

*    WIEDER GELÖSCHT: Const in Flash aus"avr-libc: Frequently Asked Questions"

*

* Gerhard V0.3  11.10.08

*  Lichtmarkierung wieder entfernt bei Matrix_Ax_Ausgang

*

* Gerhard V0.4  17.10.08

*  AF und Shoot ergänzt

*

* Gerhard V0.5   22.10.08

*   Tasterabfrage ergänzt für Start von AF, Shoot und einem LED-Durchlauf

*

* Gerhard V0.6   01.11.08

*  Verzögerungen durch _delay_ms

*  increment-timer durch 16bit timer erzeugt

*  Flag für AF-delay eingeführt

*  Eingebundene Programme von MEGA8 auf USB162 angepasst

*    TIMSK1 satt TIMSK

*    TIMER1_COMPA_vect statt SIG_OUTPUT_COMPARE1A

* Gerhard V0.7   02.11.08

*  ISR (Interrupt Sevice Routine) anstatt veraltete Form "SIGNAL" verwendet

*  Reset des Counters bei Start (TCNT1=0)

*

* Gerhard V0.8  03.11.08

*    TCCR1B = (1<<CS11) | (1<<WGM12); statt  TCCR1B |= (1<<CS11) | (1<<WGM12);

 */

#define F_CPU  8000000UL

#include "avr\io.h"

#include <stdint.h>

#include <util/delay.h>    // definiert _delay_ms() 

#include <avr/interrupt.h>  // definiert increment_time

void delay_ms(uint16_t);

int main (void);

void Parameter_Init()

{

}

void PORT_Init()

{

  PORTB = 0b11110001; // set A1 to A5 to high (highside to LED-Anode)

                      // LEDx on, wenn Ax to output, 

            // LEDx off, if Ax to input

  DDRB =  0b00001110; // set A1 to A5 to input (means tristate and LEDx off)

  PORTC = 0b00000000; // set PC-port to low

            //AF und Shoot (PC7 and PC6=low)

  DDRC =  0b11000000; // set PC-port as input, except AF and Shoot

  PORTD = 0b01101111; // LED (PD4=low) and Kx (PD0-3,PD5-6=high) (means off)

            // PD7 no internal pull up for switch BUT)

  DDRD =  0b01111111;  // set LED (PD4) as output

                        // and Kx (PD0-3,PD5-6=high) as output (lowside to LED_Kathode)

            // PD7 as input for BUT

}

volatile  uint8_t time_number = 0;

volatile  uint8_t Low_LED_Matrix[30];

volatile  uint8_t High_LED_Matrix[30];

void Matrix_Init()

{

  uint8_t Matrix_Kx_high= 0b01101111;     //Low_Matrix_LEDx off and LED off

  uint8_t Matrix_K1_low = 0b01111110;     //PD0 an K1 direkt an Kathode LEDx

  uint8_t Matrix_K2_low = 0b01111101;     //PD1 an K2

  uint8_t Matrix_K3_low = 0b01111011;     //PD2 an K3

  uint8_t Matrix_K4_low = 0b01110111;     //PD3 an K4

  uint8_t Matrix_K5_low = 0b01011111;     //PD5 an K5

  uint8_t Matrix_K6_low = 0b00111111;     //PD6 an K6

  uint8_t Matrix_Ax_Eingang = 0b00000000; //High_Matrix_LEDs off

  uint8_t Matrix_A1_Ausgang = 0b00000001; //PB0 an A1 über Rx an Anode LEDx

  uint8_t Matrix_A2_Ausgang = 0b00010000; //PB4 an A2

  uint8_t Matrix_A3_Ausgang = 0b00100000; //PB5 an A3

  uint8_t Matrix_A4_Ausgang = 0b01000000; //PB6 an A4

  uint8_t Matrix_A5_Ausgang = 0b10000000; //PB7 an A5

  Low_LED_Matrix[0]  = Matrix_Kx_high;    // Kx auf high  (=low_Matrix off)

  High_LED_Matrix[0] = Matrix_Ax_Eingang; // set Ax to input (=high_matrix off

  Low_LED_Matrix[1]  = Matrix_K1_low;     // K1 auf low  (Matrix EIN)

  High_LED_Matrix[1] = Matrix_A1_Ausgang; // set A1 to output, rest to input

                            //   means tristate

  Low_LED_Matrix[2]  = Matrix_K1_low;

  High_LED_Matrix[2] = Matrix_A2_Ausgang;

  Low_LED_Matrix[3]  = Matrix_K1_low;

  High_LED_Matrix[3] = Matrix_A3_Ausgang;

  Low_LED_Matrix[4]  = Matrix_K1_low;

  High_LED_Matrix[4] = Matrix_A4_Ausgang;

  Low_LED_Matrix[5]  = Matrix_K1_low;

  High_LED_Matrix[5] = Matrix_A5_Ausgang;

  Low_LED_Matrix[6]  = Matrix_K2_low;    //K2 auf low  (Matrix EIN)

  High_LED_Matrix[6] = Matrix_A1_Ausgang;

  Low_LED_Matrix[7]  = Matrix_K2_low;

  High_LED_Matrix[7] = Matrix_A2_Ausgang;

  Low_LED_Matrix[8]  = Matrix_K2_low;

  High_LED_Matrix[8] = Matrix_A3_Ausgang;

  Low_LED_Matrix[9]  = Matrix_K2_low;

  High_LED_Matrix[9] = Matrix_A4_Ausgang;

  Low_LED_Matrix[10] = Matrix_K2_low;

  High_LED_Matrix[10]= Matrix_A5_Ausgang;

  Low_LED_Matrix[11]  = Matrix_K3_low;    //K3 auf low  (Matrix EIN)

  High_LED_Matrix[11] = Matrix_A1_Ausgang;

  Low_LED_Matrix[12]  = Matrix_K3_low;

  High_LED_Matrix[12] = Matrix_A2_Ausgang;

  Low_LED_Matrix[13]  = Matrix_K3_low;

  High_LED_Matrix[13] = Matrix_A3_Ausgang;

  Low_LED_Matrix[14]  = Matrix_K3_low;

  High_LED_Matrix[14] = Matrix_A4_Ausgang;

  Low_LED_Matrix[15]  = Matrix_K3_low;

  High_LED_Matrix[15] = Matrix_A5_Ausgang;

  Low_LED_Matrix[16]  = Matrix_K4_low;    //K4 auf low  (Matrix EIN)

  High_LED_Matrix[16] = Matrix_A1_Ausgang;

  Low_LED_Matrix[17]  = Matrix_K4_low;

  High_LED_Matrix[17] = Matrix_A2_Ausgang;

  Low_LED_Matrix[18]  = Matrix_K4_low;

  High_LED_Matrix[18] = Matrix_A3_Ausgang;

  Low_LED_Matrix[19]  = Matrix_K4_low;

  High_LED_Matrix[19] = Matrix_A4_Ausgang;

  Low_LED_Matrix[20]  = Matrix_K4_low;

  High_LED_Matrix[20] = Matrix_A5_Ausgang;

  Low_LED_Matrix[21]  = Matrix_K5_low;    //K5 auf low  (Matrix EIN)

  High_LED_Matrix[21] = Matrix_A1_Ausgang;

  Low_LED_Matrix[22]  = Matrix_K5_low;

  High_LED_Matrix[22] = Matrix_A2_Ausgang;

  Low_LED_Matrix[23]  = Matrix_K5_low;

  High_LED_Matrix[23] = Matrix_A3_Ausgang;

  Low_LED_Matrix[24]  = Matrix_K5_low;

  High_LED_Matrix[24] = Matrix_A4_Ausgang;

  Low_LED_Matrix[25]  = Matrix_K5_low;

  High_LED_Matrix[25] = Matrix_A5_Ausgang;

  Low_LED_Matrix[26]  = Matrix_K6_low;    //K6 auf low  (Matrix EIN)

  High_LED_Matrix[26] = Matrix_A1_Ausgang;

  Low_LED_Matrix[27]  = Matrix_K6_low;

  High_LED_Matrix[27] = Matrix_A2_Ausgang;

  Low_LED_Matrix[28]  = Matrix_K6_low;

  High_LED_Matrix[28] = Matrix_A3_Ausgang;

  Low_LED_Matrix[29]  = Matrix_K6_low;

  High_LED_Matrix[29] = Matrix_A4_Ausgang;

  Low_LED_Matrix[30]  = Matrix_K6_low;

  High_LED_Matrix[30] = Matrix_A5_Ausgang;

}

/**

  @brief  Wird vom 16 Bit Timer ausgelöst, wenn dieser den Vergleichwert erreicht

      Wird in TIC fuer incremental_value verwendet (Gerhard)

  @param  none

  @return  none

*/

ISR (TIMER1_COMPA_vect) //ISR (TIMER1_COMPA_vect) statt (SIGNAL) SIG_OUTPUT_COMPARE1A

{

  /*  time_number stellt den Zeitzeiger von 1 bis 29 dar. 

    Die Incremental_value wird durch den 16bit-counter1 erzeugt

  */

  // bisherige LEDx der Bargraphanzeige wieder ausschalten

  PORTD = PORTD | ~Low_LED_Matrix[time_number];

  DDRB = DDRB & ~High_LED_Matrix[time_number];

  time_number++;   // nächste LEDx der Bargraphanzeige auswählen

  // naechste LEDx der Bargraphanzeige einschalten

  PORTD = PORTD & Low_LED_Matrix[time_number];

  DDRB = DDRB | High_LED_Matrix[time_number];

}

// wartet ms Millisekunden

void delay_ms (uint16_t ms)

{

  uint16_t t;

  for( t=0; t<=ms; t++)

    _delay_ms(1); 

}

int main(void)

{  

  PORT_Init();

  Parameter_Init();

  Matrix_Init();

  uint16_t increment_value = 3000;  // Wert kann 1 bis 60000 sein

                    // entspricht 1 - 60000µs, wenn Teiler auf 8

  uint16_t AF_delay_time = 1000;    // in ms

  uint8_t AF_delay = 0;        // 0 ist keine AF-Verzögerung

  uint8_t time_number_max = 29;    // max. Anzahl der LEDs

  asm("WDR");            //Watchdog Timer Reset

  MCUSR= ~(1<<WDRF);

  WDTCSR = (1<<WDCE) | (1<<WDE);

  WDTCSR = 0x00;

  WDTCKD = 0x00;

  while (1)

  {

  PORT_Init();

// AF_Verzögerung toogeln

//    AF_delay ^= (1<<0);

//LED an PD4 einschalten

    PORTD = PORTD | 0b00010000; //LED auf high (EIN)

//Für Entprellung. Taster muß mal losgelassen worden sein (BUT an PD7 nicht gedrückt)

    while (!(PIND & (1<<PD7)) )  // solange Taster gedrückt

    {

    }

//Tasterabfrage für Start (BUT an PD7 gedrückt=low)

    while (PIND & (1<<PD7) )  // solange Taster nicht gedrückt

    {

    }

    // Taster wird gedrückt

    PORTD = PORTD & 0b11101111; //LED auf low (aus)

//AF an PC7

    PORTC = PORTC | 0b10000000; //AF auf high (EIN)

    if (AF_delay != 0)

    {  delay_ms(AF_delay_time);  //AF um AF_delay_time ms verzögert

    }

//Shoot an PC6

    PORTC = PORTC | 0b01000000; //Shoot auf high (EIN)

// Init 16 bit Counter und Freigabe timerinterrupt

  OCR1A = (uint16_t)(increment_value);// Vergleichwert mit increment_value laden: 

                      // Takt= 8MHz/8

  TIMSK1 |= (1<<OCIE1A);           // Interrupt wenn Timer Vergleichswert erreicht

  TCNT1=0;              // Timer1 zurücksetzen

  TCCR1B = 0;    //zusätzlich TCCR1B reseten

  TCCR1B |= (1<<CS11) | (1<<WGM12);  // Timer1 mit Div 8 starten (CS11) und Clear Counter on Compare Match

  sei();                // IRQ Behandlung ein

// init time_number

  time_number = 1;

  // LED1 der Bargraphanzeige einschalten

  PORTD = PORTD & Low_LED_Matrix[time_number];

  DDRB = DDRB | High_LED_Matrix[time_number];

// solange warten, bis alle LEDs durchlaufen sind und counter und interrupt stoppen

  while (time_number <= time_number_max);

  cli();    //Interrupt löschen

  PORTC = PORTC & 0b01111111; //AF auf low (aus)

  PORTC = PORTC & 0b10111111; //Shoot auf low (aus)

// Bargraphanzeige ausschalten

  time_number = 0;

  PORTD = PORTD & Low_LED_Matrix[time_number];

  DDRB = DDRB | High_LED_Matrix[time_number];

  }

  return 0;

}