interruption I2C pic 18F

[inviteec13c33a]

salut a tous ,
je suis debutant dans la prog des pic , j'utilise un 18F2525 en esclave
j ai quelque souci , jcrois que sa vien de mes intéruption I2C , et sauvegarde des registres,

je suis bloqué et je tourne en rond,

la carte maitre avec qui je communique en interruption m envoit dans un premier temps mon adresse , c est pour cela que je me met en reception dans l'init I2C,

puis ensuite elle m 'envoit 3 octet pour me dire qu'elle est prette a communiquer : 1er octet = adresse
2er octet = type de data
3er octet = data

mes flag de communication sont mis a jour dans la reception , et la je revient dans mon main et rentre dans cette boucle:

if(Flag_I2C.reveil_MITS == oui_ && Flag_I2C.emission_en_cours == non_ && Flag_I2C.reception_en_cours == non_ && Flag_I2C.emission_OK == non_ && Flag_I2C.reception_OK == oui_ )

{

I2C_commande(emission_,mode_MI TS_,_repos_);
Flag_I2C.emission_en_cours = oui_;

}


et la quand le prog execute I2C_commande(emission_,mode_MI TS_,_repos_);
il rentre dans la fonction """""""""void I2C_commande (unsigned char,unsigned char,unsigned char);"""""""" mais ne detecte pas que je suis en emission
et ne fais pas de front descendant sur la pin RC6 (je suis obligé de faire un front descandant sur cette pin pour que la carte maitre se mette en interruption)

alors que si je modifie le prog du maitre en enlevant les 3 premier octet emis pour dire qu il est pret ,
il arrive bien a rentrer dans I2C_commande(emission_,mode_MI TS_,_repos_);
et se mettre en mode emission ou reception

peut etre qu i faut que je sauvegarde les registres , je ne sais pas lequel ,quel varible.......

voila mon probleme je ne comprend pas , si vous voyer d autre erreur sur mon code merci de les dire , sa m aidera beaucoup.

voici mon code: la ou en fichier jointe plus bas

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
define.h
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#define		cAdd_High_Vector_Int	0x0008			
#define		cAdd_Low_Vector_Int	0x0018	
#define		Port_in_2		   	PORTCbits.RC6
#define 		reveil_hard_MITS_	PORTBbits.RB4

#define adresse_MOI_		((unsigned char) 0x20)
#define mode_MITS_ 			((unsigned char) 0x01)
#define etat_MITS_ 			((unsigned char) 0x02)
#define statut_MITS_		((unsigned char) 0x04)


#define OFF_ 				((unsigned char) 0x00)
#define veille_ 			((unsigned char) 0x01)
#define reveil_MITS_ 		((unsigned char) 0x02)

#define _repos_			((unsigned char) 0x00)
#define _arret_ 		((unsigned char) 0x07)


#define emission_            1
#define reception_			 2

/***************** Variables pour l'I2C ******************
unsigned char adresse_I2C_E;
unsigned char type_I2C_E;
unsigned char data_I2C_E;
signed char test_transmission;

unsigned char adresse_I2C_R;
unsigned char type_I2C_R;
unsigned char data_I2C_R;

unsigned int chargdriver;

struct
{
	unsigned commande_valide :1;
	unsigned emission_OK:1;
	unsigned reception_OK :1;
	unsigned emission_en_cours:1;
	unsigned reception_en_cours:1;
	unsigned reveil_MITS:1;
}Flag_I2C;

unsigned char mode_commande_I2C;
unsigned char type_commande_I2C;
unsigned char data_commande_I2C;
unsigned char compteur_I2C;

#pragma udata My_Var1	// Variable Save on IT

#pragma code	




///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
MAIN
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "p18f2525.h"
#include"define.h"
#include"fonctions.h"
#include <i2c.h>
#include "I2c.c"
#include "Gestion IT.C"


#pragma code		// return to default code section


void main (void)
{
	Init_port(); 									
	Init_IT();										
	Initialisation_Variables();
	Init_variables_I2C();							
	Init_reg_I2C(); 

	while(1)										//Boucle principale
	{
			if(Flag_I2C.reveil_MITS == oui_ && Flag_I2C.emission_en_cours == non_ && Flag_I2C.reception_en_cours == non_ && Flag_I2C.emission_OK == non_ && Flag_I2C.reception_OK == oui_ )	

	                {	
	
		             I2C_commande(emission_,mode_MITS_,_repos_);
		             Flag_I2C.emission_en_cours = oui_;
				
	                 }
    }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

*************************************************************
void Init_port(void)
{
	TRISA=0b11111111; 			//Configuration du port A
	TRISB=0b00000101;			//Configuration du port B
	TRISC=0b10011000;			//Configuration du port C

	Port_in_2 = on_;
	
}

***************************************************************
void Init_IT(void)

{
	RCONbits.IPEN = 1;	//Validation du mode prioritaire des ITs

	//GIEH = 1 ==> validation des ITs priorite haute
	//GIEL = 0 ==> validation des ITs priorite basse
	//TMR0 = 0==> validation de l'IT du timer0
	//INT0IE = 0 ==> validation de l'IT INT0
	//RBIE = 0 ==> pas d'IT sur le portB
	//TMR0IF = 0 ==> intialisation du flag timer0
	//INT0IF = 0 ==> intialisation du flag INT0
	//RBIF = 0 ==> intialisation du flag portB
	INTCON = 0b10000000;

	//RBPU = 1 ==> pas de pull up sur le portB
	//INTDEG0 = 0 ==> front descendant
	//INTDEG1 = 1 ==> pas d'importance
	//INTDEG2 = 1 ==> pas d'importance
	//*=0 unimplemented
	//TMR0IP = 0==> timer0 en priorite haute
	//*=0 unimplemented
	//RBIP = 0 ==> pas d'imporatnce
	INTCON2 = 0b10110000;

	PIR2 = 0;			//Reset Flag IT
	PIR1 = 0;			//Reset Flag IT

	IPR1 = 0;			
	IPR2 = 0;

	PIE1 = 0;			//On devalide toute les interruptions sur PIE1
	PIE2 = 0; 			//desactivation des autres ITs

	PIE1bits.SSPIE = 1;	//validation de l'I2C 
	PIPR1bits.SSPIP = 1;	//I2C en haute priorite
	
}
****************************************************************
void Init_variables_I2C(void)
{
	Flag_MITS.en_veille = non_;
	Flag_I2C.reveil_MITS = non_;

	
	Flag_I2C.emission_en_cours = non_;
	Flag_I2C.reception_en_cours = non_;
	Flag_I2C.reception_OK = non_;
	Flag_I2C.emission_OK = non_;

	adresse_I2C_E = 0;
	type_I2C_E = 0;
	data_I2C_E;

	adresse_I2C_R = 0;
	type_I2C_R = 0;
	data_I2C_R = 0;
	
	I2C_commande(reception_,etat_MITS_,reveil_MITS_);
}

********************************************************************
void Init_reg_I2C(void)
{   
	SSPADD = adresse_MOI_;
	SSPSTAT = SLEW_OFF ;			// slew rate on/off 
    SSPCON1 = 0x36;                 // select serial mode 
    SSPCON2 = 0x00;                 // power on state
                        
}

*******************************************************************
void I2C_commande(unsigned char mode_IT_I2C,unsigned char type_IT_I2C,unsigned char data_IT_I2C)
{
	
		
	//
	switch ( mode_IT_I2C )
	{
		
		case emission_:			//mode emission
			
			Port_in_2 = 0;
			Tempo02();
			Port_in_2 = 1;
		break;

		case reception_:		//mode reception
		
			if ( Flag_MITS.en_veille == oui_)
			{	
				reveil_hard_MITS_ = 0;
				Tempo02();
				reveil_hard_MITS_ = 1;
				
			}
		break;
	}

	mode_commande_I2C = mode_IT_I2C;
	type_commande_I2C = type_IT_I2C;
	data_commande_I2C = data_IT_I2C;		//type de donnée a envoyer ou recevoir
	
	compteur_I2C = 0;
} 


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Gestion IT.C
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////


#pragma code High_Vector = cAdd_High_Vector_Int		
void Interrupt_High(void)
{
	check_Interrupt_High();		// Call SP interuption High
}

#pragma code					// return to default code section


#pragma interrupt	check_Interrupt_High	save=PROD,section("My_Var1") 	

void check_Interrupt_High(void)
{
	if ( PIR1bits.SSPIF == 1)
	{
		IT_I2C();
	}


}
#pragma code				// return to default code section



///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
I2c.c
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void IT_I2C(void)
{
	
	
	INTCONbits.GIE = 0;
	
	compteur_I2C++;			//incrementation compteur I2C
	

	switch(mode_commande_I2C)												    //emission ou reception
	{
		case emission_:															//dans le cas emission
			
			
			if ( compteur_I2C == 1 )  //adresse, ecriture         
 			{
				adresse_I2C_R = SSPBUF ;			   	   //Lecture adresse
				
			}		

			if ( compteur_I2C == 2 )  //  donnée,lecture
			{
				data_I2C_R = SSPBUF;
				Flag_I2C.emission_en_cours = oui_;
				
								
			}

			if( compteur_I2C == 3 )     //adresse lecture
			{
				adresse_I2C_R = SSPBUF;

				SSPCON1bits.CKP = 0;	       
                                 
				switch (type_commande_I2C)
				{
					case mode_MITS_:
						
						switch (data_commande_I2C)
						{
							case _repos_:{SSPBUF = mode_MITS_ ;}break;					
							
							case _arret_:{SSPBUF = mode_MITS_ ;}break;
						}
					break;

					case etat_MITS_:
					
						switch (data_commande_I2C)
						{
								case veille_:{SSPBUF = etat_MITS_;}break;				
								
								case reveil_MITS_:{SSPBUF = etat_MITS_;}break;
						}
					break;
					

					

			if(compteur_I2C == 4 )												 
			{
				SSPCON1bits.CKP = 0;	//on bloque la clock
				
				SSPBUF = data_commande_I2C;


				
			}
			if(compteur_I2C == 5  )												
			{	
				
		    	if( SSPSTATbits.P == 1 )
				{
			
				Flag_I2C.emission_OK = oui_;
				Flag_I2C.emission_en_cours = non_;
			
				}
				else
				{
				Flag_I2C.emission_OK = non_;
				}
			
		
													
				Flag_I2C.emission_en_cours = non_;											//Reset Flag
				
            
			}
		break;
		case reception_:																	//cas de la reception
			
				
			if ( compteur_I2C == 1 )          
 			{	
				adresse_I2C_R = SSPBUF ;					
					if( chargdriver == non_  )			
					{
						compteur_I2C = 0;
						chargdriver = oui_;
													
					}
				
			}	
		
			if(compteur_I2C == 2)
			{
				
				type_I2C_R = SSPBUF;														//chargement type
				
			}

			if(compteur_I2C == 3)
			{	
				data_I2C_R = SSPBUF;														//Chargement de la donnee
				
				switch (type_commande_I2C)
				{
					case etat_MITS_:
					
						switch (data_commande_I2C)
						{
											
							case reveil_MITS_:
								
								if(adresse_I2C_R == adresse_MOI_ && type_I2C_R == etat_MITS_ && data_I2C_R == reveil_MITS_)
								{
								Flag_I2C.commande_valide = oui_;
								
								}
								else
								{
									Flag_I2C.commande_valide = non_;
								}
								if(Flag_I2C.commande_valide == oui_ )   
									Flag_I2C.reception_OK = oui_;
								else
								{
									Flag_I2C.reception_OK  = non_;
									PIR2bits.BCLIF = 0;
								}
						
								if(Flag_I2C.reception_OK == oui_)
								{	
									Flag_I2C.reveil_MITS = oui_;
																								 
								}
							break;	

						}
					break;
			}		
			
			   Flag_I2C.reception_en_cours = non_;		//reset flag
				
		break;
			
	}
		
}
	
	SSPCON1bits.CKP = 1;	//on relache la clock
	SSPCON1bits.SSPOV = 0;
	
	
	PIR1bits.SSPIF = 0; 	//Reset Flag
	INTCONbits.GIE = 1;
	

	
}

et encore merci pour vos aides
-----

[inviteec13c33a]

SVP ya t il quelqun qui s y connnait en C pour pic 18F

[invitee0bbe70d]

Bonjour,

Il y a plusieurs erreurs dans l'organisation du projet.
Tout d'abord, on n'inclut pas des fichiers xxxx.C and un autre fichier yyyyyy.C.
Retirer--->
#include "I2c.c"
#include "Gestion IT.C"

Dans MPLAB, il suffit d'ajouter des fichiers au projet et ils seront tous compilés.
Les fichiers headers xxxx.H sont par contre corrects.

Concernant les interruptions, il faut lire la doc...
Pour les périphériques, il faut autoriser le périphérique + le bit PEIE (int de type périphérique) + le bit GEIE (int global)

Je te recommande de lire le cours de Bigonoff sur les PIC18 (même s'il est en ASM tu apprendras énormément).

2eme excellente source côté C, le cours de l'IUFM d'AIX :
http://www.aix-mrs.iufm.fr/formation...indexPIC_C.htm

Autre conseil : utilise les librairies fournies avec le compilateur C18. Cela te facilitera la vie car des fonctions existent pour initialisr ET utiliser tous les périphériques.


Bonne lecture

[ElMamat]

Bonsoir,
Je vois quelques pistes mais je ne sais pas si ca resoudra ton probleme.
Je vois que a aucun moment tu testes si l esclave as recus une adresse ou une donnee.(SSPSTATbits.DA).
De plus tu es dans une liaison de type maitre/esclave et l'esclave ne pourra envoyer des données que si le maitre lui dit d'en envoyer,l'esclave ne peut prendre le controle du bus, en mettant le bit RW à 1 (je crois à vérifier) mais comme tu ne verifies jamais ce bit il y a surement un soucis.

[A voir en vidéo sur Futura]

[inviteec13c33a]

""Bonjour,

Il y a plusieurs erreurs dans l'organisation du projet.
Tout d'abord, on n'inclut pas des fichiers xxxx.C and un autre fichier yyyyyy.C.
Retirer--->
#include "I2c.c"
#include "Gestion IT.C"

Dans MPLAB, il suffit d'ajouter des fichiers au projet et ils seront tous compilés.
Les fichiers headers xxxx.H sont par contre corrects.""

- lorsque je ne mes pas #include xxxxx.c sa me met une erreur a la complilation


""Bonsoir,
Je vois quelques pistes mais je ne sais pas si ca resoudra ton probleme.
Je vois que a aucun moment tu testes si l esclave as recus une adresse ou une donnee.(SSPSTATbits.DA).
De plus tu es dans une liaison de type maitre/esclave et l'esclave ne pourra envoyer des données que si le maitre lui dit d'en envoyer,l'esclave ne peut prendre le controle du bus, en mettant le bit RW à 1 (je crois à vérifier) mais comme tu ne verifies jamais ce bit il y a surement un soucis.""

-si je peut lui envoyer des donnée quand je veux , je fais un front descendant sur une de ses broches et il rentre en interruption et me demande ce que je veut



et j ai une autre question meme si cela n a pas resolu mon probleme,
quan je rentre dans le sous programme d'interruption i2c est ce qu il faut que je desactive le bit GIE (qui desactive les interruption)?

merci encore pour votre aide

[invitee0bbe70d]

Bonsoir,

Il y a plusieurs problèmes dans ta gestion des interruptions, notamment dans ta routine d'interruption IT_I2C.

* Le bit GIE ne doit pas JAMAIS être manipulé dans l'interruption mais uniquement dans le programme principal. Supprime ces lignes :
INTCONbits.GIE = 0; (au début )
INTCONbits.GIE = 1; ( a la fin )

Il suffit comme tu l'as fait (PIR1bits.SSPIF = 0; //Reset Flag) de reseter le flag qui a provoqué les interruptions.
Le flag GIE est automatiquement désactivé à l'entrée dans l'interruption et réactivé à la sortie.

Il faudra donc avant de rentrer dans ta boucle while(1) de ton main() ajouter l'autorisation du bit GIE ( INTCONbits.GIE = 1; )

Autre PB : il faut éviter de faire les traitements trop long dans l'interruption. Il vaut mieux positionner un sémaphore (flag) et faire le traitement dans le programme principal.

Attention, si tu utilises des variables à la fois dans le programme principal et dans les interruptions, elles doivent impérativement avoir l'attribut volatile...

[invite03481543]

Bonsoir,

microchip ayant dit l'essentiel, j'ajouterai juste que si tu as un fichier gestionIT.c, il faut lui associer un fichier gestionIT.h qui doit contenir les déclaratifs des fonctions utilisées dans le fichier C (en utilisant extern), ainsi que pour les variables associées.

Ex:

// gestionIT.c

void fonction1(void)
{
.......
}

char fonction2(int var)
{
......
}

Le fichier h associé:

// gestionIT.h

extern void fonction1(void);
extern unsigned char fonction2(int var);

Ainsi tu n'incluras que gestionIT.h, i2c.h étant déclaré, inutile de mettre i2c.c puisque tout est déjà accessible par le biais de i2c.h le linker fera le reste.

Il faut par contre veiller à ce que tous ces fichiers soient bien dans le même répertoire que le projet.
@+

[inviteec13c33a]

* Le bit GIE ne doit pas JAMAIS être manipulé dans l'interruption mais uniquement dans le programme principal. Supprime ces lignes :
INTCONbits.GIE = 0; (au début )
INTCONbits.GIE = 1; ( a la fin )

Il suffit comme tu l'as fait (PIR1bits.SSPIF = 0; //Reset Flag) de reseter le flag qui a provoqué les interruptions.
Le flag GIE est automatiquement désactivé à l'entrée dans l'interruption et réactivé à la sortie.

lorsque j enleve :
INTCONbits.GIE = 0; (au début )
INTCONbits.GIE = 1; ( a la fin )

et que je reset le flag ala fin de mon interruption , il arrive a lire les deux premiere trame et la 3me il ne met pas le ack

alors que si je laisse le bit GIE comme avant sa fonctionnne, d ou sa pourrait provenir si vous avez des idee,

merci encore

[inviteec13c33a]

merci a tous , s est bon j ai resolu mon prob
enlever le bit GIE dans l'interruption I2C
et arreter l orloge quans je suis en emision reception et j avais mal configuré le registre SSPCON2,

et il faut bien que je mette par exemple :
volatile unsigned char flagi2c;

quand j utilise des flag dans mes interruption et dans mon prog principal

merci

[invite45b23d34]

Bonjour à tous,

Je relance cette discussion car je rencontre un problème avec les interruptions du PIC 18F25k22 pour la liaison i2C. Mon problème est que mon programme n'entre jamais dans les routines d'interruptions.

#include <p18f25k22.h>  
#include <delays.h>    
#include <i2c.h>  

#pragma config STVREN   = ON
#pragma config LVP      = OFF
	
        #pragma config XINST    = OFF       // Extended Instruction Set
        #pragma config CP0      = OFF
        #pragma config CP1      = OFF
    	#pragma config CP2      = OFF
	    #pragma config CP3      = OFF
        #pragma config CPB      = OFF
	    #pragma config CPD      = OFF
        #pragma config WRT0     = OFF
        #pragma config WRT1     = OFF
	    #pragma config WRT2     = OFF
	    #pragma config WRT3     = OFF
        #pragma config WRTB     = ON       // Boot Block Write Protection
        #pragma config WRTC     = OFF
	    #pragma config WRTD     = OFF

void high_isr(void);
void low_isr(void);

#define nbreg		12 //nombres de registre pour l'i2c 1< nbreg < 255
#define Slave_Address 	0x40

volatile unsigned char buf;
volatile unsigned char registre[nbreg];


#pragma code high_vector=0x08
	void high_int(void)
	{
		_asm goto high_isr _endasm
			
	}
#pragma code


#pragma code low_vector=0x18
	void interrupt_at_low_vector(void)
	{
	    _asm goto low_isr _endasm
	}
#pragma code



void init(void)
{	int i;


	PORTA = 0x00; //init port A
	TRISA = 0x01;  //porta 1 en entrée
	
	PORTB = 0x00;  //init port b
	TRISB = 0x06; //rb1 et rb2 en entree pour i2c

	PORTC = 0x00; 
	TRISC = 0x18;
	
	ADCON1 = 6;
	OSCCON = 0x40; // Fosc = 2MHz 0x40=> 0x70    pour Fosc = 16MHz => 0x70

	RCONbits.IPEN = 0;

	INTCONbits.PEIE = 1;		//validation int via péripheriques (dans reg INTCON)
	INTCONbits.GIE = 1;	//validation toutes int (dans reg INTCON)


	PIR2 = 0;			//Reset Flag IT
	PIR1 = 0;			//Reset Flag IT
	IPR1 = 0;			
	IPR2 = 0;
	PIE1 = 0;			//On devalide toute les interruptions sur PIE1
	PIE2 = 0; 			//desactivation des autres ITs


	SSP1ADD=Slave_Address<<1; //adresse du pic sur le bus i2c

	SSP1CON1 = 0b00110110;  // bit 0-3 mode 7bits esclave 		
						// bit 4 valide horloge 
	SSP1CON2 = 0x00;
	SSP1CON2bits.SEN = 1;
	SSP1STAT = 0b0000000; 		//	raz registre status des ports serie
	

	PIE1bits.SSP1IE = 1;			// validation interruption via port serie (dans registre PIE1)
	PIR1bits.SSP1IF = 0;		//raz bit interruption i2c
		
	for(i=0;i<nbreg;i++) registre[i]=0;


}

#pragma interruptlow high_isr
void high_isr(void)
{	
	PORTB =0x08;
}
#pragma code



#pragma interruptlow low_isr
void low_isr(void)
{
	PORTB =0x08;
}
#pragma code




void main (void)
 {
	unsigned char val1;
	unsigned char val2;
	unsigned char reg;
	unsigned char addr;
	int test;

	registre[5] = 0xEB;
	registre[3] = 0x0F;
	registre[4] = 0x70;

	val1 = 0x06;
	val2 = 0x0A;
	reg = 0x06;
	addr = 0x00;
	test = 0;


	init();
	
 	PORTB =0x01;
		while(1)
		{		
	    }       
	                    
 }

Cela fait un petit moment que je bloque, j'espère qu'un œil nouveau pourra voir mon/mes erreur(s).

[invite83989eb4]

Bonjour,
Je me permet de relancer cette discussion, par ce que j'ai un problème du même type.

Voila Je dois effectuer une communication I2C entre un afficheur LCD (piloté par un µproc ATMEGA) et un PIC 18F2550.
Le PIC 18F est configuré en esclave.
J'utilise le compilateur C18 avec MPLAB X et le programmeur Pickit 3.

Voici mon code

//******** C18 *********************
#include <p18f2550.h>
#include <stdlib.h>
#include <stdio.h>

#pragma config WDT = OFF
#pragma config LVP = OFF
#pragma config MCLRE = OFF
#pragma config DEBUG = OFF
#pragma config FOSC = HS //Oscillateur externe
int i=0;
unsigned int value = 0;
unsigned int i2c_flag = 0 ;
int buffer = 0;
int addr ;
int select;
//Interuptions haut niveau => Pour I2C
void Interrupt_High(void);
#pragma code highVector=0x08 // on déclare que lors d'une interruption
void atInterrupthigh(void)
{
_asm GOTO Interrupt_High _endasm // on doit éxecuter le code de la fonction MyHighInterrupt
}
#pragma code // retour à la zone de code


#pragma interrupt Interrupt_High
void Interrupt_High(void)
{ // Check si on est entrée dans l'interrupt

LATCbits.LATC0 = 1 ;
if(PIR1bits.SSPIF == 1 && SSPSTATbits.BF == 1)
{
LATCbits.LATC1=1;
value = 300 ;

if(SSPCON1bits.SSPOV == 1)
{
SSPCON1bits.SSPOV = 0; //Clear overflow
}
addr = SSPBUF; // On vide le buffer

PIR1bits.SSPIF ==0;
SSPBUF = 153 ; // Envoie du premier octet
LATCbits.LATC1 = 0 ;
}
SSPCON1bits.CKP=1;
LATCbits.LATC0 = 0 ;
PIR1bits.SSPIF ==0;

}


void main(void){
INTCON=0b00000000; // INTERDIRE les interruption
TRISCbits.TRISC2 = 0; // Configurer les 3 LEDs en Sortie
TRISCbits.TRISC1 = 0;
TRISCbits.TRISC0 = 0;

TRISBbits.TRISB0 = 1; // Configurer broches I2C en entrées
TRISBbits.TRISB1 = 1;
ADCON1 = 0x0F; // Toutes les entrées sont digitales

// Initialisation
PORTC=0 ;
PIE1bits.SSPIE=1 ; // Autoriser interruption MSSP
IPR1bits.SSPIP=1; // Haute priorité
IPR2bits.BCLIP=0; // BUS collision basse priorité
PIE2 = 0; //desactivation des interruption bus collision
SSPADD=0x9A; // Adresse de l'esclave
SSPCON1=0b00110110;
SSPCON2=0b10000000;
SSPSTATbits.SMP=0; // High-speed mode
SSPSTATbits.CKE=0; // Mode I2C
INTCON=0b11000000; // autoriser les interruption (générales) et périphériques

while(1)
{
}
}

en réalité, la communication I2C fonctionne, cépendant j'essaye de configurer la trame pour qu'il y ait une interruption à chaque fois que le LCD fait une requète.
La première interruption marche trés bien, le probleme est que aprés il n'arrete pas d'entrer en interruption, même si le LCD ne comminuque plus. Du coup le principe d'interruption deviens inutile.

Sa fait plusieurs jours que je cherche une solution, sans resultats. La j'avoue que je n'arrive plus à comprendre, si quelqu'un à une solution à proposer ce serait génial.

Merci d'avance.

[invite83989eb4]

Voici une image de la trame
(Jaune = SDA, Bleu = SCL, violet RC0, vert RC1)