C++ Server Client anwendung Verständnis Fragen

Hallo
Ich Arbeite gerade an meinem ersten C++ Programm, einer Client Server Anwendung um Messdaten eines Solarladereglers auszulesen und speichern und an einen Server und oder Display weiterzuleiten (Modbus Protokoll).
Gewisse Sachen verstehe ich aber nicht und bräuchte dafür bitte eure Hilfe.

1. Ich Lese vom SolarRegler Die Werte als Register (Modbus) in einen Buffer *uint8_t und Speicher sie in einem Array uint16_t. Ein Register hat ja 2 Byte.
zum Umwandeln der Werte von x bit in y bit verwnde ich diese Funktionen aus der LibModbus:

#define MODBUS_GET_INT16_FROM_INT8(tab_int8, index) ((tab_int8[(index)] << 8) + tab_int8[(index) + 1])
#define MODBUS_SET_INT16_TO_INT8(tab_int8, index, value) \
    do { \
        tab_int8[(index)] = (value) >> 8;  \
        tab_int8[(index) + 1] = (value) & 0xFF; \
} while (0)

zum versenden übers Netzwerk würde ich sie auch mit hilfe der Funktionen wieder in einen uint8_t bzw. char Buffer Legen.
die gegenseite sollte sie dann analog zum Client wieder in uint16_t umwandeln und Speichern.

Muss ich da wegen Endianess etwas beachten?

Ich bin der meineung dass das nur wichtig ist bei Werten größer ein Byte damit sie nicht in einem int16_t buffer "falsch" abgelegt wird.

2. Ich würde zum versenden über Netzwerk gern mein eigenes Protokoll entwerfen. Da die Werte aber alle Binär vorhanden sind will ich sie auch so versenden wie oben beschrieben.
Sollte ich dann im Header zum beschreiben was zu machen ist bzw. was in der Payload ist Text verwenden oder sollte besser alles Binär gesendet werden?

zb.: 8bitt -> Action 16bit -> Message lenght 16bit -> Payload Type 16Bit -> Register StartAddress 16bitt -> Register Count...

Sollte ich auch bevor das Protokoll ausgewertet wird Message Lenght überprüfen ob alles empfangen wurde und evt. mit einem weiteren recv den fehlenten Rest and den Buffer anhängen?
wie lange bleiben eigentlich die Daten die empfangen werden in dem Socket.

3. Wie sieh es mit Thresds aus? Sollte ich den Server in einem eigenen Thread laufen lassen. oder kann er auch als Teil der Hauptschleife laufen, in der dann auch noch evt. Daten wieder an das Display gesendet werden.
Für den Client wollte ich eigentlich keine Threads verwenden da er zuerst sowieso die Daten vom Solar Lade Regler liest und Speichert und dann über Netzwerk an den Server sendet. Oder sollte ich da auch Threads verwenden.
wenn Ja welche sollte ich verwenden POSIX oder die Thread Class aus c++?

4. Was muss beim Multi Threading beachtet werden?
Ich habe eine Klasse memory die die ganzen Register in Arrays speichert und die natürlich zum versenden auch wieder ausgelesen werden müssen. Muss ich da mit mutex Arbeiten?
Nur beim Schreiben oder auch beim Lesen?

So das wars jetzt erst mal. Ist nicht leicht als Neuling alle Infos richtig zu interpretieren.
Hoffe mir kann einer von den Profis die ein oder andere Frage beantworten.
mfg Thomas

Danke für die Antworten.
Zum System:
Der client im Garten ist ein Raspberry und als Server werde ich vmtl. Mein Qnap Nas verwenden.
Also alles Linux gcc.
Beim Modbus protokoll werden die einzelnen Register als Big Endian versendet und so würde ich sie auch weiter versenden.
Finde ich auch Logischer.
Das Display ist übrigens auch wieder mit Modbus angeschlossen. Aber da ich die Daten auch aus der Ferne abfragen möchte, muss ich im prinzip eine Art Proxy bauen.
Da ich nicht Display(Master) und Computer(Master) gleichzeitig betreiben kann.
Würde Später dann auch die Gelegenheit Nützen um ein bar Werte, die am Solarladeregler nicht so aussagekräftig sind, durch die des Batterie Monitors zu ersetzen.
Aber evt. Werde ich den Code später auch mal veröffentlichen also sollte das auch auf unterschiedlichen Endianess funktionieren.

Angenommen ich mach das alles im Hauptthread dann muss ich bei jeden Schleifendurchgang mit Select den Socket überwachen, und dann mit accept() die verbindung annehmen, und der Client wartet beim connect bis der Server wieder beim accept() angekommen ist?

Zum Protokoll:
Den Anfang und das Ende mit einem Byte zumarkieren wird schwierig da im Prinzip von 0x00 bis 0xFF alles gesendet werden kann

Muss ich in der Hauptschleife eigentlich auch ein sleep ö. ä. Einbauen damit der Prozessor nicht komplett ausgelastet ist?

Mfg Thomas

semi
Ok das muss ich mir merken klingt plausibel wenn auch im ersten Moment etwas kompliziert.

mini73
Diese Funktion kenne ich schon mir ist nur nicht ganz klar wann es nötig ist auch Endianess zu achten.
Dazu ein beispiel:
Ich will diesen Wert: uint16_t = 0x0110 versenden.
lege den jetzt in einen Buffer:
char Buffer[2] = {0x01, 0x10] dazu verwende ich dieses Makro:

#define MODBUS_SET_INT16_TO_INT8(tab_int8, index, value) \
    do { \
        tab_int8[(index)] = (value) >> 8;  \
        tab_int8[(index) + 1] = (value) & 0xFF; \
} while (0)

Beim empfänger liegt dieser Wert genauso im Buffer und wir dann mit diesem Makro:

#define MODBUS_GET_INT16_FROM_INT8(tab_int8, index) ((tab_int8[(index)] << 8) + tab_int8[(index) + 1])

Dann liegt der Wert doch beim empfänger genauso vor:
uint16_t = 0x0110

wie der Wert doch jetzt im Speicher des jeweiligen Systems liegt ist doch in diesem Fall egal die binär Minipulationen müssen doch gleich Funktionieren. Natürlich setzt das Vorraus dass mein Protokoll die Daten in einem bestimmten Format (in diesem Fall Big Endian) versendet.
Oder habe ich da was falsch verstanden?

mfg Thomas