Le radar contre-attaque

// Mission 4 · L'enquête : tape une valeur de 0 à 180 dans le moniteur série
// et observe ce que fait le servo EF10155.
#include <ESP32Servo.h>

const int PIN_SERVO = 18;
Servo servo;

void setup() {
  Serial.begin(115200);
  servo.setPeriodHertz(50);
  servo.attach(PIN_SERVO, 500, 2500);
  servo.write(90);                                   // on commence au milieu
  Serial.println("Enquête prête. Tape une valeur entre 0 et 180, puis Entrée.");
}

void loop() {
  if (Serial.available()) {
    String ligne = Serial.readStringUntil('\n');
    ligne.trim();
    if (ligne.length() == 0) return;
    int valeur = constrain(ligne.toInt(), 0, 180);
    servo.write(valeur);
    Serial.printf("→ write(%d)\n", valeur);
  }
}

// Mission 4 · Naboucle : le radar à balayage
// Verdict de l'enquête : notre EF10155 est un servo À POSITION, sur environ un tour (360°).
// R2 / L2 : tourner le radar à la main, plus ou moins vite selon l'appui.
// △ : balayage automatique (aller-retour entre les deux bords). R1 : retour au centre.
// ↑ ↓ : vitesse du balayage. ← → : largeur du balayage.

#include <Bluepad32.h>
#include <ESP32Servo.h>

// ================= Réglages =================
const int PIN_SERVO = 18;
const int US_MIN = 500;            // impulsion pour 0°    (comme dans le programme d'enquête)
const int US_MAX = 2500;           // impulsion pour 360°
const int CENTRE = 180;            // le milieu de la course, en degrés : l'antenne regarde devant
const int ECART_MAX = 90;          // sécurité : jamais plus de 90° de chaque côté du centre
                                   // (impulsions de 1 000 à 2 000 µs), tant qu'on n'a pas réglé

Servo radar;
ControllerPtr manette = nullptr;

float angle = CENTRE;              // où est le radar, en degrés
int demiLargeur = 60;              // le balayage va de CENTRE - demiLargeur à CENTRE + demiLargeur
int vitesseAuto = 45;              // vitesse du balayage, en degrés par seconde
bool automatique = false;          // le radar balaie-t-il tout seul ?
bool retourCentre = false;         // R1 : on rentre au centre
int sensAuto = 1;                  // +1 : vers la droite, -1 : vers la gauche
int sensPrecedent = 99;            // pour ne recolorer la barre que si ça change
unsigned long dernierTemps = 0;

enum { B_TRIANGLE, B_R1, B_HAUT, B_BAS, B_GAUCHE, B_DROITE, NB_BOUTONS };
bool avant[NB_BOUTONS];

bool vientDAppuyer(int numero, bool appuye) {
  bool nouveau = appuye && !avant[numero];
  avant[numero] = appuye;
  return nouveau;
}

int versMicrosecondes(float a) {
  return US_MIN + (int)(a * (US_MAX - US_MIN) / 360);
}

// ================= Connexion =================
void onConnectedController(ControllerPtr ctl) {
  if (manette != nullptr) return;
  manette = ctl;
  sensPrecedent = 99;
  Serial.println("🎮 Manette connectée : le radar est prêt.");
}

void onDisconnectedController(ControllerPtr ctl) {
  if (manette == ctl) {
    manette = nullptr;
    automatique = false;
    Serial.println("❌ Manette déconnectée : le radar s'arrête.");
  }
}

// ================= Lecture de la manette =================
void lireManette() {
  if (vientDAppuyer(B_TRIANGLE, manette->y())) {
    automatique = !automatique;
    retourCentre = false;
    Serial.println(automatique ? "△ Balayage automatique : marche" : "△ Balayage automatique : arrêt");
  }
  if (vientDAppuyer(B_R1, manette->r1())) {
    automatique = false;
    retourCentre = true;
    Serial.println("R1 : retour au centre");
  }

  uint8_t f = manette->dpad();
  if (vientDAppuyer(B_HAUT, f & DPAD_UP))      { vitesseAuto = min(vitesseAuto + 15, 180); Serial.printf("Vitesse : %d °/s\n", vitesseAuto); }
  if (vientDAppuyer(B_BAS, f & DPAD_DOWN))     { vitesseAuto = max(vitesseAuto - 15, 15);  Serial.printf("Vitesse : %d °/s\n", vitesseAuto); }
  if (vientDAppuyer(B_DROITE, f & DPAD_RIGHT)) { demiLargeur = min(demiLargeur + 10, ECART_MAX); Serial.printf("Largeur : ±%d°\n", demiLargeur); }
  if (vientDAppuyer(B_GAUCHE, f & DPAD_LEFT))  { demiLargeur = max(demiLargeur - 10, 10);        Serial.printf("Largeur : ±%d°\n", demiLargeur); }
}

// ================= Le mouvement =================
// Renvoie le déplacement fait pendant ce tour (en degrés), pour la couleur de la barre
float bouger() {
  unsigned long maintenant = millis();
  float dt = (maintenant - dernierTemps) / 1000.0;          // secondes écoulées depuis le dernier tour
  dernierTemps = maintenant;
  float avantAngle = angle;

  int gachettes = manette ? manette->throttle() - manette->brake() : 0;   // R2 moins L2 : -1020 à 1020
  if (abs(gachettes) > 40) {                                 // les gâchettes ont la priorité
    automatique = false;
    retourCentre = false;
    angle += gachettes / 1020.0 * 120 * dt;                  // jusqu'à 120 °/s à fond
  } else if (automatique) {
    angle += sensAuto * vitesseAuto * dt;
    if (angle >= CENTRE + demiLargeur) { angle = CENTRE + demiLargeur; sensAuto = -1; }   // bord droit : demi-tour
    if (angle <= CENTRE - demiLargeur) { angle = CENTRE - demiLargeur; sensAuto = 1; }    // bord gauche : demi-tour
  } else if (retourCentre) {
    float pas = vitesseAuto * dt;
    if (abs(angle - CENTRE) <= pas) { angle = CENTRE; retourCentre = false; }
    else angle += (angle < CENTRE) ? pas : -pas;
  }

  angle = constrain(angle, CENTRE - ECART_MAX, CENTRE + ECART_MAX);   // butées logicielles
  radar.writeMicroseconds(versMicrosecondes(angle));
  return angle - avantAngle;
}

// ================= Ce que voit le pilote =================
void signaler(float deplacement) {
  int sens = (deplacement > 0.01) - (deplacement < -0.01);   // 1, -1 ou 0
  if (sens == sensPrecedent || !manette) return;
  sensPrecedent = sens;
  if (sens > 0)      manette->setColorLED(0, 255, 0);        // vert : vers la droite
  else if (sens < 0) manette->setColorLED(0, 80, 255);       // bleu : vers la gauche
  else               manette->setColorLED(255, 255, 255);    // blanc : immobile
}

// ================= Programme principal =================
void setup() {
  Serial.begin(115200);
  radar.setPeriodHertz(50);
  radar.attach(PIN_SERVO, US_MIN, US_MAX);
  radar.writeMicroseconds(versMicrosecondes(angle));
  dernierTemps = millis();
  BP32.setup(&onConnectedController, &onDisconnectedController);
  BP32.forgetBluetoothKeys();   // à mettre en commentaire une fois que tout marche
  Serial.println("Naboucle prêt. Maintiens SHARE + PS pour coupler la manette.");
}

void loop() {
  BP32.update();
  if (manette && manette->isConnected()) lireManette();
  signaler(bouger());
  delay(15);
}

// Mission 4 · Naboucle, version holo-écran
// Le même programme que Naboucle, avec en plus l'écran OLED qui affiche :
// le radar vu de dessus avec la vraie position de l'antenne et les bords du balayage,
// le mode, l'angle, la largeur, la vitesse et l'impulsion envoyée au servo.
// Sans écran branché, tout marche quand même.

#include <Bluepad32.h>
#include <ESP32Servo.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// ================= Réglages =================
const int PIN_SERVO = 18;
const int US_MIN = 500;            // impulsion pour 0°    (comme dans le programme d'enquête)
const int US_MAX = 2500;           // impulsion pour 360°
const int CENTRE = 180;            // le milieu de la course, en degrés : l'antenne regarde devant
const int ECART_MAX = 90;          // sécurité : jamais plus de 90° de chaque côté du centre
                                   // (impulsions de 1 000 à 2 000 µs), tant qu'on n'a pas réglé

Servo radar;
ControllerPtr manette = nullptr;

float angle = CENTRE;              // où est le radar, en degrés
int demiLargeur = 60;              // le balayage va de CENTRE - demiLargeur à CENTRE + demiLargeur
int vitesseAuto = 45;              // vitesse du balayage, en degrés par seconde
bool automatique = false;          // le radar balaie-t-il tout seul ?
bool retourCentre = false;         // R1 : on rentre au centre
int sensAuto = 1;                  // +1 : vers la droite, -1 : vers la gauche
int sensPrecedent = 99;            // pour ne recolorer la barre que si ça change
unsigned long dernierTemps = 0;

enum { B_TRIANGLE, B_R1, B_HAUT, B_BAS, B_GAUCHE, B_DROITE, NB_BOUTONS };
bool avant[NB_BOUTONS];

bool vientDAppuyer(int numero, bool appuye) {
  bool nouveau = appuye && !avant[numero];
  avant[numero] = appuye;
  return nouveau;
}

int versMicrosecondes(float a) {
  return US_MIN + (int)(a * (US_MAX - US_MIN) / 360);
}

// ================= Connexion =================
void onConnectedController(ControllerPtr ctl) {
  if (manette != nullptr) return;
  manette = ctl;
  sensPrecedent = 99;
  Serial.println("🎮 Manette connectée : le radar est prêt.");
}

void onDisconnectedController(ControllerPtr ctl) {
  if (manette == ctl) {
    manette = nullptr;
    automatique = false;
    Serial.println("❌ Manette déconnectée : le radar s'arrête.");
  }
}

// ================= Lecture de la manette =================
void lireManette() {
  if (vientDAppuyer(B_TRIANGLE, manette->y())) {
    automatique = !automatique;
    retourCentre = false;
    Serial.println(automatique ? "△ Balayage automatique : marche" : "△ Balayage automatique : arrêt");
  }
  if (vientDAppuyer(B_R1, manette->r1())) {
    automatique = false;
    retourCentre = true;
    Serial.println("R1 : retour au centre");
  }

  uint8_t f = manette->dpad();
  if (vientDAppuyer(B_HAUT, f & DPAD_UP))      { vitesseAuto = min(vitesseAuto + 15, 180); Serial.printf("Vitesse : %d °/s\n", vitesseAuto); }
  if (vientDAppuyer(B_BAS, f & DPAD_DOWN))     { vitesseAuto = max(vitesseAuto - 15, 15);  Serial.printf("Vitesse : %d °/s\n", vitesseAuto); }
  if (vientDAppuyer(B_DROITE, f & DPAD_RIGHT)) { demiLargeur = min(demiLargeur + 10, ECART_MAX); Serial.printf("Largeur : ±%d°\n", demiLargeur); }
  if (vientDAppuyer(B_GAUCHE, f & DPAD_LEFT))  { demiLargeur = max(demiLargeur - 10, 10);        Serial.printf("Largeur : ±%d°\n", demiLargeur); }
}

// ================= Le mouvement =================
// Renvoie le déplacement fait pendant ce tour (en degrés), pour la couleur de la barre
float bouger() {
  unsigned long maintenant = millis();
  float dt = (maintenant - dernierTemps) / 1000.0;          // secondes écoulées depuis le dernier tour
  dernierTemps = maintenant;
  float avantAngle = angle;

  int gachettes = manette ? manette->throttle() - manette->brake() : 0;   // R2 moins L2 : -1020 à 1020
  if (abs(gachettes) > 40) {                                 // les gâchettes ont la priorité
    automatique = false;
    retourCentre = false;
    angle += gachettes / 1020.0 * 120 * dt;                  // jusqu'à 120 °/s à fond
  } else if (automatique) {
    angle += sensAuto * vitesseAuto * dt;
    if (angle >= CENTRE + demiLargeur) { angle = CENTRE + demiLargeur; sensAuto = -1; }   // bord droit : demi-tour
    if (angle <= CENTRE - demiLargeur) { angle = CENTRE - demiLargeur; sensAuto = 1; }    // bord gauche : demi-tour
  } else if (retourCentre) {
    float pas = vitesseAuto * dt;
    if (abs(angle - CENTRE) <= pas) { angle = CENTRE; retourCentre = false; }
    else angle += (angle < CENTRE) ? pas : -pas;
  }

  angle = constrain(angle, CENTRE - ECART_MAX, CENTRE + ECART_MAX);   // butées logicielles
  radar.writeMicroseconds(versMicrosecondes(angle));
  return angle - avantAngle;
}

// ================= Ce que voit le pilote =================
void signaler(float deplacement) {
  int sens = (deplacement > 0.01) - (deplacement < -0.01);   // 1, -1 ou 0
  if (sens == sensPrecedent || !manette) return;
  sensPrecedent = sens;
  if (sens > 0)      manette->setColorLED(0, 255, 0);        // vert : vers la droite
  else if (sens < 0) manette->setColorLED(0, 80, 255);       // bleu : vers la gauche
  else               manette->setColorLED(255, 255, 255);    // blanc : immobile
}

// ================= L'holo-écran =================
Adafruit_SSD1306 ecran(128, 64, &Wire, -1);
bool ecranPret = false;            // faux si l'écran n'est pas branché : le reste marche quand même
unsigned long derniereImage = 0;
const int PERIODE_ECRAN = 100;     // une image toutes les 100 ms : 10 images par seconde

void demarrerEcran() {
  Wire.begin(21, 22);              // SDA sur D21, SCL sur D22
  ecranPret = ecran.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  if (!ecranPret) {
    Serial.println("📟 Pas d'écran trouvé : on continue sans lui.");
    return;
  }
  ecran.setTextColor(SSD1306_WHITE);
  ecran.setTextWrap(false);
}

// Une jauge horizontale : un cadre, rempli selon la valeur (0 à maxi)
void dessinerJauge(int x, int y, int largeur, int valeur, int maxi) {
  ecran.drawRect(x, y, largeur, 7, SSD1306_WHITE);
  int plein = (largeur - 2) * constrain(valeur, 0, maxi) / maxi;
  ecran.fillRect(x + 1, y + 1, plein, 5, SSD1306_WHITE);
}

// Le titre dans la bande jaune (lignes 0 à 15), avec la batterie de la manette à droite (ou « ... » qui clignote sans manette)
void dessinerTitre(const char* titre) {
  ecran.setTextSize(1);
  ecran.setCursor(0, 3);
  ecran.print(titre);
  if (manette && manette->battery() > 0) dessinerJauge(100, 3, 28, manette->battery(), 255);
  else if (!manette && (millis() / 500) % 2) { ecran.setCursor(110, 3); ecran.print("..."); }
  ecran.drawFastHLine(0, 13, 128, SSD1306_WHITE);  // la bande jaune s'arrête à la ligne 15
}

// Un point sur le cercle du radar : l'antenne au CENTRE regarde vers le haut de l'écran
int pointX(int cx, float a, int r) { return cx + r * sin((a - CENTRE) * PI / 180); }
int pointY(int cy, float a, int r) { return cy - r * cos((a - CENTRE) * PI / 180); }

void mettreAJourEcran() {
  if (!ecranPret || millis() - derniereImage < PERIODE_ECRAN) return;
  derniereImage = millis();
  ecran.clearDisplay();
  dessinerTitre("RADAR");

  // Le radar vu de dessus, à gauche : les bords du balayage en pointillés, l'antenne en trait plein
  const int cx = 26, cy = 40, r = 22;
  ecran.drawCircle(cx, cy, r, SSD1306_WHITE);
  ecran.fillCircle(cx, cy, 2, SSD1306_WHITE);
  for (int k = 4; k <= r; k += 4) {                          // les deux bords, en pointillés
    ecran.drawPixel(pointX(cx, CENTRE - demiLargeur, k), pointY(cy, CENTRE - demiLargeur, k), SSD1306_WHITE);
    ecran.drawPixel(pointX(cx, CENTRE + demiLargeur, k), pointY(cy, CENTRE + demiLargeur, k), SSD1306_WHITE);
  }
  ecran.drawLine(cx, cy, pointX(cx, angle, r), pointY(cy, angle, r), SSD1306_WHITE);   // l'antenne

  // Les chiffres, à droite
  ecran.setTextSize(1);
  ecran.setCursor(58, 18);
  ecran.print(automatique ? "BALAYAGE" : retourCentre ? "RETOUR" : "MANUEL");
  ecran.setCursor(58, 28);
  ecran.printf("Angle %+d", (int)angle - CENTRE);            // 0 = droit devant
  ecran.setCursor(58, 38);
  ecran.printf("Larg  +-%d", demiLargeur);
  ecran.setCursor(58, 48);
  ecran.printf("Vit %d d/s", vitesseAuto);
  ecran.setCursor(58, 57);
  ecran.printf("%d us", versMicrosecondes(angle));
  ecran.display();
}

// ================= Programme principal =================
void setup() {
  Serial.begin(115200);
  radar.setPeriodHertz(50);
  radar.attach(PIN_SERVO, US_MIN, US_MAX);
  radar.writeMicroseconds(versMicrosecondes(angle));
  dernierTemps = millis();
  demarrerEcran();
  BP32.setup(&onConnectedController, &onDisconnectedController);
  BP32.forgetBluetoothKeys();   // à mettre en commentaire une fois que tout marche
  Serial.println("Naboucle prêt. Maintiens SHARE + PS pour coupler la manette.");
}

void loop() {
  BP32.update();
  if (manette && manette->isConnected()) lireManette();
  signaler(bouger());
  mettreAJourEcran();
  delay(15);
}