Chronomètre slot car au laser + écran GLCD – Mesure de temps au tour précise

Composants

Arduino Mega 2560 (plus de RAM/broches pour GLCD)	1
Module laser KY-008 (650 nm, 5V)	1
Récepteur laser KY-008 (phototransistor, sortie digitale)	1
Écran GLCD 128x64 (contrôleur KS0108, interface parallèle 8 bits)	1
Fils, plaque d'essai, supports	1 jeu

Logiciels

• Arduino IDE
• Bibliothèque openGLCD : Bitbucket (successeur de GLCDks0108)
• Documentation brochage : Arduino Playground

Principe

Une barrière laser traverse la piste de slot cars. À chaque passage de voiture, le faisceau est coupé → le récepteur détecte la transition → l'Arduino mesure le temps entre deux coupures (temps au tour). Affichage temps réel sur GLCD : tour courant, dernier tour, meilleur tour, compteur de tours.

Câblage

• Laser KY-008 : 3 broches (-, +, S). Relier S et + au 5V (laser toujours allumé). Ou S sur pin digitale pour contrôle logiciel.
• Récepteur : GND, VCC (5V), SIGNAL → Pin 2 Arduino (interruption possible).
• GLCD KS0108 : 20 broches (8 données, 3 contrôle, 5 alimentation, 4 non utilisées). Voir doc openGLCD pour mapping exact sur Mega. Utilisez un connecteur dédié (photo fournie).

Alignement critique

Le défi principal : aligner laser et récepteur face à face de part et d'autre de la piste (largeur ~5-8 cm). Supports rigides, réglage fin. Tout désalignement = pertes de détection.

Code complet (chronomètre avec anti-rebond)

#include <openGLCD.h>

// Variables temps
unsigned long currentRunStart = 0;
unsigned long lastLapTime = 0;
unsigned long bestLapTime = 0;
int lapCount = 0;
unsigned long savedMillis;

// Zones d'affichage GLCD
gText tLaps;    // Compteur tours (gros chiffres)
gText tLast;    // Dernier tour
gText tBest;    // Meilleur tour

// Capteur laser
const int GATE_PIN = 2;
int gateState = HIGH;
int lastGateState = HIGH;
unsigned long lastDebounce = 0;
const int DEBOUNCE_MS = 50;

void setup() {
  pinMode(GATE_PIN, INPUT);
  delay(50); // Laisser laser/récepteur stabiliser

  GLCD.Init(NON_INVERTED);

  // Zones texte
  tLaps.DefineArea(textAreaTOP, lcdnums14x24);           // Haut, police large
  tLast.DefineArea(0, GLCD.CenterY, 8, 2, fixednums7x15); // Bas-gauche
  tBest.DefineArea(GLCD.CenterX, GLCD.CenterY, 8, 2, fixednums7x15); // Bas-droite
  tBest.SetFontColor(WHITE);
  tBest.ClearArea();

  // Étiquettes fixes
  GLCD.SelectFont(System5x7);
  GLCD.CursorTo(1, 4); GLCD.print("DERNIER");
  GLCD.CursorTo(11, 4); GLCD.print("MEILLEUR");

  // Reset
  currentRunStart = lastLapTime = bestLapTime = 0;
  lapCount = 0;
}

void loop() {
  int reading = digitalRead(GATE_PIN);

  // Anti-rebond
  if (reading != lastGateState) {
    lastDebounce = millis();
  }
  if ((millis() - lastDebounce) > DEBOUNCE_MS) {
    if (reading != gateState) {
      gateState = reading;
      // Front descendant = faisceau coupé
      if (gateState == LOW) {
        savedMillis = millis(); // Horodatage précis

        if (lapCount > 0) {
          lastLapTime = savedMillis - currentRunStart;
          if (lastLapTime < bestLapTime || bestLapTime == 0) {
            bestLapTime = lastLapTime;
          }
        }
        currentRunStart = savedMillis;
        lapCount++;
      }
    }
  }
  lastGateState = reading;

  // Affichage temps réel
  unsigned long now = millis();
  int sec, milli;

  // Tours
  tLaps.CursorTo(0, 0);
  tLaps.Printf(F("%02d"), lapCount);

  // Tour en cours
  if (lapCount > 0) calcTime(now - currentRunStart, &sec, &milli);
  else calcTime(0, &sec, &milli);
  tLaps.CursorTo(3, 0);
  tLaps.Printf(F("%02d.%03d"), sec, milli);

  // Dernier tour
  calcTime(lastLapTime, &sec, &milli);
  tLast.CursorTo(1, 1);
  tLast.Printf(F("%02d.%03d"), sec, milli);

  // Meilleur tour
  calcTime(bestLapTime, &sec, &milli);
  tBest.CursorTo(1, 1);
  tBest.Printf(F("%02d.%03d"), sec, milli);
}

// Conversion ms → secondes + millisecondes
void calcTime(unsigned long ms, int *sec, int *milli) {
  *sec = ms / 1000;
  *milli = ms - (*sec * 1000);
}

Fonctionnalités clés du code

• Anti-rebond logiciel (50 ms) sur signal récepteur.
• Détection front descendant (faisceau coupé = LOW).
• Horodatage unique savedMillis pour cohérence calculs.
• Gestion premier tour (pas de « dernier tour » avant 2ème passage).
• Affichage multi-zones GLCD avec polices optimisées (chiffres gros + étiquettes).
• Format SS.sss (secondes + millisecondes).

Résultat

Chronomètre précis, affichage clair, coût modique. Idéal pour pistes slot cars maison, courses entre amis, analyse performances voitures/moteurs.

Évolutions possibles

• Multi-pistes (plusieurs barrières + multiplexage)
• Enregistrement CSV sur carte SD (historique courses)
• Interface Bluetooth/BLE pour appli smartphone
• Détection direction (2 barrières) → sens de course
• Classement multi-joueurs, gestion départs, pénalités