Ir al contenido

PLC ESP32 industrial · 12 a 24 Vdc · Wi-Fi y Bluetooth · Arduino IDE

PLC ESP32 industrial: características técnicas

Referencia técnica completa de la familia PLC ESP32: fuente de alimentación, interruptores DIP, E/S analógicas y digitales, salidas de relé, Wi-Fi, Bluetooth, Ethernet, RS-485, RS-232, I2C, SPI, RTC, microSD y el ESP32 de doble núcleo con FreeRTOS, con esquemas de cableado y código para Arduino IDE para cada función.

Fuente de alimentación
12 a 24 Vdc, 2 A como mínimo
Programación
Arduino IDE, C y C++
Comunicaciones
Wi-Fi, Bluetooth, Ethernet, RS-485, RS-232, Serial TTL, I2C, SPI
Extras
Doble núcleo, FreeRTOS, RTC, microSD, GPIO

Visión general del PLC ESP32

Qué es el PLC ESP32 industrial#

El PLC ESP32 es la gama de controladores industriales de Industrial Shields basada en el ESP32 de doble núcleo de Espressif, con Wi-Fi y Bluetooth nativos en todos los modelos. Combina un control determinista de E/S con conectividad inalámbrica y se alimenta a 12-24 Vdc. Usa este controlador industrial ESP32 para automatización conectada, monitorización remota, IoT industrial y retrofit de maquinaria.

El PLC ESP32 se programa en C y C++ con Arduino IDE y el paquete de placas de Industrial Shields. Además de Wi-Fi y Bluetooth ofrece Ethernet, RS-485, RS-232, Serial TTL, I2C y SPI, y admite Modbus RTU, Modbus TCP y MQTT. La lógica de control y las comunicaciones pueden ejecutarse en núcleos distintos. No tiene Linux: si necesitas Linux, Docker o Node-RED, el PLC Raspberry Pi es la mejor opción.

Certificaciones: CE y RoHS. Esta página cubre los modelos configurados con interruptores DIP (ESP32 PLC 19R a 58). El ESP32 PLC 14 tiene su propia página: Características técnicas del ESP32 PLC 14.

Modelos de PLC ESP32 y E/S#

El número de modelo es el total aproximado de puntos de E/S. R indica salidas de relé y AR, analógicas y de relé combinadas. CORE es la combinación preconfigurada más habitual, lista para pedir; FLEX te permite elegir las placas de comunicación. Las entradas analógicas se configuran como 0 a 10 V o 4 a 20 mA y todas las salidas digitales admiten PWM.

Modelo de PLC ESP32Entradas analógicasEntradas digitalesSalidas digitalesSalidas de reléE/S totalesCORE/FLEX
ESP32 PLC 14274014Sí
ESP32 PLC 19R423817No
ESP32 PLC 21678021Sí
ESP32 PLC 38AR10911838No
ESP32 PLC 38R8461634No
ESP32 PLC 42121416042No
ESP32 PLC 57R12692451No
ESP32 PLC 58162124061No

Compara la gama en la página de la familia PLC ESP32 o descarga fichas técnicas, guías de usuario y certificados desde la documentación técnica.

Instalación y configuración

Programación con Arduino IDE#

Arduino IDE es la plataforma original para programar placas Arduino. Esta aplicación multiplataforma está disponible para Windows, macOS y Linux bajo la licencia GNU General Public License. Arduino IDE admite código estructurado en C y C++. Para programar los PLC basados en ESP32 en este entorno, Industrial Shields ofrece un paquete de placas con las bibliotecas y herramientas necesarias.

Recomendamos usar el Arduino IDE Legacy (1.8.X) para programar los PLC basados en ESP32, aunque se puede usar otro software compatible con ESP. El Arduino IDE 1.8.X se puede descargar desde este enlace. Después de descargar e instalar Arduino IDE, instala el paquete de placas industrialshields-esp-32 dentro del IDE. Para hacerlo, sigue este tutorial y selecciona el paquete industrialshields-esp-32 en el paso 6.

Fuente de alimentación: 12 a 24 Vdc#

Los PLC basados en ESP32 deben alimentarse con una fuente de alimentación externa que proporcione una tensión de entre 12 y 24 Vdc. ¡Atención! Aunque a primera vista pueda parecer que el PLC funciona alimentado por el puerto USB, no es así. El uso de una fuente de alimentación externa es obligatorio para que el PLC funcione correctamente.

El consumo de los PLC basados en ESP32 oscila entre 700 y 1500 mA. Por eso, Industrial Shields recomienda usar una fuente de alimentación capaz de entregar al menos 2 A.

Especificaciones de la fuente de alimentación:

  • Tensión: entre 12 y 24 Vdc.
  • Intensidad: al menos 2 A.

El esquema de esta sección muestra las conexiones necesarias para alimentar correctamente un PLC.

Esquema de cableado de la alimentación del PLC ESP32

Interruptores DIP#

Los PLC basados en ESP32 tienen varios interruptores que sirven para configurar ciertas funciones del PLC. Esta sección explica cómo usarlos correctamente. Para distinguir las distintas partes del PLC y localizar cada interruptor, se usa la siguiente nomenclatura:

Lateral derecho del PLC ESP32: nomenclatura de zonas

Vista superior del PLC ESP32: nomenclatura de zonas

Lateral izquierdo del PLC ESP32: nomenclatura de zonas

En cada zona hay uno o varios interruptores que sirven para configurar algunas funciones del PLC. Las tablas siguientes indican la función de cada interruptor y cómo configurarlo.

Zona A: interruptor inferior izquierdo

Interruptor DIP inferior izquierdo de la zona A del PLC ESP32

Interruptor

Off

On

1

X

X

2

RS232

EXP 2 o Serial 2 (según el estado del interruptor 4)

3

RS485

Serial 1 (TX1/RX1)

4

Serial 2 (TX2/RX2)

EXP2

  1. No se usa.
  2. Este interruptor sirve para seleccionar entre RS232, Serial2 y EXP2 (Expansion Shield 2), junto con el interruptor 4. RS232 se selecciona cuando el interruptor está en OFF. En ON, se activa Serial2 o EXP2, según el valor del interruptor 4 (consulta la configuración del interruptor 4).
  3. Este interruptor sirve para seleccionar entre RS485 (OFF) y Serial1 (ON).
  4. Sirve para seleccionar entre EXP2 (ON) y Serial2 (OFF) cuando el interruptor 2 está en ON.

Zonas B, C y D: interruptor analógico

Interruptor DIP analógico del PLC ESP32 en las zonas B, C y D

Interruptor

Off

On

1

AX.5

QX.5

2

AX.6

QX.6

3

AX.7

QX.7

4

X

X

Estos interruptores sirven para elegir entre salida digital o analógica, según la tabla anterior. En OFF, solo estará disponible la salida analógica correspondiente. En ON, solo estará disponible la salida digital correspondiente. Los interruptores funcionan igual en las zonas B, C y D, y el valor de "X" cambia según la zona:

  • Zona B: X = 0
  • Zona C: X = 1
  • Zona D: X = 2

Consumo por modelo#

Este informe analiza el consumo de los distintos modelos de PLC ESP32 en reposo y con todas las salidas activas. Conocer estos valores es clave para optimizar la eficiencia en aplicaciones industriales.

En reposo

En este escenario, el PLC ESP32 está encendido, con todos los pines y comunicaciones desactivados y alimentado a 24 V. Esta prueba mide el consumo base cuando el equipo está en reposo y no realiza ninguna tarea de procesamiento ni de salida.

Modelo

Corriente (mA)

Potencia (W)

21+902,16
42+89
2,136
58+77
1,848
19R+72
1,728
38R+73
1,752
57R+76
1,824
38AR+73
1,752
53ARR+75
1,8
57AAR+75
1,8
54ARA+78
1,872
50RRA+78
1,872

Todas las salidas en HIGH

En esta prueba, el PLC ESP32 se configura para poner todos sus pines de salida en estado alto, alimentado a 24 V. Las salidas no están conectadas, así que el consumo real variará según la corriente que absorba el equipo conectado a cada salida.

Modelo

Corriente (mA)

Potencia (W)

21+102
2,448
42+116
2,784
58+1202,88
19R+191
4,584
38R+304
7,296
57R+415
9,96
38AR+209
5,016
53ARR+3197,656
57AAR+221
5,304
54ARA+226
5,424
50RRA+328
7,872

Entradas y salidas

Entradas analógicas: 0 a 10 Vdc, 11 bits#

Una entrada analógica permite leer niveles de tensión analógicos y codificar el valor con un número de N bits. Las entradas analógicas del PLC basado en ESP32 usan como referencia el GND interno (el mismo que la fuente de alimentación). Las entradas analógicas de estos PLC tienen las siguientes especificaciones:

  • Rango de tensión: de 0 a 10 Vdc.
  • Resolución: 11 bits, es decir, los valores leídos van de 0 a 2047.

Además, las entradas analógicas también se pueden usar como entradas digitales no aisladas que toleran hasta 24 Vdc. Para ello, consulta la sección de entradas digitales. Las entradas analógicas son las comprendidas entre IX.7 e IX.12, donde X es 0, 1 o 2 según la zona. Puedes identificar las entradas analógicas de tu equipo con el siguiente símbolo:

Símbolo de entrada analógica de 0 a 10 Vdc

Entrada analógica 0V - 10Vdc

El siguiente esquema muestra las conexiones necesarias para usar correctamente una entrada analógica (usada como digital, la entrada tolera hasta 24 V):

Esquema de cableado de una entrada analógica del PLC ESP32

Configuración del software

Para usarlas, las entradas analógicas deben configurarse en la parte de setup del código, como se hace habitualmente en las placas Arduino. Después se leen con la función "analogRead()", con el nombre de la entrada como parámetro. Por ejemplo, I0.7 se lee como I0_7:

void setup() {
  pinMode(I0_7, INPUT);
  Serial.begin(9600);
}

void loop() {
  Serial.println(analogRead(I0_7));
}

También te puede interesar este post: Conceptos básicos sobre las entradas analógicas de un PLC industrial.

Entradas digitales: 5 a 24 Vdc#

Las entradas digitales sirven para captar señales que solo tienen dos estados: alto o bajo, verdadero o falso, etc. Las entradas digitales del PLC ESP32 interpretan como nivel alto los valores de 5 Vdc o más, hasta 24 Vdc, y como nivel bajo los valores inferiores a 5 V. Hay 2 tipos de entradas que se pueden usar como entrada digital:

  • Entradas digitales aisladas (5 - 24 Vdc): estas entradas están optoaisladas, es decir, tienen una protección adicional y usan como referencia un pin de masa externo. Son los pines de IX.0 a IX.6, donde X es 0, 1 o 2 según la zona.
  • Entradas digitales no aisladas (5 - 24 Vdc): estas entradas no están optoaisladas y usan como referencia el GND interno del PLC. Son las mismas que las entradas analógicas, de IX.7 a IX.12, donde X es 0, 1 o 2 según la zona.

Puedes identificarlas con los siguientes símbolos:

Símbolo de entrada digital aislada de 5 a 24 Vdc

Entrada aislada 5V - 24V

Símbolo de entrada digital no aislada de 5 a 24 Vdc

Entrada no aislada 5V - 24V

Los siguientes esquemas muestran las conexiones necesarias para usar correctamente ambas entradas como digitales:

Esquema de cableado de una entrada digital aislada del PLC ESP32

Esquema de cableado de una entrada digital no aislada del PLC ESP32

Configuración del software

Para usarlas, las entradas digitales deben configurarse en la parte de setup del código, como se hace habitualmente en las placas Arduino. Después se leen con la función "digitalRead()", con el nombre de la entrada como parámetro. Por ejemplo, I0.0 se lee como I0_0:

void setup() {
  pinMode(I0_0, INPUT);
  Serial.begin(9600);
}

void loop() {
  Serial.println(digitalRead(I0_0));
}

Estos posts amplían el tema: Conceptos básicos sobre las entradas digitales de un controlador industrial, Entradas digitales PNP en un PLC industrial.

Entradas de interrupción#

