Tutorial: Braço robótico programável – Projeto Final

Depois de um longo e tenebroso inverno, vamos ao projeto de verdade! Afinal, já era sem tempo! O circuito como comentado na introdução, vai ser baseado no Arduino MEGA, alguns potenciômetros, botões e LEDS para o “painel de controle local”. Um modulo HC-06  conectará o braço, via rede Bluetooth, com um celular Android (controle em modo remoto).

BRAÇOS ROBÓTICOS:

Os braços robóticos podem ser classificados segundo o número de “juntas”, ou “graus de liberdade” (DOF – Degree of Freedom) que possuem. Por exemplo:

  • Base giratória (de 360 ou 180 graus). A base é conhecida como “Waist” ou simplesmente “Base”.
  • O ombro ou “Shoulder” é o responsável por levantar ou abaixar o braço na vertical
  • O cotovelo ou”Elbow”, fará o braço ir para a frente ou para trás.
  • A garra ou “Gripper” (em alguns casos “Claw”), funciona abrindo ou fechando para “agarrar coisas”.

Observe que nesse diagrama só o braço propriamente dito já possui 3 DOF. A garra que no caso do meArm (4DOF) adiciona o quarto elemento. Nesse projeto ficaremos por aqui (até 4 DOF), mas é obvio que poderíamos ter mais “juntas no corpo”  e principalmente a garra poderia ser mais sofisticada com 2 ou 3 DOF (rotação e elevação).

Os Braços que serão testados nesse projeto serão o SanSmart 3 DOF e o meArm 4DOF 

  O braço ao lado por exemplo, possui 5DOF e foi desenvolvido pela EASYDS, que possui uma linha completa de Kits Robóticos Educacionais em MDF. Vale a pena dar uma olhada no site.

O CIRCUITO:

Para o acionamento das juntas serão utilizados servo motores conectados diretamente ao Arduino, mas poderiam também ser utilizados “Stepper Motors” para maior torque e precisão.

A escolha adequada dos servos é muito importante (existem servos baratos chineses que são muito mal construídos como por exemplo o MG995, que infelizmente são os que vieram com meu SanSmart 3DOF aArm) .

A alimentação dos servos deve ser separada do Arduino e demais componentes. Uma fonte externa de 5 a 6V deve funcionar sem problemas (verifique o datasheet de seus servos para verificar a faixa de voltagem apropriada). Uma prática comum também é a utilização de capacitores de 470uF entre VCC e GND para minimizar os ruídos gerados pelos motores internos dos servos.  Não se esqueça de conectar todos os terras (fonte externa com  o Arduino).

Caso os servos tenham problemas e vibrem muito, faça ajustes nos delays de seu codigo. É importante que os servos tenham tempo para chegar a um determinado ponto antes de receber um novo comando. Também vale a pena verificar se os servos são digitais ou analógicos, pois apesar de serem parecidos mecanicamente, os digitais trabalham em uma frequência de 300Hz enquanto que os analógicos com 50Hz. A biblioteca standard do Arduino <Servo.h>  foi desenvolvida para servos analógicos e podem ser modificadas caso necessário, para para um melhor funcionamento com servos digitais.

Abaixo o diagrama completo:

O CÓDIGO:

 

O projeto não é complicado, mas possui muitas variáveis. O mais prudente foi definir-las claramente e deixar suas declarações en um arquivo exclusivo:

ArmDefine.h

No arquivo também foram definidos os valores mínimo, máximo e iniciais para os servos. No codigo incluído nesse tutorial, existem dois conjuntos de parâmetros referentes aos braços robóticos que testei em meu projeto (claro que somente um grupo de constantes deverá ser utilizado):

  1. MeArm 4-DOF
    • #define minGrip 15  
    • #define minBase 0  
    • #define minShou 60  
    • #define minElbw 60
    • #define maxGrip 45  
    • #define maxBase 170 
    • #define maxShou 180  
    • #define maxElbw 150
      #define midGrip 30 
    • #define midBase 87 
    • #define midShou 138 
    • #define midElbw 100
  2. SS 3-DOF
    • #define minGrip 75  
    • #define minBase 5  
    • #define minShou 5  
    • #define minElbw 0
      #define maxGrip 125  
    • #define maxBase 150 
    • #define maxShou 155  
    • #define maxElbw 0
      #define midGrip 100 
    • #define midBase 90 
    • #define midShou 90 
    • #define midElbw 0

Para cada tipo de braço vão existir parâmetros distintos e é importante que você encontre os correctos para o seu. O que sugiro é que inicialmente os potenciômetros fiquem em seu ponto médio e que o Mapping das saídas PWM sejam definidas com os valores standard: Max = 255, Min = 0 e Mid = 126 ("#defines" acima). Ao se ir variando os potenciômetros (um a um), deve-se observar no Monitor Serial (ou LCD) quais deverão ser os valores mínimos e máximos em que o braço trabalhará corretamente. Estes serão os valores finais a serem utilizados para as definições.

Para a "gravação" dos conjuntos de coordenadas (ou steps) que o robot deverá reproduzir, utilizarei arrays de dados:

  int gripPosition[100]; 
int basePosition[100];
int shouPosition[100];
int elbwPosition[100];

  int positionIndex = 0;

Observe que não estou guardando as posições "gravadas" e ao finalizar -se o "programa do robot", o índice voltará a zero e o robot esperará pela gravação de uma nova sequência. Se poderia guardar esses arrays de dados na EEPROM do Arduino, por exemplo. Isso faria com que o programa pudesse ser executado infinitas vezes, ou até mesmo possuir mais de um programa armazenado. Fica aqui a dica para o desenvolvimento de um projeto mais sofisticado.

A lógica do programa:

O bloco principal (“Loop”) é na verdade bem simples:

  1. Verifica se há mensagens no buffer serial, provenientes do Android
  2. Se há mensagens, verifica se o controle deverá ser Local ou Remoto ( o default é Local).
  3. Verifica se existe um comando para executar o “programa” (sequencia de passos). Se existe, o executa. Do contrário, entende que o “programa” não está completo e ainda se devem gravar novos passos.
  4. Se há uma nova posição é definida, adiciona a mesma ao programa
  5. Volta ao início e executa o passo 1 novamente.

void loop()
{
   checkBTcmd();
   defineLocalRemote();

   execTaskCmd = digitalRead (execTaskPin);
   if(execTaskCmd == HIGH || command == "runon")
   {
      runProgram();
   }
   else recArmPosition();
   command = "";
}

A função checkBTcmd() monta uma string a partir dos caracteres que chegam do modulo BT. Essa string é passada a variável “command”.

A função defineLocalRemote() analisará  a variável “command” verificando se um comando para mudar a função de local a remoto ou vice e versa é recebida. O comando de Alarm também é analisado aqui. Pela lógica do programa, se “Alarm” for acionado no no Android, significará que o braço deverá  passar obrigatoriamente ao modo Remoto.

A função runProgram () executará as preparações, como acender/apagar os LEDS correspondentes, etc. e principalmente invocará a função: executeTask(). Essa última, é a função que contem a lógica de execução da sequencia de steps. A função incrementa o “positionIndex” enviando ao braço uma a uma, as coordenadas para seu posicionamento usando a função: armPosition(grip, base, shoulder, elbow).

Por último, a função que realmente comandará os servos e gravará os “steps” é a recArmPosition(). Dependendo do comando recebido do Android, esta função deverá definir se o posicionamento dos servos será comandado através dos potenciômetros, ou através dos “sliders” do Android. A cada mudança de posição, esta função enviará as coordenadas aos servos via a função armPosition(grip, base, shoulder, elbow). A leitura da posição dos potenciômetros ou dos sliders e o correspondente acionamento dos servos ocorrerá até o momento em que o comando de “Gravar” ou “PROGRAM” seja acionado. Nesse momento o índice de posição dos Arrays será incrementado e as coordenadas guardadas.

Para simplificação de entendimento, todo o codigo foi baseado em funções específicas. O bloco de Setup, Loop e as funções descritas anteriormente estão praticamente todas no file:

MJRoBot_Arm_Robot_Task_Prgm.ino

As funções mais gerais como leituras de comandos BT: void checkBTcmd(); gerador de som: void beep(int pin, int freq, long ms)  e debouncing : boolean debounce(int pin); estão no file:

General_Functions.ino

Um dado importante. Como o Arduino executará instruções baseadas em um clock de 16Mhz,  é de se esperar que os botões de comando sejam lidos centenas ou até milhares de vezes por segundo, daí ser importantíssimo fazer um “debouncing” do botão que define a gravação do step.

O quarto e último file que compõe o código é:

Arm_Ctrl_and_Display.ino

Nesse file estão principalmente as funções de leitura de potenciômetros: bool readPotenciometers(); leitura dos sliders do Android: bool readSliders(); posicionamento dos servos: void armPosition(int gripp, int basee, int shoulder, int elbow). As demais funções do file são auxiliares para display de dados no LCD, Serial Monitor, alarmes, etc.

O código completo para o projeto pode ser baixado aqui:

Link para o código do Arduino

Abaixo um vídeo do braço robótico 4DOF “meArm”:

Video: MeArm controlled by Android

No vídeo o braço está sendo programado remotamente através da nova versão da app Android

A app pode ser baixada gratuitamente aqui:

MJRoBot Arduino Arm Robot Ctrl.

Agora é só colocar a mão na massa, quer dizer no Arduino e mandar bala! Até a próxima!

Para mais exemplos, códigos, etc. Por favor, visite meu blog:

MJRoBot.org




Exibições: 27344

Comentar

Você precisa ser um membro de Laboratorio de Garagem (arduino, eletrônica, robotica, hacking) para adicionar comentários!

Entrar em Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço