Tonen daadwerkelijke snelheid.

[Timo]

Wat Klaas vertelde is de eenvoudigste manier, een lichtsluis A en een B,  afstand is bekend,  de tijd wordt dan vastgelegd en in Excel de omrekening van snelheid.
Het enigste verschil dat ik doe is dat ik met IR reflectie werkt, en het rekenwerk laat doen door een microcontroller, geeft dan gelijk op een display de snelheid weer.

Uhm, dan ben je toch gewoon weer terug bij wat al gezegd is? Of je nu een PIC, een losse Atmel, een ARM of een Arduino pakt, dat maakt dan ook niet meer uit. En op dit moment zijn de Arduino clone boardjes (en of je het clone moet noemen is maar de vraag, iedereen mag een Arduino maken) gewoon best bang for the buck. Voor die 3 euro kan ik het zelf niet meer maken.

En of je nu lichtsluizen, IR reflectie, LDR's, stroomdetectie of drukknoppen gebruikt maakt in de basis ook niet uit. Je hebt gewoon twee inputs nodig die aangeven of de trein bij punt A of punt B is om de tijdmeting te kunnen starten/stoppen.


Timo

[Fransx]

Sorry Timo, het maakt terdege uit wat je voor input gebruikt.

Stroom detectie ben je afhankelijk van blokken en je moet digitaal rijden, dus niet bruikbaar voor analoge rijders.
LDR is helemaal niet te gebruiken om de licht gevoeligheid ook reflectie met de CNY70 en daar heb ik zeker ervaring mee.
Een IR lichtsluis of reflectie kan voor elke systeem gebruikt worden, componenten zijn hetzelfde alleen iets anders in gebruik.

Kost pijs is ook voor een PIC zeer laag, wat de prijs nu is is de interface en de inputs.

Opmerking:
Wat mij het meest opvalt is dat men er veel vanuit gaat dat men stroom detectie toepast, er zijn ook andere systemen voor detectie.

IK heb de software twee jaar geleden al ontwikkeld en dacht, ik reageer weer eens, helaas, heb er nu eigenlijk geen zin meer in om hierover verder op in te gaan.
Lekker vakantie vieren en tot misschien na half juli, Frans

[Fritsprt]

En of je nu lichtsluizen, IR reflectie, LDR's, stroomdetectie of drukknoppen gebruikt maakt in de basis ook niet uit. Je hebt gewoon twee inputs nodig die aangeven of de trein bij punt A of punt B is om de tijdmeting te kunnen starten/stoppen.

Volgens mij slaat Timo de spijker op zijn kop. Het principe is altijd hetzelfde. Om de snelheid uit te rekenen in km/h of m/s heb je altijd de tijd nodig die verstrijkt tussen die twee punten en de afstand tussen die twee punten. v=d/t

Om de snelheid van mijn Faller auto's te berekenen meette ik eenvoudig de tijd die ze er over deden om 1m af te leggen. Volgens onderstaande tabel bepaalde ik de snelheid.

Snelheidsberekening 1:87              km/h   cm/s   s/m        30   10   10,4 50   16   6,3 80   26   3,9 100   32   3,1 120   38   2,6

Ga je het electronisch doen dan mag het duidelijk zijn dat er verschillen tussen de sensoren zijn en dat de één meer geschikt is dan de ander. En hoe nauwkeurig wil je het hebben? Het blijft hobby. En het leuke van deze hobby is dat je het zo ingewikkeld mag maken als je zelf wil.

Groet, Frits

[Fransx]

Ach ja, nog even ter informatie, kan ook de meting doen op een rollerbank.

Frans

[Timo]

Hoi Frans, nu moet je je niet op je teentjes getrapt voelen, zo was mijn post echt net bedoelt  En als je de luxe hebt om nu vakantie te hebben dan bof je  Maar het ging mij er vooral om dat je eerst Klaas aan haalt (suggestie dat het puur in hardware kan) en dan vervolgens de opmerking maakt dat je een microcontroller in de mix gegooid hebt. Dan snijdt die opmerking geen hout meer en opper je precies hetzelfde als oa Max en ik. En tuurlijk zou iedereen het op prijs stellen als je de code deelt  Zou hier een universeel systeem gemaakt kunnen worden.

