Une Horloge Textuelle Dans Un Cadre Ikea Transformé En Miroir Pilotée Par Un Arduino

Bonjour,

J'ai pu réaliser ces derniers jours ce projet d'horloge textuelle que j'avais découvert sur internet, en version anglaise, il y a quelques années. L'aboutissement d'une longue préparation afin de trouver LA bonne solution, peu coûteuse et réalisable avec mon équipement actuel (un kit découverte Arduino Uno R3), un PC, une imprimante jet d'encre (pas de découpe laser ni d'impression 3D).

J'ai ainsi découvert les joies du langage C pur et dur, habitué que j'étais aux langages plus "évolués" et moins pinailleurs sur les types de variables, de tableaux.

Au départ, je voulais que l'horloge textuelle donne l'heure à la seconde près mais il m'aurait fallu pouvoir éclairer largement plus de 255 LED pour arriver à mes fins, j'ai donc réduit mes ambitions à une horloge qui donne l'heure de 5 minutes en 5 minutes, en précisant tout de même le nombre de minutes en plus de l'heure affichée. (Par exemple, pour 19h46, on écrit "HUIT HEURES MOINS LE QUART DU SOIR +1").

Parti de là, j'ai pu déterminer le nombre de cases d'un carré contenant toutes les lettres pour écrire tous les mots nécessaires à l'affichage de l'heure. Il a fallu cogiter pour que toutes les lettes de chaque mot à former soient contiguës et essayer de caser les mots de telle sorte qu'ils apparaissent toujours dans le bon ordre, en essayant si possible de mutualiser certaines lettres de mots différents (Exemple, "TROISEPT", j'utilise "TROIS" ou "SEPT" mais pas les deux simultanément"). Tout tenait dans un carré de 11 x 11 lettres (soit 121 lettres, donc 121 leds pour éclairer chacune des lettres).

J'ai longtemps stagné sur la façon d'éclairer ces LEDS individuellement vu le delta entre la dizaine de sorties de l'Arduino et mon besoin de 121 LEDS. En cherchant, j'ai trouvé qu'on pouvait utiliser des multiplexeurs (1 entrée pilote 8 sorties) et les mettre en série. (https://www.aranacorp.com/fr/utilisation-dun-multiplexer-avec-arduino/)

J'allais m'orienter vers cette solution quand j'ai découvert l'existence de rubans LED qui ressemblent à ceux qu'on peut trouver à 1€ à Action mais qui sont adressables individuellement et pilotables par 1 sortie d'Arduino, le rêve !!!

J'avais toutes les cartes pour commencer ...

• Un ruban de 5m avec 150 LEDS adressables individuellement WS2812B RGB 5050SMD (19,99€ à Amazon)
• Un module RTC (Horloge temps réel) avec sa pile (4,99€ à Amazon)
• 2 micro-boutons poussoir (récupérés dans mon kit de démarrage Arduino)
• 1 cellule photo électrique (récupérée dans mon kit de démarrage Arduino)
• 4 résistances (3 x 220kOhms et 1 x 10kOhms) pour les capteurs boutons et le bandeau lumineux
• Un arduino nano - acheté à la fin quand mon projet était prêt (7€ sur le boncoin)
• Un connecteur femelle USB C à souder pour l'alimentation du cadre (2€ dans un magasin d'électronique)
• Un cadre profond Ikéa de 25 x 25 style SANNAHED, mais je pense, plus ancien (2€ à Emmaüs)
• Un rouleau de film miroir sans tain 200 x 50 cm (2,99€ à Action)
• Une chute de carton plume, du papier fort, du papier calque, du carton, de la colle
• Un fer à souder, un peu de fil, de la soudure à l'étain

Il existe en gros 3 types de rubans LED, ceux avec des écartement de 35 mm (30 LEDS/m), de 16 mm (60 LEDS/m) ou de 7mm (144 LEDS/m).

