M-DUINO ETHERNET PLC ARDUINO 19R

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 admite la estructuración de código en C y C++. Para programar los PLC basados en Arduino Mega en este entorno, Industrial Shields proporciona un paquete de placas con las librerías y herramientas necesarias.

Recomendamos usar Arduino IDE Legacy (2.3.X) para programar los PLC basados en M-Duino, aunque se puede usar otro software compatible con Arduino. 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. Para hacerlo, sigue este tutorial y selecciona el paquete industrialshields en el paso 6.

Fuente de alimentación

Interruptores DIP

Los PLC basados en M-Duino tienen algunos interruptores que se pueden usar para configurar ciertas funcionalidades del PLC. Esta sección explica cómo usarlos correctamente. Para diferenciar las distintas partes del PLC y localizar cada interruptor, se usará la siguiente nomenclatura:

En cada zona hay uno o más interruptores, usados para configurar algunas funcionalidades del PLC. Las siguientes tablas indican la función de cada interruptor y cómo configurarlos. 

Zona A: interruptor superior izquierdo

Interruptor superior:

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

Interruptor inferior:

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

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

Zona A: interruptor inferior izquierdo

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

OFF se desactiva el I2C para acceder al RTC.

Zona B, C y D: Interruptor analógico

Estos interruptores sirven para elegir entre salida digital o analógica, según la tabla anterior. Si está en OFF, solo estará disponible la salida analógica correspondiente. Si está 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 de energía

Este informe explora cómo consumen energía los distintos modelos de PLC M-Duino en escenarios de reposo y de salidas al máximo. Entender estos patrones 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 apagados y utilizando una fuente de 24V. Esta prueba mide el consumo base cuando el dispositivo está en reposo y no está realizando ningún procesamiento ni salida.

Todas las salidas a 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 en las salidas y una alimentación de 24V. Esto da una idea del consumo cuando el equipo está activando señales de salida.

Entradas analógicas

La entrada analógica permite leer niveles de tensión analógicos, codificando el valor con un número de N bits. Las entradas analógicas del PLC basado en M-Duino usan el GND interno como referencia (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 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 se pueden usar como entradas digitales no aisladas, tolerando hasta 24Vdc. Para ello, consulta la sección de entradas digitales. Las entradas analógicas son las que van de IX.7 a IX.12, con X siendo 0, 1 o 2 según la zona. Puedes identificar las entradas analógicas en tu dispositivo con el siguiente símbolo:

Entrada analógica 0V - 10Vdc

  

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

Configuración de software

Para usarlas, las entradas analógicas deben configurarse en la parte de setup del código, como se hace habitualmente en placas Arduino comunes. Después 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));
}

También te puede interesar este post: Conceptos básicos sobre las entradas analógicas de un PLC industrial.

Entradas digitales

Las entradas digitales se usan 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 valores altos 5 Vdc o superiores, hasta 24 Vdc, mientras que valores inferiores a 5V se interpretan como bajos. 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 un pin de masa externo como referencia. Son los pines de IX.0 a IX.6, donde X es 0, 1 o 2 según la zona. 
• Entrada digital no aislada (5 - 24 Vdc): estas entradas no están opto-aisladas, y usan el GND interno del PLC como referencia. Son las mismas que las entradas analógicas, de IX.7 a IX.12, con X siendo 0, 1 o 2 según la zona.

Puedes identificarlas con los siguientes símbolos:

Entrada aislada 5V - 24V

 

Entrada no aislada 5V - 24V

 

 Los siguientes diagramas muestran las conexiones necesarias para usar correctamente ambas entradas como digitales:

Configuración de software

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

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 de las entradas digitales del PLC M-Duino admiten interrupciones, lo que significa que se pueden usar con ISR (rutina de servicio de interrupción) para ejecutar cierto código 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 de hardware

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

• I0.5 e I0.6 también funcionan como Pin3 y Pin2. Activa las interrupciones poniendo en ON los interruptores 3 y 4 inferiores de comunicación.
• I1.5 e I1.6 también funcionan como Tx1 y Rx1. Activa las interrupciones poniendo en ON los interruptores 1 y 2 superiores de comunicación.
• I2.0 e I2.1 también funcionan como SCA y SCL. Activa las interrupciones poniendo en ON los interruptores 3 y 4 superiores de comunicación. En este caso no podrás usar I2C.
  

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

Configuración de 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 ocurre 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 de software

El procedimiento para programar las salidas analógicas es el mismo que en Arduino habitual: primero, el modo del pin debe fijarse como "OUTPUT" en el setup del código, y después la salida se puede escribir usando "analogWrite()". Las salidas analógicas se referencian por su nombre usando un "_" en vez del ".". Por ejemplo, A0.5 se usa 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: Conceptos básicos sobre las salidas analógicas de un PLC industrial.

Salidas digitales

Las salidas digitales del PLC M-Duino pueden dar un valor bajo (0 Vdc) o alto (hasta 24 Vdc). Estas salidas se etiquetan como QX.X, y se pueden identificar con el siguiente símbolo.

El valor alto de 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 sea de 24V, conecta el pin QVdc a 24V y el pin COM(-) a GND. El siguiente diagrama muestra un ejemplo de conexión:

Salida digital (PWM opcional)

Configuración de software

Las salidas digitales deben configurarse en la parte de setup del código como se hace habitualmente en placas Arduino comunes, usando primero "pinMode()" para fijarla como "OUTPUT", y "digitalWrite()" para cambiar el valor de la salida. Consulta 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.

Salida PWM

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

El valor alto de la salida puede oscilar entre 5 y 24 Vdc. Igual que cuando se usan como salidas digitales simples, esta tensión debe fijarse usando dos pines situados junto a las salidas: QVdc y COM(-). Por ejemplo, si quieres fijar 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.

En nuestro repositorio hay un tutorial de ejemplo sobre cómo programar el PLC para usar las salidas PWM con la librería avr-Pulses .

Salida con capacidad PWM

Salida de relé

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 sus placas. Los relés del PLC M-Duino pueden trabajar hasta 30 Vdc o 250 Vac. Cada salida de relé tiene dos terminales y se identifica como RX. El siguiente diagrama muestra las conexiones:

Configuración de software

La salida de relé debe configurarse en la parte de setup del código, usando funciones de Arduino, y se controlan como si fueran salidas digitales. Las salidas se referencian por el nombre indicado en la serigrafía: R0.1, por ejemplo, se usa como R0_1. Consulta el siguiente ejemplo. Cuando la salida se pone en "HIGH", el relé se activa, es decir, el contacto se cierra, mientras que en "LOW" el contacto se abre.

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.

Ethernet

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

Una LAN es una red de ordenadores y otros dispositivos electrónicos que cubre una zona pequeña, como una sala, una oficina o un edificio. Se contrapone a 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 por 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 PLC M-Duino incorporan un puerto Ethernet con el controlador W5500, que se comunica con el Arduino por SPI. El W5500 es un controlador Ethernet embebido con TCP/IP cableado por hardware que facilita la conexión a Internet de los sistemas embebidos. Este chip permite tener conectividad a Internet en las aplicaciones con un único chip que integra la pila TCP/IP, el MAC Ethernet 10/100 y el PHY. Con este chip se puede integrar Ethernet en las aplicaciones.  

Configuración de software

El paquete de placas de Industrial Shields incluye una librería "Ethernet" para facilitar el uso de este protocolo. La librería incluye varios ejemplos, que puedes consultar en File > Examples > Ethernet dentro de Arduino IDE.

Echa también un vistazo al siguiente programa. Antes de ejecutar el código, asegúrate de que el PLC está bien alimentado, de que el cable Ethernet está bien conectado al equipo y de que el paquete de placas "industrialshields" está bien 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 usando 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");
    }
   }
}

RS-485

RS485, también conocido como TIA-485(-A) o EIA-485, es un estándar que define las características eléctricas de los drivers 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 slew-rate limitado usado para comunicación RS-485. Funciona con una única alimentación de +5V y su corriente nominal es de 300 μA. Al adoptar comunicación half-duplex para convertir nivel TTL a nivel RS-485, puede alcanzar una tasa de transmisión máxima de 2,5 Mbps. El transceptor MAX485 consume entre 120 μA y 500 μA en condiciones sin carga o a plena carga cuando el driver está desactivado.

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

Configuración de hardware

Para usar el RS485 con los PLC M-Duino, revisa el interruptor superior izquierdo de la zona A. El RS485 siempre está activo, pero hay un interruptor (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 inicial - Hardware" de esta página.

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

Configuración de software

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

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

RS232

RS-232 es un estándar de transmisión de datos por comunicación serie. Define formalmente las señales usadas en la comunicación entre un DTE (Data Terminal Equipment), como un terminal de ordenador, 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 transmisor/doble receptor que se usa para convertir las señales RX, TX, CTS y RTS de serie TTL a puerto serie TIA-232 (RS-232).

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

Configuración de hardware 

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

Configuración de software

Una vez hecha la configuración de hardware, se puede pasar a la configuración de software y a su uso. Primero hay que incluir la librería RS232.h que proporciona nuestro paquete de placas. Después, se inicializa la comunicación con "RS232.begin(<baudrate>);". A partir de ahí, RS232 ya se puede usar con las funciones "RS232.read();" y "RS232.write();". 

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

Serie TTL

La serie TTL es una interfaz de comunicación entre dos dispositivos que trabajan con tensiones de nivel bajo. Se usan dos señales: Tx (transmisión de datos) y Rx (recepción de datos), que permiten 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 blog.

Configuración de hardware

El PLC M-Duino tiene dos puertos serie. Uno de ellos, Serial 1 (TX1, RX1), se activa con el interruptor superior izquierdo de la zona A. Para más información sobre los interruptores, consulta la sección "Instalación inicial - Hardware" 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 masa común.

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

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

Configuración de software

Para usar la comunicación serie con el PLC, se puede usar el objeto "Serial" de Arduino. Consulta el siguiente ejemplo, que usa Serial 1 para enviar y recibir bytes con el puerto serie USB y Serial 1. Para usar Serial 2 en lugar de Serial 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 direccionamiento para comunicarse con los esclavos. Es un bus muy usado en la industria, sobre todo para comunicar microcontroladores y sus periféricos en sistemas integrados, normalmente situados en la misma PCB. La velocidad es de 100 Kbit/s en modo estándar.

Configuración de hardware

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

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

• El puerto I2C trabaja a 5V. Niveles de tensión superiores pueden dañar el PLC. 
• Los pines I2C, SCL y SDA, tienen pull-up a 5V.

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

Configuración de software

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

Antes de ejecutar el código, asegúrate de que el PLC está bien alimentado, de que el paquete de placas "industrialshields" está bien instalado en Arduino IDE y de 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 comunicaciones 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 único 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 habla en el bus.

El PLC M-Duino tiene un puerto SPI.

Configuración de hardware

Para usar el SPI, los 3 pines mencionados (SCLK, MISO, MOSI) deben estar bien conectados:

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

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

Configuración de software

El paquete de placas "industrialshields" incluye una librería SPI basada en la librería SPI de Arduino. Esta librería permite programar el MDuino como maestro SPI.

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

RTC

RTC significa Real Time Clock (reloj en tiempo real), un dispositivo electrónico que mide el paso del tiempo. Aunque se puede llevar la hora sin RTC, usar uno tiene ventajas como:

• Mantener la hora sin tener que ajustarla de nuevo tras un reinicio, un apagado, etc.
  
• Bajo consumo (importante cuando funciona con alimentación alternativa.
• Libera al sistema de control principal para 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 por I2C. El reloj en tiempo real serie DS1307 es un reloj/calendario de bajo consumo en decimal codificado en binario (BCD) completo, con 56 bytes de NV SRAM. 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,3V que puede alimentar el RTC.

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

Configuración de software

La librería RTC, incluida en nuestro paquete de placas, sirve para interactuar con el RTC. Consulta 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 bien 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);
}

SD

Las tarjetas Secure Digital (SD) son dispositivos de almacenamiento no volátil que usan tecnología de memoria 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 32GB de almacenamiento (se pueden usar tarjetas de mayor capacidad, pero solo serán accesibles y utilizables los primeros 32GB).
• Sistemas de archivos admitidos: FAT32 y FAT16.

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

Configuración de 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 inicial - Hardware" de esta página.

Configuración de software

El paquete de placas "industrialshields" incluye una librería SD para facilitar su uso. Consulta 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 queremos usar otro puerto serie con este equipo, podemos usar algunos pines digitales para crear un puerto serie. La librería SoftwareSerial se ha desarrollado para permitir la comunicación serie en otros pines digitales del Arduino, replicando la funcionalidad por software. Se pueden tener varios puertos serie por software con velocidades de hasta 115200 bps. Un parámetro permite la señalización invertida para los dispositivos que requieren ese protocolo.

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

Señales de 5 Vdc

Estos pines se pueden programar según las funciones de Arduino, como E/S que trabajan a 5V o cualquier otra función disponible en los pines.

• Pines I2C: SDA/SCL: El protocolo I2C está pensado para trabajar con configuración pull-up. En este caso, lee 5V cuando no hay nada conectado.
• Serial 0: RX0/TX0: El protocolo Serial0 también puede funcionar como pin de 5V. Si se usan estos pines, la comunicación USB no puede funcionar al mismo tiempo.
• Serial 1: RX1/TX1: El protocolo Serial1 también puede funcionar como pin de 5V. Siempre habilitado.
• SPI: MISO/MOSI/SCK: Estos pines solo pueden funcionar como pines de 5V si no se va a usar el protocolo Ethernet. Como el protocolo 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 hacen referencia a las entradas I0.5/I0.6. Si el interruptor está en posición OFF, los pines Pin 2/Pin 3 estarán disponibles.