Browsed by
Etiqueta: Plc Arduino

Ardbox – MDuino Arduino pin

Ardbox – MDuino Arduino pin

This post describes how to gain direct access to Arduino board pins  inside the  Ardbox and MDuino PLCs. This allows to work with the PLCs in the same way as using an Arduino, in other words,  pins at 5V and configurable as input or outpts.

Also, this  enables usage of  sensors  working at lower voltages than industrial standards 10V dc/24Vdc.  NOTE:Make sure the voltage DOES NOT EXCEED 5VDC!!!!!!!!

Following are listed the connections with direct access to the Arduino board  pins.

Ardbox: DE-D7  // RE-D4 // SDA-PIN2  // SCL-PIN3

MDuino: SCL // SDA // RX0 // TX0 // RX1 // TX1 // Pin3 // Pin2

In order to enable the direct connection to Arduino pins, the configuration switches for these connections must be set to OFF position.

 

 

 

IoT in industry improves reliability equipment. Arduino as PLC application.

IoT in industry improves reliability equipment. Arduino as PLC application.

Resumen

IoT and Plc MDuino

Hoy en día, los fabricantes tienen que mantener las fábricas en funcionamiento 24×7, y, con el fin de asegurarlo, los equipos deben ser fiables debido a que un fallo puede costar millones de euros y un alto impacto en la capacidad de enviar el producto a los clientes. ¿Cómo puede la IoT ayudar a aumentar el uso de los equipo de producción y minimizar el tiempo improductivo no planificado de la fábrica? Supervisando los equipos de la fábrica, de forma rápida, proporcionando a los ingenieros de mantenimiento los pertinentes mensajes de error detallado en tiempo real. En este post mostraremos un ejemplo de cómo puede ayudar la IoT en un entorno industrial.

 

Proycto, Hardware y Arqutectura 

En este proyecto, Opiron Electronics  conecta un M-Duino PLC de IndustrialShields a la plataforma Xively IoT. En este ejemplo se va a mostrar una característica de monitorización en línea para un proceso de fábrica, lo que permitirá a los ingenieros de mantenimiento y operadores visualizar los datos de fábrica usando Internet y acceder a los mismos a través de los teléfonos inteligentes o tabletas. En este caso no vamos a implementar una solución de automatización completa, ya que no es el alcance de este post. Desde el punto de vista del hardware, la arquitectura que vamos a aplicar será como muestra la siguiente figura:

Picture Architecture


Primeros pasos

Antes de nada debemos asegurar que tenemos una cuenta Xively. Si aún no la tenemos podemos registrarnos para obtener una cuenta gratuita aquí. En segundo lugar, seleccionamos los datos que deseamos visualizar. IoT no va a sustituir a los sistemas SCADA; tenemos que pensarlo como una extensión, por lo que es importante seleccionar los datos críticos que tendremos en la nube. En nuestro ejemplo vamos a utilizar una temperatura.


Software y código

Como de costumbre, vamos a utilizar el IDE de Arduino para programar nuestro PLC. Por otra parte, para este proyecto vamos a utilizar la biblioteca Xively para Arduino que se puede descargar aquí. Necesitaremos la biblioteca de cliente HTTP, también, disponible aquí. El boceto subirá un flujo de datos a la plataforma Xively. Xively genera gráficos basados en los datos que nos proporcione, pero se pueden crear triggers y notificaciones para tener capacidades de alerta para nuestra aplicación. En cuanto al código M-Duino PLC, que se puede descargar aquí:
2014111_arduino_code Principales ventajas

Los principales beneficios de la solución  propuesta son:

  1. El control online reduce drasticamente los costes de mantenimiento y el tiempo de inactividad.
  2. Conectado: Los ingenieros de mantenimiento pueden mantenerse conectado al equipo y proceso, lo que significa que unos tiempos de reparación más rápida y una mejora de la fiabilidad.
  3. Basdo en Hardware libre: Desde el punto de vista de hardware y software, esta característica significa gran flexibilidad, gran disponibilidad de recursos en el Internet en caso de fallos o cambiar implementaciones, etc.
img_home
Industrial Shields harware
Ponte en contacto con nosotros!!!

Tiene un proceso para ser automatizado. Póngase en contacto con Industrialshields para implementar la solución completa y para comprar el hardware adecuado.

