OpenMV Cam RT1062

Az OpenMV Cam RT1062 egy alacsony fogyasztású gépi látás kártya, amely az NXP i.MX RT1062 köré épül (Cortex‑M7 @ 600 MHz). A kártya nagy sebességű USB‑C hálózatot, Wi‑Fi/Bluetooth-t és 10/100 Ethernetet párosít egy OV5640 5MP érzékelővel, amely cserélhető hordozón ül. A kamera mélyalvásban csak ~30 µA-t vesz fel egy LiPo akkumulátorról, ami kiválóan alkalmassá teszi akkumulátoros projektekhez.

A teljes adatlapért, fényképekért és méretekért lásd az OpenMV Cam RT1062 termékoldalt.

Kiemelt jellemzők

• NXP i.MX RT1062 Cortex‑M7 600 MHz-en.

• 32 MB külső SDRAM (16 bites @ 160 MHz, 320 MB/s), valamint 1 MB belső SRAM és 16 MB QSPI flash memória (133 MHz 4 bites SDR, 66 MB/s olvasás); 4 KB EEPROM az R6+ kártyákon.

• OV5640 5MP rolling‑shutter érzékelő.

• Beépített IMU (12 bites 3 tengelyes gyorsulásmérő, ±2/4/8 g).

• Nagy sebességű USB‑C (480 Mb/s, 1,5 A áramkorlát), 10/100 Mb/s Ethernet (PoE‑képes pajzson keresztül), Wi‑Fi a/b/g/n + Bluetooth 5.1 (chipantenna vagy U.FL opció).

• microSD foglalat — SD legfeljebb 2 GB, SDHC legfeljebb 32 GB, SDXC legfeljebb 2 TB.

• LiPo töltő (500 mA az R6+ kártyákon, 100 mA az R4/R5-ön), RTC tartalék akkumulátor csatlakozó pontokkal. A mélyalvás ~30 µA-t vesz fel akkumulátorról.

• 14 I/O láb, mind 3,3 V kimenet / 3,3 V toleráns, 4 mA lábanként, megszakítás-képes.

• Felhasználói RGB LED, felhasználói SW gomb, hardveres bekapcsoló gomb (mélyalvás / ébresztés állapotgép), valamint külön állapot-LED a töltéshez / USB-hez / VIN tápellátáshoz.

Figyelem

Az RT1062 I/O lábai nem 5 V toleránsak. Ne csatlakoztassa az eszközt közvetlenül egy 5 V-os MCU-hoz, mint az Arduino Mega. A kártyát csak a VIN-en keresztül táplálja.

Kiosztás

Láb referencia

Láb neve	Funkció
P0	SPI1 MOSI / PWM2 B3
P1	SPI1 MISO / CAN0 TX
P2	SPI1 SCLK / PWM2 B3
P3	SPI1 SS / CAN0 RX
P4	I2C1 SCL / UART1 TX / PWM1 X2
P5	I2C1 SDA / UART1 RX / PWM1 X3
P6	ADC
P7	PWM2 A0
P8	PWM2 B0
P9	PWM1 A3
P10	PWM1 B3 / képkocka-szinkron I/O
P11	ébresztés (aktív alacsony, kösse GND-re az ébresztéshez)
P12	RESET — húzza GND-re a kártya újraindításához (nem GPIO)
P13	digitális I/O
P14	digitális I/O
ON/OFF	fejléc pad, amely a hardveres bekapcsoló gombot replikálja (aktív alacsony)
SW	felhasználói gomb (aktív alacsony)
ST	alacsony VIN tápellátáson, magas USB tápellátáson
CHG	aktív alacsony; alacsony, amíg egy csatlakoztatott LiPo akkumulátor töltődik
PG	aktív alacsony; alacsony, amikor VIN vagy USB tápellátás van jelen
LED_RED	RGB LED piros csatorna (aktív alacsony)
LED_GREEN	RGB LED zöld csatorna (aktív alacsony)
LED_BLUE	RGB LED kék csatorna (aktív alacsony)

Megjegyzés

A P10 képkocka-szinkron vonal egy megosztott busz. Egyszerre csatlakozik az MCU-hoz, a kamera érzékelőjének trigger / expozíció lábához és a felhasználói fejléchez. Az irány alkalmazás-függő — az MCU, az érzékelő vagy egy külső jel is meghajthatja attól függően, hogyan van az érzékelő konfigurálva. Ügyeljen arra, hogy egyszerre csak egy meghajtó legyen aktív.

