En este Instructable, intentaré hacer este increíble reloj que encontré en el sitio web de Hack-a-day. Un poco se explica sobre cómo funciona el reloj, ya que todavía está en desarrollo. Pero a partir del video de The You-tube, parece que están usando algún tipo de pantalla Flip-disc, no hay cables entre la piedra de Horas / minutos, lo que sugiere que usa algún tipo de tecnología inalámbrica.

Mi conocimiento electrónico es muy limitado, por lo que las piedras se conectarán entre sí.

Como quería hacer algo similar, y como no tengo experiencia en electrónica, este es mi primer proyecto electrónico, hice una investigación intensiva, compré un kit de inicio de Adruino y experimenté un poco. y leí mucho de Instructables y foros, aprendí mucho y quiero compartir con ustedes lo que aprendí.

Haré todo lo posible por explicar mi trabajo en la mayor cantidad de detalles posible, compartiendo algunos de los enlaces que he realizado durante la realización de este proyecto.

Así que este Instructable es cómo hacer que este reloj dominó usando un tablero Adruino, intentaré dividirlo principalmente en tres partes:

1 - El hardware

- El electroimán de bricolaje / Flip-dot

- El circuito electrónico real.

2 - El software

3 - La construcción de la caja del reloj real

Entonces … ¡comencemos!:)

Suministros:

Paso 1: Habilidades requeridas

Como dije antes, incluso si tengo un gran interés en la electrónica y no tengo conocimiento de ello, este es mi primer proyecto. así que si eres un novato como yo, investiga un poco, y cómo funciona el componente, no es tan difícil en realidad … hay mucha lógica involucrada.

Durante mi "viaje" descubrí que tienes que tener y comprensión para:

- Electrónica básica. (Lee el Instructable. ¡Aún aprenderás mucho!)

- Cómo soldar.

- Cómo utilizar un multímetro, etc.

- Escribir código en C, o al menos poder entender el código que estás leyendo y cómo funciona.

También debe tener paciencia y una generosa cantidad de tiempo libre.:)

Paso 2: Lista de componentes

Esto es lo que necesitas para hacer un reloj dominó:

• 21x LED's (más algún extra por cometer errores)
• Un tablero arduino
• 21 Parte superior del conductor actual como un ULN2803
• 2 pulsadores
• 21 turnos de registro como un 74HC595
• 2x o 3x grandes prototipos de PCB s. El tipo con cobre "ojos".
• RTC (reloj de tiempo real) como un DS1307
• 21 tornillos metalicos
• Alambre de cobre aislado (preferiblemente uno grueso)
• Batería conduciendo el RTC como un CR2032v con su titular
• Oscilador de cristal de 32 khz
• Pieza de madera para la caja del reloj.
• algunos cables
• Resistores (los valores vendrán bajo los pasos)
• Transistores (los valores vendrán bajo los pasos)
• 21 imán regular redondo pequeño (9,5 mm x 3,2 mm)

Paso 3: Haciendo el Flip - Puntos (1)

puede visualizar el efecto de cambio de hora usando diferentes métodos, el más fácil será usar algunos LED que se enciendan y se apaguen … pero Heyyy … ¡qué genial es eso!.. alternativamente puedes usar un flip-dots. Usted puede comprar estos en

www.flipdots.com/EN/electromagnetic_displays/products/page-10/electromagnetic_status_indicators.html

pero vamos, esto es instructivos que estamos tratando de hacer cosas desde cero, así que haremos un flip-point desde cero, por primera vez alguna teoría acerca de cómo opera flip-dots puedes hacer un bucle a este sitio web:

www.flipdots.com/EN/electromagnetic_displays/principle_of_operations/index.html

Para construir el electromagneto necesitarás:

- unos cables de cobre aislados, como un cable magnético (uno grueso, para evitar que el imán se caliente)

- un tornillo metálico

