Reloj DS3231 de alta precisión y eficiencia

Reloj-DS3231-i2c

El reloj DS3231 es un integrado bastante versátil capaz de llevar cuenta del tiempo y fecha con una precisión de +/- 2 minutos por año.

Reloj-DS3231-i2c-bateria-arduinoPuedes conseguirlo por un costo de 5 a 10 USD en la tienda de Amazon.

El integrado DS3231 es presentado usualmente en un pequeño circuito que incluye, entre otros componentes, una pila de litio CR2032 (en la parte de abajo del circuito, por eso no se ve en la foto) que le brinda autonomía de hasta unos 5 años, aún sin otra fuente de alimentación.

El DS3231 cuenta con un interfaz i2c desde el cual podremos ajustar y consultar su información.

Puede ser alimentado tanto con 3.3v como 5v lo que da buena comodidad en nuestros proyectos Arduino independientemente de que controladora y voltajes utilicemos.

Manipulando el DS3231 desde Arduino

Hay numerosas librerías disponibles para controlar al DS3231 en nuestros proyectos Arduino.

En mi caso, me destilé por la librería SODAQ DS3231 que está disponible para su integración desde el propio gestor de librerías del IDE oficial de Arduino.

NOTA: La librería SODAQ no compila (al menos la versión que tengo en este momento) correctamente para el ESP8266. Tuve que buscar el archivo Sodaq_DS3231.cpp y al principio donde se hace el #include avr\pgmspace.h cambiarlo por:

#if (defined(__AVR__))
#include <avr\pgmspace.h>
#else
#include <pgmspace.h>
#endif

Para mi actual proyecto, conecté el reloj DS3231 a una controladora ESP8266 para así obtener buena precisión horaria en  el registro histórico de datos.

Cómo vuelta de tuerca, hago que el ESP8266 consulte via Internet con un servidor de NTP al ser encendido y así ajuste el reloj del DS3231.

Ajustando el reloj DS3231 con un servidor NTP via Internet

Antes de presentar el código que utilizo para ajustar el DS3231 via Internet con un servidor NTP, necesito explicar algunas cosas que verán allí:

Primero, el objeto ssd es simplemente una pantalla OLED que tengo conectada -también vía i2c a mi ESP8266.

Segundo, la función que presento aquí abajo es llamada dentro de mi código general luego de confirmar que el ESP8266 se ha conectado a mi red WIFI.  No estoy poniendo toda esa parte del software porque serían cientos de líneas de código que no considero “centrales” al tema de este artículo.

Por último, hay una serie de variables y objetos que se inicializan para que puedan ser consumidos por esta función, que voy a intentar detallar aquí debajo e iría en los inicios de tu proyecto de software para Arduino:

/* ==== Includes ==== */
#include <WiFiUdp.h> //Se necesita para consultar el NTP y ajustar el reloj
#include <Sodaq_DS3231.h> //Librería para el DS3231

/*==== Objetos-libs ====*/
Sodaq_DS3231 clock;  //RTC DS3231
WiFiUDP udp;	//Instancia UDP para enviar y recibir paquetes al Servidor NTP

/* Variables para el RTC y acceso NTP */
unsigned int localPort = 2390;      //puerto local para recibir paquete UDP desde el NTP server
IPAddress timeServerIP; // donde voy a guardar la IP del servidor NTP
const char* ntpServerName = "0.pool.ntp.org"; //el servidor NTP
const int NTP_PACKET_SIZE = 48; // tamaño del paquete NTP que nos interesa
byte packetBuffer[NTP_PACKET_SIZE]; //buffer para paquetes entrantes y salientes al NTP
const double timezone = -3.0;

/* ==== Setup ==== */
void setup() {
        //aquí va todo el código de tu Setup, y al final, activas el reloj:
	clock.begin();
}

Esta es la función que hace la magia de consultar al servidor NTP y así ajustar el DS3231 con los datos precisos del tiempo y fecha:

