Laser-gestuurde Slotcar Rondeteller met GLCD-display – Precieze Tijdmeting voor RC-banen

Onderdelen en Benodigdheden

Apps en Online Services

• Arduino IDE

Over dit Project

Intro

Met een KY-008 lasermodule en passende sensor bouwde ik een elektronische tijdmeetpoort voor een slotcar-baan. De laserstraal wordt door de auto onderbroken, wat de Arduino detecteert en de rondetijd berekent.

Hardware

Hoofdcomponenten: Lasermodule, laserontvanger, GLCD-scherm.
GLCD-bibliotheek: OpenGLCD (pinout: Arduino Playground). Een handige connector voor het GLCD is gemaakt (zie foto's).

KY-008 Lasermodule: 3 pinnen (-, +, S). S en + beide op 5V voor continue laser. Optioneel: S op digitale pin voor softwarematige aan/uit.

Sensor: 3 pinnen (GND, VCC, SIGNAAL) → voeding + Arduino input-pin.

Uitdaging: Perfect uitlijnen van laser en sensor over de baan.

Code

De sketch meet rondetijden met milliseconden-nauwkeurigheid, debounced sensor-invoer, en toont op het GLCD:

• Huidige rondetijd (live)
• Laatste ronde
• Beste ronde
• Rondenummer

#include "openGLCD.h"

// Variabelen voor rondetijden
unsigned long currentRunStartMillis;
unsigned long lastRunInMillis;
unsigned long bestRunInMillis;
int currentLap;
unsigned long savedMillis;

// GLCD tekstgebieden
gText t1, t2, t3;
int sec_val, milli_val;

// Laserpoort
const int gateSensorPin = 2;
int gateSensorState;
int lastgateSensorState = LOW;
unsigned long lastDebounceTime = 0;
int debounceDelay = 50;

void setup() {
  pinMode(gateSensorPin, INPUT);
  delay(50); // Wachten tot sensor/stabilisatie
  
  GLCD.Init(NON_INVERTED);
  
  // Tekstgebieden definiëren
  t1.DefineArea(textAreaTOP, lcdnums14x24); // Rondenummer + huidige tijd
  t2.DefineArea(0, GLCD.CenterY, 8, 2, fixednums7x15); // Laatste ronde
  t3.DefineArea(GLCD.CenterX, GLCD.CenterY, 8, 2, fixednums7x15); // Beste ronde
  t3.SetFontColor(WHITE);
  t3.ClearArea();
  
  // Labels
  GLCD.SelectFont(System5x7);
  GLCD.CursorTo(1, 4); GLCD.print("LAST");
  GLCD.CursorTo(11, 4); GLCD.print("BEST");
  
  // Reset
  currentRunStartMillis = 0;
  lastRunInMillis = 0;
  bestRunInMillis = 0;
  currentLap = 0;
}

void loop() {
  int reading = digitalRead(gateSensorPin);
  
  // Debouncing
  if (reading != lastgateSensorState) {
    lastDebounceTime = millis();
  }
  
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != gateSensorState) {
      gateSensorState = reading;
      
      // LOW = straal onderbroken = auto passeert
      if (gateSensorState == LOW) {
        savedMillis = millis();
        
        if (currentLap > 0) {
          lastRunInMillis = savedMillis - currentRunStartMillis;
          if (lastRunInMillis < bestRunInMillis || bestRunInMillis == 0) {
            bestRunInMillis = lastRunInMillis;
          }
        }
        
        currentRunStartMillis = savedMillis;
        currentLap++;
      }
    }
  }
  lastgateSensorState = reading;
  
  // Display updaten
  savedMillis = millis();
  
  // Huidige rondetijd
  if (currentLap > 0) {
    calcResultFromMillis(savedMillis - currentRunStartMillis, &sec_val, &milli_val);
  } else {
    calcResultFromMillis(0, &sec_val, &milli_val);
  }
  
  t1.CursorTo(0, 0);
  t1.Printf(F("%02d"), currentLap); // Rondenummer
  t1.CursorTo(3, 0);
  t1.Printf(F("%02d.%03d"), sec_val, milli_val); // Huidige tijd
  
  // Laatste ronde
  calcResultFromMillis(lastRunInMillis, &sec_val, &milli_val);
  t2.CursorTo(1, 1);
  t2.Printf(F("%02d.%03d"), sec_val, milli_val);
  
  // Beste ronde
  calcResultFromMillis(bestRunInMillis, &sec_val, &milli_val);
  t3.CursorTo(1, 1);
  t3.Printf(F("%02d.%03d"), sec_val, milli_val);
}

// Helper: milliseconden → seconden + milliseconden
void calcResultFromMillis(unsigned long value, int *sec_val, int *milli_val) {
  *sec_val = int(value / 1000);
  *milli_val = value - *sec_val * 1000;
}

Resultaat

De teller werkt betrouwbaar met milliseconden-precisie. Ideaal voor slotcar-rennen of andere toepassingen waar een onderbroken straal een event triggert.