Python forArduino

# ── 1. Imports come first ─────────────────────────────────
from machine import Pin, ADC, PWM   # hardware access
import time                          # sleep, ticks_ms
import sys                           # system info

# ── 2. Constants (UPPER_CASE by convention) ───────────────
LED_PIN  = 13
BAUD     = 9600
INTERVAL = 0.5   # seconds

# ── 3. Global variables ───────────────────────────────────
counter = 0

# ── 4. Hardware objects ───────────────────────────────────
led = Pin(LED_PIN, Pin.OUT)

# ── 5. Functions ──────────────────────────────────────────
def blink(times=1, ms=200):
    """Blink the LED 'times' times with 'ms' delay."""  # docstring
    for _ in range(times):
        led.on()
        time.sleep_ms(ms)
        led.off()
        time.sleep_ms(ms)

# ── 6. Main entry point ───────────────────────────────────
# MicroPython runs main.py top-to-bottom, then enters REPL.
# Wrap your program in a main() function and call it:
def main():
    print("Arduino ready!")
    blink(times=3)

    while True:           # the infinite loop replaces C++ loop()
        global counter
        counter += 1
        print(f"Loop {counter}")
        time.sleep(INTERVAL)

main()   # runs automatically when file loads

# ── Variable assignment ──────────────────────────────────
name     = "Arduino"
count    = 0
voltage  = 3.3
is_on    = False
nothing  = None

# Multiple assignment
x, y, z = 1, 2, 3     # tuple unpacking
a = b = c = 0          # chain assignment

# ── Type introspection ──────────────────────────────────
print(type(42))            # <class 'int'>
print(isinstance(42, int))  # True  — preferred over type() check

# ── Explicit type conversion ─────────────────────────────
raw   = 512
volts = float(raw) * 3.3 / 65535   # R4 ADC is 14-bit (0-65535)
text  = str(raw)
val   = int("42")

# ── f-strings (Python 3.6+, supported in MicroPython) ──
print(f"Voltage: {volts:.3f} V")    # format spec in f-string
print(f"Count: {count}, Pin: {13}")

# ── Truthiness — falsy values ────────────────────────────
# None, False, 0, 0.0, "", [], {}, () → all falsy
# Everything else → truthy
if count:             # True only if count != 0
    print("has value")
if val is not None:  # explicit None check — preferred style
    print("not null")

# ── bytes / bytearray — essential for hardware ───────────
buf = bytearray(4)     # 4-byte mutable buffer filled with zeros
buf[0] = 0xFF           # set first byte
buf[1] = 0b10110000    # binary literal
print(buf.hex())        # 'ffb00000'

# ── Constants — by convention UPPER_CASE, not enforced ──
MAX_BRIGHTNESS = 255
I2C_ADDR       = 0x3C   # hex literal — common in embedded code

# ── No ++ operator — use += 1 ────────────────────────────
i = 0
i += 1      # NOT i++  ← that doesn't exist in Python

