Struct per Uart Senden

[fridrich (Gast)]

Hallo Freunde,
ich sitze vor einem Problem, ich möchte eine Structur per Uart Versenden 
aber es klappt nicht.

volatile struct
{
  char start;
  uint8_t len;
  double Temp_array[3] ;
  char end;
}proto, Proto;

Proto.start=0x02;
Proto.end=0x03;
Proto.len= sizeof(Proto.Temp_array);

void Transmit(void *cData,uint8_t len)
{
  while(len-- > 0)
  {
    uart_putc( *(char *)cData);  // shift out data
    cData++;
  }

}
void main(int)
{
     while(1)
    {
    _delay_ms(500);
    Transmit(Proto.start,sizeof(Proto));
    }
}

Leider kommt nur Müll aus der Uart raus .
Die Uart Fuktion von Peter Fleury fuktioniert sonst bestens es liegt 
also an meiner  Trasmit Funktion.
Ich komme aber nicht auf den Fehler Bitte helft mir !

Danke gruß
Fridrich

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Der UART versendet einzelne Bytes.

also die struct in Bytes zerlegen, die einzeln übertragen und
dann beim Empfänger wieder passend zusammenbauen.

Senden in etwa so:

unsigned char *p;

for ( p=(unsigned char *) &Proto; (p - (unsigned char *) &Proto) < sizeof(Proto); p++)
  uart_putchar( *p);

[holger (Gast)]

void Transmit(uint8_t *cData,uint8_t len)
{
  while(len-- > 0)
  {
    uart_putc(cData);  // shift out data
    cData++;
  }

}


Transmit(Proto,sizeof(Proto));

[Joachim D. (Firma: JDCC) (scheppertreiber)]

> uart_putc(cData);

;-)

> uart_putc(*cData);

[holger (Gast)]

>;-)
>
>> uart_putc(*cData);

Ok!

[Konrad S. (maybee)]

fridrich schrieb:
> cData++;
Besser:

 ((char *)cData)++;

damit klar ist, dass der Pointer um ein Byte erhöht werden soll.

fridrich schrieb:
> Transmit(Proto.start,sizeof(Proto));
So:

 Transmit(&Proto.start,sizeof(Proto));

oder besser:

 Transmit(&Proto,sizeof(Proto));

weil die Adresse der Struktur gemeint ist.

Bedenklich ist:
fridrich schrieb:
> volatile struct
was darauf hindeutet, dass die Inhalte der Struktur aus einer ISR heraus 
modifiziert werden. Wenn das mitten in der Übertragung passiert, dann 
empfängst du evtl. inkonsistente Daten.

[Frank M. (ukw) (Moderator)]

fridrich schrieb:
> Hallo Freunde,
> ich sitze vor einem Problem, ich möchte eine Structur per Uart Versenden
> aber es klappt nicht.

Bedenke, dass die Datenstruktur auf Quell- und Zielsystem verschieden 
aufgebaut sein kann. Das fängt mit dem Alignment an und geht dann über 
den CPU-Endian bis hin zum (möglich verschiedenen) Format eines 
double-Wertes.

Eine portable Übertragung geht nur über eine ASCII-Präsentation der 
einzelnen Struct-Member.

[Rolf Magnus (Gast)]

Konrad S. schrieb:
> fridrich schrieb:
>> cData++;
> Besser: ((char *)cData)++;
> damit klar ist, dass der Pointer um ein Byte erhöht werden soll.

Nein. Das ergibt einen Fehler, da man das Ergebnis eines Casts nicht 
inkrementieren kann. Wäre auch irgendwie sinnlos.

Noch so am Rande:

fridrich schrieb:
> void main(int)

Das gehört umgedreht:

int main(void)

[Konrad S. (maybee)]

Rolf Magnus schrieb:
> Nein. Das ergibt einen Fehler, da man das Ergebnis eines Casts nicht
> inkrementieren kann. Wäre auch irgendwie sinnlos.

Ok, das sehe ich ein. Scheint so, als hätte ich so eine Konstruktion 
noch nie eingesetzt seit der gcc das überprüft. Erstaunlich.

[Joachim D. (Firma: JDCC) (scheppertreiber)]

Konrad S. schrieb:
> Ok, das sehe ich ein. Scheint so, als hätte ich so eine Konstruktion
> noch nie eingesetzt seit der gcc das überprüft. Erstaunlich.

Das ist bestimmt der Optimierung zum Opfer gefallen ;)

[fridrich (Gast)]

Vielen Dank für Eure Hilfe  jetzt klappt es!

[Veit D. (devil-elec)]

Hallo,

ich muss das nochmal aufwärmen. Ich hänge am gleichen Problem, kann 
lesen wie ich möchte, ich weiß nicht wo der Fehler liegt. Der Datentyp 
passt nicht. So verstehe ich das jedenfalls. Nur was muss ich anders 
machen? Kann mir bitte jemand helfen? Ich nutze ebenfalls die uart Lib 
vom Peter Fleury.

struct Nachricht {
  uint8_t adress = 0;
  uint8_t function = 0;
  uint8_t wert = 0;
} message;

Deklaration:

void sendStruct(uint8_t *structPtr, uint8_t length);

Aufruf:

message.adress = 78;
message.function = 135;
message.wert = 207;
sendStruct(&message, sizeof(message));

Funktion:

void sendStruct(uint8_t *structPtr, uint8_t length)
{   
  while(length-- > 0)
  {
    uart_putc(*structPtr);  // Bytes rausschieben
    structPtr++;
  }
}

Fehlermeldungen:  die Zeile 534 bezieht sich auf den Aufruf

Fehler
cannot convert 'Nachricht*' to 'uint8_t* {aka unsigned char*}' for argument '1' to 'void sendStruct(uint8_t*, uint8_t)'  
C:main.cpp  534
Fehler
recipe for target 'main.o' failed
Makefile  86

Warnung
non-static data member initializers only available with -std=c++11 or -std=gnu++11  
main.cpp  130
Warnung
non-static data member initializers only available with -std=c++11 or -std=gnu++11  
main.cpp  131
Warnung
non-static data member initializers only available with -std=c++11 or -std=gnu++11  
main.cpp  132

[Franz (Gast)]

sendStruct erwartet einen Zeiger auf uint8_t, Du übergibst aber einen 
Zeiger auf struct Nachricht. Du musst also irgendwo den Zeiger auf 
struct Nachricht in einen Zeiger auf uint8_t konvertieren aka "casten".

Du hast zwei Möglichkeiten:
1. Du konvertierst den Zeiger vor dem Aufruf von sendStruct.
2. Du änderst die Funktion sendStruct, so dass sie einen Zeiger auf 
struct Nachricht nimmt statt auf uint8_t. Dann musst Du den Zeiger 
innerhalb von sendStruct konvertieren. Aber Vorsicht: Sowohl der Zeiger, 
den Du an uart_putc übergibst, als auch der Zeiger, der in der Schleife 
inkrementiert wird, muss von Typ uint8_t sein.

Die Warnungen gehen weg, wenn Du das "= 0" in der Deklaration von struct 
Nachricht weglässt.

PS: Der Mischmasch aus Deutsch und Englisch im Code liest sich 
grauenvoll.

[Veit D. (devil-elec)]

Hallo,

wegen den Warnungen. Seit wann darf man die Structur Variablen nicht 
initialisieren?

deutsch englisch, ich weiß immer nicht wie ich die sinnvoll benennen 
soll.

Typcast habe ich jetzt im Funktionsaufruf gemacht. Danke.

struct Nachricht {
  uint8_t adresse;
  uint8_t funktion;
  uint8_t wert;
} daten;

Deklaration:

void sendStruct(uint8_t *structPtr, uint8_t length);

Aufruf:

daten.adresse = 78;
daten.funktion = 135;
daten.wert = 207;
sendStruct((uint8_t*)&daten, sizeof(daten));

Funktion:

void sendStruct(uint8_t *structPtr, uint8_t length)
{   
  while(length-- > 0)
  {
    uart_putc(*structPtr);  // Bytes rausschieben
    structPtr++;
  }
}

es wird alles fehlerfrei kompiliert.
Leider aber!
Statt der ersten 78 wird ein N übertragen. Übertragen wird
N  '135'  '207'
Ändere ich die Daten, ist immer wieder der erste Wert falsch.
Was ist da los?

[Veit D. (devil-elec)]

Hallo,

ähm Moment, dass ist ja der ascii Code ...
Nur dann ergeben sich doch Probleme die Daten überhaupt richtig zu 
übertragen?

[Franz (Gast)]

Veit D. schrieb:
> Hallo,
>
> wegen den Warnungen. Seit wann darf man die Structur Variablen nicht
> initialisieren?

Das darf und durfte man in C in der Form, wie Du es hingeschrieben hast, 
noch nie. In C++ darf man es seit C++11.

Es geht aber folgendermaßen:

struct Nachricht {
  uint8_t adresse;
  uint8_t funktion;
  uint8_t wert;
} daten = {0, 0, 0};

Oder wenn man Deklaration und Definition trennt:

struct Nachricht {
  uint8_t adresse;
  uint8_t funktion;
  uint8_t wert;
};

struct Nachricht daten = {0, 0, 0};

Oder kürzer, aber gleichbedeutend:

struct Nachricht daten = {0};

> Leider aber!
> Statt der ersten 78 wird ein N übertragen. Übertragen wird
> N  '135'  '207'
> Ändere ich die Daten, ist immer wieder der erste Wert falsch.
> Was ist da los?

Na dann passt es doch. 'N' ist gleichbedeutend mit 78, siehe 
ASCII-Tabelle. Wenn Du den Zahlenwert sehen willst, musst Du die 
Formatierung der Ausgabe auf Empfängerseite umstellen.

[Veit D. (devil-elec)]

Hallo,

okay, vielen Dank.