ARDBOX Relé ARDUINO PLC

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 estructuración de código en C y C++. Industrial Shields recomienda usar Arduino IDE para programar los PLC basados en Arduino, aunque cualquier software compatible con Arduino funciona con los controladores de Industrial Shields.

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

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

Power supply

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

Por eso, se recomienda una fuente de alimentación de 2A o superior. Cualquier fuente de alimentación industrial será una buena elección.

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

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

Interruptores del Ardbox Relay

Ardbox Relay has two different switch areas:

Zona superior (TOP):

Zona derecha (RIGHT):

Consumo

Ardbox relay:

Analog inputs 

Las entradas analógicas tienen una tolerancia de 0 a 10 Vdc con 10 bits de resolución, y están aisladas, compartiendo la masa interna. En las E/S digitales y analógicas hay aislamiento propio, por lo que es posible conectarlas a una fuente de alimentación distinta de los 24 Vdc.

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

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

Digital inputs

La tensión varía entre −Vcc (o GND) y +Vcc, sin valores intermedios. Dos estados: 0 (-Vcc o GND) y 1 (+Vcc). En las E/S digitales y analógicas hay aislamiento propio, por lo que es posible conectarlas a una fuente de alimentación distinta de los 24V.

Ardbox Relay - Entradas: 4 digitales aisladas (5-24Vdc).

  int IOO = digitalRead(I0_0);
  int IO1 = digitalRead(I0_1);
  int IO4 = digitalRead(I0_4);
  int IO5 = digitalRead(I0_5);

Entradas de interrupción

Rutina de servicio de interrupción. Un mecanismo que permite asociar una función a la ocurrencia de un evento concreto. Cuando ocurre el evento, el procesador sale inmediatamente del flujo normal del programa y ejecuta la función ISR asociada, ignorando cualquier otra tarea.

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

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

Analog outputs

La tensión varía entre −Vcc (o GND) y +Vcc, y puede tomar cualquier valor. Una entrada analógica proporciona una medida codificada en forma de valor digital con un número de N bits. En las E/S digitales y analógicas hay aislamiento propio, por lo que es posible conectarlas a una fuente de alimentación distinta de los 24V.

Ardbox Relay - Salidas: 2 salidas analógicas de 0-10V, configurables por interruptor.

  analogWrite(A0_0, 255);
  analogWrite(A0_1, 10);

  // CONFIGURE THE RIGHT SWITCH WITH ALL OUTPUT AS ANALOG(OFF)
  analogWrite(Q0_0, 182);
  analogWrite(Q0_1, 30);

Digital outputs

La tensión varía entre −Vcc (o GND) y +Vcc, sin valores intermedios. Dos estados: 0 (-Vcc o GND) y 1 (+Vcc). En las E/S digitales y analógicas hay aislamiento propio, por lo que es posible conectarlas a una fuente de alimentación distinta de los 24V.

Ardbox Relay - Salidas: 2 digitales (5 a 24Vdc). El Ardbox Relay no ofrece salida PWM; esta función solo está disponible en el modelo Ardbox Analog.

  // CONFIGURE THE RIGHT SWITCH WITH ALL OUTPUT AS DIGITAL(ON)
  digitalWrite(Q0_0, HIGH);
  digitalWrite(Q0_1, LOW);

Relés

Un relé es un interruptor electromagnético controlado por una señal eléctrica. En las unidades de Industrial Shields estos dispositivos ya están integrados en la placa y se pueden accionar directamente con la función digitalWrite(RX, HIGH). Los relés de Industrial Shields son normalmente abiertos y admiten una corriente máxima de 4A a 230Vac y 2A a 24Vdc.

Ardbox Relay - Salidas: 8 salidas de relé (220Vac – 5A). (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);

RS-485

RS-485, también conocido como TIA-485(-A), EIA-485, es un estándar que define las características eléctricas de los transmisores y receptores en sistemas de comunicación serie. La señalización es balanceada y admite sistemas multipunto.

Ejemplo de uso

Ejemplo básico de escritura por 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 por 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 en 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 los receptores A, B a los transmisores Y, X.

RS-232

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

 

Ejemplo de uso

Ejemplo básico de escritura por 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 por 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 utiliza 3 cables: uno para el reloj (SCL), uno para los datos (SDA) y otro para 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 utiliza direccionamiento para seleccionar los esclavos.

I2C es un bus de comunicaciones serie. La velocidad es de 100 kbit/s en modo estándar, aunque también admite velocidades de hasta 3,4 Mbit/s. Es un bus muy utilizado en la industria, principalmente para comunicar microcontroladores con sus periféricos en sistemas integrados, o para comunicar circuitos integrados que residen en la misma PCB.

Ejemplo de uso

IMPORTANTE: asegúrate de descargar lasplacas de PLC basadas en Arduino for 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
}

SPI

SPI es un protocolo de comunicación síncrono con arquitectura maestro-esclavo. Los dispositivos esclavos no pueden iniciar la comunicación ni intercambiar datos entre ellos directamente. Solo el maestro puede seleccionar con qué esclavo se comunica a través del 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 con nuestro 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. Es posible 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 lo requieran.

Solo se pueden usar los pines de 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 estándar de Arduino, como E/S que funcionan a 5V, u otras funciones adicionales presentes en los pines.

    I2C Pins – SDA/SCL:

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

SPI – MISO/MOSI/SCK:

Estos pines solo pueden funcionar a 5V si no se va a usar el protocolo Ethernet. Como el protocolo Ethernet usa el SPI para comunicarse con la placa Arduino, ambos comportamientos no pueden darse a la vez, ya que Ethernet dejaría de funcionar.

Pin2/Pin3:

These pins are only referred to the inputs I0.5/I0.6. If the switch configuration is in OFF position the pins Pin 2/Pin 3 will be available.