Arduino Nicla Vision

Az Arduino Nicla Vision egy 22,86 × 22,86 mm-es gépi látás kártya, amelyet a STMicroelectronics STM32H747AII6 köré építettek — ez egy kétmagos SoC, amely egy 400 MHz-es Cortex‑M7-et és egy 200 MHz-es Cortex‑M4-et egyesít. Az OpenMV firmware teljes egészében az M7 magon fut. A kártya a mikrovezérlőt egy GC2145 2 MP-es színes CMOS érzékelővel, egy LSM6DSOX 6 tengelyes IMU-val, egy MP34DT06 MEMS mikrofonnal, egy VL53L1CB repülési idő alapú távolságmérővel, Wi‑Fi + Bluetooth LE 5.1 modullal, valamint egy akkumulátortöltővel / töltöttségmérővel párosítja.

Arduino Nicla Vision

A teljes adatlapért, fényképekért és méretekért lásd az Arduino Nicla Vision termékoldalt.

Kiemelt jellemzők

  • STMicroelectronics STM32H747AII6 kettős Cortex‑M7 (400 MHz) + Cortex‑M4 (200 MHz). Az OpenMV firmware kizárólag az M7 magon fut.

  • 2 MB belső flash memória, valamint 16 MB külső QSPI flash memória (az alkalmazás + ROMFS számára).

  • 1 MB belső SRAM.

  • Hardveres JPEG kódoló/dekódoló.

  • GC2145 2 MP-es színes CMOS érzékelő.

  • Beépített IMU (LSM6DSOX gyorsulásmérő + giroszkóp), MEMS mikrofon (MP34DT06JTR) és VL53L1CB repülési idő alapú távolságmérő (akár ~4 m-ig).

  • Wi‑Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 a Murata 1DX (CYW4343W) modulon keresztül — a mellékelt antennához egy beépített U.FL csatlakozóval kapcsolódik.

  • Nagy sebességű USB (480 Mb/s) a Micro USB-n keresztül, egy külső ULPI PHY-n (USB3320C) át.

  • 13 felhasználói I/O láb az Arduino szélső csatlakozósorokon — négy digitális LPIO (D0–D3), három 1,8 V-os analóg bemenet (A0–A2), az SCL/SDA I²C pár, valamint az SCLK/CIPO/COPI/CS SPI négyes.

  • Akkumulátortámogatás — Li‑Po csatlakozó a hátoldalon, BQ-stílusú töltő és MAX17262 töltöttségmérő a belső PMIC buszon keresztül.

  • 5 lábú ESLOV csatlakozó a hátoldalon a forrasztásmentes I²C bővítéshez.

Figyelem

A felhasználói digitális lábak alapértelmezetten 3,3 V-osak, de szoftveresen programozható szintillesztőkön (VDDIO_EXT) keresztül vannak vezetve, amelyek 1,8 V-ra is átkonfigurálhatók. Az analóg lábak (A0–A2) csak 1,8 V-osak — ezek megkerülik a szintillesztőket, és közvetlenül a mikrovezérlőhöz kapcsolódnak. Ha 3,3 V-ot vezetsz az A0–A2 lábakra, az károsítja a SoC-t.

Lábkiosztás

Arduino Nicla Vision lábkiosztás

Lábkiosztási referencia

Tizenhárom felhasználói láb érhető el az Arduino szélső csatlakozósorokon (J1 és J2). További hibakeresési, helyreállítási és PMIC jelek a kártya hátoldalán lévő tesztpontokra vannak vezetve.

Láb neve

Referencia

Funkció

D0

3,3 V

GPIO / LPIO0 (J1‑1)

D1

3,3 V

LPUART1 TX / TIM1 CH2 / LPIO1 (J2‑3)

D2

3,3 V

LPUART1 RX / TIM1 CH3 / LPIO2 (J2‑4)

D3

3,3 V

GPIO / LPIO3 (J2‑5)

A0

1,8 V

ADC1 4. csatorna (J1‑8)

A1

1,8 V

ADC2 2. csatorna (J1‑7)

A2

1,8 V

ADC3 5. csatorna (J1‑2)

SCL

3,3 V

I2C1 SCL / UART4 RX / TIM4 CH3 (J2‑2)

SDA

3,3 V

I2C1 SDA / UART4 TX / TIM4 CH4 (J2‑1)

SCLK

3,3 V

SPI4 SCK / TIM1 CH3N (J1‑6)

CIPO

3,3 V

SPI4 MISO / TIM1 CH3 (J1‑5)

COPI

3,3 V

SPI4 MOSI / TIM1 CH4 (J1‑4)

CS

3,3 V

SPI4 NSS / TIM1 CH2 (J1‑3)

RESET

3,3 V

húzd a GND-re (vagy nyomd meg a beépített kapcsolót) a kártya újraindításához

LED_RED

3,3 V

RGB LED piros csatornája (aktív alacsony)

LED_GREEN

3,3 V

RGB LED zöld csatornája (aktív alacsony)

LED_BLUE

3,3 V

RGB LED kék csatornája (aktív alacsony)

Megjegyzés

A D0–D3 és az SCLK/CIPO/COPI/CS a TXB0108 kétirányú szintillesztő mögött helyezkedik el — ez az alkatrész csak a push‑pull GPIO meghajtást támogatja, így a nyitott kollektoros (open‑drain) buszforgalom (pl. egy bitenként vezérelt 1‑Wire vagy I²C ezeken a lábakon) nem fog működni.

Az SCL/SDA egy külön NTS0304 szintillesztő mögött helyezkedik el, amely a push‑pull és az open‑drain meghajtást is támogatja, ezért működik ott az I²C 1.

Mindkét szintillesztő referenciája a VDDIO_EXT (alapértelmezetten 3,3 V a beépített PMIC-ből), és meghajtási erősségük egy közvetlen GPIO-hoz képest korlátozott — jelszintű, nem pedig teljesítményterhelésre tervezték őket.

Tápfeszültség lábak

Szélső csatlakozósor lábai:

  • VIN (J2‑9) — fő 3,6 – 5 V-os rendszer-tápsín. A PMIC innen kapja a bemenetét.

  • VDDIO_EXT (J2‑7) — a szintillesztő tápsín kimenete, 1,8 V vagy 3,3 V (alapértelmezetten 3,3 V). Ezzel táplálhatod az LPIO/SPI/I²C lábakra csatlakoztatott külső 1,8 V-os vagy 3,3 V-os perifériákat, hogy azonos logikai szinten kommunikáljanak a csatlakozósorokkal.

  • VBAT (J3‑2) — Li‑Po akkumulátor bemenet. A beépített PMIC a VIN-ről tölti a cellát, és a töltöttségi állapotot a töltöttségmérőn keresztül jelzi.

  • NTC (J3‑1) — opcionális Li‑Po termisztor bemenet.

  • GND (J2‑6) — közös föld.

  • NC (J2‑8) — nincs csatlakoztatva.

Tesztpontok a kártya hátoldalán:

  • +3V3 — fő 3,3 V-os tápsín.

  • D_P / D_N — USB nagy sebességű adatpár (a PHY után).

Az USB és az ESLOV csatlakozó egyaránt egy pár LM66100 ideális diódán (forrásonként egy) keresztül táplálja a VIN-t, így bármelyik tápforrás önállóan is meg tudja táplálni a kártyát, és a kettő soha nem hajtja vissza egymást. Ha kívülről hajtod meg a VIN-t a J2‑9-en, az élvez elsőbbséget — a diódák egyszerűen leállnak az USB / ESLOV felől, amint a külső tápsín magasabbra emelkedik.

A kártya tehát az alábbi útvonalak bármelyikén keresztül táplálható:

  • Micro USB — 5 V a VIN-be az USB-oldali ideális diódán keresztül.

  • ESLOV csatlakozó — akár 5 V a J5 VESLOV lábán, az ESLOV-oldali ideális diódán keresztül a VIN-be vezetve (lásd ESLOV csatlakozó).

  • VIN láb (J2‑9) — közvetlenül egy szabályozott 3,6 – 5 V-os tápfeszültséggel hajtsd meg.

  • Li‑Po akkumulátor — csatlakoztasd a hátoldalon lévő J4 akkumulátorcsatlakozóhoz vagy a J3 / J2‑6 VBAT/GND/NTC pontjaihoz. Ne csatlakoztass egyszerre két akkumulátort.

