Python, HEX, Serial, and Print

Question

Using Python 3, I need to write data 0x00 - 0xff through serial one byte at a time and also want to print on the screen the current byte in Hex where it is in the loop. Now that I've been working on this, it seems like I can just make a simple for loop counting from 0 - 255 and send that.

But, for learning purposes is the way I declared this variable correct?

# Characters to test, all 255 chars
mytest = { '\00', '\01', '\02', '\03', '\04', '\05', '\06', '\07', '\08', '\09', '\0a', '\0b', '\0c', '\0d', '\0e', '\0f', \
           '\10', '\11', '\12', '\13', '\14', '\15', '\16', '\17', '\18', '\19', '\1a', '\1b', '\1c', '\1d', '\1e', '\1f', \
           '\20', '\21', '\22', '\23', '\24', '\25', '\26', '\27', '\28', '\29', '\2a', '\2b', '\2c', '\2d', '\2e', '\2f', \
           '\30', '\31', '\32', '\33', '\34', '\35', '\36', '\37', '\38', '\39', '\3a', '\3b', '\3c', '\3d', '\3e', '\3f', \
           '\40', '\41', '\42', '\43', '\44', '\45', '\46', '\47', '\48', '\49', '\4a', '\4b', '\4c', '\4d', '\4e', '\4f', \
           '\50', '\51', '\52', '\53', '\54', '\55', '\56', '\57', '\58', '\59', '\5a', '\5b', '\5c', '\5d', '\5e', '\5f', \
           '\60', '\61', '\62', '\63', '\64', '\65', '\66', '\67', '\68', '\69', '\6a', '\6b', '\6c', '\6d', '\6e', '\6f', \
           '\70', '\71', '\72', '\73', '\74', '\75', '\76', '\77', '\78', '\79', '\7a', '\7b', '\7c', '\7d', '\7e', '\7f', \
           '\80', '\81', '\82', '\83', '\84', '\85', '\86', '\87', '\88', '\89', '\8a', '\8b', '\8c', '\8d', '\8e', '\8f', \
           '\90', '\91', '\92', '\93', '\94', '\95', '\96', '\97', '\98', '\99', '\9a', '\9b', '\9c', '\9d', '\9e', '\9f', \
           '\a0', '\a1', '\a2', '\a3', '\a4', '\a5', '\a6', '\a7', '\a8', '\a9', '\aa', '\ab', '\ac', '\ad', '\ae', '\af', \
           '\b0', '\b1', '\b2', '\b3', '\b4', '\b5', '\b6', '\b7', '\b8', '\b9', '\ba', '\bb', '\bc', '\bd', '\be', '\bf', \
           '\c0', '\c1', '\c2', '\c3', '\c4', '\c5', '\c6', '\c7', '\c8', '\c9', '\ca', '\cb', '\cc', '\cd', '\ce', '\cf', \
           '\d0', '\d1', '\d2', '\d3', '\d4', '\d5', '\d6', '\d7', '\d8', '\d9', '\da', '\db', '\dc', '\dd', '\de', '\df', \
           '\e0', '\e1', '\e2', '\e3', '\e4', '\e5', '\e6', '\e7', '\e8', '\e9', '\ea', '\eb', '\ec', '\1e', '\ee', '\ef', \
           '\f0', '\f1', '\f2', '\f3', '\f4', '\f5', '\f6', '\f7', '\f8', '\f9', '\fa', '\fb', '\fc', '\fd', '\fe', '\ff' }

for c in mytest:
    print (" ".join(hex(ord(n)) for n in c))
    serial.write(c)    # Let's pretend this sends the same to the serial port I defined somewhere.

Reading posts here, I have come up with the above to print the hex to screen. Which works, sort of.. when I put in one char at a time to test with. However instead of 0x00 it is printing 0x0 I am expecting two 00's well, three I guess 0x00. AND when I run it in the loop, I get all sorts of unexpected output. lol

Test output using single bytes..

0x0  0x1  0x2

Output when running in the for loop...

0x5c 0x38 0x39
0xc
0x8
0x7 0x30
0x5c 0x63 0x65
0x5c 0x39 0x36
0x5c 0x38 0x35
0x5c 0x64 0x36
0x5c 0x65 0x35
0x5c 0x38 0x37
0xc 0x30
0x5c 0x63 0x61
0x4 0x39
0x5c 0x64 0x64
0x0 0x65
0x1e
0x5c 0x63 0x31
0x24
0x4 0x61
0x8 0x37
0x7 0x37
0x8 0x38
0x1b
0x4 0x38
0x26
0x4 0x66
0x2e
0x5c 0x38 0x64
0x5c 0x39 0x64
0x5c 0x64 0x38
0x0
0x2 0x63
0x5c 0x39 0x61
0x27
0x5 0x65
0x3 0x64
0x3
0x15
0x2 0x39
0x19
0x5 0x63
0x5c 0x64 0x35
0x7 0x39
0x8 0x66
0xc 0x31
0x5c 0x64 0x63
0x5
0x3 0x66
0x5c 0x63 0x62
0x5c 0x65 0x63
0x5c 0x63 0x38
0x2a
0x1d
0x5c 0x38 0x63
0x8 0x63
0x5c 0x65 0x30
0x2 0x61
0x1 0x66
0xc 0x64
0x5c 0x65 0x62
0x5c 0x64 0x31
0x0 0x64
0xe
0x5 0x64
0x5c 0x65 0x37
0x5c 0x38 0x38
0x5c 0x65 0x39
0x5c 0x63 0x36
0xc 0x36
0x7 0x36
0x5c 0x65 0x31
0xb
0x2f
0x8 0x62
0x1
0x31
0x5c 0x38 0x61
0x1 0x39
0x2 0x38
0x6 0x38
0x1 0x62
0x3b
0x5c 0x63 0x33
0x5c 0x64 0x65
0x6 0x63
0x2b
0x5 0x66
0x8 0x64
0x5c 0x65 0x38
0x5c 0x64 0x62
0x6 0x64
0x5c 0x38 0x34
0x6 0x62
0x5c 0x39 0x30
0x6 0x61
0x16
0x1c
0x4 0x64
0xc 0x37
0x5c 0x64 0x66
0x5c 0x39 0x39
0x5c 0x63 0x39
0x8 0x32
0x3 0x65
0x11
0x28
0x5c 0x38 0x62
0x0 0x66
0xd
0x5 0x62
0x8 0x34
0x33
0x7 0x38
0x7 0x66
0x5c 0x39 0x32
0x4 0x63
0x2 0x66
0x1 0x38
0x7 0x31
0x5c 0x64 0x37
0x36
0x8 0x35
0x1 0x64
0x5c 0x39 0x31
0x5c 0x65 0x66
0x0 0x61
0x2 0x62
0x22
0x5c 0x64 0x32
0x0 0x38
0x25
0x5c 0x65 0x33
0x32
0xf
0x8 0x61
0x2 0x64
0x5c 0x63 0x34
0xc 0x38
0x7 0x61
0x8 0x36
0x2 0x65
0x1f
0x7 0x35
0x0 0x63
0xc 0x65
0x5c 0x63 0x30
0x5c 0x64 0x61
0x3 0x62
0x7 0x62
0x7 0x65
0x4 0x62
0x8 0x65
0x7 0x63
0x6
0x5c 0x39 0x66
0x5c 0x64 0x39
0x2
0xa
0x3 0x39
0x5 0x39
0x5c 0x64 0x30
0x5 0x38
0x3 0x63
0x3c
0x5c 0x63 0x37
0x7 0x64
0x9
0xc 0x63
0x3e
0x0 0x62
0x17
0xc 0x61
0x5c 0x63 0x35
0x5c 0x38 0x66
0x38
0x5c 0x64 0x33
0x5c 0x63 0x66
0x5c 0x38 0x30
0x5c 0x63 0x64
0x5c 0x65 0x65
0xc 0x34
0x5c 0x39 0x37
0x5c 0x63 0x32
0x8 0x30
0x1 0x65
0xc 0x32
0xc 0x35
0x6 0x39
0x5c 0x38 0x32
0x5c 0x65 0x61
0x3 0x38
0x5c 0x64 0x34
0x5c 0x65 0x32
0x1 0x61
0x5c 0x63 0x63
0x4 0x65
0x13
0x23
0x2c
0x3a
0x6 0x65
0x3f
0x8 0x39
0x34
0x39
0x5c 0x39 0x65
0x7
0x12
0x35
0xc 0x33
0x8 0x31
0x6 0x66
0x3 0x61
0x5c 0x38 0x36
0x18
0x0 0x39
0x37
0xc 0x39
0x5c 0x65 0x36
0x5c 0x39 0x63
0x3d
0x7 0x33
0x5c 0x38 0x33
0x5c 0x38 0x65
0x5c 0x39 0x34
0x21
0x5c 0x39 0x62
0x14
0x1a
0x7 0x34
0x5c 0x39 0x33
0x5c 0x65 0x34
0x4
0x2d
0x10
0x29
0x5c 0x39 0x35
0x1 0x63
0x20
0xc 0x62
0x7 0x32
0x5 0x61
0x8 0x33
0xc 0x66
0x30
0x5c 0x39 0x38
0x5c 0x38 0x31

