Saltar al contenido

Construya un reloj de red (NCLK) con Microduino-RTC

julio 11, 2021
FDCSS7FHKVKTGMI

El resolutivo de la sincronización del reloj a través de Internet. por PKJ,

El sistema de administración de reloj basado en la web le permite monitorear el estado del reloj desde cualquier lugar y cambiar la configuración de manera centralizada. y este pequeño dispositivo está construido con tecnología PoE, por lo que los relojes IP obtienen su hora, datos y energía de la misma red que admite sus otros puntos finales IP.

Autor: https://www.facebook.com/pan.kejia
Editor: https://www.facebook.com/Microduino

Principales características:
– Configurado automáticamente por SNTP (Protocolo simple de tiempo de red)
– DHCP o IP estática direccionable
– Alimentación a través de Ethernet (IEEE 802.3af) utilizando los mismos componentes de red que los teléfonos IP
– Sincronización horaria con PCF8563
– Componente de pantalla OLED

Listas de componentes de hardware:
1. Microduino-Core +
2. Microduino-FT232R
3. 【Microduino-ENC28J60】 + 【Microduino-RJ45】
4. Microduino-OLED
5. Microduino-RTC

Consulte los detalles técnicos en http://wiki.Microduino.cc

Paso 1: Microduino-RTC

Microduino-RTCMicroduino-RTC

Microduino-RTC es un módulo RTC de la serie Microduino.
– el chip principal es PCF8563
– utilizar la interfaz I2C
– EEPROM AT24C32 a bordo
– archivos de código abierto [check]

Utilice los siguientes códigos para conducir y probar el módulo Microduino-RTC.
biblioteca necesaria [download]

#include
#include

// iniciar el reloj de tiempo real
Rtc_Pcf8563 rtc;

configuración vacía ()
{
Serial.begin (9600);
// limpiar los registros
rtc.initClock ();
// establece una hora para empezar.
// día, día de la semana, mes, siglo (1 = 1900, 0 = 2000), año (0-99)
rtc.setDate (29, 4, 8, 0, 13);
// horas, minutos, segundos
rtc.setTime (00, 21, 0);
}

