µController programmierung

[Medi (Gast)]

Hallo Community,

ich versuche erste Schritte mit den XMEGA8E5 zu machen leider komme ich 
an einer Stelle nicht weiter und brauche eure Hilfe bzw. Rat dazu:

Zum Problem:

Wenn in die Funktion "laden_USB" gesprungen wird dann werden die Tasten 
nicht mehr bzw. nicht mehr schnell genug ausgewertet das äußert sich so 
dass ich die Tasten mehrmals drücken muss dann gehen die LEDs irgendwann 
an und dann sofort aus.

Als würde aus der Funktion "laden_USB" kurz in die Funktion 
"tasten_abfrage" gesprungen werden und dann wieder zurück in die 
"laden_USB".

Was kann ich tun damit die Tasten immer abgefragt werden und 
vorallendingen das dann auch die Anweisung ausgeführt wird.


Hier ist der Quellcode:

Hoffe man kann verstehen was ich meine.....

#include <avr/io.h>
#include <avr/interrupt.h>
#define F_CPU 8000000UL
#include <util/delay.h>



void clock_init (void)
{
  OSC.CTRL |= OSC_RC8MEN_bm; //Oszillator auf 8 Mhz einstellen
  while(!(OSC.STATUS & OSC_RC8MRDY_bm)); //Warten bis der Oszillator bereit ist
  CCP = CCP_IOREG_gc; //Schützt I/O Register, Interrupts werden ignoriert
  CLK.CTRL = (CLK.CTRL &~ CLK_SCLKSEL_gm) | CLK_SCLKSEL_RC8M_gc; //aktiviert den internen Oszillator
}



void port_init (void)
{
  /*Charge_Voltage*/
  PORTA.DIR &= ~PIN1_bm; //PORTA.1 als Eingang definiert (0,93V-1,4V)
  
  /*Charge_Current*/
  PORTA.DIR &= ~PIN0_bm; //PORTA.0 als Eingang definiert (1.5V = 1.2A)
  
  /*Reedkontakt init*/
  PORTC.DIR &= ~PIN5_bm; //PORTC.5 auf Eingang Reedkontakt
  PORTC.PIN5CTRL |= PORT_OPC_PULLUP_gc; //Pull-Up Widerstand am PORTC.5 aktiv (Reedkontakt)
  
  /*LEDs init*/
  PORTC.DIR = 0x1C;      //PORTC auf Ausgang LEDs
  /*PORTC.OUT &= ~ PIN3_bm; //PORTC.3 auf high WW-LEDs->aus*/
  /*PORTC.OUT &= ~ PIN2_bm; //PORTC.2 auf high KW-LEDs->aus*/  
  
  /*System ON/OFF*/
  PORTC.DIR |= PIN1_bm; //PORTC.1 auf Ausgang ON/OFF
  PORTC.OUT &= ~PIN1_bm; //PORTC.1 auf low
  
  /*Status LED Init*/
  PORTD.DIR |= PIN6_bm; //LED Grün Ausgang
  //PORTD.OUT |= PIN6_bm;
  
  PORTD.DIR |= PIN7_bm; //LED Rot Ausgang
  PORTD.OUT |= PIN7_bm;  
  
  PORTR.DIR |= PIN0_bm; //LED Blau Ausgang
  PORTR.OUT |= PIN0_bm;
  
  /*Charger Fault*/
  PORTD.DIR &= ~PIN5_bm; //PORTD.5 als Eingang definiert
  
  /*DC-Power OK*/
  PORTD.DIR &= ~PIN4_bm; //PORTD.4 als Eingang definiert
  
  /*Charger ON/OFF*/
  PORTD.DIR |= PIN3_bm;
  PORTD.OUT &= ~ PIN3_bm; //Laden an
  //PORTD.OUT |=  PIN3_bm; //Laden aus
  
  /*Charger Indikator*/
  PORTD.DIR &= ~PIN2_bm; //PORTD.2 als Eingang definiert
  
  /*USB-Power OK*/
  PORTD.DIR &= ~PIN1_bm; //PORTD.1 als Eingang definiert
  
  /*Taster Init*/
  PORTA.DIR &= ~PIN7_bm; //PORTA7 als Eingang definieren (Taster POL)
  PORTA.PIN7CTRL |= PORT_OPC_PULLUP_gc; //Pull-Up Widerstand am PORTA7 aktiv (Taster POL)
  
  PORTA.DIR &= ~PIN6_bm; //PORTA6 als Eingang definieren (Taster UV) 
  PORTA.PIN6CTRL |= PORT_OPC_PULLUP_gc; //Pull-Up Widerstand am PORTA6 aktiv (Taster UV)  
  
  /*PORTA.DIR &= ~PIN5_bm; //PORTA5 als Eingang definieren (Taster Reserved)*/
  /*PORTA.PIN5CTRL |= PORT_OPC_PULLDOWN_gc; //Pull-Up Widerstand am PORTA7 aktiv (Taster3)*/
}



