/*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) ;    }
}