Bonjours
j'aimerais savoir si je peux calculer le temps entre instructions dans programme sur l'arduino uno.
je fais par exemple:
int v=13;
l=7;
void setup () {
pinMode(13,OUTPUT);
pinMode(7,INPUT);
}
void loop () {
if (digitalRead(7)==HIGH){
digitalWrite(13,HIGH)}
if (digitalRead(7)==LOW){
digitalWrite(13,LOW)}
}
comment je peux savoir combien de temps la led branchée sur pin 13 a resté allumé?
y a t'il un moyen de le savoir?
merci d'avance
hello
oui, avec millis() avant et après
ou micro()
oui, avec millis() avant et après
ou micro()
Surtout pas !
Le résultat sera faux car ces fonctions gèrent le débordement du timer 0 et donc "consomment" des cycles horloges pour elles même.
Une autre raison de ne pas les utiliser est que le préscaler du timer 0 est très mal configuré pour ce type de mesure = 8 ce qui veux dire que le pas minimum de mesure est égal 8 cycles horloge.
Solution :
Comme millli ou micro tu va utiliser un timer mais tu va bien le configurer.
Le timer 0 est utilisé par les fonctions delay et milli donc on le laisse.
Il reste T1 qui est 16 bits et T2 qui est 8 bits.
Il faut configurer le prédiviseur à 1. Comme cela la lecture du registre du compteur TCNTx donne directement le nombre de cycles horloge utilisés.
Le plus simple est d'utiliser le timer 2 qui est 8 bits et compte de 0 à 255.
Un compteur déborde --> quand il arrive au maximum il retombe à 0.
Il ne faut pas à avoir à gérer les débordement car cela fausserait la mesure.
Juste avant le code que tu veux mesurer tu fait une raz (remise à zéro) :
TCNT2 = 0 ; // Raz pour ne pas avoir à gérer les débordements
/*
code à mesurer
*/
Nombre_de_cycles_horloge = TCNT2 ; // Mesure directe
Tout est expliqué dans la datasheet du micro-controleur à télécharger sur le site du fabricant : Atmel.
Le prescaler se règle dans le registre TCCR2B
Il suffit de mettre le bit CS20 à 1 pour ne pas diviser la fréquence de système de 16 MHz.
C'est à dire que dans le setup() tu ajoute la ligne :
TCCR2B = 1 ;
autant pour moi!
merci beaucoup 
si le résultat par exemple est:
Nombre_de_cycles_horloge = 200;
que signifie 200 pour que je puisse trouvé le temps qu'il a fallu?
Quel nom ai-je donné à la variable ?
Il me semble que c'est Nombre_de_cycles_horloge c'est parlant non ?
Un cycle horloge c'est une période du signal horloge.
Pour un signal périodique la période est l'inverse de la fréquence.
La fréquence est celle du micro-contrôleur c'est à dire 16 MHz.
Donc une période = 1/16 000 000 = 62,5 ns.
bonjour
merci pour votre patience
je suis encore débutant et c'est pourquoi je pose un peu trop de question
le compteur a comme valeur maxi 255 soit un temps de 15.9375 ms, et donc si le programme est mesuré dépasse les 5 minutes par exemple! comment je peux le mesuré?
Tu adapte le préscaler.
Si tu utilise un préscaler de 8, tu pourra mesurer un temps 8 fois plus long mais le pas de mesure ne sera plus 1 cycle horloge mais 8 cycles horloge.
Autre solution tu utilises le timer 1 qui est 16 bits et qui peut compter de 0 jusqu'à 216 -1 soit 65535.
Remarque : je t'ai donné une méthode pour mesurer les temps d'exécution de fonctions simples où la précision de la mesure peut être importante.
Si les temps que tu veux mesurer sont si long autant utiliser milli() tu ne sera pas à 20 cycles horloge près et tu pourra mesurer jusqu'à 49 jours.
le temps que je vais mesurer atteint parfois une heure deux heures ou plus.
et ce que je veux calculer c'est combien de temps la led a resté allumer, un quart d'heure, une heure ... ou plus!
et même la valeur trouver avec milli() comment je vais la convertir à une valeur de temps?
si je trouve par exemple une valeur de 60 (60 ms, ou 60 us ou quoi au juste?)
Bonjour,
toutou2525:
comment je peux savoir combien de temps la led branchée sur pin 13 a resté allumé?
y a t'il un moyen de le savoir?
Moi je ne comprend pas la question initiale. Le temps que la led va rester allumée dépend essentiellement du temps que l'entrée 7 va être haute puisque le programme recopie l'entrée 7 sur la sortie 13.
'' Moi je ne comprend pas la question initiale. Le temps que la led va rester allumée dépend essentiellement du temps que l'entrée 7 va être haute puisque le programme recopie l'entrée 7 sur la sortie 13.''
l'entrée 7 soit HIGH ou LOW d'une manière automatique, donc je veux bien savoir combien de temps elle a resté HIGH ou l'inverse
Tu veux mesurer le temps que la led reste allumée a chaque cycle ou le temps total qu'elle reste allumée?
le temps total qu'elle reste allumer
Il faut mesurer le temps entre de début de l'allumage et la fin de l'allumage et cumuler les temps.
Ce qui donne par exemple:
int v = 13;
int l = 7;
void setup () {
pinMode(13, OUTPUT);
pinMode(7, INPUT);
}
void loop () {
static unsigned dureeAllumage=0;
static unsigned debutAllumage=millis();
static byte etatprec=LOW;
byte etat=digitalRead(7);
if (etat == HIGH) {
digitalWrite(13, HIGH);
}
if (etat == LOW) {
digitalWrite(13, LOW);
}
if (etat==HIGH && etatprec==LOW)
{
// on vient d'allumer la led
debutAllumage=millis();
}
else if (etat==LOW && etatprec==HIGH)
{
// on vient d'éteindre la led
dureeAllumage+=millis()-debutAllumage;
}
etatprec=etat;
}
merci pour vos réponse
ce que je veux: je vais allumer la led à l'aide d'un bouton poussoir pendant un temps (disant 10 min) puis je vais l'éteindre à l'aide de ce bouton. Puis utiliser le temps que la led a été allumé dans un autre calcul dans mon programme. la led est allumée et éteint automatiquement.
Mouais.....
Ce n'est pas tout a fait ce que le titre du message laisse entendre.............
Tu aurais dis dès le départ ce que tu voulais faire EXACTEMENT on aurait tous gagné du temps.
pardon je me suis mal exprimé
alors donc j'utilise l'instruction millis()?
oui