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.

Orientierung in Simulink

Mit MATLAB Simulink 2019b ist der Quellcode unter Output im Function Block zu finden (ändert sich mit 2022a). Die Eingabe und Ausgabeparameter müssen in den entsprechenden Reitern konfiguriert werden.

Pseudo Code der S-Function

Platzhalter Pseudocode

Programmablaufplan

Implementierung in C++

Die S-Function ist mit dem folgenden Quellcode implementiert. Die Unterbrechungen dienen dabei nur der Erklärung, in Simulink (2022a) ist es eine Textdatei. In den vorigen Simulink Versionen wird der Code unübersichtlich auf mehrere Reiter 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: 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;
/* 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)
{
    // 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
            *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