Instalación Inicial
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 GNU General Public License. Arduino IDE admite la estructuración de código en C y C++.
Industrial Shields recomienda usar el Legacy Arduino IDE (1.8.X) para programar los PLC basados en ESP32, aunque se puede utilizar otro software compatible con ESP. El IDE Arduino 1.8.X se puede descargar desde
este enlace.
Después de descargar e instalar el Arduino IDE, instala 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.
Entradas y Salidas
ENTRADAS ANALÓGICAS
Variación de tensión entre -Vcc (o GND) y +Vcc, puede tomar cualquier valor. Una entrada analógica proporciona una medida codificada en forma de valor digital con un número de N bits. En las E/S digitales y analógicas hay autoaislamiento, por lo que es posible conectarlas usando una fuente de alimentación distinta de la de 24V.
Entradas: (6x) Analógicas (0-10Vdc) / Digitales (5-24Vdc), configurables por software.
Para saber más sobre entradas analógicas...
TYPICAL CONNECTION

ENTRADAS DIGITALES
Variación de tensión desde -Vcc (o GND) hasta +Vcc, sin valores intermedios. Dos estados: 0 (-Vcc o GND) y 1 (+Vcc). En las E/S digitales y analógicas hay autoaislamiento, por lo que es posible conectarlas usando una fuente de alimentación distinta de la de 24V.
Entradas: (7x) Digitales aisladas (5-24Vdc) y (6x) Digitales (5-24Vdc), configurables por software.
Todas las entradas digitales son PNP.
Para saber más sobre entradas digitales ...
TYPICAL CONNECTIONS
- Digital Isolated Input:
- Entrada digital no aislada:
ENTRADAS DE INTERRUPCIÓN
Rutina de servicio de interrupción (ISR): Las ISR son un mecanismo que permite asociar una función a la aparición de un evento concreto. Cuando se produce el evento, el procesador sale inmediatamente del flujo normal del programa del PLC y ejecuta la función ISR asociada, ignorando cualquier otra tarea.
Los pines que admiten interrupciones son los siguientes:
|
Pin del PLC |
Pin del ESP32 |
| 0.5 |
27 |
| 0.6 |
26 |
No es necesaria ninguna configuración de los interruptores externos para usar las interrupciones en los PLC basados en ESP32.
Para saber más sobre las entradas de interrupción...
TYPICAL CONNECTION
PROGRAM EXAMPLE
En este ejemplo, el pin I0.5 activa una interrupción cada vez que cambia su estado, imprimiendo un mensaje por el puerto serie.
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");
}
COMUNICACIONES
Ethernet
Ethernet es la tecnología más utilizada en las redes de área local (LAN) cableadas. 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 utiliza en contraposición a una red de área extensa (WAN), que abarca áreas 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.
El controlador del puerto Ethernet incluido en los PLC basados en ESP es el circuito integrado W5500, compatible con las librerías de la Arduino Ethernet2 Shield. Es un controlador Ethernet embebido con TCP/IP por hardware que proporciona una conexión a internet sencilla para sistemas embebidos. El W5500 permite a los usuarios disponer de conectividad a internet en sus aplicaciones utilizando un único chip que integra la pila TCP/IP, 10/100 Ethernet MAC y PHY. El chip W5500 incorpora un búfer de memoria interno de 32KB para el procesamiento de los paquetes Ethernet. Dispone de SPI para facilitar la integración con el microcontrolador externo.
Hardware
Importante: Asegúrate de que tu ESP32 PLC esté correctamente alimentado (12-24Vdc). El USB no es capaz de alimentar correctamente el PLC ni la comunicación Ethernet. No es necesario ningún interruptor ni configuración adicional para que funcione la comunicación Ethernet, debería ser plug and play.
Software
Importante: Asegúrate de tener el paquete de placas industrialshields-esp-32 correctamente instalado en tu Arduino IDE.
Una vez hecha la configuración del hardware, se puede proceder con la configuración del software y su uso. Se puede utilizar la librería Ethernet con todas sus funciones para establecer la conexión. Basta con incluirla en el código de esta manera:
#include <Ethernet.h>
Example codes:
Servidor TCP Echo
Este ejemplo configura un servidor TCP sobre Ethernet, que escucha las conexiones entrantes de los clientes y responde a los mensajes recibidos devolviéndolos al cliente.
Para probar la conexión con un PC, puedes usar Netcat para conectarte fácilmente al servidor y enviar bytes (la conexión Ethernet debe estar configurada en tu PC). En este caso se puede hacer con este comando (ten en cuenta que la IP y el puerto deben ser los utilizados en el código): nc 10.10.10.100 5566.
Arduino code:
#include <Ethernet.h>
// MAC address
byte mac[] = { 0xBE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
// IP address
byte ip[] = { 10, 10, 10, 100 };
int tcp_port = 5566;
EthernetServer server = EthernetServer(5566);
void setup()
{
// Initialize the ethernet device
Ethernet.begin(mac, ip);
// Start server for listening for clients
server.begin();
}
void loop()
{
// If an incoming client connects, there will be bytes available to read:
EthernetClient client = server.available();
if (client.available()) {
// Read bytes from the incoming client and write them back
// to the same client connected to the server
client.write(client.read());
}
}
Cliente TCP Echo
Este ejemplo configura un cliente TCP sobre Ethernet, que se puede utilizar para conectarse al servidor del código anterior. Se debe conocer la IP y el puerto en el que escucha el servidor y configurarlos en consecuencia en el código. En este caso, el cliente envía los datos recibidos del servidor a través del puerto serie. Para probar este programa con un PC, se puede abrir un servidor TCP con Netcat usando el siguiente comando (la conexión Ethernet debe estar correctamente configurada en tu PC para comunicarse con el ESP32 PLC): nc -l 5566.
Código Arduino:
#include <Ethernet.h>
byte mac[] = { 0xBE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 10, 10, 10, 100 };
byte server[] = { 10, 10, 10, 90};
int tcp_port = 5566;
EthernetClient client;
void setup()
{
Ethernet.begin(mac, ip);
Serial.begin(9600);
delay(1000);
Serial.println("Connecting...");
if (client.connect(server, tcp_port)) { // Connection to server
Serial.println("Connected to server");
client.println();
} else {
Serial.println("Connection failed");
}
}
void loop()
{
if (client.available()) {
if(Serial.available()){
char s = Serial.read(); // Read a byte from serial
client.write(s); // Send what is read on serial monitor
char c = client.read(); //read a byte from the server
Serial.print(c); // Print the data received from the server through serial monitor
}
}
if (!client.connected()) {
Serial.println();
Serial.println("Disconnecting.");
client.stop();
while(true);
}
}
Para saber más sobre la comunicación Ethernet...
Ethernet con HTTP.
Ethernet con MQTT.
Ethernet con Modbus TCP/IP (PLC = Slave).
Ethernet con Modbus TCP/IP (PLC = Master).
Prueba de Ethernet en Arduino o ESP32 PLC
RS485
RS-485 también conocido como TIA-485(-A) y EIA-485, es un estándar que define las características eléctricas de los emisores y receptores para su uso en sistemas de comunicaciones serie. La señalización eléctrica es balanceada y se admiten sistemas multipunto.
Nuestros PLC basados en ESP32 incorporan el circuito integrado MAX485.
MAX485 es un transceptor de bajo consumo y con velocidad de conmutación limitada utilizado para la comunicación RS-485. Funciona con una única alimentación de +5V y la corriente nominal es de 300 μA. Al adoptar la comunicación half-duplex para implementar la función de convertir el nivel TTL en nivel RS-485, puede alcanzar una velocidad máxima de transmisión de 2.5Mbps. El transceptor MAX485 consume una corriente de alimentación de entre 120μA y 500μA, en condiciones sin carga o con carga completa respectivamente, cuando el controlador está deshabilitado.
Los PLC basados en ESP32 solo admiten comunicaciones half duplex RS-485.
Hardware
Importante: Asegúrate de que tu ESP32 PLC esté correctamente alimentado (12-24Vdc).
Configuración de los interruptores
Para el protocolo de comunicación RS-485 hay un interruptor que afecta a esta comunicación, el interruptor inferior izquierdo de la zona A:
El interruptor número 3 se utiliza para seleccionar entre Serial1 o RS485. Para activar la comunicación RS485, el interruptor 3 debe estar en OFF.
Software
Importante: Asegúrate de tener el paquete de placas industrialshields-esp-32 correctamente instalado en tu Arduino IDE.
Una vez hecha la configuración del hardware, se puede proceder con la configuración del software y su uso. En primer lugar, es necesario incluir la librería RS485.h incluida en nuestro paquete de placas.
#include <RS485.h>
Después, no olvides implementar la inicialización correcta de tu comunicación en la función setup(). Para probar la conexión usaremos el puerto serie, por lo que también lo inicializaremos:
RS485.begin(38400);
Serial.begin(9600);
Nota: Comprueba que la velocidad de transmisión (baud rate) entre el PLC y el portátil (Serial) y entre el PLC y el dispositivo conectado por RS-485 esté correctamente configurada (los 2 dispositivos que se comunican deben funcionar a la misma velocidad).
Códigos de ejemplo
Ejemplo básico de escritura RS-485 (envío):
// Include Industrial Shields libraries
#include <RS485.h>
//// IMPORTANT: check switches configuration
////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
// Begin serial port
Serial.begin(9600);
// Begin RS485 port
RS485.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-485 port
RS485.write(tx);
}
}
Ejemplo básico de lectura RS-485 (recepción):
// Include Industrial Shields libraries
#include <RS485.h>
void setup() {
// Begin serial port
Serial.begin(9600);
// Begin RS485 port
RS485.begin(38400);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void loop() {
// Print received byte when available
if (RS485.available()) {
byte rx = RS485.read();
// Hexadecimal representation
Serial.print("HEX: ");
Serial.print(rx, HEX);
// Decimal representation
Serial.print(", DEC: ");
Serial.println(rx, DEC);
}
}
Serial TTL
Interfaz de comunicación entre dos dispositivos con un nivel de tensión bajo. Un puerto serie envía datos mediante una secuencia de bits. Se utilizan dos señales: Tx (Transmit Data, transmisión de datos) y Rx (Receive Data, recepción de datos), que permiten la comunicación full-duplex.
Los PLC ESP32 tienen dos puertos TTL, Serial 1 (RX0/TX0) y Serial 2 (RX1/TX1). Además, existe el puerto serie utilizado en el USB.
Para saber más sobre Serial TTL...
Hardware
Importante: Asegúrate de que tu ESP32 PLC esté correctamente alimentado (12-24Vdc).
Configuración de los interruptores
Para el protocolo Serial hay un interruptor que afecta a esta comunicación, el interruptor inferior izquierdo de la zona A:
Para activar Serial 1: el interruptor 3 debe estar en ON.
Para activar Serial 2: el interruptor 2 debe estar en ON y el interruptor 4 debe estar en OFF.
Software
Importante: Asegúrate de tener el paquete de placas industrialshields-esp-32 correctamente instalado en tu Arduino IDE.
Una vez hecha la configuración del hardware, se puede proceder con la configuración del software y su uso. Para utilizar el puerto serie, necesitamos inicializar el que queramos usar:
Serial.begin(9600); // USB serial port
Serial1.begin(9600); // Serial 1
Serial2.begin(9600); // Serial 2
Ejemplo básico de lectura y escritura con Serial TTL.
Este ejemplo básico utiliza Serial (puerto USB) y Serial1 (TX1/RX1) para leer y escribir un byte cada vez.
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 síncrono que utiliza 2 cables, uno para el reloj (SCL) y otro para los datos (SDA). Esto significa que el maestro y el esclavo envían datos por el mismo cable, que está controlado por el maestro, que también genera la señal de reloj. I2C no utiliza selección de esclavo, sino direccionamiento.
I2C es un protocolo de comunicaciones serie. La velocidad es de 100 Kbit/s en modo estándar, pero admite velocidades de hasta 3.4 Mbit/s. Es un bus muy utilizado en la industria, principalmente para comunicar microcontroladores y sus periféricos en sistemas integrados. También se utiliza para comunicar circuitos integrados entre sí, normalmente situados en una misma PCB (placa de circuito impreso).
Hardware
Importante: Asegúrate de que tu ESP32 PLC esté correctamente alimentado (12-24Vdc).
La comunicación I2C funciona a 5V y no requiere resistencias pull-up, ya que ya están implementadas en la PCB.
Configuración de los Interruptores
Para la comunicación I2C no es necesaria ninguna configuración, está siempre habilitada. No hay ningún interruptor que le afecte.
Pines utilizados
Los pines utilizados en la comunicación I2C son los siguientes:
|
ESP32 PLC Pinout
|
ESP32 Pin
|
| SDA |
21 |
| SCL |
22 |
Software
Importante: Asegúrate de tener el paquete de placas industrialshields-esp-32 correctamente instalado en tu Arduino IDE.
Las funciones necesarias para utilizar I2C están implementadas en la librería Wire.h.
Código de ejemplo
Este ejemplo sencillo implementa un escáner I2C, que explora el bus I2C en busca de dispositivos. Si se encuentra un dispositivo, se informa en el monitor serie de Arduino.
#include <Wire.h>
void setup()
{
Wire.begin();
//Wire.setTimeout(10000);
//Wire.setClock(100000);
Serial.begin(9600);
while (!Serial);
Serial.println("\nI2C Scanner");
}
void loop()
{
byte error, address;
int nDevices;
Serial.println("Scanning...");
nDevices = 0;
for(address = 0x01; address < 127; address++ )
{
// The i2c_scanner uses the return value of
// the Write.endTransmisstion to see if
// a device did acknowledge to the address.
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
Serial.print("I2C device found at address 0x");
if (address<16)
Serial.print("0");
Serial.print(address,HEX);
Serial.println(" !");
nDevices++;
}
else if (error==4)
{
Serial.print("Unknown error at address 0x");
if (address<16)
Serial.print("0");
Serial.println(address,HEX);
}
}
if (nDevices == 0)
Serial.println("No I2C devices found\n");
else
Serial.println("done\n");
delay(5000); // wait 5 seconds for next scan
}
Para saber más sobre la comunicación I2C...
Bus I2C en PLC 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 utilizada para comunicaciones de corta distancia, principalmente en sistemas embebidos. Los dispositivos SPI se comunican en modo full duplex mediante una arquitectura maestro-esclavo, normalmente con un único maestro.
SPI utiliza 3 pines (SCLK, MOSI, MISO) para comunicarse y un pin adicional selector de chip (también llamado SS, selección de esclavo), que el maestro usa para indicar al esclavo con el que quiere comunicarse:
Hardware
Importante: Asegúrate de que tu ESP32 PLC esté correctamente alimentado (12-24Vdc).
La comunicación SPI funciona a 5V.
Los pines SPI no están establecidos con una configuración pull-up o pull-down. El estado de estos pines es desconocido, por lo que, al usarlos, requieren una configuración pull-up o pull-down. La placa ESP32 permite configurar los pines en pull-up por software. Alternativamente, si no se configura el pull-up interno, se debe utilizar un pull-up o pull-down externo para que los pines funcionen correctamente.
Configuración de los Interruptores
Para la comunicación SPI no es necesaria ninguna configuración, no hay ningún interruptor que le afecte.
Pines utilizados
Los pines utilizados en la comunicación SPI son los siguientes:
|
Function
|
PLC Pin
|
ESP32 Pin
|
| MISO |
SO |
GPIO 19 |
| MOSI |
SI |
GPIO 23 |
| CLOCK |
SCK
|
GPIO 18
|
Estos pines solo pueden funcionar como pines SPI de 5V si no se va a utilizar el protocolo Ethernet, ya que el protocolo Ethernet ya utiliza el SPI para comunicarse con la placa ESP32. Por lo tanto, SPI no se puede utilizar al mismo tiempo que la comunicación Ethernet.
Además, se pueden utilizar pines de selección de chip.
Software
Importante: Asegúrate de tener el paquete de placas industrialshields-esp-32 correctamente instalado en tu Arduino IDE.
Nuestra librería de comunicación SPI se basa en la librería SPI de Arduino, que permite la comunicación SPI utilizando los PLC basados en ESP32 únicamente como maestro.
Programa de ejemplo: SPI maestro
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 los datos recibidos se almacenan en la variable correspondiente (la transferencia SPI se basa en el envío y la recepción simultáneos) y se imprimen por el puerto serie.
// Include the SPI library:
#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 la comunicación SPI...
Bus SPI en un PLC de Industrial ShieldsWi-Fi
Wi-Fi es uno de los avances tecnológicos más importantes de la era moderna. Al igual que otros tipos de conexión inalámbrica, como Bluetooth, es una tecnología de transmisión por radio basada en un conjunto de estándares que permite comunicaciones seguras y de alta velocidad entre una gran variedad de dispositivos digitales, puntos de acceso y hardware. Permite que los dispositivos compatibles con Wi-Fi accedan a internet sin necesidad de cables. Puede funcionar a distancias cortas y largas, estar bloqueado y protegido, o ser abierto y gratuito. Es increíblemente versátil y fácil de usar.
Nuestros PLC basados en ESP32 admiten conexiones tanto de 2.4GHz como de 5GHz. 2.4GHz gracias al ESP32 interno, y 5GHz gracias a un chip dedicado, el ISM43340, integrado en el PLC.
Hardware
Importante: Asegúrate de que tu ESP32 PLC esté correctamente alimentado (12-24Vdc).
Configuración de los interruptores
No es necesaria ninguna configuración para utilizar las capacidades Wi-Fi.
Software
Importante: Asegúrate de tener el paquete de placas industrialshields-esp-32 correctamente instalado en tu Arduino IDE.
Para utilizar las comunicaciones Wi-Fi, es necesario incluir en el código del programa la librería correcta, según el tipo de red que quieras utilizar:
-2.4GHz. WiFi.h
-5GHz: WiFi5.h
Estas librerías se pueden incluir en el código de esta manera:
#include <WiFi.h>
#include <WiFi5.h>
Código de ejemplo
Este programa sencillo explora la WiFi en busca de redes disponibles e imprime los resultados por el puerto serie.
#include "WiFi.h"
void setup()
{
Serial.begin(115200);
// Set WiFi to station mode and disconnect from an AP if it was previously connected
WiFi.mode(WIFI_STA);
WiFi.disconnect();
delay(100);
Serial.println("Setup done");
}
void loop()
{
Serial.println("scan start");
// WiFi.scanNetworks will return the number of networks found
int n = WiFi.scanNetworks();
Serial.println("scan done");
if (n == 0) {
Serial.println("no networks found");
} else {
Serial.print(n);
Serial.println(" networks found");
for (int i = 0; i < n; ++i) {
// Print SSID and RSSI for each network found
Serial.print(i + 1);
Serial.print(": ");
Serial.print(WiFi.SSID(i));
Serial.print(" (");
Serial.print(WiFi.RSSI(i));
Serial.print(")");
Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*");
delay(10);
}
}
Serial.println("");
// Wait a bit before scanning again
delay(5000);
}
Más ejemplos de Wi-Fi con código:
Cómo conectar tu PLC basado en ESP32 a Wi-Fi
Bluetooth
Bluetooth es un estándar de tecnología inalámbrica. Se desarrolló como una forma de intercambiar datos a corta distancia. 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 designados (cada uno con un ancho de banda de 1 MHz).
Hardware
Importante: Asegúrate de que tu ESP32 PLC esté correctamente alimentado (12-24Vdc). El USB no es capaz de alimentar correctamente el PLC ni la comunicación Ethernet. No es necesario ningún interruptor ni configuración adicional para que funcione la comunicación Bluetooth.
Software
Importante: Asegúrate de tener el paquete de placas industrialshields-esp-32 correctamente instalado en tu Arduino IDE.
Este ejemplo muestra cómo leer y enviar bytes por Bluetooth usando BluetoothSerial. El puerto Serial se utiliza para enviar y recibir datos desde el PC. Para comunicarse con el PLC por Bluetooth se puede usar 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 aplicación.
#include "BluetoothSerial.h"
BluetoothSerial SerialBT;
void setup() {
Serial.begin(115200);
SerialBT.begin("ESP32test"); //Bluetooth device name
Serial.println("The device started, now you can pair it with bluetooth!");
}
void loop() {
if (Serial.available()) {
SerialBT.write(Serial.read());
}
if (SerialBT.available()) {
Serial.write(SerialBT.read());
}
delay(20);
}
Más ejemplos de uso de Bluetooth:
Interactuar con el PLC industrial M-Duino WiFi/BLE mediante BluetoothCómo controlar un controlador industrial ESP32 mediante Bluetooth
Funciones especiales
RTC
El término reloj en tiempo real se utiliza para evitar confusiones con los relojes de hardware ordinarios, que son únicamente señales que gobiernan la electrónica digital y no cuentan el tiempo en unidades humanas. No se debe confundir el RTC con la computación en tiempo real, que comparte la sigla pero no está directamente relacionada con la hora del día.
Aunque se puede medir el tiempo sin un RTC, utilizar uno tiene ventajas:
- Bajo consumo de energía (importante al funcionar con alimentación alternativa).
- Libera al sistema de control principal para tareas críticas en el tiempo.
- A veces más preciso que otros métodos.
Hay una batería de litio tipo botón de 3,3V que alimenta el RTC. El módulo RTC está basado en el chip DS1307. El reloj en tiempo real serie DS1307 (RTC) es un reloj/calendario de bajo consumo en decimal codificado en binario completo (BCD) más 56 bytes de SRAM no volátil. La dirección y los datos se transfieren en serie a través de un bus bidireccional I2C.
El reloj/calendario proporciona información de segundos, minutos, horas, día, fecha, mes y año. La fecha de fin de mes se ajusta automáticamente en los meses con menos de 31 días, incluidas las correcciones por año bisiesto. El reloj funciona en formato de 24 horas o de 12 horas con indicador AM/PM. El DS1307 tiene un circuito integrado de detección de alimentación que detecta fallos de alimentación y cambia automáticamente a la alimentación de respaldo. El funcionamiento del reloj continúa mientras el dispositivo opera con la alimentación de respaldo.
Hardware Configuration
Importante: Asegúrate de que tu ESP32 PLC esté correctamente alimentado (12-24Vdc).
Configuración de los interruptores:
En los PLC basados en ESP32, I2C está siempre habilitado, por lo que no es necesaria ninguna configuración para utilizar el RTC.
Software Configuration
Importante: Asegúrate de tener el paquete de placas industrialshields-esp-32 correctamente instalado en tu Arduino IDE.
Para utilizar el RTC se usará la librería RTC.h, por lo que es necesario incluirla en nuestro código. Esta librería está incluida en nuestro paquete de placas. Se puede incluir de esta manera:
#include <RTC2.h>
Para comprobar si el puerto RTC funciona, es fácil usar el monitor serie del Arduino IDE con la sentencia adecuada dentro de la función setup():
Serial.begin(9600L);
Example Code
Prueba básica del RTC
// 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);
}
SD
Secure Digital (SD) es un formato de tarjeta de memoria no volátil desarrollado por la SD Card Association (SDA) para su uso en dispositivos portátiles.
Las familias más recientes de tarjetas SD mejoran la velocidad de la tarjeta aumentando la velocidad del bus (la frecuencia de la señal de reloj que sincroniza la entrada y salida de información de la tarjeta).
Sea cual sea la velocidad del bus, la tarjeta puede indicar al host que está "ocupada" hasta que se complete una operación de lectura o escritura. El cumplimiento de una clase de velocidad superior garantiza que la tarjeta limita su uso de la indicación de "ocupada". Tamaño: 15 x 11 x 1 mm.
Las capacidades de SD son las siguientes:
- Capacidad máxima: 4GB. Se pueden usar tarjetas de mayor capacidad, pero solo se podrá acceder a los primeros 4GB.
- Arquitecturas de sistema de archivos permitidas: FAT32 & FAT16.
Hardware Configuration
Asegúrate de que tu ESP32 PLC esté correctamente alimentado (12-24Vdc).
Configuración de los Interruptores
La microSD utiliza la comunicación SPI para interactuar con el ESP32. El protocolo SPI está siempre
habilitado, ya que no hay interruptores que lo configuren, por lo que no es necesaria ninguna configuración para utilizar la microSD.
Software Configuration
Importante: Asegúrate de tener el paquete de placas industrialshields-esp-32 correctamente instalado en tu Arduino IDE.
Con las placas de Industrial Shields, existe una librería que simplifica la implementación de la uSD llamada SD, basada en la implementación de la librería SD de Arduino con algunos cambios menores, como establecer el pin de selección de chip utilizado en la comunicación SPI con el módulo SD.
Example Code
Este código de ejemplo inicializa la tarjeta SD e imprime el contenido de su directorio raíz por el puerto serie.
#include <SD.h>
const int chipSelect = 13;
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);
pinMode(13, OUTPUT);
Serial.print("Initializing SD card...");
if (!SD.begin(chipSelect)) {
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);
}
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();
}
}
Para saber más sobre las tarjetas SD:
Fundamentos de las tarjetas SD en un PLC industrialGPIO
Señales de 3.3Vdc/5Vdc
3.3V Pins
Estos pines se pueden programar según las características del ESP, como E/S que funcionan a 3.3V o cualquier función adicional presente en los pines:
|
PLC Terminal
|
ESP32 Pin
|
|
TX1
|
GPIO 17 |
|
RX1
|
GPIO 16 |
|
VN
|
SENS VN (GPIO 39)
|
|
VP
|
SENS VP (GPIO 36)
|
|
SO
|
GPIO 19
|
|
SI
|
GPIO 23
|
|
SCK
|
GPIO 18
|
Serial 1: RX1/TX1:
El protocolo Serial1 también puede funcionar como pin de 3.3V.
Vp/Vn:
Estos pines pueden funcionar como solo entrada de 3.3V.
SPI: MISO/MOSI/SCK:
Estos pines también pueden funcionar como pines de 3.3V, aunque solo si no se va a utilizar el protocolo Ethernet. Como el protocolo Ethernet utiliza el SPI para comunicarse con la placa ESP, la conexión Ethernet y los pines no se pueden utilizar al mismo tiempo.
Advertencia: para utilizar los pines Serial como GPIO, los interruptores correspondientes deben configurarse de modo que se seleccione Serial 1 (consulta la sección Hardware para más detalles).
5V Pins
Estos pines se pueden programar según las características del ESP, como E/S que funcionan a 5V o cualquier función adicional presente en los pines:
|
PLC Terminal
|
ESP32 Pin
|
| SCL |
GPIO 22 |
| SDA |
GPIO 21 |
| GPIO 0 |
GPIO 0 |
Pines I2C: SDA/SCL:
El protocolo I2C está pensado para funcionar en configuración pull-up, que está incluida en la placa. Por lo tanto, solo se pueden utilizar en configuración pull-up: lee 5V cuando no hay nada conectado.
GPIO 0:
El pin GPIO_0 funciona a 5Vdc y se puede utilizar como entrada o salida digital.
ESP32 Dual Core
El controlador lógico programable ESP32 incluye 2 microprocesadores Xtensa 32-bit LX6. Cuando ejecutamos código en Arduino IDE, por defecto se ejecuta en el core 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 core, para obtener mejor rendimiento y eficiencia. Para trabajar con el segundo core, solo necesitamos definir una segunda función de bucle, llamada "loop1()". El código dentro de esta función será ejecutado por el core 0, mientras que el código dentro de la función habitual "loop()" lo ejecuta el core 1. De esta manera podemos definir tareas distintas para cada core:
void setup() {
// Setup code
}
void loop() {
// Core 1 tasks
}
void loop1() {
// Core 0 tasks
}
Organizando el programa así podemos aprovechar los 2 cores del ESP32. Sin embargo, hay que tener en cuenta algunas consideraciones al usar el dual core, ya que pueden aparecer problemas de concurrencia: por ejemplo, si ambos intentan usar el Serial a la vez. Para evitar estos problemas se pueden usar mecanismos como los semáforos.
Para saber más sobre el dual core 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 kernel de sistema operativo ligero, escalable y portable, junto con una serie de componentes de software y herramientas para dar soporte al desarrollo de aplicaciones embebidas. FreeRTOS se puede utilizar con Arduino IDE en placas ESP32 para añadir funcionalidad de sistema operativo en tiempo real a tus proyectos.
Con FreeRTOS puedes crear varias 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 temporización precisa y una coordinación de tareas.
No es necesario incluir ninguna librería para utilizar FreeRTOS con los PLC basados en ESP32, ya que está integrado en ESP-IDF como componente (Arduino aprovecha ESP-IDF).
Una de las características más útiles de FreeRTOS son las tareas, fragmentos de código planificables. Para crear una tarea se utiliza la función xTaskCreate() .
Código de ejemplo:
Este programa crea 2 tareas que ponen periódicamente en 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() {}