OpenMV AE3¶

OpenMV AE3 izgrađen je oko Alif Ensemble E3 — dvojezgrenog ARM Cortex‑M55 SoC‑a (400 MHz HP jezgra + 160 MHz HE jezgra) s dvije ugrađene NPU jedinice (400 MHz / 204 GOPS HP NPU + 160 MHz / 46 GOPS HE NPU). Ploča uparuje NPU jedinice s PAG7936 1 MP senzorom s globalnim okidačem, USB‑C high‑speed sučeljem, Wi‑Fi‑jem, Bluetooth 5.1, LSM6DSM IMU‑om, mikrofonom i 8×8 VL53L8CX mjeračem udaljenosti tehnologijom time‑of‑flight, sve na ploči dimenzija 30 × 30 mm.

Za potpuni podatkovni list, fotografije i dimenzije pogledajte stranicu proizvoda OpenMV AE3.

Istaknute značajke¶

Alif Ensemble E3 — dvojezgreni ARM Cortex‑M55 s Helium 128‑bitnim SIMD‑om, 400 MHz HP jezgra + 160 MHz HE jezgra (~640 / ~256 DMIPS, CoreMark 1748 / 752).
Dvije NPU jedinice: 400 MHz / 204 GOPS HP NPU + 160 MHz / 46 GOPS HE NPU za AI/ML — pokreće YOLO detekciju objekata uz druge radne zadatke.
Hardverski 2D GPU za skaliranje.
13,5 MB unutarnjeg SRAM‑a plus 5,5 MB ugrađene MRAM memorije i 32 MB vanjske oktalne flash memorije (100 MHz 8‑bitni DDR, 200 MB/s čitanje).
4 KB sigurnosne RAM memorije s ugrađenim RTC‑om.
PAG7936 1 MP senzor u boji s globalnim okidačem.
Ugrađeni IMU (LSM6DSM akcelerometar + žiroskop), mikrofon i VL53L8CX 8×8 time‑of‑flight senzor (do 4 m).
High‑speed USB‑C (480 Mb/s) s EMI filtriranjem i TVS zaštitom, Wi‑Fi a/b/g/n + Bluetooth 5.1 (čip antena ili U.FL opcija).
10 korisničkih I/O pinova — P0–P3 na bočnim priključcima, P4–P5 na Qwiic konektoru i P6–P9 na B2B priključku na stražnjoj strani. Na B2B priključak također su izvedene dodatne linije za otklanjanje pogrešaka i oporavak.
Svi pinovi 3,3 V izlaz / podnose 3,3 V, 25 mA po pinu, sposobni za prekide. ADC ulazi referencirani su na 1,8 V.
Korisnička RGB LED, korisnička tipka, prekidač za oporavak, Qwiic konektor.
80 µA duboko mirovanje pri 3,3 V (24 mA u praznom hodu, 50–60 mA aktivno).

Upozorenje

I/O pinovi AE3 ne podnose 5 V. Ne spajajte uređaj izravno na 5 V MCU poput Arduino Mega — koristite pretvarač razine napona za bilo koji 5 V signal.

Raspored pinova¶

Referenca pinova¶

AE3 izlaže 10 korisničkih pinova na bočnim priključcima (P0–P9). Dodatni signali — uključujući JTAG i liniju za oporavak — izvedeni su na B2B (board‑to‑board) priključak na stražnjoj strani ploče za module proširenja i nosive ploče.

