1 – NodeMCU ESP32.

El siguiente paso de «Espressif» despues de ESP12 es ESP32. Una de las novedades de este circuito es Bluetooth además de WiFi.

La última NodeMCU utiliza el modulo ESP32 con mejoras respecto a la versión anterior ESP12.

Este circuito utiliza un procesador de Tensilica Xtensa LX6, a 32 bit y una frecuencia de 240 MHz.

2 – Datos técnicos y características de NodeMCU con ESP32.

El modulo ESP32 es un modulo con varias mejoras respecto al anterior ESP12. Tenemos un procesador más rápido de doble nucleo.

Para comunicarnos con el exterior tenemos ademas de una conexión Wifi una nueva conexión Bluetooth.

Disponemos de 520 KB de momeria SRAM y 16 MBytes de memoria flash.

Otra de las mejoras son las entradas GPIO, entre ellas disponemos de 12 entradas analógicas.

Características de NodeMCU con ESP32:

• Procesador ESP8266, de 32 bits a 240MHz de Tensilica doble nucleo.

---

• 448 KiB ROM.

---

• 520 KiB de SRAM.

---

• Memoria Flash de 128 Megabits (16 MegaBytes).

---

• Tensión de trabajo 3.3V.

---

• Intensidad de consumo 50mA aproximadamente aunque tiene picos de más de 300mA.

---

• Protocolo 802.11 b/g/n .

---

• Wifi Direct (P2P) Soft-AP.

---

• Stack TCP/IP.

---

• Interface WIFI a 2.4 Ghz.

---

• Bluetooth BLE.

---

• Pulsador para Flash.

---

• Pulsador para Reset.

---

• Conector micro usb.

---

• 32 pins GPIO (input-Output).

---

• Chip CH340G dedicado a USB-UART.

Tener en cuenta que la arquitectura y el orden de los pines puede cambiar dependiendo de la versión que utilices.

3 – Descripción de cada uno de los pines NodeMCU ESP32.

• Pins GPIO. Los pins gpio (General Purpose Input/Output) utilizamos estos pines como entradas o salidas independientemente si son analógicas o digitales.
• El pin ADC o TOUT, (Analog to digital converter), estos pines los podemos utilizar para recibir señales analógicas de diferentes dispositivos o sensores.

La linea de código por la cual leeremos el valor de entrada en este pin es :

analogRead(A0)

• Los pines PWM (Pulse width modulation) se pueden utilizar para las salidas analógicas.
• Los pines SPI (Serial Peripheral Interface) se utilizan para las comunicaciones entre circuitos integrados siguiendo un protocolo de comunicación sincrono, como por ejemplo con pantallas OLED. Entre los pines SPI tenemos SPICLK, SPIQ (MISO), SPID (MOSI) y SPICS.
• Pines UART (Universal asynchronous Receiver / Transmitter) Los pines UART los utilizamos para la recepción (RX) y transmisión (TX) de datos de la nodemcu. Los datos enviados a través de los pines UART nos permiten configurar tanto la velocidad de transmisión de los datos como su formato.

• Pin Flash. El pin flash (GPIO0) es recomendable tenerlo en un estado «LOW», es decir puesto a tierra cada vez que quieras flashear tu nodemcu, al igual que el pin GPIO15. Por el contrario se deberá dar tensión de 3.3V (estado HIGH) al pin GPIO2, a través de una resistencia de 3.3k.

Cuando conectamos la nodemcu a través del cable usb y flasheamos la tarjeta, esta automáticamente pone los pines GPIO0, GPIO2 y GPIO15 en el estado descrito arriba sin necesidad de cablearla.

En esta dirección puedes obtener mucha información con respecto a esta placa.

4 – Programación.

Programando ESP32 con Eclipse

Toda la información que necesitas para trabajar con un entorno como Eclipse la tienes disponible en :»esp-idf«.

