12-bit ADC to PIC18F2423

[kronanberg]

Bonjour,

Voila je travaille sur le PIC18F2423 sur le Convertisseur Analogique Numérique. Ce convertisseur est un convertisseur 12 bits.

Le résultat est contenu dans 2 registres ADRESH et ADRESL. Mais je ne vois pas dans la doc ou il précise que le résultat serait sur 16 bits.

Puisque je récupère la valeur de ces 2 registres, a priori elle me parait correcte mais je pensais récupérer un résultat sur 12 bits ???

Donc est-ce normal ?

Voici la fonction d'initialisation et de conversion du CAN :

/****************************************
*  		INITIALISATION DE ADC			*
*****************************************/
void Init_AD()
{
	TRISAbits.TRISA0 = 1;		//Pin AN0(RA0) en entree
	TRISAbits.TRISA1 = 1;		//Pin AN1(RA1) en entree
	TRISAbits.TRISA2 = 1;		//Pin AN2(RA2) en entree

	ADCON0 = 0x01;				
		//ADON = 1 ==> Enable converter module

	ADCON1 = 0x0C;
		//VCFG1 = 0 ==> Vss Voltage Reference
		//VCFG0 = 0 ==> Vdd Voltage Reference
		//PCFG  = C ==> AN0,1,2 Analog Input
	
	ADCON2 = 0x01;
}


/****************************************
*  		FONCTION CONVERSION				*
*****************************************/
unsigned int Convert()
{
	ADCON0bits.GO = 1;
	while(ADCON0bits.GO);
	return ADRES;
}

Merci pour les réponses !
-----

[DAUDET78]

J'y connait rien en PIC, mais tu récupéres sur 16 bits un résultat sur 12 bits
4 bits de droite de ADRESH
8 bits de ADRESL

Sauf erreur de ma part.

[Delivereath]

DAUDET78 t'a donné la bonne réponse. Tu as 4 bits superflus.

Tu peux néanmoins spécifier si tu veux le résultat aligné à gauche (donc 8 bits sur ADRESH + les 4 bits de poids fort sur ADRESL) ou bien si tu veux le résultat aligné à droite (4 bits de poids faible sur ADRESH + 8 bits sur ADRESL).

Ceci se fait avec le bit 7 du registre ADCON2 (voir page 229 de la datasheet).

[kronanberg]

Merci pour ces réponses !!

J'avais deja essayé en prenant les 12 premiers bits mais ça fonctionnait pas !!
J'avais pas fais gaffe au bit7 qui permet de sélectionner si le resultat est aligné à gauche ou à droite !!

J'essayerai ça demain mais normalement ça devrait fonctionner !!

Merci encore

[A voir en vidéo sur Futura]

[RISC]

Salut,

Attention au temps d'acquisition de ton convertisseur....je te recommande de bien lire les sections 2.1, 2.2 et 2.3 de la datasheet qui expliquent cela de manière détaillée.

Tu trouveras des exemples d'initialisation pour le convertisseur ici (filtre famille PIC18).

a+

[kronanberg]

Salut !!

Je viens de regarder les temps d'acquisition et c vrai que je ne respectait pas les temps minimum (mais apparemment ça fonctionnait quand même)

Du coup, j'ai fais un petit calcul de retour donc :

Le temps d'acquisition minimum avec une impédance d'entrée de 1,5 k est Tacq = 1, 44 us.

La période de l'horloge de conversion est de :
Tad = 8 * Tosc = 1 us (car j'utilise un quartz 8 MHz)

Je suis obligé d'attendre un minimum de 2 cycles d'horloge pour faire correctement l'acquisition de mon signal !

Voici mon code :

/****************************************
*  		INITIALISATION DE ADC			*
*****************************************/
void Init_AD()
{
	TRISAbits.TRISA0 = 1;		//Pin AN0(RA0) en entree
	TRISAbits.TRISA1 = 1;		//Pin AN1(RA1) en entree
	TRISAbits.TRISA2 = 1;		//Pin AN2(RA2) en entree

	ADCON0 = 0x01;				
		//ADON = 1 ==> Enable converter module

	ADCON1 = 0x0C;
		//VCFG1 = 0 ==> Vss Voltage Reference
		//VCFG0 = 0 ==> Vdd Voltage Reference
		//PCFG  = C ==> AN0,1,2 Analog Input
	
	ADCON2 = 0x89;
		//ACFM 	= 1 	==> Right justified
		//ACQT  = 001   ==> Acquisition Time is 2 TAD
		//ADCS 	= 001	==> Conversion clock is Fosc/8
}

/****************************************
*  		FONCTION CONVERSION				*
*****************************************/
unsigned int Convert()
{
	ADCON0bits.GO = 1;
	while(ADCON0bits.GO);
	return (ADRES & 0x0FFF);
}

La conversion de mes broche est ensuite réalisé toutes les 100 ms pour le moment. Pour cela j'utilise un Timer :

/********************************************
*		INTERRUPTION PRIORITE HAUTE			*
*********************************************/
#pragma interrupt high_isr
void high_isr(void)
{

	/************************************
	*   	INTERRUPTION TIMER 0	 	*
	************************************/
	if(INTCONbits.TMR0IF)			
	{						
		T0CONbits.TMR0ON = 0;		// stop the timer
		INTCONbits.TMR0IF = 0;		//Reset du flag d'Interruption
		
		ADCON0 = 0x01;				//Conversion broche AN0
		valeurA = Convert();

		ADCON0 = 0x05;				//Conversion broche AN1
		valeurB = Convert();

		ADCON0 = 0x09;				//Conversion broche AN2
		valeurC = Convert();

		T0CONbits.TMR0ON = 1;		// start the timer
	}


}

Voila je me demandais si il y avait peut être une solution pour rendre le code plus propre (genre en utilisant les interruptions!). Mais je ne vois pas trop comment pour le moment !!

Merci pour les réponses

[RISC]

Salut,

Il y a un mode spécial (Special Event Trigger) dans l'unité CCP utilisée en mode compare qui permet de lancer automatiquement le convertisseur A/N quand le Timer 1 ou le Timer 3 fait son rollover.
Il suffit d'initialiser le timer avec ta fréquence d'échantillonnage (10Hz)

a+

[kronanberg]

Salut !!

C'est interressant comme mode !! je ne le connaissais pas !!!
Je viens de lire le fonctionnement mais ça me parait encore un peu compliquer pour le moment !!!

Mais ce que je me dis c'est ou je vais définir les pin qui sont à convertir !!

Et le fais que je dois réaliser 3 conversions va m'obliger à les faire séquentiellement donc je ne sais pas trop si dans mon cas ce mode de déclenchement automatique de Conversion peut me servir !!!!

Merci pour ces réponses !! Ya trjs de nouvelles choses à découvrir

[RISC]

Salut,

Si tu as 3 conversions, tu utilises le timer1 ou 3 comme indiqué précédemment.
Si je suppose que tu dois convertir AN0, AN1 et AN2 tu auras donc la conversion AN0 qui sera démarrée automatiquement par le timer1 ou 3 en mode CCP2 trigger (voir datasheet section 2.8). Quand la conversion de AN0 est finie tu as une interruption, il te suffit donc, dnas l'interruption, de relancer une conversion en sélectionnant AN1 et idem quand AN1 est terminée, interruption et lancement de conversion sur AN2. Quand AN2 est terminée, choisir AN0 sans relancer la conversion et ...plus rien. 100ms plus tard la conversion sur AN0 sera de nouveau déclanchée par le CCP2 en mode compare.
Il suffit donc d'avoir une variable globale dans ton interruption qui indique le canal en cours de conversion et de tester quand c'est AN2 pour le remettre à AN0.
De cette manière toutes les 100ms tes 3conversions seront lancées les unes après les autres en cascade et de nouveau attente de la prochaine interruption automatique du timer.

a+