generer un signal 40khz carre

**iceheart31** · 17/09/2012, 11h55

bonjour ,
je souhaite generer un signal de 40khz a l aide d un , sur un carte picdemplus2, compiler c18 et pickit3 en programmer, le tout sur mplab8.87

je pense que mon code a souffert de mes different essai mais je vous le soumet malgre tout ... J'ai de tres gros soucis avec l'utilisation des timer ... malgre les divers sujets lus sur le sujets ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
/*
 
 */
#include  <p18f4520.h> //ATTENTION penser a adapter la ref du uC
 
#pragma config OSC = INTIO67, FCMEN = OFF, PWRT = OFF, MCLRE = ON
#pragma config PBADEN = OFF
#pragma config LVP = OFF
#pragma config WDT = OFF, DEBUG=ON
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
#define TRISA_Init		0b00111111			//LEDS (RA6 et RA7 configure en output )
#define TRISB_Init		0b11111110			//RB0 configure en output
#define TRISC_Init		0b00111111			//Toutes les pins configurees en input par mesure de securite
#define	LED_PRESENCE	LATA = 0b10000000	//allume une LED : RA7 allumee et RA6 eteinte
#define	LED_ABSENCE		LATA = 0b01000000	//allume une LED : RA6 allumee et RA7 eteinte
#define Compteur_Pulses_TX_Init 20			//configure le nombre de pulses du compteur 
 
int  	Compteur_Pulses_TX;			//declaration de notre compteur de pulses emis
int  	Compteur_Pulses_RX;			//declaration de notre compteur pulses recus
int 	Compteur_MS_TIMEOUT;		//declaration de notre compteur nombre de cycles complets				///////////////////////////////////////////////////////////////////////////
 
void main(void) 
 
{	OSCCON = 0b01110000;			//configuration du registre de controle de l oscillateur 
	while (!(OSCCONbits.IOFS) )		//quand le bit IOFS (i/o frequency stable)est a 0
	Nop()
	OSCTUNE = 0b01000000;			//configuration du registre de reglage de l oscillateur  :oscillateur interne
	while (!(OSCCONbits.IOFS) )		//quand le bit IOFS (i/o frequency stable)est a 0
	Nop()							//,PLL active, frequence calibree en usine,
//Config des PORT
 
	TRISA = TRISA_Init;  	// initialisation de portA
	TRISB = TRISB_Init;		// initialisation de portB
	TRISC = TRISC_Init;		// initialisation de portC
//config des timer 0 et 1
//Timer0
	T0CON =   0b11000000; 		//Timer0 enable sur 16bits
	INTCON =  0;				//initialisation du registre interuption 0
	INTCON2 = 0b01000000;		//initialisation du registre interuption 2
	TMR0L	= 0b1010;			//
	//TMR0H	= 0;				//
								//
 
//
	T1CON =   0b10000001; 					//  enable en 16 bits
	INTCON =  0;							//initialisation du registre interuption 0
	INTCON2 = 0b100100;						//initialisation du registre interuption 2
//	TMR1L	= 0b11111111;//0b11011011;		//(40 000 000/4)=x; (10cm/34300=y)c'est le temps  pour parcourir 10 cm a la vitesse de la lumiere
//	TMR1H	= 0b11111111;//0b11111110;		//x*y =292 cycles, nous somme sur 16 bits donc 292 = la duree 
											//du timer
///////////////////////////////////////////////////////////////////////////////////////
TMR1H = 0;//initialise le timerH 1
TMR1L = 0;//initialise le timerL 1
 
while(1)
	{ 				///////////////////////////////////////////////////////////////////////////////////
	Compteur_Pulses_TX = Compteur_Pulses_TX_Init;	//initialisation du compteur de pulses emis
	TRISB = TRISB_Init;								// initialisation de portB
 
	// debut de l emission de pulses I0IO.....
	while	(Compteur_Pulses_TX)
		{ 	
			LATB = 0b00000001;				//creation d un pulse I		
 
			LATB = 0;						//creation d un pulse 0
		//	Nop();							//creer de courts delais afin d affiner le signal carre
 
		Compteur_Pulses_TX = Compteur_Pulses_TX -1;		//compte a rebour 20->0 dans l exemple
		}
	// passage en entree 
	TRISB = 0xFF;				// toutes les pins a 1, donc en entree	
	//init du TimeOut
//Timer0
	T0CON =   0b11000000; 		//Timer0 enable sur 16bits
 
	TMR0L = 0; 					//Timer0 low 
	INTCONbits.TMR0IF = 0;		//overflow flag bit a 0
	INTCONbits.INT0IF = 0;		//external interrupt flag bit a 0
	Compteur_MS_TIMEOUT = 500;	//500ms
	Compteur_Pulses_RX = Compteur_Pulses_TX_Init;	// init du cptr de pulses recues à 20, pour decrementer a chaque pulses reçues
 
/*while (Compteur_Pulses_TX)
	{
INTCONbits.TMR0IF == 1;//quand le flag passe a 1
TMR0L = TMR0L +1; 	   //tu incremente le timer 0
}*/	}
}

**Bktero** · 17/09/2012, 14h47

Ton code ne fait absolument pas ce que tu décris. D’ailleurs, je ne sais pas vraiment ce qu'il fait

Ici, tu fais des sorties et des entrées, alors que ton problème est de générer un signal carré à 40kHz. Je te conseille de créer un mini projet à côté pour ne réaliser que cette tâche et comprendre le principe.

Tu as 2 solutions :

Tout faire dans le while(1) du main. Soyons honnêtes, c'est une mauvaise solution.
Régler ton timer pour qu'il déclenche une interruption avec une fréquence de 80kHz. Chaque fois qu'une interruption a lieu, tu changes l'état de la patte. Tu auras donc un signal carré à 40kHz.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
	while	(Compteur_Pulses_TX)
		{ 	
			LATB = 0b00000001;				//creation d un pulse I		
 
			LATB = 0;						//creation d un pulse 0
		//	Nop();							//creer de courts delais afin d affiner le signal carre
 
		Compteur_Pulses_TX = Compteur_Pulses_TX -1;		//compte a rebour 20->0 dans l exemple
		}

Si tu as un oscilloscope, tu pourras tenter de regarder la fréquence du signal carré généré, mais tu risques de ne pas avoir assez de bande-passante car les changement se font extrêmement vite. Si tu souhaites être en attente active, tu dois attendre avant de changer d'état (pour 0 --> 1 et pour 1 --> 0).

**iceheart31** · 17/09/2012, 14h52

merci pour ta reponse . alors pour a voir branche la carte sur un oscillo , je vois passer un signal carré ....
cependant , tes remarques me semble pleine de bon sens ... je vais essaye de creuser dans ce sens ... merci , et je reste ouvert a toutes autre remarque, conseils etc ;..

**Bktero** · 17/09/2012, 14h57

En même temps, tu dois pas pouvoir monter à beaucoup plus de 4MHz avec le PIC et si tu as un oscilloscope correct tu as une bande passante de facilement 40MHz.... Je me suis un peu emballé

Quelle est la fréquence du signal que tu observes d'ailleurs ?

**iceheart31** · 17/09/2012, 14h59

je n'ai plus trop les chiffre en tete mais c'etait tres faible 4khz un truc comme ca ...

**iceheart31** · 17/09/2012, 15h54

j ai ecris ce bout de code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include  <p18f4520.h> //ATTENTION penser a adapter la ref du uC
#include <timers.h>


#pragma config OSC = INTIO67, FCMEN = OFF, PWRT = OFF, MCLRE = ON
#pragma config PBADEN = OFF
#pragma config LVP = OFF
#pragma config WDT = OFF, DEBUG=ON

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

/** I N T E R R U P T S ***********************************************/
#pragma interrupt InterruptService 
void InterruptService(void)
{
	if(INTCONbits.TMR0IF)
	{	// Interruption Timer0
		INTCONbits.TMR0IF = 0;
		WriteTimer0(65411); // //mettre la valeur adapté a son delais pour generer ici 
		// Ton traitement
		LATBbits.LATB0 = !LATBbits.LATB0;	// Example
	}
}	
#pragma code InterruptVector = 0x08
void InterruptVector (void)
{
  _asm
    goto InterruptService //saut dans la routine d'interruption
  _endasm
}

/** T R A I T E M E N T ***********************************************/
#pragma code
void main(void)
{
    // Set up global interrupts
    RCONbits.IPEN = 0;          // Désactive les niveaux de priorité sur les interruptions(mode compatibilité)
    INTCONbits.GIE = 1;        	// Autoriser les interruptions
    INTCONbits.PEIE = 1;      	// Autoriser les interruptions périphériques

	// Débordement Timer0 toutes les X secondes
	OpenTimer0(TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_256);
	WriteTimer0(65411); //mettre la valeur adapté a son delais pour generer ici 
		// Ton traitement
	INTCONbits.TMR0IF = 0;

	// Configuration des Ports
	TRISBbits.TRISB0= 0;
	
	// Initialisation des Ports
	LATBbits.LATB0 = 0;

	while(1)
	{
INTCONbits.TMR0IF = 1
LATBbits.LATB0 = (!(LATBbits.LATB0));//il refuse cette ecriture

	}
}

cependant j ai un soucis de syntaxe evers la fin du code

**Bktero** · 17/09/2012, 15h59

Bizarre puisqu'il l'accepte dans la routine d'interruption.... Pourquoi avoir mis des parenthèses en plus ?

De toute façon, tu n'en as pas besoin : tu as l'interruption pour modifier l'état de la sortie, pourquoi le faire aussi dans le while(1) ?

**iceheart31** · 17/09/2012, 16h50

bon , je vais reprendre demain . Voila ou en est mon code : le compteur ne se reinitialise pas tout seul ... (j'arrive pas d'ailleurs a le remettre a sa valeur pour qu'il recommence a compter toujours a partir du meme point ).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
/*
 ============================================================================
 Name        : fonctions.c
 Author      : Philippe Seguy
 Version     : 1.0
 Copyright   : Your copyright notice
 Description : Ansi-style
			   La fonction gere un signal TX a 40kHz et attend le retour de ce signal. Il s agit d'un signal ultrason
			   Ce fichier contient les fonctions necessaires a l inititialisation 
			   des Timer0, PORT.
				Il est prévu pour fonctionner avec un uC PIC18f13k22. J ai utilise MP Lab IDE 8.87
			   ,C18 et un programmer Pick it 3.
 
				Actuellement le PIC selectionner est un pic18f4520 pour les besoins de la simulation. PENSER a changer le PIC, 
				et verifier les configurations.
 ============================================================================
 */
#include  <p18f4520.h> //ATTENTION penser a adapter la ref du uC
#include <timers.h>
 
 
#pragma config OSC = INTIO67, FCMEN = OFF, PWRT = OFF, MCLRE = ON
#pragma config PBADEN = OFF
#pragma config LVP = OFF
#pragma config WDT = OFF, DEBUG=ON
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
/** I N T E R R U P T S ***********************************************/
#pragma interrupt InterruptService 
void InterruptService(void)
{
	if(INTCONbits.TMR0IF)
	{	// Interruption Timer0
		INTCONbits.TMR0IF = 0;
		WriteTimer0 (65411); // //mettre la valeur adapté a son delais pour generer ici 80khz
		// Ton traitement
		LATBbits.LATB0 = !LATBbits.LATB0;
		INTCONbits.TMR0IF = 0;	// Example
	}
}	
#pragma code InterruptVector = 0x08
void InterruptVector (void)
{
  _asm
    goto InterruptService //saut dans la routine d'interruption
  _endasm
}
 
/** T R A I T E M E N T ***********************************************/
#pragma code
void main(void)
{
    // Set up global interrupts
    RCONbits.IPEN = 0;          // Désactive les niveaux de priorité sur les interruptions(mode compatibilité)
    INTCONbits.GIE = 1;        	// Autoriser les interruptions
    INTCONbits.PEIE = 1;      	// Autoriser les interruptions périphériques
 
	// Débordement Timer0 toutes les X secondes
	OpenTimer0(TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_256);
	WriteTimer0 (65411); //mettre la valeur adapté a son delais pour generer ici 80khz
 
	// Ton traitement
 
 
 
	// Configuration des Ports
	TRISBbits.TRISB0= 0;
 
	// Initialisation des Ports
	LATBbits.LATB0 = 0;
 
//	while(1)
//	{
 
//	}
 
}

a nouveau je suis ouvert a toutes remarques , conseils, et pourquoi pas félicitations

ou protestations

merci a vous !!!!

**iceheart31** · 18/09/2012, 10h31

voila mon code final ..; vous en pensez quoi ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/*============================================================================
 Name        : fonctions.c
 Author      : Philippe Seguy
 Version     : 1.0
 Copyright   : Your copyright notice
 Description : Ansi-style
			   La fonction gere un signal TX a 40kHz et attend le retour de ce signal. Il s agit d'un signal ultrason
			   Ce fichier contient les fonctions necessaires a l inititialisation 
			   des Timer0, PORT.
				Il est prévu pour fonctionner avec un uC PIC18f4520. J ai utilise MP Lab IDE 8.87
			   ,C18 et un programmer Pick it 3.
 ============================================================================
 */
#include  <p18f4520.h> //ATTENTION penser a adapter la ref du uC
#include <timers.h>
 
 
#pragma config OSC = INTIO67, FCMEN = OFF, PWRT = OFF, MCLRE = ON
#pragma config PBADEN = OFF
#pragma config LVP = OFF
#pragma config WDT = OFF, DEBUG=ON
 
 
#define nbre_pulses 20					// quantité de pulses à envoyer 
 
void gestion_timer0 (void);				// prototype de la fonction (faire un fichier header qui les regroupera toutes)
 
 
 
/** I N T E R R U P T S ***********************************************/
 
#pragma code InterruptVector = 0x08
void InterruptVector (void)
{
	 if(INTCONbits.TMR0IF) // Interruption Timer0
	{
		gestion_timer0();
	}
}
 
/** T R A I T E M E N T ***********************************************/
#pragma code
 
 
/************************************************************************
*                                                                                                                                               *
*                                                       GESTION INTERRUPTIONS                                           *
*                                                                                                                                               *
************************************************************************/
 
/*
	cptr_pulses est une variable qui compte le nombre de pulses envoyé
	on test si l'interruption vient de TMR0IF
		si oui=>	- on va dans la fonction gestion_timer0()
					- on test si on a envoyé assez de pulses
			si oui=>	- alors on le repasse à 0
						- on met à 45536 le TIMER0 pour avoir la prochaine interruption dans 10ms
						- on assure de mettre la pin RB0 à 0
			si non=>	- on inverse la polarité de RB0
						- on met à 65511 le TIMER0 pour avoir les pulses à 40kHz
						- on incrémente le compteur de pulses
					- on efface le flag TMR0IF
					- on replace le bit GIE à 1 pour réactiver les interruptions							
*/
 
 
void gestion_timer0 (void)
{
	static unsigned char cptr_pulses;
 
	if (cptr_pulses == nbre_pulses)
		{
			cptr_pulses = 0x00;
			WriteTimer0 (45536); 	// 10ms / 500ns = 20000
									// 65536 - 20000 = 45536
		}
	else
		{	
			LATBbits.LATB0 ^= 1;
			WriteTimer0 (65511);
			cptr_pulses = cptr_pulses + 1;
		} 
 
	INTCONbits.TMR0IF = 0;
	INTCONbits.GIE = 1;
}
 
/************************************************************************
*                                                                                                                                               *
*                                                       PROGRAMME PRINCIPAL                                                     *
*                                                                                                                                               *
************************************************************************/
 
void main(void)
{
    // Set up global interrupts
    RCONbits.IPEN = 0;          // Désactive les niveaux de priorité sur les interruptions(mode compatibilité)
    INTCONbits.GIE = 1;        	// Autoriser les interruptions
    INTCONbits.PEIE = 1;      	// Autoriser les interruptions périphériques
 
	// Premier Débordement Timer0 à 10ms (les trames de détections de présence sont envoyées toutes les 10ms)
	// 10ms / 500ns = 20000
	// 65536 - 20000 = 45536
	OpenTimer0(TIMER_INT_ON & T0_16BIT & T0_SOURCE_INT & T0_PS_1_1);
	WriteTimer0 (45536); 
 
	// Configuration des Ports
	TRISBbits.TRISB0= 0;
 
	// Initialisation des Ports
	LATBbits.LATB0 = 0;
 
	while(1)				// bouclage en attendant les interruptions
	{
 
	}
}

**iceheart31** · 25/09/2012, 08h52

j ai reussi a generer mon signal carre , a ceci pres : le temps ou le signal est a 0 est plus long de qq *µs... et ce quelque soit la technique utilisée .. c'est embetant .... a votre avis est ce un soucis avec ce modele de pic ( PIC18f4520) ? ou autre chose .. merci

**pfeuh** · 25/09/2012, 09h19

Salut,

Envoyé par iceheart31

j ai reussi a generer mon signal carre , a ceci pres : le temps ou le signal est a 0 est plus long de qq *µs... et ce quelque soit la technique utilisée ..

Je ne vais pas parler spécifiquement de ton PIC, mais des micros en général.

Tu génères ton signal par interruption, c'est donc normal de ne pas être précis, le temps de réponse à une interruption est variable à cause des niveaux de priorités d'interruptions, de l'instruction que le micro est en train d'exécuter (toutes les instructions ne prennent pas forcement le même nombre de cycles, en plus ne micro ne va pas sauter à l'interruption en plein milieu d'une instruction), etc...

Donc si c'est faisable, le plus simple est de configurer un timer en auto reload et de le router vers une GPIO (general purpose input output pin) quelconque. Comme ça ton signal carré vivra sa vie tout seul indépendamment du programme. Si tu veux changer de fréquence, reprogramme simplement le diviseur du timer. A toi de voir si ton PIC le permet.

A+

Pfeuh

generer un signal 40khz carre

C

Discussions similaires

Partager

Partager