OpenMV Cam RT1062

OpenMV Cam RT1062 to energooszczędna płytka wizji maszynowej zbudowana wokół układu NXP i.MX RT1062 (Cortex‑M7 @ 600 MHz). Płytka łączy sieć wysokiej prędkości przez USB‑C, Wi‑Fi/Bluetooth oraz Ethernet 10/100 z sensorem OV5640 5MP na wymiennym nośniku. W trybie głębokiego uśpienia kamera pobiera z akumulatora LiPo zaledwie ~30 µA, co sprawia, że doskonale nadaje się do projektów zasilanych bateryjnie.

OpenMV Cam RT1062

Pełną kartę katalogową, zdjęcia i wymiary znajdziesz na stronie produktu OpenMV Cam RT1062.

Najważniejsze cechy

  • NXP i.MX RT1062 Cortex‑M7 taktowany 600 MHz.

  • 32 MB zewnętrznej pamięci SDRAM (16‑bit @ 160 MHz, 320 MB/s) oraz 1 MB wewnętrznej pamięci SRAM i 16 MB pamięci flash QSPI (133 MHz 4‑bit SDR, odczyt 66 MB/s); 4 KB EEPROM na R6+.

  • Sensor OV5640 5MP z migawką typu rolling‑shutter.

  • Wbudowany IMU (12‑bitowy 3‑osiowy akcelerometr, ±2/4/8 g).

  • Wysokiej prędkości USB‑C (480 Mb/s, limit prądu 1,5 A), Ethernet 10/100 Mb/s (z obsługą PoE przez shield), Wi‑Fi a/b/g/n + Bluetooth 5.1 (antena typu chip lub opcjonalne U.FL).

  • Gniazdo microSD — SD do 2 GB, SDHC do 32 GB, SDXC do 2 TB.

  • Ładowarka LiPo (500 mA na R6+, 100 mA na R4/R5), RTC z polami pod baterię podtrzymującą. W głębokim uśpieniu pobór z akumulatora wynosi ~30 µA.

  • 14 pinów I/O, wszystkie z wyjściem 3,3 V / tolerancją 3,3 V, 4 mA na pin, z obsługą przerwań.

  • Użytkowa dioda RGB LED, przycisk użytkownika SW, sprzętowy przycisk zasilania (maszyna stanów głębokie uśpienie / wybudzenie) oraz osobna dioda statusu dla ładowania / USB / zasilania VIN.

Ostrzeżenie

Piny I/O układu RT1062 nie tolerują napięcia 5 V. Nie podłączaj urządzenia bezpośrednio do mikrokontrolera 5 V, takiego jak Arduino Mega. Zasilaj płytkę wyłącznie przez VIN.

Rozkład wyprowadzeń

Rozkład wyprowadzeń OpenMV Cam RT1062 OV5640

Opis wyprowadzeń

Nazwa pinu

Funkcja

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 / I/O synchronizacji ramki

P11

wybudzenie (aktywne stanem niskim, połącz z GND, aby wybudzić)

P12

RESET — zewrzyj do GND, aby zresetować płytkę (nie jest to GPIO)

P13

cyfrowe I/O

P14

cyfrowe I/O

ON/OFF

pole złącza powielające sprzętowy przycisk zasilania (aktywne stanem niskim)

SW

przycisk użytkownika (aktywny stanem niskim)

ST

niski przy zasilaniu z VIN, wysoki przy zasilaniu z USB

CHG

aktywny stanem niskim; niski podczas ładowania podłączonego akumulatora LiPo

PG

aktywny stanem niskim; niski, gdy obecne jest zasilanie VIN lub USB

LED_RED

czerwony kanał diody RGB LED (aktywny stanem niskim)

LED_GREEN

zielony kanał diody RGB LED (aktywny stanem niskim)

LED_BLUE

niebieski kanał diody RGB LED (aktywny stanem niskim)

Informacja

