Ing.
Ramiro Vladimir Mora Miranda
RESUMEN:
Son diversos los prototipos que actualmente
emplean placas tipo Arduino, como instrumento principal para su desarrollo. Estas
placas, también son empleadas en la adquisición de datos reales, con el fin de
ser evaluados o tratados por un programa CAD, como Labview. Es posible simular
un dispositivo Arduino, en el programa Proteus, mediante la librería denominada
Simulino y que este circuito simulado, se conecte de forma remota y virtual con
otra aplicación desarrollada en Labview, lo que permitirá la evaluación a
distancia, de una propuesta, sin la necesidad de adquirir componentes
electrónicos adicionales, reduciendo significativamente el costo y tiempo
empleado en un proceso de diseño, que en algunos casos, requiere de
dispositivos reales que no siempre se encuentran disponibles.
PALABRAS CLAVE: Arduino, Labview,
Proteus, Simulino, Ethernet.
1 INTRODUCCIÓN
Trabajar con programas
para el Diseño Asistido por Computadora (Computer
Aided Design – CAD) Electrónicos, ofrece muchas ventajas; una de las más
significativas es la disponibilidad de contar con un grupo innumerable de
instrumentos y dispositivos, a los que no se acceden fácilmente, ya sea por su
carencia en el laboratorio o la ausencia del producto dentro del mercado local,
sin mencionar la cantidad de recursos económicos que demandarían su
adquisición. Es por esta razón que, tanto estudiantes como docentes de las
carreras de Ingeniería de Sistemas Electrónicos, Telecomunicaciones, Mecatrónica
y otras, realizan los diseños de sus circuitos electrónicos empleando estos
programas informáticos, que hoy en día, alcanzaron una mayor precisión y
confiabilidad.
Por otra parte, está
Arduino, que es una plataforma de hardware de código abierto, basada en una
sencilla placa con entradas y salidas, analógicas y digitales. Es un
dispositivo que permite la conexión entre el mundo físico con el mundo virtual,
o el mundo analógico con el digital. Arduino, se está convirtiendo en uno de
los instrumentos, cada vez más, utilizado en las actividades académicas y
profesionales dentro del campo de la Ingeniería Electrónica. Arduino, en sus
diferentes versiones, aporta de una manera importante al desarrollo de un
proyecto y si a esto se añade la disponibilidad de una gran cantidad de
sensores, actuadores y otros dispositivos, acondicionados especialmente para
este tipo de placas, se obtienen prototipos con altas prestaciones de calidad,
confiabilidad y rendimiento.
Los sistemas CAD
electrónicos no podían ignorar este avance tecnológico en base a Arduino, y es
por eso que programadores independientes, desarrollaron librerías para simular
estas placas. Es el caso de la librería Simulino para Proteus, que pone a
disposición del usuario, una gama amplia de placas Arduino (Nano, Uno y Mega),
además de proporcionar el simulador para el sensor ultrasónico HC-SR04.
Son diversas las
universidades que adquieren licencias del programa Labview y las ponen a
disposición de los estudiantes y docentes para el desarrollo de sus actividades
académicas y proyectos de investigación. LabVIEW (acrónimo de Laboratory
Virtual Instrumentation Engineering Workbench) es una plataforma y entorno de
desarrollo para diseñar sistemas, con un lenguaje de programación visual
gráfico, recomendado para sistemas hardware y software de pruebas, control y
diseño, simulado o real y embebido.
Existen varias
experiencias en cuanto a la adquisición y procesamiento de datos empleando
Labview y placas Arduino. Sin embargo, algunos proyectos requieren de dispositivos
específicos y, en ocasiones, complica el desarrollo de estos proyectos las
limitaciones técnicas y tecnológicas de los laboratorios. Es a este
inconveniente que el presente trabajo pretende dar una solución; a través de la
simulación, en Proteus, de un circuito electrónico que emplee Arduino, para la adquisición
y procesamiento de datos a cargo de un programa Labview, que radicará en una
computadora distinta y distante; ambas computadoras estarán conectadas vía
Ethernet.
2 SIMULACIÓN DE ARDUINO EN PROTEUS
Una etapa importante en
el desarrollo de un proyecto, es la del diseño. Proteus, es una de las muchas
herramientas informáticas que existen para este efecto. Se seleccionó Proteus,
debido principalmente a que el programa permite la simulación de placas
Arduino, a través de la instalación previa de las librerías adecuadas, en este
caso las denominadas Simulino.
El procedimiento para la
instalación de Simulino, en Proteus, es muy sencillo, solo se deben copiar los
archivos Arduino.lib y Arduino.idx en la carpeta Library, en el lugar donde se instaló el programa Proteus, de esta
manera Arduino, estará disponible dentro de la enorme lista de componentes
virtuales que ofrece Proteus.
En
http://www.instructables.com/id/How-to-add-Arduino-Library-in-to-Proteus-7-8/
se explica con detalle el procedimiento para la instalación de Simulino en
Proteus.
El circuito de prueba,
para el presente trabajo, consideró el sensor ultrasónico HC-SR04, el cual
también está disponible dentro la librería Simulino, para Proteus. El código del programa Arduino puede ser
descargado del Anexo.
Fig. 1. Circuito para la
medición de distancia.
Para simular el
circuito, se requiere compilar del programa que, en su formato ya compilado,
normalmente tiene una extensión HEX, y contiene el lenguaje de máquina para que
el microcontrolador de Arduino, ejecute las instrucciones. El archivo se lo
genera en el programa específicamente desarrollado para Arduino, y este, lo
deposita en una ubicación temporal.
En
http://geekelectronica.blogspot.com/2015/01/simular-arduino-con-proteus.html
encontrará una descripción detallada de este proceso.
Una vez compilado el programa,
se procede a su cargado en el simulador. Basta con realizar un doble clic sobre
el símbolo representativo de la placa Arduino, para obtener la ventana de
configuración y dentro del campo Program
File se indica la ubicación del programa compilado.
Fig. 2. Definición del
programa compilado para Arduino.
Antes de iniciar la
simulación, se debe considerar que el sensor ultrasónico HC-SR04, también
requiere de un programa para su ejecución. El archivo UltraSonicsensor.HEX fue
el empleado para el proyecto y está disponible junto con la librería Simulino.
Fig. 3. Identificación
del programa compilado para el HC-SR04.
Al momento de simular el programa, se
obtuvieron mediciones de distancia dentro la pantalla de la terminal virtual,
en la figura 4 se presentan estos valores.
Fig. 4. Lecturas de
distancia generados por Arduino.
El sensor ultrasónico
entregó datos a Arduino, el cual los interpretó e imprimió mediante la
comunicación serial, valores que representan la distancia a la que se
encontraría un objeto real; con la variación del potenciómetro es posible
obtener lecturas diferentes, serán precisamente estos datos los que sean
recibidos por Labview.
3 ADQUISICIÓN DE DATOS EN LABVIEW A TRAVÉS
DE ARDUINO
LabVIEW, por medio de
complementos tales como MakerHub o NI-VISA, permiten conectarse con plataformas
embebidas comunes como chipKIT, Arduino y NI myRIO, o transductores comunes
incluyendo acelerómetros, sensores de temperatura y sensores ultrasónicos de
distancia. Para conectar Labview, con una placa Arduino, es necesario instalar
lo que denominan el Firmware, que no
es nada más que un programa intermedio entre Labview y las prestaciones de
Arduino.
En la página web:
http://www.instructables.com/id/Arduino-and-LabVIEW/ se encuentra un
procedimiento detallado acerca de la instalación y configuración de NI-VISA
para la adquisición de datos por medio de Arduino.
En las figuras 5 y 6, se
presentan los circuitos programados en Labview, para la adquisición de datos a
ser enviados por Arduino, vía puerto serial. Recordando que esto se
desarrollará en un entorno simulado.
Para lo opción True.
Fig. 5. Circuito de
adquisición de datos para la opción True.
Para la opción False.
Fig. 6. Circuito de
adquisición de datos para la opción False.
A continuación, se
realizará la comunicación entre Simulino (Arduino simulado en Proteus) y los
programas Labview, a través de puertos seriales virtuales.
4 COMUNICACIÓN ENTRE LABVIEW Y SIMULINO
Es posible realizar la
comunicación de dos aplicaciones diferentes, ambas instaladas en una misma
computadora y es a través de un par de puertos seriales virtuales, no físicos.
En este trabajo, se empleó una comunicación virtual tipo null modem.
Fig. 7. Configuración de
dos puertos seriales virtuales en Eltima Software.
El programa Virtual
Serial Port Driver de Eltima, permitió comunicar, a través del puerto serial
virtual, el circuito simulado en Proteus, el cual contaba con una placa virtual
Arduino, y Labview. Existen otras aplicaciones similares y gratuitas, sin
embargo el programa de Eltima, en su versión de prueba fue suficiente como para
lograr una comunicación efectiva entre Simulino y el circuito en Labview.
En la página web
http:/perso.wanadoo.es/pictob/rs232virtual.htm se tiene un tutorial para la
configuración del programa de Eltima.
Fig. 8. Esquema de
comunicación entre Proteus y Labview.
Una prueba de
conectividad, entre los puertos seriales virtuales (COM1 y COM2), se realizó
empleando el programa Mttty, que es una aplicación gratuita tipo Hyperterminal.
Confirmada la
posibilidad de envío y recepción de datos entre las aplicaciones Mttty, por
medio de los dos puertos seriales virtuales, se procedió a la simulación del
circuito en Proteus, y la adquisición de los datos, representativos de la
distancia, por parte de Labview. El resultado se presenta en la figura 9.
Fig. 9. Lectura en
Labview de valores de distancia generados por Simulino
Con esta experiencia fue
posible realizar la lectura de datos de un entorno simulado, con ambas
aplicaciones residentes en una misma computadora; el paso siguiente es poder
lograr la lectura de datos, pero esta vez, con las aplicaciones instaladas en
dos computadoras diferentes, las que se encontrarán conectadas a una red de
área local.
5 COMUNICACIÓN LABVIEW CON SIMULINO VÍA
ETHERNET
Si bien, el empleo de
dos aplicaciones CAD, instaladas en la misma computadora, permite su conexión a
través de puertos seriales virtuales, muchas veces es necesario recurrir a un
par de computadoras, una para la simulación del circuito (Proteus) y la otra el
tratamiento de los datos (Labview). Esto mejoraría las prestaciones de
rendimiento, superando las limitaciones de Hardware, o quizás por cuestiones de
licencia de uso, sin descartar la posibilidad de la realización de trabajos a
distancia.
La conexión, entre el
circuito simulado en Proteus, el que cuenta con una placa Arduino, y Labview,
se realizó a través de puertos seriales virtuales conectados a Ethernet, esto
se consiguió mediante la aplicación Network Serial Port Kit de Fabulatech.com,
en su versión de evaluación. Existen otras aplicaciones similares disponibles
en Internet.
En la página web oficial
del producto, se tiene un resumen de la configuración necesaria para su
funcionamiento. Visite: http://www.fabulatech.com/network-serial-port-kit.html
Figura 10. Esquema de
comunicación entre Proteus y Labview vía Ethernet
Fue necesario definir
una de las computadoras como Cliente y a la otra como Servidor, además de
configurar a los puertos seriales virtuales como tipo null modem.
Una prueba de la
configuración cliente – servidor de los puertos seriales virtuales, para el
envío y recepción de datos, fue a través de la aplicación Mttty instalada en
ambas computadoras.
 |
 |
