OpenMV Cam RT1062¶

OpenMV Cam RT1062 adalah papan visi mesin berdaya rendah yang dibangun di sekitar NXP i.MX RT1062 (Cortex‑M7 @ 600 MHz). Papan ini memadukan jaringan USB‑C berkecepatan tinggi, Wi‑Fi/Bluetooth, dan Ethernet 10/100 dengan sensor OV5640 5MP pada carrier yang dapat dilepas. Kamera hanya menarik ~30 µA dari baterai LiPo saat deep sleep, sehingga sangat cocok untuk proyek berbasis baterai.

Untuk datasheet lengkap, foto, dan dimensi lihat halaman produk OpenMV Cam RT1062.

Sorotan¶

NXP i.MX RT1062 Cortex‑M7 pada 600 MHz.
32 MB SDRAM eksternal (16‑bit @ 160 MHz, 320 MB/s) ditambah 1 MB SRAM internal dan 16 MB flash QSPI (133 MHz 4‑bit SDR, 66 MB/s baca); 4 KB EEPROM pada R6+.
Sensor rolling‑shutter OV5640 5MP.
IMU terintegrasi (akselerometer 3‑sumbu 12‑bit, ±2/4/8 g).
USB‑C kecepatan tinggi (480 Mb/s, batas arus 1,5 A), Ethernet 10/100 Mb/s (mendukung PoE melalui shield), Wi‑Fi a/b/g/n + Bluetooth 5.1 (antena chip atau opsi U.FL).
Soket microSD — SD hingga 2 GB, SDHC hingga 32 GB, SDXC hingga 2 TB.
Pengisi daya LiPo (500 mA pada R6+, 100 mA pada R4/R5), RTC dengan bantalan baterai cadangan. Deep sleep menarik ~30 µA dari baterai.
14 pin I/O, semua keluaran 3,3 V / toleran 3,3 V, 4 mA per pin, mendukung interupsi.
LED RGB pengguna, tombol SW pengguna, tombol daya perangkat keras (mesin status deep‑sleep / wake), dan LED status terpisah untuk pengisian daya / USB / daya VIN.

Peringatan

Pin I/O RT1062 tidak toleran 5 V. Jangan hubungkan perangkat langsung ke MCU 5 V seperti Arduino Mega. Sumber daya papan hanya melalui VIN.

Tata Letak Pin¶

Referensi pin¶

Nama pin	Fungsi
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 / frame sync I/O
P11	wakeup (aktif rendah, hubungkan ke GND untuk membangunkan)
P12	RESET — tarik ke GND untuk mereset papan (bukan GPIO)
P13	digital I/O
P14	digital I/O
ON/OFF	bantalan header yang mereplikasi tombol daya perangkat keras (aktif rendah)
SW	tombol pengguna (aktif rendah)
ST	rendah pada daya VIN, tinggi pada daya USB
CHG	aktif‑rendah; rendah saat baterai LiPo yang terpasang sedang mengisi daya
PG	aktif‑rendah; rendah saat daya VIN atau USB tersedia
LED_RED	saluran merah LED RGB (aktif rendah)
LED_GREEN	saluran hijau LED RGB (aktif rendah)
LED_BLUE	saluran biru LED RGB (aktif rendah)

Catatan

Jalur frame‑sync P10 adalah bus bersama. Jalur ini dihubungkan ke MCU, pin trigger/eksposur sensor kamera, dan header pengguna sekaligus. Arah ditentukan oleh aplikasi — MCU, sensor, atau sinyal eksternal dapat menggerakkannya tergantung pada konfigurasi sensor. Pastikan hanya satu driver yang aktif pada satu waktu.

Catatan

ON/OFF dan P11 mengacu pada rel RAW yang selalu aktif (bukan rel 3,3 V yang disaklari), sehingga tetap berfungsi saat bagian papan lainnya berada dalam mode deep sleep / daya rendah. Kedua input aktif rendah.

Pin-pin ini melewati level shifter sehingga dapat bekerja pada rel RAW. Jika Anda benar-benar memerlukan perilaku GPIO 3,3 V langsung pada ON/OFF atau P11 (misalnya untuk menggerakkannya dari MCU 3,3 V tanpa melewati shifter), papan ini menyediakan bantalan pull-up dan jumper 0-ohm yang memungkinkan Anda melewati shifter. Ini adalah modifikasi perangkat keras tingkat lanjut — sebagian besar pengguna sebaiknya membiarkannya apa adanya.

