ESP8266 y RFM69 HCW transceptor digital

RFM69-HCW-y-SPARKFUN-Breakout

Me he propuesto conectar el microcontrolador ESP8266 con el transceptor de datos digital RFM69 HCW.

RFM69-HCW-y-SPARKFUN-BreakoutEl RFM69 es un radio digital de bajo costo y muy buenas prestaciones que opera en diversas frecuencias (los mios funcionan en los 915mhz) y cuenta con una extensa documentación y librerías para los proyectos Arduino en Internet.

El RFM69 admite encriptación de los paquetes de datos por hardware, lo que es para muchos -como yo- algo muy atractivo y necesario.

Además cada radio tiene una identificación única, pudiendo coexistir hasta 255 radios en una misma red, y hasta 255 redes en un mismo espacio. Todo esto gestionado por el hardware del RFM69 y sus librerías.

El RFM69 se conecta a tu Arduino vía el interfaz SPI. Además le debes soldar una antena -cualquier cable, observando el largo correcto para la frecuencia de radio que adquieres, funcionará.

En mi caso utilicé un cable de 78mm soldado al terminal «A» de Antenna.

En la red encontrarás suficiente documentación para integrar estos radios a los módulos «oficiales» de Arduino.  Sin embargo, no es tan fácil encontrar información con respecto a los ESP8266.

De ahí mi interés de aprovechar y contarles la historia, por si necesitan hacer lo mismo.

Continuar leyendo «ESP8266 y RFM69 HCW transceptor digital»

Bus i2c Scanner

Este pequeño programa para Arduino buscará entre las direcciones del bus i2c en busca de componentes conectados que respondan, oficiando asi de escáner de bus i2c.

Scanner de bus i2cMe ha ocurrido ya un par de veces que al adquirir un componente que se conecta al bus de datos i2c,  la dirección explicitada en la documentación no es correcta.

Pues bien, la solución es cargar momentáneamente este pequeño programa y descubrir asi donde se esconde el componente en cuestión.

Indudablemente un ahorro de tiempo importante, a mi me ha resultado útil y por eso quería compartirlo con ustedes para que lo tengan presente:

Código del Scanner de bus i2c

Simple en su funcionamiento, no necesita mayor detalle este pequeño scanner de i2c:

#include <Wire.h>
 
void setup()
{
  Wire.begin();
  Serial.begin(115200);
  while (!Serial);             // Esperamos a que el serial se active
  Serial.println("\nI2C Scanner");
}
 
void loop()
{
  byte error, address;
  int nDevices;
  Serial.println("Escaneando...");
  nDevices = 0;
  for(address = 1; address < 127; address++ )
  {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0)
    {
      Serial.print("Componente I2C encontrado en 0x");
      if (address<16)
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");
 
      nDevices++;
    }
    else if (error==4)
    {
      Serial.print("Error en 0x");
      if (address<16)
        Serial.print("0");
      Serial.println(address,HEX);
    }    
  }
  if (nDevices == 0)
    Serial.println("No encontré nada en I2C\n");
  else
    Serial.println("TERMINADO\n");
 delay(5000);        
}

Al ejecutarlo, el programa les listará las direcciones donde encontró componentes i2c.

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.