Voir les contributions

Cette section vous permet de consulter les contributions (messages, sujets et fichiers joints) d'un utilisateur. Vous ne pourrez voir que les contributions des zones auxquelles vous avez accès.


Messages - bricoleau

Pages: 1 2 3 [4]
46
Vos projets / Contrôle numérique des aiguillages
« le: janvier 12, 2016, 11:03:12 pm »
Bonjour

Voici le petit chantier qui m’occupe actuellement, sur lequel j’aimerais bien recueillir vos avis éclairés  :D

Commençons d’abord par préciser que je n’ai aucun réseau à la maison, ni aucune expérience du modélisme ferroviaire. Mais j’ai d’autres compétences et centres d’intérêt qui font que je commence à maîtriser un peu arduino et ce qui gravite autour.

Un ami m’a demandé de lui filer un coup de main pour passer son réseau (courant continu) en commande numérique. Il dispose d’une quinzaine d’aiguillages électriques de type jouef, ainsi que quelques dételeurs, qu’il souhaite commander par ordinateur, ou par une centrale qu’il se fabriquera.

On n’est clairement pas dans du modélisme haut de gamme et dispendieux.
Du coup, pour rester dans la même philosophie, mon objectif était de lui proposer une solution bon marché. Suite à la lecture de plusieurs articles très intéressants sur locoduino, je suis parti sur la création de modules de commande d’aiguillages.

Chaque module a 8 sorties, pour gérer 4 aiguillages simples.
Il est constitué d’une arduino pro mini et deux ULN2803, dont les sorties sont couplées deux à deux pour être en mesure de fournir jusqu'à 1A aux bobines de l'aiguillage, bien que j’ai quelques doutes sur la pertinence de ce montage. L’expérience dira si cela tient la route longtemps.
Le tout est assemblé à la main, soudé sur une plaque de prototypage pastillée, avec une connectique de type bornier à vis côté 12V/Aiguillages.

L’arduino pro mini fonctionne comme un périphérique escale I2C. Les modules pourront être branchés en cascade, chacun ayant sa propre adresse I2C. Le tout devra être piloté par une centrale. Une foultitude d’options est possible à ce niveau-là, à affiner plus tard.

Je suis actuellement en phase de réalisation du premier prototype. Mon objectif initial est atteint : le coût matériel d’un module est de moins de 4€ frais de port compris, soit moins de 1€ par aiguillage à commander. Evidemment, il s’agit de composants achetés en ligne auprès de vendeurs asiatiques.

Photo avec les ULN2803 pas encore montés :



Pour les soudures, j’en suis resté aux gros pâtés d’étain bien baveux. Pas très doué à ce niveau-là  ;D

Si l'approche reste minimaliste côté hardware, c’est l’inverse côté logiciel embarqué dans l’arduino pro mini : aucune économie de neurones n’est tolérée. Je suis plutôt du genre à ne figer une version de code que lorsque je ne vois absolument plus rien d’améliorable.

L’arduino mini gère en autonomie le premier niveau de sécurité des aiguillages : durée des impulsions, contrôle d’exclusion des sorties contradictoires etc.
J’ai retenu ce principe de module « intelligent » pour sécuriser les équipements contre toute défaillance logique de la centrale en amont et/ou perte de la communication avec celle-ci.

Du coup, c’est dans les fonctionnalités « ferroviaires » que j’ai quelques doutes, du fait de mon manque d’expérience dans ce domaine.

Voici ce qui est réalisé pour l’instant :
L’arduino mini reçoit des consignes de positionnement de chaque aiguillage. Il peut même recevoir simultanément plusieurs consignes pour des aiguillages différents.
Puis, de manière asynchrone, il gère l’activation des deux bobines de chaque aiguillage, sous forme d’impulsions et selon trois paramètres  communs à toutes les sorties :
  • Durée d’une impulsion vers une bobine (exemple : 500 ms)
  • Durée minimum de repos d’un aiguillage. S’applique à partir de la fin d’impulsion sur une des deux bobines de l’aiguillage (exemple : 300 ms).
  • Durée minimum entre deux débuts d’impulsion sur des aiguillages différents. Là, il s’agit de donner la possibilité de ménager la source d’alim 12V, selon sa capacité à délivrer du courant. Si cette durée est à zéro, les 4 aiguillages peuvent être basculés simultanément. Si elle est supérieure à la durée d’impulsion, un seul aiguillage à la fois peut être actif. Et entre les deux, cela permet de régler le nombre maximum de bobines activables simultanément.
Toute consigne reçue et non immédiatement exécutable est mise en attente pour être exécutée dès que possible.

