GUIA DE INICIACIÓN PRÁCTICA

Instrumentación Avanzada. G. Murcia – J. Strack
GUIA DE EJERCICIOS
Nº 2
INSTRUMENTACIÓN AVANZADA
Comunicando LabVIEW
a un PIC18F2550
1
Instrumentación Avanzada. G. Murcia – J. Strack
2.-COMUNICANDO LABVIEW A UN PIC18F2550
Ejercicio 2.1
Tomando el ejercicio 1.4 realizar los ajustes necesarios para que además de encenderse
un LED en pantalla se encienda un LED físicamente sobre la placa PIC suministrada
por la cátedra.
Recordemos el ejercicio 1.4:
Como vimos en las transparencias de la Clase 2, para resolver el problema debemos:
1. Instalar el driver mchpcdc, para que la placa PIC didáctica suministrada por la cátedra
sea reconocida por la PC como un dispositivo conectado a un puerto COM virtual.
2. Instalar las librerías NI-VISA, para poder realizar luego la comunicación con el
dispositivo conectado al puerto COM virtual. Las herramientas que usaremos están en la
pestaña “Data Comunication” del diagrama de bloques de labVIEW.
3. Generar una programación en LabVIEW y en el PIC para resolver este problema, como
por ejemplo la que se representa en la siguiente figura:
2
Instrumentación Avanzada. G. Murcia – J. Strack
Programa en PC
Programa en PIC
• Que escriba un carácter en el
puerto COM que actué de
“instrucción” para el PIC.
Que lea un carácter en el buffer de
recepción COM virtual
• Seguida a esa instrucción
podríamos enviar al COM
virtual otros cuatro caracteres
que sean “1” o “0” según se
quiera encender o apagar las
salidas RB0 a RB3 del PIC.
¿Es la
“instrucción”?
NO
SI
Que lea los cuatro caracteres “1” o “0”
Que escriba los “1” o “0” en RB0 a RB3
4. El programa en el PIC se puede generar con el software PIC C Compiler. A continuación
se muestra un código que escribe las salidas RB0 a RB3 de un 18F2550 cuando se recibe
el carácter “A” a modo de “instrucción”.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////
////
////
Programa Asignatura Instrumentación - Año 2015 ////
////
////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <18F2550.h>
#include <usb_bootloader.h>
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
#use delay(clock=48000000)
#include <usb_cdc.h>
//Asignacion de variables
#define LEDV PIN_C0
#define LEDR PIN_C1
#define LED_ON output_high
#define LED_OFF output_low
void usb_debug_task(void) // Función que atiende la comunicación USB y gestiona el LED de dos colores
{
static int8 last_enumerated;
int8 new_connected;
int8 new_enumerated;
static int8 last_cdc;
int8 new_cdc;
//new_connected=usb_attached(); no uso sense pin
new_enumerated=usb_enumerated();
new_cdc=usb_cdc_connected();
if ((new_enumerated) && (new_cdc))
{LED_ON(LEDV); LED_OFF(LEDR);}
else
{LED_ON(LEDR); LED_OFF(LEDV);}
last_enumerated=new_enumerated;
last_cdc=new_cdc;
}
//declaramos variables globales
char c, B0, B1, B2, B3; // son variables tipo caracter
3
Instrumentación Avanzada. G. Murcia – J. Strack
void main(void)
{
usb_init_cs();
// Función principal
set_tris_b(0xF0);
//Configuración para el puerto B como digital con 4 entradas/4 salidas
output_bit(PIN_B0,0); // Ponemos salidas a 0
output_bit(PIN_B1,0);
output_bit(PIN_B2,0);
output_bit(PIN_B3,0);
while (TRUE)
{
usb_task();
usb_debug_task();
if (usb_cdc_kbhit())
{
c=usb_cdc_getc();
// Abre un ciclo while infinito
// Vale 1 si hay un caracter en el buffer de recepción
// Leemos el caracter y la grabamos en la variable c
if (c=='A')// si el caracter leído es A entra en rutina de escribir salidas digitales
{
B0=usb_cdc_getc(); // Leemos el caracter
output_bit(PIN_B0,B0); // Escribimos salida
B1=usb_cdc_getc(); // Leemos el caracter
output_bit(PIN_B1,B1); // Escribimos salida
B2=usb_cdc_getc(); // Leemos el caracter
output_bit(PIN_B2,B2); // Escribimos salida
B3=usb_cdc_getc(); // Leemos el caracter
output_bit(PIN_B3,B3); // Escribimos salida
}
}
}
}
// Cierra el ciclo while infinito
// Cierra la función principal
5. Una vez compilado el programa anterior (generación del archivo.hex) cargamos el código
en el PIC con el software SIOW.exe, haciendo uso del BootLoader previamente cargado
en el 18F2550 como vimos en las transparencias de la Clase 2.
4
Instrumentación Avanzada. G. Murcia – J. Strack
6. El programa en la PC haciendo uso de la librería VISA tendrá que:
a) Abrir una comunicación al puerto COM.
b) Enviar el carácter “A” (que actúa como instrucción para entrar en
la rutina de escribir salidas digitales según el código del mostrado
en el punto 4) .
c) Enviar cuatro caracteres que sean “0” o “1” para encender o apagar
los LEDs respectivos.
d) Cerrar la comunicación al puerto COM abierto en a).
Finalmente:
Ejercicio 2.2
Tomando el ejercicio 1.7 realizar los ajustes necesarios para que los pines RB0 a RB3 de la
placa PIC representen los últimos 4 bit en binario de un número decimal ingresado en
pantalla.
Recordemos el ejercicio 1.7:
Ejercicio 2.3
Modifique el código cargado en el PIC para que ahora si la PC le envía el carácter “B”
al microcontrolador este le responda con el estado de los pines RB4 a RB7. Muestre en
un panel frontal el estado de estas cuatro entradas digitales.
1. Como vimos en las transparencias de la Clase 2 para resolver el problema debemos
generar una programación en LabVIEW y en el PIC, como por ejemplo la que se
representa en la siguiente figura:
5
Instrumentación Avanzada. G. Murcia – J. Strack
Programa en PIC
Programa en PC
Lee un carácter en el buffer de
recepción
La PC envía el carácter “B” al
puerto COM virtual
¿Es una “B”?
NO
SI
Lee las entradas RB4 a RB7
Arma un carácter (byte) con el estado
de RB4 a RB7
La PC lee el carácter con los
estados de RB4 a RB7
Envía a la PC el carácter los estados
de RB4 a RB7
2. Podemos modificar el código que ya hemos cargado en el PIC para agregarle esta nueva
función. El nuevo programa podría quedar así:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////
////
////
Programa Asignatura Instrumentación - Año 2015 ////
////
////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <18F2550.h>
#include <usb_bootloader.h>
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
#use delay(clock=48000000)
#include <usb_cdc.h>
//Asignacion de variables
#define LEDV PIN_C0
#define LEDR PIN_C1
#define LED_ON output_high
#define LED_OFF output_low
void usb_debug_task(void) // Función que atiende la comunicación USB y gestiona el LED de dos colores
{
static int8 last_enumerated;
int8 new_connected;
int8 new_enumerated;
static int8 last_cdc;
int8 new_cdc;
//new_connected=usb_attached(); no uso sense pin
new_enumerated=usb_enumerated();
new_cdc=usb_cdc_connected();
if ((new_enumerated) && (new_cdc))
{LED_ON(LEDV); LED_OFF(LEDR);}
else
{LED_ON(LEDR); LED_OFF(LEDV);}
last_enumerated=new_enumerated;
last_cdc=new_cdc;
}
6
Instrumentación Avanzada. G. Murcia – J. Strack
//declaramos variables globales
char c, B0, B1, B2, B3, ENT_DIG;
void main(void)
{
usb_init_cs();
// son variables tipo caracter
Agregamos esta nueva variable
// Función principal
set_tris_b(0xF0);
//Configuración para el puerto B como digital con 4 entradas/4 salidas
output_bit(PIN_B0,0); // Ponemos salidas a 0
output_bit(PIN_B1,0);
output_bit(PIN_B2,0);
output_bit(PIN_B3,0);
while (TRUE)
{
usb_task();
usb_debug_task();
if (usb_cdc_kbhit())
{
c=usb_cdc_getc();
// Abre un ciclo while infinito
// Vale 1 si hay un caracter en el buffer de recepción
// Leemos el caracter y la grabamos en la variable c
if (c=='A')// si el caracter leído es A entra en rutina de escribir salidas digitales
{
B0=usb_cdc_getc(); // Leemos el caracter
output_bit(PIN_B0,B0); // Escribimos salida
B1=usb_cdc_getc(); // Leemos el caracter
output_bit(PIN_B1,B1); // Escribimos salida
B2=usb_cdc_getc(); // Leemos el caracter
Agregamos esta
output_bit(PIN_B2,B2); // Escribimos salida
B3=usb_cdc_getc(); // Leemos el caracter
output_bit(PIN_B3,B3); // Escribimos salida
}
porción de código
if (c=='B')// si el caracter leído es B entra en rutina de leer entradas digitales
{
ENT_DIG=1*input(PIN_B4)+2*input(PIN_B5)+4*input(PIN_B6)+8*input(PIN_B7);
usb_cdc_putc(ENT_DIG);
}
}
}
}
// Cierra el ciclo while infinito
// Cierra la función principal
3. Compilamos y cargamos el nuevo código.
4. Programamos en labVIEW:
7
Instrumentación Avanzada. G. Murcia – J. Strack
Ejercicio 2.4
Modifique nuevamente el código cargado en el PIC para que ahora se pueda ver en la
PC el valor de la entrada analógica AN0, AN1, AN2 o AN3, funcionando el conversor
analógico/digital en 10 bits.
1. Como vimos en las transparencias de la Clase 2 para resolver el problema debemos
generar una programación en LabVIEW y en el PIC, como por ejemplo la que se
representa en la siguiente figura:
Programa en PIC
Programa en PC
Lee un carácter en el buffer de
recepción
La PC envía el carácter “C” al
puerto COM virtual seguido de
otro carácter (un número de
“0” a “3”) que indica que
entrada leer.
¿Es una “C”?
NO
SI
Lee el siguiente carácter (canal)
Selecciona la entrada analógica dada
por canal y lee el conv. A/D
La PC lee el carácter con el
estado del conversor A/D
Envía a la PC el valor del conversor
A/D
2. Podemos modificar nuevamente el código que ya hemos cargado en el PIC para agregarle
esta nueva función. El nuevo programa quedaría:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////
////
////
Programa Asignatura Instrumentación - Año 2015 ////
////
////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <18F2550.h>
Agregamos esta instrucción que
#DEVICE ADC=10
configura el conversor A/D en 10 bit
#include <usb_bootloader.h>
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
#use delay(clock=48000000)
#include <usb_cdc.h>
//Asignacion de variables
#define LEDV PIN_C0
#define LEDR PIN_C1
#define LED_ON output_high
#define LED_OFF output_low
void usb_debug_task(void) // Función que atiende la comunicación USB y gestiona el LED de dos colores
{
static int8 last_enumerated;
int8 new_connected;
int8 new_enumerated;
static int8 last_cdc;
int8 new_cdc;
//new_connected=usb_attached(); no uso sense pin
new_enumerated=usb_enumerated();
new_cdc=usb_cdc_connected();
8
Instrumentación Avanzada. G. Murcia – J. Strack
if ((new_enumerated) && (new_cdc))
{LED_ON(LEDV); LED_OFF(LEDR);}
else
{LED_ON(LEDR); LED_OFF(LEDV);}
last_enumerated=new_enumerated;
last_cdc=new_cdc;
}
//declaramos variables globales
char c, B0, B1, B2, B3, ENT_DIG, CH_A;
int8 envia[2];
int16 dato;
void main(void)
{
usb_init_cs();
// son variables tipo caracter
Agregamos estas nuevas variables
// Función principal
set_tris_b(0xF0);
//Configuración para el puerto B como digital con 4 entradas/4 salidas
output_bit(PIN_B0,0); // Ponemos salidas a 0
output_bit(PIN_B1,0);
output_bit(PIN_B2,0);
output_bit(PIN_B3,0);
setup_adc_ports(AN0_TO_AN3|VSS_VDD); //habilitamos 4 puertos para entrada analógica
setup_adc(ADC_CLOCK_INTERNAL);
//Utilizamos el reloj interno
while (TRUE)
// Abre un ciclo while infinito
Agregamos
{
usb_task();
usb_debug_task();
if (usb_cdc_kbhit())
// Vale 1 si hay un caracter en el buffer de recepción
{
c=usb_cdc_getc();
// Leemos el caracter y la grabamos en la variable c
esta configuración
if (c=='A')// si el caracter leído es A entra en rutina de escribir salidas digitales
{
B0=usb_cdc_getc(); // Leemos el caracter
output_bit(PIN_B0,B0); // Escribimos salida
B1=usb_cdc_getc(); // Leemos el caracter
output_bit(PIN_B1,B1); // Escribimos salida
B2=usb_cdc_getc(); // Leemos el caracter
output_bit(PIN_B2,B2); // Escribimos salida
B3=usb_cdc_getc(); // Leemos el caracter
output_bit(PIN_B3,B3); // Escribimos salida
}
if (c=='B')// si el caracter leído es B entra en rutina de leer entradas digitales
{
ENT_DIG=1*input(PIN_B4)+2*input(PIN_B5)+4*input(PIN_B6)+8*input(PIN_B7);
usb_cdc_putc(ENT_DIG);
}
if (c=='C')// entra en rutina de leer un valor de una entrada analógica
{
CH_A=usb_cdc_getc();
set_adc_channel(CH_A);
delay_ms(1);
dato=read_adc();
// Leemos el dato
Agregamos
delay_us(500);
dato=read_adc();
envia[0]=dato&0x00FF;
envia[1]=(dato&0xFF00)/256;
usb_cdc_putc(envia[0]);
usb_cdc_putc(envia[1]);
}
}
}
}
// Cierra el ciclo while infinito
// Cierra la función principal
9
esta porción de código
Instrumentación Avanzada. G. Murcia – J. Strack
3. Compilamos y cargamos el nuevo código.
4. Programamos en labVIEW:
Ejercicio 2.5
Explore la barra de herramientas “INSTRUMENTACIÓN AVANZADA” ubicada en la
paleta “User Libraries”.
Ejercicio 2.6
Imagine que un sensor de temperatura que entrega 10mV/°C se conecta a una entrada
analógica de la placa PIC.
Simulando este sensor mediante un potenciómetro muestre en pantalla la temperatura
medida en grados Centígrados y en grados Fahrenheit.
10