machine — funktioner relaterade till hårdvaran

Modulen machine innehåller specifika funktioner relaterade till hårdvaran på ett visst kort. De flesta funktionerna i denna modul gör det möjligt att uppnå direkt och obegränsad åtkomst till och kontroll av hårdvarublock i ett system (som CPU, timers, bussar, etc.).

Minnesåtkomst

Modulen exponerar tre indexerbara objekt som används för rå minnesåtkomst. Var och en beter sig som en gles array indexerad efter byteadress: value = memN[addr] läser, memN[addr] = value skriver. Adressen är alltid en byteadress, oavsett åtkomstbredd.

machine.mem8

Indexerbar 8-bitars minnesåtkomst. mem8[addr] läser en int i intervallet 0-255 från byten vid addr; mem8[addr] = value skriver de låga 8 bitarna av value. addr måste vara justerad till 1 byte (valfri adress).

machine.mem16

Indexerbar 16-bitars (halvord) minnesåtkomst. mem16[addr] läser en int i intervallet 0-65535; mem16[addr] = value skriver de låga 16 bitarna. addr måste vara justerad till 2 byte.

machine.mem32

Indexerbar 32-bitars (ord) minnesåtkomst. mem32[addr] läser en int i intervallet 0-0xFFFFFFFF; mem32[addr] = value skriver de låga 32 bitarna. addr måste vara justerad till 4 byte.

Exempelanvändning (registren är specifika för en STM32H7-mikrokontroller – på OpenMV Cam H7 / H7 Plus / Pure Thermal är header-stiftet P0 kopplat till PB15):

import machine
from micropython import const

GPIOB = const(0x58020400)
GPIO_BSRR = const(0x18)
GPIO_IDR = const(0x10)

# set P0 (PB15) high via the GPIOB bit-set/reset register
machine.mem32[GPIOB + GPIO_BSRR] = 1 << 15

# read P0 (PB15) directly out of the GPIOB input-data register
value = (machine.mem32[GPIOB + GPIO_IDR] >> 15) & 1

Funktioner relaterade till återställning

machine.reset() → None

Hårdåterställer enheten på ett sätt som liknar att trycka på den externa RESET-knappen.

machine.soft_reset() → None

Utför en mjukåterställning av interpretatorn, vilket raderar alla Python-objekt och återställer Python-heapen.

machine.reset_cause() → int

Hämta orsaken till återställningen. Se konstanter för de möjliga returvärdena.

machine.bootloader(value: int | None = None, /) → NoReturn

Återställ kameran till dess DFU-/seriell-nedladdnings-startladdare, redo att flashas om med ny fast programvara. Detta anrop returnerar aldrig; kortet startar om direkt in i startladdaren.

Argumentet value accepteras för portöverskridande kompatibilitet men ignoreras på alla OpenMV-stödda kort.

Funktioner relaterade till avbrott

Följande funktioner tillåter kontroll över avbrott. Vissa system kräver avbrott för att fungera korrekt, så att inaktivera dem under långa perioder kan äventyra grundläggande funktionalitet, till exempel kan watchdog-timers utlösas oväntat. Avbrott bör endast inaktiveras under en minimal tid och sedan återaktiveras till sitt tidigare tillstånd. Till exempel:

import machine

# Disable interrupts
state = machine.disable_irq()

# Do a small amount of time-critical work here

# Enable interrupts
machine.enable_irq(state)

machine.disable_irq() → int

Inaktivera avbrottsbegäranden. Returnerar det föregående IRQ-tillståndet som bör betraktas som ett ogenomskinligt värde. Detta returvärde bör skickas till funktionen enable_irq() för att återställa avbrott till sitt ursprungliga tillstånd, innan disable_irq() anropades.

machine.enable_irq(state: int) → None

Återaktivera avbrottsbegäranden. Parametern state bör vara det värde som returnerades från det senaste anropet till funktionen disable_irq().

Funktioner relaterade till ström

machine.freq(hz: int | None = None, /) → int | tuple[int, ...]