Il y a aussi différentes qualités de résistance à l'humidité, j'ai pris les plus simples.

Le ruban de 60 LEDS/m me plaisait bien mais le cadre aurait dû mesurer moins de 19 cm sans possibilité de changer (à part couper le ruban 121 fois et souder entre chaque 3 petits fils ... galère). Comme je voulais être un peu libre de tâtonner, j'ai acheté un ruban de 5m avec des LEDS tous les 35 mm avec dans l'idée que je pouvais les plier en accordéon (et c'était finalement une bonne idée).

J'ai créé ma grille de lettre de 21 cm x 21 cm sous Powerpoint, un tableau noir de 121 cases (11 x 11) où j'ai inscrit en blanc chacune des lettres nécessaires à l'écriture de l'heure.

Je voulais d'abord imprimer ce tableau sur du papier calque mais l'encre ne séchait pas et j'en ai mis de partout. j'ai donc imprimé sur papier A4 80g classique et finalement, le contraste est largement suffisant.

Chaque lettre correspondra à un numéro d'ordre du bandeau de LEDS, pour allumer les mots "IL EST", je devrais allumer les LED 1, 2 4, 5 et 6 ... facile !!!

Mots à éclairer pour chaque horaire :

00h00  :  IL EST MINUIT    
00h05  :  IL EST MINUIT CINQ   
00h10  :  IL EST MINUIT DIX   
00h15  :  IL EST MINUIT ET QUART   
00h20  :  IL EST MINUIT VINGT   
00h25  :  IL EST MINUIT VINGT-CINQ   
00h30  :  IL EST MINUIT ET DEMIE   
00h35  :  IL EST UNE HEURE MOINS VINGT-CINQ DU MATIN   
00h40  :  IL EST UNE HEURE MOINS VINGT DU MATIN   
00h45  :  IL EST UNE HEURE MOINS LE QUART DU MATIN   
00h50  :  IL EST UNE HEURE MOINS DIX DU MATIN   
00h55  :  IL EST UNE HEURE MOINS CINQ DU MATIN   
01h00  :  IL EST UNE HEURE DU MATIN   
On reprend la même logique d'incrémentation des minutes   
02h00  :  IL EST DEUX HEURE DU MATIN   
03h00  :  IL EST TROIS HEURE DU MATIN   
04h00  :  IL EST QUATRE HEURE DU MATIN   
05h00  :  IL EST CINQ HEURE DU MATIN   
06h00  :  IL EST SIX HEURE DU MATIN   
07h00  :  IL EST SEPT HEURE DU MATIN   
08h00  :  IL EST HUIT HEURE DU MATIN   
09h00  :  IL EST NEUF HEURE DU MATIN   
10h00  :  IL EST DIX HEURE DU MATIN   
11h00  :  IL EST ONZE HEURE DU MATIN   
11h05  :  IL EST ONZE HEURE CINQ DU MATIN   
11h10  :  IL EST ONZE HEURE DIX DU MATIN   
11h15  :  IL EST ONZE HEURE ET QUART DU MATIN   
11h20  :  IL EST ONZE HEURE VINGT DU MATIN   
11h25  :  IL EST ONZE HEURE VINGT-CINQ DU MATIN   
11h30  :  IL EST ONZE HEURE ET DEMIE DU MATIN   
11h35  :  IL EST MIDI MOINS VINGT-CINQ   
11h40  :  IL EST MIDI MOINS VINGT   
11h45  :  IL EST MIDI MOINS LE QUART   
11h50  :  IL EST MIDI MOINS DIX   
11h55  :  IL EST MIDI MOINS CINQ   
12h00  :  IL EST MIDI    
13h00  :  IL EST UNE HEURE    
14h00  :  IL EST DEUX HEURE    
15h00  :  IL EST TROIS HEURE    
16h00  :  IL EST QUATRE HEURE    
17h00  :  IL EST CINQ HEURE    
18h00  :  IL EST SIX HEURE    
19h00  :  IL EST SEPT HEURE    
20h00  :  IL EST HUIT HEURE DU SOIR   
21h00  :  IL EST NEUF HEURE DU SOIR   
22h00  :  IL EST DIX HEURE DU SOIR   
23h00  :  IL EST ONZE HEURE DU SOIR   
23h05  :  IL EST ONZE HEURE CINQ DU SOIR   
23h10  :  IL EST ONZE HEURE DIX DU SOIR  
23h15  :  IL EST ONZE HEURE ET QUART DU SOIR  
23h20  :  IL EST ONZE HEURE VINGT DU SOIR  
23h25  :  IL EST ONZE HEURE VINGT-CINQ DU SOIR   
23h30  :  IL EST ONZE HEURE ET DEMIE DU SOIR   
23h35  :  IL EST MINUIT MOINS VINGT-CINQ  
23h40  :  IL EST MINUIT MOINS VINGT   
23h45  :  IL EST MINUIT MOINS LE QUART   
23h50  :  IL EST MINUIT MOINS DIX   
23h55  :  IL EST MINUIT MOINS CINQ 
et +1 +2 +3 ou +4 pour indiquer le nombre de minutes à ajouter à l'heure affichée ...

Une fois ma grille papier imprimée, je connaissais l'écartement exact à donner aux LEDS. J'ai pu donc plier le bandeau et le coller sur mon papier plume aux bons endroits. Ne pouvant utiliser le pliage pour passer d'une ligne à l'autre, j'ai coupé la bande toutes les 11 LEDS et patiemment ressoudé les 3 contacts pour chacun des segments (+, - et data).

Cette implantation est économique en soudure mais a été un petit casse-tête pour l'animation de l'écriture puisque l'ordre des led est croissant de gauche à droite pour les lignes impaires mais décroissant de gauche à droite pour les lignes paires.

Lors de mes premiers essais d'éclairage des lettres avec ces diodes, j'ai vu qu'il y avait un champ d'éclairage trop vaste. Des cases sensées être éteintes étaient allumées par des diodes voisines. J'ai donc ajouté une grille réalisée en papier plié en accordéon, collé sur un film transparent. Cela a permis d'isoler précisément chaque lettre, la lecture est maintenant tout à fait agréable.

Avec les 3,5 cm de profondeur du cadre que j'avais trouvé, j'avais largement la place d'empiler la vitre, le film permettant à la glace de devenir une glace sans tain (on voit son reflet et seulement ce qui est éclairé derrière), la grille en papier pour isoler chaque éclairage et la plaque de carton plume supportant les LEDS. Il restait de la place pour embarquer l'électronique mais pas un Arduino Uno, j'ai donc acheté un Arduino Nano exprès pour cette horloge.

Le film "Glace sans tain" trouvé chez Action a été très facile à poser proprement avec leur astuce de brumiser la vitre à l'aide d'un spray (j'ai utilisé un spray d'Evian) juste avant de poser le film, en commençant par un bout et en chassant les bulles à l'aide d'une carte de crédit ... Une fois sec, si on s'est bien appliqué, c'est impeccable !!!

J'ai percé la face avant pour pouvoir y loger une cellule photorésistante afin de connaître la luminosité ambiante et le bas du cadre pour insérer une prise USB femelle qui permet d'alimenter l'ensemble (le 5V de l'USB fait tout fonctionner sans problèmes, j'avais un peu peur, au début, de la consommation des LEDS, mais c'est en fait nickel).

Le cadre était blanc et pas en très bon état, je l'ai enduit, poncé, et peint à la bombe ... tout neuf !

En toute fin, j'ai ajouté un crocher à l'arrière pour suspendre le cadre et deux crochets sur le côté pour pouvoir refermer l'arrière du cadre.

L'Arduino gère donc :

• Deux boutons poussoir (à l'arrière du cadre) pour passer en mode réglage et ajuster l'heure
• Une cellule photorésistante pour connaitre la luminosité ambiante
• Le bandeau de LEDS adressables.
• La carte RTC.

L'Arduino nano est vraiment petit, j'ai pas mal galéré à faire mes soudures, mais, bon, ça tient !

Je demande l'indulgence de tous les développeurs C pour le code qui va suivre. Etant vraiment autodidacte sur le sujet, j'ai probablement codé d'une manière peu orthodoxe, mais, promis, ça fonctionne !!!

#include <virtuabotixRTC.h>
// Horloge temps réel
// SCLK -> 6, I/O -> 7, CE -> 8
// CLK -> 6 , DAT -> 7, Reset -> 8
virtuabotixRTC myRTC(6, 7, 8);


#include <Adafruit_NeoPixel.h>
// Bandeau 121 leds
#define PIN 9          // On connecte le bandeau de LED sur la broche 9
#define NUMPIXELS 121  // On a 121 LEDS sur le bandeau
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);


