temporisation ajustable avec un 18f2221

[dodge256]

Bonjour à tous

Voilà je voudrais réaliser une temporisation ajustable ( avec potar ) sur un pic .
J'ai déjà lu quelques sujets sur le net mais le problème est qu'a chaque fois les programmes sont en asm et perso j'ai plus de connaissance en c .
Je compile avec ccs ( juste pour info ) .
Je pense utiliser une entrée de convertion A/N , mais le problème est que dans le programme je ne sais pas comment transformer cette information fournie par le convertisseur en une tempo qui varie en fonction du potar .

Auriez vous une idée , une piste , voir même un prog en c fonctionnant sur ccs ou mplab qui me permettrait de comprendre le principe ?

merci
-----

[invitefaaca50b]

tu cree une boucle imbriquee qui est lancee x fois par une boucle exterieure. X est la valeur de ton convertisseur sur 8 bits par exemple... Si ta boucle imbriquee fait:
- 1 seconde, tu pourras compter de 1 a 255 secondes en variant la position de ton potar
- 1 miliseconde, tu pourras compter de 1 a 255 milisecondes en variant la position de ton potar

Regarde les exemples sur le cours de Mr Bigonoff. C'est facile a comprendre... Gaffos aux temps d'execution des boucles qui selon les cas peuvent fausser le calcul. Expliqué aussi sur le site de Mr Bigonoff

Sinon, utilise PicDel (google) qui est un logiciel generateur de boucle de tempo... tu remplacera une variable par ta valeur de potar...

[dodge256]

Merci pour les informations .

Voila ce que donne mon programme .

while (1)
{
convertion=read_adc(adc_start_ and_read);
decompte=0;

while (decompte<convertion)
{
output_bit(pin_C0,1);
delay_ms(1);
decompte++;
delay_us(420);
}
output_bit(pin_C0,0);
delay_ms(5);
}

}


après test sur isis , cela fonctionne correctement .
J'ai bien une tempo de 2 secondes à 1minute .
Ce qui me dérange ce sont les delay .
Comment le site de bigonoff et temporairement fermé je n'ai pas pu lire ces tuto .
Auriez vous une autre solution que d'utiliser des delays ??

Merci

[RISC]

Salut,

La meilleure solution pour faire des délais précis est d'utiliser les interruptions.

a+

[A voir en vidéo sur Futura]

[invite3570b5f7]

Je sais pas si c'est "naze" comme solution mais je la donne quand même :

- en fait tu utilise l'ADC pour avoir ta valeur sur 10 bits.
Déjà tu baisse la fréquence du quartz ou de l'oscillateur au MAX genre 7KHz ( sur AVR ).

Ensuite avec le timer tu fais un compteur : milliers,centaines,dizaines,un ité ...

Cela évite les " delays "

[dodge256]

ok
Je teste et je vous tiens au courant .
merci

[dodge256]

Bonjour

voilà le fruit de mes recherches .
J'ai deux petits soucis .
1er : J'ai fait des tests sous mplab et je me suis aperçu qu'il y a un problème sur la convertion a/n .
Je ne sais pas pourquoi mais des que ADIF = PIR1<6> ET GO = ADCON0 <1> PASSE A 1 , mes valeurs disponibles dans ADRESH et ADRESL s'effacent du coup je n'ai pas le temps de les traiter .

2eme : mon timer0 , ne fonctionne pas .




//*********************c a/n ******************

#byte adcon0 = 0xFC2
#byte adcon1 = 0xFC1
#byte adcon2 = 0xFC0
#byte adresh = 0xFC4
#byte adresl = 0xFC3

#bit ADON=ADCON0.0
#bit GO=ADCON0.1

//****************** interruption ****************************

#byte T0CON = 0xFD5
#byte INTCON = 0xFF2
#byte INTCON2 = 0xFF1
#byte INTCON3 = 0xFF0
#byte PIR1 = 0xF9E // drapeaux d'interruption
#byte PIR2 = 0xFA1 // drapeaux d'interruption
#byte PIE1 = 0xF9D // active les interruptions
#byte PIE2 = 0xFA0 // active les interruptions
#byte IPR1 = 0xF9F // priorité d'interruption
#byte IPR2 = 0xFA2 // priorité d'interruption
#byte RCON = 0xFD0
#byte TMR0L = 0xFD6 // timer0 resulta bas
#byte TRM0H = 0xFD7 // timer0 resulta haut