Let's say the device on the other end of the serial connection is looking for

"0x01, 0x02, 0x03, 0xbb"

Questions:
Is there a difference between 0x0 and 0x00 when sending over serial? I think it is just a representation of the same information. Therefore, 0x00 IS the same as 0x0, or 0x01 and 0x1.

What is wrong with my variable declaration to make the garbage come out when I print in the loop?

I think something like this will accomplish what I want, assuming 0x01 and 0x1 are the same:

for x in range(256)
    print (" ".join(hex(ord(n)) for n in x))
    serial.write(x)

Thank you.

Answer 1

Well, for one you need to use [ and ] in the variable declaration. In Python, { makes a set , which is unordered. [ makes a list , which is ordered.

Then for the actual content, you need to use \\x00 , not just \\00 . So your declaration should be

mytest = [ '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08', '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f', \
       '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', \
       '\x20', '\x21', '\x22', '\x23', '\x24', '\x25', '\x26', '\x27', '\x28', '\x29', '\x2a', '\x2b', '\x2c', '\x2d', '\x2e', '\x2f', \
       '\x30', '\x31', '\x32', '\x33', '\x34', '\x35', '\x36', '\x37', '\x38', '\x39', '\x3a', '\x3b', '\x3c', '\x3d', '\x3e', '\x3f', \
       '\x40', '\x41', '\x42', '\x43', '\x44', '\x45', '\x46', '\x47', '\x48', '\x49', '\x4a', '\x4b', '\x4c', '\x4d', '\x4e', '\x4f', \
       '\x50', '\x51', '\x52', '\x53', '\x54', '\x55', '\x56', '\x57', '\x58', '\x59', '\x5a', '\x5b', '\x5c', '\x5d', '\x5e', '\x5f', \
       '\x60', '\x61', '\x62', '\x63', '\x64', '\x65', '\x66', '\x67', '\x68', '\x69', '\x6a', '\x6b', '\x6c', '\x6d', '\x6e', '\x6f', \
       '\x70', '\x71', '\x72', '\x73', '\x74', '\x75', '\x76', '\x77', '\x78', '\x79', '\x7a', '\x7b', '\x7c', '\x7d', '\x7e', '\x7f', \
       '\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87', '\x88', '\x89', '\x8a', '\x8b', '\x8c', '\x8d', '\x8e', '\x8f', \
       '\x90', '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97', '\x98', '\x99', '\x9a', '\x9b', '\x9c', '\x9d', '\x9e', '\x9f', \
       '\xa0', '\xa1', '\xa2', '\xa3', '\xa4', '\xa5', '\xa6', '\xa7', '\xa8', '\xa9', '\xaa', '\xab', '\xac', '\xad', '\xae', '\xaf', \
       '\xb0', '\xb1', '\xb2', '\xb3', '\xb4', '\xb5', '\xb6', '\xb7', '\xb8', '\xb9', '\xba', '\xbb', '\xbc', '\xbd', '\xbe', '\xbf', \
       '\xc0', '\xc1', '\xc2', '\xc3', '\xc4', '\xc5', '\xc6', '\xc7', '\xc8', '\xc9', '\xca', '\xcb', '\xcc', '\xcd', '\xce', '\xcf', \
       '\xd0', '\xd1', '\xd2', '\xd3', '\xd4', '\xd5', '\xd6', '\xd7', '\xd8', '\xd9', '\xda', '\xdb', '\xdc', '\xdd', '\xde', '\xdf', \
       '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7', '\xe8', '\xe9', '\xea', '\xeb', '\xec', '\x1e', '\xee', '\xef', \
       '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf7', '\xf8', '\xf9', '\xfa', '\xfb', '\xfc', '\xfd', '\xfe', '\xff' ]

I'm not sure what the intention was with the line

print (" ".join(hex(ord(n)) for n in c))

If there is only one character in the string c , which there is, you can just do print(hex(ord(c)))