février 23

Domotique avec Google Home, Teensy et Blynk

Mon projet domotique 2017. Le but étant de piloter les télécommandes infra-rouge (Freebox, ampli 5.1, switch HDMI…), les lampes de la maison (via des prises commandés en 433mhz) et un ruban LED multicolors via mon Google Home (et aussi IFTTT et Blynk).
Tout le montage rentre dans un bocal translucide de chez Ikea.

Le tout consomme 1.7 Watts au repos et 6.5 Watts avec une couleur allumé.

 

Pré-requis

Composants :

  • Régulateur 3.3volts LD1117v33
  • Teensy 3.2
  • ESP01 (WiFi)
  • XY-FST-433 (RX433)
  • SFH4346 (LED infra-rouge)
  • WS2812 (ruban LED)
  • Condensateur 1000 uF/25V
  • Transfo 5 Volts /2A
  • Éventuellement, un relais 220V/RX433

Le Principe

IFTTT reçoit les commandes du Google Home (trigger) et l’envoie une URL (WebHook) sur le serveur Blynk.
Celui-ci est connecté au Teensy via le ESP01 et déclenche des actions via le code Arduino.

On dit : Allume et un mot clé (tout, un, deux, Freebox…), le code Arduino contient des IF qui réagissent aux mot clés indiqués et envoie les codes infra-rouge ou 433mhz.

Le code Arduino

/*URL pour webhook IFTTT (passé en GET)  
 * https://ipduserveurblynk:9443/tokenblynk/update/v2?value={{TextField}}
 * avec le navigateur
 * https://ipduserveurblynk:9443/tokenblynk/update/v0?value=MotClé 
 * 
 * A base de Teensy 3.2
 * 2017 - Par Pit Wyman
 */
 
#define ESP8266_BAUD vitesse
#include <SoftwareSerial.h>
#define HWSERIAL Serial1 //pin RX1=0, TX1=1 du TeensyLC, Teensy 3.2

//RX433
#include <RCSwitch.h>
RCSwitch mySwitch = RCSwitch();
int PinRX433 = 10; //pin Arduino/Teensy du module RX433

//Blynk
#define BLYNK_PRINT Serial //pour afficher les infos de connexion Wifi et Blynk  
#include <BlynkSimpleShieldEsp8266.h>

//ESP10
#include <ESP8266_Lib.h>
SoftwareSerial EspSerial(0, 1); // TX, RX de ESP10
ESP8266 wifi(&EspSerial);

//InfraRouge
/*
2 LED IR en série et Pas de résistance (avec certaines alims, ça envoie pas assez de jus)
Arduino Uno/Nano = pin 3
Teensy LC = 16
Tensy 3 à 3.6 = pin 5
*/
#include <IRremote.h>
//irrecv.blink13(true);// allume la LED interne du Teensy lors de l'envoie
IRsend irsend; //LED IR

//Ruban LED WS2812
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#define WS2812Data 16 // Pin de la broche data du WS2812

// nombre de LED du WS2812
#define NbLED 55
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NbLED, WS2812Data, NEO_GRB + NEO_KHZ800);

int vitesse = 9600;
char auth[] = "***"; //token Blynk
char ssid[] = "****"; // Nom WiFi
char pass[] = "*****"; // Clé WiFi

#define VERSION "MaDomotique - Fin 2017"

void setup() {/*******************************************/
  Serial.begin(vitesse);//moniteur serie
  pixels.begin(); // NeoPixel library.
 //transmission RX433
  mySwitch.enableTransmit(PinRX433);
  // Optional set pulse length. default 320
  //mySwitch.setPulseLength(280); 
  // Optional set protocol (default is 1, will work for most outlets)
  //mySwitch.setProtocol(1); 
  // Optional set number of transmission repetitions. defaut 15
  //mySwitch.setRepeatTransmit(15);

  EspSerial.begin(ESP8266_BAUD);
  delay(50);
  Blynk.begin(auth, wifi, ssid, pass, "192.168.0.30"); //IP du serveur local Blynk
  
ws2812 (0,NbLED, 0,0,0);//éteint
ws2812 (0,NbLED, 255,255,255);//allume
delay(200);
ws2812 (0,NbLED, 0,0,0);//éteint
}

/******************** Allumer/éteindre lampes, Freebox ou Ampli 5.1 ***********************************/

BLYNK_WRITE(V0){// Allume ***
String ValeurV0 = param.asStr();
Serial.print("allume : ");
Serial.println(ValeurV0);

ws2812 (0,8, 255,0,0);//controle
ws2812 (0,8, 0,0,0);
   
Blynk.virtualWrite(0,ValeurV0);//envoie la valeur sur display de Blynk
 
      if (ValeurV0 == "tout" or ValeurV0 == "tous" or ValeurV0 == "tu"){
      mySwitch.send(16762196, 24); //lampe 1
      delay(100);
      mySwitch.send(16765268, 24); //lampe 2
      delay(100);
      mySwitch.send(16766036, 24); //lampe 3 
      delay(100);
      mySwitch.send(16766228, 24); //étoile papier
      delay(100);
      ws2812 (0,NbLED, 255,0,0); //WS2812 en rouge
      }

  if (ValeurV0 == "première" || ValeurV0 == "un" || ValeurV0 == "1" || ValeurV0 == "hein"){
  mySwitch.send(16762196, 24); //lampe 1
  }

      if (ValeurV0 == "deuxième" || ValeurV0 == "deux" || ValeurV0 == "2" || ValeurV0 == "de"){
      mySwitch.send(16765268, 24); //lampe 2
      }

  if (ValeurV0 == "troisième" || ValeurV0 == "trois" || ValeurV0 == "3"){
  mySwitch.send(16766036, 24); //lampe 3 
  }

  if (ValeurV0 == "veilleuse" or ValeurV0 == "étoile"){
  mySwitch.send(16766228, 24); //étoile papier
  }

  if (ValeurV0 == "cuisine") {
  mySwitch.send(1975778, 24); //cuisine
  }

      if (ValeurV0 == "Freebox" or ValeurV0 == "télé" or ValeurV0 == "tele"){

      irsend.sendNEC(0xA55A38C7, 32);// InfraRouge - Ampli 5.1 sur ON (allume la télé via prise intélligente)
          
      irsend.sendNEC(0xFF20DF, 32);// InfraRouge - switch HDMI sur Freebox
      delay(40);
      irsend.sendNEC(0xFFFFFF, 32);
      delay(100);
         
      CommandeFreebox("power");// allume la Freebox
      delay(2000);// attendre 2 sec
      CommandeFreebox ("ok");// valider (sur bouton télévision)
      }

if (ValeurV0 == "ampli" or ValeurV0 == "l'ampli"){// Ampli 5.1
      irsend.sendNEC(0xA55A38C7, 32);
}

if (ValeurV0 == "blanc"){// Ruban LED
      ws2812 (0,NbLED, 255,255,255);
}
if (ValeurV0 == "rouge"){// Ruban LED
      ws2812 (0,NbLED, 255,0,0);
} 
if (ValeurV0 == "vert"){// Ruban LED
      ws2812 (0,NbLED, 0,255,0);
} 
if (ValeurV0 == "bleu"){// Ruban LED
      ws2812 (0,NbLED, 0,0,255);
}
if (ValeurV0 == "jaune"){// Ruban LED
      ws2812 (0,NbLED, 255,255,0);
}
if (ValeurV0 == "orange"){// Ruban LED
      ws2812 (0,NbLED, 255,127,0);
}
if (ValeurV0 == "violet"){// Ruban LED
      ws2812 (0,NbLED, 127,0,255);
}

}//V0

BLYNK_WRITE(V1){// éteint ***
String ValeurV1 = param.asStr();
Serial.print("éteint : ");
Serial.println(ValeurV1);

ws2812 (0,8, 255,0,0);//controle
ws2812 (0,8, 0,0,0);
 
  if (ValeurV1 == "tout" or ValeurV1 == "tous" or ValeurV1 == "tu"){
  mySwitch.send(16762193, 24); //lampe 1
  delay(100);
  mySwitch.send(16765265, 24); //lampe 2
  delay(100);
  mySwitch.send(16766033, 24); //lampe 3 
  delay(100); 
  mySwitch.send(16766225, 24); //étoile papier
  delay(100);
  ws2812 (0,NbLED, 0,0,0); //WS2812
  }
  
      if (ValeurV1 == "première" || ValeurV1 == "un" || ValeurV1 == "1" || ValeurV1 == "hein"){
      mySwitch.send(16762193, 24); //lampe 1
      }

  if (ValeurV1 == "deuxième" || ValeurV1 == "deux" || ValeurV1 == "2" || ValeurV1 == "de"){
  mySwitch.send(16765265, 24); //lampe 2
  delay(100);
  }

      if (ValeurV1 == "troisième" || ValeurV1 == "trois" || ValeurV1 == "3"){
      mySwitch.send(16766033, 24); //lampe 3 
      delay(100);
      }

  if (ValeurV1 == "veilleuse" or ValeurV1 == "étoile"){
  mySwitch.send(16766225, 24); //étoile papier
  }

  if (ValeurV1 == "cuisine"){
  mySwitch.send(1975778, 24); //cuisine
  }
  
  if (ValeurV1 == "Freebox" or ValeurV1 == "télé"){
  CommandeFreebox ("power");// éteint la Freebox

  //la télé est éteinte via l'ampli HDMI
  //irsend.sendNEC(0x2FD48B7, 32);// InfraRouge - TV Toshiba sur OFF
  //delay(40);
  //irsend.sendNEC(0xFFFFFF, 32);
  delay(100);
  irsend.sendNEC(0xA55A38C7, 32);// InfraRouge - Ampli 5.1 sur OFF 
  }
  
      if (ValeurV1 == "ampli" or ValeurV1 == "l'ampli"){// Ampli 5.1
      irsend.sendNEC(0xA55A38C7, 32);
      }
      
if (ValeurV1 == "blanc" or ValeurV1 == "rouge" or ValeurV1 == "vert" or ValeurV1 == "bleu" or ValeurV1 == "jaune" or ValeurV1 == "orange" or ValeurV1 == "violet"){// Ruban LED
      ws2812 (0,NbLED, 0,0,0);
} 

}//V1

/****************************************** Switch HDMI  - InfraRouge *********************************/
BLYNK_WRITE(V2){// HDMI ***
String ValeurV2 = param.asStr();
Serial.print("HDMI  : ");
Serial.println(ValeurV2);

if (ValeurV2 == "Freebox"){
      irsend.sendNEC(0xFF20DF, 32);
      delay(40);
      irsend.sendNEC(0xFFFFFF, 32); 
  }//if

  if (ValeurV2 == "Netflix"){
      irsend.sendNEC(0xFF10EF, 32);
      delay(40);
      irsend.sendNEC(0xFFFFFF, 32);
  }//if

  if (ValeurV2 == "Kodi" or ValeurV2 == "mediacenter" or ValeurV2 == "libreelec"){
      irsend.sendNEC(0xFF50AF, 32);
      delay(40);
      irsend.sendNEC(0xFFFFFF, 32);  
  }//if

}//V2

/************************************* Ampli 5.1  - InfraRouge ************************************/
BLYNK_WRITE(V3){// monte/augmente l'ampli de ***
int ValeurV3 = param.asInt();
Serial.print("monte le volume de : ");
Serial.println(ValeurV3);

ws2812 (8,8+ValeurV3, 255,0,0);//controle
ws2812 (8,8+ValeurV3, 0,0,0);

  if (ValeurV3){
  
for (int i=0; i <= ValeurV3*2; i++){
Serial.println(ValeurV3);  
irsend.sendNEC(0xA55A50AF, 32);
delay(40);  
}//for
  }//if
  
}//V3

BLYNK_WRITE(V4){// baisse/diminue l'ampli de ***
int ValeurV4 = param.asInt();
Serial.print("baisse le volume de : ");
Serial.println(ValeurV4); 

ws2812 (8,8+ValeurV4, 255,0,0);//controle
ws2812 (8,8+ValeurV4, 0,0,0);

   if (ValeurV4){
  
for (int i=0; i <= ValeurV4*2; i++)
{
Serial.println(ValeurV4);  
irsend.sendNEC(0xA55AD02F, 32);
delay(40);
}//for
  }//if
  
}//V4

BLYNK_WRITE(V5){// coupe/remet l'ampli
int ValeurV5 = param.asInt();

if (ValeurV5 == 1){
Serial.println(ValeurV5);  
irsend.sendNEC(0xA55A48B7, 32);
  }//if
  
}//V5

/***************************************** Chaines Freebox - Webhook ************************/

BLYNK_WRITE(V6){// Freebox/regarder ***
String ValeurV6 = param.asStr();
Serial.print("regarder : ");
Serial.println(ValeurV6);

//définition des chaines
if (ValeurV6=="Mosaïque" or ValeurV6=="mosaïque" or ValeurV6=="panel") {CommandeFreebox("0");}
if (ValeurV6 == "TF 1") {CommandeFreebox("1");}
if (ValeurV6 == "France 2") {CommandeFreebox("2");}
if (ValeurV6== "France 3") {CommandeFreebox("3");}
if (ValeurV6 == "Canal +" or ValeurV6=="Canal") {CommandeFreebox("4");}
if (ValeurV6 == "France 5") {CommandeFreebox("5");}
if (ValeurV6 == "M 6") {CommandeFreebox("6");}
if (ValeurV6=="Arte") {CommandeFreebox("7");}
if (ValeurV6=="C 8") {CommandeFreebox("8");}
if (ValeurV6=="W 9") {CommandeFreebox("9");}
//a partir de 2 chiffres, ça ne marche plus ?!?


if (ValeurV6=="pause") {CommandeFreebox("play");}
if (ValeurV6=="direct") {
CommandeFreebox("green");
delay(2000);
CommandeFreebox("ok");
}

if (ValeurV6=="programme") {CommandeFreebox("epg");}
if (ValeurV6=="menu") {CommandeFreebox("green");}
if (ValeurV6=="maison") {CommandeFreebox("home");}
if (ValeurV6=="ok") {CommandeFreebox("ok");}
if (ValeurV6=="haut") {CommandeFreebox("up");}
if (ValeurV6=="bas") {CommandeFreebox("down");}
if (ValeurV6=="droite") {CommandeFreebox("right");}
if (ValeurV6=="gauche") {CommandeFreebox("left");}

if (ValeurV6=="dvd"){
CommandeFreebox("home");
delay(2000);
CommandeFreebox("right");
delay(1000);
CommandeFreebox("right");
delay(1000);
CommandeFreebox("right");
delay(1000);
CommandeFreebox("ok");
}

if (ValeurV6=="TV"){
CommandeFreebox("home");
delay(2500);
CommandeFreebox("ok");
}

/*************************************** Regarder Freebox Netflix ou Kodi ***************************************/

if (ValeurV6 == "Freebox" or ValeurV6 == "télé"){
      irsend.sendNEC(0xFF20DF, 32);// InfraRouge - switch HDMI sur Freebox
      delay(40);
      irsend.sendNEC(0xFFFFFF, 32);
      //la télé est allumé via l'ampli HDMI
      //delay(100);
      //irsend.sendNEC(0x2FD48B7, 32);// InfraRouge - TV Toshiba sur ON
      //delay(40);
      //irsend.sendNEC(0xFFFFFF, 32);
      delay(100);
      irsend.sendNEC(0xA55A38C7, 32);// InfraRouge - Ampli 5.1 sur ON     
  
      CommandeFreebox("power");// allume la Freebox
      delay(2000);// attendre 2 sec
      CommandeFreebox ("ok");// valider (sur bouton télévision)
      }

if (ValeurV6 == "Netflix"){
      //Ampli (qui allume la télé)
      irsend.sendNEC(0xFF10EF, 32);
      delay(40);
      irsend.sendNEC(0xFFFFFF, 32);  
delay(100);
      //HDMI sur Netflix
      irsend.sendNEC(0xFF10EF, 32);
      delay(40);
      irsend.sendNEC(0xFFFFFF, 32); 
}
if (ValeurV6 == "Kodi"){
      //Ampli (qui allume la télé)
      irsend.sendNEC(0xFF10EF, 32);
      delay(40);
      irsend.sendNEC(0xFFFFFF, 32);  
delay(100);
      //HDMI sur Kodi
      irsend.sendNEC(0xFF50AF, 32);
      delay(40);
      irsend.sendNEC(0xFFFFFF, 32);
}

}//V6

/********************************************* couper les lumières et la télé ***********************/

BLYNK_WRITE(V7){// on va se coucher
int ValeurV7 = param.asInt();

if (ValeurV7){
// lumières
mySwitch.send(16762193, 24); //lampe 1
  delay(100);
  mySwitch.send(16765265, 24); //lampe 2
  delay(100);
  mySwitch.send(16766033, 24); //lampe 3 
  delay(100); 
  mySwitch.send(16766225, 24); //étoile papier
  delay(100);
  ws2812 (0,NbLED, 0,0,0); //WS2812

CommandeFreebox ("power");// éteint la Freebox

irsend.sendNEC(0xA55A38C7, 32);// éteint l'ampli (qui éteint la télé)    
}
  
}//V7

/****************************** Ruban LED WS 2812 via l'appli Blynk *****************************/

BLYNK_WRITE(V8){ //zeRGBa de Blynk (http://docs.blynk.cc/#widgets-controllers-zergba)
  
  int r = param[0].asInt(); //rouge
  int v = param[1].asInt(); //vert
  int b = param[2].asInt(); //bleu

ws2812 (0,NbLED, r,v,b);//WS2812

}//V8


void CommandeFreebox(String MotCle){ /************************************* Fonction envoie des codes Freebox **************************************/
// WebHook Blynk avec : http://hd1.freebox.fr/pub/remote_control?code=86700567&key=/pin/
//&key=<touche>&long=true
//&key=<touche>&repeat=<n>

Blynk.virtualWrite(10, MotCle);
}

void ws2812 (int debut, int fin, int rouge, int vert, int bleu) /************** Fonction d'affichage des LED du ruban WS2812 *****************************/
{
    for(int i=debut;i<=fin;i++){
    // position de la LED (0=1er), couleurs RVB (de 0 à 255)
    pixels.setPixelColor(i, pixels.Color(rouge,vert,bleu)); 
    pixels.show(); // update couleurs
  }  
}//WS2812


void loop() { /**************************** LOOP *************************/
Blynk.run();      
}//loop


Ce code sera évidement adapté pour votre cas. Pour le miens, lorsque mon ampli 5.1 s’allume, il commande une multiprise « intelligente » qui allume la télé, le caisson basse et autre.
Le seul truc que je n’ai pas pu faire c’est changer les chaines de la Freebox qui ont 2 chiffres. Même en testant une URL dédié à ça, pas moyen.

L’électronique

Je suis partie d’un Teensy 3.2, un Arduino Uno n’est pas suffisant en terme de puissance.

Un ESP01 relié l’ensemble au WiFi, le module RX4333 envoie les codes en 433 mhz. 2 LED infra-rouge relié en série envoient les codes infra-rouge.
Le ruban LED (WS2812) est aussi relié au 5 volts.

L’ensemble est alimenté via un transfo 5 volts, un régulateur 3.3 volts alimente le ESP01. Un condensateur de 1000 uF/25V stabilise la tension (et pour protéger le ruban LED).

Le montage

Les composants électroniques sont fixés sur une plaque et reliés entrent eux par le dessous. Simple mais suffisant.
Le ruban LED s’enroule autour des montants.

J’ai fais une armature avec mon imprimante 3D. Tout est juste emboité, un trou est prévu à la base pour mettre un connecteur pour le transfo.
L’ensemble est coiffé par un bocal (à sucre je crois) de chez Ikea.

Fichier 3D

IFTTT et Blynk

J’utilise aussi le WebHook de IFTTT pour envoyer les mots clés qui seront reçu par Blynk et le WebHook de Blynk pour envoyer du code sur Teensy.

EX : Envoie le mot clé (TextField) sur l’IP du serveur Blynk/LeTokenBlynk, sur la VirtualPin V0

Dans le code Arduino :

BLYNK_WRITE(V0)
String ValeurV0 = param.asStr() (si c’est un mot)
String ValeurV0 = param.asInt() (si c’est un chiffre)

 

source 01 

Catégorie : Electronique | Commenter
février 18

Récupérer les codes 433 mhz et infra-rouge d’une télécommande

Le but est d’afficher les codes des télécommandes du style commande de lampe, porte de garage et autre fonctionnant sous 433 mhz (RX433) mais aussi ceux des télécommandes infra-rouge de télévision au autre.

On pourra donc ensuite, grâce à une autre montage, envoyer ces codes et piloter n’importe quoi !

Le montage

Simple, un Arduino Nano, une diode réceptrice infra-rouge et un récepteur 433 mhz.

Le code Arduino

//InfraRouge
#include <IRremote.h>
int recvPin = 11; //pin Arduino pour récepteur InfraRouge (TOSP4838)
IRrecv irrecv(recvPin);

//RX433
#include <RCSwitch.h>
RCSwitch mySwitch = RCSwitch();
decode_results results;

void  setup ( )
{
  Serial.begin(9600);
  irrecv.enableIRIn();
  irrecv.blink13(true);//allume la LED interne lors de l'envoie InfraRouge
  mySwitch.enableReceive(0);  // Récepteur RX433 (XY-MK-5V) sur pin 2 de Arduino Uno et Nano
}

// affichage des codes InfraRouge
void  ircode (decode_results *results)
{
  // Panasonic
  if (results->decode_type == PANASONIC) {
    Serial.print(results->address, HEX);
    Serial.print(":");
  }
  Serial.print(results->value, HEX);
}//void

// afficahge des codes encodés
void  encoding (decode_results *results)
{
  switch (results->decode_type) {
    default:
    case UNKNOWN:      Serial.print("Inconnu");       break ;
    case NEC:          Serial.print("NEC");           break ;
    case SONY:         Serial.print("SONY");          break ;
    case RC5:          Serial.print("RC5");           break ;
    case RC6:          Serial.print("RC6");           break ;
    case DISH:         Serial.print("DISH");          break ;
    case SHARP:        Serial.print("SHARP");         break ;
    case JVC:          Serial.print("JVC");           break ;
    case SANYO:        Serial.print("SANYO");         break ;
    case MITSUBISHI:   Serial.print("MITSUBISHI");    break ;
    case SAMSUNG:      Serial.print("SAMSUNG");       break ;
    case LG:           Serial.print("LG");            break ;
    case WHYNTER:      Serial.print("WHYNTER");       break ;
    case AIWA_RC_T501: Serial.print("AIWA_RC_T501");  break ;
    case PANASONIC:    Serial.print("PANASONIC");     break ;
    case DENON:        Serial.print("Denon");         break ;
  }
}

// dump les résultats
void  dumpInfo (decode_results *results)
{
  // Check if the buffer overflowed
  if (results->overflow) {
    Serial.println("IR code too long. Edit IRremoteInt.h and increase RAWBUF");
    return;
  }

  // Show Encoding standard
  Serial.print("Encodage  : ");
  encoding(results);
  Serial.println("");

  // Show Code & length
  Serial.print("Code      : ");
  ircode(results);
  Serial.print(" (");
  Serial.print(results->bits, DEC);
  Serial.println(" bits)");
}

//structure
void  dumpRaw (decode_results *results)
{
  // Print Raw data
  Serial.print("Timing[");
  Serial.print(results->rawlen-1, DEC);
  Serial.println("]: ");

  for (int i = 1;  i < results->rawlen;  i++) {
    unsigned long  x = results->rawbuf[i] * USECPERTICK;
    if (!(i & 1)) {  // even
      Serial.print("-");
      if (x < 1000)  Serial.print(" ") ;
      if (x < 100)   Serial.print(" ") ;
      Serial.print(x, DEC);
    } else {  // odd
      Serial.print("     ");
      Serial.print("+");
      if (x < 1000)  Serial.print(" ") ;
      if (x < 100)   Serial.print(" ") ;
      Serial.print(x, DEC);
      if (i < results->rawlen-1) Serial.print(", "); //',' not needed for last one
    }
    if (!(i % 8))  Serial.println("");
  }
  Serial.println("");                    // Newline
}

//+=============================================================================
// Dump out the decode_results structure.
//
void  dumpCode (decode_results *results)
{
  // Start declaration
  Serial.print("unsigned int  ");          // variable type
  Serial.print("rawData[");                // array name
  Serial.print(results->rawlen - 1, DEC);  // array size
  Serial.print("] = {");                   // Start declaration

  // Dump data
  for (int i = 1;  i < results->rawlen;  i++) {
    Serial.print(results->rawbuf[i] * USECPERTICK, DEC);
    if ( i < results->rawlen-1 ) Serial.print(","); // ',' not needed on last one
    if (!(i & 1))  Serial.print(" ");
  }

  // End declaration
  Serial.print("};");  // 

  // Comment
  Serial.print("  // ");
  encoding(results);
  Serial.print(" ");
  ircode(results);

  // Newline
  Serial.println("");

  // Now dump "known" codes
  if (results->decode_type != UNKNOWN) {

    // Some protocols have an address
    if (results->decode_type == PANASONIC) {
      Serial.print("unsigned int  addr = 0x");
      Serial.print(results->address, HEX);
      Serial.println(";");
    }

    // All protocols have data
    Serial.print("unsigned int  data = 0x");
    Serial.print(results->value, HEX);
    Serial.println(";");
  }
}

void  loop ( )
/************************************************** InfraRouge ******************************************/
{
  decode_results  results;        // Somewhere to store the results

  if (irrecv.decode(&results)) {  // Grab an IR code
    dumpInfo(&results);           // Output the results
    dumpRaw(&results);            // Output the results in RAW format
    dumpCode(&results);           // Output the results as source code
    Serial.println("");           // Blank line between entries
    irrecv.resume();              // Prepare for the next value
  }
 /**************************************************** RX433 ********************************************/
 if (mySwitch.available()) 
  {  
    int value = mySwitch.getReceivedValue();
    Serial.println("RX433");
    
    if (value == 0) {
      Serial.print("Codage inconnu");
    } else 
    {
      Serial.print("Reçu ");
      Serial.print( mySwitch.getReceivedValue() );
      Serial.print(" / ");
      Serial.print( mySwitch.getReceivedBitlength() );
      Serial.print("bit ");
      Serial.print("Protocole: ");
      Serial.println( mySwitch.getReceivedProtocol() );
    }
    mySwitch.resetAvailable();
  }//RX433
  
}//loop

Codes infra-rouge

Il y a plusieurs protocoles :

Pour  Sony et  RC5/6, chque transmission doit être répétés 3 fois !
ATTENTION :
la librairie IRremote.h ne semble pas pouvoir envoyer des codes codés sur plus de 32bits.
Les RC6, 36 doivent donc êtres envoyer en raw, qui prennent plus de taille mémoire.
L’envoie des codes se fera avec la librairie IRremote.h
Exemple : (0x devant le code) et le nombre de bits
irsend.sendNEC(0xA55A38C7, 32);

Codes RX433

L’envoie se fera avec la librairie RCSwitch.h
Exemple
mySwitch.send(1975778, 24);
Catégorie : Teensy/Arduino | Commenter