Megjegyzés

Az ON/OFF és a P11 a mindig bekapcsolt RAW sínhez van viszonyítva (nem a kapcsolt 3,3 V-os sínhez), így működőképesek maradnak, miközben a kártya többi része mélyalvásban / alacsony fogyasztású módban van. Mindkét bemenet aktív alacsony.

Ezek a lábak szintillesztőkön mennek keresztül, hogy a RAW sínen tudjanak ülni. Ha mindenképpen 3,3 V-direkt GPIO viselkedésre van szüksége az ON/OFF vagy a P11 esetében (például hogy egy 3,3 V-os MCU-ról hajtsa meg őket az illesztő megkerülésével), a kártya felhúzó és 0 ohmos jumper padokat tesz elérhetővé, amelyek lehetővé teszik az illesztő megkerülését. Ez egy haladó hardveres átalakítás — a legtöbb felhasználónak érintetlenül kell hagynia.

Megjegyzés

A P13 és P14 alapértelmezetten egyszerű GPIO különleges funkció nélkül. A padok opcionálisan más jelekre is átirányíthatók a kártya hátoldalán lévő 0 ohmos ellenállás-forrasztóhidak újrafolyatásával:

• P13 ↔ CHG állapot / JTAG TRSTB

• P14 ↔ ST állapot / JTAG TDI

A legtöbb felhasználó nem fog hozzányúlni ezekhez a jumperekhez — hagyja őket a GPIO alapértelmezésen, kivéve, ha kifejezetten energiagazdálkodási visszaolvasásra vagy JTAG-ra van szüksége.

Táp lábak

• 3.3V — szabályozott 3,3 V-os sín. Az RT1062-n csak kimenet — ne tápláljon külső tápot ebbe a lábba. Legfeljebb 1 A áll rendelkezésre a pajzsok számára.

• VIN — 5 V bemenet. Táplálja a kártyát és a beépített LiPo töltőt.

• RAW — bemenet/kimenet, mindig bekapcsolt (3,6 V – 5 V). Azt a forrást viszi, amelyik éppen aktív (VIN, USB vagy csatlakoztatott akkumulátor), és bemenetként is használható. A RAW-ot soros diódán keresztül kell meghajtania, amikor tápot táplál bele — különben az áram visszafolyik a VIN/USB-be, és károsítja a tápot vagy a beépített védelmet.

• GND — közös föld.

Megjegyzés

A beépített energiagazdálkodási chip automatikusan kiválasztja az USB vagy VIN közül azt, amelyiknek magasabb a feszültsége, hogy táplálja a kártyát és az akkumulátortöltőt. Ha LiPo van csatlakoztatva, az a fennmaradó tartalékon töltődik, és a vezérlő visszavált az akkumulátorra, hogy a kártya tovább működjön, ha a VIN/USB lecsökken vagy kihúzzák.

Megjegyzés

A kártya hátoldalán forrasztó padok vannak egy külső 3,3 V-os RTC tartalék akkumulátorhoz. Egy gombelem ezekre a padokra kötése életben tartja az RTC-t, miközben a kártya többi része táplálatlan.

Javaslat

Használja az akkumulátor-élettartam becslőt annak modellezésére, hogy mennyi ideig fog futni az RT1062 egy akkumulátorról adott aktív / mélyalvási kitöltési tényező mellett.

Ethernet lábak

Az RT1062 a 10/100 Mb/s Ethernet PHY MDI párjait dedikált padokon teszi elérhetővé a GPIO fejléc mellett. Az MDI lábakat nem biztonságos közvetlenül egy RJ45-höz kötni — Ethernet mágnesesség (egy szigetelő transzformátor, vagy magjack-be építve, vagy a pajzson) szükséges a PHY és a kábel között. Az OpenMV PoE pajzs tartalmazza ezeket; ha saját csatlakozót készít, használjon mágnesesség-integrált RJ45-öt vagy külső transzformátort.

• ETH_LED — kapcsolat/aktivitás LED. Aktív alacsony, amikor a kapcsolat fennáll; villog forgalom esetén.

• ETH_TXP / ETH_TXN — adópár.

• ETH_RXP / ETH_RXN — vevőpár.

Megjegyzés

