RTC ne fonctionne plus avec la pile

Salut,

Je suis actuellement en train de développer une horloge. J’affiche l’heure sur 6 matrice, et je la lis avec une TinyRTC ( Celle-ci ).

Mais le problème est que je ne peux pas stocker l’heure… Dès que je mets une pile dans ma RTC, elle s’arrête de fonctionner sans raison apparente. J’ai deux pile et cela me fait exactement avec l’une ou l’autre.

Je voulais donc savoir si c’était déjà arriver à quelqu’un ? Ou qui aurait une solution :slight_smile:

Merci d’avance

Mon code (pas très optimisé et pas très beau :3 ) :

#include <Wire.h>
#include <RTClib.h>
#include "LedControl.h"


int item = 6;   // Nombre de matrice

LedControl lc=LedControl(12,11,10,item);  // Pins: DIN,CLK,CS, # of Display connected
RTC_DS1307 RTC; //Classe RTC_DS1307 // RTC
 
unsigned long delayTime=200;  // Delay between Frames


int numero_affichage = 0;

int old_seconde = 0;
int old_heure = 0;
int old_minut = 0;

int seconde_a = 0;
int minut_a = 0;
int heure_a = 0;
int seconde_b = 0;
int minut_b = 0;
int heure_b = 0;

int seconde = 0;
int minut = 0;
int heure = 0;
int flag = 0;

// Put values in arrays
byte n_0[] =
{
  B00111100,
  B01111110,
  B01100110,
  B01100110,
  B01100110,
  B01100110,
  B01111110,
  B00111100
};

byte n_1[] = 
{
  B00001100,
  B00011100,
  B00111100,
  B00001100,
  B00001100,
  B00001100,
  B00001100,
  B00001100
};
 
byte n_2[] = 
{
  B00111100,
  B01111110,
  B01100110,
  B00001110,
  B00111100,
  B01110000,
  B01111110,
  B01111110
};

byte n_3[] = 
{
  B01111110,
  B01111110,
  B00001110,
  B00111100,
  B00111110,
  B00000110,
  B01111110,
  B00111100
};

byte n_4[] = 
{
  B01100110,
  B01100110,
  B01100110,
  B01111110,
  B01111110,
  B00000110,
  B00000110,
  B00000110
};
 
byte n_5[] = 
{
  B01111110,
  B01111110,
  B01100000,
  B01111100,
  B00111110,
  B00000110,
  B01111110,
  B00111100
};

byte n_6[] = 
{
  B00011100,
  B00111100,
  B01110000,
  B01111100,
  B01100110,
  B01100110,
  B01111110,
  B00111100
};

byte n_7[] = 
{
  B01111110,
  B01111110,
  B00000110,
  B00001110,
  B00011100,
  B00011000,
  B00011000,
  B00011000
};
 
byte n_8[] = 
{
  B00111100,
  B01111110,
  B01100110,
  B01100110,
  B01111110,
  B01100110,
  B01111110,
  B00111100
};

byte n_9[] = 
{
  B00111100,
  B01111110,
  B01100110,
  B01100110,
  B01111110,
  B00111110,
  B00001110,
  B00111100
};
 
void setup()
{
  Serial.begin(9600);
  RTC.begin(); //Démarrage de la librairie RTClib.h

  if (! RTC.isrunning()) {
    Serial.println("RTC ne fonctionne pas !");
  }
    
  //Met à l'heure à date à laquelle le sketch est compilé
  RTC.adjust(DateTime(__DATE__, __TIME__)); 
  
  lc.shutdown(0,false);
  lc.shutdown(1,false);
  lc.shutdown(2,false);
  lc.shutdown(3,false);
  lc.shutdown(4,false);
  lc.shutdown(5,false);
  
  lc.setIntensity(0,5);
  lc.setIntensity(1,5);
  lc.setIntensity(2,5);
  lc.setIntensity(3,5);
  lc.setIntensity(4,5);
  lc.setIntensity(5,5);
  
  lc.clearDisplay(0);
  lc.clearDisplay(1);
  lc.clearDisplay(2);
  lc.clearDisplay(3);
  lc.clearDisplay(4);
  lc.clearDisplay(5);
}

