Compare capture pwm mode 5

Compare Capture PWM modeCompare Capture PWM modeCompare Capture PWM modeCompare Capture PWM mode

El modulo CCP se puede configurar en tres

maneras:

Comparador

Captura

PWM

El modulo incluye también el TIMER1 y TIMER3

es un registro de control para establecer de

funciones lógicas (Conocido como CCP) que

aumentan la operación de los TIMERS y puede

simplificar tus aplicaciones. Este hardware

podría permitirte hacer múltiples funciones

para ejecutar al mismo tiempo. Si el

microcontrolador tiene 2 CCP, entonces uno es

conocido como CCP1 y el otro como CCP2. Si

tenemos dos módulos entonces todos los

registros están identificados con el CCP1 o

CCP2.

Modo Captura

El primer modulo Captura que es usado para

funciones de repetición para el tiempo o para

determinar el ancho de pulso. Se debe de

configurar que tipo de flaco de debe de

detectar y que timer usar para copiar el

contenido del TIMER al registro de CCPxL (bajo

byte) CCPxH (Alto byte).

Diagrama de Operación en Modo Captura

Un ejemplo sencillo es como se muestra en el

diagrama siguiente:

El timer empezara a incrementar hasta llegar a

su valor de desbordamiento, si hemos

configurado nuestro canal CCP en modo captura

[MODULO CCP] 2011

MicroCursos | Curso de Hi tech Compiler For PIC18 43

que cada vez que detecte un flaco de subida

rápidamente copie el valor de TIMER y lo

guarde en el registro CCPxH:CCPxL.

En este caso si tenemos el TIMER configurado

en 16 bit y el microcontrolador opera a 4Mhz,

como mínimo valor de captura será:

Timer configurado al mínimo:

Tick – 1uS

~1uS capturara nuestro modulo como minina

resolución para tener el máximo simplemente

multiplicamos:

1 �� ∗ 65535 = 65.535�� Máxima resolución de captura.

Nota: Estos valores pueden cambiar

dependiendo de la velocidad de trabajo del

Microcontrolador.

Si usamos los dos módulos CCP en modo

Captura podemos obtener el valor de ancho de

pulso del un PWM.

Al tener los dos valores guardados en los

registros CCPxH:L procedemos a restar el valor

guardado:

� �ℎ� �� = ��2�: � − ��1�: �

Automáticamente tendremos el ancho de pulso,

pero recuerde que tenemos limitante de

captura con relación a la frecuencia de trabajo

del microcontrolador.

Para poner a prueba el modo captura del CCP,

realizaremos una práctica donde capture el

ancho de pulso de un generador de PWM.

Los primero pasos son básicos en la

programación se debe de configurar primero los

puertos del microcontrolador como entradas o

salidas respectivamente a cada modulo que

vallamos a usar, después se Configurara el

TIMER1 a 16 bit y un prescalar de 1, para que

ticks sean cada ciclo del microcontrolador.

Después Configuraremos el modulo CCP1 como

captura con un flanco de interrupción de

subida, después configuraremos el CCP2 sin

interrupción pero con un flaco de bajada.

Se realiza esta estrategia para esperar

exactamente los flancos de subida y bajada,

cuando configuramos el canal CCP1 en modo

captura y que cada

interrupción surja con

un flanco de subida esto

hace que cuando por

primera vez al conectar

nuestro circuito espera

hasta que realmente

este en un flanco de

subida y empiece a

contar el TIMER al

realizar esta acción

rápidamente se

desactiva la interrupción

[MODULO CCP] 2011


del CCP1 y a la vez activa el siguiente canal CCP

para que empiece el canal a contar el pulso positivo y cuando detecte el flaco de bajada detenga el timer

y lo copie al registro CCP2H:L, después restamos los registros CCP2H:L-CCP1H:L .

Ahora bien configuramos el USART (modo hardware) esto sirve para enviar el dato obtenido de la

operación anterior, como nuestro resultado tendrá un valor mayor que 2 bytes, debemos de separarlos

y enviar uno tras otro a nuestro software ‘Capture’

El programa que contiene el Microcontrolador es el siguiente:

/////////////////////////////////////////////////// ///// // USO CCP modo Captura //// //Autor: george.manson.69 //// //Lugar: Mexico //// //Compilador: HI TECH PIC18 (LITE MODE) //// /////////////////////////////////////////////////// ///// #include<htc.h> #include<stdio.h> /////////////////////////////////////////////////// ////////// //Configuracion para trabajar Con oscilador interno de 8Mhz __CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLL POSTDIV2 & CPUDIV1 & USBOSC); /////////////////////////////////////////////////// ////////// __CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BOR V45 & WDTPS32K); __CONFIG(3,PBDIGITAL & LPT1DIS & MCLREN); __CONFIG(4,STVRDIS & LVPDIS & ICPORTDIS & DEBUGDIS) ; __CONFIG(5,UNPROTECT); __CONFIG(6,UNPROTECT); __CONFIG(7,UNPROTECT); ////////////////////////////// //Frecuencia FOSC 8Mhz ////////////////////////////// #define _XTAL_FREQ 8000000 //////////////////////////////

Software para visualizar el ancho de pulso

[MODULO CCP] 2011


//Variable Globales // ////////////////////////////// unsigned int valor1; unsigned int valor2; unsigned int result; unsigned char flag; unsigned char buffer[2]; ////////////////////////////// //FUNCION DE 1 SEG // ////////////////////////////// void DELAY1S(void){ unsigned char time; for(time=0;time<100;time++){ __delay_ms(10); } } ///////////////////////////////////////////////// //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){ if(CCP2IF && CCP2IE){ CCP1IE=0; CCP2IF=0; valor1=ReadCapture1(); valor2=ReadCapture2(); result=valor2-valor1; flag=1; } if(CCP1IF && CCP1IE){ CCP2IE=1; } } ////////////////////////////// //FUNCION PRINCIPAL ////////////////////////////// void main(void){ OSCCON=0x70; NOP();NOP();NOP();NOP(); /////////////////////////////////////////////////// /////////////////// // Configuracion de Puertos /// /////////////////////////////////////////////////// /////////////////// TRISC=0x86; /*---------------------Fin de Conf. Puertos-------- -----------------*/ /////////////////////////////////////////////////// /////////////////// // Configuracion de Timer1 /// /////////////////////////////////////////////////// /////////////////// OpenTimer1(TIMER_INT_OFF &//Interrupcion De sactivada T1_16BIT_RW &//valor de 16 bit T1_SOURCE_INT &//Corriente desde el oscilador principal T1_PS_1_1 &//Preescalar de 1

[MODULO CCP] 2011


T1_OSC1EN_OFF & T1_SYNC_EXT_OFF & T1_SOURCE_CCP); //Sincronismo desactivado /*---------------------Fin de Conf. TIMER1--------- -----------------*/ /////////////////////////////////////////////////// /////////////////// // Configuración de CCP1 (Captura) /// /////////////////////////////////////////////////// /////////////////// OpenCapture1(CAPTURE_INT_ON & //Interrupción Desac tivada C1_EVERY_RISE_EDGE);//Cada elevación /*---------------------Fin de Conf. CCP1----------- -----------------*/ /////////////////////////////////////////////////// /////////////////// // Configuracion de CCP2 (Captura) /// /////////////////////////////////////////////////// /////////////////// OpenCapture2(CAPTURE_INT_OFF & //Interrupcion Acti vada C2_EVERY_FALL_EDGE);//Cada CAIDA /*---------------------Fin de Conf. CCP2----------- -----------------*/ /////////////////////////////////////////////////// //////////////////// // Configuración del USART /// /////////////////////////////////////////////////// //////////////////// OpenUSART(USART_TX_INT_OFF &//Interrupción por Tr ansmisión apagado USART_RX_INT_OFF &//Interrupción por Recepció n Apagado USART_ASYNCH_MODE &//Modo Asincronico USART_EIGHT_BIT &//8-bit de transmision USART_CONT_RX &//Recepcion Continua USART_BRGH_HIGH, //Alta velocidad de baudios 25); //para alta Velocidad: // FOSC / (16 * (spbrg + 1)) // spbrg=(FOS/baud*16)-1 //Para baja Velocidad: // FOSC / (64 * (spbrg + 1)) /*---------------------Fin de Conf. USART---------- ------------------*/ WriteTimer1(0); GIE=1; //INTERRUPCIONES GLOBALES ACTIVADAS PEIE=1; //ACTIVA INTERURPCIONES POR PERIFERICOS while(1){ if(flag){ DELAY1S(); buffer[0]=result&0xFF; buffer[1]=(result>>8)&0xFF; WriteUSART(buffer[0]); WriteUSART(buffer[1]); WriteTimer1(0); flag=0; CCP1IE=1; } } }

[MODULO CCP] 2011


El circuito a manejar es el siguiente:

Al armar nuestro circuito procure primero

conectar el software, y después alimente el

circuito ya conectado a la entrada del serial y

listo.

Si usted no tiene un puerto Serial puede

adquirir un cable de USB-SERIAL para simular un

puerto Serial en una entrada de USB, es muy

eficiente realizar eso, ya que últimamente las

computadoras portátiles no tienen este puerto

de comunicación.

También es muy eficiente realizar

un circuito impreso del MAX232

para hacer enlaces más rápido, en

lugar de armar la conexión en el

protoboard todas las veces

necesarias, si realizamos esto

podemos ahorrar mucho tiempo

para hacer la práctica.

Al realizar la

práctica usted

verá en el

software el

tiempo que

corresponde

al acho de

pulso.

Esto Puede ser

en ‘mS’ o ‘uS’.

[MODULO CCP] 2011


Modo PWM

Esta configuración del CCP en modo PWM, nos

proporciona un control del ancho de pulso a

una frecuencia muy estable más que usar

timers para realizar dicha acción.

El uso es muy sencillo cada canal CCP se debe

de configurar primero a la frecuencia deseada,

si se cuenta con más canales CCP cada uno de

ellos debe de tener la misma frecuencia lo único

que se puede cambiar individualmente es su

ancho de pulso.

Antes de entrar a la configuración del canal

PWM se debe de definir el timer2.

Este TIMER proporciona la frecuencia deseada

dependiendo del prescalar y postescalar.

La función de configuración del timer2 es la

siguiente:

OpenTimer2(unsigned char config);

Config puede tener los siguientes parámetros

separados por un ‘&’.

Establecer interrupción por TIMER2.

TIMER_INT_ON

TIMER_INT_OFF

Valor de Prescalar:

T2_PS_1_1

T2_PS_1_4

T2_PS_1_16

Valor postesclar:

T2_POST_1_1

T2_POST_1_2

...

T2_POST_1_15

T2_POST_1_16

Después que configuramos el TIMER2, ya

podemos poner la función de configuración del

PWM.

OpenPWM1(char period); Period puede ser cualquier valor de 0x00 a 0xFF. Para calcular el periodo se requiere la siguiente

fórmula:

�� = !"�� # + 1% ∗ 4 ∗ '(��∗ '�)2 ��*�

Del cual podemos despejar “period”

�� = + 1, ∗ - 4'��. ∗ '�)2��*�/ − 1

Tosc =corresponde a la frecuencia del Cristal

interno o externo.

F= a la frecuencia a trabajar

TMR2presclar = es el valor antes definido en la

función de OpenTimer2

Después tenemos la función de:

SetDCPWM1(unsigned int dutycycle);

Dutycycle = es de 0 a 512 que corresponde el

porcentaje del ancho de pulso.

Para entender mejor el uso del PWM, se hará

un ejemplo sencillo para el de este modulo.

[MODULO CCP] 2011


El esquema a manejar para este ejemplo es el siguiente:

Como vemos es muy simple nuestro proyecto simplemente hay que medir el ancho de pulso con un

osciloscopio para ver el resultado.

El programa que contiene el Microcontrolador es el siguiente:

/////////////////////////////////////////////////// ///// // USO DEL PWM //// //Autor: george.manson.69 //// //Lugar: Mexico //// //Compilador: HI TECH PIC18 (LITE MODE) //// /////////////////////////////////////////////////// ///// #include<htc.h> /////////////////////////////////////////////////// ////////// //Configuracion para trabajar Con oscilador interno de 8Mhz __CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLL POSTDIV2 & CPUDIV1 & USBOSC); /////////////////////////////////////////////////// ////////// __CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BOR V45 & WDTPS32K); __CONFIG(3,PBDIGITAL & LPT1DIS & MCLREN); __CONFIG(4,STVRDIS & LVPDIS & ICPORTDIS & DEBUGDIS) ; __CONFIG(5,UNPROTECT); __CONFIG(6,UNPROTECT); __CONFIG(7,UNPROTECT); //////////////////////////////

[MODULO CCP] 2011


//Frecuencia FOSC 8Mhz ////////////////////////////// #define _XTAL_FREQ 8000000 ///////////////////////////////////////////////// //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){ /////////////////////////////////////////////// //Configuramos el Oscilador Interno a 8Mhz //// /////////////////////////////////////////////// OSCCON=0x70; NOP();NOP();NOP();NOP(); /////////////////////////////////////////////////// //////////////////// // Configuracion del TIMER2 /// /////////////////////////////////////////////////// //////////////////// OpenTimer2(TIMER_INT_OFF & T2_PS_1_16 & T2_POST_1_1); /*---------------------Fin de Conf. TIMER2--------- ------------------*/ /////////////////////////////////////////////////// /////////////////// // Configuracion de PWM /// /////////////////////////////////////////////////// /////////////////// OpenPWM1(124); //1kHZ de PWM //PWM period = [(period ) + 1] x 4 x Tosc x TMR 2 prescaler //PWM period = [(255)+1]x(4/4Mhz)x16 // [.001s/((4/8Mhz)*16)]-1=period // [1/(f*(4/Tosc)*preescalar)]-1=period SetDCPWM1(255);//Establece 50%de duty cycle /*---------------------Fin de Conf. PWM------------ ------------------*/ GIE=0; //INTERRUPCIONES GLOBALES ACTIVADAS PEIE=0; //ACTIVA INTERURPCIONES POR PERIFERICOS while(1); }

[MODULO CCP] 2011


La desventaja de este método es que se debe de programar las veces que sea necesarias para cambiar el

ancho de pulso, entonces se realiza una pequeña practica para cambiar el ancho de pulso vía serial con

un software que fue realizado en Visual C# 2010 Express.

Este ejemplo controlara el giro de un motor DC vía serial, usando solo un canal CCP modo PWM.

El programa a manejar es el siguiente:

/////////////////////////////////////////////////// ///// // USO DEL PWM (Control de Motor) //// //Autor: george.manson.69 //// //Lugar: Mexico //// //Compilador: HI TECH PIC18 (LITE MODE) //// /////////////////////////////////////////////////// ///// #include<htc.h> #include<stdio.h> /////////////////////////////////////////////////// ////////// //Configuracion para trabajar Con oscilador interno de 8Mhz __CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLL POSTDIV2 & CPUDIV1 & USBOSC); /////////////////////////////////////////////////// //////////

[MODULO CCP] 2011


__CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BOR V45 & WDTPS32K); __CONFIG(3,PBDIGITAL & LPT1DIS & MCLREN); __CONFIG(4,STVRDIS & LVPDIS & ICPORTDIS & DEBUGDIS) ; __CONFIG(5,UNPROTECT); __CONFIG(6,UNPROTECT); __CONFIG(7,UNPROTECT); ////////////////////////////// //Frecuencia FOSC 8Mhz ////////////////////////////// #define _XTAL_FREQ 8000000 ////////////////////////////// //Variables globales ////////////////////////////// unsigned char buffer[2]; unsigned char flag=0; unsigned int pwm; ///////////////////////////////////////////////// //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){ if(RCIF && RCIE){ //Resivimos dos bytes getsUSART(buffer,2); RCIF=0; flag=1; } } ////////////////////////////// //FUNCION PRINCIPAL ////////////////////////////// void main(void){ /////////////////////////////////////////////// //Configuramos el Oscilador Interno a 8Mhz //// /////////////////////////////////////////////// OSCCON=0x70; NOP();NOP();NOP();NOP(); /////////////////////////////////////////////////// /////////////////// // Configuracion de Puertos /// /////////////////////////////////////////////////// /////////////////// TRISC=0x80; /*---------------------Fin de Conf. Puertos-------- -----------------*/ /////////////////////////////////////////////////// //////////////////// // Configuracion del USART /// /////////////////////////////////////////////////// //////////////////// OpenUSART(USART_TX_INT_OFF &//Interrupcion por Tr ansmision apagado USART_RX_INT_ON &//Interrupcion por Recepcion ENCENDIDO USART_ASYNCH_MODE &//Modo Asincronico USART_EIGHT_BIT &//8-bit de transmision USART_CONT_RX &//Recepcion Continua USART_BRGH_HIGH, //Alta velocidad de baudios

