Race Time stiger ombord (3 / 4 steg)

Steg 3: Program

Här är programmet för det. Jag har använt Debounce biblioteket för att minska input buller från knapparna. Klockan är från Rob Faludi öppen källkod klocka. Jag måste vara ärlig, jag lånade koden för att testa en lång/kort knapptryckning och jag kan inte komma ihåg var. Förlåt! Jag vill också tacka Graynomad från Arduino forum för att hjälpa mig reda ut de inledande problemen jag hade med displayen. (Bara så folk vet, du behöver bara att växla Trck när alla register är inlästa, inte efter var och en. Om du gör det efter varje en, du sluta med spökbilder och displayen ser illa!)

Jag också ber om ursäkt, jag är inte bäst en kommentera min kod. Jag försöker bli bättre på det och göra det som jag går. Om du har några frågor om det. Vänd jag försöker och svara!

#include < Debounce.h >

/*
Räkna ner Timer

Användning - tre knappar: läge, timme och minut.

Kort tryck Mode = Start/Paus timer
Tryck länge på läge (2,5 sek) = retur/avsluta inställning av timer

Med timer pausad tryck minut och timme tillsammans återställa klockan

I inställningen Timer-läge, tryck på timme/minut att öka tidsinställningarna.

*/

#define timeroffest 0 //adjustment för fel i timing

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

Dämpningstid minutePinDB = Debounce (25, minutePin);
Dämpningstid hourPinDB = Debounce (25, hourPin);

#define Dämpningstid 50 / / ms Dämpningstid period att förhindra flimmer när du trycker på eller släppa knappen
#define holdTime 2500 / / ms håll period: hur lång tid att vänta för press + hålla händelse

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

#define DP_BIT B00001000

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

booleska stoppläge = false;
booleska setMode = false;
Boolean kör = 0, återställa = 0, långsam = false;

int näst = 118, minut = 0, timme = 0; deklarera arbetande tid variabler

int sMin = 30, sHour = 2; deklarera inställd tid variabler

osignerade långa autostart = 0;

void setup() {

pinMode (resetPin, ingång); stift för normalt öppna växlar för att ställa in tiden
pinMode (minutePin, ingång);
pinMode (hourPin, ingång);
pinMode (sloPin, indata);

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

digitalWrite (Trck, låg);

checkButtons();

minut = sMin;
timme = sHour;

Intro sekvens
outputChar(129); r
outputChar(0); CLR
outputChar(0); CLR
digitalWrite (Trck, hög);
digitalWrite (Trck, låg);
Delay(250);

outputChar(0); CLR
outputChar(129); r
outputChar(0); CLR
digitalWrite (Trck, hög);
digitalWrite (Trck, låg);
Delay(250);

outputChar(0); CLR
outputChar(0); CLR
outputChar(129); r
digitalWrite (Trck, hög);
digitalWrite (Trck, låg);
Delay(250);

outputChar(195); t
outputChar(0); CLR
outputChar(129); r
digitalWrite (Trck, hög);
digitalWrite (Trck, låg);
Delay(250);

outputChar(0); CLR
outputChar(195); t
outputChar(129); r
digitalWrite (Trck, hög);
digitalWrite (Trck, låg);
Delay(250);

outputChar(199); b B11000111
outputChar(195); t B11000011
outputChar(129); r B10000001
digitalWrite (Trck, hög);
digitalWrite (Trck, låg);
Delay(2000);

outputChar(0); CLR
outputChar(0); CLR
outputChar(0); CLR
digitalWrite (Trck, hög);
digitalWrite (Trck, låg);
Delay(250);
}

void loop() {

om (setMode == true) {
setTime();
}
annars om (stoppläge == true) {
Clock();
}

om (timme == 0 & & minut == 0 & & setMode == false) {
Stoppläge = false;
displayFin();
}
annars om (långsam == true) displaySlo();
annat displayOut();

om (stoppläge == 0 & & Återställ == 1) {
för det andra = 118;
minut = sMin;
timme = sHour;
återställa = 0;
}

checkButtons(); kör en funktion som kontrollerar inställningen knapparna
}

void setTime() {
statisk boolean minStat = false hrStat = false;
int minBut, hrBut;

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

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

om (hrBut == låg & & hrStat == false) {
sHour = sHour + 1.
om (sHour > 9) sHour = 0;
hrStat = sant;
}
om (hrBut == hög & & hrStat == true) {
hrStat = false;
}

om (minBut == låg & & minStat == false) {
sMin = sMin + 1.
om (Liselott > 59) sMin = 0;
minStat = sant;
}
om (minBut == hög & & minStat == true) {
minStat = false;
}

timme = sHour;
minut = sMin;
för det andra = 118;
}

void checkButtons() {

statiska lång btnDnTime; tid knappen trycktes ner
statiska lång btnUpTime; tiden på knappen släpptes
statisk boolean ignoreUp = false; Om du vill ignorera knappen släppa eftersom klicka + håll utlöstes
statisk int R = 0; Mode-knappen stat
statisk int Rstate = 0;

R = digitalRead(resetPin); Läs Mode knappen stat
Testa för knappen intryckt och lagra ner tid
om (R == låg & & Rstate == hög & & (millis() - btnUpTime) > long(debounce))
{
btnDnTime = millis();
}
Testa för knappen utgåvan och lagra upp tid
om (R == hög & & Rstate == låg & & (millis() - btnDnTime) > long(debounce) & & setMode == false)
{
om (ignoreUp == false) stoppläge =! stoppläge; testa om låg-hög inställda läge bör växlas
annat ignoreUp = false;
btnUpTime = millis();
}
Testa för knappen nedtryckt för längre tid än tid som håll
om (R == låg & & (millis() - btnDnTime) > long(holdTime))
{
setMode =! setMode; växla mellan inställda läge till Timing läge eller vice versa
Stoppläge = 0;
ignoreUp = sant;
btnDnTime = millis();
}
Rstate = R;

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

om (stoppläge == 0) {
om (minutePinDB.read() == låg & & hourPinDB.read() == låg) återställa = 1;
}

om (digitalRead(sloPin) == låg) långsamt = sant;

}

void clock() {
statiska osignerade långa lastTick = 0; Ställ in en lokal variabel för att hålla sista gången flyttade vi fram en sekund
(statiska variabler initieras en gång och hålla deras värden mellan funktionsanrop)

Flytta framåt en sekund varje 1000 millisekunder
om (millis() - lastTick > = 500 + timeroffest) {
lastTick = millis();
andra--;
}

flytta tillbaka en minut var 60 sekunder
om (andra < 0) {
minut--;
för det andra = 118; nollställs sekunder
}

flytta tillbaka en timme varje 60 minuter
om (minut < 0) {
timme--;
minut = 59. nollställs minuter}
}

om (timme < 0) {
timme = 0; nollställs timmar
}

}

void displayOut() {

statiska byte dp_bit = 0;

byte set_bit = 0;

statiska byte secFlash;
statiska osignerade lång uppdatering = 0;

byte ut;

om (millis() - uppdatera > = 4) {

uppdatera = millis();

om (secFlash! = understödja) {
dp_bit ^ = DP_BIT; Toggle DP bit
secFlash = andra.
}
annat if(runMode == false) {
dp_bit = DP_BIT;
}

om (setMode == true) {
set_bit ^ = DP_BIT;
}
annat set_bit = 0;

outputChar (tecken [minut % 10] ^ set_bit);
outputChar (tecken [minut/10]);
outputChar (tecken [timme] ^ dp_bit);

digitalWrite (Trck, hög); spärr data till OPs
digitalWrite (Trck, låg);
}
}

void displayFin()
{
statiska osignerade långa flashtimer = 0;
statiska byte flash = sant;
statisk int flashdelay = 0;

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

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

om (flash == true) {
outputChar(B10010111);
outputChar(B10000101);
outputChar(B11100011);
}
annat {
outputChar(B00000000);
outputChar(B00000000);
outputChar(B00000000);
}
digitalWrite (Trck, hög); spärr data till OPs
digitalWrite (Trck, låg);
}

void displaySlo()
{
statiska osignerade långa slowtimer = 0;
statiska byte flashslow = sant;
statisk int slowdelay = 0, slowcount = 0;

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

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

om (flashslow == true) {
outputChar(character[0]);
outputChar(B01000011);
outputChar(character[5]);
}
annat {
outputChar(B00000000);
outputChar(B00000000);
outputChar(B00000000);
}
digitalWrite (Trck, hög); spärr data till OPs
digitalWrite (Trck, låg);

om (slowcount > = 21) {
långsam = false;
slowcount = 0;
}
annars = långsam sant;

}

void outputChar (byte c) {
för (int jag = 0; jag < = 7; i ++) {
digitalWrite (Tserial, bitRead(c, i));
digitalWrite (Tclk, hög);
digitalWrite (Tclk, låg);
}
}