Chloride Dosing System

Chloride Dosing System

Resumen

La fabricación de agua potable es un proceso de diferentes etapas. El último paso se llama desinfección, i su finalidad es destruir los microorganismos en el agua. Para lograrlo, existen los sistemas de inyección de cloro. Esta técnica se llama dosificación. La dosificación es la técnica para controlar la adición de una sustancia a un líquido que fluye o gas. Los sistemas de dosificación están diseñados para lograr el nivel de dosificación requerido por el mantenimiento de la señal de control como una proporción de la tasa de flujo de fluido. En este post vamos a desarrollar un sistema de dosificación de cloro basado en Arduino.

Equipo a utilizar
Los equipos de control de dosificación constan básicamente de los siguientes elementos:

  • Un controlador, en este caso vamos a utilizar un M-Duino PLC.

  • Un medidor de flujo.

  • Una bomba dosificadora.

  • Un sensor de nivel de dosificación.


    nanodac-dosingcontrol

La siguiente figura muestra la disposición general del sistema de control de dosificación: La concentración de dosis medida por el sensor de nivel de dosificación se utiliza para detener la bomba si hay una alta concentración en el tanque. El medidor de flujo proporciona la entrada del bucle de control, que está conectado a la bomba (como salida).

Software y código

En este ejemplo, el nivel de dosificación y medidor de flujo se configuran como una entrada analógica 0-10V. La bomba funciona con un controlador de frecuencia. Como tenemos que desarrollar un lazo de control, hemos creado un controlador PID vinculado a la entrada especificada, la producción y el valor de consigna. Puede encontrar el código usado en el link que hay a continuación:
2014111_arduino_codePrincipales ventajas

Los principales beneficios de la solución propuesta por Opiron e Industrial shields son:

  • Flexibilidad: Com se puede ver, el hardware basado en código abierto se puede utilizar para controlar el nivel de dosificación de un sistema de cloro. Sin embargo, esta misma arquitectura puede ser usado con cualquier líquido o gas usando el algoritmo PID.
  • Libertad para modificar el software: con este tipo de software no estamos limitados al uso hardware y software propietario.
  • Fácil ser integrado: No importa si ya dispone de un sistema de automatización. El hardware Arduino es fácil de integrar en su sistema ..
  • East to be integrated: No matter if you already have an automation system. The Arduino hardware is easy to integrate into your system..
Ponte en contacto con nosotros!!!

Tiene un proceso para ser automatizado. Póngase en contacto con Industrialshields para implementar la solución completa y para comprar el hardware adecuado.

Developing a packaging machine based on Arduino hardware

Developing a packaging machine based on Arduino hardware

Resumen

Las máquinas de embalaje se utilizan para cerrar y proteger los productos para su distribución, venta y uso. Son muy populares en la industria, ya que aseguran la seguridad, fiabilidad y por lo general se integra su proceso en la línea de proceso. Garantizan una gran productividad. En este proyecto, Opiron Electrónica desarrollará una máquina de embalaje básica sobre la base de los PLCs basados en Arduino y resto de Hardware libre de IndustrialShields.
Ardbox RelaySistema

Packaging machines have three basic control functions: HMI( the Human Machine Interface), PLC (the logic part of the control), and the Motion Control functionality. The main idea of the Project is to develop a reliable and flexible machine. We will make use of an Ardbox Relay as the main processor of the system, but, as packaging machines need to be integrated into more complex systems, as we saw in the

Las máquinas de embalaje tienen tres funciones básicas de control: HMI (Human Machine Interface), PLC (la parte lógica del control), y la funcionalidad de control de movimiento. La idea principal del proyecto es desarrollar una máquina fiable y flexible. Haremos uso de un relé Ardbox como el procesador principal del sistema, aunque como máquinas de embalaje normalmente se integran en sistemas más complejos, como vimos en el post Alimentando una máquina de embalaje de leche con driver de frecuencia con Arduino en este caso usaremos el M-Duino PLC, el cual tiene connexión Ethernet y puede enviar datos a un SCADA. Todos los detalles del Hardware utilizado se pueden encontrar en IndustrialShields.

packaging_machine_industrial_shields

Hardware y operativa

