[SOLVED]Help with protocol for masterplug UK wall sockets

---

Hi there,

Today I purchased some wall sockets and homeduino doesnt recognise the protocol.

I am hoping someone maybe able to help me.

below is the debug from pimatic when i press button 1 on

debug [pimatic-homeduino]: received: [ 452, 1336, 3392, 10124 ] 0000220100010101000000010101000001000100010000000101010000000101000100010000000001010103
debug [pimatic-homeduino]: data: "RF receive 452 3392 1336 10124 0 0 0 0 0000110200020202000000020202000002000200020000000202020000000202000200020000000002020203"

button 1 off

 [pimatic-homeduino]: received: [ 456, 1320, 3384, 10100 ] 0000220100010101000000010101000001000100010000000101010000000101000100000101010100000003
debug [pimatic-homeduino]: data: "RF receive 456 3384 1320 10100 0 0 0 0 0000110200020202000000020202000002000200020000000202020000000202000200000202020200000003"

button 2 on

debug [pimatic-homeduino]: received: [ 456, 1324, 3384, 10112 ] 0000220100010101000000010101000001000100010000000101010000000101000100000100000100010103
debug [pimatic-homeduino]: data: "RF receive 456 3384 1324 10112 0 0 0 0 0000110200020202000000020202000002000200020000000202020000000202000200000200000200020203"

button 2 off

debug [pimatic-homeduino]: received: [ 452, 1336, 3384, 10108 ] 0000220100010101000000010101000001000100010000000101010000000101000100010001010001000003
debug [pimatic-homeduino]: data: "RF receive 452 3384 1336 10108 0 0 0 0 0000110200020202000000020202000002000200020000000202020000000202000200020002020002000003"

button 3 on

debug [pimatic-homeduino]: received: [ 452, 1336, 3376, 10112 ] 0000220100010101000000010101000001000100010000000101010000000101000100010100000000010103
debug [pimatic-homeduino]: data: "RF receive 452 3376 1336 10112 0 0 0 0 0000110200020202000000020202000002000200020000000202020000000202000200020200000000020203"

button 3 off

debug [pimatic-homeduino]: received: [ 452, 1332, 3380, 10108 ] 0000220100010101000000010101000001000100010000000101010000000101000100000001010101000003
debug [pimatic-homeduino]: data: "RF receive 452 3380 1332 10108 0 0 0 0 0000110200020202000000020202000002000200020000000202020000000202000200000002020202000003"

button 4 on

debug [pimatic-homeduino]: received: [ 456, 1320, 3384, 10096 ] 0000220100010101000000010101000001000100010000000101010000000101000100000001000101000103
debug [pimatic-homeduino]: data: "RF receive 456 3384 1320 10096 0 0 0 0 0000110200020202000000020202000002000200020000000202020000000202000200000002000202000203"

button 4 off

debug [pimatic-homeduino]: received: [ 456, 1324, 3384, 10100 ] 0000220100010101000000010101000001000100010000000101010000000101000100010100010000010003
debug [pimatic-homeduino]: data: "RF receive 456 3384 1324 10100 0 0 0 0 0000110200020202000000020202000002000200020000000202020000000202000200020200020000020003"

all on

debug [pimatic-homeduino]: received: [ 460, 1312, 3388, 10108, 20940 ] 00002201000101010000000101010000010001000100000001010100000001010001000100010000010001030000220100010101000000010101000001000100010000000101010000000101000100010001000001000104
debug [pimatic-homeduino]: data: "RF receive 460 3388 1312 10108 20940 0 0 0 00001102000202020000000202020000020002000200000002020200000002020002000200020000020002030000110200020202000000020202000002000200020000000202020000000202000200020002000002000204"

all off

debug [pimatic-homeduino]: received: [ 456, 1324, 3384, 10092 ] 0000220100010101000000010101000001000100010000000101010000000101000100000100010100010003
debug [pimatic-homeduino]: data: "RF receive 456 3384 1324 10092 0 0 0 0 0000110200020202000000020202000002000200020000000202020000000202000200000200020200020003"

I hope someone can help. Thanks

This is where I am now having followed the tutorial to add a protocol.

I have converted each buttons pulses to binary values, and you can see the id in the protocol. But i am struggling to decode the rest. Any guidance would be appreciated.

1011100011100101010001110001101010000111 - 1 on
1011100011100101010001110001101001111000 - 1 off
1011100011100101010001110001101001001011 - 2 on
1010100011100101010001110001101010110100 - 2 off
1011100011100101010001110001101011000011 - 3 on
1011100011100101010001110001101000111100 - 3 off
1011100011100101010001110001101001011010 - all off
|---------------ID?------------|

Great debug info, and I think you made a good followup with decoding the pulses, however I think you made an error with the decoded value for 2 on.

What I notice is that the off code after the ID is the inverted value of the on code

1 on    10000111
1 off   01111000
2 on    01001011
2 off   10110100
3 on    11000011
3 off   00111100
4 on    00101101
4 off   11010010
all on  10100101
all off 01011010

Also the on code always ends on 1 and off on 0 and there are always 4 1’s and 4 0’s in the code

Thanks for your keen eye! I’ve been staring at this for ages and not noticed that. Now i need to figure how to make it work as a protocol

So if i make the last bit in the sequence the “on/off” command. How does the rest fit as a protocol? No idea how to do this.

I see that the off-code is the opposide of the on-code a 0 in off is a 1 in on.

ok so im stumped with this. I am now trying to make a test case in lib-controller.coffee, but i dont know what the values are of what im receiving.

I can say the last bit is the on/off command, and the first bit is the id. But what is the value of the id. And how do i get a unit number from the rest of the pulses?

If you would have some other similar remotes you could verify if their pulses have a similar format, but I think is’s safe to assume the first 32 bits are the ID.

The integer value of the first 32 bits should be the value of the id

You could verify if you can program the wall sockets with a different id, but same command bits, just to make sure there is no dependency between the ID and command

so the id value for the test case is 3102033690? I used a binary converter to get it.

If i use that for the test case i get this when i run gulp test

#decodePulses() switch31 should decode the pulses:

      AssertionError: pulse 110200020202000000020202000002000200020000000202020000000202000200020000000002020203 of switch31 should be detected.
      + expected - actual

      -false
      +true

    at Context.<anonymous> (test/lib-controller.coffee:930:9)

This is my protocol file

module.exports = (helper) ->
  # mapping for decoding
  pulsesToBinaryMapping = {
    '11': ''    #header
    '02': '1' #binary 1
    '00': '0' #binary 0
    '03': ''    #footer
  }
  # same for send
  binaryToPulse = {
    '1': '02'
    '0': '00'
  }
  return protocolInfo = {
    name: 'switch31'
    type: 'switch'
    values:
      id:
        type: "number"
      state:
        type: "number"
    brands: ["Masterplug UK"]
    pulseLengths: [452, 1336, 3392, 10124]
    pulseCount: 85
    decodePulses: (pulses) ->
      # pulses is something like: '110200020202000000020202000002000200020000000202020000000202000200020000000002020203'
      # we first map the sequences to binary
      binary = helper.map(pulses, pulsesToBinaryMapping)
      # binary is now something like: '1011100011100101010001110001101010000111'
      # | 1011100011100101010001110001101 | 010000111 |
      # | ID                              |   State   |
      return result = {
        id: helper.binaryToNumber(binary, 0, 31)
        state: helper.binaryToBoolean(binary, 40)
      }
    encodeMessage: (message) ->
      id = helper.map(helper.numberToBinary(message.id, 31), binaryToPulse)
      state = (if message.state then binaryToPulse['1'] else binaryToPulse['0'])
      return "11#{id}#{state}#03"
  }

ok so i got the tests to pass after fiddling with the coffee file.

Here it is. How do i integrate this into pimatic to test??

