Características técnicas

Arduino IDE

Arduino IDE es la plataforma original para programar placas Arduino. Esta aplicación multiplataforma está disponible para Windows, macOS y Linux bajo la Licencia Pública General de GNU (GNU General Public License). Arduino IDE admite la estructuración de código en C y C++.

Industrial Shields recomienda utilizar el Arduino IDE Legacy (1.8.X) para programar los PLC basados en ESP32, aunque se puede utilizar otro software compatible con ESP. El Arduino IDE 1.8.X se puede descargar desde este enlace. 

Tras descargar e instalar el Arduino IDE, instala el paquete de placas industrialshields-esp-32 dentro del IDE. Puedes hacerlo siguiendo este tutorial y seleccionando el paquete industrialshields-esp-32 en el paso número 6.

Alimentación

El PLC 14 I/Os basado en ESP32 puede alimentarse entre 12-24V y tiene un consumo de entre 700mA y 1500mA. Por lo tanto, recomendamos una fuente de alimentación capaz de suministrar al menos 2A. Cualquier fuente de alimentación industrial será una buena opción para alimentar los PLC.

Recuerda: nuestras unidades están diseñadas para alimentarse entre 12-24V. Si se alimentan únicamente por USB, la unidad no podrá funcionar correctamente. El USB debe utilizarse solo para programar los PLC, no para alimentarlos.

A continuación se muestra un esquema sencillo de cómo conectar una fuente de alimentación a cualquier unidad de Industrial Shields.

Consumo de energía

Este informe analiza cómo consumen energía distintos ESP32 PLC 14 en reposo y con las salidas activadas. Comprender estos patrones es fundamental para optimizar la eficiencia en aplicaciones industriales.

En reposo

En este escenario, el ESP32 PLC 14 está encendido, con todos los pines y comunicaciones desactivados. Esta prueba mide el consumo de energía de referencia cuando el dispositivo está inactivo y no realiza ninguna tarea de procesamiento ni de salida.

Todas las salidas en HIGH

En esta prueba, el ESP32 PLC 14 se configura para poner todos sus pines de salida en estado alto, con lo que consume la corriente máxima en las operaciones de salida. Esto permite conocer el consumo de energía cuando el dispositivo está activando señales de salida.

Entradas analógicas

La entrada analógica permite leer niveles de tensión analógicos, codificando el valor con un número de N bits. Las entradas analógicas del PLC 14 I/Os utilizan el GND interno como referencia (el mismo que el de la alimentación). Además, las entradas analógicas también pueden utilizarse como entradas digitales no aisladas que toleran hasta 24Vdc.

Ten en cuenta que los valores de las entradas analógicas son lineales en todo el rango entre 1V y 10V cuando se utiliza el modo 0-10V , ya que la resolución es de aproximadamente 11,5 bits, igual que cuando se utiliza el modo 4-20mA.

Nota: Las entradas analógicas tienen una resolución de 11,507 bits contando de 0 a 10Vdc. El primer rango de 1V (0-1Vdc -> 0 - 291) no es lineal, pero el segundo rango de 9V (1-10Vdc -> 291 - 2910) sí lo es.

El PLC 14 I/Os dispone de 2 entradas analógicas (AI0.0 y AI0.1) que pueden utilizarse en ambos modos (0-10V y 4-20mA). 

Conexión típica

El siguiente esquema muestra un ejemplo de conexión:

Configuración del software

Las entradas analógicas deben configurarse en la parte setup del código, como se hace habitualmente en las placas Arduino comunes.

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

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

Entradas digitales

Las entradas digitales se utilizan para capturar señales que se encuentran en uno de dos estados: alto o bajo, verdadero o falso, etc. Las entradas digitales del 14 I/Os interpretan como valores altos las tensiones de 3,3 Vdc o superiores, hasta 24 Vdc, mientras que los valores inferiores a 3,3V se interpretan como bajos. Todas las entradas digitales del 14 I/Os están optoaisladas y la resolución es de 10 bits.

El PLC 14 I/Os dispone de 9 entradas digitales (de I0.0 a I0.8).

Nota: los pines I0.7 y I0.8 cumplen funciones diferentes según el modo seleccionado. 

Conexión típica

El siguiente esquema muestra un ejemplo de conexión:

Configuración del software

Las entradas digitales deben configurarse en la parte setup del código, como se hace habitualmente en las placas Arduino comunes.

Salidas digitales

Las salidas digitales del 14 I/Os pueden proporcionar un valor bajo (0 Vdc) o alto (hasta 24 Vdc). El valor alto de salida puede estar entre 3,3 y 24 Vdc, mientras que los valores inferiores a 3,3V se interpretan como bajos. Todas las salidas digitales están optoaisladas.

El PLC 14 I/Os dispone de 4 salidas digitales (de Q0.0 a Q0.3).

Conexión típica

El siguiente esquema muestra un ejemplo de conexión:

Configuración del software

Las salidas digitales deben configurarse en la parte setup del código, como se hace habitualmente en las placas Arduino comunes.

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

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

Como las salidas digitales pueden tomar valores de 5V y 24V, es necesario configurarlas. Para más información, consulta este post.

Salida de relé

Un relé es un interruptor electromagnético controlado por una señal eléctrica. En las unidades de Industrial Shields estos dispositivos ya están integrados en sus placas. El relé incluido en el PLC 14 I/Os tiene las siguientes especificaciones:

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

El PLC 14 I/Os dispone de 1 salida de relé cuyos terminales son REL-A y REL-B.

Conexión típica

El siguiente esquema muestra un ejemplo de conexión:

Configuración del software

La salida de relé debe configurarse en la parte setup del código, como se hace habitualmente en las placas Arduino comunes.

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

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

Ethernet

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

Una LAN es una red de ordenadores y otros dispositivos electrónicos que cubre un área pequeña, como una sala, una oficina o un edificio. Se utiliza en contraposición a la 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 conoce como protocolo IEEE 802.3. El protocolo ha evolucionado y mejorado con el tiempo hasta transferir datos a una velocidad de un gigabit por segundo.

Nuestro PLC 14 I/Os incorpora el circuito integrado W5500.

El W5500 es un controlador Ethernet embebido con TCP/IP por hardware que facilita la conexión a Internet de los sistemas embebidos. Este chip permite a los usuarios disponer de conectividad a Internet en sus aplicaciones mediante un único chip que integra la pila TCP/IP, y la MAC y el PHY de 10/100 Ethernet. El chip W5500 integra un búfer de memoria interna de 32Kb para el procesamiento de paquetes Ethernet. Con este chip, los usuarios pueden implementar la aplicación Ethernet añadiendo un programa de sockets sencillo. Se proporciona SPI para facilitar la integración con el microcontrolador externo.

Código de ejemplo

Este código sirve como herramienta de diagnóstico para comprobar el correcto funcionamiento de la función Ethernet de tu PLC 14 I/O. Establece una conexión con "www.google.com" a través del controlador W5500 usando configuración IP por DHCP. Antes de ejecutar el código, asegúrate de que tu PLC esté correctamente alimentado, confirma que el cable Ethernet esté bien conectado a tu dispositivo y comprueba que el paquete de placas "industrialshields-esp-32" esté correctamente instalado en tu Arduino IDE.

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

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 drivers y receptores para su uso en sistemas de comunicación serie. La señalización eléctrica es balanceada y admite sistemas multipunto.

Nuestro PLC 14 I/Os incorpora el circuito integrado MAX485.

El 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. Adopta comunicación semidúplex para realizar la conversión del nivel TTL a nivel RS-485 y 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, sin carga o con carga completa, cuando el driver está deshabilitado.

El 14 I/Os admite comunicaciones RS-485 semidúplex.

Código de ejemplo

