Projet Réveil-Matin (partie XII) - Retour sur l'affichage LCD

-
L'affichage sur un écran LCD a déjà été traité dans un article précédent. Cependant, dans la version présentée alors, le module LCD 1602 mobilisait 6 pins de sortie sur l'Arduino. Or, dans l'article précédent, il avait été démontré qu'il était possible de piloter ce module à travers un convertisseur Série/Parallèle 74HC595. Ce qui permettait d'alléger le nombre de pins mobilisées pour l'affichage en le réduisant à 3. Pour cela, un driver avait été développé sur le modèle du driver standard LiquidCrystal. Dans l'article précédent, le driver se nommait LiquidCrystal_74h595. Il a été renommé depuis en LCDDisplay lors de la mise en bibliothèque.
Cet article présente les modifications à apporter à la classe LCDClockDisplay pour utiliser ce nouveau driver

Câblage du projet


Le câblage du projet Horloge, pour l'affichage sur un LCD, reprend le câblage présenté dans l'article « Piloter un écran LCD avec un 74HC595 sur Arduino » en ajoutant les trois boutons de réglage de l'heure et un buzzer passif pour le signal d'alarme.

Modifications à apporter dans la classe LCDClockDisplay

Du fait que le driver LCDDisplay (anciennement nommé LiquidCrystal_74h595), présenté dans l'article « Piloter un écran LCD avec un 74HC595 sur Arduino », reprend l'interface publique du driver standard LiquidCrystal, les modifications à apportées dans la classe LCDClockDisplay sont minimes. Elles se résument à :
  • Remplacer les références à l'ancien driver LiquidCrystal par LCDDisplay.
  • Modifier le constructeur de la classe pour accepter les trois pins connectées au 74HC595 au lieu des six pins connectées directement au module LCD 1602.
Pour le reste du fonctionnement de la classe LCDClockDisplay, se référer à l'article « Projet Réveil-Matin (partie IX) - Affichage sur un écran LCD ».
La classe LCDClockDisplay est développées, comme toutes les classes C++, dans deux fichier : un fichier de définition LCDClockDisplay.h et un fichier d'implémentation LCDClockDisplay.cpp. Les modifications apportées dans ces deux fichiers sont surlignées en vert.

Modifications apportées au fichier LCDClockDisplay.h

#ifndef LCDClockDisplay_h
#define LCDClockDisplay_h

#include <LCDDisplay.h>
#include "ClockDisplay.h"

class LCDClockDisplay : public ClockDisplay {
  static const int POS_CLOCK = 4;
  static const int POS_HOUR = 6;
  static const int POS_MINUTE = POS_HOUR + 3;
  static const int POS_ALARM = 15;
  static const char* BLINK2;
  static const char* BLINK8;
  static const char* LABELS[];
  static byte BELL_CHAR[];
  static byte EACUTE_CHAR[];
  LCDDisplay __LCD;

  protected:
  virtual void _displayTime();
  virtual void _displayStatus();
  virtual void _displayAlarm();
  virtual void _doBlink(bool);

  public:
  LCDClockDisplay(uint8_t, uint8_t, uint8_t);
  virtual void begin();
};

#endif // LCDClockDisplay_h

Modifications apportées au fichier LCDClockDisplay.cpp

#include "LCDClockDisplay.h"

const char* LCDClockDisplay::BLINK2 = "  ";
const char* LCDClockDisplay::BLINK8 = "  :  :  ";
byte LCDClockDisplay::BELL_CHAR[8] = {
  B00100,
  B01010,
  B01010,
  B01010,
  B11011,
  B10001,
  B11111,
  B00100
};

byte LCDClockDisplay::EACUTE_CHAR[8] = {
  B00010,
  B00100,
  B01110,
  B10001,
  B11111,
  B10000,
  B01110,
  B00000
};

const char *LCDClockDisplay::LABELS[] = {"", "R\1glage heure:", "R\1glage Alarme:", "R\1glage heure:", "R\1glage heure:", "R\1glage Alarme:", "R\1glage Alarme:" } ;

LCDClockDisplay::LCDClockDisplay(uint8_t dataPin, uint8_t latchPin, uint8_t clockPin) 
  : ClockDisplay(), __LCD(dataPin, latchPin, clockPin)
{
}


void LCDClockDisplay::begin() {
  ClockDisplay::begin();
  this->__LCD.begin(16,2);
  this->__LCD.createChar(0, BELL_CHAR);
  this->__LCD.createChar(1, EACUTE_CHAR);
}

void LCDClockDisplay::_doBlink(bool blinkStatus) {
  char strTime[10];
  switch (this->_clockStatus) {
    case HOUR_SETUP:
    case ALARM_HOUR_SETUP:
      sprintf(strTime, "%02d", this->_time.HH());
      this->__LCD.setCursor(POS_HOUR, 1);
      this->__LCD.print(blinkStatus ? strTime : BLINK2);
      break;
    case MINUTE_SETUP:
    case ALARM_MINUTE_SETUP:
      sprintf(strTime, "%02d", this->_time.MN());
      this->__LCD.setCursor(POS_MINUTE, 1);
      this->__LCD.print(blinkStatus ? strTime : BLINK2);
      break;
    case ALARM_ACTIVE:
      sprintf(strTime, "%02d:%02d:%02d", this->_time.HH(), this->_time.MN(), this->_time.SS());
      this->__LCD.setCursor(POS_CLOCK, 1);
      this->__LCD.print(blinkStatus ? strTime : BLINK8);
      break;
  }
}

void LCDClockDisplay::_displayTime() {
  char strTime[10];
  int pos = 0;
  switch (this->_clockStatus) {
    case HOUR_DISPLAY:
    case ALARM_ACTIVE:
      sprintf(strTime, "%02d:%02d:%02d", this->_time.HH(), this->_time.MN(), this->_time.SS());
      pos = POS_CLOCK;
      break;
    default:
      sprintf(strTime, "%02d:%02d", this->_time.HH(), this->_time.MN());
      pos = POS_HOUR;
      break;
  }
  this->__LCD.setCursor(pos, 1);
  this->__LCD.print(strTime);
}

void LCDClockDisplay::_displayStatus() {
  this->__LCD.clear();
  this->__LCD.setCursor(0, 0);
  this->__LCD.print(LABELS[(int)this->_clockStatus]);
  this->_displayAlarm();
}

void LCDClockDisplay::_displayAlarm() {
  this->__LCD.setCursor(POS_ALARM, 0);
  this->__LCD.write(this->_alarmStatus ? 0 : ' ');
}

Modifications apportées dans le sketch Arduino

#include "LCDClockDisplay.h"
#include "ClockAlarm.h"
#include "Clock.h"

// Déclaration des pins de connexion des boutons de commande.
#define BTN_CMD 9
#define BTN_UP 7
#define BTN_DOWN 8
// Déclaration de la pin de connexion du buzzer passif.
#define BUZZER 10
// Déclaration des pin du 74HC595
#define IC_DATA 2
#define IC_LATCH 3
#define IC_CLOCK 4

LCDClockDisplay clockDisplay(IC_DATA, IC_LATCH, IC_CLOCK);
BuzzerClockAlarm clockAlarm(BUZZER);
Clock myclock(clockDisplay, clockAlarm, BTN_CMD, BTN_UP, BTN_DOWN);


void setup() {
  myclock.begin();
}

void loop() {
  myclock.loop();
}

Conclusion

Avec cet article, nous obtenons ce que l'on peut considérer comme la version définitive du projet Horloge.
Celui-ci ne mobilise plus que 7 pins sur l'Arduino :
  • Trois pins(2, 3 et 4) pour piloter le convertisseur Série/Parallèle 74HC595, qui lui-meme pilote le module LCD 1602.
  • Trois pins (7, 8 et 9) pour piloter les trois boutons utilisés pour le réglage de l'heure.
  • Une pin (10) pour  piloter le buzzer passif  qui émet le signal d'alarme.
Pays/territoire : 55700 Stenay, France

Commentaires

Enregistrer un commentaire

Posts les plus consultés de ce blog

Afficheur à LED 7 segments (classe SegmentLedDisplay)

-
Image
Les afficheurs LED 7 segments permettent d'afficher des chiffres. Cet article présente les différents aspect de ce composant en commençant par le câblage pour terminer par la programmation. Un afficheur LED est en fait un réseau de LED, une par segment, chacune des LED étant pilotée par une broche. Il existe plusieurs sortes d'afficheurs. Certains ont une anode commune. Les LEDs sont alors contrôlées par leur cathode. Pour d'autres, c'est la cathode qui est commune. Dans ce cas, les LEDs sont contrôlées par leur anode. Aussi, il est très important de vérifier sur la fiche technique dans quel sens doit être effectué le câblage en polarisation directe. Dans c'est article, le composant utilisé est un afficheur 5161AS qui est utilisé. Pour ce composant, c'est la cathode qui est commune. Câblage d'un afficheur LED à 7 segments Brochage de l'afficheur 5161AS Dans la figure ci-contre présente le brochage de l'afficheur 5161DS. Ce qui
Lire la suite

Piloter un clavier matriciel sur le bus I2C avec un PCF8574

-
Image
Dans l'article précédent , le pilotage d'un clavier matriciel connecté à un Arduino avait été présenté. Le clavier utilisé possédait seize touches. Et on avait constaté que l'architecture matricielle de celui-ci avait permis de ne mobiliser que huit pins numériques. Or, huit pins sur un micro-contrôleur qui n'en comporte que douze demeure un nombre relativement élevé. Aussi est-il pertinent de rechercher une solution alternative pour réduire, voire annuler ce nombre. La solution proposée dans cet article permet de libérer toutes les pins numériques de l'Arduino. Elle procède du même principe que celle présentée pour le module LCD 1602 , à savoir de passer par le bus I2C à l'aide d' un circuit intégré PCF8574 . Principe du câblage du clavier avec un PCF8574 Schéma électronique Comme pour le module LCD 1602, le principe consiste à intercaler un circuit PCF8574 entre le clavier et le micro-contrôleur. Coté Arduino la connexion se fait par les pins SD
Lire la suite

Utiliser Visual Studio Code pour développer sur Arduino

-
Image
Pour ceux qui sont déçus de la faible ergonomide de l'IDE standard d'arduino, il est possible d'utiliser Visual Studio Code pour développer en C++ des programmes pour Arduino. En effet, VsCode présente de nombreux avantages pour les développeur, l'intellisense, l'utilisation d'outils de gestion de code comme Git et la possibilité de déboguer à distance (mais sur certains Arduino seulement). Le présent article présente comment configurer VSCode pour ce faire. Pré-requis L'IDE Arduino doit être installé. Cela reste nécessaire, même si celui-ci ne sera plus utilisé, car son installation comprend celles de tous les drivers et bibliothèques nécessaires au développement. VSCode doit être installé. Il ne sera présenté, dans cet article, que de configuration de VSCode. Pour l'installation, se repporter à l'adresse https://code.visualstudio.com/docs . Installation des extensions VSCode Par défaut VSCode ne prévoit rien. En effet, sa vocation
Lire la suite