Discussion :

[Jay M]

oui, comme dit précédemment si bpPresseAction(b); est suffisamment long alors il n'y a pas de souci.

Comme vous le dites, dans ce cas précis ce n'est pas nécessaire puisque s'il n'y a aucun moteur attaché, appeler plusieurs fois la fonction n'est pas un pb (ça ne fait rien) et s'il y en a au moins un on aura des attentes actives suffisamment longues pour gommer les rebonds d'appui. (pas sûr que le second delay(motEtatOnTemps); soit nécessaire, j'ai cru comprendre que le premier c'était le temps que l'aiguillage se déplace et ensuite on éteint la commande)

L'objectif est juste pédagogique puisque Jacques débute, mentionner qu'il faut tenir compte des rebonds dans les deux sens (cf sa remarque d'ailleurs). Vous l'aviez explicité pour le relâchement, l'idée était de rendre visible ce besoin aussi lors de l'appui et une façon générale simple de faire est de rajouter ce delay(20); avant et après l'attente active (voire delay(15); ça ne m'a jamais joué de mauvais tour avec mes boutons)

L'autre option qui me semble était l'intention inachevée de Jacques au départ (d'après le code posté) serait d'utiliser la bibliothèque de Thomas Ouellet Fredericks (bounce) pour gérer les boutons (Personnellement je préfère la biblio de @bricoleau du forum arduino qui a l'avantage d'être compacte et en français ou alors celle de Matthias Hertel (OneButton)).

==> ça permet de cacher toute cette complexité et de se concentrer sur le coeur de code, ce qui est sympathique quand on débute.


on a l'embarras du choix !

[jpbbricole]

Bonjour Jay M

L'autre option qui me semble était l'intention inachevée de Jacques au départ (d'après le code posté) serait d'utiliser la bibliothèque de Thomas Ouellet Fredericks (bounce) pour gérer les boutons (Personnellement je préfère la biblio de @bricoleau du forum arduino qui a l'avantage d'être compacte et en français ou alors celle de Matthias Hertel (OneButton)).

==> ça permet de cacher toute cette complexité et de se concentrer sur le coeur de code, ce qui est sympathique quand on débute.

On ne peut pas parler de complexité dans ce programme, au plus 4 lignes de code, pour traiter les rebonds! Mais c'est vrai, l'utilisation d'une bibliothèque comme celles que tu indiques c'est "plus classe", le problème, je n'ai pas trouvé comment les utiliser en tableau. J'ai trouvé une méthode pour la bibliothèque JC_Button, pour les autres? As-tu un truc pas trop alambiqué?

Cordialement
jpbbricole

[Jay M]

Bonjour @JP

On ne peut pas parler de complexité dans ce programme, au plus 4 lignes de code, pour traiter les rebonds!

certes, ce n'est pas la mer à boire dans les cas simples. Ca devient quand même un peu compliqué si on veut pouvoir gérer plusieurs boutons en parallèle et ne pas avoir à faire de l'attente active sur relâchement pour ne pas redéclencher.

Mais c'est vrai, l'utilisation d'une bibliothèque comme celles que tu indiques c'est "plus classe", le problème, je n'ai pas trouvé comment les utiliser en tableau. J'ai trouvé une méthode pour la bibliothèque JC_Button, pour les autres? As-tu un truc pas trop alambiqué?

Oui, il faut créer les éléments du tableau dynamiquement qui seront des pointeurs vers les objets (les instances de la classe, obtenus par appel à new).

Comme ce sont des pointeurs dans le tableau, on utilise l'opérateur -> au lieu du . (point) pour appeler des méthodes sur ces objets.

Voici un exemple avec la bibliothèque simpleBouton.h que je mentionnais plus haut et qui est en français !!

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
#include <simpleBouton.h>   // à télécharger sur  https://forum.arduino.cc/index.php?topic=375232.0
const byte pinBoutons[] = {2, 3, 4}; // mettre 3 boutons momentanés sur les pin 2,3 et 4. Câblage : pin---BP---GND.
const byte nombreDeBoutons = sizeof(pinBoutons) / sizeof(pinBoutons[0]);
 
simpleBouton* lesBoutons[nombreDeBoutons]; // notre tableau contenant tous les pointeurs vers les objets boutons
 
void appuiBouton(byte bp)
{
  Serial.print(F("Bouton sur pin#"));
  Serial.print(pinBoutons[bp]);
  Serial.println(F(" est enfoncé"));
}
 
void relacheBouton(byte bp)
{
  Serial.print(F("Bouton sur pin#"));
  Serial.print(pinBoutons[bp]);
  Serial.println(F(" est relâché"));
}
 
void setup()
{
  Serial.begin(115200);
  for (byte bp = 0; bp < nombreDeBoutons; bp++)
    lesBoutons[bp] = new simpleBouton(pinBoutons[bp]);  //  Débounce à 20ms par défaut sinon le passer en second paramètre
}
 
void loop()
{
  for (byte bp = 0; bp < nombreDeBoutons; bp++) {
    lesBoutons[bp]->actualiser();
    if (lesBoutons[bp]->vientDEtreEnfonce()) appuiBouton(bp);
    if (lesBoutons[bp]->vientDEtreRelache()) relacheBouton(bp);
  }
}

la loop est super simple à lire, on teste les boutons les uns après les autres et on affiche un message si un changement notable a eu lieu. La bibliothèque se charge du reste.

Dans le cas de Jacques par exemple on se fiche même de tester le relâchement, on ne s'intéresserait à faire un mouvement des aiguillages que lorsque la méthode vientDEtreEnfonce() répond vrai et donc le code

Code :

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

1
2
3
4
5
6
if (digitalRead(bp[b].port) == bpEtatPresse) {
  bpPresseAction(b);
  delay(20);  // Pour éviter les rebonds d’appui 
  while(digitalRead(bp[b].port) == bpEtatPresse) {}         // Attente du relâchement du bp
  delay(20);  // Pour éviter les rebonds au relachement
}

deviendrait

Code :

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

 if (lesBoutons[b]->vientDEtreEnfonce()) bpPresseAction(b);

C'est plus simple à lire et en plus on gagne l'asynchronicité: on peut maintenant tenir le bouton enfoncé et appuyer sur les autres ça va fonctionner

je vous laisse tester et j'espère que vous ne trouverez pas que la déclaration du tableau est trop "alambiquée" !


la Classe simpleBouton expose d'autres méthodes que vientDEtreEnfonce() ou vientDEtreRelache(), jetez un oeil dans son .h pour voir toutes les possibilités. Il y a aussi des exemples.

[jpbbricole]

Bonjour Jay M

Exactement ce que je cherchais, et c'est pas trop "alambiqué" merci!

Cordialement
jpbbricole

[Jay M]

Ça reste une 4ème possibilité techniquement dans la spécification du langage.cetait mon point et toujours bon de savoir que ça existe.

Les meilleurs pratiques sont souvent à géométrie variable. Merci de donner un lien vers vos standards institutionnels...

(même si j'y souscris sur le fond, la possibilité offerte par cette capacité peut rendre service spécifiquement quand on travaille sur petit micro-controlleurs avec peu de mémoire et ou parfois il faut faire de la gymnastique pour que ça rentre).

[Jay M]

ces boutons-poussoirs doivent actionner des moteurs nommés comme suit :
C1_V1 => G1, A1, A3 ;
C1_V2 => G1, A1, A4 ;
C2_V1 => B1, B3, A2, A3 ;
C2_V2 => B1, B3, A2, A4 ;
C2_V3 => B1, B4 ;
C3_V1 => B2, B3, A2, A3 ;
C3_V2 => B2, B3, A2, A4 ;
C3_V3 => B2, B4 ;

bonjour

A titre de curiosité, comment fonctionnent ces moteurs ? vous en avez deux par aiguillage on dirait, mécaniquement comment cela se passe-t-il ?

(ou est-ce qu'il n'y a en fait qu'un seul moteur et la pin active un certain sens ?)

[Jsiorat]

bonjour

A titre de curiosité, comment fonctionnent ces moteurs ? vous en avez deux par aiguillage on dirait, mécaniquement comment cela se passe-t-il ?

(ou est-ce qu'il n'y a en fait qu'un seul moteur et la pin active un certain sens ?)

Bonjour en ce WE encore ensoleillé !
ce sont des des moteurs à solénoïdes, c'est ce qu'il y a de plus simples : un côté droit, un côté gauche.
Achetés en Allemagne, chez TILLIGBAHN.

[Jsiorat]

Bonjour à toutes et tous (Toutes ? et pourquoi pas !)

Je vois que votre intérêt pour ma question est au plus haut niveau ! Je vois aussi les professionnels que vous êtes !
En vous lisant, en expérimentant vos réflexions, j'en apprends plus qu'en quelques semaines sur un banc de l'école.

jpbbricole :

Si j'ai bien compris ce code (du 19/09), ce tableau à 3 dimensions (bouton - pin utilisé - moteur D/G)

Code :

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

1
2
3
4
5
6
7
8
9
10
bpDefinition bp[] = {
{"C1_V1",  5, maG1_D, maA1_G, maA3_D, maNU},
{"C1_V2",  6, maG1_D, maA1_D, maA4_D, maNU},
{"C2_V1",  7, maB1_G, maB3_D, maA2_G, maA3_G},
{"C2_V2",  8, maB1_G, maB3_D, maA2_D, maA4_G},
{"C2_V3",  9, maB1_D, maB4_D, maNU, maNU},
{"C3_V1", 10, maB2_G, maB3_G, maA2_G, maA3_G},
{"C3_V2", 11, maB2_G, maB3_G, maA2_D, maA4_G},
{"C3_V3", 12, maB2_G, maB4_G, maNU, maNU},
};

il n'y a donc que 8 pins utilisés sur la mega 2560 ?
Les pins 22 à 52 sont donc libre. On peut donc les utiliser pour allumer des leds sur un tableau de commande qui va simuler le trajet défini par C1_V1, C1_V2, C2_V1 etc ...
je voudrais transposer ça sur une breakboard, c'est possible ? en remplaçant les maG1_D, maA1_G, maA3_D etc. par des LEDs pour en voir le fonctionnement et voir l'utilisation du moniteur série. je vais m'atteler à ça aujourd'hui même !

Cordialement, Jacques

[Jay M]

Bonjour en ce WE encore ensoleillé !
ce sont des des moteurs à solénoïdes, c'est ce qu'il y a de plus simples : un côté droit, un côté gauche.
Achetés en Allemagne, chez TILLIGBAHN.

Bonjour

Je ne les connais pas. Donc si je comprends bien il y a deux broches, si vous envoyez une impulsion sur une des deux broches ça bascule l’aiguillage dans son sens (droite ou gauche). Je suppose qu’il y a système d’électro aimant et un mécanisme de verrouillage ?

il n'y a donc que 8 pins utilisés sur la mega 2560 ?

non il en faut plus.

Les pins des aiguillages sont dans cette structure / tableaux

Code :

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

1
2
3
4
 motAigDefinition motAig = {
	{"G1 D", "A1 G", "A1 D", "A2 G", "A2 D", "A3 G", "A3 D", "A4 G", "A4 D", "B1 G", "B1 D", "B2 G", "B2 D", "B3 G", "B3 D", "B4 G", "B4 D"},
	{  22,     23,     24,     25,     26,     27,     28,     29,     30,     31,     32,     33,     34,     35,     36,     37,     38}
};

Vous n’avez besoin d’avoir le contrôle des 2 broches de chaque aiguillage qui si elles servent, ici G1-G sur le dessin ne sert à rien car ça enverrait le train hors des voies mais les autres sont nécessaires.

Et ensuite il vous faut les pins des boutons, ce sont les nombres de 5 à 12 dans cette définition de structure

Code :

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

1
2
3
4
5
6
7
8
9
10
 bpDefinition bp[] = {
{"C1_V1",  5, maG1_D, maA1_G, maA3_D, maNU},
{"C1_V2",  6, maG1_D, maA1_D, maA4_D, maNU},
{"C2_V1",  7, maB1_G, maB3_D, maA2_G, maA3_G},
{"C2_V2",  8, maB1_G, maB3_D, maA2_D, maA4_G},
{"C2_V3",  9, maB1_D, maB4_D, maNU, maNU},
{"C3_V1", 10, maB2_G, maB3_G, maA2_G, maA3_G},
{"C3_V2", 11, maB2_G, maB3_G, maA2_D, maA4_G},
{"C3_V3", 12, maB2_G, maB4_G, maNU, maNU},
};

chaque ligne de ce tableau décrit un cheminement. Par exemple la première dit que pour aller de C1 à la voie V1, ça se fait en appuyant sur le bouton relié à la pin 5. Lorsqu’il est activé il faut déclencher des impulsions sur 3 broches : maG1_D, maA1_G,p et maA3_D (l’entrée maNU est ignorée par le code).

maG1_D (Sans doute pour moteur aiguillage G1 Droite) est défini dans une énumération.

Code :

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

1
2
 enum motAigIndex 
{    maG1_D, maA1_G, maA1_D, maA2_G, maA2_D, maA3_G, maA3_D, maA4_G, maA4_D, maB1_G, maB1_D, maB2_G, maB2_D, maB3_G, maB3_D, maB4_G, maB4_D};

Les énumérations permettent d’avoir des jolis noms pour des constantes, elles prennent des valeurs croissantes dans la liste (0,1,2,3,...) donc maG1_D vaut 0, maA1_G vaut 1 etc.
@JP s’en sert pour faire un index dans le tableau des Nº de pins car elles sont rangées dans le même ordre. C’est ce qui permet d’envoyer la commande à la bonne pin.

Bref vous aurez des fils sur les pins 5 à 12 vers les boutons et 22 à 38 vers les aiguillages soit 25 pins utilisées.

——-

Je suppose que vos trains ne vont que des C vers les V sinon faudra faire attention à des configurations à risque

[Jsiorat]

quand je disais que vous étiez des chefs ...

Maintenant, j'ai compris ce fameux tableau et l'énumération !
Je vais essayer de transposer tout ça sur une "planche à pain " !!!

Pour palier le fait d'"aller dans le vide" , je pense qu'il faut refaire une initialisation de la gare à l’exception du trajet initialisé par le bouton appuyé.
Par contre, une question se pose : au cas ou l'appui sur un bouton a lieu à l'instant "T" ou une rame se trouve sur un aiguillage, l'aiguillage va changer de position ce qui risque de créer un déraillement. J'entrevois la solution d'une détection par led infrarouge située avant les aiguillages sur les circuits C1, C2 et C3. Il faut que je réfléchisse au problème !

Pour info, TILLIGBAHN, est une société allemande de trains miniature, spécialisée sur les échelles H0 (1/87) et TT (1/120)

Bonne journée.

[jpbbricole]

Bonjour Jacques

Bonjour à toutes et tous (Toutes ? et pourquoi pas !)

Il y en a, mais pas assez!

Si j'ai bien compris ce code (du 19/09), ce tableau à 3 dimensions (bouton - pin utilisé - moteur D/G)
====================
bpDefinition bp[] = {
{"C1_V1", 5, maG1_D, maA1_G, maA3_D, maNU},
{"C1_V2", 6, maG1_D, maA1_D, maA4_D, maNU},
....
il n'y a donc que 8 pins utilisés sur la mega 2560 ?

Pour résumer, il n'y a aucun changement de câblage entre ton programme de l'article #7. Le programme que je te propose ne fait que répondre à la question de cette discussion, "Effectuer une association entre deux tableaux", en "rangeant" le programme différemment. Il y a toujours 8 boutons (Pin en entrée) et 17 moteurs (Pin en sortie). Les pin des moteurs sont énumérées pas les noms maG1_D, maA1_G, maA3_D, maNU etc dans l'énumération enum motAigIndex cette énumération va de 0 (maG1_D) à 16 (maB4_D) donc 17 positions. Cette énumération permet de récupérer le numéro de port du moteur concerné par la fonction byte motAigPort = motAig.port[motAigIndex];.
Oui, je sais, c'est un peu alambiqué, mais tu t'y feras assez vite, mais c'est, à mon avis, le meilleur moyen de gérer ce type de programme qui est destiné à s'étendre assez rapidement, la preuve:

Les pins 22 à 52 sont donc libre. On peut donc les utiliser pour allumer des leds sur un tableau de commande qui va simuler le trajet défini par C1_V1, C1_V2, C2_V1 etc ...

Donc je te conseille de suivre ce que je te propose en fin de l'article #11 PS: Si ton pupitre est susceptible.....,
Pour ce qui est d'ajouter des LED de parcours, elles seront assez facilement intégrées à ce programme.

A+
Cordialement
jpbbricole

[Jsiorat]

Bonjour

Je suppose qu’il y a système d’électro aimant et un mécanisme de verrouillage ?

Je suppose que vos trains ne vont que des C vers les V sinon faudra faire attention à des configurations à risque

Effectivement, ça roule dans ce sens ... C1 vers V1, C2 vers V2 et C3 vers V3.

Après réflexion, je pense qu'il n'est pas nécessaire de réinitialiser la gare.
Toujours après réflexion, il ne faut pas que les électro aimant restent sous tension. Est-ce que, en fin de procédure, on peut utiliser "break" ?

Jacques

[jpbbricole]

Bonjour Jacques

Toujours après réflexion, il ne faut pas que les électro aimant restent sous tension. Est-ce que, en fin de procédure, on peut utiliser "break" ?

Ce n'est pas nécessaire, l'électro-aimant reçoit une impulsion de motEtatOnTemps millisecondes.

Code :

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

1
2
3
4
	digitalWrite(motAigPort, motEtatOn);       // Moteur ON
	delay(motEtatOnTemps);
	digitalWrite(motAigPort, !motEtatOn);      // Moteur NOT ON
	delay(motEtatOnTemps);

... allumer des leds sur un tableau de commande qui va simuler le trajet défini par C1_V1, C1_V2, C2_V1 etc ...

Vu que le nombre de LED va devenir conséquent, en plus du câblage des aiguilles, je te conseille d'utiliser des LED de type WS2812, ainsi, depuis ton Mega, tu n'as que le GND, VCC et Data (3 fils) qui "courent" d'une LED à l'autre. Ces LED peuvent prendre toutes les couleurs de l'arc-en-ciel, ainsi tu pourrais mettre une LED par aiguille qui serait verte pour gauche et rouge pour droite.

... allumer des leds sur un tableau de commande qui va simuler le trajet défini par C1_V1, C1_V2, C2_V1 etc ...
je voudrais transposer ça sur une breakboard, c'est possible ? en remplaçant les maG1_D, maA1_G, maA3_D etc. par des LEDs pour en voir

Oui, c'est comme ceci que j'ai testé mon programme, les LED s'allument le temps de motEtatOnTemps, mais c'est tout à fait visible.

A+
Cordialement
jpbbricole

[Guesset]

Bonjour,

ce sont des des moteurs à solénoïdes, c'est ce qu'il y a de plus simples : un côté droit, un côté gauche.
Achetés en Allemagne, chez TILLIGBAHN.

Si je comprends bien ce ne sont pas des moteurs rotatifs mais des barres aimantées glissant dans un solénoïde dans un sens ou l'autre selon le sens du courant. Une extrémité solidaire de l'aiguillage le commande directement. C'est simple et efficace.

Comment sont ils commandés ? Par un pont en H en circuit intégré ?

Salutations

[kaitlyn]

Le problème est que tout le reste est décalé depuis 39+1!!!!
Tu ne trouves pas que cela fait un peu château de cartes!!!
Je pourrais faire un C2V2=8, quelle gymnastique!!! Le simple tableau est nettement plus aisé et plus souple d'emploi?
Ne pas oublier qu'on est dans un forum où une grande partie des lecteurs/acteurs sont des débutants.

Bonjour jpbbricole,

L'illustration montrait le mode de fonctionnement de l'énumération, c'est-à-dire qu'un énumérateur a pour valeur celle du précédent + 1, et si le premier n'est pas explicitement initialisé, sa valeur sera de 0.

À partir de là, peuvent se présenter 3 cas possibles, normalisés sous forme de conventions de codage.

1: L'énumération est une suite (de +1) et elle commence à 0.
On laisse le compilateur faire l'initialisation.

Code C++ :

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

1
2
enum Etage {RDC, PREMIER, DEUXIEME, TROISIEME, QUATRIEME, DERNIER};
enum {OUVERT, FERME};

2: L'énumération est une suite (de +1) mais ne commence pas par 0.
On initialise manuellement le premier énumérateur, le compilateur fera le reste.

Code C++ :

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

enum Jour {LUNDI= 1, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI, DIMANCHE};

3: L'énumération nest pas complètement une suite.
On initialise explicitement tous les énumérateurs.

Code C++ :

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

1
2
3
4
5
6
7
8
enum Capteur {
    TEMPERATURE = 7,
    VITESSE = 8,
    PRESENCE = 32,
    PRESSION = 9,
    LUMIERE = 10,
    NIVEAU = 42,
}

L'énumération n'a pas pour objectif de remplacer le tableau, c'est un autre genre d'outil, ou plutôt l'énumération est un set d'outils car elle a de nombreuses applications possibles. Et quand elle est bien utilisée, elle peut apporter de la clarté et de la robustesse au code. Essaie d'en apprendre d'avantage à son sujet, tu décideras après si oui ou non elle a sa place dans ta caisse à outils.


Pour terminer, il faut savoir que je ne code pratiquement jamais. Là j'ai eu une occasion de m'exercer un peu, et je me suis contrainte à produire quelque chose d'accessible, dans le sens où tant qu'à le faire, si ça peut être utile, c'est mieux. L'accessibilité se jauge avec le niveau mais aussi la volonté, de ce point de vue, si tu fais abstraction des std::cout (car édition en ligne avec les moyens du bord) et du gestionnaire de bouton factice class Button, le reste ne t'est pas insurmontable. Aussi, le deuxième code apportait une réponse à ton interrogation sur l'intégration d'un objet dans un tableau.


Ainsi mes messages ne sont pas forcément destinés à l'auteur du sujet, parfois c'est plus une piste de réflexion, et en toute modestie, pour les intervenants. Le reste n'est qu'une question de choix, et de ce côté là je respecte chacun.


Désolée d'avoir semé le trouble dans votre discussion

[Jay M]

À partir de là, peuvent se présenter 3 cas possibles, normalisés sous forme de conventions de codage.

un 4ème cas pour être un peu plus précis: on n'est pas obligé de donner une valeur à tous les éléments, la règle du +1 par rapport au précédent s'applique alors pour les éléments non initialisés

si on fait tourner cela

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
enum : byte {a = 3, b, c, d = 22, e, f};
 
void setup() {
  Serial.begin(115200);
  Serial.println(a);
  Serial.println(b);
  Serial.println(c);
  Serial.println(d);
  Serial.println(e);
  Serial.println(f);
}
 
void loop() {}

le moniteur série dira

3
4
5
22
23
24

On voit que b et c ont pris les valeurs suivant celle donnée à a (3) alors que e et f ont pris les valeurs suivant celle donnée à d (22)

à noter que l'on peut aussi utiliser les éléments précédents dans des calculs pour définir une nouvelle valeur. Par exemple on peut écrire

Code :

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

enum : byte {a = 3, b, c, d = b+c, e, f};

[Jay M]

Oui - effectivement vous pouvez passer par une bibliothèque qui cache la mécanique. Elle fonctionne sur le même principe mais au lieu d’utiliser Timer 1 ils ont pris Timer 2.

Faut savoir alors ce qu’il se passe en dessous suivant les besoins du système:

- ils ont une interface conceptuelle de haut niveau avec une classe qui simplifie le développement (dans mon code c’est vous qui gérez à la main)
- Ils ont 100 niveaux de luminosité (Le code ci dessous n’en traite que 10)
- Ils gèrent 20 pins au Max (modifiable dans le code de la bibliothèque mais ça mange plus de mémoire même si vous n’utilisez pas les pins).
- comme ils prennent une fréquence d’interruption à 15.6kHz vous vous retrouvez à passer 20 à 30% du temps CPU dans leur interruption (Le code ci dessous n’est qu’à 500Hz donc 31 fois moins de pression sur le CPU)

[Jay M]

cool!
bonne continuation

(j'aime bien cette bibliothèque simpleBouton.h car elle est très optimisée sur l'usage mémoire)

[Jay M]

Salut JP

Bravo pour avoir poussé le boulot jusqu’au bout !

La fonction serialEvent() est appelée automatiquement pour vous comme la loop(). Normalement on ne la met donc pas dans le code (même si ça ne gène pas de l’appeler plus souvent).

Pourquoi avez vous un delay 250 et pourquoi rappeler ensuite le test de tous les boutons dans le if?il suffirait de tester les boutons les uns après les autres

Code :

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

1
2
3
4
5
6
 if (bpScanStatus())				   // S'il y a un bouton presse                             
	{
		delay(250);					   // Attendre d'eventuelles autres bp
		bpScanStatus();
		bpPressedAction();
	}

Je renouvelle mon alerte sur le nombre de String utilisées et toutes leurs mini modifications qui risquent de conduire à un morcellement de la mémoire. Pour le buffer de commande, rajouter un reserve() dans le setup avec disons 50 caractères serait une bonne chose. Passer les String par référence lors des appels de fonction serait aussi à considérer (sinon elles sont dupliquées).

Pour comprendre pourquoi c’est important d’y faire attention surtout sur un UNO ou MEGA, lisez The Evils of Arduino Strings

[Jay M]

Salut

super photo !

Notez qu'il existe des Leds bicolores (elles ont trois pattes) dont des rouge/vert ce qui permet d'avoir qu'une seule LED (on gagne un fil à câbler en moins par paire donc)


on en trouve en Asie par lot de 50 à moins de 2€

La carte Mega possède à mon avis, suffisamment de broches pour ça. Elle risque de bosser fortement !

ça devrait aller

A votre avis, une carte UNO peut elle commander une autre carte UNO ? ce qui(à mon avis), diminuerai les risques de flashage ! On pourrai dans ce cas, lancer le programme SoftPWM sur une carte spécifique.

Oui c'est possible mais ça rend encore plus complexe votre développement. ce n'est pas nécessaire à ce stade et je pense que le risque est limité. Si vous voulez partir sur une carte supplémentaire, il existe des composants qui font directement du PWM pour vous (16 sorties, on peut chaîner les cartes) avec une bibliothèque Arduino adapté et donc ça enlèverait le besoin de SoftPWM et pas besoin de développement d'un protocole de communication entre les 2 Arduinos

Seule interrogation, quand on utilise cette bibliothèque, est-ce que la différence est bien faite entre les broches qui vont être traitées en PWM et le autres broches ?

la bibliothèque SoftPWM ne distingue pas les pin en PWM. elle les traite toutes de la même façon (en non PWM) - en gérant elle même l'allumage et extinction des LEDs (en vérifiant plus de 15000 fois par seconde s'il faut le faire)

Bon dimanche à tous.
Je vais au jardin !!!

profitez, il commence à pleuvoir là où je suis !