#BIT TMR0ON =T0CON.7 // active timer 0
#bit INT0IE = INTCON.4 // active int0
#bit INT1IE = INTCON3.3 // active int1
#bit INT2IE = INTCON3.4 // active int2
#bit RBIE = INTCON.3 // active les interruption sur rb
#bit RCIE = PIE1.5 // active interruption reception euart

#BIT GIE = INTCON.7 // valide toute les interruptions
#bit PEIE = INTCON.6 // valide les interruptions periphériques
#bit TMR0IE = INTCON.5 // valide interruption timer0

#bit TMR0IF = INTCON.2 // drapeaux du timmer 0
#bit INT0IF = INTCON.1 // drapeaux de int0
#bit INT1IF = INTCON3.0 // drapeaux de int1
#bit INT2IF = INTCON3.1 // drapeaux de int2
#bit RBIF = intcon.0 // drapeaux rb
#bit ADIF = PIR1.6 // drapeaux c a/n
#bit RCIF = PIR1.5 // drapeaux reception euart

#bit TMR0IP = INTCON2.2 // priorité timer 0
#bit RBIP = INTCON2.0 // priorité port b
#bit RCIP = IPR1.5 // priorité interruption reception euart
#bit INT1IP = INTCON3.6 // priorité int1
#bit INT2IP = INTCON3.7 // priorité int2


//****************************** ****************************** *************

void init_acd (void);
void prechargement (void);
void init_inter (void);
void active_tmr0(void);
void can (void);
void desactive_tmr0 (void);

int16 acd = 0x0000;
int16 tempo=0x0000;

//*********************** interruption timer0 **************************

#INT_TIMER0
void timer0_isr ()
{
If (tempo == acd )
{
output_bit ( pin_a2,0);
tempo=0x0000;
desactive_tmr0();
}
else
{
tempo=tempo+1;
}

prechargement ();
TMR0IF=0x00;
}


//*********************** mise en marche timer o***************************** ***
void active_tmr0()
{
TMR0IP=0; // priorité timer 0
TMR0IF=0; // drapeaux de int0
TMR0IE=1; // active timer 0
TMR0ON=1;
}
//********************* desactive timer 0 *************************
void desactive_tmr0()
{
TMR0IP=0; // priorité timer 0
TMR0IF=0; // drapeaux de int0
TMR0IE=0; // active timer 0
TMR0ON=0;
}
//******************* init_interrupt ****************************** *

void init_inter ()
{
rcon = 0b10011100;
ipr1 = 0b00000000;
ipr2 = 0b00000000;
pie1 = 0b00000000;
pie2 = 0b00000000;
pir1 = 0b00000000;
pir2 = 0b00000000;
intcon = 0b01001000;
intcon2= 0b00000100;
intcon3= 0b00000000;
t0con = 0b00100000;



}


//*************************** prechargement compteur ************************

void prechargement ()
{
adresh=0xff;
adresl=0xe0;

}

//************************ convertion an ****************************** *

void can ()
{
//init_acd ();
ADON=1;
go=1;
do
{

}
while (go==1);
acd=ADRESH*256+ADRESL;
ADON=0;

}


//****************************** ****************************** ******

void main()
{



setup_spi(FALSE);
setup_wdt(WDT_OFF);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
setup_oscillator(False);
init_acd ();
init_inter();

while (1)
{
can ();

active_tmr0();
// output_bit ( pin_a2,1);
// prechargement ();

}
}

void init_acd ()
{
ADCON0 = 0b00001101;
ADCON1 = 0b00000001;
ADCON2 = 0b00100100;

}


merci

[dodge256]

J'ai trouvé la solution pour le convertisseur ( erreur dans ADCON0 ) pas le bon AN sélectionné .
ADCON0 = 0b00000001 .

En revanche pour le timer 0

[dodge256]

Lors de l'activation de gie et peie , le programme bloque et reste bloqué à la définition du .h

[dodge256]

J'ai trouvé d'où venait le problème .
J'avais mal configuré le PSA = TOCON<3> .
Pourriez vous m'expliquer a quoi sert ce bit ?
Je pense ne pas avoir bien compris .

Merci

[dodge256]

personne ??