void CDavisLoggerSerial::readCallback(const char *data, size_t len)
{
boost::lock_guard<boost::mutex> l(readQueueMutex);
try
{
//_log.Log(LOG_NORM,"Davis: received %ld bytes",len);
switch (m_state)
{
case DSTATE_WAKEUP:
if (len==2) {
_log.Log(LOG_NORM,"Davis: System is Awake...");
m_state=DSTATE_LOOP;
m_statecounter=DAVIS_READ_INTERVAL-1;
}
break;
case DSTATE_LOOP:
if (len==2)
break; //could be a left over from the awake
if (len!=100) {
_log.Log(LOG_ERROR,"Davis: Invalid bytes received!...");
//lets try again
try {
clearReadCallback();
close();
doClose();
setErrorStatus(true);
} catch(...)
{
//Don't throw from a Stop command
}
}
else {
if (!HandleLoopData((const unsigned char*)data,len))
{
//error in data, try again...
try {
clearReadCallback();
close();
doClose();
setErrorStatus(true);
} catch(...)
{
//Don't throw from a Stop command
}
}
}
break;
}
//onRFXMessage((const unsigned char *)data,len);
}
catch (...)
{
}
}
/**
* Process a clean close by unregistering the read callback and closing the port.
* Once this method has been called, you have to open the port and register the read callback again.
*/
void AsyncSerial::terminate(bool silent/*=true*/) {
if (isOpen()) {
try {
clearReadCallback();
close();
doClose();
setErrorStatus(true);
} catch(...) {
if (silent == false) {
throw;
}
}
}
}
bool Teleinfo::StopHardware()
{
if (isOpen())
{
try {
clearReadCallback();
close();
} catch(...)
{
//Don't throw from a Stop command
}
}
StopHeartbeatThread();
m_bIsStarted=false;
return true;
}
bool S0MeterSerial::StopHardware()
{
m_bIsStarted=false;
if (isOpen())
{
try {
clearReadCallback();
close();
doClose();
setErrorStatus(true);
} catch(...)
{
//Don't throw from a Stop command
}
}
StopHeartbeatThread();
return true;
}
bool CDavisLoggerSerial::StopHardware()
{
m_stoprequested=true;
m_thread->join();
// Wait a while. The read thread might be reading. Adding this prevents a pointer error in the async serial class.
sleep_milliseconds(10);
if (isOpen())
{
try {
clearReadCallback();
close();
doClose();
setErrorStatus(true);
} catch(...)
{
//Don't throw from a Stop command
}
}
m_bIsStarted=false;
return true;
}
void AsyncSerial::readEnd(const boost::system::error_code& error,
size_t bytes_transferred)
{
if(error)
{
//error can be true even because the serial port was closed.
//In this case it is not a real error, so ignore
if(isOpen())
{
_log.Log(LOG_ERROR,"Serial Port closed!... Error: %s", error.message().c_str());
clearReadCallback();
close();
doClose();
setErrorStatus(true);
}
} else {
if(pimpl->callback) pimpl->callback(pimpl->readBuffer,
bytes_transferred);
doRead();
}
}
Meteostick::~Meteostick()
{
clearReadCallback();
}
KMTronicSerial::~KMTronicSerial()
{
clearReadCallback();
}
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
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_STATUS,"Davis: Serial Worker stopped...");
}
P1MeterSerial::~P1MeterSerial()
{
clearReadCallback();
}
CurrentCostMeterSerial::~CurrentCostMeterSerial()
{
clearReadCallback();
}
CRFLinkSerial::~CRFLinkSerial()
{
clearReadCallback();
}
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...");
}
CRFLink::~CRFLink()
{
clearReadCallback();
}
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;
}
}
MySensorsSerial::~MySensorsSerial()
{
clearReadCallback();
}
OTGWSerial::~OTGWSerial()
{
clearReadCallback();
}
