Je suis ton servo

// Mission 3 · Test du servo : un lent balayage, sans manette
#include <ESP32Servo.h>

const int PIN_SERVO = 18;
const int US_MIN = 500;          // impulsion supposée pour 0°   (en microsecondes)
const int US_MAX = 2500;         // impulsion supposée pour 270°

Servo servo;

void setup() {
  Serial.begin(115200);
  servo.setPeriodHertz(50);                  // 50 impulsions par seconde
  servo.attach(PIN_SERVO, US_MIN, US_MAX);
}

void loop() {
  for (int us = 1000; us <= 2000; us += 10) {   // de 1 ms à 2 ms : la zone sûre
    servo.writeMicroseconds(us);
    delay(20);
  }
  Serial.println("aller terminé");
  for (int us = 2000; us >= 1000; us -= 10) {
    servo.writeMicroseconds(us);
    delay(20);
  }
  Serial.println("retour terminé");
}

// Mission 3 · Calibrage : tape un angle dans le moniteur série, le servo y va
#include <ESP32Servo.h>

const int PIN_SERVO = 18;
const int US_MIN = 500;          // impulsion supposée pour 0°
const int US_MAX = 2500;         // impulsion supposée pour 270°

Servo servo;

int versMicrosecondes(int angle) {           // 0..270° → 500..2500 µs
  return map(angle, 0, 270, US_MIN, US_MAX);
}

void setup() {
  Serial.begin(115200);
  servo.setPeriodHertz(50);
  servo.attach(PIN_SERVO, US_MIN, US_MAX);
  servo.writeMicroseconds(versMicrosecondes(135));   // on démarre au milieu
  Serial.println("Calibrage prêt. Tape un angle entre 0 et 270, puis Entrée.");
}

void loop() {
  if (Serial.available()) {
    String ligne = Serial.readStringUntil('\n');      // lit ce qui a été tapé
    ligne.trim();                                     // enlève espaces et retours
    if (ligne.length() == 0) return;                  // ligne vide : on ignore
    int angle = constrain(ligne.toInt(), 0, 270);
    int us = versMicrosecondes(angle);
    servo.writeMicroseconds(us);
    Serial.printf("→ %d° demandés : impulsion de %d µs\n", angle, us);
  }
}

// Mission 3 · Dagoservo : la porte du hangar, pilotée à la manette
// ✕ ouvre, ○ ferme, △ position du milieu, joystick gauche = manivelle,
// ↑ ↓ vitesse, R1 = arrêt d'urgence. Barre lumineuse : rouge fermé, vert ouvert.

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

// ================= Réglages (à adapter après le calibrage) =================
const int PIN_SERVO = 18;
const int US_MIN = 500;          // impulsion pour 0°
const int US_MAX = 2500;         // impulsion pour 270°
const int FERME = 30;            // ← ton angle « porte fermée », noté au calibrage
const int OUVERT = 150;          // ← ton angle « porte ouverte »

Servo porte;
ControllerPtr manette = nullptr;

float position = FERME;          // où est la porte maintenant (en degrés)
float cible = FERME;             // où elle doit aller
int vitesse = 60;                // en degrés par seconde
unsigned long dernierTemps = 0;
int etatPrecedent = -1;          // pour ne signaler un changement qu'une fois

// ================= Petits outils =================
enum { B_CROIX, B_ROND, B_TRIANGLE, B_R1, B_HAUT, B_BAS, 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 angle) {
  return US_MIN + (int)(angle * (US_MAX - US_MIN) / 270);
}

int angleMin() { return min(FERME, OUVERT); }    // marche même si FERME > OUVERT
int angleMax() { return max(FERME, OUVERT); }

// ================= Connexion =================
void onConnectedController(ControllerPtr ctl) {
  if (manette != nullptr) return;
  manette = ctl;
  etatPrecedent = -1;                            // pour recolorer la barre
  Serial.println("🎮 Manette connectée : la porte est à tes ordres.");
}

void onDisconnectedController(ControllerPtr ctl) {
  if (manette == ctl) {
    manette = nullptr;
    cible = position;                            // par sécurité, la porte s'arrête
    Serial.println("❌ Manette déconnectée : la porte s'arrête.");
  }
}

// ================= Lecture de la manette =================
void lireManette() {
  if (vientDAppuyer(B_CROIX, manette->a()))    { cible = OUVERT; Serial.println("✕ Ouverture"); }
  if (vientDAppuyer(B_ROND, manette->b()))     { cible = FERME;  Serial.println("○ Fermeture"); }
  if (vientDAppuyer(B_TRIANGLE, manette->y())) { cible = (FERME + OUVERT) / 2; Serial.println("△ Position du milieu"); }
  if (vientDAppuyer(B_R1, manette->r1()))      { cible = position; Serial.println("R1 : arrêt d'urgence"); }

  uint8_t f = manette->dpad();
  if (vientDAppuyer(B_HAUT, f & DPAD_UP)) {
    vitesse = min(vitesse + 20, 240);
    Serial.printf("Vitesse : %d °/s\n", vitesse);
  }
  if (vientDAppuyer(B_BAS, f & DPAD_DOWN)) {
    vitesse = max(vitesse - 20, 20);
    Serial.printf("Vitesse : %d °/s\n", vitesse);
  }

  // Le joystick gauche, comme une manivelle : plus on pousse, plus la cible avance vite
  int x = manette->axisX();                      // de -508 à 512
  if (abs(x) > 80) {
    cible += x / 512.0 * 2.0;                    // jusqu'à 2° par tour de loop()
  }
  cible = constrain(cible, angleMin(), angleMax());   // butées logicielles
}

// ================= Le mouvement en douceur =================
void bouger() {
  unsigned long maintenant = millis();
  float pas = vitesse * (maintenant - dernierTemps) / 1000.0;   // degrés autorisés depuis le dernier tour
  dernierTemps = maintenant;

  if (abs(cible - position) <= pas) position = cible;           // arrivé !
  else if (cible > position) position += pas;
  else position -= pas;

  porte.writeMicroseconds(versMicrosecondes(position));
}

// ================= Ce que voit et sent le pilote =================
void signaler() {
  int etat;                                       // 0 fermée, 1 ouverte, 2 entre les deux
  if (abs(position - FERME) < 1) etat = 0;
  else if (abs(position - OUVERT) < 1) etat = 1;
  else etat = 2;
  if (etat == etatPrecedent || !manette) return;  // rien de nouveau
  etatPrecedent = etat;

  if (etat == 0) {
    manette->setColorLED(255, 0, 0);
    manette->playDualRumble(0, 150, 0, 200);      // « clac » : porte fermée
    Serial.println("Porte fermée");
  } else if (etat == 1) {
    manette->setColorLED(0, 255, 0);
    manette->playDualRumble(0, 150, 0, 200);
    Serial.println("Porte ouverte");
  } else {
    manette->setColorLED(255, 120, 0);            // orange : en mouvement
  }
}

// ================= Programme principal =================
void setup() {
  Serial.begin(115200);
  porte.setPeriodHertz(50);
  porte.attach(PIN_SERVO, US_MIN, US_MAX);
  porte.writeMicroseconds(versMicrosecondes(position));
  dernierTemps = millis();

  BP32.setup(&onConnectedController, &onDisconnectedController);
  BP32.forgetBluetoothKeys();   // à mettre en commentaire une fois que tout marche
  Serial.println("Dagoservo prêt. Maintiens SHARE + PS pour coupler la manette.");
}

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

// Mission 3 · Dagoservo, version holo-écran
// Le même programme que Dagoservo, avec en plus l'écran OLED qui affiche :
// l'état de la porte, un dessin de la porte qui bouge, son angle, la cible,
// la vitesse et la durée de 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 (à adapter après le calibrage) =================
const int PIN_SERVO = 18;
const int US_MIN = 500;          // impulsion pour 0°
const int US_MAX = 2500;         // impulsion pour 270°
const int FERME = 30;            // ← ton angle « porte fermée », noté au calibrage
const int OUVERT = 150;          // ← ton angle « porte ouverte »

Servo porte;
ControllerPtr manette = nullptr;

float position = FERME;          // où est la porte maintenant (en degrés)
float cible = FERME;             // où elle doit aller
int vitesse = 60;                // en degrés par seconde
unsigned long dernierTemps = 0;
int etatPrecedent = -1;          // pour ne signaler un changement qu'une fois

// ================= Petits outils =================
enum { B_CROIX, B_ROND, B_TRIANGLE, B_R1, B_HAUT, B_BAS, 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 angle) {
  return US_MIN + (int)(angle * (US_MAX - US_MIN) / 270);
}

int angleMin() { return min(FERME, OUVERT); }    // marche même si FERME > OUVERT
int angleMax() { return max(FERME, OUVERT); }

// ================= Connexion =================
void onConnectedController(ControllerPtr ctl) {
  if (manette != nullptr) return;
  manette = ctl;
  etatPrecedent = -1;                            // pour recolorer la barre
  Serial.println("🎮 Manette connectée : la porte est à tes ordres.");
}

void onDisconnectedController(ControllerPtr ctl) {
  if (manette == ctl) {
    manette = nullptr;
    cible = position;                            // par sécurité, la porte s'arrête
    Serial.println("❌ Manette déconnectée : la porte s'arrête.");
  }
}

// ================= Lecture de la manette =================
void lireManette() {
  if (vientDAppuyer(B_CROIX, manette->a()))    { cible = OUVERT; Serial.println("✕ Ouverture"); }
  if (vientDAppuyer(B_ROND, manette->b()))     { cible = FERME;  Serial.println("○ Fermeture"); }
  if (vientDAppuyer(B_TRIANGLE, manette->y())) { cible = (FERME + OUVERT) / 2; Serial.println("△ Position du milieu"); }
  if (vientDAppuyer(B_R1, manette->r1()))      { cible = position; Serial.println("R1 : arrêt d'urgence"); }

  uint8_t f = manette->dpad();
  if (vientDAppuyer(B_HAUT, f & DPAD_UP)) {
    vitesse = min(vitesse + 20, 240);
    Serial.printf("Vitesse : %d °/s\n", vitesse);
  }
  if (vientDAppuyer(B_BAS, f & DPAD_DOWN)) {
    vitesse = max(vitesse - 20, 20);
    Serial.printf("Vitesse : %d °/s\n", vitesse);
  }

  // Le joystick gauche, comme une manivelle : plus on pousse, plus la cible avance vite
  int x = manette->axisX();                      // de -508 à 512
  if (abs(x) > 80) {
    cible += x / 512.0 * 2.0;                    // jusqu'à 2° par tour de loop()
  }
  cible = constrain(cible, angleMin(), angleMax());   // butées logicielles
}

// ================= Le mouvement en douceur =================
void bouger() {
  unsigned long maintenant = millis();
  float pas = vitesse * (maintenant - dernierTemps) / 1000.0;   // degrés autorisés depuis le dernier tour
  dernierTemps = maintenant;

  if (abs(cible - position) <= pas) position = cible;           // arrivé !
  else if (cible > position) position += pas;
  else position -= pas;

  porte.writeMicroseconds(versMicrosecondes(position));
}

// ================= Ce que voit et sent le pilote =================
void signaler() {
  int etat;                                       // 0 fermée, 1 ouverte, 2 entre les deux
  if (abs(position - FERME) < 1) etat = 0;
  else if (abs(position - OUVERT) < 1) etat = 1;
  else etat = 2;
  if (etat == etatPrecedent || !manette) return;  // rien de nouveau
  etatPrecedent = etat;

  if (etat == 0) {
    manette->setColorLED(255, 0, 0);
    manette->playDualRumble(0, 150, 0, 200);      // « clac » : porte fermée
    Serial.println("Porte fermée");
  } else if (etat == 1) {
    manette->setColorLED(0, 255, 0);
    manette->playDualRumble(0, 150, 0, 200);
    Serial.println("Porte ouverte");
  } else {
    manette->setColorLED(255, 120, 0);            // orange : en mouvement
  }
}

// ================= 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
}

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

  // L'état de la porte, en grand
  ecran.setTextSize(2);
  ecran.setCursor(0, 16);
  if (abs(position - FERME) < 1)       ecran.print("FERMEE");
  else if (abs(position - OUVERT) < 1) ecran.print("OUVERTE");
  else                                 ecran.print("BOUGE");

  // Les chiffres
  ecran.setTextSize(1);
  ecran.setCursor(0, 34);
  ecran.printf("Angle %d deg", (int)position);
  ecran.setCursor(0, 44);
  ecran.printf("Cible %d deg", (int)cible);
  ecran.setCursor(0, 54);
  ecran.printf("%d deg/s %d us", vitesse, versMicrosecondes(position));

  // La porte vue de côté : fermée = couchée, ouverte = debout
  const int px = 122, py = 44, longueur = 24;     // le pivot et la longueur de la porte
  float fraction = (position - FERME) / (float)(OUVERT - FERME);   // 0 = fermée, 1 = ouverte
  float angle = fraction * PI / 2;                                  // de 0 à 90° à l'écran
  ecran.drawLine(px, py, px - longueur * cos(angle), py - longueur * sin(angle), SSD1306_WHITE);
  ecran.drawLine(px + 1, py, px + 1 - longueur * cos(angle), py - longueur * sin(angle), SSD1306_WHITE);
  ecran.fillCircle(px, py, 2, SSD1306_WHITE);
  float fc = (cible - FERME) / (float)(OUVERT - FERME) * PI / 2;    // un petit rond : là où elle va
  ecran.drawCircle(px - longueur * cos(fc), py - longueur * sin(fc), 2, SSD1306_WHITE);
  ecran.drawFastHLine(90, py + 3, 38, SSD1306_WHITE);              // le sol
  ecran.display();
}

// ================= Programme principal =================
void setup() {
  Serial.begin(115200);
  porte.setPeriodHertz(50);
  porte.attach(PIN_SERVO, US_MIN, US_MAX);
  porte.writeMicroseconds(versMicrosecondes(position));
  dernierTemps = millis();

  demarrerEcran();
  BP32.setup(&onConnectedController, &onDisconnectedController);
  BP32.forgetBluetoothKeys();   // à mettre en commentaire une fois que tout marche
  Serial.println("Dagoservo prêt. Maintiens SHARE + PS pour coupler la manette.");
}

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