Naziv pina	Referenca	Funkcija
P0	3,3 V	SPI0 MOSI / I2C2 SCL / UART4 TX / TIM0 T1 / PDM D3
P1	3,3 V	SPI0 MISO / I2C2 SDA / UART4 RX / TIM0 T0
P2	3,3 V	SPI0 SCLK / LPI2C SDA / UART5 TX / TIM1 T1
P3	3,3 V	SPI0 SS / LPI2C SCL / UART5 RX / TIM1 T0 / PDM C3
P4	3,3 V	I2C1 SCL / UART1 TX / TIM2 T1 / PDM C0 / CAN TX
P5	3,3 V	I2C1 SDA / UART1 RX / TIM2 T0 / PDM D0 / CAN RX
P6	1,8 V	I2C1 SDA / UART3 CTS / TIM9 T0 (samo B2B)
P7	1,8 V	I2C1 SCL / UART3 RTS / TIM9 T1 (samo B2B)
P8	1,8 V	I3C SDA / UART3 RX / TIM5 T0 / ADC ch S10 (samo B2B)
P9	1,8 V	I3C SCL / UART3 TX / TIM5 T1 / ADC ch S11 (samo B2B)
P10	1,8 V	GPIO / JTAG TCK (samo B2B)
P11	1,8 V	GPIO / JTAG TDO (samo B2B)
P13	1,8 V	GPIO / JTAG TMS (samo B2B)
P14	1,8 V	GPIO / JTAG TDI (samo B2B)
RESET	3,3 V	povucite na GND za resetiranje ploče
SW	3,3 V	korisnička tipka (aktivna na niskoj razini)
LED_RED	3,3 V	crveni kanal RGB LED‑a (aktivan na niskoj razini)
LED_GREEN	3,3 V	zeleni kanal RGB LED‑a (aktivan na niskoj razini)
LED_BLUE	3,3 V	plavi kanal RGB LED‑a (aktivan na niskoj razini)

Napomena

P0–P5 nalaze se na bočnim priključcima (referencirani na 3,3 V); P6–P9 izloženi su samo na B2B priključku na stražnjoj strani ploče i referencirani su na 1,8 V. Dovođenje 3,3 V na pin referenciran na 1,8 V oštetit će SoC — provjerite da je svaki signal spojen na B2B priključak na 1,8 V.

Pinovi za napajanje¶

3.3V — glavna naponska sabirnica AE3. Ista 3,3 V sabirnica izložena je na lemnim pločicama GPIO priključka, na Qwiic konektoru i na B2B priključku na stražnjoj strani ploče.
1.8V — izložen na B2B priključku samo kao izlaz. Koristite ga za napajanje periferije s 1,8 V logikom na B2B nosivoj ploči; ne dovodite napon na njega izvana.
GND — zajednička masa.

AE3 nema VIN pin ni LiPo punjač. Može se napajati kroz bilo koji od tri puta:

USB‑C — ugrađeni regulator snižava 5 V s USB‑a na 3,3 V i dovodi to na 3,3 V sabirnicu.
Qwiic konektor — dovedite regulirano napajanje od 3,3 V na Qwiic priključak kako biste ploču napajali iz Qwiic modula.
GPIO priključak / B2B 3,3 V pločice — dovedite regulirano napajanje od 3,3 V na bilo koju od 3,3 V pločica na I/O priključku ili B2B konektoru.

USB regulator napaja sabirnicu kroz idealnu diodu, pa vanjska napajanja od 3,3 V na Qwiic / GPIO / B2B strani mogu napajati ploču čak i dok je USB i dalje spojen, bez povratnog napajanja USB regulatora.

Savjet

Koristite procjenitelj trajanja baterije za modeliranje koliko će dugo AE3 raditi na bateriji za zadani omjer aktivnog rada / dubokog mirovanja.

Pinovi za oporavak i otklanjanje pogrešaka¶

RESET — povucite na GND za resetiranje ploče. Otpuštanje omogućuje SoC‑u da se normalno pokrene.

Postoji prekidač za oporavak na prednjoj (strani kamere) ploče, u donjem lijevom kutu. Kada je omogućen, prisiljava SE UART AE3 da izlazi preko USB‑a kako bi OpenMV IDE mogao ponovno programirati ugrađeni pokretač (bootloader). Isti način oporavka može se aktivirati i daljinski povlačenjem RECOVERY pina na B2B konektoru na nisku razinu.

AE3 podržava i SWD i potpuno JTAG otklanjanje pogrešaka:

1,8 V SWD priključak na bočnoj strani ploče namijenjen je za Tag-Connect ECV3-06-CTX kabel i izvodi četiri SWD signala (TCK / TMS / TDO / RSTN) plus GND.
B2B priključak na stražnjoj strani ploče izlaže iste pinove za otklanjanje pogrešaka (P10 = TCK, P11 = TDO, P13 = TMS, P14 = TDI) plus sistemski RSTN i zasebni JTAG RSTN. Ti se pinovi mogu koristiti bilo za SWD (TCK + TMS) bilo za potpuni JTAG; JTAG RSTN linija potrebna je samo u potpunom JTAG načinu.

Svi signali za otklanjanje pogrešaka referencirani su na 1,8 V — provjerite da je vaš adapter za otklanjanje pogrešaka konfiguriran za 1,8 V logiku prije spajanja.

Ugrađena periferija¶

LED‑ovi¶

AE3 ima jedan korisnički RGB LED, softverski upravljiv kroz machine.LED

from machine import LED

LED("LED_RED").on()
LED("LED_GREEN").on()
LED("LED_BLUE").on()

Korisnička tipka¶

AE3 ima jednu korisničku tipku (SW):

from machine import Pin

sw = Pin("SW", Pin.IN)
print(sw.value())

Da biste ploču doveli u duboko mirovanje i da je SW ponovno probudi, samo pozovite machine.deepsleep() — nije potrebna nikakva konfiguracija buđenja, tipka je izravno spojena na ulaz za buđenje:

import machine

machine.deepsleep()   # press SW to wake the board

SW možete spojiti i kao softverski prekidač napajanja. Okidajte na rastući brid — linija se ustaljuje na visokoj razini nakon što korisnik otpusti tipku, pa je sljedeći pritisak nedvosmisleno događaj buđenja:

import machine
from machine import Pin

def power_off(_):
    machine.deepsleep()

Pin("SW", Pin.IN).irq(power_off, Pin.IRQ_RISING)

# ...rest of the application runs here. Press SW once to sleep,
# press it again to wake.

Senzor kamere¶

PAG7936 se pokreće kroz modul csi — senzori kamere

import csi

cam = csi.CSI()
cam.reset()
cam.pixformat(csi.RGB565)
cam.framesize(csi.HD)         # 1280×800
cam.snapshot(time=2000)       # let auto‑exposure settle

while True:
    img = cam.snapshot()

PAG7936 podržava okidani način rada — integracija piksela poravnava se točno sa svakim pozivom csi.CSI.snapshot umjesto sa slobodno tekućim taktom sličica, što je korisno za sinkronizaciju snimanja s vanjskim događajem ili drugim senzorom. Omogućite ga kroz csi.CSI.ioctl s csi.IOCTL_SET_TRIGGERED_MODE. Broj sličica u sekundi pada na otprilike polovicu slobodno tekućeg načina jer se očitavanje više ne preklapa s integracijom sljedeće sličice:

cam.ioctl(csi.IOCTL_SET_TRIGGERED_MODE, True)

NPU¶

Dvije ugrađene NPU jedinice AE3 (400 MHz / 204 GOPS HP NPU + 160 MHz / 46 GOPS HE NPU) izložene su kroz modul ml — Strojno učenje. Modeli pohranjeni na datotečnom sustavu /rom namijenjenom samo za čitanje učitavaju se izravno iz flash memorije bez kopiranja u RAM, pa čak i veliki detektori udobno stanu uz živi međuspremnik slike. Pokrenite YOLOv8 detektor na svakoj sličici i nacrtajte predikcije povrh žive slike:

import csi
import time
import ml
from ml.postprocessing.ultralytics import YoloV8

# Initialize the sensor.
csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.VGA)

# Load YOLO V8 model from ROM FS.
model = ml.Model("/rom/yolov8n_192.tflite", postprocess=YoloV8(threshold=0.4))
print(model)

