Braço robótico simples e inteligente usando Arduino !!!: 5 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Neste instrutível estarei fazendo um braço robótico simples. Isso será controlado por meio de 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 - por 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 que você precisa: -

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

1. Servo motores x 5 Link para os EUA: - https://amzn.to/2OxbSH7Link para a Europa: -

2. Potenciômetros x 5 (usei 100k.) Link para os EUA: - https://amzn.to/2ROjhDMLink para a Europa: -

3. Arduino UNO. (Você também pode usar o Arduino Nano) Link para os EUA: - https://amzn.to/2DBbENWLink para a Europa: -

4. Placa de ensaio. (Eu sugiro este kit) Link para os EUA: - https://amzn.to/2Dy86w4Link para a Europa: -

5. Bateria. (opcional, estou usando um adaptador 5v)

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 deste 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

#incluir

// 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

void setup ()

{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 os pinos de entrada analógica e mapeá-los para controlar os 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 os servos zumbam continuamente, o que é irritante, então limitamos o servo para se mover entre: 1-179 * / Pot_0 = analogRead (A0); // Leia a entrada do pote e armazene-a na variável Pote_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); }

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 (data == 'P') Serial.println ("Reproduzindo 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 valores é 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 (Current_4_Pos! = Servo_4_Pos) {Storage [Index] = 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 tocar os movimentos gravados. {for (int i = 0; i <Index; i ++) // Percorra a matriz usando o loop for {Servo_Number = Storage / 100; // Encontra o número de servo Servo_Position = Storage % 100; // Encontra a posição do servo switch (Servo_Number) {case 0: Servo_0.write (Servo_Position); pausa; caso 1: Servo_1.write (Servo_Posição); pausa; caso 2: Servo_2.write (Servo_Posição); pausa; caso 3: Servo_3.write (Servo_Posição); pausa; caso 4: Servo_4.write (Servo_Posição); pausa; } 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….

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.