Este código establece una comunicación sencilla entre dos dispositivos mediante el protocolo RS485. Los datos escritos desde la interfaz serie de un dispositivo se transmiten al otro por RS485. Carga este código en el PLC 14 I/O y en otro dispositivo con capacidad de comunicación RS485 (como cualquiera de nuestros PLC). Conéctalos haciendo coincidir A+ con A+ y B- con B-. Antes de ejecutar el código, asegúrate de que tu PLC esté correctamente alimentado, verifica que los cables RS485 estén bien conectados a los dispositivos y confirma que el paquete de placas "industrialshields-esp-32" esté correctamente instalado en tu Arduino IDE.

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

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

Código de ejemplo

Este código utiliza la librería "Wire.h" para implementar un escáner I2C que busca dispositivos en el bus I2C. Cuando se detecta un dispositivo, se indica en el monitor serie. Antes de ejecutar el código, asegúrate de que tu PLC esté correctamente alimentado, confirma que la librería "Wire.h" esté instalada en tu Arduino IDE y verifica que el paquete de placas "industrialshields-esp-32" esté correctamente instalado en tu Arduino IDE.

Ten en cuenta que, si conectas los pines I2C (SDA y SCL) a otro dispositivo, este debería aparecer en el escaneo.

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

Bluetooth

Bluetooth es otro estándar de tecnología inalámbrica. Bluetooth se desarrolló como una forma de intercambiar datos a corta distancia. 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 designados (cada uno con 1 MHz de ancho de banda).

Si quieres saber cómo usar Bluetooth con tu 14 I/Os, puedes consultar esta guía.

Wi-Fi

El 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 rápidas y seguras entre una gran variedad de dispositivos digitales, puntos de acceso y hardware. Hace posible que los dispositivos compatibles con Wi-Fi accedan a Internet sin necesidad de cables. Puede funcionar a distancias cortas y largas, estar protegido y asegurado, o ser abierto y gratuito. Es increíblemente versátil y fácil de usar.

Código de ejemplo

Este código utiliza la librería "WiFi.h" para conectar el 14 I/Os a la red Wi-Fi que desees. Indica en el monitor serie la dirección IP utilizada para conectarse. Antes de ejecutar el código, asegúrate de que tu PLC esté correctamente alimentado, confirma que la librería "WiFi.h" esté instalada en tu Arduino IDE y verifica que el paquete de placas "industrialshields-esp-32" esté correctamente instalado en tu Arduino IDE.

Asegúrate de cambiar las variables ssid y password por los datos de tu configuración Wi-Fi.

#include "WiFi.h"

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

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

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

void loop() {

}

Modos del 14 I/Os

Como se ha mencionado en algunas secciones anteriores, el PLC 14 I/Os puede configurarse en 2 modos diferentes:

• Modo 0-10V
• Modo 4-20mA

Según el modo elegido, el comportamiento de los pines de entrada AI0.0/I0.7 y AI0.1/I0.8 varía, como se detalla a continuación.

Configura el modo en el Arduino IDE yendo a Tools > Model y seleccionando el modo deseado:

ESP32 doble núcleo

El controlador lógico programable ESP32 incluye 2 microprocesadores Xtensa LX6 de 32 bits. Cuando ejecutamos código en el 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 mayor rendimiento y eficiencia. Para trabajar con el segundo núcleo, solo necesitamos definir una segunda función de bucle, llamada "loop1()". El código de esta función se ejecutará en el núcleo 0, mientras que el código de la función "loop()" habitual se ejecuta en el núcleo 1. De este modo 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 de esta forma podemos aprovechar los 2 núcleos del ESP32. Aun así, hay que tener en cuenta algunas consideraciones al usar el doble núcleo, ya que pueden aparecer problemas de concurrencia: por ejemplo, si ambos intentan usar el Serial al mismo tiempo. Para evitar estos problemas pueden utilizarse mecanismos como los 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 portable, junto con una serie de componentes de software y herramientas para dar soporte al desarrollo de aplicaciones embebidas. FreeRTOS puede utilizarse con el Arduino IDE en placas ESP32 para añadir a tus proyectos la funcionalidad de un sistema operativo en tiempo real.

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 en aplicaciones en tiempo real que requieren una temporización precisa y la coordinación de tareas.

No es necesario incluir ninguna librería para usar 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.

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