Algunas entradas digitales del PLC ESP32 admiten interrupciones, es decir, se pueden usar con ISR (rutinas de servicio de interrupción) para ejecutar cierto código cuando se detecta un evento (un cambio de estado en el pin). Hay dos pines de este tipo en cada zona: IX.5 e IX.6. Se usan y se conectan como entradas digitales aisladas normales, y las interrupciones se programan por software.

Configuración del software

Este es un ejemplo de cómo usar los pines de interrupción. En este caso, la función "isrI0_5()" se llama automáticamente cada vez que se produce un cambio de estado en el pin I0.5.

void setup() {
  // Begin serial port
  Serial.begin(9600);
  // Set input 
  pinMode(I0_5, INPUT);
  //Initialize interrupt
  attachInterrupt(digitalPinToInterrupt(I0_5), isrI0_5, CHANGE);
}

void loop() {
  while(true);
}

void isrI0_5() { 
  Serial.println("Interrupt activated");
}

Para saber más sobre las entradas de interrupción: Cómo usar las entradas de interrupción con placas Arduino industriales

Salidas analógicas: 0 a 10 Vdc, 12 bits#

Una salida analógica proporciona una tensión determinada por un valor digital de N bits. Los PLC ESP32 pueden tener entre 3 y 9 salidas analógicas, según el modelo. Están rotuladas como AX.X y hay que seleccionarlas mediante un interruptor DIP para usarlas (consulta Interruptores DIP). Las salidas analógicas del PLC ESP32 tienen las siguientes especificaciones:

  • Rango de tensión: de 0 a 10 Vdc.
  • Resolución: 12 bits.

Las salidas analógicas tienen un pin GND externo compartido que hay que conectar para fijar la referencia. Este símbolo identifica las salidas analógicas y el siguiente esquema muestra cómo conectarlas:

Símbolo de salida analógica de 0 a 10 Vdc

Salida analógica 0 - 10V

Esquema de cableado de una salida analógica del PLC ESP32

Configuración del software

Las salidas analógicas se programan igual que en un Arduino normal: primero se configura el modo del pin como "OUTPUT" en el setup del código y después se escribe la salida con "analogWrite()". Para referirte a cada salida analógica usa su nombre con "_" en lugar de ".". Por ejemplo, A0.5 se usa como A0_5:

void setup()
{
    pinMode(A0_5, OUTPUT);
}

// Loop function
void loop()
{   
    analogWrite(A0_5, 0);    
    delay(1000);   
    analogWrite(A0_5, 200);
    delay(1000);
}

Para saber más sobre las salidas analógicas: Conceptos básicos sobre las salidas analógicas de un PLC industrial.

Salidas digitales: 5 a 24 Vdc#

Las salidas digitales del ESP32 pueden dar un valor bajo (0 Vdc) o alto (hasta 24 Vdc). Están rotuladas como QX.X y se identifican con el siguiente símbolo.

El valor alto de la salida puede ir de 5 a 24 Vdc. Esta tensión se fija con dos pines situados junto a las salidas: QVdc y COM(-). Por ejemplo, si quieres que la salida dé 24 V, conecta el pin QVdc a 24 V y el pin COM(-) a GND. El siguiente esquema muestra un ejemplo de conexión:

Símbolo de salida digital (PWM opcional)

Salida digital (PWM opcional)

Esquema de cableado de una salida digital del PLC ESP32

Configuración del software

Las salidas digitales deben configurarse en la parte de setup del código, como se hace habitualmente en las placas Arduino: primero con "pinMode()" para definirlas como "OUTPUT" y después con "digitalWrite()" para cambiar su valor. Mira el siguiente ejemplo:

void setup() {
  pinMode(Q0_0, OUTPUT);
}

void loop() {
  digitalWrite(Q0_0, HIGH);
  delay(1000);
  digitalWrite(Q0_0, LOW);
  delay(1000);
}

Puedes saber más sobre las salidas digitales en este post: Conceptos básicos sobre las salidas digitales de un PLC industrial.

Salidas PWM#

En los PLC basados en ESP32, todas las salidas digitales se pueden usar como salidas PWM.

El valor alto de la salida puede ir de 5 a 24 Vdc. Igual que cuando se usan como salidas digitales simples, esta tensión se fija con dos pines situados junto a las salidas: QVdc y COM(-). Por ejemplo, si quieres que la salida dé 24 V, conecta el pin QVdc a 24 V y el pin COM(-) a GND. El siguiente esquema muestra un ejemplo de conexión.

Encontrarás un tutorial de ejemplo sobre cómo programar el PLC para usar las salidas PWM en PLC ESP32: prueba de salidas PWM.

Símbolo de salida con PWM

Salida con PWM

Salidas de relé: 5 A a 250 Vac#

Un relé es un interruptor electromagnético controlado por una señal eléctrica. En los equipos de Industrial Shields estos dispositivos ya vienen integrados en las placas. Los relés del PLC ESP32 tienen las siguientes especificaciones:

  • Corriente máxima en DC: 3 A a 30 Vdc.
  • Corriente máxima en AC: 5 A a 250 Vac

Cada salida de relé tiene dos bornes y está rotulada como RX.X. El siguiente esquema muestra las conexiones:

Esquema de cableado de una salida de relé del PLC ESP32

Configuración del software

Las salidas de relé deben configurarse en la parte de setup del código con funciones de Arduino y se controlan como si fueran salidas digitales. Para referirte a cada salida usa el nombre de la serigrafía: por ejemplo, R0.1 se usa como R0_1. Mira el siguiente ejemplo. Cuando la salida está en "HIGH", el relé se activa y el contacto se cierra; cuando está en "LOW", el contacto queda abierto.

void setup() {
  pinMode(R0_1, OUTPUT);
}

void loop() {
  digitalWrite(R0_1, HIGH);
  delay(1000);
  digitalWrite(R0_1, LOW);
  delay(1000);
}

Para saber más sobre las salidas de relé, consulta este post: Conceptos básicos sobre los relés internos de un PLC industrial.

Comunicaciones: Wi-Fi, Bluetooth, Ethernet, RS-485, RS-232, I2C, SPI

Ethernet (W5500)#

Ethernet es la tecnología más usada en las redes de área local cableadas ( LAN ).

Una LAN es una red de ordenadores y otros dispositivos electrónicos que cubre un área pequeña, como una sala, una oficina o un edificio. Se contrapone a una red de área amplia (WAN) , que abarca zonas geográficas mucho mayores. Ethernet es un protocolo de red que controla cómo se transmiten los datos en una LAN. Técnicamente se denomina protocolo IEEE 802.3. El protocolo ha evolucionado con el tiempo hasta transferir datos a un gigabit por segundo.

Los PLC ESP32 incorporan un puerto Ethernet con el controlador W5500, que se comunica con el ESP32 por SPI. El W5500 es un controlador Ethernet embebido con pila TCP/IP por hardware que simplifica la conexión a Internet de los sistemas embebidos. Este chip da conectividad a Internet a tus aplicaciones con un único integrado que incluye la pila TCP/IP , el MAC Ethernet 10/100 y el PHY. Con él puedes integrar Ethernet en tus aplicaciones.

Configuración del software

El paquete de placas de Industrial Shields incluye una biblioteca "Ethernet" que facilita el uso de este protocolo. La biblioteca trae varios ejemplos, que encontrarás en File > Examples > Ethernet dentro de Arduino IDE.

Echa también un vistazo al siguiente programa. Antes de ejecutarlo, comprueba que el PLC está bien alimentado, que el cable Ethernet está bien conectado al equipo y que el paquete de placas "industrialshields-esp-32" está correctamente instalado en Arduino IDE. Este código sirve como herramienta de diagnóstico para comprobar que el puerto Ethernet funciona. Establece una conexión con "www.google.com" a través del controlador W5500 con configuración IP por DHCP.

#include "Ethernet.h"

#define REMOTE "www.google.com"

const uint16_t port = 80;
uint8_t mac[] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x01};

EthernetClient c;