Catatan

P13 dan P14 adalah GPIO biasa secara default tanpa fungsi khusus. Bantalan secara opsional dapat diarahkan ulang ke sinyal lain dengan mereflow jembatan solder resistor 0-ohm di bagian belakang papan:

P13 ↔ status CHG / JTAG TRSTB
P14 ↔ status ST / JTAG TDI

Sebagian besar pengguna tidak perlu menyentuh jumper ini — biarkan pada default GPIO kecuali Anda secara khusus memerlukan pembacaan manajemen daya atau JTAG.

Pin daya¶

3.3V — rel 3,3 V yang diatur. Hanya keluaran pada RT1062 — jangan sambungkan daya eksternal ke pin ini. Tersedia hingga 1 A untuk shield.
VIN — input 5 V. Memberi daya pada papan dan pengisi daya LiPo terintegrasi.
RAW — input/output, selalu aktif (3,6 V – 5 V). Membawa sumber mana pun yang aktif (VIN, USB, atau baterai yang terpasang), dan juga dapat digunakan sebagai input. Anda harus menggerakkan RAW melalui dioda seri saat menyuplai daya ke dalamnya — jika tidak, arus akan mengalir balik ke VIN/USB dan merusak sumber daya atau proteksi terintegrasi.
GND — ground bersama.

Catatan

Chip manajemen daya terintegrasi secara otomatis memilih antara USB atau VIN yang memiliki tegangan lebih tinggi untuk memberi daya pada papan dan pengisi baterai. Jika LiPo terpasang, ia mengisi daya dengan headroom tersisa, dan kontroler beralih ke baterai untuk menjaga papan tetap berjalan jika VIN/USB turun atau dicabut.

Catatan

Bagian belakang papan memiliki bantalan solder untuk baterai cadangan RTC 3,3 V eksternal. Menghubungkan baterai koin ke bantalan ini membuat RTC tetap berjalan saat seluruh papan tidak bertenaga.

Tip

Gunakan estimator masa pakai baterai untuk memodelkan berapa lama RT1062 akan berjalan dengan baterai untuk siklus kerja aktif / deep‑sleep tertentu.

Pin Ethernet¶

RT1062 mengekspos pasangan MDI PHY Ethernet 10/100 Mb/s pada bantalan khusus di sebelah header GPIO. Pin MDI tidak aman untuk langsung dihubungkan ke RJ45 — magnet Ethernet (transformator isolasi, baik yang terpasang di magjack maupun pada shield) diperlukan antara PHY dan kabel. Shield PoE OpenMV sudah menyertakannya; jika Anda membuat jack sendiri, gunakan RJ45 terintegrasi magnet atau transformator eksternal.

ETH_LED — LED link/aktivitas. Aktif rendah saat link aktif; berkedip saat ada lalu lintas.
ETH_TXP / ETH_TXN — pasangan transmit.
ETH_RXP / ETH_RXN — pasangan receive.

Catatan

Header ini juga mengekspos empat bantalan yang dicetak sutra Reserved. Bantalan ini kompatibel dengan pasangan Ethernet gigabit pada OpenMV N6 (DC P/N dan DD P/N) sehingga shield Ethernet/PoE yang sama dapat dipasang ke salah satu papan. PHY RT1062 hanya mendukung 10/100 Mb/s, sehingga keempat bantalan tersebut tidak memiliki konektivitas listrik — biarkan tidak terhubung.

Pin recovery dan debug¶

RESET — tarik ke GND untuk mereset papan. Melepasnya memungkinkan MCU start up secara normal.
SBL — tarik ke 3,3 V saat memberi daya pada papan untuk masuk ke mode ROM bootloader (Serial Boot Loader). OpenMV IDE menggunakan mode ini untuk reflash bootloader terintegrasi.

Header ARM SWD/JTAG 10‑pin khusus terpasang, kompatibel dengan adapter ST‑LINK dan SEGGER J‑Link.

Catatan

RT1062 hanya mengekspos debug SWD melalui konektor ini secara default. JTAG penuh tidak tersedia secara langsung.

Periferal terintegrasi¶

LED¶

RT1062 memiliki dua LED RGB:

LED RGB pengguna — dapat dikontrol oleh perangkat lunak, diekspos sebagai LED_RED, LED_GREEN dan LED_BLUE
```
from machine import LED

LED("LED_RED").on()
LED("LED_GREEN").on()
LED("LED_BLUE").on()
```
LED Daya — digerakkan langsung oleh perangkat keras manajemen daya terintegrasi, tanpa kontrol perangkat lunak. Gunakan untuk membaca kondisi suplai daya sekilas.

Saat berjalan:

Saluran

Arti

Biru

VIN memberi daya pada papan (mati saat USB)

Hijau

Daya USB atau VIN tersedia

Merah

mengisi daya baterai LiPo yang terpasang

Saat deep sleep semua saluran mati kecuali Merah, yang tetap menyala saat LiPo sedang mengisi daya.

Saluran	Arti
Biru	VIN memberi daya pada papan (mati saat USB)
Hijau	Daya USB atau VIN tersedia
Merah	mengisi daya baterai LiPo yang terpasang

Tombol¶

RT1062 memiliki dua tombol:

SW — tombol pengguna serba guna. Dapat dibaca dari kode sebagai input GPIO aktif‑rendah normal:
```
from machine import Pin

sw = Pin("SW", Pin.IN)
print(sw.value())
```
Tombol daya — digerakkan oleh mesin status power‑controller khusus pada papan RT1062, sepenuhnya dalam perangkat keras. Tidak diekspos ke kode pengguna; kontroler memutuskan tindakan berdasarkan berapa lama ditekan:
- Tahan ~5 detik saat papan sedang berjalan → mesin status beralih ke deep sleep.
- Tahan ~1 detik saat papan dalam deep sleep → mesin status menghidupkan sistem kembali.
Menarik bantalan header ON/OFF ke rendah memiliki efek yang sama dengan menekan tombol daya terintegrasi — berguna untuk menghubungkan sakelar eksternal atau menggerakkan jalur dari mikrokontroler lain.

Pin status daya¶

Tiga input status aktif‑rendah dari chip manajemen daya terintegrasi:

PG — rendah saat daya VIN atau USB tersedia. Selalu terhubung.
ST — rendah saat papan berjalan dengan VIN, tinggi saat berjalan dengan daya USB. Tidak terhubung secara default.
CHG — rendah saat baterai LiPo yang terpasang sedang mengisi daya. Tidak terhubung secara default.

from machine import Pin

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

Sensor kamera¶

OV5640 digerakkan melalui modul csi --- sensor kamera

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 memiliki kompresor JPEG terintegrasi. Atur csi.CSI.pixformat ke csi.JPEG dan sensor mengirimkan bingkai terkompresi langsung ke kamera melalui bus kamera, sehingga pengambilan gambar beresolusi tinggi menjadi praktis: csi.HD (1280×720), csi.FHD (1920×1080), dan full 5MP csi.WQXGA2 (2592×1944) semuanya di-stream sebagai JPEG. Atur kompresi dengan csi.CSI.quality (0-100, lebih tinggi = bingkai lebih besar, lebih detail):

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

Sensor berada pada modul yang dapat dilepas — ganti dengan modul kamera OpenMV lainnya (global shutter, termal, resolusi lebih tinggi, dll.) tanpa mengubah sisa papan.

Machine learning¶

ml --- Machine Learning menjalankan model TFLite terkuantisasi pada Cortex‑M7 dengan kernel CMSIS‑NN — cukup cepat untuk detektor kompak pada beberapa bingkai per detik. Model pada filesystem hanya‑baca /rom dimuat langsung dari flash tanpa menyalin ke RAM. Berikut adalah detektor BlazeFace 128×128 yang melapisi wajah yang terdeteksi dan enam landmark-nya pada setiap bingkai:

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¶

Firmware RT1062 tidak menghubungkan akselerometer terintegrasi ke modul imu --- sensor imu. Komunikasikan langsung melalui bus I²C internal — chip berada pada alamat 0x15 dan menyimpan tiga saluran akselerasi 12‑bit bertanda plus satu byte temperatur 8‑bit mulai dari register 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¶

Papan R6 dan yang lebih baru menyertakan EEPROM I²C generik 4 KB pada bus internal yang sama dengan akselerometer. (Revisi sebelumnya tidak memilikinya — memanggil cuplikan ini pada R4/R5 akan time out karena tidak ada I²C ack.) Gunakan API machine.I2C standar readfrom_mem / writeto_mem dengan alamat memori 16‑bit:

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

