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

Dekodierung RS-232 in Simulink

Inhaltsverzeichnis