Répondre à la discussion
Affichage des résultats 1 à 12 sur 12

interruption I2C pic 18F



  1. #1
    jum0034

    interruption I2C pic 18F


    ------

    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

    Code:
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    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

    -----
    Fichiers attachés Fichiers attachés
    Dernière modification par gienas ; 07/09/2008 à 16h30. Motif: Ajouté balises code

  2. Publicité
  3. #2
    jum0034

    Re : interruption I2C pic 18F

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

  4. #3
    microchip

    Re : interruption I2C pic 18F

    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
    Dernière modification par microchip ; 07/09/2008 à 17h23. Motif: correction
    Here to help ;=)

  5. #4
    ElMamat

    Re : interruption I2C pic 18F

    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.

  6. A voir en vidéo sur Futura
  7. Comparatifs

    Gagnez du temps et de l'argent grâce à nos comparatifs de produits. Parmi nos sujets :
  8. #5
    jum0034

    Re : interruption I2C pic 18F

    ""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

  9. #6
    microchip

    Re : interruption I2C pic 18F

    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...
    Here to help ;=)

  10. Publicité
  11. #7
    invite03481543

    Re : interruption I2C pic 18F

    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:
    Code:
    // gestionIT.c
    
    void fonction1(void)
    {
    .......
    }
    
    char fonction2(int var)
    {
    ......
    }
    Le fichier h associé:
    Code:
    // 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.
    @+

  12. #8
    jum0034

    Re : interruption I2C pic 18F

    * 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

  13. #9
    jum0034

    Re : interruption I2C pic 18F

    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
    Dernière modification par jum0034 ; 08/09/2008 à 21h54.

  14. #10
    GY22

    Re : interruption I2C pic 18F

    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.

    Code:
    #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).

  15. #11
    nassim.ayadi

    Re : interruption I2C pic 18F

    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.

  16. #12
    nassim.ayadi

    Re : interruption I2C pic 18F

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


  17. Publicité

Discussions similaires

  1. Choix de philo: programmer un PIC 18F en C
    Par PlatipuS dans le forum Électronique
    Réponses: 10
    Dernier message: 13/04/2010, 10h08
  2. pic 18F et L298
    Par piupiuvb dans le forum Électronique
    Réponses: 5
    Dernier message: 23/03/2009, 08h11
  3. comment passer des pic 16F au pic 18F ?
    Par MorpheusPic dans le forum Électronique
    Réponses: 5
    Dernier message: 13/08/2008, 22h04
  4. Passage I2C d'un 16F en 18F
    Par grd666 dans le forum Électronique
    Réponses: 2
    Dernier message: 18/06/2008, 13h42
  5. Interruption I2C
    Par Pitch21 dans le forum Électronique
    Réponses: 4
    Dernier message: 19/01/2007, 10h20
Découvrez nos comparatifs produits sur l'informatique et les technologies.