Note de ce sujet :
  • Moyenne : 0 (0 vote(s))
  • 1
  • 2
  • 3
  • 4
  • 5
Sortie Version 1.00-beta.17
#1
Nouvelle version en ligne. Elle apporte des nouveaux écrans pour la version tournant sur les écrans 480*320 pixels (  JC3248W535)Cordialement

André


Pièces jointes Miniature(s)
           
Répondre

#2
Merci André pour cette nouvelle version.
C'est un détail mais depuis la version précédente, le fichier Server.cpp a été renommé Sever.cpp.
Répondre

#3
(13-11-2026, 08:58 PM)Mike a écrit : Merci André pour cette nouvelle version.
C'est un détail mais depuis la version précédente, le fichier Server.cpp a été renommé Sever.cpp.

Merci pour Sever.cpp

Cdlt
André
Répondre

#4
(13-11-2026, 08:53 PM)F1ATB a écrit : Nouvelle version en ligne. Elle apporte des nouveaux écrans pour la version tournant sur les écrans 480*320 pixels (  JC3248W535)Cordialement

André

Bonjour André,

En effectuant quelques tests ce matin avec cette dernière version, je me suis rendu compte d'un comportement plutôt bizarre lorsque je tente d'effectuer des mises à jour via OTA avec mon navigateur Firefox (v160.0), que ce soit en en navigation courante ou privée, et que je n'avais encore jamais vu. 
En effet, avec cette version du routeur (mais c'est également vrai pour d'autres fichiers avec des versions antérieures...), à l'issue du téléversement l'ESP effectue un reboot (normal), et la page web reste figée en l'état (normal aussi...). Mais immédiatement après le redémarrage et dès que l'ESP reprend la main sur son cycle, Firefox relance la procédure de mise à jour sans même cliquer sur le bouton 'Mettre à jour'. 
Conséquence : le fichier est de nouveau téléversé, l'ESP reboote, et ce cycle recommence indéfiniment jusqu'à ce que l'on clique sur un onglet différent ('Accueil' par exemple) pendant le téléversement, ce qui l'annule et on repart sur un fonctionnement normal.

Je n'ai pas constaté ce comportement avec Chrome (v157), aussi je pense que c'est sûrement du côté Firefox qu'il y a un problème et je ne suis pas sûr qu'il soit possible de le résoudre du coup, mais je souhaitais quand même le signaler... En PJ quelques logs (expurgés de données sensibles) où on voit ces redémarrages après l'update, si besoin.


Pièces jointes
.txt   logs.txt (Taille : 14.08 Ko / Téléchargements : 1)
_________________________________________________
Routeur Solaire en v17.30 (modifié avec écran OLED)
Pilotage d'un cumulus de 3kW + Jeedom v4.6.2 + Station solaire 3,5kW
Répondre

#5
(14-11-2026, 01:19 PM)DanielJ a écrit :
(13-11-2026, 08:53 PM)F1ATB a écrit : Nouvelle version en ligne. Elle apporte des nouveaux écrans pour la version tournant sur les écrans 480*320 pixels (  JC3248W535)Cordialement

André

Bonjour André,

En effectuant quelques tests ce matin avec cette dernière version, je me suis rendu compte d'un comportement plutôt bizarre lorsque je tente d'effectuer des mises à jour via OTA avec mon navigateur Firefox (v160.0), que ce soit en en navigation courante ou privée, et que je n'avais encore jamais vu. 
En effet, avec cette version du routeur (mais c'est également vrai pour d'autres fichiers avec des versions antérieures...), à l'issue du téléversement l'ESP effectue un reboot (normal), et la page web reste figée en l'état (normal aussi...). Mais immédiatement après le redémarrage et dès que l'ESP reprend la main sur son cycle, Firefox relance la procédure de mise à jour sans même cliquer sur le bouton 'Mettre à jour'. 
Conséquence : le fichier est de nouveau téléversé, l'ESP reboote, et ce cycle recommence indéfiniment jusqu'à ce que l'on clique sur un onglet différent ('Accueil' par exemple) pendant le téléversement, ce qui l'annule et on repart sur un fonctionnement normal.

Je n'ai pas constaté ce comportement avec Chrome (v157), aussi je pense que c'est sûrement du côté Firefox qu'il y a un problème et je ne suis pas sûr qu'il soit possible de le résoudre du coup, mais je souhaitais quand même le signaler... En PJ quelques logs (expurgés de données sensibles) où on voit ces redémarrages après l'update, si besoin.
Il faut que j'essaye avec Firefox.
Je ne suis pas le créateur du code pour le téléchargement par OTA depuis un navigateur, c'est du code trouvé sur le net d'origine Espressif je crois.

André
Répondre

#6
Bonjour André.
j ai testé le JC3248W535 ca fonctionne bien mais lors du scroll ça redémarrer l ecran .
j ai trouver le bug lorsque il n y a pas d action programmé il y a une division par zéro dans Gauges.cpp
Code :
Wx = EcranW / (2 * nb_Action);
a remplacé par 
Code :
Wx = EcranW / (2 * max(nb_Action, 1));
si pas source programmé possible aussi d avoir div/0  
j ai profité pour modifier aussi la fluidité du scrolling ca fonctionne bien maintenant.
Répondre

#7
Qu'avez vous modifier pour la fluidité. Merci pour le bug.

André
Répondre

#8
j ai modifié dans 4 fichiers.

Ecran.cpp
Affichage par memcpy au lieu de draw16bitRGBBitmap, glissements horizontal et vertical animés, une seule page par geste, boutons ON et OFF affichés par memcpy
Code :
#include "Ecrans/Ecran.h"
#include "Cartes/carte.h"
#include "Communications/comSortie.h"
#include "Ecrans/pagesEcran/Gauges.h"
#include "Ecrans/pagesEcran/Graph_10mn.h"
#include "Ecrans/pagesEcran/Graph_48h.h"
#include "Ecrans/pagesEcran/Messages.h"
#include "Ecrans/pagesEcran/Ouvre_10mn.h"
#include "Ecrans/pagesEcran/Ouvre_48h.h"
#include "Ecrans/pagesEcran/Tableau.h"
#include "Ecrans/pagesEcran/Temperatures_48h.h"
#include "Puissance.h"
#include "Sources/Source_Linky.h"
#include "commonFX.h"
#include "config.h"
#include <Arduino.h>
#include <Arduino_GFX_Library.h>
#include <U8g2lib.h>
#include <Wire.h>
#include <string.h>
#include "esp_heap_caps.h"

// Paramètres écran
byte rotation = 3;
unsigned long DurEcran = 30000;
unsigned long allumEcranMillis = 0;
int16_t PageOld = PAGE_MESSAGES, PageActu = PAGE_MESSAGES, PageDelta = 0, PageTotal = 8, PageDeltaY = 0;

int16_t EcranW, EcranH;
static int16_t EcranH20, EcranH40;

uint16_t CoulTexte, CoulFond, CoulBouton, CoulBoutFond, CoulBoutBord, CoulW, CoulWh, CoulTabTexte, CoulTabFond, CoulTabBord;
uint16_t CoulSaisieTexte, CoulSaisieFond, CoulSaisieBord, CoulTemp, CoulGrTexte, CoulGrFond, CoulMesFond, CoulMesTexte;
static unsigned long runtime_0 = 0, runtime_1 = 0;

static uint16_t touchX = 0, touchY = 0;
int16_t DeltaTouchX = 0, DeltaTouchY = 0;

// ===== Transitions de pages optimisées =====
// CanvaBase et CanvaRef ont la même taille physique (320x480) et la même rotation :
// leurs framebuffers ont la même organisation et se copient par memcpy.
// En rotation 1 ou 3 :
//  - une colonne logique = une ligne physique de 320 pixels contiguë
//    => glissement horizontal = 2 memcpy par image ;
//  - une ligne logique = une colonne physique
//    => glissement vertical = 2 petits memcpy par ligne physique.
#define RAW_W 320
#define RAW_H 480
#define FRAME_BYTES ((size_t)RAW_W * RAW_H * sizeof(uint16_t))
#define TRANS_AUCUNE 0
#define TRANS_HORIZONTALE 1
#define TRANS_VERTICALE 2
static uint16_t *PageAvant = nullptr; // copie de l'image affichée avant le changement (PSRAM)
static uint8_t TransType = TRANS_AUCUNE;
static int8_t TransSens = 1;          // horizontal : +1 nouvelle page par la droite, -1 par la gauche
static int16_t TransDY0 = 0;          // vertical : décalage de départ (PageDeltaY)
static uint32_t TransDebut = 0, TransImageUs = 0;
static bool GesteConsomme = false;    // un glissement ne déclenche qu'un seul changement

// Prototypes
void TouchSetup();
bool getTouchPoint(uint16_t &x, uint16_t &y, int16_t &dX, int16_t &dY);
void PrintCentre(Arduino_Canvas *canva, const String &S, int16_t X, int16_t Y, uint8_t Sz);
void PrintGauche(Arduino_Canvas *canva, const String &S, int16_t X, int16_t Y, uint8_t Sz);
void PrintDroite(Arduino_Canvas *canva, const String &S, int16_t X, int16_t Y, uint8_t Sz);
void SetCouleurs();
String ULtoHex(unsigned long x);
unsigned long ConvCouleur(String V);
uint16_t HSLtoRGB565(float H, float S, float L);
bool Bouton_Appui(Bouton &b, int16_t x, int16_t y);
void Bouton_Trace(Bouton &B, uint16_t colorBord);
void AfficherRef();
static void DessinePageComplete(int16_t page);
static void DessinePageLive(int16_t page);
static void DemarrerTransition(int16_t vers, int8_t sens);
static void DemarrerTransitionY();
static void TransitionLoop();

