Arduino IDE

Arduino IDE es la plataforma original para programar placas Arduino. Esta aplicación multiplataforma está disponible en Windows, macOS y Linux bajo la Licencia Pública General de GNU. Arduino IDE soporta estructuración de código C y C++. Para programar los PLCs basados en ESP32 en este entorno, Industrial Shields proporciona un paquete de placas con las librerías y herramientas necesarias.

Recomendamos utilizar el IDE Arduino heredado (1.8.X) para programar PLCs basados en ESP32, aunque podría utilizarse otro software compatible con ESP. El IDE Arduino 1.8.X se puede descargar desde este link. Después de descargar e instalar el IDE de Arduino, instale el paquete de placas industrialshields-esp-32 dentro del IDE. Esto se puede hacer siguiendo este tutorial y seleccionando el paquete industrialshields-esp-32 en el paso número 6.

Fuente de alimentación

Interruptores DIP

Los PLCs basados en ESP32 tienen algunos interruptores que se pueden utilizar para configurar ciertas funcionalidades del PLC. En esta sección se explica cómo utilizarlos adecuadamente. Para diferenciar las distintas partes del PLC y ubicar cada interruptor en consecuencia, se utilizará la siguiente nomenclatura:

En cada zona hay uno o varios interruptores, que se utilizan para configurar algunas de las funcionalidades del PLC. En las tablas siguientes se indica la finalidad de cada interruptor y cómo configurarlos. 

Zona A: interruptor inferior izquierdo

1. No se utiliza.
2. Este interruptor se utiliza para seleccionar entre RS232, Serial2 y EXP2 (Escudo de expansión 2), utilizado junto con el interruptor 4. RS232 se selecciona cuando el interruptor está en OFF. Cuando está en ON, Serial2 o EXP2 estarán activos, dependiendo del valor del interruptor 4 (ver configuración del interruptor 4).
3. Este interruptor se utiliza para seleccionar entre RS485 (OFF) y Serial1 (ON).
4. Permite seleccionar entre EXP2 (ON) y Serial2 (OFF) cuando el interruptor 2 está en ON.

Zona B, C y D: Interruptor analógico

Estos conmutadores se utilizan para elegir entre salida digital o analógica, según la tabla anterior. Si está en OFF, sólo estará disponible la salida analógica correspondiente. Si está en ON, sólo estará disponible la salida digital correspondiente. Los conmutadores se comportan de la misma forma en las zonas B, C y D, siendo el valor "X" diferente según la zona:

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

Consumo de energía

Este informe explora cómo consumen energía los distintos modelos de PLC ESP32 en situaciones de inactividad y de alto rendimiento. Comprender estos patrones es crucial para optimizar la eficiencia en aplicaciones industriales.

Reposo

En este escenario, el PLC ESP32 está encendido, con todos los pines y comunicaciones apagados y utilizando una fuente de alimentación de 24V. Esta prueba mide el consumo de energía de referencia cuando el dispositivo está inactivo y no participa activamente en ninguna tarea de procesamiento o salida.

Todas las salidas HIGH

Para esta prueba, el PLC ESP32 está configurado para establecer todos sus pines de salida a un estado alto utilizando una fuente de alimentación de 24V. Sin embargo, las salidas no están conectadas, lo que significa que el consumo de energía variará en función de la corriente consumida por el dispositivo conectado a cada salida.

Entradas analógicas

La entrada analógica proporciona una forma de leer los niveles de tensión analógica, codificando el valor con un número de N bits. Las entradas analógicas en el PLC basado en ESP32 utilizan el GND interno como referencia (el mismo que la fuente de alimentación). Las entradas analógicas en estos PLC tienen las siguientes especificaciones:

• Rango de voltaje: de 0 a 10 Vdc.
• Resolución: 11 bits, lo que significa que los valores de lectura pueden oscilar entre 0 y 2047. 
  

Además, las entradas analógicas también pueden utilizarse como entradas digitales no aisladas que toleran hasta 24Vdc. Para ello, consulte el apartado de entradas digitales. Las entradas analógicas son las comprendidas entre IX.7 y IX.12, siendo X 0, 1 o 2 según la zona. Puede identificar las entradas analógicas de su equipo con el siguiente símbolo:

