Robô de controle de gestos

Componentes e suprimentos

Arduino UNO

Arduino Nano R3

Receptor transmissor RF-433

Codificador e decodificador HT12

Adafruit Analog Accelerometer:ADXL335

Blindagem do motor para Uno

Motor DC (genérico)

Ferramentas e máquinas necessárias

Ferro de soldar (genérico)

Sobre este projeto

O robô de controle por gestos é um dos tipos mais comuns de projetos feitos por amadores e alunos para entender e implementar o conhecimento de microcontroladores em um projeto físico e prático. O conceito por trás disso é simples:a orientação da palma da mão controla o movimento do carro robô. Como isso faz, você pergunta? Vamos decompô-lo.

Para obter um bom entendimento, avançaremos entendendo a função e a função de cada componente e, em seguida, combinando-os para atingir o desempenho desejado.

1. ADXL335 (Acelerômetro)

A função do acelerômetro é simples:detectar a orientação do pulso. O acelerômetro mede a aceleração, incluindo a aceleração devida à gravidade 'g' também. Assim, podemos usar o acelerômetro para detectar a orientação do pulso medindo o componente de 'g' em qualquer eixo específico de ADXL335, conforme mostrado na figura abaixo:

Devido à inclinação da mão, o ângulo do eixo X e / ou Y com mudanças verticais e, portanto, um componente de aceleração 'g' atua sobre eles também, que pode ser medido e, portanto, indica a orientação da mão.

O ADXL335 pode medir até 3g de aceleração e tem interface com o Arduino conectando seus pinos de eixo aos pinos analógicos do Arduino. O acelerômetro emite valores de tensão proporcionais à aceleração.

Neste projeto, o acelerômetro é conectado ao Arduino Nano e à palma da mão. O ADXL335 saídas de tensão na faixa de 0 a Vcc (tensão aplicada geralmente 3,3 V) e é lido pelos pinos analógicos do Arduino. Assim, para o usuário, obtemos um valor na faixa de 0 a 1024 (ADC de 10 bits). A orientação diferente produz um valor analógico diferente para cada eixo, que é então mapeado para diferentes movimentos do robô.

O diagrama do circuito para o acelerômetro é:

Um código de teste para entender o funcionamento do ADXL335 é o seguinte:

  void setup () {pinMode (A0, INPUT); // eixo x está conectado a A0 pinMode (A1, INPUT); // o eixo y está conectado ao A1 pinMode (A2, INPUT); // eixo z está conectado a A2Serial.begin (9600); // Para imprimir dados no Monitor Serial} void loop () {Serial.print ("X ="); Serial.println (analogRead (A0)); Serial.print ("Y ="); Serial.println (analogRead (A1)); Serial.print ("Z ="); Serial.println (analogRead (A2)); atraso (1000);}

Você pode executar este programa para ver quais valores você obtém para a inclinação para frente, para trás, para a esquerda e para a direita da palma da mão e do pulso, que serão usados finalmente para controlar o robô.

2. Transmissor e receptor RF-433

A função do módulo RF é simples:transmitir dados de comando do pulso do Arduino Nano para o motor que controla o Arduino Uno. O módulo RF usa ondas de rádio na freqüência de 433 Hz e, portanto, o nome RF-433. Eles usam a Modulação de Amplitude para enviar dados, mas não entrando em muitos detalhes técnicos e mantendo as coisas simples, eles serão usados para transmitir comandos ao robô, ou seja:avançar, retroceder, direita ou esquerda. E no caso de não haver dados, fique parado. Eles funcionam bem em até 10 metros de alcance.

Agora, para entender como implementar o módulo RF em nosso projeto, vamos trabalhar nos circuitos transmissor e receptor sequencialmente.

Circuito do transmissor

O circuito do transmissor consiste em duas partes:o Transmissor RF e o Codificador HT12E. O Transmissor consiste em um pino de dados, uma antena, um terra e energia. É trabalho do codificador HT12E fornecer dados ao transmissor. O codificador consiste em 4 pinos de dados cujos dados podem ser enviados. Usaremos esses 4 pinos de dados para representar os quatro movimentos, um ALTO nesses pinos individualmente representará um dos quatro movimentos e um BAIXO em todos representa ficar parado.

O diagrama do circuito é como mostrado:

Os pinos do lado esquerdo (A0-A7) são os pinos de endereço e definem o par que irá trocar dados (o transmissor e o receptor tendo os mesmos endereços irão apenas compartilhar dados). Definiremos A0-A7 como BAIXO (aterrado).

Os pinos de entrada de dados são conectados aos pinos digitais do Arduino (neste projeto de 6 a 9) e eles produzirão os dados de comando como:

Comando Pino Digital (Quando ALTO)

9 para a frente

10 reverso

11 Esquerda

12 certo

Vamos digitalWrite os pinos digitais como HIGH com base na entrada de ADXL335 para executar o movimento necessário.

Circuito receptor

O circuito do receptor é completamente semelhante ao circuito do transmissor, conforme mostrado, mas em vez de pinos de dados indo como saída do Arduino, neste caso eles serão lidos como entradas para receber o comando do Arduino Uno e executar os motores conforme necessário:

Para simplificar, você pode conectar o LED em série no pino 17 com um resistor de 1K em vez do circuito complexo, como mostrado para indicar a conexão adequada com o transmissor.

3. PROTETOR DO MOTOR

A blindagem do motor é a parte mais fácil de manusear devido à disponibilidade da biblioteca Adafruit AFMotor, link:- https://github.com/adafruit/Adafruit-Motor-Shield-library

Baixe e copie a biblioteca na pasta de bibliotecas do Arduino para poder incluí-la no esboço do programa.

Um exemplo de biblioteca AFMotor é fornecido:

  #include  AF_DCMotor motor (4); // Conecte os fios do motor ao ponto Motor 4 na configuração do shieldvoid () {Serial.begin (9600); // configura a biblioteca serial em 9600 bps Serial.println ("Teste do motor!"); // liga o motor motor.setSpeed (200); motor.run (RELEASE);} void loop () {uint8_t i; Serial.print ("tick"); motor.run (FORWARD); para (i =0; i <255; i ++) {motor.setSpeed (i); atraso (10);} para (i =255; i! =0; i--) {motor.setSpeed (i); atraso (10);} Serial.print ("tock"); motor.run (PARA TRÁS); para (i =0; i <255; i ++) {motor.setSpeed (i); atraso (10);} para (i =255; i! =0; i--) {motor.setSpeed (i); atraso (10);} Serial.print ("tecnologia"); motor.run (RELEASE); atraso (1000);

4. Combinando tudo

A última e a parte final incluem combinar todas as partes acima para formar o robô completo que segue os comandos da mão!

Como a blindagem do motor usa quase todos os pinos digitais, usaremos os pinos analógicos do Arduino Uno para ler os dados do receptor. O diagrama de circuito final é o dado:

A blindagem do motor lida com as conexões aos motores. Conecte uma bateria de 9 V à entrada de energia da blindagem.

NOTA:Eu pessoalmente prefiro conectar 2 ou até mesmo 3,9 V baterias em paralelo à entrada de energia da blindagem para fornecer energia suficiente para operar todos os quatro motores. Eu conectei os quatro motores em um grupo de 2 (os mesmos motores são conectados em paralelo e, portanto, requerem apenas os pontos 3 e 4 do motor para funcionar).

O código final

Para Arduino Nano:

  int x_axis =0; int y_axis =0; int forward =9; int backward =10; int right =11; int left =12; void setup () {pinMode (A0, INPUT); // pinMode do eixo X (A3, OUTPUT); // pinMode do eixo Y (forward, OUTPUT); // HIGH para mover para frente pinMode (backward, OUTPUT); // HIGH para mover para trás pinMode (right, OUTPUT); // HIGH para mover para a direita pinMode (left, OUTPUT); // HIGH para mover para a esquerda Serial.begin (9600);} void loop () {x_axis =analogRead (A0); y_axis =analogRead (A3); Serial.print ("X ="); Serial.println (x_axis); Serial.print ("Y ="); Serial.println (eixo y); if (eixo y> =390) {Serial.println ("Avançar"); digitalWrite (para a frente, HIGH); } else {if (y_axis <=310) {Serial.println ("BACK"); digitalWrite (para trás, ALTO); } else {if (x_axis> =380) {Serial.println ("RIGHT"); digitalWrite (direita, ALTO); } else {if (x_axis <=320) {Serial.println ("LEFT"); digitalWrite (esquerda, ALTO); } Serial.println (""); }}} atraso (200); if (x_axis> 320 &&x_axis <380 &&y_axis> 310 &&y_axis <390) {digitalWrite (forward, LOW); digitalWrite (para trás, BAIXO); digitalWrite (direita, BAIXO); digitalWrite (esquerda, BAIXO); }}

Para Arduino Uno:

  #include  AF_DCMotor motor_right (3); AF_DCMotor motor_left (4); int forward =0; int backward =0; int right =0; int left =0; void setup () { pinMode (A2, INPUT); pinMode (A3, INPUT); pinMode (A4, INPUT); pinMode (A5, INPUT); Serial.begin (9600); motor_right.setSpeed (255); motor_left.setSpeed (255); motor_right.run (RELEASE); motor_left.run (RELEASE);} void loop () {forward =digitalRead (A0); para trás =digitalRead (A1); direita =leitura digital (A2); esquerda =leitura digital (A3); if (forward ==HIGH) {motor_right.run (FORWARD); motor_left.run (FORWARD); Serial.println ("Encaminhar"); } if (backward ==HIGH) {motor_right.run (BACKWARD); motor_left.run (BACKWARD); Serial.println ("Reverso"); } if (right ==HIGH) {motor_right.run (FORWARD); motor_left.run (RELEASE); Serial.println ("DIREITO"); } if (left ==HIGH) {motor_right.run (RELEASE); motor_left.run (FORWARD); Serial.println ("LEFT"); } if (left ==LOW &&right ==LOW &&forward ==LOW &&backward ==LOW) {motor_right.run (RELEASE); motor_left.run (RELEASE); } atraso (100);}

As fotos e vídeos estão aqui:

Câmera de rastreamento facial DCF77 Analyzer / Clock v2.0

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial