Faire sa propre centrale DCC

#define VERSION "version 1.0b1 du 14/8/13 - Copyright D.Bultez"
#include "Arduino.h"

//TCO Pins

//Afficheurs 7 segments
// segment pins
#define SEGa 22
#define SEGb 23
#define SEGc 24
#define SEGd 25
#define SEGe 26
#define SEGf 27
#define SEGg 28
#define SEGdp 29

// digit pins
#define K1 37
#define K2 36
#define K3 35
#define K4 34
#define K5 33
#define K6 32
#define K7 31
#define K8 30

// leds aiguilles
#define AgD1 49
#define AgD2 48
#define AgD3 47
#define AgD4 46
#define AgD5 45
#define AgD6 44
#define AgD7 43

// clés aiguilles
#define AgC1 38
#define AgC2 39
#define AgC3 40
#define AgC4 41

//boutons de fonction
#define BIT 42          // bouton IT
#define BR 7            // bouton R
#define BStartStop 12   // poussoir STOP / START
#define BFunction 6     // poussoir Fonction

// LOCOS
#define BLoco4 5     // poussoir loco 4
#define BLoco3 4     // poussoir loco 3
#define BLoco2 3     // poussoir loco 2
#define BLoco1 2     // poussoir loco 1

#define LLoco4 53    // led loco 4
#define LLoco3 52    // led loco 3
#define LLoco2 51    // led loco 2
#define LLoco1 50    // led loco 1

// vitesse (pots)
#define VLoco1 A0    // loco 1
#define VLoco2 A2    // loco 2
#define VLoco3 A4    // loco 3
#define VLoco4 A6    // loco 4

// direction (clé)
#define Dir1 A1      // loco 1
#define Dir2 A3      // loco 2
#define Dir3 A5      // loco 3
#define Dir4 A7      // loco 4

// DCC
#define LDCC 13         // led DCC OK

#define DCC_PIN     10  // Arduino pin for DCC out
                        // this pin is connected to "DIRECTION" of LMD18200
#define DCC_PWM     11  // must be HIGH for signal out
                        // connected to "PWM in" of LMD18200


// --------------------------------------------------
//                  GLOBALS
// --------------------------------------------------

byte _seg[8] = { SEGa,SEGb,SEGc,SEGd,SEGe,SEGf,SEGg,SEGdp};  //pin number of segments
byte _allseg[64];                                            //segments states of 8 digits
byte _vide[8] = { 0,0,0,0,0,0,0,0 };
byte _zero[8] = { 1,1,1,1,1,1,0,0 };
byte _un[8] = { 0,1,1,0,0,0,0,0 };
byte _deux[8] = { 1,1,0,1,1,0,1,0 };
byte _trois[8] = { 1,1,1,1,0,0,1,0 };
byte _quatre[8] = { 0,1,1,0,0,1,1,0 };
byte _cinq[8] = { 1,0,1,1,0,1,1,0 };
byte _six[8] = { 1,0,1,1,1,1,1,0 };
byte _sept[8] = { 1,1,1,0,0,0,0,0 };
byte _huit[8] = { 1,1,1,1,1,1,1,0 };
byte _neuf[8] = { 1,1,1,0,0,1,1,0 };
byte _hexA[8] = { 1,1,1,0,1,1,1,0 };
byte _hexb[8] = { 0,0,1,1,1,1,1,0 };
byte _hexc[8] = { 1,0,0,1,1,1,0,0 };
byte _hexd[8] = { 0,1,1,1,1,0,1,0 };
byte _hexE[8] = { 1,0,0,1,1,1,1,0 };
byte _hexF[8] = { 1,0,0,0,1,1,1,0 };
byte _dig[8] = { K1,K2,K3,K4,K5,K6,K7,K8 };

int curdigit = 0;  // digit courant
int lastdigit;     // digit précédant

byte _led[12] = { AgD1,AgD2,AgD3,AgD4,AgD5,AgD6,AgD7,LLoco1,LLoco2,LLoco3,LLoco4,LDCC };  // leds

byte _canton[8] = { 0,0,0,0,0,0,0,0 }; // 0=C1, 1=C2, 2=C3, 3=C4, 4=C5,
                                       // 5=C6(garage), 6=Quai1, 7=Quai2

// locos

byte _loco1[8] = { 03,1,0,2,5,0,0,0 }; // 0=N° DCC de loco, 1=AV-1 ou AR-0, 2=vitesse 1..4 ou arret 0
byte _loco2[8] = { 04,1,0,2,5,0,0,0 }; // 3=temps restant canton en cours, 4=N° canton en cours
byte _loco3[8] = { 05,1,0,2,5,0,0,0 }; // 5=N° canton suivant, 6= reserved for futur use
byte _loco4[8] = { 06,1,0,2,5,0,0,0 }; // 7=Loco autorisee 1=START 0=STOP

byte locoAdr1 = 3;
byte locoAdr2 = 4;
byte locoAdr3 = 5;
byte locoAdr4 = 6;
byte vitesse;
byte dir;

int BLoco1cur;
int BLoco1state = LOW;
int BLoco1count;
int BLoco2cur;
int BLoco2state = LOW;
int BLoco2count;
int BLoco3cur;
int BLoco3state = LOW;
int BLoco3count;
int BLoco4cur;
int BLoco4state = LOW;
int BLoco4count;


// -----------------------------------------------------------------
//                          for DCC protocol
// -----------------------------------------------------------------

#define PREAMBLE 0    
#define SEPARATOR 1
#define SENDBYTE  2

//Timer frequency is 2MHz for ( /8 prescale from 16MHz )
#define TIMER_SHORT 0x8D  // 58usec pulse length
#define TIMER_LONG  0x1B  // 116usec pulse length

unsigned char last_timer=TIMER_SHORT;  // store last timer value  
unsigned char flag=0;  // used for short or long pulse
unsigned char every_second_isr = 0;  // pulse up or down
unsigned char state= PREAMBLE;
unsigned char preamble_count = 16;
unsigned char outbyte = 0;
unsigned char cbit = 0x80;


// -------------------  buffer for DCC commands -------------------

struct Message {
   unsigned char data[7];
   unsigned char len;
} ;

#define MAXMSG  9

struct Message msg[MAXMSG] = {
    { { 0xFF,     0, 0xFF, 0, 0, 0, 0}, 3},    // idle msg
    { { locoAdr1, 0x3F,  0, 0, 0, 0, 0}, 4},   // 128 speed steps and direction (b7) in next byte
    { { locoAdr2, 0x3F,  0, 0, 0, 0, 0}, 4},   // 128 speed steps and direction (b7) in next byte
    { { locoAdr3, 0x3F,  0, 0, 0, 0, 0}, 4},   // 128 speed steps and direction (b7) in next byte
    { { locoAdr4, 0x3F,  0, 0, 0, 0, 0}, 4},   // 128 speed steps and direction (b7) in next byte
    { { locoAdr1, 0x80,  0, 0, 0, 0, 0}, 3},   // Function group 1 : 0x80 means light off
    { { locoAdr2, 0x90,  0, 0, 0, 0, 0}, 3},   // Function group 1 : 0x90 means light on
    { { locoAdr1, 0x80,  0, 0, 0, 0, 0}, 3},   // Function group 1 : 0x80 means light off
    { { locoAdr2, 0x90,  0, 0, 0, 0, 0}, 3}    // Function group 1 : 0x90 means light on
  };              
  // loco msg must be filled later with speed and XOR data byte
  // function msg command 0x80 or 0x90 is filled in "assemble_dcc_msglight()"
                                
int msgIndex=0;  
int byteIndex=0;

boolean debug = false;

unsigned long time;          // INTERNAL TIME FOR 1 SECONDE TEMPO


//------------------------------------------------------
//                    Setup Timer2
//------------------------------------------------------

//Configures the 8-Bit Timer2 to generate an interrupt at the specified frequency.
//Returns the time load value which must be loaded into TCNT2 inside your ISR routine.

void SetupTimer2(){
 
  //Timer2 Settings: Timer Prescaler /8, mode 0
  //Timmer clock = 16MHz/8 = 2MHz oder 0,5usec
  TCCR2A = 0;
  TCCR2B = 0<<CS22 | 1<<CS21 | 0<<CS20;

  //Timer2 Overflow Interrupt Enable  
  TIMSK2 = 1<<TOIE2;

  //load the timer for its first cycle
  TCNT2=TIMER_SHORT;
}

//------------------------------------------------------
//        Timer2 overflow interrupt vector handler  
//------------------------------------------------------

ISR(TIMER2_OVF_vect) {
  //Capture the current timer value TCTN2. This is how much error we have
  //due to interrupt latency and the work in this function
  //Reload the timer and correct for latency.  

  unsigned char latency;
  
  // for every second interupt just toggle signal
  if (every_second_isr)  {
     digitalWrite(DCC_PIN,1);
     every_second_isr = 0;    
    
     // set timer to last value
     latency=TCNT2;
     TCNT2=latency+last_timer;
    
  }  else  {  // != every second interrupt, advance bit or state
     digitalWrite(DCC_PIN,0);
     every_second_isr = 1;
    
     switch(state)  {
       case PREAMBLE:
           flag=1; // short pulse
           preamble_count--;
           if (preamble_count == 0)  {  // advance to next state
              state = SEPARATOR;
              // get next message
              msgIndex++;
              if (msgIndex >= MAXMSG)  {  msgIndex = 0; }  
              byteIndex = 0; //start msg with byte 0
           }
           break;
        case SEPARATOR:
           flag=0; // long pulse
           // then advance to next state
           state = SENDBYTE;
           // goto next byte ...
           cbit = 0x80;  // send this bit next time first        
           outbyte = msg[msgIndex].data[byteIndex];
           break;
        case SENDBYTE:
           if (outbyte && cbit)  {
              flag = 1;  // send short pulse
           }  else  {
              flag = 0;  // send long pulse
           }
           cbit = cbit >> 1;
           if (cbit == 0)  {  // last bit sent, is there a next byte?
              byteIndex++;
              if (byteIndex >= msg[msgIndex].len)  {
                 // this was already the XOR byte then advance to preamble
                 state = PREAMBLE;
                 preamble_count = 16;
              }  else  {
                 // send separtor and advance to next byte
                 state = SEPARATOR ;
              }
           }
           break;
     }  
 
     if (flag)  {  // if data==1 then short pulse
        latency=TCNT2;
        TCNT2=latency+TIMER_SHORT;
        last_timer=TIMER_SHORT;
     }  else  {   // long pulse
        latency=TCNT2;
        TCNT2=latency+TIMER_LONG;
        last_timer=TIMER_LONG;
     }  
  }
}

//---------------------------------------
//                  SETUP
//---------------------------------------

void setup(void) {
  int i;
// init PinMode for 8 segment displays
for (i = 0; i < 8; i++) {
  pinMode(_seg[i], OUTPUT);
  digitalWrite(_seg[i], HIGH);
  pinMode(_dig[i], OUTPUT);
  digitalWrite(_dig[i], HIGH); // all OFF
}

// init PinMode for leds
for (i = 0; i < 12; i++) {
  pinMode(_led[i], OUTPUT);
  digitalWrite(_led[i], HIGH);  // all ON
  }
  delay (500);
for (i = 0; i < 12; i++) {
  digitalWrite(_led[i], LOW);  // all OFF
  }
  
// init PinMode for switches
pinMode(AgC1, INPUT_PULLUP);
pinMode(AgC2, INPUT_PULLUP);
pinMode(AgC3, INPUT_PULLUP);
pinMode(AgC4, INPUT_PULLUP);

pinMode(BIT, INPUT_PULLUP);
pinMode(BR,  INPUT_PULLUP);
pinMode(BFunction,  INPUT_PULLUP);
pinMode(BStartStop,  INPUT_PULLUP);

// locos
pinMode(BLoco1,  INPUT_PULLUP);
pinMode(BLoco2,  INPUT_PULLUP);
pinMode(BLoco3,  INPUT_PULLUP);
pinMode(BLoco4,  INPUT_PULLUP);
pinMode(Dir1,  INPUT_PULLUP);
pinMode(Dir2,  INPUT_PULLUP);
pinMode(Dir3,  INPUT_PULLUP);
pinMode(Dir4,  INPUT_PULLUP);

// speed pots
pinMode(VLoco1,  INPUT);
pinMode(VLoco2,  INPUT);
pinMode(VLoco3,  INPUT);
pinMode(VLoco4,  INPUT);

// DCC pins
pinMode(DCC_PIN, OUTPUT);
pinMode(DCC_PWM, OUTPUT);

// init _allseg[64] & _hexseg[128]

for (i = 0; i < 64; i++) { _allseg[i] = 0; }

Serial.begin(9600);
delay(100);
Serial.println(VERSION);
  
//Start the timer
SetupTimer2();  
delay(100);
Serial.println("DCC ready");

//départ temps loop
time = millis();              // départ timer seconde
delay(100);
Serial.println("Second Timer started");

}            // end SETUP


