Module StepDown LM2596 (exemple d'application)

{
  "meta": {
    "symbol": "AAPL",
    "interval": "15min"
  },
  "values": [
    {
      "datetime": "2026-07-24 09:30:00",
      "open": "212.41",
      "high": "213.02",
      "low": "212.20",
      "close": "212.88",
      "volume": "1840233"
    }
  ],
  "status": "ok"
}

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>

#define TFT_CS 15
#define TFT_DC 2
#define TFT_RST 4

Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);

void setup() {
  tft.begin();
  tft.setRotation(3); // Format paysage 320 x 240 ; avec 1, l'image est à l'envers
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_GREEN);
  tft.setTextSize(3);
  tft.setCursor(20, 100);
  tft.print("Display laeuft!");
}

void loop() {}

/* ============================================================
ESP32 Ticker boursier avec historique des cours
Display : 2,4" TFT ILI9341 (Adafruit_GFX / Adafruit_ILI9341)
Cours   : finnhub.io – Cours en direct, 60 requêtes/minute
Historique : twelvedata.com – Bougies intraday pour le graphique
============================================================ */

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <time.h>
#include <Fonts/FreeSans9pt7b.h>
#include <Fonts/FreeSans12pt7b.h>
#include <Fonts/FreeSansBold24pt7b.h>

// ---------- Broches de l'écran ----------
#define TFT_CS 15
#define TFT_DC 2
#define TFT_RST 4

// MOSI 23, SCK 18, MISO 19 = SPI matériel, utilisé automatiquement
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);

// ============ À ADAPTER ICI =================================
const char* WIFI_SSID   = "MEIN_WLAN";
const char* WIFI_PASS   = "MEIN_PASSWORT";
const char* FINNHUB_KEY = "MEIN_FINNHUB_KEY";
const char* TWELVE_KEY  = "MEIN_TWELVEDATA_KEY";

struct Symbol { const char* ticker; const char* name; };

// Votre watchlist – ajoutez ou supprimez des lignes, le reste s'adapte
const Symbol watchlist[] = {
  { "AAPL", "Apple" },
  { "MSFT", "Microsoft" },
  { "NVDA", "NVIDIA" },
  { "AMZN", "Amazon" },
  { "TSLA", "Tesla" }
};

// ============================================================
const uint8_t ANZAHL = sizeof(watchlist) / sizeof(watchlist[0]);

// Fuseau horaire Allemagne avec passage automatique à l'heure d'été
const char* TZ_INFO = "CET-1CEST,M3.5.0/02,M10.5.0/03";
const char* NTP_SERVER = "pool.ntp.org";

const uint32_t KURS_INTERVALL    = 60000;  // 1 min – Cours en direct (Finnhub)
const uint32_t CHART_INTERVALL   = 240000; // 4 min – un graphique (Twelve Data)
const uint32_t WECHSEL_INTERVALL = 8000;   // 8 s – valeur suivante de la liste

#define MAX_PUNKTE 26 // Points de données dans le graphique (26 x 15 min = 1 journée de trading)

// Données d'exécution, remplies par le programme
struct Daten {
  float kurs;
  float diff;
  float proz;
  bool gueltig;
  float verlauf[MAX_PUNKTE];
  uint8_t punkte;
};

Daten daten[ANZAHL]; // global -> démarre automatiquement avec des zéros

// ---------- Couleurs (RGB565) ----------
#define FARBE_BG       0x0862 // presque noir
#define FARBE_BAR      0x1105 // barre d'en-tête
#define FARBE_TEXT     0xFFFF // blanc
#define FARBE_GRAU     0x7C52 // texte secondaire
#define FARBE_LINIE    0x39C7 // ligne auxiliaire dans le graphique
#define FARBE_GRUEN    0x2610 // en hausse
#define FARBE_ROT      0xE267 // en baisse
#define FARBE_GRUEN_BG 0x09C5 // surface de remplissage sous la courbe
#define FARBE_ROT_BG   0x38A2

// ---------- Mise en page ----------
#define BREITE  320
#define HOEHE   240
#define KOPF_H  28
#define CHART_X 12
#define CHART_Y 152
#define CHART_W 296
#define CHART_H 60

uint32_t tKurse = 0;
uint32_t tChart = 0;
uint32_t tWechsel = 0;
uint8_t anzeigeIndex = 0; // valeur actuellement affichée
uint8_t chartIndex = 0;   // prochain graphique à mettre à jour
int letzteSekunde = -1;

