OpenMV Cam RT1062¶

OpenMV Cam RT1062 on vähävirtainen konenäkölevy, joka rakentuu NXP i.MX RT1062 ‑piirin (Cortex‑M7 @ 600 MHz) ympärille. Levy yhdistää USB‑C‑pohjaisen suurnopeusverkon, Wi‑Fin/Bluetoothin ja 10/100 Ethernetin OV5640 5MP ‑sensoriin irrotettavalla kantajalla. Kamera ottaa syväunessa LiPo‑akusta vain noin 30 µA, mikä tekee siitä erinomaisen valinnan akkukäyttöisiin projekteihin.

Täydellisen datalehden, valokuvat ja mitat löydät OpenMV Cam RT1062 ‑tuotesivulta.

Kohokohdat¶

NXP i.MX RT1062 Cortex‑M7 600 MHz:llä.
32 MB ulkoista SDRAM‑muistia (16‑bittinen @ 160 MHz, 320 MB/s) sekä 1 MB sisäistä SRAM‑muistia ja 16 MB QSPI flash‑muistia (133 MHz 4‑bittinen SDR, 66 MB/s luku); 4 KB EEPROM R6+:ssa.
OV5640 5MP rolling‑shutter ‑sensori.
Integroitu IMU (12‑bittinen 3‑akselinen kiihtyvyysanturi, ±2/4/8 g).
High‑speed USB‑C (480 Mb/s, 1,5 A virtaraja), 10/100 Mb/s Ethernet (PoE‑kykyinen shieldin kautta), Wi‑Fi a/b/g/n + Bluetooth 5.1 (piiriantenni tai U.FL‑vaihtoehto).
microSD‑liitin — SD enintään 2 GB, SDHC enintään 32 GB, SDXC enintään 2 TB.
LiPo‑laturi (500 mA R6+:ssa, 100 mA R4/R5:ssä), RTC varmistusparistopadeilla. Syväunessa virrankulutus on ~30 µA akulla.
14 I/O‑nastaa, kaikki 3,3 V lähtö / 3,3 V kestäviä, 4 mA per nasta, keskeytyskykyisiä.
Käyttäjän RGB‑LED, käyttäjän SW‑painike, laitteistollinen virtapainike (syväuni‑ / herätystilakone) sekä erillinen tila‑LED lataukselle / USB:lle / VIN‑virralle.

Varoitus

RT1062:n I/O‑nastat eivät kestä 5 V:tä. Älä kytke laitetta suoraan 5 V:n mikro‑ohjaimeen, kuten Arduino Megaan. Syötä levyyn virtaa vain VIN:n kautta.

Nastajärjestys¶

Nastaviittaus¶

Nastan nimi	Toiminto
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 / kehyssynkronointi‑I/O
P11	herätys (aktiivinen matalalla, kytke GND:hen herättääksesi)
P12	RESET — vedä GND:hen nollataksesi levyn (ei GPIO)
P13	digitaalinen I/O
P14	digitaalinen I/O
ON/OFF	header‑padi, joka jäljittelee laitteistollista virtapainiketta (aktiivinen matalalla)
SW	käyttäjän painike (aktiivinen matalalla)
ST	matala VIN‑virralla, korkea USB‑virralla
CHG	aktiivinen matalalla; matala kun liitetty LiPo‑akku latautuu
PG	aktiivinen matalalla; matala kun VIN‑ tai USB‑virta on läsnä
LED_RED	RGB‑LEDin punainen kanava (aktiivinen matalalla)
LED_GREEN	RGB‑LEDin vihreä kanava (aktiivinen matalalla)
LED_BLUE	RGB‑LEDin sininen kanava (aktiivinen matalalla)

Muista

P10 kehyssynkronointilinja on jaettu väylä. Se on kytketty samanaikaisesti MCU:hun, kamerasensorin liipaisin‑/valotusnastaan ja käyttäjän headeriin. Suunta on sovelluskohtainen — MCU, sensori tai ulkoinen signaali voi ohjata sitä sen mukaan, miten sensori on konfiguroitu. Varmista, että vain yksi ohjain on aktiivinen kerrallaan.

Muista

ON/OFF ja P11 on viitattu aina päällä olevaan RAW‑kiskoon (ei kytkettyyn 3,3 V:n kiskoon), joten ne pysyvät toiminnassa, kun muu levy on syväunessa / vähävirtatilassa. Molemmat tulot ovat aktiivisia matalalla.

