Real Time Target - Socket mit S-function - Mein MATLAB Forum

WICHTIG: Der Betrieb von goMatlab.de wird privat finanziert fortgesetzt. - Mehr Infos...

Partner:

Forum

Option

[Erweitert]

• Diese Seite per Mail weiterempfehlen

Gehe zu:

Real Time Target - Socket mit S-function

Gast


	Beiträge: ---

	Anmeldedatum: ---

	Wohnort: ---

	Version: ---

Verfasst am: 17.11.2016, 11:17 Titel: Real Time Target - Socket mit S-function

Hallo.
Ich möchte mit einer s-function in Matlab/Simulink einen Smart Meter in Echtzeit mit einem xpc-target auslesen. Ich verwende Matlab R2016a und Simulink Real Time 2016a auf dem TargetPC. In Simulink selbst funktioniert mein Programm einwandfrei. Ich kann es aber nicht auf den EchtzeitPC spielen und bekomme folgende Fehlermeldung:

The call to slrt_make_rtw_hook, during the exit hook generated the following error:
Invalid Simulink object name: loader

The build process will terminate as a result.
Caused by:
Invalid Simulink object name: loader
No block diagram 'loader' is loaded.

Ich vermute es liegt an den headern (z.B. winsock.h) die der TargetPC nicht zur Verfügung hat? Oder was ist das Problem?

Bin über jeden Hinweis, der mir eine Lauffähigkeit auf dem TargetPC bringen kann, sehr dankbar.

Code:

#define S_FUNCTION_NAME Smart_Meter // Dateiname
#define S_FUNCTION_LEVEL 2

// Headerdateien

#include <simstruc.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <windows.h>
#include <winsock.h>
#include <io.h>
#pragma comment(lib, "ws2_32.lib") // Ws2_32 Bibliothek einbinden

/* Funktion: mdlInitializeSizes ===========================================
* Nutzen:
* Größe, Anzahl und Eigenschaften der Paramter, Zustände, Eingänge und
* Ausgänge werden gesetzt.
*/
static void mdlInitializeSizes(SimStruct *S)
{
// Parameter
ssSetNumSFcnParams(S, 0); // Anzahl der externen Paramter
if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
// Fehler für Anzahl der erwarteten Paramter != Anzahl Paramter in
// Dialog Box
return;
}

// Zusände
ssSetNumContStates(S, 0); // Anzahl der kontinuierlichen Zusände: 0
ssSetNumDiscStates(S, 0); // Anzahl der diskreten Zusände: 0

// Eingänge
if (!ssSetNumInputPorts(S, 0)) return; // Anzahl der Eingänge: 0
// ssSetInputPortWidth(S,0,0); // Port 0 mit Breite 1
// ssSetInputPortRequiredContiguous(S,0,true); // Durchgriff für Port
// ssSetInputPortDirectFeedThrough(S,0,1); // Änderung am Ausgang Port

// Ausgänge
if (!ssSetNumOutputPorts(S, 14)) return; // Anzahl der Ausgänge: 14
ssSetOutputPortWidth(S, 0, 1); // Port 0 mit Breite 1 (Ausgang 1)
ssSetOutputPortWidth(S, 1, 1); // Port 1 mit Breite 1 (Ausgang 2)
ssSetOutputPortWidth(S, 2, 1); // Port 2 mit Breite 1 (Ausgang 3)
ssSetOutputPortWidth(S, 3, 1); // Port 3 mit Breite 1 (Ausgang 4)
ssSetOutputPortWidth(S, 4, 1); // Port 4 mit Breite 1 (Ausgang 5)
ssSetOutputPortWidth(S, 5, 1); // Port 5 mit Breite 1 (Ausgang 6)
ssSetOutputPortWidth(S, 6, 1); // Port 6 mit Breite 1 (Ausgang 7)
ssSetOutputPortWidth(S, 7, 1); // Port 7 mit Breite 1 (Ausgang 8)
ssSetOutputPortWidth(S, 8, 1); // Port 8 mit Breite 1 (Ausgang 9)
ssSetOutputPortWidth(S, 9, 1); // Port 9 mit Breite 1 (Ausgang 10)
ssSetOutputPortWidth(S, 10, 1); // Port 10 mit Breite 1 (Ausgang 11)
ssSetOutputPortWidth(S, 11, 1); // Port 11 mit Breite 1 (Ausgang 12)
ssSetOutputPortWidth(S, 12, 1); // Port 12 mit Breite 1 (Ausgang 13)
ssSetOutputPortWidth(S, 13, 1); // Port 13 mit Breite 1 (Ausgang 14)

// Setzen der Abtastzeit
ssSetNumSampleTimes(S, 1);

// Work-Vektor Einstellungen setzen
ssSetNumRWork(S, 0);
ssSetNumIWork(S, 0);
ssSetNumPWork(S, 0);
ssSetNumModes(S, 0);
ssSetNumNonsampledZCs(S, 0);

// Übereinstimmung mit erstelltem Simulink Block
ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE);
ssSetOptions(S, 0);
}

/* Funktion: mdlInitializeSampleTimes =====================================
* Nutzen:
* Abtastzeit der s-function deklarieren.
* Muss mit ssSetNumSampleTimes übereinstimmen.
*/
static void mdlInitializeSampleTimes(SimStruct *S)
{
ssSetSampleTime(S, 0, CONTINUOUS_SAMPLE_TIME);
ssSetOffsetTime(S, 0, 0.0);
}

/* Funktion: mdlOutputs ===================================================
* Abstract:
* Hier steht der C-Code um die Ausgänge zu setzen.
*/
static void mdlOutputs(SimStruct *S, int_T tid)
{
// Initialisierung verschiedener Variablen
WSADATA wsaData; // Nötig um Socktes auf Windows nutzen zu können
int my_socket; // Socket-Funktion initialisieren
struct sockaddr_in adressdaten; // Adressdaten von Verbindungsziel
int my_connect; // Connect-Funktion initialisieren
char sendebefehl[] = {0x10,0x7B,0x01,0x7C,0x16}; // Auslesebefehl
int my_send; // Send-Funktion initialisieren
char daten[152]; // Array um empfangene Daten zu speichern
int my_recv; // Recv-Funktion initialisieren
int i,j; // Hilfsvariablen für for-Schleifen
double U_phase1, I_phase1, P_phase1, Q_phase1, U_phase2, I_phase2,
P_phase2, Q_phase2,U_phase3, I_phase3, P_phase3, Q_phase3,
P_gesamt, Q_gesamt; // Verbrauchsdaten

// Ausänge deklarieren
real_T *U_phase1_out = ssGetOutputPortSignal(S,0);
real_T *I_phase1_out = ssGetOutputPortSignal(S,1);
real_T *P_phase1_out = ssGetOutputPortSignal(S,2);
real_T *Q_phase1_out = ssGetOutputPortSignal(S,3);
real_T *U_phase2_out = ssGetOutputPortSignal(S,4);
real_T *I_phase2_out = ssGetOutputPortSignal(S,5);
real_T *P_phase2_out = ssGetOutputPortSignal(S,6);
real_T *Q_phase2_out = ssGetOutputPortSignal(S,7);
real_T *U_phase3_out = ssGetOutputPortSignal(S,8);
real_T *I_phase3_out = ssGetOutputPortSignal(S,9);
real_T *P_phase3_out = ssGetOutputPortSignal(S,10);
real_T *Q_phase3_out = ssGetOutputPortSignal(S,11);
real_T *P_gesamt_out = ssGetOutputPortSignal(S,12);
real_T *Q_gesamt_out = ssGetOutputPortSignal(S,13);

// Überprüfung von WSADATA auf korrekte Initialisierung
if (WSAStartup(MAKEWORD(1,1), &wsaData) != 0) {
fprintf(stderr, "WSAStartup failed.\n");
exit(1);
}

// Socket - Verbindung über TCP/IP erzeugen
my_socket = socket(AF_INET, SOCK_STREAM, 0);
// Fehlerabfrage (socket() liefert bei Fehler den Wert -1)
if (my_socket == -1) {
printf("Socketfehler\n");
exit(EXIT_FAILURE);
}

// Adressdaten von Smart Meter/Pegelwandler in struct adressdaten schreiben
adressdaten.sin_family = AF_INET; // Adressfamilie
adressdaten.sin_port = htons(10001); // Portnummer (short network byte)
adressdaten.sin_addr.s_addr = inet_addr("134.60.35.60"); //IP-Adresse

// Verbindung des Verbindungsziels über socket herstellen
my_connect = connect(my_socket, (struct sockaddr*)&adressdaten,
sizeof(struct sockaddr_in));
// Fehlerabfrage (connect() liefert bei Fehler den Wert -1)
if (my_connect == -1 ) {
printf("Connectfehler\n");
exit(EXIT_FAILURE);
}

// Smart Meter/Pegelwandler Auslesebefehl senden
my_send = send(my_socket, sendebefehl, sizeof(sendebefehl), 0);
// Fehlerabfrage (send() liefert bei Fehler den Wert -1)
if (my_send == -1 ) {
printf("Sendfehler\n");
exit(EXIT_FAILURE);
}

// Daten von Smart Meter/Pegelwandler empfangen & in char Array speichern
my_recv = recv(my_socket, (char*)&daten, sizeof(daten), 0);
// Fehlerabfrage (recv() liefert bei Fehler den Wert -1)
if (my_recv == -1 ) {
printf("Recvfehler\n");
exit(EXIT_FAILURE);
}

// Socket wieder schließen
closesocket(my_socket);
WSACleanup();

// Empfangenes Array als Hexadezimalcode ausgeben
// for(i=0;i<sizeof(daten);i++) {
// printf("%02X ",(int)(*(unsigned char*)(&daten[i])));
// }

// Verbrauchsdaten aus empfangenem Hexadezimalcode extrahieren
for(j=0;j<sizeof(daten);j++) {
if (j==52){
// Spannung Phase 1
U_phase1 = daten[j]+daten[j+1]*256;
printf("Spannung Phase 1: %d V\n",
(unsigned double)(unsigned char)U_phase1);
j++;
}
if (j==59){
// Stromstärke Phase 1
I_phase1 = (daten[j]+daten[j+1]*256)*0.1;
printf("Stromstärke Phase 1: %f A\n",I_phase1);
j++;
}
if (j==65){
// Wirkleistung Phase 1
P_phase1 = (daten[j]+daten[j+1]*256)*0.1;
printf("Wirkleistung Phase 1: %f kW\n",P_phase1);
j++;
}
if (j==72){
// Blindleistung Phase 1
Q_phase1 = (daten[j]+daten[j+1]*256)*0.1;
printf("Blindleistung Phase 1: %f kVar\n",Q_phase1);
j++;
printf("\n");
}
if (j==79){
// Spannung Phase 2
U_phase2 = daten[j]+daten[j+1]*256;
printf("Spannung Phase 2: %d V\n",
(unsigned double)(unsigned char)U_phase2);
j++;
}
if (j==86){
// Stromstärke Phase 2
I_phase2 = (daten[j]+daten[j+1]*256)*0.1;
printf("Stromstärke Phase 2: %f A\n",I_phase2);
j++;
}
if (j==92){
// Wirkleistung Phase 2
P_phase2 = (daten[j]+daten[j+1]*256)*0.1;
printf("Wirkleistung Phase 2: %f kW\n",P_phase2);
j++;
}
if (j==99){
// Blindleistung Phase 2
Q_phase2 = (daten[j]+daten[j+1]*256)*0.1;
printf("Blindleistung Phase 2: %f kVar\n",Q_phase2);
j++;
printf("\n");
}
if (j==106){
// Spannung Phase 3
U_phase3 = daten[j]+daten[j+1]*256;
printf("Spannung Phase 3: %d V\n",
(unsigned double)(unsigned char)U_phase3);
j++;
}
if (j==113){
// Stromstärke Phase 3
I_phase3 = (daten[j]+daten[j+1]*256)*0.1;
printf("Stromstärke Phase 3: %f A\n",I_phase3);
j++;
}
if (j==119){
// Wirkleistung Phase 3
P_phase3 = (daten[j]+daten[j+1]*256)*0.1;
printf("Wirkleistung Phase 3: %f kW\n",P_phase3);
j++;
}
if (j==126){
// Blindleistung (Phase 3
Q_phase3 = (daten[j]+daten[j+1]*256)*0.1;
printf("Blindleistung Phase 3: %f kVar\n",Q_phase3);
j++;
printf("\n");
}
if (j==137){
// Wirkleistung gesamt
P_gesamt = (daten[j]+daten[j+1]*256)*0.1;
printf("Wirkleistung gesamt: %f kW\n",P_gesamt);
j++;
}
if (j==144){
// Blindleistung gesamt
Q_gesamt = (daten[j]+daten[j+1]*256)*0.1;
printf("Blindleistung gesamt: %f kVar\n",Q_gesamt);
j++;
}
}

// Output setzen
U_phase1_out[0] = (unsigned double)(unsigned char) U_phase1;
I_phase1_out[0] = I_phase1;
P_phase1_out[0] = P_phase1;
Q_phase1_out[0] = Q_phase1;
U_phase2_out[0] = (unsigned double)(unsigned char) U_phase2;
I_phase2_out[0] = I_phase2;
P_phase2_out[0] = P_phase2;
Q_phase2_out[0] = Q_phase2;
U_phase3_out[0] = (unsigned double)(unsigned char) U_phase3;
I_phase3_out[0] = I_phase3;
P_phase3_out[0] = P_phase3;
Q_phase3_out[0] = Q_phase3;
P_gesamt_out[0] = P_gesamt;
Q_gesamt_out[0] = Q_gesamt;
}