////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
  Serial.begin(9600L);
  Serial.println("ethernet started");

  test();
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void loop() {
  if (!c.connected()) {
    Serial.println("Disconnected");
    test();
  }
  delay(1000);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void test() {
  //if you need a DHCP IP use this configuration:
  Ethernet.begin(mac);
          
  switch (Ethernet.hardwareStatus()) {
    case EthernetW5100:
      Serial.println("W5100 found");
      break;

    case EthernetW5200:
      Serial.println("W5200 found");
      break;

    case EthernetW5500:
      Serial.println("W5500 found");
      break;

    default:
      Serial.println("Unknown hardware");
      break;
  }

  uint8_t MAC[6];
  Ethernet.MACAddress(MAC);
  for (int i = 0; i < 6; ++i) {
    if (i > 0) {
      Serial.print(':');
    }
    Serial.print(MAC[i], HEX);
  }
  Serial.println();

  //use this block with DHCP IP:
  Serial.println(Ethernet.localIP());
  if (Ethernet.localIP() == IPAddress({0,0,0,0})) {
    Serial.println("Local IP FAIL");
  } else {
    Serial.println("Local IP OK");
    if (c.connect(REMOTE, port)) {
      Serial.println("Remote connection OK");
    } else {
      Serial.println("Remote connection FAIL");
    }
   }
}

Para saber más sobre la comunicación Ethernet:

RS-485 (MAX485)#

RS485, también conocido como TIA-485(-A) o EIA-485, es un estándar que define las características eléctricas de los emisores y receptores usados en sistemas de comunicación serie. El PLC ESP32 ofrece RS485 half-duplex gracias al transceptor MAX485 integrado.

El MAX485 es un transceptor de bajo consumo y slew rate limitado para comunicación RS-485. Funciona con una única alimentación de +5 V y su corriente nominal es de 300 μA. Usa comunicación half-duplex para convertir niveles TTL en niveles RS-485 y alcanza una velocidad máxima de 2,5 Mbps. Con el driver desactivado, el MAX485 consume entre 120 μA y 500 μA, sin carga o a plena carga.

Si quieres saber más sobre RS485, consulta este post.

Configuración del hardware

Para usar RS485 con los PLC ESP32, revisa el interruptor inferior izquierdo de la zona A: el interruptor 3 debe estar en OFF para activar RS485. Para más información sobre los interruptores, consulta la sección Interruptores DIP .

Los pines RS485, A+ y B-, deben conectarse correctamente al equipo con el que se comunica el PLC. ¡Atención! Recuerda alimentar correctamente el PLC con una fuente de 12-24 V.

Configuración del software

Nuestro paquete de placas incluye una biblioteca RS485 para facilitar la programación. Se usa como la biblioteca Serial de Arduino, con métodos como "available()", "read()", etc.

Mira el siguiente código, que establece una comunicación half-duplex y te permite leer o enviar mensajes desde el terminal del PC.

#include "RS485.h"

void setup() {
  // Begin Serial port
  Serial.begin(9600);
  // Begin RS485 port
  RS485.begin(9600, HALFDUPLEX);
}

void loop() {
  //Send one byte for the serial, receive this byte by rs485
  if (Serial.available()){
    read_from_serial();
  }
  if (RS485.available()){
    read_from_rs485();
  }
}

static void read_from_serial(void){
  char tx = Serial.read(); //Read byte
  if (tx != '\n') Serial.println(tx); //Print the byte 
  RS485.write(tx); //Transmit by rs485
}

static void read_from_rs485(void){
  char rx = RS485.read(); //Receive the same byte
  if (rx != '\n') {
    Serial.println(rx); //Print the byte
  } 
}

RS-232 (MAX232)#

RS-232 es un estándar de transmisión de datos por comunicación serie. Define formalmente las señales usadas en la comunicación entre un DTE (Data Terminal Equipment), como un terminal informático, y un DCE (Data Circuit-terminating Equipment o Data Communication Equipment), como un módem. El PLC ESP32 incluye un transceptor MAX232 que permite comunicación full-duplex por RS232. El MAX232 es un doble emisor y doble receptor que se usa para convertir las señales RX, TX, CTS y RTS de Serial TTL a puerto serie TIA-232 (RS-232) .

Si quieres saber más sobre RS232, consulta este post.

Configuración del hardware

Para usar RS232 con los PLC ESP32, revisa el interruptor inferior izquierdo de la zona A: el interruptor 2 debe estar en OFF para activar RS232. Para más información sobre los interruptores, consulta la sección Interruptores DIP .

Los pines RS232, TX y RX, deben conectarse correctamente al equipo con el que se comunica el PLC. ¡Atención! Recuerda alimentar correctamente el PLC con una fuente de 12-24 V.

Configuración del software

Una vez hecha la configuración del hardware, puedes pasar a la configuración del software y a su uso. Primero hay que incluir la biblioteca RS232.h de nuestro paquete de placas. Después se inicializa la comunicación con "RS232.begin();". A partir de ahí ya puedes usar RS232 con las funciones "RS232.read();" y "RS232.write();".

Mira los siguientes ejemplos de lectura y escritura:

// Include Industrial Shields libraries
#include "RS232.h"

//// IMPORTANT: check switches configuration

//////////////////////////////////////////////////////////////////////////////////////////////

void setup() {

  // Begin serial port
  Serial.begin(9600);
  // Begin RS232 port
  RS232.begin(38400);

}

///////////////////////////////////////////////////////////////////////////////////////////////

void loop() {

  // Wait bytes in the serial port
  if (Serial.available()) {
    byte tx = Serial.read();

    // Echo the byte to the serial port again
    Serial.write(tx);

    // And send it to the RS-232 port
    RS232.write(tx);

  }   
 }
// Include Industrial Shields libraries
#include "RS232.h"

//// IMPORTANT: check switches configuration

//////////////////////////////////////////////////////////////////////////////////////////////

void setup() {
  // Begin serial port
  Serial.begin(9600);
  // Begin RS232 port
  RS232.begin(38400);

}

//////////////////////////////////////////////////////////////////////////////////////////////

void loop() {

  // Print received byte when available
  if (RS232.available()) {
    byte rx = RS232.read();

    // Hexadecimal representation
    Serial.print("HEX: ");
    Serial.print(rx, HEX);

    // Decimal representation
    Serial.print(", DEC: ");
    Serial.println(rx, DEC);

  } 
}

Serial TTL: niveles de 3,3 V#

Serial TTL es una interfaz de comunicación entre dos dispositivos que trabajan a baja tensión. Usa dos señales, Tx (transmisión de datos) y Rx (recepción de datos), que permiten comunicación full-duplex. Los PLC ESP32 tienen dos puertos TTL externos, Serial 1 (RX1/TX1) y Serial 2 (RX2/TX2).

Para saber más sobre la interfaz Serial TTL, visita este post del blog.

Configuración del hardware

El PLC ESP32 tiene dos puertos serie, que se activan con el interruptor inferior izquierdo de la zona A (para saber más sobre la configuración de los interruptores, consulta la sección Interruptores DIP de esta página):

  • Serial 1 (TX1, RX1): el interruptor 3 debe estar en ON.
  • Serial 2 (TX2, RX2): el interruptor 2 debe estar en ON y el interruptor 4 en OFF.

Para que la comunicación serie funcione, haz las siguientes conexiones entre el PLC y el otro equipo:

  • TX -> RX
  • RX -> TX
  • GND: ambos equipos deben compartir una masa común.

¡Atención! Los puertos serie de los PLC ESP32 trabajan a niveles de 3,3 V. Tensiones superiores pueden dañar el PLC.

Recuerda también alimentar correctamente el PLC con una fuente de 12-24 Vdc adecuada.

Configuración del software

Para usar la comunicación serie con el PLC puedes usar el objeto "Serial" de Arduino. Mira el siguiente ejemplo, que usa Serial 1 para enviar y recibir bytes entre el puerto serie USB y Serial 1. Para usar Serial 2 en lugar de Serial 1, usa el objeto "Serial2".

void setup() {
  // Initialize serial connections
  Serial.begin(9600);
  Serial1.begin(9600);
}

void loop() {
  // Read byte from Serial and send it through Serial 1
  if (Serial.available()) { // Check if there is available byte to read
    Serial1.print(Serial.read());
  }

  // Read byte from Serial 1 and send it through Serial
  if (Serial1.available()) {
    Serial.print(Serial1.read());
  }
}

I2C: pull-up a 5 V#

I2C es un protocolo de comunicación serie. Es un protocolo síncrono maestro-esclavo que usa 2 cables, uno para el reloj (SCL) y otro para los datos (SDA). El maestro controla el bus, genera la señal de reloj y usa direcciones para comunicarse con los esclavos. Es un bus muy usado en la industria, sobre todo para comunicar microcontroladores con sus periféricos en sistemas integrados, normalmente en la misma PCB. La velocidad es de 100 Kbit/s en modo estándar.

Configuración del hardware

Los PLC ESP32 tienen un puerto I2C, con los pines SCL y SDA. Puedes conectar otros dispositivos a este bus como esclavos. Al conectarlos, ten en cuenta las siguientes especificaciones:

  • El puerto I2C trabaja a 5 V. Tensiones superiores pueden dañar el PLC.
  • Los pines I2C, SCL y SDA, tienen pull-up a 5 V.

Recuerda también alimentar correctamente el PLC con una fuente de 12-24 Vdc adecuada.

Configuración del software

El I2C se usa con la biblioteca "Wire". Mira el siguiente ejemplo, que implementa un escáner I2C que busca dispositivos conectados al bus. Cuando detecta uno, lo indica en el monitor serie. Si conectas los pines I2C (SDA y SCL) a otro dispositivo, debería aparecer en el escaneo.

Antes de ejecutar el código, comprueba que el PLC está bien alimentado, que el paquete de placas "industrialshields-esp-32" está correctamente instalado en Arduino IDE y que has seleccionado el modelo de PLC correcto en el IDE.

#include "Wire.h"

void setup() {
  Serial.begin(115200);
  Wire.begin();
}

void loop() {
  byte error, address;
  int nDevices = 0;

  delay(5000);

  Serial.println("Scanning for I2C devices ...");
  for(address = 0x01; address < 0x7f; address++){
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0){
      Serial.printf("I2C device found at address 0x%02X\n", address);
      nDevices++;
    } else if(error != 2){
      Serial.printf("Error %d at address 0x%02X\n", error, address);
    }
  }
  if (nDevices == 0){
    Serial.println("No I2C devices found");
  }
}