En este post vamos sólo a mostrar la parte de control de la máquina de embalaje. Se trata de un alimentador y un elevador. El alimentador consiste en un pistón, cuando un producto se encuentra en la parte delantera del alimentador, el alimentador se mueve hacia adelante y cuando se encuentra en el elevador, lo baja un nivel. Cuando el elevador está en el nivel inferior, todo el producto puede ser embalado de forma automática.

PLC Programming Packing Machine_industrial_shields

Los componentes a usar serán:

  1. Cinco interruptores mecánicos (inversa, hacia adelante, superior del interruptor, interruptor central y el interruptor inferior).
  2. 4 relés basados en Arduino. 2 de ellos para el alimentador (movimiento hacia adelante y hacia atrás) y 2 más para el elevador (movimiento hacia arriba y hacia abajo).

Software y código usados

Tal y como se ha descrito anteriormente, el sistema funciona en seis pasos. Además, el código tiene una función adicional pero interesante: la capacidad de recibir comandos desde otro PLC (M-Duino) en el caso que un operador desee detener el proceso de forma remota. Se puede descargar el código fuente de Arduino en el siguiente enlace:

2014111_arduino_code

Beneficios clave

  • controlar de forma remota desde otra funcionalidad de PLC.
  • basado en Hardware Open Source, lo que significa fiable, barato y ampliable.
  • fácil de instalar.
A Conveyor Belt Control System with an Arduino PLC and a Rasberry PI Panel PC HMI

A Conveyor Belt Control System with an Arduino PLC and a Rasberry PI Panel PC HMI

http://www.industrialshields.com

Las cintas transportadoras son muy comunes en la industria: podemos encontrarlas en diferentes industrias como la minería, alimentación y bebidas o productos químicos entre otros. Se utilizan para transportar materiales pesados de un lugar a otro. En este proyecto vamos a hacer un sistema de control basado de una cinta transportadora para la industria alimenticia con un PLC de hardware libre basado en Arduino: el PLC M-Duino que puede ser controlado a través de un software SCADA / HMI.

Introducción

Los requisitos a cumplir para que que la cintra transportadora funciona correctamente son:

  1. Se debe comprobar que la cinta está en funcionamiento todo el rato.
  2. Si un problema ocurre debe avisar al operario de la sección.

Para conseguir los requerimientos la cinta transportadora tiene dispositivos de detección fotoeléctricos y sensores inductivos sensores, luces y relés. Específicamente, los dispositivos de hardware que se programen y su función son los siguientes:

  1. Célula fotoeléctrica: Detectar todos y cada uno de los productos producidos.
  2. Sensor de movimiento inductivo: Detectar el movimiento de la cinta
  3. Salida del relé: Parar el motor de accionamiento de la cinta si un error ocurre.
  4. Luces de aviso: Alerta si se produce una alarma.

El esquema seria como el mostrado a continuación:

picture1Código de programación

En la siguiente parte de este tutorial vamos a programar el M-Duino:

  1. Para la célula fotoeléctrica, vamos a utilizar las interrupciones en el modo ascendente. Cada vez que tenemos una nueva interrupción, un nuevo producto fabricado se ha detectado.
  2. Para detectar que el motor esté en marcha también vamos a utilizar las interrupciones en modo creciente. Cada vez que tenemos una nueva interrupción, podemos contar con un nuevo bucle ciclo detectado.
  3. Vamos a utilizar tres luces de aviso, dos de ellas indicarán alarma si se produce un fallo:
  • Si el motor se ha parado.
  • Si se produce un fallo de la producción, (que significa que no se detecta paso de productos a través de la barrera fotoeléctrica durante más de 30 segundos).

La última luz de aviso vendrá de otra parte de la fábrica e indicará que hay demanda de producto y por lo tanto la cinta transportadora debe estar funcionando. Finalmente comentar que se van a usar relés para parar los motores si una ocurre alguna de las alarmas.

2014111_arduino_code

