Helios KWL (easycontrols) über modbus tcp einbinden

// Helios KWL mit easyControls über Modbus TCP steuern v2.0
// by jan punkt wachsmuth at web.de, Feedback gerne erwünscht.
//
//INPUTS
//AI1 .... Betriebsart
//AI2 .... Lüfterstufe
//
//OUTPUTS
//AQ1 .... Temperatur Aussenluft
//AQ2 .... Temperatur Zuluft
//AQ3 .... Temperatur Fortluft
//AQ4 .... Temperatur Abluft
//AQ5 .... Ventilator Zuluft (rpm)
//AQ6 .... Ventilator Abluft (rpm)
//AQ7 .... Bypass aktiv
//AQ8 .... Anzahl Fehler
//AQ9 .... Anzahl Warnungen
//A10 .... Anzahl Infos
//A11 .... Luefertestufe
//A12 .... Betriebsart
//TQ1 .... Artikelbezeichnung


//CONSTANTS
// Disable/enable debug mode (writes log messages)
#define DEBUG_MODE 1


//VARIABLES
char* answer;
float tempAussenluft = 0.0;
float tempZuluft = 0.0;
float tempFortluft = 0.0;
float tempAbluft = 0.0;
float rpmZuluft = 0.0;
float rpmAbluft = 0.0;
float bypass = 0.0;
float anzahlFehler = 0.0;
float anzahlWarnungen = 0.0;
float anzahlInfo = 0.0;
char artikelBez[32];
int betriebsart = 0;
int luefterStufe = 0;

// Modbus TCP header
char modbusTCP[30];

char tIDl,tIDh;
char szBuffer[100];
int nLen;
int err;
int zaehler;

printf("Helios KWL Modbus TCP start");

// modbusTCP Header vorbereiten und konstante Werte eintragen
tIDl=0;
tIDh=0;
// Protocol Identifier - 2 Byte Zahl, immer 0
modbusTCP[2]=0;
modbusTCP[3]=0;
// Length - 2 Byte Zahl - Länge des nachfolgenden Datenpaketes insgesamt
modbusTCP[4]=0;
modbusTCP[5]=0;
// Unit Identifier - immer 180 für Helios KWL
modbusTCP[6]=180;
// reference number - Zweck unklar
modbusTCP[8]=0;
modbusTCP[9]=1;
// Word count - Anzahl der zu schreibenden Worte (16 Bit)
modbusTCP[10]=0;


int modbusTCPwriteVar(char* heliosVar)
{
int wordLen;
int nLen;

// Anfrage mit modbusTCP Header erstellen (variabler Anteil)

// Transaction Identifier - 2 Byte Zahl, die mit jeder Anfrage hochzählt
modbusTCP[0] = tIDh;
modbusTCP[1] = tIDl;
tIDl++;
if (tIDl == 256) {
tIDl = 0;
tIDh++;
if (tIDh == 256)
tIDh = 0;
}
// Function Code
modbusTCP[7] = 16; // Write Multiple Registers (16)
// Word count - Anzahl der zu schreibenden Worte (16 Bit)
// inkl. 0-Byte am Ende (+1), aufrunden (+1)
nLen = strlen(heliosVar);
wordLen = (nLen + 2) >> 1;
nLen = wordLen << 1;
// Length - 2 Byte Zahl - Länge des nachfolgenden Datenpaketes insgesamt
modbusTCP[5] = 7 + nLen;
// Anzahl der zu schreibenden Register (a 16 Bit)
modbusTCP[11] = wordLen;
// Byte count - Anzahl der nachfolgenden Bytes
modbusTCP[12] = nLen;
strncpy(&modbusTCP[13], heliosVar, nLen);

// Header und Daten an Helios senden
stream_write(stream, modbusTCP, 13 + nLen);
stream_flush(stream);

// TCP Datenpaket empfangen, max. 500 msec auf Antwort warten
nLen = stream_read(stream, szBuffer, sizeof(szBuffer) - 1, 500);
if (nLen == 0) {
printf("modbusTCP request for %s failed (0 bytes read) !", heliosVar);
return 1;
} else {
// weitere Überprüfung der Antwort fehlt - Werte ähnlich wie in der Anfrage
// es wird angenommen, dass die Antwort passt
return 0;
}
}


char* modbusTCPreadVar(char* heliosVar, int len)
{
// "countWords" Worte (a 16-Bit) aus Holding Register auslesen
// TCP Anfrage mit modbusTCP Header erstellen

// Transaction Identifier - 2 Byte Zahl, die mit jeder Anfrage hochzählt
modbusTCP[0] = tIDh;
modbusTCP[1] = tIDl;
tIDl++;
if (tIDl == 256) {
tIDl = 0;
tIDh++;
if (tIDh == 256)
tIDh = 0;
}
// Length - 2 Byte Zahl - Länge des nachfolgenden Datenpaketes insgesamt
modbusTCP[5] = 6;
// Function Code
modbusTCP[7] = 3; // Read Holding Registers (3)
// Word count - Anzahl der zu lesenden Worte (16 Bit), muss < 256 sein!
// Variable=6 Byte, "="=1 Byte, Wert=len Byte, 0-Byte am Ende (+1), aufrunden (+1)
modbusTCP[11] = (9 + len) >> 1;
// TCP Datenpaket mit modbus Header senden
stream_write(stream, modbusTCP, 12);
stream_flush(stream);

// TCP Datenpaket empfangen, max. 500 msec auf Antwort warten
nLen = stream_read(stream, szBuffer, sizeof(szBuffer) - 1, 500);

// Länge der Antwort prüfen (mind v0XXXX=y\0)
if (nLen>16) {
// Variable auslesen und überprüfen, immer 6 Bytes lang "v0XXXX"
if (strncmp(heliosVar, &szBuffer[9], 6) == 0) {
return &szBuffer[16];
} else {
szBuffer[15]=0;
printf("modbusTCP variable %s is not %s !", heliosVar, &szBuffer[9]);
return NULL;
}
} else {
printf("modbusTCP answer too short, only %i Bytes, <%s>", nLen, &szBuffer[9]);
return NULL;
}
}


