Laser-Lichtschranken-Rundentimer für Slotcars (Arduino Mega, GLCD)

Komponenten

• 1× Arduino Mega 2560
• 1× KY-008 Lasermodul (5 V)
• 1× Passender Lasersensor (Empfänger, 3 Pins: VCC, GND, Signal)
• 1× Grafik-LCD (GLCD, KS0108, 128×64)
• Widerstände, Kabel, 3D-gedruckte/gelaserte Halterungen für Laser & Sensor

Software

• Arduino IDE
• OpenGLCD Library (Bitbucket: bperrybap/openglcd)

Aufbau

Laser & Sensor werden gegenüberliegend an der Slotcar-Bahn montiert (Tor). Unterbricht ein Auto den Strahl, wird ein Rundenzähler ausgelöst. Das GLCD zeigt:

• Aktuelle Rundenzeit (Live)
• Letzte Rundenzeit
• Bestzeit
• Rundenzähler

Verdrahtung (Kurz)

• Laser: VCC→5 V, GND→GND, S→5 V (dauerhaft an) oder Digital-Pin (schaltbar)
• Sensor: VCC→5 V, GND→GND, Signal→Pin 2 (Interrupt-fähig)
• GLCD: Datenpins D0–D7 → Mega Pins 22–29, Control: RS→30, RW→31, EN→32, CS1→33, CS2→34, RES→35 (siehe OpenGLCD Pinout)

Code (Hauptlogik)

#include <openGLCD.h>

unsigned long currentRunStartMillis, lastRunInMillis, bestRunInMillis;
int currentLap = 0;
const int gateSensorPin = 2;
int gateSensorState, lastGateSensorState = LOW;
unsigned long lastDebounceTime = 0;
const int debounceDelay = 50;

gText t1, t2, t3; // Textbereiche für Runden, Letzte, Beste

void setup() {
  pinMode(gateSensorPin, INPUT);
  delay(50); // Sensor/Laser stabilisieren

  GLCD.Init(NON_INVERTED);
  t1.DefineArea(textAreaTOP, lcdnums14x24); // Runden oben groß
  t2.DefineArea(0, GLCD.CenterY, 8, 2, fixednums7x15); // Letzte
  t3.DefineArea(GLCD.CenterX, GLCD.CenterY, 8, 2, fixednums7x15); // Beste
  t3.SetFontColor(WHITE);

  GLCD.SelectFont(System5x7);
  GLCD.CursorTo(1, 4); GLCD.print("LAST");
  GLCD.CursorTo(11, 4); GLCD.print("BEST");

  currentRunStartMillis = lastRunInMillis = bestRunInMillis = 0;
}

void loop() {
  int reading = digitalRead(gateSensorPin);
  if (reading != lastGateSensorState) lastDebounceTime = millis();

  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != gateSensorState) {
      gateSensorState = reading;
      if (gateSensorState == LOW) { // Strahl unterbrochen
        unsigned long saved = millis();
        if (currentLap > 0) {
          lastRunInMillis = saved - currentRunStartMillis;
          if (lastRunInMillis < bestRunInMillis || bestRunInMillis == 0)
            bestRunInMillis = lastRunInMillis;
        }
        currentRunStartMillis = saved;
        currentLap++;
      }
    }
  }
  lastGateSensorState = reading;

  // Anzeige aktualisieren
  unsigned long now = millis();
  int sec, milli;
  t1.CursorTo(0, 0); t1.Printf(F("%02d"), currentLap);

  if (currentLap > 0) calc(now - currentRunStartMillis, &sec, &milli);
  else calc(0, &sec, &milli);
  t1.CursorTo(3, 0); t1.Printf(F("%02d.%03d"), sec, milli); // Aktuelle Laufzeit

  calc(lastRunInMillis, &sec, &milli);
  t2.CursorTo(1, 1); t2.Printf(F("%02d.%03d"), sec, milli); // Letzte Runde

  calc(bestRunInMillis, &sec, &milli);
  t3.CursorTo(1, 1); t3.Printf(F("%02d.%03d"), sec, milli); // Bestzeit
}

void calc(unsigned long ms, int *s, int *m) {
  *s = ms / 1000;
  *m = ms - *s * 1000;
}

Herausforderungen & Tipps

• Ausrichtung: Laser & Sensor exakt ausrichten (mechanische Halterungen helfen).
• Entprellung: 50 ms Debounce verhindert Mehrfachauslösung durch Flattern.
• GLCD-Pinout: Mega hat genug Pins – OpenGLCD-Doku für exakte Zuordnung beachten.
• Stromversorgung: Laser & Sensor direkt vom Mega (5 V) versorgt, reicht meist.

Erweiterungen

• Mehrere Lichtschranken (Sektorenzeiten).
• Datenlogging auf SD-Karte (CSV).
• Drahtlose Anzeige (Bluetooth/ESP32) für Zuschauer.
• Startampel (Rot/Gelb/Grün) per LEDs.