Construction d'un tachymètre-dwellmètre

[Yvan_Delaserge]

Les voitures construites avant les années 80 étaient classiquement équipées d'allumages à vis platinées. Périodiquement, l'écart entre les vis platinées devait être ajusté.
De l'écartement entre les vis platinées dépend le dwell, qui exprime le rapport cyclique de la tension appliquée au primaire de la bobine lorsque le moteur est en marche.
Pour un moteur 4 cylindres, la came du rupteur comporte 4 lobes. Pour chaque tour de l'axe de l'allumeur, on va avoir quatre cycles de fermeture et d'ouverture des vis platinées. Un tous les 90 degrés.



Les lecteurs attentifs auront remarqué que sur l'illustration ci-dessus, la came comporte 8 lobes. Nous avons donc affaire à un moteur 8 cylindres. Mais le principe est le même que pour un 4 cylindres.

Le dwell s'exprime en degrés. Une valeur typique est de 57 degrés avec une tolérance de + ou - 5. C'est-à-dire que lorsque les vis platinées entrent en contact, du courant va circuler dans la bobine d'allumage. Lorsque l'axe de l'allumeur aura tourné de 57 degrés, les vis platinées vont s'écarter, interrompant le courant dans le primaire de la bobine.
Pour un véhicule neuf, les cames de l'allumeur sont de dimension nominale et on peut donc fixer le dwell uniquement en réglant l'écartement des vis platinées.
Pour un véhicule âgé de plusieurs dizaines d'années, l'allumeur peut avoir pris du jeu, les cames n'être plus tout-à-fait aux dimensions nominales. Il vaut mieux mesurer directement le dwell plutôt que l'écartement des vis platinées.

C'est pour cette raison que j'ai entrepris la construction d'un tachymètre-dwellmètre comme on en construisait dans les années 70.
-----

[Yvan_Delaserge]

Le schéma du tachymètre-dwellmètre que j'ai construit est le suivant:



Comme on peut le voir, il est basé sur un circuit bien vintage, un 7402, même pas low-power Schottky.

Pour ceux qui voudraient construire le même circuit, autant que vous le sachiez tout de suite: tel quel il ne fonctionne pas.
Le premier problème est que le circuit d'entrée, qui est fait pour protéger l'IC contre les surtensions et les inversions de polarité, ne laisse pas circuler suffisamment de courant pour faire commuter une porte NOR d'un 7402. J'ai essayé un IC National et un Texas Instruments, mais j'avais le problème avec les deux.

