Está en la página 1de 5

16/4/2018 RobotyPic: Control de velocidad de un motor DC con PIC

Control de velocidad de un motor DC con PIC


Se trata de controlar la velocidad de un motor DC con una señal de impulsos. Variando el tiempo en
estado alto de la señal con respecto al tiempo en estado bajo conseguiremos reducir la tensión
media que le llega al motor y en consecuencia variaremos su velocidad.

Para hacer ese control con el PIC, en este proyecto emplearemos el modo PWM (Pulse Width
Modulation). Leeremos una tensión con el conversor AD del PIC proporcionada por un
potenciómetro como control manual de la velocidad. Este valor determinará el tiempo de los pulsos
en estado alto de la señal que controlará la velocidad.

En el modo PWM el PIC compara el valor del registro CCP (en este caso el CCP2) con el valor del
timer1. En el registro CCP habremos cargado previamente un valor responsable de la velocidad del
motor. Cuando ambos coinciden, se produce la interrupción con la que gestionaremos el cambio de
estado de la señal hasta una nueva comparación con la cuenta del timer 1.

http://robotypic.blogspot.com.ar/2012/11/control-de-velocidad-de-un-motor-dc-con.html 1/5
16/4/2018 RobotyPic: Control de velocidad de un motor DC con PIC

lectura_AD=read_adc(); //Lectura canal analógico

#int_ccp2

void ccp2_int(){

//Conmutación estado salida CCP2


if(++cambio==1){

//Modo comparación,conmutación salida a 0


setup_ccp2(CCP_COMPARE_CLR_ON_MATCH);
//carga del ccp2 con valor semiperiodo alto

ccp_2=lectura_AD;
}
else{
//Modo comparación, conmutación salida a 1
setup_ccp2(CCP_COMPARE_SET_ON_MATCH);
//Carga del ccp2 con valor del semiperiodo bajo
ccp_2=255-lectura_AD;
}
//Reinicio del temporizador para nueva comparación
set_timer1(0);
}

[+/-] Ver / Ocultar programa completo en C


////////////////////////////////////////////////////////////////////////////////
// //
// CONTROL VELOCIDAD MOTOR DC CON PIC //
// //
// (c) RobotyPic 2012 //
// //
////////////////////////////////////////////////////////////////////////////////

#include <16f876a.h> //Archivo para control del pic 16f876a

#device adc=8 //Configuración conversor AD a 8 bits

#fuses XT,NOWDT

#use delay(clock=4000000) //frecuencia de reloj 4 MHz

#byte trisb=0x86
#byte portb=0x06
#byte trisc=0x87
#byte portc=0x07

#define use_portb_lcd TRUE //Configuración puerto b control lcd


#include <lcd.c> //archivo para control del lcd

/***************** Definición de las variables globales ***********************/

int1 cambio=0; //Control del cambio


int16 lectura_AD; //Referencia de velocidad

/********************** Prototipos de las funciones ***************************/

void main (void); //función principal


void ccp2_int (void); //función por interrupción

/******************************************************************************/
/******************* FUNCIÓN GENERACIÓN MODULACIONES PWM **********************/

#int_ccp2

http://robotypic.blogspot.com.ar/2012/11/control-de-velocidad-de-un-motor-dc-con.html 2/5
16/4/2018 RobotyPic: Control de velocidad de un motor DC con PIC
void ccp2_int(){
if(++cambio==1){ //Conmutación estado salida CCP2
setup_ccp2(CCP_COMPARE_CLR_ON_MATCH); //Modo comparación, conmutación salida a 0
ccp_2=lectura_AD; //carga del ccp2 con valor semiperiodo alto
}

else{
setup_ccp2(CCP_COMPARE_SET_ON_MATCH); //Modo comparación, conmutación salida a 1
ccp_2=255-lectura_AD; //Carga del ccp2 con valor semiperiodo bajo
}
set_timer1(0); //Reinicio del temporizador para comparación
}

/******************************************************************************/
/******************** FUNCIÓN PRINCIPAL ***************************************/

void main(){

float velocidad; //Porcentaje velocidad

trisc=0x00; //Puerto C como salida de datos


port_b_pullups(TRUE); //Habilitación resistencias pullups puerto b
lcd_init(); //Inicialización del lcd

setup_timer_1(T1_INTERNAL|T1_DIV_BY_1); //Configuración Timer para comparación


setup_ccp2(CCP_COMPARE_SET_ON_MATCH); //Modo comparación, conmutación salida a 1

setup_adc_ports(AN0); //Canal de entrada analógico AN0


setup_adc(ADC_CLOCK_INTERNAL); //Fuente de reloj RC para conversor AD

enable_interrupts(int_ccp2); //habilitación interrupción por comparación


enable_interrupts(GLOBAL); //Habilitación de toda las interrupciones

while (true){
set_adc_channel(0); //Habiliatación lectura AD
delay_us(20); //Estabilización
lectura_AD=read_adc(); //Lectura canal analógico
velocidad=(lectura_AD/2.55); //Cálculo % de velocidad

printf(lcd_putc, "\fVelocidad = %3.0f%%", velocidad);


}
}

En esta animación se puede ver la simulación bajo proteus.

Los archivos del proyecto se pueden descargar en el siguiente enlace:

Descargar archivos Control Velocidad Motor

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes
versiones de software:
- Windows xp y windows 7
- Proteus V7.7 SP2
- CCS PIC C COMPILER v4.084

-->

Quizás también le interese:


http://robotypic.blogspot.com.ar/2012/11/control-de-velocidad-de-un-motor-dc-con.html 3/5
16/4/2018 RobotyPic: Control de velocidad de un motor DC con PIC

Emisor - Receptor PIC controlador de Control de un Robot que evita Control de un brazo
de infrarojos con servos por I2C LCD03 por bus I2C obstáculos. Robot de 4 ejes
PIC con PIC

Linkwithin

Publicado por Robotypic

7 comentarios:
Erick Colina Huaman dijo...
Buen aporte.
8 de mayo de 2013, 15:38

Mamen Gil dijo...


Muy bueno
10 de marzo de 2014, 20:33

NiErickzon dijo...
Hola!
una pregunta, si solo quisiera utilizar la parte del código para obtener las revoluciones por minuto sin
la pantalla, qué es lo que debería incluir en mi programa?
Es que debo registrar las revoluciones por minuto de un motor de AC a través de un pic18f4550 y
manipular los datos con labview... en realidad no sé mucho de como usar ambos jaja pero la tarjeta
de adquisición de datos ya la hice :)

espero puedas ayudarme


saludos!
3 de abril de 2014, 7:47

Robotypic dijo...
Si quieres medir las rpm deberás insertar un encoder. Contando los impulsos del encoder
correspondientes a una vuelta y midiendo el tiempo que tarda en leerlos sabrás el tiempo que le
cuesta un giro completo y por tanto las rpm. Para medir los pulsos puedes utilizar el modo de captura
del pic o la interrupción externa. También mediante dos posibles procesos; bien midiendo el tiempo
entre pulsos del encoder o bien midiendo el numero de pulsos en un tiempo dado.
3 de abril de 2014, 23:43

Cristobal Fernandez dijo...


Muy bueno, gracias por el aporte me sirvió mucho
29 de noviembre de 2015, 18:07

Unknown dijo...
Hola que tal el circuito me funciona muy bien la salida me da 2.5 khz podrias ayudarme que debo
modificar del codigo para obtener una salida de 20 Khz. Por favor
21 de diciembre de 2015, 16:55

http://robotypic.blogspot.com.ar/2012/11/control-de-velocidad-de-un-motor-dc-con.html 4/5
16/4/2018 RobotyPic: Control de velocidad de un motor DC con PIC

Robotypic dijo...
Aumenta el valor de carga del temporizador set_timer(0); Ponle otro valor superior a 0.
22 de diciembre de 2015, 19:54

Publicar un comentario

http://robotypic.blogspot.com.ar/2012/11/control-de-velocidad-de-un-motor-dc-con.html 5/5