Forum-passionnement

Code : Tout sélectionner

// ============================================================
// User_Setup.h pour écran ST7789 135x240 (1,14") - ESP32
// ============================================================
// A COPIER dans : <dossier_libraries>/TFT_eSPI/User_Setup.h
// (remplacer le contenu existant par un copier/coller)
// ============================================================

#define ST7789_DRIVER

#define TFT_WIDTH  135
#define TFT_HEIGHT 240

// --- Câblage SPI matériel ESP32 (VSPI) ---
#define TFT_MOSI 23   // SDA de l'écran
#define TFT_SCLK 18   // SCL de l'écran
#define TFT_CS   5   // CS
#define TFT_DC   2   // DC (Data/Command)
#define TFT_RST  4   // RES
#define TFT_BL   15   // BLK (rétroéclairage) - optionnel si câblé direct au 3.3V

// Décalage nécessaire sur beaucoup de modules 135x240
// (souvent basés sur un contrôleur pensé pour 240x240,
//  avec un offset de 40 px en Y et 52 px en X)
#define TFT_RGB_ORDER TFT_BGR   // à tester : TFT_RGB si couleurs inversées
#define TFT_BACKLIGHT_ON HIGH   // allume le rétroéclairage 

#define LOAD_GLCD
#define LOAD_FONT2
#define LOAD_FONT4
#define LOAD_FONT6
#define LOAD_FONT7
#define LOAD_FONT8
#define LOAD_GFXFF
#define SMOOTH_FONT

#define SPI_FREQUENCY  27000000
#define SPI_READ_FREQUENCY 20000000

Code : Tout sélectionner

/*
  ============================================================
  Panneau d'affichage de gare HO
  Version 1.11 © Ramasoft Juillet 2026
  - Affichage 4 colonnes : ARRIV / DEP / nom / V, horloge centrée
  - Bandeau d'en-tête et espacement des lignes calculés dynamiquement
  - Ligne séparatrice retracée à chaque rafraîchissement de l'horloge
  ESP32 + écran ST7789 135x240 (SPI) + RTC DS3231 (I2C)
  ============================================================

  Bibliothèques nécessaires :
   - TFT_eSPI          (Bodmer)  -> configurer User_Setup.h (fichier fourni à part)
   - RTClib            (Adafruit)
   - Wire              (incluse avec l'ESP32)

  Câblage :
   Écran ST7789        ESP32    couleur fil
   ------------------------------------------
   VCC        -> 3.3V           rouge
   GND        -> GND            noir
   SCL        -> GPIO18 (SCK)   jaune
   SDA        -> GPIO23 (MOSI)  blanc
   RES        -> GPIO04         bleu
   DC         -> GPIO02         gris
   CS         -> GPIO05         vert
   BLK        -> GPIO15         orange

   RTC DS3231         ESP32
   ---------------------------
   VCC        -> 3.3V           rouge (ou 5V selon module, la plupart acceptent les deux)
   GND        -> GND            noir
   SDA        -> GPIO21         blanc
   SCL        -> GPIO22         jaune
  ============================================================
*/

#include <SPI.h>
#include <TFT_eSPI.h>
#include <Wire.h>
#include <RTClib.h>

TFT_eSPI tft = TFT_eSPI();
RTC_DS3231 rtc;

// Broches I2C explicites (RTC DS3231)
// Ce sont déjà les valeurs par défaut de l'ESP32, mais les préciser
// ici rend le câblage lisible directement dans le sketch.
#define RTC_SDA 21
#define RTC_SCL 22

// Broche de rétroéclairage, pilotée explicitement
#define PIN_BACKLIGHT 15

// ---------- Structure d'un train ----------
struct Train {
  uint8_t heure;          // heure de départ de Châteauroux (0-23) 
  uint8_t minute;         // minute de départ (0-59) 
  const char* nom;        // destination affichée en colonne DEPART
  const char* arrivee;    // heure d'arrivée affichée en colonne ARRIVEE (texte libre, ex "7h12")
  const char* quai;       // voie affichée en colonne V
};

// ---------- Table d'horaires ----------
// A classer par heure croissante, ça simplifie le filtrage ...
Train horaires[] = {
  {  7, 15, "PARIS Austerlitz",     "7h12",  "1" },
  {  7, 42, "TOULOUSE Matabiau",    "7h39",  "3" },
  {  8,  5, "LIMOGES Benedictins",  "8h02",  "3" },
  {  8, 30, "PARIS Capitole",       "8h27",  "2" },
  {  9, 20, "TOULOUSE Capitole",    "9h17",  "1" },
  { 10, 10, "BRIVE Omnibus",        "10h07", "5" },
  { 10, 45, "LIMOGES Benedictins",  "10h42", "4" },
  { 11, 15, "VAL de L'INDRE",       "*****", "6" },
  { 12,  0, "ORLEANS",              "11h57", "2" },
  { 13, 30, "PARIS Austerlitz",     "13h27", "1" },
  { 14, 10, "MONTAUBAN Omnibus",    "14h07", "4" },
  { 14, 35, "VIERZON (NANTES)",     "14h32", "3" },
  { 16, 20, "LIMOGES Benedictins",  "16h17", "5" },
  { 17, 45, "TOULOUSE Matabiau",    "17h42", "3" },
  { 18, 30, "PARIS Austerlitz",     "18h27", "1" },
  { 19,  0, "ORLEANS",              "18h27", "2" },
  { 20, 15, "PARIS Capitole",       "20h12", "1" },
  { 20, 25, "TOULOUSE Capitole",    "20h22", "3" },
};
const int NB_TRAINS = sizeof(horaires) / sizeof(horaires[0]);

// Nombre de lignes de trains affichées simultanément à l'écran
const int LIGNES_AFFICHEES = 6;

// Nombre max de caractères affichés pour le nom de destination
// (au-delà, le nom est tronqué - à ajuster selon le rendu réel à l'écran)
const int NOM_MAX_CAR = 19;

// ---------- Couleurs (RGB565) ----------
#define COL_FOND       TFT_BLACK
#define COL_ENTETE_BG  TFT_NAVY
#define COL_ENTETE_TXT TFT_YELLOW
#define COL_TXT        TFT_WHITE
#define COL_DEPART     TFT_GREENYELLOW  // colonne DEPART (heure de départ locale)
#define COL_ARRIVEE    TFT_ORANGE   // colonne ARRIVEE dans une couleur distincte
#define COL_QUAI       TFT_CYAN
#define COL_HORLOGE    TFT_YELLOW

// ---------- Emplacements des colonnes (à ajuster si ça déborde chez toi) ----------
const int X_ARRIVEE  = 1;   // colonne ARRIVEE (heure d'arrivée)
const int X_NOM      = 46;  // colonne destination (juste après l'heure de départ)
const int X_DEPART   = 180; // colonne DEPART (heure de départ, ex "7h15")
const int X_VOIE     = 236; // colonne V (voie/quai), alignée à droite

const int HAUTEUR_MARGE_BASSE = 4; // marge sous le texte de l'horloge avant la ligne séparatrice

// Ces 3 valeurs ne sont plus des constantes figées : elles sont calculées
// dans setup(), une fois que tft.fontHeight() est utilisable, pour que le
// bandeau d'en-tête et l'espacement des lignes s'adaptent automatiquement
// à la vraie hauteur de la police de l'horloge (plus de débordement possible).
int HAUTEUR_ENTETE;     // hauteur de la bande d'en-tête
int Y_DEBUT_LISTE;      // position Y de la première ligne de train
int HAUTEUR_LIGNE;      // hauteur allouée à chaque ligne de train

const int Y_LABELS        = 10;  // position verticale des libellés d'en-tête
const int Y_HORLOGE_CENTRE = 3; // position verticale de l'horloge (police plus grande)

unsigned long derniereMAJ = 0;
const unsigned long INTERVALLE_MAJ = 1000; // vérifier/rafraîchir l'horloge 1x/seconde

int dernierIndexTrain = -1;   // mémorise le 1er train affiché, pour ne redessiner
                               // la liste que si elle change réellement

void setup() {
  Serial.begin(115200);

  // --- Rétroéclairage piloté explicitement ---
  pinMode(PIN_BACKLIGHT, OUTPUT);
  digitalWrite(PIN_BACKLIGHT, HIGH);

  // --- Init écran ---
  tft.init();
  tft.setRotation(1);       // 1 = paysage (240x135). Essayer 3 si à l'envers => 270°
  tft.fillScreen(COL_FOND);

  // --- Calcul dynamique des hauteurs, à partir de la vraie hauteur de police ---
  int hPoliceHorloge = tft.fontHeight(4);
  HAUTEUR_ENTETE = Y_HORLOGE_CENTRE + hPoliceHorloge + HAUTEUR_MARGE_BASSE;
  Y_DEBUT_LISTE  = HAUTEUR_ENTETE + 3;
  HAUTEUR_LIGNE  = (tft.height() - Y_DEBUT_LISTE) / LIGNES_AFFICHEES;

  // --- Init RTC ---
  Wire.begin(RTC_SDA, RTC_SCL);   // explicite : SDA=GPIO21, SCL=GPIO22

  if (!rtc.begin()) {
    tft.setTextColor(TFT_RED, COL_FOND);
    tft.setTextSize(1);
    tft.drawString("Erreur RTC DS3231 !", 5, 5, 2);
    Serial.println("RTC DS3231 non détecté");
    while (1) delay(1000);
  }

  if (rtc.lostPower()) {
    Serial.println("RTC réinitialisée à l'heure de compilation");
    // Décommenter la ligne suivante UNE FOIS pour régler l'heure
    // (à l'heure de compilation du sketch), puis recommenter
    // l'heure est sauvegardée par la pile
    // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }

  // --- Dessin initial : tout l'écran une seule fois ---
  dessinerEnTeteStatique();
  DateTime maintenant = rtc.now();
  dessinerHorloge(maintenant);
  dernierIndexTrain = trouverPremierTrainFutur(maintenant);
  dessinerListeTrains(dernierIndexTrain);
}

void loop() {
  if (millis() - derniereMAJ >= INTERVALLE_MAJ) {
    derniereMAJ = millis();
    DateTime maintenant = rtc.now();

    // --- L'horloge est la seule chose repeinte chaque seconde ---
    dessinerHorloge(maintenant);

    // --- La liste des trains n'est repeinte QUE si elle change réellement ---
    int idx = trouverPremierTrainFutur(maintenant);
    if (idx != dernierIndexTrain) {
      dernierIndexTrain = idx;
      dessinerListeTrains(idx);
    }
  }
}

// ============================================================
// En-tête STATIQUE : libellés de colonnes + ligne séparatrice
// Dessiné une seule fois dans setup(), jamais réécrit ensuite
// ============================================================
void dessinerEnTeteStatique() {
  tft.fillRect(0, 0, tft.width(), HAUTEUR_ENTETE, COL_ENTETE_BG);
  tft.setTextColor(COL_ENTETE_TXT, COL_ENTETE_BG);

  tft.drawString("Arrivee", X_ARRIVEE, Y_LABELS, 2);
  tft.drawString("Depart", X_DEPART, Y_LABELS, 2);
  tft.drawRightString("V", X_VOIE, Y_LABELS, 2);

  // Ligne séparatrice horizontale, dessinée une seule fois
  tft.drawFastHLine(0, HAUTEUR_ENTETE, tft.width(), TFT_DARKGREY);
}

// ============================================================
// Horloge : SEULE zone repeinte chaque seconde (pas tout l'écran)
// HH:MM en grand (police 4), secondes en petit à côté (police 2,
// même taille que les colonnes DEPART/ARRIV)
// ============================================================
void dessinerHorloge(DateTime &maintenant) {
  char bufHeureMin[6];
  sprintf(bufHeureMin, "%02dh%02d", maintenant.hour(), maintenant.minute());

  char bufSec[4];
  sprintf(bufSec, "%02d", maintenant.second());

  // Zone élargie maintenant que ARRIV a été déplacé à x=180
  const int xZoneDebut = 56;
  const int xZoneFin   = 176;
  tft.fillRect(xZoneDebut, 0, xZoneFin - xZoneDebut, HAUTEUR_ENTETE, COL_ENTETE_BG);

  tft.setTextColor(COL_HORLOGE, COL_ENTETE_BG);

  // Largeurs réelles des deux textes, pour bien centrer l'ensemble
  int largeurGrand  = tft.textWidth(bufHeureMin, 4);
  int largeurPetit  = tft.textWidth(bufSec, 2);
  const int espace  = 5;
  int largeurTotale = largeurGrand + espace + largeurPetit;

  int xDebut = (xZoneDebut + xZoneFin) / 2 - largeurTotale / 2;

  // Heure:minute en grand
  tft.drawString(bufHeureMin, xDebut, Y_HORLOGE_CENTRE, 4);

  // Secondes en petit, alignées vers le bas du grand texte (effet "exposant")
  tft.drawString(bufSec, xDebut + largeurGrand + espace, Y_HORLOGE_CENTRE + 5, 2);

  // On retrace systématiquement la ligne séparatrice : par sécurité, au cas
  // où le texte de l'horloge déborderait légèrement de la zone repeinte
  tft.drawFastHLine(0, HAUTEUR_ENTETE, tft.width(), TFT_DARKGREY);
}

// ============================================================
// Liste des prochains trains - dessinée seulement quand elle change
// ============================================================
void dessinerListeTrains(int indexDepart) {
  // Efface uniquement la zone de la liste (pas l'en-tête)
  tft.fillRect(0, Y_DEBUT_LISTE, tft.width(), tft.height() - Y_DEBUT_LISTE, COL_FOND);

  for (int i = 0; i < LIGNES_AFFICHEES; i++) {
    int idx = (indexDepart + i) % NB_TRAINS;
    int y = Y_DEBUT_LISTE + i * HAUTEUR_LIGNE;

    Train &t = horaires[idx];

    // --- Colonne DEPART (heure de départ locale, ex "7h15") ---
    char bufDepart[6];
    sprintf(bufDepart, "%dh%02d", t.heure, t.minute);
    tft.setTextColor(COL_DEPART, COL_FOND);
    tft.drawString(bufDepart, X_DEPART, y, 2);

    // --- Colonne nom de destination (tronqué si trop long) ---
    tft.setTextColor(COL_TXT, COL_FOND);
    afficherTronque(t.nom, X_NOM, y, NOM_MAX_CAR, 2);

    // --- Colonne ARRIVEE (couleur distincte) ---
    tft.setTextColor(COL_ARRIVEE, COL_FOND);
    tft.drawString(t.arrivee, X_ARRIVEE, y, 2);

    // --- Colonne V (voie/quai) ---
    tft.setTextColor(COL_QUAI, COL_FOND);
    tft.drawRightString(t.quai, X_VOIE, y, 2);
  }
}

// ---------- Affiche une chaîne tronquée à maxLen caractères ----------
void afficherTronque(const char* texte, int x, int y, int maxLen, uint8_t font) {
  char buf[32];
  int len = strlen(texte);
  if (len > maxLen) len = maxLen;
  memcpy(buf, texte, len);
  buf[len] = '\0';
  tft.drawString(buf, x, y, font);
}

// ============================================================
// Trouve l'index du premier train dont l'heure de départ
// est >= à l'heure actuelle. Si aucun (fin de journée),
// reboucle sur le premier train du lendemain.
// ============================================================
int trouverPremierTrainFutur(DateTime &maintenant) {
  int minutesActuelles = maintenant.hour() * 60 + maintenant.minute();

  for (int i = 0; i < NB_TRAINS; i++) {
    int minutesTrain = horaires[i].heure * 60 + horaires[i].minute;
    if (minutesTrain >= minutesActuelles) {
      return i;
    }
  }
  // Tous les trains du jour sont passés -> on reboucle sur le premier
  return 0;
}