Ik moest de metalen as waarop het de voelers kwamen, isoleren...
... en in tweëen 'delen', d.w.z. bij elke omwenteling van de as moesten er twee pulsen gegeven worden anders kon de fietscomputer niet goed ingesteld worden om de juiste snelheid te tonen. Of ik moest bij een omwenteling de getoonde snelheid x2 doen. Dat werkte niet echt betrouwbaar.
Het meetwagentje hing achter de trein en om de snelheid te lezen, moest je a.h.w. even achter de trein aan lopen om 'm te kunnen aflezen.
Ik vond dat niet zo'n succes. Daarbij komt dat ik nu bij mijn sluitwagons de koppeling verwijderd heb, zodoende kan ik 'm niet meer achter een trein hangen.
Vandaar dat ik liever een stationaire meting langs de baan doe, waarbij de snelheid (gemeten over een vaste afstand) van de voorbij rijdende trein getoond wordt.
/********************************************************************
Speedometer
als er bij opstarten licht brand boven de ldr's zijn ze alle twee hoog,
dwz boven het kantelpunt (offset = 511) en gaat alles goed.
dus alvorens de speedometer te gebruiken controleren of er voldoende
licht aanwezig is.
********************************************************************/
#include <Wire.h>
#include "Adafruit_LEDBackpack.h"
#include "Adafruit_GFX.h"
Adafruit_7segment display = Adafruit_7segment();
#define ldrLeft A2 // linker lichtsluis
#define ldrRight A3 // rechter lichtsluis
bool timerRuns = false;
bool fromLeft = false;
bool fromRight = false;
bool drawDots = false;
bool reset = false;
unsigned long curTime = 0;
unsigned long preTime = 0;
unsigned long runTime = 0;
int valLeft = 0;
int valRight = 0;
int offset = 511; // 0 is geheel bedekt, 1023 is vol verlicht
float distance = 98; // afstand tussen LDR's in mm.
float speed = 10000; // preset in schaal km/h.
/*******************************************************************/
void setup() {
display.begin(0x70);
display.setBrightness(7); // 0..15
display.print(speed, 1); // display "----"
display.writeDisplay();
pinMode(ldrLeft, INPUT);
pinMode(ldrRight, INPUT);
delay(5000); // opstartvertraging 5 seconden
} // end of setup
/*******************************************************************/
void loop() {
valLeft = analogRead(ldrLeft); delay(10);
valRight = analogRead(ldrRight); delay(10);
speedometer();
} // end of loop
/*******************************************************************/
void speedometer() {
if (!timerRuns) { // nog geen meting
if (valLeft < offset || valRight < offset) { // links of rechts bezet ?
timerRuns = true;
preTime = millis();
runTime = 0;
if (valLeft < offset) fromLeft = true;
if (valRight < offset) fromRight = true;
// alle 2 bezet of te weinig licht: is foute boel, dus opnieuw...
if (fromLeft && fromRight) reset = true;
}
} else { // meting loopt...
curTime = millis();
runTime = curTime - preTime;
if ((runTime / 500) % 2) // knipperen display
display.print(speed, 1);
else
display.clear();
display.writeDisplay();
if (fromLeft && (valRight < offset) ||
fromRight && (valLeft < offset)) {
preTime = curTime;
calculateSpeed();
}
}
} // end of speedometer
/*******************************************************************/
void calculateSpeed() {
if (!reset) {
speed = ((distance * 3600) / runTime / 1000) * 87;
display.print(speed, 1); // display gemeten snelheid in km/h
display.writeDisplay();
delay(5000); // display speed for 5 seconds
}
timerRuns = false; // reset speedometer
fromLeft = false;
fromRight = false;
reset = false;
speed = 10000;
display.print(speed, 1); // display "----"
display.writeDisplay();
} // end of calculateSpeed
/*******************************************************************/
Dan heb je hier helemaal niets aan. Ik ben benieuwd!
.... een Arduino met wat software voor het rekenwerk en klaar is Peter. Indien gewenst heb ik een schema en wat software ter informatie...
Zie in ieder geval al wel dat je software voor H0 is.
@Klaas, moet je nog steeds iets hebben dat de tijd opslaat...Jawel, maar tijd meten is veel makkelijker dan snelheid bepalen.
Voor die andere moet je zelf een interface bouwen. Uiteindelijk kosten ze dan evenveel...Die op Banggood is (net als de I2C variant) ook gewoon direct aan de Arduino te koppelen. Kost je alleen 3 draadjes maar pinnen zat op zo'n Arduino. Ondanks dat ze hetzelfde display hebben stuur je ze beide iets anders aan (I2C tegen shift register), verder geen probleem. Zowel die met shift register als die met I2C hebben het genoemde display op Kiwi. Die is ook wel zo aan een Arduino te hangen (alleen weerstanden nodig) maar kost je wel heel veel pinnen. Die valt dus wel af, zeker omdat hij ook meer kost.
Bij deze (https://www.kiwi-electronics.nl/1-4cm-4-Digit-7-Segment-Display-met-I2C-Backpack-Rood?gclid=CKGf-eG6v8UCFWrJtAodmQ4A5g) staat dat die op basis van I2C is. Wat dat betekent weet ik niet, maar betekent dat wel dat ik 'm zonder problemen en rechtstreeks op het (kloon) Arduino board kan aansluiten en dat deze (https://www.kiwi-electronics.nl/1-4cm-4-Digit-7-Segment-Display-Rood) dat niet kan?
Afgezien dat die Adafruit iets duurder is, vind ik dat wanneer die zonder probleem geïnstalleerd kan worden, dat wel een groot voordeel.
Gisteren stond ik met een biertje in de hand te genieten van de zon en een muziekje dus kon niet reageren.
Wat betreft libraries, iedereen kan er een maken dus je kunt ze ook echt overal vinden. Maar voor jou (en eigenlijk iedereen) is het gewoon makkelijk om een complete download (zipje) te maken met alle benodigde code bij elkaar.
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.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.
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.
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.
| 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 |
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.
/*****************************************************************************
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();
}
/****************************************************************************/
Dat meetwagentje is best wel interessant. Jammer dat 'ie wat lang is (>40ft) en buffertjes heeft. En misschien wat onhandig op een rangeerbaantje. Maar ....
ESU komt met een meetwagen (http://www.esu.eu/produkte/engineering-edition/messwagen-ehg-388/) (of misschien is die al wel leverbaar, ......
Maar vooral de prijs is aantrekkelijk - slechts €179... 8)En dat is nu precies de reden waarom ik dit soort diy-projecten liever heb; eigen werk en goedkoper.
ik heb nog wat software voor een stopwatch ook - indien gewenst...Max, zou je ook nog iets kunnen maken voor het werken met IR sensoren. Of Timo misschien? Want bij nader inzien wil ik mijn lichtsluisjes liever voor wat anders gebruiken.
Max, zou je ook nog iets kunnen maken voor het werken met IR sensoren. Of Timo misschien?
Wat betreft het aanwezig blijven van het programma: welkom in d emoderne wereld van microcontrollers.Inderdaad, na wat neuzen en speuren op Internet gaat er zeker een nieuwe wereld voor mij open.
/*****************************************************************************
test versie: Speedometer tbv Peter
*****************************************************************************/
// 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 uit, 1023 is aan
float distance = 98; // afstand tussen meetpunten 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();
showStart = millis();
} // end setup
/****************************************************************************/
void loop() {
speedometer();
displaySpeed();
} // end loop
/****************************************************************************/
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();
}
/****************************************************************************/
Dus inderdaad zoals je aangeeft:
A0 en A1 beide geen spanning: geen trein/bezetmelding in beide secties;
A0 gaat hoog: de trein rijdt de sectie binnen, dus start meting;
A1 gaat hoog: de trein verlaat deze sectie en gaat de volgende sectie binnen: stop meting.
Hoe lang A0 of A1 hoog blijven is m.i. niet belangrijk. Als er een heeeeele lang trein in dat blok rijdt (die heb ik overigens niet) kan in theorie zowel A0 alsook A1 hoog zijn.
Maar een gegeven moment is de trein beide blokken uit en zijn beide melders dus weer laag en kan een nieuwe meting beginnen.
De regel:
scaleSpeed = ((distance * 3600) / runTime / 1000) * 87;
is voor Peter volledig valide. Voor een modelspoorder is het handiger als de 87 een constante wordt.
Ik als N rijder kan hier dan 160 invullen, die dan automatisch via compileren goed gezet wordt.
Vraag van een niet Arduino bezitter:
Doet analogRead(A0) een digitale read?
Ik zal de variabele 'distance' aanpassen aan mijn situatie, nl. 3660 mm.
En als ik de weerstanden aanbreng en de verbinding van de BDL naar de Arduino, zou het moeten werken?
Doet analogRead(A0) een digitale read?Zoals de naam al zegt leest analogRead(A0) de analoge waarde van A0. Je kunt A0 overigens gewoon als digitale input gebruiken door digitalRead(A0) te doen. De Arduino (Uno) heeft 14 digitale in- en uitgangen (0 - 13) en 6 (A0 - A5) analoge ingangen. Je kan A0 -A5 zefs gewoon doortellen vanaf 14. M.a.w. A0 = 14, A1 = 15 enz.
/*****************************************************************************
test versie: Speedometer tbv Peter
*****************************************************************************/
// 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 uit, 1023 is aan
float distance = 98; // afstand tussen meetpunten 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();
Serial.begin(9600);
Serial.println("Check inputs");
showStart = millis();
display.println(Overflow); // display "----"
} // end setup
/****************************************************************************/
void loop() {
speedometer();
displaySpeed();
} // end loop
/****************************************************************************/
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;
Serial.print("start left = "); Serial.println(valLeft);
Serial.print("start right = "); Serial.println(valRight);
}
} 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();
Serial.print("finish left = "); Serial.println(valLeft);
Serial.print("finish right = "); Serial.println(valRight);
Serial.print("scale speed = "); Serial.println(scaleSpeed, 1);
}
}
}
/****************************************************************************/
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();
}
/****************************************************************************/
Een nieuwe meting kan pas plaats vinden als het tweede blok ook verlaten is. Denk ik... 8)Hoewel het in praktijk ook voorkomt dat twee blokken achter elkaar bezet zijn... Wat dan?
(aan de overkant is een begraafplaats...)Nou ja, dan heb je daar ook weinig last van ;)
Hoewel het in praktijk ook voorkomt dat twee blokken achter elkaar bezet zijn... Wat dan?Maar je gaat toch geen snelheid meten als het volgende blok bezet is... ???
Misschien toch handiger om te meten met IR of LDR en over een kortere afstand?Dat nooit. ;D Je hebt de perfecte melders liggen... ;)
Of wordt dit nu een uitdaging die we toch gaan oplossen? ;DYep... 8)
Maar je gaat toch geen snelheid meten als het volgende blok bezet is... ???Wat ik bedoel te zeggen is, dat de Arduino staat ingesteld om snelheid te meten wanneer melder 1 getriggerd wordt en meet wanneer melder 2 getriggerd wordt.
/*****************************************************************************
test versie: Speedometer tbv Peter
*****************************************************************************/
// libraries
#include <Wire.h>
#include "Adafruit_LEDBackpack.h"
#include "Adafruit_GFX.h"
Adafruit_7segment display = Adafruit_7segment();
const int section1 = A0; // first section
const int section2 = A1; // second section
const int Overflow = 10000;
unsigned long curTime = 0;
unsigned long preTime = 0;
unsigned long runTime = 0;
// speedometer
bool sect1occup = false;
bool sect2occup = false;
bool timerRuns = false;
bool calcReady = false;
int valSect1 = 0;
int valSect2 = 0;
int threshold = 511; // 0 is uit, 1023 is aan
float distance = 3450; // afstand tussen meetpunten in mm.
float scaleSpeed = 0; // in schaal km/h.
/****************************************************************************/
void setup() {
// set display
display.begin(0x70);
display.setBrightness(7); // 0..15
display.writeDisplay();
Serial.begin(9600);
Serial.println("Check inputs");
display.println(Overflow); // display "----"
} // end setup
/****************************************************************************/
void loop() {
speedometer();
displaySpeed();
} // end loop
/****************************************************************************/
void speedometer() {
valSect1 = analogRead(section1);
valSect2 = analogRead(section2);
if (valSect1 > threshold) sect1occup = true; else sect1occup = false;
if (valSect2 > threshold) sect2occup = true; else sect2occup = false;
if (!timerRuns) { // nog geen meting
if (sect1occup && !sect2occup) { // meting begint
timerRuns = true;
preTime = millis();
runTime = 0;
Serial.print("sector 1 = "); Serial.println(valSect1);
}
} else { // als de meting loopt...
curTime = millis();
runTime = curTime - preTime;
if (sect2occup) { // meting ten einde
// bereken schaal snelheid
scaleSpeed = ((distance * 3600) / runTime / 1000) * 87;
calcReady = true;
timerRuns = false;
Serial.print("sector 2 = "); Serial.println(valSect2);
Serial.print(" speed = "); Serial.println(scaleSpeed, 1);
}
}
}
/****************************************************************************/
void displaySpeed() {
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...
display.print(scaleSpeed, 1); // display gemeten snelheid in km/h
if (!sect1occup && !sect2occup) calcReady = false;
} else {
display.println(Overflow); // display "----"
}
}
display.writeDisplay();
}
/****************************************************************************/
#define TEST 1
#if (TEST == 1)
byte varname = 1;
//const byte bla = 2;
#endif
#if (TEST == 2)
const byte bla = 2;
#endif
void setup() {
// put your setup code here, to run once:
}
void loop() {
// put your main code here, to run repeatedly:
}
Zolang TEST i 1, dan is er geen probleem. Maar zodra je er een 2 van maakt is het mis. En het gaat dan ook alleen mis als je ergens daarin een variable probeert te maken. Ik snap even niet meer waarom. Je hebt nu de displaytijd aangepast zodat deze de snelheid toont, zolang de 2e bezetmelder actief is?Inderdaad... 8)
Echter, vandaag heb ik mijn kleinzoontje om op te passen, dus niet veel tijd om rustig en uitgebreid te testen.;D Je bent opa of je bent 't niet... ;D
Zal pas weer in de loop van de middag kunnen :(
#DEFINE TEST1 1
;#DEFINE TEST2 1
#ifdef TEST1
; Doe iets voor TEST1
#endif
#ifdef TEST2
; Doe iets voor TEST2
#endif
Daarnet even een uurtje getest, maar ik denk dat we 'm nu wel hebben. (y)Dat is mooi - om niet te zeggen heel mooi. (y)
De metingen met een losse loc, een korte trein en een lange trein gingen allemaal goed.
Het enige is -vooralsnog- dat, wanneer 2 treinen achter elkaar rijden met verschillende topsnelheden en de langzamere rijdt voor, dat dan de snellere trein moet afremmen. Als dit gebeurt wanneer voor trein 1 een meting plaatsvindt en de snellere trein moet afremmen en gaat versnellen wanneer sector 2 vrijkomt (en trein 2 dus niet met volle snelheid het blok/meettraject kan berijden), is het dan even opletten.Dat is logisch: om goed te kunnen meten moet de snelheid wel constant zijn. 8)
Heb ook geconstateerd dat als trein A nog in sector 2 rijdt en trein B gaat al sector 1 binnen, dat dan ook een geldige meting plaatsvindt, al zal de gemeten snelheid dan niet correct zijn. Maar dat is dan maar zo.Dat is dan fout - dat zal ik nakijken. ???
De waarden van valSect1 en valSect 2 schommelen tussen 999 en 1011, met een gemiddelde van 1003. Zijn toch mooie waarden?Dat is perfect - niets meer aan veranderen.
Ik heb er nu 47k weerstanden tussen zitten. Dit is nog steeds een goede waarde?
Moet er nu nog meer gebeuren?Ja. Als het gaat zoals ik hoop dat het gaat hebben we straks diverse stukjes schakeling en software voor verschillende situaties. Die moeten dan in elkaar geschoven worden tot een groot geheel - en daarna getest. Het zou plezierig zijn als je daar dan mee zou willen helpen. Mocht je in de tussentijd nog meer op- en aanmerkingen hebben - graag. Experimentjes als dit zijn heel leerzaam.
Het enige is -vooralsnog- dat, wanneer 2 treinen achter elkaar rijden met verschillende topsnelheden en de langzamere rijdt voor, dat dan de snellere trein moet afremmen. Als dit gebeurt wanneer voor trein 1 een meting plaatsvindt en de snellere trein moet afremmen en gaat versnellen wanneer sector 2 vrijkomt (en trein 2 dus niet met volle snelheid het blok/meettraject kan berijden), is het dan even opletten.Tja, als een trein afremt geeft het niet wat je wil nee :p Er is geen andere plaats waar je kunt meten? Je zou ook een extra sectie kunnen maken (stroomdetectie) en deze gebruiken. Als je dan wel een stuk hebt waar de trein altijd snel gaat.
/***************************************************
SpeedOmeter v1.0 - Speedometer for modelrailroad
Created by Timo Engelgeer (Septillion), May 28, 2015
Based on Speedometer bij Max Roodveldt
Calculates the (scale) speed of a (model) train based on two
detections on the layout. This can be any kind you like.
****************************************************/
#define SPEEDOMETER_VERSION "v1.0"
/***** Configuration *******************************
The Speedometer is made very versatile. So in order to make it work with your setup
you have to configure it. The next few blocks will guide you to the configuration.
-- Display --
Because you can use different display's with Speedometer you have to select the correct one.
1 SSD1306 128x64 OLED display (I2C, default adress 0x3C)
2 Adafruit 7-segment display (I2C, default adress is 0x70)
****************************************************/
#define LCD_TYPE 2
/**-- Sensor --
It doesn't matter what kind of sensor you use. This can be an active low (signal goes
low when train passes) or active high (signal goes high when train passes).
#define ACTIVE_LOW for active low (uncommented)
//#define ACTIVE_LOW for active high (commented)
Analoog komt nog ;)
**/
#define ACTIVE_LOW
/**-- Pins --
To which pins are the sensors connected? Left and Right respectively
**/
const byte InputL = 9;
const byte InputR = 10;
/**-- Settings --
Distance => Distance between start of the first detector and
the start of the second (in mm)
Scale => Scale of the layout
TimeShowSpeed =>Time to show the speed after finishing the measurement (in ms)
TimeOut => Time to ignore re-triggering the detector after
finishing measurement (in ms)
**/
unsigned int distance = 5000;
unsigned int scale = 87;
const unsigned int TimeShowSpeed = 5000;
const unsigned int TimeOut = 3000;
/**-- Done! --
You are done. Upload the sketch!
**/
//SSD1306 based OLED display
#if (LCD_TYPE == 1)
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
Adafruit_SSD1306 display(255);
const byte I2CAdress = 0x3C;
#define INFO_EXTEND
//Adafruit 7-segment I2C
#else if (LCD_TYPE == 2)
#include <Wire.h>
#include "Adafruit_LEDBackpack.h"
#include "Adafruit_GFX.h"
Adafruit_7segment display = Adafruit_7segment();
const byte I2CAdress = 0x70;
const byte DisplayBrightness = 7; // 0..15
#endif
/***** Global vars *********************************/
bool timerRuns = false; //Does the timer run?
bool direction = false; //In which direction? (false = to left, true = to right
bool ready = true; //ready to start the clock?
byte displayScreen = 0; //Which screen is displayed last?
unsigned long startTime; //Saved start time
unsigned long endTime; //Saved end time
unsigned long showTimer = -1;//Time when display started showing something
//Speed stats
unsigned int speed, maxSpeed, minSpeed, avgSpeed = 0;
/***** Default functions ***************************/
void setup() {
//Initialize the display
displayInit();
//Set the input acording to the setting
#if defined(ACTIVE_LOW)
pinMode(InputL, INPUT_PULLUP);
pinMode(InputR, INPUT_PULLUP);
#else
pinMode(InputL, INPUT);
pinMode(InputR, INPUT);
#endif
}
void loop(){
//Check for a finished measurement
if(checkInput()){
//If so, calculate the speed and display it
speed = calcSpeed(endTime - startTime);
displaySpeed(speed);
//Set timer to display it
showTimer = millis();
//Calc and store stats, skip for small displays
#ifdef INFO_EXTEND
if(speed > maxSpeed){
maxSpeed = speed;
}
if(speed < minSpeed || minSpeed == 0){
minSpeed = speed;
}
if(avgSpeed == 0){
avgSpeed = speed;
}
else{
avgSpeed += speed + 1;
avgSpeed /= 2;
}
#endif
}
//As long as display timer runs we don't update the screen
if(millis() - showTimer > TimeShowSpeed){
//If timer runs, busy display
if(timerRuns){
displayBusy();
}
//or the idle display
else{
displayIdle();
}
}
}
/***** SpeedOmeter functions ***********************/
//Calculates the speed as a fixed point int (1 decimal), with correct rounding
unsigned int calcSpeed(unsigned long time){
return (unsigned int)((36UL * distance * scale + (time / 2)) / time );
}
//Checks the inputs, returns true if a measurement is done, false otherwise
bool checkInput(){
//state of the input, HIGH for detect (no matter the setting)
bool lVal, rVal;
//Set depending the setting
#if defined(ACTIVE_LOW)
lVal = !digitalRead(InputL);
rVal = !digitalRead(InputR);
#else
lVal = digitalRead(InputL);
rVal = digitalRead(InputR);
#endif
//Busy with timing
if(timerRuns){
//End when the other detector is reached
//Save endTime, remove flag, return true because of end
if(direction && lVal || !direction && rVal){
endTime = millis();
timerRuns = false;
return true;
}
}
//Not busy
else{
//We are ready and there is an input
if((lVal || rVal) && ready){
startTime = millis();
timerRuns = true;
ready = false;
direction = rVal;
}
//Probably not ready,
//make ready if no input at least TimeOut after ending timer
else if(!lVal && !rVal && (millis() - endTime > TimeOut)){
ready = true;
}
}
//As long as it's not the end of the timer
return false;
}
/***** Display functions ***************************/
//Set up the display
void displayInit(){
//SSD1306 based OLED display
#if (LCD_TYPE == 1)
//Setup, clear and welkom
display.begin(SSD1306_SWITCHCAPVCC, I2CAdress);
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0,0);
display.print("SpeedOmeter ");
display.println(SPEEDOMETER_VERSION);
display.println("Model railroad speed");
display.println("By Timo Engelgeer");
display.println("Septillion");
display.print("Scale: ");
display.println(scale);
display.print("Dist: ");
display.print(distance);
display.display();
delay(1000);
//Adafruit 7-segment I2C
#else if (LCD_TYPE == 2)
// set display
display.begin(I2CAdress);
display.setBrightness((DisplayBrightness > 15 ? 15 : DisplayBrightness)); // 0..15
//Start up animation
for(byte i = 0; i < 4; i++){
byte icons[] = {0x5C, 0x63};
for(byte y = 0; y < 4; y++){
display.writeDigitRaw(y + (y > 2 ? 1 : 0), icons[y % 2] || (y == i ? 0x80 : 0x00));
}
display.writeDisplay();
delay(500);
}
#endif
}
//Displays the speed
void displaySpeed(unsigned int speed){
//SSD1306 based OLED display
#if (LCD_TYPE == 1)
byte position = 2; //to allign the speed right
displayScreen = 2; //so we do this once
//Clear etc
display.clearDisplay();
display.stopscroll();
display.setTextColor(WHITE);
display.setTextSize(2);
display.setCursor(0,0);
//Calculate the position so it's aligned to the right
for(unsigned int test = (speed / 100); test; test /= 10){
position--;
}
//Print speed
display.print("Speed:");
display.setTextSize(4);
display.setCursor(position * 24,16);
display.print(speed/10);
display.print(",");
display.print(speed % 10);
display.setCursor(80, 48);
display.setTextSize(2);
display.print("km/h");
display.display();
//Adafruit 7-segment I2C
#else if (LCD_TYPE == 2)
byte displayPos = 4; //Position on the screen
displayScreen = 2;//so we do this once
//Disable blink
display.blinkRate(0);
//But it speed is out of reach...
if(speed > 9999){
//Make speed 9999 and blink
speed = 9999;
display.blinkRate(1);
}
//Print speed
if(speed){ //if speed is not 0
for(byte i = 0; speed && i <= 4; ++i) {
display.writeDigitNum(displayPos--, speed % 10, i == 1);
if(displayPos == 2) display.writeDigitRaw(displayPos--, 0x00);
speed /= 10;
}
}
else {
display.writeDigitNum(displayPos--, 0, false);
}
//Fill rest with 0
while(displayPos >= 0) display.writeDigitRaw(displayPos--, 0x00);
display.writeDisplay();
#endif
}
//Display when the timer is started
void displayBusy(){
//SSD1306 based OLED display
#if (LCD_TYPE == 1)
if(displayScreen != 3){
displayScreen = 3; //so we do this once
//Clear etc
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,0);
//If from right to left, scroll <--
if(direction){
for(byte i = 0; i < 2; i++){
display.print("<--- ");
}
display.startscrollleft(0x00, 0x01);
}
//If from left to right, scroll -->
else{
for(byte i = 0; i < 2; i++){
display.print("---> ");
}
display.startscrollright(0x00, 0x01);
}
//Display the info below
displayInfo();
display.display();
}
//Adafruit 7-segment I2C
#else if (LCD_TYPE == 2)
if(displayScreen != 3){
displayScreen = 3; //so we do this once
// |---- for from left, ----| for from right
for(byte i = 0; i < 5; i++){
if(i == 2) display.writeDigitRaw(i++, 0x00);
if(i == 0 && !direction){
display.writeDigitRaw(i, 0x70);
}
else if(i == 5 && direction){
display.writeDigitRaw(i, 0x46);
}
else{
display.writeDigitRaw(i, 0x40);
}
}
//and blink 1Hz
display.blinkRate(2);
display.writeDisplay();
}
#endif
}
//Screen to display when waiting for input
void displayIdle(){
//SSD1306 based OLED display
#if (LCD_TYPE == 1)
if(displayScreen != 4){
displayScreen = 4; //so we do this once
//Clear, don't scroll, set size, set cursor, write
display.clearDisplay();
display.stopscroll();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,0);
display.print("Wachten...");
//And add info
displayInfo();
display.display();
}
//Adafruit 7-segment I2C
#else if (LCD_TYPE == 2)
if(displayScreen != 4){
displayScreen = 4; //so we do this once
display.blinkRate(0); //Don't blink
// Write "____"
for(byte i = 0; i < 5; i++){
if(i == 2) display.writeDigitRaw(i++, 0x00);
display.writeDigitRaw(i, 0x08);
}
display.writeDisplay();
}
#endif
}
void displayError(){
displayScreen = 5;
}
//Display's the stats (min, max, avg, last)
void displayInfo(){
#if (LCD_TYPE == 1)
//Print last speed, max speed, min speed and average
display.setTextSize(1);
display.print("Lst: ");
display.print(speed / 10);
display.print(",");
display.print(speed % 10);
display.println("km/h");
display.print("Max: ");
display.print(maxSpeed / 10);
display.print(",");
display.print(maxSpeed % 10);
display.println("km/h");
display.print("Min: ");
display.print(minSpeed / 10);
display.print(",");
display.print(minSpeed % 10);
display.println("km/h");
display.print("Avg: ");
display.print(avgSpeed / 10);
display.print(",");
display.print(avgSpeed % 10);
display.println("km/h");
#endif
}
while(displayPos >= 0) display.writeDigitRaw(displayPos--, 0x00);
Op zich niet fout maar in het originele code was displayPos een int, ik heb hem als byte gedefinieerd. En een byte kleiner dan 0 is niet mogelijk ::) Nu vervangen door displayPos < 100 omdat er nu een rollover naar 255 plaats vindt. Dit zou het moeten oplossen./***************************************************
SpeedOmeter v1.1 - Speedometer for modelrailroad
Created by Timo Engelgeer (Septillion), May 30, 2015
Based on Speedometer bij Max Roodveldt
Calculates the (scale) speed of a (model) train based on two
detections on the layout. This can be any kind you like.
****************************************************/
#define SPEEDOMETER_VERSION "v1.0"
/***** Configuration *******************************
The Speedometer is made very versatile. So in order to make it work with
your setup you have to configure it. The next few blocks will guide you to
the configuration.
-- Display --
Because you can use different display's with Speedometer you have to select
the correct one.
1 SSD1306 128x64 OLED display (I2C, default adress 0x3C)
2 Adafruit 7-segment display (I2C, default adress is 0x70)
****************************************************/
#define LCD_TYPE 1
/**-- Sensor --
It doesn't matter what kind of sensor you use. This can be an active low
(signal goes low when train passes) or active high (signal goes high when
train passes).
Comment the line below for active low.
#define ACTIVE_LOW for active low (uncommented)
//#define ACTIVE_LOW for active high (commented => not defined)
Analoog komt nog ;)
**/
#define ACTIVE_LOW
/**-- Pins --
To which pins are the sensors connected? Left and Right respectively
**/
const byte InputL = 9;
const byte InputR = 10;
/**-- Settings --
Distance => Distance between start of the first detector and
the start of the second (in mm)
Scale => Scale of the layout
TimeShowSpeed =>Time to show the speed after finishing the measurement (in ms)
TimeOut => Time to ignore re-triggering the detector after
finishing measurement (in ms)
**/
unsigned int distance = 5000;
unsigned int scale = 87;
const unsigned int TimeShowSpeed = 5000;
const unsigned int TimeOut = 3000;
/**-- Done! --
You are done. Upload the sketch!
**/
//SSD1306 based OLED display
#if (LCD_TYPE == 1)
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
Adafruit_SSD1306 display(255);
const byte I2CAdress = 0x3C;
#define INFO_EXTEND
//Adafruit 7-segment I2C
#else if (LCD_TYPE == 2)
#include <Wire.h>
#include "Adafruit_LEDBackpack.h"
#include "Adafruit_GFX.h"
Adafruit_7segment display = Adafruit_7segment();
const byte I2CAdress = 0x70;
const byte DisplayBrightness = 7; // 0..15
#endif
/***** Global vars *********************************/
bool timerRuns = false; //Does the timer run?
bool direction = false; //In which direction? (false = to left, true = to right
bool ready = true; //ready to start the clock?
byte displayScreen = 0; //Which screen is displayed last?
unsigned long startTime; //Saved start time
unsigned long endTime; //Saved end time
unsigned long showTimer = -1;//Time when display started showing something
//Speed stats
unsigned int speed, maxSpeed, minSpeed, avgSpeed = 0;
/***** Default functions ***************************/
void setup() {
//Initialize the display
displayInit();
//Set the input acording to the setting
#if defined(ACTIVE_LOW)
pinMode(InputL, INPUT_PULLUP);
pinMode(InputR, INPUT_PULLUP);
#else
pinMode(InputL, INPUT);
pinMode(InputR, INPUT);
#endif
}
void loop(){
//Check for a finished measurement
if(checkInput()){
//If so, calculate the speed and display it
speed = calcSpeed(endTime - startTime);
displaySpeed(speed);
//Set timer to display it
showTimer = millis();
//Calc and store stats, skip for small displays
#ifdef INFO_EXTEND
if(speed > maxSpeed){
maxSpeed = speed;
}
if(speed < minSpeed || minSpeed == 0){
minSpeed = speed;
}
if(avgSpeed == 0){
avgSpeed = speed;
}
else{
avgSpeed += speed + 1;
avgSpeed /= 2;
}
#endif
}
//As long as display timer runs we don't update the screen
if(millis() - showTimer > TimeShowSpeed){
//If timer runs, busy display
if(timerRuns){
displayBusy();
}
//or the idle display
else{
displayIdle();
}
}
}
/***** SpeedOmeter functions ***********************/
//Calculates the speed as a fixed point int (1 decimal), with correct rounding
unsigned int calcSpeed(unsigned long time){
return (unsigned int)((36UL * distance * scale + (time / 2)) / time );
}
//Checks the inputs, returns true if a measurement is done, false otherwise
bool checkInput(){
//state of the input, HIGH for detect (no matter the setting)
bool lVal, rVal;
//Set depending the setting
#if defined(ACTIVE_LOW)
lVal = !digitalRead(InputL);
rVal = !digitalRead(InputR);
#else
lVal = digitalRead(InputL);
rVal = digitalRead(InputR);
#endif
//Busy with timing
if(timerRuns){
//End when the other detector is reached
//Save endTime, remove flag, return true because of end
if(direction && lVal || !direction && rVal){
endTime = millis();
timerRuns = false;
return true;
}
}
//Not busy
else{
//We are ready and there is an input
if((lVal || rVal) && ready){
startTime = millis();
timerRuns = true;
ready = false;
direction = rVal;
}
//Probably not ready,
//make ready if no input at least TimeOut after ending timer
else if(!lVal && !rVal && (millis() - endTime > TimeOut)){
ready = true;
}
}
//As long as it's not the end of the timer
return false;
}
/***** Display functions ***************************/
//Set up the display
void displayInit(){
//SSD1306 based OLED display
#if (LCD_TYPE == 1)
//Setup, clear and welkom
display.begin(SSD1306_SWITCHCAPVCC, I2CAdress);
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0,0);
display.print("SpeedOmeter ");
display.println(SPEEDOMETER_VERSION);
display.println("Model railroad speed");
display.println("By Timo Engelgeer");
display.println("Septillion");
display.print("Scale: ");
display.println(scale);
display.print("Dist: ");
display.print(distance);
display.display();
delay(1000);
//Adafruit 7-segment I2C
#else if (LCD_TYPE == 2)
byte icons[] = {0x5C, 0x63};
// set display
display.begin(I2CAdress);
display.setBrightness((DisplayBrightness > 15 ? 15 : DisplayBrightness)); // 0..15
//Start up animation
for(byte i = 0; i < 4; i++){
for(byte y = 0; y < 4; y++){
display.writeDigitRaw(y + (y >= 2 ? 1 : 0), icons[(y + i) % 2] | (y == i ? 0x80 : 0x00));
}
display.writeDisplay();
delay(500);
}
#endif
}
//Displays the speed
void displaySpeed(unsigned int speed){
//SSD1306 based OLED display
#if (LCD_TYPE == 1)
byte position = 2; //to allign the speed right
displayScreen = 2; //so we do this once
//Clear etc
display.clearDisplay();
display.stopscroll();
display.setTextColor(WHITE);
display.setTextSize(2);
display.setCursor(0,0);
//Calculate the position so it's aligned to the right
for(unsigned int test = (speed / 100); test; test /= 10){
position--;
}
//Print speed
display.print("Speed:");
display.setTextSize(4);
display.setCursor(position * 24,16);
display.print(speed/10);
display.print(",");
display.print(speed % 10);
display.setCursor(80, 48);
display.setTextSize(2);
display.print("km/h");
display.display();
//Adafruit 7-segment I2C
#else if (LCD_TYPE == 2)
byte displayPos = 4; //Position on the screen
displayScreen = 2;//so we do this once
//Disable blink
display.blinkRate(0);
//But it speed is out of reach...
if(speed > 9999){
//Make speed 9999 and blink
speed = 9999;
display.blinkRate(1);
}
//Print speed
if(speed){ //if speed is not 0
for(byte i = 0; speed && i <= 4; ++i) {
display.writeDigitNum(displayPos--, speed % 10, i == 1);
if(displayPos == 2) display.writeDigitRaw(displayPos--, 0x00);
speed /= 10;
}
}
else {
display.writeDigitNum(displayPos--, 0, false);
}
//Fill rest with 0
while(displayPos < 100) display.writeDigitRaw(displayPos--, 0x00);
display.writeDisplay();
#endif
}
//Display when the timer is started
void displayBusy(){
//SSD1306 based OLED display
#if (LCD_TYPE == 1)
if(displayScreen != 3){
displayScreen = 3; //so we do this once
//Clear etc
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,0);
//If from right to left, scroll <--
if(direction){
for(byte i = 0; i < 2; i++){
display.print("<--- ");
}
display.startscrollleft(0x00, 0x01);
}
//If from left to right, scroll -->
else{
for(byte i = 0; i < 2; i++){
display.print("---> ");
}
display.startscrollright(0x00, 0x01);
}
//Display the info below
displayInfo();
display.display();
}
//Adafruit 7-segment I2C
#else if (LCD_TYPE == 2)
if(displayScreen != 3){
displayScreen = 3; //so we do this once
// |---- for from left, ----| for from right
for(byte i = 0; i < 5; i++){
if(i == 2) display.writeDigitRaw(i++, 0x00);
if(i == 0 && !direction){
display.writeDigitRaw(i, 0x70);
}
else if(i == 4 && direction){
display.writeDigitRaw(i, 0x46);
}
else{
display.writeDigitRaw(i, 0x40);
}
}
//and blink 1Hz
display.blinkRate(2);
display.writeDisplay();
}
#endif
}
//Screen to display when waiting for input
void displayIdle(){
//SSD1306 based OLED display
#if (LCD_TYPE == 1)
if(displayScreen != 4){
displayScreen = 4; //so we do this once
//Clear, don't scroll, set size, set cursor, write
display.clearDisplay();
display.stopscroll();
display.setTextSize(2);
display.setTextColor(WHITE);
display.setCursor(0,0);
display.print("Wachten...");
//And add info
displayInfo();
display.display();
}
//Adafruit 7-segment I2C
#else if (LCD_TYPE == 2)
if(displayScreen != 4){
displayScreen = 4; //so we do this once
display.blinkRate(0); //Don't blink
// Write "____"
for(byte i = 0; i < 5; i++){
if(i == 2) display.writeDigitRaw(i++, 0x00);
display.writeDigitRaw(i, 0x08);
}
display.writeDisplay();
}
#endif
}
void displayError(){
displayScreen = 5;
}
//Display's the stats (min, max, avg, last)
void displayInfo(){
#if (LCD_TYPE == 1)
//Print last speed, max speed, min speed and average
display.setTextSize(1);
display.print("Lst: ");
display.print(speed / 10);
display.print(",");
display.print(speed % 10);
display.println("km/h");
display.print("Max: ");
display.print(maxSpeed / 10);
display.print(",");
display.print(maxSpeed % 10);
display.println("km/h");
display.print("Min: ");
display.print(minSpeed / 10);
display.print(",");
display.print(minSpeed % 10);
display.println("km/h");
display.print("Avg: ");
display.print(avgSpeed / 10);
display.print(",");
display.print(avgSpeed % 10);
display.println("km/h");
#endif
}
Ben benieuwd hoe je dit uit gaat leggen aan iemand zonder veel programmeer ervaring ??? Kiezen tussen LOW en HIGH is misschien toch makkelijker...
In de configuratie, het klopt dat er twee regels met #define ACTIVE_LOW in de comments staan. Het idee was dat je de define comment (dus eigenlijk weg haalt) om naar active high te schakelen. Dus wel definiëren voor active low (#define ACTIVE_LOW) of niet definiëren voor active high (//#define ACTIVE LOW). Het is op zich niet fout om het aan te passen naar #define ACTIVE_HIGH aangezien hiermee ACTIVE_LOW niet gedefinieerd wordt ;D (Ook al wordt er nergens gekeken naar ACTIVE_HIGH :p ) Zou dit eigenlijk duidelijker zijn?
En dan nog een domme fout waar jullie niets gemerkt hebben. ;D Ik had een simpele opstart animatie gemaakt voor het display. Hierin staat een regel met een bitwise OR van twee waarde. Ik had alleen ipv a | b geschreven a || b. Aangezien dit altijd waar is leverde dit dus de waarde 1 op ipv het gewenste getal. Als het goed is toonde het display bij het opstarten dus even 4 streepje bovenaan, klopt dat?;D Nee - er waren slechts drie streepjes; het derde cijfer was zwart...
Ruimte die er vaak niet is
Dat is dan fout - dat zal ik nakijken. ???Is dit inderdaad een foutje en is het er al uit gehaald?
Is dit inderdaad een foutje en is het er al uit gehaald?
Het probleempje is dat ik het hier niet goed kan simuleren - ik test met drukknoppen.
void digitalWrite(uint8_t pin, uint8_t val)
{
uint8_t timer = digitalPinToTimer(pin);
uint8_t bit = digitalPinToBitMask(pin);
uint8_t port = digitalPinToPort(pin);
volatile uint8_t *out;
if (port == NOT_A_PIN) return;
// If the pin that support PWM output, we need to turn it off
// before doing a digital write.
if (timer != NOT_ON_TIMER) turnOffPWM(timer);
out = portOutputRegister(port);
uint8_t oldSREG = SREG;
cli();
if (val == LOW) {
*out &= ~bit;
} else {
*out |= bit;
}
SREG = oldSREG;
}