# ── Integer vs float division ────────────────────────────
print(10 / 3)    # 3.3333  — always float
print(10 // 3)   # 3       — floor division (like C int/int)
print(10 % 3)    # 1       — modulo
print(2 ** 8)    # 256     — exponentiation

# ── Logical operators are WORDS not symbols ──────────────
x, y = 5, 10
if x > 0 and y < 20:   # not &&
    print("both true")
if x == 0 or y == 0:    # not ||
    print("one is zero")
if not is_on:             # not !
    print("LED is off")

# ── Bitwise (identical to C++) ───────────────────────────
reg = 0b10110000
reg |=  (1 << 2)   # SET bit 2
reg &= ~(1 << 7)   # CLEAR bit 7
reg ^=  (1 << 4)   # TOGGLE bit 4

# ── Chained comparisons (Pythonic!) ─────────────────────
val = 512
if 0 <= val <= 1023:      # more readable than val>=0 and val<=1023
    print("valid ADC reading")

# ── Ternary expression ───────────────────────────────────
status = "ON" if is_on else "OFF"

# ── IF / ELIF / ELSE ──────────────────────────────────────
temp = 25
if temp < 0:
    print("Freezing")
elif temp < 20:           # elif — NOT else if
    print("Cold")
else:
    print("Warm")

# ── MATCH / CASE (Python 3.10+, MicroPython 1.21+) ───────
mode = 2
match mode:
    case 0: print("OFF")
    case 1: print("BLINK")
    case 2: print("CHASE")
    case _: print("UNKNOWN")  # wildcard default

# ── FOR LOOP — iterates directly over any iterable ────────
pins = [9, 10, 11]
for pin in pins:          # no index needed!
    print(pin)

# Range (like C for-loop)
for i in range(10):        # 0–9
    print(i)
for i in range(2, 10, 2): # 2,4,6,8 (start, stop, step)
    print(i)

# enumerate() — get index AND value (not range(len()))
for i, pin in enumerate(pins):
    print(f"LED{i} → pin {pin}")

# for…else — else runs ONLY if loop completed without break
for n in pins:
    if n == 99:
        break
else:
    print("pin 99 not found")   # prints — loop completed

# ── WHILE LOOP ────────────────────────────────────────────
count = 0
while count < 5:
    count += 1

# ── NON-BLOCKING TIMING with ticks_ms ────────────────────
# MicroPython equivalent of millis() pattern
last_tick = time.ticks_ms()
INTERVAL_MS = 1000

while True:
    now = time.ticks_ms()
    if time.ticks_diff(now, last_tick) >= INTERVAL_MS:
        last_tick = now
        print("tick!")      # periodic work — not blocking
    # other code runs here every loop iteration

# ── BREAK / CONTINUE / PASS ──────────────────────────────
for i in range(10):
    if i == 5:
        break           # exit loop entirely
    if i % 2 == 0:
        continue        # skip even numbers
    print(i)

def not_yet_implemented():
    pass               # pass = no-op placeholder (like {} in C++)

# ── Basic function ───────────────────────────────────────
def add(a, b):
    return a + b

# ── Default parameters ───────────────────────────────────
def blink(pin, times=1, ms=200):
    for _ in range(times):
        pin.on();  time.sleep_ms(ms)
        pin.off(); time.sleep_ms(ms)

blink(led)              # uses defaults: times=1, ms=200
blink(led, times=3)     # keyword argument — order doesn't matter
blink(led, 5, 100)      # positional arguments

# ── Multiple return values (as tuple) ───────────────────
def read_sensors():
    temp    = 25.4
    humidity = 60.2
    return temp, humidity       # returns a tuple

t, h = read_sensors()           # unpack immediately

# ── *args — variadic positional arguments (tuple) ───────
def total(*nums):
    return sum(nums)

total(1, 2, 3, 4)   # 10

# ── **kwargs — variadic keyword args (dict) ──────────────
def configure(**opts):
    for key, val in opts.items():
        print(f"  {key} = {val}")

configure(baud=9600, debug=True)

# ── Type hints (documentation, not enforced at runtime) ─
def voltage(raw: int, ref: float = 3.3) -> float:
    return raw * ref / 65535.0   # R4 14-bit ADC

# ── Lambda — anonymous single-expression function ────────
scale = lambda x: x * 3.3 / 65535
result = scale(32767)   # 1.65 V

# ── Functions as arguments (callback pattern) ────────────
def apply(value, func):
    return func(value)

apply(512, scale)   # passes function as argument

# ── Closure — inner function captures outer variable ─────
def make_scaler(ref_voltage):
    def scaler(raw):
        return raw * ref_voltage / 65535  # ref_voltage captured
    return scaler

to_5v = make_scaler(5.0)   # closure with 5V reference
to_3v = make_scaler(3.3)   # closure with 3.3V reference

# ── Generator — lazy sequence, saves RAM on MCU ─────────
def pwm_steps(start=0, stop=256, step=16):
    while start < stop:
        yield start        # pauses here, resumes on next()
        start += step

for level in pwm_steps():
    print(level)           # 0, 16, 32, ... 240

from machine import Pin, PWM

# ── Class definition ─────────────────────────────────────
class SmartLED:
    """A PWM-capable LED with convenience methods."""

    # Class variable — shared by ALL instances
    count = 0

    def __init__(self, pin: int, freq: int = 1000):
        """Constructor — called when SmartLED(13) is created."""
        self._pin = Pin(pin, Pin.OUT)         # _prefix = private by convention
        self._pwm = PWM(self._pin, freq=freq)
        self._brightness = 0
        self._is_on = False
        SmartLED.count += 1                 # increment class variable

    # ── Regular methods ──────────────────────────────────
    def on(self, brightness: int = 65535):    # R4 PWM is 16-bit
        self._brightness = max(0, min(65535, brightness))
        self._pwm.duty_u16(self._brightness)
        self._is_on = True

    def off(self):
        self._pwm.duty_u16(0)
        self._is_on = False

    def toggle(self):
        self.off() if self._is_on else self.on()

    def blink(self, times=1, ms=200):
        for _ in range(times):
            self.on(); time.sleep_ms(ms)
            self.off(); time.sleep_ms(ms)

    # ── Properties — computed / validated attributes ──────
    @property
    def brightness(self):
        return self._brightness

    @brightness.setter
    def brightness(self, value):
        if not (0 <= value <= 65535):
            raise ValueError(f"Brightness must be 0-65535, got {value}")
        self.on(value)

    # ── Dunder (magic) methods ───────────────────────────
    def __repr__(self):        # repr(obj) — developer string
        return f"SmartLED(pin={self._pin}, on={self._is_on})"

    def __str__(self):         # str(obj) / print(obj)
        state = "ON" if self._is_on else "OFF"
        return f"LED[{state} @{self._brightness}]"

    def __bool__(self):        # truth value: if led:
        return self._is_on

    def __del__(self):         # called before garbage collection
        self.off()
        SmartLED.count -= 1

    # ── Class and static methods ─────────────────────────
    @classmethod
    def total(cls):
        return cls.count         # cls = the class itself

    @staticmethod
    def percent_to_duty(pct):  # no self or cls needed
        return int(pct / 100 * 65535)


# ── Inheritance ──────────────────────────────────────────
class RGBled(SmartLED):
    """Extends SmartLED with color channel tracking."""

    def __init__(self, r_pin, g_pin, b_pin):
        super().__init__(r_pin)           # call parent __init__
        self._g = SmartLED(g_pin)
        self._b = SmartLED(b_pin)

    def color(self, r, g, b):          # r,g,b as 0-255
        scale = lambda v: v * 257      # 0-255 → 0-65535
        self.on(scale(r))
        self._g.on(scale(g))
        self._b.on(scale(b))


# ── Usage ────────────────────────────────────────────────
led = SmartLED(13)
led.blink(times=3)
led.brightness = 32000    # uses setter
print(led)                  # uses __str__
print(SmartLED.total())     # class method
duty = SmartLED.percent_to_duty(50)  # static method

# ══ LIST — mutable ordered sequence ═════════════════════
pins = [9, 10, 11]
pins.append(12)          # [9, 10, 11, 12]
pins.insert(0, 8)         # [8, 9, 10, 11, 12]
pins.pop()                # removes & returns 12
pins.remove(8)            # removes first occurrence of 8
pins.sort()               # in-place sort
pins.reverse()            # in-place reverse
len(pins)                  # length
pins[0]                   # first element
pins[-1]                  # last element
pins[1:3]                  # slice [10, 11]
pins[::-1]                 # reversed copy

# ══ TUPLE — immutable ordered sequence ══════════════════
# Use for fixed data: pin configs, coordinates, RGB values
pos = (3, 4)
x, y = pos                # unpack
first, *rest = (1, 2, 3, 4)   # first=1, rest=[2,3,4]
RGB_RED   = (255, 0, 0)  # constant config — tuple is ideal

# ══ DICT — key/value map ════════════════════════════════
config = {
    "baud":   9600,
    "pins":   [9, 10, 11],
    "debug":  True
}
config["baud"]           # 9600 — KeyError if missing
config.get("baud")       # 9600 — None if missing (safe)
config.get("x", 0)       # 0    — default if missing
config["mode"] = "blink" # add / update key
del config["debug"]      # delete key
"baud" in config          # True — key membership

for key, val in config.items():   # iterate pairs
    print(f"  {key}: {val}")

# ══ SET — unordered, unique elements ════════════════════
active = {9, 10}
active.add(11)            # {9, 10, 11}
active.discard(99)        # no error if missing
9 in active                # True — fast membership test
all_pins  = {9, 10, 11, 12}
used = active & all_pins   # intersection: {9, 10, 11}
free = all_pins - active   # difference:   {12}

# Syntax: [expression  for item in iterable  if condition]

# ── LIST COMPREHENSION ───────────────────────────────────
squares  = [x**2 for x in range(10)]
evens    = [x for x in range(20) if x % 2 == 0]
voltages = [raw * 3.3 / 65535 for raw in adc_readings]

# Flatten a 2D list (nested comprehension)
matrix = [[1,2],[3,4],[5,6]]
flat   = [x for row in matrix for x in row]  # [1,2,3,4,5,6]

# ── DICT COMPREHENSION ───────────────────────────────────
pins       = [9, 10, 11]
pin_states = {p: False for p in pins}   # {9: False, 10: False, 11: False}
inverted   = {v: k for k, v in config.items()}  # flip keys/values

# ── SET COMPREHENSION ────────────────────────────────────
unique_lengths = {len(w) for w in ["hi", "hey", "hello", "hi"]}  # {2, 3, 5}

# ── GENERATOR EXPRESSION — lazy, no RAM allocation ──────
# Use () instead of []. Ideal when you only iterate once.
total = sum(x**2 for x in range(1000))   # ← no list built in RAM!

# ── Conditional expression (ternary) inside comprehension
labels = ["even" if x % 2 == 0 else "odd" for x in range(6)]
# ['even','odd','even','odd','even','odd']

# ── try / except / else / finally ───────────────────────
try:
    val = int("not a number")     # raises ValueError
except ValueError as e:
    print(f"Bad value: {e}")
except (TypeError, OSError) as e:  # catch multiple types
    print(f"Error: {e}")
except Exception as e:            # catch-all (use sparingly)
    print(f"Unexpected: {e}")
    raise                          # re-raise the original exception
else:
    print("No exception occurred")  # runs ONLY on success
finally:
    print("Always runs — cleanup")  # runs no matter what

# ── Custom exception class ───────────────────────────────
class SensorError(Exception):
    def __init__(self, msg, code=None):
        super().__init__(msg)
        self.code = code

raise SensorError("Temp sensor offline", code=503)

# ── Common exceptions in embedded/MicroPython ────────────
# ValueError   — wrong value for right type: int("abc")
# TypeError    — wrong type: "1" + 1
# OSError      — hardware I/O failure (I2C, UART, file)
# IndexError   — list index out of range
# KeyError     — dict key not found
# AttributeError — object has no such attribute
# MemoryError  — ran out of RAM (critical on MCU!)

# ── Safe sensor reading pattern ──────────────────────────
def safe_read(sensor, retries=3):
    for attempt in range(retries):
        try:
            return sensor.read()
        except OSError:
            time.sleep_ms(100)
    return None   # all retries failed

# ── Import styles ────────────────────────────────────────
import time                        # use as time.sleep()
import time as t                  # use as t.sleep()
from machine import Pin, ADC, PWM # import specific names
from machine import *             # import all — avoid (pollutes namespace)

# ── MicroPython built-in modules ─────────────────────────
import machine    # Pin, ADC, PWM, UART, I2C, SPI, Timer
import time       # sleep, sleep_ms, sleep_us, ticks_ms, ticks_diff
import sys        # sys.exit, sys.platform, sys.version
import gc         # garbage collector — gc.collect(), gc.mem_free()
import math       # sin, cos, sqrt, pi — hardware float
import struct     # pack/unpack binary data — common in sensor protocols
import ujson      # JSON encode/decode (micro version)
import uasyncio   # async/await coroutines (micro asyncio)

# ── Writing your own module ──────────────────────────────
# Save as 'sensors.py' on the device (via Arduino Lab IDE)
# sensors.py:
#   def read_temp(adc_pin): ...
#   def read_light(adc_pin): ...

from sensors import read_temp     # import from your module

# ── __name__ guard (good practice) ───────────────────────
# Code inside this block only runs when the file is run directly,
# not when it's imported as a module.
if __name__ == "__main__":
    main()

# ── Check available RAM ───────────────────────────────────
import gc
gc.collect()
print(gc.mem_free(), "bytes free")

"""
Hello World — Arduino Uno R4 MicroPython
Blinks the built-in LED on pin 13 and prints to serial.

Hardware: No extra components.
IDE: Open Serial Terminal in Arduino Lab for MicroPython.
"""

from machine import Pin
import time

LED_PIN = 13              # built-in LED on Uno R4
led     = Pin(LED_PIN, Pin.OUT)
count   = 0

print("Hello, Arduino World!")

while True:
    led.on()
    time.sleep(0.5)
    led.off()
    time.sleep(0.5)

    count += 1
    print(f"Blink #{count}")

from micropython import const
import gc

# ✅ const() — stored as C integer, not Python object → saves RAM
MAX_BRIGHTNESS = const(65535)
LED_PIN        = const(13)

# ✅ Pre-allocate buffers OUTSIDE loops
buf = bytearray(32)   # allocate once
while True:
    read_into(buf)    # reuse the same buffer — no new allocation

# ✅ Use ticks_diff for non-blocking timing
last = time.ticks_ms()
while True:
    now = time.ticks_ms()
    if time.ticks_diff(now, last) >= 1000:
        last = now
        do_periodic_work()    # never blocked by sleep

# ✅ Tuple for config data (no mutation = safer + less RAM)
VALID_PINS = (9, 10, 11)     # NOT a list

# ✅ Use f-strings (not % or .format — they create more objects)
print(f"v={voltage:.3f}V raw={raw}")

# ✅ Periodic GC — prevents heap fragmentation
if state["tick"] % 200 == 0:
    gc.collect()
    print(f"RAM free: {gc.mem_free()}")

# ✅ Graceful Ctrl+C exit — always wrap main loop
try:
    main()
except KeyboardInterrupt:
    cleanup()   # turn off pins, save state, etc.