75347569-Hi-Tech

Curso de Hi-tech Compiler (lite Mode) 2010

2 Para Microcontroladores PIC16 100 % C!!!

Tabla de contenido

Introduccin ........................................................................................................................................... 3 1. Programas a usar en este curso.................................................................................................. 4

1.1 Hoja de proyectos ................................................................................................................. 5 1.2 Entorno de un Programa ...................................................................................................... 8

1.2.1 Tipos de Variables ......................................................................................................... 8 1.2.2 Formato Radix ................................................................................................................ 9

1.2.3 Expresiones .................................................................................................................... 9 1.2.4 Instrucciones ................................................................................................................ 10

1.3 Inicializando nuestro Programa .......................................................................................... 13 Programas Sencillos ............................................................................................................................... 14

1.4 Parpadeo .............................................................................................................................. 14 1.5 Display de 7 segmentos ..................................................................................................... 17 1.6 Usando el USART ............................................................................................................... 21 1.7 Interrupciones por Timers ................................................................................................... 27

1.7.1 Uso del Timer0 y USART ............................................................................................ 30 1.8 Uso del PWM (Pulse Width Module) ................................................................................. 33 1.9 Valores ADC (Convertidor de Anlogo-Digital)................................................................. 36 2.0 Uso del LCD ........................................................................................................................ 43 2.1 Lector de Voltaje ................................................................................................................. 48 2.2 Selector de canal anlogo con Teclado 4x4 ..................................................................... 51 2.3 PWM a salida anlogo ........................................................................................................ 57 2.4 Medidor de voltaje por software ......................................................................................... 61 2.5 Reloj con Displays ............................................................................................................... 65 2.6 Control de Servo ................................................................................................................. 75

2.6.1 Software para control de servo ................................................................................... 83 2.7 Control de velocidad ............................................................................................................ 88

2.7.1 Software para labview ................................................................................................. 91 2.8 Matriz de Led 8x24 (Contador de 000 a 999) ................................................................... 98

Gracias! .......................................................................................................................................... 109



Introduccin

Este curso ofrece a los alumnos o maestros que estn involucrndose en la

programacin de microcontroladores PIC, y algunas veces no se sabe que

compiladores en C se pueden usar ya que por internet se puede encontrar una gran

variedad de compiladores en C, y es muy importante elegir cul de estos es ms

flexible a la hora de programar. El compilador Hi tech es un buen compilador para no

empezar a programar ya que es un programa para los profesionales en la

programacin, ya que no ofrece libreras, ni drivers para nuestros proyectos, en este

compilador se necesita crear las libreras de casi todos los mdulos que contiene el

micro, mientras MikroC es un buen compilador para empezar, ya que se basa ms la

programacin a nivel educacional, ya que ofrece ms libreras de LCD, GLCD, MMC

CARD, PWM entre varios y la programacin se hace ms sencilla, pero la desventaja es que es un compilador ya estructurado y no se puede hacer mucho en las libreras ya

que si se quiere modificar alguna de ellas es muy difcil. Ahora el compilador ms

famoso por internet ya que ofrece un sinfn de proyectos programados con el

compilador PIC C COMPILER por la compaa CCS, este programa es uno de los

mejores ya que ofrece libreras muy tiles y verstiles, gracias al internet se puede encontrar varios ejemplos, es gran compilador recomendado por un servidor.



1. Programas a usar en este curso

El primer programa que usaremos en este curso es el ms conocido entre los

programadores de microcontroladores PIC.

1.-MPLAB v8.53

Se puede descargar gratuitamente en la pgina de www.microchip.com

2.-Hi tech Compiler for PIC10/12/16

Se puede descargar el lite mode que ofrece gratis solo la nica desventaja que la optimizacin es desactivada, www.htsoft.com

3.-Proteus 7.x

Se puede bajar versin demo en la pgina www.labcenter.co.uk



1.1 Hoja de proyectos

Para la creacin de nuestro primer programa se debe de crear un espacio de trabajo, abrimos nuestro programa MPLAB, y despus dirigimos nuestro ratn donde dice y despus

< proyect Wizard>

Aparcera una ventana, en esta venta solo es un saludo, presionamos , despus

elegimos que microcontroladores usaremos en este caso usaremos el microcontrolador

PIC16F886 y presionamos .



Ahora nos pedir el compilador que usaremos para programar el micro, en este caso usaremos

el compilador Hi tech y presionamos .

Despus usaremos guardaremos el proyecto en la localidad que nosotros conocemos, y

despus presionamos , y

Ahora que hemos creado el lugar de trabajo, presionamos en la hoja en blanco en la parte superior izquierda, y guardamos esa hoja en la misma localidad y agregamos la opcin de y listo, has creado el lugar de trabajo, cada vez que vallamos hacer un proyecto se tiene que hacer los pasos anteriores.



1.2 Entorno de un Programa

Antes de empezar a programar y simular hay que tener en cuenta los siguientes conocimientos.

*Conocimiento de algn lenguaje de programacin

*Conocimiento en electrnica anlogo y digital

Para entender la programacin en C para microcontroladores se dar una pequea

actualizacin para aquellos que aun no saben la programacin de alto nivel.

1.2.1 Tipos de Variables

El compilador HI-TECH Compiler soporta tipos de informacin bsica con 1, 2,3 y 4 tamao de

byte. Todos los tipos de milti-byte siguen por lo menos el formato del primer byte ms

significante. El tamao de valores WORD tienen el byte ms significante en la direccin ms

baja y DOUBLE WORD tiene el byte y WORD en el primer formato ms significante en la direccin ms baja. En la tabla siguiente se explica:



1.2.2 Formato Radix

Cualquier constate integral tendr un tipo con la cual es el tipo ms pequeo que puede

mantener el valor sin desbordar. El sufijo l o L puede ser usado con la contante para indicar que debe ser asignado tambin un tipo SIGNED LONG o UNSIGNED LONG tiene un sufijo u o U podra usarse con la contante para indicar que debe ser asignado un tipo sin signo. Y ambos I o

L y u o U poden ser usados para indicar un tipo UNSIGNED LONG INT.

Para los valores de tipo carcter se pueden encerrar con apostrofes por ejemplo:

A

Una variable de tipo carcter de varios elementos no pueden usar este tipo de apostrofes ya

que son caracteres de tipo string, que es una cadena de caracteres, para usar este tipo de

variable string se debe de hacer como el ejemplo:

char cadena[ ]=HOLA MUNDO;

1.2.3 Expresiones

Las operaciones y directivas son comprimidas de expresiones. Expresiones pueden ser hechas

de nmero, identificadores, cadenas de caracteres y operadores. Los operadores pueden ser

unitarios (un operador ej. not) o binario (2 operadores ej. +). Los operadores permitidos estn en la tabla siguiente.



1.2.4 Instrucciones

