arobasseb

Bonjour à tous,
 
Aujourd'hui nous allons voir comment utiliser le module RTC DS1307 disponible sur la boutique Robot Maker.
Pour ce tuto nous allons également utiliser :

• une breadboard
• un écran LCD
• Le module I2C pour écran LCD
• du fil male femelle 
• du fil male male 

(d'autres composants intéressants sont également disponible sur la boutique, n'hésite pas à y faire un tour ! )
 
Présentation
 
Tout d'abord, qu'est ce qu'un module RTC ? 
 
RTC signifie Real Time Clock soit en français horloge temps réel. 
 
OK, donc je peux l'accrocher dans mon salon ? Pas vraiment
 
En fait ce module, une fois configuré, compte le temps qui passe et ce, de façon autonome et précise grâce à sa pile s'il n'est pas branché.
 
Et du coup à quoi ça sert, c'est pas une pendule et on peut déjà compter le temps avec une arduino par exemple ?
 
Avec ce module on peut faire des montages qui agissent en fonction du temps réel, par exemple allumer les lampes à 18h, ou le grille pain à 6h mais aussi en fonction du jour, mois, ... en effet il connait la date et l'heure réelle.
Son avantage réside dans le fait qu'en cas de coupure d'alimentation il continue de compter, et aucune instruction ne risque de le ralentir, à l'inverse d'une arduino ou, dans ce cas, il y aurai une dérive de temps. 
Il se pilote via un bus I2C, ce qui le rend facile d'utilisation avec justement une arduino.
 
Quelques photos de notre star du jour : 
 



 
Le montage
 
Le schéma :

(dans le schéma, le module n'est pas du même fabricant, mais les connections sont les même)
 
En vrai :

 
Le montage est simple grâce à l'I2C ; il faut connecter les broches SDA des 2 modules sur la broche A4 de l'arduino et les broches SCL sur la broche A5 , les broches VCC au 5V et GND au GND
Attention pour une utilisation avec une arduino par exemple il faudra utiliser un convertisseur de tension (ce point sera peut-être aborder plus tard)
 
C'est cool tout est branché et maintenant ?
 
La programmation
 
Voici le code avec les commentaires qui suffisent à eux même : 

#include <Wire.h>    // Bibliothèque pour l'I2C
#include "RTClib.h"  // Bibliothèque pour le module RTC
#include <LiquidCrystal_I2C.h> // Bibliothèque pour l'écran

RTC_DS1307 RTC;      // Instance du module RTC de type DS1307
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); ////Instance d'écran

void setup(void) {
  //Initialisation de l'éran
  lcd.begin(16,2);
  lcd.clear();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.setCursor(0, 1);
  
  // Initialise la liaison I2C  
  Wire.begin();
  
  // Initialise le module RTC
  RTC.begin();
 
  //Initialise la date et le jour au moment de la compilation 
  // /!\ /!\ Les lignes qui suivent sert à définir la date et l'heure afin de régler le module, 
  // pour les montages suivant il ne faut surtout PAS la mettre, sans à chaque démarrage 
  // le module se réinitialisera à la date et heure de compilation
  
  DateTime dt = DateTime(__DATE__, __TIME__);
  RTC.adjust(dt);
  
  // /!\
  ////////////////////////////////////////////////////////////////////////////////////////////
}

void loop(){
  
  DateTime now=RTC.now(); //Récupère l'heure et le date courante
  
  affiche_date_heure(now);  //Converti la date en langue humaine
  
  delay(1000); // delais de 1 seconde
}

//Converti le numéro de jour en jour /!\ la semaine commence un dimanche
String donne_jour_semaine(uint8_t j){ 
  switch(j){
   case 0: return "DIM";
   case 1: return "LUN";
   case 2: return "MAR";
   case 3: return "MER";
   case 4: return "JEU";
   case 5: return "VEN";
   case 6: return "SAM";
   default: return "   ";
  }
}

// affiche la date et l'heure sur l'écran
void affiche_date_heure(DateTime datetime){
  
  // Date 
  String jour = donne_jour_semaine(datetime.dayOfWeek()) + " " + 
                Vers2Chiffres(datetime.day())+ "/" + 
                Vers2Chiffres(datetime.month())+ "/" + 
                String(datetime.year(),DEC);
  
  // heure
  String heure = "";
  heure  = Vers2Chiffres(datetime.hour())+ ":" + 
           Vers2Chiffres(datetime.minute())+ ":" + 
           Vers2Chiffres(datetime.second());

  //affichage sur l'écran
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(jour);
  lcd.setCursor(0, 1);
  lcd.print(heure);
}

//permet d'afficher les nombres sur deux chiffres
String Vers2Chiffres(byte nombre) {
  String resultat = "";
  if(nombre < 10)
    resultat = "0";
  return resultat += String(nombre,DEC);  
}

J'ai joins le fichier de code ainsi que  les librairies pour le module RTC et LCD.
 
une petite vidéo :
 
 
 
N'hésite pas à laisser un commentaire.

Aujourd'hui je vous présente un composant fort utile le 74hc595.
 
Qui est-il ? C'est un registre à décalage de 8 bits.
 
A quoi sert-il ? il sert à convertir une information série en parallèle. Mais on l'utilise aussi pour économiser le nombre de broche utilisée en sortie.
C'est d'ailleurs pour ce dernier cas que je vais présenter la chose .
 
En effet, au dessus de 3 sorties à piloter, il peut être intéressant d'utiliser ce composant afin d'économiser des broches sur votre carte de commande. Pourquoi 3, car c'est le nombre minimum de broche nécessaire au fonctionnement du composant.
 
Comment ça fonctione ? Afin de mieux comprendre le fonctionnment j'ai fait ces quelques images ci-dessous : 
 






 
Comme on peut le voir, il y a 2 grandes phases : 
La première on place les données que l'on veut 
La deuxième est la validation des données
 
Maintenant passons à la pratique.
 
Dans cet exemple, le but sera d'allumer des LED car c'est le plus simple électriquement. En effet, on peut également piloter des moteurs, des relais, des électrovannes, ... mais cela nécessite une interface de puissance, ce qui n'est pas le sujet de ce tutoriel.
 

 
comme on peut le voir le schéma est très simple : 
Nous avons d'une part le microcontroleur qui alimente et pilote le 74HC595
puis le 74HC595 qui fait le lien avec les LED
et enfin les LED
 
Il est tant, maintenant, de faire fonctionner tout ça.

//constantes pour les broches de commande du 74HC595
int DS_pin = 8;   // broche de donnée
int STCP_pin = 9; // broche de validation de la donnée
int SHCP_pin = 10;// broche de validation compléte (latch)

boolean registre[8]; //c'est un tableau de 8 bit correspondant aux sorties du 74HC595 à l'état voulu
                      // pour se programme j'ai fait le choix du tableau car cela reste simple pour un tutoriel

void setup()
{
    //configure les broches en sortie
    pinMode(DS_pin,OUTPUT);
    pinMode(STCP_pin,OUTPUT);
    pinMode(SHCP_pin,OUTPUT);
}

//Cette fonction "écrit" le contenu du tableau dans le registre
//pour chaque bit, on met la brohe de validation du bit à 0, on place la broche de donnée à l'état contenu dans le tableau et ensuite on valide le bit
//à la fin on valide le tout
void EcrireRegistre()
{
  
  digitalWrite(STCP_pin, LOW);
  
  for (int i = 7; i>=0; i--)
  {
    digitalWrite(SHCP_pin, LOW);
    digitalWrite(DS_pin, registre[i] );
    digitalWrite(SHCP_pin, HIGH);
  }
  
  digitalWrite(STCP_pin, HIGH);
}


//Dans la boucle du programme plusieurs séquences différentes sont jouées
void loop()
{
   //Allume successivement les sorties
   for(int i = 0; i<8; i++)
   {
    registre[i] = HIGH;
    delay(300);
    EcrireRegistre();
   }

   //éteint successivement les sorties
   for(int i = 7; i>=0; i--)
   {
    registre[i] = LOW;
    delay(300);
    EcrireRegistre();
  
   }

   //séquence qui allume une LED sur 2 alternativement
    bool b = 0;
    for(int i = 0; i<4; i++)
    {
        
      for(int j = 0; j<8; j++)
      {
        registre[j] = j%2 xor b;
      }
      EcrireRegistre();
      b = not b;
      delay(300);
    }

    //remise à zéro de toutes les LED
    for(int j = 0; j<8; j++)
    {
      registre[j] = 0;
    }
    EcrireRegistre();
}

 
 
Pour aller plus loin
 
Je vais vous donner deux astuces afin d'étendre un peu le sujet.
 
Astuce 1 : avoir plus de 8 sorties
 
Pour avoir plus de 8 sorties, naturellement on se dit qu'il faut un deuxième 74hc595 et l'on clône le montage en utilisant les autres pins disponibles. Mais si c'était ça je n'aurai pas pris la peine d'écrire cette astuce.
En effet, vous l'avez peut-être remarqué sur le schéma, il y a une broche Q7'. Et c'est de là que vient l'astuce. En effet on peut chainer les 74HC595 entre eux, en reliant la broche Q7' du premier, sur la broche DS (souvenez-vous la broche de donnée) du suivant.
Enfin, afin de synchroniser les deux 74HC595 il suffit de connecter leurs broches ST_CP et SH_CP entre eux.
 
 
Au niveau du code, au lieu de boucler sur 8 bits, il faut boucler sur 16 bits. Et voilà, avec le même nombre de fils on augmente notre circuit de 8 sorties supplémentaires. 
 
 
En théorie vous pouvez en chainer autant que vous voulez, mais en pratique, avec un arduino le temps de mise à jour des registres deviendra de plus en plus long et donc nuira au fonctionnment du programme.
 
Astuce 2 : s'en servir pour augmenter le nombre d'entrée
 
Les puristes ne vont surement pas aimer, et cette astuce se révèle plus être une bidouille. M'enfin, je me lance
 
Imaginons que nous ayons 8 interrupteurs, mais que 4 broches de libres sur notre arduino. On se dit c'est mal barré, on a pas d'autre arduino, c'est fin ; et soudain vous vous souvenez qu'il vous reste un 74HC595. La bidouille peut commencer.
 
Le principe est simple, on va faire se décaler un bit à travers le registre (juste un seul), du coup pour les interrupteurs en sortie, seulement 1 seul sera alimenté et si tous les interrupteurs sont raccordés sur une seule entrée de l'arduino, alors on connait l'état d'interrupteur.
 
 
Bon j'avoue, c'est un peu empirique