pymcu-micropython 0.1.0a1__py3-none-any.whl

pymcu_micropython/__init__.py

@@ -0,0 +1,2 @@
+# pymcu_micropython -- MicroPython stdlib flavor for PyMCU
+# This package provides MicroPython-compatible modules that compile to bare-metal firmware.

pymcu_micropython/avr.py

@@ -0,0 +1,121 @@
+# MicroPython-compatible avr module for PyMCU
+#
+# AVR-specific peripherals:
+#   EEPROM  -- non-volatile byte storage (shim over pymcu.hal.eeprom)
+#   SoftSPI -- bit-bang SPI (shim over pymcu.hal.softspi)
+#   SoftI2C -- bit-bang I2C (shim over pymcu.hal.softi2c)
+#
+# All classes follow ZCA (zero-cost abstraction) rules:
+#   - All methods are @inline
+#   - No SRAM instance structs emitted beyond the wrapped HAL object
+#
+# Usage:
+#   from avr import EEPROM, SoftSPI, SoftI2C
+#   from machine import Pin
+#
+#   ee = EEPROM()
+#   ee.write(0, 42)
+#   val = ee.read(0)
+#
+#   scl = Pin(5, Pin.OUT)
+#   sda = Pin(4, Pin.OUT)
+#   i2c = SoftI2C(scl, sda)
+#
+#   sck  = Pin(13, Pin.OUT)
+#   mosi = Pin(11, Pin.OUT)
+#   miso = Pin(12, Pin.IN)
+#   spi  = SoftSPI(sck, mosi, miso, baudrate=500)
+
+from pymcu.types import uint8, uint16, uint32, inline
+from pymcu.hal.eeprom import EEPROM as _EEPROM
+from pymcu.hal.softspi import SoftSPI as _SoftSPI
+from pymcu.hal.softi2c import SoftI2C as _SoftI2C
+
+
+# ---------------------------------------------------------------------------
+# EEPROM
+# ---------------------------------------------------------------------------
+
+class EEPROM:
+    @inline
+    def __init__(self):
+        self._ee = _EEPROM()
+
+    @inline
+    def read(self, addr: uint16) -> uint8:
+        return self._ee.read(addr)
+
+    @inline
+    def write(self, addr: uint16, value: uint8):
+        self._ee.write(addr, value)
+
+
+# ---------------------------------------------------------------------------
+# SoftSPI
+# ---------------------------------------------------------------------------
+
+class SoftSPI:
+    CONTROLLER = 0
+    PERIPHERAL = 1
+
+    @inline
+    def __init__(self, sck, mosi, miso, baudrate: uint16 = 500, mode: uint8 = 0):
+        # sck, mosi, miso: machine.Pin instances.
+        # baudrate: target SCK frequency in kHz (controller mode only).
+        # mode: SoftSPI.CONTROLLER (0) or SoftSPI.PERIPHERAL (1).
+        self._spi = _SoftSPI(sck._pin, mosi._pin, miso._pin, mode, None, baudrate)
+
+    @inline
+    def transfer(self, data: uint8) -> uint8:
+        return self._spi.transfer(data)
+
+    @inline
+    def write(self, data: uint8):
+        self._spi.write(data)
+
+    @inline
+    def select(self):
+        self._spi.select()
+
+    @inline
+    def deselect(self):
+        self._spi.deselect()
+
+
+# ---------------------------------------------------------------------------
+# SoftI2C
+# ---------------------------------------------------------------------------
+
+class SoftI2C:
+    @inline
+    def __init__(self, scl, sda, freq: uint32 = 100000):
+        # scl, sda: machine.Pin instances (must have external pull-ups).
+        # freq: bus frequency in Hz; converted to half-period microseconds
+        #   as half_us = 500_000 // freq (compile-time fold when freq is literal).
+        #   100 kHz -> half_us=5, 400 kHz -> half_us=1.
+        half_us: uint8 = 500000 // freq
+        self._i2c = _SoftI2C(scl._pin, sda._pin, half_us)
+        self._i2c.init()
+
+    @inline
+    def scan(self) -> uint8:
+        # Returns count of responding devices (not a list -- no heap on MCU).
+        count: uint8 = 0
+        addr: uint8 = 1
+        while addr < 128:
+            if self._i2c.ping(addr):
+                count = count + 1
+            addr = addr + 1
+        return count
+
+    @inline
+    def writeto(self, addr: uint8, data: uint8) -> uint8:
+        return self._i2c.write_to(addr, data)
+
+    @inline
+    def readfrom(self, addr: uint8) -> uint8:
+        return self._i2c.read_from(addr)
+
+    @inline
+    def ping(self, addr: uint8) -> uint8:
+        return self._i2c.ping(addr)