module.exports = (helper) ->
  # mapping for decoding
  pulsesToBinaryMapping = {
    '11': ''    #header
    '02': '1' #binary 1
    '00': '0' #binary 0
    '03': ''    #footer
  }
  # same for send
  binaryToPulse = {
    '1': '02'
    '0': '00'
  }
  return protocolInfo = {
    name: 'switch31'
    type: 'switch'
    values:
      id:
        type: "number"
      state:
        type: "number"
    brands: ["Masterplug UK"]
    pulseLengths: [452, 1336, 3392, 10124]
    pulseCount: 84
    decodePulses: (pulses) ->
      # pulses is something like: '110200020202000000020202000002000200020000000202020000000202000200020000000002020203'
      # we first map the sequences to binary
      binary = helper.map(pulses, pulsesToBinaryMapping)
      # binary is now something like: '1011100011100101010001110001101010000111'
      # | 1011100011100101010001110001101 | 01000011 | 1 |
      # | ID                              |   ??     |on |
      return result = {
        id: helper.binaryToNumber(binary, 0, 31)
        state: helper.binaryToBoolean(binary, 39)
      }
    encodeMessage: (message) ->
      id = helper.map(helper.numberToBinary(message.id, 31), binaryToPulse)
      state = (if message.state then binaryToPulse['1'] else binaryToPulse['0'])
      return "11#{id}#{state}#03"
  }

Hi,

I would take a bit different approach:

Use the 8 command bits for on as the unit number
When issuing the on command use the binary representation of the unit number
When using the off command use the inverted binary representation of the unit number

i am way out of my depth here.

I have no idea how to write that into the protocol.

I see your point though. Would be the best way to distinguish which button does what.

I think something like this:

  id = helper.binaryToNumber(binary, 0, 31)
  unit = helper.binaryToNumber(binary, 32)
  state = helper.binaryToBoolean(binary, 39)
  if state == false
    unit = unit ^ 0xff
  return result = {
    id: id
    state: state
    unit: unit
  }

now getting unmatched outdent errors. dammit

if state = false

should be

if state == false

Have tried your suggestion but still getting outdent errors. (Bcause I have no idea what im doing!)

Here is the file so far… can you take a look. Thanks

module.exports = (helper) ->
  # mapping for decoding
  pulsesToBinaryMapping = {
    '11': ''    #header
    '02': '1' #binary 1
    '00': '0' #binary 0
    '03': ''    #footer
  }
  # same for send
  binaryToPulse = {
    '1': '02'
    '0': '00'
  }
  return protocolInfo = {
    name: 'switch31'
    type: 'switch'
    values:
      id:
        type: "number"
      unit:
        type: "number"
      state:
        type: "boolean"
    brands: ["Masterplug UK"]
    pulseLengths: [452, 1336, 3392, 10124]
    pulseCount: 84
    decodePulses: (pulses) ->
      # pulses is something like: '110200020202000000020202000002000200020000000202020000000202000200020000000002020203'
      # we first map the sequences to binary
      binary = helper.map(pulses, pulsesToBinaryMapping)
      # binary is now something like: '1011100011100101010001110001101010000111'
      # | 10111000111001010100011100011010 | 1000011 | 1 |
      # | ID                               | unit??  |on |
   return result = {
        id = helper.binaryToNumber(binary, 0, 31)
        unit = helper.binaryToBoolean(binary, 32)
        state = helper.binaryToBoolean(binary, 39)
        if state == false
          unit = unit ^ 0xff
        return result = {
          id: id
          state: state
          unit: unit
  }
  }
    encodeMessage: (message) ->
      id = helper.map(helper.numberToBinary(message.id, 31), binaryToPulse)
      unit = helper.map(helper.numberToBinary(message.id, 6), binaryToPulse)
      state = (if message.state then binaryToPulse['1'] else binaryToPulse['0'])
      return "11#{id}#[unit]#{state}#03"
  }

You have a syntax error

  }
  }

The first } should be indented, I think. I currently don’t have a coffeescript compiler at hand to check

I found out some other interesting details of the last 8 bits

Not only is the off code the inverse of the on code, the first 4 bits are also the inverse of the last 4 bits

1 on    1000 0111
1 off   0111 1000
2 on    0100 1011
2 off   1011 0100
3 on    1100 0011
3 off   0011 1100
4 on    0010 1101
4 off   1101 0010
all on  1010 0101
all off 0101 1010

