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 Pública General de GNU. Arduino IDE soporta estructuración de código C y C++. Para programar los PLCs basados en Arduino Mega en este entorno, Industrial Shields proporciona un paquete de placas con las librerías y herramientas necesarias.

We recommend using the Legacy Arduino IDE (1.8.X) to program M-Duino based PLCs, although other Arduino compatible software could be used. The Arduino 1.8.X IDE can be downloaded from .​ Después de descargar e instalar el IDE de Arduino, instala el paquete de placas industrialshields dentro del IDE. Esto se puede hacer siguiendo este tutorial y seleccionando el paquete industrialshields en el paso número 6.

Fuente de alimentación

Interruptores DIP

Los PLCs basados en M-Duino tienen algunos interruptores que se pueden utilizar para configurar ciertas funcionalidades del PLC. En esta sección se explica cómo utilizarlos adecuadamente. Para diferenciar las distintas partes del PLC y ubicar cada interruptor en consecuencia, se utilizará la siguiente nomenclatura:

En cada zona hay uno o varios interruptores, que se utilizan para configurar algunas de las funcionalidades del PLC. En las tablas siguientes se indica la finalidad de cada interruptor y cómo configurarlos.

Zona A: interruptor superior izquierdo

Interruptor superior:

1. Si este conmutador está en ON, habilita la entrada I1.X y deshabilita TX1. Si este conmutador está en OFF, habilita TX1 y deshabilita I1.X.
   
2. Si este conmutador está en ON, habilita la entrada I1.X y deshabilita RX1. Si este conmutador 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 este conmutador 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 este conmutador está en OFF, habilita SCL y deshabilita I2.X.

Interruptor inferior:

1. Si este conmutador está en ON, habilita la opción Half Duplex (HD) y deshabilita la FD. Si este conmutador está en OFF, habilita la opción Full Duplex (FD) y deshabilita la HD.
2. Si este interruptor está en OFF, habilita el Chip Select de la tarjeta microSD. En algunos modelos de PLC M-Duino, si este interruptor 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 este interruptor 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 este interruptor está en OFF, habilita el Pin 3 y deshabilita I0.X.

*La X representa diferentes pines para los diferentes modelos de PLC M-Duino.

Zona A: interruptor inferior izquierdo

Sólo se utilizan los interruptores 1 y 2. Ambos interruptores activan la comunicación para comunicarse con el RTC mediante I2C. Teniendo estos interruptores en modo ON se activa esta comunicación, mientras que si está en modo OFF desactiva el I2C para llegar al RTC.

​

Zona B, C y D: Interruptor analógico

Estos conmutadores se utilizan para elegir entre salida digital o analógica, según la tabla anterior. Si está en OFF, sólo estará disponible la salida analógica correspondiente. Si está en ON, sólo estará disponible la salida digital correspondiente. Los conmutadores se comportan de la misma forma en las zonas B, C y D, siendo el valor "X" diferente según la zona:

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

Consumo de energía

Este informe explora cómo consumen energía los distintos modelos de PLC M-Duino en situaciones de reposo y de alto rendimiento. Comprender estos patrones es crucial para optimizar la eficiencia en aplicaciones industriales.

Reposo

In this scenario, the M-Duino PLC is powered on, with all pins and communications turned off and utilizing a 24V power supply. This test measures the baseline power consumption when the device is idle and not actively engaged in any processing or output tasks.

Todas las salidas en ALTO

Para esta prueba, el PLC M-Duino está configurado para poner todos sus pines de salida en un estado alto, consumiendo la máxima corriente para las operaciones de salida y utilizando una fuente de alimentación de 24V. De este modo se obtiene información sobre el consumo de energía cuando el dispositivo conduce activamente las señales de salida.

Entradas analógicas

La entrada analógica proporciona una forma de leer los niveles de tensión analógica, codificando el valor con un número de N bits. Las entradas analógicas del PLC basado en M-Duino utilizan el GND interno como referencia (el mismo que la fuente de alimentación). Las entradas analógicas en estos PLCs tienen las siguientes especificaciones:

