Release v0.1.0a2 (alpha 2)

examples/adc-interrupt/README.md

@@ -9,9 +9,11 @@ instead of polling. `adc.irq(adc_isr)` registers the handler at the ADC vector,
 enables `ADIE`, and sets the global interrupt flag (`SEI`) for you — no
 `@interrupt` decorator or `asm("SEI")` needed.
 
-The ISR reads `ADCL` first (which latches `ADCH`), stashes the low byte in
-`GPIOR1`, and signals the main loop through bit `GPIOR0[1]`. The main loop prints
-the result over UART and kicks off the next conversion.
+The ISR reads `ADCL` first (which latches `ADCH`) and publishes the low byte
+plus a done flag through two plain module globals. The compiler detects both as
+ISR-shared (volatile semantics) and auto-promotes them to `GPIOR` registers, so
+the handoff is single-cycle I/O with zero SRAM. The main loop prints the result
+over UART and kicks off the next conversion.
 
 ## Hardware
 
@@ -27,7 +29,7 @@ conversion.
 ## Key concepts
 
 - `AnalogPin.irq()` — zero-boilerplate ISR registration
-- `GPIOR0`/`GPIOR1` general-purpose I/O registers used as atomic flags/storage
+- ISR-shared plain globals — auto-promoted to `GPIOR` registers by the compiler
 - Reading `ADCL` before `ADCH` to latch a coherent result
 
 ## Build & flash

examples/adc-interrupt/src/main.py

@@ -4,42 +4,48 @@
 # (byte 0x002A / word 0x0015), enables ADIE, and sets SEI -- no
 # @interrupt decorator or asm("SEI") needed.
 #
-# The ISR reads ADCL first (latches ADCH), stores the low byte in GPIOR1,
-# and signals the main loop via GPIOR0[1].
+# The ISR reads ADCL first (latches ADCH), publishes the low byte and a
+# done flag through plain module globals. Both are detected as ISR-shared
+# (volatile semantics) and auto-promoted to GPIOR registers, so the
+# ISR<->main handoff is single-cycle I/O with zero SRAM.
 # Main loop prints the result over UART and triggers the next conversion.
 #
 # Hardware: Arduino Uno
 #   - ADC0 = PC0 (analog input)
 #   - UART TX 9600 baud
 #
 from pymcu.types import uint8
-from pymcu.chips.atmega328p import GPIOR0, GPIOR1, ADCL, ADCH
+from pymcu.chips.atmega328p import ADCL, ADCH
 from pymcu.hal.uart import UART
 from pymcu.hal.adc import AnalogPin
 
+# Written by the ISR, read by main. ISR-shared -> auto-promoted to GPIORs;
+# both start at 0 on reset.
+sample: uint8 = 0   # latest ADC low byte
+done:   uint8 = 0   # conversion-complete flag
+
 
 def adc_isr():
     # Must read ADCL first to latch ADCH.
-    GPIOR1.value = ADCL.value
-    GPIOR0[1] = 1
+    global sample, done
+    sample = ADCL.value
+    done = 1
 
 
 def main():
     uart = UART(9600)
     adc  = AnalogPin("PC0")
     adc.irq(adc_isr)
 
-    GPIOR0[1] = 0
-    GPIOR1.value = 0
     uart.println("ADC IRQ")
 
     # Kick off first conversion
     adc.start_conversion()
 
     while True:
-        if GPIOR0[1] == 1:
-            GPIOR0[1] = 0
-            result: uint8 = GPIOR1.value
+        if done == 1:
+            done = 0
+            result: uint8 = sample
             uart.write(result)
             uart.write('\n')
             # Start next conversion

examples/analog-inout-mp/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "analog-inout-mp"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+    "pymcu-stdlib>=0.1.0",
+    "pymcu-micropython>=0.1.0a1",
+]
+
+[tool.pymcu]
+board     = "arduino_uno"
+frequency = 16000000
+sources   = "src"
+entry     = "main.py"
+stdlib    = ["micropython"]

examples/analog-inout-mp/src/main.py

@@ -0,0 +1,21 @@
+# Arduino "AnalogInOutSerial" (03.Analog), ported to PyMCU on the MicroPython
+# compatibility layer (machine).
+#
+# Reads a potentiometer on A0, maps 0-1023 to a 0-255 PWM duty on D6 (OC0A), and
+# echoes the duty byte over UART. Exercises machine.ADC, machine.PWM (both Pin
+# overloads -- Pin(14) int for A0 and Pin("PD6") string) and machine.UART.
+from machine import Pin, ADC, PWM, UART
+from pymcu.types import uint8, uint16
+
+
+def main():
+    uart = UART(0, 9600)
+    pot = ADC(Pin(14))        # Pin(14) == A0 == PC0  (int->name overload)
+    led = PWM(Pin("PD6"))     # OC0A PWM output        (str overload)
+    led.init()
+
+    while True:
+        sensor: uint16 = pot.read()      # 0..1023
+        out: uint8 = uint8(sensor >> 2)  # map 0..1023 -> 0..255 (Arduino map)
+        led.duty(out)                    # analogWrite(D6, out)
+        uart.write(out)                  # echo duty byte (sync marker for tests)

examples/analog-inout/pyproject.toml

@@ -0,0 +1,8 @@
+[project]
+name = "analog-inout"
+version = "0.1.0"
+[tool.pymcu]
+target = "atmega328p"
+frequency = 16000000
+sources = "src"
+entry = "main.py"

examples/analog-inout/src/main.py

@@ -0,0 +1,19 @@
+# Arduino "AnalogInOutSerial" (03.Analog), native PyMCU HAL.
+# Read A0, map 0-1023 -> 0-255 PWM duty on D6, echo duty over UART.
+from pymcu.types import uint8, uint16
+from pymcu.hal.uart import UART
+from pymcu.hal.adc import AnalogPin
+from pymcu.hal.pwm import PWM
+
+
+def main():
+    uart = UART(9600)
+    pot = AnalogPin("PC0")
+    led = PWM("PD6", 0)
+    led.start()
+
+    while True:
+        sensor: uint16 = pot.read()
+        out: uint8 = uint8(sensor >> 2)
+        led.set_duty(out)
+        uart.write(out)

examples/dht-sensor/src/main.py

@@ -3,10 +3,14 @@
 # Demonstrates:
 #   - Board abstractions:  pymcu.boards.arduino_uno
 #   - Stdlib driver:       pymcu.drivers.dht11 (arch-neutral ZCA, same pattern as Pin/UART)
-#   - Multi-file project:  main.py is the only local file; drivers live in the stdlib
+#   - Multi-file project:  main.py is the only local file; the driver lives in the stdlib
 #
-# sensor = DHT11("PD2")   → D2 = "PD2" bound at compile time
-# sensor.read()        → match __CHIP__.arch → match pin_name (const[str]) → direct protocol
+# sensor = DHT11(D2)   → D2 = "PD2" bound at compile time
+# sensor.read()        → match __CHIP__.arch → match pin_name (const[str]) → shared protocol
+#
+# The driver stores only a const[str] pin name (a scalar field), so DHT11.read() is a
+# zero-cost abstraction: the heavy bit-bang protocol lives in one shared _pd_read(bit)
+# subroutine, not duplicated per instance.
 #
 # Wiring:
 #   DHT11 DATA → Arduino D2 (4.7 kΩ pull-up to +5 V)
@@ -21,31 +25,28 @@
 from pymcu.hal.gpio import Pin
 from pymcu.hal.uart import UART
 from pymcu.time import delay_ms
-from dht11 import DHT11
-
-
-def nibble_hex(n: uint8) -> uint8:
-    if n < 10:
-        return n + 48
-    return n + 55
+from pymcu.drivers.dht11 import DHT11
 
 
 def main():
-    uart     = UART(9600)
-    led      = Pin(LED_BUILTIN, Pin.OUT)
-    data_pin = Pin(D2, Pin.IN)   # DHT11 data pin — driver switches direction at runtime
-    sensor   = DHT11(data_pin)   # ZCA: sensor.pin tracks data_pin.name compile-time
+    uart   = UART(9600)
+    led    = Pin(LED_BUILTIN, Pin.OUT)
+    sensor = DHT11(D2)   # ZCA: stores the const "PD2" name, no per-instance protocol copy
 
     print("DHT11")
 
     while True:
-        sensor.measure()
+        # read() returns uint16: high byte = humidity %, low byte = temperature °C.
+        # 0xFFFF signals a failure (no sensor, timeout or checksum mismatch).
+        data: uint16 = sensor.read()
 
-        if sensor.failed:
+        if data == 0xFFFF:
             print("ERR")
             led.low()
         else:
-            print("H:", sensor.humidity, " T:", sensor.temperature, sep="")
+            humidity:    uint8 = uint8(data >> 8)
+            temperature: uint8 = uint8(data & 0xFF)
+            print("H:", humidity, " T:", temperature, sep="")
             led.high()
 
         delay_ms(2000)

examples/i2c-irq/README.md

@@ -7,7 +7,8 @@ Interrupt-driven I2C **peripheral** (TWI slave) at address 0x42.
 Configures the TWI hardware as an I2C peripheral and registers an ISR with
 `i2c.irq(handler)` (no `@interrupt` decorator or manual `TWIE`/`SEI` writes).
 The ISR runs the TWI state machine — inspecting `TWSR`, ACKing each event, and
-saving received data bytes to `GPIOR0` for the main loop to print as hex.
+saving received data bytes to a plain module global (auto-promoted to a `GPIOR`
+register by the compiler) for the main loop to print as hex.
 
 > The ISR **must** re-arm the interrupt by writing `TWCR` with `TWINT=1`
 > (`0xC4 = TWINT|TWEA|TWEN`) or the peripheral stalls.
@@ -26,7 +27,7 @@ saving received data bytes to `GPIOR0` for the main loop to print as hex.
 ## Key concepts
 
 - TWI peripheral mode + interrupt-driven state machine
-- `GPIOR0` as an atomic flag between ISR and main loop
+- ISR-shared plain global between ISR and main — auto-promoted to a `GPIOR` register
 
 ## Build & flash
 

examples/i2c-irq/src/main.py

@@ -5,7 +5,9 @@
 #   - i2c.irq(handler): register ISR at TWI vector via compile_isr;
 #     no @interrupt decorator, TWCR.TWIE write, or asm("SEI") needed
 #   - TWI state machine in the ISR: check TWSR, ACK each event
-#   - GPIOR0 atomic storage: SBI/CBI are single-cycle IO instructions
+#   - ISR<->main handoff through a plain module global: detected as
+#     ISR-shared (volatile semantics) and auto-promoted to a GPIOR
+#     register, so the received byte moves through single-cycle I/O
 #
 # Hardware: Arduino Uno as I2C peripheral
 #   SDA = PC4 (Arduino pin A4) -- controlled by TWI hardware
@@ -17,22 +19,30 @@
 # (bit 7) to re-arm the interrupt; otherwise the peripheral stalls.
 # TWCR = 0xC4: TWINT(7)|TWEA(6)|TWEN(2).
 #
+# Note: a received 0x00 byte is indistinguishable from "no data" in this
+# simple demo -- the main loop only reports non-zero bytes.
+#
 # Output:
 #   "I2CI\n"    -- boot banner
 #   "XX\n"      -- two hex digits for each data byte received from controller
 #
 from pymcu.types import uint8
-from pymcu.chips.atmega328p import TWSR, TWDR, TWCR, GPIOR0
+from pymcu.chips.atmega328p import TWSR, TWDR, TWCR
 from pymcu.hal.i2c import I2C
 from pymcu.hal.uart import UART
 
+# Last received data byte, written by the ISR and consumed by main.
+# ISR-shared -> auto-promoted to a GPIOR register; starts at 0 on reset.
+rx: uint8 = 0
+
 
 def on_event():
+    global rx
     status: uint8 = TWSR.value & 0xF8
     if status == 0x60:          # own SLA+W received, ACK returned
         TWCR.value = 0xC4       # TWINT | TWEA | TWEN -- ready for data
     elif status == 0x80:        # data byte received, ACK returned
-        GPIOR0[0] = TWDR.value  # save byte for main loop
+        rx = TWDR.value         # save byte for main loop
         TWCR.value = 0xC4
     elif status == 0xA0:        # STOP or repeated START received
         TWCR.value = 0xC4
@@ -48,12 +58,11 @@ def main():
     # No @interrupt decorator or asm("SEI") needed.
     i2c.irq(on_event)
 
-    GPIOR0[0] = 0
     uart.println("I2CI")
 
     while True:
-        if GPIOR0[0] != 0:
-            byte: uint8 = GPIOR0[0]
-            GPIOR0[0] = 0
+        if rx != 0:
+            byte: uint8 = rx
+            rx = 0
             uart.write_hex(byte)
             uart.write('\n')

examples/interrupt-counter/README.md

@@ -6,7 +6,8 @@ External interrupt (INT0) press counter.
 
 `btn.irq(Pin.IRQ_FALLING, int0_isr)` configures the INT0 hardware interrupt on
 **PD2** (falling edge), enables the interrupt mask, and sets `SEI` — no manual
-`EICRA`/`EIMSK` writes. The ISR sets an atomic flag in `GPIOR0`; the main loop
+`EICRA`/`EIMSK` writes. The ISR sets a plain module global — the compiler
+detects it as ISR-shared and auto-promotes it to `GPIOR0` — and the main loop
 clears it, increments a counter, toggles the LED, and sends the raw count over
 UART.
 
@@ -20,7 +21,7 @@ UART.
 ## Key concepts
 
 - `Pin.irq()` for hardware external interrupts
-- `GPIOR0` SBI/CBI atomic flag pattern (ISR sets, main clears)
+- ISR-shared plain global (ISR sets, main clears) — auto-promoted to `GPIOR0`, compiles to SBI/CBI/IN/OUT
 
 ## Build & flash