CCS C Uygulamalarının neredeyse tümü PIC16F648 ile yapılmış 2 tane PIC16F628 ile isis Simülasyon dosyaları C ve HEX Kodları var PIC C ile programla yapan yada öğrenmeye çalışan kişiler için güzel bir kaynak çok çeşitli devreler var Derleyici olarak CCS C Kullanılmış rs232, keypad, lcd,display, eeprom, sayıcı, pwm vb. basit devreler üzerine kurulu bir sürü örnek dosyaları
Aşağıda ugulamalardan bir kaç örnek ve listesi bulunmakta
PIC16F628 ile Led yak söndür
//////////////////////////////////////////////////////////////////////////////////// // VsZeNeR'04 // 14/Agosto/05 // [email protected] // Programa: Parpadeo de un led cada 0.5s // Version: 0.0 revision del 16F648a // // Dispositivo: PIC 16F628A 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 <16f628a.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 }
PIC16F648A ile Kayan Ledler
//////////////////////////////////////////////////////////////////////////////////// // VsZeNeR'04 // 14/Agosto/05 // [email protected] // Programa: Coche Fantastico // Version: 2.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 B. Adaptacion 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 // En la variable cont se va almacenando los valores 1-2-4-8-16-32-64-128 // que en binario corresponden a la secuencia 00000001-00000010-00000100... // son los led's a iluminar, coincidiendo con la secuencia de iluminacion // del coche fantastico(version Ecuatoriana: auto fantastico) ////////////////////////////////////////////////////////////////////////////////// #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 como salida ///PROGRAMA void main(void) { int i,cont; //variables definidas set_tris_b(0x00); //portb como salida disable_interrupts(GLOBAL); //todas las interrupciones desactivadas do{ //bucle... cont=1; //inicializar... for(i=1;i<8;i++){ //led's on derecha output_b(cont); //ilumino led correspondiente delay_ms(100); cont=cont*2; } for(i=1;i<8;i++){ output_b(cont); //ilumino led correspondiente delay_ms(100); cont=cont/2; } }while(TRUE); //...infinito }
PIC16F648A ile Led bar Display Uygulaması
//////////////////////////////////////////////////////////////////////////////////// // VsZeNeR'05 // 8/Noviembre/05 // [email protected] // Programa: Led's & display 7seg andodo comun // Version: 0.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.236 // Entorno IDE: MPLAB IDE v7.22 Simulador: Proteus 6.7sp3 // // Notas: Este programa muestra como incorporar codigo ASM en nuestro programa en C. // Los modulos en asm manejan lso perifericos(uno es una barra de led's, se // iluminan hasta 4 led's de forma consecutiva y vuelta a empezar, y el otro // maneja un contador ascendente bcd de 0a9 y vuelta a empezar). Se usa los // perifericos decodificador 4555 y bcd-7seg 74247. // Conexiones: A0 -> A 4555 DEC // A1 -> B 4555 DEC // B4 -> A 74247/Led D1 // B5 -> B 74247/Led D2 // B6 -> C 74247/Led D3 // B7 -> D 74247/Led D4 ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador #fuses INTRC //oscilador interno #use delay (clock=4000000) //Fosc=4Mhz #use fast_io(a) #use fast_io(b) #byte PORTB=0x06 //definicion del PORTB #byte STATUS=0x03 //definicion del STATUS ///PROGRAMA void main(void) { char cont=0; //definicion de... signed char bcd=-1; //...variables set_tris_a (0x00); //porta salida set_tris_b (0x00); //portb salida for(;;){ //bucle... output_a(cont); //enciende led correspondiente #asm //modulo asm para manejar bcd->7seg movlw 1 ;w <- 1 addwf bcd,1 ;bcd <- w + bcd movf bcd,0 ;w <- bcd sublw 10 ;10- w btfsc STATUS,2 ;¿se ha llegado a 9? goto igual ;SI->ve a igual swapf bcd,0 ;NO: w <- parte alta bcd goto muestra ;ve a muestra igual: movlw 0 ;w <- 0 movwf bcd ;bcd <- w muestra: movwf PORTB ;PORTB <- w #endasm //fin modulo asm para manejar bcd->7seg delay_ms(450); #asm //modulo asm para manejar led's movlw 1 ;w <- 1 addwf cont,1 ;cont <- w + cont #endasm //fin modulo asm para manejar led's if(cont>3) //¿se ha mostrado el ultimo led? cont=0; //SI-> reset cont } //...infinito }
PIC16F648A 7 segment bcd Uygulaması
//////////////////////////////////////////////////////////////////////////////////// // VsZeNeR'05 // 22/Agosto/05 // [email protected] // 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 // 0 0 0 0 0 // 0 0 0 1 1 // 0 0 1 0 2 // 0 0 1 1 3 // 0 1 0 0 4 // 0 1 0 1 5 // 0 1 1 0 6 // 0 1 1 1 7 // 1 0 0 0 8 // 1 0 0 1 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); //porta como entrada disable_interrupts(GLOBAL); //todas las interrupciones desactivadas output_b(tabBCD[i]); //inicializa displayBCD digito 0 for(;;){ //bucle... if(!input(PIN_A0)) //¿se ha pulsado el boton? { delay_ms(151); //SI -> retardo para evitar los rebotes i++; //incremento contador indice tabBCD if(i>9) //¿se ha mostrado digito 9? i=0; //SI -> restaura valor indice(para mostrar digito 0) output_b(tabBCD[i]); //muestra por portb digito 7 segmentos } } //...infinito }
PIC16F648A Error Int portB
////////////////////////////////////////////////////////////////////////////////////
// VsZeNeR'06
// 01/Julio/06
//
// Programa: Prueba Interrupcion debido a cambio de estado del portb <4:7>
// Version: 0.0
//
// Dispositivo: PIC 16F648A Compilador: CCS vs3.249
// Entorno IDE: MPLAB IDE v7.40 Simulador: Proteus 6.9sp4
//
// Notas: Este programa se encarga de ver si el compilador de la casa CCS no desactiva
// correctamente la interrupcion del puerto b, para ello debe:
// 1. Leer el puerto del puerto B
// 2. Borrar el bit de la interrupcion(bit RBIF)
// Cada vez que hay un cambio de estado en los pines del puerto B <4:7>
// se producira una interrupcion, la cual incrementa una variable que se utilizara
// en el programa principal para mostrar la iluminacion de led's. Aparte,
// cada vez que se produzca una interrupcion se iluminara un led conectado al pin
// A4 que se apagara cuando salgamos de dicha interrupcion.
//
// Conexiones: A0 -> A dec 4028
// A1 -> B dec 4028
// A2 -> C dec 4028
// A3 -> D dec 4028
// A4 -> led indicador de interrupcion
// B4 -> boton
// B5 -> boton
// B6 -> boton
// B7 -> boton
//
// Conclusion: El CCS no realiza bien el tratamiento de la interrupcion
// del portB, por lo que tendremos que leer/escribir algun pin
// del portB o el puerto entero.
//////////////////////////////////////////////////////////////////////////////////
#include <16f648a.h> //pic a utilizar
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador
#fuses INTRC //oscilador interno
#use delay (clock=4000000) //Fosc=4Mhz
#use fast_io(b)
#use fast_io(a)
///DECLARACION DE VARIABLES GLOBALES
int variable=0;
///LLAMADA FUNCION INTERRUPCION
#INT_RB
void IntPortB4_7()
{
output_high(pin_a4); //indicador de interrupcion on
//Activar la linea de abajo para ver los cambios!!!
// while(!input(PIN_B4) || !input(PIN_B5) || !input(PIN_B6) || !input(PIN_B7)); //elimina rebotes
//en caso que funcione el ccs no deberia abordar de nuevo la interrupcion hasta un cambio de estado
//de cualquiera de los pines <4:7> del portb. El CCS falla, por lo que si tenemos la linea de lectura/escritura
//del puerto b(o alguno de sus pines) desactivada siempre nos entrara en la interrupcion!
variable++; //incrementamos variable
if(variable>0b00001001) //¿se ha iluminado el ultimo led?
variable=0; //SI -> reset variable
output_low(pin_a4); //indicador interrupcion off
}
///PROGRAMA
void main(void)
{
setup_oscillator(OSC_4MHZ); //configuramos el oscilador a 4MHz
set_tris_a (0x00); //porta salida
set_tris_b (0xFF); //portb entrada
enable_interrupts(int_rb); //activar interrupcion rb4:7
enable_interrupts(GLOBAL); //activar interrupciones
output_low(pin_a4); //indicador de la interrupcion off
do{ //bucle...
output_a(variable); //mostramos por el porta el valor de variable
}while(TRUE); //...infinito
}
PIC16F648A lcd ve 24lc256 Eeprom
//////////////////////////////////////////////////////////////////////////////////// // VsZeNeR'05 // 30/Agosto/05 // [email protected] // Programa: Escribir & leer eeprom externa 24LC256 y mostrarla por lcd // 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) la informacion grabada en la memoria // externa 24LC256(eeprom) y luego se muestra por la lcd // Se utiliza variables locales: // ·dir-> posicion a grabar en la eeprom 24LC256 // ·men1[] -> contiene 1º mensaje a escribir en eeprom y mostrar en lcd // ·men2[] -> contiene 2º mensaje a escribir en eeprom y mostrar en lcd // ·men3[] -> contiene 3º mensaje a escribir en eeprom y mostrar en lcd // ·men4[] -> contiene 4º mensaje a escribir en eeprom y mostrar en lcd // En la pantalla lcd se muestra la direccion de memoria donde esta grabado el // mensaje a mostrar y el correspondiente mensaje. // Tener en cuenta que hay que poner la directiva NOLVP para que el pin B4 sea de // salida. // Conexiones: A0 -> SCK eeprom externa // A1 -> SDA eeprom externa // B0 -> E // B1 -> RS // B2 -> RW // B4 -> D4 // B5 -> D5 // B6 -> D6 // B7 -> D7 ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #use delay(CLOCK=4000000) //Fosc=4Mhz #fuses HS,NOPUT,NOPROTECT,NOBROWNOUT,NOLVP,NOWDT //comandos para el programador #define use_portb_lcd TRUE //utilizar el port b para lcd #define EEPROM_SDA PIN_A1 //definimos los pines donde... #define EEPROM_SCL PIN_A0 //la eeprom ira conectada #include <24256.c> //libreria de eeprom externa 24LC256 #include <lcd.c> //libreria de lcd ///PROGRAMA void main(void){ int dir=0; //direccion de eeprom a escribir y leer mensajes char men1[]="VsZeNeR'05"; //declaracion de... char men2[]="Hola"; char men3[]="Foro"; char men4[]="TODOPIC!"; //...mensajes a escribir y leer por 25LC256 lcd_init(); //inicializa lcd init_ext_eeprom(); //inicializa eeprom lcd_putc("~ Escribiendo en...\n24LC256\n"); delay_ms(500); write_ext_eeprom(dir,men1); //proceso de escribir... dir++; write_ext_eeprom(dir,men2); dir++; write_ext_eeprom(dir,men3); dir++; write_ext_eeprom(dir,men4); //...los mensajes en la eeprom externa lcd_putc("\fFin de escritura en\n24LC25"); delay_ms(1500); lcd_putc("\f>>>Leyendo...\n"); for(dir=0;dir<4;dir++){ //bucle para leer mensajes en eeprom externa y muestra por lcd printf(lcd_putc,"\n %d ~ %s",dir,read_ext_eeprom(dir)); delay_ms(1500); //retraso para que se vea en pantalla los mensajes lcd_putc("\n "); //borrado 2ºlinea de lcd } output_a(0b00); //apago port a lcd_putc("\fFin de lectura!"); for(;;){ //animacion... for(dir=1;dir<8;dir++){ lcd_gotoxy(dir,2); lcd_putc("VsZeNeR'05"); delay_ms(200); lcd_putc("\n "); } for(dir=6;dir>1;dir--){ lcd_gotoxy(dir,2); lcd_putc("VsZeNeR'05"); delay_ms(200); lcd_putc("\n "); } } //...final }
5x7 Led Matrix
////////////////////////////////////////////////////////////////////////////////// // VsZeNeR'05 // 19/Diciembre/05 // [email protected] // Programa: Abecedario en matrices de led's 5x7 // Version: 0.0 // // Dispositivo: PIC 16F648A Compilador: CCS vs3.236 // Entorno IDE: MPLAB IDE v7.30 Simulador: Proteus 6.7sp3 // // Notas: Este programa muestra por el abecedario en una matriz de led's 5x7. // En las columnas se usa un decodificador 4028 para hacer su barrido // Conexiones: A0 -> A 4028 DEC // A1 -> B 4028 DEC // A2 -> C 4028 DEC // A3 -> D 4028 DEC // B0 -> Fila 1 matriz 5x7 // B1 -> Fila 2 matriz 5x7 // B2 -> Fila 3 matriz 5x7 // B3 -> Fila 4 matriz 5x7 // B4 -> Fila 5 matriz 5x7 // B5 -> Fila 6 matriz 5x7 // B6 -> Fila 7 matriz 5x7 ////////////////////////////////////////////////////////////////////////////////// #include <16f648a.h> //pic a utilizar #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP //ordenes para el programador #fuses INTRC //oscilador interno #use delay (clock=4000000) //Fosc=4Mhz #use fast_io(a) #use fast_io(b) ///DEFINICION VARIABLES GLOBALES int letra[5],opcion=0; ///LLAMADA FUNCION INTERRUPCION #INT_TIMER1 void interrupcion() { switch(opcion){ //selecciona letra case 0: letra[0]=0b00000001; //A letra[1]=0b01110110; letra[2]=0b01110110; letra[3]=0b01110110; letra[4]=0b00000001; opcion++; break; case 1: letra[0]=0b01001001; //B letra[1]=0b00110110; letra[2]=0b00110110; letra[3]=0b00110110; letra[4]=0b00000000; opcion++; break; case 2: letra[0]=0b00111110; //C letra[1]=0b00111110; letra[2]=0b00111110; letra[3]=0b00111110; letra[4]=0b01000001; opcion++; break; case 3: letra[0]=0b01000001; //D letra[1]=0b00111110; letra[2]=0b00111110; letra[3]=0b00111110; letra[4]=0b00000000; opcion++; break; case 4: letra[0]=0b00111110; //E letra[1]=0b00110110; letra[2]=0b00110110; letra[3]=0b00110110; letra[4]=0b00000000; opcion++; break; case 5: letra[0]=0b01111110; //F letra[1]=0b01110110; letra[2]=0b01110110; letra[3]=0b01110110; letra[4]=0b00000000; opcion++; break; case 6: letra[0]=0b01001110; //G letra[1]=0b00110110; letra[2]=0b00110110; letra[3]=0b00111110; letra[4]=0b01000001; opcion++; break; case 7: letra[0]=0b00000000; //H letra[1]=0b01110111; letra[2]=0b01110111; letra[3]=0b01110111; letra[4]=0b00000000; opcion++; break; case 8: letra[0]=0b00111110; //I letra[1]=0b00111110; letra[2]=0b00000000; letra[3]=0b00111110; letra[4]=0b00111110; opcion++; break; case 9: letra[0]=0b01111111; //J letra[1]=0b00000000; letra[2]=0b00111110; letra[3]=0b00101110; letra[4]=0b01001111; opcion++; break; case 10: letra[0]=0b00111110; //K letra[1]=0b01011101; letra[2]=0b01101011; letra[3]=0b01110111; letra[4]=0b00000000; opcion++; break; case 11: letra[0]=0b00111111; //L letra[1]=0b00111111; letra[2]=0b00111111; letra[3]=0b00111111; letra[4]=0b00000000; opcion++; break; case 12: letra[0]=0b00000000; //M letra[1]=0b01111101; letra[2]=0b01111011; letra[3]=0b01111101; letra[4]=0b00000000; opcion++; break; case 13: letra[0]=0b00000011; //N letra[1]=0b01011111; letra[2]=0b01101111; letra[3]=0b01110111; letra[4]=0b00000011; opcion++; break; case 14: letra[0]=0b00000011; //Ñ letra[1]=0b01011101; letra[2]=0b01101101; letra[3]=0b01110101; letra[4]=0b00000011; opcion++; break; case 15: letra[0]=0b01000001; //O letra[1]=0b00111110; letra[2]=0b00111110; letra[3]=0b00111110; letra[4]=0b01000001; opcion++; break; case 16: letra[0]=0b01111001; //P letra[1]=0b01110110; letra[2]=0b01110110; letra[3]=0b01110110; letra[4]=0b00000000; opcion++; break; case 17: letra[0]=0b00000001; //Q letra[1]=0b00011110; letra[2]=0b00101110; letra[3]=0b00111110; letra[4]=0b01000001; opcion++; break; case 18: letra[0]=0b01111001; //R letra[1]=0b00110110; letra[2]=0b01010110; letra[3]=0b01100110; letra[4]=0b00000000; opcion++; break; case 19: letra[0]=0b01001110; //S letra[1]=0b00110110; letra[2]=0b00110110; letra[3]=0b00110110; letra[4]=0b00111001; opcion++; break; case 20: letra[0]=0b01111110; //T letra[1]=0b01111110; letra[2]=0b00000000; letra[3]=0b01111110; letra[4]=0b01111110; opcion++; break; case 21: letra[0]=0b01000000; //U letra[1]=0b00111111; letra[2]=0b00111111; letra[3]=0b00111111; letra[4]=0b01000000; opcion++; break; case 22: letra[0]=0b01100000; //V letra[1]=0b01011111; letra[2]=0b00111111; letra[3]=0b01011111; letra[4]=0b01100000; opcion++; break; case 23: letra[0]=0b01000000; //W letra[1]=0b00111111; letra[2]=0b01000111; letra[3]=0b00111111; letra[4]=0b01000000; opcion++; break; case 24: letra[0]=0b00111011; //X letra[1]=0b01010111; letra[2]=0b01101111; letra[3]=0b01010111; letra[4]=0b00111011; opcion++; break; case 25: letra[0]=0b01111110; //Y letra[1]=0b01111101; letra[2]=0b00000011; letra[3]=0b01111101; letra[4]=0b01111110; opcion++; break; case 26: letra[0]=0b00111100; //Z letra[1]=0b00111010; letra[2]=0b00110110; letra[3]=0b00101110; letra[4]=0b00011110; opcion=0; } set_timer1(3036); //TMR1 se desborda cada 0,5s } void main(void) { int i; //variable contador enable_interrupts(INT_TIMER1); //interrupcion TIMER1 activada setup_timer_1(T1_INTERNAL|T1_DIV_BY_8); //configuracion TMR1 set_timer1(65535); //carga TMR1 para un desbordamiento inmediato enable_interrupts(GLOBAL); //activadas interrupciones set_tris_b (0x00); //portb salida set_tris_a (0x00); //porta salida do{ //bucle... for(i=0;i<5;i++){ output_a(i); //columnas output_b(letra[i]); //filas delay_ms(10); //pausa para poder verse } }while(TRUE); //...infinito }
LCD Kayan Yazı
//////////////////////////////////////////////////////////////////////////////////// // VsZeNeR'05 // 29/Agosto/05 // [email protected] // Programa: VsZeNeR'05 mov pantalla // 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) como la palabra VsZeNeR'05 // se va moviendo por pantalla, empieza en la 1ºfila y termina en la 2ºfila. // Se utiliza variables locales: // ·x -> indice filas, es de tipo char signed porque necesitamos nº negativos // para que en la 2ºfila del lcd aparezca primero el final del mensaje. // ·y -> indice de columnas: y=1 -> 1ºcolumna // y=2 -> 2ºcolumna // La 'x' se comprende en pantalla desde 1 hasta 16 y la 'y' desde 1 hasta 2. // 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) { char y=1; //indice columnas signed char x=1; //indice filas lcd_init(); //inicializa lcd while(TRUE){ //bucle... lcd_gotoxy(x,y); //cursor para escribir mensaje lcd_putc("VsZeNeR'05"); //muestra por pantalla el mensaje delay_ms(150); x++; //incremento indice de filas if(x>16){ //¿ya se ha mostrado mensaje entero por 1ºfila? x=-8; //SI -> indice fila x=-8 y++; //incremento indice columnas if(y>2) //¿ya se ha mostrado mensaje por 2º columna? y=1; //SI -> restauro indice columna } lcd_putc("\f"); //borra pantalla } //...infinito }
LCD DS1302 Uygulaması
//////////////////////////////////////////////////////////////////////////////////// // VsZeNeR'05 // 09/Septiembre/05 // [email protected] // Programa: Reloj-Calendario DS1302 // 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) 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. // ·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' // B0 -> E // B1 -> RS // B2 -> RW // B4 -> D4 // B5 -> D5 // B6 -> D6 // B7 -> D7 // 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) #define use_portb_lcd TRUE //utilizar el port b para lcd #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 #include <lcd.c> //libreria de lcd ///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(lcd_putc,"\fFecha: %2X/%2X/%2X\nHora: %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 lcd_init(); //inicializa lcd rtc_init(); //inicializa rtc lcd_putc("Reloj Calendario\n VsZeNeR'05"); //presentacion... 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: lcd_putc("\fConfigurar\nhoras?"); //horas if(!input(PIN_A5)){ while(!input(PIN_A5)){} beep(); horas(); menu=1; //apunta siguiente opcion } break; case 1: lcd_putc("\fConfigurar\nminutos?"); //minutos if(!input(PIN_A5)){ while(!input(PIN_A5)){} beep(); minutos(); menu=2; //apunta siguiente opcion } break; case 2: lcd_putc("\fConfigurar\ndia?"); //dias if(!input(PIN_A5)){ while(!input(PIN_A5)){} beep(); dia(); menu=3; //apunta siguiente opcion } break; case 3: lcd_putc("\fConfigurar\nmes?"); //mes if(!input(PIN_A5)){ while(!input(PIN_A5)){} beep(); mes(); menu=4; //apunta siguiente opcion } break; case 4: lcd_putc("\fConfigurar\nanio?"); //años if(!input(PIN_A5)){ while(!input(PIN_A5)){} beep(); anio(); menu=5; //apunta siguiente opcion } break; case 5: lcd_putc("\fSalir\nconfigurar?"); //salir configuracion if(!input(PIN_A5)){ menu=6; beep(); } } if(!input(PIN_A3)){ //controla el boton up... while(!input(PIN_A3)){} menu++; if(menu>5) menu=0; } //...para mostrar menu por lcd delay_ms(130); //retardo para ver lcd }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(lcd_putc,"\fConf.Horas:\nHora: %2X:%2X:%2X",hour,min,sec); //muestra por lcd 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(lcd_putc,"\nHora: %2X:%2X:%2X",hour,min,sec); //muestra por lcd hour } }while(input(PIN_A5)); while(!input(PIN_A5)){} //elimina rebotes } ///FUNCION CONFIGURA MINUTOS void minutos(void){ printf(lcd_putc,"\fConf.Minutos:\nHora: %2X:%2X:%2X",hour,min,sec); //muestra por lcd 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(lcd_putc,"\nHora: %2X:%2X:%2X",hour,min,sec); //muestra por lcd min } }while(input(PIN_A5)); while(!input(PIN_A5)){} //elimina rebotes } ///FUNCION CONFIGURA DIAS void dia(void){ printf(lcd_putc,"\fConf.Dias:\nFecha: %2X/%2X/%2X",day,mth,year); //muestra por lcd 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(lcd_putc,"\fConf.Dias:\nFecha: %2X/%2X/%2X",day,mth,year); //muestra por lcd day } }while(input(PIN_A5)); while(!input(PIN_A5)){} //elimina rebotes } ///FUNCION CONFIGURA MES void mes(void){ printf(lcd_putc,"\fConf.Mes:\nFecha: %2X/%2X/%2X",day,mth,year); //muestra por lcd 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(lcd_putc,"\fConf.Mes:\nFecha: %2X/%2X/%2X",day,mth,year); //muestra por lcd } }while(input(PIN_A5)); while(!input(PIN_A5)){} //elimina rebotes } ///FUNCION CONFIGURA AÑOS void anio(void){ printf(lcd_putc,"\fConf.Anio:\nFecha: %2X/%2X/%2X",day,mth,year); //muestra por lcd 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(lcd_putc,"\fConf.Anio:\nFecha: %2X/%2X/%2X",day,mth,year); //muestra por lcd } }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 }
LCD Üzerine tek tek harf yazdırma
//////////////////////////////////////////////////////////////////////////////////// // VsZeNeR'05 // 26/Agosto/05 // [email protected] // 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) //¿ya esta completa la 1º fila del lcd? y=2; //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 }
4 Ledli Kara Şimşek
//////////////////////////////////////////////////////////////////////////////////// // VsZeNeR'04 // 12/Agosto/05 // [email protected] // Programa: Coche Fantastico // Version: 1.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 B por medio de la instruccion de rotar. // // RB0 -> 1º Led // RB1 -> 2º Led // RB2 -> 3º Led // RB3 -> 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(B) //puerto B como salida #byte portb= 0x6 //direccion port b ///PROGRAMA void main(void) { int led_on=0b0001; //led a iluminar set_tris_b(0xf0); //portb como salida (algunas desactivadas) disable_interrupts(GLOBAL); //todas las interrupciones desactivadas do{ //bucle... do{ //iluminacion hacia izquierda portb=led_on; rotate_left(&led_on,1); delay_ms(300); }while(bit_test(led_on,3)==0); do{ //iluminacion hacia derecha portb=led_on; rotate_right(&led_on,1); delay_ms(300); }while(bit_test(led_on,0)==0); }while(TRUE); //...infinito }
8 Ledli Kara şimşek devresi
//////////////////////////////////////////////////////////////////////////////////// // VsZeNeR'04 // 14/Agosto/05 // [email protected] // Programa: Coche Fantastico // Version: 2.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 B. Adaptacion 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 // En la variable cont se va almacenando los valores 1-2-4-8-16-32-64-128 // que en binario corresponden a la secuencia 00000001-00000010-00000100... // son los led's a iluminar, coincidiendo con la secuencia de iluminacion // del coche fantastico(version Ecuatoriana: auto fantastico) ////////////////////////////////////////////////////////////////////////////////// #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 como salida ///PROGRAMA void main(void) { int i,cont; //variables definidas set_tris_b(0x00); //portb como salida disable_interrupts(GLOBAL); //todas las interrupciones desactivadas do{ //bucle... cont=1; //inicializar... i=1; //...variables do{ //led's on derecha output_b(cont); //ilumino led correspondiente delay_ms(100); cont=cont*2; i++; //incremento i }while(i<8); i=1; //reset valor i do{ //led's on izquierda output_b(cont); //ilumino led correspondiente delay_ms(100); cont=cont/2; i++; //incremento i }while(i<8); }while(TRUE); //...infinito }
PIC C Basit Örnek uygulama Listesi
16f628a led on-off
16f648a auto fantastico for
16f648A juego luces
aupa depo
betis
c&asm
ccp1 capture
ccp1_pwm
ccp1_pwm_vs2
clave
coche fantastico
comecocos
contador 0000a9999
contador 00_99
contador ascendente
contador automatico
contador bcd 0a9
contador bcd rev
contador descendente
contador reversible
dado
dispensador d turnos
ds1620
Error Int portB
hola_rot_7seg
int portb
int rb0
int rda eeprom 25lc256
int rda eeprom interna
int rda eeprom internaI
kit while
kit
lcd & 24lc256
lcd & keypad
lcd & rs232
lcd abecedario
lcd caracter nuevo
lcd contador
lcd ds1302
lcd hola_mundo
lcd limites
lcd mover palabra
lcd read&write eeprom interna
limites 7seg
matrix led 5x7
Parpadeo un led
parpadeo4leds
pcf8591 adc
pcf8591 aout
publicar
reloj 7seg
rs232 & keypad
rs232 & leds
saa1064 16disp 7seg
saa1064 dinamico
saa1064 estatico
version_ahorro_1pin
vs_pcf8591
PIC C
Kaynak: todopic.mforos.com
microchip-pic-serisi-ile-pic-c-ornekleri-basit-uygulamalar
Şifre-Pass: 320volt.com
Yayım tarihi: 2008/07/07 Etiketler: ccs c örnekleri, ccs c projeleri, ccs c sample, microchip pic projeleri, örnek devreler, PIC C, pic c örnekleri, pic c sample, PIC16F628 örnekleri, PIC16F648, PICC, simulasyon
De donde son?
No entiendo nada del idioma, pero estos programas están en castellano… es mas el que lo hizo parece Argentino.
Sigo renegando un poco con el C. Sique siendo más facil para mi el assembler.