如何解码此小端（int32）消息？

Question

I have a task to do. I get lot of data and my job is to decode it. Every piece I get is written in readable string of hex numbers. For example: "8a fd ff ff"

I tried with struct.unpack('<l', "8a fd ff ff") and I also tried a lot of way to decode and it would be too long to list. Only thing I know that this should give me -630 as a result. I don't know how the data was transformed to this form.

data = "8a fd ff ff"
aa = np.array(list(data))
print(aa)
struct.unpack('<l', aa)

struct.error: unpack requires a buffer of 4 bytes

so the result should be -630. I tested it with an online hex decoder.

Answer 1

A find the first answer good, but a more intuitive, and easier to remember is following. Given that all of your data is given as a space separated string of hex numbers you can use :

data = "8a fd ff ff"
bytes_data = bytes.fromhex( data.strip() ) 
struct.unpack("<l", bytes_data)

In this example we first load the data, remove all the whitespaces, convert to binary hex representation and read it out. Output is as you expect it to be.

Answer 2

Step-wise conversion from hex string to byte string

unpack() expects a byte string as the second argument (which must match the format as specified by the first argument). However, what we have now in data is '8a fd ff ff' , which is a hex string. So we need to convert the hex string into byte string by taking the steps below:

1. Split the data:

data_split = data.split()
# ['8a', 'fd', 'ff', 'ff']

2. Now, the split data are still hex strings, so we need to read them as hex using int() , passing in 16 as the second argument because hexadecimal is base 16:

data_converted = [int(hex_string, 16) for hex_string in data_split]
# [138, 253, 255, 255]

3. We can now convert the data to bytes:

byte_array = [chr(int_) for int_ in data_converted]
# ['\x8a', '\xfd', '\xff', '\xff']

4. We then join the array into a single string:

byte_string = ''.join(byte_array)
# '\x8a\xfd\xff\xff'

5. Finally, we can use unpack() , with the l format character for long (ie, 4 bytes):

unpack('<l', byte_string)
# (-630,)

Answer 3

struct.unpack doesn't expect a string but a byte string: a sequence of bytes in the binary form.

 >>> data = "8a fd ff ff"
 >>> bytestr = "".join(chr(int(h, 16)) for h in data.split())
 >>> struct.unpack("<l", bytestr )
 (-630,)

Your array has a list of the string representations characters instead:

>>> import numpy as np
>>> data = "8a fd ff ff"
>>> aa = np.array(list(data))>>> aa
array(['8', 'a', ' ', 'f', 'd', ' ', 'f', 'f', ' ', 'f', 'f'],
      dtype='|S1')

It should contain the bytes themselves:

>>> aa = np.array([chr(int(h, 16)) for h in data.split()])
>>> aa
array(['\x8a', '\xfd', '\xff', '\xff'],
      dtype='|S1')
>>> struct.unpack("<l", aa)
(-630,)