Go Down

Topic: rf433 code for ELRO Flamingo home devices (FA500) (Read 34255 times) previous topic - next topic

Karl-Heinz

#15
Jan 18, 2015, 11:02 pm Last Edit: Feb 15, 2015, 08:43 pm by Karl-Heinz
Hello,
I had a look at the code above and managed to write a sketch that prints the 28Bit codes of your remote control. As a start I had a look at the RCSwitch library to find out how the interuptHandler finds the start of the telegrams. Then the library is also able to send the codes which is very similar RCSwitch does. In the end I think this could be protocol 4 of the RCSwitch lib in future  :)

Everytime you push a button on your remote control the code is printed in the following way:

Code: [Select]

Code: 0x24613E20 (28Bit) Binary: 0010010001100001001111100010 PulseLength: 330 microseconds
Raw data: 4988,292,1016,292,1020,936,372,284,1020,288,1032,928,372,284,1024,284,1024,284,1024,936,372,932,296,216,296,216,1320,216,1316,216,304,1320,216,1316,220,292,220,292,220,1320,216,292,1312,220,288,224,1312,228,284,224,1316,1312,228,288,220,1316,220,




Btw I think that you misinterpreted what's Bit 1 and Bit 0:
- Bit 0 is 1 pulse HIGH and 3 pulses LOW
- Bit 1 is 3 pulses HIGH and 1 pulse LOW
but that didn't matter as your send routine simply did the same mistake leading to the right waveform again. (See also send1() and send0() routines in the RCSwitch lib).


Using audacity to analyze the waveforms you can see that the remote control sends:
- 4 times a 28Bit code
- 6 times (unknown code)
- 6 times a 24Bit code
The last one is printed by the RCSwitch library but this one does not work with the switches. The right one is the first one which is printed by my program. I don't know why the remote control sends 3 different codes, probably it is able to support 3 different switch-models.

The lib can be found here
https://github.com/windkh/flamingoswitch

Thank you all for your effort it helped me alot.

Karl-Heinz

In germany you can buy the switches from mumbi m-FS300

wex_storm

#17
Feb 21, 2015, 09:45 pm Last Edit: Feb 22, 2015, 11:17 am by wex_storm
Hello everybody.

MANY MANY thanks for your Sketches. I also bought some new "mumbi m-FS300" remote plugs in Germany. They also do not have those little switches to set them up.
3 evenings of testing now and I found a reliable and stabel solution to drive the switches:
1. You have to send 3 of 4 commands (yes I tested it!) from the sketch for turning one device on/off (not one single send-command)
2. To get these 4 commands, you can use the sketch attached at the bottom
3. You then - and that was my goal - can drive the plugs via RCSwitch (with the changes from FlamingoSwitch - THANKS for that!!!) also attached at the bottom (you have to add a 4th protocol)

To get all 4 commands for one device (on or off) - you have to push the button often, so that all 4 commands are shown in the Serial Monitor while playing the Sketch from the attached archive.

Edited RCSwitch.cpp in the archive, so that you can send commands like:
Code: [Select]
mySwitch.setProtocol(4);
         mySwitch.setRepeatTransmit(1);
        mySwitch.setPulseLength(300);
        mySwitch.send("0010011011100001011110011001");
        mySwitch.send("0010011101011111101011111001");
        mySwitch.send("0010011010011111010011000101");
        mySwitch.send("0010011010011000100010010001");
        delay(500);



I hope this helps some of you not to also spend some evenings with this stuff :)

One sad point: powering off does not always work - I don't know why... perhaps ou have a clue.

EDIT: When setting the pulseLength to 220 also shutting off works. I think that's the parameter, which everybody has to find out for themselves.

Greetings
   Wex

Karl-Heinz

The pulse length is around 300... I wonder that 220 also works.
I noticed that sending one code also works very well. Probably this depends on how you teached the switches. Nice to hear that you made progress...
Should I ad your changes to the flamingo repository?

renard-ad

Hello guys, thanks for your precious information. I made some measurements and hope that the following will help (if so, let me know !).

My goal isn't to control plugs but to create kind of plugs controlled by the remote I bought.

I mesure thanks to an Ikalogic digital analyser directly on the remote, to avoid external disturbance.

1 frame = 4+6+6 blocs that I'll call A,B,C

A bloc: 4 times a 28 bit code
B bloc: 6 times a 32 bit code
C bloc: 6 times a 24 bit code

