Char Array über USART Empfangen und vergleichen

[Markus P. (sebastianwurst)]

Hallo,
ich will eine Variablenfolge die z.B so aussieht 99|33|01|01 über die 
serielle Schnittstelle zum Mikrocontroller schicken und im Mikro dann 
das Empfangene auf Gleichheit vergleichen.

Im Moment mache ich das so:

char ReceiveSerial[40];
char Lr99110101[]  = "99|11|01|01";

// Zeichen Empfangen wenn was anliegt
if ((UCSR0A & (1<<RXC0)))
    {   
  
  uart_gets(ReceiveSerial, sizeof( ReceiveSerial));
  
  USART_Transmit(); // Kontrolle zum Terminalprogramm


     if (!strcmp(ReceiveSerial,Lr99110101)) 
   {  
  
  stopbit = false;
  }

}

Das ist das uart_gets()

/*String empfangen*/
void 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 '\0'kam
                                  // * oder das aufnehmende Array voll ist
  while( NextChar != '\r'  && StringLen < MaxLen - 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  } 
                                  // Noch ein '\0' anhängen um einen Standard
                                  // C-String daraus zu machen
  *Buffer = '\0';
}

Funktionieren tut das, doch merke ich das die uart_gets() unglaublich 
viel Zeit beansprucht, da andere Funktionen ins stocken geraten.
Wie könnte ich denn auch eleganter dieses char Array auf Gleichheit 
abfragen ohne eine Funktion zu benutzen die das mit eine Stringfunktion 
macht?

Vielen Dank für die Tips....

[Daniel V. (danvet)]

1.) UART Receive Interrupt verwenden
ODER
2.) while-schleife abbrechen, wenn z.B. 10ms kein Zeichen gekommen ist. 
Wenn allerdings ein Zeichen kommt, dann alle einlesen, bis '\r'. Sonst 
wartest du bis auf den St.Nimmerleinstag auf deinen String

[Matthias H. (experimentator)]

Hallo Markus,

Deine Empfangsfunktion bringt wahrscheinlich deshalb den Rest ins 
Stocken, weil es je nach Baudrate, Sendegeschwindigkeit/-frequenz der 
Gegenseite und Länge der Nachricht ein paar Millisekunden oder länger 
dauern kann, bis die Nachricht gelesen wurde.
Die Abhilfe geht in die Richtung, die Daniel geschrieben hat. Falls das 
nicht möglich ist, müßtest Du während des Empfangens hin und wieder eine 
Funktion aufrufen, die die anderen gewünschten Funktionen ausführt, so 
eine Art Miniatur-Scheduler.

Zum Stringvergleich:
In diesem Fall ist der in Ordnung, anders geht es auch nicht schneller. 
Wenn Du mit mehreren anderen Strings vergleichen willst, dann solltest 
Du Dir einen Zustandsautomaten schreiben, der mit jedem Zeichen 
weitergesetzt wird oder Dich mal mit String-Matching-Algorithmen 
beschäftigen 
(http://en.wikipedia.org/wiki/Category:Algorithms_on_strings, 
http://de.wikipedia.org/wiki/String-Matching-Algorithmus).

[Markus P. (sebastianwurst)]

Danke schonmal.

Kann mir vielleicht einer ein Tipp geben und zwar will ich diese 
Variable:

char Codetest2[]  = {'29','34','41','52'};

per RS232 ohne eine String Funktion übertragen. Also einfach nur per 
Zahl. Wie ist da der beste Weg? Ich habe folgende Funktionen zur 
Verfügung (s. Unten), gerne nehme ich dann auch noch Beispiele entgegen.
DAs Problem welches ich einfach habe ist das ein char nur 1 Zeichen sein 
darf, also bei der erste Ziffer mit 29 würde mit der usart_write_char 
Funktion nur eine 9 übertragen.
Wie stelle ich das am besten an das nachher "29344152" auf meinem 
Terminal steht?

Vielen Dank.

void usart_write_char(char c)
{
#if CMD_TELNET
  if(usart_status.usart_disable)
  {
        if(rx_buffer_pointer_in == (rx_buffer_pointer_out - 1))
        {
            //Datenverlust
                    telnetd_send_data ();
                    while(telnetd_status.ack_wait)
                    {
                        eth_get_data();
                    }
        }

        *rx_buffer_pointer_in++ = c;

        if (rx_buffer_pointer_in == &usart_rx_buffer[BUFFER_SIZE-1])
        {
            rx_buffer_pointer_in = &usart_rx_buffer[0];
        }
    }
    return;
#else
    #if !USE_CAM
        if(!usart_status.usart_disable)
        {
            //Warten solange bis Zeichen gesendet wurde
            while(!(USR & (1<<UDRE)));
            //Ausgabe des Zeichens
            UDR = c;
        }
        return;
    #endif //USE_CAM
#endif
}

//------------------------------------------------------------------------------
void usart_write_P (const char *Buffer,...)
{
  va_list ap;
  va_start (ap, Buffer);  
  
  int format_flag;
  char str_buffer[10];
  char str_null_buffer[10];
  char move = 0;
  char Base = 0;
  int tmp = 0;
  char by;
  char *ptr;
    
  //Ausgabe der Zeichen
    for(;;)
  {
    by = pgm_read_byte(Buffer++);
    if(by==0) break; // end of format string
            
    if (by == '%')
    {
            by = pgm_read_byte(Buffer++);
      if (isdigit(by)>0)
        {
                                 
         str_null_buffer[0] = by;
        str_null_buffer[1] = '\0';
        move = atoi(str_null_buffer);
                by = pgm_read_byte(Buffer++);
        }

      switch (by)
        {
                case 's':
                    ptr = va_arg(ap,char *);
                    while(*ptr) { usart_write_char(*ptr++); }
                    break;
        case 'b':
          Base = 2;
          goto ConversionLoop;
        case 'c':
          //Int to char
          format_flag = va_arg(ap,int);
          usart_write_char (format_flag++);
          break;
        case 'i':
          Base = 10;
          goto ConversionLoop;
        case 'o':
          Base = 8;
          goto ConversionLoop;
        case 'x':
          Base = 16;
          //****************************
          ConversionLoop:
          //****************************
          itoa(va_arg(ap,int),str_buffer,Base);
          int b=0;
          while (str_buffer[b++] != 0){};
          b--;
          if (b<move)
            {
            move -=b;
            for (tmp = 0;tmp<move;tmp++)
              {
              str_null_buffer[tmp] = '0';
              }
            //tmp ++;
            str_null_buffer[tmp] = '\0';
            strcat(str_null_buffer,str_buffer);
            strcpy(str_buffer,str_null_buffer);
            }
          usart_write_str (str_buffer);
          move =0;
          break;
        }
      
      }  
    else
    {
      usart_write_char ( by );  
    }
  }
  va_end(ap);
}

//----------------------------------------------------------------------------
//Ausgabe eines Strings
void usart_write_str(char *str)

{
  while (*str)
  {
    usart_write_char(*str++);
  }  
}

void USART_Transmit( unsigned char data )
{
/* Wait for empty transmit buffer */
while ( !( UCSR0A & (1<<UDRE0)) )
;
/* Put data into buffer, sends the data */
UDR0 = data;
}

/* puts ist unabhaengig vom Controllertyp */
void uart_puts (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen" */
        USART_Transmit(*s);
        s++;
    }
}

[Markus P. (sebastianwurst)]

Matthias H. schrieb:
> Hallo Markus,
>
> Deine Empfangsfunktion bringt wahrscheinlich deshalb den Rest ins
> Stocken, weil es je nach Baudrate, Sendegeschwindigkeit/-frequenz der
> Gegenseite und Länge der Nachricht ein paar Millisekunden oder länger
> dauern kann, bis die Nachricht gelesen wurde.
> Die Abhilfe geht in die Richtung, die Daniel geschrieben hat. Falls das
> nicht möglich ist, müßtest Du während des Empfangens hin und wieder eine
> Funktion aufrufen, die die anderen gewünschten Funktionen ausführt, so
> eine Art Miniatur-Scheduler.
>


Ich merke es auch beim Empfangen, also da passiert auch irgendetwas 
zeitkritisches...

[Matthias H. (experimentator)]

Hallo Markus,

> Ich merke es auch beim Empfangen, also da passiert auch irgendetwas
> zeitkritisches...

Das kannst Du ausrechnen. Nehmen wir an, Du benutzt eine Baudrate von 
9600 und die Einstellungen 8N1 (8 Bits, keine Parität, 1 Stoppbit). Dann 
werden pro Zeichen 9 Bits plus Startbit übertragen, also max. 960 
Zeichen pro Sekunde. Deine Nachricht ist anscheinend 12 Zeichen lang. 
Also dauert die Übertragung mindestens 1/80 Sekunde, also 12,5 ms. Falls 
Dein Sender langsamer sendet, mit Pausen zwischen den Zeichen, oder 
Deine Empfangsfunktion aus irgendeinem Grund noch viel Rechenleistung 
verbrät, dann dauert es entsprechend länger.

[Karl H. (kbuchegg)]

Markus P. schrieb:
> Danke schonmal.
>
> Kann mir vielleicht einer ein Tipp geben und zwar will ich diese
> Variable:
>
>

> char Codetest2[]  = {'29','34','41','52'};
>

>
>
> per RS232 ohne eine String Funktion übertragen. Also einfach nur per
> Zahl. Wie ist da der beste Weg? Ich habe folgende Funktionen zur
> Verfügung (s. Unten), gerne nehme ich dann auch noch Beispiele entgegen.
> DAs Problem welches ich einfach habe ist das ein char nur 1 Zeichen sein
> darf, also bei der erste Ziffer mit 29 würde mit der usart_write_char
> Funktion nur eine 9 übertragen.
> Wie stelle ich das am besten an das nachher "29344152" auf meinem
> Terminal steht?

Indem du damit anfängst erst mal das Array richtig zu definieren und zu 
initialisieren.

uint8_t Codetest2[] = { 29, 34, 41, 52 };

Du willst Zahlen speichern. Also ist schon mal char kein geeigneter 
Datentyp dafür. Gewöhn dir an, char ausschliesslich für echte Zeichen 
(also 'A', 'B', 'C'...) bzw. in Arrayform für Strings ("Hallo") zu 
benutzen.


und dann schreibst du dir eine Funktion, die eine Zahl ausgeben kann.

void usart_write_uint8( uint8_t nr )
{
  char buffer[6];

  itoa( nr, buffer, 10 );
  usart_write_str( buffer );
}

mit dieser Hilfsfunktion schreibst du dir eine weitere Funktion, die ein 
Array von Zahlen ausgeben kann

void usart_write_uint8Array( uint8_t size, uint8_t numbers )
{
  uint8_t i;

  for( i = 0; i < size; i++ )
    usart_write_uint8( numbers[i] );
}

und die benutzt du dann um dein ursprüngliches Array auszugeben

#define ARRAY_SIZE(x)  (sizeof(x)/sizeof(*x))

int main()
{
  .....


  usart_write_uint8Array( ARRAY_SIZE( Codetest2 ), Codetest2 );
}

Das Geheimnis beim Programmieren besteht nicht darin, sich für jeden 
Pfurz immer wieder möglichst komplizierte neue Funktionen einfallen zu 
lassen. Das Geheimnis besteht darin, sich mit Basisfunktionen und darauf 
aufbauenden Hilfsfunktionen letztendlich bis zu der Ebene 
hochzuarbeiten, mit der man sein Problem lösen kann.

[Matthias H. (experimentator)]

> char Codetest2[]  = {'29','34','41','52'};

Das funktioniert so natürlich nicht, falls es überhaupt durch den 
Compiler geht.

Du hast im wesentlichen folgende Möglichkeiten, falls Du nicht was 
völlig eigenes basteln möchtest:

- Du überträgst zeichenweise (+ Nullbyte o. ä. als Endemarkierung). Da 
braucht man dann nichts umzucodieren.

char Codetest2[]  = "29344152";

- Du überträgst zeichenweise binär. Dann mußt Du irgendein Zeichen außer 
der 0 als Endezeichen festlegen. Ist aber ineffizient.

- Du überträgst in BCD-Codierung 
(http://de.wikipedia.org/wiki/BCD-Code) binär. Dabei werden 2 Ziffern in 
ein Byte gepackt, was effizienter ist als zeichenweiser Versand.

BCD geht ungefähr so (mit ungültiger Ziffer als Endemarkierung):

char Codetest2[]  = {0x29, 0x34, 0x41, 0x52, 0xf0};

- Du überträgst binär. Dann mußt Du festlegen, welchen Datentyp Du 
verwenden möchtest, z. B. 4-Byte-Integer mit Vorzeichen, und mußt auf 
die Byte Order achten, also in welcher Reihenfolge der Prozessor die 
einzelnen Datenbytes, die die Variable bilden, im Speicher anordnet. Es 
ist Network Byte Order = "Big Endian" empfehlenswert. Siehe Funktionen 
htonl()/ntohl() usw. der Standardbibliothek, soweit vorhanden.

- Wenn Du kompliziertere Datenstrukturen übertragen möchtest, so wäre es 
eine Überlegung wert, sich mal Google Protocol Buffers oder andere 
Standardverfahren anzusehen (wobei Protocol Buffers wahrscheinlich zu 
groß für Deinen Mikrocontroller ist...).

[Markus P. (sebastianwurst)]

Vielen Dank Karl-Heinz du hast mir sehr weiter geholfen!!!!
Mein Problem wird nur auch noch das sein was der Matthias mir schon sehr 
gut vorgerechnet hat. Ich betreibe auf den gleichen yc auch noch einen 
Phasenanschnitt und da muss ich alle paar ms einen Triac ansteuern, da 
kann ich mir keinen Zeitverlust  gönnen. Jetzt weiß ich garnicht wie ich 
das machen kann ohne den Phasenanschnitt zu beeinflussen ? Hättest du 
(ihr) da auch vielleicht eine Idee ?
Vielen super dank schonmal ...

[Karl H. (kbuchegg)]

Regelmässige Dinge tun?
ganz klar: ein Fall für einen Timer.

[Matthias H. (experimentator)]

Hallo Markus,

Markus P. schrieb:
> Mein Problem wird nur auch noch das sein was der Matthias mir schon sehr
> gut vorgerechnet hat. Ich betreibe auf den gleichen yc auch noch einen
> Phasenanschnitt und da muss ich alle paar ms einen Triac ansteuern, da
> kann ich mir keinen Zeitverlust  gönnen. Jetzt weiß ich garnicht wie ich
> das machen kann ohne den Phasenanschnitt zu beeinflussen ? Hättest du
> (ihr) da auch vielleicht eine Idee ?

Du mußt Dir überlegen, in welchem Zeitraster Du den Triac bedienen mußt, 
damit er funktioniert, wie Du willst und wieviel Zeit Dir zum Lesen der 
Nachricht übrig bleibt.

Falls die Funktion uart_getc() blockierend liest, mußt Du eine andere 
Möglichkeit finden.
Daniel V. hat ja dazu schon Anregungen geschrieben.

Interruptbetrieb heißt, daß der Schnittstellenbaustein einen 
Hardware-Interrupt auslöst, sobald ein Zeichen ankommt und dann eine 
Funktion aufgerufen wird, die das Zeichen z. B. in einen Buffer (am 
besten eine globale Variable) liest. Die Interruptfunktion sollte so 
wenig wie möglich machen, das heißt, das Prüfen, ob eine Nachricht 
vollständig gelesen wurde und die Verarbeitung sollten außerhalb des 
Interrupthandlers in der Hauptschleife gemacht werden. Es könnte noch 
weitere Nebenbedingungen geben, z. B. daß Funktionen der 
Standardbibliothek nicht aufgerufen werden dürfen oder so. Ob das von 
Deinem Mikrocontroller unterstützt wird und wie es geht, sollte in der 
Dokumentation stehen. Dazu sind noch ein paar Kleinigkeiten zu beachten, 
z. B. sollten die Interrupts abgeschaltet werden, während der Puffer in 
der Hauptschleife geleert wird, sonst gibt es undefiniertes Verhalten 
und Fehler.

Beim Lesen mit Timeout brauchst Du eine nichtblockierende Lesefunktion 
für die Schnittstelle und liest so lange, bis ein Timer zuende ist, z. 
B. 10 ms, oder die Nachricht komplett ist.

[Markus P. (sebastianwurst)]

Hab es jetzt mit einem Timer gelöst.

[Nn N. (jaytharevo)]

Markus P. schrieb:
>

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

Hey, dein Kommentar und dein Code passen nicht zusammen.
Das ist kein oder_ sondern ein _und.

[Daniel V. (danvet)]

Julian Schild schrieb:
> Markus P. schrieb:
>>

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

>
> Hey, dein Kommentar und dein Code passen nicht zusammen.
> Das ist kein oder_ sondern ein _und.

Aber es ist eine while-Abfrage. Er soll solange drin bleiben, wie BEIDE 
(also UND) Bedingungen erfüllt sind. Ist die eine ODER die andere 
Bedingung nicht mehr erfüllt, dann wird die Schleife beendet.