En wat ik zeg, welke microcontroller je dan pakt is om het even. Maar niets verslaat op dit moment een Arduino cloon bordje. Voor 3 euro is er zelf niet tegenaan te bouwen. Zelf kom ik ook van de PIC's en doe er nog regelmatig wat mee maar voor 3 euro gaat je dat niet lukken (uC, spanningsregelaar, PCB en mogelijkheid om te programmeren).

Afgezien van LDR hebben alle genoemde manieren van detectie een digitale output en maakt het geen fluit uit welke je nu uiteindelijk aan je systeem hangt. En zelfs een LDR kan op dezelfde hardware, alleen andere code en gaan. Dat is nu juist de hele grap van een microcontroller tegenover hardware. 

Stroom detectie ben je afhankelijk van blokken en je moet digitaal rijden, dus niet bruikbaar voor analoge rijders.

Dat is een misvatting. Stroomdetectie is prima te gebruiken bij analoog. Tijdens het meten van een snelheid staat er constant spanning op de baan dus kan er gewoon een melding gegeven worden. Ook kan je zelf bepalen waar je zo'n detectie plaatst, blok of geen blok. Wat wel een punt is dat de meeste stroomdetectie ontwerpen maar in één polariteit werken maar dit is in de meeste ontwerpen prima op te lossen door een AC optocoupler te gebruiken.

En waarom stroomdetectie populair is in dit draadje is omdat de topic starter heeft aangegeven al stroomdetectie op zijn baan heeft liggen. Het is dan natuurlijk super makkelijk hiervan gebruik te maken. Samen met het feit dat stroomdetectie een strak gedefinieerd begin/einde aangeeft. Maar er is de hele tijd de weg vrijgehouden voor andere soorten van detectie. Zeker omdat Max zelf LDR's gebruikt. En misschien geeft dit niet de meest nauwkeurige meting, bruikbaar zijn ze, zoals Max laat zien, zeker wel.


Timo (die hier niemand wil wegjagen  )

[peterha]

Hallo,

@Frans,
Je gaf naar mijn mening ook een hele zinvolle bijdrage voor mij; ik realiseerde me n.a.v. jouw reactie dat ik zelf ook nog twee lichtsluisjes heb, die ik daarvoor best kan gebruiken.
En als je zegt dat je ook software daarvoor hebt, dan kan jouw oplossing toch ook prima werken? Ik ben wel benieuwd, misschien maakt de samenvoeging van al jullie software oplossingen wel een perfect product?

Naar aanleiding van een ieders bijdrage kunnen toch ook voor- en nadelen van diverse componenten besproken worden? Overigens kan en moet ieder gewoon doen wat hij (of zij) het beste acht.

Een rollenbank is statisch en misschien goed om de snelheidsstappen van een loc te bepalen, maar wat ik wil is de snelheid meten van een daadwerkelijk rijdende trein. Daar is een rollenbank niet geschikt voor.

@Timo,
Ik heb inderdaad mijn baan opgedeeld in blokken en voorzien van bezet-/terugmelders. Maar of en hoe deze dan gebruikt kunnen worden voor bedoelde snelheidsmeting weet ik niet.
Die melders worden tenslotte al gebruikt voor de terugmeldkaart BDL168. Kun je ze dan tegelijk ook nog gebruiken voor een snelheidsmeting?

Als het gebruik van LDR's minder betrouwbaar is, dan kun je toch ook een soort 'tunneltje' maken, waarbij je desnoods een lampje inbouwt, zodat er een constant, gelijk licht is en het omgevingslicht niet meer zoveel uitmaakt? Of is dat te simpel gedacht?

Peter

[Timo]

Zoals altijd leiden meerdere wegen naar Rome 

LDR's zijn wat onnauwkeurig doordat je niet met zekerheid kunt zeggen wanneer (dus positie van de loc over de LDR) de LDR onder de drempelwaarde zakt. Dit doordat je niet met zekerheid kunt zeggen waar het licht vandaan komt, hoe de LDR geplaatst is en verschil in LDR's. Dit zou je wat kunnen ondervangen door kokertjes en extra lichtbronnen. Eigenlijk ga je dan naar een klassieke lichtsluis. Hoe belangrijk een nauwkeurige meting is hangt af van de lengte van het stuk spoor, de snelheid (en dus ook de schaal) en hoe belangrijk jij een fout vindt.

Manieren van detectie die ik zo even kan bedenken:
- Stroomdetectie
- IR Lichtsluis
- LDR (al dan niet als sluis)
- IR reflectie
- Reedswitches
- Hallsensoren
- Schakelaars onder de rails (lijkt me niet heel pratisch)
- Drukknoppen (krijg je dus eigenlijk gewoon een stopwatch die de snelheid geeft ipv tijd)

In de basis zijn ze allemaal gelijk => de tijd moet bepaald worden tussen twee gebeurtenissen.

Overigens is de stoomdetectie prima te gebruiken voor zowel S88 als snelheidsmeting. Je tapt de draden tussen stroomdetectie en S88 af van de blokken die je wilt gebruiken + de GND draad van de S88 bus. Die drie draden hang je aan een Arduino en je zorgt dat je deze voedt uit een losse voeding.

@Max, heb jij de laatste code nog kunnen uitgraven? Anders begin ik met aanpassen van je oudere code (vooral voor andere schermen enzo).


Timo

[Max Roodveldt]

Timo,
voor dat ik die code hier neer zet wil ik 't eerst even proberen. 
Dat kan morgenochtend na 10en. Kun je tot zolang nog even geduld hebben? 

(omdat de code voor de lichtsluis onderdeel is van een groter geheel - PBM snelheidsregelaar, stopwatch, snelheidsmeter - heb ik de code even gestript)

Ook zal ik een paar LDR's plaatsen in m'n Roco ovaaltje - al is 't alleen maar om met eigen ogen te zien hoe groot de spreiding is.
Ik ben nu eenmaal dol op dingen waarvan anderen zeggen dat ze niet gaan...

mvg

[Max Roodveldt]

Dit werkt:

Code: [Selecteer]

/*****************************************************************************
test versie: Speedometer met LDR's
*****************************************************************************/

// libraries
#include <Wire.h>
#include "Adafruit_LEDBackpack.h"
#include "Adafruit_GFX.h"

Adafruit_7segment display = Adafruit_7segment();

const int LDRleft       =     A0; // LDR left
const int LDRright      =     A1; // LDR right

const int Overflow      =  10000;
unsigned long curTime   =      0;
unsigned long preTime   =      0;
unsigned long runTime   =      0;

// speedometer
bool  timerRuns         =  false;
bool  fromLeft          =  false;
bool  fromRight         =  false;
bool  calcReady         =  false;
int   valLeft           =      0;
int   valRight          =      0;
int   refLight          =    511; // 0 is geheel bedekt, 1023 is vol verlicht
float distance          =     98; // afstand tussen LDR's in mm.
float scaleSpeed        =      0; // in schaal km/h.

// display schaalsnelheid
unsigned long showTime  =  5000; // tijd snelheid zichtbaar in ms
unsigned long showStart =     0;

/****************************************************************************/

void setup() {
 
  // set display
  display.begin(0x70);
  display.setBrightness(7); // 0..15
  display.writeDisplay();

  calibrateSpeedometer();

  showStart = millis();
 
} // end setup

/****************************************************************************/

void loop() {
   
   speedometer();
   displaySpeed();
 
} // end loop

/****************************************************************************/

void calibrateSpeedometer() {                            // check the light...

  valLeft  = analogRead(LDRleft);
  valRight = analogRead(LDRright);
  refLight = (valLeft + valRight) / 4;                 // helft van gemiddelde
 
  display.println(refLight);
  display.writeDisplay();

  delay(2500); 
 
  display.println(Overflow);                                // display "----"
  display.writeDisplay();
 
}

/****************************************************************************/

void speedometer() {
 
  if (calcReady) return;            // als berekening klaar is rest overslaan.

  valLeft  = analogRead(LDRleft);
  valRight = analogRead(LDRright);

  if (!timerRuns) {                                         // nog geen meting

    if (valLeft < refLight || valRight < refLight) { // links of rechts bezet?
      timerRuns = true;                                        // meting loopt
      preTime   = millis();
      runTime   = 0;
      if (valLeft  < refLight) fromLeft  = true;
      if (valRight < refLight) fromRight = true;
    }

  } else {                                           // als de meting loopt...
 
    curTime = millis();         
    runTime = curTime - preTime;
   
    if (fromLeft  && (valRight < refLight) ||
        fromRight && (valLeft  < refLight)) {              // meting ten einde
     
      // bereken schaal snelheid
      scaleSpeed = ((distance * 3600) / runTime / 1000) * 87;
      calcReady  = true;
      timerRuns  = false;
      fromLeft   = false;
      fromRight  = false;
      showStart  = millis();
    }
  }
}

/****************************************************************************/

void displaySpeed() {
 
  unsigned long timeNow = millis();

  if (timerRuns) {                         // als snelheidsmeting gaande is...
   
    if ((runTime / 100) % 2) {                            // knipperen display
      display.println(Overflow);                             // display "----"
    } else
      display.clear();                                       // display "    "
   
  } else {

    if (calcReady) {                        // als snelheidsmeting klaar is...
      if ((timeNow - showTime) < showStart) {
        display.print(scaleSpeed, 1);      // display gemeten snelheid in km/h
      } else {
        calcReady = false;
        showStart = timeNow;
        display.println(Overflow);                           // display "----"
      }
    }
  }
  display.writeDisplay();
}

/****************************************************************************/

Tijdens het opstarten lees ik even het beschikbare licht zodat ik een referentiepunt heb. Als dat klaar is zie ik "----". Na het passeren van het eerste meetpunt zie ik "----" knipperen, na het passeren van het tweede meetpunt verschijnt voor 5 sec. de snelheid in km/h als "123.4". Daarna weer "----" en kan de volgende meting plaats vinden. Als ik er met dezelfde snelheid meerdere malen overheen rij zie ik steeds hetzelfde resultaat dus met de nauwkeurigheid zal het wel meevallen...

Het lijkt me wel lollig een en ander ook eens met andere sensoren te proberen: vooral IR reflectie klinkt interessant, omdat dat ook tussen de biels zou moeten kunnen.

wordt vervolgd...

[gvandersel]

Is dat Ardiuno verplicht tegenwoordig?
Download koploper (of iTrain of RocRail) Maak twee secties van 20 cm op 80 cm afstand.
Voer beide secties in in koploper en ga je trein ijken. Je weet dan precies bij welke stap welke snelheid hoort.

Groet,

Gerard van der Sel.

[peterha]

Gerard, het gaat me niet om het ijken van de lokomotieven maar, zoals al meermalen aangehaald, het kijken wat de daadwerkelijke snelheid van de treinen is als ze rijden.

Ik gebruik iTrain en daarmee heb ik ook al mijn treinen geijkt voor alle 28 snelheidsstappen, zoals je ook doet in Koploper, TrainController etc.
Met Rocrail kun je je treinen zo niet ijken, maar moet je de hoogste snelheid bepalen en die via de decodersetting aanpassen aan je gewenste snelheid. Wat Rocrail wel heeft, is de mogelijkheid om in het server venster de snelheid te tonen van de trein die op dat moment door een gedefinieerd blok rijdt.

Dat kan iTrain niet, dat kan Koploper niet, dat kan Traincontroller niet en ik wil een apart iets hebben waarmee ik dat wel kan, los van het programma en ik wil dat in een display'tje getoond hebben.

Groeten, Peter.

Een van de mogelijkheden is Arduino, maar zoals Fransx ook zei, het kan ook met een PIC.
Nogmaals, het gaat me niet om het ijkproces.

[gvandersel]

Dan kan het nog simpeler. Neem de "Lichtsluis van Huub Maaskant". En laat deze de rol van de reedswitch overnemen. Lengte van een route uitrekenen en de trein deze af laten leggen.

Groet,

Gerard van der Sel.

[Timo]

@Gerard, en wat bepaald dan de tijd?


Timo

[ex44]

ESU komt met een meetwagen (of misschien is die al wel leverbaar, dat weet ik zo niet) waar je ook allerlei dingen mee kunt meten. Schijnt ook via (een) functietoets(en) op afstand te werken.

[Max Roodveldt]

Dat meetwagentje is best wel interessant. Jammer dat 'ie wat lang is (>40ft) en buffertjes heeft. En misschien wat onhandig op een rangeerbaantje. Maar vooral de prijs is aantrekkelijk - slechts €179... 

mvg

PS - ik heb nog wat software voor een stopwatch ook - indien gewenst...