17/03/2 0014 Manual Practicas Pic en C JOSE ANTONIO LINERO MADRID SALESIANOS ,MALAGA 17/03/20014 INDICE 1. Parpadeo de un led cada 0.5 seg. 2. Parpadeo de tres led cada 0.5 seg. 3. Parpadeo de cuatro led cada 0.5 seg. 4. Coche fantástico v1. 5. Juego de luces. 6. Contador ascendente. 7. Contador 0 a 9 BCD&Boton. 8. Súper contador 0000a9999 (7 seg.) 9. Dado digital (7 seg). 10. Hola Mundo (Lcd). 11. Abecedario (Lcd). 12. Dado digital (Lcd). 13. Reloj-Calendario Rs232. 14. Termómetro Digital con ds1620. Herramientas • • • • • • • MPlab IDE -> Entorno de trabajo CCS Plug-in MPlab -> Integrar nuestro compilador CCS al entrono MPlab CCS Demo -> Una version demo de nuestro compilador Manual CCS -> Manual de nuestro compilador en español 7Seg -> Programa que genera el codigo de display"s 7segmentos(ac & cc) LCD 5x7 -> Programa que genera codigo para caracteres cgram LCD 5x7 ASCII & RCC -> Programas para obtener codigo ASCII y RCC para colores resistor 1. Parpadeo de un led cada 0.5 seg. //Programa: Parpadeo de un led cada 0.5s //Version: 0.0 // //Dispositivo: PIC 16F648A Compilador: CCS vs3.227 //Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3 // //Notas: Parpadeo de un led cada 0.5s por el pin RB0 del puerto B ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOWDT,NOPROTECT,PUT //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz #use fast_io(b) ///PROGRAMA void main(void) { set_tris_b(0xFE); //portb como salida(RB0,las demas desactivadas) disable_interrupts(GLOBAL); //todas las interrupciones desactivadas do{ output_low(PIN_B0); //led off delay_ms(500); output_high(PIN_B0); //led on delay_ms(500); }while(TRUE); //bucle infinito } 2. Parpadeo de tres led cada 0.5 seg. //Programa: Parpadeo de tres leds cada 0.5s //Version: 0.1 // //Dispositivo: PIC 16F648A Compilador: CCS vs3.227 //Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3 // //Notas: Parpadeo de tres leds cada 0.5s de tres formas diferentes: // RB0 -> con la funcion output_high()/output_low() // RB1 -> definiendo el pin RB1 // RB2 -> con la funcion output_bit() ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOCPD,NOWDT,NOPUT,NOLVP,NOBROWNOUT //ordenes programador #use delay (clock=4000000) //Fosc=4Mhz #use fast_io(b) #bit RB1=0x106.1 //definicion pin potrb B1 ///PROGRAMA void main(void) { set_tris_b(0xF8); //puerto b como salida disable_interrupts(GLOBAL); //todas interrupciones desactivadas RB1=0; //valor inicial B1 para que los led"s se iluminen igual do{ output_high(PIN_B0); //led"s on RB1=!RB1; output_bit(PIN_B2,1); delay_ms(500); output_low(PIN_B0); //led"s off RB1=!RB1; output_bit(PIN_B2,0); delay_ms(500); }while(TRUE); //bucle infinito } 3. Parpadeo de cuatro led cada 0.5 seg // Programa: Parpadeo de cuatro leds cada 0.5s // Version: 0.2 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.227 // Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3 // // Notas: Parpadeo de cuatro leds cada 0.5s de cuatro formas diferentes: // RB0 -> con la funcion output_high()/output_low() // RB1 -> definiendo el pin RB1 // RB2 -> con la funcion output_bit() // RB3 -> con la funcion bit_set()/bit_clear() ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOCPD,NOWDT,NOPUT,NOLVP,NOBROWNOUT //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz #use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3) //pin de salida portb #bit RB1=0x106.1 //definicion pin potrb B1 #byte portb=06 ///PROGRAMA void main(void) { set_tris_b(0x00); //puerto b como salida disable_interrupts(GLOBAL); //todas interrupciones desactivadas RB1=0; //valor inicial B1 para que los led"s se iluminen igual do{ output_high(PIN_B0); //led"s on RB1=!RB1; output_bit(PIN_B2,1); bit_set(portb,3); delay_ms(500); output_low(PIN_B0); //led"s off RB1=!RB1; output_bit(PIN_B2,0); bit_clear(portb,3); delay_ms(500); }while(TRUE); //bucle infinito } 4. Coche fantástico v1. // Programa: Coche Fantastico // Version: 0.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.227 // Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3 // // Notas: Barrido de led"s simulando la iluminacion del coche fantastico por el // puerto A // // RA0 -> 1º Led // RA1 -> 2º Led // RA2 -> 3º Led // RA3 -> 4º Led ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOWDT,NOPROTECT,PUT //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz #use standard_io(A) //puerto A como salida ///DECLARACIONES DE FUNCIONES void derecha(void); //ilumina led"s derecha a izquierda void izquierda(void); //ilumina led"s izquierda a derecha ///PROGRAMA void main(void) { set_tris_a(0xF0); //porta como salida menos RA4(desactivado) disable_interrupts(GLOBAL); //todas las interrupciones desactivadas do{ //bucle... derecha(); izquierda(); }while(TRUE); //...infinito } void derecha(void) { output_high(PIN_A0); delay_ms(300); output_low(PIN_A0); output_high(PIN_A1); delay_ms(300); output_low(PIN_A1); output_high(PIN_A2); delay_ms(300); output_low(PIN_A2); output_high(PIN_A3); delay_ms(300); } void izquierda(void) { output_low(PIN_A3); output_high(PIN_A2); delay_ms(300); output_low(PIN_A2); output_high(PIN_A1); delay_ms(300); output_low(PIN_A1); } 5. Juego de luces // Programa: Juego de luces // Version: 0.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.227 // Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3 // // Notas: Iluminacion de juego de luces fuera-dentro y viceversa por el puerto B. // Adaptacion a c por vszener del codigo en basic de lordlafebre. // // RB0 -> 1º Led // RB1 -> 2º Led // RB2 -> 3º Led // RB3 -> 4º Led // RB4 -> 5º Led // RB5 -> 6º Led // RB6 -> 7º Led // RB7 -> 8º Led ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz #use standard_io(B) //puerto B ///PROGRAMA void main(void) { signed char i; //variable indice int leds[4]={0b10000001,0b01000010,0b00100100,0b00011000}; //led"s set_tris_b(0x00); //portb como salida disable_interrupts(GLOBAL); //todas las interrupciones desactivadas do{ //bucle... for(i=0;i<4;i++){ //led"s on fuera-dentro output_b(leds[ i ]); //ilumino led"s correspondientes delay_ms(100); } for(i=3;i>-1;i--){ //led"s on dentro-fuera output_b(leds[ i ]); //ilumino led"s correspondientes delay_ms(100); } }while(TRUE); } //...infinito 6. Contador ascendente. // Programa: Contador ascendente 0-9 // Version: 0.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.227 // Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3 // // Notas: Contador del 0 al 9 cada 0,5s y vuelta a empezar. Tener en cuenta // que hay que poner la directiva NOLVP para que el pin B4 sea de salida ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz #use standard_io(B) ///PROGRAMA void main(void) { char i=0; //contador para tabla 7 seg int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67}; //7seg hex 0-9 set_tris_b(0x00); //portb como salida disable_interrupts(GLOBAL); //todas las interrupciones desactivadas do{ //bucle... output_b(tab7seg[ i ]); //muestra por portb digito 7 segmentos delay_ms(500); i++; //incremento contador para visualizar siguiente digito if(i>9) //¿ya se ha mostrado el digito 9? { i=0; //SI -> vuelve a empezar(digito 0) } }while(TRUE); //...infinito } 7. Contador 0 a 9 BCD&Boton. // Programa: Contador 0-9 display BDC & Boton // Version: 0.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.227 // Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3 // // Notas: Contador 0 al 9 cada vez que pulsemos el boton y vuelta a empezar. Tener // en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de // salida. Cuando agregamos un boton a nuestro circuito hay que tener en cuenta // que este dispositivo genera 'rebotes' que hay que ser eliminados para // una correcta visualizacion en el display del digito seleccionado. Esta vez // la eliminacion de 'los rebotes' se ha realizado mediante software. // Cuando por el pin A0 del porta se introduce un '0' logico(low), se // incrementa un digito en el display BCD. // // Conexiones: A0 -> boton // B0 -> a // B1 -> b // B2 -> c // B3 -> d // BCD: // d c b a NUM // 0000 0 // 0001 1 // 0010 2 // 0011 3 // 0100 4 // 0101 5 // 0110 6 // 0111 7 // 1000 8 // 1001 9 ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz #use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3) #use standard_io(A) ///PROGRAMA void main(void) { char i=0; //contador para tabla BCD int tabBCD[10]={0b0000,0b0001,0b0010,0b0011,0b0100,0b0101,0b0110,0b0111,0b1000,0b1001}; //BCD 0-9 set_tris_a(0xFF); disable_interrupts(GLOBAL); //porta como entrada //todas las interrupciones desactivadas output_b(tabBCD[i]); //inicializa displayBCD digito 0 for(;;){ if(!input(PIN_A0)) { delay_ms(151); //bucle... //¿se ha pulsado el boton? //SI -> retardo para evitar los rebotes i++; //incremento contador if(i>9) //¿se ha mostrado digito indice tabBCD 9? i=0; //SI -> restaura valor indice(para mostrar digito 0) output_b(tabBCD[i]); //muestra por portb digito 7 segmentos } } } //...infinito 8. Súper contador 0000a9999 (7 seg.) // Programa: Contador del 0000 al 9999 // Version: 0.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.227 // Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3 // // Notas: Contador del 0000 al 9999 cada 1s y vuelta a empezar. Tener en cuenta // que hay que poner la directiva NOLVP para que el pin B4 sea de salida. // Se utiliza variables locales: // * i -> indice tabla 7seg para mostrar digito por 1º 7seg // * j -> indice tabla 7seg para mostrar digito por 2º 7seg // * w -> indice tabla 7seg para mostrar digito por 3º 7seg // * z -> indice tabla 7seg para mostrar digito por 4º 7seg // * flag -> variable que cuenta 1s // * var -> ajuste fino para que desborde cada segundo // Utilizamos la funcion de interrupcion para actualizar indices de la // tabla de 7seg para mostrar el digito correspondiente en el respectivo // 7seg, para ello el TMR0 se desborda cada 1s, para ello debe ser cargado // con 61(equivale a un desbordamiento cada 50ms mas o menos), para obtener // un desbordamiento de 1s utilizamos una variable(flag) que no entra en // la actualizacion de indices hasta transcurrido 1s. // Conexiones: // · RA0 -> Display 1º 7seg // · RA1 -> Display 2º 7seg // · RA2 -> Display 3º 7seg // · RA3 -> Display 4º 7seg // · RB0 -> a 7seg // · RB1 -> b 7seg // · RB2 -> c 7seg // · RB3 -> d 7seg // · RB4 -> e 7seg // · RB5 -> f 7seg // · RB6 -> g 7seg ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz #use standard_io(B) #use fixed_io(a_outputs=PIN_A0,PIN_A1,PIN_A2,PIN_A3) //A0,A1,A2,A3 como salidas en porta char i=0,j=0,w=0,z=0,flag=0,var=20; //variables globales ///LLAMADA FUNCION INTERRUPCION #INT_TIMER0 void interrupcion() { if(flag>var){ //¿ya es 1 segundo? var--; //SI -> decremento var... if(var<18) var=20; //...ajuste fino de 1s flag=0; //reset flag para contar 1s if(i>Cool{ //¿se ha mostrado por 1º 7seg digito 9? i=0; //SI -> i=0 (muestra digito 0) (*) j++; //incremento indice j if(j>9){ //¿se ha mostrado por 2º 7seg digito 9? j=0; //SI -> j=0 (muestra digito 0) w++; //incremento indice w if(w>9){ //¿se ha mostrado por 3º 7seg digito 9? w=0; //SI -> w=0 (muestra digito 0) z++; //incremento indice z if(z>9) //¿se ha mostrado por 4º 7seg digito 9? z=0; //SI -> z=0 (muestra digito 0) } } } else{ //(*) NO -> incrementa i i++;} } set_timer0(61); //reset TMR0 flag++; //incremento variable flag } ///PROGRAMA void main(void) { int tab7seg[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67}; //7seg hex 0-9 set_tris_b(0x00); //portb como salida enable_interrupts(INT_TIMER0); //interrupcion TIMER0 activada setup_counters(RTCC_INTERNAL,RTCC_DIV_256); //configuracion interrupcion TMR0 set_timer0(61); //carga TMR0 enable_interrupts(GLOBAL); //activadas interrupciones do{ //bucle... output_high(PIN_A0); output_high(PIN_A1); output_high(PIN_A2); output_low(PIN_A3); output_b(tab7seg[ i ]); delay_ms(10); output_high(PIN_A0); output_high(PIN_A1); output_low(PIN_A2); output_high(PIN_A3); output_b(tab7seg[ j ]); delay_ms(10); //activado... //...1º 7seg //activado... //...2º 7seg output_high(PIN_A0); output_low(PIN_A1); //activado... output_high(PIN_A2); output_high(PIN_A3); output_b(tab7seg[ w ]); //...3º 7seg delay_ms(10); output_low(PIN_A0); //activado... output_high(PIN_A1); output_high(PIN_A2); output_high(PIN_A3); output_b(tab7seg[ z ]); //...4º 7seg delay_ms(10); }while(TRUE); //...infinito } 9. Dado digital (7 seg). // Programa: Dado digital // Version: 0.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.227 // Entorno IDE: MPLAB IDE v7.20 Simulador: Proteus 6.7sp3 // // Notas: Dado digital, que al presionar el boton conectado al pin A0 del porta // genera un numero pseudo-aleatorio mediante la funcion rand() que se // encuentra en la libreria STDLIB.H. El numero pseudo-aleatorio es elegido // mediante la funcion rand() y segun los "rebotes" producidos por el boton.Tener // en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de // salida. Cuando agregamos un boton a nuestro circuito hay que tener en cuenta // que este dispositivo genera "rebotes" que hay que ser eliminados para // una correcta visualizacion en el display del digito seleccionado. Esta vez // la eliminacion de "los rebotes" se ha realizado mediante software. // // Conexiones: A0 -> boton // B0 -> a // B1 -> b // B2 -> c // B3 -> d // BCD: // d c b a NUM // 0000 0 // 0001 1 // 0010 2 // 0011 3 // 0100 4 // 0101 5 // 0110 6 // 0111 7 // 1000 8 // 1001 9 ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #include <STDLIB.H> //libreria donde esta la funcion rand(); #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz #use fixed_io(b_outputs=PIN_B0,PIN_B1,PIN_B2,PIN_B3) #use standard_io(A) ///PROGRAMA void main(void) { char num=0; set_tris_a(0xFF); //variable almacena numero aleatorio //porta como entrada disable_interrupts(GLOBAL); //todas las interrupciones desactivadas srand(10); //maximo hasta 9 for( ; ; ){ //bucle... if(!input(PIN_A0)) //¿se ha pulsado el boton? { do{ //elimina... num=rand(); //genera numero pseudo-aleatorio }while(!input(PIN_A0)); //...rebotes } output_b(num); //muestra por portb digito 7 segmentos } //...infinito } 10. Hola Mundo (Lcd). // Programa: Hola mundo // Version: 0.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.227 // Entorno IDE: MPLAB IDE v7.21 Simulador: Proteus 6.7sp3 // // Notas: Se muestra por pantalla de lcd(LM016L) en la primera linea la // frase "hola mundo Giño" y en la segunda linea "VsZeNeR"05". Tener // en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de // salida. // // Conexiones: B0 -> E // B1 -> RS // B2 -> RW // B4 -> D4 // B5 -> D5 // B6 -> D6 // B7 -> D7 ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz #define use_portb_lcd TRUE //definir portb lcd #include<lcd.c> //libreria manejo lcd ///PROGRAMA void main(void) { lcd_init(); //inicializa lcd printf(lcd_putc,"hola mundo ; ) VsZeNeR"05" ); //muestra por pantalla el mensaje } 11. Abecedario (Lcd). // Programa: Abecedario // Version: 0.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.227 // Entorno IDE: MPLAB IDE v7.21 Simulador: Proteus 6.7sp3 // // Notas: Se muestra por pantalla de lcd(LM016L) el abecedario y vuelta a empezar // Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de // salida. // ·abecedario[] -> vector donde se almacena abecedario // ·x -> indice para vector abecedario e indice para columna lcd // ·y -> indice para fila lcd: y=1 -> Fila 1 // y=2 -> Fila 2 // Conexiones: B0 -> E // B1 -> RS // B2 -> RW // B4 -> D4 // B5 -> D5 // B6 -> D6 // B7 -> D7 ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz #define use_portb_lcd TRUE //definir portb lcd #include<lcd.c> //libreria manejo lcd ///PROGRAMA void main(void) { char abecedario[27]={" ","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y"," z"},x,y=1; //tabla y variables definidas lcd_init(); //inicializa lcd do{ //bucle... for(x=1;x<27;x++){ //bucle para mostrar digito if(y==1) //1º fila del lcd lcd_gotoxy(x,y); else //2º fila del lcd lcd_gotoxy((x-16),y); if(x>15) y=2; //¿ya esta completa la 1º fila del lcd? //SI -> escribe en 2º fila printf(lcd_putc,"%c",abecedario[ x ]); //muestra por pantalla el caracter delay_ms(300); } printf(lcd_putc,"f " ) ; //borra pantalla del lcd y=1; //restablece indice }while(TRUE); //...infinito } 12. Dado digital (Lcd). // Programa: Dado digital con lcd y buzzer // Version: 0.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.227 // Entorno IDE: MPLAB IDE v7.21 Simulador: Proteus 6.7sp3 // // Notas: Dado digital, que al presionar el boton conectado al pin A0 del porta // genera un numero pseudo-aleatorio mediante la funcion rand() que se // encuentra en la libreria STDLIB.H. El numero pseudo-aleatorio es elegido // mediante la funcion rand() y segun los "rebotes" producidos por el boton.Tener // en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de // salida. Cuando agregamos un boton a nuestro circuito hay que tener en cuenta // que este dispositivo genera "rebotes" que hay que ser eliminados para // una correcta visualizacion en la lcd del digito seleccionado. Esta vez // la eliminacion de "los rebotes" se ha realizado mediante software. // // Conexiones: A0 -> boton // B0 -> E // B1 -> RS // B2 -> RW // B4 -> D4 // B5 -> D5 // B6 -> D6 // B7 -> D7 // B3 -> Buzzer(beep) ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #define RAND_MAX 7 //dado solamente 6 numeros #include <STDLIB.H> //libreria donde esta la funcion rand(); #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador #use delay (clock=4000000) //Fosc=4Mhz #use standard_io(B) #use fast_io(A) #define use_portb_lcd TRUE //definir portb lcd #include<lcd.c> //libreria manejo lcd ///PROGRAMA void main(void) { char num=0; //variable almacena numero aleatorio set_tris_a(0xFF); //porta como entrada disable_interrupts(GLOBAL); //todas las interrupciones desactivadas lcd_init(); //inicializa lcd srand(10); //maximo hasta 9 lcd_putc("Dado Electronico Pulse boton..." ); while(input(PIN_A0)){} lcd_putc("fDado: VsZeNeR"05" ); lcd_gotoxy(7,1); //Se mantiene cabecera hasta que se pulse el boton //Coordenadas dond se muestra el numero for( ; ; ){ //bucle... if(!input(PIN_A0)) //¿se ha pulsado el boton? { do{ //SI -> elimina... num=rand(); //genera numero pseudo-aleatorio }while(!input(PIN_A0)); //...rebotes printf(lcd_putc,"%d",num); //muestra por lcd numero lcd_putc("" ); //retrocede un espacio output_high(PIN_B3); //activa buzzer(beep) delay_ms(50); //tiempo de escucha del beep output_low(PIN_B3); //desactiva buzzer(beep) } } } //...infinito 13. Reloj-Calendario Rs232 // Programa: Reloj-Calendario DS1302 y RS232 // Version: 1.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.227 // Entorno IDE: MPLAB IDE v7.21 Simulador: Proteus 6.7sp3 // // Notas: Se muestra por virtual terminal la fecha y hora obtenida mediante la // lectura del DS1302. Pudiendose modificar mediante los botones Conf/Ok y up. // Se utiliza variables globales: // ·day-> dia ds1302 // ·mth -> mes ds1302 // ·year -> año ds1302 // ·hour -> hora ds1302 // ·min -> minutos ds1302 // ·sec-> segundos ds1302 // ·menu -> variable que muestra opcion del menu configurar // ·flag -> variable que cuenta hasta 130ms aprox./ tb vale como control menu // ·var -> ajuste fino para que desborde cada 130ms aprox. // Se carga el TMR0 con 0 por lo tanto se desborda en 65ms aprox, queremos // visualizar y restaurar valores cogidos del ds1302 cada 130ms aprox por lo tanto // utilizamos una variable llamada flag que sera la encargada de dicha tarea. // Al inicio del programa debe ser configurado el reloj, siendo el boton "up" el // encargado de ir moviendose mediante las opciones del menu:hora,minutos,.... // y el boton "Conf/Ok" el encargado de configurar el reloj(cuando estemos en modo ver // hora y fecha) o el encargado de salir de la configuracion de las opciones(cuando // estemos en formato de configurar fecha y hora). // Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de // salida. // Conexiones: A0 -> RST DS1302 // A1 -> SCLK DS1302 // A2 -> I/O DS1302 // A3 -> Boton "up" // A5 -> Boton "Conf/Ok" // B1 -> Tx // B2 -> Rx // B3 -> Zumbador(beep) ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #use delay(CLOCK=4000000) //Fosc=4Mhz #fuses HS,NOPUT,NOPROTECT,NOBROWNOUT,NOLVP,NOWDT,NOMCLR //comandos para el programador #use standard_io(a) #use standard_io(b) #use rs232(baud=9600, xmit=PIN_B1, rcv=PIN_B2, FORCE_SW) //manejo del RS232 #define RTC_SCLK PIN_A1 //definimos pin"s... #define RTC_IO PIN_A2 #define RTC_RST PIN_A0 //...de conexion de la rtc ds1302 #include <ds1302.c> //libreria de rtc ds1302 ///VARIABLES GLOBALES byte day,mth,year,dow,hour,min,sec; //variabes para ds1302 byte menu=0,flag=0,var=2; //variables para menu configurar ///DEFINICION DE FUNCIONES void configurar(void); void horas(void); void minutos(void); void dia(void); void mes(void); void anio(void); void beep(void); ///LLAMADA FUNCION INTERRUPCION #INT_TIMER0 void interrupcion() { if(flag>var){ //¿ya es 130ms aprox? var--; //SI -> decremento var... if(var==0) var=2; //...ajuste fino de 130ms aprox flag=0; //reset flag para contar 130ms aprox rtc_get_date(day,mth,year,dow); //coge dia,mes,año rtc_get_time(hour,min,sec ); //coge hora,minuto,segundo printf("fFecha: %2X/%2X/%2X Hora: %2X:%2X:%2X",day,mth,year,hour,min,sec); //lcd } set_timer0(0); //reset TMR0 flag++; //incremento variable flag } ///PROGRAMA void main(void){ enable_interrupts(INT_TIMER0); //interrupcion TIMER0 activada setup_counters(RTCC_INTERNAL,RTCC_DIV_256); //configuracion interrupcion TMR0 set_timer0(0); //carga TMR0 rtc_init(); //inicializa rtc puts("Reloj Calendario" ); puts("VsZeNeR"05" ); delay_ms(800); //...inicial configurar(); //ve a menu configurar enable_interrupts(GLOBAL); //activadas interrupciones for( ; ; ){ //bucle... if(input(PIN_A5)==0){ //Si se pulsa Conf.... while(!input(PIN_A5)){} //elimina rebotes beep(); configurar(); } //ve a menu configurar } //...infinito } ///FUNCION CONFIGURAR void configurar(void){ disable_interrupts(GLOBAL); //desactivadas interrupciones do{ switch(menu){ case 0: printf("fConfigurar horas?" ); //horas if(!input(PIN_A5)){ while(!input(PIN_A5)){} beep(); horas(); menu=1; //apunta siguiente opcion flag=1; //para el retorno funcion ver sig } break; case 1: printf("fConfigurar minutos?" ); //minutos if(!input(PIN_A5)){ while(!input(PIN_A5)){} beep(); minutos(); menu=2; //apunta siguiente opcion flag=1; //para el retorno funcion ver sig } break; case 2: printf("fConfigurar dia?" ); //dias if(!input(PIN_A5)){ while(!input(PIN_A5)){} beep(); dia(); menu=3; //apunta siguiente opcion flag=1; //para el retorno funcion ver sig } break; case 3: printf("fConfigurar mes?" ); //mes if(!input(PIN_A5)){ while(!input(PIN_A5)){} beep(); mes(); menu=4; //apunta siguiente opcion flag=1; //para el retorno funcion ver sig } break; case 4: printf("fConfigurar año?" ); //años if(!input(PIN_A5)){ while(!input(PIN_A5)){} beep(); anio(); menu=5; //apunta siguiente opcion flag=1; //para el retorno funcion ver sig } break; case 5: printf("fSalir configurar?" ); //salir configuracion if(!input(PIN_A5)){ while(!input(PIN_A5)){} //elimina rebotes menu=6; flag=1; beep(); } } do{ //controla pulsador... if(!input(PIN_A3)){ while(!input(PIN_A3)){} menu++; flag++; if(menu>5) menu=0; } if(!input(PIN_A5)) //controla pulsador... flag++; //..."Conf/Ok" }while(!flag); //.."Up" flag=0; }while(menu<6); menu=0; //actualiza indices menu rtc_set_datetime(day,mth,year,dow,hour,min); //nueva hora,minuto,... enable_interrupts(GLOBAL); //activadas interrupciones set_timer0(0); //carga TMR0 } ///FUNCION CONFIGURA HORAS void horas(void){ printf("fConf.Horas: Hora: %2X:%2X:%2X",hour,min,sec); //muestra por v.terminal do{ if(!input(PIN_A3)){ //¿se ha pulsado up? while(!input(PIN_A3)){} //elimina rebotes hour++; //SI -> incremento hour switch(hour){ //limites... case 0x0A: hour=0x10;break; case 0x1A: hour=0x20;break; case 0x24: hour=0x00; } //...hour printf(" Hora: %2X:%2X:%2X",hour,min,sec); //muestra por v.terminal } }while(input(PIN_A5)); while(!input(PIN_A5)){} //elimina rebotes } ///FUNCION CONFIGURA MINUTOS void minutos(void){ printf("fConf.Minutos: Hora: %2X:%2X:%2X",hour,min,sec); //muestra por v.terminal do{ if(!input(PIN_A3)){ //¿se ha pulsado up? while(!input(PIN_A3)){} //elimina rebotes min++; //SI -> incremento min switch(min){ //limites... case 0x0A: min=0x10;break; case 0x1A: min=0x20;break; case 0x2A: min=0x30;break; case 0x3A: min=0x40;break; case 0x4A: min=0x50;break; case 0x5A: min=0x00; } //...min printf(" Hora: %2X:%2X:%2X",hour,min,sec); //muestra por v.terminal } }while(input(PIN_A5)); while(!input(PIN_A5)){} //elimina rebotes } ///FUNCION CONFIGURA DIAS void dia(void){ printf("fConf.Dias: Fecha: %2X/%2X/%2X",day,mth,year); //muestra por v.terminal do{ if(!input(PIN_A3)){ //¿se ha pulsado up? while(!input(PIN_A3)){} //elimina rebotes day++; //SI -> incremento day switch(day){ //limites... case 0x0A: day=0x10;break; case 0x1A: day=0x20;break; case 0x2A: day=0x30;break; case 0x32: day=0x01; } //...day printf("fConf.Dias: Fecha: %2X/%2X/%2X",day,mth,year); //muestra por v.terminal } }while(input(PIN_A5)); while(!input(PIN_A5)){} //elimina rebotes } ///FUNCION CONFIGURA MES void mes(void){ printf("fConf.Mes: Fecha: %2X/%2X/%2X",day,mth,year); //muestra por v.terminal do{ if(!input(PIN_A3)){ //¿se ha pulsado up? while(!input(PIN_A3)){} //elimina rebotes mth++; //SI -> incremento mth switch(mth){ //limites... case 0x0A: mth=0x10;break; case 0x13: mth=0x01; } //...mth printf("fConf.Mes: Fecha: %2X/%2X/%2X",day,mth,year); //muestra por v.terminal } }while(input(PIN_A5)); while(!input(PIN_A5)){} //elimina rebotes } ///FUNCION CONFIGURA AÑOS void anio(void){ printf("fConf.Año: Fecha: %2X/%2X/%2X",day,mth,year); //muestra por v.terminal do{ if(!input(PIN_A3)){ //¿se ha pulsado up? while(!input(PIN_A3)){} //elimina rebotes year++; //SI -> incremento mth switch(year){ //limites... case 0x0A: year=0x10;break; case 0x1A: year=0x20;break; case 0x2A: year=0x30;break; case 0x3A: year=0x40;break; case 0x4A: year=0x50;break; case 0x5A: year=0x60;break; case 0x6A: year=0x70;break; case 0x7A: year=0x80;break; case 0x8A: year=0x90;break; case 0x9A: year=0x00; } //...year printf("fConf.Año: Fecha: %2X/%2X/%2X",day,mth,year); //muestra por v.terminal } }while(input(PIN_A5)); while(!input(PIN_A5)){} //elimina rebotes } ///FUNCION BEEP void beep(void){ output_high(PIN_B3); //activa zumbador delay_ms(50); output_low(PIN_B3); //desactiva zumbador } 14. Termómetro Digital con ds1620. // Programa: Termometro digital mediante el ds1620 // Version: 1.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.249 // Entorno IDE: MPLAB IDE v7.31 Simulador: Proteus 6.7sp3 // // Notas: Este programa muestra por el hyperterminal la temperatura leida // del dispositivo ds1620. // // Conexiones: A0 -> DQ ds1620 // A1 -> CLK/CONV# ds1620 // A2 -> RST# ds1620 ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP #fuses INTRC #use delay (clock=4000000) #use rs232(baud=9600,xmit=PIN_B2,rcv=PIN_B1) #define DS1620_DQ PIN_A0 #define DS1620_CLK PIN_A1 #define DS1620_RST PIN_A2 #include <vs_ds1620.c> //pic a utilizar //ordenes para el programador //oscilador interno //Fosc=4Mhz //manejo del RS232 //declaracion... //...de pines para el ds1620 //libreria ds1620 ///LLAMADA FUNCION INTERRUPCION #INT_TIMER1 void interrupcion() //leemos la temp y la enviamos via serial rs232 al hyperterminal { printf("\fVsZeNeR'06 -> Termometro Digital\n\r\n\rTemperatura: %3.1f ºC",read_ds1620()); } ///PROGRAMA void main(void) { setup_oscillator(OSC_4MHZ); del oscilador interno a 4MHz enable_interrupts(INT_TIMER1); activada SETUP_TIMER_1(T1_INTERNAL|T1_DIV_BY_8); interrupcion TMR1 set_timer1(10); TMR1 enable_interrupts(GLOBAL); interrupciones setup_uart(TRUE); //activamos la uart //configuracion //interrupcion TIMER1 //configuracion //carga //activadas for(;;){} } //bucle infinito -> espera interrupcion del TMR1