A fejléc négy padot is elérhetővé tesz, amelyek Reserved felirattal vannak ellátva. Ezek lábnyom-kompatibilisek az OpenMV N6 gigabites Ethernet párjaival (DC P/N és DD P/N), így ugyanaz az Ethernet / PoE pajzs bármelyik kártyába bedugható. Az RT1062 PHY-ja csak 10/100 Mb/s-ot tud, így ennek a négy padnak nincs elektromos összeköttetése — hagyja őket csatlakoztatlanul.

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

• RESET — húzza GND-re a kártya újraindításához. Elengedve az MCU normálisan indul el.

• SBL — húzza 3,3 V-ra a kártya tápellátása közben, hogy ROM rendszerbetöltő (Serial Boot Loader) módba lépjen. Az OpenMV IDE ezt a módot használja a beépített rendszerbetöltő újraflashelésére.

Egy dedikált ARM 10 tűs SWD/JTAG fejléc van felszerelve, amely kompatibilis a ST‑LINK és SEGGER J‑Link adapterekkel.

Megjegyzés

Az RT1062 alapértelmezetten csak SWD hibakeresést tesz elérhetővé ezen a csatlakozón keresztül. A teljes JTAG nem érhető el alapból.

Beépített perifériák

LED-ek

Az RT1062 két RGB LED-del rendelkezik:

• Felhasználói RGB LED — szoftveresen vezérelhető, LED_RED, LED_GREEN és LED_BLUE néven elérhető:

  from machine import LED
  
  LED("LED_RED").on()
  LED("LED_GREEN").on()
  LED("LED_BLUE").on()
  

• Táp LED — közvetlenül a beépített energiagazdálkodási hardver hajtja meg, nincs szoftveres vezérlés. Használja arra, hogy egy pillantással leolvassa, mit csinál a tápellátás.

  Futás közben:

  Csatorna	Jelentés
  Kék	a VIN táplálja a kártyát (USB-n ki)
  Zöld	USB vagy VIN tápellátás jelen van
  Piros	egy csatlakoztatott LiPo akkumulátor töltése

  Mélyalvásban minden csatorna ki van kapcsolva, kivéve a Pirosat, amely még mindig világít, amíg egy LiPo töltődik.

Gombok

Az RT1062 két gombbal rendelkezik:

• SW — általános célú felhasználói gomb. Kódból normál aktív alacsony GPIO bemenetként olvasható:

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

• Bekapcsoló gomb — egy dedikált energiavezérlő állapotgép hajtja meg az RT1062 kártyán, teljesen hardveresen. Nincs kitéve a felhasználói kódnak; a vezérlő dönti el, mit tegyen attól függően, mennyi ideig tartják lenyomva:

  • Tartsa ~5 másodpercig miközben a kártya fut → az állapotgép mélyalvásba vált.

  • Tartsa ~1 másodpercig miközben a kártya mélyalvásban van → az állapotgép visszakapcsolja a rendszert.

  Az ON/OFF fejléc pad alacsonyra húzása ugyanazzal a hatással jár, mint a beépített bekapcsoló gomb megnyomása — hasznos egy külső kapcsoló bekötéséhez vagy a vonal meghajtásához egy másik mikrokontrollerről.

Tápállapot lábak

Három aktív alacsony állapotbemenet a beépített energiagazdálkodási chiptől:

• PG — alacsony, amikor VIN vagy USB tápellátás van jelen. Mindig csatlakoztatva.

• ST — alacsony, amikor a kártya VIN-en fut, magas, amikor USB tápellátáson fut. Alapértelmezetten nincs csatlakoztatva.

• CHG — alacsony, amíg egy csatlakoztatott LiPo akkumulátor töltődik. Alapértelmezetten nincs csatlakoztatva.

from machine import Pin

power_ok = not Pin("PG", Pin.IN).value()

Kamera érzékelő

Az OV5640-et a csi — kameraérzékelők modulon keresztül lehet meghajtani:

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

Az OV5640 beépített JPEG tömörítővel rendelkezik. Állítsa be a csi.CSI.pixformat-ot csi.JPEG-re, és az érzékelő tömörített képkockákat ad át közvetlenül a kamerának a kamerabuszon keresztül, ami praktikussá teszi a nagy felbontású felvételeket: csi.HD (1280×720), csi.FHD (1920×1080) és a teljes 5MP-es csi.WQXGA2 (2592×1944) mind JPEG-ként streamel. Hangolja a tömörítést a csi.CSI.quality-val (0-100, magasabb = nagyobb képkockák, több részlet):

cam.pixformat(csi.JPEG)
cam.framesize(csi.WQXGA2)
cam.quality(90)

Az érzékelő egy cserélhető modulon ül — cserélje ki bármelyik másik OpenMV kameramodulra (global shutter, hőkamera, magasabb felbontás stb.) anélkül, hogy a kártya többi részét megváltoztatná.

Gépi tanulás

A ml — Gépi tanulás kvantált TFLite modelleket futtat a Cortex‑M7-en CMSIS‑NN kernelekkel — elég gyorsan ahhoz, hogy kompakt detektorokat néhány képkocka/másodperc sebességgel futtasson. A csak olvasható /rom fájlrendszeren lévő modellek közvetlenül a flash memóriából töltődnek be, RAM-ba másolás nélkül. Íme egy 128×128-as BlazeFace detektor, amely minden képkockára rávetíti az észlelt arcot és annak hat jellegzetes pontját:

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

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

# Load built-in face detection model
model = ml.Model("/rom/blazeface_front_128.tflite", postprocess=BlazeFace(threshold=0.4))
print(model)

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

    # faces is a list of ((x, y, w, h), score, keypoints) tuples
    for r, score, keypoints in model.predict([img]):
        ml.utils.draw_predictions(img, [r], ("face",), ((0, 0, 255),), format=None)

        # keypoints is a ndarray of shape (6, 2)
        # 0 - right eye (x, y)
        # 1 - left eye (x, y)
        # 2 - nose (x, y)
        # 3 - mouth (x, y)
        # 4 - right ear (x, y)
        # 5 - left ear (x, y)
        ml.utils.draw_keypoints(img, keypoints, color=(255, 0, 0))

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

IMU

Az RT1062 firmware nem köti össze a beépített gyorsulásmérőt az imu — imu érzékelő modullal. Ehelyett közvetlenül a belső I²C buszon kommunikáljon vele — a chip a 0x15 címen található, és három előjeles 12 bites gyorsulási csatornát plusz egy 8 bites hőmérséklet bájtot tárol a 0x03 regisztertől kezdve:

import machine
import time

ADDR     = 0x15
DATA_REG = 0x03
LSB_PER_G = 1024.0    # ±2 g range

def s12(hi, lo):
    v = ((hi << 8) | lo) >> 4
    return v - 0x1000 if v & 0x800 else v

bus = machine.I2C(2)
print("Devices on I²C2:", bus.scan())

while True:
    d = bus.readfrom_mem(ADDR, DATA_REG, 7)
    x = s12(d[0], d[1]) / LSB_PER_G
    y = s12(d[2], d[3]) / LSB_PER_G
    z = s12(d[4], d[5]) / LSB_PER_G
    temp_c = d[6] * 0.586 + 25.0
    print("x=%+.2fg  y=%+.2fg  z=%+.2fg  T=%.1f°C" % (x, y, z, temp_c))
    time.sleep_ms(100)

EEPROM

Az R6 és későbbi kártyák egy általános 4 KB-os I²C EEPROM-ot tartalmaznak ugyanazon a belső buszon, mint a gyorsulásmérő. (A korábbi változatokon nincs ilyen — ezen kódrészletek hívása R4/R5-ön időtúllépést okoz egy hiányzó I²C ack miatt.) Használja a szabványos machine.I2C readfrom_mem / writeto_mem API-t egy 16 bites memóriacímmel:

import machine
import time

EEPROM_ADDR = 0x50            # default address
PAGE_SIZE   = 32              # bytes per page (both read and write)
EEPROM_SIZE = 4096

bus = machine.I2C(2)

# Dump the entire 4 KB one page at a time
data = bytearray()
for offset in range(0, EEPROM_SIZE, PAGE_SIZE):
    data += bus.readfrom_mem(EEPROM_ADDR, offset, PAGE_SIZE, addrsize=16)
print(len(data), "bytes")

# Write a small payload back at offset 0 (fits in one page)
bus.writeto_mem(EEPROM_ADDR, 0, b"hello, world", addrsize=16)
time.sleep_ms(10)             # ~5 ms write cycle after each page

# Read it back
print(bus.readfrom_mem(EEPROM_ADDR, 0, 12, addrsize=16))

