320volt / Mikrodenetleyici Projeleri/

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

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

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ı

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ı

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

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

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		   
} 

5x7 Led Matrix

5x7 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ı

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ı

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

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

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

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 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 Tüm dosyalar: microchip-pic-serisi-ile-ccs-c-ornekleri-basit-uygulamalar.rar

  • Daniel R. Bouza

    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.