Rover controlado pela web: 14 etapas (com imagens)

2025 Autor: John Day | [email protected]. Última modificação: 2025-01-13 06:58

Construir e brincar com robôs é meu principal prazer culpado na vida. Outros jogam golfe ou esqui, mas eu construo robôs (já que não posso jogar golfe ou esquiar:-). Acho relaxante e divertido! Para fazer a maioria dos meus bots, eu uso kits de chassis. Usar kits me ajuda a fazer o que eu gosto mais, o software e a eletrônica, e também contribui para um chassi melhor para mim.

Neste Instructable, veremos o que é necessário para fazer um rover controlado por Wifi / web simples, mas robusto. O chassi utilizado é o pescoço de ganso Actobotics. Eu o escolhi pelo seu tamanho, capacidade de expansão e custo, mas você pode usar qualquer outro chassi de sua escolha.

Para um projeto como este, precisaremos de um bom computador de placa única sólida e para este bot eu escolhi usar o Raspberry Pi (RPI) um computador baseado em Linux. O RPI (e o Linux) nos dá muitas opções de codificação e o Python será usado para o lado da codificação. Para a interface da web, uso o Flask, uma estrutura web leve para Python.

Para acionar os motores, escolhi um RoboClaw 2x5a. Permite uma comunicação serial simples para comandá-lo e funciona bem com o RPI e os motores do pescoço de ganso.

Finalmente, ele tem uma webcam para feedback de vídeo do tipo POV para dirigi-lo remotamente. Vou cobrir cada tópico com mais detalhes posteriormente.

Etapa 1: Hardware necessário

• Chassi Actobotics Gooesneck ou um substituto adequado de sua escolha
• Raspberry Pi de sua escolha (ou clone) - Um RPI modelo B é usado neste bot, mas qualquer um com pelo menos duas portas USB funcionará
• Placa Servo Padrão B x1
• Suporte de canal de ângulo único de 90 ° x1
• Motorista RoboClaw 2x5a
• S3003 ou servo de tamanho padrão semelhante
• Breadboard pequeno ou mini breadboard
• Fios de ligação fêmea para fêmea
• Fios de jumper macho para fêmea
• Web cam (opcional) - Eu uso um Logitech C110, e aqui está uma lista de câmeras compatíveis para RPI
• Fonte de alimentação 5v-6v para energia servo
• Bateria 7,2v-11,1v para alimentação do motor de acionamento
• 5v 2600mah (ou superior) banco de energia USB para RPI
• Adaptador wi-fi USB

No meu bot, eu uso rodas de 4 para torná-lo um pouco mais All-Terrain-Indoor. Para esta opção, você precisará de:

• 4 "Roda para serviço pesado x2
• Cubo de parafuso de fixação com furo de 4 mm (0,770 polegada) x2

Etapa 2: montagem do chassi

Primeiro monte o chassi seguindo as instruções incluídas com o chassi ou vídeo. Depois de terminar, você deve ter algo parecido com a imagem. NOTA: Ao montar a parte do pescoço, apenas deixe o suporte de montagem desligado.

No meu bot, optei por substituir as rodas com o chassi por rodas resistentes de 4 . Isso é opcional e não é necessário, a menos que você queira fazer o mesmo.

Etapa 3: Montagem dos eletrônicos

O pescoço de ganso tem muito espaço e opções para montar seus eletrônicos. Apresento essas fotos como uma linha de orientação, mas você pode escolher como gostaria de colocar tudo para fora. Você pode usar isoladores, fita dupla-face, Velcro ou fita servo para montar a placa e as baterias.

Etapa 4: Adicionar a webcam

Pegue o suporte de 90 graus, o servo hub leve e quatro (4) dos parafusos de 0,3125 para esta etapa:

• Pegue o hub do servo e coloque-o em um lado do suporte e prenda-os juntos com os parafusos de 0,2125 "como na ilustração
• Em seguida, monte o servo no suporte do servo
• Fixe o suporte de 90 graus com a buzina do servo à coluna do servo e use o parafuso da buzina que veio com o servo para conectá-los juntos
• Agora monte o Servo no suporte na parte superior do pescoço de ganso com os parafusos restantes
• Monte a câmera com zíperes ou fita dupla-face no suporte de 90 graus

Use as fotos como guias, se necessário.

Etapa 5: conectando tudo

A fiação é bastante simples para este robô.

Os motores:

Solda leva em ambos os motores, se você ainda não tiver feito isso

Com a frente dos robôs (a extremidade com o pescoço de ganso) voltada para longe de você:

• Conecte os fios do motor no motor esquerdo ao canal M1A e M1B
• Conecte os fios do motor no motor direito ao canal M2A e M2B

Conexões de aterramento (GND):

• Conecte um pino de aterramento no RoboClaw à placa de aterramento. A linha do pino de aterramento no RoboClaw está mais próxima do centro (veja a foto)
• Conecte o PIN 6 no RPI à placa de jumper. Veja a imagem do cabeçalho RPI para as atribuições dos pinos.
• Conecte o GND do pacote de bateria do servo a um dos pinos na placa de jumper.
• Execute um fio de jumper da placa de jumper para o fio GND do servo.

RPI para RoboClaw:

Conecte o pino RPI GPIO14 TXD ao pino RoboClaw S1

Poder:

• Conecte o fio POS da bateria do servo ao cabo POS do servo
• Conecte o fio POS da bateria do motor ao POS (+) do terminal de entrada de energia do motor RoboClaw. Vamos deixar o terminal GND desconectado por enquanto.

Etapa 6: Configurando o RPI

Presumo que o usuário aqui saiba algo sobre Linux e RPI. Não abordo como configurar ou conectar a um. Se precisar de ajuda com isso, use as páginas abaixo.

Para obter a configuração do RPI, dê uma olhada nas seguintes páginas:

• Configuração Básica RPI
• RPI Guia de início rápido
• NOOBS setup guilde

Para páginas iniciais gerais, a página principal do RPI e as páginas do eLinux são ótimos lugares para começar.

Veja este link para configuração geral de RPI Wifi.

Se você planeja usar algum tipo de câmera ou webcam no bot, dê uma olhada nessas páginas para obter os arquivos básicos necessários.

• Configuração da câmera RPI
• Configuração da câmera eLinix RPI

Transmissão de vídeo:

Existem algumas maneiras de fazer o streaming de vídeo funcionar em um RPI, mas o método que prefiro é usar o Motion.

Para instalá-lo em seu RPI, execute: sudo apt-get install motion

Este instrutível vai além da configuração para streaming também.

Etapa 7: Configurando a Porta Serial RPI

Precisaremos desabilitar o modo do console do Linux para usar o RX e TX, pois queremos falar com o controlador de motor RoboClaw a partir desta porta. Para fazer isso, você pode usar este método ou esta ferramenta. A escolha é sua no método, já que ambos fazem a mesma coisa no final.

Etapa 8: Instalando os módulos Python

Você precisará do python instalado no RPI, bem como no pip do instalador do pacote python.

Para instalar o pip faça:

1. sudo apt-get install python-setuptools
2. sudo easy_install pip

Então:

1. frasco de instalação do sudo pip
2. sudo pip install pyserial
3. sudo pip instalar RPIO

Esses serão todos os módulos necessários para a execução do código.

Etapa 9: Configurando o RoboClaw

Eu tenho o código do robô falando com o RoboClaw no modo serial padrão em 19200 baud.

Para configurar o RoboClaw para isso, faça:

1. Clique no botão "MODE" no RoboClaw
2. Aperte o botão set até que o LED pisque 5 (cinco) vezes entre os atrasos
3. Clique no botão "LIPO" para armazenar
4. Em seguida, aperte o botão "SET" até que o LED pisque 3 (três) vezes entre os atrasos
5. Aperte o botão LIPO para armazenar

Isso é tudo para configurar o controlador do motor. Veja o pdf no link acima para mais informações, se necessário.

Etapa 10: Instalando o programa / arquivos Rover

Baixe e copie o arquivo rover.zip para o seu RPI no diretório do usuário pi.

Se você estiver executando o Linux ou um Mac, você pode usar 'scp' para fazer isso:

scp ~ / localização / do / arquivo / rover.zip pi @ your_rpi_ip: / ~

Para Windows, você pode baixar e usar o pscp e, em seguida, fazer:

pscp /location/of/the/file/rover.zip pi @ your_rpi_ip: / ~

Depois que o arquivo zip for copiado para o RPI, faça login como o usuário pi.

Agora execute:

descompacte rover.zip

Isso descompactará os arquivos para uma pasta chamada 'rover' e terá o seguinte nessa pasta:

• restrover.py (O código Python para o robô)
• estático (contém os arquivos de imagem para os botões na página de controle)
• templates (contém o arquivo index.htlm, a página da web de controle)

Se você estiver usando uma webcam, modifique a linha próxima à parte inferior do arquivo index.html na pasta de modelos. Altere o URL na linha IFRAME para corresponder ao URL src de seu stream de vídeo.

Etapa 11: Iniciando o Bot Up

Conecte a alimentação USB ao RPI.

Para iniciar o código do bot, faça login como o usuário pi e execute:

• rover cd
• sudo python restrover.py

Se tudo estiver OK, você deve ver uma tela semelhante à imagem nesta etapa

Se você encontrar algum erro ou problema, terá que corrigi-lo antes de prosseguir.

Agora, conecte o fio GND (-) ao terminal NEG (-) na entrada de alimentação do motor RoboClaw.

Etapa 12: Acessando a página de controle do bot

Depois que o script python do robô estiver em execução, ligue o RoboClaw e navegue até o ip do RPI como:

your_rpi_ip

Você deverá ver a página de controle da Web aparecer como nas imagens. Caso contrário, verifique seu terminal de saída RPI, procure quaisquer erros e corrija-os.

Uma vez na página, você está pronto para controlar o bot.

O robô irá iniciar na configuração "Med run" e na velocidade Média.

O bot pode ser controlado pelos botões da página ou pelas teclas do teclado.

As chaves são:

• w - para a frente
• z - reverso / para trás
• a - curva longa à esquerda
• s - curva longa à direita
• q - curva curta à esquerda
• e - curva curta à direita
• 1 - panorâmica da câmera para a esquerda
• 2 - panorâmica da câmera para a direita
• 3 - pan totalmente para a esquerda
• 4 - pan totalmente à direita
• / - câmera inicial / central
• h - parar / parar robô

Há um buffer de retardo de meio segundo entre os comandos enviados. Fiz isso para eliminar comandos repetidos indesejados. Você pode, é claro, remover isso do código, se desejar (em index.html)

O resto dos controles e controles devem ser autoexplicativos.

Etapa 13: o código Python / Flask

Este bot usa Python e a estrutura da web Flask. Você pode aprender mais sobre o Flask aqui se estiver interessado.

A grande diferença de um aplicativo Flask e um script Python normal é a classe / método @ app.route usado para fazer o tratamento de URI. Fora isso, é praticamente Python normal em sua maior parte.

#! / usr / bin / env python

# # Wifi / Web rover orientado # # Escrito por Scott Beasley - 2015 # # Usa RPIO, pyserial e Flask # import time importar serial de RPIO importar PWM de flask importar Flask, render_template, request app = Flask (_name_, static_url_path = '') # Conecte-se à porta de comunicação para falar com o controlador do motor Roboclaw, tente: # Altere a taxa de transmissão aqui se for diferente de 19200 roboclaw = serial. Serial ('/ dev / ttyAMA0', 19200) exceto IOError: print ("Porta de comunicação não found ") sys.exit (0) # Variáveis de controle de velocidade e drive last_direction = -1 speed_offset = 84 turn_tm_offset = 0.166 run_time = 0.750 # Posição neutra do servo (home) servo_pos = 1250 servo = PWM. Servo () servo.set_servo (18, servo_pos) # Uma pequena pausa para acalmar o tempo time.sleep (3) # # Manipuladores de URI - todas as ações da página do bot são feitas aqui # # Envie a página de controle dos bots (página inicial) @ app.route ("/") def index (): return render_template ('index.html', name = None) @ app.route ("/ forward") def forward (): last_direction global, run_ti me print "Forward" go_forward () last_direction = 0 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Se não for contínuo, então pare após o atraso se run_time> 0: last_direction = -1 halt () return "ok" @ app.route ("/ backward") def backward (): global last_direction, run_time print "Backward" go_backward () last_direction = 1 # sleep 100ms + run_time time.sleep (0,100 + run_time) # Se não for contínuo, pare após o atraso if run_time> 0: last_direction = -1 halt () return "ok" @ app.route ("/ left") def left (): last_direction global, turn_tm_offset print "Left" go_left () last_direction = -1 # sleep @ 1 / 2 segundos time.sleep (0,500 - turn_tm_offset) # stop halt () time.sleep (0,100) return "ok" @ app.route ("/ right") def right (): global last_direction, turn_tm_offset print "Right" go_right () # sleep @ 1/2 segundo time.sleep (0,500 - turn_tm_offset) last_direction = -1 # stop halt () time.sleep (0,100) return "ok" @ app.route ("/ ltforward") def ltforward (): last_direction global, turn_t m_offset print "Virar para a esquerda" go_left () # sleep @ 1/8 segundo time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @app.route ("/ rtforward") def rtforward (): global last_direction, turn_tm_offset print "Curva para a direita" go_right () # sleep @ 1/8 segundo time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @ app.route ("/ stop") def stop (): global last_direction print "Stop" halt () last_direction = -1 # sleep 100ms time.sleep (0.100) return "ok" @ app.route ("/ panlt") def panlf (): servo_pos global imprimir "Panlt" servo_pos - = 100 se servo_pos 2500: servo_pos = 2500 servo.set_servo (18, servo_pos) # sleep 150ms tempo. sleep (0.150) return "ok" @ app.route ("/ home") def home (): global servo_pos print "Home" servo_pos = 1250 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) return "ok" @ app.route ("/ panfull_lt") def panfull_lt (): servo_pos global print "Pan full l eft "servo_pos = 500 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) return" ok "@ app.route (" / panfull_rt ") def panfull_rt (): servo_pos global print" Pan full right "servo_pos = 2500 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0,150) return "ok" @ app.route ("/ speed_low") def speed_low (): global speed_offset, last_direction, turn_tm_offset speed_offset = 42 turn_tm_offset = 0,001 # Atualize a direção atual para obter uma nova velocidade se last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @ app.route ("/ speed_mid") def speed_mid (): global speed_offset, last_direction, turn_tm_offset speed_offset = 84 turn_tm_offset = 0.166 # Atualizar direção atual para obter nova velocidade se last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @ app.route ("/ speed_hi") def speed_hi (): global speed_offset, last_direction, turn_tm_offset speed_offset = 126 tur n_tm_offset = 0.332 # Atualizar direção atual para obter nova velocidade se last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @ app.route ("/ contínuo ") def continuous (): global run_time print" Continuous run "run_time = 0 # sleep 100ms time.sleep (0.100) return" ok "@ app.route (" / mid_run ") def mid_run (): global run_time print" Mid run "run_time = 0.750 halt () # sleep 100ms time.sleep (0.100) return" ok "@ app.route (" / short_time ") def short_time (): global run_time print" Short run "run_time = 0.300 halt () # sleep 100ms time.sleep (0.100) return "ok" # # Funções do motor # def go_forward (): global speed_offset if speed_offset! = 42: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (128 + speed_offset)) else: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (255 - speed_offset)) def go_backward (): global speed_offset if speed_offset! = 42: roboclaw.write (chr (127 - speed_offset)) roboclaw.wri te (chr (255 - speed_offset)) else: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (128 + speed_offset)) def go_left (): global speed_offset if speed_offset! = 42: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (128 + speed_offset)) else: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (255 - speed_offset)) def go_right (): global speed_offset se speed_offset! = 42: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (255 - speed_offset)) else: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (128 + speed_offset)) def halt (): roboclaw.write (chr (0)) if _name_ == "_main_": app.run (host = '0.0.0.0', port = 80, debug = True)

Se você não quiser ou precisar de informações de depuração do Flask, defina debug como 'false' na linha app.run.

if _name_ == "_main_":

app.run (host = '0.0.0.0', porta = 80, debug = False)

Você também pode alterar a porta que o servidor HTTP do Flask escuta aqui também.

Etapa 14: Usar outro hardware

Se você quiser usar outro hardware, como outro tipo de SBC (Single Board Computer) você deve ter poucos problemas para fazer Python e Flask rodando em outras placas como Beagle Bone, PCDuino etc … Você terá que alterar o código para corresponder ao GPIO layout e usar os recursos de acionamento do servo da nova placa.

Para usar outro tipo de driver de motor, você só precisa modificar as funções go_forward, go_backward, go_left, go_right e halt para fazer o que quer que o driver de motor substituto precise para fazer com que o motor execute essa função específica.