• Rango de tensión: de 0 a 10 Vc.
• Resolución: 10 bits, lo que significa que los valores leídos pueden oscilar entre 0 y 1023.
  

Además, las entradas analógicas también pueden utilizarse como entradas digitales no aisladas que toleran hasta 24Vcc. Para ello, consulte el apartado de entradas digitales. Las entradas analógicas son las comprendidas entre IX.7 y IX.12, siendo X 0, 1 ó 2 según la zona. Puede identificar las entradas analógicas de su equipo con el siguiente símbolo:

Entrada analógica 0V - 10Vdc 

  

El siguiente diagrama ilustra las conexiones necesarias para utilizar correctamente una entrada analógica (cuando se utiliza como digital, la entrada puede tolerar hasta 24V):

Configuración de software

Para utilizarlas, las entradas analógicas deben configurarse en la parte de configuración del código, como se hace habitualmente en las placas Arduino comunes. Luego se pueden leer usando 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));
}

El siguiente post también puede ser de interés: Aprende las funciones básicas sobre las entradas analógicas de un PLC industrial.​

Entradas digitales

Las entradas digitales se utilizan para capturar señales que existen en uno de dos estados: alto o bajo, verdadero o falso, etc. Las entradas digitales del PLC M-Duino interpretan como altos valores de 5 Vcc o superiores, hasta 24 Vcc, mientras que valores inferiores a 5V se interpretan como bajos. Hay 2 tipos de entradas que se pueden utilizar como entrada digital:

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

Puede identificarlos con los siguientes símbolos:

Entrada aislada de 5 V - 24 V

 

Entrada no aislada de 5 V - 24 V

 

Los siguientes diagramas ilustran las conexiones necesarias para utilizar correctamente ambas entradas como digitales:

Configuración de software

Para utilizarlas, las entradas digitales deben configurarse en la parte de configuración del código, como se hace habitualmente en las placas Arduino comunes. Luego se pueden leer usando 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));
}

Los siguientes posts amplían este tema:Conceptos básicos: entradas digitales de un PLC industrial, Entradas digitales PNP en un PLC industrial.​

Entradas de interrupción

Algunas de las entradas digitales del PLC M-Duino tienen capacidad de interrupción, lo que significa que pueden utilizarse con ISRs (rutina de servicio de interrupción) para desencadenar la ejecución de determinado código cuando se detecta un evento (un cambio de estado en el pin). Hay dos pines de este tipo por zona: IX.5 y IX.6. Se utilizan y conectan como entradas digitales aisladas normales, y las interrupciones se programan mediante software.

Configuración del hardware

Las entradas de interrupción deben activarse mediante los interruptores superiores de la zona A:

• I0.5 e I0.6 también funcionan como Pin3 y Pin2. Habilite las interrupciones poniendo en ON los interruptores número 3 y 4 de los interruptores de comunicación descendente.
• I1.5 e I1.6 también funcionan como Tx1 y Rx1. Habilite las interrupciones poniendo en ON los interruptores número 1 y 2 de los interruptores de comunicación ascendente.
• I2.0 e I2.1 también funcionan como SCA y SCL. Habilite las interrupciones activando los interruptores número 3 y 4 de los interruptores de comunicación. En este caso no podrás utilizar I2C.
  

Consulte la sección "Instalación inicial - Hardware" de esta página para obtener más información.

Configuración del software

Este es un ejemplo de cómo utilizar 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

Configuración del software

El procedimiento para programar las salidas analógicas es el mismo que Arduino normal: en primer lugar, el modo de pin se debe establecer en "OUTPUT" en la configuración del código, y luego la salida se puede escribir utilizando "analogWrite()". Las salidas analógicas pueden ser referenciadas por su nombre y utilizando un "_" en lugar del ".". Por ejemplo, A0.5 se utiliza como A0_5:

