Écran SPI et game loop

// Ecran TFT ST7789 240x320 (connecteur J1)
constexpr int PIN_TFT_RESET = D7;
constexpr int PIN_TFT_DC    = D8;   // Data/Command : 0 = commande, 1 = donnée
constexpr int PIN_TFT_SCK   = D9;   // Horloge SPI
constexpr int PIN_TFT_MOSI  = D10;  // Données SPI (microcontrôleur -> écran)
constexpr int PIN_TFT_CS    = -1;   // CS est relié à GND sur la carte : l'écran
                                    // est toujours sélectionné (-1 = pas de broche)

constexpr uint32_t TFT_SPI_FREQUENCY = 40000000;  // 40 MHz

// Rotation 0 = portrait, 2 = portrait retourné de 180 degrés
constexpr int SCREEN_ROTATION = 2;
constexpr int SCREEN_WIDTH    = 240;
constexpr int SCREEN_HEIGHT   = 320;

#include <Arduino.h>
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>

#include "config.h"

Adafruit_ST7789 tft(&SPI, PIN_TFT_CS, PIN_TFT_DC, PIN_TFT_RESET);

void setup() {
    // Broches SPI du PCB (pas de MISO : l'écran ne renvoie rien)
    SPI.begin(PIN_TFT_SCK, -1, PIN_TFT_MOSI, PIN_TFT_CS);

    tft.init(SCREEN_WIDTH, SCREEN_HEIGHT, SPI_MODE3);
    tft.setSPISpeed(TFT_SPI_FREQUENCY);
    tft.setRotation(SCREEN_ROTATION);
    tft.fillScreen(ST77XX_BLACK);

    tft.setTextSize(4);                 // police de 6 x 8 pixels, multipliée par 4
    tft.setTextColor(ST77XX_WHITE);
    tft.setCursor(72, 40);              // (240 - 4 lettres x 6 x 4) / 2 = 72 : centré
    tft.print("PONG");

    tft.drawRect(20, 120, 200, 60, ST77XX_WHITE);   // rectangle (contour)
    tft.fillCircle(120, 250, 20, ST77XX_YELLOW);    // disque (plein)
}

void loop() {}

constexpr uint32_t FRAME_TIME_MS = 16;  // Durée d'une image : ~60 images/s

void update(float joystickX) {
    // 2. Calculer la nouvelle image (étapes 4 et 5)
}

void draw() {
    // 3. L'afficher (étapes 4 et 5)
}

void loop() {
    static uint32_t lastFrameMs = 0;   // static : garde sa valeur d'un tour à l'autre
    uint32_t nowMs = millis();
    if (nowMs - lastFrameMs < FRAME_TIME_MS) {
        return;
    }
    lastFrameMs = nowMs;

    float joystickX = normalizeJoystick(analogRead(PIN_JOYSTICK_X), joystickCenterX);  // 1. Lire
    update(joystickX);                 // 2. Calculer
    draw();                            // 3. Afficher
}

// include/config.h
constexpr int   PADDLE_WIDTH     = 40;
constexpr int   PADDLE_HEIGHT    = 6;
constexpr int   PADDLE_MARGIN    = 10;    // Distance entre la raquette et le bord
constexpr float PADDLE_MAX_SPEED = 5.0f;  // En pixels par image

// src/main.cpp
constexpr int PADDLE_Y = SCREEN_HEIGHT - PADDLE_MARGIN - PADDLE_HEIGHT;

float paddleX = (SCREEN_WIDTH - PADDLE_WIDTH) / 2.0f;  // position calculée
int   drawnPaddleX = (int)paddleX;                     // position affichée

void update(float joystickX) {
    paddleX += joystickX * PADDLE_MAX_SPEED;
    paddleX = constrain(paddleX, 0.0f, (float)(SCREEN_WIDTH - PADDLE_WIDTH));
}

void draw() {
    int x = (int)paddleX;
    if (x != drawnPaddleX) {
        tft.fillRect(drawnPaddleX, PADDLE_Y, PADDLE_WIDTH, PADDLE_HEIGHT, ST77XX_BLACK);  // effacer
        tft.fillRect(x, PADDLE_Y, PADDLE_WIDTH, PADDLE_HEIGHT, ST77XX_WHITE);             // dessiner
        drawnPaddleX = x;
    }
}

// include/config.h
constexpr int BALL_SIZE = 6;

// src/main.cpp
float ballX  = (SCREEN_WIDTH - BALL_SIZE) / 2.0f;
float ballY  = (SCREEN_HEIGHT - BALL_SIZE) / 2.0f;
float ballVX = 2.0f;  // pixels par image
float ballVY = 3.0f;

int drawnBallX = (int)ballX;
int drawnBallY = (int)ballY;

void moveBall() {
    ballX += ballVX;
    ballY += ballVY;

    if (ballX < 0) {
        ballX = 0;
        ballVX = -ballVX;
    } else if (ballX + BALL_SIZE > SCREEN_WIDTH) {
        ballX = SCREEN_WIDTH - BALL_SIZE;
        ballVX = -ballVX;
    }

    if (ballY < 0) {
        ballY = 0;
        ballVY = -ballVY;
    } else if (ballY + BALL_SIZE > SCREEN_HEIGHT) {
        ballY = SCREEN_HEIGHT - BALL_SIZE;
        ballVY = -ballVY;
    }
}

void drawBall() {
    int x = (int)ballX;
    int y = (int)ballY;
    if (x == drawnBallX && y == drawnBallY) {
        return;
    }
    tft.fillRect(drawnBallX, drawnBallY, BALL_SIZE, BALL_SIZE, ST77XX_BLACK);  // effacer
    tft.fillRect(x, y, BALL_SIZE, BALL_SIZE, ST77XX_WHITE);                    // dessiner
    drawnBallX = x;
    drawnBallY = y;
}