Lo primero que debemos hacer es descargar las herramientas toolchain para trabajar con Windows, puesto que es  un software diseñado en un primer momento para trabajar en Linux.

La descarga la puedes hacer desde el siguiente enlace : «toolchain«.

Una vez descargado lo descomprimimos y lo guardamos en la carpeta C, msys32.

En este directorio, msys32, se nos habrán creado las herramientas necesarias para emular el entorno unix y poder compilar los dispositivos esp32. El ejecutable que emula el entorno unix es “mingw32.exe”

Ahora deberás clonar el repositorio de librerías para trabajar con esp idf, este paso lo puedes hacer desde la consola de comandos de Windows ms2 , dentro del directorio C:\msys32\home\usuario deberás escribir la siguiente línea de comandos: “git clone –recursive https://github.com/espressif/esp-idf.git”.

---

(Para utilizar la descarga de repositorios de Git, recuerda que deberas tener instalada la herramienta Git y creada la variable de entorno) En este momento se habrá creado el directorio esp-idf.

---

El siguiente paso es crear la variable donde especificamos la ruta del repositorio esp-idf, para esto crearemos un archivo en el directorio “C:/msys32/etc/profile.d/”, y se llamará “export_idf_path.sh”, dentro de este archivo guardaremos la siguiente instrucción “export IDF_PATH=«C:/msys32/home/user-name/esp/esp-idf»

Creando archivos y directorios antes de arrancar Eclipse.

Ahora ya tenemos lo necesario para compilar y ejecutar nuestro programa en esp32. Los pasos serian:

1. Conectar nuestro modulo ESP32 a través del puerto usb.

2. Abrir consola mingw32.exe, que se encuentra dentro del directorio C:/msys32.

3. Con el comando “cd” ir al directorio donde se encuentra nuestro programa, por ejemplo «C:\msys32\home\usuario\esp-idf\examples\get-started\hello_world» . Mucho cuidado con las barras del directorio, debes poner la barra del numero siete, de otra manera no encontrará la ruta del directorio, quedaría de la siguiente manera: «C:/msys32/home/Cesar/esp-idf/examples/get-started/hello_world».

4. Una vez estamos dentro de este directorio escribir en línea de comandos “make menuconfig” donde seleccionaremos «Serial flasher config», luego «Select» y nos desplazaremos a la ventana siguiente.

5. En esta ventana configuramos en «Default serial port» el puerto COM asignado ( indicado en «administrador de dispositivos de windows, puertos ), y desde “Default baud rate” seleccionamos la velocidad que son 115200 baudios de transferencia.

6. Después de grabar con «Save» todas las modificaciones salimos de la ventana de configuración con «Exit». Volvemos a la consola de comandos donde escribimos “make flash” para cargar el programa que se encuentra en nuestro directorio seleccionado.

7. Una vez cargado el programa en esp32 podemos ver el resultado desde PuTTY, indicando la comunicación serial, el numero de puerto COM y la velocidad en baudios de transferencia.

8. Si todo ha saldio bién ya podemos ver el resultado del programa.

El siguiente paso es la instalación y configuración de eclipse.

