lego et arduino V2

**fredo du 45** · 08/08/2021, 22h34

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 :

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

**Jay M** · 09/08/2021, 22h37

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

https://www.developpez.net/forums/d2.../arduino-lego/

**fredo du 45** · 09/08/2021, 22h40

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

**fredo du 45** · 10/08/2021, 09h38

Bonjour,

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

Bonne journée

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

**Jay M** · 10/08/2021, 22h08

gestionLed() semble gérer le lance flamme?

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

Code :

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

    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 :

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

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

Code :

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

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

Code :

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

        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.

**fredo du 45** · 11/08/2021, 16h59

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

**Jay M** · 11/08/2021, 17h44

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

**fredo du 45** · 11/08/2021, 17h48

Merci pour le retour.
Je vais tenter comme cela.

**Jay M** · 11/08/2021, 18h26

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 :

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

lego et arduino V2

Arduino

Vue hybride

Discussions similaires

Partager

Partager