//Actualizar reloj RTC con datos del NTP
void actualizareloj()
{
	ssd.clearDisplay();
	ssd.setCursor(0, 0);
	ssd.println("Actualizando RTC");
	ssd.println(ntpServerName);
	ssd.display();
	if (udp.begin(localPort) == 0) //activo puerto udp 2390 para los paquetes del servidor NTP
	{
		ssd.print("\nERROR PUERTO UDP");
	}
	else {
		while (udp.parsePacket() > 0); // discard any previously received packets
		WiFi.hostByName(ntpServerName, timeServerIP); //Busco IP del servidor NTP
		if (timeServerIP[0] == 0)
		{
			ssd.println("\nERROR NO IP");
		}
		else
		{
			ssd.println("IP " + (String)timeServerIP[0] + '.' + (String)timeServerIP[1] + '.' + (String)timeServerIP[2] + '.' + (String)timeServerIP[3]);
			ssd.display();
			yield();
			// Envio paquete NTP para pedir hora
			memset(packetBuffer, 0, NTP_PACKET_SIZE);
			packetBuffer[0] = 0b11100011;   // LI, Version, Mode
			packetBuffer[1] = 0;     // Stratum, or type of clock
			packetBuffer[2] = 6;     // Polling Interval
			packetBuffer[3] = 0xEC;  // Peer Clock Precision
									 // 8 bytes of zero for Root Delay & Root Dispersion
			packetBuffer[12] = 49;
			packetBuffer[13] = 0x4E;
			packetBuffer[14] = 49;
			packetBuffer[15] = 52;
			udp.beginPacket(timeServerIP, 123); //NTP requests are to port 123
			udp.write(packetBuffer, NTP_PACKET_SIZE);
			udp.endPacket();
			yield();
			//Ahora a esperar la respuesta del servidor NTP:
			int cb = 0;
			unsigned long mi = millis();
			while (millis() - mi < 4000 && !cb)
			{
				cb = udp.parsePacket();
				yield();
			}
			if (cb != 0)
			{
				//Vino paquete con hora
				udp.read(packetBuffer, NTP_PACKET_SIZE); // Levantamos paquete al buffer
				unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
				unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
				// combine the four bytes (two words) into a long integer
				// this is NTP time (seconds since Jan 1 1900):
				unsigned long secsSince1900 = highWord << 16 | lowWord;
				// now convert NTP time into everyday time:
				// Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
				const unsigned long seventyYears = 2208988800UL;
				// subtract seventy years:
				unsigned long epoch = secsSince1900 - seventyYears;
				// adjust to user timezone
				epoch += timezone * 3600;
				ssd.println("\nOK");
				clock.setEpoch(epoch);
			}
			else {
				ssd.print("\nERROR NO RESPONDE");
			}
		}
		udp.stopAll();
	}
	ssd.display();
	delay(3000);
}

Como siempre, por favor espero dudas y comentarios acerca de este código para gestionar el DS3231, o simplemente para que cuenten en que andan con Arduino.

Enviar email con un Ethernet Shield W5100

Ethernet Shield W5100

El Ethernet Shield W5100 es compatible con los pines del Arduino UNO, Arduino Mega y algunos otros, siempre y cuando el módulo Arduino incluya el conector ICSP de 6 pines.

Ethernet Shield W5100El Ethernet Shield W5100 es accesible por el entorno de los 10 USD en todas las tiendas electrónicas:  Por ejemplo puedes encontrar infinidad de marcas y presentaciones del W5100 en amazon.com.

Como soy un tanto más rebuscado, para este pequeño proyecto Arduino voy a conectar el Ethernet Shield W5100 a un módulo WEMOS D1 R2 (basado en el ESP8266) compatible con la programación Arduino, que justamente carece del conector ICSP.

El conector ICSP expone en forma estandarizada la conectividad SPI entre el módulo Arduino y sus periféricos. Pero si el módulo compatible con Arduino que quieres utilizar carece de conector ICSP, entonces será simplemente cuestión de recablear correctamente tu proyecto para acceder al bus SPI.

Conectando el Ethernet Shield W5100 al Wemos D1 R2

El Ethernet Shield W5100 puede ser fácilmente conectado al módulo Wemos D1 R2 con 8 cables, de acuerdo a este pinout:

WEMOS   W5100
GND --- GND (pin 1 ICSP)
5V  --- 5V  (pin 3 ICSP)
3v3 --- 3v3
RST --- RST (pin 4 ICSP, abajo del GND)
SS  --- SS (pin 10)
MOSI--- MOSI (pin 2 ICSP, entre 5V y GND)
MISO--- MISO (pin 6 ICSP, abajo 5V)
CLK --- CLK (pin 5 ICSP, entre MISO y RST)

Queda claro entonces que en vez de montar el Ethernet W5100 sobre el WEMOS D1 R2, los ponemos uno al lado del otro y realizamos ese cableado.

Si estás utilizando un Arduino Mega, u otro, con conector ICSP, simplemente colocas el Shield Ethernet W5100 como lo harías normalmente con cualquier Shield.

En ese caso toma precaución que ninguna parte de metal (o soldaduras) del Ethernet Shield toquen alguna parte del circuito del módulo Arduino:

En mi caso, durante otro proyecto, cuando monté el Ethernet Shield al Arduino MEGA, el conector de ETHERNET facilmente podía hacer cortocircuito con una parte del MEGA, por lo que tuve que separarlos unos milímetros (igual hacían contacto para funcionar correctamente).

Enviar un correo con el Ethernet Shield W5100

Es posible enviar un correo con el Ethernet Shield W5100 y aquí debajo te dejo el código que yo utilicé con suceso.

#include <SPI.h>
#include <Ethernet.h>     //Ethernet Shield

EthernetClient client;

//Shield requiere un MACADDRESS UNICO
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 

//Configura una IP, gateway y subnet para tu red local:
IPAddress ip(192, 168, 2, 19);  
IPAddress gateway(192, 168, 2, 1);
IPAddress subnet(255, 255, 255, 0);

//Reemplaza las xxx con la IP de tu servidor de correo
IPAddress servidormail(xxx, xxx, xxx, xxx);

void setup()
{
	Serial.begin(9600);
	delay(1000);
	Serial.println("INICIO SISTEMA");
	Ethernet.begin(mac, ip, gateway, gateway, subnet);
	delay(2000);
	Serial.println("Ethernet Inicializado");

        //Cambia las cuentas de correo de remitente y destino por las que quieras probar tu!
	byte resultado = mandaremail(servidormail, "Hola desde ARDUINO", "Rutina de correo funciona", "remitente@correo.com", "destino@correo.com");
	Serial.println("RESULTADO DE ENVIAR EMAIL: " + (String)resultado);
}

void loop()
{
	/* add main program code here */
}


byte mandaremail(IPAddress smtp, String titulo, String mensaje, String de, String para)
{
	byte thisByte = 0;
	byte respCode;
	Serial.println("Mandar correo iniciado");
	if (client.connect(smtp, 25)) //Me conecto o devuelvo error
	{
		Serial.println(F("connectado"));
	}
	else {
		Serial.println(F("No pudo conectarse"));
		return 0;
	}

	if (!eRcv()) return 1;

	// coloca una ip pública tuya
	client.println(F("helo 1.2.3.4"));
	if (!eRcv()) return 2;
	client.println("MAIL From: <" + de + ">");
	if (!eRcv()) return 3;
	client.println("RCPT To: " + para);
	if (!eRcv()) return 4;
	client.println(F("DATA"));
	if (!eRcv()) return 5;
	client.println("To: You <" + para + ">");
	// change to your address
	client.println("From: cuenta <" + de + ">");
	client.println("Subject: " + titulo + "\r\n");
	client.println(mensaje);
	client.println(F("."));
	if (!eRcv()) return 6;
	client.println(F("QUIT"));
	if (!eRcv()) return 7;
	client.stop();
	return 255; // Email enviado
}

byte eRcv()
{
	byte respCode;
	byte thisByte;
	int loopCount = 0;
	while (!client.available()) {
		delay(1);
		loopCount++;
		// Si no recibo nada en 10 segs, doy timeout
		if (loopCount > 10000) {
			client.stop();
			Serial.println(F("\r\nTimeout"));
			return 0;
		}
	}
	respCode = client.peek();
	while (client.available())
	{
		thisByte = client.read();
		Serial.write(thisByte);
	}
	if (respCode >= '4')
	{
		efail();
		return 0;
	}
	return 1;
}

void efail()
{
	byte thisByte = 0;
	int loopCount = 0;

	client.println(F("QUIT"));

	while (!client.available()) {
		delay(1);
		loopCount++;

		// Si no recibo nada en 10 segs, doy timeout
		if (loopCount > 10000) {
			client.stop();
			Serial.println(F("\r\nTimeout"));
			return;
		}
	}

	while (client.available())
	{
		thisByte = client.read();
		Serial.write(thisByte);
	}
	client.stop();
	Serial.println(F("desconectado"));
}

Este código ejecuta su magia durante el setup {} y  es un ejemplo, nada más, de una funcionalidad básica para enviar correos desde tu Arduino.

Igualmente considera que necesitarás un servidor de correos (protocolo SMTP, sin encriptar) convencional, que confíe en la IP desde donde le conversará tu Arduino.