Controle seu computador com gestos de mão usando Arduino

Recentemente, Laptops ou computadores controlados por gestos estão ficando muito famosos. Essa técnica é chamada Movimento de salto o que nos permite controlar certas funções em nosso computador / laptop, simplesmente acenando com a mão na frente dele. É muito legal e divertido fazê-lo, mas esses laptops têm preços muito altos. Portanto, neste projeto, vamos tentar construir nosso próprio Controle de gestos Laptop / Computador combinando o poder do Arduino e Python.

Usaremos dois  Sensores ultrassônicos  para determinar a posição da nossa mão e  controla um media player (VLC) com base na posição. Eu usei isso para demonstração, mas depois de entender o projeto, você pode fazer qualquer coisa alterando apenas algumas linhas de código e controlar seu aplicativo favorito da sua maneira favorita.

Pré-requisitos:

Já cobrimos alguns projetos que combinam o Arduino com o Python. Portanto, suponho que você já instalou o Python e sua biblioteca serial e experimentou com sucesso alguns projetos básicos, como o LED piscando. Caso contrário, não se preocupe, você pode voltar a este  tutorial sobre Controle de Arduino-Python  e se dê bem com ele. Portanto, verifique se você instalou a biblioteca Python e pyserial antes de continuar. 

Conceito por trás do projeto:

O conceito por trás do projeto é muito simples. Colocaremos dois sensores ultrassônicos (Ultrasonic) em cima do monitor e leremos a distância entre o monitor e a mão usando o Arduino. Com base nesse valor de distância, executaremos determinadas ações. Para executar ações em nosso computador, usamos a biblioteca Python pyautogui   Os comandos do Arduino são enviados ao computador através da porta serial (USB). Esses dados serão então lidos pelo python, que está sendo executado no computador e com base nos dados lidos, uma ação será executada.

Diagrama de circuito:

Para   controlar o PC com gestos com as mãos, basta conectar os dois sensores ultrassônicos ao Arduino. Sabemos que o sensor trabalha com 5V e, portanto, eles são alimentados pelo regulador de tensão do Arduino. O Arduino pode ser conectado ao PC / Laptop para alimentar o módulo e também para comunicação serial. Quando as conexões estiverem concluídas, coloque-as no monitor, como mostrado abaixo. Usei uma fita dupla face para colá-la no meu monitor, mas você pode usar sua própria criatividade. Depois de prendê-lo em um local, podemos prosseguir com a programação.

Programando seu Arduino:

O Arduino deve ser programado para ler a distância da mão do sensor. O   programa completo   é apresentado no final desta página; logo abaixo, eu expliquei o programa.

Ao ler o valor da distância, podemos chegar a determinadas ações a serem controladas com gestos; por exemplo, neste programa eu programei   5 ações   como uma demonstração.

Açao 1: Quando as duas mãos são colocadas diante do sensor a uma certa distância, o vídeo no VLC player deve ser reproduzido/pausado.

Açao 2: Quando a mão direita é colocada diante do sensor a uma certa distância, o vídeo deve avançar rapidamente um passo.

Açao 3: Quando a mão esquerda é colocada diante do sensor a uma certa distância, o vídeo deve retroceder um passo.

Açao 4: Quando a mão direita é colocada diante do sensor a uma distância específica e, em seguida, se movida em direção ao sensor, o vídeo deve avançar rapidamente e, se afastado, o vídeo deve retroceder.

Açao 5: Quando a mão esquerda é colocada diante do sensor a uma distância específica e, em seguida, se movida em direção ao sensor, o volume do vídeo deve aumentar e, se afastado, o volume diminui.

Vamos ver como o programa foi escrito para executar as ações acima.   Portanto, como todos os programas, começamos com a definição dos pinos de E/S  como mostrado abaixo. Os dois sensores estão conectados aos pinos digitais 2,3,4 e 5 e são alimentados por pinos de + 5V. Os pinos de gatilho são de saída e os pinos de eco são de entrada.

A comunicação serial entre Arduino e python ocorre a uma taxa de transmissão de 9600.

const int trigger1 = 2; //Pino de gatilho do 1º Sensor
const int echo1 = 3; //Pino de eco do 1º sensor
const int trigger2 = 4; //Pino de gatilho do 2º sensor
const int echo2 = 5;//Pino de eco do 2º sensor
void setup() {
Serial.begin(9600);

pinMode(trigger1, OUTPUT);
pinMode(echo1, INPUT);
pinMode(trigger2, OUTPUT);
pinMode(echo2, INPUT);
}

Precisamos  calcular a distância entre o sensor e a mão  cada vez antes de concluir qualquer ação. Portanto, temos que fazer isso várias vezes, o que significa que esse código deve ser usado como uma função. Escrevemos uma função chamada   Calcule_distância()   que nos retornará a distância entre o sensor e a mão.

/*###Função para calcular a distância###*/
void calculate_distance(int trigger, int echo)
{
digitalWrite(trigger, LOW);
delayMicroseconds(2);
digitalWrite(trigger, HIGH);
delayMicroseconds(10);
digitalWrite(trigger, LOW);

time_taken = pulseIn(echo, HIGH);
dist= time_taken*0.034/2;
if (dist>50)
dist = 50;
}

Dentro do nosso main  loop nós  verificamos o valor da distância e executamos as ações  mencionadas acima. Antes disso, usamos duas variáveis ​​ distL  e  distR  que é atualizado com o valor atual da distância.

calculate_distance(trigger1,echo1);
distL =dist; //obter distância do sensor esquerdo

calculate_distance(trigger2,echo2);
distR =dist; //obter distância do sensor certo

Como sabemos a distância entre os dois sensores, agora podemos compará-la com valores predefinidos e chegar a determinadas ações. Por exemplo, se as duas mãos estão posicionadas a uma distância de 40 mc, reproduzimos/pausamos o vídeo. Aqui a palavra “Play/Pause”   serão enviadas através da porta serial

if ((distL >40 && distR>40) && (distL <50 && distR<50)) //Detectar as duas mãos
{Serial.println("Play/Pause"); delay (500);}

Se a mão direita sozinha for colocada antes do módulo, avançaremos rapidamente o vídeo em uma etapa e, se for a mão esquerda, retrocederemos em uma etapa. Com base na ação, aqui a palavra  “Rewind” ou "Forward"  serão enviados através da porta serial

if ((distL >40 && distL<50) && (distR ==50)) //Detectar a mão esquerda
{Serial.println("Rewind"); delay (500);}

if ((distR >40 && distR<50) && (distL ==50)) //Detectar a mão direita
{Serial.println("Forward"); delay (500);}

Para controlar detalhadamente o volume e a faixa, usamos uma metodologia diferente, a fim de evitar falsos gatilhos. Para  controlar o volume  temos que colocar a mão esquerda aprox. A uma distância de 15 cm, você pode movê-lo em direção ao sensor para diminuir o volume e afastá-lo do sensor para aumentar o volume. O código para o mesmo é mostrado abaixo. Com base na ação, aqui a palavra "Vup" ou "Vdown" será enviado através da porta serial

//Bloquear à esquerda - modo de controle
if (distL>=13 && distL<=17)
{
  delay(100); //Tempo de espera da mão
  calculate_distance(trigger1,echo1);
  distL =dist;
  if (distL>=13 && distL<=17)
  {
    Serial.println("Left Locked");
    while(distL<=40)
    {
      calculate_distance(trigger1,echo1);
      distL =dist;
      if (distL<10) //Mão empurrada
      {Serial.println ("Vup"); delay (300);}
      if (distL>20) //Mão puxada para fora
      {Serial.println ("Vdown"); delay (300);}
    }
  }
}

Também podemos usar o mesmo método para o sensor do lado direito, para   controlar a trilha do vídeo. Ou seja, se movermos a mão direita em direção ao sensor, ele avançará rapidamente o filme e, se você o afastar do sensor, ele retrocederá o filme. Com base na ação, aqui a palavra "Rewind" ou "Forward" será enviado através da porta serial

Agora você pode ler o código completo do  completo para este PC controlado por gesto, fornecido no final da página  e tentar entendê-lo como um todo e copie-o para o seu IDE do Arduino.

