Braço robótico simples e inteligente usando Arduino

Componentes e suprimentos

Arduino UNO

Micro Servos

Potenciômetros

Breadboard (genérico)

Sobre este projeto

Neste tutorial, estarei fazendo um braço robótico simples que será controlado por um braço mestre. O braço se lembrará dos movimentos e jogará em sequência. O conceito não é novo. Tive a ideia de "mini braço robótico -by Stoerpeak". Eu queria fazer isso há muito tempo, mas naquela época eu era totalmente novato e não tinha conhecimento de programação. Agora, finalmente, estou construindo um, mantendo-o simples, barato e compartilhando com todos vocês.

Então vamos começar....

Etapa 1:coisas de que você precisa

Aqui está uma lista do que você precisa:-

1. Servo motores x 5 (Amazon Link)

2. Potenciômetros x 5 (Amazon Link)

3. Arduino UNO. (Amazon Link)

4. Bateria. (Estou usando um adaptador 5v)

5. Placa de ensaio. (Amazon Link)

6. Papelão / Madeira / Sun-board / acrílico o que quer que esteja disponível ou seja fácil de encontrar.

E você também precisará do Arduino IDE instalado.

Etapa 2:fazendo o braço

Aqui, usei palitos de picolé para fazer o braço. Você pode usar qualquer material que estiver disponível para você. E você pode experimentar diferentes designs mecânicos para tornar o braço ainda melhor. meu projeto não é muito estável.

Usei apenas fita dupla-face para colar os servos no palito de picolé e prendê-los com parafusos.

Para o braço Master, colei potenciômetros em palitos de picolé e fiz o braço.

Consultar as fotos lhe dará uma ideia melhor.

Montei tudo em uma placa de tela tamanho A4 usada como base.

Etapa 3:Fazendo conexões

Nesta etapa faremos todas as conexões necessárias, consulte as fotos acima.

Primeiro conecte todos os servos em paralelo à fonte de alimentação (o fio vermelho para + ve e o fio preto ou marrom para Gnd)
Em seguida, conecte os fios de sinal, ou seja, o fio amarelo ou laranja ao pino PWM do Arduino.
Agora conecte os potenciômetros a + 5v e Gnd do arduino em paralelo.
Conecte o terminal do meio ao pino analógico do ardunio.

Aqui, os pinos digitais 3, 5, 6, 9 e 10 são usados para controlar os servos

Os pinos analógicos A0 a A4 são usados para entrada de potenciômetros.

O servo conectado ao pino 3 será controlado por potenciômetro conectado a A0

O servo conectado ao pino 5 será controlado pelo potenciômetro em A1 e assim por diante ....

Nota:- Mesmo que os servos não sejam alimentados por arduino, certifique-se de conectar o Gnd dos servos ao arduino ou o braço não funcionará.

Etapa 4:codificação

A lógica desse código é bastante simples:os valores dos potenciômetros são armazenados em uma matriz, os registros são percorridos usando um loop for e os servos executam as etapas de acordo com os valores. Você pode verificar este tutorial que usei para referência "Arduino Potentiometer Servo Control &Memory"

Código:- (arquivo para download anexado abaixo).

Primeiro, declararemos todas as variáveis necessárias globalmente para que possamos usá-las em todo o programa. Nenhuma explicação especial é necessária para isso.

  #include  
 // Objetos Servo 
 Servo Servo_0; 
 Servo Servo_1; 
 Servo Servo_2; 
 Servo Servo_3; 
 Servo Servo_4; 
 // Objetos do potenciômetro 
 int Pot_0; 
 int Pot_1; 
 int Pot_2; 
 int Pot_3; 
 int Pot_4; 
 // Variável para armazenar a posição do servo 
 int Servo_0_Pos; 
 int Servo_1_Pos; 
 int Servo_2_Pos; 
 int Servo_3_Pos; 
 int Servo_4_Pos; 
 // Variável para armazenar os valores da posição anterior 
 int Prev_0_Pos; 
 int Prev_1_Pos; 
 int Prev_2_Pos; 
 int Prev_3_Pos; 
 int Prev_4_Pos; 
 // Variável para armazenar os valores da posição atual 
 int Current_0_Pos; 
 int Current_1_Pos; 
 int Current_2_Pos; 
 int Current_3_Pos; 
 int Current_4_Pos; 
 int Servo_Position; // Armazena o ângulo 
 int Servo_Number; // Armazena nº de servo 
 int Storage [600]; // Array para armazenar dados (aumentar o tamanho do array consumirá mais memória) 
 int Index =0; // O índice da matriz começa na 0ª posição 
 char data =0; // variável para armazenar dados da entrada serial.

Agora vamos escrever uma função de configuração, onde definiremos os pinos e suas funções. Esta é a função principal executada primeiro.

  configuração void () 
 {
 Serial.begin (9600); // Para comunicação serial entre arduino e IDE. 
 // Objetos servo são anexados aos pinos PWM. 
 Servo_0.attach (3); 
 Servo_1.attach (5); 
 Servo_2.attach (6); 
 Servo_3.attach (9); 
 Servo_4.attach (10); 
 // Os servos são definidos para a posição 100 na inicialização. 
 Servo_0.write (100); 
 Servo_1.write (100); 
 Servo_2.write (100); 
 Servo_3.write (100); 
 Servo_4. write (100); 
 Serial.println ("Pressione 'R' para gravar e 'P' para reproduzir"); 
}

Agora temos que ler os valores dos potenciômetros usando pinos de entrada analógica e mapeá-los para controlar servos. Para isso, definiremos uma função e a nomearemos Map_Pot ();, você pode nomeá-lo como quiser, é uma função definida pelo usuário.

  void Map_Pot () 
 {
 / * Os servos giram a 180 graus 
 mas usá-los até os limites não é 
 uma boa ideia, pois faz com que o os servos zumbem continuamente 
 o que é irritante, então limitamos o servo para se mover 
 entre:1-179 * / 
 Pot_0 =analogRead (A0); // Lê a entrada do pote e armazena-a na variável Pot_0. 
 Servo_0_Pos =map (Pot_0, 0, 1023, 1, 179); // Mapear servos conforme o valor entre 0 a 1023 
 Servo_0.write (Servo_0_Pos); // Mova o servo para essa posição. 
 
 Pot_1 =analogRead (A1); 
 Servo_1_Pos =map (Pot_1, 0, 1023, 1, 179); 
 Servo_1.write (Servo_1_Pos); 
 
 Pot_2 =analogRead (A2); 
 Servo_2_Pos =map (Pot_2, 0, 1023, 1, 179); 
 Servo_2.write (Servo_2_Pos); 
 
 Pot_3 =analogRead (A3); 
 Servo_3_Pos =map (Pot_3, 0, 1023, 1, 179); 
 Servo_3.write (Servo_3_Pos); 
 
 Pot_4 =analogRead (A4); 
 Servo_4_Pos =map (Pot_4, 0, 1023, 1, 179); 
 Servo_4.write (Servo_4_Pos); 
}

