////////////////////////////////////////////////////////////////////
//          Programme ARDUINO pour le pilotage d'aiguillages       //
//                    équipés de servomoteurs                      //
//                        en DCC ou Analogique                     //
//                                                                 //
//                   Paramètrage via le port Série                 //
//                                                                 //
//                      UAICF Nevers-Vauzelles                     //
//                    http://www.modelisme58.fr                    //
//                                                                 //
//                           Septembre 2026                        //
//                            Version 3.2                          //
//                                                                 //
//                          Configuration                          //
//         pour commander 6 aiguillages avec boutons poussoirs     //
//                                                                 //
/////////////////////////////////////////////////////////////////////



//*** A modifier si besoin ****************************************************

#define DEBUG_Wokwi_Test

//#define DEBUG_CommandeAnalogique
//#define Serial_DEBUG_Serie
//#define DEBUG_ProgrammeDCC

//*** Fin des modifications ***************************************************



// *** Librairies nécessaires ***
// *** Bibliothèque à installer : http://mrrwa.org ou http://sourceforge.net/projects/mrrwa/files/MRRwA-2011-12-31.zip/download
#include <NmraDcc.h>            // DCC

#include <Servo.h>              // Commande des Servomoteurs      
#include <EEPROM.h>             // Gestion de la mémoire
#include <SoftwareSerial.h>     // Ajout d'un port série
#include <avr/wdt.h>            // Pour le RESET

NmraDcc  Dcc ;                  // DCC
DCC_MSG  Packet ;               // DCC

const char Date_Compilation[] = __DATE__;

// *** Plages des adresses en mémoire ***
#define PlageNbreMaxServos        0       // Nbre de servomoteurs
#define PlageServoTempo           1       // Vitesse de déplacement des servomoteurs
#define PlageCentrale             2       // Type de centrale DCC : 0 => Roco | 1 => Lenz
#define PlageAdresse             61       // Adresse DCC sur enregistrées sur 2 adresses EEPROM
#define PlageMin                 90       // Position extrême mini du servomteur (valeur mini = 0)
#define PlageMax                100       // Position extrême maxi du servomteur (valeur maxi = 180)
#define PlageInvDCC             130       // True ou 1 => inversion des positions mini et maxi en DCC
#define PlageInvMinMax          140       // True ou 1 => inversion des positions mini et maxi pour logiciel
#define PlageTriple             110       // True ou 1 => aiguillage triple
#define PlagePosition           120       // True ou 1 => position du 2éme moteur si aiguillage triple

#define Tempo                  1500       // Tempo entre 2 consignes DCC


// *** Définition des variables, constantes ***
byte NbreMaxServos;                       // Nombre de servomoteurs connectés à la carte ARDUINO
byte ServoTempo   ;                       // Vitesse de déplacement du servomoteur - Plus la valeur est faible, plus la vitesse est rapide
boolean  PremierMouvement = true;

int AddrOld = 0;                          // Decodeur DCC NMRA (valeur précédente)
int BoardAddrOld = 0;                     // Decodeur DCC NMRA (valeur précédente)
int OutputAddrOld = 0;                    // Decodeur DCC NMRA (valeur précédente)
int StateOld = 0;                         // Decodeur DCC NMRA (valeur précédente)
int ArduinoBorne[6];                      // Tableau de définition des adresses DCC des accessoires pilotés
int AIGUILLAGE = 0;                       // Numéro de l'aiguillage commandé
boolean SENSAIGUILLAGE = 0;               // Position de l'aiguillage commandé
boolean MouvementAig = 0;                 // Variable = 1 si un ou pluseurs aiguillages du décodeur en mouvement
int Compteur;                             // Compteur nombre de pas
int CompteurMax;                          // Maximum écart entre position mini et maxi des servomteurs
byte capteurAncienVal[6];                 // Etat n-1 des boutons
byte Centrale;                            // Type de centrale DCC (problème de décalage des adresses DCC des accessoires)
boolean ModeManuel;
byte capteurVal[6];
byte lectureBoutonPrecedente[6];          // Dernière lecture brute du bouton
unsigned long dateChangementBouton[6];    // Date du dernier changement détecté
const unsigned long DelaiAntiRebond = 50; // Anti-rebond en millisecondes
unsigned long compteurDCC;
unsigned long dernierPasServo = 0;          // Horodatage du dernier pas des servos
unsigned long finModeManuel = 0;            // Fin de maintien après une commande série manuelle

struct DCCAccessoryAddress
{
  int address;  // Adresse DCC
  boolean output;   // Etat de l'accesoire : 1=on / 0=off
};

DCCAccessoryAddress accessory[6];

struct servo
{
  byte angle;
  byte setpoint;
  byte minangle;
  byte maxangle;
  boolean invertedDCC;
  boolean invertedMinMax;
  boolean triple;
  boolean positionTriple;
  Servo servo;
  byte functionnumber;
  int sens;
  boolean Actif;
};

servo servos[6];

#include "analogique.h"
#include "dcc.h"
#include "configuration.h"
#include "portserie.h"
#include "wokwi_test.h"


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup()
{
  delay (1000);
  Serial.begin (9600);
  Serial.println(F("***"));
  Serial.println(F("UAICF Nevers-Vauzelles - http://modelisme58.free.fr"));
  Serial.println(Date_Compilation);
  Serial.println(F("Decodeur de SERVOMOTEURS compatible DCC - V3.1b"));
  Serial.print(F("Commande de servomoteurs avec boutons poussoir en Analogique, Port COM et "));

  Centrale = EEPROM.read(PlageCentrale);
  if (Centrale < 0 || Centrale > 1)
  {
    Centrale = 0;
    EEPROM.update(PlageCentrale, Centrale);
  }

  switch (Centrale)
  {
    case 0:
      Serial.println(F("Centrale DCC (Roco, NanoX,...)\n"));
      break;
    case 1:
      Serial.println(F("Centrale DCC LENZ\n"));
      break;
  }

  NbreMaxServos = EEPROM.read(PlageNbreMaxServos);
  if (NbreMaxServos < 1 || NbreMaxServos > 6)
  {
    NbreMaxServos = 6;
    EEPROM.update(PlageNbreMaxServos, NbreMaxServos);
  }

  ServoTempo = EEPROM.read(PlageServoTempo);
  if (ServoTempo  < 1 || ServoTempo  > 254)
  {
    ServoTempo = 50;
    EEPROM.update(PlageServoTempo, ServoTempo);
  }

  for (int n = 0; n < 6; n++)
  {
    byte m = 14 + n;
    byte p = 3 + n;
    pinMode(m, INPUT_PULLUP);             // Bornes Arduino pour bouton à levier
    pinMode(p, OUTPUT);                   // Bornes Arduino pour pilotage servomoteur
    delay (10);
  }

  ConfigureDecodeurServos();              // Configuration des paramètres des caractéristiques des servomoteurs

#ifdef DEBUG_Wokwi_Test
  Config_Test_Wokwi();
#endif

  CalculEcart();
  Initialisation();

  Serial.print(F("Nbre Servos = "));
  Serial.print(NbreMaxServos);
  Serial.print(F("\t\tVitesse = "));
  Serial.println(ServoTempo);

  for (int n = 0; n < NbreMaxServos; n++)
  {
    Serial.print(n + 1);
    Serial.print(F(" -> DCC = "));
    Serial.print(accessory[n].address);
    Serial.print(F(" | Min = "));
    Serial.print(servos[n].minangle);
    Serial.print(F(" | Max = "));
    Serial.print(servos[n].maxangle);
    Serial.print(F(" | InvDCC = "));
    Serial.print(servos[n].invertedDCC);
    Serial.print(F(" | InvMinMax = "));
    Serial.print(servos[n].invertedMinMax);
    Serial.print(F(" | Triple = "));
    Serial.print(servos[n].triple);
    Serial.print(F(" | Position = "));
    Serial.println(servos[n].positionTriple);
  }

  Dcc.init( MAN_ID_DIY, 10, CV29_ACCESSORY_DECODER | CV29_OUTPUT_ADDRESS_MODE, 0 ); // Appel de la fonction initiale pour recevoir les adresses DCC
  pinMode(2, INPUT_PULLUP); // Interruption 0 - Ne pas oublier de mettre une résistance de 10 k raccordée au +5 Volts)

  Serial.println(F("\n$qXY pour simuler une commande DCC : X adresse DCC | Y position 0 ou 1"));

  Serial.println(F("--- Fin Initialisation ---"));
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop()
{
  //*************************************************************************************
  // Commande en mode Analogique
  CommandeAnalogique();

  //*************************************************************************************
  // Commande en mode DCC
  Dcc.process();

  const unsigned long currentMillis = millis();

  //*************************************************************************************
  // Fin du maintien d'un servo commandé directement par le port série.
  // IMPORTANT : ne jamais détacher un servo qui est actuellement en déplacement.
  if (ModeManuel && (long)(currentMillis - finModeManuel) >= 0)
  {
    ModeManuel = false;

    for (byte n = 0; n < NbreMaxServos; n++)
    {
      if (!servos[n].Actif && servos[n].servo.attached())
      {
        servos[n].servo.detach();
      }
    }
  }

  //*************************************************************************************
  // Déplacement progressif des servomoteurs.
  //
  // Chaque servo possède son propre état "Actif".
  // Il n'y a plus de coupure globale basée sur CompteurMax :
  // un servo s'arrête uniquement lorsqu'il atteint sa consigne.
  if (MouvementAig &&
      (unsigned long)(currentMillis - dernierPasServo) >= (unsigned long)ServoTempo)
  {
    dernierPasServo = currentMillis;

    boolean EncoreUnServoActif = false;

    for (byte n = 0; n < NbreMaxServos; n++)
    {
      if (!servos[n].Actif)
      {
        continue;
      }

      // Sécurité : le servo doit être attaché avant write().
      if (!servos[n].servo.attached())
      {
        servos[n].servo.attach(ArduinoBorne[n]);
        servos[n].servo.write(servos[n].angle);
      }

      // Avance d'un degré vers la consigne.
      if (servos[n].angle < servos[n].setpoint)
      {
        servos[n].angle++;
      }
      else if (servos[n].angle > servos[n].setpoint)
      {
        servos[n].angle--;
      }

      // IMPORTANT : envoyer la dernière position AVANT detach().
      servos[n].servo.write(servos[n].angle);

      if (servos[n].angle == servos[n].setpoint)
      {
        servos[n].Actif = false;
        servos[n].servo.detach();
      }
      else
      {
        EncoreUnServoActif = true;
      }
    }

    MouvementAig = EncoreUnServoActif;
  }
} // Fin de la boucle LOOP