ESLOV csatlakozó

A J5 a kártya hátoldalán egy 5 lábú Molex forrasztásmentes ESLOV csatlakozó:

Láb

Név

Funkció

J5‑1

VESLOV

tápbemenet (≤ 5 V) — egy LM66100 ideális diódán keresztül a VIN-be összevezetve (OR)

J5‑2

INT

külső megszakítás bemenet a PD9 lábon

J5‑3

SCL_EXT

megosztva a J2 SCL ponttal — ugyanaz az I²C 1 busz, mint a felhasználói csatlakozósoron

J5‑4

SDA_EXT

megosztva a J2 SDA ponttal — ugyanaz az I²C 1 busz, mint a felhasználói csatlakozósoron

J5‑5

GND

közös föld

Az ESLOV SCL_EXT/SDA_EXT és a J2 SCL/SDA lábai ugyanazok — egyetlen I²C 1 busz, amely két csatlakozón van kivezetve.

Javaslat

Használd a akkumulátor-élettartam becslőt annak modellezéséhez, hogy a Nicla Vision egy adott aktív / mélyalvás kitöltési tényező mellett mennyi ideig fut akkumulátorról.

Helyreállítási és hibakeresési lábak

  • RESET — egyszerre egy nyomógomb a kártya tetején és egy pont (J3‑4 / P5 tesztpont), amely a SoC NRST vonalához van kötve. Húzd a GND-re az újraindításhoz.

A Nicla Vision az Arduino szabványos dupla koppintásos újraindítását használja az Arduino rendszerbetöltőjébe való belépéshez — nyomd meg gyorsan kétszer az újraindító gombot, és a kártya DFU eszközként jelentkezik be. Az OpenMV IDE ezt a módot használja a firmware újraflashelésére.

Az STM32 SWD jelei a kártya hátoldalán, a két J2 csatlakozósor között lévő tesztpont-soron keresztül érhetők el. Forrassz beléjük egy 2,54 mm-es (100 mil) csatlakozósort egy ST‑LINK vagy J‑Link adapter csatlakoztatásához:

  • P1 / P2 — belső PMIC I²C busz a PF0 (SDA) és PF1 (SCL) lábakon. Ez a machine.I2C(2) a Nicla Vision-ön, és a PMIC, a töltöttségmérő, valamint a ToF forgalmát viszi.

  • P3 — TMS / SWDIO (PA13)

  • P4 — TCK / SWCLK (PA14)

  • P5 — NRST

  • P6 — TDO / SWO (PB3)

  • P7 — +1V8 tápsín (a SoC I/O tápellátása — egyben a megfelelő referencia a hibakereső adapter számára is).

  • P8 — VOTP_PMIC — csak gyári programozáshoz. Csatlakoztatás nélkül kell hagyni.

Minden hibakeresési jel 1,8 V-os referenciájú — az STM32H747 I/O gyűrűje ezen a kártyán a +1V8 tápsínről működik. Csatlakoztatás előtt állítsd a hibakereső adaptert 1,8 V-os logikára.

Beépített perifériák

LED-ek

A Nicla Vision egyetlen felhasználói RGB LED-del rendelkezik, amely szoftveresen vezérelhető a machine.LED segítségével:

from machine import LED

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

A kártya oldalán lévő külön DL2 CHARGE LED közvetlenül a PMIC CHGB kimenetére van kötve — akkor világít, amikor egy Li‑Po akkumulátor töltődik az USB / ESLOV / VIN forrásról, és nem vezérelhető a felhasználó által.

Kamera érzékelő

A GC2145-öt a csi — kameraérzékelők modulon keresztül vezéreljük:

import csi

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

while True:
    img = cam.snapshot()

