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

Paso 4: Programar el reloj

En este paso, vamos a crear un programa a ser cargado en el microcontrolador ATmega en la placa Arduino Uno. El programa pondrá el 13 necesaria LEDs mostrar un reloj de 24 horas en binario. En pasos posteriores, a preocuparnos por el tiempo, pero por ahora siempre se iniciará a las 00:00.

Estructura del programa
Programas Arduino tienen 2 métodos principales; un método que se ejecuta una vez al principio donde se realiza la inicialización (llamado setup) y otro método que se llama continuamente (llamado loop).

En setup(), a configurar el tiempo a 00:00 y establecer cuales pines van a unidad 13 LEDs.

En el loop() a ver si más de un segundo se ellapsed (y si es así, incrementar el tiempo), luego mostrar el tiempo alimentando el LED apropiado. El método millis() es fundamental para mantener el tiempo. Devuelve el número de milisegundos que tienen ellapsed ya que el circuito fue desarrollado como un sin firmar largo. "Sin signo" significa que no sea negativa y mucho se refiere a cuántos bits (32 para ser exactos) se utilizan para realizar un seguimiento de este número (los bits son el número de dígitos binarios).

El capricho con millis()
Ya que existe un número finito de bits en un sin firmar largo, en algún momento nos vamos de dígitos! Según la documentación de Arduino en millis(), envolverá alrededor (es decir, restablecer a cero) después de aproximadamente 50 días. ¿Lo molesto sería tener que reajustar su reloj cada 50 días? Como uno de los Estados objetivos, estamos luchando por la perfección funcional y este comportamiento distruptive es inaceptable. Así, la lógica en el método tick() se usa para ver cuando nos envuelva y seguir sin que nadie lo supiera.

Asignaciones de pines
Antes de saltar en pleno y comienzo de asignación de pins digitales, se te requiere un pin PWM (anchura de pulso modulado) para mostrar los segundos en el medidor analógico en un paso posterior. En el Arduino Uno, pines 3, 5, 6, 9, 10 y 11 están habilitados para PWM (como significada por la "~"). Por lo tanto, soy ahorro pin 11 de pantalla analógica y usando las clavijas 0 - 10, 12 y 13 para la exhibición de LED binario.

El código de
/*
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.

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

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 cuando usted pulse reset
void setup()
{
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 (0, 0, 0);
}

la rutina de loop se ejecuta una y otra vez para siempre
void loop()
{
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_second, m_minute y m_hour.
*/
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()
{
TODO leer los potenciómetros, fijar la hora y minutos
}