Nämä nastat kulkevat tasonsiirtimien kautta, jotta ne voivat toimia RAW‑kiskolla. Jos tarvitset ehdottomasti 3,3 V:n suoraa GPIO‑toimintaa ON/OFF‑ tai P11‑nastalle (esimerkiksi ohjataksesi niitä 3,3 V:n MCU:sta ilman tasonsiirtimen kautta kulkemista), levyssä on ylösvedot ja 0 ohmin jumper‑padit, joilla voit ohittaa tasonsiirtimen. Tämä on edistynyt laitteistomuokkaus — useimpien käyttäjien tulisi jättää se rauhaan.

Muista

P13 ja P14 ovat oletuksena tavallisia GPIO‑nastoja ilman erityistoimintoa. Padit voidaan valinnaisesti reitittää uudelleen muihin signaaleihin uudelleenjuottamalla levyn takana olevat 0 ohmin vastusjuotossillat:

P13 ↔ CHG‑tila / JTAG TRSTB
P14 ↔ ST‑tila / JTAG TDI

Useimmat käyttäjät eivät koske näihin jumpereihin — jätä ne GPIO‑oletukseen, ellet erityisesti tarvitse virranhallinnan takaisinlukua tai JTAG:ia.

Virtanastat¶

3.3V — säädelty 3,3 V:n kisko. Vain lähtö RT1062:ssa — älä syötä ulkoista virtaa tähän nastaan. Shieldeille saatavilla enintään 1 A.
VIN — 5 V:n tulo. Syöttää virtaa levylle ja sisäänrakennetulle LiPo‑laturille.
RAW — tulo/lähtö, aina päällä (3,6 V – 5 V). Kuljettaa kulloinkin aktiivista lähdettä (VIN, USB tai liitetty akku), ja sitä voi käyttää myös tulona. RAW:ta tulee ohjata sarjadiodin kautta kun siihen syötetään virtaa — muuten virta virtaa takaisin VIN:iin/USB:hen ja vahingoittaa virtalähdettä tai sisäänrakennettua suojausta.
GND — yhteinen maa.

Muista

Sisäänrakennettu virranhallintapiiri valitsee automaattisesti sen lähteen — USB:n tai VIN:n — jolla on korkeampi jännite syöttääkseen virtaa levylle ja akkulaturille. Jos LiPo on liitetty, se latautuu jäljelle jäävällä marginaalilla, ja ohjain siirtyy akkuun pitääkseen levyn käynnissä, jos VIN/USB notkahtaa tai irrotetaan.

Muista

Levyn takana on juotospadit ulkoiselle 3,3 V:n RTC‑varmistusparistolle. Nappipariston johdottaminen näihin padeihin pitää RTC:n käynnissä, kun muu levy on virrattomana.

Vihje

Käytä akun keston arviointityökalua mallintaaksesi, kuinka kauan RT1062 toimii akulla tietyllä aktiivisen / syväunen työsuhteella.

Ethernet‑nastat¶

RT1062 tuo 10/100 Mb/s Ethernet‑PHY:n MDI‑parit erillisiin padeihin GPIO‑headerin viereen. MDI‑nastoja ei ole turvallista kytkeä suoraan RJ45:een — Ethernet‑magnetiikka (eristysmuuntaja, joko magjackiin sisäänrakennettu tai shieldissä) on pakollinen PHY:n ja kaapelin välillä. OpenMV PoE shield sisältää sen; jos rakennat oman liittimen, käytä magnetiikkaintegroitua RJ45:tä tai ulkoista muuntajaa.

ETH_LED — linkki‑/aktiivisuus‑LED. Aktiivinen matalalla kun linkki on pystyssä; vilkkuu liikenteen yhteydessä.
ETH_TXP / ETH_TXN — lähetyspari.
ETH_RXP / ETH_RXN — vastaanottopari.

Muista

Header tuo myös neljä padia, joissa on silkkipainatus Reserved. Nämä ovat jalanjälkiyhteensopivia OpenMV N6 ‑levyn gigabitin Ethernet‑parien kanssa (DC P/N ja DD P/N), joten sama Ethernet‑/PoE‑shield voidaan liittää kumpaan tahansa levyyn. RT1062:n PHY tekee vain 10/100 Mb/s:ää, joten näillä neljällä padilla ei ole sähköistä yhteyttä — jätä ne kytkemättä.