//---------------------------------------
//                  LOOP
//---------------------------------------

void loop(void) {
  
  int i, j;
  
//multiplexage des afficheurs
digitalWrite(_dig[lastdigit], HIGH);      // éteint le digit allumé
for (j = 0; j < 8; j++) {
  digitalWrite(_seg[j], _allseg[j+8*curdigit]);    // recopie des segments pour le digit suivant
  }
digitalWrite(_dig[curdigit], LOW);      // allume le digit suivant durant toute la durée de loop()
lastdigit = curdigit;
curdigit = curdigit +1;
if (curdigit > 7) {curdigit = 0;}

//gestion des led aiguilles en fonction des clés  
  digitalWrite(_led[0] , digitalRead(AgC1)); // A1 droit
  digitalWrite(_led[2] , !digitalRead(AgC1)); // A1 devie
  digitalWrite(_led[3] , !digitalRead(AgC2)); // A2 devie
  digitalWrite(_led[1] , digitalRead(AgC2) & !digitalRead(AgC3));
  digitalWrite(_led[4] , digitalRead(AgC2) & digitalRead(AgC3));
  digitalWrite(_led[5] , !digitalRead(AgC4)); // A4 droit (entrée sortie de garage)
  digitalWrite(_led[6] , digitalRead(AgC4)); // A4 devie (boucle garage)
  
  
//gestion des taches toutes les secondes
if ((time+1000) < millis())  {
  time = time+1000;              // pour rattraper les secondes si ça dérape
  SR_second();
 }

// vitesse locos
  vitesse = (4L * analogRead(VLoco1))/1023;
  _loco1[2] = vitesse;
  vitesse = (4L * analogRead(VLoco2))/1023;
  _loco2[2] = vitesse;
  vitesse = (4L * analogRead(VLoco3))/1023;
  _loco3[2] = vitesse;
  vitesse = (4L * analogRead(VLoco4))/1023;
  _loco4[2] = vitesse;
  
// gestion des boutons hors locos
if (!digitalRead(BIT) ) {

  }

if (!digitalRead(BR) ) {

  }

if (!digitalRead(BStartStop) ) {
  Stop_loco1();
  Stop_loco2();
  Stop_loco3();
  Stop_loco4();
  delay(1000);
  }

 
// debug on console
if (!digitalRead(BFunction)) {
  if (debug) {
  Serial.print("LOCOS ");
  Serial.print(_loco1[0]);
  Serial.print(_loco1[1]);
  Serial.print(_loco1[2]);
  Serial.print(_loco1[3]);
  Serial.print(_loco1[4]);
  Serial.print(_loco1[5]);
  Serial.print(_loco1[7]);
  Serial.print(" ");
  Serial.print(_loco2[0]);
  Serial.print(_loco2[1]);
  Serial.print(_loco2[2]);
  Serial.print(_loco2[3]);
  Serial.print(_loco2[4]);
  Serial.print(_loco2[5]);
  Serial.print(_loco2[7]);
  Serial.print(" ");
  Serial.print(_loco3[0]);
  Serial.print(_loco3[1]);
  Serial.print(_loco3[2]);
  Serial.print(_loco3[3]);
  Serial.print(_loco3[4]);
  Serial.print(_loco3[5]);
  Serial.print(_loco3[7]);
  Serial.print(" ");
  Serial.print(_loco4[0]);
  Serial.print(_loco4[1]);
  Serial.print(_loco4[2]);
  Serial.print(_loco4[3]);
  Serial.print(_loco4[4]);
  Serial.print(_loco4[5]);
  Serial.print(_loco4[7]);
  Serial.print(" -CANTONS- ");
  Serial.print(_canton[0]);
  Serial.print(_canton[1]);
  Serial.print(_canton[2]);
  Serial.print(_canton[3]);
  Serial.print(_canton[4]);
  Serial.print(_canton[5]);
  Serial.print(_canton[6]);
  Serial.println(_canton[7]);
  delay(100);
  }
  }

    
if (Serial.available())  {
  char inByte = Serial.read();
  switch (inByte) {
   case '=' :
   for (i = 0; i<11; i++) {
     Serial.print(digitalRead(_led[i]));
   }
   Serial.println();
   break;
   case '@' :
   debug = !debug;
   break;
   default :
   break;
  }
}
  
}            // end LOOP

//------------------------------------

// -----------------------------------------------------------------------
//                 ROUTINE À CHAQUE SECONDE
// -----------------------------------------------------------------------

void SR_second() {             // routine periodique (1 seconde)

/*
test et décrément durée dans canton de chaque loco et avancement au canto suivant si dispo
si la vitesse de la loco n'est pas = 0
- si durée = 0 avant décrément, la loco attend la disponibilité du canton suivant
- si durée = 0 après décrément, canto suivant (selon direction), sinon pas de changement
- au changement de canton, la nouvelle durée devient inversement proportionnelle à la vitesse
- si canton suivant non dispo (#0) clignotement du n° de loco
rappel :
byte _canton[8] = { 0,0,0,0,0,0,0,0 }; // 0=C1, 1=C2, 2=C3, 3=C4, 4=C5, 5=C6(garage), 6=Quai1, 7=Quai2
byte _loco1[8] = { 03,1,0,2,5,0,0,0 }; // 0=N° DCC de loco, 1=AV-1 ou AR-0, 2=vitesse 1..4 ou arret 0
byte _loco2[8] = { 04,1,0,2,5,0,0,0 }; // 3=temps restant canton en cours, 4=N° canton en cours
byte _loco3[8] = { 05,1,0,2,5,0,0,0 }; // 5=N° canton suivant, 6= reserved for futur use
byte _loco4[8] = { 06,1,0,2,5,0,0,0 }; // 7=Loco autorisee 1=START 0=STOP
*/

if (debug) {
Serial.print(time);
Serial.print(" cantons ");
}

// Gestion des boutons de fonction loco

BLoco1cur = digitalRead(BLoco1); //enfoncé = LOW
if (BLoco1cur == LOW && BLoco1count == 0)  { BLoco1count++; }  // attente seconde suivante
if (BLoco1cur == LOW && BLoco1count == 1)  {    //LOW > 1 seconde = debounced
  BLoco1count = 0;
  BLoco1state = !BLoco1state;
  if (BLoco1state == HIGH) { Start_loco1(); } else { Stop_loco1(); }
}

BLoco2cur = digitalRead(BLoco2); //enfoncé = LOW
if (BLoco2cur == LOW && BLoco2count == 0)  { BLoco2count++; }  // attente seconde suivante
if (BLoco2cur == LOW && BLoco2count == 1)  {    //LOW > 1 seconde = debounced
  BLoco2count = 0;
  BLoco2state = !BLoco2state;
  if (BLoco2state == HIGH) { Start_loco2(); } else { Stop_loco2(); }
}

BLoco3cur = digitalRead(BLoco3); //enfoncé = LOW
if (BLoco3cur == LOW && BLoco3count == 0)  { BLoco3count++; }  // attente seconde suivante
if (BLoco3cur == LOW && BLoco3count == 1)  {    //LOW > 1 seconde = debounced
  BLoco3count = 0;
  BLoco3state = !BLoco3state;
  if (BLoco3state == HIGH) { Start_loco3(); } else { Stop_loco3(); }
}

BLoco4cur = digitalRead(BLoco4); //enfoncé = LOW
if (BLoco4cur == LOW && BLoco4count == 0)  { BLoco4count++; }  // attente seconde suivante
if (BLoco4cur == LOW && BLoco4count == 1)  {    //LOW > 1 seconde = debounced
  BLoco4count = 0;
  BLoco4state = !BLoco4state;
  if (BLoco4state == HIGH) { Start_loco4(); } else { Stop_loco4(); }
}

// ----------------------------
//     avancement Loco1
// ----------------------------
if (_loco1[7] == 1) {              // si en cours de manoeuvre
 if (debug) { Serial.print(_loco1[4]); }  //position courante
  dir = digitalRead(Dir1);
  _loco1[1] = dir;
  _loco1[5] = CantonSuivant(_loco1[4]);
// décrément du temps restant si > 0
 if (_loco1[3] > 0) { _loco1[3]--; }
 // si le temps = 0 tentative de passer au canton suivant sinon arret
 if ((_loco1[3] == 0) & !(_loco1[5] == _loco1[4]) & (_canton[_loco1[5]] == 0))  {
  // test canton suivant # du canton en cours
  // et canton suivant libre
   _canton[_loco1[4]] = 0;       // liberation du canton quitté
   razdigit(_loco1[4]);          // raz du digit TCO
   _loco1[4] = _loco1[5];        // maj du canton en cours
   setdigit1(_loco1[4]);         // digit occupé marqué 1
   _canton[_loco1[4]] = 1;       // marquage du canton avec le N° de loco
   _loco1[3] = NewDureeCanton(_loco1[2]); // reinit duree dans le canton
 }
}

// ----------------------------
//     avancement Loco2
// ----------------------------
if (_loco2[7] == 1) {
 if (debug) { Serial.print(_loco2[4]); }  //position courante
  dir = digitalRead(Dir2);
  _loco2[1] = dir;
  _loco2[5] = CantonSuivant(_loco2[4]);
// décrément du temps restant si > 0
 if (_loco2[3] > 0) { _loco2[3]--; }
 // si le temps = 0 tentative de passer au canton suivant sinon arret
 if ((_loco2[3] == 0) & !(_loco2[5] == _loco2[4]) & (_canton[_loco2[5]] == 0))  {
  // test canton suivant # du canton en cours
  // et canton suivant libre
   _canton[_loco2[4]] = 0;       // liberation du canton quitté
   razdigit(_loco2[4]);          // raz du digit TCO
   _loco2[4] = _loco2[5];        // maj du canton en cours
   setdigit2(_loco2[4]);         // digit occupé marqué 2
   _canton[_loco2[4]] = 2;       // marquage du canton avec le N° de loco
   _loco2[3] = NewDureeCanton(_loco2[2]); // reinit duree dans nouveau canton
 }
}

// ----------------------------
//     avancement Loco3
// ----------------------------
if (_loco3[7] == 1) {
 if (debug) { Serial.print(_loco3[4]); }  //position courante
  dir = digitalRead(Dir3);
  _loco3[1] = dir;
  _loco3[5] = CantonSuivant(_loco3[4]);
// décrément du temps restant si > 0
 if (_loco3[3] > 0) { _loco3[3]--; }
 // si le temps = 0 tentative de passer au canton suivant sinon arret
 if ((_loco3[3] == 0) & !(_loco3[5] == _loco3[4]) & (_canton[_loco3[5]] == 0))  {
  // test canton suivant # du canton en cours
  // et canton suivant libre
   _canton[_loco3[4]] = 0;       // liberation du canton quitté
   razdigit(_loco3[4]);          // raz du digit TCO
   _loco3[4] = _loco3[5];        // maj du canton en cours
   setdigit3(_loco3[4]);         // digit occupé marqué 3
   _canton[_loco3[4]] = 3;       // marquage du canton avec le N° de loco
   _loco3[3] = NewDureeCanton(_loco3[2]); // reinit duree dans nouveau canton
 }
}

// ----------------------------
//     avancement Loco4
// ----------------------------
if (_loco4[7] == 1) {
 if (debug) { Serial.print(_loco4[4]); }  //position courante
  dir = digitalRead(Dir4);
  _loco4[1] = dir;
  _loco4[5] = CantonSuivant(_loco4[4]);
// décrément du temps restant si > 0
 if (_loco4[3] > 0) { _loco4[3]--; }
 // si le temps = 0 tentative de passer au canton suivant sinon arret
 if ((_loco4[3] == 0) & !(_loco4[5] == _loco4[4]) & (_canton[_loco4[5]] == 0))  {
  // test canton suivant # du canton en cours
  // et canton suivant libre
   _canton[_loco4[4]] = 0;       // liberation du canton quitté
   razdigit(_loco4[4]);          // raz du digit TCO
   _loco4[4] = _loco4[5];        // maj du canton en cours
   setdigit4(_loco4[4]);         // digit occupé marqué 4
   _canton[_loco4[4]] = 4;       // marquage du canton avec le N° de loco
   _loco4[3] = NewDureeCanton(_loco4[2]); // reinit duree dans nouveau canton
 }
}
 if (debug) { Serial.println(); }

} // fin de SR_second()

// ----------------------------
//         DUREE DANS UN CANTON
// ----------------------------

byte NewDureeCanton(byte vitesse)  {
  byte duree;
  switch (vitesse) {
    case 1:
      duree = 4;
      break;
    case 2:
      duree = 3;
      break;
    case 3:
      duree = 2;
      break;
    case 4:
      duree = 1;
      break;
    default:
      duree = 4;
      break;
  }
  return duree;
}

// ----------------------------
//         CANTON SUIVANT
// ----------------------------

byte CantonSuivant(byte canton)  {
  
  byte result = canton;  //sans changement par défaut
  
  switch (canton) {
    case 0: // depuis C1 > C2 ou quai 1 / 2 ou C5
      if (dir) {
        result = 1;
        } else {
          if (digitalRead(AgC2))  {
            if ((!digitalRead(AgC4) & digitalRead(AgC3))) { result = 5; }
            if (!digitalRead(AgC3)) { result = 6; }
          } else { result = 7; }
        }
      break;
      
    case 1: //depuis C2 > C3 ou C1
      if (dir) {result =  2;} else {result = 0;}
      break;
      
    case 2: //depuis C3 > C4 ou C2
      if (dir) {result =  3;} else {result = 1;}
      break;
      
    case 3: //depuis C4 > C5 ou C3
      if (dir) {result =  4;} else {result = 2;}
      break;
      
    case 4: //depuis C5 vers quai 1 / 2 suivant aiguille 1 ou C3
      if (dir) {
        if (digitalRead(AgC1))  {
          result =  6;  //quai 1
        } else {
          result =  7;//quai 2
        }
      } else { result = 3; }
      break;
      
    case 5:  //du garage vers C1 suivant aiguilles 2, 3 et 4
      if (dir) {
        if ((!digitalRead(AgC4) & digitalRead(AgC2) & digitalRead(AgC3))) {
          result =  0;
        } else {
          result = 5; //reste garage  
        }
      } else { result = 5; }
      break;
      
    case 6:  //depuis quai 1 > C1 ou C5
      if (dir) {
        if (digitalRead(AgC2) && !digitalRead(AgC3)) {
          result =  0; //C1
        } else {
          result = 6; // reste à quai 1
        }
      } else {
        if (digitalRead(AgC1))  {
          result =  4;  //C5
        }
      }
      break;
      
    case 7:  //depuis quai 2 > C1 ou C5
      if (dir) {
        if (!digitalRead(AgC2)) {
          result =  0;  //C1
        } else {
          result = 7; // reste à quai 2
        }
      } else {
        if (!digitalRead(AgC1))  {
          result =  4;  //C5
        }
      }
      break;
      
    default:
      result =  0;
      break;
  }
  return result;
}

