Un ESP01 que es el más pequeño de los diferentes módulos ESP8266, requiere añadir algunos componentes para conectarse y programar u operar el módulo.
Esquemático con ESP01
Al módulo se añade: una fuente de alimentación a 3.3V, un módulo de conexión USB-TTL para conectar a una computadora y unas botoneras para controlar el modo de operación y reinicio reset).
La alimentación del circuito presentada en el esquema, sigue las indicaciones de la sección: Fuente de alimentación 3.3VDC.
El control de modo de "operación/Programación" y "reset" se implementa con botoneras.
El modo predeterminado de inicio es "operación" por medio de GPIO0 a estado HIGH (+VCC ) con una resistencia (pullup), al presionar la botonera se cambia el estado a LOW (GND).
Para programar se presiona la botonera "programar" y luego se añade un pulso a "reset", el módulo queda listo para "subir" instrucciones desde IDE Arduino.
En la versión ESP-01 el LED interno se encuentra conectado al pin de TX usado para la comunicación Serial. Usar mensajes por puerto serial causaría un conflicto en el modo de operación con el parpadeo de led, asunto a tomar encuentra en las instrucciones.
Una forma de implementación funcional, es no usar los mensajes por puerto serial. Otra forma es cambiar el LED a otro pin y configurarlo como salida, ej: GPIO2. El nuevo pin permite conectar Tx y Rx y observar los mensajes del proceso de conexión. Adicionalmente GPIO2 es el led interno de otros modelos de ESP8266.
En caso de usar los componentes junto a un protoboard se muestra también el diagrama de conexión como referencia
la programación del módulo se realiza en la siguiente sección.
En el mercado se encuentran la versión como módulo HM-10 presentado como módulo Bluetooth LE en varios formatos genéricos o como módulo para "arduino".
Los módulos HM-10 permiten usar comunicación serial usando instrucciones AT, tanto para configuración como para mensajería de datos.
Para conectase con el módulo desde el computador se puede usar un arduino como intermediario, pudiendo así configurar el dispositivo. Posteriormente, usando un esquema semejante se puede ampliar para enviar/recibir un mensaje a un dispositivo, por ejemplo una tablet o un móvil.
La comunicación hacia el HM-10 se realiza con un computador y un Arduino, aprovechando la conexión serial del módulo y enviando instrucciones AT.
El módulo tiene dos pines para alimentación Vcc y GND y los dos pines de comunicación Tx y Rx.
La conexión con el Arduino requiere el acondicionamiento de la señal de transmisión Tx desde el Arduino a 5V hacia el módulo HM-10 a 3.3V mediante un divisor de voltaje. El divisor de voltaje se implementa con las resistencias R1 de 1KΩ y R2 de 2.2KΩ.
Configuración Serial - Arduino
La configuración serial se puede realizar mientras el módulo no se encuentre conectado o "emparejado" a otro dispositivo.
El led del módulo parpadea en esta modalidad, indicando que no está emparejado y contesta instrucciones de configuración.
La terminal o "monitor de Arduino" se debe configurar a ala misma velocidad que lo indicado en la sección script de Arduino, y se usa envío de NL y CR (nueva linea y enter)
Ejemplos de instrucciones enviadas desde "monitor de Arduino"
AT+VERSION
+VERSION=Firmware V4.2.0,Bluetooth V4.0 LE
AT+NAME
+NAME=BT05
AT+ROLE
+ROLE=0
AT+HELP
********************************************************************
* Command Description *
* ---------------------------------------------------------------- *
* AT Check if the command terminal work normally *
* AT+RESET Software reboot *
* AT+VERSION Get firmware, bluetooth, HCI and LMP version *
* AT+HELP List all the commands *
* AT+NAME Get/Set local device name *
* AT+PIN Get/Set pin code for pairing *
* AT+PASS Get/Set pin code for pairing *
* AT+BAUD Get/Set baud rate *
* AT+LADDR Get local bluetooth address *
* AT+ADDR Get local bluetooth address *
* AT+DEFAULT Restore factory default *
* AT+RENEW Restore factory default *
* AT+STATE Get current state *
* AT+PWRM Get/Set power on mode(low power) *
* AT+POWE Get/Set RF transmit power *
* AT+SLEEP Sleep mode *
* AT+ROLE Get/Set current role. *
* AT+PARI Get/Set UART parity bit. *
* AT+STOP Get/Set UART stop bit. *
* AT+START System start working. *
* AT+IMME System wait for command when power on. *
* AT+IBEA Switch iBeacon mode. *
* AT+IBE0 Set iBeacon UUID 0. *
* AT+IBE1 Set iBeacon UUID 1. *
* AT+IBE2 Set iBeacon UUID 2. *
* AT+IBE3 Set iBeacon UUID 3. *
* AT+MARJ Set iBeacon MARJ . *
* AT+MINO Set iBeacon MINO . *
* AT+MEA Set iBeacon MEA . *
* AT+NOTI Notify connection event . *
* AT+UUID Get/Set system SERVER_UUID . *
* AT+CHAR Get/Set system CHAR_UUID . *
* -----------------------------------------------------------------*
* Note: (M) = The command support slave mode only. *
* For more information, please visit http://www.cyobd.com *
* Copyright@2013 www.cyobd.com. All rights reserved. *
********************************************************************
Algunas instrucciones pueden variar en otros módulos con diferente firmware. Lo presentado es solo un ejemplo de lo que se puede hacer en éste módulo de www.cyobd.com
Instrucciones Arduino
/* Comunicación Serial por BluetoothBasada en: https://www.arduino.cc/en/Tutorial/SoftwareSerialExample*/#include<SoftwareSerial.h>intRx=10;//conexión al módulointTx=11;SoftwareSerialmoduloBtLE(Rx,Tx);voidsetup(){intbaudiosArduino=9600;// Serial USBSerial.begin(baudiosArduino);while(!Serial){}// espera conexiónSerial.println("\n USB <->PC, Listo..!!");//Puerto Serial Módulo BluetoothintbaudiosBtLE=9600;moduloBtLE.begin(baudiosBtLE);moduloBtLE.println("Listo Bluetooth a Tablet/móvil");delay(1000);moduloBtLE.write("AT+VERSION");delay(1000);}voidloop(){// recibe mensaje Bluetooth y envia por USB a PCif(moduloBtLE.available()){Serial.write(moduloBtLE.read());}// envia mensaje Serial-USB a Bluetoothif(Serial.available()){moduloBtLE.write(Serial.read());}}
Conexión a tablet/móvil
Se realizó la prueba en una tablet con Arduino, descargando el programa "Serial Bluetooth terminal" desde la tienda Play Store de Google.
El siguiente paso en la tablet es usando la aplicación, realizar una búsqueda de dispositivos, menú/dispositivos/scan, y así encontrar el que tiene el nombre de la sección anterior donde se pide AT+NAME, en este caso: "BT05".
una vez que se han conectado al módulo desde la tablet/móvil se pueden intercambier mensajes con la PC.
Son de largo alcance a 915MHz y con pines compatible con 3-5v.
La comunicación con el módulo y un microcontrolador se realiza mediante protocolo SPI.
En éste modo se facilita la conexión directa con módulos Arduino a 5V, al traer convertidor de señal de 3.3 a 5V bidireccional.
Una recomendación es conectarlos y encenderlos siempre con la antena conectada.
La configuración de pines se muestra en la figura.
Módulos de desarrollo LoRa
También se puede usar los módulos Lora emparejados con ESP32 como microcontrolador. Aportan conexión a WIFI y viene en varias configuraciones, lo más relevante es que traen antenas de 915MHz
El módulo de desarrollo facilita realizar pruebas con tan solo unos cuantos elementos, tiene conexión USB para programación o acceso de datos y una pequeña pantalla para visualizar mensajes de estado.
otro modelo del mismo fabricante es el Wireless-Stick-Lite que es muy semejante al anterior, pero no incorpora la pantalla OLED.
Los módulos para gateway permiten operar simultáneamente con varios canales, requieren añadir un controlador implementado con un Raspberry Pi. Se pueden usar para conectarse a un gestor de gateways, por ejemplo TTN o uno implementado de forma privada con elementos abiertos como ChirpStack.
Para subir las instrucciones (programar) el ESP8266 desde la computadora usando un puerto USB, es necesario disponer de un módulo USB-TTL. La conexión también es util para obtener los datos desde el "monitor serial" del IDE Arduino.
Para comunicarse con el ESP8266 se requiere conectar los cables de:
transmisión TX
recepción RX
Tierra GND
El módulo USB-TTL de preferencia debe tener entre los pines de conexión, uno de 3.3v semejante al mostrado en la imagen. El pin 3V3 es usado en caso de necesitar alimentar el módulo ESP8266. Sin embargo, en los dispositivos usados se encontró que la corriente proporcionada no es suficiente para el funcionamiento del dispositivo.
Revisar las opciones de carga de programa en la sección de "IDE Arduino con ESP8266"
La alimentación de energía de los dispositivos con ESP8266 es a 3.3V.
Para la mayor parte de los diseños se realiza desde la alimentación de energía con 110V AC, por lo que es necesario usar un regulador de voltaje para llegar hasta a 3.3V DC que es el voltaje de operación del ESP8266.
2. Componente HLK-PM03
HLK-PM03
Idealmente se puede usar un regulador HLK-PM03, que simplifica la fuente de alimentación.
Sin embargo inicialmente para el desarrollo no se encontró en el mercado local y se analiza algunas opciones si se encuentra en un caso semejante.
3. Alternativas a componente HLK-PM03
Por facilidad y disponibilidad, la fuente de alimentación se realiza dos pasos:
Reducción de 110V AC a 5V DC
Reducción de 5V DC a 3.3V DC
3.1 Reducción de 110VAC a 5VDC
El primer paso, 110V AC a 5V DC, se puede implementar con el circuito de un cargador de celular con salida USB.
En los módulos desarrollados, en algunos casos se ha usado solo la placa de circuito del cargador para optimizar espacio en la caja del dispositivo.
3.2 Reducción de 5VDC a 3.3VDC
Para el segundo paso es necesario un regulador de 5VDC a 3.3VDC como por ejemplo el LM1117-3.3V en formato componente o como módulo.
componente
módulo
Lo que disponga para el desarrollo del circuito no afecta al funcionamiento, solo el espacio usado en el protoboard o el destinado para la placa de circuito (PCB).
La opción de usar el módulo de 5VDC a 3.3VDC es la que más se ha usado en los diseños.
Sin embargo al principio no se tenía un módulo y se optó para el primer prototipo por curiosidad la alternativa de usar diodos para disminuir el voltaje hasta lo requerido. Los diodos en sentido directo tienen caídas de voltaje de 0.7 V, por lo que se usaron dos diodos en serie en sentido directo, se recomienda verificar el voltaje en operación empezando con 3 diodos.
Otra opciones para 5V a 3.3V, usar un circuito con diodos zener.
3.3 Fuente para protoboard
Si la implementación la realiza solo en protoboard, puede un modulo regulador semejante al mostrado, que permite seleccionar si la salida al protoboard es de 5VDC o 3.3VDC cambiando los jumpers.
La alimentación del módulo se puede realizar con una fuente igual ao mayor a 5VDC.
Se puede realizar una comunicación Serial por medio de Bluetooth con la libreria básica de ESP32 para arduino.
En un ejercicio básico par controlar los estados de un LED es enviar un mensaje de '1' para encender el Led incorporado del módulo y un mensaje de '0' para apagar el Led.
Por un lado se usa un módulo ESP32, y por el otro un móvil/tablet con una aplicación básica de terminal serial, para tener resultados semejantes al mostrado.
Para la configuración inicial de los dispositivos requiere una aplicación en un dispositivo tablet o móvil para configurar la conexión a la red WiFi con los datos de SSID y Password.
El concepto presentado por espressif con documentación actualizada al 2018.06.08 se encuentra en:
La implementación de la aplicación que se usó para probar el ejercicio se encuentra en Google Play. Revisar el desarro de la aplicación realizará como otro tema.
Modo configuración de WiFi, usando la aplición SmartConfig
Modo normal de conexión WiFi, con los datos WiFi ya configurados
Para seleccionar los modos se usa una botonera "Configuración" en un pin digital disponible con funcion y circuito semejante a RESET, en el ejemplo se usa GPIO14.
Modo configuración de WiFi
Para iniciar el modo configuración de la red se deben usar las botoneras "Configuración" y "RESET" con la secuencia:
1. pulsar Botonena GPIO14 y mantener pulsada
2. Luego pulsar y soltar reset
3. Mantener pulsado GPIO14 por 5 segundos después y soltar
4. Usar el móvil/tableta con la aplicación SmartConfig para configurar
5. Escribir SSID y password en móvil/tablet y "confirmar"
6. Esperar confirmación y estará conectado.
Modo normal de conexión WiFi
Es el modo predeterminado de operación, no requiere presionar el botón de "Configuración". Arranca con los valores almacenados de SSID y PASSWORD.
Monitor Serial
Los resultados del proceso de configuración y conexión a WiFi se muestran a continuación. Para fines de muestra, se ha demorado la activación con el móvil/tablet, note que la conexión a WiFI se realiza casi inmediatamente (tres puntos ...)
Las instrucciones se han dividido por bloques: configura_wifi() y conecta_wifi(). En ambas funciones se presentan mensajes y parpadeos de led.
Configura_wifi() espera a que se obtenga un valor afirmativo para WiFi.smartConfigDone() y finalizar.
Conecta_wifi() es muy semejante a la función inicia_wifi() usada en los primeros ejemplos que usaba variables para SSID y Password()
/* ESP32 Smart Config de Espressif
modificado a partir de:
https://www.espressif.com/en/products/software/esp-touch/overview
Usa el GPIO14 en estado LOW para entrar en modo configuración.
Usar BOTONERA "CONFIGURACION" en pin14, con pullup (HIGH)
Para configurar:
1. pulsar Botonena GPIO14 y mantener pulsada
2. Luego pulsar y soltar reset
3. Mantener pulsado GPIO14 por 5 segundos después y soltar
4. Usar el móvil/tableta con la aplicación SmartConfig para configurar
5. Escribir SSID y password en móvil/tablet y "confirmar"
6. Esperar confirmación y estará conectado.
*/
#include <WiFi.h>
// PIN configuración
const PROGMEM uint8_t CONFIG_pin = 14;
// LED monitor interno
//ESP01-pin=1, ESP07-pin=2; ESP32-pin=5
const PROGMEM uint8_t LED_pin = 5;
void setup() {
Serial.begin(115200);
// PIN configuración
pinMode(CONFIG_pin, INPUT);
// LED monitor
pinMode(LED_pin, OUTPUT);
// Revisa si entra a modo configuración
if (digitalRead(CONFIG_pin)==LOW){
Serial.println("configurando WiFi");
// configura con SmartConfig
configura_wifi();
}
// Modo conexión a Router
conecta_wifi();
}
void loop() {
// Ejemplo de tarea a realizar.
Serial.println("conectado a:");
Serial.print(WiFi.SSID());
Serial.print(" , ");
Serial.print(WiFi.localIP());
Serial.print(" , ");
Serial.println(WiFi.RSSI());
// LED interno enciende en LOW
digitalWrite(LED_pin, HIGH);
delay(100);
digitalWrite(LED_pin, LOW);
delay(100);
digitalWrite(LED_pin, HIGH);
delay(100);
digitalWrite(LED_pin, LOW);
delay(250);
// termina ejemplo
delay(1000);
}
void configura_wifi(){
// inicia en modo estación
WiFi.mode(WIFI_AP_STA);
WiFi.beginSmartConfig();
int cuenta = 0;
// Espera por un paquete Smartconfig del móvil/tablet
Serial.println("Esperando conexión SmartConfig móvil/tablet");
while (!WiFi.smartConfigDone()) {
delay(500);
Serial.print(".");
cuenta = cuenta+1;
if (cuenta>=40){
Serial.println("\n Esperando conexión SmartConfig móvil/tablet");
cuenta = 0;}
// LED interno enciende en LOW
digitalWrite(LED_pin, HIGH);
delay(50);
digitalWrite(LED_pin, LOW);
delay(50);
}
Serial.println("\n Finalizado SmartConfig.");
}
void conecta_wifi() {
// conexion WiFi
Serial.println("\n Conectando a WiFi");
WiFi.begin();//ssid, password);
int cuenta = 0;
while (WiFi.status() != WL_CONNECTED){
Serial.print(".");
cuenta = cuenta+1;
if (cuenta>=40){
Serial.println();
cuenta = 0;}
// LED interno enciende en LOW
digitalWrite(LED_pin, LOW);
delay(250);
digitalWrite(LED_pin, HIGH);
delay(250);
}
Serial.print("\n WiFi conectado , Dirección IP: ");
Serial.print(WiFi.SSID());
Serial.print(" , ");
Serial.println(WiFi.localIP());
delay(10);
}
Por desarrollar:
Personalizar la aplicación del móvil/tableta a partir del código básico de espressif.
/* Redes disponibles
* Realiza una búsqueda de redes Wifi cercanas
*/
#include <WiFi.h>
void setup()
{
Serial.begin(115200);
// Si estaba conectada como estación, se desconecta.
WiFi.mode(WIFI_STA);
WiFi.disconnect();
delay(100);
Serial.println("Configuración completada.");
}
void loop()
{
Serial.println("Busca redes WiFi cercanas");
//determina el número de redes cercanas
int n = WiFi.scanNetworks();
Serial.println("Busqueda completada ");
if (n == 0) {
Serial.println("NO se encontraron redes.");
} else {
Serial.print(n);
Serial.println(" redes encontradas");
for (int i = 0; i < n; ++i) {
// Muestra el SSID y RSSI de cada red encontrada
Serial.print(i + 1);
Serial.print(": ");
Serial.print(WiFi.SSID(i));
Serial.print(" (");
Serial.print(WiFi.RSSI(i));
Serial.print(")");
Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*");
delay(10);
}
}
Serial.println("");
// Espera antes de la próxima búsqueda...
delay(5000);
}
Para crear un Access Point se usa de la libreria la intrucción WIFI.softAP()
Como base se tiene el ejercicio de una página web para encender o apagar el LED incorporado.
En ésta ocasión no es necesario conectarse a un router, el AP aparece en la lista de dispositivos circundantes. Se selecciona y se ingresa con el nombre de red y la contraseña.
/* ESP32 Soft AP con web server para encender LED_Pin
forma básica con la función inicia_wifi
Referencia: https://www.arduino.cc/en/Tutorial/WiFiWebServer
*/
#include <WiFi.h>
const char* ssid = "iotirni19_AP";
const char* password = "xxxxx";
// puerto de servidor web 80
const PROGMEM uint8_t puertoweb = 80;
WiFiServer server(puertoweb);
// LED monitor interno
//ESP01-pin=1, ESP07-pin=2; ESP32-pin=5
const PROGMEM uint8_t LED_pin = 5;
int LED_estado = 0;
void setup()
{
// Conexion serial
Serial.begin(115200);
Serial.setTimeout(500);
// espera inicializar serial
while(!Serial) { }
// LED monitor
pinMode(LED_pin, OUTPUT);
delay(10);
// Convertir en AP
WiFi.softAP(ssid, password);
//inicia_wifi(); // no se conecta a un router
server.begin();
}
void loop(){
WiFiClient client = server.available();
if (client){
String linea = "";
Serial.println();
Serial.println("Nuevo cliente.");
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
if (c == '\n') {
// Si recibe fin de linea y la linea es vacia,
// la peticion http finalizó, se responde:
if (linea.length() == 0) {
// HTTP headers inician con ésta secuencia:
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println();
// contenido despues de headers
client.print("LED estado: ");
client.print(String(LED_estado)+"
");
client.print("Click <a href=\"/H\">ENCIENDE LED</a><br>");
client.print("Click <a href=\"/L\"> APAGA LED</a><br>");
// finaliza contenido:
client.println();
// sale del lazo:
break;
} else {
linea = "";
}
} else if (c != '\r') {
linea = linea + c;
}
// Revisa click del cliente "GET /H" or "GET /L":
if (linea.endsWith("GET /H")) {
digitalWrite(LED_pin, HIGH);
LED_estado = 1;
}
if (linea.endsWith("GET /L")) {
digitalWrite(LED_pin, LOW);
LED_estado = 0;
}
}
}
delay(1); // espera que browser procese
client.stop(); // cierra conexión:
Serial.println("Cliente desconectado.");
}
}
Enciender y Apagar elLED incorporado (Pin 5) en el módulo ESP32 desde una página web.
El módulo se configura como un Web Server para responder a las petición desde un browser. La dirección mostrada en la figura es un ejemplo.
La librería básica usada es WiFi.h con los valores de SSID y Password para acceder a la red existente, valores que se deben actualizar de acuerdo a la configuración de su red. El router asigna una dirección IP de forma automática, y su valor se muestra en el monitor serial, dirección usada en un brower para observar el resultado.
Para simplificar las instrucciones, la sección de conexión a la red WiFi se realiza en la función inicia_wifi().
Instrucciones:
Para iniciar el modo servidor web se requiere WifiServer server(puertoweb), el puerto web es el 80.
En el programa se revisa el estado del cliente (client): conectado, disponible, leyendo cada caracter enviado por el browser e interpretando las instrucciones por cada fin de línea ('\n').
Si la línea recibida finaliza con "GET /H" o "GET /L" se realiza el cambio de estado del LED.
Al final se cierra la conexión, y se continua monitoreando el estado del cliente.
/* ESP32 web server para encender LED_Pin
forma básica con la función inicia_wifi
Referencia: https://www.arduino.cc/en/Tutorial/WiFiWebServer
*/
#include <WiFi.h>
const char* ssid = "";
const char* password = "";
// puerto de servidor web 80
const PROGMEM uint8_t puertoweb = 80;
WiFiServer server(puertoweb);
// LED monitor interno
//ESP01-pin=1, ESP07-pin=2; ESP32-pin=5
const PROGMEM uint8_t LED_pin = 5;
void setup()
{
// Conexion serial
Serial.begin(115200);
Serial.setTimeout(500);
// espera inicializar serial
while(!Serial) { }
// LED monitor
pinMode(LED_pin, OUTPUT);
delay(10);
inicia_wifi();
server.begin();
}
void loop(){
WiFiClient client = server.available();
if (client){
String linea = "";
Serial.println();
Serial.println("Nuevo cliente.");
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
if (c == '\n') {
// Si recibe fin de linea y la linea es vacia,
// la peticion http finalizó, se responde:
if (linea.length() == 0) {
// HTTP headers inician con ésta secuencia:
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println();
// contenido despues de headers
client.print("Click <a href="\"/H\"">ENCIENDE LED</a>
");
client.print("Click <a href="\"/L\""> APAGA LED</a>
");
// finaliza contenido:
client.println();
// sale del lazo:
break;
} else {
linea = "";
}
} else if (c != '\r') {
linea = linea + c;
}
// Revisa click del cliente "GET /H" or "GET /L":
if (linea.endsWith("GET /H")) {
digitalWrite(LED_pin, HIGH);
}
if (linea.endsWith("GET /L")) {
digitalWrite(LED_pin, LOW);
}
}
}
delay(1); // espera que browser procese
client.stop(); // cierra conexión:
Serial.println("Cliente desconectado.");
}
}
void inicia_wifi() {
// conexion WiFi
Serial.print("\n Conectando a ");
Serial.println(ssid);
WiFi.begin(ssid, password);
int cuenta = 0;
while (WiFi.status() != WL_CONNECTED){
Serial.print(".");
cuenta = cuenta+1;
if (cuenta>=40){
Serial.println();
cuenta = 0;}
// LED interno enciende en LOW
digitalWrite(LED_pin, LOW);
delay(250);
digitalWrite(LED_pin, HIGH);
delay(250);
}
Serial.print("\n WiFi conectado \n Dirección IP: ");
Serial.println(WiFi.localIP());
delay(10);
}
Puntos por desarrollar
Añadir en la pagina el estado del LED. Sugerencia: aumentar una variable de estado para el led y usarla en la página html.
Conectar a un servidor MQTT e iniciar el estado del LED con el correspondiente en el Estado MQTT.
