ordi de bord

pour débuter , il me faudrait les sondes suivantes:

T°C d'huile, une sonde deux fil (+ et -)
Pression d'huile sonde deux fil (+ et -)
T°C d'admission: 2 fils (+ et moins)
T°C EGT: 2 fils (+ et -)
prm: 3 fils : +, signal et masse.

Salut a tous!

Je n'ai pas trouver de section pour me présenter donc si il en a une j’irais faire ma petite présentation.
Novice dans la programmation arduino, j'ai déjà monter une gestion pour turbo a géométrie variable trouver sur le net sur base de uno.

Salut Beru tu va bien? j'ai trouver ton projet ici et vue que je vais faire la même chose sur notre camion je venais au nouvelles.

Pour ma part j'ai commencer a plancher sur le sujet je vais utiliser un arduino mega 2560 avec un écran 20X4
Le montage sera prévu pour un lt35 dépanneuse ou l'on viens de changer le moteur par un 5 cylindres tdi-m. Vue que l'ancien moteur a couler une bielle a cause des mauvaise information donner par le tableau de bord rudimentaire, je veut essayer de lui faire un petit ordinateur de bord évolutif.

Les bases a mesurer sont diverse températures, pression collecteur.
Les sorties, deux niveau de refroidissement, 4 niveau de led de couleur pour faire un schift light (car il n'y a pas de compte tour) et une alarme sonore
Sur l'afficheur les tr/min, pression de sural et en défilement les températures.

Pour le calcul des valeur de sonde de température j'ai un autre programme ou çà a déjà été intégrer il faudra donc extraire les bonne ligne de programmation.

pour le calcul des tr/min, j'ai fait ça dans ma gestion de groupe électrogène disponible ici : Commande automatique de groupe électrogène - machine à états et autres questions - Réalisations et Projets Finis - Arduino Forum (voir la dernière version du code) en utilisant un capteur de proximité qui compte des dents sur le volant moteur

merci de l'info je vais aller voir çà de plus prêt. :wink:

Salut,

Pour revenir à la lecture des infos analogiques, je me suis posé pas mal de questions. J'ai constaté que déjà, la référence du CAN, c'est VCC, et que le petit régulateur de l'arduino est vraiment crade, et VCC bouge beaucoup. Donc pour commencer, il faut lui donner une vraie référence bien stable. Il faut peut-être intervenir au niveau du core arduino également, car dans wiring_analog.c, on peut lire :

uint8_t analog_reference = DEFAULT;

void analogReference(uint8_t mode)
{
	// can't actually set the register here because the default setting
	// will connect AVCC and the AREF pin, which would cause a short if
	// there's something connected to AREF.
	analog_reference = mode;
}

L'idée d'un court-circuit n'est pas très engageante...

Pour les capteurs en eux-même, si on peut les déconnecter du circuit 12V, j'utilise un petit générateur de courant à base d'un PNP (genre 2N2905 ou 2N2907). Si on fait passer un courant constant dans une résistance, on obtient alors une tension constante, complètement indépendante de l'alimentation, c'est déjà un grand pas en avant! de plus, la tension obtenue est directement proportionnelle à la valeur de la résistance (mesure linéaire).
Par exemple, si on fait passer 1mA dans une résistance, alors la tension mesurée en mV sera égale à la résistance (utile pour faire des mesures, non?).

Autre exemple, on veut mesurer un capteur qui donne une résistance de 1000 à 3500 ohms, on en déduit que pour un courant de (5/3500) = 1,43mA, on peut alors mesurer une tension de 5V pour 3500ohms et 1,43V pour 1000ohms. La conversion donnera alors une valeur entre 293 pour 1000ohms et 1023 pour 3500ohms, sous une tension de référence AREF de 5V.

hi hi hi...

Pour mon précédent montage j'avais utiliser un transistor (7808) pour réguler la tentions d’alimentation de l'arduino avec les réutilisation de 5V de celui ci pour les capteur.
Je n'ai pas noter de tentions bizarres ou de fonctionnement aléatoire. Seulement sur mon capteur de régime moteur après avoir rallonger les fils qui ce sont mis a capter des interférences. (je n'avais pas utiliser des fils blindées...)

Je vais citer ici le programme que j'ai déjà utiliser qui proviens du net.
Ce programme sert a gérer un turbo a géométrie variable et la lda sur une pompe a injection de turbo diesel.
Il mesure également deux sondes de température.

J'aimerais me baser sur ce programme pour extraire les gestion de sondes et de régime moteur.

};

// R1 = 2400ohm, R2 = old style Bosch temp sensor
unsigned char tempMap[] = {
    'M','1','D',
    0x8,0x1,0xAB,0x00,0xAA,
    // values at -64,-32,0,32, 64,96,128,160 °C
    175+64,120+64,90+64,62+64,44+64,30+64,6+64,-55+64,
//    255,227,179,109,51,19,9,0,  Calculated from bosch reference, does not seems to be accurate?
    00,00,00,                  // lastX,lastY,lastRet
};

// Use slighly logaritmic output positions instead of plain linear
/*unsigned char vntActuatorMovementRemap[] = {
 'M','1','D',
 0x8,0x0,0xDE,0xAD,0x00,
 0,2,8,20,50,90,180,255
 };

// used for RPM counting
volatile unsigned long rpmLastTeethSeenTime = 0;
volatile unsigned long rpmNow = 0;


[code]

Vous pouvez trouver le programme entier ici -> [url=http://dmn.kuulalaakeri.org/vnt-lda/]http://dmn.kuulalaakeri.org/vnt-lda/[/url]

[/code]

bon j'ai commencer a taper un code je me suis inspirer de la base de bricofoy merci a lui XD.

Je ne comprend pas encore bien tous ce que je fait, il y a des erreurs pour le moment que je ne comprend pas... "assignment of read-only variable 'A..' "

voici mon début de code

/*
Ordinateur de bord pour lt 35 2.5 tdi
V1
*/

// donées mécaniques

#define nbr_phases_vilo  5     // nombre de phases capter sur le vilbrequin pour un tour moteur
#define rpm_led1         4000  // led vertes
#define rpm_led2         4250  // led vertes
#define rpm_led3         4500  // led orange
#define rpm_led4         5000  // led rouge
#define temp_eau_def     108   // température de déclenchement de l'alarme surchauffe en C°
#define vent1_on         92    // température de déclenchement du premiere ventilateur en C°
#define vent2_on         96    // température de déclenchement du second ventilateur en C°
#define vent1_off        82    // température de d'arret du premier ventilateur en C°
#define vent2_off        86    // température de d'arret du second ventilateur en C°
#define temp_oil_def     130   // température de déclenchement de l'alarme température d'huile en C°



// brochage des entrées

#define eauPin    A0    //sonde de température d'eau moteur
#define oilPin    A1    //Sonde de température d'huile moteur
#define airPin    A2    //Sonde de température d'air d'admission
#define mapPin    A3    //capteur pression suralimentation
#define g28Pin    13   //entrée capteur régime moteur
#define g80Pin    12    //capteur levée d'aiguille

// brochage des sorties

#define g28Pin    13    //entrée capteur régime moteur
#define g80Pin    12    //capteur levée d'aiguille
#define N75Pin    11    //commande de vanne de turbo
#define wPin      10    //sortie info W pour ancien compteur vag
#define vent1Pin  A8 
#define vent2Pin  A9
#define alPin     A10   //alarme sonore
#define led1Pin   A12
#define led2Pin   A13
#define led3Pin   A14
#define led4Pin   A15

// variables globales
unsigned int rpm_moteur; 	//vitesse de rotation moteur.

//variables utilisees en interruption (volatile = stockees en RAM)
volatile unsigned int rpm_cpt;                     //compteur de passage en interruption. Pour savoir cb de périodes sont utilisées pour le calcul de F
volatile unsigned long rpm_periode;                //periode des implulsion du capteur de rotation
volatile unsigned long rpm_tprecedent,rpm_tcourant;//temps utilisés pour calculer la périod


;void setup()
{
  pinMode(eauPin, INPUT);
  pinMode(oilPin, INPUT);
  pinMode(airPin, INPUT);
  pinMode(mapPin, INPUT);
  pinMode(g28Pin, INPUT_PULLUP);
  pinMode(g80Pin, INPUT_PULLUP);
  
  pinMode(vent1Pin, OUTPUT);
  pinMode(vent2Pin, OUTPUT);
  pinMode(alPin,    OUTPUT);
  pinMode(led1Pin,  OUTPUT);
  pinMode(led2Pin,  OUTPUT);
  pinMode(led3Pin,  OUTPUT);
  pinMode(led4Pin,  OUTPUT);
  pinMode(N75Pin,   OUTPUT);
  pinMode(wPin,     OUTPUT);
}

void calcule_rpm() {
  //calcul de la vitesse de rotation du moteur.
  
  //on calcule la fréquence avec 1*60*1000/période car la période est en ms (*1000), et que l'on veut la fréquence en tr/min et non en Hz ou tr/s (*60)
  //on divise ensuite le total par le nombre de dents comptées par le capteur sur 1 tour moteur
  //la periode est une moyenne des rpm_cpt periodes mesurees en interruption avant passage par ici
  
  //Serial.print(rpm_cpt);
  //Serial.println(" ");  
  if (rpm_cpt)
    rpm_moteur = (unsigned int)(60000/(rpm_periode/rpm_cpt))/nbr_phases_vilo;
    rpm_cpt = 0; 			//remise à zero du compteur pour les prochaines mesures
    rpm_periode = 0;			//idem pour la periode 
}

//Gestion des ventilateurs

void ventilateurs(){
 
  vent1Pin = digitalRead(eauPin);


  if (eauPin > vent1_on) {       // enclenchement du premier ventilateur
        
    digitalWrite(vent1Pin, HIGH);  
  } 
  else (eauPin < vent1_off); {
   
    digitalWrite(vent1Pin, LOW); // déclenchement du ventilateur
  }
    vent1Pin = digitalRead(eauPin);


  if (eauPin > vent2_on) {       // enclenchement du second ventilateur
        
    digitalWrite(vent2Pin, HIGH);  
  } 
  else (eauPin < vent2_off); {
   
    digitalWrite(vent2Pin, LOW); // déclenchement du ventilateur
  }
}
 // gestion des led pour passage de vitesse
 
 void led(){
    led1Pin = (rpm_led1);


  if (rpm_moteur > rpm_led1) {       // enclenchement led verte premier niveau
        
    digitalWrite(led1Pin, HIGH);  
  } 
  else (rpm_moteur < rpm_led1); {
   
    digitalWrite(rpm_led1, LOW);     // déclenchement led
  }
      led2Pin = (rpm_led2);


  if (rpm_moteur > rpm_led2) {       // enclenchement led verte deuxiemme niveau
        
    digitalWrite(led2Pin, HIGH);  
  } 
  else (rpm_moteur < rpm_led2); {
   
    digitalWrite(rpm_led2, LOW);     // déclenchement led
  }
      led3Pin = (rpm_led3);


  if (rpm_moteur > rpm_led3) {       // enclenchement led orange
        
    digitalWrite(led3Pin, HIGH);  
  } 
  else (rpm_moteur < rpm_led3); {
   
    digitalWrite(rpm_led3, LOW);     // déclenchement led
  }
      led4Pin = (rpm_led4);


  if (rpm_moteur > rpm_led4) {       // enclenchement led rouge
        
    digitalWrite(led1Pin, HIGH);  
  } 
  else (rpm_moteur < rpm_led4); {
   
    digitalWrite(rpm_led4, LOW);     // déclenchement led
  }
}

la fatigue prenant le dessus, je te dirais juste que quand tu fais "if (eauPin > vent1_on)", le compilateur traduit en "if (A0 > 92)", ce qui sera toujours faux (A0 = qqchose comme 14 je crois).

il faut donc faire "if (analogRead(eauPin) > vent1_on)" pour déclencher une conversion de eauPin.

ensuite, ";void setup()" ne doit pas trop marcher (le point-virgule)

"vent1Pin = digitalRead(eauPin);" ne peut pas marcher, vent1Pin est un alias, une constante, tu ne peut pas lui assigner une valeur. par contre, digitalWrite(vent1Pin, digitalRead(eauPin)); devrait te rendre un petit service.

Je ne vais pas plus loin, j'aurais plus vite fait de réécrire ton code que de le corriger en t'expliquant.

relis tout et bon courage,

Cinci

Merci beaucoup d'avoir pris le temps de me répondre.

Je vais reprendre mon travail et corriger çà déjà. XD

Bon j'ai reçu tous le matos et hier j'ai commencer a programmer pour tester l'écran lcd.

J'y vais par étapes car je ne comprend pas tous encore mais déjà çà commence a m'éclater XD

Donc j'ai commencer par programmer ce que je veut afficher:

Depuis j'en ai rajouter et j'ai également programmer un capteur map pour mesurer la pression du collecteur d'admission.
Mon code actuel:

/*

 
 The circuit:
 * LCD RS pin to digital pin 12
 * LCD Enable pin to digital pin 11
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2
 * LCD R/W pin to ground
 * 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(12, 11, 5, 4, 3, 2);

void setup() {
   // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
  
    lcd.begin(20, 4);
  
      
   lcd.setCursor(0,0);
  lcd.print("RPM");
    lcd.setCursor(8,0);
  lcd.print("Tr");
  
 
    lcd.setCursor(16,0);
  lcd.print("Bar");
  
   lcd.setCursor(0,1);
  lcd.print("Eau");
    lcd.setCursor(6,1);
  lcd.print("C");
    lcd.setCursor(0,3);
  lcd.print("Huile");
    lcd.setCursor(8,3);
  lcd.print("C");
    lcd.setCursor(0,2);
  lcd.print("Air");
    lcd.setCursor(6,2);
  lcd.print("C");
  
   lcd.setCursor(10,1);
  lcd.print("Vent1");
    lcd.setCursor(10,2);
  lcd.print("Vent2");
  
}

void loop() {
    int capteurMap = analogRead(A0);                 // capteur MAP
                                                      // Converssion lecture annalogique (de 0 - 1023) en pression de (-1 à 1bar):
  float pression =0.441*(capteurMap*(5/1023.0))-1;    // 0.44 et la valeur a modifien en fonction du capteur map. (0.44 pour capteur de 200Kpa)
  // print out the value you read:
  Serial.println(pression);
  
     lcd.setCursor(11,0);
  lcd.print(pression);
}

beau boulot, tu avance bien!
Si je peux me permettre un conseil, (j'ai déjà réalisé ce type de code pour un obd et un mano) j'ai remarqué qu'avec l’acquisition de multiple capteurs, la mise a jour des données pouvais ralentir. C'est flagrant sur le régime moteur, les pics de régimes ne sont pas affichés car l'arduino doit voir tous les autres capteurs avant de revenir sur celui des tr/min. L'astuce que j'utilise consiste a écrire un fonction en dehors de la void loop pour chaque capteur, et d'appeler la fonction tr/min entre tous les capteurs. Ça permet de mettre a jour les tr/min beaucoup plus souvent, sans surcharger le code, il faut bien entendu inclure la mise a jour du lcd dans la fonction tr/min.

Oui je voie ce que tu veut dire mais je ne sais pas encore ques que tu entend par écrire une fonction pour les capteurs en dehors de " Void loop"
Car si tel est le cas elle ne sera pas rafraichie a chaque tour du programme. Non?

De plus j'ai mis une tempo pour faire clignoter ma sortie d'alarme mais cette tempo me ralentis toute l’exécution du programme. Y a t'il une solution pour que la tempo soit uniquement affecter a mon utilisation sans bloquer le rafraichissement tous le programme?

Sinon j'ai bosser toute la journée et j'ai bien avancer! :astonished:

/*

 
 The circuit:
 * LCD RS pin to digital pin 12
 * LCD Enable pin to digital pin 11
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2
 * LCD R/W pin to ground
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)
 
 Capteurs:
 * Map sur Analogic A0
 
  */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int eauPin = A0;    // sonde d'eau
int vent1Pin = A8;
int vent2Pin = A9;
int alarme = A10;

void setup() {
   // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
  
  lcd.begin(20, 4);
      
  pinMode(vent1Pin, OUTPUT); 
  pinMode(vent2Pin, OUTPUT);
  pinMode(alarme, OUTPUT);
  
      
   lcd.setCursor(0,0);
  lcd.print("RPM");
    lcd.setCursor(8,0);
  lcd.print("Tr");
  
 
    lcd.setCursor(16,0);
  lcd.print("Bar");
  
   lcd.setCursor(0,1);
  lcd.print("Eau");
    lcd.setCursor(7,1);
  lcd.print("C");
    lcd.setCursor(0,3);
  lcd.print("Huile");
    lcd.setCursor(9,3);
  lcd.print("C");
    lcd.setCursor(0,2);
  lcd.print("Air");
    lcd.setCursor(7,2);
  lcd.print("C");
  
   lcd.setCursor(10,1);
  lcd.print("Vent1");
    lcd.setCursor(10,2);
  lcd.print("Vent2");
  
}

void loop() {
    int capteurMap = analogRead(A0);                 // capteur MAP
                                                      // Converssion lecture annalogique (de 0 - 1023) en pression de (-1 à 1bar):
  float pression =0.441*(capteurMap*(5/1023.0))-1;    // 0.44 et la valeur a modifien en fonction du capteur map. (0.44 pour capteur de 200Kpa)
  // print out the value you read:
  Serial.print("pression:");
  Serial.print(pression);
  
     lcd.setCursor(11,0);
  lcd.print(pression);

  
  // Gestion des ventilateurs et aficheage temp d'eau
  
  int eauValue = analogRead(A0);  // variable température d'eau
  int tempEau = eauValue*0.12; 
  
   { if (tempEau >= 70)          // enchlenchement V1        
  digitalWrite(vent1Pin, HIGH);
     if (tempEau >= 90)          // enchlenchement V2         
  digitalWrite(vent2Pin, HIGH);
     } 
   { if (tempEau <= 75)          // déchlenchement V1 
  digitalWrite(vent1Pin, LOW);
     if (tempEau <= 85)          // déchlenchement V2
  digitalWrite(vent2Pin, LOW);  
     }
   
  Serial.print("tempEau:");
  Serial.print(tempEau);
  
    lcd.setCursor(4,1);          // effacement valeur d'eau précédente
  lcd.print("   ");
    lcd.setCursor(4,1);
  lcd.print(tempEau);            // affichage temps d'eau
  
  // Affichage temps D'huile
  
  int HuileValue = analogRead(A0);  // variable température d'huile
  int tempHuile = HuileValue*0.15; 
  
   Serial.print("tempHuile:");
  Serial.print(tempHuile);
  
   lcd.setCursor(6,3);          // effacement valeur d'huile précédente
  lcd.print("   ");
    lcd.setCursor(6,3);
  lcd.print(tempHuile);            // affichage temps d'huile
  
    // Affichage temps D'Air
  
  int AirValue = analogRead(A0);  // variable température d'air
  int tempAir = AirValue*0.1; 
  
   Serial.print("tempAir:");
  Serial.println(tempAir);
  
   lcd.setCursor(4,2);          // effacement valeur d'Air précédente
  lcd.print("   ");
    lcd.setCursor(4,2);
  lcd.print(tempAir);            // affichage temps d'air
 
  
  // alarme
  
  {if ((tempEau >= 110) || (tempHuile >= 130) || (tempAir >= 90)) 
    digitalWrite(alarme, HIGH);
    delay(500);
    digitalWrite(alarme,LOW);
    delay(500);
  
 
 }
}

petite vidéo a suivre pour montrer le fonctionnement.
J'ai volontairement utiliser qu'une seule entrer pour tester actuellement...

Les led Rouge et verte sont les seuils de déclenchement des ventilateurs et la orange l'alarme pour une surchauffe quelconque.

Je m'explique, void setup() et void loop() sont des fonctions, c'est a dire des portions de code qui font référence a un nom de fonction, et on peut les lires si on les appelles via leur noms. Par exemple dans le code du bootloader de l'uno il doit y avoir un appel a la fonction setup() puis loop().
Tu peux très bien créer tes propres fonctions, tu les écris après ou avant la loop() et tu les utilises uniquement quand tu en as besoin dans la loop().
Pour exemple, en dessous j'ai créé un fonction Tempeau(). Pour pouvoir utiliser la valeur de tempEau dans toutes les fonctions, il faut la déclarer avant setup(), il n'est pas obligatoire de lui attribuer une valeur au début.

Pour ton problème de led alarme, la encore il y a une astuce, je suis passé par la aussi. Je voulais afficher la valeur du peak boost pendant quelques secondes avant qu'elle ne s'efface. Pour ce genre de tempo, tu utilise un compteur que tu lance lorsque la led s'allume, et que tu incrémente a chaque lecture. Arrivé a un certain nombre de lecture ça inverse l'état de ta sortie. en changeant le nombre cible du compteur tu peux faire varier le temps ou la led va rester allumer. J'ai fait la modif dans le code, et je l'ai intégré dans un fonction pour alléger la loop().

 The circuit:
 * LCD RS pin to digital pin 12
 * LCD Enable pin to digital pin 11
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2
 * LCD R/W pin to ground
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)
 
 Capteurs:
 * Map sur Analogic A0
 
  */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int eauPin = 0;    // sonde d'eau
int vent1Pin = 8;
int vent2Pin = 9;
int alarme = 10;

int tempEau;
int comptalarm=0;
boolean LED=LOW;

