probleme d'afficheur LCD I2C avec horloge RTC

Bonjour,

Je débute et j'ai voulu réaliser le classique horloge RTC avec afficheur LCD.

J'ai donc cherché et trouvé un exemple sur le net et réalisé le câblage.

Le LCD ne fonctionne pas, j'ai donc recherché un test lcd et cela fonctionne avec une librairie différente.

Evidemment, si je modifie la librairie dans le programme rtc ça ne fonctionne pas.

Je pensais que les afficheur LCD I2C étaient standard, je me suis trompé.

Quelque chose de particulier au niveau du I2C que je n'aurais pas compris.

Merci de votre aide

Bonjour

Je pensais que les afficheur LCD I2C étaient standard, je me suis trompé.

non pas standard. Le panneau LCD de l'afficheur est contrôlé presque toujours par un circuit intérgré "quasi standard' qui reçoit ses commandes en parallèle , sur 8 ou 4 bits. Entre ce controleur d'écran et le bus I2C un second circuit intégré d'interface(I2C/Parallèle) et à ce niveau des circuits intégrés divers peuvent être rencontrés

Donc la solution c'est soit de trouver un programme complet qui se base sur la meme librairie soit de modifier le programme que j'ai trouvé pour qu'il s'adapte a la bonne libraire ( ce dont je ne me sent pas capable a l'heure actuelle.

ou trouver l'afficheur qui correspond à la solution déjà programmée

Ou poster ton code qui marche pour qu'on t'explique et qu'on t'aide à ajouter ce qui lui manque

En fouillant pour trouver une solution, ben j'ai trouvé une solution :)

J'ai trouvé un programme avec les bonnes librairies et ça fonctionne.

Merci quand même de votre aide.

L'idée est de récupérer l'information heure / minute pour réaliser un affichage type afficheur 7 segment.

Je ne vois pas comment faire, si quelqu'un peut m'orienter.

Au final je voudrais réaliser un afficheur heure date température comme sur les enseignes commerciales.

J'y comprends rien. Ça fonctionne ou pas ? Qu'est-ce qui manque ? Poste ton code, on ne peut rien faire si on ne sait pas où tu en es

Merci de vous intéresser à mon problème.

Effectivement je continue a réfléchir et a chercher de mon coté, donc oui j'ai réussi a régler mon problème.

Je résume :

j'ai réussi a faire fonctionner la RTC avec afficheur LCD I2C. J'ai réussi a faire fonctionner la sonde humidité/température. J'ai réussi a combiner les deux et a afficher les infos la ou je voulais.

|500x375

Maintenant c'est comment récupérer ces infos pour pouvoir les afficher avec un afficheur 7 segments de 4 digits.

Je me vois deux problèmes :

Comment récupérer ces infos et sous quelle forme.

Comment alimenter les 4 x 7 segment a partir d'un arduino uno sachant qu'il ne me reste que 10 ou 11 sorties de dispo.

4 X 7 segments ça fait 28 circuits + les ":" et le signe des degrés.

Le résultat final sera une horloge géante affichant alternativement l'heure, la date et la température.

Pour info, voici mon code :

#include <dht11.h>
#define DHT11PIN 2 // broche DATA -> broche 2

dht11 DHT11;


#include <Wire.h> //librairie déjà sur arduino
#include <LiquidCrystal_I2C.h> //pour télécharger la librairie: croquis - include library - manage libraries - LiquidCrystal_I2C.h de Frank de Brabander
#include <RTClib.h> //librairie à télécharger en ZIP sur https://github.com/jcw/rtclib

#if defined(ARDUINO) && ARDUINO >= 100
#define printByte(args)  write(args);
#else
#define printByte(args)  print(args,BYTE);
#endif

uint8_t clock[8] = {0x0,0xe,0x15,0x17,0x11,0xe,0x0}; 
RTC_DS1307 RTC;
LiquidCrystal_I2C lcd(0x27,16,2); // Adresse du LCD 0x27 avec 16 colonnes et 2 lignes

void setup()
{
 lcd.init();  // initialisation du LCD
 lcd.backlight();
 lcd.print("Initialising..."); //afficher un message sur l'afficheur LCD
 //lcd.createChar(2, clock);
 Wire.begin();
 RTC.begin();
 RTC.adjust(DateTime(__DATE__, __TIME__)); //Ajuster la clock avec l'heure et la date de l'ordinateur
}

void loop()
{ DHT11.read(DHT11PIN);
 lcd.clear(); //code pour afficher heure et date de la clock (du RTC) sur l'écran LCD
  DateTime now = RTC.now();
  lcd.printByte(2);
  lcd.print(" ");
 lcd.print(now.hour(), DEC);
   lcd.print(':');
   lcd.print(now.minute(), DEC);
   lcd.print(':');
   lcd.print(now.second(), DEC);
   lcd.setCursor(11, 0);
   lcd.print('H');
   lcd.print(':');
   lcd.setCursor(14, 0);
   lcd.print(DHT11.humidity, DEC);
  lcd.setCursor(0, 1);
  lcd.print(now.day(), DEC);
   lcd.print('/');
   lcd.print(now.month(), DEC);
   lcd.print('/');
   lcd.print(now.year(), DEC);
   lcd.setCursor(11, 1);
   lcd.print('T');
   lcd.print(':');
   lcd.setCursor(14, 1);
   lcd.print(DHT11.temperature, DEC);
 delay(1000);
}

Pour contoler un afficheur 7 non 8 segments -> ne pas oublier le point décimal, on peut utiliser des registres à décalge de type 74HC595. Avec plusieurs afficheurs il faut 1 registre par afficheur, les registres étant chaînés (mis à la queue leu leu)

Il doit exister une nombreuse documentation à commencer sur ce forum -> utilise la loupe en haut à droite pour faire des recherches sur ce forum, quelque chose comme "afficheurs 74HC595" devrait donner des résultats.

Salut

Felicitation d'avoir fait tout ça en projet débutant.

Tu peux trouver des écrans 4Digit 7Segments sur des shield a commander en I2C ici ou ici par exemple

Sinon tu peux utiliser des registres à décalage qui te permettent de rajouter des sorties à ton arduino. Un des composants les plus courants est le 74HC595. Il est très bien documenté exemple de tuto

D'autres composants remplissent la même fonction mais communiquent en I2C mcp23s17. Ils sont aussi plus chers.

Fantoche: Salut

Felicitation d'avoir fait tout ça en projet débutant.

Merci, mais c'est du a mon plus gros défaut, j'ai AUCUNE patience.

Je n'ai fait que compiler des programmes glanés sur le net et au final pas appris grand chose.

Je vais donc mettre un frein et essayer de comprendre ce que je fait et surtout étudier un peu pour ne plus faire du bête copié/collé.

Merci de votre aide, je prend bonne note pour les registre a décalage.

Je vois déjà en gros comment procéder, ce qui me bloque c'est comment extraire la valeur de chaque digit pour contrôler complètement l'affichage.

Bonjour

Je vais donc mettre un frein et essayer de comprendre ce que je fait et surtout étudier un peu pour ne plus faire du bête copié/collé.

sage décision !!

ce qui me bloque c'est comment extraire la valeur de chaque digit

prenons les minutes, il faut extraire le chiffre des dizaines et celui des unités Utiliser la division entière par 10 et le modulo 10 (reste de la division par 10)

Etudier Division et Modulo sur cette page , extraite d'un ensemble de tutoriels chaudement recommendés https://eskimon.fr/tuto-arduino-105-le-langage-arduino-12

Je veut bien faire des calculs, diviser tout ça, ce qui m'échappe totalement, c'est ou se trouve cette valeur.

Prenons les minutes, comment j'obtient cette valeur ??

C'est vraiment totalement abstrait pour moi.

il faut vraiment prendre le temps de comprendre le code utilisé !!

Prenons les minutes, comment j'obtient cette valeur ??

lcd.print(now.minute(), DEC)

c'est fait içi par la fonction now.minute(), il suffit de conserver le résultat dans une variable.

Pour en savoir plus, étudier les exemples fournis avec la librairie RTClib

J'ai fait un tour sur le lien concernant les opération de base ( division et modulo ) et j'ai compris comment faire pour extraire les unité et le dizaines.

Par contre je viens d'éplucher les exemple de le biblio RTC et je ne vois nulle part comment on place la valeur dans une variable.

Un exemple de code peut être ?

int date_heure = hour();  // variable date_heure contient l'heure actuelle
int date_minute = minute(); // variable date_minute contient la minute actuelle
int date_seconde = second(); // variable date_seconde contient la minute actuelle

Ne me dite pas que c'est aussi simple que ça ? Si ?

EDIT : Je viens de rentrer et de tester et c'est aussi simple que ça.

Donc plus qu'a assimiler la commande du registre a décalage et c'est parti.

Un transistor (npn ou pnp) par afficheur pour commuter le commun (anode ou cathode) soit 4 broches sur l'arduino, quand aux 7 segments ils sont tous en parallèle soit 7 broches sur l'arduino. On commute les communs en séquence dont on perd 75% de luminosité, par contre on n'ajoute rien d'autre que des transistors pas chers !

rafununu: Un transistor (npn ou pnp) par afficheur pour commuter le commun (anode ou cathode) soit 4 broches sur l'arduino, quand aux 7 segments ils sont tous en parallèle soit 7 broches sur l'arduino. On commute les communs en séquence dont on perd 75% de luminosité, par contre on n'ajoute rien d'autre que des transistors pas chers !

Certes, mais au niveau logiciel cela me semble beaucoup plus simple de travailler avec les registres

Juste une précision, pour l'écran a 4 digits, il faut afficher chaque chiffre séquentiellement. Par exemple pour écrire 1234 on affiche 1 _ _ _ puis _ 2 _ _ puis _ _ 3 _ puis _ _ _ 4. C'est la persistance rétinienne (le cerveau de l'utilisateur quoi) qui donne l'impression de lire 1234