Détection de top synchro sur FI sur 162kh (fréquence étalon).

**Pat42** · 18/03/2020, 16h26

Bonjour a tous,
Il y a quelques mois de cela , vous m'avez aidé à mettre au point un fréquencemètre avec la soustraction des FI et autres
petites choses qui vont bien, pour lire précisément les fréquences en AM et en FM sur certains de mes récepteurs radios
dont je fais la collection et je m'en suis bien sortie (compréhension des timers 1 et 2).

Il ya peu de temps je me suis fabriqué un récepteur sur 162 khz (FRANCE INTER: heure étalon) pour étalonner
mes deux fréquencemètres,et ils en avaient besoin...

Puis il m'est venu l'idée de récupérer la modulation de phases (photo jointe), pour le fun et mettre au point ma petite horloge a moi...

Mais malheureusement! les quelques connaissances que j'ai acquéri ne me suffisent pas pour résoudre le premier pb sur lequel je bute.

Aprés avoir passé des heures devant mon écran
à tester milli(); delay, les interruptions...et avoir parcouru le net, je demande de l'aide!

Je vous explique;

Pendant la 59 em secondes du code horaire (voir photo), il ya un silence synchro qui dure plus de 1 seconde et le premier front montant
qui suit ce silence est le top du début de la première seconde.

Je n'arrive pas à écrire un petit bout de code qui me permettrait en fait pour débuter mon programme:

1) de détecter un niveau bas égal à environ 800ms ( à partir des fronts montants, pris en charge par l' interrupt sur la pin2. Cela n'arrive
qu'une fois dans la minute).

2) puis quand on a compté 800ms, on active une tempo de 520 ms qui sera suivi d'un niveau haut sur la pin 13 de 50ms. Dans l'idéal, il y aura le top de la 1° seconde encadré par un niveau haut de 50ms, ce qui me permettra avec un ET logique d'éliminer les parasites éventuels.

3) si les tops sont plus rapprochés que 800ms, la pin 13 reste à 0

C'est juste le début , mais j'ai vraiment du mal...j'ai fait pas mal d'essais mais aucun ne fonctionnait correctement...

je vous ai mis un de mes essais...

1) l'interruption reinitialise "tempoDepart"
2) je saute dans un sous programme "programme()" qui attend un niveau bas de plus de 800ms, et met à 1 la pin 13 puis va dans loop.
Il qui passe dans "else" si le temps entre deux interrupts fait moims que 800ms et met
la pin 13 à 0 et va dans loop.

Le pgr que je vous montre fonctionne sur trois pattes. Il continue à tourner même sans interruption, d'ou des niveaux hauts régulièrement .

j' ai testé le programme dans une routine appelée par l' interruption, mais apparemment millis() ne fonctionne pas dans ce genre de routine.

La photo montre les modulation de phase et la logique associée.

Merci de me donner un coup de main.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
int led = 13;
unsigned long tempoDepart = 0;
int interval=800;
 
 
void setup() {
pinMode(led, OUTPUT);
digitalWrite(led,LOW); 
attachInterrupt(0, mafonction, RISING); 
tempoDepart = millis();
 Serial.begin(115200);  
}                                                                  
 
void loop (){programme();}
 
 
                      void mafonction()  
                     {tempoDepart= millis();}
 
 
    void programme(){ if ( ( millis()- tempoDepart ) >= interval ) 
                    {                                                          //si plus de 800 ms sans interrupt, led allumée 50 ms
                   digitalWrite(led,HIGH);
                    delay(50);                                                 // calibrage niveau haut
                      digitalWrite (led,LOW);                   
                        tempoDepart=millis();}
 
 
                      else { digitalWrite(led,LOW); }}

**jpbbricole** · 19/03/2020, 19h53

Bonsoir Pat42

Envoyé par Pat42

Le pgr que je vous montre fonctionne sur trois pattes. Il continue à tourner même sans interruption, d'ou des niveaux hauts régulièrement .

Je n'ai pas encore étudié ton programme, mais ton problème ci dessus, peut provenir du fait que tu n'initialises pas la pin de l'interrupt:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define interruptPin 2 
                                    // Pin de l'interrupt
void setup()
{
	Serial.begin(115200);
	pinMode(led, OUTPUT);
	digitalWrite(led,LOW);

	pinMode(interruptPin, INPUT_PULLUP);
	attachInterrupt(digitalPinToInterrupt(interruptPin), mafonction, RISING);

	tempoDepart = millis();
	Serial.begin(115200);
}

J'ai légèrement modifié attachInterrupt comme préconisé chez Arduino.
Je me "lance" dans ton programme!

A+
Cordialement
jpbbricole

**Pat42** · 19/03/2020, 21h35

Bonsoir jpbbricole,

En fait le programme prends bien en compte les interruptions (je pourrais éventuellement mettre une photo). A chaque interruption et si le temps entre deux interruptions est plus grand que 800ms comme indiqué dans "interval", j'ai bien le programme qui fait le job , c'est à dire, un niveau haut sur la pin 13 que j'ai calibré à 50ms-----> aprés un niveau bas de 800ms ( je n'ai pas mis pour l'instant la tempo de 520 ms indiquée dans mon précédent poste, pour simplifier ).

Le soucis est que je n'arrive pas à faire patienter le pgr dans une boucle infinie, mais non bloquante, pour qu'il attende la prochaine interruption.
Du coup, le programme m' envoie des niveaux "hauts parasites" sur la pin 13 de 50ms régulièrement en plus des niveaux "hauts normaux"et cela est bien compréhensible puisqu'il continue à appeler la routine (même s'il n'y pas d'interrupt).

Dans l'autre cas, si le temps entre 2 interruptions est plus court que 800ms, le prg fait aussi le job.
J' ai bien un niveau bas sur la pin 13 , avec régulièrement des créneaux "parasites" de 50ms puisque le prg continu a tourner.

Pour être bien bien compris; j'aurais besoin d'une solution pour que le programme attende "dans un coin" l' interruption, qu'il fasse son job et qu' il retourne dans "son coin" en attendant la prochaine interrupt.

j'ai essayé avec divers solution while(1) {}, boucle infini , loop, mais rien ne fonctionne.

Cordialement

Pat

**Pat42** · 19/03/2020, 21h44

Jpbbricole,

j'ai oublié , je vais tester le code que vous avez modifié .

en vous remerciant.

Pat

**jpbbricole** · 19/03/2020, 22h01

Bonsoir Pat

Envoyé par Pat42

Jpbbricole,

j'ai oublié , je vais tester le code que vous avez modifié .

en vous remerciant.

Pat

J'ai, un peu, étudié ton programme. Je ne pense pas que mes modifications vont changer grand chose, c'était de la cosmétique, le problème est structurel. Je peux regarder cela demain matin.

Bonne soirée.
Cordialement
jpbbricole

**jpbbricole** · 20/03/2020, 11h20

Bonjour Pat

Voilà, j'ai "étudié" ton programme. Le premier point, c'est l'indentation de ton programme, une bonne indentation rend le programme beaucoup plus claire et plus aisé à débugger.
Tu parles d'une transition de HAUT à bas puis de bas à HAUT, donc 2 transitions à évaluer, donc l'interruption est sur l'événement CHANGE.
A noter les variables déclarées comme volatile pour toutes les variables partagées entre le programme principal et les routine d'interruption.
J'ai ajouté quelques variables et "embelli" le tout de quelques Serial.print pour voire ce qui se passe.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#define interruptPin 2                                      // Pin de l'interrupt
 
volatile boolean mesureEnCours = false;                     // Volatile pour les variables traitées en interrupt
volatile boolean mesureNouvelle = false;
volatile unsigned long tempoDepart = millis();                       
volatile unsigned long topSyncMilliSec = millis();                      
 
int led = 13;
const unsigned int topSyncMinimum=800;
 
void setup()
{
	Serial.begin(115200);
 
	pinMode(interruptPin, INPUT_PULLUP);
	pinMode(led, OUTPUT);
 
	pinMode(led, OUTPUT);
	digitalWrite(led,LOW);
	/*
		comme on veut mesurer une impulsion négative (10001) 
		il y a 2 transitions à détecter
		il faut mettre CHANGE comme déclenchement
	*/
	attachInterrupt(digitalPinToInterrupt(interruptPin), impulsionInterruption, CHANGE);
}
 
void loop()
{
	if (mesureNouvelle == true)
	{
		Serial.print("\nImpulsion LOW ");
		Serial.print(topSyncMilliSec);
		Serial.println(" milliSec.");
 
		topSyncAction();
 
		mesureNouvelle = false;
	}
}
 
void impulsionInterruption()
{
	if (digitalRead(interruptPin) == LOW && !mesureEnCours) // Si transition HIGHlow et pas de mesure en cours
	{
		tempoDepart= millis();
		mesureEnCours = true;                               // Mesure en cours
	}
	if (digitalRead(interruptPin) == HIGH && mesureEnCours) // Si transition lowHIGH et une mesure en cours
	{
		topSyncMilliSec = millis()-tempoDepart;
		mesureEnCours = false;                               // Plus de mesure en cours
		mesureNouvelle = true;
	}
}
 
 
void topSyncAction()
{ 
	if (topSyncMilliSec >= topSyncMinimum)
	{                                                          // si plus de 800 ms sans interrupt, led allumée 50 ms
		Serial.println("Top sync.");
		digitalWrite(led,HIGH);
		delay(50);                                             // calibrage niveau haut
		digitalWrite (led,LOW);
	}
 
	else 
	{ 
		Serial.print("Parasite ");
		Serial.print(topSyncMilliSec);
		Serial.println(" milliSec.");
 
		digitalWrite(led,LOW); 
	}
}

A toi de jouer

A+
Cordialement
jpbbricole

**Vincent PETIT** · 20/03/2020, 13h46

Salut,

jpbbricole.

Envoyé par Pat42

mettre au point ma petite horloge a moi...

Alors il faudra ce méfier de millis() car dans une 50aine de jour il y aura un reset de millis() et il pourra y avoir un loupé.

**Jay M** · 20/03/2020, 17h34

Envoyé par Vincent PETIT

Alors il faudra se méfier de millis() car dans une 50aine de jour il y aura un reset de millis() et il pourra y avoir un loupé.

Non non, @JP l'a écrit correctement. il fait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (topSyncMilliSec >= topSyncMinimum) {...}

et topSyncMinimum est une constante et topSyncMilliSec a bien été calculé comme il le fallait avec une soustraction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 topSyncMilliSec = millis()-tempoDepart

Une modification que j'apporterais c'est

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

intconst unsigned int topSyncMinimum=800;

pour avoir la durée en entier non signé et dire au compilateur que c'est une constante.

L'autre modification ce serait de dupliquer les variables volatiles dans la loop dans une section critique (interruptions bloquées). En effet comme elles ont plusieurs octets, les maths peuvent planter si on a une interruption pendant qu'on utilise ces octets. (pas de garantie d'atomicité sur 32 bits avec un processeur 8 bit) ou ne pas laisser l'interruption jouer avec les variables si mesureNouvelle est vrai. (ie tant que la loop() ne l'a pas traité)

**jpbbricole** · 20/03/2020, 19h45

Bonsoir Jay M

Envoyé par Jay M

Une modification que j'apporterais c'est

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

intconst unsigned int topSyncMinimum=800;

...

C'est corrigé.

Envoyé par Jay M

L'autre modification ce serait de dupliquer les variables ...

Alors, là, j'ai pas tout compris, pourrais-tu me réécrire la void loop() en conséquence.

A+
Cordialement
jpbbricole

**Jay M** · 21/03/2020, 09h38

Envoyé par jpbbricole

Alors, là, j'ai pas tout compris, pourrais-tu me réécrire la void loop() en conséquence.

Salut JP,

ça ressemblerait sans doute à cela avec une gestion de zone critique:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// les pins
const uint8_t interruptPin = 2;  // Pin de l'interrupt
const uint8_t ledPin = LED_BUILTIN; // la LED intégrée sur la carte (pin 13 sur un UNO par exemple)
 
// les constantes
const unsigned int topSyncMinimum = 800U;
 
// Volatile pour les variables utilisées en interruption et dans le code principal
volatile boolean mesureEnCours = false;  
volatile boolean mesureNouvelle = false;
volatile unsigned long tempoDepart = 0 ;
volatile unsigned long topSyncMilliSec = 0;
 
// variable pour copie lors des opérations non atomiques
unsigned long topSyncMilliSecProtected;
 
void impulsionInterruption()
{
  uint8_t etatPin = digitalRead(interruptPin); // ne lire qu'une seule fois la valeur de la pin, c'est lent et on veut toujours limiter le temps passé dans une ISR
  if (etatPin == LOW && !mesureEnCours) {
    // Si transition HIGH -> LOW et pas de mesure en cours
    tempoDepart = millis(); // on note le temps de départ
    mesureEnCours = true; // et le fait qu'on commence une mesure
  } else if (etatPin == HIGH && mesureEnCours) {
    // Si transition LOW -> HIGH et une mesure est déjà en cours
    topSyncMilliSec = millis() - tempoDepart; // on note la durée
    mesureEnCours = false; // On termine une mesure
    mesureNouvelle = true; // On met un drapeau pour dire à la loop qu'une durée est dispo
  }
}
 
void setup()
{
  Serial.begin(115200);
 
  pinMode(interruptPin, INPUT_PULLUP);
 
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
 
  /*
    comme on veut mesurer une impulsion négative (10001)
    il y a 2 transitions à détecter
    il faut mettre CHANGE comme déclenchement
  */
  attachInterrupt(digitalPinToInterrupt(interruptPin), impulsionInterruption, CHANGE);
}
 
void loop()
{
  if (mesureNouvelle) {
    // ZONE PROTEGEE CAR topSyncMilliSec EST SUR 4 OCTETS. OPERATIONS NON ATOMIQUES
    noInterrupts();
    topSyncMilliSecProtected = topSyncMilliSec;
    interrupts();
 
    Serial.print(F("\nImpulsion LOW "));
    Serial.print(topSyncMilliSecProtected);
    Serial.println(F(" millisec."));
 
    topSyncAction(); // va aussi utiliser topSyncMilliSecProtected
 
    mesureNouvelle = false;
  }
}
 
void topSyncAction()
{
  if (topSyncMilliSecProtected >= topSyncMinimum) {
    // si plus de topSyncMinimum ms sans interrupt, led allumée 50 ms
    Serial.println(F("Top sync."));
    digitalWrite(ledPin, HIGH);
    delay(50);  // calibrage niveau haut
    digitalWrite(ledPin, LOW);
  } else {
    Serial.println(F("Parasite"));
  }
}

Explication:

Sur un processeur 8 bits, la majorité des opérations sur 1 octet (test d'un booléen, comparaison de valeur, opérations mathématiques genre addition, soustraction, décalage, ...) se font en 1 cycle d'horologe et donc ne peuvent pas être tronçonnées par une interruption. On dit qu'elles sont 'atomiques' (c'est l'élément de base comme un atome).

Il n'en va pas de même quand vous travaillez sur des variables qui font plusieurs octets, le processeur ne sachant pas traiter des opérations sur 2 ou 4 octets d'un coup, le compilateur est obligé de générer plusieurs lignes de code pour effectuer le calcul, et dans chaque ligne on va accéder à des octets faisant partie de la variable. charger cela dans un registre, faire le traitement puis éventuellement remettre une nouvelle valeur dans l'octet d'origine.

Si vous n'avez pas de bol et qu'une interruption vient modifier la variable sur laquelle vous travaillez pendant ces opérations saucissonnées, et comme vous avez (comme il se doit) déclaré la variable volatile, le calcul ne met pas toute la donnée en mémoire cache, il accède directement à chaque octet directement en mémoire et le traitement peut ne plus vouloir rien dire car certains octets peuvent changer pendant l'opération.

un exemple:

Imaginez un compteur de type unsigned int, donc sur deux octets, qui s'incrémente avec des interruptions.
Imaginez que vous voulez imprimer la valeur chaque fois que le compteur a monté de 5.

Votre interruption pourrait ressembler à cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
// Volatile pour les variables utilisées en interruption et dans le code principal
volatile unsigned int compteur = 0;
volatile bool affichageRequis = false;
 
void incrementeISR()
{
  compteur++;
  if (compteur % 5 == 0) affichageRequis = true;
}

et la loop testera le drapeau pour effectuer l'affichage

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void loop()
{
  if (affichageRequis) {
    Serial.print(F("Le compteur vaut : "));
    Serial.println(compteur);
    affichageRequis = false;
  }
}

On se dit que tout va bien se passer....

Mais si vous n'avez pas de chance, lorsque compteur vaut 255 (soit 0x00FF) un affichage sera demandé puisque c'est divisible par 5.
Si pendant que la loop travaille sur Serial.println(compteur); pour convertir le compteur en ASCII une interruption arrive, le compteur vaudra 256 (soit 0x0100). Comme le compilateur ne travaille que sur des octets, il pourrait avoir traité l'octet de poids faible 0xFF puis ensuite voir en mémoire 0x01 pour l'octet de poids fort et donc fabriquer un affichage qui correspond à 511 (soit 0x01FF) au lieu de 255. Vous imaginez les conséquences que ça pourrait avoir si la valeur n'était pas utilisée juste en affichage mais pour déclencher un processus d'urgence par exemple si vous dépassez 500...

==> pour se prémunir de ces opérations non atomiques, il faut dupliquer les variables critiques qui pourraient être modifiées dans notre dos par l'interruption en créant une copie locale. Donc ici une loop correcte serait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
void loop()
{
  if (affichageRequis) {
    // ZONE PROTEGEE CAR compteur EST SUR 2 OCTETS. OPERATIONS NON ATOMIQUES
    noInterrupts();
    unsigned int compteurProtected = compteur;
    interrupts();
    Serial.print(F("Le compteur vaut : "));
    Serial.println(compteurProtected);
    affichageRequis = false;
  }
}

il faut bien sûr garder la zone critique la plus courte possible, se contenter de dupliquer les variables clés afin de ne pas rater d'interruptions.
Dans l'interruption on n'a pas à s'en soucier bien sûr puisqu'une interruption ne peut pas être interrompue.

Sur un processeur 32 bits, beaucoup d'opérations de base se font en atomique sur 32 bits, donc on n'a moins le soucis pour des maths simples, mais un affichage de valeur ou un calcul complexe faisant intervenir plusieurs fois la variable peut aussi présenter un souci. Donc soit il faut s'assurer que l'interruption ne peut pas interférer avec nos calculs, soit se protéger en travaillant sur une copie.

j'espère que ça clarifie mon propos.

**jpbbricole** · 21/03/2020, 17h52

Bonsoir Jay M

Voilà, j'ai modifié le programme en "m'inspirant" de tes remarques, toujours pertinentes et surtout enrichissantes, pour moi, autodidacte. J'ai découvert le C avec l'Arduino, avant j'ai été "formaté" par quelques décennies de VisualBasic!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#define interruptPin 2                                     // Pin de l'interrupt
#define topSyncLedPin 13                                   // Pin de LED topSync
 
volatile boolean mesureEnCours = false;                    // Volatile pour les variables traitées en interrupt
volatile boolean mesureNouvelle = false;
volatile unsigned long topSyncInterrDepart = millis();                       
volatile unsigned long topSyncInterrMilliSec = millis();                      
unsigned long topSyncMilliSec;
 
const unsigned int  topSyncMinimum=800;                    // variable pour copie lors des opérations non atomiques
 
void setup()
{
	Serial.begin(115200);
 
	pinMode(interruptPin, INPUT_PULLUP);
	pinMode(topSyncLedPin, OUTPUT);
 
	pinMode(topSyncLedPin, OUTPUT);
	digitalWrite(topSyncLedPin,LOW);
	/*
		comme on veut mesurer une impulsion négative (10001) 
		il y a 2 transitions à détecter
		il faut mettre CHANGE comme déclenchement
	*/
	attachInterrupt(digitalPinToInterrupt(interruptPin), impulsionInterruption, CHANGE);
}
 
void loop()
{
	if (mesureNouvelle == true)
	{
		noInterrupts();
		topSyncMilliSec = topSyncInterrMilliSec;
		interrupts();
 
		Serial.print("\nImpulsion LOW ");
		Serial.print(topSyncMilliSec);
		Serial.println(" milliSec.");
 
		topSyncAction();
 
		mesureNouvelle = false;
	}
}
 
void impulsionInterruption()
{
	byte interruptPinStatus = digitalRead(interruptPin);
 
	if (interruptPinStatus == LOW && !mesureEnCours) // Si transition HIGHlow et pas de mesure en cours
	{
		topSyncInterrDepart= millis();
		mesureEnCours = true;                               // Mesure en cours
	}
	if (interruptPinStatus == HIGH && mesureEnCours) // Si transition lowHIGH et une mesure en cours
	{
		topSyncInterrMilliSec = millis()-topSyncInterrDepart;
		mesureEnCours = false;                               // Plus de mesure en cours
		mesureNouvelle = true;
	}
}
 
 
void topSyncAction()
{ 
	if (topSyncMilliSec >= topSyncMinimum)
	{                                                          // si plus de 800 ms sans interrupt, led allumée 50 ms
		Serial.println("Top sync.");
		digitalWrite(topSyncLedPin,HIGH);
		delay(50);                                             // calibrage niveau haut
		digitalWrite (topSyncLedPin,LOW);
	}
 
	else 
	{ 
		Serial.println("Parasite ");
	}
}

J'espère n'avoir rien oublié

A+
Cordialement
jpbbricole

**Jay M** · 21/03/2020, 18h16

salut JP

partagé avec plaisir

juste dans topSyncAction() j'avais viré

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Serial.print(topSyncMilliSec);
Serial.println(" milliSec.");
digitalWrite(topSyncLedPin,LOW);

car la LED est forcément LOW et vous appelez cette fonction depuis la loop() où vous aviez déjà affiché justement topSyncMilliSec, donc pas la peine de répéter pour garder l'affichage "simple".

et dans l'interruption j'avais proposé un else entre les deux if histoire de gagner en performance puisque les 2 conditions ne peuvent pas être vraies en même temps.

mais oui c'est cohérent et vous avez bien intégré la zone critique pour capturer la valeur.

**Pat42** · 22/03/2020, 17h18

Bonjour Jpbbricole, à Jay M et à tous ceux qui participent à l'avancement de mon projet "mon horloge à moi".

Merci pour ton bout de code qui fonctionne parfaitement.
Un pb de résolu .
Je joins une photo.

Si j'ai bien compris, c'est le premier front montant après 800ms de "silence" qui génère l'interruption.

Je voulais faire un peu plus compliqué en encadrant le top 1°sec. par une impulsion calibrée (50ms), puis appliquer
un "ET" à la porte et au top 1°sec, et ainsi immuniser le système aux parasites qui pourraient déclencher l'interrupt,
avant le top du début 1°sec.

Mais après des tests, l'antenne à côté d'une belle alimentation à découpage, le filtrage tient le coup et pas de souci.

Je vais me pencher sur ton programme pour bien le comprendre et apprendre... (j'aurais éventuellement besoin d'aide pour bien comprendre)

Il faut ensuite que je me penche sur les secondes et la lecture des bits, ouvrir une porte de de 200ms après un temps de 800ms au début de chaque seconde.

j'ai du temps...confinement oblige.

Il est certain que j'aurais encore besoin de vos précieuses aides.

Cordialement
Pat42

Ps: Etant débutant, je ne suis pas rentré dans votre discussion avec Jay M, lol.
J'ai testé le prg que tu as modifié et c'est ok, bien que je n'ai évidemment pas tout compris de ce qu'il apporte en plus...

Peux tu m'expliquer la raison pour laquelle il y a deux bouts de code identique ligne 17 et 19 ?
pinMode(topSyncLedPin, OUTPUT

Cordialement
Pat42

**Jay M** · 22/03/2020, 17h41

Envoyé par Pat42

Peux tu m'expliquer la raison pour laquelle il y a deux bouts de code identique ligne 17 et 19 ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pinMode(topSyncLedPin, OUTPUT);

c'est parce que @JP voulait voir si vous suiviez

(bug de copier coller sans doute en pratique, ça ne sert bien sûr à rien)

**jpbbricole** · 22/03/2020, 17h42

Bonjour Pat

Envoyé par Pat42

Si j'ai bien compris, c'est le premier front montant après 800ms de "silence" qui génère l'interruption.

Non pas tout à fait, le premier flanc descendant (début du silence) déclenche le chrono topSyncInterrDepart et le prochain flanc montant, l'arrête et on capture le temps dans topSyncMilliSec. Ensuite, on évalue si topSyncMilliSec est >= à topSyncMinimum pour décider si parasite ou pas.

Envoyé par Pat42

Peux tu m'expliquer la raison pour laquelle il y a deux bouts de code identique ligne 17 et 19 ?
pinMode(topSyncLedPin, OUTPUT

Un oubli

tu peux en supprimer une des deux.

A+
Cordialement
jpbbricole

**Pat42** · 22/03/2020, 23h57

Merci pour vos réponses, il est 23h37 et je suis encore en train de me casser la tête pour comprendre la routine appelée par l'interruption
void impulsionInterruption().

Il y a quelques mois, j'ai écrit un programme pour un fréquencemètre à installer sur certaines de mes radios ( j'écoute les ondes courtes, cela sert) avec multiplexage de cinq afficheurs 7 segments , utilisé le timer 1 et 2,fait des soustractions, des divisions, des "réglages" joué avec les modulos et avec votre aide sur les timers, je m'en suis bien sorti.

Eh là! j'ai quelques difficultés à comprendre le programme que vous m'avez gentiment écrit.

Je suis perplexe.

Perdrais-je des neurones...?

Pat42

**Jay M** · 23/03/2020, 05h39

Le programme configure la pin d’interruption pour réagir aux fronts montants ou descendants. La routine d’interruption est donc appelée à chaque transition d’état.

L’idée de l’interruption est de calculer combien de temps a duré le signal LOW et @JPbricole traite cela avec une petite machine à états.

Quand on rentre dans l’interruption il mémorise dans interruptPinStatus l’état de la pin pour savoir si on est HIGH ou LOW. Comme on est appelé uniquement sur les fronts, si on est LOW c’est qu’il vient de se produire une transition HIGH => LOW et inversement si on est HIGH.

Comme on veut mesurer le temps passé à LOW, tant que la transition reçue n’est pas HIGH => LOW On ne fait rien. Lorsque on la reçoit on note l’heure de départ en mettant millis() dans topSyncInterrDepart et on met un drapeau à vrai (mesureEnCours ) qui note que ça y est on est en train de mesurer une phase LOW.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 if (interruptPinStatus == LOW && !mesureEnCours) // Si transition HIGHlow et pas de mesure en cours
	{
		topSyncInterrDepart= millis();
		mesureEnCours = true;                               // Mesure en cours
	}

Lors de la prochaine interruption on va passer de LOW à HIGH et si une mesure est en cours (ie on a bien noté un moment de départ) alors on calcule la durée de cette phase LOW en soustrayant à l’heure courante la valeur mémorisée précédemment et on met cela dans topSyncInterrMilliSec.

On a alors fini un cycle de mesure de phase LOW donc on enlève le drapeau mesureEnCours (mis a false) et on active un nouveau drapeau mesureNouvelle à vrai pour signaler a loop qu’une durée calculée est maintenant disponible

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 if (interruptPinStatus == HIGH && mesureEnCours) // Si transition lowHIGH et une mesure en cours
	{
		topSyncInterrMilliSec = millis()-topSyncInterrDepart;
		mesureEnCours = false;                               // Plus de mesure en cours
		mesureNouvelle = true;
	}

Pendant ce temps la loop tourne bêtement à ne rien faire en attendant de voir si une mesure est dispo

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 if (mesureNouvelle == true) ...

Quand ce drapeau est détecté c’est donc qu’on a une mesure de la durée et la loop effectue un petit affichage cosmétique et appelle topSyncAction().

Dans cette fonction on teste simplement si la durée est supérieure à 800ms et si oui on allume D13 pendant 50ms puis on l’éteint

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 if (topSyncMilliSec >= topSyncMinimum)
	{                                                          // si plus de 800 ms sans interrupt, led allumée 50 ms
		Serial.println("Top sync.");
		digitalWrite(topSyncLedPin,HIGH);
		delay(50);                                        
		digitalWrite (topSyncLedPin,LOW);
	}

Si la durée était moindre alors c’est pas une bonne mesure et on l’ignore

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 else { 
		Serial.println("Parasite ");
	}

Une fois topSyncAction() exécutée on retourne dans la loop où on va noter que cette mesure a bien été prise en compte

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 mesureNouvelle = false;

en remettant le drapeau à faux et donc la loop reprend patiemment son attente active. Le drapeau sera remis à vrai par les interruptions après mesure de la prochaine séquence à LOW et on recommencera

Ça aide ?

**Pat42** · 23/03/2020, 17h35

Bonjour Jay M et merci d'avoir pris un moment pour me donner ces explications.
Un petit bonjour aussi à jpbbricole.

Je vais me "mettre dessus".

Bonne soirée et à bientôt...

Pat42

**jpbbricole** · 23/03/2020, 17h48

Bonjour Pat

Envoyé par Pat42

Je vais me "mettre dessus".

C'est vrai, qu'avec une explication comme celle de @Jay M, ça donne envie de "creuser"!

A+
Bonne soiré (Sagement à la maison)
Cordialement
jpbbricole