Amikor kis képkockaméretet kérsz, a GC2145 illesztőprogram egy arányosan kis kiolvasási ablakot vág ki az érzékelőből — alapértelmezetten a kiolvasásról a kimenetre történő leskálázás aránya 3-szorosra van korlátozva a képkockasebesség fenntartása érdekében. A csi.IOCTL_SET_FOV_WIDE ezt a korlátot 5-szörösre emeli, ami azt jelenti, hogy az illesztőprogram az érzékelő szélesebb területéről olvas ki, amikor kis felbontásokat közvetít. Az eredmény egy észrevehetően szélesebb látómező a kis képkockaméreteknél, némi átviteli teljesítmény árán:

cam.ioctl(csi.IOCTL_SET_FOV_WIDE, True)
cam.ioctl(csi.IOCTL_GET_FOV_WIDE)  # returns the current setting

M4 mag

A Cortex‑M4 mag az openamp modulon keresztül érhető el processzorok közötti kommunikációhoz. Az OpenMV firmware csak az M7-en fut; az M4-nek nincs saját MicroPython futtatókörnyezete, így a használata azt jelenti, hogy egy különálló C firmware-képet kell építeni, és azt a fájlrendszerből kell betölteni az openamp.RemoteProc segítségével. Egy előre elkészített példa firmware, amely egy virtuális UART végpontot valósít meg, elérhető az openamp_vuart tárolóban — kövesd a README-jét a vuart.elf felépítéséhez:

import openamp
import time

def ept_recv_callback(src_addr, data):
    print("Received:", data.decode())

ept = openamp.Endpoint("vuart-channel", callback=ept_recv_callback)

rproc = openamp.RemoteProc("vuart.elf")
rproc.start()

count = 0
while True:
    if ept.is_ready():
        ept.send("Hello World %d!" % count, timeout=1000)
        count += 1
    time.sleep_ms(1000)

A gyakorlatban ezt a támogatást leginkább az openamp interfész demonstrációjaként érdemes kezelni, nem pedig egy működő kétmagos platformként — az M4 nem indítható újra az M7-től függetlenül, így az M4 leállítása a teljes rendszer újraindítását kényszeríti ki.

Mikrofon

A beépített MP34DT06JTR PDM mikrofon a audio — Audio modul modulon keresztül, az STM32 DFSDM perifériáján át rögzíthető. Minden puffer előjeles 16 bites PCM bytearray formában érkezik, készen arra, hogy DSP céljából a ulab/numpy modulba táplálják — például egy egyszerű hangerő-érzékelő:

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

A beépített LSM6DSOX gyorsulásmérő + giroszkóp az imu — imu érzékelő modulon keresztül érhető el:

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)

Az IMU egy dedikált belső SPI buszra (SPI5) van kötve, így nem ütközik a csatlakozósorokra kivezetett felhasználói SPI4-gyel.

Repülési idő alapú távolságmérő

A beépített ST VL53L1CB repülési idő alapú távolságmérő a belső PMIC I²C buszon (I²C 2) helyezkedik el. Használd a befagyasztott vl53l1x — VL53L1X ToF távolságérzékelő illesztőprogram illesztőprogramot akár ~4 m-ig terjedő távolságmérésekhez:

import time
from machine import I2C
import vl53l1x

bus = I2C(2)               # internal bus (PMIC / fuel gauge / ToF)
tof = vl53l1x.VL53L1X(bus)

while True:
    print("Distance:", tof.read(), "mm")
    time.sleep_ms(100)

Akkumulátor töltöttségmérő

A Maxim MAX17262 ModelGauge m5 töltöttségmérő a Li‑Po akkumulátor feszültségét, áramát, hőmérsékletét és töltöttségi állapotát követi nyomon. Az I²C 2-n helyezkedik el a 0x36 címen.

A MAX17262 belső árammérővel rendelkezik, így az áramregiszter közvetlenül mikroamperben olvasható ki, külső Rsense tényező alkalmazása nélkül. A töltöttségmérő olvasása ártalmatlan — nincs hozzá szállított illesztőprogram, de a MAX17262 adatlapban dokumentált regiszterek közvetlenül kiolvashatók:

import time
import struct
from machine import I2C

FUEL_GAUGE = 0x36   # MAX17262

def read_reg(bus, addr, reg):
    return struct.unpack("<H", bus.readfrom_mem(addr, reg, 2))[0]