# Visualization parameters.
n = len(model.labels)
model_class_colors = [
    (int(255 * i // n), int(255 * (n - i - 1) // n), 255)
    for i in range(n)
]

clock = time.clock()
while True:
    clock.tick()
    img = csi0.snapshot()

    # boxes is a list of list per class of ((x, y, w, h), score) tuples
    boxes = model.predict([img])

    # Draw bounding boxes around the detected objects
    for i, class_detections in enumerate(boxes):
        rects = [r for r, score in class_detections]
        labels = [model.labels[i] for j in range(len(rects))]
        colors = [model_class_colors[i] for j in range(len(rects))]
        ml.utils.draw_predictions(img, rects, labels, colors, format=None)

    print(clock.fps(), "fps")

HE jezgra¶

AE3 pakira dvije Cortex‑M55 jezgre u jednom MCU‑u: visokoučinkovitu (HP) jezgru koja pokreće glavnu MicroPython instancu, kameru, HP NPU, USB i tako dalje; te energetski učinkovitu (HE) jezgru koja radi na znatno nižoj snazi i pokreće vlastitu malu MicroPython instancu. Obje jezgre dijele Open-AMP / RPMsg sabirnicu poruka, pa HP jezgra može slati Python funkcije HE jezgri, dobiti rezultate natrag i držati dvije polovice razdvojenima.

Najjednostavnija ulazna točka je dekorator @openamp.async_remote. On serijalizira Python funkciju, šalje je HE jezgri, a HE jezgra je pokreće kao asyncio zadatak. Nakon registracije zadataka, instancirajte openamp.RemoteProc s flash adresom HE firmvera i pozovite rproc.start() za pokretanje druge jezgre. Bez povratnog poziva, print() izlaz dekorirane funkcije prosljeđuje se preko zadane krajnje točke na stdout HP jezgre — zgodno za „hello world”:

import time
import openamp

@openamp.async_remote
async def task1(ept):
    import asyncio
    while True:
        print("Hello from the HE core!")
        await asyncio.sleep(1)

# Boot the HE core. This runs the registered tasks.
rproc = openamp.RemoteProc(0x80320000)
rproc.start()

while True:
    print("Hello from the HP core!")
    time.sleep(1)

Za dvosmjernu razmjenu poruka proslijedite povratni poziv dekoratoru. Povratni poziv izvršava se na HP jezgri kad god HE zadatak pozove ept.send()

import time
import openamp

def task_callback(src_addr, data):
    print("HP received:", data.decode())

@openamp.async_remote(task_callback)
async def task1(ept):
    import asyncio
    count = 0
    while True:
        ept.send(f"count = {count}")
        count += 1
        await asyncio.sleep(1)

rproc = openamp.RemoteProc(0x80320000)
rproc.start()

while True:
    time.sleep(1)

HE jezgra ima vlastitu HE NPU (160 MHz, 46 GOPS), pa može pokretati drugi ML model paralelno s onim čime je zauzeta HP NPU HP jezgre. Korisna podjela je staviti mali, uvijek aktivni model okidača / klasifikatora na HE stranu i pustiti HP jezgru da reagira samo kada se nešto zanimljivo označi — prepoznavanje ključnih riječi s ugrađenog mikrofona dobro pristaje jer je kontinuirano, niske propusnosti, a HE jezgra ostaje na znatno nižoj snazi od HP. Zamrznuti pomoćnik ml.apps.MicroSpeech prepoznaje „Yes” i „No” odmah po izlasku iz kutije — izgovorite riječi glasno i jasno u ugrađeni mikrofon za pokretanje detekcije:

import time
import openamp

def task_callback(src_addr, data):
    print("Heard:", data.decode())

@openamp.async_remote(task_callback)
async def task1(ept):
    from ml.apps import MicroSpeech
    speech = MicroSpeech(gain_db=24)
    while True:
        label, scores = speech.listen(timeout=0, threshold=0.70)
        if label:
            ept.send(label)

rproc = openamp.RemoteProc(0x80320000)
rproc.start()

while True:
    time.sleep(1)

Za bogatiju podjelu, pokrenite BlazeFace na HP NPU dok HE jezgra obrađuje prepoznavanje ključnih riječi u pozadini — HP petlja preklapa zadnju čutu ključnu riječ preko sličice kamere:

import csi
import time
import openamp
import ml
from ml.postprocessing.mediapipe import BlazeFace

label = None
label_ticks = 0
LABEL_HOLD_MS = 2000

def task_callback(src_addr, data):
    global label, label_ticks
    label = data.decode()
    label_ticks = time.ticks_ms()

@openamp.async_remote(task_callback)
async def task1(ept):
    from ml.apps import MicroSpeech
    speech = MicroSpeech(gain_db=24)
    while True:
        l, scores = speech.listen(timeout=0, threshold=0.70)
        if l:
            ept.send(l)

# Start the HE core before initializing the camera on the HP core.
rproc = openamp.RemoteProc(0x80320000)
rproc.start()

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.VGA)
csi0.window((400, 400))

model = ml.Model("/rom/blazeface_front_128.tflite",
                 postprocess=BlazeFace(threshold=0.4))

clock = time.clock()
while True:
    clock.tick()
    img = csi0.snapshot()
    for r, score, keypoints in model.predict([img]):
        ml.utils.draw_predictions(img, [r], ("face",),
                                  ((0, 0, 255),), format=None)
        ml.utils.draw_keypoints(img, keypoints, color=(255, 0, 0))
    if label is not None:
        if time.ticks_diff(time.ticks_ms(), label_ticks) < LABEL_HOLD_MS:
            img.draw_string((4, 4), f"Heard: {label}",
                            color=(255, 0, 0), scale=2)
        else:
            label = None
    print(clock.fps(), "fps")

HE jezgra je dobro prilagođena za uvijek aktivne ili niskostope radne zadatke za koje ne želite da se natječu s kamera/NPU cjevovodom na HP strani — malo ML zaključivanje, lagani DSP na podacima s mikrofona ili IMU‑a te slični pozadinski poslovi.

Nekoliko ograničenja koja treba imati na umu:

Pridržavajte se mikrofona i IMU‑a kada upravljate periferijom s HE jezgre — to je ono za što je HE strana dizajnirana. Svaku periferiju može posjedovati samo jedna jezgra u danom trenutku, pa odaberite HP ili HE za nju i toga se držite tijekom cijelog životnog vijeka skripte.
Tijelo svakog @openamp.async_remote zadatka mora se serijalizirati u manje od 500 bajtova mpy bytecode‑a — držite funkciju malom i izdvojite težu logiku u zasebne biblioteke modula koji se zamrzavaju u firmware.
Uvozi unutar otpremljene funkcije vide samo module koji postoje na datotečnom sustavu HE jezgre. HE jezgra ima vlastiti /rom ROMFS — odvojen od /rom HP jezgre — pa moduli i ML modeli koje želite imati dostupne na HE strani moraju biti ugrađeni u ROMFS sliku HE strane, a ne HP.

Mikrofon¶

Ugrađeni mikrofon snima se kroz audio — Audio modul. Svaki međuspremnik stiže kao predznačeni 16‑bitni PCM bytearray, što ga čini trivijalnim za predaju u ulab/numpy za brzi DSP. Jednostavan detektor glasnoće — ispiše svaki put kada RMS glasnoća prijeđe prag:

import audio
from ulab import numpy as np

def loudness(pcmbuf):
    samples = np.array(np.frombuffer(pcmbuf, dtype=np.int16), dtype=np.float)
    rms = np.sqrt(np.mean(samples ** 2))
    if rms > 10000:
        print("Loud!", int(rms))

audio.init(channels=1, frequency=16000, gain_db=24)
audio.start_streaming(loudness)

while True:
    pass

IMU¶

Ugrađeni LSM6DSM akcelerometar + žiroskop izložen je kroz imu — imu senzor

import imu
import time

while True:
    print(imu.acceleration_mg())   # (x, y, z) in milli‑g
    print(imu.angular_rate_mdps()) # (x, y, z) in milli‑deg/s
    time.sleep_ms(100)

Time‑of‑flight senzor¶

AE3 nosi VL53L8CX 8×8 višezonski time‑of‑flight senzor koji vraća do 64 očitanja udaljenosti po sličici, s maksimalnim dometom od ~4 m. Izložen je kroz modul tof — upravljački program za time-of-flight senzor — pozovite tof.init() za pokretanje senzora i tof.read_depth() za dohvaćanje dubinske sličice kao ravnog popisa očitanja u milimetrima (jedno po zoni):

import tof

tof.init()
while True:
    depth, depth_min, depth_max = tof.read_depth()
    print("min:", depth_min, "mm  max:", depth_max, "mm")

Dubinsko polje može se i nacrtati preko sličice u boji s glavnog senzora — tof.draw_depth() ga slika na postojeću image.Image, dok tof.snapshot() vraća svježe iscrtanu dubinsku sliku:

import image
import tof
import csi

# Bring up the VL53L8CX time-of-flight sensor.
tof.init()

# Configure the main camera at VGA RGB565.
cam = csi.CSI()
cam.reset()
cam.pixformat(csi.RGB565)
cam.framesize(csi.VGA)

# Off-screen framebuffer used to compose the camera frame and the
# up-scaled depth heat-map side by side before pushing the result
# back to the live preview.
b = image.Image(640, 480, image.RGB565)

while True:
    # Grab a colour frame from the main camera.
    img = cam.snapshot()

    try:
        # Capture TOF data [depth map, min distance, max distance].
        # vflip / hmirror align the ToF orientation with the camera.
        depth, dmin, dmax = tof.read_depth(vflip=True, hmirror=True)

        # Zones with no return read back as 0.0 — clamp them to the
        # frame's max distance so the colour palette doesn't show
        # them as "closest".
        for i in range(0, len(depth)):
            if depth[i] == 0.0:
                depth[i] = dmax

    except RuntimeError:
        # The sensor occasionally faults on a frame; reset and skip.
        tof.reset()
        continue

    # Draw the camera frame into the left half of the framebuffer,
    # scaled to 60% so it leaves room for the depth heat-map on
    # the right.
    b.draw_image(img, x=0, y=64+8, x_scale=0.6, hint=image.BILINEAR)

    # Up-sample the 8x8 depth array 30x with bicubic smoothing and
    # blend it into the right half using the depth palette.
    # scale=(0, 400) maps 0-400 mm to the full palette range.
    tof.draw_depth(b, depth, x=320+64+16, y=64+8, alpha=255,
                   hint=image.BICUBIC, x_scale=30, y_scale=30,
                   scale=(0, 400), color_palette=image.PALETTE_DEPTH)

    # Copy the composed framebuffer back into the live preview so
    # OpenMV IDE shows both panels.
    img.set(b)

Wi‑Fi¶

Ugrađeni CYW43439 izložen je putem network — konfiguracija mreže kao stanično sučelje. Nakon spajanja, ipconfig("addr4") vraća par (ip, netmask)

import network, time

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("ssid", "password")
while not wlan.isconnected():
    time.sleep(1)
print("Wi‑Fi IP:", wlan.ipconfig("addr4")[0])

Bluetooth¶

Isti CYW43439 također izlaže Bluetooth 5.1. Koristite aioble — Asinkroni BLE za asyncio‑prilagođeni BLE — na primjer, oglašavajte se kao periferija i čekajte da se središnji uređaj spoji:

import asyncio
import aioble

async def run():
    while True:
        conn = await aioble.advertise(250_000, name="OpenMV-AE3")
        print("Connected:", conn.device)
        await conn.disconnected()

asyncio.run(run())

Referenca sabirnica¶

GPIO¶

Koristite machine.Pin za čitanje ili upravljanje bilo kojim od pinova označenih sitotiskom. Izlazi su 3,3 V CMOS i mogu ponirati/davati do 25 mA po pinu.

from machine import Pin

out = Pin("P0", Pin.OUT)
out.on()
out.off()
out.value(1)

inp = Pin("P1", Pin.IN, Pin.PULL_UP)
print(inp.value())

Bilo koji ulazni pin može također pokrenuti prekid na promjenama brida:

def handler(pin):
    print("triggered:", pin)

Pin("P1", Pin.IN, Pin.PULL_UP).irq(
    handler, Pin.IRQ_FALLING | Pin.IRQ_RISING,
)

UART¶

Sabirnica	TX	RX	RTS	CTS
UART1	P4	P5	—	—
UART3	P9	P8	P7	P6
UART4	P0	P1	—	—
UART5	P2	P3	—	—

from machine import UART

uart = UART(1, baudrate=115200)
uart.write("hello")
uart.read(5)

UART3 je jedina sabirnica s hardverskom kontrolom toka. Budući da P6–P9 sjede na B2B priključku i referencirani su na 1,8 V, UART3 radi samo kroz pretvarač razine napona ili B2B nosivu ploču — ne spajajte 3,3 V logiku izravno na njega.

I²C¶

Sabirnica	SCL	SDA
I2C1	P4	P5
I2C2	P0	P1
LPI2C	P3	P2

from machine import I2C

i2c = I2C(1, freq=400_000)
i2c.scan()
i2c.writeto(0x76, b"hi")

Ugrađeni Qwiic konektor izvodi I2C2 na 3,3 V.

I2C1 i I2C2 mogu se koristiti i u ciljnom (slave) načinu kroz machine.I2CTarget kako bi se izložilo memorijsko područje drugom I²C kontroleru:

from machine import I2CTarget

buf = bytearray(32)
target = I2CTarget(1, addr=0x42, mem=buf)

Napomena

LPI2C periferija nije izložena u firmveru. Da je izložena, podržavala bi samo ciljni (slave) način, a I2C1 i I2C2 već pokrivaju i kontrolersku i ciljnu operaciju.

SPI¶

Sabirnica	MOSI	MISO	SCK	CS
SPI0	P0	P1	P2	P3

from machine import SPI
from machine import Pin

spi = SPI(0, baudrate=10_000_000)
cs = Pin("P3", Pin.OUT, value=1)   # CS is not driven by the SPI peripheral

cs.value(0)
spi.write(b"hello")
cs.value(1)

ADC¶

Alif Ensemble E3 izlaže dva 12‑bitna ADC kanala na P8 i P9 (samo B2B priključak). Oba ulaza referencirana su na 1,8 V — read_u16 vraća 0–65535 u rasponu 0–1,8 V na pinu:

from machine import ADC
import time

adc = ADC("P8")
while True:
    voltage = adc.read_u16() * 1.8 / 65535
    print(voltage)
    time.sleep_ms(100)

Upozorenje

ADC ulazi AE3 referencirani su na 1,8 V, a ne na 3,3 V. Dovođenje sirovog 3,3 V signala zasitit će pretvarač i može oštetiti pin — više napone podijelite vanjski.

PWM¶

Pin	Mjerač vremena / kanal
P0	TIM0 T1
P1	TIM0 T0
P2	TIM1 T1
P3	TIM1 T0
P4	TIM2 T1
P5	TIM2 T0
P6	TIM9 T0 (samo B2B)
P7	TIM9 T1 (samo B2B)
P8	TIM5 T0 (samo B2B)
P9	TIM5 T1 (samo B2B)

Upravljajte bilo kojim od njih putem machine.PWM

from machine import Pin, PWM

pwm = PWM(Pin("P0"), freq=1_000, duty_u16=32768)

Softverski bit‑bang sabirnice¶

machine.SoftI2C i machine.SoftSPI rade na bilo kojem GPIO‑u ako vam treba dodatna sabirnica.

Toplinski senzor (izvan ploče)¶

Firmware uključuje fir — upravljački program termalnog senzora (fir == daleko infracrveno) upravljački program za vanjski ožičeni AMG8833 8 × 8 toplinski snimač. Spojite modul na I²C sabirnicu navedenu u nastavku, zatim čitajte sličice s fir.init() + fir.snapshot()

import time
import image
import fir

fir.init()                          # auto‑detects the sensor
clock = time.clock()

while True:
    clock.tick()
    try:
        img = fir.snapshot(x_scale=5, y_scale=5,
                           color_palette=image.PALETTE_IRONBOW,
                           hint=image.BICUBIC,
                           copy_to_fb=True)
    except OSError:
        continue
    print(clock.fps())

fir upravljački program komunicira sa senzorom samo preko I²C 1 — ožičite modul na P4 (SCL) i P5 (SDA).

Mjerenje vremena¶

time¶

Modul time pokriva blokirajuća kašnjenja, monotone otkucaje i mjerenje proteklog vremena:

import time

time.sleep(1)              # seconds
time.sleep_ms(500)
time.sleep_us(10)

start = time.ticks_ms()
# ...do work...
elapsed = time.ticks_diff(time.ticks_ms(), start)

Virtualni mjerači vremena¶

machine.Timer zakazuje periodičke ili jednokratne povratne pozive bez zauzimanja utora hardverskog mjerača vremena. Proslijedite -1 kao id za korištenje virtualnog (softverskog) mjerača vremena:

from machine import Timer

one_shot = Timer(-1)
one_shot.init(period=5_000, mode=Timer.ONE_SHOT,
              callback=lambda t: print("once"))

periodic = Timer(-1)
periodic.init(period=2_000, mode=Timer.PERIODIC,
              callback=lambda t: print("tick"))

Vrijednosti perioda izražene su u milisekundama. Pozovite deinit() za zaustavljanje i oslobađanje utora.

Sat stvarnog vremena¶

machine.RTC čuva vrijeme na zidnom satu kroz resetiranja, podržan s 4 KB ugrađene sigurnosne RAM memorije koja preživljava duboko mirovanje:

from machine import RTC

rtc = RTC()
rtc.datetime((2026, 4, 30, 4, 12, 0, 0, 0))   # Y, M, D, weekday, h, m, s, subsec
print(rtc.datetime())

RTC također radi tijekom dubokog mirovanja, pa ga možete koristiti kao izvor buđenja za machine.deepsleep().

Informacije o pokretanju i izvođenju¶

Prozor USB pokretača (bootloader)¶

Pri svakom uključivanju kamera pokreće kratki pokretač (bootloader) (nekoliko sekundi) koji omogućuje OpenMV IDE‑u da ažurira firmware bez potrebe da korisnik uđe u DFU način. Nakon isteka prozora pokretač predaje kontrolu boot.py, a zatim main.py.

Skripta koja se izvodi može ponovno ući u pokretač (bootloader) na zahtjev pozivanjem machine.bootloader()

import machine

machine.bootloader()

Datotečni sustav i redoslijed pokretanja¶

Firmware AE3 montira do dva datotečna sustava pri pokretanju:

Unutarnja flash memorija — uvijek montirana na /flash. Po zadanom sadrži main.py i README.txt; stvara se pri samom prvom pokretanju.
ROMFS — datotečni sustav samo za čitanje, memorijski mapiran na /rom, koji se koristi za isporuku velikih podatkovnih sredstava (npr. AI modela) koja imaju koristi od pristupa bez kopiranja. MicroPython ga montira automatski pri pokretanju, prije nego što se pokrene bilo koji korisnički Python.

Nakon montiranja, radni direktorij postavlja se na /flash. Interpreter zatim izvodi skripte iz tog direktorija:

boot.py se izvršava pri svakom mekom resetiranju (hladno pokretanje, Ctrl‑D iz REPL‑a ili kad god se skripta koja se izvodi vrati).
main.py se izvršava samo pri hladnom pokretanju, neposredno nakon boot.py. Naknadna meka resetiranja ponovno pokreću boot.py, ali padaju izravno u REPL — za ponovno pokretanje main.py morate u potpunosti resetirati ploču.

Zadani main.py isporučen na svježe programiranoj ploči samo treperi plavim kanalom korisničkog RGB LED‑a kao otkucaj srca (dva kratka impulsa, kratka stanka), pa možete prepoznati da se firmware uredno pokrenuo bez ijednog spojenog domaćina.

sys.path je proširen tako da uključuje oba datotečna sustava i njihove lib/ poddirektorije, pa moduli koji se mogu uvesti mogu se nalaziti u /flash/lib ili /rom/lib.

Kada je spojen preko USB‑a, /flash se na domaćinu također prikazuje kao USB pogon za masovnu pohranu, što vam omogućuje izravno uređivanje boot.py, main.py i bilo kojih drugih datoteka. Izbacite pogon prije resetiranja kamere kako bi domaćin ispraznio svoje predmemorirane upise.

Napomena

Budući da OS tretira pogon kao pasivni blok uređaj, datoteke stvorene ili izmijenjene kodom koji se izvodi na OpenMV Cam neće se pojaviti dok domaćin ponovno ne montira pogon. Ako i OS i OpenMV Cam istovremeno pišu na isti datotečni sustav, OS će pobijediti i prepisati izmjene koje je napravila kamera.

Napomena

Crveni kanal korisničkog RGB LED‑a može se nakratko upaliti dok domaćin čita s USB pogona za masovnu pohranu ili na njega piše — to je pokazatelj aktivnosti vođen firmverom, a ne kvar.

Veličine pohrane¶

AE3 se isporučuje s:

/flash — 8 MB FAT datotečni sustav, čitanje/pisanje.
/rom na HP jezgri — 24 MB memorijski mapiran ROMFS samo za čitanje za skripte i podatke koje HP jezgra učitava pri pokretanju.
/rom na HE jezgri — 1 MB ROMFS samo za čitanje u vlasništvu HE jezgre. Moduli i ML modeli koje želite imati dostupne @openamp.async_remote zadacima moraju biti ugrađeni u ovu sliku, a ne HP.

Pokazatelj nepopravljive pogreške (hard fault)¶

Ako korisnički RGB LED brzo prolazi kroz sve boje — dovoljno brzo da obično izgleda kao trepćuća bijela LED umjesto kao zasebne nijanse — firmware je naišao na nepopravljivu nepopravljivu pogrešku (hard fault). Ponovno programirajte firmware za oporavak; ako ponovno programiranje ne pomogne, ploča je možda fizički oštećena.

Softverske biblioteke¶

Pogledajte indeks biblioteka za potpuni popis modula — uključujući one koji su jedinstveni za AE3 build.