pymcu_micropython/board_chips.py

@@ -0,0 +1,33 @@
+# Board -> chip mapping for boards known to the MicroPython flavor.
+# The PyMCU build driver merges this into its own BOARD_CHIPS dict at build time.
+# Extension entries take precedence over the built-in driver mapping.
+
+BOARD_CHIPS: dict = {
+    # Common MicroPython boards
+    "pyboard":          "stm32f405",
+    "pyboard_v11":      "stm32f405",
+    "rp2040":           "rp2040",
+    "esp32_generic":    "esp32",
+    "esp8266_generic":  "esp8266",
+    # Arduino / AVR
+    "arduino_uno":      "atmega328p",
+    "arduino_nano":     "atmega328p",
+    "arduino_mega":     "atmega2560",
+    "arduino_micro":    "atmega32u4",
+    # ATtiny named dev boards
+    "digispark":        "attiny85",
+    "adafruit_trinket": "attiny85",
+    # ATtiny bare chips -- 8-pin
+    "attiny85":  "attiny85",
+    "attiny45":  "attiny45",
+    "attiny25":  "attiny25",
+    "attiny13":  "attiny13",
+    "attiny13a": "attiny13a",
+    # ATtiny bare chips -- 14-pin
+    "attiny84": "attiny84",
+    "attiny44": "attiny44",
+    "attiny24": "attiny24",
+    # ATtiny bare chips -- 20-pin
+    "attiny2313": "attiny2313",
+    "attiny4313": "attiny4313",
+}

pymcu_micropython/boards/__init__.py

@@ -0,0 +1,2 @@
+# Board pin definitions for the MicroPython flavor.
+# Each board file maps integer Arduino pin numbers to PyMCU port strings.

pymcu_micropython/boards/arduino_mega.py

@@ -0,0 +1,51 @@
+# MicroPython-style board constants for Arduino Mega 2560 (ATmega2560 @ 16 MHz)
+#
+# The Mega has 54 digital + 16 analog pins. Since machine._arduino_pin_name
+# only covers the Uno's D0-D13 mapping, pin constants here use port strings
+# directly. Pass them to Pin() or HAL functions as-is.
+
+# Digital pins D0-D13
+D0  = "PE0"; D1  = "PE1"; D2  = "PE4"; D3  = "PE5"
+D4  = "PG5"; D5  = "PE3"; D6  = "PH3"; D7  = "PH4"
+D8  = "PH5"; D9  = "PH6"; D10 = "PB4"; D11 = "PB5"
+D12 = "PB6"; D13 = "PB7"
+
+# Digital pins D14-D21 (serial / I2C)
+D14 = "PJ1"; D15 = "PJ0"; D16 = "PH1"; D17 = "PH0"
+D18 = "PD3"; D19 = "PD2"; D20 = "PD1"; D21 = "PD0"
+
+# Digital pins D22-D29 (Port A)
+D22 = "PA0"; D23 = "PA1"; D24 = "PA2"; D25 = "PA3"
+D26 = "PA4"; D27 = "PA5"; D28 = "PA6"; D29 = "PA7"
+
+# Digital pins D30-D37 (Port C, reversed)
+D30 = "PC7"; D31 = "PC6"; D32 = "PC5"; D33 = "PC4"
+D34 = "PC3"; D35 = "PC2"; D36 = "PC1"; D37 = "PC0"
+
+# Digital pins D38-D41
+D38 = "PD7"; D39 = "PG2"; D40 = "PG1"; D41 = "PG0"
+
+# Digital pins D42-D49 (Port L, reversed)
+D42 = "PL7"; D43 = "PL6"; D44 = "PL5"; D45 = "PL4"
+D46 = "PL3"; D47 = "PL2"; D48 = "PL1"; D49 = "PL0"
+
+# Digital pins D50-D53 (SPI)
+D50 = "PB3"; D51 = "PB2"; D52 = "PB1"; D53 = "PB0"
+
+# Analog pins A0-A7 (Port F)
+A0  = "PF0"; A1  = "PF1"; A2  = "PF2"; A3  = "PF3"
+A4  = "PF4"; A5  = "PF5"; A6  = "PF6"; A7  = "PF7"
+
+# Analog pins A8-A15 (Port K)
+A8  = "PK0"; A9  = "PK1"; A10 = "PK2"; A11 = "PK3"
+A12 = "PK4"; A13 = "PK5"; A14 = "PK6"; A15 = "PK7"
+
+# Named aliases
+LED         = "PB7"
+LED_BUILTIN = "PB7"
+TX   = "PE1"; RX   = "PE0"
+TX1  = "PD3"; RX1  = "PD2"
+TX2  = "PH1"; RX2  = "PH0"
+TX3  = "PJ1"; RX3  = "PJ0"
+SCL  = "PD0"; SDA  = "PD1"
+SCK  = "PB1"; MOSI = "PB2"; MISO = "PB3"; SS = "PB0"

pymcu_micropython/boards/arduino_micro.py

@@ -0,0 +1,17 @@
+# MicroPython-style board constants for Arduino Micro (ATmega32U4 @ 16 MHz)
+#
+# Port strings are used directly since machine._arduino_pin_name covers Uno only.
+
+D0  = "PD2"; D1  = "PD3"; D2  = "PD1"; D3  = "PD0"
+D4  = "PD4"; D5  = "PC6"; D6  = "PD7"; D7  = "PE6"
+D8  = "PB4"; D9  = "PB5"; D10 = "PB6"; D11 = "PB7"
+D12 = "PD6"; D13 = "PC7"
+
+A0 = "PF7"; A1 = "PF6"; A2 = "PF5"; A3 = "PF4"
+A4 = "PF1"; A5 = "PF0"
+
+LED         = "PC7"
+LED_BUILTIN = "PC7"
+TX   = "PD3"; RX  = "PD2"
+SCL  = "PD0"; SDA = "PD1"
+SCK  = "PB1"; MOSI = "PB2"; MISO = "PB3"; SS = "PB0"

pymcu_micropython/boards/arduino_nano.py

@@ -0,0 +1,36 @@
+# MicroPython-style board constants for Arduino Nano (ATmega328P @ 16 MHz)
+#
+# Identical pinout to Arduino Uno. Integer pin numbers match silk-screen.
+# MicroPython uses integer pin numbers resolved to port strings by the compiler.
+
+# Digital pins (same numbering as Arduino silk-screen)
+D0  = 0     # PD0 / RX
+D1  = 1     # PD1 / TX
+D2  = 2     # PD2 / INT0
+D3  = 3     # PD3 / INT1 / OC2B
+D4  = 4     # PD4
+D5  = 5     # PD5 / OC0B
+D6  = 6     # PD6 / OC0A
+D7  = 7     # PD7
+D8  = 8     # PB0
+D9  = 9     # PB1 / OC1A
+D10 = 10    # PB2 / SS / OC1B
+D11 = 11    # PB3 / MOSI / OC2A
+D12 = 12    # PB4 / MISO
+D13 = 13    # PB5 / SCK / LED
+
+# Analog pins (port-string form; no standard integer offset on Nano)
+A0 = "PC0"
+A1 = "PC1"
+A2 = "PC2"
+A3 = "PC3"
+A4 = "PC4"   # SDA
+A5 = "PC5"   # SCL
+A6 = "ADC6"  # ADC-only (no GPIO; not connected to a port pin)
+A7 = "ADC7"  # ADC-only (no GPIO; not connected to a port pin)
+
+# Named aliases
+LED         = 13
+LED_BUILTIN = 13
+TX   = 1
+RX   = 0

pymcu_micropython/boards/arduino_uno.py

@@ -0,0 +1,39 @@
+# MicroPython-style board constants for Arduino Uno (ATmega328P @ 16 MHz)
+#
+# MicroPython uses integer pin numbers matching the Arduino silk-screen numbering.
+# These are compile-time constants resolved to port strings by the compiler.
+#
+# Usage:
+#   from machine import Pin
+#   led = Pin(13, Pin.OUT)    # D13 = PB5 (built-in LED)
+#
+# Note: explicit string literals are required here because the pymcu compiler
+# only registers module-level globals for explicit assignments.
+
+# Digital pins (same numbering as Arduino silk-screen)
+D0  = 0     # PD0 / RX
+D1  = 1     # PD1 / TX
+D2  = 2     # PD2 / INT0
+D3  = 3     # PD3 / INT1 / OC2B
+D4  = 4     # PD4
+D5  = 5     # PD5 / OC0B
+D6  = 6     # PD6 / OC0A
+D7  = 7     # PD7
+D8  = 8     # PB0
+D9  = 9     # PB1 / OC1A
+D10 = 10    # PB2 / SS / OC1B
+D11 = 11    # PB3 / MOSI / OC2A
+D12 = 12    # PB4 / MISO
+D13 = 13    # PB5 / SCK / LED
+
+# Analog pins (also usable as digital GPIO via integer 14-19)
+A0 = "PC0"
+A1 = "PC1"
+A2 = "PC2"
+A3 = "PC3"
+A4 = "PC4"   # SDA
+A5 = "PC5"   # SCL
+
+# Named aliases
+LED      = 13    # Built-in LED (PB5 / D13)
+LED_BUILTIN = 13

pymcu_micropython/boards/attiny13.py

@@ -0,0 +1,11 @@
+# MicroPython-style board constants for ATtiny13 bare chip (8-pin DIP)
+# Also covers ATtiny13A (improved oscillator) -- same pinout.
+# Very minimal: 1KB flash, 64B SRAM. No UART, no USI.
+
+PB0 = "PB0"; PB1 = "PB1"; PB2 = "PB2"
+PB3 = "PB3"; PB4 = "PB4"
+PB5 = "PB5"   # RESET by default -- GPIO requires RSTDISBL fuse!
+
+A0 = "PB5"; A1 = "PB2"; A2 = "PB4"; A3 = "PB3"
+
+INT0 = "PB1"

pymcu_micropython/boards/attiny13a.py

@@ -0,0 +1,10 @@
+# MicroPython-style board constants for ATtiny13A bare chip (8-pin DIP)
+# Same pinout as ATtiny13. See attiny13.py for details.
+
+PB0 = "PB0"; PB1 = "PB1"; PB2 = "PB2"
+PB3 = "PB3"; PB4 = "PB4"
+PB5 = "PB5"   # RESET by default -- GPIO requires RSTDISBL fuse!
+
+A0 = "PB5"; A1 = "PB2"; A2 = "PB4"; A3 = "PB3"
+
+INT0 = "PB1"

pymcu_micropython/boards/attiny2313.py

@@ -0,0 +1,12 @@
+# MicroPython-style board constants for ATtiny2313 bare chip (20-pin DIP)
+# Also covers ATtiny4313 (4KB flash, 256B SRAM) -- same pinout.
+
+D0 = "PD0"; D1 = "PD1"; D2 = "PD2"; D3 = "PD3"
+D4 = "PD4"; D5 = "PD5"; D6 = "PD6"
+D7 = "PB0"; D8 = "PB1"; D9 = "PB2"; D10 = "PB3"
+D11 = "PB4"; D12 = "PB5"; D13 = "PB6"; D14 = "PB7"
+
+TX  = "PD1"; RX  = "PD0"
+SCK = "PB2"; MOSI = "PB0"; MISO = "PB1"
+SCL = "PB2"; SDA  = "PB0"
+INT0 = "PD2"; INT1 = "PD3"

pymcu_micropython/boards/attiny24.py

@@ -0,0 +1,12 @@
+# MicroPython-style board constants for ATtiny24 bare chip (14-pin DIP)
+# Same pinout as ATtiny84. See attiny84.py for details.
+
+D0 = "PA0"; D1 = "PA1"; D2 = "PA2"; D3 = "PA3"
+D4 = "PA4"; D5 = "PA5"; D6 = "PA6"; D7 = "PA7"
+D8 = "PB0"; D9 = "PB1"; D10 = "PB2"
+
+A0 = "PA0"; A1 = "PA1"; A2 = "PA2"; A3 = "PA3"
+A4 = "PA4"; A5 = "PA5"; A6 = "PA6"; A7 = "PA7"
+
+SCK  = "PB2"; MOSI = "PB0"; MISO = "PB1"
+SCL  = "PB2"; SDA  = "PB0"; INT0 = "PB2"

pymcu_micropython/boards/attiny25.py

@@ -0,0 +1,11 @@
+# MicroPython-style board constants for ATtiny25 bare chip (8-pin DIP)
+# Same pinout as ATtiny85. See attiny85.py for details.
+
+PB0 = "PB0"; PB1 = "PB1"; PB2 = "PB2"
+PB3 = "PB3"; PB4 = "PB4"
+PB5 = "PB5"   # RESET by default -- GPIO requires RSTDISBL fuse!
+
+A0 = "PB5"; A1 = "PB2"; A2 = "PB4"; A3 = "PB3"
+
+SCK  = "PB2"; MOSI = "PB0"; MISO = "PB1"
+SCL  = "PB2"; SDA  = "PB0"; INT0 = "PB2"

pymcu_micropython/boards/attiny4313.py

@@ -0,0 +1,12 @@
+# MicroPython-style board constants for ATtiny4313 bare chip (20-pin DIP)
+# Same pinout as ATtiny2313. See attiny2313.py for details.
+
+D0 = "PD0"; D1 = "PD1"; D2 = "PD2"; D3 = "PD3"
+D4 = "PD4"; D5 = "PD5"; D6 = "PD6"
+D7 = "PB0"; D8 = "PB1"; D9 = "PB2"; D10 = "PB3"
+D11 = "PB4"; D12 = "PB5"; D13 = "PB6"; D14 = "PB7"
+
+TX  = "PD1"; RX  = "PD0"
+SCK = "PB2"; MOSI = "PB0"; MISO = "PB1"
+SCL = "PB2"; SDA  = "PB0"
+INT0 = "PD2"; INT1 = "PD3"

pymcu_micropython/boards/attiny44.py

@@ -0,0 +1,12 @@
+# MicroPython-style board constants for ATtiny44 bare chip (14-pin DIP)
+# Same pinout as ATtiny84. See attiny84.py for details.
+
+D0 = "PA0"; D1 = "PA1"; D2 = "PA2"; D3 = "PA3"
+D4 = "PA4"; D5 = "PA5"; D6 = "PA6"; D7 = "PA7"
+D8 = "PB0"; D9 = "PB1"; D10 = "PB2"
+
+A0 = "PA0"; A1 = "PA1"; A2 = "PA2"; A3 = "PA3"
+A4 = "PA4"; A5 = "PA5"; A6 = "PA6"; A7 = "PA7"
+
+SCK  = "PB2"; MOSI = "PB0"; MISO = "PB1"
+SCL  = "PB2"; SDA  = "PB0"; INT0 = "PB2"

pymcu_micropython/boards/attiny45.py

@@ -0,0 +1,11 @@
+# MicroPython-style board constants for ATtiny45 bare chip (8-pin DIP)
+# Same pinout as ATtiny85. See attiny85.py for details.
+
+PB0 = "PB0"; PB1 = "PB1"; PB2 = "PB2"
+PB3 = "PB3"; PB4 = "PB4"
+PB5 = "PB5"   # RESET by default -- GPIO requires RSTDISBL fuse!
+
+A0 = "PB5"; A1 = "PB2"; A2 = "PB4"; A3 = "PB3"
+
+SCK  = "PB2"; MOSI = "PB0"; MISO = "PB1"
+SCL  = "PB2"; SDA  = "PB0"; INT0 = "PB2"

pymcu_micropython/boards/attiny84.py

