Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Curso de HI-TECH PDF
Curso de HI-TECH PDF
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
compiladores en C se pueden usar ya que por internet se puede encontrar una gran
compilador se necesita crear las libreras de casi todos los mdulos que contiene 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
1.-MPLAB v8.53
Se puede descargar el lite mode que ofrece gratis solo la nica desventaja que la
3.-Proteus 7.x
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 <proyect> y despus
Aparcera una ventana, en esta venta solo es un saludo, presionamos <next>, despus
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 <add
file to proyect> y listo, has creado el lugar de trabajo, cada vez que vallamos hacer un proyecto
Antes de empezar a programar y simular hay que tener en cuenta los siguientes conocimientos.
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
direccin ms baja.
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
Para los valores de tipo carcter se pueden encerrar con apostrofes por ejemplo:
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
1.2.3 Expresiones
Las operaciones y directivas son comprimidas de expresiones. Expresiones pueden ser hechas
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<10){
Var++;
Esta es una instruccin parecida a la de arriba la diferencia es que al menos una vez entrara al
Var++;
}while(var<3);
If(//comparacin) {//accin}
[else if()]{//accion}
[else {//accion}]
Var=2;
If(var==1){
//accin
}else if(var==2){
}else{
//accin
De otra forma se puede desarrollar estas comparaciones, es muy comn usar la instruccin
Switch (variable){
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
For(variable=0;variable<100;variable++){
//accin
Se usa un ciclo for, como vemos en el ejemplo la variable en inicializada cuando entra por
primera vez al ciclo, despus comparara en este caso la variable es menor de 100, si es as
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
Despus se debe de configurar las __CONFIG, que son la configuracin del procesador. Se
__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
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
va a trabajar el microcontrolador.
Estas tres lneas anteriores es lo bsico para tener configurado correctamente nuestro
programa y microcontrolador.
Programas Sencillos
1.4 Parpadeo
TRISB, despus se debe de desactivar las interrupciones, despus para hacer el ciclo
Material a usar:
1 MCU PIC16F886
1 LED
1 Resistencia de 10Kohm
1 Resistencia de 330ohm
__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
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 4000000 //Oscilador Interno de 4MHZ
void main(void){
//Puerto B como salida
TRISB=0x00;
//Comparadores desactivados
// CMCON=0x07;
while(1){
__delay_ms(10);
RB0=0;
__delay_ms(10);
RB0=1;
}
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
B
F
E C
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
00111111 = 0 en el display catodo pero como usamos un anodo comn cambian lo valores
11000000
0b10010010,0b10000011,0b11111000,0b00000000,0b00011000};
Ahora simplemente agregamos una variable mas para el uso del For.
La funcin DELAY1S es un retardo de un segundo esta funcin se tuvo que hacer, ya que el
compilador no ofrece tanto retardo para una frecuencia de 4Mhz.
void DELAY1S(void){
for(time=0;time<100;time++){
__delay_ms(10);
__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
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 4000000 //Oscilador Interno de 4MHZ
0b10010010,0b10000011,0b11111000,0b00000000,0b00011000};
//Variable para el ciclo FOR
unsigned char x;
for(time=0;time<100;time++){
__delay_ms(10);
}
}
void main(void){
//Puerto B como salida
TRISC=0x00;
while(1){
for(x=0;x<10;x++){ //Ciclo for
PORTC=mostrar[x]; //Saca el valor que correponde al puerto C
DELAY1S(); //LLama a la funcion de retardo de 1seg
19 Para Microcontroladores PIC16 100 % C!!!
Curso de Hi-tech Compiler (lite Mode) 2010
}
}
Simulacin
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
Nota.- Esta Liberia solo funciona para micros que tienen integrado el USART (hardware) y no
Nuestro primer proyecto con el USART ser mandar un mensaje de HOLA MUNDO utilizando
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.
Si se cuenta con una laptop, recuerde adquirir un cable de USB<->SERIAL para poder hacer la
simulacin.
PC MAX232 PIC
incluimos nuestra librera, en este caso el archivo .H despus de haber incluido el archivo que
1
16
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.
Por ejemplo queremos una velocidad de 9600 bits x segundo =9600baud y usamos una
1
4
9600 16
Value=25
__CONFIG(UNPROTECT & WDTDIS & PWRTEN & INTIO & MCLREN & LVPDIS);
__CONFIG(DEBUGDIS & BORDIS);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//UNPROTECT = Codigo no Potegido
//WDTDIS = Watch Dog Timer Desactivado
//PWRTEN = Power Activado
//INTIO = Osiclador interno
//MCLREN = Activamos Master Clear
//LVPDIS = Low Voltage Porgramming Desactivado
//DEBUGDIS = Desactiva Debug
//BOR = Desactivado
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 4000000 //Oscilador Interno de 8MHZ
/////////////////////////////////////////////////
For(x=0;x<10;x++){
Putch(letra[x];
}
while(1);
}
archivo, <stdio.h>.
__CONFIG(UNPROTECT & WDTDIS & PWRTEN & INTIO & MCLREN & LVPDIS);
__CONFIG(DEBUGDIS & BORDIS);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//UNPROTECT = Codigo no Potegido
//WDTDIS = Watch Dog Timer Desactivado
//PWRTEN = Power Activado
//INTIO = Osiclador interno
//MCLREN = Activamos Master Clear
//LVPDIS = Low Voltage Porgramming Desactivado
//DEBUGDIS = Desactiva Debug
//BOR = Desactivado
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 4000000 //Oscilador Interno de 8MHZ
/////////////////////////////////////////////////
//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
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
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
Es un evento que cambia el proceso a otro lugar y cuando este proceso termine regresa al
estado actual.
Ej.
actividad, pero al terminar de hablar por telfono, regresamos con nuestro amigo y hablamos
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
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
para que ocurra una interrupcin. En este caso que sea interno, por ejemplo.
Entonces usaremos una frmula para configurar y saber qu valor del timer0 debemos de
4
=
(256 $0)
Prescalar es un valor que puede ser cargado de 2, 4, 8, 16, 32, 64, 128, 256 el TMR0 es el
'
$0 = 256 { }
4
(
)
OVERFLOW
Se nota que la interrupcin es cada 3mS entonces sumando el voltaje positivo y cero es igual a
El programa que ahora haremos es el siguiente para comprobar cmo funciona la interrupcin
por timer0.
__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
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 4000000 //Oscilador Interno de 4MHZ
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;
}
////////////////////////////////////
///Interrupcion Por timer0
////////////////////////////////////
static void interrupt
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
}
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
__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
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 4000000 //Oscilador Interno de 4MHZ
////////////////////////////////////////////
//Variables a usar
void main(void){
TRISB=0;
OpenTIMER0(prescalar_256,ON);
//Interrupcion timpo=(1/(FOSC/4))*preescalar*(256-timer1)
// 65mS=tiempo maximo
// timer0=+256-{tiempo/[(1/(FOSC/4))*preescalar]}
TMR0=2;
//Configuracion del USART
OpenUSART(25,OFF,OFF); //value=(FOSC/(baud*16))-1
//SIN INTERRUPCIONES
//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
////////////////////////////////////
static void interrupt
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
}
}
Nota: Use siempre el circuito MAX232 para adaptar los niveles rs232 a TTL cada vez que use
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
4
+,
= (
+ 1) ($2
)
Tosc = 1/(FOSC/4)=4/TOSC
Ahora que hablamos del timer2 es necesario agregar la librera para trabajar con el timer2, este
#define PRESCALE_1
#define PRESCALE_4
#define PRESCALE_16
Un ejemplo sencillo es hacer uso del PWM y que tenga una frecuencia de 1Khz teniendo como
1
= / 01
4
(
)
1
= / 01
4
11 ( ) 16
4
OpenTimer2(PRESCALE_16);
OpenPwm(61);
duty= Es un valor unsigned char de 0 a 255, que corresponde de 0 a 100% de ancho de pulso.
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.
__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
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 4000000 //Oscilador Interno de 4MHZ
/////////////////////////////////////////////////
//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){
TRISB=0;
//Configuramos TIMER 2 para PWM
OpenTimer2(PRESCALE_16);
//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);
1024.
La exactitud lo darn los bits, mas bits que tenga un ADC entonces tendremos un valor ms
Por ejemplo el ADC del PIC16F886 puede ser configurado de 8 o 10 bit, usaremos uno de 8 bit,
Si tenemos como referencia el valor de la alimentacin en este caso con +5 y masa, entonces
= 125.256 125
= 502.9888 503
5 125 5
8 ': '
= =
255 255
'
= 2.450
5 503 5
10 ': '
= =
1024 1024
'
= 2.456
Como vemos al usar un convertidor de 8 bit sea a perdido 6 mVolts, mientras el convertidor de
void OpenADC(const unsigned char FOSC,const unsigned char an0,const unsigned char an1);
Donde:
FOSC_2
FOSC_8
//an0
#define AN0 0X01
#define AN0_AN1 0X03
#define AN0_AN2 0X07
#define AN0_AN3 0X0F
#define AN0_AN4 0X1F
#define AN0_AN6 0X7F
#define AN0_AN7 0XFF
//an1
#define AN8 0X01
#define AN8_AN9 0X02
#define AN8_AN10 0X07
#define AN8_AN11 0X0F
#define AN8_AN12 0X1F
#define AN8_AN13 0X3F
El canal ADC contiene un multiplexor que hace la funcin de establecer el canal por el
convertidor anlogo-digital:
Por ejemplo:
Para hacer esta accin se ha creado una funcin que pueda cambiar el canal muy fcilmente.
ch = este valor puede entrar de 0 a 15, que corresponde al mximo de canales que puede tener
Ten en cuenta que si usted establece solo dos canales, se refiere que simplemente usara un
rango de 0 a 1, y as sucesivamente.
void startADC(void);
Despus de empezar el ADC funcionar se debe de esperar hasta que este termine, usando una
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
Este funcin es llamada y devuelve un valor de 10 bit de un valor anlogo obtenido. Ej.
__CONFIG(UNPROTECT & WDTDIS & PWRTEN & INTIO & MCLREN & LVPDIS);
__CONFIG(DEBUGDIS & BORDIS);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//UNPROTECT = Codigo no Potegido
//WDTDIS = Watch Dog Timer Desactivado
//PWRTEN = Power Activado
//INTIO = Osiclador interno
//MCLREN = Activamos Master Clear
//LVPDIS = Low Voltage Porgramming Desactivado
//DEBUGDIS = Desactiva Debug
//BOR = Desactivado
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 8000000 //Oscilador Interno de 8MHZ
///////////////////////////////
//Funcion de 1 segundo
////////////////////////////////
void Delay1S(void){
unsigned char x;
for(x=0;x<100;x++){
__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){}
//////////////////////////////////////////////
//Funcion Principal
//////////////////////////////////////////////
void main(void){
TRISA=0x07;
TRISC=0x80; //RB1=RX,RB2=TX
//Configuracion del USART
OpenUSART(51,OFF,OFF); //value=(FOSC/(baud*16))-1
//SIN INTERRUPCIONES
while(1){
Delay1S(); //Retardo de 1 SEG
for(y=0;y<3;y++){ //CICLO para leer las 3 entradas analogas
channelADC(y);
__delay_ms(1);
startADC();
while(GODONE!=0);
adc[y]=readADC();
}//imprime el valor de cada entrada
printf("AN0= %u | AN1= %u | AN2= %u\r\n",adc[0],adc[1],adc[2]);
}
trabaje con un oscilador interno, con entradas anlogas que empieza de AN0, AN1,
AN2, tambin configuramos el USART que trabaje a una velocidad de 9600 baud, al
empezar el programa principal, este selecciona el canal que vamos a usar con un ciclo
que termine y despus con un arreglo de datos de tipo int guarda el dato anlogo.
Al salir del ciclo for el arreglo contiene las 3 lecturas de los 3 canales anlogos, al tener
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
Para el uso sencillo del LCD se ha creado funciones para manejar estos tipos de
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)
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.
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:
// 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
la funcin, writeRSLCD(); despus con un ciclo for hara contar 0 a 100 y ser mostrado
string);
Esta instruccin para usarla se debe de agregar la librera stdio.h al principio del
programa.
__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
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 4000000 //Oscilador Interno de 4MHZ
//////////////////////////////////////////////////
//VARIBALES GLOBALES
//////////////////////////////////////////////////
unsigned char value;
unsigned char word[25];
//////////////////////////////////////////////////
//Funcion de segundo
//////////////////////////////////////////////////
void DELAY1S(void){
unsigned char seg;
for(seg=0;seg<100;seg++){
__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){}
/////////////////////////////////////////////////
//Funcion Principal
/////////////////////////////////////////////////
void main(void){
PORTA=0x00;
TRISA=0x20;
Simulacin correspondiente:
Ahora empecemos hacer una prctica sencilla para poner a prueba el funcionamiento
entonces es una tarea muy sencilla, solo usaremos un canal anlogo, en mi caso el
AN0.
Para cambiar el puerto de trabajo del LCD, se puede modificar la librera lcddr.h Solo
#define E RB4
#define RS RB5
#define RW RB6
Presentamos el Programa:
__CONFIG(UNPROTECT & WDTDIS & PWRTEN & INTIO & MCLREN & LVPDIS);
__CONFIG(DEBUGDIS & BORDIS);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//UNPROTECT = Codigo no Potegido
//WDTDIS = Watch Dog Timer Desactivado
//PWRTEN = Power Activado
//INTIO = Osiclador interno
//MCLREN = Activamos Master Clear
//LVPDIS = Low Voltage Porgramming Desactivado
//DEBUGDIS = Desactiva Debug
//BOR = Desactivado
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 4000000 //Oscilador Interno de 8MHZ
////////////////////////////////////////////////
//Variables Globales
////////////////////////////////////////////////
//unsigned int adc;
float adc;
unsigned char y;
unsigned int word[25];
int lengh;
/////////////////////////////////////////////////
//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=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:
Despus de ver el uso de los canales anlogos, y el modulo LCD, ahora debemos de
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
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.
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
11011111
10111111
01111111
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:
opciones en la pantalla LCD, que nos indique que canal anlogo queremos ver, para la
__CONFIG(UNPROTECT & WDTDIS & PWRTEN & INTIO & MCLREN & LVPDIS);
__CONFIG(DEBUGDIS & BORDIS);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//UNPROTECT = Codigo no Potegido
//WDTDIS = Watch Dog Timer Desactivado
//PWRTEN = Power Activado
//INTIO = Osiclador interno
//MCLREN = Activamos Master Clear
//LVPDIS = Low Voltage Porgramming Desactivado
//DEBUGDIS = Desactiva Debug
//BOR = Desactivado
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 8000000 //Oscilador Interno de 8MHZ
//////////////////////////////////////////////////
//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<100;seg++){
__delay_ms(10);
}
}
///////////////////////////////////////////////////
//FUNCION DE TENER CANAL ANALOGO
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);
case '1':
send_byte(CLEAR);
gotoXYLCD(1,1);
writeRSLCD("CANAL UNO");
//Ver canal Canal analogo 1
while(1){
analogo=LEEADC(1);
gotoXYLCD(1,2);
sprintf(word,"%i Salir(A) ",analogo);
writeSLCD(word);
value=getkey(0);
if(value=='A') break;
}
break;
case '2':
send_byte(CLEAR);
gotoXYLCD(1,1);
writeRSLCD("CANAL DOS");
//Ver canal Canal analogo 2
while(1){
analogo=LEEADC(2);
gotoXYLCD(1,2);
sprintf(word,"%i Salir(A) ",analogo);
writeSLCD(word);
value=getkey(0);
if(value=='A') break;
}
break;
case '3':
send_byte(CLEAR);
gotoXYLCD(1,1);
writeRSLCD("CANAL TRES");
//Ver canal Canal analogo 3
while(1){
puerto (COM) y los baudios, y por supuesto contiene un barra deslizadora que hace la
Para hacer la simulacin correspondiente se tiene otro software sirve para hacer
Puertos virtuales, donde podemos hacer enlaces entre dos programas como puede ser
vez que el programa enva un dato, el proceso que est haciendo en ese momento el
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
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
__CONFIG(UNPROTECT & WDTDIS & PWRTEN & INTIO & MCLREN & LVPDIS);
__CONFIG(DEBUGDIS & BORDIS);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//UNPROTECT = Codigo no Potegido
//WDTDIS = Watch Dog Timer Desactivado
//PWRTEN = Power Activado
//INTIO = Osiclador interno
//MCLREN = Activamos Master Clear
//LVPDIS = Low Voltage Porgramming Desactivado
//DEBUGDIS = Desactiva Debug
//BOR = Desactivado
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 8000000 //Oscilador Interno de 8MHZ
///////////////////////////////////////////////////
//Librerias de trabajo
////////////////////////////////////////////////////
#include"libUSART/usartdr.h" //Libreria creada para uso del usart
#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;
/////////////////////////////////////////////////
//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
}
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.
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
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
por el serial.
la entrada anlogo que vamos a usar, abra el software para conectarlo en el COM
Ahora habr haga o abra la simulacin en proteus, use el COMPIM para simular
__CONFIG(UNPROTECT & WDTDIS & PWRTEN & INTIO & MCLREN & LVPDIS);
__CONFIG(DEBUGDIS & BORDIS);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//UNPROTECT = Codigo no Potegido
//WDTDIS = Watch Dog Timer Desactivado
//PWRTEN = Power Activado
//INTIO = Osiclador interno
//MCLREN = Activamos Master Clear
//LVPDIS = Low Voltage Porgramming Desactivado
//DEBUGDIS = Desactiva Debug
//BOR = Desactivado
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 8000000 //Oscilador Interno de 8MHZ
///////////////////////////////////////////////////
//Librerias de trabajo
////////////////////////////////////////////////////
#include"libUSART/usartdr.h" //Libreria creada para uso del usart
#include"libADC/adcdr.h" //Libreria creada para uso del ADC
////////////////////////////////////////////////
///Variables globales ////////
////////////////////////////////////////////////
unsigned int ADC;
unsigned char send[2];
/////////////////////////////////////////////////
//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=0x01; //RA0=entrada
TRISC=0x80; //RC8=RX,RC7=TX
//Configuracion del USART
OpenUSART(207,OFF,OFF); //value=(FOSC/(baud*16))-1
//No interrupciones
//a 2400 baudios
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
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.
que solo un display ser activado por un cierto tiempo y despus apagara para prender
Para mostrar el numero en el primer display se debe de activar el pin 1 y los demas
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
desbordamiento cada 1mS, teniendo que cambiar al siguiente display, la frmula para
del timer0.
'
$0 = 256 { }
4
(
)
$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
117
= 1667
6
Para el uso de esta interrupcin se usara el timer1 ya que s muy parecido al timer0
$1 = 15550
Este valor es para tener una interrupcin cada 200mS para tener un segundo se debe
1
8= =5
2009
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
Ahora para mostrar los nmeros en los display se debe de contar en cuenta los valores
en el puerto B, como son 6 display entonces se usaran 6 pines del puerto B para
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
__CONFIG(UNPROTECT & WDTDIS & PWRTEN & INTIO & MCLREN & LVPDIS);
__CONFIG(DEBUGDIS & BORDIS);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//UNPROTECT = Codigo no Potegido
//WDTDIS = Watch Dog Timer Desactivado
//PWRTEN = Power Activado
//INTIO = Osiclador interno
////////////////////////////////////////////////
//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
////////////////////////////////////
static void interrupt
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)<32){
PORTB=(PORTB<<1)|0x40;
}else{
PORTB=0x41;
}
T0IF=0;
//Configuramos TIMER0
//Para obtener 1 mS
OpenTIMER0(prescalar_16,ON);
//Interrupcion timpo=(1/(FOSC/4))*preescalar*(256-timer1)
// 1mS=tiempo maximo
// timer0=+256-{tiempo/[(1/(FOSC/4))*preescalar]}
TMR0=131;
OpenTIMER1(pr_8,ON);
//Interrupcion timpo=(1/(FOSC/4))*preescalar*(256-timer1)
// 200mS=tiempo maximo
// timer1=+65536-{tiempo/[(1/(FOSC/4))*preescalar]}
TMR1LOAD(15550);
Recuerde usar en cada Display una conexin de transistor como se muestra abajo:
modificaciones:
Utilizando 4 interruptores.
2.- Despus de realizar lo anterior coloque un sensor de temperatura (LM35) para que
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
Primero que nada hay que saber que es un servo, servo es un pequeo pero potente
motor.
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
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.
Nosotros nos basaremos en las caractersticas que contiene la marca de servos hi tech
como mnimo y 2.1 ms como mximo entonces tenemos un rango de operacin del
servo es de:
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
de tener el servo.
tiempo alto.
1.-Prescalar
Prescalar de 2 para tener un tick cada 0.4uS
'1; =
2.1
5250
0.4
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
= 2250
0.4
'18
Para saber el rango con los que vamos a controlar solamente restamos:
3000 0.4
= 1.2
Ahora debemos de sacar el valor que es necesario para cada grado, es simplemente
dividir:
8: 3000
;:
= = = 16.6666 17
180 180
Entonces se nota que para que gire un grado se debe de tener 17.
Por ejemplo:
50 17 = 850
Pero como sabemos que los tick mnimos son 2250 entonces se lo sumamos:
para que pueda girar el servo a 50 grados, y despus se generara una interrupcin
Para sacar el valor del tiempo bajo simplemente se debe de sacar cuantos tick son
para 20ms:
20
'120
= = 50000
0.4
Al tener este valor se debe de restar 3100 (valor obtenido anteriormente para sacar
tiempo alto)
Y por ultimo este valor se resta a 65536 para despus cargrselo al timer1:
Recuerde que antes de cargarlo se debe de poner el pin en bajo y despus cargar el
En resumen, primero saque el valor para el tiempo alto y bajo, cuando surja la
interrupcin ponga el pin en alto y cargue con el tiempo alto, despus que surja otra
180 grados), el USART debe estar configurado mnimo a 57,600 baud o mximo
115,200 baud.
El programa es el siguiente;
//////////////////////////////////////////////
//Funcion Principal
//////////////////////////////////////////////
void main(void){
CMCON=0x07; //APAGA COMPRADORES INTERNOS
TRISA=0x00;
TRISB=0x02; //RB1=RX,RB2=TX
//Configuracion del USART
OpenUSART(20,OFF,ON); //value=(FOSC/(baud*16))-1
//interrupcion de recepcion activado
//a 57600 baudios
//Configuramos Timer1
OpenTIMER1(pr_2,ON); //Prescalar de 2
//Activamos la interrupcion por timer
TMR1LOAD(tick);
GIE=1; //INTERRUPCIONES GLOBALES DesACTIVADAS
PEIE=1; //DesACTIVA INTERURPCIONES POR PERIFERICOS
while(1){
if(flag==1){
RCIE=0; //Desactiva interrupcion por recepcion del USART
AUX=(POSICION*17)+2200; //AQUI OBTIENES LOS TICK'S~2250
AUXH=65536-AUX; //AQUI OBTIENES EL TIEMPO EN ALTO
SERVOH=AUXH; //ACTUALIZA EL SERVO SELECCIONADO
AUX=50000-AUX; //20ms - (TIEMPO TRANSCURRIDO EN ALTO)
AUXL=65536-AUX; //AQUI OBTIENES EL TIEMPO BAJO
SERVOL=AUXL; //ACTUALIZAS SERVO SELECCIONADO
flag=0;
RCIE=1;
}
}
}
El software que vamos a usar en esta ocasin es Microsoft Visual C# 2010 Express,
este nos servir para realizar nuestras aplicaciones para entornos de Windows, es muy
es cosas sencillas para que usted tenga una nocin de cmo funcionan las cosas.
express y lo bajamos, ten en cuenta que se debe de registrar para poder bajar el
software.
Window form
application
Si deseamos cambiar
el nombre a control de
servo lo podemos
hacer en la parte
inferior. Y despus
falta decirle que tiene que hacer cada cosa, para realizar lo
comunicacin o abrir el puerto, en este caso es COM1 por default si se desea cambiar
Para abrir el puerto haga dos click en el botn conectar, y agregamos la siguiente lnea
Damos F5 para correr programa y veremos con la ayuda de Virtual serial port la
conexin.
podemos cambiar el giro del motor, con un software hecho por nosotros mismos.
pueda conseguir.
Los elementos que vamos a usar del microcontrolador es el modulo PWM, cosa que ya
Si usted desea realizar esta prctica fsicamente puede usar el MAX232 para hacer
conexiones entre PIC y PC via Serial, en las simulacin no se usa el MAX ya que
para simular perfectamente nuestros circuitos, pensando que no se puede hacer esto
sin el MAX232.
__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
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 8000000 //Oscilador Interno de 8MHZ
/////////////////////////////////////////////////
//Librerias de perifericos
/////////////////////////////////////////////////
#include"timer2/timer2.h"//LLama la libreria de usar Timer2
#include"pwmdr/pwm.h"//LLama libreria para usar PWM
#include"libUSART/usartdr.h" //Libreria creada para uso del usart
////////////////////////////////////////////////
///Variables globales ////////
////////////////////////////////////////////////
unsigned int DUTY;
unsigned char uPWM[2];
bit flag=0;
/////////////////////////////////////////////////
//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){
//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;
}
while(1){
//Espera a habilitar
if(flag){
//////////////////////////////////////
//DUTY=0xPWM[1]PWM[0]=16bit
DUTY=(unsigned int)uPWM[1]<<8;
DUTY|=((unsigned int)uPWM[0]&0x00FF);
//////////////////////////////////////
//Cambiamos el duty del PWM
PwmDuty(DUTY);
//
flag=0;
}
}
}
preocupe aqu le diremos lo ms bsico para usted sepa por lo menor hacer interfaces
ventanas abiertas en la pantalla puede presionar <ctrl><t> y listo tendr las dos venta
lo necesario para realizar las practicas con el serial, ms que nada funciones de
lectura.
manualmente lo que nos pide, esta parte nos menciona que hemos creado un control
donde especifica que ah va estar COM disponible del serial, si usted tiene una
computadora casera nota que al presionar el control aparecer los COM disponibles en
while sirve para hacer un ciclo hasta que sea verdad, para
agregamos, hacemos esto para que solo entre una sola vez a la opcin de
presionemos <stop>
por paso (por secuencia una tras otra), la funcin llamada <flat sequence> esta en
agregarlo a la hoja
<while loop> .
regresa a la hoja front panel y agregue un control de numrico el que usted desee, solo
que sea aquel que puede cambiar su valor cuando el usuario desee, y cambie el rango
que tenga el control que haya elegido de 0 a 100, que corresponde a porcentaje, es
actual enviado.
actual. Ahora que ya tenemos los controles de muestra en el front panel, ahora falta
que se encuentra en las funciones del <serial>, esta funcin <write> al encontrarla la
Esto tiene que hacerse ya que permite la opcin de configuracin enviar el puerto
fuera del ciclo <while loop> use una funcin de cerrar puerto que se encuentra tambin
las funciones del <serial> <close>. Esto permite que cuando salgamos del ciclo <while
Si usted se ha dado cuenta es los mismos pasos que cuando realizamos la prctica de
Si sabemos que enviaremos 2 bytes seguidos, y que esos bytes no tendrn el valor del
Enviamos un porcentaje de 50% si sabemos que el valor mximo que debe de tener el
8'=9 8
512
;
100
necesarias.
arreglo para ser convertido a una cadena de caracteres, ya que es lo nico que permite
En la parte frontal se puede realizar algunos arreglos, para que pueda estar mejor
presentado:
labview.
guste, despus abrir otra venta para grabar el archivo, tambin usted escriba el
Ahora nos dirigimos a LLB manager que est ubicado en tools lo abrimos y aparecer
Presionamos dos veces el archivo y nos llevara al proyecto, ahora nos dirigimos a
tools y presionamos la
configuracin de nuestro
ejecutable
su propio icono.
Al terminar solo falta de presionar el botn build y listo, te dir que el ejecutable se
Este proyecto es una matriz de led 8x24, lo que vamos a desarrollar es un contador de
000 a 999, con el cual se usara una de tantas formas de programar una matriz, usando
Fila
Columna
Para:
F1= 0
F2=0
F3=1
Y para las columnas
C=0
C2=1
C3=1
Esto quiere decir que solo va a prender los led que
10000000 ->01000000
00100000
corrimiento de 16 bit.
1er <for> para contar centenas
74HC164 solo use otro pin para 4to <for>para Tener un retardo de 1
Nuestra misin en crear un contador de 5to <for> para mostrar en cada columna
0X00,0X00,0XC4,0XC6,0XFF,0XFF,0XC0,0XC0, //1
0X00,0X00,0XCE,0XE7,0XF3,0XDB,0XCF,0XE6, //2
0X00,0X00,0X42,0XDB,0XDB,0XDB,0XFF,0X7E,//3
0X00,0X10,0XD8,0XDC,0XD6,0XFF,0XFF,0XD8,//4
0X00,0X00,0XCE,0XDF,0XDB,0XDB,0XF3,0X73, //5
0X00,0X00,0X7E,0XFF,0XD3,0XD3,0XF7,0X66, //6
0X00,0X00,0XC3,0XE3,0X73,0X3B,0X1F,0X0F, //7
0X00,0X00,0X66,0XFF,0XDB,0XDB,0XFF,0X66, //8
0X00,0X00,0X4E,0XDF,0XDB,0XDB,0XFF,0X7E}; //9
Curso de Hi-tech Compiler (lite Mode) 2010
__CONFIG(UNPROTECT & WDTDIS & PWRTEN & INTIO & MCLREN & LVPDIS & BORDIS);
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
//UNPROTECT = Codigo no Potegido
//WDTDIS = Watch Dog Timer Desactivado
//PWRTEN = Power Activado
//INTIO = Osiclador interno
//MCLREN = Activamos Master Clear
//LVPDIS = Low Voltage Porgramming Desactivado
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#define _XTAL_FREQ 4000000 //Oscilador Interno de 4MHZ
void config(void);
void SEND_DATA(unsigned char DATA);
void CLEAR(void);
//---------------------------------------------------------
//VARIABLES DONDE SE ENCUENTRA LOS NUMEROS /
//---------------------------------------------------------
const unsigned char ALFA[10][8]={0X00,0X3C,0X7E,0XC3,0XC3,0XC3,0X7E,0X3C, //0
0X00,0X00,0XC4,0XC6,0XFF,0XFF,0XC0,0XC0, //1
0X00,0X00,0XCE,0XE7,0XF3,0XDB,0XCF,0XE6, //2
0X00,0X00,0X42,0XDB,0XDB,0XDB,0XFF,0X7E, //3
0X00,0X10,0XD8,0XDC,0XD6,0XFF,0XFF,0XD8, //4
0X00,0X00,0XCE,0XDF,0XDB,0XDB,0XF3,0X73, //5
0X00,0X00,0X7E,0XFF,0XD3,0XD3,0XF7,0X66, //6
0X00,0X00,0XC3,0XE3,0X73,0X3B,0X1F,0X0F, //7
0X00,0X00,0X66,0XFF,0XDB,0XDB,0XFF,0X66, //8
0X00,0X00,0X4E,0XDF,0XDB,0XDB,0XFF,0X7E}; //9
//---------------------------------------------------------
//VARIABLES A USAR EN EL PROYECTO /
//---------------------------------------------------------
void main(void){
config(); //Configuramos puertos
RESET=1;
//Ya que el 74HC164 contiene un pin de reset que puede ir directamente
//al POSITIVO pero se puede poner directo al micro para manipular
//el encendido y apagado de la matriz
CLEAR();
//Al inicializar la matriz apagada
overload=113;
//1mS*8=8mS para un segundo=113
//Con la ayuda de MPLAB SIM se puede apreciar el un retardo de
//993.837uS~1Seg
SEND_DATA(1);
//Al inicializar la matriz se envia el dato para proceder a vizualizar
//cada numero.
//Se puede decir que este incio es muy importante
GIE=0;
}
//---------------------------------------------------------
//FUNCION DE TE PERIMITE ENVIAR UN CERO O UNO /
//---------------------------------------------------------
//----------------------------------------------------------
//FUNCION DE BORRADO
/
//----------------------------------------------------------
void CLEAR(void){
for(MAX=1;MAX<=24;MAX++){ //24 ES EL MAXIMO DE->
SEND_DATA(0); //->COLUMNAS
}
}
Gracias!
Gracias!
microcontroladores picmicro.
george.manson.69@gmail.com
Copyright 2010