je me lance, je poste aussi le code de la nano émetteur ( deux nano pour des problème de place et d'implantation dans l'avion).
/*************************** RTC *************************/
// SCL = A4
// SDA = A5
/************************ Débimètre **********************/
// impulsions = 2
/********************** jauge essence ********************/
// essence = A0
/*********************************************************/
#include <Wire.h>
#include <RTClib.h>
#include <EEPROM.h>
RTC_DS3231 rtc;
int Heure, Minute, Seconde;
DateTime startTime;
unsigned long lastUpdate = 0; // Temps du dernier rafraîchissement du temps écoulé
const int CapteurNiveauCarburant = A0; // Broche analogique à laquelle est connecté le capteur de niveau de carburant
unsigned long pinImpulsions = 2; // pin 2 pour Débimetre
int buttonState = 0; // bouton RAZ
volatile unsigned impulsions = 0; // variable pour les interuption du débimetre
unsigned int impulsionsParLitre; // nombres d'inpulsions par litre
// Avec buse (803) 1mm = 0.05-0.5 L/mn K= 17000
// Avec buse (815) 2mm = 0.12-1.5 L/mn K= 7000
// Avec buse (845) 3mm = 0.20-4.5 L/mn K= 3500
// Avec buse (865) 4mm = 0.25-6.5 L/mn K= 2100
// Sans buse (810) = 0.30-10 L/mn K= 1330
float totalLitres = 0.0; // Consomation sur la durée du vol
float litresParHeure = 0.0; // nombre de litres par heure
unsigned long previousMillis = 0; // pour le calcul du temps du nombre de L/H
const long interval = 1000; // Une mesure par seconde
int Tvolheures, Tvolminutes; // Temps de vol par Heures et par Minutes
float NiveauCarburant; // Niveau du carburant dans le reservoir
int An , Mo, Jo, He, Mi, Se, DoW, Co, AuraTM, AuraTH, Hrest, Mrest ;
int Coe;
// float oldLh, oldconso, oldtank, oldhRest, oldTvolM; // pour savoir si il y a changement pour l'affichage
/*************** Déclarations HC-05 BT ************************/
#include <SoftwareSerial.h>
SoftwareSerial bluetooth(5, 6); // ouverture des ports RX et TX pour le module Bluetooth HC-05
/************** atache interrupt *****************************/
void isr() { // pour Détection des inpulsions du débimètre
impulsions++;
}
void setup() {
Serial.begin(9600);
/********************** serial Bluetooth ***********************/
bluetooth.begin(9600);
/**************************** RTC ******************************/
if (!rtc.begin()) {
// Serial.println("Could not find RTC");
while (1);
}
startTime = rtc.now(); // Enregistrer le moment où le chronomètre démarre
lastUpdate = millis(); // Enregistrer le moment de démarrage du chronomètre
/********************* Pin Capteurs ******************************/
pinMode(CapteurNiveauCarburant, INPUT); // Définir la broche du capteur comme une entrée
pinMode(pinImpulsions, INPUT_PULLUP); // INPUT_PULLUP
attachInterrupt(digitalPinToInterrupt(pinImpulsions), isr, RISING); // FALLING High.Low - RISING Low-High _ CHANGE les deux
/*********************** lecture EEprom ************************/
EEPROM.get(0, totalLitres);
EEPROM.get(10, NiveauCarburant);
EEPROM.get(20, impulsionsParLitre);
///////////////// faire Affichage momentanée de la conso //////////////
raz();
}
void loop() {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
// impulsions = impulsions / 60; // pour débug: ATTENTION a retirer
totalLitres += impulsions / (float)impulsionsParLitre;
litresParHeure = (impulsions / (float)impulsionsParLitre) * 3600.0;
impulsions = 0; // Remettre impulsions à zéro
previousMillis = currentMillis;
}
if (litresParHeure <= 0) { // mise en eeprom si moteur coupé
EEPROM.put(0, totalLitres);
EEPROM.put(10, NiveauCarburant);
}
if (litresParHeure > 0) { // démarre l'horatime si moteur en marche
HoraTime();
}
RTC();
HoraTime();
calculNiveauReservoir();
calculTempsRestant();
/******************************************** Réception Android ************************************/
while (bluetooth.available()) {
String annee = bluetooth.readStringUntil(','); // prend la valeur "année' (type chaine de charactères), en provenance du module bluetooth // affichage pour débug
String mois = bluetooth.readStringUntil(','); // prend la valeur "mois' (type chaine de charactères), en provenance du module bluetooth
String jour = bluetooth.readStringUntil(','); // prend la valeur "jour' (type chaine de charactères), en provenance du module bluetooth
String heure = bluetooth.readStringUntil(','); // prend la valeur "heure' (type chaine de charactères), en provenance du module bluetooth
String Minute = bluetooth.readStringUntil(','); // prend la valeur "minute' (type chaine de charactères), en provenance du module bluetooth
String seconde = bluetooth.readStringUntil(','); // prend la valeur "seconde' (type chaine de charactères), en provenance du module bluetooth
String coef = bluetooth.readStringUntil('f'); // prend la valeur "coef' (type chaine de charactères), en provenance du module bluetooth
int Ann = annee.toInt(); // transforme la valeur chaine de charactères, en valeur numérique
int Moi = mois.toInt();
int Jou = jour.toInt();
int Heu = heure.toInt();
int Min = Minute.toInt();
int Sec = seconde.toInt();
Coe = coef.toInt();
rtc.adjust(DateTime(Ann, Moi, Jou, Heu, Min, Sec)); // envoi de la mise à l'heure de la RTC
if ( Coe != 0 ) {
impulsionsParLitre = Coe;
EEPROM.put(20, impulsionsParLitre);
}
}
/******************************************** Envoie vers NANO Récepteur ************************************/
Serial.write((byte*)&An, sizeof(An)); // Envoie le 1er nombre
Serial.write((byte*)&Mo, sizeof(Mo)); // Envoie le 2em nombre
Serial.write((byte*)&Jo, sizeof(Jo)); // Envoie le 3em nombre
Serial.write((byte*)&He, sizeof(He)); // Envoie le 4em nombre
Serial.write((byte*)&Mi, sizeof(Mi)); // Envoie le 5em nombre
Serial.write((byte*)&Se, sizeof(Se)); // Envoie le 6em nombre
// Serial.write((byte*)&DoW, sizeof(DoW)); // Envoie le 7em nombre
Serial.write((byte*)&impulsionsParLitre, sizeof(impulsionsParLitre)); // Envoie le 8em nombre
Serial.write((byte*)&AuraTH, sizeof(AuraTH)); // Envoie le 9em nombre
Serial.write((byte*)&AuraTM, sizeof(AuraTM)); // Envoie le 10em nombre
Serial.write((byte*)&Hrest, sizeof(Hrest)); // Envoie le 11em nombre
Serial.write((byte*)&Mrest, sizeof(Mrest)); // Envoie le 12em nombre
Serial.write((byte*)&NiveauCarburant, sizeof(NiveauCarburant)); // Envoie le 13em nombre
Serial.write((byte*)&litresParHeure, sizeof(litresParHeure)); // Envoie le 14em nombre
Serial.write((byte*)&totalLitres, sizeof(totalLitres)); // Envoie le 15em nombre
delay(1000); // Attente d'une seconde avant d'envoyer les prochaines données
}
/************************************ Date et Heure RTC ************************************/
void RTC() {
DateTime now = rtc.now();
An = now.year();
Mo = now.month();
Jo = now.day();
DoW = now.dayOfTheWeek();
He = now.hour();
Mi = now.minute();
Se = now.second();
}
/******************************************** HoraTime ************************************/
void HoraTime() {
DateTime now = rtc.now();
// Calculer le temps écoulé depuis le démarrage du chronomètre
TimeSpan elapsedTime = now - startTime;
unsigned long currentTime = millis();
if (currentTime - lastUpdate >= 1000) { // Mettre à jour toutes les secondes
lastUpdate = currentTime;
// Calculer le temps écoulé en heures, minutes et secondes
uint8_t heures = elapsedTime.hours();
uint8_t minutes = elapsedTime.minutes();
// uint8_t secondes = elapsedTime.seconds();
AuraTM = minutes;
AuraTH = heures;
}
}
/******************************* calcul du Niveau dans le Reservoir ************************/
void calculNiveauReservoir() {
int somme = 0;
for (int i = 0; i < 10; i++) {
somme += analogRead(CapteurNiveauCarburant); //somme des valeurs
}
int lectureCapteur = somme / 10.0; // valeur moyenne
if (lectureCapteur >= 0 && lectureCapteur < 93 ) // 0 -- 5 L
{
NiveauCarburant = map(lectureCapteur, 0, 93, 0, 50);
}
else if (lectureCapteur >= 93 && lectureCapteur < 186 ) // 5 __10 L
{
NiveauCarburant = map(lectureCapteur, 93, 186, 50, 100);
}
else if (lectureCapteur >= 186 && lectureCapteur < 279 ) // 10 -- 15 L
{
NiveauCarburant = map(lectureCapteur, 186, 279, 100, 150);
}
else if (lectureCapteur >= 279 && lectureCapteur < 372 ) // 15 -- 20 L
{
NiveauCarburant = map(lectureCapteur, 279, 372, 150, 200);
}
else if (lectureCapteur >= 372 && lectureCapteur < 465 ) // 20 -- 25 L
{
NiveauCarburant = map(lectureCapteur, 372, 465, 200, 250);
}
else if (lectureCapteur >= 465 && lectureCapteur <= 558 ) // 25 -- 30 L
{
NiveauCarburant = map(lectureCapteur, 465, 558, 250, 300);
}
else if (lectureCapteur >= 558 && lectureCapteur <= 651 ) // 30 -- 35 L
{
NiveauCarburant = map(lectureCapteur, 558, 651, 300, 350);
}
else if (lectureCapteur >= 651 && lectureCapteur <= 744 ) // 35 -- 40 L
{
NiveauCarburant = map(lectureCapteur, 651, 744, 350, 400);
}
else if (lectureCapteur >= 744 && lectureCapteur <= 837 ) // 40 -- 45 L
{
NiveauCarburant = map(lectureCapteur, 744, 837, 400, 450);
}
else if (lectureCapteur >= 837 && lectureCapteur <= 930 ) // 45 -- 50 L
{
NiveauCarburant = map(lectureCapteur, 837, 930, 450, 500);
}
else if (lectureCapteur >= 930 && lectureCapteur <= 1023 ) // 50 -- 55 L
{
NiveauCarburant = map(lectureCapteur, 930, 1023, 500, 550);
}
NiveauCarburant = NiveauCarburant / 10;
}
/*************************** temps de vol restant *****************************/
void calculTempsRestant() { // temps de vol restant
calculNiveauReservoir();
// float capaciteRestante = NiveauCarburant - totalLitres; // Calculer la capacité restante
float tempsRestantEnMinutes = NiveauCarburant / litresParHeure * 60; // Calculer le temps restant en minutes
Hrest = (int)(tempsRestantEnMinutes / 60); // Calculer les heures
Mrest = (int)(tempsRestantEnMinutes) % 60; // Calculer les minutes
if (Mrest > 59) {
Hrest += 1; // Si les minutes dépassent 60, ajouter une heure
Hrest -= 59; // Soustraire 59 minutes aux minutes puisque on a rajouté une heure aux heures
}
}
void raz() { // remise a 0 de l'eeprom
totalLitres = 0.0;
NiveauCarburant = 0;
// totalImpulsions = 0;
// litresParHeure = 0.0;
EEPROM.put(0, totalLitres);
EEPROM.put(10, NiveauCarburant);
delay(300);
}