// ----------------------------
//         RAZ DIGIT 7 SEGMENT
// ----------------------------

void razdigit(byte c)  {
  int s;
  for (s = 0; s < 8; s++) {
   _allseg[s+(8*c)] = _vide[s]; // insertion du carcatère hexa suivant à gauche  
 }
}

// ----------------------------
//         SET DIGIT 7 SEGMENT
// ----------------------------

void setdigit1(byte c)  {
  int s;
  for (s = 0; s < 8; s++) {
   _allseg[s+(8*c)] = _un[s]; // insertion du carcatère hexa suivant à gauche
 }
}

void setdigit2(byte c)  {
  int s;
  for (s = 0; s < 8; s++) {
   _allseg[s+(8*c)] = _deux[s]; // insertion du carcatère hexa suivant à gauche
 }  
}

void setdigit3(byte c)  {
  int s;
  for (s = 0; s < 8; s++) {
   _allseg[s+(8*c)] = _trois[s]; // insertion du carcatère hexa suivant à gauche
 }  
}

void setdigit4(byte c)  {
  int s;
  for (s = 0; s < 8; s++) {
   _allseg[s+(8*c)] = _quatre[s]; // insertion du carcatère hexa suivant à gauche
 }  
}


// ----------------------------
//         INIT LOCOS
// ----------------------------

boolean Start_loco1()  {
  boolean r=false;
  _loco1[2] = 1; //vitesse réduite = 1
  _loco1[3] = 4; //durée 4
  _loco1[4] = 6; //quai 1
  _loco1[5] = 0; //canton 1
  if (_canton[6] == 0) { //disponible
    _canton[6] = 1; // canton occupé
    _loco1[7] = 1;  // loco autorisée à rouler
    setdigit1(6);
    digitalWrite(_led[7] , HIGH);
    r = true;
    if (debug) { Serial.println("start loco 1");}
  } else { blinkLocoLed(7); }
}

boolean Start_loco2()  {
  boolean r=false;
  _loco2[2] = 1; //vitesse réduite = 1
  _loco2[3] = 4; //durée 4
  _loco2[4] = 7; //quai 2
  _loco2[5] = 0; //canton 1
  if (_canton[7] == 0) { //disponible
    _canton[7] = 2; // canton occupé
    _loco2[7] = 1;  // loco autorisée à rouler
    setdigit2(7);
    digitalWrite(_led[8] , HIGH);
    r = true;
    if (debug) { Serial.println("start loco 2");}
  } else { blinkLocoLed(8); }  
}

boolean Start_loco3()  {
  boolean r=false;
  _loco3[2] = 1; //vitesse réduite = 1
  _loco3[3] = 4; //durée 4
  _loco3[4] = 5; //garage
  _loco3[5] = 0; //
  if (_canton[5] == 0) { //disponible
    _canton[5] = 3; // canton occupé
    _loco3[7] = 1;  // loco autorisée à rouler
    setdigit3(5);
    digitalWrite(_led[9] , HIGH);
    r = true;
    if (debug) { Serial.println("start loco 3");}
  } else { blinkLocoLed(9); }  
}

boolean Start_loco4()  {
  boolean r=false;
  _loco4[2] = 1; //vitesse réduite = 1
  _loco4[3] = 4; //durée 4
  _loco4[4] = 5; //garage
  _loco4[5] = 0; //
  if (_canton[5] == 0) { //disponible
    _canton[5] = 4; // canton occupé
    _loco4[7] = 1;  // loco autorisée à rouler
    setdigit4(5);
    digitalWrite(_led[10] , HIGH);
    r = true;
    if (debug) { Serial.println("start loco 4");}
  } else { blinkLocoLed(10); }  
}

// ----------------------------
//         RESET LOCOS
// ----------------------------

boolean Stop_loco1()  {
  if (_loco1[7] == 1) {
  digitalWrite(_led[7] , LOW);
  _loco1[7] = 0;
  _canton[_loco1[4]] = 0;       // liberation du canton quitté
  razdigit(_loco1[4]);          // raz du digit TCO
  if (debug) { Serial.println("stop loco 1");}
  }
}

boolean Stop_loco2()  {
  if (_loco2[7] == 1) {
  digitalWrite(_led[8] , LOW);
  _loco2[7] = 0;
  _canton[_loco2[4]] = 0;       // liberation du canton quitté
  razdigit(_loco2[4]);          // raz du digit TCO
  if (debug) { Serial.println("stop loco 2");}
  }
}

boolean Stop_loco3()  {
  if (_loco3[7] == 1) {
  digitalWrite(_led[9] , LOW);
  _loco3[7] = 0;
  _canton[_loco3[4]] = 0;       // liberation du canton quitté
  razdigit(_loco3[4]);          // raz du digit TCO
  if (debug) { Serial.println("stop loco 3");}
  }
}

boolean Stop_loco4()  {
  if (_loco4[7] == 1) {
  digitalWrite(_led[10] , LOW);
  _loco4[7] = 0;
  _canton[_loco4[4]] = 0;       // liberation du canton quitté
  razdigit(_loco4[4]);          // raz du digit TCO
  if (debug) { Serial.println("stop loco 4");}
  }
}

void blinkLocoLed(int x) {
  for (int y = 0; y<4; y++) {
    digitalWrite(_led[x], HIGH);
    delay(100);
    digitalWrite(_led[x], LOW);
    delay(100);    
  }
}