// Bouton de de réglage de l'horloge
// bouton 1 -> Mode setup heure (en rouge) -> mode setup minutes (en vert) -> Mise à jour RTC et fin
// bouton 2 -> +1 heure ou + 1mn
const int bouton1Pin = 2;
const int bouton2Pin = 4;
int bouton1Etat = 0;
int bouton2Etat = 0;


// Capteur de lumière
int capteur_lum = 0;       // capteur branché sur le port A0
int analog_lum;            // valeur analogique envoyé par le capteur
int intensite = 255;       // Intensité des leds
const int iMax = 255;      // Intensité max si beaucoup de lumière
const int iMin = 20;       // Intensité min si nuit noire
const int lMin = 20;       // Luminosité lue en pleine nuit
const int lMax = 800;      // Luminosité lue en pleine lumière


// Définition des leds à allumer pour chaque valeur trouvée
const int htexte[13][13] = {
  { 39, 38, 37, 36, 35, 34, NULL },                          // MINUIT
  { 50, 51, 52, 61, 60, 59, 58, 57, NULL },                  // UNE HEURE
  { 8, 9, 10, 11, 61, 60, 59, 58, 57, 56, NULL },            // DEUX HEURES
  { 19, 18, 17, 16, 15, 61, 60, 59, 58, 57, 56, NULL },      // TROIS HEURES
  { 23, 24, 25, 26, 27, 28, 61, 60, 59, 58, 57, 56, NULL },  // QUATRE HEURES
  { 45, 46, 47, 48, 61, 60, 59, 58, 57, 56, NULL },          // CINQ HEURES
  { 22, 21, 20, 61, 60, 59, 58, 57, 56, NULL },              // SIX HEURES
  { 15, 14, 13, 12, 61, 60, 59, 58, 57, 56, NULL },          // SEPT HEURES
  { 66, 65, 64, 63, 61, 60, 59, 58, 57, 56, NULL },          // HUIT HEURES
  { 51, 52, 53, 54, 61, 60, 59, 58, 57, 56, NULL },          // NEUF HEURES
  { 42, 41, 40, 61, 60, 59, 58, 57, 56, NULL },              // DIX HEURES
  { 30, 31, 32, 33, 61, 60, 59, 58, 57, 56, NULL },          // ONZE HEURES
  { 44, 43, 42, 41, NULL }                                   // MIDI
};


