Tablero de tiempo de la raza (3 / 4 paso)

Paso 3: programa de

Este es el programa para él. He utilizado la biblioteca Debounce para reducir el ruido de entrada de los botones. El procedimiento de reloj es de reloj de Rob Faludi código abierto. Tengo que ser honesto, pidió prestado el código para la prueba una largo corto pulsación y no recuerdo donde. ¡ Lo siento! También me gustaría dar las gracias a Graynomad de los foros de Arduino para ayudarme a resolver los problemas iniciales que tuvo con la pantalla. (Solo para que las personas saben, basta con alternar Trck una vez se cargan todos los registros, no después de cada uno. Si lo haces después de cada uno, acabar con el fantasma y la pantalla se ve mal!)

También pido disculpas, no soy la mejor una comentando mi código. Estoy tratando de obtener mejor y hacerlo como ir. Si tienes cualquier duda sobre ello por favor pregunte I probar y responder!

#include < Debounce.h >

/*
La cuenta regresiva del temporizador

Uso - tres botones: modo, hora y minuto.

Resumen Pulse Mode = temporizador de inicio/pausa
Tiempo Pulse Mode (2.5 seg) = entrar/salir del modo de ajuste temporizador

Con temporizador en pausa Pulse minutos y horas para reajustar el reloj

En modo de ajuste de temporizador pulse hora/minuto incremento tiempo configuración.

*/

#define timeroffest 0 //adjustment de error en el momento

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

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

#define debounce 50 / / ms debounce período para evitar que cuando presionar o soltar el botón del
#define holdTime 2500 / / ms mantenga período: Cuánto tiempo debe esperar para prensa + evento

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

#define DP_BIT B00001000

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

Boolean runMode = false;
setMode boolean = false;
Boolean ejecutar = 0, reset = 0, lento = false;

int = segundo 118 minutos = 0, hora = 0; declarar variables de tiempo de trabajo

int sMin = 30, sHour = 2; declarar variables de tiempo

sin firmar largo autostart = 0;

void setup() {}

pinMode (resetPin, entrada); Pins para interruptores normalmente abiertos ajustar la hora
pinMode (minutePin, entrada);
pinMode (hourPin, entrada);
pinMode (sloPin, entrada);

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

digitalWrite (Trck, LOW);

checkButtons();

minutos = sMin;
hora = sHour;

Secuencia de Intro
outputChar(129); r
outputChar(0); CLR
outputChar(0); CLR
digitalWrite (Trck, alto);
digitalWrite (Trck, LOW);
Delay(250);

outputChar(0); CLR
outputChar(129); r
outputChar(0); CLR
digitalWrite (Trck, alto);
digitalWrite (Trck, LOW);
Delay(250);

outputChar(0); CLR
outputChar(0); CLR
outputChar(129); r
digitalWrite (Trck, alto);
digitalWrite (Trck, LOW);
Delay(250);

outputChar(195); t
outputChar(0); CLR
outputChar(129); r
digitalWrite (Trck, alto);
digitalWrite (Trck, LOW);
Delay(250);

outputChar(0); CLR
outputChar(195); t
outputChar(129); r
digitalWrite (Trck, alto);
digitalWrite (Trck, LOW);
Delay(250);

outputChar(199); b B11000111
outputChar(195); t B11000011
outputChar(129); r B10000001
digitalWrite (Trck, alto);
digitalWrite (Trck, LOW);
Delay(2000);

outputChar(0); CLR
outputChar(0); CLR
outputChar(0); CLR
digitalWrite (Trck, alto);
digitalWrite (Trck, LOW);
Delay(250);
}

void loop() {}

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

Si (horas == 0 & & minuto == 0 & & setMode == false) {}
runMode = false;
displayFin();
}
else if (lento == true) displaySlo();
displayOut() otra cosa;

Si (runMode == 0 & & reset == 1) {}
en segundo lugar = 118;
minutos = sMin;
hora = sHour;
RESET = 0;
}

checkButtons(); ejecuta una función que comprueba los botones de ajuste
}

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

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

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

Si (hrBut == baja & & hrStat == false) {}
sHour sHour = 1;
Si sHour (sHour > 9) = 0;
hrStat = true;
}
Si (hrBut == alto & & hrStat == true) {}
hrStat = false;
}

Si (minBut == baja & & minStat == false) {}
sMin = sMin + 1;
Si (sMin > 59) sMin = 0;
minStat = true;
}
Si (minBut == alto & & minStat == true) {}
minStat = false;
}

hora = sHour;
minutos = sMin;
en segundo lugar = 118;
}

void checkButtons() {}

estática btnDnTime largo; tiempo que el botón fue presionado
estática btnUpTime largo; tiempo que se suelta el botón
Static boolean ignoreUp = false; Si se ignora el botón liberar porque se activó el clic + hold
Static int I = 0; Estado de botón de modo
Static int Rstate = 0;

R = digitalRead(resetPin); leer estado del botón de modo
Para tecla y almacenar el tiempo
Si (R == baja & & Rstate == alto & & (millis() - btnUpTime) > long(debounce))
{
btnDnTime = millis();
}
Prueba para el lanzamiento del botón y almacenar el tiempo hasta
Si (R == alto & & Rstate == baja & & (millis() - btnDnTime) > long(debounce) & & setMode == false)
{
Si (ignoreUp == false) runMode =! runMode; comprobar si el modo de ajuste de baja debe ser fijado
Else ignoreUp = false;
btnUpTime = millis();
}
Prueba para pulsador para más de largo que el tiempo de espera
Si (R == baja & & (millis() - btnDnTime) > long(holdTime))
{
setMode =! setMode; Alternar modo de ajuste de modo de sincronización o viceversa
runMode = 0;
ignoreUp = true;
btnDnTime = millis();
}
Rstate = R;

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

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

Si (digitalRead(sloPin) == LOW) lento = true;

}

{} void clock()
lastTick largo sin signo estático = 0; configurar una variable local para celebrar la última vez que nos mudamos a un segundo delantero
(variables estáticas se inicializan una vez y mantienen sus valores entre llamadas a funciones)

movimiento hacia adelante de un segundo cada 1000 milisegundos
Si (millis() - lastTick > = 500 + timeroffest) {}
lastTick = millis();
segundo--;
}

retroceder un minuto cada 60 segundos
Si (segunda < 0) {}
minutos--;
en segundo lugar = 118; poner los segundos a cero
}

retroceder una hora cada 60 minutos
Si (minutos < 0) {}
hora--;
minuto = 59; poner minutos a cero}
}

Si (hora < 0) {}
hora = 0; poner horas a cero
}

}

void displayOut() {}

Static byte dp_bit = 0;

set_bit byte = 0;

secFlash byte estática;
actualización largo sin signo estático = 0;

byte de salida;

Si (millis() - actualizar > = 4) {}

actualizar = millis();

Si (secFlash! = segundo) {}
dp_bit ^ = DP_BIT; poco de alternar la DP
secFlash = segundo;
}
otra cosa if(runMode == false) {}
dp_bit = DP_BIT;
}

Si (setMode == true) {}
set_bit ^ = DP_BIT;
}
otro set_bit = 0;

outputChar (carácter [minuto % 10] ^ set_bit);
outputChar (carácter [minuto/10]);
outputChar (carácter [hora] ^ dp_bit);

digitalWrite (Trck, alto); pestillo datos de OPs
digitalWrite (Trck, LOW);
}
}

void displayFin()
{
flashtimer largo sin signo estático = 0;
flash de Static byte = true;
Static int flashdelay = 0;

tiempo de Flash int [2] = {}
250, 750};

Si (millis() - flashtimer > flashdelay) {}
Flash = 1 - flash;
flashtimer = millis();
flashdelay = tiempo de Flash [flash];
}

Si (flash == true) {}
outputChar(B10010111);
outputChar(B10000101);
outputChar(B11100011);
}
Else {}
outputChar(B00000000);
outputChar(B00000000);
outputChar(B00000000);
}
digitalWrite (Trck, alto); pestillo datos de OPs
digitalWrite (Trck, LOW);
}

void displaySlo()
{
slowtimer largo sin signo estático = 0;
Static byte flashslow = true;
Static int slowdelay = 0, slowcount = 0;

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

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

Si (flashslow == true) {}
outputChar(character[0]);
outputChar(B01000011);
outputChar(character[5]);
}
Else {}
outputChar(B00000000);
outputChar(B00000000);
outputChar(B00000000);
}
digitalWrite (Trck, alto); pestillo datos de OPs
digitalWrite (Trck, LOW);

Si (slowcount > = 21) {}
lento = false;
slowcount = 0;
}
más lento = true;

}

void outputChar (byte c) {}
para (int i = 0; i < = 7; i ++) {}
digitalWrite (Tserial, bitRead(c, i));
digitalWrite (Tclk, alto);
digitalWrite (Tclk, LOW);
}
}