rf433 code for ELRO Flamingo home devices (FA500)

Hallo,

Has somebody already decoded the RF433 protocol for the ELRO Flamingo home devices (model numer starts with FA500)? In the Netherlands o.a. sold by the Kruidvat stores.

If have tried it to decode by using the receive and transmit code from both the RemotSwitch and RCSwitch libraries. Without any succes. With both I receive a code but when I try to resend these code the devices do not react. The code received by Remoteswith differs from the RCSwitch.

Anyone any ideas how I can solve this?

Hi,

I've used NewRemoteSwitch library for similar switches.

Regards, Sergey.

Sergey thanks for your response.

I do receive a code from my remote with the ShowReceivedCode from NewRemoteSwith library, the result:

Addr 20496 unit 1 off, period: 271us.

But when I try to send an On or Off signal to the device with the LightShow sketch provided as demo, the device does not recognise this signal and does not switch.

Did you do something special to send out the signal? I use:

NewRemoteTransmitter transmitter(20496, 11, 271, 3); transmitter.sendUnit(1, true);

My old Kaku and X10 devices working fine with this setup.

Regards, Johan

Are you aware that you probably will have to link the device within 10 seconds after plugging the switch into the socket? Not sure, but the manual says so to be able to operate it with the standard remote control. Imagine the same is applicable for your arduino transmitter....

The device can be programmed with the remote controller ( multiple remotes /codes per device supported).

I have tried to analyse the signal with a digital analyser and it seem to be the 24 bits protocol that I also had detected witb RCSwitch showcode scetch. But when I tried to sent the same signal the device does not react. I found a diffrence in the sync /start signal. RCRemote use 1 pulse high and 31 pulses low. My remote send 1pulse high and 15 pulses low. But when I changed that the device still does not react.

