#include "TimerOne.h" #include //JcapResduino _7_3_2016 Jauge à essence capacitive ou resistive (Arduino) //avec option d'entrée resistive //Voir les commentaires en fin de listing int deb = 0; //si 0, pas de print de debug, voir SETUP pour sa valeur actuelle const int OUT_PIN = A2; const int IN_PIN = A0; //Stray capacitance value will vary from board to board. //Calibrate this value using known capacitor. const float IN_STRAY_CAP_TO_GND = 240;//En gros 220pF + 20 à 30pF de parasite const float IN_CAP_TO_GND = IN_STRAY_CAP_TO_GND; const int MAX_ADC_VALUE = 1023; const int IN_RES = A3;//resistance variable du flotteur sur broche A3 float inCap ;//valeur de la capacité de la jauge en pF int CC;//inCap contraint entre C0 et C4 //************************ //Affichage du cadran // Le PWM a une periode de 2ms. Donc une u = 2000/255 = 78 µs environ const int CADRAN = 3; //D3 pin PWM liée à Timer2, celui ci non utilisé const int TAFF = 1000; //Durée d'affichage en ms, de l'aiguille pour chaque 1/4 au démarrage const int TAIGUILLE = 50;//Si <50,l'aiguille durant l'étalonnage est très "nerveuse" const int LED1 = 5;//les 3 autres Led sont sur D6,7,8 int tcad ;//Période T à afficher au cadran PWM de 0 à 255 int Cap_ou_Res ;// calculé lors de la première DETECTION DE LA JAUGE, A SEC // =0 si jauge capacitive //Capteur resistif de type =1 si le cadran affiche 4/4, jauge deconnectée //Capteur resistif de type =2 si le cadran affiche 0, jauge deconnectée //Pour differents cadrans sur établi //const int C0= 175, C1= 200, C2= 220, C3= 235, C4= 255 ;//Capacité de la jauge en pF //const int T0= 10,T1= 23,T2= 69,T3= 100,T4= 179;// cadran Veglia //Température 40°,60°,80°,100° logique inversée //const int T0= 100,T1= 117,T2= 133,T3= 155,T4= 200;// 12V important! //Cadran Osculatti FUEL(bleu) //const int T0= 50, T1= 93,T2= 123,T3= 157,T4= 230;//A110,affichage des 1/4de reservoir pour chaque 1/4 int C0 = 0, T0 = 0; //T0=0 mais C0 est lue jauge à sec int C1, C2, C3, C4; //valeurs remplies depuis l'EEprom au démarrage,capacités du reservoir 1/4 à 4/4 int T1, T2, T3, T4; //et périodes d'affichage du cadran 1/4 à 4/4 const int BP1 = 11; //Boutons poussoirs avec résistance pullup. const int BP2 = 12; //5V = OFF, 0V=ON const int TCAD_MAX = 250; //Affichage maxi du cadran, en unités PWM int mode = 0; //Pour étalonnage: 1 du cadran, 2 pour le niveau du reservoir int b1 = 0, b2 = 0; //b1 =1 si BP1 a été poussé,b2 =1 si BP2 a été poussé volatile int state = 0; //0 ou 1 pour flash de la Led en cours.Dans une ASR,à protéger int ledC = 0; //Led courante en cours d'étalonnage int capC = 0; //Capacité courante int eepC = 0; // pointeur à l'EEPROM: de 0 à 7 les 4 capas de niveau d'essence(16bits) //de 8à15 les 4 périodes du cadran et en 16/17 CO saisi jauge à sec int tcadC = 0; //Periode courante du cadran en cours d'étalonnage int stoRe = 0; //Valeur sur 16bits à ecrire en EEPROM int fromEep = 0; //Valeur 16b relue de l'EEPROM int hiB = 0; //Lu de l'EEPROM 16 bits int loB = 0; ///Lu de l'EEPROM 8 bits int eW = 0; //pointeur en ecriture à l'EEPROM dans RecopyEeprom() int lByte = 0;//nombre de bytes à lire/ecrire pour l'EEPROM //*********************DEFINITION DES FONCTIONS ***************** void D()/////////////////////////// ///////////DEBUG///while (1){} ///////////////// //Imprime toutes les variables globales { if (deb < 7 )return; { Serial.print("/inCap="); Serial.print(inCap); Serial.print("/CC="); Serial.println(CC); Serial.print("/tcad="); Serial.print(tcad ); Serial.print("/mode="); Serial.println(mode); Serial.print("/b1="); Serial.print(b1); Serial.print("/b2="); Serial.println(b2); Serial.print("/ledC="); Serial.print(ledC); Serial.print("/capC="); Serial.println(capC); Serial.print("/eepC="); Serial.print(eepC); Serial.print("/tcadC="); Serial.println(tcadC); Serial.print("/stoRe="); Serial.print(stoRe); Serial.print("/fromEep="); Serial.println(fromEep); Serial.print("/hiB="); Serial.print(hiB); Serial.print("/loB="); Serial.println(loB); Serial.print("/eW="); Serial.println(eW); //while (1) {} //pour attente infinie } } void _4LedOn()///////while (1){}///////////////////////////////////////////////////// { if (deb >= 5)Serial.println("_4LedOn()"); for (int i = 5; i < 9; i++)digitalWrite(i, 1); } void _4LedOff()//////while (1){}////////////////////////////////////////////////// { if (deb >= 5)Serial.println("_4LedOff()"); for (int i = 5; i < 9; i++)digitalWrite(i, 0); } void Aff4() //////////////////while (1){}/////////////////////////////////////////////// { if (deb >= 5)Serial.println("Aff4()"); //Affiche les 4 quarts au demarrage //A la première utilisation, mettre la jauge au sec, maintenire BP1 pendant //que l'on pousse l'inter RESET de l'Arduino.Relacher RESET puis BP1 //Les 4 Led clignotent, pousser BP1 pour enregistrer C0, capa de la jauge à vide //On fait ensuite l'hypothèse que C4 = C0*4: Nota on parlera toujours de "capa" même pour les //tensions mesurées aux borne de la resistance variable avec le niveau du flotteur //Le logiciel calcul les 4 quarts de niveau d'essence et de cadran de façon linéaire //C'est un réglage de base qui permet un affichage approximatif du niveau. //La procédure d'étalonnage ensuite permettra d'affiner CHAQUE 1/4 de FACON INDEPENDANTE. //soit pour la position de l'aiguille autour du 1/4 soit pour le niveau du reservoir //La première fois que la jauge est connectée au circuit il faut impérativement proceder //à à sa detection, c'est à dire JAUGE A SEC,pousser le RESET de l'Arduino if ((digitalRead(BP2) == 0) )InitC0etR0();//Jauge à sec,si BP2 poussé, enregistrer C0 LecEep();//Lit les 4 capas(reservoir) et les 4T(cadran) en 16bits depuis l'EEPROM,+puis C0 //+ Cap_ou_Res PrintEeprom16(); Serial.println("C 1 - 4 "); Serial.println(C1); Serial.println(C2); Serial.println(C3); Serial.println(C4); Serial.println(); Serial.println("T 1 - 4 "); Serial.println(T1); Serial.println(T2); Serial.println(T3); Serial.println(T4); Serial.println(); Serial.print("Capteur a vide C0 = "); Serial.println(C0); Serial.println(); Serial.print("Cap_ou_Res_ = "); Serial.println(Cap_ou_Res); Serial.println("0 pour capteur capacitif"); Serial.println("1 pour capteur resistif de type =1 : le cadran affiche 4/4, capteur deconnecte"); Serial.println("2 pour capteur resistif de type =2 : le cadran affiche 0, capteur deconnecte"); Serial.println(); //Affiche les 4 quarts au cadran au demarrage analogWrite (CADRAN, T0); _4LedOff(); delay(TAFF); analogWrite (CADRAN, T1); digitalWrite(LED1, 1); //Et aussi les Led delay(TAFF); digitalWrite(LED1, 0); analogWrite (CADRAN, T2); digitalWrite(LED1 + 1, 1); delay(TAFF); digitalWrite(LED1 + 1, 0); analogWrite (CADRAN, T3); digitalWrite(LED1 + 2, 1); delay(TAFF); digitalWrite(LED1 + 2, 0); analogWrite (CADRAN, T4); digitalWrite(LED1 + 3, 1); delay(TAFF); digitalWrite(LED1 + 3, 0); } void AfficTcad()/////////while (1){}////////////////////////////////////////////// { if (deb >= 5)Serial.println("AfficTcad()"); Serial.print("Ligne_"); Serial.print(__LINE__); Serial.print(" Periode du cadran 0-255: tcad = "); Serial.println(tcad); Serial.println(); analogWrite (CADRAN, tcad); } void CalculC_et_T_lineaire() //////while (1){}/////////////////////////////////// { if (deb >= 5)Serial.println("CalculC_et_T_lineaire()"); Serial.println("CalculC_et_T_lineaire"); //Exécutée seulement avec jauge à sec ou noyée eepC = 16; ReadEep16(); C0 = fromEep; //recupérer C0 puis C4 eepC = 6; ReadEep16(); C4 = fromEep; if (C4 <= C0)return; //C0 ou C4 non valable, pas de calcul linéaire float del = (float)(C4 - C0) / 4.0 ; //4fois 1/4 egaux C1 = C0 + del; // premier 1/4 eepC = 0; stoRe = C1; WriteEep16(); //ecrit C1 en EEprom 0,1 C2 = C1 + del; //2/4 stoRe = C2; WriteEep16(); //ecrit C2 en EEprom 2,3 C3 = C2 + del; //3/4 stoRe = C3; WriteEep16(); //ecrit C3 en EEprom 4,5 // C4 est déjà là, en EEpron 6,7 //Maintenant on remplit les 4 positions d'aiguille pifométrées eepC = 8; stoRe = 100; WriteEep16(); // stoRe = 150; WriteEep16(); stoRe = 192; WriteEep16(); stoRe = 255; WriteEep16(); } void CalculTcad()/////////////////////////////////while (1){}/////////////////////////// { if (deb >= 5)Serial.println("CalculTcad()"); _4LedOff();// 4 Leds OFF, on va les rafraichir, mais L4 jamais ON CC = constrain(CC, C0, C4); //Make sure C is in between Serial.print("Ligne_"); Serial.print(__LINE__); Serial.print(" CC constrained = "); Serial.print(CC); Serial.println(" pF"); if (CC <= C1) { tcad = (float)((( CC - C0) * (T1 - T0) / (C1 - C0) + T0)); //No Led ON, aiguille < 1/4 return; } if (CC <= C2) { tcad = (float)((( CC - C1) * (T2 - T1) / (C2 - C1) + T1)); digitalWrite(LED1, 1);//Led 1 ON aiguille entre 1/4 et 2/4 return; } if (CC <= C3) { tcad = (float)((( CC - C2) * (T3 - T2) / (C3 - C2) + T2)); digitalWrite(LED1 + 1, 1);//Led 2 ON aiguille entre 2/4 et 3/4 return; } // Donc CC entre C3 et C4 tcad = (float)((( CC - C3) * (T4 - T3) / (C4 - C3) + T3)); digitalWrite(LED1 + 2, 1);//Led 3 ON aiguille entre 3/4 et 4/4 if(CC == C4){ digitalWrite(LED1 + 2, 0);digitalWrite(LED1 + 3, 1);}//Led 3 OFF, Led 4 ON aiguille sur 4/4 } void EepDump()////////while (1){}////////////////////////////////////////////// { //Pour les essais de lecture de 16 bits de l'EEPROM, ajuster eepC à l'adresse du HiByte eepC = 0; ReadEep16(); delay(100); Serial.print("fromEep__"); Serial.println(fromEep); while (1) {} LecEep(); Serial.print(T1); Serial.print(T2); Serial.print(T3); Serial.println(T4); } void Etalon()///while (1){}//////////////////////////////////////////////////// { if (deb > 0) { Serial.println("Etalon"); D(); } //si BP1, circuler dans les Leds,si BP2, confirmer Led capC = 0; tcadC = 0; tcad = 0; _4LedOff(); analogWrite (CADRAN, tcad); delay(1000); //et cadran à 0 digitalWrite(ledC, 1); //Allumer la Led courante delay(1000); while (1) { //sortie de cette boucle par 3 goto pour avoir un seul return LectBp();//Serial.print(b1);Serial.println(b2); delay(100);// a tt hasard if (b1 == 1) { eepC = eepC + 2; // goto sortie; }// BP1 traiter la prochaine Ledreturn;} if (b2 == 1) //après mise à jour du pointeur EEP { interrupts();// c'est BP2 pour traiter cette Led :flasher la Led courante delay(1000); if (mode == 1) { GetTcadC(); goto sortie; } //Mode 1.Obtenir puis enregitrer la période courante en EEP { GetCapC(); goto sortie; } // Mode=2.Obtenir puis enregitrer la capa courante en EEP } } sortie: //Fin de l'étalonnage d'une Led noInterrupts(); //Pas de flash digitalWrite (ledC, 0); //eteindre Led courante ledC ++; //prochaine Led (circuler entre D5 et D8) delay(2000); //à tt hasard return; } void Flash_isr() //while (1){}//////////////////////////////////////////////////// { if (deb >= 5)Serial.println("Flash_isr()"); state = !state; //Toggle. Cette fonction est executée //par interruption de Timer1 digitalWrite(ledC, state); //Led Courante } void GetC0_or_R0()//while (1);//////////////////////////////////////////////////// //Premier etalonnage, jauge à sec si capacitive, flotteur pendant si résistive { if (deb >= 5)Serial.println("GetC0_or_CR0()"); Cap_ou_Res = 0; //Assume capteur capacitif LectBp(); //attendre relachement de BP2 poussé au demarrage (avec RESET) while (digitalRead(BP2) == 1) { //tant que BP2 off _4LedOn(); delay(200); _4LedOff(); delay(200); } _4LedOff(); //BP2 poussé for (int i = 1; i < 3; i++)LireIncap(); //calcul CC, la capacité Serial.print("Ligne_"); Serial.println(__LINE__); Serial.print("CC dans GetC0_or_R0() = "); Serial.println(CC); delay(5000);//while (1); if (CC <= 50) //Pas de jauge capacitive connectée, donc resistive (avec 47pF connectés on lit CC=59pF) { Cap_ou_Res = 1; //Assume jauge type Alpine 1300,cadran au maxi capteur deconnecté for (int i = 1; i < 3; i++)CC = analogRead(IN_RES); //calcul CC, la resistance if (CC >= 512) { Cap_ou_Res = 2; //Type 1600,cadran à 0 capteur deconnecté CC = 1023 - CC; } } stoRe = CC; eepC = 16; WriteEep16(); //mettre C0 en EEPROM 16/17 stoRe = Cap_ou_Res; WriteEep16(); //mettre 0 ou 1ou 2 en EEPROM 18/19 if (Cap_ou_Res == 0)stoRe = CC * 2; //Assume C4 = 2*C0 c'est une estimation, on corrigera C4 lors de l'étalonnage des 4 1/4 else stoRe = 800; //Assume Rgrande pour niveau haut, jauge de type 1, soit V=800u, 4V en entrée. eepC = 6; WriteEep16(); //mettre C4 en EEPROM 6/7 } void GetCapC()//while (1){}//////////////////////////////////////////////////// { if (deb >= 5)Serial.println("GetCapC()"); while (1) //Boucle infini, ne sort que par BP2 { delay(500); LectBp(); if (b2 == 1) { if (Cap_ou_Res == 0)LireIncap(); //capa du niveau actuel du reservoir else LireInres();//Capteur resistif stoRe = CC; // preparer à stocker en EEPROM WriteEep16() ; //sauver période et sortir LectBp(); while (b2 == 1)LectBp(); //Attendre BP2 relevé delay(1000); return; } } } void GetTcadC()//while (1){}//////////////////////////////////////////////////// { if (deb >= 5)Serial.println("GetTcadC()"); tcadC = 0; analogWrite (CADRAN, T0); //Aiguille à zero while (1) //Boucle infini, ne sort que par BP2 { if (digitalRead(BP2) == 0) //BP2 ON, pour enregistrer { stoRe = tcadC; //La période actuelle va aller en EEPROM WriteEep16() ; delay(1000); // pour anti rebond while (digitalRead(BP2) == 0)delay(100); delay(1000); return; //sauver période et sortir } while (digitalRead(BP1) == 0) //BP1 pour tirer aiguille à droite { Serial.println("Aig++"); tcadC++; //BP1 tire l'aiguille du cadran vers la droite if (tcadC >= TCAD_MAX)tcadC = 0; //Trop à droite, retour à 0 tcad = tcadC; analogWrite (CADRAN, tcad); //pas trop vite la montée de l'aiguille delay(TAIGUILLE); //Afficher le cadran et boucler tant que BP1 appuyé } //Augmenter TAIGUILLE pour une montée plus lente } } void InitC0etR0()//while (1){}//////////////////////////////////////////////////// { if (deb >= 5)Serial.println("InitC0ouC4()()"); Serial.println("InitC0etR0()");//Executée uniquement avec jauge à sec GetC0_or_R0(); //Ecrire en EEP C0(jauge à sec) CalculC_et_T_lineaire(); //Initialise Jcap entre C0,T=0 et C4,T4 , linéairement } void LectBp()//while (1){}//////////////////////////////////////////////////// { //if (deb >= 5)Serial.println("LectBp()"); b1 = 0; b2 = 0; //1 si BP poussé if ((digitalRead(BP1) == 1) && (digitalRead(BP2) == 1))goto sor; //aucun poussé if (digitalRead(BP1) == 0 ) //C'est BP1 qui est poussé { while (digitalRead(BP1) == 0) delay(300); //attendre delay(300); //100ms //BP1 relaché, anti rebond while (digitalRead(BP1) == 0)delay(300); //BP1 encore poussé, attendre b1 = 1; //BP1 enfin relaché delay(100); goto sor; } while (digitalRead(BP2) == 0)delay(300); //Pas BP1 donc c'était BP2 poussé, attendre delay(300); //100ms //BP2 relaché, anti rebond while (digitalRead(BP2) == 0) delay(300);//BP2 encore poussé, attendre delay(300); b2 = 1; //BP2 enfin relaché sor: return; } void LecEep()//while (1){}//////////////////////////////////////////////////// { if (deb >= 5)Serial.println("LecEep()"); eepC = 0; //pointeur à l'EEprom, on lit de 0 à 15 soit 8 valeurs de 16 bits ReadEep16(); C1 = fromEep; ReadEep16(); C2 = fromEep; ReadEep16(); C3 = fromEep; ReadEep16(); C4 = fromEep; ReadEep16(); T1 = fromEep; ReadEep16(); T2 = fromEep; ReadEep16(); T3 = fromEep; ReadEep16(); T4 = fromEep; ReadEep16(); C0 = fromEep; //En 16 et 17 ReadEep16(); Cap_ou_Res = fromEep; //En 18 et 19, 0 ou 1 ou 2 } void LireIncap()//while (1){}//////////////////////////////////////////////////// //Fait la moyenne des nech capas lues et calcul int CC { if (deb >= 5)Serial.println("LireIncap()"); int nech = 100; //Nb d'echantillon à moyenner long int acc = 0; //accumulation des echantillons for (int i = 1; i <= nech; i++) { //Capacitor under test between OUT_PIN and IN_PIN //Rising high edge on OUT_PIN pinMode(IN_PIN, INPUT);//Ici se retrouvent la capa C et la capa parasite de la broche digitalWrite(OUT_PIN, HIGH);//Charge la capa C (et la capa parasite,+capa220pF) en série. int val = analogRead(IN_PIN);// Lecture de l' ADC : V capa parasite/masse+capa 220pF digitalWrite(OUT_PIN, LOW);// première decharge // delay(10); //Clear everything for next measurement pinMode(IN_PIN, OUTPUT);//deuxiéme decharge // delay(10); //Calculate and print result inCap = (float)val * IN_CAP_TO_GND / (float)(MAX_ADC_VALUE - val); acc = acc + inCap; //cumul delay(10);//tous les 10ms } inCap = (float)acc / (float)nech; //moyenne sur nech #if defined DEBUG Serial.print(F("Capacitance Value = "));//F pour string en Flash Serial.print(inCap, 3); Serial.print(F(" pF (")); Serial.print(inCap); Serial.println(F(") ")); while (millis() % 1000 != 0); #endif CC = (int)inCap; Serial.print("Ligne_"); Serial.print(__LINE__); Serial.print(" Brut inCap = CC en pF "); Serial.print(CC); Serial.println(" pF"); } void LireInres()//while (1){}//////////////////////////////////////////////////// //Fait la moyenne des nech tension sur la resistnce lues et calcul int CC { if (deb >= 5)Serial.println("LireInres()"); int nech = 100; //Nb d'echantillon à moyenner long int acc = 0; //accumulation des echantillons for (int i = 1; i <= nech; i++) { inCap = analogRead(IN_RES);// Lecture de l' ADC : V resistance, on garde inCap acc = acc + inCap; //cumul delay(10);//tous les 10ms } inCap = (float)acc / (float)nech; //moyenne sur nech #if defined DEBUG Serial.print(F("V resistance = "));//F pour string en Flash Serial.println(inCap, 3); while (millis() % 1000 != 0); #endif CC = (int)inCap;//En fait c'est V resistance if ( Cap_ou_Res == 2)CC = 1023 - CC; //Corriger CC pour type 2 Serial.print("Ligne_"); Serial.print(__LINE__); Serial.print(" Vin (0-1023, corrigé si type 2) = CC = "); Serial.println(CC); } void ModeEtalonnage()//while (1){}//////////////////////////////////////////////////// //////Deux modes: cadran ou reservoir////// { if (deb > 0) { Serial.println("ModeEtalonnage"); D(); } mode = 1; //Assume mode saisie des périodes du cadran LectBp();//Serial.println(b1);Serial.println(b2);Serial.println(b1&&b2); if ((b1 == 0) && (b2 == 0))return; //pas d'étalonnage demandé (par BP) if (b2 == 1)mode = 2; //c'est la saisie du niveau donc des capacités, ajuster mode Timer1.initialize(1000000); //Toutes les secondes génére IT pour isr_Flash Timer1.attachInterrupt(Flash_isr); //On toggle la Led en cours. noInterrupts(); //Fin du flash while (1) { ledC = LED1; //première Led en D5 les autres en 6,7 et 8 eepC = 0; //en début d'EEPROM, pointe aux 4 capacités if (mode == 1)eepC = 8; //saisie du cadran, pointer aux T enregistrées for ( int i = 1; i <= 4; i++) { delay(1000); Etalon(); //Etalonner les 4 Leds } } } void PrintEeprom16()//while (1){}//////////////////////////////////////////////////// { if (deb >= 5)Serial.println("PrintEeprom16()"); eepC = 0; Serial.println( "EEPROM de 0 a 19"); while (eepC < 19) { ReadEep16(); //les 4 C, les 4T, C0, Cap_ou_Res Serial.println( fromEep); } Serial.println(); // eepC=100; //while (eepC <118){ReadEep16();Serial.println( fromEep);} } void RazEeprom(int ad1, int nB) //while (1){}///////////////////////////// //A partir de l'adresse ad1, on met à 0 nB bytes { for (int i = 0; i < nB; i++) EEPROM.write(ad1 + i, 0); } void ReadEep16()//while (1){}//////////////////////////////////////////////////// { if (deb >= 5)Serial.println("PrintEeprom16()"); hiB = EEPROM.read(eepC);// Serial.print("hiB__");Serial.println(hiB); eepC++; loB = EEPROM.read(eepC);//Serial.print("loB__");Serial.println(loB); eepC++; //preparer prochaine adresse fromEep = (hiB << 8) + loB; } void RecopyEeprom(int ad1, int ad2, int lB)///while(1){}//////////// //Copier lB bytes de l'adresse ad1 à l'adresse ad2. ad2=0,6 pour suivre chaque fonction, //7 pour lister toutes les var globales Serial.begin(9600); Serial.println(__FILE__); Serial.print(__DATE__); Serial.println(__TIME__); //Mesure de la capacité de la jauge pinMode(OUT_PIN, OUTPUT); pinMode(IN_PIN, OUTPUT); //les deux BP pinMode(BP1, INPUT_PULLUP); //5V si BP off, 0V si BP on pinMode(BP2, INPUT_PULLUP); //les 4 Led pinMode (LED1, OUTPUT); pinMode (LED1 + 1, OUTPUT); pinMode (LED1 + 2, OUTPUT); pinMode (LED1 + 3, OUTPUT); //Affichage du cadran pinMode(CADRAN, OUTPUT); //Sortie PWM // RestoreEtalonnage(); //Seulement si on a rempli les valeurs C,T dans cette fonction Aff4(); //Affiche les 4X1/4 du cadran au demarrage //et possibilité de premier etalonnage, jauge à sec Serial.print("Ligne_"); Serial.print(__LINE__); Serial.print(digitalRead(BP1)); Serial.println(digitalRead(BP1)); } //*********************************************************************** ///////////////////////LOOP//////////while (1);////////////////////////// //*********************************************************************** void loop() //On reste ici pour lire et afficher { ModeEtalonnage(); //Voir si un BP a été poussé if (Cap_ou_Res != 0)LireInres(); //Capteur resistif else LireIncap(); // Mesure la capa de la jauge en pF CalculTcad();// Interpolle pour calculer Tcad, 0 à 255 AfficTcad(); //PWM Tcad } ////////DEBUGGING//////////////////////// //Pour sauver les valeurs en EEPROM, voir à la fin de SetUp() // Breakpoint du pauvre, activé selon deb=0 ou non,kk recepteur du car lu(et ignoré) //if(deb!=0) //{ Serial.print("Ligne_");Serial.print(__LINE__);while (Serial.available()==0);int kk = Serial.read();} //Serial.print("Ligne_");Serial.print(__LINE__); //La macro __LINE__donne le N° de ligne. //Pour continuer, dans le haut de l'ecran COM3, entrer un car puis Return //Une autre possibilité est de générer ou non du code de debug à la compilation. //#define DEBUG // #if defined DEBUG #endif ////////////////////////////////////////////////// #define DEBUG //imprime la valeur de la capa avant constrain()ie >C0,