Cwik Clock v1.0 - un reloj binario de Arduino (9 / 15 paso)

Paso 9: Prototipos la pantalla ajuste de la hora y segundos

Ahora que tenemos el programa básico para el funcionamiento de un reloj binario, el know-how de los potenciómetros y son expertos en el uso de amperímetros, es tiempo de poner todos juntos! Puede parecer como el nido de la rata de cables y componentes, pero usted no debería tener problemas si sigues paso a paso.

En el siguiente video, utilizar el botón de reinicio en la ONU para iniciar nuestro programa desde el principio (tiempo 00:00). Se pueden ver a los segundos contando en el medidor análogo que por desgracia tiene un valor máximo de 50, no 60 (pero podemos abrirlo y cambiar el fondo si lo desea). Independientemente de lo que el medidor indica, "garrapatas" 60 veces por minuto. Después de un minuto completo, vemos el tiempo cambiar a 00:01, y restablece el medidor analógico. Más tarde cambiar al modo de ajuste de tiempo (esto es cuando se enciende el LED naranja en la parte superior central), en que punto se puede ver los segundos restablece a 0. Configurar la hora 16:59, y el momento que activar el modo de ajuste de tiempo off (el LED naranja en la parte superior central se apaga), los segundos en el medidor analógico empiezan a contar otra vez. Espere un minuto, momento en el que el tiempo cambia a las 17:00.

El código Final
/*
Cwik Clock v1.0 - la exhibición de prototipos
Autor: Dennis Cwik
Fecha: 23 de julio de 2012

Este programa es el controlador para un reloj binario, LEDs
conectado a los pines digitales 0 a 10, 12 y 13. 2 potenciómetros
conectado al control A0 y A1 las horas y minutos respectivamente,
y sólo cuando A2 es alta. Cuando A2 es alta, un LED en
PIN A5 se encenderá para Dile al usuario que están en tiempo establecer modo.
Finalmente, pin 11 se usa con PWM para mostrar a los segundos en un análogo
amperímetro.

Este ejemplo de código es de dominio público.
*/

Esto puede modificarse para que propósitos de depuración hacer un minuto ir más rápido.
int ONE_SECOND = 1000; medido en milisegundos
int DELAY_BETWEEN_LOOP_CALLS = 200; medido en milisegundos

No topar con esto, es a partir de la documentación de arduino
unsigned MAX_UNSIGNED_LONG largo = 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 º columna de LEDs
int PIN_MIN1 = 0;
int PIN_MIN2 = 1;
int PIN_MIN4 = 2;
int PIN_MIN8 = 3;

2 º columna de LEDs
int PIN_MIN10 = 4;
int PIN_MIN20 = 5;
int PIN_MIN40 = 6;

3 º columna de LEDs
int PIN_HOUR1 = 7;
int PIN_HOUR2 = 8;
int PIN_HOUR4 = 9;
int PIN_HOUR8 = 10;

PWM en el medidor analógico para mostrar a segundos.
int SEC_OUTPUT_PIN = 11;

4 º columna de LEDs
int PIN_HOUR10 = 12;
int PIN_HOUR20 = 13;

la última vez que los segundos en el tiempo se incrementa
m_lastTick largo sin firmar;

solía decirnos si establecemos el tiempo o no
Boolean m_inTimeSetMode = false;

el tiempo de
m_second de bytes;
m_minute de bytes;
m_hour de bytes;

/**
* Rutina de configuración obligatorio para Arduino, se ejecuta una vez al principio.
*/
void setup()
{
una de las entradas analógicas utilizando como salida
pinMode (CLOCK_MODE_LED_PIN, salida);

inicializar los pernos utilizados para hacer salir tiempo
pinMode (PIN_MIN1, salida);
pinMode (PIN_MIN2, salida);
pinMode (PIN_MIN4, salida);
pinMode (PIN_MIN8, salida);
pinMode (PIN_MIN10, salida);
pinMode (PIN_MIN20, salida);
pinMode (PIN_MIN40, salida);

pinMode (PIN_HOUR1, salida);
pinMode (PIN_HOUR2, salida);
pinMode (PIN_HOUR4, salida);
pinMode (PIN_HOUR8, salida);
pinMode (PIN_HOUR10, salida);
pinMode (PIN_HOUR20, salida);

inicializar variables de reloj
m_lastTick = 0;
setTime (0, 0, 0);
}

/**
* Se llama método obligatorio para Arduino, continuamente después setup().
*/
void loop()
{
checkMode();

ver si estamos el tiempo de fraguado, o dejando el flujo de tiempo normalmente
Si (m_inTimeSetMode)
{
getTimeFromPots();
}
otra cosa
{
Tick();
}

Ahora que el tiempo ha sido actualizado, Mostrar la hora
displaySeconds();
displayMinutes();
displayHours();

arbitraria demora así que no estamos procesando a 100% del tiempo,
un acto de ahorro de energía
Delay(DELAY_BETWEEN_LOOP_CALLS);
}

/**
* Un método auxiliar para establecer m_hour, m_minute y m_second.
*/
void setTime (newHour bytes, newMinute bytes, newSecond bytes)
{
m_second = newSecond;
m_minute = newMinute;
m_hour = newHour;
}

/**
* Este método realiza un seguimiento del flujo lógico del tiempo. Si dispone de tiempo suficiente
* pasado desde la última vez que fue llamado, m_second, m_minute y m_hour
* se actualizará apropiado. Esto toma en cuenta que millis() rollos
* en aproximadamente cada 50 días.
*/
void tick()
{
sin firmar largo ahora = millis();
msElapsed largo sin firmar;

primero tenemos que saber cuánto tiempo ha pasado desde la última vez
llamada tick()
Si (ahora < m_lastTick)
{
jadeo, tampoco hemos logramos viajar en el tiempo o millis() envuelto alrededor!
msElapsed = (MAX_UNSIGNED_LONG - m_lastTick) +;
}
otra cosa
{
msElapsed =-m_lastTick;
}

por cada segundo que pasa (ojala solo 1, a menos que nuestro código es realmente perezoso),
Agregar un segundo al tiempo y aumentar los minutos y horas si fuera necesario
para (int i = 0; i < msElapsed / ONE_SECOND; ++ i)
{
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;
}
}
}
}
}

/**
* Este método utiliza PWM para mostrar el m_second en un metro análogo conectado
a la SEC_OUTPUT_PIN.
*/
void displaySeconds()
{
analogWrite (SEC_OUTPUT_PIN, mapa (m_second, 59, 0, 0, 255));
}

/**
* Este método lee el m_minute, convierte a binario y muestra
* que en los LEDs correspondientes (los que PIN_MIN *).
*/
void displayMinutes()
{
bytes los = m_minute % 10;
digitalWrite (PIN_MIN1 y B1);
digitalWrite (PIN_MIN2 y B10);
digitalWrite (PIN_MIN4 y B100);
digitalWrite (PIN_MIN8 y B1000);

División es tipo de cara, pero asumiremos que la compilación esto optimiza para nosotros :)
decenas de bytes = m_minute / 10;
digitalWrite (PIN_MIN10, tens & B1);
digitalWrite (PIN_MIN20, tens & B10);
digitalWrite (PIN_MIN40, decenas y B100);
}

/**
* Este método lee el m_hour, convierte a binario y muestra
* que en los LEDs correspondientes (los que PIN_HOUR *).
*/
void displayHours()
{
bytes los = m_hour % 10;
digitalWrite (PIN_HOUR1 y B1);
digitalWrite (PIN_HOUR2 y B10);
digitalWrite (PIN_HOUR4 y B100);
digitalWrite (PIN_HOUR8 y B1000);

decenas de bytes = m_hour / 10;
digitalWrite (PIN_HOUR10, tens & B1);
digitalWrite (PIN_HOUR20, tens & B10);
}

/**
* Este método lee los valores de los 2 potenciómetros, convierte a
* mimnutes y horas y conjuntos de m_minute y m_hour a los valores asociados.
*/
void getTimeFromPots()
{
leer los potenciómetros
int hourSensor = analogRead(HOUR_INPUT_PIN);
int minuteSensor = analogRead(MIN_INPUT_PIN);

las lecturas del sensor (de 0 a 1023) al apropiado de la escala
escala (0 a 23 horas, de 0 a 59 minutos)
setTime (mapa (hourSensor, 0, 1023, 0, 23), mapa (minuteSensor, 0, 1023, 0, 59), 0);

ajustamos el último tick ahora, porque cuando establece m_inTimeSetMode en false,
cuántos segundos podrían han pasado desde la última de ellas, y el tiempo saltaría adelante
m_lastTick = millis();
}

/**
* Este método comprueba CLOCK_MODE_SWITCH_PIN para ver si es alta. Si es así,
* significa que ahora estamos en modo de ajuste de reloj (m_inTimeSetMode está establecida en true), y
* enciende la CLOCK_MODE_LED_PIN.
*/
void checkMode()
{
m_inTimeSetMode = (analogRead(CLOCK_MODE_SWITCH_PIN) > 512);
digitalWrite (CLOCK_MODE_LED_PIN, m_inTimeSetMode);
}