Wort über das Terminal an dem uC senden

[Jakob (Gast)]

Hallo, ich hab ich jetzt mit dem UART versucht.
Ich möchte mit meinen uC über RS232 mitn PC übers Terminal Programm 
reden.
Text ausgeben und Zahlen einlesen funktioniert alles Einwand frei.
Nun möchte ich ein Wort auf dem Terminal eingeben und der uC soll es 
wieder geben zur Kontrolle. Dies funktioniert leider nicht. Ich blicke 
nicht ganz durch die gets und string Geschichte beim UART durch. ? Ich 
arbeite mit printf und scanf.

________________________________________________
Hier mal der Code aus der Main :
________________________________________________

int main(void)
{
    init_uart(103);      //RS232 Initialisierung 
    stdout = &uart_output;    //
    stdin = &uart_input;    //
          unsigned int input;          //16bit  
  
  
  char str[50]; //Für die Einlesung eines Wortes
  
  
  while(1){  
  puts("\033[2J");  // clear screen
  puts("\033[0;0H");  // set cursor to 0,0    
  
  printf("Geben sie jetzt eine Zahl ein = ");
  scanf("%u",&input);
  printf("\n\rDeine Eingabe war %u",input);
  _delay_ms(2000);
  printf("\n\rEin Sinnloses Wort eingeben = ");
  gets(str);  <----------------------------------------
  printf("\n\rDeine Eingabe war = %s",str);
  
  
  
  _delay_ms(5000);}}

________________________________________________
Und hier Meine UART Routinen :
________________________________________________

//const int UBRR_VAL = 103;    //UBRR_VAL für 16Mhz und 9600baud beim ATMega32      


/*---------------------------------------------------------------------------
init_uart(): USART Initialisierung 
Parameter: UBRR_VAL                       
---------------------------------------------------------------------------*/

//für korrekten UBRR_VAL siehe Datenblatt des jeweiligen Microcontrollers

void init_uart (int UBRR_VAL)
{
  UCSRB |= (1<<TXEN) | (1<<RXEN);    // UART TX/RX einschalten
  UCSRC |= (1<<URSEL)|(3<<UCSZ0);    // Asynchron, 8Bit Framesize, Paritymode disabled, 1 Stopbit (8N1) 

  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF; 
}


/*---------------------------------------------------------------------------
uart_putchar(): Senden einzelner Zeichen 
Parameter: c = Zeichen                       
---------------------------------------------------------------------------*/
void uart_putchar (unsigned char c)
{
  while (!(UCSRA & (1<<UDRE)))      // warten bis Senden moeglich
    {
    }
    UDR = c;
}

/*---------------------------------------------------------------------------
uart_getchar(): Empfangen einzelner Zeichen                       
---------------------------------------------------------------------------*/
unsigned char uart_getchar (void)
{
    while (!(UCSRA & (1<<RXC)))  // warten bis Zeichen verfuegbar
        {
    }
    return UDR;            // Zeichen aus UDR an Aufrufer zurueckgeben
}

/*---------------------------------------------------------------------------
uart_puts(): Senden einer Zeichenkette
Parameter: *s = Zeichenkette
---------------------------------------------------------------------------*/
void uart_puts (char *s)
{
  while (*s)          // so lange *s != '\0' also ungleich dem "String-Endezeichen"
  {
    uart_putchar(*s);
    s++;
  }
}

________________________________________________
Zusätzlich für die Verwendung von printf etc :
________________________________________________

FILE uart_output = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);
FILE uart_input = FDEV_SETUP_STREAM(NULL, uart_getchar, _FDEV_SETUP_READ);

________________________________________________
Auf dem Terminal sieht es so aus :

Geben sie jetzt eine Zahl ein = 888
Deine Eingabe war 888
Ein Sinnloses Wort eingeben = jkjk

Der Courser liegt nach der Eingabe auf dem E von Eingabe.

[Karl H. (kbuchegg)]

Der springende Punkt ist, dass du hier

  ... 888

