pymcu-micropython 0.1.0a1__tar.gz

pymcu_micropython-0.1.0a1/.github/workflows/publish.yml

@@ -0,0 +1,78 @@
+name: Publish
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  # Pure-Python wheel + sdist (hatchling). No native build matrix needed.
+  build:
+    name: Build wheel + sdist
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Build wheel + sdist
+        run: uv build
+
+      - name: Upload dist artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/*
+          retention-days: 15
+
+  # Trusted Publishing (OIDC) to PyPI on every v* tag — stable and pre-release
+  # alike, so the 0.1.0a1 alpha lands on real PyPI alongside the core packages.
+  publish-pypi:
+    name: Publish to PyPI
+    needs: build
+    if: github.ref_type == 'tag'
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Publish to PyPI
+        run: uv publish dist/*
+
+  # Manual smoke-test channel: dispatch without a tag publishes to TestPyPI.
+  publish-testpypi:
+    name: Publish to TestPyPI
+    needs: build
+    if: github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    environment: prerelease
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Publish to TestPyPI
+        run: uv publish --publish-url https://test.pypi.org/legacy/ dist/*

pymcu_micropython-0.1.0a1/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.venv/
+.DS_Store

pymcu_micropython-0.1.0a1/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: pymcu-micropython
+Version: 0.1.0a1
+Summary: MicroPython stdlib flavor for PyMCU
+Requires-Python: >=3.11
+Requires-Dist: pymcu-stdlib>=0.1.0a1

pymcu_micropython-0.1.0a1/README.md

@@ -0,0 +1,76 @@
+# pymcu-micropython
+
+MicroPython standard-library flavor for **PyMCU** — an AOT (ahead-of-time) Python compiler that targets microcontrollers.
+
+## What is this?
+
+`pymcu-micropython` is a drop-in compatibility layer that lets you write firmware using the familiar [MicroPython](https://micropython.org/) API (`machine`, `utime`, `micropython` modules) while compiling it to bare-metal machine code with PyMCU.  All classes and functions are implemented as zero-cost abstractions (ZCA): they are marked `@inline` so that no SRAM instance structs, no stack frames, and no interpreter overhead are introduced — the compiler resolves everything at compile time.
+
+## Modules
+
+| Module | MicroPython equivalent | Description |
+|--------|------------------------|-------------|
+| `machine` | `machine` | `Pin`, `UART`, `ADC`, `PWM`, `SPI`, `I2C`, `Timer`, `WDT`, `Signal` |
+| `utime` | `utime` / `time` | `sleep_ms()`, `sleep_us()`, `sleep()`, `ticks_ms()`, `ticks_us()`, `ticks_diff()`, `ticks_add()` |
+| `micropython` | `micropython` | `const()`, `@native`, `@viper` stubs |
+
+## Installation
+
+```sh
+pip install pymcu-micropython
+```
+
+Or add it as a dependency in your project's `pyproject.toml`:
+
+```toml
+[project]
+dependencies = [
+    "pymcu>=0.1.0a1",
+    "pymcu-stdlib>=0.1.0a1",
+    "pymcu-micropython>=0.1.0a1",
+]
+```
+
+## Quick start
+
+The API is intentionally identical to MicroPython, so existing MicroPython sketches work without modification:
+
+```python
+from machine import Pin
+from utime import sleep_ms
+
+def main():
+    led = Pin(13, Pin.OUT)   # Arduino Uno built-in LED (D13 = PB5)
+    while True:
+        led.value(1)
+        sleep_ms(500)
+        led.value(0)
+        sleep_ms(500)
+```
+
+Compile and flash with PyMCU:
+
+```sh
+pymcu build
+pymcu flash
+```
+
+## Examples
+
+| Example | Description |
+|---------|-------------|
+| [`examples/blink`](examples/blink) | Blink the built-in LED at 1 Hz |
+| [`examples/adc-read`](examples/adc-read) | Read a potentiometer and print values over UART |
+| [`examples/uart-echo`](examples/uart-echo) | Echo received bytes back over UART |
+
+## Supported boards
+
+The library currently ships pin-mapping support for:
+
+- **Arduino Uno** (ATmega328P)
+
+Additional boards can be added by contributing a file under `src/pymcu_micropython/boards/`.
+
+## License
+
+See [LICENSE](LICENSE) for details.

pymcu_micropython-0.1.0a1/examples/adc-read/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "adc-read"
+version = "0.1.0a1"
+requires-python = ">=3.11"
+dependencies = [
+    "pymcu-stdlib>=0.1.0a1",
+    "pymcu-compiler[avr]>=0.1.0a1",
+    "pymcu-micropython>=0.1.0a1",
+]
+
+[tool.pymcu]
+board     = "arduino_uno"
+frequency = 16000000
+sources   = "src"
+entry     = "main.py"
+stdlib    = ["micropython"]
+
+[tool.pymcu.flash]
+programmer = "avrdude"

pymcu_micropython-0.1.0a1/examples/adc-read/src/main.py

@@ -0,0 +1,32 @@
+# ADC Read -- MicroPython style on Arduino Uno
+#
+# Demonstrates:
+#   machine.ADC  -- read_u16() returns 0-65535 scaled from 10-bit ADC
+#   machine.UART -- print values over serial
+#   utime        -- sleep_ms() between readings
+#
+# Wiring:
+#   A0: potentiometer center tap (or any analog voltage 0-5V)
+#
+# Expected behaviour:
+#   Prints ADC value every 200 ms over UART at 9600 baud
+
+from machine import UART, ADC, Pin
+from utime import sleep_ms
+from pymcu.types import uint16
+
+
+def main():
+    uart = UART(0, 9600)
+    adc  = ADC(Pin(14))   # Pin(14) = A0 = PC0
+
+    uart.println("ADC ready")
+
+    while True:
+        val: uint16 = adc.read()    # 0-1023
+        uart.write_str("ADC=")
+        # Print high byte as proxy for value (0-255 range)
+        from pymcu.types import uint8
+        hi: uint8 = val >> 2        # scale 0-1023 to 0-255
+        uart.print_byte(hi)
+        sleep_ms(200)

pymcu_micropython-0.1.0a1/examples/blink/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "blink"
+version = "0.1.0a1"
+requires-python = ">=3.11"
+dependencies = [
+    "pymcu-stdlib>=0.1.0a1",
+    "pymcu-compiler[avr]>=0.1.0a1",
+    "pymcu-micropython>=0.1.0a1",
+]
+
+[tool.pymcu]
+board     = "arduino_uno"
+frequency = 16000000
+sources   = "src"
+entry     = "main.py"
+stdlib    = ["micropython"]
+
+[tool.pymcu.flash]
+programmer = "avrdude"

pymcu_micropython-0.1.0a1/examples/blink/src/main.py

@@ -0,0 +1,21 @@
+# Blink -- MicroPython style on Arduino Uno
+#
+# Demonstrates:
+#   machine.Pin  -- integer pin numbers (D13 = PB5 built-in LED)
+#   utime        -- sleep_ms() with no hardware timer dependency
+#
+# Wiring:
+#   No external wiring -- uses built-in LED on D13
+#
+# Expected behaviour:
+#   LED toggles at 1 Hz (500 ms per half-period) indefinitely
+
+from machine import Pin
+from utime import sleep_ms
+
+
+def main():
+    led = Pin(13, Pin.OUT)
+    while True:
+        led.toggle()
+        sleep_ms(500)

pymcu_micropython-0.1.0a1/examples/dht-sensor/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "dht-sensor"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+    "pymcu-stdlib>=0.1.0a1",
+    "pymcu-compiler[avr]>=0.1.0a1",
+    "pymcu-micropython>=0.1.0a1",
+]
+
+[tool.pymcu]
+board     = "arduino_uno"
+frequency = 16000000
+sources   = "src"
+entry     = "main.py"
+stdlib    = ["micropython"]
+
+[tool.pymcu.flash]
+programmer = "avrdude"
+# port = "/dev/cu.usbmodemXXXX"   # set your board port here, or pass --port

pymcu_micropython-0.1.0a1/examples/dht-sensor/src/dht.py

@@ -0,0 +1,115 @@
+# DHT11/DHT22 temperature and humidity driver (MicroPython style)
+#
+# API matches micropython-lib dht.py:
+#   sensor = DHT11(Pin(2, Pin.IN))   # or DHT22(...)
+#   sensor.measure()         -- read sensor (updates internal state)
+#   sensor.humidity()        -- humidity value
+#   sensor.temperature()     -- temperature value
+#   sensor.failed            -- True if read failed or checksum mismatch
+#                               (PyMCU extension: real MicroPython raises Exception)
+#
+# DHT11: humidity() -> integer % RH,  temperature() -> integer C
+# DHT22: humidity() -> float % RH,    temperature() -> float C (signed)
+#
+# Wiring:
+#   DATA -> pin passed in (e.g. D2), with 4.7 kohm pull-up to +5 V
+#   VCC  -> +5 V  (DHT11) or +3.3/5 V (DHT22)
+#   GND  -> GND
+#
+# Protocol (single-wire, 40-bit):
+#   1. MCU pulls low >= 18 ms  (start signal)
+#   2. MCU releases, sensor pulls low ~80 us then high ~80 us (ACK)
+#   3. 40 bits: each bit starts with ~50 us LOW; HIGH duration decides value:
+#      count > 35 loop iterations = 1, else = 0
+#   4. Checksum = lower 8 bits of sum of the first 4 bytes
+
+from pymcu.types import uint8, inline
+from machine import Pin, time_pulse_us
+from utime import sleep_ms, sleep_us
+
+
+class DHTBase:
+    @inline
+    def __init__(self, pin: Pin):
+        self._pin      = pin
+        self.failed    = False
+        self._hum_int  = 0
+        self._hum_dec  = 0
+        self._temp_int = 0
+        self._temp_dec = 0
+
+    @inline
+    def measure(self):
+        # Start signal: hold low >= 18 ms, then pull high 20-40 us before
+        # releasing to input.  The high() call leaves PORT bit = 1 so that
+        # mode(IN) enables the AVR internal pull-up (PORT=1, DDR=0).
+        self._pin.mode(Pin.OUT)
+        self._pin.low()
+        sleep_ms(18)
+        self._pin.high()
+        sleep_us(30)
+        self._pin.mode(Pin.IN)
+
+        # ACK: sensor pulls low ~80 us, then high ~80 us
+        if time_pulse_us(self._pin, 0, 1000) < 0:
+            self.failed = True
+            return
+        if time_pulse_us(self._pin, 1, 1000) < 0:
+            self.failed = True
+            return
+
+        # Read five bytes: hum_int, hum_dec, temp_int, temp_dec, checksum
+        hum_int:  uint8 = self._read_byte()
+        hum_dec:  uint8 = self._read_byte()
+        temp_int: uint8 = self._read_byte()
+        temp_dec: uint8 = self._read_byte()
+        checksum: uint8 = self._read_byte()
+
+        expected: uint8 = (hum_int + hum_dec + temp_int + temp_dec) & 0xFF
+        if checksum != expected:
+            self.failed = True
+            return
+
+        self.failed    = False
+        self._hum_int  = hum_int
+        self._hum_dec  = hum_dec
+        self._temp_int = temp_int
+        self._temp_dec = temp_dec
+
+    def _read_byte(self) -> uint8:
+        result: uint8 = 0
+        bit: uint8 = 0
+        while bit < 8:
+            # pulse_in(1) waits through the ~50 us bit-start LOW then
+            # measures the HIGH duration: ~26 us = 0, ~70 us = 1.
+            # Timeout returns -1 (int16) which is < 40, so the bit reads as 0;
+            # the checksum will catch any corrupted frame.
+            high_dur = time_pulse_us(self._pin, 1, 1000)
+            result = result << 1
+            if high_dur > 40:
+                result = result | 1
+            bit = bit + 1
+        return result
+
+
+class DHT11(DHTBase):
+    @inline
+    def humidity(self) -> uint8:
+        return self._hum_int
+
+    @inline
+    def temperature(self) -> uint8:
+        return self._temp_int
+
+
+class DHT22(DHTBase):
+    @inline
+    def humidity(self):
+        return (self._hum_int << 8 | self._hum_dec) * 0.1
+
+    @inline
+    def temperature(self):
+        t = ((self._temp_int & 0x7F) << 8 | self._temp_dec) * 0.1
+        if self._temp_int & 0x80:
+            t = 0 - t
+        return t

pymcu_micropython-0.1.0a1/examples/dht-sensor/src/main.py

@@ -0,0 +1,48 @@
+# DHT11 Sensor -- MicroPython style on Arduino Uno
+#
+# Demonstrates:
+#   machine.Pin  -- integer pin numbers (D2 = PD2 sensor, D13 = PB5 LED)
+#   print()       -- UART 0 auto-initialized at 115200 baud by pymcu build
+#   utime        -- sleep_ms() between measurements
+#   local driver -- dht11.DHT11 reads temperature and humidity
+#
+# MicroPython equivalent (runs unmodified on any MicroPython board with DHT):
+#   from machine import Pin
+#   from utime import sleep_ms
+#   from dht import DHT11
+#   sensor = DHT11(Pin(2, Pin.IN))
+#
+# Wiring:
+#   DHT11 DATA -> D2  (4.7 kohm pull-up to +5 V recommended)
+#   DHT11 VCC  -> +5 V
+#   DHT11 GND  -> GND
+#   LED:    built-in on D13 (no wiring needed)
+#
+# UART output (115200 baud, auto-initialized by pymcu build):
+#   Boot:  "DHT11 ready"
+#   OK:    "H: XX  T: XX"
+#   Error: "read error"
+
+from machine import Pin
+from utime import sleep_ms
+from dht import DHT11
+
+
+led    = Pin(13, Pin.OUT)
+sensor = DHT11(Pin(2, Pin.IN))
+
+print("DHT11 ready")
+
+while True:
+    sensor.measure()
+
+    if sensor.failed:
+        print("read error")
+        led.low()
+    else:
+        print("H: ", sensor.humidity(), "  T: ", sensor.temperature(), sep="")
+        led.high()
+        sleep_ms(100)
+        led.low()
+
+    sleep_ms(2000)

pymcu_micropython-0.1.0a1/examples/eeprom-avr/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "eeprom-avr"
+version = "0.1.0a1"
+requires-python = ">=3.11"
+dependencies = [
+    "pymcu-stdlib>=0.1.0a1",
+    "pymcu-compiler[avr]>=0.1.0a1",
+    "pymcu-micropython>=0.1.0a1",
+]
+
+[tool.pymcu]
+board     = "arduino_uno"
+frequency = 16000000
+sources   = "src"
+entry     = "main.py"
+stdlib    = ["micropython"]
+
+[tool.pymcu.flash]
+programmer = "avrdude"

pymcu_micropython-0.1.0a1/examples/eeprom-avr/src/main.py

@@ -0,0 +1,34 @@
+# eeprom-avr -- AVR EEPROM read / write
+#
+# Demonstrates avr.EEPROM to persist a counter across power cycles.
+# On each boot the counter is read from EEPROM, incremented, written
+# back, then the value is blinked out on the built-in LED (D13 / PB5):
+#   - each digit blinked N times (1-second on / off per blink)
+#   - 3-second pause between boots
+#
+# EEPROM address 0 holds the counter (0-9, wraps to 0 at 10).
+#
+# Wiring:  none -- built-in LED
+# Expected: blink count increments by 1 each power cycle (wraps at 10)
+
+from avr import EEPROM
+from machine import Pin
+from utime import sleep_ms
+
+ADDR: int = 0
+
+led  = Pin(13, Pin.OUT)
+ee   = EEPROM()
+n: int = ee.read(ADDR)
+if n >= 10:
+    n = 0
+count: int = n + 1
+ee.write(ADDR, count)
+i: int = 0
+while i < count:
+    led.value(1)
+    sleep_ms(500)
+    led.value(0)
+    sleep_ms(500)
+    i = i + 1
+sleep_ms(3000)

pymcu_micropython-0.1.0a1/examples/lm35-sensor/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "lm35-sensor"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+    "pymcu-stdlib>=0.1.0a1",
+    "pymcu-compiler[avr]>=0.1.0a1",
+    "pymcu-micropython>=0.1.0a1",
+]
+
+[tool.pymcu]
+board     = "arduino_uno"
+frequency = 16000000
+sources   = "src"
+entry     = "main.py"
+stdlib    = ["micropython"]
+
+[tool.pymcu.flash]
+programmer = "avrdude"
+# port = "/dev/cu.usbmodemXXXX"   # set your board port here, or pass --port

pymcu_micropython-0.1.0a1/examples/lm35-sensor/src/main.py

@@ -0,0 +1,34 @@
+# LM35 Temperature Sensor -- MicroPython style on Arduino Uno
+#
+# Demonstrates:
+#   machine.ADC  -- analog read on A0
+#   lm35.LM35    -- temperature conversion (integer and tenths)
+#   utime        -- sleep_ms() between readings
+#
+# MicroPython equivalent (runs unmodified on any MicroPython board):
+#   from machine import ADC
+#   from utime import sleep_ms
+#   from lm35 import LM35
+#   sensor = LM35(ADC(0))
+#
+# Wiring:
+#   LM35 VS   -> +5 V
+#   LM35 GND  -> GND
+#   LM35 VOUT -> A0
+#
+# UART output (115200 baud, auto-initialized by pymcu build):
+#   Boot:   "LM35 ready"
+#   Every 1 s:  "T: 24.8 C"   (integer part + tenths combined)
+
+from machine import ADC, Pin
+from utime import sleep_ms
+from lm35 import LM35
+
+
+sensor = LM35(ADC(Pin(14)))   # A0 = Pin(14) = PC0
+
+print("LM35 ready")
+
+while True:
+    print("T: ", sensor.temperature(), " C", sep="")
+    sleep_ms(1000)

pymcu_micropython-0.1.0a1/examples/mem8-test/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "mem8-test"
+version = "0.1.0a1"
+requires-python = ">=3.11"
+dependencies = [
+    "pymcu-stdlib>=0.1.0a1",
+    "pymcu-compiler[avr]>=0.1.0a1",
+    "pymcu-micropython>=0.1.0a1",
+]
+
+[tool.pymcu]
+board     = "arduino_uno"
+frequency = 16000000
+sources   = "src"
+entry     = "main.py"
+stdlib    = ["micropython"]
+
+[tool.pymcu.flash]
+programmer = "avrdude"

pymcu_micropython-0.1.0a1/examples/mem8-test/src/main.py

@@ -0,0 +1,24 @@
+# mem8-test -- raw I/O register access via pymcu.chips
+#
+# Demonstrates direct AVR I/O register access by blinking the built-in
+# LED (D13 / PB5) through DDRB and PORTB without using Pin.
+#
+# pymcu.chips.atmega328p exposes every hardware register as a typed
+# ptr[uint8] module-level constant. The compiler maps reads/writes to
+# the appropriate instruction (IN/OUT for I/O registers, LDS/STS for
+# extended I/O). No special compiler magic required -- ptr is the
+# standard PyMCU mechanism for raw memory access.
+#
+# Wiring:  none -- built-in LED
+# Expected: LED blinks at 2 Hz indefinitely
+
+from pymcu.chips.atmega328p import DDRB, PORTB, PORTB5
+from utime import sleep_ms
+
+DDRB.value = DDRB.value | (1 << PORTB5)
+
+while True:
+    PORTB.value = PORTB.value | (1 << PORTB5)
+    sleep_ms(250)
+    PORTB.value = PORTB.value & ~(1 << PORTB5)
+    sleep_ms(250)

pymcu_micropython-0.1.0a1/examples/pwm-demo/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "pwm-demo"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+    "pymcu-stdlib>=0.1.0a1",
+    "pymcu-compiler[avr]>=0.1.0a1",
+    "pymcu-micropython>=0.1.0a1",
+]
+
+[tool.pymcu]
+board     = "arduino_uno"
+frequency = 16000000
+sources   = "src"
+entry     = "main.py"
+stdlib    = ["micropython"]
+
+[tool.pymcu.flash]
+programmer = "avrdude"
+# port = "/dev/cu.usbmodemXXXX"   # set your board port here, or pass --port