// Industrial Shields by BOOT & WORK CORP. // Powered by Opiron Electronics -www.opiron.com- // Feb.2015 technical information for newsletter // This sketch demonstrates how to program some // digital input / output signals through an M-Duino // PLC. The sketch is inspired in a real project of a // food plant, where we have to control a conveyor belt. // Keywords: Conveyor Belt, industrial automation. ////////////////////////////// //// PLC: M-DUINO MODULE //// //// Number of inputs: 2 //// Number of outputs: 4 //// you need to configurate the correctly switch position for running like digital / analog or PWM mode ////////////////////////////// //// M-Duino Pins Used: //// Q0.0 — PIN 36 — Digital Output (24Vdc) — Motor Failure Strobe //// Q0.1 — PIN 37 — Digital Output (24Vdc) — Product Demand Strobe //// Q0.2 — PIN 38 — Digital Output (24Vdc) — Product Failure Strobe //// Q0.3 — PIN 39 — Digital Output (24Vdc) — Stop Motor //// I0.0 — PIN 22 — Digital Input (24Vdc) — Photoelectric Barrier sensor, when active, a new product crosses the photoelectric barrier //// I0.1 — PIN 23 — Digital Input (24Vdc) — Inductive sensor, when active, a new loop detected in the motor //Pins defintion #define Motor_Failure_Strobe 36 // Alert if a motor failure alarm occurs #define Product_Demand_Strobe 37 // Alert if a product order is required #define Production_Failure_Strobe 38 // Alert if a production failure occurs #define Stop_Motor 39 // If an alert is detected we will stop the conveyor belt #define Photo_sensor 22 // Photoelectric sensor to detect manufactured products #define Ind_sensor 23 // Inductive sensor to detect the motion in the motor //Thresholds and constant interval times #define MINSPEED_THRESHOLD 500 // We consider that the minimum speed when the motor runs is 500 rpm, if a less speed is detected, we must alert and stop the plant #define time_photo_limit 4500 // We consider an interval of 4,5 seconds as the limit between each product can cross the photoelectric barrier #define rpm_interval 60000 // 1 minute // Variables volatile unsigned int rpm; // Variable to count the speed of the motor, consider rpm as revolutions per minute boolean Alarm; // Variable that says if we are in an alarm state or not unsigned long time_photo; // Variable to count the time between each product cross the photoelectric barrier unsigned long prevTime_rpm; // Variable to count each 60s the rpm of the motor // Functions void speedcount(); void manufacturing(); void setup() // Configuration is here: { // Pin settings pinMode(Motor_Failure_Strobe, OUTPUT); pinMode(Product_Demand_Strobe, OUTPUT); pinMode(Production_Failure_Strobe,OUTPUT); pinMode(Stop_Motor,OUTPUT); pinMode(Photo_sensor, INPUT); pinMode(Ind_sensor, INPUT); // Thresholds settings rpm=MINSPEED_THRESHOLD; // Initial speed value initialized with a higher value of minimun motor speed to disable an initial alarm // Interrupts attachInterrupt(Ind_sensor, speedcount, RISING); // Pin 2 attachInterrupt(Photo_sensor, manufacturing,RISING); // Pin 3 // Variables Alarm=0; } // End setup void loop() // The code in loop() runs repeatedly: { if(millis() – prevTime_rpm > rpm_interval) // Each 60 seconds we reinitialize rpm’s to 0 { prevTime_rpm = millis(); rpm=0; } if (rpm<MINSPEED_THRESHOLD) // Alarms Check I: Motor doesn’t work at the proper speed { digitalWrite(Motor_Failure_Strobe,HIGH); digitalWrite(Stop_Motor,HIGH); Alarm=1; } if(time_photo>time_photo_limit) // Alarms Check II: The manufactured products doesn’t cross the photoelectric barrier { digitalWrite(Production_Failure_Strobe,HIGH); digitalWrite(Stop_Motor,HIGH); Alarm=1; } else if (Product_Demand_Strobe) // Nonmal Conditions { Alarm=0; digitalWrite(Motor_Failure_Strobe,LOW); // The Failure Strobes must be off digitalWrite(Production_Failure_Strobe,LOW); digitalWrite(Stop_Motor,LOW); // The Motor must be running } // End Normal Conditions } // End loop void speedcount() // This function is executed each time that we have a new interrupt { rpm++; // Speed up! } // End speedcount() void manufacturing() // This function is executed each time a new product crosses the photoelectric barrier { time_photo=0; // When a new product crosses the photoelectric cell, the counter must reset } // End manufactuing()

POWERED BY OPIRON ELECTRONICS
Controlling temperature with a got exchanger through a modulating valve in chemical industry

Controlling temperature with a got exchanger through a modulating valve in chemical industry

Introducción

En la industria, la necesidad de controlar la temperatura es habitual. Un elemento típico utilizado y diseñado con este propósito es el intercambiador de calor, que intercambia dos o más fluidos con diferente temperatura.
Ardbox PID loopEn este post vamos a explicar cómo implementar un control de la temperatura a través de una válvula de modulación que va a regular la cantidad de vapor que entra en el intercambiador de calor, con el fin de calentar el proceso químico. Para cumplir con los requisitos especificados, Opiron electronics ha desarrollado un algoritmo PID que se desarrollará en la Ardbox PLC de Industrial Shields.

Hot Exchanger Logica

Obviamente, el objetivo principal del algoritmo que vamos a hacer es un programa para controlar la temperatura de la tubería donde fluye el proceso químico. El elemento que nos dará la posibilidad de regular la temperatura es una válvula de modulación que tiene una interfaz de entrada analógica (0/10 V CC), donde vamos a enviar la consigna de nuestro PLC. La válvula de modulación controlará la cantidad de vapor que fluye a la tubería, y por lo tanto la temperatura (cuanto más cantidad de vapor que enviamos, más temperatura que hay en la tubería). Para controlar la temperatura, vamos a utilizar un algoritmo de PID y un sensor de temperatura como señal de entrada. Además hay otros puntos básicos a programar: apertura y cierre de la válvula y encendido / apagado de la bomba, que los vamos a programar desde un punto vista de seguridad del proceso. Básicamente, si la temperatura del proceso está fuera de los límites (> 80 ºC). Para código véase a continuación el programa desarrollado por Opiron:
2014111_arduino_code

// Industrial Shields by BOOT & WORK CORP.
// Powered by Opiron Electronics -www.opiron.com-
// Jan.2015 technical information for newsletter
// This sketch demonstrates how to use a PID with 
// an ARDBOX ANALOG PLC. The sketch is inspired in a
// real project of a chemical plant, where we have to 
// control the temperature of a pipe.
// PID explanation: The purpose of the pid is to 
// control a loop with a temperature sensor and
// a modulating valve. The modulating valve has 
// an analog input where we can send the setpoint
// Keywords: PID, industrial automation, modulating valve
/////////////////////////////////
//// PLC: ARDBOX ANALOG MODULE///
//// Number of Digital inputs: 2  
//// Number of Digital outputs: 3
//// Number of Analog inputs: 1
//// Number of Analog outputs: 1
//// you need to configurate the correctly switch position for running like digital / analog or PWM mode.
//////////////////////////////
//// Ardbox Pins Used:
//// Q0.9 --- PIN 0 --- Digital Output (24Vdc) --- Start / Stop pump
//// Q0.8 --- PIN 1 --- Digital Output (24Vdc) --- Open / Close feeding valve
//// Q0.7 --- PIN 7 --- Digital Output (24Vdc) --- Light alarm indicator
//// I0.3 --- PIN 4 --- Digital Input (24Vdc)  --- Pump runs confirmation 
//// I0.2 --- PIN 8 --- Digital Input (24Vdc)  --- Feed Valve Opened Ok
//// I0.9 --- PIN A0 --- Analog Input (0/10Vdc) --- Feeding Temperature signal
//// Q0.6 --- PIN A3 --- Analog Output (0/10Vdc) --- Setpoint to Modulating Valve

//libraries
#include 

//Pins defintion
#define Pump_Output 0        // Start / Stop pump
#define Valve_Output 1       // Open / Close feeding valve
#define Light  7             // 1 = Red (alarm) / 0 = false (Ok)
#define Pump_Input 4         // Pump Runs Ok
#define Valve_Input 8        // Feed Valve Opened Ok
#define Temperature A0       // Feed Temperature (after PID)
#define ModulatingValve A3   // Setpoint to Modulating Valve

// Other constants
#define HighTemp  80
#define LowTemp  40
#define intervalValve 10000
#define intervalPump 10000
#define intervalTemperature 60000

