if (c >= 'A') zulässig?

[Terra (Gast)]

Hallo zusammen,

ich bin gerade dabei Daten welche vom Uart kommen zu sortieren, 
Großbuchstaben möchte ich abfangen.

.
.
/*
* Get received character from ringbuffer
* uart_getc() returns in the lower byte the received character and 
* in the higher byte (bitmask) the last receive error
* UART_NO_DATA is returned when no data is available.
*/
unsigned int ch = uart_getc();

if ((ch&0x00FF) == 'A') ruleTheWorld();
//oder
if ((ch<<1) == 'A') ruleTheWorld();
//oder
if ((char)(ch) == 'A') ruleTheWorld();
// oder
if ((char)(ch) == 65) ruleTheWorld();

All diese Beispiele fangen meine Buchstaben A nicht ab.

Meine Frage an euch ist also: Wie prüft man Character in C korrekt ab?

Lg,
Marc

[Rufus Τ. F. (rufus)]

Terra schrieb:
> All diese Beispiele fangen meine Buchstaben A nicht ab.

Was heißt für Dich "abfangen"? Aufrufen von "ruleTheWorld"?

Alle Beispiele bis auf eines sind gleichwertig, und alle sollten 
funktionieren.

if ((ch<<1) == 'A') ruleTheWorld();

Das ist Quark. Gequirlt, gerührt und geschüttelt.

Probier doch mal das hier:

unsigned int ch = 'A';

if ((ch&0x00FF) == 'A') ruleTheWorld();
//oder
if ((char)(ch) == 'A') ruleTheWorld();
// oder
if ((char)(ch) == 65) ruleTheWorld();

[mse2 (Gast)]

Terra schrieb:
> All diese Beispiele fangen meine Buchstaben A nicht ab.
Müssten sie aber. Dann würde ich mal vermuten, dass in Deinem ch aus 
irgendwelchen Gründen einfach kein 'A' drinnen ist.

[Helmut L. (helmi1)]

Terra schrieb:
> Meine Frage an euch ist also: Wie prüft man Character in C korrekt ab?

Da gibt es die Funktionen:

isalpha(x)   true wenn es ein Buchstabe ist
islower(x)   true wenn es ein Kleinbuchstabe ist
isupper(x)   true wenn es ein Grossbuchstabe ist
isalnum(x)   true wenn es Buchstabe oder Ziffer ist
isdigit(x)   true wenn es eine Ziffer ist
isxdigit(x)  true wenn es eine Hex Ziffer ist

alles in ctype.h

[Ralf G. (ralg)]

Rufus Τ. Firefly schrieb:
> Probier doch mal das hier:
> unsigned int ch = 'A';

Steht das 'A' dann nicht im High-Byte?

[Fabian O. (xfr)]

Ralf G. schrieb:
> Rufus Τ. Firefly schrieb:
>> Probier doch mal das hier:
>> unsigned int ch = 'A';
>
> Steht das 'A' dann nicht im High-Byte?

Nein. Das ist nichts anderes als:

unsigned int ch = 65;

[Ralf G. (ralg)]

Ralf G. schrieb:
> Steht das 'A' dann nicht im High-Byte?

Richtig. Totaler Käse. Hab' überlegt, ob die zurückgegebenen 16 Bit 
vielleicht vertauscht sind, weil der Sender die 'andersrum' im Speicher 
ablegt.

[Terra (Gast)]

Vielen Dank für euer Feedback.

Offenbar gibt es noch irgendwo einen anderen Fehler weil, wie gesagt 
ruleTheWorld() nicht aufgerufen wird.

Danke für folgenden Tipp:
isupper(x)   true wenn es ein Grossbuchstabe ist

das werde ich gleich probieren. Leider habe ich kein Debuginterface, 
sonst wäre das Problem schon gefunden...

Wichtig für mich war euer Feedback, dass mein Code grundsätzlich OK ist 
und der Hinweis auf isupper().

DANKE

[Rufus Τ. F. (rufus)]

Ralf G. schrieb:
> Hab' überlegt, ob die zurückgegebenen 16 Bit
> vielleicht vertauscht sind, weil der Sender die 'andersrum' im Speicher
> ablegt.

Liefert denn uart_getc einen 16-Bit-Wert? Das wäre für eine UART sehr 
ungewöhnlich.

[Fabian O. (xfr)]

> Liefert denn uart_getc einen 16-Bit-Wert? Das wäre für eine UART sehr
> ungewöhnlich.

Steht zumindest im Kommentar:

/*
* Get received character from ringbuffer
* uart_getc() returns in the lower byte the received character and 
* in the higher byte (bitmask) the last receive error
* UART_NO_DATA is returned when no data is available.
*/

UART_NO_DATA ist wahrscheinlich -1, um kompatibel zu EOF aus stdio.h zu 
sein. Irgendwie muss man ja kodieren, ob ein neues Zeichen empfangen 
wurde oder nicht, wenn uart_getc() nicht blockieren soll.

[J.-u. G. (juwe)]

Rufus Τ. Firefly schrieb:
> Liefert denn uart_getc einen 16-Bit-Wert? Das wäre für eine UART sehr
> ungewöhnlich.

Ja, bei der Fleury-Lib ist das so. Das obere Byte enthält den 
Fehlercode, z.B. wenn kein Zeichen gelesen wurde (UART_NO_DATA). Dieser 
Fehlercode sollte nach Aufruf von uart_getc geprüft werden. Das hat der 
TO wohl versäumt.

[Fabian O. (xfr)]

Fabian O. schrieb:
> UART_NO_DATA ist wahrscheinlich -1, um kompatibel zu EOF aus stdio.h zu
> sein.

Oder auch nicht ...

#define UART_NO_DATA 0x0100 /* no receive data available */

Jedenfalls wäre es dann sinnvoll, das obere Byte nicht auszumaskieren. 
Denn im Fehlerfall oder bei keinen Daten kann ja alles mögliche im 
unteren Byte stehen:

if (ch == 'A') ruleTheWorld();

[Ralf G. (ralg)]

Ralf G. schrieb:
> Steht das 'A' dann nicht im High-Byte?

