void Meteostick::Do_PollWork()
{
bool bFirstTime = true;
int sec_counter = 0;
while (!m_stoprequestedpoller)
{
sleep_seconds(1);
sec_counter++;
if (sec_counter % 12 == 0) {
m_LastHeartbeat = mytime(NULL);
}
if (!isOpen())
{
if (m_retrycntr == 0)
{
_log.Log(LOG_STATUS, "Meteostick: serial setup retry in %d seconds...", RETRY_DELAY);
}
m_retrycntr++;
if (m_retrycntr >= RETRY_DELAY)
{
m_retrycntr = 0;
if (OpenSerialDevice())
bFirstTime = true;
}
}
}
_log.Log(LOG_STATUS, "Meteostick: Worker stopped...");
}
void MySensorsSerial::Do_Work()
{
int sec_counter = 0;
while (!m_stoprequested)
{
sleep_seconds(1);
sec_counter++;
if (sec_counter % 12 == 0) {
mytime(&m_LastHeartbeat);
}
if (m_stoprequested)
break;
if (!isOpen())
{
if (m_retrycntr == 0)
{
_log.Log(LOG_STATUS, "MySensors: retrying in %d seconds...", RETRY_DELAY);
}
m_retrycntr++;
if (m_retrycntr >= RETRY_DELAY)
{
m_retrycntr = 0;
OpenSerialDevice();
}
}
}
_log.Log(LOG_STATUS, "MySensors: Serial Worker stopped...");
}
void Meteostick::Do_PollWork()
{
bool bFirstTime = true;
while (!m_stoprequestedpoller)
{
sleep_seconds(1);
time_t atime = mytime(NULL);
struct tm ltime;
localtime_r(&atime, <ime);
if (ltime.tm_sec % 12 == 0) {
mytime(&m_LastHeartbeat);
}
if (!isOpen())
{
if (m_retrycntr == 0)
{
_log.Log(LOG_STATUS, "Meteostick: serial setup retry in %d seconds...", RETRY_DELAY);
}
m_retrycntr++;
if (m_retrycntr >= RETRY_DELAY)
{
m_retrycntr = 0;
if (OpenSerialDevice())
bFirstTime = true;
}
}
}
_log.Log(LOG_STATUS, "Meteostick: Worker stopped...");
}
void KMTronicSerial::Do_Work()
{
int sec_counter = 0;
while (!m_stoprequested)
{
sleep_seconds(1);
sec_counter++;
if (sec_counter % 12 == 0) {
m_LastHeartbeat=mytime(NULL);
}
if (m_stoprequested)
break;
if (!isOpen())
{
if (m_retrycntr == 0)
{
_log.Log(LOG_STATUS, "KMTronic: retrying in %d seconds...", RETRY_DELAY);
}
m_retrycntr++;
if (m_retrycntr >= RETRY_DELAY)
{
m_retrycntr = 0;
if (OpenSerialDevice())
{
GetRelayStates();
}
}
}
}
_log.Log(LOG_STATUS, "KMTronic: Serial Worker stopped...");
}
void OTGWSerial::Do_PollWork()
{
bool bFirstTime=true;
int sec_counter = 25;
while (!m_stoprequestedpoller)
{
sleep_seconds(1);
sec_counter++;
if (sec_counter % 12 == 0) {
m_LastHeartbeat=mytime(NULL);
}
if (!isOpen())
{
if (m_retrycntr==0)
{
_log.Log(LOG_STATUS,"OTGW: serial setup retry in %d seconds...", RETRY_DELAY);
}
m_retrycntr++;
if (m_retrycntr>=RETRY_DELAY)
{
m_retrycntr=0;
if (OpenSerialDevice())
{
bFirstTime = true;
}
}
}
else
{
if ((sec_counter % 28 == 0) && (m_bRequestVersion))
{
m_bRequestVersion = false;
GetVersion();
}
else if ((sec_counter % 30 == 0) || (bFirstTime)) //updates every 30 seconds
{
bFirstTime = false;
SendOutsideTemperature();
SendTime();
GetGatewayDetails();
}
}
}
_log.Log(LOG_STATUS,"OTGW: Worker stopped...");
}
void CJabloDongle::Do_Work() {
int sec_counter=30-5;
_log.Log(LOG_STATUS,"JabloDongle: Worker started...");
while (!m_stoprequested)
{
sleep_seconds(1);
sec_counter++;
if (sec_counter%12==0)
{
m_LastHeartbeat=mytime(NULL);
}
if (sec_counter%30==0)
{
//poll status
}
if(!isOpen()) {
OpenSerialDevice();
if(ProbeDongle()) {
m_stoprequested = true;
}
ReadSlots();
SendSwitchIfNotExists(0x1000000, SUBSWITCH_PGX, 0, false, 0, "PGX");
SendSwitchIfNotExists(0x1000000, SUBSWITCH_PGY, 0, false, 0, "PGY");
if(!SendSwitchIfNotExists(0x1000001, 0, 0, false, 0, "SIREN_LOUD")) {
SetSwitchIcon(0x1000001, 0, 13); //Set wonderful red light icon in web gui
}
if(!SendSwitchIfNotExists(0x1000002, 0, 0, false, 0, "SIREN_BEEP")) {
SetSwitchType(0x1000002, 0, STYPE_Dimmer);
}
if(!SendSwitchIfNotExists(0x1000003, 0, 0, false, 0, "ENROLL")) {
SetSwitchIcon(0x1000003, 0, 9);
}
//add smoke detectors at startup (they are difficult to activate :-) )
for(std::vector<Ja_device*>::iterator i = slots.begin(); i != slots.end(); i++) {
if((*i)->model == JDEV_JA85ST) {
std::stringstream dev_desc;
dev_desc << (*i)->ModelAsString() << "_" << std::setfill('0') << (*i)->id << "_SENSOR";
SendSwitchIfNotExists((*i)->id, SUBSWITCH_SENSOR, 0, false, 0, dev_desc.str());
}
}
}
}
_log.Log(LOG_STATUS,"JabloDongle: Worker stopped...");
}
void OTGWSerial::Do_PollWork()
{
bool bFirstTime=true;
while (!m_stoprequestedpoller)
{
sleep_seconds(1);
time_t atime = mytime(NULL);
struct tm ltime;
localtime_r(&atime, <ime);
if (ltime.tm_sec % 12 == 0) {
mytime(&m_LastHeartbeat);
}
if (!isOpen())
{
if (m_retrycntr==0)
{
_log.Log(LOG_STATUS,"OTGW: serial setup retry in %d seconds...", RETRY_DELAY);
}
m_retrycntr++;
if (m_retrycntr>=RETRY_DELAY)
{
m_retrycntr=0;
if (OpenSerialDevice())
bFirstTime=true;
}
}
else
{
time_t atime=time(NULL);
if ((atime%30==0)||(bFirstTime)) //updates every 30 seconds
{
bFirstTime=false;
SendOutsideTemperature();
SendTime();
GetGatewayDetails();
}
}
}
_log.Log(LOG_STATUS,"OTGW: Worker stopped...");
}
void CRego6XXSerial::Do_Work()
{
int sec_counter = 0;
while (!m_stoprequested)
{
sleep_seconds(1);
if (m_stoprequested)
break;
sec_counter++;
if (sec_counter % 12 == 0) {
m_LastHeartbeat=mytime(NULL);
}
if (!isOpen())
{
if (m_retrycntr==0)
{
_log.Log(LOG_STATUS,"Rego6XX: serial retrying in %d seconds...", Rego6XX_RETRY_DELAY);
}
m_retrycntr++;
if (m_retrycntr>=Rego6XX_RETRY_DELAY)
{
m_retrycntr=0;
m_pollcntr = 0;
m_pollDelaycntr = 0;
m_readBufferHead = 0;
m_readBufferTail = 0;
OpenSerialDevice();
}
}
else if(m_errorcntr > Rego6XX_MAX_ERRORS_UNITL_RESTART)
{
// Reopen the port and clear the error counter.
try {
clearReadCallback();
close();
doClose();
setErrorStatus(true);
} catch(...)
{
//Don't throw from a Stop command
}
_log.Log(LOG_ERROR,"Rego6XX: Reopening serial port");
sleep_seconds(2);
m_retrycntr=0;
m_pollcntr = 0;
m_pollDelaycntr = 0;
m_readBufferHead = 0;
m_readBufferTail = 0;
m_errorcntr = 0;
OpenSerialDevice();
}
else
{
m_pollDelaycntr++;
if (m_pollDelaycntr>=Rego6XX_COMMAND_DELAY)
{
// Before issueing a new command, the recieve buffer must be empty.
// It seems that there are errors sometimes and this will take care
// of any problems even if it bypasses the circular buffer concept.
// There should not be any data left to recieve anyway since commands
// are sent with 5 seconds in between.
m_readBufferHead = 0;
m_readBufferTail = 0;
m_pollDelaycntr = 0;
if(g_allRegisters[m_pollcntr].type != REGO_TYPE_NONE)
{
RegoCommand cmd;
cmd.data.address = 0x81;
cmd.data.command = 0x02;
switch(m_regoType)
{
case 0:
cmd.data.regNum[0] = (g_allRegisters[m_pollcntr].regNum_type1 & 0xC000) >> 14 ;
cmd.data.regNum[1] = (g_allRegisters[m_pollcntr].regNum_type1 & 0x3F80) >> 7 ;
cmd.data.regNum[2] = g_allRegisters[m_pollcntr].regNum_type1 & 0x007F;
break;
case 1:
cmd.data.regNum[0] = (g_allRegisters[m_pollcntr].regNum_type2 & 0xC000) >> 14 ;
cmd.data.regNum[1] = (g_allRegisters[m_pollcntr].regNum_type2 & 0x3F80) >> 7 ;
cmd.data.regNum[2] = g_allRegisters[m_pollcntr].regNum_type2 & 0x007F;
break;
case 2:
cmd.data.regNum[0] = (g_allRegisters[m_pollcntr].regNum_type3 & 0xC000) >> 14 ;
cmd.data.regNum[1] = (g_allRegisters[m_pollcntr].regNum_type3 & 0x3F80) >> 7 ;
cmd.data.regNum[2] = g_allRegisters[m_pollcntr].regNum_type3 & 0x007F;
break;
default:
_log.Log(LOG_ERROR,"Rego6XX: Unknown type!");
break;
}
cmd.data.value[0] = 0;
cmd.data.value[1] = 0;
cmd.data.value[2] = 0;
cmd.data.crc = 0;
for ( int i = 2; i < 8; i++ )
cmd.data.crc ^= cmd.raw[ i ];
WriteToHardware((char*)cmd.raw, sizeof(cmd.raw));
}
else
{
m_pollcntr = 0;
}
}
void CDavisLoggerSerial::Do_Work()
{
int sec_counter = 0;
while (!m_stoprequested)
{
sleep_seconds(1);
sec_counter++;
if (sec_counter % 12 == 0) {
mytime(&m_LastHeartbeat);
}
if (m_stoprequested)
break;
#ifdef DEBUG_DAVIS
sOnConnected(this);
HandleLoopData(NULL,0);
continue;
#endif
if (!isOpen())
{
if (m_retrycntr==0)
{
_log.Log(LOG_STATUS,"Davis: serial setup retry in %d seconds...", RETRY_DELAY);
}
m_retrycntr++;
if (m_retrycntr>=RETRY_DELAY)
{
m_retrycntr=0;
OpenSerialDevice();
}
}
else
{
switch (m_state)
{
case DSTATE_WAKEUP:
m_statecounter++;
if (m_statecounter<5) {
write("\n",1);
}
else {
m_retrycntr=0;
//still did not receive a wakeup, lets try again
terminate();
}
break;
case DSTATE_LOOP:
m_statecounter++;
if (m_statecounter>=DAVIS_READ_INTERVAL)
{
m_statecounter=0;
write("LOOP 1\n", 7);
}
break;
}
}
}
_log.Log(LOG_STATUS,"Davis: Serial Worker stopped...");
}
void CDavisLoggerSerial::Do_Work()
{
while (!m_stoprequested)
{
sleep_seconds(1);
if (m_stoprequested)
break;
#ifdef DEBUG_DAVIS
sOnConnected(this);
HandleLoopData(NULL,0);
continue;
#endif
if (!isOpen())
{
if (m_retrycntr==0)
{
_log.Log(LOG_NORM,"Davis: serial setup retry in %d seconds...", RETRY_DELAY);
}
m_retrycntr++;
if (m_retrycntr>=RETRY_DELAY)
{
m_retrycntr=0;
OpenSerialDevice();
}
}
else
{
switch (m_state)
{
case DSTATE_WAKEUP:
m_statecounter++;
if (m_statecounter<5) {
write("\n",1);
}
else {
m_retrycntr=0;
//still did not receive a wakeup, lets try again
try {
clearReadCallback();
close();
doClose();
setErrorStatus(true);
} catch(...)
{
//Don't throw from a Stop command
}
}
break;
case DSTATE_LOOP:
m_statecounter++;
if (m_statecounter>=DAVIS_READ_INTERVAL)
{
m_statecounter=0;
write("LOOP 1\n", 7);
}
break;
}
}
}
_log.Log(LOG_NORM,"Davis: Serial Worker stopped...");
}
void CRFLink::Do_Work()
{
int msec_counter = 0;
int sec_counter = 0;
while (!m_stoprequested)
{
sleep_milliseconds(200);
if (m_stoprequested)
break;
msec_counter++;
if (msec_counter == 5)
{
msec_counter = 0;
sec_counter++;
if (sec_counter % 12 == 0) {
m_LastHeartbeat = mytime(NULL);
}
if (isOpen())
{
if (sec_counter % 10 == 0)
{
//Send ping (keep alive)
time_t atime = mytime(NULL);
if (atime - m_LastReceivedTime > 15)
{
//Timeout
_log.Log(LOG_ERROR, "RFLink: Not received anything for more then 15 seconds, restarting...");
m_retrycntr = (RFLINK_RETRY_DELAY-3) * 5;
m_LastReceivedTime = atime;
try {
clearReadCallback();
close();
doClose();
setErrorStatus(true);
}
catch (...)
{
//Don't throw from a Stop command
}
}
else
write("10;PING;\n");
}
}
}
if (!isOpen())
{
if (m_retrycntr==0)
{
_log.Log(LOG_STATUS,"RFLink: serial retrying in %d seconds...", RFLINK_RETRY_DELAY);
}
m_retrycntr++;
if (m_retrycntr/5>=RFLINK_RETRY_DELAY)
{
m_retrycntr=0;
m_rfbufferpos=0;
OpenSerialDevice();
}
}
/*
if (m_sendqueue.size()>0)
{
boost::lock_guard<boost::mutex> l(m_sendMutex);
std::vector<std::string>::iterator itt=m_sendqueue.begin();
if (itt!=m_sendqueue.end())
{
std::string sBytes=*itt;
write(sBytes.c_str(),sBytes.size());
m_sendqueue.erase(itt);
}
}
*/
}
_log.Log(LOG_STATUS,"RFLink: Serial Worker stopped...");
}
