void *deviceLevel2ReceiveThread::Entry()
{
vscpEvent *pEvent;
// Must be a valid main object pointer
if (NULL == m_pMainThreadObj) return NULL;
int rv;
while (!TestDestroy() && !m_bQuit) {
pEvent = new vscpEvent;
if (NULL == pEvent) continue;
rv = m_pMainThreadObj->m_pDeviceItem->m_proc_VSCPBlockingReceive(
m_pMainThreadObj->m_pDeviceItem->m_openHandle, pEvent, 500);
if ((CANAL_ERROR_SUCCESS != rv) || (NULL == pEvent)) {
delete pEvent;
continue;
}
// Identify ourselves
pEvent->obid = m_pMainThreadObj->m_pDeviceItem->m_pClientItem->m_clientID;
// If timestamp is zero we set it here
if ( 0 == pEvent->timestamp ) {
pEvent->timestamp = vscp_makeTimeStamp();
}
// If no GUID is set,
// - Set driver GUID if define
// - Set interface GUID if no driver GUID defined.
uint8_t ifguid[16];
// Save nickname
uint8_t nickname_msb = pEvent->GUID[14];
uint8_t nickname_lsb = pEvent->GUID[15];
// Set if to use
memcpy( ifguid, pEvent->GUID, 16 );
ifguid[14] = 0;
ifguid[15] = 0;
// If if is set to zero use interface id
if ( vscp_isGUIDEmpty( ifguid ) ) {
// Set driver GUID if set
if ( !m_pMainThreadObj->m_pDeviceItem->m_interface_guid.isNULL() ) {
m_pMainThreadObj->m_pDeviceItem->m_interface_guid.writeGUID( pEvent->GUID );
}
else {
// If no driver GUID set use interface GUID
m_pMainThreadObj->m_pDeviceItem->m_pClientItem->m_guid.writeGUID( pEvent->GUID );
}
// Preserve nickname
pEvent->GUID[14] = nickname_msb;
pEvent->GUID[15] = nickname_lsb;
}
// There must be room in the receive queue (even if rom (or whisky) has been better)
if (m_pMainThreadObj->m_pCtrlObject->m_maxItemsInClientReceiveQueue >
m_pMainThreadObj->m_pCtrlObject->m_clientOutputQueue.GetCount()) {
m_pMainThreadObj->m_pCtrlObject->m_mutexClientOutputQueue.Lock();
m_pMainThreadObj->m_pCtrlObject->m_clientOutputQueue.Append(pEvent);
m_pMainThreadObj->m_pCtrlObject->m_semClientOutputQueue.Post();
m_pMainThreadObj->m_pCtrlObject->m_mutexClientOutputQueue.Unlock();
}
else {
if (NULL == pEvent) vscp_deleteVSCPevent(pEvent);
}
}
return NULL;
}
void *
deviceLevel1ReceiveThread(void *pData)
{
canalMsg msg;
// Level1MsgOutList::compatibility_iterator nodeLevel1;
CDeviceItem *pDevItem = (CDeviceItem *)pData;
if (NULL == pDevItem) {
syslog(
LOG_CRIT,
"deviceLevel1ReceiveThread quitting due to NULL DevItem object.");
return NULL;
}
// Blocking receive method must have been found
if (NULL == pDevItem->m_proc_CanalBlockingReceive) {
return NULL;
}
while (!pDevItem->m_bQuit) {
if (CANAL_ERROR_SUCCESS == pDevItem->m_proc_CanalBlockingReceive(
pDevItem->m_openHandle, &msg, 500)) {
// There must be room in the receive queue
if (pDevItem->m_pCtrlObject->m_maxItemsInClientReceiveQueue >
pDevItem->m_pCtrlObject->m_clientOutputQueue.size()) {
vscpEvent *pvscpEvent = new vscpEvent;
if (NULL != pvscpEvent) {
memset(pvscpEvent, 0, sizeof(vscpEvent));
// Set driver GUID if set
/*if ( pDevItem->m_interface_guid.isNULL()
) { pDevItem->m_interface_guid.writeGUID(
pvscpEvent->GUID );
}
else {
// If no driver GUID set use interface GUID
pDevItem->m_guid.writeGUID(
pvscpEvent->GUID );
}*/
// Convert CANAL message to VSCP event
vscp_convertCanalToEvent(
pvscpEvent, &msg, pDevItem->m_pClientItem->m_guid.m_id);
pvscpEvent->obid = pDevItem->m_pClientItem->m_clientID;
// If no GUID is set,
// - Set driver GUID if it is defined
// - Set to interface GUID if not.
uint8_t ifguid[16];
// Save nickname
uint8_t nickname_lsb = pvscpEvent->GUID[15];
// Set if to use
memcpy(ifguid, pvscpEvent->GUID, 16);
ifguid[14] = 0;
ifguid[15] = 0;
// If if is set to zero use interface id
if (vscp_isGUIDEmpty(ifguid)) {
// Set driver GUID if set
if (!pDevItem->m_interface_guid.isNULL()) {
pDevItem->m_interface_guid.writeGUID(
pvscpEvent->GUID);
} else {
// If no driver GUID set use interface GUID
pDevItem->m_pClientItem->m_guid.writeGUID(
pvscpEvent->GUID);
}
// Preserve nickname
pvscpEvent->GUID[15] = nickname_lsb;
}
// =========================================================
// Outgoing translations
// =========================================================
// Level I measurement events to Level II measurement float
if (pDevItem->m_translation & VSCP_DRIVER_OUT_TR_M1M2F) {
vscp_convertLevel1MeasuremenToLevel2Double(pvscpEvent);
}
// Level I measurement events to Level II measurement string
else if (pDevItem->m_translation &
VSCP_DRIVER_OUT_TR_M1M2S) {
vscp_convertLevel1MeasuremenToLevel2String(pvscpEvent);
}
// Level I events to Level I over Level II events
if (pDevItem->m_translation & VSCP_DRIVER_OUT_TR_ALL512) {
pvscpEvent->vscp_class += 512;
uint8_t *p = new uint8_t[16 + pvscpEvent->sizeData];
if (NULL != p) {
memset(p, 0, 16 + pvscpEvent->sizeData);
memcpy(
p + 16, pvscpEvent->pdata, pvscpEvent->sizeData);
pvscpEvent->sizeData += 16;
delete[] pvscpEvent->pdata;
pvscpEvent->pdata = p;
}
}
pthread_mutex_lock(
&pDevItem->m_pCtrlObject->m_mutexClientOutputQueue);
pDevItem->m_pCtrlObject->m_clientOutputQueue.push_back(
pvscpEvent);
sem_post(&pDevItem->m_pCtrlObject->m_semClientOutputQueue);
pthread_mutex_unlock(
&pDevItem->m_pCtrlObject->m_mutexClientOutputQueue);
}
}
}
}
return NULL;
}
void *deviceCanalReceiveThread::Entry()
{
canalMsg msg;
CanalMsgOutList::compatibility_iterator nodeCanal;
// Must be a valid main object pointer
if (NULL == m_pMainThreadObj) return NULL;
// Blocking receive method must have been found
if (NULL == m_pMainThreadObj->m_pDeviceItem->m_proc_CanalBlockingReceive) return NULL;
while (!TestDestroy() && !m_bQuit) {
if (CANAL_ERROR_SUCCESS ==
m_pMainThreadObj->m_pDeviceItem->m_proc_CanalBlockingReceive(
m_pMainThreadObj->m_pDeviceItem->m_openHandle, &msg, 500 ) ) {
// There must be room in the receive queue
if (m_pMainThreadObj->m_pCtrlObject->m_maxItemsInClientReceiveQueue >
m_pMainThreadObj->m_pCtrlObject->m_clientOutputQueue.GetCount()) {
vscpEvent *pvscpEvent = new vscpEvent;
if (NULL != pvscpEvent) {
memset( pvscpEvent, 0, sizeof( vscpEvent ) );
// Convert CANAL message to VSCP event
vscp_convertCanalToEvent( pvscpEvent,
&msg,
m_pMainThreadObj->m_pDeviceItem->m_pClientItem->m_guid.m_id );
pvscpEvent->obid = m_pMainThreadObj->m_pDeviceItem->m_pClientItem->m_clientID;
// If no GUID is set,
// - Set driver GUID if it is defined
// - Set to interface GUID if not.
uint8_t ifguid[16];
// Save nickname
uint8_t nickname_lsb = pvscpEvent->GUID[15];
// Set if to use
memcpy( ifguid, pvscpEvent->GUID, 16 );
ifguid[14] = 0;
ifguid[15] = 0;
// If if is set to zero use interface id
if ( vscp_isGUIDEmpty( ifguid ) ) {
// Set driver GUID if set
if ( !m_pMainThreadObj->m_pDeviceItem->m_interface_guid.isNULL() ) {
m_pMainThreadObj->m_pDeviceItem->m_interface_guid.writeGUID( pvscpEvent->GUID );
}
else {
// If no driver GUID set use interface GUID
m_pMainThreadObj->m_pDeviceItem->m_pClientItem->m_guid.writeGUID( pvscpEvent->GUID );
}
// Preserve nickname
pvscpEvent->GUID[15] = nickname_lsb;
}
m_pMainThreadObj->m_pCtrlObject->m_mutexClientOutputQueue.Lock();
m_pMainThreadObj->m_pCtrlObject->m_clientOutputQueue.Append(pvscpEvent);
m_pMainThreadObj->m_pCtrlObject->m_semClientOutputQueue.Post();
m_pMainThreadObj->m_pCtrlObject->m_mutexClientOutputQueue.Unlock();
}
}
}
}
return NULL;
}
void *
deviceLevel2ReceiveThread(void *pData)
{
vscpEvent *pEvent;
CDeviceItem *pDevItem = (CDeviceItem *)pData;
if (NULL == pDevItem) {
syslog(
LOG_CRIT,
"deviceLevel2ReceiveThread quitting due to NULL DevItem object.");
return NULL;
}
int rv;
while (!pDevItem->m_bQuit) {
pEvent = new vscpEvent;
if (NULL == pEvent) continue;
rv = pDevItem->m_proc_VSCPBlockingReceive(
pDevItem->m_openHandle, pEvent, 500);
if ((CANAL_ERROR_SUCCESS != rv) || (NULL == pEvent)) {
delete pEvent;
continue;
}
// Identify ourselves
pEvent->obid = pDevItem->m_pClientItem->m_clientID;
// If timestamp is zero we set it here
if (0 == pEvent->timestamp) {
pEvent->timestamp = vscp_makeTimeStamp();
}
// If no GUID is set,
// - Set driver GUID if define
// - Set interface GUID if no driver GUID defined.
uint8_t ifguid[16];
// Save nickname
uint8_t nickname_msb = pEvent->GUID[14];
uint8_t nickname_lsb = pEvent->GUID[15];
// Set if to use
memcpy(ifguid, pEvent->GUID, 16);
ifguid[14] = 0;
ifguid[15] = 0;
// If if is set to zero use interface id
if (vscp_isGUIDEmpty(ifguid)) {
// Set driver GUID if set
if (!pDevItem->m_interface_guid.isNULL()) {
pDevItem->m_interface_guid.writeGUID(pEvent->GUID);
} else {
// If no driver GUID set use interface GUID
pDevItem->m_pClientItem->m_guid.writeGUID(pEvent->GUID);
}
// Preserve nickname
pEvent->GUID[14] = nickname_msb;
pEvent->GUID[15] = nickname_lsb;
}
// There must be room in the receive queue (even if room (or whisky) has
// been better)
if (pDevItem->m_pCtrlObject->m_maxItemsInClientReceiveQueue >
pDevItem->m_pCtrlObject->m_clientOutputQueue.size()) {
pthread_mutex_lock(
&pDevItem->m_pCtrlObject->m_mutexClientOutputQueue);
pDevItem->m_pCtrlObject->m_clientOutputQueue.push_back(pEvent);
sem_post(&pDevItem->m_pCtrlObject->m_semClientOutputQueue);
pthread_mutex_unlock(
&pDevItem->m_pCtrlObject->m_mutexClientOutputQueue);
} else {
if (NULL == pEvent) vscp_deleteVSCPevent_v2(&pEvent);
}
}
return NULL;
}
