Fortement inspiré du système sans bâton existant en Grande-Bretagne, ci-dessous le code nécessaire à la réalisation d'un block système manuel de voie unique à partir d'une carte Arduino Uno.
Quelques composants électroniques seront nécessaires comme des LED, des inverseurs, ... mais tout est presque dit (en anglais!!!) dans le code ci-dessous.
Comme pour les autres programmes, j'utilise Serial.println() pour afficher des informations dans le moniteur série ce qui permet de comprendre le fonctionnement mais aussi de corriger plus facilement les erreurs de programmation.
Code : Tout sélectionner
// Name
#define NAME "Tokenless-Blocksystem"
#define NAME2 "Tokenless block system for single track"
#define NAME3 "with IN&OUT datas for interlocking system"
// Version & Copyright
#define VERSION "Version 2.0 (Arduino Uno)"
#define COPYRIGHT "Copyright Fabrice Fayolle, August 2019"
// A -> B : Down Line
// B -> A : Up Line
// Rail directions : Up Line -> To London / Down Line -> To the station
// Arduino Uno
// Pin -> Use for -> Connect to
// 0
// 1
// 2 -> A:Normal -> Orange LED (Common - with a 470 ohms resistor)
// 3 -> A:Blocked -> Red LED
// 4 -> A:Accepted -> Green LED
// 5 -> B:Normal -> Orange LED (Common - with a 470 ohms resistor)
// 6 -> B:Blocked -> Red LED
// 7 -> B:Accepted -> Green LED
// 8
// 9
// 10 -> Block A->B (OUT) -> Interlocking System PCB
// 11 -> Signal A (IN) -> Interlocking System PCB
// 12 -> Block B->A (OUT) -> Interlocking System PCB
// 13 -> Signal B (IN) -> Interlocking System PCB
// 14 -> Lever input (B:Arrived) -> SPDT ON-(ON)
// 15 -> Lever input (B:Offer) -> SPDT ON-(ON)
// 16 -> Lever input (B:Normal/Accept)-> SPDT ON-ON
// 17 -> Lever input (A:Arrived) -> SPDT ON-(ON)
// 18 -> Lever input (A:Offer) -> SPDT ON-(ON)
// 19 -> Lever input (A:Normal/Accept)-> SPDT ON-ON
// INPUT
// SPDT ON-ON
// 1 -> 5V -> Accept
// Common point
// 2 -> GND -> Normal
int A_Normal_Accept = 19;
int B_Normal_Accept = 16;
// SPDT ON-MON
// 1 -> 5V
// Common point
// 2 -> GND -> Offer
int A_Offer = 18;
int B_Offer = 15;
// SPDT ON-MON
// 1 -> 5V
// Common point
// 2 -> GND -> Arrived
int A_Arrived = 17;
int B_Arrived = 14;
//
int A_Block_NOK = 10;
int A_Signal_Not_Open = 11;
int B_Block_NOK = 12;
int B_Signal_Not_Open = 13;
// Orange LED
int A_Normal = 2;
int B_Normal = 5;
// Red LED
int A_Blocked = 3;
int B_Blocked = 6;
// Green LED
int A_Accepted = 4;
int B_Accepted = 7;
void setup()
{
Serial.begin(9600);
Serial.println(NAME);
Serial.println(NAME2);
Serial.println(NAME3);
Serial.println("-------------------------------------------------------------------------- -");
Serial.print(VERSION); Serial.print(", "); Serial.println(COPYRIGHT);
Serial.println("---------------------------------------------------------------------------");
Serial.println("");
pinMode(A_Normal, OUTPUT);
digitalWrite(A_Normal, LOW);
pinMode(B_Normal, OUTPUT);
digitalWrite(B_Normal, LOW);
pinMode(A_Blocked, OUTPUT);
digitalWrite(A_Blocked, LOW);
pinMode(B_Blocked, OUTPUT);
digitalWrite(B_Blocked, LOW);
pinMode(A_Accepted, OUTPUT);
digitalWrite(A_Accepted, LOW);
pinMode(B_Accepted, OUTPUT);
digitalWrite(B_Accepted, LOW);
pinMode(A_Normal_Accept, INPUT_PULLUP);
pinMode(B_Normal_Accept, INPUT_PULLUP);
pinMode(A_Offer, INPUT_PULLUP);
pinMode(B_Offer, INPUT_PULLUP);
pinMode(A_Arrived, INPUT_PULLUP);
pinMode(B_Arrived, INPUT_PULLUP);
pinMode(A_Signal_Not_Open, INPUT_PULLUP);
pinMode(A_Block_NOK, OUTPUT);
digitalWrite(A_Block_NOK, HIGH);
pinMode(B_Signal_Not_Open, INPUT_PULLUP);
pinMode(B_Block_NOK, OUTPUT);
digitalWrite(B_Block_NOK, HIGH);
// Normalization of the block
// Each signalman sets his block instrument to “Accept” (A_Normal_Accept and B_Normal_Accept to HIGH), provided no shunting is taking place into the block section.
// The block status is indicated to both signalmen as “Normal” (A_Normal and B_Normal to LOW)
if (digitalRead(A_Normal_Accept) == LOW || digitalRead(B_Normal_Accept) == LOW)
{
Serial.println("Error: To initialize the block system, please set both block instrument to Accept");
}
while (digitalRead(A_Normal_Accept) == LOW || digitalRead(B_Normal_Accept) == LOW)
{
digitalWrite(A_Blocked, HIGH);
digitalWrite(B_Blocked, HIGH);
delay(250);
digitalWrite(A_Blocked, LOW);
digitalWrite(B_Blocked, LOW);
delay(250);
}
digitalWrite(A_Normal, HIGH);
digitalWrite(B_Normal, HIGH);
Serial.println("Block system: OK");
}
void loop()
{
while (digitalRead(A_Normal_Accept) == LOW && digitalRead(B_Normal_Accept) == LOW)
{
if (digitalRead(A_Offer) == LOW)
{
Serial.println("Error: A can't take the B offer because B is not set to Accept. Maybe shunting is taking place into the block section");
for (int i = 0; i < 4; i++)
{
digitalWrite(A_Normal, LOW);
delay(250);
digitalWrite(A_Normal, HIGH);
delay(250);
}
}
if (digitalRead(B_Offer) == LOW)
{
Serial.println("Error: B can't take the A offer because A is not set to Accept. Maybe shunting is taking place into the block section");
for (int i = 0; i < 4; i++)
{
digitalWrite(B_Normal, LOW);
delay(250);
digitalWrite(B_Normal, HIGH);
delay(250);
}
}
}
// When the next train arrives at A, the A signalman sets his block instrument to “Normal” (A_Normal_Accept to LOW).
// He then presses “Offer” (A_Offer to LOW).
// At B, automatic acceptance of the train occurs, and the block status is indicated as “Blocked” (B_Blocked to HIGH).
// If the B instrument were not set to “Accept” (B_Normal_Accept at HIGH), this would not occur, and a blinking warning would be given
// When acceptance has occurred, the block status at A is indicated as “Accepted” (A_Accepted to HIGH).
if ((digitalRead(A_Normal_Accept) == LOW) && (digitalRead(B_Normal_Accept) == HIGH) && (digitalRead(A_Offer) == LOW))
{
Serial.println("Block system: A->B (accepting)");
digitalWrite(A_Normal, LOW);
digitalWrite(A_Accepted, HIGH);
digitalWrite(B_Normal, LOW);
digitalWrite(B_Blocked, HIGH);
// Block System releases the starting signal lever towards B (interlocking system).
Serial.println("Block system: A->B (starting signal towards B interlocking system releasing)");
digitalWrite(A_Block_NOK, LOW);
// Block System don't release the B starting signal lever towards A (interlocking system).
digitalWrite(B_Block_NOK, HIGH);
delay(250);
// The A signalman may now, at any time, release his starting signal towards B.
// As the signal clears (A_Signal_Not_Open at LOW), the block status changes to “Blocked” (A_Blocked to HIGH).
Serial.println("Block system: A->B (waiting to open the starting signal towards B)");
while (digitalRead(A_Signal_Not_Open))
{
}
Serial.println("Block system: A->B (starting signal towards B opening)");
digitalWrite(A_Accepted, LOW);
digitalWrite(A_Blocked, HIGH);
delay(250);
// The A signalman replaces his starting signal to danger once the train has departed from A (A_Signal_Not_Open at HIGH).
Serial.println("Block system: A->B (waiting to close the starting signal towards B)");
while (!digitalRead(A_Signal_Not_Open))
{
}
Serial.println("Block system: A->B (starting signal towards B closing)");
// Block System cancels the releasing of the starting signal lever towards B (interlocking system).
digitalWrite(A_Block_NOK, HIGH);
delay(250);
// The B signalman checks that the train has arrived complete at B (tail lamp) and then sets his block instrument to “Normal” (B_Normal to LOW).
// He presses “Train Arrived” (B_Arrived to LOW).
// The block section status is then restored to “Normal” (A_Normal and B_Normal at LOW) and indicated to both signalmen by “Normal” indications (A_Normal and B_Normal to LOW).
while ((digitalRead(B_Arrived) != LOW) || (digitalRead(B_Normal_Accept) != LOW))
{
}
Serial.println("Block system: A->B (train arriving complete)");
Serial.println("Block system: OK");
digitalWrite(A_Blocked, LOW);
digitalWrite(B_Blocked, LOW);
digitalWrite(A_Normal, HIGH);
digitalWrite(B_Normal, HIGH);
}
// When the next train arrives at B, the B signalman sets his block instrument to “Normal” (B_Normal_Accept to LOW).
// He then presses “Offer” (B_Offer to LOW).
// ...
if ((digitalRead(B_Normal_Accept) == LOW) && (digitalRead(A_Normal_Accept) == HIGH) && (digitalRead(B_Offer) == LOW))
{
digitalWrite(B_Normal, LOW);
digitalWrite(B_Accepted, HIGH);
digitalWrite(A_Normal, LOW);
digitalWrite(A_Blocked, HIGH);
digitalWrite(B_Block_NOK, HIGH);
digitalWrite(A_Block_NOK, LOW);
delay(250);
while (digitalRead(B_Signal_Not_Open))
{
}
digitalWrite(B_Accepted, LOW);
digitalWrite(B_Blocked, HIGH);
delay(250);
while (!digitalRead(B_Signal_Not_Open))
{
}
digitalWrite(B_Block_NOK, LOW);
delay(250);
while ((digitalRead(A_Arrived) != LOW) || (digitalRead(A_Normal_Accept) != LOW))
{
}
digitalWrite(B_Blocked, LOW);
digitalWrite(A_Blocked, LOW);
digitalWrite(B_Normal, HIGH);
digitalWrite(A_Normal, HIGH);
}
}
