Sind Sie sicher Abfrage, Usart, Atmega32

[Jürgen G (Gast)]

Hallo,

ich brauch mal eure Hilfe.
Ich möchte über einen Befehl der von der seriellen Schnittstelle (Putty) 
kommt, einige Strings leeren. Ausgabe auf das Terminal funktioniert. 
(Siehe Bild)
Mein Problem ist jetzt bei Punkt 2.
Drücke ich y oder n wird einfach nur der Buchstabe angezeigt.

Wo liegt mein Fehler?

Verzeiht mir bitte mein Programmierstil. Bin noch in der Lernphase.

Danke für eure Hilfe.

[chbalnuweit (Gast)]

Ich kann in deiner main nicht erkennen, wo du "uart_string" 
herbekommst...

[chbalnuweit (Gast)]

Da es scheinbar in der ISR ausgelesen wird, sollte char uart_string 
besser auch volatile sein!

[Jürgen G (Gast)]

Ok, habs geändert.
Sieht jetzt so aus:

volatile uint8_t uart_str_complete=0; 
volatile uint8_t uart_str_count=0;
volatile char uart_string[10];

Wie muss ich denn folgenden Code ändern das es funktioniert?

  if (strcmp (uart_string, "2" ) == 0)
      {
        uart_string[0] = '\0';
      uart_schreibe_string("\n\rSind Sie sicher?\(y\/n\)");
      
      while( uart_string[1] != '\0');
        
        if (strcmp (uart_string, "y" )==0)
        {
          uart_string[0] = '\0';
          uart_schreibe_string("Daten geloescht");
        }
        if (strcmp (uart_string, "n" )==0)
          {
          uart_string[0] = '\0';
          uart_schreibe_string("Hauptmenue");
        }
      }

[chbalnuweit (Gast)]

Hast du mal mit einem Minimalbeispiel probiert, ob das Empfangen des 
Strings überhaupt richtig funktioniert?

[chbalnuweit (Gast)]

oid uart_gets( char* Buffer, uint8_t MaxLen ) 
{ 
  uint8_t NextChar; 
  uint8_t StringLen = 0; 
  NextChar = uart_getc();   // Warte auf und empfange das nächste Zeichen
                // Sammle solange Zeichen, bis:
                // * entweder das String Ende Zeichen kam
                // * oder das aufnehmende Array voll ist
  while( NextChar != '\n') 
  {   
    *Buffer++ = NextChar; 
    StringLen++; 
    NextChar = uart_getc(); 
  } 
        // Noch ein '\0' anhängen um einen Standard
        // C-String daraus zu machen
  *Buffer = '\0'; 
}

 *Buffer = '\0'; <-- Hier überschreibst du das letzte Zeichen mit '\0', 
in deinem Falle vermutlich dein "y" , weshalb deine uart_string immer 
leer ist.

[Jürgen G (Gast)]

hab gerade folgendes geändert:

if (strcmp (uart_string, "ok" ) == 0)// <-----
      {
        uart_string[0] = '\0';
      uart_schreibe_string("\n\rSind Sie sicher?\(y\/n\)");

Jetzt muss ich ok eingeben das die Frage kommt ob ich sicher bin.
Heist also er speichert den String.

[chbalnuweit (Gast)]

Okay gut, meine Vermutung war auch Unsinn, da da weiter oben ja 
"*Buffer++ = ..." ausgeführt wird, was ein post-inkrement des Pointers 
bedeutet und somit später auch nichts überschrieben wird.
Funktioniert generell das mehrfache Empfangen von Strings?
Versuch mal ein Echo-Programm, sodass der MC immer das auf die Konsole 
zurückgibt, was du eingeben hast. Vielleicht hilft dir das, deinem 
Fehler auf die Spur zu kommen.

[Jürgen G (Gast)]

Erledigt.
Sobald ich die Entertaste drücke, gibt er genau das aus was ich 
eingegeben habe. Es scheint also, dass er die uart_string richtig 
beschreibt.

Mit dieser while-Schleife möchte ich ja auf eine Antwort des Benutzer 
warten.

while( uart_string[1] != '\0');

Also quasie auf ein y oder ein n.
Ist die Abfrage richtig?

[chbalnuweit (Gast)]

Jürgen G schrieb:
> Sobald ich die Entertaste drücke,
...

[Jürgen G (Gast)]

???

[chbalnuweit (Gast)]

Ich bin davon ausgegangen, dass du die Entertaste gedrückt hast, da du 
es so programmiert hast, dass man sie drücken muss.
Wenn du "ok" oder "2" eingetippt hast, wirst du ja wohl auch die 
Entertaste gedrückt haben, oder?

[chbalnuweit (Gast)]

Sorry, ich glaube wir haben aneinander vorbei geredet:
Ich dachte dein Problem hat sich erledigt, weil du nach dem "y" nicht 
"Enter" gedrückt hast. Aber scheinbar bezog sich dein "Erledigt" auf die 
Idee mit dem Echo-Programm ;-)