// Variables
unsigned long Valvetime;            // We use time to check if Valve opens when we have sent an Open Order
double Setpoint, Input, Output;     // PID Values
double kp = 2.5, ki = 30.3, kd = 5.1;         
unsigned long PIDwindowStartTime;   // Use it to compare PID Window Time
unsigned long PumpwindowStartTime;  // Use it to compare Valve Opening time
unsigned long ValvewindowStartTime; // Use it to compare Valve Opening time
unsigned long TemperaturewindowStartTime; // Use it to compare Temperature out of range
boolean valvefail;                  // 0 = Valve OK, 1 = Valve fails
boolean pumpfail;                   // 0 = Pump OK, 1 = Pump fails
boolean tempfail;                   // 0 = Temp OK, 1 = Temp fails

// Objects
PID TemperaturePID(&Input, &Output, &Setpoint,kp,ki,kd, DIRECT);

void setup() 
{ //Configuration is here:

  //Pin settings
  pinMode(Pump_Output, OUTPUT);
  pinMode(Valve_Output,OUTPUT);
  pinMode(Light,OUTPUT);
  pinMode(Pump_Input,INPUT);
  pinMode(Valve_Input,INPUT);

  // turn the PID on
  TemperaturePID.SetMode(AUTOMATIC);
  Setpoint=60;

  // Ini variables
  valvefail=0;
  pumpfail=0;
  tempfail=0;

} // End setup

void loop() {    // The code in loop() runs repeatedly:

if (tempfail)   // Alarms check I: tempfail
{
  digitalWrite(Pump_Output,LOW);
  digitalWrite(Valve_Output,LOW);
  digitalWrite(Light,HIGH);
}

else if (valvefail) // Alarms check II: Valve can't be opened
{
  digitalWrite(Pump_Output,LOW);
  digitalWrite(Valve_Output,LOW);
  digitalWrite(Light,HIGH);
}

else if (pumpfail) // Alarms check II: Pump doesn't start properly
{
  digitalWrite(Pump_Output,LOW);
  digitalWrite(Valve_Output,LOW);
  digitalWrite(Light,HIGH);
}

else 
  {
    digitalWrite(Pump_Output,HIGH);
    digitalWrite(Valve_Output,HIGH);
    digitalWrite(Light,LOW);
    Input = analogRead(Temperature);
    if (Input> HighTemp || Input < LowTemp)     {     if(millis() - TemperaturewindowStartTime>intervalTemperature)  //We count 1 minute             
    { 
      TemperaturewindowStartTime += intervalTemperature;
      tempfail=1;
    }
    }
    else
    {
      tempfail=0;
    }
    TemperaturePID.Compute();
    analogWrite(ModulatingValve, Output);
    if (Pump_Input==0)    //We wait for the Opened confirmation from the valve
    {
    if(millis() - PumpwindowStartTime>intervalPump)  //We count 10s until the Valve is Opened. If the Valve doesn't return the opened confirmation, we send an alarm                
    { 
      PumpwindowStartTime += intervalPump;
      pumpfail=1;
    }
   } // end If Pump_Input
   else if (Pump_Input==1)
   {
    pumpfail=0;  
   } // end Valve_Input==1
    if (Valve_Input==0)    //We wait for the Opened confirmation from the valve
    {
    if(millis() - ValvewindowStartTime>intervalValve)  //We count 10s until the Valve is Opened. If the Valve doesn't return the opened confirmation, we send an alarm                
    { 
      ValvewindowStartTime += intervalValve;
      valvefail=1;
    }
   } // end If Valve_Input
   else if (Valve_Input==1)
   {
    valvefail=0;  
   } // end Valve_Input==1

  } // end else, normal conditions
} // end loop
POWERED BY OPIRON ELECTRONICS

 

Using Arduino as a PLC: Automation controller with Ardbox Relay

Using Arduino as a PLC: Automation controller with Ardbox Relay

Como podemos conectar a un Ardbox Relay (PLC basado en Arduino)?

Arduino PLC
Arduino based PLC

Para connectar con el Ardbox Relay de Industrial Shields se pueden usar las señales de 24V (estándar industrial). En el ejemplo inferior se puede ver el control de una cinta de transporte usando una de las 8 salidas ‘relé’ del equipo.

Automation controll with Ardbox Relay
Automation control with Ardbox Relay