void loop()
{
  DateTime now = RTC.now();
  seconde = now.second();
  minut = now.minute();
  heure = now.hour();
  
  old_seconde = seconde;
  old_minut = minut;
  old_heure = heure;
  
  seconde_a = seconde / 10;
  seconde_b = seconde - (seconde_a * 10);

  minut_a = minut / 10;
  minut_b = minut - (minut_a * 10);
  
  heure_a = heure / 10;
  heure_b = heure - (heure_a * 10);
  
  affichage(heure_a, 0);
  affichage(heure_b, 1);
  affichage(minut_a, 2);
  affichage(minut_b, 3);
  affichage(seconde_a, 4);
  affichage(seconde_b, 5);  
}

void affichage(int numero, int afficheur)
{

  switch(numero)
  {
    case 0 :
      for (int i = 0; i < 8; i++)
      {
        lc.setRow(afficheur,i,n_0[i]);
      }
      break;
    case 1 :
      for (int i = 0; i < 8; i++)
      {
        lc.setRow(afficheur,i,n_1[i]);
      }
      break;
    case 2 :
      for (int i = 0; i < 8; i++)
      {
        lc.setRow(afficheur,i,n_2[i]);
      }
      break;
    case 3 :
      for (int i = 0; i < 8; i++)
      {
        lc.setRow(afficheur,i,n_3[i]);
      }
      break;
    case 4 :
      for (int i = 0; i < 8; i++)
      {
        lc.setRow(afficheur,i,n_4[i]);
      }
      break;
    case 5 :
      for (int i = 0; i < 8; i++)
      {
        lc.setRow(afficheur,i,n_5[i]);
      };
      break;
    case 6 :
      for (int i = 0; i < 8; i++)
      {
        lc.setRow(afficheur,i,n_6[i]);
      }
      break;
    case 7 :
      for (int i = 0; i < 8; i++)
      {
        lc.setRow(afficheur,i,n_7[i]);
      }
      break;
    case 8 :
      for (int i = 0; i < 8; i++)
      {
        lc.setRow(afficheur,i,n_8[i]);
      }
      break;
    case 9 :
      for (int i = 0; i < 8; i++)
      {
        lc.setRow(afficheur,i,n_9[i]);
      }
      break;
  }
}

bonjour,
tu ne mets pas la pile à l’envers?

Du tout, il est pratiquement impossible de la mettre à l'envers sans exploser le socle...

c'est une pile ou une batterie (CR2032 ou LIR2032)?

bonsoir
Sans pile , mais alimenté en 5V , le module est "fonctionnel" en écriture/lecture ?

Bonsoir,

Ce module exige une "battery" (accus rechargeable) LIR 2032.
Il y a un pont résistif dans le circuit d'alim de sauvegarde pour abaisser la tension de la LIR (4.2v) au 3/4.
Si tu mets une pile de 3V la tension est aussi abaissée au 3/4.
De plus une pile dans un circuit de charge...ça ne doit pas être recommandé

schéma de la TinyRTC

Bonsoir,

Au temps pour moi, je n’avais pas fait attention. C’est bien une batterie CR2032 3V.

Oui le module fonctionne parfaitement juste avec une alimentation en 5V.

Donc Papybricol, je devrais regarder pour en trouvé une en 4.2V ?

Merci pour vos réponse

Fazzeex:
C'est bien une batterie CR2032 3V.

non c'est une pile et c'est hyper dangereux de l'utiliser comme ça (recharge d'une pile 3v avec alimentation 5v), il faut :

  • soit supprimer la diode dans le circuit de charge
  • soit utiliser une batterie LIR2032

Pourtant c'est marqué " Lithium Battery ".

Au tout cas merci de la réponse, je vais regardé demain si je peux en trouver une.

Merci !

Fazzeex:
Pourtant c'est marqué " Lithium Battery ".

oui " Lithium Battery " en français "pile lithium"
j'ai eu le même pb sur une livraison alors que la précédente était livré avec des LIR

Battery

C'est de l'anglais !
Les mêmes mots n'ont pas la même signification en anglais ou en français.
Batterie c'est un assemblage comme une batterie de casseroles. Tout comme "pile" vient "d'empillage" de "sources chimiques de tension élémentaires".
Batterie n'a jamais voulu dire que c'est rechargeable , c'est une déformation française.
Nous devrions dire "accumulateur".