// ===========================================================
void setup() {
  Serial.begin(115200);
  delay(200);

  tft.begin();
  tft.setSPISpeed(40000000); // 40 MHz ; en cas de perturbations d'image, réduire à 24000000
  tft.setRotation(3);        // Format paysage 320 x 240 (1 = tourné de 180 degrés)

  statusText("Connexion au Wi-Fi ...");
  wifiVerbinden();

  configTzTime(TZ_INFO, NTP_SERVER);

  statusText("Récupération des cours ...");
  kurseAktualisieren();

  statusText("Chargement des graphiques ...");
  for (uint8_t i = 0; i < ANZAHL; i++) {
    chartAktualisieren(i);
    delay(1000); // Twelve Data autorise 8 requêtes par minute
  }

  tft.fillScreen(FARBE_BG);
  kopfzeileZeichnen();
  wertZeichnen(anzeigeIndex);

  tKurse = tChart = tWechsel = millis();
}

// ===========================================================
void loop() {
  uint32_t jetzt = millis();

  // Cours en direct de tous les symboles
  if (jetzt - tKurse >= KURS_INTERVALL) {
    tKurse = jetzt;
    kurseAktualisieren();
    wertZeichnen(anzeigeIndex);
  }

  // Charger un graphique à tour de rôle
  if (jetzt - tChart >= CHART_INTERVALL) {
    tChart = jetzt;
    chartAktualisieren(chartIndex);
    if (chartIndex == anzeigeIndex) wertZeichnen(anzeigeIndex);
    chartIndex = (chartIndex + 1) % ANZAHL;
  }

  // Passer à la valeur suivante
  if (jetzt - tWechsel >= WECHSEL_INTERVALL) {
    tWechsel = jetzt;
    anzeigeIndex = (anzeigeIndex + 1) % ANZAHL;
    wertZeichnen(anzeigeIndex);
  }

  uhrzeitZeichnen();
  delay(50);
}

// ===========================================================
// Wi-Fi
// ===========================================================
void wifiVerbinden() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  uint8_t versuche = 0;
  while (WiFi.status() != WL_CONNECTED && versuche < 40) {
    delay(500);
    Serial.print(".");
    versuche++;
  }
  Serial.println();
  if (WiFi.status() == WL_CONNECTED) {
    Serial.print("Connecté. IP : ");
    Serial.println(WiFi.localIP());
  } else {
    Serial.println("Échec de la connexion Wi-Fi.");
    statusText("Pas de Wi-Fi !");
  }
}

// ===========================================================
// Cours en direct de Finnhub
// ===========================================================
void kurseAktualisieren() {
  if (WiFi.status() != WL_CONNECTED) {
    wifiVerbinden();
    if (WiFi.status() != WL_CONNECTED) return;
  }

  for (uint8_t i = 0; i < ANZAHL; i++) {
    String url = String("https://finnhub.io/api/v1/quote?symbol=")
               + watchlist[i].ticker + "&token=" + FINNHUB_KEY;

    WiFiClientSecure client;
    client.setInsecure(); // sans vérification de certificat – suffisant ici

    HTTPClient https;
    https.setTimeout(8000);

    if (https.begin(client, url)) {
      int code = https.GET();
      if (code == HTTP_CODE_OK) {
        JsonDocument doc;
        DeserializationError fehler = deserializeJson(doc, https.getString());
        if (!fehler) {
          daten[i].kurs   = doc["c"] | 0.0f;
          daten[i].diff   = doc["d"] | 0.0f;
          daten[i].proz   = doc["dp"] | 0.0f;
          daten[i].gueltig = (daten[i].kurs > 0);
          Serial.printf("%-6s %8.2f (%+.2f%%)\n", watchlist[i].ticker, daten[i].kurs, daten[i].proz);
        } else {
          Serial.printf("Erreur JSON pour %s : %s\n", watchlist[i].ticker, fehler.c_str());
        }
      } else {
        Serial.printf("Finnhub HTTP %d pour %s\n", code, watchlist[i].ticker);
      }
      https.end();
    }
    delay(250);
  }
}