I need to do more investigation work I supose :-(

Possibly the FA500 remote control is sending more required data than just the 24 bit code.

Using the Arduino sketch from the RCSwitch library, I get:

# A on

Decimal: 4260117 (24Bit) Binary: 010000010000000100010101 Tri-State: F00F000F0FFF PulseLength: 329 microseconds Protocol: 1
Raw data: 10232,392,928,988,332,388,924,388,932,388,928,384,940,380,928,988,336,380,928,384,940,380,928,384,940,384,928,380,940,384,932,980,340,380,932,376,948,376,932,984,340,376,940,976,348,372,936,980,344,

However, when I analyze the same signal using the rtl_433 tool from https://github.com/merbanan/rtl_433, I get:

# A on

*** signal_start = 38594077, signal_end = 38825145
signal_len = 231068, pulses = 614
Iteration 1. t: 161 min: 73 (528) max: 249 (86) delta 245
Iteration 2. t: 161 min: 73 (528) max: 249 (86) delta 0
Pulse coding: Short pulse length 73 - Long pulse length 249

Short distance: 197, long distance: 1237, packet distance: 2528

p_limit: 161

[00] {182} 13 72 39 b0 9b 91 cd 84 dc 8e 6c 26 e4 73 60 00 00 00 00 00 00 00 00 : 00010011 01110010 00111001 10110000 10011011 10010001 11001101 10000100 11011100 10001110 01101100 00100110 11100100 01110011 01100000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[01] {66} 00 00 00 00 00 00 00 00 00 : 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[02] {66} 00 00 00 00 00 00 00 00 00 : 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[03] {1} 00 : 00000000
[04] {58} 00 00 00 00 00 00 00 00 : 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[05] {58} 00 00 00 00 00 00 00 00 : 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[06] {58} 00 00 00 00 00 00 00 00 : 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
[07] {25} 41 01 15 00 : 01000001 00000001 00010101 00000000
[08] {25} 41 01 15 00 : 01000001 00000001 00010101 00000000
[09] {25} 41 01 15 00 : 01000001 00000001 00010101 00000000
[10] {25} 41 01 15 00 : 01000001 00000001 00010101 00000000
[11] {25} 41 01 15 00 : 01000001 00000001 00010101 00000000

What seems suspicious is that the Arduino code apparently is only concerned with lines [07] to [11] above, totally ignoring lines [01] to [11]. Possibly this is why we cannot get sending to work using the the RCSwitch library.

Does anyone know that lines [01] to [11] could be? Interestingly, some bits in these lines change every time while others do not. Could it be some sort of collission protection scheme?

I have put more log output and an Arduino sending sketch on https://gist.github.com/probonopd/331674026839b96cd8d7.

When I saw your post I did realize that I have not post my last experiences with these devices. I manage to decode the signal. It was very hard because the remote controller of the FA500 send out a sequence of 4 different codes (each code also sent multiple times). With RCSwitch / Remoteswitch and Newremote switch you can “catch” some of these codes but node the ones that switches the FA500.

I first tried to “catch” the codes with OLS, Open Bench Logic sniffer (ols.lxtreme.nl ) with arduino as sump client (GitHub - gillham/logic_analyzer: Implementation of a SUMP compatible logic analyzer for the Arduino). It is very hard to start the analyser and the remote at the same time but I managed to receive 3 different codes. But none of these codes was able to switch the FA500.

At the end I tried it with audacity and the soundcard as Analyser: (see: http://hblok.net/blog/posts/2012/09/02/home-automation-on-433-92-mhz-with-arduino/ and http://davehouston.net/learn.htm) . Then I realize there was one code more in the signal. That first code in the sequence switches my FA500.

Attached schreen picture of the audacity output voor all codes and a detail picture of the first code (the one FA500 uses).

I manage to detect all 8 codes (4 units on/off for 2 remotes). I did not manage to find the logic behind these codes. I hard coded them in my arduino and can switch now my FA500 devices.

Below the “subroutine code” I use in my Arduino domotica program (als use for X10 and Klik aan / Klik Uit switching).
Because of that I more or less standardised the call of these routine:

Flamingo_Send(house, unit, command);

Where housecode is A-D (code on the remote, like x10/KAKU housecode) and unit is remote unit number (0 or 1, like x10 / KAKU unit number)). Command is 0 or 1 (on or off).

I have added also a lot of debug stuf because it was not easy to get it working.
Hope you can use this the switch your FA500 devices.

Regards,
Johan

/******************************************************************************
** Flamingo_send **


** Flamingo device commands (on/off)hard coded (not deciphered yet) **
** code is 28 byte long. To transfer it in 32 bit code 4 0 **
** is added to the left. For programming reason hex code representation
*
** of device code is used. E.g. Remote 0,C,On: **
** code 28 bits: 0001100110111111110100100110 **
** code 32 bits: 00011001101111111101001001100000 **
** Hex: 19BFD260 **


** “Sync” 1 pulse High, 15 pulse low **
** “1” 1 pulse High, 3 pulse low **
** “0” 3 pulse High, 1 pulse low **
** “end” N/A **


** For internal ref: Unit 0 = white remote , unit 1 = black remote **


******************************************************************************/
//Compiler only coding
#define FREMOTE 2 /*amount supported remotes /
#define FUNITS 4 /
Amount of units supported per remote /
#define FCMDN 2 /
Amount of CMD 0 = AAN, 1 = UIT */

//define device codes:

uint32_t fdev[FREMOTE][FUNITS][FCMDN] = {0xD9762A10, /* Remote 0, Unit A, Aan /
0xDAA47850, /
Remote 0, Unit A, Uit /
0xDBDA22E0, /
Remote 0, Unit B, Aan /
0xDBA27220, /
Remote 0, Unit B, Uit /
0x19BFD260, /
Remote 0, Unit C, Aan /
0x195EEAA0, /
Remote 0, Unit C, Uit /
0x984CC650, /
Remote 0, Unit D, Aan /
0x9A8C1050, /
Remote 0, Unit D, Uit /
0xDBFFFE90, /
Remote 1, Unit A, Aan /
0xD91CEF10, /
Remote 1, Unit A, Uit /
0xDBC52FA0, /
Remote 1, Unit B, Aan /
0xD9E35160, /
Remote 1, Unit B, Uit /
0x19B0FE60, /
Remote 1, Unit C, Aan /
0x19682B20, /
Remote 1, Unit C, Uit /
0x9924E7D0, /
Remote 1, Unit D, Aan /
0x9BA928D0}; /
Remote 1, Unit D, Uit */

//Define Flamingo_send variables / constants

int fpulse = 300; /* Pulse witdh in microseconds /
int fretrans = 5; /
Code retransmission */
uint32_t fsendbuff;
uint32_t fdatabit;
uint32_t fdatamask = 0x80000000;

void Flamingo_Send(int fhousec, int funitc, int fcmd)
{

//Test if used codes are valid

if ((funitc < 1) || (funitc > 2)){ // check if unit code between 1-2 (Remote 0 of 1)
sendcmd_error = true; // no => command error
#if defined DEBUG
Serial.print("Unit error: ");
Serial.println(funitc);
#endif
return;
}
else {
funitc = funitc - 1; //To address right code in array
}

if ((fhousec < 0) || (fhousec > 3)){ // check if house code between 1-4 (A-D)
sendcmd_error = true; // no => command error
#if defined DEBUG
Serial.print("House error: ");
Serial.println(fhousec);
#endif
return;
}
// else {
// fhousec = fhousec - 1; //To address right code in array
// }

if ((fcmd < 0) || (fcmd > 1)){ // check if command = 0 (off) or 1 (on)
#if defined DEBUG
Serial.print("Command error: ");
Serial.println(fcmd);
#endif
sendcmd_error = true; // no => command error
return;
}
//End test used codes

#if defined DEBUG
Serial.println("Send Flamingo command ");
Serial.print(“Flamingo House/Device code = :”);
Serial.println(fhousec);
Serial.print(“Flamingo Unit/remote code = :”);
Serial.println(funitc);
Serial.print(“command = :”);
Serial.println(fcmd);
Serial.println();
#endif

//Zend Command

for (int nRepeat=0; nRepeat <= fretrans; nRepeat++) {

fsendbuff = fdev[funitc][fhousec][fcmd];

// send SYNC 1P High, 15P low
// Serial.println(“Zend sync”);

digitalWrite(rfPin, HIGH);
delayMicroseconds(fpulse * 1);
digitalWrite(rfPin, LOW);
delayMicroseconds(fpulse * 15);

// end send SYNC

// Send command

for(int i = 0; i < 28; i++) //Flammingo command is only 28 bits */
{
//read data bit
fdatabit = fsendbuff & fdatamask; //Get most left bit
fsendbuff = (fsendbuff << 1); //Shift left

if (fdatabit != fdatamask)
{ //Write 0
digitalWrite(rfPin, HIGH);
delayMicroseconds(fpulse * 3);
digitalWrite(rfPin, LOW);
delayMicroseconds(fpulse * 1);
}
else
{ //Write 1
digitalWrite(rfPin, HIGH);
delayMicroseconds(fpulse * 1);
digitalWrite(rfPin, LOW);
delayMicroseconds(fpulse * 3);
}
}
}
}

FA500 all protocols.jpg

FA500 First code.jpg

Hi Johan,

thanks for your reply. You are a great example of why I love the Arduino community :slight_smile: Maybe I will keep the Flamingo set after your encouraging post (was thinking of returning it to the shop).

Unfortunately, your code is not compiling for me, I get

Flamingo_send.ino: In function ‘void Flamingo_Send(int, int, int)’:
Flamingo_send:59: error: ‘sendcmd_error’ was not declared in this scope
Flamingo_send:71: error: ‘sendcmd_error’ was not declared in this scope
Flamingo_send:87: error: ‘sendcmd_error’ was not declared in this scope
Flamingo_send:112: error: ‘rfPin’ was not declared in this scope

Like this, I get it to compile:

/******************************************************************************
** Flamingo_send                                                             **
**                                                                           **
**       Flamingo device commands (on/off)hard coded (not deciphered yet)    **
**       code is 28 byte long. To transfer it in 32 bit code 4 *0            **
**       is added to the left. For programming reason hex code representation**
**       of device code is used. E.g. Remote 0,C,On:                         **
**         code 28 bits: 0001100110111111110100100110                        **
**         code 32 bits: 00011001101111111101001001100000                    **
**         Hex:          19BFD260                                            **
**                                                                           **
**        "Sync" 1 pulse High, 15 pulse low                                  **
**        "1"    1 pulse High, 3 pulse low                                   **
**        "0"    3 pulse High, 1 pulse low                                   **
**        "end"  N/A                                                         **
**                                                                           **
**       For internal ref: Unit 0 = white remote , unit 1 = black remote     **
**                                                                           **
******************************************************************************/
// Compiler only coding
#define FREMOTE 2                                  /*amount supported remotes */
#define FUNITS  4                                  /* Amount of units supported per remote */
#define FCMDN   2                                  /* Amount of CMD 0 = On, 1 = Off */

int rfPin = 10;

// define device codes:

uint32_t fdev[FREMOTE][FUNITS][FCMDN] = {0xD9762A10,                                           /* Remote 0, Unit A, On  */
                                         0xDAA47850,                                           /* Remote 0, Unit A, Off */
                                         0xDBDA22E0,                                           /* Remote 0, Unit B, On  */
                                         0xDBA27220,                                           /* Remote 0, Unit B, Off */
                                         0x19BFD260,                                           /* Remote 0, Unit C, On  */
                                         0x195EEAA0,                                           /* Remote 0, Unit C, Off */
                                         0x984CC650,                                           /* Remote 0, Unit D, On  */
                                         0x9A8C1050,                                           /* Remote 0, Unit D, Off */
                                         0xDBFFFE90,                                           /* Remote 1, Unit A, On  */
                                         0xD91CEF10,                                           /* Remote 1, Unit A, Off */
                                         0xDBC52FA0,                                           /* Remote 1, Unit B, Aan */
                                         0xD9E35160,                                           /* Remote 1, Unit B, Off */
                                         0x19B0FE60,                                           /* Remote 1, Unit C, On  */
                                         0x19682B20,                                           /* Remote 1, Unit C, Uit */
                                         0x9924E7D0,                                           /* Remote 1, Unit D, On  */
                                         0x9BA928D0                                            /* Remote 1, Unit D, Uit */
                                        };                                          


// Define Flamingo_send variables / constants

int fpulse = 300;                              /* Pulse witdh in microseconds */
int fretrans = 5;                              /* Code retransmission         */
uint32_t fsendbuff;
uint32_t fdatabit;
uint32_t fdatamask = 0x80000000;

void Flamingo_Send(int fhousec, int funitc, int fcmd)
{

  // Test if used codes are valid

  if ((funitc < 1) || (funitc >  2)) {                  // check if unit code between 1-2 (Remote 0 of 1)
    Serial.print("Unit error: ");
    Serial.println(funitc);
    return;
  }
  else  {
    funitc = funitc - 1;                               // To address right code in array
  }

  if ((fhousec < 0) || (fhousec >  3)) {               // check if house code between 1-4 (A-D)
    Serial.print("House error: ");
    Serial.println(fhousec);
    return;
  }

  if ((fcmd < 0) || (fcmd > 1)) {                       // check if command = 0 (off) or 1 (on)
    Serial.print("Command error: ");
    Serial.println(fcmd);
    return;
  }
  
  //End test used codes

  Serial.println("Send Flamingo command ");
  Serial.print("Flamingo House/Device code = :");
  Serial.println(fhousec);
  Serial.print("Flamingo Unit/remote code = :");
  Serial.println(funitc);
  Serial.print("command = :");
  Serial.println(fcmd);
  Serial.println();


  // Send Command

  for (int nRepeat = 0; nRepeat <= fretrans; nRepeat++) {

    fsendbuff = fdev[funitc][fhousec][fcmd];

    // send SYNC 1P High, 15P low
    Serial.println("Send sync");

    digitalWrite(rfPin, HIGH);
    delayMicroseconds(fpulse * 1);
    digitalWrite(rfPin, LOW);
    delayMicroseconds(fpulse * 15);

    // end send SYNC

    // Send command

    for (int i = 0; i < 28; i++)                                 // Flamingo command is only 28 bits */
    {
      // read data bit
      fdatabit = fsendbuff & fdatamask;                         // Get most left bit
      fsendbuff = (fsendbuff << 1);                             // Shift left

      if (fdatabit != fdatamask)
      { // Write 0
        digitalWrite(rfPin, HIGH);
        delayMicroseconds(fpulse * 3);
        digitalWrite(rfPin, LOW);
        delayMicroseconds(fpulse * 1);
      }
      else
      { // Write 1
        digitalWrite(rfPin, HIGH);
        delayMicroseconds(fpulse * 1);
        digitalWrite(rfPin, LOW);
        delayMicroseconds(fpulse * 3);
      }
    }
  }
}

void setup() {
  Serial.begin(9600);
}

void loop() {
  Flamingo_Send(0, 1, 1);
  delay(1000);
  Flamingo_Send(0, 1, 0);
  delay(3000);
}

Unfortunately, my Flamingos do not react. Do you have any way to determine, based on my information on ELRO Flamingo FA50R Remote Protocol · GitHub what I need to change?

Thanks!
probono

At first sight the code looks fine to me. At this momment I cannot test it on my Arduino (maybe later this week).

Just te be sure: Have you programmed the Flamingo device to listen to this code?

Regards, Johan

Hi Johan,

you are absolutely right -- I was (wrongly) assuming that pressing "A on" on my physical remote control would send the same code as your sketch (which did not work). After programming the Flamingos to listen to the sketch, it is now working wonderfully.

Out of curiosity, is it possible to translate the codes I have sniffed into the notation your sketch is using?

Thanks, probono

Oke I am glad it is working.

You now have the codes of my two remote controllers. I hope you do not live nearby :slight_smile:

As you proably know It is possible to program a flamingo device to listen to multiple code’s. So you can program it to react to your remote controller and my codes via the arduino.

I do not think that you have received the right codes with the standards tools to detect the codes the remote is sending for the flamingo devices. As described before the flamingo remote controller is sending out 4 different codes. The one you received with the rcswitch (or other tools) is code 2,3 or 4. I was only possible to detect the first code, the flamingo code, using audacity and the aux in of the soundcard as analyser. It took me some days to recognized this.

So if you want the detect the codes of your remote then you have put some effort in it. Maybe with the knowledge I have now can write a detection utility but don’t count on it.

If you can read dutch I can send you my notes on my “flamingo journey” with some exploination about the detected codes /protocols.

Regards,
Johan

...or so I tought.

In the end I was able to switch them on but not off. I decided to return my Flamingos to the shop because I don't like the fact that there are not physical switches to encode the addresses. It feels like I can never be sure which codes they react to, and the whole addressing thing feels a bit fragile to me.

Still, I would be interested in reading your full Flamingo journey with the help of Google translate.

Thanks, probono

I don't have an arduino, but this was the only forum mentioning this problem. I am trying to setup the ELRO Flamingo switches (FA500) in Domoticz on the raspberry PI. Is there any way to fix this problem for domoticz? I am using a rfxcom transceiver. It can 'learn' the signal from the remote, but then when I am transmitting the signal back to the Flamingo switches, they do not respond to that signal.

@johanm: Any way I can convert your code to work on the raspberry pi with domoticz (or some other platform)?

PS. @johanm I am also dutch by the way.

@johanm,

Dear johanm, i have also purchased some flamingo FA500. But when i use your sketch i can't 'teach' my arduino to your codes. I have emptied the memory of the flamingos, but no result. Can you please help me?

btw i'm also Dutch:)

greeting, Michel

I'm also trying to use these switches in my microcontroller, but I have a weird problem. We checked all the signals sent out by the remote using an osciloscope and tried all protocols using a modified RCSwitch library. After these tests we determined that the second protocol that is sent out; is the correct one for the switches. So after this we wanted to connect a few devices, and see if everything worked. Only we noticed at this point, that when we assign A to outlet1, B to outlet2 and C to outlet3, no matter what channel we choose, all switches turn on and off at all channels!! So when I press A on, all devices turn on, and C off, all devices turn off. All switches seem to have accepted all codes. And all of this is happening using the original remote! When we try to use the Arduino we have the exact same problem.

Is there anyone else that has had this problem? And is there a way to fix it? It allmost seems like the switches have some kind of ROM that has been written to.

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: 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.

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

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:

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 :slight_smile:

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

RCSwitch_Flamingo.zip (6.48 KB)

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?

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