Bonjour.
je sèche complètement depuis plusieurs jour sur un problème. je tente de faire un menu pour un affichage sur un écran rond 1,28" bibliothèque "Adafruit_GC9A01A.h". deux arduino nano, un RTC 3231, un R05 pour infos venant d'un android, un capteur de débit, une jauge essence. deux boutons poussoirs, boutton1 pour choisir un menu ( a chaque appuie on change de menu, comme montrée sur le code test menu) et boutton2 pour un chrono.(appui court pour, start et stop, appui long pour, raz)
c'est un montage pour afficher des données de consommation de carburant sur un ulm, ce n'est pas un montage intrusif, donc pas de problème pour la sécurité.
j'ai fais plusieurs codes pour tester chaque éléments et ça fonctionne bien (même si ce n'ai pas très bien codé) mais dès que j’essaie de les rassembler sur un seul code, la fonction menu ne marche pas.
je ne sais pas si je peut poster tout les codes, ca fait long de code.
je vais poster le test du code "menu" qui fonctionne a vide et le code "chrono" dites moi si je peut poster les autre pour plus de compréhension.
ps: menu principal "data débimetre" , menu " date et heure", menu "chrono"
voici le code test "menu"
#include <Adafruit_GFX.h>
#include <Adafruit_GC9A01A.h>
#define BUTTON_PIN 2 // Pin pour le bouton (interrupteur)
#define TFT_DC 9
#define TFT_CS 10
Adafruit_GC9A01A tft(TFT_CS, TFT_DC);
#define BLACK 0x0000
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#define Maroon 0x7800
#include <Fonts/FreeSansBold12pt7b.h>
volatile bool buttonPressed = false;
volatile unsigned long lastDebounceTime = 0;
volatile unsigned long debounceDelay = 50;
enum Menu {
MAIN_MENU,
CLOCK_MENU,
TIMER_MENU
};
Menu currentMenu = MAIN_MENU;
void setup() {
Serial.begin(9600);
tft.begin();
tft.fillScreen(BLACK);
tft.setFont(&FreeSansBold12pt7b);
pinMode(BUTTON_PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), buttonInterrupt, FALLING);
drawMainMenu();
}
void loop() {
if (buttonPressed) {
switch (currentMenu) {
case MAIN_MENU:
currentMenu = CLOCK_MENU;
drawClockMenu();
break;
case CLOCK_MENU:
currentMenu = TIMER_MENU;
drawTimerMenu();
break;
case TIMER_MENU:
currentMenu = MAIN_MENU;
drawMainMenu();
break;
}
buttonPressed = false;
}
}
void drawMainMenu() {
tft.fillScreen(BLACK);
tft.setCursor(30, 100);
tft.setTextColor(YELLOW); // Texte noir
tft.println("Menu Principal");
}
void drawClockMenu() {
tft.fillScreen(BLACK);
tft.setCursor(30, 120);
tft.setTextColor(CYAN); // Texte noir
tft.println("Menu Horloge");
}
void drawTimerMenu() {
tft.fillScreen(BLACK);
tft.setCursor(30, 140);
tft.setTextColor(GREEN); // Texte noir
tft.println("Menu Chrono");
}
void buttonInterrupt() {
if (millis() - lastDebounceTime > debounceDelay) {
buttonPressed = true;
}
lastDebounceTime = millis();
}
le code test " chrono"
#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_GC9A01A.h"
#include <Wire.h>
///////////////////////// ECRAN ROND 1,28 " //////////////////
#define BLACK 0x0000
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define CYAN 0xFFE0
#define WHITE 0xFFFF
#define Maroon 0x7800
#define TFT_DC 9
#define TFT_CS 10
Adafruit_GC9A01A tft(TFT_CS, TFT_DC);
#include <Fonts/FreeSansBold9pt7b.h>
#include <Fonts/FreeSansBold12pt7b.h>
#include <Fonts/FreeSansBold18pt7b.h>
#include <Fonts/FreeSansBold24pt7b.h>
int oldSec, oldMi, T;
#include <OneButton.h>
const int boutonPin = 2; // Broche du bouton
unsigned long tempsDebut = 0; // Stocke le temps auquel le chronomètre est démarré
unsigned long tempsPasse = 0; // Stocke le temps écoulé depuis le démarrage du chronomètre
bool chronometreEnMarche = false; // Indique si le chronomètre est en cours d'exécution
OneButton bouton(boutonPin, true); // Créez un objet OneButton en spécifiant la broche du bouton et si elle est en mode pull-up
void setup() {
Serial.begin(9600); // Initialise la communication série
////////////////// TFT ////////////////////
tft.begin();
tft.fillScreen(GC9A01A_BLACK);
bouton.attachClick(toggleChronometre); // Attachez la fonction toggleChronometre() à l'événement de clic sur le bouton
bouton.attachLongPressStart(startResetChronometre); // Attachez la fonction startResetChronometre() à l'événement de début d'appui long sur le bouton
bouton.attachDuringLongPress(resetChronometre); // Attachez la fonction resetChronometre() à l'événement de maintien d'appui long sur le bouton
}
void loop() {
bouton.tick(); // Appel de la méthode tick() de la bibliothèque OneButton dans la boucle loop()
if (T == 0) {
tft.setTextSize(8);
tft.setCursor(65, 90);
tft.print(00);
tft.setCursor(15, 90);
tft.print(00);
tft.setCursor(180, 90);
tft.print(00);
tft.setCursor(130, 90);
tft.print(00);
tft.setCursor(96, 104);
tft.print(":");
T = 1;
}
if (chronometreEnMarche) {
unsigned long tempsActuel = millis();
tempsPasse = tempsActuel - tempsDebut;
}
afficherTemps(tempsPasse);
delay(10); // Légère pause pour la stabilité
}
void toggleChronometre() {
if (chronometreEnMarche) { // Si le chronomètre est en marche, arrêtez-le
tempsPasse = millis() - tempsDebut;
chronometreEnMarche = false;
} else { // Sinon, démarrez ou redémarrez le chronomètre
tempsDebut = millis() - tempsPasse;
chronometreEnMarche = true;
}
}
void startResetChronometre() {
// Si l'appui long débute alors que le chronomètre est arrêté, remettez-le à zéro
if (!chronometreEnMarche) {
resetChronometre();
}
}
void resetChronometre() {
// Réinitialise le chronomètre en remettant à zéro les variables
tempsDebut = 0;
tempsPasse = 0;
chronometreEnMarche = false;
Serial.println("Chronomètre réinitialisé !");
}
void afficherTemps(unsigned long temps) {
unsigned long secondes = temps / 1000;
unsigned long minutes = secondes / 60;
secondes %= 60;
tft.setTextSize(8);
tft.setTextColor(WHITE);
if (oldMi != minutes) {
tft.fillRect(5, 78, 120, 86, tft.color565(0, 0, 0)); // carré pour effacer les minutes
tft.setCursor(65, 90);
tft.print(minutes % 10, DEC);
tft.setCursor(15, 90);
tft.print(minutes / 10, DEC);
oldMi = minutes;
}
if (oldSec != secondes) {
tft.fillRect(116, 78, 120, 86, tft.color565(0, 0, 0)); // carré pour effacer les secondes
// tft.fillRect(98, 90, 6, 22, tft.color565(0, 0, 0)); // // carré pour effacer les : des minutes
tft.setCursor(180, 90);
tft.print(secondes % 10, DEC);
tft.setCursor(130, 90);
tft.print(secondes / 10, DEC);
tft.setCursor(96, 104);
tft.print(":");
oldSec = secondes;
}
}
voici le menu test "Heure et date"
#include "Adafruit_GFX.h"
#include "Adafruit_GC9A01A.h"
#include <Wire.h>
///////////////////////// ECRAN ROND 1,28 " //////////////////
#define BLACK 0x0000
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#define Maroon 0x7800
#define TFT_DC 9
#define TFT_CS 10
Adafruit_GC9A01A tft(TFT_CS, TFT_DC);
#include <Fonts/FreeSansBold9pt7b.h>
#include <Fonts/FreeSansBold12pt7b.h>
#include <Fonts/FreeSansBold18pt7b.h>
#include <Fonts/FreeSansBold24pt7b.h>
int An, Mo, Jo, He, Mi, Se, DoW;
int oldAn, oldMo, oldJo, oldHe, oldMi, oldSe, oldDate;
char daysOfTheWeek[7][12] = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};
char moisannee[][13] = {" ", "Janvier", "Fevrier", "Mars", "Avril", "Mai", "Juin", "Juillet", "Aout", "Septembre", "Octobre", "Novembre", "Decembre"};
void setup() {
Serial.begin(9600); // Initialise la communication série
////////////////// TFT ////////////////////
tft.begin();
tft.fillScreen(GC9A01A_BLACK);
}
void loop() {
ReceptionData();
MenuDateHeure();
}
void ReceptionData() {
if (Serial.available() >= 7 * sizeof(int)) { // + 3 * sizeof(float)) {
Serial.readBytes((byte*)&An, sizeof(An));
Serial.readBytes((byte*)&Mo, sizeof(Mo));
Serial.readBytes((byte*)&Jo, sizeof(Jo));
Serial.readBytes((byte*)&He, sizeof(He));
Serial.readBytes((byte*)&Mi, sizeof(Mi));
Serial.readBytes((byte*)&Se, sizeof(Se));
Serial.readBytes((byte*)&DoW, sizeof(DoW));
}
}
/********************************************************** VOID Menu Date Heure ***********************************************************/
void MenuDateHeure() {
tft.setFont(&FreeSansBold18pt7b);
tft.setTextColor(GREEN);
if (oldDate != Jo) {
tft.fillRect(20, 100, 200, 90, tft.color565(0, 0, 0)); // Gauche, Haut, Longueur, Hauteur
tft.setCursor(45, 135);
tft.print(daysOfTheWeek[DoW]);
tft.setTextColor(CYAN);
tft.setCursor(50, 180);
tft.print(Jo);
// tft.setCursor(86, 180);
// tft.print(Mo);
tft.setCursor(80, 220);
tft.print(An);
oldDate = Jo;
tft.setFont(&FreeSansBold12pt7b);
tft.setCursor(90, 175);
tft.print(moisannee[Mo]);
}
tft.setFont(&FreeSansBold24pt7b);
tft.setTextColor(YELLOW);
tft.setCursor(80, 90);
tft.print(':');
tft.setCursor(150, 90);
tft.print(':');
if (oldHe != He) {
tft.fillRect(20, 54, 60, 40, tft.color565(0, 0, 0)); // carré pour effacer les heures
tft.setCursor(50, 90); // place le curseur pour les unitées d'heures
tft.print(He % 10, DEC); // garde uniquement les unitées d'heures
tft.setCursor(25, 90); // place le curseur pour les dizaines d'heures
tft.print(He / 10, DEC); // garde uniquement les dizaines d'heures
oldHe = He;
}
if (oldMi != Mi) {
tft.fillRect(90, 54, 60, 40, tft.color565(0, 0, 0)); // carré pour effacer les minutes
tft.setCursor(120, 90);
tft.print(Mi % 10, DEC);
tft.setCursor(95, 90);
tft.print(Mi / 10, DEC);
oldMi = Mi;
}
if (oldSe != Se) {
tft.fillRect(160, 54, 60, 40, tft.color565(0, 0, 0)); // carré pour effacer les secondes
tft.setCursor(190, 90);
tft.print(Se % 10, DEC);
tft.setCursor(165, 90);
tft.print(Se / 10, DEC);
oldSe = Se;
}
}
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);
}
et pour fini le code de l'affichage, la ou devrait se trouver la partie menu que je galère vraiment a faire.
/************************ ECRAN ******************/
//
// CG9A01 Arduino Nano
// RS -------- NC
// CS -------- 10
// DC --------- 9
// SDA -------- 11
// SCL -------- 13
//
// GND = 0v
// VCC = 3,3v
//////////////////////
// Bouton Menu = 2
// Bouton Chrono = 3
//////////////////////
#include <Wire.h>
#define BLACK 0x0000
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#define Maroon 0x7800
///////////////////////// ECRAN ROND 1,28 " //////////////////
#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_GC9A01A.h"
#define TFT_DC 9
#define TFT_CS 10
Adafruit_GC9A01A tft(TFT_CS, TFT_DC);
#include <Fonts/FreeSansBold9pt7b.h>
#include <Fonts/FreeSansBold12pt7b.h>
#include <Fonts/FreeSansBold18pt7b.h>
#include <Fonts/FreeSansBold24pt7b.h>
int An, Mo, Jo, He, Mi, Se, impulsionsParLitre, AuraTH, AuraTM, Hrest, Mrest;
int oldAn, oldMo, oldJo, oldHe, oldMi, oldSe, oldcoef;
float NiveauCarburant, litresParHeure, totalLitres;
float oldLh, oldconso, oldtank, oldhRest, oldTvolM; // pour savoir si il y a changement pour l'affichage
int Al;
void MenuPrincipal() {
ReceptionData();
AFFICHAGE();
HORLOGE();
}
void setup() {
Serial.begin(9600); // Initialise la communication série à 9600 bits par seconde
////////////////// TFT ////////////////////
tft.begin();
tft.fillScreen(GC9A01A_BLACK);
AfficheInfoFond ();
}
void loop() {
MenuPrincipal();
}
/******************************************** VOID AFFICHAGE ************************************/
void AFFICHAGE() {
//////////////////////// Litre / heure ( L/H ) /////////////////////////
tft.setFont(&FreeSansBold18pt7b);
tft.setTextColor(WHITE);
if (litresParHeure != oldLh) {
tft.fillRect(40, 33, 78, 32, tft.color565(0, 0, 0)); // carré noir pour effacer L/h
if ( litresParHeure < 10.00 ) {
tft.setCursor(60, 60); // Horizontal, Vertical
tft.print(litresParHeure, 1);
} else {
tft.setCursor(41, 60); // Horizontal, Vertical
tft.print(litresParHeure, 1);
}
oldLh = litresParHeure;
}
////////////////////////////// totalLitres consomés pendant le vol ( conso ) /////////////////////////
if (totalLitres != oldconso ) {
tft.fillRect(40, 68, 70, 32, tft.color565(0, 0, 00)); // dizaine efface L.totalLitres
if ( totalLitres <= 9.90) {
tft.setCursor(60, 95);
tft.print(totalLitres, 1 ); // Unitées totalLitres
} else {
tft.setCursor(41, 95);
tft.print(totalLitres, 1 ); // Unitées totalLitres
}
oldconso = totalLitres;
}
////////////////////////////// NiveauCarburant ( tank ) /////////////////////////
if (NiveauCarburant != oldtank) {
if (NiveauCarburant <= 20) {
tft.setTextColor(RED);
}
tft.fillRect(40, 103, 78, 32, tft.color565(0, 0, 0)); // carré noir pour effacer
if (NiveauCarburant < 10.00) {
tft.setCursor(60, 130); // Horizontal, Vertical
tft.print(NiveauCarburant, 1);
} else {
tft.setCursor(41, 130);
tft.print(NiveauCarburant, 1);
}
oldtank = NiveauCarburant;
Al = 1;
}
tft.setTextColor(WHITE);
//////////////////////// Autonomie ( H rest ) /////////////////////////
if (Mrest != oldhRest) {
tft.fillRect(10, 138, 45, 32, tft.color565(0, 0, 0)); // carré pour effacer He
tft.fillRect(68, 138, 50, 32, tft.color565(0, 0, 0)); // carré pour effacer Mi
if (Mrest <= 0.00) {
Hrest = 0;
Mrest = 0;
}
if (Hrest < 10.00) {
tft.setCursor(32, 165); // Horizontal, Vertical
tft.print(Hrest);
} else {
tft.setCursor(14, 165);
tft.print(Hrest);
}
if (Mrest < 10.00) {
tft.setCursor(88, 165);
tft.print(Mrest);
} else {
tft.setCursor(70, 165);
tft.print(Mrest);
}
oldhRest = Mrest;
}
//////////////////////// Temps de vol ( T de vol ) /////////////////////////
tft.setFont(&FreeSansBold12pt7b);
tft.setTextColor(CYAN);
if (AuraTM != oldTvolM) {
tft.fillRect(114, 182, 32, 22, tft.color565(60, 60, 60)); // fond Gris M
tft.fillRect(164, 182, 32, 22, tft.color565(60, 60, 60)); // fond Gris H
tft.setCursor(118, 200);
tft.print(AuraTH);
tft.setCursor(166, 200);
tft.print(AuraTM);
oldTvolM = AuraTM;
}
/////////////////////////////// Coeffisiant ////////////////////////////////
int coef;
if (impulsionsParLitre == 1420) {
coef = 0;
}
if (impulsionsParLitre == 17000) {
coef = 1;
}
if (impulsionsParLitre == 7000) {
coef = 2;
}
if (impulsionsParLitre == 3500) {
coef = 3;
}
if (impulsionsParLitre == 2100) {
coef = 4;
}
tft.setFont(&FreeSansBold9pt7b);
if (impulsionsParLitre != oldcoef) {
tft.fillRect(188, 33, 20, 32, tft.color565(0, 0, 0)); // carré noir pour effacer L/h
tft.setTextColor(Maroon);
tft.setCursor(190, 60); // Horizontal, Vertical
tft.print(coef, 1);
oldcoef = impulsionsParLitre;
}
}
/******************************************** VOID HORLOGE ************************************/
void HORLOGE() {
tft.setFont(&FreeSansBold12pt7b);
tft.setTextColor(BLACK);
tft.setCursor(132, 226);
tft.print(':');
tft.setCursor(98, 226);
tft.print(':');
if (oldHe != He) {
tft.fillRect(68, 210, 33, 22, tft.color565(60, 160, 60)); // carré pour effacer les heures
tft.setCursor(83, 228); // place le curseur pour les unitées d'heures
tft.print(He % 10, DEC); // garde uniquement les unitées d'heures
tft.setCursor(70, 228); // place le curseur pour les dizaines d'heures
tft.print(He / 10, DEC); // garde uniquement les dizaines d'heures
oldHe = He;
}
if (oldMi != Mi) {
tft.fillRect(104, 210, 34, 22, tft.color565(60, 160, 60)); // carré pour effacer les minutes
tft.setCursor(117, 228);
tft.print(Mi % 10, DEC);
tft.setCursor(104, 228);
tft.print(Mi / 10, DEC);
oldMi = Mi;
}
if (oldSe != Se) {
tft.fillRect(132, 210, 34, 22, tft.color565(60, 160, 60)); // carré pour effacer les secondes
tft.fillRect(98, 210, 6, 22, tft.color565(60, 160, 60)); // // carré pour effacer les : des minutes
tft.setCursor(151, 228);
tft.print(Se % 10, DEC);
tft.setCursor(138, 228);
tft.print(Se / 10, DEC);
oldSe = Se;
}
}
/******************************************** VOID AFFICHAGE INFOS FOND ************************************/
void AfficheInfoFond () {
tft.fillScreen(BLACK);
//////////////// Affichage des infos valeurs ///////////////
tft.fillRect(0, 176, 240, 100, tft.color565(60, 60, 60)); // fond Gris Haut
tft.fillRect(0, 0, 240, 29, tft.color565(60, 60, 60)); // fond Gris Bas
tft.fillRect(72, 210, 94, 22, tft.color565(60, 160, 60)); // Rectangle Vert Heure
tft.setFont(&FreeSansBold9pt7b);
tft.setTextColor(YELLOW);
tft.setCursor(70, 24);
tft.print("Debit metre");
tft.setCursor(38, 198);
tft.print("T de vol:");
tft.setCursor(150, 200); // h pour T de Vol
tft.print('h');
tft.setCursor(57, 165); // h pour T REST
tft.print("h");
tft.setFont(&FreeSansBold12pt7b);
tft.setTextColor(GREEN);
tft.setCursor(125, 60);
tft.print("L/h");
tft.setCursor(125, 95);
tft.print("conso");
tft.setCursor(125, 130);
tft.print("Tank");
tft.setCursor(125, 165);
tft.print("T Rest");
tft.setTextColor(CYAN);
tft.setCursor(118, 200);
tft.print(0);
tft.setCursor(166, 200);
tft.print(0);
///////////////////////////////// RTC ///////////////////////
tft.setFont(&FreeSansBold12pt7b);
tft.setTextColor(BLACK);
tft.setCursor(132, 226);
tft.print(':');
tft.setCursor(98, 226);
tft.print(':');
tft.setCursor(83, 228); // place le curseur pour les unitées d'heures
tft.print(He % 10, DEC); // garde uniquement les unitées d'heures
tft.setCursor(70, 228); // place le curseur pour les dizaines d'heures
tft.print(He / 10, DEC); // garde uniquement les dizaines d'heures
tft.setCursor(117, 228);
tft.print(Mi % 10, DEC);
tft.setCursor(104, 228);
tft.print(Mi / 10, DEC);
tft.fillRect(98, 210, 6, 22, tft.color565(60, 160, 60)); // // carré pour effacer les : des minutes
tft.setCursor(151, 228);
tft.print(Se % 10, DEC);
tft.setCursor(138, 228);
tft.print(Se / 10, DEC);
}
/********************************************************** VOID Menu Date Heure ***********************************************************/
void MenuDateHeure() { // MENU PRINCIPAL
tft.fillScreen(BLACK);
tft.setFont(&FreeSansBold18pt7b);
tft.setTextColor(RED);
tft.setCursor(90, 100);
tft.print("Menu");
tft.setCursor(20, 140);
tft.print("Date Heure");
}
/********************************************************************** VOID MENU CHRONO **********************************************************/
void MenuChrono() {
tft.fillScreen(BLACK);
tft.setFont(&FreeSansBold18pt7b);
tft.setTextColor(RED);
tft.setCursor(90, 100);
tft.print("Menu");
tft.setCursor(98, 140);
tft.print("Chrono");
}
void ReceptionData() {
if (Serial.available() >= 14 * sizeof(int) + 3 * sizeof(float)) {
Serial.readBytes((byte*)&An, sizeof(An));
Serial.readBytes((byte*)&Mo, sizeof(Mo));
Serial.readBytes((byte*)&Jo, sizeof(Jo));
Serial.readBytes((byte*)&He, sizeof(He));
Serial.readBytes((byte*)&Mi, sizeof(Mi));
Serial.readBytes((byte*)&Se, sizeof(Se));
Serial.readBytes((byte*)&impulsionsParLitre, sizeof(impulsionsParLitre));
Serial.readBytes((byte*)&AuraTH, sizeof(AuraTH));
Serial.readBytes((byte*)&AuraTM, sizeof(AuraTM));
Serial.readBytes((byte*)&Hrest, sizeof(Hrest));
Serial.readBytes((byte*)&Mrest, sizeof(Mrest));
Serial.readBytes((byte*)&NiveauCarburant, sizeof(NiveauCarburant));
Serial.readBytes((byte*)&litresParHeure, sizeof(litresParHeure));
Serial.readBytes((byte*)&totalLitres, sizeof(totalLitres));
}
}
Je n'ai pas lu tout le code et ne dispose pas de ce matériel mais il semble que votre souci principal soit l'intégration de différents morceaux de codes
La programmation par machine à états (cf mon tuto éventuellement) permet généralement d'aborder ce genre de code.
j'ai noté cependant ceci
je ne sais pas quel Arduino vous utilisez, sur un UNO ou Nano la formule donne 14x2+3x4= 40 ça tient dans le buffer de 64 octets mais sur une plateforme 32 bits, ce serait 14x4+3x4= 68 et ça n'arrivera jamais si le buffer de réception série est limité à 64 octets.
en pratique il vaut mieux lire les données asynchrones au fil de l'eau , quand elles arrivent et une fois que vous avez reçu tous vos octets, vous effectuez l'extraction.
d'autre part, si par hasard un octet se perd, votre mode de communication ne s'en remet pas. On utilise généralement pour un protocole binaire une trame de début ou de fin qui permet de se synchroniser
Bonjour,
dans ton code final, on ne retrouve pas la structure du menu de test, il me semble ?
As tu compris ce qui ce passe dans le programme de test "menu"?
De plus ta fonction loop appel la fonction "MenuPrincipal" qui appel plusieurs fonction qui n'ont aucun lien avec l'affichage.
Ta loop devrait contenir directement le code de cette fonction.
Ta fonction "AFFICHAGE", ne devrait pas contenir de fonction de dessin à l'écran, mais avoir la même structure que la fonction "loop" du programme "menu"
Cette fonction gérant en faite le menu à afficher, en appelant la fonction dédié au bon menu.
Ton programme de test est un peu léger et il me semble ne gère pas le rafraichissement des données récupéré dans "ReceptionData".
J'espère que ma réponse est compréhensible et t'aiguille sur ce que tu pourrais faire.
un peu comme pour la transmission des données entre l'android et la nano
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.