Blog du réseau du Mesnil-sur-Jorg
jeudi 18 avril 2024
|
|
Le réseau : Platine de gestion des aiguillages par arduino ... la suite
Il restait à déterminer la manière de reporter les indicateurs visuels de position des aiguillages sur le TCO.
Deux choix : soit utiliser un des deux micro-contacts de chaque moteur d'aiguillages, soit de le faire par programmation de l'arduino.
Dans ce deuxième cas, encore 2 choix s'offrent à moi.
Soit utiliser un système dit de "Charlieplexing" décrit ici
mais ce système n'exonère pas de l'ajout d'un "registre de décallage" 74HC595 pour ajouter 8 sorties supplémentaires. On a besoin de 5 sorties pour gérer 16 leds et 2 autres pour les leds de visualisation du choix des butées en cours de réglage. Le compte est bon mais je ne sais pas si je saurai adapter le code du CharliePlexing au fonctionnement des 74HC595
La deuxième solution serait d'utliser 2 de ces petites bêtes mises en série ce qui offrirait 16 sorties .... il en manquerait donc encore 2. Donc, il en faudrait 3 bêtes .... pas certain que j'ai la place sur la platine.
LA SUITE ....
Un intervenant du groupe de Serge Ducatez sur FB m'apprend qu'il n'est pas possible de réaliser un "CharliePlexing" avec des 74HC595. Donc, seule solution utilisation de 3 de ces petites bêtes pour gérer directement les leds.
Voici les tests de gestion avec deux 74HC595 par un arduino (dans cet exemple, le programme allume/éteint successivement chaque jeu des leds "position direct". Les leds "position déviées sont branchées en parrallèle mais en sens inverse.
Voici le PCB qui en découle .... plus beaucoup de place !!!!
.png)
//*************************************************************************
// GESTION DE 8 AIGUILLAGES PAR SERVOMOTEURS
// fichier Gestion_8_servos
//*************************************************************************
// le 04/01/2021 à 11:09
// fonctionnement testé le 11/01/2021 20:23 => OK => à voir fonctionnement de plusieurs servo en même temps
// essais du 12/01/2021 => mettre le do ... while dans une boucle pour chaque servo => pas OK
// MAJ 24/01/2021 => mettre tous les servos au point milieu si aucun n'est sélectionné en réglage.
// Test 08/02/2021 20:28 => OK voir ci-dessous
// * à terminer gestion des leds du TCO
// * fonctionnement de plusieurs aiguillages en même temps
// * remplacement des delay() par millis()
//=========================================================================
// I) Détection du mode de fonctionnement par BP permanent connecté sur A0
// I-a le BP est enfoncé en position basse => mode "REGLAGE"
// - sélection du servomoteur concerné sur A2
// - positionnement du servo concerné au point milieu
// - sélection de la butée à régler sur A4
// - BP enregistrement sur eeprom sur A5
// - si aucun aiguillage n'est sélectionné, mise au point milieu de tous les servos.
// I-b le BP reste en position haute => mode "COMMANDE"
// - sélection du BP enfoncé sur A1
// - connection du servomoteur concerné au pin + 2
// - lecture des données de ce servomoteur
// - basculement de la position
// - enregistrement en eeprom
// I-c Gestion des 16 leds (bicolores) concernées sur le TCO
//=========================================================================
//*************************************************************************
// - chaque servo doit avoir sa propre butée minni et maxi et donc son point milieu (on peut se contenter de le calculer)
// - le réglage des butées sera donc individuel
// - la vitesse de déplacement peut-être commune. Lidéal est qu'elle puisse être réglée par un potentiomètre et mise en mémoire.
// - toutes ces caractéristiques doivent poivoir être enregistrées en EEprom ainsi que sa dernière poistion.
// - chaque servo doit pouvoir être détaché en fin de course et donc attaché en début de service
// - le mode REGLAGE doit être séparé du mode UTIISATION.
// - en mode REGLAGE, la validation de ces derniers doit être confirmée par un busser et la led interne
// - En mode UTILISATION, une seule touche avec le stylet doit faire passer l'aiguillage d'un état à un autre.
// - Possibilité de BP pour les tests.
// - la position de chacun des aiguillages sera reportée sur le TCO par 2 leds bicolores non polarisées
// (2 pattes) : une pour le sens "Direct" et une pour le sens "Dévié". Le plus simple étént de mettre ces led en tête bêche.
// - un petit montage électronique sera sans doute nécessaire pour palier à la différence de luminosité entre une led verte et une led rouge en //.
//**************************************************************************
#include "EEPROM.h" // bibliothèque pour gérer la mise en mémoire
#include "Servo.h" // bibliothèque pour gérer les servos
#include "Wire.h"
#include "LiquidCrystal_PCF8574.h" // bibliothèque pour gérer les affichages sur un écran LCd
LiquidCrystal_PCF8574 lcd(0x27); // défini l'adresse de l'écran LCD 0x27 for a 16 chars and 2 line display
Servo servoAiguillage[8];
#define limitAngleMin 1200
#define limitAngleMax 1800
#define PointMilieuT 1500
int angleMin[8]; // à initialiser dans l'eeprom
int angleMax[8]; // à initialiser dans eeprom
int angleIntermediaire[8]; // valeur de l'angle intermédiaire pendant le mouvement
int DernierePositionServo[8]; // PointMilieuT = milieu, angleMin[0] = gauche, angleMax[0] = droite => à lire dans eeprom
int sensMouvement[8];
int Limite[8];
const byte vitesse = 1; // multiplicateur permettant de régler la vitesse de déplacement
const byte Temporisation = 4;
unsigned long departTache1 = 0;
int valeurLectureButee; // valeur de la résistance variable transcrite en mS
int validationReglageButee; // état du bouton de validation des données
byte numPoussoir;
#define pinServo 3 // Les servos sont connectés à partir de D3
/* A reprendre pour brancher autrement
#define pinBuzzer 13 // Le buzzer est connecté sur D13
*/
#define pinBPChoixMode A0 // BP choix mode sur A0
#define pinBPAiguillages A1 // BP aiguillages sur A1
#define pinSwitchSelecteurServo A2 // les 8 switches de sélection du servo à régler sur A2
#define pinSelecteurButee A3 // switche de sélection de la butée (gauche/droite) en cours de réglage sur A3
#define pinSDA A4 // Réservé pour l'affichage si carte Uno
#define pinSCL A5 // Réservé pour l'affichage si carte Uno
#define pinRVButees A6 // la résistance variable de réglage des butées sur A4 => A6 en production
#define pinBPValidationReglage A7 // le BP de validation des réglages sur A5 => A7 en production
// les drapeaux
int dernierServoReglage = -1;
bool Y = 0; // flag affichage mode REGLAGE
bool Z = 0; // flag affichage mode COMMANDE
bool X = 0; // flag affichage butée droite (angle max)
bool W = 0; // flag affichage butée gauche (angle min))
bool flagPM = 0; // flag de mise au point milieu des servos pour maintenance
/* =========== GESTION DE TROIS 74HC595 en série par Arduino ================ */
const int data_Pin = 11; //pin 14 (DS) du 74HC595 (Entrée)
const int verrou_Pin = 12; //pin 12 (ST_CP) du 74HC595 (Horloge de registre de sortie)
const int horloge_Pin = 13; //pin 11 (SH_CP) du 74HC595 (Horloge de registre de décalage)
const int pinDepartLed = 0;
// nombre de 74HC595 en série
#define Nombre_74hc595 3
#define numOfRegisterPins Nombre_74hc595 * 8
boolean Registres[numOfRegisterPins];
void clearRegisters(){
//Place tous les pins du 74HC595 à l'état "OFF"
for(int i = numOfRegisterPins - 1; i >= 0; i--){
Registres[i] = LOW;
} // Fin de for
} // Fin de fonction
void writeRegisters(){
//Enregistrer et afficher les valeurs dans le registre
//A n'executer que APRES que toutes les valeurs aient été programmées
digitalWrite(verrou_Pin, LOW);
for(int i = numOfRegisterPins - 1; i >= 0; i--){
digitalWrite(horloge_Pin, LOW);
int val = Registres[i];
digitalWrite(data_Pin, val);
digitalWrite(horloge_Pin, HIGH);
} // Fin de for
digitalWrite(verrou_Pin, HIGH);
} // Fin de fonction
void setRegisterPin(int index, int value){
//Place un pin du 74HC595 à l'état HAUT ou BAS
Registres[index] = value;
} // Fin de fonction
int allumeLed(int numLed, int couleurLed){
if(couleurLed == 0){
// couleur verte voie directe active & voie déviée inactive
setRegisterPin(pinDepartLed + ((numLed - 1) * 2), LOW);
setRegisterPin(pinDepartLed + ((numLed - 1) * 2) + 1, HIGH);
writeRegisters();
} else if(couleurLed == 1){
// couleur rouge voie directe inactive & voie déviée active
setRegisterPin(pinDepartLed + ((numLed - 1) * 2), HIGH);
setRegisterPin(pinDepartLed + ((numLed - 1) * 2) + 1, LOW);
writeRegisters();
} else {
// led éteinte
setRegisterPin(pinDepartLed + ((numLed - 1) * 2), LOW);
setRegisterPin(pinDepartLed + ((numLed - 1) * 2) + 1, LOW);
writeRegisters();
} // fin de if
} // Fin de fonction
/* ================== FIN DE GESTION DE TROIS 74HC595 ================== */
byte CalculLimite(){
if (DernierePositionServo[numPoussoir] == PointMilieuT){ // le servo est au PointMilieuT, il doit regagner angleMin[0]
sensMouvement[numPoussoir] = -1;
Limite[numPoussoir] = angleMin[numPoussoir];
DernierePositionServo[numPoussoir] = angleMin[numPoussoir];
} else if (DernierePositionServo[numPoussoir] == angleMin[numPoussoir]){ // le servo est en butée gauche, il doit regagner angleMax[0]
sensMouvement[numPoussoir] = 1;
Limite[numPoussoir] = angleMax[numPoussoir];
DernierePositionServo[numPoussoir] = angleMax[numPoussoir];
} else { // le servo est en butée droite (ou autre), il doit regagner angleMin[0]
sensMouvement[numPoussoir] = -1;
Limite[numPoussoir] = angleMin[numPoussoir];
DernierePositionServo[numPoussoir] = angleMin[numPoussoir];
}
}
void InterruptBouton() {
// fonction pour déterminer le BP appuyé (par interruption sur D2)
numPoussoir = (analogRead(pinBPAiguillages) + 64) / 128;
Serial.println(numPoussoir);
} // Fin de fonction
void setup() {
pinMode(LED_BUILTIN, OUTPUT); // Initialise la led incorporée
Serial.begin(9600); // connexion au moniteur série de l'ordinateur
/* Gestion de l'interruption sur D2 pour les BP des aiguillages */
pinMode(pinBPAiguillages, INPUT); //entrée analogique des boutons réglée en entrée
attachInterrupt(0, InterruptBouton, HIGH); //interruption sur pin D2 (interrupt 0)
/* ============================================================= */
/* Gestion de trois 74HC595 pour la gestion des leds du TCO */
pinMode(data_Pin, OUTPUT);
pinMode(verrou_Pin, OUTPUT);
pinMode(horloge_Pin, OUTPUT);
//Reset tous les pins du 74HC595
clearRegisters();
writeRegisters();
/* ========================================================= */
/* Initialisation de l'écran LCD */
Wire.begin();
Wire.beginTransmission(0x27);
int error = Wire.endTransmission();
if (error == 0) {
Serial.println(": LCD found.");
} else {
Serial.print("Error: ");
Serial.print(error);
Serial.println(": LCD not found.");
} // fin de if (error == 0)
lcd.begin(16, 2); // initialize the lcd
lcd.setBacklight(255);lcd.clear();lcd.home();
/* ============================== */
/* lecture des derniers réglages dans l'eeprom */
/* Initialisation si première utilisation */
/* les informations du servo 1 sont dans les bytes 0 à 9, ceux du servo 2 de 10 à 19 ... and so on ... */
for(byte i = 0; i < 8; i++)
{
angleMin[i] = EEPROM.read(i * 10) | ((int)EEPROM.read((i * 10) + 1)) << 8; // lecture des 2 bytes pour int angleMin[]
if (angleMin[i] > 1500 || angleMin[i] < limitAngleMin){ // si incohérence de valeur ou initialisation (=255)
angleMin[i] = limitAngleMin; // on enregistre la limite pour angleMin
EEPROM.update((i * 10), angleMin[i] & 0xFF); // écrit le premier byte de la valeur int
EEPROM.update((i * 10) + 1, angleMin[i] >> 8); // écrit le second byte de la valeur int
} // fin de if (angleMin[i] > 1500 || angleMin[i] < 256)
angleMax[i] = EEPROM.read((i * 10) + 2) | ((int)EEPROM.read((i * 10) + 3)) << 8;// lecture des 2 bytes pour int angleMax[]
if (angleMax[i] < 1500 || angleMax[i] > limitAngleMax){ // si incohérence de valeur ou initialisation (=255)
angleMax[i] = limitAngleMax; // on enregistre la limite pour angleMax
EEPROM.update((i * 10) + 2, angleMax[i] & 0xFF); // écrit le premier byte de la valeur int
EEPROM.update((i * 10) + 3, angleMax[i] >> 8); // écrit le second byte de la valeur int
} // fin de if (angleMax[i] == 0)
DernierePositionServo[i] = EEPROM.read((i * 10) + 4) | ((int)EEPROM.read((i * 10) + 5)) << 8;
if (DernierePositionServo[i] < limitAngleMin || DernierePositionServo[i] > limitAngleMax){
DernierePositionServo[i] = PointMilieuT;
EEPROM.update((i * 10) + 4, DernierePositionServo[i] & 0xFF); // écrit le premier byte de la valeur int
EEPROM.update((i * 10) + 5, DernierePositionServo[i] >> 8); // écrit le second byte de la valeur int
} // if (DernierePositionServo[i] < ...
/* fin de lecture des données et d'initialisation de l'eeprom */
/* positionnement à la derniere poition */
angleIntermediaire[i] = DernierePositionServo[i]; // on met le servo à sa dernière position
servoAiguillage[i].attach(pinServo + i);
servoAiguillage[i].writeMicroseconds(angleIntermediaire[i]);
delay(25);
lcd.setBacklight(255); lcd.clear(); lcd.home();
lcd.setCursor(0, 0); lcd.noCursor();
lcd.print("Aiguillage ");
lcd.setCursor(11, 0); lcd.noCursor();
lcd.print(i + 1);
lcd.setCursor(0, 1);
lcd.noCursor();
lcd.print(angleIntermediaire[i]);
//delay(2000);
delay(125);
servoAiguillage[i].detach();
} // fin de for
} // fin de setup
void loop() {
if (analogRead(pinBPChoixMode) < 512) {
//************************************
// Bouton MODE enfoncé => mode REGLAGE
//************************************
delay(25);
if (Y == 0){
//Serial.print("Bouton : "); // Debug
//Serial.print(pinBPChoixMode); // Debug
//Serial.print(" en mode REGLAGE : "); // Debug
//Serial.println(analogRead(pinBPChoixMode)); // Debug
//tone(pinBuzzer,5000,500);
Serial.println("MODE REGLAGE : ");
lcd.setBacklight(255);lcd.clear();lcd.home();
lcd.print("MODE REGLAGE");
//tone(pinBuzzer,2000,300);
Y += 1; // flag choix REGLAGE
Z = 0; // RAZ flag choix COMMANDE
} // fin de if (Y == 0)
// Détermination de l'aiguillage en cours de réglage
byte ServoEnCours = (analogRead(pinSwitchSelecteurServo) + 64) / 128; // retourne le n° du servo à régler sélectionné par switches
delay(25); // pour éviter les rebonds ... utilité à vérifie
//ServoEnCours = 0; //pour les tests
if (ServoEnCours < 8) {
if (ServoEnCours != dernierServoReglage){
Serial.print("Reglage servo : "); // Debug
Serial.print(ServoEnCours); // Debug
Serial.println(". "); // Debug
lcd.setBacklight(255);lcd.clear();lcd.home();
lcd.setCursor(0, 0);
lcd.print("Reglage servo ");
lcd.setCursor(14,0);
lcd.print(ServoEnCours);
servoAiguillage[ServoEnCours].attach(pinServo + ServoEnCours); // on connecte le servo à régler au pin correspondant à partir du pin 2
dernierServoReglage = ServoEnCours;
X = 0; // RAZ flag affichage butée droite (angle max)
W = 0; // RAZ flag affichage butée gauche (angle min)
} else { // else de if (ServoEnCours != dernierServoRegle)
// Détermination de la butée (angleMin / angleMax) en cours de réglage
// ButeeEnCours = 0 => bouton appuyé => butée droite (angleMax)
// ButeeEnCours = 1023 => bouton relaché => butée gauche (angleMin)
int ButeeEnCours = analogRead(pinSelecteurButee);
delay(25);
if (ButeeEnCours < 512) {
// bouton = enfoncé => on définit que le réglage concerne angleMax
if (X == 0){
Serial.print("Bouton enfoncé :");
Serial.print(ButeeEnCours);
Serial.println(". Réglage butée DROITE (angle maxi).");
lcd.setCursor(0, 1);
lcd.print("angle Max");
servoAiguillage[ServoEnCours].writeMicroseconds(PointMilieuT); // positionne le servo au point milieu
delay(Temporisation);
X += 1;
W = 0; // RAZ flag affichage butée gauche (angle min))
} // fin de if (X == 0)
// Lecture de l'angle
valeurLectureButee = analogRead(pinRVButees); // Lecture de la résistance variable => valeurs de 0 à 1023)
delay(25);
valeurLectureButee = map(valeurLectureButee, 0, 1023, PointMilieuT, limitAngleMax); // conversion en microsecondes
servoAiguillage[ServoEnCours].writeMicroseconds(valeurLectureButee); // positionne le servomoteur entre le point milieu et angle Max
delay(Temporisation);
//if (valeurLectureButee == limitAngleMax) tone(pinBuzzer,6000,75);
// Enregistrement du réglage par l'action du bouton validation
validationReglageButee = analogRead(pinBPValidationReglage);
delay(25);
if ( validationReglageButee > 512) {
// le bouton poussoir de validation a été appuyé
digitalWrite(LED_BUILTIN, HIGH);
angleMax[ServoEnCours] = valeurLectureButee;
angleIntermediaire[ServoEnCours] = angleMax[ServoEnCours];
DernierePositionServo[ServoEnCours] = angleMax[ServoEnCours];
Serial.print("Angle maxi N° "); //Débug
Serial.println(ServoEnCours); //Débug
Serial.print("réglé à "); //Débug
Serial.println(angleMax[ServoEnCours]); //Débug
lcd.setBacklight(255);lcd.clear();lcd.home();
lcd.setCursor(0, 0);
lcd.print("Angle maxi ");
lcd.setCursor(12, 0);
lcd.print(ServoEnCours);
lcd.setCursor(0, 1);
lcd.print("regle a ");
lcd.setCursor(12,1);
lcd.print(angleMax[ServoEnCours]);
EEPROM.update((ServoEnCours * 10) + 2, angleMax[ServoEnCours] & 0xFF); // écrit le premier byte de la valeur int angleMax
EEPROM.update((ServoEnCours * 10) + 3, angleMax[ServoEnCours] >> 8); // écrit le second byte de la valeur int angleMax
EEPROM.update((ServoEnCours * 10) + 4, DernierePositionServo[ServoEnCours] & 0xFF); // écrit le premier byte de la valeur int
EEPROM.update((ServoEnCours * 10) + 5, DernierePositionServo[ServoEnCours] >> 8); // écrit le second byte de la valeur int
//tone(pinBuzzer,1000,75);
digitalWrite(LED_BUILTIN, LOW);
} // fin de if ( validationReglageButee > 512)
} else { // else de if (ButeeEnCours < 512)
// bouton = relaché => on définit que le réglage concerne angleMin
if (W == 0){
Serial.print("Bouton relaché :");
Serial.print(ButeeEnCours);
Serial.println(". Réglage butée GAUCHE (angle min)."); // Debug
lcd.setCursor(0, 1);
lcd.print("angle Min");
servoAiguillage[ServoEnCours].writeMicroseconds(PointMilieuT); // positionne le servo au point milieu
delay(25);
W += 1;
X = 0; // RAZ flag affichage butée droite (angle max)
} // fin de if (W == 0)
// Lecture de l'angle
valeurLectureButee = analogRead(pinRVButees); // Lecture de la résistance variable sur le pin A2 => valeurs de 0 à 1023)
delay(25);
valeurLectureButee = map(valeurLectureButee, 0, 1023, limitAngleMin, PointMilieuT);// conversion en microsecondes
servoAiguillage[ServoEnCours].writeMicroseconds(valeurLectureButee); // positionne le servomoteur
delay(Temporisation);
// if (valeurLectureButee == limitAngleMin) tone(pinBuzzer,6000,75);
// Enregistrement du réglage par l'action du bouton validation
validationReglageButee = analogRead(pinBPValidationReglage);
delay(50);
if (validationReglageButee > 512) { // on détecte si le bouton poussoir de validation a été appuyé
// le bouton poussoir de validation a été appuyé
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
angleMin[ServoEnCours] = valeurLectureButee;
angleIntermediaire[ServoEnCours] = angleMin[ServoEnCours];
DernierePositionServo[ServoEnCours] = angleMin[ServoEnCours];
Serial.print("Angle mini N° "); //Débug
Serial.println(ServoEnCours); //Débug
Serial.print("regle a "); //Débug
Serial.println(angleMin[ServoEnCours]); //Débug
lcd.setBacklight(255);lcd.clear();lcd.home();
lcd.setCursor(0, 0);
lcd.print("Angle mini ");
lcd.setCursor(12, 0);
lcd.print(ServoEnCours);
lcd.setCursor(0, 1);
lcd.print("position ");
lcd.setCursor(12,1);
lcd.print(angleMin[ServoEnCours]);
EEPROM.update((ServoEnCours * 10) + 0, angleMin[ServoEnCours] & 0xFF); // écrit le premier byte de la valeur int angleMax
EEPROM.update((ServoEnCours * 10) + 1, angleMin[ServoEnCours] >> 8); // écrit le second byte de la valeur int angleMax
EEPROM.update((ServoEnCours * 10) + 4, DernierePositionServo[ServoEnCours] & 0xFF); // écrit le premier byte de la valeur int
EEPROM.update((ServoEnCours * 10) + 5, DernierePositionServo[ServoEnCours] >> 8); // écrit le second byte de la valeur int
//tone(pinBuzzer,1000,75);
digitalWrite(LED_BUILTIN, LOW);
} // fin de if (validationReglageButee > 512)
} // fin de if (ButeeEnCours < 512)
} // if (ServoEnCours != dernierServoRegle
} else {
if (flagPM == 0){
byte i;
for (i = 0; i < 8; i++) {
servoAiguillage[i].attach(pinServo + i); // on connecte les servos au pin correspondant à partir du pin 2
servoAiguillage[i].writeMicroseconds(PointMilieuT); // on positionne les servos au point milieu
static unsigned long departTempoTache1 = millis();
do {
if (millis() - departTempoTache1 >= 150){
servoAiguillage[i].detach();
departTempoTache1 = 0;
Serial.print("Aiguillages ");Serial.print(i + 1);Serial.println(" au point milieu!");
Serial.print("Servo ");Serial.print(i);Serial.println(" détaché!");
break;
} else {
Serial.print("Servo ");Serial.print(i);Serial.println(" en attente!");
}
}
while(1);
} // fin de for
i = 0;
flagPM = 1;
lcd.setBacklight(255);lcd.clear();lcd.home();
lcd.print("Reglages desactives!");
lcd.setCursor(0, 1);
lcd.print("Position : ");
lcd.setCursor(11, 1);
lcd.print(PointMilieuT);
} // fin de if (flagPM == 0)
} // fin de if (ServoEnCours < 8)
} else { // else de if (analogRead(pinBPChoixMode) < 512)
//*************************************
// Bouton MODE relaché => mode COMMANDE
//*************************************
if (Z == 0){
//Serial.print("Bouton : "); // Debug
//Serial.print(pinBPChoixMode); // Debug
//Serial.print(" en mode COMMANDE : "); // Debug
//Serial.println(analogRead(pinBPChoixMode)); // Debug
Serial.println("MODE COMMANDE : ");
lcd.setBacklight(255);lcd.clear();lcd.home();
lcd.print("MODE COMMANDE");
//tone(pinBuzzer,2500,100);
Z += 1; // flag choix COMMANDE
Y = 0; // RAZ flag choix REGLAGE
X = 0; // RAZ flag affichage butée droite (angle max)
W = 0; // RAZ flag affichage butée gauche (angle min)
dernierServoReglage = -1;
if (flagPM == 1) {
byte i;
for (i = 0; i < 8; i++) {
angleIntermediaire[i] = DernierePositionServo[i];
servoAiguillage[i].attach(pinServo + i); // on connecte les servos au pin correspondant à partir du pin 2
servoAiguillage[i].writeMicroseconds(angleIntermediaire); // on positionne les servos au point milieu
delay(150);
servoAiguillage[i].detach();
} // fin de for
i = 0;
flagPM = 0;
} // fin de if (flagPM == 1)
} // fin de if (Z == 0)
if (analogRead(pinBPAiguillages) < 1023) { // on a appuyé sur un des BP de commande des aiguillages
// delay(25); // pour éviter les rebonds ... utilité à vérifier
// numPoussoir = (analogRead(pinBPAiguillages) + 64) / 128; // retourne le n° du poussoir activé pour 8 poussoirs
Serial.println(numPoussoir);
if (numPoussoir < 8) {
Serial.print("Aiguillages n° ");
Serial.print(numPoussoir + 1);
Serial.print(" actionné. Se positionne à ");
servoAiguillage[numPoussoir].attach(numPoussoir + pinServo); // on connecte le servomoteur correspondant au BP
CalculLimite();
Serial.println(DernierePositionServo[numPoussoir]);
do {
angleIntermediaire[numPoussoir] = angleIntermediaire[numPoussoir] + (sensMouvement[numPoussoir]);
servoAiguillage[numPoussoir].writeMicroseconds(angleIntermediaire[numPoussoir]);
delay(Temporisation * vitesse);
if (angleIntermediaire[numPoussoir] >= Limite[numPoussoir]){
lcd.setBacklight(255);lcd.clear();lcd.home();
lcd.setCursor(0, 0);
lcd.print("Aiguillage ");
lcd.setCursor(11, 0);
lcd.print(numPoussoir + 1);
lcd.setCursor(0, 1);
lcd.print("position ");
lcd.setCursor(12,1);
lcd.print(angleIntermediaire[numPoussoir]);
EEPROM.update((numPoussoir * 10) + 4, angleIntermediaire[numPoussoir] & 0xFF); // écrit le premier byte de la valeur int
EEPROM.update((numPoussoir * 10) + 5, angleIntermediaire[numPoussoir] >> 8); // écrit le premier byte de la valeur int
delay(150);
servoAiguillage[numPoussoir].detach();
break;
} // fin de if (angleIntermediaire[numPoussoir] == Limite[numPoussoir])
}
while(1); // fin de do
} // fin de if (numPoussoir < 8)
} // fin de (analogRead(pinBPAiguillages) < 1023)
} // fin de if (analogRead(pinBPMode) < 512)
}// fin de loop
Publié le : Mercredi 07 avril 2021 @ 12:02:35
Menu
Article du Jour
Il n'y a pas encore d'article du jour.
Anciens Articles
Lettre d'information
Activité du Site
Pages vues depuis 15/01/2020 : 456 407
- Nb. de membres 7
- Nb. d'articles 119
- Nb. de forums 0
- Nb. de sujets 45
- Nb. de critiques 0