// ATtiny85 activer un relais avec du retard
// MAJ 01-12-2021
// Auteur: Ph Blondé
// Lien: https://forum.espacetrain.com/index.php?topic=3781.0
// Alimentation de l'ensemble en 5V
// ATtiny85 : attention à graver la séquence d'initialisation avant de télécharger le programme!
// 8 MHz

//**********************************************************************************************
// PRINCIPE DE FONCTIONNEMENT DU MONTAGE

// Ce module réagit en recevant un signal de détection (IR) au passage d'un train.
// La détection est déclenchée au passage d'un train sur le modulino UFO87.
// Après un retard ajustable entre 1s et 10mn (temporisation), un relais est activé pendant 1s.
// Ce relais pourra déclencher une animation sur un modulino (ou autre).
// Le temps de temporisation est déterminé par lecture de la valeur d'une résistance variable.
// Cette résistance variable est une résistance variable de 25 tours.
// Dans la phase de temporisation une Led rouge clignote une fois par seconde.
// A l'issue du temps de temporisation, le relais et une Led verte s'activent pendant 1s.
// Le relais (REED 1T) et les Leds sont activés si leur broche est mis à 0 (LOW).
// Un train long ne doit activer qu'une fois le système.
// Un retard de 15s est imposé avant toute prise en compte d'une autre détection.
// Nota : le détecteur IR est un kit de chez Microprocessor (5 détections IR).

//**********************************************************************************************
// PRINCIPE DE LA BOUCLE DE TEMPORISATION

// Lecture de la valeur de la résistance variable qui fixe la valeur du retard
// Valeurs du retard : 0V donne 1 seconde et 5V donne 600s (10mn > 600s)
// Le nombre de boucles à faire est égal à la valeur du retard en secondes (utilisation de map)
// Chaque boucle dure 1 seconde. Exemple : 10 boucles donnent 10 secondes
// La Led rouge clignote pour signaler l'activation de la boucle

//**********************************************************************************************
// REPERAGE DES BROCHES DE L'ATtiny85

// LAISSER LIBRE - RESET                BROCHE N° 1 > RESET
// Detection_Train                      BROCHE N° 2 > VALEUR 3 OU A3 POUR LE CODE
// Resistance_Variable_Valeur_Retard    BROCHE N° 3 > VALEUR 4 OU A2 POUR LE CODE
// Moins alimentation                   BROCHE N° 4 > GND (0V)
// Relais_De_Sortie                     BROCHE N° 5 > PWM VALEUR 0 POUR LE CODE
// Led_Rouge_Temoin_Temporisation       BROCHE N° 6 > PWM VALEUR 1 POUR LE CODE
// Led_Verte_Témoin_Activation_Relais   BROCHE N° 7 > VALEUR 2 OU A1 POUR LE CODE
// Plus alimentation 5V                 BROCHE N° 8 > 5V

//**********************************************************************************************
// DESCRIPTION DES DONNEES

//ENTREES
const int Detection_Train = 3; // BROCHE N° 2
int Etat_Detection_Train;

const int Resistance_Variable_Valeur_Retard = A2; // BROCHE N° 3
int Valeur_Retard;

// SORTIES
const int Relais_De_Sortie = 0; // BROCHE N° 5

const int Led_Rouge_Temoin_Temporisation = 1; // BROCHE N° 6
const int Led_Verte_Temoin_Activation = 2; // BROCHE N° 7

//**********************************************************************************************
void setup()
{
pinMode (Relais_De_Sortie, OUTPUT);
digitalWrite (Relais_De_Sortie, HIGH);

pinMode (Led_Rouge_Temoin_Temporisation, OUTPUT);
digitalWrite (Led_Rouge_Temoin_Temporisation, HIGH);

pinMode (Led_Verte_Temoin_Activation, OUTPUT);
digitalWrite (Led_Verte_Temoin_Activation, HIGH);

pinMode (Detection_Train, INPUT_PULLUP);
}
//**********************************************************************************************
void loop()
{
  Detection ();
}

//**********************************************************************************************
void Detection ()
{
// Attente du signal de détection

do
  {
    Etat_Detection_Train = digitalRead (Detection_Train);
  }
while (Etat_Detection_Train == HIGH);
Temporisation ();
}

//**********************************************************************************************
void Temporisation ()
{
Valeur_Retard = analogRead (Resistance_Variable_Valeur_Retard);
Valeur_Retard = map (Valeur_Retard, 0, 1023, 0, 600);

int Delais_Temporisation = 0;
while (Delais_Temporisation < Valeur_Retard)
  {
    digitalWrite (Led_Rouge_Temoin_Temporisation, LOW);
    delay (200);
    digitalWrite (Led_Rouge_Temoin_Temporisation, HIGH);
    delay (800);
    Delais_Temporisation ++;
  }
Activation ();
}

//**********************************************************************************************
void Activation ()
{
// Activation du relais et de la Led verte

digitalWrite (Led_Verte_Temoin_Activation, LOW);
digitalWrite (Relais_De_Sortie, LOW);
delay (1500);
digitalWrite (Relais_De_Sortie, HIGH);
digitalWrite (Led_Verte_Temoin_Activation, HIGH);
Desactivation ();
}

//**********************************************************************************************
void Desactivation ()
{
// Désactivation du système durant 15s.

int Delais_Desactivation = 0;
while (Delais_Desactivation <= 15)
  {
    digitalWrite (Led_Rouge_Temoin_Temporisation, LOW);
    delay (800);
    digitalWrite (Led_Rouge_Temoin_Temporisation, HIGH);
    delay (200);
    Delais_Desactivation ++;
  }
Detection ();
}