Agora vamos escrever a função de loop:

  void loop () 
 {
 Map_Pot (); // Chamada de função para ler os valores do potenciômetro 
 
 while (Serial.available ()> 0) 
 {
 data =Serial.read (); 
 if (data =='R') 
 Serial.println ("Gravando Movimentos ..."); 
 if (dados =='P') 
 Serial.println ("Reproduzindo Movimentos Gravados .. . "); 
} 
 if (data =='R') // Se 'R' for inserido, inicie a gravação. 
 {
 // Armazene os valores em um variável 
 Prev_0_Pos =Servo_0_Pos; 
 Prev_1_Pos =Servo_1_Pos; 
 Prev_2_Pos =Servo_2_Pos; 
 Prev_3_Pos =Servo_3_Pos; 
 Prev_4_Pos =Servo_4_Pos; 
 
 Map_Pot (); // Função de mapa chamada para comparação 
 
 if (abs (Prev_0_Pos ==Servo_0_Pos)) // valor absoluto é obtido comparando 
 {
 Servo_0.write (Servo_0_Pos); // Se os valores correspondem ao servo é reposicionado 
 if (Current_0_Pos! =Servo_0_Pos) // Se os valores não correspondem 
 {
 Storage [Index] =Servo_0_Pos + 0; // O valor é adicionado ao array 
 Index ++; // Valor do índice incrementado em 1 
} 
 Current_0_Pos =Servo_0_Pos; 
} 
 / * Da mesma forma, a comparação de valores é feita para todos os servos, +100 é adicionado a cada para a entrada 
 como um valor diferencial. * / 
 if (abs (Prev_1_Pos ==Servo_1_Pos)) 
 {
 Servo_1.write (Servo_1_Pos); 
 if (Current_1_Pos! =Servo_1_Pos) 
 {
 Armazenamento [Índice] =Servo_1_Pos + 100; 
 Índice ++; 
} 
 Atual_1_Pos =Servo_1_Pos; 
} 
 
 if (abs (Prev_2_Pos ==Servo_2_Pos)) 
 {
 Servo_2.write (Servo_2_Pos); 
 if (Current_2_Pos! =Servo_2_Pos) 
 {
 Armazenamento [Índice] =Servo_2_Pos + 200; 
 Índice ++; 
} 
 Atual_2_Pos =Servo_2_Pos; 
} 
 
 if (abs (Prev_3_Pos ==Servo_3_Pos)) 
 {
 Servo_3.write (Servo_3_Pos); 
 if (Current_3_Pos! =Servo_3_Pos) 
 {
 Armazenamento [Índice] =Servo_3_Pos + 300; 
 Índice ++; 
} 
 Atual_3_Pos =Servo_3_Pos; 
} 
 if (abs (Prev_4_Pos ==Servo_4_Pos)) 
 {
 Servo_4.write (Servo_4_Pos); 
 if (Atual_4_Pos! =Servo_4_Pos) 
 {
 Armazenamento [Índice] =Servo_4_Pos + 400; 
 Índice ++; 
} 
 Atual_4_Pos =Servo_4_Pos; 
} 
 / * Os valores são impressos no monitor serial, '\ t' é para exibir os valores em formato tabular * / 
 Serial.print (Servo_0_Pos); 
 Serial.print ("\ t"); 
 Serial.print (Servo_1_Pos); 
 Serial.print ("\ t"); 
 Serial.print (Servo_2_Pos); 
 Serial.print ("\ t"); 
 Serial.print (Servo_3_Pos); 
 Serial.print ("\ t"); 
 Serial.println (Servo_4_Pos); 
 Serial.print ("Índice ="); 
 Serial.println (Índice); 
 atraso (50); 
} 
 if (data =='P') // SE 'P' for inserido, começa a reproduzir os movimentos gravados. 
 {
 para (int i =0; i  {
 Servo_Number =Storage [i] / 100; // Encontra o número de servo 
 Servo_Position =Storage [i]% 100; // Encontra a posição do servo 
 switch (Servo_Number) 
 {
 caso 0:
 Servo_0.write (Servo_Position); 
 break; 
 caso 1:
 Servo_1.write (Servo_Posição); 
 break; 
 caso 2:
 Servo_2.write (Servo_Posição); 
 break; 
 caso 3:
 Servo_3.write (Servo_Posição); 
 quebrar; 
 caso 4:
 Servo_4.write (Servo_Posição); 
 quebrar; 
} 
 atraso (50); 
} 
} 
}

Assim que o código estiver pronto, faça o upload para a placa arduino.

O braço inteligente está pronto para funcionar. A função ainda não é tão suave quanto a feita por Stoerpeak.

Se você pode tornar o código melhor ou tem alguma sugestão para mim, por favor me avise na seção de comentários.

Com isso dito, vamos prosseguir para os testes ....
Record-Play.ino

Etapa 5:Teste

Depois de fazer o upload do código para a placa com sucesso, abra o 'Monitor Serial', você pode encontrá-lo na opção Ferramentas. Quando o monitor serial iniciar, o arduino será reiniciado. Agora você pode controlar o braço robótico usando o braço mestre. Mas nada está sendo gravado.

Para iniciar a gravação, digite 'R' no monitor agora você pode realizar os movimentos que deseja gravar.

Depois que os movimentos forem feitos, você deve inserir 'P' para reproduzir os movimentos registrados. Os servos continuarão a realizar os movimentos enquanto a placa não for reiniciada.

Espero que goste do projeto.

Obrigada...

Código

Record-Play.ino
Snippet de código # 1
Snippet de código # 2
Snippet de código # 3
Snippet de código 4

Record-Play.ino Arduino

Erro ao abrir o arquivo.

Snippet de código # 1 Texto simples

 #include  // Servo ObjetosServo Servo_0; Servo Servo_1; Servo Servo_2; Servo Servo_3; Servo Servo_4; // Objetos de potenciômetroint Pot_0; int Pot_1; int Pot_2; int Pot_3; int Pot_4; // Variável para armazenar Servo Positionint Servo_0_Pos; int Servo_1_Pos; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; // Variável para armazenar valores de posição anteriorint Prev_0_Pos; int Prev_1_Pos; int Prev_2_Pos; int Prev_3_Pos; int Prev_4_Pos; // Variável para armazenar os valores da posição atualint Current_0_Pos; int Current_1_Pos; int Current_2_Pos; int Current_3_Pos; int Current_4_Pos; int Servo_Position; // Armazena o ângulo int Servo_Number; // Armazena nº de servoint Storage [600]; // Array para armazenar dados (aumentar o tamanho do array consumirá mais memória) int Index =0; // O índice da matriz começa a partir do 0º positionchar data =0; // variável para armazenar dados da entrada serial.

Snippet de código # 2 Texto simples

 configuração vazia () {Serial.begin (9600); // Para comunicação serial entre arduino e IDE. // Objetos servo são anexados aos pinos PWM. Servo_0.attach (3); Servo_1.attach (5); Servo_2.attach (6); Servo_3.attach (9); Servo_4.attach (10); // Os servos são definidos para a posição 100 na inicialização. Servo_0.write (100); Servo_1.write (100); Servo_2.write (100); Servo_3.write (100); Servo_4.write (100); Serial.println ("Pressione 'R' para gravar e 'P' para reproduzir"); }

Snippet de código # 3 Texto simples

 void Map_Pot () {/ * Os servos giram a 180 graus, mas usá-los até os limites não é uma boa ideia, pois faz os servos zumbirem continuamente, o que é irritante, então limitamos o servo para se mover entre:1-179 * / Pot_0 =analogRead (A0); // Lê a entrada do pote e armazena-a na variável Pot_0. Servo_0_Pos =mapa (Pot_0, 0, 1023, 1, 179); // Mapear servos conforme o valor entre 0 a 1023 Servo_0.write (Servo_0_Pos); // Mova o servo para essa posição. Pote_1 =leitura analógica (A1); Servo_1_Pos =mapa (Pote_1, 0, 1023, 1, 179); Servo_1.write (Servo_1_Pos); Pote_2 =leitura analógica (A2); Servo_2_Pos =mapa (Pot_2, 0, 1023, 1, 179); Servo_2.write (Servo_2_Pos); Pote_3 =Leitura analógica (A3); Servo_3_Pos =mapa (Pot_3, 0, 1023, 1, 179); Servo_3.write (Servo_3_Pos); Pote_4 =leitura analógica (A4); Servo_4_Pos =mapa (Pot_4, 0, 1023, 1, 179); Servo_4.write (Servo_4_Pos);}

Snippet de código # 4 Texto simples

 void loop () {Map_Pot (); // Chamada de função para ler os valores do potenciômetro while (Serial.available ()> 0) {data =Serial.read (); if (data =='R') Serial.println ("Gravando Movimentos ..."); if (data =='P') Serial.println ("Tocando movimentos gravados ..."); } if (data =='R') // Se 'R' for inserido, inicie a gravação. {// Armazena os valores em uma variável Prev_0_Pos =Servo_0_Pos; Prev_1_Pos =Servo_1_Pos; Prev_2_Pos =Servo_2_Pos; Prev_3_Pos =Servo_3_Pos; Prev_4_Pos =Servo_4_Pos; Map_Pot (); // Função de mapa chamada para comparação if (abs (Prev_0_Pos ==Servo_0_Pos)) // valor absoluto é obtido comparando {Servo_0.write (Servo_0_Pos); // Se os valores correspondem, o servo é reposicionado if (Current_0_Pos! =Servo_0_Pos) // Se os valores não correspondem a {Storage [Index] =Servo_0_Pos + 0; // O valor é adicionado ao array Index ++; // Valor do índice incrementado em 1} Current_0_Pos =Servo_0_Pos; } / * Da mesma forma, a comparação de valor é feita para todos os servos, +100 é adicionado a cada entrada como um valor diferencial. * / if (abs (Prev_1_Pos ==Servo_1_Pos)) {Servo_1.write (Servo_1_Pos); if (Current_1_Pos! =Servo_1_Pos) {Storage [Index] =Servo_1_Pos + 100; Index ++; } Current_1_Pos =Servo_1_Pos; } if (abs (Prev_2_Pos ==Servo_2_Pos)) {Servo_2.write (Servo_2_Pos); if (Current_2_Pos! =Servo_2_Pos) {Storage [Index] =Servo_2_Pos + 200; Index ++; } Current_2_Pos =Servo_2_Pos; } if (abs (Prev_3_Pos ==Servo_3_Pos)) {Servo_3.write (Servo_3_Pos); if (Current_3_Pos! =Servo_3_Pos) {Storage [Index] =Servo_3_Pos + 300; Index ++; } Current_3_Pos =Servo_3_Pos; } if (abs (Prev_4_Pos ==Servo_4_Pos)) {Servo_4.write (Servo_4_Pos); if (Atual_4_Pos! =Servo_4_Pos) {Armazenamento [Índice] =Servo_4_Pos + 400; Index ++; } Current_4_Pos =Servo_4_Pos; } / * Os valores são impressos no monitor serial, '\ t' é para exibir os valores em formato tabular * / Serial.print (Servo_0_Pos); Serial.print ("\ t"); Serial.print (Servo_1_Pos); Serial.print ("\ t"); Serial.print (Servo_2_Pos); Serial.print ("\ t"); Serial.print (Servo_3_Pos); Serial.print ("\ t"); Serial.println (Servo_4_Pos); Serial.print ("Índice ="); Serial.println (Índice); atraso (50); } if (data =='P') // SE 'P' for inserido, começa a reproduzir os movimentos gravados. {for (int i =0; i

Esquemas

Livros do Conselho Notáveis INICIAR:Um Terminal STandalone ARduino

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial