Étape 9: Prototypage l’écran, réglage de l’heure et secondes
Dans la vidéo suivante, j’utilise le bouton de réinitialisation sur l’ONU pour lancer notre programme depuis le début (temps de 00:00). Vous pouvez voir les secondes comptage sur le compteur analogique qui malheureusement a une valeur maximale de 50, 60 pas (mais nous pouvons ouvrir et échanger sur le fond, si vous le souhaitez). Peu importe ce que le mètre indique, il "tiques" 60 fois par minute. Après une minute, nous voyons le temps changer à 00:01, et remet à zéro le compteur analogique. Plus tard, je passe en mode de réglage de temps (c’est lors de l’allumage de la LED orange en haut au centre), à quel point vous pouvez voir les secondes réinitialisé à 0. J’ai mis du temps à 16:59 et le moment où que je tourne mode de réglage hors tension (la LED orange sur le haut au centre de s’éteint), les secondes sur le compteur analogique commencent à décompter à nouveau. J’ai alors attendre encore une minute, à quel point le temps passe à 17:00.
Le Code Final
/*
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. 2 potentiomètres
connecté à A0 et A1 contrôle les heures et les minutes respectivement,
et seulement si A2 est tiré en haut. Quand on tire sur A2 haute, une LED sur
broche A5 s’allume pour indiquer à l’utilisateur qu’elles sont définies dans le temps mode.
Enfin, la broche 11 est utilisé avec PWM pour montrer les secondes sur un analogue
ampèremètre.
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 ;
MLI sur le compteur analogique pour afficher les secondes.
int SEC_OUTPUT_PIN = 11 ;
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 ;
/**
* Routine de configuration obligatoire pour Arduino, est exécuté une fois, au tout début.
*/
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
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) ;
}
/**
* Méthode obligatoire pour Arduino, on l’appelle en permanence après setup().
*/
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 ;
}
}
}
}
}
/**
* Cette méthode utilise PWM pour afficher la m_second sur un compteur analogique connecté
* à SEC_OUTPUT_PIN.
*/
Sub displaySeconds()
{
analogWrite (SEC_OUTPUT_PIN, carte (m_second, 59, 0, 0, 255)) ;
}
/**
* Cette méthode lit le m_minute, le 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, le 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) ;
les lectures de capteurs (de 0 à 1023) pour le cas échéant à l’échelle
échelle (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) ;
}