@@ -0,0 +1,12 @@
+# MicroPython-style board constants for ATtiny84 bare chip (14-pin DIP)
+# Also covers ATtiny44 (4KB flash) and ATtiny24 (2KB flash) -- same pinout.
+
+D0 = "PA0"; D1 = "PA1"; D2 = "PA2"; D3 = "PA3"
+D4 = "PA4"; D5 = "PA5"; D6 = "PA6"; D7 = "PA7"
+D8 = "PB0"; D9 = "PB1"; D10 = "PB2"
+
+A0 = "PA0"; A1 = "PA1"; A2 = "PA2"; A3 = "PA3"
+A4 = "PA4"; A5 = "PA5"; A6 = "PA6"; A7 = "PA7"
+
+SCK  = "PB2"; MOSI = "PB0"; MISO = "PB1"
+SCL  = "PB2"; SDA  = "PB0"; INT0 = "PB2"

pymcu_micropython/boards/attiny85.py

@@ -0,0 +1,11 @@
+# MicroPython-style board constants for ATtiny85 bare chip (8-pin DIP)
+# Also covers ATtiny45 (4KB flash) and ATtiny25 (2KB flash) -- same pinout.
+
+PB0 = "PB0"; PB1 = "PB1"; PB2 = "PB2"
+PB3 = "PB3"; PB4 = "PB4"
+PB5 = "PB5"   # RESET by default -- GPIO requires RSTDISBL fuse!
+
+A0 = "PB5"; A1 = "PB2"; A2 = "PB4"; A3 = "PB3"
+
+SCK  = "PB2"; MOSI = "PB0"; MISO = "PB1"
+SCL  = "PB2"; SDA  = "PB0"; INT0 = "PB2"

pymcu_micropython/boards/digispark.py

@@ -0,0 +1,13 @@
+# MicroPython-style board constants for Digispark (ATtiny85 @ 16.5 MHz USB)
+# Port strings used directly (no integer mapping for ATtiny in machine.py).
+
+P0 = "PB0"; P1 = "PB1"; P2 = "PB2"
+P3 = "PB3"; P4 = "PB4"
+P5 = "PB5"   # RESET by default -- GPIO requires RSTDISBL fuse!
+
+A0 = "PB5"; A1 = "PB2"; A2 = "PB4"; A3 = "PB3"
+
+LED         = "PB1"
+LED_BUILTIN = "PB1"
+SCK  = "PB2"; MOSI = "PB0"; MISO = "PB1"
+SCL  = "PB2"; SDA  = "PB0"

pymcu_micropython/lm35.py

@@ -0,0 +1,40 @@
+# LM35 precision temperature sensor driver (MicroPython style)
+#
+# API:
+#   sensor = LM35(ADC(Pin(14)))   # A0 = Pin(14) on Arduino Uno
+#   sensor.read()                 -- raw ADC count (0-1023)
+#   sensor.temperature()          -- degrees Celsius as float (e.g. 24.8)
+#
+# Conversion formula (5 V reference, 10-bit ADC):
+#   V_out  = ADC_raw * 5000.0 / 1024  (mV)
+#   Temp_C = V_out / 10.0             (LM35 outputs 10 mV/C)
+#   => Temp_C = ADC_raw * 0.4882813
+#
+# Wiring (Arduino Uno / ATmega328P, 5 V supply):
+#   LM35 VS   -> +5 V
+#   LM35 GND  -> GND
+#   LM35 VOUT -> A0 (or any analog input)
+#
+# Note: The LM35 does not require calibration.  For accurate results use
+# the 5 V rail as the ADC reference (default on Arduino Uno).  With a 3.3 V
+# supply replace the constant 500 with 330 and 5000 with 3300.
+
+from pymcu.types import uint16, inline
+from machine import ADC as _ADC
+
+
+class LM35:
+    @inline
+    def __init__(self, adc: _ADC):
+        # adc: machine.ADC instance (e.g. ADC(Pin(14)) for A0).
+        self._adc = adc
+
+    @inline
+    def read(self) -> uint16:
+        # Raw ADC count, 0-1023
+        return self._adc.read()
+
+    @inline
+    def temperature(self):
+        raw: uint16 = self._adc.read()
+        return raw * 0.4882813