bucle vacío ()
{
// ambas funciones de formato llaman al getTime () interno para que el
// las cadenas formateadas están en la fecha / hora actual.
Serial.println (“CÓDIGO_1:”);
Serial.print (rtc.formatTime ());
Serial.print (“”);
Serial.print (rtc.formatDate ());
Serial.print (” r n”);

Serial.println (“CÓDIGO_2:”);
Serial.print (“20”);
Serial.print (rtc.getYear ());
Serial.print (“https://www.instructables.com/”);
Serial.print (rtc.getMonth ());
Serial.print (“https://www.instructables.com/”);
Serial.print (rtc.getDay ());
Serial.print (“”);
Serial.print (rtc.getHour ());
Serial.print (“:”);
Serial.print (rtc.getMinute ());
Serial.print (“:”);
Serial.print (rtc.getSecond ());
Serial.print (” r n”);

retraso (1000);
Serial.print (” r n”);
}

}

—–
Microduino es hardware de código abierto, compatible con Arduino System, el ecosistema más popular donde los diseñadores pueden obtener todo para construir sus propias aplicaciones. Todos los códigos de código abierto se pueden descargar desde http://wiki.Microduino.cc

Actualmente, la serie Microduino ya tenía 3 módulos centrales y alrededor de 20 placas de extensión desarrolladas, todos los módulos están diseñados y probados dentro de la comunidad Microduino, y alrededor de 700 fanáticos de Microduino contribuyen al esfuerzo para desarrollar aún más la serie Microduino.

Paso 2: Lista de piezas de hardware

Lista de piezas de hardwareLista de piezas de hardwareLista de piezas de hardwareLista de piezas de hardwareLista de piezas de hardwareLista de piezas de hardware

Paso 3: parte del software

Parte del software

Parte del software:
cargue el programa en su Microdino-Core + a través de Microduino-FT232R.

———————————-

#include “U8glib.h”

U8GLIB_SSD1306_128X64 u8g (U8G_I2C_OPT_NONE); // HW SPI Com: CS = 10, A0 = 9 (los pines de hardware son SCK = 13 y MOSI = 11)
// ——- ajuste de tamaño de fuente, grande | mediano | pequeño
#define setFont_L u8g.setFont (u8g_font_7x13)
#define setFont_M u8g.setFont (u8g_font_fixed_v0r)
#define setFont_S u8g.setFont (u8g_font_chikitar)
/ *
fuente:
u8g.setFont (u8g_font_7x13)
u8g.setFont (u8g_font_fixed_v0r);
u8g.setFont (u8g_font_chikitar);
u8g.setFont (u8g_font_osb21);
* /

#include
#include

Rtc_Pcf8563 rtc;
int time_nian, time_yue, time_ri, time_shi, time_fen, time_miao, time_zhou;

#include

#define SECONDS_IN_DAY 86400
#define START_YEAR 1900
#define TIME_ZONE +8
static int days_in_month[] = {
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

mymac byte estático[] = {
0x00,0x1A, 0x4B, 0x38,0x0C, 0x5C};
byte Ethernet :: búfer[700];

ntpServer byte estático[] = {
193,204,114,232};
byte estático srcPort = 0;

uint32_t timeStamp;

boolean NET_TIME_reply;

#define NET_TIME_INTERVAL 1000
#define TIME_OUT 10000
#definir INTERVALO 100000
unsigned long lastTime = 0, TIME_cache = 0;

configuración vacía () {
Serial.begin (57600);

volcdsetup (“Cargar RED”, 0,15);
retraso (1000);
si (! ether.begin (tamaño de Ethernet :: búfer, mymac))
Serial.println (“No se pudo acceder al controlador Ethernet”);
demás
Serial.println (“controlador Ethernet inicializado”);
si (! ether.dhcpSetup ())
{
Serial.println (“No se pudo obtener la configuración de DHCP”);
volcdsetup (“Error DHCP”, 0,15);
retraso (1000);
}
demás
{
Serial.println (“Configuración DHCP completada”);
volcdsetup (“DHCP correcto”, 0,15);
retraso (1000);
}
ether.printIp (“Dirección IP: t”, ether.myip);
ether.printIp (“Máscara de red: t”, ether.mymask);
ether.printIp (“Puerta de enlace: t”, ether.gwip);

// ———————————————— ——-
volcdsetup (“Tiempo neto de carga”, 0,15);
retraso (1000);
NET_TIME_reply = verdadero;
vonettime ();
si (NET_TIME_reply)
{
volcdsetup (“Error de sincronización de tiempo”, 0,15);
retraso (1000);
}
demás
{
vosettime ();
volcdsetup (“Time Sync. Succeed”, 0,15);
retraso (1000);
}

// ———————————————— ——-
Serial.println ();
}

bucle vacío () {
if (millis () – lastTime> INTERVAL)
{
NET_TIME_reply = verdadero;
vonettime ();
si (! NET_TIME_reply)
{
vosettime ();
}
lastTime = millis ();
}

volcd ();

}

void volcd ()
{
u8g.firstPage ();
hacer {
setFont_M;
u8g.setPrintPos (0, 9);
u8g.print (“HORA:”);
u8g.print (rtc.formatDate ());

u8g.setPrintPos (0, 20);
u8g.print (rtc.formatTime ());

// —————————————–
u8g.setPrintPos (0, 34);
u8g.print (“HORA:”);
u8g.print (“20”);
u8g.print (rtc.getYear ());
u8g.print (“https://www.instructables.com/”);
u8g.print (rtc.getMonth ());
u8g.print (“https://www.instructables.com/”);
u8g.print (rtc.getDay ());

u8g.setPrintPos (0, 45);
u8g.print (rtc.getHour ());
u8g.print (“:”);
u8g.print (rtc.getMinute ());
u8g.print (“:”);
u8g.print (rtc.getSecond ());

String WEEK = “”;
cambiar (rtc.getWeekday ())
{
caso 1:
WEEK = “Lunes”;
rotura;
caso 2:
WEEK = “Martes”;
rotura;
caso 3:
WEEK = “Miércoles”;
rotura;
caso 4:
WEEK = “jueves”;
rotura;
caso 5:
WEEK = “Viernes”;
rotura;
caso 6:
WEEK = “Sábado”;
rotura;
caso 7:
WEEK = “Domingo”;
rotura;
}
u8g.setPrintPos (60, 45);
u8g.print (SEMANA);

setFont_S;
u8g.drawFrame (0, 54,128,10);
u8g.setPrintPos (3, 62);
u8g.print (“Microduino-RTC v1.0 201307”);
}
while (u8g.nextPage ());
}

void vosettime ()
{
rtc.initClock (); // establece una hora para empezar.
rtc.setDate (time_ri, time_zhou, time_yue, 0, time_nian% 100); // día, día de la semana, mes, siglo (1 = 1900, 0 = 2000), año (0-99)
rtc.setTime (time_shi, time_fen, time_miao); // horas, minutos, segundos

}

void volcdsetup (char * zi, unsigned int x, unsigned int y)
{
u8g.firstPage ();
hacer {
setFont_L;
u8g.setPrintPos (x, y);
u8g.print (zi);
}
while (u8g.nextPage ());
}

void vonettime ()
{
uint32_t tiempo de espera = millis (); //
while (NET_TIME_reply == true && millis () – tiempo de espera {
ether.packetLoop (ether.packetReceive ());
if (millis () – TIME_cache> NET_TIME_INTERVAL) //
{
ether.ntpRequest (ntpServer, srcPort);
TIME_cache = millis ();
NET_TIME_reply = verdadero; // 标记 发送
}

if (NET_TIME_reply && ether.ntpProcessAnswer (& timeStamp, srcPort)) //
{
printDate (marca de tiempo + 3600 * TIME_ZONE); //
TIME_cache = millis ();
NET_TIME_reply = falso; //
}
}
}

void printDate (uint32_t timeStamp) {

semana larga sin firmar = (((timeStamp / 3600/24) +1)% 7);

Serial.print (“Fecha y hora actuales:”);
Serial.println (marca de tiempo);

unsigned int year = START_YEAR;
while (1) {
uint32_t segundos;
if (isLeapYear (año)) segundos = SECONDS_IN_DAY * 366;
más segundos = SEGUNDOS_DÍA_DÍA * 365;
if (timeStamp> = segundos) {
timeStamp – = segundos;
año ++;
}
más romper;
}

mes int sin firmar = 0;
while (1) {
uint32_t segundos = SECONDS_IN_DAY * días_in_month[month];
if (isLeapYear (año) && month == 1) seconds = SECONDS_IN_DAY * 29;
if (timeStamp> = segundos) {
timeStamp – = segundos;
mes ++;
}
más romper;
}
mes ++;

unsigned int day = 1;
while (1) {
if (timeStamp> = SECONDS_IN_DAY) {
timeStamp – = SECONDS_IN_DAY;
día ++;
}
más romper;
}

hora int sin firmar = timeStamp / 3600;
unsigned int minuto = (marca de tiempo – (uint32_t) hora * 3600) / 60;
unsigned int second = (timeStamp – (uint32_t) hora * 3600) – minuto * 60;

Serial.print (“semana:”);
Serial.println (semana);

if (día <10) Serial.print ("0");
Serial.print (día);
Serial.print (“https://www.instructables.com/”);

if (mes <10) Serial.print ("0");
Serial.print (mes);
Serial.print (“https://www.instructables.com/”);

Serial.println (año);

if (hora <10) Serial.print ("0");
Serial.print (hora);
Serial.print (“:”);

if (minuto <10) Serial.print ("0");
Serial.print (minuto);
Serial.print (“:”);

if (segundo <10) Serial.print ("0");
Serial.println (segundo);

Serial.println ();

time_nian = año;
time_yue = mes;
time_ri = día;
time_shi = hora;
time_fen = minuto;
time_miao = segundo;
time_zhou = semana;
}

boolean isLeapYear (unsigned int year) {

return (año% 4 == 0 && (año% 100! = 0 || año% 400 == 0));
}
—————————

Sé el primero en compartir

    3 comentarios

    0
    bingdo72
    bingdo72

    Hace 6 años en Introducción

    Esto es bueno.

    0
    JDM-Idaho
    JDM-Idaho

    Hace 7 años en Introducción

    Este es un proyecto muy interesante: no puedo encontrar ninguno que venda el hardware. Si aún no está en el mercado, ¿por qué es un proyecto instructable?

    0
    makermodule
    makermodule

    Responder hace 7 años el Introducción

    ¡Hurra! Su proyecto, Microduino: Arduino en su bolsillo: ¡pequeño, apilable, inteligente, ha sido aceptado!
    ¡Finalmente obtuve la aprobación de Kickstarter! ¡Lanzaremos Microduino a las 10 a.m., el 9 de septiembre (EST)! ¡Por favor espere!

    Verifique el estado de Microduino desde
    Facekbook: https://www.facebook.com/Microduino
    Gorjeo: http://www.twitter.com/Microduino
    Wiki: http://wiki.Microduino.cc

    close