while(1){ //accion}

Esta es una instruccin de Mientras sea verdad se puede hacer ciclos perpetuos o con un fin

por ejemplo:

While(var



do{

Var++;

}while(var



Case 0: //accin

Break;

Case 1; //accin

Break;

Case

Default: //accin

Break;

}

Como vemos si la variable tiene un valor fuera de rango de los case entonces lo que se

ejecutara ser lo que contenga en default, pero si es lo contrario si la variable contiene un valor de 0 entonces entrara hacer la accin en el case 0.

Para desarrollar un ciclo contable y fcil de hacer se usa:

For(variable=0;variable



1.3 Inicializando nuestro Programa

Para empezar hacer nuestro programa siempre hay que tener en cuenta algunos puntos

importantes.

En nuestra hoja de trabajo siempre se incluir la librera del Microcontrolador en este caso es estndar ya que solo debemos de colocar la lnea:

#include //Incluimos librera del micro a usar

Despus se debe de configurar las __CONFIG, que son la configuracin del procesador. Se

debe de tomar en cuenta que siempre se debe de configurar lo ms importante.

__CONFIG(UNPROTECT & WDTDIS & PWRTEN & INTIO & MCLREN & LVPDIS);

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//UNPROTECT = Codigo no Potegido

//WDTDIS = Watch Dog Timer Desactivado

//PWRTEN = Power Activado

//INTIO = Osiclador interno

//MCLREN = Activamos Master Clear

//LVPDIS = Low Voltage Porgramming Desactivado

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

Despus si usamos un cristal interno o externo se debe de especificar a qu velocidad

va a trabajar el microcontrolador.

#define _XTAL_FREQ 4000000 //Oscilador Interno de 4MHZ

Estas tres lneas anteriores es lo bsico para tener configurado correctamente nuestro

programa y microcontrolador.



Programas Sencillos

1.4 Parpadeo

Al inicio de nuestro programa inicializamos el puerto B como salida, con la instruccin

TRISB, despus se debe de desactivar las interrupciones, despus para hacer el ciclo

perpetuo se debe de usar el while.

El esquema a manejar es el siguiente:

Material a usar:

1 MCU PIC16F886

1 LED

1 Resistencia de 10Kohm

1 Resistencia de 330ohm



Programa del Micro:

#include //Incluimos libreria del micro a usar


/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/







/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


void main(void){

//Puerto B como salida

TRISB=0x00;

//Comparadores desactivados

// CMCON=0x07;

GIE=0; //INTERRUPCIONES GLOBALES DesACTIVADAS

PEIE=0; //DesACTIVA INTERURPCIONES POR PERIFERICOS

while(1){

__delay_ms(10);

RB0=0;

__delay_ms(10);

RB0=1;

}

}



Al simular se observa que tiene una frecuencia de parpadeo 50Hz

1.5 Display de 7 segmentos

Este ejemplo demuestra como usar el display de 7 segmentos, para empezar debemos de sacar los valores necesarios para mostrar cada nmero por ejemplo, para mostrar el valor de cero, se debe de prender simultneamente los led,

A,B,C,D,E,F

Para poner a uno cada uno de ellos se tiene que usar la siguiente forma, ponemos las letras

que empiecen al revs F,E,D,C,B,A y cada uno ser un UNO pero solo tenemos 6 valores y

necesitamos 2 ms para que sea un byte completo, entonces los que falten simplemente

estarn en cero. Hay que tomar en cuenta si nuestro display es catodo o anodo ya que puede

afectar que valores deben de ser cero o unos.

00111111 = 0 en el display catodo pero como usamos un anodo comn cambian lo valores

11000000

Y Asi para todos los nmeros, hasta el 9.

A

B

C

D

E

F



Despus simplemente todos esos valores lo ponemos a una arreglo de un solo byte

Unsigned char arrey[]={0b11000000,0b11111001,0b10100100,0b10110000,0b10011001,

0b10010010,0b10000011,0b11111000,0b00000000,0b00011000};

Ahora simplemente agregamos una variable mas para el uso del For.

for(x=0;x



Programa que contiene el Microcontrolador.



/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/







/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


//Arreglo de 1 byte que contiene la numeracion

//para que se muestre en un Display de 7 SEG

unsigned char mostrar[]={0b11000000,0b11111001,0b10100100,0b10110000,0b10011001,

0b10010010,0b10000011,0b11111000,0b00000000,0b00011000};

//Variable para el ciclo FOR

unsigned char x;

//Funcion de retardo de 1 seg

//1/10mS = 100 repeticiones para obtener un 1seg

void DELAY1S(void){

//Varibale local entonces solo se usa en esta funcion

unsigned char time;

for(time=0;time



}

}

}

Simulacin



1.6 Usando el USART

Ya que el compilador Hi-tech no ofrece libreras listas para usar los mdulos de comunicacin,

adc, pwm, etc. Se ha creado la librera para el uso del USART integrado

que contiene el microcontrolador. Para el uso de la librera simplemente

copiamos la carpeta libUSART y la pegamos donde hemos creado

nuestro proyecto. Y despus agregamos en nuestro espacio de trabajo los archivos siguientes.

Y listo para usar el USART del microcontrolador.

Nota.- Esta Liberia solo funciona para micros que tienen integrado el USART (hardware) y no que sean simulados (por software)

Nuestro primer proyecto con el USART ser mandar un mensaje de HOLA MUNDO utilizando la librera antes mencionado.

Tenga en cuenta que para la realizacin de este circuito se debe de contar con un integrado

especial para transformar los niveles RS232 a TTL, el CI que vamos a usar ser MAX232.

Las conexiones de este circuito ser el siguiente:



Si se cuenta con una laptop, recuerde adquirir un cable de USBSERIAL para poder hacer la

simulacin.

Un diagrama sencillo para entender la conexin de PC a PIC seria;

Para programar el microcontrolador para el uso de este modulo, en sencillo, simplemente

incluimos nuestra librera, en este caso el archivo .H despus de haber incluido el archivo que

especifica nuestro Microcontrolador. Despus como un pin del Puerto C es el transmisor y el

otro receptor, entonces debemos de definir los pines de entrada y salida.

Buscamos la velocidad de comunicacin (baudios) con la formula:

16 1

La variable value es el valor que necesitamos escribir en la funcin de openUSART();

PC MAX232 PIC



Explicacin de funciones de la funcin openUSART (unsigned char, interrupciones RX, TX);

UNSIGNED CHAR es un valor entero de 0 a 255 donde especifica que valor necesitamos con

respecto a la frecuencia de trabajo. Para saber el valor se usa la formula antes vista.

RX, TX especifica si queremos interrupciones de Recepcin o Transmisor.

Por ejemplo queremos una velocidad de 9600 bits x segundo =9600baud y usamos una frecuencia de 4Mhz, despejamos la formula anterior;

49600 16 1 Value=25

Este valor se debe de cargar a la funcin openUSART (25,OFF,OFF);

Programa que contiene nuestro micro;


#include //libreria para trabajar con conversiones

#include"libUSART/usartdr.h" //Libreria creada para uso del usart


__CONFIG(DEBUGDIS & BORDIS);

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/







//DEBUGDIS = Desactiva Debug

//BOR = Desactivado

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


Unsigned char letra[]={HOLA MUNDO};

/////////////////////////////////////////////////



//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

////////////////////////////////////////////////

static void interrupt

isr(void){}

//////////////////////////////////////////////

//Funcion Principal

//////////////////////////////////////////////

void main(void){

TRISA=0x07;

TRISC=0x80; //RC7=RX,RC6=TX

//Configuracion del USART

OpenUSART(25,OFF,OFF); //value=(FOSC/(baud*16))-1

//SIN INTERRUPCIONES

//a 9600 baudios



For(x=0;x



Ahora bien si deseamos no usar el ciclo for ni una variable que contenga el texto, podemos

usar la instruccin prinft(string) simplemente incluimos en nuestro proyecto el siguiente archivo, .

Entonces modificamos nuestro programita.






/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/








//BOR = Desactivado

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


/////////////////////////////////////////////////





//de datos

////////////////////////////////////////////////


isr(void){}

//////////////////////////////////////////////

//Funcion Principal

//////////////////////////////////////////////

void main(void){

TRISA=0x07;





//a 9600 baudios





printf("hola mundo");

while(1);

}

Este mtodo es muy simple, pero conlleva a usar mas memoria de la forma anterior, se

recomienda hacer una funcin simple, para realizar la misma funcin pero el uso de

memoria que sea menor.



1.7 Interrupciones por Timers

Ahora viene un tema muy interesante, interrupciones por timer0, este tema se debe de aclarar

muy concretamente ya que es un modulo muy complejo para entender, pero primero que nada vallamos a definir Que es una interrupcin?.

Es un evento que cambia el proceso a otro lugar y cuando este proceso termine regresa al

estado actual.

Ej.

Cuando estamos hablando con un amigo, y de repente suena el telfono, Qu hacemos?

Interrumpimos la pltica y despus contestamos el telfono, ah estamos haciendo otra

actividad, pero al terminar de hablar por telfono, regresamos con nuestro amigo y hablamos

donde nos quedamos antes de que el telfono sonara.

Las interrupcin en los microcontroladores es prcticamente igual, ya que cuando el micro este

haciendo un proceso y de repente surge una interrupcin este guarda en una memoria el lugar

donde se haba quedado y atiende la interrupcin y despus regresa a donde se haba

quedado.

Para entender mejor este aspecto ya en la prctica, el PIC16F886 tiene timers que pueden ser usados como contadores de eventos externos o internos, en este caso usaremos internos.

Adems los timers pueden variar a su tamao ya que pueden ser de 8,16 bits,

Cuando un timer es configurado para que overflow (desbordado) tenemos una interrupcin.

En el microcontrolador tenemos el timer 0,1,2, el timer0 es de 8 bit en los PIC16 mientras en los

PIC18 pueden ser de 8 o 16 bit, este timer puede actuar como contador interno o externo, en el



interno tenemos que hay que contar los pulsos de oscilador/4. Se puede configurar este timer0

para que ocurra una interrupcin. En este caso que sea interno, por ejemplo.

Queremos que haga una interrupcin cada 3mS.

Entonces usaremos una frmula para configurar y saber qu valor del timer0 debemos de

cargar cada vez que ocurra una interrupcin.

= 4 (256 $0) Prescalar es un valor que puede ser cargado de 2, 4, 8, 16, 32, 64, 128, 256 el TMR0 es el

valor que debemos de encontrar entonces simplemente despejamos.

$0 = 256 { '( 4) }

TMR0=244 //VALOR QUE SE DEBE DE CARGAR AL TIMER0 CADA VEZ QUE SE

OVERFLOW

Se nota que la interrupcin es cada 3mS entonces sumando el voltaje positivo y cero es igual a 6mS, entonces estamos generando una frecuencia de 162Hz aprox.



Vemos el Diagrama a usar

El programa que ahora haremos es el siguiente para comprobar cmo funciona la interrupcin

por timer0.


#include"libTIMER0/OpenTimer0.h"//Incluimos libreria de timer0


/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/







/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


void main(void){

TRISB=0x00;

ANSELH=0x00;//Desactivamos PORTB como entrada analoga

OpenTIMER0(prescalar_256,ON);

//Interrupcion timpo=(1/(FOSC/4))*preescalar*(256-timer0)

// 500uS=tiempo maximo

// timer0=+256-{tiempo/[(1/(FOSC/4))*preescalar]}

TMR0=244;

GIE=1; //INTERRUPCIONES GLOBALES ACTIVADAS

PEIE=1; //ACTIVA INTERURPCIONES POR PERIFERICOS



while(1);

}

////////////////////////////////////

///Interrupcion Por timer0

////////////////////////////////////


isr(void){

if(T0IF){

RB0=~RB0;//Cmabia de estado cada vez ejecuta esta accion //amado TOGGLE

T0IF=0; //Camabia flag de interrupcion

}

TMR0=244;//Carga otra vez el timer 0

}

1.7.1 Uso del Timer0 y USART

Este ejemplo es muy sencillo, utilizaremos la interrupcin por TIMER0, para que se desborde cada ~65mS que es el tiempo mximo que puede desbordar el TIMER0, despus al tener 15

interrupciones cumplidas pasara aproximadamente 1 segundo, despus sumara +1 a la

variable que se mostrara por el USART.

Programa principal del PIC16f628A:



#include"timer0/OpenTimer0.h"//Incluimos libreria de timer0

#include"lib/usartdr.h" //Incluimos libreria del serial


/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/







/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


////////////////////////////////////////////

//Variables a usar



////////////////////////////////////////////

unsigned char cont=0,seg=0;

unsigned int numero;

void main(void){

TRISB=0;



// 65mS=tiempo maximo


TMR0=2;




//a 9600 baudios



while(1){

if(seg){ //Ha lledo a 1 seg

printf("Contando = %u\r\n",numero++); //Imprime y suma +1

seg=0; //Reset flag de segundo

}

}

}

////////////////////////////////////

///Interrupcion Por timer0

////////////////////////////////////


isr(void){

if(T0IF){ //Ha surguido una interrupcion?

cont++; //Cuenta mas +1

if(cont==15){ //Ha llegado a 1 seg?

seg=1; //Pone flag de segundo

cont=0; //Vuelve a contar

}

T0IF=0; //Rest falg de interrupcion por timer0

TMR0=2; //Carga timer0 para dar 65mS*15=1seg

}

}

El esquema manejar es el siguiente:



Nota: Use siempre el circuito MAX232 para adaptar los niveles rs232 a TTL cada vez que use

una comunicacin serial.



1.8 Uso del PWM (Pulse Width Module)

El PIC16F628A contiene un canal llamado CCP, que puede funcionar como:

Comparador

Captura

PWM

Para configurar el PWM, se ha creado una librera para manejar tal canal en modo PWM, la funcin siguiente contiene solo un parmetro para calcular, que es el periodo, el periodo

simplemente es el tiempo que deseamos.

void OpenPwm(const unsigned char periodo);

El periodo se puede calcular con una simple formula.

+, = ( + 1) 4 ($2 ) PWM period = Tiempo propuesto por nosotros

Periodo= El valor necesario para cargar en nuestra formula.

Tosc = 1/(FOSC/4)=4/TOSC

TMR2 preescalar = Es el valor que se ha propuesto para el timer2.

Ahora que hablamos del timer2 es necesario agregar la librera para trabajar con el timer2, este timer2 es un contador de 8-bit parecido al timer0 pero simplemente contiene 3 preescalares.

#define PRESCALE_1

#define PRESCALE_4

#define PRESCALE_16



La funcin del timer2 se debe de agregar antes de poner la lnea de PWM.

Un ejemplo sencillo es hacer uso del PWM y que tenga una frecuencia de 1Khz teniendo como prescalar en el timer2 un valor de 16 y un cristal interno corriendo a 4Mhz, si despejamos la frmula para obtener el nmero periodo tenemos que:

= / 1 ( 4) 0 1

= / 111 ( 44) 160 1

Tenemos que debemos de cargar el valor de 61 a la funcin de PWM.

OpenTimer2(PRESCALE_16);

OpenPwm(61);

Ahora tenemos una funcin de cambiar el ancho de pulso que es:

void PwmDuty(unsigned char duty);

duty= Es un valor unsigned char de 0 a 255, que corresponde de 0 a 100% de ancho de pulso.

Ahora bien si queremos un ancho de pulso de 50 % a 1kHz es simplemente cargar el valor

255/2=127.

PwmDuty(127);

Esto corresponde a usar un valor de 8 bit, mas adelante se usara 10-bit para mejor precisin de ancho de pulso.

Programa sencillo para uso del PWM.





#include"timer2/timer2.h"//LLama la libreria de usar Timer2

#include"pwmdr/pwm.h"//LLama libreria para usar PWM


/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/







/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


/////////////////////////////////////////////////





//de datos

////////////////////////////////////////////////


isr(void){}

//////////////////////////////////////////////

//Funcion Principal

//////////////////////////////////////////////

void main(void){

TRISB=0;

//Configuramos TIMER 2 para PWM


//Usamos libreria PWM

OpenPwm(61);

//PWM period = [(period ) + 1] x 4 x Tosc x TMR2 prescaler

//PWM period = [(255)+1]x(4/4Mhz)x16

// [.001s/((4/4Mhz)*16)]-1=period

// [1/(f*(4/Tosc)*preescalar)]-1=period

PwmDuty(127); //255=100% 127=50% de duty



while(1);

}



La simulacin tenemos:

1.9 Valores ADC (Convertidor de Anlogo-Digital)

El convertidor Anlogo-Digital convierte un valor de voltaje a un numero entero de 8 o 10-bits, si es un valor de 8 bit corresponde a un valor de 0 a 255, y si es de 10 bit entonces es de 0 a

1024.

La exactitud lo darn los bits, mas bits que tenga un ADC entonces tendremos un valor ms

cercano al valor que hemos medido.

Por ejemplo el ADC del PIC16F886 puede ser configurado de 8 o 10 bit, usaremos uno de 8 bit, que mida un voltaje de 2.456 volts, el ADC hace lo siguiente:

Si tenemos como referencia el valor de la alimentacin en este caso con +5 y masa, entonces

tenemos un rango de 0 a 5 Volts,

= 2555 = 2.456 2555

= 125.256 125



Como vemos se ha redondeado ya que lo que entrega el ADC es un valor entero de tipo

unsigned char , pero ahora usaremos uno de 10 bit;

= 2555 = 2.456 10245 = 502.9888 503

Para comparar se hace las operaciones inversamente:

8 ': ' = 5255 = 125 5255 ' = 2.450

10 ': ' = 51024 = 503 51024 ' = 2.456

Como vemos al usar un convertidor de 8 bit sea a perdido 6 mVolts, mientras el convertidor de

10 bit no se perdi nada ya que el valor se encuentra en rango.

Las operaciones anteriores lo hace automticamente el convertidor y nosotros simplemente

pedimos el valor obtenido.

La funcin que vamos a usar para la configuracin del ADC es la siguiente:

void OpenADC(const unsigned char FOSC,const unsigned char an0,const unsigned char an1);

Donde:

FOSC = tiempo de conversion, se puede tomar un valor de los siguientes:

FOSC_2

FOSC_8



FOSC_32

FOSC_FRC *Por lo general se usa un tiempo preestablecido a 2u a 6uS

an0 = Que canales vamos a usar como ADC del puerto A

//an0

#define AN0 0X01

#define AN0_AN1 0X03


#define AN0_AN3 0X0F



#define AN0_AN7 0XFF

an1= Los canales de puerto B

//an1

#define AN8 0X01






El canal ADC contiene un multiplexor que hace la funcin de establecer el canal por el

cual pedimos el ADC. En la figura siguiente se muestra como est constituido el

convertidor anlogo-digital:

Sacado del Datasheet del Microcontrolador PIC16F886

Seleccin del Canal

Cuando se cambia a un canal es necesario hacer un

retardo especifico, esto puede ser uS, o mS.

Por ejemplo:

Delay_mS(1); //Retardo de 1 milisegundo



Seleccionar canal (CANAL);

Para hacer esta accin se ha creado una funcin que pueda cambiar el canal muy fcilmente.

void channelADC(unsigned char ch);

ch = este valor puede entrar de 0 a 15, que corresponde al mximo de canales que puede tener

en este caso el Microcontrolador PIC16F886.

Ten en cuenta que si usted establece solo dos canales, se refiere que simplemente usara un

rango de 0 a 1, y as sucesivamente.

Despus de seleccionar el canal se debe de empezar la conversin, en este caso se ha creado

una funcin de startADC

void startADC(void);

Despus de empezar el ADC funcionar se debe de esperar hasta que este termine, usando una

instruccin adicional que el usuario debe de usar.

while(GODONE!=0);

Esto hace un ciclo hasta que termine la conversin, al terminar la conversin usted ya puede

leer el dato, por default tiene un valor de 10 bit, entonces necesitamos una variable 16 bit para

guardar el valor (unsigned int).

Se ha creado una funcin de leer dato anlogo.

unsigned int readADC()

Este funcin es llamada y devuelve un valor de 10 bit de un valor anlogo obtenido. Ej.






#include"libADC/adcdr.h"//Inluimos libreria de trabajo con ADC



/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/








//BOR = Desactivado

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


unsigned int adc[3];

unsigned char y;

///////////////////////////////

//Funcion de 1 segundo

////////////////////////////////

void Delay1S(void){

unsigned char x;

for(x=0;x



//a 9600 baudios

//Configuracion del ADC

OpenADC(FOSC_FRC,AN0_AN2,OFF);

//Oscilador interno

//AN0 a AN2 como entrada analogo

//PORTB sin analoga



while(1){

Delay1S(); //Retardo de 1 SEG

for(y=0;y



Mostramos la simulacin:



2.0 Uso del LCD

Los LCDs pueden adherir una gran variedad de aplicaciones en trminos de promover

una interfaz para el usuario que este manejando un aparato, como puede ser debuger de una aplicacin, simplemente dar una buena vista a nuestro proyecto. El LCD ms

comn es el Hitachi 44780, el cual da una simple interfaz entre el procesador y un LCD.

Usando este interfaz tampoco es tan simple para nuevos diseadores o programadores

porque es difcil encontrar una buena documentacin sobre el este interfaz, inicializar

el interfaz puede ser un problema.

Para el uso sencillo del LCD se ha creado funciones para manejar estos tipos de display, basndose en la informacin y tabla siguiente.

Establece Display/Cursor: DPrende lcd(1)/apaga LCD(0) CCursor activado (1)/Desactivado (0) BParpadeo del Cursor activado (1)/Desactivado (0) Mover Cursor/Recorrer cursor: SCCorrimiento del display activado (1)/Desactivado (0) RLCorrimiento hacia derecha (1)/Izquierda (0)



Establecer tamao del interfaz DLDato de 8 bit(1)/4 bit(0) NNumero de lneas del Display 1(0)/2(1) FTamao de letra 5 x 10(1)/5 x 7(0) Estado del bit de BUSY: BFBit en UNO cuando este en proceso de algo

Mover cursor a la posicin de la RAM:

ADireccion Leer/Escribir en el LCD: HDATOS

Antes de enviar cualquier comando o datos hacia el LCD, el modulo debe ser inicializado, en este

caso se trabajara con un modo de 8 bit, Esto es hecho usando las siguientes instrucciones.

1 Esperar 15mS despus de conectar la alimentacin 2 Escribir 0x30 hacia el LCD y esperar 5mS antes de otra instruccin 3 Escribir 0x30 hacia el LCD y esperar 160uS antes de otra instruccin 4 Establecer LCD

Escribe el modo a usar 8 o 4 bit Escribe 0x01 para apagar display Escribe 0x01 para limpiar display Escribe la direccin del cursor Escribe prender display/cusor

Todo lo anterior se resume a usar la funcin:

Lcd_init(unsigned char config); //Inicializamos LCD.

Config = Puede ser dos opciones

CURSOR_ON Prende el cursor y parpadea

CURSOR_OFF Apaga Cursor

Hay otras funciones pblicas, a esto se refiere a que el usuario puede llamarlas sabiendo que son especialmente para lo que es, las funciones pblicas son las siguientes:

//writeCLCD(unsigned char c);



// Funcion que escribe un caracter en el LCD

//writeSLCD(unsigned char *dir);

// funcion para escribir una cadena de caracteres

// guardadas en la RAM

//writeRSLCD(const unsigned char *string); // funcion para escribir una cadena de caracteres

// guardadas en la ROM

//gotoXYLCD(unsigned char x,unsigned char y); // Posiciona el cursor en el lugar elegido

Para dar un pequeo ejemplo del uso del Modulo LCD, se desarrolla lo siguiente, Al iniciar la simulacin, se escribir en el LCD la letra A demostrando la funcin

writeCLCD(); despus borrara la pantalla con la instruccin que no es publica pero es usada para poder limpiar la pantalla LCD, send_byte(CLEAR); enva un comando de limpiar pantalla, y despus escribimos un string guardado en la ROM y comprobamos

la funcin, writeRSLCD(); despus con un ciclo for hara contar 0 a 100 y ser mostrado en el lcd los valores de 0 a 100, poniendo en prueba una nueva funcin:

sprintf(arreglo,"datos en string %si hay valores a transformar ",valor a transformer a string);

Esta instruccin para usarla se debe de agregar la librera stdio.h al principio del

programa.

Despus ser proyectado al LCD con el uso de la instruccin writeSLCD();.



Programa de ejemplo:



#include"liblcd/lcddr.h"


/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/







/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


//////////////////////////////////////////////////

//VARIBALES GLOBALES

//////////////////////////////////////////////////

unsigned char value;

unsigned char word[25];

//////////////////////////////////////////////////

//Funcion de segundo

//////////////////////////////////////////////////

void DELAY1S(void){

unsigned char seg;

for(seg=0;seg



lcd_init(CURSOR_OFF);



writeCLCD('A'); //Escribe un simple caracter

DELAY1S(); //Funcion de retardo 1 segundo

gotoXYLCD(1,2);//FILA 2

writeRSLCD("HOLA MUNDO");//Escribe un string guardado en la ROM

gotoXYLCD(1,1); //FILA 1

writeRSLCD("I CAN WRITE");//Escribe un string guardado en la ROM

DELAY1S();

DELAY1S();

send_byte(CLEAR); //CLEAR DISPLAY

for(value=0;value



2.1 Lector de Voltaje

Ahora empecemos hacer una prctica sencilla para poner a prueba el funcionamiento

del LCD y el convertidor anlogo-digital, se trata de leer un dato anlogo y despus

transformar ese dato a un valor de voltaje, como el rango mximo es de 0 a 5 v, entonces es una tarea muy sencilla, solo usaremos un canal anlogo, en mi caso el

AN0.

Use un potencimetro de cualquier valor, preferentemente de 1kohm a 500 kohm,

conecte la terminal del potencimetro hacia la entrada anloga del microcontrolador

(AN0), despus conecte el LCD, en el puerto C.

Para cambiar el puerto de trabajo del LCD, se puede modificar la librera lcddr.h Solo cambie los parmetros indicados en el archivo .H y listo.

#define PUERTOX TRISC

#define PUERTOY PORTC

#define E RB4

#define RS RB5

#define RW RB6

Presentamos el Programa:



#include //para uso del float

#include"liblcd/lcddr.h" //Libreria creada para uso del lcd

#include"libADC/adcdr.h"//Inluimos libreria de trabajo con ADC





/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/








//BOR = Desactivado

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


////////////////////////////////////////////////

//Variables Globales

////////////////////////////////////////////////

//unsigned int adc;

float adc;

unsigned char y;

unsigned int word[25];

int lengh;

/////////////////////////////////////////////////





//de datos

////////////////////////////////////////////////


isr(void){}

//////////////////////////////////////////////

//Funcion Principal

//////////////////////////////////////////////

void main(void){

TRISA=0x01;

TRISB=0x00;//Puerto para PINES DE E,RS,RW del LCD

//Configuracion del ADC

OpenADC(FOSC_FRC,AN0,OFF);

//Oscilador interno

//AN0 como entrada analogo

//PORTB sin analoga

//Inicializamos LDC

lcd_init(CURSOR_OFF); //Inicializa Cursor APAGADO





writeRSLCD("Lectura de ADC");

while(1){

__delay_ms(100);

channelADC(0); //Canal 0

startADC(); //Empieza Conversion

while(GODONE!=0); //Ha terminado

adc=readADC(); //lee dato de 10 bit

adc=(adc*5)/1024; //

sprintf(word,"AN0=%.2f volts",adc);//Cambia todo a un string completo

gotoXYLCD(1,2); //Segunda Linea

writeSLCD(word); //Escribe la conversion del LCD

}

}

Simulacin Correspondiente:



2.2 Selector de canal anlogo con Teclado 4x4

Despus de ver el uso de los canales anlogos, y el modulo LCD, ahora debemos de

conocer el uso del teclado 4x4, el funcionamiento es sencillo.

Un teclado que funciona a base de matriz, conexiones de fila y columna, es una

manera eficiente para utilizar menos pines y hacer la programacin de este ms

sencilla, para los que apenas inician en la programacin a lo mejor es muy complejo realizar este tipo de libreras, por eso se ha realizado una librera para trabajar al menos usar teclados 4x4.

Para que usted tengo nocin de cmo funcionan, se da un pequeos pasos de cmo se debe de realizar una librera de cualquier tamao de teclado.

Realizar librera de 4X4 por pasos:

1.- Selecciona el puerto a usar (si el puerto contiene resistencias pull-ups mucho mejor)

2.- Hacer en nibble mas alto como entrada, y el nibble de menos peso como salida



3.- SI tiene resistencias pull-ups el puerto seleccionado actvelas, sino se debe de colocar externamente las resistencias en el nibble de entrada hacia +5.

4.-Inicialize la salida como encendidos, y despus apaga el pin 1110eeee y haga un corrimiento de mayor a menor:

11011111

10111111

01111111

En cada transicin de corrimiento debe de haber un retardo de 5mS, y guarde el dato de corrimiento, y lea el puerto completo, para saber si hubo algn cambio.

5.- Hay dos opciones para tomar una letra cuando se presiona y cuando no se presiona:

5.1 Si no presiona ninguna letra procure regresar un valor que usted conozca y que no est en rango de las letras que se vaya a usar.

5.2 Si se presiona una tecla guarde el valor obtenido, y decodifique ese valor con una letra establecida por nosotros y regrese y salga del ciclo y use la letra o valor obtenido a su antojo.

Estos pasos pueden funcionar para teclados de otro valor por ejemplo 4x10, 10x12 etc.

Se ha creado dos funciones necesarias para el uso del teclado 4x4, son las siguientes:

void key_init(void); Llamamos antes de otra funcion

unsigned char getkey(unsigned char kbd); Lee el dato del teclado

kbd = debe de ser un valor 0 para inicializar la funcin de leer teclado

Esta funcin devuelve un valor de tipo unsigned char (0 255)



Para saber cmo funciona, vamos a desarrollar un proyecto sencillo, es tener 4

opciones en la pantalla LCD, que nos indique que canal anlogo queremos ver, para la

seleccin del canal se usara por supuesto el teclado 4x4.

El programa a manejar es el siguiente:



#include"liblcd/lcddr.h"//Libreria para trabajar con Lcd

#include"libkey/keydr.h"//Libreria para trabajar con teclado 4x4

#include"libADC/adcdr.h"//Libreria para trabajar con ADC



/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/








//BOR = Desactivado

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


//////////////////////////////////////////////////

//VARIBALES GLOBALES

//////////////////////////////////////////////////

unsigned char value,x;

unsigned int ADC,analogo;

unsigned char word[25];

//////////////////////////////////////////////////

//Funcion de segundo

//////////////////////////////////////////////////

void DELAY1S(void){

unsigned char seg;

for(seg=0;seg



///////////////////////////////////////////////////

unsigned int LEEADC(unsigned char y){

channelADC(y);

__delay_ms(1);

startADC();

while(GODONE!=0);

ADC=readADC();

return ADC;

}

/////////////////////////////////////////////////





//de datos

////////////////////////////////////////////////


isr(void){}

/////////////////////////////////////////////////

//Funcion Principal

/////////////////////////////////////////////////

void main(void){

//Configuramos El puerto A como nibble alto como Salida y nibble Bajo como entrada

TRISA=0x0F;

//Inicializamos teclado 4x4

key_init();

//Inicializamos LCD 16X2 con cursor apagado

lcd_init(CURSOR_OFF);

//Inicializamos Convertidor Analogo AN0->AN4 puerto B no analogo

OpenADC(FOSC_FRC,AN0_AN3,OFF);



while(1){

//Parte del Programa que menciona que canal queremos ver;

send_byte(CLEAR);

gotoXYLCD(1,1);

writeRSLCD("CANAL ANALOGO");

gotoXYLCD(1,2);

writeRSLCD("A0, A1, A2, A3");

value=0;

while(value==0)value=getkey(0);

//Funcion que te deja ver el canal analogo que hallamos elegido

switch(value){

case '0':

send_byte(CLEAR);



gotoXYLCD(1,1);

writeRSLCD("CANAL CERO");

//Ver canal Canal analogo 0

while(1){

analogo=LEEADC(0);

gotoXYLCD(1,2);

sprintf(word,"%i Salir(A) ",analogo);

writeSLCD(word);

value=getkey(0);

if(value=='A') break;

}

break;

case '1':

send_byte(CLEAR);

gotoXYLCD(1,1);

writeRSLCD("CANAL UNO");


while(1){

analogo=LEEADC(1);

gotoXYLCD(1,2);


writeSLCD(word);

value=getkey(0);


}

break;

case '2':

send_byte(CLEAR);

gotoXYLCD(1,1);

writeRSLCD("CANAL DOS");


while(1){

analogo=LEEADC(2);

gotoXYLCD(1,2);


writeSLCD(word);

value=getkey(0);


}

break;

case '3':

send_byte(CLEAR);

gotoXYLCD(1,1);

writeRSLCD("CANAL TRES");


while(1){



analogo=LEEADC(3);//Llama a la funcion de llamar

analogo

gotoXYLCD(1,2); //Posiciona Cursor en coordenadas

seleccionadas

//Convierte a la variable a un string


//Escribe en el LCD

writeSLCD(word);

//lee teclado

value=getkey(0);

//Si presionamos 'A' salimos


}

break;

default:

//Sino se presiono una de las letras que deben

send_byte(CLEAR);

writeRSLCD("Intente Otra vez");

DELAY1S();

break;

}

}

}

Simulacin:



2.3 PWM a salida anlogo

Esta prctica es muy interesante ya que usaremos el PWM que contiene el

microcontrolador, y el USART integrado, con

el uso de un filtro RC, podemos obtener por

medio del PWM unas salida anloga de 10-bit,

para cambiar el valor de salida, usaremos un

software que fue creado en Microsoft Visual

C# 2010 express Edition , que puede ser

bajado solo registrndose en la pgina de Microsoft.

El funcionamiento del Software es muy sencillo, solo tiene la opcin de cambiar el

puerto (COM) y los baudios, y por supuesto contiene un barra deslizadora que hace la funcin de cambiar el voltaje, como vemos en la imagen el software.

Para hacer la simulacin correspondiente se tiene otro software sirve para hacer

Puertos virtuales, donde podemos hacer enlaces entre dos programas como puede ser

PROTEUS y nuestro software Convertidor de Digital a anlogo.

El programa a que a continuacin se da, se basa en la interrupcin por recepcin, cada

vez que el programa enva un dato, el proceso que est haciendo en ese momento el

microcontroladores es interrumpido para recibir el dato, y despus vuelve al proceso

donde se haba quedado.

Como ahora se tiene pensado usar 10-bit en la configuracin del duty del PWM,

entonces simplemente en las libreras que hemos usado para el PWM, la funcin



PwmDuty.c cambie simplemente de char a int, y tambin cambie en pwm.h la funcin

PwmDuty.c por lo que se haba cambiado anteriormente.

Al tener lo anterior, se creado dos lneas que harn que pueda convertir un valor

unsigned char a unsigned int, esto hace que pueda usarse dos byte individualmente y

unirse para crear un Word.

Mostramos el programa del PIC.





/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/








//BOR = Desactivado

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


///////////////////////////////////////////////////

//Librerias de trabajo

////////////////////////////////////////////////////


#include"timer2/timer2.h"//Incluimos timer2

#include"pwmdr/pwm.h" //Incluimos libreria para trabajar con PWM

////////////////////////////////////////////////

///Variables globales ////////

////////////////////////////////////////////////

unsigned int DUTY;

unsigned char uPWM[2];

bit flag=0;

/////////////////////////////////////////////////







//de datos

////////////////////////////////////////////////


isr(void){

//Ha resivido un dato?

if(RCIF){

//Tomo 2 bytes del serial

uPWM[0]=getch();

uPWM[1]=getch();

//Ya termine de resivir

RCIF=0;

//Habilito cambio de PWM DUTY

flag=1;

}

}

//////////////////////////////////////////////

//Funcion Principal

//////////////////////////////////////////////

void main(void){

TRISC=0x80; //RB1=RX,RB2=TX


OpenUSART(207,OFF,ON); //value=(FOSC/(baud*16))-1

//INTERRUPCIONES POR RECEPCION

//a 2400 baudios

//Configuramos el timer2


//Configuramos el PWM

OpenPwm(124); //para f=1Khz

//PWM period = [(period ) + 1] x 4 x Tosc x TMR2 prescaler

//PWM period = [(255)+1]x(4/4Mhz)x16

// [.001s/((4/8Mhz)*16)]-1=period

// [1/(f*(4/Tosc)*preescalar)]-1=period

PwmDuty(0);



while(1){

//Espera a habilitar

if(flag){

//////////////////////////////////////

//DUTY=0xPWM[1]PWM[0]=16bit

DUTY=(unsigned int)uPWM[1]



flag=0;

}

}

}

Antes de Inicialar debemos de tener abierto el Software Virtual Serial port, Creamos 2

puertos Virtuales en el botn ADD PAIR al tener dos parece cada uno ser conectado

a un programa, por ejemplo para el COM1 ser conectado a proteus por medio del compim, mientras que el COM2 ser conectado a nuestro software convertidor Digital a

Anlogo.

Al tener conectado satisfactoriamente nuestra conexin virtual, ya podemos a poner

mover la barra que har cambiar el voltaje en la salida del PWM conectado al arreglo RC.Vemos que al medir el voltaje ser acerca mucho al voltaje del software, se observa tambin el PWM, tiene una frecuencia de 1Khz como hemos precisado.



NOTA: Recuerde que si desea realizar la practica Fsicamente, se debe de usar el

MAX232 para hacer el interfaz de comunicacin entre el PIC y PC.

2.4 Medidor de voltaje por software

Esta prctica es muy sencilla, es hacer un enlace con un programa creado en Visual

C# para luego ser conectado va serial a nuestro microcontrolador, que este toma un

valor anlogo en el canal 0 (AN0) y despus es procesado para enviarlo

por el serial.

Use el MAX232 para hacer la

conexin entre PIC y PC, coloque un

potencimetro de cualquier valor que

usted desee a la entrada RA0 que es

la entrada anlogo que vamos a usar, abra el software para conectarlo en el COM

disponible en nuestra computadora, o si usted desea crear un enlace virtual entren

proteus y nuestro programa, utilizando el software Virtual Serial Port.

Abrimos el programa ADC.exe y dirigimos nuestro mouse al botn serial y elegimos el

COM2 a 2400 baud y decimos ok y conectamos.



Ahora habr haga o abra la simulacin en proteus, use el COMPIM para simular

puertos, y seleccione COM1 a 2400 baud, y presione play.

Se observa que cambia el voltaje cada vez que movemos el potencimetro.

El programa que contiene el Microcontrolador es el siguiente:







/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/








//BOR = Desactivado

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


///////////////////////////////////////////////////

//Librerias de trabajo

////////////////////////////////////////////////////


#include"libADC/adcdr.h" //Libreria creada para uso del ADC

////////////////////////////////////////////////

///Variables globales ////////

////////////////////////////////////////////////

unsigned int ADC;

unsigned char send[2];

/////////////////////////////////////////////////





//de datos

////////////////////////////////////////////////


isr(void){}

//////////////////////////////////////////////

//Funcion Principal

//////////////////////////////////////////////

void main(void){

TRISA=0x01; //RA0=entrada




//No interrupciones

//a 2400 baudios



//Configuramos ADC

OpenADC(FOSC_FRC,AN0,OFF);//Canal AN0 como analogo



while(1){

__delay_ms(1); //Tiempo antes de pedir otro dato

startADC(); //Empieza conversion

while(GODONE!=0); //ha terminad?

ADC=readADC(); //SI, lee dato

send[0]=ADC&0xFF; //toma el low byte

send[1]=(ADC>>8)&0x03;//Toma el high byte

putch(send[0]); //envia low byte primero

putch(send[1]); //envia high byte segundo

}

}

Se observa que se descompone la variable ADC ya que es una variable de 16-bit,

entonces lo que pasa es separar en 2 byte la variable, uno nombrado como bajo byte (low byte) y alto byte(high byte). Despus es enviar el low byte y en seguida el high byte, y el software se encargara de unir los dos byte para transformarlo en el valor que

haba ledo.

Nota: la instruccin ADC>>8 mueve 8-bit a la derecha y despus pasa por una

comparacin AND para que solo acepte 3 bit del byte que se forma al moverlo.

Ejemplo:

ADC=0Xff00;

ADC>>8=0x00FF

0x00FF&0x03=0x03



2.5 Reloj con Displays

Ahora haremos una prctica muy interesantes vamos a usar dos interrupciones por

timer0,1, cada uno manejara un tiempo establecido, para que estn en sincrona.

El timer 0 manejara el corrimiento entre los Display a esto se le llama multiplexado, ya que solo un display ser activado por un cierto tiempo y despus apagara para prender

el siguiente Display. Ejemplo:

Para mostrar el numero en el primer display se debe de activar el pin 1 y los demas

se deben de dejar a cero, para que solo muestre un solo numero en el

display correspondiente, como se

muestra en la imagen, debemos de

tener un controlador que pueda

cambiar el numero al correr los

pines del selector, para que estn

en sincrona.

Es muy importante realizar esta acciones a una gran velocidad, normalmente para 6

displays que sern multiplexados, se debe de tener mas de 60Hz en cada uno de los

displays ya para evitar flashazos.

El corrimiento se har con el timer0 que estar configurado a que haga un

desbordamiento cada 1mS, teniendo que cambiar al siguiente display, la frmula para



calcular el valor para se pueda cargarse al TMR0 se debe de calcular con la frmula

del timer0.

$0 = 256 { '( 4) }

Si va a operar nuestro microcontrolador con un cristal interno de 8Mhz, con un

prescalar de 16 para tener una frecuencia de 1Khz (1mS), se despeja y obtenemos:

$0 = 131 Este valor se debe de cargar cada vez que surja la interrupcin del timer0, si nuestro reloj tiene 6 displays y cada uno se va a cambiar cada 1mS entonces tenemos que la frecuencia de cada uno ser de:

= 1176 1667 Que ser ms que suficiente para eliminar los tales flashazos.

Como mencione anteriormente se debe de tener dos interrupciones funcionando a la

vez, la primera interrupcin ya la hemos visto y como opera, ahora la siguiente

interrupcin es la ms primordial, ya que es la que se encargara de contar el tiempo y

no se debe de interrumpir en absoluto.

Para el uso de esta interrupcin se usara el timer1 ya que s muy parecido al timer0

pero contiene contador de 16 bit, y tiene ms temporizacin que el timer0 la formula es

igual que el del timer0 pero ahora solos sustituiremos:



$1 = 65536 { '( 4) }

El prescalar solo tiene 4 (1,2,4,8), despejamos y tenemos

$1 = 15550 Este valor es para tener una interrupcin cada 200mS para tener un segundo se debe

de dividir este valor por el reciproco y tenemos que:

8 = 12009 = 5 Deben surgir 5 interrupciones para tener 1 Segundo, entonces aumentara una variable

que guardara. Cada segundo que pase y as al llegar a 60 segundos y aumenta otra

variable que guardara los minutos y cuando los minutos alcancen 60 minutos este

aumenta la variable horas, y as.

Ahora para mostrar los nmeros en los display se debe de contar en cuenta los valores

de corrimiento como se hablo anteriormente, estos valores de corrimiento ser hecho

en el puerto B, como son 6 display entonces se usaran 6 pines del puerto B para

multiplexarlos, al Iniciar el corrimiento este tiene un valor de 1, al correrlo, tomara un

valor de 2, y de nuevamente al correrlo este tomara un valor de 4, por deduccin se

incrementa en mltiplos de 2, entonces solo basta de usar instrucciones de if cada vez

que llegue al valor deseado por ejemplo:



If((PORTB&0x3F)==1) {

Mostrar el valor que corresponde al Display 1

}

Ahora bien como deseamos cambiar manualmente los valores de HORAS y MINUTOS,

se usaran simplemente 3 push botons para hacer estos cambios, uno ser el que

establece la hora y minutos, si este botn no est presionado no afecta presionar los

botones de hora y minutos, pero s lo contrario est presionado se podr cambiar

satisfactoriamente los valores hora y minutos.

Aqu Mostramos el resultado de la programacin:





/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/










//BOR = Desactivado

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/


/////////////////////////////////////////////////

//Librerias

/////////////////////////////////////////////////

#include"timer0/OpenTimer0.h"//Incluimos libreria de timer0

#include"libADC/adcdr.h" //Libreria creada para uso del ADC

#include"timer1/timer1dr.h" //Libreria para uso del timer1

/////////////////////////////////////////////////

//Definiciones de trabajo

/////////////////////////////////////////////////

#define SET_TIEMPO !(PORTA&0x01)

#define HORA !(PORTA&0x02)

#define MIN !(PORTA&0X04)

////////////////////////////////////////////////

//Variables Globales

////////////////////////////////////////////////

const unsigned char mostrar[]={0b11000000,0b11111001,0b10100100,0b10110000,0b10011001,

0b10010010,0b10000011,0b11111000,0b00000000,0b00011000};

unsigned char H2,H1,M2,M1,S2,S1;

unsigned char overflow1;

unsigned char TIEMPO=1,FECHA=0;

////////////////////////////////////

///Interrupcion Por timer0 y timer1

////////////////////////////////////


isr(void){

////////////////////////////////////////////

//CADA 1mS se efectuara esta accion

//Esta Funcion se encarga de correr los display

//Para cuando es necesario mostrar el numero

//En el Display siguiente

////////////////////////////////////////////

if(T0IF && !TMR1IF){

if((PORTB&0x3F)



TMR0=131;//Carga otra vez el timer 0

}

///////////////////////////////////////////

//Cada 200mS se efectuara esta accion

//Esta funcion se enecarga de incrementar

//las variables que se mostraran en los

//Displays

///////////////////////////////////////////

if(TMR1IF && TMR1IE){

T0IF=0; //Desactiva Timer0

overflow1++;

if(overflow1==5){

overflow1=0;

S1++;

if(S1==10){

S1=0;

S2++;

if(S2==6){

S2=0;

M1++;

if(M1==10){

M1=0;

M2++;

if(M2==6){

M2=0;

H1++;

if(H1==10 && H2



///////////////////////////////////////////////////

TRISB=0X00;

PORTB=0X41;

///////////////////////////////////////////////////

//Puerto C como salida ///

//Puerto C sera usado para sacar el numero ///

///////////////////////////////////////////////////

TRISC=0;

PORTC=0;

///////////////////////////////////////////////////

//PORTA como salida ///

//PORTA como entrada analoga ///

///////////////////////////////////////////////////

TRISA=0X07;

PORTA=0x00;

CM1CON0=0x00;//Desactiva comparadores

CM2CON0=0x00;

//Configuramos ADC

OpenADC(FOSC_FRC,OFF,OFF);//No usaremos Canal Analgos

//Configuramos TIMER0

//Para obtener 1 mS





TMR0=131;

OpenTIMER1(pr_8,ON);




TMR1LOAD(15550);



/////////////////////////////////////////////////////

//Inicia el Ciclo Perpetuo

/////////////////////////////////////////////////////

while(1){

if(TIEMPO && !FECHA){

/////////////////////////////////////////////////////

//Cuando sea 1 en el puerto B este muestra el valor

//Que contiene la variable

//Asi es para todas las comparaciones

/////////////////////////////////////////////////////

if((PORTB&0x3F)==1){

PORTC=mostrar[S1];



}else if((PORTB&0x3F)==2){

PORTC=mostrar[S2];


/////////////////////////////////////////////////////

//Si presionamos el boton de SET_TIEMPO

//Este da permiso para que pueda incrementar

//la vriable de MINUTOS

/////////////////////////////////////////////////////

if(!SET_TIEMPO){

if(!MIN){

M1++;

while(!MIN);

if(M1==10){

M1=0;

M2++;

if(M2==6){

M2=0;

}

}

}

}

PORTC=mostrar[M1];


PORTC=mostrar[M2];


/////////////////////////////////////////////////////

//Si presionamos el boton de SET_TIEMPO

//Este da permiso para que pueda incrementar

//la variable de HORAS

/////////////////////////////////////////////////////

if(!SET_TIEMPO){

if(!HORA){

H1++;

while(!HORA);

if(H1==10 && H2

Curso de Hi


}

}

Recuerde usar en cada Display una conexin de transistor como se muestra abajo:

Curso de Hi-tech Compiler (lite Mode)

Para Microcontroladores PIC16 100 % C!!!


tech Compiler (lite Mode) 2010




Cada Display tendr su propio transistor, para que no

caiga toda la corriente en el Microcontrolador, y

tambin pueda iluminar mucho ms.

Ahora se propone que usted haga las siguientes

modificaciones:

1.- Que pueda mostrar la fecha : Dia/Mes/Ao

Utilizando 4 interruptores.

2.- Despus de realizar lo anterior coloque un sensor de temperatura (LM35) para que pueda mostrar cada 30 Segundos la temperatura:

El sensor calbrelo a que muestre una temperatura de 0 a 100 grados.



2.6 Control de Servo

Entender este tema es muy complicado ya que requiere muchas operacin si se desea

realizar un control de varios servos, por esta razn se simplificara a un solo servo a

controlar, haciendo ms sencilla la explicacin y las operaciones.

Primero que nada hay que saber que es un servo, servo es un pequeo pero potente

dispositivo que dispone en su interior de un pequeo motor con un

reductor de velocidad y multiplicador de fuerza, tambin dispone de

un pequeo circuito que gobierna el sistema. El recorrido del eje de salida es de 180 en la mayora de ellos, pero puede ser fcilmente

modificado para tener un recorrido libre de 360 y actuar as como un

motor.

El control de posicin lo efecta el servo internamente mediante un potencimetro que

va conectado mecnicamente al eje de salida y controla un pwm (modulador de anchura de pulsos) interno para as compararlo con la entrada pwm externa del servo, mediante un sistema diferencial, y as modificar la posicin del eje de salida hasta que los valores se igualen y el servo pare en la posicin indicada, en esta posicin el motor

del servo deja de consumir corriente y tan solo circula una pequea corriente hasta el circuito interno, si forzamos el servo (moviendo el eje de salida con la mano) en este momento el control diferencial interno lo detecta y enva la corriente necesaria al motor

para corregir la posicin.



Para controlar un servo tendremos que aplicar un pulso de duracin y frecuencia

especficos. todos los servos disponen de tres cables dos para alimentacin Vcc y Gnd

y otro cable para aplicar el tren de pulsos de control que harn que el circuito de control

diferencial interno ponga el servo en la posicin indicada por la anchura del pulso.

En la siguiente tabla estn indicados los valores de control y disposicin de cables de

varias marcas que comercializan servos.

Nosotros nos basaremos en las caractersticas que contiene la marca de servos hi tech

como se aprecia en la tabla anterior las caractersticas de ancho de pulso es de 0.9 ms

como mnimo y 2.1 ms como mximo entonces tenemos un rango de operacin del

servo es de:

8: = 2.19 0.99 = 1.29 Lgica de SERVO

Para operar un servo via rs232, con un microcontrolador en general, se debe de tomar

2 interrupciones, una por timer y otra por USART, en este caso el tiempo es muy

importante entonces es mas primordial que se atienda la interrupcin por timer que por

Curso de Hi


recepcin del USART. Ya que necesitamos una estabilidad en la frecuencia que debe

de tener el servo.

porcin en tiempo alto y el resto quedara en bajotiempo alto.

El uso del timer1 es muy importante su configuracin, en este caso se debe de

configurar de la siguiente manera:

1.-Prescalar de 2 para tener un tick cada 0.4uS

2.- Activar la interrupcin por TIMER1

Si tenemos un pulso mximo de 2.1ms este valor lo divi

Este valor son los tick necesarios para llevar

bien para sacar los tick mnimos para llevar el pulso a 0.9ms se divide entre 0.4us

como la vez anterior.

Curso de Hi-tech Compiler (lite Mode)

Para Microcontroladores PIC16 100 % C!!!


Para tener la frecuencia estable aunque se

modifique el ancho de pulso, y que este en

rango de operacin del servomotor, se debe

de llevar a cabo las siguientes formulas.

Como sabemos que 50Hz equivale a tiempo

a 20 ms, y que solo va a variar una pequea

porcin en tiempo alto y el resto quedara en bajo, las operaciones se harn para el

El uso del timer1 es muy importante su configuracin, en este caso se debe de

configurar de la siguiente manera:

Prescalar de 2 para tener un tick cada 0.4uS

Activar la interrupcin por TIMER1

Si tenemos un pulso mximo de 2.1ms este valor lo dividimos por 0.4us:

'1; = 2.10.4 5250 Este valor son los tick necesarios para llevar a cabo un pulso positivo de 2.1ms, ahora

bien para sacar los tick mnimos para llevar el pulso a 0.9ms se divide entre 0.4us

tech Compiler (lite Mode) 2010


Para tener la frecuencia estable aunque se

modifique el ancho de pulso, y que este en

75347569-Hi-Tech

Documents

Transcript of 75347569-Hi-Tech