Para saber más sobre la comunicación I2C:

SPI: niveles de 3,3 V#

La Serial Peripheral Interface (SPI) es una especificación de interfaz de comunicación serie síncrona para comunicaciones de corta distancia, sobre todo en sistemas embebidos. Los dispositivos SPI se comunican en full-duplex con una arquitectura maestro-esclavo, normalmente con un solo maestro. La comunicación SPI usa 3 pines: SCLK, MOSI y MISO. Además, se usa un pin extra por cada esclavo, llamado chip select (CS) o slave select (SS), para seleccionar el esclavo con el que se habla en el bus.

Los PLC ESP32 tienen un puerto SPI.

Configuración del hardware

Para usar el SPI, los 3 pines mencionados (SCLK, MISO, MOSI) deben estar bien conectados:

Función

Pin del PLC

Pin del ESP32

MISO

SO

GPIO 19

MOSI

SI

GPIO 23

CLOCK

SCK

GPIO 18

Además, puede que necesites un pin de chip select por cada esclavo para direccionarlo. El PLC ESP32 tiene varios GPIO que pueden cumplir esta función. Consulta la sección de GPIO de esta página para saber más sobre los pines disponibles.

¡Atención! El SPI trabaja a niveles de 3,3 V; cualquier tensión superior puede dañar el PLC.

Recuerda también alimentar correctamente el PLC con una fuente de 12-24 Vdc adecuada.

Configuración del software

El paquete de placas "industrialshields-esp32" incluye una biblioteca SPI basada en la biblioteca SPI de Arduino. Esta biblioteca permite programar el ESP32 como maestro SPI.

Este programa muestra cómo configurar el ESP32 como maestro en una comunicación SPI y enviar y recibir datos. En este caso se envía el carácter "0" y el dato recibido se guarda en la variable correspondiente (la transferencia SPI envía y recibe a la vez) y se imprime por el puerto serie.

#include "SPI.h"

// Set pin as the slave select:
const int slaveSelectPin = GPIO_0;
volatile byte receivedData;

void setup() {
  Serial.begin(9600);
  // Set the slaveSelectPin as an output:
  pinMode(slaveSelectPin, OUTPUT);
  // Initialize SPI:
  SPI.begin();
}

void loop() {
  
  SPI.beginTransaction(SPISettings(100000, MSBFIRST, SPI_MODE0));
  digitalWrite(slaveSelectPin, LOW); // Start of transmission: set chip select LOW
  receivedData = SPI.transfer('0');
  digitalWrite(slaveSelectPin, HIGH); // End of transmission: set chip select HIGH
  SPI.endTransaction();
  
  Serial.println((char)receivedData);
 
  delay(100);
}

Para saber más sobre SPI, consulta este post: Bus SPI en un PLC Arduino de Industrial Shields

Bluetooth#

Bluetooth es un estándar de tecnología inalámbrica. Se desarrolló para intercambiar datos a corta distancia y opera en el rango de 2400-2483,5 MHz, dentro de la banda ISM de 2,4 GHz. Los datos se dividen en paquetes y se intercambian por uno de los 79 canales Bluetooth definidos (cada uno con un ancho de banda de 1 MHz).

Los PLC ESP32 tienen Bluetooth gracias al microcontrolador ESP32. No hace falta ninguna configuración de hardware para usarlo; el único requisito es que el PLC esté bien alimentado con una fuente de 12-24 Vdc.

Configuración del software

Este ejemplo muestra cómo leer y enviar bytes por Bluetooth con BluetoothSerial. El puerto serie se usa para enviar y recibir datos desde el PC. Para comunicarte con el PLC por Bluetooth puedes usar una app móvil como "Serial Bluetooth Terminal": establece la conexión Bluetooth con el PLC y selecciona el dispositivo en la app.

Recuerda comprobar que el paquete de placas industrialshields-esp-32 está correctamente instalado en Arduino IDE.

#include "BluetoothSerial.h"

BluetoothSerial SerialBT;

void setup() {
  Serial.begin(115200);
  SerialBT.begin("ESP32test"); //Bluetooth device name
  Serial.println("The device started, now you can pair it with bluetooth!");
}

void loop() {
  if (Serial.available()) {
    SerialBT.write(Serial.read());
  }
  if (SerialBT.available()) {
    Serial.write(SerialBT.read());
  }
  delay(20);
}

Más ejemplos sobre Bluetooth: Interactuar con el PLC industrial M-Duino WiFi/BLE por Bluetooth

Wi-Fi#

Igual que otras conexiones inalámbricas como Bluetooth, Wi-Fi es una tecnología de transmisión por radio basada en un conjunto de estándares que permiten comunicaciones rápidas y seguras entre una gran variedad de dispositivos digitales, puntos de acceso y hardware. Permite que los dispositivos con Wi-Fi accedan a Internet sin cables y puede funcionar a corta y larga distancia, cerrada y protegida o abierta y libre. Todo esto hace que Wi-Fi sea muy versátil y fácil de usar.

Los PLC ESP32 tienen Wi-Fi gracias al microcontrolador ESP32. No hace falta ninguna configuración de hardware para usarlo; el único requisito es que el PLC esté bien alimentado con una fuente de 12-24 Vdc.

Configuración del software

Mira este sketch de ejemplo para configurar una conexión Wi-Fi. El código usa la biblioteca "WiFi.h" para conectar el ESP32 a la red Wi-Fi que quieras e indica en el monitor serie la dirección IP usada.

Recuerda comprobar que el paquete de placas industrialshields-esp-32 está correctamente instalado en Arduino IDE y cambia las variables ssid y password por los datos de tu red Wi-Fi.

#include "WiFi.h"

const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

void setup() {
  Serial.begin(115200); 
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(WiFi.status());
  }
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

void loop() {

}

Para saber más sobre la comunicación Wi-Fi:

Funciones adicionales: RTC, doble núcleo, FreeRTOS, microSD, GPIO

