Capteur de distance HC-SR04

/*
 * Premier test HC-SR04 — Kaihatsu Lab
 * Mesure la distance et l'affiche dans le moniteur série (115 200 bauds).
 *
 * ESP32 : ECHO sort en 5 V. Passe-le par un diviseur de tension (par exemple 1 kΩ et 2 kΩ)
 * avant de le brancher sur PIN_ECHO. TRIG accepte le 3,3 V.
 */
const uint8_t PIN_TRIG = 25;
const uint8_t PIN_ECHO = 26;

const float TEMPERATURE_C = 20.0;                               // température de l'air : elle change la vitesse du son
const float SOUND_CM_PER_US = (331.3 + 0.606 * TEMPERATURE_C) / 10000.0;   // m/s -> cm/µs

void setup() {
  Serial.begin(115200);
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);
  digitalWrite(PIN_TRIG, LOW);
}

// Retourne la distance en cm, ou -1 si aucun écho n'est revenu.
float readDistanceCm() {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);         // impulsion de 10 µs : le capteur envoie 8 salves à 40 kHz
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);

  unsigned long us = pulseIn(PIN_ECHO, HIGH, 30000UL);   // 30 ms maximum, soit environ 5 m
  if (us == 0) return -1;
  return us * SOUND_CM_PER_US / 2.0;    // l'onde fait l'aller-retour : on divise par 2
}

void loop() {
  float d = readDistanceCm();
  if (d < 0) {
    Serial.println(F("Pas d'echo"));
  } else {
    Serial.print(d, 1);
    Serial.println(F(" cm"));
  }
  delay(100);                           // laisse s'éteindre les échos de la mesure précédente
}

/*
 * HC-SR04 filtré — Kaihatsu Lab
 * Médiane de 5 mesures (supprime les valeurs aberrantes), puis moyenne exponentielle (lisse le résultat).
 * Les mesures hors de la plage 2 à 400 cm sont ignorées.
 */
const uint8_t PIN_TRIG = 25;
const uint8_t PIN_ECHO = 26;              // derrière un diviseur de tension sur ESP32

const float MIN_CM = 2.0;
const float MAX_CM = 400.0;
const float ALPHA  = 0.3;                 // 0 à 1 : plus c'est petit, plus c'est lisse mais lent

float smooth = -1;

float rawCm() {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);
  unsigned long us = pulseIn(PIN_ECHO, HIGH, 30000UL);
  if (us == 0) return -1;
  return us / 58.3;                       // environ 20 °C
}

float medianOf5() {
  float v[5];
  uint8_t n = 0;
  for (uint8_t i = 0; i < 5; i++) {
    float d = rawCm();
    if (d >= MIN_CM && d <= MAX_CM) v[n++] = d;
    delay(30);
  }
  if (n == 0) return -1;
  for (uint8_t i = 1; i < n; i++) {       // tri par insertion
    float x = v[i];
    int8_t j = i - 1;
    while (j >= 0 && v[j] > x) { v[j + 1] = v[j]; j--; }
    v[j + 1] = x;
  }
  return v[n / 2];
}

void setup() {
  Serial.begin(115200);
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);
}

void loop() {
  float m = medianOf5();
  if (m > 0) {
    smooth = (smooth < 0) ? m : ALPHA * m + (1.0 - ALPHA) * smooth;
    Serial.print(F("brut "));
    Serial.print(m, 1);
    Serial.print(F(" cm | filtre "));
    Serial.print(smooth, 1);
    Serial.println(F(" cm"));
  } else {
    Serial.println(F("Pas de mesure valide"));
  }
}

/*
 * Radar — Kaihatsu Lab
 * HC-SR04 monté sur un servomoteur qui balaie de 15° à 165°, résultat tracé sur un écran OLED SSD1306.
 * Bibliothèques : Adafruit GFX, Adafruit SSD1306, ESP32Servo.
 *
 * ECHO passe par un diviseur de tension (5 V vers 3,3 V). Le servo est alimenté en 5 V à part,
 * les masses sont reliées entre elles.
 */
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <ESP32Servo.h>

const uint8_t PIN_TRIG  = 25;
const uint8_t PIN_ECHO  = 26;
const uint8_t PIN_SERVO = 13;

#define SCREEN_W  128
#define SCREEN_H  64
#define OLED_ADDR 0x3C

const int   ANGLE_MIN = 15;
const int   ANGLE_MAX = 165;
const int   ANGLE_STEP = 5;
const int   STEPS = (ANGLE_MAX - ANGLE_MIN) / ANGLE_STEP + 1;
const float RANGE_CM = 100.0;             // distance affichée au bord de l'écran
const int   CX = 64, CY = 63, RADIUS = 60;

Adafruit_SSD1306 display(SCREEN_W, SCREEN_H, &Wire, -1);
Servo servo;
float dist[STEPS];                        // dernière distance mesurée à chaque angle (-1 = rien)

float readCm() {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);
  unsigned long us = pulseIn(PIN_ECHO, HIGH, 25000UL);
  if (us == 0) return -1;
  return us / 58.3;
}

void drawRadar(int current) {
  display.clearDisplay();
  display.drawCircle(CX, CY, RADIUS, SSD1306_WHITE);
  display.drawCircle(CX, CY, RADIUS / 2, SSD1306_WHITE);
  display.drawLine(0, CY, SCREEN_W - 1, CY, SSD1306_WHITE);

  for (int i = 0; i < STEPS; i++) {       // points détectés
    if (dist[i] < 0 || dist[i] > RANGE_CM) continue;
    float a = (ANGLE_MIN + i * ANGLE_STEP) * DEG_TO_RAD;
    float r = dist[i] / RANGE_CM * RADIUS;
    display.fillCircle(CX + r * cos(a), CY - r * sin(a), 2, SSD1306_WHITE);
  }

  float a = (ANGLE_MIN + current * ANGLE_STEP) * DEG_TO_RAD;   // ligne de balayage
  display.drawLine(CX, CY, CX + RADIUS * cos(a), CY - RADIUS * sin(a), SSD1306_WHITE);

  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  if (dist[current] >= 0) { display.print((int)dist[current]); display.print(F(" cm")); }
  else display.print(F("--"));
  display.display();
}

void setup() {
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);
  Wire.begin(21, 22);
  display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
  servo.setPeriodHertz(50);
  servo.attach(PIN_SERVO, 500, 2400);
  for (int i = 0; i < STEPS; i++) dist[i] = -1;
}

void loop() {
  for (int i = 0; i < STEPS; i++) {                 // aller
    servo.write(ANGLE_MIN + i * ANGLE_STEP);
    delay(70);                                      // temps pour que le servo se stabilise
    dist[i] = readCm();
    drawRadar(i);
  }
  for (int i = STEPS - 1; i >= 0; i--) {            // retour
    servo.write(ANGLE_MIN + i * ANGLE_STEP);
    delay(70);
    dist[i] = readCm();
    drawRadar(i);
  }
}