Como fazer um carrinho robô com Arduino: controle por Bluetooth passo a passo

Montar um carrinho com Arduino é uma das formas mais divertidas de aprender eletrônica e programação em um único projeto. Com dois motores CC com redução, um driver de motor L298N, duas baterias 18650, um módulo Bluetooth HC-05 e um Arduino Uno, você monta em um fim de semana um carrinho robô que dirige pelo celular. No caminho, vai ver com os próprios olhos por que motores não podem ser ligados direto no Arduino, por que a escolha da bateria importa tanto e como algumas linhas de código movem um veículo de verdade.

Neste guia montamos juntos, do início ao fim, um carrinho robô 2WD (dois motores): lista de peças e divisão de custos, montagem do chassi, tabelas de ligação, código para frente, para trás e curvas e controle por Bluetooth pelo celular. Os dois problemas que mais dão trabalho aos iniciantes, o carrinho que não anda reto e o Arduino que reinicia quando os motores ligam, ganham cada um a sua própria seção, com soluções práticas e testadas. Nas últimas seções você vê como dirigir o mesmo carrinho com um ESP32 ou um Raspberry Pi Pico e como transformá-lo em um robô que desvia de obstáculos ou segue linha.

Como funciona um carrinho robô com Arduino?

Você pode dividir um carrinho robô em quatro partes. O Arduino é o cérebro: ele lê o comando do celular e decide qual motor gira em qual sentido e com que velocidade. O driver de motor L298N é o músculo: ele transforma os sinais fracos de 5 V do Arduino na corrente alta de que os motores precisam. Os motores com redução giram as rodas, e o pacote de baterias alimenta tudo. Esses carrinhos não têm direção; eles fazem curvas girando as duas rodas em velocidades ou sentidos diferentes. Isso se chama tração diferencial: se a roda esquerda gira para a frente e a direita para trás, o carrinho gira no lugar para a direita. Uma pequena roda boba, que gira livre na frente ou atrás, mantém o corpo equilibrado.

A linha mais importante da tabela é a corrente de travamento: quando uma roda empurra um obstáculo ou o carrinho arranca, cada motor puxa por um instante mais de 1 ampère. Um pino do Arduino fornece no máximo 20–40 mA, então os motores são sempre ligados através de um driver. Fazendo esse trabalho, o L298N perde cerca de 1,5–2,5 V; com um pacote de baterias de 7,4 V, sobram 5–6 V para os motores, exatamente a faixa ideal dos motores TT. Explicamos em detalhe o funcionamento interno do driver e a ideia da ponte H em Controle de motor CC com L298N.

Lista de peças

A maioria dos kits de chassi também traz um suporte para 4 pilhas AA; como você vai ver daqui a pouco, esse suporte é fraco demais em conjunto com o L298N, por isso colocamos células 18650 na lista. O HC-06 é o irmão mais simples do HC-05, que só funciona como escravo, e serve perfeitamente para controlar um carrinho pelo celular. Os discos de plástico com fendas do kit são discos de encoder para um sensor de velocidade que você pode usar depois para fazer o carrinho andar perfeitamente reto; não os jogue fora, só deixe de lado por enquanto.

Custo: para onde vai o orçamento?

Os preços mudam o tempo todo conforme o vendedor e o câmbio, então não citamos valores; em vez disso, mostramos quais itens ocupam o orçamento e onde dá para economizar. A regra geral é: os módulos eletrônicos (L298N, HC-05, resistores) são baratos, enquanto a maior parte do orçamento vai para a placa, o kit de chassi e, sobretudo, as baterias e o carregador. A bateria é o último lugar para economizar: boas células 18650 podem ser recarregadas centenas de vezes e reaproveitadas em todos os projetos de robô que você fizer depois.

2WD ou 4WD?

Recomendamos 2WD para o seu primeiro carrinho: é mais barato, consome menos corrente, gira fácil no lugar e combina melhor com projetos seguintes, como um robô seguidor de linha. Se você montar um 4WD, ligue os dois motores de cada lado em paralelo nos mesmos terminais OUT e confira se os dois giram no mesmo sentido. Um canal do L298N passa então a carregar a corrente de dois motores; isso não é problema andando normalmente, mas, quando as rodas travam, o limite de 2 A por canal pode ser ultrapassado e a proteção térmica do driver corta os motores.

Alimentação: por que duas células 18650?

A maioria dos problemas de carrinhos robô vem da bateria errada. A fonte certa precisa atender duas condições ao mesmo tempo: deixar tensão suficiente para os motores depois da perda do L298N e não desabar quando os motores puxam ampères na arrancada. Duas células Li-ion 18650 em série (2S) dão 8,4 V totalmente carregadas e 7,4 V em média, e fornecem vários ampères com folga. O Arduino Uno recomenda 7–12 V na entrada VIN, então o mesmo pacote pode alimentar os motores e o Arduino. Com células de 2500 mAh, um carrinho 2WD que consome em média 0,8 A andando (motores mais placas) funciona por cerca de 3 horas na teoria; como você nunca descarrega o pacote por completo, 2–2,5 horas é um número mais realista. Para calcular com os seus valores, use a ferramenta Duração da bateria.

Em vez de adivinhar quanta carga resta, você pode medir. Ligue o positivo da bateria (depois da chave) ao A0 através de um divisor de tensão feito com dois resistores de 10 kΩ: um pacote de 8,4 V aparece como 4,2 V no A0, abaixo do limite de leitura de 5 V do Arduino. O divisor consome só cerca de 0,4 mA, então não afeta a duração da bateria.

1// Pil + (anahtardan sonra) → 10 kΩ → A0 → 10 kΩ → GND / battery + (after the switch) → 10 kΩ → A0 → 10 kΩ → GND
2const float DIVIDER = 2.0;   // iki eşit direnç gerilimi yarıya böler / two equal resistors halve the voltage
3
4void setup() {
5  Serial.begin(9600);
6}
7
8void loop() {
9  float v = analogRead(A0) * 5.0 / 1023.0 * DIVIDER;
10  Serial.print(F("Pil / Battery: "));
11  Serial.print(v, 2);
12  Serial.println(F(" V"));
13  if (v < 6.6) Serial.println(F("Sarj et / Charge now"));   // hücre başına 3,3 V / 3.3 V per cell
14  delay(1000);
15}

Montagem passo a passo

1. Tire o papel protetor das peças de acrílico. Se os motores vieram sem fios, solde dois fios em cada motor e reforce as soldas com cola quente; um fio de motor que se solta com a vibração é o defeito mais comum.
2. Fixe os motores na parte de baixo do chassi com os suportes de acrílico em forma de T e os parafusos M3 longos do kit. Os dois eixos dos motores precisam ficar alinhados, e os terminais dos fios dos motores devem ficar virados para dentro.
3. Se pretende usar os discos de encoder, encaixe-os agora no lado de dentro do eixo do motor; depois que as rodas estiverem colocadas, fica difícil.
4. Monte a roda boba no meio da outra ponta do chassi usando espaçadores. Escolha uma altura de espaçador que deixe o chassi paralelo ao chão.
5. Empurre as rodas até o fim, alinhando-as com o eixo em forma de D; uma roda frouxa faz o carrinho desviar o tempo todo.
6. Coloque o suporte de baterias com fita dupla face ou velcro em um lugar onde o peso fique perto do eixo das rodas. Se a maior parte do peso ficar sobre a roda boba, as rodas de tração vão patinar.
7. Monte o Arduino e o L298N no andar de cima com espaçadores de plástico. Você deve alcançar com facilidade a porta USB do Arduino, e o dissipador do L298N deve ficar ao ar livre; garanta que parafusos de metal não encostem nas soldas embaixo das placas.
8. Ligue a chave em série com o fio positivo da bateria para poder ligar e desligar o carrinho sem tirar as células.
9. Torça juntos os dois fios de cada motor no caminho até o L298N, mantenha todos os fios curtos e prenda-os com abraçadeiras. Antes de colocar as células, confira com um multímetro que não há curto-circuito entre os terminais da bateria.

Esquema de ligação

Pense na ligação em duas partes: o lado de potência (bateria, chave, L298N, motores) e o lado de sinal (os fios finos do Arduino até o L298N e o HC-05). Tire os pequenos jumpers dos pinos ENA e ENB do L298N; vamos ligar esses pinos às saídas PWM do Arduino para definir a velocidade no código. Deixe o jumper de 5V do L298N no lugar: como o pacote fica abaixo de 12 V, o regulador da própria placa alimenta a lógica do driver.

Escolhemos D5 e D6 como pinos de velocidade de propósito. No Uno, a biblioteca Servo desativa o PWM nos pinos 9 e 10, e a função tone() o desativa nos pinos 3 e 11. Com ENA e ENB em 5 e 6, o controle de velocidade dos motores continua funcionando quando você acrescentar um servo ou um buzzer depois. D2 e D3 ficam reservados para encoders porque suportam interrupções. Você pode ver a disposição dos pinos da sua placa na ferramenta Pinagem.

Primeiro sketch: para a frente, para trás, esquerda e direita

Antes de passar para o Bluetooth, vamos testar os motores e a ligação sozinhos. O coração do código é a função drive(left, right): ela recebe a velocidade de cada motor separadamente, de -255 a 255, em que um valor positivo significa para a frente, um negativo para trás e zero, parado. Explicamos como o valor de velocidade vira tensão em O que é PWM?. Antes de carregar, coloque o carrinho em cima de uma caixa para que as rodas girem livres; a espera de 3 segundos no setup() dá tempo para isso.

1// Sol motor / left motor: ENA=5, IN1=7, IN2=8 — Sağ motor / right motor: ENB=6, IN3=9, IN4=4
2const int ENA = 5, IN1 = 7, IN2 = 8;
3const int ENB = 6, IN3 = 9, IN4 = 4;
4
5const int SPEED = 180;   // temel hız 0-255 / base speed 0-255
6const int TRIM = 0;      // % düzeltme: + sol, - sağ motoru yavaşlatır / % trim: + slows left, - slows right
7
8void drive(int left, int right) {               // her biri -255 … 255 / each -255 … 255
9  if (TRIM > 0) left = left * (100 - TRIM) / 100;
10  if (TRIM < 0) right = right * (100 + TRIM) / 100;
11  digitalWrite(IN1, left > 0);  digitalWrite(IN2, left < 0);
12  digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
13  analogWrite(ENA, abs(left));
14  analogWrite(ENB, abs(right));
15}
16
17void forward()   { drive(SPEED, SPEED); }
18void backward()  { drive(-SPEED, -SPEED); }
19void turnLeft()  { drive(-SPEED, SPEED); }     // yerinde sola / spin left in place
20void turnRight() { drive(SPEED, -SPEED); }     // yerinde sağa / spin right in place
21void stopCar()   { drive(0, 0); }
22
23void setup() {
24  int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
25  for (int p : pins) pinMode(p, OUTPUT);
26  stopCar();
27  delay(3000);             // tekerlekleri kaldırmak için zaman / time to lift the wheels
28}
29
30void loop() {
31  forward();   delay(1500);
32  stopCar();   delay(500);
33  backward();  delay(1500);
34  stopCar();   delay(500);
35  turnLeft();  delay(600);
36  stopCar();   delay(500);
37  turnRight(); delay(600);
38  stopCar();   delay(2000);
39}

Com as rodas no ar, o carrinho deve ir para a frente, para trás, para a esquerda e para a direita, um de cada vez. Se uma roda girar no sentido errado, não mude o código; troque os dois fios daquele motor nos terminais OUT do L298N. Se as duas rodas girarem no sentido errado, troque os fios dos dois motores. Se os motores zumbirem mas não girarem, o valor de SPEED está baixo demais: a maioria dos motores TT precisa de um valor PWM de pelo menos uns 80–120 para começar a se mover, e esse limite sobe conforme a bateria descarrega.

Controle por Bluetooth pelo celular (HC-05)

O HC-05 funciona como um cabo serial sem fio entre o celular e o Arduino: o app no celular envia uma letra, o Arduino a lê e faz o movimento correspondente. A maioria dos apps de controle que você encontra na Play Store buscando “Bluetooth RC Car” ou “Bluetooth RC Controller” envia F para a frente, B para trás, L para a esquerda, R para a direita e S para parar quando você solta um botão; alguns também usam G, I, H e J para as diagonais e 0–9 mais q para a velocidade. Os pinos do módulo, os padrões do LED e os comandos AT estão em módulo Bluetooth HC-05.

1. A chave do carrinho pode ficar desligada enquanto você carrega o sketch abaixo; o Arduino e o HC-05 são alimentados pelo USB. Se o LED do HC-05 piscar rápido, o módulo está esperando uma conexão.
2. Encontre o HC-05 nas configurações de Bluetooth do seu celular Android e faça o pareamento com o PIN 1234 (ou 0000, se não der certo).
3. Abra o app de controle, conceda as permissões de Bluetooth e de dispositivos por perto e selecione o HC-05 na lista de dispositivos. Depois de conectado, o LED do módulo dá duas piscadas curtas a cada dois segundos.
4. Mantenha o Arduino ligado pelo USB, abra o Monitor Serial em 9600 baud e aperte os botões no app. A letra que cada botão envia aparece na tela; se o seu app enviar letras diferentes, mude as linhas case no código para combinar.
5. Desconecte o cabo USB, ligue a chave, coloque o carrinho no chão e dirija.

1#include <SoftwareSerial.h>
2
3SoftwareSerial bt(10, 11);               // RX, TX → HC-05 TXD, RXD (RXD bölücüyle / RXD via divider)
4
5const int ENA = 5, IN1 = 7, IN2 = 8;     // sol motor / left motor
6const int ENB = 6, IN3 = 9, IN4 = 4;     // sağ motor / right motor
7const int TRIM = 0;                      // % düzeltme / % trim
8const unsigned long TIMEOUT = 600;       // ms; 0 = kapalı / 0 = disabled
9
10int speed = 200;                         // 0-255
11unsigned long lastCmd = 0;
12
13void drive(int left, int right) {
14  if (TRIM > 0) left = left * (100 - TRIM) / 100;
15  if (TRIM < 0) right = right * (100 + TRIM) / 100;
16  digitalWrite(IN1, left > 0);  digitalWrite(IN2, left < 0);
17  digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
18  analogWrite(ENA, abs(left));
19  analogWrite(ENB, abs(right));
20}
21
22void setup() {
23  int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
24  for (int p : pins) pinMode(p, OUTPUT);
25  drive(0, 0);
26  Serial.begin(9600);                    // gelen harfleri görmek için / to see incoming letters
27  bt.begin(9600);                        // HC-05 veri modu hızı / HC-05 data mode baud rate
28}
29
30void loop() {
31  if (bt.available()) {
32    char c = bt.read();
33    Serial.println(c);
34    lastCmd = millis();
35    int half = speed / 2;
36    switch (c) {
37      case 'F': drive(speed, speed);   break;   // ileri / forward
38      case 'B': drive(-speed, -speed); break;   // geri / backward
39      case 'L': drive(-speed, speed);  break;   // yerinde sola / spin left
40      case 'R': drive(speed, -speed);  break;   // yerinde sağa / spin right
41      case 'G': drive(half, speed);    break;   // ileri-sol / forward-left
42      case 'I': drive(speed, half);    break;   // ileri-sağ / forward-right
43      case 'H': drive(-half, -speed);  break;   // geri-sol / back-left
44      case 'J': drive(-speed, -half);  break;   // geri-sağ / back-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, 100, 240);   // hız kademesi / speed level
49    }
50  }
51  if (TIMEOUT > 0 && millis() - lastCmd > TIMEOUT) drive(0, 0);   // komut yoksa dur / no command: stop
52}

O TIMEOUT do código é um recurso de segurança: esses apps ficam enviando a mesma letra enquanto você segura um botão, então, se nenhuma letra chegar por 600 ms, o código entende que a conexão caiu e para o carrinho. Assim o carrinho não continua indo em direção à parede quando o celular sai do alcance ou o app fecha. Se o seu app enviar a letra só uma vez por toque no botão, o carrinho vai parar depois de 600 ms; nesse caso, coloque TIMEOUT em 0 para desativar esse recurso. Também não usamos delay() em nenhum lugar do loop(); esperas longas fazem os comandos atrasarem, e você descobre por quê em millis() vs delay().

O carrinho não anda reto: causas e soluções

Se o carrinho desvia devagar para um lado mesmo que você dê o mesmo valor PWM de “para a frente” aos dois motores, não se preocupe; esse é o problema mais comum de carrinhos robô. Motores baratos com redução giram em velocidades diferentes mesmo com a mesma tensão: diferenças no atrito das engrenagens, nas escovas e nos ímãs deixam cada motor um pouco diferente. Some uma roda frouxa, uma roda boba que fica girando ou peso concentrado de um lado, e um desvio de 20–30 cm em 2 metros é perfeitamente normal. Corrija primeiro as causas mecânicas e depois ajuste a diferença que sobrar no software.

Depois de resolver os problemas mecânicos, faça o ajuste fino no software. A constante TRIM do código diminui em uma porcentagem a velocidade do motor mais rápido: um valor positivo deixa o motor esquerdo mais lento, um negativo, o direito. Calibre assim:

1. Carregue totalmente as células; calibrar com a bateria cheia dá resultados consistentes.
2. Cole no chão uma faixa reta de fita de 2 metros e coloque o carrinho no início, apontando ao longo da fita.
3. No loop() do primeiro sketch, deixe só forward() e uma espera de 3 segundos e deixe o carrinho andar.
4. Se o carrinho desviar para a direita, o motor esquerdo está mais rápido: aumente o TRIM em 3; se desviar para a esquerda, diminua o TRIM em 3.
5. Repita até o desvio em 2 metros cair para poucos centímetros e depois copie o mesmo valor de TRIM para o sketch do Bluetooth.
6. Calibre na velocidade que você mais usa; a diferença entre os motores muda um pouco com a velocidade.

O próximo nível para andar perfeitamente reto e medir distância é o encoder. Você encaixa os discos de 20 fendas do kit nos eixos dos motores e conta cada fenda com um sensor de velocidade de fenda baseado no LM393. Ligue as saídas dos sensores aos pinos D2 e D3, que aceitam interrupções, e compare a contagem de pulsos das duas rodas: se o lado esquerdo se adiantar, diminua um pouco a velocidade do motor esquerdo. Esse controle proporcional (P) simples mantém o carrinho reto independentemente do nível da bateria e do piso. Uma roda de 65 mm percorre cerca de 20,4 cm por volta, então cada pulso significa aproximadamente 1 cm de deslocamento. Explicamos como as interrupções funcionam em Interrupções no Arduino.

O Arduino reinicia quando os motores ligam

Se o Arduino reinicia ou o HC-05 perde a conexão (o LED volta a piscar rápido) quando o carrinho arranca, muda de sentido ou bate em um obstáculo, o problema quase sempre está na alimentação. Na arrancada, os dois motores juntos podem puxar 2–3 A; uma bateria fraca não consegue fornecer isso e a tensão dela desaba por um instante. O processador do Uno se reinicia por segurança quando a alimentação cai abaixo de 2,7 V (brown-out). Some a isso o ruído elétrico das escovas dos motores e a queda de tensão em fios finos. Estas são as soluções, começando pela mais eficaz:

• Troque a bateria: use duas células 18650 carregadas em vez de uma bateria de 9 V ou de pilhas AA cansadas; a maioria dos problemas acaba aqui.
• Use o caminho de alimentação certo: alimente o Arduino pela bateria através do VIN; não ligue a saída 5V do L298N ao VIN.
• Capacitores nos motores: solde um capacitor cerâmico de 100 nF entre os dois terminais de cada motor; ele suprime o ruído das escovas na origem.
• Capacitor de reserva: ligue um capacitor eletrolítico de 470–1000 µF aos terminais 12V e GND do L298N (terminal positivo no 12V). Ele cobre a demanda de corrente momentânea na arrancada.
• Partida suave: em vez de saltar para 255, aumente a velocidade passo a passo, como mostrado abaixo; o pico de corrente fica menor.
• Pare antes de dar ré: passar direto de para a frente para trás leva a corrente do motor ao pico; pare por 100–200 ms antes de mudar o sentido.
• Fios de potência grossos e curtos: não use jumpers nem protoboard entre a bateria e o L298N; use fio de pelo menos 0,5 mm² e bornes com parafuso.
• Fontes separadas: se o problema continuar, alimente o Arduino com um power bank e os motores com a bateria e ligue os dois GNDs.

1// Yumuşak kalkış: ilk koddaki drive() ile kullan / soft start: use with drive() from the first sketch
2void rampTo(int target) {
3  for (int s = 60; s < target; s += 20) {
4    drive(s, s);
5    delay(15);              // yaklaşık 10 adımda tam hız / full speed in about 10 steps
6  }
7  drive(target, target);
8}
9
10// Kullanım: forward() yerine rampTo(SPEED) / usage: rampTo(SPEED) instead of forward()

Carrinho robô com ESP32 e Raspberry Pi Pico

O ESP32 tem Bluetooth clássico embutido, então você não precisa de um HC-05: a biblioteca BluetoothSerial cria a mesma conexão serial com o celular, e os apps de controle acima funcionam sem mudanças. As entradas do L298N entendem como HIGH qualquer valor acima de cerca de 2,3 V, então os sinais de 3,3 V do ESP32 bastam. Alimente a placa ESP32 pela saída 5V do L298N no pino 5V (VIN) da placa; não ligue a bateria direto nesse pino. Este código não compila para o ESP32-S3 e o ESP32-C3, porque eles só têm BLE.

1#include "BluetoothSerial.h"
2
3BluetoothSerial bt;
4
5const int ENA = 25, IN1 = 27, IN2 = 33;   // sol motor / left motor
6const int ENB = 26, IN3 = 32, IN4 = 4;    // sağ motor / right motor
7
8int speed = 200;                          // 0-255
9unsigned long lastCmd = 0;
10
11void drive(int left, int right) {
12  digitalWrite(IN1, left > 0);  digitalWrite(IN2, left < 0);
13  digitalWrite(IN3, right > 0); digitalWrite(IN4, right < 0);
14  analogWrite(ENA, abs(left));
15  analogWrite(ENB, abs(right));
16}
17
18void setup() {
19  int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
20  for (int p : pins) pinMode(p, OUTPUT);
21  drive(0, 0);
22  bt.begin("BlueGrays-Car");              // telefonda görünecek ad / name shown on the phone
23}
24
25void loop() {
26  if (bt.available()) {
27    char c = bt.read();
28    lastCmd = millis();
29    switch (c) {
30      case 'F': drive(speed, speed);   break;   // ileri / forward
31      case 'B': drive(-speed, -speed); break;   // geri / backward
32      case 'L': drive(-speed, speed);  break;   // yerinde sola / spin left
33      case 'R': drive(speed, -speed);  break;   // yerinde sağa / spin right
34      case 'S': drive(0, 0);           break;   // dur / stop
35      case 'q': speed = 255;           break;   // tam hız / full speed
36      default:
37        if (c >= '0' && c <= '9') speed = map(c - '0', 0, 9, 100, 240);
38    }
39  }
40  if (millis() - lastCmd > 600) drive(0, 0);    // komut yoksa dur / no command: stop
41}

O Raspberry Pi Pico padrão não tem Bluetooth, então você liga o HC-05 aos pinos da UART0. Como o Pico trabalha em 3,3 V, desta vez não é preciso divisor de tensão. Alimente o Pico pelo pino VSYS e o HC-05 direto pela saída 5V do L298N; funcionando com baterias, sem USB, não há tensão no pino VBUS. No código do Pico, a velocidade é dada em porcentagem, de -100 a 100:

1from machine import Pin, PWM, UART
2import time
3
4bt = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))   # GP0 → HC-05 RXD, GP1 ← HC-05 TXD
5
6ena = PWM(Pin(15)); ena.freq(1000)                  # sol motor hızı / left motor speed
7enb = PWM(Pin(10)); enb.freq(1000)                  # sağ motor hızı / right motor speed
8in1, in2 = Pin(14, Pin.OUT), Pin(13, Pin.OUT)
9in3, in4 = Pin(12, Pin.OUT), Pin(11, Pin.OUT)
10
11def drive(left, right):                             # -100 … 100 (%)
12    in1.value(left > 0); in2.value(left < 0)
13    in3.value(right > 0); in4.value(right < 0)
14    ena.duty_u16(int(abs(left) * 655))
15    enb.duty_u16(int(abs(right) * 655))
16
17speed = 80
18last = time.ticks_ms()
19drive(0, 0)
20
21while True:
22    if bt.any():
23        c = bt.read(1)
24        last = time.ticks_ms()
25        if c == b'F':   drive(speed, speed)          # ileri / forward
26        elif c == b'B': drive(-speed, -speed)        # geri / backward
27        elif c == b'L': drive(-speed, speed)         # yerinde sola / spin left
28        elif c == b'R': drive(speed, -speed)         # yerinde sağa / spin right
29        elif c == b'S': drive(0, 0)                  # dur / stop
30        elif c == b'q': speed = 100                  # tam hız / full speed
31        elif c and 48 <= c[0] <= 57:                 # '0'…'9' hız kademesi / speed level
32            speed = 40 + (c[0] - 48) * 6
33    if time.ticks_diff(time.ticks_ms(), last) > 600:
34        drive(0, 0)                                  # komut yoksa dur / no command: stop

Próximos passos: melhore o seu carrinho

• Robô que desvia de obstáculos: acrescente na frente um sensor de distância HC-SR04 e um servo motor que o vira para a esquerda e para a direita; detalhes no guia Robô que desvia de obstáculos.
• Robô seguidor de linha: coloque 2–3 sensores infravermelhos TCRT5000 embaixo da frente e siga uma linha preta no chão; veja Robô seguidor de linha.
• Controle com joystick: monte um controle de verdade, sem celular, com um segundo Arduino, um módulo joystick e um nRF24L01.
• Controle infravermelho: dirija com os botões do controle da TV; associe os códigos de Receptor IR + controle remoto aos comandos de direção.
• Direção por Wi-Fi: use um ESP32 para servir uma página de controle que abre no navegador do celular; o guia Servidor web e WebSocket com ESP32 cobre o básico.
• Encoders e distância: use sensores de velocidade para andar exatamente 1 metro e girar exatamente 90 graus; essa é a base dos robôs que resolvem labirintos.
• Braço robótico: acrescente em cima do carrinho um pequeno braço robótico com servos para carregar objetos.

Erros comuns e soluções

• Nenhum motor gira: os GNDs não estão em comum, a chave está desligada, os jumpers de ENA e ENB foram retirados mas os pinos não estão ligados, ou a bateria está descarregada.
• O LED do L298N acende, mas os motores só zumbem: o valor PWM está abaixo do limite de partida do motor ou a tensão da bateria está baixa; aumente a velocidade e carregue a bateria.
• O sketch não carrega: pode estar selecionada a porta ou a placa errada; se você ligou o HC-05 nos pinos 0 e 1, desligue-o durante o carregamento. Outras causas em Erro ao carregar código no Arduino.
• O celular vê o HC-05, mas não conecta: o módulo está conectado a outro celular, o app não recebeu a permissão de “dispositivos por perto” ou o PIN de pareamento está errado.
• O carrinho reage aos comandos com atraso: há um delay() no loop() ou muita coisa sendo mostrada no Monitor Serial; faça as esperas com millis().
• O dissipador do L298N esquenta muito: as rodas estão travadas ou, em um carrinho 4WD, a corrente por canal está alta demais; procure atrito mecânico.
• O carrinho dá um tranco ao ligar: os pinos ficam indefinidos por um instante na inicialização; defina os pinos como saída e chame drive(0, 0) logo nas primeiras linhas do setup().

Um carrinho robô com Arduino é um ótimo ponto de partida que ensina controle de motores, gestão de energia, comunicação sem fio e depuração em um único projeto. Quando terminar, você vai ter um chassi que fica um pouco mais inteligente a cada sensor novo. No app BlueGrays você encontra passo a passo, com esquemas do circuito e código, os projetos do carrinho controlado por Bluetooth com L298N, do robô que desvia de obstáculos e da detecção de superfície preta e branca com TCRT5000.