Mind az olvasásoknak, mind az írásoknak egy 32 bájtos oldalon belül kell maradniuk. Bontsa fel a nagyobb átviteleket oldalanként egy-egy hívásra, és adjon hozzá ~5 ms írásciklus-késleltetést az egymást követő írások között.

Wi‑Fi

A beépített CYW43-családú modul a network — hálózati konfiguráció-en keresztül érhető el állomás interfészként. Csatlakozás után az ipconfig("addr4") visszaadja az (ip, netmask) párt:

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 vezeték nélküli modul Bluetooth 5.1-et is elérhetővé tesz. Használja az aioble — Aszinkron BLE-t az asyncio-barát BLE-hez — például hirdessen perifériaként, és várjon, amíg egy központi csatlakozik:

import asyncio
import aioble

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

asyncio.run(run())

Ethernet

Amikor egy RJ45 (mágnesességgel) csatlakozik az MDI padokhoz, a 10/100 PHY LAN interfészként jelenik meg. A DHCP automatikusan fut, amint a kapcsolat felépül:

import network, time

lan = network.LAN()
lan.active(True)
while not lan.isconnected():
    time.sleep(1)
print("Ethernet IP:", lan.ipconfig("addr4")[0])

microSD kártya

Amikor egy kártyát behelyeznek, az automatikusan a /sdcard helyre csatolódik, és a szokásos fájlrendszeren keresztül használható:

import os

for entry in os.listdir("/sdcard"):
    print(entry)

Busz referencia

GPIO

Használja a machine.Pin-t bármelyik feliratozott láb olvasásához vagy meghajtásához. A kimenetek 3,3 V CMOS-ok, és lábanként legfeljebb 4 mA-t tudnak nyelni/forrásolni.

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

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

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

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

UART

Busz	TX	RX
UART1	P4	P5

from machine import UART

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

I²C

Busz	SCL	SDA
I2C1	P4	P5

from machine import I2C

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

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

from machine import I2CTarget

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

SPI

Busz	MOSI	MISO	SCK	CS
SPI1	P0	P1	P2	P3

from machine import SPI
from machine import Pin

spi = SPI(1, 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)

CAN

Busz	TX	RX
CAN1	P1	P3

Megjegyzés

A CAN-t a v5.0.0 firmware még nem támogatja ezen a kártyán.

from machine import CAN

can = CAN(1, 500_000)
can.set_filters(None)
can.send(0x123, b"\xDE\xAD\xBE\xEF")
print(can.recv())

ADC

Az egyetlen felhasználói ADC láb a P6, amely ~3,3 V-on teljes skálájú:

from machine import ADC
import time

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

PWM

Láb	FlexPWM csatorna
P0	PWM2 B3
P2	PWM2 B3
P4	PWM1 X2
P5	PWM1 X3
P7	PWM2 A0
P8	PWM2 B0
P9	PWM1 A3
P10	PWM1 B3

Hajtsa meg bármelyiket a machine.PWM-en keresztül:

from machine import Pin, PWM

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

Szoftveresen bit-bangelt buszok

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

Hőkamera érzékelő (kártyán kívüli)

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

• MLX90621 — 16 × 4 IR tömb

• MLX90640 — 32 × 24 IR tömb

• MLX90641 — 16 × 12 IR tömb

• AMG8833 — 8 × 8 IR tömb

Kösse a modult a kártya I²C buszára, és olvassa a 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 4-en keresztül kommunikál az érzékelővel — kösse a modult a P4 (SCL) és P5 (SDA) lábakra.

Időzítés

time

A time modul lefedi a blokkoló késleltetéseket, a monoton tickeket és az eltelt idő mérését:

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 anélkül, hogy egy hardveres időzítő helyét foglalná. Adjon át -1-et id-ként 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 milliszekundumban vannak megadva. Hívja meg a deinit()-et a leállításhoz és a hely felszabadításához.

Valós idejű óra

A machine.RTC megtartja a valós időt az újraindításokon át, és (a hátsó padokra kötött opcionális 3,3 V-os tartalék akkumulátorral, lásd Táp lábak) a teljes áramkimaradáson át is:

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

Az RTC mélyalváson keresztül is fut, így ébresztési forrásként használhatja a machine.deepsleep()-hez.

Watchdog

A machine.WDT újraindítja a kártyát, ha az alkalmazás lefagy. Egyszer elindítva nem állítható le és nem konfigurálható újra — táplálja periodikusan a fő ciklusán 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

USB rendszerbetöltő ablak

Minden bekapcsoláskor a kamera egy rövid rendszerbetöltőt futtat (néhány másodperc), amely lehetővé teszi az OpenMV IDE számára a firmware frissítését anélkül, hogy a felhasználónak DFU módba kellene lépnie. Az ablak lejárta után a rendszerbetöltő átadja a vezérlést a boot.py-nak, majd a main.py-nak.

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

import machine

machine.bootloader()

Fájlrendszer és indítási sorrend

Az RT1062 firmware indításkor legfeljebb három fájlrendszert csatol:

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

• microSD kártya — ha egy kártyát behelyeznek, az a /sdcard helyre csatolódik.

• ROMFS — csak olvasható, memóriába leképezett fájlrendszer a /rom helyen, amelyet nagy adat-eszközök (pl. AI modellek) szállítására használnak, amelyek profitálnak a másolásmentes hozzáférésből. A MicroPython automatikusan csatolja indításkor, mielőtt bármilyen felhasználói Python futna.

A csatolás után a munkakönyvtár a /sdcard-ra van állítva, amikor a kártya jelen van, egyébként a /flash-re. Az értelmező ezután abból a könyvtárból futtatja a szkripteket:

• A boot.py minden szoft reset alkalmával végrehajtódik (hidegindítás, Ctrl‑D a REPL-ből, vagy amikor a futó szkript visszatér).

• A main.py csak hidegindításkor hajtódik végre, közvetlenül a boot.py után. A későbbi szoft resetek újra lefuttatják a boot.py-t, de egyenesen a REPL-be esnek — a main.py újrafuttatásához teljesen újra kell indítani a kártyát.

Ha egy boot.py-t vagy main.py-t helyez az SD kártyára, az felülírja a flash memóriában lévő példányt anélkül, hogy hozzányúlna — mindkét fájlt az indítási könyvtárban keresi a rendszer (/sdcard, amikor a kártya csatolva van, egyébként /flash).

Egy frissen flashelt kártyán szállított alapértelmezett main.py egyszerűen villogtatja a felhasználói RGB LED kék csatornáját szívritmusként (két rövid impulzus, rövid szünet), így megállapíthatja, hogy a firmware tisztán elindult, anélkül, hogy bármilyen gazdagép csatlakozna.

A sys.path ki van bővítve mindhárom fájlrendszerrel és azok lib/ alkönyvtáraival, így az importálható modulok a /flash/lib, /sdcard/lib vagy /rom/lib helyen lehetnek.

Ahhoz, hogy a rendszert egy behelyezett SD kártya figyelmen kívül hagyására kényszerítse (például a flash main.py futtatásához akkor is, ha kártya van jelen), hozzon létre egy SKIPSD nevű üres fájlt a /flash gyökerében.

USB-n keresztül csatlakoztatva az indítási fájlrendszer (/sdcard, ha kártya van jelen, egyébként /flash) USB háttértár-meghajtóként is megjelenik a gazdagépen, lehetővé téve a boot.py, main.py és bármely más fájl közvetlen szerkesztését. Adja ki a meghajtót a kamera újraindítása előtt, hogy a gazdagép kiürítse a gyorsítótárazott írásait.

Megjegyzés

Mivel az operációs rendszer a meghajtót passzív blokkeszközként kezeli, az OpenMV Cam-en futó kód által létrehozott vagy módosított fájlok addig nem jelennek meg, amíg a gazdagép újra nem csatolja a meghajtót. Ha az operációs rendszer és az OpenMV Cam egyszerre írja ugyanazt a fájlrendszert, az operációs rendszer nyer, és felülírja a kamera által végzett változtatásokat. Használja az SD kártyát bármely olyan adathoz, amelyet a szkript visszaír, és csatolja újra, mielőtt ezeket a fájlokat a gazdagépről olvasná.

Megjegyzés

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

Tárolási méretek

Az RT1062 a következőkkel szállít:

• /flash — 4 MB FAT fájlrendszer, olvasás/írás.

• /rom — 8 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 másolásmentes mmap hozzáférésből.

• /sdcard — a behelyezett microSD kártya teljes mérete (ha jelen van), olvasás/írás.

Hard-fault jelző

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

Szoftverkönyvtárak

A modulok teljes listájáért lásd a könyvtárindexet — beleértve azokat is, amelyek egyediek az RT1062 buildhez.