def read_signed(bus, addr, reg):
    v = read_reg(bus, addr, reg)
    return v - 0x10000 if v & 0x8000 else v

bus = I2C(2)

while True:
    # 0x05 RepCap — remaining capacity, raw × 0.5 mAh
    rep_cap   = read_reg(bus, FUEL_GAUGE, 0x05) * 0.5
    # 0x06 RepSOC — state of charge, raw / 256 %
    soc       = read_reg(bus, FUEL_GAUGE, 0x06) / 256
    # 0x08 Temp — die temperature, signed, raw / 256 °C
    temp      = read_signed(bus, FUEL_GAUGE, 0x08) / 256
    # 0x09 VCell — battery voltage, raw × 78.125 µV
    vcell     = read_reg(bus, FUEL_GAUGE, 0x09) * 78.125 / 1_000_000
    # 0x0A Current — signed, raw × 156.25 µA
    current   = read_signed(bus, FUEL_GAUGE, 0x0A) * 156.25 / 1000
    # 0x0B AvgCurrent — averaged current
    avg_curr  = read_signed(bus, FUEL_GAUGE, 0x0B) * 156.25 / 1000
    # 0x10 FullCapRep — learned full capacity, raw × 0.5 mAh
    full_cap  = read_reg(bus, FUEL_GAUGE, 0x10) * 0.5
    # 0x11 TTE — time-to-empty (valid while discharging), raw × 5.625 s
    tte_s     = read_reg(bus, FUEL_GAUGE, 0x11) * 5.625
    # 0x20 TTF — time-to-full   (valid while charging),  raw × 5.625 s
    ttf_s     = read_reg(bus, FUEL_GAUGE, 0x20) * 5.625
    # 0x17 Cycles — charge-cycle counter, 1% per LSB
    cycles    = read_reg(bus, FUEL_GAUGE, 0x17) / 100

    print("V:        %.3f V" % vcell)
    print("Capacity: %.1f / %.1f mAh (%.1f %%)" % (rep_cap, full_cap, soc))
    print("Temp:     %.1f C" % temp)
    print("Current:  %.1f mA  (avg %.1f mA)" % (current, avg_curr))
    print("TTE:      %.0f s   TTF: %.0f s" % (tte_s, ttf_s))
    print("Cycles:   %.2f" % cycles)
    print()
    time.sleep_ms(1000)

A Current előjeles kettes komplemens: pozitív töltés közben, negatív kisütés közben. A TTE csak akkor értelmes, ha az áram negatív; a TTF csak akkor, ha az áram pozitív.

Energiagazdálkodási IC

Az NXP MC34PF1550A0EP PMIC kezeli a Nicla Vision összes szabályozóját — a +3V3 fő tápsínt, a +1V8 SoC mag / I/O tápsínt, a VDDIO_EXT-et a szintillesztőkhöz, valamint a Li‑Po töltőt. Az I²C 2-n helyezkedik el a 0x08 címen.

Figyelem

A PMIC regiszterek olvasása rendben van; az írásuk veszélyes. Egy buck szabályozó vagy töltőbeállítás hibás konfigurálása maradandóan károsíthatja a kártyát, az akkumulátort, vagy mindkettőt. Kezeld a PMIC-et csak olvashatóként, hacsak nem tudod pontosan, mit csinálsz.

A leghasznosabb dolog, amit a PMIC elárul, és amit a töltöttségmérő nem tud, az a töltő állapotgépe — hogy a kártya éppen USB / ESLOV / VIN forrásról fut-e, a Li‑Po a töltési ciklus mely szakaszában van, és hogy a töltő termikus vagy watchdog hibában van-e. A töltő regiszterei a PF1550 fő I²C címterében a 0x80 eltolásnál helyezkednek el (lásd a PF1550 adatlap 22.2. fejezetét), így például a 0x04 töltőcímen lévő CHG_INT_OK a 0x84 PMIC regiszterből olvasható ki:

import time
from machine import I2C

PMIC = 0x08

