RoboCarinhas: o Robô que Muda de Cara a Cada Direção
Um robô de duas rodas que anda para frente, para trás, para a esquerda e para a direita, e troca de expressão na tela da UNIHIKER K10 a cada direção.
Um robô que muda de cara conforme o caminho
Vai para frente? Olhos olhando para cima e sorrisão. Dá ré? Sobrancelhas preocupadas e boca em "o". Gira? Olhar de lado e sorriso torto. O RoboCarinhas é isso: um robô de duas rodas que troca de expressão na tela da UNIHIKER K10 a cada direção que toma.
Aqui você confere as peças usadas, como elas se juntam, o código do robô e a biblioteca para a Arduino IDE que foi preciso criar para chegar até aqui, a TR0548_K10. No final, o próximo passo: fazer o robô obedecer comandos de voz.
Agradecimento à RoboCore
Todos os materiais deste projeto — a plataforma, a placa, o controlador de motores, o suporte e a bateria — foram cedidos gentilmente pela RoboCore, para fins de gerar conhecimento. Sem essa parceria, o RoboCarinhas não sairia da ideia. Obrigado, RoboCore!
As peças do RoboCarinhas
São cinco peças, todas da RoboCore: o chassi com motores e rodas, o cérebro com tela, o controlador que dá força aos motores e a bateria com o seu suporte.
- Plataforma Robótica Falcon V2 — chassi 2WD: base, dois motores DC com caixa de redução, duas rodas e esfera deslizante
- UNIHIKER K10 — cérebro do robô e rosto: roda o programa e desenha as carinhas na tela de 2,8 polegadas
- Controlador de Motores para BBC micro:bit / UNIHIKER K10 — recebe a K10 no encaixe e aciona os motores
- Suporte para 1 Bateria Li-Ion 18650 — segura a bateria e entrega os cabos de ligação
- Bateria Li-Ion 18650 3,7 V 2600 mAh — energia do robô
Dois detalhes que ajudam a entender o projeto. Primeiro: o controlador foi pensado para a micro:bit, mas a K10 se encaixa nele direto — vale conferir as conexões antes de ligar uma placa na outra, já que as duas trabalham com lógica de 3,3 V. Segundo: a bateria carregada fica em 4,2 V, dentro da faixa de 3,5 a 5,5 V do controlador, então uma única célula 18650 alimenta o conjunto.
Montagem e alimentação
A montagem cabe em quatro passos.
- Monte o chassi Falcon V2 com os dois motores e as duas rodas, seguindo o manual de montagem da RoboCore.
- Fixe o controlador de motores no chassi e encaixe a K10 nele, em pé, pelo conector de borda.
- Ligue os dois motores nos bornes verdes do controlador. A biblioteca trata o motor 1 como o esquerdo e o motor 2 como o direito; se um deles girar ao contrário do esperado, inverta os dois fios desse motor.
- Coloque a bateria 18650 no suporte e ligue os dois cabos no borne de alimentação do controlador, que traz a marca de 3,5 a 5,5 V.
Três cuidados antes de ligar:
- O suporte não tem chave liga/desliga nem tampa. O robô liga pela chave que tem na placa controladora.
- Para gravar o programa, ligue a K10 ao computador pelo cabo USB-C que acompanha a placa. Faça o primeiro teste com as rodas no ar: o programa pode mover os motores assim que a bateria estiver ligada.
- Recarregue a bateria em um carregador próprio para 18650. A RoboCore vende um carregador duplo para isso.
Por que foi preciso criar uma biblioteca
A K10 sabe desenhar na tela e ouvir você, mas não sabe girar um motor sozinha: quem faz isso é o controlador. E o controlador não liga os motores por pinos comuns. Ele recebe ordens por I2C e distribui sinais PWM por um chip dedicado, o PCA9685, no endereço 0x40. Cada motor usa dois canais desse chip: um recebe o PWM para um sentido, o outro para o sentido contrário.
O suporte que a RoboCore indica para o controlador é uma extensão do MakeCode para micro:bit. Para programar a K10 na Arduino IDE era preciso escrever essas ordens à mão, canal por canal. Foi aí que nasceu a TR0548_K10: uma biblioteca que esconde o I2C e o PWM atrás de comandos em português, como frente, tras, esquerda e direita, para que qualquer estudante consiga programar o robô sem saber o que é um registrador.
A biblioteca TR0548_K10 por dentro
A biblioteca (versão 1.1.0) depende apenas da Adafruit PWM Servo Driver Library, instalável pelo Gerenciador de Bibliotecas da Arduino IDE. Velocidades vão de 0 a 255, e o sinal indica o sentido quando o comando aceita valores negativos.
begin()— inicia o chip PWM em 1000 Hz e já deixa todos os motores paradosfrente(v)etras(v)— os dois motores girando no mesmo sentido, para frente ou para trásesquerda(v)edireita(v)— os motores em sentidos opostos, o que faz o robô girar no próprio eixotanque(esq, dir)— velocidade independente para cada lado, de -255 a 255; serve para fazer curvasmotor(m, v)— controla um motor (1 a 4), de -255 a 255; motorFrente, motorTras e motorParar são atalhosstopAll()— para os quatro motoresservo(s, angulo)— posiciona um servo (1 a 8) entre 0 e 180 graus
Por dentro, cada motor ocupa dois canais do chip: o motor 1 usa os canais 6 e 7, o motor 2 os canais 4 e 5, o motor 3 os canais 2 e 3 e o motor 4 os canais 0 e 1. Para andar num sentido, o PWM vai para um canal e o outro fica em zero; para o sentido oposto, os papéis se invertem. A velocidade de 0 a 255 é convertida para os 12 bits do chip (0 a 4095). Os servos ocupam os canais de 8 a 15.
O programa mais curto possível, o exemplo TesteBasico da biblioteca, anda três segundos e para:
A TR0548_K10 está publicada no GitHub, em repositório próprio: github.com/Tio-Rafa-SE/TR0548_K10, e futuramente vai para o Gerenciador de Bibliotecas da Arduino IDE.
O código do RoboCarinhas
O programa parte de um exemplo simples, com dois círculos como olhos e uma boca, e acrescenta três coisas: olhos com pupila e brilho, sobrancelhas e bochechas, e uma carinha diferente para cada direção. Ele tem três blocos.
1. Configuração. Os tempos e a velocidade ficam no topo, como constantes, para qualquer estudante mudar sem mexer na lógica:
2. Desenho. Cada peça do rosto é uma função pequena. O olho, por exemplo, é um círculo branco, uma pupila colorida deslocada em dx e dy — é o que faz o robô olhar para cima, para baixo ou para o lado — e um brilhinho:
A boca é uma curva montada com 25 bolinhas ao longo de uma parábola: curva positiva é sorriso, negativa é boca triste. A função desenharExpressao(estado) limpa a tela com um retângulo preto, desenha o rosto do estado pedido e só então chama updateCanvas() uma vez, para a imagem aparecer inteira de uma vez.
- Estado 0, parado: pupilas azuis olhando de frente, boca reta cinza
- Estado 1, frente: pupilas verdes olhando para cima, bochechas rosa e sorrisão verde
- Estado 2, trás: pupilas laranja olhando para baixo, sobrancelhas inclinadas e boca em "o"
- Estado 3, esquerda: pupilas azuis deslocadas para a esquerda, uma sobrancelha levantada e sorriso torto
- Estado 4, direita: pupilas roxas deslocadas para a direita, espelho da esquerda
3. Movimento. O setup() liga a K10, a tela e o controlador. No loop(), cada direção segue o mesmo ritmo: desenha a carinha, anda, para, volta para a carinha neutra e espera um segundo. A biblioteca faz o programa ficar assim de curto:
O código completo está no repositório, na seção do GitHub, ao final desta página.
O que saiu disso
O robô cumpre a sequência frente, trás, esquerda e direita, e a K10 mostra a carinha de cada direção enquanto ele anda. Essa versão, sem voz, foi executada no robô montado com as peças da RoboCore. Três aprendizados ficam:
- Comece pelo que já funciona. Cada novidade — pupilas, sobrancelhas, bochechas — entrou em cima de um exemplo que já rodava, usando só funções de desenho que já tinham aparecido na tela.
- Uma biblioteca muda o jeito de ensinar. robo.frente(255) cabe numa aula; escrever PWM em canais de um chip I2C, não.
- Carinha e movimento andam juntos. Desenhar o rosto antes de mover deixa a relação entre comando e resultado visível para quem está aprendendo.
Próximo passo: comandos de voz
A meta é o robô obedecer a voz, com a carinha acompanhando o movimento. A K10 tem reconhecimento de fala offline, que não precisa de internet. Pela documentação da DFRobot, a biblioteca de voz funciona em três chamadas: asrInit inicia o reconhecimento, addASRCommand cadastra cada comando com um número e um texto, e isDetectCmdID diz se aquele comando foi ouvido. O reconhecimento trabalha em inglês ou chinês, então os comandos previstos são go forward, go back, turn left, turn right e stop.
As primeiras tentativas de juntar voz, tela e motores no mesmo programa fizeram a K10 reiniciar em laço, e por isso o RoboCarinhas desta versão não usa voz. O plano é testar o exemplo oficial de voz sozinho, depois somar a tela e, por fim, os motores, um de cada vez, até descobrir em que ponto a placa reinicia. Quando funcionar, a segunda versão do robô ganha um novo artigo.
O projeto no GitHub
O RoboCarinhas está no GitHub como um repositório pronto para reproduzir. Ele traz o código, as fotos da montagem, a licença MIT e um README com hardware, ligações, software, passo a passo de gravação, resultado esperado e problemas conhecidos.
github.com/Tio-Rafa-SE/Robocainhas
Para reproduzir o robô: monte o chassi e as peças como na seção de montagem, instale o pacote de placas da K10, a biblioteca TR0548_K10 e a Adafruit PWM Servo Driver Library, abra o RoboCarinhas.ino, selecione a K10 e grave.
Quer montar o seu RoboCarinhas?
O código completo e o README com passo a passo estão no repositório do projeto no GitHub, junto com a biblioteca TR0548_K10 criada para programar a UNIHIKER K10.