910 changed files with 128788 additions and 35253 deletions
--- a/.classpath
+++ b/.classpath
@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry exported="true" kind="lib" path="libs/dom4j-1.6.1.jar" sourcepath="C:/Users/Ziver/Documents/Programmering/Java/libs/dom4j-1.6.1/src"/>
-	<classpathentry exported="true" kind="lib" path="libs/javassist.jar" sourcepath="C:/Users/Ziver/Documents/Programmering/Java/libs/javassist-3.12.GA"/>
-	<classpathentry kind="lib" path="libs/junit-benchmarks-0.7.0.jar"/>
-	<classpathentry kind="lib" path="libs/mysql-connector-java-5.1.36-bin.jar"/>
-	<classpathentry kind="lib" path="libs/servlet-api.jar"/>
-	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.module.container"/>
-	<classpathentry exported="true" kind="lib" path="libs/commons-fileupload-1.2.1.jar" sourcepath="C:/Users/Ziver/Documents/Programmering/Java/libs/commons/commons-fileupload-1.2.1-sources.jar"/>
-	<classpathentry exported="true" kind="lib" path="libs/commons-io-1.4.jar"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
-	<classpathentry kind="con" path="org.eclipse.jst.server.core.container/org.eclipse.jst.server.tomcat.runtimeTarget/Apache Tomcat v7.0"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry kind="lib" path="libs/sqlite-jdbc-3.7.2.jar"/>
-	<classpathentry kind="output" path="bin"/>
-</classpath>
--- a/.gitattributes
+++ b/.gitattributes
@ -0,0 +1,5 @@
+# Github language stats file
+external/* linguist-vendored
+lib/* linguist-vendored
+*.css linguist-vendored
+*.js linguist-vendored
--- a/.gitignore
+++ b/.gitignore
@ -1,2 +1,14 @@
-Zutil.jar
-/build/
+# Configuration and dependencies
+/hal.conf
+/hal.db*
+/lib/zutil-*
+/recordings/
+
+# Runtime files
+/screenlog.0*
+/OZW_Log.txt
+
+# Build and Ide files
+build
+.gradle
+.idea
--- a/.gitmodules
+++ b/.gitmodules
@ -0,0 +1,3 @@
+[submodule "arduino/lib/NexaControl"]
+	path = arduino/lib/NexaControl
+	url = https://github.com/dcollin/NexaControl.git
--- a/.project
+++ b/.project
@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>ZUtil</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.wst.common.project.facet.core.builder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.wst.validation.validationbuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
-		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-		<nature>org.eclipse.jem.beaninfo.BeanInfoNature</nature>
-		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
-	</natures>
-</projectDescription>
--- a/35
+++ b/35
@ -0,0 +1,35 @@
+// Jenkinsfile (Pipeline Script)
+node {
+    // Configure environment
+    env.JAVA_HOME = tool name: 'jdk-11'
+    env.REPO_URL = "repo.koc.se/hal.git" //scm.getUserRemoteConfigs()[0].getUrl()
+    env.BUILD_NAME = "BUILD-${env.BUILD_ID}"
+
+
+    checkout scm
+
+    stage('Build') {
+        sh './gradlew clean'
+        sh './gradlew build'
+    }
+
+    stage('Test') {
+        try {
+            sh './gradlew test'
+        } finally {
+            junit testResults: '**/build/test-results/test/*.xml'
+        }
+    }
+
+    stage('Package') {
+        sh './gradlew distZip'
+        archiveArtifacts artifacts: 'build/distributions/Hal.zip', fingerprint: true
+
+        // Tag artifact
+        withCredentials([[$class: 'UsernamePasswordMultiBinding', credentialsId: 'f8e5f6c6-4adb-4ab2-bb5d-1c8535dff491',
+                                      usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD']]) {
+            sh "git tag ${env.BUILD_NAME}"
+            sh "git push 'https://${USERNAME}:${PASSWORD}@${env.REPO_URL}' ${env.BUILD_NAME}"
+        }
+    }
+}
--- a/LICENSE.txt
+++ b/LICENSE.txt
@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Ziver Koc
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+The MIT License (MIT)
+
+Copyright (c) 2016-2025 Daniel Collin, Ziver Koc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/README.md
+++ b/README.md
@ -0,0 +1,104 @@
+# Hal
+
+Hal is a home automation hub with sensor statistics with the functionality to 
+share that data between friends. It has been developed to be very extensible so future 
+Sensors and other input devices can be supported.
+
+Features:
+- **Map**, Set up a house map with sensors and events mapped on a floorplan
+- **Triggers and Actions**, IFTTT type functionality
+- **Power;Challenge**, Sync power or sensor usage between friends to challenge each other to lower the power usage
+- **[Google Assistant Integration](plugins/hal-assistant-google/READNME.md)**
+
+Currently supported devices:
+- **Network Scanner**, IP scanner to detect devices on local network
+- **NUT**, Linux UPS daemon
+- **Tellstick**, Supported devices:
+  - NexaSelfLearning
+  - Oregon0x1A2D
+- **Raspberry Pi**, GPIO connected sensors
+- **[Zigbee](plugins/hal-zigbee/README.md)**
+  - Temperature Sensors
+  - Humidity Sensors
+  - Pressure Sensors
+  - OnnOff Devices
+- **Google Assistant**
+- **MQTT Devices**
+
+Under development (Not ready to be used yet)
+- **Z-Wave**
+
+
+The project is currently in alpha state, and as such things will change and break continuously.
+
+### Screenshots
+![Week Graph](screenshot_01.jpg)
+
+![Home Map](screenshot_02.jpg)
+
+![Sensor Overview](screenshot_03.jpg)
+
+![Event Overview](screenshot_04.jpg)
+
+## Installing
+
+To run the Hal server you first need to clone the git repository and then run the 
+gradle command to build and run the server:
+
+```
+./gradlew run
+```
+
+Check `hal.conf.example` for available configuration options. 
+By default, HAL server will be listening to http://localhost:8080. 
+
+## Running the tests
+
+The current test coverage is greatly lacking, but to run the available JUnit 
+test-cases run:
+
+```
+./gradlew test
+```
+
+## Architecture
+
+```
+ HalAbstractControlerManager
+       |
+       |             HalAbstractController
+       |                   |
+       |                   |              HalAbstractDevice
+       |                   |                   |
+ .-----------.       .------------.       .--------.  
+ |           |       |            |       |        |
+ |           |       |            | ----> | Device | 
+ |           |       |            |       |        |
+ |           | ----> | Controller |       '--------'
+ |           |       |            |       .--------.  
+ |           |       |            |       |        |
+ |  Manager  |       |            | ----> | Device | 
+ |           |       |            |       |        |
+ |           |       '------------'       '--------'
+ |           |       .------------.       .--------.  
+ |           |       |            |       |        |
+ |           | ----> | Controller | ----> | Device | 
+ |           |       |            |       |        |
+ '-----------'       '------------'       '--------'
+         
+```
+
+## Authors
+
+* **Daniel Collin**
+* **Ziver Koc**
+
+
+## License
+
+This project is licensed under the MIT License - see the 
+[LICENSE.txt](LICENSE.txt) file for details
+
+## Acknowledgments
+
+* Tellstick, for open-sourcing their code 
--- a/Zutil.iml
+++ b/Zutil.iml
@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
-    </content>
-    <orderEntry type="jdk" jdkName="1.8" jdkType="JavaSDK" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="module-library" scope="TEST">
-      <library name="JUnit4">
-        <CLASSES>
-          <root url="jar://$APPLICATION_HOME_DIR$/lib/junit-4.12.jar!/" />
-          <root url="jar://$APPLICATION_HOME_DIR$/lib/hamcrest-core-1.3.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-    <orderEntry type="module-library">
-      <library name="lib">
-        <CLASSES>
-          <root url="file://$MODULE_DIR$/lib" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES>
-          <root url="file://$MODULE_DIR$/lib" />
-        </SOURCES>
-        <jarDirectory url="file://$MODULE_DIR$/lib" recursive="false" />
-        <jarDirectory url="file://$MODULE_DIR$/lib" recursive="false" type="SOURCES" />
-      </library>
-    </orderEntry>
-  </component>
-</module>
--- a/arduino/ArduinoTellstickDuo/ArduinoTellstickDuo.ino
+++ b/arduino/ArduinoTellstickDuo/ArduinoTellstickDuo.ino
@ -0,0 +1,72 @@
+#include "usart.h"
+#include "rf.h"
+#include "buffer.h"
+#include "config.h"
+
+/*
+* Timer2 interrupt in 16kHz. Samples the RF Rx data pin
+*/
+ISR(TIMER2_COMPA_vect) {
+
+  if ( !IS_RADIO_RECIEVER_ON() ) { //if no Radio Rx should be performed
+    return;
+  }
+
+  uint8_t bit = RX_PIN_READ();
+
+  //will store "lows" on even buffer addresses and "highs" on odd buffer addresses
+  if ( ( ((uintptr_t)bufferWriteP) & 0x1 ) != bit ) { //compare the bit and the buffer pointer address. true if one is odd and one is even.
+    //step the buffer pointer
+    if ( bufferWriteP+1 > RF_rxBufferEndP ) {
+      *RF_rxBufferStartP = 1;   //reset the next data point before going there
+      bufferWriteP = RF_rxBufferStartP;
+    } else {
+      *(bufferWriteP+1) = 1;   //reset the next data point before going there
+      ++bufferWriteP;
+    }
+  } else {
+    if ( *bufferWriteP < 255 ) {  //Do not step the value if it already is 255 (max value)
+      ++(*bufferWriteP);    //step the buffer value
+    }
+  }
+
+};//end timer2 interrupt
+
+
+void setup() {
+
+  Serial.begin(9600);
+
+  setupPins();
+
+  //setup timer2 interrupt at 16kHz for RF sampling
+  cli();    //stop interrupts
+  TCCR2A = 0;   // set entire TCCR2A register to 0
+  TCCR2B = 0;   // same for TCCR2B
+  TCNT2  = 0;   //initialize counter value to 0
+  OCR2A = 124;  // = ( (16000000Hz) / (16000Hz*8prescaler) ) - 1    (must be <256)
+  TCCR2A |= (1 << WGM21);  // turn on CTC mode
+  TCCR2B |= (1 << CS21);    // Set CS21 bit for 8 prescaler
+  TIMSK2 |= (1 << OCIE2A);  // enable timer compare interrupt
+  sei();    //allow interrupts
+
+  //reset buffer just to be sure
+  for (uint8_t* p = RF_rxBufferStartP; p <= RF_rxBufferEndP; ++p) {
+    *p = 0;
+  }
+  
+  Serial.println(F("+V2"));
+
+  ACTIVATE_RADIO_RECEIVER();
+
+};//end setup
+
+void loop() {
+
+  //Receive and execute command over serial
+  parseSerialForCommand();
+
+  //Receive signal over air and send it over serial
+  parseRadioRXBuffer();
+
+};//end loop
--- a/arduino/ArduinoTellstickDuo/archtech.cpp
+++ b/arduino/ArduinoTellstickDuo/archtech.cpp
@ -0,0 +1,115 @@
+#include "archtech.h"
+#include "buffer.h"
+
+/*******************************************************************************
+                      --ARCHTECH PROTOCOL SPECIFICATION--
+
+    ----SIGNAL----
+A signal consists of a PREAMBLE, DATA and an POSTAMBLE.
+Each signal is sent 4 times in a row to increase the delivery success rate.
+
+    ----PREAMBLE----
+send high for 250 microseconds
+send low for 2,500 microseconds
+
+    ----DATA----
+26 bits of transmitter id
+1 bit indicating if the on/off bit is targeting a group
+1 bit indicating "on" or "off"
+4 bits indicating the targeted unit/channel/device
+4 bits indicating a absolute dim level (optional)
+
+Total: 32 or 36 bits depending if absolute dimming is used
+
+Each real bit in the data field is sent over air as a pair of two inverted bits.
+  real bit        bits over air
+     1       =        "10"
+     0       =        "01"
+
+Over air a "1"(one) is sent as:
+send high for 250 microseconds
+send low for 1,250 microseconds
+
+Over air a "0"(zero) is sent as:
+send high for 250 microseconds
+send low for 250 microseconds
+
+    ----POSTAMBLE----
+send high for 250 microseconds
+send low for 10,000 microseconds
+
+*******************************************************************************/
+
+#define ARCHTECH_SHORT_MIN       2
+#define ARCHTECH_SHORT_MAX       7
+#define ARCHTECH_LONG_MIN       17
+#define ARCHTECH_LONG_MAX       27
+#define ARCHTECH_PREAMP_MIN     40
+#define ARCHTECH_PREAMP_MAX     48
+
+#define IS_SHORT(b)         (  ARCHTECH_SHORT_MIN <= b && b <= ARCHTECH_SHORT_MAX )
+#define IS_LONG(b)          (   ARCHTECH_LONG_MIN <= b && b <= ARCHTECH_LONG_MAX  )
+#define IS_PREAMP_LONG(b)   ( ARCHTECH_PREAMP_MIN <= b && b <= ARCHTECH_PREAMP_MAX )
+
+#define IS_ONE(b1,b2,b3,b4)   ( IS_SHORT(b1) && IS_LONG(b2)  && IS_SHORT(b3) && IS_SHORT(b4) )
+#define IS_ZERO(b1,b2,b3,b4)  ( IS_SHORT(b1) && IS_SHORT(b2) && IS_SHORT(b3) && IS_LONG(b4)  )
+#define IS_PREAMP(b1,b2)      ( IS_SHORT(b1) && IS_PREAMP_LONG(b2) )
+
+bool parseArctechSelfLearning(uint8_t* bufStartP, uint8_t* bufEndP) {    //start points to a "high" buffer byte, end points to a "low" buffer byte
+  uint64_t data = 0;
+  bool dimValuePresent;
+  uint8_t b1,b2,b3,b4;
+
+  //parse preamp
+
+  b1 = *bufStartP;
+  stepBufferPointer(&bufStartP);
+  b2 = *bufStartP;
+  stepBufferPointer(&bufStartP);
+  if (!IS_PREAMP(b1, b2)){
+    return false;
+  }
+
+  //parse data
+
+  uint16_t dataBitsInBuffer = (calculateBufferPointerDistance(bufStartP, bufEndP)-2) / 4;   //each bit is representd by 4 high/low
+  if (dataBitsInBuffer == 32) {
+    dimValuePresent = false;
+  } else if (dataBitsInBuffer == 36){
+    dimValuePresent = true;
+  } else {
+    return false;
+  }
+
+  for (uint8_t i = 0; i < dataBitsInBuffer; ++i) {
+    b1 = *bufStartP;    //no of high
+    stepBufferPointer(&bufStartP);
+    b2 = *bufStartP;    //no of low
+    stepBufferPointer(&bufStartP);
+    b3 = *bufStartP;    //no of high
+    stepBufferPointer(&bufStartP);
+    b4 = *bufStartP;    //no of low
+    stepBufferPointer(&bufStartP);
+
+    if (IS_ONE(b1,b2,b3,b4)) {  //"one" is sent over air
+      data <<= 1; //shift in a zero
+      data |= 0x1;    //add one
+    } else if (IS_ZERO(b1,b2,b3,b4)) { //"zero" is sent over air
+      data <<= 1; //shift in a zero
+    } else {
+      return false;
+    }
+
+  }
+
+  //data parsed - send event over serial
+
+  Serial.print(F("+Wclass:command;protocol:arctech;model:selflearning;data:0x"));
+  uint8_t hexToSend = (dimValuePresent ? 9 : 8);
+  for (int8_t i = hexToSend - 1; i >= 0; --i) {
+    Serial.print( (byte)((data >> (4 * i)) & 0x0F), HEX);
+  }
+  Serial.println(F(";"));
+
+  return true;
+}; //end parseArctechSelfLearning
--- a/arduino/ArduinoTellstickDuo/archtech.h
+++ b/arduino/ArduinoTellstickDuo/archtech.h
@ -0,0 +1,8 @@
+#ifndef ARCHTECH_H
+#define ARCHTECH_H
+
+#include "Arduino.h"
+
+bool parseArctechSelfLearning(uint8_t* bufStartP, uint8_t* bufEndP);
+
+#endif //ARCHTECH_H
--- a/arduino/ArduinoTellstickDuo/buffer.cpp
+++ b/arduino/ArduinoTellstickDuo/buffer.cpp
@ -0,0 +1,6 @@
+#include "buffer.h"
+
+uint8_t RF_rxBuffer[512];   //must have and even number of elements
+uint8_t* RF_rxBufferStartP = &RF_rxBuffer[0];
+uint8_t* RF_rxBufferEndP = &RF_rxBuffer[511];
+volatile uint8_t* bufferWriteP = RF_rxBufferStartP;
--- a/arduino/ArduinoTellstickDuo/buffer.h
+++ b/arduino/ArduinoTellstickDuo/buffer.h
@ -0,0 +1,31 @@
+#ifndef BUFFER_H
+#define BUFFER_H
+
+#include "Arduino.h"
+
+extern uint8_t RF_rxBuffer[512];   //must have and even number of elements
+extern uint8_t* RF_rxBufferStartP;
+extern uint8_t* RF_rxBufferEndP;
+extern volatile uint8_t* bufferWriteP;
+
+inline uint16_t calculateBufferPointerDistance(uint8_t* bufStartP, uint8_t* bufEndP) {
+  if (bufStartP <= bufEndP) {
+    return bufEndP - bufStartP + 1;
+  } else {
+    return (RF_rxBufferEndP - bufStartP) + (bufEndP - RF_rxBufferStartP) + 2;
+  }
+};   //end calculateBufferPointerDistance
+
+inline uint8_t* getNextBufferPointer(uint8_t* p) {
+  if ( p + 1 > RF_rxBufferEndP) {
+    return RF_rxBufferStartP;
+  } else {
+    return p + 1;
+  }
+};  //end getNextBufferPointer
+
+inline void stepBufferPointer(uint8_t** p) {
+  *p = getNextBufferPointer(*p);
+};  //end stepBufferPointer
+
+#endif //BUFFER_H
--- a/arduino/ArduinoTellstickDuo/config.h
+++ b/arduino/ArduinoTellstickDuo/config.h
@ -0,0 +1,25 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include "Arduino.h"
+
+/*
+* RX PIN = 7
+* TX PIN = 8
+*/
+inline void setupPins(){
+    pinMode(7, INPUT); 
+    pinMode(8, OUTPUT);
+};
+
+#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__)
+    //pin7 = PD7 = port D, bit 8
+    #define     RX_PIN_READ()        ( digitalRead(7) )    // optimized "digitalRead(7)"
+    //pin8 = PB0 = port B, bit 1
+    #define     TX_PIN_LOW()         ( PORTB &= 0b01111111 )    // optimized "digitalWrite(8, LOW)"
+    #define     TX_PIN_HIGH()        ( PORTB |= 0b10000000 )    // optimized "digitalWrite(8, HIGH)"
+#else
+    #unsupported architecture
+#endif
+
+#endif //CONFIG_H
--- a/arduino/ArduinoTellstickDuo/oregonV2.1.cpp
+++ b/arduino/ArduinoTellstickDuo/oregonV2.1.cpp
@ -0,0 +1,210 @@
+#include "oregonV2.1.h"
+#include "buffer.h"
+
+/*******************************************************************************
+                     --OREGON v2.1 PROTOCOL SPECIFICATION--
+
+    ----SIGNAL----    
+A signal consists of a PREAMBLE, DATA and an POSTAMBLE.
+Each signal is sent 2 times in a row to increase the delivery success rate.
+Between the two times there is a "low" pause of 8192us.
+
+    ----PREAMBLE----
+send 16 "1"(ones) over the air
+
+    ----DATA----
+16 bits of sensor type
+XX bits of data (where XX <= 64)
+
+The length XX depends on the sensor type. I.e. 0x1A2D => XX=56
+
+Over air a "1"(one) is sent as:
+send high for 512 microseconds
+send low for 1024 microseconds
+send high for 512 microseconds
+
+Over air a "0"(zero) is sent as:
+send low for 512 microseconds
+send high for 1024 microseconds
+send low for 512 microseconds
+
+    ----POSTAMBLE----
+send 8 "0"(zeros) over the air
+
+*******************************************************************************/
+
+#define SMALL_PULSE(x) (  4<=x && x<=13 )
+#define BIG_PULSE(x)   ( 12<=x && x<=22 )
+#define MORE_DATA_NEEDED -1
+#define INVALID_DATA -2
+
+enum {
+	PARSE_PREAMP = 0,
+	PARSE_ID,
+	PARSE_DATA
+} static state = PARSE_PREAMP;
+
+static uint8_t byteCnt = 0;
+static uint8_t bitCnt = 0;
+static uint8_t totByteCnt = 0;
+int8_t byteLength = -1;
+
+void reset() {
+	byteCnt = 0;
+	bitCnt = 0;
+	totByteCnt = 0;
+	state = PARSE_PREAMP;
+	byteLength = -1;
+};  //end reset
+
+void parseOregonStream(bool level, uint8_t count) {
+	static uint8_t cnt = 0; //used for counting stuff independent in every state
+	static uint16_t sensorType = 0;
+	static int8_t byte;
+	static uint8_t bytesToParse = 0;    //the number of bytes left in the data part to parse
+	static uint8_t buffer[8];
+
+	if (level) {
+		count+=3;
+	} else {
+		count-=3;
+	}
+
+	switch(state) {
+		case PARSE_PREAMP:  //look for 25 big pulses followed by one short in a row
+			if (BIG_PULSE(count)) {
+				++cnt;
+				break;
+			}
+			if (SMALL_PULSE(count)) {
+				if (cnt > 25) {
+					state=PARSE_ID;
+					sensorType = 0;
+				}
+				cnt = 0;
+			}
+			break;
+
+		case PARSE_ID:  //get the two first Bytes
+			byte = getByte(level, count);
+			if (byte == INVALID_DATA) {
+				reset();
+                cnt = 0;
+				break;
+			} else if (byte == MORE_DATA_NEEDED) {
+				break;
+			} else {
+				if (sensorType == 0) {
+					sensorType = byte << 8;
+				} else {
+					sensorType |= byte;
+					switch (sensorType) {
+						case 0xEA4C:
+							bytesToParse = 5;
+							byteLength = 63;
+							break;
+						case 0x0A4D:
+						case 0x1A2D:    //sensor THGR2228N (channel + sensor_id + battery_level + temp + humidity + checksum)
+							bytesToParse = 7;
+							byteLength = 79;
+							break;
+						default:
+							reset();
+                            cnt = 0;
+							return;
+					}
+					state = PARSE_DATA;
+					cnt = 0;
+				}
+			}
+			break;
+
+		case PARSE_DATA:    //get the remaining data
+			byte = getByte(level, count);
+			if (byte == INVALID_DATA) {
+				reset();
+                cnt = 0;
+				break;
+			} else if (byte == MORE_DATA_NEEDED) {
+				break;
+			}
+			buffer[cnt] = byte;
+            ++cnt;
+			if (bytesToParse == 0) {
+                Serial.print(F("+Wclass:sensor;protocol:oregon;model:0x"));
+                Serial.print(sensorType, HEX);
+                Serial.print(F(";data:0x"));
+                for (int8_t i = 0; i < cnt; ++i) {
+                  Serial.print(buffer[i], HEX);
+                }
+                Serial.println(F(";"));
+                reset();
+                cnt = 0;
+			}
+            --bytesToParse;
+            
+			break;
+	}
+    
+}; //end parseOregonStream
+
+int8_t getByte(bool level, uint8_t count) {
+	int8_t bit = getBit(level, count);
+	static uint8_t byte = 0;
+	
+	if (bit == INVALID_DATA) {
+		return INVALID_DATA;
+	} else if (bit == MORE_DATA_NEEDED) {
+		return MORE_DATA_NEEDED;
+	}
+	byte >>= 1;
+	if (bit) {
+		byte |= (1<<7);
+	}
+	++totByteCnt;
+	++byteCnt;
+	if (byteCnt < 8) {
+		return MORE_DATA_NEEDED;
+	}
+	byteCnt=0;
+	return byte;
+}; //end getByte
+
+int8_t getBit(bool level, uint8_t count) {
+	static bool bit = 0;
+
+	if (bitCnt == 0) {
+		//First pulse must be small
+		if (!SMALL_PULSE(count)) {
+			return INVALID_DATA;
+		}
+		bitCnt = 1;
+
+	} else if (bitCnt == 1) {
+		//Second pulse must be long
+		if (!BIG_PULSE(count) && totByteCnt!=byteLength){ //special check - last byte might have strange values
+			bitCnt = 0;
+			return INVALID_DATA;
+		}
+
+		bit = level;
+		bitCnt = 2;
+		return bit;
+
+	} else if (bitCnt == 2) {
+		//Prepare for next bit
+		if (level && SMALL_PULSE(count)) {
+			//Clean start
+			bitCnt = 0;
+		} else if (BIG_PULSE(count)) {
+			//Combined bit
+			bitCnt = 1;
+		} else if (SMALL_PULSE(count)) {
+			//Clean start
+			bitCnt = 0;
+		}
+		return MORE_DATA_NEEDED;
+	}
+
+	return MORE_DATA_NEEDED;
+}; //end getBit
--- a/arduino/ArduinoTellstickDuo/oregonV2.1.h
+++ b/arduino/ArduinoTellstickDuo/oregonV2.1.h
@ -0,0 +1,11 @@
+#ifndef OREGONV21_H
+#define OREGONV21_H
+
+#include "Arduino.h"
+
+void reset();
+void parseOregonStream(bool level, uint8_t sampleCount);
+int8_t getByte(bool level, uint8_t count);
+int8_t getBit(bool level, uint8_t count);
+
+#endif //OREGONV21_H
--- a/arduino/ArduinoTellstickDuo/rf.cpp
+++ b/arduino/ArduinoTellstickDuo/rf.cpp
@ -0,0 +1,127 @@
+#include "rf.h"
+#include "buffer.h"
+#include "archtech.h"
+#include "config.h"
+#include "oregonV2.1.h"
+
+#define SILENCE_LENGTH  100 //the number of samples with "low" that represents a silent period between two signals
+
+volatile bool RFRX = false;
+
+void parseRadioRXBuffer() {
+  static uint8_t* bufferReadP = RF_rxBufferStartP;
+  static uint8_t* startDataP = 0; //will always point to a "high" buffer address
+  static uint8_t* endDataP = 0;   //will always point to a "low" buffer address
+  static uint8_t prevValue = 0;  //contains the value of the previous buffer index read
+
+  bool parse = false;
+  while (bufferReadP != bufferWriteP) { //stop if the read pointer is pointing to where the writing is currently performed
+    uint8_t sampleCount = *bufferReadP;
+
+    if ( (((uintptr_t)bufferReadP) & 0x1) == 1 ) { //buffer pointer is odd (stores highs)
+      //Serial.print("high:"); Serial.println(sampleCount);
+      if (prevValue >= SILENCE_LENGTH) {
+        startDataP = bufferReadP;   //some new data must start here since this is the first "high" after a silent period
+      }
+
+      //stream data to stream parsers
+      parseOregonStream(HIGH, sampleCount);
+
+    } else { //buffer pointer is even    (stores lows)
+      //Serial.print("low:"); Serial.println(sampleCount);
+      if (sampleCount >= SILENCE_LENGTH) {  //evaluate if it is time to parse the curernt data
+        endDataP = bufferReadP;     //this is a silient period and must be the end of a data
+        if (startDataP != 0){
+          parse = true;
+          break;
+        }
+      }
+
+      //stream data to stream parsers
+      parseOregonStream(LOW, sampleCount);
+
+    }
+
+    //step the read pointer one step
+    uint8_t* nextBufferReadP = getNextBufferPointer(bufferReadP);
+    if (nextBufferReadP == startDataP) { //next pointer will point to startDataP. Data will overflow. Reset the data pointers.
+      startDataP = 0;
+      endDataP = 0;
+      prevValue = 0;
+    }
+
+    //advance buffer pointer one step
+    bufferReadP = nextBufferReadP;
+
+    prevValue = sampleCount;  //update previous value
+  }
+
+  if (!parse) {
+    return;
+  }
+
+  if (startDataP == 0 || endDataP == 0) {
+    return;
+  }
+
+  /*
+  * At this point the startDataP will point to the first high after a silent period
+  * and the endDataP will point at the first (low) silent period after the data data start.
+  */
+
+  //Serial.print((uintptr_t)startDataP); Serial.print(" - "); Serial.println((uintptr_t)endDataP);
+
+  //Let all available parsers parse the data set now.
+  parseArctechSelfLearning(startDataP, endDataP);
+  //TODO: add more parsers here
+
+  //reset the data pointers since the data have been parsed at this point
+  startDataP = 0;
+  endDataP = 0;
+
+};   //end radioTask
+
+void sendTCodedData(uint8_t* data, uint8_t T_long, uint8_t* timings, uint8_t repeat, uint8_t pause) {
+  ACTIVATE_RADIO_TRANSMITTER();
+  for (uint8_t rep = 0; rep < repeat; ++rep) {
+    bool nextPinState = HIGH;
+    for (int i = 0; i < T_long; ++i) {
+      uint8_t timeIndex = (data[i / 4] >> (6 - (2 * (i % 4)))) & 0x03;
+      if (timings[timeIndex] > 0 || i == T_long - 1) {
+        if (nextPinState){
+            TX_PIN_HIGH();
+        }else{
+            TX_PIN_LOW();
+        }
+        delayMicroseconds(10 * timings[timeIndex]);
+      }
+      nextPinState = !nextPinState;
+    }
+    TX_PIN_LOW();
+    if (rep < repeat - 1) {
+      delay(pause);
+    }
+  }
+  ACTIVATE_RADIO_RECEIVER();
+};
+
+void sendSCodedData(uint8_t* data, uint8_t pulseCount, uint8_t repeat, uint8_t pause) {
+  ACTIVATE_RADIO_TRANSMITTER();
+  for (uint8_t rep = 0; rep < repeat; ++rep) {
+    bool nextPinState = HIGH;
+    for (int i = 0; i < pulseCount; ++i) {
+      if (data[i] > 0 || i == pulseCount - 1) {
+        if (nextPinState){
+            TX_PIN_HIGH();
+        }else{
+            TX_PIN_LOW();
+        }
+        delayMicroseconds(data[i] * 10);
+      }
+      nextPinState = !nextPinState;
+    }
+    delay(pause);
+  }
+  TX_PIN_LOW();
+  ACTIVATE_RADIO_RECEIVER();
+};
--- a/arduino/ArduinoTellstickDuo/rf.h
+++ b/arduino/ArduinoTellstickDuo/rf.h
@ -0,0 +1,17 @@
+#ifndef RF_H
+#define RF_H
+
+#include "Arduino.h"
+
+#define ACTIVATE_RADIO_RECEIVER()       (RFRX = true)
+#define ACTIVATE_RADIO_TRANSMITTER()    (RFRX = false)
+#define IS_RADIO_RECIEVER_ON()          (RFRX)
+#define IS_RADIO_TRANSMITTER_ON()       (!RFRX)
+
+extern volatile bool RFRX;
+
+void parseRadioRXBuffer();
+void sendTCodedData(uint8_t* data, uint8_t T_long, uint8_t* timings, uint8_t repeat, uint8_t pause);
+void sendSCodedData(uint8_t* data, uint8_t pulseCount, uint8_t repeat, uint8_t pause);
+
+#endif  //RF_H
--- a/arduino/ArduinoTellstickDuo/usart.cpp
+++ b/arduino/ArduinoTellstickDuo/usart.cpp
@ -0,0 +1,106 @@
+#include "usart.h"
+#include "rf.h"
+
+uint8_t Serial_rxBuffer[79];
+
+void parseSerialForCommand() {
+  if (Serial.available() > 0) {
+    uint8_t rxDataSize = Serial.readBytesUntil('+', &Serial_rxBuffer[0], 79);
+    if (rxDataSize > 0) {
+      parseRxBuffer(&Serial_rxBuffer[0], 0, rxDataSize, false, 3, 0);
+    }
+  }
+};   //end serialTask
+
+bool parseRxBuffer(byte* buffer, uint8_t startIndex, uint8_t endIndex, bool debug, uint8_t repeat, uint8_t pause) {
+  if (startIndex > endIndex) {
+    return false;
+  }
+  char c = buffer[startIndex];
+  //Serial.print("DEBUG: char:"); Serial.println(c, DEC);
+  switch (c) {
+    case 'S':
+      return handleSCommand(buffer, startIndex + 1, endIndex, debug, repeat, pause);
+    case 'T':
+      return handleTCommand(buffer, startIndex + 1, endIndex, debug, repeat, pause);
+    case 'V':
+      Serial.println(F("+V2"));
+      return parseRxBuffer(buffer, startIndex + 1, endIndex, debug, repeat, pause);
+    case 'D':
+      return parseRxBuffer(buffer, startIndex + 1, endIndex, !debug, repeat, pause);
+    case 'P':
+      if (endIndex - startIndex + 1 < 3) {
+        return false;
+      } //at least {'P',[p-value],'+'} must be left in the buffer
+      return parseRxBuffer(buffer, startIndex + 2, endIndex, debug, repeat, buffer[startIndex + 1]);
+    case 'R':
+      if (endIndex - startIndex + 1 < 3) {
+        return false;
+      } //at least {'R',[r-value],'+'} must be left in the buffer
+      return parseRxBuffer(buffer, startIndex + 2, endIndex, debug, buffer[startIndex + 1], pause);
+    case '+':
+      return true;
+    default:
+      //Serial.print("DEBUG: unknown char: '"); Serial.print(c, BIN); Serial.println("'");
+      return false;
+  }
+}; //end parseRxBuffer
+
+bool handleSCommand(byte* buffer, uint8_t startIndex, uint8_t endIndex, bool debug, uint8_t repeat, uint8_t pause) {
+  //Parse message received from serial
+  uint8_t S_data[78]; //78 pulses
+  uint8_t pulseCount = 0;
+  for (uint8_t i = startIndex; i <= endIndex; ++i) {
+    if (buffer[i] == '+') {
+      break;
+    } else if (i == endIndex) {
+      return false;
+    } else {
+      S_data[pulseCount++] = buffer[i];
+    }
+  }
+  //Send message
+  sendSCodedData(&S_data[0], pulseCount, repeat, pause);
+
+  //send confirmation over serial
+  Serial.println(F("+S"));
+  return true;
+}; //end handleS
+
+bool handleTCommand(byte* buffer, uint8_t startIndex, uint8_t endIndex, bool debug, uint8_t repeat, uint8_t pause) {
+  //Parse message received from serial
+  uint8_t T_data[72]; //0-188 pulses
+  if (endIndex - startIndex < 5) {
+    //Serial.println("DEBUG: wrong size!");
+    return false;
+  }
+  uint8_t buff_p = startIndex;
+  uint8_t T_times[4] = {buffer[buff_p++], buffer[buff_p++], buffer[buff_p++], buffer[buff_p++]};
+  uint8_t T_long = buffer[buff_p++];
+  uint8_t T_bytes = 0;
+  if ( (T_long / 4.0) > (float)(T_long / 4) ) {
+    T_bytes = T_long / 4 + 1;
+  } else {
+    T_bytes = T_long / 4;
+  }
+  uint8_t j = 0;
+  while (j < T_bytes) {
+    if (buffer[buff_p] == '+') {
+      break;
+    } else if (buff_p >= endIndex) {
+      return false;
+    } else {
+      T_data[j++] = buffer[buff_p++];
+    }
+  }
+  if ( j != T_bytes ) {
+    return false;
+  }
+
+  //Send message
+  sendTCodedData(&T_data[0], T_long, &T_times[0], repeat, pause);
+
+  //send confirmation over serial
+  Serial.println(F("+T"));
+  return parseRxBuffer(buffer, buff_p, endIndex, debug, repeat, pause);
+}; //end handleT
--- a/arduino/ArduinoTellstickDuo/usart.h
+++ b/arduino/ArduinoTellstickDuo/usart.h
@ -0,0 +1,13 @@
+#ifndef USART_H
+#define USART_H
+
+#include "Arduino.h"
+
+void parseSerialForCommand();
+bool parseRxBuffer(byte* buffer, uint8_t startIndex, uint8_t endIndex, bool debug, uint8_t repeat, uint8_t pause);
+bool handleSCommand(byte* buffer, uint8_t startIndex, uint8_t endIndex, bool debug, uint8_t repeat, uint8_t pause);
+bool handleTCommand(byte* buffer, uint8_t startIndex, uint8_t endIndex, bool debug, uint8_t repeat, uint8_t pause);
+
+extern uint8_t Serial_rxBuffer[79];
+
+#endif  //USART_H
--- a/arduino/HalMultiSensor/HalConfiguration.h
+++ b/arduino/HalMultiSensor/HalConfiguration.h
@ -0,0 +1,31 @@
+#ifndef HALCONFIGURATION_H
+#define HALCONFIGURATION_H
+
+//#define ENABLE_DEBUG // comment out to disable debug
+
+
+#define TIMER_MILLISECOND 60000 // poling in minutes
+#define INDICATOR_PIN     13      // diode
+#define TX_PIN            11
+#define DEVICE_BASE_ID    99
+
+// POWER CONSUMPTION SENSOR
+//#define POWERCON_ENABLED // comment out to disable sensor
+#define POWERCON_SENSOR         SensorPhotocell()
+#define POWERCON_PROTOCOL       ProtocolOregon(TX_PIN, DEVICE_BASE_ID + 0)
+#define POWER_TIMER_MULTIPLIER  1
+
+// TEMPERATURE SENSOR
+#define TEMPERATURE_ENABLED // comment out to disable sensor
+#define TEMPERATURE_SENSOR      SensorDHT(DHT11, 10)
+#define TEMPERATURE_PROTOCOL    ProtocolOregon(TX_PIN, DEVICE_BASE_ID + 1)
+#define TEMPERATURE_TIMER_MULTIPLIER 10
+
+// LIGHT SENSOR
+//#define LIGHT_ENABLED // comment out to disable sensor
+#define LIGHT_SENSOR            SensorBH1750()
+#define LIGHT_PROTOCOL          ProtocolOregon(TX_PIN, DEVICE_BASE_ID + 2)
+#define LIGHT_TIMER_MULTIPLIER  10
+
+
+#endif // HALCONFIGURATION_H
--- a/arduino/HalMultiSensor/HalInclude.h
+++ b/arduino/HalMultiSensor/HalInclude.h
@ -0,0 +1,14 @@
+#ifndef HALDEFINITIONS_H
+#define HALDEFINITIONS_H
+
+/////// SENSORS
+#include "SensorBH1750.h"
+#include "SensorDHT.h"
+#include "SensorPhotocell.h"
+
+//////// PROTOCOLS
+#include "ProtocolNexa.h"
+#include "ProtocolOregon.h"
+
+
+#endif // HALDEFINITIONS_H
--- a/arduino/HalMultiSensor/HalInterfaces.h
+++ b/arduino/HalMultiSensor/HalInterfaces.h
@ -0,0 +1,101 @@
+#ifndef HALINTERFACES_H
+#define HALINTERFACES_H
+
+#include <Arduino.h>
+#include "HalConfiguration.h"
+
+// Utility functions
+
+#ifdef ENABLE_DEBUG
+    #define DEBUG(msg) \
+        Serial.println(msg); \
+        Serial.flush();
+    #define DEBUGF(msg, ...) \
+        static char buffer[80];\
+        snprintf(buffer, sizeof(buffer), msg, __VA_ARGS__);\
+        Serial.println(buffer);\
+        Serial.flush();
+#else
+    #define DEBUG(msg)
+    #define DEBUGF(msg, ...)
+#endif
+
+
+inline void pulse(short pin, short count)
+{
+    while (--count >= 0)
+    {
+        digitalWrite(INDICATOR_PIN, HIGH);
+        delay(150);
+        digitalWrite(INDICATOR_PIN, LOW);
+        if (count != 0) delay(200);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////
+// INTERFACES
+
+class Sensor
+{
+public:
+    virtual void setup() = 0;
+};
+class Protocol
+{
+public:
+    virtual void setup() = 0;
+};
+
+
+
+struct PowerData
+{
+    unsigned int consumption;
+};
+class SensorPowerConsumption : public Sensor
+{
+public:
+    // returns number of pulses from power meter
+    virtual void read(PowerData& data) = 0;
+};
+class ProtocolPowerConsumption : public Protocol
+{
+public:
+    virtual void send(const PowerData& data) = 0;
+};
+
+
+struct TemperatureData
+{
+    float temperature;
+    float humidity;
+};
+class SensorTemperature : public Sensor
+{
+public:
+    virtual void read(TemperatureData& data) = 0;
+};
+class ProtocolTemperature : public Protocol
+{
+public:
+    virtual void send(const TemperatureData& data) = 0;
+};
+
+
+struct LightData
+{
+    unsigned int lumen;
+};
+class SensorLight : public Sensor
+{
+public:
+    virtual void read(LightData& data) = 0;
+};
+class ProtocolLight : public Protocol
+{
+public:
+    virtual void send(const LightData& data) = 0;
+};
+
+
+#endif // HALINTERFACES_H
--- a/arduino/HalMultiSensor/HalMultiSensor.ino
+++ b/arduino/HalMultiSensor/HalMultiSensor.ino
@ -0,0 +1,132 @@
+/*
+A interrupt based sensor device that reads multiple sensors and transmits
+the data to a central location.
+*/
+#include <Arduino.h>
+
+#include "HalConfiguration.h"
+#include "HalInterfaces.h"
+#include "HalInclude.h"
+#include "Interrupt.h"
+
+
+#ifndef POWERCON_ENABLED
+    #define POWER_TIMER_MULTIPLIER 1
+#endif
+#ifndef TEMPERATURE_ENABLED
+    #define TEMPERATURE_TIMER_MULTIPLIER 1
+#endif
+#ifndef LIGHT_ENABLED
+    #define LIGHT_TIMER_MULTIPLIER 1
+#endif
+#define TIMER_MULTIPLIER_MAX \
+    POWER_TIMER_MULTIPLIER * TEMPERATURE_TIMER_MULTIPLIER * LIGHT_TIMER_MULTIPLIER
+unsigned int timerMultiplier = 0;
+
+// Sensors
+SensorPowerConsumption* powerSensor;
+SensorTemperature* tempSensor;
+SensorLight* lightSensor;
+
+// Protocols
+ProtocolPowerConsumption* powerProtocol;
+ProtocolTemperature* tempProtocol;
+ProtocolLight* lightProtocol;
+
+
+
+void timerInterruptFunc();
+
+void setup()
+{
+    #ifdef ENABLE_DEBUG
+    Serial.begin(9600);
+    #endif
+    pinMode(INDICATOR_PIN, OUTPUT);
+
+    // Setup Sensors and protocols
+    #ifdef POWERCON_ENABLED
+    DEBUG("Setup POWERCON_SENSOR");
+    powerSensor = new POWERCON_SENSOR;
+    powerSensor->setup();
+    powerProtocol = new POWERCON_PROTOCOL;
+    powerProtocol->setup();
+    #endif
+
+    #ifdef TEMPERATURE_ENABLED
+    DEBUG("Setup TEMPERATURE_SENSOR");
+    tempSensor = new TEMPERATURE_SENSOR;
+    tempSensor->setup();
+    tempProtocol = new TEMPERATURE_PROTOCOL;
+    tempProtocol->setup();
+    #endif
+
+    #ifdef LIGHT_ENABLED
+    DEBUG("Setup LIGHT_SENSOR");
+    lightSensor = new LIGHT_SENSOR;
+    lightSensor->setup();
+    lightProtocol = new LIGHT_PROTOCOL;
+    lightProtocol->setup();
+    #endif
+
+    DEBUG("Setup SLEEP_INTERRUPT");
+    Interrupt::setWatchDogCallback(timerInterruptFunc);
+    Interrupt::setupWatchDogInterrupt(TIMER_MILLISECOND); // one minute scheduled interrupt
+
+
+    pulse(INDICATOR_PIN, 3);
+    DEBUG("Ready");
+}
+
+
+void timerInterruptFunc()
+{
+    ++timerMultiplier;
+    if (timerMultiplier > TIMER_MULTIPLIER_MAX)
+        timerMultiplier = 1;
+}
+
+void loop()
+{
+    digitalWrite(INDICATOR_PIN, HIGH);
+
+    // Send power consumption
+    #ifdef POWERCON_ENABLED
+    if (timerMultiplier % POWER_TIMER_MULTIPLIER == 0)
+    {
+        static PowerData powerData;
+        powerSensor->read(powerData); // not needed, only here for future use
+        DEBUGF("Read POWERCON_SENSOR= consumption:%d", powerData.consumption);
+        powerProtocol->send(powerData);
+    }
+    #endif
+
+    // Handle temperature sensor
+    #ifdef TEMPERATURE_ENABLED
+    if (timerMultiplier % TEMPERATURE_TIMER_MULTIPLIER == 0)
+    {
+        static TemperatureData tempData;
+        tempSensor->read(tempData);
+        DEBUGF("Read TEMPERATURE_SENSOR= temperature:%d, humidity:%d", (int)tempData.temperature, (int)tempData.humidity);
+        tempProtocol->send(tempData);
+    }
+    #endif
+
+    // Handle light sensor
+    #ifdef LIGHT_ENABLED
+    if (timerMultiplier % LIGHT_TIMER_MULTIPLIER == 0)
+    {
+        static LightData lightData;
+        lightSensor->read(lightData);
+        DEBUGF("Read LIGHT_SENSOR= lumen:%d", lightData.lumen);
+        lightProtocol->send(lightData);
+    }
+    #endif
+
+    digitalWrite(INDICATOR_PIN, LOW);
+
+    DEBUG("Sleeping");
+    Interrupt::sleep();
+    DEBUG("Wakeup");
+}
+
--- a/arduino/HalMultiSensor/HalMultiSensorEnclosure.FCStd
+++ b/arduino/HalMultiSensor/HalMultiSensorEnclosure.FCStd
--- a/arduino/HalMultiSensor/HalMultiSensorEnclosure_bottom.stl
+++ b/arduino/HalMultiSensor/HalMultiSensorEnclosure_bottom.stl
--- a/arduino/HalMultiSensor/HalMultiSensorEnclosure_top.stl
+++ b/arduino/HalMultiSensor/HalMultiSensorEnclosure_top.stl
--- a/arduino/HalMultiSensor/Interrupt.cpp
+++ b/arduino/HalMultiSensor/Interrupt.cpp
@ -0,0 +1,234 @@
+#include "Interrupt.h"
+#include <avr/power.h>
+#include <avr/sleep.h>
+#include <avr/wdt.h>
+#include "HalInterfaces.h"
+
+void emptyFunc(){}
+bool Interrupt::wakeUpNow = false;
+InterruptFunction Interrupt::pinCallback = emptyFunc;
+InterruptFunction Interrupt::wdtCallback = emptyFunc;
+
+
+void Interrupt::handlePinInterrupt()        // the interrupt is handled here after wakeup
+{
+    (*Interrupt::pinCallback) ();
+    //Interrupt::wakeUp();
+}
+
+void Interrupt::sleep()
+{
+    /*
+     * The 5 different modes are:
+     *     SLEEP_MODE_IDLE         -the least power savings
+     *     SLEEP_MODE_ADC
+     *     SLEEP_MODE_PWR_SAVE
+     *     SLEEP_MODE_STANDBY
+     *     SLEEP_MODE_PWR_DOWN     -the most power savings
+     *
+     * For now, we want as much power savings as possible, so we
+     * choose the according
+     * sleep mode: SLEEP_MODE_PWR_DOWN
+     */
+    set_sleep_mode(SLEEP_MODE_PWR_DOWN);   // sleep mode is set here
+    wakeUpNow = false;
+
+    sleep_enable();         // enables the sleep bit in the mcucr register
+                            // so sleep is possible. just a safety pin
+
+    //power_adc_disable();
+    //power_spi_disable();
+    //power_usart0_disable();
+    //power_timer0_disable();
+    //power_timer1_disable();
+    //power_timer2_disable();
+    //power_twi_disable();
+    //power_all_disable();
+
+    while( ! Interrupt::wakeUpNow)
+    {
+        sleep_mode();           // here the device is actually put to sleep!!
+                 // THE PROGRAM CONTINUES FROM HERE AFTER WAKING UP
+    }
+    sleep_disable();        // first thing after waking from sleep:
+                            // disable sleep...
+
+    //power_adc_enable();
+    //power_spi_enable();
+    //power_usart0_enable();
+    //power_timer0_enable();
+    //power_timer1_enable();
+    //power_timer2_enable();
+    //power_twi_enable();
+    //power_all_enable();     // during normal running time.
+}
+
+void Interrupt::setupPinInterrupt(int pin)
+{
+    noInterrupts(); // disable all interrupts
+
+    /* Now it is time to enable an interrupt.
+     * In the function call attachInterrupt(A, B, C)
+     * A   can be either 0 or 1 for interrupts on pin 2 or 3.
+     * B   Name of a function you want to execute at interrupt for A.
+     * C   Trigger mode of the interrupt pin. can be:
+     *             LOW        a low level triggers
+     *             CHANGE     a change in level triggers
+     *             RISING     a rising edge of a level triggers
+     *             FALLING    a falling edge of a level triggers
+     *
+     * In all but the IDLE sleep modes only LOW can be used.
+     */
+    attachInterrupt((pin == PIND2 ? 0 : 1), Interrupt::handlePinInterrupt, RISING);
+
+    //detachInterrupt(0);      // disables interrupt 0 on pin 2 so the
+                             // wakeUpNow code will not be executed
+
+    interrupts(); // enable all interrupts
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Watchdog timer
+uint16_t wdtTime;
+int32_t wdtTimeLeft;
+
+
+void Interrupt::handleWatchDogInterrupt()
+{
+    wdt_disable();
+    if (wdtTime <= 0)
+        return;
+    DEBUGF("WDT interrupt, time=%u, timeLeft=%ld", wdtTime, wdtTimeLeft);
+
+    if (wdtTimeLeft <= 0)
+    {
+        Interrupt::wakeUp();
+        (*Interrupt::wdtCallback) ();
+        wdtTimeLeft = wdtTime;
+    }
+
+    setupWatchDogInterrupt();
+}
+
+ISR(WDT_vect)
+{
+    Interrupt::handleWatchDogInterrupt();
+}
+
+void Interrupt::setupWatchDogInterrupt(int32_t milliseconds)
+{
+    wdtTimeLeft = wdtTime = milliseconds;
+    setupWatchDogInterrupt();
+}
+
+void Interrupt::setupWatchDogInterrupt()
+{
+    if (wdtTime <= 0){
+        wdt_disable();
+        return;
+    }
+
+    noInterrupts();
+
+    unsigned short duration;
+
+    if (8000 <= wdtTimeLeft){
+        wdtTimeLeft -= 8000;
+        duration = (1 << WDP3) | (1 << WDP0);
+    } else if (4000 <= wdtTimeLeft){
+       wdtTimeLeft -= 4000;
+       duration = (1 << WDP3);
+    } else if (2000 <= wdtTimeLeft){
+       wdtTimeLeft -= 2000;
+       duration = (1 << WDP2) | (1 << WDP1) | (1 << WDP0);
+    } else if (1000 <= wdtTimeLeft){
+       wdtTimeLeft -= 1000;
+       duration = (1 << WDP2) | (1 << WDP1);
+    } else if (500 <= wdtTimeLeft){
+       wdtTimeLeft -= 500;
+       duration = (1 << WDP2) | (1 << WDP0);
+    } else if (256 <= wdtTimeLeft){
+       wdtTimeLeft -= 256;
+       duration = (1 << WDP2);
+    } else if (128 <= wdtTimeLeft){
+       wdtTimeLeft -= 128;
+       duration = (1 << WDP1) | (1 << WDP0);
+    } else if (64 <= wdtTimeLeft){
+       wdtTimeLeft -= 64;
+       duration = (1 << WDP1);
+    } else if (32 <= wdtTimeLeft){
+       wdtTimeLeft -= 32;
+       duration = (1 << WDP0);
+    } else { //(16 <= wdtTimeLeft){
+       wdtTimeLeft -= 16;
+       duration = 0;
+    }
+
+    wdt_reset();
+    MCUSR &= ~(1 << WDRF);  // reset status flag
+
+    /* WDCE = Watchdog Change Enable
+     *
+     * WDTON(1)  WDE  WDIE  Mode
+     * 1         0    0     Stopped
+     * 1         0    1     Interrupt
+     * 1         1    0     Reset
+     * 1         1    1     Interrupt first, reset on second trigger
+     * 0         x    x     Reset
+     */
+    WDTCSR = (1 << WDCE) | (1<<WDE); // enable configuration
+    /* WDP3 WDP2 WDP1 WDP0  Number of cycles  Typical Time-out time (VCC = 5.0V)
+     * 0    0    0    0     2K (2048)         16 ms
+     * 0    0    0    1     4K (4096)         32 ms
+     * 0    0    1    0     8K (8192)         64 ms
+     * 0    0    1    1     16K (16384)       0.125 s
+     * 0    1    0    0     32K (32768)       0.25 s
+     * 0    1    0    1     64K (65536)       0.5 s
+     * 0    1    1    0     128K (131072)     1.0 s
+     * 0    1    1    1     256K (262144)     2.0 s
+     * 1    0    0    0     512K (524288)     4.0 s
+     * 1    0    0    1     1024K (1048576)   8.0 s
+     */
+    WDTCSR = (1 << WDIE) | duration;
+    //WDTCSR = (1 << WDIE) | (1 << WDP3) | (1 << WDP0);
+
+    interrupts();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// Timer 1
+/*
+ISR(Timer1_COMPA_vect) // timer compare interrupt service routine
+{
+    //DEBUG("Timer1e Interrupt");
+    __pinInterruptHandler__();
+}
+*/
+/*
+void Interrupt::setupTimerInterrupt(unsigned int milliseconds)
+{
+    noInterrupts(); // disable all interrupts
+
+    // initialize Timer1
+    TCCR1A = 0;
+    TCCR1B = 0;
+
+    /* Clock Select Bit Description
+     *  CS12    CS11    CS10    Description
+     *  0       0       0       No clock source (Stop timer)
+     *  0       0       1       clk/1 (No prescaling)
+     *  0       1       0       clk/8
+     *  0       1       1       clk/64
+     *  1       0       0       clk/256
+     *  1       0       1       clk/1024
+     *  1       1       0       External clock source on T1 pin. Clock on falling edge.
+     *  1       1       1       External clock source on T1 pin. Clock on rising edge.
+     */
+/*    TCCR1B |= (1 << CS12); // 256 prescaler
+    TCNT1 = 34286; // preload timer 65536-16MHz/256/2Hz
+    //TODO: TIMSK1 |= (1 << TOIE1); // enable timer overflow interrupt
+
+    interrupts(); // enable all interrupts
+}
+*/
--- a/arduino/HalMultiSensor/Interrupt.h
+++ b/arduino/HalMultiSensor/Interrupt.h
@ -0,0 +1,39 @@
+#ifndef INTERRUPT_H
+#define INTERRUPT_H
+
+#include <Arduino.h>
+
+typedef void (*InterruptFunction) ();
+
+class Interrupt
+{
+public:
+    static void wakeUp() { wakeUpNow = true; };
+    static void sleep();
+    static void setupPinInterrupt(int pin);
+    static void setupWatchDogInterrupt(int32_t milliseconds);
+    //static void setupTimerInterrupt(unsigned int milliseconds);
+
+    static void setPinCallback(InterruptFunction callback){ Interrupt::pinCallback = callback;}
+    static void setWatchDogCallback(InterruptFunction callback){ Interrupt::wdtCallback = callback;}
+
+    /* Should not be called externally, used as triggering functions */
+    static void handlePinInterrupt();
+    static void handleWatchDogInterrupt();
+private:
+    static bool wakeUpNow;
+
+    static InterruptFunction pinCallback;
+    static InterruptFunction wdtCallback;
+
+    static void setupWatchDogInterrupt();
+
+    // Disable constructors and copy operators
+    Interrupt() {};
+    Interrupt(Interrupt const&);
+    void operator=(Interrupt const&);
+
+};
+
+
+#endif // INTERRUPT_H
--- a/arduino/HalMultiSensor/ProtocolNexa.cpp
+++ b/arduino/HalMultiSensor/ProtocolNexa.cpp
@ -0,0 +1 @@
+
--- a/arduino/HalMultiSensor/ProtocolNexa.h
+++ b/arduino/HalMultiSensor/ProtocolNexa.h
@ -0,0 +1,8 @@
+#ifndef PROTOCOLNEXA_H
+#define PROTOCOLNEXA_H
+
+#include "HalInterfaces.h"
+
+
+
+#endif // PROTOCOLNEXA_H
--- a/arduino/HalMultiSensor/ProtocolOregon.cpp
+++ b/arduino/HalMultiSensor/ProtocolOregon.cpp
@ -0,0 +1,215 @@
+#include "ProtocolOregon.h"
+
+#define RF_DELAY 512
+#define RF_DELAY_LONG RF_DELAY*2
+#define RF_SEND_HIGH() digitalWrite(txPin, HIGH)
+#define RF_SEND_LOW() digitalWrite(txPin, LOW)
+
+
+void ProtocolOregon::setup()
+{
+  pinMode(txPin, OUTPUT);
+  RF_SEND_LOW();
+}
+
+
+void ProtocolOregon::send(const PowerData& data)
+{
+    send(data.consumption, 0);
+}
+
+void ProtocolOregon::send(const TemperatureData& data)
+{
+    send(data.temperature, data.humidity);
+}
+
+void ProtocolOregon::send(const LightData& data)
+{
+    send(data.lumen, 0);
+}
+
+
+
+void ProtocolOregon::send(float temperature, short humidity)
+{
+    byte buffer[9];
+    setType(buffer, 0x1A,0x2D); //temperature/humidity sensor (THGR2228N)
+    setChannel(buffer, 0x20);
+    setId(buffer, address); //set id of the sensor, BB=187
+    setBatteryLevel(buffer, true); // false : low, true : high
+    setTemperature(buffer, temperature); //org setTemperature(OregonMessageBuffer, 55.5);
+    setHumidity(buffer, humidity);
+    calculateAndSetChecksum(buffer);
+
+    // Send the Message over RF
+    rfSend(buffer, sizeof(buffer));
+    // Send a "pause"
+    RF_SEND_LOW();
+    delayMicroseconds(RF_DELAY_LONG * 8);
+    // Send a copy of the first message. The v2.1 protocol send the message two RF_DELAYs
+    rfSend(buffer, sizeof(buffer));
+    RF_SEND_LOW();
+}
+
+/**
+ * \brief Set the sensor type
+ * \param data Oregon message
+ * \param type Sensor type
+ */
+inline void ProtocolOregon::setType(byte data[], byte b1, byte b2)
+{
+  data[0] = b1;
+  data[1] = b2;
+}
+
+/**
+ * \brief Set the sensor channel
+ * \param data Oregon message
+ * \param channel Sensor channel (0x10, 0x20, 0x30)
+ */
+inline void ProtocolOregon::setChannel(byte data[], byte channel)
+{
+  data[2] = channel;
+}
+
+
+inline void ProtocolOregon::setId(byte data[], byte id)
+{
+  data[3] = id;
+}
+
+/**
+ * \param   level     false: low, true: high
+ */
+inline void ProtocolOregon::setBatteryLevel(byte data[], bool level)
+{
+  if (!level) data[4] = 0x0C;
+  else data[4] = 0x00;
+}
+
+inline void ProtocolOregon::setTemperature(byte data[], float temp)
+{
+  // Set temperature sign
+  if (temp < 0)
+  {
+    data[6] = 0x08;
+    temp *= -1;
+  }
+  else
+  {
+    data[6] = 0x00;
+  }
+
+  // Determine decimal and float part
+  int tempInt = (int)temp;
+  int td = (int)(tempInt / 10);
+  int tf = (int)round((float)((float)tempInt/10 - (float)td) * 10);
+
+  int tempFloat = (int)round((float)(temp - (float)tempInt) * 10);
+
+  // Set temperature decimal part
+  data[5] = (td << 4);
+  data[5] |= tf;
+
+  // Set temperature float part
+  data[4] |= (tempFloat << 4);
+}
+
+inline void ProtocolOregon::setHumidity(byte data[], byte hum)
+{
+  data[7] = (hum/10);
+  data[6] |= (hum - data[7]*10) << 4;
+}
+
+inline void ProtocolOregon::calculateAndSetChecksum(byte data[])
+{
+  int sum = 0;
+  for(byte i = 0; i<8;i++)
+  {
+    sum += (data[i]&0xF0) >> 4;
+    sum += (data[i]&0x0F);
+  }
+  data[8] = ((sum - 0x0A) & 0xFF);
+}
+
+
+
+
+//*********************************************************************************************************
+
+
+/**
+ * \brief Send logical "0" over RF
+ * \details a zero bit be represented by an off-to-on transition
+ * \ of the RF signal at the middle of a clock period.
+ * \ Remember, the Oregon v2.1 protocol adds an inverted bit first
+ */
+inline void ProtocolOregon::sendZero(void)
+{
+  RF_SEND_HIGH();
+  delayMicroseconds(RF_DELAY);
+  RF_SEND_LOW();
+  delayMicroseconds(RF_DELAY_LONG);
+  RF_SEND_HIGH();
+  delayMicroseconds(RF_DELAY);
+}
+
+/**
+ * \brief Send logical "1" over RF
+ * \details a one bit be represented by an on-to-off transition
+ * \ of the RF signal at the middle of a clock period.
+ * \ Remember, the Oregon v2.1 protocol add an inverted bit first
+ */
+inline void ProtocolOregon::sendOne(void)
+{
+  RF_SEND_LOW();
+  delayMicroseconds(RF_DELAY);
+  RF_SEND_HIGH();
+  delayMicroseconds(RF_DELAY_LONG);
+  RF_SEND_LOW();
+  delayMicroseconds(RF_DELAY);
+}
+
+
+/******************************************************************/
+/******************************************************************/
+/******************************************************************/
+
+/**
+ * \brief Send a buffer over RF
+ * \param data Data to send
+ * \param length size of data array
+ */
+void ProtocolOregon::sendData(byte data[], byte length)
+{
+  for (byte i=0; i<length; ++i)
+  {
+    (bitRead(data[i], 0)) ? sendOne() : sendZero();
+    (bitRead(data[i], 1)) ? sendOne() : sendZero();
+    (bitRead(data[i], 2)) ? sendOne() : sendZero();
+    (bitRead(data[i], 3)) ? sendOne() : sendZero();
+    (bitRead(data[i], 4)) ? sendOne() : sendZero();
+    (bitRead(data[i], 5)) ? sendOne() : sendZero();
+    (bitRead(data[i], 6)) ? sendOne() : sendZero();
+    (bitRead(data[i], 7)) ? sendOne() : sendZero();
+  }
+}
+
+/**
+ * \brief Send an Oregon message
+ * \param data The Oregon message
+ */
+void ProtocolOregon::rfSend(byte data[], byte size)
+{
+    // Send preamble
+    byte preamble[] = { 0xFF,0xFF };
+    sendData(preamble, 2);
+    // Send sync nibble
+    //sendQuarterLSB(0xA); // It is not use in this version since the sync nibble is include in the Oregon message to send.
+    // Send data
+    sendData(data, size);
+    // Send postamble
+    byte postamble[] = { 0x00 };
+    sendData(postamble, 1);
+}
+
--- a/arduino/HalMultiSensor/ProtocolOregon.h
+++ b/arduino/HalMultiSensor/ProtocolOregon.h
@ -0,0 +1,37 @@
+#ifndef PROTOCOLOREGON_H
+#define PROTOCOLOREGON_H
+
+#include <Arduino.h>
+#include "HalInterfaces.h"
+
+
+class ProtocolOregon : public ProtocolTemperature, public ProtocolPowerConsumption, public ProtocolLight
+{
+public:
+    ProtocolOregon(short pin, unsigned char address) : txPin(pin), address(address){};
+
+    virtual void setup();
+    virtual void send(const TemperatureData& data);
+    virtual void send(const PowerData& data);
+    virtual void send(const LightData& data);
+
+private:
+    short txPin;
+    unsigned char address;
+
+    void send(float temperature, short humidity);
+    void setType(byte *data, byte b1, byte b2);
+    void setChannel(byte *data, byte channel);
+    void setId(byte *data, byte id);
+    void setBatteryLevel(byte *data, bool level);
+    void setTemperature(byte *data, float temp);
+    void setHumidity(byte* data, byte hum);
+    void calculateAndSetChecksum(byte* data);
+
+    void sendZero(void);
+    void sendOne(void);
+    void sendData(byte *data, byte length);
+    void rfSend(byte *data, byte size);
+};
+
+#endif // PROTOCOLOREGON_H
--- a/arduino/HalMultiSensor/SensorBH1750.cpp
+++ b/arduino/HalMultiSensor/SensorBH1750.cpp
@ -0,0 +1,93 @@
+/*
+
+This is a library for the BH1750FVI Digital Light Sensor
+breakout board.
+
+The board uses I2C for communication. 2 pins are required to
+interface to the device.
+
+
+based on Christopher Laws, March, 2013 code.
+
+*/
+
+#include "SensorBH1750.h"
+#include <util/delay.h>
+
+
+#define BH1750_I2CADDR 0x23
+
+// No active state
+#define BH1750_POWER_DOWN 0x00
+
+// Waiting for measurement command
+#define BH1750_POWER_ON 0x01
+
+// Reset data register value - not accepted in POWER_DOWN mode
+#define BH1750_RESET 0x07
+
+// Start measurement at 1lx resolution. Measurement time is approx 120ms.
+#define BH1750_CONTINUOUS_HIGH_RES_MODE  0x10
+
+// Start measurement at 0.5lx resolution. Measurement time is approx 120ms.
+#define BH1750_CONTINUOUS_HIGH_RES_MODE_2  0x11
+
+// Start measurement at 4lx resolution. Measurement time is approx 16ms.
+#define BH1750_CONTINUOUS_LOW_RES_MODE  0x13
+
+// Start measurement at 1lx resolution. Measurement time is approx 120ms.
+// Device is automatically set to Power Down after measurement.
+#define BH1750_ONE_TIME_HIGH_RES_MODE  0x20
+
+// Start measurement at 0.5lx resolution. Measurement time is approx 120ms.
+// Device is automatically set to Power Down after measurement.
+#define BH1750_ONE_TIME_HIGH_RES_MODE_2  0x21
+
+// Start measurement at 1lx resolution. Measurement time is approx 120ms.
+// Device is automatically set to Power Down after measurement.
+#define BH1750_ONE_TIME_LOW_RES_MODE  0x23
+
+
+
+void SensorBH1750::setup() {
+  Wire.begin();
+  //configure(BH1750_ONE_TIME_HIGH_RES_MODE);
+}
+
+
+void SensorBH1750::configure(uint8_t mode) {
+    switch (mode) {
+        case BH1750_CONTINUOUS_HIGH_RES_MODE:
+        case BH1750_CONTINUOUS_HIGH_RES_MODE_2:
+        case BH1750_CONTINUOUS_LOW_RES_MODE:
+        case BH1750_ONE_TIME_HIGH_RES_MODE:
+        case BH1750_ONE_TIME_HIGH_RES_MODE_2:
+        case BH1750_ONE_TIME_LOW_RES_MODE:
+            // apply a valid mode change
+            Wire.beginTransmission(BH1750_I2CADDR);
+            Wire.write(mode);
+            Wire.endTransmission();
+            _delay_ms(10);
+            break;
+        default:
+            // Invalid measurement mode
+            DEBUG("Invalid measurement mode");
+            break;
+    }
+}
+
+
+void SensorBH1750::read(LightData& data) {
+	configure(BH1750_ONE_TIME_HIGH_RES_MODE);
+    _delay_ms(200); // Wait for measurement
+
+	Wire.beginTransmission(BH1750_I2CADDR);
+	Wire.requestFrom(BH1750_I2CADDR, 2);
+	uint16_t level = Wire.read();
+	level <<= 8;
+	level |= Wire.read();
+	Wire.endTransmission();
+
+	data.lumen = level/1.2; // convert to lux
+}
+
--- a/arduino/HalMultiSensor/SensorBH1750.h
+++ b/arduino/HalMultiSensor/SensorBH1750.h
@ -0,0 +1,21 @@
+#ifndef SensorBH1750_H
+#define SensorBH1750_H
+
+#include <Wire.h>
+#include "HalInterfaces.h"
+
+
+class SensorBH1750 : public SensorLight{
+public:
+    virtual void setup();
+    virtual void read(LightData& data);
+
+private:
+    unsigned int pulses;
+
+    void configure(uint8_t mode);
+
+};
+
+#endif // SensorBH1750_H
+
--- a/arduino/HalMultiSensor/SensorDHT.cpp
+++ b/arduino/HalMultiSensor/SensorDHT.cpp
@ -0,0 +1,165 @@
+/* DHT library
+MIT license
+written by Adafruit Industries
+*/
+// Modified by Ziver Koc
+//
+
+#include "SensorDHT.h"
+
+
+void SensorDHT::setup()
+{
+    // set up the pins!
+    pinMode(_pin, INPUT_PULLUP);
+    #ifdef __AVR
+        _bit = digitalPinToBitMask(_pin);
+        _port = digitalPinToPort(_pin);
+    #endif
+    _maxcycles = microsecondsToClockCycles(1000);  // 1 millisecond timeout for
+                                                   // reading pulses from DHT sensor.
+}
+
+
+// Expect the signal line to be at the specified level for a period of time and
+// return a count of loop cycles spent at that level (this cycle count can be
+// used to compare the relative time of two pulses).  If more than a millisecond
+// ellapses without the level changing then the call fails with a 0 response.
+// This is adapted from Arduino's pulseInLong function (which is only available
+// in the very latest IDE versions):
+//   https://github.com/arduino/Arduino/blob/master/hardware/arduino/avr/cores/arduino/wiring_pulse.c
+uint32_t SensorDHT::expectPulse(bool level) {
+    uint32_t count = 0;
+    // On AVR platforms use direct GPIO port access as it's much faster and better
+    // for catching pulses that are 10's of microseconds in length:
+    #ifdef __AVR
+    uint8_t portState = level ? _bit : 0;
+    while ((*portInputRegister(_port) & _bit) == portState) {
+        if (count++ >= _maxcycles) {
+            return 0; // Exceeded timeout, fail.
+        }
+    }
+    // Otherwise fall back to using digitalRead (this seems to be necessary on ESP8266
+    // right now, perhaps bugs in direct port access functions?).
+    #else
+    while (digitalRead(_pin) == level) {
+        if (count++ >= _maxcycles) {
+            return 0; // Exceeded timeout, fail.
+        }
+    }
+    #endif
+
+    return count;
+}
+
+
+void SensorDHT::read(TemperatureData& retData)
+{
+    // Reset 40 bits of received data to zero.
+    static uint8_t data[5];
+    data[0] = data[1] = data[2] = data[3] = data[4] = 0;
+
+    // Send start signal.  See DHT datasheet for full signal diagram:
+    //   http://www.adafruit.com/datasheets/Digital%20humidity%20and%20temperature%20sensor%20AM2302.pdf
+
+    // Go into high impedence state to let pull-up raise data line level and
+    // start the reading process.
+    digitalWrite(_pin, HIGH);
+    delay(250);
+
+    // First set data line low for 20 milliseconds.
+    pinMode(_pin, OUTPUT);
+    digitalWrite(_pin, LOW);
+    delay(20);
+
+    uint32_t cycles[80];
+    {
+        // Turn off interrupts temporarily because the next sections are timing critical
+        // and we don't want any interruptions.
+        noInterrupts();
+
+        // End the start signal by setting data line high for 40 microseconds.
+        digitalWrite(_pin, HIGH);
+        delayMicroseconds(40);
+
+        // Now start reading the data line to get the value from the DHT sensor.
+        pinMode(_pin, INPUT_PULLUP);
+        delayMicroseconds(10);  // Delay a bit to let sensor pull data line low.
+
+        // First expect a low signal for ~80 microseconds followed by a high signal
+        // for ~80 microseconds again.
+        if (expectPulse(LOW) == 0) {
+            DEBUG("DHT:Timeout waiting for start signal low pulse.");
+            interrupts();
+            return;
+        }
+        if (expectPulse(HIGH) == 0) {
+            DEBUG("DHT:Timeout waiting for start signal high pulse.");
+            interrupts();
+            return;
+        }
+
+        // Now read the 40 bits sent by the sensor.  Each bit is sent as a 50
+        // microsecond low pulse followed by a variable length high pulse.  If the
+        // high pulse is ~28 microseconds then it's a 0 and if it's ~70 microseconds
+        // then it's a 1.  We measure the cycle count of the initial 50us low pulse
+        // and use that to compare to the cycle count of the high pulse to determine
+        // if the bit is a 0 (high state cycle count < low state cycle count), or a
+        // 1 (high state cycle count > low state cycle count). Note that for speed all
+        // the pulses are read into a array and then examined in a later step.
+        for (int i=0; i<80; i+=2) {
+            cycles[i]   = expectPulse(LOW);
+            cycles[i+1] = expectPulse(HIGH);
+        }
+
+        interrupts();
+    } // Timing critical code is now complete.
+
+    // Inspect pulses and determine which ones are 0 (high state cycle count < low
+    // state cycle count), or 1 (high state cycle count > low state cycle count).
+    for (int i=0; i<40; ++i) {
+        uint32_t lowCycles  = cycles[2*i];
+        uint32_t highCycles = cycles[2*i+1];
+        if ((lowCycles == 0) || (highCycles == 0)) {
+            DEBUG("DHT:Timeout waiting for pulse.");
+            return;
+        }
+        data[i/8] <<= 1;
+        // Now compare the low and high cycle times to see if the bit is a 0 or 1.
+        if (highCycles > lowCycles) {
+            // High cycles are greater than 50us low cycle count, must be a 1.
+            data[i/8] |= 1;
+        }
+        // Else high cycles are less than (or equal to, a weird case) the 50us low
+        // cycle count so this must be a zero.  Nothing needs to be changed in the
+        // stored data.
+    }
+
+
+    // Check we read 40 bits and that the checksum matches.
+    if (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {
+        switch (_type) {
+        case DHT11:
+          retData.temperature = data[2];
+          retData.humidity = data[0];
+          break;
+        case DHT22:
+        case DHT21:
+            retData.temperature = data[2] & 0x7F;
+            retData.temperature *= 256;
+            retData.temperature += data[3];
+            retData.temperature *= 0.1;
+            if (data[2] & 0x80) {
+                retData.temperature *= -1;
+            }
+            retData.humidity = data[0];
+            retData.humidity *= 256;
+            retData.humidity += data[1];
+            retData.humidity *= 0.1;
+            break;
+        }
+    }
+    else {
+        DEBUG("DHT:Checksum failure!");
+    }
+}
--- a/arduino/HalMultiSensor/SensorDHT.h
+++ b/arduino/HalMultiSensor/SensorDHT.h
@ -0,0 +1,33 @@
+#ifndef SensorDHT_h
+#define SensorDHT_h
+
+#include <Arduino.h>
+#include "HalInterfaces.h"
+
+
+// Define types of sensors.
+#define DHT11 11
+#define DHT22 22
+#define DHT21 21
+
+
+class SensorDHT : public SensorTemperature
+{
+public:
+    SensorDHT(uint8_t  type, uint8_t pin) : _type(type), _pin(pin) {};
+
+    virtual void setup();
+    virtual void read(TemperatureData& data);
+
+private:
+    uint8_t _type, _pin;
+    uint32_t _maxcycles;
+    #ifdef __AVR
+        // Use direct GPIO access on an 8-bit AVR so keep track of the port and bitmask
+        // for the digital pin connected to the DHT.  Other platforms will use digitalRead.
+        uint8_t _bit, _port;
+    #endif
+
+    uint32_t expectPulse(bool level);
+};
+#endif
--- a/arduino/HalMultiSensor/SensorPhotocell.cpp
+++ b/arduino/HalMultiSensor/SensorPhotocell.cpp
@ -0,0 +1,25 @@
+#include "SensorPhotocell.h"
+#include <Arduino.h>
+
+unsigned int SensorPhotocell::pulse = 0;
+
+void SensorPhotocell::interruptHandler()
+{
+    digitalWrite(INDICATOR_PIN, HIGH);
+    DEBUG("PHCELL: INTERRUPT");
+    ++pulse;
+    digitalWrite(INDICATOR_PIN, LOW);
+}
+
+
+void SensorPhotocell::setup()
+{
+    Interrupt::setPinCallback(SensorPhotocell::interruptHandler);
+    Interrupt::setupPinInterrupt(PC2); //PC3
+}
+
+void SensorPhotocell::read(PowerData& data)
+{
+    data.consumption = pulse;
+    pulse = 0;
+}
--- a/arduino/HalMultiSensor/SensorPhotocell.h
+++ b/arduino/HalMultiSensor/SensorPhotocell.h
@ -0,0 +1,20 @@
+#ifndef SensorPhotocell_H
+#define SensorPhotocell_H
+
+#include "HalInterfaces.h"
+#include "Interrupt.h"
+
+
+class SensorPhotocell : public SensorPowerConsumption
+{
+public:
+    virtual void setup();
+    virtual void read(PowerData& data);
+
+private:
+    static unsigned int pulse;
+
+    static void interruptHandler();
+};
+
+#endif // SensorPhotocell_H
--- a/arduino/NexaTellstick/NexaTellstick.ino
+++ b/arduino/NexaTellstick/NexaTellstick.ino
@ -0,0 +1,155 @@
+#include "NexaSelfLearningReceiver.h"
+
+#define TX_PIN          10
+#define RX_PIN          4
+#define RX_LED          13
+
+//Radio RX
+NexaSelfLearningReceiver receiver = NexaSelfLearningReceiver(RX_PIN, RX_LED);
+short dim = 0;
+uint64_t receivedSignal = 0;
+
+//Serial RX
+byte rxBuffer[79];
+
+void setup(){
+    Serial.begin(9600);
+};
+
+void loop(){
+  
+    //Receive and execute command over serial
+    if(Serial.available() > 0){
+        uint8_t rxDataSize = Serial.readBytesUntil('+', &rxBuffer[0], 79);
+        if(rxDataSize > 0){
+          if(parseRxBuffer(&rxBuffer[0], 0, rxDataSize, false, 3, 0)){
+            //Serial.println(F("DEBUG:PARSE OK"));
+          }else{
+            //Serial.println(F("DEBUG:PARSE ERROR"));            
+          }
+        }
+    }
+    
+    //Receive signal over air and send it over serial
+    receivedSignal = receiver.receiveSignal(NULL, NULL, NULL, NULL, &dim, 100);
+    if(receivedSignal > 0){
+        Serial.print(F("+Wclass:command;protocol:arctech;model:selflearning;data:0x"));
+        uint8_t hexToSend = (dim == NULL ? 8 : 9);
+        for(int8_t i = hexToSend-1; i >= 0; --i){
+            Serial.print( (byte)((receivedSignal>>(4*i))&0x0F), HEX);
+        }
+        Serial.println(F(";"));
+    }
+    
+};
+
+bool parseRxBuffer(byte* buffer, uint8_t startIndex, uint8_t endIndex, bool debug, uint8_t repeat, uint8_t pause){
+    if(startIndex > endIndex){
+        return false;
+    }
+    char c = buffer[startIndex];
+    //Serial.print("DEBUG: char:"); Serial.println(c, DEC);
+    switch(c){
+        case 'S':
+            return handleS(buffer, startIndex+1, endIndex, debug, repeat, pause);
+        case 'T':
+            return handleT(buffer, startIndex+1, endIndex, debug, repeat, pause);
+        case 'V':
+            Serial.println(F("+V2"));
+            return parseRxBuffer(buffer, startIndex+1, endIndex, debug, repeat, pause);
+        case 'D':
+            return parseRxBuffer(buffer, startIndex+1, endIndex, !debug, repeat, pause);
+        case 'P':
+            if(endIndex-startIndex+1 < 3){return false;} //at least {'P',[p-value],'+'} must be left in the buffer
+            return parseRxBuffer(buffer, startIndex+2, endIndex, debug, repeat, buffer[startIndex+1]);
+        case 'R':
+            if(endIndex-startIndex+1 < 3){return false;} //at least {'R',[r-value],'+'} must be left in the buffer
+            return parseRxBuffer(buffer, startIndex+2, endIndex, debug, buffer[startIndex+1], pause);
+        case '+':
+            return true;
+        default:
+            //Serial.print("DEBUG: unknown char: '"); Serial.print(c, BIN); Serial.println("'");
+            return false;
+    }
+};
+
+bool handleS(byte* buffer, uint8_t startIndex, uint8_t endIndex, bool debug, uint8_t repeat, uint8_t pause){
+    //Parse message received from serial
+    uint8_t S_data[78]; //78 pulses
+    uint8_t pulseCount = 0;
+    for(uint8_t i = startIndex; i <= endIndex; ++i){
+        if(buffer[i] == '+'){
+            break;
+        }else if(i == endIndex){
+            return false;
+        }else{
+            S_data[pulseCount++] = buffer[i];
+        }
+    }
+    //Send message
+    for(uint8_t rep = 0; rep < repeat; ++rep){
+        bool nextPinState = HIGH;
+        for(int i = 0; i < pulseCount; ++i){
+            if(S_data[i] > 0 || i == pulseCount-1){
+                digitalWrite(TX_PIN, nextPinState);
+                delayMicroseconds(S_data[i]*10);
+            }
+            nextPinState = !nextPinState;
+        }
+        delay(pause);
+    }
+    //send confirmation over serial
+    Serial.println(F("+S"));
+    return true;
+};
+
+bool handleT(byte* buffer, uint8_t startIndex, uint8_t endIndex, bool debug, uint8_t repeat, uint8_t pause){
+    //Parse message received from serial
+    uint8_t T_data[72]; //0-188 pulses
+    if(endIndex - startIndex < 5){
+        //Serial.println("DEBUG: wrong size!");
+        return false;
+    }
+    uint8_t buff_p = startIndex;
+    uint8_t T_times[4] = {buffer[buff_p++], buffer[buff_p++], buffer[buff_p++], buffer[buff_p++]};
+    uint8_t T_long = buffer[buff_p++];
+    uint8_t T_bytes = 0;
+    if( (T_long/4.0) > (float)(T_long/4) ){
+        T_bytes = T_long/4 + 1;
+    }else{
+        T_bytes = T_long/4;
+    }
+    uint8_t j = 0;
+    while(j < T_bytes){
+        if(buffer[buff_p] == '+'){
+            break;
+        }else if(buff_p >= endIndex){
+            return false;
+        }else{
+            T_data[j++] = buffer[buff_p++];
+        }
+    }
+    if( j != T_bytes ){
+        return false;
+    }
+    //Send message
+    for(uint8_t rep = 0; rep < repeat; ++rep){
+        bool nextPinState = HIGH;
+        for(int i = 0; i < T_long; ++i){
+            uint8_t timeIndex = (T_data[i/4]>>(6-(2*(i%4))))&0x03;
+            if(T_times[timeIndex] > 0 || i == T_long-1){
+                digitalWrite(TX_PIN, nextPinState);
+                delayMicroseconds(10*T_times[timeIndex]);
+            }
+            nextPinState = !nextPinState;
+        }
+        digitalWrite(TX_PIN, LOW);
+        if(rep < repeat-1){
+            delay(pause);
+        }
+    }
+    //send confirmation over serial
+    Serial.println(F("+T"));
+    return parseRxBuffer(buffer, buff_p, endIndex, debug, repeat, pause);
+};
+
--- a/arduino/lib/NexaControl
+++ b/arduino/lib/NexaControl
@ -0,0 +1 @@
+Subproject commit 5fd5429375b3fffbf0bdd041d493d5c6ff0c156a
--- a/build.gradle
+++ b/build.gradle
@ -0,0 +1,126 @@
+plugins {
+    id 'java'
+    id 'application'
+}
+
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2025 Ziver Koc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// ------------------------------------
+// Hal common configuration
+// ------------------------------------
+
+allprojects {
+    repositories {
+        mavenLocal()
+        mavenCentral()
+    }
+}
+
+subprojects { 
+    apply plugin: 'java-library'
+
+    dependencies {
+        //implementation 'se.koc:zutil:1.0.314'
+        implementation 'se.koc:zutil:1.0.0-SNAPSHOT'
+
+        testImplementation 'junit:junit:4.12'
+        testImplementation 'org.hamcrest:hamcrest-core:2.2'
+    }
+
+    sourceSets {
+        main {
+            java {
+                srcDirs 'src'
+            }
+            // We do not want the resource folder to be included in the jar file
+            //resources {
+            //    srcDir 'resource'
+            //}
+        }
+        test {
+            java {
+                srcDirs 'test'
+            }
+        }
+    }
+
+    tasks.withType(JavaCompile) {
+        options.compilerArgs << "-Xlint:deprecation"
+        //options.compilerArgs << "-Xlint:unchecked"
+    }
+}
+
+// ------------------------------------
+// Hal general configuration
+// ------------------------------------
+
+dependencies {
+    project.subprojects.each { subProject ->
+        runtimeOnly subProject
+    }
+}
+
+distributions {
+    main {
+        contents {
+            // from root project
+            from 'hal.conf.example'
+            from 'logging.properties'
+            from 'run.sh'
+
+            // from subprojects
+            project.subprojects.each { subProject ->
+                into('bin') {
+                    from "${subProject.projectDir}/resources/bin"
+                }
+                into('web') {
+                    from "${subProject.projectDir}/resources/web"
+                }
+                into('resources') {
+                    from ("${subProject.projectDir}/resources") {
+                        exclude 'bin'
+                        exclude 'web'
+                    }
+                }
+            }
+        }
+    }
+}
+
+distTar.enabled = false
+distZip.enabled = false
+assemble.dependsOn(installDist)
+
+project.gradle.startParameter.taskNames.each { taskName ->
+    if (taskName == 'distZip') {
+        distZip.enabled = true
+    }
+}
+
+application {
+    mainClass = 'se.hal.HalServer'
+}
+
+startScripts.enabled = false
--- a/build.xml
+++ b/build.xml
@ -1,91 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="Zutil" >
-	
-	<!-- ________________________ PROPERTIES AND SETTINGS ________________________ -->
-	
-	<!--common properties-->
-	<property name="gitRoot" value="." />
-	<property name="srcDir" value="${gitRoot}/src" />
-	<property name="testDir" value="${gitRoot}/test" />
-	<property name="libDir" value="${gitRoot}/lib" />
-    <property name="buildRoot" value="${gitRoot}/build" />
-	<property name="buildDir" value="${buildRoot}/production" />
-    <property name="buildTestDir" value="${buildRoot}/test" />
-    <property name="releaseDir" value="${buildRoot}/release" />
-    <property name="reportsDir" value="${buildRoot}/reports" />
-
-	<!--define standard arduments for javac-->
-	<presetdef name="javac">
-		<javac includeantruntime="false" />
-	</presetdef>
-
-	<!-- ________________________ CLASSPATHS ________________________ -->
-	
-	<!--classpath included when building-->
-	<path id="classpath.build">
-        <fileset dir="${libDir}">
-            <include name="**/*.jar"/>
-        </fileset>
-        <pathelement location="${buildDir}" />
-	</path>
-
-    <path id="classpath.test">
-        <pathelement location="${buildTestDir}" />
-        <!--include libraries used for building-->
-        <path refid="classpath.build"/>
-    </path>
-	
-	<!-- ________________________ EXECUTION TARGETS ________________________ -->
-
-    <target name="test" depends="build-test">
-        <mkdir dir="${reportsDir}" />
-        <junit printsummary="yes" haltonfailure="false" fork="true">
-            <classpath refid="classpath.test" />
-            <formatter type="plain" usefile="false" /> <!-- to screen -->
-            <formatter type="xml" /> <!-- to file -->
-
-            <batchtest todir="${reportsDir}" skipNonTests="true">
-                <fileset dir="${buildTestDir}" includes="**/*Test*.class" />
-            </batchtest>
-        </junit>
-    </target>
-
-    <!-- ________________________ BUILD TARGETS ________________________ -->
-
-	<!--clean all build paths-->
-	<target name="clean">
-		<delete includeemptydirs="true" failonerror="false">
-			<fileset dir="${buildRoot}" includes="**/*"/>
-		</delete>
-	</target>
-
-	<!--build product code-->
-    <target name="release" depends="build">
-        <jar destfile="${releaseDir}/Zutil.jar" basedir="${buildDir}" />
-    </target>
-
-	<target name="build">
-		<mkdir dir="${buildDir}" />
-		<javac srcdir="${srcDir}" destdir="${buildDir}" debug="yes" debugLevel="lines,vars,source">
-            <classpath refid="classpath.build" />
-			<include name="**/*.java" />
-		</javac>
-        <copy todir="${buildDir}">
-            <fileset dir="${srcDir}"
-                     excludes="**/*.java" />
-        </copy>
-	</target>
-
-    <target name="build-test" depends="build">
-        <mkdir dir="${buildTestDir}" />
-        <javac srcdir="${testDir}" destdir="${buildTestDir}" debug="yes" debugLevel="lines,vars,source">
-            <classpath refid="classpath.test" />
-            <include name="**/*.java" />
-        </javac>
-        <copy todir="${buildTestDir}">
-            <fileset dir="${testDir}"
-                     excludes="**/*.java" />
-        </copy>
-    </target>
-		
-</project>
--- a/external/Z-Stick_Gen5_Drivers.zip
+++ b/external/Z-Stick_Gen5_Drivers.zip
--- a/external/tellstick-core/AUTHORS.txt
+++ b/external/tellstick-core/AUTHORS.txt
@ -0,0 +1,7 @@
+telldus-core has been developed by :
+ 
+	Micke Prag <micke.prag@telldus.se>
+	Fredrik Jacobsson <fredrik.jacobsson@telldus.se>
+	Stefan Persson <stefan.persson@telldus.se>
+
+The package is maintained by Micke Prag <micke.prag@telldus.se>
--- a/external/tellstick-core/LICENSE.txt
+++ b/external/tellstick-core/LICENSE.txt
@ -0,0 +1,502 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
--- a/external/tellstick-core/Protocol.cpp
+++ b/external/tellstick-core/Protocol.cpp
@ -0,0 +1,267 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/Protocol.h"
+#include <list>
+#include <sstream>
+#include <string>
+
+#include "client/telldus-core.h"
+#include "service/ControllerMessage.h"
+#include "service/ProtocolBrateck.h"
+#include "service/ProtocolComen.h"
+#include "service/ProtocolEverflourish.h"
+#include "service/ProtocolFineoffset.h"
+#include "service/ProtocolFuhaote.h"
+#include "service/ProtocolGroup.h"
+#include "service/ProtocolHasta.h"
+#include "service/ProtocolIkea.h"
+#include "service/ProtocolMandolyn.h"
+#include "service/ProtocolNexa.h"
+#include "service/ProtocolOregon.h"
+#include "service/ProtocolRisingSun.h"
+#include "service/ProtocolSartano.h"
+#include "service/ProtocolScene.h"
+#include "service/ProtocolSilvanChip.h"
+#include "service/ProtocolUpm.h"
+#include "service/ProtocolWaveman.h"
+#include "service/ProtocolX10.h"
+#include "service/ProtocolYidong.h"
+#include "common/Strings.h"
+
+class Protocol::PrivateData {
+public:
+	ParameterMap parameterList;
+	std::wstring model;
+};
+
+Protocol::Protocol() {
+	d = new PrivateData;
+}
+
+Protocol::~Protocol(void) {
+	delete d;
+}
+
+std::wstring Protocol::model() const {
+	std::wstring strModel = d->model;
+	// Strip anything after : if it is found
+	size_t pos = strModel.find(L":");
+	if (pos != std::wstring::npos) {
+		strModel = strModel.substr(0, pos);
+	}
+
+	return strModel;
+}
+
+void Protocol::setModel(const std::wstring &model) {
+	d->model = model;
+}
+
+void Protocol::setParameters(const ParameterMap &parameterList) {
+	d->parameterList = parameterList;
+}
+
+std::wstring Protocol::getStringParameter(const std::wstring &name, const std::wstring &defaultValue) const {
+	ParameterMap::const_iterator it = d->parameterList.find(name);
+	if (it == d->parameterList.end()) {
+		return defaultValue;
+	}
+	return it->second;
+}
+
+int Protocol::getIntParameter(const std::wstring &name, int min, int max) const {
+	std::wstring value = getStringParameter(name, L"");
+	if (value == L"") {
+		return min;
+	}
+	std::wstringstream st;
+	st << value;
+	int intValue = 0;
+	st >> intValue;
+	if (intValue < min) {
+		return min;
+	}
+	if (intValue > max) {
+		return max;
+	}
+	return intValue;
+}
+
+bool Protocol::checkBit(int data, int bitno) {
+	return ((data >> bitno)&0x01);
+}
+
+
+Protocol *Protocol::getProtocolInstance(const std::wstring &protocolname) {
+	if (TelldusCore::comparei(protocolname, L"arctech")) {
+		return new ProtocolNexa();
+
+	} else if (TelldusCore::comparei(protocolname, L"brateck")) {
+		return new ProtocolBrateck();
+
+	} else if (TelldusCore::comparei(protocolname, L"comen")) {
+		return new ProtocolComen();
+
+	} else if (TelldusCore::comparei(protocolname, L"everflourish")) {
+		return new ProtocolEverflourish();
+
+	} else if (TelldusCore::comparei(protocolname, L"fuhaote")) {
+		return new ProtocolFuhaote();
+
+	} else if (TelldusCore::comparei(protocolname, L"hasta")) {
+		return new ProtocolHasta();
+
+	} else if (TelldusCore::comparei(protocolname, L"ikea")) {
+		return new ProtocolIkea();
+
+	} else if (TelldusCore::comparei(protocolname, L"risingsun")) {
+		return new ProtocolRisingSun();
+
+	} else if (TelldusCore::comparei(protocolname, L"sartano")) {
+		return new ProtocolSartano();
+
+	} else if (TelldusCore::comparei(protocolname, L"silvanchip")) {
+		return new ProtocolSilvanChip();
+
+	} else if (TelldusCore::comparei(protocolname, L"upm")) {
+		return new ProtocolUpm();
+
+	} else if (TelldusCore::comparei(protocolname, L"waveman")) {
+		return new ProtocolWaveman();
+
+	} else if (TelldusCore::comparei(protocolname, L"x10")) {
+		return new ProtocolX10();
+
+	} else if (TelldusCore::comparei(protocolname, L"yidong")) {
+		return new ProtocolYidong();
+
+	} else if (TelldusCore::comparei(protocolname, L"group")) {
+		return new ProtocolGroup();
+
+	} else if (TelldusCore::comparei(protocolname, L"scene")) {
+		return new ProtocolScene();
+	}
+
+	return 0;
+}
+
+std::list<std::string> Protocol::getParametersForProtocol(const std::wstring &protocolName) {
+	std::list<std::string> parameters;
+	if (TelldusCore::comparei(protocolName, L"arctech")) {
+		parameters.push_back("house");
+		parameters.push_back("unit");
+
+	} else if (TelldusCore::comparei(protocolName, L"brateck")) {
+		parameters.push_back("house");
+
+	} else if (TelldusCore::comparei(protocolName, L"comen")) {
+		parameters.push_back("house");
+		parameters.push_back("unit");
+
+	} else if (TelldusCore::comparei(protocolName, L"everflourish")) {
+		parameters.push_back("house");
+		parameters.push_back("unit");
+
+	} else if (TelldusCore::comparei(protocolName, L"fuhaote")) {
+		parameters.push_back("code");
+
+	} else if (TelldusCore::comparei(protocolName, L"hasta")) {
+		parameters.push_back("house");
+		parameters.push_back("unit");
+
+	} else if (TelldusCore::comparei(protocolName, L"ikea")) {
+		parameters.push_back("system");
+		parameters.push_back("units");
+		// parameters.push_back("fade");
+
+	} else if (TelldusCore::comparei(protocolName, L"risingsun")) {
+		parameters.push_back("house");
+		parameters.push_back("unit");
+
+	} else if (TelldusCore::comparei(protocolName, L"sartano")) {
+		parameters.push_back("code");
+
+	} else if (TelldusCore::comparei(protocolName, L"silvanchip")) {
+		parameters.push_back("house");
+
+	} else if (TelldusCore::comparei(protocolName, L"upm")) {
+		parameters.push_back("house");
+		parameters.push_back("unit");
+
+	} else if (TelldusCore::comparei(protocolName, L"waveman")) {
+		parameters.push_back("house");
+		parameters.push_back("unit");
+
+	} else if (TelldusCore::comparei(protocolName, L"x10")) {
+		parameters.push_back("house");
+		parameters.push_back("unit");
+
+	} else if (TelldusCore::comparei(protocolName, L"yidong")) {
+		parameters.push_back("unit");
+
+	} else if (TelldusCore::comparei(protocolName, L"group")) {
+		parameters.push_back("devices");
+
+	} else if (TelldusCore::comparei(protocolName, L"scene")) {
+		parameters.push_back("devices");
+	}
+
+	return parameters;
+}
+
+std::list<std::string> Protocol::decodeData(const std::string &fullData) {
+	std::list<std::string> retval;
+	std::string decoded = "";
+
+	ControllerMessage dataMsg(fullData);
+	if ( TelldusCore::comparei(dataMsg.protocol(), L"arctech") ) {
+		decoded = ProtocolNexa::decodeData(dataMsg);
+		if (decoded != "") {
+			retval.push_back(decoded);
+		}
+		decoded = ProtocolWaveman::decodeData(dataMsg);
+		if (decoded != "") {
+			retval.push_back(decoded);
+		}
+		decoded = ProtocolSartano::decodeData(dataMsg);
+		if (decoded != "") {
+			retval.push_back(decoded);
+		}
+	} else if (TelldusCore::comparei(dataMsg.protocol(), L"everflourish") ) {
+		decoded = ProtocolEverflourish::decodeData(dataMsg);
+		if (decoded != "") {
+			retval.push_back(decoded);
+		}
+	} else if (TelldusCore::comparei(dataMsg.protocol(), L"fineoffset") ) {
+		decoded = ProtocolFineoffset::decodeData(dataMsg);
+		if (decoded != "") {
+			retval.push_back(decoded);
+		}
+	} else if (TelldusCore::comparei(dataMsg.protocol(), L"mandolyn") ) {
+		decoded = ProtocolMandolyn::decodeData(dataMsg);
+		if (decoded != "") {
+			retval.push_back(decoded);
+		}
+	} else if (TelldusCore::comparei(dataMsg.protocol(), L"oregon") ) {
+		decoded = ProtocolOregon::decodeData(dataMsg);
+		if (decoded != "") {
+			retval.push_back(decoded);
+		}
+	} else if (TelldusCore::comparei(dataMsg.protocol(), L"x10") ) {
+		decoded = ProtocolX10::decodeData(dataMsg);
+		if (decoded != "") {
+			retval.push_back(decoded);
+		}
+	} else if (TelldusCore::comparei(dataMsg.protocol(), L"hasta") ) {
+		decoded = ProtocolHasta::decodeData(dataMsg);
+		if (decoded != "") {
+			retval.push_back(decoded);
+		}
+	}
+
+	return retval;
+}
--- a/external/tellstick-core/Protocol.h
+++ b/external/tellstick-core/Protocol.h
@ -0,0 +1,46 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOL_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOL_H_
+
+#include <string>
+#include <list>
+#include <map>
+#include "client/telldus-core.h"
+
+typedef std::map<std::wstring, std::wstring> ParameterMap;
+
+class Controller;
+
+class Protocol {
+public:
+	Protocol();
+	virtual ~Protocol(void);
+
+	static Protocol *getProtocolInstance(const std::wstring &protocolname);
+	static std::list<std::string> getParametersForProtocol(const std::wstring &protocolName);
+	static std::list<std::string> decodeData(const std::string &fullData);
+
+	virtual int methods() const = 0;
+	std::wstring model() const;
+	void setModel(const std::wstring &model);
+	void setParameters(const ParameterMap &parameterList);
+
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller) = 0;
+
+protected:
+	virtual std::wstring getStringParameter(const std::wstring &name, const std::wstring &defaultValue = L"") const;
+	virtual int getIntParameter(const std::wstring &name, int min, int max) const;
+
+	static bool checkBit(int data, int bit);
+
+private:
+	class PrivateData;
+	PrivateData *d;
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOL_H_
--- a/external/tellstick-core/ProtocolBrateck.cpp
+++ b/external/tellstick-core/ProtocolBrateck.cpp
@ -0,0 +1,53 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolBrateck.h"
+#include <string>
+
+int ProtocolBrateck::methods() const {
+	return TELLSTICK_UP | TELLSTICK_DOWN | TELLSTICK_STOP;
+}
+
+std::string ProtocolBrateck::getStringForMethod(int method, unsigned char, Controller *) {
+	const char S = '!';
+	const char L = 'V';
+	const char B1[] = {L, S, L, S, 0};
+	const char BX[] = {S, L, L, S, 0};
+	const char B0[] = {S, L, S, L, 0};
+	const char BUP[]   = {L, S, L, S, S, L, S, L, S, L, S, L, S, L, S, L, S, 0};
+	const char BSTOP[] = {S, L, S, L, L, S, L, S, S, L, S, L, S, L, S, L, S, 0};
+	const char BDOWN[] = {S, L, S, L, S, L, S, L, S, L, S, L, L, S, L, S, S, 0};
+
+	std::string strReturn;
+	std::wstring strHouse = this->getStringParameter(L"house", L"");
+	if (strHouse == L"") {
+		return "";
+	}
+
+	for( size_t i = 0; i < strHouse.length(); ++i ) {
+		if (strHouse[i] == '1') {
+			strReturn.insert(0, B1);
+		} else if (strHouse[i] == '-') {
+			strReturn.insert(0, BX);
+		} else if (strHouse[i] == '0') {
+			strReturn.insert(0, B0);
+		}
+	}
+
+	strReturn.insert(0, "S");
+	if (method == TELLSTICK_UP) {
+		strReturn.append(BUP);
+	} else if (method == TELLSTICK_DOWN) {
+		strReturn.append(BDOWN);
+	} else if (method == TELLSTICK_STOP) {
+		strReturn.append(BSTOP);
+	} else {
+		return "";
+	}
+	strReturn.append("+");
+
+	return strReturn;
+}
--- a/external/tellstick-core/ProtocolBrateck.h
+++ b/external/tellstick-core/ProtocolBrateck.h
@ -0,0 +1,19 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLBRATECK_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLBRATECK_H_
+
+#include <string>
+#include "service/Protocol.h"
+
+class ProtocolBrateck : public Protocol {
+public:
+	int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLBRATECK_H_
--- a/external/tellstick-core/ProtocolComen.cpp
+++ b/external/tellstick-core/ProtocolComen.cpp
@ -0,0 +1,23 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolComen.h"
+#include <string>
+
+int ProtocolComen::methods() const {
+	return (TELLSTICK_TURNON | TELLSTICK_TURNOFF | TELLSTICK_LEARN);
+}
+
+int ProtocolComen::getIntParameter(const std::wstring &name, int min, int max) const {
+	if (name.compare(L"house") == 0) {
+		int intHouse = Protocol::getIntParameter(L"house", 1, 16777215);
+		// The last two bits must be hardcoded
+		intHouse <<= 2;
+		intHouse += 2;
+		return intHouse;
+	}
+	return Protocol::getIntParameter(name, min, max);
+}
--- a/external/tellstick-core/ProtocolComen.h
+++ b/external/tellstick-core/ProtocolComen.h
@ -0,0 +1,21 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLCOMEN_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLCOMEN_H_
+
+#include <string>
+#include "service/ProtocolNexa.h"
+
+class ProtocolComen : public ProtocolNexa {
+public:
+	virtual int methods() const;
+
+protected:
+	virtual int getIntParameter(const std::wstring &name, int min, int max) const;
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLCOMEN_H_
--- a/external/tellstick-core/ProtocolEverflourish.cpp
+++ b/external/tellstick-core/ProtocolEverflourish.cpp
@ -0,0 +1,133 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolEverflourish.h"
+#include <stdio.h>
+#include <sstream>
+#include <string>
+#include "service/ControllerMessage.h"
+
+int ProtocolEverflourish::methods() const {
+	return TELLSTICK_TURNON | TELLSTICK_TURNOFF | TELLSTICK_LEARN;
+}
+
+std::string ProtocolEverflourish::getStringForMethod(int method, unsigned char, Controller *) {
+	unsigned int deviceCode = this->getIntParameter(L"house", 0, 16383);
+	unsigned int intCode = this->getIntParameter(L"unit", 1, 4)-1;
+	unsigned char action;
+
+	if (method == TELLSTICK_TURNON) {
+		action = 15;
+	} else if (method == TELLSTICK_TURNOFF) {
+		action = 0;
+	} else if (method == TELLSTICK_LEARN) {
+		action = 10;
+	} else {
+		return "";
+	}
+
+	const char ssss = 85;
+	const char sssl = 84;  // 0
+	const char slss = 69;  // 1
+
+	const char bits[2] = {sssl, slss};
+	int i, check;
+
+	std::string strCode;
+
+	deviceCode = (deviceCode << 2) | intCode;
+
+	check = calculateChecksum(deviceCode);
+
+	char preamble[] = {'R', 5, 'T', 114, 60, 1, 1, 105, ssss, ssss, 0};
+	strCode.append(preamble);
+
+	for(i = 15; i >= 0; i--) {
+		strCode.append(1, bits[(deviceCode >> i)&0x01]);
+	}
+	for(i = 3; i >= 0; i--) {
+		strCode.append(1, bits[(check >> i)&0x01]);
+	}
+	for(i = 3; i >= 0; i--) {
+		strCode.append(1, bits[(action >> i)&0x01]);
+	}
+
+	strCode.append(1, ssss);
+	strCode.append(1, '+');
+
+	return strCode;
+}
+
+// The calculation used in this function is provided by Frank Stevenson
+unsigned int ProtocolEverflourish::calculateChecksum(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;
+}
+
+std::string ProtocolEverflourish::decodeData(const ControllerMessage &dataMsg) {
+	uint64_t allData;
+	unsigned int house = 0;
+	unsigned int unit = 0;
+	unsigned int method = 0;
+
+	allData = dataMsg.getInt64Parameter("data");
+
+	house = allData & 0xFFFC00;
+	house >>= 10;
+
+	unit = allData & 0x300;
+	unit >>= 8;
+	unit++;  // unit from 1 to 4
+
+	method = allData & 0xF;
+
+	if(house > 16383 || unit < 1 || unit > 4) {
+		// not everflourish
+		return "";
+	}
+
+	std::stringstream retString;
+	retString << "class:command;protocol:everflourish;model:selflearning;house:" << house << ";unit:" << unit << ";method:";
+	if(method == 0) {
+		retString << "turnoff;";
+	} else if(method == 15) {
+		retString << "turnon;";
+	} else if(method == 10) {
+		retString << "learn;";
+	} else {
+		// not everflourish
+		return "";
+	}
+
+	return retString.str();
+}
--- a/external/tellstick-core/ProtocolEverflourish.h
+++ b/external/tellstick-core/ProtocolEverflourish.h
@ -0,0 +1,24 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLEVERFLOURISH_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLEVERFLOURISH_H_
+
+#include <string>
+#include "service/Protocol.h"
+#include "service/ControllerMessage.h"
+
+class ProtocolEverflourish :  public Protocol {
+public:
+	int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+	static std::string decodeData(const ControllerMessage &dataMsg);
+
+private:
+	static unsigned int calculateChecksum(unsigned int x);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLEVERFLOURISH_H_
--- a/external/tellstick-core/ProtocolFineoffset.cpp
+++ b/external/tellstick-core/ProtocolFineoffset.cpp
@ -0,0 +1,52 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolFineoffset.h"
+#include <stdlib.h>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include "common/Strings.h"
+
+std::string ProtocolFineoffset::decodeData(const ControllerMessage &dataMsg) {
+	std::string data = dataMsg.getParameter("data");
+	if (data.length() < 8) {
+		return "";
+	}
+
+	// Checksum currently not used
+	// uint8_t checksum = (uint8_t)TelldusCore::hexTo64l(data.substr(data.length()-2));
+	data = data.substr(0, data.length()-2);
+
+	uint8_t humidity = (uint8_t)TelldusCore::hexTo64l(data.substr(data.length()-2));
+	data = data.substr(0, data.length()-2);
+
+	uint16_t value = (uint16_t)TelldusCore::hexTo64l(data.substr(data.length()-3));
+	double temperature = (value & 0x7FF)/10.0;
+
+	value >>= 11;
+	if (value & 1) {
+		temperature = -temperature;
+	}
+	data = data.substr(0, data.length()-3);
+
+	uint16_t id = (uint16_t)TelldusCore::hexTo64l(data) & 0xFF;
+
+	std::stringstream retString;
+	retString << "class:sensor;protocol:fineoffset;id:" << id << ";model:";
+
+	if (humidity <= 100) {
+		retString << "temperaturehumidity;humidity:" << static_cast<int>(humidity) << ";";
+	} else if (humidity == 0xFF) {
+		retString << "temperature;";
+	} else {
+		return "";
+	}
+
+	retString << "temp:" << std::fixed << std::setprecision(1) << temperature << ";";
+
+	return retString.str();
+}
--- a/external/tellstick-core/ProtocolFineoffset.h
+++ b/external/tellstick-core/ProtocolFineoffset.h
@ -0,0 +1,19 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLFINEOFFSET_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLFINEOFFSET_H_
+
+#include <string>
+#include "service/Protocol.h"
+#include "service/ControllerMessage.h"
+
+class ProtocolFineoffset : public Protocol {
+public:
+	static std::string decodeData(const ControllerMessage &dataMsg);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLFINEOFFSET_H_
--- a/external/tellstick-core/ProtocolFuhaote.cpp
+++ b/external/tellstick-core/ProtocolFuhaote.cpp
@ -0,0 +1,60 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolFuhaote.h"
+#include <string>
+
+int ProtocolFuhaote::methods() const {
+	return TELLSTICK_TURNON | TELLSTICK_TURNOFF;
+}
+
+std::string ProtocolFuhaote::getStringForMethod(int method, unsigned char, Controller *) {
+	const char S = 19;
+	const char L = 58;
+	const char B0[] = {S, L, L, S, 0};
+	const char B1[] = {L, S, L, S, 0};
+	const char OFF[] = {S, L, S, L, S, L, L, S, 0};
+	const char ON[]  = {S, L, L, S, S, L, S, L, 0};
+
+	std::string strReturn = "S";
+	std::wstring strCode = this->getStringParameter(L"code", L"");
+	if (strCode == L"") {
+		return "";
+	}
+
+	// House code
+	for(size_t i = 0; i < 5; ++i) {
+		if (strCode[i] == '0') {
+			strReturn.append(B0);
+		} else if (strCode[i] == '1') {
+			strReturn.append(B1);
+		}
+	}
+	// Unit code
+	for(size_t i = 5; i < 10; ++i) {
+		if (strCode[i] == '0') {
+			strReturn.append(B0);
+		} else if (strCode[i] == '1') {
+			strReturn.append(1, S);
+			strReturn.append(1, L);
+			strReturn.append(1, S);
+			strReturn.append(1, L);
+		}
+	}
+
+	if (method == TELLSTICK_TURNON) {
+		strReturn.append(ON);
+	} else if (method == TELLSTICK_TURNOFF) {
+		strReturn.append(OFF);
+	} else {
+		return "";
+	}
+
+	strReturn.append(1, S);
+	strReturn.append("+");
+	return strReturn;
+}
+
--- a/external/tellstick-core/ProtocolFuhaote.h
+++ b/external/tellstick-core/ProtocolFuhaote.h
@ -0,0 +1,19 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLFUHAOTE_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLFUHAOTE_H_
+
+#include <string>
+#include "service/Protocol.h"
+
+class ProtocolFuhaote : public Protocol {
+public:
+	int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLFUHAOTE_H_
--- a/external/tellstick-core/ProtocolGroup.cpp
+++ b/external/tellstick-core/ProtocolGroup.cpp
@ -0,0 +1,16 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolGroup.h"
+#include <string>
+
+int ProtocolGroup::methods() const {
+	return TELLSTICK_TURNON | TELLSTICK_TURNOFF | TELLSTICK_DIM | TELLSTICK_BELL | TELLSTICK_LEARN | TELLSTICK_EXECUTE | TELLSTICK_TOGGLE | TELLSTICK_UP | TELLSTICK_DOWN | TELLSTICK_STOP;
+}
+
+std::string ProtocolGroup::getStringForMethod(int method, unsigned char data, Controller *) {
+	return "";
+}
--- a/external/tellstick-core/ProtocolGroup.h
+++ b/external/tellstick-core/ProtocolGroup.h
@ -0,0 +1,22 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLGROUP_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLGROUP_H_
+
+#include <string>
+#include "service/Protocol.h"
+
+class ProtocolGroup : public Protocol {
+public:
+	virtual int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLGROUP_H_
+
+
+
--- a/external/tellstick-core/ProtocolHasta.cpp
+++ b/external/tellstick-core/ProtocolHasta.cpp
@ -0,0 +1,201 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolHasta.h"
+#include <stdio.h>
+#include <sstream>
+#include <string>
+#include "common/Strings.h"
+
+int ProtocolHasta::methods() const {
+	return TELLSTICK_UP | TELLSTICK_DOWN | TELLSTICK_STOP | TELLSTICK_LEARN;
+}
+
+std::string ProtocolHasta::getStringForMethod(int method, unsigned char, Controller *) {
+	if (TelldusCore::comparei(model(), L"selflearningv2")) {
+		return getStringForMethodv2(method);
+	}
+	return getStringForMethodv1(method);
+}
+
+std::string ProtocolHasta::getStringForMethodv1(int method) {
+	int house = this->getIntParameter(L"house", 1, 65536);
+	int unit = this->getIntParameter(L"unit", 1, 15);
+	std::string strReturn;
+
+	strReturn.append(1, 164);
+	strReturn.append(1, 1);
+	strReturn.append(1, 164);
+	strReturn.append(1, 1);
+	strReturn.append(1, 164);
+	strReturn.append(1, 164);
+
+	strReturn.append(convertByte( (house & 0xFF) ));
+	strReturn.append(convertByte( (house>>8) & 0xFF ));
+
+	int byte = unit&0x0F;
+
+	if (method == TELLSTICK_UP) {
+		byte |= 0x00;
+
+	} else if (method == TELLSTICK_DOWN) {
+		byte |= 0x10;
+
+	} else if (method == TELLSTICK_STOP) {
+		byte |= 0x50;
+
+	} else if (method == TELLSTICK_LEARN) {
+		byte |= 0x40;
+
+	} else {
+		return "";
+	}
+	strReturn.append(convertByte(byte));
+
+	strReturn.append(convertByte(0x0));
+	strReturn.append(convertByte(0x0));
+
+	// Remove the last pulse
+	strReturn.erase(strReturn.end()-1, strReturn.end());
+
+	return strReturn;
+}
+
+std::string ProtocolHasta::convertByte(unsigned char byte) {
+	std::string retval;
+	for(int i = 0; i < 8; ++i) {
+		if (byte & 1) {
+			retval.append(1, 33);
+			retval.append(1, 17);
+		} else {
+			retval.append(1, 17);
+			retval.append(1, 33);
+		}
+		byte >>= 1;
+	}
+	return retval;
+}
+
+std::string ProtocolHasta::getStringForMethodv2(int method) {
+	int house = this->getIntParameter(L"house", 1, 65536);
+	int unit = this->getIntParameter(L"unit", 1, 15);
+	int sum = 0;
+	std::string strReturn;
+	strReturn.append(1, 245);
+	strReturn.append(1, 1);
+	strReturn.append(1, 245);
+	strReturn.append(1, 245);
+	strReturn.append(1, 63);
+	strReturn.append(1, 1);
+	strReturn.append(1, 63);
+	strReturn.append(1, 1);
+	strReturn.append(1, 35);
+	strReturn.append(1, 35);
+
+	strReturn.append(convertBytev2( (house>>8) & 0xFF ));
+	sum = ((house>>8)&0xFF);
+	strReturn.append(convertBytev2( (house & 0xFF) ));
+	sum += (house & 0xFF);
+
+	int byte = unit&0x0F;
+
+	if (method == TELLSTICK_UP) {
+		byte |= 0xC0;
+
+	} else if (method == TELLSTICK_DOWN) {
+		byte |= 0x10;
+
+	} else if (method == TELLSTICK_STOP) {
+		byte |= 0x50;
+
+	} else if (method == TELLSTICK_LEARN) {
+		byte |= 0x40;
+
+	} else {
+		return "";
+	}
+	strReturn.append(convertBytev2(byte));
+	sum += byte;
+
+	strReturn.append(convertBytev2(0x01));
+	sum += 0x01;
+
+	int checksum = ((static_cast<int>(sum/256)+1)*256+1) - sum;
+	strReturn.append(convertBytev2(checksum));
+	strReturn.append(1, 63);
+	strReturn.append(1, 35);
+
+	return strReturn;
+}
+
+std::string ProtocolHasta::convertBytev2(unsigned char byte) {
+	std::string retval;
+	for(int i = 0; i < 8; ++i) {
+		if (byte & 1) {
+			retval.append(1, 63);
+			retval.append(1, 35);
+		} else {
+			retval.append(1, 35);
+			retval.append(1, 63);
+		}
+		byte >>= 1;
+	}
+	return retval;
+}
+
+std::string ProtocolHasta::decodeData(const ControllerMessage& dataMsg) {
+	uint64_t allData = dataMsg.getInt64Parameter("data");
+
+	unsigned int house = 0;
+	unsigned int unit = 0;
+	unsigned int method = 0;
+	std::string model;
+	std::string methodstring;
+
+	allData >>= 8;
+	unit = allData & 0xF;
+	allData >>= 4;
+	method = allData & 0xF;
+	allData >>= 4;
+	if(TelldusCore::comparei(dataMsg.model(), L"selflearning")) {
+		// version1
+		house = allData & 0xFFFF;
+		house = ((house << 8) | (house >> 8)) & 0xFFFF;
+		model = "selflearning";
+		if(method == 0) {
+			methodstring = "up";
+		} else if(method == 1) {
+			methodstring = "down";
+		} else if(method == 5) {
+			methodstring = "stop";
+		} else {
+			return "";
+		}
+	} else {
+		// version2
+		house = allData & 0xFFFF;
+
+		model = "selflearningv2";
+		if(method == 12) {
+			methodstring = "up";
+		} else if(method == 1 || method == 8) {  // is method 8 correct?
+			methodstring = "down";
+		} else if(method == 5) {
+			methodstring = "stop";
+		} else {
+			return "";
+		}
+	}
+
+	if(house < 1 || house > 65535 || unit < 1 || unit > 16) {
+		// not hasta
+		return "";
+	}
+
+	std::stringstream retString;
+	retString << "class:command;protocol:hasta;model:" << model << ";house:" << house << ";unit:" << unit << ";method:" << methodstring << ";";
+	return retString.str();
+}
--- a/external/tellstick-core/ProtocolHasta.h
+++ b/external/tellstick-core/ProtocolHasta.h
@ -0,0 +1,27 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLHASTA_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLHASTA_H_
+
+#include <string>
+#include "service/ControllerMessage.h"
+#include "service/Protocol.h"
+
+class ProtocolHasta : public Protocol {
+public:
+	int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+	static std::string decodeData(const ControllerMessage &dataMsg);
+
+protected:
+	static std::string convertByte(unsigned char byte);
+	static std::string convertBytev2(unsigned char byte);
+	std::string getStringForMethodv1(int method);
+	std::string getStringForMethodv2(int method);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLHASTA_H_
--- a/external/tellstick-core/ProtocolIkea.cpp
+++ b/external/tellstick-core/ProtocolIkea.cpp
@ -0,0 +1,151 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolIkea.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include "common/Strings.h"
+#ifdef _WINDOWS
+#define strtok_r(s, d, p) strtok_s(s, d, p)
+#endif
+
+int ProtocolIkea::methods() const {
+	if (TelldusCore::comparei(model(), L"selflearning-switch")) {
+		return TELLSTICK_TURNON | TELLSTICK_TURNOFF;
+	}
+	return TELLSTICK_TURNON | TELLSTICK_TURNOFF | TELLSTICK_DIM;
+}
+
+std::string ProtocolIkea::getStringForMethod(int method, unsigned char level, Controller *) {
+	const char B1[] = {84, 84, 0};
+	const char B0[] = {170, 0};
+
+	int intSystem = this->getIntParameter(L"system", 1, 16)-1;
+	int intFadeStyle = TelldusCore::comparei(this->getStringParameter(L"fade", L"true"), L"true");
+	std::wstring wstrUnits = this->getStringParameter(L"units", L"");
+
+	if (method == TELLSTICK_TURNON) {
+		level = 255;
+	} else if (method == TELLSTICK_TURNOFF) {
+		level = 0;
+	} else if (method == TELLSTICK_DIM) {
+	} else {
+		return "";
+	}
+
+	if (wstrUnits == L"") {
+		return "";
+	}
+
+	std::string strUnits(TelldusCore::wideToString(wstrUnits));
+	int intUnits = 0;  // Start without any units
+
+	char *tempUnits = new char[strUnits.size()+1];
+#ifdef _WINDOWS
+	strcpy_s(tempUnits, strUnits.size()+1, strUnits.c_str());
+#else
+	snprintf(tempUnits, strUnits.size()+1, "%s", strUnits.c_str());
+#endif
+
+	char *saveptr;
+	char *strToken = strtok_r(tempUnits, ",", &saveptr);
+	do {
+		int intUnit = atoi(strToken);
+		if (intUnit == 10) {
+			intUnit = 0;
+		}
+		intUnits = intUnits | ( 1<<(9-intUnit) );
+	} while ( (strToken = strtok_r(NULL, ",", &saveptr)) != NULL );
+
+	delete[] tempUnits;
+
+	std::string strReturn;
+	strReturn.append(1, 'S');
+	strReturn.append(1, 84);
+	strReturn.append(1, 84);
+	strReturn.append(1, 84);
+	strReturn.append(1, 84);
+	strReturn.append(1, 84);
+	strReturn.append(1, 84);
+	strReturn.append(1, 170);
+
+	std::string strChannels = "";
+	int intCode = (intSystem << 10) | intUnits;
+	int checksum1 = 0;
+	int checksum2 = 0;
+	for (int i = 13; i >= 0; --i) {
+		if ((intCode >> i) & 1) {
+			strChannels.append(B1);
+			if (i % 2 == 0)
+				checksum2++;
+			else
+				checksum1++;
+		} else {
+			strChannels.append(B0);
+		}
+	}
+	strReturn.append(strChannels);  // System + Units
+
+	strReturn.append(checksum1 %2 == 0 ? B1 : B0);  // 1st checksum
+	strReturn.append(checksum2 %2 == 0 ? B1 : B0);  // 2nd checksum
+
+	int intLevel = 0;
+	if (level <= 12) {
+		intLevel = 10;  // Level 10 is actually off
+	} else if (level <= 37) {
+		intLevel = 1;
+	} else if (level <= 62) {
+		intLevel = 2;
+	} else if (level <= 87) {
+		intLevel = 3;
+	} else if (level <= 112) {
+		intLevel = 4;
+	} else if (level <= 137) {
+		intLevel = 5;
+	} else if (level <= 162) {
+		intLevel = 6;
+	} else if (level <= 187) {
+		intLevel = 7;
+	} else if (level <= 212) {
+		intLevel = 8;
+	} else if (level <= 237) {
+		intLevel = 9;
+	} else {
+		intLevel = 0;  // Level 0 is actually full on
+	}
+
+	int intFade = 0;
+	if (intFadeStyle == 1) {
+		intFade = 11 << 4;  // Smooth
+	} else {
+		intFade = 1 << 4;  // Instant
+	}
+
+	intCode = intLevel | intFade;  // Concat level and fade
+
+	checksum1 = 0;
+	checksum2 = 0;
+	for (int i = 0; i < 6; ++i) {
+		if ((intCode >> i) & 1) {
+			strReturn.append(B1);
+			if (i % 2 == 0)
+				checksum1++;
+			else
+				checksum2++;
+		} else {
+			strReturn.append(B0);
+		}
+	}
+
+	strReturn.append(checksum1 %2 == 0 ? B1 : B0);  // 1st checksum
+	strReturn.append(checksum2 %2 == 0 ? B1 : B0);  // 2nd checksum
+
+	strReturn.append("+");
+
+	return strReturn;
+}
--- a/external/tellstick-core/ProtocolIkea.h
+++ b/external/tellstick-core/ProtocolIkea.h
@ -0,0 +1,19 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLIKEA_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLIKEA_H_
+
+#include <string>
+#include "service/Protocol.h"
+
+class ProtocolIkea : public Protocol {
+public:
+	int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLIKEA_H_
--- a/external/tellstick-core/ProtocolMandolyn.cpp
+++ b/external/tellstick-core/ProtocolMandolyn.cpp
@ -0,0 +1,46 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolMandolyn.h"
+#include <stdlib.h>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include "common/Strings.h"
+
+std::string ProtocolMandolyn::decodeData(const ControllerMessage &dataMsg) {
+	std::string data = dataMsg.getParameter("data");
+	uint32_t value = (uint32_t)TelldusCore::hexTo64l(data);
+
+	// parity not used
+	// bool parity = value & 0x1;
+	value >>= 1;
+
+	double temp = static_cast<double>(value & 0x7FFF) - static_cast<double>(6400);
+	temp = temp/128.0;
+	value >>= 15;
+
+	uint8_t humidity = (value & 0x7F);
+	value >>= 7;
+
+	// battOk not used
+	// bool battOk = value & 0x1;
+	value >>= 3;
+
+	uint8_t channel = (value & 0x3)+1;
+	value >>= 2;
+
+	uint8_t house = value & 0xF;
+
+	std::stringstream retString;
+	retString << "class:sensor;protocol:mandolyn;id:"
+		<< house*10+channel
+		<< ";model:temperaturehumidity;"
+		<< "temp:" << std::fixed << std::setprecision(1) << temp
+		<< ";humidity:" << static_cast<int>(humidity) << ";";
+
+	return retString.str();
+}
--- a/external/tellstick-core/ProtocolMandolyn.h
+++ b/external/tellstick-core/ProtocolMandolyn.h
@ -0,0 +1,19 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLMANDOLYN_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLMANDOLYN_H_
+
+#include <string>
+#include "service/Protocol.h"
+#include "service/ControllerMessage.h"
+
+class ProtocolMandolyn : public Protocol {
+public:
+	static std::string decodeData(const ControllerMessage &dataMsg);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLMANDOLYN_H_
--- a/external/tellstick-core/ProtocolNexa.cpp
+++ b/external/tellstick-core/ProtocolNexa.cpp
@ -0,0 +1,279 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolNexa.h"
+#include <stdio.h>
+#include <sstream>
+#include <string>
+#include "service/TellStick.h"
+#include "common/Strings.h"
+
+int ProtocolNexa::lastArctecCodeSwitchWasTurnOff = 0;  // TODO(stefan): always removing first turnon now, make more flexible (waveman too)
+
+int ProtocolNexa::methods() const {
+	if (TelldusCore::comparei(model(), L"codeswitch")) {
+		return (TELLSTICK_TURNON | TELLSTICK_TURNOFF);
+
+	} else if (TelldusCore::comparei(model(), L"selflearning-switch")) {
+		return (TELLSTICK_TURNON | TELLSTICK_TURNOFF | TELLSTICK_LEARN);
+
+	} else if (TelldusCore::comparei(model(), L"selflearning-dimmer")) {
+		return (TELLSTICK_TURNON | TELLSTICK_TURNOFF | TELLSTICK_DIM | TELLSTICK_LEARN);
+
+	} else if (TelldusCore::comparei(model(), L"bell")) {
+		return TELLSTICK_BELL;
+	}
+	return 0;
+}
+
+std::string ProtocolNexa::getStringForMethod(int method, unsigned char data, Controller *controller) {
+	if (TelldusCore::comparei(model(), L"codeswitch")) {
+		return getStringCodeSwitch(method);
+	} else if (TelldusCore::comparei(model(), L"bell")) {
+		return getStringBell();
+	}
+	if ((method == TELLSTICK_TURNON) && TelldusCore::comparei(model(), L"selflearning-dimmer")) {
+		// Workaround for not letting a dimmer do into "dimming mode"
+		return getStringSelflearning(TELLSTICK_DIM, 255);
+	}
+	if (method == TELLSTICK_LEARN) {
+		std::string str = getStringSelflearning(TELLSTICK_TURNON, data);
+
+		// Check to see if we are an old TellStick (fw <= 2, batch <= 8)
+		TellStick *ts = reinterpret_cast<TellStick *>(controller);
+		if (!ts) {
+			return str;
+		}
+		if (ts->pid() == 0x0c30 && ts->firmwareVersion() <= 2) {
+			// Workaround for the bug in early firmwares
+			// The TellStick have a fixed pause (max) between two packets.
+			// It is only correct between the first and second packet.
+			// It seems faster to send two packes at a time and some
+			// receivers seems picky about this when learning.
+			// We also return the last packet so Device::doAction() doesn't
+			// report TELLSTICK_ERROR_METHOD_NOT_SUPPORTED
+
+			str.insert(0, 1, 2);  // Repeat two times
+			str.insert(0, 1, 'R');
+			for (int i = 0; i < 5; ++i) {
+				controller->send(str);
+			}
+		}
+		return str;
+	}
+	return getStringSelflearning(method, data);
+}
+
+std::string ProtocolNexa::getStringCodeSwitch(int method) {
+	std::string strReturn = "S";
+
+	std::wstring house = getStringParameter(L"house", L"A");
+	int intHouse = house[0] - L'A';
+	strReturn.append(getCodeSwitchTuple(intHouse));
+	strReturn.append(getCodeSwitchTuple(getIntParameter(L"unit", 1, 16)-1));
+
+	if (method == TELLSTICK_TURNON) {
+		strReturn.append("$k$k$kk$$kk$$kk$$k+");
+	} else if (method == TELLSTICK_TURNOFF) {
+		strReturn.append(this->getOffCode());
+	} else {
+		return "";
+	}
+	return strReturn;
+}
+
+std::string ProtocolNexa::getStringBell() {
+	std::string strReturn = "S";
+
+	std::wstring house = getStringParameter(L"house", L"A");
+	int intHouse = house[0] - L'A';
+	strReturn.append(getCodeSwitchTuple(intHouse));
+	strReturn.append("$kk$$kk$$kk$$k$k");  // Unit 7
+	strReturn.append("$kk$$kk$$kk$$kk$$k+");  // Bell
+	return strReturn;
+}
+
+std::string ProtocolNexa::getStringSelflearning(int method, unsigned char level) {
+	int intHouse = getIntParameter(L"house", 1, 67108863);
+	int intCode = getIntParameter(L"unit", 1, 16)-1;
+	return getStringSelflearningForCode(intHouse, intCode, method, level);
+}
+
+std::string ProtocolNexa::getStringSelflearningForCode(int intHouse, int intCode, int method, unsigned char level) {
+	const unsigned char START[] = {'T', 127, 255, 24, 1, 0};
+	// const char START[] = {'T',130,255,26,24,0};
+
+	std::string strMessage(reinterpret_cast<const char*>(START));
+	strMessage.append(1, (method == TELLSTICK_DIM ? 147 : 132));  // Number of pulses
+
+	std::string m;
+	for (int i = 25; i >= 0; --i) {
+		m.append( intHouse & 1 << i ? "10" : "01" );
+	}
+	m.append("01");  // Group
+
+	// On/off
+	if (method == TELLSTICK_DIM) {
+		m.append("00");
+	} else if (method == TELLSTICK_TURNOFF) {
+		m.append("01");
+	} else if (method == TELLSTICK_TURNON) {
+		m.append("10");
+	} else {
+		return "";
+	}
+
+	for (int i = 3; i >= 0; --i) {
+		m.append( intCode & 1 << i ? "10" : "01" );
+	}
+
+	if (method == TELLSTICK_DIM) {
+		unsigned char newLevel = level/16;
+		for (int i = 3; i >= 0; --i) {
+			m.append(newLevel & 1 << i ? "10" : "01");
+		}
+	}
+
+	// The number of data is odd.
+	// Add this to make it even, otherwise the following loop will not work
+	m.append("0");
+
+	unsigned char code = 9;  // b1001, startcode
+	for (unsigned int i = 0; i < m.length(); ++i) {
+		code <<= 4;
+		if (m[i] == '1') {
+			code |= 8;  // b1000
+		} else {
+			code |= 10;  // b1010
+			// code |= 11; //b1011
+		}
+		if (i % 2 == 0) {
+			strMessage.append(1, code);
+			code = 0;
+		}
+	}
+	strMessage.append("+");
+
+// 	for( int i = 0; i < strMessage.length(); ++i ) {
+// 		printf("%i,", (unsigned char)strMessage[i]);
+// 	}
+// 	printf("\n");
+	return strMessage;
+}
+
+std::string ProtocolNexa::decodeData(const ControllerMessage& dataMsg) {
+	uint64_t allData = dataMsg.getInt64Parameter("data");
+
+	if(TelldusCore::comparei(dataMsg.model(), L"selflearning")) {
+		// selflearning
+		return decodeDataSelfLearning(allData);
+	} else {
+		// codeswitch
+		return decodeDataCodeSwitch(allData);
+	}
+}
+
+std::string ProtocolNexa::decodeDataSelfLearning(uint64_t allData) {
+	unsigned int house = 0;
+	unsigned int unit = 0;
+	unsigned int group = 0;
+	unsigned int method = 0;
+
+	house = allData & 0xFFFFFFC0;
+	house >>= 6;
+
+	group = allData & 0x20;
+	group >>= 5;
+
+	method = allData & 0x10;
+	method >>= 4;
+
+	unit = allData & 0xF;
+	unit++;
+
+	if(house < 1 || house > 67108863 || unit < 1 || unit > 16) {
+		// not arctech selflearning
+		return "";
+	}
+
+	std::stringstream retString;
+	retString << "class:command;protocol:arctech;model:selflearning;house:" << house << ";unit:" << unit << ";group:" << group << ";method:";
+	if(method == 1) {
+		retString << "turnon;";
+	} else if(method == 0) {
+		retString << "turnoff;";
+	} else {
+		// not arctech selflearning
+		return "";
+	}
+
+	return retString.str();
+}
+
+std::string ProtocolNexa::decodeDataCodeSwitch(uint64_t allData) {
+	unsigned int house = 0;
+	unsigned int unit = 0;
+	unsigned int method = 0;
+
+	method = allData & 0xF00;
+	method >>= 8;
+
+	unit = allData & 0xF0;
+	unit >>= 4;
+	unit++;
+
+	house = allData & 0xF;
+
+	if(house > 16 || unit < 1 || unit > 16) {
+		// not arctech codeswitch
+		return "";
+	}
+
+	house = house + 'A';  // house from A to P
+
+	if(method != 6 && lastArctecCodeSwitchWasTurnOff == 1) {
+		lastArctecCodeSwitchWasTurnOff = 0;
+		return "";  // probably a stray turnon or bell	(perhaps: only certain time interval since last, check that it's the same house/unit... Will lose
+						// one turnon/bell, but it's better than the alternative...
+	}
+
+	if(method == 6) {
+		lastArctecCodeSwitchWasTurnOff = 1;
+	}
+
+	std::stringstream retString;
+	retString << "class:command;protocol:arctech;model:codeswitch;house:" << static_cast<char>(house);
+
+	if(method == 6) {
+		retString << ";unit:" << unit << ";method:turnoff;";
+	} else if(method == 14) {
+		retString << ";unit:" << unit << ";method:turnon;";
+	} else if(method == 15) {
+		retString << ";method:bell;";
+	} else {
+		// not arctech codeswitch
+		return "";
+	}
+
+	return retString.str();
+}
+
+std::string ProtocolNexa::getCodeSwitchTuple(int intCode) {
+	std::string strReturn = "";
+	for( int i = 0; i < 4; ++i ) {
+		if (intCode & 1) {  // Convert 1
+			strReturn.append("$kk$");
+		} else {  // Convert 0
+			strReturn.append("$k$k");
+		}
+		intCode >>= 1;
+	}
+	return strReturn;
+}
+
+std::string ProtocolNexa::getOffCode() const {
+	return "$k$k$kk$$kk$$k$k$k+";
+}
--- a/external/tellstick-core/ProtocolNexa.h
+++ b/external/tellstick-core/ProtocolNexa.h
@ -0,0 +1,39 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLNEXA_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLNEXA_H_
+
+#ifdef _MSC_VER
+typedef unsigned __int64 uint64_t;
+#else
+#include <stdint.h>
+#endif
+#include <string>
+#include "service/ControllerMessage.h"
+#include "service/Device.h"
+
+class ProtocolNexa : public Protocol {
+public:
+	virtual int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+	static std::string decodeData(const ControllerMessage &dataMsg);
+
+protected:
+	std::string getStringSelflearning(int method, unsigned char data);
+	std::string getStringCodeSwitch(int method);
+	std::string getStringBell();
+	virtual std::string getOffCode() const;
+	static std::string getCodeSwitchTuple(int code);
+	static std::string getStringSelflearningForCode(int house, int unit, int method, unsigned char data);
+
+private:
+	static int lastArctecCodeSwitchWasTurnOff;
+	static std::string decodeDataCodeSwitch(uint64_t allData);
+	static std::string decodeDataSelfLearning(uint64_t allData);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLNEXA_H_
--- a/external/tellstick-core/ProtocolOregon.cpp
+++ b/external/tellstick-core/ProtocolOregon.cpp
@ -0,0 +1,347 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolOregon.h"
+#include <stdlib.h>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include "common/Strings.h"
+
+std::string ProtocolOregon::decodeData(const ControllerMessage &dataMsg) {
+	std::string data = dataMsg.getParameter("data");
+
+	std::wstring model = dataMsg.model();
+	if (model.compare(L"0xEA4C") == 0) {
+		return decodeEA4C(data);
+	} else if (model.compare(L"0x1A2D") == 0) {
+		return decode1A2D(data);
+	} else if (model.compare(L"0xF824") == 0) {
+		return decodeF824(data);
+	} else if (model.compare(L"0x1984") == 0 || model.compare(L"0x1994") == 0) {
+		return decode1984(data, model);
+	} else if (model.compare(L"0x2914") == 0) {
+		return decode2914(data);
+	} else if (model.compare(L"0xC844") == 0 || model.compare(L"0xEC40") == 0) {
+		// C844 - pool thermometer
+		return decodeC844(data, model);
+	}
+
+	return "";
+}
+
+std::string ProtocolOregon::decodeEA4C(const std::string &data) {
+	uint64_t value = TelldusCore::hexTo64l(data);
+
+	uint8_t checksum = 0xE + 0xA + 0x4 + 0xC;
+	checksum -= (value & 0xF) * 0x10;
+	checksum -= 0xA;
+	value >>= 8;
+
+	uint8_t checksumw = (value >> 4) & 0xF;
+	bool neg = value & (1 << 3);
+	int hundred = value & 3;
+	checksum += (value & 0xF);
+	value >>= 8;
+
+	uint8_t temp2 = value & 0xF;
+	uint8_t temp1 = (value >> 4) & 0xF;
+	checksum += temp2 + temp1;
+	value >>= 8;
+
+	uint8_t temp3 = (value >> 4) & 0xF;
+	checksum += (value & 0xF) + temp3;
+	value >>= 8;
+
+	checksum += ((value >> 4) & 0xF) + (value & 0xF);
+	uint8_t address = value & 0xFF;
+	value >>= 8;
+
+	checksum += ((value >> 4) & 0xF) + (value & 0xF);
+	// channel not used
+	// uint8_t channel = (value >> 4) & 0x7;
+
+	if (checksum != checksumw) {
+		return "";
+	}
+
+	double temperature = ((hundred * 1000) + (temp1 * 100) + (temp2 * 10) + temp3)/10.0;
+	if (neg) {
+		temperature = -temperature;
+	}
+
+	std::stringstream retString;
+	retString << "class:sensor;protocol:oregon;model:EA4C;id:" << static_cast<int>(address)
+		<< ";temp:" << std::fixed << std::setprecision(1) << temperature << ";";
+
+	return retString.str();
+}
+
+std::string ProtocolOregon::decode1984(const std::string &data, const std::wstring &model) {
+	// wind
+	uint64_t value = TelldusCore::hexTo64l(data);
+
+	uint8_t crcCheck = value & 0xF;  // PROBABLY crc
+	value >>= 4;
+	uint8_t messageChecksum1 = value & 0xF;
+	value >>= 4;
+	uint8_t messageChecksum2 = value & 0xF;
+
+	value >>= 4;
+	uint8_t avg1 = value & 0xF;
+	value >>= 4;
+	uint8_t avg2 = value & 0xF;
+	value >>= 4;
+	uint8_t avg3 = value & 0xF;
+	value >>= 4;
+	uint8_t gust1 = value & 0xF;
+	value >>= 4;
+	uint8_t gust2 = value & 0xF;
+	value >>= 4;
+	uint8_t gust3 = value & 0xF;
+	value >>= 4;
+	uint8_t unknown1 = value & 0xF;
+	value >>= 4;
+	uint8_t unknown2 = value & 0xF;
+	value >>= 4;
+	uint8_t direction = value & 0xF;
+
+	value >>= 4;
+	uint8_t battery = value & 0xF;  // PROBABLY battery
+	value >>= 4;
+	uint8_t rollingcode = ((value >> 4) & 0xF) + (value & 0xF);
+	uint8_t checksum = ((value >> 4) & 0xF) + (value & 0xF);
+	value >>= 8;
+	uint8_t channel = value & 0xF;
+	checksum += unknown1 + unknown2 + avg1 + avg2 + avg3 + gust1 + gust2 + gust3 + direction + battery + channel;
+
+	if (model.compare(L"0x1984") == 0) {
+		checksum += 0x1 + 0x9 + 0x8 + 0x4;
+	} else {
+		checksum += 0x1 + 0x9 + 0x9 + 0x4;
+	}
+
+	if (((checksum >> 4) & 0xF) != messageChecksum1 || (checksum & 0xF) != messageChecksum2) {
+		// checksum error
+		return "";
+	}
+
+
+	double avg = ((avg1 * 100) + (avg2 * 10) + avg3)/10.0;
+	double gust = ((gust1 * 100) + (gust2 * 10) + gust3)/10.0;
+	float directiondegree = 22.5 * direction;
+
+	std::stringstream retString;
+	retString << "class:sensor;protocol:oregon;model:1984;id:" << static_cast<int>(rollingcode)
+		<< ";winddirection:" << directiondegree
+		<< ";windaverage:" << std::fixed << std::setprecision(1) << avg
+		<< ";windgust:" << std::fixed << std::setprecision(1) << gust << ";";
+
+	return retString.str();
+}
+
+std::string ProtocolOregon::decode1A2D(const std::string &data) {
+	uint64_t value = TelldusCore::hexTo64l(data);
+	// checksum2 not used yet
+	// 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);
+	// channel not used
+	// uint8_t channel = (value >> 4) & 0x7;
+
+	checksum += 0x1 + 0xA + 0x2 + 0xD - 0xA;
+
+	// TODO(micke): Find out how checksum2 works
+	if (checksum != checksum1) {
+		return "";
+	}
+
+	double temperature = ((temp1 * 100) + (temp2 * 10) + temp3)/10.0;
+	if (neg) {
+		temperature = -temperature;
+	}
+	int humidity = (hum1 * 10.0) + hum2;
+
+	std::stringstream retString;
+	retString << "class:sensor;protocol:oregon;model:1A2D;id:" << static_cast<int>(address)
+		<< ";temp:" << std::fixed << std::setprecision(1) << temperature
+		<< ";humidity:" << humidity << ";";
+
+	return retString.str();
+}
+
+std::string ProtocolOregon::decode2914(const std::string &data) {
+	// rain
+	uint64_t value = TelldusCore::hexTo64l(data);
+
+	uint8_t messageChecksum1 = value & 0xF;
+	value >>= 4;
+	uint8_t messageChecksum2 = value & 0xF;
+
+	value >>= 4;
+	uint8_t totRain1 = value & 0xF;
+	value >>= 4;
+	uint8_t totRain2 = value & 0xF;
+	value >>= 4;
+	uint8_t totRain3 = value & 0xF;
+	value >>= 4;
+	uint8_t totRain4 = value & 0xF;
+	value >>= 4;
+	uint8_t totRain5 = value & 0xF;
+	value >>= 4;
+	uint8_t totRain6 = value & 0xF;
+	value >>= 4;
+	uint8_t rainRate1 = value & 0xF;
+	value >>= 4;
+	uint8_t rainRate2 = value & 0xF;
+	value >>= 4;
+	uint8_t rainRate3 = value & 0xF;
+	value >>= 4;
+	uint8_t rainRate4 = value & 0xF;
+
+	value >>= 4;
+	uint8_t battery = value & 0xF;  // PROBABLY battery
+	value >>= 4;
+	uint8_t rollingcode = ((value >> 4) & 0xF) + (value & 0xF);
+	uint8_t checksum = ((value >> 4) & 0xF) + (value & 0xF);
+	value >>= 8;
+	uint8_t channel = value & 0xF;
+	checksum += totRain1 + totRain2 + totRain3 + totRain4 + totRain5 + totRain6 + rainRate1 + rainRate2 + rainRate3 + rainRate4 + battery + channel + 0x2 + 0x9 + 0x1 + 0x4;
+
+	if (((checksum >> 4) & 0xF) != messageChecksum1 || (checksum & 0xF) != messageChecksum2) {
+		// checksum error
+		return "";
+	}
+
+	double totRain = ((totRain1 * 100000) + (totRain2 * 10000) + (totRain3 * 1000) + (totRain4 * 100) + (totRain5 * 10) + totRain6)/1000.0*25.4;
+	double rainRate = ((rainRate1 * 1000) + (rainRate2 * 100) + (rainRate3 * 10) + rainRate4)/100.0*25.4;
+
+	std::stringstream retString;
+	retString << "class:sensor;protocol:oregon;model:2914;id:" << static_cast<int>(rollingcode)
+		<< ";raintotal:" << std::fixed << std::setprecision(1) << totRain
+		<< ";rainrate:" << std::fixed << std::setprecision(1) << rainRate << ";";
+	return retString.str();
+}
+
+std::string ProtocolOregon::decodeF824(const std::string &data) {
+	uint64_t value = TelldusCore::hexTo64l(data);
+
+	uint8_t crcCheck = value & 0xF;  // PROBABLY crc
+	value >>= 4;
+	uint8_t messageChecksum1 = value & 0xF;
+	value >>= 4;
+	uint8_t messageChecksum2 = value & 0xF;
+	value >>= 4;
+	uint8_t unknown = value & 0xF;
+	value >>= 4;
+	uint8_t hum1 = value & 0xF;
+	value >>= 4;
+	uint8_t hum2 = value & 0xF;
+	value >>= 4;
+	uint8_t neg = value & 0xF;
+	value >>= 4;
+	uint8_t temp1 = value & 0xF;
+	value >>= 4;
+	uint8_t temp2 = value & 0xF;
+	value >>= 4;
+	uint8_t temp3 = value & 0xF;
+	value >>= 4;
+	uint8_t battery = value & 0xF;  // PROBABLY battery
+	value >>= 4;
+	uint8_t rollingcode = ((value >> 4) & 0xF) + (value & 0xF);
+	uint8_t checksum = ((value >> 4) & 0xF) + (value & 0xF);
+	value >>= 8;
+	uint8_t channel = value & 0xF;
+	checksum += unknown + hum1 + hum2 + neg + temp1 + temp2 + temp3 + battery + channel + 0xF + 0x8 + 0x2 + 0x4;
+
+	if (((checksum >> 4) & 0xF) != messageChecksum1 || (checksum & 0xF) != messageChecksum2) {
+		// checksum error
+		return "";
+	}
+
+	double temperature = ((temp1 * 100) + (temp2 * 10) + temp3)/10.0;
+	if (neg) {
+		temperature = -temperature;
+	}
+	int humidity = (hum1 * 10.0) + hum2;
+
+	std::stringstream retString;
+	retString << "class:sensor;protocol:oregon;model:F824;id:" << static_cast<int>(rollingcode)
+		<< ";temp:" << std::fixed << std::setprecision(1) << temperature
+		<< ";humidity:" << humidity << ";";
+
+	return retString.str();
+}
+
+std::string ProtocolOregon::decodeC844(const std::string &data, const std::wstring &model) {
+	uint64_t value = TelldusCore::hexTo64l(data);
+
+	uint8_t messageChecksum1 = value & 0xF;
+	value >>= 4;
+	uint8_t messageChecksum2 = value & 0xF;
+	value >>= 4;
+	uint8_t neg = value & 0xF;
+	value >>= 4;
+	uint8_t temp1 = value & 0xF;
+	value >>= 4;
+	uint8_t temp2 = value & 0xF;
+	value >>= 4;
+	uint8_t temp3 = value & 0xF;
+	value >>= 4;
+	uint8_t battery = value & 0xF;  // PROBABLY battery
+	value >>= 4;
+	uint8_t rollingcode = ((value >> 4) & 0xF) + (value & 0xF);
+	uint8_t checksum = ((value >> 4) & 0xF) + (value & 0xF);
+	value >>= 8;
+	uint8_t channel = value & 0xF;
+	checksum += neg + temp1 + temp2 + temp3 + battery + channel;
+
+	if (model.compare(L"0xC844") == 0) {
+		checksum += 0xC + 0x8 + 0x4 + 0x4;
+	} else {
+		checksum += 0xE + 0xC + 0x4 + 0x0;
+	}
+
+	if (((checksum >> 4) & 0xF) != messageChecksum1 || (checksum & 0xF) != messageChecksum2) {
+		// checksum error
+		return "";
+	}
+
+	double temperature = ((temp1 * 100) + (temp2 * 10) + temp3)/10.0;
+	if (neg) {
+		temperature = -temperature;
+	}
+
+	std::stringstream retString;
+	retString << "class:sensor;protocol:oregon;model:C844;id:" << static_cast<int>(rollingcode)
+		<< ";temp:" << std::fixed << std::setprecision(1) << temperature << ";";
+	return retString.str();
+}
--- a/external/tellstick-core/ProtocolOregon.h
+++ b/external/tellstick-core/ProtocolOregon.h
@ -0,0 +1,27 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLOREGON_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLOREGON_H_
+
+#include <string>
+#include "service/Protocol.h"
+#include "service/ControllerMessage.h"
+
+class ProtocolOregon : public Protocol {
+public:
+	static std::string decodeData(const ControllerMessage &dataMsg);
+
+protected:
+	static std::string decodeEA4C(const std::string &data);
+	static std::string decode1A2D(const std::string &data);
+	static std::string decodeF824(const std::string &data);
+	static std::string decode1984(const std::string &data, const std::wstring &model);
+	static std::string decode2914(const std::string &data);
+	static std::string decodeC844(const std::string &data, const std::wstring &model);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLOREGON_H_
--- a/external/tellstick-core/ProtocolRisingSun.cpp
+++ b/external/tellstick-core/ProtocolRisingSun.cpp
@ -0,0 +1,115 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolRisingSun.h"
+#include <string>
+#include "common/Strings.h"
+
+int ProtocolRisingSun::methods() const {
+	if (TelldusCore::comparei(model(), L"selflearning")) {
+		return (TELLSTICK_TURNON | TELLSTICK_TURNOFF | TELLSTICK_LEARN);
+	}
+	return TELLSTICK_TURNON | TELLSTICK_TURNOFF;
+}
+
+std::string ProtocolRisingSun::getStringForMethod(int method, unsigned char data, Controller *controller) {
+	if (TelldusCore::comparei(model(), L"selflearning")) {
+		return getStringSelflearning(method);
+	}
+	return getStringCodeSwitch(method);
+}
+
+std::string ProtocolRisingSun::getStringSelflearning(int method) {
+	int intHouse = this->getIntParameter(L"house", 1, 33554432)-1;
+	int intCode = this->getIntParameter(L"code", 1, 16)-1;
+
+	const char code_on[][7] = {
+		"110110", "001110", "100110", "010110",
+		"111001", "000101", "101001", "011001",
+		"110000", "001000", "100000", "010000",
+		"111100", "000010", "101100", "011100"
+	};
+	const char code_off[][7] = {
+		"111110", "000001", "101110", "011110",
+		"110101", "001101", "100101", "010101",
+		"111000", "000100", "101000", "011000",
+		"110010", "001010", "100010", "010010"
+	};
+	const char l = 120;
+	const char s = 51;
+
+	std::string strCode = "10";
+	int code = intCode;
+	code = (code < 0 ? 0 : code);
+	code = (code > 15 ? 15 : code);
+	if (method == TELLSTICK_TURNON) {
+		strCode.append(code_on[code]);
+	} else if (method == TELLSTICK_TURNOFF) {
+		strCode.append(code_off[code]);
+	} else if (method == TELLSTICK_LEARN) {
+		strCode.append(code_on[code]);
+	} else {
+		return "";
+	}
+
+	int house = intHouse;
+	for(int i = 0; i < 25; ++i) {
+		if (house & 1) {
+			strCode.append(1, '1');
+		} else {
+			strCode.append(1, '0');
+		}
+		house >>= 1;
+	}
+
+	std::string strReturn;
+	for(unsigned int i = 0; i < strCode.length(); ++i) {
+		if (strCode[i] == '1') {
+			strReturn.append(1, l);
+			strReturn.append(1, s);
+		} else {
+			strReturn.append(1, s);
+			strReturn.append(1, l);
+		}
+	}
+
+	std::string prefix = "P";
+	prefix.append(1, 5);
+	if (method == TELLSTICK_LEARN) {
+		prefix.append("R");
+		prefix.append( 1, 50 );
+	}
+	prefix.append("S");
+	strReturn.insert(0, prefix);
+	strReturn.append(1, '+');
+	return strReturn;
+}
+
+std::string ProtocolRisingSun::getStringCodeSwitch(int method) {
+	std::string strReturn = "S.e";
+	strReturn.append(getCodeSwitchTuple(this->getIntParameter(L"house", 1, 4)-1));
+	strReturn.append(getCodeSwitchTuple(this->getIntParameter(L"unit", 1, 4)-1));
+	if (method == TELLSTICK_TURNON) {
+		strReturn.append("e..ee..ee..ee..e+");
+	} else if (method == TELLSTICK_TURNOFF) {
+		strReturn.append("e..ee..ee..e.e.e+");
+	} else {
+		return "";
+	}
+	return strReturn;
+}
+
+std::string ProtocolRisingSun::getCodeSwitchTuple(int intToConvert) {
+	std::string strReturn = "";
+	for(int i = 0; i < 4; ++i) {
+		if (i == intToConvert) {
+			strReturn.append( ".e.e" );
+		} else {
+			strReturn.append( "e..e" );
+		}
+	}
+	return strReturn;
+}
--- a/external/tellstick-core/ProtocolRisingSun.h
+++ b/external/tellstick-core/ProtocolRisingSun.h
@ -0,0 +1,24 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLRISINGSUN_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLRISINGSUN_H_
+
+#include <string>
+#include "service/Protocol.h"
+
+class ProtocolRisingSun : public Protocol {
+public:
+	int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+
+protected:
+	std::string getStringSelflearning(int method);
+	std::string getStringCodeSwitch(int method);
+	static std::string getCodeSwitchTuple(int code);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLRISINGSUN_H_
--- a/external/tellstick-core/ProtocolSartano.cpp
+++ b/external/tellstick-core/ProtocolSartano.cpp
@ -0,0 +1,108 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolSartano.h"
+#ifdef _MSC_VER
+typedef unsigned __int16 uint16_t;
+#else
+#include <stdint.h>
+#endif
+#include <stdio.h>
+#include <sstream>
+#include <string>
+
+int ProtocolSartano::methods() const {
+	return TELLSTICK_TURNON | TELLSTICK_TURNOFF;
+}
+
+std::string ProtocolSartano::getStringForMethod(int method, unsigned char, Controller *) {
+	std::wstring strCode = this->getStringParameter(L"code", L"");
+	return getStringForCode(strCode, method);
+}
+
+std::string ProtocolSartano::getStringForCode(const std::wstring &strCode, int method) {
+	std::string strReturn("S");
+
+	for (size_t i = 0; i < strCode.length(); ++i) {
+		if (strCode[i] == L'1') {
+			strReturn.append("$k$k");
+		} else {
+			strReturn.append("$kk$");
+		}
+	}
+
+	if (method == TELLSTICK_TURNON) {
+		strReturn.append("$k$k$kk$$k+");
+	} else if (method == TELLSTICK_TURNOFF) {
+		strReturn.append("$kk$$k$k$k+");
+	} else {
+		return "";
+	}
+
+	return strReturn;
+}
+
+std::string ProtocolSartano::decodeData(const ControllerMessage &dataMsg) {
+	uint64_t allDataIn;
+	uint16_t allData = 0;
+	unsigned int code = 0;
+	unsigned int method1 = 0;
+	unsigned int method2 = 0;
+	unsigned int method = 0;
+
+	allDataIn = dataMsg.getInt64Parameter("data");
+
+	uint16_t mask = (1<<11);
+	for(int i = 0; i < 12; ++i) {
+		allData >>= 1;
+		if((allDataIn & mask) == 0) {
+			allData |= (1<<11);
+		}
+		mask >>= 1;
+	}
+
+	code = allData & 0xFFC;
+	code >>= 2;
+
+	method1 = allData & 0x2;
+	method1 >>= 1;
+
+	method2 = allData & 0x1;
+
+	if(method1 == 0 && method2 == 1) {
+		method = 0;  // off
+	} else if(method1 == 1 && method2 == 0) {
+		method = 1;  // on
+	} else {
+		return "";
+	}
+
+	if(code > 1023) {
+		// not sartano
+		return "";
+	}
+
+	std::stringstream retString;
+	retString << "class:command;protocol:sartano;model:codeswitch;code:";
+	mask = (1<<9);
+	for(int i = 0; i < 10; i++) {
+		if((code & mask) != 0) {
+			retString << 1;
+		} else {
+			retString << 0;
+		}
+		mask >>= 1;
+	}
+	retString << ";method:";
+
+	if(method == 0) {
+		retString << "turnoff;";
+	} else {
+		retString << "turnon;";
+	}
+
+	return retString.str();
+}
--- a/external/tellstick-core/ProtocolSartano.h
+++ b/external/tellstick-core/ProtocolSartano.h
@ -0,0 +1,24 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLSARTANO_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLSARTANO_H_
+
+#include <string>
+#include "service/Protocol.h"
+#include "service/ControllerMessage.h"
+
+class ProtocolSartano : public Protocol {
+public:
+	int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+	static std::string decodeData(const ControllerMessage &dataMsg);
+
+protected:
+	std::string getStringForCode(const std::wstring &code, int method);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLSARTANO_H_
--- a/external/tellstick-core/ProtocolScene.cpp
+++ b/external/tellstick-core/ProtocolScene.cpp
@ -0,0 +1,16 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolScene.h"
+#include <string>
+
+int ProtocolScene::methods() const {
+	return TELLSTICK_EXECUTE;
+}
+
+std::string ProtocolScene::getStringForMethod(int method, unsigned char data, Controller *) {
+	return "";
+}
--- a/external/tellstick-core/ProtocolScene.h
+++ b/external/tellstick-core/ProtocolScene.h
@ -0,0 +1,22 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLSCENE_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLSCENE_H_
+
+#include <string>
+#include "service/Protocol.h"
+
+class ProtocolScene : public Protocol {
+public:
+	virtual int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLSCENE_H_
+
+
+
--- a/external/tellstick-core/ProtocolSilvanChip.cpp
+++ b/external/tellstick-core/ProtocolSilvanChip.cpp
@ -0,0 +1,146 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolSilvanChip.h"
+#include <string>
+#include "common/Strings.h"
+
+int ProtocolSilvanChip::methods() const {
+	if (TelldusCore::comparei(model(), L"kp100")) {
+		return TELLSTICK_UP | TELLSTICK_DOWN | TELLSTICK_STOP | TELLSTICK_LEARN;
+	} else if (TelldusCore::comparei(model(), L"ecosavers")) {
+		return TELLSTICK_TURNON | TELLSTICK_TURNOFF | TELLSTICK_LEARN;
+	} else if (TelldusCore::comparei(model(), L"displaymatic")) {
+		return TELLSTICK_UP | TELLSTICK_DOWN | TELLSTICK_STOP;
+	}
+	return 0;
+}
+
+std::string ProtocolSilvanChip::getStringForMethod(int method, unsigned char data, Controller *controller) {
+	if (TelldusCore::comparei(model(), L"kp100")) {
+		std::string preamble;
+		preamble.append(1, 100);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 100);
+
+		const std::string one = "\xFF\x1\x2E\x2E";
+		const std::string zero = "\x2E\xFF\x1\x2E";
+		int button = 0;
+		if (method == TELLSTICK_UP) {
+			button = 2;
+		} else if (method == TELLSTICK_DOWN) {
+			button = 8;
+		} else if (method == TELLSTICK_STOP) {
+			button = 4;
+		} else if (method == TELLSTICK_LEARN) {
+			button = 1;
+		} else {
+			return "";
+		}
+		return this->getString(preamble, one, zero, button);
+	} else if (TelldusCore::comparei(model(), L"displaymatic")) {
+		std::string preamble;
+		preamble.append(1, 0x25);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 0x25);
+		const std::string one = "\x69\25";
+		const std::string zero = "\x25\x69";
+		int button = 0;
+		if (method == TELLSTICK_UP) {
+			button = 1;
+		} else if (method == TELLSTICK_DOWN) {
+			button = 4;
+		} else if (method == TELLSTICK_STOP) {
+			button = 2;
+		}
+		return this->getString(preamble, one, zero, button);
+	} else if (TelldusCore::comparei(model(), L"ecosavers")) {
+		std::string preamble;
+		preamble.append(1, 0x25);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 255);
+		preamble.append(1, 1);
+		preamble.append(1, 0x25);
+		const std::string one = "\x69\25";
+		const std::string zero = "\x25\x69";
+		int intUnit = this->getIntParameter(L"unit", 1, 4);
+		int button = 0;
+		if (intUnit == 1) {
+			button = 7;
+		} else if (intUnit == 2) {
+			button = 3;
+		} else if (intUnit == 3) {
+			button = 5;
+		} else if (intUnit == 4) {
+			button = 6;
+		}
+
+		if (method == TELLSTICK_TURNON || method == TELLSTICK_LEARN) {
+			button |= 8;
+		}
+		return this->getString(preamble, one, zero, button);
+	}
+	return "";
+}
+
+std::string ProtocolSilvanChip::getString(const std::string &preamble, const std::string &one, const std::string &zero, int button) {
+	int intHouse = this->getIntParameter(L"house", 1, 1048575);
+	std::string strReturn = preamble;
+
+	for( int i = 19; i >= 0; --i ) {
+		if (intHouse & (1 << i)) {
+			strReturn.append(one);
+		} else {
+			strReturn.append(zero);
+		}
+	}
+
+	for( int i = 3; i >= 0; --i) {
+		if (button & (1 << i)) {
+			strReturn.append(one);
+		} else {
+			strReturn.append(zero);
+		}
+	}
+
+	strReturn.append(zero);
+	return strReturn;
+}
--- a/external/tellstick-core/ProtocolSilvanChip.h
+++ b/external/tellstick-core/ProtocolSilvanChip.h
@ -0,0 +1,22 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLSILVANCHIP_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLSILVANCHIP_H_
+
+#include <string>
+#include "service/Protocol.h"
+
+class ProtocolSilvanChip : public Protocol {
+public:
+	int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+
+protected:
+	virtual std::string getString(const std::string &preamble, const std::string &one, const std::string &zero, int button);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLSILVANCHIP_H_
--- a/external/tellstick-core/ProtocolUpm.cpp
+++ b/external/tellstick-core/ProtocolUpm.cpp
@ -0,0 +1,78 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolUpm.h"
+#include <string>
+
+int ProtocolUpm::methods() const {
+	return TELLSTICK_TURNON | TELLSTICK_TURNOFF | TELLSTICK_LEARN;
+}
+
+std::string ProtocolUpm::getStringForMethod(int method, unsigned char, Controller *) {
+	const char S = ';';
+	const char L = '~';
+	const char START[] = {S, 0};
+	const char B1[] = {L, S, 0};
+	const char B0[] = {S, L, 0};
+	// const char BON[] = {S,L,L,S,0};
+	// const char BOFF[] = {S,L,S,L,0};
+
+	int intUnit = this->getIntParameter(L"unit", 1, 4)-1;
+	std::string strReturn;
+
+	int code = this->getIntParameter(L"house", 0, 4095);
+	for( size_t i = 0; i < 12; ++i ) {
+		if (code & 1) {
+			strReturn.insert(0, B1);
+		} else {
+			strReturn.insert(0, B0);
+		}
+		code >>= 1;
+	}
+	strReturn.insert(0, START);  // Startcode, first
+
+	code = 0;
+	if (method == TELLSTICK_TURNON || method == TELLSTICK_LEARN) {
+		code += 2;
+	} else if (method != TELLSTICK_TURNOFF) {
+		return "";
+	}
+	code <<= 2;
+	code += intUnit;
+
+	int check1 = 0, check2 = 0;
+	for( size_t i = 0; i < 6; ++i ) {
+		if (code & 1) {
+			if (i % 2 == 0) {
+				check1++;
+			} else {
+				check2++;
+			}
+		}
+		if (code & 1) {
+			strReturn.append(B1);
+		} else {
+			strReturn.append(B0);
+		}
+		code >>= 1;
+	}
+
+	if (check1 % 2 == 0) {
+		strReturn.append(B0);
+	} else {
+		strReturn.append(B1);
+	}
+	if (check2 % 2 == 0) {
+		strReturn.append(B0);
+	} else {
+		strReturn.append(B1);
+	}
+
+	strReturn.insert(0, "S");
+	strReturn.append("+");
+	return strReturn;
+}
+
--- a/external/tellstick-core/ProtocolUpm.h
+++ b/external/tellstick-core/ProtocolUpm.h
@ -0,0 +1,19 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLUPM_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLUPM_H_
+
+#include <string>
+#include "service/Protocol.h"
+
+class ProtocolUpm : public Protocol {
+public:
+	int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLUPM_H_
--- a/external/tellstick-core/ProtocolWaveman.cpp
+++ b/external/tellstick-core/ProtocolWaveman.cpp
@ -0,0 +1,77 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolWaveman.h"
+#ifdef _MSC_VER
+#else
+#include <stdint.h>
+#endif
+#include <stdio.h>
+#include <sstream>
+#include <string>
+
+int ProtocolWaveman::lastArctecCodeSwitchWasTurnOff = 0;
+
+int ProtocolWaveman::methods() const {
+	return TELLSTICK_TURNON | TELLSTICK_TURNOFF;
+}
+
+std::string ProtocolWaveman::getStringForMethod(int method, unsigned char, Controller *) {
+	return getStringCodeSwitch(method);
+}
+
+std::string ProtocolWaveman::getOffCode() const {
+	return "$k$k$k$k$k$k$k$k$k+";
+}
+
+std::string ProtocolWaveman::decodeData(const ControllerMessage& dataMsg) {
+	uint64_t allData = 0;
+	unsigned int house = 0;
+	unsigned int unit = 0;
+	unsigned int method = 0;
+
+	allData = dataMsg.getInt64Parameter("data");
+
+	method = allData & 0xF00;
+	method >>= 8;
+
+	unit = allData & 0xF0;
+	unit >>= 4;
+	unit++;
+
+	house = allData & 0xF;
+
+	if(house > 16 || unit < 1 || unit > 16) {
+		// not waveman
+		return "";
+	}
+
+	house = house + 'A';  // house from A to P
+
+	if(method != 6 && lastArctecCodeSwitchWasTurnOff == 1) {
+		lastArctecCodeSwitchWasTurnOff = 0;
+		return "";  // probably a stray turnon or bell	(perhaps: only certain time interval since last, check that it's the same house/unit... Will lose
+						// one turnon/bell, but it's better than the alternative...
+	}
+
+	if(method == 6) {
+		lastArctecCodeSwitchWasTurnOff = 1;
+	}
+
+	std::stringstream retString;
+	retString << "class:command;protocol:waveman;model:codeswitch;house:" << static_cast<char>(house);
+
+	if(method == 0) {
+		retString << ";unit:" << unit << ";method:turnoff;";
+	} else if(method == 14) {
+		retString << ";unit:" << unit << ";method:turnon;";
+	}	else {
+		// not waveman
+		return "";
+	}
+
+	return retString.str();
+}
--- a/external/tellstick-core/ProtocolWaveman.h
+++ b/external/tellstick-core/ProtocolWaveman.h
@ -0,0 +1,26 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLWAVEMAN_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLWAVEMAN_H_
+
+#include <string>
+#include "service/ProtocolNexa.h"
+
+class ProtocolWaveman : public ProtocolNexa {
+public:
+	int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+	static std::string decodeData(const ControllerMessage &dataMsg);
+
+protected:
+	virtual std::string getOffCode() const;
+
+private:
+	static int lastArctecCodeSwitchWasTurnOff;
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLWAVEMAN_H_
--- a/external/tellstick-core/ProtocolX10.cpp
+++ b/external/tellstick-core/ProtocolX10.cpp
@ -0,0 +1,185 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include "service/ProtocolX10.h"
+#ifdef _MSC_VER
+#else
+#include <stdint.h>
+#endif
+#include <stdio.h>
+#include <sstream>
+#include <string>
+
+const unsigned char HOUSES[] = {6, 0xE, 2, 0xA, 1, 9, 5, 0xD, 7, 0xF, 3, 0xB, 0, 8, 4, 0xC};
+
+int ProtocolX10::methods() const {
+	return TELLSTICK_TURNON | TELLSTICK_TURNOFF;
+}
+
+std::string ProtocolX10::getStringForMethod(int method, unsigned char data, Controller *controller) {
+	const unsigned char S = 59, L = 169;
+	const char B0[] = {S, S, 0};
+	const char B1[] = {S, L, 0};
+	const unsigned char START_CODE[] = {'S', 255, 1, 255, 1, 255, 1, 100, 255, 1, 180, 0};
+	const unsigned char STOP_CODE[] = {S, 0};
+
+	std::string strReturn = reinterpret_cast<const char*>(START_CODE);
+	std::string strComplement = "";
+
+	std::wstring strHouse = getStringParameter(L"house", L"A");
+	int intHouse = strHouse[0] - L'A';
+	if (intHouse < 0) {
+		intHouse = 0;
+	} else if (intHouse > 15) {
+		intHouse = 15;
+	}
+	// Translate it
+	intHouse = HOUSES[intHouse];
+	int intCode = getIntParameter(L"unit", 1, 16)-1;
+
+	for( int i = 0; i < 4; ++i ) {
+		if (intHouse & 1) {
+			strReturn.append(B1);
+			strComplement.append(B0);
+		} else {
+			strReturn.append(B0);
+			strComplement.append(B1);
+		}
+		intHouse >>= 1;
+	}
+	strReturn.append( B0 );
+	strComplement.append( B1 );
+
+	if (intCode >= 8) {
+		strReturn.append(B1);
+		strComplement.append(B0);
+	} else {
+		strReturn.append(B0);
+		strComplement.append(B1);
+	}
+
+	strReturn.append( B0 );
+	strComplement.append( B1 );
+	strReturn.append( B0 );
+	strComplement.append( B1 );
+
+	strReturn.append( strComplement );
+	strComplement = "";
+
+	strReturn.append( B0 );
+	strComplement.append( B1 );
+
+	if (intCode >> 2 & 1) {  // Bit 2 of intCode
+		strReturn.append(B1);
+		strComplement.append(B0);
+	} else {
+		strReturn.append(B0);
+		strComplement.append(B1);
+	}
+
+	if (method == TELLSTICK_TURNON) {
+		strReturn.append(B0);
+		strComplement.append(B1);
+	} else if (method == TELLSTICK_TURNOFF) {
+		strReturn.append(B1);
+		strComplement.append(B0);
+	} else {
+		return "";
+	}
+
+	if (intCode & 1) {  // Bit 0 of intCode
+		strReturn.append(B1);
+		strComplement.append(B0);
+	} else {
+		strReturn.append(B0);
+		strComplement.append(B1);
+	}
+
+	if (intCode >> 1 & 1) {  // Bit 1 of intCode
+		strReturn.append(B1);
+		strComplement.append(B0);
+	} else {
+		strReturn.append(B0);
+		strComplement.append(B1);
+	}
+
+	for( int i = 0; i < 3; ++i ) {
+		strReturn.append( B0 );
+		strComplement.append( B1 );
+	}
+
+	strReturn.append( strComplement );
+	strReturn.append( reinterpret_cast<const char*>(STOP_CODE) );
+	strReturn.append("+");
+	return strReturn;
+}
+
+std::string ProtocolX10::decodeData(const ControllerMessage& dataMsg) {
+	uint64_t intData = 0, currentBit = 31;
+	bool method = 0;
+
+	intData = dataMsg.getInt64Parameter("data");
+
+	int unit = 0;
+	int rawHouse = 0;
+	for(int i = 0; i < 4; ++i) {
+		rawHouse >>= 1;
+		if (checkBit(intData, currentBit--)) {
+			rawHouse |= 0x8;
+		}
+	}
+
+	if (checkBit(intData, currentBit--) != 0) {
+		return "";
+	}
+
+	if (checkBit(intData, currentBit--)) {
+		unit |= (1<<3);
+	}
+
+	if (checkBit(intData, currentBit--)) {
+		return "";
+	}
+	if (checkBit(intData, currentBit--)) {
+		return "";
+	}
+
+	currentBit = 14;
+
+	if (checkBit(intData, currentBit--)) {
+		unit |= (1<<2);
+	}
+	if (checkBit(intData, currentBit--)) {
+		method = 1;
+	}
+	if (checkBit(intData, currentBit--)) {
+		unit |= (1<<0);
+	}
+	if (checkBit(intData, currentBit--)) {
+		unit |= (1<<1);
+	}
+
+	int intHouse = 0;
+	for(int i = 0; i < 16; ++i) {
+		if (HOUSES[i] == rawHouse) {
+			intHouse = i;
+			break;
+		}
+	}
+
+	std::stringstream retString;
+	retString << "class:command;protocol:x10;model:codeswitch;";
+	retString << "house:" << static_cast<char>('A' + intHouse);
+	retString << ";unit:" << unit+1;
+	retString << ";method:";
+	if (method == 0) {
+		retString << "turnon;";
+	} else {
+		retString << "turnoff;";
+	}
+
+	return retString.str();
+}
--- a/external/tellstick-core/ProtocolX10.h
+++ b/external/tellstick-core/ProtocolX10.h
@ -0,0 +1,22 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLX10_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLX10_H_
+
+#include <string>
+#include "service/Protocol.h"
+#include "service/ControllerMessage.h"
+
+class ProtocolX10 : public Protocol {
+public:
+	int methods() const;
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+
+	static std::string decodeData(const ControllerMessage &dataMsg);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLX10_H_
--- a/external/tellstick-core/ProtocolYidong.cpp
+++ b/external/tellstick-core/ProtocolYidong.cpp
@ -0,0 +1,31 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#include <string>
+#include "service/ProtocolYidong.h"
+
+std::string ProtocolYidong::getStringForMethod(int method, unsigned char, Controller *) {
+	int intCode = this->getIntParameter(L"unit", 1, 4);
+	std::wstring strCode = L"111";
+
+	switch(intCode) {
+	case 1:
+		strCode.append(L"0010");
+		break;
+	case 2:
+		strCode.append(L"0001");
+		break;
+	case 3:
+		strCode.append(L"0100");
+		break;
+	case 4:
+		strCode.append(L"1000");
+		break;
+	}
+
+	strCode.append(L"110");
+	return getStringForCode(strCode, method);
+}
--- a/external/tellstick-core/ProtocolYidong.h
+++ b/external/tellstick-core/ProtocolYidong.h
@ -0,0 +1,18 @@
+//
+// Copyright (C) 2012 Telldus Technologies AB. All rights reserved.
+//
+// Copyright: See COPYING file that comes with this distribution
+//
+//
+#ifndef TELLDUS_CORE_SERVICE_PROTOCOLYIDONG_H_
+#define TELLDUS_CORE_SERVICE_PROTOCOLYIDONG_H_
+
+#include <string>
+#include "service/ProtocolSartano.h"
+
+class ProtocolYidong : public ProtocolSartano {
+public:
+	virtual std::string getStringForMethod(int method, unsigned char data, Controller *controller);
+};
+
+#endif  // TELLDUS_CORE_SERVICE_PROTOCOLYIDONG_H_
--- a/external/tellstick-core/README.txt
+++ b/external/tellstick-core/README.txt
@ -0,0 +1,30 @@
+This is Telldus Core version {version}
+
+Telldus Core is the driver and tools for controlling a Telldus Technologies
+TellStick. It does not containing any GUI tools which makes it suitable for
+server use.
+
+
+INSTALLING Telldus Core
+
+On Windows, if you want to install the precompiles binary packages, simply
+launch the package and follow the instructions in the installation wizard.
+
+If you have a source package (a .tar.gz file), follow the instruction in the
+INSTALL file.
+
+
+CONFIGURATION AND TOOLS
+
+Once Telldus Core is installed, we suggest that you start by adding the devices
+you want to control.
+
+On Windows, this is done by installing TelldusCenter. On Linux it's done by
+editing the file /etc/tellstick.conf directly, or in TelldusCenter.
+
+Telldus Core installs the tool tdtool for controlling devices with TellStick.
+Have a look in the man page for a description how to use it:
+
+	man tdtool
+
+TellStick is a trademark of Telldus Technologies AB
--- a/external/tellstick-driver/SerialDriver_Windows/Static/amd64/ftd2xx.lib
+++ b/external/tellstick-driver/SerialDriver_Windows/Static/amd64/ftd2xx.lib
--- a/external/tellstick-driver/SerialDriver_Windows/Static/i386/ftd2xx.lib
+++ b/external/tellstick-driver/SerialDriver_Windows/Static/i386/ftd2xx.lib
--- a/external/tellstick-driver/SerialDriver_Windows/amd64/ftbusui.dll
+++ b/external/tellstick-driver/SerialDriver_Windows/amd64/ftbusui.dll
--- a/external/tellstick-driver/SerialDriver_Windows/amd64/ftcserco.dll
+++ b/external/tellstick-driver/SerialDriver_Windows/amd64/ftcserco.dll
--- a/external/tellstick-driver/SerialDriver_Windows/amd64/ftd2xx.lib
+++ b/external/tellstick-driver/SerialDriver_Windows/amd64/ftd2xx.lib
--- a/external/tellstick-driver/SerialDriver_Windows/amd64/ftd2xx64.dll
+++ b/external/tellstick-driver/SerialDriver_Windows/amd64/ftd2xx64.dll
--- a/external/tellstick-driver/SerialDriver_Windows/amd64/ftdibus.sys
+++ b/external/tellstick-driver/SerialDriver_Windows/amd64/ftdibus.sys
--- a/external/tellstick-driver/SerialDriver_Windows/amd64/ftlang.dll
+++ b/external/tellstick-driver/SerialDriver_Windows/amd64/ftlang.dll
--- a/external/tellstick-driver/SerialDriver_Windows/amd64/ftser2k.sys
+++ b/external/tellstick-driver/SerialDriver_Windows/amd64/ftser2k.sys
--- a/external/tellstick-driver/SerialDriver_Windows/amd64/ftserui2.dll
+++ b/external/tellstick-driver/SerialDriver_Windows/amd64/ftserui2.dll
--- a/external/tellstick-driver/SerialDriver_Windows/dpinst-amd64.exe
+++ b/external/tellstick-driver/SerialDriver_Windows/dpinst-amd64.exe
--- a/external/tellstick-driver/SerialDriver_Windows/dpinst-x86.exe
+++ b/external/tellstick-driver/SerialDriver_Windows/dpinst-x86.exe
--- a/Show more
+++ b/Show more
				`@ -0,0 +1 @@`
				`Subproject commit 5fd5429375b3fffbf0bdd041d493d5c6ff0c156a`