# Charger state machine (low nibble of CHG_SNS, register 0x87)
CHG_STATES = {
    0x0: "precharge",
    0x1: "fast charge (constant current)",
    0x2: "fast charge (constant voltage)",
    0x3: "end of charge",
    0x4: "done",
    0x6: "timer fault",
    0x7: "thermistor suspend",
    0x8: "off — input invalid or charger disabled",
    0x9: "battery overvoltage",
    0xA: "thermal shutdown",
    0xC: "linear mode (not charging)",
}

bus = I2C(2)

while True:
    # 0x84 CHG_INT_OK — single-bit indicators
    ok = bus.readfrom_mem(PMIC, 0x84, 1)[0]
    vbus_ok = bool(ok & (1 << 5))   # bit 5 — VBUS valid (USB/ESLOV/VIN)
    bat_ok  = bool(ok & (1 << 2))   # bit 2 — battery OK
    chg_ok  = bool(ok & (1 << 3))   # bit 3 — charger actively charging
    thm_ok  = bool(ok & (1 << 7))   # bit 7 — thermistor in normal range

    # 0x87 CHG_SNS — charger state + thermal regulation flag
    chg_sns = bus.readfrom_mem(PMIC, 0x87, 1)[0]
    state   = CHG_STATES.get(chg_sns & 0x0F, "reserved")
    treg    = bool(chg_sns & (1 << 7))   # thermal regulation active

    print("VBUS valid:         ", vbus_ok)
    print("battery OK:         ", bat_ok)
    print("charger active:     ", chg_ok)
    print("thermistor normal:  ", thm_ok)
    print("thermal reg active: ", treg)
    print("state:              ", state)
    print()
    time.sleep_ms(1000)

Más, az adatlapban megtekintésre érdemes, csak olvasható regiszterek (mind a 0x80 töltő-eltolásnál): 0x80 CHG_INT (rögzített töltő-megszakítások — hibajelzők), 0x86 VBUS_SNS (a több bites VBUS állapot, beleértve az OVLO / UVLO / DPM értékeket), valamint 0x88 BATT_SNS (akkumulátor jelenléte és túláram állapota).

Wi‑Fi

A beépített Murata 1DX (CYW4343W) a network — hálózati konfiguráció modulon keresztül érhető el állomás (station) interfészként. Csatlakoztasd a mellékelt antennát a beépített U.FL csatlakozóhoz, mielőtt elindítanád a rádiót:

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

Ugyanaz a Murata 1DX Bluetooth LE 5.1-et is biztosít. Használd az aioble — Aszinkron BLE modult az asyncio-barát BLE-hez — például hirdesd magad perifériaként, és várd, hogy egy központi egység csatlakozzon:

import asyncio
import aioble

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

asyncio.run(run())

Busz referencia

GPIO

Használd a machine.Pin osztályt bármelyik feliratozott láb olvasásához vagy meghajtásához. A kimenetek 3,3 V-os CMOS szintűek (alapértelmezetten VDDIO_EXT), és a szintillesztők a lábankénti meghajtási erősséget néhány milliamperre korlátozzák — jelszintű, nem pedig teljesítményterhelésre tervezték őket.

from machine import Pin

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

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

Bármelyik bemeneti láb megszakítást is kiválthat él-átmeneteknél:

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

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

UART

Busz

TX

RX

UART4

SDA

SCL

 
from machine import UART

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

Megjegyzés

Az UART4 megosztja a lábait az I²C 1-gyel — ugyanazok az SDA/SCL pontok viszik mindkét buszt. Ezeken a lábakon UART-ot vagy I²C-t válassz, nem mindkettőt.

A D1/D2 felirat UART_TX/UART_RX-et is jelez, de ebben a firmware-ben ezek a lábak az LPUART1-hez vannak vezetve, nem a machine.UART-hoz. Maga a machine.UART(1) a chipen lévő Bluetooth vezérlő számára van fenntartva, és nem érhető el a csatlakozósorokon.

I²C

Busz

SCL

SDA

I2C1

SCL

SDA

 
from machine import I2C

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

A J2 SCL/SDA pontjai és az ESLOV csatlakozó SCL_EXT/SDA_EXT lábai ugyanarra az I²C 1 buszra kapcsolódnak — lásd a fenti ESLOV csatlakozó részt az ESLOV lábkiosztásáért.

