ARDBOX Analog ARDUINO PLC

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 es compatible con los lenguajes C y C++. Industrial Shields recomienda usar Arduino IDE para programar los PLCs basados en Arduino, aunque cualquier software compatible con Arduino es compatible con los controladores de Industrial Shields.

Además, Industrial Shields ofrece la posibilidad de seleccionar tu PLC basado en Arduino en el Arduino IDE y compilar tus sketches para los diferentes PLCs.

Descarga el Arduino IDE:

Página oficial de Arduino IDE

Instala las unidades de Industrial Shields en el Arduino IDE:

Cómo instalar las placas de Industrial Shields

Versión Ardbox:

La familia Ardbox consta de 2 modelos principales:

Ardbox Analog

Ardbox Relay

En estos modelos puedes añadir comunicaciones (a elegir en el momento de la compra) como:

• WIFI y Bluetooth
• GPRS
• DALI
• LoRa

Y puedes elegir entre comunicación RS485 o RS232 en el momento de la compra.

La diferencia entre estos dos PLCs es que, en el modelo Relay, se añaden una serie de relés, mientras que en el modelo Analog se añaden pines analógicos.

Alimentación

Todos los PLCs basados en Arduino pueden alimentarse entre 12-24V. La familia Ardbox tiene un consumo de entre 700 mA y 1500 mA.

Por lo tanto, la fuente de alimentación recomendada es de 2A o superior. Cualquier fuente de alimentación industrial será una buena elección.

Si por alguna razón deseas utilizar una fuente de alimentación inferior a 1,5 A, contacta con el soporte técnico de Industrial Shields para asegurarte de que tu sistema funcionará correctamente.

A continuación se muestra un diagrama sencillo de cómo alimentar cualquier equipo de Industrial Shields.

Interruptores ARDBOX ANALOG

El Ardbox Analog tiene tres áreas de switches diferentes:

 Zona IZQUIERDA (interruptor de comunicaciones):

Zona SUPERIOR (Switch RO-DI):

Zona DERECHA (Switch D/A OUT):

Interruptores ARDBOX RELAY

Ardbox Relay tiene dos zonas de interruptores diferentes:

Zona SUPERIOR:

Zona DERECHA:

Consumo de energía

Ardbox analógico:

Ardbox relay:

Entradas analógicas 

Las entradas analógicas admiten de 0 a 10 Vdc con 10 bits de resolución; además, están aisladas y comparten el GND interno. Las E/S digitales y analógicas tienen autoaislamiento, por lo que es posible conectarlas a una alimentación distinta de 24 Vdc. 

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

Si se usa la comunicación RS485 (configurada por defecto), solo tendrás 6 entradas analógicas. Para tener 8 entradas analógicas, configúralo en el switch izquierdo: 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);

Entradas digitales

Variación de tensión  desde  -Vcc (o GND)  hasta  +Vcc, sin valores intermedios. Dos estados: 0 (-Vcc o GND) y 1 (+Vcc).  Las E/S digitales y analógicas tienen autoaislamiento, por lo que es posible conectarlas a una alimentación distinta de 24 V.  

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

Si se usa la comunicación RS485 (configurada por defecto), solo tendrás 6 entradas analógicas. Para tener 10 entradas digitales, configúralo en el switch izquierdo: 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);

Entradas de interrupción

Interrupt Service Routine (rutina de servicio de interrupción).  Mecanismo que permite asociar una función a la aparición de un evento concreto. Cuando el evento se produce, el procesador sale inmediatamente del flujo normal del programa y ejecuta la función ISR asociada, ignorando cualquier otra tarea. 

Ardbox Analog - Entradas:  (1x) entradas de interrupción (5-24Vdc). “Pueden funcionar como entrada digital (24Vdc)”.

En este ejemplo activamos INT0 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

Variación de tensión  entre  -Vcc (o GND)  y  +Vcc; puede tomar cualquier valor. Una entrada analógica proporciona una medida codificada en forma de valor digital con un número de N bits.  Las E/S digitales y analógicas tienen autoaislamiento, por lo que es posible conectarlas a una alimentación distinta de 24 V.  

