ESP32 PLC 58

Analog inputs

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.
• Resolution: 11 bits, which means the read values can range between 0 and 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

  

 The next diagram illustrates the necessary connections to properly use an analog input (when used as a digital, the input can tolerate up to 24V):

Software setup

In order to use them, the analog inputs must be configured in the set up part of the code, like it is usually done in common Arduino boards. Then they can be read using the "analogRead()" function, with the input name as its parameter. For example, I0.7 is read as I0_7:

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

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

The following post might also be of interest: Learning the basics about analog inputs of an industrial PLC.

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:

• Digital isolated inputs (5 - 24 Vdc): these inputs are opto-isolated, which means they have an extra protection and they use an external ground pin for reference.  They are the pins from IX.0 to IX.6, where X is 0,1 or 2 depending on the zone. 
• 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

 

 The next diagrams illustrate the necessary connections to properly use both inputs as digital:

Software setup

In order to use them, the digital inputs must be configured in the set up part of the code, like it is usually done in common Arduino boards. Then they can be read using the "digitalRead()" function, with the input name as its parameter. For example, I0.0 is read as I0_0:

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

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

The following posts expand on this topic: Basics about digital inputs of an industrial controller, PNP Digital Inputs on industrial PLC.

Entradas de interrupción

Some of the digital inputs in the ESP32 PLC are interrupt capable, which means they can be used with ISRs (interrupt service routine) to trigger certain code execution when an event (a change of state in the pin) is detected. There are two pins of this type each zone: IX.5 and IX.6. They are used and connected as regular digital isolated inputs, and the interrupts are programmed through software.

Configuración del software

This is an example of how to use the interrupt pins. In this case, the function "isrI0_5()" is automatically called every time a change of state occurs on the I0.5 pin.

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

To know more about interrupts inputs: How to use Interrupt Inputs with industrial Arduino boards

Salidas analógicas

An analog output provides a voltage determined by a digital value with an N-bit number. The ESP32 PLCs can have between 3 and 9 analog outputs, depending on the model. These are labeled as AX.X,  and need to be selected via DIP switch to be used (check the hardware section on this page for more information.). Refer to the switch section in this page for more information about the switches. The analog outputs in the ESP32 PLC have the following specifications:

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

The analog outputs have a shared external GND pin, which needs to be connected to set the reference. This symbol identifies the analog outputs, and the following diagram illustrates how to connect:

0 - 10V salida analógica

Configuración del software

The procedure to program the analog outputs is the same as regular Arduino: first, the pin mode must be set to "OUTPUT" in the setup of the code, and then the output can be written using "analogWrite()". The analog outputs can be referenced by its name and using a "_" instead of the ".". For example, A0.5 is used as A0_5:

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

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

To know more about analog outputs: Basics about analog outputs of an industrial PLC.

​

Digital outputs

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.

The output high value can range between 5 and 24 Vdc. This voltage needs to be set using two pins located next to the outputs: QVdc and COM(-). For instance, should you wanna set the output to 24V, the QVdc pin should be connected to 24V and the COM(-) pin to GND. The following diagram illustrates an example connection:

Salida digital (PWM opcional)

Software setup

The digital outputs must be configured in the setup part of the code like it is usually done in common Arduino boards, using the "pinMode()" first to set it as "OUTPUT", and "digitalWrite()" to change the output value. Check the following example:

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

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

You can learn more about digital outputs in this post: Basics about digital outputs of an industrial PLC.

PWM output

In the ESP32 based PLCs, all the digital outputs can be used as PWM outputs.

The output high value can range between 5 and 24 Vdc. As when using them as simple digital outputs, this voltage needs to be set using two pins located next to the outputs: QVdc and COM(-). For instance, should you wanna set the output to 24V, the QVdc pin should be connected to 24V and the COM(-) pin to GND. The following diagram illustrates an example connection.

An example tutorial about how to program the PLC to use the PWM outputs can be found in this website.

PWM capable output

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:

Software setup

The relay output must be configured in the set up part of the code, using Arduino functions, and they are controlled as if they were digital outputs. The outputs can be referenced by the name shown in the serigraphy: R0.1 for instance is used as R0_1. Check the following example. When the output is set to "HIGH", the real i turned on, meaning the switch closes, whereas when it is set to "LOW" the switch is open.

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

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

To know more about the relay outputs, check out this post: Learning the basics about internal relays of an industrial PLC.

Ethernet

Ethernet is the most commonly used technology in wired local area networks ( LANs ). 

A LAN is a network of computers and other electronic devices that covers a small area such as a room, office, or building. It is used in contrast to a wide area network (WAN) , which spans much larger geographical areas. Ethernet is a network protocol that controls how data is transmitted over a LAN. Technically it is referred to as the IEEE 802.3 protocol. The protocol has evolved and improved over time to transfer data at the speed of a gigabit per second.

 The ESP32 PLCs incorporate an Ethernet port, using the W5500 controller, which communicates with the ESP32 using SPI. The W5500 is a Hardwired TCP/IP embedded Ethernet controller that provides easier Internet connection to embedded systems. This chip enables users to have Internet connectivity in their applications by using the single chip in which TCP/IP stack, 10/100 Ethernet MAC and PHY are embedded. With this chip users can integrate Ethernet into their applications.  

Configuración del software

The Industrial Shields boards package includes an "Ethernet" library, intended to facilitate the use of this protocol. Various examples are included with the library, you can check them out going to File > Examples > Ethernet inside the Arduino IDE.

Also take a look at the following program. Before running the code, ensure that your PLC is powered correctly, confirm that the Ethernet cable is securely connected to your device and make sure the "industrialshields-esp-32" board package is properly installed in your Arduino IDE. This code serves as a diagnostic tool to ensure the proper functioning of the Ethernet port. It establishes a connection to "www.google.com" through the W5500 controller using DHCP IP configuration. 

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

• Http requests to a server using an Arduino based PLC
• MQTT client for Arduino based PLC as a I/Os module
• How to use Modbus TCP Slave Library with a PLC controller Arduino
• Modbus TCP Master with Industrial Arduino & ESP32 PLCs
• Ethernet test in Arduino or 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.

If you want to know more about RS485, check out this 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.

The RS485 pins, A+ and B- need to be properly connected to the device the PLC is communicating with. Attention! Remember to properly power the PLC with a 12-24V power supply.

Software setup

Our boards package includes an RS485 library to make programming easier. This library is used as the Arduino Serial library, with methods such as "available()", "read()", etc.

Check out the following code, which establishes half duplex communication and allows the user to read or send messages from the terminal of the 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 is a standard for serial communication transmission of data. It formally defines the signals used in communication between DTE (Data Terminal Equipment) such as a computer terminal, and DCE (Data Circuit-terminating Equipment or Data Communication Equipment), such as a modem. The ESP32 PLC includes a MAX232 transceiver chip, allowing full-duplex communication through RS232. The MAX232 is a dual transmitter/dual receiver that is used to convert the RX, TX, CTS, RTS signals, converting signals from Serial TTL to TIA-232 (RS-232) serial port.

If you want to know more about RS232, check this 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.

The RS232 pins, TX and RX need to be properly connected to the device the PLC is communicating with. Attention! Remember to properly power the PLC with a 12-24V power supply.

Configuración del software

Once the hardware configuration is done, it is possible to proceed with the software configuration and its usage. Firstly, it is necessary to include the RS232.h library provided by our boards package. Then, the communication must be initialized with "RS232.begin(<baudrate>);". After this RS232 can already be used with the functions "RS232.read();" and "RS232.write();". 

Check the following read and write examples:

// 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 is a communication Interface between two devices with working at a low level voltage. Two signals are used: Tx (Transmit Data) and Rx (Receive Data), which allow full-duplex communication. The ESP32 PLCs have two external TTL ports, Serial 1 (RX1/TX1) and Serial 2 (RX2/TX2).

To know more about the serial TTL interface, visit this blog.

Configuración del hardware 

The ESP32 PLC features two serial ports, which need to be activated using the A zone bottom left switch (to know more about the switch configuration, check the "Initial installation - Hardware" section in this page):

• Serial 1 (TX1, RX1): switch 3 needs to be set to 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, both devices need to share a common ground.

Attention! The ESP32 PLCs serial ports work at 3.3V levels. Higher voltage levels might damage the PLC. 

Also, remember to properly power the PLC with a suitable 12-24Vdc power supply.

Software setup

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 is a serial communications protocol. It is a master-slave synchronous protocol and 2 cables are used, one for the clock (SCL) and one for the data (SDA). The master controls the bus and creates the clock signal, and uses addressing to communicate with the slaves. It is a very used bus in the industry, mainly to communicate microcontrollers and their peripherals in integrated systems, normally located in the same PCB. The speed is 100 Kbit/s in standard mode.

Hardware setup

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:

• The I2C port works at 5V. Higher voltage levels might damage the PLC. 
• Los pines I2C, SCL y SDA, se ponen a 5V.

Also, remember to properly power the PLC with a suitable 12-24Vdc power supply.

Configuración del software

The I2C can be used with the library "Wire". Check the following example which implements an I2C scanner that searches the bus for any connected devices. When a device is detected, it will be reported to the serial monitor. Note that if you connect the I2C pins (SDA and SCL) to an other device, it should appear in the scan.

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:

• I2C Bus on PLC Arduino for industrial automation
• How to setup external i2c on industrial Arduino or ESP32 based PLC
  

SPI

The  Serial Peripheral Interface (SPI) is a synchronous serial communication interface specification used for short-distance communication, primarily in embedded systems. SPI devices communicate in full duplex mode using a master-slave architecture, usually with a single master. 3 pins are used with SPI communication: SCLK, MOSI, MISO. Additionally, one extra pin for each slave, called chip select (CS) or slave select (SS) is used to select the slave that is being talked to in the bus.

The ESP32PLCs feature one SPI port.

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.

Also, remember to properly power the PLC with a suitable 12-24Vdc power supply.

Software setup

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.

This program shows how to set up the ESP32 as a master in SPI communication, and send and receive data. In this case the character "0" is sent, and the received data is stored in the corresponding variable (SPI transfer is based on a simultaneous send and receive) and printed through the serial port.

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

To know more about SPI check the following post: Bus SPI on PLC Arduino from Industrial Shields

Bluetooth

Bluetooth is a wireless technology standard. It was developed as a way to exchange data over a short range and it operates in the 2400-2483.5 MHz range within the ISM 2.4 GHz frequency band. Data is split into packets and exchanged through one of the 79 designed Bluetooth channels (each of which with a 1 MHz bandwidth). 

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.

Software setup

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.

Remember to make sure you have the industrialshields-esp-3 board package properly installed in your 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);
}

To check more examples about Bluetooth: Interact with M-Duino WiFi/BLE industrial PLC via 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.

The ESP32 PLCs have Wi-Fi capabilities thanks to the ESP32 microcontroller. No hardware setup is needed in order to use it, the only requirement is for the PLC to be properly powered using a 12-24Vdc power supply.

Software setup

Check this example sketch to know how to setup a Wi-Fi connection. This code uses the "WiFi.h" library to connect the ESP32 to your desired Wi-Fi. It reports to the serial monitor the IP address used to connect. 

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

}

To know more about the Wi-Fi communication: 

• How to connect your ESP32 based PLC to Wi-Fi
• ESP32 WiFi / Bluetooth
• How to work with the 5GHz Wi-Fi module of the ESP32

RTC

RTC stands for Real Time clock, en electronic device that measures the passage of time. Although keeping time can be done without an RTC, using one has benefits such as:

• Mantaining the time without needing to set ti again after a reboot, shutdown, 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.
• Sometimes more accurate than other methods.
  

The ESP32 PLC include a DS1307 RTC module, which communicates with the ESP32 microcontroller using I2C. The DS1307 serial real-time clock is a lowpower, full binary-coded decimal (BCD) clock/calendar, including 56 bytes of NV SRAM. Iprovides seconds, minutes, hours, day, date, month, and year information. 

In order to power the RTC when the PLC is not  connected, the PLC includes a 3,3V lithium coin cell battery which can be used to supply the 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.

Software setup

The RTC library, included with our boards package, can be used to interact with the RTC. Check the following code example where time is read from the RTC and printed to the serial monitor. 

Remember to make sure you have the industrialshields-esp-3 board package properly installed in your 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());
}

However, we can also use the second core, for better performance and efficiency. In order to work with the second core, we just need to define a second loop function, called "loop1()". The code inside this function will be executed by core 0, whereas the code inside the usual "loop()" function is executed by core 1. This way we can define different tasks for each core:

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.

Check this blog post to know more about the ESP32 dual core.

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).

One of the most useful features of FreeRTOS are tasks, schedulables pieces of code. In order to create a task the function xTaskCreate() is used.

Software setup

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

Secure Digital (SD) cards are non-volatile memory storage devices that use flash memory technology. Designed for portable electronic devices, SD cards provide a reliable and compact solution for data storage.

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.

The SD slot communicates with the ESP32 using SPI, and there is no hardware configuration needed. Remember to power the PLC with a proper 12-24Vdc power supply.

Configuración del software

The "industrialshields-esp32" boards package includes an SD library to facilitate its usage. Check the following example, which initializes the SD card and prints the contents of it root directory through the serial port.

#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

There are some GPIO pins of the ESP32 directly available in the PLC, which can be used for various tasks. Depending on the pin they can work at either 3.3V or 5V. Caution! Using a higher voltage than the tolerated by the pin might damage the PLC. Check the following tables to see each available pin.

3.3V Pins 

5V Pins