lego et arduino V2

Version imprimable

lego et arduino V2

Bonjour à tous,

Afin d'effectuer mon nouveau projet, je cale sur le soucis suivant :
- je voudrais faire en sorte d'avoir des canons qui tirent de temps en temps, et surtout pas tous en même temps.

j'utilise le programme suivant :

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
const byte pinlanceflamme = 5;
const byte pinCanon = 3;
const byte pinmarcheur = 6;
 
void gestionLed() {
  static unsigned long chronoLed;
  if (millis() - chronoLed >= 100) { // on change la LED toutes les 100ms
    analogWrite(pinlanceflamme , 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();
  }
}
 
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(500); // 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);
        digitalWrite(pinmarcheur, HIGH);
        chronoCanon = millis();
        etatCanon = enTir;
      }
      break;
 
    case enTir:
      if (millis() - chronoCanon >= 30) { // on allume le canon 0.5 secondes (500 ms)
        digitalWrite(pinCanon, LOW);
        digitalWrite(pinmarcheur, LOW);
        if (++nombreDeTirs >= 20) etatCanon = enInitialisation; // on a fini les 3 coups de canon
        else {
          duree = 15; // 1s entre 2 coups de canon consécutifs
          chronoCanon = millis();
          etatCanon = enAttente;
        }
      }
      break;
  }
}
 
void setup() {
 
  pinMode(pinlanceflamme, OUTPUT);
  pinMode(pinCanon, OUTPUT);
  pinMode(pinmarcheur, OUTPUT);
}
 
void loop() {
  gestionLed();
  gestionCanon();
}

Du coup la j'ai bien 2 canons qui s'illuminent mais en même temps.

je prévois d'en mettre 5 en tout, en plus du lance flamme.

Merci d'avance.

Bonne journée.

09/08/2021, 22h37
Jay M

C’est la suite du projet précédent?

https://www.developpez.net/forums/d2.../arduino-lego/
09/08/2021, 22h40
fredo du 45

Bonjour
Non c est un nouveau projet
Je pense avoir trouvé la solution
Je mettrai mon ébauche sur le site demain si c est possible de vérifier
Merci d avance

Bonjour,

voici le code utilisé, si quelqu'un voit une erreur merci de me le dire.

Bonne journée

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
const byte pinlanceflamme = 5;
const byte pinCanon = 3;
const byte pinmarcheur = 6;
const byte pindroid = 9;
const byte pinmissile = 10;
const byte pincanonvaisseau = 11;
 
void gestionLed() {
  static unsigned long chronoLed;
  if (millis() - chronoLed >= 100) { // on change la LED toutes les 100ms
    analogWrite(pinlanceflamme , 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();
  }
}
 
enum : byte {enInitialisation, enAttente, enTir} etatCanon = enInitialisation;
enum : byte {eninit2, attente2, tir2} etatmarcheur = eninit2;
enum : byte {eninit3, attente3, tir3} etatdroid = eninit3;
enum : byte {eninit4, attente4, tir4} etatmissile = eninit4;
enum : byte {eninit5, attente5, tir5} etatcanonvaisseau = eninit5;
 
void gestioncanonvaisseau() {
  static unsigned long chronoCanon5;
  static unsigned long duree5;
  static byte nombreDeTirs5;
 
  switch (etatmissile) {
    case eninit5:
      duree5 = 8000 + random(500); // on génére une attente aléatoire entre 5 et 10s
      chronoCanon5 = millis();
      etatcanonvaisseau = attente5;
      nombreDeTirs5 = 0;
      break;
 
    case attente5:
      if (millis() - chronoCanon5 >= duree5) { // l'attente est finie
        digitalWrite(pincanonvaisseau, HIGH);
        chronoCanon5 = millis();
        etatcanonvaisseau = tir5;
      }
      break;
 
    case tir5:
      if (millis() - chronoCanon5 >= 30) { // on allume le canon 0.5 secondes (500 ms)
        digitalWrite(pincanonvaisseau, LOW);
        if (++nombreDeTirs5 >= 20) etatcanonvaisseau = eninit5; // on a fini les 3 coups de canon
        else {
          duree5 = 15; // 1s entre 2 coups de canon consécutifs
          chronoCanon5 = millis();
          etatcanonvaisseau = attente5;
        }
      }
      break;
  }
  }
 
void gestionmissile() {
  static unsigned long chronoCanon4;
  static unsigned long duree4;
  static byte nombreDeTirs4;
 
  switch (etatmissile) {
    case eninit4:
      duree4 = 8000 + random(300); // on génére une attente aléatoire entre 5 et 10s
      chronoCanon4 = millis();
      etatmissile = attente4;
      nombreDeTirs4 = 0;
      break;
 
    case attente4:
      if (millis() - chronoCanon4 >= duree4) { // l'attente est finie
        digitalWrite(pinmissile, HIGH);
        chronoCanon4 = millis();
        etatmissile = tir4;
      }
      break;
 
    case tir4:
      if (millis() - chronoCanon4 >= 30) { // on allume le canon 0.5 secondes (500 ms)
        digitalWrite(pinmissile, LOW);
        if (++nombreDeTirs4 >= 20) etatmissile = eninit4; // on a fini les 3 coups de canon
        else {
          duree4 = 15; // 1s entre 2 coups de canon consécutifs
          chronoCanon4 = millis();
          etatmissile = attente4;
        }
      }
      break;
  }
  }
void gestiondroid() {
  static unsigned long chronoCanon3;
  static unsigned long duree3;
  static byte nombreDeTirs3;
 
  switch (etatdroid) {
    case eninit3:
      duree3 = 5000 + random(100); // on génére une attente aléatoire entre 5 et 10s
      chronoCanon3 = millis();
      etatdroid = attente3;
      nombreDeTirs3 = 0;
      break;
 
    case attente3:
      if (millis() - chronoCanon3 >= duree3) { // l'attente est finie
        digitalWrite(pindroid, HIGH);
        chronoCanon3 = millis();
        etatdroid = tir3;
      }
      break;
 
    case tir3:
      if (millis() - chronoCanon3 >= 30) { // on allume le canon 0.5 secondes (500 ms)
        digitalWrite(pindroid, LOW);
        if (++nombreDeTirs3 >= 20) etatdroid = eninit3; // on a fini les 3 coups de canon
        else {
          duree3 = 15; // 1s entre 2 coups de canon consécutifs
          chronoCanon3 = millis();
          etatdroid = attente3;
        }
      }
      break;
  }
}
void gestionmarcheur() {
  static unsigned long chronoCanon2;
  static unsigned long duree2;
  static byte nombreDeTirs2;
 
  switch (etatmarcheur) {
    case eninit2:
      duree2 = 5000 + random(200); // on génére une attente aléatoire entre 5 et 10s
      chronoCanon2 = millis();
      etatmarcheur = attente2;
      nombreDeTirs2 = 0;
      break;
 
    case attente2:
      if (millis() - chronoCanon2 >= duree2) { // l'attente est finie
        digitalWrite(pinmarcheur, HIGH);
        chronoCanon2 = millis();
        etatmarcheur = tir2;
      }
      break;
 
    case tir2:
      if (millis() - chronoCanon2 >= 30) { // on allume le canon 0.5 secondes (500 ms)
        digitalWrite(pinmarcheur, LOW);
        if (++nombreDeTirs2 >= 20) etatmarcheur = eninit2; // on a fini les 3 coups de canon
        else {
          duree2 = 15; // 1s entre 2 coups de canon consécutifs
          chronoCanon2 = millis();
          etatmarcheur = attente2;
        }
      }
      break;
  }
}
void gestionCanon() {
  static unsigned long chronoCanon;
  static unsigned long duree;
  static byte nombreDeTirs;
 
  switch (etatCanon) {
    case enInitialisation:
      duree = 5000 + random(500); // 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 >= 30) { // on allume le canon 0.5 secondes (500 ms)
        digitalWrite(pinCanon, LOW);
 
        if (++nombreDeTirs >= 20) etatCanon = enInitialisation; // on a fini les 3 coups de canon
        else {
          duree = 15; // 1s entre 2 coups de canon consécutifs
          chronoCanon = millis();
          etatCanon = enAttente;
        }
      }
      break;
  }
}
 
void setup() {
 
  pinMode(pinlanceflamme, OUTPUT);
  pinMode(pinCanon, OUTPUT);
  pinMode(pinmarcheur, OUTPUT);
  pinMode(pindroid, OUTPUT);
  pinMode(pinmissile, OUTPUT);
  pinMode(pincanonvaisseau, OUTPUT);
}
 
void loop() {
  gestionLed();
  gestionCanon();
  gestionmarcheur();
  gestiondroid();
  gestionmissile();
  gestioncanonvaisseau();
}

10/08/2021, 22h08
Jay M

gestionLed() semble gérer le lance flamme?

