surement encore un topic sur horloge 1307

Bonjour tout le monde,
j’ai reçu voici 3 jours ma carte horloge ds1307
et voila que je n’arrive pas a la faire fonctionner
j’ai utiliser et rechercher sur le net une solution mais je n’ai rien trouver de convainquant
j’ai essayer les library ds1307new.h; ds1307.h et RTClib.h
le seul qui pourrait faire croire que cela fonctionne est celui ci:

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

uint8_t rw = 25;
LiquidCrystal lcd(23,27,29,31,33,35); 
RTC_Millis RTC;

void setup () {
    Serial.begin(57600);
    // following line sets the RTC to the date & time this sketch was compiled
    RTC.begin(DateTime(__DATE__, __TIME__));
    if (rw != 255) {
		pinMode(rw,OUTPUT);
		digitalWrite(rw,LOW);
	}
  lcd.begin(20, 4);
  lcd.clear();
}



void loop () {
    DateTime now = RTC.now();
    
     lcd.setCursor(0, 0);
 lcd.print("il est: ");
  if (now.hour()<10)
 {
  lcd.print("0");
 lcd.print(now.hour(),DEC);
 }
 else
 {
   lcd.print(now.hour(),DEC);
 }
 
  lcd.print(":");
   if (now.minute()<10)
 {
  lcd.print("0");
 lcd.print(now.minute(),DEC);
 }
 else
 {
   lcd.print(now.minute(),DEC);
 }
 
 lcd.print(".");
 
 if (now.second()<10)
 {
  lcd.print("0");
 lcd.print(now.second(),DEC);
 }
 else
 {
   lcd.print(now.second(),DEC);
 }
 
 lcd.print("s");
 
 lcd.setCursor(0, 1);
 lcd.print("nous sommes le: ");
 
 lcd.setCursor(4, 2);
 if (now.day()<10)
 {
  lcd.print("0");
 lcd.print(now.day(),DEC);
 }
 else
 {
   lcd.print(now.day(),DEC);
 }
 lcd.print("/");
 
 if (now.month()<10)
 {
  lcd.print("0");
 lcd.print(now.month(),DEC);
 }
 else
 {
   lcd.print(now.month(),DEC);
 }
 lcd.print("/");
 lcd.print(now.year(),DEC);
 
 
    Serial.print(now.year(), DEC);
    Serial.print('/');
    Serial.print(now.month(), DEC);
    Serial.print('/');
    Serial.print(now.day(), DEC);
    Serial.print(' ');
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();
    
    
    
    Serial.println();
    delay(100);
}

mais helas j’ai bien peur que le programme ne lise pas le ds1307 tout juste sa mémoire
lorsque je coupe l’alim et que je la remet je retrouve l’heure de mon premier transfert
avec tous les autres programmes essayé je n’ai que des codes d’erreur
si vous avez une solution a me proposer …
merci d’avance

Bonjour,

complicyte1: j'ai reçu voici 3 jours ma carte horloge ds1307 et voila que je n'arrive pas a la faire fonctionner j'ai utiliser et rechercher sur le net une solution mais je n'ai rien trouver de convainquant j'ai essayer les library ds1307new.h; ds1307.h et RTClib.h le seul qui pourrait faire croire que cela fonctionne est celui ci:

Si tu veut tester ton DS1307 tu peut essayer mon code n'utilisant aucune librairie : http://skyduino.wordpress.com/2012/01/07/tutoriel-arduino-horloge-rtc-ds1307-librairie-liquidcrystal/

complicyte1: mais helas j'ai bien peur que le programme ne lise pas le ds1307 tout juste sa mémoire lorsque je coupe l'alim et que je la remet je retrouve l'heure de mon premier transfert avec tous les autres programmes essayé je n'ai que des codes d'erreur

Vu le code que tu nous donne c'est normal, il reprogramme le DS1307 avec la même heure à chaque redémarrage ;) Tente avec mon code, et si cela ne marche toujours pas, vérifie que ton DS1307 à bien une pile de sauvegarde en état de marche, que les cablage sont correcte et qu'il y a bien les résistances de tirage à +VCC sur SDA et SCL.

salut

le code suivant fonctionne chez moi, il est basé sur l’exemple fourni avec la lib ds1703.h qu’il utilise.

tu lance le port série, et tu envoie les commandes de type h21 pour régler l’heure sur 21h, m20 pour les minutes sur 20m, s** pour les secondes, j0* pour le numéro du jour de la semaine, D** pour la date, M** le mois et A** l’année

tout autre caractère provoque la lecture de la date, qui est renvoyée sur le port série

#include <WProgram.h>
#include <Wire.h>
#include <DS1307.h> // written by  mattt on the Arduino forum and modified by D. Sjunnesson

void setup()
{
  Serial.begin(9600);

 /*
  RTC.stop();
  RTC.set(DS1307_SEC,1);        //set the seconds
  RTC.set(DS1307_MIN,23);     //set the minutes
  RTC.set(DS1307_HR,12);       //set the hours
  RTC.set(DS1307_DOW,4);       //set the day of the week
  RTC.set(DS1307_DATE,5);       //set the date
  RTC.set(DS1307_MTH,3);        //set the month
  RTC.set(DS1307_YR,9);         //set the year
  RTC.start();
*/
}
int valeur=0;
int commande=0;
char truc[10];
int i=0;

void loop()
{

  if (Serial.available())      // Look for char in serial que and process if found
    {     
      
      commande = Serial.read();
      
      Serial.println(commande);
      
      for (i=0;i<2;i++) {
      //do {
	truc[i]=Serial.read();
	Serial.print("truc[");
	Serial.print(i,DEC);
	Serial.print("] = ");
	Serial.println(truc[i],DEC);
      }
      //while(truc[i]>0);
      
      Serial.print(" i = ");
      Serial.println(i,DEC);
      
      Serial.print(" truc =  ");
      Serial.println(truc);
      
      
      
      valeur = (byte) ((truc[0]-48)*10 + (truc[1]-48)); //-48 car la valeur ascii des chiffres =48 pour zero

      switch (commande) {
	case 'h' :      // If command = "T" Set Date
	  RTC.set(DS1307_HR,valeur);
	  Serial.print("champ heures regle sur ");
	  Serial.print(valeur,DEC);
	  Serial.println("");
	  break;
	case 'm' :     
	  RTC.set(DS1307_MIN,valeur);
	  Serial.print("champ minutes regle sur ");
	  Serial.print(valeur,DEC);
	  Serial.println(""); 
	  break;
	case 's' :     
	  RTC.set(DS1307_SEC,valeur);
	  Serial.print("champ secondes regle sur ");
	  Serial.print(valeur,DEC);
	  Serial.println("");
	  break;	 
	case 'D' :     
	  RTC.set(DS1307_DATE,valeur);
	  Serial.print("champ date regle sur ");
	  Serial.print(valeur,DEC);
	  Serial.println("");
	  break;  
	case 'j' :     
	  RTC.set(DS1307_DOW,valeur);
	  Serial.print("champ jour regle sur ");
	  Serial.print(valeur,DEC);
	  Serial.println("");
	  break;  
	case 'M' :     
	  RTC.set(DS1307_MTH,valeur);
	  Serial.print("champ mois regle sur ");
	  Serial.print(valeur,DEC);
	  Serial.println("");
	  break;  
	case 'A' :     
	  RTC.set(DS1307_YR,valeur);
	  Serial.print("champ annee regle sur ");
	  Serial.print(valeur,DEC);
	  Serial.println("");
	  break;  
	default :
	 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.print(RTC.get(DS1307_YR,false)); //read year 
  Serial.println();
	  break;
      }
    }
    else {   
        
   /* 

  delay(1000);*/
    }
}

bonjour,

le code suivant fonctionne chez moi, il est basé sur l'exemple fourni avec la lib ds1703.h qu'il utilise.

le code fonctionne

des trucs très bizarre avec ma carte ds1307 tout d'abord la première fois que j'ai fais le transfert du programme vers arduino tout ok j'ai débranché rebranché heure 0:0:0 vérifié la batterie voltmètre 3.5v donc ok je rebranche le tout reglage je m’aperçois que les seconde defilent a chaque partie de reglage heure réglé je dé/rebranche cette fois ci ok je modifie un peut le programme pour l'afficheur tout ok je coupe l'alim et je rallume et la !!! 0:0:0 je change la batterie avec une de pc que j'avais je la change sans couper l'alim au moment ou je retire la batterie lcd affiche l'heure en mémoire mais sans défiler

moralité l'heure ne bouge pas (pratique quand on se repose ;) mais pas au boulot :drooling_face: ) a chaque fois que je débranche et je rebranche 0:0:0 si je retire la batterie l' heure reviens j'ai peur que ce soit ma ds qui merde ....

bonsoir

Tente avec mon code, et si cela ne marche toujours pas, vérifie que ton DS1307 à bien une pile de sauvegarde en état de marche, que les cablage sont correcte et qu'il y a bien les résistances de tirage à +VCC sur SDA et SCL.

merci de la réponse avant de faire un post j'avais bien vu ton code qui m'a l'air super mais un peu hard pour moi ( quand cela fonctionne j'arrive a le mettre a ma sauce, mais quand cela ne fonctionne pas c'est plus compliqué) pour les résistances c'est une carte toute faite acheté sur Ebay le montage est correct de plus je branche derriere une autre carte i2c qui fonctionne pour la batterie voir la réponse du post suivant merci

Nouvelle version, j’ai amélioré mon programme dans le train ce matin, il est bien plus simple à utiliser maintenant (message explicatif, nettoyage du code, ajout de commentaires plus clairs) :

/*Sketch de lecture et programmation pour horloge RTC I2C DS1307
 * utilise la librairie DS1307 disponible sur le forum arduino,et basé sur l'exemple fourni
 * avec la lib.
 * Librairie DS1307 fournie par mattt et D. Sjunnesson
 * 
 * Programme sous licence GNU GPL
 * 
 * (c) bricofoy 2012
 */

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

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

int valeur=0;
int commande=0;
char truc[2];	//buffer de lecture des valeurs
int i=0;

// explication de l'utilisation
void usage() {
  Serial.println("\nUSAGE : u U 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("\nListe des commandes : h** : heure, m** : minutes, s** : secondes, j0* : jour de la semaine");
  Serial.println("  D** : jour de la date, M** : mois, A** : annee.");
  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() {
      commande = Serial.read();
      Serial.print("   "); //ici on envoie 3 espaces sur le terminal, sans ça la lecture suivante est fausse
			   //sinon il faut envoyer un seul espace avec println et ça marche aussi
      for (i=0;i<2;i++) {
	truc[i]=Serial.read();
	Serial.print(" "); //idem que plus haut : un espace à envoyer sinon ça foire. Ici un seul suffit.
      }
 
      valeur = byte((truc[0]-48)*10 + (truc[1]-48)); //-48 car la valeur ascii des chiffres =48 pour le 0, =49 pour le 1, etc 

      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;
	default :
	  break;
      }
      lecture_RTC();
}

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

concernant ton soucis de DS1307 qui se remet à 0:0:0, attention j’ai remarqué que ça arrive quand utilise les fonctions RTC.start() et RTC.stop() de la lib DS1307

les utilises-tu dans ton programme ?

essayes avec mon code, au boot il envoie l’heure, sinon pour afficher l’heure sans rien programmer il suffit d’envoyer un caractère autre que ceux des commandes.

J'ai essayé mon module aujourd'hui et j'en ai profité pour tester ton code. Pas de problème il fonctionne.

Il arrive parfois que je recoive des trames eronnées :

Heure actuelle : 17:56:13 4 20/2/2012 Heure actuelle : 25:52:8 7 165/45/2165 (???)

Problème de parasite, un delay à mettre qq part ? J'ai le même problème avec d'autres codes par moment.

A+

Curieux. Est-ce juste une erreur de lecture, où est-ce que c'est le DS1307 qui a perdu l'heure ? (la trame suivante est Ok même sans reréglage de l'heure ou pas ? )

la trame suivante est Ok même sans reréglage de l’heure ou pas ?

Oui

ok donc c'est juste un soucis de lecture. Là comme ça je ne sais pas d'où ça peut venir, peut-être la librairie DS1307 qui déconne. Je suis en train de corriger la librairie pour la faire marcher sur l'IDE 1.0, je verrai à l'occasion si je trouve une erreur.

Merci pour l'info en tout cas :)

J’ai ce code sous 1.0

/*
  RealTimeClockDS1307 - library to control a DS1307 RTC module
  Copyright (c) 2011 David H. Brown. All rights reserved
  
  Much thanks to John Waters and Maurice Ribble for their
  earlier and very helpful work (even if I didn't wind up
  using any of their code):
   - http://combustory.com/wiki/index.php/RTC1307_-_Real_Time_Clock
   - http://www.glacialwanderer.com/hobbyrobotics/?p=12

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


#include <Wire.h>
#include <RealTimeClockDS1307.h>

//RealTimeClock RTC;//=new RealTimeClock();

#define Display_Clock_Every_N_Seconds 1
#define Display_ShortHelp_Every_N_Seconds 25
//#define TEST_Squarewave
//#define TEST_StopStart
//#define TEST_1224Switch

int count=0;
char formatted[] = "00-00-00 00:00:00x";

void setup() {
//  Wire.begin();
  Serial.begin(9600);
}
 
void loop() {
  if(Serial.available())
  {
    processCommand();
  }
  delay(1000);
  RTC.readClock();
  count++;
  if(count % Display_Clock_Every_N_Seconds == 0){
    Serial.print(count);
    Serial.print(": ");
    RTC.getFormatted(formatted);
    Serial.print(formatted);
    Serial.println();
  }
  
  if(count % Display_ShortHelp_Every_N_Seconds == 0) {
    Serial.println("Send ? for a list of commands.");
  }
#ifdef TEST_Squarewave
if(count%10 == 0)
{
  switch(count/10 % 6)
  {
    case 0:
    Serial.print("Squarewave disabled (low impedance): ");
    RTC.sqwDisable(0);
    Serial.println((int) RTC.readData(7));
    break;
    case 1:
    Serial.print("Squarewave disabled (high impedance): ");
    RTC.sqwDisable(1);
    Serial.println((int) RTC.readData(7));
    break;
    case 2:
    Serial.println("Squarewave enabled at 1 Hz");
    RTC.sqwEnable(RTC.SQW_1Hz);
    break;
    case 3:
    Serial.println("Squarewave enabled at 4.096 kHz");
    RTC.sqwEnable(RTC.SQW_4kHz);
    break;
    case 4:
    Serial.println("Squarewave enabled at 8.192 kHz");
    RTC.sqwEnable(RTC.SQW_8kHz);
    break;
    case 5:
    Serial.println("Squarewave enabled at 32.768 kHz");
    RTC.sqwEnable(RTC.SQW_32kHz);
    break;
    default:
    Serial.println("Squarewave test not defined");
  }//switch
}
#endif

#ifdef TEST_StopStart
if(count%10 == 0)
{
  if(!RTC.isStopped()) 
  {
    if(RTC.getSeconds() < 45) 
    {
      Serial.println("Stopping clock for 10 seconds");
      RTC.stop();
    }//if we have enough time
  } else {
    RTC.setSeconds(RTC.getSeconds()+11);
    RTC.start();
    Serial.println("Adding 11 seconds and restarting clock");
  }
}//if on a multiple of 10 counts
#endif

#ifdef TEST_1224Switch  
  if(count%10 == 0)
  {
    if(count %20 == 0)
    {
      Serial.println("switching to 12-hour time");
      RTC.switchTo12h();
      RTC.setClock();
    }
    else
    {
      Serial.println("switching to 24-hour time");
      RTC.switchTo24h();
      RTC.setClock();
    }
  }
#endif
}

void processCommand() {
  if(!Serial.available()) { return; }
  char command = Serial.read();
  int in,in2;
  switch(command)
  {
    case 'H':
    case 'h':
    in=SerialReadPosInt();
    RTC.setHours(in);
    RTC.setClock();
    Serial.print("Setting hours to ");
    Serial.println(in);
    break;
    case 'I':
    case 'i':
    in=SerialReadPosInt();
    RTC.setMinutes(in);
    RTC.setClock();
    Serial.print("Setting minutes to ");
    Serial.println(in);
    break;
    case 'S':
    case 's':
    in=SerialReadPosInt();
    RTC.setSeconds(in);
    RTC.setClock();
    Serial.print("Setting seconds to ");
    Serial.println(in);
    break;
    case 'Y':
    case 'y':
    in=SerialReadPosInt();
    RTC.setYear(in);
    RTC.setClock();
    Serial.print("Setting year to ");
    Serial.println(in);
    break;
    case 'M':
    case 'm':
    in=SerialReadPosInt();
    RTC.setMonth(in);
    RTC.setClock();
    Serial.print("Setting month to ");
    Serial.println(in);
    break;
    case 'D':
    case 'd':
    in=SerialReadPosInt();
    RTC.setDate(in);
    RTC.setClock();
    Serial.print("Setting date to ");
    Serial.println(in);
    break;
    case 'W':
    Serial.print("Day of week is ");
    Serial.println((int) RTC.getDayOfWeek());
    break;
    case 'w':
    in=SerialReadPosInt();
    RTC.setDayOfWeek(in);
    RTC.setClock();
    Serial.print("Setting day of week to ");
    Serial.println(in);
    break;
    
    case 't':
    case 'T':
    if(RTC.is12hour()) {
      RTC.switchTo24h();
      Serial.println("Switching to 24-hour clock.");
    } else {
      RTC.switchTo12h();
      Serial.println("Switching to 12-hour clock.");
    }
    RTC.setClock();
    break;
    
    case 'A':
    case 'a':
    if(RTC.is12hour()) {
      RTC.setAM();
      RTC.setClock();
      Serial.println("Set AM.");
    } else {
      Serial.println("(Set hours only in 24-hour mode.)");
    }
    break;
    
    case 'P':
    case 'p':
    if(RTC.is12hour()) {
      RTC.setPM();
      RTC.setClock();
      Serial.println("Set PM.");
    } else {
      Serial.println("(Set hours only in 24-hour mode.)");
    }
    break;

    case 'q':
    RTC.sqwEnable(RTC.SQW_1Hz);
    Serial.println("Square wave output set to 1Hz");
    break;
    case 'Q':
    RTC.sqwDisable(0);
    Serial.println("Square wave output disabled (low)");
    break;
    
    case 'z':
    RTC.start();
    Serial.println("Clock oscillator started.");
    break;
    case 'Z':
    RTC.stop();
    Serial.println("Clock oscillator stopped.");
    break;
    
    case '>':
    in=SerialReadPosInt();
    in2=SerialReadPosInt();
    RTC.writeData(in, in2);
    Serial.print("Write to register ");
    Serial.print(in);
    Serial.print(" the value ");
    Serial.println(in2);
    break;    
    case '<':
    in=SerialReadPosInt();
    in2=RTC.readData(in);
    Serial.print("Read from register ");
    Serial.print(in);
    Serial.print(" the value ");
    Serial.println(in2);
    break;

    default:
    Serial.println("Unknown command. Try these:");
    Serial.println(" h## - set Hours       d## - set Date");
    Serial.println(" i## - set mInutes     m## - set Month");
    Serial.println(" s## - set Seconds     y## - set Year");
    Serial.println(" w## - set arbitrary day of Week");
    Serial.println(" t   - toggle 24-hour mode");
    Serial.println(" a   - set AM          p   - set PM");
    Serial.println();
    Serial.println(" z   - start clock     Z   - stop clock");
    Serial.println(" q   - SQW/OUT = 1Hz   Q   - stop SQW/OUT");
    Serial.println();
    Serial.println(" >##,###  - write to register ## the value ###");
    Serial.println(" <##      - read the value in register ##");
    
  }//switch on command
  
}

//read in numeric characters until something else
//or no more data is available on serial.
int SerialReadPosInt() {
  int i = 0;
  boolean done=false;
  while(Serial.available() && !done)
  {
    char c = Serial.read();
    if (c >= '0' && c <='9')
    {
      i = i * 10 + (c-'0');
    }
    else 
    {
      done = true;
    }
  }
  return i;
}

Et avec celui-çi j’ai également des erreurs :

1: FF-1F-3F 1F:73:32P
2: 12-02-20 21:39:33
3: 12-02-20 21:39:34
4: 12-02-20 21:39:35
5: 1F-02-20 21:39:36
6: 12-02-20 21:39:37
7: FF-02-20 21:39:38
8: 12-02-20 21:39:39
9: FF-03-20 21:39:40
10: 12-02-20 21:39:41
11: 12-02-20 21:39:42
12: FF-1F-3F 1F:3F:43P
13: 1F-02-20 21:39:44
14: 12-02-20 21:39:45
15: 12-02-20 21:39:46
16: 12-02-20 21:39:47
17: 12-02-20 21:39:48
18: 12-02-20 21:39:49
19: 12-02-20 21:39:50
20: 12-02-20 21:39:51
21: FF-1F-3F 21:39:52
22: 12-02-20 21:39:53
23: 12-02-20 21:39:54
24: 12-02-20 21:39:55
25: 12-02-20 21:39:56

ok, donc si avec une lib totalement différente il y a le même problème, je penche plutot pour une erreur de communication au niveau de l'I2C. Tes résistance de pull-up ont des valeurs normales ? Tu n'as pas par exemple deux dispositifs I2C incluant les résistance de pull-up ? (un seul des éléments du bus I2C doit les avoir normalement, sinon les résistances se divisent et donnent au final une valeur trop faible)

/*Sketch de lecture et programmation pour horloge RTC I2C DS1307
 * utilise la librairie DS1307 disponible sur le forum arduino,et basé sur l'exemple fourni
 * avec la lib.
 * Librairie DS1307 fournie par mattt et D. Sjunnesson
 * 
 * Programme sous licence GNU GPL
 * 
 * (c) bricofoy 2012
 */

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

#include <LiquidCrystal.h> // librairy du lcd

uint8_t rw = 25; // broche du read/wrtie du lcd
LiquidCrystal lcd(23,27,29,31,33,35);  / le brochage sur la mega

void setup() {
  Serial.begin(9600);
   if (rw != 255) {  //
		pinMode(rw,OUTPUT);
		digitalWrite(rw,LOW);
	}
  lcd.begin(20, 4);
  lcd.clear();
  usage();
  lecture_RTC();

}
int jour=1;
int valeur=0;
int commande=0;
char truc[2];	//buffer de lecture des valeurs
int i=0;

// explication de l'utilisation
void usage() {
  Serial.println("\nUSAGE : u U 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("\nListe des commandes : h** : heure, m** : minutes, s** : secondes, j0* : jour de la semaine");
  Serial.println("  D** : jour de la date, M** : mois, A** : annee.");
  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() {
      commande = Serial.read();
      Serial.print("   "); //ici on envoie 3 espaces sur le terminal, sans ça la lecture suivante est fausse
			   //sinon il faut envoyer un seul espace avec println et ça marche aussi
      for (i=0;i<2;i++) {
	truc[i]=Serial.read();
	Serial.print(" "); //idem que plus haut : un espace à envoyer sinon ça foire. Ici un seul suffit.
      }
 
      valeur = byte((truc[0]-48)*10 + (truc[1]-48)); //-48 car la valeur ascii des chiffres =48 pour le 0, =49 pour le 1, etc 

      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;
	default :
	  break;
      }
      lecture_RTC();
}


void loop() {
   if (Serial.available()) {
     ecriture_RTC();
   }
     
     lcd.setCursor(0, 0);  
  lcd.print(RTC.get(DS1307_HR,true)); //read the hour and also update all the values by pushing in true
   lcd.print(":");
   lcd.print(RTC.get(DS1307_MIN,false));//read minutes without update (false)
   lcd.print(":");
   lcd.print(RTC.get(DS1307_SEC,false));//read seconds
   lcd.setCursor(0,1);                
   jour=RTC.get(DS1307_DOW,false);
    switch(jour) { // Affiche sur 3 lettres le jour en cours
	  case 1:
	    lcd.print("LUN ");
	    break;
	 
	  case 2:
	    lcd.print("MAR ");
	    break;
	 
	  case 3:
	    lcd.print("MER ");
	    break;
	 
	  case 4:
	    lcd.print("JEU ");
	    break;
	 
	  case 5:
	    lcd.print("VEN ");
	    break;
	 
	  case 6:
	    lcd.print("SAM ");
	    break;
	 
	  case 7:
	    lcd.print("DIM ");
	    break;
	  }
lcd.setCursor(5,1);
   lcd.print(RTC.get(DS1307_DATE,false));//read date
   lcd.print("/");
   lcd.print(RTC.get(DS1307_MTH,false));//read month
   lcd.print("/");
   lcd.print(RTC.get(DS1307_YR,false));
     
     
     
    
}

j’ai toujours mon probleme de 0:0:0 mais pas tout le temps
mais surtout toujours pas d’incrémentation des secondes
mise a l’heure a 20:11:11 , il est 22:00 et toujours sur mon afficheur 20:11:11

J’ai ce code sous 1.0

ou as tu trouve la librairy RealTimeClockDS1307.h

complicyte1: j'ai toujours mon probleme de 0:0:0 mais pas tout le temps mais surtout toujours pas d'incrémentation des secondes mise a l'heure a 20:11:11 , il est 22:00 et toujours sur mon afficheur 20:11:11

Curieux.

Avec mon code, essayes de rajouter RTC.start(); à la fin de la fonction setup() pour s'assurer du démarrage de l'horloge.

ATTENTION avec mon code il y a une erreur possible lors de la lecure du port série pour la mise à l'heure (c'était mon premier essai de lecture du port série... :P ). Je suis en train de le corriger, ainsi que de corriger la lib DS1307.h que j'ai employé pour la faire fonctionner sur arduino1.0

Je posterai demain le code et la lib corrigée, pour le moment, dodo !

ou as tu trouve la librairy RealTimeClockDS1307.h

Ici : https://github.com/davidhbrown/RealTimeClockDS1307

@ Bricofoy

Je regarderais demain les soudures et resistances. C'est le seul dispositif connecté sur ma mega,j'ai justement enlevé le reste.

J'utilise ce module :

Voila la version qui marche de mon code.

Il y a deux problèmes connus (je suis en train de corriger la lib) : lors du démarrage de l’horloge les secondes sont remises à 0, et lors de la modif d’une valeur sans avoir fait une lecture avant, toutes les valeurs sont re-écrites à celles de la dernière lecture… c’est un peu gênant :confused:

Je posterai la lib corrigée et modifiée pour arduino1.0 (pour le moment je l’ai modifiée pour 1.0 mais les deux bugs ne sont pas corrigés)

/*Sketch de lecture et programmation pour horloge RTC I2C DS1307
 * utilise la librairie DS1307 disponible sur le forum arduino,et basé sur l'exemple fourni
 * avec la lib.
 * Librairie DS1307 fournie par mattt et D. Sjunnesson
 * 
 * Programme sous licence GNU GPL
 * 
 * (c) bricofoy 2012
 */


// This is for compatibility with both arduino 1.0 and previous 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. Attention au demarrage les secondes sont remises à 0");
  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();
    }
}

http://bricofoy.free.fr/forums/arduino/DS1307.zip

voila la nouvelle version de la lib DS1307 corrigée pour fonctionner avec arduino 1.0 ou les anciennes versions.

Correction de bugs : -arret/mise en route de l'horloge ne remet plus les secondes à zéro -modification de l'horloge est effectuée correctement même si l'horloge est en route

pour moi tout est ok

un très grand merci à vous tous !!!!! :)

Merci pour ta mise à jour :slight_smile:

Une question, comment peut on stocker la valeur des minutes dans une variable pour déclencher un evenement à h+15 par exemple ?
Je ne trouve pas la syntaxe.

++