ESP32 PLC 58

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 leídos pueden ir de 0 a 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 muestra las conexiones necesarias para usar correctamente una entrada analógica (cuando se usa como digital, la entrada tolera hasta 24V):

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 comunes. Después pueden leerse 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 puede interesarte el siguiente post: Aprender los conceptos 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 están optoaisladas, lo que significa que tienen una protección adicional y usan un pin de tierra externo 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 muestran las conexiones necesarias para usar correctamente ambas entradas como digitales:

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 comunes. Después pueden leerse 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));
}

Los siguientes posts amplían este tema: Conceptos básicos de las entradas digitales de un controlador industrial, Entradas digitales PNP en un PLC industrial.

Entradas de interrupción

Algunas de las entradas digitales del ESP32 PLC admiten interrupciones, lo que significa que pueden usarse 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 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 entradas de interrupción con placas Arduino industriales

Salidas analógicas

Una salida analógica proporciona una tensión determinada por un valor digital de N bits. Los ESP32 PLC pueden tener entre 3 y 9 salidas analógicas, según el modelo. Se identifican como AX.X,  y deben seleccionarse mediante un interruptor DIP para poder usarse (consulta la sección de hardware de esta página para más información.). Consulta la sección de interruptores de esta página para más información sobre los interruptores. Las salidas analógicas del ESP32 PLC 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 fijar la referencia. Este símbolo identifica las salidas analógicas, y el siguiente diagrama muestra cómo conectarlas:

0 - 10V salida analógica

Configuración del software

El procedimiento para programar las salidas analógicas es el mismo que en Arduino estándar: primero, el modo del pin debe configurarse como "OUTPUT" en el setup del código, y después la salida puede escribirse con "analogWrite()". Las salidas analógicas pueden referenciarse por su nombre usando "_" en lugar de ".". Por ejemplo, A0.5 se usa 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 de 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 la salida puede ir de 5 a 24 Vdc. Esta tensión debe fijarse con dos pines situados junto a las salidas: QVdc y COM(-). Por ejemplo, si quieres fijar la salida a 24V, el pin QVdc debe conectarse a 24V y el pin COM(-) a GND. El siguiente diagrama muestra un ejemplo de conexión:

Salida digital (PWM opcional)

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 comunes, usando primero "pinMode()" para definirlas como "OUTPUT", y "digitalWrite()" para cambiar el valor de la 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);
}

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

Salida PWM

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

El valor alto de la salida puede ir de 5 a 24 Vdc. Igual que al usarlas como salidas digitales simples, esta tensión debe fijarse con dos pines situados junto a las salidas: QVdc y COM(-). Por ejemplo, si quieres fijar la salida a 24V, el pin QVdc debe conectarse a 24V y el pin COM(-) a GND. El siguiente diagrama muestra un ejemplo de conexión.

Puedes encontrar un tutorial de ejemplo sobre cómo programar el PLC para usar las salidas PWM en esta 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

La salida de relé debe configurarse en la parte de setup del código, usando funciones de Arduino, y se controla como si fuera una salida digital. Las salidas pueden referenciarse por el nombre que aparece en la serigrafía: R0.1, por ejemplo, se usa como R0_1. Mira el siguiente ejemplo. Cuando la salida se pone en "HIGH", el relé se activa, es decir, el contacto se cierra, mientras que cuando se pone en "LOW" el contacto 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: Aprender los conceptos básicos de los relés internos de un PLC industrial.

Ethernet

Ethernet es la tecnología más utilizada en 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 áreas 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 y mejorado con el tiempo hasta transferir datos a una velocidad de un gigabit por segundo.

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

Configuración del software

El paquete de placas de Industrial Shields incluye una librería "Ethernet" pensada para facilitar el uso de este protocolo. La librería incluye varios ejemplos, que puedes consultar en File > Examples > Ethernet dentro de Arduino IDE.

Mira también el siguiente programa. Antes de ejecutar el código, asegúrate de que el PLC está bien alimentado, comprueba que el cable Ethernet está bien conectado al dispositivo y verifica 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 el funcionamiento correcto del puerto Ethernet. Establece una conexión con "www.google.com" a través del controlador W5500 usando 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:

• Peticiones HTTP a un servidor con un PLC basado en Arduino
• Cliente MQTT para PLC basado en Arduino como módulo de E/S
• Cómo usar la librería Modbus TCP Slave con un controlador PLC Arduino
• Modbus TCP Master con PLC Arduino industrial & ESP32
• Prueba de Ethernet en un PLC Arduino o ESP32
  

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 conectarse correctamente al dispositivo con el que se comunica el PLC. ¡Atención! Recuerda 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 usa como la librería Serial de Arduino, con métodos como "available()", "read()", etc.

