UART + Tasterabfrage vertragen sich nicht

[Peter (Gast)]

Hallo zusammen,

ich habe Programm geschrieben, dass 2 Taster einliest (Berücksichtigt 
ist das Pollen des Tasters)

Neben dem Einlesen des Tasters kommen anfragen (interruptgesteuert) üben 
den(?) UART. Bei einer bestimmten Bitfolge im Protokoll, soll das 
Program sich ändernde Tasterzustände übermitteln.

Auf Variablen mit volatile wurde geachtet.

Die Tasterabfrage funktioniert grundsätzlich. Allerdings kommt es 
mitunter vor, dass Zustandswechel nicht erkannt werden. Ich habe nun 
nochmal verschiedene Artikel über Interruots gelesen, um herauszufinden 
ob es Variablenprobleme gibt. Ich weiss, dass es Probleme geben kann, 
wenn der der C-Code in Assembler mehrere Befehle nach sich zieht. 
Allerdings habe ich deswegen um die Tasterabfrage die Interrupts 
ausgeschaltet.

Oder sehe ich vielleicht ein anderes Problem vor lauter Versteifung auf 
die Interrupts nicht?

Vielleicht könnt ihr mir helfen

//Für Variablen, die in beiden Modulen verwendet werden müsse
//Globale Variablen
volatile char uart_str_complete = 0;                     // 1 .. String komplett empfangen
volatile char uart_str_count = 0;
volatile char uart_string[20] = "";

char eingang1_flag = 0x01;          //Positiv oder Negativ
char eingang2_flag = 0x01;          //Als erstes Positiv
char eingang3_flag = 0x01;
char eingang4_flag = 0x01;



ISR(USART_RXC_vect)
{
  unsigned char nextChar;
  // Daten aus dem Puffer lesen
  nextChar = UDR;
  if( uart_str_complete == 0 ) {  // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen
 
    // Daten werden erst in string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
    if( //nextChar != '!' &&
        //nextChar != '\r' &&
    (nextChar != 0xFF) &&  (uart_str_count < 20 - 1 )) {
      uart_string[uart_str_count] = nextChar;
      uart_str_count++;
    }
    else {
      uart_string[uart_str_count] = '\0';
      uart_str_count = 0;
      uart_str_complete = 1;
    }
  }
}



und dann das Hauptprogramm:

  FOREVER_START
  //Tasten einlesen
  count++;
  cli();
  checkIncome();
  sei();
  if (uart_str_complete ==1) {
  
      if (uart_string[byte_start] == '#') {
        
        if (checkToken(uart_string) == 1) 
        {
          
          if (checkSum(uart_string) == 1)
          {
            writePort(uart_string);
            writeBack(answer_as_slave);
            //matrix_eingaenge = 0;        //löscht Informationen intern, weil schon verschickt wurde
            IchWarDavor = 1;
          }
          else {
            writeBack(answer_wrong_checksum);
          }
        }
        else if ((IchWarDavor == 1) && (checkToken != 1))
        {
          matrix_eingaenge = 0; IchWarDavor = 0;
        }
      }
      else {
        //uart_puts("Fehler");
        }
      
      
      uart_str_complete = 0;

      
  }
  FOREVER_END




und die EINLESEROUTINE

