Reloj DeLorean. Vamos a dar un paseo al futuro!

¡En el futuro! Si a Marty McFly le hubieran contado lo que realmente nos esperaba en el año 2020, no sé si de verdad hubiera querido viajar allí. Pero ¡no nos queda otra que mirar hacia delante! Y, ¿qué forma mejor de evitar los problemas actuales, que dar un salto hacia delante? Quédate con nosotros a descubrir como ajustar el reloj DeLorean, y evitar otro año de horrible cuarentena.

 

Lo primero de todo que tenemos que tener bien claro es los materiales que vamos a utilizar. Afortunadamente, no se trata de un proyecto demasiado complejo. Se trata únicamente de aplicar nuestros conocimientos en Arduino a una serie de displays de 7 segmentos. Una vez hayamos impreso la carcasa con ayuda de la impresión 3D, el resto será cuestión de soldar y voilà, Reloj DeLorean montado. Nosotros hemos tomado de referencia el montaje original de je-je linge. También podéis seguir su blog para realizar este montaje, pero os invitamos aún así a que lo montéis con nosotros y así veáis nuestro punto de vista.

Os dejamos todo lo necesario para llevar acabo este proyecto en nuestra cuenta de GitHub (código Arduino, librerias y pegatinas).

 

¿Verdad que quedó chulo?

 

Listado de materiales para tu Reloj DeLorean

 

Vamos a hacer un listado de todos y cada uno de los materiales que vamos a emplear en nuestro montaje:

 

Los displays

El primero de todos es el más evidente, los displays de 7 segmentos. Yo los he adquirido por Banggood, aunque están también disponibles en Aliexpress. Lo principal que debemos tener en cuenta es usar 9, a poder ser, de los colores de la peli, aunque no tienen que ser forzosamente estos.

La iluminación

Otro de los básicos de nuestros proyectos son los diodos Led. Es un imprescindible de este y otros proyectos.  Porque todos los proyectos lucen mucho más con unas cuantas de nuestras bombillitas preferidas, aquí tenéis un importante surtido variado de nuestros inseparables compañeros. Casi de la mano de todos ellos, tenemos que tener a mano un buen juego de resistencias, cuyo valor sea algo intermedio entre 220 y 470 ohmios, para garantizar una buena iluminación sin riesgo de chamuscar nuestros queridos Leds.

El controlador

El núcleo de nuestro proyecto lo va a componer un Arduino Nano. Este barato y versátil microcontrolador, nos va a venir perfecto por su reducido tamaño, para introducirlo en nuestras conexiones, así como por su bajo precio, que va a ayudar a contener el coste del presupuesto.

RTC

No podemos olvidarnos, para diseñar nuestro reloj, ¡de introducir un reloj! (RTC). Este pequeño instrumento es esencial, pues va a permitirnos conocer en todo momento, la hora real en la que nos encontremos. Ya veremos posteriormente, cuando hablemos del código de Arduino, que este va a ser un tema controvertido, pues vamos a tener que hablar del horario de invierno y de verano. Sin enrollarnos demasiado, vamos a proponeros estos modelos de reloj, a los que más tarde debemos añadir una pila de 3V.

La alimentación

