Labview & pic

Realizado por: George.manson.69
http://ucursos.webs.com

LEER PARA APRENDER / Por: Jorge Rdz, Editor
Pasó casi un año desde que ya no había realizado ninguna práctica utilizando
Microcontroladores PIC16, del cual me ha fascinado bastante ya que un día me
pregunte, Es necesario aprender Microcontroladores? Donde lo puedo aplicar? Estas
dos cuestiones me las hacía muy seguido, entonces un día, en mi trabajo encontré en
una maquina avanzada que había tenido una falla, ya que mi trabajo se trata de reparar
fallas en equipos, pues tuve que ir a ver que era esa tal falla, pues no era más que una
tarjeta de control que se había quemado unos diodos, no fue muy difícil saber que era
la falla, y después como tenía tiempo necesario para hacer otras cosas me la pase
revisando que mas tenia o de que estaba compuesto la tarjeta y vi que había un
Microcontrolador y una calcomanía tapando de qué tipo de Micro usaba, no espere
mucho tiempo para saber cual era, y valla sorpresa era un MicroPIC 16C57 cuando lo
vi me recordó todas las practicas que había hecho con anterioridad, desde ese
momento supe que las horas perdidas pasándola programando y realizado proyectos
con esos PIC ahora sé a dónde van los conocimientos adquiridos de tantas horas
programando Microcontroladores PIC y sé que vale la pena seguir programando!.

Introducción
Este Manual concerniente a las prácticas sobre la utilización de comunicación serial
utilizando como hardware el Microcontrolador PIC16F886 y Labview para la interface
Hombre-Máquina fueron realizados para abrirnos paso a realizar nuevas maneras de
programar en Labview, y usando el compilador MPLAB X IDE para la programación en
C para Microcontroladores PIC16.
A lo largo de este manual usted entenderá como hacer correctamente un enlace Serial
hacia Labview y PIC16.

1. MPLAB X
Recientemente Microchip ha lanzado un proyecto para mejorar el aspecto de su IDE en
este caso de MPLAB. En su reciente actualización 8.80 ha mejorado en sus aspectos
con unos pocos detalles del cual no son muy impactantes como son la competencia
casi directa con AVR son su AVRStudio 5, del cual es casi como programar en C#. Era
tiempo de que Microchip se pusiera las pilas y que lanzara su nuevo IDE basado en
JAVA, hablamos de MPLAB X.

1.1 PROTEUS
Una de las maneras de realizar un proyecto siempre es simularlo antes de empezar
hacerlo físicamente ya que nos ahorra tiempo en construcción y sacar fallas antes de
proceder, para nuestro caso usaremos una herramienta sumamente importante para la
simulaciones de circuitos lógicos y programables entre varios más, estamos hablando
de PROTEUS, simulador muy conocido entre toda la comunidad de electrónica y de
control.

1.2 LABVIEW
Para la interfaz del usuario usaremos el software Labview 2010 donde aprenderemos a
desarrollar comunicación seriales a su máxima capacidad, entre otras herramientas
necesarias para desarrollar sistemas muy estables para las comunicaciones.

1.3 INICIANDO EN MPLAB X
En esta parte nos enfocaremos en la programación en C usando el compilador HI
TECH FOR PIC16 del cual nos proporcionara la habilidad para programar los PIC de
una manera muy sencilla ahorrando memoria al máximo.
1.3.1 Entorno de MPLAB X
En nuestra primera impresión de usar MPLAB X es como si fuera una sombra de JAVA,
pero es muy distinto ya que es para Microcontroladores PIC.
1. Exploramos librerías del proyecto tanto los archivos principales.
2. Observamos el contenido de los archivos tanto las librerías y el programa principal.
3. Aquí podemos ver la información concerniente al Microcontrolador.
4. Salida donde podemos observar errores al compilarse el archivo también podemos
debuggear el programa.
1
2
3
4

1.3.2 Crear Nuevo proyecto
Para crear nuestro primer proyecto debemos de dar click en donde dice <Create New
Project> o podemos ir a <File><Creare New Project>
Como haremos nuestro proyecto desde cero daremos click en <Standalone Project>
daremos <Next> y elegiremos el Microcontrolador a usar en este caso para todos los
proyectos usaremos el PIC16F886.

Si tenemos un debugeador en nuestras manos podemos seleccionar uno de ellos como
puede ser el PICKit 2, 3 etc. Como vamos a usar un emulador simplemente
seleccionamos:
En la siguiente ventana encontraremos que compilador vamos a usar, normalmente por
default encontremos los disponibles en nuestra computadora.

