/*
   ***********************************************
   *        Gestion d'éclairage aléatoire        *
   *              version 20250218               *
   *          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.
   */

#include <avr/io.h>
#include <avr/interrupt.h>

#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

const int pins[] = {pinLampadaire, pinMaison1, pinMaison2, pinMaison3, pinMaison4
#if defined(__AVR_ATtiny84__)
, pinMaison5, pinMaison6
#endif
};

unsigned long tempsAllumage[nombreLeds];
unsigned long prochainCycle[nombreLeds];
unsigned long chrono[nombreLeds];
unsigned long tempo1 = 30000;
unsigned long tempo2 = 60001;
unsigned long tempo3 = 10000;
unsigned long tempo4 = 40001;
void setup() {
  for (int i = 0; i < nombreLeds; i++) {
    pinMode(pins[i], OUTPUT);
    digitalWrite(pins[i], LOW);
    chrono[i] = millis();
  }

  // Initialisation de la graine aléatoire
  long graine = 0;
  for (int i = 0; i < 5; i++) {
    #if defined(__AVR_ATtiny84__)
    graine += analogRead(analogPin);
    #elif defined(__AVR_ATtiny85__)
    graine += analogRead(pinPotentiometre);
    #endif
    delay(10); // Laisser un peu de temps entre les lectures
  }
  randomSeed(graine + millis());
}

void loop() {
  // Lire le potentiomètre et ajuster les limites de temps
  int valeurPot = analogRead(pinPotentiometre);
  float facteur = map(valeurPot, 0, 1023, 1, 100)/10; // Facteur entre 0.1 et 10

  for (int i = 0; i < nombreLeds; i++) {
    unsigned long tempsActuel = millis();

    // Si la LED est éteinte, vérifier si c'est l'heure de l'allumer
    if (digitalRead(pins[i]) == LOW) {
      if (tempsActuel - chrono[i] >= prochainCycle[i]) {
        digitalWrite(pins[i], HIGH);
        chrono[i] = tempsActuel; // Redémarre le chrono
        tempsAllumage[i] = random(tempo1* facteur, tempo2 * facteur); // Redéfinit la durée d'allumage
      }
    } else {
      // Si la LED est allumée, vérifier si c'est l'heure de l'éteindre
      if (tempsActuel - chrono[i] >= tempsAllumage[i]) {
        digitalWrite(pins[i], LOW);
        chrono[i] = tempsActuel; // Redémarre le chrono
        prochainCycle[i] = random(tempo3 * facteur, tempo4 * facteur); // Redéfinit le temps d'attente
      }
    }
  }
}