PLC Arduino Ardbox: características técnicas

Qué es el PLC Arduino Ardbox#

El Ardbox es el PLC Arduino compacto de Industrial Shields, basado en el Arduino Leonardo. Ofrece 20 puntos de E/S en un formato más pequeño que el M-Duino, montado en carril DIN y alimentado a 12 a 24 Vdc, para máquinas, cuadros de control compactos y sistemas distribuidos donde el espacio es limitado.

El Ardbox se programa en C y C++ con Arduino IDE y el paquete de placas de Industrial Shields. Incluye RS-485 o RS-232 (a elegir en la compra), I2C y SPI, y puede añadir Wi-Fi y Bluetooth, GPRS, DALI o LoRa en el momento de la compra. Entre los protocolos admitidos está Modbus RTU sobre RS-485.

Certificaciones: CE y RoHS. Cuando un proyecto necesita más de 20 puntos de E/S o certificación ETL, el M-Duino es la opción de mayor tamaño. Para tener control, Linux e IA en un mismo equipo, consulta el Ardbox Q, basado en Arduino UNO Q: su arquitectura es distinta y no se trata en esta página.

Modelos Ardbox y E/S#

Los dos modelos Ardbox tienen 20 puntos de E/S. El modelo Analog añade pines analógicos y el modelo Relay añade salidas de relé.

Lee la presentación de la familia de PLC Ardbox o descarga fichas técnicas, guías de usuario y certificados desde la documentación técnica.

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++. Industrial Shields recomienda Arduino IDE para programar los PLC basados en Arduino, aunque con los controladores de Industrial Shields se puede usar cualquier software compatible con Arduino.

El paquete de placas de Industrial Shields te permite seleccionar tu PLC basado en Arduino en Arduino IDE y compilar tus sketches para cada modelo de PLC.

Descarga Arduino IDE:

Página oficial de Arduino IDE

Instala las placas de Industrial Shields en Arduino IDE:

Cómo instalar las placas de Industrial Shields

Relacionado: cargar un bootloader en un PLC Ardbox, cargar un sketch en un Ardbox desde la línea de comandos de Linux.

Versiones y opciones del Ardbox#

La familia Ardbox se compone de 2 modelos principales:

Ardbox Analog

Ardbox Relay

Los dos modelos pueden añadir las siguientes comunicaciones, a elegir en el momento de la compra:

• Wi-Fi y Bluetooth
• GPRS
• DALI
• LoRa

La comunicación RS-485 o RS-232 también se elige en el momento de la compra.

La diferencia entre los dos PLC es que el modelo Relay añade salidas de relé, mientras que el modelo Analog añade pines analógicos.

Relacionado: Wi-Fi y Bluetooth en el PLC Ardbox.

Fuente de alimentación: 12 a 24 Vdc#

Todos los PLC basados en Arduino se pueden alimentar entre 12 y 24 Vdc. La familia Ardbox necesita una fuente de alimentación que dé hasta 1,5 A (potencia nominal de 30 W); el consumo de cada modelo está en la tabla de esta página.

Se recomienda una fuente de alimentación de 2 A o más. Cualquier fuente de alimentación industrial es una buena opción para alimentarlos.

Recuerda: nuestros equipos están diseñados para alimentarse entre 12 y 24 Vdc. Alimentado solo por USB, el equipo no puede realizar sus funciones. El USB solo sirve para programar los PLC, no para alimentarlos.

Si por algún motivo quieres usar una fuente de alimentación de menos de 1,5 A, contacta con el soporte técnico de Industrial Shields para asegurarte de que tu sistema funcionará sin problemas de alimentación.

El siguiente esquema muestra cómo alimentar cualquier equipo de Industrial Shields.

Interruptores DIP: Ardbox Analog#

El Ardbox Analog tiene tres zonas de interruptores:

Zona izquierda: interruptor de comunicaciones

Zona superior: interruptor RO-DI

No puedes usar ambos a la vez: si las salidas están en ON, RS (RS-485) debe estar en OFF, y viceversa.

Zona derecha: interruptor de salidas D/A

La zona derecha configura las salidas. Si el interruptor está en ON, Q0.X funciona como salida digital. Si está en OFF, funciona como salida analógica. Otro interruptor selecciona half-duplex o full-duplex para RS-485: ON para half-duplex y OFF para full-duplex.

Interruptores DIP: Ardbox Relay#

El Ardbox Relay tiene dos zonas de interruptores:

Zona superior

Zona derecha

Consumo por modelo#

Consumo medido de cada modelo en reposo y a plena carga.

Ardbox Analog

Ardbox Relay

Entradas analógicas: 0 a 10 Vdc#

Las entradas analógicas del Ardbox aceptan de 0 a 10 Vdc con 10 bits de resolución; no están aisladas y comparten el GND interno. Las E/S digitales y analógicas tienen aislamiento propio, así que se pueden conectar a una fuente de alimentación distinta de 24 Vdc.

Entradas del Ardbox Analog: 6 u 8 analógicas (0 a 10 Vdc), configurables por software.

Si se usa la comunicación RS-485, que es la configuración por defecto, solo tendrás 6 entradas analógicas. Si quieres tener 8, configúralo en el interruptor izquierdo del PLC: pon I0.8 e I0.9 en ON y RS485 en OFF.

  int IO2 = analogRead(I0_2);
  int IO3 = analogRead(I0_3);
  int IO4 = analogRead(I0_4);
  int IO5 = analogRead(I0_5);
  int IO6 = analogRead(I0_6);
  int IO7 = analogRead(I0_7);
  int IO8 = analogRead(I0_8);
  int IO9 = analogRead(I0_9);

Relacionado: entradas analógicas de un PLC industrial, convertir 4-20 mA a 0-10 V en un PLC Arduino.

Entradas digitales: 5 a 24 Vdc#

Las entradas digitales ven una tensión de -Vcc (o GND) a +Vcc, sin valores intermedios. Dos estados: 0 (-Vcc o GND) y 1 (+Vcc). Las E/S digitales y analógicas tienen aislamiento propio, así que se pueden conectar a una fuente de alimentación distinta de 24 V.

Entradas del Ardbox Analog: 8 o 10 digitales (5 a 24 Vdc).

Si se usa la comunicación RS-485, que es la configuración por defecto, solo tendrás 8 entradas digitales. Si quieres tener 10, configúralo en el interruptor izquierdo del PLC: pon I0.8 e I0.9 en ON y RS485 en OFF.

  int IOO = digitalRead(I0_0);
  int IO1 = digitalRead(I0_1);
  int IO2 = digitalRead(I0_2);
  int IO3 = digitalRead(I0_3);
  int IO4 = digitalRead(I0_4);
  int IO5 = digitalRead(I0_5);
  int IO6 = digitalRead(I0_6);
  int IO7 = digitalRead(I0_7);
  int IO8 = digitalRead(I0_8);
  int IO9 = digitalRead(I0_9);

Relacionado: entradas digitales de un controlador industrial, entradas digitales PNP en un PLC industrial.

Entrada de interrupción (I0.0)#

Una rutina de servicio de interrupción (ISR) es un mecanismo que permite asociar una función a un evento concreto. Cuando ocurre el evento, el procesador sale de inmediato del flujo normal del programa y ejecuta la función ISR asociada, ignorando cualquier otra tarea.

Entradas del Ardbox Analog: 1 entrada de interrupción (5 a 24 Vdc), que también puede funcionar como entrada digital (24 Vdc).

En este ejemplo activamos INT1 con el pin I0_0.

  #define INTERRUPT I0_0 // other pins: I0_3, I0_2, I0_1

  volatile bool state = false;

  void setup() {
    pinMode(INTERRUPT, INPUT_PULLUP);
    attachInterrupt(digitalPinToInterrupt(INTERRUPT), function_call_back, CHANGE);
  }

  void loop() {
    if (state == true){
      Serial.println("Interrupt activated");
      state = false;
    }
  }

  void function_call_back(){ //Change led state
    state = true;
  }

Salidas analógicas: 0 a 10 Vdc#

Una salida analógica puede tomar cualquier valor entre -Vcc (o GND) y +Vcc: proporciona una tensión fijada por un valor digital codificado con un número de N bits. Las E/S digitales y analógicas tienen aislamiento propio, así que se pueden conectar a una fuente de alimentación distinta de 24 V.

Salidas del Ardbox Analog: 7 salidas analógicas (0 a 10 Vdc): 7 salidas digitales se pueden convertir en analógicas con el interruptor de la zona derecha.

  analogWrite(A0_0, 255);
  analogWrite(A0_1, 10);
  analogWrite(A0_2, 0);
  analogWrite(A0_3, 240);
  analogWrite(A0_4, 124);
  analogWrite(A0_5, 100);
  analogWrite(A0_6, 200);
  analogWrite(A0_6, 20);

  // CONFIGURE THE RIGHT SWITCH WITH ALL OUTPUT AS ANALOG(OFF)
  analogWrite(Q0_0, 182);
  analogWrite(Q0_1, 30);
  analogWrite(Q0_2, 50);
  analogWrite(Q0_3, 10);
  analogWrite(Q0_4, 0);
  analogWrite(Q0_5, 100);
  analogWrite(Q0_6, 255);

Relacionado: salidas analógicas de un PLC industrial.

Salidas digitales: 5 a 24 Vdc#

Una salida digital conmuta entre -Vcc (o GND) y +Vcc, sin valores intermedios. Dos estados: 0 (-Vcc o GND) y 1 (+Vcc). Las E/S digitales y analógicas tienen aislamiento propio, así que se pueden conectar a una fuente de alimentación distinta de 24 V.

Salidas del Ardbox Analog: 10 salidas digitales (5 a 24 Vdc); 7 de ellas pueden dar PWM (5 a 24 Vdc).

  // CONFIGURE THE RIGHT SWITCH WITH ALL OUTPUT AS DIGITAL(ON)
  digitalWrite(Q0_0, HIGH);
  digitalWrite(Q0_1, LOW);
  digitalWrite(Q0_2, HIGH);
  digitalWrite(Q0_3, LOW);
  digitalWrite(Q0_4, HIGH);
  digitalWrite(Q0_5, HIGH);
  digitalWrite(Q0_6, LOW);
  digitalWrite(Q0_7, LOW);
  digitalWrite(Q0_8, LOW);
  digitalWrite(Q0_9, HIGH);

Relacionado: salidas digitales de un PLC industrial, salidas optoaisladas del Ardbox.

Salidas de relé (Ardbox Relay)#

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 y se accede a ellos directamente con la función digitalWrite(RX, HIGH). Los relés de Industrial Shields son normalmente abiertos y admiten una corriente máxima de 4 A hasta 230 Vac y de 2 A hasta 24 Vdc.

Salidas del Ardbox Relay: 8 salidas de relé, de R1 a R8 (230 Vac, 4 A).

  // Close the relay contacts (relay on)
  digitalWrite(R1, HIGH);
  digitalWrite(R2, HIGH);
  digitalWrite(R3, HIGH);
  digitalWrite(R4, HIGH);
  digitalWrite(R5, HIGH);
  digitalWrite(R6, HIGH);
  digitalWrite(R7, HIGH);
  digitalWrite(R8, HIGH);

  delay(500);

  // Open the relay contacts (relay off)
  
  digitalWrite(R1, LOW);
  digitalWrite(R2, LOW);
  digitalWrite(R3, LOW);
  digitalWrite(R4, LOW);
  digitalWrite(R5, LOW);
  digitalWrite(R6, LOW);
  digitalWrite(R7, LOW);
  digitalWrite(R8, LOW);

Relacionado: relés internos y salidas de relé en un PLC.

Salidas PWM y avr-Pulses#

La modulación por ancho de pulso (PWM) activa una salida digital durante una parte del periodo y la mantiene desactivada el resto. La tensión media de salida, a lo largo del tiempo, es igual al valor analógico deseado. La frecuencia del pulso se mantiene y lo que cambia es su ancho.

Una salida PWM da un valor Vcc durante un tiempo determinado.
Atención a la tensión de alimentación, porque la salida PWM tendrá la misma diferencia de tensión.

Las salidas digitales/PWM Q0.0, Q0.1, Q0.2, Q0.3, Q0.4, Q0.5 y Q0.6 también funcionan como salidas analógicas A0.0, A0.1, A0.2, A0.3, A0.4, A0.5 y A0.6.

Trenes de pulsos con la biblioteca avr-Pulses

El módulo Pulses de la biblioteca avr-Pulses ofrece funciones para iniciar y detener un tren de pulsos a la frecuencia deseada con los pines PWM.

La función startPulses(pin, frequency, precision) inicia el tren de pulsos con la frecuencia y la precisión indicadas. La frecuencia por defecto es 1 kHz y la precisión por defecto es 3.

pinMode(3, OUTPUT);
startPulses(3, 2000, 3);

La función stopPulses(pin) detiene el tren de pulsos.

stopPulses(3);

Importante: no se pueden tener frecuencias distintas en pines que comparten el mismo temporizador. Algunas salidas comparten temporizador, así que trabajan a la misma frecuencia.

Precaución: cuando se usan los pines del TIMER0, las funciones de tiempo como delay(), millis(), micros() y delayMicroseconds() cambian su comportamiento.

Precisión recomendada para cada rango de frecuencia:

Para tener una precisión alta en la frecuencia deseada, usa la precisión que corresponde al rango de la tabla anterior. Consulta el código de ejemplo en Biblioteca del módulo Pulses para PLC basados en Arduino.

El Ardbox Relay no tiene salidas PWM.

RS-485: half-duplex y full-duplex#

RS-485, 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. La señalización eléctrica es balanceada y admite sistemas multipunto.

Antes de usar esta comunicación serie, comprueba que los interruptores y los jumpers están bien configurados.

Ejemplos de RS-485 con Arduino

Ejemplo básico de escritura RS-485 (envío):

// Include Industrial Shields libraries
#include 

//// 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 

//// IMPORTANT: check switches configuration

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

Ejemplo básico de RS-485 full-duplex:

// Include Industrial Shields libraries
#include 
//// IMPORTANT: check switches configuration
//// IMPORTANT: Full duplex mode is only available when device supports it
////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
  // Begin serial port
  Serial.begin(9600);
  // Begin RS485 port
  RS485.begin(38400, FULLDUPLEX);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void loop() {
  // Wait bytes from the RS-485
  if (RS485.available()) {
    byte tx = RS485.read();
    // In full-duplex mode it is possible to send and receive data
    // at the same time in a secure way
    RS485.write(tx);
    // Echo the byte to the serial port
    Serial.write(tx);
  }
}

Para probar el modo full-duplex, conecta A y B (receptores) a Y y X (emisores).

Relacionado: conceptos básicos de RS-485, RS-485 con PLC basados en Arduino y ESP32, conectar dos PLC por RS-485.

RS-232#

RS-232, también conocido como TIA-232-F, EIA-232-F o V.24, es un estándar para la transmisión de datos por comunicación serie. Especifica los niveles de tensión, la temporización de las señales y el protocolo de datos para la comunicación entre dispositivos.

Antes de usar esta comunicación serie, comprueba que los interruptores y los jumpers están bien configurados.

Ejemplos de RS-232 con Arduino

Ejemplo básico de escritura RS-232

// Include Industrial Shields libraries
#include 
//// IMPORTANT: check switches configuration
//////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
  // Begin serial port
  Serial.begin(9600);
  // Begin RS232 port
  RS232.begin(38400);
}

///////////////////////////////////////////////////////////////////////////////////////////////
void loop() {
  // Wait bytes in the serial port
  if (Serial.available()) {
    byte tx = Serial.read();
    // Echo the byte to the serial port again
    Serial.write(tx);
    // And send it to the RS-232 port
    RS232.write(tx);
  }   
}

Ejemplo básico de lectura RS-232

// Include Industrial Shields libraries
#include 

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

Relacionado: conceptos básicos de RS-232, prueba de RS-232 en el Ardbox.

I2C#

I2C es un protocolo síncrono que usa solo 3 cables: reloj (SCL), datos (SDA) y tierra (GND). Esto significa que el maestro y el esclavo envían datos por el mismo cable, que controla el maestro, que es quien genera la señal de reloj. I2C usa direcciones para seleccionar los esclavos.

I2C es un bus de comunicación serie. La velocidad es de 100 kbit/s en modo estándar, pero también admite velocidades de 3,4 Mbit/s. Es un bus muy usado en la industria, sobre todo para comunicar microcontroladores con sus periféricos en sistemas integrados o para comunicar circuitos integrados de la misma PCB.

Antes de usar esta comunicación serie, comprueba que los interruptores y los jumpers están bien configurados.

Ejemplo de escáner I2C

Importante: comprueba que el paquete de placas de Industrial Shields está instalado en Arduino IDE.

Ejemplo sencillo de escaneo I2C:

#include 

void setup() {
  Wire.begin();
  Serial.begin(9600);
  while (!Serial); // Leonardo: wait for Serial Monitor
  Serial.println("\nI2C Scanner");
}

void loop() {
  int nDevices = 0;
  Serial.println("Scanning...");

  for (byte address = 1; address < 127; ++address) {
    Wire.beginTransmission(address);
    byte 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
}

Relacionado: bus I2C en un PLC basado en Arduino, configurar un I2C externo.

SPI#

SPI es un bus de comunicación síncrono con arquitectura maestro-esclavo. Los esclavos no pueden iniciar la comunicación ni intercambiar datos directamente entre ellos. Solo el maestro puede seleccionar el esclavo con el que se comunica mediante el pin SS (slave select).

Ejemplo de SPI

// include the SPI library:
#include 

// set pin 10 as the slave select for the digital pot:
const int slaveSelectPin = 10;

void setup() {
  // set the slaveSelectPin as an output:
  pinMode(slaveSelectPin, OUTPUT);
  // initialize SPI:
  SPI.begin();
}

void loop() {
  // go through the six channels of the digital pot:
  for (int channel = 0; channel < 6; channel++) {
    // change the resistance on this channel from min to max:
    for (int level = 0; level < 255; level++) {
      digitalPotWrite(channel, level);
      delay(10);
    }
    // wait a second at the top:
    delay(100);
    // change the resistance on this channel from max to min:
    for (int level = 0; level < 255; level++) {
      digitalPotWrite(channel, 255 - level);
      delay(10);
    }
  }
}

void digitalPotWrite(int address, int value) {
  // take the SS pin low to select the chip:
  digitalWrite(slaveSelectPin, LOW);
  // send in the address and value via SPI:
  SPI.transfer(address);
  SPI.transfer(value);
  // take the SS pin high to de-select the chip:
  digitalWrite(slaveSelectPin, HIGH);
}

Relacionado: bus SPI en los PLC de Industrial Shields.

Pines directos del Arduino Leonardo#

Para añadir otro puerto serie, se pueden usar algunos pines digitales y crear un puerto serie por software. 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 del Ardbox.

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.

Pines SPI MISO/MOSI/SCK: estos pines solo pueden funcionar como pines de 5 V cuando ningún módulo de expansión usa el bus SPI.

Pin 2/Pin 3: en el Ardbox, el pin 2 del Leonardo es la entrada I0.0, y en el Ardbox Relay el pin 3 es la entrada I0.1.

Casos de estudio con Ardbox#

• Monitorización de la cadena de frío de una flota refrigerada con un Ardbox Analog
• Eficiencia de rutas de una flota con datos GPS y un Ardbox Analog
• Mejora de una línea de producción con un PLC Ardbox
• Automatización de habitaciones de hotel con un PLC Ardbox DALI y un panel táctil

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

Cursos, ejemplos y documentos#

• Curso gratuito: Programación de PLC Arduino: fundamentos
• Curso gratuito: Programación de PLC Arduino: aplicaciones industriales
• Simuladores interactivos: clasificación en cinta transportadora, cámara frigorífica, todos los simuladores
• Biblioteca de soluciones PLC: OpenPLC en los PLC de Industrial Shields, calculadora 4-20 mA, cómo elegir un controlador industrial
• Tutoriales: M-Duino o Ardbox para retrofit industrial, tiempo de respuesta del pinout del Ardbox Analog, usar el Ardbox con OpenPLC
• Documentos: Fichas técnicas, guías de usuario y certificados CE del Ardbox

Preguntas frecuentes sobre el PLC Arduino#

¿Qué es el PLC Arduino Ardbox?

El Ardbox es el PLC Arduino compacto de Industrial Shields, basado en el Arduino Leonardo. Ofrece 20 puntos de E/S en carril DIN para máquinas, cuadros de control compactos y sistemas distribuidos donde el espacio es limitado.

¿Cómo se programa el PLC Arduino Ardbox?

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.2 se lee como I0_2 y la salida de relé R1 se escribe como R1.

¿Qué fuente de alimentación necesita el Ardbox?

Una fuente externa de 12 a 24 Vdc; se recomienda de 2 A o más. El USB solo sirve para programar el PLC, no para alimentarlo.

¿Qué comunicaciones incluye el Ardbox?

RS-485 o RS-232, a elegir en la compra, además de I2C y SPI. Wi-Fi y Bluetooth, GPRS, DALI o LoRa se pueden añadir en el momento de la compra.

¿Qué diferencia hay entre el Ardbox Analog y el Ardbox Relay?

Los dos tienen 20 puntos de E/S. El Ardbox Analog tiene 8 entradas analógicas, 2 entradas digitales y 10 salidas digitales, 7 de ellas configurables como salidas analógicas de 0 a 10 Vdc. El Ardbox Relay tiene 6 entradas analógicas, 4 entradas digitales, 2 salidas digitales y 8 salidas de relé.

¿Cuándo conviene elegir un M-Duino en lugar de un PLC Arduino Ardbox?

Cuando el proyecto necesita más de 20 puntos de E/S o certificación ETL, que solo tienen los M-Duino 21, 42 y 58. El Ardbox cuenta con CE y RoHS.