Display mecánico con servos.

Arduino / Reloj

Agregado 2 comentario

El principio de funcionamiento de la pantalla propuesta, que fue hecha y construida por Instructables bajo el apodo de alstroemeria, es la siguiente: los segmentos avanzados por servos proyectan una sombra, lo que los hace visibles. Los segmentos restantes, ubicados en el mismo plano con el fondo, se fusionan con él.

Está claro que hecho en casa Resulta costoso, porque para ella el maestro adquiere hasta 28 servos de este tipo:

Y un módulo de gestión que se conecta a Arduino así:

El módulo de reloj en tiempo real (RTC) en este contexto parece ser un gasto muy pequeño.

Habiendo adquirido todos los componentes necesarios, el maestro hasta ahora los deja de lado para trabajar en plantillas para hacer la parte mecánica de la pantalla. Él obtiene cuatro archivos: 1, 2, 3, 4. El asistente muestra los archivos 1 y 3 dos veces en un plotter de corte, y 2 y 4, uno a la vez, todos en una escala 1: 1, y obtiene seis partes, algunas de las cuales se parecen a las viejas tarjetas perforadas de alguna manera. También puede imprimir, también en una escala de 1: 1 y en las mismas cantidades, y cortar manualmente.

Dremel corta pasadores metálicos huecos con una longitud de 20 mm y tubos con un diámetro externo ligeramente mayor que el diámetro externo del pasador con una longitud de 10 mm:

Pega las capas con cinta gruesa de doble cara, agrega tubos:

Agrega segmentos móviles pegados a los pasadores que pasan a través de los tubos, en el reverso pega los empujadores de alambre de acero a los mismos pasadores, y aquí es donde los pasadores son huecos:

Dobla los empujadores, pega los servos y se conecta a ellos:

Cierra los servos con la hoja perforada restante:

El módulo de servo control se conecta de acuerdo con el esquema dado al comienzo del artículo. Las unidades en sí están conectadas al módulo en el orden correspondiente a las designaciones de segmento estándar:

El módulo RTC se conecta de la siguiente manera: SDA - pin 4 Arduino, SCL - pin 5, más alimentación y cable común - paralelo a las líneas Arduino correspondientes. Aquí está el resultado:

El asistente establece el tiempo en el módulo RTC con este boceto (necesita la biblioteca RTClib):

Dibuja aquí

#include
#include "RTClib.h"

RTC_DS1307 RTC;

configuración nula () {
    Serial.begin (57600);

    Wire.begin ();

    RTC.begin ();
  
    if (! RTC.isrunning ()) {
    Serial.println ("¡RTC NO se está ejecutando!");
    RTC.adjust (DateTime (__ DATE__, __TIME__));
    }
}

Luego completa el boceto principal que requiere la misma biblioteca:

#include 
#include "RTClib.h"

RTC_DS1307 RTC;

corto segA = 0; // Display pin 14
segB corto = 1; // Display pin 16
corto segC = 2; // Display pin 13
segD corto = 3; // Display pin 3
segE corto = 4; // Display pin 5
corto segF = 5; // Display pin 11
segG corta = 6; // Display pin 15

corto segA_OUT = 110;
corto segB_OUT = 110;
corto segC_OUT = 110;
corto segD_OUT = 110;
corto segE_OUT = 110;
corto segF_OUT = 110;
corto segG_OUT = 110;

corto segA_IN = 90;
corto segB_IN = 90;
corto segC_IN = 90;
corto segD_IN = 90;
corto segE_IN = 90;
corto segF_IN = 90;
corto segG_IN = 90;

int TIEMPO = 2000;

DateTime datePast;
DateTime dateNow;

// mantenimiento de la casa
configuración nula () {
  Serial.begin (9600);
  Wire.begin ();
  RTC.begin ();
  RTC.adjust (DateTime (__ DATE__, __TIME__));
  datePast = RTC.now ();
}

// lazo principal
bucle vacío () {
  dateNow = RTC.now ();
  if (! (datePast.hour () == dateNow.hour () && datePast.minute () == dateNow.hour ()))
  {
    displayNumber (dateNow.hour () * 100 + dateNow.minute ());
    datePast = dateNow;
  }
}

// Dado un número, mostramos 10:22
// Después de recorrer los 4 números, la pantalla se deja apagada
void displayNumber (int toDisplay) {
  para (int dígito = 4; dígito> 0; dígito--) {
    lightNumber (toDisplay% 10, dígito);
    toDisplay / = 10;
  }

  // iniciar movimiento
  Serial.print ("T"); Serial.println (TIEMPO);
}

movimiento nulo (int servo, int posición) {
  Serial.print ("#");
  Serial.print (servo);
  Serial.print ("P");
  Serial.print (posición);
}

// Dado un número, activa esos segmentos
// Si número == 10, apague el número
void lightNumber (int numberToDisplay, int segmento) {

  int offset = (segmento - 1) * 7;
  switch (numberToDisplay) {

  caso 0:
    mover (segA + offset, segA_OUT);
    mover (segB + offset, segB_OUT);
    mover (segC + offset, segC_OUT);
    mover (segD + offset, segD_OUT);
    mover (segE + offset, segE_OUT);
    mover (segF + offset, segF_OUT);
    mover (segG + offset, segG_IN);
    romper

  caso 1:
    mover (segA + offset, segA_IN);
    mover (segB + offset, segB_OUT);
    mover (segC + offset, segC_OUT);
    mover (segD + offset, segD_IN);
    mover (segE + desplazamiento, segE_IN);
    mover (segF + offset, segF_IN);
    mover (segG + offset, segG_IN);
    romper

  caso 2:
    mover (segA + offset, segA_OUT);
    mover (segB + offset, segB_OUT);
    mover (segC + offset, segC_IN);
    mover (segD + offset, segD_OUT);
    mover (segE + offset, segE_OUT);
    mover (segF + offset, segF_IN);
    mover (segG + offset, segG_OUT);
    romper

  caso 3:
    mover (segA + offset, segA_OUT);
    mover (segB + offset, segB_OUT);
    mover (segC + offset, segC_OUT);
    mover (segD + offset, segD_OUT);
    mover (segE + desplazamiento, segE_IN);
    mover (segF + offset, segF_IN);
    mover (segG + offset, segG_OUT);
    romper

  caso 4:
    mover (segA + offset, segA_IN);
    mover (segB + offset, segB_OUT);
    mover (segC + offset, segC_OUT);
    mover (segD + offset, segD_IN);
    mover (segE + desplazamiento, segE_IN);
    mover (segF + offset, segF_OUT);
    mover (segG + offset, segG_OUT);
    romper

  caso 5:
    mover (segA + offset, segA_OUT);
    mover (segB + offset, segB_IN);
    mover (segC + offset, segC_OUT);
    mover (segD + offset, segD_OUT);
    mover (segE + desplazamiento, segE_IN);
    mover (segF + offset, segF_OUT);
    mover (segG + offset, segG_OUT);
    romper

  caso 6:
    mover (segA + offset, segA_OUT);
    mover (segB + offset, segB_IN);
    mover (segC + offset, segC_OUT);
    mover (segD + offset, segD_OUT);
    mover (segE + offset, segE_OUT);
    mover (segF + offset, segF_OUT);
    mover (segG + offset, segG_OUT);
    romper

  caso 7:
    mover (segA + offset, segA_OUT);
    mover (segB + offset, segB_OUT);
    mover (segC + offset, segC_OUT);
    mover (segD + offset, segD_IN);
    mover (segE + desplazamiento, segE_IN);
    mover (segF + offset, segF_IN);
    mover (segG + offset, segG_IN);
    romper

  caso 8:
    mover (segA + offset, segA_OUT);
    mover (segB + offset, segB_OUT);
    mover (segC + offset, segC_OUT);
    mover (segD + offset, segD_OUT);
    mover (segE + offset, segE_OUT);
    mover (segF + offset, segF_OUT);
    mover (segG + offset, segG_OUT);
    romper

  caso 9:
    mover (segA + offset, segA_OUT);
    mover (segB + offset, segB_OUT);
    mover (segC + offset, segC_OUT);
    mover (segD + offset, segD_OUT);
    mover (segE + desplazamiento, segE_IN);
    mover (segF + offset, segF_OUT);
    mover (segG + offset, segG_OUT);
    romper

  caso 10:
    mover (segA + offset, segA_IN);
    mover (segB + offset, segB_IN);
    mover (segC + offset, segC_IN);
    mover (segD + offset, segD_IN);
    mover (segE + desplazamiento, segE_IN);
    mover (segF + offset, segF_IN);
    mover (segG + offset, segG_IN);
    romper
  }
}

Todo funciona: