Time Board race (3 / 4 stap)

Stap 3: programma

Hier is het programma voor het. Ik heb de ontdendering bibliotheek gebruikt ter vermindering van lawaai van de input van de knoppen. De klok-procedure is van Rob Faludi de opensource klok. Ik heb om eerlijk te zijn, ik geleend van de code voor het testen van een lang/kort knooppers en ik kan me niet herinneren waar. Sorry! Ik bedank ook Graynomad uit de forums van de Arduino voor portie mij uitzoeken van de aanvankelijke problemen die ik had met de display. (Net zo mensen weet, je hoeft alleen om te schakelen Trck als eenmaal alle registers zijn geladen, niet na elkaar. Als u het na elkaar doen, je eindigen met beeldschaduwen en het display ziet er slecht!)

Ook het spijt me, ik ben niet de beste een commentaar van mijn code. Ik probeer te krijgen beter in en als ik ga het doen. Als u vragen hebt over het vraag zal ik proberen te beantwoorden!

#include < Debounce.h >

/*
Aftellen Timer

Gebruik - drie knoppen: Mode, uur en minuut.

Druk kort op Mode = timer starten/onderbreken
Lang indrukken van Mode (2,5 sec) = modus voor het instellen van Enter/exit-timer

Met timer onderbroken druk op Minute en uur samen om het opnieuw instellen van de klok

Druk in de modus voor het instellen van de Timer, op uur/minuut aan increment tijdinstellingen.

*/

#define timeroffest 0 //adjustment vanwege fouten in timing

#define resetPin 8
#define minutePin 9
#define hourPin 10
#define sloPin 11

Debounce minutePinDB = ontdendering (25, minutePin);
Debounce hourPinDB = ontdendering (25, hourPin);

#define debounce 50 / / ms debounce periode om te voorkomen dat trillen wanneer indrukken of loslaten van de knop
#define holdTime 2500 / / ms hold periode: hoe lang moeten wachten voor pers + evenement

#define Tserial 4
#define Tclk 6
#define Trck 5

#define DP_BIT B00001000

byteteken [10] = {}
B01110111, B00010100, B10110011, B10110110, B11010100, B11100110, B11100111, B00110100, B11110111, B11110100};

Boole runMode = false;
Boole setMode = false;
Boolean lopen = 0, reset = 0, langzaam = false;

int tweede = 118, minuten = 0, uur = 0; werkende tijdvariabelen declareren

int sMin = 30, sHour = 2; tijdinstelling variabelen declareren

niet-ondertekende lange autostart = 0;

VOID Setup {}

pinMode (de resetPin, INPUT); pinnen voor normaal open switches om de tijd
pinMode (minutePin, INPUT);
pinMode (hourPin, INPUT);
pinMode (sloPin, INPUT);

pinMode (Tserial, uitvoer);
pinMode (Tclk, uitvoer);
pinMode (Trck, uitvoer);

digitalWrite (Trck, laag);

checkButtons();

Minute = sMin;
uur = sHour;

Intro Sequence
outputChar(129); r
outputChar(0); CLR
outputChar(0); CLR
digitalWrite (Trck, hoge);
digitalWrite (Trck, laag);
delay(250);

outputChar(0); CLR
outputChar(129); r
outputChar(0); CLR
digitalWrite (Trck, hoge);
digitalWrite (Trck, laag);
delay(250);

outputChar(0); CLR
outputChar(0); CLR
outputChar(129); r
digitalWrite (Trck, hoge);
digitalWrite (Trck, laag);
delay(250);

outputChar(195); t
outputChar(0); CLR
outputChar(129); r
digitalWrite (Trck, hoge);
digitalWrite (Trck, laag);
delay(250);

outputChar(0); CLR
outputChar(195); t
outputChar(129); r
digitalWrite (Trck, hoge);
digitalWrite (Trck, laag);
delay(250);

outputChar(199); b B11000111
outputChar(195); t B11000011
outputChar(129); r B10000001
digitalWrite (Trck, hoge);
digitalWrite (Trck, laag);
delay(2000);

outputChar(0); CLR
outputChar(0); CLR
outputChar(0); CLR
digitalWrite (Trck, hoge);
digitalWrite (Trck, laag);
delay(250);
}

void loop {}

Als (setMode == true) {}
setTime();
}
else if (runMode == true) {}
Clock();
}

Als (uur == 0 & & minuut == 0 & & setMode == false) {}
runMode = false;
displayFin();
}
anders als (langzaam == true) displaySlo();
anders displayOut();

Als (runMode == 0 & & reset == 1) {}
tweede = 118;
Minute = sMin;
uur = sHour;
reset = 0;
}

checkButtons(); een functie die de instelling-knoppen controleert worden uitgevoerd
}

VOID setTime() {}
statische Boole minStat = false hrStat = false;
int minBut, hrBut;

minutePinDB.update();
hourPinDB.update();

minBut = minutePinDB.read();
hrBut = hourPinDB.read();

Als (hrBut == LOW & & hrStat == false) {}
sHour = sHour + 1;
Als (sHour > 9) sHour = 0;
hrStat = true;
}
Als (hrBut == HIGH & & hrStat == true) {}
hrStat = false;
}

Als (minBut == LOW & & minStat == false) {}
sMin = sMin + 1;
Als (sMin > 59) sMin = 0;
minStat = true;
}
Als (minBut == HIGH & & minStat == true) {}
minStat = false;
}

uur = sHour;
Minute = sMin;
tweede = 118;
}

ongeldig checkButtons() {}

statische lange btnDnTime; tijd die de knop werd ingedrukt
statische lange btnUpTime; tijd die de knop werd vrijgegeven
statische Boole ignoreUp = false; of de knop negeren vrijgeven omdat de klik + greep was leverde
statische int R = 0; Status van de knop modus
statische int goed = 0;

R = digitalRead(resetPin); lezen modus knop staat
Testen voor knop ingedrukt en de down tijd opslaan
Als (R == LOW & & goed == HIGH & & (millis() - btnUpTime) > long(debounce))
{
btnDnTime = millis();
}
Testen voor knop release en opslaan van het tijdstip van omhoog
Als (R == HIGH & & goed == LOW & & (millis() - btnDnTime) > long(debounce) & & setMode == false)
{
Als (ignoreUp == false) runMode =! runMode; Als laag-hoog instellen modus moet worden toggled testen
anders ignoreUp = false;
btnUpTime = millis();
}
Testen voor knop ingedrukt voor langer dan de tijd vasthouden
Als (R == LOW & & (millis() - btnDnTime) > long(holdTime))
{
setMode =! setMode; Set modus naar de modus van de Timing of vice versa in-/ uitschakelen
runMode = 0;
ignoreUp = true;
btnDnTime = millis();
}
Goed = R;

minutePinDB.update();
hourPinDB.update();

Als (runMode == 0) {}
Als (minutePinDB.read() == LOW & & hourPinDB.read() == LOW) reset = 1;
}

Als (digitalRead(sloPin) == LOW) langzaam = true;

}

ongeldig clock() {}
statische unsigned long lastTick = 0; een lokale variabele instellen om te houden van de laatste keer zijn we verhuisd naar voren één seconde
(statische variabelen zijn geïnitialiseerd zodra en houden van hun waarden tussen de functieaanroepen van de)

verplaatsen naar voren één seconde elke 1000 milliseconden
Als (millis() - lastTick > 500 + timeroffest =) {}
lastTick = millis();
tweede--;
}

terugplaatsen van een minuut om de 60 seconden
Als (tweede < 0) {}
minuut--;
tweede = 118; seconden weer op nul gezet
}

terugplaatsen van één uur om de 60 minuten
Als (minuut < 0) {}
uur--;
Minute = 59; minuten weer op nul gezet}
}

Als (uur < 0) {}
uur = 0; uur weer op nul gezet
}

}

ongeldig displayOut() {}

statische byte dp_bit = 0;

byte set_bit = 0;

statische byte secFlash;
statische niet-ondertekende lange update = 0;

byte output;

Als (millis() - update > = 4) {}

Update = millis();

Als (secFlash! = tweede) {}
dp_bit ^ = DP_BIT; knevel het DP bits
secFlash = tweede;
}
anders if(runMode == false) {}
dp_bit = DP_BIT;
}

Als (setMode == true) {}
set_bit ^ = DP_BIT;
}
anders set_bit = 0;

outputChar (teken [minuut % 10] ^ set_bit);
outputChar (teken [minuut/10]);
outputChar (teken [uur] ^ dp_bit);

digitalWrite (Trck, hoge); Klink gegevens aan OPs
digitalWrite (Trck, laag);
}
}

VOID displayFin()
{
statische unsigned long flashtimer = 0;
statische byte flash = true;
statische int flashdelay = 0;

int flashtime [2] = {}
250, 750};

Als (millis() - flashtimer > flashdelay) {}
Flash = 1 - flash;
flashtimer = millis();
flashdelay = flashtime [flash];
}

Als (flash == true) {}
outputChar(B10010111);
outputChar(B10000101);
outputChar(B11100011);
}
else {}
outputChar(B00000000);
outputChar(B00000000);
outputChar(B00000000);
}
digitalWrite (Trck, hoge); Klink gegevens aan OPs
digitalWrite (Trck, laag);
}

VOID displaySlo()
{
statische unsigned long slowtimer = 0;
statische byte flashslow = true;
statische int slowdelay = 0, slowcount = 0;

int slowtime [2] = {}
200, 500};

Als (millis() - slowtimer > slowdelay) {}
flashslow = 1 - flashslow;
slowtimer = millis();
slowdelay = slowtime [flashslow];
slowcount ++;
}

Als (flashslow == true) {}
outputChar(character[0]);
outputChar(B01000011);
outputChar(character[5]);
}
else {}
outputChar(B00000000);
outputChar(B00000000);
outputChar(B00000000);
}
digitalWrite (Trck, hoge); Klink gegevens aan OPs
digitalWrite (Trck, laag);

Als (slowcount > = 21) {}
traag = false;
slowcount = 0;
}
anders = langzaam true;

}

VOID outputChar (byte c) {}
for (int i = 0; ik < = 7; i ++) {}
digitalWrite (Tserial, bitRead(c, i));
digitalWrite (Tclk, hoge);
digitalWrite (Tclk, laag);
}
}