add periphery led

3rd/periphery/include/periphery.h

@@ -1,8 +1,8 @@
 #include "../c-periphery/src/gpio.h"
 // #include "../c-periphery/src/i2c.h"
-// #include "../c-periphery/src/led.h"
-// #include "../c-periphery/src/mmio.h"
+#include "../c-periphery/src/led.h"
+#include "../c-periphery/src/mmio.h"
 #include "../c-periphery/src/pwm.h"
-// #include "../c-periphery/src/serial.h"
-// #include "../c-periphery/src/spi.h"
+#include "../c-periphery/src/serial.h"
+#include "../c-periphery/src/spi.h"
 #include "../c-periphery/src/version.h"

ffigen/ffigen/meta/parser.py

@@ -17,6 +17,7 @@ class Header:
             'size_t', 'bool',
             'int8_t', 'int16_t', 'int32_t', 'int64_t',
             'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t',
+            'intptr_t', 'uintptr_t',
         }
         self.functions = [] # type: list[Function]
 
@@ -32,7 +33,7 @@ class Header:
         self.type_aliases[k] = v
 
     def build_enum(self, node: c_ast.Enum, alias_name: str | None = None):
-        enum = Enum(node.name)
+        enum = Enum(node.name, alias_name)
         for item in node.values.enumerators:
             enum.values.append(item.name)
         self.types.append(enum)

ffigen/ffigen/meta/schema.py

@@ -23,8 +23,9 @@ class Struct(NamedFields): pass
 class Union(NamedFields): pass
     
 class Enum:
-    def __init__(self, name: str):
+    def __init__(self, name: str, typedef_name: str | None = None):
         self.name = name
+        self.typedef_name = typedef_name
         self.values = [] # type: list[str]
 
     def __repr__(self):

ffigen/gen_periphery.py

@@ -10,6 +10,17 @@ file_dir = os.path.dirname(os.path.abspath(__file__))
 path = '3rd/periphery/include/periphery.h'
 code = pcpp.CmdPreprocessor([None, path, '-o', 'tmp.h', '-I', os.path.join(file_dir, 'libc_include')])
 
+mapping = {
+    'enum serial_parity parity': 'serial_parity_t parity',
+}
+# remap tmp.h
+with open('tmp.h', 'r') as f:
+    content = f.read()
+for k, v in mapping.items():
+    content = content.replace(k, v)
+with open('tmp.h', 'w') as f:
+    f.write(content)
+
 ast = pycparser.parse_file('tmp.h')
 os.remove('tmp.h')
 

ffigen/libc_include/stdint.h

@@ -6,4 +6,4 @@ typedef int int64_t;
 typedef unsigned uint8_t;
 typedef unsigned uint16_t;
 typedef unsigned uint32_t;
-typedef unsigned uint64_t;
+typedef unsigned uint64_t;

ffigen/libc_include/sys/types.h

@@ -0,0 +1,2 @@
+typedef int intptr_t;
+typedef unsigned uintptr_t;

include/typings/periphery.pyi

@@ -16,6 +16,19 @@ class gpio_config:
     @overload
     def __init__(self, direction: int, edge: int, event_clock: int, debounce_us: int, bias: int, drive: int, inverted: bool, label: str): ...
     
+class spi_msg:
+    txbuf: intptr #  (const uint8_t*)
+    rxbuf: intptr #  (uint8_t*)
+    len: int #  (size_t)
+    deselect: bool #  (bool)
+    deselect_delay_us: int #  (uint16_t)
+    word_delay_us: int #  (uint8_t)
+    
+    @overload
+    def __init__(self): ...
+    @overload
+    def __init__(self, txbuf: intptr, rxbuf: intptr, len: int, deselect: bool, deselect_delay_us: int, word_delay_us: int): ...
+    
 class periphery_version:
     major: int #  (unsigned)
     minor: int #  (unsigned)
@@ -138,6 +151,120 @@ def gpio_errno(gpio: intptr, /) -> int:
 def gpio_errmsg(gpio: intptr, /) -> str:
     """Wraps `const char* gpio_errmsg(gpio_t* gpio)`"""
 
+def led_new() -> intptr:
+    """Wraps `led_t* led_new()`"""
+
+def led_open(led: intptr, name: str, /) -> int:
+    """Wraps `int led_open(led_t* led, const char* name)`"""
+
+def led_read(led: intptr, value: intptr, /) -> int:
+    """Wraps `int led_read(led_t* led, bool* value)`"""
+
+def led_write(led: intptr, value: bool, /) -> int:
+    """Wraps `int led_write(led_t* led, bool value)`"""
+
+def led_close(led: intptr, /) -> int:
+    """Wraps `int led_close(led_t* led)`"""
+
+def led_free(led: intptr, /) -> None:
+    """Wraps `void led_free(led_t* led)`"""
+
+def led_get_brightness(led: intptr, brightness: intptr, /) -> int:
+    """Wraps `int led_get_brightness(led_t* led, unsigned* brightness)`"""
+
+def led_get_max_brightness(led: intptr, max_brightness: intptr, /) -> int:
+    """Wraps `int led_get_max_brightness(led_t* led, unsigned* max_brightness)`"""
+
+def led_get_trigger(led: intptr, str: intptr, len: int, /) -> int:
+    """Wraps `int led_get_trigger(led_t* led, char* str, size_t len)`"""
+
+def led_get_triggers_entry(led: intptr, index: int, str: intptr, len: int, /) -> int:
+    """Wraps `int led_get_triggers_entry(led_t* led, unsigned index, char* str, size_t len)`"""
+
+def led_get_triggers_count(led: intptr, count: intptr, /) -> int:
+    """Wraps `int led_get_triggers_count(led_t* led, unsigned* count)`"""
+
+def led_set_brightness(led: intptr, brightness: int, /) -> int:
+    """Wraps `int led_set_brightness(led_t* led, unsigned brightness)`"""
+
+def led_set_trigger(led: intptr, trigger: str, /) -> int:
+    """Wraps `int led_set_trigger(led_t* led, const char* trigger)`"""
+
+def led_name(led: intptr, str: intptr, len: int, /) -> int:
+    """Wraps `int led_name(led_t* led, char* str, size_t len)`"""
+
+def led_tostring(led: intptr, str: intptr, len: int, /) -> int:
+    """Wraps `int led_tostring(led_t* led, char* str, size_t len)`"""
+
+def led_errno(led: intptr, /) -> int:
+    """Wraps `int led_errno(led_t* led)`"""
+
+def led_errmsg(led: intptr, /) -> str:
+    """Wraps `const char* led_errmsg(led_t* led)`"""
+
+def mmio_new() -> intptr:
+    """Wraps `mmio_t* mmio_new()`"""
+
+def mmio_open(mmio: intptr, base: int, size: int, /) -> int:
+    """Wraps `int mmio_open(mmio_t* mmio, uintptr_t base, size_t size)`"""
+
+def mmio_open_advanced(mmio: intptr, base: int, size: int, path: str, /) -> int:
+    """Wraps `int mmio_open_advanced(mmio_t* mmio, uintptr_t base, size_t size, const char* path)`"""
+
+def mmio_ptr(mmio: intptr, /) -> intptr:
+    """Wraps `void* mmio_ptr(mmio_t* mmio)`"""
+
+def mmio_read64(mmio: intptr, offset: int, value: intptr, /) -> int:
+    """Wraps `int mmio_read64(mmio_t* mmio, uintptr_t offset, uint64_t* value)`"""
+
+def mmio_read32(mmio: intptr, offset: int, value: intptr, /) -> int:
+    """Wraps `int mmio_read32(mmio_t* mmio, uintptr_t offset, uint32_t* value)`"""
+
+def mmio_read16(mmio: intptr, offset: int, value: intptr, /) -> int:
+    """Wraps `int mmio_read16(mmio_t* mmio, uintptr_t offset, uint16_t* value)`"""
+
+def mmio_read8(mmio: intptr, offset: int, value: intptr, /) -> int:
+    """Wraps `int mmio_read8(mmio_t* mmio, uintptr_t offset, uint8_t* value)`"""
+
+def mmio_read(mmio: intptr, offset: int, buf: intptr, len: int, /) -> int:
+    """Wraps `int mmio_read(mmio_t* mmio, uintptr_t offset, uint8_t* buf, size_t len)`"""
+
+def mmio_write64(mmio: intptr, offset: int, value: int, /) -> int:
+    """Wraps `int mmio_write64(mmio_t* mmio, uintptr_t offset, uint64_t value)`"""
+
+def mmio_write32(mmio: intptr, offset: int, value: int, /) -> int:
+    """Wraps `int mmio_write32(mmio_t* mmio, uintptr_t offset, uint32_t value)`"""
+
+def mmio_write16(mmio: intptr, offset: int, value: int, /) -> int:
+    """Wraps `int mmio_write16(mmio_t* mmio, uintptr_t offset, uint16_t value)`"""
+
+def mmio_write8(mmio: intptr, offset: int, value: int, /) -> int:
+    """Wraps `int mmio_write8(mmio_t* mmio, uintptr_t offset, uint8_t value)`"""
+
+def mmio_write(mmio: intptr, offset: int, buf: intptr, len: int, /) -> int:
+    """Wraps `int mmio_write(mmio_t* mmio, uintptr_t offset, const uint8_t* buf, size_t len)`"""
+
+def mmio_close(mmio: intptr, /) -> int:
+    """Wraps `int mmio_close(mmio_t* mmio)`"""
+
+def mmio_free(mmio: intptr, /) -> None:
+    """Wraps `void mmio_free(mmio_t* mmio)`"""
+
+def mmio_base(mmio: intptr, /) -> int:
+    """Wraps `uintptr_t mmio_base(mmio_t* mmio)`"""
+
+def mmio_size(mmio: intptr, /) -> int:
+    """Wraps `size_t mmio_size(mmio_t* mmio)`"""
+
+def mmio_tostring(mmio: intptr, str: intptr, len: int, /) -> int:
+    """Wraps `int mmio_tostring(mmio_t* mmio, char* str, size_t len)`"""
+
+def mmio_errno(mmio: intptr, /) -> int:
+    """Wraps `int mmio_errno(mmio_t* mmio)`"""
+
+def mmio_errmsg(mmio: intptr, /) -> str:
+    """Wraps `const char* mmio_errmsg(mmio_t* mmio)`"""
+
 def pwm_new() -> intptr:
     """Wraps `pwm_t* pwm_new()`"""
 
@@ -213,6 +340,171 @@ def pwm_errno(pwm: intptr, /) -> int:
 def pwm_errmsg(pwm: intptr, /) -> str:
     """Wraps `const char* pwm_errmsg(pwm_t* pwm)`"""
 
+def serial_new() -> intptr:
+    """Wraps `serial_t* serial_new()`"""
+
+def serial_open(serial: intptr, path: str, baudrate: int, /) -> int:
+    """Wraps `int serial_open(serial_t* serial, const char* path, uint32_t baudrate)`"""
+
+def serial_open_advanced(serial: intptr, path: str, baudrate: int, databits: int, parity: int, stopbits: int, xonxoff: bool, rtscts: bool, /) -> int:
+    """Wraps `int serial_open_advanced(serial_t* serial, const char* path, uint32_t baudrate, unsigned databits, serial_parity_t parity, unsigned stopbits, bool xonxoff, bool rtscts)`"""
+
+def serial_read(serial: intptr, buf: intptr, len: int, timeout_ms: int, /) -> int:
+    """Wraps `int serial_read(serial_t* serial, uint8_t* buf, size_t len, int timeout_ms)`"""
+
+def serial_write(serial: intptr, buf: intptr, len: int, /) -> int:
+    """Wraps `int serial_write(serial_t* serial, const uint8_t* buf, size_t len)`"""
+
+def serial_flush(serial: intptr, /) -> int:
+    """Wraps `int serial_flush(serial_t* serial)`"""
+
+def serial_input_waiting(serial: intptr, count: intptr, /) -> int:
+    """Wraps `int serial_input_waiting(serial_t* serial, unsigned* count)`"""
+
+def serial_output_waiting(serial: intptr, count: intptr, /) -> int:
+    """Wraps `int serial_output_waiting(serial_t* serial, unsigned* count)`"""
+
+def serial_poll(serial: intptr, timeout_ms: int, /) -> int:
+    """Wraps `int serial_poll(serial_t* serial, int timeout_ms)`"""
+
+def serial_close(serial: intptr, /) -> int:
+    """Wraps `int serial_close(serial_t* serial)`"""
+
+def serial_free(serial: intptr, /) -> None:
+    """Wraps `void serial_free(serial_t* serial)`"""
+
+def serial_get_baudrate(serial: intptr, baudrate: intptr, /) -> int:
+    """Wraps `int serial_get_baudrate(serial_t* serial, uint32_t* baudrate)`"""
+
+def serial_get_databits(serial: intptr, databits: intptr, /) -> int:
+    """Wraps `int serial_get_databits(serial_t* serial, unsigned* databits)`"""
+
+def serial_get_parity(serial: intptr, parity: intptr, /) -> int:
+    """Wraps `int serial_get_parity(serial_t* serial, serial_parity_t* parity)`"""
+
+def serial_get_stopbits(serial: intptr, stopbits: intptr, /) -> int:
+    """Wraps `int serial_get_stopbits(serial_t* serial, unsigned* stopbits)`"""
+
+def serial_get_xonxoff(serial: intptr, xonxoff: intptr, /) -> int:
+    """Wraps `int serial_get_xonxoff(serial_t* serial, bool* xonxoff)`"""
+
+def serial_get_rtscts(serial: intptr, rtscts: intptr, /) -> int:
+    """Wraps `int serial_get_rtscts(serial_t* serial, bool* rtscts)`"""
+
+def serial_get_vmin(serial: intptr, vmin: intptr, /) -> int:
+    """Wraps `int serial_get_vmin(serial_t* serial, unsigned* vmin)`"""
+
+def serial_get_vtime(serial: intptr, vtime: intptr, /) -> int:
+    """Wraps `int serial_get_vtime(serial_t* serial, float* vtime)`"""
+
+def serial_set_baudrate(serial: intptr, baudrate: int, /) -> int:
+    """Wraps `int serial_set_baudrate(serial_t* serial, uint32_t baudrate)`"""
+
+def serial_set_databits(serial: intptr, databits: int, /) -> int:
+    """Wraps `int serial_set_databits(serial_t* serial, unsigned databits)`"""
+
+def serial_set_parity(serial: intptr, parity: int, /) -> int:
+    """Wraps `int serial_set_parity(serial_t* serial, serial_parity_t parity)`"""
+
+def serial_set_stopbits(serial: intptr, stopbits: int, /) -> int:
+    """Wraps `int serial_set_stopbits(serial_t* serial, unsigned stopbits)`"""
+
+def serial_set_xonxoff(serial: intptr, enabled: bool, /) -> int:
+    """Wraps `int serial_set_xonxoff(serial_t* serial, bool enabled)`"""
+
+def serial_set_rtscts(serial: intptr, enabled: bool, /) -> int:
+    """Wraps `int serial_set_rtscts(serial_t* serial, bool enabled)`"""
+
+def serial_set_vmin(serial: intptr, vmin: int, /) -> int:
+    """Wraps `int serial_set_vmin(serial_t* serial, unsigned vmin)`"""
+
+def serial_set_vtime(serial: intptr, vtime: float, /) -> int:
+    """Wraps `int serial_set_vtime(serial_t* serial, float vtime)`"""
+
+def serial_fd(serial: intptr, /) -> int:
+    """Wraps `int serial_fd(serial_t* serial)`"""
+
+def serial_tostring(serial: intptr, str: intptr, len: int, /) -> int:
+    """Wraps `int serial_tostring(serial_t* serial, char* str, size_t len)`"""
+
+def serial_errno(serial: intptr, /) -> int:
+    """Wraps `int serial_errno(serial_t* serial)`"""
+
+def serial_errmsg(serial: intptr, /) -> str:
+    """Wraps `const char* serial_errmsg(serial_t* serial)`"""
+
+def spi_new() -> intptr:
+    """Wraps `spi_t* spi_new()`"""
+
+def spi_open(spi: intptr, path: str, mode: int, max_speed: int, /) -> int:
+    """Wraps `int spi_open(spi_t* spi, const char* path, unsigned mode, uint32_t max_speed)`"""
+
+def spi_open_advanced(spi: intptr, path: str, mode: int, max_speed: int, bit_order: int, bits_per_word: int, extra_flags: int, /) -> int:
+    """Wraps `int spi_open_advanced(spi_t* spi, const char* path, unsigned mode, uint32_t max_speed, spi_bit_order_t bit_order, uint8_t bits_per_word, uint8_t extra_flags)`"""
+
+def spi_open_advanced2(spi: intptr, path: str, mode: int, max_speed: int, bit_order: int, bits_per_word: int, extra_flags: int, /) -> int:
+    """Wraps `int spi_open_advanced2(spi_t* spi, const char* path, unsigned mode, uint32_t max_speed, spi_bit_order_t bit_order, uint8_t bits_per_word, uint32_t extra_flags)`"""
+
+def spi_transfer(spi: intptr, txbuf: intptr, rxbuf: intptr, len: int, /) -> int:
+    """Wraps `int spi_transfer(spi_t* spi, const uint8_t* txbuf, uint8_t* rxbuf, size_t len)`"""
+
+def spi_transfer_advanced(spi: intptr, msgs: intptr, count: int, /) -> int:
+    """Wraps `int spi_transfer_advanced(spi_t* spi, const spi_msg_t* msgs, size_t count)`"""
+
+def spi_close(spi: intptr, /) -> int:
+    """Wraps `int spi_close(spi_t* spi)`"""
+
+def spi_free(spi: intptr, /) -> None:
+    """Wraps `void spi_free(spi_t* spi)`"""
+
+def spi_get_mode(spi: intptr, mode: intptr, /) -> int:
+    """Wraps `int spi_get_mode(spi_t* spi, unsigned* mode)`"""
+
+def spi_get_max_speed(spi: intptr, max_speed: intptr, /) -> int:
+    """Wraps `int spi_get_max_speed(spi_t* spi, uint32_t* max_speed)`"""
+
+def spi_get_bit_order(spi: intptr, bit_order: intptr, /) -> int:
+    """Wraps `int spi_get_bit_order(spi_t* spi, spi_bit_order_t* bit_order)`"""
+
+def spi_get_bits_per_word(spi: intptr, bits_per_word: intptr, /) -> int:
+    """Wraps `int spi_get_bits_per_word(spi_t* spi, uint8_t* bits_per_word)`"""
+
+def spi_get_extra_flags(spi: intptr, extra_flags: intptr, /) -> int:
+    """Wraps `int spi_get_extra_flags(spi_t* spi, uint8_t* extra_flags)`"""
+
+def spi_get_extra_flags32(spi: intptr, extra_flags: intptr, /) -> int:
+    """Wraps `int spi_get_extra_flags32(spi_t* spi, uint32_t* extra_flags)`"""
+
+def spi_set_mode(spi: intptr, mode: int, /) -> int:
+    """Wraps `int spi_set_mode(spi_t* spi, unsigned mode)`"""
+
+def spi_set_max_speed(spi: intptr, max_speed: int, /) -> int:
+    """Wraps `int spi_set_max_speed(spi_t* spi, uint32_t max_speed)`"""
+
+def spi_set_bit_order(spi: intptr, bit_order: int, /) -> int:
+    """Wraps `int spi_set_bit_order(spi_t* spi, spi_bit_order_t bit_order)`"""
+
+def spi_set_bits_per_word(spi: intptr, bits_per_word: int, /) -> int:
+    """Wraps `int spi_set_bits_per_word(spi_t* spi, uint8_t bits_per_word)`"""
+
+def spi_set_extra_flags(spi: intptr, extra_flags: int, /) -> int:
+    """Wraps `int spi_set_extra_flags(spi_t* spi, uint8_t extra_flags)`"""
+
+def spi_set_extra_flags32(spi: intptr, extra_flags: int, /) -> int:
+    """Wraps `int spi_set_extra_flags32(spi_t* spi, uint32_t extra_flags)`"""
+
+def spi_fd(spi: intptr, /) -> int:
+    """Wraps `int spi_fd(spi_t* spi)`"""
+
+def spi_tostring(spi: intptr, str: intptr, len: int, /) -> int:
+    """Wraps `int spi_tostring(spi_t* spi, char* str, size_t len)`"""
+
+def spi_errno(spi: intptr, /) -> int:
+    """Wraps `int spi_errno(spi_t* spi)`"""
+
+def spi_errmsg(spi: intptr, /) -> str:
+    """Wraps `const char* spi_errmsg(spi_t* spi)`"""
+
 def periphery_version() -> str:
     """Wraps `const char* periphery_version()`"""
 
@@ -226,6 +518,8 @@ gpio_event_clock_t = int
 gpio_bias_t = int
 gpio_drive_t = int
 pwm_polarity_t = int
+serial_parity_t = int
+spi_bit_order_t = int
 # enums
 GPIO_ERROR_ARG: int
 GPIO_ERROR_OPEN: int
@@ -254,10 +548,36 @@ GPIO_BIAS_DISABLE: int
 GPIO_DRIVE_DEFAULT: int
 GPIO_DRIVE_OPEN_DRAIN: int
 GPIO_DRIVE_OPEN_SOURCE: int
+LED_ERROR_ARG: int
+LED_ERROR_OPEN: int
+LED_ERROR_QUERY: int
+LED_ERROR_IO: int
+LED_ERROR_CLOSE: int
+MMIO_ERROR_ARG: int
+MMIO_ERROR_OPEN: int
+MMIO_ERROR_CLOSE: int
 PWM_ERROR_ARG: int
 PWM_ERROR_OPEN: int
 PWM_ERROR_QUERY: int
 PWM_ERROR_CONFIGURE: int
 PWM_ERROR_CLOSE: int
 PWM_POLARITY_NORMAL: int
-PWM_POLARITY_INVERSED: int
+PWM_POLARITY_INVERSED: int
+SERIAL_ERROR_ARG: int
+SERIAL_ERROR_OPEN: int
+SERIAL_ERROR_QUERY: int
+SERIAL_ERROR_CONFIGURE: int
+SERIAL_ERROR_IO: int
+SERIAL_ERROR_CLOSE: int
+PARITY_NONE: int
+PARITY_ODD: int
+PARITY_EVEN: int
+SPI_ERROR_ARG: int
+SPI_ERROR_OPEN: int
+SPI_ERROR_QUERY: int
+SPI_ERROR_CONFIGURE: int
+SPI_ERROR_TRANSFER: int
+SPI_ERROR_CLOSE: int
+SPI_ERROR_UNSUPPORTED: int
+MSB_FIRST: int
+LSB_FIRST: int