En el apartado de la alimentación, tenemos que hacer uso de un enchufe de 220 a 5V, con una intensidad de 2A. Creemos que el cargador clásico de los móviles es una buena opción, ya que vamos a poder reciclarlo de nuestras estanterías y darle un nuevo uso (al menos en nuestro caso, en el vuestro de no tener uno, podéis buscarlo en el enlace adjunto. Para conectar el cargador vamos a hacer un uso de un adaptador Balun Hembra, disponible aquí. Todos estos materiales han de ir unidos por cables, de los cuales asumo que encontraréis por casa.

Barretas/Bornas para cables

Se necesitan para conectar todos los cables que van a Vcc y a 0V al Arduino. Puede que no parezca necesario, pero realmente es imprescindible para realizar bien este proyecto. Como consejo os recomiendo cortar sólo un poco el borde de los cables, y asegurarse de que agarren bien los mismos al bornero que montemos. Borneros hay muchos, yo os pongo estos que tienen un enganche rápido muy cómodo.

Y con esto completaríamos los materiales necesarios…

 

 

 

 

 

 

Siguiendo los enlaces de Aliexpress, conseguimos el listado de materiales completo por unos 25 € aprox. Es un precio muy redondo, que podéis comparar con el de jeje linge, que oscila entre los 80-90 euros. Creo que ya sólo por eso merece la pena editar esta entrada, pero si aún no estás convencido, ¡te reto a que sigas leyendo!

Impresión 3D

El próximo paso para realizar nuestro montaje tras hacer nuestro pedido será, imprimir nuestras piezas. Para la impresión 3D, vamos a descargar los archivos .stl desde el sitio web de Thingiverse. Hay varios diseños en la web, pero nosotros vamos a seguir el montaje original. Una vez descargados los archivos, los abriremos en el laminador 3D que usemos, en nuestro caso es el Ultimaker Cura.

 

Parámetros del Cura

 

Nosotros hemos escogido una resolución de la pieza de 0.2 mm, dado que es una pieza de gran tamaño, para evitar que nuestras impresiones se eternicen. Es una pieza que requiere soportes para los agujeros que tiene en el medio para pasar los cables. También hemos tenido que hacer uso de 60ºC en la cama caliente, para evitar que la pieza se despegue, dado que la pieza va a estar muchas horas haciéndose (incluso 12) en nuestra área de impresión. Colocamos una velocidad de 50 mm/s para no forzar excesivamente nuestra impresora.

 

Montaje Reloj DeLorean

El montaje del reloj DeLorean se compondrá por una parte de juntar y pegar todas las piezas impresas, y por la otra, de soldar los componentes y conectarlos a la placa Arduino. Para pegar las piezas impresas hemos hecho uso del loctite, herramienta popular donde las haya. Hay que hacer coincidir los agujeros del medio de los tres bloques. Aprovechando unas pinzas, hemos mantenido presión durante unos minutos largos en las piezas hasta conseguir una estructura sólida. Dado que nosotros hicimos uso de un PLA plateado para la elaboración de nuestra pieza, no hemos necesitado de spray para pintarla.

 

Para la parte del cableado eléctrico, necesitaremos hacer uso de un soldador, cable y estaño. Yo empleo a mayores pasta flux para que sea más sencillo soldar cada uno de los cables. Primero tenemos que cablear los displays, para ello utilizamos el siguiente esquema:

 

Cableado Displays

 

Después pasaremos a soldar los leds de colores. Si se quiere, los leds verdes se pueden conectar uno al pin 12 y el otro al 13, y en vez de lucir todo el rato, lucirán uno cuando la hora sea AM y el otro cuando sea PM. Nosotros no lo hemos hecho, pero el código que os dejamos si que tiene contemplada esa opción.

Cableado leds

 

El RTC también necesita que le soldemos unos cables:

Cableado RTC

 

 

También tenemos que soldar los cables de alimentación al conector

Cableado conector

 

Una vez soldados todos los cables, lo primero que tenemos que hacer es pegar con pegamento fuerte los leds en sus respectivos agujeros (rojos arriba, verdes en medio y amarillos abajo). Después colocaremos los leds en su correspondentes huecos. Seguidamente, pasaremos los cables por los agujeros hasta que estén todos abajo.

El conector de la alimentación, hay que colocarle en el agujero situado abajo a la derecha. También le pegaremos con pegamento fuerte o silicona caliente.

Una vez que tengamos todos los cables, hay que ir conectado todos los Vcc a unas barretas y todos los 0V a otras barretas. Como dato; si als barretas son pequeñas, se conectan entre sí mediante un cable y así podemos seguir conectando cables en otra barreta.

Una vez conectados los Vcc y los 0V a las barretas, sacamos un cable Vcc de una barreta y lo conectamos a +5V del arduino y otro cable de las barretas de 0V y lo conectamos a GND en el arduino. Después conectaremos las entradas A4 y A5 del RTC y las D3-D11 de los displays.

Nosotros hemos pegado con silicona caliente todos los componentes para que no se uevan y para que esté todo más ordenado, porque no hay apenas hueco.

Para finalizar, tenemos que pegar las pegatinas que os hemos dejado en nuestro github, para poder distinguir que display nos marca la hora y cual el año, etc.

Al final de la entrada os mostramos un vídeo con todo el montaje donde podréis ver como se ha realizado el montaje y así apoyaros con esta entrada.

Código Arduino

El código de Arduino disponible va a hacer distinción horaria entre horario de invierno y horario de verano. Será una canallada, pero cada 6 meses deberemos de cambiar el código empleado para que se ajuste el letrero de la hora actual (la fila del medio). Tal y como os hemos dicho al principio, tenéis las librerías y los códigos en nuestro GitHub.

Nota: Estamos intentando crear un código que cambie automáticamente el horario de invierno-verano, pero necesitamos un poco de tiempo para ponernos con ello…

Os aconsejo primero cargar el siguiente programa para que el RTC coja la hora actúal (esto ya es un consejito después de muchos dolores de cabeza con los RTC). La hora la podréis ver en el monitor serie (no os aparecerá en los displays). Para cargar este código necesitaremos las librerías Wire y RTClib.

Si este código no os funciona, os dejo otro en GitHub que también funciona muy bien.

//Ejemplo basico para la lectura de la hora y fecha del modulo DS1307


#include <Wire.h> //llamado de libreria

#include "RTClib.h" //llamado de libreria DS1307

 
RTC_DS1307 RTC;

void setup () {

    Serial.begin(57600);

    Wire.begin();

    RTC.begin();

 

  if (! RTC.isrunning()) {

    Serial.println("RTC is NOT running!");  

    RTC.adjust(DateTime(__DATE__, __TIME__));

  }

}

 

void loop () {

    DateTime now = RTC.now();
 
    
    Serial.print(now.day(), DEC);

    Serial.print('/');
    
    Serial.print(now.month(), DEC);

    Serial.print('/');

    Serial.print(now.year(), DEC);

    Serial.print(' ');

    Serial.print(now.hour(), DEC);

    Serial.print(':');

    Serial.print(now.minute(), DEC);

    Serial.print(':');

    Serial.print(now.second(), DEC);

    Serial.println();

   
    delay(950);
}

 

Ahora si que sí, vamos a cargar el programa final. Para hacer el intercambio de verano a invierno y viceversa, no tendremos más que comentar/descomentar unas de las dos líneas dentro del void loop (línea 125 o 126).

Nosotros no lo hemos hecho, pero si conectáis los leds del medio a los pines 12 y 13, se encenderá uno cuando la hora es AM y el otro cuando es PM (está en el programa ya programado)

Para cargar este código deberemos hacer uso de las librerías RTClib, SevenSegmentTM1637 y SevenSegmentExtended.

Nota: Este programa hay que meterle inmediatamente después que el anterior, sino la hora no coincidirá, dado que cogerá la hora del anterior programa para empezar.
#include "SevenSegmentTM1637.h"
#include "SevenSegmentExtended.h"
#include "RTClib.h"

// Salida reloj Rojo
const byte PIN_CLK_Red = A0;   // define CLK pin  
// Salida reloj Verde
const byte PIN_CLK_Green = A1;   // define CLK pin 
// Salida reloj Naranja
const byte PIN_CLK_Orange = A2;   // define CLK pin 

//Displays Rojos
const byte PIN_DIO_R1 = 3;
SevenSegmentExtended      red1(PIN_CLK_Red, PIN_DIO_R1);
const byte PIN_DIO_R2 = 4;
SevenSegmentTM1637       red2(PIN_CLK_Red, PIN_DIO_R2);
const byte PIN_DIO_R3 = 5;
SevenSegmentExtended     red3(PIN_CLK_Red, PIN_DIO_R3);

//Displays Verdes
const byte PIN_DIO_G1 = 6;
SevenSegmentExtended      green1(PIN_CLK_Green, PIN_DIO_G1);
const byte PIN_DIO_G2 = 7;
SevenSegmentTM1637       green2(PIN_CLK_Green, PIN_DIO_G2);
const byte PIN_DIO_G3 = 8;
SevenSegmentExtended     green3(PIN_CLK_Green, PIN_DIO_G3);

//se pueden conectar los leds del medio a los pines 12 y 13
int greenAM = 12;
int greenPM = 13;

// Displays Naranjas
const byte PIN_DIO_O1 = 9;   // define DIO pin (any digital pin)
SevenSegmentExtended      orange1(PIN_CLK_Orange, PIN_DIO_O1); // SegmentExtended pour utiliser la methode "PrintTime"
const byte PIN_DIO_O2 = 10;   
SevenSegmentTM1637        orange2(PIN_CLK_Orange, PIN_DIO_O2); //SegmentTM1637 pour utiliser la methode "print" permet d'enlever les ":" entre les chiffres
const byte PIN_DIO_O3 = 11;   
SevenSegmentExtended       orange3(PIN_CLK_Orange, PIN_DIO_O3); 

bool parse=false;
bool config=false;
int Hour=0;
RTC_DS3231 rtc;
int backlight = 50;
int year_red = 2028;
int year_orange = 2018;

void setup() {

  pinMode(PIN_CLK_Red, OUTPUT);
  pinMode(PIN_CLK_Green, OUTPUT);
  pinMode(PIN_CLK_Orange, OUTPUT);
  pinMode(PIN_DIO_O1, OUTPUT);
  pinMode(PIN_DIO_O2, OUTPUT);
  pinMode(PIN_DIO_O3, OUTPUT);
  pinMode(PIN_DIO_G1, OUTPUT); 
  pinMode(PIN_DIO_G2, OUTPUT);
  pinMode(PIN_DIO_G3, OUTPUT); 
  pinMode(PIN_DIO_R1, OUTPUT);
  pinMode(PIN_DIO_R2, OUTPUT);
  pinMode(PIN_DIO_R3, OUTPUT);
  pinMode(greenAM, OUTPUT);
  pinMode(greenPM, OUTPUT);

  Serial.begin(9600);       // inicializa la conexión del Seriañ a  @9600 baudios
  orange1.begin();          // inicializa el display
  orange2.begin();
  orange3.begin();              
  green1.begin();
  green2.begin();
  green3.begin();            
  red1.begin();
  red2.begin();
  red3.begin();            
  orange1.setBacklight(backlight);  //establece el brillo al 100 %
  orange2.setBacklight(backlight);
  orange2.setColonOn(0); // Switch off ":" for orange "year"
  orange3.setBacklight(backlight);  
  green1.setBacklight(backlight); 
  green2.setBacklight(backlight);
  green3.setBacklight(backlight); 
  red1.setBacklight(backlight);
  red2.setBacklight(backlight);
  red3.setBacklight(backlight);  
  red2.setColonOn(0); // Switch off ":" for red "year"
  
#ifndef ESP8266
  while (!Serial); 
#endif

  Serial.begin(9600);

  delay(3000); // wait for console opening

  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (rtc.lostPower()) {
    Serial.println("RTC lost power, lets set the time!");
    // cuando se va la alimentación, el reloj vuelve a la hora de compilación del programa
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }

}

void loop() {
  
    DateTime now = rtc.now();
    Serial.print(now.year(), DEC);
    Serial.print('/');
    Serial.print(now.month(), DEC);
    Serial.print('/');
    Serial.print(now.day(), DEC);
    Serial.print(" ");
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();

//Descomentar dependiendo si estamso en el horario de verano o en el de invierno
//Hour=now.hour(); // Horario de verano
//Hour=now.hour()-1; // Horario de invierno

if(now.hour()>=13){
   Hour=now.hour();
  digitalWrite(greenAM,0);
  digitalWrite(greenPM,1);}
  
else if(now.hour()==12)
  {Hour=now.hour();
   digitalWrite(greenAM,0);
  digitalWrite(greenPM,1);}

else{
  Hour=now.hour();
  digitalWrite(greenAM,1);
  digitalWrite(greenPM,0);
  }

//Displays Rojos -  HORA del pasado: 11.09 2028 10:07
red1.printTime(11, 9, true);
red2.print(year_red, true);
red3.printTime(10, 07, true); 

//Green Displays - HORa del presente - Heora actual
green1.printTime(now.month(), now.day(), true);  
green2.print(now.year());
green3.printTime(Hour, now.minute(), true);

// Orange Displays - HORA del futuro 10.09 2018 01:24                      
orange1.printTime(11, 9, true);                     
orange2.print(year_orange, true);
orange3.printTime(01, 24, true);
                     
}

 

Y nada más, proyecto sencillito, no demasiado caro, y que le da un toque molón y retro a tu mesita del salón o escritorio. Os dejamos con un último vídeo para Youtube, espero que os haya gustado y os animéis a seguirnos pues tenemos nuevos proyectos en camino.

¡¡¡Un abrazo y hasta pronto!!!

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *