Télécommande TV à ultrasons et à commande gestuelle

Le code suivant doit être téléchargé sur l'Arduino.

/* Télécommande à glissement

Ce programme utilise un télémètre à ultrasons pour déterminer le geste de l'utilisateur et envoie un signal infrarouge à un téléviseur Sony en fonction de la commande donnée.
Balayez haut (> 25 cm) = Chaîne suivante
Balai bas = Chaîne vers le bas
Maintien prolongé (> 25 cm) = Augmenter le volume
- Maintien faible = Volume bas
- Capteur de couverture (< 7,6 cm) = Marche/Arrêt

Créé par Dan Nicholson.

Ce code d'exemple est dans le domaine public.

Ce code utilise la bibliothèque IRremote (https://github.com/shirriff/Arduino-IRremote)

*/
#include <IRremote.h>

// Définit les fonctions de contrôle
#define CONTROL_CH 1 // Changement de canal
#define CONTROL_VOL 2 // Volume
#define CONTROL_POW 3 // Puissance

#définir CONTROL_UP 1
#définir CONTROL_DOWN -1

#define DIST_MAX 20 // Distance maximale en pouces, toute valeur supérieure est ignorée.
#define DIST_DOWN 10 // Seuil pour les commandes de montée/descente. Si la valeur est supérieure, la commande est « montée ». Si elle est inférieure, la commande est « descente ».
#define DIST_POW 3 // Seuil de commande d'alimentation, inférieur à = mise sous/hors tension

// Broche IR
const int irPin = 3; // Cette valeur est définie dans la bibliothèque ; cette variable sert uniquement de rappel. La modifier n'aura aucun impact sur la broche définie dans la bibliothèque.
Capteur de ping à 2 broches
const int pingPin = 8;
const int echoPin = 7;
// Broches de la LED de confirmation
const int led = 13; // LED interne pour le débogage haut/bas
const int ledR = 11;
const int ledG = 10;
const int ledB = 9;
// Minuterie LED
non signé, long terme;
// Objet émetteur IR
IRsend irsend;
// Indicateur de confirmation de mise sous tension (nécessite deux glissements pour envoyer le signal)
booléen powerConfirmed = faux ;

void setup() {
// Initialisation de la communication série et configuration des broches
Série.début(9600);
pinMode(led, SORTIE);
pinMode(ledR, SORTIE);
pinMode(ledG, SORTIE);
pinMode(ledB, SORTIE);
pinMode(pingPin, SORTIE);
pinMode(echoPin, INPUT);
minuteur = millis();
}

boucle vide()
{

// Serial.println(millis());
longue durée, pouces;
valeur entière ;

// Vérifier la lecture
durée = doPing();

// Minuteur pour confirmer les actions (actuellement uniquement l'alimentation)
si (minuterie && minuterie < (millis() - 5000) && (millis() > 5000))
{
Serial.println("réinitialisation du minuteur");
minuteur = faux ;
}

digitalWrite(led, LOW);
setColor(0, 0, 0); // désactivé


// convertir le temps en distance
pouces = microsecondesToInches(durée);

// Si la distance est inférieure à la distance maximale en pouces, agissez
si (pouces < DIST_MAX)
{
// Sortie de débogage
Série.print(pouces);
Serial.println("dans");

// Si très proche, il s'agit d'un signal « d'alimentation ».
si (pouces < DIST_POW)
{
Série.println(timer);
// allumé ou éteint
si (minuterie)
{
faireIR(CONTROL_POW, 0);
minuteur = faux ;
delay(2000); // On ne souhaite pas envoyer ce message plus d'une fois. Délai de 2 secondes
}
autre
{
Serial.println("drapeau d'alimentation défini");
minuteur = millis();
définirCouleur(255,50,50);
délai(500);
}
}
sinon // est un volume ou un canal
{
// La distance détermine la direction de contrôle
valeur = handleDist(pouces);
// Attendez une demi-seconde
délai(300);
// Vérifiez à nouveau, la main a-t-elle disparu ?
si (microsecondesToInches(doPing()) > DIST_MAX)
{
doIR(CONTROL_CH, valeur); // glisser
}
autre
{
// volume
int d = 500; // Le premier délai est plus long pour une seule modification de volume
// répéter jusqu'à ce que la main soit retirée
tant que (pouces < DIST_MAX)
{
valeur = handleDist(pouces); // est-ce vers le haut ou vers le bas ?
doIR(CONTROL_VOL, valeur); // déclencher le signal IR
délai(d); // attendre
pouces = microsecondesToInches(doPing()); // vérifier à nouveau la main
d = 100 ; // les délais sont plus courts pour un réglage rapide du volume multiple
}
delay(500); // Ceci empêche tout changement de chaîne accidentel après un réglage du volume
}
}
}
delay(50); // Assez court pour détecter tous les balayages.
}
/*
* Si la distance est inférieure au seuil, indiquez « haut » et allumez la LED correspondante.
*/
int handleDist(int pouces)
{
si (pouces > DIST_DOWN)
{
digitalWrite(led, HIGH);
retourner CONTROL_UP;
}
autre
{
digitalWrite(led, LOW);
retourner CONTROL_DOWN;
}
}

/*
* Déclencher le code IR correct
*/
void doIR(int contrôle, int val)
{
interrupteur (commande)
{
cas CONTROL_POW :
// pouvoir
Serial.println("mise sous tension / hors tension 0xa90");
pour (int i = 0; i < 3; i++)
{
définirCouleur(255, 0, 0);
irsend.sendSony(0xa90, 12); // Code d'alimentation du téléviseur Sony
délai(40);
}
casser;
cas CONTROL_CH :
définirCouleur(0, 255, 0);
// Sortie « canal haut / bas » en fonction de la valeur
si (val == CONTROL_UP)
{
digitalWrite(led, HIGH);
pour (int i = 0; i < 3; i++)
{
irsend.sendSony(0x90, 12);
délai(40);
}
Serial.println("canal 0xD00A");
}
sinon // bas
{
pour (int i = 0; i < 3; i++)
{
irsend.sendSony(0x890, 12);
délai(40);
}
Serial.println("canal hors service 0x3002");
}
casser;
cas CONTROL_VOL :
définirCouleur(0, 0, 255);
// Afficher « augmenter/diminuer le volume » en fonction de la valeur
si (val == CONTROL_UP)
{
digitalWrite(led, HIGH);
pour (int i = 0; i < 3; i++)
{
irsend.sendSony(0x490, 12);
délai(40);
}
Serial.println("volume up 0x490");
}
sinon //vers le bas
{
pour (int i = 0; i < 3; i++)
{
irsend.sendSony(0xC90, 12);
délai(40);
}
Serial.println("volume vers le bas 0xC90");
}
casser;
}
}
void setColor(int rouge, int vert, int bleu)
{
analogWrite(ledR, rouge);
analogWrite(ledG, vert);
analogWrite(ledB, bleu);
}

long doPing()
{
digitalWrite(pingPin, BAS);
délaiMicrosecondes(2);
digitalWrite(pingPin, HIGH);
délaiMicrosecondes(5);
digitalWrite(pingPin, BAS);
retourner pulseIn(echoPin, HIGH);
}

conversion de microsecondes longues en pouces (microsecondes longues)
{
// Selon la fiche technique de Parallax pour le PING))), il existe
// 73,746 microsecondes par pouce (soit une vitesse de propagation du son de 1130 pieds par pouce)
// seconde). Cela donne la distance parcourue par le ping, en sortie.
// et retour, donc on divise par 2 pour obtenir la distance de l'obstacle.
// Voir : http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
renvoyer microsecondes / 74 / 2 ;
}

microsecondes longues à centimètres (microsecondes longues)
{
// La vitesse du son est de 340 m/s ou 29 microsecondes par centimètre.
Le ping effectue un aller-retour, donc pour trouver la distance de
// objet dont on prend la moitié de la distance parcourue.
renvoyer microsecondes / 29 / 2 ;
}

Étape 4 : Laissez-le tourner !

Commandes
Les commandes sont expliquées dans la vidéo et sont les suivantes :

Pouvoir
En passant le doigt sur le capteur à moins de 7,5 cm (3 pouces), la LED clignote en violet. Cela confirme qu'un signal d'allumage/extinction est prêt à être envoyé. Pour éviter d'éteindre accidentellement le téléviseur, le programme attend un second passage de doigt dans les 5 secondes suivant le premier pour confirmation. À ce moment-là, le signal est envoyé au téléviseur pour l'allumer ou l'éteindre.

Canal
Un glissement de doigt à moins de 25 cm du capteur (mais pas à moins de 7,5 cm) fera changer de canal. Un glissement entre 25 et 50 cm fera changer de canal.

Volume
Maintenir votre main à moins de 25 cm du capteur (mais pas à moins de 7,5 cm) diminuera le volume. Entre 25 et 50 cm, le volume augmentera. Le volume continuera de varier (à la hausse ou à la baisse) jusqu'à ce que vous retiriez votre main.