ESP32 es un único chip combinado Wi-Fi y Bluetooth de 2,4 GHz diseñado con la tecnología TSMC de 40 nm de potencia ultra baja. Está diseñado para lograr la mejor potencia y rendimiento de RF, y muestra robustez, versatilidad y fiabilidad en una amplia variedad de aplicaciones y escenarios de potencia. Algunas aplicaciones son IoT Sensor Hub genérico de baja potencia, registradores de datos IoT genéricos de baja potencia y red de malla.

Está diseñado para aplicaciones móviles, dispositivos electrónicos portátiles e Internet de las cosas (IoT). Cuenta con todas las características de vanguardia de los chips de baja potencia, incluida la sincronización de reloj de grano fino, múltiples modos de potencia y escalado dinámico de potencia. La salida del amplificador de potencia también es ajustable, contribuyendo así a un equilibrio óptimo entre el rango de comunicación, la velocidad de datos y el consumo de energía.

Características generales del ESP32

ESP32 Wi-Fi

802.11 b/g/n

802.11 n (2.4 GHz), up to 150 Mbps

ESP32 Bluetooth / ESP32 BLE

Bluetooth 4.2 BR/EDR BLE dual-mode controller
+12 dBm transmitting power

NZIF receiver with -97 dBm BLE sensivity

CPU y memoria

Microprocesador(es) Xtensa de uno o dos núcleos LX6 de 32 bits, hasta 600 MIPS (200 MIPS para ESP32-S0WD, 400 MIPS para ESP32-D2WD)
448 KB ROM
520 KB SRAM
16 KB SRAM en RTC (8KB de Memoria RTC FAST a la que accede la CPU principal durante el arranque RTC desde el modo Deep-sleep y 8 KB de Memoria RTC SLOW a la que accede el coprocesador durante el modo de suspensión profunda).

Relojes y temporizadores

Osciladores internos de 8 MHz con calibración
Oscilador RC interno con calibración
Oscilador de cristal externo de 2 MHz ~ 60 MHz (40 MHz sólo para la funcionalidad Wi-Fi/BT)
Oscilador de cristal externo de 32 kHz para el RTC con calibración
Dos grupos de temporizadores, incluyendo 2 x temporizadores de 64 bits y 1 x watchdog principal en cada grupo.
Un temporizador RTC
RTC watchdog

Interfaces periféricos avanzados

x34 GPIOs programables
ADC SAR de 12 bits de hasta 18 canales
2 x 8-bit DAC
10 sensores táctiles
4 x SPI
2 x I2S
2 x I2C
3 x UART
1 host (SD/eMMC/SDIO)
1 slave (SDIO/SP)
Interfaz MAC Ethernet con DMA dedicado y soporte IEEE 1588
CAN 2.0
IR (TX(RX)
Motor PWM
LED PWM hasta 16 canales
Sensor Hall

Seguridad

Arranque seguro
Encriptación flash
1024-bit OTP, hasta 768-bit para clientes
Aceleración de hardware criptográfico:
- AES
- Hash (SHA-2)
- RSA
- EXX
- Random Number Generator (RNG)

La imagen de abajo muestra el pinout del ESP32:

Para más información, consulta la ficha técnica.

ESP32 Arduino

Placa ESP32

Para cargar el programa en el ESP32 tienes que instalar la placa. Ve a Archivo > Preferencias y en URL adicionales del Administrador de tableros agrega la siguiente URL: https://dl.espressif.com/dl/package_esp32_index.json

*Si ya tienes una URL ponla junto a la otra separada por coma, como en la imagen de abajo.

Ahora puedes instalar la placa. Ve a Tools > Boards > Boards Manager y busca ESP32. Aparecerá el ESP32 de Espressif Systems. Instálalo.

Una vez instalado ves a Tools > Boards y elige DOIT ESP32 DEVKIT V1.

Ejemplos

Además, existen múltiples aplicaciones para múltiples sectores para conseguir el control industrial. Con proyectos ESP32 para soluciones de automatización.

Ver

ESP32 WiFi

Encontrarás algunos ejemplos para probar en File > Examples > Examples for ESP32 Dev Module. Echemos un vistazo al ejemplo de WiFi Scan.

Aquí tienes el código con algunos añadidos y comentarios:

ESP32 WiFi > Wifi_Scan code:

#include "WiFi.h"
void setup()
{
    Serial2.begin(19200);
    // Set WiFi to station mode and disconnect from an AP if it was previously connected
    WiFi.mode(WIFI_STA);
    WiFi.disconnect();
    delay(100);
    
    Serial2.println("Setup done");
}
void loop()
{
    int start = millis(); // Capture start time 
    Serial2.println("scan start");
    // WiFi.scanNetworks will return the number of networks found
    int n = WiFi.scanNetworks();
    int finish = millis();
    Serial2.print("scan done, time = ");
    Serial2.print(finish - start);
    Serial2.println(" ms");
    if (n == 0) {
        Serial2.println("no networks found");
    } else {
        Serial2.print(n);
        Serial2.println(" networks found");
        for (int i = 0; i < n; ++i) {
            // Print SSID and RSSI for each network found
            Serial2.print(i + 1);
            Serial2.print(": ");
            Serial2.print(WiFi.SSID(i));
            Serial2.print(" (");
            Serial2.print(WiFi.RSSI(i));
            Serial2.print(")");
            Serial2.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*");
            delay(10);
        }
    }
    Serial2.print("");
    // Wait a bit before scanning again
    delay(5000);
}

Cargar un programa

IMPORTANTE

To load a program, you have to press the button BOOT while is uploading the program. Once it is uploaded, press the button EN to run the program.

Resultado

Después de cargar el programa anterior de WiFiScan, verás algo así en el Serial Monitor:

ESP32 Bluetooth

Encontrarás algunos ejemplos para probar en File > Examples > Examples for ESP32 Dev Module. Vamos a echar un vistazo al BLE para escribir un ejemplo.

Aquí tienes el código con algunos añadidos y comentarios:

ESP32 BLE > BLE write code:

/*
    Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleWrite.cpp
    Ported to Arduino ESP32 by Evandro Copercini
*/
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
// See the following for generating UUIDs:
// https://www.uuidgenerator.net/
#define SERVICE_UUID        "3e3593cf-e5cb-46ee-8fa4-16c8b6a563d0" // example comes with 4fafc201-1fb5-459e-8fcc-c5c9c331914b
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
class MyCallbacks: public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pCharacteristic) {
      std::string value = pCharacteristic->getValue();
      if (value.length() > 0) {
        Serial2.println("*********");
        Serial2.print("New value: ");
        for (int i = 0; i < value.length(); i++)
          Serial2.print(value[i]);
        Serial2.println();
        Serial2.println("*********");
      }
    }
};
void setup() {
  Serial2.begin(19200);
  Serial2.println("1- Download and install an BLE scanner app in your phone");
  Serial2.println("2- Scan for BLE devices in the app");
  Serial2.println("3- Connect to MyESP32");
  Serial2.println("4- Go to CUSTOM CHARACTERISTIC in CUSTOM SERVICE and write something");
  Serial2.println("5- See the magic =)");
  BLEDevice::init("MyESP32");
  BLEServer *pServer = BLEDevice::createServer();
  BLEService *pService = pServer->createService(SERVICE_UUID);
  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
                                         CHARACTERISTIC_UUID,
                                         BLECharacteristic::PROPERTY_READ |
                                         BLECharacteristic::PROPERTY_WRITE
                                       );
  pCharacteristic->setCallbacks(new MyCallbacks());
  pCharacteristic->setValue("Hello World");
  pService->start();
  BLEAdvertising *pAdvertising = pServer->getAdvertising();
  pAdvertising->start();
}
void loop() {
  // put your main code here, to run repeatedly:
  delay(2000);
}