Podemos instalar eclipse desde la página oficial de eclipse en la siguiente dirección: eclipse (https://eclipse.org/home/index.php)

Eclipse tiene muchas versiones, la versión que necesitas en Eclipse IDE para los lenguajes de programación C/C++ .

Después de descargarlo deberas ejecutar el archivo ejecutable “.exe”, acuérdate de tener si es posible la última versión de Java.

Una vez tenemos instalado eclipse, creamos un nuevo proyecto desde la pestaña File->New->C Project.

Para empezar podemos copiar el ejemplo de “hello world” que tenemos en el directorio “C:\msys32\home\Cesar\esp-idf\examples\get-started\hello_world”. Copiamos el contenido y lo pegamos en el directorio del proyecto que hayamos creado. Tendremos que modificar el contenido del archivo “Makefile”, dentro del archivo “Makefile” veremos la instrucción “PROJECT_NAME := hello-world”, donde deberemos cambiar “hello-world” por el nombre de nuestro proyecto.

El siguiente paso es configurar nuestro proyecto para que se pueda compilar.

Primero, con el botón derecho del ratón en el nombre de nuestro proyecto, iremos a propiedades dentro de nuestro proyecto y realizaremos los siguientes cambios:

1. En la opción C/C++ Build deseleccionaremos la opción “use default built command”.
2. Debajo en “build command” escribimos: “python${IDF_PATH}/tools/windows/eclipse_make.py”.
3. Dentro de C/C++ Build iremos a la pestaña “environment” luego clickeamos “Add” para añadir las variables: de nombre: ”BATCH_BUILD” y de valor “1”; también añadiremos la variable “IDF_PATH” con el valor del directorio donde se encuentra nuestro repositorio esp-idf, por ejemplo:” C:\msys32\home\Cesar\esp-idf”.
4. Todavía dentro de C/C++ Build y también en la ventana de “environment” debemos editar la variable “path” añadir la dirección de “C:\msys32\opt\xtensa-esp32-elf\bin;C:\msys32\usr\bin;C:\msys32\mingw32\bin”
5. En el quinto paso debemos incluir los includes que necesitamos para nuestro proyecto, esto lo hacemos desde “C/C++ General” luego en “path and symbols” y luego dentro de “includes” añadimos los directorios que necesitamos donde se encuentran los includes que vamos a utilizar. Por ejemplo necesitamos incluir los includes que necesitamos de nuestro repositorio, para esto clickeamos «Add» luego «Filesystem» y el directorio donde se encuentran, en mi caso: «C:\msys32\home\Cesar\esp-idf\components\freertos\include» , como también añadir los includes que se generan con el proyecto que tenemos entre manos, para esto clickearemos «Add», luego «Workspace» y seleccionaremos el directorio, por ejemplo en mi caso «/hello_world/build/include».
6. Ahora debemos ir a la pestaña “Preprocessor Includes…” que se encuentra dentro de “C/C++ General”, y entrar en la pestaña “providers”, aquí seleccionaremos “CDT Cross GCC Built-in Compiler Settings” y escribiremos en la ventana de abajo xtensa-esp32-elf-gcc ${FLAGS} -E -P -v -dD «${INPUTS}», también seleccionamos “CDT GCC Build Output Parser” y escribimos en la ventana de abajo “xtensa-esp32-elf-(g?cc)|([gc]\+\+)|(clang)”
7. Ahora podemos construir el proyecto con el martillo de Eclipse, si no sale ningún error ya podremos compilarlo, para compilar debemos crear el target. Clickeamos nuestro proyecto y con el botón derecho del ratón nos vamos a “Build Targets” y luego “Create”, escribimos “flash”, luego hacemos la misma operación lo único que al ya tener “build Targets” creado, clickearemos este y con el botón derecho del ratón crearemos “clean” y luego crearemos “all”.
8. Una vez hecho todos estos pasos podemos clickear y ejecutar dentro de “build Targets” donde pone “flash”, después de hacer doble click en flash el programa se debería transferir a nuestra placa ESP32.
9. Puedes comprobar que puerto serie se ha asignado correctamente abriendo el archivo «sdkconfig» dentro de tu proyecto y comprobando la linea 32 con la siguiente instrucción «CONFIG_ESPTOOLPY_PORT=»COM3» «, en esta variable deberás poner el puerto COM asignado a tu placa en el caso de que no lo esté.

Ejemplo de código para poder testear tu placa ESP32

//Código de ejemplo que imprime el hola mundo 
//Este código pertenece al ejemplo del repositorio de esp-idf

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"


void app_main()
{
    printf("Hello world!, segundo intento\n");

    /* Print chip information */
    esp_chip_info_t chip_info;
    esp_chip_info(&chip_info);
    printf("This is ESP32 chip with %d CPU cores, WiFi%s%s, ",
            chip_info.cores,
            (chip_info.features & CHIP_FEATURE_BT) ? "/BT" : "",
            (chip_info.features & CHIP_FEATURE_BLE) ? "/BLE" : "");

    printf("silicon revision %d, ", chip_info.revision);

    printf("%dMB %s flash\n", spi_flash_get_chip_size() / (1024 * 1024),
            (chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "embedded" : "external");

    for (int i = 10; i >= 0; i--) {
        printf("Restarting in %d seconds...\n", i);
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
    printf("Restarting now.\n");
    fflush(stdout);
    esp_restart();
}

También podemos probar el led interno de la placa con este otro código, lo único que modifico es un printf con un hola mundo, y también cambio el pin asignado por defecto en el programa para el led interno, por defecto viene el 5 (#define BLINK_GPIO CONFIG_BLINK_GPIO) y en mi placa el led interno esta conectado al pin 2 (#define BLINK_GPIO 2)

//Este código también extraído de los ejemplos del repositorio de esp-idf
//podemos ver el encendido y apagado del led interno de la placa

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "sdkconfig.h"

/* Can run 'make menuconfig' to choose the GPIO to blink,
   or you can edit the following line and set a number here.
*/
//#define BLINK_GPIO CONFIG_BLINK_GPIO
#define BLINK_GPIO 2

void blink_task(void *pvParameter)
{
    /* Configure the IOMUX register for pad BLINK_GPIO (some pads are
       muxed to GPIO on reset already, but some default to other
       functions and need to be switched to GPIO. Consult the
       Technical Reference for a list of pads and their default
       functions.)
    */
    gpio_pad_select_gpio(BLINK_GPIO);
    /* Set the GPIO as a push/pull output */
    gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);
    while(1) {
        /* Blink off (output low) */
        gpio_set_level(BLINK_GPIO, 0);
        vTaskDelay(1000 / portTICK_PERIOD_MS);
        /* Blink on (output high) */
        gpio_set_level(BLINK_GPIO, 1);
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main()
{
    printf("Hola mundo\n");
    xTaskCreate(&blink_task, "blink_task", configMINIMAL_STACK_SIZE, NULL, 5, NULL);
}

Programando ESP32 con Arduino IDE

La instalación de Arduino IDE esta disponible desde su página oficial :»arduino.cc«. Dentro de la página oficial en el menu deberás seleccionar la opción «software», y seleccionar la opción de descarga que te corresponda.

Cuando accedas a la página de descarga podrás elegir entre contribuir con una ayuda económica y después descargar o descargarlo directamente.

Una vez descargado deberás ejecutar el archivo .exe, se creará el directorio con los archivos y herramientas para trabajar con el entorno de programación Arduino. El archivo que abre el entorno de programación es Arduino.exe, dentro del directorio arduino o desde el acceso directo normalmente en el escritorio.

Ahora que ya tenemos instalado el entorno de programación deberemos instalar el repositorio de Git, desde la página «git-scm.com«, solo con visitar la página empezará la descarga.

Ya descargado ejecutaremos el archivo «Git-2.14.1-64-bit.exe», con este paso descargaremos el programa necesario para poder descargar las librerías necesarias relacionadas con esp32 en arduino.

Ahora podemos ejecutar el programa llamado «Git Gui» para descargar las libreiras. Después de abrir el programa se nos abrirá esta ventana:

Tendremos que seleccionar «clone existing repository», después en «Source Location» escribiremos «https://github.com/espressif/arduino-esp32.git» y en «Target directory» escribiremos el directorio donde se encuentra Arduino, en mi caso «C:\Users\Cesar\Documents\Arduino» y continuaremos escribiendo «\hardware\espressif\esp32», de esta manera se creará el directorio «C:\Users\Cesar\Documents\Arduino\hardware\espressif\esp32».

Cuando se instalen las librerías deberemos ir al directorio: «C:\Users\Cesar\Documents\Arduino\hardware\espressif\esp32\tools» y ejecutar el archivo «get.exe» para que se genere el compilador del esp, xtensa-esp32-elf.

Ahora cada vez que queramos actualizar las librerias podemos abrir «Git Gui» despues seleccionar abrir repositorio «C:\Users\Cesar\Documents\Arduino\hardware\espressif\esp32», después seleccionar «Remote->Fetch from->origin», de esta manera actualizaremos las librerias del esp32.

Con esto estaría terminada la instalación del entorno de programación Arduino para esp32, dentro del entorno de programación deberíamos poder seleccionar en herramientas->placa:->ESP32 Dev Module.

---

La información para la configuración del entorno de programación esta en:»github.com/espressif/arduino-esp32«.

---

Más abajo tenemos un sencillo programa que es muy practico para testear y comprobar que hemos conectado correctamente con la placa y el programa se ha ejecutado bién, lo que hace este programa es encender un led azul embedido en la placa NodeMCU.

También podemos ver la información que nos muestra el «monitor serie» del entorno de programación arduino.

//Primer ejemplo
const int pinLED = 2;

void setup() {

Serial.begin(115200);
pinMode(pinLED, OUTPUT);

}

void loop() {

digitalWrite(pinLED, HIGH);
delay(400);
digitalWrite(pinLED, LOW);
delay(1000);

}

Otro ejemplo sencillo para comprobar la conexión a internet y obtener la ip de nuestra nodemcu es el siguiente:

//wifi esp32
#include <WiFi.h>

const char* ssid     = "nombre de nuestra red wifi";
const char* password = "contraseña de nuestra red wifi";

void setup()
{
    Serial.begin(115200);
    delay(10);

    Serial.println();
    Serial.print("Conectando a: ");
    Serial.println(ssid);

    WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    Serial.println("");
    Serial.println("Conectado a wifi");
    Serial.println("Dirección IP: ");
    Serial.println(WiFi.localIP());
}

void loop()
{
}

En este ejemplo utilizamos esp32 en modo servidor para encender y apagar el led de la placa.

#include <WiFi.h>

const char* ssid     = "nombre de nuestra red wifi";
const char* password = "contraseña de la red wifi";
const int pinLED = 2;

WiFiServer server(80);

void setup()
{
    Serial.begin(115200);
    pinMode(pinLED, OUTPUT);     
    
    delay(10);


    Serial.println();
    Serial.println();
    Serial.print("Connecting to ");
    Serial.println(ssid);

    WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    Serial.println("");
    Serial.println("WiFi connected.");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());
    
    server.begin();

}

int value = 0;

void loop(){
 WiFiClient client = server.available();   

  if (client) {                             
    Serial.println("New Client.");          
    String currentLine = "";                
    while (client.connected()) {           
      if (client.available()) {            
        char c = client.read();             
        Serial.write(c);                    
        if (c == '\n') {                    

       
          if (currentLine.length() == 0) {
            client.println("HTTP/1.1 200 OK");
            client.println("Content-type:text/html");
            client.println();


            client.print("<br><br><br><br><H1><center><a href=\"/H\">Encender</a></center></H1><br><br><br><br><br>");
            client.print("<H1><center><a href=\"/L\">Apagar</a></center></H1><br>");


            client.println();

            break;
          } else {    
            currentLine = "";
          }
        } else if (c != '\r') {  
          currentLine += c;      
        }

        
        if (currentLine.endsWith("GET /H")) {
          digitalWrite(pinLED, HIGH);               
        }
        if (currentLine.endsWith("GET /L")) {
          digitalWrite(pinLED, LOW);                
        }
      }
    }
    
    client.stop();
    Serial.println("Client Disconnected.");
  }
}