Arduino Spider Robot (quadrúpede)

Componentes e suprimentos

Arduino Nano R3

Módulo Bluetooth Low Energy (BLE) (Genérico)

Expansão OLED da Onion Corporation

Cátodo comum difuso RGB

PCB personalizado JLCPCB

Sobre este projeto

Ei pessoal! Aqui está um novo tutorial para guiá-lo passo a passo enquanto faz esse tipo de projeto eletrônico super incrível, que é o "robô rastreador" também conhecido como "robô aranha" ou "robô quadrúpede".

Como todos notaram a evolução em alta velocidade da tecnologia de robótica, decidimos levar vocês a um nível mais alto em robótica e fabricação de robôs. começamos há um tempo fazendo alguns projetos eletrônicos básicos e um robô básico como o PICTO92, o robô seguidor de linha, a fim de torná-lo um pouco familiarizado com o material eletrônico e descobrir que você é capaz de inventar seus próprios projetos.

Passando para outro nível, começamos com este robô que é básico no conceito, mas se tornará um pouco complicado se você se aprofundar em seu programa. E como esses gadgets são muito caros na loja on-line, fornecemos esta orientação passo a passo para orientar vocês na criação de seu próprio Spiderbot .

Este projeto é muito útil de fazer, especialmente depois de obter o PCB personalizado que encomendamos da JLCPCB para melhorar a aparência de nosso robô e também há documentos e códigos suficientes neste guia para permitir que você crie seu rastreador facilmente.

Fizemos esse projeto em apenas 7 dias, apenas dois dias para terminar a fabricação do hardware e a montagem, depois cinco dias para preparar o código e o aplicativo Android. a fim de controlar o robô através dele. Antes de começar, vamos ver primeiro

O que você aprenderá:

Selecionando os componentes certos dependendo das funcionalidades do seu projeto

Fazendo o circuito para conectar todos os componentes escolhidos

Monte todas as partes do projeto

Dimensionamento do equilíbrio do robô

Usando o aplicativo Android. para se conectar por Bluetooth e começar a manipular o sistema

Etapa 1:O que é um "robô aranha?"

Como o próprio nome o define, nosso robô é uma representação básica dos movimentos do sipder, mas não realizará exatamente os mesmos movimentos do corpo, pois estamos usando apenas quatro pernas em vez de oito pernas.

Também chamado de quadrúpede robô por ter quatro pernas e realizar seus movimentos com essas pernas, o movimento de cada perna está relacionado às demais pernas para identificar a posição do corpo do robô e também para controlar o equilíbrio corporal do robô.

Robôs com pernas lidam com o terreno melhor do que suas contrapartes com rodas e se movem de maneiras variadas e animalescas. No entanto, isso torna os robôs com pernas mais complicados e menos acessíveis para muitos fabricantes. e também o custo de fabricação e as altas despesas que um fabricante deve gastar para criar um quadrúpede de corpo inteiro, uma vez que é baseado em servo motores ou motores de passo e ambos são mais caros do que os motores DC que poderiam ser usados em robôs com rodas.

Vantagens

Você encontrará quadrúpedes abundantes na natureza, porque quatro pernas permitem estabilidade passiva ou a capacidade de ficar em pé sem ajustar ativamente a posição. O mesmo se aplica aos robôs. Um robô de quatro patas é mais barato e simples do que um robô com mais pernas, mas ainda assim pode alcançar estabilidade.

Etapa 2:Servo motores são os principais atuadores

Um servomotor, conforme definido na Wikipedia, é um atuador rotativo ou linear que permite o controle preciso da posição angular ou linear, velocidade e aceleração. [1] Ele consiste em um motor adequado acoplado a um sensor para feedback de posição. Também requer um controlador relativamente sofisticado, geralmente um módulo dedicado projetado especificamente para uso com servomotores.

Servomotores não são uma classe específica de motor, embora o termo servomotor seja freqüentemente usado para se referir a um motor adequado para uso em um sistema de controle de malha fechada.

De modo geral, o sinal de controle é um trem de pulso de onda quadrada. As frequências comuns para sinais de controle são 44 Hz, 50 Hz e 400 Hz. A largura de pulso positiva é o que determina a posição do servo. Uma largura de pulso positiva de cerca de 0,5 ms fará com que a sirene do servo se desvie o máximo que puder para a esquerda (geralmente em torno de 45 a 90 graus, dependendo do servo em questão). Uma largura de pulso positiva de cerca de 2,5 ms a 3,0 ms fará com que o servo se desvie para a direita o máximo que puder. Uma largura de pulso de cerca de 1,5 ms fará com que o servo mantenha a posição neutra em 0 graus. A alta tensão de saída é geralmente algo entre 2,5 volts e 10 volts (com 3 V típico). A baixa tensão de saída varia de -40mV a 0V.

Etapa 3:A fabricação de PCB (produzida por JLCPCB)

Sobre JLCPCB

JLCPCB (Shenzhen JIALICHUANG Electronic Technology Development Co., Ltd.), é a maior empresa de protótipos de PCB na China e um fabricante de alta tecnologia especializado em protótipos de PCB rápidos e produção de pequenos lotes de PCB.

Com mais de 10 anos de experiência na fabricação de PCB, a JLCPCB tem mais de 200.000 clientes em casa e no exterior, com mais de 8.000 pedidos online de prototipagem de PCB e produção de pequenas quantidades de PCB por dia. A capacidade de produção anual é de 200.000 m². para vários PCBs de 1, 2 ou multicamadas. JLC é um fabricante profissional de PCB caracterizado por grande escala, equipamentos de poço, gerenciamento rigoroso e qualidade superior.

Voltar para nosso projeto

Para produzir o PCB, comparei o preço de muitos produtores de PCB e escolhi a JLCPCB, os melhores fornecedores de PCB e os fornecedores de PCB mais baratos para solicitar este circuito. Tudo o que eu preciso fazer é alguns cliques simples para fazer o upload do arquivo gerber e definir alguns parâmetros como a cor e quantidade da espessura do PCB, então eu paguei apenas 2 dólares para obter meu PCB depois de apenas cinco dias.

Como mostra a imagem do esquema relacionado, usei um Arduino Nano para controlar todo o sistema e também projetei o formato de aranha do robô para tornar este projeto muito mais melhor.

Você pode obter o arquivo do circuito (PDF) aqui. Como você pode ver nas fotos acima, o PCB é muito bem fabricado e eu tenho o mesmo formato de aranha do PCB que projetamos e todos os rótulos e logotipos estão lá para me guiar durante as etapas de soldagem.

Você também pode baixar o arquivo Gerber para este circuito aqui, caso deseje fazer um pedido para o mesmo projeto de circuito.

Etapa 4:Ingredientes

Agora vamos revisar os componentes necessários que precisamos para este projeto, então como eu disse, estou usando um Arduino Nano para rodar todos os 12 servo motores das quatro pernas do robô. O projeto também inclui um display OLED para mostrar as faces do Cozmo e um módulo bluetooth para controlar o robô por meio de um aplicativo android.

Para criar este tipo de projetos, precisaremos de:

- O PCB que pedimos da JLCPCB

- 12 servo motores como você se lembra 3 servos para cada perna:https://amzn.to/2B25XbG

- Um Arduino Nano:https://amzn.to/2MmZsVg

- Módulo Bluetooth HC-06:https://amzn.to/2B1Z3CY

- Uma tela OLED:https://amzn.to/2OySnyn

- LEDs RGB de 5 mm:https://amzn.to/2B56hq3

- Alguns conectores de cabeçalho:https://amzn.to/2nyZg7i

- E as peças do corpo do robô de que você precisa para imprimi-las usando uma impressora 3D

Etapa 5:montagem do robô

Agora que temos a placa de circuito impresso pronta e todos os componentes soldados muito bem, depois precisamos montar o corpo do robô, o procedimento é tão fácil então basta seguir os passos que mostro, precisamos primeiro preparar cada perna de um lado e fazer um led precisamos de dois servo motores para as juntas e as peças impressas Coxa, Femur e Tibia com esta pequena peça de fixação.

Sobre as peças do corpo do robô você pode baixar seus arquivos STL aqui.

Começando com o primeiro servo, coloque-o em seu soquete e segure-o com seus parafusos, em seguida gire o machado do servo a 180 ° sem colocar o parafuso de fixação e passe para a próxima parte que é o fêmur para conectá-lo à tíbia usando o primeiro machado de junta de servo e a peça de fixação. A última etapa para completar a perna é colocar a segunda junta, quero dizer, o segundo servo para segurar a terceira parte da perna que é a peça Coxa.