0V - 10Vdc Entrada analógica

  

El siguiente diagrama ilustra las conexiones necesarias para utilizar correctamente una entrada analógica (cuando se utiliza como digital, la entrada puede tolerar hasta 24V):

Configuración del software

Para utilizarlas, las entradas analógicas deben configurarse en la parte de configuración del código, como se hace habitualmente en las placas Arduino comunes. Luego se pueden leer usando 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));
}

El siguiente post también puede ser de interés: Conocimientos básicos de las entradas analógicas de un PLC industrial.

Entradas digitales

Las entradas digitales se utilizan para capturar señales que existen en uno de dos estados: high o low, verdadero o falso, etc. Las entradas digitales del PLC ESP32 interpretan como altos valores de 5 Vdc o superiores, hasta 24 Vdc, mientras que valores inferiores a 5V se interpretan como bajos. Hay 2 tipos de entradas que se pueden utilizar como entrada digital:

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

Puedes identificarlos con los siguientes símbolos:

5V - 24V entrada aislada

 

5V - 24V entrada no aislada

 

Los siguientes diagramas ilustran las conexiones necesarias para utilizar correctamente ambas entradas como digitales:

Configuración del software

Para utilizarlas, las entradas digitales deben configurarse en la parte de configuración del código, como se hace habitualmente en las placas Arduino comunes. Luego se pueden leer usando 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));
}

Las siguientes entradas profundizan en este tema: Conceptos básicos sobre las entradas digitales de un controlador industrial, Entradas digitales PNP en PLC industriales.

Entradas de interrupción

Algunas de las entradas digitales del PLC ESP32 tienen capacidad de interrupción, lo que significa que pueden utilizarse con ISR (rutina de servicio de interrupción) para desencadenar la ejecución de determinado código cuando se detecta un evento (un cambio de estado en el pin). Hay dos pines de este tipo por zona: IX.5 y IX.6. Se utilizan y conectan como entradas digitales aisladas normales, y las interrupciones se programan mediante software.

Configuración del software

Este es un ejemplo de cómo utilizar 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 utilizar entradas de interrupción con placas Arduino industriales

Salidas analógicas

Una salida analógica proporciona una tensión determinada por un valor digital con un número de N bits. Los PLCs ESP32 pueden tener entre 3 y 9 salidas analógicas, dependiendo del modelo. Éstas se etiquetan como AX.X, y deben seleccionarse mediante un interruptor DIP para poder utilizarse (consulte la sección de hardware en esta página para obtener más información).  Las salidas analógicas del PLC ESP32 tienen las siguientes especificaciones:

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

Las salidas analógicas tienen un pin GND externo compartido, que debe conectarse para establecer la referencia. Este símbolo identifica las salidas analógicas, y el siguiente diagrama ilustra cómo conectarlas:

0 - 10V salida analógica

Configuración del software

El procedimiento para programar las salidas analógicas es el mismo que Arduino normal: en primer lugar, el modo de pin se debe establecer en "OUTPUT" en la configuración del código, y luego la salida se puede escribir utilizando "analogWrite()". Las salidas analógicas pueden ser referenciadas por su nombre y usando un "_" en lugar del ".". Por ejemplo, A0.5 se utiliza como A0_5:

void setup()
{
    pinMode(A0_0,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

Las salidas digitales del ESP32 pueden proporcionar un valor bajo (0 Vcc) o alto (hasta 24 Vcc). Estas salidas se etiquetan como QX.X, y se pueden identificar con el siguiente símbolo.

El valor alto de salida puede oscilar entre 5 y 24 Vcc. Esta tensión debe ajustarse mediante dos pines situados junto a las salidas: QVdc y COM(-). Por ejemplo, si desea ajustar la salida a 24V, el pin QVdc debe conectarse a 24V y el pin COM(-) a GND. El siguiente diagrama ilustra un ejemplo de conexión:

Salida digital (PWM opcional)

Configuración del software

Las salidas digitales deben ser configuradas en la parte de setup del código como se hace habitualmente en las placas Arduino comunes, usando primero "pinMode()" para establecerlo como "OUTPUT", y "digitalWrite()" para cambiar el valor de salida. Mira el siguiente ejemplo:

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

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

Puede obtener más información sobre las salidas digitales en este post: Conceptos básicos sobre las salidas digitales de un PLC industrial.

Salida PWM

En los PLCs basados en ESP32, todas las salidas digitales se pueden utilizar como salidas PWM.

El valor alto de salida puede oscilar entre 5 y 24 Vcc. Al igual que cuando se utilizan como simples salidas digitales, esta tensión debe ajustarse mediante dos pines situados junto a las salidas: QVdc y COM(-). Por ejemplo, si desea ajustar la salida a 24V, el pin QVdc debe conectarse a 24V y el pin COM(-) a GND. El siguiente diagrama ilustra un ejemplo de conexión.

Un tutorial de ejemplo sobre cómo programar el PLC para utilizar las salidas PWM se puede encontrar en este sitio web.

Salida con capacidad PWM

Salida relé

Un relé es un interruptor electromagnético controlado por una señal eléctrica. En las unidades Industrial Shields estos dispositivos ya están integrados en sus placas. Los relés incluidos en el PLC ESP32 tienen las siguientes especificaciones:

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

​

Cada salida de relé tiene dos terminales, y está etiquetada como RX.X. El siguiente diagrama ilustra las conexiones:

Configuración del software

Las salidas de relé deben configurarse en la parte de configuración del código, utilizando funciones de Arduino, y se controlan como si fueran salidas digitales. Las salidas se pueden referenciar por el nombre que aparece en la serigrafía: R0.1 por ejemplo se utiliza como R0_1. Compruebe el siguiente ejemplo. Cuando la salida está en "HIGH", el real i encendido, lo que significa que el interruptor se cierra, mientras que cuando está en "LOW" el interruptor está 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: Conocimiento básico de los relés internos de un PLC industrial.

Ethernet

Ethernet es la tecnología más utilizada 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 habitación, una oficina o un edificio. Se utiliza en contraste con 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 a través de una LAN. Técnicamente se denomina protocolo IEEE 802.3. El protocolo ha evolucionado y mejorado con el tiempo hasta transferir datos a una velocidad de un gigabit por segundo.

Los autómatas ESP32 incorporan un puerto Ethernet, utilizando el controlador W5500, que se comunica con el ESP32 mediante SPI. El W5500 es un controlador Ethernet embebido TCP/IP cableado que facilita la conexión a Internet de los sistemas embebidos. Este chip permite a los usuarios tener conectividad a Internet en sus aplicaciones mediante el uso de un solo chip en el que la pila TCP / IP, 10/100 Ethernet MAC y PHY están incrustados. Con este chip, los usuarios pueden integrar Ethernet en sus aplicaciones.  

Configuración del software

El paquete de placas Industrial Shields incluye una librería "Ethernet", destinada a facilitar el uso de este protocolo. Se incluyen varios ejemplos con la librería, puedes comprobarlos yendo a Archivo > Ejemplos > Ethernet dentro del IDE de Arduino.

Eche también un vistazo al siguiente programa. Antes de ejecutar el código, asegúrese de que su PLC está alimentado correctamente, confirme que el cable Ethernet está bien conectado a su dispositivo y asegúrese de que el paquete de la placa "industrialshields-esp-32" está correctamente instalado en su IDE Arduino. Este código sirve como herramienta de diagnóstico para asegurar el correcto funcionamiento del puerto Ethernet. Establece una conexión a "www.google.com" a través del controlador W5500 utilizando la configuración IP 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:

• Peticiones Http a un servidor utilizando un PLC basado en Arduino
• Cliente MQTT para PLC basado en Arduino como módulo de E/S
• Cómo utilizar Modbus TCP Slave Library con un controlador PLC Arduino
• Modbus TCP Maestro con Industrial Arduino y ESP32 PLCs
• Prueba Ethernet en Arduino o ESP32 PLC
  

RS-485

RS485, también conocido como TIA-485(-A), EIA-485, es un estándar que define las características eléctricas de los controladores y receptores para su uso en sistemas de comunicaciones en serie. El PLC ESP32 incluye capacidades RS485 half-duplex, gracias al chip transceptor MAX485 incorporado.

El MAX485 es un transceptor de baja potencia y slew-rate limitado utilizado para la comunicación RS-485. Funciona con una sola fuente de alimentación de +5 V y la corriente nominal es de 300 μA. Al adoptar la comunicación semidúplex para implementar la función de convertir el nivel TTL en nivel RS-485, puede alcanzar una velocidad de transmisión máxima de 2,5 Mbps. El transceptor MAX485 consume una corriente de alimentación de entre 120μA y 500μA en condiciones sin carga o con carga completa cuando el controlador está desactivado.

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

Configuración del hardware

Para utilizar el RS485 con los PLCs ESP32, compruebe el interruptor de la zona A inferior izquierda: el interruptor número 3 debe estar en OFF para activar el RS485. Para más información sobre los interruptores, consulte la sección "Instalación inicial - Hardware" en esta página.

Los pines RS485, A+ y B- deben estar correctamente conectados al dispositivo con el que se comunica el PLC. Atención. Recuerde alimentar correctamente el PLC con una fuente de alimentación de 12-24V.

Configuración del software

Nuestro paquete de placas incluye una librería RS485 para facilitar la programación. Esta librería se utiliza como la librería serie de Arduino, con métodos como "available()", "read()", etc.

Compruebe el siguiente código, que establece una comunicación half duplex y permite al usuario 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
  } 
}

RS232

RS-232 es una norma para la transmisión de datos por comunicación serie. Define formalmente las señales utilizadas en la comunicación entre DTE (Data Terminal Equipment), como un terminal de ordenador, y DCE (Data Circuit-terminating Equipment o Data Communication Equipment), como un módem. El PLC ESP32 incluye un chip transceptor MAX232, que permite la comunicación full-duplex a través de RS232. El MAX232 es un transmisor/receptor dual que se utiliza para convertir las señales RX, TX, CTS, RTS, convirtiendo las señales del puerto serie TTL a TIA-232 (RS-232).

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

Configuración del hardware 

Para utilizar el RS232 con los PLCs ESP32, compruebe el interruptor de la zona A, abajo a la izquierda: el interruptor número 2 debe estar en OFF para activar el RS232. Para más información sobre los interruptores, consulte la sección "Instalación inicial - Hardware" en esta página.

Los pines RS232, TX y RX deben estar correctamente conectados al dispositivo con el que se comunica el PLC. Atención. Recuerde alimentar correctamente el PLC con una fuente de alimentación de 12-24V.

Configuración del software

Una vez realizada la configuración del hardware, se puede proceder a la configuración del software y su uso. En primer lugar, es necesario incluir la librería RS232.h proporcionada por nuestro paquete de placas. Luego, se debe inicializar la comunicación con "RS232.begin(<baudrate>);". Después de esto RS232 ya se puede utilizar con las funciones "RS232.read();" y "RS232.write();". 

Comprueba 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

Serial TTL es una interfaz de comunicación entre dos dispositivos que funcionan a bajo nivel de tensión. Se utilizan dos señales: Tx (Transmitir Datos) y Rx (Recibir Datos), que permiten la comunicación full-duplex. Los PLCs ESP32 tienen dos puertos TTL externos, Serial 1 (RX1/TX1) y Serial 2 (RX2/TX2).

Para saber más sobre la interfaz TTL serie, visite este blog.

Configuración del hardware 

El PLC ESP32 dispone de dos puertos serie, que deben activarse mediante el interruptor de la zona A inferior izquierda (para saber más sobre la configuración del interruptor, consulte la sección "Instalación inicial - Hardware" de esta página):

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

Para que la comunicación serie funcione, debe realizar las siguientes conexiones entre el PLC y el otro dispositivo:

• TX -> RX
• RX -> TX
• GND, ambos dispositivos deben compartir puntos en común.

Atención! Los puertos serie de los PLCs ESP32 funcionan a niveles de 3,3V. Niveles de voltaje más altos podrían dañar el PLC. 

Además, recuerde alimentar correctamente el PLC con una fuente de alimentación adecuada de 12-24 Vdc.

Configuración del software

Para utilizar la comunicación Serial con el PLC, se puede utilizar el objeto "Serial" de Arduino. Compruebe el siguiente ejemplo, que utiliza el Serial 1, para enviar y recibir bytes utilizando el puerto serie USB y el Serial 1. Para utilizar el Serial 2 en lugar del 1, se debe utilizar 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

I2C es un protocolo de comunicaciones serie. Es un protocolo síncrono maestro-esclavo y se utilizan 2 cables, uno para el reloj (SCL) y otro para los datos (SDA). El maestro controla el bus y crea la señal de reloj, y utiliza el direccionamiento para comunicarse con los esclavos. Es un bus muy utilizado en la industria, principalmente para comunicar microcontroladores y sus periféricos en sistemas integrados, normalmente ubicados en la misma placa de circuito impreso. La velocidad es de 100 Kbit/s en modo estándar..

Configuración del hardware 

Los PLCs ESP32 tienen un puerto I2C, con los pines SCL y SDA. A este bus se pueden conectar otros dispositivos como esclavos. Cuando conecte otros dispositivos, tenga en cuenta las siguientes especificaciones:

• El puerto I2C funciona a 5V. Niveles de tensión superiores podrían dañar el PLC. 
• Los pines I2C, SCL y SDA, se ponen a 5V.

Además, recuerde alimentar correctamente el PLC con una fuente de alimentación adecuada de 12-24 Vdc.

Configuración del software

El I2C se puede utilizar con la librería "Wire". Comprueba el siguiente ejemplo que implementa un escáner I2C que busca en el bus cualquier dispositivo conectado. Cuando un dispositivo es detectado, será reportado al monitor serie. Ten en cuenta que si conectas los pines I2C (SDA y SCL) a otro dispositivo, éste debería aparecer en el escáner.

Antes de ejecutar el código, asegúrese de que su PLC está correctamente alimentado, compruebe que el paquete de la placa "industrialshields-esp-32" está correctamente instalado en su IDE Arduino y que ha seleccionado el modelo correcto de PLC en su 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:

• Bus I2C en PLC Arduino para automatización industrial
• Cómo configurar I2C externo en Arduino industrial o PLC basado en ESP32
  

SPI

La Interfaz Periférica Serie (SPI) es una especificación de interfaz de comunicación serie síncrona utilizada para la comunicación a corta distancia, principalmente en sistemas embebidos. Los dispositivos SPI se comunican en modo dúplex completo utilizando una arquitectura maestro-esclavo, normalmente con un único maestro. En la comunicación SPI se utilizan 3 pines: SCLK, MOSI, MISO. Además, se utiliza un pin adicional para cada esclavo, llamado chip select (CS) o slave select (SS) para seleccionar el esclavo con el que se está hablando en el bus.

Los ESP32PLC disponen de un puerto SPI.

Configuración del hardware

Para utilizar el SPI, los 3 pines de mención (SCLK, MISO, MOSI) deben estar correctamente conectados:

Además, puede ser necesario utilizar un pin de selección de chip para cada esclavo con el fin de direccionarlo. El PLC ESP32 tiene algunos GPIO que se pueden utilizar para cumplir esta función. Compruebe la función GPIO en esta página para saber más sobre los pines disponibles.

Atención! El SPI funciona a niveles de tensión de 3,3V, cualquier tensión superior podría dañar el PLC.

Además, recuerde alimentar correctamente el PLC con una fuente de alimentación adecuada de 12-24 Vdc.

Configuración del software

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

Este programa muestra cómo configurar el ESP32 como maestro en la comunicación SPI, y enviar y recibir datos. En este caso se envía el carácter "0", y los datos recibidos se almacenan en la variable correspondiente (la transferencia SPI se basa en un envío y recepción simultáneos) y se imprimen a través del 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 consulte el siguiente post: Bus SPI en PLC Arduino desde Industrial Shields

Bluetooth

Bluetooth es un estándar tecnológico inalámbrico. Se desarrolló como una forma de intercambiar datos a corta distancia y funciona en el rango de 2400-2483,5 MHz dentro de la banda de frecuencia ISM de 2,4 GHz. Los datos se dividen en paquetes y se intercambian a través de uno de los 79 canales Bluetooth diseñados (cada uno de ellos con un ancho de banda de 1 MHz). 

Los PLC ESP32 tienen capacidades Bluetooth gracias al microcontrolador ESP32. No es necesaria ninguna configuración de hardware para poder utilizarlo, el único requisito es que el PLC esté correctamente alimentado mediante una fuente de alimentación de 12-24Vdc.

Configuración del software

Este ejemplo muestra como leer bytes y enviar bytes a través de Bluetooth usando BluetootSerial. El puerto serie se utiliza para enviar y recibir datos desde el PC. Para comunicarse con el PLC a través de Bluetooth se puede utilizar una aplicación móvil como "Serial Bluetooth Terminal". Para ello, establece la conexión Bluetooth con el PLC y selecciona el dispositivo en la app.

Recuerde que debe asegurarse de que tiene el paquete de la placa industrialshields-esp-3 correctamente instalado en su IDE de Arduino.

#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);
}

Para ver más ejemplos sobre la comunicación Bluetooth: Interactúa con el PLC industrial M-Duino WiFi/BLE a través de Bluetooth 

Wi-Fi

Al igual que otros tipos de conexión inalámbrica como Bluetooth, Wi-Fi es una tecnología de transmisión por radio basada en un conjunto de normas que permite comunicaciones seguras y de alta velocidad entre una amplia variedad de dispositivos digitales, puntos de acceso y hardware. Hace posible que los dispositivos con capacidad Wi-Fi accedan a Internet sin necesidad de cables y puede funcionar en distancias cortas y largas, estar bloqueada y protegida, o abierta y libre. Todo esto hace que Wi-Fi sea realmente versátil y fácil de usar.

Los PLC ESP32 tienen capacidades Wi-Fi gracias al microcontrolador ESP32. No es necesaria ninguna configuración de hardware para poder utilizarlo, el único requisito es que el PLC esté correctamente alimentado mediante una fuente de alimentación de 12-24Vdc.

Configuración del software

Echa un vistazo a este sketch de ejemplo para saber cómo configurar una conexión Wi-Fi. Este código utiliza la librería "WiFi.h" para conectar el ESP32 al Wi-Fi deseado. Informa al monitor serie de la dirección IP utilizada para conectar. 

Recuerde que debe asegurarse de tener el paquete de la placa industrialshields-esp-3 correctamente instalado en su IDE Arduino, y asegúrese de cambiar las variables ssid y password a las configuraciones Wi-Fi que desee.

#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: 

• Cómo conectar tu PLC basado en ESP32 a Wi-Fi
• ESP32 WiFi / Bluetooth
• Cómo trabajar con el módulo Wi-Fi 5GHz del ESP32

RTC

RTC son las siglas de Real Time clock (reloj en tiempo real), un dispositivo electrónico que mide el paso del tiempo. Aunque se puede medir el tiempo sin un RTC, utilizar uno tiene ventajas como:

• Mantener la hora sin necesidad de volver a ajustarla tras un reinicio, apagado, etc.
  
• Bajo consumo de energía (importante cuando se funciona con energía alternativa.
• Libera el sistema de control principal para tareas en las que el tiempo es un factor crítico.
• 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 mediante I2C. El reloj en tiempo real en serie DS1307 es un reloj/calendario de baja potencia, con codificación decimal binaria completa (BCD), que incluye 56 bytes de SRAM NV. Proporciona información de segundos, minutos, horas, día, 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 puede utilizarse para alimentar el RTC.

No es necesaria ninguna configuración de hardware para utilizar el RTC, el único requisito es que el PLC esté correctamente alimentado utilizando una fuente de alimentación de 12-24Vdc, y que tenga una pila de litio de botón para mantener la hora cuando el PLC no tenga alimentación.

Configuración del software

La librería RTC, incluida en el paquete de nuestras placas, puede usarse para interactuar con el RTC. Comprueba el siguiente ejemplo de código donde se lee la hora desde el RTC y se imprime en el monitor serie. 

Recuerde que debe asegurarse de que tiene el paquete de la placa industrialshields-esp-3 correctamente instalado en su IDE de Arduino.

// 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);
}

