Divers périphériques pyb

Vue d'ensemble

En tant que microcontrôleur monopuce, contrôler le port IO, l'IIC, le SPI, le CAN, le PWM et les timers est tout à fait supportable. De plus, utiliser le langage python est un moyen simple de les manipuler sans se soucier des registres.

Remarque : comme MicroPython peut fonctionner sur de nombreuses plateformes, le module pyb, pyboard, était à l'origine basé sur STM32, mais par la suite esp8266 et esp32, ainsi que la série nrf, ont été ajoutés. Leurs architectures sont différentes de celle de STM32. C'est pourquoi l'équipe officielle a unifié le module machine, plus universel, et pyb finira par être abandonné.

Pour l'OpenMV4 H7 Plus / OpenMV4 H7 / OpenMV3, le contrôleur principal est un STM32, utilisant généralement le module pyb.

Le tout dernier OpenMV RT1062 sorti en 2024, dont le contrôleur principal est un IMXRT1062, ne prend en charge que le module machine, pas le module pyb. Veuillez utiliser le code correspondant du module machine~

Fonctions couramment utilisées

pyb.delay(50) # délai de 50 millisecondes
pyb.millis() # obtient le nombre de millisecondes écoulées depuis le démarrage

LED

from pyb import LED

led = LED(1) # LED rouge
led.toggle()
led.on()# allumer
led.off()# éteindre

LED(1) -> LED rouge\ LED(2) -> LED verte\ LED(3) -> LED bleue\ LED(4) -> LED infrarouge, deux

Le module pyb ne peut pas être utilisé sur OpenMV RT, seul le module machine suivant peut être utilisé :

from machine import LED
import time

red_led = LED("LED_RED")
green_led = LED("LED_GREEN")
blue_led = LED("LED_BLUE")
blue_led.off()
green_led.off()
red_led.off()

while(1):
    green_led.toggle()
    red_led.on()
    time.sleep_ms(250)
    red_led.off()
    time.sleep_ms(250)

IO

from pyb import Pin

p_out = Pin('P7', Pin.OUT_PP)# définit p_out comme broche de sortie
p_out.high()# met la broche p_out au niveau haut
p_out.low()# met la broche p_out au niveau bas

p_in = Pin('P7', Pin.IN, Pin.PULL_UP)# définit p_in comme broche d'entrée, et active la résistance de tirage
value = p_in.value() # obtient la valeur, 0 ou 1# lit la valeur de la broche p_in

Le module pyb ne peut pas être utilisé sur OpenMV RT, seul le module machine suivant peut être utilisé :

from machine import Pin

p_out = Pin("P7", Pin.OUT)# définit p_out comme broche de sortie
p_out.high()# met la broche p_out au niveau haut
p_out.low()# met la broche p_out au niveau bas

p_in = Pin("P8", Pin.IN, Pin.PULL_UP)# définit p_in comme broche d'entrée, et active la résistance de tirage
value = p_in.value() # obtient la valeur, 0 ou 1# lit la valeur de la broche p_in

Servomoteur

Tutoriel vidéo 34 - OpenMV contrôle trois servomoteurs : https://singtown.com/learn/50541/

from pyb import Servo

s1 = Servo(1) # servo en position 1 (P7)
s1.angle(45) # se déplace à 45 degrés
s1.angle(-60, 1500) # se déplace à -60 degrés en 1500ms
s1.speed(50) # pour les servos à rotation continue

• Servo(1) -> P7 (PD12)
• Servo(2) -> P8 (PD13)

Ajouté sur OpenMV3 M7 / OpenMV4 H7 :

• Servo(3) -> P9 (PD14)

Remarque : la broche P9 de l'OpenMV4 H7 Plus ne peut pas utiliser le PWM

L'OpenMV RT1062 dispose de quatre broches PWM : P7 P8 P9 P10. Vous ne pouvez pas utiliser le module pyb sur OpenMV RT, seul le module machine suivant peut être utilisé :

# Exemple de contrôle de servomoteur
#
# Cet exemple montre comment utiliser OpenMV pour contrôler un servomoteur
#
# Le système de servocommande nécessite un PWM à 50 Hz, avec une largeur d'impulsion de 1000us à 2000us.

import time
from machine import PWM

# P7 et P8 peuvent partager le même module PWM, ils doivent avoir la même fréquence.
p7 = PWM("P7", freq=50, duty_ns=(2000 * 1000))
p8 = PWM("P8", freq=50, duty_ns=(2000 * 1000))

# P9 et P10 peuvent partager le même module PWM, ils doivent avoir la même fréquence.
p9 = PWM("P9", freq=50, duty_ns=(2000 * 1000))
p10 = PWM("P10", freq=50, duty_ns=(2000 * 1000))


while True:
    for i in range(1000, 2000, 100):
        p7.duty_ns(i * 1000)
        p8.duty_ns(i * 1000)
        p9.duty_ns(i * 1000)
        p10.duty_ns(i * 1000)
        time.sleep_ms(1000)

    for i in range(2000, 1000, -100):
        p7.duty_ns(i * 1000)
        p8.duty_ns(i * 1000)
        p9.duty_ns(i * 1000)
        p10.duty_ns(i * 1000)
        time.sleep_ms(1000)

Interruption IO

from pyb import Pin, ExtInt

callback = lambda e: print("intr")
ext = ExtInt(Pin('P7'), ExtInt.IRQ_RISING, Pin.PULL_NONE, callback)

Le module pyb ne peut pas être utilisé sur OpenMV RT, seul le module machine suivant peut être utilisé :

from machine import Pin
import time
pin0 = Pin("P0", Pin.IN, Pin.PULL_UP)
callback = lambda e: print("intr")
pin0.irq(callback, Pin.IRQ_FALLING)

while True:
    time.sleep(1)

Timer

from pyb import Timer

tim = Timer(4, freq=1000)
tim.counter() # obtient la valeur du compteur
tim.freq(0.5) # 0.5 Hz
tim.callback(lambda t: pyb.LED(1).toggle())

Timer 1 Canal 3 Négatif -> P0\ Timer 1 Canal 2 Négatif -> P1\ Timer 1 Canal 1 Négatif -> P2\ Timer 2 Canal 3 Positif -> P4\ Timer 2 Canal 4 Positif -> P5\ Timer 2 Canal 1 Positif -> P6\ Timer 4 Canal 1 Négatif -> P7\ Timer 4 Canal 2 Négatif -> P8

Ajouté sur OpenMV M7 :\ Timer 4 Canal 3 Positif -> P9

Le module pyb ne peut pas être utilisé sur OpenMV RT, seul le module machine suivant peut être utilisé :

from machine import LED
from machine import Timer

blue_led = LED("LED_BLUE")

# Lorsqu'il est appelé, nous recevrons l'objet timer en retour
# Remarque : les fonctions n'ont pas le droit d'allouer de la mémoire dans le callback
def tick(timer):
    blue_led.toggle()

# Le module machine ne prend actuellement en charge que le timer virtuel -1.
tim = Timer(-1, freq=1, callback=tick)  # crée un objet timer — déclenché à 1Hz

PWM

from pyb import Pin, Timer

p = Pin('P7') # P7 dispose de TIM4, CH1
tim = Timer(4, freq=1000)
ch = tim.channel(1, Timer.PWM, pin=p)
ch.pulse_width_percent(50)

Le module pyb ne peut pas être utilisé sur OpenMV RT, seul le module machine suivant peut être utilisé :

from machine import PWM
import time

p7 = PWM("P7", freq=100, duty_u16=32768)

while True:
    for i in range(0, 65536, 256):
        p7.duty_u16(65535 - i)
        time.sleep_ms(10)
    p7.duty_u16(32768)

ADC

from pyb import Pin, ADC

adc = ADC('P6')
adc.read() # lit la valeur, 0-4095

Le module pyb ne peut pas être utilisé sur OpenMV RT, seul le module machine suivant peut être utilisé :

from machine import ADC

adc = ADC('P6')
adc.read_u16()

DAC

from pyb import Pin, DAC

dac = DAC('P6')
dac.write(120) # sortie entre 0 et 255

UART

from pyb import UART

uart = UART(3, 9600)
uart.write('hello')
uart.read(5) # lit jusqu'à 5 octets

UART 3 RX ->; P5 (PB11)\ UART 3 TX -> P4 (PB10)

Ajouté sur OpenMV3 M7 / OpenMV4 H7 / OpenMV4 H7 Plus :\ UART 1 RX -> P0 (PB15)\ UART 1 TX -> P1 (PB14)

Le module pyb ne peut pas être utilisé sur OpenMV RT, seul le module machine suivant peut être utilisé :

from machine import UART

uart = UART(1, 9600)
uart.write('hello')
uart.read(5) # lit jusqu'à 5 octets

L'OpenMV RT1062 ne dispose que du port série 1, correspondant aux broches P4 P5. UART 1 RX -> P5 (PB11)\ UART 1 TX -> P4 (PB10)

SPI

from pyb import SPI

spi = SPI(2, SPI.MASTER, baudrate=200000, polarity=1, phase=0)
spi.send(b'hello')
spi.recv(5) # reçoit 5 octets sur le bus
spi.send_recv(b'hello') # envoie et reçoit 5 octets

Le module pyb ne peut pas être utilisé sur OpenMV RT, seul le module machine suivant peut être utilisé :

from machine import SPI

spi = SPI(1, baudrate=int(1000000000 / 66), polarity=0, phase=0)
spi.write(b'hello')
spi.read(5) # reçoit 5 octets sur le bus

txdata = b"12345678"
rxdata = bytearray(len(txdata))
spi.write_readinto(txdata, rxdata)  # Écrit et lit des octets simultanément.

I2C

from machine import I2C, Pin
i2c = I2C(sda=Pin('P5'),scl=Pin('P4'))

i2c.scan()
i2c.writeto(0x42, b'123')         # écrit 3 octets vers l'esclave à l'adresse 7 bits 42
i2c.readfrom(0x42, 4)             # lit 4 octets depuis l'esclave à l'adresse 7 bits 42

i2c.readfrom_mem(0x42, 8, 3)      # lit 3 octets depuis la mémoire de l'esclave 42,
                                # en commençant à l'adresse mémoire 8 de l'esclave
i2c.writeto_mem(0x42, 2, b'\x10') # écrit 1 octet dans la mémoire de l'esclave 42
                                # en commençant à l'adresse 2 de l'esclave

I2C 2 SCL (Horloge série) -> P4 (PB10)\ I2C 2 SDA (Données série) -> P5 (PB11)

Ajouté sur OpenMV3 M7 / OpenMV4 H7 / OpenMV4 H7 Plus :\ I2C 4 SCL (Horloge série) -> P7 (PD13)\ I2C 4 SDA (Données série) -> P8 (PD12)

La bibliothèque machine est un protocole I2C émulé en logiciel, donc n'importe quelle broche peut être utilisée, mais il est recommandé d'utiliser les broches mentionnées ci-dessus.

Sur OpenMV RT, vous pouvez l'appeler ainsi :

from machine import I2C, Pin
i2c = I2C(1)

i2c.scan()
i2c.writeto(0x42, b'123')         # écrit 3 octets vers l'esclave à l'adresse 7 bits 42
i2c.readfrom(0x42, 4)             # lit 4 octets depuis l'esclave à l'adresse 7 bits 42

i2c.readfrom_mem(0x42, 8, 3)      # lit 3 octets depuis la mémoire de l'esclave 42,
                                # en commençant à l'adresse mémoire 8 de l'esclave
i2c.writeto_mem(0x42, 2, b'\x10') # écrit 1 octet dans la mémoire de l'esclave 42
                                # en commençant à l'adresse 2 de l'esclave

Bouton personnalisé sur la broche Switch SW

# Le commutateur utilisateur sur l'OpenMV Cam peut être lu via la broche « SW ».
# Cette broche est anti-rebond matériellement via un circuit RC.
# Il suffit donc de lire l'état de la broche pour savoir si le commutateur est enfoncé.

import machine

sw = machine.Pin("SW", machine.Pin.IN)
r = machine.LED("LED_RED")

while True:
    r.value(not sw.value())
    print(sw.value())

Seul l'OpenMV RT dispose de boutons personnalisés SW, les OpenMV4 H7 / OpenMV4 H7 Plus / OpenMV3 M7 n'ont pas de boutons personnalisés.