Dekodierung RS-232 in Simulink

Autor: Tim Schonlau (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:

1. rx_data_in beinhaltet das Byte das aus dem Buffer ausgelesen wird
2. 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

1. ZaehlerUertrag_out
2. ZaehlerParameter_out
3. SenKam_SpurA_f64
4. SenKam_SpurC_f64
5. SenKam_SpurC_f64
6. SenKam_Spurzuordnung
7. SenKam_StopplinieErkannt
8. SenKam_StopplinieAbstand
9. SenKam_ObjekteAnzahl
10. SenKam_ObjektNummer
11. SenKam_ObjektX
12. SenKam_ObjektY
13. SenKam_Objektbreite
14. SenKam_Objekttiefe
15. SenKam_Objektausrichtung
16. SenKam_Objektgeschwindigkeit
17. SenKam_Vertrauenswert

---

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:

1. das empfangte Byte dem Start_Byte (170) entspricht
2. 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 ist mit dem folgenden Quellcode implementiert. In Simulink (2022a) wird der Quellcode übersichtlich in einem Fenster programmiert, in den vorigen Simulink Versionen wird der Code unübersichtlich auf mehrere Registerkarten aufgeteilt.

/* Includes_BEGIN */
#define BITS_IN_BYTE 8
#define START_BYTE 170
#define STOPP_BYTE 85

Platzhalter Quellcode Beschreibung

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: 0 - 45

static uint8_T oldState = 0; // Alten Zustand speichern

//int i = 0;

union data
{
	uint8_T datenErfassung[4]; // collect data
	float datenSpeicher;       // data storage 
}polyn;
/* Includes_END */

/* Externs_BEGIN */

/* Externs_END */

void merge_rxdata_to_signals_Start_wrapper(const uint8_T *size_of_data, const int_T p_width0)
{
/* Start_BEGIN */
/*
 * Custom Start code goes here.
 */
/* Start_END */
}

void merge_rxdata_to_signals_Outputs_wrapper(const uint8_T *rx_data_in,
                                             const uint8_T *Status,
                                             uint8_T *ZaehlerUertragung_out,
                                             uint8_T *ZaehlerParameter_out,
                                             real_T *SenKam_SpurA_f64,
                                             real_T *SenKam_SpurB_f64,
                                             real_T *SenKam_SpurC_f64,
                                             boolean_T *SenKam_Spurzuordnung,
                                             boolean_T *SenKam_StopplinieErkannt,
                                             real_T *SenKam_StopplinieAbstand,
                                             uint8_T *SenKam_ObjekteAnzahl,
                                             uint8_T *SenKam_ObjektNummer,
                                             real_T *SenKam_ObjektX,
                                             real_T *SenKam_ObjektY,
                                             real_T *SenKam_Objektbreite,
                                             real_T *SenKam_Objekttiefe,
                                             real_T *SenKam_Objektausrichtung,
                                             real_T *SenKam_Objektgeschwindigkeit,
                                             uint8_T *SenKam_Vertraunswert,
                                             const uint8_T *size_of_data, const int_T p_width0)
{
/* Output_BEGIN */
//if(*Status != oldState)
if(Status > 0)
{
    // Empfangene Daten aus Buffer auslesen
    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
            *SenKam_Spurzuordnung = data;  
            zaehler_param = 0;
        }
        // Nach 14 Datenbyte --> Stopplinie erkannt 
        else if(zaehler_uebertragung == 14)
        { 
            *SenKam_StopplinieErkannt = data;  
            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)
        { 
            *SenKam_ObjekteAnzahl = data;  
            zaehler_param = 0;
        }
         // Nach 20 Datenbyte --> Objektnummer
        else if(zaehler_uebertragung == 20)
        { 
            *SenKam_ObjektNummer = data;  
            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 --> Vertraunswert
        else if(zaehler_uebertragung == 45)
        { 
            *SenKam_Vertraunswert = data;  
            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;
    }
    //oldState = *Status;
}
/* Output_END */
}

void merge_rxdata_to_signals_Terminate_wrapper(const uint8_T *size_of_data, const int_T p_width0)
{
/* Terminate_BEGIN */
/*
 * Custom Terminate code goes here.
 */
/* Terminate_END */
}

→ zurück zum Kommunikationsartikel: Kom - Kommunikation
→ zurück zum Hauptartikel: Praktikum SDE