3 BP ET 1 AFFICHEUR 7 SEGMENT

Bonjour a tous,

je m apel gael et j ai un probleme

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.

un petit coup de main serais le bien venu

je mets mon code de base qui marche bien

merci a tous

test.ino (1.93 KB)

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.

salut,

merci de la piste j essaye de trouver se dont tu parle
si des liens vers des tuto je suis preneur

merci

Allez, c'est mon jour de bonté... lien

ouchh

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é...

Je t'ai conseillé de faire un schéma de tes états, un peu comme ça...

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

Merci

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

Il ne reste plus qu'à coder ça...

Bonjour,

Il te faut créer un tableau de bool chiffreAffiche[3] qui indique si le chiffre correspondant est à afficher

A l'appui sur une touche tu mets le chiffreAffiche correspondant à true et tu mémorise millis()

Toutes les 0.5s (par exemple) tu affiches le chiffre qui est à true dans chiffreAffiche puis tu passes au suivant pour la prochaine fois

Au bout de time (quand millis()-millisMemorise>=time) tu éteins tout et remet la table chiffreAffiche à false

Je connaissai les film de bool mais pas les tableaux! :slight_smile: :slight_smile: :slight_smile:

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

MERCI J ESSAYE D AVANCER AVEC TOUT CA

cest ce genre de tableau?

const byte chiffreAffiche[3] = 
{
 //
  B01100000, // 1
  B11011010, // 2
  B11110010, // 3
  
};

Non, je ne parlais pas d'un tableau de const, mais de

bool chiffreAffiche[3]={0};

Bonsoir,

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

Tu peux faire comme ça par exemple

const int led1A = 14;
const int led1B = 15;
const int led1C = 16;
const int led1D = 17;
const int led1E = 18;
const int led1F = 19;
const int led1G = 20;

const int bp_1 = A2;
const int bp_2 = A3;
const int bp_3 = A4;

boolean etatbp1 = LOW;
boolean etatbp2 = LOW;
boolean etatbp3 = LOW;

int time = 10000;

void setup()
{
  Serial.begin(115200);

  pinMode(led1A, OUTPUT);
  pinMode(led1B, OUTPUT);
  pinMode(led1C, OUTPUT);
  pinMode(led1D, OUTPUT);
  pinMode(led1E, OUTPUT);
  pinMode(led1F, OUTPUT);
  pinMode(led1G, OUTPUT);

  pinMode(bp_1, INPUT);
  pinMode(bp_2, INPUT);
  pinMode(bp_3, INPUT);
  /*
    boolean etatbp1 = LOW;
    boolean etatbp2 = LOW;
    boolean etatbp3 = LOW;

    int bp_1 = LOW;
    int bp_2 = LOW;
    int bp_3 = LOW;
  */
}

const unsigned long permutationTime = 500; // temps de permutation de l'affichage

void loop()
{
  static bool chiffreAffiche[3] = {0};
  static unsigned long millisDebutAff = 0;
  static unsigned long millisPermutation = 0;
  static byte nAffichage;

  etatbp1 = digitalRead(bp_1); // on memorise l'etat des bp
  etatbp2 = digitalRead(bp_2);
  etatbp3 = digitalRead(bp_3);

  if (etatbp1 == HIGH)
  {
    chiffreAffiche[0] = true;
    millisDebutAff = millis();
  }
  else if (etatbp2 == HIGH)
  {
    chiffreAffiche[1] = true;
    millisDebutAff = millis();
  }
  else if (etatbp3 == HIGH)
  {
    chiffreAffiche[2] = true;
    millisDebutAff = millis();
  }

  if (millis() - millisPermutation >= permutationTime)
  {
    millisPermutation = millis();
    // recherche le chiffre suivant à afficher
    for (byte i = 0; i < 3; i++)
    {
      nAffichage = (nAffichage + 1) % 3;
      if (chiffreAffiche[nAffichage])
        break;
    }
    if (chiffreAffiche[nAffichage])
    {
      switch (nAffichage)
      {
        case 0:
          allume1();
          break;
        case 1:
          allume2();
          break;
        case 2:
          allume3();
          break;
      }
    }
  }

  if (millis() - millisDebutAff > time)
  {
    for (byte i = 0; i < 3; i++)
      chiffreAffiche[i] = false;
    eteind();
  }
}

void allume1()
{
  digitalWrite(led1A, LOW);
  digitalWrite(led1B, HIGH);
  digitalWrite(led1C, HIGH);
  digitalWrite(led1D, LOW);
  digitalWrite(led1E, LOW);
  digitalWrite(led1F, LOW);
  digitalWrite(led1G, LOW);
}

void allume2()
{
  digitalWrite(led1A, HIGH);
  digitalWrite(led1B, HIGH);
  digitalWrite(led1C, LOW);
  digitalWrite(led1D, HIGH);
  digitalWrite(led1E, HIGH);
  digitalWrite(led1F, LOW);
  digitalWrite(led1G, HIGH);
}

void allume3()
{
  digitalWrite(led1A, HIGH);
  digitalWrite(led1B, HIGH);
  digitalWrite(led1C, HIGH);
  digitalWrite(led1D, HIGH);
  digitalWrite(led1E, LOW);
  digitalWrite(led1F, LOW);
  digitalWrite(led1G, HIGH);
}

void eteind()
{
  digitalWrite(led1A, LOW);
  digitalWrite(led1B, LOW);
  digitalWrite(led1C, LOW);
  digitalWrite(led1D, LOW);
  digitalWrite(led1E, LOW);
  digitalWrite(led1F, LOW);
  digitalWrite(led1G, LOW);
  //  digitalWrite(hp1, LOW);
}

: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.
:slight_smile: :slight_smile: :slight_smile:

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

fig12.gif

fig12.gif

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.

se weekend j ai fait ca au niveau schemas electrique est ce que ca parai coherent?

j ai 11 bp avec led, 6 afficheur multiplexer (en fait chaque segments est en parralelle ,sur des grosses resistance (150 Ohms 5W), 6 buzzer,

quest ce que vous en pensez?

sauvegarde 11bp CENTRALISER.pdf (127 KB)

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.

Exemple de multiplexage (source)

salut
concernant les resistance de 100 ohms sur les bp j ai pris l exemple pull up ici