War total auf dem Holzweg :-( Die 16 Bit kommen ja nicht über UART 
rein...

[Terra (Gast)]

Ja, uart_getc liefert einen 16-bit Wert, genau wie ihr erkannt habt 
verwende ich die Fleury-Lib. (Darum habe ich den Kommentar mit Hinweis 
auf 16-bit mitkopiert.)

Die Fehlerbehandlung funktioniert, auch das "Echo" der Zeichen 
funktioniert, nur das Abfangen von einem String z.B. "VERSION" will 
nicht funktionieren.

if(ch == 'A'){
    uart_putcs("hello"); // Mein Aufruf
}else{
    uart_putc(ch); // Echo
}

Wie gesagt das "hello" wird nicht geschickt, das Echo funktioniert.

Ich werde mich noch weiter mit dem Problem beschäftigen.

DANKE

[J.-u. G. (juwe)]

Terra schrieb:
> uart_putcs("hello"); // Mein Aufruf

> Wie gesagt das "hello" wird nicht geschickt,

Kein Wunder, die Stringsendefunktion heißt uart_puts(...).

[Fabian O. (xfr)]

Wenn Du das Echo so schreibst, musst Du allerdings vorher das High-Byte 
geprüft haben, ob überhaupt etwas empfangen wurde! Sonst sendest Du 
ständig etwas.

Die Funktion uart_putcs() gibt es übrigens nicht in der Fleury-Lib ... 
Am besten postest Du mal den richtigen Code, dann kann man Dir bestimmt 
schnell sagen, wo der Fehler liegt.

[Terra (Gast)]

Fabian, hast recht, ich werde am besten den gesamten Code posten. (Das 
isupper() geht schon :-)

Aufruf:

uartRX = uart_getc();
processUartData((char)(uartRX&0x00FF));

Funktion:

void processUartData(char c){
  
  static char string[6];
  static uint8_t i=0;
  
  if(isupper(c)){  // process only upper case characters
      
    if (i<5 && c!='\r'){
      string[i]=c;
      i++;
    }else{
      if (strcmp(&string, "VER") == 0)
      {
        uart_puts("Version 1\n");
      }
      i = 0;
    }
    
  }else{
    switch (c)
    {
      case 'a': uart_puts("Hello World\n"); break;
      default: uart_putc( (unsigned char)uartRX );
    }
  }

Inzwischen geht das Erkennen der Großbuchstaben, aber bei der Eingabe 
"VER" möchte ich "Version 1" ausgeben.
Das schaffe ich irgendwie nicht.

DANKE,
Marc

[Helmut L. (helmi1)]

Terra schrieb:
> if (strcmp(&string, "VER") == 0)
>       {
>         uart_puts("Version 1\n");
>       }

strcmp  gibt 0 zurueck wenn gleich

du brauchst auch nicht &string zu schreiben sondern nur string.

[J.-u. G. (juwe)]

Terra schrieb:
> if (strcmp(&string, "VER") == 0)

strcmp erwartet 2 C-Strings. Dein char-Array "string" ist aber kein 
C-String (Nullterminierung fehlt).

[Sebastian W. (sebastian_w29)]

isupper('\r') ist nicht wahr.

[Helmut L. (helmi1)]

Sebastian W. schrieb:
> isupper('\r') ist nicht wahr.

Dann sag mit doch mal bitte den Grossbuchstaben von Carrige Return.
Das darf ja auch nicht wahr sein, ist ja kein Buchstabe.

[Patrick D. (oldbug)]

Genau!
Und damit hier:

    if (i<5 && c!='\r'){

die zweite Bedingung unnötig! :-)

[Fabian O. (xfr)]

Außerdem fehlt der Check, ob überhaupt Daten empfangen worden sind:

uartRX = uart_getc();
if ((uartRX & 0xFF00) == 0) {
  processUartData(uartRX);
}

Und uartRX hat an der Stelle nichts zu suchen:

default: uart_putc( (unsigned char)uartRX );

Da gehört hin:

default: uart_putc(c);

[Patrick D. (oldbug)]

Ich würde mir ausserdem noch zwei Funktionen zum Zerlegen der 
Bestandteile aus "uartRX" basteln:

int uart_geterror(int);

und

char uart_getchar(int);

Das erspart das mühselige Lesen der Bitmasken...

[Terra (Gast)]

Danke für euer Feedback.
Die Angeführten Fehler habe ich gleich ausgebessert und habe jetzt 
folgende Implementation:

void processUartData(char c){
  
  static char string[6];
  static uint8_t i=0;
  
  if(isupper(c)){  // process only upper case characters
      
    if (i<5){
      string[i]=c;
      i++;
      uart_puts("if works\n");
    }else{
      if (strcmp(string, "VER") == 0)
      {
        uart_puts("Version 1\n");
      }
      uart_puts("else works\n");
      i = 0;
      memset(string, 0, sizeof(string));
    }
    
  }else{
    switch (c)
    {
      case 'a': uart_puts("Hello World\n"); break;
      default: uart_putc(c);
    }
  }  
}  
int main(void)
{  
  io_init();
  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); 
  sei();
  while(1)
  {
    /*
         * Get received character from ringbuffer
         * uart_getc() returns in the lower byte the received character and 
         * in the higher byte (bitmask) the last receive error
         * UART_NO_DATA is returned when no data is available.
         *
         */
        uartRX = uart_getc();
        if ( uartRX & UART_NO_DATA )
        {
            /* 
             * no data available from UART 
             */
        }
        else
        {
            /*
             * new data available from UART
             * check for Frame or Overrun error
             */
            if ( uartRX & UART_FRAME_ERROR )
            {
                /* Framing Error detected, i.e no stop bit detected */
                uart_puts_P("UART Frame Error. No stop bit?");
            }
            if ( uartRX & UART_OVERRUN_ERROR )
            {
                /* 
                 * Overrun, a character already present in the UART UDR register was 
                 * not read by the interrupt handler before the next character arrived,
                 * one or more received characters have been dropped
                 */
                uart_puts_P("UART Overrun Error.");
            }
            if ( uartRX & UART_BUFFER_OVERFLOW )
            {
                /* 
                 * We are not reading the receive buffer fast enough,
                 * one or more received character have been dropped 
                 */
                uart_puts_P("Buffer overflow error.");
            }
      processUartData((char)(uartRX&0x00FF));           
        }
  }     
}

Wenn ich "VER" an den Controller sende bekomme ich als Feedback:
if works
if works
if works

Wenn ich ein zweites Mal "VER" schicke bekomme ich:

if works
if works
else works

Cool, so weit war ich noch nie. Leider noch nicht am Ziel.

Was meint ihr?

Lg,
Marc

[J.-u. G. (juwe)]

Terra schrieb:
> Wenn ich "VER" an den Controller sende bekomme ich als Feedback:
> if works
> if works
> if works
>
> Wenn ich ein zweites Mal "VER" schicke bekomme ich:
>
> if works
> if works
> else works

Ja klar. So hast Du es programmiert. Fünf mal "if works" bekommst Du, 
weil Deine Abfrage

Terra schrieb:
> if (i<5)

genau 5 mal wahr ist. Beim Empfang des zweiten "R" wird diese Bedingung 
unwahr und der else-Zweig wird ausgeführt. Es wird also eine Vergleich 
zwischen Deinem char-Array "string" mit dem Inhalt "VERVE" und dem 
char-Array "VER\0" ausgeführt. Diese beiden Arrays sind ungleich (strcmp 
liefert nicht 0). Folglich kommt die Ausgabe "else works".

[Patrick D. (oldbug)]

strcmp benötigt die null-Terminierung vor dem Aufruf!

[Stefan E. (sternst)]

Patrick Dohmen schrieb:
> strcmp benötigt die null-Terminierung vor dem Aufruf!

Die ist vorhanden, denn als statische Variable wird 'string' komplett 
mit 0 initialisiert (was natürlich nicht heißt, dass eine explizite 
Null-Terminierung im Code nicht sinnvoll wäre).

[Terra (Gast)]

Danke, jetzt geht es endgültig!!!
Ich bin glücklich :-)

  static char string[4];
  static uint8_t i=0;
  
  if(isupper(c)){  // process only upper case characters
      
    if (i<4){
      string[i]=c;
      string[i+1]='\0';
      i++;
      
      if (strcmp(string, "VER") == 0)
      {
        uart_puts("Version 1\n");
      }
      
    }else{
      i = 0;
      memset(string, 0, sizeof(string));
    }
    
  }else{
}

Ihr hattet alle recht.

Schönen Abend noch,
Marc

[Patrick D. (oldbug)]

Ich dachte dabei auch eher an die Zeile:

memset(string, 0, sizeof(string));

...

[Karl H. (kbuchegg)]

Meine Meinung:

Die Dinge trennen

* eine Zeile empfangen, wobei Zeile definiert ist als eine Abfolge von 
Zeichen, bis zum abschliessenden \r (oder \n)
* ist die Zeile vollständig, dann wird sie ausgewertet, indem sie zb mit 
einer Liste von SChlüsselwörtern verglichen wird.

Zum einen erhält man so bessere in sich abgeschlossene Einheiten. Zum 
anderen fehlt ja in deinem Programm auch noch eine Möglichkeit, wie zb 
ein Benutzer eine Fehleingabe korrigieren kann, in dem er zb mit 
Backspace das zuletzt eingegebene Zeichen wieder zurücknimmt. Oder 
machst du keine Tippfehler?


Und noch ein kleiner Hinweis.
Es ist nett, wenn du dir "if works" etc. ausgeben lässt. Aber wenn ich 
Probleme mit einem Vergleich habe, dann würde ich mir einfach mal den 
STring mit dem ich vergleiche ausgeben lassen :-)

[Karl H. (kbuchegg)]

Terra schrieb:
> Danke, jetzt geht es endgültig!!!

Aber nur zufällig.

>   static char string[4];

>     if (i<4){

d.h. i kann den Wert 3 annehmen

>       string[i]=c;
>       string[i+1]='\0';

Damit greifst du hier auf string[4] zu. string[4] existiert aber nicht.

[Terra (Gast)]

Karl Heinz, guter Punkt den falschen String auszugeben, macht Sinn :-)
Die Größe des Arrays habe ich auch noch um eines erhöht. Alle Befehle 
sollen aus exakt 3 Zeichen bestehen. Das funktioniert schon ganz gut.

DANKE