const int ilEst[6] = { 1, 2, 4, 5, 6, NULL };                                              // IL EST
const int duMatin[8] = { 106, 105, 111, 112, 113, 114, 115, NULL };                        // DU MATIN
const int duSoir[7] = { 106, 105, 103, 102, 101, 100, NULL };                              // DU SOIR
const int m5[5] = { 95, 96, 97, 98, NULL };                                                // CINQ
const int m10[4] = { 110, 109, 108, NULL };                                                // DIX
const int m15[8] = { 72, 73, 82, 81, 80, 79, 78, NULL };                                   // ET QUART
const int m20[6] = { 89, 90, 91, 92, 93, NULL };                                           // VINGT
const int m25[11] = { 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, NULL };                      // VINGT-CINQ
const int m30[8] = { 72, 73, 88, 87, 86, 85, 84, NULL };                                   // ET DEMIE
const int m35[16] = { 67, 68, 69, 70, 71, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, NULL };  // MOINS VINGT-CINQ
const int m40[11] = { 67, 68, 69, 70, 71, 89, 90, 91, 92, 93, NULL };                      // MOINS VINGT
const int m45[13] = { 67, 68, 69, 70, 71, 76, 77, 82, 81, 80, 79, 78, NULL };              // MOINS LE QUART
const int m50[9] = { 67, 68, 69, 70, 71, 110, 109, 108, NULL };                            // MOINS DIX
const int m55[10] = { 67, 68, 69, 70, 71, 95, 96, 97, 98, NULL };                          // MOINS CINQ
const int p1[3] = { 117, 118, NULL };                                                      // +1
const int p2[3] = { 117, 119, NULL };                                                      // +2
const int p3[3] = { 117, 120, NULL };                                                      // +3
const int p4[3] = { 117, 121, NULL };                                                      // +4

byte chaine[NUMPIXELS] = { 0 };
int modeSetup = 0;


// Initialisation des variables du temps
int heure = 0;
int minute = 0;


void setup() {
  Serial.begin(9600);
  pixels.begin();
  pixels.clear();  // Remet tous les pixel à zéro
  pinMode(bouton1Pin, INPUT);
  pinMode(bouton2Pin, INPUT);
}


// Mise à jour de l'état du tableau chaine qui pilotera les leds
void allumeLed(int px[], String texte) {
  Serial.print(texte + " ");
  for (int i = 0; px[i] != NULL; i++) {
    chaine[px[i] - 1] = true;
  }
}


// Délai avec test des boutons
void _delay(unsigned long d) {
  bouton1Etat = 0;
  bouton2Etat = 0;
  unsigned long start = millis();
  while (millis() - start < d) {
    if (digitalRead(bouton1Pin) == HIGH) {
      Serial.println("Bouton 1 Pressé");
      bouton1Etat = 1;
      break;
    }
    if (digitalRead(bouton2Pin) == HIGH) {
      Serial.println("Bouton 2 Pressé");
      bouton2Etat = 1;
      break;
    }
  }
}


