Discussion :

[fredo du 45]

Bonjour,

Je viens vers vous car je bloque sur un programme pour des lego, en effet, j'ai besoin d'avoir en même temps un effet flamme et un moteur pas à pas qui tourne et la ca na marche pas.

Voici ce que j'ai taper.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <Stepper.h>
 
// Définir le nombre de pas par tour
int LED = 3;
int NbrPas = 200; 
 
Stepper MonMoteur(NbrPas, 8, 9, 10, 11);
 
 
void setup() {
  // Vitesse à 60 tours/min
  MonMoteur.setSpeed(60);
 
  Serial.begin(9600);
  pinMode(LED, OUTPUT);
}
void loop() {
 
 
  analogWrite(LED , random(120)+250);
delay(random(100));
 
  Serial.println("Sens 1");
  MonMoteur.step(NbrPas);
  delay(100);
}

merci de votre retour

[Jay M]

Bonjour

Il faut enlever le delay() et ne pas demander 200 pas - c’est bloquant - faites en un seul et la prochaine loop fera le pas d’après

Si la led varie trop vite il faut utiliser millis() pour la mettre à jour toutes les x millisecondes (cf l’exemple blink without delay)

(Sinon la bibliothèque accelstepper permet de faire bouger un moteur pas à pas sous forme d’un appel non bloquant)

[fredo du 45]

merci pour votre retour, je vais essayer de suite.

[Jay M]

un bout de code comme cela

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <Stepper.h>
 
// Définir le nombre de pas par tour
const byte pinLED = 3;
Stepper monMoteur(200, 8, 9, 10, 11);
 
unsigned long chronoLed;
unsigned long chronoMoteur;
 
void setup() {
  monMoteur.setSpeed(2000); // mettre une grande valeur
  pinMode(pinLED, OUTPUT);
}
 
void loop() {
  if (millis() - chronoLed >= 100) { // on change la LED toutes les 100ms
    analogWrite(pinLED , random(120) + 250); // notez que l'on passe normalement une valeur entre 0 et 255 donc random(120) + 250 va déborder et être tronqué
    chronoLed = millis();
  }
  if (millis() - chronoMoteur >= 5) { // on fait un pas toutes les 5 ms (200 pas x 5 ms = 1s == 1 tour par seconde)
    monMoteur.step(1);
    chronoMoteur = millis();
  }
}

vous permet de gérer les timing séparément pour la LED et le moteur pas à pas

AccelStepper vous permettrait de contrôler tout cela plus finement

[fredo du 45]

Super,

c'est impeccable merci beaucoup.

[Jay M]

pour répondre à votre MP, rajouter des traitements c'est simplement rajouter un peu de gestion, le tout est de ne pas bloquer la boucle. par exemple si un bouton doit allumer le laser pendant 1 seconde après relâchement du bouton (câblé en pullup interne donc pin -- bouton -- GND) vous pouvez faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <Stepper.h>
 
// Définir le nombre de pas par tour
const byte pinLED = 3;
const byte pinLaser = 4;
const byte pinBouton = 5;
Stepper monMoteur(200, 8, 9, 10, 11);
 
void gestionLed() {
  static unsigned long chronoLed;
  if (millis() - chronoLed >= 100) { // on change la LED toutes les 100ms
    analogWrite(pinLED , random(120) + 250); // notez que l'on passe normalement une valeur entre 0 et 255 donc random(120) + 250 va déborder et être tronqué
    chronoLed = millis();
  }
}
 
void gestionMoteur() {
  static unsigned long chronoMoteur;
  if (millis() - chronoMoteur >= 5) { // on fait un pas toutes les 5 ms (200 pas x 5 ms = 1s == 1 tour par seconde)
    monMoteur.step(1);
    chronoMoteur = millis();
  }
}
 
void gestionLaser() {
  static unsigned long chronoLaser;
  static bool laserON = false;
  if (digitalRead(pinBouton) == LOW) { // bouton appuyé
    digitalWrite(pinLaser, HIGH);
    laserON = true;
    chronoLaser = millis();
  } else {
    if (laserON && (millis() - chronoLaser >= 1000)) { // on conserve le laser allumé 1s après le relâchement du bouton
      digitalWrite(pinLaser, LOW);
      laserON = false;
    }
  }
}
 
void setup() {
  monMoteur.setSpeed(2000); // mettre une grande valeur
  pinMode(pinLED, OUTPUT);
  pinMode(pinLaser, OUTPUT);
  pinMode(pinBouton, INPUT_PULLUP);
}
 
void loop() {
  gestionLed();
  gestionMoteur();
  gestionLaser();
}

[fredo du 45]

Je reviens vers vous, le code fonctionne très bien pour ce que je veux faire, par contre j'ai voulu rajouter un élément type canon.

J'arrive a le faire clignoter sans souci, par contre je n'arrive pas a trouver la solution pour le mettre en pose en certain temps avant qu'il recommence à tirer.

si vous avez des idées.

voici le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
 #include <Stepper.h>
 
// Définir le nombre de pas par tour
 
 
const byte pinLED = 3;
const byte ledcanon = 5;
Stepper monMoteur(200, 8, 9, 10, 11);
 
 
 
unsigned long chronoLed;
unsigned long chronoMoteur;
unsigned long chronoOn;
 
void setup() {
  monMoteur.setSpeed(2000); // mettre une grande valeur
  pinMode(pinLED, OUTPUT);
  pinMode(ledcanon, OUTPUT);
 
}
 
void loop() {
  if (millis() - chronoLed >= 100) { // on change la LED toutes les 100ms
    analogWrite(pinLED , random(120) + 250); // notez que l'on passe normalement une valeur entre 0 et 255 donc random(120) + 250 va déborder et être tronqué
    chronoLed = millis();
  }
  if (millis() - chronoMoteur >= 5) { // on fait un pas toutes les 5 ms (200 pas x 5 ms = 1s == 1 tour par seconde)
    monMoteur.step(1);
    chronoMoteur = millis();
  }
  if (millis() - chronoOn >= 20) { 
    digitalWrite(ledcanon , 255); 
    chronoOn = millis();          
 }
 if (millis() - chronoOn >= 20) { 
    digitalWrite(ledcanon , 0); 
    chronoOn = millis();        
 }
 
 }

merci d'avance

[fredo du 45]

le but étant de ne pas passer par un bouton, mais par un système automatique car après il est en vitrine

merci

[Jay M]

OK, le principe reste le même, il suffit de définir quel est l'événement qui doit déclencher le laser (par exemple un coup de la Laser toutes les x secondes ou x est aléatoire?) et de coder cela

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include <Stepper.h>
 
// Définir le nombre de pas par tour
const byte pinLED = 3;
const byte pinCanon = 4;
Stepper monMoteur(200, 8, 9, 10, 11);
 
void gestionLed() {
  static unsigned long chronoLed;
  if (millis() - chronoLed >= 100) { // on change la LED toutes les 100ms
    analogWrite(pinLED , random(120) + 250); // notez que l'on passe normalement une valeur entre 0 et 255 donc random(120) + 250 va déborder et être tronqué
    chronoLed = millis();
  }
}
 
void gestionMoteur() {
  static unsigned long chronoMoteur;
  if (millis() - chronoMoteur >= 5) { // on fait un pas toutes les 5 ms (200 pas x 5 ms = 1s == 1 tour par seconde)
    monMoteur.step(1);
    chronoMoteur = millis();
  }
}
 
enum : byte {enInitialisation, enAttente, enTir} etatCanon = enInitialisation;
void gestionCanon() {
  static unsigned long chronoCanon;
  static unsigned long duree;
 
  switch (etatCanon) {
    case enInitialisation:
      duree = 5000 + random(5000); // on génére une attente aléatoire entre 5 et 10s
      chronoCanon = millis();
      etatCanon = enAttente;
      break;
 
    case enAttente:
      if (millis() - chronoCanon >= duree) { // l'attente est finie
        digitalWrite(pinCanon, HIGH);
        chronoCanon = millis();
        etatCanon = enTir;
      }
      break;
 
    case enTir:
      if (millis() - chronoCanon >= 500) { // on allume le canon 0.5 secondes (500 ms)
        digitalWrite(pinCanon, LOW);
        etatCanon = enInitialisation;
      }
      break;
  }
}
 
