Ir al contenido

PLC Arduino industrial · Carril DIN · 12 a 24 Vdc · Ethernet

PLC Arduino M-Duino: características técnicas

Referencia técnica completa de la familia de PLC Arduino M-Duino: fuente de alimentación, interruptores DIP, E/S analógicas y digitales, salidas de relé, Ethernet, RS-485, RS-232, I2C, SPI, RTC y microSD, con esquemas de cableado y código para Arduino IDE de cada función.

Fuente de alimentación
12 a 24 Vdc, mínimo 2 A
Programación
Arduino IDE
Comunicaciones
Ethernet, RS-485, RS-232, Serial TTL, I2C, SPI
Extras
RTC, microSD, pines directos de Arduino, señales de 5 Vdc

Visión general del PLC Arduino M-Duino

Qué es el PLC Arduino M-Duino#

El M-Duino es la gama de PLC Arduino de gran formato de Industrial Shields: un PLC industrial basado en el Arduino Mega 2560 original, montado en carril DIN y alimentado a 12 a 24 Vdc. Está pensado para proyectos de automatización y control que necesitan más puntos de E/S que un controlador compacto como el PLC Arduino Ardboxenlace.​

Todos los modelos M-Duino incluyen Ethernet de serie (controlador W5500) y añaden RS-485, RS-232, Serial TTL, I2C y SPI, un reloj de tiempo real y una ranura microSD. El PLC Arduino se programa en C y C++ con Arduino IDE y el paquete de placas de Industrial Shields, y admite protocolos industriales como Modbus RTU, Modbus TCP y MQTT.

Certificaciones: CE y RoHS en todos los modelos; ETL en los M-Duino 21, 42 y 58.

Modelos M-Duino y E/S#

El número del modelo es el total aproximado de puntos de E/S. El sufijo R indica salidas de relé y AR, salidas mixtas analógicas y de relé.

Modelo de PLC ArduinoEntradas analógicasEntradas digitalesSalidas digitalesSalidas de reléE/S totales
M-Duino 19R423817
M-Duino 21678021
M-Duino 38AR10911838
M-Duino 38R8461634
M-Duino 42121416042
M-Duino 57R12682349
M-Duino 58162022058

Compara toda la gama en la página de la familia de PLC Arduino M-Duino o descarga fichas técnicas, guías de usuario y certificados desde la documentación técnicaenlace.​

Instalación y configuración

Programación con 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 GNU General Public License. Arduino IDE admite código estructurado en C y C++. Para programar los PLC basados en Arduino Mega en este entorno, Industrial Shields ofrece un paquete de placas con las bibliotecas y herramientas necesarias.

Recomendamos usar el Arduino IDE Legacy (2.3.X) para programar los PLC basados en M-Duino, aunque se puede usar otro software compatible con Arduino. El Arduino IDE 2.3.X se puede descargar desde este enlace. Después de descargar e instalar Arduino IDE, instala el paquete de placas industrialshields dentro del IDE. Puedes hacerlo siguiendo este tutorial y seleccionando el paquete industrialshields en el paso número 6.

Fuente de alimentación: 12 a 24 Vdc#

Los PLC basados en M-Duino se deben alimentar con una fuente de alimentación externa que proporcione una tensión de entre 12 y 24 Vdc. ¡Atención! Aunque a primera vista pueda parecer que el PLC funciona alimentado por el puerto USB, no es así. Es obligatorio usar una fuente de alimentación externa para que el PLC funcione correctamente.

El consumo de los PLC basados en M-Duino oscila entre 700 y 1500 mA. Por eso, Industrial Shields recomienda usar una fuente de alimentación capaz de entregar al menos 2 A.

Especificaciones de la fuente de alimentación:

  • Tensión: entre 12 y 24 Vdc.
  • Intensidad: al menos 2 A.

El esquema de esta sección muestra las conexiones necesarias para alimentar correctamente un PLC.

Esquema de alimentación

Interruptores DIP#

Los PLC basados en M-Duino tienen varios interruptores que sirven para configurar determinadas funciones del PLC. En esta sección se explica cómo usarlos correctamente. Para distinguir las distintas partes del PLC y localizar cada interruptor, se usa la siguiente nomenclatura:

Lateral derecho del PLC M-Duino: nomenclatura de zonas

Vista superior del PLC M-Duino: nomenclatura de zonas

Lateral izquierdo del PLC M-Duino: nomenclatura de zonas

En cada zona hay uno o varios interruptores que sirven para configurar algunas funciones del PLC. Las siguientes tablas indican la función de cada interruptor y cómo configurarlo.

Zona A: interruptor superior izquierdo

Interruptor superior de la zona A

Interruptor

Off

On

1 (superior)

TX1

I1.X

2 (superior)

RX2

I1.X

3 (superior)

SDA

I2.X

4 (superior)

SCL

I2.X

1 (inferior)

FD

HD

2 (inferior)

SD

X

3 (inferior)

Pin 2

I0.X

4 (inferior)

Pin 3

I0.X

Interruptor superior:

  1. Si este interruptor está en ON, habilita la entrada I1.X y deshabilita TX1. Si está en OFF, habilita TX1 y deshabilita I1.X.
  2. Si este interruptor está en ON, habilita la entrada I1.X y deshabilita RX1. Si está en OFF, habilita RX1 y deshabilita I1.X.
  3. Si este interruptor está en ON, habilita la entrada I2.X y deshabilita SDA. Si está en OFF, habilita SDA y deshabilita I2.X.
  4. Si este interruptor está en ON, habilita la entrada I2.X y deshabilita SCL. Si está en OFF, habilita SCL y deshabilita I2.X.

Interruptor inferior:

  1. Si este interruptor está en ON, habilita la opción Half Duplex (HD) y deshabilita FD. Si está en OFF, habilita Full Duplex (FD) y deshabilita HD.
  2. Si este interruptor está en OFF, habilita el Chip Select de la tarjeta microSD. En algunos modelos de PLC M-Duino, si está en ON, habilita una salida digital.
  3. Si este interruptor está en ON, habilita la entrada I0.X y deshabilita el Pin 3. Si está en OFF, habilita el Pin 3 y deshabilita I0.X.
  4. Si este interruptor está en ON, habilita la entrada I0.X y deshabilita el Pin 2. Si está en OFF, habilita el Pin 3 y deshabilita I0.X.

*La X representa pines distintos según el modelo de PLC M-Duino.

Zona A: interruptor inferior izquierdo

Interruptor inferior de la zona A

Interruptor

Off

On

1

X

RTC

2

X

RTC

3

X

X

4

X

X

Solo se usan los interruptores 1 y 2. Ambos habilitan la comunicación con el RTC mediante I2C. Con estos interruptores en ON se activa esta comunicación, mientras que en

OFF se deshabilita el acceso I2C al RTC.

Zonas B, C y D: interruptor analógico

Interruptor analógico

Interruptor

Off

On

1

AX.5

QX.5

2

AX.6

QX.6

3

AX.7

QX.7

4

X

X

Estos interruptores sirven para elegir entre salida digital o analógica, según la tabla anterior. En OFF, solo estará disponible la salida analógica correspondiente. En ON, solo estará disponible la salida digital correspondiente. Los interruptores funcionan igual en las zonas B, C y D, y el valor de "X" cambia según la zona:

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

Consumo por modelo#

Este informe analiza cómo consumen energía los distintos modelos de PLC M-Duino en reposo y con todas las salidas activas. Conocer este comportamiento es clave para optimizar la eficiencia en aplicaciones industriales.

En reposo

En este escenario, el PLC M-Duino está encendido, con todos los pines y comunicaciones desactivados y una fuente de alimentación de 24 V. Esta prueba mide el consumo base cuando el equipo está en reposo y no realiza tareas de procesamiento ni de salida.

MODELO

CORRIENTE (mA)

POTENCIA (W)

21+99
2,376
42+92
2,208
58+76
1,824
19R+80
1,92
38R+77
1,848
57R+73
1,752
38AR+72
1,728
53ARR+71
1,704
57AAR+71
1,704
54ARA+76
1,824
50RRA+82
1,968

Todas las salidas en HIGH

En esta prueba, el PLC M-Duino se configura para poner todos sus pines de salida en estado alto, con el consumo máximo de corriente para las salidas y una fuente de alimentación de 24 V. Así se obtiene el consumo cuando el equipo está activando señales de salida.

MODELO

CORRIENTE (mA)

POTENCIA (W)

