horloge à temp réel (DS1307) et pic 18F452

[invitedf6fcb20]

Bonjour.
Est ce que quelqu'un pourrait m'expliquer ces différentes lignes de code s'il vous plait ?

#include <p18f452.h>
#include <delays.h>
#include<stdio.h>
#include<i2c.h>
#include"lcdpd2p.h"

#pragma config WDT = OFF

int octetrecu1;
int octetrecu2;
int octetrecu3;
int octetrecu4;
int octetrecu5;
int octetrecu6;
int octetrecu7;
int octetrecu8;



/////////////////////////////////////////////////////////////
// PROTOTYPE //
/////////////////////////////////////////////////////////////

void ack(void);
void init_I2C(void);
void read_trameI2C(int *octet1, int *octet2, int *octet3, int *octet4,int *octet5, int *octet6, int *octet7, int *octet8);
void tempo(unsigned int count);
unsigned int SWReadI2C( void );

/////////////////////////////////////////////////////////////
// read_tram_i2c(); //
/////////////////////////////////////////////////////////////

void read_trameI2C(int *octet1, int *octet2, int *octet3, int *octet4,int *octet5, int *octet6, int *octet7, int *octet8)
{
*octet1 = ReadI2C();
SSPCON2bits.ACKEN = 1;
ack();
*octet2 = ReadI2C();
SSPCON2bits.ACKEN = 1;
ack();
*octet3 = ReadI2C();
SSPCON2bits.ACKEN = 1;
ack();
*octet4 = ReadI2C();
SSPCON2bits.ACKEN = 1;
ack();
*octet5 = ReadI2C();
SSPCON2bits.ACKEN = 1;
ack();
*octet6 = ReadI2C();
SSPCON2bits.ACKEN = 1;
ack();
*octet7 = ReadI2C();
SSPCON2bits.ACKEN = 1;
ack();
*octet8 = ReadI2C();
}


////////////////////////////////////////////////////////////////////////
// TEST ACK //
////////////////////////////////////////////////////////////////////////

void ack(void)
{
IdleI2C();
while (SSPCON2bits.ACKSTAT);
}

////////////////////////////////////////////////////////////////////////
// TEMPO //
////////////////////////////////////////////////////////////////////////

void tempo(unsigned int compte)
{
while (compte--);
}

/////////////////////////////////////////////////////////////
// INITIALISATION I2C //
/////////////////////////////////////////////////////////////

void init_I2C(void)
{
DDRCbits.RC3=1;
DDRCbits.RC4=1;
SSPCON1=0x28;

SSPSTATbits.SMP=1;

SSPADD=9;
}

/////////////////////////////////////////////////////////////
// Fonction Principale //
/////////////////////////////////////////////////////////////

void main(void)
{

int Valeur = 1;
InitLCD();
stdout = _H_USER;

init_I2C();
IdleI2C();

StartI2C();
while (SSPCON2bits.RSEN);

WriteI2C(0xD0);
ack();

WriteI2C(0x00);
ack();

WriteI2C(0x00);
ack();

WriteI2C(0x01);
ack();

WriteI2C(0x00);
ack();

WriteI2C(0x02);
ack();

WriteI2C(0x51);
ack();

WriteI2C(0x03);
ack();

WriteI2C(0x03);
ack();

WriteI2C(0x04);
ack();

WriteI2C(0x11);
ack();

WriteI2C(0x05);
ack();

WriteI2C(0x03);
ack();

WriteI2C(0x06);
ack();

WriteI2C(0x09);
ack();

WriteI2C(0x07);
ack();

WriteI2C(0x03);
ack();

StopI2C();

while (SSPCON2bits.PEN);

tempo(60000);

IdleI2C();

StartI2C();

while (SSPCON2bits.RSEN);

WriteI2C(0xD1);
ack();

////////////////////////////////////////////////////////////////////////
// lecture de la trame I2C //
////////////////////////////////////////////////////////////////////////

read_trameI2C(&octetrecu1, &octetrecu2, &octetrecu3, &octetrecu4, &octetrecu5, &octetrecu6, &octetrecu7, &octetrecu8);



////////////////////////////////////////////////////////////////////////
// CLOTURATION I2C //
////////////////////////////////////////////////////////////////////////

NotAckI2C(); // transmet l'acquittement du maître
while (SSPCON2bits.ACKEN); // attend fin de l'acquittement

StopI2C(); // initialise une stop-condition

while (SSPCON2bits.PEN); // attend fin de stop-condition
printf("=%X", octetrecu1);
printf("=%X", octetrecu2);
printf("=%X", octetrecu3);
printf("=%X", octetrecu4);
printf("=%X", octetrecu5);
Gotoxy(0,1);
printf("=%X", octetrecu6);
printf("=%X", octetrecu7);
printf("=%X", octetrecu8);
while(1); // boucle infinie
}

-----

[invite0b985a93]

Pour comprendre les lignes de code, tu peut regarder dans la datasheet de ta RTC. ils doivent surement expliquer comment doit s’opérer la communication I²C.
Aussi non cherche des tutos et des cours sur internet sur la communication I²C. Tu comprendras mieux le code

[invitedf6fcb20]

Je ne comprend la série writeI2C(0xXX).
Que ce passe t-il exactement ?

[invitefaaca50b]

writeI2C est la sequence d'ecriture via le bus I²C. tu selectionne un octet a envoyer et la sequence l'envoie. De meme ReadI2C lit les infos en provenance du bis I²C

[A voir en vidéo sur Futura]

[invitedf6fcb20]

Sur la doc technique du DS1307, j'ai trouvé ceci:

mais je ne comprend toujours pas
Le premier WriteI2C (0xD0) représente quoi au juste. C'est l'adresse de quoi exactement du périphérique attribué à l'interface PIC-DS1307 ?
Et ensuite, on envoie le registre sur lequelle on veut écrire, puis on envois la donnée à écrire ?
Par exemple:
WriteI2C(0x00);//registre des secondes
ack();

WriteI2C(0x00);//On affecte 0 secondes
ack();

Cela marcherait par deux par la suite ?

[invite0b985a93]

Regarde à la page 8 figure 7 de la datasheet.
Tu as un schéma qui t'explique quelle sont les étapes à faire pour lire les données dans ta RTC.

1) tu commence par envoyer l'adresse du "slave". càd que tu dis à qui tu veut parler (car tu peut avoir plusieurs CI sur un même bus i²C)
dans l'adresse, tu rajoute un 1 afin de dire que tu veut lire dans ta RTC (R/W)
2) ack
3) ensuite, tu peut lire les données sur ton bus I²C.
4) tu envoi un ack si tu veut passer au registre suivant. si tu as fini tu envoi à la place un non-ack

dans ton code ça correspondrai à ça:

StartI2C();

while (SSPCON2bits.RSEN);

WriteI2C(0xD1);
ack();

////////////////////////////////////////////////////////////////////////
// lecture de la trame I2C //
////////////////////////////////////////////////////////////////////////

read_trameI2C(&octetrecu1, &octetrecu2, &octetrecu3, &octetrecu4, &octetrecu5, &octetrecu6, &octetrecu7, &octetrecu8);



////////////////////////////////////////////////////////////////////////
// CLOTURATION I2C //
////////////////////////////////////////////////////////////////////////

NotAckI2C(); // transmet l'acquittement du maître
while (SSPCON2bits.ACKEN); // attend fin de l'acquittement

StopI2C(); // initialise une stop-condition

while (SSPCON2bits.PEN); // attend fin de stop-condition

Bon ça c’est pour la lecture des données.
Avant cette étape, tu dois penser à configurer ta RTC pour, par exemple, lancer le comptage des secondes minutes, heures,...
Pour ce faire tu doit faire comme suit: (voir figure 6 page 8)

1) tu commence par envoyer l'adresse du "slave". càd que tu dis à qui tu veut parler (car tu peut avoir plusieurs CI sur un même bus i²C)
dans l'adresse, tu rajoute une 0 afin de dire que tu veut écrire dans ta RTC (R/W)
2) ack
3) ensuite tu indique l'adresse du registre où tu veut écrire
4) ack
5) Ensuite tu peut écrire les données que tu compte introduire dans le registre (donc tu donne un nombre de 8bits)
6) tu envoi un ack si tu veut passer au registre suivant. si tu as fini tu envoi à la place un non-ack

Mais il existe une bonne panoplie de tutoriel sur la communication i²C sur internet. N'oublie pas que google est ton amis !

[paulfjujo]

bonjour,


voila l'equivalent en asm
tres facilement transposable en C , de la partie initialisation du RTC
si l'init reussi , la led connectée sur Pin7 doit osciller à 1Hz..
si ce n'est pas le cas, pas la peine d'aller voir plus loin.

Nota : dans cette initialisation, une configuration de date par defaut est installée.
ce qui permettra d'effectuer une lecture de la RTC , avant de passer à la phase ecriture reelle
de la date en cours...

Nota: il faut aussi que la pile (CR3020 ou autre ) de 3,6V soit connectée sur la PIN alim sauvegarde.

Init_RTC
	CALL STOP
	CALL DELAY_10mS	; 10mS
	CALL START
	MOVLW	0xD0	; B'11010000'=0xD0 = adresse device
       CALL OUT_BYTE
       CALL ACK
       clrf ADDR
       MOVF ADDR, W	; addresse registre
     	CALL OUT_BYTE
     	CALL ACK
     	MOVF SEC,W
     	CALL OUT_BYTE
     	CALL ACK
	MOVf MIN,W
     	CALL OUT_BYTE
     	CALL ACK
	Movf HEURE,w
     	CALL OUT_BYTE
     	CALL ACK
	Movf JourSem,w 		;day of the week
     	CALL OUT_BYTE
     	CALL ACK
	Movf Jour,w 	  	;date 02
     	CALL OUT_BYTE
      CALL ACK
 	MOVF Mois,W	   	;Mois 12
     	CALL OUT_BYTE
     	CALL ACK
	MOVF Annee,W		; ANNEE=5
     	CALL OUT_BYTE
     	CALL ACK
	MOVLW	B'10010000'   	;Registre de controle  SQWE=1 RS0=RS1=0 sortie 1Hz
     	CALL OUT_BYTE
     	CALL NACK
	call STOP
	CALL DELAY_10mS	; 10mS
      return
; a ce momment la led connectée sur pin7 doit osciller a 1HZ !

[invite5637435c]

Le premier WriteI2C (0xD0) représente quoi au juste. C'est l'adresse de quoi exactement du périphérique attribué à l'interface PIC-DS1307 ?

Il faut lire absolument la doc du composant DS1307, le protocole I2C y est résumé pour ce qui concerne le dialogue avec ce composant spécifique.
Vu ta questions je pense que tu n'as pas du tout lu ce document.
Pourtant il va falloir le faire ce petit effort sans quoi tu ne saura pas ce que le µC doit effectuer comme procédures pour récupérer les datas et les envoyer vers le DS1307.
@+

[invitedf6fcb20]

Pour le moment, je cible plutôt sur le lcd, mais j'y reviendrai à coup sur.
Merci pour les infos.

[invitedf6fcb20]

Pourriez-vous m'aider à retranscrire ce programme assembleur en c s'il vous plaît ?
Je n'ai jamais été très bon en assembleur, même si j'essaie d'y remédier.

Init_RTC
	CALL STOP
	CALL DELAY_10mS	; 10mS
	CALL START
	MOVLW	0xD0	; B'11010000'=0xD0 = adresse device
       CALL OUT_BYTE
       CALL ACK
       clrf ADDR
       MOVF ADDR, W	; addresse registre
     	CALL OUT_BYTE
     	CALL ACK
     	MOVF SEC,W
     	CALL OUT_BYTE
     	CALL ACK
	MOVf MIN,W
     	CALL OUT_BYTE
     	CALL ACK
	Movf HEURE,w
     	CALL OUT_BYTE
     	CALL ACK
	Movf JourSem,w 		;day of the week
     	CALL OUT_BYTE
     	CALL ACK
	Movf Jour,w 	  	;date 02
     	CALL OUT_BYTE
      CALL ACK
 	MOVF Mois,W	   	;Mois 12
     	CALL OUT_BYTE
     	CALL ACK
	MOVF Annee,W		; ANNEE=5
     	CALL OUT_BYTE
     	CALL ACK
	MOVLW	B'10010000'   	;Registre de controle  SQWE=1 RS0=RS1=0 sortie 1Hz
     	CALL OUT_BYTE
     	CALL NACK
	call STOP
	CALL DELAY_10mS	; 10mS
      return
; a ce momment la led connectée sur pin7 doit osciller a 1HZ !

void Init_RTC(void)
{
	StartI2C();					//Démarrage I2C
	WriteI2C(0b1101001);		//mode 7bits en écriture
	while(IdleI2C()==0);		//attente de la libération du bus I2C
	WriteI2C(0x00);				//On pointe le registre des seconde
	while(IdleI2C()==0);
	WriteI2C(0x00);				//La valeur 0 est affectée au registre des secondes
	while(IdleI2C()==0);
	WriteI2C(0x00);				//La valeur 0 est affectée au registre des minutes
	while(IdleI2C()==0);
	WriteI2C(0x12);				//La valeur 18 est affectée au registre des heures
	while(IdleI2C()==0);
	WriteI2C(0x05);				//La valeur 5 est affectée au registre des jour de la semaine
	while(IdleI2C()==0);
	WriteI2C(0x12);				//La valeur 18 est affectée au registre du jour du mois
	while(IdleI2C()==0);
	WriteI2C(0x03);				//La valeur 3 est affectée au registre du mois
	while(IdleI2C()==0);
	WriteI2C(0x07);				//La valeur 7 est affectée au registre des années
	while(IdleI2C()==0);
	Write(0b10010000);			//Registre de controle  SQWE=1 RS0=RS1=0 sortie 1Hz*
	NotAckI2C();
	StopI2C();					//Arret I2C
}