Étape 7: Prototypage, l’affichage et réglage de l’heure
Pour ce faire, nous allons utiliser un commutateur d’unipolaires bidirectionnels (SPDT), ou un interrupteur « on - on ». Connectez le fil moyen à A2 d’entrée analogique, d'entre les fils extérieurs à la terre et l’autre conducteur extérieur à 5V. La méthode analogRead(A2) doit maintenant retourner 0 ou 1023 quand l’interrupteur est basculé en arrière.
Nous voulons indiquer visuellement à l’utilisateur qu’ils sont en mode de réglage avec une LED. L’ONU a seulement 14 broches numériques, et puisque nous utilisons déjà chacun d’eux (13 pour les LEDs de temps) et 1 broche pour le PWM qui sera utilisé sur le compteur analogique, nous pouvons heureusement transformer une broche analogique en numérique broche de sortie ! Il suffit d’appeler pinMode (A5, sortie) à utiliser A5 comme une broche de sortie numérique.
Nous aurons besoin de vérifier si nous sommes en mode de mise à l’heure ou l’affichage de temps au tout début de la méthode loop(). Nous allons mettre cette logique dans une méthode appelée checkMode().
Maintenant, vous avez une horloge binaire qui garde le temps et pouvez être réglée manuellement par l’utilisateur !
Tout le Code jusqu'à présent
/*
Horloge Cwik v1.0 - prototypage l’affichage
Auteur : Dennis Cwik
Date : 23 juillet 2012
Ce programme est le contrôleur pour une horloge binaire, avec LED
fixée à broches numériques entre 0 et 10, 12 et 13, permet pour le moment
réglage avec les potentiomètres et peuvent être affichés/masqués entre temps
réglage du mode et mode d’affichage de temps.
Cet exemple de code est dans le domaine public.
*/
Ceci peut être modifié faire passer une minute plus rapidement à des fins de débogage.
int ONE_SECOND = 1000 ; mesuré en millisecondes
int DELAY_BETWEEN_LOOP_CALLS = 200 ; mesuré en millisecondes
Je n’est pas venu avec cela, c’est à partir des documents de l’arduino
unsigned long MAX_UNSIGNED_LONG = 4294967295 ; = (2 ^ 32) - 1
int HOUR_INPUT_PIN = A0 ;
int MIN_INPUT_PIN = A1 ;
int CLOCK_MODE_SWITCH_PIN = A2 ;
int CLOCK_MODE_LED_PIN = A5 ;
1ère colonne de LED
int PIN_MIN1 = 0 ;
int PIN_MIN2 = 1 ;
int PIN_MIN4 = 2 ;
int PIN_MIN8 = 3 ;
2ème colonne de LED
int PIN_MIN10 = 4 ;
int PIN_MIN20 = 5 ;
int PIN_MIN40 = 6 ;
3ème colonne de LED
int PIN_HOUR1 = 7 ;
int PIN_HOUR2 = 8 ;
int PIN_HOUR4 = 9 ;
int PIN_HOUR8 = 10 ;
4ème colonne de LED
int PIN_HOUR10 = 12 ;
int PIN_HOUR20 = 13 ;
la dernière fois les secondes dans le temps ont été incrémenté
unsigned long m_lastTick ;
utilisé pour nous dire si nous allons régler l’heure ou pas
m_inTimeSetMode booléen = false ;
le temps
m_second octet ;
m_minute octet ;
m_hour octet ;
la routine d’installation s’exécute une fois que lorsque vous appuyez sur reset :
void setup()
{
à l’aide d’une des entrées analogiques en sortie
pinMode (CLOCK_MODE_LED_PIN, sortie) ;
initialiser les broches utilisés pour afficher du temps comme sortie
pinMode (PIN_MIN1, sortie) ;
pinMode (PIN_MIN2, sortie) ;
pinMode (PIN_MIN4, sortie) ;
pinMode (PIN_MIN8, sortie) ;
pinMode (PIN_MIN10, sortie) ;
pinMode (PIN_MIN20, sortie) ;
pinMode (PIN_MIN40, sortie) ;
pinMode (PIN_HOUR1, sortie) ;
pinMode (PIN_HOUR2, sortie) ;
pinMode (PIN_HOUR4, sortie) ;
pinMode (PIN_HOUR8, sortie) ;
pinMode (PIN_HOUR10, sortie) ;
pinMode (PIN_HOUR20, sortie) ;
initialiser des variables de l’horloge
m_lastTick = 0 ;
setTime (2, 18, 0) ;
}
la routine de la boucle s’exécute maintes et maintes fois pour toujours :
void loop()
{
checkMode() ;
voir si nous sommes réglage de l’heure, ou laisser l’écoulement du temps normalement
Si (m_inTimeSetMode)
{
getTimeFromPots() ;
}
d’autre
{
Tick() ;
}
maintenant que le temps a été mis à jour, indiquer l’heure
displaySeconds() ;
displayMinutes() ;
displayHours() ;
arbitraires retarder afin que nous ne sommes pas traitement loin 100 % du temps,
un acte d’économie d’énergie
Delay(DELAY_BETWEEN_LOOP_CALLS) ;
}
/**
* Une méthode d’assistance pour définir m_hour, m_minute et m_second.
*/
void setTime (newHour octets, newMinute octets, newSecond octets)
{
m_second = newSecond ;
m_minute = newMinute ;
m_hour = newHour ;
}
/**
* Cette méthode assure le suivi de l’enchaînement logique des temps. Si assez de temps a
* écoulées depuis la dernière fois qu’on l’appelait, m_second, m_minute et m_hour
* met à jour approprié. Ceci tienne compte de cette millis() rouleaux
* sur à peu près tous les 50 jours.
*/
Sub tick()
{
unsigned long maintenant = millis() ;
unsigned long msElapsed ;
tout d’abord, nous avons besoin de savoir combien de temps s’est écoulé depuis la dernière fois que nous
tick() appelé
Si (maintenant < m_lastTick)
{
le souffle coupé, non plus, nous avons réussi en voyages dans le temps, ou millis() enroulé autour !
msElapsed = (MAX_UNSIGNED_LONG - m_lastTick) + maintenant ;
}
d’autre
{
msElapsed = maintenant - m_lastTick ;
}
pour chaque seconde qui s’est écoulé (si tout va bien juste 1, sauf si notre code est vraiment lag),
Ajouter 1 seconde à la fois et augmenter les minutes et les heures si nécessaire.
pour (int i = 0; i < msElapsed / ONE_SECOND; ++ j’ai)
{
m_lastTick = m_lastTick + ONE_SECOND ;
++ m_second ;
Si (m_second == 60)
{
m_second = 0 ;
++ m_minute ;
Si (m_minute == 60)
{
m_minute = 0 ;
++ m_hour ;
Si (m_hour == 24)
{
m_hour = 0 ;
}
}
}
}
}
Sub displaySeconds()
{
TODO contrôlent l’affichage analogique
}
/**
* Cette méthode lit le m_minute variable, convertit en binaire et affiche
* il des voyants approprié (ceux qui sont PIN_MIN *).
*/
Sub displayMinutes()
{
octet plus = m_minute % 10 ;
digitalWrite (PIN_MIN1, celles & B1) ;
digitalWrite (PIN_MIN2, celles & B10) ;
digitalWrite (PIN_MIN4, celles & B100) ;
digitalWrite (PIN_MIN8, celles & B1000) ;
Division est peu cher, mais nous supposerons que la compilation optimise cela pour nous:)
des dizaines d’octets = m_minute / 10 ;
digitalWrite (PIN_MIN10, dizaines & B1) ;
digitalWrite (PIN_MIN20, dizaines & B10) ;
digitalWrite (PIN_MIN40, dizaines & B100) ;
}
/**
* Cette méthode lit le m_hour variable, convertit en binaire et affiche
* il des voyants approprié (ceux qui sont PIN_HOUR *).
*/
Sub displayHours()
{
octet plus = m_hour % 10 ;
digitalWrite (PIN_HOUR1, celles & B1) ;
digitalWrite (PIN_HOUR2, celles & B10) ;
digitalWrite (PIN_HOUR4, celles & B100) ;
digitalWrite (PIN_HOUR8, celles & B1000) ;
des dizaines d’octets = m_hour / 10 ;
digitalWrite (PIN_HOUR10, dizaines & B1) ;
digitalWrite (PIN_HOUR20, dizaines & B10) ;
}
/**
* Cette méthode lit les valeurs de 2 potentiomètres, convertit à
* mimnutes heures et séries m_minute et m_hour pour les valeurs associées.
*/
Sub getTimeFromPots()
{
lire les potentiomètres
int hourSensor = analogRead(HOUR_INPUT_PIN) ;
int minuteSensor = analogRead(MIN_INPUT_PIN) ;
mettre à l’échelle les valeurs (de 0 à 1023) à l’échelle appropriée (0 à 23 heures, 0 à 59 minutes)
setTime (carte (hourSensor, 0, 1023, 0, 23), carte (minuteSensor, 0, 1023, 0, 59), 0) ;
Nous avons mis le dernier battement maintenant, parce que quand nous avons mis m_inTimeSetMode false,
nombre de secondes pourrait se sont écoulés depuis le dernier d'entre eux, et le temps serait avancer
m_lastTick = millis() ;
}
/**
* Cette méthode vérifie CLOCK_MODE_SWITCH_PIN pour voir si elle est haute. Si c’est le cas,
* Cela signifie que nous sommes maintenant en mode réglage de l’horloge (m_inTimeSetMode a la valeur true), et
* allume le CLOCK_MODE_LED_PIN.
*/
Sub checkMode()
{
m_inTimeSetMode = (analogRead(CLOCK_MODE_SWITCH_PIN) > 512) ;
digitalWrite (CLOCK_MODE_LED_PIN, m_inTimeSetMode) ;
}