21+120
2,88
42+128
3,072
58+126
3,024
19R+202
4,848
38R+313
7,512
57R+425
10,2
38AR+221
5,304
53ARR+323
7,752
57AAR+221
5,304
54ARA+231
5,544
50RRA+322
7,728

Entradas y salidas del PLC Arduino

Entradas analógicas: 0 a 10 Vdc#

Una entrada analógica permite leer niveles de tensión analógicos y codificar el valor con un número de N bits. Las entradas analógicas de los PLC basados en M-Duino usan como referencia el GND interno (el mismo que la fuente de alimentación). Las entradas analógicas de estos PLC tienen las siguientes especificaciones:

  • Rango de tensión: de 0 a 10 Vdc.
  • Resolución: 10 bits, es decir, los valores leídos van de 0 a 1023.

Además, las entradas analógicas también se pueden usar como entradas digitales no aisladas que toleran hasta 24 Vdc. Para ello, consulta la sección de entradas digitales. Las entradas analógicas son las comprendidas entre IX.7 e IX.12, donde X es 0, 1 o 2 según la zona. Puedes identificar las entradas analógicas de tu equipo con el siguiente símbolo:

Entrada analógica 0 V - 10 Vdc

Entrada analógica 0 V - 10 Vdc

El siguiente esquema muestra las conexiones necesarias para usar correctamente una entrada analógica (usada como digital, la entrada tolera hasta 24 V):

Esquema de entrada analógica

Configuración del software

Para usarlas, las entradas analógicas se deben configurar en la parte de setup del código, como se hace normalmente en las placas Arduino. Después se pueden leer 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 te puede interesar este post: Conceptos básicos sobre las entradas analógicas de un PLC industrial.

Entradas digitales: 5 a 24 Vdc#

Las entradas digitales sirven para captar señales que solo tienen dos estados: alto o bajo, verdadero o falso, etc. Las entradas digitales del PLC M-Duino interpretan como nivel alto los valores de 5 Vdc o más, hasta 24 Vdc, mientras que los valores inferiores a 5 V se interpretan como nivel bajo. Hay 2 tipos de entradas que se pueden usar como entrada digital:

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

Puedes identificarlas con los siguientes símbolos:

Símbolo de entrada aislada

Entrada aislada 5 V - 24 V

Símbolo de entrada no aislada

Entrada no aislada 5 V - 24 V

Los siguientes esquemas muestran las conexiones necesarias para usar correctamente ambos tipos de entrada como digitales:

Esquema de entrada aislada

Esquema de entrada no aislada

Configuración del software

Para usarlas, las entradas digitales se deben configurar en la parte de setup del código, como se hace normalmente en las placas Arduino. Después se pueden leer 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));
}

Estos posts amplían el tema: Conceptos básicos sobre las entradas digitales de un controlador industrial, Entradas digitales PNP en un PLC industrial.

Entradas de interrupción#

Algunas entradas digitales del PLC M-Duino admiten interrupciones, es decir, se pueden usar con ISR (rutinas de servicio de interrupción) para ejecutar un código concreto 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 hardware

Las entradas de interrupción se deben activar con los interruptores superiores de la zona A:

  • I0.5 e I0.6 también funcionan como Pin3 y Pin2. Habilita las interrupciones poniendo en ON los interruptores 3 y 4 del bloque inferior de comunicaciones.
  • I1.5 e I1.6 también funcionan como Tx1 y Rx1. Habilita las interrupciones poniendo en ON los interruptores 1 y 2 del bloque superior de comunicaciones.
  • I2.0 e I2.1 también funcionan como SDA y SCL. Habilita las interrupciones poniendo en ON los interruptores 3 y 4 del bloque superior de comunicaciones. En este caso no podrás usar I2C.


Consulta la sección "Instalación y configuración" de esta página para más información.

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

Salidas analógicas: 0 a 10 Vdc#

Una salida analógica proporciona una tensión determinada por un valor digital de N bits. Los PLC M-Duino pueden tener entre 3 y 9 salidas analógicas, según el modelo. Están etiquetadas como AX.X y, para usarlas, se deben seleccionar con el interruptor DIP. Consulta la sección de interruptores de esta página para más información. Las salidas analógicas del PLC M-Duino tienen las siguientes especificaciones:

  • Rango de tensión: de 0 a 10 Vdc.
  • Resolución: 8 bits.