J'ai donc remplacé l'IC par un 74LS02 et la première porte (appelons-la la porte d'entrée!) accepte alors de commuter sans problèmes.

Le problème qui apparaît ensuite est qu'avec un LS, en position tachymètre, la 3e porte ne commute pas. Elle reçoit sur ses deux entrées deux créneaux en opposition de phase, donc sa sortie reste en permanence au niveau bas.

Pour la fonction tachymètre, on veut qu'à chaque impulsion présente à l'entrée, une impulsion courte, mais de durée constante, soit envoyée au galvanomètre. Ces impulsions seront intégrées par le condensateur en parallèle avec le galvanomètre et ce dernier va dévier d'un angle proportionnel au nombre d'impulsions par unité de temps, donc de la vitesse de rotation du moteur.

Pour générer ces impulsions courtes, la résistance et le condensateur entre les portes 2 et 3 introduisent un retard lors de l'arrivée de l'impulsion. La 3e porte aura donc pendant un bref instant ses deux entrées à 0, et donc sa sortie passera à 1 pendant un bref instant, puis à zéro. La diode sert à décharger rapidement le condensateur lorsque la sortie de la 2e porte repasse à 0.

Pour que cela fonctionne avec le LS, j'ai dû augmenter le condensateur à 0,1 uF. Donc mille fois plus que la valeur indiquée.

[Yvan_Delaserge]

Une fois que le circuit fonctionne, vient le gros morceau: L'étalonnage et la réalisation d'une échelle pour le galvanomètre.



J'ai réalisé l'étalonnage au GBF et à l'oscilloscope. J'ai un fréquencemètre, mais il ne descend pas assez bas en fréquence. Donc il y a eu pas mal de règles de trois à faire (!)

Il s'agit d'ouvrir le galva (J'ai utilisé un vu-mètre) de placer un morceau de papier de la bonne taille sur le cadran original et d'y inscrire les coches correspondant aux tours-minutes et aux dwells.

Ensuite, on sort le papier du vu-mètre, on le scanne et on reprend le dessin avec un programme graphique, avant de l'imprimer à la bonne dimension et de le coller de manière définitive sur l'échelle du vu-mètre.

Il existe des programmes qui permettent de réaliser des cadrans très pro, par exemple MeterBasic

Mais comme vous pouvez le voir en observant le cadran, le circuit ne se comporte pas linéairement. Il est donc bien indispensable de tracer une échelle point par point.

[Yvan_Delaserge]

Avec Meter Basic, on obtient facilement des échelles très propres.



Mais pas utilisables telles quelles dans le cas présent.

[A voir en vidéo sur Futura]

[Yvan_Delaserge]

Le circuit est réalisé sur une plaque d'essai et ne présente pas de difficulté particulière.

[Yvan_Delaserge]

Et finalement une vue de l'appareil terminé.


Rétrospectivement, je me dis que la mise au point de cet appareil a été plutôt fastidieuse. Il serait probablement possible avec la technologie actuelle de faire quelque chose à la fois de plus précis et plus facile à construire. Je suis en train d'y réfléchir.

[PIXEL]

on pourrait envisager une approche en logique programmée ...

je me coltine le même probléme pour une moto ancienne

[Yvan_Delaserge]

Oui, c'est bien dans cette direction-là que je compte imaginer une solution. A suivre...

[jiherve]

Bonsoir
Là c'est typiquement l'application ou un petit µC 8 broches ferait merveille.
JR

[DAUDET78]

Pour que cela fonctionne avec le LS, j'ai dû augmenter le condensateur à 0,1 uF. Donc mille fois plus que la valeur indiquée.

C'est surtout la 10K qui est trop grande ! Avec un 74LS, tu as le droit, au grand maximum à 5K !

Pourquoi ne pas utiliser du 74HC02 ???

[mag1]

Bonjour,

J'ai fait un truc similaire pour régler les anciens systèmes d'allumage (préparation 4L Trophy, entre autres). Avec un voltmètre numérique. Le DWELL, en pourcents, est le rapport cyclique vis fermées/vis ouvertes (c'est l'angle de came qui est en degrés). Pour calibrer, je réglais la tension alim pour avoir 1 volt vis fermées. Le DWEEL est alors la valeur moyenne : 50% de DWELL = 500mV.
Je vais essayer de retrouver le schéma...

MM

[Yvan_Delaserge]

C'est surtout la 10K qui est trop grande ! Avec un 74LS, tu as le droit, au grand maximum à 5K !

Pourquoi ne pas utiliser du 74HC02 ???

Désolé du lapsus. C'est bien un 74HC02. Pas un LS!
Voir photo #5

[Yvan_Delaserge]

Voici la version années 2010

Un Arduino permet d'utiliser facilement un affichage à LCD.
J'ai gardé le même circuit d'entrée que pour le premier montage, de même que l'alimentation à partir du 12 V de la voiture.

L'entrée se fait par la patte D2, qui permet de programmer une interruption.

J'ai fait deux versions du software. L'une utilise une interruption, l'autre pas.

Voici celle avec une interruption:

/*The circuit:
 * LCD RS pin to digital pin 13
 * LCD Enable pin to digital pin 12
 * LCD D4 pin to digital pin 11
 * LCD D5 pin to digital pin 10
 * LCD D6 pin to digital pin 9
 * LCD D7 pin to digital pin 8
 * LCD R/W pin to ground
 * LCD VSS pin to ground
 * LCD VCC pin to 5V
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)
 */
// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

const byte input = 2;
const byte interruptPin = 2;

volatile int interruption=0;
unsigned long tempsDebutImpuls = 0;
unsigned long tempsFinImpuls = 0;
int prevInputState=0;
unsigned long dureeOn = 0;
unsigned long dureeOff = 0;
float toursMinute = 0;//on va faire la sliding moyenne sur 6 mesures
int moyTours = 0;
int moyTours0 = 0;
int moyTours1 = 0;
int moyTours2 = 0;
int moyTours3 = 0;
int moyTours4 = 0;
int moyTours5 = 0;
float dwell = 0;//on va faire la sliding moyenne sur 6 mesures
int moyDwell = 0;
int moyDwell0 = 0;
int moyDwell1 = 0;
int moyDwell2 = 0;
int moyDwell3 = 0;
int moyDwell4 = 0;
int moyDwell5 = 0;
int i = 1;//compteur pour affichage




void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("Rev/min   Dwell ");

//  pinMode(7, OUTPUT);//pour mesurer le temps de rotation de la boucle loop
  pinMode(interruptPin, INPUT);
  attachInterrupt(digitalPinToInterrupt(interruptPin), interruptionActivee, CHANGE);//l'entrée se fait sur la broche 2
  
//  Serial.begin(9600);
}

void loop() {
  if (i == 1) {affichage();}
  i ++;
  //on affiche sur le LCD toutes les 40 000 boucles loop
  if (i == 40000) { i = 1;}
  
  if (interruption == 1) { 
     calculs();
     interruption = 0;
   }
 
//  digitalWrite(7, HIGH);//pour mesurer le temps de la boucle loop
//  digitalWrite(7, LOW);//pour mesurer le temps de la boucle loop
}

void interruptionActivee(){
//on cherche à rendre aussi courte que possible la fonction appelée par l'interruption  
interruption = 1;
}

void calculs(){
  // read the input pin:
  int inputState = digitalRead(input);
  
  if (inputState == HIGH && prevInputState == 0)
{
  tempsDebutImpuls = micros();
  dureeOff = micros()- tempsFinImpuls;
  prevInputState = 1;
}

if (inputState == LOW && prevInputState == 1)
{
  tempsFinImpuls = micros();
  dureeOn = micros()- tempsDebutImpuls;
  prevInputState = 0;
}

  toursMinute = 30000000 / (dureeOn + dureeOff);
  moyTours5 = moyTours4;
  moyTours4 = moyTours3;
  moyTours3 = moyTours2;
  moyTours2 = moyTours1;
  moyTours1 = moyTours0;
  moyTours0 = toursMinute;
  moyTours = (moyTours0 + moyTours1 + moyTours2 + moyTours3 + moyTours4 + moyTours5) / 6;

  dwell = 90 * dureeOn / (dureeOn + dureeOff);
  moyDwell5 = moyDwell4;
  moyDwell4 = moyDwell3;
  moyDwell3 = moyDwell2;
  moyDwell2 = moyDwell1;
  moyDwell1 = moyDwell0;
  moyDwell0 = dwell;
  moyDwell = (moyDwell0 + moyDwell1 + moyDwell2 + moyDwell3 + moyDwell4 + moyDwell5) / 6;
}

void affichage() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  lcd.print(moyTours);
  lcd.print("   ");
  lcd.print(moyDwell);
  lcd.print(" deg");
//  Serial.println(moyDwell);
}

