Un petit tour de l’avis des membres de mon club m’a fait découvrir une autre réalisation consistant à compter les tours d’essieu d’un wagon, avec un détecteur Hall et un compteur de vélo. Mais c’est trop gros pour du N !
Nous voulions quelque chose de discret, pas cher et précis à la fois, qui soit visible à coté de la console DCC (une ECOS) pour permettre l’étalonnage des trains.
J’ai pris du plaisir à réaliser ce petit montage et j’y ai ajouté quelques astuces qui devraient vous plaire...
Le principe
Comme dans l’article précité, la mesure sera basée sur la mesure du temps qui sépare les passages devant 2 capteurs de position. Le plus petit Arduino, le Pro-Mini suffit à s’acquitter de cette tâche et un afficheur à 4 digits à Led permet de lire la vitesse avec une bonne luminosité.
Les capteurs devront être placés de part et d’autre de la console DCC, là où le charcutage du décor est le moins critique. Il faudra donc un système de réglage de la distance prise en compte dans le logiciel pour le calcul de la vitesse, sans ajouter de clavier, ni obliger de brancher le PC/Mac. Vous allez voir comment !!
La liste des courses
J’ai commencé par une recherche sur eBay, auprès de mes vendeurs favoris (qui sont mentionnés dans l’article Où acheter ?.
Voici mes trouvailles :
Les capteurs de position
Capteur infrarouge à réflexion
Capteur infrarouge à réflexion à base de TCRT5000L
Ce circuit tout fait pour 1,41€ [1] se connecte par 3 fils (+5V, masse et signal DO, actif a l’état bas).
Il mesure 1,5 x 3,5 cm et le capteur fait 0,5 x 1 cm. Un trou de 1,5 x 1,5 cm permet de le mettre en place avec le seul capteur TCRT5000L qui dépasse pour se situer en face du bas de caisse des voitures, à environ 1,5 cm.
L’afficheur 4 digits
Ce circuit tout fait pour 3,25€ [2] est équipé d’un circuit TM1637 qui fait tout le travail pour nous. Il se connecte avec seulement 4 fils (+5V, masse, signaux CLK et DIO). Une bibliothèque existe. Elle est fournie avec le code en fin d’article.
L’Arduino Pro Mini
C’est le moins cher, pour quelques € [3] et le plus petit, facile à oublier dans un coin du réseau.
Attention, il y a plusieurs modèles : préférez ceux qui sont marqués "DTR" et "GND" dans les coins.
Il se programme comme les autres à condition de connecter un circuit d’interface USB série, de préférence à base de FT232 (FTDI) dont le driver est déjà présent dans votre système Mac ou PC, donc le port est facilement reconnu par l’IDE Arduino.
L’adaptateur USB série
Cet adaptateur peut servir à programmer des quantités d’Arduino Pro Mini. Un seul suffit, peu cher [4]
Les 6 broches de ce circuit coincident exactement avec les 6 broches sur le coté droit de l’Arduino. Il faudra veuiller à faire coincider la patte "DTR" du Pro Mini avec la patte "DTR" de l’adaptateur USB et les pattes "GND" des 2 cartes aussi.
Les fils de câblage
Pour 0,50€ le cable [5] que je coupe en deux pour relier les 2 capteurs, la prise à 3 contacts allant sur un capteur et les fils à l’autre extrémité sont soudés directement sur l’Arduino.
Au total, la facture s’élève avec peine à 8 € (sans l’adaptateur FT232 que vous devez avoir déjà dans vos stocks), soit environ 10€ avec les quelques fils, soudure, et outils nécessaires.
Le schéma de câblage
En respectant ce schéma, il est impossible de se tromper !
Les 2 détecteurs et l’afficheur utilisent le 5V de l’Arduino (donc à relier à VCC et GND) : j’ai mesuré une consommation totale d’environ 50 mA (bien inférieure au 150 mA maximum que supporte le Pro Mini).
Les sorties des détecteurs sont à relier aux Pins 8 et 9 (ou toutes autres qui vous conviendrait mieux à condition de modifier le programme en conséquence).
L’afficheur utilise les 2 Pins 2 et 3 pour les signaux CLK et DIO respectivement.
Pour l’alimentation, il existe plusieurs options possibles :
Alimenter le montage directement en 5 V avec un petit chargeur pour USB par exemple : On raccordera l’alimentation directement sur les pins 5V et GND de l’Arduino.
Alimenter le montage à partir d’une tension plus élevée, sans excéder 12V. Comme on trouve souvent du 12V (voir un peu plus) sur nos réseaux, notamment pour l’alimentation des accessoires, j’ai pris l’habitude, par méfiance, d’intercaler un régulateur 9V. Dans ce cas il faut se raccorder sur les pins RAW (+9V) et GND.
On trouve de petits régulateurs en kit pour moins de 2€ [6].
Avant d’installer le montage sur le réseau, j’ai réalisé le montage sous forme "volante" comme on dit, j’ai écrit et mis au point le programme et l’ai testé avec un simple batterie LiPo comme source d’énergie.
Cela m’a permis de tester la distance entre les capteurs et les trains, déterminer la distance par rapport à la voie, avant de faire les trous dans le réseau :)))
Remarques pratiques :J’ai pris soin de faire en sorte que tous les éléments soient connectés à l’aide de mini-connecteurs pour pouvoir passer les câbles dans les trous. Attention à bien respecter les couleurs des fils : rouge pour le +5V et noir pour le GND, les signaux pouvant avoir la couleur que vous voulez.
Le programme
Le programme est un automate qui doit se dérouler de façon totalement fiable, dans n’importe quel sens de circulation, selon plusieurs phases :
détecter le passage d’un convoi devant l’un ou l’autre détecteur et initialiser la mesure du temps en enregistrant la valeur du temps système avec millis() ;
détecter le passage du convoi devant l’autre détecteur et enregistrer à nouveau le temps système.
calculer le temps passé T entre les 2 détecteurs et en déduire la vitesse V du train selon la formule V = D / T où D est la distance entre les capteurs.
afficher le résultat sur l’afficheur pendant quelques secondes
retourner en attente d’une autre mesure.
Pour réaliser cet automate, on verra que j’ai utilisé une variable décrivant les différentes situations possibles. L’action qui en découle est conditionnée par un test de cette variable. C’est simple !
Pour définir et enregistrer la distance D exacte, j’ai évité de coder cette distance en dur dans le programme. Au contraire, j’ai imaginé une condition qui doit être réalisée à la mise sous tension pour appeler un sous-programme de réglage. Il utilise les 2 capteurs pour augmenter ou diminuer la valeur précédente (comme des boutons + et -) et pour enregistrer le résultat dans l’EEPROM de l’Arduino, sur 2 octets seulement (jusqu’à 65532 mm soit 65 m ce qui est largement suffisant, mais sans dépasser 65 cm toutefois dans le programme actuel à cause des types des variables de calcul)
Enfin, vous découvrirez quelques astuces qui vous seront peut-être utiles dans vos programmes.
TM1637Display qu’il faut télécharger [7] et installer dans l’IDE. Cette bibliothèque est fournie avec le programme dans l’archive jointe à la fin de l’article.
EEPROM est une bibliothèque intégrée à l’IDE
Déclaration des pattes de l’Arduino utilisées : 2 et 3 pour l’afficheur, 8 et 9 pour les capteurs.
Déclaration de l’afficheur avec ses 2 pins (création de l’objet "display").
Je n’ai pas trouvé nécessaire ni souhaitable d’ajouter d’autres périphériques (leds, boutons, ..). Je me suis dit qu’il faut faire avec les organes d’interface ci-dessus qui sont 2 entrées et une sortie. Nous verrons plus loin comment...
Définition des variables
uint8_t data[] = { 0xff, 0xff, 0xff, 0xff };
uint8_t blank[] = { 0, 0, 0, 0 };
uint8_t lumin = 0x0f;
unsigned long _time1, _time2, temps;
byte dt0, dt1, odt0, odt1;
bool debug = false;
bool done;
// etat des capteurs de proximité
// repos = tous les bits à 0 (etat=0)
// dt0 = 0 si détection sur DT0 => P0=1
// dt1 = 0 si détection sur DT1 => P1=2
// 1ere detection sur DT0 : DP0 = 4
// 1ere detection sur DT1 : DP1 = 8
// affiche pendant _time2 : AFF = 16
enum {Repos=0, P0=1, P1=2, DP0=4, DP1=8, AFF=16 };
byte etat=Repos;
// distance entre capteurs 500 mm
unsigned int distance=500;
unsigned int VCM, VKM;
unsigned int val = 500;// distance par défaut en mm
unsigned int delai = 5000;
unsigned int k=0;
byte V0,V1;
Nous avons maintenant les variables utilisées par le programme :
data[] et blank[] sont des affichages spéciaux ;
les variables de temps pour le calcul de vitesse, les instants de détection et des temporisations ;
les valeurs des capteurs,
des booleens debug pour des affichages sur la console (faux donc désactivé par défaut) et done pour sortir d’une boucle while dans la configuration de la distance ;
la variable d’état pour l’automate : elle est constituée de l’assemblage de bits correspondant aux divers événements. Les valeurs résultantes permettent de prendre les bonnes décisions ;
les variables pour le calcul de la distance ;
une valeur par défaut de la distance entre les capteurs : 50 cm ou 500 mm, la distance étant exprimée en mm pour une meilleure précision.
Remarque : la distance entre capteurs doit être inférieure à 655 mm pour ne pas dépasser la capacité des variables unsigned int VCM et VKM, à cause d’un facteur 100 utilisé pour augmenter la précision. Si ce devait être le cas, il faudrait changer leur type en unsigned long.
Le programme du setup
Il commence par l’ouverture du port série pour la console et l’envoi de la chaine de caractère VERSION. Cette pratique permet de savoir ce qu’il y a dans la mémoire de l’Arduino !
Ensuite il y a l’initialisation de l’afficheur avec un test d’affichage pendant 1 seconde (8888), l’initialisation des pins des détecteurs, la lecture des 2 premiers octets de l’EEPROM qui devraient contenir la distance D.
Si les valeurs lues sont 0xFF, cela signifie que l’EEPROM est vide : il faut donc ignorer cette lecture et prendre la valeur 500 définie plus tôt. Seule la procédure de réglage permettra d’écrire une valeur significative dans l’EEPROM. Alors, au démarrage suivant c’est cette valeur qui sera utilisée.
// ----------------------------
// SETUP
// ----------------------------
void setup() {
Serial.begin(115200);
while (!Serial) {
; // wait for serial port to connect. Needed for native USB port only
}
Serial.println(VERSION);
display.setBrightness(0x0f); // All segments on
display.setSegments(data);
delay(1000);
Serial.println("init détecteurs");
// init Pins détecteurs
pinMode(DT0, INPUT_PULLUP);
pinMode(DT1, INPUT_PULLUP);
V0 = EEPROM.read(0);
V1 = EEPROM.read(1);
if ((V0!=0xFF)&&(V1!=0xFF)) {
val = V0;
val = val << 8;
val = val | V1;
}
display.showNumberDec(val, false, 4, 0);
distance=val;
Serial.print("distance = ");Serial.println(distance);
delay(2000);
odt0=digitalRead(DT0);
odt1=digitalRead(DT1);
if (!odt0 && !odt1) { // les 2 detecteurs sont excités
reglage(); // reglage distance
}
_time1=millis();
_time2=millis();
etat=AFF;
}
Pour déclencher la procédure de réglage, il faut placer un wagon devant chaque détecteur et mettre le montage sous tension. Voici ce que fait cette procédure :
L’affichage de la valeur initiale (soit 500, soit le contenu de l’EEPROM)
L’attente de la libération des 2 capteurs dans une boucle while qui bloque le programme en attendant
la lecture des 2 détecteurs, l’un pour augmenter, l’autre pour diminuer la valeur de la distance. Une tempo de 200 ms permet de rendre cette action "humaine".
Et si les 2 détecteurs sont à nouveau actifs en même temps, la nouvelle valeur est enregistrée en EEPROM.
Petite astuce nécessaire du fait que l’EEPROM ne peut stocker que des octets (byte) et que la distance est un entier (2 octets) : L’entier est recopié dans l’octet V1, perdant au passage les 8 bits de poids fort. Puis l’entier est décalé de 8 bits vers la droite, perdant ainsi ses 8 bits de poids faible et le résultat est copié dans V2. V1 et V2 sont ensuite stockés dans l’EEPROM avec la fonction update qui évite d’écrire si la valeur précédente était identique (cela augmente la durée de vie de l’EEPROM).
Une façon plus "moderne" de convertir 1 entier en 2 octets et 2 octets en 1 entier est d’utiliser les macros word(), lowByte() et highByte() :
// au lieu de val = V0; val = val << 8; val = val | V1;//
// tout simplement ://
val = word(V0,V1);
// au lieu de V1 = val; V0 = val >> 8;//
// tout simplement ://
V0 = highByte(val);
V1 = lowByte(val);
Le réglage de la distance entre les capteurs et l’enregistrement en EEPROM
Le coeur du programme étant le calcul de vitesse, nous y voici maintenant !
Après vérification que le temps n’est pas nul pour éviter une division par 0 qui planterait le programme, on calcule la vitesse réelle en millimetre/milliseconde (ou mètres/seconde) multipliée par 100 pour augmenter la précision (plus de chiffres significatifs).
Puis on applique le rapport 576/100 pour obtenir des km/h à l’échelle 1/160.
Rappel : on multiplie les m/s par 3600/1000 = 3,6 pour obtenir des km/h.
Puis on multiplie par 160 (échèle N), d’où le nombre 576 ci-dessus.
Le résultat est affiché pendant 5 secondes et la variable d’état devient égale à AFF pour que l’extinction soit effectuée plus loin dans la LOOP.
La LOOP permet de faire du multitâche simplifié dans la mesure où ces tâches ne s’exécutent que si une condition particulière est réalisée.
Ici chaque condition est une ou plusieurs valeurs de la variable d’état état.
Nous avons donc successivement :
la lecture du 1er capteur
la lecture du 2eme capteur
le test du port série, si la console est connectée
le maintien de l’affichage du résultat pendant 5 secondes
et une animation durant l’inter-détection.
Le traitement des capteurs est le plus important :
Il est conditionné par l’état Repos ou une détection préalable sur l’autre capteur seulement.
Une première détection permet de positionner les bits de la variable d’état qui décrivent le capteur actif.
Une deuxième détection lance la procédure de calcul et d’affichage.
Dans tous les autres cas les lectures des ports DT0 ou DT1 sont ignorées. Cela a l’énorme avantage d’ignorer les détections parasites, les rebonds, etc..
La seule précaution à prendre consiste à éviter d’inonder de lumière les capteurs, ce qui provoquerait des fausses mesures. Mais cela se verrait très vite.
// ----------------------------
// LOOP
// ----------------------------
void loop() {
// lecture des capteurs de proximité
//enum etat {Repos=0, P0=1, P1=2, DP0=4, DP1=8, AFF=16 };
dt0=digitalRead(DT0);
if (!dt0) { // detection sur DT0 (niveau LOW)
if (etat==Repos) { // =0 : premiere detection sur DT0
etat = P0+DP0; // 5
k=0;
temps = millis();
_time1=millis();
if (debug) {Serial.print("etat=");Serial.println(etat);}
} else { // sinon c'est une 2me detection
if (etat == P1+DP1) { // bonne seulement après DT1
temps = millis()-temps;
if (debug) {Serial.print(" Temps=");Serial.print(temps); }
if (debug) {Serial.print(", Distance=");Serial.print(distance);}
calcul();
}
}
}
//enum etat {Repos=0, P0=1, P1=2, DP0=4, DP1=8, AFF=16 };
dt1=digitalRead(DT1);
if (!dt1) { // detection sur DT1 (niveau LOW)
if (etat==Repos) { // =0 : premiere detection sur DT0
etat = P1+DP1; // 10
k=0;
temps = millis();
_time1=millis();
if (debug) {Serial.print("etat=");Serial.println(etat);}
} else { // sinon c'est une 2me detection
if (etat == P0+DP0) { // bonne seulement après DT0
temps = millis()-temps;
if (debug) {Serial.print(" Temps=");Serial.print(temps); }
if (debug) {Serial.print(", Distance=");Serial.print(distance);}
calcul();
}
}
}
Le test de la console via le port série est très sommaire :
On lit un nombre entier et on le teste.
Si c’est une valeur positive non nulle, on considère que c’est la distance entre les capteurs en mm et on l’écrit dans l’EEPROM.
Si la valeur est égale à 0, comme il est interdit de diviser par 0 dans le calcul de vitesse, on utilise ce cas particulier pour permuter le booléen debug. S’il est vrai, quantité d’affichages apparaissent alors sur la console.
while (Serial.available() > 0)
{
val = Serial.parseInt(); // lecture entier
if (Serial.read() == '\n')
{
if (val==0) {debug = !debug;}
else {
V1 = val;
V0 = val >> 8;
EEPROM.update(0, V0);
EEPROM.update(1, V1);
Serial.print("distance entre capteurs : ");
Serial.println(val);
distance = val;
}
}
}
La variable delai est initialisée à 5000 (5 secondes). Au bout de 5 secondes l’affichage est éteint et l’état Repos autorise une nouvelle mesure.
if (_time2+delai > millis()) {
if (etat==AFF) {
etat=Repos;
if (debug) {Serial.print("etat=");Serial.println(etat);}
display.setSegments(blank);
}
}
Animation entre les détections du 1er et du 2ème détecteur
C’est juste pour faire joli : la condition dans l’if représente ce cas particulier. Tant que cette condition existe, on affiche un compteur k qui est incrémenté à chaque loop. Cela permet de se rendre compte de la vitesse d’exécution de l’Arduino !
if ((etat==P1+DP1)||(etat==P0+DP0)) {
display.showNumberDec(k, false, 4, 0);
k++;
}
} // fin de LOOP
Le programme ne pèse que 6202 octets, soit 20% de la flash du Pro Mini, qui n’est donc pas surchargé !
Vous pouvez le télécharger ici (l’archive contient aussi la bibliothèque TM1637) :
L’installation sur le réseau
J’ai commencé par percer des trous carrés de 1,5 cm de coté aux emplacements des capteurs, sur une ligne droite passant devant la console DCC. Dans chaque trou, j’ai glissé un capteur avec les diodes IR placées vers la voie, à un bon centimètre au dessus du sol pour viser sur le bas de la caisse des wagons, voitures et locos.
Ensuite un 3ème trou devant la console DCC est percé pour installer l’afficheur. celui-ci sera maintenu à environ 45° pour être bien orienté vers les yeux du conducteur.
Le câblage est ensuite réalisé sous le réseau, simplement en branchant les câbles (vérifiez plusieurs fois avant de brancher et avant de mettre sous tension que les connecteurs sont dans le bon sens et sur les bonnes pins, le montage "en l’air" ayant pour but des marquer les câbles avec des repères).
Après mise sous tension et l’affichage de "8888" puis "500", je teste le système en faisant passer un wagon ou une loco. Ca marche !
Il ne reste plus qu’à étalonner la distance en plaçant un wagon devant chaque détecteur et en redémarrant le système. On trouve très vite le capteur qui augmente et celui qui diminue ! Quand la valeur est bonne on place les 2 wagons devant les 2 capteurs en même temps et l’initialisation est terminée.
L’intégration dans le décor se fait en installant une cabane sur chaque capteur, quelques buissons et c’est beau comme sur les photos ci-dessus.
Merci d’avance pour vos commentaires et suggestions, ainsi que votre propre expérience (plutôt sur le Forum).
Ah bon !
j’en vois en vente chez Farnel, RS, Mouser, entre autres !
Essayez avec le bon nom : tcrt5000, notamment chez TME, ça ira mieux, vous verrez...
Les liens sur eBay ne sont valables qu’un certain temps et l’orthographe laisse parfois à désirer.
Bonjour,
pour l’étalonnage je ne saisis pas bien le deroulement,
la valeur est bonne : quelle valeur et ou la voit on ?
Pouvez vous m’expliquer plus précisément.
Merci
Il y a un afficheur dans le montage qui affiche la vitesse réelle au passage d’un convoi. Il n’y a pas d’étalonnage pour ce montage, tout est décrit dans cet article, mais pour étalonner une loco il faut faire varier sa vitesse avec la centrale jusqu’à ce que l’affichage de sa vitesse indique la vitesse souhaitée, puis noter le cran DCC correspondant.
Bonjour, dans la description de l’installation vous dites ceci :
Il ne reste plus qu’à étalonner la distance en plaçant un wagon devant chaque détecteur et en redémarrant le système. On trouve très vite le capteur qui augmente et celui qui diminue ! Quand la valeur est bonne on place les 2 wagons devant les 2 capteurs en même temps et l’initialisation est terminée.
Je ne saisi pas très bien .
quelque chose m’échape ??
il suffit de lire la fonction "reglage" pour comprendre :
Le setup (au démarrage du programme) regarde si les 2 détecteurs sont activés simultanément. Si oui il lance le reglage.
Pour ce faire il faut mettre un wagon devant chaque détecteur et démarrer le système ensuite.
Une valeur de distance par défaut s’affiche : 500 (mm)
en bougeant l’un des wagons (reculer, en sortant du capteur et retour devant le capteur) on augmente la valeur, et en bougeant l’autre on la diminue (il faut évidemment mesurer la distance entre les 2 capteurs auparavant). quand c’est bon, on peut enlever les 2 wagons et la valeur est sauvegardée en eeprom.
Le programme donné est pour un Pro-mini qui a le même processeur que le Nano et le UNO. Cela devrait marcher sans modifier le programme si vous avez respecté les positions des entrées-sorties. Mais il faut nous donner tous les détails de l’erreur pour vous éclairer.
Bonjour, Voici le message que je recois lorsque j’essaye de le téléverser sur un carte NANO.
J’ai essayé avec une carte UNO, et la pas de problème .
Merci à vous
Arduino : 1.8.9 (Windows Store 1.8.21.0) (Windows 10), Carte : "Arduino Nano, ATmega328P"
Le croquis utilise 5072 octets (16%) de l’espace de stockage de programmes. Le maximum est de 30720 octets.
Les variables globales utilisent 465 octets (22%) de mémoire dynamique, ce qui laisse 1583 octets pour les variables locales. Le maximum est de 2048 octets.
avrdude : stk500_getsync() attempt 1 of 10 : not in sync : resp=0x74
avrdude : stk500_getsync() attempt 2 of 10 : not in sync : resp=0x72
avrdude : stk500_getsync() attempt 3 of 10 : not in sync : resp=0x61
avrdude : stk500_getsync() attempt 4 of 10 : not in sync : resp=0x66
avrdude : stk500_getsync() attempt 5 of 10 : not in sync : resp=0x66
avrdude : stk500_getsync() attempt 6 of 10 : not in sync : resp=0x69
avrdude : stk500_getsync() attempt 7 of 10 : not in sync : resp=0x63
avrdude : stk500_getsync() attempt 8 of 10 : not in sync : resp=0x20
avrdude : stk500_getsync() attempt 9 of 10 : not in sync : resp=0x6c
avrdude : stk500_getsync() attempt 10 of 10 : not in sync : resp=0x69
Une erreur est survenue lors du transfert du croquis
Ce rapport pourrait être plus détaillé avec
l’option "Afficher les résultats détaillés de la compilation"
activée dans Fichier -> Préférences.
Bonjour voila le système fonctionne très bien, j’ai même fait un circuit imprimé avec une alimentation stabilisée pour utilisation avec une carte Nano
Pour une voie double, la détection ne se fait pas sur la voie la plus éloignée, j’ai essayer en réglant la sensibilise des capteurs , mais sans résultat.
est il possible d’ajouter deux autres capteurs et de modifier le code pour pouvoir avoir deux zone de détection.
oui sans doute, l’Arduino n’est pas exténué par cette tâche et ils reste des pattes disponibles.
Chez moi j’ai fait une mesure sur double voie en utilisant les détecteurs de présence d’une zone de mesure et ceux des zones adjacentes.
C’est même une fonction intégrée à la centrale DCC , voir projet Dominique
Bonjour, serait il possible d"allonger la section de mesure a 1 mètre de manière a être plus précis encore dans la mesure, quelle modification faut il apporter au code
oui si vous voulez ! Cet article décrit un exemple de réalisation mis en œuvre dans mon club. Rien ne vous empêche de le modifier pour votre usage personnel.
Dans ce cas vous modifiez la formule donnée dans « calcul de la vitesse » en fonction de votre distance personnelle. V=D/T, c’est pas sorcier !
Bonjour
Je débute avec Arduino (J’ai réussi a mettre en œuvre la simulation arc)
J’ai télécharger "vitessen"
Les 2 Fichiers "mesure_vitesse_N.ino" & " TM1637Test.ino "
Quand je fais la vérification l’IDE Arduino marque :
"Erreur de compilation pour la carte Arduino Pro et Pro Mini"
Je ne sais que faire ni ou chercher !!!!
Merci
Avez vous lu ? : Nous avons 2 déclarations de bibliothèque :
TM1637Display qu’il faut télécharger [7] et installer dans l’IDE. Cette bibliothèque est fournie avec le programme dans l’archive jointe à la fin de l’article.
EEPROM est une bibliothèque intégrée à l’IDE
Voir : Installer une bibliothèque
Deux remarques, 1. comme votre problème est personnel (vous débutez) et non spécifique à l’article, je vous suggère de le poster sur le forum en référence (avec le lien) à cet article. 2. Ce n’est pas le dernier message d’erreur qui donne la cause de l’anomalie de compilation mais le premier, c’est d’ailleurs l’ensemble en rouge qu’il faut poster.
Bonjour
Je ne sais pas si le sujet est encore suivi mais j’ai acheté et monté le système que tu as conçu pour le mettre en oeuvre sur mon circuit de voitures au 1/32.
Je n’ai jamais fait d’arduino et je suis confronté à des erreurs de programme. j’ai réussi à passer le cap de l’installation des bibliothèques mais j’ai à nouveau des messages d’erreur que je ne comprends pas.
Si toutefois, il y a encore une âme patiente et sympathique pour m’aider, ce serait top.
Quoi qu’il en soit, merci pour cette publication que je trouve vraiment géniale, j’adore ajouter des modules sur mon circuit.
Merci d’avance pour les éventuelles réponses.
Bonne journée
Stéphahe
Voici les messages que j’ai :
Arduino : 1.8.13 (Windows Store 1.8.42.0) (Windows 10), Carte : "Arduino Mini, ATmega328P"
TM1637Display.cpp:60:1 : error : prototype for ’TM1637Display::TM1637Display(uint8_t, uint8_t)’ does not match any in class ’TM1637Display’
Hello
Bon, j’ai réussi à intégrer les bibliothèques et la compilation fonctionne sur mon pc mais en revanche, j’ai un message d’erreur quand je téléverse le programme...
Est-ce que qu’une âme charitable saurait m’aider svp
Désolé de vous solliciter comme ça mais j’aimerais bien faire fonctionner ce programme.
Bonne journée
Stéphane
Arduino : 1.8.13 (Windows Store 1.8.42.0) (Windows 10), Carte : "Arduino Mini, ATmega168"
Le croquis utilise 5052 octets (35%) de l’espace de stockage de programmes. Le maximum est de 14336 octets.
Les variables globales utilisent 466 octets (45%) de mémoire dynamique, ce qui laisse 558 octets pour les variables locales. Le maximum est de 1024 octets.
avrdude : stk500_getsync() attempt 1 of 10 : not in sync : resp=0x80
avrdude : stk500_getsync() attempt 2 of 10 : not in sync : resp=0x98
avrdude : stk500_getsync() attempt 3 of 10 : not in sync : resp=0x7e
avrdude : stk500_getsync() attempt 4 of 10 : not in sync : resp=0x33
avrdude : stk500_getsync() attempt 5 of 10 : not in sync : resp=0xe6
avrdude : stk500_getsync() attempt 6 of 10 : not in sync : resp=0x86
avrdude : stk500_getsync() attempt 7 of 10 : not in sync : resp=0x60
avrdude : stk500_getsync() attempt 8 of 10 : not in sync : resp=0x0f
avrdude : stk500_getsync() attempt 9 of 10 : not in sync : resp=0x1e
avrdude : stk500_getsync() attempt 10 of 10 : not in sync : resp=0x0f
Une erreur est survenue lors du transfert du croquis
Ce rapport pourrait être plus détaillé avec
l’option "Afficher les résultats détaillés de la compilation"
activée dans Fichier -> Préférences.
Bonjour,
pourrais je savoir ou vous avez acheté tous les composants car comme vous je voudrais faire un mesureur de vitesse pour mes voitures de slot au 1/32
D’avance merci
et meilleurs vœux pour la nouvelle année.
Merci beaucoup pour votre partage.
Je serais intéressé par votre votre réalisation pour mesurer la vitesse entre deux points espacés de 10 mètres j’aimerais que cette valeur soit figé est-ce faisable et à la place des capteurs je pense mettre des palpeurs au sol en entrant et en sortant. Ha j’ai oublier une chose importante , je suis vraiment novice en programmation. Merci cordialement
Merci de décrire vos palpeurs et votre application (qui doit être du modélisme ferroviaire).
Pour la distance il suffit de la mettre en constante dans le programme, en enlevant le système de réglage et l’enregistrement en EEPROM. Vous trouverez comment faire en lisant d’autres articles sur ce site.
Bonjour et bravo pour cette réalisation et le partage de celle-ci.
Je suis très intéresssé par ce montage de part ses composants mais j’utilise l’échelle HO et voulais savoir si en modifiant la ligne :
VKM=VCM*576/100 ;
par
VKM=VCM*313,2/100 ;
cela pouvait fonctionner.
Je sais que LIKIKI a posté sur ce même site un autre montage "Calcul de la vitesse d’un train miniature avec l’Arduino" directement adapté à cette échelle mais je préfèrerai construire le votre.
D’avance merci pour votre réponse.
Cordialement.
Serge
Néanmoins, les variables en question sont des entiers, donc pour éviter des résultats inattendus restez avec 313. De même pour la virgule qui ne convient pas.
bonjour ,
j’ai refait le meme systeme mais pour mesurer la vitesse de mini z , ma question , avez vous une idee pour augmenter la distance de detection
merci
Bonjour,
Pour adapter la distance à votre réseau, vous pouvez mesurer la distance avec un mètre et stocker la valeur dans l’EEPROM et/ou en définissant cette distance en constante dans le programme (sans utiliser l’EEPROM dans ce cas). Cela évite d’utiliser la mesure proposée dans l’article avec le jeu d’un wagon passant devant les capteurs.
Bien évidemment il faudra adapter les paramètres de calcul de la vitesse en fonction de l’échelle de votre réseau.
Dominique
Je ne comprends pas votre question et je pense que l’on sort du cadre de cet article. Pouvez-vous poser la question sur le forum avec détails, schéma et photos ?