Agora repita a mesma coisa para todas as pernas para preparar as quatro pernas. Depois disso, pegue o chassi superior e coloque o resto dos servos em seus soquetes e conecte cada perna ao servo apropriado. Há apenas uma última parte impressa que é o chassi do robô inferior onde colocaremos nossa placa de circuito

Etapa 6:o aplicativo Android

Falar sobre o andróide permite que você

conecte-se ao seu robô através de Bluetooth e faça movimentos para frente e para trás e viradas para a esquerda à direita, permite também controlar a cor da luz do robô em tempo real, escolhendo a cor desejada nesta roda de cores.

Você pode baixar o aplicativo Android gratuitamente neste link:aqui

Etapa 7:o código do Arduino e a validação do teste

Agora temos o robô quase pronto para rodar, mas precisamos configurar primeiro os ângulos das juntas, então carregue o código de configuração que permite colocar cada servo na posição correta conectando os servos em 90 graus não se esqueça de conectar o 7V Bateria DC para operar o robô.

Em seguida, precisamos fazer o upload do programa principal para controlar o robô usando o aplicativo Android. Ambos os programas você pode baixá-los a partir destes links:

- Código servo de escalonamento:link para download - Programa principal do robô aranha:link para download

Após fazer o upload do código, conectei o display OLED para exibir os sorrisos do robô Cozmo que fiz no código principal.

Como vocês podem ver galera nas fotos acima, o robô segue todas as instruções enviadas do meu smartphone e ainda algumas outras melhorias para realizar para deixá-lo muito mais melhor.

Código

Código principal do Spider Robot

