+from typing import overload
+from stdc import intptr
+
+class gpio_config:
+ direction: int # (gpio_direction_t)
+ edge: int # (gpio_edge_t)
+ event_clock: int # (gpio_event_clock_t)
+ debounce_us: int # (uint32_t)
+ bias: int # (gpio_bias_t)
+ drive: int # (gpio_drive_t)
+ inverted: bool # (bool)
+ label: str # (const char*)
+
+ @overload
+ def __init__(self): ...
+ @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)
+ patch: int # (unsigned)
+ commit_id: str # (const char*)
+
+ @overload
+ def __init__(self): ...
+ @overload
+ def __init__(self, major: int, minor: int, patch: int, commit_id: str): ...
+
+def gpio_new() -> intptr:
+ """Wraps `gpio_t* gpio_new()`"""
+
+def gpio_open(gpio: intptr, path: str, line: int, direction: int, /) -> int:
+ """Wraps `int gpio_open(gpio_t* gpio, const char* path, unsigned line, gpio_direction_t direction)`"""
+
+def gpio_open_name(gpio: intptr, path: str, name: str, direction: int, /) -> int:
+ """Wraps `int gpio_open_name(gpio_t* gpio, const char* path, const char* name, gpio_direction_t direction)`"""
+
+def gpio_open_advanced(gpio: intptr, path: str, line: int, config: intptr, /) -> int:
+ """Wraps `int gpio_open_advanced(gpio_t* gpio, const char* path, unsigned line, const gpio_config_t* config)`"""
+
+def gpio_open_name_advanced(gpio: intptr, path: str, name: str, config: intptr, /) -> int:
+ """Wraps `int gpio_open_name_advanced(gpio_t* gpio, const char* path, const char* name, const gpio_config_t* config)`"""
+
+def gpio_open_sysfs(gpio: intptr, line: int, direction: int, /) -> int:
+ """Wraps `int gpio_open_sysfs(gpio_t* gpio, unsigned line, gpio_direction_t direction)`"""
+
+def gpio_read(gpio: intptr, value: intptr, /) -> int:
+ """Wraps `int gpio_read(gpio_t* gpio, bool* value)`"""
+
+def gpio_write(gpio: intptr, value: bool, /) -> int:
+ """Wraps `int gpio_write(gpio_t* gpio, bool value)`"""
+
+def gpio_poll(gpio: intptr, timeout_ms: int, /) -> int:
+ """Wraps `int gpio_poll(gpio_t* gpio, int timeout_ms)`"""
+
+def gpio_close(gpio: intptr, /) -> int:
+ """Wraps `int gpio_close(gpio_t* gpio)`"""
+
+def gpio_free(gpio: intptr, /) -> None:
+ """Wraps `void gpio_free(gpio_t* gpio)`"""
+
+def gpio_read_event(gpio: intptr, edge: intptr, timestamp: intptr, /) -> int:
+ """Wraps `int gpio_read_event(gpio_t* gpio, gpio_edge_t* edge, uint64_t* timestamp)`"""
+
+def gpio_poll_multiple(gpios: intptr, count: int, timeout_ms: int, gpios_ready: intptr, /) -> int:
+ """Wraps `int gpio_poll_multiple(gpio_t** gpios, size_t count, int timeout_ms, bool* gpios_ready)`"""
+
+def gpio_get_direction(gpio: intptr, direction: intptr, /) -> int:
+ """Wraps `int gpio_get_direction(gpio_t* gpio, gpio_direction_t* direction)`"""
+
+def gpio_get_edge(gpio: intptr, edge: intptr, /) -> int:
+ """Wraps `int gpio_get_edge(gpio_t* gpio, gpio_edge_t* edge)`"""
+
+def gpio_get_event_clock(gpio: intptr, event_clock: intptr, /) -> int:
+ """Wraps `int gpio_get_event_clock(gpio_t* gpio, gpio_event_clock_t* event_clock)`"""
+
+def gpio_get_debounce_us(gpio: intptr, debounce_us: intptr, /) -> int:
+ """Wraps `int gpio_get_debounce_us(gpio_t* gpio, uint32_t* debounce_us)`"""
+
+def gpio_get_bias(gpio: intptr, bias: intptr, /) -> int:
+ """Wraps `int gpio_get_bias(gpio_t* gpio, gpio_bias_t* bias)`"""
+
+def gpio_get_drive(gpio: intptr, drive: intptr, /) -> int:
+ """Wraps `int gpio_get_drive(gpio_t* gpio, gpio_drive_t* drive)`"""
+
+def gpio_get_inverted(gpio: intptr, inverted: intptr, /) -> int:
+ """Wraps `int gpio_get_inverted(gpio_t* gpio, bool* inverted)`"""
+
+def gpio_set_direction(gpio: intptr, direction: int, /) -> int:
+ """Wraps `int gpio_set_direction(gpio_t* gpio, gpio_direction_t direction)`"""
+
+def gpio_set_edge(gpio: intptr, edge: int, /) -> int:
+ """Wraps `int gpio_set_edge(gpio_t* gpio, gpio_edge_t edge)`"""
+
+def gpio_set_event_clock(gpio: intptr, event_clock: int, /) -> int:
+ """Wraps `int gpio_set_event_clock(gpio_t* gpio, gpio_event_clock_t event_clock)`"""
+
+def gpio_set_debounce_us(gpio: intptr, debounce_us: int, /) -> int:
+ """Wraps `int gpio_set_debounce_us(gpio_t* gpio, uint32_t debounce_us)`"""
+
+def gpio_set_bias(gpio: intptr, bias: int, /) -> int:
+ """Wraps `int gpio_set_bias(gpio_t* gpio, gpio_bias_t bias)`"""
+
+def gpio_set_drive(gpio: intptr, drive: int, /) -> int:
+ """Wraps `int gpio_set_drive(gpio_t* gpio, gpio_drive_t drive)`"""
+
+def gpio_set_inverted(gpio: intptr, inverted: bool, /) -> int:
+ """Wraps `int gpio_set_inverted(gpio_t* gpio, bool inverted)`"""
+
+def gpio_line(gpio: intptr, /) -> int:
+ """Wraps `unsigned gpio_line(gpio_t* gpio)`"""
+
+def gpio_fd(gpio: intptr, /) -> int:
+ """Wraps `int gpio_fd(gpio_t* gpio)`"""
+
+def gpio_name(gpio: intptr, str: intptr, len: int, /) -> int:
+ """Wraps `int gpio_name(gpio_t* gpio, char* str, size_t len)`"""
+
+def gpio_label(gpio: intptr, str: intptr, len: int, /) -> int:
+ """Wraps `int gpio_label(gpio_t* gpio, char* str, size_t len)`"""
+
+def gpio_chip_fd(gpio: intptr, /) -> int:
+ """Wraps `int gpio_chip_fd(gpio_t* gpio)`"""
+
+def gpio_chip_name(gpio: intptr, str: intptr, len: int, /) -> int:
+ """Wraps `int gpio_chip_name(gpio_t* gpio, char* str, size_t len)`"""
+
+def gpio_chip_label(gpio: intptr, str: intptr, len: int, /) -> int:
+ """Wraps `int gpio_chip_label(gpio_t* gpio, char* str, size_t len)`"""
+
+def gpio_tostring(gpio: intptr, str: intptr, len: int, /) -> int:
+ """Wraps `int gpio_tostring(gpio_t* gpio, char* str, size_t len)`"""
+
+def gpio_errno(gpio: intptr, /) -> int:
+ """Wraps `int gpio_errno(gpio_t* gpio)`"""
+
+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()`"""
+
+def pwm_open(pwm: intptr, chip: int, channel: int, /) -> int:
+ """Wraps `int pwm_open(pwm_t* pwm, unsigned chip, unsigned channel)`"""
+
+def pwm_enable(pwm: intptr, /) -> int:
+ """Wraps `int pwm_enable(pwm_t* pwm)`"""
+
+def pwm_disable(pwm: intptr, /) -> int:
+ """Wraps `int pwm_disable(pwm_t* pwm)`"""
+
+def pwm_close(pwm: intptr, /) -> int:
+ """Wraps `int pwm_close(pwm_t* pwm)`"""
+
+def pwm_free(pwm: intptr, /) -> None:
+ """Wraps `void pwm_free(pwm_t* pwm)`"""
+
+def pwm_get_enabled(pwm: intptr, enabled: intptr, /) -> int:
+ """Wraps `int pwm_get_enabled(pwm_t* pwm, bool* enabled)`"""
+
+def pwm_get_period_ns(pwm: intptr, period_ns: intptr, /) -> int:
+ """Wraps `int pwm_get_period_ns(pwm_t* pwm, uint64_t* period_ns)`"""
+
+def pwm_get_duty_cycle_ns(pwm: intptr, duty_cycle_ns: intptr, /) -> int:
+ """Wraps `int pwm_get_duty_cycle_ns(pwm_t* pwm, uint64_t* duty_cycle_ns)`"""
+
+def pwm_get_period(pwm: intptr, period: intptr, /) -> int:
+ """Wraps `int pwm_get_period(pwm_t* pwm, double* period)`"""
+
+def pwm_get_duty_cycle(pwm: intptr, duty_cycle: intptr, /) -> int:
+ """Wraps `int pwm_get_duty_cycle(pwm_t* pwm, double* duty_cycle)`"""
+
+def pwm_get_frequency(pwm: intptr, frequency: intptr, /) -> int:
+ """Wraps `int pwm_get_frequency(pwm_t* pwm, double* frequency)`"""
+
+def pwm_get_polarity(pwm: intptr, polarity: intptr, /) -> int:
+ """Wraps `int pwm_get_polarity(pwm_t* pwm, pwm_polarity_t* polarity)`"""
+
+def pwm_set_enabled(pwm: intptr, enabled: bool, /) -> int:
+ """Wraps `int pwm_set_enabled(pwm_t* pwm, bool enabled)`"""
+
+def pwm_set_period_ns(pwm: intptr, period_ns: int, /) -> int:
+ """Wraps `int pwm_set_period_ns(pwm_t* pwm, uint64_t period_ns)`"""
+
+def pwm_set_duty_cycle_ns(pwm: intptr, duty_cycle_ns: int, /) -> int:
+ """Wraps `int pwm_set_duty_cycle_ns(pwm_t* pwm, uint64_t duty_cycle_ns)`"""
+
+def pwm_set_period(pwm: intptr, period: float, /) -> int:
+ """Wraps `int pwm_set_period(pwm_t* pwm, double period)`"""
+
+def pwm_set_duty_cycle(pwm: intptr, duty_cycle: float, /) -> int:
+ """Wraps `int pwm_set_duty_cycle(pwm_t* pwm, double duty_cycle)`"""
+
+def pwm_set_frequency(pwm: intptr, frequency: float, /) -> int:
+ """Wraps `int pwm_set_frequency(pwm_t* pwm, double frequency)`"""
+
+def pwm_set_polarity(pwm: intptr, polarity: int, /) -> int:
+ """Wraps `int pwm_set_polarity(pwm_t* pwm, pwm_polarity_t polarity)`"""
+
+def pwm_chip(pwm: intptr, /) -> int:
+ """Wraps `unsigned pwm_chip(pwm_t* pwm)`"""
+
+def pwm_channel(pwm: intptr, /) -> int:
+ """Wraps `unsigned pwm_channel(pwm_t* pwm)`"""
+
+def pwm_tostring(pwm: intptr, str: intptr, len: int, /) -> int:
+ """Wraps `int pwm_tostring(pwm_t* pwm, char* str, size_t len)`"""
+
+def pwm_errno(pwm: intptr, /) -> int:
+ """Wraps `int pwm_errno(pwm_t* pwm)`"""
+
+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()`"""
+
+def periphery_version_info() -> intptr:
+ """Wraps `const periphery_version_t* periphery_version_info()`"""
+
+# aliases
+gpio_direction_t = int
+gpio_edge_t = int
+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
+GPIO_ERROR_NOT_FOUND: int
+GPIO_ERROR_QUERY: int
+GPIO_ERROR_CONFIGURE: int
+GPIO_ERROR_UNSUPPORTED: int
+GPIO_ERROR_INVALID_OPERATION: int
+GPIO_ERROR_IO: int
+GPIO_ERROR_CLOSE: int
+GPIO_DIR_IN: int
+GPIO_DIR_OUT: int
+GPIO_DIR_OUT_LOW: int
+GPIO_DIR_OUT_HIGH: int
+GPIO_EDGE_NONE: int
+GPIO_EDGE_RISING: int
+GPIO_EDGE_FALLING: int
+GPIO_EDGE_BOTH: int
+GPIO_EVENT_CLOCK_REALTIME: int
+GPIO_EVENT_CLOCK_MONOTONIC: int
+GPIO_EVENT_CLOCK_HTE: int
+GPIO_BIAS_DEFAULT: int
+GPIO_BIAS_PULL_UP: int
+GPIO_BIAS_PULL_DOWN: int
+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
+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
+
+ 
+ 
+ 
+ 
+ 
+ 
+