Lors d'un changement d'état de la patte D2, on a une interruption qui exécute la fonction interruptionActivee().

Cette fonction est la plus simple possible, car pendant l'exécution d'une interruption, le compteur que l'on utilise pour la fonction micros() s'arrête. On se borne à un changement d'état de la variable "interruption". Puis on retourne à la boucle loop() qui exécute la fonction calculs().

Au moyen de la fonction micros(), qui est un compteur incrémenté de 1 chaque microseconde, on mesure la durée des états hauts et bas des vis platinées. Haut = bobine d'allumage non alimentée. Bas= bobine alimentée.
Après calcul des tours/minute et du dwell, on effectue une moyenne des six dernières mesures, pour le cas où on aurait des glitch à l'entrée (vis platinées ne présentant pas un parfait état de surface).

La fonction affichage() est exécutée environ une fois par seconde.

[jiherve]

Bonjour,
Il y a encore plus simple : utiliser le Timer 1 et la fonction input capture d'icelui on récupère directement le temps écoulé entre 2 fronts qu'il est loisible de changer à la volée. on mesurera donc en même temps la période (donc les RPM) et le rapport cyclique (DWELL). La boucle principale ne fait alors que les calculs, précision : celle de l'oscillateur
Un gestion par pointeurs d'un buffer tournant évitera les recopie des ancienne valeurs.
En fait c'est très proche des quelques routines nécessaire pour faire un fréquencemètre /périodemètre
JR

[mag1]

Bonjour,

J'ai retrouvé le schéma sur un bout de papier. Le voici "au propre".

L'affichage est un voltmètre digital. (il n'y avait pas encore de picaxe...)



MM

[Yvan_Delaserge]

Bonjour,
Il y a encore plus simple : utiliser le Timer 1 et la fonction input capture d'icelui on récupère directement le temps écoulé entre 2 fronts qu'il est loisible de changer à la volée. on mesurera donc en même temps la période (donc les RPM) et le rapport cyclique (DWELL). La boucle principale ne fait alors que les calculs, précision : celle de l'oscillateur
Un gestion par pointeurs d'un buffer tournant évitera les recopie des ancienne valeurs.
En fait c'est très proche des quelques routines nécessaire pour faire un fréquencemètre /périodemètre
JR

Excellent, je ne connaissais pas. Il y a une fonction Pulsein, qui permet de mesurer directement la durée en microsecondes du niveau haut et/ou du niveau bas d'une impulsion. C'est aussi basé sur une interruption et on ne peut pas trop s'y fier pour des impulsions inférieures à 10 microsecondes. Probablement pour la même raison exposée ci-dessus: le compteur des microsecondes s'arrête lors d'une interruption.

mais Pulsein permettrait d'économiser quelques lignes de code.

[Yvan_Delaserge]

Bonjour,

J'ai retrouvé le schéma sur un bout de papier. Le voici "au propre".

L'affichage est un voltmètre digital. (il n'y avait pas encore de picaxe...)

Pièce jointe 330709

MM

Excellent, merci du schéma. Il présente l'intérêt de pouvoir s'affranchir de la réalisation d'un cadran pour le vu-mètre. A l'heure actuelle, on trouve des petits afficheurs à 3 chiffres qui feraient parfaitement l'affaire.

Je pense que la non-linéarité de mon cadran est due au vu-mètre.
Le circuit avec le 74HC02 devrait se comporter linéairement: duty cycle pour le dwell et nombre d'impulsions de durée identique par seconde pour le nombre de tours du moteur.

Au lieu de ça les indications du vu-mètre sont "tassées" sur la droite. D'où perte de précision sur la droite du cadran.

[Yvan_Delaserge]

J'ai écrit une autre version du soft, mais sans faire appel à une interruption.

/*The circuit:
 * LCD RS pin to digital pin 13
 * LCD Enable pin to digital pin 12
 * LCD D4 pin to digital pin 11
 * LCD D5 pin to digital pin 10
 * LCD D6 pin to digital pin 9
 * LCD D7 pin to digital pin 8
 * LCD R/W pin to ground
 * LCD VSS pin to ground
 * LCD VCC pin to 5V
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)
 */
 // include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

int input = 2;
unsigned long tempsDebutImpuls = 0;
unsigned long tempsFinImpuls = 0;
int prevInputState=0;
unsigned long dureeOn = 0;
unsigned long dureeOff = 0;
float toursMinute = 0;//on va faire la sliding moyenne sur 6 mesures
int moyTours = 0;
int moyTours0 = 0;
int moyTours1 = 0;
int moyTours2 = 0;
int moyTours3 = 0;
int moyTours4 = 0;
int moyTours5 = 0;
float dwell = 0;//on va faire la sliding moyenne sur 6 mesures
int moyDwell = 0;
int moyDwell0 = 0;
int moyDwell1 = 0;
int moyDwell2 = 0;
int moyDwell3 = 0;
int moyDwell4 = 0;
int moyDwell5 = 0;
int i = 1;//compteur pour affichage

void setup() {
 // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
 // Print a message to the LCD.
  lcd.print("Rev/min   Dwell "); 
  // make the input's pin an input:
  pinMode(input, INPUT);
//  pinMode(7, OUTPUT);//pour mesurer le temps de rotation de la boucle loop
//  Serial.begin(9600);
}

void loop() {
  
  // read the input pin:
  int inputState = digitalRead(input);
  
  if (inputState == HIGH && prevInputState == 0)
{
  tempsDebutImpuls = micros();
  dureeOff = micros()- tempsFinImpuls;
  prevInputState = 1;
  moyennes();
}

if (inputState == LOW && prevInputState == 1)
{
  tempsFinImpuls = micros();
  dureeOn = micros()- tempsDebutImpuls;
  prevInputState = 0;
  moyennes();
}

if(i==1){affichage();
} 
i ++;
if (i==40000){i=1;//on affiche sur le LCD toutes les 40 000 boucles loop
}
//  digitalWrite(7, HIGH);//pour mesurer le temps de rotation de la boucle loop
//  digitalWrite(7, LOW);//pour mesurer le temps de rotation de la boucle loop
}

//on calcule les moyennes lors des changements d'état de l'entrée
void moyennes(){
toursMinute = 30000000/(dureeOn + dureeOff);
moyTours5 = moyTours4;
moyTours4 = moyTours3;
moyTours3 = moyTours2;
moyTours2 = moyTours1;
moyTours1 = moyTours0;
moyTours0 = toursMinute;
moyTours = (moyTours0 + moyTours1 + moyTours2 + moyTours3 + moyTours4 + moyTours5)/6;

dwell = 90 * dureeOn/(dureeOn + dureeOff);
moyDwell5 = moyDwell4;
moyDwell4 = moyDwell3;
moyDwell3 = moyDwell2;
moyDwell2 = moyDwell1;
moyDwell1 = moyDwell0;
moyDwell0 = dwell;
moyDwell = (moyDwell0 + moyDwell1 + moyDwell2 + moyDwell3 + moyDwell4 + moyDwell5)/6;
}

void affichage(){
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  lcd.print(moyTours);
  lcd.print("   ");
  lcd.print(moyDwell);
  lcd.print(" deg");
//  Serial.println(moyDwell);
  }

Dans cette version, on détecte les fronts montants et descendants du signal dans la boucle loop(), qui tourne en environ 5 microsecondes, selon la mesure à l'oscilloscope. Pour qu'elle tourne le plus vite possible, la boucle ne fait que ces tests de front montant/descendant à chaque tour (et aussi compte le nombre de tours pour afficher les valeurs environ 1 fois par seconde sur le LCD).

Les calculs et moyennes ne sont faits que lors des changements d'état de l'entrée, comme dans l'autre version.
L'erreur sur les fronts montants/descendants sera ainsi comprise entre 0 et 5 microsecondes. Avec les moyennes sur 6 mesures, elle devrait être de 2-3 microsecondes. C'est probablement moins bien qu'avec une interruption. Je ne sais pas combien de temps dure l'interruption, et surtout quelle est l'erreur introduite dans le compteur micros().

Mais ces erreurs sont négligeables. Un moteur 4 temps de 4 cylindres, qui tourne à 2000 tours/minute va produire des impulsions de 15 msec en tout donc 7,5 msec ON et 7,5 msec OFF. Une erreur de 3 usec / 7500 usec = 0,4 pour mille.

C'est bien meilleur que pour un affichage sur vu-mètre et surtout, il n'y a pas de réglage à faire. C'est donc indéréglable.

[nornand]

Bravo ! enfin un Arduino qui sert a autre chose qu'a allumer un LED .

[Yvan_Delaserge]

Je viens de terminer la version à Arduino. La précision est excellente, au moins égale à celle de mon oscilloscope.

[Yvan_Delaserge]

Le schéma est le suivant:



J'ai repris le schéma de départ avec juste deux petites modifications: L'alimentation 12 V est ramenée à 5 V en deux étapes: d'abord une Zener 9 V, puis le régulateur 5 V qui figure sur la carte Arduino nano. Je voulais éviter que ce dernier chauffe trop.

Et j'ai ajouté une 100 K de l'entrée de l'Arduino vers la masse pour éviter que cette dernière, qui est à très haute impédance, "flotte" et capte des parasites.

[Yvan_Delaserge]

Voici la dernière version du software:

/*The circuit:
 * LCD RS pin to digital pin 13
 * LCD Enable pin to digital pin 12
 * LCD D4 pin to digital pin 11
 * LCD D5 pin to digital pin 10
 * LCD D6 pin to digital pin 9
 * LCD D7 pin to digital pin 8
 * LCD R/W pin to ground
 * LCD VSS pin to ground
 * LCD VCC pin to 5V
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)
 */
 // include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

int input = 2;
unsigned long tempsDebutImpuls = 0;
unsigned long tempsFinImpuls = 0;
int prevInputState=0;
unsigned long dureeOn = 0;
unsigned long dureeOff = 0;
float toursMinute = 0;//on va faire la sliding moyenne sur 6 mesures
int moyTours = 0;
int moyTours0 = 0;
int moyTours1 = 0;
int moyTours2 = 0;
int moyTours3 = 0;
int moyTours4 = 0;
int moyTours5 = 0;
float dwell = 0;//on va faire la sliding moyenne sur 6 mesures
int moyDwell = 0;
int moyDwell0 = 0;
int moyDwell1 = 0;
int moyDwell2 = 0;
int moyDwell3 = 0;
int moyDwell4 = 0;
int moyDwell5 = 0;
int i = 1;//compteur pour affichage

void setup() {
 // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
 // Print a message to the LCD.
  lcd.print("Rev/min   Dwell "); 
  // make the input's pin an input:
  pinMode(input, INPUT);
//  pinMode(7, OUTPUT);//pour mesurer le temps de rotation de la boucle loop
//  Serial.begin(9600);
}

void loop() {
  
  // read the input pin:
  int inputState = digitalRead(input);

//détection d'un front montant  
  if (inputState == HIGH && prevInputState == 0)
{
  tempsDebutImpuls = micros();
  dureeOff = micros()- tempsFinImpuls;
  prevInputState = 1;
  
  //fenêtre de lecture entre 10000 et 100 t/min
  if (dureeOff > 3000 && dureeOff < 300000){
    moyennes();
   }
}

//détection d'un front descendant
if (inputState == LOW && prevInputState == 1)
{
  tempsFinImpuls = micros();
  dureeOn = micros()- tempsDebutImpuls;
  prevInputState = 0;
  
  //fenêtre de lecture entre entre 10000 et 100 t/min
  if (dureeOn > 3000 && dureeOn < 300000)
    {
    moyennes();
    }
}

//compteur d'affichage
if(i==1){affichage();
} 
i ++;
if (i==40000){i=1;//on affiche sur le LCD toutes les 40 000 boucles loop
}

//  digitalWrite(7, HIGH);//pour mesurer le temps de rotation de la boucle loop
//  digitalWrite(7, LOW);//pour mesurer le temps de rotation de la boucle loop
}

//on calcule les moyennes lors des changements d'état de l'entrée
void moyennes(){
toursMinute = 30000000/(dureeOn + dureeOff);
moyTours5 = moyTours4;
moyTours4 = moyTours3;
moyTours3 = moyTours2;
moyTours2 = moyTours1;
moyTours1 = moyTours0;
moyTours0 = toursMinute;
moyTours = (moyTours0 + moyTours1 + moyTours2 + moyTours3 + moyTours4 + moyTours5)/6;

dwell = 90 * dureeOn/(dureeOn + dureeOff);
moyDwell5 = moyDwell4;
moyDwell4 = moyDwell3;
moyDwell3 = moyDwell2;
moyDwell2 = moyDwell1;
moyDwell1 = moyDwell0;
moyDwell0 = dwell;
moyDwell = (moyDwell0 + moyDwell1 + moyDwell2 + moyDwell3 + moyDwell4 + moyDwell5)/6;
}

void affichage(){
  lcd.clear();
  
  // timeout: On efface l'affichage si on n'a pas d'activité à l'entrée après 400 ms
  if ( (micros()- tempsDebutImpuls >= 400000)|| (micros()- tempsFinImpuls >= 400000))
  {  
  clearDisplay();
  }
  
  //on n'affiche pas les valeurs hors norme
  else if( moyTours < 100)
  {
   lcd.print("REV / MIN < 100 ");
  }
  else if( moyTours > 2500)
  {
   lcd.print("REV / MIN > 2500");
  }
   else if( moyDwell <5 || moyDwell > 85)
  {
   lcd.print("DWELL OFF LIMITS");
  }
  
  //on n'affiche que les valeurs dans la norme
  else{ 
       lcd.print("Rev/min   Dwell ");
       // set the cursor to column 0, line 1
       // (note: line 1 is the second row, since counting begins with 0):
       lcd.setCursor(0, 1);
       lcd.print(moyTours);
       lcd.setCursor(10, 1);
       lcd.print(moyDwell);
       lcd.print(" deg");
       }
  }
  
  void clearDisplay(){
  lcd.clear();
  lcd.print("Rev/min   Dwell ");
  }

[DAUDET78]

Le schéma est le suivant:

La 10K est trop faible, elle bouffe trop d'énergie sur l'allumage.
D'autre part, elle se prend des centaines de volt, une 1/4W est limitée à 300V

[zibuth27]

hello,

circuit d'entrée :
en accord avec Daudet, ton circuit de capture du signal des vis platinées est à relativement faible impédance (11k5 + 3,3nF sur les vis platinées) cela pourrait perturber les allumages limites.
tu peux augmenter largement cette cette valeur, le filtrage RC actuel est à 4.2kHz et le taux de division de tension avec la 100k ou la pull-up interne te laissent de la marge
Un allumage classique genre bobine vintage Ducellier va produire une surtension de l'ordre de 250V (voir PJ)

Je ne vois pas, de plus, la nécessité fonctionnelle de la diode D1, puisqu'elle existe déjà dans la zener (et que l'alternance négative, quand elle existe, est déjà largement atténuée par le taux de division du circuit d'entrée.

il existe une autre solution que de mettre 100k à la masse de l'entrée, c'est d'utiliser la résistance programmable de pull-up de la pin PD2. Il suffit alors de la programmer pour l'utilisation des fronts, (par interruptions ou par polling)


remarque sur le Dwell :
tu le mesures en degrés, OK
mais tu dois convertir ces degrés lorsque tu changes d'architecture moteur
le Dwell n'est évidemment pas de 57° pour l'exemple que tu montres dans ton post #1 (8 cylindres, 1 bobine)
je préfère donc, comme beaucoup, parler en rapport cyclique, de 0 à 1. C'est plus universel.

suggestion :
le but du Dwell est finalement de mesurer un temps de charge en énergie magnétique dans la bobine, c'est donc des millisecondes qui représentent la grandeur à mesurer
puisque tu utilises un arduino, tu pourrais peut-être afficher le temps de fermeture rupteur (temps de charge bobine) en valeur absolue, des ms, le dwell en ° ou rapport, représente quant à lui, une valeur relative
Ayant par ailleurs calculé la constante de temps de ton circuit, tu te rends alors mieux compte de la baisse d'énergie à haut régime.


saluts

[Yvan_Delaserge]

Salut les gars et merci pour ces remarques pleines de bon sens.

Le circuit dont je me suis inspiré, qui datait des années 70, comportait une résistance de 10K en entrée et c'était déjà trop pour un circuit TTL 7402, comme je l'explique en début de fil. J'ai dû le remplacer par un 74HC02 pour que la première porte puisse changer d'état.

Mais avec les centaines de MOhms de résistance d'entrée de l'Arduino, il est bien clair que la valeur de la 10 K pourra être augmentée.
Je pourrais la remplacer par 2 résistances de 47 K en série. Qu'en pensez-vous?

Avec 2 résistances de 47 KOhms en série en entrée, le filtre passe-bas verrait sa fréquence de coupure ramenée à environ 420 Hz. Si un moteur 4 cylindres 4 temps tourne à 10 000 tours/minute, la fréquence des allumages est de 333 Hz. Donc, ça irait bien. De toutes manières, le dwell, on va le mesurer avec le moteur au ralenti, aux environs de 1000 t/min, c'est-à-dire avec une fréquence d'allumages de 33 Hz.

Mais dans ce cas, quelle valeur choisir pour la résistance de rappel à la masse de l'entrée? 1 MOhm?

J'avais pensé à utiliser la résistance de pullup de l'entrée de l'Arduino. Elle fait environ 50 K, mais elle ramène l'entrée à + 5 V au lieu de la masse.
Mais surtout, si la résistance en série avec l'entrée du montage est maintenant augmentée à 100 K, je ne suis pas sûr qu'on arrive encore à faire commuter l'entrée de l'Arduino.

OK pour la diode D1, c'est une 1N 4007. Son utilité était de court-circuiter les impulsions négatives, sans doute par peur de surcharger la Zener. mais avec 100 K de résistance d'entrée, elle ne sert vraiment plus à rien.

Il serait effectivement très facile de modifier le mode d'affichage du Dwell. Les voitures que je bricole pour l'instant sont toutes des 4 cylindres 4 temps, mais il serait possible d'ajouter deux commutateurs, un pour 2 temps/4 temps et un autre pour 4, 6 ou 8 cylindres.

Sur les docs du constructeur, le dwell est donné en degrés, c'est de l'ordre de 55 degrés + ou - 5 degrés. En gros, c'est un peu plus de la moitié du temps ON. Un rapport cyclique d'environ 60 %. Mais à haut régime, c'est clair que la bobine a de moins en moins de temps pour emmagasiner de l'énergie entre 2 allumages.

[Yvan_Delaserge]

Encore quelques vues du montage. Hier soir je n'ai pas eu le temps de les poster.



On voit à gauche une petite plaquette d'essais qui contient les circuits de mise en forme du signal d'entrée et de filtrage de l'alimentation, ainsi que le potentiomètre nécessaire pour régler le contraste de l'affichage LCD.

Sur la droite, on voit l'afficheur LCD 2 lignes de 16 caractères, marqué QAPASS.
L'Arduino Nano est placé sur l'afficheur. Il est fixé à l'afficheur par 4 de ses broches, qui se trouvent en bas à gauche. Mécaniquement, ça paraît assez solide, compte tenu des faibles dimensions et de la légèreté de la platine Arduino Nano.
Quand j'ai réalisé ce montage, je n'avais pas encore réussi à programmer les Arduino Mini, dont les dimensions sont encore plus réduites. Mais c'est maintenant chose faite, ça va m'être utile pour les réalisations à venir.

On distingue sur l'Arduino nano le petit régulateur 5 Volts à 3 pattes plus une mini-ailette, que j'avais peur de faire surchauffer, et qui sert à alimenter le microcontrôleur, l'afficheur, ainsi que son éclairage. La consommation totale est de moins de 30 mA.

[Yvan_Delaserge]

Le boîtier a été réalisé sur mesure, à partir de chutes de bois.
Il est constitué de deux plaquettes de contreplaqué 5 mm et d'un cadre en contreplaqué collé assez épais.
Un appareil comme celui-ci doit pouvoir être manipulé avec les nains pleines de cambouis et il sera sans doute souvent posé en équilibre instable sur un moteur qui vibre. En prévoyant du bois assez épais, il devrait pouvoir tomber par terre sans se casser.

[Yvan_Delaserge]

Et enfin quelques affichages.



Il est important d'éviter d'afficher des indications trompeuses. J'ai donc choisi de ne pas afficher les régimes moteurs inférieurs à 100 parce qu'il est impossible que le moteur tourne en-dessous de cette vitesse. Et de ne pas afficher les régimes supérieurs à 2500 tours/minute parce qu'ils ne nous intéressent pas. le réglage du dwell se fait au ralenti, c'est-à-dire aux environs de 1000 tours/minute.

Lorsque l'alimentation du montage est branchée, mais l'entrée du montage n'est pas connectée, ou que le moteur ne tourne pas, l'Arduino va mesurer des intervalles OFF très longs, qu'il ne faut évidemment pas comptabiliser, sous peine de fausser les mesures à venir. Le software y veille et lorsque cela arrive, l'affichage n'indique rien sous "rev/min" et "dwell".

Enfin, si le dwell est < 5 degrés ou > 85 degrés, on affiche " dwell off limits". Mon générateur basse fréquence n'arrive pas à me génerer des rapports cycliques suffisamment extrêmes pour que je puisse vérifier que cette fonction est OK. Je vais essayer aujourd'hui avec un autre générateur.

[DAUDET78]

Je pourrais la remplacer par 2 résistances de 47 K en série. Qu'en pensez-vous?

C'est plus raisonnable.