arduino et lego

Version imprimable

arduino et lego

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:

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

12/04/2021, 10h37
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)
12/04/2021, 10h43
fredo du 45

merci pour votre retour, je vais essayer de suite.

un bout de code comme cela

Code:

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

12/04/2021, 14h16
fredo du 45

Super,

c'est impeccable merci beaucoup.

:applo:

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:

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();
}

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:

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

14/04/2021, 12h15
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

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:

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)

14/04/2021, 12h47
fredo du 45

Merci
Je vais essayer
14/04/2021, 14h12
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

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:

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();
}

14/04/2021, 19h15
fredo du 45

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

bonne journée.
14/04/2021, 23h02
Jay M

Cool

N’hésitez pas à poster une petite vidéo du résultat !!
14/04/2021, 23h14
fredo du 45

Pas de soucis encore un petit mois pour finir le montage des lego.
Je reviendrai vers vous avec plaisir
07/05/2021, 21h35
fredo du 45

Et voici le résultat.

encore merci à Jay M

https://www.youtube.com/watch?v=pGlQ1mjJC70
08/05/2021, 00h57
Jay M

Magique !!!