Hey,
in m'n projectje (chronometer hondensport) stoot ik als beginneling op een praktisch probleempje/
m'n chronometer project moet van verschillende, opeenvolgende honden een tijdsopname doen.
ik kan perfect een tijdsopname doen van 1 hondje, no problem.
maar als een volgende hond in de baan komt heb ik momenteel een klein? probleem.
het zit zo:
er staan twee rijen fotocellen op 15 cm uit elkaar aan de ingang van de baan.
voor alle gemak noem ik ze A & B, waarbij A de zijde naar de geleiders is (en dat is ook tegelijk de chrono lijn) en B de zijde van de baan is, (hier wordt bepaald of er al dan niet een hond in de baan is)
de eerste hond komt in de baan, en er wordt een tijd genomen, quasi ogenblikkelijk daarna kruist de neus van de hond ook lijn B, dus er zijn twee sensorlijnen gelijktijdig onderbroken gedurende x aantal duizendsten van een seconde (variabel naargelang de snelheid van de hond).
op een bepaald moment verlaat het achterlijf van de hond sensorlijn A maar is nog actief binnen sensorlijn B, tot op het moment dat de hond daar ook volledig doorgelopen is.
de hond gaat om een balletje en komt terug...
eerst door sensorlijn B ditmaal en quasi ogenblikkelijk erna ook door sensorlijn A.
op het moment dat de hond door sensorlijn A loopt richting baasje, dan neem ik terug een tijd op.
nu zijn er een aantal mogelijkheden voor de daaropvolgende 3 honden:
-
de volgende hond is een ietsje te laat vertrokken en de eerste hond is al uit de beide sensorlijnen eer de volgende hond aan de sensors komt
-
de volgende hond is veel te vroeg vertrokken, en loopt door de sensorslijnen A & B vooraleer de vorige hond door sensorlijn B gelopen is
-
de volgende hond en de eerdere hond lopen quasi gelijktijdig door de beide sensorlijn, maar de eerste hond was eerst door sensorlijn B en dan pas de volgende hond door sensorlijn A (dit is wat we beogen in deze sport, de nauwst mogelijke kruisingen van 2 honden)
in dit geval is het quasi onmogelijk om te zien hoeveel duizendsten de tweede hond over had op z'n kruising omdat beide honden gelijktijdig door de beide sensorlijnen lopen... -
de eerste hond maakt een fout en komt naast de baan terug, en loopt dus niet door sensorlijnen A & B bij de terugkeer (hierop reageert de lijnrechter door een welbepaalde lamp aan te zetten), de volgende hond komt dus door de sensors en krijgt een foutmelding daardoor
-
de eerste hond is juist niet helemaal uit de sensorlijn A als de volgende hond er net wel inkomt, waardoor de sensorlijn A niet onderbroken werd maar wel de sensorlijn B zeer kortstondig.
nu heb ik reeds een groot deel van deze mogelijkheden uitgezet in een excel bestand, met een tijdsinterval van 1 milliseconde.
mijn grootste probleem is momenteel het volgende:
als er een hond door de sensorlijnen loopt dan verzet ik een vlag (HIB = Hond In Baan), maar doordat de honden x aantal milliseconden de sensors onderbreken, komt bij een volgende doorgang van de loop{} natuurlijk direct de volgende voorwaarde voor een tijdsopname kijken
hieronder een stukje van m'n huidige code:
Hond =0;
debounceB =0;
//#### Routine voor de "A" sensor bij een correcte 1ste hond naar de box ####
if (startLijnSensor == HIGH && HIB == LOW && toonDisplay == LOW && debounceB == 0)
{
Hond++; // toon aan dat hond 1 in de baan is
Heat[Hond].wisselTijd = millis(); // neem een eerste tijd
toonDisplay = HIGH; // toon aan dat de gegevens op een bepaald moment mogen getoond worden (idle)
}
//#### Routine voor de "B" sensor bij het doorlopen NAAR de box ####
if (passLijnSensor == HIGH && HIB == LOW && debounceB == 0)
{
debounceB = millis(); // neem een tijd voor later gebruik
HIB = HIGH; // Toon aan dat er een hond op de baan zit
}
//#### Routine voor de sensor : "FotoCelB" bij het doorlopen NAAR de geleider ####
if (passLijnSensor == HIGH && HIB == HIGH && (millis() - debounceB) > 1000 && debounceB != 0)
{
HIB = LOW; // de hond heeft net de baan correct verlaten
toonDisplay = LOW; // toon aan dat er bij "idle" terug gegevens mogen getoond worden
}
//#### Routine voor de sensor : "FotoCelA" bij het doorlopen NAAR de geleider van 1° hond ####
if (startLijnSensor == HIGH && HIB == LOW && toonDisplay == LOW && debounceB > 0 )
{
Heat[Hond].loopTijd = millis(); // neem de eindtijd van deze hond
}
//#############################################################
in feite moet ik kunnen meten of een fotosensor onderbroken werd of niet gedurende een bepaalde tijd (een vaste waarde helpt niet, omdat niet alle honden even snel lopen)
ik zoek dus naar een systeem dat me verteld:
de sensorlijn (A of B) is gedurende x milliseconden NIET onderbroken geweest, dus de nieuwe voorwaarde gaat pas in nadat er een onderbreking was...
enige uitzondering is de perfecte kruising, waarbij de doorgang van de twee honden als een vloeiend geheel waargenomen wordt
iemand een idee?
ik vrees eigenlijk dat dit zelfs voor een wiskundige & programmeur is, want ik loop steeds terug vast tegen de loop{} functie
ik ben wel in het bezit van een demo programma waarop dit visueel wordt weergegeven als iemand dit nuttig zou vinden
Grtz,
Yves
