Microchip PIC Serisi CCS C Örnekleri Basit Uygulamalar
Kategori: Microcontroller (atmel,microchip vs) 7/07/2008 Tarihinde yazılmış
Uygulamaları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ı buradan indirebilirsiniz Alternatif link kaynak:todopic.mforos.com
Aşağıda ugulamalardan bir kaç örnek ve listesi bulunmakta
PIC16F628 ile Led yak söndür
////////////////////////////////////////////////////////////////////////////////////
// VsZeNeR'04
// 14/Agosto/05
// vszener@gmail.com
// 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
// vszener@gmail.com
// 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
// vszener@gmail.com
// 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
// vszener@gmail.com
// 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
// vszener@gmail.com
// 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
}
5×7 Led Matrix
//////////////////////////////////////////////////////////////////////////////////
// VsZeNeR'05
// 19/Diciembre/05
// vszener@gmail.com
// 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
// vszener@gmail.com
// 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
// vszener@gmail.com
// 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
// vszener@gmail.com
// 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
// vszener@gmail.com
// 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
// vszener@gmail.com
// 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 5×7
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
Kategori Arşivi Yayımlanan Tüm 
Yazar olmak isterseniz 
