j ai 3 bp cablé et un afficheur 7 segment sur un arduino
j ai mon code qui marche bien: quand j appui sur le bp1 il s affiche 1 sur le 7 segment pendant un certain temps quand j appui sur le bp2 il s affiche 2 sur le 7 segment pendant un certain temps et quand j appui sur le bp3 il s affiche 3 sur le 7 segment pendant un certain temps, j utilise delays pour tout ca mais je voudrais faire evoluer mon code car je voudrais que quand j appui sur bp1 il s affiche 1 sur le 7 segment mais si j appui pendant le temps d affichage de 1 sur le bp2 il saffiche en alternance 1 et 2 mais comme j utiliuse delay je suis bloquer.
j ai bien vue la fonction millis mais j ai du mal a l assimiler alors que je pense que la base que je doit coder doit etre simple.
Pour faire ce genre de chose, le plus efficace est de concevoir ton code comme une machine d'états. Tu peux chercher dans la section des tutos celui qu'a écrit J-M-L sur le sujet, il te donnera des bases.
Une fois que tu auras compris le principe, il te faudra dessiner tes états et tes transitions. Ce n'est pas forcément simple puisque tu as des transitions qui dépendent du temps et d'autres qui dépendent de l'état de plusieurs boutons.
Donc, il est vital de bien définir ton graphe afin que tout soit clair et que tu puisses coder ensuite sereinement.
c est facile et compliqué a la fois, je comprends bien quand il montre les examples mais tres dur a concevoir dans mon application, je pense comprendre comment supprimer les delay avec la fonction millis mais je bloque sur comment afficher mes 2 etats en alternance sur mon afficheur quand le bp1 et le bp2 sont activé...
J ai bien bosser mais je bloque dans ma tête sur la façon d afficher sur un seul afficheur 7 segment quand les 3 bp sont appui alternativement 1 2 et 3 et que l afficheur doit marquer alternativement 1 2 et 3.
Au niveau du code je sais interroger les bp, poser la question SI bp1 high et bp2 high et bp3 high alors
Digitalwrite affiche1
Digitalwrite affiche2
Digitalwrite affiche3
Mais je sais pas comment le dire pour qu il s affiche les uns après autres par exemple toutes les secondes sur une durée de 1minutes sans utilisé delay qui bloquerai mon programme
Merci de m éclairer encore un peu
Je me doute en plus que le code ne doit pas être compliqué une fois que l on a la syntaxe ca sera beaucoup du copier coller
C'est bien. Je pense que tu dois créer trois variables d'état, une pour chaque led : allumée ou éteinte. Ce sera le plus simple, sinon, il te faudra un très grand nombre d'états pour rendre compte de toutes les possibilités.
La loop doit faire ceci :
lecture des 3 boutons
si au moins un bouton est enfoncé : un petit delay(30) pour l'anti-rebond
vérifier les timeout et agir en conséquence (un pour chaque led)
si un bouton est enfoncé, mettre à jour l'état de la led correspondante selon le cas et réinitialiser le chrono associé à la led. Par exemple, si le bouton 2 est enfoncé : si led1 allumée et pas led3, c'est la première colonne ; si led3 et led1 allumées; c'est la troisième colonne ; si led1 et led3 éteintes, c'est la seconde.
allumer ou éteindre les led en fonction de leur état mis à jour
Je connaissai les film de bool mais pas les tableaux!
je pense que j ai voulu entrependre quelque chose qui me depasse mais je vais essayer de trouver des infos sur ses tableau et voir comment sa marche.
A l'appui sur une touche tu mets le chiffreAffiche[] correspondant à true CA JE DEVRAI Y ARRIVER
et tu mémorise millis() CA AUSSI JE PENSE J AI VUE DES EXEMPLES COMME DANS BLINK WITOUT DELAY
Toutes les 0.5s (par exemple) tu affiches le chiffre qui est à true OK JE VOIS TOUJOURS AVEC MILLIS IL ME SEMBLE
puis tu passes au suivant pour la prochaine fois CA PAS COMPRIS
Au bout de time (quand millis()-millisMemorise>=time) tu éteins tout et remet la table chiffreAffiche[] à false ETTEINDRE LA TABLE CA JE VOIS PAS DU FAIT QUE JE MAITRISE PAS ENCORE LES TABLEAU JE SUPPOSE
alors j ai un peu avancer mais on y est pas encore(meme loin a mon avis)
pour les tableaux de bool j ai pas fait mais deja j ai avancer mon code pour comprendre en supprimant les delay qui verouiller l ensemble.
petit rappel de se que je veux faire, cest facile je veux:
quand j appuis sur un bp1 le chiffre 1 s affiche sur l afficheur 7 segment pendant 10s et puis s eteint.
quand j appui sur un bp2 le chiffre 2 s affiche sur l afficheur pendant 10s et puis s eteint.(jusque la j y arrive avec le code suivant)
mais je veux surtout que quand le chiffre 1 et afficher et que j appui sur le bp2 les chiffre 1 et 2 s affiche en alternance sur mon afficheur.
et la j avance plus >:(
une ame charitable pour me donner un bout de code pour essayer de progresser sil vous plait.
#include "SevSeg.h"
SevSeg sevseg;
const int bp_1=A0;
const int bp_2=A1;
const int bp_3=A2;
boolean etatbp1=LOW;
boolean etatbp2=LOW;
boolean etatbp3=LOW;
unsigned long previousMillis = 0;
void setup() {
pinMode(bp_1, INPUT);
pinMode(bp_2, INPUT);
pinMode(bp_3, INPUT);
int bp_1=LOW;
int bp_2=LOW;
int bp_3=LOW;
byte numDigits = 3;
byte digitPins[] = {2, 3, 4};
byte segmentPins[] = {12, 11, 10, 9, 8, 7, 6, 5};
bool resistorsOnSegments = false; // 'false' means resistors are on digit pins
byte hardwareConfig = COMMON_ANODE; // See README.md for options
bool updateWithDelays = false; // Default 'false' is Recommended
bool leadingZeros = false; // Use 'true' if you'd like to keep the leading zeros
bool disableDecPoint = true; // Use 'true' if your decimal point doesn't exist or isn't connected
sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments,
updateWithDelays, leadingZeros, disableDecPoint);
sevseg.setBrightness(160);
}
void loop()
{
unsigned long currentMillis = millis();
etatbp1=digitalRead(bp_1); // on memorise l'etat des bp
etatbp2=digitalRead(bp_2); // on memorise l'etat des bp
if (etatbp1==HIGH)
{
sevseg.setNumber(11, 7);
previousMillis = millis();
}
if (currentMillis - previousMillis >= 10000) {
previousMillis = currentMillis;
sevseg.blank ();}
{
sevseg.refreshDisplay(); // Must run repeatedly
}
if (etatbp2==HIGH)
{
sevseg.setNumber(222, 1);
currentMillis = millis();
}
if (currentMillis - previousMillis >= 10000) {
previousMillis = currentMillis;
sevseg.blank ();}
{
sevseg.refreshDisplay(); // Must run repeatedly
}
if (etatbp3==HIGH)
{
sevseg.setNumber(333, 1);
currentMillis = millis();
}
if (currentMillis - previousMillis >= 10000) {
previousMillis = currentMillis;
sevseg.blank ();}
{
sevseg.refreshDisplay(); // Must run repeatedly
}
}
merci je voudrais bien progresser tout seul mais la je bloque
:o ouch merci kamill va falloir que je l essaye et que j arrive a le comprendre car c'est le but mais ça va être un bon début a moins qu il fonctionne du premier coup, je pensé bien que ça allais être très facile pour ceux qui savent.
SUPER Kamill ca marche maintenant je vais pouvoir jouer avec tout car je veux le faire evoluer a 11 bp qui afficheront 1 2 3 4 5 6 7 8 A C E sur 6 ecrans en meme temps qui seront multiplexer comme sur la photos mais avec sur chaque cathode un NPN pour la puissance
d apres vous la partie electronique fonctionera ?
je metrais un schemas specifique apres histoire de valider la partie materiel avant de passer a la fabrication du pcb
Oui, il n'y a pas de raison que ça ne fonctionne pas (il faut avoir un nombre de sorties suffisant). Bien sur il faut des résistances sur les segments.
Il y a des tas de solutions
On peut aussi utiliser des afficheurs à anode commune
On peut aussi utiliser des circuits spécialisés comme les TM1637, TM1638, MAX7219 ...
Il existe aussi des modules afficheur tout faits avec ces circuits.
Je n'ai pas regardé en détail, mais la façon dont tu pilotes les afficheurs avec les transistors est très très bizarre.
L'émetteur doit être au gnd et le collecteur à la cathode commune de l'afficheur. Il doit y avoir une résistance de base.
Pas la peine d'utiliser des résistances 5W, des 1/4W suffisent, les sorties de l'arduino ne peuvent débiter que 20mA (40 en pointe).
Même chose pour les transistors des leds, je ne comprend pas ce que tu as voulu faire.
Les résistances de 100 ohms sur les entrées me semblent ne servir à rien.
