Protokoll über Uart

[Peter (Gast)]

Hallo Zusammen!

Trotz langem probieren und noch viel längerem Suchen wende ich mich an 
euch und erbitte eure Hilfe.

Ich sende von einem Arduino Board an einen Atmega8 mittels Uart Char und 
zwar in folgender Form:


Startbyte (Ascii 50)
Datenlänge (Ascii 51-60)
ID-Byte (Ascii 61 bis 99)
Datenbyte 1 (Ascii 100 bis 200)
Datenbyte 2 (Ascii 100 bis 200)
Datenbyte 3 (Ascii 100 bis 200)
....
Datenbyte n (Ascii 100 bis 200)
Checksum (noch nicht implementiert --> Ascii 0)
Endbyte (Ascii 250)

Vom Arduino wird in Abständen von ca. 100ms gesendet.

Ziel ist es, Basierend auf dem ID Byte verschiedene Daten zu senden. ID 
61 sollte z.B. ADC Informationen des Arduinos übertragen, die dann vom 
ATmega8 verarbeitetet werden. Der ATmega8 sendet NIE an das Arduino 
Board zurück.

Ich verwende die Uart Routine von Peter Fleury.

Ich hab mir das abarbeiten der Daten am µC wie folgt vorgestellt:
- Auslesen aus dem Ringbuffer so lange, bis ein Startbyte erhalten wird.
- Dann die Datenlänge, ID Byte und die Datenbytes in ein Array 
schreiben.
- Warten bis das Endbyte kommt.
- Befehl verarbeiten.

In meinen Programm sieht das wie folgt aus (bist jetzt ist nur das 
Schreiben auf ein LCD Display mit der Befehl ID 51 eingeführt)

#ifndef F_CPU
#define F_CPU 7372800UL
#endif

#ifndef UART_BAUD_RATE
#define UART_BAUD_RATE 4800
#endif

#include <stdlib.h>
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include "lcd-routines.h"
#include "uart.h"

const unsigned int cell_MAG_output = 9;
const unsigned int cell_MOT_output = 9;
const unsigned int cell_PELT_output = 7;
const unsigned int cell_MOT2_output = 17;
const unsigned int cell_T_Ist_output = 16;
const unsigned int cell_pump_output = 17;

const unsigned int Uart_STX =50;
const unsigned int Uart_ID = 51;
const unsigned int Uart_ETX = 254;
const unsigned int Uart_ADC_offset = 100;
const unsigned int Uart_LEN_offset = 61;

void WriteLCD (int *val_array);
void GetSignal (int *val_array);

int main(void)
{

  int cmd_val[10];
  
  sei();      //Interrupts enabled
  lcd_init();
  uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
  lcd_string("Starte");
    while(1)
    {  
    GetSignal(cmd_val);

    WriteLCD(cmd_val);
    }

}

Also, mit der Funktion GetSignal(int *val_array) möchte ich den 
Ringbuffer nach einer gesendeten Befehlskette überprüfen.

void GetSignal (int *val_array) {
  unsigned int c;
  unsigned int counter = 0;
    
    //Suchen nach StartByte
    do 
    {
      c = uart_getc();
    } while (c != Uart_STX);
    
    lcd_string("Start gefunden");

    //Informations Bytes einholen
    counter = 0;

    do 
    {
      c = uart_getc();
      val_array[counter] = c;
      counter ++;
    } while (c != Uart_ETX);
    lcd_string("Ende");     //DIESER PUNKT WIRD NIE ERREICHT

}

Das Problem: Ich komme aus der 2ten Schleife (c != Uart_ETX) nie mehr 
heraus! Ich hab schon mit nem LogicAnalyser überprüft, ob das Endbyte 
kommt. Und es wird wirklich gesendet.

Ich finde Einfach den Fehler nicht!
Ihr seid meine letzte Hoffnung, bevor ich noch durchdreh :)

Vielen Dank im Voraus!
lg Peter

[Karl H. (kbuchegg)]

Peter schrieb:

>       c = uart_getc();

Sieh dir bitte das Beispiel an, welches P. Fleury seinen UART Routinen 
beigelegt hat.
In a Nutshell: Du kannst nicht einfach hergehen und den Returnwert von 
uart_getc() so direkt verwenden!

uart_getc() wartet nicht, bis ein Zeichen auf der UART vorliegt. Wenn 
nichts da ist, dann kommt uart_getc() sofort zurück und meldet 
pflichtbewusst: Ich hab nichts.

Du jedoch gehst in deinem Code her und ignorierst das. Du tust so, als 
ob du jedesmal wenn uart_getc() zurückkommt ein Zeichen hättest.

Und da du dieses machst, bügelst du dir hier

>       val_array[counter] = c;
>       counter ++;

in weiterer Folge den Speicher nieder. Irgendeinen Speicher. Speicher, 
den du nicht niederbügeln dürftest, der nicht zu deiner Variablen 
gehört.

Ab dem Zeitpunkt werden dann keine Wetten mehr angenommon, was in deinem 
Programm alles passiert oder nicht passiert. Wenn dein fehlerhaftes 
Programm aktiv den Speicher sabotiert, sind alle Wetten sinnlos. Alles 
kann passieren.


> bevor ich noch durchdreh

Nicht durchdrehen!
Statt dessen die Funktionsdoku lesen und das beigelegte Beispiel 
studieren!

[Amateur (Gast)]

@Peter

>Checksum (noch nicht implementiert --> Ascii 0)

...ist das Wirklich sinnvoll, wenn der Empfänger sowieso nicht 
antwortet?