Ugyanaz a hardver cél (slave) módban is használható a machine.I2CTarget segítségével, hogy egy memóriaterületet egy másik I²C vezérlő számára elérhetővé tegyen:

from machine import I2CTarget

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

SPI

Busz

MOSI

MISO

SCK

CS

SPI4

COPI

CIPO

SCLK

CS

 
from machine import SPI
from machine import Pin

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

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

ADC

A Nicla Vision három 12 bites ADC csatornát vezet ki az A0, A1 és A2 lábakon. Mindhárom 1,8 V-os referenciájú — a read_u16 0–65535 értéket ad vissza a lábon mért 0–1,8 V tartományban:

from machine import ADC
import time

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

Figyelem

A Nicla Vision ADC bemenetei 1,8 V-os referenciájúak (és nincs szintillesztő a SoC előtt). Egy 3,3 V-os jel rávezetése telíti a konvertert, és károsíthatja a lábat — a magasabb feszültségeket kívülről oszd le.

PWM

Láb

Időzítő / csatorna

D1

TIM1 CH2

D2

TIM1 CH3

SCL

TIM4 CH3, TIM16 CH1

SDA

TIM4 CH4, TIM17 CH1

SCLK

TIM1 CH3N

CIPO

TIM1 CH3

COPI

TIM1 CH4

CS

TIM1 CH2

Bármelyiket meghajthatod a machine.PWM segítségével:

from machine import Pin, PWM

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

Megjegyzés

Több láb osztozik a TIM1 csatornáin:

  • A TIM1 CH2 a D1 és a CS lábon van.

  • A TIM1 CH3 a D2 és a CIPO lábon van; az SCLK ugyanannak a csatornának az invertált komplementerét (TIM1 CH3N) adja ki.

  • A TIM1 CH4 kizárólag a COPI lábon van.

Időzítő-csatornánként egy fogyasztót válassz. Az SPI négyes lábai (SCLK/CIPO/COPI/CS) szintén nem hajthatók meg PWM-mel, amíg a machine.SPI(4) használja őket.

Szoftveresen, bitenként vezérelt buszok

A machine.SoftI2C és a machine.SoftSPI bármelyik GPIO-n működik, ha egy extra buszra van szükséged.

Hőkamera érzékelő (külső)

A firmware tartalmazza a fir — hőérzékelő-meghajtó (fir == far infrared, távoli infravörös) illesztőprogramot a kívülről bekötött hőkamerákhoz:

  • MLX90621 — 16 × 4 IR mátrix

  • MLX90640 — 32 × 24 IR mátrix

  • MLX90641 — 16 × 12 IR mátrix

  • AMG8833 — 8 × 8 IR mátrix

Kösd a modult a kártya I²C buszára, és olvass be képkockákat a fir.init() + fir.snapshot() segítségével:

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())

A fir illesztőprogram csak az I²C 1-en kommunikál az érzékelővel — kösd a modult a feliratozott SCL / SDA pontokhoz.

Időzítés

time

A time modul a blokkoló késleltetéseket, a monoton ütemjeleket és az eltelt idő mérését fedi le:

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)

Virtuális időzítők

A machine.Timer periodikus vagy egyszeri visszahívásokat ütemez egy hardveres időzítő-hely lefoglalása nélkül. Add meg az id-ként a -1 értéket egy virtuális (szoftveres) időzítő használatához:

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"))

A periódusértékek ezredmásodpercben vannak megadva. Hívd meg a deinit() metódust a leállításhoz és a hely felszabadításához.

Valós idejű óra

A machine.RTC az újraindítások között is megtartja a faliórai időt:

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())

Watchdog

A machine.WDT újraindítja a kártyát, ha az alkalmazás lefagy. Az elindítása után nem állítható le és nem konfigurálható át — etesd rendszeresen a fő ciklusodon belül:

from machine import WDT

wdt = WDT(timeout=5_000)   # 5 second window
while True:
    # ...do work...
    wdt.feed()

Indítási és futásidejű információk

Firmware frissítés (DFU)

A Nicla Vision az Arduino szabványos dupla koppintásos újraindítását használja az Arduino rendszerbetöltőjébe való belépéshez. Nyomd meg gyorsan kétszer az újraindító gombot — a kártya DFU eszközként jelentkezik be újra az USB-n, és az OpenMV IDE új firmware-képet flashelhet.

Egy futó szkript igény szerint újra beléphet a rendszerbetöltőbe a machine.bootloader() meghívásával:

import machine

machine.bootloader()

Fájlrendszer és indítási sorrend

A Nicla Vision firmware indításkor legfeljebb két fájlrendszert csatol fel:

  • Belső flash memória — mindig a /flash alá csatolva. Alapértelmezetten a main.py és a README.txt fájlokat tartalmazza; a legelső indításkor jön létre.

  • ROMFS — csak olvasható, memóriába leképezett fájlrendszer a /rom alatt, amelyet a MicroPython indításkor automatikusan felcsatol.

A felcsatolás után a munkakönyvtár a /flash lesz. Az értelmező ezután ebből a könyvtárból futtatja a szkripteket:

  • A boot.py minden szoft újraindításkor lefut (hidegindítás, Ctrl‑D a REPL-ből, vagy amikor a futó szkript visszatér).

  • A main.py csak hidegindításkor fut le, közvetlenül a boot.py után. A további szoft újraindítások újra lefuttatják a boot.py-t, de egyből a REPL-re ugranak — a main.py újrafuttatásához teljesen újra kell indítanod a kártyát.

A frissen flashelt kártyán szállított alapértelmezett main.py csak villogtatja a felhasználói RGB LED kék csatornáját szívverésként (két rövid felvillanás, rövid szünet), így anélkül is megállapíthatod, hogy a firmware tisztán elindult, hogy bármilyen hosztot csatlakoztatnál.

A sys.path ki van bővítve mindkét fájlrendszerrel és azok lib/ alkönyvtáraival, így az importálható modulok a /flash/lib vagy a /rom/lib alatt helyezkedhetnek el.

USB-n keresztül csatlakoztatva a /flash USB háttértárolóként is megjelenik a hoszton, lehetővé téve, hogy közvetlenül szerkeszd a boot.py, main.py és bármely más fájlt. A kamera újraindítása előtt dobd le a meghajtót, hogy a hoszt kiírja a gyorsítótárazott írásokat.

Megjegyzés

Mivel az operációs rendszer passzív blokk-eszközként kezeli a meghajtót, a kamerán futó kód által létrehozott vagy módosított fájlok addig nem jelennek meg, amíg a hoszt újra fel nem csatolja a meghajtót. Ha az operációs rendszer és a kamera egyszerre írja ugyanazt a fájlrendszert, az operációs rendszer győz, és felülírja a kamera által végzett módosításokat. A szkript által visszaírt adatokhoz használd az SD kártyát, és csatold újra, mielőtt ezeket a fájlokat a hosztról olvasnád.

Megjegyzés

A felhasználói RGB LED piros csatornája röviden felvillanhat, miközben a hoszt az USB háttértároló meghajtóról olvas vagy arra ír — ez egy firmware által vezérelt aktivitásjelző, nem hiba.

Tárolóméretek

A Nicla Vision a következőkkel kerül szállításra:

  • /flash — 11 MB FAT fájlrendszer, írható/olvasható.

  • /rom — 4 MB csak olvasható, memóriába leképezett ROMFS, amelyet olyan szkriptek és ML modellek szállítására használnak, amelyek profitálnak a zéró-másolatú mmap hozzáférésből.

Hard fault jelző

Ha a felhasználói RGB LED gyorsan végigciklázik az összes színen — elég gyorsan ahhoz, hogy inkább villódzó fehér LED-nek tűnjön, mint különálló árnyalatoknak —, akkor a firmware egy helyrehozhatatlan hard faultba ütközött. A helyreállításhoz flasheld újra a firmware-t; ha az újraflashelés nem segít, lehet, hogy a kártya fizikailag károsodott.

Szoftverkönyvtárak

A modulok teljes listájáért lásd a könyvtárindexet — beleértve azt is, mely modulok egyediek a Nicla Vision build-ben.