J'aimerais réaliser une led qui clignote dont je pourrais régler (grâce à deux potar) la fréquence de clignotement ainsi que la durée d'allumage de celle-ci (je crois que cela s'appelle le duty-cycle).
Je m'explique autrement: je règle ma fréquence sur 2 Hz donc 1/2 seconde, puis je règle le temps d'allumage de ma led pour qu'elle puisse s'allumer entre 25 et 250 ms sans que ce réglage altère ma fréquence.
Voici mon programme, pour le réglage de la fréquence cela fonctionne parfaitement mais quand je veux y intégrer la notion durée d'allumage cela met le bazard, je n'arrive pas à faire coordonner ces deux notions: fréquence/duty-cycle.
Je viens d'atteindre les limites de mon cerveau.
Si vous avez une astuce pour palier ce problème, je vous en serais infiniment reconnaissant.
Cordialement
Les // en fin de programme ont été utilisé pour mes infructueux essais.
car je pense que c'est là que se situe mon souci.
// Programme: Clignotement d'une led dont la frequence de clignotement
// varie avec un potentiomètre ainsi que son duty-cycle
// Branchement des potentiomètres:
// Les deux broches extérieur des potentiomètres sont branchées.
// l'une sur le + 5 volt et l'autre sur le GND.
// La broche du milieu est branchée sur la pin analogique A0 pour la vitesse de clignotement/fréquence.
// La broche du milieu est branchée sur la pin analogique A1 pour le temp d'allumage/duty-cycle.
// La led utilisié est la led de l'arduino D13
//
//
// DECLARATION DES VARIABLES.
//=============================
//
// Variable pour le potentiomètre branché en A0 (vitesse de clignotement/fréquence).
const int potar = A0;
// Variable pour le potentiomètre branché en A1 (Temps d'allumage/duty-cycle).
const int potarT = A1;
//variable qui prend la valeur lu au potentiomètre (Vitesste de clignotement/fréquence).
int valeurLue;
// Variable qui prend la valeur lu au potentiomètre (Temps d'allumage/duty-cycle).
int valeurLueT;
// Variable valeur de la vitesse de clignotement/fréquence (float= variable avec virgule)
float frequence;
// Variable valeur du temps d'allumage/duty-cycle.
float temps;
// Variale de la led qui va clignoter
int led = 13 ;
void setup()
{
// Déclaration de la led pin 13 en sortie.
pinMode (led, OUTPUT);
}
void loop()
{
// On lit la valeur reçu au potentionmètre (Vitesse de clignotement/fréquence).
// on convertit en nombre binaire la tension lue en sortie du potentiomètre de vitesse de clignotement/fréquence.
valeurLue = analogRead(potar);
// On lit la valeur reçu au potentiomètre (Temps d'allumage/duty-cycle).
// On convertit en nombre binaire la tension lue en sortie du potentiomètre temps d'allumage/duty-cycle.
valeurLueT = analogRead (potarT);
//on traduit la valeur brute en tension à l'aide de map
frequence = map (valeurLue, 0, 1023, 25, 250); //conversion de la valeur lue en vitesse de clignotement/fréquence.
// cest à dire entre 25 ms et 250 ms. Ce qui correspond de 2 Hz à 20 Hz.
//on traduit la valeur brute en tension à l'aide de map
temps = map (valeurLueT, 0, 1023, 25, 250); //conversion de la valeur lue en temps d'allumage/duty-cycle.
// cest à dire que la durée d'allumage soit de 25 ms et 250 ms.
// On fait clignoter la led
digitalWrite(led, HIGH);
//delay(frequence);
//delay(temps);
//delay(100);
digitalWrite(led, LOW);
//delay(frequence);
//delay(temps);
//delay(100);
}
je pourrais régler (grâce à deux potar) la fréquence de clignotement ainsi que la durée d'allumage de celle-ci (je crois que cela s'appelle le duty-cycle).
On va préciser quelques termes :
Signal périodique : c'est un signal constitué par un motif qui est répété à l'infini
Période (T) : c'est un temps qui se mesure en seconde, c'est le temps correspondant à la durée du motif précédent.
Dit autrement c'est le temps pour que le signal se retrouve identique à lui même.
Fréquence(F) : l'unité est le hertz, symbole Hz. C'est l'inverse de la période F = 1/T
Rapport cyclique (duty cycle c'est de l'anglais) :
Cette notion s'applique pour un motif simple composé seulement d'un état haut et d'un état bas.
Il s'exprime en pourcentage. Quand on parle d'un rapport cyclique 60% par convention on parle du temps du "1" .
Un rapport cyclique (RC) de 60% correspont à un temps de "1" égal à 60% (ou 0,6 en nombre pur) de la période et un temps de "0" égal à 40% (ou 0,4 en nombre pur) de la période.
Ce qui veut dire que si tu est obligé de spécifier des temps pour constituer ton signal il faut spécifier :
une variable pour la période To ( --> on sait que Fo= 1/To).
une variable pour le rapport cyclique (RC).
une variable pour le temps du "1" en fonction du RC que tu veux: T_1 = To*RC (RC exprimé en nombre pur)
une variable pour le temps du "0" en fonction du RC que tu veux: T_0 = To*(1-RC)
Je fixe To et RC
J'allume
delais T_1
J'éteint
delais T_0
PS :
Quand on parle de rapport cyclique "60/40" il faut faire attention au contexte :
soit on donne le pourcentage du "1" suivi de celui du "0"
soit cela signifie, notamment pour une horloge, que le temps du "1" peut varier de 60 % à 40% du temps de la période.
D'accord avec 68tjs, a partir du moment ou tu appelles frequence la période, tu es mal parti.
Après c'est très simple
Tu sélectionnes la période entre 25ms et 1s (250ms c'est déjà un clignotement rapide) avec le 1er potar
Tu sélectionnes le temps d'allumage entre 25ms et la période précédement calculée avec le 2eme potar (tu peux aussi comme le suggère 68tjs introduire le rapport cyclique)
et ça roule tout seul
void loop()
{
// On lit la valeur reçu au potentionmètre periode
valeurLue = analogRead(potar);
// On lit la valeur reçu au potentiomètre Temps d'allumage
valeurLueT = analogRead (potarT);
int periode = map(valeurLue, 0, 1023, 1000, 25); //conversion de la valeur lue en periode
int tempsAllumage = map(valeurLueT, 0, 1023, 25, periode); //conversion de la valeur lue en temps d'allumage
// On fait clignoter la led
digitalWrite(led, HIGH);
delay(tempsAllumage);
digitalWrite(led, LOW);
delay(periode-tempsAllumage);
}
A toi, 68tjs pour cette véritable mise a niveau et de toutes tes explications délivrées avec pédagogie.
Un vrai cours magistral où tu as su me faire percer les arcanes du duty-cycle et de la fréquence.
A toi, kamill d'avoir pris de ton temps pour me retranscrire et corrigé mon code, j'ai fais un copié/collé et cela fonctionne à la perfection, je pense.....je suis même sur que malgré les excellentes explications de 68tjs j'aurai quand même galéré à mettre tous cela en forme.
Il va falloir que je bosse comme un damné pour avoir le dixième de votre niveau.
Cela s'appelle ne pas interrompre la transmission de la chaîne du savoir.
Quand j'ai commencer à travailler je ne savais quasiment rien, les collègues m'ont beaucoup appris, place aux nouvelles générations.