- un pequeño imán regular redondo (9,5 mm x 3,2 mm) (se puede encontrar aquí:

- el soporte (imprima las plantillas adjuntas y córtelas, y luego péguelas)

Antes de llegar a las instrucciones exactas de construcción, tengo que mencionar un par de cosas, estamos haciendo un electroimán como parte de un circuito electrónico, lo que significa que debemos tener en cuenta el La corriente pasa por el imán, los resistans. necesaria y no menos importante la fuerza de tracción del imán, para que pueda coincidir con la fuerza de imán regular que compramos en el sitio web, para eso:

Para el corriente:

Los LED están limitados a 20 mA, lo cual no será suficiente para manejar nuestro electroimán, por eso vamos a utilizar una parte del controlador de corriente más alta como una ULN2803 Con su propia resistencia de límite de corriente para el imán, el número de devanados y el calibre del cable y el núcleo que utiliza impactarán la impedancia de la bobina resultante y, por lo tanto, su consumo de corriente.

Para el resistans:

puede hacerlo de forma experimental: encuentre una resistencia variable de mayor vataje, póngala en serie con el suministro, la bobina y el transistor, con el transistor NPN como el ULN2803 como la parte inferior de la cuerda que va a tierra.

Agregue una resistencia a tierra a un pin de entrada, y un interruptor a +5 para que pueda subir un momento para encenderlo.

Marca el resistor a la resistencia más alta, y bájalo lentamente hasta que obtengas tu respuesta, ¡o hasta que algo fume!.. ¡Oooops!

Para el Fuerza de tracción:

Fuerza magnética = I * N donde I es actual y N es la cantidad de vueltas

Entonces, ahora que tenemos una idea de lo que necesitamos, hagamos nuestros puntos …

Paso 4: Haciendo el Flip - Puntos (2)

Paso 5: La parte de hardware - una descripción

Lo primero que necesitas es:

Un tablero arduino (Se puede comprar en:

Como es un reloj que haremos, si no lo mencioné antes: -), entonces necesitaremos algún tipo de mecanismo de tiempo, para eso podemos usar:

- el reloj interno de arduino, que está bien, pero durante mi búsqueda descubrí que no es tan preciso, y quería algo preciso, así que no tengo que configurar el reloj cada vez, así que vamos a utilizar un RTC (Reloj en tiempo real).. estoy usando:

- DS1307 (documentación:

Tenemos seguimiento de salidas múltiples (21 en total) pero tenemos pines de salida limitados de nuestra placa arduino, para resolver que vamos a utilizar registros de desplazamiento, - 74HC595 (documentación:

lo que hacen básicamente los registros de desplazamiento es tomar datos en serie y dividirlos en paralelos, luego combinar los datos de entrada con una señal de reloj para que podamos obtener datos de salida útiles sincronizados.

Para obtener más información, consulte estos tutoriales shiftout:

www.arduino.cc/en/Tutorial/ShiftOut

www.youtube.com/watch?v=R7xI-flj1Mw

www.youtube.com/watch?v=6lFi07CSXUY&feature=channel

y luego necesitas algo resistencias, algunos LED's, y el electroimán que hicimos en el paso anterior:)

Paso 6: La parte de software - Explicación del código (1)

¡Este reloj puede ser codificado de diferentes maneras! … en mi ejemplo y para que sea más fácil para mí, usaré 3 registros de desplazamiento para cada dígito (6 en total) y cada 2 registros de desplazamiento (74HC595) se conectarán a 3 pines de salida de Arduino, luego lo intentaré para cambiar los datos enviados de un registro de desplazamiento a otro!

Aquí una explicación detallada del Código

1) Comenzaremos por definir nuestros pines, estamos usando pines Ar Arduino para cada registro de 2 turnos (consulte la documentación de los pines)

arduino.cc/en/Reference/Int

// Líneas de datos a la piedra de la hora

int hlatchPin = 3;

int hclockPin = 4;

int hdataPin = 5;

// Líneas de datos a la piedra del minuto decimal

int dlatchPin = 6;

int dclockPin = 7;

int ddataPin = 8;

// Líneas de datos a la piedra de un solo minuto.

int mlatchPin = 9;

int mclockPin = 10;

int mdataPin = 11;

// botones de ajuste de hora y minuto

const int hourPin = 12;

const int minPin = 13;

2) Entonces definimos nuestras variables.

int h = 0;

int m = 0;

int mins = 0;

int d = 0;

int previousHours = 0;

int previousMins = 0;

byte number_to_display;

int hours_display 13;

3) Luego definimos el valor de la visualización de la hora (binario: solo mire la imagen adjunta)

