Gestion boutons arduino

[invite0f178c4b]

Bonjour à tous,

Je me (re)°met à la prog des µc grâce à nos amis Italiens et je bute sur un truc qui me chiffonne :
J'ai mon programme qui tourne en boucle, je lis une lm35, un HIH4000 et un baromètre et j'affiche ça sur un écran LCD, bref, j'ai réinventé la station météo. ALors je fais bien mumuse, je mesure ma température au 1/100 °C parceque je voulais voir comment marchait le suréchantillonnage (c'est magique, j'approche ma main et ça bouge de quelques centièmes ), mais je bloque sur un truc, je voulais mettre un peu de convivialité à tout ça en gérant des boutons poussoirs pour aller d'une page à l'autre, afficher un menu, etc. ... et je me retrouve face à un dilème : soit j'appuie sur mon bouton au moment ou le programme scrutte ce dernier, soit je scrutte sans cesse ce dernier... J'ai bien pensé aux interruptions, mais si je veux mettre plusieurs boutons, je fais comment ? Je voulais aussi savoir si vous connaissiez un moyen "propre" de détecter des fronts montants sur une bouton poussoir sans subir les rebonds (si possible sans devoir perdre mon temps à perdre du temps processeur avec une tempo logicielle, mais plutôt avec des circuits RC ou des timers qui libèrent le µc pendant la tempo).

Voilà, ça en fait des questions floues pour un seul post, mais je n'aurais pas dérangé l'élite des électroniciens pour rien

Merci d'avance,
Mayonaise
-----

[gcortex]

Tu lis les boutons l'un après l'autre et tu exécutes n fois un sous programme pendant le rebond !

PS : tu utilises les pull-up intégrées ?

[invite0f178c4b]

C'est justement ce que je voudrais essayer de ne pas faire (executer autant de fois la boucle qu'il y a de rebonds)... Et non, je n'utilise pas les pullup intégrés car je voulais tester différents filtres RC pour faire antirebond. Mais à terme, je peux les utiliser, je préfère juste avoir la main la dessus pour mes essais.

[gcortex]

non

Si tu as une routine de 2ms, tu l'exécutes toujours 10 fois pour couvrir les 20ms d'éventuels rebonds, quelque soit leur nombre !

[A voir en vidéo sur Futura]

[terriblement]

Le plus simple est d'avoir un timer qui vérifie toutes les x ms si une des entrées a changée.
Si changement et stable sur une durée >20ms, alors tu 'set un flag' que tu traiteras dans ton main.

[invite0f178c4b]

Bonjour à tous et merci pour ces réponses.

Le plus simple est d'avoir un timer qui vérifie toutes les x ms si une des entrées a changée.
Si changement et stable sur une durée >20ms, alors tu 'set un flag' que tu traiteras dans ton main.

Je ne me suis pas encore attaqué aux timers (et aux interruption non plus), mais j'ai une idée de leur utilité et en effet, je pense que ça peut servir. Si je génère une interruption par le biais d'un timer toutes les 1 ms pour lancer une routine de vérification de l'état des boutons qui, en cas de front montant (en fait détection d'un état 1 alors qu'il était à 0 auparavant), attend 20ms et génère un flag avant de redonner la main au programme principal qui le traitera le moment voulu, ça vous parraît correct ? Je vais m'attaquer à la doc sur les timers et les interruptions, mais ça m'a l'air assez ardu sur la référence arduino. si quelqu'un a un tuto intéressant à proposer, je suis prenneur...

Si tu as une routine de 2ms, tu l'exécutes toujours 10 fois pour couvrir les 20ms d'éventuels rebonds, quelque soit leur nombre !

Tu veux dire si mon, void loop() dure 2 ms ?

Comment je peux savoir le temps que dure ce programme par exemple ? L'IDE d'arduino le donne dans un endroit secret ?

/*
PROGRAMME :   THERMO-HYGROMETRE_LCD

Licence : GPL V3 SA

Réalisé par : Mathieu
Version :     0.3
Date :        10/02/2013

NOTES :

TO DO :

DONE :

*/

/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
COMPILATEUR : Déclaration des variables et librairies à utiliser
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

//Déclaration des librairies du programme------------------------------------------------------------------------------------------------------------------------------------------

#include <LiquidCrystal.h>                           //Inclure la librairie LiquidCristal

//Déclaration des constantes du programme------------------------------------------------------------------------------------------------------------------------------------------

//Routine d'initialisation de la librairie LiquidCristal

//Routine d'initialisation détaillée de la librairie LiquidCristal
///*
const int RS = 12;                                  //La pin RS de l'afficheur LCD est connectée à la pin 12 de l'Arduino
const int E = 11;                                   //La pin Enable de l'afficheur LCD est connectée à la pin 11 de l'Arduino
const int D4 = 5;                                   //La pin D4 de l'afficheur LCD est connectée à la pin 5 de l'Arduino
const int D5 = 4;                                   //La pin D5 de l'afficheur LCD est connectée à la pin 4 de l'Arduino
const int D6 = 3;                                   //La pin D6 de l'afficheur LCD est connectée à la pin 3 de l'Arduino
const int D7 = 2;                                   //La pin D7 de l'afficheur LCD est connectée à la pin 2 de l'Arduino
LiquidCrystal lcd(RS, E, D4, D5, D6, D7);           //Initiation de la librairie LiquidCristal d'après les variables
//*/
//Fin de routine d'initialisation détaillée de la librairie LiquidCristal

//LiquidCrystal lcd(12, 11, 5, 4, 3, 2);            //Initiation de la librairies LiquidCristal : (RS = 12, Enable = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2)

//Fin de la routine d'initialisation de la librairie LiquidCristal

const int RHPIN = 0;                                //La mesure de la tension renvoyée par la sonde RH se fera sur la pin A0
const int TEMPPIN = 1;                              //La mesure de la tension renvoyée par la sonde de température se fera sur la pin A1
const int PRESPIN = 2;                              //La mesure de la tension renvoyée par la sonde de pression se fera sur la pin A2
const int ECHRH = 256;                              //Le suréchantillonnage de l'humidité sera de 6 bits (128)
const int ECHT = 256;                               //Le suréchantillonnage de la température sera de 6 bits (128)
const int ECHP = 256;                               //Le suréchantillonnage de la pression sera de 6 bits (128)

//Déclaration des variables du programme-------------------------------------------------------------------------------------------------------------------------------------------

//Les types "int"
//int analogRhValue = 0;                   //Valeur retournée par le CAN après lecture de l'humidité
//int analogTValue = 0;                    //Valeur retournée par le CAN après lecture de la température
int i = 0;                                 //Constante à incrémenter
int j = 0;                                 //Constante à incrémenter

//Les variables de type "long"
long analogRhValue = 0;                    //Valeur de l'humidité retournée après suréchantillonnage
long analogTValue = 0;                     //Valeur de la température retournée après suréchantillonnage
long analogPValue = 0;                     //Valeur de la pression retournée après suréchantillonnage

//Les type "float"
float relativeHumidity = 0;              //Valeur calculée de l'humidité
float temperature = 0;                   //Valeur calculée de la température
float pression = 0;                      //Valeur calculée de la pression

/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
SETUP : Ce qui est contenu dans cette boucle n'est exécuté qu'une fois au démarrage de l'Arduino ou en cas de reset de ce dernier
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
void setup() 
{//..............................................................................................................................................................Début de la boucle
  lcd.begin(16,2);                      //Déclaration des dimensions de l'afficheur
  delay(10);                            //Pause rapide pour laisser le temps d'initialisation
  pinMode(RHPIN, INPUT);                //On déclare la pin considérée en entrée
  pinMode(TEMPPIN, INPUT);              //On déclare la pin considérée en entrée
  pinMode(PRESPIN, INPUT);              //On déclare la pin considérée en entrée
}//................................................................................................................................................................Fin de la boucle

/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
LOOP : Ce qui est contenu dans cette boucle est exécuté sans fin après démarrage de l'Arduino
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
void loop() 
{//..............................................................................................................................................................Début de la boucle
  //Début du sous-programme "LECTURE ET CALCUL DE L'HUMIDITE"********************
  
  //Lecture du port du CAN sur lequel est branché l'hygromètre conversion en humidité relative
  
  analogRhValue = 0;                                            //On met la variable "analogRhValue" à zéro
  
  //Boucle de lecture de l'humidité suréchantillonnée
  for (i = 0; i < ECHRH; i++)
  {
    /*En fait, on n'a pas besoin de table pour suréchantillonner, on gagne alors en place mémoire !
    analogRhTable[i] = analogRead(RHPIN);                       //Lecture de la valeur renvoyée par l'hygromètre et stockage dans la la table "analogRhTable" à l'index "i"
    */
    
    ///*Si on décommente cet encadrement de routine, il faut activer la routine précédente ainsi que la "Routine de sommation de la table" en commentant la désactivation (permet de tester 
    analogRhValue = analogRhValue + analogRead(RHPIN);          //On aditionne la valeur lue sur RHPIN à analogRhValue (long)
    //*/
    delay(1);
  }
  
  //Routine de sommation de la table
  /*Désactivation
  for (i = 0; i < ECHRH; i++)
  {
    analogRhValue = analogRhValue + analogRhTable[i];           //On aditionne "analogRhValue" avec "analogRhTable" indice "i" et on le stocke dans "analogRhValue"
  }
  */
  
  relativeHumidity = ((((float)(analogRhValue)/(float)(ECHRH))-164.0)/6.35);     
  //Conversion de la valeur "analogValue" en "relativeHumidity" qui est un type float() représentant l'humidité relative
  
  //Fin du sous-programme "LECTURE ET CALCUL DE L'HUMIDITE"**********************
  
  //Début du sous-programme "LECTURE ET CALCUL DE LA TEMPERATURE"********************
  
  //Lecture du port du CAN sur lequel est branché l'hygromètre conversion en humidité relative
  
  analogTValue = 0;                                            //On met la variable "analogtValue" à zéro
  
  //Boucle de lecture de l'humidité suréchantillonnée
  for (i = 0; i < ECHT; i++)
  {
    /*En fait, on n'a pas besoin de table pour suréchantillonner, on gagne alors en place mémoire !
    analogTTable[i] = analogRead(TEMPPIN);                      //Lecture de la valeur renvoyée par l'hygromètre et stockage dans la la table "analogRhTable" à l'index "i"
    */
    
    ///*Si on décommente cet encadrement de routine, il faut activer la routine précédente ainsi que la "Routine de sommation de la table" en commentant la désactivation (permet de tester 
    analogTValue = analogTValue + analogRead(TEMPPIN);          //On aditionne la valeur lue sur TPIN à analogTValue (long)
    //*/
    delay(1);
  }
  
  //Routine de sommation de la table
  /*Désactivation
  for (i = 0; i < ECHT; i++)
  {
    analogTValue = analogTValue + analogTTable[i];           //On aditionne "analogTValue" avec "analogTTable" indice "i" et on le stocke dans "analogTValue"
  }
  */
  
  temperature = (((float)(analogTValue)/(float)(ECHT))*0.48876);                
  //Conversion de la valeur "analogValue" en "temperature" qui est un type int() représentant l'humidité relative
  
  //Fin du sous-programme "LECTURE ET CALCUL DE LA TEMPERATURE"**********************
  
  //Début du sous-programme "LECTURE ET CALCUL DE LA PRESSION"********************
  
  //Lecture du port du CAN sur lequel est branché lla sonde de pression conversion en pression absolue
  
  analogPValue = 0;                                            //On met la variable "analogPValue" à zéro
  
  //Boucle de lecture de la pression suréchantillonnée
  for (i = 0; i < ECHP; i++)
  {
    /*En fait, on n'a pas besoin de table pour suréchantillonner, on gagne alors en place mémoire !
    analogTPable[i] = analogRead(PRESPIN);                       //Lecture de la valeur renvoyée par l'hygromètre et stockage dans la la table "analogRhTable" à l'index "i"
    */
    
    ///*Si on décommente cet encadrement de routine, il faut activer la routine précédente ainsi que la "Routine de sommation de la table" en commentant la désactivation (permet de tester 
    analogPValue = analogPValue + analogRead(PRESPIN);          //On aditionne la valeur lue sur PRESPIN à analogPValue (long)
    //*/
    delay(1);
  }
  
  //Routine de sommation de la table
  /*Désactivation
  for (i = 0; i < ECHP; i++)
  {
    analogPValue = analogPValue + analogPTable[i];           //On aditionne "analogPValue" avec "analogPTable" indice "i" et on le stocke dans "analogPValue"
  }
  */
  
  pression = (((float)(analogPValue)/(float)(ECHP))*(5.0/1023.0)*487.514);                
  //Conversion de la valeur "analogPValue" en "pression" qui est un type int() représentant l'humidité relative
  
  //Fin du sous-programme "LECTURE ET CALCUL DE LA PRESSION"**********************
  
  //Début du sous-programme "ECRITURE DE LA VALEUR MESUREE"********************
  if (j == 0)
  {
    lcd.clear();                                             //On efface l'écran
    lcd.print("Hygro. : ");                                  //On écrit "Hygro. :" au début de la première ligne
    //lcd.setCursor(9, 0);                                   //On place le curseur en ligne 1, 10° position (on part de 0, 0)
    lcd.print(relativeHumidity);                             //On écrit la valeur de l'humidité
    lcd.print(" %");                                         //On écrit l'unité à la suite de la mesure
    j++;                                                     //On incrémente j
  }
  else
  {
    lcd.clear();                                             //On efface l'écran
    lcd.print("P : ");                                       //On écrit "P :" au début de la première ligne
    //lcd.setCursor(9, 0);                                   //On place le curseur en ligne 1, 10° position (on part de 0, 0)
    lcd.print(pression);                                     //On écrit la valeur de la pression
    lcd.print(" mBar");                                      //On écrit l'unité à la suite de la mesure
    j = 0;                                                   //On resete j
  }
  
  //Le thermomètre il est pêté chef, y'a Mathieu q'a voulu le brancher sur sa vieille CB et il a fait "pfffuit"
  
  lcd.setCursor(0, 1);                                     //On place le curseur en ligne 2, première position (on part de 0, 0)
  lcd.print("Temp. : ");                                   //On écrit "Temp. :" au début de la première ligne
  lcd.print(temperature);                                  //On écrit la valeur de la température
  lcd.print(" C");                                         //On écrit l'unité à la suite de la mesure
  
  //Fin du sous-programme "ECRITURE DE LA VALEUR MESUREE"**********************
    
  //Début du sous-programme "DELAI DE RAFFRAICHISSEMENT"********************
  delay(1000);                                               //On attend 500ms avant de recommencer
  //Fin du sous-programme "DELAI DE RAFFRAICHISSEMENT"**********************
  
  
}//................................................................................................................................................................Fin de la boucle

Merci encore.

[cubitus_54]

je mesure ma température au 1/100 °C parceque je voulais voir comment marchait le suréchantillonnage

Si je ne raconte pas de bêtises le LM35 à une précision au mieux de 0,2° ce qui fait que 1/5°C

[DAUDET78]

Si je ne raconte pas de bêtises le LM35 à une précision au mieux de 0,2° ce qui fait que 1/5°C

Mais, étant analogique, il a une résolution infinie ..... limitée par son bruit propre et celle des ampliOPs. 1/100° de degrés ..... ça me laisse rêveur !

[invite0f178c4b]

Je me fous de la précicion absolue du thermomètre, c'était pour tester en pratique le suréchantillonnage et le fait de faire de l'ombre sur le capteur suffit à changer sa température de quelques centièmes et je trouve ça rigolo

[invite0f178c4b]

Bon alors pour les septiques, je mes suis replongé dans le code et je suréchantillonne 256fois chaque mesure. Comme l'a précisé Daudet, j'ai des capteurs analogiques, donc avec une résolution infinie (même si leur précision peut laisser à désirer...). Le CAN arduino est un CAN 10 bits . Je suréchantillonne 256 fois donc j'ai une résolution théorique de 18 bits. Soient une sortie variant entre 0 et 262 143 ce qui correspond à une résolution de 19 µV... L'erreur de ma chaine de mesure est disproportionnée par rapport à la résolution, je le conçois, mais l'instrumentiste qui sommeille en mois maintiens que, même si le résultat ne veut rien dire, ces hautes sensibilités peuvent être intéressantes, notamment sur des boucles esclaves asservies en cascades, puisque l'erreur absolue du capteur est corrigée par une adaptation de la demande de consigne du régulateur maître, l'important n'étant que la précision du capteur de sortie de ce dernier...

[invite0f178c4b]

Mais au fait, on digresse là, je me eprmet de rappeller le sujet :
Citation Envoyé par gcortex
Le plus simple est d'avoir un timer qui vérifie toutes les x ms si une des entrées a changée.
Si changement et stable sur une durée >20ms, alors tu 'set un flag' que tu traiteras dans ton main.
Je ne me suis pas encore attaqué aux timers (et aux interruption non plus), mais j'ai une idée de leur utilité et en effet, je pense que ça peut servir. Si je génère une interruption par le biais d'un timer toutes les 1 ms pour lancer une routine de vérification de l'état des boutons qui, en cas de front montant (en fait détection d'un état 1 alors qu'il était à 0 auparavant), attend 20ms et génère un flag avant de redonner la main au programme principal qui le traitera le moment voulu, ça vous parraît correct ? Je vais m'attaquer à la doc sur les timers et les interruptions, mais ça m'a l'air assez ardu sur la référence arduino. si quelqu'un a un tuto intéressant à proposer, je suis prenneur...