C -> UART -> Übertragen von Strukturen

[Jan H. (janiiix3)]

Nabend Profis ;)

mal eine generelle Frage an euch..
Ich habe z.B folgende Struktur.

typedef struct
{
   uint8_t uiParameter;
   uint8_t pKanal[10];
   uint32_t uiAddresse;
}Filter_t;

einfach mal als Beispiel jetzt..


Und dann gibt es die "0815" uart Funktion die einen Zeiger und die 
Anzahl der Daten entgegennimmt.

void uartPuts( uint8_t *pData , uint8_t uiLength )
{
   //senden..
}

Wie sendet man sinnvoll jetzt solch eine Struktur?
Es gibt ja zig. verschiedene Arten..
Was hat sich bis jetzt so bewährt?

[Stefan F. (Gast)]

Jan H. schrieb:
> Wie sendet man sinnvoll jetzt solch eine Struktur?

So wie es der Empfänger braucht. Im einfachsten Fall einen Zeuger auf 
das erste Byte, und die Länge angeben.

Was soll das denn werden?

[Jan H. (janiiix3)]

Es soll erstmal nichts spezielles werden.
Einfach die Vorgehensweise, wie man sowas am besten macht.
Ich hätte es jetzt wie folgt gemacht..

// verkürzt
BytesSenden( Struktur->Member0 , Anzahl );
BytesSenden( Struktur->Member1 , Anzahl );

Hätte jetzt jeden Member einzeln bearbeitet..

[Bernd K. (prof7bit)]

Jan H. schrieb:
> Was hat sich bis jetzt so bewährt?

Es hat sich bewährt daß man sich stets dessen bewußt sein muß daß es 
verschiedene Endianness und verschiedene Alignmentregeln gibt und das 
nicht dem Zufall überlässt sondern aufs Bit genau festnagelt und 
dokumentiert und sicherstellt daß das dann auch so bleibt. Dazu sind 
dann ein paar mehr Maßnahmen zu beachten als einfach nur blind ein 
Struct byteweise auszugeben und auf das beste zu hoffen.

[Bernd K. (prof7bit)]

Das erste was mir bei Deinem struct schon mal auffällt ist daß die 
Elemente nicht ordentlich an ihren self-alignment-Grenzen ausgerichtet 
sind und daher Padding erzwingt und noch dazu auf unterschiedlichen 
Plattformen möglicherweise unterschiedlich viel davon.

[Stefan F. (Gast)]

Naj H. schrieb:
> wie man sowas am besten macht.

Das kommt auf den konkreten Anwendungsfall an.

Ich tendiere Dazu, Daten in menschen-lesbarer Form zu übermitteln. CSV, 
JSON, XML oder ähnliche Datenformate nutze ich sehr gerne, weil ich sie 
gut mitlesen und manuell simulieren kann.

Binär ist natürlich kompakter. Vielleicht brauchst du Prüfsummen oder 
Handshake.

[Jan H. (janiiix3)]

Bernd K. schrieb:
> Jan H. schrieb:
>> Was hat sich bis jetzt so bewährt?
>
> Es hat sich bewährt daß man sich stets dessen bewußt sein muß daß es
> verschiedene Endianness und verschiedene Alignmentregeln gibt und das
> nicht dem Zufall überlässt sondern aufs Bit genau festnagelt und
> dokumentiert und sicherstellt daß das dann auch so bleibt. Dazu sind
> dann ein paar mehr Maßnahmen zu beachten als einfach nur blind ein
> Struct byteweise auszugeben und auf das beste zu hoffen.

Wie wäre es denn Sinnvoller?
Ein Beispiel wäre nett ;)

[brt (Gast)]

Jan H. schrieb:
> Was hat sich bis jetzt so bewährt?

Es ist wichtig die Grenze der einzelnen Datenpakete sicher zu erkennen.
Das geht entweder mit einer definierte Pause die über einen Timeout 
erkannt wird oder über Framing.

Bei mir bewährt hat sich:
https://en.wikipedia.org/wiki/Consistent_Overhead_Byte_Stuffing

Immer nur 1 Byte Overhead und sichere Erkennung der Paketgrenzen.

Vorschlag:

- Daten binär verpacken (evtl. _attribute_ ((packed)) benutzen)
- Checksumme anhängen
- COBS-encodieren