void setup()
{
    pinMode(A0_0,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: Funciones básicas de las salidas analógicas de un PLC industrial.

Salidas digitales

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

El valor alto de salida puede oscilar entre 5 y 24 Vcc. Esta tensión debe ajustarse mediante dos pines situados junto a las salidas: QVdc y COM(-). Por ejemplo, si desea ajustar la salida a 24V, el pin QVdc debe conectarse a 24V y el pin COM(-) a GND. El siguiente diagrama ilustra un ejemplo de conexión:

Salida digital (PWM opcional)

Configuración de software

Las salidas digitales deben ser configuradas en la parte de setup del código como se hace habitualmente en las placas Arduino comunes, usando primero "pinMode()" para establecerlo como "OUTPUT", y "digitalWrite()" para cambiar el valor de 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);
}

Puede obtener más información sobre las salidas digitales en este post: Funciones básicas de las salidas digitales de un PLC industrial.​

Salida PWM

En los PLCs basados en M-Duino, todas las salidas digitales pueden utilizarse como salidas PWM. 

El valor alto de salida puede oscilar entre 5 y 24 Vcc. Al igual que cuando se utilizan como simples salidas digitales, esta tensión debe ajustarse mediante dos pines situados junto a las salidas: QVdc y COM(-). Por ejemplo, si desea ajustar la salida a 24V, el pin QVdc debe conectarse a 24V y el pin COM(-) a GND. El siguiente diagrama ilustra un ejemplo de conexión.

Encontrará un tutorial de ejemplo sobre cómo programar el PLC para utilizar las salidas PWM en esta página web.

Salida con capacidad PWM

Salida de relé

Un relé es un interruptor electromagnético controlado por una señal eléctrica. En las unidades Industrial Shields estos dispositivos ya están integrados en sus placas. Los relés incluidos en el PLC M-Duino pueden trabajar hasta 24 Vcc o 220 Vca. Cada salida de relé tiene dos terminales, y está etiquetada como RX.X. El siguiente diagrama ilustra las conexiones:

Configuración de software

Las salidas de relé deben configurarse en la parte de configuración del código, utilizando funciones de Arduino, y se controlan como si fueran salidas digitales. Las salidas se pueden referenciar por el nombre que aparece en la serigrafía: R0.1 por ejemplo se utiliza como R0_1. Compruebe el siguiente ejemplo. Cuando la salida está en "HIGH", el real i encendido, lo que significa que el interruptor se cierra, mientras que cuando está en "LOW" el interruptor 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: Aprende los conceptos básicos sobre los relés internos de un PLC industrial .

Ethernet

Ethernet es la tecnología más utilizada en 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 habitación, una oficina o un edificio. Se utiliza en contraste con una 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 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 la velocidad de un gigabit por segundo.

Los PLCs M-Duinos incorporan un puerto Ethernet, utilizando el controlador W5500, que se comunica con el Arduino utilizando SPI. El W5500 es un controlador Ethernet embebido TCP/IP Hardwired que facilita la conexión a Internet de los sistemas embebidos. Este chip permite a los usuarios tener conectividad a Internet en sus aplicaciones mediante el uso de un único chip en el que la pila TCP / IP, 10/100 Ethernet MAC y PHY están incrustados. Con este chip, los usuarios pueden integrar Ethernet en sus aplicaciones.

Configuración del software

El paquete de placas Industrial Shields incluye una librería "Ethernet", destinada a facilitar el uso de este protocolo. Se incluyen varios ejemplos con la librería, puedes comprobarlos yendo a Archivo > Ejemplos > Ethernet dentro del IDE de Arduino. 

Eche también un vistazo al siguiente programa. Antes de ejecutar el código, asegúrese de que su PLC está correctamente alimentado, confirme que el cable Ethernet está bien conectado a su dispositivo y asegúrese de que el paquete de placas "industrialshields" está correctamente instalado en su IDE Arduino. Este código sirve como herramienta de diagnóstico para asegurar el correcto funcionamiento del puerto Ethernet. Establece una conexión a "www.google.com" a través del controlador W5500 utilizando la configuración IP 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");
    }
   }
}

RS-485

RS485, también conocido como TIA-485(-A), EIA-485, es un estándar que define las características eléctricas de los controladores y receptores para su uso en sistemas de comunicaciones serie.Los PLCs M-Duino incluyen capacidades RS485 half-duplex, gracias al chip transceptor MAX485 incorporado.

El MAX485 es un transceptor de baja potencia y slew-rate limitado utilizado para la comunicación RS-485. Funciona con una sola fuente de alimentación de +5 V y la corriente nominal es de 300 μA. Al adoptar la comunicación semidúplex para implementar la función de convertir el nivel TTL en nivel RS-485, puede alcanzar una velocidad de transmisión máxima de 2,5 Mbps. El transceptor MAX485 consume una corriente de alimentación de entre 120μA y 500μA en condiciones de descarga o carga completa cuando el controlador está desactivado.

Si desea saber más sobre RS485, consulte esteartículo.

Configuración del hardware

Para utilizar el RS485 con los PLCs M-Duino, compruebe el interruptor de la zona A arriba a la izquierda. El RS485 está siempre activo, pero hay un conmutador (número 1) que sirve para elegir entre half-duplex y full-duplex. Para más información sobre los interruptores, consulte la sección "Instalación inicial - Hardware" en esta página.

Los pines RS485, A+ y B- deben estar correctamente conectados al dispositivo con el que se comunica el PLC. Atención. Recuerde alimentar correctamente el PLC con una fuente de alimentación de 12-24V.

Configuración de software

Nuestro paquete de placas incluye una librería RS485 para facilitar la programación. Esta librería se utiliza como la librería Serial de Arduino, con métodos como "available()", "read()", etc.

Echa un vistazo al siguiente código, que establece una comunicación half duplex y permite al usuario 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
  } 
}

RS232

RS-232 es una norma para la transmisión de datos por comunicación serie. Define formalmente las señales utilizadas en la comunicación entre DTE (Data Terminal Equipment), como un terminal de ordenador, y DCE (Data Circuit-terminating Equipment o Data Communication Equipment), como un módem. El PLC M-Duino incluye un chip transceptor MAX232, que permite la comunicación full-duplex a través de RS232. El MAX232 es un transmisor/receptor dual que se utiliza para convertir las señales RX, TX, CTS, RTS, convirtiendo las señales del puerto serie TTL a TIA-232 (RS-232).

Si quieres saber más sobre RS232, consulta este artículo.

Configuración del hardware

Los pines RS232, TX y RX deben estar correctamente conectados al dispositivo con el que se comunica el PLC. ¡Atención! Recuerde alimentar correctamente el PLC con una fuente de alimentación de 12-24V.

Configuración del software

Una vez realizada la configuración del hardware, se puede proceder a la configuración del software y su uso. En primer lugar, es necesario incluir la librería RS232.h proporcionada por nuestro paquete de placas. Luego, se debe inicializar la comunicación con "RS232.begin(<baudrate>);". Después de esto ya se puede utilizar RS232 con las funciones "RS232.read();" y "RS232.write();".

Comprueba 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 funcionan con una tensión de bajo nivel. Se utilizan dos señales: Tx (Transmitir Datos) y Rx (Recibir Datos), que permiten la comunicación full-duplex. Los PLCs M-Duino tienen dos puertos TTL externos, Serial 0 (RX0/TX0) y Serial 1 (RX1/TX1).

Para obtener más información sobre la interfaz Serial TTL, visite este blog.​

Configuración del hardware

El PLC M-Duino dispone de dos puertos serie. Uno de ellos, el Serial 1 (TX1, RX1), debe activarse mediante el interruptor de la zona A, arriba a la izquierda. Para más información sobre los interruptores, consulte la sección "Instalación inicial - Hardware" en esta página.

Para que la comunicación serie funcione, es necesario realizar las siguientes conexiones entre el PLC y el otro dispositivo: 

• TX -> RX
• RX -> TX
• GND, ambos dispositivos deben compartir una toma de tierra común.

¡Atención! Los puertos serie de los PLCs M-Duino funcionan a niveles de 5V. Niveles de tensión superiores podrían dañar el PLC.

Además, recuerde alimentar correctamente el PLC con una fuente de alimentación adecuada de 12-24Vcc. 

Configuración de software

Para utilizar la comunicación Serial con el PLC, se puede utilizar el objeto "Serial" de Arduino. Compruebe el siguiente ejemplo, que utiliza el Serial 1, para enviar y recibir bytes utilizando el puerto serie USB y el Serial 1. Para utilizar el Serial 2 en lugar del 1, se debe utilizar el objeto "Serial2".

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

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

  // Read byte from Serial 1 and send it through Serial   
  if (Serial1.available()) {
    Serial.print(Serial1.read());
  }
}