Given your comments, each bloc may refer to a bunch of reveiver models. Each would only interpret the bloc of the frame that is interesting for it.
At the moment, I didn't confirm the lines bellow by generating such frames and controlling the plug reacts. So I can't tell if all A, B and C blocs are needed.

---- A bloc ----

Sync : 1 pulse High, 15 pulse Low
1 : HLLL
0 : HHHL
Length of a pulse : 326 to 328µs

The A bloc is a 4 times repetition of the same 28 bit code (ex : A1A1A1A1).
If I push many times the button, the code will be A1, then A2, then A3, etc and it rolls back to A1.
The A1 code is the one I have after powering on the remote.

Bellow, spaces intend to show similar parts in codes.

A codes (28 bits) for Aon :
A1 : s001001 11010001001001000111 10
A2 : s001001 01100011000101111101 10
A3 : s001001 11001011111001111000 10
A4 : s001001 01011000010010110101 10

A codes (28 bits) for Aoff :
A1 : s001001 00010011100010100001 10
A2 : s001001 00011010001011001110 10
A3 : s001001 00001101101100110110 10
A4 : s001001 01010010111110000011 10

A codes (28 bits) for Bon :
A1 : s001001 11011010100011110001 01
A2 : s001001 11010010111000010100 01
A3 : s001001 11011011111111000110 01
A4 : s001001 00011011000110101110 01

A codes (28 bits) for Boff :
A1 : s001001 11011110010011001010 01
A2 : s001001 01100001111001100111 01
A3 : s001001 10110101000000100101 01
A4 : s001001 10110100110111110011 01

A codes (28 bits) for Con :
A1 : s111001 10011011010111000100 01
A2 : s111001 11001101101001000110 01
A3 : s111001 01111011001101101100 01
A4 : s111001 00011100010101001110 01

A codes (28 bits) for Coff :
A1 : s111001 10010101011101101101 01
A2 : s111001 11001010110011110101 01
A3 : s111001 11000011001100110011 01
A4 : s111001 01100110111011110111 01

A codes (28 bits) for Don :
A1 : s011001 10001110000101000000 10
A2 : s011001 10100000010010010001 10
A3 : s011001 10100011110110011010 10
A4 : s011001 01011110010101110110 10

A codes (28 bits) for Doff :
A1 : s011001 10010001000110001110 10
A2 : s011001 00110010010001111100 10
A3 : s011001 10101111011001100010 10
A4 : s011001 00010110010010001101 10

Possible interpretation would be :
[6 bits address][20 bits for not understood command][2 bits maybe for something like row / column stuff]
It would be great to discover how the mysterious parts are generated
About the address part, I saw in this forum thread that another user has the same. This could be a coincidence or just a synchronisation preamble.

---- Bloc B ----

Sync : 1 pulse High, 40 pulses Low, then 1 pulse High and 10 pulse Low
0 : HLHLLLLL
1 : HLLLLLHL
Length of a pulse : 255µs

The B bloc is a 6 times repetition of the same 32 bit code (ex : BBBBBB).
If I push many times the button, it is always the same code that is sent.

Bellow, spaces intend to show similar parts in codes.

B code (32 bits) for Aon  : s000010100110101000000000100 1 00 00
B code (32 bits) for Aoff : s000010100110101000000000100 0 00 00
B code (32 bits) for Bon  : s000010100110101000000000100 1 00 01
B code (32 bits) for Boff : s000010100110101000000000100 0 00 01
B code (32 bits) for Con  : s000010100110101000000000100 1 00 10
B code (32 bits) for Coff : s000010100110101000000000100 0 00 10
B code (32 bits) for Don  : s000010100110101000000000100 1 00 11
B code (32 bits) for Doff : s000010100110101000000000100 0 00 11

The obvious interpretation would be :
[29 bits address (and sync preamble ?)][On 1/Off 0][00][Button number 0 to 3]
The "00" might be the extension of the button number so that it is not only 0 to 3 but 0 to 15 buttons available.

---- C bloc ----
Similar to A bloc.

Sync : 1 pulse High, 30 pulses Low
1 : HLLL
0 : HHHL
Length of a pulse : 326 to 328µs

The C bloc is a 6 times repetition of the same 24 bit code (ex : CCCCCC).
If I push many times the button, it is always the same code that is sent.

Bellow, spaces intend to show similar parts in codes.

C code (24 bits) for Aon  : s00010101000 00001 0001010 1
C code (24 bits) for Aoff : s00010101000 00001 0001010 0
C code (24 bits) for Bon  : s00010101000 00100 0001010 1
C code (24 bits) for Boff : s00010101000 00100 0001010 0
C code (24 bits) for Con  : s00010101000 00101 0001010 1
C code (24 bits) for Coff : s00010101000 00101 0001010 0
C code (24 bits) for Don  : s00010101000 10000 0001010 1
C code (24 bits) for Doff : s00010101000 10000 0001010 0

The obvious interpretation would be :
[11 bits address (and/or sync preamble ?)][5 bits for not understood button identification, except that the binary value increases][7 more bits for address (group ?)][On 1/Off 0]

-----------
I would be very happy if you post your own codes, so that we might perform better code interpretation.

Please leave a comment if anything helped or if you've got an idea.

Atb

renArD



Karl-Heinz

I only have the 28Bit codes of my remote control at hand:

0x24DC206, 0x267C51A, 0x25C90CE, 0x277193A  // (28Bit) A OFF
0x25B25B6, 0x24613E2, 0x27263DE, 0x24E77D6  // (28Bit) A ON

0x275BADD, 0x26933A9, 0x27F3115, 0x2440F0D  // (28Bit) B OFF
0x2717B51, 0x2547C99, 0x26585B9, 0x259A085  // (28Bit) B ON

0xE4936D5, 0xE73720D, 0xE616D1D, 0xE4D49F5  // (28Bit) C OFF
0xE56BF91, 0xE56EB71, 0xE62AF39, 0xE4FBCD9   // (28Bit) C ON

0x65B67B6, 0x64C8BFA, 0x6504C32, 0x6526F4A  // (28Bit) D OFF
0x65F1C2A, 0x670319A, 0x65E1942, 0x643F986   // (28Bit) D ON

Binary:
A OFF
0x24DC206 --> 1001 00110111000010000001 10
0x267C51A --> 1001 10011111000101000110 10
0x25C90CE --> 1001 01110010010000110011 10
0x277193A --> 1001 11011100011001001110 10

A ON
0x25B25B6 --> 1001 01101100100101101101 10
0x24613E2 --> 1001 00011000010011111000 10
0x27263DE --> 1001 11001001100011110111 10
0x24E77D6 --> 1001 00111001110111110101 10

The first 4 bits are probably an address for the Button (A = 1001) here.




renard-ad

