PROGRAMACIÓN EN ARDUINO Y

AUTOMATIZACIÓN EN PLC

ARDUINO:
Arduino es una plataforma de hardware y software
de código abierto, basada en una sencilla placa con
entradas y salidas, analógicas y digitales, en un
entorno de desarrollo que está basado en el
lenguaje de programación Processing. Es decir, una
plataforma de código abierto para prototipos
electrónicos.
Al ser open source, tanto su diseño como su
distribución, puede utilizarse libremente para el
desarrollo de cualquier tipo de proyecto sin
necesidad de licencia.
El proyecto fue concebido en Italia en el año 2005 por el zaragozano David Cuartielles,
ingeniero electrónico y docente de la Universidad de Mälmo (Suecia) y Massimo Banzi,
italiano, diseñador y desarrollador Web.
Hasta principios de 2015 la web oficial de Arduino era www.arduino.cc mantenida por
los creadores de Arduino y todo su equipo. En febrero de 2015 se hizo público la
ruptura entre los fundadores de Arduino y el fabricante de las placas de Arduino
liderado por Gianluca Martino, comenzando este una nueva dirección del proyecto
Arduino

¿CÓMO SE USA?
El Arduino es una placa basada en un microcontrolador ATMEL. Los microcontroladores
son circuitos integrados en los que se pueden grabar instrucciones, las cuales las
escribes con el lenguaje de programación que puedes utilizar en el entorno Arduino IDE.
Estas instrucciones permiten crear programas que interactúan con los circuitos de la
placa.

El microcontrolador de Arduino posee lo que se llama una interfaz de entrada, que es

una conexión en la que podemos conectar en la placa diferentes tipos de periféricos. La
información de estos periféricos que conectes se trasladará al microcontrolador, el cual
se encargará de procesar los datos que le lleguen a través de ellos.

El tipo de periféricos que puedas utilizar para enviar datos al microcontrolador depende
en gran medida de qué uso le estés pensando dar. Pueden ser cámaras para obtener
imágenes, teclados para introducir datos, o diferentes tipos de sensores.
También cuenta con una interfaz de salida, que es la que se encarga de llevar la
información que se ha procesado en el Arduino a otros periféricos. Estos periféricos
pueden ser pantallas o altavoces en los que reproducir los datos procesados, pero
también pueden ser otras placas o controladores.

PROGRAMA EN ARDUINO:
La programación de Arduino es la programación de un microcontrolador. Esto era algo
más de los ingenieros electrónicos, pero Arduino lo ha extendido a todo el público.
Arduino ha socializado la tecnología.

Programar Arduino consiste en traducir a líneas de código las tareas automatizadas que
queremos hacer leyendo de los sensores y en función de las condiciones del entorno
programar la interacción con el mundo exterior mediante unos actuadores.

Arduino proporciona un entorno de programación sencillo y potente para programar,

pero además incluye las herramientas necesarias para compilar el programa y “quemar”
el programa ya compilado en la memoria flash del microcontrolador. Además el IDE nos
ofrece un sistema de gestión de librerías y placas muy práctico. Como IDE es un
software sencillo que carece de funciones avanzadas típicas de otros IDEs, pero
suficiente para programar.

ESTRUCTURA DE UN SKETCH:
Un programa de Arduino se denomina sketch o proyecto y tiene la extensión
.ino. Importante: para que funcione el sketch, el nombre del fichero debe estar en un
directorio con el mismo nombre que el sketch.

No es necesario que un sketch esté en un único fichero, pero si es imprescindible que

todos los ficheros estén dentro del mismo directorio que el fichero principal.

void setup() {
 // put your setup code here, to run once:
}

void loop() {
// put your main code here, to run repeatedly:
}

La estructura básica de un sketch de Arduino es bastante simple y se compone de al

menos dos partes. Estas dos partes son obligatorias y encierran bloques que contienen
declaraciones, estamentos o instrucciones.

PLC:
Un controlador lógico programable, más conocido por sus siglas en
inglés PLC (Programmable Logic Controller) o por autómata programable, es
una computadora utilizada en la ingeniería automática o automatización industrial, para
automatizar procesos electromecánicos, tales como el control de la maquinaria de la
fábrica en líneas de montaje o atracciones mecánicas.

Los PLC son utilizados en muchas industrias y máquinas. A diferencia de las

computadoras de propósito general, el PLC está diseñado para múltiples señales de
entrada y de salida, rangos de temperatura ampliados, inmunidad al ruido eléctrico y
resistencia a la vibración y al impacto. Los programas para el control de funcionamiento
de la máquina se suelen almacenar en baterías, copia de seguridad o en memorias no
volátiles. Un PLC es un ejemplo de un sistema de tiempo real, donde los resultados de
salida deben ser producidos en respuesta a las condiciones de entrada dentro de un
tiempo limitado, de lo contrario no producirá el resultado deseado.

FUNCIONES DEL PLC:

Un PLC realiza, entre otras, las siguientes funciones:

 Recoger datos de las fuentes de entrada a través de las fuentes digitales y

analógicas.
 Tomar decisiones en base a criterios preprogramados.
 Almacenar datos en la memoria.
  Generar ciclos de tiempo.
 Realizar cálculos matemáticos.
 Actuar sobre los dispositivos externos mediante las salidas analógicas y digitales.
 Comunicarse con otros sistemas externos.
Los PLC se distinguen de otros controladores automáticos, en que pueden ser
programados para controlar cualquier tipo de máquina, a diferencia de otros
controladores (como por ejemplo un programador o control de la llama de una caldera)
que, solamente, pueden controlar un tipo específico de aparato.

Además de poder ser programados, son automáticos, es decir son aparatos que
comparan las señales emitidas por la máquina controlada y toman decisiones en base a
las instrucciones programadas, para mantener estable la operación de dicha máquina.

Puedes modificar las instrucciones almacenadas en memoria, además de monitorizarlas.

COMO SE USA:
Una vez que se pone en marcha, el procesador realiza una serie de tareas según el
siguiente orden:

a) Al encender el procesador ejecuta un auto-chequeo de encendido y bloquea las

salidas. A continuación, si el chequeo ha resultado correcto, el PLC entra en el modo de
operación normal.
b) El siguiente paso lee el estado de las entradas y las almacena en una zona de la
memoria que se llama tabla de imagen de entradas (hablaremos de ella mas adelante).
c) En base a su programa de control, el PLC actualiza una zona de la memoria llamada
tabla de imagen de salida.
d) A continuación el procesador actualiza el estado de las salidas "copiando" hacia los
módulos de salida el estado de la tabla de imagen de salidas (de este modo se controla
el estado de los módulos de salida del PLC, relay, triacs, etc.).
e) Vuelve a ejecutar el paso b)
Cada ciclo de ejecución se llama ciclo de barrido (scan), el cual normalmente se divide
en:

 Verificación de las entradas y salidas

 Ejecución del programa

LOGIX PRO:
El simulador LogixPro 500 es una
herramienta interactiva, creada para
asistir y desarrollar en los estudiantes
habilidades y destrezas necesarias en
programación y desarrollo de sistemas
con PLC`s.
Es una herramienta fácil de usar muy intuitiva y de inmediata aplicación, en lo particular
nunca había utilizado simuladores para practicar programación de Controladores Lógicos
Programables, muchos seguidores del blog, canal de YouTube y redes sociales
recomendaban utilizar el simulador, así lo hice y la verdad lo recomiendo ampliamente.
CABLES PARA RESISTENCIAS
CONEXIÓN

LEDS RGD SENSOR DE

TEMPERATURA Y
HUMEDAD

VENTILADOR PROTOBOARD
// Incluimos librería
#include <DHT.h>

// Definimos el pin digital donde se conecta el sensor

#define DHTPIN 2
// Dependiendo del tipo de sensor
#define DHTTYPE DHT11

// Inicializamos el sensor DHT11

DHT dht(DHTPIN, DHTTYPE);

//LED NORMAL
char caracter;
int RGBVALUE;
//FIN LED NORMAL

void setup() {
// Inicializamos comunicación serie
Serial.begin(4800);

// Comenzamos el sensor DHT

dht.begin();

//Led Normal******************************************************
pinMode(13,OUTPUT); //Led Normal Integrado
pinMode(8,OUTPUT); //Led Normal Rojo
pinMode(9,OUTPUT); //Led Normal Amarillo
pinMode(10,OUTPUT); //Led Normal Verde

//Fin Led Normal************************************************************

//LED RGB***************************************************
pinMode(7,OUTPUT);
pinMode(6,OUTPUT);
pinMode(5,OUTPUT);

//Ventilador
pinMode(12,OUTPUT);
//***********************************

pinMode(2,INPUT);
}

void loop() {

// Leemos la humedad relativa

float h = dht.readHumidity();
// Leemos la temperatura en grados centígrados (por defecto)
float t = dht.readTemperature();
// Leemos la temperatura en grados Fahreheit
float f = dht.readTemperature(true);
//LED INICIO********************************************************

//Led Integrado*************************************
caracter=Serial.read();
delay(10);
/*Cuando se acabe la cadena comprobará el valor, y si es correcto
lo aceptará, sino lo ignorará*/

if (caracter== 'a'){
//Si la cadena dice Enciendete, se prende el led.
digitalWrite(13,HIGH);
}
if (caracter == 'b'){
//Si la cadena dice Apagate, se prende el led.
digitalWrite(13,LOW);
}
//Led ROJO******************************************

delay(10);
/*Cuando se acabe la cadena comprobará el valor, y si es correcto
lo aceptará, sino lo ignorará*/

if (caracter== 'c'){
//Si la cadena dice Enciendete, se prende el led.
digitalWrite(8,HIGH);
}
if (caracter == 'd'){
//Si la cadena dice Apagate, se prende el led.
digitalWrite(8,LOW);
}
//Led Amarillo****************************************

delay(10);
/*Cuando se acabe la cadena comprobará el valor, y si es correcto
lo aceptará, sino lo ignorará*/

if (caracter== 'p'){
//Si la cadena dice Enciendete, se prende el led.
digitalWrite(9,HIGH);
}
if (caracter == 'f'){
//Si la cadena dice Apagate, se prende el led.
digitalWrite(9,LOW);
}

//LED VERDE*******************************************

delay(10);
/*Cuando se acabe la cadena comprobará el valor, y si es correcto
lo aceptará, sino lo ignorará*/

if (caracter== 'g'){
//Si la cadena dice Enciendete, se prende el led.
digitalWrite(10,HIGH);
}
 if (caracter == 'h'){
//Si la cadena dice Apagate, se prende el led.
digitalWrite(10,LOW);
}

//LED RGB*************************************************

String num = Serial.readStringUntil('\n');

int i, len;

int result=0;

len = num.length();

for(i=0; i<len; i++)

{
result = result * 10 + ( num[i] - '0' );
}

if (result!=0){

int resulta = result;

if (101<resulta<355){
analogWrite(7, resulta-100);
}

if (201<resulta<455){
analogWrite(6, resulta-200);
}

if (301<resulta<555){
analogWrite(5, resulta-300);
}
}

//FIN LED

//Ventilador***********************************************************

if (t>29){
digitalWrite(12,HIGH);
}

if (t<=29){
digitalWrite(12,LOW);
}

if (caracter== 'v'){
//Si la cadena dice Enciendete, se prende el led.
digitalWrite(12,HIGH);
}
if (caracter == 'n'){
//Si la cadena dice Apagate, se prende el led.
digitalWrite(12,LOW);
 }

//Sensor Inicio******************************************************************
// Esperamos 5 segundos entre medidas
delay(1000);

// Comprobamos si ha habido algún error en la lectura

if (isnan(h) || isnan(t) || isnan(f)) {
Serial.println("Error obteniendo los datos del sensor DHT11");
return;
}

// Calcular el índice de calor en Fahreheit

float hif = dht.computeHeatIndex(f, h);
// Calcular el índice de calor en grados centígrados
float hic = dht.computeHeatIndex(t, h, false);

Serial.print(h); //Imprimimos la Humedad

Serial.print("_");
Serial.print(t);//Imprimimos la temperatura Celsius
Serial.print("_");
Serial.print(f);//Imprimimos la temperatura Farenheit
Serial.print("_");
Serial.print(hic);//Imprimimos el indice de calor Celsius
Serial.print("_");
Serial.println(hif);//Imprimimos el indice de calor Farenheit
}