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:

Official Arduino IDE page

Instala las unidades de Industrial Shields en el Arduino IDE:

How to install Industrial Shields Boards

Versión Ardbox:

La familia Ardbox consta de 2 modelos principales:

Ardbox Analog

Ardbox Relay

In these models you can add communications (to choose at the time of purchase) such as:

• WIFI & 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.

Next is shown a simple diagram to see how to power supply any Industrial Shields unit.

Switch ARDBOX ANALOG

El Ardbox Analog tiene tres áreas de switches diferentes:

 LEFT Zone (Communication SWITCH):

Zona SUPERIOR (Switch RO-DI):

Zona DERECHA (Switch D/A OUT):

Switch ARDBOX RELAY

Ardbox Relay has two different switch areas:

Zona SUPERIOR:

Zona DERECHA:

Consumo de energía

Ardbox analógico:

Ardbox relay:

Analog inputs 

The analog inputs have a tolerance of 0 to 10 Vdc with 10 bits of resolution, they are also isolated and sharing the internal GND. In Digital and Analog I/O there’s self insulation, so its posible to connect them in a different power supply than 24 Vdc. 

Ardbox Analog - Inputs: 6 or 8 Analog (0-10Vdc) configurable by 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

Voltage variation  from  –Vcc (or GND)  to  +Vcc, with no intermediate values. Two states: 0 (-Vcc or GND) and 1 (+Vcc).  In Digital and Analog I/O there’s self insulation, so its posible to connect them in a different power supply than 24 V.  

Ardbox Analog - Inputs:  8 or 10 Digital (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 Rutine.  A mechanism that allows a function to be associated with the occurance of a particular event. When the event occurs the processor exits immediately from the normal flow of the program and runs the associated ISR function ignoring any other task. 

Ardbox Analog - Inputs:  (1x) Interrupt Inputs (5-24Vdc). “Can work like Digital Input (24Vdc)”.

In this example we activate INT0 using 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

Voltage variation  between  –Vcc (or GND)  and  +Vcc, can take any value. An analog input provides a coded measurement in the form of a digital value with an N-bit number.  In Digital and Analog I/O there’s self insulation, so its posible to connect them in a different power supply than 24 V.  

Ardbox Analog - Outputs: 7 Analog 0-10V output and can convert 7 digital outputs to analog outputs, configurables by Right Switch.

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

Digital outputs

Voltage variation  from  –Vcc (or GND)  to  +Vcc, with no intermediate values. Two states: 0 (-Vcc or GND) and 1 (+Vcc).  In Digital and Analog I/O there’s self insulation, so its posible to connect them in a different power supply than 24 V. 

Ardbox Analog - Outputs:  10 Digitals (5 to 24Vdc) and 7 of that 10 digital outputs can provide PWM (5 to 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 4A para 230Vca y 2A para 24Vcc.

Ardbox Relay - Outputs:  8 Relay outputs (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);

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 and Q0.6 Digital/PWM out also as A0.0, A0.1, A0.2, A0.3, A0.4, A0.5 and A0.6 Analog out.

Module Pulses from avr-Pulses library

The Pulses module provides functions for starting and stopping a train of pulses at the desired frequency using PWM pins. The

startPulses(pin, frequency, precision)  function starts the train of pulses at the specified frequency and precision. The default frequency is 1kHz and the default precision is 3.

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

The  stopPulses(Pin)  function stops the train of pulses.

stopPulses(3);

Next it is showed recommended precision between different frequencies:

To have a high precision on the desired frequency, it is recommended to use the closer precision to the values of the previous table.  Example Code 

RS-485

 RS-485, also known as TIA-485(-A), EIA-485, is a standard defining the electrical characteristics of drivers and receivers for use in serial communications systems. The electrical signaling is balanced, and multi-point systems are supported.

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

Basic RS-485 read example (receive):

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

 Basic RS-232 read example

// 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 is a synchronous protocol that only uses 3 cables, one for the clock (SCL) and one for the data (SDA) and ground (GND). This means that the master and the slave send data through the same cable, which is controlled by the master, who creates the clock signal. I2C uses addressing to select slaves.

I2C is a serial communications bus. The speed is 100 kbit/s in standard mode, but also allows speeds of 3.4 Mbit/s. It is a very used bus in the industry, mainly to communicate microcontrollers and their peripherals in integrated systems, or to communicate integrated circuits that reside in a same PCB.

Ejemplo de uso

IMPORTANT:  Make sure to download the  Arduino based PLC boards  for 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 is a synchronous communication protocol bus that has a master-slave architecture. Slave devices cannot initiate communication, nor exchange data with each other directly. Only the master can select to which slave will communicate with through the SS (slave select) pin.

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

If we want to use another Serial Port using your equipment, we can make use of some digital pins to create a Serial. The SoftwareSerial library has been developed to allow serial communication on other digital pins of the Arduino, using software to replicate the functionality.  It is possible to have multiple software serial ports with speeds up to 115200 bps. A parameter enables inverted signaling for devices which require that protocol.

Only I/O 5V from Ardbox or M-Duino  boards can be used. 

5VDC Signals

 These pins can be programmed according to Arduino features such as I/Os operating at 5V or any additional features present in the pins. 

    I2C Pins – 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:

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.