N-spoor – deel 20 – Snelheid meten

Hoe snel, of hoe hard, mag een model treintje eigenlijk rijden? Vaak rijden de modeltreintjes in verhouding te hard. Op de diverse modelspoor websites zijn hierover soms verhitte discussies te vinden. Met berekeningen en vergelijkingen. Het valt niet mee.
Uiteindelijk komt het er vaak op neer dat men kiest voor de “onderbuik-gevoel-snelheid”.

Maar het is natuurlijk wel leuk om de snelheid van je treintje te meten. Hiervoor toch die discussies her en der gevolgd om de gemeten snelheid op de baan om te zetten naar een snelheid in de echte wereld.

Op deze site heeft iemand de snelheid van zijn treintje gemeten over een afstand van 60 cm: zijn treintje deed daar 3838 ms over. Dat is omgerekend naar cm/s:

Snelheid = afstand/tijd
Snelheid = 60 / (3838/1000)
Snelheid = 15,6 cm/s

Om de echte-wereld-snelheid te berekenen heb ik de op die website genoemde formule gehanteerd.

Snelheid (km/h)  =   360 *  Afstand (dm) * Schaal (units) /  Tijd (ms)

Voor schaal N vullen we bij Schaal 160 in.

Snelheid = 360* 6* 160 / 3838
Snelheid = 90 km/u

De snelheden op het echte spoor variëren van ca 130 km/u voor hoofdtrajecten, 100 km/u op zijtrajecten, tot 40 – 60 km/u op rangeerterreinen. Een snelheid van 90 km/u past dus prima.

Maar nu: hoe gaan we de snelheid op mijn baantje meten? Hiervoor gaan we de TCRT5000-module inzetten die ik ook voor detectie op de draai/rangeerschijf heb gebruikt (zie hier).

In het schema van deze module kan je zien dat er een poortje van een 74HC14 (a high speed CMOS SCHMITT INVERTER) gebruikt wordt voor het uitgangssignaal en het aansturen van een LED: bij detectie licht de LED op, OUT-signaal wordt “1”.
De optimale afstand van sensor tot te-detecteren-object is volgens de datasheet slechts 2,5 mm. In de praktijk “ziet” de sensor de loc op een afstand van ca. 1 – 2 cm ook prima.

Twee van deze modules, aan een Arduino geknoopt, langs de rails met een bepaalde afstand X daartussen. De eerste module detecteert de loc, daarna wordt de loc door de tweede module gedetecteerd. De tijd die daartussen zit wordt geregistreerd in ms. Dat is alles! Een OLED-schermpje laat de resultaten zien.
Tijdens het testen werkte de boel ineens niet meer goed! De zon was ineens gaan schijnen en zorgde ervoor dat de sensor continu een “1” op de uitgang gaf! Goed om te weten natuurlijk. Dus óf niet gebruiken wanneer de zon schijnt, óf zorgen voor een betere afscherming (sensor opnemen in een kokertje, of zo).

Op de Arduino draait onderstaande sketch.

/* 
Snelheidsmeter loc's via een Arduino Nano

Bepaal tijd verstreken tussen 
het triggeren van twee lichtsluisjes

Lichtsluisje ter bepaling starttijd
Lichtsluisje ter bepaling eindtijd
*/

#include <Wire.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
// 0X3C+SA0 - 0x3C or 0x3D
#define I2C_ADDRESS 0x3C
SSD1306AsciiWire oled;

const int detectStart = A1;                     	// IR detector = draad geel
const int detectEind = A2;                      	// IR detector = draad blauw
//int btn = 2;                                      // Knop om waardes te laten zien

bool eerste_detectie = LOW;
bool tweede_detectie = LOW;
int StartStatus = LOW;
int EindStatus = LOW;
unsigned long starttijd;
unsigned long eindtijd;
unsigned long verstrekentijd;

unsigned long afstand = 20;									// De afstand tussen de twee lichtsluizen in cm
int snelheid;
unsigned long wereld_snelheid;


void setup() {
  //pinMode(detectStart, INPUT_PULLUP);
  //pinMode(detectEind, INPUT_PULLUP);
//  pinMode (btn, INPUT_PULLUP);
    
  // Begin Serial communication at a baud rate of 115200:
  Serial.begin(115200);
  Wire.begin();
  oled.begin(&Adafruit128x32, I2C_ADDRESS);
  oled.set400kHz();  
  oled.setFont(Adafruit5x7);  
  oled.clear(); 

  oled.print("Snelheidsmeter_3.ino");
  Serial.println("Snelheidsmeter_3.ino");
  delay(1500);
  oled.clear();
}


void loop() {
  oled.println("Nieuwe meting");
  Serial.println("Nieuwe meting");
  
  // Evt. startknop toevoegen.
  
  while (eerste_detectie == LOW) {            // Zolang geen detectie: wachten 
  detect_start();                             // Start vaststellen
  }
  while (tweede_detectie == LOW) {            // Zolang geen detectie: wachten 
  detect_eind();                              // Eindtijd vaststellen
  }
  
  // bereken het verschil = verstreken tijd
  verstrekentijd = eindtijd - starttijd;
  
  bereken();
  eerste_detectie = LOW;
  tweede_detectie = LOW; 
}


void detect_start() {
	StartStatus = digitalRead(detectStart);
	if (StartStatus == HIGH){
    oled.clear();
		// eerste gebeurtenis
		starttijd = millis();
    eerste_detectie = HIGH;    
	}
}


void detect_eind() {
  EindStatus = digitalRead(detectEind);
  if (EindStatus == HIGH){
	// tweede gebeurtenis
	eindtijd = millis();
  tweede_detectie = HIGH;
  }
}


void bereken() {
	oled.clear();
	
	// Bereken aan de hand van de verstreken tijd tussen 1e en 2e lichtsluisjes
	// de snelheid en de snelheid die de trein in de echte wereld zou hebben
	
	// snelheid = verstreken_tijd per afgelegde afstand
 
	snelheid = afstand/(verstrekentijd/1000);
  // Speed (km/h)  =   360 *  Distance (dm) * Scale  (units) /  Time  (ms)  
  wereld_snelheid = (360*(afstand/10)*160)/verstrekentijd;

 //   int btn_Status = digitalRead(btn);
 // if (btn_Status == LOW){
    oled.print("Tijd is ");
    oled.print(verstrekentijd);
    oled.println(" ms");
    
  	oled.print("Snelheid is ");
  	oled.print(snelheid);
  	oled.println(" cm/s");
  
    oled.print("Omgerekend ");
    oled.print(wereld_snelheid);
    oled.println(" km/u");
    // oled.print("");
//  }
  Serial.print("Snelheid is ");
  Serial.print(snelheid);
  Serial.println(" cm/s");

  Serial.print("De verstreken tijd is ");
  Serial.println(verstrekentijd);  
	
  Serial.print("Omgerekend ");
  Serial.print(wereld_snelheid);
  Serial.println(" km/u");
  Serial.println("");
}

En wat zijn dan de resultaten? In een volgend deel!