Je ne comprends pas trop cela (surtout le commentaire explique pourquoi c'est un peu bizarre)

Code:

analogWrite(pinlanceflamme , 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é

les commentaires ne sont plus à jour

Code:

duree = 5000 + random(500); // on génére une attente aléatoire entre 5 et 10s

Code:

if (millis() - chronoCanon >= 30) { // on allume le canon 0.5 secondes (500 ms)

Code:

if (++nombreDeTirs >= 20) etatCanon = enInitialisation; // on a fini les 3 coups de canon

...

il n'y a pas besoin de tous ces enums. Il suffirait d'un seul énum et de plusieurs variables, une pour chaque arme.

ça fait beaucoup de duplication de code et vous n'avez aucune garantie qu'ils ne tireront pas en même temps (mais bon l'aléatoire devrait rendre cela peu probable)

idéalement une structure (ou une classe) qui décrit une arme et une seule fonction de gestion du tir vous permettrait de ne pas faire toute cette duplication de code.
11/08/2021, 16h59
fredo du 45

Bonjour

Je suis parti sur la base du programme que vous m aviez fait pour l autre lego, c est pour cela que les commentaires ne sont pas à jour.
Gestionled commande effectivement le lance flamme.
Je pensais jouer sur le random afin d avoir des tirs aléatoires.
Bonne journée
11/08/2021, 17h44
Jay M

OK, ça peut le faire.
si vous aviez 10 armes de plus ce serait beaucoup de travail de dupliquer toutes les fonctions...
c'est pour cela qu'on essaye plutôt de factoriser les choses
11/08/2021, 17h48
fredo du 45

Merci pour le retour.
Je vais tenter comme cela.

Tenez j'ai tapé cela un peu vite fait en faisant des copier coller. il suffit de configurer nos armes dans le tableau lesArmes. C'est l'intérêt de la programmation orientée objet.
ça doit faire à peu près la même chose que votre code (sauf que j'ai mis des paramètres différents pour chacune des armes)

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
class Arme {
 
    enum t_etatArme : uint8_t {enInitialisation, enAttente, enTir};
 
  public:
    Arme(const char * nom, const uint8_t pin, const uint8_t nbCoups = 5, const uint32_t entre2Tirs = 15, const uint32_t entre2Rafales = 5000, const uint32_t dureeFlash = 30) :
      _nom(nom),
      _pin(pin),
      _nbCoups(nbCoups),
      _entre2Tirs(entre2Tirs),
      _entre2Rafales(entre2Rafales),
      _dureeFlash(dureeFlash)
    {
      etat = enInitialisation;
    }
 
    void begin() {
      pinMode(_pin, OUTPUT);
      chrono = -_entre2Rafales; // pour commencer à tirer plus vite
    }
 
    void gestionTir() {
      switch (etat) {
        case enInitialisation:
          duree = _entre2Rafales + random(_entre2Rafales);
          chrono = millis();
          etat = enAttente;
          nombreDeTirs = 0;
          break;
 
        case enAttente:
          if (millis() - chrono >= duree) { // l'attente est finie
            digitalWrite(_pin, HIGH);
            Serial.print(_nom);  Serial.println(" en tir");
            chrono = millis();
            etat = enTir;
          }
          break;
 
        case enTir:
          if (millis() - chrono >= _dureeFlash) { // on allume le canon 30ms
            digitalWrite(_pin, LOW);
 
            if (++nombreDeTirs >= _nbCoups) etat = enInitialisation; // on a fini la rafale
            else {
              duree = _entre2Tirs;
              chrono = millis();
              etat = enAttente;
            }
          }
          break;
      }
    }
 
  private:
    const char *  _nom;
    uint8_t       _pin;
    uint8_t       _nbCoups;
    uint32_t      _entre2Tirs;
    uint32_t      _entre2Rafales;
    uint32_t      _dureeFlash;
 
    t_etatArme etat;
    uint32_t chrono;
    uint32_t duree;
    uint8_t nombreDeTirs;
};
 
Arme lesArmes[] = {
  // nom,             pin,      nb Coups dans une rafale,   pause entre 2 Tirs d'une rafale,  pause min entre 2 rafales,  durée d'un flash
  { "Canon",          3,        1,                          0,                                5000,                        30},
  { "Lance Flamme",   5,        3,                          1000,                             5000,                       200},
  { "Marcheur",       6,        10,                         15,                               3000,                        20},
  { "Droid",          9,        20,                         20,                               5000,                        10},
  { "Missile",       10,        1,                          0,                                4000,                       100},
  { "Vaisseau",      11,        4,                          100,                              1000,                        50},
};
 
void setup() {
  Serial.begin(115200);
  Serial.println();
  for (auto && arme : lesArmes) arme.begin();
}
 
void loop() {
  for (auto && arme : lesArmes) arme.gestionTir();
}

vous voyez que c'est plus court. J'ai repris la fonction de gestion en gros telle qu'elle était et j'ai mis en variable un peu tous les paramètres que j'ai défini comme attributs des instances de la classe, comme cela chaque instance aura son comportement spécifique