Étape 4: Programmation de l’horloge
Structure du programme
Arduino programmes ont 2 principales méthodes ; une méthode qui est exécutée une fois au début lorsque l’initialisation est effectuée (appelé setup) et une autre méthode qui est appelée en permanence (appelé boucle).
Dans setup(), nous régler l’heure à 00:00 et mettre en place les épingles vont en voiture le 13 LEDs.
Dans loop() nous allons voir si plus d’une seconde a ellapsed (et dans l’affirmative, incrémentez le temps), puis afficher l’heure en alimentant les LEDs appropriées. La méthode millis() joue un rôle important pour garder le temps. Elle retourne le nombre de millisecondes qui ont ellapsed, comme le circuit est alimenté comme un unsigned long. « Non signé » signifie qu’il ne sera pas négatif et long se réfère à combien de bits (32 pour être exact) est utilisés pour garder une trace de ce nombre (bits correspondent au numéro de chiffres binaires).
La bizarrerie avec millis()
Étant donné qu’un nombre fini de bits dans un unsigned long, à un moment donné nous allons manquer de chiffres ! Selon la documentation Arduino sur millis(), il se terminera autour (c’est à dire, remise à zéro) après environ 50 jours. Comment ennuyeux qui serait d’avoir à nouveau régler votre horloge tous les 50 jours ? Parmi les États de buts, nous sommes la quête de la perfection fonctionnelle et ce comportement perturbe est inacceptable. Ainsi, la logique dans notre méthode tick() est utilisée pour voir quand nous envelopper et continuer sans que personne n’étant le plus sage.
Affectation des broches
Avant de nous lancer en plein et commencer à assigner des broches numériques, nous allons requis une épingle (largeur d’impulsion modulée) de PWM pour afficher les secondes sur le compteur analogique dans une étape ultérieure. Sur l’Arduino Uno, broches, 3, 5, 6, 9, 10 et 11 sont activés pour PWM (comme signifié par le "~"). Donc, je suis sauver broche 11 pour l’affichage analogique et à l’aide de broches 0 - 10, 12 et 13 pour l’affichage à LED binaire.
Le code
/*
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
attaché à broches numériques entre 0 et 10, 12 et 13.
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
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()
{
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 (0, 0, 0) ;
}
la routine de la boucle s’exécute maintes et maintes fois pour toujours
void loop()
{
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_second, m_minute et m_hour.
*/
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()
{
TODO lire les potentiomètres, régler l’heure et les minutes
}