Returnera MCU:ns klockfrekvenser.

På STM32-portarna (varje OpenMV Cam M4/M7/H7/H7+/PT/N6 och de Arduino-märkta varianterna) är returvärdet en tupel av de interna klockorna i Hz. På STM32N6 (OpenMV Cam N6) är tupeln (CPUCLK, SYSCLK, HCLK, PCLK1, PCLK2, PCLK4, PCLK5); på de andra STM32-kamerorna är den (SYSCLK, HCLK, PCLK1, PCLK2).

På mimxrt-porten (OpenMV Cam RT1062) och alif-porten (OpenMV Cam AE3) är returvärdet ett enda heltal – CPU-frekvensen i Hz.

Att anropa freq(hz) för att ställa in klockan utlöser NotImplementedError på alla OpenMV-stödda kort.

machine.idle() → None

Stänger av klockan till CPU:n, användbart för att minska strömförbrukningen när som helst under korta eller långa perioder. Kringutrustning fortsätter att fungera och exekveringen återupptas så snart något avbrott utlöses, eller som mest en millisekund efter att CPU:n pausades.

Det rekommenderas att anropa denna funktion inuti varje tät loop som kontinuerligt kontrollerar en extern förändring (dvs. polling). Detta minskar strömförbrukningen utan att påverka prestandan nämnvärt. För att minska strömförbrukningen ytterligare, se funktionerna lightsleep(), time.sleep() och time.sleep_ms().

machine.sleep() → None

Anteckning

Denna funktion är föråldrad, använd lightsleep() istället utan argument.

machine.lightsleep(time_ms: int | None = None, /) → None

Stoppa exekveringen och gå in i ett lågeffektstillstånd med fullständig bibehållning av RAM och kringutrustning. MCU-klockan stängs av; när funktionen returnerar återupptas exekveringen från den punkt där lightsleep() anropades med varje delsystem fortfarande i drift.

Om time_ms anges är det den maximala sovtiden i millisekunder. Med eller utan timeout kan exekveringen återupptas tidigare om någon konfigurerad väckningskälla utlöses (ett Pin-IRQ, ett RTC-larm, ett aktiverat kringutrustningsavbrott, …). Väckningskällor måste ställas in före anropet.

Strömbesparingen är mer blygsam än deepsleep() men uppvaknandet är omedelbart och inget tillstånd går förlorat.

machine.deepsleep(time_ms: int | None = None, /) → NoReturn

Stoppa exekveringen och gå in i det djupaste tillgängliga lågeffektstillståndet. Innehållet i RAM, kringutrustningens tillstånd och nätverksanslutningar kan alla gå förlorade. När MCU:n vaknar startar den från början av huvudskriptet, liknande en påslagning eller hårdåterställning; reset_cause() returnerar då DEEPSLEEP_RESET så att skriptet kan skilja ett uppvaknande från deepsleep från andra återställningsorsaker.

Om time_ms anges schemalägger MCU:n ett uppvaknande efter så många millisekunder (eller tidigare, om en annan konfigurerad väckningskälla utlöses först). Skicka ingenting för att sova tills en extern väckningskälla utlöses.

Detta anrop returnerar aldrig – hantera återupptagen exekvering högst upp i huvudskriptet, villkorat av reset_cause().

Diverse funktioner

machine.unique_id() → bytes

Returnera ett bytes-objekt som innehåller en unik identifierare för detta kort. Värdet läses ut från MCU:ns hårdvara (vanligtvis det fabriksprogrammerade enhetsserienumret), så det är stabilt mellan omstarter och skiljer sig från ett kort till nästa.

Längden beror på MCU-familjen – 12 byte på STM32, 8 byte på mimxrt- och alif-portarna. Om din applikation behöver ett ID med fast längd, skiva eller hasha det returnerade värdet.

machine.time_pulse_us(pin: Pin, pulse_level: int, timeout_us: int = 1000000, /) → int

Mät bredden på en enstaka puls på pin och returnera dess varaktighet i mikrosekunder.

pin måste vara konfigurerad som en digital ingång.

pulse_level är pulspolariteten som ska tidsmätas: 1 för en hög puls, 0 för en låg puls.

Funktionen arbetar i två faser. Först, om stiftet inte redan är vid pulse_level, väntar den på att stiftet ska övergå till pulse_level (början av pulsen). Sedan mäter den tiden stiftet stannar vid pulse_level innan det övergår tillbaka (slutet av pulsen). Den uppmätta tiden returneras i mikrosekunder.

timeout_us begränsar varje fas oberoende (så ett värsta-fall-anrop varar upp till 2 * timeout_us). Vid timeout returnerar funktionen ett negativt värde som identifierar vilken fas som fick timeout:

• -2 – timeout vid väntan på den ledande flanken (stiftet nådde aldrig pulse_level).

• -1 – timeout vid väntan på den efterföljande flanken (pulsen var längre än timeout_us).

machine.bitstream(pin: Pin, encoding: int, timing: tuple, data: bytes, /) → None

Sänder data genom bit-banging av det angivna pin. Argumentet encoding anger hur bitarna kodas, och timing är en kodningsspecifik tidsspecifikation.

De kodningar som stöds är:

• 0 för pulslängdsmodulering av typen ”high low”. Detta sänder 0- och 1-bitar som tidsstyrda pulser, med början på den mest signifikanta biten. timing måste vara en fyr-tupel av nanosekunder i formatet (high_time_0, low_time_0, high_time_1, low_time_1). Till exempel är (400, 850, 800, 450) tidsspecifikationen för WS2812 RGB-lysdioder vid 800kHz.

Tidsprecisionen är hårdvaruberoende; snabbare MCU:er producerar tätare pulser (vanligtvis tiotals nanosekunder).

Anteckning

För att styra WS2812-/NeoPixel-remsor, se modulen neopixel för ett API på högre nivå.

Konstanter

Konstanterna nedan returneras av reset_cause() och identifierar varför MCU:n senast återställdes. Tillgängliga på STM32- och mimxrt-portarna; alif-porten (OpenMV Cam AE3) exponerar för närvarande inte konstanter för återställningsorsak och dess reset_cause() returnerar alltid 0.

machine.PWRON_RESET: int

Återställning orsakad av att ström tillförs chippet. STM32- och mimxrt-portarna.

machine.WDT_RESET: int

Återställning orsakad av att watchdog-timern löper ut. STM32- och mimxrt-portarna.

machine.SOFT_RESET: int

Återställning orsakad av soft_reset() (Python-interpretatorn startades om utan en hårdvaruåterställning). STM32- och mimxrt-portarna.

machine.HARD_RESET: int

Återställning orsakad av att NRST-stiftet aktiverats (extern återställningsknapp). Endast STM32-portarna.

machine.DEEPSLEEP_RESET: int

Återställning orsakad av uppvaknande från deep-sleep. Endast STM32-portarna.

Klasser

• class Pin – styr I/O-stift
• class Signal – styr och avläs externa I/O-enheter
• klass LED – portabel styrning av inbyggd LED
• class ADC – analog till digital-konvertering
• klass PWM – pulsbreddsmodulering
• class UART – duplex seriell kommunikationsbuss
• class SPI – ett bussprotokoll för Serial Peripheral Interface (styrenhetssidan)
• class SoftSPI – mjukvaruemulerad SPI-buss
• class I2C – ett tvåtrådigt seriellt protokoll
• class SoftI2C – en mjukvaruemulerad I2C-buss
• class I2CTarget – en I2C-målenhet
• klass I2S – Inter-IC Sound-bussprotokoll
• class CAN – protokollet Controller Area Network
• class RTC – realtidsklocka
• class Timer – virtuell periodisk/engångstimer
• class WDT – watchdog-timer
• class SDCard – drivrutin för SD-/MMC-kort
• klassen Counter – pulsräknare
• klassen Encoder – kvadraturavkodare