Also, when you take the first 4 bits of the on codes, and reverse the bits you get the binary representation of 1 till 5

1 on    1000 = reversed 0001 = 1
2 on    0100 = reversed 0010 = 2
3 on    1100 = reversed 0011 = 3
4 on    0010 = reversed 0100 = 4
all on  1010 = reversed 0101 = 5

You have a better eye for this than me!

Ive hit a wall with it right now, as far as writing the protocol goes. Will come back to it tomorrow with a fresher mind!

I got some time on my hands, so came up with this solution

# Helper function to reverse a string
reverse = (s) ->
  if s.length < 2 then s else reverse(s[1..-1]) + s[0]

module.exports = (helper) ->
  pulsesToBinaryMapping = {
    '000022': ''
    '00': '0'
    '01': '1'
    '03': ''
  }
  binaryToPulse = {
    '0': '00'
    '1': '01'
  }
  return protocolInfo = {
    name: 'switch31'
    type: 'switch'
    values:
      id:
        type: "number"
      channel:
        type: "number"
      state:
        type: "boolean"
      all:
        type: "boolean"
    brands: [ "Masterplug UK" ]
    pulseLengths: [ 452, 1336, 3392, 10124 ]
    pulseCount: 88
    decodePulses: (pulses) ->
      # Pulses are something like:
      # 0000220100010101000000010101000001000100010000000101010000000101000100010000000001010103

      # We first map the sequences to binary
      binary = helper.map(pulses, pulsesToBinaryMapping)
      # Binary is now something like:
      # 1011100011100101010001110001101010000111
      # <              ><              ><  ><  >
      # First segment is the id
      # Second segment is the inverted id
      # Third segment is the reverse channel
      # Fourth segment is the inverted reverse channel
      # Also the last bit of the binary sequence is the state

      # Get the first 16 bits and convert to a number
      id = helper.binaryToNumber(binary, 0, 15)

      # Validate the id with the 2nd 2 bytes which contains the inverted id
      if id != (helper.binaryToNumber(binary, 16, 31) ^ 0xffff)
        console.error "ID validation failed"
        return false

      # Get the 33 till 36th bits to calculate the channel
      channel = binary.substr(32, 4)

      # Validate the channel with the last 4 bits which contains the inverted channel
      if helper.binaryToNumber(channel, 0, 3) != (helper.binaryToNumber(binary, 36, 39) ^ 0xf)
        console.error "Channel validation failed"
        return false

      # Reverse the channel bits
      channel = reverse(channel)
      # Convert bits to number
      channel = helper.binaryToNumber(channel, 0, 3)

      # get the last bit of the sequence for the on/off state
      state = helper.binaryToBoolean(binary, 39)

      # If this is an off signal, inverse the channel
      if state == false
        channel = channel ^ 0xf

      # If the channel number is 5 it's all channels on
      all = false
      if channel == 5
        all = true

      # Return the decoded pulses
      return result = {
        id: id
        channel: channel
        state: state
        all: all
      }

    encodeMessage: (message) ->
      id = message.id
      # Bit shift the id 16 positions to the left and add the inverted id
      id = (id << 16) + (id ^ 0xffff)
      # Convert the number to a binary string
      id = helper.numberToBinary(id, 32)
      # Convert the binary string to pulses
      id = helper.map(id, binaryToPulse)

      # If the message is for all channels override the channel to channel 5
      channel = message.channel
      if message.all == true
        channel = 5

      # If this is an off signal, inverse the channel
      if message.state == false
        channel = channel ^ 0xf

      # Bit shift the inverted channel 4 positions to the left and add the channel
      # The channel is still in reverse order, that's why the left part of the
      # channel needs to be inverted and not the right part
      channel = ((channel ^ 0xff) << 4) + channel
      # Convert the number to a binary string
      channel = helper.numberToBinary(channel, 8)
      # Only now we can reverse the bits
      channel = reverse(channel)
      # Convert the binary string to pulses
      channel = helper.map(channel, binaryToPulse)

      # Return the encoded message
      return "000022#{id}#{channel}03"
  }