/*
   ***********************************************
   *        Gestion d'éclairage aléatoire        *
   *              version 20241229               *
   *          pour arduino Tiny84 ou 85          *
   *                                             *
   ***********************************************
   
   Reprise divers montages.dip       ATtiny84 - Eclairage aléatoire 20241229
           
   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   !                  Ce code est distribué gratuitement sous licence                   !
   !                       Creativ Commons CC-BY-NC-ND 3.0                              !
   !                                                                                    !
   !         Cette licence permet à d'autres utilisateurs d'utiliser ce code            !
   !       à des fins non commerciales,  dans la mesure où le nom de l'auteur est       !
   !       mentionné. Toute modification du code devra être soumise à                   !
   !       l'autorisation expresse de l'auteur.                                         !
   ! Tests sur https://www.tinkercad.com/things/fSRf3OmMYml-attiny85eclairage-aleatoire !
   !       auteur Philippe GUENET - [email protected] - https://wgnt-train.fr       !
   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   
   * Animation lumineuse avec ATtiny85 ou ATtiny84
   * Éclairage aléatoire de plusieurs maisons + un lampadaire extérieur
   * Basée sur un ATtiny85 ou un ATtiny84.
   * 
   * Pour ATtiny85 :
   *   - 5 pins utilisées (PB0 à PB4)
   *   - Potentiomètre connecté à PB5 (entrée analogique)
   * 
   * Pour ATtiny84 :
   *   - 7 pins utilisées (PB2 + PA0 à PA5)
   *   - Potentiomètre connecté à PA6
   *   - Lecture aléatoire via PA7 (entrée analogique supplémentaire)
   *
   * Fonctionnement :
   * - Une temporisation alternée (tempo1/tempo2) change l'état des LEDs aléatoirement.
   * - La temporisation `tempo1` est réglable avec un potentiomètre (1 à 5 secondes).
   * - La LED du lampadaire (pinLampadaire) reste toujours allumée.
   */

#if defined(__AVR_ATtiny85__)
const byte pinLampadaire = PB0;
const byte pinMaison1 = PB1;
const byte pinMaison2 = PB2;
const byte pinMaison3 = PB3;
const byte pinMaison4 = PB4;
const byte pinPotentiometre = PB5; // Pin pour le potentiomètre
const int nombreLeds = 5;

#elif defined(__AVR_ATtiny84__)
const byte pinLampadaire = PB2;
const byte pinMaison1 = PA0;
const byte pinMaison2 = PA1;
const byte pinMaison3 = PA2;
const byte pinMaison4 = PA3;
const byte pinMaison5 = PA4;
const byte pinMaison6 = PA5;
const byte pinPotentiometre = PA6;
const int analogPin = PA7; // Utilisé pour générer une graine aléatoire
const int nombreLeds = 7;
#else
#error "Ce code est conçu uniquement pour ATtiny84 ou ATtiny85"
#endif

int tempo1 = 5000; // Temporisation modifiable via le potentiomètre (par défaut : 2.5 secondes)
const int tempo2 = 10000; // Temporisation fixe de 5 secondes

byte leds = 0B11111111; // État des LEDs (1 = allumée, 0 = éteinte)
unsigned long temps; // Stocke le dernier moment où les LEDs ont changé d'état
byte randNumber; // Stocke la valeur aléatoire pour l'état des LEDs
int tempo; // Temporisation actuelle (alterne entre tempo1 et tempo2)

// Fonction pour ajuster `tempo1` en fonction du potentiomètre
void ajusterTempo() {
#if defined(__AVR_ATtiny84__) || defined(__AVR_ATtiny85__)
  int lecturePot = analogRead(pinPotentiometre); // Lecture de la valeur du potentiomètre
  tempo1 = map(lecturePot, 0, 1023, 10000, 50000); // Mapping : ajuste entre 1 et 5 secondes
#endif
} // Fin de ajusterTempo()

void setup() {
#if defined(__AVR_ATtiny85__)
  pinMode(pinLampadaire, OUTPUT);
  pinMode(pinMaison1, OUTPUT);
  pinMode(pinMaison2, OUTPUT);
  pinMode(pinMaison3, OUTPUT);
  pinMode(pinMaison4, OUTPUT);
  pinMode(pinPotentiometre, INPUT); // Configuration du potentiomètre
  randomSeed(millis()); // Initialisation de la graine aléatoire avec millis()

#elif defined(__AVR_ATtiny84__)
  pinMode(pinLampadaire, OUTPUT);
  pinMode(pinMaison1, OUTPUT);
  pinMode(pinMaison2, OUTPUT);
  pinMode(pinMaison3, OUTPUT);
  pinMode(pinMaison4, OUTPUT);
  pinMode(pinMaison5, OUTPUT);
  pinMode(pinMaison6, OUTPUT);
  randomSeed(analogRead(analogPin)); // Initialisation de la graine aléatoire via entrée analogique
#endif
  ajusterTempo(); // Lecture initiale de la temporisation réglable
  temps = millis(); // Initialisation du temps
  tempo = tempo1; // Définir la temporisation initiale
} // Fin de setup()

void loop() {
  // Mise à jour de l'état des LEDs
  for (int i = 0; i < nombreLeds; i++) {
    digitalWrite(i, bitRead(leds, i)); // Applique l'état de chaque LED
  }

  // Vérifie si le temps écoulé dépasse la temporisation actuelle
  if (millis() - temps >= tempo) {
    temps = millis(); // Réinitialisation du temps
    ajusterTempo(); // Mise à jour de la valeur de `tempo1` (potentiomètre)
    tempo = (tempo == tempo1) ? tempo2 : tempo1; // Alterne entre tempo1 et tempo2

    // Génération d'un nouvel état aléatoire pour les LEDs
    byte newRandNumber = random(1 << nombreLeds); // Génère un nombre aléatoire
    if (newRandNumber != leds) { // Évite les changements inutiles si l'état reste identique
      leds = newRandNumber | 0B00000001; // Assure que le lampadaire reste toujours allumé
    } // Fin de if (newRandNumber != leds)
  } // Fin de if (millis() - temps >= tempo)
} // Fin de loop()