[MODULO CCP] 2011


25); //para alta Velocidad: // FOSC / (16 * (spbrg + 1)) // spbrg=(FOS/baud*16)-1 //Para baja Velocidad: // FOSC / (64 * (spbrg + 1)) /*---------------------Fin de Conf. USART---------- ------------------*/ /////////////////////////////////////////////////// //////////////////// // Configuracion del TIMER2 /// /////////////////////////////////////////////////// //////////////////// OpenTimer2(TIMER_INT_OFF & T2_PS_1_16 & T2_POST_1_1); /*---------------------Fin de Conf. TIMER2--------- ------------------*/ /////////////////////////////////////////////////// /////////////////// // Configuracion de PWM /// /////////////////////////////////////////////////// /////////////////// OpenPWM1(124); //1kHZ de PWM //PWM period = [(period ) + 1] x 4 x Tosc x TMR 2 prescaler //PWM period = [(255)+1]x(4/4Mhz)x16 // [.001s/((4/8Mhz)*16)]-1=period // [1/(f*(4/Tosc)*preescalar)]-1=period SetDCPWM1(0);//Establece duty cycle /*---------------------Fin de Conf. PWM------------ ------------------*/ GIE=1; //INTERRUPCIONES GLOBALES ACTIVADAS PEIE=1; //ACTIVA INTERURPCIONES POR PERIFERICOS while(1){ if(flag==1){ RCIE=0; //Convertimos los dos bytes a unsigned int pwm=(unsigned int)buffer[0]; pwm+=(unsigned int)buffer[1]<<8; SetDCPWM1(pwm);//Establece duty cycle flag=0; RCIE=1; } } }

Al armar nuestro circuito, primero conecte el

software y después conecte el circuito, y

empiece a mover la barra deslizadora y vera

que el motor empezara a girar lento

rápidamente depende como vallamos

moviendo el trackbar

[MODULO CCP] 2011


Imágenes del Circuito Terminado:

Observe que el motor debe ser activado por

medio de un transistor 2N2222

He usado un cable de USB a serial para hacer el

interfaz en mi LABTOP.

Modo Comparador

El modo comparador cambia el estado de pin

CCPx del PIC cuando el contenido del TMR1

concuerda con el valor registros CCPRxH y

CCPRxL como se muestra en el esquema

siguiente:

Este modo es usado para switchar después de

un tiempo específico.

El evento que puede ser programado es para

establecer el pin CCPx a 0 o 1, y el reset para el

tiemer1. Cuando se usa el pin CCPx, debe ser

configurado como una salida entonces debe de

estar apropiadamente el bit del registro TRIS a

0. En todos los casos cuando el resultado de la

comparación es positivo, el bit CCPxIF en el

registro PIR es puesto a 1. Este bit puede ser

checado por el programa. Si el Modulo CCP la

interrupción es establecido, genera una

búsqueda de interrupción.

Uno de los eventos que puede ser generado

como el resultado de la comparación es iniciar

positivo es para resetear el timer1. Esta

operación incrementa las posibilidades para

timer1, como puede trabajar como un

comprador de 16 bit con un modulo contador

igual para el valor guardado en los registros

CCPRxH y CCPRxL en el modulo CCP.

Nuestra practica para entender mas sobre este

modo comparador, se tratara de configurar

correctamente el modulo y el timer para

empezar la comparación de un valor puesto en

los registros CCPPRxH:L, y cada vez que se de

esta igualdad surja una interrupción y podamos

cambiar de estado un pin determinado.

[MODULO CCP] 2011


El programa que contiene el Microcontrolador es el Siguiente:

/////////////////////////////////////////////////// ///// // USO DEL COMPARADO //// //Autor: george.manson.69 //// //Lugar: Mexico //// //Compilador: HI TECH PIC18 (LITE MODE) //// /////////////////////////////////////////////////// ///// #include<htc.h> /////////////////////////////////////////////////// ////////// //Configuracion para trabajar Con oscilador interno de 8Mhz __CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLL POSTDIV2 & CPUDIV1 & USBOSC); /////////////////////////////////////////////////// ////////// __CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BOR V45 & WDTPS32K); __CONFIG(3,PBDIGITAL & LPT1DIS & MCLREN); __CONFIG(4,STVRDIS & LVPDIS & ICPORTDIS & DEBUGDIS) ; __CONFIG(5,UNPROTECT); __CONFIG(6,UNPROTECT); __CONFIG(7,UNPROTECT); ////////////////////////////// //Frecuencia FOSC 8Mhz ////////////////////////////// #define _XTAL_FREQ 8000000 ///////////////////////////////////////////////// //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){ //Espera por interrupcion if(CCP1IF && CCP1IE){ RC0=~RC0;//cambia estado CCP1IF=0;//reset flag de interrupcion WriteTimer1(0);//inicializa a cero } } ////////////////////////////// //FUNCION PRINCIPAL ////////////////////////////// void main(void){ /////////////////////////////////////////////// //Configuramos el Oscilador Interno a 8Mhz //// /////////////////////////////////////////////// OSCCON=0x70; NOP();NOP();NOP();NOP(); /////////////////////////////////////////////////// /////////////////// // Configuración de PUERTOS //// /////////////////////////////////////////////////// /////////////////// TRISC=0x00;//Puerto C como salida /*---------------------Fin de Conf. PUERTOS-------- -----------------*/

[MODULO CCP] 2011


/////////////////////////////////////////////////// /////////////////// // Configuración de TIMER1 //// /////////////////////////////////////////////////// /////////////////// OpenTimer1(TIMER_INT_OFF &//Desactiva Interrupcio n por timer T1_16BIT_RW &//Contador de 16 bit T1_SOURCE_INT &//Corriente del Oscilador inte rno T1_PS_1_1 &//Prescalar de 1 T1_OSC1EN_OFF &//Oscilador del timer desactiv ado T1_SYNC_EXT_OFF &//Sincronismo Externo Desact ivado T1_SOURCE_CCP); //Ambos CCP tiene el Timer1 /*---------------------Fin de Conf. TIMER1--------- -----------------*/ /////////////////////////////////////////////////// /////////////////// // Configuración de Compare /// /////////////////////////////////////////////////// /////////////////// CCP1CON=0b00001010; //Evento de Interrupción al ser iguales TMR1 y //CCPRxH:L CCP1IE=1; //Activa Interrupción por CCP CCPR1L=30000&0xFF; //Inicializa registros de C CPRxH:L CCPR1H=(30000>>8)&0xFF;//Con un valor de 30000 WriteTimer1(0); // /*---------------------Fin de Conf. PWM------------ ------------------*/ GIE=1; //INTERRUPCIONES GLOBALES ACTIVADAS PEIE=1; //ACTIVA INTERURPCIONES POR PERIFERICO S while(1);//ciclo perpetuo }

Cuando cargamos el registro CCPRx con un valor de 30000 nuestro periodo es calculado con la formula:

�� = 30000 ∗ 0.5�� = 0.015 �

0.5uS es el valor que corresponde a los pasos que estará incrementando el timer1 en este caso como

vemos el valor corresponde a la frecuencia de trabajo del microcontrolador.

Cuando se cumpla la igualdad en TIMER1 y CCPRx generara una interrupción del cual se tuvo que

esperar 15mS para que siguiera tal interrupción después cambiamos de estado el pin deseado, al hacer

esto estamos generando una frecuencia de 33Hz.

El diagrama a Manejar es el siguiente:

[MODULO CCP] 2011


Ahora si deseamos realizar un variador de frecuencia que tenga de rango 1Khz a 15 Hz usando un

Potenciómetro y una entrada análoga podemos hacerlo, simplemente se trata de que el valor leído del

canal análogo pase por una operación simple donde se convierte en un valor de 16 bit.

��1 = "*�� ∗ 65535#/1023

El resultado se deposita en el registro CCPRxH:L y listo, al variar el potenciómetro variara la frecuencia:

El esquema a manejar es el siguiente:

[MODULO CCP] 2011


El programa que tiene el microcontrolador es e siguiente:

/////////////////////////////////////////////////// ///// // USO DEL COMPARADO //// //Autor: george.manson.69 //// //Lugar: Mexico //// //Compilador: HI TECH PIC18 (LITE MODE) //// /////////////////////////////////////////////////// ///// #include<htc.h> /////////////////////////////////////////////////// ////////// //Configuracion para trabajar Con oscilador interno de 8Mhz __CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLL POSTDIV2 & CPUDIV1 & USBOSC); /////////////////////////////////////////////////// ////////// __CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BOR V45 & WDTPS32K); __CONFIG(3,PBDIGITAL & LPT1DIS & MCLREN); __CONFIG(4,STVRDIS & LVPDIS & ICPORTDIS & DEBUGDIS) ; __CONFIG(5,UNPROTECT); __CONFIG(6,UNPROTECT); __CONFIG(7,UNPROTECT); ////////////////////////////// //Frecuencia FOSC 8Mhz ////////////////////////////// #define _XTAL_FREQ 8000000 ////////////////////////////// //Variable Globales // ////////////////////////////// unsigned int result; ///////////////////////////////////////////////// //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){ //Espera por interrupcion if(CCP1IF && CCP1IE){ RC0=~RC0;//cambia estado CCP1IF=0;//reset flag de interrupcion WriteTimer1(0);//inicializa a cero } } ////////////////////////////// //FUNCION PRINCIPAL ////////////////////////////// void main(void){ /////////////////////////////////////////////// //Configuramos el Oscilador Interno a 8Mhz //// /////////////////////////////////////////////// OSCCON=0x70; NOP();NOP();NOP();NOP();

[MODULO CCP] 2011


/////////////////////////////////////////////////// /////////////////// // Configuracion de PUERTOS //// /////////////////////////////////////////////////// /////////////////// TRISC=0x00;//Puerto C como salida TRISA=0x01;// /*---------------------Fin de Conf. PUERTOS-------- -----------------*/ /////////////////////////////////////////////////// /////////////////// // Configuracion de ADC /// /////////////////////////////////////////////////// /////////////////// OpenADC(ADC_FOSC_RC &//Internal Oscilador Intern o ADC_RIGHT_JUST &//Justificacion a la derecha (10 -bit) ADC_20_TAD, //Tiempo de Adquisicion (TAD) ADC_CH0 &//CANAL 0 analogo ADC_INT_OFF &//Interrupcion por ADC APAGDO ADC_REF_VDD_VSS, //V+ref=VCC,V-ref=GND 1); //AN0=analogo,resto digitales /*---------------------Fin de Conf. ADC------------ ------------------*/ /////////////////////////////////////////////////// /////////////////// // Configuracion de TIMER1 //// /////////////////////////////////////////////////// /////////////////// OpenTimer1(TIMER_INT_OFF &//Desactiva Interrupcio n por timer T1_16BIT_RW &//Contador de 16 bit T1_SOURCE_INT &//Corriente del Oscilador inte rno T1_PS_1_1 &//Prescalar de 1 T1_OSC1EN_OFF &//Oscilador del timer desactiv ado T1_SYNC_EXT_OFF &//Sincronismo Externo Desact ivado T1_SOURCE_CCP); //Ambos CCP tiene el Timer1 /*---------------------Fin de Conf. TIMER1--------- -----------------*/ /////////////////////////////////////////////////// /////////////////// // Configuracion de Compare /// /////////////////////////////////////////////////// /////////////////// CCP1CON=0b00001010; //Evento de Interrupcion al se r iguales TMR1 y //CCPRxH:L CCP1IE=1; //Activa Interrupcion por CCP CCPR1L=30000&0xFF; //Inicializa registros de CCPR xH:L CCPR1H=(30000>>8)&0xFF;//Con un valor de 30000 WriteTimer1(0); // /*---------------------Fin de Conf. PWM------------ ------------------*/ GIE=1; //INTERRUPCIONES GLOBALES ACTIVADAS PEIE=1; //ACTIVA INTERURPCIONES POR PERIFERICO S while(1){ __delay_ms(10); ConvertADC(); //Empieza Conversion while(BusyADC()); //Espera a terminar result=ReadADC(); //lee resultado result=(unsigned int)(((unsigned long)result*6553 5)/1023); CCPR1L=result&0xFF; //Inicializa registros de CCP RxH:L CCPR1H=(result>>8)&0xFF;//Con un valor } }

Compare capture pwm mode 5

Documents

Transcript of Compare capture pwm mode 5