Course temps Conseil (3 / 4 étapes)

Étape 3: programme

Voici le programme pour elle. J’ai utilisé la bibliothèque Debounce pour réduire le bruit d’entrée depuis les boutons. La procédure de l’horloge est de horloge libres de Rob Faludi. Je dois être honnête, j’ai emprunté le code pour tester un bouton long/court et je ne me souviens plus où. Désolé ! Je tiens également à remercier Graynomad des forums Arduino pour m’avoir aidé à démêler les problèmes initiaux, que j’ai eu avec l’affichage. (Juste que les gens sachent, vous devez seulement alterner Trck une fois que tous les registres sont chargés, pas après chacun d’eux. Si vous le faites après chacun d’eux, vous vous retrouvez avec les images fantômes et l’affichage semble mauvais!)

Je présente également mes excuses, je ne suis pas le meilleur un commenter mon code. Je suis en train d’obtenir mieux en mieux et que je vais le faire. Si vous avez des questions à ce sujet s’il vous plaît demander je vais essayer et répondre !

#include < Debounce.h >

/*
Compte à rebours

Utilisation - trois boutons : Mode, heure et Minute.

Appuyez brièvement sur Mode = timer Start/Pause
Appuyez longuement sur Mode (2.5 s) = mode de réglage de minuterie entrée/sortie

Avec minuteur en pause Appuyez sur des minutes et des heures pour réinitialiser l’horloge

En mode de réglage de la minuterie, appuyez sur Heure/Minute à paramètres incrément d’heure.

*/

#define timeroffest 0 //adjustment d’erreur dans le calendrier

#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 période pour éviter le scintillement quand appuyant sur ou en relâchant le bouton
#define holdTime 2500 / / ms hold période : combien de temps à attendre pour la presse + tenue d’événement

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

#define DP_BIT B00001000

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

runMode booléen = false ;
setMode booléen = false ;
Boolean exécuter = 0, réinitialiser = 0, lent = false ;

int = deuxième 118 minutes = 0, heure = 0 ; déclarer des variables de temps de travail

int sMin = 30, sHour = 2 ; déclarer des variables de temporisation

unsigned long autostart = 0 ;

void setup() {}

pinMode (resetPin, entrée) ; broches pour les commutateurs normalement ouverts régler l’heure
pinMode (minutePin, entrée) ;
pinMode (hourPin, entrée) ;
pinMode (sloPin, INPUT) ;

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

digitalWrite (Trck, faible) ;

checkButtons() ;

minute = sMin ;
heure = sHour ;

Séquence d’Intro
outputChar(129) ; r
outputChar(0) ; CLR
outputChar(0) ; CLR
digitalWrite (Trck, élevé) ;
digitalWrite (Trck, faible) ;
Delay(250) ;

outputChar(0) ; CLR
outputChar(129) ; r
outputChar(0) ; CLR
digitalWrite (Trck, élevé) ;
digitalWrite (Trck, faible) ;
Delay(250) ;

outputChar(0) ; CLR
outputChar(0) ; CLR
outputChar(129) ; r
digitalWrite (Trck, élevé) ;
digitalWrite (Trck, faible) ;
Delay(250) ;

outputChar(195) ; t
outputChar(0) ; CLR
outputChar(129) ; r
digitalWrite (Trck, élevé) ;
digitalWrite (Trck, faible) ;
Delay(250) ;

outputChar(0) ; CLR
outputChar(195) ; t
outputChar(129) ; r
digitalWrite (Trck, élevé) ;
digitalWrite (Trck, faible) ;
Delay(250) ;

outputChar(199) ; b B11000111
outputChar(195) ; t B11000011
outputChar(129) ; r B10000001
digitalWrite (Trck, élevé) ;
digitalWrite (Trck, faible) ;
Delay(2000) ;

outputChar(0) ; CLR
outputChar(0) ; CLR
outputChar(0) ; CLR
digitalWrite (Trck, élevé) ;
digitalWrite (Trck, faible) ;
Delay(250) ;
}

void loop() {}

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

Si (heure == 0 & & minute == 0 & & setMode == false) {}
runMode = false ;
displayFin() ;
}
ElseIf (lent == true) displaySlo() ;
d’autre displayOut() ;

Si (runMode == 0 & & reset == 1) {}
deuxième = 118 ;
minute = sMin ;
heure = sHour ;
Reset = 0 ;
}

checkButtons() ; exécute une fonction qui vérifie les boutons de réglage
}

setTime() Sub {}
public static boolean minStat = false hrStat = false ;
int minBut, hrBut ;

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

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

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

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

heure = sHour ;
minute = sMin ;
deuxième = 118 ;
}

void checkButtons() {}

public static long btnDnTime ; fois que la touche a été enfoncée
public static long btnUpTime ; fois que la touche a été relâchée
public static boolean ignoreUp = false ; s’il faut ignorer le bouton libérer car le clic + cale a été déclenché
public static int R = 0 ; État du bouton mode
public static int Rstate = 0 ;

R = digitalRead(resetPin) ; lire l’état du bouton Mode
Tester la touche enfoncée et stocker le temps d’arrêt
Si (R == LOW & & Rstate == HIGH & & (millis() - btnUpTime) > long(debounce))
{
btnDnTime = millis() ;
}
Test pour le bouton et stocker le temps haut
Si (R == HIGH & & Rstate == LOW & & (millis() - btnDnTime) > long(debounce) & & setMode == false)
{
Si (ignoreUp == false) runMode =! runMode ; tester si le mode de réglage bas-haut doit être activée/désactivée
else ignoreUp = false ;
btnUpTime = millis() ;
}
Tester la touche maintenue enfoncée pendant plus longtemps que le temps de maintien
Si (R == LOW & & (millis() - btnDnTime) > long(holdTime))
{
setMode =! setMode ; activer/désactiver le mode de réglage de mode de synchronisation, ou vice versa
runMode = 0 ;
ignoreUp = true ;
btnDnTime = millis() ;
}
Rstate = R ;

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

Si (runMode == 0) {}
Si (minutePinDB.read() == LOW & & hourPinDB.read() == faible) réinitialiser = 1 ;
}

Si (digitalRead(sloPin) == faible) lent = true ;

}

clock() Sub {}
public static unsigned lastTick long = 0 ; mettre en place une variable locale pour contenir la dernière fois que nous avons déménagé avant une seconde
(les variables statiques sont initialisées une fois et conservent leurs valeurs entre les appels de fonction)

déplacement vers l’avant une seconde chaque 1000 millisecondes
Si (millis() - lastTick > = 500 + timeroffest) {}
lastTick = millis() ;
deuxième--;
}

Remettez une minute toutes les 60 secondes
Si (second < 0) {}
minute--;
deuxième = 118 ; remettre les secondes à zéro
}

reculer d’une heure toutes les 60 minutes
Si (minute < 0) {}
heure--;
minute = 59 ; remettre les minutes à zéro}
}

Si (heure < 0) {}
heure = 0 ; remettre les heures à zéro
}

}

void displayOut() {}

public static byte dp_bit = 0 ;

set_bit octet = 0 ;

public static byte secFlash ;
public static unsigned long mise à jour = 0 ;

octet de sortie ;

Si (millis() - mise à jour > = 4) {}

mise à jour = millis() ;

Si (secFlash! = seconde) {}
dp_bit ^ = DP_BIT ; bit de bascule la DP
secFlash = seconde ;
}
d’autre if(runMode == false) {}
dp_bit = DP_BIT ;
}

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

outputChar (personnage [minute % 10] ^ set_bit) ;
outputChar (personnage [minute/10]) ;
outputChar (caractère [heure] ^ dp_bit) ;

digitalWrite (Trck, élevé) ; verrouillage des données à l’OPs
digitalWrite (Trck, faible) ;
}
}

Sub displayFin()
{
public static unsigned flashtimer long = 0 ;
flash statique octets = true ;
public static int flashdelay = 0 ;

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

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

Si (flash == true) {}
outputChar(B10010111) ;
outputChar(B10000101) ;
outputChar(B11100011) ;
}
else {}
outputChar(B00000000) ;
outputChar(B00000000) ;
outputChar(B00000000) ;
}
digitalWrite (Trck, élevé) ; verrouillage des données à l’OPs
digitalWrite (Trck, faible) ;
}

Sub displaySlo()
{
public static unsigned slowtimer long = 0 ;
public static byte flashslow = true ;
public static int slowdelay = 0, slowcount = 0 ;

int slowtime [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, élevé) ; verrouillage des données à l’OPs
digitalWrite (Trck, faible) ;

Si (slowcount > = 21) {}
lente = false ;
slowcount = 0 ;
}
d’autre lent = true ;

}

void outputChar (byte c) {}
pour (int i = 0; i < = 7; i ++) {}
digitalWrite (Tserial, bitRead(c, i)) ;
digitalWrite (Tclk, élevé) ;
digitalWrite (Tclk, faible) ;
}
}