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.

1.2.3 Diagrama Electrónico

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.

Foto del Proyecto

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”

Devices & Hardware

Labview & pic