ESP32 Doble núcleo

El controlador lógico programable ESP32 incluye 2 microprocesadores Xtensa LX6 de 32 bits. Cuando ejecutamos código en Arduino IDE, por defecto, se ejecuta en el núcleo 1, como podemos 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 utilizar el segundo núcleo, para mejorar el rendimiento y la eficiencia. Para trabajar con el segundo núcleo, sólo tenemos que definir una segunda función de bucle, llamada "loop1()". El código dentro de esta función será ejecutado por el núcleo 0, mientras que el código dentro de la función habitual "loop()" es ejecutado por el núcleo 1. De esta forma podemos definir diferentes tareas para cada núcleo:

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

Organizando el programa así podemos aprovechar los 2 núcleos del ESP32. Sin embargo, hay que tener en cuenta algunas consideraciones a la hora de utilizar el doble núcleo, ya que pueden aparecer problemas de concurrencia: por ejemplo si ambos intentan utilizar el Serial al mismo tiempo. Para evitar estos problemas se podrían utilizar mecanismos como semáforos.

Echa un vistazo a este post del blog para saber más sobre el ESP32 de doble núcleo.

FreeRTOS

FreeRTOS es un popular sistema operativo en tiempo real (RTOS) de código abierto diseñado para microcontroladores y pequeños sistemas embebidos. Proporciona un núcleo de sistema operativo ligero, escalable y portátil, junto con una serie de componentes de software y herramientas para apoyar el desarrollo de aplicaciones embebidas. FreeRTOS puede utilizarse con el IDE de Arduino en placas ESP32 para añadir funcionalidad de sistema operativo en tiempo real a sus proyectos.

Con FreeRTOS, puedes crear múltiples tareas en tu sketch, cada una con su propia prioridad, y utilizar mecanismos de sincronización como semáforos y exclusión mutua para coordinar las tareas. Esto puede ser útil para aplicaciones en tiempo real que requieren una sincronización y coordinación precisa de las tareas.

No es necesario incluir ninguna librería para usar FreeRTOS con PLCs basados en ESP32, ya que está integrado en ESP-IDF como un componente (Arduino aprovecha ESP-IDF).

Una de las características más útiles de FreeRTOS son las tareas, piezas de código programables. Para crear una tarea se utiliza la función xTaskCreate() .

Configuración de software

Este programa crea 2 tareas para poner periódicamente HIGH y LOW, dos salidas digitales. Los LEDs del PLC.

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() {}

SD

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

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

• Ranura MicroSD.
• Hasta 32 GB de almacenamiento (aunque se pueden utilizar tarjetas de mayor capacidad, sólo los primeros 32 GB serán accesibles y utilizables).
• FAT32 y FAT16 permitidas como arquitecturas de sistema de archivos.

La ranura SD se comunica con el ESP32 utilizando SPI, y no hay configuración de hardware necesaria. Recuerde alimentar el PLC con una fuente de alimentación adecuada de 12-24Vdc.

Configuración del software

El paquete de placas "industrialshields-esp32" incluye una librería SD para facilitar su uso. Compruebe el siguiente ejemplo, que inicializa la tarjeta SD e imprime el contenido de su directorio raíz a través del 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() ;
  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();
  }
}

GPIO

Hay algunos pines GPIO del ESP32 directamente disponibles en el PLC, que se pueden utilizar para diversas tareas. Dependiendo del pin pueden trabajar a 3.3V o 5V. Atención. Utilizar un voltaje superior al tolerado por el pin puede dañar el PLC. Consulte las siguientes tablas para ver cada pin disponible.

Pins 3.3V 

Pins de 5V