horloge modifier

//ma modification du code

#include "Wire.h"
#include <RTClib.h>
#include <Adafruit_NeoPixel.h>
//#include "pitches.h"  // copiez le fichier pitches.h dans le répertoire où réside votre projet Arduino, puis redémarrez le logiciel Arduino

//declaration des Pins
#define BP_REGLAGE_HEURE 7 // bouton-poussoir de réglage de l'heure
#define BP_INC_MINUTE 2    // bouton-poussoir d'incrémentation des minutes
#define BP_INC_HEURE 3     // bouton-poussoir d'incrémentation de l'heure
#define BP_MARCHE_ARRET 4  // bouton-poussoir marche/arrêt du carillon
#define DHD_DIAL_PIN 8     // broche de commande du cadran de l'horloge
#define STRIP_LITOPHANIES 5  // broche de commande de la bande de lithophanies
#define STRIP_HEURES 11    // broche de commande de la bande d'heures
#define STRIP_MINUTES 9    // broche de commande de la bande de minutes
#define STRIP_SECONDES 6   // broche de commande de la bande de secondes
#define TONE_PIN 10        // broche de commande du buzzer

#define DS3231_ADDRESS 0x68 //adresse par défaut du module 3231 RTC
#define BRIGHTNESS 12 //définit la luminosité maximale - un nombre plus élevé est plus lumineux. Si le nombre est trop élevé, il dépassera la consommation actuelle d'Arduino

#define CHIME_QUARTER 0
#define CHIME_HALF 5
#define CHIME_THREE_QUARTER 15
#define CHIME_HOUR 30
#define CHIME_END 50

//configuration pour le carillon de l'heure et de la demi-heure de Westminster
unsigned int melody[50] =
{
  // 0
  NOTE_GS4, NOTE_FS4, NOTE_E4, NOTE_B3, 0,
  // 5
  NOTE_E4, NOTE_GS4, NOTE_FS4, NOTE_B3, 0, NOTE_E4, NOTE_FS4, NOTE_GS4, NOTE_E4, 0,
  // 15
  NOTE_GS4, NOTE_E4, NOTE_FS4, NOTE_B3, 0, NOTE_B3, NOTE_FS4, NOTE_GS4, NOTE_E4, 0, NOTE_GS4, NOTE_FS4, NOTE_E4, NOTE_B3, 0,
  // 30
  NOTE_E4, NOTE_GS4, NOTE_FS4, NOTE_B3, 0, NOTE_E4, NOTE_FS4, NOTE_GS4, NOTE_E4, 0, NOTE_GS4, NOTE_E4, NOTE_FS4, NOTE_B3, 0, NOTE_B3, NOTE_FS4, NOTE_GS4, NOTE_E4, 0 // 49
};

int noteDurations[50] =
{
  4, 4, 4, 2, 8,
  4, 4, 4, 2, 8, 4, 4, 4, 2, 8,
  4, 4, 4, 2, 8, 4, 4, 4, 2, 8, 4, 4, 4, 2, 8,
  4, 4, 4, 2, 8, 4, 4, 4, 2, 8, 4, 4, 4, 2, 8, 4, 4, 4, 2, 8
};

bool chime_hour {false};
bool chime_15 {false};
bool chime_30 {false};
bool chime_45 {false};
bool chime_active {true}; //Initialise la variable utilisée pour indiquer si le carillon est activé ou désactivé

byte one = 0x01; //variable utilisée pour indiquer le réglage de l'heure pour les minutes dans DS3231
byte two = 0x02; //variable utilisée pour indiquer le réglage de l'heure pour les minutes dans DS3231

byte hourval{0}, hourpos{0}, minuteval{0}, secondval{0}; // contient l'heure réelle
byte pixelColorRed{0}, pixelColorGreen{0}, pixelColorBlue{0}; //contient les valeurs de couleur pour NeoPixels

byte hourval_set{0};   // détient l'heure définie
byte minuteval_set{0}; // maintient l'heure réglée en minutes


RTC_DS3231 RTC; // Établir l'objet horloge
DateTime Clock; // Maintient l'heure actuelle de l'horloge

Adafruit_NeoPixel strip1 = Adafruit_NeoPixel(60, 6, NEO_GRB + NEO_KHZ800); // objet de bande pour les secondes 60 neopixels contrôlés sur la broche 6
Adafruit_NeoPixel strip2 = Adafruit_NeoPixel(60, 9, NEO_GRB + NEO_KHZ800); // objet de bande pour les minutes 60 neopixels contrôlés sur la broche 9
Adafruit_NeoPixel strip3 = Adafruit_NeoPixel(36, 11, NEO_GRB + NEO_KHZ800); // objet de bande pour les heures 36 neopixels contrôlés sur la broche 11
Adafruit_NeoPixel strip4 = Adafruit_NeoPixel(120, 5, NEO_GRB + NEO_KHZ800); // objet de bande pour les lithophanies 120 neopixels contrôlés sur la broche 5

#define STRIP1_OFF strip1.Color(0, 0, 0)
#define STRIP2_OFF strip2.Color(0, 0, 0)
#define STRIP3_OFF strip3.Color(0, 0, 0)

#define STRIP1_RED strip1.Color(255, 0, 0)
//#define STRIP2_RED strip2.Color(255, 0, 0)
//#define STRIP3_RED strip3.Color(255, 0, 0)

//#define STRIP1_GREEN strip1.Color(0, 255, 0)
#define STRIP2_GREEN strip2.Color(0, 255, 0)
//#define STRIP3_GREEN strip2.Color(0, 255, 0)

//#define STRIP1_BLUE strip1.Color(0, 0, 255)
//#define STRIP2_BLUE strip2.Color(0, 0, 255)
#define STRIP3_BLUE strip3.Color(0, 0, 255)

// ou

const uint32_t red = strip1.Color(255, 0, 0);   //définit la couleur rouge NeoPixel sur la bande 1 pour les secondes
const uint32_t green = strip2.Color(0, 255, 0); //définit la couleur Vert NeoPixel sur la bande 2 pour les minutes
const uint32_t blue = strip3.Color(0, 0, 255);  //définit la couleur NeoPixel Bleu sur la bande 2 pour les heures
const uint32_t of = strip1.Color(0, 0, 0);     //définit NeoPixel Pas de couleur pour la bande 1
const uint32_t off = strip2.Color(0, 0, 0);     //définit NeoPixel Pas de couleur pour la bande 2
const uint32_t offf = strip3.Color(0, 0, 0);     //définit NeoPixel Pas de couleur pour la bande 3


//prototype de fonction
void set_lights();
void play_chime(const int& startPos,const int& endPos);
void change_hours();
void change_minutes();
void setDateTime_hours();
void setDateTime_minutes();
void clearPixels();
byte decToBcd(byte val);
byte bcdToDec(byte val);



void setup()
{
    pinMode(BP_REGLAGE_HEURE, INPUT_PULLUP); // déclarer la broche 7 comme une entrée avec des pullups internes (fil rouge - bouton-poussoir de réglage de l'heure):
    pinMode(BP_INC_MINUTE, INPUT_PULLUP); // déclarer la broche 2 comme une entrée avec des pullups internes (fil bleu - bouton-poussoir d'incrémentation des minutes):
    pinMode(BP_INC_HEURE, INPUT_PULLUP); // déclarer la broche 3 comme une entrée avec des pullups internes (fil vert - bouton-poussoir d'incrémentation de l'heure):
    pinMode(BP_MARCHE_ARRET, INPUT_PULLUP); // déclarer la broche 4 comme une entrée avec des pullups internes (fil blanc - bouton-poussoir marche/arrêt du carillon) :
    pinMode(DHD_DIAL_PIN, OUTPUT);       // déclarer la broche 8 comme une sortie (DHD Dial Crystal LED):
    pinMode(STRIP_LITOPHANIES, OUTPUT);       // déclarer la broche 5 comme une sortie (NeoPixel Control Pin des lithophanies):
    pinMode(STRIP_SECONDES, OUTPUT);       // déclarer la broche 6 comme une sortie (NeoPixel Control Pin des secondes):
    pinMode(STRIP_MINUTES, OUTPUT);       // déclarer la broche 9 comme une sortie (NeoPixel Control Pin des minutes):
    pinMode(STRIP_HEURES, OUTPUT);       // déclarer la broche 11 comme une sortie (NeoPixel Control Pin des heures):
    pinMode(TONE_PIN, OUTPUT);
    digitalWrite(TONE_PIN, LOW);

    Wire.begin();
    RTC.begin();              // commence l'horloge
    Serial.begin(9600);       // définit le numéro de série pour le débogage du programme
    delay(100);
  //     RTC.adjust(DateHeure(__DATE__, __HEURE__)); // Exécutez ceci pour régler l'heure sur l'heure du PC lors de la mise sous tension d'Arduino - activer uniquement pour le débogage et le dépannage


    strip1.setBrightness(BRIGHTNESS); // définit le niveau de luminosité défini en haut du programme pour la bande 1
    strip2.setBrightness(BRIGHTNESS); // définit le niveau de luminosité défini en haut du programme pour la bande 2
    strip3.setBrightness(BRIGHTNESS); // définit le niveau de luminosité défini en haut du programme pour la bande 3
    strip4.setBrightness(BRIGHTNESS); // définit le niveau de luminosité défini en haut du programme pour la bande 4
}


void loop()
{

  int button_Set_Time = digitalRead(BP_REGLAGE_HEURE);    // Lire le bouton-poussoir de réglage de l'heure
  int button_Minute_Inc = digitalRead(BP_INC_MINUTE);  // Lire le bouton-poussoir d'incrémentation des minutes
  int button_Hour_Inc = digitalRead(BP_INC_HEURE);    // Lire le bouton-poussoir d'incrémentation de l'heure
  int button_Set_Chime = digitalRead(BP_MARCHE_ARRET);   // Lire le bouton poussoir marche/arrêt du carillon

  // Obtenir l'heure actuelle du module d'horloge en temps réel
  Clock = RTC.now();           // obtenir l'heure RTC

  secondval = Clock.second();  // obtient les secondes
  minuteval = Clock.minute();  // obtenir des minutes
  hourval = Clock.hour();      // obtenir des heures

// Ceci est ici pour le débogage en série si nécessaire
   // Serial.print("set time: "); Serial.print(button_Set_Time); Serial.print('\n');
   // Serial.print("heure : "); Serial.print(bouton_Heure_Inc); Serial.print('\n');
   // Serial.print("minute: "); Serial.print(bouton_Minute_Inc); Serial.print('\n');
   // Serial.print("carillon : "); Serial.print(button_Set_Chime); Serial.print('\n');
   // Série.print('\n');

  if (hourval > 11) hourval -= 12;             // si hourval> 11 then hourval -= hourval - 12 cela en fait juste une horloge de 12 heures
  hourpos = hourval;
  hourpos = ((hourpos * 36)/12 )+(minuteval/20);   //détermine le point bleu à éclairer par exemple 3:30 est (3 * 60 + 30) / 19.85 = 10.57 donc le pixel est 10 est illuminé puisque Arduino tronque le reste


  // peut être defini pour chaque bande par un nombre de 1 a 255

  // Définit les valeurs initiales pour chaque bade
  strip1.setPixelColor(secondval, STRIP1_RED);
  strip2.setPixelColor(minuteval, STRIP2_GREEN);
  strip3.setPixelColor(hourpos, STRIP3_BLUE);
  strip4.setPixelColor(hourpos, STRIP3_BLUE);  //pas sur pour hourpos pour stip4

  strip1.show();
  strip2.show();
  strip3.show();
  strip4.show();

  //Vérifiez si les secondes sont juste passées à 0. Si c'est le cas, éteignez les LED des secondes de l'horloge et recommencez
  if (secondval == 0)
  {
    switch (minuteval)
    {
      case 0:
        chime_hour = true;
        break;
      case 15:
        chime_15 = true;
        break;
      case 30:
        chime_30 = true;
        break;
      case 45:
        chime_45 = true;
        break;
      default:
        break;
    }

    strip1.setPixelColor(0, STRIP1_RED);
    for (int i = 1; i < 60; i++)
    {
      strip1.setPixelColor(i, STRIP1_OFF);
    }

    strip1.show();
  }

  set_lights();
  delay(20);

  // Jouez à Westminster à l'heure si le carillon est réglé et allumez également la LED
  if (chime_hour && chime_active )
  {
    int limit = hourval;

    play_chime(CHIME_HOUR, CHIME_END);
//    delay(1000);

    // Sonne l'heure.
    // Zéro est vraiment midi.
    if (limit == 0) limit = 12;


    for (int i = 0; i < limit; i++)
    {
      unsigned long noteDuration = 1000UL;  //en float pour que la multiplication fonctionne
      tone(TONE_PIN, NOTE_E3, noteDuration);
      set_lights();
      int pauseBetweenNotes = int(noteDuration * 1.30f); // pour distinguer les notes, fixez un temps minimum entre elles.

      delay(pauseBetweenNotes); //attention Bloquant pendant la durée de la note le programme ne peut rien faire d'autre
      noTone(TONE_PIN); // arrête la tonalité :
    }

    chime_hour = false;
  }

  //turn the LED off at 1 minute since it is turned on when the hour changes if the time is set
  if (minuteval == 1) digitalWrite(DHD_DIAL_PIN, LOW);

  //Jouez à Westminster au quart d'heure si le carillon est réglé et allumez également la LED
//  if (chime_15 == true && chime_active == true) en dessous c'est la meme chose
  if (chime_15 && chime_active )
  {
    play_chime(CHIME_QUARTER, CHIME_HALF);
    chime_15 = false;
  }

  //éteint la LED à 16 minutes puisqu'elle s'allume au changement de 1/4 d'heure si l'heure est réglée
  if (minuteval == 16) digitalWrite(DHD_DIAL_PIN, LOW);


  //Jouez la dernière moitié de Westminster à l'heure si le carillon est réglé et allumez la LED
  if ( chime_30 && chime_active )
  {
    play_chime(CHIME_HALF, CHIME_THREE_QUARTER);
    chime_30 = false;
  }

  //éteint la LED à 31 minutes puisqu'elle s'allume à 30 minutes si le carillon est réglé
  if (minuteval == 31) digitalWrite(DHD_DIAL_PIN, LOW);

  //Jouez à Westminster aux 3/4 d'heure si le carillon est réglé et allumez également la LED
  if (chime_45 && chime_active )
  {
    play_chime(CHIME_THREE_QUARTER, CHIME_HOUR);
    chime_45 = false;
  }

  //éteint la LED à 46 minutes puisqu'elle s'allume au changement de 3/4 d'heure si l'heure est réglée
  if (minuteval == 46) digitalWrite(DHD_DIAL_PIN, LOW);

  //Vérifier les boutons poussoirs
  //vérifier si le bouton régler l'heure et changer les heures est enfoncé
  if (!button_Set_Time && !button_Hour_Inc && button_Minute_Inc && button_Set_Chime )
  {
    clearPixels();
    change_hours();
    delay(300);
  }

  //vérifier si le bouton régler l'heure et changer les minutes est enfoncé
  if (!button_Set_Time && button_Hour_Inc  && !button_Minute_Inc && button_Set_Chime)
  {
    clearPixels();
    change_minutes();
    delay(150);
  }

  //vérifier si le bouton Définir le carillon est enfoncé et que le carillon n'est pas actuellement actif
  if (button_Set_Time  && button_Hour_Inc  && button_Minute_Inc && !button_Set_Chime && !chime_active )
  {
    delay (500);
    chime_active = true;
    chime_hour = false;
    chime_15 = false;
    chime_30 = false;
    chime_45 = false;
    tone(TONE_PIN, NOTE_G6, 125);
    delay(130);
    tone(TONE_PIN, NOTE_C7, 125);
    delay(130);
    tone(TONE_PIN, NOTE_G7, 125);
    delay(125);
    noTone(TONE_PIN);
    delay (1000);
  }


  //vérifier si le bouton Set Chime est enfoncé et si le carillon est actuellement actif
  if (button_Set_Time && button_Hour_Inc  && button_Minute_Inc && !button_Set_Chime && chime_active )
  {
    delay (500);
    chime_active = false;
    chime_hour = false;
    chime_15 = false;
    chime_30 = false;
    chime_45 = false;
    tone(TONE_PIN, NOTE_A3, 125);
    delay(130);
    tone(TONE_PIN, NOTE_A2, 200);
    delay(205);
    tone(TONE_PIN, NOTE_A1, 150);
    delay(155);
    noTone(TONE_PIN);
    delay (1000);
  }
}//fin de la boucle loop