void interrupt_init (void)
{
  PMIC.CTRL |= PMIC_LOLVLEN_bm; //Interrupt eingeschaltet
  sei(); //Interrupt freischalten
}



void timer4_init (void)
{
  TCC4.CTRLA = TC45_CLKSEL_DIV256_gc; //Vorteiler auf 8 eingestellt
  TCC4.CTRLB = TC45_WGMODE_NORMAL_gc; //Timer auf normal Mode (hochzählend) eingestellt
  TCC4.PER = 5000; //Timer vorladen 5000 überlauf nach 160 ms
  TCC4.INTCTRLA = TC45_OVFINTLVL_LO_gc; //Interrupt Modus aktiv
  TCC4.INTFLAGS = TC4_OVFIF_bm;
}



void tasten_abfrage (void)
{
  static uint8_t tasterwert_vorher = 1, tasterwert1_vorher = 1, tasterwert_jetzt = 0, tasterwert1_jetzt = 0, anzahl = 0, anzahl1 = 0;    
  
    tasterwert_jetzt = PORTA.IN & PIN7_bm; //aktueller Tasterwert POL wird eingelesen  
    tasterwert1_jetzt = PORTA.IN & PIN6_bm; //aktueller Tasterwert UV wird eingelesen
    _delay_ms(20);
    
    if(tasterwert1_jetzt != tasterwert1_vorher) //gibt es einen Unterschied?
    {
      if(tasterwert1_jetzt == 0)
      {
        anzahl1++;
      }
    
      switch (anzahl)
      {
        case 1:  PORTC.OUT = 0x10; //Taste UV 1 mal gedrückt -> UV an
            PORTC.OUTCLR = 0x0C; //POL-Beleuchtung aus
            PORTR.OUTCLR = PIN0_bm; //Status-LED blau an
            PORTD.OUTSET = PIN6_bm;  //Status-LED grün aus
            break;
            
            default: anzahl1 = 1;
      }    
    }
    tasterwert1_vorher=tasterwert1_jetzt; //aktuellen Tasterwert merken und wieder vergleichen    
      
      
      
      if(tasterwert_jetzt != tasterwert_vorher)  //gibt es einen Unterschied?  
      {
        if(tasterwert_jetzt == 0)  
        {
          anzahl++;
        }
      
        switch (anzahl)
        {
          case 1: PORTC.OUT = 0x0C; //Taste POL 1 mal gedrückt -> POL an
              PORTC.OUTCLR = 0x10; //UV-Beleuchtung aus
              PORTD.OUTCLR = PIN6_bm; //Status-LED grün an
              PORTR.OUTSET = PIN0_bm;  //Status-LED blau aus             
              break;  
                            
              default: anzahl = 1;
        }
      }
        tasterwert_vorher=tasterwert_jetzt; //aktuellen Tasterwert merken und wieder vergleichen     
}




void laden_DC (void)
{  
  if((PORTC.IN & PIN5_bm) && (!(PORTD.IN & PIN4_bm)) && (!(PORTD.IN & PIN2_bm))) //Reedkontakt OK (high) & DC-PWR OK (low) & Charge Indicator (low)
  {
    PORTD.OUTSET = PIN7_bm; //Rote Status LED aus
    
    PORTC.OUTCLR = 0x1C; //Beleuchtung aus
    PORTR.OUTSET = PIN0_bm;  //Status-LED blau aus
    
    _delay_ms(250);
    PORTD.OUTTGL = 0x40; //grüne Status LED toggeln
  }
    else
    {
      if((PORTD.IN & PIN2_bm) && (PORTC.IN & PIN5_bm) && (!(PORTD.IN & PIN4_bm))) //Charge Indicator (high) & Reedkontakt OK (high) & DC-PWR OK (low)
      {
        PORTC.OUTCLR = 0x1C; //Beleuchtung aus
        PORTD.OUT &= ~ PIN6_bm; //grüne Status LED an
      }
  
      /*#################### Netzteilabfrage ########################*/
      /*else
      {
        if((PORTD.IN & PIN4_bm) && (PORTC.IN & PIN5_bm)) //Charge Indicator (low) & Reedkontakt OK (high)
        {
          PORTC.OUTCLR = 0x1C; //Beleuchtung aus
          PORTD.OUTSET =  PIN6_bm; //grüne Status LED aus
          PORTD.OUT &=  ~PIN7_bm; //rote Status LED an
        }
      }*/
    }
}




void laden_USB (void)
{
  if(!(PORTD.IN & PIN1_bm) && (!(PORTD.IN & PIN2_bm))) //USB-Power OK (low) & Charge_Indicator (low)
  {
    PORTC.OUTCLR = 0x1C; //Beleuchtung aus
    PORTR.OUTSET = PIN0_bm;  //Status-LED blau aus
    _delay_ms(500);
    PORTD.OUTTGL = 0x40; //Status-LED grün toggeln
  }
  else
  {
    if((!(PORTD.IN & PIN1_bm)) && (PORTD.IN & PIN2_bm)) //USB-Power OK (low) & Charge_Indicator (high)
    {
      PORTD.OUTCLR = PIN6_bm; //Status-LED grün an
    }
  }
}


void start_init (void)
{
  PORTC.OUT &= ~ PIN4_bm; //PORTC.4 auf low UV-LEDs->aus  
  PORTC.OUT |= PIN3_bm; //PORTC.3 auf high WW-LEDs->an 100%
  PORTC.OUT |= PIN2_bm; //PORTC.2 auf high KW-LEDs->an 100%
  PORTD.OUT &= ~ PIN6_bm; //PORTD.6 low -> Status-LED grün-> an  
}

int main(void)
{    
  clock_init ();
  port_init();
  timer4_init();
  interrupt_init();  
  start_init();
  
  while(1)
    {    
    tasten_abfrage();
    laden_USB(); 
  }
}

/*##################Timer-Interrupt############################*/
ISR(TCC4_OVF_vect)
{
  TCC4.INTFLAGS = TC4_OVFIF_bm;  
  laden_DC();
}

[Route_66 H. (route_66)]

Hallo!
wenn Du in der     laden_USB(); ein

    _delay_ms(500);

machst, wunderst Du Dich über Verzögerungen?

[Blinky (Gast)]

Hallo,

Mit diesem Befehl "_delay_ms(500);" wartet der Controller in der 
"laden_USB" Funktion 500ms lang. Danach darf er mal kurz die Tastatur 
abfragen mit "tasten_abfrage()" in der Hauptschleife um danach wieder 
500ms zu warten.

Besser wäre das ganze über einen Timer Interrupt zu lösen der z.B. Nach 
Ablauf von Zählern ein bestimmtes Statusflag setzt das dann in der 
Hauptschleife die einzelnen Aktionen steuert (Stichwort State Engine).

[Medi (Gast)]

Blinky schrieb:
> Hallo,
>
> Mit diesem Befehl "_delay_ms(500);" wartet der Controller in der
> "laden_USB" Funktion 500ms lang. Danach darf er mal kurz die Tastatur
> abfragen mit "tasten_abfrage()" in der Hauptschleife um danach wieder
> 500ms zu warten.
>
> Besser wäre das ganze über einen Timer Interrupt zu lösen der z.B. Nach
> Ablauf von Zählern ein bestimmtes Statusflag setzt das dann in der
> Hauptschleife die einzelnen Aktionen steuert (Stichwort State Engine).