Mira 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 un estándar para la transmisión serie de datos. Define formalmente las señales usadas en la comunicación entre un DTE (Data Terminal Equipment), como un terminal de ordenador, y un DCE (Data Circuit-terminating Equipment o Data Communication Equipment), como un módem. El ESP32 PLC incluye un chip transceptor MAX232, que permite la comunicación full duplex por RS232. El MAX232 es un doble transmisor/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 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 conectarse correctamente al dispositivo con el que se comunica el PLC. ¡Atención! Recuerda alimentar correctamente el PLC con una fuente de alimentación de 12-24V.

Configuración del software

Una vez hecha la configuración de hardware, se puede pasar a la configuración del software y a su uso. Primero, hay que incluir la librería RS232.h que proporciona nuestro paquete de placas. Después, la comunicación debe inicializarse con "RS232.begin(<baudrate>);". A partir de ahí ya se puede 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

Serial TTL es una interfaz de comunicación entre dos dispositivos que trabajan a un nivel de tensión bajo. Se usan dos señales: Tx (Transmit Data) y Rx (Receive Data), que permiten la comunicación full duplex. Los ESP32 PLC tienen dos puertos TTL externos, Serial 1 (RX1/TX1) y Serial 2 (RX2/TX2).

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

Configuración del hardware 

El ESP32 PLC tiene dos puertos serie, que deben activarse con el interruptor inferior izquierdo de la zona A (para saber más sobre la configuración de los interruptores, consulta la sección "Instalación inicial - Hardware" de esta página):

• Serial 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 una tierra común.

¡Atención! Los puertos serie de los ESP32 PLC trabajan a niveles de 3.3V. Niveles de tensión superiores podrían dañar el PLC. 

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

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 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 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 situados en la misma PCB. 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 trabaja a 5V. Niveles de tensión superiores podrían dañar el PLC. 
• Los pines I2C, SCL y SDA, se ponen a 5V.

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

Configuración del software

El I2C puede usarse con la librería "Wire". Mira el siguiente ejemplo, que implementa un escáner I2C que busca dispositivos conectados en el bus. Cuando se detecta un dispositivo, se notifica en el monitor serie. Ten en cuenta que si conectas los pines I2C (SDA y SCL) a otro dispositivo, debería aparecer en el escaneo.

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 un PLC industrial basado en Arduino o ESP32
  

SPI

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

Los ESP32PLC tienen 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.

Recuerda también alimentar correctamente 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 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 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 se basa en un envío y una recepción simultáneos) 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 el siguiente post: Bus SPI en PLC Arduino de Industrial Shields

Bluetooth

Bluetooth es un estándar de tecnología inalámbrica. Se desarrolló como forma de intercambiar datos a corta distancia y opera 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 definidos (cada uno 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.

Recuerda comprobar que tienes el paquete de placas industrialshields-esp-3 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);
}

Para ver más ejemplos sobre Bluetooth: Interactuar con el PLC industrial M-Duino WiFi/BLE por 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 ESP32 PLC tienen Wi-Fi gracias al microcontrolador ESP32. No se necesita configuración de hardware para usarlo: el único requisito es que el PLC esté correctamente alimentado con una fuente de alimentación de 12-24Vdc.

Configuración del software

Mira este sketch de ejemplo para saber cómo configurar una conexión Wi-Fi. Este código usa la librería "WiFi.h" para conectar el ESP32 a la red Wi-Fi que quieras. Muestra en el monitor serie la dirección IP usada para conectarse. 

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 de 5GHz del ESP32

RTC

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 un RTC, usarlo tiene ventajas como:

• Mantener la hora sin tener que volver a ajustarla tras un reinicio, un 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 ESP32 PLC incluye un módulo RTC DS1307, que se comunica con el microcontrolador ESP32 por I2C. El reloj en tiempo real serie DS1307 es un reloj/calendario de bajo consumo en decimal codificado en binario (BCD) completo, con 56 bytes de NV SRAM. 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,3V que puede 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 nuestro paquete de placas, puede usarse para interactuar con el RTC. Mira el siguiente ejemplo de código, en el que se lee la hora del RTC y se imprime en el monitor serie. 

Recuerda comprobar que tienes el paquete de placas industrialshields-esp-3 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);
}

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 usar el segundo núcleo para obtener mejor rendimiento y eficiencia. Para trabajar con el segundo núcleo, solo hay que definir una segunda función loop, llamada "loop1()". El código dentro de esta función lo ejecuta el núcleo 0, mientras que el código dentro de la función habitual "loop()" lo ejecuta el núcleo 1. Así podemos definir tareas diferentes 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.

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

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 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 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 no volátil que usan 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 por SPI y no requiere configuración de hardware. Recuerda 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. Mira el siguiente ejemplo, que inicializa la tarjeta SD e imprime 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();
  }
}

GPIO

Algunos pines GPIO del ESP32 están disponibles directamente en el PLC y pueden usarse para varias tareas. Según el pin, pueden trabajar a 3.3V o a 5V. ¡Precaución! Usar una tensión superior a la que tolera el pin podría dañar el PLC. Consulta las tablas siguientes para ver cada pin disponible.

Pines de 3.3V 

Pines de 5V