Forum-passionnement

Code : Tout sélectionner

/* 
Commande Pont tournant Nema 17 avec TMC2209 et Arduino Mega
**************************************************************
              Version 1.20  © Ramasoft Juillet 2026
**************************************************************
Broches de contrôle du Moteur
2 -> PIN_ENABLE Bleu
3 -> PIN_STEP  	Orange	
4 -> PIN_DIR   	Jaune	

Autres Broches utilisées 
5 -> PIN_IR   	          Capteur Infrarouge ou effet Hall  Vert
6 -> PIN_ARRET_URGENCE    Bouton Arrêt d'urgence             Blanc 

Boutons de commande           
7 PIN_CLK   Encodeur CLK Jaune 
8 PIN_DT    Encodeur DT  Bleu
9 PIN_SW   Clic Encodeur                                     Marron

10 PIN_BTN_CW_LENT    rotation sens horaire                  Vert     
11 PIN_BTN_CCW_LENT   rotation sens anti horaire             bleu 
12 PIN_BTN_CW_RAPIDE  rotation sens horaire rapide           Jaune  
13 PIN_BTN_CCW_RAPIDE rotation sens anti-horaire rapide      rouge
Bien s'assurer que les boutons Vert et Jaune font tourner le pont dans le sens des aiguilles d'une montre
Si ça tourne à l'envers, il faut inverser le connecteur du moteur sur la carte du driver

Écran LCD LiquidCrystal I2C : 20 -> SDA Oranger 21 -> SCL Vert

Broches pour les relais qui mettent le courant 
sur les 8 voies de stockage: 22 à 29
      22 -> Blanc/marron  E1
      23 -> Marron        E2
      24 -> Blanc/Vert    S1
      25 -> Vert          S2
      26 -> Blanc/Bleu    S3
      27 -> Bleu          S4
      28 -> Blanc/orange  S5  
      29 -> Orange        S6
Bug de l'IDE Arduino à l'ajout de lignes de remarques en début de code -> sauvegarder pour éviter l'erreur
*/
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>
#include <AccelStepper.h>

// --- AFFECTATION DES BROCHES (PINOUT) ---
const int PIN_ENABLE = 2;
const int PIN_STEP = 3;
const int PIN_DIR = 4;
const int PIN_IR = 5;
const int PIN_ARRET_URGENCE = 6;

const int PIN_CLK = 7;  // Encodeur CLK 
const int PIN_DT = 8;   // Encodeur DT  
const int PIN_SW = 9;    // Clic Encodeur

const int PIN_BTN_CW_LENT = 10;
const int PIN_BTN_CCW_LENT = 11;
const int PIN_BTN_CW_RAPIDE = 12;
const int PIN_BTN_CCW_RAPIDE = 13;

// Tableau des pins pour les 8 relais
const int PINS_RELAIS[8] = {22, 23, 24, 25, 26, 27, 28, 29};

// --- CONFIGURATION ADRESSES EEPROM ---
const int ADDR_POS_ACTUELLE = 0;
const int ADDR_VOIES_START = 4; 

// --- CONFIGURATION DU MOTEUR ---
const float VMax = 4000;
const float Acceleration = 500;
const int VitesseLente = 100;    
const int VitesseRapide = 800;  

// --- INSTANCIATION DES OBJETS ---
LiquidCrystal_I2C lcd(0x27, 20, 4); 
AccelStepper Moteur(AccelStepper::DRIVER, PIN_STEP, PIN_DIR);

// --- VARIABLES GLOBALES ---
int etatPrecedentCLK;        // Stocke l'état précédent de CLK pour détecter le changement
int voieSelectionnee = 0; 
int derniereVoieAffichee = -1;
long positionsVoies[8]; 
long positionActuelle = 0;

long pasAEffectuer = 0; // Variables pour la détermination du chemin le plus court
long ecartBrut = 0;
unsigned long dernierTempsClic = 0;
unsigned long dernierTempsEncodeur = 0;
const unsigned long DELAI_DEBOND_CLIC = 250; 
const unsigned long DELAI_DEBOND_ROTATION = 150; // Filtre anti-rebond en millisecondes pour la rotation

// États pour le menu principal
enum Etats { INITIALISATION, VEILLE, DEPLACEMENT, REGLAGE_MANUEL, URGENCE };
Etats etatCourant = INITIALISATION;


void setup() {
  
    // Configuration des entrées/sorties
  pinMode(PIN_ENABLE, OUTPUT);
  pinMode(PIN_IR, INPUT_PULLUP);
  pinMode(PIN_ARRET_URGENCE, INPUT_PULLUP);
  
  pinMode(PIN_CLK, INPUT_PULLUP);
  pinMode(PIN_DT, INPUT_PULLUP);
  pinMode(PIN_SW, INPUT_PULLUP);
  
  pinMode(PIN_BTN_CW_LENT, INPUT_PULLUP);
  pinMode(PIN_BTN_CCW_LENT, INPUT_PULLUP);
  pinMode(PIN_BTN_CW_RAPIDE, INPUT_PULLUP);
  pinMode(PIN_BTN_CCW_RAPIDE, INPUT_PULLUP);

  for (int i = 0; i < 8; i++) {
    pinMode(PINS_RELAIS[i], OUTPUT);
  }
  couperToutesLesVoies();

  // Configuration AccelMoteur
  Moteur.setMaxSpeed(VMax);
  Moteur.setAcceleration(Acceleration);
  digitalWrite(PIN_ENABLE, HIGH); 

  // Initialisation LCD
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("PONT TOURNANT V1.20 ");
  lcd.setCursor(0, 2);
  lcd.print("Initialisation...");

  // Lecture EEPROM
  EEPROM.get(ADDR_POS_ACTUELLE, positionActuelle);
  Moteur.setCurrentPosition(positionActuelle); 
  
  for (int i = 0; i < 8; i++) {
    EEPROM.get(ADDR_VOIES_START + (i * sizeof(long)), positionsVoies[i]);
  }

  delay(1500);

  // Lecture de l'état initial pour la scrutation de l'encodeur
  etatPrecedentCLK = digitalRead(PIN_CLK);

  // Premier affichage du menu
  AffichageInitial();
  
  etatCourant = VEILLE;
}

void loop() {
  // L'arrêt d'urgence est traité en priorité avant tout le reste
  if (digitalRead(PIN_ARRET_URGENCE) == LOW || etatCourant == URGENCE) {
    
    // Actions immédiates de sécurité
    digitalWrite(PIN_STEP, LOW);     
    digitalWrite(PIN_ENABLE, HIGH);  // Relâche le moteur
    couperToutesLesVoies();          // Coupe le jus des voies
    //etatCourant = URGENCE;           // Verrouille l'état
    
    // Affichage écran
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("!!! ARRET URGENCE !!!");
    lcd.setCursor(0, 2);
    lcd.print("Deverrouillez Bouton");
   // Boucle bloquante tant que le bouton physique est enfoncé
    while (digitalRead(PIN_ARRET_URGENCE) == LOW) {
      delay(100); 
    }

    // Une fois le bouton déverrouillé, on force le calibrage
    delay(1000);
    calibrerZero();
    
    // 5. Reconstruction du menu principal
    AffichageInitial();
    etatCourant = VEILLE;
    derniereVoieAffichee = -1;
    return; // On repart proprement sur un loop tout neuf en mode VEILLE
  }

  // Si pas d'urgence, le switch classique prend le relais
  switch (etatCourant) {
          
    case VEILLE:
      // Lecture de l'encodeur 
      readEncoder();
      
      // Mise à jour de l'affichage de la voie uniquement sur changement
      if (voieSelectionnee != derniereVoieAffichee) {
        lcd.setCursor(12, 1);
        lcd.print("    "); 
        lcd.setCursor(12, 1);
        
        if (voieSelectionnee < 2) {
          lcd.print("Entree " + String(voieSelectionnee + 1)); 
        } else {
          lcd.print("Sortie " + String(voieSelectionnee - 1)); 
        }
        derniereVoieAffichee = voieSelectionnee;
      }
      
      // Affichage de la position : sert au débogage mais pas que ...
      lcd.setCursor(13, 2);
      lcd.print(Moteur.currentPosition());
      
      // Clic de validation -> on passe en mode Déplacement
      if (digitalRead(PIN_SW) == LOW && (millis() - dernierTempsClic > DELAI_DEBOND_CLIC)) {
        dernierTempsClic = millis();
        etatCourant = DEPLACEMENT;
      }

      // Passage en mode réglage si appui sur les boutons manuels
      if (digitalRead(PIN_BTN_CW_LENT) == LOW || digitalRead(PIN_BTN_CCW_LENT) == LOW ||
          digitalRead(PIN_BTN_CW_RAPIDE) == LOW || digitalRead(PIN_BTN_CCW_RAPIDE) == LOW) {
        lcd.clear();
        etatCourant = REGLAGE_MANUEL;
      }
      break;

    case DEPLACEMENT:
      digitalWrite(PIN_ENABLE, LOW); 
      couperToutesLesVoies();         
      
      lcd.setCursor(0, 3);
      lcd.print("Statut: En route... ");
      
      

      // 1. Calcul de l'écart géométrique brut
      ecartBrut = positionsVoies[voieSelectionnee] - Moteur.currentPosition();

      // 2. Détermination du sens de rotation le plus court et du nombre de pas réels
      if (ecartBrut >= 0) {
        if (ecartBrut <= 22000) {
          // Sens Horaire direct
          pasAEffectuer = ecartBrut;
        } else {
          // Sens Anti-Horaire (on contourne par l'autre côté)
          pasAEffectuer = ecartBrut - 44000; 
        }
      } 
      else { // ecartBrut < 0
        if (ecartBrut >= -22000) {
          // Sens Anti-Horaire direct
          pasAEffectuer = ecartBrut;
        } else {
          // Sens Horaire (on contourne par l'autre côté)
          pasAEffectuer = ecartBrut + 44000;
        }
      }

      // 3. On applique l'ordre de mouvement relatif à AccelStepper
      // AccelStepper gère lui-même le changement de sens (Dir Pin) selon le signe (+ ou -)
      Moteur.move(pasAEffectuer);

      // 4. Boucle d'exécution du mouvement
      while (Moteur.distanceToGo() != 0) {
        if (digitalRead(PIN_ARRET_URGENCE) == LOW) {
          Moteur.stop();
          return; 
        }
        Moteur.run();
      }

      // 5. Une fois arrivé, on "re-confectionne" la position actuelle entre 0 et 43999
      // pour que l'Arduino ne garde pas en mémoire des chiffres cumulés géants
      positionActuelle = (Moteur.currentPosition() % 44000 + 44000) % 44000;
      //positionActuelle=(positionsVoies[voieSelectionnee]);
      Moteur.setCurrentPosition(positionActuelle);
      
      EEPROM.put(ADDR_POS_ACTUELLE, positionActuelle); 
      
      alimenterVoie(voieSelectionnee); 
      digitalWrite(PIN_ENABLE, HIGH);  

      lcd.setCursor(0, 3);
      lcd.print("Statut: Aligne & OK ");
      delay(1000);
      
      lcd.setCursor(0, 3);
      lcd.print("                    ");
      etatCourant = VEILLE;
      derniereVoieAffichee = -1; 
      break;

   case REGLAGE_MANUEL:
      lcd.setCursor(0, 0);
      lcd.print("=== MODE REGLAGE ===");
      lcd.setCursor(0, 1);
      if (voieSelectionnee < 2) {
        lcd.print("Reglage Voie: E" + String(voieSelectionnee + 1));
      } else {
        lcd.print("Reglage Voie: S" + String(voieSelectionnee - 1));
      }
      
      lcd.setCursor(0, 2);
      lcd.print("Position: ");
      lcd.print(Moteur.currentPosition());
            
      lcd.setCursor(0, 3);
      lcd.print("Tourner Enc = Annule"); // Message mis à jour pour l'utilisateur

      digitalWrite(PIN_ENABLE, LOW); // Active le moteur

      // Sortir sans sauvegarder si on tourne l'encodeur
      int etatActuelCLK = digitalRead(PIN_CLK);
      if (etatActuelCLK != etatPrecedentCLK && etatActuelCLK == LOW) {
        // L'encodeur a bougé ! On annule tout.
        lcd.setCursor(0, 3);
        lcd.print("Mouvement ANNULE !  ");
        delay(1000);
        
        // On recharge l'ancienne position de la voie depuis la mémoire RAM 
        // pour effacer les déplacements manuels qu'on venait de faire
        Moteur.moveTo(positionsVoies[voieSelectionnee]);
        while(Moteur.distanceToGo() != 0) Moteur.run(); 
        
        // Retour au menu principal
        AffichageInitial();
        digitalWrite(PIN_ENABLE, HIGH); // Relâche le moteur
        
        etatCourant = VEILLE;
        derniereVoieAffichee = -1;
        etatPrecedentCLK = etatActuelCLK; // On synchronise l'état avant de quitter
        break; // On sort immédiatement du case
      }
      etatPrecedentCLK = etatActuelCLK; // Sauvegarde de l'état pour le prochain tour de loop

      // 1. Rotation Horaire Lente
      if (digitalRead(PIN_BTN_CW_LENT) == LOW) {
        Moteur.setSpeed(VitesseLente);
        while (digitalRead(PIN_BTN_CW_LENT) == LOW) {
          Moteur.runSpeed();
        }
        lcd.setCursor(10, 2); lcd.print(Moteur.currentPosition()); lcd.print("    ");
      }
      // 2. Rotation Anti-Horaire Lente
      else if (digitalRead(PIN_BTN_CCW_LENT) == LOW) {
        Moteur.setSpeed(-VitesseLente);
        while (digitalRead(PIN_BTN_CCW_LENT) == LOW) {
          Moteur.runSpeed();
        }
        lcd.setCursor(10, 2); lcd.print(Moteur.currentPosition()); lcd.print("    ");
      }
      // 3. Rotation Horaire Rapide
      else if (digitalRead(PIN_BTN_CW_RAPIDE) == LOW) {
        Moteur.setSpeed(800);
        while (digitalRead(PIN_BTN_CW_RAPIDE) == LOW) {
          Moteur.runSpeed();
        }
        lcd.setCursor(10, 2); lcd.print(Moteur.currentPosition()); lcd.print("    ");
      }
      // 4. Rotation Anti-Horaire Rapide
      else if (digitalRead(PIN_BTN_CCW_RAPIDE) == LOW) {
        Moteur.setSpeed(-800);
        while (digitalRead(PIN_BTN_CCW_RAPIDE) == LOW) {
          Moteur.runSpeed();
        }
        lcd.setCursor(10, 2); lcd.print(Moteur.currentPosition()); lcd.print("    ");
      }

      // --- SAUVEGARDE DE LA POSITION PAR CLIC ---
      if (digitalRead(PIN_SW) == LOW && (millis() - dernierTempsClic > DELAI_DEBOND_CLIC)) {
        dernierTempsClic = millis();
        
        positionsVoies[voieSelectionnee] = Moteur.currentPosition();
        EEPROM.put(ADDR_VOIES_START + (voieSelectionnee * sizeof(long)), positionsVoies[voieSelectionnee]);
        
        lcd.setCursor(0, 3);
        lcd.print("Position MEMORISEE  ");
        delay(1500);
        AffichageInitial();
        digitalWrite(PIN_ENABLE, HIGH);
        
        etatCourant = VEILLE;
        derniereVoieAffichee = -1;
      }
      break;
  
  }
}