I2C

I2C es un protocolo de comunicaciones serie. Es un protocolo síncrono maestro-esclavo y se utilizan 2 cables, uno para el reloj (SCL) y otro para los datos (SDA). El maestro controla el bus y crea la señal de reloj, y utiliza el direccionamiento para comunicarse con los esclavos. Es un bus muy utilizado en la industria, principalmente para comunicar microcontroladores y sus periféricos en sistemas integrados, normalmente ubicados en la misma placa de circuito impreso. La velocidad es de 100 Kbit/s en modo estándar. 

Configuración del hardware 

Los PLCs M-Duino tienen un puerto I2C, con los pines SCL y SDA. Estos pines necesitan ser activados usando el interruptor superior izquierdo de la zona A (SCL y SDA necesitan ser seleccionados en los interruptores 3 y 4). Para más información sobre los interruptores, consulta la sección "Instalación inicial - Hardware" en esta página.

A este bus se pueden conectar otros dispositivos como esclavos. Al conectar otros dispositivos, tenga en cuenta las siguientes especificaciones:

• El puerto I2C funciona a 5V. Niveles de tensión superiores podrían dañar el PLC.
• Los pines I2C, SCL y SDA, se ponen a 5V.

Además, recuerde alimentar correctamente el PLC con una fuente de alimentación adecuada de 12-24Vcc. 

Configuración del software

El I2C se puede utilizar con la librería "Wire". Comprueba el siguiente ejemplo que implementa un escáner I2C que busca en el bus cualquier dispositivo conectado. Cuando un dispositivo es detectado, será reportado al monitor serie. Ten en cuenta que si conectas los pines I2C (SDA y SCL) a otro dispositivo, éste debería aparecer en el escaneo.

Antes de ejecutar el código, asegúrese de que su PLC está correctamente alimentado, compruebe que el paquete de placas "industrialshields" está correctamente instalado en su IDE Arduino y que ha seleccionado el modelo de PLC correcto dentro de su IDE.

#include "Wire.h"

void setup() {
  Serial.begin(115200);
  Wire.begin();
}

void loop() {
  byte error, address;
  int nDevices = 0;

  delay(5000);

  Serial.println("Scanning for I2C devices ...");
  for(address = 0x01; address < 0x7f; address++){
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    if (error == 0){
      Serial.printf("I2C device found at address 0x%02X\n", address);
      nDevices++;
    } else if(error != 2){
      Serial.printf("Error %d at address 0x%02X\n", error, address);
    }
  }
  if (nDevices == 0){
    Serial.println("No I2C devices found");
  }
}

SPI

La Interfaz Periférica en Serie (SPI) es una especificación de interfaz de comunicación serie síncrona utilizada para la comunicación a corta distancia, principalmente en sistemas embebidos. Los dispositivos SPI se comunican en modo dúplex completo utilizando una arquitectura maestro-esclavo, normalmente con un único maestro. En la comunicación SPI se utilizan 3 pines: SCLK, MOSI, MISO. Además, se utiliza un pin extra para cada esclavo, llamado chip select (CS) o slave select (SS) para seleccionar el esclavo con el que se está hablando en el bus.

El PLC M-Duino dispone de un puerto SPI.

Configuración del hardware

Para utilizar el SPI, los 3 pines de mención (SCLK, MISO, MOSI) deben estar correctamente conectados:

¡Atención! El SPI funciona a niveles de tensión de 5V, cualquier tensión superior podría dañar el PLC.

Además, recuerde alimentar correctamente el PLC con una fuente de alimentación adecuada de 12-24Vcc.

Configuración del software

El paquete de placas "industrialshields-esp32" incluye una librería SPI, basada en la librería SPI de Arduino. Esta biblioteca permite programar el ESP32 como maestro SPI.

Este programa muestra cómo configurar el ESP32 como maestro en la 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 un envío y recepción simultáneos) y se imprimen a través del 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 el siguiente post: Bus SPI en un PLC Arduino de Industrial Shields

RTC

RTC son las siglas de Real Time clock (reloj en tiempo real), un dispositivo electrónico que mide el paso del tiempo. Aunque se puede medir el tiempo sin un RTC, utilizar uno tiene ventajas como:

• Mantener la hora sin necesidad de volver a ajustarla tras un reinicio, apagado, etc.
  
• Bajo consumo de energía (importante cuando se funciona con energía alternativa.
• Libera el sistema de control principal para tareas en las que el tiempo es un factor crítico.
• 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 en tiempo real en serie DS1307 es un reloj/calendario de baja potencia, con código decimal binario (BCD) completo, que incluye 56 bytes de SRAM NV. Proporciona información de segundos, minutos, horas, día, 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 utilizarse para alimentar el RTC.

No es necesaria ninguna configuración de hardware para utilizar el RTC, el único requisito es que el PLC esté correctamente alimentado utilizando una fuente de alimentación de 12-24Vdc, y que disponga de una pila de litio tipo botón para mantener la hora cuando el PLC no tenga alimentación.

Configuración de software

La librería RTC, incluida en el paquete de nuestras placas, puede usarse para interactuar con el RTC. Comprueba el siguiente ejemplo de código donde se lee la hora desde el RTC y se imprime en el monitor serie.

Recuerda asegurarte de que tienes el paquete de la placa industrialshields correctamente instalado en tu IDE de Arduino.

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

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

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

• Ranura MicroSD.
• Hasta 32 GB de almacenamiento (aunque se pueden utilizar tarjetas de mayor capacidad, sólo los primeros 32 GB serán accesibles y utilizables).
• Se admiten FAT32 y FAT16 como arquitecturas de sistema de archivos.

La ranura SD se comunica con el M-Duino mediante SPI, y no es necesaria ninguna configuración de hardware. Recuerde alimentar el PLC con una fuente de alimentación adecuada de 12-24Vdc.

Configuración del hardware

Para utilizar la SD con los PLCs M-Duino, active el interruptor superior izquierdo de la zona A. Para más información sobre los interruptores, consulte la sección "Instalación inicial - Hardware" en esta página.

Configuración del software

El paquete de placas "industrialshields" incluye una librería SD para facilitar su uso. Compruebe el siguiente ejemplo, que inicializa la tarjeta SD e imprime el contenido de su directorio raíz a través del 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 queremos usar otro Puerto Serie usando este equipo, podemos hacer uso de algunos pines digitales para crear un Serial. La librería SoftwareSerial ha sido desarrollada para permitir la comunicación serie en otros pines digitales del Arduino, usando software para replicar la funcionalidad. Es posible tener múltiples puertos serie software con velocidades de hasta 115200 bps. Un parámetro habilita la señalización invertida para dispositivos que requieran ese protocolo.

Sólo se pueden utilizar E/S de 5V de placas Ardbox o M-Duino.

Señales de 5 Vcc

Estos pines pueden ser programados de acuerdo a las características de Arduino, tales como E/S que operan a 5V o cualquier característica adicional presente en los pines.

• I2C Pins – SDA/SCL: El protocolo I2C está pensado para trabajar en una configuración pull-up. En este caso lee 5V cuando no hay nada conectado.
• Serial 0 – RX0/TX0: El protocolo Serial0 puede funcionar también como pin de 5V. Si se utilizan estos pines, la comunicación USB no puede funcionar al mismo tiempo.
• Serial 1 – RX1/TX1: El protocolo Serial1 puede funcionar también como pin de 5V. Siempre activado.
• SPI – MISO/MOSI/SCK: Estos pines sólo pueden funcionar como pines de 5V si no se va a utilizar el protocolo Ethernet. Como el protocolo Ethernet utiliza el SPI para comunicarse con la placa Arduino, ambos comportamientos no pueden ocurrir al mismo tiempo ya que la Ethernet no funcionaría.
• Pin2/Pin3: Estos pines sólo están referidos a las entradas I0.5/I0.6. Si la configuración del interruptor está en posición OFF, los pines Pin 2/Pin 3 estarán disponibles.