Como puedes ver, tienes que ir a www.uuidgenerator.net para generar un identificador numérico de 128 bits UUID (identificador único universal). Se utiliza para garantizar que los servicios y las características de tu dispositivo sean únicos a nivel mundial.

Después de cargar el programa en el Monitor Serial verás 5 pasos a seguir:

Descarga e instala una aplicación de escáner BLE en tu teléfono. Por ejemplo, BLE Scanner de Bluepixel Technologies.
Scan for BLE devices in the app.
Conéctate a MyESP32. No lo verás hasta que ejecutes el programa.
Ves a CUSTOM CHARACTERISTIC en CUSTOM SERVICE y escribe algo.
Mira la magia =). Todo lo que escribas se imprimirá.

Resultado

Después de cargar el programa anterior de escritura BLE verás algo así en el Serial Monitor:

Hello? y It works :) son dos mensajes enviados desde el teléfono.

Connections with our industrial PLC

M-Duino

La comunicación entre el módulo WiFi y el PLC es por TTL. El ESP32 usa Serial2 para enviar los datos al PLC. El PLC recibe los datos por Serial1. Por lo tanto, debes conectar el pin ESP TX2 al pin PLC RX1 y el pin ESP RX2 al pin PLC TX1. El ESP conecta el Vin y GND a la fuente de alimentación. A partir de ahora, la comunicación Serial 1 estará ocupada.

Aquí tienes un diagrama:

Dale un vistazo al M-Duino. El PLC industrial con Arduino MEGA

M-Duino -Arduino PLC >>

Código del PLC

El programa del PLC únicamente lee los datos recibidos por Serial1 y los imprime por Serial.

void setup() {
  Serial.begin(19200);
  Serial1.begin(19200);
}

void loop() {
  if (Serial1.available()){
    Serial.print((char)Serial1.read());
  }
}

Ardbox

Para evitar inhabilitar los pines de comunicación RS232 (pins 0 y 1) utilizamos el serial del software en vez del serial del hardware. En Ardbox tenemos 3 pines RX disponibles (MISO, MOSI y SCK). En este caso utilizamos MISO como RX y MOSI como TX.

ESP32 y Ardbox ejemplo conexiones

Dale un vistazo a Ardbox. El PLC industrial con Arduino Leonardo
Ardbox - Arduino PLC >>

Código del PLC

La función del programa es la misma que antes.

#include <SoftwareSerial.h>

SoftwareSerial mySerial(MISO, MOSI); // RX, TX 

void setup() {
  Serial.begin(19200);
  mySerial.begin(19200);
}

void loop() {
  if (mySerial.available()){
    Serial.print((char)mySerial.read());
  }
}

IMPORTANTE

Recuerda conectar el mismo GND (ESP32 - PLC).

* Para hacer la prueba hemos realizado estas conexiones, pero el módulo ESP32 estará dentro del PLC correctamente conectado.