Changeset dfae48

Timestamp:

01/10/12 10:01:55 (4 months ago)

Author:

Stefan Persson <stefan.persson@…>

Branches:

('master', 'deebf2045e7119c339412580f37a1e653f7d5715')('controller-upgrade', '00f95d22e12d96ef089e0902ef62ae8ce841dc6f')

Children:

673daf471de0a8094bad2a567b78527158a5f15d

Parents:

06ac023b4a4081c2c409979fb0da45b8123ba9d1fb8e978accbe51e1a0923cb57edfd03c8ca531ca

git-author:

Stefan Persson <stefan.persson@telldus.se>2012-01-10 10:01:55+01:00

git-committer:

Stefan Persson <stefan.persson@telldus.se>2012-01-10 10:01:55+01:00

Message:

Merge remote-tracking branch 'origin/t132' into ticket132

Conflicts:

telldus-core/service/DeviceManager.cpp

Files:

• examples/php/live/authentication/common.php (added)
• examples/php/live/authentication/getAccessToken.php (added)
• examples/php/live/authentication/getRequestToken.php (added)
• examples/php/live/authentication/index.php (added)
• rfcmd/rfcmd.c (modified) (6 diffs)
• telldus-core/client/CallbackDispatcher.cpp (modified) (2 diffs)
• telldus-core/client/Client.cpp (modified) (2 diffs)
• telldus-core/client/telldus-core.cpp (modified) (1 diff)
• telldus-core/common/Message.cpp (modified) (2 diffs)
• telldus-core/common/Message.h (modified) (1 diff)
• telldus-core/common/Socket_win.cpp (modified) (3 diffs)
• telldus-core/common/Strings.cpp (modified) (2 diffs)
• telldus-core/common/Strings.h (modified) (1 diff)
• telldus-core/service/CMakeLists.txt (modified) (3 diffs)
• telldus-core/service/ClientCommunicationHandler.cpp (modified) (2 diffs)
• telldus-core/service/ConnectionListener_win.cpp (modified) (1 diff)
• telldus-core/service/DeviceManager.cpp (modified) (2 diffs)
• telldus-core/service/EventHandler_win.cpp (modified) (1 diff)
• telldus-core/service/EventUpdateManager.cpp (modified) (1 diff)
• telldus-core/service/ProtocolNexa.cpp (modified) (1 diff)
• telldus-core/service/ProtocolOregon.cpp (modified) (2 diffs)
• telldus-core/service/SettingsWinRegistry.cpp (modified) (8 diffs)
• telldus-core/service/TelldusMain.cpp (modified) (3 diffs)
• telldus-core/service/Timer.cpp (added)
• telldus-core/service/Timer.h (added)
• telldus-gui/Plugins/Live/__init__.js (modified) (2 diffs)
• telldus-core/service/Controller.h (modified) (1 diff)
• telldus-core/service/ControllerManager.cpp (modified) (5 diffs)
• telldus-core/service/ControllerManager.h (modified) (1 diff)
• telldus-core/service/TellStick.h (modified) (1 diff)
• telldus-core/service/TellStick_libftdi.cpp (modified) (4 diffs)

rfcmd/rfcmd.c

@@ -58 +58 @@
 
 /*******************************************************************************
+ * Modifications from rfcmd.c ver 2.1.0 based on marvelous work by Snakehand
+ * See http://www.telldus.com/forum/viewtopic.php?t=97&start=63
+ *  Added support for EVERFLOURISH
+ * Note:
+ * 1. Command line syntax:
+ *    /usr/local/bin/rfcmd  /dev/ttyUSB0  EVERFLOURISH 1 15
+ *    Arg 1: device
+ *    Arg 2: protocol
+ *    Arg 3: device number (0..65535)
+ *    Arg 4: Level (0=off, 15=on, 10=learn)
+ ******************************************************************************/
+
+/*******************************************************************************
  * Modifications from rfcmd ver 2.1.1 done by Johan Ström
  *  Default disabled semaphores for FreeBSD.
@@ -99 +112 @@
 int createRisingSunString(const char * pCodeStr, const char* pUnitStr, const char * pOn_offStr,
                         char * pTxStr);
-
+int createEverFlourishString(const char* pUnitStr, const char * pLevelStr,
+                        char * pTxStr);
 void printUsage(void);
 void printVersion(void);
@@ -149 +163 @@
                         exit(1);
                         }
-                        /* else - a send cmd string was created */
+                /* else - a send cmd string was created */
+        } else if ( (argc == 5) && (strcmp(*(argv+2),"EVERFLOURISH")==0) ) {
+        //                      Unit,          Level
+                if ( createEverFlourishString(*(argv+3), *(argv+4), txStr) == 0 ) {
+                        printUsage();
+                        exit(1);
+                }
+                /* else - a send cmd string was created */
         } else if ( (argc >= 2) && (strcmp(*(argv+1),"--version")==0) ) {
                 printVersion();
@@ -526 +547 @@
 }
 
+unsigned int everflourish_find_code(unsigned int x) {
+        unsigned int bits[16] = { 0xf ,0xa ,0x7 ,0xe,
+                                  0xf ,0xd ,0x9 ,0x1,
+                                  0x1 ,0x2 ,0x4 ,0x8,
+                                  0x3 ,0x6 ,0xc ,0xb };
+        unsigned int bit = 1;
+        unsigned int res = 0x5;
+        int i;
+        unsigned int lo,hi;
+
+        if ((x&0x3)==3) {
+                lo = x & 0x00ff;
+                hi = x & 0xff00;
+                lo += 4;
+                if (lo>0x100) lo = 0x12;
+                x = lo | hi;
+        }
+
+        for(i=0;i<16;i++) {
+                if (x&bit) {
+                        res = res ^ bits[i];
+                }
+                bit = bit << 1;
+        }
+
+        return res;
+}
+
+
+int createEverFlourishString(const char * pUnitStr, const char * pLevelStr,
+                        char * pTxStr)
+{
+        int len = 0;
+        int level;
+        int unit;
+        unsigned int check;
+        int i;
+
+        unit = atoi(pUnitStr);
+        level = atoi(pLevelStr);                /* ON=15, OFF=0, LEARN=10 */
+        check = everflourish_find_code(unit);
+
+#ifdef RFCMD_DEBUG
+   printf("unit: %d, level: %d\n", unit, level);
+#endif
+
+        /* check converted parameters for validity */
+        if((unit < 0) || (unit > 0xffff) ||
+          (level < 0) || (level > 15)) {
+        } else {
+                const char ssss = 85;
+                const char sssl = 84; // 0
+                const char slss = 69; // 1
+
+                const char bits[2] = {sssl,slss};
+                int i;
+
+                char preamble[] = {'R', 5, 'T', 114,60,1,1,105,ssss,ssss};
+                memcpy(pTxStr, preamble, sizeof(preamble));
+                len += sizeof(preamble);
+
+                for(i=15;i>=0;i--) pTxStr[len++]=bits[(unit>>i)&0x01];
+                for(i=3;i>=0;i--) pTxStr[len++]=bits[(check>>i)&0x01];
+                for(i=3;i>=0;i--) pTxStr[len++]=bits[(level>>i)&0x01];
+
+                pTxStr[len++] = ssss;
+                pTxStr[len++] = '+';
+        }
+
+        pTxStr[len] = '\0';
+        return strlen(pTxStr);
+}
 
 void printUsage(void)
@@ -536 +629 @@
         printf("\t DEVICE: /dev/ttyUSB[0..n]\n" );
 #endif
-        printf("\t PROTOCOLS: NEXA, SARTANO, WAVEMAN, IKEA, RISINGSUN\n" );
+        printf("\t PROTOCOLS: NEXA, SARTANO, WAVEMAN, IKEA, RISINGSUN, EVERFLOURISH\n" );
         printf("\n");
         printf("\t PROTOCOL ARGUMENTS - NEXA, WAVEMAN:\n");
@@ -552 +645 @@
         printf("\t\tOFF_ON: 0..1\n" );
         printf("\n");
+        printf("\t PROTOCOL ARGUMENTS - EVERFLOURISH:\n");
+        printf("\t\tDEVICE: 0..65535\n");
+        printf("\t\tLEVEL: 0=off, 10=learn, 15=on\n" );
+        printf("\n");
         printf("Report bugs to <info.tech@telldus.se>\n");
 }

telldus-core/client/CallbackDispatcher.cpp

@@ -9 +9 @@
 
 #include "CallbackDispatcher.h"
+#include "common.h"
 
 using namespace TelldusCore;
@@ -29 +30 @@
 
 void TDDeviceEventDispatcher::run() {
+        char *str = wrapStdString(strData);
         d->event(deviceId, method, strData.c_str(), d->id, d->context);
+
         doneRunning = true;
 }

telldus-core/client/Client.cpp

@@ -183 +183 @@
 
                 std::wstring clientMessage = d->eventSocket.read(5000); //testing 5 second timeout
+
                 while(clientMessage != L""){
                         //a message arrived
@@ -283 +284 @@
 
 std::wstring Client::sendToService(const Message &msg) {
-        Socket s;
-        s.connect(L"TelldusClient");
-        if (!s.isConnected()) { //Connection failed
-                TelldusCore::Message msg;
-                msg.addArgument(TELLSTICK_ERROR_CONNECTING_SERVICE);
-                return msg;
-        }
-        s.write(msg.data());
-
-        return s.read(5000);
+        
+        int tries = 0;
+        std::wstring readData;
+        while(tries < 20){
+                tries++;
+                if(tries == 20){
+                        TelldusCore::Message msg;
+                        msg.addArgument(TELLSTICK_ERROR_CONNECTING_SERVICE);
+                        return msg;
+                }
+                Socket s;
+                s.connect(L"TelldusClient");
+                if (!s.isConnected()) { //Connection failed
+                        msleep(500);
+                        continue; //retry
+                }
+                s.write(msg.data());
+                if (!s.isConnected()) { //Connection failed sometime during operation... (better check here, instead of 5 seconds timeout later)
+                        msleep(500);
+                        continue; //retry
+                }
+                readData = s.read(5000);
+                if(readData == L""){
+                        msleep(500);
+                        continue; //TODO can we be really sure it SHOULD be anything?
+                }
+                
+                if (!s.isConnected()) { //Connection failed sometime during operation...
+                        msleep(500);
+                        continue; //retry
+                }
+                break;
+        }
+
+        return readData;
 }
 

telldus-core/client/telldus-core.cpp

@@ -521 +521 @@
  */
 int WINAPI tdSendRawCommand(const char *command, int reserved) {
+        std::wstring wcommand;
+        for(int i = 0; i < strlen(command);++i) {
+                wcommand.append(1, (unsigned char)command[i]);
+        }
         Message msg(L"tdSendRawCommand");
-        msg.addArgument(command);
+        msg.addArgument(wcommand);
         msg.addArgument(reserved);
         return Client::getIntegerFromService(msg);

telldus-core/common/Message.cpp

@@ -24 +24 @@
 
 void Message::addArgument(const std::wstring &value) {
-        std::wstringstream st;
-        st << (int)value.size();
-        this->append(st.str());
+        //std::wstringstream st;
+        //st << (int)value.size();
+        this->append(TelldusCore::intToWstring(value.size())); //st.str());
         this->append(L":");
         this->append(value);
@@ -32 +32 @@
 
 void Message::addArgument(int value) {
-        std::wstringstream st;
-        st << (int)value;
+        //std::wstringstream st;
+        //st << (int)value;
         this->append(L"i");
-        this->append(st.str());
+        this->append(TelldusCore::intToWstring(value)); // st.str());
         this->append(L"s");
 }
+
+/*
+void Message::addSpecialArgument(const std::wstring &value){
+        int i = 0;
+        while(i<1000000){
+                i++;
+
+                char numstr[21]; // enough to hold all numbers up to 64-bits
+                //sprintf(numstr, "%d", value.size());
+                //this->append(TelldusCore::charToWstring(numstr)); //.str());
+
+                itoa(value.size(), numstr, 10);
+                std::string test(numstr);
+                std::wstring temp(test.length(), L' ');
+                std::copy(test.begin(), test.end(), temp.begin());
+
+                this->append(temp);
+                this->append(L":");
+                this->append(value);
+
+                /*
+                std::wstringstream st;
+                st << (int)value.size();
+                this->append(st.str());
+                this->append(L":");
+                this->append(value);
+                
+        }
+}
+
+void Message::addSpecialArgument(int value){
+        int i = 0;
+        while(i<1000000){
+                i++;
+                /*
+                //std::wstringstream st;
+                //st << (int)value;
+                this->append(L"i");
+                //this->append(st.str());
+                this->append(L"s");
+                
+        }
+}
+*/
+/*
+void Message::addSpecialArgument(const char *value){
+        this->addSpecialArgument(TelldusCore::charToWstring(value));
+}
+*/
 
 void Message::addArgument(const char *value) {

telldus-core/common/Message.h

@@ -12 +12 @@
 
                 void addArgument(const std::wstring &);
+                //void addSpecialArgument(const std::wstring &);
+                //void addSpecialArgument(int);
+                //void addSpecialArgument(const char *);
                 void addArgument(int);
                 void addArgument(const char *);

telldus-core/common/Socket_win.cpp

@@ -38 +38 @@
         if (d->hPipe != INVALID_HANDLE_VALUE) {
                 CloseHandle(d->hPipe);
+                d->hPipe = 0;
         }
         delete d;
@@ -90 +91 @@
         memset(&oOverlap, 0, sizeof(OVERLAPPED));
 
-        d->readEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
+        d->readEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
         oOverlap.hEvent = d->readEvent;
         BOOL fSuccess = false;
+        std::wstring returnString;
+        bool moreData = true;
 
-        memset(&buf, 0, BUFSIZE);
+        while(moreData){
+                moreData = false;
+                memset(&buf, 0, sizeof(buf));
 
-        ReadFile( d->hPipe, &buf, sizeof(wchar_t)*BUFSIZE, &cbBytesRead, &oOverlap);
+                ReadFile( d->hPipe, &buf, sizeof(buf)-sizeof(wchar_t), &cbBytesRead, &oOverlap);
+                
+                result = WaitForSingleObject(oOverlap.hEvent, timeout);
+                
+                if(!d->running){
+                        CancelIo(d->hPipe);
+                        WaitForSingleObject(oOverlap.hEvent, INFINITE);
+                        d->readEvent = 0;
+                        CloseHandle(oOverlap.hEvent);
+                        return L"";
+                }
 
-        result = WaitForSingleObject(oOverlap.hEvent, timeout);
+                if (result == WAIT_TIMEOUT) {
+                        CancelIo(d->hPipe);
+                        // Cancel, we still need to cleanup
+                }
+                fSuccess = GetOverlappedResult(d->hPipe, &oOverlap, &cbBytesRead, true);
         
-        if(!d->running){
-                CancelIo(d->hPipe);
-                CloseHandle(d->readEvent);
-                return L"";
+                if (!fSuccess) {
+                        DWORD err = GetLastError();
+
+                        if(err == ERROR_MORE_DATA){
+                                moreData = true;
+                        }
+                        else{
+                                buf[0] = 0;
+                        }
+                        if (err == ERROR_BROKEN_PIPE) {
+                                d->connected = false;
+                        }
+                }
+                returnString.append(buf);
         }
-
-        if (result == WAIT_TIMEOUT) {
-                CancelIo(d->hPipe);
-                CloseHandle(d->readEvent);
-                return L"";
-        }
-        fSuccess = GetOverlappedResult(d->hPipe, &oOverlap, &cbBytesRead, false);
-        if (!fSuccess) {
-                DWORD err = GetLastError();
-                if (err == ERROR_BROKEN_PIPE) {
-                        d->connected = false;
-                }
-                buf[0] = 0;
-        }
-
-        CancelIo(d->hPipe);
-        CloseHandle(d->readEvent);
-        return buf;
+        d->readEvent = 0;
+        CloseHandle(oOverlap.hEvent);
+        return returnString;
 }
 
@@ -130 +144 @@
         DWORD bytesWritten = 0;
         int result;
-        BOOL fSuccess;
+        BOOL fSuccess = false;
 
         memset(&oOverlap, 0, sizeof(OVERLAPPED));
 
-        HANDLE writeEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
+        HANDLE writeEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
         oOverlap.hEvent = writeEvent;
         
-        WriteFile(d->hPipe, msg.data(), (DWORD)msg.length()*sizeof(wchar_t), &bytesWritten, &oOverlap);
+        BOOL writeSuccess = WriteFile(d->hPipe, msg.data(), (DWORD)msg.length()*sizeof(wchar_t), &bytesWritten, &oOverlap);
+        result = GetLastError();
+        if (writeSuccess || result == ERROR_IO_PENDING) {
+                result = WaitForSingleObject(writeEvent, 500);
+                if (result == WAIT_TIMEOUT) {
+                        CancelIo(d->hPipe);
+                        WaitForSingleObject(oOverlap.hEvent, INFINITE);
+                        CloseHandle(writeEvent);
+                        CloseHandle(d->hPipe);
+                        d->hPipe = 0;
+                        d->connected = false;
+                        return;
+                }
+                fSuccess = GetOverlappedResult(d->hPipe, &oOverlap, &bytesWritten, TRUE);
+        }
 
-        result = WaitForSingleObject(writeEvent, 500);
-        if (result == WAIT_TIMEOUT) {
-                CancelIo(d->hPipe);
-                CloseHandle(writeEvent);
-                d->connected = false;
-                return;
-        }
-        fSuccess = GetOverlappedResult(d->hPipe, &oOverlap, &bytesWritten, TRUE);
         CloseHandle(writeEvent);
         if (!fSuccess) {
-                CancelIo(d->hPipe);
+                CloseHandle(d->hPipe);
+                d->hPipe = 0;
                 d->connected = false;
                 return; 

telldus-core/common/Strings.cpp

@@ -93 +93 @@
 
 std::wstring TelldusCore::intToWstring(int value) {
+#ifdef _WINDOWS
+        //no stream used
+//TODO! Make effective and safe...
+        wchar_t numstr[21]; // enough to hold all numbers up to 64-bits
+        _itow_s(value, numstr, sizeof(numstr), 10);
+        std::wstring newstring(numstr);
+        return newstring;
+        //return TelldusCore::charToWstring(stdstring.c_str());
+        //std::wstring temp = TelldusCore::charToWstring(stdstring.c_str());
+        //std::wstring temp(stdstring.length(), L' ');
+        //std::copy(stdstring.begin(), stdstring.end(), temp.begin());
+        //return temp;
+#else
         std::wstringstream st;
         st << value;
         return st.str();
+#endif
 }
 
 std::string TelldusCore::intToString(int value) {
+//Not sure if this is neecssary (for ordinary stringstream that is)
+#ifdef _WINDOWS
+        char numstr[21]; // enough to hold all numbers up to 64-bits
+        _itoa_s(value, numstr, sizeof(numstr), 10);
+        std::string stdstring(numstr);
+        return stdstring;
+#else
         std::stringstream st;
         st << value;
         return st.str();
-}
+#endif
+}
+
+/*
+std::wstring TelldusCore::intToWStringSafe(int value){
+        #ifdef _WINDOWS
+                //no stream used
+        //TODO! Make effective and safe...
+                char numstr[21]; // enough to hold all numbers up to 64-bits
+                itoa(value, numstr, 10);
+                std::string stdstring(numstr);
+                return TelldusCore::charToWstring(stdstring.c_str());
+                //std::wstring temp = TelldusCore::charToWstring(stdstring.c_str());
+                //std::wstring temp(stdstring.length(), L' ');
+                //std::copy(stdstring.begin(), stdstring.end(), temp.begin());
+                //return temp;
+        #else
+                return TelldusCore::intToWString(value);
+        #endif
+}
+*/
 
 int TelldusCore::wideToInteger(const std::wstring &input){
@@ -199 +240 @@
                 if ((np = (char *)realloc (p, size)) == NULL) {
                         free(p);
-            return "";
+                        return "";
                 } else {
                         p = np;

telldus-core/common/Strings.h

@@ -12 +12 @@
         bool comparei(std::wstring stringA, std::wstring stringB);
         std::wstring intToWstring(int value);
+        //std::wstring intToWStringSafe(int value);
         std::string intToString(int value);
         std::string wideToString(const std::wstring &input);

telldus-core/service/CMakeLists.txt

@@ -25 +25 @@
         TelldusMain.cpp
         TellStick.cpp
+        Timer.cpp
         EventUpdateManager.cpp
 )
@@ -80 +81 @@
         Event.h
         EventHandler.h
+        EventUpdateManager.h
         Log.h
         Sensor.h
@@ -85 +87 @@
         TelldusMain.h
         TellStick.h
-        EventUpdateManager.h
+        Timer.h
 )
 FIND_PACKAGE(Threads REQUIRED)

telldus-core/service/ClientCommunicationHandler.cpp

@@ -77 +77 @@
                 int deviceId = TelldusCore::Message::takeInt(&msg);
                 (*intReturn) = d->deviceManager->doAction(deviceId, TELLSTICK_TURNON, 0);
+
         } else if (function == L"tdTurnOff") {
                 int deviceId = TelldusCore::Message::takeInt(&msg);
@@ -207 +208 @@
                 int reserved = TelldusCore::Message::takeInt(&msg);
                 (*intReturn) = d->deviceManager->sendRawCommand(command, reserved);
-                EventUpdateData *eventData = new EventUpdateData();
-                eventData->messageType = L"TDRawDeviceEvent";
-                eventData->controllerId = -1;
-                eventData->eventValue = command;
-                d->deviceUpdateEvent->signal(eventData);
 
         } else if (function == L"tdConnectTellStickController") {

telldus-core/service/ConnectionListener_win.cpp

@@ -92 +92 @@
         d->hEvent = CreateEvent(NULL, true, false, NULL);
         oOverlap.hEvent = d->hEvent;
+        bool recreate = true;
         
         while (1) {
-                hPipe = CreateNamedPipe( 
-                        (const wchar_t *)d->pipename.c_str(),             // pipe name 
-                        PIPE_ACCESS_DUPLEX |      // read/write access 
-                        FILE_FLAG_OVERLAPPED,     //Overlapped mode
-                        PIPE_TYPE_MESSAGE |       // message type pipe 
-                        PIPE_READMODE_MESSAGE |   // message-read mode 
-                        PIPE_WAIT,                // blocking mode 
-                        PIPE_UNLIMITED_INSTANCES, // max. instances  
-                        BUFSIZE,                  // output buffer size 
-                        BUFSIZE,                  // input buffer size 
-                        0,                        // client time-out 
-                        &d->sa);                    // default security attribute 
+                BOOL alreadyConnected = false;
+                if (recreate) {
+                        hPipe = CreateNamedPipe(
+                                (const wchar_t *)d->pipename.c_str(),             // pipe name
+                                PIPE_ACCESS_DUPLEX |      // read/write access
+                                FILE_FLAG_OVERLAPPED,     //Overlapped mode
+                                PIPE_TYPE_MESSAGE |       // message type pipe
+                                PIPE_READMODE_MESSAGE |   // message-read mode
+                                PIPE_WAIT,                // blocking mode
+                                PIPE_UNLIMITED_INSTANCES, // max. instances
+                                BUFSIZE,                  // output buffer size
+                                BUFSIZE,                  // input buffer size
+                                0,                        // client time-out
+                                &d->sa);                    // default security attribute
 
-                if (hPipe == INVALID_HANDLE_VALUE) {
-                        //TelldusCore::logMessage("Could not create named pipe"); 
-                        return;
+                        if (hPipe == INVALID_HANDLE_VALUE) {
+                                return;
+                        }
+
+                        ConnectNamedPipe(hPipe, &oOverlap);
+                        alreadyConnected = GetLastError() == ERROR_PIPE_CONNECTED;
+                        recreate = false;
                 }
+                if(!alreadyConnected){
+                        DWORD result = WaitForSingleObject(oOverlap.hEvent, 1000);
+                        if (!d->running) {
+                                CancelIo(hPipe);
+                                WaitForSingleObject(oOverlap.hEvent, INFINITE);
+                                break;
+                        }
+                        
+                        if(result == WAIT_TIMEOUT){
+                                //CloseHandle(hPipe);
+                                continue;
+                        }
+                        BOOL connected = GetOverlappedResult(hPipe, &oOverlap, &cbBytesRead, false);
 
-                ConnectNamedPipe(hPipe, &oOverlap);
-
-                DWORD result = WaitForSingleObject(oOverlap.hEvent, 1000);
-
-                if (!d->running) {
-                        break;
-                }
-                if(result == WAIT_TIMEOUT){
-                        CloseHandle(hPipe);
-                        continue;
-                }
-                BOOL connected = GetOverlappedResult(hPipe, &oOverlap, &cbBytesRead, false);
-
-                if (!connected) {
-                        CloseHandle(hPipe);
-                        return;
+                        if (!connected) {
+                                CloseHandle(hPipe);
+                                return;
+                        }
                 }
                 ConnectionListenerEventData *data = new ConnectionListenerEventData();
+                ResetEvent(oOverlap.hEvent);
                 data->socket = new TelldusCore::Socket(hPipe);
                 d->waitEvent->signal(data);
+
+                recreate = true;
         }
 

telldus-core/service/DeviceManager.cpp

@@ -6 +6 @@
 #include "Strings.h"
 #include "Message.h"
-#include "common.h"
-#include "Log.h"
+
+#include "common.h" //TODO remove?
+#include "Log.h" //TODO remove?
 
 #include <map>
@@ -511 +512 @@
                                 }
                                 else if(childType == TELLSTICK_TYPE_SCENE){
-                                        deviceReturnValue = doGroupAction(DeviceManager::getDeviceParameter(deviceId, L"devices", L""), action, data, childType, deviceId, duplicateDeviceIds); //TODO make scenes (and test) infinite loops-safe
+                                        deviceReturnValue = doGroupAction(DeviceManager::getDeviceParameter(deviceId, L"devices", L""), action, data, childType, deviceId, duplicateDeviceIds); //TODO make scenes infinite loops-safe
                                 }
                                 else{

telldus-core/service/EventHandler_win.cpp

@@ -52 +52 @@
 
 bool EventHandler::waitForAny() {
-        int result = WaitForMultipleObjects(d->eventCount, d->eventArray, FALSE, INFINITE);
-
-        TelldusCore::MutexLocker locker(&d->mutex);
-        if (result == WAIT_TIMEOUT) {
-                return false;
+        
+        while(1){
+                int result = WaitForMultipleObjects(d->eventCount, d->eventArray, FALSE, 1000);
+                if (result == WAIT_TIMEOUT) {
+                        continue;
+                }
+                TelldusCore::MutexLocker locker(&d->mutex);
+                int eventIndex = result - WAIT_OBJECT_0;
+                if (eventIndex >= d->eventCount) {
+                        return false;
+                }
+                return true;
         }
-        int eventIndex = result - WAIT_OBJECT_0;
-        if (eventIndex >= d->eventCount) {
-                return false;
-        }
-        return true;
 }

telldus-core/service/EventUpdateManager.cpp

@@ -74 +74 @@
 void EventUpdateManager::sendMessageToClients(EventUpdateData *data){
 
+        int connected = 0;
         for(SocketList::iterator it = d->clients.begin(); it != d->clients.end();){
-
                 if((*it)->isConnected()){
-
+                        connected++;
                         TelldusCore::Message msg;
 

telldus-core/service/ProtocolNexa.cpp

@@ -4 +4 @@
 #include "TellStick.h"
 #include "Strings.h"
-#include "common.h"
 
 int ProtocolNexa::lastArctecCodeSwitchWasTurnOff=0;  //TODO, always removing first turnon now, make more flexible (waveman too)

telldus-core/service/ProtocolOregon.cpp

@@ -17 +17 @@
         if (model.compare(L"0xEA4C") == 0) {
                 return decodeEA4C(data);
-        } else if (model.compare(L"0x1A2D")) {
+        } else if (model.compare(L"0x1A2D") == 0) {
                 return decode1A2D(data);
         }
@@ -70 +70 @@
 
 std::string ProtocolOregon::decode1A2D(const std::string &data) {
-        //TODO
-        return "";
+        uint64_t value = strtol(data.c_str(), NULL, 16);
+        uint8_t checksum2 = value & 0xFF;
+        value >>= 8;
+        uint8_t checksum1 = value & 0xFF;
+        value >>= 8;
+
+        uint8_t checksum = ((value >> 4) & 0xF) + (value & 0xF);
+        uint8_t hum1 = value & 0xF;
+        value >>= 8;
+
+        checksum += ((value >> 4) & 0xF) + (value & 0xF);
+        uint8_t neg = value & (1 << 3);
+        uint8_t hum2 = (value >> 4) & 0xF;
+        value >>= 8;
+
+        checksum += ((value >> 4) & 0xF) + (value & 0xF);
+        uint8_t temp2 = value & 0xF;
+        uint8_t temp1 = (value >> 4) & 0xF;
+        value >>= 8;
+
+        checksum += ((value >> 4) & 0xF) + (value & 0xF);
+        uint8_t temp3 = (value >> 4) & 0xF;
+        value >>= 8;
+
+        checksum += ((value >> 4) & 0xF) + (value & 0xF);
+        uint8_t address = value & 0xFF;
+        value >>= 8;
+
+        checksum += ((value >> 4) & 0xF) + (value & 0xF);
+        uint8_t channel = (value >> 4) & 0x7;
+
+        checksum += 0x1 + 0xA + 0x2 + 0xD - 0xA;
+
+        //TODO: Find out how checksum2 works
+        if (checksum != checksum1) {
+                return "";
+        }
+
+        double temperature = ((temp1 * 100) + (temp2 * 10) + temp3)/10.0;
+        if (neg) {
+                temperature = -temperature;
+        }
+
+        std::stringstream retString;
+        retString << "class:sensor;protocol:oregon;model:1A2D;id:" << (int)address
+                << ";temp:" << std::fixed << std::setprecision(1) << temperature << ";";
+
+        return retString.str();
 }

telldus-core/service/SettingsWinRegistry.cpp

@@ -1 +1 @@
 #include "Settings.h"
+#include "Strings.h"
 #include <Windows.h>
 #include <sstream> 
@@ -6 +7 @@
 #include <iostream>
 #include <fstream>
+#include "common.h"
 
 #include "../client/telldus-core.h"
@@ -94 +96 @@
         intDeviceId = getNextDeviceId();
 
-        std::wostringstream ssRegPath; 
-        ssRegPath << d->strRegPathDevice << intDeviceId;
-        std::wstring strCompleteRegPath = ssRegPath.str();
+        std::wstring strCompleteRegPath = d->strRegPathDevice;
+        strCompleteRegPath.append(TelldusCore::intToWstring(intDeviceId));
                 
         if (RegCreateKeyEx(d->rootKey, strCompleteRegPath.c_str(), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hk, &dwDisp)) {
@@ -123 +124 @@
                 DWORD nResult(0);
 
-                long lngStatus = RegQueryValueEx(hk, L"LastUsedId", NULL, NULL, reinterpret_cast<LPBYTE>(&nResult), &dwLength); //(LPBYTE)Buff, &dwLength);
+                long lngStatus = RegQueryValueEx(hk, L"LastUsedId", NULL, NULL, reinterpret_cast<LPBYTE>(&nResult), &dwLength);
 
                 if(lngStatus == ERROR_SUCCESS){
@@ -144 +145 @@
         TelldusCore::MutexLocker locker(&mutex);
         
-        std::wostringstream ssRegPath; 
-        ssRegPath << d->strRegPathDevice << intDeviceId;
-        std::wstring strCompleteRegPath = ssRegPath.str();
+        std::wstring strCompleteRegPath = d->strRegPathDevice;
+        strCompleteRegPath.append(TelldusCore::intToWstring(intDeviceId));
 
         long lngSuccess = RegDeleteKey(d->rootKey, strCompleteRegPath.c_str());
@@ -162 +162 @@
         HKEY hk;
 
-        std::wostringstream ssRegPath; 
-        ssRegPath << d->strRegPathDevice << intDeviceId;
-        std::wstring strCompleteRegPath = ssRegPath.str();
+        std::wstring strCompleteRegPath = d->strRegPathDevice;
+        strCompleteRegPath.append(TelldusCore::intToWstring(intDeviceId));
         long lnExists = RegOpenKeyEx(d->rootKey, strCompleteRegPath.c_str(), 0, KEY_QUERY_VALUE, &hk);
                         
@@ -192 +191 @@
         int ret = TELLSTICK_SUCCESS;
                 
-        std::wostringstream ssRegPath; 
-        ssRegPath << d->strRegPathDevice << intDeviceId;
-        std::wstring strCompleteRegPath = ssRegPath.str();
+        std::wstring bla = TelldusCore::intToWstring(intDeviceId);
+        std::wstring strCompleteRegPath = d->strRegPathDevice;
+        strCompleteRegPath.append(bla);
         long lnExists = RegOpenKeyEx(d->rootKey, strCompleteRegPath.c_str(), 0, KEY_WRITE, &hk);
                                 
@@ -224 +223 @@
         HKEY hk;
 
-        std::wostringstream ssRegPath; 
-        ssRegPath << d->strRegPathDevice << intDeviceId;
-        std::wstring strCompleteRegPath = ssRegPath.str();
+        std::wstring strCompleteRegPath =  d->strRegPathDevice;
+        strCompleteRegPath.append(TelldusCore::intToWstring(intDeviceId));
         long lnExists = RegOpenKeyEx(d->rootKey, strCompleteRegPath.c_str(), 0, KEY_WRITE, &hk);
         if (lnExists == ERROR_SUCCESS) {

telldus-core/service/TelldusMain.cpp

@@ -7 +7 @@
 #include "ControllerListener.h"
 #include "EventUpdateManager.h"
+#include "Timer.h"
+#include "Log.h"
 
 #include <stdio.h>
@@ -40 +42 @@
         EventRef clientEvent = d->eventHandler.addEvent();
         EventRef dataEvent = d->eventHandler.addEvent();
+        EventRef janitor = d->eventHandler.addEvent(); //Used for regular cleanups
+        Timer supervisor(janitor); //Tells the janitor to go back to work
+        supervisor.setInterval(60*5); //Every 5 minutes
+        supervisor.start();
 
         ControllerManager controllerManager(dataEvent.get());
@@ -102 +108 @@
                         }
                 }
+                if (janitor->isSignaled()) {
+                        //Clear all of them if there is more than one
+                        while(janitor->isSignaled()) {
+                                janitor->popSignal();
+                        }
+                        Log::debug("Do Janitor cleanup");
+                }
         }
+
+        supervisor.stop();
 }
 

telldus-gui/Plugins/Live/__init__.js

@@ -61 +61 @@
                 } else if (action == "bell") {
                         com.telldus.core.bell( msg.getInt('id') );
+                } else if (action == "up") {
+                        com.telldus.core.up( msg.getInt('id') );
+                } else if (action == "down") {
+                        com.telldus.core.down( msg.getInt('id') );
+                } else if (action == "stop") {
+                        com.telldus.core.stop( msg.getInt('id') );
                 }
         }
@@ -71 +77 @@
                         separatorId = 0;
                 }
-                supportedMethods = msg.getInt('supportedMethods');
+                //Mask to lowest common denominator
+                supportedMethods =
+                        com.telldus.core.TELLSTICK_TURNON |
+                        com.telldus.core.TELLSTICK_TURNOFF |
+                        com.telldus.core.TELLSTICK_DIM |
+                        com.telldus.core.TELLSTICK_BELL |
+                        com.telldus.core.TELLSTICK_UP |
+                        com.telldus.core.TELLSTICK_DOWN |
+                        com.telldus.core.TELLSTICK_STOP;
+                supportedMethods = supportedMethods & msg.getInt('supportedMethods');
                 isRegistered = true;
                 registrationLinkVisible(false);

telldus-core/service/Controller.h

@@ -17 +17 @@
         virtual int firmwareVersion() = 0;
         virtual int send( const std::string &message ) = 0;
+        virtual int reset() = 0;
 
 protected:

telldus-core/service/ControllerManager.cpp

@@ -3 +3 @@
 #include "Mutex.h"
 #include "TellStick.h"
+#include "Log.h"
 
 #include <map>
@@ -91 +92 @@
 
         std::list<TellStickDescriptor>::iterator it = list.begin();
+        Log::notice("Before for-loop");
         for(; it != list.end(); ++it) {
+                Log::notice("Something in the loop");
                 //Most backend only report non-opened devices.
                 //If they don't make sure we don't open them twice
@@ -97 +100 @@
                 ControllerMap::const_iterator cit = d->controllers.begin();
                 for(; cit != d->controllers.end(); ++cit) {
+                        Log::notice("Something in second the loop");
                         TellStick *tellstick = reinterpret_cast<TellStick*>(cit->second);
                         if (!tellstick) {
+                                Log::notice("No tellstick");
                                 continue;
                         }
                         if (tellstick->isSameAsDescriptor(*it)) {
                                 found = true;
+                                Log::notice("FOUND");
                                 break;
                         }
@@ -112 +118 @@
                 int controllerId = d->lastControllerId-1;
                 TellStick *controller = new TellStick(controllerId, d->event, *it);
+                Log::notice("Is it open?");
                 if (!controller->isOpen()) {
+                        Log::notice("Yes it was");
                         delete controller;
                         continue;
@@ -120 +128 @@
         }
 }
+
+int ControllerManager::resetController(Controller *controller) {
+        TellStick *tellstick = reinterpret_cast<TellStick*>(controller);
+        if (!tellstick) {
+                return true; //not tellstick, nothing to reset at the moment, just return true
+        }
+        Log::notice("resettingController");
+        int success = controller->reset(); //ehh, här är väl controllern borttagen förresten?
+        Log::notice("Remove device");
+        deviceInsertedOrRemoved(tellstick->vid(), tellstick->pid(), tellstick->serial(), false); //remove from list and delete
+        Log::notice("Device removed");
+        return success;
+}

telldus-core/service/ControllerManager.h

@@ -15 +15 @@
 
         Controller *getBestControllerById(int id);
-
-protected:
         void loadControllers();
+        int resetController(Controller *controller);
 
 private:

telldus-core/service/TellStick.h

@@ -30 +30 @@
         virtual int firmwareVersion();
         virtual int pid() const;
+        virtual int vid() const;
+        virtual std::string serial() const;
+
         bool isOpen() const;
         bool isSameAsDescriptor(const TellStickDescriptor &d) const;
+        virtual int reset();
         virtual int send( const std::string &message );
         bool stillConnected() const;

telldus-core/service/TellStick_libftdi.cpp

@@ -22 +22 @@
 #include "Strings.h"
 #include "common.h"
+#include "Log.h"
 
 #include <unistd.h>
@@ -98 +99 @@
 int TellStick::pid() const {
         return d->pid;
+}
+
+int TellStick::vid() const {
+        return d->vid;
+}
+
+std::string TellStick::serial() const {
+        return d->serial;
 }
 
@@ -136 +145 @@
 }
 
+int TellStick::reset(){
+        Log::notice("Resetting one");
+        int success = ftdi_usb_reset( &d->ftHandle );
+        Log::notice("Has reset one");
+        if(success < 0){
+                return TELLSTICK_ERROR_UNKNOWN; //-1 = FTDI reset failed, -2 = USB device unavailable
+        }
+        return success;
+}
+
 void TellStick::run() {
         int dwBytesRead = 0;
@@ -274 +293 @@
         ftdi_init(&ftdic);
 
+        Log::notice("Trying to find Duo");
         int ret = ftdi_usb_find_all(&ftdic, &devlist, vid, pid);
         if (ret > 0) {
+                Log::notice("Curdev > 0");
                 for (curdev = devlist; curdev != NULL; curdev = curdev->next) {
+                        Log::notice("Something in the loop");
                         ret = ftdi_usb_get_strings(&ftdic, curdev->dev, NULL, 0, NULL, 0, serialBuffer, 10);
+                        Log::notice("Ret: %d",ret);
+                        //blir -9 efter felen, "get serial number failed", även lsusb -v ger annat svar än innan...?
                         if (ret != 0) {
                                 continue;