Usaremos el compilador Hi tech Compiler for PIC16 , después buscaremos un lugar
para guardar nuestro proyecto y aceptamos.
Como en MPLAB 8.8 al tener el proyecto listo debemos de hacer una extensión “.c”
para ellos vamos a <New File> y en ventana de categorías buscaremos en <Micochip
embedded> y elegimos la carpeta donde está el compilador hi tech y en <File Type>en
la primera opción es que estamos buscando para el compilador hi tech for PIC16. En la
siguiente ventana nos pedirá el Nombre del archivo y la extensión después la ubicación
del archivo del cual debe ser la misma donde creamos el proyecto.
Al agregar el archivo con la extensión “.c” aparecerá en el explorador en <Important
Files> del cual solo debemos de pasarlo nuevamente a la carpeta <Source File> para
que este bien ubicado a la hora de compilar.

1.4 Crear enlaces
Como hemos realizado nuestro primer proyecto en MPLAB X no tiene mucha ciencia la
programación en C, ya que si hemos programado en Hi tech compiler es prácticamente
igual.
La idea de nuestro primer programa en C es hacer una comunicación serial que prenda
un puerto completo del cual podemos usar interrupciones por Recepción de datos o
simple recepción de datos.
1.4.1 Enlace PIC
En la segunda opción podemos hacer un programa que nos quede de la siguiente
manera:
/*
* File: Main.c
* Author: george
*
* Created on November 13, 2011, 6:34 PM
*/
#include "pic.h"
__CONFIG(FOSC_HS & WDTE_OFF & PWRTE_ON & MCLRE_ON & CP_OFF & CPD_OFF & BOREN_OFF
& IESO_OFF & FCMEN_OFF & LVP_OFF & DEBUG_OFF & BOR4V_BOR40V & WRT_OFF);
/*
* FOSC_HS 20Mhz External Crystal
* WDTE_OFF Watch dog disable
* PWERTE_ON Power System Enable
* MCLRE_ON Master Clear Enable
*/
#define _XTAL_FREQ 20000000 //
#include "libUSART/usartdr.h"//Libreria para usar el serial
/*
* VARIABLES GLOBALES DEL PROGRAMA
*/
unsigned char data;
//ISR Interrupt
static void interrupt
isr(void){}
//Programa Principal
void main(void) {
TRISC=0x80;//RX COMO ENTRADA Y TX COMO SALIDA
TRISB=0X00;//PUERTO COMPLETO COMO SALIDA
/*
* CONFIGURAMOS SERIAL
* VALUE=(FOSC/(BAUD*16))-1
* SIN INTERRUPCIONES
* A 19200
*/

OpenUSART(64,OFF,ON);//64=19200
GIE=0; //DESACTIVA INTERRUPCIONES GLOBALES
PEIE=0; //DESACTIVA INTERRUPCIONES POR PERIFERICOS
PORTB=0X00; //INICIALIZA PUERTO B COMO APAGADO
while(1){ //CICLO PERPETUO
data=getch(); //ESPERA A RECIBIR 1 BYTE DEL SERIAL
PORTB=data; //PROYECTA EL BYTE EN EL PUERTO B
}
}
1.4.1 Crear enlace en Labview
Lo que primero se debe de realizar en Labview es crear un <New VI> después al
abrirse las dos ventas de Block diagram y Front Panel , nos pasaremos a la ventana de
Block Diagram del cual buscaremos la opción de SERIAL, que está ubicado en
<Functions> <Instrument I/O> <Serial> y seleccionamos la opción de VISA Configure
Serial Port que nos servirá para configurar los baudios, bits de paridad entre varias
opciones más.
Al agregar el control de configuración de puerto
agregaremos dos controles que harán la función
de buscar el puerto que es VISA resource name
que cada vez que exista un puerto disponible, este
lo visualizara. En baud rate por defecto esta a
9600 que podemos cambiar fácilmente escribiendo
sobre la velocidad de transmisión.
Después de configurar correctamente el puerto,
ahora podemos hacer un ciclo perpetuo hasta que
salgamos con un stop.
Para ello buscaremos la opción de While Loop ,
después buscaremos la opción de escribir en el puerto, que consta de solo enviar una
cadena de caracteres pero en este caso solo enviaremos un byte, pero para enviar
este dato debe de transformarse de un arreglo booleano a numero y de este a un
arreglo de caracteres.
En la siguiente imagen tenemos la programación completa como debe de quedar
nuestro proyecto en Labview, recuerde siempre cerrar el puerto al terminar la conexión
para que este pueda cerrarse correctamente y que pueda seguir funcionando bien el
puerto seleccionado.

Si nos pasamos al lado de Front Panel nos quedara de la siguiente manera:
Recuerde que usaremos una velocidad de transmisión de 19200 baud por defecto
siempre aparecerá en 9200 baud.
Se debe de conectar primero el hardware que en este caso es el PIC16 ya que estará
esperando el dato de un byte, al este estar conectado daremos play en Labview para
correr el programa y rápidamente este enviara el primer dato, y ya podremos enviar los
estados de los switches.
Recuerde siempre usar el MAX 232 para las conversiones de niveles RS232.

1.4.2 Esquema del Proyecto
Hemos usado un regulador de voltaje 7805 para proporcionarle al Microcontrolador
exactamente 5 Volts. En el Puerto B está conectado en cada pin un led con su
respectiva resistencia para poder visualizar el interruptor presionado en Labview.
Aunque el esquema es demasiado sencillo, hemos empezado con algo así, para
calentar motores, ay que su usted se ha dado cuenta en la programación hemos usado
una buena lógica para algo tan simple, entonces a lo largo de este curso usted
aprenderá a realizar cosas muy complejas con Labview y los Microcontroladores en
general, ay que este misma función que hemos creado en Labview se puede usar para
distintos Microcontroladores existentes en el mercado.

Siempre recuerde usar el circuito MAX232 para las conversiones del protocolo RS232,
ya que este protocolo aunque no sea mucha corriente a usar convierte de 5 volts a 12
volts aproximadamente.
1.5 Recibir datos del Pic Hacia Labview
Al recibir datos del Microcontrolador hacia Labview es un procedimiento demasiado
parecido a la práctica anterior, del cual el pic debe de capturar los datos y después
enviarlos. Para ello se debe de configurar correctamente el periférico de serial del pic a
una velocidad de 19200 baud, al guardar el dato leído del puerto B se debe llamar la
función que realiza el envío de datos hacia Labview. Al recibir los datos Labview este
debe de leer los datos existentes en ese momento para saber cuántos bytes necesita
leer y después capturar todos los datos que están guardados en su buffer, y
procesarlos hacer acciones.

1.5.1 Configuración de PIC16F886
La diferencia del proyecto anterior es que ahora es hacer que el puerto B sea Entrada
digital, y usar interruptores para que tomar los datos y guárdalos en una variable, del
cual se enviara a Labview, para ello se agrega la librería USART como se realizo en la
práctica anterior, al tomar solo los 4 bits de menor peso del puerto B este solo se envía
para después esperar 100mS que servirán para sincronización.
/*
* File: Main.c
* Author: george
*
*/
#include "pic.h"
/*
*/
#include "libUSART/usartdr.h"//Libreria para usar el serial
/*
* VARIBALES GLOBALES
*/
unsigned char dato;
//Funcion de Tiempo
void dly(unsigned int t){
while(--t)__delay_ms(1);
}
//ISR Interrupt
isr(void){}
//Programa Principal
void main(void) {
TRISC=0x80;//RX COMO ENTRADA Y TX COMO SALIDA
TRISB=0X0F;//NIBBLE BAJO COMO ENTRADA RESTO SALIDA
ADCON0=0x00;//DESACTIVA ENTRADAS ANALOGAS
ANSELH=0x00;//ENTRADAS ANALOGAS EN PUERTO B APAGADO
/*
* A 19200
*/
OpenUSART(64,OFF,OFF);//64=19200
GIE=0; //DESACTIVA INTERRUPCIONES GLOBALES

PEIE=0; //DESACTIVA INTERRUPCIONES POR PERIFERICOS
while(1){
dato=PORTB&0x0F; //TOMA SOLO NIBBLE BAJO
putch(dato); //CARGA DATO EN EL SERIAL PARA ENVIARLO
dly(100); //ESPERA 100mS
}
}
1.5.3 Configuración de enlace en Labview
Como hemos realizado en el proyecto anterior se debe de crear un Nuevo IV, después
en la ventana Font Panel agregaremos unos cuantos arreglos para que nos quede de
la siguiente forma, note que esto puede ser a su gusto ya que lo más importante esta
en Block Diagram :
Visa resource name es donde podemos agregar el COM disponible del cual se puede
obtener al agregar las configuración del puerto.
Set up 19200 esto nos proporciona la velocidad a que
debe de trabajar la comunicación en Labview, como al
agregarlo por default aparecerá con una velocidad de
9 600 baud solo se debe de escribir la velocidad
deseada que en este caso es de 19200 baud como se
ha configurado el Microcontrolador.
Mientras por ultimo podemos observar un arreglo
boleando compuesto por solo 4 bits, que nos
proporcionara la visualización de 4 interruptores que
estarán conectado al nibble de menor peso del puerto
B del Microcontrolador.
Ahora entrando a lo más complicado que es la programación de este mismo, se debe
siempre de configurar primero que nada el serial, esto se hace buscando el IV <VISA
Configure Serial Port> del cual solo debemos de sacar dos parámetros que son el COM
y los BAUD.

Como ya hemos agregado la configuración del puerto, ahora se debe de crear un
evento, esto quiere decir que configuraremos un evento del cual al recibir un carácter o
un byte este rápidamente entrara, para ellos se debe de agregar el siguiente VI <Visa
Enable Event> nos pedirá un parámetro en particular que es la configuración del evento
o la selección del evento, tendremos varios de estos pero el más importante será al
recibir un carácter <Serial Character> después se debe de estar seguro de que este
correctamente sin evento en ese momento del cual se agrega <Visa Discard Event> y
nos quedar de la siguiente manera:
Ahora como puede o no fallar la conexión en un momento inesperado, se debe de
checar siempre el estado de este, se agrega la función <unbundle by name>
Para obtener los status de errores, solo debemos de seleccionar el ‘status’ para luego
usar el bit que nos arroja que es un ‘F’ cuando no hay errores de conexión o un ‘T’
cuando existen algún tipo de falla.
Para cuando la opción en Verdadera (T) solo se agrega un <case structure> que hara
la función de un if-else como en la programación en C.
En la ventana de Verdadero solo se directo las señales fuera del ciclo while-loop, como
se va en imagen siguiente:

Como vemos al salir del case structure se usa la misma señal de status para salir del
ciclo while-loop.
En la opción de False entra a esperar evento del cual hemos seleccionado Serial
Character la espera de timeout será de 10,000 mS del cual si en este tempo no se
recibe ninguna señal de recepción de al menos un byte este rápidamente enviara una
señal de error y se saldrá del ciclo o marcara error.
Al recibir una señal este rápidamente pasa al cuantos byte se recibieron del cual es
property node en la forma de <Bytes at port> (bytes en el puerto) este leerá todos los
bytes recibidos para después usarlos para usar el IV para leer los datos, y arrojarlos
como una cadena de caracteres (string)
Como hemos visto al recibir los datos en forma de cadenas de caracteres del cual solo
es un byte, solo se debe de transformar en un arreglo de bytes y después buscar en el
arreglo de bytes el primer byte para después transformar de número a un arreglo
binario que este ya visualizara el estado de los interruptores. Y después solo
cerraremos el puerto pero antes se debe de borrar cualquier evento antes abierto.

1.5.3 Esquema del Diagrama Electrónico
2. Graficando señales análogas con DAC
Las mayorías de las veces necesitamos adquirir datos continuos, por ejemplo de
temperatura, Luz, y entre varios sensores que varíen con respecto a circunstancias
físicas. Después de tomar este dato análogo, se envía a una PC para procesar con
respecto a un algoritmo incluido en un tipo de software donde hace el proceso de
arrojar en la salida un dato digital o variable.
En esta práctica vas a proponer graficar datos continuos esto quiere decir que cada vez
que el Microcontrolador en s entrada análoga consiga leer el estado del sensor
rápidamente lo envié para apreciarlo en una grafica realizada en Labview con respecto
al tiempo.
1.2.1 Realización del Hardware y Software para el Microcontrolador
El primer paso es configurar puertos y entradas digitales o análogas, de esto solo se
debe de incluir la librería para el uso del convertidor análogo a digital, y después usar
solo una entrada análoga en este caso el AN0, estos datos se enviaran casi

instantáneo ya que usaremos nada mas un retardo de 1mS del cual nos servirá
también para adquirir correctamente la conversión de la variable análoga, y al tener
cargado esta variable se enviara por serial para que laview procese este dato y lo pase
a graficar.
Todo lo anterior se resume al programa siguiente:
/*
* File: main.c
* Author: george
*
*/
#include "pic.h"
/*
*/
#include "libADC/adcdr.h"
#include "libUSART/usartdr.h"
/*
* VARIABLES GLOBALES DEL PROGRAMA
*/
unsigned int value_adc;
unsigned char data[2];
/*
* SE OBTIENE EL DATO ANALOGO
* EN ESTE CASO AL LEER EL EL DATO SERA DE 1024 BITS
* DEL CUAL ES 2 BYTES
*/
unsigned int take_data_analog(){
__delay_ms(1);
startADC();
while(GO_DONE!=0);
return readADC();
}
/*
* SE DESPEJA EL DATO ANALOGO Y SEPARA LOS 2 BYTES
* PARQ QUE SE GUARDEN EN UN ARREGLO POR SEPARADO
* PARA PREPARARLO PARA EL ENVIO
*/
void convert_two_byte(unsigned int analog){

data[0]=(analog>>8)&0x03; //TOMA BYTE DE MAYOR PESO
data[1]=analog&0xFF; //TOMA BYTE DE MENOR PESO
}
/*
* ENVIA LOS DOS BYTES POR EL PUESRTO SERIAL
* ENVIA PRIMERO EL BYTE DE MAYOR PESO Y DEPSUES EL DE MENOR PESO
*/
void send_data_rs232(void){
putch(data[0]);
putch(data[1]);
}
//ISR Interrupt
isr(void){}
/*
* FUNCION PRINCIPAL
*/
void main(void){
TRISA=0X01; //RA0 COMO ENTRADA ANALOGA
TRISC=0X80; //SE CONFIGURAMOS TX Y RX
/*
* A 19200
*/
/*
* CONFIGURAMOS ADC
* PUERTOB DESACTIVADO PARA ENTRADAS ANALOGAS
* SOLO SE ACTIVA EL RA0 COMO ENTRADA ANALOGA
*/
OpenADC(FOSC_32,AN0,OFF);
GIE=0;//INTERRUPCIONES GLOBALES ACTIVADAS
PEIE=0;//ACTIVA INTERURPCIONES POR PERIFERICOS
/*
* EMPIEZA EL PROGRAMA PRINCIPAL
*/
while(1){
value_adc=take_data_analog();//TOMA DATO ANALOGO
convert_two_byte(value_adc); //CONVIERTE A DOS BYTES
send_data_rs232(); //ENVIA DATOS
}
}
1.2.2 Graficado en Labview
Como hemos estado viendo en los proyectos anteriores siempre se debe de configurar
el puerto y los baudios que es lo más básico para empezar, ya si el usuario quiere
cambiar más opciones lo puede hacer. Por ahora como vamos a recibir datos debemos
de crear un evento, que es esperar por 10s un carácter del rs232, al recibir estos datos

rápidamente debe leerlos y mandarlos a procesar que no es más que juntar los dos
bytes y enviarlo a graficar.
Siempre una buena presentación del programa puede ayudar mucho a la hora de
comercializar un software, por eso nunca deje la presentación su proyecto a un lado.

3. Control de Intensidad de lámpara
Esta práctica conlleva a la manipulación de una lámpara de 12
poder controlar corriente alterna se debe de usar un TRIAC de potencia como se
muestra en parte de una hoja de datos de un TRIAC.
Como sabemos un triac es un switch de par de tir
dispositivo puede abrir
corriente
puede ser en control de intensidad de una lámpara, o control de velocidad de un motor.
dispositivo puede abrir
corriente en la puerta. Es usado en aplicaciones donde involucre corriente alterna como
dispositivo puede abrir en cualquier dirección la corriente aplicando una pequeña
en la puerta. Es usado en aplicaciones donde involucre corriente alterna como
en cualquier dirección la corriente aplicando una pequeña
Como sabemos un triac es un switch de par de tiristores invertidos en paralelo,
Esta práctica conlleva a la manipulación de una lámpara de 127VCA
istores invertidos en paralelo,
7VCA del cual para
istores invertidos en paralelo,
fig 3.0
del cual para
istores invertidos en paralelo,este
fig 3.0

Un triac es un interruptor de estado sólido, una pequeña corriente en la terminal de la
puerta puede conducir una gran corriente, pensando que un triac como dos SCR
puesto en paralelo invertido cada uno de ellos, donde el cátodo de uno de los SCR está
conectado hacia el ánodo del otro y viceversa. La puertas están conectadas juntas,
porque tenemos dos tipos configuración de SCR’s esto permite activar amos a medios
ciclos.
En el ejemplo anterior el interruptor realice la función de cortar la corriente cuando sea
necesario, la idea es usar una pequeña corriente para controlar dispositivos de alto
voltaje como son motores y calentadores. Lo peligroso de aquí es el alto voltaje que
esta prendido en sí mismo. Esto puede ser un gran problema para los controles de
estado lógico al menos que usen un pequeño relay como lo hacen los microondas.

Para controlar con un Microcontrolador sin dañarlo por una sobre carga en la etapa de
potencia, se debe de usar un opto acoplador del cual se encarga de separar la etapa
de control que en este caso puede ser un microprocesador con la de potencia.
En la figura se puede observar un simple ejemplo de un control de una carga resistiva
esto puede ser una resistencia para generar calor, o una lámpara entre varios, mientras
en la Figura 8, es para cargas inductivas como puede ser motores con cruce por cero,
este último se refiere a que no hará caso a la onda negativa que genera la onda
sinodal.
Y cuando se desee usar las dos partes de la onda se recomiendo un opto con cruce
por cero.

3.1 Control de Lámpara
Para empezar a entender el funcionamiento de encender lámparas con TRIAC y PIC,
necesitamos hacer una pequeña practica para calentar motores, primero que nada la
idea es encender una lámpara con Labview, del cual solo es ponerlo en encendido y
apagado.
3.1.1 Software para PIC
El programa consta de solo recibir un dato de Labview y reaccionar con forme a ello, el
dato será solo de un 1 byte y que solo responda con un comando cuando hay que
encenderlo o apagarlo, para ello se usara la interrupción por recepción de datos.
/*
* File: MAIN.c
* Author: george
*
*/
#include "pic.h"
/*
*/
//definiciones de variables globales
unsigned char DATA;
//definiciones de trabajo
#define LAMPARA_ON RB7=1
#define LAMPARA_OFF RB7=0
//ISR Interrupt
isr(void){
if(RCIF){ //HEMOS RECIBIDO UN DATO?
RCIF=0; //RESET A FLAG DE INTERRUPCION DE DATO
DATA=getch();//TOMAMOS DATO
if(DATA==0xFF){//ES PARA ENCENDER?
LAMPARA_ON;
}
if(DATA==0x77){//ES PARA APAGAR
LAMPARA_OFF;
}
}
}

/*
* FUNCION PRINCIPAL
*/
void main(void) {
TRISB=0; //PUERTO B COMO SALIDA
TRISC=0X80; //SE CONFIGURAMOS TX Y RX
PORTB=0;
/*
* A 19200
*/
GIE=1;//ACTIVAMOS INTERRUPCIONES GENERALES
PEIE=1;//ACTIVAMOS INTERRUPCIONES POR PERIFERICOS
while(1);
}
3.1.2 Software para Labview
La estrategia a seguir que al usar un interruptor virtual que solo mande verdadero o
falso, con este dato booleano entrara a un case structure del cual este elegirá que dato
debe de enviar, en este caso como hemos programado en el Microcontrolador que al
recibir el dato 0xFF mande a prender la lámpara sino el dato 0x77 para apagar la
lámpara.
En Labview la programación es muy sencilla como podemos verla en el block diagram:

Simple no? Solo enviamos el dato 255 que corresponde en hexadecimal 0xFF, y el
dato 119 que corresponde a 0x77, después es subministrada para convertirse a arreglo
y después convertir de arreglo a string.
En la parte de front panel podemos hacer unos cuantos arreglos para que nuestro
programa quede bien hecho.
3.1.3 Diagramas
El diagrama que a continuación se da es solo la etapa de potencia del cual consta de
un moc3011 que es un optoacoplador a salida a triac esto quiere decir que podemos
usarlo para conectarlo directamente a gate del TRIAC que estará conectado a la carga.
En el Microcontrolador es igual del cual hemos estado trabajando conectado al
max232, nada mas que en el pin RB7 vamos a conectar el led del optoacoplador para
encender la lámpara cuando mandemos el dato de Labview al Micro.

3.1.4 Fotos del Proyecto
3.1.5 Tomando Señal
Ahora antes de desarrollar la practica deseada, debemos de entender cómo debemos
de tomar la referencia de la onda senoidal , esto quiere decir que al tomar la onda
positiva debemos de obtener la señal convertida a un nivel legible por el
Microcontrolador esto quiere decir que debemos de rectificar la entrada usando un
diodo antes de rectificador de onda completa, para después activar un transistor que
está alimentado con tan solo 5 volt esto hará una onda cuadra a nivel TTL, para
después entre el Microcontrolador para saber cuando está en la onda positiva y cuando
está en la onda negativa, o en pocas palabras cuando cruza por cero.

Representación de la Idea:
Al realizar el siguiente circuito en la salida del transistor debemos de tener una onda
cuadra de 0 a 5v, del cual este entrara al Microcontrolador para decir cuando esta el
ciclo positivo y cuando está en el ciclo negativo.
La señal generada antes y después del diodo es el siguiente:
Escala 2 volts.
Salida después del transistor
Entrada a la base del transistor
Con esta señal cuadrada que
genera es de 0 a 5 v, del cual ya podemos
trabajar con ella. Es muy fácil ahora que
tenemos esta señal TTL, ya que podemos
usarla como una entrada para el
Microcontrolador, en este caso para el
pic16f886, tiene un PIC muy especial del
cual es la entrada para usar el Timer0
como contador de pulsos externos.
Entrada para el
PIC

En la programación del Microcontrolador se debe de hacer un ciclo perpetuo del
cual este integrado por un tiempo de retraso de envio que es de 1 segundo. Después
de este lapso de tiempo será tomado el valor actual del contador (Timer0) para enviarlo
a Labview.
El software es el siguiente:
/*
* File: main.c
* Author: george
*
*/
#include "pic.h"
__CONFIG(FOSC_HS& WDTE_OFF & PWRTE_ON & MCLRE_ON & CP_OFF & CPD_OFF & BOREN_OFF
/*
*/
/*
* VARIABLES GLOBALES DE TRABAJO
*/
unsigned char senal;
/*
* FUNCION DE TIEMPO
*/
void dly(unsigned int t){
while(--t)__delay_ms(1);
}
/////////////////////////////////////////////////
//Funcion de interrupcion
//Si no se usa simplemente no hacemos nada...
//Esto sirve para direccionar lo los datos
//en un lugar muy cercano al Inicio de la memoria
//de datos
////////////////////////////////////////////////
isr(void){}
/*
* PROGRAMA PRINCIPAL
*/
void main(void) {
/*
* Inicliazamos Puertos
*/

ANSELH=0X00;//Analogo desactivado
TRISA=0x10; //RA4 como entrada resto salida
TRISC=0x80;//
ADCON0=0x00;//
/*
* Inicializamos TIMER0
* Entrada de senal extarna,Prescalar 1:2
*/
OPTION_REG=0b10100000;
/*
* A 19200
*/
TMR0;
GIE=0;
PEIE=0;
while(1){
TMR0=0; //Reseteamos Contador
dly(1000); //Esperamos 1 Segundo
senal=TMR0;//Leemos El contador
putch(senal);//Enviamos dato
}
}
El programa en Labview es demasiado sencillo, del cual solo debe de recibir un dato (1
byte) este dato debemos de convertirlo a string, ya que hemos referenciado que el dato
recibido es un dato de Hz, del cual se debe juntar dos string por esta razón se usa la
función, “concaténate” para unir el ‘dato’ + “Hz”

En front Panel podemos ver cómo queda
nuestro programa, lo que debemos hacer
primer es Iniciar Labview y después
conectar rápidamente el hardware que es
el Microcontrolador.
Este marcara la frecuencia que tiene la
conexión VCA.
El diagrama a Manejar es el siguiente:
P. 1
P.2

Algunas fotos del Proyecto:
P.3

3.1.6 Manipulando la Intensidad de lámpara
Como hemos realizado en las dos prácticas anteriores, al controlar el encendido de la
lámpara y tomando la señal, al combinar las dos podemos crear un controlador de
intensidad de una lámpara, esto va a controlar la onda senoidal de voltaje de entrada
que son 127 VCA.
Para controlar la onda senoidal se debe de rectorar ambas ondas positiva y negativa
para hacer eso se debe de generar un PWM de la misma frecuencia pero cuadrada, del
cual esta señal PWM debe de recortar la onda exactamente cuándo cruce por cero.
He recortado la onda de inicio tanto para la positiva y negativa porque ya que la onda
está decayendo el resultado es menor potencia del cual se reflejara en intensidad, y
podemos ver mucho mejor el descenso de la iluminación de la lámpara. Ya que si fuera
al contrario no veremos mucho el cambio que realiza de intensidad ya que como la
onda empieza a subir tiene mayor potencia y aunque variemos el PWM al principio de
la onda este no reflejara mucho el cambio de intensidad de la lámpara.
Como hemos realizado en la segunda práctica de este proyecto al obtener los ciclos o
los hertz de la corriente alterna, al usar ese método podemos sincronizar la frecuencia
PWM con la onda senoidal, ya que al cruzar por cero podemos apagar el optoacoplador
exactamente e iniciar el pulso PWM donde deseamos y cuando vuelva a cruzar por
cero apagamos y esperamos a iniciar el pulso para que de la lámpara encienda, y
obtendremos un ancho de pulso proporcional a la frecuencia de VCA.

El firmware del Microcontrolador es muy sencillo usando l interrupción por recepción de
datos (Rs232) y la interrupción por desbordamiento por timer0, podemos hacer esta
práctica:
/*
* File: main.c
* Author: george
*
* Created on December 3, 2011, 1:45 PM
*/
#include "pic.h"
__CONFIG(FOSC_HS& WDTE_OFF & PWRTE_ON & MCLRE_ON & CP_OFF & CPD_OFF & BOREN_OFF
/*
*/
#include "libTIMER0/OpenTIMER0.h"
/*
* DEFINICIONES GLOBALES
*/
#define PIN_INTENSIDAD RC0
/*
* VARIABLES GLOBALES
*/
unsigned char BUFFER=127;
/////////////////////////////////////////////////
//Funcion de interrupcion
//Si no se usa simplemente no hacemos nada...
//Esto sirve para direccionar lo los datos
//en un lugar muy cercano al Inicio de la memoria
//de datos
////////////////////////////////////////////////
isr(void){
if(T0IF){
T0IF=0;
PIN_INTENSIDAD=1;
T0IE=0;
}else if(RCIF){
RCIF=0;
BUFFER=getch();
}
}
/*
* PROGRAMA PRINCIPAL
*/

void main(void) {
/*
* CONFIGURAMOS PUERTOS
*/
TRISA=0X10; //RA4 COMO ENTRADA RESTO SALIDA
TRISC=0X80; //RC7 COMO ENTRADA Y RC6 COMO SALIDA
ANSELH=0X00; //PORTB DIGITAL
ADCON0=0X00; //APAGAMOS CONVERTIDOR ANALOGO
CM1CON0=0x00;
CM2CON0=0x00;
/*
* Configuramos Timer 0
* FORMULA:
* TMR0=256-{TIEMPO_DESEADO/[(1/(_XTAL_FREQ/4)*PRESCLAR]}
* Tiempo Requerido T=0.004 s
* Valor del timer 0 a cargar = 50
*/
OpenTIMER0(prescalar_256,OFF);
/*
* A 19200
*/
GIE=1; //TODAS LAS INTERRUPCIONES APAGADAS
PEIE=1; //TODAS LAS INTERRUPCIONES POR PERIFERICOS APAGADAS
while(1){
if(RA4==1){
TMR0=BUFFER;
T0IE=1;
PIN_INTENSIDAD=0;
while(RA4==1);
TMR0=BUFFER;
T0IE=1;
PIN_INTENSIDAD=0;
while(RA4==0);
}
}
}
El software en Labview muestra una sencillez ya que solo enviaremos un dato al
Microcontrolador y este al recibirlo solo cargara la variable BUFFER con el dato
enviado desde Labview que es el dato que corresponde a la intensidad de la lámpara.
Hemos configurado el timer0 con un prescalar de 256 y a una frecuencia de trabajo de
20Mhz esto ayuda a que genere exactamente 8mS de desbordamiento como máximo.
Al enviar un dato de 0 a 255 este valor al ser cargado a la variable BUFFER carga
automáticamente al registro TMR0 del timer0 del cual indica cuando hay que
interrumpir para prender el led del optoacoplador, esto realizándose a 60Hz del cual el
PWM será del mismo valor de la frecuencia de VCA.

Diagrama:
RETOS:
Esta sección usted deberá de realizar las siguientes practicas que involucren un enlace
con Labview, estará a prueba para conocer si usted allá entendido correctamente las
practicas anteriores:
1.- Visualice y un dato análogo que usted desee, como puede ser un sensor de
temperatura, sensor de proximidad o lo que usted desee, solo que al leer un dato que
este fuera del rango señale cuando este en bajo nivel o alto.
Minvalor< DATO < Maxvalor
2.- Manipule dos lámpara de 127 VCA del cual pueda ajustar la intensidad de cada uno
de ellos por separado.
Nota: Cuando trabaje con 127 VCA tenga mucho cuidado a la hora de conectar o
tener un corto circuito, ya que habla con una de las corrientes más peligrosas.

Realizado por
George arth
Pagina
http://ucursos.webs.com
http://ucursos.blogspot.com
“Aprende para que después compartas conocimientos”

Labview & pic

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Labview & pic

Similar a Labview & pic (20)

Último

Último (6)

Labview & pic