Decoding the message bit field 0x0700

[FransOv]

Does anyone now how to correctly decode the WPR3_0700_MeldungsBitfeld 0x0700 (32 bytes). The warnings and error messages are numbered from 01 to FF. For each active message the corresponding bit (1-based) in this datapoint is set. However I cannot get the result right.
Optolink-switch delivers this datapoint as a hexadecimal string:
For warning D5, Humidistat closed, this gives
"0000000000000000000000000000000000000000000000000000200000000000"
For error EE, Loss of communication with a KM-Bus device, it gives:
"0000000000000000000000000000000000000000000000000000000000400000"
However instead of D5 I get D3 and instead of EE I get EA as can be illustrated with this Python program (a lot easier then counting bits):

bits="0000000000000000000000000000000000000000000000000000200000000000"
errors=""
pos=[8,4,2,1]
for biti, bit in enumerate(bits):
    if bit!="0":
        q=int(bit)
        bx=biti*4
        for pxi, px in enumerate(pos):
            if q&px!=0:
                errors=errors+'{:X}'.format(bx+pxi+1)+" "

print (errors)

or this program in the Home Assistant template language:

{% set bits="0000000000000000000000000000000000000000000000000000000000400000"|list %}
{% set ns=namespace(errors="") %}
{% set ns.pos=[8,4,2,1] %}
{% for bit in bits %}
  {% if bit!="0" %}
    {% set q=bit|int(base=16) %}
    {% set bx=loop.index0*4 %}
    {% for px in ns.pos %}
      {% if q|bitwise_and(px)!=0 %}
        {% set ns.errors=ns.errors~'{:X}'.format(bx+loop.index)~" " %}
      {% endif %}
    {%  endfor %}
  {% endif %}
{% endfor %}
{{ ns.errors }}

So one is shifted two bits down and the orther is shifted 4 bits down. I don't know how to handle this.

[philippoo66]

hmm, I'm not sure if I understand... you say
0x1 1000000000000000000000000000000000000000000000000000000000000000
0x2 2000000000000000000000000000000000000000000000000000000000000000
0x3 4000000000000000000000000000000000000000000000000000000000000000
0x4 8000000000000000000000000000000000000000000000000000000000000000
0x5 0100000000000000000000000000000000000000000000000000000000000000
0x6 0200000000000000000000000000000000000000000000000000000000000000
0x7 0400000000000000000000000000000000000000000000000000000000000000
...
right?

if so, then it would be
0xd2 0000000000000000000000000000000000000000000000000000200000000000
0xd5 0000000000000000000000000000000000000000000000000000010000000000 (3 bits 'further right')

0xeb 0000000000000000000000000000000000000000000000000000000000400000
0xee 0000000000000000000000000000000000000000000000000000000000020000 (3 bits 'further right')

so at least the "3 bits 'further right'" applies to both values, right?

I 'produced' the 64-digits strings by

for myval in range(1, 256):
    val = 2**(myval-1)
    mystr = f"{val:x}"
    mystr = mystr.rjust(64, "0")
    print(hex(myval), mystr[::-1])

according to ChatGPT the 'inverse' funktion would be

def recover_myval(mystr):
    # zurückdrehen
    help_str = mystr[::-1]
    # von hex in int umwandeln
    val = int(help_str, 16)
    # nur ein gesetztes Bit → Position finden
    bitpos = val.bit_length() - 1
    myval = bitpos + 1  # da dein Zähler bei 1 startet
    return myval

then you finally would need to add 3 to the return value and you should have your error/warning 'code'?

[philippoo66]

instead of D5 I get D3 and instead of EE I get EA

I'm afraid somehow your algoithm is wrong or the input was wrong and this is what confused you.

[FransOv]

No, I think 8000000...... would be error code 01, 40000000...... would be error code 02, 2000000...... would be error code 03 and C8000000 would be error code 01, error code 02 and error code 05

[FransOv]

I think I got it. Instead of an array of 256 bits we need to treat it as an array of 32 bytes. In each byte you take the bit position not from the left but from the right and zerobased, so:
0x01 is 00
0x02 is 01
.
.
0x40 is 06
0x80 is 07
Count the bytes from left to right and count the bits from right to left, why not if it confuses reverse engineering!

This program now gives the correct results (the last one gives 6, 7 and EE):

#bitfield="0000000000000000000000000000000000000000000000000000200000000000"
#bitfield="0000000000000000000000000000000000000000000000000000000000400000"
bitfield="C000000000000000000000000000000000000000000000000000000000400000"
bts=bytearray.fromhex(bitfield)
errors=""
pos=[1,2,4,8,16,32,64,128]
for bi, b in enumerate(bts):
    if b!=0:
        bx=bi*8
        for pxi, px in enumerate(pos):
            if b&px!=0:
                errors=errors+'{:X}'.format(bx+pxi)+" "

print (errors)

[FransOv]

This is the program in the Home Assistant template language, it returns 6, 7, D5 and EE:

{% set bits="C000000000000000000000000000000000000000000000000000200000400000"|list %}
{% set ns=namespace(errors="") %}
{% set ns.pos=[1,2,4,8,16,32,64,128] %}
{% for byte in bits|slice(32) %}
  {% set q=byte|join|int(base=16) %}
  {% if q!="0" %}
    {% set bx=loop.index0*8 %}
    {% for px in ns.pos %}
      {% if q|bitwise_and(px)!=0 %}
        {% set ns.errors=ns.errors~'{:X}'.format(bx+loop.index0)~" " %}
      {% endif %}
    {%  endfor %}
  {% endif %}
{% endfor %}
{{ ns.errors }}

[philippoo66]

Count the bytes from left to right and count the bits from right to left, why not if it confuses ...!

;-)

[philippoo66]

with ByteBit Filter you can switch endian, so toggle the byte order reading the entire bytes - perhaps then it would be 'less confusing'? (and ease the decoding?)

[FransOv]

I don't think that will work for a 32 byte field. Actually, from a programming point a view it does make kind of sense as most programming languages that support addressable bits index them from lsb to msb. From a data point of view it is however less straightforward.