// MAJ 2024-11-09 - Chargement à 16MHz
// Utilisation de PWM (ou MLI en français : Modulation de Largeur d'Impulsion).

// REPERAGE DES BROCHES D'UN ATtiny45 OU 85 :
// Broche 1 : Reset       Broche 8 : 5V
// Broche 2 : A3 ou 3     Broche 7 : A1 ou 2
// Broche 3 : A2 ou 4     Broche 6 : 1 (PWM)
// Broche 4 : GND         Broche 5 ; 0 (PWM)

// LE CIRCUIT EN HOe:
// Simple boucle dont la moitié est visible.
// En coulisse : un point de détection (détecteur à effet Hall) et une zone d'arrêt.
// Composition du train :
//  - Un locotracteur ROCO suivi d'un autre démotorisé (prise de courant supplémentaire).
//  - des wagonnets.

// DÉROULEMENT DE LA SEQUENCE :
// L'inverseur marche/arrêt (MA_AT) est activé.
// Le train démarre en coulisse et la vitesse passe de "Vitesse_Mini" à celle de "Potentiometre_Vitesse".
// Pendant le roulage la vitesse est ajustable par "Potentiometre_Vitesse".
// De retour dans la coulisse, il passe au dessus du détecteur à effet Hall.
// Début du ralentissement après un décompte de 2 s ; Le train n'est plus sur la zone de détection.
// Le "Potentiometre_Temps_Arret" fixe le temps d'arrêt de 10 s à "Temps_Maxi_Arret" (180 s).
// La séquence redémarre après ce temps d'arrêt.

// NOTES :

// 1 - "Vitesse_Mini" est à ajuster à la tension de démarrage du moteur dans DECLARATION DES VARIABLES.
//     "Vitesse_Maxi" est à ajuster dans DECLARATION DES VARIABLES.
// 2 - Les taux d'inertie en accélération et en freinage sont à ajuster au type de matériel.
//    "Inertie_Acceleration" et "Inertie_Freinage" sont à ajuster dans DECLARATION DES VARIABLES.
// 3 - Le temps maxi d'arrêt peut être modifié dans "Temps_Maxi_Arret" dans DECLARATION DES VARIABLES.
// 4 - La tension max d'alimentation du moteur est de 12 V. Sa consommation moyenne est de 200 mA.
//     Faute de puissance, l'ATtiny85 ne peut pas commander directement le moteur du locotracteur.
//     Une broche de sortie délivre un maximum de 40 mA sous 5 V.
//     Un ULN2803L, assure l'interface et peut délivrer jusqu'à 4 A sous 12 V.
// 5 - Deux LEDs (rouge et verte) indiquent l'état de marche du train ou celui de son arrêt en coulisse.

// ****************************************************************************************************

// DECLARATION DES VARIABLES

int const Detection_MA_AT = 4;  // Détection à effet Hall ou bascule de l'inverseur Marche-arrêt
int Etat_Detection_MA_AT;

int const Potentiometre_Vitesse = A3;
int Valeur_Vitesse;
int Vitesse;

int const Potentiometre_Temps_Arret = A1;
int Valeur_Temps_Arret;
int Temps_Arret;

int const PWM = 1;
int Valeur_PWM;

int const Led_Rouge_Vert = 0;

// Valeurs à ajuster suivant type de matériel :
int Inertie_Acceleration = 35;
int Inertie_Freinage = 50;
int Vitesse_Maxi = 130;
int Vitesse_Mini = 30;
int Temps_Maxi_Arret = 180; // En secondes


void setup()
{
pinMode (Detection_MA_AT, INPUT_PULLUP); // PULLUP : maintien à HIGH si pas de signal

pinMode (Potentiometre_Vitesse, INPUT);

pinMode (Potentiometre_Temps_Arret, INPUT);

pinMode (PWM, OUTPUT);
analogWrite (PWM, 0);

pinMode (Led_Rouge_Vert, OUTPUT);
}


void loop()

{
// TEST SUR LA POSITION DE L'INVERSEUR MARCHE/ARRET (MA_AT)
do
  {
    Etat_Detection_MA_AT = digitalRead (Detection_MA_AT);
    digitalWrite (Led_Rouge_Vert, LOW); // LOW = Rouge
  }
while (Etat_Detection_MA_AT == LOW);

// DÉPART - ACCÉLÉRATION
digitalWrite (Led_Rouge_Vert, HIGH); // HIGH = Vert
Valeur_PWM = (Vitesse_Mini);
do
  {
    Valeur_Vitesse = analogRead (Potentiometre_Vitesse);
    Vitesse = map (Valeur_Vitesse, 0, 1023, Vitesse_Mini, Vitesse_Maxi);
    analogWrite (PWM, Valeur_PWM);
    delay (Inertie_Acceleration); // En ms
    Valeur_PWM = (Valeur_PWM + 1);
  }
while (Valeur_PWM <= Vitesse);

// ROULAGE - ATTENTE DE DÉTECTION DE PASSAGE
do
  {
    Valeur_Vitesse = analogRead (Potentiometre_Vitesse);
    Vitesse = map (Valeur_Vitesse, 0, 1023, Vitesse_Mini, Vitesse_Maxi);
    analogWrite (PWM, Vitesse);
    Etat_Detection_MA_AT = digitalRead (Detection_MA_AT);
  }
while (Etat_Detection_MA_AT == HIGH);

// LA DÉTECTION N'EST PLUS EN "HIGH"
delay (2000); // Retard de 2 s pour passer la zone de détection

// RALENTISSEMENT
Valeur_PWM = Vitesse;
do
  {
    analogWrite (PWM, Valeur_PWM);
    delay (Inertie_Freinage); // En ms
    Valeur_PWM = (Valeur_PWM -1);
  }
while (Valeur_PWM >= 0);

// TEMPS D'ARRÊT
Valeur_Temps_Arret = analogRead (Potentiometre_Temps_Arret);
Temps_Arret = map (Valeur_Temps_Arret, 0, 1023, 5, Temps_Maxi_Arret);

do
  {
    digitalWrite (Led_Rouge_Vert, LOW); // LOW = Rouge
    delay (1000);
    Temps_Arret = (Temps_Arret - 1);
  }
while (Temps_Arret >= 0);
Valeur_PWM = 0;
}