OpenMV Pure Thermal¶

Az OpenMV Pure Thermal egy teljes rendszerű hőkamerás panel, amely az STMicroelectronics STM32H743 (Cortex‑M7 @ 480 MHz) köré épül, 64 MB külső SDRAM‑mal, 32 MB QSPI flash memóriával, hardveres JPEG kodekkel, egy 4,3”-os 800×480-as IPS kapacitív érintőképernyővel, HDMI kimenettel, FLIR® Lepton® hőkamera‑foglalattal és egy 5MP-es OV5640 látható fényű kamerával. Emellett Wi‑Fi‑t, microSD‑foglalatot, lézeres távolságmérőt, hangjelzőt és nagy teljesítményű fehér megvilágítót is tartalmaz.

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

Kiemelt jellemzők¶

STMicroelectronics STM32H743XI Cortex‑M7 480 MHz-en.
Hardveres JPEG kódoló/dekódoló.
64 MB külső SDRAM (~400 MB/s) plusz 1 MB belső SRAM.
2 MB belső flash memória + 32 MB külső QSPI flash memória (~50 MB/s olvasás).
OV5640 5MP-es rolling‑shutter látható fényű érzékelő.
FLIR® Lepton® foglalat — bármilyen Lepton 1/2/2.5/3/3.5 modult fogad, radiometrikus vagy nem radiometrikus változatban, képpontonkénti hőmérséklettel Celsius-fokban.
4,3”-os 800×480-as IPS kapacitív érintőképernyő (24‑bites szín @ 60 Hz) akár 5‑pontos gesztustámogatással.
HDMI kimenet TFP410 DVI szerializálón keresztül — akár 1280×720 @ 60 Hz.
Wi‑Fi WINC1500-on keresztül; az MJPEG over RTSP alapból támogatott.
Full‑speed USB‑C (12 Mb/s, 900 mA áramkorlátozással) — a gazdagép felé VCP + USB háttértárként jelenik meg, és a töltést is kezeli.
microSD foglalat — SD akár 2 GB-ig, SDHC akár 32 GB-ig, SDXC akár 2 TB-ig.
VL53L1CX lézeres távolságmérő (akár ~4 m).
Hangjelző szoftveresen vezérelt hangerővel / frekvenciával.
Nagy teljesítményű fehér LED megvilágító a felhasználói RGB állapotjelző LED mellett.
LiPo akkumulátor-csatlakozó USB-s töltéssel 500 mA-en.
10 I/O láb, 5 V-tűrő 3,3 V kimenettel, 25 mA lábanként (összesen 120 mA), megszakításra képes. A P6 nem 5 V-tűrő, ha ADC vagy DAC módban használják.
ARM 10 lábú SWD csatlakozó ST‑LINK / J‑Link hibakereséshez.
Qwiic csatlakozó I²C perifériákhoz.

Megjegyzés

A panel bal alsó szélén egy nyílás található egy opcionális ¼”–20 állványanyához. Gyárilag nincs beszerelve — forrassz egyet a nyílásba, ha a panelt egy szabványos kamera-állványra szeretnéd rögzíteni.

Lábkiosztás¶

Lábkiosztási hivatkozás¶

Láb neve	Funkció
P0	UART1 RX / SPI2 MOSI
P1	UART1 TX / SPI2 MISO
P2	SPI2 SCK / FDCAN2 TX
P3	SPI2 NSS (CS) / FDCAN2 RX
P4	I2C2 SCL / UART3 TX / TIM2 CH3
P5	I2C2 SDA / UART3 RX / TIM2 CH4
P6	ADC / DAC / TIM2 CH1
P7	I2C4 SCL / TIM4 CH1
P8	I2C4 SDA / TIM4 CH2
P9	digitális I/O
RESET	húzd GND-re a panel újraindításához
SYN	képkocka‑szinkron pad — nincs bekötve
VIN	shield VIN pad — nincs bekötve
BOOT0	húzd 3,3 V-ra bekapcsoláskor DFU / ROM rendszerbetöltőhöz
BUZZER	fedélzeti piezo hangjelző (TIM2/PWM vezérelt)
LED_RED	RGB állapotjelző LED piros csatorna (aktív alacsony)
LED_GREEN	RGB állapotjelző LED zöld csatorna (aktív alacsony)
LED_BLUE	RGB állapotjelző LED kék csatorna (aktív alacsony)
LED_WHITE	nagy teljesítményű fehér megvilágító LED

Megjegyzés

A shielden/fejlécen lévő SYN és VIN padeknek nincs elektromos bekötésük a Pure Thermalon — csak a fejléc-kompatibilitás miatt vannak ott. Ehelyett tápláld a panelt USB‑C-n vagy a fedélzeti LiPo akkumulátor-csatlakozón keresztül (lásd a Tápláb részt lentebb). Vedd figyelembe azt is, hogy a VIN pad VBAT felirattal szerepel a panelen (címkézési hiba) — a pozíció a szabványos OpenMV‑fejléc VIN lábáé, és egyik módon sincs bekötve.

Tápláb¶

3.3V — stabilizált 3,3 V-os sín. Akár 250 mA áll rendelkezésre a shieldek számára.
GND — közös föld.

A Pure Thermalt USB‑C-n vagy a fedélzeti LiPo akkumulátor-csatlakozón keresztül táplálják. Az USB‑C port összesen 900 mA-re áramkorlátozott, és a LiPo töltését is 500 mA-en kezeli, így egy akkumulátor USB mellé csatlakoztatása is támogatott.

A fedélzeti bekapcsológomb be- és kikapcsolja a rendszer tápsínjeit, és attól függetlenül működik, hogy a panel USB-ről vagy a LiPo-ról kapja a tápot. Tartsd nyomva a gombot pár másodpercig az állapot váltásához — a gyors megnyomást figyelmen kívül hagyja, hogy megakadályozza a véletlen kikapcsolást.

A forrás kiválasztása két egyszerű szabályt követ:

Az akkumulátor csak akkor táplálja a panelt, ha feszültsége 3 V felett van. E küszöbérték alatt a fedélzeti PMIC lecsatlakoztatja az akkumulátort, hogy megvédje a túlzott lemerüléstől.
Ha USB van jelen, az USB táplálja a panelt, és bármely csatlakoztatott LiPo a háttérben töltődik.

A LiPo csatlakozó fordított feszültség elleni védelmet is tartalmaz, így az akkumulátor fordított bekötése nem károsítja a panelt.

Megjegyzés

A panel az akkumulátor feszültségét és egy akkumulátor áram-érzékelő jelet is visszavezet az MCU ADC csatornáira, de egyik firmware-támogatása sem készült még el.

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

RESET — húzd GND-re a panel újraindításához. A Pure Thermalon van egy dedikált RESET gomb is, amely ugyanazt csinálja.
BOOT0 — húzd 3,3 V-ra a panel táplálása közben az STM32 ROM rendszerbetöltőbe (DFU mód) való belépéshez. Az OpenMV IDE ezt a módot használja a fedélzeti rendszerbetöltő újraflashelésére. A panelen lévő dedikált BOOT0 gomb ugyanazt csinálja — tartsd nyomva a táplálás közben.

A panel egy SWD hibakereső fejlécet (RST / SWCLK / SWDIO / SWO) tesz elérhetővé a GPIO fejléc mellett, amely kompatibilis az ST‑LINK és SEGGER J‑Link adapterekkel. Egy különálló ARM 10 lábú SWD csatlakozó is fel van szerelve — ugyanazokat az SWD jeleket hordozza (nincs teljes JTAG), de a szabványos 0,05”-os 10 lábú formátumban.

Megjegyzés

Az SWO trace láb a fedélzeti FLIR® Lepton® SPI órajelével van megosztva. Az SWO nem használható a Leptonnal egyidejűleg — válaszd az egyiket vagy a másikat.

Egy harmadik PURE Modules Debug csatlakozó is fel van szerelve a panelen. Néhány hibakeresési célú jelet (SWCLK, SWDIO, RST, SPI2_MISO, SPI2_MOSI, VBUS, 3,3 V, GND és két GPIO láb) tesz elérhetővé kiegészítő modulok csatlakoztatásához. Az ezen a csatlakozón lévő két GPIO lábat egy belső bit‑bangelt I²C busz hajtja meg, nem pedig egy hardveres periféria.

Mindhárom hibakereső csatlakozó (az inline SWD fejléc, az ARM 10 lábú SWD csatlakozó és a PURE Modules Debug csatlakozó) a 3,3 V-hoz van viszonyítva — győződj meg róla, hogy a hibakereső adaptered 3,3 V-os logikára van konfigurálva, mielőtt csatlakoztatod.

Fedélzeti perifériák¶

LED-ek¶

A Pure Thermalon három LED található a panelen:

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()
```
Fehér megvilágító — a LED_WHITE-on keresztül meghajtva. A LED_WHITE hardveresen aktív magasként van bekötve, miközben a firmware minden más fedélzeti LED-et aktív alacsonyként kezel, ezért a low() / high() metódusokat használd a on() / off() helyett (amelyek megfordítanák a logikát):
```
from machine import LED

light = LED("LED_WHITE")
light.low()    # turn the white LED ON
light.high()   # turn the white LED OFF
```

Töltésjelző LED — közvetlenül a fedélzeti energiagazdálkodási hardver hajtja meg, nincs szoftveres vezérlés. Akkor is működik, ha a rendszer tápsínjei be vannak kapcsolva, és akkor is, ha ki (azaz a bekapcsológomb bármelyik állásában).

Szín	Jelentés
Kék	töltés — lásd a hibajegyzéket: lehet, hogy nem kapcsol ki a töltés befejeztével
Zöld	töltés kész — lásd a hibajegyzéket: lehet, hogy nem aktiválódik megbízhatóan
Piros	alacsony akkumulátor (≤ 3,2 V, csak amikor nem tölt aktívan)

Hangjelző¶

A fedélzeti piezo hangjelző egy időzítő-csatornához van bekötve — hajtsd meg a machine.PWM segítségével szoftveresen vezérelt frekvenciájú (hangmagasságú) és kitöltési tényezőjű (hangerejű) hangokhoz:

import time
from machine import Pin, PWM

beep = PWM(Pin("BUZZER"), freq=2_000, duty_u16=32768)   # ~50% duty
time.sleep_ms(500)                                      # sound for 0.5 s
beep.deinit()

Kamera-érzékelő¶

Az OV5640 az elsődleges CSI a Pure Thermalon — add át a cid=csi.OV5640-et az explicit címzéséhez:

import csi

cam = csi.CSI(cid=csi.OV5640)
cam.reset(hard=True)
cam.pixformat(csi.RGB565)
cam.framesize(csi.WVGA)
cam.snapshot(time=2000)       # let auto‑exposure settle

while True:
    img = cam.snapshot()

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

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

Az OV5640 hangtekercs-aktuátoros (voice-coil-actuator) autofókuszos objektívvel rendelkezik. Indíts el egy egyszeri autofókusz-menetet a csi.CSI.ioctl-on keresztül a csi.IOCTL_TRIGGER_AUTO_FOCUS-szal — az érzékelő egyszer végigfuttatja a fókuszmotort, és ráélesít arra, ami előtte van:

cam.ioctl(csi.IOCTL_TRIGGER_AUTO_FOCUS)

Add ki újra az ioctl-t, valahányszor a jelenet változik — az autofókusz egyszeri, nem folyamatos.

Megjegyzés

Az OV5640 STROBE kimenete (szinkronizált vaku / IR megvilágításhoz használt) be van kötve az MCU-ba a Pure Thermalon, de a firmware-támogatása még nem készült el.

Hőkamera-érzékelő¶

A FLIR® Lepton® foglalat egy második CSI-ként jelenik meg ugyanazon a csi — kameraérzékelők API-n keresztül. Add át a cid=csi.LEPTON-t a címzéséhez, és hagyd ki a hardveres újraindítást:

import csi

lepton = csi.CSI(cid=csi.LEPTON)
lepton.reset(hard=False)
lepton.pixformat(csi.GRAYSCALE)
lepton.framesize(csi.QVGA)

while True:
    img = lepton.snapshot()

Megjegyzés

A Lepton VSYNC kimenete (egy impulzus hőkockánként) be van kötve az MCU-ba a Pure Thermalon, de a firmware-támogatása még nem készült el.

Mindkét CSI futhat egymás mellett. Az alábbi példa egy színes képkockát húz be az OV5640-ből és egy hőkockát a Leptonból, majd a Leptont a színes képkocka tetejére vetíti egy Ironbow paletta és egy alfa-maszk segítségével, amely alacsony intenzitásnál átlátszóra halványul:

import csi
import image
import math

alpha_pal = image.Image(256, 1, image.GRAYSCALE)
for i in range(256):
    alpha_pal[i] = int(math.pow((i / 255), 2) * 255)

csi0 = csi.CSI()
csi0.reset(hard=True)
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.WVGA)

csi1 = csi.CSI(cid=csi.LEPTON)
csi1.reset(hard=False)
csi1.pixformat(csi.GRAYSCALE)
csi1.framesize(csi.QVGA)

img1 = image.Image(csi1.width(), csi1.height(), csi1.pixformat())

while True:
    img0 = csi0.snapshot()
    csi1.snapshot(blocking=False, image=img1)
    img0.draw_image(
        img1, 0, 0,
        color_palette=image.PALETTE_IRONBOW,
        alpha_palette=alpha_pal,
        hint=image.BILINEAR,
    )

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 működtessen. 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 az észlelt arcot és hat tereppontját vetíti rá a látható fényű kamera minden képkockájára:

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

Lézeres távolságmérő¶

A fedélzeti ST VL53L1CX time‑of‑flight távolságmérő az I²C 2-es buszra van bekötve. Használd a befagyasztott vl53l1x — VL53L1X ToF távolságérzékelő illesztőprogram illesztőprogramot akár ~4 m-ig terjedő távolságmérésekhez:

import time
from machine import I2C
import vl53l1x

bus = I2C(2)
tof = vl53l1x.VL53L1X(bus)

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

LCD kimenet¶

A 4,3”-os fedélzeti LCD 800 × 480 (WVGA) felbontású, és a display — kijelzőmeghajtó modul RGB kijelző interfészén keresztül van meghajtva — add át a framesize=display.FWVGA-t a natív felbontásához igazodva:

import display

lcd = display.RGBDisplay(framesize=display.FWVGA, refresh=60)
lcd.backlight(True)           # turn the LCD backlight on
lcd.write(img)

A háttérvilágítás egy GPIO-hoz van bekötve, így a backlight() elfogad True / False értéket (vagy bármilyen 0–100 közötti értéket, ahol a 0 a kikapcsolt, és bármilyen nemnulla a bekapcsolt állapot):

lcd.backlight(False)           # turn the backlight off
lcd.backlight(True)            # back on

Érintőképernyő¶

A kapacitív érintésvezérlő az FT5X06; a multitouch pozíciók és gesztusesemények a ft5x06 — Érintőképernyő-meghajtó-on keresztül érhetők el. Regisztrálj egy visszahívást az érintésekre való reagáláshoz, és olvasd ki benne az aktív pontokat:

import ft5x06

touch = ft5x06.FT5X06()

def on_touch(n):
    for i in range(n):
        x = touch.get_point_x(i)
        y = touch.get_point_y(i)
        print("touch", i, "at", x, y)

    gesture = touch.get_gesture()
    if gesture != ft5x06.GESTURE_NONE:
        print("gesture:", gesture)

touch.touch_callback(on_touch)

HDMI kimenet¶

A firmware az LCD képkocka-pufferét a fedélzeti tfp410 — DVI/HDMI vezérlő HDMI szerializálóra is kivezeti, így egy külső monitor tükrözi azt, ami az LCD-n van. Példányosítsd a tfp410.TFP410-et a HDMI kimenet engedélyezéséhez:

import tfp410

hdmi = tfp410.TFP410()

Ha csak HDMI kimenetet szeretnél, és nem érdekel a fedélzeti LCD, kapcsold ki a háttérvilágítást, és emeld a képkocka-puffer felbontását WVGA fölé. A TFP410 akár 1280×720 @ 60 Hz-et támogat, így például:

lcd = display.RGBDisplay(framesize=display.HD, refresh=60)
lcd.backlight(False)         # the on‑board LCD can't render HD
hdmi = tfp410.TFP410()

A fedélzeti panel 800×480-on rögzített, így bármi WVGA fölött csak a külső HDMI monitoron értelmes.

Ahhoz, hogy megtudd, mikor csatlakoztattak vagy húztak ki egy HDMI monitort, regisztrálj egy hot‑plug visszahívást a TFP410-en. A visszahívás True értékkel sül el csatlakozáskor és False értékkel lecsatlakozáskor:

def on_hotplug(connected):
    print("HDMI", "connected" if connected else "disconnected")

hdmi.hotplug_callback(on_hotplug)

A csatlakozási állapotot bármikor le is kérdezheted a isconnected() segítségével (csak akkor, ha nincs visszahívás regisztrálva).

A HDMI port a DDC (display data) és CEC (consumer electronics control) csatornákat is hordozza, amelyek a class DisplayData – kijelzőadatok osztályon keresztül érhetők el. Használd a csatlakoztatott monitor EDID blokkjának kiolvasására (hogy igazodni tudj a natív felbontásához / frissítési frekvenciájához), vagy CEC képkockák küldésére/fogadására, hogy más, ugyanazon a vezetéken lévő HDMI eszközöket vezérelj:

from display import DisplayData

dd = DisplayData(cec=True, ddc=True)

edid = dd.display_id()        # EDID bytes from the monitor
print(len(edid), "byte EDID")

# Send a CEC "image view on" command (opcode 0x04) from address 1 to address 0
dd.send_frame(0, 1, b"\x04")

# ...or wait for an incoming CEC frame addressed to us (logical address 1)
src, data = dd.receive_frame(1, timeout=5_000)
print("CEC from", src, ":", data)

Wi‑Fi¶

A Wi‑Fi egy Microchip WINC1500 modulon fut, amely a class WINC – WiFi shield illesztőprogram interfészen keresztül érhető el:

import network, time

wlan = network.WINC()
wlan.connect("ssid", "password")
while not wlan.isconnected():
    time.sleep(1)
print("Wi‑Fi IP:", wlan.ipconfig("addr4")[0])

Megjegyzés

Alkatrészhiány miatt néhány Pure Thermal egységet a WINC1500 modul beszerelése nélkül szállítottak. Ha a network.WINC hibát ad, vagy soha nem csatlakozik, ellenőrizd a panelen a hiányzó Wi‑Fi modult — a kamera többi része nélküle is pontosan ugyanúgy működik.

microSD kártya¶

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

import os

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

Busz-hivatkozás¶

GPIO¶

Használd a machine.Pin-t bármely feliratozott láb olvasásához vagy meghajtásához. A kimenetek 3,3 V-os CMOS-ok, a bemeneti oldalon 5 V-tűrők, és lábanként akár 25 mA-t tudnak nyelni/szolgáltatni (összesen 120 mA-t a teljes fejlécen).

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ármely bemeneti láb megszakítást is kiválthat él-átmeneteknél:

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	P1	P0
UART3	P4	P5

from machine import UART

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

I²C¶

Busz	SCL	SDA
I2C2	P4	P5
I2C4	P7	P8

from machine import I2C

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

Ugyanez 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(2, addr=0x42, mem=buf)

A fedélzeti Qwiic csatlakozó az egyik ilyen I²C buszt vezeti ki plug‑and‑play modulok számára. A Qwiic vonal nyitott nyelőjű (open‑drain) tranzisztorokon keresztül 5 V-ra van szintelt, így a busz csak standard módra (100 kHz) és fast módra (400 kHz) korlátozott — ne próbálj fast‑mode‑plus vagy magasabb sebességeket átküldeni a Qwiic fejlécen.

A Qwiic csatlakozó 5 V-ot ad ki a csatlakoztatott modulok táplálásához; nem használható magának a Pure Thermalnak a táplálására — ehelyett tápláld a panelt USB‑C-n vagy a LiPo akkumulátor-csatlakozón keresztül.

SPI¶

Busz	MOSI	MISO	SCK	CS
SPI2	P0	P1	P2	P3

from machine import SPI
from machine import Pin

spi = SPI(2, 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 (FDCAN)¶

Busz	TX	RX
FDCAN2	P2	P3

from machine import CAN

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

ADC és DAC¶

A P6 az egyetlen felhasználói analóg láb. Használható akár 12‑bites ADC bemenetként, akár DAC kimenetként.

ADC — teljes skála 3,3 V-on a lábon:

from machine import ADC
import time

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

DAC — a pyb.DAC-en keresztül. A 8‑bites érték 0–3,3 V-ot fed le:

from pyb import DAC

dac = DAC("P6")
voltage = 1.65
dac.write(int(voltage / 3.3 * 255))

ADC vagy DAC módban a P6 csak 3,3 V-tűrő — ne adj rá 5 V-ot.

PWM¶

Láb	Időzítő / csatorna
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM2 CH1
P7	TIM4 CH1
P8	TIM4 CH2

Megjegyzés

A TIM1 fenntartott a firmware számára a kamera-érzékelő képpont-órajelének előállításához, így a P0/P1/P2-n fizikailag jelen lévő TIM1 csatornák nem használhatók felhasználói PWM-hez a kamera megtörése nélkül.

A TIM4 meg van osztva a pyb.Servo-val — egy szervó példányosítása az egész időzítőt 50 Hz-es működésre konfigurálja át, ezért ne keverd a machine.PWM-et a P7/P8-on a pyb.Servo-val ugyanabban a szkriptben.

Hajtsd meg bármelyiküket a machine.PWM-en keresztül:

from machine import Pin, PWM

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

Szoftveres bit‑bangelt buszok¶

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

Hőérzékelő (panelen kívüli)¶

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

MLX90621 — 16 × 4 IR mátrix
MLX90640 — 32 × 24 IR mátrix
MLX90641 — 16 × 12 IR mátrix
AMG8833 — 8 × 8 IR mátrix

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

import time
import image
import fir

fir.init()                          # auto‑detects the sensor
clock = time.clock()

while True:
    clock.tick()
    try:
        img = fir.snapshot(x_scale=5, y_scale=5,
                           color_palette=image.PALETTE_IRONBOW,
                           hint=image.BICUBIC,
                           copy_to_fb=True)
    except OSError:
        continue
    print(clock.fps())

A fir illesztőprogram csak I²C 2-n kommunikál az érzékelővel — kösd be a modult a P4 (SCL) és P5 (SDA) lábakra.

Időzítés¶

time¶

import time

time.sleep(1)
time.sleep_ms(500)
time.sleep_us(10)

start = time.ticks_ms()
elapsed = time.ticks_diff(time.ticks_ms(), start)

Virtuális időzítők¶

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ívd meg a deinit()-et a leállításhoz és a slot felszabadításához.

Valós idejű óra¶

from machine import RTC

rtc = RTC()
rtc.datetime((2026, 4, 30, 4, 12, 0, 0, 0))
print(rtc.datetime())

Ha egy LiPo akkumulátor van csatlakoztatva, az RTC akkor is tartja az időt, amikor a rendszer tápsínjei ki vannak kapcsolva (a fedélzeti bekapcsológombbal lekapcsolva). Ha csak USB van bedugva, a bekapcsológomb megnyomása az RTC tápellátását is megszakítja — így a falióra szerinti idő nem éli túl a tápkapcsolást csatlakoztatott akkumulátor nélkül.

Watchdog¶

from machine import WDT

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

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

USB rendszerbetöltő ablak¶

Minden bekapcsoláskor a kamera lefuttat egy rövid rendszerbetöltőt (néhány másodperc), amely lehetővé teszi, hogy az OpenMV IDE frissítse a firmware-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 kérésre újra beléphet a rendszerbetöltőbe a machine.bootloader() meghívásával.

Fájlrendszer és indítási sorrend¶

A Pure Thermal firmware indításkor akár három fájlrendszert csatol fel:

Belső flash memória — mindig a /flash-en van csatolva. Alapból a main.py-t és a README.txt-t tartalmazza; a legelső indításkor jön létre.
microSD kártya — ha egy kártya van behelyezve, az a /sdcard-on csatolódik.
ROMFS — csak olvasható, memóriába leképezett fájlrendszer a /rom-on, amely nagy adat-eszközök (pl. AI modellek) szállítására szolgál, amelyek profitálnak a másolás nélküli hozzáférésből. A MicroPython automatikusan felcsatolja indításkor, mielőtt bármilyen felhasználói Python lefutna.

A felcsatolás után a munkakönyvtár a /sdcard-ra állítódik, ha 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 újraindításkor lefut.
A main.py csak hidegindításkor fut le, közvetlenül a boot.py után.

Egy boot.py vagy main.py SD kártyára helyezése felülírja a flash memóriában lévő példányt anélkül, hogy hozzányúlna.

USB-n keresztül csatlakoztatva az indítási fájlrendszer (a /sdcard, ha kártya van jelen, egyébként a /flash) USB háttértár-meghajtóként is megjelenik a gazdagépen. Vesd ki a meghajtót, mielőtt újraindítod a kamerát, hogy a gazdagép kiürítse a gyorsítótárazott írásait.

Megjegyzés

Az OpenMV Cam-en futó kód által létrehozott vagy módosított fájlok nem jelennek meg a gazdagépen, amíg a meghajtót újra fel nem csatolják. Használd az SD kártyát bármilyen adathoz, amelyet a szkript visszaír, és csatold fel újra, mielőtt ezeket a fájlokat a gazdagépről olvasnád.

Tárhelyméretek¶

A Pure Thermal a következőkkel érkezik:

/flash — 24 MB FAT fájlrendszer, olvasható/írható.
/rom — 8 MB csak olvasható, memóriába leképezett ROMFS, amely olyan szkriptek és ML modellek szállítására szolgál, amelyek profitálnak a másolás nélküli mmap hozzáférésből.
/sdcard — a behelyezett microSD kártya teljes mérete (amikor jelen van), olvasható/írható.

Hard‑fault jelző¶

Ha a felhasználói RGB LED gyorsan végigciklusozik az összes színen — elég gyorsan ahhoz, hogy inkább egy villódzó fehér LED-nek tűnjön, semmint különálló árnyalatoknak —, akkor a firmware egy helyrehozhatatlan hard fault-ba ütközött. A helyreállításhoz flasheld újra a firmware-t.

Hardveres hibajegyzék¶

Néhány panel-szintű furcsaságot a Pure Thermal hardveres hibajegyzék dokumentál. Fontos tudnivalók:

Akkumulátor-csatlakozó interferencia — a PCB-n lévő alkatrészek közvetlenül a LiPo akkumulátor-csatlakozó alatt helyezkednek el, és az akkumulátor-kábel dugóján kiálló ék beleakadhat ezekbe, amikor a kábelt eltávolítják, néha lerántva alkatrészeket a panelről. Vágd le az éket a kábel dugójáról oldalcsípő fogóval az első használat előtt.
Az RTC leáll, amíg a panel ki van kapcsolva — a 32 kHz-es kvarcon (Y2) lévő terhelő kapacitás túl nagy. A C96 és C97 (a kvarcot körülvevő pár az STM32 mellett) eltávolítása lehetővé teszi, hogy az RTC tartalék tápellátáson tovább működjön. A legtöbb panelt már eltávolított kondenzátorokkal szállítják; ha az RTC elveszíti az időt, amikor kihúzzák, ellenőrizd ezeket a pozíciókat. A teljes szálhoz lásd a #1536 és #1600 GitHub hibajegyeket.
A töltésjelző LED kék marad — a töltő bárhol befejezheti a töltési ciklust 4,15 V és 4,19 V között anélkül, hogy a jelzőt kékről (töltés) zöldre (feltöltve) váltaná. Az akkumulátor ilyen esetben is teljesen fel van töltve; bízz egy feszültségmérésben, ne a LED-ben.
A felirat VIN-t VBAT-ként címkézi tévesen — a szabványos OpenMV‑fejléc VIN pozíciójában lévő pad VBAT felirattal szerepel a Pure Thermalon. A címke hibás, de a gyakorlatban nem számít, mert a padnek egyik módon sincs elektromos bekötése.

Szoftverkönyvtárak¶

A modulok teljes listájáért lásd a könyvtár-indexet — beleértve azt is, hogy melyek egyediek a Pure Thermal buildhez.