roboreactor-firmata 0.1.0__tar.gz

roboreactor_firmata-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2026 RoboReactor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

roboreactor_firmata-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: roboreactor-firmata
+Version: 0.1.0
+Summary: A unified, dynamic Firmata control library supporting GPIO, I2C, SPI, UART, and CAN-bus on STM32 and ESP32 microcontrollers
+Author-email: RoboReactor <info@roboreactor.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyfirmata2>=2.4.4
+Requires-Dist: pyserial>=3.5
+Dynamic: license-file
+
+# roboreactor-firmata
+
+A unified, dynamic Firmata client library for configuring and controlling **GPIO**, **I2C**, **SPI**, **UART**, and **CAN-bus** peripherals on **STM32** and **ESP32** microcontrollers.
+
+Instead of being limited to hardcoded hardware pins, `roboreactor-firmata` allows you to dynamically assign peripheral pins at runtime from Python using a custom extended SysEx protocol.
+
+---
+
+## Installation
+
+```bash
+pip install roboreactor-firmata
+```
+
+---
+
+## Firmware Flashing
+
+Before running the Python client, flash the matching custom `.ino` sketch located inside the `firmware/` directory to your microcontroller:
+
+- **STM32**: Flash `StandardFirmataCustom_STM32.ino` (Requires `STM32duino` core and optional `STM32_CAN` library).
+- **ESP32**: Flash `StandardFirmataCustom_ESP32.ino` (Uses ESP32's native Arduino core and built-in `TWAI` CAN driver).
+
+---
+
+## Quick Start Examples
+
+### 1. STM32 Control (e.g., STM32F401RCT6)
+
+```python
+import time
+from roboreactor_firmata import STM32Board
+
+# Connect to the board
+board = STM32Board('/dev/ttyUSB0', mcu='STM32F401RCT6')
+board.samplingOn(50)  # Start polling thread
+
+# --- 1. Dynamic I2C Config ---
+board.configure_custom_i2c(sda_pin="PB9", scl_pin="PB8")
+board.i2c_config()
+
+def i2c_callback(data):
+    print(f"I2C Data: {data}")
+
+board.i2c_read(0x68, 0x75, 1, callback=i2c_callback)
+
+# --- 2. Dynamic UART Config ---
+def uart_callback(data):
+    print(f"UART Rx: {data}")
+
+board.configure_custom_uart(rx_pin="PA3", tx_pin="PA2", baudrate=9600, callback=uart_callback)
+board.uart_write(b"Hello STM32")
+
+# --- 3. Dynamic SPI Config ---
+def spi_callback(data):
+    print(f"SPI Rx: {data}")
+
+board.configure_custom_spi(mosi="PA7", miso="PA6", sclk="PA5", cs="PA4")
+board.spi_transfer("PA4", [0x9F, 0x00, 0x00, 0x00], callback=spi_callback)
+
+time.sleep(2)
+board.exit()
+```
+
+### 2. ESP32 Control
+
+```python
+import time
+from roboreactor_firmata import ESP32Board
+
+# Connect to the board (ESP32 defaults to 115200 baud)
+board = ESP32Board('/dev/ttyUSB0', baudrate=115200)
+board.samplingOn(50)
+
+# --- 1. Dynamic I2C Config ---
+# Route Wire to GPIO 21 (SDA) and GPIO 22 (SCL)
+board.configure_custom_i2c(sda_pin=21, scl_pin=22)
+board.i2c_config()
+
+# --- 2. Dynamic CAN-bus Config ---
+def can_callback(msg_id, payload, is_extended):
+    print(f"CAN Rx - ID: {hex(msg_id)}, Payload: {payload}")
+
+# Route TWAI CAN to GPIO 4 (RX) and GPIO 5 (TX) at 500kbps
+board.configure_custom_can(rx_pin=4, tx_pin=5, baudrate=500000, callback=can_callback)
+
+# Transmit CAN frame
+board.can_write(msg_id=0x123, data_bytes=[0xAA, 0xBB, 0xCC], is_extended=0)
+
+time.sleep(2)
+board.exit()
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the `LICENSE` file for details.

roboreactor_firmata-0.1.0/README.md

@@ -0,0 +1,98 @@
+# roboreactor-firmata
+
+A unified, dynamic Firmata client library for configuring and controlling **GPIO**, **I2C**, **SPI**, **UART**, and **CAN-bus** peripherals on **STM32** and **ESP32** microcontrollers.
+
+Instead of being limited to hardcoded hardware pins, `roboreactor-firmata` allows you to dynamically assign peripheral pins at runtime from Python using a custom extended SysEx protocol.
+
+---
+
+## Installation
+
+```bash
+pip install roboreactor-firmata
+```
+
+---
+
+## Firmware Flashing
+
+Before running the Python client, flash the matching custom `.ino` sketch located inside the `firmware/` directory to your microcontroller:
+
+- **STM32**: Flash `StandardFirmataCustom_STM32.ino` (Requires `STM32duino` core and optional `STM32_CAN` library).
+- **ESP32**: Flash `StandardFirmataCustom_ESP32.ino` (Uses ESP32's native Arduino core and built-in `TWAI` CAN driver).
+
+---
+
+## Quick Start Examples
+
+### 1. STM32 Control (e.g., STM32F401RCT6)
+
+```python
+import time
+from roboreactor_firmata import STM32Board
+
+# Connect to the board
+board = STM32Board('/dev/ttyUSB0', mcu='STM32F401RCT6')
+board.samplingOn(50)  # Start polling thread
+
+# --- 1. Dynamic I2C Config ---
+board.configure_custom_i2c(sda_pin="PB9", scl_pin="PB8")
+board.i2c_config()
+
+def i2c_callback(data):
+    print(f"I2C Data: {data}")
+
+board.i2c_read(0x68, 0x75, 1, callback=i2c_callback)
+
+# --- 2. Dynamic UART Config ---
+def uart_callback(data):
+    print(f"UART Rx: {data}")
+
+board.configure_custom_uart(rx_pin="PA3", tx_pin="PA2", baudrate=9600, callback=uart_callback)
+board.uart_write(b"Hello STM32")
+
+# --- 3. Dynamic SPI Config ---
+def spi_callback(data):
+    print(f"SPI Rx: {data}")
+
+board.configure_custom_spi(mosi="PA7", miso="PA6", sclk="PA5", cs="PA4")
+board.spi_transfer("PA4", [0x9F, 0x00, 0x00, 0x00], callback=spi_callback)
+
+time.sleep(2)
+board.exit()
+```
+
+### 2. ESP32 Control
+
+```python
+import time
+from roboreactor_firmata import ESP32Board
+
+# Connect to the board (ESP32 defaults to 115200 baud)
+board = ESP32Board('/dev/ttyUSB0', baudrate=115200)
+board.samplingOn(50)
+
+# --- 1. Dynamic I2C Config ---
+# Route Wire to GPIO 21 (SDA) and GPIO 22 (SCL)
+board.configure_custom_i2c(sda_pin=21, scl_pin=22)
+board.i2c_config()
+
+# --- 2. Dynamic CAN-bus Config ---
+def can_callback(msg_id, payload, is_extended):
+    print(f"CAN Rx - ID: {hex(msg_id)}, Payload: {payload}")
+
+# Route TWAI CAN to GPIO 4 (RX) and GPIO 5 (TX) at 500kbps
+board.configure_custom_can(rx_pin=4, tx_pin=5, baudrate=500000, callback=can_callback)
+
+# Transmit CAN frame
+board.can_write(msg_id=0x123, data_bytes=[0xAA, 0xBB, 0xCC], is_extended=0)
+
+time.sleep(2)
+board.exit()
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the `LICENSE` file for details.

roboreactor_firmata-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "roboreactor-firmata"
+version = "0.1.0"
+authors = [
+    { name = "RoboReactor", email = "info@roboreactor.com" }
+]
+description = "A unified, dynamic Firmata control library supporting GPIO, I2C, SPI, UART, and CAN-bus on STM32 and ESP32 microcontrollers"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "pyfirmata2>=2.4.4",
+    "pyserial>=3.5"
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["roboreactor_firmata*"]

roboreactor_firmata-0.1.0/roboreactor_firmata/__init__.py

@@ -0,0 +1,4 @@
+from .stm32 import STM32Board
+from .esp32 import ESP32Board
+
+__all__ = ['STM32Board', 'ESP32Board']

roboreactor_firmata-0.1.0/roboreactor_firmata/board.py

@@ -0,0 +1,262 @@
+import time
+from pyfirmata2 import Board
+
+# Standard Firmata Commands
+I2C_REQUEST = 0x76
+I2C_REPLY = 0x77
+I2C_CONFIG = 0x78
+
+# Custom Dynamic Peripherals Commands
+CUSTOM_I2C_CONFIG   = 0x10
+CUSTOM_SPI_CONFIG   = 0x11
+CUSTOM_UART_CONFIG  = 0x12
+CUSTOM_SPI_TRANSFER = 0x13
+CUSTOM_CAN_CONFIG   = 0x14
+CUSTOM_CAN_WRITE    = 0x15
+CUSTOM_CAN_READ     = 0x16
+CUSTOM_UART_WRITE   = 0x17
+CUSTOM_ULTRASONIC_CONFIG = 0x18
+CUSTOM_ULTRASONIC_DATA   = 0x19
+CUSTOM_ULTRASONIC_STOP   = 0x1A
+
+
+class RoboReactorBoard(Board):
+    """
+    Base Board class for RoboReactor microcontrollers.
+    Inherits from pyfirmata2.Board and adds support for dynamic I2C, SPI, UART, and CAN-bus.
+    """
+    def __init__(self, port, layout, baudrate=57600, *args, **kwargs):
+        self.i2c_callbacks = {}
+        self.spi_callback = None
+        self.uart_callback = None
+        self.can_callback = None
+        self.ultrasonic_callbacks = {}
+        
+        # Initialize base Board
+        super().__init__(port, layout, baudrate, *args, **kwargs)
+        
+        # Register standard command handlers
+        self.add_cmd_handler(I2C_REPLY, self._handle_i2c_reply)
+        
+        # Register custom command handlers
+        self.add_cmd_handler(CUSTOM_SPI_TRANSFER, self._handle_spi_reply)
+        self.add_cmd_handler(CUSTOM_UART_CONFIG, self._handle_uart_incoming)
+        self.add_cmd_handler(CUSTOM_CAN_READ, self._handle_can_incoming)
+        self.add_cmd_handler(CUSTOM_ULTRASONIC_DATA, self._handle_ultrasonic_incoming)
+
+    def get_pin_index(self, pin_name):
+        """Must be implemented by subclasses to map physical names to pin indices."""
+        raise NotImplementedError("get_pin_index() must be implemented by subclasses.")
+
+    # --- Convenience Write/Read Methods ---
+    def digital_write(self, pin_name, value):
+        """Write HIGH (1) or LOW (0) to a digital pin by name."""
+        pin_idx = self.get_pin_index(pin_name)
+        self.digital[pin_idx].mode = 1  # OUTPUT
+        self.digital[pin_idx].write(value)
+
+    def digital_read(self, pin_name):
+        """Read state from a digital pin by name."""
+        pin_idx = self.get_pin_index(pin_name)
+        self.digital[pin_idx].mode = 0  # INPUT
+        return self.digital[pin_idx].read()
+
+    def pwm_write(self, pin_name, duty_cycle):
+        """Write PWM value (0.0 to 1.0) to a pin by name."""
+        pin_idx = self.get_pin_index(pin_name)
+        self.digital[pin_idx].mode = 3  # PWM
+        self.digital[pin_idx].write(duty_cycle)
+
+    def servo_write(self, pin_name, angle):
+        """Write servo angle (0 to 180 degrees) to a pin by name."""
+        pin_idx = self.get_pin_index(pin_name)
+        self.digital[pin_idx].mode = 4  # SERVO
+        self.digital[pin_idx].write(angle)
+
+    # --- Dynamic I2C Config (SDA / SCL redirection) ---
+    def configure_custom_i2c(self, sda_pin, scl_pin):
+        """Redirect and configure dynamic SDA and SCL pins for the Wire bus."""
+        sda_idx = self.get_pin_index(sda_pin)
+        scl_idx = self.get_pin_index(scl_pin)
+        self.send_sysex(CUSTOM_I2C_CONFIG, [sda_idx, scl_idx])
+
+    # --- Standard I2C Engine ---
+    def i2c_config(self, delay_us=0):
+        """Configure I2C bus delay (in microseconds)."""
+        data = self._encode_8bit_to_7bit([delay_us & 0xFF, (delay_us >> 8) & 0xFF])
+        self.send_sysex(I2C_CONFIG, data)
+
+    def i2c_write(self, address, register, data_bytes):
+        """Write data bytes to an I2C slave register."""
+        mode = 0  # Write Mode
+        payload = [register] + list(data_bytes)
+        data = [address & 0x7F, mode & 0x7F]
+        data.extend(self._encode_8bit_to_7bit(payload))
+        self.send_sysex(I2C_REQUEST, data)
+
+    def i2c_read(self, address, register, num_bytes, callback=None):
+        """Read data bytes from an I2C slave register."""
+        if callback:
+            self.i2c_callbacks[(address, register)] = callback
+        mode = 1  # Read Once Mode
+        payload = [register, num_bytes]
+        data = [address & 0x7F, mode & 0x7F]
+        data.extend(self._encode_8bit_to_7bit(payload))
+        self.send_sysex(I2C_REQUEST, data)
+
+    def _handle_i2c_reply(self, *data):
+        if len(data) < 4:
+            return
+        address = data[0]
+        register = data[1] | (data[2] << 7)
+        raw_payload = data[3:]
+        decoded_bytes = self._decode_7bit_pairs(raw_payload)
+        callback = self.i2c_callbacks.get((address, register))
+        if callback:
+            callback(decoded_bytes)
+
+    # --- Dynamic SPI Config & Transfer ---
+    def configure_custom_spi(self, mosi, miso, sclk, cs):
+        """Configure dynamic MOSI, MISO, SCLK, and CS pins for SPI."""
+        mosi_idx = self.get_pin_index(mosi)
+        miso_idx = self.get_pin_index(miso)
+        sclk_idx = self.get_pin_index(sclk)
+        cs_idx = self.get_pin_index(cs)
+        self.send_sysex(CUSTOM_SPI_CONFIG, [mosi_idx, miso_idx, sclk_idx, cs_idx])
+
+    def spi_transfer(self, cs_pin, data_bytes, callback=None):
+        """Perform full-duplex SPI read/write transfer and register callback for reply."""
+        if callback:
+            self.spi_callback = callback
+        cs_idx = self.get_pin_index(cs_pin)
+        payload = [cs_idx] + self._encode_8bit_to_7bit(data_bytes)
+        self.send_sysex(CUSTOM_SPI_TRANSFER, payload)
+
+    def _handle_spi_reply(self, *data):
+        decoded = self._decode_7bit_pairs(data)
+        if self.spi_callback:
+            self.spi_callback(decoded)
+
+    # --- Dynamic UART Config & Operations ---
+    def configure_custom_uart(self, rx_pin, tx_pin, baudrate, callback=None):
+        """Configure dynamic RX/TX pins for a UART serial port and register read callback."""
+        if callback:
+            self.uart_callback = callback
+        rx_idx = self.get_pin_index(rx_pin)
+        tx_idx = self.get_pin_index(tx_pin)
+        baud_bytes = [
+            baudrate & 0x7F,
+            (baudrate >> 7) & 0x7F,
+            (baudrate >> 14) & 0x7F
+        ]
+        self.send_sysex(CUSTOM_UART_CONFIG, [rx_idx, tx_idx] + baud_bytes)
+
+    def uart_write(self, data_bytes):
+        """Write raw bytes to the dynamic UART serial port."""
+        payload = self._encode_8bit_to_7bit(data_bytes)
+        self.send_sysex(CUSTOM_UART_WRITE, payload)
+
+    def _handle_uart_incoming(self, *data):
+        decoded = self._decode_7bit_pairs(data)
+        if self.uart_callback:
+            self.uart_callback(bytes(decoded))
+
+    # --- Dynamic CAN-bus Config & Operations ---
+    def configure_custom_can(self, rx_pin, tx_pin, baudrate, callback=None):
+        """Configure dynamic RX/TX pins for CAN-bus and register frame receive callback."""
+        if callback:
+            self.can_callback = callback
+        rx_idx = self.get_pin_index(rx_pin)
+        tx_idx = self.get_pin_index(tx_pin)
+        baud_bytes = [
+            baudrate & 0x7F,
+            (baudrate >> 7) & 0x7F,
+            (baudrate >> 14) & 0x7F,
+            (baudrate >> 21) & 0x7F
+        ]
+        self.send_sysex(CUSTOM_CAN_CONFIG, [rx_idx, tx_idx] + baud_bytes)
+
+    def can_write(self, msg_id, data_bytes, is_extended=0):
+        """Write a CAN frame to the CAN bus."""
+        id_bytes = [
+            msg_id & 0x7F,
+            (msg_id >> 7) & 0x7F,
+            (msg_id >> 14) & 0x7F,
+            (msg_id >> 21) & 0x7F,
+            (msg_id >> 28) & 0x7F
+        ]
+        length = len(data_bytes)
+        payload = id_bytes + [is_extended & 0x7F, length & 0x7F]
+        payload.extend(self._encode_8bit_to_7bit(data_bytes))
+        self.send_sysex(CUSTOM_CAN_WRITE, payload)
+
+    def _handle_can_incoming(self, *data):
+        if len(data) < 7:
+            return
+        msg_id = 0
+        for i in range(5):
+            msg_id |= (data[i] << (i * 7))
+        is_extended = data[5]
+        length = data[6]
+        raw_payload = data[7:]
+        decoded_payload = self._decode_7bit_pairs(raw_payload)
+        
+        if self.can_callback:
+            self.can_callback(msg_id, bytes(decoded_payload[:length]), bool(is_extended))
+
+    # --- Helper methods for encoding / decoding ---
+    def _encode_8bit_to_7bit(self, data):
+        """Encodes standard 8-bit bytes into 7-bit pairs for Firmata Sysex."""
+        encoded = []
+        for val in data:
+            encoded.append(val & 0x7F)
+            encoded.append((val >> 7) & 0x7F)
+        return encoded
+
+    def _decode_7bit_pairs(self, data):
+        """Decodes 7-bit pairs from Firmata Sysex back into 8-bit bytes."""
+        decoded = []
+        for i in range(0, len(data), 2):
+            if i + 1 < len(data):
+                val = data[i] | (data[i+1] << 7)
+                decoded.append(val)
+        return decoded
+
+    # --- Dynamic Ultrasonic Config & Readings ---
+    def configure_ultrasonic(self, trig_pin, echo_pin, interval_ms, callback=None):
+        """Configure dynamic Trigger and Echo pins for an ultrasonic sensor (HC-SR04) with background polling."""
+        trig_idx = self.get_pin_index(trig_pin)
+        echo_idx = self.get_pin_index(echo_pin)
+        if callback:
+            self.ultrasonic_callbacks[(trig_idx, echo_idx)] = callback
+        
+        interval_bytes = [
+            interval_ms & 0x7F,
+            (interval_ms >> 7) & 0x7F
+        ]
+        self.send_sysex(CUSTOM_ULTRASONIC_CONFIG, [trig_idx, echo_idx] + interval_bytes)
+
+    def stop_ultrasonic(self, trig_pin, echo_pin):
+        """Stop background polling for the specified ultrasonic sensor."""
+        trig_idx = self.get_pin_index(trig_pin)
+        echo_idx = self.get_pin_index(echo_pin)
+        if (trig_idx, echo_idx) in self.ultrasonic_callbacks:
+            del self.ultrasonic_callbacks[(trig_idx, echo_idx)]
+        self.send_sysex(CUSTOM_ULTRASONIC_STOP, [trig_idx, echo_idx])
+
+    def _handle_ultrasonic_incoming(self, *data):
+        if len(data) < 7:
+            return
+        trig_idx = data[0]
+        echo_idx = data[1]
+        
+        duration = 0
+        for i in range(5):
+            duration |= (data[2 + i] << (i * 7))
+            
+        # Speed of sound is 343 m/s -> roundtrip distance calculation in cm (duration / 58.3)
+        distance_cm = duration / 58.3 if duration > 0 else -1.0
+        
+        callback = self.ultrasonic_callbacks.get((trig_idx, echo_idx))
+        if callback:
+            callback(distance_cm)

roboreactor_firmata-0.1.0/roboreactor_firmata/esp32.py

@@ -0,0 +1,55 @@
+from .board import RoboReactorBoard
+
+class ESP32Board(RoboReactorBoard):
+    """
+    Board implementation specifically for ESP32 microcontrollers.
+    Pins are configured directly by their GPIO index (e.g., GPIO12 or 12).
+    """
+    def __init__(self, port, baudrate=115200, *args, **kwargs):
+        # ESP32 has up to 40 GPIO pins (0-39)
+        # Note: Baudrate defaults to 115200 for ESP32 standard uploads
+        num_digital_pins = 40
+        num_analog_pins = 16  # standard 16 analog channels max (ADC1/ADC2)
+        pwm_pins = tuple(range(num_digital_pins))
+        
+        layout = {
+            'digital': tuple(range(num_digital_pins)),
+            'analog': tuple(range(num_analog_pins)),
+            'pwm': pwm_pins,
+            'use_ports': True,
+            'disabled': (1, 3) # TX0 (1) / RX0 (3) are default disabled
+        }
+        
+        super().__init__(port, layout, baudrate, *args, **kwargs)
+
+    def get_pin_index(self, pin_name):
+        """Translate a pin name (e.g., 'GPIO12', 'IO12', or '12') to its numeric index."""
+        if isinstance(pin_name, int):
+            return pin_name
+        pin_name = str(pin_name).upper().strip()
+        if pin_name.startswith('GPIO'):
+            try:
+                return int(pin_name[4:])
+            except ValueError:
+                pass
+        elif pin_name.startswith('IO'):
+            try:
+                return int(pin_name[2:])
+            except ValueError:
+                pass
+        try:
+            return int(pin_name)
+        except ValueError:
+            raise ValueError(f"Invalid ESP32 pin name: {pin_name}. Use format like 'GPIO12', 'IO12', or integer 12.")
+
+    def get_gpio(self, pin_name, mode):
+        """
+        Configure and return a pin object using the physical pin name.
+        """
+        pin_idx = self.get_pin_index(pin_name)
+        
+        if mode == 'a':
+            # Analog channel mapping for ESP32
+            return self.get_pin(f'a:{pin_idx}:i')
+        else:
+            return self.get_pin(f'd:{pin_idx}:{mode}')

roboreactor_firmata-0.1.0/roboreactor_firmata/stm32.py

@@ -0,0 +1,89 @@
+from .board import RoboReactorBoard
+
+# Pin mappings for different STM32 microcontrollers in the STM32duino Core
+PIN_MAPS = {
+    # STM32F401RCT6 (64-pin package)
+    'STM32F401RCT6': {
+        **{f'PA{i}': i for i in range(16)},
+        **{f'PB{i}': i + 16 for i in range(16)},
+        **{f'PC{i}': i + 32 for i in range(16)},
+        'PD2': 48,
+        'PH0': 49,
+        'PH1': 50,
+    },
+    # STM32F401CCU6 (48-pin package / Blackpill)
+    'STM32F401CCU6': {
+        **{f'PA{i}': i for i in range(16)},
+        **{f'PB{i}': i + 16 for i in range(16)},
+        'PC13': 32,
+        'PC14': 33,
+        'PC15': 34,
+        'PH0': 35,
+        'PH1': 36,
+    },
+    # STM32F103C8T6 (48-pin package / Bluepill)
+    'STM32F103C8T6': {
+        **{f'PA{i}': i for i in range(16)},
+        **{f'PB{i}': i + 16 for i in range(16)},
+        'PC13': 32,
+        'PC14': 33,
+        'PC15': 34,
+        'PD0': 35,
+        'PD1': 36,
+    }
+}
+
+class STM32Board(RoboReactorBoard):
+    """
+    Board implementation specifically for STM32 microcontrollers.
+    """
+    def __init__(self, port, mcu='STM32F401RCT6', baudrate=57600, *args, **kwargs):
+        self.mcu = mcu.upper()
+        if self.mcu not in PIN_MAPS:
+            raise ValueError(f"Unknown MCU type: {mcu}. Available options: {list(PIN_MAPS.keys())}")
+        
+        self.pin_map = PIN_MAPS[self.mcu]
+        
+        # Dynamically build the layout based on the number of pins on this MCU
+        num_digital_pins = max(self.pin_map.values()) + 1
+        num_analog_pins = 16  # Standard 16 analog channels max
+        pwm_pins = tuple(self.pin_map.values())
+        
+        layout = {
+            'digital': tuple(range(num_digital_pins)),
+            'analog': tuple(range(num_analog_pins)),
+            'pwm': pwm_pins,
+            'use_ports': True,
+            'disabled': (0, 1) # Default disabled serial pins (e.g. RX/TX)
+        }
+        
+        super().__init__(port, layout, baudrate, *args, **kwargs)
+
+    def get_pin_index(self, pin_name):
+        """Translate a physical pin name (e.g., 'PA0') to its numeric index."""
+        pin_name = pin_name.upper().strip()
+        if pin_name not in self.pin_map:
+            raise ValueError(f"Pin {pin_name} is not available or exposed on {self.mcu}")
+        return self.pin_map[pin_name]
+
+    def get_gpio(self, pin_name, mode):
+        """
+        Configure and return a pin object using the physical pin name.
+        
+        Modes:
+            'i' - Input
+            'o' - Output
+            'a' - Analog Input
+            'p' - PWM Output
+            's' - Servo Output
+        """
+        pin_idx = self.get_pin_index(pin_name)
+        
+        if mode == 'a':
+            if pin_name.startswith('PA') and int(pin_name[2:]) < 8:
+                analog_channel = int(pin_name[2:])
+                return self.get_pin(f'a:{analog_channel}:i')
+            else:
+                raise ValueError(f"Pin {pin_name} does not support analog input mode on {self.mcu}")
+        else:
+            return self.get_pin(f'd:{pin_idx}:{mode}')

roboreactor_firmata-0.1.0/roboreactor_firmata.egg-info/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: roboreactor-firmata
+Version: 0.1.0
+Summary: A unified, dynamic Firmata control library supporting GPIO, I2C, SPI, UART, and CAN-bus on STM32 and ESP32 microcontrollers
+Author-email: RoboReactor <info@roboreactor.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyfirmata2>=2.4.4
+Requires-Dist: pyserial>=3.5
+Dynamic: license-file
+
+# roboreactor-firmata
+
+A unified, dynamic Firmata client library for configuring and controlling **GPIO**, **I2C**, **SPI**, **UART**, and **CAN-bus** peripherals on **STM32** and **ESP32** microcontrollers.
+
+Instead of being limited to hardcoded hardware pins, `roboreactor-firmata` allows you to dynamically assign peripheral pins at runtime from Python using a custom extended SysEx protocol.
+
+---
+
+## Installation
+
+```bash
+pip install roboreactor-firmata
+```
+
+---
+
+## Firmware Flashing
+
+Before running the Python client, flash the matching custom `.ino` sketch located inside the `firmware/` directory to your microcontroller:
+
+- **STM32**: Flash `StandardFirmataCustom_STM32.ino` (Requires `STM32duino` core and optional `STM32_CAN` library).
+- **ESP32**: Flash `StandardFirmataCustom_ESP32.ino` (Uses ESP32's native Arduino core and built-in `TWAI` CAN driver).
+
+---
+
+## Quick Start Examples
+
+### 1. STM32 Control (e.g., STM32F401RCT6)
+
+```python
+import time
+from roboreactor_firmata import STM32Board
+
+# Connect to the board
+board = STM32Board('/dev/ttyUSB0', mcu='STM32F401RCT6')
+board.samplingOn(50)  # Start polling thread
+
+# --- 1. Dynamic I2C Config ---
+board.configure_custom_i2c(sda_pin="PB9", scl_pin="PB8")
+board.i2c_config()
+
+def i2c_callback(data):
+    print(f"I2C Data: {data}")
+
+board.i2c_read(0x68, 0x75, 1, callback=i2c_callback)
+
+# --- 2. Dynamic UART Config ---
+def uart_callback(data):
+    print(f"UART Rx: {data}")
+
+board.configure_custom_uart(rx_pin="PA3", tx_pin="PA2", baudrate=9600, callback=uart_callback)
+board.uart_write(b"Hello STM32")
+
+# --- 3. Dynamic SPI Config ---
+def spi_callback(data):
+    print(f"SPI Rx: {data}")
+
+board.configure_custom_spi(mosi="PA7", miso="PA6", sclk="PA5", cs="PA4")
+board.spi_transfer("PA4", [0x9F, 0x00, 0x00, 0x00], callback=spi_callback)
+
+time.sleep(2)
+board.exit()
+```
+
+### 2. ESP32 Control
+
+```python
+import time
+from roboreactor_firmata import ESP32Board
+
+# Connect to the board (ESP32 defaults to 115200 baud)
+board = ESP32Board('/dev/ttyUSB0', baudrate=115200)
+board.samplingOn(50)
+
+# --- 1. Dynamic I2C Config ---
+# Route Wire to GPIO 21 (SDA) and GPIO 22 (SCL)
+board.configure_custom_i2c(sda_pin=21, scl_pin=22)
+board.i2c_config()
+
+# --- 2. Dynamic CAN-bus Config ---
+def can_callback(msg_id, payload, is_extended):
+    print(f"CAN Rx - ID: {hex(msg_id)}, Payload: {payload}")
+
+# Route TWAI CAN to GPIO 4 (RX) and GPIO 5 (TX) at 500kbps
+board.configure_custom_can(rx_pin=4, tx_pin=5, baudrate=500000, callback=can_callback)
+
+# Transmit CAN frame
+board.can_write(msg_id=0x123, data_bytes=[0xAA, 0xBB, 0xCC], is_extended=0)
+
+time.sleep(2)
+board.exit()
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the `LICENSE` file for details.

roboreactor_firmata-0.1.0/roboreactor_firmata.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+roboreactor_firmata/__init__.py
+roboreactor_firmata/board.py
+roboreactor_firmata/esp32.py
+roboreactor_firmata/stm32.py
+roboreactor_firmata.egg-info/PKG-INFO
+roboreactor_firmata.egg-info/SOURCES.txt
+roboreactor_firmata.egg-info/dependency_links.txt
+roboreactor_firmata.egg-info/requires.txt
+roboreactor_firmata.egg-info/top_level.txt

roboreactor_firmata-0.1.0/roboreactor_firmata.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

roboreactor_firmata-0.1.0/roboreactor_firmata.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pyfirmata2>=2.4.4
+pyserial>=3.5

roboreactor_firmata-0.1.0/roboreactor_firmata.egg-info/top_level.txt

@@ -0,0 +1 @@
+roboreactor_firmata

roboreactor_firmata-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+