DTMF8870 combinaison à plusieurs touches

Bonjour je cherchais à faire une combinaison à plusieurs touches
avec un DTMF8870 .
j’ai cherché quelques jours et j’y suis arrivé.
Les 4 codes fonctionnent parfaitement .
La ou cela ce complique pour moi c’est pour faire le clignotement
pour la led11,j’ai laissé les lignes de codes dont je me suis servi
pour le faire mais je n’y arrive pas impossible de faire clignoter
la led11. :confused:
Merci de votre aide. :o

Je laisse le code en plusieurs fois.

  // indicateur d'interruption indiquant qu'une nouvelle
  // tonalité DTMF a été localisée 
  volatile  bool toneLoc = false ;
  
   // déclaration des compteurs
   
   int var1        ; //  n1
   int var2        ; //  n2
   int var3        ; //  n3
   int var4        ; //  n4
   int var5        ; //  n5
   int var6        ; //  n6
   int var7        ; //  n7
   int var8        ; //  n8
   int var9        ; //  n9
    
   int etat_out1  ;  
   int etat_out2  ;  
   int etat_out3  ;  
   int etat_out4  ;
   int etat_out5  ;
   int etat_out6  ;
   int etat_out7  ;
   int etat_out8  ;
   int etat_out9  ;

  // attribution des sorties << out >> aux broches ARDUINO
  // de 1 à 9 , rien n'y est raccordé ( sauf le 2 pour STD ).
   
   int  out1 =  0 ;
   int  out2 =  1 ;
   int  out3 =  3 ;
   int  out4 =  4 ;
   int  out5 =  5 ;
   int  out6 =  6 ;
   int  out7 =  7 ;
   int  out8 =  8 ;
   int  out9 =  9 ;
     
   int  out10 = 10  ;  // mise à zéro
     
   int  led11 = 11  ;  
   int  led12 = 12  ; 
   int  led13 = 13  ;
   int  ledA0 = A0  ; 
   int  ledA5 = A5  ; 
     
   int  etat_led11 ;  
   int  etat_led12 ;  
   int  etat_led13 ;
   int  etat_ledA0 ;  
   int  etat_ledA5 ; 
   
   unsigned long ms_precedente =    0 ;
   const long interval_clignot = 1000 ;
   //  pour le troisième type code.
   //  !!! mais ne fonctionne pas pour la fonction cligno

  void  setup ( )
  {
  // broche du DTMF 8870 de Q1 à Q4 raccordée sur l'arduino
  pinMode ( A4 , INPUT ) ;    // Q4 in
  pinMode ( A3 , INPUT ) ;    // Q3 in
  pinMode ( A2 , INPUT ) ;    // Q2 in
  pinMode ( A1 , INPUT ) ;    // Q1 in
  
  pinMode (  out1 , OUTPUT ) ;
  pinMode (  out2 , OUTPUT ) ;
  pinMode (  out3 , OUTPUT ) ;
  pinMode (  out4 , OUTPUT ) ;
  pinMode (  out5 , OUTPUT ) ;
  pinMode (  out6 , OUTPUT ) ;
  pinMode (  out7 , OUTPUT ) ;
  pinMode (  out8 , OUTPUT ) ;
  pinMode (  out9 , OUTPUT ) ;
  pinMode ( out10 , OUTPUT ) ;
  
  pinMode ( led11 , OUTPUT ) ;  
  pinMode ( led12 , OUTPUT ) ;  
  pinMode ( led13 , OUTPUT ) ;  
  pinMode ( ledA0 , OUTPUT ) ;  
  pinMode ( ledA5 , OUTPUT ) ;  
  
  // broche STD du DTMF 8870 raccordée sur 2 arduino.    
  attachInterrupt (digitalPinToInterrupt(2),newDTMF,RISING);
  }
  void loop ( ) 
  {
  // décode les données DTMF à l'arrivée des données
  if (toneLoc == true ) 
  {
  char keySymbol ;  // caractère décodé
    
  bool Q1 = digitalRead ( A1 ) ;    
  bool Q2 = digitalRead ( A2 ) ;  
  bool Q3 = digitalRead ( A3 ) ;  
  bool Q4 = digitalRead ( A4 ) ;  

   // combine les bits Q1..Q4 en un octet
  byte toneData =(0x00 | Q1 | (Q2 << 1 )| (Q3 << 2 )|(Q4 << 3 ));

  // décode le caractère DTMF
  keySymbol = dtmf_decode ( toneData ) ;

  // effacer le drapeau localisé pour attendre le prochain signal
  toneLoc = false ;
  } }
  // isr pour définir l'indicateur de données reçues lors d'une
  // interruption.
  void  newDTMF ( )
  {
  toneLoc = true ;
  }
  // convertit les données Q1..Q4 en caractère DTMF
  char  dtmf_decode ( byte recv_data )
  {
    switch (recv_data)
    {
    case   1 :    // touche tel : 1
    digitalWrite  ( out1 , HIGH ) ;
                            break ;
    case   2 :    // touche tel : 2
    digitalWrite  ( out2 , HIGH ) ;
                            break ;
    case   3 :    // touche tel : 3
    digitalWrite  ( out3 , HIGH ) ;
                            break ;
    case   4 :      // touche tel 4
    digitalWrite  ( out4 , HIGH ) ;
                            break ;
    case   5 :          // touche 5
    digitalWrite  ( out5 , HIGH ) ;
                            break ;
    case   6 :    // touche tel : 6
    digitalWrite  ( out6 , HIGH ) ;
                            break ;
    case   7 :    // touche tel : 7
    digitalWrite  ( out7 , HIGH ) ; 
                            break ; 
    case   8 :    // touche tel : 8
    digitalWrite  ( out8 , HIGH ) ;
                            break ;
    case   9 :    // touche tel : 9
    digitalWrite  ( out9 , HIGH ) ;
                            break ;
    case  10 :    // touche tel : 0
    digitalWrite ( out10 , HIGH ) ;
                            break ;
    // case  11 :    touche tel * ; 
    // case  12 :    touche tel # ; 
    }

Mettre les codes bout à bout tel que.

azerthuiop:
Bonjour je cherchais à faire une combinaison à plusieurs touches
avec un DTMF8870 .
j’ai cherché quelques jours et j’y suis arrivé.
Les 4 codes fonctionnent parfaitement .
La ou cela ce complique pour moi c’est pour faire le clignotement
pour la led11,j’ai laissé les lignes de codes dont je me suis servi
pour le faire mais je n’y arrive pas impossible de faire clignoter
la led11. :confused:
Merci de votre aide. :o

Je laisse le code en plusieurs fois.

  // indicateur d'interruption indiquant qu'une nouvelle

// tonalité DTMF a été localisée
 volatile  bool toneLoc = false ;
 
  // déclaration des compteurs
 
  int var1        ; //  n1
  int var2        ; //  n2
  int var3        ; //  n3
  int var4        ; //  n4
  int var5        ; //  n5
  int var6        ; //  n6
  int var7        ; //  n7
  int var8        ; //  n8
  int var9        ; //  n9
   
  int etat_out1  ;  
  int etat_out2  ;  
  int etat_out3  ;  
  int etat_out4  ;
  int etat_out5  ;
  int etat_out6  ;
  int etat_out7  ;
  int etat_out8  ;
  int etat_out9  ;

// attribution des sorties << out >> aux broches ARDUINO
 // de 1 à 9 , rien n’y est raccordé ( sauf le 2 pour STD ).
 
  int  out1 =  0 ;
  int  out2 =  1 ;
  int  out3 =  3 ;
  int  out4 =  4 ;
  int  out5 =  5 ;
  int  out6 =  6 ;
  int  out7 =  7 ;
  int  out8 =  8 ;
  int  out9 =  9 ;
   
  int  out10 = 10  ;  // mise à zéro
   
  int  led11 = 11  ;  
  int  led12 = 12  ;
  int  led13 = 13  ;
  int  ledA0 = A0  ;
  int  ledA5 = A5  ;
   
  int  etat_led11 ;  
  int  etat_led12 ;  
  int  etat_led13 ;
  int  etat_ledA0 ;  
  int  etat_ledA5 ;
 
  unsigned long ms_precedente =    0 ;
  const long interval_clignot = 1000 ;
  //  pour le troisième type code.
  //  !!! mais ne fonctionne pas pour la fonction cligno

void  setup ( )
 {
 // broche du DTMF 8870 de Q1 à Q4 raccordée sur l’arduino
 pinMode ( A4 , INPUT ) ;    // Q4 in
 pinMode ( A3 , INPUT ) ;    // Q3 in
 pinMode ( A2 , INPUT ) ;    // Q2 in
 pinMode ( A1 , INPUT ) ;    // Q1 in
 
 pinMode (  out1 , OUTPUT ) ;
 pinMode (  out2 , OUTPUT ) ;
 pinMode (  out3 , OUTPUT ) ;
 pinMode (  out4 , OUTPUT ) ;
 pinMode (  out5 , OUTPUT ) ;
 pinMode (  out6 , OUTPUT ) ;
 pinMode (  out7 , OUTPUT ) ;
 pinMode (  out8 , OUTPUT ) ;
 pinMode (  out9 , OUTPUT ) ;
 pinMode ( out10 , OUTPUT ) ;
 
 pinMode ( led11 , OUTPUT ) ;  
 pinMode ( led12 , OUTPUT ) ;  
 pinMode ( led13 , OUTPUT ) ;  
 pinMode ( ledA0 , OUTPUT ) ;  
 pinMode ( ledA5 , OUTPUT ) ;  
 
 // broche STD du DTMF 8870 raccordée sur 2 arduino.    
 attachInterrupt (digitalPinToInterrupt(2),newDTMF,RISING);
 }
 void loop ( )
 {
 // décode les données DTMF à l’arrivée des données
 if (toneLoc == true )
 {
 char keySymbol ;  // caractère décodé
   
 bool Q1 = digitalRead ( A1 ) ;    
 bool Q2 = digitalRead ( A2 ) ;  
 bool Q3 = digitalRead ( A3 ) ;  
 bool Q4 = digitalRead ( A4 ) ;

// combine les bits Q1…Q4 en un octet
 byte toneData =(0x00 | Q1 | (Q2 << 1 )| (Q3 << 2 )|(Q4 << 3 ));

// décode le caractère DTMF
 keySymbol = dtmf_decode ( toneData ) ;

// effacer le drapeau localisé pour attendre le prochain signal
 toneLoc = false ;
 } }
 // isr pour définir l’indicateur de données reçues lors d’une
 // interruption.
 void  newDTMF ( )
 {
 toneLoc = true ;
 }
 // convertit les données Q1…Q4 en caractère DTMF
 char  dtmf_decode ( byte recv_data )
 {
   switch (recv_data)
   {
   case   1 :    // touche tel : 1
   digitalWrite  ( out1 , HIGH ) ;
                           break ;
   case   2 :    // touche tel : 2
   digitalWrite  ( out2 , HIGH ) ;
                           break ;
   case   3 :    // touche tel : 3
   digitalWrite  ( out3 , HIGH ) ;
                           break ;
   case   4 :      // touche tel 4
   digitalWrite  ( out4 , HIGH ) ;
                           break ;
   case   5 :          // touche 5
   digitalWrite  ( out5 , HIGH ) ;
                           break ;
   case   6 :    // touche tel : 6
   digitalWrite  ( out6 , HIGH ) ;
                           break ;
   case   7 :    // touche tel : 7
   digitalWrite  ( out7 , HIGH ) ;
                           break ;
   case   8 :    // touche tel : 8
   digitalWrite  ( out8 , HIGH ) ;
                           break ;
   case   9 :    // touche tel : 9
   digitalWrite  ( out9 , HIGH ) ;
                           break ;
   case  10 :    // touche tel : 0
   digitalWrite ( out10 , HIGH ) ;
                           break ;
   // case  11 :    touche tel * ;
   // case  12 :    touche tel # ;
   }




Mettre les codes bout à bout tel que.

//=================quatrième type de code===================

// une fois que l’on a tapé les 3 codes , taper sur n’importe
// qu’elle touche du tel et ledA5 HIGH.
// donc pour ledA5 HIGH taper 1234 505050 609090 et un chiffre
// entre 0 et 9 ou * ou # et la ledA5 s’allume.
// je ne comprends pas trop car * et # non utilisé dans le
// switch mais ça fonctionne nickel .

etat_led13 = digitalRead ( led13 ) ;
etat_led12 = digitalRead ( led12 ) ;
etat_led11 = digitalRead ( led11 ) ;
if ( etat_led13 ,etat_led12 , etat_led11 == HIGH )
{ digitalWrite ( ledA5 , HIGH ) ; }

// j’ai essayé de mettre ce quatrième code à la fin mais cela
// ne fonctionnait pas donc je l’ai laissé ici.

//=====================premier type de code================

// c’est le code le moins pratique ( mais il fonctionne ) .

// << code de 1 à 9 >>

/* dans le choix de code on ne peut pas mettre 2 chiffres
identique ni 0 .
ici le code fait 4 chiffres .
l’ordre de saisie n’a pas d’importance pour allumée la led13
toutes les combinaisons de 1,2,3,4 l’allumeront.
désolé je n’ai pas trouvé mieux . */

if
// ici choisir le code que l’on veut .
( ( digitalRead ( out1 ) == HIGH ) &&
( digitalRead ( out2 ) == HIGH ) &&
( digitalRead ( out3 ) == HIGH ) &&
( digitalRead ( out4 ) == HIGH ) &&

( digitalRead ( out5 ) == LOW ) && // ligne 197
( digitalRead ( out6 ) == LOW ) &&
( digitalRead ( out7 ) == LOW ) &&
( digitalRead ( out8 ) == LOW ) &&
( digitalRead ( out9 ) == LOW ) )

{
/* une fois le code tapé la led13 passe à high mais il n’est
pas nécessaire de retapé le code entier pour l’éteindre,un
appui sur 1,2,3 ou 4 le fera .
MAIS !!! si on tape sur une touche au dela de 4 cela bloque
tout,il faut donc faire une mise à zéro (appui zéro tel)qui
éteindra la led13 et taper 1,2,3,4 pour l’allumer à nouveau */

// action << on off >>
etat_led13 = ! etat_led13 ;
digitalWrite ( led13 , etat_led13 ) ;
}

/on peut faire 5 codes car il nous restent 5 broches dispo
11 , 12 , 13 , A0 , A5. pour pouvoir gérer les 5 codes
en même temps mettre une bascule D montée en << on off >>
sur chaques sorties ou les mise à zéro pour passer de code
en code n’auront aucun effet car la bascule D est active
sur front montant .
/

//====================code de mise à zéro================

/l’action de mise à zéro est obligatoire pour le premier type
de code si on fait une erreur quand on tape le code la sortie
reste à HIGH et on ne peut plus refaire celui ci.
ex: si on tape 1,2,3,5 il faut faire une mise à zéro car le 5
bloque tout( il faut que le 5 soit à LOW voir ligne 197 ) .
/

if ( digitalRead ( out10 ) == HIGH )
{
digitalWrite ( out1 , LOW ) ;
digitalWrite ( out2 , LOW ) ;
digitalWrite ( out3 , LOW ) ;
digitalWrite ( out4 , LOW ) ;
digitalWrite ( out5 , LOW ) ;
digitalWrite ( out6 , LOW ) ;
digitalWrite ( out7 , LOW ) ;
digitalWrite ( out8 , LOW ) ;
digitalWrite ( out9 , LOW ) ;
digitalWrite ( out10 , LOW ) ;
}

dernière partie

  //=================deuxième type de code===================
 
   //    << code de plusieurs appuis de touches identique >>
  
  /*ici on utilise la sortie out5 donc quand on appuie 3 fois 
    sur la touche 5 la led12 HIGH.
    MAIS!!! pas 3 appuis sur 5 ( ça serait trop facile grrr )
    pour que la led12 s'allume il faut taper
    505050  et pour qu'elle s'éteigne taper 505050 .
    il y a moins de contrainte que le premier  
    type de code pas besoin de mise à zéro pour gérer plusieurs
    codes en même temps .*/ 
  
  static int etat_out5_precedent = LOW ; 
  // déclaration de variable locale .
  
  etat_out5 = digitalRead ( out5 )     ; 
  if ( etat_out5 == LOW && etat_out5_precedent == HIGH ) 
  { 
  var5 ++ ; // compteur n1
  }
  etat_out5_precedent = etat_out5     ;
  if ( var5 == 3 ) //  choisir le nombre d'appui
  // ici 3 appuis sur le compteur var5 ( touche 5 tel ).
  // donc appui tel: 505050 led12 HIGH ou LOW .
  // si on fait une erreur de chiffre en tapant le code
  // pas de mise à zéro nécessaire ex:
  // si on tape 50502750 led12 HIGH .
  { 
  // action << on off >>
  etat_led12 = ! etat_led12           ;
  digitalWrite ( led12 , etat_led12 ) ;
  
  var5 = 0 ; // mise à zéro du compteur n5
  }    
    

 //====================troisième type de code=================

 //     << code d'appui sur plusieurs touches différentes >>

 // code identique au deuxième mais ici 2 touches d'appui 
 // différentes pour faire le code , on peut en mettre plus .
 
 // il faut éviter de mettre tous les compteurs utilisés à 1
 // car code trop facile à trouver .
 // il suffirait de taper 102030405060708090 dans n'importe
 // quel ordre et led11 HIGH.
 
  static int etat_out6_precedent = LOW ; 
  static int etat_out9_precedent = LOW ; 
  // déclaration de variable locale .
  
  etat_out6 = digitalRead ( out6 )     ; 
  etat_out9 = digitalRead ( out9 )     ;
 
  if ( etat_out6 == LOW && etat_out6_precedent == HIGH )  
  {    
  var6 ++ ; // compteur n6
  }
  if ( etat_out9 == LOW && etat_out9_precedent == HIGH )  
  {    
  var9 ++ ; // compteur n9
  }
  etat_out6_precedent = etat_out6     ;
  etat_out9_precedent = etat_out9     ;
  
   if  ( ( var6 == 1 ) && ( var9 == 2 ) ) 
  // modifier le compteur à utiliser et le nombre d'appui:
  // ici 1 appui  sur le compteur var6 ( touche 6 tel ).
  // et  2 appuis sur le compteur var9 ( touche 9 tel ).
  // donc appui tel: 609090 led11 HIGH ou LOW .
  // la aussi si on fait une erreur de chiffre en tapant 
  // le code pas de mise à zéro nécessaire ex:
  // si on tape 60908590 led11 HIGH .
   {
   // action << on off >>
   etat_led11 = ! etat_led11           ;
   digitalWrite ( led11 , etat_led11 ) ;
   
   // j'ai essayé d'enlever l'action << on off >>  pour faire
   // un clignotement avec millis mais ça ne fonctionne pas.
   
   /* digitalWrite ( ledA0 , HIGH )      ;
      etat_ledA0 = digitalRead ( ledA0 ) ;
      if  ( etat_ledA0 == LOW ) 
      {
      digitalWrite ( led11 , LOW ) ;
      }
      if  ( etat_ledA0 == HIGH )  
      {
      unsigned long ms_actuelle = millis ( ) ;
      if ( ms_actuelle - ms_precedente >= interval_clignot ) 
      {
      ms_precedente = ms_actuelle         ;
      etat_led11 = ! etat_led11           ;
      digitalWrite ( led11 , etat_led11 ) ; */
   
    // mise à zéro des compteurs .
    var1 = 0 ;
    var2 = 0 ;
    var3 = 0 ;
    var4 = 0 ;
    var5 = 0 ;
    var6 = 0 ;
    var7 = 0 ;
    var8 = 0 ;
    var9 = 0 ;
    
    } }  //  } }

azerthuiop:
Désolé je n’ai pas mis le code intermédiaire entre balise. voila qui est fait

 //=================quatrième type de code=================== 

// une fois que l’on a tapé les 3 codes , taper sur n’importe
// qu’elle touche du tel et ledA5 HIGH.
// donc pour ledA5 HIGH taper 1234 505050 609090 et un chiffre
// entre 0 et 9 ou * ou # et la ledA5 s’allume.
// je ne comprends pas trop car * et # non utilisé dans le
// switch mais ça fonctionne nickel .

etat_led13  = digitalRead ( led13 ) ;
   etat_led12  = digitalRead ( led12 ) ;
   etat_led11  = digitalRead ( led11 ) ;
   if ( etat_led13 ,etat_led12 , etat_led11 == HIGH )
   { digitalWrite ( ledA5 , HIGH ) ; }
   
// j’ai essayé de mettre ce quatrième code à la fin mais cela
// ne fonctionnait pas donc je l’ai laissé ici.
   
 
  //=====================premier type de code================
 
 // c’est le code le moins pratique ( mais il fonctionne ) .
 
 // << code de 1 à 9 >>
 
   /* dans le choix de code on ne peut pas mettre 2 chiffres
   identique ni 0 .
   ici le code fait 4 chiffres .
   l’ordre de saisie n’a pas d’importance pour allumée la led13
   toutes les combinaisons de 1,2,3,4 l’allumeront.
   désolé je n’ai pas trouvé mieux . */

if
       // ici choisir le code que l’on veut .
   ( ( digitalRead ( out1 ) ==  HIGH  ) &&
     ( digitalRead ( out2 ) ==  HIGH  ) &&
     ( digitalRead ( out3 ) ==  HIGH  ) &&
     ( digitalRead ( out4 ) ==  HIGH  ) &&

( digitalRead ( out5 ) ==  LOW   ) &&  // ligne 197
     ( digitalRead ( out6 ) ==  LOW   ) &&
     ( digitalRead ( out7 ) ==  LOW   ) &&
     ( digitalRead ( out8 ) ==  LOW   ) &&
     ( digitalRead ( out9 ) ==  LOW   ) )

{
/* une fois le code tapé la led13 passe à high mais il n’est
  pas nécessaire de retapé le code entier pour l’éteindre,un
  appui sur 1,2,3 ou 4 le fera .
  MAIS !!! si on tape sur une touche au dela de 4 cela bloque  
  tout,il faut donc faire une mise à zéro (appui zéro tel)qui  
  éteindra la led13 et taper 1,2,3,4 pour l’allumer à nouveau */

// action << on off >>
     etat_led13 = ! etat_led13           ;
     digitalWrite ( led13 , etat_led13 ) ;
     }

/on peut faire 5 codes car il nous restent 5 broches dispo
 11 , 12 , 13 , A0 , A5. pour pouvoir gérer les 5 codes
 en même temps mettre une bascule D  montée en << on off >>
 sur chaques sorties ou les mise à zéro pour passer de code
 en code n’auront aucun effet car la bascule D est active
 sur front montant .
/

//====================code de mise à zéro================

/l’action de mise à zéro est obligatoire pour le premier type
 de code si on fait une erreur quand on tape le code la sortie
 reste à HIGH et on ne peut plus refaire celui ci.
 ex: si on tape 1,2,3,5 il faut faire une mise à zéro car le 5
 bloque tout( il faut que le 5 soit à LOW voir ligne 197 ) .
/
     
     if ( digitalRead ( out10 ) == HIGH )
     {
     digitalWrite ( out1  , LOW ) ;
     digitalWrite ( out2  , LOW ) ;
     digitalWrite ( out3  , LOW ) ;
     digitalWrite ( out4  , LOW ) ;
     digitalWrite ( out5  , LOW ) ;
     digitalWrite ( out6  , LOW ) ;
     digitalWrite ( out7  , LOW ) ;
     digitalWrite ( out8  , LOW ) ;
     digitalWrite ( out9  , LOW ) ;
     digitalWrite ( out10 , LOW ) ;
     }

bonsoir , j’ai trouvé un code pour faire un clignotement
sélectionnable pour faire une commande de cd4017.
je cherchais à faire un code pour pouvoir faire une action de x led
à une fréquence voulue.
je vous laisse la modif de code.
bonne soirée à tous. :slight_smile:

 // mettre << avant >> le set up
 
   int nombre_de_fois   ; //   pour le
   boolean fonct_cligno ; // clignotement

 // mettre << dans >> le set up
 
   nombre_de_fois = 50    ;  //   pour le
   fonct_cligno   = true  ;  // clignotement


 //=================quatrième type de code==================

    etat_led13  = digitalRead ( led13 ) ;
    etat_led12  = digitalRead ( led12 ) ;
    etat_led11  = digitalRead ( led11 ) ;
    if ( etat_led13 ,etat_led12 , etat_led11 == HIGH )
    { digitalWrite ( ledA5 , HIGH ) ; }
    

//===================fonction clignotement===================

 // fonction nombre de clignotement sélectionnable.
 // ne fonctionne que pour le premier et le quatrième 
 // type de code , je n'ai pas trouvé mieux.  

  //   pour le clignotement supprimer cette ligne.
  //  { digitalWrite ( ledA5 , HIGH ) ; }
  //   mettre le code ci-dessous à la place .
  
    {
     digitalWrite ( ledA0 , HIGH )      ;  
     etat_ledA0 = digitalRead ( ledA0 ) ;
     if ( etat_ledA0 == HIGH ) 
     {
     if ( fonct_cligno )
     {
     for ( int t = 0 ; t < nombre_de_fois ; t ++ )
     {
     digitalWrite ( ledA5 , HIGH ) ;
     delay ( 500 ) ;
     digitalWrite ( ledA5 , LOW  ) ;
     delay ( 500 ) ;
     digitalWrite ( ledA0 , LOW ) ;
     digitalWrite ( led11 , LOW ) ;
     digitalWrite ( led12 , LOW ) ;
     digitalWrite ( ledv13 ,LOW ) ;
     } } } }

 //===================premier type de code====================
 
     // action << on off >>
      etat_led13 = ! etat_led13           ; 
     digitalWrite ( led13 , etat_led13 ) ; }
     
    
//=================fonction clignotement=======================

 // fonction nombre de clignotement sélectionnable.
 // ne fonctionne que pour le premier et le quatrième 
 // type de code , je n'ai pas trouvé mieux.  
 // pour le clignotement suprimer cette ligne.
 // digitalWrite ( led13 , etat_led13 ) ; }
 // mettre le code ci-dessous à la place .
 
     digitalWrite ( ledA0 , HIGH )      ;  
     etat_ledA0 = digitalRead ( ledA0 ) ;
     if ( etat_ledA0 == HIGH ) 
     {
     if ( fonct_cligno )
     {
     for ( int t = 0 ; t < nombre_de_fois ; t ++ )
     {
     digitalWrite ( led13 , HIGH ) ;
     delay ( 500 ) ;
     digitalWrite ( led13 , LOW  ) ;
     delay ( 500 ) ;
     digitalWrite ( ledA0 , LOW )  ;
     digitalWrite ( ledA5 , LOW )  ;
     } } } }

Bonjour je me suis rendu compte qu'en tapant 609090 ( led11 HIGH ça c'est normal) mais en tapant un autre chiffre , n'importe lequel à la suite ledA5 HIGH ( et ça c'est pas normal ) je ne comprend pas pourquoi. Normalement ledA5 HIGH quand led11,led12,led13 = HIGH Ce qui fonctionne très bien quand on tape 1,2,3,4 5,0,5,0,5,0 6,0,9,0,9,0 sur le tel , la ledA5 s'allume bien au bout du troisième code.

if ( etat_led13 , etat_led12 , etat_led11 == HIGH ) donc cette ligne de code me semblait correcte. et bien non pour que 6,0,9,0,9,0 n 'allume que la led11 et pas la ledA5 quand on tape un autre chiffre après le 0 il faut modifier cette ligne .

if ( etat_led13 && etat_led12 && etat_led11 == HIGH ) je ne serais vous expliquer pourquoi mais ça fonctionne très bien comme ça.

Pourtant avec 1,2,3,4 et 5,0,5,0,5,0 cela fonctionnait très bien avec les virgules la ledA5 ne s'allumait pas il fallait faire le troisième code pour qu'elle passe à HIGH . Bonne journée à tous .

Bonsoir pour le clignotement avec millis il faut mettre le code juste
après la < void loop > en fait on ne peut pas faire un clignotement
direct avec millis en sortie de condition < if > ( c’est pas que l’on ne
peut pas c’est que tu n’as pas trouvé ce n’est pas pareil ). :o
donc on laisse le < on off > après le premier type de code.
la dernière ligne de code est donc :
digitalWrite ( led13 , etat_led13 ) ;
on se sert de l’état de la led13 pour faire le clignotement avec millis
en utilisant la ledA0 .
les 3 codes utilisent 3 sorties et le clignotement 2 , donc on à plus de
broches dispo pour le 4em type de code ,
il me faut un atmega 2560 .
j’ai fait 2 clignotements indépendants avec millis , avec 2 codes et cela
fonctionne on a bien 2 clignotement commandés séparément avec 2
code différents .
si on choisit de mettre plusieurs clignotements millis avec plusieurs codes
il faut penser à les différencier dans les déclarations avant le < set up >
et dans la < void loop > .

bonne soirée .
voici le code .

     // mettre ses 2 lignes de code avant le < setup> pour le 
     // clignotement avec millis .
         unsigned long ms_precedente =    0 ; 
         const long interval_clignot      = 500 ; 
     
     // mettre ses lignes de code après la < void loop >
     // pour le clignotement avec millis pour le premier
     // type de code .
     
     void loop ( )
     {
     // digitalWrite ( led13 , etat_led13 ) ; (c'est la dernière ligne de code du type 1 )
     etat_led13 = digitalRead ( led13 ) ;
     if (etat_led13 == LOW )
     {
     digitalWrite ( ledA0 , LOW ) ;
     }
     if ( etat_led13 == HIGH )
     {
     unsigned long ms_actuelle = millis ( ) ; 
     if ( ms_actuelle - ms_precedente >= interval_clignot )
     {
     ms_precedente = ms_actuelle ;
     etat_ledA0 =! etat_ledA0   ;
     digitalWrite ( ledA0 , etat_ledA0 ) ; } } 

     // le reste du code à la suite.......

    /*  si on fait plusieurs codes  avec clignotements
      avec  millis , pensez à différencier les déclarations
      avant le < setup > et les actions dans la < void loop > .
      
      ex: avant le < setup > si 2em code avec millis ,
      les 2 lignes de code doivent être différentes.
      unsigned long ms_precedente1 =   0 ; 
      const long interval_clignot1 = 500 ; */
      
     // et dans la < void loop > idem
     
   // digitalWrite ( led12 , etat_led12 ) ; c'est la dernière ligne de code du type 2
   /* etat_led12 = digitalRead ( led12 ) ;
      if (etat_led12 == LOW )
      {
      digitalWrite ( ledA5 , LOW ) ;
      }
      if ( etat_led12 == HIGH )
      {
       unsigned long ms_actuelle1 = millis ( ) ; 
      if ( ms_actuelle1 - ms_precedente1 >= interval_clignot1 )
      {
      ms_precedente1 = ms_actuelle1 ;
      {
      etat_ledA5 =! etat_ledA5   ;
      digitalWrite ( ledA5 , etat_ledA5 ) ; } } 
      
      etc.... */

      /*on peut faire autant de codes différents avec millis
      et qu'ils fonctionnent en même temps il suffit 
      d'identifier toutes les déclarations et fonctions millis .*/

Bonsoir , si on veut plus de sorties car il nous reste plus beaucoup
de broches ( surtout si on fait plusieurs clignotement avec millis qui
nous en prend 2 à chaque fois ) .
on peut mettre un ou plusieurs registre à décalage 74HC595 et la
on peut faire ce que l’on veut , dans le code ci-dessous il y en a 2
donc on peut sélectionner 16 leds à allumer .
mais on peut aussi faire des clignotements avec une ou plusieurs leds.
il existe de nombreux codes et explications sur le net .

bonne soirée .

voici le code .

   // indicateur d'interruption indiquant qu'une nouvelle
   // tonalité DTMF a été localisée 
   volatile  bool toneLoc = false ;
  
  // attribution des sorties << out >> aux broches ARDUINO
  // de 1 à 9 , rien n'y est raccordé ( sauf le 2 pour STD ).
   
   int  out1 =  0 ;
   int  out2 =  1 ;
   int  out3 =  3 ;
   int  out4 =  4 ;
   int  out5 =  5 ;
   int  out6 =  6 ;
   int  out7 =  7 ;
   int  out8 =  8 ;
   int  out9 =  9 ;
     
   int  out10 = 10  ;  // mise à zéro
     
   int  ledA0 = A0  ; // pour << on off >>
    
   int  etat_ledA0 ;  // pour << on off >>
    
 //============ pour la commande des 74HC595==============

   const int DATA   = 13 ; 
   const int LATCH  = 12 ; 
   const int CLK    = 11 ; 

   void  setup ( )
   {
   pinMode ( DATA  , OUTPUT ) ; // pour la
   pinMode ( LATCH , OUTPUT ) ; // commande
   pinMode ( CLK   , OUTPUT ) ; // des 74HC595

   // broche du DTMF 8870 de Q1 à Q4 raccordée sur l'arduino
   pinMode ( A4 , INPUT ) ;    // Q4 in
   pinMode ( A3 , INPUT ) ;    // Q3 in
   pinMode ( A2 , INPUT ) ;    // Q2 in
   pinMode ( A1 , INPUT ) ;    // Q1 in
  
   pinMode (  out1 , OUTPUT ) ;
   pinMode (  out2 , OUTPUT ) ;
   pinMode (  out3 , OUTPUT ) ;
   pinMode (  out4 , OUTPUT ) ;
   pinMode (  out5 , OUTPUT ) ;
   pinMode (  out6 , OUTPUT ) ;
   pinMode (  out7 , OUTPUT ) ;
   pinMode (  out8 , OUTPUT ) ;
   pinMode (  out9 , OUTPUT ) ;
   pinMode ( out10 , OUTPUT ) ;
  
   pinMode ( ledA0 , OUTPUT ) ;  // pour << on off >>
     
   // broche STD du DTMF 8870 raccordée sur 2 arduino .    
   attachInterrupt (digitalPinToInterrupt(2),newDTMF,RISING);
   }
   void loop ( ) 
   {
   // décode les données DTMF à l'arrivée des données
   if (toneLoc == true ) 
   {
   char keySymbol ;  // caractère décodé
    
   bool Q1 = digitalRead ( A1 ) ;    
   bool Q2 = digitalRead ( A2 ) ;  
   bool Q3 = digitalRead ( A3 ) ;  
   bool Q4 = digitalRead ( A4 ) ;  

   // combine les bits Q1..Q4 en un octet
   byte toneData =(0x00 | Q1 | (Q2 << 1 )| (Q3 << 2 )|(Q4 << 3 ));

   // décode le caractère DTMF  keySymbol = dtmf_decode(toneData);
   keySymbol = dtmf_decode ( toneData ) ;
  
   // effacer le drapeau localisé pour attendre le prochain signal
   toneLoc = false ;
   } }
   // isr pour définir l'indicateur de données reçues lors d'une
   // interruption.
   void  newDTMF ( )
   {
   toneLoc = true ;
   }
   // convertit les données Q1..Q4 en caractère DTMF
   char  dtmf_decode ( byte recv_data )
   {
   switch (recv_data)
   {
    case   1 :    // touche tel : 1
    digitalWrite  ( out1 , HIGH ) ;
                            break ;
    case   2 :    // touche tel : 2
    digitalWrite  ( out2 , HIGH ) ;
                            break ;
    case   3 :    // touche tel : 3
    digitalWrite  ( out3 , HIGH ) ;
                            break ;
    case   4 :      // touche tel 4
    digitalWrite  ( out4 , HIGH ) ;
                            break ;
    case   5 :          // touche 5
    digitalWrite  ( out5 , HIGH ) ;
                            break ;
    case   6 :    // touche tel : 6
    digitalWrite  ( out6 , HIGH ) ;
                            break ;
    case   7 :    // touche tel : 7
    digitalWrite  ( out7 , HIGH ) ; 
                            break ; 
    case   8 :    // touche tel : 8
    digitalWrite  ( out8 , HIGH ) ;
                            break ;
    case   9 :    // touche tel : 9
    digitalWrite  ( out9 , HIGH ) ;
                            break ;
    case  10 :    // touche tel : 0
    digitalWrite ( out10 , HIGH ) ;
                            break ;
    // case  11 :    touche tel * ; 
    // case  12 :    touche tel # ; 
    } 
    
       // ici choisir le code que l'on veut .
        if
    ( ( digitalRead ( out1 ) ==  HIGH  ) &&
      ( digitalRead ( out2 ) ==  HIGH  ) &&
      ( digitalRead ( out3 ) ==  HIGH  ) &&
      ( digitalRead ( out4 ) ==  HIGH  ) &&

      ( digitalRead ( out5 ) ==  LOW   ) &&  
      ( digitalRead ( out6 ) ==  LOW   ) &&
      ( digitalRead ( out7 ) ==  LOW   ) &&
      ( digitalRead ( out8 ) ==  LOW   ) &&
      ( digitalRead ( out9 ) ==  LOW   ) )

      {  
      
     //=========== action===== << on off >> =============
    
     etat_ledA0 = ! etat_ledA0            ; 
     digitalWrite ( ledA0 , etat_ledA0 )  ;
      
     //========== fonction avec 2x74HC595 =====OK=======
     
     if ( etat_ledA0 == HIGH ) 
     {
     // sélectionner les leds à allumer
     byte bitsToSend1  =  B11000000 ;
     // ici les 2 dernières leds du 1er 74hc595 sont à high.
     byte bitsToSend2  =  B11000000 ;
     // ici les 2 dernières leds du 2em 74hc595 sont à high.
    
     digitalWrite ( LATCH , LOW ) ;
     shiftOut ( DATA , CLK , MSBFIRST , bitsToSend2 ) ;
     shiftOut ( DATA , CLK , MSBFIRST , bitsToSend1 ) ;
     digitalWrite ( LATCH , HIGH ) ; 
   
     delay ( 2000 ) ; // une tempo est mise pour éteindre
     // les leds
     
     // éteindre toutes les leds
     bitsToSend1  =  B00000000 ;
     bitsToSend2  =  B00000000 ;  
    
     digitalWrite ( LATCH , LOW ) ;
     shiftOut ( DATA , CLK , MSBFIRST , bitsToSend2 ) ;
     shiftOut ( DATA , CLK , MSBFIRST , bitsToSend1 ) ;
     digitalWrite ( LATCH , HIGH ) ;  
     } }  
     
      // mise à zéro des << out >>
      if ( digitalRead ( out10 ) == HIGH ) 
      { 
      digitalWrite ( out1  , LOW ) ; 
      digitalWrite ( out2  , LOW ) ;
      digitalWrite ( out3  , LOW ) ;
      digitalWrite ( out4  , LOW ) ;
      digitalWrite ( out5  , LOW ) ;
      digitalWrite ( out6  , LOW ) ;
      digitalWrite ( out7  , LOW ) ;
      digitalWrite ( out8  , LOW ) ;
      digitalWrite ( out9  , LOW ) ;
      digitalWrite ( out10 , LOW ) ;
      } }

   // quand  le code est saisit taper un chiffre du code
   // cela éteindra la ledA0 et taper un chiffre autre que
   // le code avant de raccrocher car si on raccroche sans 
   // avoir fait cela lors d'un rapel des que l'on va taper 
   // sur 1,2,3ou4 la ledA0 et les 74hc595 vont changer d'état. 
  
   // donc penser à taper 0 en premier pour pouvoir saisir à 
   // nouveau le code ( même après avoir raccroché ) .

Bonsoir pour le premier type de code j’ai trouvé la façon de faire
un code avec plusieurs chiffres dans l’ordre avec un cd4017 de
nombreuses vidéos explicatives sont dispo sur le net .
je me suis servi de cette méthode pour faire le code en ajoutant
un cd4016 .
l’arduino pilote le cd4016 et le cd4016 pilote le cd4017 .
l’arduino ne pilote que le reset du cd4017 .

bonne soirée .

voici le code .

   // indicateur d'interruption indiquant qu'une nouvelle
   // tonalité DTMF a été localisée / reçue.
   volatile  bool toneLoc = false ;
  
   // attribution des sorties << out >> aux broches ARDUINO
   // de 1 à 9 , rien n'y est raccordé ( sauf le 2 pour STD ).
   
   int  out1  =   0 ;
   int  out2  =   1 ;
   int  out3  =   3 ;
   int  out4  =   4 ;
   int  out5  =   5 ;
   int  out6  =   6 ;
   int  out7  =   7 ;
   int  out8  =   8 ;
   int  out9  =   9 ;
   int  out10 =  10 ; 
     
   int  contact_A1  = 11 ;  // contact_A1 sur le pin 13 du 4016 
   int  contact_A2  = 12 ;  // contact_A2 sur le pin  5 du 4016
   int  contact_A3  = 13 ;  // contact_A3 sur le pin  6 du 4016
   int  contact_A4  = A0 ;  // contact_A4 sur le pin 12 du 4016

   int  reset       = A5 ;  // reset sur le pin 15 du 4017
     
  void  setup ( )
  {
  // broche du DTMF de Q1 à Q4 raccordée sur l'arduino
  pinMode ( A1 , INPUT ) ;    // Q1 DTMF
  pinMode ( A2 , INPUT ) ;    // Q2 DTMF
  pinMode ( A3 , INPUT ) ;    // Q3 DTMF
  pinMode ( A4 , INPUT ) ;    // Q4 DTMF
  
  pinMode (  out1 , OUTPUT ) ;
  pinMode (  out2 , OUTPUT ) ;
  pinMode (  out3 , OUTPUT ) ;
  pinMode (  out4 , OUTPUT ) ;
  pinMode (  out5 , OUTPUT ) ;
  pinMode (  out6 , OUTPUT ) ;
  pinMode (  out7 , OUTPUT ) ;
  pinMode (  out8 , OUTPUT ) ;
  pinMode (  out9 , OUTPUT ) ;
  pinMode ( out10 , OUTPUT ) ;
  
  pinMode ( contact_A1  , OUTPUT ) ;  // 11 arduino
  pinMode ( contact_A2  , OUTPUT ) ;  // 12 arduino
  pinMode ( contact_A3  , OUTPUT ) ;  // 13 arduino
  pinMode ( contact_A4  , OUTPUT ) ;  // A0 arduino
  
  pinMode ( reset , OUTPUT )       ;  // A5 arduino  

  // broche STD du DTMF 8870 raccordée sur 2 arduino.    
  // exécuter isr pour définir l'indicateur de données reçues 
  // lorsqu'une interruption se produit sur la broche 2 .
  attachInterrupt (digitalPinToInterrupt(2),newDTMF,RISING);
  }
  void loop ( ) 
  {
  // décode les données DTMF à l'arrivée des données
  if (toneLoc == true ) 
  {
  char keySymbol ;  // caractère décodé
    
  bool Q1 = digitalRead ( A1 ) ;  // lire les  
  bool Q2 = digitalRead ( A2 ) ;  // entrées
  bool Q3 = digitalRead ( A3 ) ;  // de donnée
  bool Q4 = digitalRead ( A4 ) ;  // de Q1 ....Q4

   // combine les bits Q1..Q4 en un octet
  byte toneData =(0x00 | Q1 | (Q2 << 1 )| (Q3 << 2 )|(Q4 << 3 ));

  // décode le caractère DTMF
  keySymbol = dtmf_decode ( toneData ) ;

  // effacer le drapeau localisé pour attendre le prochain signal
  toneLoc = false ;
  } }
  // isr pour définir l'indicateur de données reçues lors d'une
  // interruption.
  void  newDTMF ( )
  {
  toneLoc = true ;
  }
  // convertit les données Q1..Q4 en caractère DTMF
  char  dtmf_decode ( byte recv_data )
  {
    switch (recv_data)
    {
    case   1 :    // touche tel : 1
    digitalWrite  ( out1 , HIGH ) ;
                            break ;
                            
    case   2 :    // touche tel : 2
    digitalWrite  ( out2 , HIGH ) ;
                            break ;
                            
    case   3 :    // touche tel : 3
    digitalWrite  ( out3 , HIGH ) ;
                            break ;
                            
    case   4 :      // touche tel 4
    digitalWrite  ( out4 , HIGH ) ;
                            break ;
         
    case   5 :          // touche 5
    digitalWrite  ( out5 , HIGH ) ;
                            break ;
                            
    case   6 :    // touche tel : 6
    digitalWrite  ( out6 , HIGH ) ;
                            break ;
                            
    case   7 :    // touche tel : 7
    digitalWrite  ( out7 , HIGH ) ; 
                            break ; 
                            
    case   8 :    // touche tel : 8
    digitalWrite  ( out8 , HIGH ) ;
                            break ;
                            
    case   9 :    // touche tel : 9
    digitalWrite  ( out9 , HIGH ) ;
                            break ;
                            
    case  10 :    // touche tel : 0
    digitalWrite ( out10 , HIGH ) ;
                            break ;
                            
    // case  11 :    touche tel * ; non utilisé
    // case  12 :    touche tel # ; non utilisé
    } 
    
//==============ici choisir le code que l'on veut============

  // ici le code est :  4  2  1  3  ( out4,out2,out1,out3 )
       
  if ( digitalRead ( out4 ) == HIGH ) // modifier out...
  {
  digitalWrite ( contact_A1 , HIGH ) ; // A1 du 4016 ( 11 arduino )
  delay ( 50 ) ;
  digitalWrite ( contact_A1 , LOW ) ;
  digitalWrite ( out4 , LOW ) ; // modifier out...
  }
  if ( digitalRead ( out2 ) == HIGH ) // modifier out...
  {
  digitalWrite ( contact_A2 , HIGH ) ; // A2 du 4016 ( 12 arduino )
  delay ( 50 ) ;
  digitalWrite ( contact_A2 , LOW ) ;
  digitalWrite ( out2 , LOW ) ; // modifier out...
  }
  if ( digitalRead ( out1 ) == HIGH )  // modifier out...
  {
  digitalWrite ( contact_A3 , HIGH ) ; // A3 du 4016 ( 13 arduino )
  delay ( 50 ) ;
  digitalWrite ( contact_A3 , LOW ) ;
  digitalWrite ( out1 , LOW ) ; // modifier out...
  } 
  
  if ( digitalRead ( out3 ) == HIGH ) // modifier out...
  {
  digitalWrite ( contact_A4 , HIGH ) ; // A4 du 4016 ( A0 arduino )
  delay ( 50 ) ;
  digitalWrite ( contact_A4 , LOW ) ;
  digitalWrite ( out3 , LOW ) ; // modifier out...
  }
  
     // ATTENTION si on modifie les << OUT >> ci dessus
     // PENSER aussi à les modifier ci dessous .
     // ex: si on modifie out4 en out8 ci dessus
     // il faut modifier le out8 en out4 ci dessous etc...

     // si on tape 5 ou 6 ou 7 ou 8 ou 9 ou 0 (out10=0)
      
      if ( ( digitalRead ( out5  ) ==  HIGH  ) ||
           ( digitalRead ( out6  ) ==  HIGH  ) ||
           ( digitalRead ( out7  ) ==  HIGH  ) ||
           ( digitalRead ( out8  ) ==  HIGH  ) ||
           ( digitalRead ( out9  ) ==  HIGH  ) ||
           ( digitalRead ( out10 ) ==  HIGH  ) )
      {
      digitalWrite ( reset , HIGH ) ; // on fait un reset
      delay ( 50 ) ;
      
     // on met tous les out à LOW car si lors d'une fausse saisie
     // on laisse un des out à HIGH cela fait un reset en continu
     // et on ne peut plus saisir le bon code.
     
     digitalWrite ( out5  , LOW )  ;
     digitalWrite ( out6  , LOW )  ;
     digitalWrite ( out7  , LOW )  ;
     digitalWrite ( out8  , LOW )  ;
     digitalWrite ( out9  , LOW )  ;
     digitalWrite ( out10 , LOW )  ;
      
     digitalWrite ( reset , LOW )  ; 
     }  }

au lieu de poster du code au km, commencez par décrire ce que vous souhaitez obtenir - quel est le cahier des charges ?

si vous souhaitez gérer une combinaison de touches, c'est un peu comme lire le port série ou un keypad => vous pouvez jeter un oeil à mon petit tuto sur le sujet. il faut juste remplacer la source des caractères par la fonction qui décode le signal (notez que votre fonction dtmf_decode() ne retourne pas de caractère malgré la promesse faite au compilateur)

Bonjour JML désolé pour les codes au KM mais je poste ses codes pour les partager si ça intéresse quelqu'un comme moi qui n'est pas un professionnel de la programmation . quand au cahier des charges depuis le début du post il n'a pas changé je cherche à faire un code à plusieurs chiffres avec un DTMF8870 et un téléphone c'est tout . quand au dernier code avec le cd4017 et le cd4016 j'ai indiqué que de nombreux exemples sont dispo sur le net car cela est trop compliqué pour moi de l'expliquer avec des mots mieux vaut le voir sur le net pour comprendre le fonctionnement . si vous avez une solution pour faire un code à plusieurs chiffres avec un DTMF8870 et un téléphone , sans keypad sans moniteur série et sans écran LCD , pourriez vous poster le code car cela fait 1 mois que je cherche sur le net et je n'ai rien trouvé. bonne journée à vous :)

Vous avez quasiment tout dans le code il suffit de l’organiser différemment

 int  dtmfRead ()
{
  // définir dans ce tableau les caractères à retourner pour les codes de 0 à 15
  static const char touches[] = {'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X',};

  if (!toneLoc) return -1; // Retourne -1 si rien à lire

  // Je vous laisse améliorer en utilisant la lecture par registre PINC, comme ça on lit les 4 instantanément    
  byte Q1 = digitalRead ( A1 ) ;  // lire les  
  byte Q2 = digitalRead ( A2 ) ;  // entrées
  byte Q3 = digitalRead ( A3 ) ;  // de donnée
  byte Q4 = digitalRead ( A4 ) ;  // de Q1 ....Q4

   // combine les bits Q1..Q4 en un octet
  byte toneIndex =(Q1 | (Q2 << 1 ) | (Q3 << 2 )|(Q4 << 3 ));

  // effacer le drapeau localisé pour attendre le prochain signal
  toneLoc = false ;
  
  return touches[toneIndex];

}

(Code tapé sur mon iPad donc pas testé)

Avec ce code vous avez une fonction qui se comporte comme read() sur le port série. Ça retourne -1 si rien de dispo sinon ça retourne un caractère (que vous définissez dans la table de 16 choix).

Ensuite vous appliquez les principes du tuto pour bâtir une chaîne d’entrée et l’analyser

Bonjour merci pour le bout de code. Il remplacerait, si j’ai bien compris, la manière
de décoder une donnée DTMF avec un tableau pour remplacer celui donc je me
sers dans les codes . ( je n’ai pas compris <la lecture par registre PINC ) .
et pour les principes du tuto donc je dois me servir pour <bâtir une chaîne d’entrée
et l’analyser>je ne comprends pas cette phrase et dans les tutos il n’y a pratiquement
que du moniteur série .
il y a trop de choses que je ne comprends pas pour faire ce code correctement ,
et un niveau en programmation plus que limite , comme le prouvent les codes ci-dessus
qui ont des structures basiques et simples , et en plus chaque code à des défauts
( mais ils fonctionnent tous ) .
j’aimerais trouver le code parfait sans aucun défaut .
ex : si on tape sur le tel: 1 0 1 2 dans l’ordre et en une seule fois ( 4 saisies )
cela allume une led tous simplement ( sans keypad,sans moniteur série et sans écran lcd).
à moins de poster votre code moi je n’y arriverais pas .
merci de m’avoir accordé de votre temps et de votre patience.
bonne journée . :o

je ne comprends pas cette phrase et dans les tutos il n'y a pratiquement que du moniteur série

je parlais de mon tuto sur le port série. Mais on s'en fiche d'où vient ou où va l'information analysée. Souvent on l'affiche à l'écran comme exemple, mais vous pouvez piloter une pin ou faire ou faire autre chose une fois l'analyse effectuée.

à moins de poster votre code moi je n'y arriverais pas .

ce forum est fait pour aider à apprendre, pas pour faire à votre place... c'est votre projet, et si cela vous tient à coeur investissez un peu de votre temps et énergie dans l'apprentissage des bases de la programmation en C et C++ et de l'environnement Arduino.

j'aimerais trouver le code parfait sans aucun défaut .

Ce code c'est celui que vous écrirez qui correspondra exactement à votre cahier des charges... donc faut pas baisser les bras, pas essayer de copier sur Pierre Paul ou Jacques mais partir de votre propre code...

Au sujet du cahier des charges

je cherche à faire un code à plusieurs chiffres avec un DTMF8870 et un téléphone c'est tout .

ce n'est pas assez précis.

par exemple comment l'Arduino saura qu'un code est complet ? les codes font-ils tous 4 touches comme dans l'exemple que vous donnez ci dessus ? ou faut-il entrer un caractère de validation (par exemple '*' ou '#' à la fin) ?

est-ce que toutes les actions sont codées en dur ou elles doivent pouvoir être définies/modifiées par l'utilisateur ? si oui comment ?

etc..

bonsoir heureusement qu’il y a Pierre Paul et Jacques; pour
ma part cela n’engage que moi, pour faire certain projet arduino
j’ai besoin de ces personnes pour m’ aider, vous le premier et je
vous en suis reconnaissant mais au bout d’un moment je ne peux
pas vous laisser dire que je baisse les bras facilement.
je pense que lorsque vous commenciez dans la programmation
au bout d’un mois de recherche vous auriez vu d’un mauvais œil
une personne vous dire <<et mon gars tu crois pas qu’on va te faire
ton code, tu baisse les bras un peut trop vite>>.
d’ou vient mes codes au km; je suis pour le partage, si mes codes n’ont
servis qu’à une seule personne cela me suffit .
quand j’ai commencé le DTMF8870 j’aurais aimé tomber sur un post
comme le mien .
bonsoir mon amis dieux te bénisse.

On ne se comprend pas bien. Je ne dis pas que c’est pas important de regarder voire Copier ce que Pierre ou Paul ont pondu mais que ça ne reste que leur programme pour leur besoin, leur cahier des charges.

Mon point c’est qu’à un moment ça devient plus efficace de partir d’une feuille blanche et d’appliquer ce que vous avez appris pour obtenir le code qui répond exactement à VOTRE besoin.

D’autre part vous frotter un peu plus près au code va vous permettre de développer vos compétences.

Enfin - j’ai pas compris l’objet de votre post je pensais que vous cherchiez à corriger ce code puisque le clignotement ne fonctionnait pas - désolé pour cette mécompréhension.

azerthuiop:
bonsoir heureusement qu’il y a Pierre Paul et Jacques; pour
ma part cela n’engage que moi, pour faire certain projet arduino
j’ai besoin de ces personnes pour m’ aider, vous le premier et je
vous en suis reconnaissant mais au bout d’un moment je ne peux
pas vous laisser dire que je baisse les bras facilement.
je pense que lorsque vous commenciez dans la programmation
au bout d’un mois de recherche vous auriez vu d’un mauvais œil
une personne vous dire <<et mon gars tu crois pas qu’on va te faire
ton code, tu baisse les bras un peut trop vite>>.
d’ou vient mes codes au km; je suis pour le partage, si mes codes n’ont
servis qu’à une seule personne cela me suffit .
quand j’ai commencé le DTMF8870 j’aurais aimé tomber sur un post
comme le mien .
bonsoir mon amis dieu te bénisse.

Bon pour que dieu me bénisse et comme c’était fun à regarder, j’ai pondu un bout de code:

Le code est documenté, mais voici le résumé:

Arduino UNO (sur MEGA ça changerait les registres des PORT)
connecter Q0 sur 8, Q1 sur 9, Q2 sur 10, Q3 sur 11.
connecter STQ sur 2
brancher 5V sur Vin et GND sur GND
branchez un cable audio dans le jack et l’autre côté à votre source

Si vous voulez générer des fréquences depuis votre ordinateur:

ce site vous permet de fabriquer des fichiers audio. Je joins deux fichiers (dans DTMF.zip), un qui envoie “0123456789*#ABC 000 111 222 333 444 555 666 777 888 999 *** ### AAA BBB CCC” et l’autre qui envoie “888”

Vous pouvez aussi utiliser cet autre site pour générer les fréquences en appuyant directement sur les touches à l’écran de l’ordinateur.

Le code utilise des interruptions pour détecter STQ et va lire les pins Q1…Q4 en utilisant les registres pour plus d’efficacité. Cela emmène des contraintes sur les pins à utiliser. Q1 à Q4 doivent être connectées sur des pins d’un même PORT, séquentiellement. Si vous changez leur place il faut modifier Q_PORT et Q_MASK pour définir le nouveau port et quels bits prendre.

#define Q_PORT  PINB    // PINB corresponds on a UNO to pins 8..13 (bits 6 & 7 map to the crystal pins and are not usable)
#define Q_MASK  0b1111  // the 4 bits of interest in the register: we use pins 8,9,10,11

Cette interruption construit un buffer en mémoire des caractères reçus.

Le setup() prépare les pins comme il faut et le buffer. la seule chose à mettre dans la loop() c’est l’appel à handleDTMF();. Vous pouvez faire ensuite autre chose si vous voulez.

Vous n’avez pas besoin de mettre les mains dans le cambouis pour la partie DTMF, mais il y a deux fonctions à bien comprendre: parseNewChar() et parseNewWord()

parseNewChar() est appelée quand on a reçu un nouveau caractère
parseNewWord() est appelée quand on a reçu un nouveau mot, c’est à dire un silence assez long (réglé à 750ms dans la constante silenceDuration) après le dernier caractère. Un silence reçu insérera un espace dans le buffer et sera considéré comme la fin d’un mot.

Quand vous avez reçu un nouveau caractère ou mot, vous pouvez (devez) analyser le contenu de la cString message qui contient une copie de ce qui a été tapé.

Si la fonction retourne true, c’est que l’analyse a été effectuée et une commande détectée et le buffer sera alors vidé. Si vous retournez false, le buffer est conservé pour le prochain tour.

Si le buffer déborde, il est vidé autoritairement.

Pour le moment les 2 fonctions ne font qu’imprimer la taille du buffer et son contenu. La seule commande recherchée est “888”, dans ce cas un message spécial est affiché et on retourne true, ce qui remet le buffer à zéro.

en jouant le fichier “0123456789*#ABC 000 111 222 333 444 555 666 777 888 999 *** ### AAA BBB CCC.wav”, vous verrez dans le moniteur série (@ 115200 bauds)

[color=purple]
DTMF listener ready
1	0
2	01
3	012
4	0123
5	01234
6	012345
7	0123456
8	01234567
9	012345678
10	0123456789
11	0123456789*
12	0123456789*#
13	0123456789*#A
14	0123456789*#AB
15	0123456789*#ABC
16	0123456789*#ABC 	NEW WORD
17	0123456789*#ABC 0
18	0123456789*#ABC 00
19	0123456789*#ABC 000
20	0123456789*#ABC 000 	NEW WORD
21	0123456789*#ABC 000 1
22	0123456789*#ABC 000 11
23	0123456789*#ABC 000 111
24	0123456789*#ABC 000 111 	NEW WORD
25	0123456789*#ABC 000 111 2
26	0123456789*#ABC 000 111 22
27	0123456789*#ABC 000 111 222
28	0123456789*#ABC 000 111 222 	NEW WORD
29	0123456789*#ABC 000 111 222 3
30	0123456789*#ABC 000 111 222 33
31	0123456789*#ABC 000 111 222 333
32	0123456789*#ABC 000 111 222 333 	NEW WORD
33	0123456789*#ABC 000 111 222 333 4
34	0123456789*#ABC 000 111 222 333 44
35	0123456789*#ABC 000 111 222 333 444
36	0123456789*#ABC 000 111 222 333 444 	NEW WORD
37	0123456789*#ABC 000 111 222 333 444 5
38	0123456789*#ABC 000 111 222 333 444 55
39	0123456789*#ABC 000 111 222 333 444 555
40	0123456789*#ABC 000 111 222 333 444 555 	NEW WORD
41	0123456789*#ABC 000 111 222 333 444 555 6
42	0123456789*#ABC 000 111 222 333 444 555 66
43	0123456789*#ABC 000 111 222 333 444 555 666
44	0123456789*#ABC 000 111 222 333 444 555 666 	NEW WORD
45	0123456789*#ABC 000 111 222 333 444 555 666 7
46	0123456789*#ABC 000 111 222 333 444 555 666 77
47	0123456789*#ABC 000 111 222 333 444 555 666 777
48	0123456789*#ABC 000 111 222 333 444 555 666 777 	NEW WORD
49	0123456789*#ABC 000 111 222 333 444 555 666 777 8
50	0123456789*#ABC 000 111 222 333 444 555 666 777 88
51	0123456789*#ABC 000 111 222 333 444 555 666 777 888
BINGO 888 trouvé !!
2	9 	NEW WORD
3	9 9
4	9 99
5	9 99 	NEW WORD
6	9 99 *
7	9 99 **
8	9 99 ***
9	9 99 *** 	NEW WORD
10	9 99 *** #
11	9 99 *** ##
12	9 99 *** ###
13	9 99 *** ### 	NEW WORD
14	9 99 *** ### A
15	9 99 *** ### AA
16	9 99 *** ### AAA
17	9 99 *** ### AAA 	NEW WORD
18	9 99 *** ### AAA B
19	9 99 *** ### AAA BB
20	9 99 *** ### AAA BBB
21	9 99 *** ### AAA BBB 	NEW WORD
22	9 99 *** ### AAA BBB C
23	9 99 *** ### AAA BBB CC
24	9 99 *** ### AAA BBB CCC
25	9 99 *** ### AAA BBB CCC 	NEW WORD

[/color]

Amusez vous bien

DTMF_MT8870.ino (9.07 KB)

DTMF.zip (25.8 KB)

Bonjour wahouh quel code d’une simplicité déconcertante pourquoi
je n’y avais pas pensé plus tôt,je n’ai jamais vu un code aussi simple.
j’en suis tous juste à savoir faire clignoter une led tout le monde se
demande pourquoi je n’ai pas trouvé ce code enfin!!!
quand à mon incompréhension de
J’ai vu votre tuto je ne savais pas qu’il y avait 3 ports et de surcroît
multiplexable sur l 'arduino ( bon en même temps je ne sais pas grand
chose ) .
quand à la bénédiction cela ne va pas être possible ( enfin pas pour
l’instant ) .
j’ai dis que j’aimerai trouver le code PARFAIT et le votre à une faille
si je tape 1012 ( oui 888 ça me va pas en plus pour le bénédiction
c’est pas bon ) dans les 750ul OK cela fonctionne ma led s’allume ,
MAIS si je tape 1012 hors temps et après n’importe quel chiffres
ma led s 'allume et ça c’est pas normal.on à du mal à avoir une
régularité dans l’allumage et l’extinction de la led j’ai essayé de
modifié le 750ul mais cela ne change rien , je vous laisse ma femme
vient de me jeter l’arduino dans la piscine je vais le chercher.
ne vous inquiétez pas je vais me venger je vais lui mettre le dernier
album de BRUEL au micro onde.

Oui, c'est un choix - le code insère un espace pour marquer les silences.

==> éventuellement supprimez l'insertion des espaces, vous serez toujours notifié en fin de mot mais vous n'aurez pas d'information précise sur où sont les mots dans ce cas là.

il suffit de ré-écrire la fonction insertDTMFSilence() sous cette forme

void insertDTMFSilence()
{
  noInterrupts();
  DTMFSatus = DTMF_SILENCE_RECEIVED; // fake receiving something
  needToHandleSilence = false;
  interrupts();
}