Shield de motores L293D com Arduino: AFMotor, 4 motores CC, motor de passo e servo

O shield de motores L293D é uma placa driver de motores que se encaixa direto em cima de um Arduino Uno e permite controlar 4 motores CC, 2 motores de passo e 2 servos com uma única placa. Seus dois chips L293D fornecem a corrente de que os motores precisam, invertem o sentido de rotação e ajustam a velocidade com PWM, então você controla todos os motores de um carrinho robô de quatro rodas sem usar um único jumper. Quase todas as placas do mercado são cópias do antigo projeto Motor Shield V1 da Adafruit e são programadas com a mesma biblioteca: a AFMotor.

Neste guia você vai ver o que há no shield, quais pinos do Arduino ele usa e quais ficam livres para sensores, como funciona o confuso jumper PWR em três configurações de alimentação diferentes, os comandos da biblioteca AFMotor e o código completo de um carrinho robô de quatro rodas controlado pelo celular. Nas últimas seções falamos do limite de corrente de 0,6 A, do motivo de o chip esquentar, da comparação com o L298N e reunimos em uma única tabela todas as causas conhecidas de “meus motores não giram”.

O que é o shield de motores L293D e como ele funciona?

Para girar um motor CC nos dois sentidos, você precisa de um circuito de quatro chaves chamado ponte H; explicamos a ideia em detalhes em Controle de motor CC com L298N. O chip L293D contém duas pontes H e, como o shield tem dois desses chips, você ganha quatro canais de motor no total. O “D” no nome indica que os diodos de proteção, que absorvem os picos de tensão reversa gerados pelo motor ao desligar, estão embutidos no chip. O L293D também desliga as saídas sozinho quando superaquece.

O grande truque do shield é o registrador de deslocamento 74HC595 no meio. Cada um dos quatro motores precisa de dois sinais para o sentido e um para a velocidade, o que soma 12 pinos do Arduino. O shield envia os oito sinais de sentido em série para o 74HC595 e gasta apenas 4 pinos com eles (D4, D7, D8, D12), mais 4 pinos PWM para a velocidade (D3, D5, D6, D11). Esse projeto economiza pinos, mas tem um preço: você não consegue controlar os motores diretamente com digitalWrite; é preciso uma biblioteca que envie os bits de sentido para o registrador. Essa biblioteca é a AFMotor.

O que há na placa? Bornes, conectores e jumper

Quais pinos o shield usa e quais ficam livres?

Os seis pinos analógicos livres são mais que suficientes para sensores, porque os pinos A0–A5 do Uno também funcionam como pinos digitais 14–19 quando necessário. Uma distribuição prática seria: um sensor de distância HC-SR04 ou um módulo Bluetooth via SoftwareSerial em A0 e A1, sensores seguidores de linha ou de obstáculo em A2 e A3, e o barramento I2C (OLED, LCD, MPU6050) em A4 e A5. Para um encoder de roda ou um botão que use attachInterrupt(), o D2 é o único pino livre; o outro pino de interrupção do Uno, o D3, é o pino de velocidade do M2. Se você não usar servos, D9 e D10 também ficam livres. Você pode ver a disposição dos pinos da sua placa na ferramenta Pinagem e o que cada pino faz em Pinagem do Arduino Uno.

Alimentação e jumper PWR: três formas corretas de ligar

O borne EXT_PWR de dois parafusos, na borda inferior da placa, é a entrada de alimentação dos motores; o lado positivo costuma estar marcado como “+M” ou “+” e o negativo como “GND”. O jumper PWR logo ao lado liga essa linha dos motores ao pino Vin do Arduino. Com o jumper encaixado, as duas placas funcionam com uma única fonte: a tensão que você aplica no EXT_PWR também alimenta o Arduino pelo Vin, ou uma fonte ligada ao conector DC do Arduino também alimenta os motores. Sem o jumper, as duas linhas ficam totalmente separadas. O LED PWR da placa só acende quando há alimentação nos motores; é a primeira coisa a verificar antes de começar a procurar defeitos nos motores.

A escolha mais comum em carrinhos robô é a fonte única: você liga um pack de duas células 18650 no EXT_PWR, encaixa o jumper, e tanto o Arduino quanto os motores funcionam com a mesma bateria. É simples, mas quando os motores puxam muita corrente na partida, a tensão da bateria pode cair por um instante e o Arduino pode reiniciar. Se isso acontecer, remover o jumper e alimentar o Arduino por uma fonte separada (um power bank, a USB ou uma fonte de 9 V) resolve de vez. Na bancada, a segunda configuração é a mais prática: o Arduino continua ligado ao computador, os motores funcionam com bateria e o jumper fica removido.

Qual bateria escolher? Dependendo da corrente, os transistores de saída do L293D “engolem” cerca de 1,5–2,6 V, então o motor recebe esse tanto a menos que a tensão da bateria. Para os motores TT amarelos de 3–6 V dos kits de robótica, duas células de lítio 18650 (7,4 V nominais, 8,4 V com carga completa) são ideais: os motores recebem cerca de 5,5–6 V e, com o jumper encaixado, o regulador do Arduino também trabalha com folga. Quatro pilhas AA (6 V) deixam apenas uns 4 V para os motores e não bastam para alimentar o Arduino pelo Vin. Uma bateria de 9 V (tipo quadrada) não fornece mais que algumas centenas de miliampères; os motores ou nem giram ou a bateria acaba em minutos. Você pode estimar a duração com a ferramenta Autonomia da bateria e ler sobre todas as opções de alimentação em Como alimentar o Arduino com bateria.

Instalando a biblioteca AFMotor

1. Abra o Gerenciador de Bibliotecas na Arduino IDE (Ferramentas > Gerenciar Bibliotecas ou Ctrl+Shift+I).
2. Digite Adafruit Motor Shield na caixa de busca. Aparecem dois resultados: Adafruit Motor Shield library, cuja descrição diz “V1 firmware”, e Adafruit Motor Shield V2 Library.
3. Para o shield com L293D, instale a da V1. A biblioteca V2 é para uma placa completamente diferente, que se comunica por I2C e usa chips TB6612.
4. Adicione a linha #include <AFMotor.h> no início do seu sketch.
5. Se quiser, abra Arquivo > Exemplos > Adafruit Motor Shield library > MotorTest e teste a placa com um motor no M1.

Primeiro sketch: girando um motor CC para frente, para trás e em velocidades diferentes

Prenda os dois fios do motor nos dois parafusos externos do borne M1 e deixe o parafuso GND do meio livre. Ligue o pack de baterias no EXT_PWR, conecte o Arduino ao computador pela USB e remova o jumper PWR (a segunda configuração acima). Se o LED PWR estiver aceso, carregue o código abaixo: o motor primeiro acelera e desacelera suavemente, depois gira para trás por dois segundos e para.

1#include <AFMotor.h>                  // Adafruit Motor Shield V1 kütüphanesi / library
2
3AF_DCMotor motor(1);                  // M1 klemensi / M1 terminal
4
5void setup() {
6  Serial.begin(9600);
7  Serial.println(F("L293D motor testi / motor test"));
8  motor.setSpeed(200);                // 0–255; bunu unutursan motor dönmez / skip this and the motor won't turn
9  motor.run(RELEASE);                 // başlangıçta dur / start stopped
10}
11
12void loop() {
13  motor.run(FORWARD);                 // ileri / forward
14  for (int s = 60; s <= 255; s++) {   // yavaşça hızlan / ramp up
15    motor.setSpeed(s);
16    delay(10);
17  }
18  for (int s = 255; s >= 60; s--) {   // yavaşça yavaşla / ramp down
19    motor.setSpeed(s);
20    delay(10);
21  }
22  motor.run(RELEASE);                 // dur / stop
23  delay(500);
24
25  motor.setSpeed(180);
26  motor.run(BACKWARD);                // geri / backward
27  delay(2000);
28  motor.run(RELEASE);
29  delay(1000);
30}