/* Funktion: mdlTerminate =================================================
* Nutzen:
* Hier werden alle Funktionen deklariert, die nach Beendigung einer
* Simulation durchgeführt werden müssen.
* Zum Beispiel muss reservierter Speicherplatz wieder freigegeben
* werden.
* Dies wird hier nicht benötigt.
*/
static void mdlTerminate(SimStruct *S)
{
}

#ifdef MATLAB_MEX_FILE // Wird dieses File als Hex-File kompiliert?
#include "simulink.c" // Mex-Dateischnittstelle mit Simulink
#else
#include "cg_sfun.h" // Funktion um Code zu erzeugen
#endif

Funktion ohne Link?

[EDITED, Jan, Bitte Code-Umgebung verwenden - Danke!]


Einstellungen und Berechtigungen
Beiträge der letzten Zeit anzeigen:	Du kannst Beiträge in dieses Forum schreiben. Du kannst auf Beiträge in diesem Forum antworten. Du kannst deine Beiträge in diesem Forum nicht bearbeiten. Du kannst deine Beiträge in diesem Forum nicht löschen. Du kannst an Umfragen in diesem Forum nicht mitmachen. Du kannst Dateien in diesem Forum posten Du kannst Dateien in diesem Forum herunterladen

Impressum | Nutzungsbedingungen | Datenschutz | FAQ |

RSS

Hosted by:

Copyright © 2007 - 2024 goMatlab.de | Dies ist keine offizielle Website der Firma The Mathworks

MATLAB, Simulink, Stateflow, Handle Graphics, Real-Time Workshop, SimBiology, SimHydraulics, SimEvents, and xPC TargetBox are registered trademarks and The MathWorks, the L-shaped membrane logo, and Embedded MATLAB are trademarks of The MathWorks, Inc.