uart atoi fehlerhafte Zeichen

[Bernd (Gast)]

Hallo,
ich möchte über die Serielle Schnittstelle bestimmte Sachen steuern. 
Dazu schicken ich Zeichen über Putty an den AVR.
Die gesendeten Zeichen sind von 0 bis 4097.

Jeweils 255 Werte gehören zu einem Befehl.

void read_commands(void)
{
  if(uart_str_complete)
  {
    uart_str_complete = 0;
    
    int16_t incoming = atoi(uart_string);
    uint8_t command = incoming / 255;
    uint8_t value = incoming % 255;
    uart_puti(incoming);
    uart_puts(uart_string);
    
    uart_puts_P("\r\nBefehl : ");
    uart_puti_formatted(command);
    
    uart_puts_P("\tWert : ");
    uart_puti_formatted(value);
    
    uart_puts_P("\r\n");
  }
}

ISR(USART0_RX_vect)
{
  unsigned char nextChar;
  // Daten aus dem Puffer lesen
  nextChar = UDR0;

  // wenn uart_string gerade in Verwendung ist, neues Zeichen verwerfen
  if( uart_str_complete == 0 ) {
    
    // Daten werden erst in uart_string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
    if( nextChar != '\n' &&  nextChar != '\r' &&  uart_str_count < UART_MAXSTRLEN )
    {
      uart_string[uart_str_count] = nextChar;
      uart_str_count++;
    }
    else {
      uart_string[uart_str_count] = '\0';
      uart_str_count = 0;
      uart_str_complete = 1;
    }
  }
}

Mein Output sieht auf der Konsole aber nicht komplett richtig aus, ich 
habe der Reihe nach folgende Werte eingegeben und mit Enter bestätigt.

15, 255, 256,

05
Befehl :   0    Wert :   0
0▒55
Befehl :   0    Wert :   0
0"56
Befehl :   0    Wert :   0

[lrep (Gast)]

Bernd schrieb:
> Die gesendeten Zeichen sind von 0 bis 4097.

Mit 8 Bit?

Da wirst du nachsynchronisieren müssen, denn wenn ein Byte verloren 
geht, oder am Empfänger durch einen Störimpuls dazukommt, stimmt der 
ganze Rest nicht mehr.

[Peter II (Gast)]

lrep schrieb:
> Mit 8 Bit?
>
> Da wirst du nachsynchronisieren müssen, denn wenn ein Byte verloren
> geht, oder am Empfänger durch einen Störimpuls dazukommt, stimmt der
> ganze Rest nicht mehr.

er überträgt strings mit Zeilenumbruch. Das sollte schon passen.

[Bernd (Gast)]

Richtig, die Eingabe erfolgt als Zeichenkette und da sollte es noch 
keine Probleme geben. Es werden auf der UART Schnittstelle max. 6 
Zeichen eingelesen.

[Peter II (Gast)]

kannst du etwas mehr code zeigen? Es fehlt noch einiges. (initalisierung 
der Variablen usw.)

[lrep (Gast)]

Bernd schrieb:
> Die gesendeten Zeichen sind von 0 bis 4097.

Peter II schrieb:
> er überträgt strings mit Zeilenumbruch. Das sollte schon passen.

Dann muß er aber darauf achten, daß die Zeichenzahl gerade ist.
Falls ungerade, dann den ganzen String verwerfen, denn man weiß ja 
nicht, wo der Fehler passierte.
...oder die ungenutzen Bits zur Übertragung einer Sequenznummerr 
verwenden.

Fraglich auch, ob wirklich 0..4097 übertragen werden soll

[Peter II (Gast)]

lrep schrieb:
> Dann muß er aber darauf achten, daß die Zeichenzahl gerade ist.
> Falls ungerade, dann den ganzen String verwerfen, denn man weiß ja
> nicht, wo der Fehler passierte.
> ...oder die ungenutzen Bits zur Übertragung einer Sequenznummerr
> verwenden.

versteht ich nicht? Er überträgt genau eine Zahl die dann in 2 Byte 
umgerechnet wird.

[Bernd (Gast)]

Peter II schrieb:
> kannst du etwas mehr code zeigen? Es fehlt noch einiges.
> (initalisierung
> der Variablen usw.)

Hallo Peter,

ich hoffe du meinst das hier.


// aus der uart.h

#define UART_MAXSTRLEN  6
#define BAUD      19200

extern volatile uint8_t uart_str_complete;
extern volatile char uart_string[UART_MAXSTRLEN + 1];
extern volatile char c;

Ansonsten wüsste ich nicht, war hier noch interessant ist.

[Walter S. (avatar)]

Bernd schrieb:
> uart_str_complete = 0;

das solltest du erst machen wenn der String ausgewertet ist sonst machen 
einkommende Zeichen evtl. deinen String kaputt,

[Konrad S. (maybee)]

Wie sieht es denn mit uart_str_count aus? Da sind noch ein paar Fragen 
offen, die das beobachtete Verhalten erklären könnten.

[lrep (Gast)]

Peter II schrieb:
> Er überträgt genau eine Zahl die dann in 2 Byte
> umgerechnet wird.

Na ja, ich bin kein C-Programmierer, aber ich sehe da einen Wertebereich 
0..4097, der vermutlich in Wirklichkeit nur 0..4095 umfasst, und ich 
sehe da die Division durch seltsame 255, was vermutlich 256 sein soll.
Bei der Verwendung von LF oder CRLF terminierten Strings, sehe ich die 
Möglichkeit, dass die Falle schon zuschnappt, und der  Strings verhunzt 
wird, wenn an irgend einer Stelle des Strings eine dezimale 10 oder 13 
über die  Leitung rauscht.

[Klugschiss (Gast)]

lrep schrieb:
> wenn an irgend einer Stelle des Strings eine dezimale 10 oder 13
> über die  Leitung rauscht.

Dies kann aber nicht geschehen, da Zahlen von 0 - 4097 Übertragen werden 
sollen.
Daraus ergibt sich eine Nutzzeichenlänge von 1 - 4 Byte im Wertebereich 
von 0x30 - 0x39.