a&a remote final
DESCRIPTION
APP androidTRANSCRIPT
UNIVERSIDAD TECNOLOGICA DE CHILE
INACAPAREA ELECTRICIDAD Y ELECTRONICA
Profesor Patrocinante:
Gustavo Dinamarca
A&A REMOTE
Antofagasta, 10 Diciembre de 2014 José Salas
Belfor Psijas
UNIVERSIDAD TECNOLOGICA DE CHILE INACAP Profesor Patrocinante:
Área electricidad y electrónica Gustavo Dinamarca
A&A REMOTE
José Salas
Belfor Psijas
10 Diciembre 2014
iii
ResumenEste documento muestra las etapas de diseño, conexión e implementación de una aplicación
para Android y el microcontrolador Arduino, en adelante “Arduino”.
Por la aplicación Android, un operador o usuario, involucrado en la actividad de control de
un sistema de tratamiento de gases, podrá, a través de su celular o aparato portátil, comunicarse con
la planta, controlándola y monitoreándola en línea, independiente de su ubicación geográfica
mientras cuente con acceso a internet desde su dispositivo.
La aplicación Android se diseñara en el programa eclipse y cumplirá la función de una
interfaz gráfica entre hombre y máquina. Esta aplicación se comunicara, vía acceso de internet, con
Arduino. Este último dispositivo contará con el programa de control de la planta de tratamiento de
gases y cumplirá la función de controlador. En el Arduino se introducirá la lógica de control y se
procesaran las señales de entrada y salida para la manipulación de las variables a controlar.
iv
Tabla de Contenidos
LISTA DE FIGURAS...........................................................................................................................................VI
LISTA DE TABLAS..........................................................................................................................................VIII
ABREVIACIONES..............................................................................................................................................IX
CAPÍTULO 1. INTRODUCCIÓN........................................................................................................................10
1.1. INTRODUCCIÓN GENERAL..................................................................................................................10
1.2. TRABAJOS PREVIOS............................................................................................................................10
1.3. LA OBTENCIÓN DE LA INFORMACIÓN.................................................................................................10
1.4. HIPÓTESIS DE TRABAJO......................................................................................................................10
1.5. OBJETIVOS..........................................................................................................................................11
1.5.1 Objetivo General...........................................................................................................................11
1.5.2 Objetivos específicos.....................................................................................................................11
1.6. ALCANCES Y LIMITACIONES..............................................................................................................11
1.7. TEMARIO Y METODOLOGÍA................................................................................................................12
CAPÍTULO 2.PROCESO.....................................................................................................................................13
2.1. INTRODUCCIÓN...................................................................................................................................13
2.2. TRATAMIENTO DE TEMPERATURA DE GASES......................................................................................13
2.3. ACTUADORES Y SENSORES.................................................................................................................13
2.4. PLANTA DE TRATAMIENTO DE GASES.................................................................................................15
2.5. LAZO DE CONTROL CERRADO.............................................................................................................17
CAPÍTULO 3.ESTRUCTURA PRINCIPAL DEL PROYECTO EN ECLIPSE.................................................18
3.1. INTRODUCCIÓN...................................................................................................................................18
3.2. ESTRUCTURA......................................................................................................................................18
CAPÍTULO 4. INTERFAZ GRÁFICA.................................................................................................................20
4.1. INTRODUCCIÓN...................................................................................................................................20
4.2. REPRESENTACIÓN DE LA PLANTA.......................................................................................................20
CAPÍTULO 5.APLICACIÓN EN PLATAFORMA ANDROID.........................................................................23
5.1. INTRODUCCIÓN...................................................................................................................................23
5.2. DISEÑO DE LA APLICACIÓN................................................................................................................23
5.3. FILOSOFÍA DE CONTROL.....................................................................................................................26
v
CAPÍTULO 6.CONECTIVIDAD........................................................................................................................27
6.1. INTRODUCCIÓN...................................................................................................................................27
6.2. ETHERNET SHIELD..............................................................................................................................27
6.3. CONFIGURACIÓN DE ROUTER.............................................................................................................28
6.4. CONFIGURACIÓN DE APLICACIÓN EN ANDROID.................................................................................29
CAPÍTULO 7.ARDUINO....................................................................................................................................31
7.1. INTRODUCCIÓN...................................................................................................................................31
7.2. PROGRAMACIÓN DEL CONTROLADOR.................................................................................................31
7.3. MODO MANUAL..................................................................................................................................33
7.4. MODO AUTOMÁTICO..........................................................................................................................34
7.5. INTERFAZ SERVIDOR...........................................................................................................................35
CAPÍTULO 8.CONCLUSIONES........................................................................................................................36
8.1. SUMARIO............................................................................................................................................36
8.2. CONCLUSIONES...................................................................................................................................36
8.3. TRABAJO FUTURO..............................................................................................................................36
BIBLIOGRAFÍA...................................................................................................................................................37
vi
Lista de FigurasFIG. 2.3.1. P&ID TRATAMIENTO DE TEMPERATURA DE GASES......................................................14
FIG. 2.4.1. PLANTA DE TRATAMIENTO DE GASES...............................................................................15
FIG. 2.4.2. GABINETE CONTENEDOR DEL CONTROLADOR...............................................................16
FIG. 2.4.3. TABLERO DE DISTRIBUCIÓN DE FUERZA Y CONTROL..................................................16
FIG. 2.5.1. LAZO DE CONTROL CERRADO..............................................................................................17
FIG. 3.2.1. CARPETAS DE “SRC” Y “GEN”...............................................................................................18
FIG. 3.2.2. CONTENIDO CARPETA “RES”................................................................................................19
FIG. 4.1.1. REPRESENTACIÓN DE LA PLANTA......................................................................................22
FIG. 5.2.1. PANTALLA DE USUARIO........................................................................................................23
FIG. 5.2.2. PANTALLA DONDE SE REPRESENTA EL PROCESO Y SUS ELEMENTOS.....................24
FIG. 5.2.3. MENÚ EN EL INFERIOR DE LA PANTALLA........................................................................25
FIG. 5.3.1. IMAGEN CON EJEMPLO DE ACTUADOR INACTIVOS.......................................................26
FIG. 5.3.2. IMAGEN CON EJEMPLO DE ACTUADOR ACTIVOS...........................................................26
FIG. 6.2.1. IMAGEN PARA ACCEDER A CÓDIGO DE WEBSERVER...................................................27
FIG. 6.2.2. MODIFICACIÓN DE IP Y PUERTO.........................................................................................28
FIG. 6.3.1 PUERTO EN ROUTER...............................................................................................................28
FIG. 6.4.1. PUBLIC VOID PARA LA CONEXIÓN CON ARDUINO..............................................................29
FIG. 6.4.2. PERMISO EN ANDROIDMANIFEST.............................................................................................30
FIG. 7.2.1. DECLARACIÓN DE VARIABLES EN ARDUINO........................................................................31
FIG. 7.2.2. DECLARACIÓN DE VARIABLES EN ARDUINO........................................................................32
FIG. 7.2.3. ASIGNACIÓN DE ENTRADAS Y SALIDAS DISCRETAS..........................................................32
FIG. 7.2.4. DECLARACIÓN DE LAS ENTRADAS ANÁLOGAS....................................................................32
FIG. 7.2.5. RUTINA DE PRESENCIA DE CLIENTE........................................................................................33
FIG. 7.3.1. COMANDOS PARA LA LECTURA Y ESCRITURA EN EL SERVIDOR....................................33
FIG. 7.3.2. PARTE DEL CÓDIGO DE LA RUTINA DEL CONTROL AUTOMÁTICO.................................34
FIG. 7.5.1. CABECERA HTML...........................................................................................................................35
vii
FIG. 7.5.2. VISUALIZACIÓN DE ENTRADAS ANALÓGICAS......................................................................35
FIG. 7.5.3. PROGRAMACIÓN ESTADO DE ACTUADORES HTML.............................................................35
FIG. 7.5.4. CIERRE HTML..................................................................................................................................35
viii
Lista de TablasTABLA 4.1.1. REPRESENTACIÓN DE COMPONENTES...............................................................................20
ix
AbreviacionesIDE Entorno de desarrollador integrado.
IP Protocolo de internet.
EV1 Válvula sinusoidal 1.
EV2 Válvula sinusoidal 2.
BB1 Bomba 1.
TK Tanque.
TT Transmisor de temperatura.
LT Transmisor de nivel.
AT Transmisor de pH.
HTML HyperText Markup Language (Lenguaje de Marcas hipertexto)
10
Capítulo 1. Introducción
1.1. Introducción General
Los tablets y teléfonos celulares son de uso común en nuestra sociedad y con el avance de la
tecnología estos equipos han aumentado sus capacidades, de la misma manera han aumentado la
conectividad entre personas, servicios y otros equipos con las tecnologías de comunicación
inalámbrica como Wi-Fi e Internet.
Estos equipos, gracias a sus prestaciones y servicios, sería una herramienta de gran utilidad
en el área del control automático, ya que a través de ellos una persona tendría la habilidad de
monitorear el proceso y controlar las variables manipulables.
La plataforma usada para este servicio es Android, ya que este posee un mayor número de
usuarios en Chile y América Latina en comparación con otros sistemas operativos para equipos
portátiles
1.2. Trabajos Previos
No se cuenta con trabajos previos propios. Pero en la página de desarrollaros de Android se
pueden encontrar ejemplo de utilización de los códigos de programación para Android. Además en
Blogs de internet hay ejemplos del encendido y apagado lámparas utilizando la plata forma Android
y el controlador Arduino conectados entre sí de manera inalámbrica por Wi-Fi o Ethernet. En clases
se ha trabajado con comandos de programación como “if” y “case”, los cuales son utilizados en el
lenguaje Java y C++, que son lenguajes con los que trabajan Android y Arduino respectivamente.
1.3. La obtención de la información
La información es obtenida en totalidad de páginas webs, donde hay video tutoriales en
YouTube, Blogs personales y la página de “Android Developers” que otorgan información para el
trabajo.
1.4. Hipótesis de Trabajo
Programando una aplicación en Android y conectándola con el micro controlado Arduino, se
podrá monitorear el estado de un proceso, visualizar la magnitud de las variables medibles y
11
controlar las variables manipulables a través de la pantalla táctil de un celular, usando como
tecnología de comunicación Internet. Toda la actividad debe desarrollarse en línea.
1.5. Objetivos
1.5.1 Objetivo General
Diseñar e implementar una aplicación que se comunique con Arduino, a través de internet, y
nos permita monitorear, observar la magnitud de las variables manipuladas y controla la primera
etapa de la planta de tratamiento de gases
1.5.2 Objetivos específicos
Definir el proceso.
Hacer una interfaz gráfica que represente el proceso.
Describir los botones y otros.
Introducir la lógica de control en Arduino.
Comunicar vía internet la aplicación Android con Arduino.
Controlar los actuadores desde el dispositivo móvil.
Visualizar en el dispositivo móvil la magnitud de las variables medibles.
Entregar ficheros desde la aplicación Android con información histórica del proceso.
1.6. Alcances y Limitaciones
.En este Proyecto se ha logrado construir una aplicación capaz de controlar de manera remota
la primera etapa del proceso de tratamiento de temperatura de gases a través de internet utilizando
una Tablet con sistema operativo Android como interfaz y un microcontrolador Arduino. La
aplicación cuenta con dos tipos de usuario, un usuario supervisor el cual cuanta con la posibilidad de
aplicar el control automático a la planta y controlar manual de la misma, el otro usuario es el
operador el cual solo tiene acceso al control manual. La aplicación visualiza los estados de los
actuadores y las mediciones de los sensores en tiempo real.
Una de las limitaciones más importantes que nos presentó el proyecto fue, la comunicación
entre Arduino y Android por el hecho de que en la aplicación Android solo se puede enviar un
comando hacia Arduino, pero no existía la retroalimentación. Esto no afecta enormemente el
proyecto. Y hubo que buscar una solución para este problema.
12
El Shield Ethernet de Arduino nos limita, en la sección de creación del código HTML, en
solo usar tres argumentos de programación, en este caso la función IF. Por ende, nuestra
visualización en pantalla se tuvo que adaptar en esto y solo logrando ver los tres actuadores
principales del proceso.
La aplicación solo es adecuada para este proceso en particular, no pudiendo ser modificada o
adaptada para otro proceso. Los ficheros son creados por el controlar Arduino y almacenados en la
memoria SD del mismo controlador.
1.7. Temario y Metodología
En el primer capítulo es una introducción al proyecto y marca las cotas a las que se enfrentan
nuestro trabajo.
El segundo capítulo se describe el proceso que se quiere representar, se nombran y enumeran
cada uno de sus componentes y como intervienen en el proceso.
El tercer capítulo se describe de manera general el entorno de desarrollo que se utiliza para
programar.
El cuarto capítulo muestra cómo se representa cada elemento de manera gráfica en la
interfaz, es decir la manera en que se verá en la pantalla de equipo portátil.
En el quino capítulo se determina los componentes que va a tener nuestra aplicación y como
funcionaran e interactuaran en ella.
Para la utilización de los distintos comandos de programación para Android y Arduino, se
buscaron ejemplos que aplicaran a nuestras necesidades, a veces agregando modificaciones para
adaptar las rutinas a lo que se requería para la aplicación. Se probó la funcionalidad de estos códigos
a través de ensayo y error.
13
Capítulo 2. Proceso
2.1. Introducción
El tratado de la temperatura del gas es un proceso muy utilizado en la industria ya sea para
un tratamiento del gas para luego liberarlo, un pre acondicionamiento para usarlo como combustible
o para su envasado y posterior trasporte.
Por lo que sería de a ayuda, para las personas involucradas en esta actividad, diseñar una
aplicación para el control de temperatura de un gas en Android para celulares o Tablets. Ya que a
través de esta aplicación podrían saber el estado actual y decidir qué hacer (controlarlo) en cualquier
lugar al que tengan acceso a internet. [5]
2.2. Tratamiento de temperatura de gases
El proceso tiene por nombre, tratamiento de temperatura de gases, el cual consiste en que
ingresa un gas, al proceso, con una temperatura inadecuada para el proceso siguiente que sería el
“lavado de gases con Venturi”. Entonces, el gas para entrar al proceso de lavado, tiene que llegar a
una temperatura ambiente para que el proceso funcione sin problema y óptimamente.
El proceso de torre de aspersión tiene por objetivo bajar la temperatura del gas de ingreso y
dejarlo a una temperatura ambiente. Para bajar esta temperatura se utiliza agua (el gas que ingresa
no tiene que reaccionar con agua), esta agua viaja a través de tuberías y es impulsada por una bomba
a la torre de aspersión, en la cual, por rociadores, es expulsada para que logre disminuir la
temperatura del gas. [5]
2.3. Actuadores y Sensores
El proceso de tratamiento de temperatura de gases cuenta con 4 sensores los cuales miden,
respectivamente, temperatura de ingreso y salida (lo más importante del proceso). Un sensor de
nivel en el tanque que abastece el rocío, el cual tiene su función en la torre de aspersión y en este
tanque también se mide constantemente el pH, ya que a medida del tiempo esta agua se contaminara
y su pH se volverá ácido.
La medición de pH, es la que condiciona el accionar de apertura de la válvula de vaciado del
tanque de abastecimiento de agua. Y el cierre de esta válvula esta acondicionado con la medición de
14
pH y la medición mínima de nivel. La válvula que suministra agua limpia al tanque de
abastecimiento, esta acondicionada por el sensor ultrasónico de nivel. Las bombas están, netamente,
en función de la temperatura. Según la medición, el algoritmo de control decidirá la operación de
una o las dos bombas, para el roció en la torre de aspersión. El extractor del gas no está
acondicionado por ninguna variable, este de activa o desactiva con un botón que arranca el proceso
completo.
En resumen la planta cuenta con:
3 Actuadores:
Válvula de suministro.
Válvula de vaciado.
Bomba de roció 1.
Y 4 sensores:
Temperatura de entrada.
Temperatura de salida.
Sensor ultrasónico de nivel.
Sensor de pH.
Fig. 2.3.1. P&ID Tratamiento de temperatura de gases
15
2.4. Planta de tratamiento de gases
El proceso que quiere ser controlado es la primera etapa del tratamiento de gases, el cual
consiste en alcanzar una temperatura adecuada del gas para que pueda ser derivado a otra etapa del
tratamiento de gases.
Para emular esta primera etapa se cuanta con una maqueta que realiza esta sección del
proceso. Esta maqueta será controlada por el controlador Arduino y nos comunicaremos de forma
remota utilizando internet desde un aparato portátil con sistema operativo Android, la aplicación
diseñada para comunicación entre estos dos dispositivos, tendrá como objetivo representar de
manera gráfica el proceso en la pantalla táctil, mostrando en modo automático las variables
sensadas, los estados de los actuadores y en modo manual dará la posibilidad de manipular los
actuadores como el usuario lo desee. Los cambios que ocurran podrán ser visualizados de manera
local en la maqueta.
La maqueta cuenta con una torre se aspersión donde se regulara la temperatura del gas, las
válvulas que modificaran el nivel del estanque de agua que se encuentra en el nivel inferior a la torre
de aspersión y la bomba que conducirá un caudal constate de agua hacia la torre de aspersión.
Fig. 2.4.1. Planta de tratamiento de gases
16
El controlador Arduino se encuentra de manera local dentro de un gabinete para su
protección, este enviara las señales desde una tarjeta de relés los cuales activaran las bobinas de los
contactores que se necesiten actuar.
Fig. 2.4.2. Gabinete contenedor del controlador
La planta cuenta con un talero de distribución de fuerza y de control, esto permitirá que la
planta pueda ser manipulada de manera local.
Fig. 2.4.3. Tablero de distribución de fuerza y control.
17
2.5. Lazo de control cerrado
Son los sistemas en los que la acción de control está en función de la señal de salida. Los sistemas de circuito cerrado usan la retroalimentación desde un resultado final para ajustar la acción de control en consecuencia. El control en lazo cerrado es imprescindible cuando se da alguna de las siguientes circunstancias:
Cuando un proceso no es posible de regular por el hombre. Una producción a gran escala que exige grandes instalaciones y el hombre no es capaz de
manejar. Vigilar un proceso es especialmente difícil en algunos casos y requiere una atención que el
hombre puede perder fácilmente por cansancio o despiste, con los consiguientes riesgos que ello pueda ocasionar al trabajador y al proceso.
Sus características son:
Ser complejos, pero amplios en cantidad de parámetros. La salida se compara con la entrada y le afecta para el control del sistema. Su propiedad de retroalimentación. Ser más estable a perturbaciones y variaciones internas.
Fig. 2.5.1. Lazo de control cerrado
18
Capítulo 3. Estructura principal del proyecto en Eclipse
3.1. Introducción
La IDE usada para programas la aplicación es Eclipse. Se eligió este programa por su
amigable interfaz y la existencia de un gran número de tutoriales e información refiriéndose a su uso
y componentes.
3.2. Estructura
Un proyecto Android está organizado por diferentes carpetas, que a su vez contienen varios
ficheros y recursos, por ejemplo, imágenes, audio, archivos xml, archivos java, etc.
En la zona superior del panel lateral izquierdo de Eclipse vemos lo siguiente:
• Dentro de la carpeta “SRC” encontramos el código Java de nuestra app, es decir, la
activity principal (MainActivity.java) y el resto de clases que vayamos creando.
• La carpeta “GEN” contiene un archivo “R.java” que nos permite acceder a los
recursos ubicados en la carpeta RES desde la activity (actividad), mediante el uso de identificadores.
• También vemos los archivos “jar” que vamos a necesitar para la versión de API
específica.
Fig. 3.2.1. Carpetas de “src” y “gen”.
La carpeta “RES” contiene los diferentes tipos de recursos que utiliza nuestra aplicación.
Dentro de “RES” encontramos 3 subcarpetas: drawable, layout, y values. La primera de ellas es la
19
encargada de guardar las imágenes, la segunda contiene un fichero xml con las vistas de cada
activity, y la última carpeta almacena estilos (Style), cadenas de caracteres (Strings), entre otros.
El archivo “AndroidManifiest.xml” define características importantes de la aplicación. Por
ejemplo, los permisos que necesita, la versión mínima de la plataforma, su número de activities
(actividades) e intents, así como los services y content providers necesarios.
El fichero “proyect.properties” tiene como función principal comprobar la versión del
sistema al instalar la aplicación en el móvil. Su contenido es generado automáticamente por el SDK
y no debe ser modificado. [1]
Fig. 3.2.2. Contenido carpeta “res”
20
Capítulo 4. Interfaz gráfica
4.1. Introducción
La interfaz gráfica de un proceso es importante, ya que a través de imágenes se representara
la planta en la pantalla del dispositivo. Esta interfaz debe ser amigables, de fácil acceso y
entendimiento para el usuario, por lo que las imágenes tienen que representar de la mejor manera los
distintos componentes del sistema y acercarse gráficamente a su forma real o normada, así las
personas que utilicen la aplicación podrán relacionar los objetos que ven en la pantalla con lo que se
encuentra en terreno.
4.2. Representación de la planta
El sistema de control de temperatura de gases se aprecian los siguientes actuadores: una
bomba y dos válvulas sinusoidales. En lo que a sensores se refiere encontramos: dos sensores de
temperatura, un sensor de pH y un sensor de nivel como elementos de medida. La estructura de la
planta también contiene dos estanques, los cuales portan el agua, una torre de aspersión, una fuente
de emanación de gas y tuberías. Los elementos antes mencionados serán representados con la
siguiente tabla:
21
Bombas
Válvulas
Sensores
Fuente de emanación de gas
Torre de aspersión
Tanque de agua
Cañería para gas
Cañería para agua
Tabla 4.1.1. Representación de componentes
22
La representación de la planta, uniendo todos sus elementos, es de la siguiente manera:
Fig. 4.1.1. Representación de la planta.
23
Capítulo 5. Aplicación en plataforma Android
5.1. Introducción
La aplicación a la que va dirigida el proyecto es Android, por la cantidad de información en
la web para desarrolladores de aplicaciones, tutoriales y documentación para diseñadores. Pero uno
de los aspectos más importantes es el hecho que en américa latina y chile, Android es el sistema
operativo más popular, rondando el 62% de usuarios en el mercado latinoamericano y nacional. [2]
5.2. Diseño de la aplicación
La aplicación tiene por nombre “A&A REMOTE”, el primer conjunto de caracteres “A&A”
haciendo referencia a Android y Arduino y “REMOTE” de por el significado de la palabra que da a
entender de una posición lejana en el espacio.
La aplicación posee dos pantallas para que el usuario interactúe con la aplicación, cada una
cumpliendo la función como interfaz para una actividad en específico.
Al iniciar la aplicación aparecerá la pantalla de identificación de usuario, donde la persona se
deberá identificar e ingresar la clave de acceso para visualizar y controlar el proceso. Esta restricción
de acceso proviene de la necesidad de que solo las personas con competencias en el área y
autorizadas intervengan en el proceso, para dar como resultado un buen funcionamiento de planta y
velar por la seguridad de las personas que pudieran estar involucradas.
Fig. 5.2.1. Pantalla de usuario
24
Además de lo anterior mencionado, en esta primera etapa, la aplicación dependiendo de
quién sea el usuario que ingrese sus datos ofrecerá ciertas restricciones, estas restricciones son sobre
el acceso a las distintas modalidades de control de la planta. La aplicación cuenta con dos tipos de
controles, un control automático en el cual por defecto está ajustado el punto de consigna en el que
deben mantenerse las variables medibles los cuales son el pH, nivel y temperatura, el otro tipo de
control es el manual, en el que se podrán controlar las válvulas y la bomba a través de botones de
encendido y apagado en pantalla.
La siguiente pantalla muestra al proceso, con una representación gráfica de la planta
simplificada y de fondo color negro para mejorar el contraste y detectar fácilmente los cambios en
las imágenes. Esta pantalla también contara con botones que simularan una botonera en terreno para
comandar los distintos actuadores. Además, se encontraran de manera visual las lecturas de las
magnitudes físicas que se miden en el proceso.
En esta sección de la aplicación el proceso estará siendo visualizado desde el servidor del
que ofrece el controlador Android a través de un elemento llamado webview. Este objeto nos da la
posibilidad d visualizar en tiempo real a través de internet el estado de la planta y la medida de sus
variables
Fig. 5.2.2. Pantalla donde se representa el proceso y sus elementos
La aplicación cuenta con un menú que se despliega para desplazarse hacia otras pantallas y
funciones.
25
Fig. 5.2.3. Menú en el inferior de la pantalla
26
5.3. Filosofía de control
La filosofía de control que se desea utilizar es representar en una circunferencia sobre los
actuadores el estado de estos mismos. La esfera color verde indica que los actuadores se encuentran
en modo de reposo y en rojo que las válvulas o la bomba está operando. Esto lo lograremos
cambiando la imagen correspondiente a la combinación de los actuadores activo o inactivos.
Fig. 5.3.1. Imagen con ejemplo de actuador inactivos
Fig. 5.3.2. Imagen con ejemplo de actuador activos
27
Capítulo 6. Conectividad
6.1. Introducción
Todos los dispositivos que estén conectados a la misma red que esté conectado el Arduino,
tendrán la posibilidad de interactuar con el aparato que queramos controlar, es decir, quien esté en la
red casa, de la oficina, del edificio, etc. Es por que a continuación se explicara a forma de realizar la
conectividad entre Arduino y un Smartphone con Android.
6.2. Ethernet Shield
El Ethernet Shield es un módulo que permite a una placa Arduino conectarse a internet. Se
basa en el chip ethernet Wiznet W5100. El Wiznet W5100 proporciona una red (IP) capaz de utilizar
TCP y UDP. Utiliza la biblioteca Ethernet, la cual facilita a conexión y operación de este módulo
[4].
El Ethernet Shield se utilizara para montar un servidor Web, el cual nos proporcionará el
código para poder verlo en nuestro navegador y poder, así, interactuar con él y con la aplicación
Android que crearemos a continuación. Este código se puede extraer del programa Arduino IDE en
Archivos > Ejemplo > Ethernet > WebServer.
Fig. 6.2.1. Imagen para acceder a código de WebServer.
Una vez hecho esto, este código se modifica: la IP y el puerto, por los que se usaran. Y
obviamente la programación para o que se desea utilizar para el proceso.
28
Fig. 6.2.2. Modificación de IP y puerto.
Posteriormente, el Ethernet Shield se conecta a un router por medio de un cable de red con
cabezales RJ-45, y este estará listo para operar.
6.3. Configuración de Router
Si queremos controlar desde internet nuestro Arduino (red externa), necesitamos abrir un
puerto del Router y saber nuestra dirección IP. Para abrir un puerto tantas formas, como modelos
hayan en el mercado, por lo general, hay que ingresar al Router por un navegador y buscar en la
configuración los puerto, y hay dar permiso a la dirección IP que les asignamos al Arduino con el
respectivo puerto.
Fig. 6.3.1 Puerto en Router.
Para saber nuestra IP, basta con buscar en internet con la simple palabra “Mi ip” con eso un
sinfín de páginas ofrece el servicio para poder saber la IP del equipo en que esta. Esto se necesita
para para acceder desde una red externa a la local, y se puede hacer accediendo a la IP del equipo
proporcionada por la compañía que brinda el servicio, IP dinámica, y colocando el puerto por el cual
29
acceder. Por ejemplo: 192.168.0.110:80. También se puede hacer con una IP estática, la IP dinámica
cambian no siempre es la misma, para tener una IP dinámica es un servicio pagado. [6] [10]
6.4. Configuración de aplicación en Android
En el proyecto de Eclipse, en el MainActivity se crea un Public void para enviar la
instrucción de control a nuestro Arduino. A través de un botón en el Layout se llama al Public void
por medio de la función OnClick, donde este llama a un Public void para presionarlo y otro para
volver a presionarlo, en simples palabras manda un ON o un OFF.
El Public void tiene que inicializar un cliente http para poder conectarnos con nuestro
WebServer en el Arduino, y se le asigna la IP correspondiente pero, se le adjunta la instrucción de
control. Por ejemplo, http://192.168.0.1:80/?L=1, este L=1 nos indica que prendera un Led 1 que
nosotros hayamos designado en el Arduino. Esta dirección se envía por el método http post, es un
protocolo que pasa los pares de nombre y valor en el cuerpo del mensaje de solicitud HTTP.
A continuación, se puede ver el código implementado en el proyecto de Eclipse.
Fig. 6.4.1. Public void para la conexión con Arduino.
También en el AndroidManifest hay que darle permisos de internet a la aplicación, ya que a
través de esta, Android tendrá acceso a internet y podrá conectarse con el Arduino.
30
Fig. 6.4.2. Permiso en AndroidManifest.
31
Capítulo 7. Arduino
7.1. Introducción
Arduino es una plataforma electrónica de prototipo de hardware libre basado en un hardware
y software flexible y fácil de usar. Arduino consiste en una placa con un microcontrolador y puertos
de entradas y salidas integrados [3], además en este caso se adoso una placa Shield Ethernet para
poder comunicarnos con el a través de internet. Los lenguajes de programación utilizados son C++
para las rutinas de control y HTML para la interacción de nuestra aplicación Android con el
controlador.
7.2. Programación del controlador
Nuestra aplicación va a utilizar Internet para el envió y recepción de señales por lo tanto
como primer paso dentro de la rutina en Arduino debemos declarar los datos necesarios de nuestra
red como la dirección IP, mascara de subred y puerto para nuestro Ethernet Shield.
Fig. 7.2.1. Declaración de variables en Arduino.
En la rutina de programación de Arduino, como paso siguiente, se definieron las variables:
ValvulaS, Bomba1, ValvulaV, TemperaturaE, TemperaturaS, pH, Nivel, Emergencia como enteros.
Las variables mencionadas corresponden respectivamente a EV1, bomba, EV2, Sensor de
temperatura de entrada, Sensor de temperatura de salida, Sensor de pH, Sensor de nivel y parada de
emergencia.
32
Fig. 7.2.2. Declaración de variables en Arduino.
Luego se deben definir los pines de entrada y salida que son utilizados en el
microcontrolador asignándolos como entradas o salidas.
Fig. 7.2.3. Asignación de entradas y salidas discretas.
Además definimos los variables de los valores que están asociados a los sensores como
variables análogas asociadas a su respectivo puerto.
Fig. 7.2.4. Declaración de las entradas análogas.
En el controlador Arduino se debe crear un cliente de conexión para que nuestro controlador
establezca comunicación a través de internet, esto se logra con una rutina “if” con la cual el Arduino
detecte que hay un cliente conectado y espere las instrucciones de este.
33
Fig. 7.2.5. Rutina de presencia de cliente.
7.3. Modo manual
En el modo manual, Arduino espera las instrucciones que va a enviar el supervisor u
operador de la planta a través de su portátil. La manipulación de los actuadores en modo manual,
como se mencionó en capítulos anteriores, se realizara por medio de botones en la pantalla del
celular o Tablet, los cuales dentro de la rutina en Android tendrán asignada una URL que
corresponderá a una instrucción en especifica en Arduino, esta dirección está conformada por la
dirección IP más el código con el que se le asigna a esa acción en particular dentro de la rutina de
Arduino. El comando “readString.indexOf” es el encargado reconocer el código enviado desde
Android al servidor y asociarlo al código de Arduino, con el comando “digitalWrite” se enviara la
acción al servidor y se ejecutara al mismo tiempo la acción programada en el controlador. En este
modo el usuario de la aplicación podrá abrir o cerrar las válvulas y encender o parar la bomba del
proceso.
Fig. 7.3.1. Comandos para la lectura y escritura en el servidor
34
La lectura de las mediciones de los sensores debe seguir entregando las magnitudes de las
variables medidas por lo que siguen enviando información al servidor que genera el Ethernet Shield
7.4. Modo automático
Al modo automático solo tendrá acceso el usuario supervisor, esto quiere decir que solo él
podrá poner en marcha el proceso de forma automática. El modo automático se activara por medio
de un botón desde la aplicación Android, la activación de este botón le indicara al Arduino que debe
utilizar la rutina diseñada para mantener el nivel del agua del estanque a cierta altura, por lo que la
manipulación de las válvulas y la bomba no necesitara intervención humana y se regirá de acuerdo a
la programación dada por los diseñadoras. Los sensores deben seguir mostrando las magnitudes de
las variables por lo que en la pantalla del aparato portátil estos valores seguirán mostrándose. [9]
Fig. 7.3.2. Parte del código de la rutina del control automático
35
7.5. Interfaz servidor
La interfaz del servidor está programada en HTML y esta guardada en Arduino, esto es
gracias a la Ethernet Shield que nos proporciona un WebServer. Esta interfaz es accesible a través
de la IP asignara al Arduino.
Lo primero que se tiene que hacer en el código es darle la cabecera de HTML.
Fig. 7.5.1. Cabecera HTML.
En el Body se ingresa el color de fondo, para nuestra interfaz se eligió el negro para darle
contraste con las imágenes dentro de nuestra pantalla.
Fig. 7.5.2. Visualización de entradas analógicas.
En la Figura anterior, se puede observar cómo se lee la entrada analógica y se imprime en el
código HTML. [7]
Ahora vemos la programación realizada para que las imágenes vallan cambiando según el
estado de los actuadores.
Fig. 7.5.3. Programación estado de actuadores HTML.
Cabe destacar, que las imágenes están almacenadas en una nube en internet, por ende se
necesita acceso a internet para ver estas imágenes.
Por último, se cierra el Body para darle fin al código HTML. [8]
Fig. 7.5.4. Cierre HTML.
36
Capítulo 8. Conclusiones
8.1. Sumario
La información se obtuvo desde la web, de páginas con tutoriales o páginas de
desarrolladores de aplicaciones Android. Donde se estudiaron los códigos y se aplicaron a los
requerimientos de nuestra aplicación
8.2. Conclusiones
El desarrollo de la aplicación es factible. Ya que los recursos y funciones de las aplicaciones
Android se pueden adaptar para utilizarlos en el control automático y monitoreo de una planta a
distancia.
La gran ventaja es el uso de aparato con los que ya cuentan lo usuarios o son fáciles de
adquirir en el mercado, como celulares y Tablet. Arruino, también es una plataforma fácil de
adquiere y familiarizarse, gracias a la gran cantidad de tutoriales y ejemplos para desarrolladores
que se encuentran y la gran ventaja de este controlador es su característica de código abierto, esto a
logrado que Arduino sea compatible con otras plataformas y códigos de programación como HTML
y C++.
Con la aplicación en Android y la programación del controlador, se logró monitorear y
controlar la planta de tratamiento de gases a través de internet, dando la posibilidad de que los
usuarios que tengan acceso y estén autorizados por la Aplicación puedan visualizar las variables
medidas, los estados de los actuadores y además controlar estos últimos desde cualquier parte del
mundo donde tengan acceso a internet.
8.3. Trabajo Futuro
Agregarle la capacidad de adaptarse a otros procesos, agregando nuevos componentes de
procesos, como otros tipos de sensores y actuadores, para que la aplicación pueda ser modificada
por el usuario y así adaptarla a sus necesidades.
37
Bibliografía
[1] http://www.elandroidelibre.com/tag/20conceptos
[2] http://guialocal.com/blog/es/2013/12/17/sistemas-operativos-mobile-quien-es-quien-en-
latinoamerica/
[3] http://www.arduino.utfsm.cl/que-es-arduino/
[4] http://arduino.cc/en/pmwiki.php?n=Main/ArduinoEthernetShield
[5] Tesis: “Automatización de cámara rociadora con Arduino”, Jorquera – Cantuarias –
Meléndez – Ruiz, 2014, Inacap Antofagasta.
[6] http://standards.ieee.org/about/get/802/802.11.html
[7] http://ascii.cl/es/codigos-html.htm
[8] http://www-app.etsit.upm.es/~alvaro/manual/manual.html
[9] http://arduino.cc/en/Reference/HomePage
[10] http://www.artinteractivo.com/arduino-ethernet