Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Forum général sur le langage C !

Modérateur : Jérémy

Scruptation de nombreuses entrées
Jérémy
Administrateur du site
Administrateur du site
Messages : 2112
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#1 Message par Jérémy » mar. 11 sept. 2018 21:44 lien vers la Data-Sheet : Cliquez ici

Bonsoir à tous,

Sur ma télécommande j'ai des trims afin de compenser le décalage du véhicule.
En tout j'ai donc 8 trims donc 8 inters à bouton poussoir à surveiller. Lors d'un appui sur l'un d'eux cela change la variable des trims. Pour ne pas rendre l'appui sur un bouton bloquant, 'j’utilise la méthode de la détection de front avec une variable mémoire. Ainsi mon programme continue de tourner en permanence, même si on reste appuyé sur le BP.

La lecture des ces trims est donc un enchainement de 16 comparaisons pour savoir si un bouton est appuyé ou relâché et si son état à changer !
Je trouve cette méthode pas top et peu optimisée!

Est ce que de votre coté vous utilisez une autre méthode pour scruter autant de boutons sans rendre bloquant le programme ?

Voici la partie de scrutation des trims pour vous donner une idée de la lourdeur de la chose !

Code : Tout sélectionner

//-------------------------------------------------------------------------------------------------
// Cette fonction check la pression sur un BP des trims
// Sil'appui est validé elle incrémente ou décremente et l'enregistre en EEPROM
// Avec le systéme d'ancien état on ne reste pas bloqué dans la fonction
void Lecture_Trim(){

   if ( (BP_Trim_G_H == 0) && (Ancien_etat1==0) ) {  // Je detecte un passage a l'état bas
      delay_ms(5);                                   // debounce
      if (BP_Trim_G_H == 0) {
          Ancien_etat1 = 1;                          // Je signale un état bas validé
       }
    }
   if ( (BP_Trim_G_H == 1) && (Ancien_etat1==1) ) {  // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_G_HB += 1;                              // L'ordre est validé
      Ancien_etat1 = 0;                              // RAZ du flag
      EEPROM_Write(0x01, V_Trim_G_HB);
      delay_ms(1);
    }
 //---
   if ( (BP_Trim_G_B == 0) && (Ancien_etat2==0) ) {  // Je detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_G_B == 0) {
          Ancien_etat2 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat2 && (BP_Trim_G_B == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_G_HB -= 1;                              // L'ordre est validé
      Ancien_etat2 = 0;                              // RAZ du flag
      EEPROM_Write(0x01, V_Trim_G_HB);
      delay_ms(1);
    }
 //---
    if ((BP_Trim_G_D == 0) && (Ancien_etat3==0) ) {  // Je detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_G_D == 0) {
          Ancien_etat3 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat3 && (BP_Trim_G_D == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_G_DG += 1;                              // L'ordre est validé
      Ancien_etat3 = 0;
      EEPROM_Write(0x02, V_Trim_G_DG);
      delay_ms(1);
    }
 //---
   if ( (BP_Trim_G_G == 0) && (Ancien_etat4==0) ) {  // JE detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_G_G == 0) {
          Ancien_etat4 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat4 && (BP_Trim_G_G == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_G_DG -= 1;                              // L'ordre est validé
      Ancien_etat4 = 0;                              // RAZ du flag
      EEPROM_Write(0x02, V_Trim_G_DG);
      delay_ms(1);
    }
    //---
   if ( (BP_Trim_D_H == 0) && (Ancien_etat5==0) ) {  // JE detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_D_H == 0) {
          Ancien_etat5 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat5 && (BP_Trim_D_H == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_D_HB += 1;                              // L'ordre est validé
      Ancien_etat5 = 0;                              // RAZ du flag
      EEPROM_Write(0x03, V_Trim_D_HB);
      delay_ms(1);
    }
 //---
   if ( (BP_Trim_D_B == 0) && (Ancien_etat6==0) ) {  // JE detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_D_B == 0) {
          Ancien_etat6 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat6 && (BP_Trim_D_B == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_D_HB -= 1;                              // L'ordre est validé
      Ancien_etat6 = 0;                              // RAZ du flag
      EEPROM_Write(0x03, V_Trim_D_HB);
      delay_ms(1);
    }
//---
   if ( (BP_Trim_D_D == 0) && (Ancien_etat7==0) ) {  // JE detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_D_D == 0) {
          Ancien_etat7 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat7 && (BP_Trim_D_D == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_D_DG += 1;                              // L'ordre est validé
      Ancien_etat7 = 0;                              // RAZ du flag
      EEPROM_Write(0x04, V_Trim_D_DG);
      delay_ms(1);
    }
 //---
   if ( (BP_Trim_D_G == 0) && (Ancien_etat8==0) ) {  // JE detecte un passage a l'état bas
      delay_ms(5);                                  // debounce
      if (BP_Trim_D_G == 0) {
          Ancien_etat8 = 1;                          // Je signale un état bas validé
       }
    }
   if (Ancien_etat8 && (BP_Trim_D_G == 1) ) {        // Si je suis déjà passé à l'état bas et que je suis revenu à haut
      V_Trim_D_DG -= 1;                              // L'ordre est validé
      Ancien_etat8 = 0;                              // RAZ du flag
      EEPROM_Write(0x04, V_Trim_D_DG);
      delay_ms(1);
    }
}


L'idée est quand même d'essayé de garder cette fonction dans mon programme principale, pour pouvoir agir en permanence sur les trims. Au pire j'aurais pus créer un écran de réglage pour n'activer cette fonction que dans certaines conditions, mais bon pas top !
Merci !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Scruptation de nombreuses entrées
Temps-x
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 876
Enregistré en : juillet 2016
Localisation : Terre

#2 Message par Temps-x » mar. 11 sept. 2018 22:34 lien vers la Data-Sheet : Cliquez ici

Bonsoir Jérémy, et tout le forum,

Généralement j'utilise très peu les interruptions quand j'ai plein de bouton à gérer, je fais tourner mon programme en boucle.
Je suis même obligé de le ralentir parfois.

Si appui sur 1 exécute et recommence la boucle
sinon passe au 2

Si appui sur 2 exécute et recommence la boucle
sinon passe au 3

Si appui sur 3 exécute et recommence la boucle
sinon passe au 4

Si appui sur 4 exécute et recommence ...........
.........................................................

L'idée d'activer une fonction quand tu as besoin est une des solutions, mais faudrait dans ce cas se servir des interruptions.

J'ai pas d'autre idée pour l'instant, mais je vais réfléchir :roll:

==> A+
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

Scruptation de nombreuses entrées
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1030
Âge : 67
Enregistré en : juillet 2015
Localisation : 01120
Contact :

#3 Message par paulfjujo » mer. 12 sept. 2018 15:55 lien vers la Data-Sheet : Cliquez ici

bonjour Jeremy et à tous,

l'usage d'un MCP2317 ( 8E + 8S ou 16E ou 16S ) en I2C ou son pendant en SPI
permet de detecter un changement d'etat de 8E , par generation d'une interruption materielle , envoyée au PIC

Scruptation de nombreuses entrées
Jérémy
Administrateur du site
Administrateur du site
Messages : 2112
Âge : 39
Enregistré en : juillet 2015
Localisation : Dans le sud
Contact :

#4 Message par Jérémy » mer. 12 sept. 2018 20:01 lien vers la Data-Sheet : Cliquez ici

bonsoir,

Cool la méthode HARD, j'aurais du y penser avant de faire la platine. Je garde ton idée sous le coude ca peu toujours servir !
Pour le moment je cherche une solution plus élégante. Après c'est juste pour m'améliorer car le PIC écran n'as pas grande chose à faire, ca ne dérange pas plus que ca de faire 16 conditions.

Au pire je peu limiter à 8 conditions en regardant seulement si il y a eu un changement d'état, qu'il soit en montant ou en descendant. Et seulement apres je rentre dans la fonction et je cherche quel est l'état qui a été modifié et dans quel sens.

Je pense pouvoir faire bien mieux ! Merci !
C'est en faisant des erreurs, que l'on apprend le mieux !!!

Scruptation de nombreuses entrées
Gérard
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 804
Âge : 60
Enregistré en : septembre 2015
Localisation : Alsace

#5 Message par Gérard » jeu. 13 sept. 2018 09:05 lien vers la Data-Sheet : Cliquez ici

Bonjour à tous,

Je viens aussi de penser à la solution de Paul. J'ai déjà utilisé le 23016. Il existe maintenant d'autres circuits, les 23017 et 23018 Ce dernier est en drain ouvert mais comme tu souhaites des entrées, ce n'est pas important. Les versions "S" sont pour le bus SPI, sinon, c'est I2C.
Le 11 / 07 / 2017, j'ai commandé une Ford Mustang.
Le 31 / 08 / 2017, j'ai eu la Mustang, un régal.


Retourner vers « Langage C »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 4 invités