Projetos

A placa de desenvolvimento Intel Galileo

Acionar portas do Arduíno com módulo Bluetooth via Android

Comandos para usar o módulo de pen drive com o Arduino

Como usar o display Nokia5110 com o Arduino

Comunicação entre dois Arduinos

Controlando um LED RGB no Arduino

Controlando um servo motor com Arduino

Dando “vida” ao chassi TG007 usando um Arduino

Dando “vida” ao chassi TG007 usando um Arduino e dois transistores TIP 102

Gerar imagens na televisão usando o Arduino

Interação Arduino + Potenciômetro + Processing

Interação Java com Arduino

Medindo distâncias com um sensor ultrasônico e um Arduino

Montando um Arduino

Multiplexando 2 displays de 7 segmentos no Arduino

Reproduzindo som WAV com seu Arduino

Usando o sensor RGB TCS230 no Arduino

Usando sensor de luz com Arduino

Usando um relógio de tempo real com Arduino

Utilizando Acelerômetro MMA7361 com Arduino

Utilizando módulo Ethernet

Utilizando um teclado matriz 4x4 no Arduino

5 coisas que você tem que saber fazer com o Arduino

Acionando motores de passo com o Arduino

Acionando um display de 7 segmentos no Arduino

Como ligar um motor de vidro de carro usando arduino

Como realizar interação entre o Arduino e o Processing

Como usar a memória EEPROM do Arduino

Como usar cartões SD com o Arduino

Como usar o módulo RF NRF24L01+ no Arduino

Como usar o Wifi Shield com o Arduino

Como usar um coletor de RFID com o Arduino

Construindo e controlando uma matriz de LEDs

Construindo um robô com o kit TG007 da Tato Equipamentos Eletrônicos

Controlando servo motor usando o Scratch for Arduino (S4A)

Criando App para Robô com arduino+Bluetooth+Câmera IP

Gravando dados em pen drive usando o Arduino

Gravando o bootloader Arduino usando Arduino

Gravando sketch no Arduino pela linha de comandos do Linux

Interface gráfica para o Arduino com Processing

Lendo dados de um módulo GPS no Arduino

Lendo dados de um pen drive usando o Arduino

Os componentes disponíveis no simulador de Arduino

Programando um relógio no Arduíno

Reproduzindo som com o Arduino

Simulando o Arduino via software on-line

Usando bússola eletrônica com Arduino

Usando leitor de RFID Mifare RC522

Usando módulo sintonizador de FM com Arduino

Usando o Scratch (S4A) para programar o Arduino

Usando o sensor de umidade e temperatura DHT11

Usando sensor de obstáculos no Arduino

Usando sensor de umidade com o Arduino

Usando um display LCD com o Arduino

Utilizando módulo bluetooth com Arduino

Utilizando sensor ultrassônico para medir distancias (Sensor 5 pinos)

Verificar se o pen drive está inserido no módulo

Medindo distâncias com um sensor ultrasônico e um Arduino

Com um Arduino em mãos e um sensor de sonar de baixo custo é possível, com pouquíssima solda e um programa muito pequeno, medir distâncias como faz uma trena eletrônica.

Você vai precisar de:

Um Arduino:

Um sensor de sonar ultrassom, que no caso dessa experiência usei um Sonar Ultrassom Griffus (V9), com custo aproximado de R$60,00 na Tato Equipamentos Eletrônicos (www.tato.ind.br) . Com esse mesmo preço é possível encontrar inúmeros outros sonares no mercado com pinagem e funcionamento idênticos ao que vou utilizar aqui.

O primeiro passo é soldar alguns fios nos pinos do sensor, para facilitar a ligação entre ele e o Arduino. Usei um pequeno pedaço de cabo de rede, removendo os fios internos. A grande sacada é usar fios coloridos, com cores diferentes, para identificar cada pino do sensor.

Feito as soldas, agora é só ligar o pino 5V do sensor ao 5V do Arduino, o GND (terra) ao GND do Arduino, o pino OUT ao pino digital 7 e o pino IN poderá ficar sem ligação por enquanto, para essa experiência ele não terá utilidade.

Agora só falta digitar o seguinte código no ambiente de desenvolvimento do Arduino e fazer upload para a placa:

void setup() {
pinMode(13, OUTPUT);
pinMode(7, INPUT);
Serial.begin(9600);
}
void loop() {
float tempo, dist;
tempo = pulseIn(7, HIGH);
dist = ((tempo * 350)/1000000)/2;
Serial.print(tempo);
Serial.print(" microssegundos, ");
Serial.print(dist);
Serial.print(" metros");
Serial.println();
delay(500);
}

O que fizemos, passo-a-passo:

Coloca o pino digital 13 no modo saída :

pinMode(13, OUTPUT);

Coloca o pino digital 7 como entrada:

pinMode(7, INPUT);

Inicia a comunicação serial em 9600bps:

Serial.begin(9600);

No loop principal:

Declaração das variáveis necessárias:

float tempo, dist;

A função pulseIn() retorna o tempo em microssegundos entre a mudança de estado de um determinado pino, ou seja, começa a contar quando o estado do pino vai a LOW e para quando o estado vai para HIGH e vice-versa, dependendo dos parâmetros utilizados:

tempo = pulseIn(7, HIGH);

Cálculo da distância percorrida pelo pulso ultrassonico. Considerei que a velocidade do som é de aproximadamente 350 metros por segundo:

dist = ((tempo * 350)/1000000)/2;

Envia via porta serial os dados que especifica:

Serial.print(tempo);

Serial.print(" microssegundos, ");

Serial.print(dist);

Serial.print(" metros");

Serial.println();

Faz uma pausa de meio segundo, ou 500 milissegundos:

delay(500);

Compile e envie o programa para seu Arduino, abra o Serial Monitor e coloque objetos (pode ser a mão) em frente ao seu sensor de sonar e veja o resultado:

Há alguns desafios com esse projeto, a saber:

1. Existe um limiar de medição mínimo e máximo para cada tipo de sonar ultrassônico, é preciso identificar esses limites;

2. Há uma latência do próprio Arduino e da execução do programa que deve ser considerado;

3. A velocidade do som no ar varia de acordo com a temperatura do meio, talvez para conseguir um máximo de performance deva-se adicionar um termo sensor ao projeto;

Acionando motores de passo com o Arduino

Motores de passos são equipamentos interessantes uma vez que podemos determinar a velocidade de a quantidade de graus que desejamos que eles virem.

Porém no quesito velocidade não são tão eficientes, uma vez que girando muito rápido, devido a inércia do rotor eles podem girar mais do que o desejado, perdendo passos, ou seja, devem ser utilizados em baixas velocidades.

Você pode encontrar motores de passo em vários lugares: lojas na Internet, impressoras e drives velhos.

Existem vários tipos, o que vamos usar é um motor de passos de 6 fios, comprado na Internet. Esse aqui:

Como comprei o motor na Internet junto veio a descrição dos fios, sendo:

Verde – bobina 1

Marrom – bobina 2

Amarelo – bobina 3

Vermelho – bobina 4

Preto (2 fios) – comum

Caso você use um motor usado, obtido de uma impressora ou scanner, por exemplo, para identificar o fio comum use um multímetro e encontre o fio com a menor resistência entre todos, ele será o comum.

Também precisaremos de uma fonte de alimentação para o motor, já que o Arduino é alimentado com os 5V da porta USB e o motor de passo, invariavelmente, trabalha com 12V. Você deve escolher uma fonte que forneça como saída no máximo 500mA, devido a limitação do circuito integrado que usaremos, descrito mais abaixo. Identificar isso numa fonte hoje em dia é fácil, pois esse tipo de informação vem impresso nela. A que vou usar fornece 12V de saída à 200mA:

Para controlar o motor precisamos de um driver para motor de passo sendo que o CI ULN2003 atende bem a essa necessidade. O CI que usarei seja exatamente esse e que aparece na imagem abaixo:

À esquerda do CI temos os pinos de 1 até 8, de cima para baixo e à direita temos os pinos 9 até 16, de baixo para cima. À esquerda temos as entradas de dados e à direita às saídas. Lembre-se que a saída suporta no máximo 500mA!

Ligaremos o CI obedecendo ao seguinte esquema:

Sendo:

A – pino 3 do Arduino

B – pino 4 do Arduino

C – pino 5 do Arduino

D – pino 6 do Arduino

1 – Bobina 1 do motor

2 – Bobina 2 do motor

3 – Bobina 3 do motor

4 – Bobina 4 do motor

5 – ao comum do motor

12V – ao positivo da fonte

GND – ao negativo da fonte

Zener – Diodo Zener de 12V 0,5W, como o da imagem abaixo:

Vamos montar tudo em uma placa de ensaio (proto-board):

Tudo ligar e verificado, agora é hora de desenvolvermos nosso programa em C para o Arduino:

void setup()
{
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
}
void loop()
{
digitalWrite(3,HIGH);
delay(100);
digitalWrite(3,LOW);
delay(1 00);
digitalWrite(4,HIGH);
delay(100);
digitalWrite(4,LOW);
delay(100);
digitalWrite(5,HIGH);
delay(100);
digitalWrite(5,LOW);
delay(100);
digitalWrite(6,HIGH);
delay(100);
digitalWrite(6,LOW);
delay(100);
}

Com esse código damos um passo completo de cada vez, ou seja, energizamos uma bobina a cada vez.

Podemos melhorá-lo para dar meio passo, ou seja, energizar as bobinas aos pares, assim o motor girará mais suavemente:

 
void setup()
{
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
}
void loop()
{
digitalWrite(3,HIGH);
delay(100);
digitalWrite(4,HIGH);
delay(100);
digitalWrite(3,LOW);
delay(1 00);
digitalWrite(5,HIGH);
delay(100);
digitalWrite(4,LOW);
delay(100);
digitalWrite(6,HIGH);
delay(100);
digitalWrite(5,LOW);
delay(100);
digitalWrite(3,HIGH);
delay(100);
digitalWrite(6,LOW);
}

Alguns pontos nesse projeto a serem considerados:

1. Para inverter a rotação, basta inverter a sequencia da energização das bobinas;

2. Há um aquecimento no CI ULN2003, portanto é preciso uma dissipação desse calor;

3. Existem também aquecimento no motor, quando maior o tempo de uso maior a geração de calor;

4. No caso de uma montagem autônoma será preciso de uma fonte 12V para o motor independente da alimentação 5V para o Arduino;

Programando um relógio no Arduíno

Existem muitas aplicações, somente de software ou de automação, onde contar o tempo é necessário, ou seja, onde é preciso ter um relógio.

Esse relógio pode ser feito apenas via software, com programação, ou pode ser implementado utilizando-se hardware específico (cristal oscilador e etc.). A ideia deste artigo é utilizar apenas técnicas de programação e comandos da linguagem C do Arduino para programar um relógio.

Eis o código fonte:

int seg=0,
min=0,
hor=0;
 
void setup()
{
Serial.begin(9600);
}
 
void loop()
{
static unsigned long ult_tempo = 0;
int tempo = millis();
if(tempo - ult_tempo >= 1000) {
ult_tempo = tempo;
seg++;
}
if(seg>=60) {
seg = 0;
min++;
}
if(min>=60) {
min = 0;
hor++;
}
if(hor>=24) {
hor=0;
min=0;
}
Serial.print(hor);
Serial.print(":");
Serial.print(min);
Serial.print(":");
Serial.println(seg);
delay(1000);
}

O que fizemos:

A função millis() retorna a quantidade de milissegundos desde o início da execução do programa. Esse retorno é bastante estável uma vez que volta ao zero apenas em aproximadamente 50 dias!

A cada 1000 milissegundos contamos um segundo, incrementando a variável seg (segundos) e guardamos essa marca, para podermos refazer a conta para encontrar os próximos 1000 milissegundos, uma vez que a contagem da função millis() sempre caminha em frente (excento quando zera, no caso que comentei acima).

Depois disso é o mais fácil: a cada 60 segundos, incrementamos um minuto, a cada 60 minutos incrementamos uma hora e a cada 24 horas voltamos tudo ao zero.

O delay é para que a impressão no terminal serial não fique confusa, mostrando várias vezes o tempo repetidamente.

Uma vez compilado e enviado ao Arduino, basta iniciar o Serial Monitor e verificar a contagem do tempo:

Mas talvez, mais interessante ainda, é incluirmos alguma coisa para ajustarmos a contagem do tempo o horário atual. Para isso você vai precisar de:

1. Um Botão

2. Um resistor (220?)

3. Fios

A ligação é a seguinte:

GND---| Resistor |-----| Botão | --------------- Pino 3 do Arduino
5V-------------------------|          |

Altere o programa para que fique assim:

int seg=0,
min=0,
hor=0,
botao;
 
void setup()
{
pinMode(3,INPUT);
Serial.begin(9600);
}
 