// Régler les lumières
void set_lights()
{
    //deja declarer en global
/*
  uint32_t red = strip1.Color(255, 0, 0);   //définit la couleur rouge NeoPixel
  uint32_t green = strip2.Color(0, 255, 0); //définit la couleur Vert NeoPixel
  uint32_t blue = strip3.Color(0, 0, 255);  //définit la couleur NeoPixel Blue
  uint32_t of = strip1.Color(0, 0, 0);     //définit NeoPixel Pas de couleur pour la bande 1
  uint32_t off = strip2.Color(0, 0, 0);     //définit NeoPixel Pas de couleur pour la bande 2
  uint32_t offf = strip3.Color(0, 0, 0);     //définit NeoPixel Pas de couleur pour la bande 3
*/


 // Obtenir l'heure actuelle du module d'horloge en temps réel
  Clock = RTC.now();           // get the RTC time
  secondval = Clock.second();  // obtient les secondes
  minuteval = Clock.minute();  // obtenir des minutes

  for (int i = 0; i < secondval; i++){
    strip1.setPixelColor(i, STRIP1_RED);
    strip1.setPixelColor(i, STRIP1_OFF);

    //strip1.setPixelColor(i, red);
    //strip1.setPixelColor(i, of);
  }

  strip2.setPixelColor(minuteval, STRIP2_GREEN);
  strip2.setPixelColor(minuteval-1, STRIP2_OFF);

  strip3.setPixelColor(hourpos, STRIP3_BLUE);
  strip3.setPixelColor(hourpos-1,STRIP3_OFF);

  strip1.show();
  strip2.show();
  strip3.show();
}


void play_chime(const int& startPos, const int& endPos)
{
  digitalWrite(DHD_DIAL_PIN, HIGH);                      //allume la LED
  // itération sur les notes de la mélodie :
  for (int thisNote = startPos; thisNote < endPos; thisNote++)
  {
    // pour calculer la durée de la note, prenez une seconde
    // divisé par le type de note.
    //par exemple. noire = 1000/4, croche = 1000/8, etc.
    unsigned long noteDuration = 1000UL / noteDurations[thisNote];
    tone(TONE_PIN, melody[thisNote], noteDuration);
    set_lights();
    int pauseBetweenNotes = int(noteDuration * 1.30f); // pour distinguer les notes, fixez un temps minimum entre elles.
    delay(pauseBetweenNotes);
    noTone(TONE_PIN); // arrête la tonalité :
  }

  set_lights();

}


//Modifier les heures d'horloge
void change_hours()
{
    if (hourval_set < 24)  hourval_set = hourval_set + 1;
    else hourval_set = 0;
    setDateTime_hours();
}


//Modifier les minutes de l'horloge
void change_minutes()
{
    if (minuteval_set < 60) minuteval_set = minuteval_set + 1;
    else minuteval_set = 0;
    setDateTime_minutes();
}

//Modifier les heures d'horloge dans le DS3231
void setDateTime_hours()
{
  Wire.beginTransmission(DS3231_ADDRESS);
  Wire.write(two); //stop Oscillator
  Wire.write(decToBcd(hourval_set));
  Wire.endTransmission();
}


//Modifier les minutes d'horloge dans le DS3231
void setDateTime_minutes()
{
  Wire.beginTransmission(DS3231_ADDRESS);
  Wire.write(one); //stop Oscillator
  Wire.write(decToBcd(minuteval_set));
  Wire.endTransmission();
}


//Éteignez les NeoPixels - Cela se produit chaque fois que les secondes passent à zéro.
void clearPixels()
{
  for (int i = 0; i < 60; i++)
     strip1.setPixelColor(i, STRIP1_OFF);

    strip1.show();
    delay(10);
}


// Convert normal decimal numbers to binary coded decimal - used for DS1307
byte decToBcd(byte val){  return ( (val / 10 * 16) + (val % 10) ); }

// Convert binary coded decimal to normal decimal numbers - used for DS1307
byte bcdToDec(byte val){  return ( (val / 16 * 10) + (val % 16) ); }