void loop() {


  // On lit l'heure
  myRTC.updateTime();
  int heureRTC = myRTC.hours;
  int minuteRTC = myRTC.minutes;


  // On lit la luminosité
  analog_lum = analogRead(capteur_lum); 
  // On calcule l'intensité des leds en fonction de la luminosité extérieure  
  long c1 = analog_lum  - lMin;
  long c2 = iMax - iMin;
  long c3 = lMax - lMin;
  intensite = round(c1 * c2 / c3);  
  if(intensite < iMin ) { intensite = iMin; }
  if(intensite > iMax ) { intensite = iMax; }

  Serial.print("Valeur luminosité = ");  
  Serial.print(analog_lum); 
  Serial.print(" - Intensité = ");
  Serial.println(intensite); 
  
  // Pas de transition si on est en mode setup
  if (modeSetup == 0) {
    heure = heureRTC;
    minute = minuteRTC;
    // On fait disparaitre le texte en fade
    for (int lum = intensite; lum >= 0; lum = lum - 1) {
      for (int i = NUMPIXELS; i >= 0; i--) {
        if (chaine[i]) {
          pixels.setPixelColor((i), pixels.Color(lum, lum, lum));      
        }
      }
      pixels.show();
      // Le délai est calculé pour compenser le temps de la boucle (entre 0 et 12)
      delay((iMax-intensite)/iMin);
    }
    _delay(1000);
    // Toutes les heures, on met une animation
    if(minuteRTC==0) {
      for(int j = 0; j < 90; j++) {
        for (int i = 0; i < NUMPIXELS; i++) {
          pixels.setPixelColor((i), pixels.Color(random(256), random(256), random(256)));          
        }    
        pixels.show();
      }
    }
  }
  // On remet le tableau de pixels à 0
  for (int i = 0; i < NUMPIXELS; i++) {
    chaine[i] = false;
  }
  // On remet toutes les LED à l'état éteint
  pixels.clear();


  Serial.print(heure);
  Serial.print(":");
  Serial.println(minute);


  // Début de l'affichage
  allumeLed(ilEst, "IL EST");


  int heureaff = heure;
  // Passé 30 minutes, On ajoute une heure et les minutes passent en "moins xxx".
  if (minute >= 35) {
    heureaff++;
  }
  // Passé midi, on reprend le texte des heures du matin
  if (heureaff > 12) {
    heureaff = heureaff - 12;
  }
  // Traitement du cas de minuit
  if (heure == 23 && heureaff == 12) { heureaff = 0; }


  Serial.print(heureaff);
  Serial.print(":");
  Serial.println(minute);


  allumeLed(htexte[heureaff], String("") + heureaff + " HEURES");


  // On traite les minutes de 5 en 5
  if (minute >= 5 and minute < 10) { allumeLed(m5, "CINQ"); }
  if (minute >= 10 and minute < 15) { allumeLed(m10, "DIX"); }
  if (minute >= 15 and minute < 20) { allumeLed(m15, "ET QUART"); }
  if (minute >= 20 and minute < 25) { allumeLed(m20, "VINGT"); }
  if (minute >= 25 and minute < 30) { allumeLed(m25, "VINGT-CINQ"); }
  if (minute >= 30 and minute < 35) { allumeLed(m30, "ET DEMIE"); }
  if (minute >= 35 and minute < 40) { allumeLed(m35, "MOINS VINGT-CINQ"); }
  if (minute >= 40 and minute < 45) { allumeLed(m40, "MOINS VINGT"); }
  if (minute >= 45 and minute < 50) { allumeLed(m45, "MOINS LE QUART"); }
  if (minute >= 50 and minute < 55) { allumeLed(m50, "MOINS DIX"); }
  if (minute >= 55) { allumeLed(m55, "MOINS CINQ"); }


  if (heure > 0 and heure < 11) { allumeLed(duMatin, "DU MATIN"); }
  if (heure >= 20 and heure <= 23 and heureaff != 0) { allumeLed(duSoir, "DU SOIR"); }


  int plus = minute % 5;
  if (plus == 1) { allumeLed(p1, "PLUS UN"); }
  if (plus == 2) { allumeLed(p2, "PLUS DEUX"); }
  if (plus == 3) { allumeLed(p3, "PLUS TROIS"); }
  if (plus == 4) { allumeLed(p4, "PLUS QUATRE"); }
  Serial.println("");


  if (modeSetup == 0) {
    // On éclaire tous les bits à 1
    for (int i = 0; i < NUMPIXELS; i++) {
      // Une ligne sur deux (ligne impaire), on traite l'ordre à l'envers
      int j = i;
      if ((i - (i % 11)) % 2 != 0) {
        j = (2 * (i - (i % 11))) + 10 - i;
      }      
      if (chaine[j]) {
        pixels.setPixelColor((j), pixels.Color(intensite, intensite, intensite));
        pixels.show();
        delay(15);
      }
    }
  } else {
    for (int i = 0; i < NUMPIXELS; i++) {
      if (chaine[i]) {
        if (modeSetup == 1) {
          pixels.setPixelColor(i, pixels.Color(255, 0, 0));
        } else {
          pixels.setPixelColor(i, pixels.Color(0, 255, 0));
        }
      }
    }
    pixels.show();
  }
  Serial.println("");


  _delay(60000);


  // Si on a appuyé sur le bouton SETUP on bascule en mode setup heure puis setup minutes
  if (bouton1Etat == 1) {
    if (modeSetup == 0) {
      Serial.println("On passe en mode Setup Heure");
      modeSetup = 1;
    } else {
      if (modeSetup == 1) {
        Serial.println("On passe en mode Setup Minute");
        modeSetup = 2;
      } else {
        Serial.println("On sort du mode Setup et on met à jour l'horloge RTC");
        // Format date:
        // secondes, minutes, heures, jour de la semaine, jour du mois, mois, année
        myRTC.setDS1302Time(00, minute, heure, 1, 01, 01, 2000);
        modeSetup = 0;
      }
    }
    delay(500);
  }
  // Si on est en mode setup et qu'on appuie sur le bouton SET, on augmente le temps de 1MN
  if (bouton2Etat == 1) {
    if (modeSetup == 1) {
      heure++;
      delay(300);
    }
    if (modeSetup == 2) {
      minute++;
      delay(50);
    }
    if (minute > 59) {
      minute = 0;
      heure++;
    }
    if (heure > 23) {
      heure = 0;
    }
  }
}

J'ai chargé deux bibliothèques :

• Adafruit_NeoPixel.h qui permet de facilement gérer un bandeau de LEDS adressables :

Pour donner une couleur et une intensité à une LED : pixels.setPixelColor((NumeroDeLaLED), pixels.Color(IntensiteRouge, IntensiteVerte, IntensiteBleue));      

Pour envoyer les données au bandeau pour traitement : pixels.show();

Pour éteindre toutes les LEDS : pixels.clear();

• virtuabotixRTC.h qui permet de dialoguer avec le petit module RTC (Real Time Clock), principalement lire et écrire l'heure (cela permet de garder la bonne heure, même si on débranche l'horloge).

Au début, le programme ne faisait qu'afficher l'heure, puis je me suis dit qu'il serait mieux de pouvoir effectuer les réglages sans avoir à connecter son PC à l'Arduino, j'ai donc ajouté le gestion de 2 boutons, un pour passer dans différents modes de paramétrage, l'autre pour mettre à jour les valeurs.

• On appuie sur le bouton 1, on passe en mode "Mise à jour Heure", les caractères passent en rouge. Chaque appui sur le bouton 2 fait avancer l'horloge d'une heure.
• On appuie à nouveau sur le bouton 1, on passe en mode "Mise à jour Minutes", les caractères passent en vert. Chaque appui sur le bouton 2 fait avancer l'horloge d'une minute. On peut garder le doigt sur le bouton pour avancer rapidement.
• On appuie encore sur le bouton 1, les caractères repassent en blanc, l'heure sélectionnée est mise à jour dans le module RTC.

A l'utilisation, l'éclairage était satisfaisant en journée mais trop fort la nuit. J'ai donc ajouté sur le devant du cadre une cellule photoélectrique dont la résistance varie en fonction de l'éclairage. Empiriquement, j'ai trouvé que la résistance lue en pleine nuit me donnait une valeur de 20 et de 800 en pleine lumière, j'ai répercuté proportionnellement ces variations sur l'intensité des LEDS du bandeau avec des valeurs allant de 20 à 255.

Dans mes premières versions du programme, j'ai inséré plein d'animations, mais à l'utilisation également, j'ai trouvé que ça attire l'œil pour rien, j'ai donc beaucoup assagi l'affichage (sauf une petite explosion rapide de couleurs, à chaque nouvelle heure :-) )

J'ai laissé toutes mes traces vers la console serie avec Serial.print(""); mais on peut bien sûr les enlever.

C'est mon premier projet posté sur instructables, j'espère que je n'ai pas été trop verbeux ou trop long et que je vous ai donné l'envie de faire votre propre horloge textuelle ...

Pascal Siméon