Déclenchement aléatoire

Bonjour à tous

ma demande pourrait paraitre bizarre mais pour le boulot j'aurai besoin de créer un code qui permettrait à chaque impulsion (BP, boucle sèche) sur une entrée de générer un nombre aléatoire qui n'activerait une sortie (relayée) que quand on tombe sur le chiffre "gagnant"

ex: fourchette de chiffre entre 1 et 200
nombre "gagnant" : 12

j'ai pu créer le code suivant sur Tinkercad. il fonctionne en théorie sauf qu'il me génère plusieurs nombre à chaque impulsion (je n'en ai pas forcement besoin) et une fois la prog transversée dans le uno plus rien ne fonctionne. mon relai de sortie ne fait que claquer

int passage = 0;

void setup()
{
  pinMode(2, INPUT);
  Serial.begin(9600);

  pinMode(13, OUTPUT);
}

void loop()
{
  if (digitalRead(2) == HIGH) {
    passage = random(1, 1000 + 1);
    Serial.println(passage);
    if (passage == 2) {
      digitalWrite(13, HIGH);
      delay(5000); // Wait for 5000 millisecond(s)
      digitalWrite(13, LOW);
    }
  }
}

je suis tout nouveau dans la prog de arduino. merci pour les coups de pouces

SVP : Lire les recommandations listées dans "Les bonnes pratiques du Forum Francophone”, éditer le message (icône crayon) et mettre le code entre balises.

1 Like

comment avez vous câblé le bouton? il y a un pull-down externe ?
le delay ne se fait que si vous avez trouvé le bon chiffre, sinon la loop() boucle et le bouton est toujours HIGH donc un nouveau chiffre aléatoire est généré

il faut attendre le relâchement du bouton si vous n'avez pas tiré le bon chiffre

un truc comme cela (tapé ici donc non testé)

const byte pinBouton = 2;
const byte pinLED  = 13;
const int passageGagnant = 2;

void setup() {
  pinMode(pinBouton, INPUT);      // PULL DOWN externe
  pinMode(pinLED, OUTPUT);
  Serial.begin(115200);           // pas la peine d'aller lentement
}

void loop() {
  if (digitalRead(pinBouton) == HIGH) {
    int passage = random(1, 1000 + 1);
    Serial.println(passage);
    if (passage == passageGagnant) {
      digitalWrite(pinLED, HIGH);
      delay(5000);                          // attente de 5s
      digitalWrite(pinLED, LOW);
    }
    while (digitalRead(pinBouton) == HIGH); // attente relâchement bouton
    delay(15);                              // anti rebond
  }
}

Bonjour

le bouton est câblé en pull-up
avant que ca ne "bugge" le câblage en pull-down ne fonctionnait pas

je vais tester le code merci

si le bouton est câblé en pullup, il passe à LOW lors d'un appui...

(et vous pourriez utiliser le pullup interne dans ce cas, pas besoin de résistance externe)

postez un schéma de votre câblage

(attention dans mon code j'ai mis la console série à 115200 bauds, pas la peine d'aller à 9600...)

Bravo !!

du premier coup
j'ai passé le moniteur a 115200 et je vois le chiffre qui s'affiche
j'ai réduit un peu la fourchette pour vérifier le fonctionnement et c'est OK
un appui un peu plus long sur le bouton génère 2 nombre au lieu d'un mais rien de méchant

voulez vous quand même voir le câblage ?

ça parait louche avec un pulldonwn

1 Like

j'étais câblé en pullup. j'ai essayé en pulldown on dirait que ca fonctionne mieux.
j'ai recâblé en pullup et ca ne l'a pas refait sur plusieurs essais.

je resterai en pulldown pour être sur

merci pour le coup de main

je pense que vous ne câblez pas correctement en pullup sinon le test
if (digitalRead(pinBouton) == HIGH) {
ne fonctionnerait pas pour détecter l'appui

Bonsoir

j'abuse encore un peu

si je souhaite gérer 2 fois le même mode aléatoire sur 2 entrées différentes qui une fois le nombre gagnant sorti active une sortie dédiée

ex :
2 => S11
E3 => S12

j'ai tenté de déclarer 2 entrées et 2 sorties mais je me retrouve avec soit une seule entrée qui fonctionne soit un tirage en boucle

je ne sais pas trop comment dissocier les 2 tirages

merci du coup de pouce

Postez votre code

const byte pinBouton1 = 2;
const byte pinLED1  = 11;
const int passageGagnant1 = 25;
const byte pinBouton2 = 3;
const byte pinLED2  = 12;
const int passageGagnant2 = 24;

void setup() {
  pinMode(pinBouton1, INPUT);      // PULL DOWN externe
  pinMode(pinLED1, OUTPUT);
  pinMode(pinBouton2, INPUT);      // PULL DOWN externe
  pinMode(pinLED2, OUTPUT);
  Serial.begin(115200);           
}

void loop() {
  if (digitalRead(pinBouton1) == HIGH) {
    int passage1 = random(1, 25 + 1);
    Serial.println(passage1);
    if (passage1 == passageGagnant1) {
      digitalWrite(pinLED1, HIGH);
      delay(5000);                          // attente de 5s
      digitalWrite(pinLED1, LOW);
    }
    while (digitalRead(pinBouton1) == HIGH); // attente relâchement bouton
    delay(15);                              // anti rebond
  }

  if (digitalRead(pinBouton2) == HIGH) {
    int passage2 = random(1, 25 + 1);
    Serial.println(passage2);
    if (passage2 == passageGagnant2) {
      digitalWrite(pinLED2, HIGH);
      delay(5000);                          // attente de 5s
      digitalWrite(pinLED2, LOW);
    }
    while (digitalRead(pinBouton2) == HIGH); // attente relâchement bouton
    delay(15);                              // anti rebond
  }
}

Quel est le souci exactement ?

Une fois que vous appuyez sur un bouton vous êtes bloqué jusqu’à son relâchement

Bonjour

merci pour la réponse

je souhaiterai que chaque bouton allume la LED qui lui est associée sans aucun croisement
bp 1 : led 1
bp 2 : led 2
tout en conservant le mode aléatoire du tirage de la première prog

Ce n’est pas le cas?

Comment sont câblés les boutons et les leds?

non ça ne l'est pas

j'avoue qu'il faut que je regarde pour ne pas dire de bêtises

le bouton tel que sur le schéma et à la place du relai une LED en sortie reliée au GND