Baca maupun tulis harus berada dalam satu halaman 32‑byte. Pisahkan transfer yang lebih besar menjadi satu panggilan per halaman, dan tambahkan penundaan siklus tulis ~5 md di antara penulisan berturut-turut.

Wi‑Fi¶

Modul keluarga CYW43 terintegrasi diekspos melalui network --- konfigurasi jaringan sebagai antarmuka stasiun. Setelah terhubung, ipconfig("addr4") mengembalikan pasangan (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¶

Modul nirkabel yang sama juga mengekspos Bluetooth 5.1. Gunakan aioble --- Async BLE untuk BLE yang ramah asyncio — misalnya, advertise sebagai periferal dan tunggu central untuk terhubung:

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¶

Ketika RJ45 (dengan magnet) dihubungkan ke bantalan MDI, PHY 10/100 muncul sebagai antarmuka LAN. DHCP berjalan otomatis setelah link aktif:

import network, time

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

Kartu microSD¶

Ketika kartu dimasukkan, kartu tersebut dipasang secara otomatis di /sdcard dan dapat digunakan melalui sistem file biasa:

import os

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

Referensi bus¶

GPIO¶

Gunakan machine.Pin untuk membaca atau menggerakkan pin mana pun yang tercetak di papan. Keluaran adalah CMOS 3,3 V dan dapat sink/source hingga 4 mA per 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())

Pin input mana pun juga dapat memicu interupsi pada transisi tepi:

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

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

UART¶

Bus	TX	RX
UART1	P4	P5

from machine import UART

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

I²C¶

Bus	SCL	SDA
I2C1	P4	P5

from machine import I2C

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

Perangkat keras yang sama juga dapat digunakan dalam mode target (slave) melalui machine.I2CTarget untuk mengekspos wilayah memori ke kontroler I²C lain:

from machine import I2CTarget

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

SPI¶

Bus	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¶

Bus	TX	RX
CAN1	P1	P3

Catatan

CAN belum didukung pada papan ini di firmware 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¶

Satu-satunya pin ADC pengguna adalah P6, yang berskala penuh pada ~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	Saluran 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

Gerakkan salah satunya melalui machine.PWM

from machine import Pin, PWM

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

Bus bit‑banged perangkat lunak¶

machine.SoftI2C dan machine.SoftSPI bekerja pada GPIO mana pun jika Anda memerlukan bus tambahan.

Sensor termal (di luar papan)¶

Firmware menyertakan driver fir --- driver sensor termal (fir == far infrared) untuk imager termal yang dihubungkan secara eksternal:

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

Hubungkan modul ke bus I²C papan dan baca bingkai dengan 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())

Driver fir hanya berkomunikasi dengan sensor melalui I²C 4 — hubungkan modul ke P4 (SCL) dan P5 (SDA).

Timing¶

time¶

Modul time mencakup penundaan blokir, tik monoton, dan pengukuran waktu yang telah berlalu:

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)

Timer virtual¶

machine.Timer menjadwalkan callback periodik atau satu‑kali tanpa mengonsumsi slot timer perangkat keras. Masukkan -1 sebagai id untuk menggunakan timer virtual (perangkat lunak):

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

Nilai periode dalam milidetik. Panggil deinit() untuk menghentikan dan melepaskan slot.

Real‑time clock¶

machine.RTC menjaga waktu jam dinding melewati reset dan (dengan baterai cadangan 3,3 V opsional yang dihubungkan ke bantalan belakang, lihat Pin daya) melewati kehilangan daya penuh:

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 juga berjalan melalui deep sleep, sehingga Anda dapat menggunakannya sebagai sumber wakeup untuk machine.deepsleep().

Watchdog¶

machine.WDT mereset papan jika aplikasi hang. Setelah dimulai tidak dapat dihentikan atau dikonfigurasi ulang — beri makan secara berkala di dalam loop utama Anda:

from machine import WDT

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

Informasi boot dan runtime¶

Jendela bootloader USB¶

Pada setiap penyalaan, kamera menjalankan bootloader singkat (beberapa detik) yang memungkinkan OpenMV IDE memperbarui firmware tanpa pengguna harus masuk ke mode DFU. Setelah jendela berakhir, bootloader menyerahkan ke boot.py dan kemudian main.py.

Skrip yang sedang berjalan dapat masuk kembali ke bootloader sesuai permintaan dengan memanggil machine.bootloader()

import machine

machine.bootloader()

Sistem file dan urutan boot¶

Firmware RT1062 memasang hingga tiga sistem file saat boot:

Flash internal — selalu dipasang di /flash. Berisi main.py dan README.txt secara default; dibuat pada boot pertama.
Kartu microSD — jika kartu dimasukkan, kartu dipasang di /sdcard.
ROMFS — filesystem hanya‑baca, dipetakan ke memori di /rom yang digunakan untuk mengirimkan aset data besar (misalnya model AI) yang mendapat manfaat dari akses zero‑copy. Dipasang secara otomatis oleh MicroPython saat startup, sebelum Python pengguna mana pun dijalankan.

Setelah pemasangan, direktori kerja disetel ke /sdcard saat kartu ada, jika tidak ke /flash. Interpreter kemudian menjalankan skrip dari direktori tersebut:

boot.py dieksekusi pada setiap soft reset (cold boot, Ctrl‑D dari REPL, atau setiap kali skrip yang berjalan kembali).
main.py dieksekusi hanya pada cold boot, segera setelah boot.py. Soft reset berikutnya menjalankan ulang boot.py tetapi langsung ke REPL — untuk menjalankan ulang main.py Anda harus mereset penuh papan.

Menjatuhkan boot.py atau main.py ke kartu SD menggantikan salinan di flash tanpa menyentuhnya — kedua file dicari di direktori boot (/sdcard saat kartu dipasang, jika tidak /flash).

main.py default yang dikirimkan pada papan yang baru di-flash hanya mengedipkan saluran biru LED RGB pengguna sebagai heartbeat (dua pulsa pendek, jeda pendek), sehingga Anda dapat mengetahui firmware booted dengan bersih tanpa host yang terpasang.

sys.path diperluas untuk menyertakan ketiga sistem file dan subdirektori lib/-nya, sehingga modul yang dapat diimpor dapat berada di /flash/lib, /sdcard/lib, atau /rom/lib.

Untuk memaksa sistem mengabaikan kartu SD yang dimasukkan (misalnya untuk menjalankan flash main.py bahkan dengan kartu hadir), buat file kosong bernama SKIPSD di root /flash.

Ketika terhubung melalui USB, filesystem boot (/sdcard jika kartu ada, jika tidak /flash) juga dienumerasi sebagai drive penyimpanan massal USB di host, memungkinkan Anda mengedit boot.py, main.py, dan file lainnya secara langsung. Eject drive sebelum mereset kamera agar host membuang cache tulisannya.

Catatan

Karena OS memperlakukan drive sebagai perangkat blok pasif, file yang dibuat atau dimodifikasi oleh kode yang berjalan di OpenMV Cam tidak akan muncul hingga host memasang ulang drive. Jika OS dan OpenMV Cam menulis ke filesystem yang sama secara bersamaan, OS akan menang dan menimpa perubahan yang dibuat oleh kamera. Gunakan kartu SD untuk data apa pun yang ditulis kembali oleh skrip, dan pasang ulang sebelum membaca file-file tersebut dari host.

Catatan

Saluran merah LED RGB pengguna mungkin menyala sebentar saat host membaca dari atau menulis ke drive penyimpanan massal USB — ini adalah indikator aktivitas yang digerakkan firmware, bukan kesalahan.

Ukuran penyimpanan¶

RT1062 dikirimkan dengan:

/flash — sistem file FAT 4 MB, baca/tulis.
/rom — ROMFS hanya‑baca, dipetakan ke memori 8 MB, digunakan untuk mengirimkan skrip dan model ML yang mendapat manfaat dari akses mmap zero‑copy.
/sdcard — ukuran penuh kartu microSD yang dimasukkan (jika ada), baca/tulis.

Indikator hard‑fault¶

Jika LED RGB pengguna bersepeda cepat melalui semua warna — cukup cepat sehingga terlihat seperti LED putih berkelip daripada warna yang berbeda — firmware telah mengalami hard fault yang tidak dapat dipulihkan. Reflash firmware untuk memulihkan; jika reflash tidak membantu, papan mungkin rusak secara fisik.

Pustaka perangkat lunak¶

Lihat indeks pustaka untuk daftar lengkap modul — termasuk modul mana yang unik untuk build RT1062.