void setup() {
  monMoteur.setSpeed(2000); // mettre une grande valeur
  pinMode(pinLED, OUTPUT);
  pinMode(pinCanon, OUTPUT);
}
 
void loop() {
  gestionLed();
  gestionMoteur();
  gestionCanon();
}

ici il y a une petite machine à état qui
- calcule une attente aléatoire entre 5 et 10s
- effectue l'attente
- effectue le tir (canon allumé pour 1/2 s)
- et on recommence


(j'ai tapé le code ici, donc sans garantie)

[fredo du 45]

Merci
Je vais essayer

[fredo du 45]

j'ai pu tester juste la led du canon, cela permet à la led de clignoter.
Juste une question peux ton dans la boucle eta canon travailler avec delay ou cela va t'il bloquer le système.
car le final que je recherche c'est d'avoir un canon qui tir 3 fois de suite et qui ce met en pose pendant environ 1 minute et qui reprend son tir.

merci

[Jay M]

si vous mettez un delai ça bloque.

Si vous voulez que le canon tire trois fois de suite, on peut rajouter cela dans l'état 'enTir' en comptant le nombre de tirs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include <Stepper.h>
 
// Définir le nombre de pas par tour
const byte pinLED = 3;
const byte pinCanon = 4;
Stepper monMoteur(200, 8, 9, 10, 11);
 
void gestionLed() {
  static unsigned long chronoLed;
  if (millis() - chronoLed >= 100) { // on change la LED toutes les 100ms
    analogWrite(pinLED , random(120) + 250); // notez que l'on passe normalement une valeur entre 0 et 255 donc random(120) + 250 va déborder et être tronqué
    chronoLed = millis();
  }
}
 
void gestionMoteur() {
  static unsigned long chronoMoteur;
  if (millis() - chronoMoteur >= 5) { // on fait un pas toutes les 5 ms (200 pas x 5 ms = 1s == 1 tour par seconde)
    monMoteur.step(1);
    chronoMoteur = millis();
  }
}
 
enum : byte {enInitialisation, enAttente, enTir} etatCanon = enInitialisation;
void gestionCanon() {
  static unsigned long chronoCanon;
  static unsigned long duree;
  static byte nombreDeTirs;
 
  switch (etatCanon) {
    case enInitialisation:
      duree = 5000 + random(5000); // on génére une attente aléatoire entre 5 et 10s
      chronoCanon = millis();
      etatCanon = enAttente;
      nombreDeTirs = 0;
      break;
 
    case enAttente:
      if (millis() - chronoCanon >= duree) { // l'attente est finie
        digitalWrite(pinCanon, HIGH);
        chronoCanon = millis();
        etatCanon = enTir;
      }
      break;
 
    case enTir:
      if (millis() - chronoCanon >= 500) { // on allume le canon 0.5 secondes (500 ms)
        digitalWrite(pinCanon, LOW);
        if (++nombreDeTirs >= 3) etatCanon = enInitialisation; // on a fini les 3 coups de canon
        else {
          duree = 1000; // 1s entre 2 coups de canon consécutifs
          chronoCanon = millis();
          etatCanon = enAttente;
        }
      }
      break;
  }
}
 
void setup() {
  monMoteur.setSpeed(2000); // mettre une grande valeur
  pinMode(pinLED, OUTPUT);
  pinMode(pinCanon, OUTPUT);
}
 
void loop() {
  gestionLed();
  gestionMoteur();
  gestionCanon();
}

[fredo du 45]

super, merci beaucoup, c'est exactement ce qu'il me fallait.

bonne journée.

[Jay M]

Cool

N’hésitez pas à poster une petite vidéo du résultat !!

[fredo du 45]

Pas de soucis encore un petit mois pour finir le montage des lego.
Je reviendrai vers vous avec plaisir

[fredo du 45]

Et voici le résultat.

encore merci à Jay M

[Jay M]

Magique !!!