
Unlocking a mutex twice seems to cause deadlocks on OS X if we stress the library. Windows seems unaffected. See #260.
343 lines
8.5 KiB
C++
343 lines
8.5 KiB
C++
//
|
|
// C++ Implementation: TellStick
|
|
//
|
|
// Description:
|
|
//
|
|
//
|
|
// Author: Micke Prag <micke.prag@telldus.se>, (C) 2009
|
|
//
|
|
// Copyright: See COPYING file that comes with this distribution
|
|
//
|
|
//
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <string>
|
|
#include <list>
|
|
#include "common/common.h"
|
|
#include "common/Mutex.h"
|
|
#include "common/Strings.h"
|
|
#include "service/Log.h"
|
|
#include "service/Settings.h"
|
|
#include "service/TellStick.h"
|
|
#include "../client/telldus-core.h"
|
|
|
|
#include "service/ftd2xx.h"
|
|
|
|
class TellStick::PrivateData {
|
|
public:
|
|
bool open, running, ignoreControllerConfirmation;
|
|
int vid, pid;
|
|
std::string serial, message;
|
|
FT_HANDLE ftHandle;
|
|
TelldusCore::Mutex mutex;
|
|
|
|
#ifdef _WINDOWS
|
|
HANDLE eh;
|
|
#else
|
|
// #include <unistd.h>
|
|
struct {
|
|
pthread_cond_t eCondVar;
|
|
pthread_mutex_t eMutex;
|
|
} eh;
|
|
#endif
|
|
};
|
|
|
|
TellStick::TellStick(int controllerId, TelldusCore::EventRef event, TelldusCore::EventRef updateEvent, const TellStickDescriptor &td )
|
|
:Controller(controllerId, event, updateEvent) {
|
|
d = new PrivateData;
|
|
#ifdef _WINDOWS
|
|
d->eh = CreateEvent( NULL, false, false, NULL );
|
|
#else
|
|
pthread_mutex_init(&d->eh.eMutex, NULL);
|
|
pthread_cond_init(&d->eh.eCondVar, NULL);
|
|
#endif
|
|
d->open = false;
|
|
d->running = false;
|
|
d->vid = td.vid;
|
|
d->pid = td.pid;
|
|
d->serial = td.serial;
|
|
Settings set;
|
|
d->ignoreControllerConfirmation = set.getSetting(L"ignoreControllerConfirmation") == L"true";
|
|
|
|
char *tempSerial = new char[td.serial.size()+1];
|
|
#ifdef _WINDOWS
|
|
strcpy_s(tempSerial, td.serial.size()+1, td.serial.c_str());
|
|
#else
|
|
snprintf(tempSerial, td.serial.size()+1, "%s", td.serial.c_str());
|
|
FT_SetVIDPID(td.vid, td.pid);
|
|
#endif
|
|
Log::notice("Connecting to TellStick (%X/%X) with serial %s", d->vid, d->pid, d->serial.c_str());
|
|
FT_STATUS ftStatus = FT_OpenEx(tempSerial, FT_OPEN_BY_SERIAL_NUMBER, &d->ftHandle);
|
|
delete[] tempSerial;
|
|
if (ftStatus == FT_OK) {
|
|
d->open = true;
|
|
FT_SetFlowControl(d->ftHandle, FT_FLOW_NONE, 0, 0);
|
|
FT_SetTimeouts(d->ftHandle, 5000, 0);
|
|
}
|
|
|
|
if (d->open) {
|
|
if (td.pid == 0x0C31) {
|
|
setBaud(9600);
|
|
} else {
|
|
setBaud(4800);
|
|
}
|
|
this->start();
|
|
} else {
|
|
Log::warning("Failed to open TellStick");
|
|
}
|
|
}
|
|
|
|
TellStick::~TellStick() {
|
|
Log::warning("Disconnected TellStick (%X/%X) with serial %s", d->vid, d->pid, d->serial.c_str());
|
|
if (d->running) {
|
|
TelldusCore::MutexLocker locker(&d->mutex);
|
|
d->running = false;
|
|
#ifdef _WINDOWS
|
|
SetEvent(d->eh);
|
|
#else
|
|
pthread_cond_broadcast(&d->eh.eCondVar);
|
|
#endif
|
|
}
|
|
this->wait();
|
|
if (d->open) {
|
|
FT_Close(d->ftHandle);
|
|
}
|
|
delete d;
|
|
}
|
|
|
|
void TellStick::setBaud( int baud ) {
|
|
FT_SetBaudRate(d->ftHandle, baud);
|
|
}
|
|
|
|
int TellStick::pid() const {
|
|
return d->pid;
|
|
}
|
|
|
|
int TellStick::vid() const {
|
|
return d->vid;
|
|
}
|
|
|
|
std::string TellStick::serial() const {
|
|
return d->serial;
|
|
}
|
|
|
|
bool TellStick::isOpen() const {
|
|
return d->open;
|
|
}
|
|
|
|
bool TellStick::isSameAsDescriptor(const TellStickDescriptor &td) const {
|
|
if (td.vid != d->vid) {
|
|
return false;
|
|
}
|
|
if (td.pid != d->pid) {
|
|
return false;
|
|
}
|
|
if (td.serial != d->serial) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void TellStick::processData( const std::string &data ) {
|
|
for (unsigned int i = 0; i < data.length(); ++i) {
|
|
if (data[i] == 13) { // Skip \r
|
|
continue;
|
|
} else if (data[i] == 10) { // \n found
|
|
if (d->message.substr(0, 2).compare("+V") == 0) {
|
|
setFirmwareVersion(TelldusCore::charToInteger(d->message.substr(2).c_str()));
|
|
} else if (d->message.substr(0, 2).compare("+R") == 0) {
|
|
this->publishData(d->message.substr(2));
|
|
} else if(d->message.substr(0, 2).compare("+W") == 0) {
|
|
this->decodePublishData(d->message.substr(2));
|
|
}
|
|
d->message.clear();
|
|
} else { // Append the character
|
|
d->message.append( 1, data[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
int TellStick::reset() {
|
|
#ifndef _WINDOWS
|
|
return TELLSTICK_SUCCESS; // nothing to be done on other platforms
|
|
#else
|
|
int success = FT_CyclePort( d->ftHandle );
|
|
if(success == FT_OK) {
|
|
return TELLSTICK_SUCCESS;
|
|
}
|
|
return TELLSTICK_ERROR_UNKNOWN;
|
|
#endif
|
|
}
|
|
|
|
void TellStick::run() {
|
|
d->running = true;
|
|
DWORD dwBytesInQueue = 0;
|
|
DWORD dwBytesRead = 0;
|
|
char *buf = 0;
|
|
|
|
// Send a firmware version request
|
|
char msg[] = "V+";
|
|
FT_Write(d->ftHandle, msg, (DWORD)strlen(msg), &dwBytesRead);
|
|
|
|
while(1) {
|
|
#ifdef _WINDOWS
|
|
FT_SetEventNotification(d->ftHandle, FT_EVENT_RXCHAR, d->eh);
|
|
WaitForSingleObject(d->eh, INFINITE);
|
|
#else
|
|
FT_SetEventNotification(d->ftHandle, FT_EVENT_RXCHAR, (PVOID)&d->eh);
|
|
pthread_mutex_lock(&d->eh.eMutex);
|
|
pthread_cond_wait(&d->eh.eCondVar, &d->eh.eMutex);
|
|
pthread_mutex_unlock(&d->eh.eMutex);
|
|
#endif
|
|
|
|
TelldusCore::MutexLocker locker(&d->mutex);
|
|
if (!d->running) {
|
|
break;
|
|
}
|
|
FT_GetQueueStatus(d->ftHandle, &dwBytesInQueue);
|
|
if (dwBytesInQueue < 1) {
|
|
continue;
|
|
}
|
|
buf = reinterpret_cast<char*>(malloc(sizeof(buf) * (dwBytesInQueue+1)));
|
|
memset(buf, 0, dwBytesInQueue+1);
|
|
FT_Read(d->ftHandle, buf, dwBytesInQueue, &dwBytesRead);
|
|
processData( buf );
|
|
free(buf);
|
|
}
|
|
}
|
|
|
|
int TellStick::send( const std::string &strMessage ) {
|
|
if (!d->open) {
|
|
return TELLSTICK_ERROR_NOT_FOUND;
|
|
}
|
|
|
|
// This lock does two things
|
|
// 1 Prevents two calls from different threads to this function
|
|
// 2 Prevents our running thread from receiving the data we are interested in here
|
|
TelldusCore::MutexLocker locker(&d->mutex);
|
|
|
|
char *tempMessage = reinterpret_cast<char *>(malloc(sizeof(std::string::value_type) * (strMessage.size()+1)));
|
|
#ifdef _WINDOWS
|
|
strcpy_s(tempMessage, strMessage.size()+1, strMessage.c_str());
|
|
#else
|
|
snprintf(tempMessage, strMessage.size()+1, "%s", strMessage.c_str());
|
|
#endif
|
|
|
|
ULONG bytesWritten, bytesRead;
|
|
char in;
|
|
FT_STATUS ftStatus;
|
|
ftStatus = FT_Write(d->ftHandle, tempMessage, (DWORD)strMessage.length(), &bytesWritten);
|
|
free(tempMessage);
|
|
|
|
if(ftStatus != FT_OK) {
|
|
Log::debug("Broken pipe on send");
|
|
return TELLSTICK_ERROR_BROKEN_PIPE;
|
|
}
|
|
|
|
if(strMessage.compare("N+") == 0 && ((pid() == 0x0C31 && firmwareVersion() < 5) || (pid() == 0x0C30 && firmwareVersion() < 6))) {
|
|
// these firmware versions doesn't implement ack to noop, just check that the noop can be sent correctly
|
|
return TELLSTICK_SUCCESS;
|
|
}
|
|
if(d->ignoreControllerConfirmation) {
|
|
// wait for TellStick to finish its air-sending
|
|
msleep(1000);
|
|
return TELLSTICK_SUCCESS;
|
|
}
|
|
|
|
while(1) {
|
|
ftStatus = FT_Read(d->ftHandle, &in, 1, &bytesRead);
|
|
if (ftStatus == FT_OK) {
|
|
if (bytesRead == 1) {
|
|
if (in == '\n') {
|
|
return TELLSTICK_SUCCESS;
|
|
} else {
|
|
continue;
|
|
}
|
|
} else { // Timeout
|
|
return TELLSTICK_ERROR_COMMUNICATION;
|
|
}
|
|
} else { // Error
|
|
Log::debug("Broken pipe on read");
|
|
return TELLSTICK_ERROR_BROKEN_PIPE;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool TellStick::stillConnected() const {
|
|
FT_STATUS ftStatus;
|
|
DWORD numDevs;
|
|
// create the device information list
|
|
ftStatus = FT_CreateDeviceInfoList(&numDevs);
|
|
if (ftStatus != FT_OK) {
|
|
return false;
|
|
}
|
|
if (numDevs <= 0) {
|
|
return false;
|
|
}
|
|
for (int i = 0; i < static_cast<int>(numDevs); i++) {
|
|
FT_HANDLE ftHandleTemp;
|
|
DWORD flags;
|
|
DWORD id;
|
|
DWORD type;
|
|
DWORD locId;
|
|
char serialNumber[16];
|
|
char description[64];
|
|
// get information for device i
|
|
ftStatus = FT_GetDeviceInfoDetail(i, &flags, &type, &id, &locId, serialNumber, description, &ftHandleTemp);
|
|
if (ftStatus != FT_OK) {
|
|
continue;
|
|
}
|
|
if (d->serial.compare(serialNumber) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::list<TellStickDescriptor> TellStick::findAll() {
|
|
std::list<TellStickDescriptor> tellstick = findAllByVIDPID(0x1781, 0x0C30);
|
|
|
|
std::list<TellStickDescriptor> duo = findAllByVIDPID(0x1781, 0x0C31);
|
|
for(std::list<TellStickDescriptor>::const_iterator it = duo.begin(); it != duo.end(); ++it) {
|
|
tellstick.push_back(*it);
|
|
}
|
|
|
|
return tellstick;
|
|
}
|
|
|
|
std::list<TellStickDescriptor> TellStick::findAllByVIDPID( int vid, int pid ) {
|
|
std::list<TellStickDescriptor> retval;
|
|
|
|
FT_STATUS ftStatus = FT_OK;
|
|
DWORD dwNumberOfDevices = 0;
|
|
|
|
#ifndef _WINDOWS
|
|
FT_SetVIDPID(vid, pid);
|
|
#endif
|
|
|
|
ftStatus = FT_CreateDeviceInfoList(&dwNumberOfDevices);
|
|
if (ftStatus != FT_OK) {
|
|
return retval;
|
|
}
|
|
if (dwNumberOfDevices > 0) {
|
|
FT_DEVICE_LIST_INFO_NODE *devInfo;
|
|
// allocate storage for list based on dwNumberOfDevices
|
|
devInfo = reinterpret_cast<FT_DEVICE_LIST_INFO_NODE*>(malloc(sizeof(FT_DEVICE_LIST_INFO_NODE)*dwNumberOfDevices)); // get the device information list
|
|
ftStatus = FT_GetDeviceInfoList(devInfo, &dwNumberOfDevices);
|
|
if (ftStatus == FT_OK) {
|
|
unsigned int id = (vid << 16) | pid;
|
|
for (unsigned int i = 0; i < dwNumberOfDevices; i++) {
|
|
if (devInfo[i].ID != id) {
|
|
continue;
|
|
}
|
|
TellStickDescriptor td;
|
|
td.vid = vid;
|
|
td.pid = pid;
|
|
td.serial = devInfo[i].SerialNumber;
|
|
retval.push_back(td);
|
|
}
|
|
}
|
|
free(devInfo);
|
|
}
|
|
return retval;
|
|
}
|