Arduino_DataBus *bus = new Arduino_ESP32QSPI(45, 47, 21, 48, 40, 39);
Arduino_GFX *g = new Arduino_AXS15231B(bus, GFX_NOT_DEFINED, 0, false, RAW_W, RAW_H);
EXT_RAM_BSS_ATTR Arduino_Canvas *CanvaBase = new Arduino_Canvas(RAW_W, RAW_H, g, 0, 0, 0);
EXT_RAM_BSS_ATTR Arduino_Canvas *CanvaRef = nullptr;

void Init_Ecran(void) {
  if (ESP32_Type != CARTE_ECRAN)
    return;
  SetCouleurs();
  // Initialize Display
  CanvaBase->begin();
  CanvaBase->setUTF8Print(true);
  // CanvaMessage->setUTF8Print(true);

  // Initialize touch
  Wire.begin(TOUCH_SDA, TOUCH_SCL);
  Wire.setClock(TOUCH_I2C_CLOCK);

  // Configure touch pins
  pinMode(TOUCH_INT_PIN, INPUT_PULLUP);
  pinMode(TOUCH_RST_PIN, OUTPUT);
  digitalWrite(TOUCH_RST_PIN, LOW);
  delay(200);
  digitalWrite(TOUCH_RST_PIN, HIGH);
  delay(200);

  CanvaBase->setRotation(rotation);
  CanvaBase->fillScreen(CoulFond);
  CanvaBase->setTextColor(CoulTexte);
  EcranW = CanvaBase->width();
  EcranH = CanvaBase->height();
  EcranH20 = EcranH - 20;
  EcranH40 = EcranH - 40;

  // CanvaRef : même taille physique et même rotation que CanvaBase (copie par memcpy)
  CanvaRef = new Arduino_Canvas(RAW_W, RAW_H, g, 0, 0, 0);
  CanvaRef->begin(GFX_SKIP_OUTPUT_BEGIN);
  CanvaRef->setRotation(rotation);
  PageAvant = (uint16_t *)heap_caps_malloc(FRAME_BYTES, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
  if (PageAvant == nullptr)
    SeriePrintln("Ecran : pas de PSRAM pour les transitions, changements sans animation");

  PageTableau();

  CanvaBase->fillScreen(CoulFond);
  CanvaBase->fillRect(0, 0, EcranW, 20, CoulFond);
  CanvaBase->setFont(u8g2_font_10x20_tf);
  PrintCentre(CanvaBase, utf8ToLatin15("Routeur Photovoltaique"), EcranW / 2, 100, 1);
  PrintCentre(CanvaBase, utf8ToLatin15("RMS S3"), EcranW / 2, 150, 2);
  PrintCentre(CanvaBase, "F1ATB", EcranW / 2, 240, 2);
  CanvaBase->flush();
  pinMode(GFX_BL, OUTPUT); // Back Light On
  digitalWrite(GFX_BL, HIGH);
  allumEcranMillis = millis();
  delay(2000);
  PageMessages();
  CanvaBase->flush();
}

void Ecran_Loop() {
  if (ESP32_Type != CARTE_ECRAN)
    return;
  if (DurEcran == 0) {
    digitalWrite(GFX_BL, HIGH); // Toujours allumé
  } else {
    if (millis() - allumEcranMillis > DurEcran) { // Duree allumage
      digitalWrite(GFX_BL, LOW);
    }
  }

  // 1) Transition en cours : une image à chaque appel (cadence limitée), non bloquant
  if (TransType != TRANS_AUCUNE) {
    TransitionLoop();
    return;
  }

  // 2) Changement de page demandé par le code extérieur (main.cpp : PageActu = 0, PageDelta = 480)
  if (PageDelta != 0) {
    DemarrerTransition(PageActu, PageDelta > 0 ? 1 : -1);
    return;
  }
  if (PageDeltaY != 0) { // changement vertical demandé (page Tableau)
    DemarrerTransitionY();
    return;
  }

  if ((millis() - runtime_0) > 20) {
    runtime_0 = millis();

    // 3) Tactile
    bool touche = getTouchPoint(touchX, touchY, DeltaTouchX, DeltaTouchY);
    if (!touche)
      GesteConsomme = false; // doigt levé : un nouveau glissement est permis
    if (touche) {
      digitalWrite(GFX_BL, HIGH);
      allumEcranMillis = millis();
      if (!GesteConsomme) {
        if (DeltaTouchX < -30) {
          GesteConsomme = true;
          DemarrerTransition((PageOld + 1) % PageTotal, 1);
          return;
        }
        if (DeltaTouchX > 30) {
          GesteConsomme = true;
          DemarrerTransition((PageTotal + PageOld - 1) % PageTotal, -1);
          return;
        }
        if (PageActu == PAGE_MESSAGES) { // défilement continu des messages
          PageMessagesLiveDY(DeltaTouchY);
          if (abs(DeltaTouchY) > 30) {
            AfficherRef();
            runtime_1 = millis();
          }
        }
        if (PageActu == PAGE_TABLEAU) { // glissement vertical (changement de champ) ou appui bouton
          PageTableauLiveDY(DeltaTouchY, touchX, touchY); // met PageDeltaY à +/-140 si glissement
          if (PageDeltaY != 0) {
            GesteConsomme = true;
            DemarrerTransitionY();
            return;
          }
        }
      }
    }

    // 4) Rafraîchissement de la page affichée
    if ((millis() - runtime_1) > 200) {
      runtime_1 = millis();
      DessinePageLive(PageActu);
      AfficherRef();
    }
  }
}

// Page fixe : 1 memcpy + flush (au lieu d'un draw16bitRGBBitmap pixel par pixel)
void AfficherRef() {
  memcpy(CanvaBase->getFramebuffer(), CanvaRef->getFramebuffer(), FRAME_BYTES);
  CanvaBase->flush();
}

// Dessin complet d'une page dans CanvaRef, avant son arrivée à l'écran.
// Les pages "Live" ne redessinent qu'1 appel sur N (compteur_boucle % N) :
// on les appelle N fois pour obtenir exactement un tracé complet.
static void DessinePageComplete(int16_t page) {
  switch (page) {
  case PAGE_TABLEAU:
    PageTableau(); // appelle déjà PageTableauLive()
    break;
  case PAGE_GRAPH_10MN:
    PageGraph_10mn();
    for (int i = 0; i < 4; i++) PageGraph_10mnLive();
    break;
  case PAGE_GRAPH_48H:
    PageGraph_48h();
    for (int i = 0; i < 10; i++) PageGraph_48hLive();
    break;
  case PAGE_OUVRE_10MN:
    PageOuvre_10mn();
    for (int i = 0; i < 4; i++) PageOuvre_10mnLive();
    break;
  case PAGE_OUVRE_48H:
    PageOuvre_48h();
    for (int i = 0; i < 10; i++) PageOuvre_48hLive();
    break;
  case PAGE_TEMPERATURES:
    PageTemperatures_48h();
    for (int i = 0; i < 10; i++) PageTemperatures_48hLive();
    break;
  case PAGE_MESSAGES:
    PageMessages();
    PageMessagesForce();
    break;
  case PAGE_GAUGES:
    PageGauges();
    for (int i = 0; i < 4; i++) PageGaugesLive();
    break;
  default:
    break;
  }
}

// Mise à jour périodique (identique à la version d'origine)
static void DessinePageLive(int16_t page) {
  switch (page) {
  case PAGE_TABLEAU:
    PageTableauLive();
    break;
  case PAGE_GRAPH_10MN:
    PageGraph_10mnLive();
    break;
  case PAGE_GRAPH_48H:
    PageGraph_48hLive();
    break;
  case PAGE_OUVRE_10MN:
    PageOuvre_10mnLive();
    break;
  case PAGE_OUVRE_48H:
    PageOuvre_48hLive();
    break;
  case PAGE_TEMPERATURES:
    PageTemperatures_48hLive();
    break;
  case PAGE_MESSAGES:
    PageMessagesLive();
    break;
  case PAGE_GAUGES:
    PageGaugesLive();
    break;
  default:
    break;
  }
}

static bool AnimationPossible() {
  return PageAvant != nullptr && (rotation == 1 || rotation == 3);
}

// Glissement horizontal vers une autre page
static void DemarrerTransition(int16_t vers, int8_t sens) {
  if (PageAvant != nullptr)
    memcpy(PageAvant, CanvaBase->getFramebuffer(), FRAME_BYTES); // photo de l'écran actuel
  PageActu = vers;
  PageDeltaY = 0;
  DessinePageComplete(vers);
  if (!AnimationPossible()) { // portrait : pas d'animation
    PageOld = PageActu;
    PageDelta = 0;
    AfficherRef();
    return;
  }
  TransSens = sens;
  TransDY0 = 0;
  TransDebut = millis();
  TransImageUs = micros();
  TransType = TRANS_HORIZONTALE;
}

// Glissement vertical de la page Tableau (CanvaRef déjà redessiné par PageTableauLiveDY)
static void DemarrerTransitionY() {
  if (!AnimationPossible()) {
    PageDeltaY = 0;
    AfficherRef();
    return;
  }
  memcpy(PageAvant, CanvaBase->getFramebuffer(), FRAME_BYTES); // photo de l'écran actuel
  TransDY0 = PageDeltaY;
  TransDebut = millis();
  TransImageUs = micros();
  TransType = TRANS_VERTICALE;
}

/*
  Horizontal : image = page "gauche" décalée de s colonnes, suivie de la page "droite" :
     x <  W-s : gauche[x + s]        x >= W-s : droite[x - (W - s)]
  Colonne logique x = ligne physique x (rotation 1) ou W-1-x (rotation 3).
*/
static void ComposerTransition(uint16_t *gauche, uint16_t *droite, int16_t s) {
  if (s < 0)
    s = 0;
  if (s > RAW_H)
    s = RAW_H;
  int16_t n = RAW_H - s; // colonnes encore visibles de la page de gauche
  const size_t L = RAW_W;
  uint16_t *dst = CanvaBase->getFramebuffer();
  if (rotation == 1) {
    if (n > 0)
      memcpy(dst, gauche + (size_t)s * L, (size_t)n * L * 2);
    if (s > 0)
      memcpy(dst + (size_t)n * L, droite, (size_t)s * L * 2);
  } else { // rotation 3
    if (n > 0)
      memcpy(dst + (size_t)s * L, gauche, (size_t)n * L * 2);
    if (s > 0)
      memcpy(dst, droite + (size_t)n * L, (size_t)s * L * 2);
  }
  if (n > 0 && n < EcranW)
    CanvaBase->writeFastVLine(n, 0, EcranH, RGB565_DARKGREY); // trait de séparation
  CanvaBase->flush();
}

/*
  Vertical (comme draw16bitRGBBitmap(0, dy, ...) d'origine) : la nouvelle image est
  décalée de dy lignes, la bande découverte garde l'ancienne image.
  Ligne logique y = colonne physique y (rotation 3) ou RAW_W-1-y (rotation 1).
*/
static void ComposerTransitionY(uint16_t *ancienne, uint16_t *nouvelle, int16_t dy) {
  int16_t a = (rotation == 3) ? dy : -dy; // décalage en colonnes physiques
  if (a > RAW_W)
    a = RAW_W;
  if (a < -RAW_W)
    a = -RAW_W;
  uint16_t *dst = CanvaBase->getFramebuffer();
  for (size_t r = 0; r < RAW_H; r++) {
    uint16_t *d = dst + r * RAW_W;
    uint16_t *o = ancienne + r * RAW_W;
    uint16_t *nv = nouvelle + r * RAW_W;
    if (a >= 0) {
      memcpy(d, o, (size_t)a * 2);
      memcpy(d + a, nv, (size_t)(RAW_W - a) * 2);
    } else {
      int16_t k = -a;
      memcpy(d, nv + k, (size_t)(RAW_W - k) * 2);
      memcpy(d + RAW_W - k, o + RAW_W - k, (size_t)k * 2);
    }
  }
  if (dy > 0)
    CanvaBase->writeFastHLine(0, dy, EcranW, RGB565_DARKGREY);
  if (dy < 0)
    CanvaBase->writeFastHLine(0, dy + EcranH, EcranW, RGB565_DARKGREY);
  CanvaBase->flush();
}

static void TransitionLoop() {
  if ((int32_t)(micros() - TransImageUs) < 0)
    return; // limitation de cadence
  TransImageUs = micros() + FRAME_INTERVAL_US;
  uint32_t duree = (TransType == TRANS_VERTICALE) ? TRANSITION_Y_MS : TRANSITION_MS;
  uint32_t t = millis() - TransDebut;
  if (t >= duree) { // fin de la transition
    TransType = TRANS_AUCUNE;
    PageOld = PageActu;
    PageDelta = 0;
    PageDeltaY = 0;
    DeltaTouchX = 1000; // ancien point tactile périmé : évite un 2e changement
    runtime_1 = millis();
    AfficherRef();
    return;
  }
  float p = float(t) / duree;
  p = 1.0f - (1.0f - p) * (1.0f - p) * (1.0f - p); // ralenti en fin de course
  if (TransType == TRANS_HORIZONTALE) {
    int16_t s = int16_t(p * EcranW);
    uint16_t *nouvelle = CanvaRef->getFramebuffer();
    if (TransSens > 0)
      ComposerTransition(PageAvant, nouvelle, s);          // la nouvelle page arrive par la droite
    else
      ComposerTransition(nouvelle, PageAvant, EcranW - s); // la nouvelle page arrive par la gauche
  } else {
    int16_t dy = int16_t(TransDY0 * (1.0f - p));
    if (dy == 0)
      dy = (TransDY0 > 0) ? 1 : -1;
    PageDeltaY = dy; // reste non nul pendant l'animation (PageTableauLiveDY attend 0)
    ComposerTransitionY(PageAvant, CanvaRef->getFramebuffer(), dy);
  }
}

void EcranPrintln(const String &Mm) {
  SeriePrintln(Mm);
  if (ESP32_Type != CARTE_ECRAN)
    return;
  Ec_Println(Mm); // Voir Messages.cpp
}

void EcranPrint(const String &m) {
  SeriePrint(m);
  if (ESP32_Type != CARTE_ECRAN)
    return;
  Ec_Print(m);
}

bool getTouchPoint(uint16_t &x, uint16_t &y, int16_t &dX, int16_t &dY) {
  bool valide = true;
  uint16_t X0 = x;
  uint16_t Y0 = y;
  uint8_t data[AXS_MAX_TOUCH_NUMBER * 6 + 2] = {0};

  // Define the read command array properly
  const uint8_t read_cmd[11] = {
      0xb5, 0xab, 0xa5, 0x5a, 0x00, 0x00, (uint8_t)((AXS_MAX_TOUCH_NUMBER * 6 + 2) >> 8), (uint8_t)((AXS_MAX_TOUCH_NUMBER * 6 + 2) & 0xff),
      0x00, 0x00, 0x00};

  Wire.beginTransmission(TOUCH_ADDR);
  Wire.write(read_cmd, 11);
  if (Wire.endTransmission() != 0) {
    valide = false;
  } else {

    if (Wire.requestFrom(TOUCH_ADDR, sizeof(data)) != sizeof(data)) {
      valide = false;
    } else {
      for (int i = 0; i < sizeof(data); i++) {
        data[i] = Wire.read();
      }

      if (data[1] > 0 && data[1] <= AXS_MAX_TOUCH_NUMBER) {
        uint16_t rawX = ((data[2] & 0x0F) << 8) | data[3];
        uint16_t rawY = ((data[4] & 0x0F) << 8) | data[5];
        if (rawX > 500 || rawY > 500)
          valide = false;
        switch (rotation) {
        case 0:
          x = rawX;
          y = rawY;
          break;
        case 1:
          y = map(rawX, 0, 320, 320, 0);
          x = rawY;
          break;
        case 2:
          x = map(rawX, 0, 320, 320, 0);
          y = map(rawY, 0, 480, 480, 0);
          break;
        case 3:
          y = rawX;
          x = map(rawY, 0, 480, 480, 0);
          break;
        }

      } else {
        valide = false;
      }
    }
  }
  if (valide) {
    if (dX == 1000) { // ancien pas valide
      dX = 0;
      dY = 0;
    } else {
      dX = x - X0;
      dY = y - Y0;
    }
  } else {
    dX = 1000; // Pas valide
  }
  return valide;
}

void PrintCentre(Arduino_Canvas *canva, const String &S, int16_t X, int16_t Y, uint8_t Sz) {
  int16_t x1, y1;
  uint16_t w, h;
  canva->setTextSize(Sz);
  canva->getTextBounds(utf8ToLatin15(S), 0, 0, &x1, &y1, &w, &h);
  canva->setCursor(X - w / 2, Y);
  canva->print(utf8ToLatin15(S));
}
void PrintGauche(Arduino_Canvas *canva, const String &S, int16_t X, int16_t Y, uint8_t Sz) {
  canva->setTextSize(Sz);
  canva->setCursor(X + 4, Y + 3);
  canva->print(utf8ToLatin15(S));
}
void PrintDroite(Arduino_Canvas *canva, const String &S, int16_t X, int16_t Y, uint8_t Sz) {
  if (X < 0)
    X = canva->width() / 2;
  canva->setTextSize(Sz);
  uint16_t w, h;
  int16_t x1, y1;
  canva->getTextBounds(utf8ToLatin15(S), 0, 0, &x1, &y1, &w, &h);
  canva->setCursor(X - w - 4, Y + 3);
  canva->print(utf8ToLatin15(S));
}

void SetCouleurs() { // A VERIFIER PB 24bits/16 bits

  CoulTexte = RGB565_WHITE;
  CoulFond = RGB565_NAVY;
  CoulBouton = RGB565_WHITE;
  CoulBoutFond = RGB565_LIGHTGREY;
  CoulBoutBord = RGB565_DARKGREY;
  CoulW = RGB565_RED;
  CoulWh = RGB565_YELLOW;
  CoulTabTexte = RGB565_BLACK;
  CoulTabFond = RGB565_LIGHTGREY;
  CoulTabBord = RGB565_DARKGREY;
  CoulSaisieTexte = RGB565_WHITE;
  CoulSaisieFond = RGB565_DARKGREY;
  CoulSaisieBord = RGB565_BLACK;
  CoulTemp = RGB565_GREEN;
  CoulGrTexte = RGB565_WHITE;
  CoulGrFond = RGB565_BLACK;
  CoulMesFond = RGB565_BLACK;
  CoulMesTexte = RGB565_WHITE;
}
// Gestion couleurs
String ULtoHex(unsigned long x) {
  char buffer[15];
  ltoa(x, buffer, 16);
  String S = "000000" + String(buffer);
  int p = S.length();
  S = "#" + S.substring(p - 6); // Format pour HTML color
  return S;
}
unsigned long ConvCouleur(String V) { // Notation CSS en UL
  return strtoul(V.c_str(), NULL, 16);
}
uint16_t HSLtoRGB565(float H, float S, float L) {
  float R, G, B;

  // Normalisation
  H = fmod(H, 360.0f);
  if (H < 0)
    H += 360.0f;

  S = constrain(S, 0.0f, 100.0f) / 100.0f;
  L = constrain(L, 0.0f, 100.0f) / 100.0f;

  if (S == 0.0f) {
    R = G = B = L;
  } else {
    float q = (L < 0.5f) ? L * (1.0f + S) : L + S - L * S;

    float p = 2.0f * L - q;

    auto HueToRGB = [](float p, float q, float t) -> float {
      if (t < 0.0f)
        t += 1.0f;
      if (t > 1.0f)
        t -= 1.0f;

      if (t < 1.0f / 6.0f)
        return p + (q - p) * 6.0f * t;
      if (t < 1.0f / 2.0f)
        return q;
      if (t < 2.0f / 3.0f)
        return p + (q - p) * (2.0f / 3.0f - t) * 6.0f;

      return p;
    };

    float h = H / 360.0f;

    R = HueToRGB(p, q, h + 1.0f / 3.0f);
    G = HueToRGB(p, q, h);
    B = HueToRGB(p, q, h - 1.0f / 3.0f);
  }

  // Conversion en RGB565
  uint8_t r = (uint8_t)(R * 255.0f);
  uint8_t g = (uint8_t)(G * 255.0f);
  uint8_t b = (uint8_t)(B * 255.0f);

  return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}

//========= GESTION DES BOUTONS =========================
bool Bouton_Appui(Bouton &b, int16_t Tx, int16_t Ty) {
  bool touche(Tx >= b.X0 && Tx <= (b.X0 + b.W) && Ty >= b.Y0 && Ty <= (b.Y0 + b.H));
  if (touche) // Passe le bouton en bleu pendant 120ms pour un retour visuel de l'appui
  {
    CanvaRef->fillRoundRect(b.X0, b.Y0, b.W, b.H, 8, RGB565_BLUE);
    AfficherRef(); // memcpy + flush (CanvaRef a la même organisation que CanvaBase)
    delay(120);
    Bouton_Trace(b, RGB565_WHITE);
    AfficherRef();
  }

  return touche;
}

void Bouton_Trace(Bouton &B, uint16_t colorBord) {
  CanvaRef->fillRoundRect(B.X0, B.Y0, B.W, B.H, 8, RGB565_BLACK);
  CanvaRef->drawRoundRect(B.X0, B.Y0, B.W, B.H, 8, colorBord);
  CanvaRef->setFont(u8g2_font_10x20_mf);
  CanvaRef->setTextColor(RGB565_WHITE);
  int16_t x1, y1;
  uint16_t w, h;
  CanvaRef->getTextBounds(utf8ToLatin15(B.Texte), 0, 0, &x1, &y1, &w, &h);
  PrintCentre(CanvaRef, B.Texte, B.X0 + B.W / 2, B.Y0 + (B.H + h) / 2 - 2, 1);
}


Ecran.h
Réglages TRANSITION_MS, TRANSITION_Y_MS, FRAME_INTERVAL_US
Code :
#pragma once
#include <Arduino.h>
#include <Arduino_GFX_Library.h>

// Pin definitions
#define GFX_BL 1
#define TOUCH_ADDR 0x3B
#define TOUCH_SDA 4
#define TOUCH_SCL 8
#define TOUCH_I2C_CLOCK 400000
#define TOUCH_RST_PIN 12
#define TOUCH_INT_PIN 11
#define AXS_MAX_TOUCH_NUMBER 1

// Transitions de pages (animées en rotation 1 ou 3, instantanées en 0 ou 2)
#define TRANSITION_MS 450         // glissement horizontal entre pages
#define TRANSITION_Y_MS 250       // glissement vertical (page Tableau)
#define FRAME_INTERVAL_US 33333   // 30 images/s max (16667 pour 60 images/s)

//Pages ecran
#define PAGE_TABLEAU 0
#define PAGE_GRAPH_10MN 1
#define PAGE_GRAPH_48H 2
#define PAGE_OUVRE_10MN 3
#define PAGE_OUVRE_48H 4
#define PAGE_TEMPERATURES 5
#define PAGE_MESSAGES 6
#define PAGE_GAUGES 7


//Paramètres écran
extern byte rotation;
extern unsigned long DurEcran ;
extern int16_t EcranW, EcranH;
extern int16_t PageOld, PageActu , PageDelta , PageTotal ,PageDeltaY;
extern uint16_t CoulTexte, CoulFond, CoulBouton, CoulBoutFond, CoulBoutBord, CoulW, CoulWh, CoulTabTexte, CoulTabFond, CoulTabBord;
extern uint16_t CoulSaisieTexte, CoulSaisieFond, CoulSaisieBord, CoulTemp, CoulGrTexte, CoulGrFond, CoulMesFond, CoulMesTexte;
extern EXT_RAM_BSS_ATTR char MessageEcran[8192];

extern EXT_RAM_BSS_ATTR Arduino_Canvas *CanvaBase;
extern EXT_RAM_BSS_ATTR Arduino_Canvas *CanvaRef;


void Init_Ecran(void);
void Ecran_Loop();
void SetCouleurs();
void EcranPrintln(const String &Mm);
void EcranPrint(const String &Mm);

void PrintCentre(Arduino_Canvas *canva, const String &S, int16_t X, int16_t Y, uint8_t Sz);
void PrintGauche(Arduino_Canvas *canva, const String &S, int16_t X, int16_t Y, uint8_t Sz);
void PrintDroite(Arduino_Canvas *canva, const String &S, int16_t X, int16_t Y, uint8_t Sz);

uint16_t HSLtoRGB565(float H, float S, float L);

// Structure Boutons
struct Bouton
{ // pour les boutons noirs
    int16_t X0;
    int16_t Y0;
    int16_t W;
    int16_t H;
    String Texte;
};
bool Bouton_Appui(Bouton &b, int16_t x, int16_t y);
void Bouton_Trace(Bouton &B,uint16_t colorBord );




Messages.cpp
Ajout de PageMessagesForce()
Code :
#include "Ecrans/pagesEcran/Messages.h"
#include "Ecrans/Ecran.h"
#include "commonFX.h"
#include "config.h"

static uint16_t compteurLoopMessage = 0, MesIdxDebut = 0, MesIdxFin = 0;
EXT_RAM_BSS_ATTR char MessageEcran[8192];

void PageMessages();
void PageMessagesLive();
void PageMessagesLiveDY(int16_t DeltaTouchY);
void PageMessagesForce();
void Ec_Println(const String &Mm);
void Ec_Print(const String &m);

void PageMessages() {
  CanvaRef->fillScreen(CoulFond);
}
void PageMessagesLiveDY(int16_t DeltaTouchY) { // ON a un defile vertical du doigt
  if (abs(DeltaTouchY) > 30) {                 // Messages
    int16_t deltaLigne = abs(int(DeltaTouchY / 10));
    while (MesIdxDebut != MesIdxFin && deltaLigne != 0) {
      if (MessageEcran[MesIdxDebut] == '\n')
        deltaLigne--;
      if (DeltaTouchY < 0) {
        MesIdxDebut = (MesIdxDebut + 1) & 0x1FFF;
      } else {
        MesIdxDebut = (MesIdxDebut - 1) & 0x1FFF;
      }
    }
    compteurLoopMessage = 0;
    PageMessagesLive();      // On trace les messages à l'écran
    compteurLoopMessage = 2; // pour mettre en pause le défilement
  }
}

// Tracé immédiat des messages (utilisé au changement de page)
void PageMessagesForce() {
  compteurLoopMessage = 0;
  PageMessagesLive();
}

void PageMessagesLive() {

  compteurLoopMessage = (compteurLoopMessage + 1) & 0x1F;
  if (compteurLoopMessage == 1) {
    int16_t EcranH20;
    EcranH20 = EcranH - 20;
    CanvaRef->setFont(u8g2_font_6x10_tf);
    CanvaRef->setTextSize(1);
    CanvaRef->setTextColor(CoulMesTexte);
    CanvaRef->setTextWrap(true);
    int16_t p = -1;
    CanvaRef->fillRect(0, 20, EcranW, EcranH20, CoulMesFond);
    CanvaRef->setCursor(0, 40);
    uint16_t idx = MesIdxDebut;
    while (idx != MesIdxFin && CanvaRef->getCursorY() < EcranH20) {
      CanvaRef->print(MessageEcran[idx]);
      if (p == -1 && MessageEcran[idx] == '\n')
        p = idx;
      idx++;
      idx = idx & 0x1FFF;
    }
    if (CanvaRef->getCursorY() >= EcranH20) {
      p++;
      p = p & 0x1FFF;
      MesIdxDebut = p; // Ligne d'après
      CanvaRef->fillRect(0, 0, EcranW, 20, CoulFond);
      CanvaRef->setFont(u8g2_font_10x20_tf);
      PrintCentre(CanvaRef, "MESSAGES", CanvaRef->width() / 2, 17, 1);
      compteurLoopMessage = 0;
    }
  }
}

void Ec_Println(const String &Mm) {
  String M_Latin = utf8ToLatin15(Mm);
  for (int i = 0; i < M_Latin.length(); i++) {
    MessageEcran[MesIdxFin] = M_Latin.charAt(i);
    MesIdxFin++;
    MesIdxFin = MesIdxFin & 0x1FFF;
  }
  MessageEcran[MesIdxFin] = '\n';
  MesIdxFin++;
  MesIdxFin = MesIdxFin & 0x1FFF;
  compteurLoopMessage = 0;
}
void Ec_Print(const String &m) {
  String M_Latin = utf8ToLatin15(m);
  for (int i = 0; i < M_Latin.length(); i++) {
    MessageEcran[MesIdxFin] = M_Latin.charAt(i);
    MesIdxFin++;
    MesIdxFin = MesIdxFin & 0x1FFF;
  }
}


Messages.h
Déclaration de PageMessagesForce()
Code :
#pragma once
#include <Arduino.h>
#include <Arduino_GFX_Library.h>



void PageMessages();
void PageMessagesLive();
void PageMessagesLiveDY(int16_t DeltaTouchY);
void PageMessagesForce();
void Ec_Println(const String &Mm);
void Ec_Print(const String &m);
Répondre



Atteindre :


Utilisateur(s) parcourant ce sujet :
1 visiteur(s)

Moteur MyBB, © 2002-2026 Melroy van den Berg.