Menu HTML / Javascript : Aperçu

Blog du Le réseau du Mesnil-sur-Jorg

mercredi 16 juin 2021
      Membre de Train d'enfer 95

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 !!!! 


2021-03-22.png

2021-03-22


//*************************************************************************
// 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
Envoyer cet article à un ami      Page spéciale pour impression
Pour lire ce contenu vous devez être connecter en tant que Membre.

[Visiteur - Votre compte]

Article du Jour
Il n'y a pas encore d'article du jour.
Lettre d'information

Recevez par mail les nouveautés du site.

Chat Box
91.168.1.Super le site !!! Colonelwog
Philippe.Merci énormément

Activité du Site

Pages vues depuis 15/01/2020 : 81 136

  • Nb. de membres 7
  • Nb. d'articles 94
  • Nb. de forums 0
  • Nb. de sujets 43
  • Nb. de critiques 0

Top 5  Statistiques


Plus de contenu