Wenn du nur ein Zeichen vom Benutzer erwartest, wieso nimmst du nicht 
einfach die uart_getc() Funktion?

while(uart_getc() != "y"){}    // tue nichts solange kein "y"
uart_puts("y wurde gedrückt")  // danach sende string zurück

[Jürgen G (Gast)]

ja, da haben wir an einander vorbei geschrieben.

Dein Vorschlag hat nicht funktioniert.

if (strcmp (uart_string, "2" ) == 0)
      {
        uart_string[0] = '\0';
      uart_schreibe_string("\n\rSind Sie sicher?\(y/n)");
      
      while(uart_getc() != "y"){}
        
        //if (strcmp (uart_string, "y" )==0)
        //{
          uart_string[0] = '\0';
          uart_schreibe_string("Daten geloescht");
        //}
        //if (strcmp (uart_string, "n" )==0)
          //{
        //  uart_string[0] = '\0';
        //  uart_schreibe_string("Hauptmenue");
        //}
      }

Mit diesem code müßte ich doch eigentlich beim Drücken des y, 'Daten 
gelöscht' als Rückmeldung erhalten.
Macht es aber nicht.

Zwischen durch auch mal ein Dankeschön für deine Mühe.

[chbalnuweit (Gast)]

Ich hätte jetzt erwartet, dass das funktioniert ;) Einen Fehler kann ich 
jetzt nicht erkennen. Ist das wirklich das ganze Programm oder gibt es 
da noch mehr?

[Jürgen G (Gast)]

Es gibt nur noch eine Datei wo die Funktionen für die Ausgabe auf die 
RS232 drin stehen. Hab ich angehängt. Aber das funktioniert ja.
Sonnst würde er mir die Frage ja nicht ausgeben.

Kann ich nicht irgendwie die uart_string sollange abfragen bis da was 
neues drin steht?