nicht nur die Tasten 8, 8 und 8 gedrückt hast, sondern auch noch auf 
Return drüclken musstest.

EIn

  scanf("%u",&input);

holt sich zwar die 3 8-er, aber es belässt den Return im Eingabestrom. 
Die nächste Eingabeoperation muss sich darum kümmern. Genauer gesagt: 
Wenn ein scanf eine Zahl einlesen soll, dann hört er beim ersten Zeichen 
auf, das nicht zur Zahl gehört. Das kann irgendein Zeichen sein, zum 
Beispiel ein Leerzeichen, ein 'a' oder aber auch ein Return. Da dieses 
Zeichen nicht zur Zahl gehört kann es aber dieser scanf hier nicht 
einfach weglesen, sondern muss es im Eingabestrom belassen.

Ein

gets(str);

hingegen ist so definiert, dass er alle Zeichen einliest, bis er auf 
einen Return stösst.

Tja. Aber genau den Fall hast du. Von der Eingabe der 888 ist da noch 
ein Return im Eingabestrom. Und genau den sieht das gets als 
allererstes, holt ihn sich und erklärt damit die Eingabe des Strings für 
beendet.

Gewöhn dich daran, dass direkte Eingaben per printf und scanf auf einem 
µC eist keine so gute Idee sind. Das scanf, so wie du das betreibst, 
sowieso schon nicht. Denn auf einem µC ist der Normalfall der, dass der 
Prozessor nicht Däumchen drehen darf, nur weil er auf eine Eingabe vom 
Benutzer wartet. D.h. hier ist man im Endeffekt mit anderen Methoden 
viel besser bedient.

[Jakob (Gast)]

Hallo, ich hab mal die Routine genommen die ich im TuT gefunden habe 
habe die main jetzt folgendermaßen geschrieben, der Effekt ist der 
selbe. Ich gebe das Wort ein drücke auf Enter und er springt zum Anfang 
des Satzes, zum E von Ein.

int main(void)
{
  
  

    init_uart(103);        //RS232 Initialisierung 
    stdout = &uart_output;    //
    stdin = &uart_input;    //
      unsigned int input;      //16bit    
    char Line[40];        // String mit maximal 39 zeichen
  
  
  while(1){  
  puts("\033[2J");  // clear screen
  puts("\033[0;0H");  // set cursor to 0,0

  uart_puts("\n\rEin Sinnloses Wort eingeben = ");  
  uart_gets( Line, sizeof( Line ) );
  uart_puts( "\r\n" );
  uart_puts( Line );  
  
  _delay_ms(5000);
  
  
  }//while(1)

_____________________
Routine =
_____________________

void uart_gets( char* Buffer, uint8_t MaxLen )
{
  uint8_t NextChar;
  uint8_t StringLen = 0;
  
  NextChar = uart_getchar();         // 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' && StringLen < MaxLen - 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getchar();
  }
  
  // Noch ein '\0' anhängen um einen Standard
  // C-String daraus zu machen
  *Buffer = '\0';
}

[Jakob (Gast)]

Jakob schrieb:
> uart_puts( "\r\n" );
> uart_puts( Line );


Dies wird ja dann so zu sagen gar nicht bearbeitet sondern bleibt im 
uart_gets stecken ?

[Karl H. (kbuchegg)]

Jakob schrieb:

Mach dir hier mal eine zusätzliche Echo-Ausgabe rein

>

> void uart_gets( char* Buffer, uint8_t MaxLen )
> {
>   uint8_t NextChar;
>   uint8_t StringLen = 0;
> 
>   NextChar = uart_getchar();         // Warte auf und empfange das 
> nächste Zeichen
>

    uart_putchar( '*' );
    uart_putchar( NextChar );
    uart_putchar( '*' );

>

>  // Sammle solange Zeichen, bis:
>  // * entweder das String Ende Zeichen kam
>  // * oder das aufnehmende Array voll ist
>  while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
>    *Buffer++ = NextChar;
>    StringLen++;
>    NextChar = uart_getchar();
>

     uart_putchar( '*' );
     uart_putchar( NextChar );
     uart_putchar( '*' );

>

>  }....
>

Dann fällt es dir leichter nachzuvollziehen, welche Zeichen (vor allen 
Dingen Steuerzeichen) in welcher Reihenfolge eintrudeln.

[Karl H. (kbuchegg)]

Jakob schrieb:
> Jakob schrieb:
>> uart_puts( "\r\n" );
>> uart_puts( Line );
>
>
> Dies wird ja dann so zu sagen gar nicht bearbeitet sondern bleibt im
> uart_gets stecken ?

Das kannst du ganz leicht rausfinden :-)

  uart_puts( "\r\n Ich hab verstanden: \"" );
  uart_puts( Line );
  uart_puts( "\"" );

Und schon hast du einen unzweideutigen Fixtext an der Ausgabe, der 
eindeutig belegt, ob es zu den puts überhaupt kommt.


Gewöhn dich an die Idee, dass du über die UART dir auch dir bekannte 
Fixtexte ausgeben kannst, die dir in der Entwicklungsphase des Programms 
helfen nachzuvollziehen, wie die Ablöufe im Programm sind. Es ist nicht 
verboten sich derartige Hilfen zunächst ins Programm einzubauen, die 
dann nach Ende der Entwicklung, bzw. wenn man ein Problem verstanden und 
behoben hat, wieder entfernt.

genau aus dem Grund ist es auch eine gute Idee, sich zb Texte mit 
Sonderzeichen einzurahmen, weil man dann auch Sonderzeichen, wie zum 
Beispiel Zeilenvorschübe im ausgegegbenen Text 'sehen' kann, indem man 
analysiert, ob diese Sonderzeichen dort in der Ausgabe auftauchen, wo 
sie auftauchen sollten. in einem

"Test.txt "

ist nun mal am Ende des eigentlichen Textes ein Leerzeichen, das man 
sonst nicht sehen würde. In

"Test.txt
"

hat sich ganz offensichtlich ein Carriage Return / Line Feed in den Text 
eingeschmuggelt. In

"
Test.txt"

steht der Carriage Return / Line Feed offenbar am Anfang des Textes.
Allen Fällen gemeinsam ist, dass man ohne die zusätzlichen 
Sonderzeichen, diese Spezialitäten nicht oder nur sehr schwer sehen 
würde.

[Jakob (Gast)]

Hab es...das Programm hat so funktioniert musste aber die 40 Zeichen 
Eingeben und bei Enter hat er nur Unsinn gemacht, aber hab mir die 
Routine nochmal genauer angeschaut und hab gemeckert das ich statt denn 
\n ein \r schreiben muss damit er mit Enter beendet :S