Linia synchronizacji ramki P10 to wspólna magistrala. Jest jednocześnie połączona z MCU, pinem wyzwalacza / ekspozycji sensora kamery oraz złączem użytkownika. Kierunek jest definiowany przez aplikację — w zależności od konfiguracji sensora linią może sterować MCU, sensor lub sygnał zewnętrzny. Upewnij się, że w danym momencie aktywny jest tylko jeden sterownik.

Informacja

ON/OFF i P11 są odniesione do zawsze aktywnej szyny RAW (a nie przełączanej szyny 3,3 V), dzięki czemu pozostają funkcjonalne, gdy reszta płytki znajduje się w trybie głębokiego uśpienia / niskiego poboru mocy. Oba wejścia są aktywne stanem niskim.

Piny te przechodzą przez konwertery poziomów, aby mogły działać na szynie RAW. Jeśli koniecznie potrzebujesz bezpośredniego zachowania GPIO 3,3 V na ON/OFF lub P11 (na przykład aby sterować nimi z mikrokontrolera 3,3 V bez przechodzenia przez konwerter), płytka udostępnia pola pod rezystory podciągające i zwory 0 omów, które pozwalają ominąć konwerter. Jest to zaawansowana przeróbka sprzętowa — większość użytkowników powinna jej nie wykonywać.

Informacja

P13 i P14 są domyślnie zwykłymi GPIO bez specjalnej funkcji. Pola te można opcjonalnie przekierować na inne sygnały, przelutowując mostki rezystorów 0 omów na tylnej stronie płytki:

  • P13 ↔ status CHG / JTAG TRSTB

  • P14 ↔ status ST / JTAG TDI

Większość użytkowników nie będzie ruszać tych zwór — pozostaw je w domyślnym ustawieniu GPIO, chyba że konkretnie potrzebujesz odczytu zarządzania zasilaniem lub JTAG.

Piny zasilania

  • 3.3V — regulowana szyna 3,3 V. Na RT1062 jest to tylko wyjście — nie podawaj na ten pin zewnętrznego zasilania. Dla shieldów dostępne jest do 1 A.

  • VIN — wejście 5 V. Zasila płytkę oraz wbudowaną ładowarkę LiPo.

  • RAW — wejście/wyjście, zawsze aktywne (3,6 V – 5 V). Przenosi aktywne w danym momencie źródło (VIN, USB lub podłączony akumulator) i może być również używane jako wejście. Podając zasilanie na RAW, musisz sterować nim przez diodę szeregową — w przeciwnym razie prąd popłynie z powrotem do VIN/USB i uszkodzi zasilacz lub wbudowane zabezpieczenie.

  • GND — masa wspólna.

Informacja

Wbudowany układ zarządzania zasilaniem automatycznie wybiera do zasilania płytki i ładowarki akumulatora to ze źródeł USB lub VIN, które ma wyższe napięcie. Jeśli podłączony jest akumulator LiPo, ładuje się on z pozostałego zapasu, a kontroler przełącza się na akumulator, aby utrzymać działanie płytki, gdy napięcie VIN/USB spadnie lub zostaną odłączone.

Informacja

Tylna strona płytki ma pola lutownicze pod zewnętrzną baterię podtrzymującą RTC 3,3 V. Podłączenie ogniwa pastylkowego do tych pól utrzymuje działanie RTC, gdy reszta płytki nie jest zasilana.

Wskazówka

Użyj estymatora żywotności baterii, aby oszacować, jak długo RT1062 będzie działać na baterii przy danym cyklu pracy aktywnej / głębokiego uśpienia.

Piny Ethernet

RT1062 udostępnia pary MDI układu PHY Ethernet 10/100 Mb/s na dedykowanych polach obok złącza GPIO. Pinów MDI nie można bezpiecznie podłączyć bezpośrednio do RJ45 — między PHY a kablem wymagane są elementy magnetyczne Ethernet (transformator izolujący, wbudowany w magjack lub umieszczony na shieldzie). Shield OpenMV PoE je zawiera; jeśli budujesz własne gniazdo, użyj RJ45 ze zintegrowanymi elementami magnetycznymi lub zewnętrznego transformatora.

  • ETH_LED — dioda link/aktywność. Aktywna stanem niskim, gdy łącze jest aktywne; miga podczas ruchu.

  • ETH_TXP / ETH_TXN — para nadawcza.

  • ETH_RXP / ETH_RXN — para odbiorcza.

Informacja

Złącze udostępnia również cztery pola opisane na nadruku jako Reserved. Są one zgodne pod względem footprintu z parami Ethernet gigabitowego na OpenMV N6 (DC P/N i DD P/N), dzięki czemu ten sam shield Ethernet / PoE można podłączyć do każdej z płytek. Układ PHY RT1062 obsługuje tylko 10/100 Mb/s, więc te cztery pola nie mają połączenia elektrycznego — pozostaw je niepodłączone.

Piny odzyskiwania i debugowania

  • RESET — zewrzyj do GND, aby zresetować płytkę. Zwolnienie pozwala MCU uruchomić się normalnie.

  • SBL — podciągnij do 3,3 V podczas zasilania płytki, aby wejść w tryb bootloadera ROM (Serial Boot Loader). OpenMV IDE używa tego trybu do ponownego wgrania wbudowanego bootloadera.

Zamontowane jest dedykowane złącze ARM 10‑pin SWD/JTAG, kompatybilne z adapterami ST‑LINK i SEGGER J‑Link.

Informacja

RT1062 domyślnie udostępnia przez to złącze tylko debugowanie SWD. Pełny JTAG nie jest dostępny od razu po wyjęciu z pudełka.

Wbudowane urządzenia peryferyjne

Diody LED

RT1062 ma dwie diody RGB LED:

  • Użytkowa dioda RGB LED — sterowalna programowo, udostępniona jako LED_RED, LED_GREEN i LED_BLUE

    from machine import LED

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

  • Dioda zasilania — sterowana bezpośrednio przez wbudowany sprzęt zarządzania zasilaniem, bez kontroli programowej. Użyj jej, aby na pierwszy rzut oka odczytać, co robi zasilanie.

    Podczas działania:

    Kanał

    Znaczenie

    Niebieski

    VIN zasila płytkę (wyłączony przy USB)

    Zielony

    obecne zasilanie USB lub VIN

    Czerwony

    ładowanie podłączonego akumulatora LiPo

    W głębokim uśpieniu wszystkie kanały są wyłączone z wyjątkiem czerwonego, który nadal świeci podczas ładowania akumulatora LiPo.

Przyciski

RT1062 ma dwa przyciski:

  • SW — uniwersalny przycisk użytkownika. Można go odczytać z kodu jako zwykłe wejście GPIO aktywne stanem niskim:

    from machine import Pin

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

  • Przycisk zasilania — sterowany przez dedykowaną maszynę stanów kontrolera zasilania na płytce RT1062, w całości sprzętowo. Nie jest udostępniony kodowi użytkownika; kontroler decyduje, co zrobić, na podstawie czasu przytrzymania:

    • Przytrzymaj przez ~5 s podczas działania płytki → maszyna stanów przechodzi w głębokie uśpienie.

    • Przytrzymaj przez ~1 s podczas głębokiego uśpienia płytki → maszyna stanów ponownie uruchamia system.

    Zwarcie pola złącza ON/OFF do stanu niskiego ma taki sam efekt jak naciśnięcie wbudowanego przycisku zasilania — przydatne do podłączenia zewnętrznego przełącznika lub sterowania linią z innego mikrokontrolera.

Piny statusu zasilania

Trzy aktywne stanem niskim wejścia statusu z wbudowanego układu zarządzania zasilaniem:

  • PG — niski, gdy obecne jest zasilanie VIN lub USB. Zawsze podłączony.

  • ST — niski, gdy płytka działa na VIN, wysoki, gdy działa na zasilaniu USB. Domyślnie niepodłączony.

  • CHG — niski podczas ładowania podłączonego akumulatora LiPo. Domyślnie niepodłączony.

from machine import Pin

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

Sensor kamery

OV5640 jest sterowany przez moduł csi — sensory kamery

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

OV5640 ma wbudowany kompresor JPEG. Ustaw csi.CSI.pixformat na csi.JPEG, a sensor będzie dostarczać skompresowane ramki prosto do kamery przez magistralę kamery, co czyni przechwytywanie w wysokiej rozdzielczości praktycznym: csi.HD (1280×720), csi.FHD (1920×1080) oraz pełne 5MP csi.WQXGA2 (2592×1944) — wszystkie przesyłane strumieniowo jako JPEG. Dostrój kompresję za pomocą csi.CSI.quality (0-100, wyższa = większe ramki, więcej szczegółów):

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

Sensor osadzony jest na wymiennym module — wymień go na dowolny z innych modułów kamer OpenMV (global shutter, termowizyjny, o wyższej rozdzielczości itp.) bez zmiany reszty płytki.

Uczenie maszynowe

ml — Uczenie maszynowe uruchamia skwantyzowane modele TFLite na Cortex‑M7 z jądrami CMSIS‑NN — wystarczająco szybko dla kompaktowych detektorów przy kilku ramkach na sekundę. Modele na tylko do odczytu systemie plików /rom ładują się bezpośrednio z pamięci flash, bez kopiowania do RAM. Oto detektor BlazeFace 128×128 nakładający wykrytą twarz i jej sześć punktów charakterystycznych na każdą ramkę:

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

Oprogramowanie układowe RT1062 nie podłącza wbudowanego akcelerometru do modułu imu — sensor imu. Zamiast tego komunikuj się z nim bezpośrednio przez wewnętrzną magistralę I²C — układ znajduje się pod adresem 0x15 i upakowuje trzy kanały przyspieszenia ze znakiem o rozdzielczości 12 bitów oraz 8‑bitowy bajt temperatury, począwszy od rejestru 0x03

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

Płytki R6 i nowsze zawierają standardowy 4 KB EEPROM I²C na tej samej wewnętrznej magistrali co akcelerometr. (Wcześniejsze wersje go nie mają — wywołanie tych fragmentów na R4/R5 zakończy się przekroczeniem czasu z powodu braku potwierdzenia I²C.) Użyj standardowego API machine.I2C readfrom_mem / writeto_mem z 16‑bitowym adresem pamięci:

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

Zarówno odczyty, jak i zapisy muszą mieścić się w obrębie strony 32‑bajtowej. Podziel każdy większy transfer na jedno wywołanie na stronę i dodaj opóźnienie cyklu zapisu ~5 ms między kolejnymi zapisami.

Wi‑Fi

Wbudowany moduł z rodziny CYW43 jest udostępniony przez network — konfiguracja sieci jako interfejs stacji. Po połączeniu ipconfig("addr4") zwraca 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

Ten sam moduł bezprzewodowy udostępnia również Bluetooth 5.1. Użyj aioble — Asynchroniczne BLE dla BLE przyjaznego dla asyncio — na przykład rozgłaszaj się jako urządzenie peryferyjne i czekaj na połączenie centrali:

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

Gdy do pól MDI podłączony jest RJ45 (z elementami magnetycznymi), układ PHY 10/100 pojawia się jako interfejs LAN. DHCP uruchamia się automatycznie, gdy łącze się pojawi:

import network, time

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

Karta microSD

Po włożeniu karta jest montowana automatycznie w /sdcard i jest dostępna przez zwykły system plików:

import os

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

Opis magistrali

GPIO

Użyj machine.Pin, aby odczytać lub sterować dowolnym z pinów opisanych na nadruku. Wyjścia są typu 3,3 V CMOS i mogą zasilać/przyjmować do 4 mA na pin.

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

Każdy pin wejściowy może również wyzwolić przerwanie przy zmianach zbocza:

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

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

UART

Magistrala

TX

RX

UART1

P4

P5

 
from machine import UART

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

I²C

Magistrala

SCL

SDA

I2C1

P4

P5

 
from machine import I2C

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

Ten sam sprzęt może być również używany w trybie urządzenia docelowego (slave) przez machine.I2CTarget, aby udostępnić obszar pamięci innemu kontrolerowi I²C:

from machine import I2CTarget

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

SPI

Magistrala

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

Magistrala

TX

RX

CAN1

P1

P3

Informacja

CAN nie jest jeszcze obsługiwany na tej płytce w oprogramowaniu układowym v5.0.0.

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

Jedynym użytkowym pinem ADC jest P6, który osiąga pełną skalę przy ~3,3 V:

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

Pin

Kanał FlexPWM

P0

PWM2 B3

P2

PWM2 B3

P4

PWM1 X2

P5

PWM1 X3

P7

PWM2 A0

P8

PWM2 B0

P9

PWM1 A3

P10

PWM1 B3

Steruj dowolnym z nich za pomocą machine.PWM

from machine import Pin, PWM

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

Programowo emulowane magistrale (bit‑bang)

machine.SoftI2C i machine.SoftSPI działają na dowolnym GPIO, jeśli potrzebujesz dodatkowej magistrali.

Sensor termowizyjny (zewnętrzny)

Oprogramowanie układowe zawiera sterownik fir — sterownik sensora termicznego (fir == far infrared, daleka podczerwień) dla zewnętrznie podłączonych kamer termowizyjnych:

  • MLX90621 — matryca IR 16 × 4

  • MLX90640 — matryca IR 32 × 24

  • MLX90641 — matryca IR 16 × 12

  • AMG8833 — matryca IR 8 × 8

Podłącz moduł do magistrali I²C płytki i odczytuj ramki za pomocą 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())

Sterownik fir komunikuje się z sensorem tylko przez I²C 4 — podłącz moduł do P4 (SCL) i P5 (SDA).

Pomiar czasu

time

Moduł time obejmuje blokujące opóźnienia, monotoniczne tiki oraz pomiar czasu, który upłynął:

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)

Liczniki wirtualne

machine.Timer planuje okresowe lub jednorazowe wywołania zwrotne bez zajmowania sprzętowego slotu licznika czasu. Przekaż -1 jako id, aby użyć wirtualnego (programowego) licznika czasu:

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

Wartości okresu podawane są w milisekundach. Wywołaj deinit(), aby zatrzymać i zwolnić slot.

Zegar czasu rzeczywistego

machine.RTC utrzymuje czas zegarowy między resetami oraz (z opcjonalną baterią podtrzymującą 3,3 V podłączoną do tylnych pól, zobacz Piny zasilania) także przy całkowitym zaniku zasilania:

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 działa również podczas głębokiego uśpienia, więc możesz go użyć jako źródła wybudzenia dla machine.deepsleep().

Watchdog

machine.WDT resetuje płytkę, jeśli aplikacja się zawiesi. Po uruchomieniu nie można go zatrzymać ani przekonfigurować — karm go okresowo wewnątrz głównej pętli:

from machine import WDT

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

Informacje o uruchamianiu i działaniu

Okno bootloadera USB

Przy każdym uruchomieniu kamera uruchamia krótki bootloader (kilka sekund), który pozwala OpenMV IDE zaktualizować oprogramowanie układowe bez konieczności wchodzenia przez użytkownika w tryb DFU. Po wygaśnięciu okna bootloader przekazuje sterowanie do boot.py, a następnie main.py.

Działający skrypt może na żądanie ponownie wejść w bootloader, wywołując machine.bootloader()

import machine

machine.bootloader()

System plików i kolejność uruchamiania

Oprogramowanie układowe RT1062 montuje przy uruchamianiu do trzech systemów plików:

  • Wewnętrzna pamięć flash — zawsze montowana w /flash. Domyślnie przechowuje main.py i README.txt; tworzona przy pierwszym uruchomieniu.

  • Karta microSD — jeśli karta jest włożona, montowana jest w /sdcard.

  • ROMFS — tylko do odczytu, mapowany w pamięci system plików w /rom używany do dostarczania dużych zasobów danych (np. modeli AI), które korzystają z dostępu bez kopiowania. Montowany automatycznie przez MicroPython przy starcie, zanim uruchomi się jakikolwiek kod Python użytkownika.

Po zamontowaniu katalog roboczy ustawiany jest na /sdcard, gdy karta jest obecna, w przeciwnym razie na /flash. Interpreter uruchamia następnie skrypty z tego katalogu:

  • boot.py jest wykonywany przy każdym miękkim resecie (zimny start, Ctrl‑D z REPL lub za każdym razem, gdy działający skrypt zakończy działanie).

  • main.py jest wykonywany tylko przy zimnym starcie, bezpośrednio po boot.py. Kolejne miękkie resety ponownie uruchamiają boot.py, ale przechodzą prosto do REPL — aby ponownie uruchomić main.py, musisz w pełni zresetować płytkę.

Umieszczenie pliku boot.py lub main.py na karcie SD nadpisuje kopię w pamięci flash bez jej naruszania — oba pliki są wyszukiwane w katalogu rozruchowym (/sdcard, gdy karta jest zamontowana, w przeciwnym razie /flash).

Domyślny main.py dostarczany na świeżo wgranej płytce po prostu miga niebieskim kanałem użytkowej diody RGB LED jako sygnał życia (dwa krótkie błyski, krótka przerwa), dzięki czemu możesz stwierdzić, że oprogramowanie układowe uruchomiło się poprawnie bez podłączonego hosta.

sys.path jest rozszerzany o wszystkie trzy systemy plików oraz ich podkatalogi lib/, dzięki czemu importowalne moduły mogą znajdować się w /flash/lib, /sdcard/lib lub /rom/lib.

Aby wymusić ignorowanie przez system włożonej karty SD (na przykład aby uruchomić main.py z pamięci flash nawet przy obecnej karcie), utwórz pusty plik o nazwie SKIPSD w katalogu głównym /flash.

Po podłączeniu przez USB rozruchowy system plików (/sdcard, jeśli karta jest obecna, w przeciwnym razie /flash) wyliczany jest również jako napęd pamięci masowej USB na hoście, co pozwala bezpośrednio edytować boot.py, main.py i inne pliki. Wysuń napęd przed zresetowaniem kamery, aby host opróżnił buforowane zapisy.

Informacja

Ponieważ system operacyjny traktuje napęd jako pasywne urządzenie blokowe, pliki utworzone lub zmodyfikowane przez kod działający na OpenMV Cam nie pojawią się, dopóki host nie zamontuje napędu ponownie. Jeśli zarówno system operacyjny, jak i OpenMV Cam zapisują ten sam system plików jednocześnie, system operacyjny wygra i nadpisze zmiany wprowadzone przez kamerę. Używaj karty SD do wszelkich danych, które skrypt zapisuje, i montuj ją ponownie przed odczytem tych plików z hosta.

Informacja

Czerwony kanał użytkowej diody RGB LED może na chwilę zaświecić, gdy host odczytuje z napędu pamięci masowej USB lub na niego zapisuje — jest to sterowany przez oprogramowanie układowe wskaźnik aktywności, a nie usterka.

Rozmiary pamięci masowej

RT1062 dostarczany jest z:

  • /flash — system plików FAT o pojemności 4 MB, do odczytu/zapisu.

  • /rom — 8 MB tylko do odczytu, mapowany w pamięci ROMFS, używany do dostarczania skryptów i modeli ML, które korzystają z dostępu mmap bez kopiowania.

  • /sdcard — pełny rozmiar włożonej karty microSD (gdy jest obecna), do odczytu/zapisu.

Wskaźnik twardej awarii (hard fault)

Jeśli użytkowa dioda RGB LED szybko przełącza się przez wszystkie kolory — na tyle szybko, że zwykle wygląda jak migocząca biała dioda LED zamiast wyraźnych barw — oznacza to, że oprogramowanie układowe napotkało nieodwracalną twardą awarię (hard fault). Aby przywrócić działanie, wgraj ponownie oprogramowanie układowe; jeśli to nie pomoże, płytka może być fizycznie uszkodzona.

Biblioteki programowe

Pełną listę modułów — w tym te, które są unikalne dla kompilacji RT1062 — znajdziesz w indeksie biblioteki.