Datenpipeline implementieren

[Christian H. (courtman)]

Hi Leute,
Ich arbeite momentan an einem kleinen Projekt und weiß noch nicht so 
richtig wie ich die Datenpipeline implementieren soll. Vielleicht habt 
ihr ein paar Tipps oder Beispiele, an denen ich mit ein wenig 
orientieren kann.

Folgendes Szenario:
Ich habe mehrere Cluster. Jedes Cluster ist gleich aufgebaut und besteht 
aus einem Mikrocontroller und mehreren Sensoren. Die Mikrocontroller 
werden per SPI an einen Master angeschlossen, der über eine BT 
Schnittstelle verfügt und mit meinem Rechner kommunizieren soll.
Ziel ist es die Sensordaten am Mikrocontroller auszulesen, an die BT 
Einheit weiterzuleiten und von dort an den Rechner. Bei der Analyse der 
Daten muss ich später noch zuordnen können, von wo die Daten stammen. 
Das heißt ich muss die Daten zusätzlich noch mit einer ID kennzeichnen.

Weiterhin möchte ich auch die Sensoren vom PC aus umkonfigurieren 
können. Auch da werde ich den Befehl mit der ID des Sensors kennzeichnen 
müssen.

Die Frage ist nun, wie ich das praktisch am Besten umsetze. Beim 
Konfigurieren brauche ich ja nur ein paar Bit davor setzen, so dass jede 
Einheit immer gleich weiß an wen weitergeleitet werden muss.
Und um die Daten zum Sensor zu schicken, füge ich einfach noch ein paar 
Bit mit der ID des Sensors an.

Und noch eine weitere Frage:
Die Cluster sind ja per SPI Slave an die BT Einheit angeschlossen. Wie 
kommuniziere ich dem Master, dass Daten verfügbar sind und ausgelesen 
werden müssen? Per 5 Wire SPI oder kann ich die Mikrocontroller auch 
einfach zyklisch durchlaufen, da sowieso alle gleich aufgebaut sind?

Danke und viele Grüße

[Gustl B. (-gb-)]

Bei SPI startet der Master die Kommunikation. Das heißt der fragt 
zyklisch die Slaves ab. Du könntest auch eine andere Schnittchenstelle 
nehmen bei der beide Seiten die kommunikation starten können. Z. B. 
UART. bei niedringen Datenraten (und danach klingt das hier) würdest du 
bei UART auch Pins am uC sparen.

Nein, du brauchst keine ID am Slave. Denn der Master setzt ja das 
ChipSelect und weiß welchen Slave er gerade über SPI abfragt. Das heißt 
der SPI Master kann dann zu den Daten eine ID schreiben wenn es über 
UART zum PC geht.

Wenn du aber die Slaves nicht fest an Steckplätze/SPI-Ports zuordnen 
willst oder so, dann könnten IDs bei den Slaves trotzdem sinnvoll sein.

[S. R. (svenska)]

Christian H. schrieb:
> wie ich die Datenpipeline implementieren soll

Das klingt nicht nach Datenpipeline, sondern nach Gateway.

Christian H. schrieb:
> Bei der Analyse der Daten muss ich später noch zuordnen können,
> von wo die Daten stammen.

Definiere dir erstmal ein Paketformat: Du hast einen Mikrocontroller mit 
mehreren Sensoren. Jeder Controller sollte eine eigene ID haben. 
Sinnvollerweise sollte jedes Paket auch einen Zeitstempel haben - ob der 
die wahre Uhrzeit angibt oder nur monoton hochzählt, ist erstmal egal. 
Dazu noch die Paketlänge und vielleicht eine Prüfsumme, schadet nicht.

Wenn die Cluster alle gleich aufgebaut sind, also jeder Controller die 
gleichen Sensoren hat, dann kannst du einfach eine Struktur mit den 
Messwerten bauen (plus ein Flag, ob die Daten gültig sind). Ansonsten 
wirst du vermutlich verschiedene Pakettypen brauchen, je nachdem, welche 
Sensordaten in diesem Paket drin sind.

struct pkt_hdr {
  /* header, für alle pakete gleich */
  uint16_t type;
  uint16_t len;
  uint32_t checksum; /* z.B. CRC32 */
  uint32_t timestamp;
};

struct cluster_v1 {
  struct pkt_hdr header;

  /* sensordaten */
  uint16_t hasTemp;
  uint16_t temp;
  uint16_t hasRpm;
  uint16_t rpm;
  uint16_t hasWhatever;
  uint16_t whatever;
  /* ... */
};

Der Master liest dann von jedem Cluster nur "Pakete" und leitet die 
unverändert (also nur verpackt in Bluetooth-Paketen) an den PC weiter. 
Was in den Paketen drin ist, interessiert den Master nicht - er muss nur 
wissen, wie groß das Paket ist und kann auch die Prüfsumme verifizieren.

Der PC bekommt sämtliche IDs, Timestamps und Sensorwerte und kann das 
dann beliebig auswerten.

Ob du die Strukturen direkt als Speicherblock überträgst (was meistens 
funktioniert) oder noch irgendwie gezielt serialisierst, bleibt dir 
überlassen. Ist in erster Linie in heterogenen bzw. diversen Umgebungen 
relevant, also wenn sich nicht alle Beteiligten über Endianness, 
Alignments oder Packing-Regeln einig sind. Wenn alle Controller gleich 
sind, ist das eher egal - und auf dem PC solltest du sowieso ordentliche 
Plausiblitätsprüfungen haben.

Christian H. schrieb:
> Die Cluster sind ja per SPI Slave an die BT Einheit angeschlossen.
> Wie kommuniziere ich dem Master, dass Daten verfügbar sind und
> ausgelesen werden müssen?

Viele SPI-Slaves nutzen für sowas einen zusätzlichen Pin, der auf dem 
SPI-Master einen Interrupt auslöst, wenn Daten vorliegen. Oder du nimmst 
die Zeit als Maßstab und fragst zyklisch ab, geht beides. Hängt von den 
Radbedingungen ab, ob eine Variante besser ist und welche.

Nachtrag: Was Gustl schrieb, geht auch. Dann würde erst der Master die 
Pakete zusammenbauen. Hat allerdings den Nachteil, dass der Master dann 
jeden Slave kennen muss, dafür sind die Slaves einfacher.

[Sebastian (Gast)]

Christian H. schrieb:
> Die Mikrocontroller werden per SPI an einen Master angeschlossen, der
> über eine BT Schnittstelle verfügt und mit meinem Rechner kommunizieren
> soll.

Nutzlast JSON? Checksummen benutzen. Upload neuer Firmware -- 
Bootloader?

LG, Sebastian