def __init__(self, mem_desc, struct): """ Attach to an existing queue or create a new one at the location defined by the pool parameter. Parameters ---------- addr Address of an memory area. size Size of the memory area at addr struct Definition of an uctype structure. This describes the messages we will manage in the queue. magic Optional. """ hdr_size = uctypes.sizeof(FIFO_HEADER) elem_size = uctypes.sizeof(struct) hdr = uctypes.struct(mem_desc.addr, FIFO_HEADER) entries = (mem_desc.size - hdr_size) // elem_size if hdr.magic != FIFO_MAGIC or hdr.elem_size != elem_size or hdr.elements != entries: print("MemFifo: init queue") hdr.rd_i = 0 hdr.wr_i = 0 hdr.elem_size = elem_size hdr.elements = entries hdr.magic = FIFO_MAGIC hdr.full = False self._hdr = hdr self._data_addr = mem_desc.addr + uctypes.sizeof(self._hdr) self._struct = struct
def __init__(self, path): self._fbdev = open(path, 'w+') self._fix_info_data = bytearray(sizeof(_fb_fix_screeninfo)) fd = self._fbdev.fileno() ioctl(fd, _FBIOGET_FSCREENINFO, self._fix_info_data, mut=True) self._fix_info = struct(addressof(self._fix_info_data), _fb_fix_screeninfo) self._var_info_data = bytearray(sizeof(_fb_var_screeninfo)) ioctl(fd, _FBIOGET_VSCREENINFO, self._var_info_data, mut=True) self._var_info = struct(addressof(self._var_info_data), _fb_var_screeninfo) self._fb_data = {}
def __init__(self): self._fbdev = open('/dev/fb0', 'w+') self._fix_info_data = bytearray(uctypes.sizeof(fb_fix_screeninfo)) fd = self._fbdev.fileno() ioctl(fd, FBIOGET_FSCREENINFO, self._fix_info_data, mut=True) self._fix_info = uctypes.struct(uctypes.addressof(self._fix_info_data), fb_fix_screeninfo) self._var_info_data = bytearray(uctypes.sizeof(fb_var_screeninfo)) ioctl(fd, FBIOGET_VSCREENINFO, self._var_info_data, mut=True) self._var_info = uctypes.struct(uctypes.addressof(self._var_info_data), fb_var_screeninfo) self._fb_data = {}
def codeobj2rawcode(codeobj): buf = bytearray(uctypes.sizeof(mp_raw_code_t_layout)) rc = uctypes.struct(uctypes.addressof(buf), mp_raw_code_t_layout) rc.kind = 2 # MP_CODE_BYTECODE rc.fun_data = uctypes.addressof(codeobj.get_code()) rc.const_table = uctypes.addressof(codeobj.get_const_table()) return rc
def __init__(self, addr, size): self._head = uctypes.struct(addr, POOL_DEF) if self._head.magic != POOL_MAGIC: print("create new pool, addr={:x}, size={}".format(addr, size)) self._head.magic = POOL_MAGIC self._head.top = addr + size self._head.addr = addr + uctypes.sizeof(POOL_DEF)
def __init__(self): self._beep_dev = open(_BEEP_DEV, 'b+') self._mixer = Mixer() self._pcm = PCM() self._tone_data = bytearray(sizeof(_input_event)) self._tone_event = struct(addressof(self._tone_data), _input_event) self._timeout = Timeout(0, None) self._cancel = None self._lock = _thread.allocate_lock()
def get_bluetooth_rfcomm_socket(address, channel): addr_data = bytearray(sizeof(sockaddr_rc)) addr = struct(addressof(addr_data), sockaddr_rc) addr.rc_family = AF_BLUETOOTH str2ba(address, addr.rc_bdaddr) addr.rc_channel = channel sock = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM) sock.connect(addr_data) return sock
def __init__(self): self._sock = socket(_AF_BLUETOOTH, SOCK_STREAM, _BTPROTO_RFCOMM) addr_data = bytearray(sizeof(_sockaddr_rc)) addr = struct(addressof(addr_data), _sockaddr_rc) addr.rc_family = _AF_BLUETOOTH _str2ba(_BDADDR_ANY, addr.rc_bdaddr) addr.rc_channel = 1 self._sock.bind(addr_data)
def __init__(self, path): info_data = bytearray(sizeof(_SF_INFO)) info = struct(addressof(info_data), _SF_INFO) self._file = _sf_open(path, _SMF_READ, info_data) if not self._file: raise SoundFileError(_sf_strerror(0)) self._frames = info.frames self._samplerate = info.samplerate self._channels = info.channels self._format = info.format self._sections = info.sections self._seekable = bool(info.seekable)
def __init__(self, name): # TODO: Need a way to convert name to MAC address (maybe) self._sock = socket(_AF_BLUETOOTH, SOCK_STREAM, _BTPROTO_RFCOMM) addr_data = bytearray(sizeof(_sockaddr_rc)) addr = struct(addressof(addr_data), _sockaddr_rc) addr.rc_family = _AF_BLUETOOTH _str2ba(name, addr.rc_bdaddr) addr.rc_channel = 1 self._sock.connect(addr_data)
def handle_request(self): addr_data = bytearray(sizeof(sockaddr_rc)) addr = struct(addressof(addr_data), sockaddr_rc) addr.rc_family = AF_BLUETOOTH str2ba(self.client_address[0], addr.rc_bdaddr) addr.rc_channel = self.client_address[1] self.socket.connect(addr_data) try: self.process_request(self.socket, self.client_address) except: self.socket.close() raise
def __init__(self, server_address, RequestHandlerClass): self.server_address = server_address self.RequestHandlerClass = RequestHandlerClass self.socket = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM) try: addr_data = bytearray(sizeof(sockaddr_rc)) addr = struct(addressof(addr_data), sockaddr_rc) addr.rc_family = AF_BLUETOOTH str2ba(server_address[0], addr.rc_bdaddr) addr.rc_channel = server_address[1] self.socket.bind(addr_data) # self.server_address = self.socket.getsockname() self.socket.listen(self.request_queue_size) except: self.server_close() raise
def __getattr__(self, name): if name == "evtcode": return self._evtcode elif name == "evtname": return self._evtname elif name == "subevtcode": return self._subevtcode elif name == "subevtname": return self._subevtname elif name == "struct_size": return uctypes.sizeof(self.struct) elif name == "struct": if self._struct is None: return None return uctypes.struct(uctypes.addressof(self.data), self._struct.get(self._module, self._struct), uctypes.LITTLE_ENDIAN) elif name == "length": return len(self._data) if self._data else 0 elif name == "data": return self._data[:self.length]
def update_display(disp_list, value): # update the time on the displays font_name = font[selected_face] for tft in disp_list: number = value % 10 value //= 10 path = root + '//' + font_name + '//' + digits[number] + '.raw' with open(path, mode='rb') as f: buf = f.read(uctypes.sizeof(IMG_HEADER, uctypes.LITTLE_ENDIAN)) header = uctypes.struct(uctypes.addressof(buf), IMG_HEADER, uctypes.LITTLE_ENDIAN) width = header.width height = header.height buffer = bytearray(width * height) f.readinto(buffer, width * height) f.close() fb = framebuf.FrameBuffer(buffer, width, height, framebuf.GS8) colorfb = fb.pixel(0, 0) tft.fill(colorfb) tft.blit(fb, (tft.width - width) // 2, (tft.height - height) // 2) tft.show()
import uctypes S1 = {} assert uctypes.sizeof(S1) == 0 S2 = {"a": uctypes.UINT8 | 0} assert uctypes.sizeof(S2) == 1 S3 = { "a": uctypes.UINT8 | 0, "b": uctypes.UINT8 | 1, } assert uctypes.sizeof(S3) == 2 S4 = { "a": uctypes.UINT8 | 0, "b": uctypes.UINT32 | 4, "c": uctypes.UINT8 | 8, } assert uctypes.sizeof(S4) == 12 S5 = { "a": uctypes.UINT8 | 0, "b": uctypes.UINT32 | 4, "c": uctypes.UINT8 | 8, "d": uctypes.UINT32 | 0, "sub": (4, { "b0": uctypes.UINT8 | 0, "b1": uctypes.UINT8 | 1, }), }
def new(sdesc): buf = bytearray(uctypes.sizeof(sdesc)) s = uctypes.struct(uctypes.addressof(buf), sdesc, uctypes.NATIVE) return s
try: import uctypes except ImportError: print("SKIP") raise SystemExit print(uctypes.sizeof({'f': uctypes.FLOAT32})) print(uctypes.sizeof({'f': uctypes.FLOAT64}))
import sys import uctypes if sys.byteorder != "little": print("SKIP") sys.exit() desc = { "ptr": (uctypes.PTR | 0, uctypes.UINT8), "ptr16": (uctypes.PTR | 0, uctypes.UINT16), "ptr2": (uctypes.PTR | 0, {"b": uctypes.UINT8 | 0}), } bytes = b"01" addr = uctypes.addressof(bytes) buf = addr.to_bytes(uctypes.sizeof(desc), "little") S = uctypes.struct(uctypes.addressof(buf), desc, uctypes.LITTLE_ENDIAN) print(S.ptr[0]) assert S.ptr[0] == ord("0") print(S.ptr[1]) assert S.ptr[1] == ord("1") print(hex(S.ptr16[0])) assert hex(S.ptr16[0]) == "0x3130" print(S.ptr2[0].b, S.ptr2[1].b) print(S.ptr2[0].b, S.ptr2[1].b) print(hex(S.ptr16[0])) assert (S.ptr2[0].b, S.ptr2[1].b) == (48, 49)
_I2C_FUNC_SMBUS_WRITE_WORD_DATA = const(0x00400000) _I2C_FUNC_SMBUS_PROC_CALL = const(0x00800000) _I2C_FUNC_SMBUS_READ_BLOCK_DATA = const(0x01000000) _I2C_FUNC_SMBUS_WRITE_BLOCK_DATA = const(0x02000000) _I2C_FUNC_SMBUS_READ_I2C_BLOCK = const(0x04000000) _I2C_FUNC_SMBUS_WRITE_I2C_BLOCK = const(0x08000000) _I2C_SMBUS_BLOCK_MAX = const(32) _i2c_smbus_data = { 'byte': UINT8 | 0, 'word': UINT16 | 0, 'block': (ARRAY | 0, UINT8 | (_I2C_SMBUS_BLOCK_MAX + 2)) } _size_of_i2c_smbus_data = sizeof(_i2c_smbus_data) _I2C_SMBUS_READ = const(1) _I2C_SMBUS_WRITE = const(0) _I2C_SMBUS_QUICK = const(0) _I2C_SMBUS_BYTE = const(1) _I2C_SMBUS_BYTE_DATA = const(2) _I2C_SMBUS_WORD_DATA = const(3) _I2C_SMBUS_PROC_CALL = const(4) _I2C_SMBUS_BLOCK_DATA = const(5) _I2C_SMBUS_I2C_BLOCK_BROKEN = const(6) _I2C_SMBUS_BLOCK_PROC_CALL = const(7) _I2C_SMBUS_I2C_BLOCK_DATA = const(8) # from linux/i2c-dev.h
try: import uctypes except ImportError: print("SKIP") raise SystemExit desc = { "f1": 0 | uctypes.UINT32, "f2": 4 | uctypes.UINT8, } # uctypes.NATIVE is default print(uctypes.sizeof(desc) == uctypes.sizeof(desc, uctypes.NATIVE)) # Here we assume that that we run on a platform with convential ABI # (which rounds up structure size based on max alignment). For platforms # where that doesn't hold, this tests should be just disabled in the runner. print( uctypes.sizeof(desc, uctypes.NATIVE) > uctypes.sizeof( desc, uctypes.LITTLE_ENDIAN)) # When taking sizeof of instantiated structure, layout type param # is prohibited (because structure already has its layout type). s = uctypes.struct(0, desc, uctypes.LITTLE_ENDIAN) try: uctypes.sizeof(s, uctypes.LITTLE_ENDIAN) except TypeError: print("TypeError")
"sub": ( 0, { "b1": uctypes.BFUINT8 | 0 | 4 << uctypes.BF_POS | 4 << uctypes.BF_LEN, "b2": uctypes.BFUINT8 | 0 | 0 << uctypes.BF_POS | 4 << uctypes.BF_LEN, }, ), } data = bytearray(b"01234567") S = uctypes.struct(uctypes.addressof(data), desc, uctypes.LITTLE_ENDIAN) print(uctypes.sizeof(S.arr)) assert uctypes.sizeof(S.arr) == 2 print(uctypes.sizeof(S.arr2)) assert uctypes.sizeof(S.arr2) == 2 print(uctypes.sizeof(S.arr3)) try: print(uctypes.sizeof(S.arr3[0])) except TypeError: print("TypeError") print(uctypes.sizeof(S.arr4)) assert uctypes.sizeof(S.arr4) == 6
"arr": (uctypes.ARRAY | 0, uctypes.UINT8 | 2), # arr2 is array at offset 0, size 2, of structures defined recursively "arr2": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0}), "arr3": (uctypes.ARRAY | 2, uctypes.UINT16 | 2), "arr4": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0, "w": uctypes.UINT16 | 1}), "sub": (0, { 'b1': uctypes.BFUINT8 | 0 | 4 << uctypes.BF_POS | 4 << uctypes.BF_LEN, 'b2': uctypes.BFUINT8 | 0 | 0 << uctypes.BF_POS | 4 << uctypes.BF_LEN, }), } data = bytearray(b"01234567") S = uctypes.struct(uctypes.addressof(data), desc, uctypes.LITTLE_ENDIAN) print(uctypes.sizeof(S.arr)) assert uctypes.sizeof(S.arr) == 2 print(uctypes.sizeof(S.arr2)) assert uctypes.sizeof(S.arr2) == 2 print(uctypes.sizeof(S.arr3)) try: print(uctypes.sizeof(S.arr3[0])) except TypeError: print("TypeError") print(uctypes.sizeof(S.arr4)) assert uctypes.sizeof(S.arr4) == 6
_I2C_FUNC_SMBUS_WRITE_WORD_DATA = 0x00400000 _I2C_FUNC_SMBUS_PROC_CALL = 0x00800000 _I2C_FUNC_SMBUS_READ_BLOCK_DATA = 0x01000000 _I2C_FUNC_SMBUS_WRITE_BLOCK_DATA = 0x02000000 _I2C_FUNC_SMBUS_READ_I2C_BLOCK = 0x04000000 _I2C_FUNC_SMBUS_WRITE_I2C_BLOCK = 0x08000000 _I2C_SMBUS_BLOCK_MAX = 32 _i2c_smbus_data = { 'byte': uctypes.UINT8 | 0, 'word': uctypes.UINT16 | 0, 'block': (uctypes.ARRAY | 0, uctypes.UINT8 | (_I2C_SMBUS_BLOCK_MAX + 2)) } _size_of_i2c_smbus_data = uctypes.sizeof(_i2c_smbus_data) _I2C_SMBUS_READ = 1 _I2C_SMBUS_WRITE = 0 _I2C_SMBUS_QUICK = 0 _I2C_SMBUS_BYTE = 1 _I2C_SMBUS_BYTE_DATA = 2 _I2C_SMBUS_WORD_DATA = 3 _I2C_SMBUS_PROC_CALL = 4 _I2C_SMBUS_BLOCK_DATA = 5 _I2C_SMBUS_I2C_BLOCK_BROKEN = 6 _I2C_SMBUS_BLOCK_PROC_CALL = 7 _I2C_SMBUS_I2C_BLOCK_DATA = 8 # from linux/i2c-dev.h
def overlay_struct(buf, desc): desc_size = uctypes.sizeof(desc, uctypes.BIG_ENDIAN) if desc_size > len(buf): raise ValueError("desc is too big (%d > %d)" % (desc_size, len(buf))) return uctypes.struct(uctypes.addressof(buf), desc, uctypes.BIG_ENDIAN)
try: import uctypes except ImportError: print("SKIP") raise SystemExit print(uctypes.sizeof({'f':uctypes.FLOAT32})) print(uctypes.sizeof({'f':uctypes.FLOAT64}))
# Test uctypes array, load and store, with array size > 1 try: import uctypes except ImportError: print("SKIP") raise SystemExit N = 5 for endian in ("NATIVE", "LITTLE_ENDIAN", "BIG_ENDIAN"): for type_ in ("INT8", "UINT8", "INT16", "UINT16", "INT32", "UINT32", "INT64", "UINT64"): desc = {"arr": (uctypes.ARRAY | 0, getattr(uctypes, type_) | N)} sz = uctypes.sizeof(desc) data = bytearray(sz) s = uctypes.struct(uctypes.addressof(data), desc, getattr(uctypes, endian)) for i in range(N): try: s.arr[i] = i - 2 except OverflowError: print("OverflowError") print(endian, type_, sz, *(s.arr[i] for i in range(N)))
if sys.byteorder != "little": print("SKIP") raise SystemExit desc = { "ptr": (uctypes.PTR | 0, uctypes.UINT8), "ptr16": (uctypes.PTR | 0, uctypes.UINT16), "ptr2": (uctypes.PTR | 0, { "b": uctypes.UINT8 | 0 }), } bts = b"01" addr = uctypes.addressof(bts) buf = addr.to_bytes(uctypes.sizeof(desc, uctypes.LITTLE_ENDIAN), "little") S = uctypes.struct(uctypes.addressof(buf), desc, uctypes.LITTLE_ENDIAN) print(addr == int(S.ptr)) print(addr == int(S.ptr2)) print(S.ptr[0]) assert S.ptr[0] == ord("0") print(S.ptr[1]) assert S.ptr[1] == ord("1") print(hex(S.ptr16[0])) assert hex(S.ptr16[0]) == "0x3130" print(S.ptr2[0].b, S.ptr2[1].b) print(S.ptr2[0].b, S.ptr2[1].b) print(hex(S.ptr16[0]))
if sys.byteorder != "little": print("SKIP") sys.exit() desc = { "ptr": (uctypes.PTR | 0, uctypes.UINT8), "ptr16": (uctypes.PTR | 0, uctypes.UINT16), "ptr2": (uctypes.PTR | 0, { "b": uctypes.UINT8 | 0 }), } bytes = b"01" addr = uctypes.addressof(bytes) buf = addr.to_bytes(uctypes.sizeof(desc)) S = uctypes.struct(uctypes.addressof(buf), desc, uctypes.LITTLE_ENDIAN) print(S.ptr[0]) assert S.ptr[0] == ord("0") print(S.ptr[1]) assert S.ptr[1] == ord("1") print(hex(S.ptr16[0])) assert hex(S.ptr16[0]) == "0x3130" print(S.ptr2[0].b, S.ptr2[1].b) print(S.ptr2[0].b, S.ptr2[1].b) print(hex(S.ptr16[0])) assert (S.ptr2[0].b, S.ptr2[1].b) == (48, 49)
import uctypes desc = { # arr is array at offset 0, of UINT8 elements, array size is 2 "arr": (uctypes.ARRAY | 0, uctypes.UINT8 | 2), # arr2 is array at offset 0, size 2, of structures defined recursively "arr2": (uctypes.ARRAY | 0, 2, { "b": uctypes.UINT8 | 0 }), "arr3": (uctypes.ARRAY | 2, uctypes.UINT16 | 2), } data = bytearray(b"01234567") S = uctypes.struct(uctypes.addressof(data), desc, uctypes.LITTLE_ENDIAN) print(uctypes.sizeof(S.arr)) assert uctypes.sizeof(S.arr) == 2 print(uctypes.sizeof(S.arr2)) assert uctypes.sizeof(S.arr2) == 2 print(uctypes.sizeof(S.arr3)) try: print(uctypes.sizeof(S.arr3[0])) except TypeError: print("TypeError")
import uctypes desc = { # arr is array at offset 0, of UINT8 elements, array size is 2 "arr": (uctypes.ARRAY | 0, uctypes.UINT8 | 2), # arr2 is array at offset 0, size 2, of structures defined recursively "arr2": (uctypes.ARRAY | 0, 2, {"b": uctypes.UINT8 | 0}), "arr3": (uctypes.ARRAY | 2, uctypes.UINT16 | 2), } data = bytearray(b"01234567") S = uctypes.struct(uctypes.addressof(data), desc, uctypes.LITTLE_ENDIAN) print(uctypes.sizeof(S.arr)) assert uctypes.sizeof(S.arr) == 2 print(uctypes.sizeof(S.arr2)) assert uctypes.sizeof(S.arr2) == 2 print(uctypes.sizeof(S.arr3)) try: print(uctypes.sizeof(S.arr3[0])) except TypeError: print("TypeError")
import lvgl as lv import ustruct import uctypes # Calculate pointer size on current machine, and corresponding fmt ptr_size = uctypes.sizeof({'p': (uctypes.PTR, uctypes.VOID)}) fmt_options = {2: 'H', 4: 'L', 8: 'Q'} buf_fmt = fmt_options[ptr_size] if ptr_size in fmt_options else None def aligned_buf(buf, alignment): """Return an aligned buffer Given a buffer, return a memory view within that buffer, which starts at an aligned address in RAM. The returned memory view is possibly smaller. !! You must keep a reference to the original buffer to prevent the garbage collector from collecting the aligned view! Arguments: buf -- An object that implements buffer protocol alignment -- Integer value """ p = lv.C_Pointer() p.ptr_val = buf if not buf_fmt: return None
import uctypes if sys.byteorder != "little": print("SKIP") sys.exit() desc = { "ptr": (uctypes.PTR | 0, uctypes.UINT8), "ptr16": (uctypes.PTR | 0, uctypes.UINT16), "ptr2": (uctypes.PTR | 0, {"b": uctypes.UINT8 | 0}), } bytes = b"01" addr = uctypes.addressof(bytes) buf = addr.to_bytes(uctypes.sizeof(desc)) S = uctypes.struct(uctypes.addressof(buf), desc, uctypes.NATIVE) print(S.ptr[0]) assert S.ptr[0] == ord("0") print(S.ptr[1]) assert S.ptr[1] == ord("1") print(hex(S.ptr16[0])) assert hex(S.ptr16[0]) == "0x3130" print(S.ptr2[0].b, S.ptr2[1].b) print (S.ptr2[0].b, S.ptr2[1].b) print(hex(S.ptr16[0])) assert (S.ptr2[0].b, S.ptr2[1].b) == (48, 49)
try: import uctypes except ImportError: print("SKIP") raise SystemExit desc = { "f1": 0 | uctypes.UINT32, "f2": 4 | uctypes.UINT8, } # uctypes.NATIVE is default print(uctypes.sizeof(desc) == uctypes.sizeof(desc, uctypes.NATIVE)) # Here we assume that that we run on a platform with convential ABI # (which rounds up structure size based on max alignment). For platforms # where that doesn't hold, this tests should be just disabled in the runner. print(uctypes.sizeof(desc, uctypes.NATIVE) > uctypes.sizeof(desc, uctypes.LITTLE_ENDIAN)) # When taking sizeof of instantiated structure, layout type param # is prohibited (because structure already has its layout type). s = uctypes.struct(0, desc, uctypes.LITTLE_ENDIAN) try: uctypes.sizeof(s, uctypes.LITTLE_ENDIAN) except TypeError: print("TypeError")
if sys.byteorder != "little": print("SKIP") raise SystemExit desc = { "ptr": (uctypes.PTR | 0, uctypes.UINT8), "ptr16": (uctypes.PTR | 0, uctypes.UINT16), "ptr2": (uctypes.PTR | 0, { "b": uctypes.UINT8 | 0 }), } bytes = b"01" addr = uctypes.addressof(bytes) buf = addr.to_bytes(uctypes.sizeof(desc), sys.byteorder) S = uctypes.struct(uctypes.addressof(buf), desc, uctypes.NATIVE) print(S.ptr[0]) assert S.ptr[0] == ord("0") print(S.ptr[1]) assert S.ptr[1] == ord("1") print(hex(S.ptr16[0])) assert hex(S.ptr16[0]) == "0x3130" print(S.ptr2[0].b, S.ptr2[1].b) print(S.ptr2[0].b, S.ptr2[1].b) print(hex(S.ptr16[0])) assert (S.ptr2[0].b, S.ptr2[1].b) == (48, 49)
def make_struct(desc): desc_size = uctypes.sizeof(desc, uctypes.BIG_ENDIAN) buf = bytearray(desc_size) return buf, uctypes.struct(uctypes.addressof(buf), desc, uctypes.BIG_ENDIAN)
raise SystemExit if sys.byteorder != "little": print("SKIP") raise SystemExit desc = { "ptr": (uctypes.PTR | 0, uctypes.UINT8), "ptr16": (uctypes.PTR | 0, uctypes.UINT16), "ptr2": (uctypes.PTR | 0, {"b": uctypes.UINT8 | 0}), } bytes = b"01" addr = uctypes.addressof(bytes) buf = addr.to_bytes(uctypes.sizeof(desc), "little") S = uctypes.struct(uctypes.addressof(buf), desc, uctypes.NATIVE) print(S.ptr[0]) assert S.ptr[0] == ord("0") print(S.ptr[1]) assert S.ptr[1] == ord("1") print(hex(S.ptr16[0])) assert hex(S.ptr16[0]) == "0x3130" print(S.ptr2[0].b, S.ptr2[1].b) print(S.ptr2[0].b, S.ptr2[1].b) print(hex(S.ptr16[0])) assert (S.ptr2[0].b, S.ptr2[1].b) == (48, 49)