Driver Shield

O Driver Shield aciona dois motores de 3 A ou quatro line drivers independentes de 1,5 A a partir de uma fonte ampla de 6-36 V, dando à OpenMV Cam um front-end robusto de controle de motores com proteção contra tensão reversa e surtos.

Driver Shield

Para o datasheet completo, fotos e informações de compra, consulte a página do produto Driver Shield.

Destaques

  • Dois motor drivers de 3 A OU quatro line drivers de 1,5 A, 6-36 V

  • Proteção contra tensão reversa e surtos transitórios na entrada

  • Entrada ADC de 0-5 V com proteção contra sobretensão de ±36 V

  • I/O digital de 0-5 V para gatilhos de sincronização da câmera, com proteção contra curto-circuito

Pinagem

Pinagem do Driver Shield

Referência de pinos

Pino

Função

P0

DIR para o par de saídas O1/O2

P1

DIR para o par de saídas O3/O4 (alternativa)

P2

DIR para o par de saídas O3/O4 (padrão)

P6

Leitura de AIN com nível deslocado (0–3,3 V em P6)

P7

PWM para o par de saídas O1/O2

P8

PWM para o par de saídas O3/O4

P10

SYN — I/O digital open-drain no bloco de terminais

PWR in

Entrada ampla de 6–36 V no bloco de terminais (tolerante a tensão reversa)

AIN in

Entrada analógica no bloco de terminais

VIN out

5,4 V a até 600 mA do regulador integrado

trilho 3.3V

Alimenta a eletrônica integrada do shield

trilho GND

Terra comum

Nota

AIN tem proteção contra sobretensão de até ±36 V e, por padrão, é uma entrada de tensão de 0–5 V, reduzida para 0–3,3 V em P6. Faça a ponte do shunt do modo 4–20 mA na frente do shield para alternar AIN para uma entrada de loop de corrente de 4–20 mA.

Nota

SYN é uma linha digital open-drain, com pull-up para 3,3 V no lado da câmera e 5 V no lado do terminal SYN. Por padrão é uma entrada — o shield desloca o nível de 0–5 V em SYN para 0–3,3 V em P10. Altere o jumper de solda integrado para inverter P10 em uma saída, deslocando o nível de 0–3,3 V em P10 para 0–5 V em SYN.

Nota

Cada um dos pinos P0, P1, P2, P6, P7, P8 e P10 pode ser reaproveitado para uso não relacionado. P0, P2, P6, P7, P8 e P10 são conectados por padrão através de jumpers de solda no lado traseiro — abra o jumper de qualquer pino que você queira liberar. P1 vem desconectado por padrão: faça a ponte de seu jumper frontal para rotear DIR de O3/O4 para P1 em vez disso (e abra o jumper traseiro de P2 para liberar P2).

Nota

Dois jumpers de modo na parte traseira do shield — um por ponte H — configuram independentemente cada par de saídas em um de três modos. Cada jumper tem marcações L e H para mostrar qual lado seleciona qual estado:

  • Baixo (padrão) — modo DIR/PWM: um pino DIR + um pino PWM por ponte.

  • Alto — modo ponte H: ambos os pinos acionam a ponte diretamente através da tabela-verdade de duas entradas do chip.

  • Flutuante (sem conexão) — modo independente: cada pino se torna um line driver autônomo roteado para uma saída.

Cada DRV8876 tem limite de corrente de 3 A no total por chip — isto é, 3 A através de uma ponte (modo DIR/PWM ou ponte H) ou 1,5 A por saída divididos entre as duas saídas (modo independente).

Uso

Modo DIR/PWM (padrão)

Acione um motor DC com escovas no par de saídas O1/O2 — defina a direção em P0 e aplique um sinal de velocidade PWM em P7. O loop abaixo aumenta o ciclo de trabalho até a velocidade máxima e o reduz de volta, depois inverte a direção e repete:

from machine import Pin, PWM
import time

direction = Pin("P0", Pin.OUT)
speed = PWM(Pin("P7"), freq=20_000, duty_u16=0)


def ramp(target):
    for duty in range(0, target, 1024):
        speed.duty_u16(duty)
        time.sleep_ms(10)
    for duty in range(target, -1, -1024):
        speed.duty_u16(duty)
        time.sleep_ms(10)


while True:
    direction.value(1)  # forward
    ramp(65_535)
    direction.value(0)  # reverse
    ramp(65_535)

As duas pontes H também podem acionar um motor de passo bipolar — mantenha ambos os canais PWM em acionamento máximo e percorra os pinos DIR pela sequência de quatro fases:

from machine import Pin, PWM
import time

dir12 = Pin("P0", Pin.OUT)
dir34 = Pin("P2", Pin.OUT)
PWM(Pin("P7"), freq=20_000, duty_u16=65_535)  # full drive on O1/O2
PWM(Pin("P8"), freq=20_000, duty_u16=65_535)  # full drive on O3/O4

SEQUENCE = [(1, 1), (0, 1), (0, 0), (1, 0)]


def step(forward=True):
    for a, b in SEQUENCE if forward else reversed(SEQUENCE):
        dir12.value(a)
        dir34.value(b)
        time.sleep_ms(5)


while True:
    for _ in range(50):  # ~1 revolution forward (200 phases)
        step()
    for _ in range(50):  # ~1 revolution backward
        step(forward=False)

Modo ponte H

Com o jumper de modo configurado em alto, ambos os pinos da ponte acionam a ponte H diretamente. Para O1/O2 a tabela-verdade é:

  • (P0, P7) = (L, L) → livre (saídas em Hi-Z)

  • (P0, P7) = (L, H) → para frente (O1 = H, O2 = L)

  • (P0, P7) = (H, L) → para trás (O1 = L, O2 = H)

  • (P0, P7) = (H, H) → freio (ambas as saídas em baixo)

(O3/O4 segue a mesma tabela com P1/P2 e P8.) O loop abaixo percorre um motor por frente → freio → trás → livre no par de saídas O1/O2:

from machine import Pin
import time

p0 = Pin("P0", Pin.OUT)
p7 = Pin("P7", Pin.OUT)


def drive(a, b):
    p0.value(a)
    p7.value(b)


while True:
    drive(0, 1)         # forward
    time.sleep(1)
    drive(1, 1)         # brake
    time.sleep_ms(500)
    drive(1, 0)         # reverse
    time.sleep(1)
    drive(0, 0)         # coast
    time.sleep_ms(500)

Qualquer pino pode ser trocado por um canal machine.PWM para acionamento proporcional — por exemplo, (P0=0, P7=PWM) dá frente/livre no ciclo de trabalho do PWM, (P0=1, P7=PWM) dá trás/freio em (100 % − duty). O loop abaixo aumenta o ciclo de trabalho e o reduz de volta com P0 mantido em 0 (frente/livre):

from machine import Pin, PWM
import time

p0 = Pin("P0", Pin.OUT, value=0)
p7 = PWM(Pin("P7"), freq=20_000, duty_u16=0)

while True:
    for duty in range(0, 65_536, 1024):
        p7.duty_u16(duty)
        time.sleep_ms(10)
    for duty in range(65_535, -1, -1024):
        p7.duty_u16(duty)
        time.sleep_ms(10)

Modo independente

Com o jumper de modo flutuando, cada pino se torna um line driver autônomo roteado para uma saída — útil para solenoides, relés ou qualquer carga liga/desliga que não precise de uma ponte H. O mapeamento é P7 → O1, P0 → O2, P8 → O3 e P1 (ou P2) → O4:

from machine import Pin
import time

outputs = [
    Pin("P7", Pin.OUT),  # O1
    Pin("P0", Pin.OUT),  # O2
    Pin("P8", Pin.OUT),  # O3
    Pin("P2", Pin.OUT),  # O4
]

while True:
    for o in outputs:    # walk a single high pulse across O1–O4
        o.value(1)
        time.sleep_ms(200)
        o.value(0)

Qualquer um dos quatro pinos também pode receber PWM via machine.PWM para acionamento proporcional — por exemplo, fazer cada saída acender e apagar gradualmente, uma de cada vez:

from machine import Pin, PWM
import time

outputs = [
    PWM(Pin("P7"), freq=1_000, duty_u16=0),  # O1
    PWM(Pin("P0"), freq=1_000, duty_u16=0),  # O2
    PWM(Pin("P8"), freq=1_000, duty_u16=0),  # O3
    PWM(Pin("P2"), freq=1_000, duty_u16=0),  # O4
]

while True:
    for o in outputs:
        for duty in range(0, 65_536, 1024):
            o.duty_u16(duty)
            time.sleep_ms(5)
        for duty in range(65_535, -1, -1024):
            o.duty_u16(duty)
            time.sleep_ms(5)

Outros I/O

Leia a entrada do bloco de terminais AIN através do pino P6 com nível deslocado:

from machine import ADC
import time

ain = ADC("P6")

while True:
    v = ain.read_u16() * 3.3 / 65535
    print("AIN:", v * (5.0 / 3.3), "V")
    time.sleep_ms(100)

Reaja a uma borda de descida na linha SYN — por exemplo, para sincronizar a câmera com outro dispositivo que puxa SYN para baixo:

from machine import Pin

def on_sync(pin):
    print("SYN falling edge")

syn = Pin("P10", Pin.IN)
syn.irq(on_sync, Pin.IRQ_FALLING)