pont tournant

// Include the libraries
#include <AccelStepper.h>
//#include <DCC_Decoder.h>

#define nbPosition 11                  // Le nombre de positions d'arret face aux voies (crans)

#define vitesseRotationManuelle 30   // Vitesse de Rotation en mode manuel/calibrage (~50 = très lent)
#define vitesseMaxCrans 75           // Vitesse de Rotation en mode crans (~200)
#define vitesseAccelerationCrans 40  // Vitesse d'accélération / décélération en mode crans (~25)
// Utilisation en mode demi-pas MotorInterfaceType 8
int tabPosition[nbPosition] = {-2048, -1886, -306, -194, -150, 0, 163, 1740, 1840, 1994, 2048};

// Utilisation en mode plei-pas MotorInterfaceType 4
//int tabPosition[nbPosition] = {-2048, -1962, -1166, -1097, -1024, -108, 0, 82, 880, 950, 1024, 1939, 2048};

int ptrCranZero;                // Position du point 0 dans le tableau
int ptrCranCourant;             // Pointeur de position courante dans le tableau

bool btnClic = false;

// Assignation des broches moteurs aux broches arduino
#define motorPin1  8                  // IN1 (Module ULN2003)
#define motorPin2  9                  // IN2 (Module ULN2003)
#define motorPin3  10                 // IN3 (Module ULN2003)
#define motorPin4  11                 // IN4 (Module ULN2003)

// Le type d'interface est défini sur 8 (HALF4WIRE), car nous voulons utiliser des demi-pas avec un moteur à 4 fils
// Si l'on souhaite mettre le moteur en mode plein-pas, la valeur devra être défini à 4 (FULL4WIRE)
#define MotorInterfaceType 8
//#define MotorInterfaceType 4

// Initialisation pour utiliser AccelStepper avec les paramètres du dessus (Séquence IN1-IN3-IN2-IN4 avec le moteur 28BYJ-48)
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);

#define baseAdresse 100  // Adresse de base du Arduino-Decodeur


// Assigner les boutons aux Pins
const int BPG = 3;              // Bouton tourne sens inverse aiguilles d'une montre
const int BPD = 4;              // Bouton tourne sens aiguilles d'une montre
const int Inter = 5;            // Interrupteur de mode
const int ledTemoin = 13;       // Led intégrée à la carte de l'arduino

bool rotationEnCours = false;   // true = Rotation en Cours

/*
 *  Fonction appelée par la librairie DCC et qui permet
 *  d'activer ou de désactiver les sorties accessoires
 *  Dans notre cas pour mettre en rotation le pont
 *  Attention, une ligne doit être décommentée si vous utilisez une Z21 qui a un décalage d'adressage)
 */
void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data) {
  address -= 1;
  address *= 4;
  address += 1;
  address += (data & 0x06) >> 1;
  //address = address - 4;        // Retirer le commentaire de cette ligne en cas d'utilisation d'un Z21

  // Appel de la fonction qui va réagir en fonction de l'adresse lue
  actionsDecodeurArduino (address);
}

/*
 *  Permet de traduire l'adresse qui a été activée en action
 */

void actionsDecodeurArduino (int adresseLue) {

  // Ex: si adresse de base est 100 alors l'arduino réagit aux adresse 100, 101, 102,...
  switch (adresseLue) {

    // Faire tourner le pont d'un cran à gauche (= comme bouton gauche)
    case (baseAdresse):
      ptrCranCourant --;
      rotationByCrans ();
      break;

    // Faire tourner le pont d'un cran à droite (= comme bouton droite)
    case (baseAdresse + 1):
      ptrCranCourant ++;
      rotationByCrans ();
      break;

    // Mettre le pont à son point 0 (s'il n'est pas déjà en position 0)
    case (baseAdresse + 2):

      if (ptrCranCourant != ptrCranZero) {

        ptrCranCourant = ptrCranZero;
        int goTO = tabPosition[ptrCranCourant];
        stepper.moveTo(goTO);
        stepper.runToPosition();
        stepper.setCurrentPosition(0);
        delay(250);
        powerOffMoteur();
      }
      break;

  }
}

/*
 *  Coupe l'alimentation sur le moteur
 *  Pour éviter qu'il ne chauffe à l'arrêt
 */

void powerOffMoteur () {
  digitalWrite( 8, LOW); // Si le moteur chauffe toujours à l'arret
  digitalWrite( 9, LOW); // Remplacer les LOW par des HIGH (et inversement)
  digitalWrite(10, LOW);
  digitalWrite(11, LOW);
}

/*
 *  Initialisation de la carte Arduino
 *  Et des composants qui lui sont raccordés
 */

void setup() {

    // Le mode PULL-UP permet de s'affranchir d'une résistance
    pinMode(Inter, INPUT_PULLUP);
    pinMode(BPD, INPUT_PULLUP);
    pinMode(BPG, INPUT_PULLUP);

    // On utilise la LED intégrée à la carte comme témoin
    pinMode(ledTemoin, OUTPUT);  //LED

    // Cherche l'emplacement du point 0 dans le tableau des positions
    for (int ii=0; ii<nbPosition; ii++) {
      if (tabPosition[ii] == 0) ptrCranZero = ii;
    }

    // Force l'emplacement du point courant dans le tableau au 0
    ptrCranCourant = ptrCranZero;   // Au point 0 au début


    // Pour le mode rotation par crans
    // On définit la vitesse MAX
    // Et la vitesse dé départ et de fin de rotation
    // La classe "AccelStepper" se charge de calculer la courbe de vitesse :)
    stepper.setMaxSpeed(vitesseMaxCrans);
    stepper.setAcceleration(vitesseAccelerationCrans);

    // Par défaut on dit que le moteur démarre au point 0
    // Mais on peu l'ajuster en manuel
    stepper.setCurrentPosition(0);

    // Déclaration pour la partie DCC
    // La fonction est appelée sur Interruption de la broche 2
    // A chaque action faite sur la centrale

/* A activer si module DCC
 *
 *
 */
//    DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
//    DCC.SetupDecoder( 0x00, 0x00, 0 );

}

/*
 * Fait tourner le moteur à gauche ou à droite en continu
 * Lorsque l'un des boutons est pressé
 */

void rotationManuelle (int sensRotation = 1) {
  rotationEnCours = true;
  if (digitalRead(ledTemoin)== LOW) digitalWrite(ledTemoin, HIGH);

  stepper.setSpeed(vitesseRotationManuelle * sensRotation);
  stepper.runSpeed();
}

/*
 * Fait tourner le moteur à gauche ou à droite par crans prédéfinis
 * Lorsque l'un des boutons est pressé
 * On définit la position de destination avec moveTo()
 * Puis runToPosition() pour lancer la rotation à la vitesse définit et avec accélération
 * Le moteur ralentira en atteignant sa position de destination
 * (1 tour = 4096)
 */

void rotationByCrans () {

  rotationEnCours = btnClic = true;
  if (digitalRead(ledTemoin)== LOW) digitalWrite(ledTemoin, HIGH);

  int goTO = tabPosition[ptrCranCourant];
  stepper.moveTo(goTO);
  stepper.runToPosition();
  delay(100);
  powerOffMoteur();

  if (ptrCranCourant == 0 || ptrCranCourant == (nbPosition-1)) {
    ptrCranCourant = ptrCranZero;
    stepper.setCurrentPosition(0);
  }
}

void loop() {

  // Mode rotation Manuelle / Calibrage
  // ---------------------------------------------
  if (digitalRead(Inter) == HIGH) {

    if (digitalRead(BPG) == LOW) {
      rotationManuelle (-1) ;
    } else if (digitalRead(BPD) == LOW ){
        rotationManuelle (1) ;
    } else {
      // Arreter la rotation lorsqu'un bouton poussoir est relaché
      if (rotationEnCours == true) {
        rotationEnCours = false;
        if (digitalRead(ledTemoin) == HIGH) { digitalWrite(ledTemoin, LOW); }

        // Le point d'arrêt devient alors le point 0
        stepper.setCurrentPosition(0);
        ptrCranCourant = ptrCranZero;
        powerOffMoteur();
      }
    }

  } else {

    // Rotation par crans / taquets
    // ---------------------------------------------

    // Call to library function that reads the DCC data
    // Lecture DCC uniquement dans le mode Crans.
    //DCC.loop();

    if (digitalRead(BPG) == LOW) {
      ptrCranCourant --;
      rotationByCrans ();
    } else if (digitalRead(BPD) == LOW ) {
      ptrCranCourant ++;
      rotationByCrans ();
    } else {
      if (rotationEnCours == true) {
        rotationEnCours = false;
        if (digitalRead(ledTemoin) == HIGH) { digitalWrite(ledTemoin, LOW); }
      }
    }

    // Lorsque les 2 poussoirs sont relachés
    if (digitalRead(BPG) == HIGH && digitalRead(BPD) == HIGH) { btnClic = false; }

  }
}