Las salidas analógicas tienen un pin GND externo compartido que se debe conectar para fijar la referencia. Este símbolo identifica las salidas analógicas, y el siguiente esquema muestra cómo conectarlas:

Símbolo de salida analógicaSalida analógica 0 - 10 V

Esquema de salida analógica

Configuración del software

Las salidas analógicas se programan igual que en un Arduino normal: primero se configura el modo del pin como "OUTPUT" en el setup del código y después se escribe la salida con "analogWrite()". Las salidas analógicas se referencian por su nombre usando "_" en lugar de ".". Por ejemplo, A0.5 se usa como A0_5:

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

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

Para saber más sobre las salidas analógicas: Conceptos básicos sobre las salidas analógicas de un PLC industrial.

Salidas digitales: 5 a 24 Vdc#

Las salidas digitales del PLC M-Duino pueden proporcionar un valor bajo (0 Vdc) o alto (hasta 24 Vdc). Estas salidas están etiquetadas como QX.X y se identifican con el siguiente símbolo.

El valor alto de la salida puede estar entre 5 y 24 Vdc. Esta tensión se fija con dos pines situados junto a las salidas: QVdc y COM(-). Por ejemplo, si quieres que la salida dé 24 V, conecta el pin QVdc a 24 V y el pin COM(-) a GND. El siguiente esquema muestra un ejemplo de conexión:

Salida digital (PWM opcional)

Salida digital (PWM opcional)

Esquema de salida digital

Configuración del software

Las salidas digitales se deben configurar en la parte de setup del código, como se hace normalmente en las placas Arduino: primero con "pinMode()" para definirlas como "OUTPUT" y después con "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 saber más sobre las salidas digitales en este post: Conceptos básicos sobre las salidas digitales de un PLC industrial.

Salidas PWM#

En los PLC basados en M-Duino, algunas salidas digitales se pueden usar como salidas PWM.

El valor alto de la salida puede estar entre 5 y 24 Vdc. Igual que al usarlas como salidas digitales simples, esta tensión se fija con dos pines situados junto a las salidas: QVdc y COM(-). Por ejemplo, si quieres que la salida dé 24 V, conecta el pin QVdc a 24 V y el pin COM(-) a GND. El siguiente esquema muestra un ejemplo de conexión.

En nuestro repositorio encontrarás un tutorial de ejemplo sobre cómo programar el PLC para usar las salidas PWM con la biblioteca avr-Pulses .

Salida digital (PWM)

Salida con capacidad PWM

Esquema de salida PWM

Salidas de relé: hasta 220 Vac#

Un relé es un interruptor electromagnético controlado por una señal eléctrica. En los equipos de Industrial Shields estos dispositivos ya vienen integrados en la placa. Los relés del PLC M-Duino pueden trabajar hasta 24 Vdc o 220 Vac. Cada salida de relé tiene dos bornes y está etiquetada como RX. El siguiente esquema muestra las conexiones:

Esquema de salida de relé

Configuración del software

Las salidas de relé se deben configurar en la parte de setup del código con funciones de Arduino, y se controlan como si fueran salidas digitales. Las salidas se referencian con el nombre de la serigrafía: por ejemplo, R0.1 se usa como R0_1. Mira el siguiente ejemplo. Cuando la salida está en "HIGH", el relé se activa y el contacto se cierra; cuando está 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: Conceptos básicos sobre los relés internos de un PLC industrial.

Comunicaciones: Ethernet, RS-485, RS-232, I2C, SPI

Ethernet (W5500)#

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 contrapone a la red de área amplia (WAN), que abarca zonas geográficas mucho mayores. Ethernet es un protocolo de red que controla cómo se transmiten los datos 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 PLC M-Duino incorporan un puerto Ethernet con el controlador W5500, que se comunica con el Arduino mediante SPI. El W5500 es un controlador Ethernet embebido con pila TCP/IP cableada en hardware que facilita la conexión a Internet de sistemas embebidos. Este chip único integra la pila TCP/IP, el MAC Ethernet 10/100 y el PHY, de modo que permite añadir conectividad a Internet y Ethernet a tus aplicaciones.

Configuración del software

El paquete de placas de Industrial Shields incluye una biblioteca "Ethernet" que facilita el uso de este protocolo. La biblioteca incluye varios ejemplos, que puedes consultar en Archivo > Ejemplos > Ethernet dentro de Arduino IDE.