Reloj en tiempo real (DS1307)#

RTC significa Real Time Clock (reloj en tiempo real), un dispositivo electrónico que mide el paso del tiempo. Aunque se puede llevar la hora sin RTC, usar uno tiene ventajas como:

  • Mantener la hora sin tener que volver a ajustarla tras un reinicio, un apagado, etc.
  • Bajo consumo (importante cuando funciona con alimentación alternativa).
  • Libera al sistema de control principal para tareas críticas en tiempo.
  • A veces es más preciso que otros métodos.

El PLC ESP32 incluye un módulo RTC DS1307, que se comunica con el microcontrolador ESP32 por I2C. El DS1307 es un reloj y calendario serie en tiempo real de bajo consumo, totalmente en decimal codificado en binario (BCD), con 56 bytes de NV SRAM. Proporciona segundos, minutos, horas, día de la semana, fecha, mes y año.

Para alimentar el RTC cuando el PLC no está conectado, el PLC incluye una pila de botón de litio de 3,3 V que alimenta el RTC.

No hace falta ninguna configuración de hardware para usar el RTC; solo es necesario que el PLC esté bien alimentado con una fuente de 12-24 Vdc y que tenga una pila de botón de litio para mantener la hora cuando el PLC esté sin alimentación.

Configuración del software

Para trabajar con el RTC puedes usar la biblioteca RTC incluida en nuestro paquete de placas. Mira el siguiente ejemplo, que lee la hora del RTC y la muestra en el monitor serie.

Recuerda comprobar que el paquete de placas industrialshields-esp-32 está correctamente instalado en Arduino IDE.

// RTC library example
// by Industrial Shields
#include "RTC2.h"
////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
  Serial.begin(9600L);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void loop() {
  if (!RTC.read()) {
    Serial.println("Read date error: is time set?");
    }
     else {
    Serial.print("Time: ");
    Serial.print(RTC.getYear());
    Serial.print("-");
    Serial.print(RTC.getMonth());
    Serial.print("-");
    Serial.print(RTC.getMonthDay());
    Serial.print(" ");
    Serial.print(RTC.getHour());
    Serial.print(":");
    Serial.print(RTC.getMinute());
    Serial.print(":");
    Serial.print(RTC.getSecond());
    Serial.print(" (");
    Serial.print(RTC.getTime());
    Serial.println(")");
  }
  delay(1000);
}

Doble núcleo del ESP32#

El controlador lógico programable ESP32 incluye 2 microprocesadores Xtensa LX6 de 32 bits. Cuando ejecutamos código desde Arduino IDE, por defecto se ejecuta en el núcleo 1, como se puede comprobar con este sencillo programa:

void setup() {
	Serial.begin(115200);
	Serial.print("setup() running on core ");
	Serial.println(xPortGetCoreID());
}

void loop() {
	Serial.print("loop() running on core ");
	Serial.println(xPortGetCoreID());
}

Sin embargo, también podemos usar el segundo núcleo para ganar rendimiento y eficiencia. Para trabajar con el segundo núcleo solo hay que definir una segunda función de bucle, llamada "loop1()". El código de esta función lo ejecuta el núcleo 0, mientras que el código de la función habitual "loop()" lo ejecuta el núcleo 1. Así podemos definir tareas distintas para cada núcleo:

void setup() {
  // Setup code
}
void loop() {
  // Core 1 tasks
}
void loop1() {
  // Core 0 tasks
}

Organizando el programa de esta forma aprovechamos los 2 núcleos del ESP32. Eso sí, al usar el doble núcleo hay que tener en cuenta que pueden aparecer problemas de concurrencia: por ejemplo, si los dos intentan usar el Serial a la vez. Para evitarlos se pueden usar mecanismos como los semáforos.

Consulta este post del blog para saber más sobre el doble núcleo del ESP32.

Tareas de FreeRTOS#

FreeRTOS es un sistema operativo en tiempo real (RTOS) de código abierto muy popular, diseñado para microcontroladores y pequeños sistemas embebidos. Ofrece un núcleo de sistema operativo ligero, escalable y portable, junto con varios componentes de software y herramientas para el desarrollo de aplicaciones embebidas. FreeRTOS se puede usar con Arduino IDE en placas ESP32 para añadir funciones de sistema operativo en tiempo real a tus proyectos.

Con FreeRTOS puedes crear varias tareas en tu sketch, cada una con su prioridad, y usar mecanismos de sincronización como semáforos y exclusión mutua para coordinarlas. Es útil en aplicaciones en tiempo real que requieren una temporización y una coordinación de tareas precisas.

No hace falta incluir ninguna biblioteca para usar FreeRTOS con los PLC basados en ESP32, porque está integrado en ESP-IDF como componente (Arduino se apoya en ESP-IDF).

Una de las funciones más útiles de FreeRTOS son las tareas, fragmentos de código planificables. Para crear una tarea se usa la función xTaskCreate() .

Configuración del software

Este programa crea 2 tareas que ponen periódicamente en HIGH y en LOW dos salidas digitales.

TaskHandle_t Task1;
TaskHandle_t Task2;

void setup() {
  Serial.begin(115200); 
  pinMode(Q0_0,OUTPUT);
  pinMode(Q0_1,OUTPUT);

  xTaskCreate(Task1code,"Task1",10000,NULL,1,&Task1);                         
  delay(500); 

  xTaskCreate(Task2code,"Task2",10000,NULL,1,&Task2);          
  delay(500); 
}

void Task1code( void * parameter ){
  Serial.print("Task1 is running on core ");
  Serial.println(xPortGetCoreID());

  for(;;){
    digitalWrite(Q0_0, HIGH);
    delay(500);
    digitalWrite(Q0_0, LOW);
    delay(500);
  } 
}

void Task2code( void * parameter ){
  Serial.print("Task2 is running on core ");
  Serial.println(xPortGetCoreID());

  for(;;){
    digitalWrite(Q0_1, HIGH);
    delay(1000);
    digitalWrite(Q0_1, LOW);
    delay(1000);
  }
}

void loop() {}

Tarjeta microSD#