De plus, le dispositif I2C Maître a la possibilité d’interroger l’arduino mini pour connaître son état instantané :
  • Positions théoriques des aiguillages (= consignes)
  • Positions réelles des aiguillages
  • Nombre de bobines en cours d’alimentation
  • Durée écoulée depuis la dernière fin d’impulsion
  • Valeurs des paramètres utilisés, que le Maître peut également modifier.
Cela donne la possibilité au Maître de gérer le niveau de sollicitation de la source d’alim 12V, de manière globale pour l’ensemble des modules présents sur le bus.

Les trames échangées en I2C comportent aussi des CRC, pour réduire les risques d’erreurs de communication liées à des parasites électriques. Une trame incorrecte est ignorée, charge au Maître de gérer la chose.

A ce stade, la question est : quelles fonctionnalités utiles pourrais-je avoir oubliées, au niveau de l’arduino mini, dans une optique de module le plus générique possible ?

Je m’interroge par exemple sur la position réelle des aiguilles.
Il n’y a aucun capteur pour donner un retour information. Ainsi, à la mise sous tension, la position de chaque aiguillage est indéterminée tant qu’une première impulsion n’a pas été envoyée. De plus, si l’aiguille est déplacée manuellement ou par un train qui circulerait en sens inverse (possible ?), il peut y avoir un déphasage logique avec l’arduino mini.
Actuellement, si l’arduino considère qu’un aiguillage est déjà dans la position indiquée par une nouvelle consigne, il ne déclenche rien.
Peut-être ajouter une fonctionnalité de remise en phase logique?

Autre interrogation : les aiguillages liés, typiques d’un changement de voie entre deux voies parallèles.
Ils seront commandés séparément, mais est-il utile ou nécessaire de gérer leur cohérence au niveau de l’arduino mini?

Autres points oubliés ?

47
Bibliothèques / Re : Bouton poussoir
« le: janvier 12, 2016, 10:31:44 pm »
Bonsoir

J'ai approfondi le point concernant le inline, et pense être arrivé à une explication qui me semble tenir la route.
Lorsque l'on met le corps d'une méthode de classe dans le .h il n'est pas nécessaire de le mettre en inline car c'est implicite.
Derrière le compilateur choisit ou non de suivre la directive, selon son analyse du code, car le inline a ses avantages et ses inconvénients. Tout n'est pas complètement clair pour moi.

Dans mes tests, j'ai l'impression que les méthodes utilisées seulement dans le programme principal conduisent à un .hex moins gros lorsqu'elles codées dans le .h, alors que celles qui sont aussi appelées depuis le .cpp n'ont pas d'impact sur la taille du .hex

Cela pourrait être cohérent avec un choix du compilo de les implémenter en inline, sauf si elles sont appelées depuis plusieurs endroits.

Quoi qu'il en soit, le gain est marginal (80 octets sur la flash, un débutant n'est pas à ça près).
Aussi je vais conserver mon optique de produire un .h le plus lisible possible, pour cette lib à destination des débutants.

Finalisation à suivre...

48
Bibliothèques / Re : Bouton poussoir
« le: janvier 06, 2016, 11:41:36 pm »
Quelques heures plus tard...

Encore merci pour le temps consacré à ma petite librairie.

Voici quelques compléments & interrogations :

En préambule, ces derniers temps je développe surtout sur arduino, donc il est fort possible que certains bons usages généraux de coding me soient étrangers, car non nécessaires dans le cas de l'IDE arduino et ses options de compil (dont je ne me suis pas encore préoccupé)

1) pour le const, c'est très bête mais je les avais juste mis au début de la ligne au lieu de la fin, alors que mon intention était bien de marquer les méthodes qui n'altèrent pas l'objet. Je m'étais vaguement posé la question de comment le compilo fait la différence avec un const type, mais sans plus. Mea culpa

2) pour le inline, je suis troublé  ;D
Je n'ai jamais approfondi ce sujet, mais je ne l'associais pas à la suppression des fonctions non utilisées.
Pour moi c'était pour que le code exécutable de la fonction appelée soit inséré directement à l'endroit d'appel, au lieu de passer par un saut avec passage de valeurs via la pile etc.
Un peu comme une macro, mais en plus précis.

Quoi qu'il en soit, j'ai essayé de mettre des inline partout, par endroits ou nulle part, sans obtenir la moindre variation de la taille du fichier .hex sur cette seule modification.
Comme si le compilateur n'en faisait qu'à sa tête.

Par ailleurs, et sauf erreur de ma part, tout ce qui n'est pas utilisé est automatiquement dégagé à la compil (ou au link?), y compris les méthodes de classe non utilisées.
J'ai fait des tests, toujours avec le programme demo 1, de supprimer les méthodes non utilisées. Dans tous les cas le fichier .hex fait la même taille

Dans le même ordre d'idée, j'ai tendance à abuser des variables constantes isolées (comme les masquexxxx de ma lib) car elles disparaissent à la compil, et sont remplacés par leur valeur directement dans le code exécutable.
Les calculs entre elles sont effectués par le (pré?)compilateur.
Il suffit de faire un test en les remplaçant par des #define pour constater que le .hex et la ram utilisée sont les mêmes.
Nb : dans ta version (constantes dans la classe), j'ai observé que l'ajout de static est obligatoire pour arriver au même résultat. Le const seul ne suffit pas, alors que je le trouvais assez "explicite". Encore un truc que je ne maîtrise pas totalement.

Du coup j'ai cherché à comprendre pourquoi ton exécutable est moins lourd, et là je n'arrive pas à poser de verdict.
Cela semble être uniquement lié au fait de définir entièrement les méthodes "simples" dans le header, au lieu de les déporter dans le cpp.
J'ai testé pas mal de combinaisons (déport d'une seule méthode, de plusieurs, etc.) et j'obtiens des résultats que je ne m'explique pas.
Par exemple pour les méthodes estEnfonce() et estRelache(), cela ne fait aucune différence.
Alors que la méthode vientDEtreEnfonceOuRelache() donne un exécutable plus léger lorsqu'elle est entièrement dans le header. Un comble quand on voit que son code est quasi le même que EstRelache(), à une constante près.
Bref y a un truc qui m'échappe au niveau de la compilation.
Après, je ne suis pas assez compétent pour aller zieuter le fichier .hex et comprendre où sont les différences exactement.

3) pour le this-> j'ai encore du mal à me faire une religion
Sur le principe je suis assez d'accord
Par exemple, sur les propriétés privées j'utilise le préfixe _ justement pour bien les repérer.
Mais autant je suis partisan d'utiliser des noms à rallonge pour avoir un code plus lisible et facile à comprendre, autant je trouve que ces 6 caractères de préfixe polluent parfois à forte dose et finissent par nuire à la lisibilité.
Du coup j'ai tendance à les mettre ou non selon les endroits.

Enfin, j'essaye aussi d'avoir un header le plus simple possible à lire.
Je me dis qu'idéalement, tout ce qui relève de l'arrière cuisine ne devrait pas y être visible.
Mais bon, le C++ semble avoir ses limites sur ce point.
Par exemple, je n'ai toujours pas compris pourquoi une classe doit exposer ses parties privées en publique (si j'ose dire  ;D)

Je vais également tâcher de mettre en stricte application ton article sur la création de lib dans les règles de l'art. Je dois creuser ça aussi.

Encore merci

49
Bibliothèques / Re : Bouton poussoir
« le: janvier 06, 2016, 07:34:19 pm »
Super

Merci pour les remarques, elles mettent le doigt sur des subtilités que je n'ai pas encore complètement appréhendées.
Je vais creuser tout ça dans le détail.

50
Bibliothèques / Bouton poussoir
« le: janvier 05, 2016, 11:57:14 pm »
Bonjour

Pour mon premier topic, je vais essayer d'apporter ma petite contribution au microcosme locoduino.

J'ai lu avec grand intérêt la plupart des articles du site, vraiment très bien faits et instructifs.
Au début, je galérais un peu dans la navigation pour en retrouver un sur lequel je voulais revenir, mais j'ai fini par trouver une petite bidouille : depuis la page d'accueil, je fais une recherche avec un mot clé au pif, puis je clique sur "tous les articles"   :P

Le dernier qui a attiré mon attention est celui sur les boutons poussoirs, un classique à destination des débutants.
J'aime beaucoup la structure de cet article ainsi que la qualité des illustrations

Concernant le code proposé avec la librairie bounce2, il me semble voir une petite amélioration possible :
bouton.attach(bp, INPUT_PULLUP);qui permet de rendre le code encore un peu plus simple en masquant l'usage de la primitive pinMode.

Bon, il reste encore le INPUT_PULLUP ::)

De mon côté, j'avais mis en ligne ailleurs une petite librairie qui me semble encore plus à la portée des débutants, surtout les francophones anglophobes   :D.
Elle définit complètement l'objet bouton poussoir dans son cablage le plus simple, et fournit toutes les fonctions de base en encapsulant toutes les primitives arduino.
Elle est aussi un poil plus économe en RAM que la bounce2.

Je vous la soumets donc comme une alternative possible, en pièce jointe (librairie complète avec exemples directement disponibles dans l'IDE arduino)

51
Présentez vous ! / Bonjour
« le: janvier 05, 2016, 10:53:16 pm »
Hello

Alors moi c'est bricoleau.
Pas de train à la maison  :-[
Mais je m'intéresse de près au modélisme arduiferroviaire

Actuellement je prépare un contrôleur d'aiguillages à commande numérique pour un pote

Pages: 1 2 3 [4]