Thanks Karl for this contribution !
I compared your codes to mine (in binary). Here is the comparison (Let's copy it to notepad to have it perfectly aligned)

A codes (28 bits) for Aon :
me  A1 : s001001 11010001001001000111 10
you A1 : s001001 01101100100101101101 10
me  A2 : s001001 01100011000101111101 10
you A2 : s001001 00011000010011111000 10
me  A3 : s001001 11001011111001111000 10
you A3 : s001001 11001001100011110111 10
me  A4 : s001001 01011000010010110101 10
you A4 : s001001 00111001110111110101 10

A codes (28 bits) for Aoff :
me  A1 : s001001 00010011100010100001 10
you A1 : s001001 00110111000010000001 10
me  A2 : s001001 00011010001011001110 10
you A2 : s001001 10011111000101000110 10
me  A3 : s001001 00001101101100110110 10
you A3 : s001001 01110010010000110011 10
me  A4 : s001001 01010010111110000011 10
you A4 : s001001 11011100011001001110 10

A codes (28 bits) for Bon :
me  A1 : s001001 11011010100011110001 01
you A1 : s001001 11000101111011010100 01
me  A2 : s001001 11010010111000010100 01
you A2 : s001001 01010001111100100110 01
me  A3 : s001001 11011011111111000110 01
you A3 : s001001 10010110000101101110 01
me  A4 : s001001 00011011000110101110 01
you A4 : s001001 01100110100000100001 01

A codes (28 bits) for Boff :
me  A1 : s001001 11011110010011001010 01
you A1 : s001001 11010110111010110111 01
me  A2 : s001001 01100001111001100111 01
you A2 : s001001 10100100110011101010 01
me  A3 : s001001 10110101000000100101 01
you A3 : s001001 11111100110001000101 01
me  A4 : s001001 10110100110111110011 01
you A4 : s001001 00010000001111000011 01

A codes (28 bits) for Con :
me  A1 : s111001 10011011010111000100 01
you A1 : s111001 01011010111111100100 01
me  A2 : s111001 11001101101001000110 01
you A2 : s111001 01011011101011011100 01
me  A3 : s111001 01111011001101101100 01
you A3 : s111001 10001010101111001110 01
me  A4 : s111001 00011100010101001110 01
you A4 : s111001 00111110111100110110 01

A codes (28 bits) for Coff :
me  A1 : s111001 10010101011101101101 01
you A1 : s111001 00100100110110110101 01
me  A2 : s111001 11001010110011110101 01
you A2 : s111001 11001101110010000011 01
me  A3 : s111001 11000011001100110011 01
you A3 : s111001 10000101101101000111 01
me  A4 : s111001 01100110111011110111 01
you A4 : s111001 00110101001001111101 01

A codes (28 bits) for Don :
me  A1 : s011001 10001110000101000000 10
you A1 : s011001 01111100011100001010 10
me  A2 : s011001 10100000010010010001 10
you A2 : s011001 11000000110001100110 10
me  A3 : s011001 10100011110110011010 10
you A3 : s011001 01111000011001010000 10
me  A4 : s011001 01011110010101110110 10
you A4 : s011001 00001111111001100001 10

A codes (28 bits) for Doff :
me  A1 : s011001 10010001000110001110 10
you A1 : s011001 01101101100111101101 10
me  A2 : s011001 00110010010001111100 10
you A2 : s011001 00110010001011111110 10
me  A3 : s011001 10101111011001100010 10
you A3 : s011001 01000001001100001100 10
me  A4 : s011001 00010110010010001101 10
you A4 : s011001 01001001101111010010 10

I again put spaces to show similar parts.

One thing interresting is to notice that your remote and mine have the same 6 bits header and 2 bits tails (so it can't be the remote address). Otherwise, I don't think that the header bits are intended to tell which button pair (A, B, C or D) had been pressed because A and B have the same header. But considering header + tail, it would be enough to recognize the button pressed.

I hope someone will post his codes so that we can try to guess how the main and curious part works.

Karl-Heinz

Good Job,
yes you are right it seems like a frame with header + "some code" + tail.
I thought that the switch needs to recognize at least 1 of the 4 codes to turn on or off. But wex_storm reported that his switches need to see at least 3 of 4 codes to turn on or off. It this is true then probably the following codes must correlate to each other.

renard-ad

Thanks !

According to my measures, only one button push is enough to switch the plug. One push will send 4 times the same code. The next push will send 4 times another code.

I think wex_storm said that in case 1 of the 4 (same) codes isn't good, there will still be 3 codes least, which seems to be the limit for the plug to consider the command (if 2 codes ok and 2 codes wrong, it doesn't switch on/off).
I wish I'll someday give it a try.

But I still think that the codes are correlated because the plug has to know that the remote configured with one push has to work with other pushs (and with other buttons !).

renard-ad

Note : I may have exchanged 1 and 0 in my codes (interpreting HLLL as 0 instead of 1).


I've almost finished my reception software. I can notice that, even if my remote sends pulses between 308 and 345µs, my RF receiver interprets them as 240 to 432µs !

As a consequence, I enlarge my receiver tolerance which is consequently more eager to false sync detections.

robwlakes

Hi folks,
Just a few thoughts on the above.  First, if it is possible to have two remotes that don't interfere and have a registering process between the remote and the switches, then it is likely that the switches have a rolling code number that is random and is initialised  When they are 'Connected'.  The code is probably determined when the batteries are first put in the transmitter, and subsequently the switches are 'taught' the code. If you remove, wait, and replace the Remote's batteries does the system fail to work? Do the switches have to be re-paired with the Remote?

The data at the beginning of the samples, before the sync section is just the Arduino+Rx stabilising to the sync pulses and the AGC is trying to find the mid way for the signal from the Remote control. I would ignore that section, I am sure the real data you are after is in the section after the synch.  The data is repeated multiple times as this is a basic way to validate the data, if same data is received say 4 times it is trusted, so it must be sent that same way from the Arduino to work the switch, not just once.

Having different data structures present in a Tx's packet may allow for different models of switches being worked by that same controller(as mentioned above).

If there is a rolling code then 'hardwired' bit patterns from one setup to another setup unlikely to work as they will have different rolling codes.  The Arduino program could be programmed to ignore that part in the bit patterns, but at the risk some other non-paired Tx may take control. A suggestion is the Arduino is given a switch that allows it to extract the rolling code from the next signal received from the Remote Control, it stores it in EEPROM and uses it as a base to make it's own transmissions. Obviously the Remote control and Switches would also need to be paired to establish the agreed rolling code.

For this suggestion Arduino would need both a Tx and Rx module.  If the remote was never to be used then just pairing the switch with the Arduino' choice of rolling code could be done and then only a Tx module would be needed.

Sorry, I apologise in advance if I have gone over old ground and contributed nothing new, R.
Learning Flute and C++, heading for a meltdown.

renard-ad

Hi robwlakes, thanks for sharing your opinion !

Quote
If you remove, wait, and replace the Remote's batteries does the system fail to work? Do the switches have to be re-paired with the Remote?
If you remove the battery and replace it, it is the same code "A1" that is sent. And the plug still works with it. The second time you push the button, it will be A2, etc.

It's the occasion to mention that the pairing process doesn't need the 4 codes of a button, neither the off button to be received. That is to say A1 or A2 or A3 or A4 of the "on" button is enough for the plug to understand all codes of this "on" button, and also all codes of the corresponding "off" button.
As a reminder, if the off button is pressed during pairing process, it tells the plug to "unpair".

Quote
The data at the beginning of the samples, before the sync section is just the Arduino+Rx stabilising to the sync pulses and the AGC is trying to find the mid way for the signal from the Remote control. I would ignore that section, I am sure the real data you are after is in the section after the synch.  The data is repeated multiple times as this is a basic way to validate the data, if same data is received say 4 times it is trusted, so it must be sent that same way from the Arduino to work the switch, not just once.
Yes, we agree that all similar parts between codes are something like synchronization or telling it is a Flamingo remote. Then the still-strange part is remote-dependant and probably button-dependant.

If I missed something please tell me.

renard-ad

#27
Apr 12, 2015, 02:08 pm Last Edit: Apr 12, 2015, 02:36 pm by renard-ad
EDIT : reorganizing some codes, we can split one more time

As I had a second remote, I decided to sniff its codes. Here is the compilation of data we have. If you have such a remote, please share your codes until a genius finds the trick to generate/understand them !

Code: [Select]
A codes (28 bits) for Aon :
renArD n°1  A1 : s001001 1101000100100100 0111 10
renArD n°2  A1 : s001001 0001010011011001 0111 10
Karl-Heinz  A1 : s001001 1100100110001111 0111 10

renArD n°1  A2 : s001001 0110001100010111 1101 10
renArD n°2  A2 : s001001 0000110011110011 1101 10
Karl-Heinz  A4 : s001001 0110110010010110 1101 10

renArD n°1  A3 : s001001 1100101111100111 1000 10
renArD n°2  A3 : s001001 0011111101001011 1000 10
Karl-Heinz  A3 : s001001 0001100001001111 1000 10

renArD n°1  A4 : s001001 0101100001001011 0101 10
renArD n°2  A4 : s001001 1101001100110101 0101 10
Karl-Heinz  A2 : s001001 0011100111011111 0101 10


A codes (28 bits) for Aoff :
renArD n°1  A1 : s001001 0001001110001010 0001 10
renArD n°2  A1 : s001001 1101111111100100 0001 10
Karl-Heinz  A1 : s001001 0011011100001000 0001 10

renArD n°1  A2 : s001001 0001101000101100 1110 10
renArD n°2  A2 : s001001 1110110111110101 1110 10
Karl-Heinz  A4 : s001001 1101110001100100 1110 10

renArD n°1  A3 : s001001 0000110110110011 0110 10
renArD n°2  A3 : s001001 1010011000111011 0110 10
Karl-Heinz  A2 : s001001 1001111100010100 0110 10

renArD n°1  A4 : s001001 0101001011111000 0011 10
renArD n°2  A4 : s001001 0100011011101001 0011 10
Karl-Heinz  A3 : s001001 0111001001000011 0011 10


A codes (28 bits) for Bon :
renArD n°1  A1 : s001001 1101101010001111 0001 01
renArD n°2  A2 : s001001 1100110110110101 0001 01
Karl-Heinz  A4 : s001001 0110011010000010 0001 01

renArD n°1  A2 : s001001 1101001011100001 0100 01
renArD n°2  A3 : s001001 0101101010001001 0100 01
Karl-Heinz  A1 : s001001 1100010111101101 0100 01

renArD n°1  A3 : s001001 1101101111111100 0110 01
renArD n°2  A4 : s001001 1111101110010101 0110 01
Karl-Heinz  A2 : s001001 0101000111110010 0110 01

renArD n°1  A4 : s001001 0001101100011010 1110 01
renArD n°2  A1 : s001001 0101010000110011 1110 01
Karl-Heinz  A3 : s001001 1001011000010110 1110 01


A codes (28 bits) for Boff :
renArD n°1  A1 : s001001 1101111001001100 1010 01
renArD n°2  A3 : s001001 1100010011100101 1010 01
Karl-Heinz  A2 : s001001 1010010011001110 1010 01

renArD n°1  A2 : s001001 0110000111100110 0111 01
renArD n°2  A4 : s001001 1011101100110000 0111 01
Karl-Heinz  A1 : s001001 1101011011101011 0111 01

renArD n°1  A3 : s001001 1011010100000010 0101 01
renArD n°2  A1 : s001001 1111101010100000 0101 01
Karl-Heinz  A3 : s001001 1111110011000100 0101 01

renArD n°1  A4 : s001001 1011010011011111 0011 01
renArD n°2  A2 : s001001 0010110101010100 0011 01
Karl-Heinz  A4 : s001001 0001000000111100 0011 01


A codes (28 bits) for Con :
renArD n°1  A1 : s111001 1001101101011100 0100 01
renArD n°2  A1 : s111001 1100000010111010 0100 01
Karl-Heinz  A1 : s111001 0101101011111110 0100 01

renArD n°1  A2 : s111001 1100110110100100 0110 01
renArD n°2  A2 : s111001 1000100010011111 0110 01
Karl-Heinz  A4 : s111001 0011111011110011 0110 01

renArD n°1  A3 : s111001 0111101100110110 1100 01
renArD n°2  A3 : s111001 0100101110001111 1100 01
Karl-Heinz  A2 : s111001 0101101110101101 1100 01

renArD n°1  A4 : s111001 0001110001010100 1110 01
renArD n°2  A4 : s111001 0000000010000001 1110 01
Karl-Heinz  A3 : s111001 1000101010111100 1110 01


A codes (28 bits) for Coff :
renArD n°1  A1 : s111001 1001010101110110 1101 01
renArD n°2  A2 : s111001 1011010011001100 1101 01
Karl-Heinz  A4 : s111001 0011010100100111 1101 01

renArD n°1  A2 : s111001 1100101011001111 0101 01
renArD n°2  A3 : s111001 1011111100010110 0101 01
Karl-Heinz  A1 : s111001 0010010011011011 0101 01

renArD n°1  A3 : s111001 1100001100110011 0011 01
renArD n°2  A4 : s111001 1100000110111011 0011 01
Karl-Heinz  A2 : s111001 1100110111001000 0011 01

renArD n°1  A4 : s111001 0110011011101111 0111 01
renArD n°2  A1 : s111001 1110011010100101 0111 01
Karl-Heinz  A3 : s111001 1000010110110100 0111 01


A codes (28 bits) for Don :
renArD n°1  A1 : s011001 1000111000010100 0000 10
renArD n°2  A1 : s011001 0110000010011010 0000 10
Karl-Heinz  A3 : s011001 0111100001100101 0000 10

renArD n°1  A2 : s011001 1010000001001001 0001 10
renArD n°2  A2 : s011001 1110111110100001 0001 10
Karl-Heinz  A4 : s011001 0000111111100110 0001 10

renArD n°1  A3 : s011001 1010001111011001 1010 10
renArD n°2  A3 : s011001 1100100010000010 1010 10
Karl-Heinz  A1 : s011001 0111110001110000 1010 10

renArD n°1  A4 : s011001 0101111001010111 0110 10
renArD n°2  A4 : s011001 0011100001110001 0110 10
Karl-Heinz  A2 : s011001 1100000011000110 0110 10


A codes (28 bits) for Doff :
renArD n°1  A1 : s011001 1001000100011000 1110 10
renArD n°2  A1 : s011001 0111100101101101 1110 10
Karl-Heinz  A2 : s011001 0011001000101111 1110 10

renArD n°1  A2 : s011001 0011001001000111 1100 10
renArD n°2  A2 : s011001 1111100011101011 1100 10
Karl-Heinz  A3 : s011001 0100000100110000 1100 10

renArD n°1  A3 : s011001 1010111101100110 0010 10
renArD n°2  A3 : s011001 1010001111000011 0010 10
Karl-Heinz  A4 : s011001 0100100110111101 0010 10

renArD n°1  A4 : s011001 0001011001001000 1101 10
renArD n°2  A4 : s011001 0101000011110010 1101 10
Karl-Heinz  A1 : s011001 0110110110011110 1101 10


As mentioned before, A1 or A2 or A3 or A4 of "on" button is enough to understand the other codes and the four "off" codes. A postal card to the one who finds the cyphering process ! ;)