// ===========================================================
// Historique des cours de Twelve Data
// ===========================================================
void chartAktualisieren(uint8_t i) {
  if (WiFi.status() != WL_CONNECTED) return;

  String url = String("https://api.twelvedata.com/time_series?symbol=")
             + watchlist[i].ticker
             + "&interval=15min&outputsize=" + String(MAX_PUNKTE)
             + "&order=ASC&apikey=" + TWELVE_KEY;

  WiFiClientSecure client;
  client.setInsecure();

  HTTPClient https;
  https.setTimeout(10000);

  if (!https.begin(client, url)) {
    Serial.println("TwelveData : échec de la connexion");
    return;
  }

  int code = https.GET();
  if (code != HTTP_CODE_OK) {
    Serial.printf("TwelveData HTTP %d pour %s\n", code, watchlist[i].ticker);
    https.end();
    return;
  }

  // Lire complètement au lieu d'analyser directement depuis le flux : Twelve Data
  // répond selon la taille avec "chunked transfer encoding", ce qui ferait échouer
  // un analyseur lisant directement.
  String antwort = https.getString();
  https.end();

  // Filtre : ne conserver que "close" par entrée ainsi que le statut et le message d'erreur
  JsonDocument filter;
  filter["values"][0]["close"] = true;
  filter["status"] = true;
  filter["message"] = true;

  JsonDocument doc;
  DeserializationError fehler = deserializeJson(doc, antwort, DeserializationOption::Filter(filter));

  if (fehler) {
    Serial.printf("Erreur JSON du graphique pour %s : %s\n", watchlist[i].ticker, fehler.c_str());
    return;
  }

  // Important : Twelve Data signale souvent les erreurs avec HTTP 200 dans le corps JSON
  const char* status = doc["status"] | "";
  if (strcmp(status, "ok") != 0) {
    Serial.printf("TwelveData signale une erreur pour %s : %s\n", watchlist[i].ticker, doc["message"] | "inconnu");
    return;
  }

  uint8_t k = 0;
  for (JsonObject eintrag : doc["values"].as<JsonArray>()) {
    if (k >= MAX_PUNKTE) break;
    daten[i].verlauf[k++] = eintrag["close"].as<float>();
  }
  daten[i].punkte = k;

  Serial.printf("Graphique %s : %d points\n", watchlist[i].ticker, k);
}

// ===========================================================
// Affichage
// ===========================================================
void kopfzeileZeichnen() {
  tft.fillRect(0, 0, BREITE, KOPF_H, FARBE_BAR);
  textAn(12, 19, "TICKER BOURSIER", &FreeSans9pt7b, FARBE_TEXT);
}

void wertZeichnen(uint8_t i) {
  char puffer[32];
  tft.fillRect(0, KOPF_H, BREITE, HOEHE - KOPF_H, FARBE_BG);

  // Nom de l'entreprise et symbole boursier
  textAn(12, 52, watchlist[i].name, &FreeSans12pt7b, FARBE_TEXT);
  textAn(12, 74, watchlist[i].ticker, &FreeSans9pt7b, FARBE_GRAU);

  if (!daten[i].gueltig) {
    textAn(12, 118, "pas de données", &FreeSans12pt7b, FARBE_GRAU);
    punkteZeichnen(i);
    return;
  }

  uint16_t farbe = (daten[i].diff >= 0) ? FARBE_GRUEN : FARBE_ROT;

  // Cours, grand
  snprintf(puffer, sizeof(puffer), "%.2f", daten[i].kurs);
  textAn(12, 122, puffer, &FreeSansBold24pt7b, FARBE_TEXT);

  // Variation, en couleur
  snprintf(puffer, sizeof(puffer), "%+.2f (%+.2f%%)", daten[i].diff, daten[i].proz);
  textAn(12, 146, puffer, &FreeSans12pt7b, farbe);

  // Triangle comme flèche directionnelle
  if (daten[i].diff >= 0)
    tft.fillTriangle(292, 92, 278, 116, 306, 116, farbe);
  else
    tft.fillTriangle(292, 116, 278, 92, 306, 92, farbe);

  chartZeichnen(i);
  punkteZeichnen(i);
}

// ---------- Historique des cours ----------
void chartZeichnen(uint8_t i) {
  tft.fillRect(CHART_X, CHART_Y, CHART_W, CHART_H, FARBE_BG);

  uint8_t n = daten[i].punkte;
  if (n < 2) {
    textAn(CHART_X, CHART_Y + 34, "Historique non disponible", &FreeSans9pt7b, FARBE_GRAU);
    return;
  }

  // Déterminer la plage de valeurs – la clôture de la veille doit toujours être visible,
  // afin que la ligne zéro ne sorte pas de l'image
  float vortag = daten[i].kurs - daten[i].diff;
  float minWert = daten[i].verlauf[0];
  float maxWert = daten[i].verlauf[0];

  for (uint8_t k = 1; k < n; k++) {
    if (daten[i].verlauf[k] < minWert) minWert = daten[i].verlauf[k];
    if (daten[i].verlauf[k] > maxWert) maxWert = daten[i].verlauf[k];
  }

  if (vortag < minWert) minWert = vortag;
  if (vortag > maxWert) maxWert = vortag;

  float spanne = maxWert - minWert;
  if (spanne < 0.0001f) spanne = 1.0f; // Éviter la division par zéro

  // Ligne en pointillés à la hauteur de la clôture de la veille
  int yVortag = CHART_Y + CHART_H - 1 - (int)((vortag - minWert) / spanne * (CHART_H - 1));
  for (int x = CHART_X; x < CHART_X + CHART_W; x += 6) {
    tft.drawFastHLine(x, yVortag, 3, FARBE_LINIE);
  }

  // Calculer les coordonnées écran de tous les points
  int px[MAX_PUNKTE], py[MAX_PUNKTE];
  for (uint8_t k = 0; k < n; k++) {
    px[k] = CHART_X + (int)((float)k * (CHART_W - 1) / (n - 1));
    py[k] = CHART_Y + CHART_H - 1 - (int)((daten[i].verlauf[k] - minWert) / spanne * (CHART_H - 1));
  }

  uint16_t linie  = (daten[i].diff >= 0) ? FARBE_GRUEN : FARBE_ROT;
  uint16_t flaeche = (daten[i].diff >= 0) ? FARBE_GRUEN_BG : FARBE_ROT_BG;

  // Passage 1 : Remplir la surface sous la courbe
  for (uint8_t k = 1; k < n; k++) {
    for (int x = px[k - 1]; x <= px[k]; x++) {
      int y = py[k - 1];
      if (px[k] != px[k - 1]) {
        y += (py[k] - py[k - 1]) * (x - px[k - 1]) / (px[k] - px[k - 1]);
      }
      tft.drawFastVLine(x, y, CHART_Y + CHART_H - y, flaeche);
    }
  }

  // Passage 2 : Dessiner la courbe par-dessus
  for (uint8_t k = 1; k < n; k++) {
    tft.drawLine(px[k - 1], py[k - 1], px[k], py[k], linie);
  }
}

void punkteZeichnen(uint8_t aktiv) {
  int x = BREITE / 2 - ((ANZAHL - 1) * 14) / 2;
  for (uint8_t k = 0; k < ANZAHL; k++) {
    tft.fillCircle(x + k * 14, 228, 3, (k == aktiv) ? FARBE_TEXT : FARBE_GRAU);
  }
}

void uhrzeitZeichnen() {
  struct tm zeit;
  if (!getLocalTime(&zeit, 0)) return;
  if (zeit.tm_sec == letzteSekunde) return; // une seule fois par seconde
  letzteSekunde = zeit.tm_sec;

  char puffer[12];
  strftime(puffer, sizeof(puffer), "%H:%M:%S", &zeit);

  // Police intégrée : peut remplir l'arrière-plan en même temps -> pas de scintillement
  tft.setFont();
  tft.setTextSize(2);
  tft.setTextColor(FARBE_TEXT, FARBE_BAR);
  tft.setCursor(BREITE - 88 - 12, 6);
  tft.print(puffer);
  tft.setTextSize(1);
}

// ---------- Petites fonctions utilitaires ----------
void textAn(int x, int grundlinie, const char* txt, const GFXfont* font, uint16_t farbe) {
  tft.setFont(font);
  tft.setTextSize(1);
  tft.setTextColor(farbe);
  tft.setCursor(x, grundlinie); // avec les polices GFX, y est la ligne de base
  tft.print(txt);
}

void statusText(const char* txt) {
  tft.fillScreen(FARBE_BG);
  textAn(20, 125, txt, &FreeSans12pt7b, FARBE_TEXT);
}