ah okay das warten über delay macht das Problem.

Timer-Interrupt habe ich auch schon drinne allerdings verarbeite ich 
dort die Funktion "laden_DC()";

Wie meinst du das mit dem Statusflag kannst du vllt ein Beispiel machen 
wie man das bei mir umsetzen könnte?

[Little B. (lil-b)]

als beispiel:

uint8_t TimerInterruptCounter = 0;

int main(void)
{    
  clock_init ();
  port_init();
  timer4_init();
  interrupt_init();  
  start_init();
  
  while(1)
    {    
    tasten_abfrage();
    if (TimerInterruptCounter >= 3) {
        laden_USB();
        TimerInterruptCounter = 0;
    }
  }
}

/*##################Timer-Interrupt############################*/
ISR(TCC4_OVF_vect)
{
  TCC4.INTFLAGS = TC4_OVFIF_bm;  
  laden_DC();
  TimerInterruptCounter++;
}

dann natürlich die delay500ms rausnehmen.

Timer Interrupt passiert alle 160ms
160msx3 = 480ms
kommt ungefähr hin...

[Route_66 H. (route_66)]

Little Basdart schrieb:
> Timer Interrupt passiert alle 160ms

...und dort wird gegebenenfalls wiederum 250 ms sinnlos gewartet, weil 
laden_DC() aufgerufen wird.

[Medi (Gast)]

Little Basdart schrieb:
> als beispiel:
> uint8_t TimerInterruptCounter = 0;
>
> int main(void)
> {
>   clock_init ();
>   port_init();
>   timer4_init();
>   interrupt_init();
>   start_init();
>
>   while(1)
>     {
>     tasten_abfrage();
>     if (TimerInterruptCounter >= 3) {
>         laden_USB();
>         TimerInterruptCounter = 0;
>     }
>   }
> }
>
> /*##################Timer-Interrupt############################*/
> ISR(TCC4_OVF_vect)
> {
>   TCC4.INTFLAGS = TC4_OVFIF_bm;
>   laden_DC();
>   TimerInterruptCounter++;
> }
>
> dann natürlich die delay500ms rausnehmen.
>
> Timer Interrupt passiert alle 160ms
> 160msx3 = 480ms
> kommt ungefähr hin...

habe das bei mir geändert-> Tastenerkennung geht jetzt gut aber es wird 
immer wieder aus der Tastenabfrage rausgesprungen d.h die LEDs gehen 
kurz an und dann wieder aus...

z.B. wird das

 switch (anzahl)
      {
        case 1:  PORTC.OUT = 0x10; //Taste UV 1 mal gedrückt -> UV an
            PORTC.OUTCLR = 0x0C; //POL-Beleuchtung aus
            PORTR.OUTCLR = PIN0_bm; //Status-LED blau an
            PORTD.OUTSET = PIN6_bm;  //Status-LED grün aus
            break;
            
            default: anzahl1 = 1;
      }

aus der Funktion tasten_abfrage kurz ausgeführt und dann wieder das

if(!(PORTD.IN & PIN1_bm) && (!(PORTD.IN & PIN2_bm))) //USB-Power OK (low) & Charge_Indicator (low)
  {
    PORTC.OUTCLR = 0x1C; //Beleuchtung aus
    PORTR.OUTSET = PIN0_bm;  //Status-LED blau aus
    //_delay_ms(500);
    PORTD.OUTTGL = 0x40; //Status-LED grün toggeln
  }

aus der Funktion laden_USB

wie kann ich es so programieren, dass wenn die taste gedrückt wird wenn 
man sich schon in der Funktion laden_USB befindet in die tasten_abfrage 
Funktion gesprungen wird und dort verharrt?

[Fritz G. (fritzg)]

Medi schrieb:
> tasterwert1_vorher=tasterwert1_jetzt; //aktuellen Tasterwert merken
> tasterwert_vorher=tasterwert_jetzt; //aktuellen Tasterwert