void loop()
{
botao = digitalRead(3);
while(botao == HIGH) {
digitalWrite(13, HIGH);
botao = digitalRead(3);
min++;
if(min>=60) {
min = 0;
hor++;
}
if(hor>=24) {
hor=0;
min=0;
}
Serial.print(hor);
Serial.print(":");
Serial.print(min);
Serial.print(":");
Serial.println(seg);
delay(200);
}
static unsigned long ult_tempo = 0;
int tempo = millis();
if(tempo - ult_tempo >= 1000) {
ult_tempo = tempo;
seg++;
}
if(seg>=60) {
seg = 0;
min++;
}
if(min>=60) {
min = 0;
hor++;
}
if(hor>=24) {
hor=0;
min=0;
}
Serial.print(hor);
Serial.print(":");
Serial.print(min);
Serial.print(":");
Serial.println(seg);
delay(1000);
}

Com isso quando se mantem o botão pressionado o tempo correrá mais rápido, cada segundo será incrementado em 200 milissegundos, ou seja, o tempo correrá 5 vezes mais rápido. Ao despressionar o botão o tempo voltará a correr normalmente, com um segundo valendo um segundo.

Dessa forma você poderá ajustar o tempo do Arduino a um relógio.

Lógico, esse projeto pode ser melhorando em muito, seja CRIATIVO!

Usando sensor de obstáculos no Arduino

O sensor SHARP GP2Y0D810Z0F é um sensor detector de obstáculos baseado em distância. Ele detecta qualquer objeto que esteja a pelo menos 10 centímetro de distância do sensor usando emissão de luz infravermelha. Existem outros modelos desse mesmo sensor que detectam obstáculo a distâncias diversas, maiores que 10cm e menores também.

Quando “percebe” um obstáculo a 10 centímetro, ou menos, de distância coloca o pino de saída em nível lógico baixo (LOW), caso contrário, mantém o pino de saída como nível lógico alto (HIGH).

Com ele é possível desenvolver várias aplicações como detectar objetos sem toque, alternativa a interrupção de feixe, controle de cronometragem entre infinitas possibilidade.

Usar um sensor como esse, já montado em uma placa com todos os componentes necessários, como é possível encontrar para compra na Internet, no Arduino é a coisa mais fácil do mundo!

Fixe seu sensor em uma placa de ensaio (proto-board) e identifique os seus pinos:

Ligue o pino VIN ao pino 5V o pino GND ao GND do Arduino. O pino OUT você pode liga-lo ao pino 3, para executar o exemplo abaixo:

 
void setup() { 
pinMode(3,INPUT);
pinMode(13, OUTPUT); 
}
 
void loop() {
if(digitalRead(3)==LOW)
digitalWrite(13, HIGH);
else
digitalWrite(13, LOW);
}

Com esse código ligamos o LED do pino 13 (existente na placa do Arduino) quando um objeto é detectado na frente do sensor, caso contrário, o LED permanecerá apagado. Simples assim!

Abaixo todos os componentes em uma placa de ensaio:

 

Construindo um robô com o kit TG007 da Tato Equipamentos Eletrônicos

A grande questão em ler os tutoriais sobre o Arduino no site dicasarduino.blogspot.com não é conseguir operar e entender o funcionamento dos equipamentos separadamente, mas sim como juntá-los em única aplicação, todos operando para dar “vida” a um pequeno robô.

O primeiro teste de todos esses conceitos foi a grande alteração que fiz, com a ajuda de Erick Ribeiro e Marcelo Suzegan, em um despertador da Imaginarium que não funcionava há algum tempo, mas possui motores e rodas que poderiam ser reaproveitados.

A construção foi bem sucedida, mas não se pode dizer o mesmo quanto ao funcionamento: com uma das rodas com um pequeno dano, motores já fadigados o robô até se move, mas de forma irregular. Até que foi divertido todo o desafio de automatizá-lo, usando um Arduino, dois transistores, dois LEDs, um backligth (do display do relógio, que estava quebrado) e alguns resistores, mas não foi um resultado de encher os olhos.

A melhor solução não demorou a ser encontrada: o kit TG007 da Tato Equipamentos Eletrônicos, que pode ser comprado em www.tato.ind.br

Acessível e fácil de montar, com alguns componentes extras e um bom Arduino, que também pode ser adquirido na Tato via o site mostrou-se o melhor caminho para quem está começando, sem grandes conhecimentos de mecânica ou eletrônica, mas que gosta de passar horas divertidíssimas criando máquinas incríveis.

OK, vamos colocar a mão na massa, vamos montar nosso robozinho!

Após receber seu kit você perceberá que ele trás os seguintes componentes, além de um manual para montagem em inglês. Mas vamos facilitar as coisas mais ainda. Primeiro vamos conferir as partes:

02 chassis, um que será a parte superior (à esquerda da imagem) e outro que será a parte inferior (à direita da imagem) do robô. Esses chassis possuem o formato e as furações adequadas para o encaixe das peças e sensores diversos.

04 peças para suporte dos motores, sendo duas para cada motor

02 rodas dentadas que podem ser utilizadas junto a um sensor para medir distância e/ou velocidade

02 motores com caixa de redução

01 esfera de giro livre

02 rodas com pneus de borracha

01 suporte para 3 pilhas pequenas, padrão AA

08 espaçadores de 25mm e 4 espaçadores de 10mm

4 parafusos de 3mm de diâmetro e 30mm de comprimento com cabeça arredondada, 02 parafusos de 3mm de diâmetro e 10mm de comprimento com cabeça chata, 06 parafusos de 3mm de diâmetro e 6mm de comprimento com cabeça arredondada e 06 porcas para parafusos de 3mm de diâmetro

Com todas as peças em mãos, agora é só montar:

O primeiro passo é soldar fios aos motores, para que eles possam ser ligados ao equipamento depois. A melhor hora é essa, com tudo ainda desmontado. Solte os motores da caixa de redução. Eles são bem presos com duas tiras plásticas flexíveis. A remoção deve ser feita com calma e sem força, é tudo questão de jeito.

Solde os fios e coloque os motores de volta na caixa de redução, depois prendendo-os com as tiras plásticas.

Agora também é a melhor hora de colocar as rodas dentadas em uma das pontas de eixo dos motores. Faça isso também com jeito, sem forçar a caixa de redução. O resultado deve ser o seguinte:

Agora vamos colocar os suportes para os motores na parte inferior do chassis. Eles são apenas encaixados e quando aparafusados aos motores ficam firmes e perfeitamente presos.

Agora é só colocar os motores, um a cada vez, nos devidos lugares e usando dois parafusos de 30mm de comprimento afixá-los usando porcas na extremidade interna.

Visão interna:

Visão externa:

Tudo no lugar:

Encaixe as rodas nas pontas de eixo externas das caixas de redução:

Chegou a vez da esfera de giro livre, o apoio do robô. Usando dois espaçadores de 25mm e dois parafusos de 6mm com cabeça arredondada prenda-os no chassis inferior:

Usando mais dois parafusos de 6mm com cabeça arredondada prenda a esfera de giro livre aos espaçadores:

Ainda no chassis inferior, mas do lado oposto ao que foi instalado os motores e a esfera de giro livre, vamos fixar o suporte para pilhas. Faça isso usando os parafusos de cabeça chata:

O próximo passo é colocar 5 espaçadores de 25mm no chassis inferior, do mesmo lado do suporte para pilhas. Para fixa-los use parafusos de 6mm de comprimento prendendo-os firmemente, esses espaçadores serão utilizados para fixar o chassis superior. Você pode escolher as melhores posições para os espaçadores de acordo com seu projeto em concordância com a furação preexistente, veja as posições que escolhi na imagem abaixo:

Antes de aparafusar o chassis superior aos espaçadores, coloque nele dois espaçadores de 10mm de comprimento para que seja possível aparafusar o Arduino ao chassis superior. A melhor hora é agora, pois os espaçadores de 10mm terão que ser aparafusados por baixo. Com os espaçadores no lugar agora é aparafusar o chassis superior:

A montagem está pronta, daqui para frente é dar “vida para a máquina”!

Dando “vida” ao chassi TG007 usando um Arduino

Para isso utilizei um controlador para dois motores DC baseado no CI TB6612FNG que tem entre as vantagens do baixo consumo de eletricidade, o pequeno tamanho e consequentemente peso quase desprezível para qualquer projeto de robótica.

O primeiro passo é fixar o seu Arduino ao chassi:

Feito isso encontre uma placa de ensaios (proto-board) que seja pequena o suficiente para abrigar todo o projeto e caiba sobre o robô ou faça como eu, corte uma que esteja disponível ao meio para essa tarefa. Lembre-se que se decidir corta uma placa de ensaios ao meio faça com capricho e com a certeza do que faz.

Prenda-a ao chassi:

Agora vamos colocar a placa do TB6612FNG na placa de ensaios:

Atente-se a nomenclatura dos pinos conforme a figura abaixo:

Vamos às ligações:

1º Conecte os pinos terra (GND) ao GND do Arduino, menos aquele que se encontra imediatamente abaixo do pino VMOT. Facilitará se você colocar uma ligação entre o pino terra do Arduino e a placa de ensaios no barramento lateral, em seguida, ligue os pinos GND ao mesmo barramento.

2º Ligue o pino VCC ao pino de 5V do Arduino. Pode-se fazer o mesmo que foi feito em relação aos pinos GND, ligue o 5V do Arduino a placa de ensaios no barramento lateral e depois ligue o pino VCC ao mesmo barramento. Isso irá facilitar caso deseje adicionar componentes que precise desses mesmos pinos.

3º Conecte os pinos AO1 ao negativo do motor 01 e o pino AO2 ao positivo do motor 01. Conecte também os pinos BO1 ao positivo do motor 02 e o pino BO2 ao negativo do motor 02. Tente manter certa organização nos fios.

4º Conecte o pino VMOT ao positivo das pilhas do seu chassi, elas que fornecerão eletricidade aos motores e não a fonte de alimentação que estiver no Arduino. Abaixo do pino VMOT há um terra (GND), esse deverá ser ligado ao negativo das pilhas. Essa separação é importantíssima, uma fonte para os motores (potência) e uma para o Arduíno. Para essa ligação faça como fizemos com os pinos GND e 5V do Arduino, use a placa de ensaios como intermediária.

5º Ligue o pino PWMA ao pino digital 05 do Arduino. Com ele que diremos a que velocidade o motor 01 deverá girar.

6º Ligue os pinos AIN2 e AIN1 aos pinos digitais 7 e 8, respectivamente, no Arduino. Com eles que acionaremos o motor 01. Pode paracer impossível, mas tente manter ordem no aparente caos de fios.

7º Ligue o pino STBY ao pino digital 11 do Arduino. Com esse pino é possível colocar e tirar a o TB6612FNG do estado de dormência (standby).

8º Ligue os pinos BIN1 e BIN2 aos pinos digitais 9 e 10, respectivamente, no Arduino. Com eles que acionaremos o motor 02.

9º Ligue o pino PWMB ao pino digital 6. Com ele que diremos a que velocidade o motor 02 deverá girar.

Agora pode apreciar! Debaixo dessa “confusão” de fios está o nosso protótipo de robô!

Em resumo temos:

Pinos 07 e 08 – motor 01

Pinos 09 e 10 – motor 02

Pino 05 – potência motor 01

Pino 06 – potência motor 02

Pino 11 - standby

Vamos programá-lo e fazê-lo andar de um lado por um segundo, e para o outro também por um segundo.

A combinação de níveis para os pinos dos motores é a seguinte:

Pino	Nível	Direção
7	HIGH	Motor 01 em frente
8	LOW
7	LOW	Motor 01 para trás
8	HIGH
7	LOW	Motor 01 parado
8	LOW
9	HIGH	Motor 02 em frente
10	LOW
9	LOW	Motor 02 para trás
10	HIGH
9	LOW	Motor 02 parado
10	LOW

O código do exemplo é o que segue:

void setup() { 
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, INPUT);
pinMode(10, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(11, OUTPUT);
}
 
void loop() {
// Toda a força!
digitalWrite(5,255);
digitalWrite(6,255);
// Para frente
digitalWrite(7,HIGH);
digitalWrite(8,LOW);
digitalWrite(9,HIGH);
digitalWrite(10,LOW);
// Sair do estado de dormência
digitalWrite(11,HIGH);
// Aguardar 1 segundo
delay(1000);
// Entrar no estado de dormência
digitalWrite(11,LOW);
// Aguardar 1 segundo
delay(1000);
// Para trás
digitalWrite(7,LOW);
digitalWrite(8,HIGH);
digitalWrite(9,LOW);
digitalWrite(10,HIGH);
// Sair do estado de dormência
digitalWrite(11,HIGH);
// Aguardar 1 segundo
delay(1000);
// Entrar no estado de dormência
digitalWrite(11,LOW);
// Aguardar 1 segundo
delay(1000);
// Para trás
}

O projeto funcionando:

Considerações finais:

1. Cuidado na ligação dos fios;

2. Atenção ao aquecimento dos motores e do TB6612FNG

3. Agora é só adicionar sensores e programar outros comportamentos