Las tarjetas Secure Digital (SD) son dispositivos de almacenamiento no volátil que usan tecnología de memoria flash. Pensadas para dispositivos electrónicos portátiles, las tarjetas SD son una solución fiable y compacta para almacenar datos.

El PLC ESP32 incorpora una ranura para tarjeta SD con las siguientes especificaciones:

  • Ranura microSD.
  • Hasta 32 GB de almacenamiento (se pueden usar tarjetas de mayor capacidad, pero solo serán accesibles y utilizables los primeros 32 GB).
  • Sistemas de archivos admitidos: FAT32 y FAT16.

La ranura SD se comunica con el ESP32 por SPI y no requiere ninguna configuración de hardware. Recuerda alimentar el PLC con una fuente de 12-24 Vdc adecuada.

Configuración del software

El paquete de placas "industrialshields-esp32" incluye una biblioteca SD que facilita su uso. Mira el siguiente ejemplo, que inicializa la tarjeta SD y muestra el contenido de su directorio raíz por el puerto serie.

#include "SD.h"

File root;

void setup() {
 // Open serial communications and wait for port to open:
  Serial.begin(115200);
  // wait for Serial Monitor to connect. Needed for native USB port boards only:
  while (!Serial);

  Serial.print("Initializing SD card...");

  int SS = SD.begin(13);
  if (!SS) {
    Serial.println("initialization failed. Things to check:");
    Serial.println("1. is a card inserted?");
    Serial.println("2. is your wiring correct?");
    Serial.println("3. did you change the chipSelect pin to match your shield or module?");
    Serial.println("Note: press reset or reopen this serial monitor after fixing your issue!");
    while (true);
  } else {
    Serial.println(SS, DEC);
  }

  Serial.println("initialization done.");

  root = SD.open("/");

  printDirectory(root, 0);

  Serial.println("done!");
}

void loop() {
  // nothing happens after setup finishes.
}

void printDirectory(File dir, int numTabs) {
  while (true) {

    File entry =  dir.openNextFile();
    if (! entry) {
      // no more files
      break;
    }
    for (uint8_t i = 0; i < numTabs; i++) {
      Serial.print('\t');
    }
    Serial.print(entry.name());
    if (entry.isDirectory()) {
      Serial.println("/");
      printDirectory(entry, numTabs + 1);
    } else {
      // files have sizes, directories do not
      Serial.print("\t\t");
      Serial.println(entry.size(), DEC);
    }
    entry.close();
  }
}

Pines GPIO: 3,3 V y 5 V#

El PLC da acceso directo a algunos pines GPIO del ESP32, que se pueden usar para distintas tareas. Según el pin, trabajan a 3,3 V o a 5 V. ¡Atención! Usar una tensión superior a la que tolera el pin puede dañar el PLC. Consulta las siguientes tablas para ver cada pin disponible.

Pines de 3,3 V

Borne del PLC
Pin del ESP32
TX1
GPIO 17
RX1
GPIO 16
VN
SENS VN (GPIO 39)
VP
SENS VP (GPIO 36)
SO
GPIO 19
SI
GPIO 23
SCK
GPIO 18
  • Serial 1: RX1/TX1: los pines de Serial1 también pueden funcionar como pines de 3,3 V.
  • Vp/Vn: estos pines solo pueden funcionar como entradas de 3,3 V.
  • SPI: MISO/MOSI/SCK: estos pines también pueden funcionar como pines de 3,3 V, pero solo si no se van a usar Ethernet ni SPI. Como Ethernet usa el SPI para comunicarse con el ESP, no se pueden usar a la vez la conexión Ethernet y estos pines como GPIO.

Atención: para usar los pines serie como GPIO hay que configurar los interruptores correspondientes, así que comprueba que Serial 1 está seleccionado (consulta la sección de hardware para más detalles).

Pines de 5 V

Borne del PLC
Pin del ESP32
SCL
GPIO 22
SDA
GPIO 21
GPIO0
GPIO 0
  • Pines I2C: SDA/SCL: el protocolo I2C está pensado para trabajar con resistencias de pull-up, que ya incluye la placa. Por eso solo se pueden usar en configuración pull-up: leen 5 V cuando no hay nada conectado.
  • GPIO 0: el pin GPIO_0 trabaja a 5 Vdc y se puede usar como entrada o salida digital.

Proyectos y recursos del PLC ESP32

Casos de estudio del PLC ESP32#

Consulta más proyectos en Proyectos con PLC ESP32 y en la biblioteca de casos de estudio.

Cursos, ejemplos y documentos#

Preguntas frecuentes sobre el PLC ESP32#

¿Qué es un PLC ESP32?

Un PLC ESP32 es un controlador industrial basado en tecnología ESP32 con Wi-Fi y Bluetooth nativos en todos los modelos. Combina control determinista con conectividad inalámbrica y se programa con Arduino IDE.

¿Cómo se programa el PLC ESP32?

Con Arduino IDE y el paquete de placas industrialshields-esp-32, en C y C++. Cada borne tiene su propio nombre en el código: la entrada I0.7 se lee como I0_7.

¿Qué fuente de alimentación necesita el PLC ESP32?

Una fuente externa de 12 a 24 Vdc de 2 A como mínimo. La alimentación por USB sola no basta para que el PLC funcione correctamente.

¿Qué comunicaciones admite el PLC ESP32 industrial?

Wi-Fi y Bluetooth en todos los modelos, además de Ethernet (W5500), RS-485, RS-232, Serial TTL, I2C y SPI. Modbus RTU, Modbus TCP y MQTT están disponibles mediante bibliotecas.

¿Cuáles son los rangos de las E/S analógicas?

Las entradas analógicas leen de 0 a 10 Vdc con una resolución de 11 bits (0 a 2047). Las salidas analógicas entregan de 0 a 10 Vdc con una resolución de 12 bits.

¿Puedo usar los dos núcleos del ESP32?

Sí. La función loop() se ejecuta en el núcleo 1 y una segunda función loop1() se ejecuta en el núcleo 0. Las tareas de FreeRTOS también están disponibles sin bibliotecas adicionales.

Ninguna sección coincide con tu búsqueda. Prueba con el nombre de un pin, un protocolo o un componente.