Wenn das portabel sein soll und auf anderen als vorher geplanten 
Maschinen laufen soll ist noch die
https://en.wikipedia.org/wiki/Endianness
zu beachten.

Grüße, Brt

[Jan H. (janiiix3)]

Stefanus F. schrieb:
> Naj H. schrieb:
>> wie man sowas am besten macht.
>
> Das kommt auf den konkreten Anwendungsfall an.
>
> Ich tendiere Dazu, Daten in menschen-lesbarer Form zu übermitteln. CSV,
> JSON, XML oder ähnliche Datenformate nutze ich sehr gerne, weil ich sie
> gut mitlesen und manuell simulieren kann.
>
> Binär ist natürlich kompakter. Vielleicht brauchst du Prüfsummen oder
> Handshake.

Ich meinte spezielle wie ich die Bytes aus der Struktur hole bzw. von 
der Adresse und dem UART übergebe.

[foobar (Gast)]

> Wie sendet man sinnvoll jetzt solch eine Struktur?

So, dass der Empfänger es auch versteht und er außerdem noch die 
Möglichkeit hat, Übertragungsfehler zu erkennen und ggf zu reparieren.

Gern benutzt wird ein ASCII-Format, ein Datensatz pro Zeile, vorne eine 
Kennung um was für einen Typ von Daten es sich handelt, dann die Daten, 
dann ein Zeilenende. Beispiel: "Filter 123 1,2,3,4,5,6,7,8,9,10 
23423424\n". Evtl noch ein paar definierte Timeouts und ne Prüfsumme, 
dann man hat was Solides.

Einfach die Daten binär roh rauszuhauen erscheint erstmal einfach, ist 
aber sehr Fehleranfällig (z.B. geht nur ein Byte verloren oder durch 
eine Störung ein Byte zuviel, kommen beide Seiten nie wieder in Sync) 
und es ist kaum noch erweiterbar.

[foobar (Gast)]

> Ich meinte spezielle wie ich die Bytes aus der Struktur hole bzw. von
> der Adresse und dem UART übergebe.

Beispiel:

static void
send_filter(Filter_t *f)
{
    char buffer[128];
    int len;

    len = sprintf(buffer, "Filter %u %u,%u,%u,%u,%u,%u,%u,%u,%u,%u %lu\n",
          f->uiParameter,
          f->pKanal[0], ..., f->pKanal[9],
          f->uiAddresse);
    uartPuts(buffer, len);
}

Empfänger wird natürlich komplexer, da er sich um die Fehlerbehandlung 
kümmern muß.

[x^2 (Gast)]

Naj H. schrieb:
> Wie sendet man sinnvoll jetzt solch eine Struktur?

Aufgrund von Padding nicht sinnvoll auf die dargestellte Weise.

Man kann offsetof() und sizeof() auf die Elemente ansetzen. Beschreibt 
man dann jedes Element als sizeof()/offsetof() Pärchen z.B. in einem 
Array, kann man sich eine generische Funktion bauen, die Strukturen 
"verschicken" kann.

typedef struct
{
   uint8_t offset;
   uint8_t bytes;
} ITEM;

typedef struct
{
   uint8_t count;
   const ITEM* items;
} MSG;

enum MSG_TYPES
{
   MSG_TYPE_1 = 0,
   //...
   MSG_TYPE_EOL
};

static const ITEM msg_type_1[] =
{
   {offsetof(Filter_t::uiParameter), sizeof(Filter_t::uiParameter)},
   //...
};

static const MSG messages[] =
{
   { sizeof(msg_type_1)/sizeof(msg_type_1[0]), msg_type_1 },
   //...
};

Dann kann man eine generische Funktion schreiben, die jeden 
Nachrichtentype versenden kann.

void send(enum MSG_TYPES type, const void* data)
{
   int i, k;

   if (type < MSG_TYPE_EOL)
   {
      const uint8_t* ptr = (const uint8_t*)data;
      const MSG msg = messages[type];

      for (i = 0; i < msg.count; i++)
      {
          for (k = 0; i < msg.items[i].bytes; ++k)
              tx_byte(ptr[msg.items[i].offset + k]);
      }
   }
}

Alles nicht compiliert/getestet. Soll nur das Prinzip demonstrieren.

[x^2 (Gast)]

Dummerweise gibt's auch noch die Endianness, die in diesem Beispiel 
ignoriert wird. Für eine richtige Lösung, sollte man diese natürlich 
berücksichtigen.