Créez une table de nuit électronique avec Arduino !

Créez une table de nuit électronique avec Arduino !

La base de ce projet est une fontaine à eau modulé avec une table de nuit électronique.

J’avais donc envie de réaliser une nouvelle fontaine à eau avec mes connaissances en électronique !
Et comme l’électronique et l’eau sont faits pour aller ensemble, j’ai eu l’idée d’une table de nuit électronique. Logique ! 🙂

Ce tutoriel a pour but de rendre l’objet décoratif (la fontaine) utile (table de nuit).
C’est donc un meuble high-tech et joli.

Il a donc fallu faire une liste de “gadget” qui étaient les bienvenus sur ce meuble. Première chose, la pompe à eau, et ensuite qui dit mon projet by Massden dit lumières, lumières et lumières !

Quelles autres fonctionnalités pratiques attend-on d’une table de nuit électronique ? Au moins donner l’heure ! Et avec tout ça, si en plus ça pouvait donner la température…

Allez c’est parti pour la réalisation de la table de nuit électronique !

  1. le capteur de température



    Ce capteur, en plus d’être très petit, est très efficace ! En effet, il peut être branché avec seulement deux fils à votre carte Arduino et lui transmet directement la température ! Pas besoin de calcul et de conversion dans votre code. Donc pas de problème de réglage ! :)



    Il vous faut seulement deux librairies :



    - OneWire

    - DallasTemperature



    Maintenant que vous avez tout en main, reliez le capteur à votre carte Arduino comme suit :
  2. Les broches 1 et 3 peuvent être reliées à la masse, la broche 2 se branche directement sur l’entrée de l’Arduino, avec une résistance entre cette entrée et la tension 5V.



    Le code qui permet de relever la température via le moniteur série :




    #include
    #include

    // Broche 2 (DATA) du capteur sur l'entrée 2 de l'arduino

    #define ONE_WIRE_BUS 2
    OneWire oneWire(ONE_WIRE_BUS); // Initialisation de oneWire
    DallasTemperature sensors(&oneWire); // Initialisation de Dallas avec oneWire
    void setup(void)
    {

    Serial.begin(9600); // Initialisation du port série
    Serial.println("Test du capteur de temperature"); // Affiche un texte de démarage
    sensors.begin(); // Initialisation de lecture capteur
    }

    void loop(void)
    {
    Serial.print(" Demande la temperature...");
    sensors.requestTemperatures(); // Envoi la commande pour obtenir la température
    Serial.println("REUSSI !");
    Serial.print("La temperature est de : ");
    Serial.println(sensors.getTempCByIndex(0),1); // Affiche la température reçu.

    delay(1000);


    Nous pouvons passer à la suite !
  3. Le module d’horloge



    C’est une petite carte avec une pile bouton qui permet de garder en mémoire le temps qui passe quand on éteint tout. Elle communique en I2C et peut donc fonctionner avec bon nombre de périphériques programmables.



    Cette fois, il nous faut 4 fils ! Un pour l’alimentation 5V, l’autre pour la masse, et les deux autres pour SCL (clock) et SDA (data).
  4. La librairie utilisée est « Wire »(inclus avec l’IDE). Mais avant de pouvoir lire l’heure, il faut paramétrer le module pour lui indiquer la bonne date et heure (à ne faire qu’une seule fois, évidemment).



    Il suffit pour cela de lancer ce programme sur votre Arduino :




    #include
    #include
    #include // Arduino LCD library
    #include
    #include
    #include

    // pin definitions
    #define sd_cs 7
    #define lcd_cs 10
    #define dc 9
    #define rst 8
    #define ONE_WIRE_BUS 2 // data DALLAS18B20 => pin2

    TFT TFTscreen = TFT(lcd_cs, dc, rst); // déclaration de l'écran
    OneWire oneWire(ONE_WIRE_BUS);
    DallasTemperature sensors(&oneWire);

    void setup() {

    // Initialisation du LCD
    TFTscreen.begin();
    TFTscreen.background(0, 0, 0); // écran noir

    Wire.begin();
    sensors.begin();

    } // Fin setup

    void loop() {

    // HEURE ET DATE
    //demande l'heure

    Wire.beginTransmission(0x68);
    Wire.write(0);
    Wire.endTransmission();
    Wire.requestFrom(0x68, 7);

    byte secs = Wire.read();
    byte mins = Wire.read();
    byte hrs = Wire.read();
    byte jour = Wire.read();
    byte date = Wire.read();
    byte mois = Wire.read();
    byte annee = Wire.read();

    //affichage heure
    TFTscreen.background(0, 0, 0);
    TFTscreen.stroke(255,255,255); // couleur texte : blanc
    TFTscreen.text("Heure ",2,10);

    if(hrs < 10) TFTscreen.print("0");
    TFTscreen.print(hrs,HEX);
    TFTscreen.print(":");

    if(mins < 10) TFTscreen.print("0");
    TFTscreen.print(mins,HEX);
    TFTscreen.print(":");

    if(secs < 10) TFTscreen.print("0");
    TFTscreen.println(secs,HEX);
    TFTscreen.print("Date ");

    if(date <10) TFTscreen.print("0");
    TFTscreen.print(date,HEX);
    TFTscreen.print("-");

    if(mois < 10) TFTscreen.print("0");
    TFTscreen.print(mois,HEX);
    TFTscreen.print("-");
    TFTscreen.print("20");

    if(annee < 10) TFTscreen.print("0");
    TFTscreen.println(annee, HEX);
    TFTscreen.println();

    delay(1000);

    // TEMPERATURE
    sensors.requestTemperatures();
    TFTscreen.stroke(255,255,10); //couleur du texte
    TFTscreen.fill(0,0,255);
    TFTscreen.rect(75,50,50,20); // rectangle en X:70/Y:70 de taille 50x20
    TFTscreen.setTextSize(1);
    TFTscreen.text("T: ",80,58);
    TFTscreen.print(sensors.getTempCByIndex(0),1);

    delay(1000);

    } // fin loop
  5. Puis dans le moniteur série d’entrer « T(sec)(min)(heure)(joursemaine)(jourmois)(mois)(année) »



    Par exemple si nous sommes le 24 décembre à 23h50 vous allez marquer « T0050236241216 » (00 secondes 50 min 23 heure 6e jour de la semaine le 24 du 12e mois en 2016.).



    Maintenant que le module est prêt, testons le ! On ne touche à rien, on change juste le sketch de l’Arduino, par celui-ci :




    #include "Wire.h"
    void setup(){
    Wire.begin();
    Serial.begin(9600);

    }

    void loop(){

    //Initialisation du pointeur
    Wire.beginTransmission(0x68);
    Wire.write(0);
    Wire.endTransmission();

    //Lecture des 7 octets contenant date et heure
    Wire.requestFrom(0x68, 7); //On demande 7 octets à l'adresse 0x68 (voir plus haut)
    byte secs = Wire.read(); //Chaque octet reçu est stocké dans une variable qui lui est propre
    byte mins = Wire.read(); //Dans l'ordre, on reçoit les secondes, les minutes, les heures, etc...
    byte hrs = Wire.read();
    byte jour = Wire.read();
    byte date = Wire.read();
    byte mois = Wire.read();
    byte annee = Wire.read();

    //Affichage des données
    Serial.print("Heure ");
    if(hrs < 10) Serial.print("0");
    Serial.print(hrs,HEX);
    Serial.print(":");

    if(mins < 10) Serial.print("0");
    Serial.print(mins,HEX);
    Serial.print(":");

    if(secs < 10) Serial.print("0");
    Serial.println(secs,HEX);
    Serial.print("Date ");

    if(date <10) Serial.print("0");
    Serial.print(date,HEX);
    Serial.print("-");

    if(mois < 10) Serial.print("0");
    Serial.print(mois,HEX);
    Serial.print("-");
    Serial.print("20");

    if(annee < 10) Serial.print("0");
    Serial.println(annee, HEX);
    Serial.println();

    delay(1000);
  6. L’écran TFT



    Maintenant, apprenons à afficher quelque chose sur un écran autre que notre ordinateur. Cette fois, il y a un peu plus de fils… 10 ! Oui, dix fils, que nous allons brancher comme suit :
  7. Commençons par choisir un fond de couleur et affichons un texte d’une autre couleur !




    #include

    #include

    #include // Arduino LCD library

    // pin definitions
    #define sd_cs 7
    #define lcd_cs 10
    #define dc 9
    #define rst 8
    #define ONE_WIRE_BUS 2 // data DALLAS18B20 => pin2

    TFT TFTscreen = TFT(lcd_cs, dc, rst); // déclaration de l'écran
    OneWire oneWire(ONE_WIRE_BUS);
    DallasTemperature sensors(&oneWire);

    void setup() {

    // Initialisation du LCD
    TFTscreen.begin();
    TFTscreen.background(118, 0, 255); // écran violet
    TFTscreen.stroke(255, 114, 0); // couleur du texte : orange
    TFTscreen.println();
    TFTscreen.println(F("CECI est un message"));
    TFTscreen.stroke(0, 168, 0); // couleur du texte : vert
    TFTscreen.text("Et ceci en est un autre !", 20,58); // Les chiffres indique la positon sur l'écran

    } // Fin setup

    void loop() {

    } // fin loop
  8. Bien, maintenant on fusionne tout ce qu’on a vu jusque-là ! Affichons la température et l’heure sur cet écran !





    #include

    #include

    #include // Arduino LCD library

    #include

    #include

    #include

    // pin definitions

    #define sd_cs 7

    #define lcd_cs 10

    #define dc 9

    #define rst 8

    #define ONE_WIRE_BUS 2 // data DALLAS18B20 => pin2

    TFT TFTscreen = TFT(lcd_cs, dc, rst); // déclaration de l'écran

    OneWire oneWire(ONE_WIRE_BUS);

    DallasTemperature sensors(&oneWire);

    void setup() {



    // Initialisation du LCD

    TFTscreen.begin();

    TFTscreen.background(0, 0, 0); // écran noir

    Wire.begin();

    sensors.begin();



    } // Fin setup

    void loop() {

    // HEURE ET DATE

    //demande l'heure

    Wire.beginTransmission(0x68);

    Wire.write(0);

    Wire.endTransmission();

    Wire.requestFrom(0x68, 7);

    byte secs = Wire.read();

    byte mins = Wire.read();

    byte hrs = Wire.read();

    byte jour = Wire.read();

    byte date = Wire.read();

    byte mois = Wire.read();

    byte annee = Wire.read();

    //affichage heure

    TFTscreen.background(0, 0, 0);

    TFTscreen.stroke(255,255,255); // couleur texte : blanc

    TFTscreen.text("Heure ",2,10);

    if(hrs < 10) TFTscreen.print("0");

    TFTscreen.print(hrs,HEX);

    TFTscreen.print(":");

    if(mins < 10) TFTscreen.print("0");

    TFTscreen.print(mins,HEX);

    TFTscreen.print(":");

    if(secs < 10) TFTscreen.print("0");

    TFTscreen.println(secs,HEX);

    TFTscreen.print("Date ");

    if(date <10) TFTscreen.print("0");

    TFTscreen.print(date,HEX);

    TFTscreen.print("-");

    if(mois < 10) TFTscreen.print("0");

    TFTscreen.print(mois,HEX);

    TFTscreen.print("-");

    TFTscreen.print("20");

    if(annee < 10) TFTscreen.print("0");

    TFTscreen.println(annee, HEX);

    TFTscreen.println();

    delay(1000);

    // TEMPERATURE

    sensors.requestTemperatures();

    TFTscreen.stroke(255,255,10); //couleur du texte

    TFTscreen.fill(0,0,255);

    TFTscreen.rect(75,50,50,20); // rectangle en X:70/Y:70 de taille 50x20

    TFTscreen.setTextSize(1);

    TFTscreen.text("T: ",80,58);

    TFTscreen.print(sensors.getTempCByIndex(0),1);

    delay(1000);

    } // fin loop
  9. Nous y voilà, nous avons un bel écran qui affiche ce que nous lui avons demandé ! C’est fini….



    Non bien sûr que non, cet affichage est très archaïque ! Nous avons choisi un écran qui est capable d’afficher plus de 2 couleurs, qui possède un slot pour carte micro SD… alors servons-nous en !
  10. La programmation de l’écran



    J’ai décomposé l’affichage avec un fond graphique et 4 chiffres pour afficher l’heure (HH : MM)


    Ensuite, libre à vous d’ajouter la date, les secondes, etc… Ces données sont récoltées par votre Arduino.



    Ouvrons donc notre petit logiciel de graphisme et créons un document à notre goût, aux dimensions de l’écran : 160×128 px. Voilà mon interface :
  11. Nous devons ensuite séparer les différents éléments au format bitmap (le fond et les chiffres).



    On exporte donc le fond sous le nom « background.bmp ». Puis chaque chiffre isolé (recadré ici au format 36×51 px ).
  12. Placez ces 11 images sur la carte µSD, fraîchement formatée.



    Le fonctionnement du code est très simple. Indiquez quelle image doit s’afficher à partir de quelle position, en donnant les coordonnées du premier pixel (en haut à gauche de l’image).



    Par exemple, le fond doit s’afficher à partir de 0-0. Il faut alors relever la position de chaque digit.



    Pour cela, il suffit d’ouvrir l’onglet « informations » sur Photoshop et ça vous indique la position de votre curseur sur l’image.
  13. 3-72 pour le premier, 41-72 puis 84-72 et enfin 121-72.



    Un petit problème se pose ici (bah oui, sinon ce ne serait pas drôle !).



    Le module renvoie l’heure sous la forme hexadécimale. C’est-à-dire, que par exemple pour 14h53, les variables seront sous la forme hrs = 20 (14 en hexa) et mins = 83 (53 en hexa).



    Donc si on décide d’afficher directement les valeurs, nous avons 20h83. Avec le variable affichage : TFTscreen.print(hrs, HEX) ; on précise que la valeur doit être affichée en hexa.



    Or pour afficher les chiffres d’un nombre un par un, nous avons besoin de faire quelques opérations (pour récupérer le chiffre des dizaines et des unités).


    Il faut alors commencer par convertir la valeur Hexa en Décimal.



    Pour ça, il faut procéder par « dizaine » mais en « seizaine » (hexa = base seize).
  14. Par exemple, pour 53 en hexa cela nous donne 83 en décimal, on retire 30 et ça nous donne 53, en décimal.



    Pour récupérer le premier chiffre (dizaine) il suffit de diviser par 10 (division entière en programmation) et on récupère le 5.




    byte dizaine = 53/10 ; // 53/10 = 5
  15. Puis pour les unités , on utilise le module :




    Byte unite = 53%10 ; // 53%10 = 3.
  16. Plus qu’à généraliser tout ça !




    //demande l'heure
    Wire.beginTransmission(0x68); // 0x68 est l'adresse I2C du module heure
    Wire.write(0);
    Wire.endTransmission();
    Wire.requestFrom(0x68, 7);
    byte secs = Wire.read(); // reception des secondes
    byte mins = Wire.read(); // minutes
    byte hrs = Wire.read(); // heures
    byte jour = Wire.read(); // jour de la semaine
    byte date = Wire.read(); // date
    byte mois = Wire.read(); // mois
    byte annee = Wire.read(); // année
    //Convertion des valeurs HEX en DEC
    if (mins > 15 && mins 31 && mins 47 && mins 63 && mins 79 ) mins = mins-30;

    if (hrs > 15 && hrs 31 && hrs 47 && hrs 63 && hrs 79 ) hrs = hrs-30;

    // TFTscreen.stroke(255,255,255); // couleur texte : blanc
    // TFTscreen.text("Heure ",2,10);
    byte dhrs = hrs/10; // recupération dizaine des heures
    byte uhrs = hrs%10; // récupération unité des heures
    byte dmins = mins/10; // récupération dizaine des minutes
    byte umins = mins%10; // récupération unité des minutes
  17. Assemblons tout ensemble pour avoir notre programme final :




    #include
    #include // Librairie lecture carte SD
    #include // Librairie écran LCD
    #include
    #include
    #include // Librairie capteur température

    // pin definitions
    #define sd_cs 4
    #define lcd_cs 10
    #define dc 9
    #define rst 8

    #define ONE_WIRE_BUS 2 // data DALLAS18B20 => pin2

    TFT TFTscreen = TFT(lcd_cs, dc, rst); // déclaration de l'écran
    OneWire oneWire(ONE_WIRE_BUS); // déclaration du bus OneWire
    DallasTemperature sensors(&oneWire); // Déclaration de OneWire pour la librairie Dallas

    // Variable des images à afficher
    PImage backg; // background
    PImage d0; // Digit 0, etc.
    PImage d1;
    PImage d2;
    PImage d3;
    PImage d4;
    PImage d5;
    PImage d6;
    PImage d7;
    PImage d8;
    PImage d9;


    void setup() {
    Wire.begin();
    sensors.begin();

    // Initialisation du LCD
    TFTscreen.begin();
    TFTscreen.background(0, 0, 0); // écran noir

    TFTscreen.begin();
    delay(100);

    // chargement des images en mémoire
    backg = TFTscreen.loadImage("backh.bmp");
    d0 = TFTscreen.loadImage("0.bmp");
    d1 = TFTscreen.loadImage("1.bmp");
    d2 = TFTscreen.loadImage("2.bmp");
    d3 = TFTscreen.loadImage("3.bmp");
    d4 = TFTscreen.loadImage("4.bmp");
    d5 = TFTscreen.loadImage("5.bmp");
    d6 = TFTscreen.loadImage("6.bmp");
    d7 = TFTscreen.loadImage("7.bmp");
    d8 = TFTscreen.loadImage("8.bmp");
    d9 = TFTscreen.loadImage("9.bmp");
    delay(500);

    // Afficher l'image de fond
    TFTscreen.image(backg, 0, 0);
    delay(500);


    } // Fin setup
    void loop() {
    //--------- HEURE ET DATE ----------//
    //demande l'heure
    Wire.beginTransmission(0x68); // 0x68 est l'adresse I2C du module heure
    Wire.write(0);
    Wire.endTransmission();
    Wire.requestFrom(0x68, 7);
    byte secs = Wire.read(); // reception des secondes
    byte mins = Wire.read(); // minutes
    byte hrs = Wire.read(); // heures
    byte jour = Wire.read(); // jour de la semaine
    byte date = Wire.read(); // date
    byte mois = Wire.read(); // mois
    byte annee = Wire.read(); // année
    //Convertion des valeurs HEX en DEC
    if (mins > 15 && mins 31 && mins 47 && mins 63 && mins 79 ) mins = mins-30;

    if (hrs > 15 && hrs 31 && hrs 47 && hrs 63 && hrs 79 ) hrs = hrs-30;

    // TFTscreen.stroke(255,255,255); // couleur texte : blanc
    // TFTscreen.text("Heure ",2,10);
    byte dhrs = hrs/10; // recupération dizaine des heures
    byte uhrs = hrs%10; // récupération unité des heures
    byte dmins = mins/10; // récupération dizaine des minutes
    byte umins = mins%10; // récupération unité des minutes

    // affichage dizaine des heures
    switch (dhrs)
    {
    case 0:
    TFTscreen.image(d0, 3, 72);
    break;
    case 1:
    TFTscreen.image(d1, 3, 72);
    break;
    case 2:
    TFTscreen.image(d2, 3, 72);
    break;
    case 3:
    TFTscreen.image(d3, 3, 72);
    break;
    default:
    break;
    }
    // affichage unité des heures
    switch (uhrs)
    {
    case 0:
    TFTscreen.image(d0, 41, 72);
    break;
    case 1:
    TFTscreen.image(d1, 41, 72);
    break;
    case 2:
    TFTscreen.image(d2, 41, 72);
    break;
    case 3:
    TFTscreen.image(d3, 41, 72);
    break;
    case 4:
    TFTscreen.image(d4, 41, 72);
    break;
    case 5:
    TFTscreen.image(d5, 41, 72);
    break;
    case 6:
    TFTscreen.image(d6, 41, 72);
    break;
    case 7:
    TFTscreen.image(d7, 41, 72);
    break;
    case 8:
    TFTscreen.image(d8, 41, 72);
    break;
    case 9:
    TFTscreen.image(d9, 41, 72);
    break;
    default:
    break;
    }
    //affichage dizaine des heures
    switch (dmins)
    {
    case 0:
    TFTscreen.image(d0, 84, 72);
    break;
    case 1:
    TFTscreen.image(d1, 84, 72);
    break;
    case 2:
    TFTscreen.image(d2, 84, 72);
    break;
    case 3:
    TFTscreen.image(d3, 84, 72);
    break;
    case 4:
    TFTscreen.image(d4, 84, 72);
    break;
    case 5:
    TFTscreen.image(d5, 84, 72);
    break;
    default:
    break;
    }
    // affichage unité des heures
    switch (umins)
    {
    case 0:
    TFTscreen.image(d0, 121, 72);
    break;
    case 1:
    TFTscreen.image(d1, 121, 72);
    break;
    case 2:
    TFTscreen.image(d2, 121, 72);
    break;
    case 3:
    TFTscreen.image(d3, 121, 72);
    break;
    case 4:
    TFTscreen.image(d4, 121, 72);
    break;
    case 5:
    TFTscreen.image(d5, 121, 72);
    break;
    case 6:
    TFTscreen.image(d6, 121, 72);
    break;
    case 7:
    TFTscreen.image(d7, 121, 72);
    break;
    case 8:
    TFTscreen.image(d8, 121, 72);
    break;
    case 9:
    TFTscreen.image(d9, 121, 72);
    break;
    default:
    break;
    }

    //---------- TEMPERATURE ----------//
    sensors.requestTemperatures();
    TFTscreen.stroke(0,0,0); //couleur du texte (Noir)
    TFTscreen.noStroke();
    TFTscreen.fill(230,230,230);
    TFTscreen.rect(65,0,50,10); // rectangle en X:70/Y:70 de taille 50x20
    TFTscreen.stroke(0,0,0);
    TFTscreen.setTextSize(1);
    TFTscreen.text("T: ",68,2);
    TFTscreen.print(sensors.getTempCByIndex(0),1);
    delay(200);
    } // fin loop


  18. #include

    #include // Librairie lecture carte SD

    #include // Librairie écran LCD

    #include

    #include

    #include // Librairie capteur température



    // pin definitions

    #define sd_cs 4

    #define lcd_cs 10

    #define dc 9

    #define rst 8



    #define ONE_WIRE_BUS 2 // data DALLAS18B20 => pin2



    TFT TFTscreen = TFT(lcd_cs, dc, rst); // déclaration de l'écran

    OneWire oneWire(ONE_WIRE_BUS); // déclaration du bus OneWire

    DallasTemperature sensors(&oneWire); // Déclaration de OneWire pour la librairie Dallas



    // Variable des images à afficher

    PImage backg; // background

    PImage d0; // Digit 0, etc.

    PImage d1;

    PImage d2;

    PImage d3;

    PImage d4;

    PImage d5;

    PImage d6;

    PImage d7;

    PImage d8;

    PImage d9;





    void setup() {

    Wire.begin();

    sensors.begin();



    // Initialisation du LCD

    TFTscreen.begin();

    TFTscreen.background(0, 0, 0); // écran noir



    TFTscreen.begin();

    delay(100);



    // chargement des images en mémoire

    backg = TFTscreen.loadImage("backh.bmp");

    d0 = TFTscreen.loadImage("0.bmp");

    d1 = TFTscreen.loadImage("1.bmp");

    d2 = TFTscreen.loadImage("2.bmp");

    d3 = TFTscreen.loadImage("3.bmp");

    d4 = TFTscreen.loadImage("4.bmp");

    d5 = TFTscreen.loadImage("5.bmp");

    d6 = TFTscreen.loadImage("6.bmp");

    d7 = TFTscreen.loadImage("7.bmp");

    d8 = TFTscreen.loadImage("8.bmp");

    d9 = TFTscreen.loadImage("9.bmp");

    delay(500);



    // Afficher l'image de fond

    TFTscreen.image(backg, 0, 0);

    delay(500);





    } // Fin setup

    void loop() {

    //--------- HEURE ET DATE ----------//

    //demande l'heure

    Wire.beginTransmission(0x68); // 0x68 est l'adresse I2C du module heure

    Wire.write(0);

    Wire.endTransmission();

    Wire.requestFrom(0x68, 7);

    byte secs = Wire.read(); // reception des secondes

    byte mins = Wire.read(); // minutes

    byte hrs = Wire.read(); // heures

    byte jour = Wire.read(); // jour de la semaine

    byte date = Wire.read(); // date

    byte mois = Wire.read(); // mois

    byte annee = Wire.read(); // année

    //Convertion des valeurs HEX en DEC

    if (mins > 15 && mins 31 && mins 47 && mins 63 && mins 79 ) mins = mins-30;



    if (hrs > 15 && hrs 31 && hrs 47 && hrs 63 && hrs 79 ) hrs = hrs-30;



    // TFTscreen.stroke(255,255,255); // couleur texte : blanc

    // TFTscreen.text("Heure ",2,10);

    byte dhrs = hrs/10; // recupération dizaine des heures

    byte uhrs = hrs%10; // récupération unité des heures

    byte dmins = mins/10; // récupération dizaine des minutes

    byte umins = mins%10; // récupération unité des minutes



    // affichage dizaine des heures

    switch (dhrs)

    {

    case 0:

    TFTscreen.image(d0, 3, 72);

    break;

    case 1:

    TFTscreen.image(d1, 3, 72);

    break;

    case 2:

    TFTscreen.image(d2, 3, 72);

    break;

    case 3:

    TFTscreen.image(d3, 3, 72);

    break;

    default:

    break;

    }

    // affichage unité des heures

    switch (uhrs)

    {

    case 0:

    TFTscreen.image(d0, 41, 72);

    break;

    case 1:

    TFTscreen.image(d1, 41, 72);

    break;

    case 2:

    TFTscreen.image(d2, 41, 72);

    break;

    case 3:

    TFTscreen.image(d3, 41, 72);

    break;

    case 4:

    TFTscreen.image(d4, 41, 72);

    break;

    case 5:

    TFTscreen.image(d5, 41, 72);

    break;

    case 6:

    TFTscreen.image(d6, 41, 72);

    break;

    case 7:

    TFTscreen.image(d7, 41, 72);

    break;

    case 8:

    TFTscreen.image(d8, 41, 72);

    break;

    case 9:

    TFTscreen.image(d9, 41, 72);

    break;

    default:

    break;

    }

    //affichage dizaine des heures

    switch (dmins)

    {

    case 0:

    TFTscreen.image(d0, 84, 72);

    break;

    case 1:

    TFTscreen.image(d1, 84, 72);

    break;

    case 2:

    TFTscreen.image(d2, 84, 72);

    break;

    case 3:

    TFTscreen.image(d3, 84, 72);

    break;

    case 4:

    TFTscreen.image(d4, 84, 72);

    break;

    case 5:

    TFTscreen.image(d5, 84, 72);

    break;

    default:

    break;

    }

    // affichage unité des heures

    switch (umins)

    {

    case 0:
    TFTscreen.image(d0, 121, 72);

    break;

    case 1:

    TFTscreen.image(d1, 121, 72);

    break;

    case 2:

    TFTscreen.image(d2, 121, 72);

    break;

    case 3:

    TFTscreen.image(d3, 121, 72);

    break;

    case 4:

    TFTscreen.image(d4, 121, 72);

    break;

    case 5:

    TFTscreen.image(d5, 121, 72);

    break;

    case 6:

    TFTscreen.image(d6, 121, 72);

    break;

    case 7:

    TFTscreen.image(d7, 121, 72);

    break;

    case 8:

    TFTscreen.image(d8, 121, 72);

    break;

    case 9:

    TFTscreen.image(d9, 121, 72);

    break;

    default:

    break;

    }



    //---------- TEMPERATURE ----------//

    sensors.requestTemperatures();

    TFTscreen.stroke(0,0,0); //couleur du texte (Noir)

    TFTscreen.noStroke();

    TFTscreen.fill(230,230,230);

    TFTscreen.rect(65,0,50,10); // rectangle en X:70/Y:70 de taille 50x20

    TFTscreen.stroke(0,0,0);

    TFTscreen.setTextSize(1);

    TFTscreen.text("T: ",68,2);

    TFTscreen.print(sensors.getTempCByIndex(0),1);

    delay(200);

    } // fin loop



  19. Maintenant notre carte Arduino est prête, nous pouvons passer à la suite, c’est-à-dire l’installation dans notre table !
  20. La table de nuit



    C’est un petit meuble à roulette qui traînait dans ma chambre. Il est un peu haut pour une simple table de nuit, mais est adapté pour ce que l’on souhaite en faire.
  21. Le point de départ, c’est l’ouverture sur le dessus, aux dimensions du carreau pour pouvoir voir l’intérieur.
  22. Créez une ouverture avec un rebord, pour pouvoir poser la vitre tout en ayant une surface parfaitement plate.



    Sur la droite, nous allons faire une autre petite ouverture pour accueillir le tableau de commande, sur le même principe
  23. Il reste de la place dans le bas pour pouvoir ajouter des boutons poussoirs ou des potentiomètres, par exemple.
  24. Il est temps de tester le ruban à LED RVB.



    Ce modèle présente la particularité de fonctionner en 5V (même tension que pour l’Arduino) contrairement à une majorité fonctionnant en 12V. Il suffit donc de brancher la prise USB à n’importe quelle sortie USB et tout est fonctionnel (ultra pratique pour la portabilité).



    Pour les tests, je l’ai branché sur une batterie externe maison !



    Fixez les rubans provisoirement avec du scotch, sous le panneau supérieur (celui avec la vitre).
  25. la fontaine à eau En premier lieu, nous allons nous intéresser à la fontaine. Avec la pompe et tout le nécessaire pour le circuit d’eau.
  26. Le circuit d’eau est opérationnel ! Nous ne notons aucune fuite :)



    Donc l’eau passe de la bassine pour aller au-dessus de la table, puis s’évacue dans le tuyau violet avant de repasser par une colonne d’eau, pour retomber dans la bassine de départ. Il faut donc fixer tout ça en place, puis homogénéiser l’ensemble.



    J’ai utilisé du simple papier mâché (un volume de colle à papier peint pour 10 volumes d’eau environ) par-dessus une structure en carton, qui sert de fondation. Pour cella, il suffit de couper des morceaux de cartons et de les coller avec de la colle chaude pour obtenir des formes qu’on pourra recouvrir de papier mâché.



    On en profite pour faire passer le fil de la pompe derrière notre surcouche et le faire rejoindre le point juste derrière le tableau de commandes.
  27. Voici le résultat une fois que le papier mâché a séché.
  28. Bon le papier mâché ce n’est pas très joliecomme ça… Donc pour rendre ça un peu plus visuel, il suffit de tout peindre de la même couleur !




    J’ai choisi le blanc afin de donner une base correcte pour appliquer n’importe quelle autre couleur par la suite.




    Nous avons donc maintenant un décor plutôt très atypique. Il manque encore un peu de couleurs, mais les formes rendent la table de nuit vivante.



    Pour la décoration, je me suis inspiré d’Alice aux pays des merveilles (Le livre et le Disney de 1951).

    Mais cela se verra d’avantage une fois que la table sera terminée :)



    Pour le moment, nous allons nous arrêter là pour le contenu de la table ! Sachant que j’ai prévu d’y mettre de l’herbe sur certaines parties, d’y ajouter de véritables plantes, un cactus ou deux, des sculptures de champignons et de personnages, ainsi que des tasses à thé de dînettes…



    Bref, cette dernière partie relève plus de l’art et de la sensibilité, je ne peux que vous conseiller d’être inventif !
  29. Installation de l’électronique



    Tout d’abord, occupons-nous de l’écran !

    Je souhaite qu’il soit au-dessus, mais qu’on puisse le bouger un peu à la manière d’une lampe de bureau.



    Un flexible en métal de 15/20cm dans lequel on glisse 3 fils de cuivre rigide permet d’obtenir ce résultat.
    Attention car il faut également passer 9 fils électriques pour relier l’écran à l’Arduino.



    Tout ça pour aller dans une boite en métal, dans laquelle on incrustera notre écran.



    Pour faire tenir le flexible, il suffit de replier les trois fils de cuivre de chaque coté pour faire pression sur les parois.
    Une pointe de colle chaude pour le coté boite en métal, et des vis sous la table.
  30. Tous nos éléments sont prêts !



    Nous n’avons pas encore vu comment tout relier ensemble, donc un schéma vaut mieux qu’un long discours :
  31. On finalise tout !



    On arrive à la partie délicate : tout fixer sous la table !



    Le tableau de commandes et ces 4 boutons, le transformateur 5V, l’Arduino, le capteur de température et enfin le module d’horloge.
  32. On vérifie que la température indiquée sur l’écran soit bien la bonne.
  33. Un peu de déco sur le dessus…
  34. Évidement, elle n’est pas finie, il reste une bonne partie de décoration/remplissage, mais elle est tout à fait fonctionnelle !



    Il reste également une partie que j’ai passé sous silence : le pilotage des LED par infrarouge. Non pas que ce ne soit vraiment compliqué à mettre en place, mais surtout un peu long à expliquer avec plusieurs étapes.



    Comme ce tuto est déjà assez long, j’ai préféré zapper cette partie, car de toute manière avec la télécommande fournie, on s’en sort déjà bien !
  35. Voici un bref aperçu de la table une fois décorée. Ce n’est qu’une vague approche (de plus, je ne sais pas dessiner).
  36. Conclusion


    Ce projet m’a demandé plus de temps qu’initialement prévu.



    Ce n’est pas tant l’électronique mais le projet en lui-même, car il y a eu beaucoup d’improvisations et de choses à refaire au fil de l’avancement !
    C’est certainement l’un de mes projets les plus complet que j’ai fait jusqu’à maintenant.

    Bien qu’il ne soit pas encore terminé, je suis déjà très satisfait du rendu actuel :)



    Finalement, les prochaines choses à faire sont :



    -Ajouter un bouton poussoir pour basculer entre l’écran de l’heure, de la date, et de la température,

    - Ajouter la fonction IR pour contrôler la couleur des LED depuis le tableau de bord,

    - Finir la décoration !



    Dans les choses possibles de faire :



    - Ajouter un capteur de mouvement (un simple geste de la main pour allumer/changer de couleur ?),

    -Ajouter une fonction réveil (avec musique personnalisé ou cloche mécanique),


    J’espère que vous avez pris autant de plaisir à lire ce tutoriel, que moi à le réaliser !

    À très bientôt !
Réalisé par
Posté le
Univers
IoT
Temps de fabrication
2h
Niveau de difficulté
Avancé
Matériel(s)
1
Arduino UNO
1
Carte micro SD
1
Capteur Dallas (Température)
1
Module DS1307 (Date & heure)
1
Table de nuit

Aucun commentaire. Soyez le premier à en écrire un !

Vous devez être connecté pour laisser un commentaire.