Perte de sans froid avec Tiny Rtc...

Bonjour à tous! J’ai lu pas mal de truc sur le DS1307 et je me suis dit : “aller, va en acheter un”. Chose faite sur e-bay (crise oblige :wink: ) et je viens de recevoir mon précieux! J’ai donc chercher à le faire fonctionner vite fait avec un programme exemple proposé par quelques personnes sur le net. Cependant, pour un code qui marche chez tout le monde (que je mettrais à la fin de ce post), chez moi ça ne fonctionne pas…

Voilà ce que j’ai fait quand j’ai reçu mon colis:
1/ je l’ai ouvert!
2/ j’ai souris!
3/ j’ai cherché la librairie RTClib.h que j’ai installée
4/ j’ai branché mon adruino UNO à mon PC
5/ j’ai connecté la carte Tiny RTC à mon arduino de la façon suivante : SDA pins 4 et SCL pins 5 + VCC à 5V et GND à GND.
6/ j’ai mis le code
7/ j’ai pas compris le résultat…

J’ai vu qu’il y avait d’autres personnes dans mon cas mais personne n’a donné de réponse…


code :
#include <Wire.h>
#include <RTClib.h>
RTC_DS1307 RTC;
//init
int scl = 5;
int sda = 4;
//int sqw = 5;
long lastDebounceTime = 0; // the last time the output pin was toggled
long debounceDelay = 10 * 1000; // the debounce time (10 seconds)
void setup() {
Wire.begin();
RTC.begin();
Serial.begin(57600);

if (! RTC.isrunning()) {
Serial.println(“RTC is NOT running!” );
} else {
//setHeure(); // à décommenter pour remettre à l’heure
}
}
void loop() {
if ((millis() - lastDebounceTime) > debounceDelay) {
affichHeure();
if (cestlheure()) {
// ce qu’il doit se passer quand il est l’heure programmée
}

lastDebounceTime = millis();
}
}
boolean cestlheure() {
DateTime maintenant = RTC.now();
boolean heureOK = false;
if (int(maintenant.hour()) == 12 && int(maintenant.minute()) == 0) heureOK = true;
return heureOK;
}
void setHeure() {
DateTime heurePC = DateTime(DATE, TIME);
DateTime heureRTC = RTC.now();

if (heurePC.hour() != heureRTC.hour() || heurePC.minute() != heureRTC.minute()) RTC.adjust(DateTime(DATE, TIME));
}
void affichHeure() {
DateTime maintenant = RTC.now();
Serial.print(“now : " );
Serial.print(maintenant.hour(), DEC);
Serial.print(”:" );
Serial.print(maintenant.minute(), DEC);
Serial.print(":" );
Serial.println(maintenant.second(), DEC);
}



Résultat:
RTC is NOT running!
now : 165:165:85
now : 165:165:85
now : 165:165:85
now : 165:165:85
now : 165:165:85
now : 165:165:85


et ça me met le même genre de délire quand je mets l’exemple ci dessous:

exemple :
/*

  • Sketch de lecture et programmation via port serie pour horloge RTC I2C DS1307
  • Librairie DS1307 fournie par mattt et D. Sjunnesson et corrigée par bricofoy.
  • Voir DS1307.h pour plus de détails
  • Exemple sous licence GNU GPL
  • (c) bricofoy 2012

*/

// compatibilité entre arduino 1.0 en anciennes versions
#if defined(ARDUINO) && ARDUINO >= 100
#include “Arduino.h”
#else
#include “WProgram.h”
#endif

#include <Wire.h>
#include <DS1307.h>

void setup() {
Serial.begin(9600);
usage();
lecture_RTC();
}

// explication de l’utilisation
void usage() {
Serial.println("\nUSAGE : u U r R h[00-23]m[00-59]s[00-59]j0[1-7]D[01-31]M[01-12]A[00-49]");
Serial.println("\nEXEMPLE : h09m35j03 regle l’heure sur 09h35 et jour de la semaine 3 (mardi).");
Serial.println("\nCommandes : h** : heure, m** : minutes, s** : secondes, j0* : jour de la semaine");
Serial.println(" M** : mois, A** : annee, D** : jour de la date.");
Serial.println(" r stoppe l’horloge, R la demarre. “);
Serial.println(” u ou U affichent ce message, tout autre caractere affiche l’heure.");
}

// fonction de lecture de l’heure dans le DS1307
void lecture_RTC() {
Serial.print("\nHeure actuelle : “);
Serial.print(RTC.get(DS1307_HR,true)); //read the hour and also update all the values by pushing in true
Serial.print(”:");
Serial.print(RTC.get(DS1307_MIN,false));//read minutes without update (false)
Serial.print(":");
Serial.print(RTC.get(DS1307_SEC,false));//read seconds
Serial.print(" “); // some space for a more happy life
Serial.print(RTC.get(DS1307_DOW,false));
Serial.print(” “);
Serial.print(RTC.get(DS1307_DATE,false));//read date
Serial.print(”/");
Serial.print(RTC.get(DS1307_MTH,false));//read month
Serial.print("/");
Serial.println(RTC.get(DS1307_YR,false)); //read year
}

// paramétrage de l’horloge
void ecriture_RTC() {
char valeur=0;
char commande=0;

commande = Serial.read();
delay(50); //delai pour permettre la bonne lecture du port série.
valeur=byte((Serial.read()-48)10); //-48 car la valeur ascii du 0 est 48, celle du 1 est 49, etc.
delay(50); //et
10 car on lit d’abord les dizaines
valeur+=byte((Serial.read()-48)); //lecture des unités

switch (commande) {
case ‘h’ :
RTC.set(DS1307_HR,valeur);
Serial.print("champ heures regle sur ");
Serial.println(valeur,DEC);
break;
case ‘m’ :
RTC.set(DS1307_MIN,valeur);
Serial.print("champ minutes regle sur ");
Serial.println(valeur,DEC);
break;
case ‘s’ :
RTC.set(DS1307_SEC,valeur);
Serial.print("champ secondes regle sur ");
Serial.println(valeur,DEC);
break;
case ‘D’ :
RTC.set(DS1307_DATE,valeur);
Serial.print("champ date regle sur ");
Serial.println(valeur,DEC);
break;
case ‘j’ :
RTC.set(DS1307_DOW,valeur);
Serial.print("champ jour regle sur ");
Serial.println(valeur,DEC);
break;
case ‘M’ :
RTC.set(DS1307_MTH,valeur);
Serial.print("champ mois regle sur ");
Serial.println(valeur,DEC);
break;
case ‘A’ :
RTC.set(DS1307_YR,valeur);
Serial.print("champ annee regle sur ");
Serial.println(valeur,DEC);
break;
case ‘u’ :
case ‘U’ :
usage();
break;
case ‘r’ :
RTC.stop();
Serial.println(“Horloge stoppee”);
break;
case ‘R’ :
RTC.start();
Serial.println(“Horloge lancee”);
break;
default :
break;
}
lecture_RTC();
}

void loop() {
if (Serial.available()) {
ecriture_RTC();
}
}

Resultat:
USAGE : u U r R h[00-23]m[00-59]s[00-59]j0[1-7]D[01-31]M[01-12]A[00-49]

EXEMPLE : h09m35j03 regle l’heure sur 09h35 et jour de la semaine 3 (mardi).

Commandes : h** : heure, m** : minutes, s** : secondes, j0* : jour de la semaine
M** : mois, A** : annee, D** : jour de la date.
r stoppe l’horloge, R la demarre.
u ou U affichent ce message, tout autre caractere affiche l’heure.

Heure actuelle : 45:85:85 7 165/45/2165

Quelqu’un peut m’aider? je ne comprends vraiment pas ce que je dois faire…
Merci d’avance pour votre aide!

paulaubry33: Bonjour à tous! J'ai lu pas mal de truc sur le DS1307 et je me suis dit : "aller, va en acheter un". Chose faite sur e-bay (crise oblige ;) ) et je viens de recevoir mon précieux! J'ai donc chercher à le faire fonctionner vite fait avec un programme exemple proposé par quelques personnes sur le net. Cependant, pour un code qui marche chez tout le monde (que je mettrais à la fin de ce post), chez moi ça ne fonctionne pas...

Voilà ce que j'ai fait quand j'ai reçu mon colis: 1/ je l'ai ouvert! 2/ j'ai souris! 3/ j'ai cherché la librairie RTClib.h que j'ai installée 4/ j'ai branché mon adruino UNO à mon PC 5/ j'ai connecté la carte Tiny RTC à mon arduino de la façon suivante : [u]SDA pins 4 et SCL pins 5 + VCC à 5V et GND à GND[/u]. 6/ j'ai mis le code 7/ j'ai pas compris le résultat...

... Quelqu'un peut m'aider? je ne comprends vraiment pas ce que je dois faire... Merci d'avance pour votre aide!

bonjour sans oublier l'alim de backup ? :grin:

Salut, comment se présente ce que tu as acheté, est-ce la puce seule ou bien une carte avec tous les composants nécessaires au fonctionnement de la puce dessus ? Si oui, les résistances de pullup du bus i2c sont-elles présentes ? (en général oui, mais il me semble que certaines cartes premiers prix les omettent...). Sinon, la pile de secours est-elle installée ? La fiche technique du DS1307 précise bien que celle-ci doit toujours être présente pour garantir un bon fonctionnement (même si je n'ai jamais eu de problème pour en faire fonctionner sans, il est possible que tu ais moins de chance ;) C'est tout ce à quoi je pense pour le moment.

PS: édite ton premier post stp pour mettre les gros pâté de code entre les balises [ code ] prévues à cet effet.

paulaubry33: Quelqu'un peut m'aider?

Oui...

paulaubry33: je ne comprends vraiment pas ce que je dois faire...

1èrement éditer ton message et mettre le code entre les balises avec le bouton #

PS. au prochain message sans que ce soit fait.... je verrouille le topic

Sinon, la pile de secours est-elle installée ?

Et encore bonne........venant de chine tout peut arriver, y compris et surtout l'assemblier qui achète à bas prix des piles en fin de vie que des gros calibres comme Foxcom revendent 1 yuan le kg pour s'en débarrasser. --> c'est du vécu avec une DS1307.

Salut

Alors plusieurs choses à dire :

1) commence par retrouver ton sang-froid STP :D Tu trouveras plein de personnes ici qui peuvent t'aider, mais la mauvaise (comme la bonne) humeur c'est contagieux. Donc si tu veux faire avancer le schmilblick je t'invite à descendre dans les tours.

2)

paulaubry33: J'ai donc chercher à le faire fonctionner vite fait avec un programme exemple proposé par quelques personnes sur le net. Cependant, pour un code qui marche chez tout le monde (que je mettrais à la fin de ce post), chez moi ça ne fonctionne pas...

Ben oui là je crois qu'il faut aussi que tu te fasses à l'idée : Arduino c'est rarement du tout prêt. Le "je-branche-j'upload-un-code-tout-fait-sans-comprendre-et-hop-hop-ça-marche" n'est pas souvent au rendez-vous.

Donne moi un petit moment et je te mettrai un code qui permet de tester ton Tiny RTC. Disons dans la soirée, si tu as la patience d'attendre jusque là.

Et d'ici là tu peux par exemple éditer ton premier post comme demandé ;)

@heifger : Euh pour la résistance de pull-up c'est une question que je me suis posée. N'étant pas très doué pour analyser de visu un circuit imprimé, j'ai pris l'hypothèse qu'il ne devait pas y en avoir, car sinon comment brancher plusieurs composants sur un même bus I2C si chacun arrive avec son pull-up ? Du coup j'en ai mis une et ça fonctionne très bien.

car sinon comment brancher plusieurs composants sur un même bus I2C si chacun arrive avec son pull-up ?

Ce n'est pas un problème en soi, c'est même préférable. La limite dans l'I2C c'est la capacité qui charge le bus. Chaque composant apporte ses dizaines de pF. En fait électroniquement parlant c'est le produit RC (R= pullup résistance de charge, C= capacité totale du bus) qui ne doit pas être trop grand.

Si tous les composants ont leur résistance de charge que se passe-t-il quand on en ajoute sur le bus : -> les capacités s'ajoutent. -> les résistances se mettent en parallèle sur les existantes donc la résistance équivalente diminue

Au final le produit RC reste quasiment constant quelque soit le nombre de circuits connectés --> c'est ce qu'il faut.

PS :Dans le cas de l'I2C les termes résistance de tirage, en français, ou pullup, en étranger, sont très mal employés Les résistances ne sont là en aucun cas pour fixer un potentiel. La norme I2C impose en sortie des collecteurs ou des drains ouvert pour réaliser des fonctions logiques "OU" câblées. Ce qui veut dire que sans cette résistance le circuit est ouvert et aucun courant ne peut circuler -> cela ne peut pas fonctionner.

merci pour cette réponse très précise Et si j'ajoute un PCF8574 sur le même bus I2C que le TinyRTC, là je dois bien ajouter une résistance de pull up sur SDA et SCL ?

Comme pour tout ce serait trop facile s’il y avait des règles absolues.
Il y a de la marge de manœuvre.

En général les cartes toute faîtes incorporent des résistances de l’ordre de plusieurs kohm, ce n’est pas donc vraiment pas gênant de les mettre en parallèle tant que la résistance équivalente est supérieure à 500 ohms/1 kohm. La limite est le courant maximal que peut supporter le transistor en collecteur ou drain ouvert.

La limite supérieure de la valeur de la résistance de charge “qui ne cause pas de problème” est vers 20 à 40 kohms pour 1 composant I2C.
Donc si en plus d’une carte comportant une résistance de charge de 7,5 kohm (c’est une valeur que j’ai souvent vue) tu ajoute un PCF8574 et dans la mesure où tu ne le relie pas avec 50m de câble il ne sera nullement besoin d’ajouter une résistance de charge supplémentaire.

Cela “peut” même fonctionner avec seulement les résistances de tirage internes au micro (de 30k à 100 kohms selon le lot de fabrication), d’ailleurs elles sont activées par défaut par la librairie Wire mais je recommande de conserver une résistance externe entre 5k et 10 k .

Tout est décrit dans la norme I2C, en pj un graphe représentant la valeur max de R en fonction de C.
Le mode normal est celui de la librairie Wire → Fh = 100kHz.
Le mode fast est le mode maximal supporté par les micro-controleur AVR (Fh = 7400 kHz), il faut modifier la librairie Wire pour l’utiliser.
Le mode fast mode plus (Fh = 1MHz) est impossible avec un avr.

I2C_RC.png

Comme promis voici un programme qui permet de vérifier le bon fonctionnement d'un Tiny RTC.

Je viens de l'assembler à partir de quelques uns de mes bouts de code, donc c'est sans prétention. Testé OK ==> uploader et regarder ce qui se raconte dans le moniteur série.

Mais je conseille quand même de commencer par essayer de comprendre le code, qui me paraît assez accessible.

...

Ah ben non. Si je mets le code mon post est refusé car je suis trop gros (> 9500 caractères). Mon fichier .c sur disque pèse 9741 octets, plus les quelques phrases ci-dessus.

Chefs modos : quelle est la marche à suivre dans ce cas ? :grin:

Tu mets le code dans deux messages.

Partie 1

//*********************************************************************
//Programme de test d'un Tiny RTC I2C
//ne nécessite aucune bibliothèque exotique
//
//à exécuter plusieurs fois avec des mises hors tensions intermédiaires
//pour vérifier la persistance des informations
//
//les fonctions générales présentes en début de code n'attendent qu'un copier/coller
//
//codé en "C basique et accessible"
//
//enjoy
//Bricoleau
//*********************************************************************

#include <Wire.h> //et c'est tout !


//*********************************************************************
//Fonctions de gestion du bus I2C
//*********************************************************************

void I2C_init()
{
    Wire.begin();
}

uint8_t I2C_ping_composant(uint8_t id_composant)
// retourne 0 si OK. Autres codes voir http://arduino.cc/en/Reference/WireEndTransmission
{
  Wire.beginTransmission(id_composant);
  return Wire.endTransmission();
}

void I2C_lecture(uint8_t id_composant, uint8_t nb_octets, uint8_t buffer[])
{
  uint8_t i;

  Wire.requestFrom(id_composant, nb_octets);
  for(i=0; i<nb_octets; i++) {
    if (Wire.available()) buffer[i]=Wire.read();
  }
}

void I2C_ecriture(uint8_t id_composant, uint8_t nb_octets, uint8_t buffer[])
{
  uint8_t i;
  Wire.beginTransmission(id_composant);
  for(i=0; i<nb_octets; i++) {
    Wire.write(buffer[i]);
  }
  Wire.endTransmission();
}

void I2C_ecriture_2paquets(uint8_t id_composant, uint8_t nb_octets1, uint8_t buffer1[], uint8_t nb_octets2, uint8_t buffer2[])
//utile pour les composants I2C avec adressage interne (eeprom etc.)
{
  uint8_t i;
  Wire.beginTransmission(id_composant);
  for(i=0; i<nb_octets1; i++) {
    Wire.write(buffer1[i]);
  }
  for(i=0; i<nb_octets2; i++) {
    Wire.write(buffer2[i]);
  }
  Wire.endTransmission();
}


//*********************************************************************
//Fonctions de gestion du DS1307 (RTC I2C)
//*********************************************************************

#define DS1307_ID B1101000

uint8_t DS1307_ping()
// retourne 0 si OK. Autres codes voir http://arduino.cc/en/Reference/WireEndTransmission
{
  return I2C_ping_composant(DS1307_ID);
}

void DS1307_lecture(uint8_t adresse, uint8_t nb_octets, uint8_t buffer[])
//lecture de n octets à partir d'une certaine adresse de la NVRAM du DS1307
{
  uint8_t buffer_adresse[1];

  buffer_adresse[0] = adresse;
  I2C_ecriture(DS1307_ID, 1, buffer_adresse);
  I2C_lecture(DS1307_ID, nb_octets, buffer);
}

void DS1307_ecriture(uint8_t adresse, uint8_t nb_octets, uint8_t buffer[])
//ecriture de n octets à partir d'une certaine adresse de la NVRAM du DS1307
{
  uint8_t buffer_adresse[1];

  buffer_adresse[0] = adresse;
  I2C_ecriture_2paquets(DS1307_ID, 1, buffer_adresse, nb_octets, buffer);
}

void DS1307_init_horloge()
//mise en route de l'horloge si stoppée
{
  uint8_t I2C_buffer[1];

  DS1307_lecture(0,1,I2C_buffer);
  if (I2C_buffer[0] > 127) {
    I2C_buffer[0] = I2C_buffer[0] & 127;
    DS1307_ecriture(0,1,I2C_buffer);
  }
}

void DS1307_lecture_horloge(uint8_t *annee, uint8_t *mois, uint8_t *jour, uint8_t *joursem, uint8_t *heure, uint8_t *minute, uint8_t *seconde)
{
  uint8_t I2C_buffer[7];

  //lecture de 7 octets à partir de l'adresse 0
  DS1307_lecture(0, 7, I2C_buffer);
  //et calcul horloge selon indications du datasheets DS1307
  *seconde =(10*((I2C_buffer[0]&B01110000)>>4))+(I2C_buffer[0]&B1111);
  *minute  =(10*((I2C_buffer[1]&B01110000)>>4))+(I2C_buffer[1]&B1111);
  *heure   =(10*((I2C_buffer[2]&B00110000)>>4))+(I2C_buffer[2]&B1111);
  *joursem =      I2C_buffer[3]&B00000111;
  *jour    =(10*((I2C_buffer[4]&B00110000)>>4))+(I2C_buffer[4]&B1111);
  *mois    =(10*((I2C_buffer[5]&B00110000)>>4))+(I2C_buffer[5]&B1111);
  *annee   =(10*((I2C_buffer[6]&B11110000)>>4))+(I2C_buffer[6]&B1111);
}

void DS1307_ecriture_horloge(uint8_t annee, uint8_t mois, uint8_t jour, uint8_t joursem, uint8_t heure, uint8_t minute, uint8_t seconde)
{
  uint8_t I2C_buffer[7];

  //ecriture de 7 octets à partir de l'adresse 0
  //selon indications du datasheets DS1307
  I2C_buffer[0] = (((seconde / 10) & B0111) << 4) + (seconde % 10);
  I2C_buffer[1] = (((minute  / 10) & B0111) << 4) + (minute  % 10);
  I2C_buffer[2] = (((heure   / 10) & B0011) << 4) + (heure   % 10);
  I2C_buffer[3] =    joursem       & B0111;
  I2C_buffer[4] = (((jour    / 10) & B0011) << 4) + (jour    % 10);
  I2C_buffer[5] = (((mois    / 10) & B0001) << 4) + (mois    % 10);
  I2C_buffer[6] = (((annee   / 10) & B1111) << 4) + (annee   % 10);
  DS1307_ecriture(0, 7, I2C_buffer);
}


//*********************************************************************
//Fonctions de gestion du AT24C32 (EEPROM 4ko I2C)
//*********************************************************************

#define AT24C32_ID B01010000

uint8_t AT24C32_ping()
// retourne 0 si OK. Autres codes voir http://arduino.cc/en/Reference/WireEndTransmission
{
  return I2C_ping_composant(AT24C32_ID);
}

void AT24C32_lecture(uint16_t adresse, uint8_t nb_octets, uint8_t buffer[])
//lecture de n octets à partir d'une certaine adresse de l'EEPROM
{
  uint8_t buffer_adresse[2];

  buffer_adresse[0] = adresse >> 8;  //adresse MSB
  buffer_adresse[1] = adresse & 255; //adresse LSB
  I2C_ecriture(AT24C32_ID, 2, buffer_adresse);
  I2C_lecture(AT24C32_ID, nb_octets, buffer);
}

void AT24C32_ecriture(uint8_t adresse, uint8_t nb_octets, uint8_t buffer[])
//ecriture de n octets à partir d'une certaine adresse de l'EEPROM
{
  uint8_t buffer_adresse[2];

  buffer_adresse[0] = adresse >> 8;  //adresse MSB
  buffer_adresse[1] = adresse & 255; //adresse LSB
  I2C_ecriture_2paquets(AT24C32_ID, 2, buffer_adresse, nb_octets, buffer);
  delay(10);  // d'après Twr du datasheet AT24C32 : le laisser finaliser l'écriture
}

Partie 2

//*********************************************************************
//Fonctions de test
//*********************************************************************

void Test_DS1307()
{
  uint8_t a,m,j,js,hh,mm,ss, i, buffer[1];

//test de présence
  Serial.println("Test du circuit RTC DS1307...");
  if (DS1307_ping()) {
    Serial.println("Non trouve !");
    Serial.print("Verifier la signification du code retour ");
    Serial.println(DS1307_ping());
    Serial.println("http://arduino.cc/en/Reference/WireEndTransmission");
    return;
  }
  Serial.println("Present !");

  DS1307_init_horloge();

//lecture de l'horloge pendant 10 secondes
//puis forçage à une valeur par défaut
//puis à nouveau lecture pendant 10 secondes
//==> verifier la persistance après mise hors tension
  for (i=0;i<20;i++)
  {
    Serial.print("Lecture horloge : ");
    DS1307_lecture_horloge(&a,&m,&j,&js,&hh,&mm,&ss);
    switch (js)
    {
      case 1 : Serial.print("lundi ");break;
      case 2 : Serial.print("mardi ");break;
      case 3 : Serial.print("mercredi ");break;
      case 4 : Serial.print("jeudi ");break;
      case 5 : Serial.print("vendredi ");break;
      case 6 : Serial.print("samedi ");break;
      case 7 : Serial.print("dimanche ");break;
    }
    if (j<10) Serial.print('0');
    Serial.print(j);
    Serial.print('/');
    if (m<10) Serial.print('0');
    Serial.print(m);
    Serial.print("/20");
    if (a<10) Serial.print('0');
    Serial.print(a);
    Serial.print(' ');
    if (hh<10) Serial.print('0');
    Serial.print(hh);
    Serial.print(':');
    if (mm<10) Serial.print('0');
    Serial.print(mm);
    Serial.print(':');
    if (ss<10) Serial.print('0');
    Serial.println(ss);
    delay(1000);
    if (i==9) {
       Serial.println("Ecriture horloge : mardi 09/07/2013 19:40:17");
       DS1307_ecriture_horloge(13,7,9,2,19,40,17);
       delay(1000);
    }
  }

//test de lecture ecriture en NVRAM
//valeurs et adresse au pif
//==> verifier la persistance après mise hors tension
  for (i=0;i<3;i++) {
    Serial.print("Lecture NVRAM adresse 10 : ");
    DS1307_lecture(10,1,buffer);
    Serial.println(buffer[0]);
    if (buffer[0] == 67) {
      buffer[0] = 116;
    } else {
      buffer[0] = 67;
    }
    Serial.print("Ecriture NVRAM adresse 10 : ");
    Serial.println(buffer[0]);
    DS1307_ecriture(10,1,buffer);
  }

}

void Test_AT24C32()
{
  uint8_t i, buffer[1];

//test de présence
  Serial.println("Test du circuit EEPROM AT24C32...");
  if (AT24C32_ping()) {
    Serial.println("Non trouve !");
    Serial.print("Verifier la signification du code retour ");
    Serial.println(AT24C32_ping());
    Serial.println("http://arduino.cc/en/Reference/WireEndTransmission");
    return;
  }
  Serial.println("Present !");

//test de lecture ecriture en EEPROM
//valeurs et adresse au pif
//==> verifier la persistance après mise hors tension
  for (i=0;i<3;i++) {
    Serial.print("Lecture EEPROM adresse 10 : ");
    DS1307_lecture(10,1,buffer);
    Serial.println(buffer[0]);
    if (buffer[0] == 67) {
      buffer[0] = 116;
    } else {
      buffer[0] = 67;
    }
    Serial.print("Ecriture EEPROM adresse 10 : ");
    Serial.println(buffer[0]);
    DS1307_ecriture(10,1,buffer);
  }
}

void setup()
{
  Serial.begin(9600); //on n'est pas pressé
  delay(5000); //...le temps d'ouvrir le moniteur série
  Serial.println("Programme de test de circuit TinyRTC");
  I2C_init();
  Test_DS1307();
  Serial.println();
  Test_AT24C32();
  Serial.println();
  Serial.println("Fin de test. Effectuer une mise hors tension et recommencer pour verifier la stabilite des valeurs");
}

void loop()
{
  delay(1000);
}

bricoleau: Comme promis voici un programme qui permet de vérifier le bon fonctionnement d'un Tiny RTC.

bonsoir c'est une bonne initiative, mais des codes simples "1307 dedicated " , ce n'est pas ce qui manque :grin:

attendons de voir, s'il... revient comment le problème aura été finalement résolu par paulaubry33 8)