L'objectif du jour : régler l'intensité lumineuse de mon afficheur 4 chiffres à 7 segments interfacé avec un TM1637 à l'aide d'un bouton poussoir.
Il s'agit de mon tout premier code alors soyez durs mais pédagogues...
Pour moi il manque un lien entre le setting setBrightness et ma variable Brightness pour que tout cela fonctionne.
Merci d'avance pour vos lumières (sans mauvais jeu de mot...) !
#include <TM1637Display.h>
#define CLK 2
#define DIO 3
TM1637Display display(CLK, DIO);
#define TEST_DELAY 2000
const int btn_lum = 4;
int etat_Bouton;
int Brightness;
int memoire_lum = HIGH; // état relâché par défaut
void setup()
{
display.setBrightness(6);
display.showNumberDec(6666); // Afficher le nombre 6666 dans l’afficheur TM1736
pinMode(btn_lum, INPUT); // le bouton est une entrée
etat_Bouton = HIGH; // initialise l'état du bouton comme "relaché"
}
void loop()
{
// lecture de l'état du bouton
etat_Bouton = digitalRead(btn_lum);
// Si le bouton a un état différent de celui enregistré ET
// que cet état est "appuyé"
if((etat_Bouton != memoire_lum) && (etat_Bouton == LOW))
{
// on incrémente la variable qui indique
// la valeur d'intensité de l'afficheur
Brightness++;
}
// on enregistre l'état du bouton pour le tour suivant
memoire_lum = etat_Bouton;
// on applique des limites au nombre pour ne pas dépasser 7 ou 0
if(Brightness > 7)
{
Brightness = 7;
}
if(Brightness < 0)
{
Brightness = 0;
}
}
Avez vous une résistance de pull-up externe sur le bouton ? (pour qu'il soit HIGH au repos). Il existe une pull up directement dans l'arduino, ça évite la résistance externe, il suffit de déclarer pinMode(btn_lum, INPUT_PULLUP);pour qu'elle soit activée
Faites attention aussi aux rebonds de votre bouton. un petit delay(15); en cas de détection d'appui devrait suffire à gommer cela.
pas la peine d'initialiser etat_Bouton dans le setup() puisque vous l'affectez directement dans la loop() (et il n'a pas besoin d'être une variable globale)
En revanche, il serait bien d'initialiser Brightness à 6 puisque c'est la valeur initiale que vous donnez.
Le test des limites de Brightness n'a pas besoin d'être fait en permanence dans la loop. Le faire que lorsque vous effectuez un changement de luminosité est suffisant et comment peut-il devenir négatif puisqu'il commence à 6, et ne fait qu'augmenter avec un max à 7 ?
idem pour l'affectation de memoire_lum
soyez cohérent dans la capitalisation des noms de variables et la langue utilisée (français ou anglais); On utilise souvent ce qu'on appelle le camelCase: Une variable commence par une minuscule et tout nouveau mot dans le nom de variable commence par une majuscule, et on essaye aussi de choisir de noms "parlants". Au lieu de memoire_lum on pourrait utiliser etatPrecedent par exemple.
ça ressemblerait alors à cela:
#include <TM1637Display.h>
#define CLK 2
#define DIO 3
TM1637Display display(CLK, DIO);
const byte pinBouton = 4;
byte luminosite = 3; // luminosité initiale à 3/7, environ la moitié
byte etatPrecedent = HIGH; // état relâché par défaut
int valeurAffichee = 6666;
void setup()
{
pinMode(pinBouton, INPUT); // le bouton est une entrée avec Pull-up externe
display.setBrightness(luminosite);
display.showNumberDec(valeurAffichee); // Afficher notre valeur (ici 6666) dans l'afficheur TM1736
}
void loop()
{
// lecture de l'état du bouton
byte etatCourant = digitalRead(pinBouton);
// Si le bouton a un état différent de celui enregistré ETque cet état est "appuyé"
if ((etatCourant != etatPrecedent) && (etatCourant == LOW)) {
// on incrémente la variable qui indique la valeur d'intensité de l'afficheur
// et on applique des limites au nombre
if (++luminosite > 7) luminosite = 0;
// et on met à jour la luminosité
display.setBrightness(luminosite);
// on enregistre l'état du bouton pour le tour suivant
etatPrecedent = etatCourant;
// anti-rebond au cas où
delay(15);
}
}
Je mesure le chemin qu'il me reste à parcourir, merci pour ces explications, elles m'en apprennent beaucoup. J'ai bien noté les remarques à propos de ma syntaxe.
J'ai effectivement une pull-up externe, en revanche pas de condensateur en parallèle de mon bouton donc le "delay" est judicieux.
Il y a une partie du code que je ne saisie pas :
if (++luminosite > 7) luminosite = 0;
L'incrémentation est intégré dans les conditions limites ? Ne devrait-il pas d'abord avoir une incrémentation du genre "luminosité++" et ensuite les limites ?
En l'état cela ne fonctionne pas mais je soupçonne une défaillance de mon montage. Je vais essayé d'utiliser la pull-up interne et trouver un bouton neuf (celui-ci est une récup...).
J’ai tapé le code ici sans tester - il faut sortir le
// on enregistre l'état du bouton pour le tour suivant
etatPrecedent = etatCourant;
du if sinon on ne met pas à jour l’état précédent quand il le faut.
Pour l’incrémentation si on met ++ devant le nom de variable ça incrémente et test la variable incrémentée alors que si on le met après ça incrémente mais s’évalue à l’ancienne valeur et donc ça ne fonctionnerait pas.
Merci pour l'explication de texte, c'est clair à présent.
J'ai testé mon bouton sur un montage simple et il fonctionne correctement.
J'ai enlevé la ligne mentionnée.
Je suis passé sur un pull-up interne en modifiant le code en conséquence.
Malgré cela mon intensité lumineuse reste figée...
J'ai fait un test en utilisant exactement la même "structure de code" (par certain de la formulation...) mais pointant sur une variation des valeurs affichées :
#include <TM1637Display.h>
#define CLK 2
#define DIO 3
TM1637Display display(CLK, DIO);
const int Bouton = 4;
byte luminosite = 1; // luminosité initiale à 3/7, environ la moitié
byte etatPrecedent = HIGH; // état relâché par défaut
int valeurAffichee = 6666;
void setup()
{
pinMode(Bouton, INPUT_PULLUP); // le bouton est une entrée avec Pull-up interne
display.setBrightness(luminosite);
display.showNumberDec(valeurAffichee); // Afficher notre valeur (ici 6666) dans l'afficheur TM1736
}
void loop()
{
// lecture de l'état du bouton
byte etatCourant = digitalRead(Bouton);
// Si le bouton a un état différent de celui enregistré ETque cet état est "appuyé"
if ((etatCourant != etatPrecedent) && (etatCourant == LOW)) {
// on incrémente la variable qui indique la valeur d'intensité de l'afficheur
// et on applique des limites au nombre
if (++valeurAffichee > 6670) valeurAffichee = 6666;
// et on met à jour la luminosité
display.showNumberDec(valeurAffichee);
// anti-rebond au cas où
delay(150);
}
}
J'ai dû augmenter notablement le délai anti-rebond pour une meilleure stabilité (l'achat d'un condensateur parait impératif) mais le code fonctionne très bien !
Du coup je ne comprends pas le problème avec la variable "luminosité"...avez-vous des suggestions ?
Tu ne mets pas à jour etatPrecedent, c'est pour ça que le traitement du bouton fonctionne mal et que tu est obligé de mettre un délai énorme.
JML 't'avais dit qu'il faut le sortir du if, mais il faut le mettre à la fin de la loop et non le supprimer.
Tu ne changes pas la luminosité dans loop, c'est pour ça qu'elle ne change pas.
Qu'est ce que tu veux faire avec ton bouton? Tu est passé de l'incrémentation de la luminosité dans ton programme précédent à l'incrémentation de la valeur affiché dans ton dernier programme.
Mon objectif reste bien celui indiqué dans le titre de mon post : régler l'intensité lumineuse de l'afficheur avec un bouton. C'était pour faire un essai de la syntaxe globale seulement...
Merci pour la remarque, j'avais mal lu l'indication de J-M-L, j'ai replacé le code (etatPrecedent) en fin de loop après le if.
Tu dis que "Tu ne changes pas la luminosité dans loop", mais cette partie là sert à ça et à définir les limites :
if (++luminosite > 7) luminosite = 0;
non ?
En tout cas l'enregistrement de l'état du bouton en fin de loop n'a pas permis de faire fonctionner le code...
J'ai essayé de modifier le code dans loop mais rien n'a fonctionné, je sèche... des idées ?
#include <TM1637Display.h>
#define CLK 2
#define DIO 3
TM1637Display display(CLK, DIO);
const byte pinBouton = 4;
byte luminosite = 3; // luminosité initiale à 3/7, environ la moitié
byte etatPrecedent = HIGH; // état relâché par défaut
int valeurAffichee = 6666;
void setup()
{
pinMode(pinBouton, INPUT); // le bouton est une entrée avec Pull-up externe
display.setBrightness(luminosite);
display.showNumberDec(valeurAffichee); // Afficher notre valeur (ici 6666) dans l'afficheur TM1736
}
void loop()
{
// lecture de l'état du bouton
byte etatCourant = digitalRead(pinBouton);
// Si le bouton a un état différent de celui enregistré ETque cet état est "appuyé"
if ((etatCourant != etatPrecedent) && (etatCourant == LOW)) {
// on incrémente la variable qui indique la valeur d'intensité de l'afficheur
// et on applique des limites au nombre
if (++luminosite > 7) luminosite = 0;
// et on met à jour la luminosité
display.setBrightness(luminosite);
// anti-rebond au cas où
delay(15);
}
// on enregistre l'état du bouton pour le tour suivant
etatPrecedent = etatCourant;
}
Si on regarde le source de la librairie on lit ceci:
//! Sets the brightness of the display.
//! //! The setting takes effect when a command is given to change the data being //! displayed.
//!
//! @param brightness A number from 0 (lowes brightness) to 7 (highest brightness)
//! @param on Turn display on or off
void setBrightness(uint8_t brightness, bool on = true);
Le changement d'intensité ne prend effet que lorsqu'on affiche.
Donc
Il faut (ré)afficher après avoir changé la luminosité
De plus il faut mettre l'entrée en INPUT_PULLUP pour activer le pullup interne
#include <TM1637Display.h>
#define CLK 2
#define DIO 3
TM1637Display display(CLK, DIO);
const byte pinBouton = 4;
byte luminosite = 3; // luminosité initiale à 3/7, environ la moitié
byte etatPrecedent = HIGH; // état relâché par défaut
int valeurAffichee = 6666;
void setup()
{
pinMode(pinBouton, INPUT_PULLUP); // le bouton est une entrée avec Pull-up externe
display.setBrightness(luminosite);
display.showNumberDec(valeurAffichee); // Afficher notre valeur (ici 6666) dans l'afficheur TM1736
}
void loop()
{
// lecture de l'état du bouton
byte etatCourant = digitalRead(pinBouton);
// Si le bouton a un état différent de celui enregistré ETque cet état est "appuyé"
if ((etatCourant != etatPrecedent) && (etatCourant == LOW)) {
// on incrémente la variable qui indique la valeur d'intensité de l'afficheur
// et on applique des limites au nombre
if (++luminosite > 7) luminosite = 0;
// et on met à jour la luminosité
display.setBrightness(luminosite);
display.showNumberDec(valeurAffichee); // on affiche pour prendre en compte la nouvelle luminosité
// anti-rebond au cas où
delay(15);
}
// on enregistre l'état du bouton pour le tour suivant
etatPrecedent = etatCourant;
}
La leçon de votre dernier post : bien potasser les librairies.
Je ne vais pas résumer tout ce que j'ai appris dans ce sujet de discussion mais c'était vraiment stimulant, merci pour votre soutient et votre pédagogie !
Allez une dernière question :
Dois-je ajouter un attribut à mon sujet pour le déclarer "résolu" ?