Geh jetzt erst mal gefrustet ins Bett:-(
Gute Nacht.

[chbalnuweit (Gast)]

  if (strcmp (uart_string, "2" ) == 0)
      {
        uart_string[0] = '\0';
      uart_schreibe_string("\n\rSind Sie sicher?\(y\/n\)");

      // Versuche hier mal "uart_string" an die Konsole auszugeben
      // damit du sehen kannst, was überhaupt drin steht.
      
      while( uart_string[1] != '\0');
        
        if (strcmp (uart_string, "y" )==0)
        {
          uart_string[0] = '\0';
          uart_schreibe_string("Daten geloescht");
        }
        if (strcmp (uart_string, "n" )==0)
          {
          uart_string[0] = '\0';
          uart_schreibe_string("Hauptmenue");
        }
      }

Hast du LEDs oder ein Oszi oder so angeschlossen, was du zum Debuggen 
nehmen könntest?
Eigentlich kann es ja nur so sein, dass er hier

 while( uart_string[1] != '\0');

hängen bleibt.
Du könntest versuchen, einen delay einzubauen und einen Pin in der 
Schleife zu toggeln. Dann kannst du das mit LED oder Oszi sichtbar 
machen.
Z.B. so:

 while( uart_string[1] != '\0')
 {
   _delay_ms(200)
   PORTA ^= (1<<PA0) 
 }

[Mike A. (Gast)]

Jürgen G schrieb:
> Also quasie auf ein y oder ein n.

Wehe der Benutzer drückt "Y" oder "N"

[Jürgen G (Gast)]

So, hat etwas gedauert.

chbalnuweit schrieb:
> // Versuche hier mal "uart_string" an die Konsole auszugeben
>       // damit du sehen kannst, was überhaupt drin steht.

Das ist meine Antwort drauf:

if (strcmp (uart_string, "2" ) == 0)
      {
      uart_schreibe_string(uart_string);
      uart_string[0] = '\0';
      uart_schreibe_string(uart_string);
      /*
      while( uart_string[1] != '\0')
      {
           _delay_ms(200);
           PORTC ^= (1<<PC7);
       }
        
        
          if (strcmp (uart_string, "y" )==0)
          {
            uart_string[0] = '\0';
              uart_schreibe_string("Daten geloescht");
          }
          if (strcmp (uart_string, "n" )==0)
            {
              uart_string[0] = '\0';
              uart_schreibe_string("Hauptmenue");
          }*/
        }

Siehe Bild

Das ist der nächste Versuch:

if (strcmp (uart_string, "2" ) == 0)
      {
      uart_string[0] = '\0';
      uart_schreibe_string("\n\rSind Sie sicher?");

      while( uart_string[1] != '\0')
      {
           _delay_ms(200);
           PORTC ^= (1<<PC7);
       }
        
        
          if (strcmp (uart_string, "y" )==0)
          {
            uart_string[0] = '\0';
              uart_schreibe_string("Daten geloescht");
          }
          if (strcmp (uart_string, "n" )==0)
            {
              uart_string[0] = '\0';
              uart_schreibe_string("Hauptmenue");
          }
        }

Led blinkt nicht.
Soll heisen, er bleibt nicht hängen und fragt somit auch nicht die 
Tasten ab. Was tun?

Danke für die Hilfe!

[chbalnuweit (Gast)]

Hast du auch vorher PC7 auf PortC  mit

DDRC = (1<<PC7) als Ausgang definiert?

Versuch weiter mit der LED zu debuggen.

Verschiebe das toggeln der LED zum Beispiel hier hin:

 if (strcmp (uart_string, "y" )==0)
          {
            PORTC ^= (1<<PC7);
            uart_string[0] = '\0';
            uart_schreibe_string("Daten geloescht");
          }

Du musst erstmal herausfinden, wo etwas schief läuft. Dann kann man 
sehen, was ggf. schief läuft.

[Wegstaben V. (wegstabenverbuchsler)]

du musst blos auf die Abfrage auf "Sind sie sicher?"  mit j/n anstelle 
y/n prüfen, dann funktioniert alles  .... oder soll y = "yoh, man" 
bedeuten?

[Karl H. (kbuchegg)]

Du solltest nicht einfach Code übernehmen, ohne ihn wenigstens 
rudimentär zu verstehen.

Deine ganzen Abfragen kranken alle an einem Punkt:

Der erste Anlaufpunkt, die erste Abfrage die du machen musst, ist 
diejenige ob uart_str_complete den Wert 1 hat. Denn DAS ist das Signal, 
mit der dir die ISR signalisiert "Huhu! Ich hab eine komplette Zeile. 
Bitte auswerten!"

Und das hier

ISR(USART_RXC_vect) 
{ 
  unsigned char buffer; 
  buffer = UDR; 
  if( uart_str_complete==0 ) 
  { 
    if(buffer!='\n'&& buffer!='\r') 
    { 
      uart_string[uart_str_count]=buffer;
      uart_putc(uart_string[uart_str_count]); 
      uart_str_count++; 
    }
    else
    { 
      uart_string[uart_str_count]='\0'; 
      uart_str_count=0; 
      uart_str_complete=1;
      uart_schreibe_string("\n\r");
    } 
  } 

                           // *******************
  uart_str_complete=0;     // <--------- das hier
                           // *******************

}

(das Setzen von uart_str_complete auf 0 am Ende) gehört da überhaupt 
nicht rein. Entweder hat derjenige, bei dem du abgeschrieben hast, 
nichts verstanden oder du selbst hast das verbockt.

Du selbst setzt dann in deinem Hauptprogramm usart_str_complete wieder 
auf 0, und zwar NACHDEM du den String der reingekommen ist augewertet 
hast. So wie das jetzt programmiert ist, ist nämlich uart_str_complete 
völlig nutzlos. Da hätte man sich die Variable auch sparen können. Nur: 
Die Variable ist vital für das funktionieren des ganzen! Deine ganzen 
Abfragen, ob irgend ein Zeichen in deinem Array '\0' wird, um daran das 
Ende einer Eingabe zu erkennen, ist völliger Humbug.

Also: 0 Setzen aus der ISR raus. Dafür die Abfrage in main, ob die ISR 
anzeigt, dass ein String komplett ist und nach der Auswertung des 
Strings, wenn die UART wieder scharf gestellt wird, die Variable auf 0 
setzen.

Dafür schreibst du:

....
  uart_schreibe_string("Menue:\n\r"
                       " 1.\)Daten lesen\n\r"
                       " 2.\)Daten loeschen\n\r"
                       " 3.\)Datum einstellen\n\r"
                       " 4.\)Uhr einstellen");

  while(1) 
  { 
    // gibt es eine fertige Eingabe über die UART?
    if (uart_str_complete != 0) {

      // Ja, es gibt eine. Was war es?

      if (strcmp (uart_string, "1") == 0)
      {
        uart_schreibe_string("\n\rFolgende Daten sind gespeichert");
        uart_schreibe_string("\n\r");
      }

      else if (strcmp (uart_string, "2" ) == 0)
      {
        uart_schreibe_string("\n\rSind Sie sicher?\(y\/n\)");

        // die UART wieder zum Empfang freigeben
        uart_str_complete = 0;
        // warte auf den Benutzer. Wenn er Return drückt, dann
        // geht uart_str_complete auf 1
        while( uart_str_complete == 0 )
          ;

        // was war die Benutzereingabe?        
        if (strcmp (uart_string, "y" ) == 0 ||
            strcmp (uart_string, "Y" ) == 0 )
        {
          uart_schreibe_string("Daten geloescht");
        }

        // wenn die Eingabe nicht 'y' war, dann nehmen wir
        // automatisch 'n' an. Denn was soll passieren, wenn der
        // Benutzer zb 'o' drueckt?
        else
          uart_schreibe_string("Hauptmenue");
        }
      }

      // was auch immer die Benutzereingabe war. Jetzt ist sie
      // fertig abgehandelt und die UART kann wieder freigeschaltet werden
      // so dass sie die naechsten Zeichen sammelt
      uart_str_complete = 0;
    }

  } 
}

