POR NÍCOLAS AMARAL VIEIRA SILVA
Aprendendo robótica da melhor maneira!
📄 Prefere ler no formato original em PDF?
Você também pode visualizar ou baixar o arquivo manualGearsbot.pdf diretamente no repositório.
O Gearsbot é uma plataforma de código aberto (ou seja, pessoas podem contribuir com o desenvolvimento de novas ferramentas para a plataforma) voltada para a simulação de robótica educacional diretamente no navegador, muito utilizada por escolas e equipes de competições como a OBR (Olimpíada Brasileira de Robótica).
Para compreender a plataforma Gearsbot como um todo, o mais fácil é imaginá-la como um laboratório virtual de robótica completo e gratuito. Com ela, você não precisa comprar kits físicos caros para aprender a programar robôs. Você consegue aprender tudo pelo próprio navegador do seu computador, sem precisar instalar nada!
Apenas ao acessar o site, você já possui acesso ao ambiente onde você cria a lógica usando blocos visuais ou Python para ler sensores e mandar comandos para os motores e logo ao lado o simulador 3D. Ao dar "Play", a física do mundo real é simulada, tornando possível testar o comportamento do robô baseado no seu programa.
Na tela de código, você cria a lógica usando blocos visuais ou Python para ler sensores e mandar comandos para os motores. Ao dar "Play", a física do mundo real é simulada (atrito das rodas com o chão, gravidade, peso do robô ao subir rampas, colisões com paredes).
Vamos desvendar primeiro a aba de código do Gearsbot, como indicado pelo círculo vermelho próximo ao canto superior esquerdo do navegador.
Observe que há dois ambientes, a aba "Blocks" e a aba "Python" onde poderemos modelar com a lógica de programação, o comportamento de nosso robô.
Na aba "Blocks", localizada no canto da página do lado esquerdo (como indicado na imagem acima), é utilizada a programação em blocos, que utiliza a tecnologia Blockly. É como um jogo de quebra-cabeças inteligente: Cada bloco representa uma instrução ou um comando para o robô. Se as peças não se encaixarem fisicamente na tela, significa que a lógica do seu código tem um erro de sintaxe. Isso impede que você cometa erros de digitação (como esquecer um parêntese ou ponto e vírgula), permitindo que se foque puramente na lógica de resolução do problema.
Porém, não utilizaremos essa tecnologia no nosso manual. Aqui utilizaremos a aba "Python" para aprender os comandos básicos para que possamos dar início à "vida" do nosso robô. A aba está localizada entre a aba "Blocks" e "Simulator", como indicado na imagem abaixo.
Essa é o ambiente onde a mágica acontece. Em "Python", você transforma o seu texto em linguagem de programação, utilizando comandos e estruturas que vão ditar a lógica por trás do comportamento do seu robô. Aqui é você quem dá as ordens! O que o robô irá fazer e como ele irá realizar essa tarefa.
Aqui é o lugar onde você aprende até mesmo errando. Quando identifica algum comando digitado incorretamente ou algum erro lógico, o editor avisa apontando a linha exata onde o erro aconteceu, ensinando você a ler mensagens de erro e a "caçar" problemas no código.
Assim que termina de digitar algum comando, já conseguimos testar na aba do simulador o comportamento do nosso robô! Só clica no botão "Play" no topo da tela e assiste ao robô se mover na mini-janela 3D logo ao lado, vendo o resultado do seu código de texto em tempo real.
O Python é como um tradutor universal muito inteligente. Os computadores e robôs não entendem a nossa língua (como o português). Eles só entendem impulsos elétricos, que nós representamos como código binário, aqueles montes de zeros e uns: 01101001. E escrever em zeros e uns seria impossível para nós, não concorda? É aí que entra o Python como uma ponte que soluciona esse problema.
Você digita comandos em Python usando palavras simples em inglês, como um print para mostrar algo na tela, por exemplo. Por trás dos panos, o Python pega essas palavras fáceis que você escreveu e as traduz rapidamente para a "linguagem de máquina" que o processador do robô ou do computador consegue entender.
Concordamos que a parte mais interessante é ver o resultado acontecer, não é mesmo? Na aba "Simulator", você testa se o robô realiza o comportamento esperado após digitar as linhas de código na aba "Python". Esta é a área onde você coloca o seu robô à prova no mundo físico virtual. É a área de execução e experimentação.
Agora que conhece um pouco da plataforma e o que podemos fazer com ela, começaremos a colocar a mão na massa e aprender a como dar os primeiros passos com o nosso robô.
Para isso, como mencionei ao apresentar a plataforma, iremos utilizar primordialmente a linguagem de programação Python para darmos as instruções ao nosso robô. Tudo o que quisermos que ele faça (ou não), digitaremos na área de programação "Python".
Mas não pense que é só digitar o que queremos que aconteça de qualquer maneira. O computador não entende a nossa língua e para isso, precisamos aprender a dar as instruções de maneira correta para que ele possa de fato realizá-las.
Para darmos nossos primeiros passos, primeiro acessaremos a plataforma Gearsbot no nosso navegador de preferência pelo endereço: https://gears.aposteriori.com.sg/
Após carregar a página, acesse o ambiente de programação na aba "Python". De cara você irá encontrar linhas de código com instruções já pré-definidas que movimentam o seu robô. Como aprenderemos as instruções básicas, limpe todo o documento, deixando-o sem nenhuma instrução.
Nosso primeiro passo será fazer com que nosso robô se movimente para frente por dois segundos. Para isso, adicionaremos algumas importações de bibliotecas (agrupamento de instruções pré-definidas das quais podemos reutilizar) no nosso documento. Essas linhas de importação servem como um "manual de instruções" e ferramentas de robótica que serão trazidas para dentro do nosso código. Nós importaremos partes de uma biblioteca chamada Pybricks, que é o sistema padrão usado para controlar robôs LEGO e simuladores semelhantes.
Adicionemos então na primeira linha do nosso código a instrução from pybricks.ev3devices import Motor, que ensina o Python a entender o que é um motor físico. Sem essa importação, o programa não saberia o que fazer quando você digitasse uma instrução que faria o motor se movimentar. É essa ferramenta que nos dá o poder de usar comandos para fazer a roda girar e parar.
Em seguida adicionamos mais uma linha de código, sendo também mais uma importação: from pybricks.parameters import Port. Os robôs têm entradas físicas onde conectamos os cabos dos motores e sensores, identificadas por letras (A, B, C, D) e números (1, 2, 3, 4). Esta linha importa o "mapa" dessas portas para o código. Ela permite que você escreva Port.A ou Port.B para indicar exatamente em qual tomada virtual do robô cada motor está plugado.
Logo após, adicionemos nossa última importação: from pybricks.tools import wait. Ela ensina o robô a pausar a execução do código por um período exato, medido em milissegundos (onde mil milissegundos equivalem a um segundo). Assim teremos nossas importações no nosso código:
from pybricks.ev3devices import Motor
from pybricks.parameters import Port
from pybricks.tools import waitA seguir, configuraremos os motores nas portas padrão do simulador. Como nosso robô padrão tem duas rodas, utilizaremos dois motores: um para a roda esquerda que será na porta A e um para a roda direita, que será na porta B.
Traduzindo para nosso código, adicionaremos duas linhas de código. A primeira instrução será motor_esquerdo = Motor(Port.A) e na linha seguinte a instrução motor_direito = Motor(Port.B).
motor_esquerdo e motor_direito são os nomes que nós inventamos para as rodas do robô. A partir de agora, toda vez que quisermos mover a roda da esquerda ou direita, basta chamarmos elas por esse nome. Na programação, o = significa guardar. Então, estamos guardando a configuração da roda dentro do nome que criamos. A palavra Motor() é a ferramenta física que importamos. Ela serve para avisar o Python: "Olha, a peça que está conectada aqui é um motor elétrico!". E por fim, Port.A e Port.B são as tomadas (portas) do robô onde os cabos estão plugados na vida real. No Gearsbot, por padrão, o motor esquerdo fica na porta A e o direito na porta B.
from pybricks.ev3devices import Motor
from pybricks.parameters import Port
from pybricks.tools import wait
motor_esquerdo = Motor(Port.A)
motor_direito = Motor(Port.B)Essas instruções foram para importar as ferramentas que nos permitirão que nosso código funcionasse e associamos os motores às suas respectivas portas. Agora diremos para o nosso robô se movimentar de fato. Para isso utilizaremos o comando motor_esquerdo.run(400) e na linha seguinte o comando motor_direito.run(400).
Lembrando que nomeamos os nossos motores de motor_esquerdo e motor_direito. Com isso, utilizamos o ponto, que funciona como uma conexão. No Python, ele serve para dizer que você vai dar uma ordem ou usar uma função que pertence àquele motor. O comando run() é a função física que faz o motor ligar e continuar girando até que venha outro comando mandando ele parar. E o número (400), que fica dentro dessa função, é a velocidade com que as rodas vão girar.
from pybricks.ev3devices import Motor
from pybricks.parameters import Port
from pybricks.tools import wait
# 1. Configura os motores nas portas padrão do simulador (A e B)
motor_esquerdo = Motor(Port.A)
motor_direito = Motor(Port.B)
# 2. Liga os motores (eles começam a girar juntos imediatamente)
motor_esquerdo.run(400)
motor_direito.run(400)Com essas instruções, o nosso robô já consegue se movimentar!
Realize a simulação com esses comandos e veja o robô andar para frente sem parar. Como nós queremos que ele se movimente para frente por apenas dois segundos, adicionaremos mais três linhas de código: a instrução wait(2000) e em seguida as instruções motor_esquerdo.stop() e motor_direito.stop().
wait() é a instrução que manda o processador do robô "esperar" ou "pausar" antes de ler a próxima linha do código. É ela que vai fazer com que o nosso robô continue andando até o momento em que nós desejarmos que ele pare, ou seja, em 2000 milissegundos. Após esse tempo na pausa da execução do programa, o Python lê as próximas linhas, que são as instruções: motor_esquerdo.stop() e motor_direito.stop(), que é o comando de ação para parar. Ele desliga imediatamente a corrente elétrica enviada para os motores. Se você não colocasse essas duas linhas, após os 2 segundos de espera do wait(2000), o programa chegaria ao fim, mas os motores continuariam ligados com a última instrução recebida, como aconteceu no teste que realizamos anteriormente. O robô continuaria andando sem parar e bateria na primeira parede que encontrasse! O stop() garante que o robô termine a sua tarefa exatamente onde você planejou.
from pybricks.ev3devices import Motor
from pybricks.parameters import Port
from pybricks.tools import wait
# 1. Configura os motores nas portas padrão do simulador (A e B)
motor_esquerdo = Motor(Port.A)
motor_direito = Motor(Port.B)
# 2. Liga os motores (eles começam a girar juntos imediatamente)
motor_esquerdo.run(400)
motor_direito.run(400)
# 3. Espera 2000 milissegundos (2 segundos) enquanto o robô anda
wait(2000)
# 4. Desliga os motores
motor_esquerdo.stop()
motor_direito.stop()Esse é o nosso primeiro código finalizado!
Com ele aprendemos a movimentar nosso robô para frente em um período determinado de tempo. Incrível, não?!
Você deve estar se perguntando como fazemos para movimentar ele para outras direções, não é mesmo? Calma que é exatamente isso que veremos agora.
Que tal movimentarmos nosso robô para trás após movimentarmos ele para frente?
Para isso, ao invés de pararmos nosso robô após os dois segundos, movimentaremos ele para trás com as instruções motor_esquerdo.run(-400) e motor_direito.run(-400).
Perceba que utilizaremos o mesmo comando que utilizamos para movimentar as rodas para frente. Mas ao utilizarmos o valor negativo, as rodas girarão no sentido contrário, fazendo o nosso robô se movimentar para trás. Colocaremos também uma pausa na execução do programa de dois segundos e em seguida, finalizamos o código parando o movimento dos motores.
from pybricks.ev3devices import Motor
from pybricks.parameters import Port
from pybricks.tools import wait
motor_esquerdo = Motor(Port.A)
motor_direito = Motor(Port.B)
# 1. Liga os motores para ir para frente (velocidade positiva)
motor_esquerdo.run(400)
motor_direito.run(400)
# 2. Espera 2000 milissegundos (2 segundos) enquanto o robô vai para frente
wait(2000)
# 3. Liga os motores para trás (velocidade negativa: -400)
motor_esquerdo.run(-400)
motor_direito.run(-400)
# 4. Espera mais 2000 milissegundos (2 segundos) enquanto o robô recua
wait(2000)
# 5. Agora sim, desliga os motores para parar a roda de forma segura
motor_esquerdo.stop()
motor_direito.stop()Após realizarmos as modificações como mostrado acima, podemos realizar o teste e ver que o robô se movimenta para frente por dois segundos e depois se movimenta para trás por dois segundos.
Mas isso não é o suficiente, não é mesmo?
Queremos que o nosso robô se movimente para a esquerda e também para a direita.
Você irá ver que fazer isso não é tão difícil quanto parece. Na verdade, você até já sabe fazer isso, só não deve ter percebido ainda.
Perceba que adicionamos a instrução motor_esquerdo.run() e motor_direito.run(), com valores diferentes em seus parâmetros (dentro de seus parênteses). Ao zerarmos o movimento de um dos motores e acelerarmos o outro, conseguimos fazer com que o robô gire para a direção da qual queremos. Por exemplo: Se desejamos girar o robô para o lado esquerdo em 90°, basta mantermos o motor esquerdo desligado e acelerarmos o botão direito por um tempo determinado, fazendo-o girar para a direção desejada.
Porém, se quisermos mudar a direção do robô para a direção oposta ao seu sentido atual (ou seja, o robô em sentido à esquerda, girar para sentido até ficar para à direita), é preciso pausar a execução do programa por um pouco mais de tempo para que ele possa ficar no sentido que desejamos. Por isso utilizamos dessa lógica de acelerar um único motor. O tempo que esse único motor permanece girando, é o que vai determinar em que sentido o robô vai parar.
from pybricks.ev3devices import Motor
from pybricks.parameters import Port
from pybricks.tools import wait
motor_esquerdo = Motor(Port.A)
motor_direito = Motor(Port.B)
# --- CURVA À DIREITA ---
motor_esquerdo.run(400)
motor_direito.run(0)
wait(1000) # Tempo suficiente para ele completar a curva para a direita
# --- AVANÇA EM LINHA RETA ---
motor_esquerdo.run(400)
motor_direito.run(400)
wait(2000) # Anda em linha reta por 2 segundos
# --- CURVA ACENTUADA À ESQUERDA (180°) ---
motor_esquerdo.run(0)
motor_direito.run(400)
wait(2000) # Tempo suficiente para ele completar a curva até ficar totalmente para a esquerda
# --- RETORNA EM LINHA RETA ---
motor_esquerdo.run(400)
motor_direito.run(400)
wait(2000) # Anda em linha reta por mais 2 segundos
# --- PARADA SEGURA ---
motor_esquerdo.stop()
motor_direito.stop()No caso do nosso código, primeiro, o robô liga apenas a roda esquerda por 1 segundo, o que faz o seu corpo girar no próprio eixo 90 graus para a direita. Assim que termina de virar, ele liga as duas rodas na mesma velocidade por 2 segundos, fazendo o robô avançar em linha reta na nova direção. Em seguida, ele muda a estratégia: desliga a roda esquerda e liga apenas a direita por 2 segundos. Como esse tempo de curva é o dobro do primeiro, o robô faz uma curva acentuada de 180 graus para a esquerda, apontando agora para o sentido oposto de onde veio. Com a nova direção definida, ele ativa novamente as duas rodas para andar para frente em linha reta por mais 2 segundos. Por fim, o programa desliga a energia de ambos os motores, fazendo o robô parar completamente e de forma segura na pista.
Viu como não é difícil aprender sobre robótica?! Terminamos com um programa robusto de "desvio e retorno", onde o robô faz uma curva à direita, anda para frente, faz uma meia-volta para a esquerda, avança novamente e realiza uma parada totalmente segura usando o comando .stop().
Com esse manual, você conheceu a Gearsbot: uma plataforma incrível que vai te ajudar no seu aprendizado em robótica.
Aqui você aprendeu sobre a plataforma e suas principais funcionalidades. Conheceu o Python, uma linguagem de programação famosa e muito utilizada no mundo todo, e ainda por cima aprendeu a movimentar o seu robô utilizando pouquíssimos comandos.
Aprendemos bastante até aqui! Espero que esse manual tenha te ajudado no seu pontapé inicial com nossos amigos robôs! Agora é só treinar um pouco mais, conhecer novos comandos e partir para a prática no mundo real!
- GEARSBOT. GearsBot Robotics Simulator. Versão Open-Source. Singapura: A Posteriori LLP, 2026. Disponível em: https://gears.aposteriori.com.sg/. Acesso em: 17 jul. 2026.
- PYBRICKS. Pybricks: Python coding for LEGO® robots. Documentation release 3.x. [S. l.]: Pybricks Team, 2026. Disponível em: https://pybricks.com/. Acesso em: 17 jul. 2026.
- PYTHON SOFTWARE FOUNDATION. Python Language Reference. Versão 3.x. Delaware: PSF, 2026. Disponível em: https://www.python.org/. Acesso em: 17 jul. 2026.
Copyright © 2026 Nícolas Amaral Vieira Silva. Todos os direitos reservados.