void checkIncome ()
{
  //Taster 1
  if (eingang1_flag == 0x01){                //positive Flanke
    if ((PIND & (1<<eingang1))&&((count % 20) == 0)){
      //PORTD ^= (1<<ausgang2);
      matrix_eingaenge ^= 0x01;            //sorgt dafür dass es umgesetzt wird
      eingang1_flag ^= 0x01;
    }
  }
  else {                          //negative Flanke
    if (!(PIND & (1<<eingang1))&&((count % 20) == 0)){
      //PORTD ^= (1<<ausgang2);
      matrix_eingaenge ^= 0x01;
      eingang1_flag ^= 0x01;
    }
  }
  //Taster 2
  if (eingang2_flag == 0x01){                //positive Flanke
    if ((PIND & (1<<eingang2))&&((count % 20) == 0)){
      //PORTD ^= (1<<ausgang3);
      matrix_eingaenge ^= 0x02;            //sorgt dafür dass es umgesetzt wird
      eingang2_flag ^= 0x01;
      
    }
  }
  else {                          //negative Flanke
    if (!(PIND & (1<<eingang2))&&((count % 20) == 0)){
      //PORTD ^= (1<<ausgang3);
      matrix_eingaenge ^= 0x02;
      eingang2_flag ^= 0x01;
    }
  }
  //Taster 3
  if (eingang3_flag == 0x01){                //positive Flanke
    if ((PIND & (1<<eingang3))&&((count % 20) == 0)){
      //PORTD ^= (1<<ausgang3);
      matrix_eingaenge ^= 0x04;            //sorgt dafür dass es umgesetzt wird
      eingang3_flag ^= 0x01;
    ;
    }
  }
  else {                          //negative Flanke
    if (!(PIND & (1<<eingang3))&&((count % 20) == 0)){
      //PORTD ^= (1<<ausgang3);
      matrix_eingaenge ^= 0x04;
      eingang3_flag ^= 0x01;
    }
  }

[Peter II (Gast)]

 if (eingang1_flag == 0x01){                //positive Flanke
    if ((PIND & (1<<eingang1))&&((count % 20) == 0)){
      //PORTD ^= (1<<ausgang2);
      matrix_eingaenge ^= 0x01;            //sorgt dafür dass es umgesetzt wird
      eingang1_flag ^= 0x01;
    }
  }
  else {                          //negative Flanke
    if (!(PIND & (1<<eingang1))&&((count % 20) == 0)){
      //PORTD ^= (1<<ausgang2);
      matrix_eingaenge ^= 0x01;
      eingang1_flag ^= 0x01;
    }
  }

das sieht mir extrem umständlich aus.

wenn bei dir (count % 20) == 0 ist, dann wird auch bei einer erkannte 
Flanke die variable eingang1_flag nicht mit angepasst. Das führt dazu, 
das eingang1_flag nicht mehr synchron zur echten flanke ist.

So etwas solle man einfach setzen und nicht per xor.

(bin mir nicht 100%sicher - der code ist nicht schön zu lesen).

[Peter II (Gast)]

Nachtrag:

ich würde es in der Art machen:

uint8_t tmp = (PIND & (1<<eingang1);
if ( eingang1_flag != tmp ) {
   eingang1_flag = tmp;
   // optional abfrage ob positive oder negative flanke
   // if ( tmp ) 
   matrix_eingaenge ^= 0x01; 
}

[Peter (Gast)]

Hallo,

schonmal Danke für den Hilfeversuch, leider konnte der Tip das Problem 
nicht lösen, weiterhin zufällige Wechsel :(. Ich habe zusätzlich nun die 
count-Variable mit innerhalb der Interruptfreien Befehle gesetzt. 
Allerdings führt das auch zu keinem Ergebnis.

Gibt es weitere Ideen?

Gruss Peter

[Peter II (Gast)]

Peter schrieb:
> Gibt es weitere Ideen?

zeig mal den geänderten code.

[Peter (Gast)]

Hier ist der veränderte Code, habe dann zusätzlich nochmal geguckt, ob 
es vielleicht an dem Pollen liegen kann, daher den auskommentierte Teil.

Hinweis, aus Schaltungsgründen musste ich den Eingang2 verwenden

  /*
  if ((count % 50)==0){
    temp = (PIND & (1<<eingang2));
  }
  */
  uint8_t temp = 0;
  temp = (PIND & (1<<eingang2));

  if (eingang2_flag != temp){
    eingang2_flag = temp;
    matrix_eingaenge ^= 0x02;
    temp = 0;
  }

[Peter II (Gast)]

dann versuche bitte noch mal genau zu beschreiben was nicht geht? 
Regiert der Taster zu oft oder gar nicht?

[Peter (Gast)]

Das Drücken oder loslassen des Tasters wird grundsätzlich erkannt. Und 
es wird der Zustandswechsel auch korrekt über uart an den Rechner 
geschickt. Dieser schtickt die Anfrage mit einer Baudrate von 19200 etwa 
alle 20ms.

Das Problem ist:
Nicht jeder ZustandsWechsel (Drücken oder loslassen) wird erkannt und 
entsprechend über den Bus verschickt.

[Peter D. (peda)]

Compilierbarer Code als Dateianhang.
Schaltplan ist auch sinnvoll.

Wir sind schließlich keine Hellseher.