(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.
(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.
_________________________________________________
Routeur Solaire en v17.30 (modifié avec écran OLED)
Pilotage d'un cumulus de 3kW + Jeedom v4.6.2 + Station solaire 3,5kW
(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.
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.
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
// ===== 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
// 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");
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;
}
}
// 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);
}
}
//========= 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();
}