Palautus‑ ja vianetsintänastat¶

RESET — vedä GND:hen nollataksesi levyn. Vapauttaminen antaa MCU:n käynnistyä normaalisti.
SBL — vedä 3,3 V:iin levyyn virtaa kytkettäessä siirtyäksesi ROM‑käynnistyslatain‑tilaan (Serial Boot Loader). OpenMV IDE käyttää tätä tilaa sisäänrakennetun käynnistyslataimen uudelleenflashaukseen.

Levyssä on erillinen ARM 10‑nastainen SWD/JTAG ‑header, joka on yhteensopiva ST‑LINK‑ ja SEGGER J‑Link ‑adaptereiden kanssa.

Muista

RT1062 tuo tämän liittimen kautta oletuksena vain SWD‑vianetsinnän. Täysi JTAG ei ole käytettävissä suoraan laatikosta.

Integroidut oheislaitteet¶

LEDit¶

RT1062:ssa on kaksi RGB‑LEDiä:

Käyttäjän RGB‑LED — ohjelmistolla ohjattava, tuotu esiin nimillä LED_RED, LED_GREEN ja LED_BLUE
```
from machine import LED

LED("LED_RED").on()
LED("LED_GREEN").on()
LED("LED_BLUE").on()
```
Virta‑LED — ohjattu suoraan sisäänrakennetulla virranhallintalaitteistolla, ei ohjelmisto‑ohjausta. Käytä sitä lukeaksesi yhdellä silmäyksellä, mitä virtalähde tekee.

Käynnissä ollessa:

Kanava

Merkitys

Sininen

VIN syöttää virtaa levylle (pois päältä USB:llä)

Vihreä

USB‑ tai VIN‑virta läsnä

Punainen

lataa liitettyä LiPo‑akkua

Syväunessa kaikki kanavat ovat pois päältä paitsi punainen, joka palaa edelleen LiPon latautuessa.

Kanava	Merkitys
Sininen	VIN syöttää virtaa levylle (pois päältä USB:llä)
Vihreä	USB‑ tai VIN‑virta läsnä
Punainen	lataa liitettyä LiPo‑akkua

Painikkeet¶

RT1062:ssa on kaksi painiketta:

SW — yleiskäyttöinen käyttäjän painike. Luettavissa koodista tavallisena aktiivinen‑matalalla GPIO‑tulona:
```
from machine import Pin

sw = Pin("SW", Pin.IN)
print(sw.value())
```
Virtapainike — ohjattu RT1062‑levyn erillisellä virtaohjaimen tilakoneella, kokonaan laitteistossa. Sitä ei tuoda käyttäjäkoodille; ohjain päättää, mitä tehdä sen mukaan, kuinka kauan sitä pidetään painettuna:
- Pidä ~5 s levyn ollessa käynnissä → tilakone siirtyy syväuneen.
- Pidä ~1 s levyn ollessa syväunessa → tilakone käynnistää järjestelmän takaisin päälle.
ON/OFF‑header‑padin vetäminen matalalle vaikuttaa samoin kuin sisäänrakennetun virtapainikkeen painaminen — hyödyllistä ulkoisen kytkimen johdottamiseen tai linjan ohjaamiseen toisesta mikro‑ohjaimesta.

Virtatilanastat¶

Kolme aktiivinen‑matalalla tilatuloa sisäänrakennetusta virranhallintapiiristä:

PG — matala kun VIN‑ tai USB‑virta on läsnä. Aina kytketty.
ST — matala kun levy toimii VIN:llä, korkea kun se toimii USB‑virralla. Ei kytketty oletuksena.
CHG — matala kun liitetty LiPo‑akku latautuu. Ei kytketty oletuksena.

from machine import Pin

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

Kamerasensori¶

OV5640:tä ohjataan csi — kennot ‑moduulin kautta:

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:ssa on sisäänrakennettu JPEG‑pakkain. Aseta csi.CSI.pixformat arvoon csi.JPEG, niin sensori toimittaa pakatut kehykset suoraan kameraan kameraväylän yli, mikä tekee korkearesoluutioisista kaappauksista käytännöllisiä: csi.HD (1280×720), csi.FHD (1920×1080) ja täysi 5MP csi.WQXGA2 (2592×1944) striimaavat kaikki JPEG‑muodossa. Säädä pakkausta arvolla csi.CSI.quality (0–100, korkeampi = suuremmat kehykset, enemmän yksityiskohtia):

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

Sensori istuu irrotettavassa moduulissa — vaihda se mihin tahansa muuhun OpenMV‑kameramoduuliin (global shutter, lämpö, korkeampi resoluutio jne.) muuttamatta muuta levyä.

Koneoppiminen¶

ml — Koneoppiminen ajaa kvantisoituja TFLite‑malleja Cortex‑M7:llä CMSIS‑NN‑ytimillä — riittävän nopeasti kompakteille tunnistimille muutamalla kehyksellä sekunnissa. Vain luku ‑muotoisessa /rom‑tiedostojärjestelmässä olevat mallit latautuvat suoraan flash‑muistista kopioimatta niitä RAM‑muistiin. Tässä on 128×128 BlazeFace‑tunnistin, joka asettaa havaitun kasvon ja sen kuusi maamerkkiä päällyksenä jokaiseen kehykseen:

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¶

RT1062‑laiteohjelmisto ei kytke sisäänrakennettua kiihtyvyysanturia imu — imu-sensori ‑moduuliin. Kommunikoi sen kanssa sen sijaan suoraan sisäisen I²C‑väylän yli — piiri sijaitsee osoitteessa 0x15 ja pakkaa kolme etumerkillistä 12‑bittistä kiihtyvyyskanavaa sekä 8‑bittisen lämpötilatavun rekisteristä 0x03 alkaen:

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¶

R6‑levyt ja uudemmat sisältävät yleisen 4 KB I²C EEPROMin samalla sisäisellä väylällä kuin kiihtyvyysanturi. (Aiemmissa versioissa ei ole sitä — näiden katkelmien kutsuminen R4/R5:ssä aiheuttaa aikakatkaisun puuttuvan I²C‑ackin vuoksi.) Käytä vakio‑ machine.I2C readfrom_mem / writeto_mem ‑API:a 16‑bittisellä muistiosoitteella:

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

Sekä lukujen että kirjoitusten on pysyttävä 32 tavun sivun sisällä. Jaa kaikki suuremmat siirrot yhteen kutsuun per sivu, ja lisää ~5 ms:n kirjoitussyklin viive peräkkäisten kirjoitusten väliin.

Wi‑Fi¶

Sisäänrakennettu CYW43‑perheen moduuli tuodaan esiin network — verkkomääritykset ‑moduulin kautta asema (station) ‑rajapintana. Yhdistämisen jälkeen ipconfig("addr4") palauttaa (ip, netmask) ‑parin:

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¶

Sama langaton moduuli tuo esiin myös Bluetooth 5.1:n. Käytä aioble — Asynkroninen BLE:a asyncio‑ystävälliseen BLE:hen — esimerkiksi mainosta itseäsi oheislaitteena ja odota, että central yhdistää:

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¶

Kun RJ45 (magnetiikalla) on kytketty MDI‑padeihin, 10/100‑PHY näkyy LAN‑rajapintana. DHCP käynnistyy automaattisesti heti, kun linkki tulee pystyyn:

import network, time

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

microSD‑kortti¶

Kun kortti asetetaan, se liitetään automaattisesti kohtaan /sdcard ja on käytettävissä tavallisen tiedostojärjestelmän kautta:

import os

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

Väyläviittaus¶

GPIO¶

Käytä machine.Pin:iä lukeaksesi tai ohjataksesi mitä tahansa silkkipainettua nastaa. Lähdöt ovat 3,3 V CMOS ja voivat upottaa/lähteistää enintään 4 mA per nasta.

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

Mikä tahansa tulonasta voi myös laukaista keskeytyksen reunan siirtymissä:

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

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

UART¶

Väylä	TX	RX
UART1	P4	P5

from machine import UART

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

I²C¶

Väylä	SCL	SDA
I2C1	P4	P5

from machine import I2C

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

Samaa laitteistoa voidaan käyttää myös kohde (slave) ‑tilassa machine.I2CTarget:n kautta tuomaan muistialue toisen I²C‑ohjaimen käyttöön:

from machine import I2CTarget

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

SPI¶

Väylä	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¶

Väylä	TX	RX
CAN1	P1	P3

Muista

CAN:ia ei vielä tueta tällä levyllä laiteohjelmistossa 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¶

Ainoa käyttäjän ADC‑nasta on P6, joka on täysiskaalainen noin 3,3 V:ssä:

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¶

Nasta	FlexPWM‑kanava
P0	PWM2 B3
P2	PWM2 B3
P4	PWM1 X2
P5	PWM1 X3
P7	PWM2 A0
P8	PWM2 B0
P9	PWM1 A3
P10	PWM1 B3

Ohjaa mitä tahansa niistä machine.PWM:n kautta:

from machine import Pin, PWM

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

Ohjelmistolla bit‑bangatut väylät¶

machine.SoftI2C ja machine.SoftSPI toimivat millä tahansa GPIO:lla, jos tarvitset ylimääräisen väylän.

Lämpösensori (levyn ulkopuolinen)¶

Laiteohjelmisto sisältää fir — lämpösensorin ajuri (fir == far infrared) ‑ajurin ulkoisesti johdotetuille lämpökuvantajille:

MLX90621 — 16 × 4 IR‑matriisi
MLX90640 — 32 × 24 IR‑matriisi
MLX90641 — 16 × 12 IR‑matriisi
AMG8833 — 8 × 8 IR‑matriisi

Johdota moduuli levyn I²C‑väylään ja lue kehyksiä komennoilla 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‑ajuri kommunikoi sensorin kanssa vain I²C 4:n yli — johdota moduuli P4:ään (SCL) ja P5:een (SDA).

Ajoitus¶

time¶

time ‑moduuli kattaa estävät viiveet, monotoniset tikitykset ja kuluneen ajan mittauksen:

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)

Virtuaaliajastimet¶

machine.Timer ajoittaa jaksoittaisia tai kertaluonteisia takaisinkutsuja kuluttamatta laitteistollista ajastinpaikkaa. Anna -1 id:ksi käyttääksesi virtuaalista (ohjelmistollista) ajastinta:

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

Jaksoarvot ovat millisekunteina. Kutsu deinit() pysäyttääksesi ja vapauttaaksesi paikan.

Reaaliaikakello¶

machine.RTC pitää seinäkellon aikaa nollausten yli ja (valinnaisella takapadeihin johdotetulla 3,3 V:n varmistusparistolla, katso Virtanastat) täydellisen virtakatkon yli:

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 käy myös syväunen läpi, joten voit käyttää sitä herätyslähteenä machine.deepsleep():lle.

Vahtikoira¶

machine.WDT nollaa levyn, jos sovellus jumiutuu. Käynnistyksen jälkeen sitä ei voi pysäyttää tai konfiguroida uudelleen — syötä sitä ajoittain pääsilmukassasi:

from machine import WDT

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

Käynnistys‑ ja ajonaikatiedot¶

USB‑käynnistyslatain‑ikkuna¶

Joka virrankytkennässä kamera ajaa lyhyen käynnistyslataimen (muutaman sekunnin), jonka avulla OpenMV IDE voi päivittää laiteohjelmiston ilman, että käyttäjän tarvitsee siirtyä DFU‑tilaan. Ikkunan umpeuduttua käynnistyslatain luovuttaa ohjauksen tiedostolle boot.py ja sitten main.py.

Käynnissä oleva skripti voi siirtyä takaisin käynnistyslataimeen pyynnöstä kutsumalla machine.bootloader()

import machine

machine.bootloader()

Tiedostojärjestelmä ja käynnistysjärjestys¶

RT1062‑laiteohjelmisto liittää käynnistyksessä enintään kolme tiedostojärjestelmää:

Sisäinen flash‑muisti — liitetään aina kohtaan /flash. Sisältää oletuksena tiedostot main.py ja README.txt; luodaan aivan ensimmäisellä käynnistyksellä.
microSD‑kortti — jos kortti on asetettu, se liitetään kohtaan /sdcard.
ROMFS — vain luku ‑muotoinen, muistiin mapattu tiedostojärjestelmä kohdassa /rom, jota käytetään suurten data‑assettien (esim. AI‑mallien) toimittamiseen, jotka hyötyvät zero‑copy‑pääsystä. MicroPython liittää sen automaattisesti käynnistyksessä, ennen kuin mikään käyttäjän Python ajetaan.

Liittämisen jälkeen työhakemistoksi asetetaan /sdcard, kun kortti on läsnä, muutoin /flash. Tulkki ajaa sitten skriptit tästä hakemistosta:

boot.py suoritetaan jokaisella pehmeällä nollauksella (kylmäkäynnistys, Ctrl‑D REPL:stä tai aina kun käynnissä oleva skripti palaa).
main.py suoritetaan vain kylmäkäynnistyksellä, heti boot.py:n jälkeen. Myöhemmät pehmeät nollaukset ajavat boot.py:n uudelleen mutta putoavat suoraan REPL:iin — ajaaksesi main.py:n uudelleen sinun on nollattava levy kokonaan.

boot.py:n tai main.py:n pudottaminen SD‑kortille ohittaa flash‑muistissa olevan kopion koskematta siihen — molemmat tiedostot etsitään käynnistyshakemistosta (/sdcard kun kortti on liitetty, muutoin /flash).

Tuoreesti flashatulle levylle toimitettu oletus‑ main.py vain vilkuttaa käyttäjän RGB‑LEDin sinistä kanavaa sydämenlyöntinä (kaksi lyhyttä pulssia, lyhyt tauko), joten voit todeta laiteohjelmiston käynnistyneen puhtaasti ilman mitään isäntää kytkettynä.

sys.path laajennetaan sisältämään kaikki kolme tiedostojärjestelmää ja niiden lib/‑alihakemistot, joten tuotavat moduulit voivat sijaita kohteissa /flash/lib, /sdcard/lib tai /rom/lib.

Pakottaaksesi järjestelmän jättämään huomiotta asetetun SD‑kortin (esimerkiksi ajaaksesi flash‑muistin main.py:n vaikka kortti olisi läsnä), luo tyhjä tiedosto nimeltä SKIPSD /flash:n juureen.

USB:n kautta kytkettäessä käynnistystiedostojärjestelmä (/sdcard jos kortti on läsnä, muutoin /flash) luetteloituu myös USB‑massamuistiasemana isännällä, jolloin voit muokata tiedostoja boot.py, main.py ja mitä tahansa muita tiedostoja suoraan. Poista asema turvallisesti ennen kameran nollausta, jotta isäntä huuhtelee välimuistissa olevat kirjoituksensa.

Muista

Koska käyttöjärjestelmä käsittelee asemaa passiivisena lohkolaitteena, OpenMV Camilla ajettavan koodin luomat tai muokkaamat tiedostot eivät näy, ennen kuin isäntä liittää aseman uudelleen. Jos sekä käyttöjärjestelmä että OpenMV Cam kirjoittavat samaan tiedostojärjestelmään samaan aikaan, käyttöjärjestelmä voittaa ja ylikirjoittaa kameran tekemät muutokset. Käytä SD‑korttia kaikkeen dataan, jonka skripti kirjoittaa takaisin, ja liitä uudelleen ennen kuin luet näitä tiedostoja isännältä.

Muista

Käyttäjän RGB‑LEDin punainen kanava saattaa syttyä hetkellisesti, kun isäntä lukee tai kirjoittaa USB‑massamuistiasemaa — tämä on laiteohjelmiston ohjaama aktiivisuusilmaisin, ei vika.

Tallennustilojen koot¶

RT1062 toimitetaan seuraavilla:

/flash — 4 MB FAT‑tiedostojärjestelmä, luku/kirjoitus.
/rom — 8 MB vain luku ‑muotoinen muistiin mapattu ROMFS, jota käytetään toimittamaan skriptejä ja ML‑malleja, jotka hyötyvät zero‑copy mmap ‑pääsystä.
/sdcard — kulloinkin asetetun microSD‑kortin koko täysimääräisenä (kun läsnä), luku/kirjoitus.

Hard‑fault‑ilmaisin¶

Jos käyttäjän RGB‑LED kiertää nopeasti läpi kaikkia värejä — niin nopeasti, että se yleensä näyttää tuikkivalta valkoiselta LEDiltä erillisten sävyjen sijaan — laiteohjelmisto on osunut palautumattomaan hard‑faultiin. Flashaa laiteohjelmisto uudelleen palautuaksesi; jos uudelleenflashaus ei auta, levy saattaa olla fyysisesti vaurioitunut.

Ohjelmistokirjastot¶

Katso kirjastohakemistosta täydellinen lista moduuleista — mukaan lukien, mitkä niistä ovat ainutlaatuisia RT1062‑buildille.