Un tableau de commande géré par arduino
- Georges de Villette
- 2000 posts et +
- Messages : 5565
- Enregistré le : 09 mars 2021, 19:23
- Prénom : Georges
- LOCALISATION : Villette d'Anthon
- Centres d'intérêts : J'ai participé au début de Mini World Lyon .
J'aime l'électronique , la mini mécanique .
Passionné par les nouvelles technologies , imprimantes 3D , Laser , CNC . - Echelle pratiquée : Aucune
- Âge : 74
- Pays :
Chine (cn)
avr. 2021
18
18:43
Re: Un tableau de commande géré par arduino
Je vais suivre ça Hervé , avec intérêt ....
Le travail est bien une maladie !!!
Puisqu'il y a une médecine du travail !!! Coluche .
Puisqu'il y a une médecine du travail !!! Coluche .
- herwat
- 2000 posts et +
- Messages : 4953
- Enregistré le : 11 mars 2021, 16:14
- Prénom : Hervé
- LOCALISATION : Creuse
- Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino - Echelle pratiquée : H0
- Âge : 76
- Pays :
France (fr)
avr. 2021
18
20:56
Re: Un tableau de commande géré par arduino
Pour une bonne compréhension, voici une vue d'ensemble du réseau, du point de vue technique :
Tous les aiguillages sont commandés par servomoteurs eux-même commandés par arduino nano eux-même commandés pour la plupart par un arduino méga centralisateur .
Je détaille : Voici le montage du servo :
. .
et le module arduino nano :
. .
Ces modules sont tous quasiment identiques . Ils peuvent commander de 2 à 4 servo . Seul change le programme .
Il y a 2 types de module : ceux qui sont directement commandés par bouton poussoir et change donc d'état par impulsion, et ceux, les plus nombreux, commandés par un arduino méga et change donc d'état par niveau logique .
Voici le plan général des aiguillages :
. .
En fait, il y a 3 TCO : le TCO voyageur
le TCO marchandise
et un petit TCO que j'appelle dérivation et qui gérera , plus tard , "probablement", le pont tournant . . .
Le TCO marchandise étant en développement, je parlerai essentiellement du TCO voyageur qui, lui, est opérationnel :
. .
et ses entrailles :
. La suite au prochain numéro .
Tous les aiguillages sont commandés par servomoteurs eux-même commandés par arduino nano eux-même commandés pour la plupart par un arduino méga centralisateur .
Je détaille : Voici le montage du servo :
. .
et le module arduino nano :
. .
Ces modules sont tous quasiment identiques . Ils peuvent commander de 2 à 4 servo . Seul change le programme .
Il y a 2 types de module : ceux qui sont directement commandés par bouton poussoir et change donc d'état par impulsion, et ceux, les plus nombreux, commandés par un arduino méga et change donc d'état par niveau logique .
Voici le plan général des aiguillages :
. .
En fait, il y a 3 TCO : le TCO voyageur
le TCO marchandise
et un petit TCO que j'appelle dérivation et qui gérera , plus tard , "probablement", le pont tournant . . .
Le TCO marchandise étant en développement, je parlerai essentiellement du TCO voyageur qui, lui, est opérationnel :
. .
et ses entrailles :
. La suite au prochain numéro .
Modifié en dernier par herwat le 18 avr. 2021, 21:00, modifié 1 fois.
- likiki
- Site Admin
- Messages : 7102
- Enregistré le : 27 févr. 2021, 16:11
- Prénom : Christian
- LOCALISATION : Ile de France
- Centres d'intérêts : Le train miniature (H0 3R), l'impression 3D
- Echelle pratiquée : H0
- Âge : 57
- Pays :
France (fr)
- Georges de Villette
- 2000 posts et +
- Messages : 5565
- Enregistré le : 09 mars 2021, 19:23
- Prénom : Georges
- LOCALISATION : Villette d'Anthon
- Centres d'intérêts : J'ai participé au début de Mini World Lyon .
J'aime l'électronique , la mini mécanique .
Passionné par les nouvelles technologies , imprimantes 3D , Laser , CNC . - Echelle pratiquée : Aucune
- Âge : 74
- Pays :
Chine (cn)
avr. 2021
19
06:32
Re: Un tableau de commande géré par arduino
Commençons par le début ...
Un TCO c'est quoi ? Est ce que ça veut dire tableau commande ... ?
Excuse ma question , mais si je veux suivre ...
Auquel cas il y aurait 3 pupitres du genre de celui ci ? C'est ça ?
Un TCO c'est quoi ? Est ce que ça veut dire tableau commande ... ?
Excuse ma question , mais si je veux suivre ...
Auquel cas il y aurait 3 pupitres du genre de celui ci ? C'est ça ?
Le travail est bien une maladie !!!
Puisqu'il y a une médecine du travail !!! Coluche .
Puisqu'il y a une médecine du travail !!! Coluche .
- herwat
- 2000 posts et +
- Messages : 4953
- Enregistré le : 11 mars 2021, 16:14
- Prénom : Hervé
- LOCALISATION : Creuse
- Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino - Echelle pratiquée : H0
- Âge : 76
- Pays :
France (fr)
avr. 2021
19
08:37
Re: Un tableau de commande géré par arduino
Euhhh, oui Georges .
TCO : tableau de commande optique .
Il y en a effectivement 3 sur mon réseau .
TCO : tableau de commande optique .
Il y en a effectivement 3 sur mon réseau .
- Georges de Villette
- 2000 posts et +
- Messages : 5565
- Enregistré le : 09 mars 2021, 19:23
- Prénom : Georges
- LOCALISATION : Villette d'Anthon
- Centres d'intérêts : J'ai participé au début de Mini World Lyon .
J'aime l'électronique , la mini mécanique .
Passionné par les nouvelles technologies , imprimantes 3D , Laser , CNC . - Echelle pratiquée : Aucune
- Âge : 74
- Pays :
Chine (cn)
avr. 2021
19
09:08
Re: Un tableau de commande géré par arduino
Merci Hervé ....
Le travail est bien une maladie !!!
Puisqu'il y a une médecine du travail !!! Coluche .
Puisqu'il y a une médecine du travail !!! Coluche .
avr. 2021
19
09:38
Re: Un tableau de commande géré par arduino
3Il y en a effectivement 3 sur mon réseau .
- Georges de Villette
- 2000 posts et +
- Messages : 5565
- Enregistré le : 09 mars 2021, 19:23
- Prénom : Georges
- LOCALISATION : Villette d'Anthon
- Centres d'intérêts : J'ai participé au début de Mini World Lyon .
J'aime l'électronique , la mini mécanique .
Passionné par les nouvelles technologies , imprimantes 3D , Laser , CNC . - Echelle pratiquée : Aucune
- Âge : 74
- Pays :
Chine (cn)
avr. 2021
19
10:25
Re: Un tableau de commande géré par arduino
Et oui Eric ! Je t'explique :
Un pour le réseau voyageur , un pour le réseau marchandises et un pour les commandes du pont tournant !!!
Tu comprends ?
.
Pas sur la tête Hervé ! Pas sur la tête !!!!
Le travail est bien une maladie !!!
Puisqu'il y a une médecine du travail !!! Coluche .
Puisqu'il y a une médecine du travail !!! Coluche .
- herwat
- 2000 posts et +
- Messages : 4953
- Enregistré le : 11 mars 2021, 16:14
- Prénom : Hervé
- LOCALISATION : Creuse
- Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino - Echelle pratiquée : H0
- Âge : 76
- Pays :
France (fr)
avr. 2021
19
11:12
Re: Un tableau de commande géré par arduino
Georges, si tu veux faire l'exposé à ma place, y faut pas hésiter ! ! !
ça me fera des vacances !
ça me fera des vacances !
- herwat
- 2000 posts et +
- Messages : 4953
- Enregistré le : 11 mars 2021, 16:14
- Prénom : Hervé
- LOCALISATION : Creuse
- Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino - Echelle pratiquée : H0
- Âge : 76
- Pays :
France (fr)
avr. 2021
19
11:46
Re: Un tableau de commande géré par arduino
Pour fixer les idée;
voilà le tableau voyageur "in situ" : .
L'emplacement du futur tableau marchandise : .
Et le petit tableau qui gère la dérivation et provisoirement en analogique le pont tournant .
voilà le tableau voyageur "in situ" : .
L'emplacement du futur tableau marchandise : .
Et le petit tableau qui gère la dérivation et provisoirement en analogique le pont tournant .
avr. 2021
19
11:49
Re: Un tableau de commande géré par arduino
Ah ok!
Je pensais que tout serait sur un même tableau...
Je pensais que tout serait sur un même tableau...
- Al1baba
- Posteur habitué
- Messages : 81
- Enregistré le : 11 mars 2021, 12:40
- Prénom : Alain
- LOCALISATION : Figeac (46)
- Centres d'intérêts : Spéléo Il y a quelques années, mais plus maintenant.
L'Histoire ferroviaire. Les voyages, La Gastronomie. Le modélisme ferroviaire bien sûr après une période de modélisme naval.
Récemment : Généalogie. En attendant que ça sèche - Echelle pratiquée : H0
- Pays :
France (fr)
avr. 2021
20
16:04
Re: Un tableau de commande géré par arduino
- herwat
- 2000 posts et +
- Messages : 4953
- Enregistré le : 11 mars 2021, 16:14
- Prénom : Hervé
- LOCALISATION : Creuse
- Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino - Echelle pratiquée : H0
- Âge : 76
- Pays :
France (fr)
avr. 2021
20
17:29
Re: Un tableau de commande géré par arduino
Pour les impatients
Voici le sketch d'un nano :
Bon . . . Je pense qu'on peut mieux faire, mais j'ai fait ce que j'ai pu avec mes connaissances et les neurones qui me reste .
Mais au moins, ça marche parfaitement .
La sortie 13, témoin de mouvement permet à l'arduino Mega d'éteindre les leds du tableau des que les aiguillages sont en mouvement . Histoire d'éviter d'engager un train avant qu'ils ne soient en positions . . . .
Voici le sketch d'un nano :
Code : Tout sélectionner
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * Gare Voyageur - Côté gauche * * * * * * *
* * * * * * * * * * * Aguillages GV 01 02 03 04 * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Programme Opérationnel
* Quatre servo
* une entrée analogique par servo
* entree niveau bas impose angle mini
* entree niveau haut impose angle maxi
*/
#include <Servo.h>
int MiniMax1[2] = {600,900} ; // Aiguillage GV01
const byte pinServo1 = 2;
const byte pinEntree1 = 2;
int MiniMax2[2] = {600,900} ; // Aiguillage GV02
const byte pinServo2 = 3;
const byte pinEntree2 = 3;
int MiniMax3[2] = {600,900} ; // Aiguillage GV03
const byte pinServo3 = 4;
const byte pinEntree3 = 4;
int MiniMax4[2] = {600,900} ; // Aiguillage GV04
const byte pinServo4 = 5;
const byte pinEntree4 = 5;
Servo monServo1;
Servo monServo2;
Servo monServo3;
Servo monServo4;
int vitesse1[2] = {-1,1} ;
int vitesse2[2] = {-1,1} ;
int vitesse3[2] = {-1,1} ;
int vitesse4[2] = {-1,1} ;
int sens1;
int sens2;
int sens3;
int sens4;
int PosActuelle1;
int PosActuelle2;
int PosActuelle3;
int PosActuelle4;
boolean Mvt;
boolean Mvt1;
boolean Mvt2;
boolean Mvt3;
boolean Mvt4;
boolean NvAncien1;
boolean NvLu1;
boolean NvAncien2;
boolean NvLu2;
boolean NvAncien3;
boolean NvLu3;
boolean NvAncien4;
boolean NvLu4;
void setup()
{
pinMode (13, OUTPUT); // Sortie témoin de mouvement des servo
monServo1.attach(pinServo1);
monServo1.writeMicroseconds(750); // Les servo sont d'abord mis en position médiane
delay(200); // avant leur position définitive
monServo2.attach(pinServo2);
monServo2.writeMicroseconds(750);
delay(200);
monServo3.attach(pinServo3);
monServo3.writeMicroseconds(750);
delay(200);
monServo4.attach(pinServo4);
monServo4.writeMicroseconds(750);
delay(200);
PosActuelle1 = 750;
PosActuelle2 = 750;
PosActuelle3 = 750;
PosActuelle4 = 750;
sens1 = 0;
sens2 = 0;
sens3 = 0;
sens4 = 0;
Mvt1 = false;
Mvt2 = false;
Mvt3 = false;
Mvt4 = false;
Mvt = Mvt1 || Mvt2 || Mvt3 || Mvt4;
// Attente pour l'initialisation du Méga soit terminée
delay(1000);
NvLu1 = analogRead(pinEntree1) > 511; NvAncien1 = !NvLu1;
NvLu2 = analogRead(pinEntree2) > 511; NvAncien2 = !NvLu2;
NvLu3 = analogRead(pinEntree3) > 511; NvAncien3 = !NvLu3;
NvLu4 = analogRead(pinEntree4) > 511; NvAncien4 = !NvLu4;
}
void loop()
/*
* J'ai fait en sorte que l'entréz ne soit lue que si
* le servo est à l'arrêt .
*/
{
NvLu1 = analogRead(pinEntree1) > 511;
NvLu2 = analogRead(pinEntree2) > 511;
NvLu3 = analogRead(pinEntree3) > 511;
NvLu4 = analogRead(pinEntree4) > 511;
if(NvLu1 == NvAncien1 && NvLu2 == NvAncien2 && NvLu3 == NvAncien3 && NvLu4 == NvAncien4 && !Mvt )
{ }
else {
if(Mvt1)
{
PosActuelle1 = PosActuelle1 + vitesse1[sens1] ;
monServo1.writeMicroseconds(PosActuelle1);
if( PosActuelle1 == MiniMax1[sens1] )
{
Mvt1 = false;
monServo1.detach();
}
}
if(Mvt2)
{
PosActuelle2 = PosActuelle2 + vitesse2[sens2] ;
monServo2.writeMicroseconds(PosActuelle2);
if( PosActuelle2 == MiniMax2[sens2] )
{
Mvt2 = false;
monServo2.detach();
}
}
if(Mvt3)
{
PosActuelle3 = PosActuelle3 + vitesse3[sens3] ;
monServo3.writeMicroseconds(PosActuelle3);
if( PosActuelle3 == MiniMax3[sens3] )
{
Mvt3 = false;
monServo3.detach();
}
}
if(Mvt4)
{
PosActuelle4 = PosActuelle4 + vitesse4[sens4] ;
monServo4.writeMicroseconds(PosActuelle4);
if( PosActuelle4 == MiniMax4[sens4] )
{
Mvt4 = false;
monServo4.detach();
}
}
if(NvLu1 == !NvAncien1 && !Mvt1 )
{
sens1 = NvLu1;
Mvt1 = true;
monServo1.attach(pinServo1);
NvAncien1 = NvLu1;
}
if(NvLu2 == !NvAncien2 && !Mvt2 )
{
sens2 = NvLu2;
Mvt2 = true;
monServo2.attach(pinServo2);
NvAncien2 = NvLu2;
}
if(NvLu3 == !NvAncien3 && !Mvt3 )
{
sens3 = NvLu3;
Mvt3 = true;
monServo3.attach(pinServo3);
NvAncien3 = NvLu3;
}
if(NvLu4 == !NvAncien4 && !Mvt4 )
{
sens4 = NvLu4;
Mvt4 = true;
monServo4.attach(pinServo4);
NvAncien4 = NvLu4;
}
}
delay(5);
Mvt = Mvt1 || Mvt2 || Mvt3 || Mvt4;
digitalWrite (13,Mvt);
}
Bon . . . Je pense qu'on peut mieux faire, mais j'ai fait ce que j'ai pu avec mes connaissances et les neurones qui me reste .
Mais au moins, ça marche parfaitement .
La sortie 13, témoin de mouvement permet à l'arduino Mega d'éteindre les leds du tableau des que les aiguillages sont en mouvement . Histoire d'éviter d'engager un train avant qu'ils ne soient en positions . . . .
- likiki
- Site Admin
- Messages : 7102
- Enregistré le : 27 févr. 2021, 16:11
- Prénom : Christian
- LOCALISATION : Ile de France
- Centres d'intérêts : Le train miniature (H0 3R), l'impression 3D
- Echelle pratiquée : H0
- Âge : 57
- Pays :
France (fr)
avr. 2021
20
18:19
Re: Un tableau de commande géré par arduino
Je t'ai mis le listing dans des balises code, c'est mieux.
Par contre, petite question, le code Arduino et le même pour un UNO comme pour un Nano où il faut le préciser ?
Par contre, petite question, le code Arduino et le même pour un UNO comme pour un Nano où il faut le préciser ?
- herwat
- 2000 posts et +
- Messages : 4953
- Enregistré le : 11 mars 2021, 16:14
- Prénom : Hervé
- LOCALISATION : Creuse
- Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino - Echelle pratiquée : H0
- Âge : 76
- Pays :
France (fr)
avr. 2021
20
19:00
Re: Un tableau de commande géré par arduino
- herwat
- 2000 posts et +
- Messages : 4953
- Enregistré le : 11 mars 2021, 16:14
- Prénom : Hervé
- LOCALISATION : Creuse
- Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino - Echelle pratiquée : H0
- Âge : 76
- Pays :
France (fr)
avr. 2021
20
19:02
Re: Un tableau de commande géré par arduino
Je viens de faire une compilation dans l'IDE arduino, en précisant UNO , . . . Pas de souci . . .
- likiki
- Site Admin
- Messages : 7102
- Enregistré le : 27 févr. 2021, 16:11
- Prénom : Christian
- LOCALISATION : Ile de France
- Centres d'intérêts : Le train miniature (H0 3R), l'impression 3D
- Echelle pratiquée : H0
- Âge : 57
- Pays :
France (fr)
avr. 2021
20
19:58
Re: Un tableau de commande géré par arduino
Oui, dans l'IDE il faut choisir le type de carte (UNO, MEGA ou NANO).
- herwat
- 2000 posts et +
- Messages : 4953
- Enregistré le : 11 mars 2021, 16:14
- Prénom : Hervé
- LOCALISATION : Creuse
- Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino - Echelle pratiquée : H0
- Âge : 76
- Pays :
France (fr)
avr. 2021
20
20:14
Re: Un tableau de commande géré par arduino
Dans la catégorie des Nano "spéciaux" et indépendant du Méga , voici le Nano 6 sur son banc d'essai :
. .
et son sketch :
Assez content moi . . . . ( en toute humilité, bien sûr ! )
. .
et son sketch :
Code : Tout sélectionner
/*
* Programme opérationnel
* Un poussoir sur entrée analogique pour changement de voie A et pas de changement voie B
* Un poussoir sur entrée analogique pour changement de voie B et pas de changement voie A
* Un poussoir sur entrée analogique sans changement de voie
* Le changement de voie A interdit le changement de voie B et réciproquement
*/
#include <Servo.h>
const byte pinServo1 = 2;
const byte pinServo2 = 3;
const byte pinServo3 = 4;
const byte pinServo4 = 5;
const byte pinBouton1 = 2;
const byte pinBouton2 = 3;
const byte pinBouton3 = 4;
int MiniMax1[2] = {600,900} ; // Amplitude du mouvement du servo 1
int MiniMax2[2] = {600,900} ;
int MiniMax3[2] = {600,900} ;
int MiniMax4[2] = {600,900} ;
int vitesse[2] = {-1,1} ;
//******************* Configuration des mouvements servo selon plan de voie *******************
boolean Inverse = true; // Indique si les sens de rotation des 2 servo A et B d'une même voie
// sont inversés ou non
// à modifier suivant la configuration du réseau
boolean InverseA = true; // Même chose pour les 2 servo de changement de voie A
boolean InverseB = true; // Même chose pour les 2 servo de changement de voie B
boolean Sensini = false; // Position du servo1 pour que son aiguillage soit droit à l'initialisation
//****************************************************************************************************
const byte Led1 = 7; // commande les leds 1 et 6
const byte Led2 = 8; // commande la led 2
const byte Led3 = 9; // commande les leds 3 et 4
const byte Led4 = 10; // commande la led 7
const byte Led5 = 11; // commande la led 8
// la led 5 est allumée en permanence
int Allumage [3][5] = {
{0,0,1,0,1}, // Changement A Bouton 1
{1,1,1,0,0}, // Pas de Changement Bouton 2
{1,0,0,1,0}, // Changement B Bouton 3
};
int Bouton;
Servo monServo1;
int vitesse1;
int angle1; // position du servo à un instant donné
int angleFinal1;
boolean Sens1; // indique si l'aiguillage doit être droit ou dévié
Servo monServo2;
int vitesse2;
int angle2;
int angleFinal2;
boolean Sens2;
Servo monServo3;
int vitesse3;
int angle3;
int angleFinal3;
boolean Sens3;
Servo monServo4;
int vitesse4;
int angle4;
int angleFinal4;
boolean Sens4;
boolean Mvt; // indique qu'il y a au moins un servo en mouvement
boolean Mvt1; // indique que le servo 1 est en mouvement
boolean Mvt2;
boolean Mvt3;
boolean Mvt4;
void setup()
{
pinMode (Led1, OUTPUT);
pinMode (Led2, OUTPUT);
pinMode (Led3, OUTPUT);
pinMode (Led4, OUTPUT);
pinMode (Led5, OUTPUT);
pinMode (13, OUTPUT );
monServo1.attach(pinServo1);
monServo1.writeMicroseconds(750);
delay(500);
angle1 = 750;
Sens1 = Sensini;
Mvt1 = true;
monServo2.attach(pinServo2);
monServo2.writeMicroseconds(750);
delay(500);
angle2 = 750;
Sens2 = Sens1^InverseA ;
Mvt2 = true;
monServo3.attach(pinServo3);
monServo3.writeMicroseconds(750);
delay(500);
angle3 = 750;
Sens3 = Sens1^Inverse ;
Mvt3 = true;
monServo4.attach(pinServo4);
monServo4.writeMicroseconds(750);
delay(500);
angle4 = 750;
Sens4 = Sens3^InverseB ;
Mvt4 = true;
vitesse1 = vitesse[Sens1]; angleFinal1 = MiniMax1[Sens1];
vitesse2 = vitesse[Sens2]; angleFinal2 = MiniMax2[Sens2];
vitesse3 = vitesse[Sens3]; angleFinal3 = MiniMax3[Sens3];
vitesse4 = vitesse[Sens4]; angleFinal4 = MiniMax4[Sens4];
Mvt = Mvt1 || Mvt2 || Mvt3 || Mvt4;
Bouton = 1 ;
digitalWrite (Led1, HIGH);
digitalWrite (Led2, HIGH);
digitalWrite (Led3, HIGH);
digitalWrite (Led4, HIGH);
digitalWrite (Led5, HIGH);
digitalWrite (13,HIGH);
}
void loop()
{
if(Mvt) { }
else {
if (analogRead(pinBouton1) > 511 ) // Changement de voie A
{Bouton = 0 ;
Sens1 = !Sensini;
Sens2 = Sens1^InverseA ;
Sens3 = !Sens1^Inverse ;
Sens4 = Sens3^InverseB ;
monServo1.attach(pinServo1);
monServo2.attach(pinServo2);
monServo3.attach(pinServo3);
monServo4.attach(pinServo4);
Mvt1 = true;
Mvt2 = true;
Mvt3 = true;
Mvt4 = true;
}
if (analogRead(pinBouton2) > 511 ) // Pas de hangement de voie
{Bouton = 1 ;
Sens1 = Sensini;
Sens2 = Sens1^InverseA ;
Sens3 = Sens1^Inverse ;
Sens4 = Sens3^InverseB ;
monServo1.attach(pinServo1);
monServo2.attach(pinServo2);
monServo3.attach(pinServo3);
monServo4.attach(pinServo4);
Mvt1 = true;
Mvt2 = true;
Mvt3 = true;
Mvt4 = true;
}
if (analogRead(pinBouton3) > 511 ) // Changement de voie B
{Bouton = 2 ;
Sens1 = Sensini;
Sens2 = Sens1^InverseA ;
Sens3 = !Sens1^Inverse ;
Sens4 = Sens3^InverseB ;
monServo1.attach(pinServo1);
monServo2.attach(pinServo2);
monServo3.attach(pinServo3);
monServo4.attach(pinServo4);
Mvt1 = true;
Mvt2 = true;
Mvt3 = true;
Mvt4 = true;
}
vitesse1 = vitesse[Sens1]; angleFinal1 = MiniMax1[Sens1];
vitesse2 = vitesse[Sens2]; angleFinal2 = MiniMax2[Sens2];
vitesse3 = vitesse[Sens3]; angleFinal3 = MiniMax3[Sens3];
vitesse4 = vitesse[Sens4]; angleFinal4 = MiniMax4[Sens4];
digitalWrite (Led1,LOW);
digitalWrite (Led2,LOW);
digitalWrite (Led3,LOW);
digitalWrite (Led4,LOW);
digitalWrite (Led5,LOW);
}
monServo1.writeMicroseconds(angle1);
if (angle1 == angleFinal1) {
vitesse1 = 0;
monServo1.detach();
Mvt1 = false;
}
angle1 = angle1 + vitesse1;
monServo2.writeMicroseconds(angle2);
if (angle2 == angleFinal2) {
vitesse2 = 0;
monServo2.detach();
Mvt2 = false;
}
angle2 = angle2 + vitesse2;
monServo3.writeMicroseconds(angle3);
if (angle3 == angleFinal3) {
vitesse3 = 0;
monServo3.detach();
Mvt3 = false;
}
angle3 = angle3 + vitesse3;
monServo4.writeMicroseconds(angle4);
if (angle4 == angleFinal4) {
vitesse4 = 0;
monServo4.detach();
Mvt4 = false;
}
angle4 = angle4 + vitesse4;
Mvt = Mvt1 || Mvt2 || Mvt3 || Mvt4;
if(!Mvt) {
digitalWrite (Led1, Allumage [Bouton][0]);
digitalWrite (Led2, Allumage [Bouton][1]);
digitalWrite (Led3, Allumage [Bouton][2]);
digitalWrite (Led4, Allumage [Bouton][3]);
digitalWrite (Led5, Allumage [Bouton][4]);
digitalWrite (13,LOW);
}
delay(6);
}
- likiki
- Site Admin
- Messages : 7102
- Enregistré le : 27 févr. 2021, 16:11
- Prénom : Christian
- LOCALISATION : Ile de France
- Centres d'intérêts : Le train miniature (H0 3R), l'impression 3D
- Echelle pratiquée : H0
- Âge : 57
- Pays :
France (fr)
avr. 2021
20
20:47
Re: Un tableau de commande géré par arduino
Tu peu être content de toi, c'est super.
- herwat
- 2000 posts et +
- Messages : 4953
- Enregistré le : 11 mars 2021, 16:14
- Prénom : Hervé
- LOCALISATION : Creuse
- Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino - Echelle pratiquée : H0
- Âge : 76
- Pays :
France (fr)
avr. 2021
21
21:19
Re: Un tableau de commande géré par arduino
Je dois reconnaitre que je me suis bien amusé sur ce programme !
Mais maintenant, passons au morceau de bravoure !
La programmation de l'arduino méga . . .
Le voilà avec son premier shield maison :
. .
Je voulais gérer les servo de ma gare cachée directement depuis le méga . . . ce fut un cuisant échec ! ! ! . . . .
Je n'ai jamais obtenu un fonctionnement fiable et n'ai jamais compris pourquoi .
C'est à ce moment là que j'ai opté pour la configuration actuelle : des nano pour gérer les servo et le méga pour commander les nano .
En fait, cette config a plusieurs avantages :
1 - Scinder les problèmes
2 - Faciliter le câblage
3 - Permettre une éventuelle maintenance plus aisée .
Je dis "éventuelle" parce que, jusqu'à maintenant il n'y en a pas . . . . c'est d'une fiabilité remarquable et . . . j'en suis le premier étonné !
Le shield définitif est à peu prés similaire
et voici le programme :
Voilà, vous savez tous , enfin pour le TCO voyageur . Pour le "marchandise", il faudra patienter un peu et même, peut-être beaucoup !
Alors je dirais quand même :
Mais maintenant, passons au morceau de bravoure !
La programmation de l'arduino méga . . .
Le voilà avec son premier shield maison :
. .
Je voulais gérer les servo de ma gare cachée directement depuis le méga . . . ce fut un cuisant échec ! ! ! . . . .
Je n'ai jamais obtenu un fonctionnement fiable et n'ai jamais compris pourquoi .
C'est à ce moment là que j'ai opté pour la configuration actuelle : des nano pour gérer les servo et le méga pour commander les nano .
En fait, cette config a plusieurs avantages :
1 - Scinder les problèmes
2 - Faciliter le câblage
3 - Permettre une éventuelle maintenance plus aisée .
Je dis "éventuelle" parce que, jusqu'à maintenant il n'y en a pas . . . . c'est d'une fiabilité remarquable et . . . j'en suis le premier étonné !
Le shield définitif est à peu prés similaire
et voici le programme :
Code : Tout sélectionner
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Mega commandant trois nano pilotant les servo gérant la gare voyageur *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Programme Opérationnel
*
* Onze boutons poussoirs
* Quinzes leds
*
*/
/* Affectation des entrées analogiques pour boutons poussoirs
de commpande */
int pinBouton [11] = {2,3,4,5,6,7,8,9,10,11,12}; // pin A2 à A12
/* Affectation des sorties pour les LEDs témoins */
int GrLed [15] = {26,28,30,32,34,36,38,40,42,44,46,48,50,51,53};
int Allumage [12][15] = { //la valeur 2 n'impose pas de changement .
{1,0,2,2,2,2,2,2,2,2,2,2,2,2,2},
{0,1,2,2,2,2,2,2,2,2,2,2,2,2,2},
{2,2,1,0,0,0,0,0,0,0,1,0,0,0,1},
{2,2,0,1,0,0,0,0,0,0,1,1,0,0,1},
{2,2,0,0,1,0,0,0,0,0,1,1,1,2,2},
{2,2,0,0,0,1,0,0,0,0,1,1,1,2,2},
{2,2,0,0,0,0,1,0,0,0,1,1,1,2,2},
{2,2,2,2,2,2,2,1,2,2,2,2,2,2,2},
{2,2,2,2,2,2,2,2,1,2,2,2,2,2,2},
{2,2,2,2,2,2,2,2,2,1,0,2,2,2,2},
{2,2,2,2,2,2,2,2,2,2,2,2,2,1,0},
{0,1,1,0,0,0,0,0,0,0,1,0,0,0,1}, // ligne prévue pour l'initialisation
};
int Precedent [15] = {0,1,1,0,0,0,0,0,0,0,1,0,0,0,1};
/* Grille des Etats de commande des onze servo répartis sur 3 platines nano
la valeur 0 correspond à l'aiguillage droit
la valeur 1 correspond à l'aiguillage dévié
la valeur 2 correspond à un état indifférent
*/
int Etat [12][11] = {
{2,0,2,2,2,0,2,2,2,2,2},
{2,1,2,2,2,1,2,2,2,2,2},
{1,2,0,2,1,2,0,2,2,2,2},
{1,2,1,0,1,2,1,2,2,2,2},
{1,2,1,1,2,2,2,1,0,2,2},
{1,2,1,1,2,2,2,0,0,1,0},
{1,2,1,1,2,2,2,0,0,0,0},
{2,2,2,2,2,2,2,2,1,2,2},
{2,2,2,2,2,2,2,2,2,2,1},
{0,2,2,2,2,2,2,2,2,2,2},
{2,2,2,2,0,2,2,2,2,2,2},
{1,1,0,2,1,1,2,2,2,2,2}, // ligne prévue pour l'initialisation
};
/* Affectation des sorties servo */
int pinServo [11] = {2,3,4,5,6,7,8,10,11,12,13}; /* pin D"x" */
/* Affectation des entrées témoins de mouvements servo */
const byte EmvtP1 = 14 ; /* pin D"x" */
const byte EmvtP2 = 15 ;
const byte EmvtP3 = 16 ;
const byte Relai5 = 17 ; // relais commandant l'alimentation des voies "parking"
const byte Relai6 = 18 ;
const byte Relai7 = 19 ;
const byte Relai89 = 20 ;
boolean Mvt ;
boolean Mvt1 ;
boolean Mvt2 ;
boolean Mvt3 ;
boolean Bouton ;
int y ; // variables d'incrémentation
int z ;
int BoutonSel ; // numéro du bouton appuyé
void setup()
{
for (y=0 ; y <= 10 ; y++){ pinMode(pinServo [y], OUTPUT); }
pinMode (EmvtP1, INPUT);
pinMode (EmvtP2, INPUT);
pinMode (EmvtP3, INPUT);
pinMode (Relai5, OUTPUT);
pinMode (Relai6, OUTPUT);
pinMode (Relai7, OUTPUT);
pinMode (Relai89, OUTPUT);
for (y=0 ; y <= 14 ; y++){ pinMode(GrLed [y], OUTPUT); }
BoutonSel = 11; // sélectionne les lignes d'initialisation
}
void loop()
{
Mvt1 = digitalRead( EmvtP1 );
Mvt2 = digitalRead( EmvtP2 );
Mvt3 = digitalRead( EmvtP3 );
Mvt = Mvt1 || Mvt2 || Mvt3 ;
if(!Mvt) {
Bouton = LOW;
for (y=0 ; y <= 10 ; y++)
{
if ( analogRead( pinBouton [y]) > 511 ){ Bouton = HIGH; }
if (Bouton){
for (z=0 ; z <= 14 ; z++)
{
if ( Allumage [BoutonSel][z] == 2 ) {}
else {Precedent [z] = Allumage [BoutonSel][z]; }
}
BoutonSel = y;
break;
}
}
}
if(Mvt) {
for (y=0 ; y <= 14 ; y++){ digitalWrite(GrLed [y], LOW); }
digitalWrite( Relai5, HIGH );
digitalWrite( Relai6, HIGH );
digitalWrite( Relai7, HIGH );
digitalWrite( Relai89, HIGH );
}
for (y=0 ; y <= 10 ; y++)
{
if ( Etat [BoutonSel][y] == 2 ) { }
else {digitalWrite(pinServo [y], Etat [BoutonSel][y] ); }
}
if(!Mvt) {
for (y=0 ; y <= 14 ; y++)
{
digitalWrite(GrLed [y], Precedent[y]);
}
digitalWrite( Relai5, !Precedent[4]);
digitalWrite( Relai6, !Precedent[5]);
digitalWrite( Relai7, !Precedent[6]);
if (Precedent[7] || Precedent[8] ){ digitalWrite( Relai89, LOW); }
}
}
Alors je dirais quand même :
avr. 2021
21
21:58
Re: Un tableau de commande géré par arduino
Ce ne sont plus des neurones que tu as dans la tête, mais des nanos arduino
Ceci dit, beau boulot...
Ceci dit, beau boulot...