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

Paso 7: Prototipo de la pantalla y ajuste de la hora

Para esto, utilizaremos un interruptor de un polo doble tiro (SPDT), o un interruptor "- en". Conecte el conductor central al A2 entrada analógica, uno de los conductores fuera de tierra y el otro cable exterior a 5V. El método de analogRead(A2) ahora debe devolver 0 o 1023 cuando el interruptor se activa y hacia atrás.

Te queremos contar visualmente al usuario están en modo de ajuste de hora con un LED. La ONU sólo tiene 14 pines digitales, y puesto que ya estamos utilizando (13 para los LEDs de tiempo) y 1 perno para el PWM que se utilizarán en el medidor análogo, por suerte podemos dar un pin analógico en digital pasador! Simplemente llame al pinMode (A5, salida) usar A5 como un pin de salida digital.

Tendremos que comprobar si estamos en modo de ajuste de la hora o tiempo mostrando al principio del método loop(). A poner la lógica en un método llamado checkMode().

Ahora tiene un reloj binario que mantiene el tiempo y puede ser ajustada manualmente por el usuario.

Todo el código hasta ahora
/*
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, permite por vez
ajuste con el potenciómetro y puede ser fijada entre el tiempo
configuración de modo de visualización de tiempo y modo.

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;

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;

la rutina de instalación se ejecuta una vez al presionar reset:
void setup()
{
una de las entradas analógicas utilizando como salida
pinMode (CLOCK_MODE_LED_PIN, salida);

Inicializa los pines utilizados para salida de tiempo como salida
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 (2, 18, 0);
}

una y otra vez funciona para siempre la rutina bucle:
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;
}
}
}
}
}

void displaySeconds()
{
Control TODO la pantalla analógica
}

/**
* Este método lee el m_minute variable, 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 variable, 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);

escala de las lecturas (de 0 a 1023) a la escala adecuada (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);
}