while( NextChar != ---->  '\r' <----- && StringLen < MaxLen - 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getchar();

Ist der Aufbau so besser, als mit Printf etc ?

  puts("\033[2J");  // clear screen
  puts("\033[0;0H");  // set cursor to 0,0

  uart_puts("\n\rEin Sinnloses Wort eingeben = ");  
  uart_gets( Line, sizeof( Line ) );
  uart_puts( "\r\nDeine Eingabe = " );
  uart_puts( Line );
  _delay_ms(10000);

[Jakob (Gast)]

Ich danke dir für die Tipp's =)

[Karl H. (kbuchegg)]

Jakob schrieb:
> Hab es...das Programm hat so funktioniert musste aber die 40 Zeichen
> Eingeben und bei Enter hat er nur Unsinn gemacht, aber hab mir die
> Routine nochmal genauer angeschaut und hab gemeckert das ich statt denn
> \n ein \r schreiben muss damit er mit Enter beendet :S

Ja, das kann sein.
Das hängt von der Einstellung deines Terminalprogramms ab, mit dem du 
arbeitest. Da gibt es alle Möglichkeiten, auch Kombinationen davon.

Und ja. das ist ein konstantes Ärgerniss.


> Ist der Aufbau so besser, als mit Printf etc ?

printf geht noch. Aber mit scanf wirst du nicht wirklich glücklich 
werden. Aus dem schon genannten Grund, dass in einem normalen 
µC-Programm die Heizungssteuerung ja nicht stehen bleiben darf, nur weil 
du eine Eingabe angefangen hast und zwischendurch mal aufs Klo musstest.

µC-Programmierung funktioniert am besten, wenn man diese sequentielle 
Vorgehensweise "erst mach dies, dann warte auf das" über Bord wirft und 
nach dem Muster vorgeht: Welches Ereignis ist eingetreten, wie muss ich 
darauf reagieren.

  lineCnt = 0;

  while( 1 ) {

    if( uart_char_available() ) {     // Ist ein Zeichen an der UART eingetroffen?
      nextChar = uart_getc();         // hole das Zeichen.
                                      // was soll damit geschehen?

      if( nextChar != '\r' )          // noch nicht das Ende einer Eingabezeile
        nextLine[lineCnt++] = nextChar;  // Zeichen zwischenspeichern

      else {                          // die Zeile ist vollständig
        nextLine[lineCnt] = '\0';
        lineCnt = 0;

                                      // auswerten
        if( strcmp( nextLine, "ein" ) == 0 )
          PORTB &= ~( 1 << PB0 );    // beispielsweise LED einschalten

        else if( strcmp( nextLine, "aus" ) == 0 )
          PORTB |= ( 1 << PB0 );     // beispielsweise LED ausschalten
      }
    }

    // mach was ganz wichtiges, was regelmässig erfolgen muss
    // zb. Überwachen ob ein motorgesteuerter Schlitten seine Endposition
    // erreicht hat.
  }

auf die Art läuft der Teil 'mach was ganz wichtiges, ...' auch dann 
weiter, während du an deinem Terminal sitzt und tippst und dir während 
des Tippens einen Kaffee holst. Trudelt das nächste getippte Zeichen 
beim AVR ein, dann wird es geholt, entschieden was damit passieren soll 
(in den meisten Fällen wird es einfach an die bisher empfangenen Zeichen 
hinten drann gehängt) und nur dann, aber auch wirklich nur dann, wenn du 
auf Return drückst, startet die Auswertung der übertragenen Zeile.

Auf etwas zu warten ist in der µC-Programmierung in 95% der Fälle eine 
ganz schlecht Design-Entscheidung.

Und genau deswegen ist scanf (nicht aber sscanf!) meist nicht wirklich 
brauchbar. Genausowenig wie ein _delay_ms ausser in ganz wenigen 
Ausnahmefällen etwas verloren hätte. Der Schlüssel zu einem Programm, 
das scheinbar mehrere Aufgaben gleichzeitig erledigen kann, besteht 
darin, dass auf nichts und niemanden gewartet wird. Ausser vielleicht 
auf die Antwort von einem DS1820 Temperatursensor. Aber da reden wir 
nicht von Millisekunden sondern von Mykrosekunden im Übertragungstakt 
:-)

[Jakob (Gast)]

Ich versuche es umzusetzen =)
War erst mal nur die Vorbereitung auf ein Größeres Projekt

[Jörg E. (jackfritt)]

Und auch bei Sensoren kann das Signal gestört sein und dein Mc wartet 
auf eine Flanke etc. Da ist es dann schön wenn auch dort eine Art 
timeout Variable vorhanden ist. Das ist mir bei wilden Steckbrett 
Aufbauten schon öfter passiert.

Und wieder Vielen Dank an Karl Heinz für die tollen Ausführungen.

[Stefan F. (Gast)]

Ich habe mir angewöhnt, beim Empfang sowohl \r als auch \n zu 
akzeptieren. Außerdem noch die Sonderlocke dass ein \n ignoriert wird, 
wenn das vorherige Zeichen ein \r war (DOS Programme und daran 
angelehnte beenden Zeilen häufig mit \r\n).