Ardbox Analog - Salidas: 7 salidas analógicas de 0-10V; además, se pueden convertir 7 salidas digitales en salidas analógicas, configurables con el interruptor derecho.

  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_7, 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);

Salidas digitales

Variación de tensión  desde  -Vcc (o GND)  hasta  +Vcc, sin valores intermedios. Dos estados: 0 (-Vcc o GND) y 1 (+Vcc).  Las E/S digitales y analógicas tienen autoaislamiento, por lo que es posible conectarlas a una alimentación distinta de 24 V. 

Ardbox Analog - Salidas:  10 digitales (5 a 24Vdc) y 7 de esas 10 salidas digitales pueden ofrecer PWM (5 a 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);

Relés

Un relé es un interruptor electromagnético controlado por una señal eléctrica. En las unidades de Industrial Shields, estos dispositivos están integrados en las placas y son accesibles directamente con la función digitalWrite(RX, HIGH). Los relés de Industrial Shields son normalmente abiertos y pueden manejar una corriente máxima de 5A para 250Vca y 3A para 30Vcc.

Ardbox Relay - Salidas:  8 salidas de relé (250Vac - 5A / 30Vdc - 3A). (R1, .. , R8)

  // Opens the relay switch
  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);

  // Close the relay switch
  
  digitalWrite(R1, LOW);
  digitalWrite(R2, LOW);
  digitalWrite(R3, LOW);
  digitalWrite(R4, LOW);
  digitalWrite(R5, LOW);
  digitalWrite(R6, LOW);
  digitalWrite(R7, LOW);
  digitalWrite(R8, LOW);

Salida PWM

Modulación por Ancho de Pulso (PWM). Activa una salida digital durante un tiempo y la mantiene apagada el resto. La tensión de salida media, en el tiempo, será igual al valor analógico deseado. La frecuencia entre pulsos es la misma mientras cambia el ancho del pulso.

    - Q0.0, Q0.1, Q0.2, Q0.3, Q0.4, Q0.5 y Q0.6: salida digital/PWM, también como A0.0, A0.1, A0.2, A0.3, A0.4, A0.5 y A0.6: salida analógica.

Módulo Pulses de la librería avr-Pulses de Industrial Shields

El módulo Pulses ofrece funciones para iniciar y detener un tren de pulsos a la frecuencia deseada mediante 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 1kHz 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);

A continuación se muestra la precisión recomendada para las distintas frecuencias:

Para obtener una precisión alta en la frecuencia deseada, se recomienda usar la precisión más cercana a los valores de la tabla anterior.  Código de ejemplo 

RS-485

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

Ejemplo de uso

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

* Recuerda que para probar el full duplex con tu PLC Ethernet debes conectar A, B (receptores) a Y, X (transmisores).

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 en comunicación serie. Especifica los niveles de tensión, la temporización de señales y el protocolo de comunicación entre dispositivos.

Ejemplo de uso

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

I2C

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

I2C es un bus de comunicaciones 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, principalmente para comunicar microcontroladores con sus periféricos en sistemas integrados, o para comunicar circuitos integrados situados en una misma PCB.

Ejemplo de uso

IMPORTANTE:  Asegúrate de descargar las  placas de PLC basadas en Arduino  para Arduino IDE.

Ejemplo básico 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
}

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 con qué esclavo se comunica mediante el pin SS (slave select).

Ejemplo de uso

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

Pines directos de Arduino

Si queremos usar otro puerto serie en el equipo, podemos utilizar 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.  Es posible tener varios puertos serie por software con velocidades de hasta 115200 bps. Un parámetro activa 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 5VDC

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

    Pines I2C: SDA/SCL:

El protocolo I2C está diseñado para funcionar en configuración pull-up. En este caso, lee 5V cuando no hay nada conectado.

    SPI: MISO/MOSI/SCK:

Estos pines solo pueden funcionar como pines de 5V si no se va a usar el protocolo Ethernet. Como Ethernet usa SPI para comunicarse con la placa Arduino, ambos comportamientos no pueden coexistir simultáneamente.

    Pin2/Pin3:

Estos pines solo hacen referencia 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.