Atmega32 RS232 Probleme mit Register

[Jakob (Gast)]

Hallo, nach langen Versuchen möchte ich hierum Hilfe bitten.
Es geht da drum zu erkennen ob der RS485 Bus noch Daten sendet, in 
dieesm Fall ob dieser angeschlossen ist oder nicht.

Der 485 Bus wird für'n Atmega in 232 umgewandelt

Von einen externen Gerät bekomme ich in Sekunden Takt ein Zeichen an 
meinen Atmega32 mit LC-Display gesendet :
71,79,82
Was das alles auf sich hat ist unwichtig. Das System funktioniert. Wenn 
ich den Bus angeschlossen habe gibt der Atmega immer das richtige aus.
Nun möchte ich das dieser erkennt ,dass wenn 2 Sek kein Zeichen kommt 
ein Fehler ausgibt. Die funktioniert bislang nur wenn ich den Atmega 
Resete und den Bus nicht angeschlossen habe. Schließe ich nun den Bus an 
springt er sofort auf die jeweilige Anzeige. Ziehe ich diesen wieder ab, 
erkennt der Atmega aber trotzdem das letzte Zeichen und springt in die 
dazu gehörige Routine.
Durch das Debuggen hab ich raus gefunden ,dass  troz nicht anliegen Bus 
das RXC Bit im UCSRA gesetzt ist und deshalb nicht in meine Routine 
springt die nach 2 Sek anzeigen soll das nichts anliegt. Kann ich dieses 
Bit "clearen" oder etc ? Damit er erkennt das nichts anliegt oder 
übersehe ich etwas offensichtliches ?

Er springt also in :

if (UCSRA & (1<<RXC))
  {  
  Zeichen=uart_getchar();  //Empfängt Zeichen am UART Eingang und überträgt dieses an die Variable Zeichen
  }

obwohl der Bus abgezogen wurde.(Immo. mit Steckverbinder)

Hier mal der Code , Code wird noch aufgeräumter (bitte keine Kommentare 
zum printf Befehl =) )

//_________________Main____________________
ISR(TIMER1_COMPA_vect)  //Timer1 Routine
{
  PORTA ^= 0x20;  //Dieser Pin wird durch die Exklusiv Oder Verknüpfung getoggelt
}

ISR(TIMER0_COMP_vect)
{
  mS++;
  if (mS==1000)
  {
    Sek++;
    mS=0;
  }  
}

int main(void)
{
  DDRA = 0b00100000; //Deklaration 11110000 1=Ausgang 0=Eingang  // X1-4a bis 7c
  DDRB = 0xFF; 
  DDRC = 0xFF;
  DDRD = 0xFF;  

  init_uart(207);            //RS232 Initialisierung 4800Baud = 207    
  
  InitialisierungDisplay();  
  DisplayAnD();           // Display An und Course Blinkt nicht
  
   
  start_timer1(23);        // Timer zur Frequenz erzeugung startetn. In den Klammern wird angegeben welche Frequenz man möchte 1Hz-106kHz !
  
  char Zeichen;              
  int Startclock=0;
    
  while(1){  
    
    
    
  if (UCSRA & (1<<RXC))
  {  
  Zeichen=uart_getchar();  //Empfängt Zeichen am UART Eingang und überträgt dieses an die Variable Zeichen
  }  
  
  else
  {
    Startclock++;
    if (Startclock==1)
    {
      start_timer0(2);
    }
    if (Sek==2)
    {
      LCD_xy(0,1);
      printf("---FBE-System---");
      LCD_xy(0,2);
      printf("EEEEEEEEEEEEE");
    }
  }
  
  switch (Zeichen)
  {
  case 79: //  O in Ascii = 79. Die Zeichen werden in Ascii übermittelt
  LCD_xy(0,1);
  printf("---FBE-System---");
  LCD_xy(0,2);
  printf("Signalausfall!!!");  
  Startclock=0;
  Sek=0;
  mS=0;
  
  
  break;
  
  
  case 71: //  G in Ascii = 71. Die Zeichen werden in Ascii übermittelt
  LCD_xy(0,1);
  printf("---FBE-System---");
  LCD_xy(0,2);
  printf("Frequenz im Band");  
  Startclock=0;
  Sek=0;
  mS=0;
  break;
  
  
  case 82:  //  R in Ascii = 82. Die Zeichen werden in Ascii übermittelt
  LCD_xy(0,1);
  printf("---FBE-System---");
  LCD_xy(0,2);
  printf("Freq. ausserhalb");  
  Startclock=0;
  Sek=0;
  mS=0;
  break;
  } //switch(zeichen)
  

    
  }//while(1)
}//Main

//_______________________Routinen________

unsigned char uart_getchar (void)
{    
    return UDR;            // Zeichen aus UDR an Aufrufer zurueckgeben
}

void start_timer0(uint8_t prescale0){
  
  TCCR0 = 0; //8bit Timer
  
  if (prescale0 == 0)
  {
    TCCR0 = (1<<CS00) | (1<<WGM01);
  }
  
  if (prescale0 == 1)
  {
    TCCR0 = (1<<CS01) | (1<<WGM01);
  }
  
  if (prescale0 == 2)
  {
    TCCR0 = (1<<CS01) |(1<<CS00) | (1<<WGM01);
  }
  
  if (prescale0 == 3)
  {
    TCCR0 = (1<<CS02) | (1<<WGM01);
  }
  
  if (prescale0 == 4)
  {
    TCCR0 = (1<<CS02) | (1<<CS00) | (1<<WGM01);
  }
  
  
  TIMSK |= (1<<OCIE0);        //Timerinterrupt für Vergleich aktivieren  //Für Overlow Deaktiviert
  OCR0 = 256 - 1 ;              //Vergleichswert bis wohin er durchzählt  zählt!(länge des Timers abhängig vom Prescaler)
  //TIMSK |= (1<<TOIE0);        // Timer Overflow Interrupt freischalten  //Für Compa Deaktivieren
  sei();                //Interrupt enable
  
}

[Karl H. (kbuchegg)]

Jakob schrieb:

Deine Programmlogik ist

  while( 1 ) {

    Sieh nach ob ein Zeichen da ist und wenn ja
      hole es

    andernfalls
      mach irgendwas mit dem Timeout-Timer

    werte Zeichen aus
  }
}

meine Frage:
WIe kannst du ein Zeichen auswerten, wenn gar keines angekommen ist?

Die Logik müsste so sein

  while( 1 ) {

    Sieh nach ob ein Zeichen da ist und wenn ja {
      hole es
      werte das zeichen aus
    }

    andernfalls
      mach irgendwas mit dem Timeout-Timer
  }

es liegt ja wohl auf der Hand, dass man nur dann ein Zeichen auswerten 
kann, wenn auch tatsächlich eines eingetroffen ist.

[Karl H. (kbuchegg)]

Deine Timeout Sache.

Grundsätzlich solltest du von derartigen Timer Start/Stop Dingen Abstand 
nehmen. Das ist meistens viel zu kompliziert.
Einen Timer startet man einmalig beim Programmstart und dann lässt man 
ihn im Normalfall durchlaufen.

Deine ISR sieht so aus

volatile uint8_t ms;

ISR( ... )
{
  if( ms < 2000 )
    ms++;
}

d.h. der Timer versucht ständig ms zu erhöhen, bis er bei 2000 
angekommen ist.

Was ihn daran hindert, die 2000 zu erreichen, das ist das Eintreffen 
eines Zeichens, welches die Variable ms wieder auf 0 zurück setzt.

  while( 1 ) {

    Sieh nach ob ein Zeichen da ist und wenn ja {
      hole es
      werte das zeichen aus
      cli();
      ms = 0;
      sei();
    }

    andernfalls
      mach irgendwas mit dem Timeout-Timer
  }

und natürlich wird dann im Falle, das kein Zeichen eingetroffen ist, 
diese Variable untersucht, ob sie die 2000 erreicht hat. Wenn ja, dann 
sind 2 Sekunden seit dem letzten Zeichen vergangen. Wenn nein, dann ist 
die Wartezeit noch nicht abgelaufen

  while( 1 ) {

    Sieh nach ob ein Zeichen da ist und wenn ja {
      hole es
      werte das zeichen aus
      cli();
      ms = 0;
      sei();
    }

    andernfalls {
      cli();
      if( ms == 2000 )
        Timeout ist aufgelaufen!
      sei();
    }
  }

(da ms eine uint16_t Variable ist, müssen Zugriffe aus main mit cli() 
bzw. sei() gekapselt werden.)

[Jakob (Gast)]

Hallo, tue ich dies nicht im nachfolgen Code ?
Das Zeichen was ankommt wird auf die Variable Zeichen geschrieben und 
dann dementsprechend reagiert.
Der ATmega erkennt aber ein Zeichen obwohl Keins kommt und aber er 
springt in diese Routine.

[Karl H. (kbuchegg)]

Jakob schrieb:
> Hallo, tue ich dies nicht im nachfolgen Code ?

Nein.

Ich hab dir extra eine Codezusammenfassung geschrieben.

Du versuchst Zeichen IMMER auszuwerten. Egal ob was reingekommen ist 
oder nicht.

> Das Zeichen was ankommt wird auf die Variable Zeichen geschrieben und
> dann dementsprechend reagiert.

nicht dementsprechend.
Du reagierst immer, egal ob was reingekommen ist oder nicht.
Deine Zeichenauswertung hängt in keinster Weise davon ab, OB ein Zeichen 
eingetrudelt ist oder nicht.

> Der ATmega erkennt aber ein Zeichen obwohl Keins kommt und aber er
> springt in diese Routine.

In welche Routine?

Der Teil hier

...
  switch (Zeichen)
  {
  case 79: //  O in Ascii = 79. Die Zeichen werden in Ascii übermittelt
  LCD_xy(0,1);
  printf("---FBE-System---");
  LCD_xy(0,2);
  printf("Signalausfall!!!");  
  Startclock=0;
  Sek=0;

hängt bei dir nicht davon ab, ob ein Zeichen angekommen ist oder nicht.

[Karl H. (kbuchegg)]

Was jetzt natürlich noch sein kann, dass ist das du ja einen offenen 
Eingang hast, wenn du das Kabel abziehst. Und dann fängt sich der offene 
Eingang jedes elektromagnetische Feld aus der Umgebung ein, das er 
kriegen kann.

[Jakob (Gast)]

Karl Heinz schrieb:
> Was jetzt natürlich noch sein kann, dass ist das du ja einen offenen
> Eingang hast, wenn du das Kabel abziehst. Und dann fängt sich der offene
> Eingang jedes elektromagnetische Feld aus der Umgebung ein, das er
> kriegen kann.

Würde dann doch auch beim Start tun, wenn der Stecker gezogen ist.

Ich werde mich später noch mal damit beschaffen und den Kopf frei 
kriegen.

  if (UCSRA & (1<<RXC))
  {  
  Zeichen=uart_getchar();  //Empfängt Zeichen am UART Eingang und überträgt dieses an die Variable Zeichen
  }

Hier erkennt er doch ob ein Zeichen ankommt oder nicht ? Andernfalls 
springt er in die else Routine. Dies macht er aber nicht da er noch 
etwas im UCSRA gesetzt hat.

Naja ich hoffe ich bekomme es nachher hin.

mfg.

[Karl H. (kbuchegg)]

Jakob schrieb:

>

  if (UCSRA & (1<<RXC))
>   {
>   Zeichen=uart_getchar();  //Empfängt Zeichen am UART Eingang und 
> überträgt dieses an die Variable Zeichen
>   }

>
> Hier erkennt er doch ob ein Zeichen ankommt oder nicht ? Andernfalls
> springt er in die else Routine. Dies macht er aber nicht da er noch
> etwas im UCSRA gesetzt hat.

Woher weisst du, das er das nicht macht?

In deinem Else Zweig machst du nur dann irgendwas sinnvolles, wenn die 
zeit abgelaufen ist. Und genau die setzt du aber in den nachfolgenden 
switch-case immer wieder auf 0 zurück. Hat der µC einmal ein gültiges 
zeichen dann hat er das auch weiterhin und setzt dann auch weiterhin die 
Zeit immer wieder zurück.

[Karl H. (kbuchegg)]

> Naja ich hoffe ich bekomme es nachher hin.

Bau erst mal deinen Code vernünftig auf. Ich denke, du hast dich da 
jetzt ganz einfach nur planlos verrannt. Und dein geschwätziger Code tut 
sein übriges, dir den Überblick schwer zu machen.

volatile uint16_t ms;

#define TIMEOUT_TIME 2000   // in Millisekunden

ISR( ... )
{
  if( ms < TIMEOUT_TIME )
    ms++;
}

void ProcessCharacter()
{
  char c = getchar();

  cli();
  ms = 0;
  sei();

  LCD_xy( 0, 2 );

    // kein Grund da jetzt 79 hinzuschreiben.
    // Wenn du 'O' meinst, dann schreib auch 'O'
    // Schreib nicht im Kommentar hin, dass 79 der ASCII Code von 'O'
    // ist, sondern schreib direkt im Code hin, dass hier ein 'O' gefragt
    // ist. Selbiges für die anderen Buchstaben.
  if( c == 'O' )
    printf("Signalausfall!!!");  

  else if( c == 'G' )
    printf("Frequenz im Band");  

  else if( c == 'R' )
    printf("Freq. ausserhalb");  
}

int main(void)
{
...

  LCD_xy(0,1);
  printf("---FBE-System---");

  start_timer0( 2 );    // Watchdog starten

  while( 1 ) {
    if (UCSRA & (1<<RXC))
      ProcessCharacter();

    else {
      cli();
      if( ms == TIMEOUT_TIME ) {
        LCD_xy( 0, 2 );
        printf("EEEEEEEEEEEEE");
      }
      sei();
    }
  }
} //Main

[Jakob (Gast)]

Danke, ich werde jetzt den Code aufräumen. Er war/ist wirklich 
"vermüllt". Ich werde mich jetzt nach deinen Beispiel orientieren.

So jetzt funktioniert es erst mal :

if (UCSRA & (1<<RXC))
  {  
  Zeichen=uart_getchar();  //Empfängt Zeichen am UART Eingang und überträgt dieses an die Variable Zeichen
  mS=0;
  Sek=0;  
  }  
  
  else
  {
    if (Sek>1)    
      Zeichen=2;    
  }

[Bülent C. (mirki)]

Wäre es nicht sinnvoller UDR aus einem interrupt heraus zu lesen, wenn 
eh schon mit interrupts gearbeitet wird?