Programando seu Python:

O programa python para este projeto é muito simples. Nós apenas precisamos estabelecer uma comunicação serial com o Arduino através da taxa de transmissão correta e, em seguida, executar algumas ações básicas do teclado. O primeiro passo com o python seria instalar o  pyautogui  módulo. Certifique-se de seguir esta etapa porque o programa  não funcionará sem o módulo pyautogui..

Instalando o módulo pyautogui para windows:

Siga as etapas abaixo para instalar pyautogui  para o Windows. Se você estiver usando outras plataformas, as etapas também serão mais ou menos semelhantes. Verifique se o computador/laptop está conectado à Internet e siga as etapas abaixo

Passo 1: Abra o prompt de comando do Windows e altere o diretório para a pasta em que você instalou o python. Por padrão, o comando deve ser

cd C:\Python27

Passo 2: Dentro do diretório python, use o comando python–m pip install–upgrade pip para atualizar seu pip. Pip é uma ferramenta em python que nos ajuda a instalar módulos python facilmente. Após a atualização deste módulo (conforme mostrado na figura abaixo), prossiga para a próxima etapa.

python –m pip install –upgrade pip

Passo 3: Use o comando“python–m pip install pyautogui” para instalar o módulo pyautogui. Quando o processo for bem-sucedido, você verá uma tela semelhante a esta abaixo.

python –m pip install –upgrade pip

Agora que o módulo pyautogui  e pyserial module instalado com sucesso com o python, podemos prosseguir com o programa python. O código python completo do  é fornecido no final do tutorial mas a explicação para o mesmo é a seguinte.

Vamos importar todos os três módulos necessários para este projeto. Eles são pyautogui, python serial e tempo.

import serial #Serial imported for Serial communication
import time #Required to use delay functions
import pyautogui

Em seguida, estabelecemos conexão com o Arduino através da porta COM. No meu computador, o Arduino está conectado à COM 18. Use o gerenciador de dispositivos para encontrar qual porta COM o seu Arduino está conectado e corrija a linha a seguir.

ArduinoSerial = serial.Serial('com18',9600) #Criar objeto de porta serial chamado arduinoSerialData
time.sleep(2) #aguarde 2 segundos para que a comunicação seja estabelecida

Dentro do loop infinito  while , ouvimos repetidamente a porta COM e  compare as palavras-chave com qualquer trabalho pré-desafiado e pressione o teclado adequadamente.

while 1:
    incoming = str (ArduinoSerial.readline()) #leia os dados seriais e imprima-os como linha
    print incoming
    
    if 'Play/Pause' in incoming:
        pyautogui.typewrite(['space'], 0.2)

    if 'Rewind' in incoming:
        pyautogui.hotkey('ctrl', 'left')  

    if 'Forward' in incoming:
        pyautogui.hotkey('ctrl', 'right') 

    if 'Vup' in incoming:
        pyautogui.hotkey('ctrl', 'down')
        
    if 'Vdown' in incoming:
        pyautogui.hotkey('ctrl', 'up')

Como você pode ver, para pressionar uma tecla, basta usar o comando “pyautogui.typewrite(['space'], 0.2)” que pressionará o espaço da tecla por 0.2s. Se você precisar de teclas de atalho como ctrl + S, poderá usar o comando hot key “pyautogui.hotkey('ctrl', 's')”.

Eu usei essas combinações porque elas funcionam no VLC media player. Você pode ajustá-las da maneira que desejar para criar seus próprios aplicativos. controlar qualquer coisa no computador com gestos.

Computador controlado por gestos em ação:

Faça as conexões conforme definido acima e faça o upload do código do Arduino na sua placa Arduino. Em seguida, use o script python abaixo e inicie o programa no seu laptop/computador.

Agora você pode reproduzir qualquer filme no seu computador usando o VLC media player e use sua mão para controlar o filme como mostrado no vídeo fornecido abaixo.

Espero que você tenha entendido o projeto e tenha gostado de brincar com ele. Esta é apenas uma demonstração e você pode usar sua criatividade para criar coisas muito mais legais controladas por gestos em torno disso. Deixe-me saber se isso foi útil e o que você criará usando isso na seção de comentários, e ficarei feliz em saber.

 

Código: 

Código do Arduino:

/*
 * Programa para controle de gestos VLC Player
 * Usando Python controlado
 */

const int trigger1 = 2; //Pino de gatilho do 1º Sensor
const int echo1 = 3; //Pino de eco do 1º sensor
const int trigger2 = 4; //Pino de acionamento do segundo sensor
const int echo2 = 5;//Pino de eco do 2º sensor

long time_taken;
int dist,distL,distR;

void setup() {
Serial.begin(9600); 
  
pinMode(trigger1, OUTPUT); 
pinMode(echo1, INPUT); 
pinMode(trigger2, OUTPUT); 
pinMode(echo2, INPUT); 
}

/*###Função para calcular a distância###*/
void calculate_distance(int trigger, int echo)
{
digitalWrite(trigger, LOW);
delayMicroseconds(2);
digitalWrite(trigger, HIGH);
delayMicroseconds(10);
digitalWrite(trigger, LOW);

time_taken = pulseIn(echo, HIGH);
dist= time_taken*0.034/2;
if (dist>50)
dist = 50;
}

void loop() { //infinite loopy
calculate_distance(trigger1,echo1);
distL =dist; //obter distância do sensor esquerdo

calculate_distance(trigger2,echo2);
distR =dist; //obter distância do sensor certo

//Comentários para debudding
/*Serial.print("L=");
Serial.println(distL);
Serial.print("R=");
Serial.println(distR);
*/

//Modos de pausa -Hold
if ((distL >40 && distR>40) && (distL <50 && distR<50)) //Detectar as duas mãos
{Serial.println("Play/Pause"); delay (500);}

calculate_distance(trigger1,echo1);
distL =dist;

calculate_distance(trigger2,echo2);
distR =dist;

//Modos de controle
//Bloquear à esquerda - modo de controle
if (distL>=13 && distL<=17)
{
  delay(100); //Tempo de espera da mão
  calculate_distance(trigger1,echo1);
  distL =dist;
  if (distL>=13 && distL<=17)
  {
    Serial.println("Left Locked");
    while(distL<=40)
    {
      calculate_distance(trigger1,echo1);
      distL =dist;
      if (distL<10) //Hand pushed in 
      {Serial.println ("Vup"); delay (300);}
      if (distL>20) //Hand pulled out
      {Serial.println ("Vdown"); delay (300);}
    }
  }
}

//Bloquear à direita - modo de controle
if (distR>=13 && distR<=17)
{
  delay(100); //Tempo de espera da mão
  calculate_distance(trigger2,echo2);
  distR =dist;
  if (distR>=13 && distR<=17)
  {
    Serial.println("Right Locked");
    while(distR<=40)
    {
      calculate_distance(trigger2,echo2);
      distR =dist;
      if (distR<10) //Mão direita empurrada
      {Serial.println ("Rewind"); delay (300);}
      if (distR>20) //Mão direita puxada
      {Serial.println ("Forward"); delay (300);}
  }
}
}

delay(200);
}

Código Python:

import serial #Serial imported for Serial communication
import time #Required to use delay functions
import pyautogui

ArduinoSerial = serial.Serial('com18',9600) #Criar objeto de porta serial chamado arduinoSerialData
time.sleep(2) #aguarde 2 segundos para que a comunicação seja estabelecida

while 1:
    incoming = str (ArduinoSerial.readline()) #leia os dados seriais e imprima-os como linha
    print incoming
    
    if 'Play/Pause' in incoming:
        pyautogui.typewrite(['space'], 0.2)

    if 'Rewind' in incoming:
        pyautogui.hotkey('ctrl', 'left')  

    if 'Forward' in incoming:
        pyautogui.hotkey('ctrl', 'right') 

    if 'Vup' in incoming:
        pyautogui.hotkey('ctrl', 'down')
        

    if 'Vdown' in incoming:
        pyautogui.hotkey('ctrl', 'up')

    incoming = "";