Skip to content
December 28, 2013 / lasseathome

Decoding NEXA remotes with TellStick Duo

This is an investigation that I have done in order to decode my remote controllers. The purpose is to understand the remote so that I later can control, supervise, and synchronize my switches inside the house when using my TellStick Duo on my Raspberry Pi. In particular I want my Raspberry Pi to be aware of the button presses on my remotes

The remotes that were tested and read.

The remotes that were tested and decoded.

Prerequisites – Hardware/software

Hardware is a TellStick Duo with two different NEXA remotes and one prove, shown in the image above and detailed in the list below.

  • NEXA NEYCT-705, normal remote with 10 buttons (four groups with on and off buttons and one general pair on/off button) and a group switch that allows to switch between four groups.
  • NEXA KCT-510, small keyring remote, with one pair of buttons marked 1 and 0.
  • proove EVT0006, 8 buttons divided into 4 groups with on and off (the first three are numbered 1-3 and the last group has black buttons and is labelled G).

On the software side there is the

  • telldus-core packages and
  • the nice python wrappers tdtool.py with td.py.
  • During the decoding and development I run this on a Linux Mint box, but this description is generic and it could be performed on RPi, Mac or Windows systems too.

The installation and setup is shown in a previous blog.

Decoding the KCT-510

This is the decoding of the signal from the small key ring remote control. On the selector at the back the remote is set to house A and unit 1. To do the decoding I run the following command in the command line and then press the button 1 and 0 on the remote. The results show that the remote sends the same message 7 times for each button press. The tdtool software recognizes both an arctech and waveman from it, with house A and unit 1 as it is set, it also seems to detect a sartano switch too.

> python tdtool.py -t
protocol:arctech;model:codeswitch;house:A;unit:1;method:turnon;
protocol:waveman;model:codeswitch;house:A;unit:1;method:turnon;
+++++   The two lines above are repeated in total 7 times ++++
protocol:arctech;model:codeswitch;house:A;unit:1;method:turnoff;
protocol:sartano;model:codeswitch;code:1111111110;method:turnoff;
+++++   The two lines above are repeated in total 7 times ++++

The sending is not consistent between on and off. When turning on there is waveman interleaved with arctec and at turning off there is sartano interleaved with arctec. This is not consistent and I have no supported hypothesis but one unsupported hypthesis about the reason. The commands sent arrive very tight in time and all are not properly received and handled so that all of them do not reach the python callback script and in the end the output.

Anyway I now know how I can use the configuration file telldus.conf to supervise and detect the usage of the keychain remote.

Decoding the NEYCT-705

Now I apply the same command python tdtool.py -t and decode the NEYCT-705.

protocol:arctech;model:selflearning;house:1642810;unit:1;group:0;method:turnon;
protocol:sartano;model:codeswitch;code:1111011010;method:turnon;
protocol:everflourish;model:selflearning;house:8210;unit:3;method:turnoff;
++++ Above transmitted 5 times ++++

protocol:arctech;model:selflearning;house:1642810;unit:1;group:0;method:turnoff;
protocol:sartano;model:codeswitch;code:1111111010;method:turnon;
protocol:everflourish;model:selflearning;house:8210;unit:3;method:turnoff;
++++ Above transmitted 5 times ++++
  • For every keypress it emitts 5 messages. The messages are interleaving with model names: arctec, sartano, and everflorish.
  • The message which is most important for the NEXA system is the arctech:
    protocol:arctech;model:selflearning;
    house:1642810;unit:1;group:0;method:turnon;
    This shows the house code the unit code and the group information that later will go into the telldus.conf file.
  • Further button presses reveals the following
    • All normal buttons have group:0, the unit goes from 1 to 16. With the switch in position I the unit goes from 1 to 4, with position II unit goes from 5 to 8, etc.
    • The special G buttons have group:1 and unit:1.

Decoding the proove EWT0006

The same command python tdtool.py -t is applied to decode the proove EWT0006. The following sequence of commands are received by first pressing the on button and then the off button. All groups are also traversed to go the the G.

protocol:arctech;model:selflearning;house:30891002;unit:16;group:0;method:turnon;
protocol:waveman;model:codeswitch;house:P;unit:10;method:turnon;
protocol:everflourish;model:selflearning;house:13759;unit:3;method:turnon;
+++ The lines above are repeated 6 times +++

protocol:arctech;model:selflearning;house:30891002;unit:16;group:0;method:turnoff;
protocol:waveman;model:codeswitch;house:P;unit:9;method:turnon;
protocol:everflourish;model:selflearning;house:13759;unit:3;method:turnon;
+++ The lines above are repeated 6 times +++
  • Every button press gives 6 messages, with arctec, waveman, and everflourish interleaved.
  • The most important part for controlling NEXA switches is:
    protocol:arctech;model:selflearning;
    house:30891002;unit:16;group:0;method:turnon;
  • The button presses result in the following.
    • Buttons numbered 1 (on and off) are connected to unit 16, buttons numbered 2 to unit 15, and 3 to 14. All of these have group 0.
    • Buttons at position 4, labelled G, are connected to unit 16 but with group 1.

Synchronizing the remote and tdtool

The telldus-core software synchronizes out of the box with the remote as long as the configuration file and the remote are consistent. Based on the information above it is now easy to build the telldus.conf file so that the tdtool and other software is in sync with the remote control.

device {
  id = 1
  name = "I-1: Kitchen"
  protocol = "arctech"
  model = "selflearning-switch"
  parameters {
    house = "1642810"
    unit = "1"
  }
}
device {
  id = 2
  name = "I-2: Bedroom"
  protocol = "arctech"
  model = "selflearning-switch"
  parameters {
    house = "1642810"
    unit = "2"
  }
}
device {
  id = 5
  name = "II-1: Dimmer"
  protocol = "arctech"
  model = "selflearning-dimmer"
  parameters {
    house = "1642810"
    unit = "5"
  }
}
device {
  id = 100
  name = "Outdoor"
  protocol = "arctech"
  model = "codeswitch"
  parameters {
    house = "A"
    unit = "1"
  }
}

With this I am now able to control the switches with the remotes and have my telldus system in sync with the rest of the system. One reason for doing all this is that I can now see the status of the NEXA switches in my small web application where I also can control the switches.

Advertisements

2 Comments

Leave a Comment
  1. Tobias / Aug 23 2014 7:01 am

    Thanks for these tips! They just saved me a lot of hassle.

  2. tony / Jan 31 2017 10:05 am

    On my installation of the tellstick duo, the python wrapper appears to have changed from tdtool.py to just tdtool. Also the -t option seems to have disappeared. It took a while but I eventually found “/usr/local/bin/tellcore_events” and got the same output using the “–raw” parameter.

    On my version I have also added a –daemon option that calls a webpage based on the device that is turned on or off allowing me to control non-nexa (lightwaverf) devices with a Nexa remote and/or wall switch

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: