Bonjour à tous,
J'ai absolument besoin de vous car je réalise un projet qui ne fonctionne toujours pas et la soutenance est dans 3 jours...
J'ai besoin de comparer 3 tensions entrant sur les pattes RA0, RA1 et RA2 d'un PIC18F252. La patte recevant la plus grande des trois tensions doit allumer une diode ( respectivement sur les pattes RC1, RC2 et RC3).
Comment dois-je m'y prendre pour faire cette comparaison ( je programme en C)?
Merci pour votre aide
bonjour,
il suffit de faire une lecture de ces 3 entrées analogique en utilisant le CAN du PIC.
Après c'est facile de trouver la plus grande de valeurs.
Regarde donc de plus près la mise en oeuvre du convertisseur analogique numérique.
A+
Voilà le code de mon convertisseur sur la patte RA0 mais ca marche toujours pas. Ce sont sans doute les bits du registre ADCON qui sont mal configurés. MAis je n'y arrive ni avec la commande OpenADC ni manuellement...
[CODE][#include <p18f252.h>
#include <adc.h>
#include <timers.h>
#include <delays.h>
/****************************** ***********************/
/* définitions des pins I/O */
/****************************** ***********************/
#define DEL1_TRIS TRISCbits.TRISC1
#define DEL1 PORTCbits.RC1
#define PdW_TRIS TRISA
#define PdW1 PORTAbits.RA0
/***************************/
/* variables diverses */
/***************************/
long tension_PdW1; /*tension aux bornes du pont de Wheatstone de la premiere bobine*/
/****************************** ****************************** ***********/
/* Cette fonction fait un delai de "temps" x 0,25 seconde */
/* sur un pic tournant a 40Mhz */
/****************************** ****************************** ***********/
void attendre (short temps)
{
short i; /* variable de boucle */
for (i = 0; i < temps; i ++)
Delay10KTCYx(0); /* delai de 0,25 seconde sur un pic a 40Mhz*/
}
/****************************** */
/* fonction principale */
/****************************** */
void main (void)
{
/* On active le convertisseur analogique/numerique*/
// OpenADC(ADC_FOSC_2 & ADC_8ANA_0REF & ADC_RIGHT_JUST,ADC_CH0 &ADC_CH1 &ADC_CH2 & ADC_INT_OFF);
// on met les pins à la main
ADCON0bits.ADON = 1;
ADCON0bits.ADCS1 = 0;
ADCON0bits.ADCS0 = 0;
ADCON1bits.ADCS2 = 0;
ADCON1bits.ADFM = 1;
ADCON1bits.ADCS2 = 0;
/* on configure les pins en I/O*/
DEL1_TRIS=0;
PdW_TRIS=1;
/*on demarre la boucle infinie */
while (1)
{
/* acquisition et conversion de la tension PdW1 */
tension_PdW1 = 0;
SetChanADC(ADC_CH0);
Delay10KTCYx(40);
ConvertADC();
while (BusyADC()) ;
tension_PdW1 = ReadADC();
if (tension_PdW1 < 2,5)
{DEL1= 0;}
else DEL1=1;
}
}
]
je te laisse entre les mains des pro du pic
A+
bon, je ne connais rien aux pic, mais je viens de regarder la doc.
Un truc me surprend dans ton initialisation:
d'après la doc, ça veut dire que le pic est cadencé à 1,25MHz.ADCON0bits.ADCS1 = 0;
ADCON0bits.ADCS0 = 0;
ADCON1bits.ADCS2 = 0;
Peut-être que j'interprète mal cette doc, mais d'après ce que j'ai compris, il faut ajuster l'horloge du convertisseur afin que le temps de conversion soit de 1,6µs par bit, donc 16µs pour une conversion de 10 bits.
Si le pic est cadencé à 40MHz par exemple, il faudra donc mettre 110 dans ces 3 bits pour ajuster l'horloge de conversion.
Je ne suis pas allé plus loin dans ton programme car je crois que ça coince déjà ici.
A+
[QUOTE=Jack]
Un truc me surprend dans ton initialisation:
d'après la doc, ça veut dire que le pic est cadencé à 1,25MHz.
QUOTE]
ça, déjà je ne le savais même pas...en fait mon pic oscille à 4Mhz (erreur de copier-coller...) donc je vais configurer les ADCS en 110 comme ca j'aurais T = 1/ (Fosc/64) = 1/(4e6/64) = 0,000016 s= 16µs.
mais bon, ca ne marche toujours pas....je desepère
l'ideal est de s'approcher de 1,6µs.
Pour le reste, tu utilises des fonctions faisant partie d'une bibliothèque, mais ça a l'air correctement écrit.
Qu'est ce qui te fait dire que ça ne fonctionne pas? Quel est le résultat lu à l'issue de la conversion? Et quelle est la tension d'entrée?.
A+
petit complément d'information:
tu parles à l'origine de 3 tensions. Les 2 autres tensions sont-elles reliées aux entrées analogiques?
Vérifies également avec un multimètre, ou mieux un oscillo l'allure de la tension fournie par ton pont de wheastone.
A+
en fait, mes entrées seront 3 tensions issues de 3 ponts de wheatstone dans le projet complet mais pour l'instant je teste le convertisseur AN avec un seul signal : du continu issue d'un générateur +5V/0V.
est-ce que je peux utiliser la valeur 2,5 ou y'a-t'il une histoire de conversion decimal-hexadecimal-binaire?
après un autre calcul, j fais configurer en 001 soit Fosc/8 et j'atteint 2µs.
malgré ces changements, ca ne marche toujours pas puisque la DEL ne s'éteint jamais. comment puis-je connaitre le résultat lu l'issue de la conersion?
tu ne peux pas tester ton programme en pas à pas sur ta carte???
Ca va être dur. dans ce cas, tu peux éventuellement sortir le résultat sur un port. Il te suffira de relever les niveaux logique et faire la conversion binaire/décimal.
Ton système ne possède pas de simulateur à tout hazard? Ca te permettrait de savoir si ton can est bien initialisé.
A+
alors en fait, j'ai tout repris et finalement le CAN marche et la DEL s'allume ou s'éteint au bon moment.
maintenant, c'est la comparaison des trois fonctions qui pose des problèmes. les trois DEL s'allument alors que seule une devrait être allumée à la fois.
pour le programme à un port, j'ai utilisé une comparaison de la tension (type int ) à un nombre en hexadecimal ( 0x1FF par exemple ce qui correspond à 2,5V). mais comparer 2 tensions entre elles ne donne rien...
mais pourquoi tu ne lis pas séquentiellement les trois entrées analogiques pour comparer ensuite leur valeur numérique?
C'est quand même plus simple.
A+
Je ne vois pas exactement ce que vous voulez dire par "lire séquentiellement". ce que je fais, c'est que je fais successivement l'acquisition des 2 tensions stockées dans 2 variables, que je compare ensuite. de la même façon que j'ai comparé tension et 0x1FF.
en tous cas, même si ca n'avance pas vite parce que je n'y connais pas grand chose, merci pour votre aide et votre patience!!
ok, je n'avais pas bien compris.Je ne vois pas exactement ce que vous voulez dire par "lire séquentiellement". ce que je fais, c'est que je fais successivement l'acquisition des 2 tensions stockées dans 2 variables, que je compare ensuite. de la même façon que j'ai comparé tension et 0x1FF.
précise à nouveau le but de ces comparaisons et montre-voir le code correspondant.
A+
évite de laisser les 2 entées inutilisé en l'air. Sinon il est fort probable que les valeurs lue soit très proche de la valeur de la dernière "bonne" convertion précédente.Envoyé par induc
Tu as raison de dire qu'il ne faut pas laisser les entrées en l'air mais je ne pense pas que le résultat soit celui de la dernière bonne conversion.Sinon il est fort probable que les valeurs lue soit très proche de la valeur de la dernière "bonne" convertion précédente.
La conversion se fera dans tous les cas mais le résultat sera sans signification.
A+
pour Xavier35, je n'ai configuré que les 2 pins que j'utilise ( RA0 et RA1, pour mon programme qui teste la comparaison entre 2 tensions)
pour jack : au final, je dois comparer 3 tensions issues de trois ponts de Wheatstone. Et je dois repérer quel signal est le plus grand.
J'arrive à comparer la valeur d'une tension d'une entrée à une valeur que je fournis en hexadecimal (par exemple 0x1FF).
Ensuite, je mets deux tensions en entrée etj'essaye de les comparer mais là, ca coince.
Voilà le code :
#include <p18f252.h>
#include <adc.h>
#include <timers.h>
#include <delays.h>
/****************************** ***********************/
/* définitions des pins I/O */
/****************************** ***********************/
#define DEL1_TRIS TRISCbits.TRISC1
#define DEL1 PORTCbits.RC1
#define DEL3_TRIS TRISCbits.TRISC3
#define DEL3 PORTCbits.RC3
#define PdW_TRIS TRISA
#define PdW1 PORTAbits.RA0
#define PdW_TRIS TRISA
#define PdW2 PORTAbits.RA1
/***************************/
/* variables diverses */
/***************************/
int tension_PdW1; /*tension aux bornes du pont de Wheatstone de la premiere bobine*/
int tension_PdW2;
/****************************** ****************************** ***********/
/* Cette fonction fait un delai de "temps" x 0,25 seconde */
/* sur un pic tournant a 40Mhz */
/****************************** ****************************** ***********/
void attendre (short temps)
{
short i; /* variable de boucle */
for (i = 0; i < temps; i ++)
Delay1KTCYx(0); /* delai de 0,25 seconde sur un pic a 40Mhz*/
}
/****************************** */
/* fonction principale */
/****************************** */
void main (void)
{
/* On active le convertisseur analogique/numerique*/
// OpenADC(ADC_FOSC_2 & ADC_8ANA_0REF & ADC_RIGHT_JUST,ADC_CH0 &ADC_CH1 &ADC_CH2 & ADC_INT_OFF);
// on met les pins à la main
ADCON0bits.ADON = 1;
ADCON0bits.ADCS0 = 0;
ADCON0bits.ADCS1 = 0;
ADCON1bits.ADCS2 = 1;
ADCON1bits.ADFM = 1;
ADCON1bits.ADCS2 = 0;
/* on configure les pins en I/O*/
DEL1_TRIS=0;
DEL3_TRIS=0;
TRISC=0;
PdW_TRIS=1;
/*on demarre la boucle infinie */
while (1)
{
/* acquisition et conversion de la tension PdW1 */
tension_PdW1 = 0;
SetChanADC(ADC_CH0);
Delay1KTCYx(20);
ConvertADC();
while (BusyADC()) ;
tension_PdW1 = ReadADC();
/* acquisition et conversion de la tension PdW1 */
tension_PdW2 = 0;
SetChanADC(ADC_CH0);
Delay1KTCYx(20);
ConvertADC();
while (BusyADC()) ;
tension_PdW2 = ReadADC();
if (tension_PdW1 < tension_PdW2)
{
DEL1= 0;
DEL3 =1;
}
else {
if (tension_PdW1 > tension_PdW2)
{
DEL1=1;
DEL3 = 0;
}
else {DEL1=1; DEL3=1;}
}
}
}
ça n'a rien à voir mais tu peux oter les lignes tension_PdW1 = 0;
tension_PdW2 = 0;
car elles ne servent à rien.
Sinon ton programme a l'air correct.
Résumons:
* si tu compares l'entrée 1 avec une constante, ça marche
* si tu compares l'entrée 2 avec une constante, ça marche
* si tu compares l'entrée 1 avec l'entrée 2, ça marche pas
c'est çà?
A+
au fait, est-ce que tu as besoin d'une résolution de 10 bits?
A+
exactement!
a+
en fait le codage en binaire c'est pas mon truc... je ne sais même pas à combien de bits correspond quelle précision.
d'après mes coéquipiers, les tensions seront comprises entre 0 et 2v ( 0 quand le pont est équilibré et ~2V sinon). voilà tout ce que je sais.
A+
Si tu regarde la structure du CAN, il est d'abord constituer d'un multiplexeur, et puis d'un "sample & hold" avec un tout petit courant de fuite avant le switch de "sample".
L'or de la sélection d'une pin en l'air, le condo "hold" gardera sont état de charge précédent, et, avec 2 conversion succesive, il n'a pas vraiment le temps de se décharger tres fort. surtout avec un "sampling time" très court.
c'est bien dommage.
L'idéal aurait été que la tension puisse varier entre 0 et 5 volts pour avoir une résolution maxi.
Bon, il faut être sur que la conversion est fiable. Tu peux modifier ton programme de manière à tester indépendemment les 2 entrées.
Je m'explique: tu compares la 1ère entrée à une valeur fixe, 0x40 par exemple et tu affiches le résultat sur une led.
Tu compares également la 2ème entrée avec 0x80 par exemple et tu affiches sur une 2ème led.
Ensuite tu relies les 2 entrées à une tension continue que tu augmentes progressivement de 0 à 5V.
Si tout va bien, la 1ère led devrait s'allumer, puis la 2ème.
A+
C'est possible. Ca dépend de la technique utilisée pour le can à approximations successives.L'or de la sélection d'une pin en l'air, le condo "hold" gardera sont état de charge précédent, et, avec 2 conversion succesive, il n'a pas vraiment le temps de se décharger tres fort. surtout avec un "sampling time" très court.
Sur les motorola par exemple, la charge était commutée et répartie dans une séries de condensateurs à valeur pondérées.
Sur les pics, je ne connais pas le principe.
Dans tous les cas, on est d'accord: pas d'entrée en l'air
A+
tout va bien!
mais les comparer 2 à 2 ne marche toujours pas...
je viens de rentrer.
En regardant ton source précédent, je viens de remarquer que tu avais écrit
SetChanADC(ADC_CH0);
pour lire l'entrée 1. Or là, tu lis à nouveau l'entrée 0 (les joies du copier/coller je suppose). Du coup tension_PdW2 et égale à tension_PdW1 et c'est normal que les 2 leds s'allument.
A+
c'était bien ça....alala!!! et la comparaison des 3 tensions marche à merveille!
en tous cas, merci beaucoup pour toute votre aide précieuse. j'ai beaucoup avancé... maintenant je m'attaque à mes interruptions qui ne se déclenche qu'une fois
encore vraiment merci!
à+
