Programmation PIC16F1938

[invite93a8d3bd]

Bonjour à tous,

Je dois réaliser un petit projet. Il constitue a relier un PIC16f1938 à une carte LTC2990 qui permet de surveiller une tension un courant ou une température. La connexion des deux cartes se fait à l'aide d'un bus avec protocole I²C !!

Je pense avoir bien compris le système de fonctionnement de ce I²C.
J'ai commencer un petit code sous MPLAB qui me permettra de créer un fichier .h. Ce fichier .h sera enregistré quelque part sur mon ordi puis le bootloader du pic pourra le retrouver ,,, Je n'aurai qu'a la "balancer" dans le PIC.

Voici mon code avec des commentaires ...

#include <pic.h>

#define SDA RC4  
#define SCL RC3
#define	TRUE 1
#define	FALSE 0

void main ()
{
 //unsigned char adresse (1001100  ??)
 //unsigend char commande (00X11111 ??)
 
 TRISC=0x18;            //SCL et RDA mis à "1" -> inputs
 
 SSPCON1=SSPCON1|0x08;  //I²C Master mode 
 SSPCON2=SSPCON2&0x00;  //Tout à zéro sur le registre 2
 
 SSAPDD=10;             //Définition de l'horloge

 SMP=1;                 //Contrôle de la vitesse de balayage désactivé
 CKE=1;                 //Autorise niveaux logiques I²C
 
 SSPIF=0;               //clear interrupt flag
 BCLIF=0;               //clear bus collision flag

 SEN=1;                 //Start condition (met SDA à 0 et SCL à 1)


 //Adresser un esclave
 //R/W doit etre à 0

 if (!ACKSTAT)          //si ACK...
  {							  
  	ACKDT=0;			//...on transmet qu'il ya bien eu acknowledge
  }
 else
  {						   
  	ACKDT=1;             //sinon y en a pas eu
  }
  ACKEN=1;              //send acknowledge sequence avec la valeur de ACKDT
 
 TRISC=0x00;            //SCL et RDA mis à "0" -> outputs
 
 //Recupere 8bits de données (mode lecture)

 PEN=1;                 //Stop condition (met SDA à 1 et SCL à 1)
}

Mon probleme est de savoir comment adresser un esclave. comment je dis au pic daller interoger un esclave?

(d'autre questions suiveront)

Cordialement

MERCI POUR VOTRE AIDE
-----

[Jack]

Bonjour.

Il me semble que la moindre des choses quand on arrive dans un nouveau forum est de lire ses règles participatives:
http://forums.futura-sciences.com/programmation-langages-algorithmique/441632-regles-participatives-nouveau-forum.html

Donc, choisir le bon forum, mettre des balises code, etc.
En conséquence, déplacement en électronique.

[RISC]

Salut Yehouda

Tu peux trouver des notes d'applications et exemples de code I2C pour ton projet :

1/ Bootloader I2C pour PIC16F1xxx (AN1302)

2/ Hi-Speed UART Bootloader pour PIC16F1xxx (AN1310)

3/ Programme I2C Master pour PIC16F1xxx
Sur cette carte se trouve un capteur de temperature I2C (MCP9800) dont tu peux récupérer le code en bas de cette page.

En cherchant les cartes tu pourras trouver d'autres exemples I2C ;=)

a+

[invite93a8d3bd]

Merci je viens de voir un peu tous ça ... c'est du chinois Il y a des codes de partout dans des milliers de dossiers.
J'ai bien lu ceux mentionnant du I²C mais je n'ai pas compris grand chose. J'ai des notions en C mais de là à comprendre les codes
donnés en exemple ...

Je prefere donc avancer pas à pas sur mon code ...
Pouvez vous me dire si ce que j'ai fais est deja correct ?

Cordialement

[A voir en vidéo sur Futura]

[invite93a8d3bd]

J'en suis arrivé à ca ...

#include <pic.h>

#define SDA RC4  
#define SCL RC3
#define	TRUE 1
#define	FALSE 0

/************************************************/
/*******************prototypes*******************/
/************************************************/

void i2c_init (void);
void i2c_start (void);
void i2c_stop (void);
void i2c_repStart (void);
void i2c_waitForIdle (void);

/************************************************/
/**********************main**********************/
/************************************************/

void main ()
{
 //Adresse esclave (10011000: esclave1 avec R/W=0)
 //Unsigned int adresse 
 i2c_init();
 i2c_start();

 //on doit adresser un esclave (7bits + bit R/W)
 //R/W doit etre à 0
 
 TRISC=0x00;            //SCL et RDA mis à "0" -> outputs
 
 //i2c_read();            //recupere les 8bits de données (mode lecture)
 i2c_stop();
}

/************************************************/
/*******************fonctions********************/
/************************************************/

/**********************/
/****initialisation****/
/**********************/

void i2c_init()
{
 TRISC=0x18;            //SCL et RDA mis à "1" -> inputs
 
 SSPCON1=0x00;
 SSPCON1=0x38;          //I²C Master mode + SSPEN (serial port)+ CKP (clock)
 SSPCON2=0x00;          //Tout à zéro sur le registre 2 (init SEN + PEN + ACK + etc...)
 SSPSTAT=0x00;
 
 SMP=1;                 //Contrôle de la vitesse de balayage désactivé (dans SSPSTAT)
 CKE=1;                 //Niveaux logiques sont pris en compte I²C (dans SSPSTAT)

 SSPADD=19;             //Avec une Fosc=8Mhz -> on obtient 100kbps

 SSPIF=0;               //Clear interrupt flag
 BCLIF=0;               //Clear bus collision flag
}

/*************/
/****start****/
/*************/

void i2c_start()
{
 i2c_waitForIdle();
 SEN=1;                 //Start condition (SDA à 0 et SCL à 1)
}

/************/
/****stop****/
/************/

void i2c_stop()
{
 i2c_waitForIdle();
 PEN=1;                //Stop condition (SDA à 1 et SCL à 1)
}

/************************/
/****repetition start****/
/************************/

void i2c_repStart()
{ 
 i2c_waitForIdle();
 RSEN=1;
}

/***************/
/****lecture****/
/***************/

int i2c_read()
{
 unsigned char i2cReadData;
 i2c_waitForIdle();

 RCEN=1;                //Receive mode
 i2cReadData = SSPBUF;
 i2c_waitForIdle();

 if (!ACKSTAT)          //si ACK...
  {							  
   ACKDT=0;			    //...on transmet qu'il ya bien eu acknowledge et que l'adressage a été bon
  }
 else
  {						   
   ACKDT=1;             //...sinon y en a pas eu; mauvais adressage
  }
  ACKEN=1;              //envoi acknowledge sequence avec la valeur de ACKDT
 return (i2cReadData);
}

/***************/
/****attente****/
/***************/

void i2c_waitForIdle()
{
 while (SSPCON2 & 0x1F)/*|STAT_RW)*/ // wait for idle and not writing
 {}; 
}

[Jack]

Et les BALISES CODES !!!!!!!!!

J'ai pourtant été assez clair.
Tu veux bien qu'on t'aide, mais tu ne veux pas faire l'effort de faciliter la lecture de ton code. C'est un comble !

[invite93a8d3bd]

Mille excuses. je ne savais pas comment cela marchait :s. j'envoyais mes messages depuis réponses rapides... je n'avais pas vu le mode avancé...

Cette fois ci avec les balises, ce qui en effet facilite grandement la tâche, le code est le suivant:

#include <pic.h>

#define SDA TRISC4  
#define SCL TRISC3
#define SDA_in RC4  
#define SCL_in RC3

/************************************************/
/*******************prototypes*******************/
/************************************************/

void i2c_init (void);
void i2c_start (void);
void i2c_stop (void);
void i2c_repStart (void);
void i2c_waitForIdle (void);
void i2c_delay(void);

/************************************************/
/**********************main**********************/
/************************************************/

void main ()
{
 //Adresse esclave (10011000: esclave1 avec R/W=0)
 //Unsigned int adresse 
 i2c_init();
 i2c_start();

 //on doit adresser un esclave (7bits + bit R/W)
 //R/W doit etre à 0
 
 SDA=0;
 SCL=0;
 
 //i2c_read();            //recupere les 8bits de données (mode lecture)
 i2c_stop();
}

/************************************************/
/*******************fonctions********************/
/************************************************/

/****Delay****/

void i2c_delay()
{
}

/****initialisation****/

void i2c_init()
{
 SDA=1;                 //SDA -> input
 SCL=1;                 //SCL -> input
 SDA_in=0;
 SCL_in=0;

 SSPCON1=0x38;          //I²C Master mode(1000) + SSPEN (serial port)+ CKP (clock)
 
 SSPCON2=0x00;          //Tout à zéro sur le registre 2 (init SEN + PEN + ACK + etc...)
 SSPSTAT=0x00;
 
 SMP=1;                 //Contrôle de la vitesse de balayage désactivé (dans SSPSTAT)
 CKE=1;                 //Niveaux logiques sont pris en compte I²C (dans SSPSTAT)

 SSPADD=19;             //Avec une Fosc=8Mhz -> on obtient 100kbps

 SSPIF=0;               //Clear interrupt flag
 BCLIF=0;               //Clear bus collision flag
}

/****start****/

void i2c_start()
{
 i2c_waitForIdle();
 i2c_delay();
 SEN=1;                 //Start condition (SDA à 0 et SCL à 1)
}

/****stop****/

void i2c_stop()
{
 i2c_waitForIdle();
 i2c_delay();
 PEN=1;                //Stop condition (SDA à 1 et SCL à 1)
}

/****repetition start****/

void i2c_repStart()
{ 
 i2c_waitForIdle();
 i2c_delay();
 RSEN=1;
}

/****lecture****/

unsigned char i2c_read()
{
 char i2cReadData, d=0;
 i2c_waitForIdle();
 RCEN=1;                //Receive mode
 i2cReadData = SSPBUF;
 i2c_waitForIdle();

 if (!ACKSTAT)          //si ACK...
  {							  
   ACKDT=0;			    //...on transmet qu'il ya bien eu acknowledge et que l'adressage a été bon
  }
 else
  {						   
   ACKDT=1;             //...sinon y en a pas eu; mauvais adressage
  }
  ACKEN=1;              //envoi acknowledge sequence avec la valeur de ACKDT
 return (i2cReadData);
}


/****verif. ligne libre****/

void i2c_waitForIdle()
{
 while (SSPCON2 & 0x1F)/*|STAT_RW)*/ // wait for idle and not writing
 {}; 
}

Cordialement c'est dans le cadre d'un stage seulement je suis nase en programmation de ce genre

[Jack]

Parfait! C'est quand même plus lisible.

Tu pourras remercier gienas qui a fait le travail pour les posts précédents.

A+

[Jack]

Mon probleme est de savoir comment adresser un esclave.

L'adresse est définie dans la doc de l'esclave

comment je dis au pic daller interoger un esclave?

i2c_read() et i2c_write() en spécifiant les bons arguments et en respectant le protocole donné dans la doc de l'esclave.

A+

[invite93a8d3bd]

Oui merci à toi gienas ...

[invite93a8d3bd]

Le mieux est de reprendre point par point mon code ...et commencer par savoir si l'initialisation est correcte ?

void i2c_init()
{
 SDA=1;                 //SDA -> input
 SCL=1;                 //SCL -> input
 SDA_in=0;
 SCL_in=0;

 SSPCON1=0x38;          //I²C Master mode(1000) + SSPEN (serial port)+ CKP (clock)
 
 SSPCON2=0x00;          //Tout à zéro sur le registre 2 (init SEN + PEN + ACK + etc...)
 SSPSTAT=0x00;
 
 SMP=1;                 //Contrôle de la vitesse de balayage désactivé (dans SSPSTAT)
 CKE=1;                 //Niveaux logiques sont pris en compte I²C (dans SSPSTAT)

 SSPADD=19;             //Avec une Fosc=8Mhz -> on obtient 100kbps

 SSPIF=0;               //Clear interrupt flag
 BCLIF=0;               //Clear bus collision flag
}

[Jack]

Mettre SCL en entrée me semble curieux pour un maitre du bus.

[invite93a8d3bd]

Je suis d'accord avec toi.

Dans mon projet le PIC16f1938 est le maitre. Pour moi SCL n'est jamais à mettre en entrée ??
La clock (SCL) est alors unidirectionnelle du PIC vers ma carte LTC2990 ??

Si je l'ai mit en entrée c'est surtout par rapport à tout les exemples que j'ai pris comme modèle pour écrire mon prog.
Je viens d'effectuer le changement: j'ai mis SCL en sortie. Je pense que l'initialisation est OK (si il y a des modifs à effectuer, dites le moi quand même).

[Jack]

La clock (SCL) est alors unidirectionnelle du PIC vers ma carte LTC2990 ??

Si je l'ai mit en entrée c'est surtout par rapport à tout les exemples que j'ai pris comme modèle pour écrire mon prog.

Par définition, c'est le maitre qui pilote l'horloge.

A+