Télécommande 100 canaux

Nombre de visites :
59
TÉLÉCOMMANDE INFRAROUGE 100 CANAUX
 
PROJET

Télécommande à 3 digits pour envoyer jusqu'à 7 types d'ordres

(ON/OFF, impulsion plus ou moins longue, extinction globale...)

à 100 accessoires au maximum.

OBJECTIF
 
  • pouvoir commander par télécommande infrarouge, un nombre important d'accessoires sur un réseau de trains miniatures, en particulier l'éclairage des bâtiments, le déclenchement de séquences sonores et même, pourquoi pas, l'éclairage d'ambiance du réseau ;
     
  • faire tout cela pour un coût minimal ;
     
  • ... avec du matériel aisément disponible dans le commerce ;
     
  • disposer d'un système extensible ;
     
  • disposer d'un système  adaptable et facilement transmissible à d'autres camarades de clubs.
 

L'ESSENTIEL


Non aux pupitres encombrants, très coûteux et difficilement modifiables !
Non aux câblages, gros consommateurs de fils, de connecteurs divers et de colliers de fixations !


La base du système de télécommande :
  • une carte ARDUINO UNO ou NANO ou MICRO comme récepteur/actionneur ;
  • un boitier de télécommande universel pour téléviseur SONY (1).
    (on trouve sur ebay à partir de 3 $ des télécommande capables de générer les codes SONY TV ).

Caractéristiques / performances :
  • un seul boitier de télécommande pour commander jusqu'à 10 récepteurs ARDUINO ;
  • 10 canaux (sorties) « HIGH » ou « LOW » par carte ARDUINO (2) ;
    (ce qui nous donne un total de 100 canaux ON / OFF).
  • chaque sortie de chaque récepteur ARDUINO peut être utilisée directement (allumage de LED par exemple) ou pour commander d'autres ensembles électroniques spécialisés (feux de camp, aiguillages, maison vivante...) ;
  • possibilité d'utiliser plusieurs boîtiers de télécommande simultanément, pour « jouer » à plusieurs.


Note :

Ce projet de télécommande est transposable sur PICAXE avec BLOCKLY PE6. Essais en cours...
 
FONCTIONNEMENT / MODE D'EMPLOI

Télécommande à 3 digits pour envoyer jusqu'à 7 types d'ordres

(ON/OFF, impulsion plus ou moins longue, extinction globale...)

à 100 accessoires au maximum.

LE CODAGE

Le challenge consiste à commander un total de 100 canaux.


Pour cela j'ai pris le parti d'utiliser un code à 3 digits :
  • premier_digit : il caractérise le récepteur ARDUINO auquel s'adresse la commande ;
  • deuxieme_digit : il désigne le canal – càd la sortie – qu'on actionne sur cet ARDUINO ;
  • troisieme_digit : il désigne l'action pour cette sortie.
À part une exception décrite plus bas, on n'utilise QUE les 10 touches du pavé numérique et la touche « POWER ».

C'est ce qui permet d'utiliser n'importe quelle télécommande qui délivre des codes SONY TV.


premier_digit

Il prend les valeurs 0 à 9, soit la possibilité de dialoguer avec 10 récepteurs ARDUINO.

Pour chaque récepteur ARDUINO il faudra donc paramétrer la variable « Cet_ARDUINO » avant de téléverser le programme.

On donne à la variable « Cet_ARDUINO » une valeur comprise entre 0 et 90, c'est-à-dire (digit_1 x 10) qui correspond en fait au numéro du premier canal du récepteur concerné.

 
deuxieme_digit
 
Note :
Il n'y a pas d'accent sur le « e » de « ... xieme » : c'est le nom de la variable).

Il prend les valeurs 0 à 9, soit la possibilité de commander 10 sorties sur un ARDUINO.

On pourrait envisager de commander 4 ou 6 sorties de plus en utilisant les flèches de directions et les touches « Programme + » et « Programme – ».
Ces touches sont présentes sur toutes les télécommandes.


troisieme_digit

Il caractérise l'action sur la sortie concernée.
Il peut prendre théoriquement les valeurs 0 à 9.

Ces possibilités ne sont pas toutes utilisées.
  • « 0 » ⇒ la sortie est mise à l'état « LOW » ;
  • « 1 » ⇒ la sortie est mise à l'état « HIGH » ;
  • « 2 » ⇒ la sortie fournit une impulsion de 1 seconde (on peut décider de programmer une autre valeur, et cela pour chaque récepteur) ;
  • « 3 » ⇒ la sortie fournit une impulsion de 2 secondes (d°) ;
  • « 4 » ⇒ la sortie fournit une impulsion de 100 millisecondes (d°) ;
  • « 8 » ⇒ mise à l'état « HIGH » des 10 canaux (sorties) simultanément de l'ARDUINO concerné (tout allumer) ;
  • « 9 » ⇒ mise à l'état « LOW » des 10 canaux (sorties) simultanément de l'ARDUINO concerné (tout éteindre) ;
Les autres codes sont en réserve.


CODE « 999 »

Le code « 999 » provoque la mise à l'état « LOW » de TOUS les CANAUX, c'est-à-dire de toutes les sorties de tous les récepteurs en fonctionnement.



Touche « POWER »

L'appui sur cette touche annule la saisie en cours et remet le récepteur dans son état d'attente de la réception du premier digit.

Cette possibilité est née du fait que nous n'avons aucun retour d'information sur le code saisi.
Seule l'observation du résultat « sur le terrain » nous dit si la commande a bien été exécutée.

Or il arrive parfois qu'elle ne le soit pas :
  • soit parce que la distance entre l'émetteur et le récepteur est trop grande ⇒ un des code n'a pas été détecté correctement ;
  • soit parce qu'un obstacle s'est interposé entre l'émetteur et le récepteur.
Il se peut aussi qu'on désire simplement annuler la saisie en cours.


Touches « Son + » et « Son – »

Elles sont équivalentes aux touches numériques « 1 » et « 0 ».

 
MODE D'EMPLOI
 
  • « 521 » met à l'état « HIGH » le canal « 2 » du récepteur « 5 » ;
  • « 160 » met à l'état « LOW » le canal « 6 » du récepteur « 1 » ;
  • « 911 » met à l'état « HIGH » le canal « 1 » du récepteur « 9 » ;
  • « 34 & Son +» met à l'état « HIGH » le canal « 4 » du récepteur « 3 » (identique à «341») ;
  • « 52 & Son – » met à l'état « LOW » le canal « 2 » du récepteur « 5 » (identique à «520») ;
  • « 712 » génère une impulsion de 1 seconde sur la sortie « 1 » du récepteur « 7 » ;
  • « 224 » génère une impulsion de 100 millisecondes sur la sortie « 2 » du récepteur « 2 » ;
  • « 408 » met à l'état « HIGH » les 10 canaux du récepteur « 4 » ;
  • « 438 » aussi : le deuxième digit n'a pas d'importance ;
  • « 469 » met à l'état « LOW » les 10 canaux du récepteur « 4 » ;
  • « 439 » aussi : le deuxième digit n'a pas d'importance ;
  • « 999 » met à l'état « LOW » tous les canaux de tous les récepteurs ;
  • «  84 & POWER» interrompt la saisie en cours ;
  • «  8 & POWER» aussi ;
  • « POWER » toute seule force tous les récepteurs à se remettre en état d'attente de la réception du premier digit.


 
REMARQUE


x 10 récepteurs ;
x 10 canaux par récepteur ;
x 7 commandes différentes ;
=
x 700 possibilités pour un total de 100 canaux ;


Si on envisageait d'utiliser 16 canaux par récepteur (possibilité maximale de la carte UNO) et 10 codes de sorties, le nombre de possibilités s'établirait à 1600 !

Est-ce bien raisonnable ?


En fait, on sait très bien qu'on n'utilisera qu'une infime partie des 700 possibilités et des 100 canaux possibles.
 
LE MATÉRIEL
  • une carte ARDUINO (NANO ou MICRO) (environ 4 €) ;

  • un module récepteur infrarouge pour ARDUINO (KY-022 TSOP 1838 - 37,9 kHz) (inférieur à 1 €) ; 

  • ... ou un récepteur IR TL1838 (environ 0,10 €) ;

  • un boitier de télécommande capable d'émettre les codes SONY TV (de 3 à 15 €).
    Celui qui est représenté ci-contre et ci-dessous vaut moins de 3 €.

Note 1 :

Il faudra une carte ARDUINO par tranche de 10 canaux.

Le prix d'un ensemble pour 10 canaux s'établit à environ 8 à 20 €, suivant le boitier manuel de télécommande utilisé.

Pour 100 canaux, ajouter 40 € pour les cartes ARDUINO supplémentaires.

Note 2 :

Les récepteurs de télécommande ARDUINO délivrent en sortie des informations soit « HIGH » ou « LOW », soit permanentes, soit impulsionnelles.
Si on veut par exemple commander l'éclairage d'un bâtiment avec l'application « Maison vivante », on utilisera une des sorties d'un récepteur pour commander une autre carte ARDUINO qui, elle, contient l'application «Maison vivante».
 
 
 
 
 
 

Ah ! Ça me plait bien.
On va faire du multiprocesseur !
Mieux que mon premier PC !
 
LE PROGRAMME C++

VERSION #2.0

Testée ⇒ OK

/*TELECOMMANDE 100 CANAUX
 * 
 * Hubert SPERI 2019
 * 
 * MODE D'EMPLOI
 * 
 * Cette applicdation utilise les codes SONY TV
 * Actuellement, seuls sont utilisés les codes 0 à 9 et Son+ / Son-
 * 
 * Un récepteur ARDUINO disposera de 10 canaux avec chaque fois l'option ON et l'option OFF.
 * 
 * Pour cela, dans la ligne " int Cet_ARDUINO = Canaux_50a59 ; // <<< CANAUX pour CET ARDUINO "
 * il faut changer "Canaux_50a59" par une des 9 autres options.
 * Ainsi chaque ARDUINO sera "réceptif" aux 10 canaux qui lui sont attribués.
 * 
 * Le boitier de télécommande manuelle, lui, pourra ainsi commander un maximum de 10 récepteurs ARDUINO
 * 
 * >>> LES CODES:
 * 
 * Un code est constitué de 3 digits :
 *    - 1 digit pour le code de l'ARDUINO récepteur (0 à 9) ; 
 *    - 1 digit pour le numéro du canal (10 canaux de 0 à 9) ;
 *    - 1 digit qui prend soit la valeur "1" pour ON et la valeur "0" pour OFF.
 *    
 * Autres valeurs pour le troisième digit :   
 *    - "2" => génère une impulsion de 1 seconde ;
 *    - "3" => génère une impulsion de 2 secondes ;
 *    - "4" => génère une impulsion de 100 millisecondes ;
 *    - "8" => active en une seule fois tous les canaux pour le récepteur concerné ;
 *    - "9" => coupe tous les canaux pour le récepteur concerné ;
 *    
 * Les 10 sorties utilisées vont de la pin 3 à la pin 12 et sont numérotées de 0 à 9.  
 * (0 pour la pin 3 ; 9 pour la pin 12).
 * Les numéros des sorties doivent impérativement se suivre.
 *    
 * Ainsi le code 521 active la pin 5 (numero 2) de l'arduino n° 5.   
 * Le code 340 désactive la pin 7 (numero 4) de l'ARDUINO n° 3.
 * 
 * >>> Particularité
 * Il existe 1 code spécial : "999" pour éteindre tous les canaux de tous les récepteurs ;
 *    
 * >>> IMPORTANT
 * En cas d'appui prolongé sur une touche, le code du digit en question sera bien envoyé plusieurs fois 
 * à intervalle de 300 ms, mais ne sera pris en compte qu'une seule fois, au moment où on relâche la touche.
 * Donc un appui prolongé sur une touche ne provoque pas de faute de saisie.
 * 
 *>>>  RAZ
 * Il arrive parfois qu'on a mal tapé le code : on croit l'avoir fait et pourtant rien ne se passe.
 * Il arrive aussi qu'on désire ne pas poursuivre la saisie.
 * ==> un appui sur la touche "POWER" remet la saisie en cours à zero et le programme en bonne position
 * pour une nouvelle saisie.
 * 
 * 
 * >>> DEVELOPPEMENTS FUTURS (peut-être)
 * Cette application n'utilise que les touches numériques, Son+ et Son-, ainsi que la touche "POWER"
 * Ces touches sont présentes sur N'IMPORTE QUEL BOITIER de télécommande.
 * 
 * Avantage : n'importe quel boitier de télécommande SONY TV ou compatible peut faire l'affaire.
 * 
 * Cependant, d'autres touches sont présentes sur presque toutes les télécommandes et peuvent être utilisées.
 *    - c'est le cas des flèches droite / gauche / haut / bas.
 *    - c'est le cas aussi de la touche "OK", de la touche "Mute" et des touches "CH+ et "CH-".
 * 
 * Ces 8 touches pourront être utilisées pour compléter les fonctions actuelles.
 * 
 * >>> PARTICULARITE INTERESSANTE
 * 
 * Si on veut connaître le code SONY d'une touche, il suffit d'activer le moniteur série et de taper la touche inconnue.
 * => son code sera affiché.
 * Ainsi on découvrira que la touche CH+ a le code 144 et que la touche CH- a le code 2192
 * La touche "Mute" a le code 656
 * La touche OK a le code 2672 mais fonctionne différemment en cas d'appui prolongé d'une télécommande à l'autre.
 * On découvre aussi que les codes des flèches haut/bas/droite/gauche sont différents d'une télécommande à l'autre !
 * (et donc ne sont pas universels).
 *
 * 
 */


//  Include following libraries to access IR sensor
#include <IRremote.h>
#include <IRremoteInt.h>

int RECV_PIN = 2;          //  The digital pin that the signal pin of the sensor is connected to
int CODE = 0 ;
int CODE_1 = 0 ;
int CODE_2 = 0 ;
int CODE_3 = 0 ;
char cmd = "" ;
int CodeRAZ = 2704 ; // Touche "POWER"

int TempoTouches = 80 ;

int digit = 0 ;
int deuxieme_digit = 0 ;
int premier_digit = 0 ;
int troisieme_digit = 0 ;

int Code_compose = 0 ;
int NumeroCanal = 0 ;
int Code_ON_OFF = 0 ;

// x10 plages de canaux pour commander x9 ARDUINO différents.
      int Canaux_0a9   =  0 ;
      int Canaux_10a19 = 10 ; 
      int Canaux_20a29 = 20 ;
      int Canaux_30a39 = 30 ;
      int Canaux_40a49 = 40 ;
      int Canaux_50a59 = 50 ;
      int Canaux_60a69 = 60 ;
      int Canaux_70a79 = 70 ;
      int Canaux_80a89 = 80 ;
      int Canaux_90a99 = 90 ;
      
      int Cet_ARDUINO = Canaux_0a9 ; // <<< CANAUX pour CET ARDUINO


IRrecv receiver(RECV_PIN);  //  Create a new receiver object that would decode signals to key codes
decode_results results;     //  A variable that would be used by receiver to put the key code into
//-----------------------------------------------------------------------------

void setup() 
{
  pinMode(3, OUTPUT) ;
  pinMode(4, OUTPUT) ;
  pinMode(5, OUTPUT) ;
  pinMode(6, OUTPUT) ;
  pinMode(7, OUTPUT) ;
  pinMode(8, OUTPUT) ;
  pinMode(9, OUTPUT) ;
  pinMode(10, OUTPUT) ;
  pinMode(11, OUTPUT) ;
  pinMode(12, OUTPUT) ;
  
  Serial.begin(9600);       //  Setup serial port to send key codes to computer
  receiver.enableIRIn();    //  Enable receiver so that it would start processing infrared signals
}
//-----------------------------------------------------------------------------

void digit_1()
    {
    do
    {
    if(receiver.decode(&results)) // Lecture du premier digit
       {                                         
       CODE = results.value ;
       CODE_1 = CODE ;
         Serial.print("CODE_1 : ") ;
         Serial.println(CODE_1) ;
       delay(TempoTouches) ;
       receiver.resume();                        
       }
    } while (CODE == 0); 
    
    delay(100) ;
    
    do                              // Neutralise l'effet d'une répétition du premier digit
    {                               // en cas d'appui trop prolongé.
    CODE = 0 ;
    if(receiver.decode(&results)) 
       {                                         
       CODE = results.value ;
       CODE_1 = CODE ;
         Serial.print("CODE_1bis : ") ;
         Serial.println(CODE) ;
       receiver.resume(); 
       delay(TempoTouches) ;
       }    
      } while (CODE != 0) ;          // On passe à la lecture du digit suivant si et seulement si
                                     // le premier appui est relâché.
    CODE = CODE_1 ;                  // On rétablit le code "CODE" utilisé dans la table de conversion.
 
    table_conversion() ;
    premier_digit = digit ;          // on renseigne le premier digit.
    CODE = 0 ;
    }
//-----------------------------------------------------------------------------

void digit_2()
    {
    do
    {
    if(receiver.decode(&results)) 
       {                                         
       CODE = results.value ;
       CODE_2 = CODE ;
         Serial.print("CODE_2 : ") ;
         Serial.println(CODE_2) ;
       delay(TempoTouches) ;
       receiver.resume();                        
       }
    } while (CODE == 0); 
     
    delay(100) ;

    do
    {
    CODE = 0 ;
    if(receiver.decode(&results)) 
       {                                         
       CODE = results.value ;
         Serial.print("CODE_2bis : ") ;
         Serial.println(CODE) ;
       receiver.resume();                        
       delay(TempoTouches) ;
       }    
      } while (CODE != 0) ;  

    CODE = CODE_2 ;

    table_conversion() ;
    deuxieme_digit = digit ;
    CODE = 0 ;
    }
//-----------------------------------------------------------------------------

void digit_3()
    {
    do
    {
    if(receiver.decode(&results)) 
       {                                         
       CODE = results.value ;
       CODE_3 = CODE ;
         Serial.print("CODE_3 : ") ;
         Serial.println(CODE_3) ;
       delay(TempoTouches) ;
       receiver.resume();                        
       }
    } while (CODE == 0);
    
    delay(100) ;

    do
    {
    CODE = 0 ;
    if(receiver.decode(&results)) 
       {                                         
       CODE = results.value ;
         Serial.print("CODE_3bis : ") ;
         Serial.println(CODE) ;
       receiver.resume();                        
       delay(TempoTouches) ;
       }    
      } while (CODE != 0) ;  

    CODE = CODE_3 ;
      
    table_conversion() ;
    troisieme_digit = digit ;
    CODE = 0 ;
    }
//-----------------------------------------------------------------------------


void loop() 
{
  CODE=0 ;
  
  digit_1() ;
  if (CODE_1 != CodeRAZ) { digit_2() ;}
  if (CODE_1 != CodeRAZ && CODE_2 != CodeRAZ) { digit_3() ;}

  Code_compose = premier_digit * 100 + deuxieme_digit * 10 + troisieme_digit ;

        Serial.print("Code composé = ") ;
        Serial.println(Code_compose);
        Serial.println() ; 

  if( CODE_3 != CodeRAZ && CODE_2 != CodeRAZ && CODE_1 != CodeRAZ) { ACTIONS() ;}

CODE_1 = 0 ;
CODE_2 = 0 ;
CODE_3 = 0 ;
}
//-----------------------------------------------------------------------------

void table_conversion ()
{
    digit = 0 ;
    switch (CODE)
    {
    case 16:
      digit = 1 ;
      break;
    case 2064:
      digit = 2 ;
      break;
    case 1040:
      digit = 3 ;
      break;
    case 3088:
      digit = 4 ;
      break;
    case 528:
      digit = 5 ;
      break;
    case 2576:
      digit = 6 ;
      break;
    case 1552:
      digit = 7 ;
      break;
    case 3600:
      digit = 8 ;
      break;
    case 272:
      digit = 9 ;
      break;
    case 2320:
      digit = 0 ;
      break;
    case 1168:
      digit = 1 ; //touche SON +
      break;
    case 3216:
      digit = 0 ; // Touche SON -
      break;
    case 2672:
      digit = 2 ; // Touche OK
      break;
    default:
      digit = 0 ;

    break;
     }
}    
//-----------------------------------------------------------------------------

void ACTIONS ()
    {      
      if (Code_compose == 999) {tout_eteindre() ; }
          
      int NumeroCanal = Code_compose / 10 ;
      int Code_ON_OFF = Code_compose % 10 ;
      int Code_Action = Code_compose % 10 ;
      int Canal_Choisi_de_Cet_ARDUINO = NumeroCanal - Cet_ARDUINO + 3 ;
      int Premiere_Sortie_de_Cet_ARDUINO = NumeroCanal/10*10 - Cet_ARDUINO + 3 ;
      
          
      Serial.print("ACTION - Numero canal = ") ;
      Serial.println(NumeroCanal) ; 
      Serial.print("Code ON-OFF = ") ;
      Serial.println(Code_ON_OFF) ;
      Serial.println() ; 


      switch( Code_ON_OFF)
         {
         case 0 :
         digitalWrite(Canal_Choisi_de_Cet_ARDUINO,LOW) ;        
         break ;

         case 1 :
         digitalWrite(Canal_Choisi_de_Cet_ARDUINO,HIGH) ;        
         break ;

         case 2 : // Impulsion de 1 seconde
         digitalWrite(Canal_Choisi_de_Cet_ARDUINO,HIGH) ; 
         delay(1000) ; 
         digitalWrite(Canal_Choisi_de_Cet_ARDUINO,LOW) ;        
         break ;
         
         case 3 : // Impulsion de 2 secondes
         digitalWrite(Canal_Choisi_de_Cet_ARDUINO,HIGH) ; 
         delay(2000) ; 
         digitalWrite(Canal_Choisi_de_Cet_ARDUINO,LOW) ;        
         break ;
 
         case 4 : // Impulsion de 100 millisecondes
         digitalWrite(Canal_Choisi_de_Cet_ARDUINO,HIGH) ;
         delay(100) ; 
         digitalWrite(Canal_Choisi_de_Cet_ARDUINO,LOW) ;        
         break ;

         case 5 :
         digitalWrite(Canal_Choisi_de_Cet_ARDUINO,HIGH) ;        
         break ;                 

         case 6 :
         digitalWrite(Canal_Choisi_de_Cet_ARDUINO,HIGH) ;        
         break ;

         case 7 :
         digitalWrite(Canal_Choisi_de_Cet_ARDUINO,HIGH) ;        
         break ;
                           
         case 8 :  // Activer les 10 canaux de ce récepteur ARDUINO
         for(int x = 0 ; x < 10 ; x++) {digitalWrite ((Premiere_Sortie_de_Cet_ARDUINO + x),HIGH) ;    }
         break ;

         case 9 :  // Désactiver les 10 canaux de ce récepteur ARDUINO
         for(int x = 0 ; x < 10 ; x++) {digitalWrite ((Premiere_Sortie_de_Cet_ARDUINO + x),LOW) ;    }
         break ;
                  
         defaults :
         //digitalWrite(NumeroCanal - Cet_ARDUINO - 7,LOW) ;
         break ;
         }     
   } 
//-----------------------------------------------------------------------------
void tout_eteindre()
{
for(int x = 3 ; x < 13 ; x++) {digitalWrite (x,LOW) ;    }
}
//-----------------------------------------------------------------------------

void tout_allumer()
{
for(int x = 3 ; x < 13 ; x++) {digitalWrite (x,HIGH) ;    }
}
 

 

 

© 2020 par Hubert SPERI – Créé avec Wix.com

WIX.png

Ce site ne contient aucun fichier avec des données personnelles et ne stocke aucune donnée personnelle lorsqu'on se connecte.

INYO_3.png
This site was designed with the
.com
website builder. Create your website today.
Start Now