Microchip PIC Serisi CCS C Örnekleri Basit Uygulamalar

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