Du weisst, dass diese zwei Zuweisungen bei jeden Aufruf gemacht werden, 
unabhängig davon, wie der Zustand ist?

[Medi (Gast)]

Fritz Ganter schrieb:
> Medi schrieb:
>> tasterwert1_vorher=tasterwert1_jetzt; //aktuellen Tasterwert merken
>> tasterwert_vorher=tasterwert_jetzt; //aktuellen Tasterwert
>
> Du weisst, dass diese zwei Zuweisungen bei jeden Aufruf gemacht werden,
> unabhängig davon, wie der Zustand ist?

stimmt du hast Recht die zwei Taster werden immer abgefragt was auch 
okay ist nur möchte ich das in zwei verschiedenen Fällen das selbe 
ausgeführt wird d.h wenn mann sich in der Funktion "laden_USB" befindet 
die man erreicht wenn die if-bedingung wahr ist. Wenn dann auch noch ein 
Tastendruck erkannt wird soll jenachdem welche taste erkannt wurde das 
ausgeführt werden was in der Funktion "taster_abfrage" steht

wie gehe ich in meinem Fall vor ?

folgende Überlegung habe ich gemacht

es gibt eine Funktion "start_init" diese soll als erste ausgeführt 
werden wenn der controller gestartet wird, dort sind alle dafault werte 
für z.B. Status-LED und die LED-Beleuchtung hinterlegt.

Im Timerinterrupt werden die Tasten abgefragt und jenachdem ob Taster an 
PORTA.6 oder PORTA.7 gedrückt wurde wird die LED-Beleuchtung 
umgeschaltet und die Status-LED (ist eine separate led) hat eine andere 
Farbe/Zustand.


dann kommen noch andere Fuktionen dazu wie z.b das Laden über USB wo der 
Ladevorgang gestartet wird und ein Status über die Farbe der Status-LED 
angezeigt wird.

wird jetzt aber beim Laden eine der Tasten wieder gedrückt soll dann der 
ladevorgang weiterlaufen aber zusätzlich die LED-Beleuchtung angehen 
etc. sprich wieder Funktion "taster_abfragen" ausgeführt werden



wahrscheinlich muss ich dann mit Flags arbeiten die jeden Zustand 
erfassen und jenachdem eine Aktion ausführen. Kriege das aber irgendwie 
nicht auf die Reihe in meinem Quellcode es kommt immer was dazwischen 
oder es wird nur kurz ausgeführt....


wäre schön wenn einer ein Beispiel in Bezug zu meinem Quellcode machen 
könnte.  komme selber nicht weiter :-(

[Medi (Gast)]

Kann keiner einen Rat geben wie ich die Zustände zwischenspeichern kann, 
damit ich immer auf die Ereignisse reagieren kann?

[Peter D. (peda)]

Die Tastenentprellung und Flankenerkenung macht man am besten komplett 
im Timerinterrupt und das Main holt sich die Events ab, wenn es ihm 
paßt.

Die Abläufe in der Mainloop macht man dann mit State-Machines.

[Medi (Gast)]

Peter Dannegger schrieb:
> Die Tastenentprellung und Flankenerkenung macht man am besten
> komplett im Timerinterrupt und das Main holt sich die Events ab, wenn es
> ihm paßt.
>
> Die Abläufe in der Mainloop macht man dann mit State-Machines.

Okay so habe ich mir das gedacht mit der Interruptabfrage der Taster 
bekomme ich denke hin. Aber mit der State-machines ist mir das Prinzip 
nicht klar obwohl ich den artikel hier schon drüber gelesen habe kannst 
du vllt ein Beispiel an Hand meines quellcodes zeigen, wäre echt super

[Peter D. (peda)]

Medi schrieb:
> kannst
> du vllt ein Beispiel an Hand meines quellcodes zeigen, wäre echt super

Dazu müßte man ja erstmal wissen, was das Programm machen soll.
Bevor man mit dem Programmieren anfangen kann, benötigt man zuerst mal 
eine vollständige Funktionsbeschreibung (Text, Zeichnung).

Allgemein:
https://www.mikrocontroller.net/articles/Statemachine