Figura 11. Prueba de
conectividad del cliente y servidor, a través del puerto virtual.
En una computadora, definida
como servidor, se ejecutó Labview con el programa desarrollado anteriormente y
un puerto serial COM1. En la otra computadora, definida como cliente, se
ejecutó Proteus, con el circuito de adquisición de datos desarrollado
anteriormente y un puerto serial COM2.
Una vez verificada la
conectividad, se procedió a la comunicación entre Simulino y Labview.
 |
 |
Figura 12. Envío y recepción de datos virtuales a través
de Ethernet.
Como se puede apreciar,
la lectura de datos por parte de Labview fue exitosa, lo que permitió enviar
información simulada e interpretada a distancia.
6 CONCLUSIÓN
Con este trabajo se
logró conectar dos aplicaciones (Proteus y Labview), instaladas cada una en computadoras
diferentes, una encargada de la captura de la información y la otra responsable
del procesamiento los datos generados a distancia, sin embargo, la experiencia
también posibilita que dos circuitos simulados de un mismo programa puedan
transferir datos el uno con el otro a través de una conexión remota, en este
caso Ethernet.
El trabajar con sistemas
CAD electrónicos, demanda recursos hardware que, de acuerdo a la complejidad
del circuito, estos serán simulados con mayor o menor velocidad, lo que en
casos particulares se torna en un problema, ya que las capacidades de la
computadora se ven sobrepasadas por las necesidades del programa de simulación.
Es precisamente en este escenario donde se podría recurrir al empleo de dos o
más computadoras que atiendan una misma necesidad de simulación, de esta
manera, la demanda del recurso físico, por parte del programa CAD, se
repartiría entre ellas.
ANEXO.
Programa para Arduino. USProteus
#define Pecho 6
#define Ptrig 7
long duracion, distancia;
int lejos, cerca;
void setup() {
Serial.begin (9600); // inicializa el puerto seria a 9600 baudios
pinMode(Pecho, INPUT); // define el pin 6 como entrada (Echo)
pinMode(Ptrig, OUTPUT); // define el pin 7 como salida (Triger)
Serial.flush();
}
void loop(){
Serial.flush();
distancia = leedistancia(); // Lee la distancia
if (distancia >= cerca && distancia <= lejos){
do{
Serial.print(distancia); // envía el valor de la distancia por el puerto serial
Serial.println("cm");
distancia = leedistancia(); // Lee la distancia
} while(distancia >= cerca && distancia <= lejos);
}
delay(1000); // La información se actualiza cada 1 seg.
}
// Función para la lectura de la distancia
long leedistancia(){
delayMicroseconds(2); // Inicia el sensor
digitalWrite(Ptrig, HIGH); // genera el pulso de triger por 10ms
delayMicroseconds(10); // Espera 10 microsegundos
digitalWrite(Ptrig, LOW);
duracion = pulseIn(Pecho, HIGH);
distancia = (duracion/58); // calcula la distancia en centimetros
return distancia;
}
ANEXO.
Programa para Arduino. USProteus
#define Pecho 6
#define Ptrig 7
long duracion, distancia;
int lejos, cerca;
void setup() {
Serial.begin (9600); // inicializa el puerto seria a 9600 baudios
pinMode(Pecho, INPUT); // define el pin 6 como entrada (Echo)
pinMode(Ptrig, OUTPUT); // define el pin 7 como salida (Triger)
Serial.flush();
}
void loop(){
Serial.flush();
distancia = leedistancia(); // Lee la distancia
if (distancia >= cerca && distancia <= lejos){
do{
Serial.print(distancia); // envía el valor de la distancia por el puerto serial
Serial.println("cm");
distancia = leedistancia(); // Lee la distancia
} while(distancia >= cerca && distancia <= lejos);
}
delay(1000); // La información se actualiza cada 1 seg.
}
// Función para la lectura de la distancia
long leedistancia(){
delayMicroseconds(2); // Inicia el sensor
digitalWrite(Ptrig, HIGH); // genera el pulso de triger por 10ms
delayMicroseconds(10); // Espera 10 microsegundos
digitalWrite(Ptrig, LOW);
duracion = pulseIn(Pecho, HIGH);
distancia = (duracion/58); // calcula la distancia en centimetros
return distancia;
}