Una referencia de matriz:

number_to_display 0 = 0000000000000000;

number_to_display 1 = 0000000001000000;

number_to_display 2 = 0100000001000000;

number_to_display 3 = 0100000000100100;

number_to_display 4 = 0010010000100100;

number_to_display 5 = 0010010001100100;

number_to_display 6 = 0110010001100100;

number_to_display 7 = 0110010000101101;

number_to_display 8 = 0010110100101101;

number_to_display 9 = 0010110101101101;

number_to_display 10 = 0110110101101101;

number_to_display 11 = 0110110100111111;

number_to_display 12 = 0011111100111111;

4) declaramos nuestras entradas / salidas

Referencia de Pinmode ():

pinMode (hlatchPin, SALIDA);

pinMode (hclockPin, SALIDA);

pinMode (hdataPin, SALIDA);

pinMode (dlatchPin, SALIDA);

pinMode (dclockPin, SALIDA);

pinMode (ddataPin, SALIDA);

pinMode (mlatchPin, SALIDA);

pinMode (mclockPin, SALIDA);

pinMode (mdataPin, SALIDA);

pinMode (hourPin, INPUT);

pinMode (minPin, INPUT);

Paso 7: Parte del software - Explicación del Código (2)

5) escribiendo el código para los botones, para establecer el tiempo por horas y minutos. Aquí vamos a utilizar un código de rebote con el botón presione para evitar múltiples cambios con cada presión

Puede consultar la referencia aquí:

int hourState = digitalRead (hourPin);

int minState = digitalRead (minPin);

int buttonState; // la hora actual del pin de entrada

int lastButtonState = LOW; // la hora anterior del pin de entrada

int buttonState2; // la hora actual del pin de entrada

int lastButtonState2 = LOW; // la hora anterior del pin de entrada

long lastDebounceTime = 0; // la última vez que se cambió el pin de salida

long debounceDelay = 50; // el tiempo de rebote; aumentar si la salida parpadea

// Ajuste de hora

// si se presiona el botón

// 1) restablecer el temporizador de rebote

// 2) tomar el retraso de rebote como el estado actual

// 3) Establecer el tiempo

// 4) guardar el horario

if (hourState == HIGH) {

lastDebounceTime = millis ();

if ((millis () - lastDebounceTime)> debounceDelay) {

buttonState = hourstate;

}

time_t t = now ();

t = t + 3600;

setTime (t);

lastButtonState = hourstate;

}

// Ajuste de minutos

if (minState == HIGH) {

lastDebounceTime = millis ();

if ((millis () - lastDebounceTime)> debounceDelay) {

buttonState2 = minstate;

}

time_t t = now ();

t = t + 60;

setTime (t);

lastButtonState2 = minstate;

}

6) La última parte es cambiar los datos. Aquí se puede encontrar un tutorial de Dios:

arduino.cc/en/Reference/ShiftOut

h = hourFormat12 ();

m = minuto ();

if (previousHours! = h) {

digitalWrite (hlatchPin, LOW);

shiftOut (hdataPin, hclockPin, MSBFIRST, (number_to_display h >> 8));

shiftOut (hdataPin, hclockPin, MSBFIRST, hours_display h);

digitalWrite (hlatchPin, HIGH);

previousHours = h;

}

if (previousMins! = m) {

mins = m;

si (minutos> = 10) {

d = 0;

mientras (minutos> = 10) {

minutos = minutos - 10;

d = d + 1;

}

digitalWrite (dlatchPin, LOW);

shiftOut (ddataPin, dclockPin, MSBFIRST, (number_to_display d >> 8));

shiftOut (ddataPin, dclockPin, MSBFIRST, number_to_display d);

digitalWrite (dlatchPin, HIGH);

digitalWrite (mlatchPin, LOW);

shiftOut (mdataPin, mclockPin, MSBFIRST, (number_to_display mins >> 8));

shiftOut (mdataPin, mclockPin, MSBFIRST, number_to_display mins);

digitalWrite (mlatchPin, HIGH);

Paso 8: Construyendo el reloj (1)

Paso 9: Construyendo el Reloj (2)