Fréquence de fonctionnement du PIC18F4550
Répondre à la discussion
Affichage des résultats 1 à 18 sur 18

Fréquence de fonctionnement du PIC18F4550



  1. #1
    invited08e1382

    Fréquence de fonctionnement du PIC18F4550


    ------

    Bonjour,
    Alors voila, je fais actuellement un projet avec mon école sur la perception de l'environnement pour les malvoyants.
    Le but est de récoté les informations de 5 télémètre par la pin CCP1, de les traiter avec le PIC18F4550 et, en fonction de la position de l'objet envoyer des bip sonore plus ou moin rapproché et avec hauteur plus ou moin grande (si l'obstacle est loin et a gauche, les bip sont espacé et grave, si l'osbtacle est proche et à droite, les bip sont rapproché et aigue).
    En parallèle, un bargraphe a 10 segments allume ces led avec le meme principe.
    Le programme testé sous Proteus Isis fonctionne bien, j'obtiens des bips plus ou moin espacé avec un panel de fréquence allant de 300 à 700 Hz.
    Le probleme est que lorsque je teste le programme sur un vrai microcontroleur, le PIC fonctionne comme au ralenti, comme 25 fois plus lentement... sauriez vous pourquoi ?
    Je ne sais pas si j'ai été assez clair, merci en tout cas
    Voici le code ( un peu long j'en suis désolé)
    Bonne soirée à tous.

    Code:
    #include <p18f4550.h>
    #include <stdio.h>
    #include <capture.h>
    #include <timers.h>
    #include <math.h>
    #include <delays.h>
    /*---------------------------------bits de configuration----------------------------------------*/
    #pragma config PLLDIV = 5  
    #pragma config CPUDIV=OSC3_PLL4
    #pragma config USBDIV = 1
    #pragma config FOSC = HSPLL_HS
    #pragma config FCMEN = ON
    #pragma config BOR = OFF
    #pragma config VREGEN = ON
    #pragma config WDT = OFF
    #pragma config PBADEN = OFF
    #pragma config LPT1OSC = OFF
    #pragma config MCLRE = ON
    #pragma config STVREN = ON
    #pragma config LVP = OFF
    #pragma config ICPRT = OFF
    #pragma config XINST = OFF
    #pragma config DEBUG = ON
    /*---------------------------------fin bits de configuration------------------------------------*/
    /*---------------------------------déclaration variable ----------------------------------------*/
    
    unsigned char config1=0x00;       //initialisation de la configuration de capture '0000 0000'
    unsigned int a=0,b=0,c=0,d=0,e=0;           // variable correspondant respectivement au télémetre 1,2,3,4,5
    unsigned int telemetre;           //variable qui sert à avoir la valeur de la mesure dans la fonction mesure()
    unsigned int minimum;              // variable dans laquelle il y a la plus petite valeur entre a,b,c,d,e
    unsigned int i,j;                 // variable qui sert à déterminer le temp des 'bip' sonore
    /*----------------------------------fin déclaration variable -----------------------------------*/
    /*----------------------------------déclaration de fonctions------------------------------------*/
    
    unsigned int mesure(void);                          //fonction mesure qui calcule à l'aide du timer1 le nombre de cycle que fait une pulsation
    void bargraph(void);                                //alumage du bargraph en fonction des donnée des télémètres (ne clignote pas, s'allume juste)
    void clignote_bargraph_son(void);                      // fait clignoter le bargraphe en fonction de la distance de l'obstacle
    unsigned int MIN(void);                              //fonction qui détermine le minimum entre a,b,c,d,e
    void son(void);                                  //création du signal sonore en fonction de la position de l'obstacle (grave aigue)
    /*-------------------------------------fin déclaration de fonctions-----------------------------*/
    /*------------------------------------programme principal---------------------------------------*/
    
    
    void main(void)
    { 
    	//intialisation des E/S du microcontrôleur et attente d'au moins 175ms pour la mise en route des télémètres
    
    	TRISA=TRISA&0b0110000;           //TRISA=0xx0000            0=sortie   1=entrée
    	TRISB=TRISB&0b11111000;          //TRISB=xxxxx000
    	TRISC=TRISC&0b0111111;          //TRISC=0xxxxxx
    	TRISC=TRISC|0b0000100;          //TRISC=0xxx1xx
    	TRISD=TRISD&0b11000000;         //TRISD=xx000000
    	PORTBbits.RB1=1;               //LED jaune allumé pour montrer la phase d'initialisation
    	ADCON1=0x0F;              // par défaut, les port A sont en mode analogique, il faut alors initialisé le registre ADCON1 pour les mettre en mode digital
    	PORTA=PORTA&0b11110000;           //mise à '0' des sorties RA0,RA1,RA2,RA3,
    	PORTB=PORTB&0b11111110;          // mise à '0'et '1' des sorties RB0 et RB2 (=led rouge BF du micro)
    	PORTB=PORTB|0b00000100;
    	PORTC=PORTC&0b0111111;           //initialisation du port RC6 ( broche qui active les télémètre)
    	PORTD=PORTD&0b11000000;         //mise à '0' des sortie RD0,RD1,RD2,RD3,RD4,RD5    
    
        // initialisation des TIMERS
    
    	T0CON=0b00000111;               //intialisation du timer0 pour le clignotement du bargraph	postcaler 256
    	INTCONbits.TMR0IE=1;            //autorise les interruption du timer0
        INTCONbits.TMR0IF=0;            // mise à zéro du flag d'interruption du timer0     
    	TMR0H=0x0;                      // initialisation du conmpteur
    	TMR0L=0x0;  
     
    	T3CON=0b10000000;               //initialisation du timer3 pour le signal sonore (postcale 1)
    	TMR3H=0;
    	TMR3L=0;	
    	PIR2bits.TMR3IF=0;
    	PIE2bits.TMR3IE=1;
    
    	Delay10KTCYx(0);               // attente de 1,281 seconde pour laisser le temps au télémètre de démarrer
    	Delay10KTCYx(0);               // et de voir la led jaune s'allumer et s'éteindre
    	Delay10KTCYx(0);              
    	PORTBbits.RB1=0;               //led jaune éteinte, fin de l'initialisation
    
    	
    
    
       // envoi du signal de déclenchement des télémètre, il faut un '1' durant au moin 20µs, on va prendre 30µs pour être sur
    		
    	PORTCbits.RC6=1;     //mise à '1'
    	Delay10TCYx(18);     // on attend 18 fois 10 cycle d'horloge., ce qui fait 180 fois l'horloge qui est de 167ns. 180*167=30µs
    	PORTCbits.RC6=0;     //on la remet à '0'
    
       // capture du signal des télémètre et mémorisation dans 5 variables différentes
    
    	a=mesure();         //l'unité de a,b,c,d et e est 'nombre de cycle'  il faut multiplier par 8 pour avoir la valeur réel du nombre de cycle d'horloge
    	b=mesure();         //la valeur max de a,b,c, et e est de : 33234 cycle du timer1 ce qui correspond a 
    	c=mesure();         //265872 cycles d'horloge soit à  44,4ms .
    	d=mesure();
    	e=mesure();
    
    	MIN();              //met la valeur minimum de a,b,c,d,e dans la variable minimum
    
    while(1)
    {
    	clignote_bargraph_son();    //fait clignoter le bargraph en fonction des valeurs de a,b,c,d,e 
    								// et activer le son. Cette fonction en appelle 2 autres...
    }	
    }
    
    
    /*---------------------------------------fin programme principal----------------------------------*/
    /*--------------------------------------------fonctions-------------------------------------------*/
    
    unsigned int MIN(void)
    {
    	if(a<b && a<c && a<d && a<e)
    		{
    			minimum=a;
    		}
    	if(b<a && b<c && b<d && b<e)
    		{
    			minimum=b;
    		}
    	if(c<a && c<b && c<d && c<e)
    		{
    			minimum=c;
    		}
    	if(d<a && d<c && d<b && d<e)
    		{
    			minimum=d;
    		}
    	if(e<a && e<c && e<d && e<b)
    		{
    			minimum=e;
    		}
    }
    
    
    unsigned int mesure(void)
    {
    		telemetre=0;                      //initialisation de la variable telemtre	
    		
    		SetTmrCCPSrc(T1_SOURCE_CCP);      //on prend le timer 1 comme source pour le CCP    
    		
    		config1 = CAP_EVERY_RISE_EDGE ;      //on config la capture sur un front montant 
    				     				    	//autrement dit, ici, config1= 00000101
    		OpenCapture1(config1);             //on démarre la capture avec la config1
    		
    		while(!PIR1bits.CCP1IF);       //tant que ccp1iF est à 0, on fait rien, quand il passe à 1, on sort du while et on démarre le timer1
    				
    		
    		OpenTimer1(10110001);	               //le timer compte avec la config T1CON=10110001  POSTCALER 8 !!!!
    		PIE1bits.CCP1IE=0;	                  //on éteint la capture pour éviter une fausse interruption
    		PIR1bits.CCP1IF=0;                   // purification de ce bit pour etre sur de ne as avoir de fausse interruption
    		config1= CAP_EVERY_FALL_EDGE;      // on change le mode de capture pour capturer le front descendant, le compteur compte toujours
    		PIE1bits.CCP1IE=1;                //on re-autorise les interruptions.
    		OpenCapture1(config1);           //on demarre la capture avec la config sur le front descendant cette fois ci
    
    		while(!PIR1bits.CCP1IF);          //on attend un front descendant
    		telemetre=ReadTimer1();          //une fois le front descendant passer, on enregistre la valeur du timer dans la variavble telemetre
    		CloseTimer1();                  //on éteint le timer
    		return(telemetre);             // on retourne la valeur du telemetre (en nombre de cycle)
    
    }
    
    void clignote_bargraph_son(void)
    {
    	if(minimum>29134)
    		{
    			T0CONbits.TMR0ON=1;                      // on démarre le compteur qui va 256 (postcale = '111') fois moins vite que la clock de 24Mhz et compte jusqu'a 65535 (16bits)
    			if(INTCONbits.TMR0IF==1)                  // si le le compteur est arrivé a 65535
    				{
    					bargraph();               //allumage du bargraph en fonction des valeurs de a,b,c,d,e
    					for(i=0;i<2808;i++)       //activation du signal sonore pendant environ 50ms, le temp d'entendre ce bip
    						{
    							son();		     //fonction qui produit le son d'un fréquence qui dépend si l'osbtacle est a droite ou a gauche...
    						}	
    											
                  		TMR0L=0x0;                         // on remet le compteur a 0
    					TMR0H=0x0;
    					T0CONbits.TMR0ON=0;                // on arrete le compteur
    					INTCONbits.TMR0IF=0;               // on remet le flag d'interruption a 0.
    				}
    			PORTA=PORTA&0b11110000;                  // on rééteint le bargraphe			
    			PORTDbits.RD1=0;                         //on remet les port de sortie sonore à 0
    			PORTDbits.RD2=0;
    			i=0;                                     //on remet i et j à 0
    			j=0;
    		}
    
    	if(minimum>24972 && minimum<29134)
    		{
    			T0CON=0b10000110;                      // on démarre le compteur qui va 128 (postcale = '110') fois moins vite que la clock de 24Mhz et compte jusqu'a 65535 (16bits)
    			if(INTCONbits.TMR0IF==1)                  // si le le compteur est arrivé a 65535
    				{
    					bargraph();               //allumage du bargraph en fonction des valeurs de a,b,c,d,e			
    					for(i=0;i<2808;i++)       //activation du signal sonore pendant environ 50ms, le temp d'entendre ce bip
    						{
    							son();		      //fonction qui produit le son d'un fréquence qui dépend si l'osbtacle est a droite ou a gauche...
    						}	
                  		TMR0L=0x0;                         // on remet le compteur a 0
    					TMR0H=0x0;
    					T0CONbits.TMR0ON=0;                // on arrete le compteur
    					INTCONbits.TMR0IF=0;               // on remet le flag d'interruption a 0.
    				}
    			PORTA=PORTA&0b11110000;                  // on rééteint le bargraphe
    			PORTDbits.RD1=0;                         //on remet les port de sortie sonore à 0
    			PORTDbits.RD2=0;
    			i=0;                                     //on remet i et j à 0
    			j=0;
    		}
    
    	if(minimum>20810 && minimum<24972)
    		{
    			T0CON=0b10000101;                      // on démarre le compteur qui va 64 (postcale = '101') fois moins vite que la clock de 24Mhz et compte jusqu'a 65535 (16bits)
    			if(INTCONbits.TMR0IF==1)                  // si le le compteur est arrivé a 65535
    				{
    					bargraph();               //allumage du bargraph en fonction des valeurs de a,b,c,d,e			
    					for(i=0;i<2808;i++)         //activation du signal sonore pendant environ 50ms, le temp d'entendre ce bip 
    						{
    							son();

    -----

  2. #2
    invited08e1382

    Re : Fréquence de fonctionnement du PIC18F4550

    la suite :

    Code:
    //fonction qui produit le son d'un fréquence qui dépend si l'osbtacle est a droite ou a gauche...
    						}	
                  		TMR0L=0x0;                         // on remet le compteur a 0
    					TMR0H=0x0;
    					T0CONbits.TMR0ON=0;                // on arrete le compteur
    					INTCONbits.TMR0IF=0;               // on remet le flag d'interruption a 0.
    				}
    			PORTA=PORTA&0b11110000;                  // on rééteint le bargraphe
    			PORTDbits.RD1=0;                         //on remet les port de sortie sonore à 0
    			PORTDbits.RD2=0;
    			i=0;                                     //on remet i et j à 0
    			j=0;
    		}
    
    	if(minimum>16848 && minimum<20810)
    		{
    			T0CON=0b10000100;                      // on démarre le compteur qui va 32 (postcale = '100') fois moins vite que la clock de 24Mhz et compte jusqu'a 65535 (16bits)
    			if(INTCONbits.TMR0IF==1)                  // si le le compteur est arrivé a 65535
    				{
    					bargraph();               //allumage du bargraph en fonction des valeurs de a,b,c,d,e			
    					for(i=0;i<2808;i++)          //activation du signal sonore pendant environ 50ms, le temp d'entendre ce bip
    						{ 
    							son();		             //fonction qui produit le son d'un fréquence qui dépend si l'osbtacle est a droite ou a gauche...
    						}
    					                   
                  		TMR0L=0x0;                         // on remet le compteur a 0
    					TMR0H=0x0;
    					T0CONbits.TMR0ON=0;                // on arrete le compteur
    					INTCONbits.TMR0IF=0;               // on remet le flag d'interruption a 0.
    				}
    			PORTA=PORTA&0b11110000;                  // on rééteint le bargraphe
    			PORTDbits.RD1=0;                         //on remet les port de sortie sonore à 0
    			PORTDbits.RD2=0;
    			i=0;                                     //on remet i et j à 0
    			j=0;
    		}
    	
    	if(minimum>12486 && minimum<16848)
    		{
    			T0CON=0b10000011;                      // on démarre le compteur qui va 16 (postcale = '011') fois moins vite que la clock de 24Mhz et compte jusqu'a 65535 (16bits)
    			if(INTCONbits.TMR0IF==1)                  // si le le compteur est arrivé a 65535
    				{
    					bargraph();               //allumage du bargraph en fonction des valeurs de a,b,c,d,e
    					for(i=0;i<2808;i++)           //activation du signal sonore pendant environ 50ms, le temp d'entendre ce bip
    						{
    							son();		            //fonction qui produit le son d'un fréquence qui dépend si l'osbtacle est a droite ou a gauche...
    						}
                  		TMR0L=0x0;                         // on remet le compteur a 0
    					TMR0H=0x0;
    					T0CONbits.TMR0ON=0;                // on arrete le compteur
    					INTCONbits.TMR0IF=0;               // on remet le flag d'interruption a 0.
    				}
    			PORTA=PORTA&0b11110000;                  // on rééteint le bargraphe
    			PORTDbits.RD1=0;                         //on remet les port de sortie sonore à 0
    			PORTDbits.RD2=0;
    			i=0;                                     //on remet i et j à 0
    			j=0;
    		}
    
    	if(minimum>8324 && minimum<12486)
    		{
    			T0CON=0b10000010;                      // on démarre le compteur qui va 8 (postcale = '010') fois moins vite que la clock de 24Mhz et compte jusqu'a 65535 (16bits)
    			if(INTCONbits.TMR0IF==1)                  // si le le compteur est arrivé a 65535
    				{
    					bargraph();               //allumage du bargraph en fonction des valeurs de a,b,c,d,e
    					for(i=0;i<2808;i++)        //activation du signal sonore pendant environ 50ms, le temp d'entendre ce bip
    						{
    							son();		         //fonction qui produit le son d'un fréquence qui dépend si l'osbtacle est a droite ou a gauche...
    						}
                  		TMR0L=0x0;                         // on remet le compteur a 0
    					TMR0H=0x0;
    					T0CONbits.TMR0ON=0;                // on arrete le compteur
    					INTCONbits.TMR0IF=0;               // on remet le flag d'interruption a 0.
    				}
    			PORTA=PORTA&0b11110000;                  // on rééteint le bargraphe
    			PORTDbits.RD1=0;                         //on remet les port de sortie sonore à 0
    			PORTDbits.RD2=0;
    			i=0;                                     //on remet i et j à 0
    			j=0;
    		}
    	
    	if(minimum>4162 && minimum<8324)
    		{
    			T0CON=0b10000001;                      // on démarre le compteur qui va 4 (postcale = '001') fois moins vite que la clock de 24Mhz et compte jusqu'a 65535 (16bits)
    			if(INTCONbits.TMR0IF==1)                  // si le le compteur est arrivé a 65535
    				{
    					bargraph();               //allumage du bargraph en fonction des valeurs de a,b,c,d,e
    					for(i=0;i<2808;i++)       //activation du signal sonore pendant environ 50ms, le temp d'entendre ce bip
    						{
    							son();		         //fonction qui produit le son d'un fréquence qui dépend si l'osbtacle est a droite ou a gauche...
    						}
                  		TMR0L=0x0;                         // on remet le compteur a 0
    					TMR0H=0x0;
    					T0CONbits.TMR0ON=0;                // on arrete le compteur
    					INTCONbits.TMR0IF=0;               // on remet le flag d'interruption a 0.
    				}
    			PORTA=PORTA&0b11110000;                  // on rééteint le bargraphe
    			PORTDbits.RD1=0;                         //on remet les port de sortie sonore à 0
    			PORTDbits.RD2=0;
    			i=0;                                     //on remet i et j à 0
    			j=0;
    		}
    	
    	if(minimum<4162)
    		{
    			T0CON=0b10000000;                      // on démarre le compteur qui va 2 (postcale = '000') fois moins vite que la clock de 24Mhz et compte jusqu'a 65535 (16bits)
    			if(INTCONbits.TMR0IF==1)                  // si le le compteur est arrivé a 65535
    				{
    					bargraph();               //allumage du bargraph en fonction des valeurs de a,b,c,d,e
    					for(i=0;i<2808;i++)         //activation du signal sonore pendant environ 50ms, le temp d'entendre ce bip
    						{
    							son();		       //fonction qui produit le son d'un fréquence qui dépend si l'osbtacle est a droite ou a gauche...
    						}
                  		TMR0L=0x0;                         // on remet le compteur a 0
    					TMR0H=0x0;
    					T0CONbits.TMR0ON=0;                // on arrete le compteur
    					INTCONbits.TMR0IF=0;               // on remet le flag d'interruption a 0.
    				}
    			PORTA=PORTA&0b11110000;                  // on rééteint le bargraphe
    			PORTDbits.RD1=0;                         //on remet les port de sortie sonore à 0
    			PORTDbits.RD2=0;
    			i=0;                                     //on remet i et j à 0
    			j=0;
    		}
    }
    
    
    
    
    
    
    void bargraph(void)
    {
    	if(a<b && a<c && a<d && a<e)                   //si l'obstacle est plus proche de a
    		{										  //  Y1 du bargraph s'allume      même démarche pour les autre cas...
    			PORTAbits.RA0=1;                    
    			PORTAbits.RA1=0;
    			PORTAbits.RA2=0;
    			PORTAbits.RA3=0;                    
    		}
    
    	if(a<c && a<d && a<e && b<c && b<d && b<e)        //si l'obstacle est plus proche de (ab)
    		{
    			PORTAbits.RA0=0;                    
    			PORTAbits.RA1=1;
    			PORTAbits.RA2=0;
    			PORTAbits.RA3=0; 
    		}
    
    	if(b<a && b<c && b<d && b<e)      //détection pour le télémètre b, Y3 s'allume
    		{
    			PORTAbits.RA0=1;                    
    			PORTAbits.RA1=1;
    			PORTAbits.RA2=0;
    			PORTAbits.RA3=0; 
    		}
    
    	if(b<a && b<d && b<e && c<a && c<d && c<e)      // détection pour le télémètre b et c, Y4 s'allume
    		{
    			PORTAbits.RA0=0;                    
    			PORTAbits.RA1=0;
    			PORTAbits.RA2=1;
    			PORTAbits.RA3=0; 
    		}
    	
    	if(c<a && c<b && c<d && c<e)     // détection pour le télémètre c , Y5 s'allume
    		{
    			PORTAbits.RA0=1;                    
    			PORTAbits.RA1=0;
    			PORTAbits.RA2=1;
    			PORTAbits.RA3=0; 
    		}
    
    	if(c<a && c<b && c<e && d<a && d<b && d<e)       // détection pour le télémètre c et d, Y6 s'allume
    		{
    			PORTAbits.RA0=0;                    
    			PORTAbits.RA1=1;
    			PORTAbits.RA2=1;
    			PORTAbits.RA3=0; 
    		}
    
    	if(d<a && d<b && d<c && d<e)       // détection pour le télémètre  d, Y7 s'allume
    		{
    			PORTAbits.RA0=1;                    
    			PORTAbits.RA1=1;
    			PORTAbits.RA2=1;
    			PORTAbits.RA3=0; 
    		}
    
    	if(d<a && d<b && d<c && e<a && e<b && e<c)       // détection pour le télémètre d et e, Y8 s'allume
    		{
    			PORTAbits.RA0=0;                    
    			PORTAbits.RA1=0;
    			PORTAbits.RA2=0;
    			PORTAbits.RA3=1; 
    		}
    
    	if(e<a && e<b && e<c && e<d)       // détection pour le télémètre  e, Y9 s'allume
    		{
    			PORTAbits.RA0=1;                    
    			PORTAbits.RA1=0;
    			PORTAbits.RA2=0;
    			PORTAbits.RA3=1; 
    		}
    }

  3. #3
    invited08e1382

    Re : Fréquence de fonctionnement du PIC18F4550

    et la fin :

    Code:
    void son(void)
    {
    	if(a<b && a<c && a<d && a<e)                   //si l'obstacle est plus proche de a
    		{										  
    			
    			T3CONbits.TMR3ON=1;                //le compteur commence 
    			if(PIR2bits.TMR3IF==1)             // si le flag d'interruption est mis a '1', on rentre dans la boucle
    				{
    					TMR3L=0b01100111;           // on ré-initialise le timer3 a 55655
    					TMR3H=0b11011001;
    					PIR2bits.TMR3IF=0;          // on remet le flag a 0
    					T3CONbits.TMR3ON=0;         // on arrete de compter
    					if(PORTDbits.RD1==0 && PORTDbits.RD2==0)      //cette boucle change l'état des ports RD1 et RD2 selon leur état précedents
    						{
    							PORTDbits.RD1=1;
    							PORTDbits.RD2=1;
    						}
    					else 
    						{
    							PORTDbits.RD1=0;
    							PORTDbits.RD2=0;
    						}
        			}             
    		}
    
    	if(a<c && a<d && a<e && b<c && b<d && b<e)        //si l'obstacle est plus proche de (ab)
    		{
    			T3CONbits.TMR3ON=1;                //le compteur commence 
    			if(PIR2bits.TMR3IF==1)             // si le flag d'interruption est mis a '1', on rentre dans la boucle
    				{
    					TMR3L=0b11001001;           // on ré-initialise le timer3 a 57033
    					TMR3H=0b11011110;
    					PIR2bits.TMR3IF=0;          // on remet le flag a 0
    					T3CONbits.TMR3ON=0;         // on arrete de compter
    					if(PORTDbits.RD1==0 && PORTDbits.RD2==0)      //cette boucle change l'état des ports RD1 et RD2 selon leur état précedents
    						{
    							PORTDbits.RD1=1;
    							PORTDbits.RD2=1;
    						}
    					else 
    						{
    							PORTDbits.RD1=0;
    							PORTDbits.RD2=0;
    						}
        			}              
    		}
    
    	if(b<a && b<c && b<d && b<e)      //détection pour le télémètre b, Y3 s'allume
    		{
    			T3CONbits.TMR3ON=1;                //le compteur commence 
    			if(PIR2bits.TMR3IF==1)             // si le flag d'interruption est mis a '1', on rentre dans la boucle
    				{
    					TMR3L=0b11000010;           // on ré-initialise le timer3 a 58050
    					TMR3H=0b11100010;
    					PIR2bits.TMR3IF=0;          // on remet le flag a 0
    					T3CONbits.TMR3ON=0;         // on arrete de compter
    					if(PORTDbits.RD1==0 && PORTDbits.RD2==0)      //cette boucle change l'état des ports RD1 et RD2 selon leur état précedents
    						{
    							PORTDbits.RD1=1;
    							PORTDbits.RD2=1;
    						}
    					else 
    						{
    							PORTDbits.RD1=0;
    							PORTDbits.RD2=0;
    						}
        			}               
    		}
    
    	if(b<a && b<d && b<e && c<a && c<d && c<e)      // détection pour le télémètre b et c, Y4 s'allume
    		{
    			T3CONbits.TMR3ON=1;                //le compteur commence 
    			if(PIR2bits.TMR3IF==1)             // si le flag d'interruption est mis a '1', on rentre dans la boucle
    				{
    					TMR3L=0b00001001;           // on ré-initialise le timer3 a 58889
    					TMR3H=0b11100110;
    					PIR2bits.TMR3IF=0;          // on remet le flag a 0
    					T3CONbits.TMR3ON=0;         // on arrete de compter
    					if(PORTDbits.RD1==0 && PORTDbits.RD2==0)      //cette boucle change l'état des ports RD1 et RD2 selon leur état précedents
    						{
    							PORTDbits.RD1=1;
    							PORTDbits.RD2=1;
    						}
    					else 
    						{
    							PORTDbits.RD1=0;
    							PORTDbits.RD2=0;
    						}
        			}               
    		}
    	
    	if(c<a && c<b && c<d && c<e)     // détection pour le télémètre c , Y5 s'allume
    		{
    			T3CONbits.TMR3ON=1;                //le compteur commence 
    			if(PIR2bits.TMR3IF==1)             // si le flag d'interruption est mis a '1', on rentre dans la boucle
    				{
    					TMR3L=0b10011011;           // on ré-initialise le timer3 a 59547
    					TMR3H=0b11101000;
    					PIR2bits.TMR3IF=0;          // on remet le flag a 0
    					T3CONbits.TMR3ON=0;         // on arrete de compter
    					if(PORTDbits.RD1==0 && PORTDbits.RD2==0)      //cette boucle change l'état des ports RD1 et RD2 selon leur état précedents
    						{
    							PORTDbits.RD1=1;
    							PORTDbits.RD2=1;
    						}
    					else 
    						{
    							PORTDbits.RD1=0;
    							PORTDbits.RD2=0;
    						}
        			}         
    		}
    
    	if(c<a && c<b && c<e && d<a && d<b && d<e)       // détection pour le télémètre c et d, Y6 s'allume
    		{
    			T3CONbits.TMR3ON=1;                //le compteur commence 
    			if(PIR2bits.TMR3IF==1)             // si le flag d'interruption est mis a '1', on rentre dans la boucle
    				{
    					TMR3L=0b10111100;           // on ré-initialise le timer3 a 60092
    					TMR3H=0b11101010;
    					PIR2bits.TMR3IF=0;          // on remet le flag a 0
    					T3CONbits.TMR3ON=0;         // on arrete de compter
    					if(PORTDbits.RD1==0 && PORTDbits.RD2==0)      //cette boucle change l'état des ports RD1 et RD2 selon leur état précedents
    						{
    							PORTDbits.RD1=1;
    							PORTDbits.RD2=1;
    						}
    					else 
    						{
    							PORTDbits.RD1=0;
    							PORTDbits.RD2=0;
    						}
        			}    
    		}
    
    	if(d<a && d<b && d<c && d<e)       // détection pour le télémètre  d, Y7 s'allume
    		{
    			T3CONbits.TMR3ON=1;                //le compteur commence 
    			if(PIR2bits.TMR3IF==1)             // si le flag d'interruption est mis a '1', on rentre dans la boucle
    				{
    					TMR3L=0b10000001;           // on ré-initialise le timer3 a 60545
    					TMR3H=0b11101100;
    					PIR2bits.TMR3IF=0;          // on remet le flag a 0
    					T3CONbits.TMR3ON=0;         // on arrete de compter
    					if(PORTDbits.RD1==0 && PORTDbits.RD2==0)      //cette boucle change l'état des ports RD1 et RD2 selon leur état précedents
    						{
    							PORTDbits.RD1=1;
    							PORTDbits.RD2=1;
    						}
    					else 
    						{
    							PORTDbits.RD1=0;
    							PORTDbits.RD2=0;
    						}
        			}    
    		}
    
    	if(d<a && d<b && d<c && e<a && e<b && e<c)       // détection pour le télémètre d et e, Y8 s'allume
    		{
    			T3CONbits.TMR3ON=1;                //le compteur commence 
    			if(PIR2bits.TMR3IF==1)             // si le flag d'interruption est mis a '1', on rentre dans la boucle
    				{
    					TMR3L=0b00000001;           // on ré-initialise le timer3 a 60929
    					TMR3H=0b11101110;
    					PIR2bits.TMR3IF=0;          // on remet le flag a 0
    					T3CONbits.TMR3ON=0;         // on arrete de compter
    					if(PORTDbits.RD1==0 && PORTDbits.RD2==0)      //cette boucle change l'état des ports RD1 et RD2 selon leur état précedents
    						{
    							PORTDbits.RD1=1;
    							PORTDbits.RD2=1;
    						}
    					else 
    						{
    							PORTDbits.RD1=0;
    							PORTDbits.RD2=0;
    						}
        			}    
    		}
    
    	if(e<a && e<b && e<c && e<d)       // détection pour le télémètre  e, Y9 s'allume
    		{
    			T3CONbits.TMR3ON=1;                //le compteur commence 
    			if(PIR2bits.TMR3IF==1)             // si le flag d'interruption est mis a '1', on rentre dans la boucle
    				{
    					TMR3L=0b01001010;           // on ré-initialise le timer3 a 61258
    					TMR3H=0b11101111;
    					PIR2bits.TMR3IF=0;          // on remet le flag a 0
    					T3CONbits.TMR3ON=0;         // on arrete de compter
    					if(PORTDbits.RD1==0 && PORTDbits.RD2==0)      //cette boucle change l'état des ports RD1 et RD2 selon leur état précedents
    						{
    							PORTDbits.RD1=1;
    							PORTDbits.RD2=1;
    						}
    					else 
    						{
    							PORTDbits.RD1=0;
    							PORTDbits.RD2=0;
    						}
        			}    
    		}
    }
    
    /*-----------------------------------fin déclaration de fonction--------------------------------*

  4. #4
    invited08e1382

    Re : Fréquence de fonctionnement du PIC18F4550

    personne ? vraiment ?

  5. A voir en vidéo sur Futura
  6. #5
    RISC

    Re : Fréquence de fonctionnement du PIC18F4550

    Salut,

    Si tu faisais voir ton schéma ????
    Quelle est la fréquence de ton quartz ?
    Le PIC18F4550 fonctionne au maximum à 48MHz

    a+

  7. #6
    invitea613d208

    Re : Fréquence de fonctionnement du PIC18F4550

    Il faut souvent se mefier des tempos qui peuvent etre diferentes dans la realite. Il faut voir aussi au niveau quartz, division de frequence ... deja si ton programme est simplement plus lent cela ne dois pas etre sorcier

    Bye

  8. #7
    invitea613d208

    Re : Fréquence de fonctionnement du PIC18F4550

    Oups dsl pour le dbl poste, mais je n'avais ps vu que tu utilisai des timers. J'ai deja eu des problemes avec eux sur des pics lorsque on les solicitent beaucoup

  9. #8
    invited08e1382

    Re : Fréquence de fonctionnement du PIC18F4550

    bonjour, merci pour vos réponses, j'utilise un quartz 20 Mhz, relié avec 2 condensateur à la masse de 15pF sur les borche osc1 et osc2, je vous envoi mon schéma ce soir (car je ne suis pas sur mon ordinateur)
    Oui , mon programme fonctionne simplement moin vite.
    Par exemple au début, j'ai une tempo de 1,2 seconde, en réel elle dure 30 seconde !
    Et normalement j'ai en sortie de la broche RD1 une fréquence de 500 hertz alors que j'obtien 20 Hertz... Il y a un facteur 25 que je ne voi pas...
    Merci encore

  10. #9
    invitea613d208

    Re : Fréquence de fonctionnement du PIC18F4550

    Est tu certain des valeurs condos du quartz ? C pas 22pf ?

  11. #10
    invited08e1382

    Re : Fréquence de fonctionnement du PIC18F4550

    Bonsoir,
    J'ai mis le schéma de cablage du PIC18F4550. J'ai pas mis tout le schéma par soucis de résolution de l'image mais de toute façon, sur ma labdec, il n'y a que le PIC, les LED, le quartz et les condo et capa qui vont avec le PIC.

    Est tu certain des valeurs condos du quartz ? C pas 22pf ?
    J'ai vérifier et la datasheet me dis bien de mettre des 15pF.
    Merci encore et bonne soirée à tous.
    Images attachées Images attachées

  12. #11
    invited08e1382

    Re : Fréquence de fonctionnement du PIC18F4550

    je tien à signaler que d'après mes observations, le ralentissement du PIC démarre au tout début du programme car le LED jaune qui indique l'éxécution de l'initialisation reste allumé 25 fois plus longtemp.
    Je pense donc que le probleme ne vient pas d'une mauvaise manip des timers mais provient plus de la mauvaise configuration des bits de configuration (#pragma config...)
    ou peut-être un soucis avec Mplab ?
    Si quelqu'un a une idée
    je continu de chercher de mon côté

  13. #12
    invitea613d208

    Re : Fréquence de fonctionnement du PIC18F4550

    Petite question, pour toi, le pic est censé pédaler a combien de Mhz ?

  14. #13
    invited7788175

    Re : Fréquence de fonctionnement du PIC18F4550

    bonsoir,
    petite remarque (je n'utilise pas de PIC mais un ATMEL) j'ai déjà eu un problème un peu du même genre et j'avais identifié deux solutions possibles:
    En mode debug le programme peut être plus lent.
    Sur l'atmel il existe un oscillateur interne ou un quartz externe en cas de mauvaise manipulation/programmation il est possible de se retrouver dans un mode bâtard particulièrement lent.

  15. #14
    invite29971eb1

    Re : Fréquence de fonctionnement du PIC18F4550

    Citation Envoyé par PIC sur PAC Voir le message
    bonsoir,
    petite remarque (je n'utilise pas de PIC mais un ATMEL) j'ai déjà eu un problème un peu du même genre et j'avais identifié deux solutions possibles:
    En mode debug le programme peut être plus lent.
    Sur l'atmel il existe un oscillateur interne ou un quartz externe en cas de mauvaise manipulation/programmation il est possible de se retrouver dans un mode bâtard particulièrement lent.
    Surtout quand tu mets un quartz de 8 ou 16MHz, mais que tu restes sur l'oscillateur interne...de 1MHz

  16. #15
    invited08e1382

    Re : Fréquence de fonctionnement du PIC18F4550

    Normalement, je dois fonctionner à 24MHz, et là, comme ftorama le dit, c'est comme si j'étais à 1 MHz !
    Cela viendrai d'où du coup ?

  17. #16
    invited08e1382

    Re : Fréquence de fonctionnement du PIC18F4550

    Bonjour, je vien de voir que la broche 4A6 (osc2) de mon PIC était configuré en digital...
    Or il faut apparemment la mettre en analogique pour un branchement de quartz comme le mien.
    Le bug vient peut-être de là.
    Je vous tient au jus

  18. #17
    invitefaaca50b

    Re : Fréquence de fonctionnement du PIC18F4550

    verifie quand meme tes configurations entre oscillateur interne et externe... Je suis sur (d'autres l'ont deja dit avant moi) que tu es en train de tourner sur l'oscillateur interne... Pour t'en assurer, enleve le quartz. Si ca continue pareil, tu es sur OSC INT...

  19. #18
    RISC

    Re : Fréquence de fonctionnement du PIC18F4550

    Salut,

    Cette configuration permet d'avoir l'USB (48MHz) et fcycle = 12 MIPS
    Code:
    #pragma config PLLDIV   = 5         //  Quartz 20 MHz (diviser par 5 pour l'entrée de la PLL x24)
    #pragma config CPUDIV   = OSC1_PLL2   
    #pragma config USBDIV   = 2         // Clock source from 96MHz PLL/2
    #pragma config FOSC     = HSPLL_HS
    a+

Discussions similaires

  1. Pic18f4550
    Par invite41088425 dans le forum Électronique
    Réponses: 4
    Dernier message: 14/04/2010, 22h00
  2. [Thermique] Chaudière gaz propane/Fréquence minimale de fonctionnement
    Par nours62 dans le forum Dépannage
    Réponses: 5
    Dernier message: 28/02/2010, 17h55
  3. Impulsions PIC18F4550
    Par invitead51e543 dans le forum Électronique
    Réponses: 2
    Dernier message: 29/01/2010, 20h51
  4. Microcontroleur Fréquence de fonctionnement
    Par invite1109a825 dans le forum Électronique
    Réponses: 33
    Dernier message: 12/12/2008, 00h32
  5. Comprendre PIC18F4550
    Par invitefc5e676f dans le forum Électronique
    Réponses: 4
    Dernier message: 29/10/2008, 22h26
Dans la rubrique Tech de Futura, découvrez nos comparatifs produits sur l'informatique et les technologies : imprimantes laser couleur, casques audio, chaises gamer...