include/typings/stdc.pyi

@@ -40,6 +40,7 @@ class UInt(_BuiltinMemory[int]): ...
 class Long(_BuiltinMemory[int]): ...
 class ULong(_BuiltinMemory[int]): ...
 class LongLong(_BuiltinMemory[int]): ...
+class ULongLong(_BuiltinMemory[int]): ...
 
 class Float(_BuiltinMemory[float]): ...
 class Double(_BuiltinMemory[float]): ...
@@ -56,6 +57,9 @@ Int64: _BuiltinMemory[int]
 UInt64: _BuiltinMemory[int]
 SizeT: _BuiltinMemory[int]
 
+IntptrT: _BuiltinMemory[int]
+UintptrT: _BuiltinMemory[int]
+
 def addressof(obj: Memory) -> intptr: ...
 def sizeof(obj: type[Memory]) -> int: ...
 

src/modules/stdc.c

@@ -274,6 +274,15 @@ void pk__add_module_stdc() {
             break;
         }
     }
+    if(sizeof(void*) == 4) {
+        py_setdict(mod, py_name("IntPtrT"), py_getdict(mod, py_name("Int32")));
+        py_setdict(mod, py_name("UIntPtrT"), py_getdict(mod, py_name("UInt32")));
+    } else if(sizeof(void*) == 8) {
+        py_setdict(mod, py_name("IntPtrT"), py_getdict(mod, py_name("Int64")));
+        py_setdict(mod, py_name("UIntPtrT"), py_getdict(mod, py_name("UInt64")));
+    } else {
+        c11__abort("unsupported pointer size");
+    }
 
     pk__bind_stdc_Float(mod);
     pk__bind_stdc_Double(mod);