Bonjour,
 
Voila je cherche à programmer un pic, mais je ne parviens pas à faire une fonction test de temps.  
 
En effet, il me faut qu'une fois un signal envoyé sur une patte du PIC, la fonction temps démarre et qu'un test de temps arrive soit :
 
#include <htc.h>
 
void main( void )  
{
 
//Initialisation des ports à 0
PORTA= 0x00;  
 
//Initialisation port sortie car RA3=entrée
TRISA = 0;
 
if (PORTA3=1)
{
fonction temps demarre...;
}
else
if (temps>2s)
{
PORTA2=1;
}
else
{
PORTA3=0;
}
}
 
Le problème étant que je ne parviens pas à trouver la manière de programmer cette fonction temps...
 
Es ce que quelqu'un pourrait il m'aider ?
 
Merci d'avance

Il faut utiliser des timers, suivant le modèle de ton PIC tu peux en avoir plus ou moins, en 8 ou 16 bits.
Tu peux regarder ce pdf : http://ww1.microchip.com/downloads [...] 51682A.pdf pour avoir une première idée (recherche google : pic tmr0 tutorial),
sinon regarder la doc de ton PIC.
Ca fait longtemps que j'ai pas touché à un PIC mais je peux essayer de t'aider après si nécessaire.

Bonjour, effectivement il y a ces fameuses fonction TMR0 dans les PIC que je choisis, mais le problème est que l'on atteint pas la seconde (enfin j'y suis pas arrivé pour le moins ) car ce sont des micro seconde et le cycle est limité !
Le pic que j'ai choisi est un 10F322 le plus basic car c'est pour un projet mais assez miniaturisé et je n'ai pas forcément besoin d'enorme place ou de fonction pour ce que je souhaite en faire.
 
Merci pour l'aide !

salut fxmartin,
 
tout dépend de ce que tu veux faire avec ta fonction temps, si tu as besoin de precision ou non.
 
- si ya besoin d'etre tres precis en terme de timming (exactement 2s): tu n'a pas le choix il faut se tapper la datasheet du uc 10fxxx et configurer le timer.
essay de prendre le prescaler le plus grand pour avoir une durée maximal. ensuite dans l'isr du timer tu declar une variable globale que tu increment a chaque fois que tu rentre dans l'ISR et tu viens tester cette valeur dans ton programme principale et lorsque elle atteint la valeure attendue, tu la remet a zero :
 
 
 
 
unsigned int DelayCounter=0;
 
 
__interrupt void Timer0_ISR(void)   // -- configurer le timer pour qu'il claque tout les millisecondes par exemple.  
{
  // Save CPU context
  ....
       DelayCounter++;
  ....
 // Restore CPU context
}
 
 
 
int main(void)
{
//Initialisation des ports à 0
PORTA= 0x00;  
 
//Initialisation port sortie car RA3=entrée
TRISA = 0;
 
// configuration du timer
 
// configuration de l'interruption timer
 
// autoriser les interruption global.
 
 
while(1)
{
 if (PORTA3=1)
   {
   // demarrer le timer....
   }
 else  
   {
   // Arreter le timer...
    }
 
if (DelayCounter>2000)  // si les 2s sont ecoulées...?
   {
    // action à faire...
   }
 else
   {
    // action à faire...
   }    
 }
}
 
 
 
 
- sinon deuxiemme solution si tu n'a pas besion de precision sur le timming: tu n'a qu a utiliser une boucle for  
 
et la ton code ressembla plus a:
 
 
void main(void)
{
unsigned int i=0;
 
while (1)
{
 
  for(i=0; i<2000000; i++)
     {
      // action a faire si le temps n'est pas encore ecoulé..
     }
  // action a faire losrque le temps est écoulé...    
}
}
 
voila j'epere que ca t'aidera.

Bonsoir,  
 
Merci pour cette réponse complète, En fait j'ai besoin d'une durée approximative de 2s dans un premier temps et après éventuellement faire du très précis faut que je vois pour l'avenir.
 
Merci pour l'aide je vais tester cela pour voir si je parviens à imbriquer cela correctement.
 
ça m'aide énormément déja à voir comment faire surtout.
 
Cela va me permettre de poursuivre mon micro projet et d'avoir un béta plus rapidement.
 
J'apprécie énormément.
 
Merci

avec TMR2 tu peux faire une horloge avec une résolution du dixième de secondes.
Avec les paramètres suivants si tu utilises l'horloge interne par défaut à 8 MHz (sauf erreur) :
prescaler = 64
PR2 = 240
postscaler = 13
Ca doit générer une interruption toutes les 0.0998 secondes (valeur théorique, faut voir la précision de l'horloge interne et le temps de traitement des interruptions) que tu peux utiliser pour incrémenter un compteur comme dit par ABMben.

Merci à vous ! Je suis justement en train de regarder tout ça de près pour avoir quelque chose d'effectif.
 
Après je ferais un test sous MPLAB avec la fonction stimulus ça devrait me permettre de tester de manière plus fonctionnelle !
 
Merci à vous deux, je vous tiens au courant bien entendu

Donc si j'ai bien compris ce que ABMBen m'a dit, mon code doit ressembler à cela :
 
#include <htc.h>
#include <PIC10F222.h>
 
// Configuration des Port GPIO GP0 sortie et GP1 entrée
int TRISGPIObits = 0b0000010;
 
// Configuration des pin en numérique
int ADCON1 = 0x06;
 
void main( void )
{
unsigned int i=0;  
 
while (1)  
{
if (GP1==1)
  for(i=0; i<2000000; i++)  
     {  
      // action a faire si le temps n'est pas encore ecoulé
 GP0==0;
     }  
  // action a faire losrque le temps est écoulé
GP0==1;
}  
}  
 
En considérant que ici 20000 représente le nombre d'incrémentation à faire avant d'arriver à la fin du compteur es ce exact ?