Wenn du mit er Eingabe per Interrupt und wie man die auswertet nicht 
klar kommst, warum verwendest du die überhaupt? In deinem Programm 
bringt dir die genau gar nichts, weil du sowieso dauernd auf einen 
Benutzer wartest. Da könntest du dir diesen ganzen Hack-Mack auch sparen 
und gleich ohne Interrupts und dafür mit der Funktion uart_gets 
arbeiten. Das wäre in deinem Fall viel einfacher. Du rufst uart_gets auf 
und wenn die Funktion einen String (= eine Zeile) gesammelt hat, dann 
kehrt sie zurück.

> Wenn du nur ein Zeichen vom Benutzer erwartest, wieso nimmst
> du nicht einfach die uart_getc() Funktion?

weil er einen Empfangs Interrupt im Spiel hat. entweder uart_getc und 
uart_gets oder eine Abhandlung über den Interrupt. Aber nicht beides 
bunt gemischt. Das funktioniert nämlich nicht.

> while(uart_getc() != "y"){}    // tue nichts solange kein "y"

Oh Mann. Da berät auch wieder ein Einäugiger einen Blinden.
Du kennst den Unterschied zwischen einem String und einem Character?

[Karl H. (kbuchegg)]

Das einzige was jetzt noch sein kann, das ist, dass dein Terminal beim 
Drücken der Return Taste sowohl ein Carriage Return als auch ein Line 
Feed schickt (also beides: \r UND \n). Im Sinne der Einfachheit 
kontrollier das und stelle dein Terminal so ein, dass es NUR ein 
LineFeed (\n) schickt. Denn das ausfiltern aller Möglichkeiten, die hier 
möglich sind, scheint nach ein paar Schuhnummern zu schwer für dich zu 
sein.

[Thomas K. (thomas_k39)]

Jürgen G schrieb:

 if (strcmp (uart_string, "2" ) == 0)
       {
       uart_string[0] = '\0';
       uart_schreibe_string("\n\rSind Sie sicher?");
 
       while( uart_string[1] != '\0')
       {
            _delay_ms(200);
            PORTC ^= (1<<PC7);
        }

Die while-Schleife kann so nicht funktionieren!

Der strcmp in der ersten Zeile prüft auf

uart_string[0] == '2' && uart_string[1] == '\0'

Das heisst, wenn der Benutzer nicht mindestens zwei Zeichen eingegeben 
hat, bevor der Code zum

while( uart_string[1] != '\0)

 kommt, wird die Schleife einfach übersprungen.

[Jürgen G (Gast)]

So, hat etwas gedauert.
Es funktioniert jetzt.

Herzlichen Dank!!!

Karl Heinz schrieb:
> Oh Mann. Da berät auch wieder ein Einäugiger einen Blinden.

Wie soll der Blinde sehen, dass der andere Einäugig ist? ;-)