Echa un vistazo también al siguiente programa. Antes de ejecutar el código, comprueba que el PLC está bien alimentado, que el cable Ethernet está bien conectado al equipo y que el paquete de placas "industrialshields" está correctamente instalado en Arduino IDE. Este código sirve como herramienta de diagnóstico para comprobar que el puerto Ethernet funciona correctamente. Establece una conexión con "www.google.com" a través del controlador W5500 con 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");
    }
   }
}

Relacionado: Prueba de Ethernet en un PLC Arduino, Servidor HTTP en un M-Duino, Mapa de registros Modbus TCP con un PLC M-Duino.

RS-485 (MAX485)#

RS485, también conocido como TIA-485(-A) o EIA-485, es un estándar que define las características eléctricas de los emisores y receptores para sistemas de comunicación serie. Los PLC M-Duino incluyen RS485 half-duplex gracias al chip transceptor MAX485 integrado.

El MAX485 es un transceptor de bajo consumo y con slew rate limitado que se usa para la comunicación RS-485. Funciona con una única alimentación de +5 V y su corriente nominal es de 300 μA. Usa comunicación half-duplex para convertir niveles TTL a niveles RS-485 y alcanza una velocidad máxima de transmisión de 2,5 Mbps. Con el driver deshabilitado, el transceptor MAX485 consume entre 120 μA y 500 μA sin carga o a plena carga.

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

Configuración del hardware

Para usar RS485 con los PLC M-Duino, revisa el interruptor superior izquierdo de la zona A. El RS485 siempre está activo, pero hay un interruptor (el número 1) para elegir entre half-duplex y full-duplex. Para más información sobre los interruptores, consulta la sección "Instalación y configuración" de esta página.

Los pines RS485, A+ y B-, se deben conectar correctamente al equipo con el que se comunica el PLC. ¡Atención! Recuerda alimentar correctamente el PLC con una fuente de 12-24 V.

Configuración del software

Nuestro paquete de placas incluye una biblioteca RS485 que facilita la programación. Se usa igual que la biblioteca Serial de Arduino, con métodos como "available()", "read()", etc.

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

Modbus RTU sobre RS-485: leer holding registers, escribir un solo registro, control de velocidad con variador, control de una enfriadora y pasarela Modbus TCP a RTU con un PLC M-Duino.

RS-232 (MAX232)#

RS-232 es un estándar para la transmisión de datos por comunicación serie. Define formalmente las señales que se usan en la comunicación entre un DTE (Data Terminal Equipment), como un terminal informático, y un DCE (Data Circuit-terminating Equipment o Data Communication Equipment), como un módem. El PLC M-Duino incluye un chip transceptor MAX232 que permite comunicación full-duplex por RS232. El MAX232 es un doble emisor y doble receptor que convierte las señales RX, TX, CTS y RTS de Serial TTL al puerto serie TIA-232 (RS-232).

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

Configuración del hardware

Los pines RS232, TX y RX, se deben conectar correctamente al equipo con el que se comunica el PLC. ¡Atención! Recuerda alimentar correctamente el PLC con una fuente de 12-24 V.

Configuración del software

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

//////////////////////////////////////////////////////////////////////////////////////////////

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 baja tensión. Usa dos señales, Tx (transmisión de datos) y Rx (recepción de datos), que permiten una comunicación full-duplex. Los PLC M-Duino tienen dos puertos TTL externos, Serial 1 (RX1/TX1) y Serial 0 (RX0/TX0).

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

Configuración del hardware

El PLC M-Duino tiene dos puertos serie. Uno de ellos, el Serial 1 (TX1, RX1), se debe activar con el interruptor superior izquierdo de la zona A. Para más información sobre los interruptores, consulta la sección "Instalación y configuración" de esta página.

Para que la comunicación serie funcione, hay que hacer las siguientes conexiones entre el PLC y el otro equipo:

  • TX -> RX
  • RX -> TX
  • GND: ambos equipos deben compartir una tierra común.

¡Atención! Los puertos serie de los PLC M-Duino trabajan con niveles de 5 V. Una tensión mayor puede dañar el PLC.

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

Configuración del software

Para usar la comunicación serie con el PLC, puedes usar el objeto "Serial" de Arduino. Mira el siguiente ejemplo, que usa Serial 1 para enviar y recibir bytes entre el puerto serie USB y el Serial 1. Para usar el Serial 2 en lugar del 1, hay que usar el objeto "Serial2".

void setup() {
  // Initialize serial connections
  Serial.begin(9600);
  Serial1.begin(9600);
}

void loop() {
  // Read byte from Serial and send it through Serial1
  if (Serial.available()) { // Check if there is an available byte to read
    Serial1.print(Serial.read());
  }

  // Read byte from Serial1 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 direcciones para comunicarse con los esclavos. Es un bus muy usado en la industria, sobre todo para comunicar microcontroladores con sus periféricos en sistemas integrados, normalmente en la misma PCB. La velocidad es de 100 kbit/s en modo estándar.

Configuración del hardware

Los PLC M-Duino tienen un puerto I2C, con los pines SCL y SDA. Estos pines se deben activar con el interruptor superior izquierdo de la zona A (hay que seleccionar SCL y SDA en los interruptores 3 y 4). Para más información sobre los interruptores, consulta la sección "Instalación y configuración" de esta página.

Se pueden conectar otros dispositivos a este bus como esclavos. Al conectarlos, ten en cuenta estas especificaciones:

  • El puerto I2C trabaja a 5 V. Una tensión mayor puede dañar el PLC.
  • Los pines I2C, SCL y SDA, tienen resistencias pull-up a 5 V.

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

Configuración del software

El I2C se puede usar con la biblioteca "Wire". Mira el siguiente ejemplo, que implementa un escáner I2C que busca en el bus cualquier dispositivo conectado. Cuando detecta uno, lo indica en el monitor serie. Si conectas los pines I2C (SDA y SCL) a otro dispositivo, debería aparecer en el escaneo.

Antes de ejecutar el código, comprueba que el PLC está bien alimentado, que el paquete de placas "industrialshields" está correctamente instalado en Arduino IDE y que has seleccionado el modelo de PLC correcto en el 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");
  }
}

SPI#

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

El PLC M-Duino tiene un puerto SPI.

Configuración del hardware

Para usar SPI, hay que conectar correctamente los 3 pines mencionados (SCLK, MISO, MOSI):

Función

Pin del PLC M-Duino

Pin del Arduino Mega

MISO

SO

50

MOSI

SI

51

RELOJ

SCK

52

RST

Reset

Reset

¡Atención! El SPI trabaja con niveles de 5 V; una tensión mayor puede dañar el PLC.

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

Configuración del software

El paquete de placas "industrialshields" incluye una biblioteca SPI basada en la biblioteca SPI de Arduino. Esta biblioteca permite programar el M-Duino como maestro SPI.

Este programa muestra cómo configurar el M-Duino 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 este post: Bus SPI en los PLC Arduino de Industrial Shields

Funciones adicionales: RTC, microSD, pines de 5 V

Reloj de tiempo real (DS1307)#

RTC significa Real Time Clock (reloj de 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 (importante cuando funciona con una alimentación alternativa).
  • Libera al sistema de control principal para las tareas críticas en tiempo.
  • A veces es más preciso que otros métodos.

El PLC M-Duino incluye un módulo RTC DS1307, que se comunica con el microcontrolador Arduino mediante I2C. El reloj de tiempo real serie DS1307 es un reloj y calendario de bajo consumo en formato decimal codificado en binario (BCD) que incluye 56 bytes de NV SRAM. Proporciona segundos, minutos, horas, día de la semana, fecha, mes y año.

Para alimentar el RTC cuando el PLC no está conectado, el PLC incluye una pila de botón de litio de 3,3 V que puede alimentar el RTC.

No hace falta ninguna configuración de hardware para usar el RTC; solo es necesario que el PLC esté bien alimentado con una fuente de 12-24 Vdc y que tenga una pila de botón de litio para mantener la hora cuando el PLC no tiene alimentación.

Configuración del software

Para trabajar con el RTC puedes usar la biblioteca RTC, incluida en nuestro paquete de placas. Mira el siguiente ejemplo de código, que lee la hora del RTC y la muestra en el monitor serie.

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

Tarjeta microSD#

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

El PLC M-Duino incorpora una ranura para tarjeta SD con las siguientes especificaciones:

  • Ranura microSD.
  • Hasta 32 GB de almacenamiento (se pueden usar tarjetas de más capacidad, pero solo serán accesibles y utilizables los primeros 32 GB).
  • Sistemas de archivos admitidos: FAT32 y FAT16.

La ranura SD se comunica con el M-Duino mediante SPI y no necesita configuración de hardware. Recuerda alimentar el PLC con una fuente adecuada de 12-24 Vdc.

Configuración del hardware

Para usar la SD con los PLC M-Duino, revisa el interruptor superior izquierdo de la zona A. Para más información sobre los interruptores, consulta la sección "Instalación y configuración" de esta página.

Configuración del software

El paquete de placas "industrialshields" incluye una biblioteca SD que facilita su uso. Mira el siguiente ejemplo, que inicializa la tarjeta SD y muestra 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();
  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();
  }
}

Pines directos de Arduino#

Si necesitas otro puerto serie en este equipo, puedes usar algunos pines digitales para crearlo. La biblioteca SoftwareSerial permite la comunicación serie en otros pines digitales del Arduino, replicando la función por software. Se pueden tener varios puertos serie por software con velocidades de hasta 115200 bps. Un parámetro habilita la señalización invertida para los dispositivos que usan ese protocolo.

Solo se pueden usar las E/S de 5 V de las placas Ardbox o M-Duino.

Pines del M-DuinoPines del Arduino Mega
MISO50
MOSI51
SCK52

Señales de 5 Vdc#

Estos pines se pueden programar con las funciones de Arduino, por ejemplo como E/S de 5 V o con cualquier otra función disponible en el pin.

  • Pines I2C: SDA/SCL: el protocolo I2C está pensado para funcionar con pull-up. En este caso lee 5 V cuando no hay nada conectado.
  • Serial 0: RX0/TX0: los pines de Serial0 también pueden funcionar como pines de 5 V. Si los usas, la comunicación USB no puede funcionar a la vez.
  • Serial 1: RX1/TX1: los pines de Serial1 también pueden funcionar como pines de 5 V. Siempre habilitados.
  • SPI: MISO/MOSI/SCK: estos pines solo pueden funcionar como pines de 5 V si no se va a usar Ethernet. Como Ethernet usa el SPI para comunicarse con la placa Arduino, ambos usos no pueden darse a la vez porque Ethernet dejaría de funcionar.
  • Pin2/Pin3: estos pines solo corresponden a las entradas I0.5/I0.6. Si el interruptor está en OFF, los pines Pin 2/Pin 3 estarán disponibles.

Proyectos y recursos de PLC Arduino

Casos de estudio de PLC Arduino con M-Duino#

Consulta todos los proyectos en la biblioteca de casos de estudio de PLC Arduinoenlace.​

Cursos, ejemplos y documentos#

Preguntas frecuentes sobre el PLC Arduino#

¿Qué es un PLC Arduino?

Un PLC Arduino es un controlador lógico programable industrial basado en una placa Arduino original, con entradas y salidas industriales, caja para carril DIN y alimentación de 12 a 24 Vdc. El M-Duino es la gama de PLC Arduino de Industrial Shields para proyectos con más puntos de E/S.

¿Cómo se programa el PLC Arduino M-Duino?

Con Arduino IDE y el paquete de placas de Industrial Shields, en C y C++. Cada borne tiene su propio nombre en el código: la entrada I0.7 se lee como I0_7.

¿Qué fuente de alimentación necesita el M-Duino?

Una fuente externa de 12 a 24 Vdc de al menos 2 A. La alimentación por USB no basta para que el PLC funcione correctamente.

¿Qué protocolos de comunicación admite el M-Duino?

Ethernet, RS-485, RS-232, Serial TTL, I2C y SPI, además de Modbus RTU, Modbus TCP y MQTT mediante bibliotecas.

¿Cuáles son los rangos de las E/S analógicas del PLC Arduino?

Las entradas analógicas leen de 0 a 10 Vdc con una resolución de 10 bits (0 a 1023). Las salidas analógicas entregan de 0 a 10 Vdc con una resolución de 8 bits.

¿Qué modelos M-Duino tienen certificación ETL?

Los M-Duino 21, 42 y 58. Todos los modelos cuentan con CE y RoHS.

Ninguna sección coincide con tu búsqueda. Prueba con el nombre de un pin, un protocolo o un componente.