Bon, passons à l'électronique .
Tous mes servo sont pilotés par des arduino nano .
vu le nombre d'aiguillage, j'ai standardisé la chose !
Tout d'abord le support :
.
- IMG_3282.jpg (61.49 Kio) Vu 751 fois
.
Que je pourrai coller soit horizontalement soit verticalement sous la table .
Ensuite, tous les module ont la même taille est fait avec des plaquettes d’essai à bande
en voilà un en construction :
.
- IMG_3283.jpg (71.32 Kio) Vu 751 fois
.
et dand le support :
.
- IMG_3284.jpg (69.19 Kio) Vu 751 fois
.
Pour des raisons pratiques, je me suis limité à commander 4 servo maximum par arduino .
Ensuite, bien sûr, chaque module est fait selon les besoins du moment .
Commande par impulsion ou par niveau logique donné par bouton poussoir , par interrupteur ou par signal venant d'un autre arduino . . . .Y en a pour tous les goût .
Par exemple, voici celui que j'ai fait dernièrement pour commander l'aiguillage triple qui dessert les trois voies de garage :
.
- IMG_3286.jpg (81.45 Kio) Vu 751 fois
.
Il pilote deux servo qui fonctionnent en simultanés .
Il y a 3 entrés pour boutons poussoir pour sélectionner la voie
Il y a 3 sorties supplémentaire pour commander 3 relais d'alimentation DCC des voies .
Et bien s^r les sorties pour la signalisation par leds .
Et voilà ce que ça donne comme programme :
.
Code : Tout sélectionner
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * Sélection de trois voies marchandise * * * * *
* * * * * BP1 pour les aiguillages RP 09 et RP 10 * * * * *
* * * * * BP2 pour l' aiguillages RP 11 * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Nano 13 avec ajout de sorties relais pour alim voies *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Programme opérationnel
* Deux servo pour actionner un aiguillage triple
* Commande par trois boutons poussoirs
* entree : changement d'état par impulsion
1
-----O----- SV1 SV2
SV1 / Voie 1 1 1
/ 2 Voie 2 1 0
--------------------------O----- Voie 3 0 0
\
\SV2 3
-----O------
*/
#include <Servo.h>
const byte pinServo1 = 3; // Servo commandant l'aiguillage SV 1
const byte pinServo2 = 4; // Servo commandant l'aiguillage SV 2
const byte pinEntree1 = A3; // Entrée pour le bouton poussoir Voie 1
const byte pinEntree2 = A4; // Entrée pour le bouton poussoir voie 2
const byte pinEntree3 = A5; // Entrée pour le bouton poussoir voie 3
const byte PinLedVoie [3] = {5,6,7};
const byte PinRelai [3] = {9,10,11};
int Voie ;
int MiniMax1[2] = {700,1000} ; // défini l'amplitude du mouvement
int MiniMax2[2] = {650,1050} ;
int vitesse[2] = {-1,1} ;
int AllumLed [3][3] = {
{1,0,0}, // Eclairage voie 1
{0,1,0}, // Eclairage voie 2
{0,0,1}, // Eclairage voie 3
};
int AllRelais [3][3]= {
{0,1,1}, // Relai alim voie 1
{1,0,1}, // Relai alim voie 2
{1,1,0}, // Relai alim voie 3
};
int y ;
//************* Configuration des mouvements servo selon plan de voie ***********
// ( inutilisé dans ce programme )
boolean Inverse = false ; // false : le sens de rotation des 2 servo est le même
// true : le sens de rotation est inverse .
// Commutation par inverseur sur A2
const byte pinInvers = 2;
//*************************************************************************************
Servo monServo1;
int Avance1;
int angle1;
int angleFinal1;
boolean Sens1;
Servo monServo2;
int Avance2;
int angle2;
int angleFinal2;
boolean Sens2;
boolean Etat1;
boolean Etat1lu;
boolean Etat2;
boolean Etat2lu;
boolean Mvt1;
boolean Mvt2;
boolean Mvt;
void setup()
{
pinMode (pinEntree1, INPUT);
pinMode (pinEntree2, INPUT);
pinMode (pinEntree3, INPUT);
pinMode (pinInvers, INPUT);
for (y=0 ; y <= 2 ; y++){ pinMode(PinLedVoie [y], OUTPUT); }
for (y=0 ; y <= 2 ; y++){ pinMode(PinRelai [y], OUTPUT); }
for (y=0 ; y <= 2 ; y++){ digitalWrite(PinRelai [y], HIGH);}
Inverse = digitalRead(pinInvers);
monServo1.attach(pinServo1);
monServo1.writeMicroseconds(780);
delay(500);
angle1 = 850;
Etat1lu = true ; //
Etat1 = true ; // ces 3 valeurs déterminent la position initiale du
Sens1 = true; // servo : "true" dans un sens, "false" dans l'autre.
Mvt1 = true;
Avance1 = vitesse[Sens1]; angleFinal1 = MiniMax1[Sens1];
monServo2.attach(pinServo2);
monServo2.writeMicroseconds(850);
delay(500);
angle2 = 850;
Etat2lu = false ; //
Etat2 = false ; // même chose que pour le servo 1 .
Sens2 = false ; //
Mvt2 = true;
Avance2 = vitesse[Sens2]; angleFinal2 = MiniMax2[Sens2];
Voie = 0 ;
}
void loop()
{
if(!Mvt1)
{ if( digitalRead(pinEntree1)){ Etat1lu = true ;
Etat2lu = false ; Voie=0; }
if( digitalRead(pinEntree2)){ Etat1lu = true ;
Etat2lu = true ; Voie=1; }
if( digitalRead(pinEntree3)){ Etat1lu = false ;
Etat2lu = true ; Voie=2; }
if (Etat1lu == Etat1 ) { }
else{
Etat1 = Etat1lu ;
Sens1 = Etat1;
monServo1.attach(pinServo1);
Mvt1 = true;
Avance1 = vitesse[Sens1]; angleFinal1 = MiniMax1[Sens1];
}
}
if(!Mvt2)
{
if (Etat2lu == Etat2 ) { }
else{
Etat2 = Etat2lu ;
Sens2 = Etat2;
monServo2.attach(pinServo2);
Mvt2 = true;
Avance2 = vitesse[Sens2]; angleFinal2 = MiniMax2[Sens2];
}
}
if(Mvt1) {
angle1 = angle1 + Avance1;
monServo1.writeMicroseconds(angle1);
if (angle1 == angleFinal1)
{
Avance1 = 0;
monServo1.detach();
Mvt1 = false;
}
}
if(Mvt2) {
angle2 = angle2 + Avance2;
monServo2.writeMicroseconds(angle2);
if (angle2 == angleFinal2)
{
Avance2 = 0;
monServo2.detach();
Mvt2 = false;
}
}
Mvt = Mvt1 || Mvt2 ;
if(Mvt){ for (y=0 ; y <= 2 ; y++)
{ digitalWrite(PinLedVoie [y], LOW);
digitalWrite(PinRelai [y], HIGH); }
}
else { for (y=0 ; y <= 2 ; y++)
{ digitalWrite(PinLedVoie [y], AllumLed [Voie][y]);
digitalWrite(PinRelai [y], AllRelais [Voie][y]); }
}
delay(6); // conditionne la vitesse de rotation des servo
}
Ou bien celui que je suis en train de faire et qui est en cours d'essai :
.
- IMG_3285.jpg (73.49 Kio) Vu 751 fois
.
Il pilote deux servo indépendamment et par niveau logique .
et voilà le programme
Code : Tout sélectionner
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * *
* * * * * Commande des 2 aiguillages GM 12 et GM 13 * * * * *
* * * * * par niveau logique * * * * *
* * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Programme en cours
*/
#include <Servo.h>
const byte pinServo1 = 3; // Servo commandant l'aiguillage GM 12
const byte pinServo2 = 4; // Servo commandant l'aiguillage GM 13
const byte pinEntree1 = A3; // Entrée pour l'aiguillage GM 12
const byte pinEntree2 = A4; // Entrée pour l'aiguillage GM 13
const byte pinMvt = 13 ; // Sortie témoin de mouvement
int MiniMax1[2] = {700,1000} ; // défini l'amplitude du mouvement
int MiniMax2[2] = {700,1000} ;
int vitesse[2] = {-1,1} ;
int y ;
//************* Configuration des mouvements servo selon niveau logique ***********
// et positio initiale
boolean Posini1 = true ;
boolean Posini2 = false ;
//*************************************************************************************
Servo monServo1;
int Avance1;
int angle1;
int angleFinal1;
boolean Sens1;
Servo monServo2;
int Avance2;
int angle2;
int angleFinal2;
boolean Sens2;
boolean Etat1;
boolean Etat1lu;
boolean Etat2;
boolean Etat2lu;
boolean Mvt1;
boolean Mvt2;
boolean Mvt;
void setup()
{
pinMode (pinEntree1, INPUT);
pinMode (pinEntree2, INPUT);
pinMode (pinMvt, OUTPUT);
monServo1.attach(pinServo1);
monServo1.writeMicroseconds(850);
delay(500);
angle1 = 850;
Etat1lu = Posini1 ;
Etat1 = Posini1 ;
Sens1 = Posini1;
Mvt1 = true;
Avance1 = vitesse[Sens1]; angleFinal1 = MiniMax1[Sens1];
monServo2.attach(pinServo2);
monServo2.writeMicroseconds(850);
delay(500);
angle2 = 850;
Etat2lu = Posini2 ;
Etat2 = Posini2 ;
Sens2 = Posini2 ;
Mvt2 = true;
Avance2 = vitesse[Sens2]; angleFinal2 = MiniMax2[Sens2];
}
void loop()
{
if(!Mvt1)
{ if( digitalRead(pinEntree1)){ Etat1lu = !Posini1 ; }
else { Etat1lu = Posini1 ; }
if (Etat1lu == Etat1 ) { }
else{
Etat1 = Etat1lu ;
Sens1 = Etat1;
monServo1.attach(pinServo1);
Mvt1 = true;
Avance1 = vitesse[Sens1]; angleFinal1 = MiniMax1[Sens1];
}
}
if(!Mvt2)
{ if( digitalRead(pinEntree2)){ Etat2lu = !Posini2 ; }
else { Etat2lu = Posini2 ; }
if (Etat2lu == Etat2 ) { }
else{
Etat2 = Etat2lu ;
Sens2 = Etat2;
monServo2.attach(pinServo2);
Mvt2 = true;
Avance2 = vitesse[Sens2]; angleFinal2 = MiniMax2[Sens2];
}
}
if(Mvt1) {
angle1 = angle1 + Avance1;
monServo1.writeMicroseconds(angle1);
if (angle1 == angleFinal1)
{
Avance1 = 0;
monServo1.detach();
Mvt1 = false;
}
}
if(Mvt2) {
angle2 = angle2 + Avance2;
monServo2.writeMicroseconds(angle2);
if (angle2 == angleFinal2)
{
Avance2 = 0;
monServo2.detach();
Mvt2 = false;
}
}
Mvt = Mvt1 || Mvt2 ;
if(Mvt){ digitalWrite(pinMvt, HIGH); }
else { digitalWrite(pinMvt, LOW); }
delay(6); // conditionne la vitesse de rotation des servo
}
.
Ce module sera piloté par l'arduino MEGA qui gère le TCO marchandise . Il va faloir que je modifie ce tableau pour la circonstance et ça, ça va être un peu galère . Mais bon . . .
pour info , je rappelle que j'ai fait
ici une description de mes TCO . ça date un peu, les images sont dégradées , mais ça donne une idée .
voili voilou . . .