void setup() {
   // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
  
  lcd.begin(20, 4);
      
  pinMode(vent1Pin, OUTPUT); 
  pinMode(vent2Pin, OUTPUT);
  pinMode(alarme, OUTPUT);
  
      
   lcd.setCursor(0,0);
  lcd.print("RPM");
    lcd.setCursor(8,0);
  lcd.print("Tr");
  
 
    lcd.setCursor(16,0);
  lcd.print("Bar");
  
   lcd.setCursor(0,1);
  lcd.print("Eau");
    lcd.setCursor(7,1);
  lcd.print("C");
    lcd.setCursor(0,3);
  lcd.print("Huile");
    lcd.setCursor(9,3);
  lcd.print("C");
    lcd.setCursor(0,2);
  lcd.print("Air");
    lcd.setCursor(7,2);
  lcd.print("C");
  
   lcd.setCursor(10,1);
  lcd.print("Vent1");
    lcd.setCursor(10,2);
  lcd.print("Vent2");
  
}

void loop() {
    
    int capteurMap = analogRead(A0);                 // capteur MAP
                                                      // Converssion lecture annalogique (de 0 - 1023) en pression de (-1 à 1bar):
  float pression =0.441*(capteurMap*(5/1023.0))-1;    // 0.44 et la valeur a modifien en fonction du capteur map. (0.44 pour capteur de 200Kpa)
  // print out the value you read:
  Serial.print("pression:");
  Serial.print(pression);
  
     lcd.setCursor(11,0);
  lcd.print(pression);

  
  // Gestion des ventilateurs et aficheage temp d'eau
  Tempeau();
 
  // Affichage temps D'huile
  
  int HuileValue = analogRead(A0);  // variable température d'huile
  int tempHuile = HuileValue*0.15; 
  
   Serial.print("tempHuile:");
  Serial.print(tempHuile);
  
   lcd.setCursor(6,3);          // effacement valeur d'huile précédente
  lcd.print("   ");
    lcd.setCursor(6,3);
  lcd.print(tempHuile);            // affichage temps d'huile
  
    // Affichage temps D'Air
  
  int AirValue = analogRead(A0);  // variable température d'air
  int tempAir = AirValue*0.1; 
  
   Serial.print("tempAir:");
  Serial.println(tempAir);
  
   lcd.setCursor(4,2);          // effacement valeur d'Air précédente
  lcd.print("   ");
    lcd.setCursor(4,2);
  lcd.print(tempAir);            // affichage temps d'air
 
  
  // alarme
  
  if ((tempEau >= 110) || (tempHuile >= 130) || (tempAir >= 90)) 
  {
    Alarme();
  }
  else{digitalWrite(alarme,LOW);
        comptalarm=0;}
 
}//fin void loop()


void Tempeau()
{
 int eauValue = analogRead(A0);  // variable température d'eau
  tempEau = eauValue*0.12; 
  
   { if (tempEau >= 70)          // enchlenchement V1        
  digitalWrite(vent1Pin, HIGH);
     if (tempEau >= 90)          // enchlenchement V2         
  digitalWrite(vent2Pin, HIGH);
     } 
   { if (tempEau <= 75)          // déchlenchement V1 
  digitalWrite(vent1Pin, LOW);
     if (tempEau <= 85)          // déchlenchement V2
  digitalWrite(vent2Pin, LOW);  
     }
   
  Serial.print("tempEau:");
  Serial.print(tempEau);
  
    lcd.setCursor(4,1);          // effacement valeur d'eau précédente
  lcd.print("   ");
    lcd.setCursor(4,1);
  lcd.print(tempEau);            // affichage temps d'eau
  
}

void Alarme()
{digitalWrite(alarme,LED);//LED est un boolean, 2 états HIGH ou LOW
  comptalarm=comptalarm+1;
  if (comptalarm>10)//en changeant la valeur ici tu change le délais.
     {LED=!LED;
     comptalarm=0; 
     }
}

Merci beaucoup d'avoir pris le temps de te pencher sur mon programme!!!

Effectivement le fonctionnement et plus homogène. Je vais continuer a travailler de cette façon pour conserver un maximum de rapidité. ]:slight_smile:

bon j'ai bien avancer sur mon code il ne me reste plus que le compte tour a mètre au point!

Mais là dessus je sèche un peut, j'ai essayer d’intégrer un code d'un autre programme c'est bien écrit enfin il n'y a pas d'erreur mais je code plante...

/*

The circuit:
 * LCD RS pin to digital pin 12
 * LCD Enable pin to digital pin 11
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2
 * LCD R/W pin to ground
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)
 
 Capteurs:
 * Map sur Analogic A0
 
  */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
int eauPin = A0;    // sonde d'eau
int vent1Pin = A8;
int vent2Pin = A9;
int alarme = A10;

int capteurMap;
int tempEau;
int tempHuile;
int tempAir;
int comptalarm=0;
boolean LED=LOW;

int captRpm = 10;
// comptage RPM
volatile unsigned long rpmLastTeethSeenTime = 0;
volatile unsigned long rpmNow = 0;

// valeur calculer
volatile int rpmActual;
volatile unsigned char rpmCorrected; 	//vitesse de rotation moteur.


int ledV1 = A12;    // schift light vert premier niveau pour 3500tr
int ledV2 = A13;    // schift light vert second niveau pour 3800tr
int ledO = A14;     // schift light orange pour 4100tr
int ledR = A15;     // schift light rouge pour 4500tr


void setup() {
   // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
  
    // entrées / sorties :
    
  pinMode(vent1Pin, OUTPUT); 
  pinMode(vent2Pin, OUTPUT);
  pinMode(alarme, OUTPUT);
  
  
  pinMode(captRpm, INPUT);
  
 digitalWrite(captRpm,HIGH); // pullup for honeywell
  attachInterrupt(0, rpmTrigger, RISING); // or falling!	//entree rotation moteur sur INT1


    // Sortie led de passage de vitesse
    
  pinMode(ledV1,OUTPUT);
  pinMode(ledV2,OUTPUT);
  pinMode(ledO,OUTPUT);
  pinMode(ledR,OUTPUT);
  
    // afficheage de la tames du LCD
   lcd.begin(20, 4);
   
   lcd.setCursor(0,0);
  lcd.print("RPM");
    lcd.setCursor(8,0);
  lcd.print("Tr");
  
    lcd.setCursor(16,0);
  lcd.print("Bar");
  
   lcd.setCursor(0,1);
  lcd.print("Eau");
    lcd.setCursor(7,1);
  lcd.print("C");
    lcd.setCursor(0,3);
  lcd.print("Huile");
    lcd.setCursor(9,3);
  lcd.print("C");
    lcd.setCursor(0,2);
  lcd.print("Air");
    lcd.setCursor(7,2);
  lcd.print("C");
  
   lcd.setCursor(10,1);
  lcd.print("Vent1");
    lcd.setCursor(10,2);
  lcd.print("Vent2");
  
} // fin void setup
void Capteurmap()
{
  int capteurMap = analogRead(A0);                
                                                      // Converssion lecture annalogique (de 0 - 1023) en pression de (-1 à 1bar):
  float pression =0.441*(capteurMap*(5/1023.0))-1;    // 0.44 et la valeur a modifien en fonction du capteur map. (0.44 pour capteur de 200Kpa)
  // print out the value you read:
  Serial.print("pression:");
  Serial.print(pression);
  
     lcd.setCursor(11,0);
  lcd.print(pression);
}

void Tempeau()
{
 int eauValue = analogRead(A0);  // variable température d'eau
  tempEau = eauValue*0.12; 
  
   { if (tempEau >= 70)          // enchlenchement V1        
  digitalWrite(vent1Pin, HIGH);
     if (tempEau >= 90)          // enchlenchement V2         
  digitalWrite(vent2Pin, HIGH);
     } 
   { if (tempEau <= 75)          // déchlenchement V1 
  digitalWrite(vent1Pin, LOW);
     if (tempEau <= 85)          // déchlenchement V2
  digitalWrite(vent2Pin, LOW);
     }
  Serial.print("tempEau:");
  Serial.print(tempEau);
  
    lcd.setCursor(4,1);          // effacement valeur d'eau précédente
  lcd.print("   ");
    lcd.setCursor(4,1);
  lcd.print(tempEau);            // affichage temps d'eau
  }

void Temphuile(){
  
  int HuileValue = analogRead(A0);  // variable température d'huile
  int tempHuile = HuileValue*0.15; 
  
   Serial.print("tempHuile:");
  Serial.print(tempHuile);
  
   lcd.setCursor(6,3);          // effacement valeur d'huile précédente
  lcd.print("   ");
    lcd.setCursor(6,3);
  lcd.print(tempHuile);            // affichage temps d'huile
}
void Tempair()
{
   int AirValue = analogRead(A0);  // variable température d'air
  int tempAir = AirValue*0.1; 
  
   Serial.print("tempAir:");
  Serial.print(tempAir);
  
   lcd.setCursor(4,2);          // effacement valeur d'Air précédente
  lcd.print("   ");
    lcd.setCursor(4,2);
  lcd.print(tempAir);            // affichage temps d'air 
}


void Alarme()
{digitalWrite(alarme,LED);//LED est un boolean, 2 états HIGH ou LOW
  comptalarm=comptalarm+1;
  if (comptalarm>10)//en changeant la valeur ici tu change le délais.
     {LED=!LED;
     comptalarm=0; 
     }
 
}

bool s;
unsigned char teethNo = 0;
long int rpmMicros = 0;  

void rpmTrigger() {
    //__asm("cli");
    s = !s;
    unsigned long now = micros();
    // filter out implausible signals
    if (now - rpmLastTeethSeenTime > 400) { 
        teethNo++;
        if (teethNo == 5) {
            teethNo = 0;
            rpmCorrected = (unsigned int)(((1000000*60)/((now-rpmMicros))));
            rpmMicros = now;
        }
        //rpmNow = micros();
        //controls.rpmActual = ((settings.rpmTeethsPerRotation*100000000)/((now- rpmLastTeethSeenTime)*60));
        rpmLastTeethSeenTime = now; 
        
         Serial.print("rpm:");
  Serial.println(rpmCorrected);
       
  
  }
}
 
 void LedRpm() {
 
 if (rpmCorrected >= 3500){
 digitalWrite(ledV1, HIGH);
 }
 else (ledV1, LOW);
 
 if (rpmCorrected >= 3800){
 digitalWrite(ledV2, HIGH);
 }
 else (ledV2, LOW);
 
 if (rpmCorrected >= 4100){
 digitalWrite(ledO, HIGH);
 }
 else (ledO, LOW);
 
  if (rpmCorrected >= 4500){
 digitalWrite(ledR, HIGH);
 }
 else (ledR, LOW);

 }
 
 
void loop() {
    
  Capteurmap(); // capteur MAP
  
  Tempeau();    // Gestion des ventilateurs et aficheage temp d'eau
 
  Temphuile();  // Affichage temps D'huile
  
  Tempair();    // Affichage temps D'Air
  
  rpmTrigger();
  
  // alarme
  
  if ((tempEau >= 110) || (tempHuile >= 130) || (tempAir >= 90)) 
  {
    Alarme();
  }
  else{digitalWrite(alarme,LOW);
        comptalarm=0;}                                                                                                                                   
  
  LedRpm();      // Gestion des led de passage de vitesse
    
}//fin void loop()

[code]

a moins que quelqu'un ai une autre solution pour mon compte tour.

[/code]

De quel type est ton signal, à variation de tension ou de fréquence?

Oui c'est un peut çà Je connait Beru d'un autre forum et il nous avait parler de ce sujet mais parement il n'a pas avancer ou publier ces progrès...
Du coup je l'ai doubler lol.

Mais bon il n'y a pas d'importances.

Mon mode de mesure et un capteur inductif qui va mesurer les phases d'injection d'origine du moteur.
Il y a donc 5 phases par tour moteur. Ce sera donc une mesure par fréquence.
D'ailleurs 5_cylindres si tu pouvait me donner le lien de tes recherches j’irais regarder çà.

Mais je n'en suis pas encore au niveau de la création et de la compréhension totale sur le fonctionnement des timer et autre modes de mesures de fréquences...

Pour le lien je parlais de celui de ton tuto dont tu parle.

Pour les phases d'injection; ce que je voulais dire c'est que sur le vilebrequin il y a 5 encoches qui chacune correspondent a un pmh sur un des 5 cylindres soit les phases d'injection pour le calculateur.

Pour les infos du capteur j'en ai aucune pour le moment (je ne me suis pas pencher sur la question en même temps! )
J'aurais tendance a dire que c'est un analogique avec variation de la tension de sortie.

Merci je vais aller voir çà alors.

Pour mon capteur il et inutilisée (celui d'origine) car en fait c'est un moteur d'audi A6 5 cylindres que j'ai monter dans une dépanneuse lt 35 qui a l'origine avait un 6 cylindre td pas fiable. :expressionless:
Le nouveau moteur a laisser tous son attirail électronique pour être remplacer par une pompe mécanique de ma conception. ]:smiley:

De plus il ne doit pas y avoir besoin de mise en forme du signal car sur un autre moteur identique j'ai monter un arduino pour gérer mon turbo a géométrie variable avec un code du net et çà fonctionne a merveille. Ce sont les même extraits de programme que j'ai tenter d’intégrer dans mon code. Mais il doit y avoir des beug dans ce que j'ai coder car le programme plante.