Karl-Heinz

excellent work. I'm going to order a further set today... to get my hands on a new remote control. I'll post the codes as soon as they arive.

Karl-Heinz

Here are the codes for the new remote control that just arrived:


Code: [Select]

A codes (28 bits) for Aon :
renArD n°1  A1 : s001001 1101000100100100 0111 10
renArD n°2  A1 : s001001 0001010011011001 0111 10
KH     n°1  A1 : s001001 1100100110001111 0111 10
KH     n°2  A2 : s001001 0111000100110000 0111 10

renArD n°1  A2 : s001001 0110001100010111 1101 10
renArD n°2  A2 : s001001 0000110011110011 1101 10
KH     n°1  A4 : s001001 0110110010010110 1101 10
KH     n°2  A3 : s001001 1110111000100101 1101 10

renArD n°1  A3 : s001001 1100101111100111 1000 10
renArD n°2  A3 : s001001 0011111101001011 1000 10
KH     n°1  A3 : s001001 0001100001001111 1000 10
KH     n°2  A4 : s001001 1001000000111100 1000 10

renArD n°1  A4 : s001001 0101100001001011 0101 10
renArD n°2  A4 : s001001 1101001100110101 0101 10
KH     n°1  A2 : s001001 0011100111011111 0101 10
KH     n°2  A1 : s001001 1110110110100000 0101 10


A codes (28 bits) for Aoff :
renArD n°1  A1 : s001001 0001001110001010 0001 10
renArD n°2  A1 : s001001 1101111111100100 0001 10
KH     n°1  A1 : s001001 0011011100001000 0001 10
KH     n°2  A2 : s001001 0100111010110101 0001 10

renArD n°1  A2 : s001001 0001101000101100 1110 10
renArD n°2  A2 : s001001 1110110111110101 1110 10
KH     n°1  A4 : s001001 1101110001100100 1110 10
KH     n°2  A3 : s001001 0010011100110011 1110 10

renArD n°1  A3 : s001001 0000110110110011 0110 10
renArD n°2  A3 : s001001 1010011000111011 0110 10
KH     n°1  A2 : s001001 1001111100010100 0110 10
KH     n°2  A4 : s001001 1011010010010101 0110 10

renArD n°1  A4 : s001001 0101001011111000 0011 10
renArD n°2  A4 : s001001 0100011011101001 0011 10
KH     n°1  A3 : s001001 0111001001000011 0011 10
KH     n°2  A1 : s001001 0110001001010100 0011 10


A codes (28 bits) for Bon :
renArD n°1  A1 : s001001 1101101010001111 0001 01
renArD n°2  A2 : s001001 1100110110110101 0001 01
KH     n°1  A4 : s001001 0110011010000010 0001 01
KH     n°2  A3 : s001001 1010101011100100 0001 01

renArD n°1  A2 : s001001 1101001011100001 0100 01
renArD n°2  A3 : s001001 0101101010001001 0100 01
KH     n°1  A1 : s001001 1100010111101101 0100 01
KH     n°2  A4 : s001001 0101111000010000 0100 01

renArD n°1  A3 : s001001 1101101111111100 0110 01
renArD n°2  A4 : s001001 1111101110010101 0110 01
KH     n°1  A2 : s001001 0101000111110010 0110 01
KH     n°2  A1 : s001001 1001110000111011 0110 01

renArD n°1  A4 : s001001 0001101100011010 1110 01
renArD n°2  A1 : s001001 0101010000110011 1110 01
KH     n°1  A3 : s001001 1001011000010110 1110 01
KH     n°2  A2 : s001001 0000100011110101 1110 01


A codes (28 bits) for Boff :
renArD n°1  A1 : s001001 1101111001001100 1010 01
renArD n°2  A3 : s001001 1100010011100101 1010 01
KH     n°1  A2 : s001001 1010010011001110 1010 01
KH     n°2  A4 : s001001 0111001001101011 1010 01

renArD n°1  A2 : s001001 0110000111100110 0111 01
renArD n°2  A4 : s001001 1011101100110000 0111 01
KH     n°1  A1 : s001001 1101011011101011 0111 01
KH     n°2  A1 : s001001 1100100011011001 0111 01

renArD n°1  A3 : s001001 1011010100000010 0101 01
renArD n°2  A1 : s001001 1111101010100000 0101 01
KH     n°1  A3 : s001001 1111110011000100 0101 01
KH     n°2  A2 : s001001 0100101000110101 0101 01

renArD n°1  A4 : s001001 1011010011011111 0011 01
renArD n°2  A2 : s001001 0010110101010100 0011 01
KH     n°1  A4 : s001001 0001000000111100 0011 01
KH     n°2  A3 : s001001 0110100011101001 0011 01


A codes (28 bits) for Con :
renArD n°1  A1 : s111001 1001101101011100 0100 01
renArD n°2  A1 : s111001 1100000010111010 0100 01
KH     n°1  A1 : s111001 0101101011111110 0100 01
KH     n°2  A1 : s111001 1110101110010111 0100 01

renArD n°1  A2 : s111001 1100110110100100 0110 01
renArD n°2  A2 : s111001 1000100010011111 0110 01
KH     n°1  A4 : s111001 0011111011110011 0110 01
KH     n°2  A3 : s111001 1000101010010000 0110 01

renArD n°1  A3 : s111001 0111101100110110 1100 01
renArD n°2  A3 : s111001 0100101110001111 1100 01
KH     n°1  A2 : s111001 0101101110101101 1100 01
KH     n°2  A4 : s111001 1111010110110100 1100 01

renArD n°1  A4 : s111001 0001110001010100 1110 01
renArD n°2  A4 : s111001 0000000010000001 1110 01
KH     n°1  A3 : s111001 1000101010111100 1110 01
KH     n°2  A1 : s111001 0100011101001110 1110 01


A codes (28 bits) for Coff :
renArD n°1  A1 : s111001 1001010101110110 1101 01
renArD n°2  A2 : s111001 1011010011001100 1101 01
KH     n°1  A4 : s111001 0011010100100111 1101 01
KH     n°2  A3 : s111001 0001001011001010 1101 01

renArD n°1  A2 : s111001 1100101011001111 0101 01
renArD n°2  A3 : s111001 1011111100010110 0101 01
KH     n°1  A1 : s111001 0010010011011011 0101 01
KH     n°2  A4 : s111001 0011011100101010 0101 01

renArD n°1  A3 : s111001 1100001100110011 0011 01
renArD n°2  A4 : s111001 1100000110111011 0011 01
KH     n°1  A2 : s111001 1100110111001000 0011 01
KH     n°2  A1 : s111001 0001000000010101 0011 01

renArD n°1  A4 : s111001 0110011011101111 0111 01
renArD n°2  A1 : s111001 1110011010100101 0111 01
KH     n°1  A3 : s111001 1000010110110100 0111 01
KH     n°2  A2 : s111001 1000111001010011 0111 01


A codes (28 bits) for Don :
renArD n°1  A1 : s011001 1000111000010100 0000 10
renArD n°2  A1 : s011001 0110000010011010 0000 10
KH     n°1  A3 : s011001 0111100001100101 0000 10
KH     n°2  A2 : s011001 0100110101110110 0000 10

renArD n°1  A2 : s011001 1010000001001001 0001 10
renArD n°2  A2 : s011001 1110111110100001 0001 10
KH     n°1  A4 : s011001 0000111111100110 0001 10
KH     n°2  A3 : s011001 0100010011001110 0001 10

renArD n°1  A3 : s011001 1010001111011001 1010 10
renArD n°2  A3 : s011001 1100100010000010 1010 10
KH     n°1  A1 : s011001 0111110001110000 1010 10
KH     n°2  A4 : s011001 0001000100001101 1010 10

renArD n°1  A4 : s011001 0101111001010111 0110 10
renArD n°2  A4 : s011001 0011100001110001 0110 10
KH     n°1  A2 : s011001 1100000011000110 0110 10
KH     n°2  A1 : s011001 0010100010011101 0110 10


A codes (28 bits) for Doff :
renArD n°1  A1 : s011001 1001000100011000 1110 10
renArD n°2  A1 : s011001 0111100101101101 1110 10
KH     n°1  A2 : s011001 0011001000101111 1110 10
KH     n°2  A1 : s011001 0000110111110111 1110 10

renArD n°1  A2 : s011001 0011001001000111 1100 10
renArD n°2  A2 : s011001 1111100011101011 1100 10
KH     n°1  A3 : s011001 0100000100110000 1100 10
KH     n°2  A2 : s011001 1111001010000101 1100 10

renArD n°1  A3 : s011001 1010111101100110 0010 10
renArD n°2  A3 : s011001 1010001111000011 0010 10
KH     n°1  A4 : s011001 0100100110111101 0010 10
KH     n°2  A3 : s011001 0011000000100001 0010 10

renArD n°1  A4 : s011001 0001011001001000 1101 10
renArD n°2  A4 : s011001 0101000011110010 1101 10
KH     n°1  A1 : s011001 0110110110011110 1101 10
KH     n°2  A4 : s011001 1111010001011011 1101 10



Go Up