1 - Objectifs
Ce projet consiste à fabriquer intégralement un système de plaque tournante pour un réseau ferroviaire en N.
Les pièces sont réalisées en bois découpé au laser, en contre plaque de bouleau de 3 mm ou en MDF de 3 mm.
Quelques réalisations en impression 3D (support moteur et support de la butée).
Les composants électroniques ont
- Arduino nano
- L298N pour gérer le moteur
- Un moteur NEMA 17
- Un servo moteur SG90
- Une plaque de distribution (Viessman 6049) pour la répartition des GND et des 5V sur les divers composants
- Un récepteur IR VS1838B
- Une alimentation 9V ou une pile 9V pour les tests
Certaines de ces pièces sont issues de la récupération sur d'anciennes imprimantes.
2 - Pièces utilisées
a - Butée de positionnement
Cette pièce servira à bloquer le plateau tournant en face des voies extérieures. Un bras horizontal, fixé au plateau supérieur du boitier, se finissant en forme de V viendra d'encastrer en une butée fixée sous le plateau tournant en autant de positions qu'il y aura de positions de rotation possibles. Le mécanisme est entrainé par un servomoteur SG90 et un petit montage d'engrenage horizontal en impression 3D et en bois découpé au laser.
b - boitier d'accueil
Ce boitier supporte l'ensemble du projet en étant totalement autonome. Le moment venu, il sera intégré dans le réseau intégralement. Il est fabriqué en planchettes de bois de bouleau ou de MDF découpées au laser.
Il est composé de 4 côtés, d'un plateau supérieur découpé par un cercle, d'un plateau intermédiaire qui supportera les mécanismes, et de barres de renfort en dessous de ce dernier.
c - Roulement à billes plateau tournant
La rotation et sa stabilité sont assurées par un système de roulement à billes plat (plateau tournant) fixé sur le plateau intermédiaire et sur la roue d'entrainement.
d - Entrainement
L'entrainement est assuré par un moteur NEMA 17, une courroie, une roue crantée. Un interrupteur fin de course permet d'initialiser la position de départ du plateau en position 1.
La roue est constituée de 2 cercles (en bois) fixés entre eux. La roue inférieure, la plus grande, est aux dimensions du roulement à billes pour la fixer dessus. La roue supérieure (la plus petite) est crantée et sera entrainée par la courroie. Merci à jpbbricole pour l'idée de retourner une courroie et de la coller sur la roue pour une parfaite adaptation de la courroie et de cette roue.
e - Partie électronique
La partie électrique et électronique repose sur un Arduino Nano. L'alimentation extérieure, nécessaire pour le moteur NEMA17, est assurée par un chargeur 9V du marché. Un montage adapte la prise de ce chargeur aux branchements sur la carte L298N. Une carte L298N pour piloter le moteur pas à pas. Une plaque de distribution nécessaire aux raccordements 5V et GND des composants concernés. Un récepteur IR pour la télécommande complète cette liste. Enfin une télécommande standard (de la récupération là encore) permet de piloter les demandes de rotation
f - Schéma du montage Arduino
Le schéma des branchements du projet est le suivant :
3 - Montages
a - Butée de blocage
Voici ce que donne le système de butée vue du dessous.
b - Entrainement
Voici ce que donne le système d'entrainement
Ici, 4 demandes de rotation sont possibles. A chaque fois, la butée se retire, le plateau tourne, la butée se repositionne. On voit des fils (rouge et noir) sortirent du centre de la roue. Ces fils serviront à alimenter la voie placée sur le plateau et ne subiront pas de torsion liée à la rotation.
4 - Tests et résultats
Le résultat donne ceci. Je signale sur les voies de sorties ne sont pas posées définitivement, celles-ci viendront une fois le module positionné à son emplacement définitif. On voit par exemple que la voie du haut (position 4) n'est pas tout à fait en face de la voie pivotante. Rien de grave. Les réglages sont ce qui m'a pris le plus de temps et devront être précis au moment de la mise en place quant au positionnement définitif des voies.
Programme Arduino associé. Je ne suis pas un expert dans la programmation pour être d'une efficacité réelle dans la formulation de syntaxes plus "informaticiennes" ou "mathématiques" que celles que j'ai utilisées. De nombreuses améliorations doivent pouvoir être trouvées, mais mon objectif premier et que ça marche comme je le souhaite.
/*
Utilisation moteur pas a pas nema 17
piloté par telecommande
conservation de la position du moteur en EPROM
4 positions
1 2 3 et 4 voies de sortie pour 1 entree
pos_demand = pos_prec retenue pour la position demandée et celle précédente
la pos_demand = 1 correspond à la position initiale
la voie tournante est placée face à la voie d'arrivée des trains
*/
#include <EEPROM.h>
#include <Stepper.h>
#include <IRremote.h>
#define RECV_PIN 7
#include <Servo.h>
Servo myservo;
// pour recevoir sur l'ir PIN 7
IRrecv irrecv(RECV_PIN);
decode_results results;
#define boutinit 4 // Interrupteur fin de course
int val1 = 10; // Lecture de la position de l'interrupteur
const int NbPasParTour = 200; // Nombre de pas pour 360 degres
int val = 20; // conserve la pos_prec du bouton saisie pour les traitements
int valx = 0; // conserve la pos_prec du bouton saisie pour les traitements
int vitesse = 10; // vitesse d'incremantation de la rotation du pont
int etat = 0; // variable pour les boucles de rotation
int pos_prec; // derniere position connue
int pos_demand; // niveau de rotation demandé par la telecommande
int pos_recue; // valeur renvoyee par la telecommande
const int adresse = 14; // adresse de stockage dans EEPROM
Stepper Moteur1(NbPasParTour, 8, 9, 10, 11); // Initialise le moteur sur les broches 8 à 11
void setup() {
pinMode(boutinit, INPUT_PULLUP); // Fin de course
myservo.attach(12); // attache le bouton à la pin 12
Serial.begin(9600);
irrecv.enableIRIn(); // Lance la reception telecommande
pos_prec = EEPROM.read(adresse); // pos_prec contenue dans l'eeprom
Moteur1.setSpeed(30); //Vitesse de rotation du moteur
}
void loop() {
pos_demand = 0; // mise à zero à chaque itération de la position demandee
receiveCode(); // appel fonction pour connaitre l'action de la telecommande
/* prévu pour debugage
if (pos_demand != 0) {
Serial.print("pos_demand ");
Serial.print(pos_demand);
Serial.print(" ValueDec ");
Serial.println(results.value);
*/
/*********************************************/
if (pos_demand > 0 && pos_demand < 5) // si une action valide de la telecommande est retournée
{
pos_prec = EEPROM.read(adresse); // lecture derniere position connue
//********************************************************************************
//***** test de la demande et mise à jour des variables utilisées pour la rotation
// Les variables mises à jour sont :
// val : sens et unité de rotation
// valx : durée de la rotation pour le mouvement spécifique
//********************************************************************************
switch (pos_demand) {
case 0 : // si la demande = 0 on ne fait rien
val = 0;
break;
case 1 :
switch (pos_prec) {
case 1: // si la demande = 1 on test la position précédente
valx = 0; // si pos_prec = pos_demand on ne fait rien
val = 0;
break;
default:
valx = 100; // si demande = 1 on donne une duree de retour importante
val = 20; // on donne un sens de rotation retour
pos_demand = 1; // on indique que la demande = 1
break;
}
break;
case 2 : // si la demande = 1 on test la position précédente
switch (pos_prec) {
case 1 :
valx = 15;
val = -20;
break;
case 2 : // si pos_prec = pos_demand on ne fait rien
valx = 0;
val = 0;
break;
case 3 :
valx = 15;
val = 20;
break;
case 4 :
valx = 30;
val = 20;
break;
case 5:
valx = 0;
val = 0;
break;
}
break;
case 3 :
switch (pos_prec) {
case 1 :
valx = 30;
val = -20;
break;
case 2 :
valx = 15;
val = -20;
break;
case 3 : // si pos_prec = pos_demand on ne fait rien
valx = 0;
val = 0;
break;
case 4 :
valx = 15;
val = 20;
break;
}
break;
case 4 :
switch (pos_prec) {
case 1 :
valx = 40;
val = -20;
break;
case 2 :
valx = 30;
val = -20;
break;
case 3 :
valx = 15;
val = -20;
break;
case 4 :
valx = 0; // si pos_prec = pos_demand on ne fait rien
val = -20;
break;
}
break;
}
//********************************************************************************
//***** fin du test de la demande et mise à jour des variables utilisées pour la rotation
//********************************************************************************
// retrait de la butée de positionnement
myservo.write(0);
delay(100);
// boucle de rotation
for (etat = 0; etat <= valx; etat += vitesse)
{
val1 = digitalRead(boutinit); // lecture etat interrupteur
/* prévu pour debugage
Serial.print(" etat = ");
Serial.print(etat);
Serial.print(" boutinit = ");
Serial.print(val1);
Serial.print(" vitesse = ");
Serial.print(vitesse);
Serial.print(" pos_prec = ");
Serial.print(pos_prec);
Serial.print(" valx = ");
Serial.print(valx);
Serial.print(" val = ");
Serial.println(val);
*/
// si l'interrupteur est actionné on confirme la demande de position à 1
// et on effectue un petit mouvement arriere pour liberer l'interrupteur
// sinon celui-ci resterait en position de blocage
if (val1 == LOW) {
pos_demand = 1;
Moteur1.step(-20);
break;
}
// sinon on effectue le mouvement de rotation demandé
else {
Moteur1.step(val);
}
}
// sortie de la butée de positionnement pour blocage
myservo.write(180);
delay(100);
/* prévu pour debugage
Serial.print(" pos_demand = ");
Serial.println(pos_demand);
*/
// ecriture de la derbnière position demandé dans EEPROM
EEPROM.write(adresse, pos_demand); // lecture derniere position connu
}
}
/**************************************************************
boucle de lecture de la telecommande et affection des variables
selon le retour spécifié
variables mises à jour
pos_recue valeur DEC recue de la telecommande
pos_demand valeur convertie en une position
*/
void receiveCode() {
if (irrecv.decode(&results))
{
pos_recue = results.value;
switch (pos_recue) {
case 8925 :
pos_demand = 1;
break;
case -15811 :
pos_demand = 2;
break;
case -8161 :
pos_demand = 3;
break;
case -28561 :
pos_demand = 4;
break;
}
irrecv.resume(); // Receive the next value
}
}
Je n'ai pas la prétention de révolutionner le principe, mais je pensais que partager ce projet m'obligerait à travailler plus proprement que ce que j'aurais fait pour moi seul. Ce pont tournant a été réalisé sur la demande d'un "confrère" à qui je remettrai l'ensemble.
Je reste à l'écoute des commentaires constructifs et vous remercie pour votre indulgence
