Dekodierung RS-232 in Simulink
Autor: Tim Schonlau, Changlai Bao (WiSe 22/23)
Einleitung
Dieser Artikel beschreibt die Implementierung einer S-Function in Simulink. Die Daten, die von der x86-CPU über den COM Port an die dSPACE Karte gesendet werden, werden mit dieser S-Function dekodiert und im online Modell bereitgestellt. Der Quellcode der S-Function wird in C++ geschrieben. Sie ist ein wichtiger Teil des Simulink online Modells des CCF. Nachdem die CCF_online.slx in Simulink geöffnet wurde, kann mit Strg + L die verlinkte Bibliothek CCF_online → SEN - Sensoren - online → SenKam - Kamera geöffnet werden.
Orientierung in Simulink
Mit MATLAB Simulink 2019b ist der Quellcode in der Output Registerkarte im Function Block zu finden (ändert sich mit 2022a).
Die Eingabe und Ausgabeparameter müssen in den entsprechenden Registerkarten konfiguriert werden.
Eine S-Function kann mit beliebig vielen Eingängen und Ausgängen konfiguriert werden, in diesem Fall sind es zwei Eingänge:
- rx_data_in beinhaltet das Byte das aus dem Buffer ausgelesen wird
- Status beschreibt den Empfangstatus des Serial Receive Blocks (Link verweist auf dSPACE Hilfe, nur im Labor erreichbar).
Für das Debugging werden die Ausgaben des dSPACE RTI Blocks Serial Receive mit ausgegeben, um in Control Desk die Kommunikation zu testen, die weiteren Ausgänge umfassen alle Parameter die über RS232 an die dSPACE Karte übermittelt werden:
SenKam - Kamera Simulink Modell
- ZaehlerUertrag_out
- ZaehlerParameter_out
- SenKam_SpurA_f64
- SenKam_SpurC_f64
- SenKam_SpurC_f64
- SenKam_Spurzuordnung
- SenKam_StopplinieErkannt
- SenKam_StopplinieAbstand
- SenKam_ObjekteAnzahl
- SenKam_ObjektNummer
- SenKam_ObjektX
- SenKam_ObjektY
- SenKam_Objektbreite
- SenKam_Objekttiefe
- SenKam_Objektausrichtung
- SenKam_Objektgeschwindigkeit
- SenKam_Objektplausibel
Implementierung der S-Function
Funktionale Beschreibung der S-Function
Da immer ein Byte aus dem Puffer ausgelesen wird, müssen Datentypen die mehrere Bytes umfassen umgewandelt und zusammengefügt werden. Beispiel mit den Spurpolynomkoeffizienten: Diese sind in der OSE Softwareumgebung als float gespeichert. Ein float lässt sich in vier Byte an die dSPACE Karte übertragen. Die S-Function sammelt also vier aufeinanderfolgende Bytes und speichert diese dann als ein float ab. Dafür sind zwei Variablen im C++-Code der S-Function nötig:
- zaehler_param
- zaehler_uebertragung
Der erste Zähler wird für die Zusammenfügung des floats benötigt. Dieser nimmt einen Wert zwischen 0 und 3 ein. Um ein 32 Bit Zeichen einzulesen, wird erst vier mal ein 8 Bit Zeichen empfangen. Mithilfe einer union Datenstruktur werden die 4 Bytes hintereinander geschrieben und mit einer Zuweisung auf das erste Byte in einen float umgewandelt.
Der zweite Zähler wird für die Übertragung der weiteren Daten verwendet. Dieser nimmt den Wert von 0 bis 45 ein.
Das Einlesen des Buffers wartet, bis das Start_Flag gesetzt ist. Dieses wird nur gesetzt wenn:
- das empfangte Byte dem Start_Byte (170) entspricht
- das Start_Flag und der zaehler_uebertragung gleich null sind
Pseudocode
WENN Status größer als 0 // Wenn neues Byte in Puffer geschrieben wurde
Programmablaufplan
Im folgendem Diagramm ist die S-Function als Programm Ablauf Plan dargestellt
Implementierung in C++
Die S-Function wird mit dem folgenden Quellcode von merge_rxdata_to_signals in Simulink (2019b) implementiert.
Im Folgenden sind die Namen der Parametervariablen aufgeführt, die zu den Libraries hinzugefügt werden müssen.
#define BITS_IN_BYTE 8
#define START_BYTE 170
#define STOPP_BYTE 85
float laneParamA = 0;
float laneParamB = 0;
float laneParamC = 0;
uint8_T lane_asign = 0;
uint8_T stop_insight = 0;
float stop_distance = 0;
uint8_T n_objekte = 0;
uint8_T number = 0;
float x_0 = 0;
float y_0 = 0;
float b = 0;
float t = 0;
float alpha = 0;
float v = 0;
uint8_T plausible = 0;
uint8_T data = 0;
static uint8_T Start_Flag = 0;
uint8_T stopp_Byte = 0;
static uint8_T zaehler_param = 0; // wertigkeit: 0 - 3
static uint8_T zaehler_uebertragung = 0; // wertigkeit: 1 - 12
static uint8_T oldState = 0; // Alter Zustand speichern
//int i = 0;
union data
{
uint8_T datenErfassung[4]; // collect data
float datenSpeicher; // data storage
}polyn;
Hier ist der Skript, der in Outputs geschrieben werden muss.
if(Status > 0)
{
// Empfängte Daten abgreifen
data = *rx_data_in;
// Wurde der Start Byte empfägt?
if(data == START_BYTE && Start_Flag == 0 && zaehler_param == 0)
{
Start_Flag = 1; // flag setzen
}
// Wurde das Flag gesetz?
else if(Start_Flag == 1)
{
zaehler_uebertragung++;
// Daten sammeln - erfolgt 4 mal --> 4 * 8 bit
if(zaehler_param <= 3)
{
polyn.datenErfassung[zaehler_param] = data;
}
// Zähler variable übergeben als Ausgang der Funktion
*ZaehlerParameter_out = zaehler_param;
zaehler_param++;
// Nach 4 Datenbyte --> Spurparameter A
if(zaehler_uebertragung == 4)
{
laneParamA = polyn.datenSpeicher;
*SenKam_SpurA_f64 = laneParamA;
zaehler_param = 0;
}
// Nach 8 Datenbyte --> Spurparameter B
else if(zaehler_uebertragung == 8)
{
laneParamB = polyn.datenSpeicher;
*SenKam_SpurB_f64 = laneParamB;
zaehler_param = 0;
}
// Nach 12 Datenbyte --> Spurparameter C
else if(zaehler_uebertragung == 12)
{
laneParamC = polyn.datenSpeicher;
*SenKam_SpurC_f64 = laneParamC;
zaehler_param = 0;
}
// Nach 13 Datenbyte --> Spurzuordnung
else if(zaehler_uebertragung == 13)
{
// Wenn nur ein Bit empfangen wird (0 oder 1) dann data direkt in Output schreiben
// Vermeiden von Fehlern durch falsche decodierung des Arrays
lane_asign = data;
*SenKam_Spurzuordnung = lane_asign;
zaehler_param = 0;
}
// Nach 14 Datenbyte --> Stopplinie erkannt
else if(zaehler_uebertragung == 14)
{
stop_insight = data;
*SenKam_StopplinieErkannt = stop_insight;
zaehler_param = 0;
}
// Nach 18 Datenbyte --> Abstand Stopplinie
else if(zaehler_uebertragung == 18)
{
stop_distance = polyn.datenSpeicher;
*SenKam_StopplinieAbstand = stop_distance;
zaehler_param = 0;
}
// Nach 19 Datenbyte --> Anzahl der Objekte
else if(zaehler_uebertragung == 19)
{
n_objekte = data;
*SenKam_ObjekteAnzahl = n_objekte;
zaehler_param = 0;
}
// Nach 20 Datenbyte --> Objektnummer
else if(zaehler_uebertragung == 20)
{
number = data;
*SenKam_ObjektNummer = number;
zaehler_param = 0;
}
// Nach 24 Datenbyte --> Objekt x-Koordinate
else if(zaehler_uebertragung == 24)
{
x_0 = polyn.datenSpeicher;
*SenKam_ObjektX = x_0;
zaehler_param = 0;
}
// Nach 28 Datenbyte --> Objekt y-Koordinate
else if(zaehler_uebertragung == 28)
{
y_0 = polyn.datenSpeicher;
*SenKam_ObjektY = y_0;
zaehler_param = 0;
}
// Nach 32 Datenbyte --> Objektbreite
else if(zaehler_uebertragung == 32)
{
b = polyn.datenSpeicher;
*SenKam_Objektbreite = b;
zaehler_param = 0;
}
// Nach 36 Datenbyte --> Objekttiefe
else if(zaehler_uebertragung == 36)
{
t = polyn.datenSpeicher;
*SenKam_Objekttiefe = t;
zaehler_param = 0;
}
// Nach 40 Datenbyte --> Objektausrichtung
else if(zaehler_uebertragung == 40)
{
alpha = polyn.datenSpeicher;
*SenKam_Objektausrichtung = alpha;
zaehler_param = 0;
}
// Nach 44 Datenbyte --> Objektgeschwindigkeit
else if(zaehler_uebertragung == 44)
{
v = polyn.datenSpeicher;
*SenKam_Objektgeschwindigkeit = v;
zaehler_param = 0;
}
// Nach 45 Datenbyte --> Objektplausibel
else if(zaehler_uebertragung == 45)
{
plausible = data;
*SenKam_Objektplausibel = plausible;
zaehler_param = 0;
}
// Nach Übertragung Objektparameter zurücksetzen
if (SenKam_ObjektNummer < SenKam_ObjekteAnzahl)
{
zaehler_uebertragung = 20;
}
// Nach Übertragung alle Parameter zurücksetzen
else if (zaehler_uebertragung >= 46 )
{
Start_Flag = 0;
zaehler_param = 0;
zaehler_uebertragung = 0;
}
*ZaehlerUertragung_out = zaehler_uebertragung;
}
// Wenn Start Byte nicht emfangen würde, Alle parameter bleiben auf 0
else
{
Start_Flag = 0;
zaehler_param = 0;
zaehler_uebertragung = 0;
}
}
→ zurück zum Kommunikationsartikel: Kom - Kommunikation
→ zurück zum Hauptartikel: Praktikum SDE