float heliosReadFloat(char* heliosVar, int len)
{
int err;
char* answer;
float floatValue;
// 1. Teil: String für Variable schreiben
err = modbusTCPwriteVar(heliosVar);
if (err)
return -999;

// 2. Teil: Antwort aus Holding Register auslesen
answer = modbusTCPreadVar(heliosVar, len);
if (answer != NULL) {
floatValue = atof(answer);
if (DEBUG_MODE)
printf("modbusTCP READ %s = %f", heliosVar, floatValue);
return floatValue;
}
return -999;
}


void heliosReadString(char* heliosVar, char* heliosString, int len)
{
int err;
char* answer;
// 1. Teil: String für Variable schreiben
err = modbusTCPwriteVar(heliosVar);
if (err) {
strcpy(heliosString, "Error!");
return;
}

// 2. Teil: Antwort aus Holding Register auslesen
answer = modbusTCPreadVar(heliosVar, len);
if (answer != NULL) {
strcpy(heliosString, answer);
if (DEBUG_MODE)
printf("modbusTCP READ %s = %s", heliosVar, heliosString);
} else {
strcpy(heliosString, "Error!");
}
}


void heliosWriteInt(char* heliosVar, int value)
{
char heliosString[20];

sprintf(heliosString,"%s=%d", heliosVar, value);
if (DEBUG_MODE)
printf("modbusTCP WRITE %s = %d", heliosVar, value);

modbusTCPwriteVar(heliosString);
}


while(TRUE)
{
// Stream zur IP-Adresse der Helios KWL (Modbus TCP Gegenstelle)
STREAM* stream = stream_create("/dev/tcp/192.168.0.120/502", 1, 0);

if (stream != NULL)
{

// Betriebsart w�hlen 0 = Automat. 1 = Handbetrieb
// Betriebsart schreiben
betriebsart=(int)getinput(0);

if(betriebsart<0)
betriebsart=0;
if(betriebsart>1)
betriebsart=1;

heliosWriteInt("v00101", betriebsart);
sleep(100);

if(betriebsart==1)
{
// Luefterstufe setzen
luefterStufe = (int)getinput(1);
if(luefterStufe<0) luefterStufe=0;
heliosWriteInt("v00102", luefterStufe);
printf("Lüfterstufe manuell schreiben %f",luefterStufe);
sleep(100);
}
else {
printf("Lüfterstufe in Automatik ");
}

// Betriebsart auslesen, char[1]
anzahlInfo = heliosReadFloat("v00101", 1);
setoutput(11, anzahlInfo);
sleep(100);

// Luefterstufe auslesen, char[1]
anzahlInfo = heliosReadFloat("v00102", 1);
setoutput(10, anzahlInfo);
sleep(100);

// Temperatur Aussenluft auslesen, char[7]
tempAussenluft = heliosReadFloat("v00104", 7);
setoutput(0, tempAussenluft);
sleep(100);

// Temperatur Zuluft auslesen, char[7]
tempZuluft = heliosReadFloat("v00105", 7);
setoutput(1, tempZuluft);
sleep(100);

// Temperatur Fortluft auslesen, char[7]
tempFortluft = heliosReadFloat("v00106", 7);
setoutput(2, tempFortluft);
sleep(100);

// Temperatur Abluft auslesen, char[7]
tempAbluft = heliosReadFloat("v00107", 7);
setoutput(3, tempAbluft);
sleep(100);

// Drehzahl Zuluft (rpm) auslesen, char[4]
rpmZuluft = heliosReadFloat("v00348", 4);
setoutput(4, rpmZuluft);
sleep(100);

// Drehzahl Abluft (rpm) auslesen, char[4]
rpmAbluft = heliosReadFloat("v00349", 4);
setoutput(5, rpmAbluft);
sleep(100);

// Bypass auslesen, char[1], undokumentiert!
bypass = heliosReadFloat("v02119", 1);
setoutput(6, bypass);
sleep(100);

// AnzahlFehler auslesen, char[2]
anzahlFehler = heliosReadFloat("v01300", 2);
setoutput(7, anzahlFehler);
sleep(100);

// AnzahlWarnungen auslesen, char[1]
anzahlWarnungen = heliosReadFloat("v01301", 1);
setoutput(8, anzahlWarnungen);
sleep(100);

// AnzahlInfo auslesen, char[1]
anzahlInfo = heliosReadFloat("v01302", 1);
setoutput(9, anzahlInfo);
sleep(100);

// Artikelbezeichnung auslesen, char[31]
heliosReadString("v00000", artikelBez, 31);
setoutputtext(0, artikelBez);
sleep(100);


} else {
printf("Unable to create TCP stream");
sleeps(9);
}
stream_close(stream);
sleeps(1);
}