A velocidade é ajustada ligando e desligando a alimentação do motor milhares de vezes por segundo; os detalhes estão em O que é PWM?. Como o M1 e o M2 usam o Timer2, você pode escolher a frequência deles: MOTOR12_64KHZ, MOTOR12_8KHZ (o padrão), MOTOR12_2KHZ e MOTOR12_1KHZ. Com 64 kHz o zumbido do motor fica inaudível, mas o L293D esquenta mais nessa frequência. Já o M3 e o M4 estão ligados ao Timer0; como esse timer também faz funcionar millis() e delay(), a biblioteca não mexe na frequência dele, e esses dois canais sempre funcionam a cerca de 1 kHz.

Código do carrinho robô de quatro rodas (4WD)

O uso favorito do shield de motores L293D é o carrinho robô de quatro rodas, porque cada um dos quatro motores tem seu próprio borne e não há bagunça de fios. Esses carrinhos não têm direção; eles viram como um tanque: se as duas rodas da esquerda giram para um lado e as duas da direita para o outro, o carrinho gira no lugar. Por isso o código não controla os motores um a um, mas em dois grupos, o lado esquerdo e o lado direito. Para o controle pelo celular, ligamos um módulo Bluetooth HC-05 nos pinos livres A0 e A1 com SoftwareSerial; o módulo é explicado em detalhes em módulo Bluetooth HC-05.

1#include <AFMotor.h>
2#include <SoftwareSerial.h>
3
4AF_DCMotor frontLeft(1);              // M1: sol ön / front left
5AF_DCMotor rearLeft(2);               // M2: sol arka / rear left
6AF_DCMotor rearRight(3);              // M3: sağ arka / rear right
7AF_DCMotor frontRight(4);             // M4: sağ ön / front right
8
9SoftwareSerial bt(A0, A1);            // RX = A0 (HC-05 TXD), TX = A1 (HC-05 RXD, bölücüyle / via a divider)
10
11int speed = 200;                      // 0–255 arası sürüş hızı / driving speed 0–255
12
13void setSide(AF_DCMotor &a, AF_DCMotor &b, int value) {   // -255 … 255
14  uint8_t dir = value > 0 ? FORWARD : (value < 0 ? BACKWARD : RELEASE);
15  uint8_t pwm = constrain(abs(value), 0, 255);
16  a.setSpeed(pwm);
17  b.setSpeed(pwm);
18  a.run(dir);
19  b.run(dir);
20}
21
22void drive(int left, int right) {     // sol ve sağ taraf / left and right side
23  setSide(frontLeft, rearLeft, left);
24  setSide(frontRight, rearRight, right);
25}
26
27void setup() {
28  Serial.begin(9600);                 // hata ayıklama / debugging
29  bt.begin(9600);                     // HC-05 varsayılan hızı / default baud rate
30  drive(0, 0);
31}
32
33void loop() {
34  if (!bt.available()) return;
35  char c = bt.read();
36  Serial.println(c);
37
38  switch (c) {
39    case 'F': drive(speed, speed);        break;   // ileri / forward
40    case 'B': drive(-speed, -speed);      break;   // geri / backward
41    case 'L': drive(-speed, speed);       break;   // yerinde sola / spin left
42    case 'R': drive(speed, -speed);       break;   // yerinde sağa / spin right
43    case 'G': drive(speed / 3, speed);    break;   // ileri-sola kavis / curve forward-left
44    case 'I': drive(speed, speed / 3);    break;   // ileri-sağa kavis / curve forward-right
45    case 'S': drive(0, 0);                break;   // dur / stop
46    case 'q': speed = 255;                break;   // tam hız / full speed
47    default:
48      if (c >= '0' && c <= '9') speed = map(c - '0', 0, 9, 90, 240);   // hız kademesi / speed step
49  }
50}

O coração do código é a função drive(left, right): ela recebe um valor de -255 a 255 para cada lado, em que positivo significa para frente, negativo para trás e zero parar. A setSide() dá aos dois motores de um mesmo lado a mesma velocidade e o mesmo sentido. Os comandos são as letras únicas enviadas por apps do tipo “Arduino Bluetooth RC Car” das lojas de aplicativos: F para frente, B para trás, L e R giram no lugar, G e I fazem curvas, S para. O controle deslizante de velocidade do app envia um dígito de 0 a 9; o código o converte em um valor PWM entre 90 e 240 e, como o limite inferior é 90, os motores ainda conseguem partir na posição mais baixa. Se uma roda girar ao contrário, não mexa no código; troque os dois fios desse motor no borne. Para a montagem do chassi e uma versão com dois motores, veja Como fazer um carrinho robô com Arduino.

Controlando motores de passo: 28BYJ-48 e NEMA 17

O shield consegue controlar dois motores de passo ao mesmo tempo: a porta de passo 1 usa os bornes M1 e M2 e a porta 2 usa M3 e M4. Com um motor bipolar (4 fios, como um NEMA 17), você liga uma bobina no M1 e a outra no M2. Com um motor unipolar (5 ou 6 fios), as duas bobinas também vão no M1 e no M2, e o fio comum vai no parafuso GND do meio do borne. Para o popular 28BYJ-48, a ligação é: fios azul e amarelo no M1, fios rosa e laranja no M2 e o fio comum vermelho no GND. O uso desse motor com a placa ULN2003 está em O que é motor de passo?.

O 28BYJ-48 é um motor de 5 V; para este teste, alimente os motores com 4 pilhas AA (6 V), remova o jumper e alimente o Arduino pela USB. Por causa da caixa de redução dentro do motor, uma volta equivale a 2048 passos completos:

1#include <AFMotor.h>
2
3// 28BYJ-48: tam adımda tur başına 2048 adım / 2048 full steps per revolution
4AF_Stepper stepper(2048, 1);          // 1 = M1 + M2, 2 = M3 + M4
5
6void setup() {
7  stepper.setSpeed(10);               // dakikada 10 tur / 10 RPM
8}
9
10void loop() {
11  stepper.step(2048, FORWARD, DOUBLE);       // bir tur ileri, güçlü tork / one turn forward, more torque
12  delay(500);
13  stepper.step(4096, BACKWARD, INTERLEAVE);  // yarım adımla bir tur geri / one turn back in half steps
14  stepper.release();                         // bobinleri kapat, ısınmasın / de-energise the coils
15  delay(1000);
16}

O setSpeed() define as rotações por minuto; por causa da caixa de redução, o 28BYJ-48 não gira mais rápido que cerca de 10–15 RPM. O ponto de atenção é que o step() é bloqueante: até o motor terminar os passos pedidos, o loop() não faz mais nada. Se você quiser ler sensores ou controlar motores CC enquanto o motor de passo gira, use a função onestep() da biblioteca junto com a biblioteca AccelStepper; o exemplo AFMotor_ConstantSpeed que vem com a biblioteca mostra exatamente isso. Chamar release() enquanto o motor espera desliga as bobinas e evita o aquecimento, mas nesse meio-tempo o eixo perde o torque de retenção.

Ligando servos: os conectores SER1 e SERVO_2

Os dois conectores de três pinos no canto do shield são para servos. Pelas marcações na placa, os pinos são − (GND), + (5 V) e S (sinal): o fio marrom do servo vai no −, o vermelho no + e o laranja no S. Pelo esquema do circuito da placa, o conector SER1 está ligado ao D10 e o SERVO_2 ao D9 (algumas fontes trazem os números invertidos; se o servo não se mexer, tente o outro pino no código). Os servos são controlados com a biblioteca Servo padrão, e o Timer1 que ela usa no Uno não conflita com os timers dos motores, então motores CC e servos funcionam juntos sem problemas.

Os servos não são alimentados pela bateria dos motores, e sim pela linha de 5 V do Arduino. Para um SG90 isso não é problema, mas servos grandes como o MG996R podem consumir mais de 1 A em movimento; o regulador do Arduino esquenta, a tensão despenca e a placa reinicia. Com servos grandes, encaixe só o fio de sinal no conector, alimente o + e o − do servo por uma fonte separada de 5–6 V e una os GNDs. Os detalhes estão em Servo MG996R com Arduino e O que é servo motor?. O código abaixo faz o servo do SER1 varrer de um lado para o outro enquanto o motor do M3 gira:

1#include <AFMotor.h>
2#include <Servo.h>
3
4AF_DCMotor motor(3);                  // M3 klemensi / M3 terminal
5Servo servo1;                         // SER1 başlığı / SER1 header
6
7void setup() {
8  servo1.attach(10);                  // SER1 = D10, SERVO_2 = D9
9  motor.setSpeed(170);
10  motor.run(FORWARD);                 // motor dönerken servo tarar / servo sweeps while the motor runs
11}
12
13void loop() {
14  for (int a = 20; a <= 160; a += 2) {   // sağa tara / sweep right
15    servo1.write(a);
16    delay(15);
17  }
18  for (int a = 160; a >= 20; a -= 2) {   // sola tara / sweep left
19    servo1.write(a);
20    delay(15);
21  }
22}

Limite de corrente (0,6 A) e aquecimento

A linha mais importante do datasheet do L293D é 0,6 A contínua e 1,2 A de pico por canal. O valor de pico vale só para pulsos muito curtos; se um motor puxa 1 A por segundos, o chip sofre. Uma conta simples mostra por que ele esquenta: o L293D é um driver antigo, com transistores bipolares, e a 0,6 A ele tipicamente perde 1,4 V no transistor de cima e 1,2 V no de baixo. Ou seja, quando um motor consome 0,6 A, são produzidos 0,6 A × 2,6 V ≈ 1,6 W de calor no chip; dois motores no mesmo chip produzem o dobro, cerca de 3 W. Um pequeno chip DIP sem dissipador não consegue se livrar desse calor, a temperatura sobe rápido e, no fim, o desligamento térmico corta as saídas. O sintoma é conhecido: os motores funcionam por um tempo, param e voltam a girar quando o chip esfria.

Os motores TT amarelos consomem cerca de 150 mA sem carga e 200–300 mA andando no chão, o que está dentro dos limites do shield. O problema são os momentos em que uma roda empurra um obstáculo ou o carrinho gira no lugar: um motor TT travado pode puxar 1–1,5 A, e em um carrinho 4WD os quatro motores fazem força ao mesmo tempo durante um giro no lugar. Para descobrir a corrente real do seu motor, ligue um multímetro em série com o motor e meça enquanto segura a roda com a mão por um instante; Como usar o multímetro mostra como fazer. Para manter o shield frio:

• Use partida suave: não pule de 0 para 255; aumente a velocidade gradualmente ao longo de 200–300 ms, e a corrente de partida cai bastante.
• Não trave o motor: em robôs que desviam de obstáculos, pare o carrinho antes que ele bata no obstáculo; um motor travado é o que mais gera calor.
• Cole dissipadores nos chips: pequenos dissipadores de alumínio com fita térmica reduzem um pouco a temperatura do L293D.
• Solde um segundo L293D: a própria Adafruit observa que dá para soldar um segundo L293D em cima dos chips existentes, perna com perna, para aumentar a capacidade de corrente; os dois chips dividem a corrente.
• Não use mais tensão que o necessário: aplicar 12 V em motores de 6 V aumenta tanto a corrente quanto o calor.
• Troque para o driver certo: se o seu motor consome continuamente mais de 0,6 A, use um driver baseado no L298N ou no TB6612FNG.

Shield de motores L293D ou L298N?

Resumindo: se você está montando um carrinho 4WD com motores TT em um Arduino Uno, o shield L293D reduz a fiação ao mínimo e reúne os quatro motores em uma só placa. Se seus motores são mais fortes, sua placa é um ESP32 ou um Pico, ou escolher os pinos é importante para você, o L298N é mais flexível; os detalhes estão em Controle de motor CC com L298N. Se quiser algo mais eficiente que os dois, o TB6612FNG, baseado em MOSFET, tem queda de tensão muito baixa e faz suas baterias durarem mais. Comparamos qual tipo de motor serve para cada tarefa em Diferença entre motor CC, servo e motor de passo.

Dá para usar com ESP32, Raspberry Pi Pico ou Mega?

Funciona bem com o Arduino Mega 2560: o shield se encaixa nos primeiros pinos digitais e analógicos do Mega, e a AFMotor conhece os timers do Mega. Não funciona com Uno R4, Leonardo, ESP32 nem Raspberry Pi Pico, porque a AFMotor escreve diretamente nos registradores de timer do ATmega328P e do ATmega2560. Com um ESP32 selecionado, a compilação para com 'DC_MOTOR_PWM_RATE' was not declared in this scope e, com um Leonardo selecionado, para com #error "This chip is not supported!". Placas ESP32 no formato do Uno (como a ESPDuino-32) encaixam fisicamente no shield, mas os números dos pinos e o nível de sinal de 3,3 V são diferentes. Nessas placas é muito mais fácil usar um L298N, um TB6612FNG ou um único chip L293D no lugar do shield. As entradas do L293D consideram HIGH qualquer valor acima de 2,3 V, então ele funciona direto com placas de 3,3 V:

1from machine import Pin, PWM
2import time
3
4en = PWM(Pin(15))                 # L293D pin 1 (1,2EN): hız / speed
5en.freq(1000)
6in1 = Pin(14, Pin.OUT)            # L293D pin 2 (1A): yön / direction
7in2 = Pin(13, Pin.OUT)            # L293D pin 7 (2A): yön / direction
8
9def motor(speed):                 # -100 … 100
10    in1.value(1 if speed > 0 else 0)
11    in2.value(1 if speed < 0 else 0)
12    en.duty_u16(int(abs(speed) * 655.35))
13
14while True:
15    motor(80)                     # ileri / forward
16    time.sleep(2)
17    motor(0)                      # dur / stop
18    time.sleep(0.5)
19    motor(-60)                    # geri / backward
20    time.sleep(2)
21    motor(0)
22    time.sleep(0.5)

Os GNDs do Pico e da bateria precisam estar ligados. No ESP32 você monta a mesma lógica na linguagem do Arduino: sentido com digitalWrite e velocidade com analogWrite nos pinos da tabela. Se essas placas são novidade para você, comece por O que é ESP32? e O que é Raspberry Pi Pico?.

Motores que não giram: erros comuns e soluções

Ideias de projetos com o shield de motores L293D

• Carrinho 4WD controlado por Bluetooth: um robô com tração nas quatro rodas que você dirige pelo celular com o código acima.
• Robô que desvia de obstáculos: um carrinho que faz a varredura à frente com um HC-SR04 montado no servo do SER1 e vira para a direção mais livre; o guia completo está em Robô que desvia de obstáculos com Arduino.
• Robô seguidor de linha: siga uma linha preta no chão com sensores infravermelhos em A0–A3; o ajuste do PID está em Robô seguidor de linha com Arduino.
• Slider de câmera: mova uma câmera lentamente sobre um trilho com um motor de passo e grave vídeos em time-lapse.
• Cabeça pan-tilt: ligue dois servos nos dois conectores de servo e aponte uma câmera ou um laser em dois eixos; para mais servos, veja Braço robótico com Arduino.
• Cortina automática ou esteira transportadora: abra e feche uma cortina com um motor CC conforme a luz, ou monte uma pequena esteira transportadora.

Este é o resumo para usar corretamente o shield de motores L293D: instale a biblioteca V1, confira o LED PWR, ajuste o jumper conforme a sua configuração de alimentação, não esqueça o setSpeed(), ligue os sensores em A0–A5 e mantenha seus motores abaixo do limite de 0,6 A. Seguindo essas regras, um pequeno shield dá conta sozinho de toda a força de um robô de quatro motores. No app BlueGrays você encontra os projetos de carrinho controlado por Bluetooth, robô que desvia de obstáculos, motor de passo e servo passo a passo, com esquemas do circuito e códigos.