Código principal do Spider Robot Arduino

 / ********************************************** *************************************************** *************************************************** ********************** * - Autor:BELKHIR Mohamed * * - Profissão:(Engenheiro Elétrico) Proprietário MEGA DAS * * - Objetivo principal:Aplicação Industrial * * - Detentor dos direitos autorais (c):Todos os direitos reservados * * - Licença:Licença BSD de 2 cláusulas * * - Data:20/04/2017 * * ******************* *************************************************** *************************************************** *************************************************** / /*********************************** NOTA ************* ************************** /// A redistribuição e o uso nas formas de origem e binária, com ou sem // modificação, são permitidos desde que o seguinte condições forem atendidas:// * As redistribuições do código-fonte devem manter o aviso de copyright acima, esta // lista de condições e a seguinte isenção de responsabilidade.// * As redistribuições na forma binária devem ser reproduzidas ce o aviso de direitos autorais acima, // esta lista de condições e a seguinte isenção de responsabilidade na documentação // e / ou outros materiais fornecidos com a distribuição.// ESTE SOFTWARE É FORNECIDO PELOS PROPRIETÁRIOS DE DIREITOS AUTORAIS E CONTRIBUIDORES "COMO ESTÁ" // E QUAISQUER GARANTIAS EXPRESSAS OU IMPLÍCITAS, INCLUINDO, MAS NÃO SE LIMITANDO A, // GARANTIAS IMPLÍCITAS DE COMERCIALIZAÇÃO E ADEQUAÇÃO A UM DETERMINADO FIM SÃO REJEITADAS / * * / # include  // para definir e controlar servos # include  // para definir um cronômetro para gerenciar todos os servos # include  #include  #include  // display OLED endereço TWI # define display OLED_ADDR 0x3CAdafruit_SSD1306 display (-1); / * Servos ----------------------------------------------- --------------------- * /// define 12 servos para 4 pernasServo servo [4] [3]; // define servos 'portsconst int servo_pin [4] [3] ={{11, 12, 13}, {2, 4, 7}, {14, 15, 16}, {8, 9, 10}}; / * Tamanho do robô ------ -------------------------------------------------- - * / const float l ength_a =50; const float length_b =77,1; const float length_c =27,5; const float length_side =71; const float z_absolute =-28; / * Constantes para movimento ---------------- ------------------------------------ * / const float z_default =-50, z_up =-30, z_boot =z_absolute; const float x_default =62, x_offset =0; const float y_start =0, y_step =40; const float y_default =x_default; / * variáveis para movimento --------------- ------------------------------------- * / volatile float site_now [4] [3]; // coordenadas em tempo real do final de cada legvolátil float site_expect [4] [3]; // coordenadas esperadas do final de cada legfloat temp_speed [4] [3]; // a velocidade de cada eixo, precisa ser recalculada antes de cada movimentofloat move_speed; // movimento speedfloat speed_multiple =1; // velocidade de movimento multipleconst float spot_turn_speed =4; const float leg_move_speed =8; const float body_move_speed =3; const float stand_seat_speed =1; volatile int rest_counter; //+1/0.02s, para descanso automático // functions 'parameterconst float KEEP =255; // define PI para cálculoconst float pi =3.1415926; / * Constantes para curva ------------- ------------------------------------------- * /// temp lengthconst float temp_a =sqrt (pow (2 * x_default + length_side, 2) + pow (y_step, 2)); const float temp_b =2 * (y_start + y_step) + length_side; const float temp_c =sqrt (pow (2 * x_default + length_side , 2) + pow (2 * y_início + y_passo + comprimento_lado, 2)); const float temp_alpha =acos ((pow (temp_a, 2) + pow (temp_b, 2) - pow (temp_c, 2)) / 2 / temp_a / temp_b); // local para turnconst float turn_x1 =(temp_a - length_side) / 2; const float turn_y1 =y_start + y_step / 2; const float turn_x0 =turn_x1 - temp_b * cos (temp_alpha); const float turn_y0 =temp_b * sin (temp_alpha) - turn_y1 - length_side; const int lightR =3; const int lightG =5; const int lightB =6; int LedR =0; int LedG =0; int LedB =0; char SerialData; // Use esta variável para ler cada caractere recebido através do serial portString data =""; void setup () {Serial.begin (9600); display.begin (SSD1306_SWITCHCAPVCC, OLED_ADDR); display.clearDisplay (); display.display (); atraso (10000); set_site (0, x_default - x_offset, y_start + y_step, z_boot); set_site (1, x_default - x_offset, y_start + y_step, z_boot); set_site (2, x_default + x_offset, y_start, z_boot); set_site (3, x_default + x_offset, y_start, z_boot); for (int i =0; i <4; i ++) {for (int j =0; j <3; j ++) {site_now [i] [j] =site_expect [i] [j]; }} // inicia o serviço servo FlexiTimer2 ::set (20, servo_service); FlexiTimer2 ::start (); // inicializa servos servo_attach (); stand (); // delay (3000); // sit (); // delay (3000); // stand (); // delay (3000); feliz(); atraso (aleatório (500, 1000)); cierra (); atraso (150); enfado (); atraso (aleatório (1000, 3000)); cierra (); atraso (150); entorna (); atraso (aleatório (1000, 3000)); cierra (); atraso (150); enfado1 (); atraso (aleatório (1000, 3000)); cierra (); atraso (150); triste (); atraso (aleatório (1000, 3000)); cierra (); atraso (150); abre (); atraso (aleatório (500, 3000)); cierra (); atraso (150); feliz(); delay (random (500, 1000));} void loop () {while (Serial.available ()) // Enquanto os dados seriais estão disponíveis, nós os armazenamos {delay (10); SerialData =Serial.read (); if (SerialData =='b') LedR =Serial.parseInt (); else if (SerialData =='g') LedG =Serial.parseInt (); else if (SerialData =='r') LedB =Serial.parseInt (); senão dados + =SerialData; } if (data =="f") // Se os dados armazenados são movimento para frente {cierra (); atraso (150); feliz(); step_forward (1); } if (data =="p") // Se os dados armazenados são um movimento para trás {cierra (); atraso (150); triste (); step_back (1); } if (data =="l") // Se os dados armazenados são para virar à esquerda do carro {cierra (); atraso (150); enfado1 (); turn_left (1); } if (data =="m") // Se os dados armazenados são para virar à direita o carro {cierra (); atraso (150); enfado (); turn_right (5); } dados =""; analogWrite (lightR, LedR); analogWrite (lightG, LedG); analogWrite (lightB, LedB);} void servo_attach (void) {for (int i =0; i <4; i ++) {for (int j =0; j <3; j ++) {servo [i] [j]. anexar (servo_pin [i] [j]); atraso (100); }}} void servo_detach (void) {for (int i =0; i <4; i ++) {for (int j =0; j <3; j ++) {servo [i] [j] .detach (); atraso (100); }}} void sit (void) {move_speed =stand_seat_speed; para (perna interna =0; perna <4; perna ++) {set_site (perna, MANTER, MANTER, z_boot); } wait_all_reach ();} / * - stand - função de bloqueio ------------------------------------- -------------------------------------- * / void stand (void) {move_speed =stand_seat_speed; para (perna interna =0; perna <4; perna ++) {set_site (perna, KEEP, KEEP, z_default); } wait_all_reach ();} / * - virar à esquerda - função de bloqueio - etapas de parâmetro que deseja virar --------------------------- ------------------------------------------------ * / void turn_left (passo interno sem sinal) {move_speed =spot_turn_speed; while (etapa--> 0) {if (site_now [3] [1] ==y_início) {// trecho 3 e 1 mover set_site (3, x_default + x_offset, y_início, z_up); wait_all_reach (); set_site (0, turn_x1 - x_offset, turn_y1, z_default); set_site (1, turn_x0 - x_offset, turn_y0, z_default); set_site (2, turn_x1 + x_offset, turn_y1, z_default); set_site (3, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach (); set_site (3, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach (); set_site (0, turn_x1 + x_offset, turn_y1, z_default); set_site (1, turn_x0 + x_offset, turn_y0, z_default); set_site (2, turn_x1 - x_offset, turn_y1, z_default); set_site (3, turn_x0 - x_offset, turn_y0, z_default); wait_all_reach (); set_site (1, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach (); set_site (0, x_default + x_offset, y_start, z_default); set_site (1, x_default + x_offset, y_start, z_up); set_site (2, x_default - x_offset, y_start + y_step, z_default); set_site (3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach (); set_site (1, x_default + x_offset, y_start, z_default); wait_all_reach (); } else {// perna 0 e 2 mover set_site (0, x_default + x_offset, y_start, z_up); wait_all_reach (); set_site (0, turn_x0 + x_offset, turn_y0, z_up); set_site (1, turn_x1 + x_offset, turn_y1, z_default); set_site (2, turn_x0 - x_offset, turn_y0, z_default); set_site (3, turn_x1 - x_offset, turn_y1, z_default); wait_all_reach (); set_site (0, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach (); set_site (0, turn_x0 - x_offset, turn_y0, z_default); set_site (1, turn_x1 - x_offset, turn_y1, z_default); set_site (2, turn_x0 + x_offset, turn_y0, z_default); set_site (3, turn_x1 + x_offset, turn_y1, z_default); wait_all_reach (); set_site (2, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach (); set_site (0, x_default - x_offset, y_start + y_step, z_default); set_site (1, x_default - x_offset, y_start + y_step, z_default); set_site (2, x_default + x_offset, y_start, z_up); set_site (3, x_default + x_offset, y_start, z_default); wait_all_reach (); set_site (2, x_default + x_offset, y_start, z_default); wait_all_reach (); }}} / * - virar à direita - função de bloqueio - etapas de parâmetro que deseja virar ------------------------------ --------------------------------------------- * / void turn_right ( passo interno sem sinal) {move_speed =spot_turn_speed; while (etapa--> 0) {if (site_now [2] [1] ==y_início) {// trecho 2 e 0 mover set_site (2, x_default + x_offset, y_início, z_up); wait_all_reach (); set_site (0, turn_x0 - x_offset, turn_y0, z_default); set_site (1, turn_x1 - x_offset, turn_y1, z_default); set_site (2, turn_x0 + x_offset, turn_y0, z_up); set_site (3, turn_x1 + x_offset, turn_y1, z_default); wait_all_reach (); set_site (2, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach (); set_site (0, turn_x0 + x_offset, turn_y0, z_default); set_site (1, turn_x1 + x_offset, turn_y1, z_default); set_site (2, turn_x0 - x_offset, turn_y0, z_default); set_site (3, turn_x1 - x_offset, turn_y1, z_default); wait_all_reach (); set_site (0, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach (); set_site (0, x_default + x_offset, y_start, z_up); set_site (1, x_default + x_offset, y_start, z_default); set_site (2, x_default - x_offset, y_start + y_step, z_default); set_site (3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach (); set_site (0, x_default + x_offset, y_start, z_default); wait_all_reach (); } else {// perna 1 e 3 mover set_site (1, x_default + x_offset, y_start, z_up); wait_all_reach (); set_site (0, turn_x1 + x_offset, turn_y1, z_default); set_site (1, turn_x0 + x_offset, turn_y0, z_up); set_site (2, turn_x1 - x_offset, turn_y1, z_default); set_site (3, turn_x0 - x_offset, turn_y0, z_default); wait_all_reach (); set_site (1, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach (); set_site (0, turn_x1 - x_offset, turn_y1, z_default); set_site (1, turn_x0 - x_offset, turn_y0, z_default); set_site (2, turn_x1 + x_offset, turn_y1, z_default); set_site (3, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach (); set_site (3, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach (); set_site (0, x_default - x_offset, y_start + y_step, z_default); set_site (1, x_default - x_offset, y_start + y_step, z_default); set_site (2, x_default + x_offset, y_start, z_default); set_site (3, x_default + x_offset, y_start, z_up); wait_all_reach (); set_site (3, x_default + x_offset, y_start, z_default); wait_all_reach (); }}} / * - avançar - função de bloqueio - etapas de etapa de parâmetro desejadas -------------------------------- ------------------------------------------- * / void step_forward (unsigned int etapa) {move_speed =leg_move_speed; while (etapa--> 0) {if (site_now [2] [1] ==y_início) {// perna 2 e 1 mover set_site (2, x_default + x_offset, y_início, z_up); wait_all_reach (); set_site (2, x_default + x_offset, y_início + 2 * y_step, z_up); wait_all_reach (); set_site (2, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach (); move_speed =body_move_speed; set_site (0, x_default + x_offset, y_start, z_default); set_site (1, x_default + x_offset, y_start + 2 * y_step, z_default); set_site (2, x_default - x_offset, y_start + y_step, z_default); set_site (3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach (); move_speed =leg_move_speed; set_site (1, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach (); set_site (1, x_default + x_offset, y_start, z_up); wait_all_reach (); set_site (1, x_default + x_offset, y_start, z_default); wait_all_reach (); } else {// perna 0 e 3 move set_site (0, x_default + x_offset, y_start, z_up); wait_all_reach (); set_site (0, x_default + x_offset, y_início + 2 * y_step, z_up); wait_all_reach (); set_site (0, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach (); move_speed =body_move_speed; set_site (0, x_default - x_offset, y_start + y_step, z_default); set_site (1, x_default - x_offset, y_start + y_step, z_default); set_site (2, x_default + x_offset, y_start, z_default); set_site (3, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach (); move_speed =leg_move_speed; set_site (3, x_default + x_offset, y_início + 2 * y_step, z_up); wait_all_reach (); set_site (3, x_default + x_offset, y_start, z_up); wait_all_reach (); set_site (3, x_default + x_offset, y_start, z_default); wait_all_reach (); }}} / * - voltar - função de bloqueio - etapas de etapa de parâmetro desejadas -------------------------------- ------------------------------------------- * / void step_back (unsigned int etapa) {move_speed =leg_move_speed; while (etapa--> 0) {if (site_now [3] [1] ==y_início) {// trecho 3 e 0 mover set_site (3, x_default + x_offset, y_início, z_up); wait_all_reach (); set_site (3, x_default + x_offset, y_início + 2 * y_step, z_up); wait_all_reach (); set_site (3, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach (); move_speed =body_move_speed; set_site (0, x_default + x_offset, y_start + 2 * y_step, z_default); set_site (1, x_default + x_offset, y_start, z_default); set_site (2, x_default - x_offset, y_start + y_step, z_default); set_site (3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach (); move_speed =leg_move_speed; set_site (0, x_default + x_offset, y_início + 2 * y_step, z_up); wait_all_reach (); set_site (0, x_default + x_offset, y_start, z_up); wait_all_reach (); set_site (0, x_default + x_offset, y_start, z_default); wait_all_reach (); } else {// perna 1 e 2 mover set_site (1, x_default + x_offset, y_start, z_up); wait_all_reach (); set_site (1, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach (); set_site (1, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach (); move_speed =body_move_speed; set_site (0, x_default - x_offset, y_start + y_step, z_default); set_site (1, x_default - x_offset, y_start + y_step, z_default); set_site (2, x_default + x_offset, y_start + 2 * y_step, z_default); set_site (3, x_default + x_offset, y_start, z_default); wait_all_reach (); move_speed =leg_move_speed; set_site (2, x_default + x_offset, y_início + 2 * y_step, z_up); wait_all_reach (); set_site (2, x_default + x_offset, y_start, z_up); wait_all_reach (); set_site (2, x_default + x_offset, y_start, z_default); wait_all_reach (); }}} // adicionar por RegisHsuvoid body_left (int i) {set_site (0, site_now [0] [0] + i, KEEP, KEEP); set_site (1, site_now [1] [0] + i, MANTER, MANTER); set_site (2, site_now [2] [0] - i, MANTER, MANTER); set_site (3, site_now [3] [0] - i, MANTER, MANTER); wait_all_reach ();} void body_right (int i) {set_site (0, site_now [0] [0] - i, MANTER, MANTER); set_site (1, site_now [1] [0] - i, MANTER, MANTER); set_site (2, site_now [2] [0] + i, MANTER, MANTER); set_site (3, site_now [3] [0] + i, MANTER, MANTER); wait_all_reach ();} void hand_wave (int i) {float x_tmp; float y_tmp; float z_tmp; move_speed =1; if (site_now [3] [1] ==y_start) {body_right (15); x_tmp =site_now [2] [0]; y_tmp =site_now [2] [1]; z_tmp =site_now [2] [2]; move_speed =body_move_speed; para (int j =0; j  i / 4) // move_speed =body_dance_speed * 2; // if (j> i / 2) // move_speed =body_dance_speed * 3; / / set_site (0, KEEP, y_default - 20, KEEP); // set_site (1, KEEP, y_default + 20, KEEP); // set_site (2, KEEP, y_default - 20, KEEP); // set_site (3, KEEP, y_default + 20, KEEP); // wait_all_reach (); // set_site (0, KEEP, y_default + 2 0, KEEP); // set_site (1, KEEP, y_default - 20, KEEP); // set_site (2, KEEP, y_default + 20, KEEP); // set_site (3, KEEP, y_default - 20, KEEP); // wait_all_reach (); //} // move_speed =body_dance_speed; // head_down (30); //} / * - serviço de microservos / função de interrupção do temporizador / 50 Hz - quando definido como site esperado, esta função move o ponto final para ele em linha reta - temp_speed [4] [3] deve ser definido antes de definir o local esperado, ele garante que o ponto final se mova em linha reta e decida a velocidade de movimento. -------------------------------------------------- ------------------------- * / void servo_service (void) {sei (); float estático alfa, beta, gama; for (int i =0; i <4; i ++) {for (int j =0; j <3; j ++) {if (abs (site_now [i] [j] - site_expect [i] [j])> =abs (temp_speed [i] [j])) site_now [i] [j] + =temp_speed [i] [j]; else site_now [i] [j] =site_expect [i] [j]; } cartesian_to_polar (alfa, beta, gama, site_now [i] [0], site_now [i] [1], site_now [i] [2]); polar_to_servo (i, alfa, beta, gama); } rest_counter ++;} / * - definir um dos pontos finais do site esperado - esta função irá definir temp_speed [4] [3] ao mesmo tempo - função sem bloqueio --------------- -------------------------------------------------- ---------- * / void set_site (int perna, float x, float y, float z) {float length_x =0, length_y =0, length_z =0; if (x! =MANTER) comprimento_x =x - site_agora [perna] [0]; if (y! =MANTER) length_y =y - site_now [leg] [1]; if (z! =MANTER) length_z =z - site_now [perna] [2]; comprimento do flutuador =sqrt (pow (comprimento_x, 2) + pow (comprimento_y, 2) + pow (comprimento_z, 2)); temp_speed [perna] [0] =length_x / length * move_speed * speed_multiple; temp_speed [perna] [1] =length_y / length * move_speed * speed_multiple; temp_speed [perna] [2] =length_z / length * move_speed * speed_multiple; if (x! =MANTER) site_expect [leg] [0] =x; if (y! =MANTER) site_expect [leg] [1] =y; if (z! =KEEP) site_expect [leg] [2] =z;} / * - aguarde um dos pontos de extremidade mover para esperar o site - função de bloqueio ----------------- -------------------------------------------------- -------- * / void wait_reach (int leg) {while (1) if (site_now [leg] [0] ==site_expect [leg] [0]) if (site_now [leg] [1] ==site_expect [leg] [1]) if (site_now [leg] [2] ==site_expect [leg] [2]) break;} / * - aguarde a movimentação de todos os endpoints para esperar o site - função de bloqueio ---- -------------------------------------------------- --------------------- * / void wait_all_reach (void) {for (int i =0; i <4; i ++) wait_reach (i);} / * - local trans de cartesiano para polar - modelo matemático 2/2 ------------------------------------- -------------------------------------- * / void cartesian_to_polar (flutuação volátil e alfa, flutuação volátil e beta , flutuação volátil &gama, flutuação volátil x, flutuação volátil y, flutuação volátil z) {// calcular wz flutuação de grau v, w; w =(x> =0? 1:-1) * (sqrt (pow (x, 2) + pow (y, 2))); v =w - comprimento_c; alfa =atan2 (z, v) + acos ((pow (comprimento_a, 2) - pow (comprimento_b, 2) + pow (v, 2) + pow (z, 2)) / 2 / comprimento_a / sqrt (pow (v , 2) + pow (z, 2))); beta =acos ((pow (comprimento_a, 2) + pow (comprimento_b, 2) - pow (v, 2) - pow (z, 2)) / 2 / comprimento_a / comprimento_b); // calcula o grau x-y-z gama =(w> =0)? atan2 (y, x):atan2 (-y, -x); // grau trans pi-> 180 alpha =alpha / pi * 180; beta =beta / pi * 180; gamma =gamma / pi * 180;} / * - local trans de polar para microsservos - mapa de modelo matemático para fato - os erros salvos no eeprom serão adicionados ----------------- -------------------------------------------------- -------- * / void polar_to_servo (int perna, float alpha, float beta, float gamma) {if (perna ==0) {alpha =90 - alpha; beta =beta; gama + =90; } else if (leg ==1) {alpha + =90; beta =180 - beta; gama =90 - gama; } else if (leg ==2) {alpha + =90; beta =180 - beta; gama =90 - gama; } else if (leg ==3) {alpha =90 - alpha; beta =beta; gama + =90; } servo [perna] [0] .write (alfa); servo [perna] [1] .write (beta); servo [perna] [2] .write (gamma);} void abre () {display.clearDisplay (); display.fillCircle (50, 15, 12, BRANCO); // ojo izquierdo grande display.fillCircle (82, 20, 7, BRANCO); // ojo derecho pequeo display.display ();} void cierra () {display.clearDisplay (); display.drawFastHLine (40, 15, 20, BRANCO); display.drawFastHLine (72, 20, 15, BRANCO); display.display ();} void entorna () {display.clearDisplay (); display.fillCircle (42, 10, 20, BRANCO); // ojo izquierdo grande display.fillCircle (82, 10, 15, BRANCO); // ojo derecho pequeo display.fillRect (0, 0, 128, 15, BLACK); // ceja superior display.fillRect (0, 40, 128, 15, BLACK); // ceja inferior display.display ();} void triste () {display.clearDisplay (); display.fillCircle (42, 10, 17, BRANCO); // ojo izquierdo grande display.fillCircle (82, 10, 17, BRANCO); // ojo derecho pequeo display.fillTriangle (0, 0, 0, 35, 78, 0, BLACK); // ceja superior display.fillTriangle (50, 0, 128, 35, 128, 0, BLACK); // ceja superior display.display ();} void happy () {display.clearDisplay (); display.fillCircle (42, 25, 15, BRANCO); // ojo izquierdo grande display.fillCircle (82, 25, 15, BRANCO); // ojo derecho pequeo display.fillCircle (42, 33, 20, BLACK); // ojo izquierdo grande display.fillCircle (82, 33, 20, PRETO); // ojo derecho pequeo display.display ();} void enfado () {display.clearDisplay (); display.fillCircle (42, 10, 18, BRANCO); // ojo izquierdo grande display.fillCircle (82, 10, 12, BRANCO); // ojo derecho pequeo display.fillTriangle (0, 0, 54, 26, 118, 0, BLACK); // ceja superior display.display ();} void enfado1 () {display.clearDisplay (); display.fillCircle (42, 10, 18, BRANCO); // ojo izquierdo grande display.fillCircle (82, 10, 12, BRANCO); // ojo derecho pequeo display.fillTriangle (0, 0, 65, 15, 120, 0, BLACK); // ceja superior display.display ();}

Peças personalizadas e gabinetes

Esquemas

Dispositivo de desinfecção de máscaras faciais - needlab Arduino, Monitorando a abertura da porta via Gmail

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial