#define useClientClose 1
#include <Wire.h>
#include <SPI.h>
#include <NativeEthernet.h>
#include <elapsedMillis.h>
#include <TimeLib.h>
byte mac[] = {0xA8, 0x61, 0x0A, 0xAE, 0x2A, 0x1B };
IPAddress ip(192, 168, 2, 11);
IPAddress gateway(192,168,2, 1);
IPAddress subnet(255, 255, 255, 0);
EthernetServer server(9010);
//IGNORE the following parameters, they remain here, as I cut this software from my major lengthy application
int PowerHeliotherm=0;
boolean allowThorAlways=true;
unsigned long PowerDownThorAsLongNoActivity=0;
int min_MYPV_Power_On=30;
float factorThor=0.862;
int ThorAskedNothing=0;
int max_ThorAskedNothing=240;
float Parameter[275];
int ParameterNrDerPowerForTHOR=0;
boolean PowerThorUpAsThorWantsToWork=false;
boolean bDruck_sendPowerToMYPV=true;
int ErrorCounterACThor=0;
int maxErrorCounterACThor=125;
boolean ConnectionToThorOK=true;
float LastThorPowerSent=0;
boolean GotAZeroBackFromThor=true;
int powerSentToThorSinceLastContactToPC=0;
int AnzahlDerMessungen=0;
int HelioAlert=0;
int LEDred=13;
int LEDyellow=14;
unsigned long LEDred_maxOn=1000;
boolean showThorDetails=true;
unsigned long Jetzt=0;
byte OutBuffer[45];
unsigned long Zeit_topowerDOWN_LEDyellow_PCC=0;
unsigned long timeLastPC_Contact_Request_made=0;
int counter_ServerContactLastMinute=0;
const byte showDataExchangeToRx =0; //zeigt Main Kommunikation mit PC geschickt wird
const byte showDataExchangeToRx2 =0; //zeigt Rest Kommunikation mit PC geschickt wird
const byte showDataExchangeToRxText =0; //zeigt Datenn die zum PC geschickt wird
const byte maxPowerMeasurements=10;
float fPges[1441][maxPowerMeasurements];
boolean firstPges[maxPowerMeasurements]={false, false, false, false, false, false, false, false, false, false};
boolean ItsMidNight[maxPowerMeasurements]={false, false, false, false, false, false, false, false, false, false};
unsigned int dayCounter[maxPowerMeasurements]={0,0,0,0,0,0,0,0,0,0};
int NrAtMidNight[maxPowerMeasurements]={9999,9999,9999,9999,9999,9999,9999,9999,9999,9999};
boolean NotFirstLoop=false;
float old_Ehour[maxPowerMeasurements] = {9999,9999,9999,9999,9999,9999,9999,9999,9999,9999};
float old_Eday[maxPowerMeasurements] = {9999,9999,9999,9999,9999,9999,9999,9999,9999,9999};
float old_Eweek[maxPowerMeasurements] = {9999,9999,9999,9999,9999,9999,9999,9999,9999,9999};
float old_Emonth[maxPowerMeasurements] = {9999,9999,9999,9999,9999,9999,9999,9999,9999,9999};
float Estunde[24][maxPowerMeasurements]; //hier speichern wir die stündlichen Summen ab
float old_Estunde[24][maxPowerMeasurements]; //hier speichern wir die stündlichen Summen ab
int counterEstunde[maxPowerMeasurements]={0,0,0,0,0,0,0,0,0,0};
int counterEtag[maxPowerMeasurements]={0,0,0,0,0,0,0,0,0,0};
int ErrorCounter[maxPowerMeasurements]={0,0,0,0,0,0,0,0,0,0};
int old_ErrorCounter[maxPowerMeasurements]={0,0,0,0,0,0,0,0,0,0};
float Etag[maxPowerMeasurements]; //hier speichern wir die laufende Tagessumme ab, dh Summe aller Messwerte durch Anzahl der Messwert
float oldEtag[maxPowerMeasurements]; //hier den gestrigen Wert, so dass wir ihn nach Miternacht für 24 Stunden abrufen können
byte letzteStunde=26;
byte dieseStunde =25;
boolean fPgesMemoryOverflow[maxPowerMeasurements]={false, false, false, false, false, false, false, false, false, false};
boolean old_fPgesMemoryOverflow[maxPowerMeasurements]={false, false, false, false, false, false, false, false, false, false};
byte ConversionLfdNrZuParameterNr[maxPowerMeasurements]={0,1,2,15,16,17,18,35,36,37};
float LastPowerMeasurement[maxPowerMeasurements];
float AverageBezug1Minute=0; int CountBezug1Minute=0;
float AverageLieferung1Minute=0; int CountLieferung1Minute=0;
float lastAverageBezug1Minute=0;
float lastAverageLieferung1Minute=0;
int EndSwitches=10;
int startCO2=15;
int SendErrorMsg1=5;
int SunRiseMinAfterMidnight=400;
int SunSetMinAfterMidnight=800;
int ThorStatusForPrintInClock=0;
int PowerUsedByMYPV=3459;
int max_MYPV_Power_Used=3500;
float T_wellness_1=38;
float T_wellness_2=39.5;
float Vbat_Wellness=4.55;
int NewInfoType=2;
int WasserVerbrauchToday=850;
byte KlimaOnOff=1;
float oldGeniaxKorrekturSimple=21;
float GeniaxKorrekturSimple=21.5;
byte cVorne_GeniaxKorrekturSimple = 0;
byte cHinten_GeniaxKorrekturSimple =0;
byte cVorne_GeniaxKorrekturComplex = 0;
byte cHinten_GeniaxKorrekturComplex =0;
float oldGeniaxKorrekturComplex=0;
float GeniaxKorrekturComplex=0;
int SolarPowerNow=0;
unsigned long Left_PC_Contact=0;
unsigned long timeOutCall=0;
boolean useClientClose_PC_Contact=true;
void setup()
{
Serial.begin(250000);
//Ignore these inits, they are caused by my snippet
OutBuffer[ 0]=0x47; OutBuffer[ 1]=0x45; OutBuffer[ 2]=0x54; OutBuffer[ 3]=0x20; OutBuffer[ 4]=0x2F; OutBuffer[ 5]=0x63; OutBuffer[ 6]=0x6F; OutBuffer[ 7]=0x6E; OutBuffer[ 8]=0x74; OutBuffer[ 9]=0x72; //GET /contr
OutBuffer[10]=0x6F; OutBuffer[11]=0x6C; OutBuffer[12]=0x2E; OutBuffer[13]=0x68; OutBuffer[14]=0x74; OutBuffer[15]=0x6D; OutBuffer[16]=0x6C; OutBuffer[17]=0x3F; OutBuffer[18]=0x70; OutBuffer[19]=0x6F; //ol.html?po
OutBuffer[20]=0x77; OutBuffer[21]=0x65; OutBuffer[22]=0x72; OutBuffer[23]=0x3D;
Parameter[0]=1;
pinMode(LEDred,OUTPUT);
pinMode(LEDyellow,OUTPUT);
Serial.println(F("connecting to Ethernet"));
pinMode(4,OUTPUT); digitalWrite(4,HIGH);
Ethernet.begin(mac, ip, gateway, subnet);
//server.begin(); //start listening for clients on EThernet
delay(1000);
}
void loop()
{
if(millis()-timeOutCall>17000)
{
//sendPowerToMYPV2(0,500);
timeOutCall=millis();
}
PCContact();
delay(1);
}
//--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void PCContact()
{
char ReadText[120];
byte Count=0;
byte Action=99;
long t1=millis();
Ethernet.setRetransmissionCount(1); //<-------------------------------------------------------------------------------------------------------------------
Ethernet.setRetransmissionTimeout(50); //<-------------------------------------------------------------------------------------------------------------------
EthernetClient client = server.available();
client.setConnectionTimeout(25);
boolean ExtraLine=false;
if (client)
{
//wait for Data from client
elapsedMillis waitPC1;
//wait for Server to connect
while(!client.available() && waitPC1 < 10000)
{
delayMicroseconds(1);
if(waitPC1>16 && waitPC1%16==0) checkSerial1_for_KNX();
}
if(waitPC1 > 1000) {Serial.print("waitPC1: "); Serial.print(waitPC1); Serial.print("\tBytes:"); Serial.println(client.available());} //INFO ONLY
if (client.available())
{
Serial.println();
while(client.available() && Count<95 )
{
ReadText[Count] = client.read();
if(ReadText[Count]>48) Serial.print(ReadText[Count]);
Count++;
}
if(ReadText[0]=='G' && ReadText[1]=='E' && ReadText[2]=='T')
{
Action = AnalyseGet(ReadText); //Decode Get Information
boolean currentLineIsBlank = true;
int Limiter=0;
//In case we haven't already read everything
while(client.available() && Limiter<120)
{
char c = client.read(); Serial.print(c); // see what has been received
if (c == '\n')
{
currentLineIsBlank = true; // you're starting a new line
}
else if (c != '\r')
{
currentLineIsBlank = false; // you've gotten a character on the current line
}
if (c == '\n' && currentLineIsBlank) break;
Limiter++;
}
//Response - usually this connection goes to a true HTTP Server
client.println(F("HTTp/1.1 200 OK")); client.println(F("Content-Type: text/html")); client.println(F("Connnection: close")); client.println();
Serial.print("\tAction:"); Serial.print(Action); byte SockNr = client.getSocketNumber(); Serial.print("\tSkNr@Start:"); Serial.print(SockNr);
switch (Action)
{
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
case 0: //Info not understood
{
Serial.print(F("\n\n\tCannot decode PC's GET Request. RXed: ")); Serial.print(ReadText); Serial.print(F(" Count="));Serial.println(Count);
client.println(F("NOK"));
break;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
case 99: //favicon - nothing to do
{
Serial.println(F("Favicon"));
break;
}
//====================================================================================================================================================================
case 20: //sende Pges Daten an den PC
{
//There is nothing special about this case 20, it has been stripped from my major application for this test - it basically sends
//in this test example : 0$0.00$0.00$0.00$0.00$0$27$53$1$1$1970$0$0.00$0$0.00$0.00$DATA$DATA
// else if(ReadText[5]=='P' && ReadText[6]=='g' && ReadText[7]=='E' && ReadText[8]=='s' && ReadText[9]=='N') bReturn=20; //Messwerte der letzten Zeit senden
//GET /PgEsNpq_FabcdTvxyz$VAB$
//012345678901234567890123
if(ReadText[10]!=ReadText[11] || ReadText[10]<48 || ReadText[10]>57) {Serial.print(F("Invalid Request: ")); Serial.println(ReadText); break;}
int PNr= ReadText[10] -48;
int StartIndex=0; int EndIndex=dayCounter[PNr];
//bei partieller Anfrage gilt GET /PgEsNpq_FabcdTvxyz$VAB$
// 012345678901234567890123
// p=q ParameterNr
// FROM
// To .it VAB=V-1 für gestern
if(PNr==9) ExtraLine=true;
if(ReadText[13]=='F' && ReadText[18]=='T' && ReadText[23]=='$')
{
int S=0;
int E= dayCounter[PNr];
//partielle Anfrage
if( (ReadText[14]=='0' || ReadText[14]=='1') && ReadText[15]>=48 && ReadText[15]<=57 && ReadText[16]>=48 && ReadText[16]<=57 && ReadText[17]>=48 && ReadText[17]<=57)
{
S = (ReadText[14]-48)*1000 + (ReadText[15]-48)*100 + (ReadText[16]-48)*10 + (ReadText[17]-48);
}
else
{
//Serial.print(F("14 15 16 17: ")); Serial.print(ReadText[14]); Serial.print(ReadText[15]); Serial.print(ReadText[16]); Serial.println(ReadText[17]);
}
if(ReadText[19]!='x' || ReadText[20]!='x' || ReadText[21]!='x' || ReadText[22]!='x' )
{
if( (ReadText[19]=='0' || ReadText[19]=='1') && ReadText[20]>=48 && ReadText[20]<=57 && ReadText[21]>=48 && ReadText[21]<=57 && ReadText[22]>=48 && ReadText[22]<=57 )
{
E = (ReadText[19]-48)*1000 + (ReadText[20]-48)*100 + (ReadText[21]-48)*10 + (ReadText[22]-48);
}
}
else
{
//Serial.print(F("19 20 21 22: ")); Serial.print(ReadText[19]); Serial.print(ReadText[20]); Serial.print(ReadText[21]); Serial.println(ReadText[22]);
}
if(E>=S)
{
StartIndex=S; EndIndex=E;
}
else
{
//Serial.print(F("E: ")); Serial.print(E); Serial.print(F(" S: ")); Serial.println(S);
}
}
else
{
//Serial.print(F("13 18 23: ")); Serial.print(ReadText[13]); Serial.print(ReadText[18]); Serial.println(ReadText[23]);
}
//Serial.print(F("Pges[")); Serial.print(PNr); Serial.print(F("] -> PC from: ")); Serial.print(StartIndex); Serial.print(F(" to ")); Serial.print(EndIndex);
if(ReadText[24]=='V' && ReadText[25]=='-' && ReadText[26]=='1' )
{
client.print(dayCounter[PNr]); client.print(F("$"));
client.print(Parameter[267]); client.print(F("$"));
client.print(Parameter[268]); client.print(F("$"));
client.print(Parameter[269]); client.print(F("$"));
client.print(LastPowerMeasurement[PNr]); client.print(F("$"));
client.print(hour()); client.print(F("$"));
client.print(minute()); client.print(F("$"));
client.print(second()); client.print(F("$"));
client.print(day()); client.print(F("$"));
client.print(month()); client.print(F("$"));
client.print(year()); client.print(F("$"));
client.print(counterEstunde[PNr]); client.print(F("$"));
client.print(Estunde[letzteStunde][PNr]); client.print(F("$"));
client.print(counterEtag[PNr]); client.print(F("$"));
client.print(Etag[PNr]); client.print(F("$"));
client.print(Parameter[EndSwitches+1]);
client.print(F("$DATA$"));
for (int i=StartIndex; i< EndIndex; i++)
{
client.print(F("$"));
if(i%100==0) checkSerial1_for_KNX();
}
client.print(F("DATA"));
}
else
{
client.print(dayCounter[PNr]); client.print(F("$"));
client.print(Parameter[267]); client.print(F("$"));
client.print(Parameter[268]); client.print(F("$"));
client.print(Parameter[269]); client.print(F("$"));
client.print(LastPowerMeasurement[PNr]); client.print(F("$"));
client.print(hour()); client.print(F("$"));
client.print(minute()); client.print(F("$"));
client.print(second()); client.print(F("$"));
client.print(day()); client.print(F("$"));
client.print(month()); client.print(F("$"));
client.print(year()); client.print(F("$"));
client.print(counterEstunde[PNr]); client.print(F("$"));
client.print(Estunde[letzteStunde][PNr]); client.print(F("$"));
client.print(counterEtag[PNr]); client.print(F("$"));
client.print(Etag[PNr]); client.print(F("$"));
client.print(Parameter[EndSwitches+1]); client.print(F("$DATA$"));
for (int i=StartIndex; i< EndIndex; i++)
{
client.print(fPges[i][PNr],4);
client.print(F("$"));
if(i%100==0) checkSerial1_for_KNX();
}
client.print(F("DATA"));
}
break;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
default:
{
break;
}
} //end e switch(Action)
ReadText[0]=0;
} //ENDE else if(ReadText[0]=='G' && ReadText[1]=='E' && ReadText[2]=='T')
} //end if(client.available())
Serial.print(F("\t\tadditional Info rxed: "));
int addC=0;
while(client.available())
{
char c=client.read(); Serial.print("0x");Serial.print(c, HEX); Serial.print(" ");
addC++;
}
if(addC>2) {Serial.print(" = Nr of Bytes:"); Serial.print(addC); } else Serial.print(F(" = None"));
#if defined (useClientClose)
if( useClientClose_PC_Contact)
{
client.close(); Serial.print("\tclient.close done");
byte SockNr = client.getSocketNumber(); Serial.print(" SNrP1:"); Serial.print(SockNr);
}
#endif
client.stop(); Serial.print("\tclient.stop executed"); byte SockNr = client.getSocketNumber(); Serial.print(" SkNr@End:"); Serial.print(SockNr);
Serial.print(F("\tdt_ms: ")); Serial.println(millis()-t1);
if(ExtraLine) Serial.println();
} //end if(client)
} //End Routine
//----------------------------------------------------------------------------------------------------------------------------
byte AnalyseGet(char ReadText[])
{
byte bReturn=0;
if(ReadText[3]==' ' && ReadText[4]=='/')
{
if (ReadText[5]=='f' && ReadText[6]=='a' && ReadText[7]=='v' && ReadText[8]=='i' && ReadText[9]=='c' && ReadText[10]=='o' ) bReturn=99; //Favicon ignore
else if(ReadText[5]=='P' && ReadText[6]=='g' && ReadText[7]=='E' && ReadText[8]=='s' && ReadText[9]=='N') bReturn=20; //Messwerte der letzten Zeit senden
}
return bReturn;
}
//==============================================================================================================================================================================================================================
int sendPowerToMYPV2(float DataToSend, float MaxData)
{
//This routine connects to a Server, which responds typically in 65ms and then sends ~810 bytes within 2.5ms.
//if(Parameter[ParameterNrDerPowerForTHOR]==0) {Serial.print(F("\n\tThor IS POWERED OFF")); return 0;}
byte OutBuffer[45];
OutBuffer[ 0]=0x47; OutBuffer[ 1]=0x45; OutBuffer[ 2]=0x54; OutBuffer[ 3]=0x20; OutBuffer[ 4]=0x2F; OutBuffer[ 5]=0x63; OutBuffer[ 6]=0x6F; OutBuffer[ 7]=0x6E; OutBuffer[ 8]=0x74; OutBuffer[ 9]=0x72; //GET /contr
OutBuffer[10]=0x6F; OutBuffer[11]=0x6C; OutBuffer[12]=0x2E; OutBuffer[13]=0x68; OutBuffer[14]=0x74; OutBuffer[15]=0x6D; OutBuffer[16]=0x6C; OutBuffer[17]=0x3F; OutBuffer[18]=0x70; OutBuffer[19]=0x6F; //ol.html?po
OutBuffer[20]=0x77; OutBuffer[21]=0x65; OutBuffer[22]=0x72; OutBuffer[23]=0x3D;
//Ist Thor allowed, if not show this
Serial.print(F("\n\t")); Serial.print(DataToSend); Serial.print(F("->Thor")); Serial.print(F(" Max:")); Serial.print(MaxData);
if(PowerHeliotherm > 0 && PowerHeliotherm < 9000 && allowThorAlways==false) {Serial.print(F(" Helio ON & allowThorAlways=false -> Send 0")); MaxData=0; }
//Thor is active, allowed to fire
unsigned long Jetzt=millis();
byte ThorBuffer[900]; int len=0;
//Ausgabewert gegen Grenzwerte checken und bei Bedarf beschränken
if(DataToSend > MaxData) DataToSend= MaxData;
else if(DataToSend < min_MYPV_Power_On) DataToSend = 0;
//korrigiert, die Wattzahl, in die von Thor benötigte, denn Thor geht von 100% = 3kW aus
DataToSend=DataToSend/factorThor;
int iData=int(DataToSend);
//Sicherheitsabfrage gegen negative Werte und Uhr starten,die die Zeit des letzten positiven Requesta an Thor zeigt
if(iData > 0)
{
PowerDownThorAsLongNoActivity = millis(); //compare against + max_PowerDownThorAsLongNoActivity denn thor schaltet nach dieser Zeit ab, wenn es keine Thor Leistung in diesem Intervall gab
ThorAskedNothing=0;
//Ist Thor noch aus, dann macht dieser Request keinen Sinn, aber über das Flag PowerThorUpAsThorWantsToWork wird Thor gestartet werden
if(Parameter[ParameterNrDerPowerForTHOR]==0) { PowerThorUpAsThorWantsToWork=true; return 0;}
}
else
{
ThorAskedNothing++;
}
Serial.print(F("\t-> iPwr:")); Serial.print(iData);
//Zuviele Requests der Größe 0 (oder kleiner) wurden nacheinander gemacht, in diesem Fall können wir Thor einfach nicht länger ansteuern, denn dann geht dieser sowieso nach 0
if(ThorAskedNothing > max_ThorAskedNothing)
{
ThorAskedNothing--;
Serial.print(F(" > ")); Serial.print(max_ThorAskedNothing); Serial.println(F(" ZeroPWR an Thor -> stop sending until >0 again"));
return 0;
}
//Jetzt haben wir einen Wert, den wir an Thor senden wollen
const byte mypv[] = {192, 168, 2, 172};
//OUTPUT BUFFER mit Payload versehen
//Started in Setup by:
// void init_Thor_OutBuffer()
// {
// OutBuffer[ 0]=0x47; OutBuffer[ 1]=0x45; OutBuffer[ 2]=0x54; OutBuffer[ 3]=0x20; OutBuffer[ 4]=0x2F; OutBuffer[ 5]=0x63; OutBuffer[ 6]=0x6F; OutBuffer[ 7]=0x6E; OutBuffer[ 8]=0x74; OutBuffer[ 9]=0x72; //GET /contr
// OutBuffer[10]=0x6F; OutBuffer[11]=0x6C; OutBuffer[12]=0x2E; OutBuffer[13]=0x68; OutBuffer[14]=0x74; OutBuffer[15]=0x6D; OutBuffer[16]=0x6C; OutBuffer[17]=0x3F; OutBuffer[18]=0x70; OutBuffer[19]=0x6F; //ol.html?po
// OutBuffer[20]=0x77; OutBuffer[21]=0x65; OutBuffer[22]=0x72; OutBuffer[23]=0x3D; //wer=
// }
int W=iData; int index=28;
if(W>=1000)
{
int T=W/1000; byte bT=byte(T); W=W-T*1000;
int H=W/100; byte bH=byte(H); W=W-H*100;
int Z=W/10; byte bZ=byte(Z); W=W-Z*10;
int E=W; byte bE=byte(E); OutBuffer[24]=bT+48; OutBuffer[25]=bH+48; OutBuffer[26]=bZ+48; OutBuffer[27]=bE+48;
}
else if(W>=100)
{
index=27;
int H=W/100; byte bH=byte(H); W=W-H*100;
int Z=W/10; byte bZ=byte(Z); W=W-Z*10;
int E=W; byte bE=byte(E); OutBuffer[24]=bH+48; OutBuffer[25]=bZ+48; OutBuffer[26]=bE+48;
}
else if(W>=10)
{
index=26;
int Z=W/10; byte bZ=byte(Z); W=W-Z*10;
int E=W; byte bE=byte(E); OutBuffer[24]=bZ+48; OutBuffer[25]=bE+48;
}
else
{
index=25; byte bE=byte(W); OutBuffer[24]=bE+48;
}
OutBuffer[index ]=0x20; OutBuffer[index+ 1]=0x48; OutBuffer[index+ 2]=0x54; OutBuffer[index+3 ]=0x54; OutBuffer[index+4]=0x50; OutBuffer[index+5]=0x2F; OutBuffer[index+6]=0x31; OutBuffer[index+7]=0x2E; OutBuffer[index+8]=0x31; // blank HTTP/1.1
OutBuffer[index+9]=0x0D; OutBuffer[index+10]=0x0A; OutBuffer[index+11]=0x0D; OutBuffer[index+12]=0x0A;
//Serial.print("OutBuffer: "); for(int i=0; i<index+13;i++) {Serial.print(OutBuffer[i],HEX); Serial.print(" "); } Serial.println();
//Fertig nun zum Senden an Thor
EthernetClient client;
Ethernet.setRetransmissionCount(1); //<-------------------------------------------------------------------------------------------------------------------
Ethernet.setRetransmissionTimeout(50); //<-------------------------------------------------------------------------------------------------------------------
checkSerial1_for_KNX(); //um maximale Zeit zu haben
boolean ReturnedOK=true;
if(client.connect(mypv, 80)==1)
{
Serial.print(F("\tconnect OK"));
byte SockNr = client.getSocketNumber(); Serial.print(" SkNr@Begin:"); Serial.print(SockNr);
client.setConnectionTimeout(100); //<-------------------------------------------------------------------------------------------------------------------
client.write(OutBuffer,index+13);
//auf Antwort warten
elapsedMillis wait;
while (len==0 && wait<500)
{
len = client.available();
checkSerial1_for_KNX();
}
//eine richtige Antwort hat ca. 807bytes
if( (bDruck_sendPowerToMYPV && wait>65) || wait>75) {Serial.print("\tanswer after>65 || 75)ms: "); Serial.print(wait); }
len=client.available(); //sollten es noch mehr geworden sein
if(bDruck_sendPowerToMYPV && (len<800 || len>830) ) {Serial.print("\tlen(>830||<800): "); Serial.print(len); Serial.print("\t");}
Serial.print("\tlen:"); Serial.print(len);
//wurden zuviele oder zuwenig Bytes empfangen
if(len<600 || len>899) //len zeigt die Gesamtlänge der Info an, die Thor gesendet hat, diese muss über 600 sein
{
ErrorCounterACThor++;
Serial.print(F("ErrorCounterACThor ++ to ")); Serial.print(ErrorCounterACThor); Serial.print(F("\tlen:")); Serial.println(len);
//
// if(len>500) //gab es irgendeine Info jenseits 500, dann zeigen wird dies hier an
// {
// for (int i=0; i<len; i++) {Serial.write(buffer[i]);} Serial.println();
// }
return 0;
}
client.read(ThorBuffer,len); //nun lesen wir empfangene Daten
//Lese den Rest, wenn es etwas gibt, ohne Abspecherung
wait=1; int addC=0;
while(client.available() && wait<1000)
{
char c=client.read(); if(bDruck_sendPowerToMYPV) { if(addC==0) Serial.println("\n\t\tRest1: "); Serial.print(c,HEX); Serial.print(F(" ")); }
addC++;
if(wait%10==0) checkSerial1_for_KNX();
}
if(addC>0) {Serial.print("\t(1)readRest:"); Serial.print(addC); Serial.print(" time:"); Serial.print(wait); }
wait=0; addC=0;
while(client.connected() && wait < 1000)
{
addC++;
if(wait%10==0) checkSerial1_for_KNX();
}
if(addC>0) {Serial.print("\t(1)stillconnected:"); Serial.print(wait); }
client.close();
client.stop(); Serial.print("\tclient.stop done"); //delibrately outside if(client.connect(mypv, 80)==1)
SockNr = client.getSocketNumber(); Serial.print(" SkNr@Stop:"); Serial.print(SockNr);
ConnectionToThorOK=true;
}
else
{
Serial.print("\tconnect NOK");
ErrorCounterACThor++;
ReturnedOK=false;
ConnectionToThorOK=false;
}
if(len<360)
{
ErrorCounterACThor++;
Serial.print(F("ErrorCounterACThor ++ to ")); Serial.print(ErrorCounterACThor); Serial.print(F("\tlen:")); Serial.println(len);
if(len>0)
{
for (int i=0; i<len; i++) {Serial.write(ThorBuffer[i]); }
}
return 0;
}
//Nun sollten wir gute Daten haben, wir durchsuchen den String nach Pow=
byte Power[5];
for (int i=350; i<len-100; i++)
{
//Serial.print(ThorBuffer[i]);
if( char(ThorBuffer[i])=='P' && char(ThorBuffer[i+1])=='o' && char(ThorBuffer[i+5])=='=')
{
Power[0]=ThorBuffer[i+6]; Power[1]=ThorBuffer[i+7]; Power[2]=ThorBuffer[i+8]; Power[3]=ThorBuffer[i+9]; Power[4]=ThorBuffer[i+10];
//Serial.print(F("i:")); Serial.println(i);
break;
}
}
//if(bDruck_sendPowerToMYPV) {Serial.print(F("Power:")); for(int i=0; i<5; i++) Serial.print(char(Power[i])); Serial.println();}
//Wir analysieren, die Zahl, die Pow= folgen wird, diese kann 1 bis 4 stellig sein
int j=0;
for(int i=0; i<5; i++)
{
if( char(Power[i]) == ' ')
{
j=i;
break;
}
}
checkSerial1_for_KNX();
//Serial.print(F("j:")); Serial.println(j);
int iPower=9999;
//Bilden die Zahl
switch (j)
{
case 1: iPower=(Power[0]-48); break;
case 2: iPower=(Power[0]-48)*10 + (Power[1]-48); break;
case 3: iPower=(Power[0]-48)*100 + (Power[1]-48)*10 + (Power[2]-48); break;
case 4: iPower=(Power[0]-48)*1000 + (Power[1]-48)*100 + (Power[2]-48)*10 + Power[3]-48; break;
default: if(ReturnedOK==false) iPower=0; else iPower=9999; break;
}
if(iPower!=9999) ErrorCounterACThor=0; //fehlerzähler zurücksetzen
else if(ErrorCounterACThor!=0) {Serial.println(F("\t\tErrorCounterACThor:")); Serial.println(ErrorCounterACThor);} //ggf aufgelaufene Fehler anzeigen
//Serial Ausgabe
if(j!=0)
{
Serial.print("\tThor retrnd: :"); Serial.print(iPower);
if( (iPower<10 || MaxData==0) && iData > 25 && LastThorPowerSent > 25) { Serial.print(F(" GotAZeroBackFromThor->true ")); GotAZeroBackFromThor=true; }
//Mittlere Power errechnen, die Thor ausgab, seit letzeter Übermittelung an Website
powerSentToThorSinceLastContactToPC+=iPower;
AnzahlDerMessungen++;
Serial.print("\t\t<P(sent)>: "); Serial.print(powerSentToThorSinceLastContactToPC/AnzahlDerMessungen);
}
else
{
Serial.println(F("\tThor contact failed"));
}
unsigned long ComTimeForDefault = millis()-Jetzt; //time_ofThorLoopControl=int(ComTimeForDefault); //Bearbeitungszeit dieser Routine
Serial.print(F("\tdt_ms:")); Serial.println(ComTimeForDefault);
return iPower;
}
//============================================================================================================================================================================================================================
void checkSerial1_for_KNX()
{
//this routine checks 9600baud KNX Bus on Serial1
}