Controlamos la TV o el centro musical con gestos.

/ * Control remoto deslizante

Este boceto utiliza un telémetro ultrasónico para determinar el gesto del usuario y envía una señal IR a un televisor Sony en función del comando dado.
- Deslizamiento alto (> 10 pulgadas) = ​​Canal arriba
- Deslizamiento bajo = Canal abajo
- Alta retención (> 10 pulgadas) = ​​Subir volumen
- Baja retención = Bajar volumen
- Sensor de cubierta (<3in) = Encender / Apagar

Creado por Dan Nicholson.

Este código de ejemplo está en el dominio público.

Este código usa la biblioteca IRremote (https://github.com/shirriff/Arduino-IRremote)

* /
#include 

// Define para funciones de control
#define CONTROL_CH 1 // Cambio de canal
#define CONTROL_VOL 2 // Volumen
#define CONTROL_POW 3 // Power

#define CONTROL_UP 1
#define CONTROL_DOWN -1

#define DIST_MAX 20 // Distancia máxima en pulgadas, todo lo anterior se ignora.
#define DIST_DOWN 10 // Umbral para los comandos arriba / abajo. Si es superior, el comando está "arriba". Si es inferior, "abajo".
#define DIST_POW 3 // Umbral para el comando de encendido, más bajo que = encendido / apagado

// PIN IR
const int irPin = 3; // esto se define en la biblioteca, esta var es solo un recordatorio. CAMBIAR ESTO NO CAMBIARÁ EL PIN EN LA BIBLIOTECA
// Sensor de ping de 2 pines
const int pingPin = 8;
const int echoPin = 7;
// Pines LED de confirmación
const int led = 13; // LED interno para depuración arriba / abajo
const int ledR = 11;
const int ledG = 10;
const int ledB = 9;
// LED en temporizador
temporizador largo sin signo;
// objeto transmisor IR
IRsend irsend;
// Indicador de confirmación de energía (necesita dos golpes para enviar la señal)
boolean powerConfirmed = false;

configuración nula () {
  // inicializa la comunicación serial y establece los pines
  Serial.begin (9600);
  pinMode (led, SALIDA);
  pinMode (ledR, OUTPUT);
  pinMode (ledG, OUTPUT);
  pinMode (ledB, OUTPUT);
  pinMode (pingPin, OUTPUT);
  pinMode (echoPin, INPUT);
  temporizador = millis ();
}

bucle vacío ()
{
 
// Serial.println (millis ());
  larga duración, pulgadas;
  valor int;

  // Verificar una lectura
  duración = doPing ();
 
  // Temporizador para confirmar acciones (actualmente solo energía)
  if (temporizador && timer <(millis () - 5000) && (millis ()> 5000))
  {
    Serial.println ("reinicio del temporizador");
    temporizador = falso;
  }

   digitalWrite (led, BAJO);
   setColor (0, 0, 0); // apagado

 
  // convierte el tiempo en una distancia
  pulgadas = microsegundos a pulgadas (duración);

  // Si está a menos de un máximo de pulgadas de distancia, actúa
  if (pulgadas  DIST_MAX)
      {
        doIR (CONTROL_CH, valor); // deslizar
      }
      otra cosa
      {
        // volumen
        int d = 500; // primer retraso es más largo para el cambio de volumen único
        // repite hasta que se quite la mano
        while (pulgadas  DIST_DOWN)
  {
    digitalWrite (led, ALTO);
    volver CONTROL_UP;
  }
  otra cosa
  {
    digitalWrite (led, BAJO);
    volver CONTROL_DOWN;
  }
}

/ *
* Disparar código IR correcto
* /
anir doIR (int control, int val)
{
  interruptor (control)
  {
  caso CONTROL_POW:
    // poder
    Serial.println ("encendido / apagado 0xa90");
    para (int i = 0; i <3; i ++)
    {
      setColor (255, 0, 0);
      irsend.sendSony (0xa90, 12); // Código de alimentación de Sony TV
      retraso (40);
    }
    romper
  caso CONTROL_CH:
    setColor (0, 255, 0);
    // salida 'canal arriba / abajo' dependiendo de val
    if (val == CONTROL_UP)
    {
      digitalWrite (led, ALTO);
      para (int i = 0; i <3; i ++)
      {
        irsend.sendSony (0x90, 12);
        retraso (40);
      }
      Serial.println ("canal hasta 0xD00A");
    }
    más // abajo
    {
      para (int i = 0; i <3; i ++)
      {
        irsend.sendSony (0x890, 12);
        retraso (40);
      }
      Serial.println ("canal inactivo 0x3002");
    }
    romper
  caso CONTROL_VOL:
    setColor (0, 0, 255);
    // salida 'volumen arriba / abajo' dependiendo de val
    if (val == CONTROL_UP)
    {
      digitalWrite (led, ALTO);
      para (int i = 0; i <3; i ++)
      {
        irsend.sendSony (0x490, 12);
        retraso (40);
      }
      Serial.println ("subir volumen 0x490");
    }
    más // abajo
    {
      para (int i = 0; i <3; i ++)
      {
        irsend.sendSony (0xC90, 12);
        retraso (40);
      }
      Serial.println ("bajar volumen 0xC90");
    }
    romper
  }
}
setColor vacío (int rojo, int verde, int azul)
{
  analogWrite (ledR, rojo);
  analogWrite (ledG, verde);
  analogWrite (ledB, azul);
}

DoPing largo ()
{
  digitalWrite (pingPin, LOW);
  delayMicroseconds (2);
  digitalWrite (pingPin, HIGH);
  delayMicroseconds (5);
  digitalWrite (pingPin, LOW);
  return pulseIn (echoPin, HIGH);
}

microsegundos largos a pulgadas (microsegundos largos)
{
  // Según la hoja de datos de Parallax para el PING))), hay
  // 73.746 microsegundos por pulgada (es decir, el sonido viaja a 1130 pies por
  // segundo). Esto da la distancia recorrida por el ping, saliente
  // y regresamos, entonces dividimos por 2 para obtener la distancia del obstáculo.
  // Ver: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
  retorno microsegundos / 74/2;
}

microsegundos largos a centímetros (microsegundos largos)
{
  // La velocidad del sonido es 340 m / so 29 microsegundos por centímetro.
  // El ping viaja de ida y vuelta, así que para encontrar la distancia del
  // objeto tomamos la mitad de la distancia recorrida.
  retorno microsegundos / 29/2;
}