Programas hechos en MPLAB

#63
aqui le dejo como debe ser el programa para cada pic, tanto como el transmisor y receptor. Puede que me salir del tema que tenia que era programas hecho en ccs c. pero si se fijan bien los programas anteriores fuera referencia apra hacer estos. y para saber tambien que podemos hacer con estos...y pues logramas hacer un robot simple. :)

Código:
///////////////////////////////////////
//AUTOR:JORGE ARTURO RODRIGUEZ HERNANDEZ
//TITLE;TRANSMISOR
//DATE:28/JUNIO/'09
///////////////////////////////////////

//CONFIGURACION///////////////////
#include<16F628A.h>
#include <STRING.H>
#fuses INTRC_IO,NOWDT,NOLVP,MCLR,NOPROTECT
#use delay(clock=4000000)
#use rs232(baud=2400,xmit=PIN_A0,rcv=PIN_A1)


void config(void){
		set_tris_a(0x22);
		set_tris_b(0x00);
		setup_comparator(NC_NC_NC_NC);
}

void accion(void){
			int x,y;
			do{
				x=getch();
				#use rs232(baud=1200,xmit=PIN_A2)
				switch(x){
					case'U':
						for(y=0;y<=15;y++){ 
							printf("U");
							delay_ms(5);
						}
						output_b(0x01); 
						break;
					case'L':
						for(y=0;y<=15;y++){ 
							printf("L");
							delay_ms(5);
						}
						output_b(0x02); 
						break;
					case'R': 
						for(y=0;y<=15;y++){ 
							printf("R");
							delay_ms(5);
						}
						output_b(0x04); 
						break;
					case'D': 
						for(y=0;y<=15;y++){ 
							printf("D");
							delay_ms(5);
						}
						output_b(0x08);
						 break;
					case'O':
						for(y=0;y<=15;y++){ 
							printf("O");
							delay_ms(5);
						}
						output_b(0x00); 
						break;
				}
				#use rs232(baud=2400,xmit=PIN_A0,rcv=PIN_A1)
					
			}while(x!='O');
}



void main(void){
		char password[]="YES";
		char word[];
		int z;
		config();
		output_b(0x00);

		do{
			#use rs232(baud=2400,xmit=PIN_A0,rcv=PIN_A1)
			gets(word);
			if(strcmp(word,password)){
				output_b(0x0f);
				#use rs232(baud=1200,xmit=PIN_A2)
				for(z=0;z<=30;z++){
					printf("A");
					delay_ms(5);
				}
				#use rs232(baud=2400,xmit=PIN_A0,rcv=PIN_A1)
				accion();
			}
			else{
				output_b(0x00);
			}
		}while(TRUE);

}
Código:
///////////////////////////////////////
//AUTOR:JORGE ARTURO RODRIGUEZ HERNANDEZ
//TITLE;RECEPTOR
//DATE:28/JUNIO/'09
///////////////////////////////////////

//CONFIGURACION///////////////////
#include<16F628A.h>
#include <STRING.H>
#fuses INTRC_IO,NOWDT,NOLVP,MCLR,NOPROTECT
#use delay(clock=4000000)
#define use_portb_lcd TRUE
#include<LCD.C>
#use rs232(baud=1200,rcv=PIN_A4)
#define EN1_2 PIN_A6
#define EN3_4 PIN_A7
#define A_1	  PIN_A0
#define A_2	  PIN_A1
#define A_3   PIN_A2
#define A_4   PIN_A3

int SALIR,c;

void config(void){
		set_tris_a(0x30);
		setup_comparator(NC_NC_NC_NC);
		output_low(EN1_2);
		output_low(EN3_4);
		output_low(A_1);
		output_low(A_2);
		output_low(A_3);
		output_low(A_4);
}
void main(void){
		config();
		lcd_init();

MAIN:
		lcd_putc("\fPASSWORD");
		output_low(EN1_2);
		output_low(EN3_4);
		do{
			c=getch();
			switch (c){
				case 'A':
					lcd_putc("\fCORRECTO");
					delay_ms(1000);
					SALIR=1;
					break;
			}
		}while(SALIR!=1);
		SALIR=0;
		lcd_putc("\fESPERANDO\n");
		lcd_putc("A SER CONTROLADO");
		output_high(EN1_2);
		output_high(EN3_4);
		output_low(A_1);
		output_low(A_3);
		do{
			c=getch();
			switch (c){
				case 'O':
					goto MAIN;
					break;
				case 'U':
					lcd_putc("\fADELANTE");
					output_high(A_1);
					output_low(A_2);
					output_high(A_4);
					output_low(A_3);
					break;
				case 'D':
					lcd_putc("\fRETROCEDER");
					output_low(A_1);
					output_high(A_2);
					output_low(A_4);
					output_high(A_3);
					break;
				case 'L':
					lcd_putc("\fIZQUIERDA");
					output_low(A_1);
					output_high(A_2);
					output_high(A_4);
					output_low(A_3);
					break;
				case 'R':
					output_high(A_1);
					output_low(A_2);
					output_low(A_4);
					output_high(A_3);
					lcd_putc("\fDERECHA");
					break;
			}
		}while(TRUE);
}
 
#67
bueno para otra vez empezar con los programas aqui les dejo una matriz de led 8x8 simple.

Código:
//-------------------------------------
//AUTOR:JORGE ARTURO RODRIGUEZ HERNANDEZ
//TITLE;MATRIX
//DATE:20/JULIO/'09
//-------------------------------------

//CONFIGURACION///////////////////
#include<16f628a.h>
#fuses INTRC_IO,NOWDT,NOLVP,MCLR,NOPROTECT
#use delay(clock=4000000)
#define DATA  PIN_A0
#define CLK   PIN_A1
#define RESET PIN_A2

void config(void){
		set_tris_b(0x00);
		set_tris_a(0x20);
		setup_comparator(NC_NC_NC_NC);
}

void SEND_DATA0(void){
		output_low(DATA);
		delay_us(2);
		output_low(CLK);
		delay_us(2);
		output_high(CLK);
}

void SEND_DATA1(void){
		output_high(DATA);
		delay_us(2);
		output_low(CLK);
		delay_us(2);
		output_high(CLK);
}


void main(void){
		int H[]={0b01000010,0b01000010,0b01000010,0b01111110,0b01000010,0b01000010,0b01000010,0b01000010};//"H" 
		int O[]={0b00111100,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b01000010,0b00111100};//"O"
		int L[]={0b01111110,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000,0b01000000};//"L"
		int A[]={0b01000010,0b01000010,0b01000010,0b01111110,0b01000010,0b01000010,0b00100100,0b00011000};//"A"
		int i;
		long j;
		config();
		output_bit(RESET,1);  // "ON"
		output_bit(CLK,0);
		output_bit(DATA,0);

		while(TRUE){
			for(j=0;j<=25;j++){
				for(i=0;i<=7;i++){
					output_b(H[i]);			//H
					delay_ms(5);
					SEND_DATA1();
				}
				SEND_DATA0();
			}

			for(j=0;j<=25;j++){
				for(i=0;i<=7;i++){
					output_b(O[i]);			//O
					delay_ms(5);
					SEND_DATA1();
				}
				SEND_DATA0();
			}

			for(j=0;j<=25;j++){
				for(i=0;i<=7;i++){
					output_b(L[i]);			//L
					delay_ms(5);
					SEND_DATA1();
				}
				SEND_DATA0();
			}	

			for(j=0;j<=25;j++){
				for(i=0;i<=7;i++){
					output_b(A[i]);			//A
					delay_ms(5);
					SEND_DATA1();
				}
				SEND_DATA0();
			}

			for(j=0;j<=25;j++){
				for(i=0;i<=7;i++){
					output_b(0X00);			//" "
					delay_ms(5);
					SEND_DATA1();
				}
				SEND_DATA0();
			}
		}
}
 

Adjuntos

#68
bueno aqui les dejo un programa ue te pide el valor a cada display,para empezar un conteo desde el numero elegido.
aqui se pone en pruebla las interrupciones en este caso el timer0.
por ejemplo si queremos un conteo de 60 segundos hay que poner en los display un 6 y un 0 y presionar S y listo.

Código:
///////////////////////////////////////
//AUTOR:JORGE ARTURO RODRIGUEZ HERNANDEZ
//TITLE;CONTADOR_RS232
//DATE:06/MAYO/2009
///////////////////////////////////////

//CONFIGURACION///////////////////
#include<16F628A.h>
#fuses INTRC_IO,NOWDT,NOLVP,MCLR,NOPROTECT
#use delay(clock=4000000)
#use rs232(baud=2400,xmit=PIN_A2,rcv=PIN_A3)

#define ENABLE_1 PIN_A1
#define ENABLE_2 PIN_A0

int mostrar[]={0b11000000,0b11111001,0b10100100,0b10110000,
			   0b10011001,0b10010010,0b10000011,0b11111000,0b00000000,0b00011000};

int x,i,KEY;
int N1;
int N2;

//CONFIGURACION/////////////
void config(void){
			set_tris_a(0x28);
			set_tris_b(0x00);
			setup_comparator(NC_NC_NC_NC);
			setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1|RTCC_8_BIT);
			set_timer0(0);
}	



//INTERRUPCION POR TIMER0
#INT_TIMER0
void MUESTRA(){
		
		output_low(ENABLE_1);
		output_high(ENABLE_2);
		output_b(mostrar[N2]);
		delay_ms(5);

		output_low(ENABLE_2);
		output_b(mostrar[N1]);
		output_high(ENABLE_1);
}

//ELECCION DEL NUMERO

NUMERO(){
	loop:	x=getch();
				switch(x){
					case 48: KEY=0; break;
					case 49: KEY=1; break;
					case 50: KEY=2; break;
					case 51: KEY=3; break;
					case 52: KEY=4; break;
					case 53: KEY=5; break;
					case 54: KEY=6; break;
					case 55: KEY=7; break;
					case 56: KEY=8; break;
					case 57: KEY=9; break;
					default: printf("NO ES UN NUMERO, INTENTE OTRA VEZ \r\n"); goto loop;
				}
		return(KEY);
}

//INICIO DEL PROGRAMA PRINCIPAL/////////////////////

void main(void){
			disable_interrupts(INT_TIMER0);
			disable_interrupts(GLOBAL);
			config();

			
		do{
			printf(">>ESCRIBA EL 1er VALOR; \r\n");
	
			N1=NUMERO();
				
			output_b(mostrar[N1]);
			output_high(ENABLE_1);
			output_low(ENABLE_2);
			delay_ms(1000);
			output_low(ENABLE_1);

			printf(">>ESCRIBA EL 2do VALOR; \r\n");
		
			N2=NUMERO();

			output_b(mostrar[N2]);
			output_low(ENABLE_1);
			output_high(ENABLE_2);
			delay_ms(1000);
			output_low(ENABLE_2);
		
			printf("PARA EMPEZAR PRESIONE (S) \r\n");
			do{
				x=getch();
			}while(x!='S');
			printf("START...\r\n");
			do{
				enable_interrupts(INT_TIMER0);
				enable_interrupts(GLOBAL);
				for(i=1;i<=45;i++){
						delay_ms(10);
				}

				if(N1==0){
					N2--;
					N1=9;
				}else{
					N1--;
				}
			}while(N1!=0 || N2!=0);
			disable_interrupts(INT_TIMER0);
			disable_interrupts(GLOBAL);
			output_low(ENABLE_1);
			output_low(ENABLE_2);
			printf("HA TERMINADO EL CONTEO; \r\n");
			delay_ms(1000);
		}while(TRUE);
}
 

Adjuntos

#69
bueno aqui les dejo dos practicas, un programa es para poner el reloj en el lcd, y otro programa es para probar el teclado 4x4.

Código:
///////////////////////////////////////
//AUTOR:JORGE ARTURO RODRIGUEZ HERNANDEZ
//TITLE;LCD TIEMPO
//DATE:22/JULIO/'09
///////////////////////////////////////

//CONFIGURACION///////////////////
#include<16F887.h>
#fuses INTRC_IO,NOWDT,NOLVP,MCLR,NOPROTECT
#use delay(clock=4000000)
#include<LCD.C>

//DEFINICIONES
#define HORA	PIN_A0
#define MINUTO	PIN_A1

//VARIABLES
int OVERFLOW,MINUTE,HOUR,SECOND;

//CONFIGURACION
void config(void){
		set_tris_a(0x03);
		set_tris_d(0x00);
		setup_adc(ADC_OFF);
		setup_comparator(NC_NC_NC_NC);
		setup_timer_0(RTCC_INTERNAL|RTCC_DIV_64|RTCC_8_BIT); //overflow cada 16.384mS
		set_timer0(0);
}

//INTERRUPCION 
#INT_TIMER0
void TIMER0(void){
		OVERFLOW++;
		if(OVERFLOW>61){
			OVERFLOW=0;
			SECOND++;
			if(SECOND==60){
				SECOND=0;
				MINUTE++;
				if(MINUTE==60){
					MINUTE=0;
					HOUR++;
					if(HOUR==24){
						HOUR=0;
					}
				}
			}
		}
}

void TIEMPO(void){
		int i;
		
		for(i=0;i<=200;i++){
			delay_ms(1);
		}
}

//INICIO DEL PROGRAMA
void main(void){
		config();
		lcd_init();
		
		SECOND=0;
		MINUTE=0;
		HOUR=0;
		lcd_putc("    R E L O J");
		enable_interrupts(INT_TIMER0);
		enable_interrupts(GLOBAL);
		while(TRUE){
			if(input(MINUTO)){
				MINUTE++;
				if(MINUTE==60){
					MINUTE=0;
				}
				TIEMPO();
			}
		
			if(input(HORA)){
				HOUR++;
				if(HOUR==24){
					HOUR=0;
				}
				TIEMPO();
			}
			lcd_gotoxy(6,2);
			printf(lcd_putc,"%u:%u:%u  ",HOUR,MINUTE,SECOND);
		}
}
Código:
///////////////////////////////////////
//AUTOR:JORGE ARTURO RODRIGUEZ HERNANDEZ
//TITLE;KEYBOARD Y LCD
//DATE:23/JULIO/'09
///////////////////////////////////////

//CONFIGURACION///////////////////
#include<16F887.h>
#fuses INTRC_IO,NOWDT,NOLVP,MCLR,NOPROTECT
#use delay(clock=8000000)
#use fast_io(b)
#include<kbd_lib.c>
#include<LCD.C>

void config(void){
		set_tris_b(0xF0);
		port_b_pullups(0xF0);
		setup_adc(NO_ANALOGS);
		setup_comparator(NC_NC_NC_NC);
		disable_interrupts(GLOBAL);
}

void main(void){
		char KEY=0;
		int N=1;
		config();
		kbd_init();
		lcd_init();

		while(TRUE){
			lcd_putc("NUMERO");
			do{
				KEY=kbd_getc();
				if(KEY!=0){
					lcd_gotoxy(N,2);
					lcd_putc(KEY);	
					N++;
				}
			}while(N<=17);
			lcd_putc("\f");
			N=1;
		}
}
 

Adjuntos

#70
hola soy nuevo en esto de programar Cy aun no entiendo la distincion entre #DEFINE y #BIT los dos hacen lo mismo? como hago por ejemplo si quiero una parte de la ram para guardar algun dato yo en asm ponia por ejemplo

ejemplo_1 equ 0x24 de este modo ejemplo_1 esta en la 0x24 de la ram

y que hace exactamente la instruccion int?
 
#71
int es una declaracion de una variable puede ser asi:
unsigned int8 d; //esta es una variable del tipo sin signo y de una extension de 8 bits, va desde 0 hasta 255

unsigned int 16 d; // la variable d tiene una extension de 2 bytes y como es sin signo va desde 0 hasta 65536

signed int8 v;// la variable v es de 1 byte y como tiene signo va desde -127 a 128 (puede ser desde -128 a 127 pero ahora no me acuerdo)

#bit sirve para darle nombre a un determinado puerto por ejemplo

#BIT LED = PORTB.0
#BIT SENSOR = PORTC.3

con define se puede hacer esto pero tambien se puede darle un "nombre" a un conjunto de instrucciones:

#define M_D_AVANZA OUTPUT_HIGH(PIN_B6); OUTPUT_LOW(PIN_B7); //parte de un programa mio para mi primer robot microcontrolado que todavia esta en construcción, lo que hace pone en alto b6 y en bajo b7 para que el motor gire (M_D_AVANZA = motor derecho avanza)

Para guardar un dato es lo de mas arriba con las variables
Espero te sirva
saludos
 
#72
Vegetal_Digital que hace exactamente tu robot porque yo tengo uno hecho con un 16f84 y ahora lo voy a mejorar con un 16f877 pero el mio tiene bumpers nomas ya que no encuentro en ninguna casa de electronica nadie que venda esos sensores SHARP o los IS471F y no se como esquive por infrarrojo vos pudiste solucionar esto? (esta argentina no vende nada )
 
#73
Mi robot es igual al tuyo, le puse dos contactos en el frente, pero se me quemo la parte de potencia de los motores que la hice con un l293, tengo que esperar hasta el viernes que llegue, y el lunes empiezan de nuevo las clases así que voy a estar con poco tiempo. Los sensores que decis no se que son, si queres experimentar con infrarrojos he leido que el CNY70 anda bien. Para mi ese es un paso que dare mas adelante.
que le queres mejorar que tenes que usar un 16f877?
Yo estoy usando el 16f84 por una cuestión de espacio.
 
#74
Este simple programa lo que hace al introducir el tiempo(MM:SS) empezara a decrementar hasta llegar a cero.

esto pone a prueba el timer0,y timer1.

Código:
///////////////////////////////////////
//AUTOR:JORGE ARTURO RODRIGUEZ HERNANDEZ
//TITLE;CONTROL DE 4 DISPLAY
//DATE:31/JULIO/2009
///////////////////////////////////////

//CONFIGURACION///////////////////
#include<16F628A.h>
#fuses HS,NOWDT,NOLVP,NOMCLR,NOPROTECT
#use delay(clock=20000000)

//definiciones del cada display 1 al 4

#define EN1  PIN_A0
#define EN2  PIN_A1
#define EN3  PIN_A2
#define EN4	 PIN_A3
#define PUSH PIN_A4
#define PUSH2 PIN_A5

//variable que contiene la decodificacion para mostrar cada numero en el display
//de 7 segmentos

int mostrar[]={0b01000000,0b01111001,0b00100100,0b00110000,0b00011001,
			   0b00010010,0b00000011,0b01111000,0b00000000,0b00011000};

//definicion de variables a usar

signed int MEN1=0,MEN2=0,SEN3=0,SEN4=0;
int i;
long j;
int OVERFLOW;

//funcion: que establece los puertos como I/O establece el timer0 con 6.5536mS 
void config(void){
		set_tris_a(0x30);
		set_tris_b(0x80);
		setup_comparator(NC_NC_NC_NC);
		setup_timer_0(RTCC_INTERNAL|RTCC_DIV_128|RTCC_8_BIT);//overflow 6.5536mS
		setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);//overflow 13.1072mS
		set_timer0(0);
}

#INT_TIMER0
void TIMER0(void){
	OVERFLOW++;
	if(OVERFLOW>152){
		OVERFLOW=0;
		SEN4--;
		if(SEN4<0){
			SEN4=9;
			SEN3--;
			if(SEN3<0){
				SEN3=5;
				MEN2--;
				if(MEN2<0){
					MEN2=9;
					MEN1--;
					if(MEN1<0){
						MEN1=0;
					}
				}
			}
		}
	}
		
}

#INT_TIMER1
void TIMER1(void){
		output_bit(EN1,0);
		output_bit(EN2,0);
		output_bit(EN3,0);
		output_b(mostrar[SEN4]);
		output_bit(EN4,1);
		delay_ms(6);
		output_bit(EN1,0);
		output_bit(EN2,0);
		output_bit(EN4,0);
		output_b(mostrar[SEN3]);
		output_bit(EN3,1);
		delay_ms(6);
		output_bit(EN1,0);
		output_bit(EN3,0);
		output_bit(EN4,0);
		output_b(mostrar[MEN2]);
		output_bit(EN2,1);
		delay_ms(6);
		output_bit(EN3,0);
		output_bit(EN2,0);
		output_bit(EN4,0);
		output_b(mostrar[MEN1]);
		output_bit(EN1,1);
}

//RUTINA DE TEMPORIZACION ANTIREBOTE
void TIEMPO(void){
	for(i=1;i<=100;i++){
		delay_ms(1);
	}
}

//rutina de temporizacion de vizualizacion
void TIEMPO1(void){
	for(j=1;j<=1000;j++){
		delay_us(1);
	}
}

void main(void){
		config();

MAIN:
		disable_interrupts(INT_TIMER0);
		enable_interrupts(INT_TIMER1);
		enable_interrupts(GLOBAL);

		//EN ESTA RUTINA INTRODUCES EL TIMEPO

		do{
			if(~input(PUSH)){
				TIEMPO();
				SEN4++;
				if(SEN4>=10){
					SEN4=0;
					SEN3++;
					if(SEN3>=6){
						SEN3=0;
						MEN2++;
						if(MEN2>=10){
							MEN2=0;
							MEN1++;
							if(MEN1>=6){
								MEN1=0;
							}
						}
					}
				}
			}
		}while(input(PUSH2));
		disable_interrupts(INT_TIMER1);
		enable_interrupts(INT_TIMER0);
		
		//EN ESAT RUTINA EMPIEZA A DECREMENTAR EL TIEMPO PUESTO ANTERIORMENTE

		do{
			output_bit(EN1,0);
			output_bit(EN2,0);
			output_bit(EN3,0);
			output_b(mostrar[SEN4]);
			output_bit(EN4,1);
			TIEMPO1();
			output_bit(EN1,0);
			output_bit(EN2,0);
			output_bit(EN4,0);
			output_b(mostrar[SEN3]);
			output_bit(EN3,1);
			TIEMPO1();
			output_bit(EN1,0);
			output_bit(EN3,0);
			output_bit(EN4,0);
			output_b(mostrar[MEN2]);
			output_bit(EN2,1);
			TIEMPO1();
			output_bit(EN3,0);
			output_bit(EN2,0);
			output_bit(EN4,0);
			output_b(mostrar[MEN1]);
			output_bit(EN1,1);
			TIEMPO1();
		}while(MEN1!=0 || MEN2!=0 || SEN3!=0 || SEN4!=0);
		disable_interrupts(GLOBAL);
		delay_ms(1000);
		goto MAIN;
}
 

Adjuntos

#75
Este programa simplemnte hace una inicializacion de la targeta y escribe "hola mundo" y lo lee y lo muestra en el LCD.

Código:
///////////////////////////////////////
//AUTOR:JORGE ARTURO RODRIGUEZ HERNANDEZ
//TITLE;SPI
//DATE:18/JUNIO/'09
///////////////////////////////////////

//CONFIGURACION///////////////////
#include<16f887.h>
#fuses HS,NOWDT,NOLVP,MCLR,NOPROTECT,NOPUT
#use delay(clock=20000000)
#define use_portb_lcd TRUE
#include<LCD.C>

long i;
long data_in;
char LETRA[11];
char GRABAR[64];

#include<comandos.h>

void config(void){
		setup_adc(ADC_OFF);
		setup_comparator(NC_NC_NC_NC);
		set_tris_c(0x10);
		set_tris_d(0x00);
		output_d(0x00);
		setup_spi(SPI_MASTER|SPI_L_TO_H|SPI_CLK_DIV_64);
}

void main(void){
		config();
		lcd_init();
		output_bit(PIN_C0,1); /*desactivamos de la SD*/
		
		for(i=0;i<10;i++)
		{
			spi_write(0xFF);		//se manda almenos 80 blocks para resetear el SD
		}

		output_bit(PIN_C0, 0); /* Activacion de la SD */


		/* Envia a la SD el comando 0 */
		//modo spi

		comando0();

		output_bit(PIN_C0,1); /* Desactivacion de la SD */
		spi_write(0xFF);
		output_d(0x01);
		delay_ms(1000);

		output_bit(PIN_C0, 0); /* Activacion de la SD */

		/* Envia a la SD el comando 1 */
		//incilizar la targeta spi
		comando1();

		output_bit(PIN_C0,1); /* Desactivacion de la SD */
		spi_write(0xFF);
		output_d(0x02);
		delay_ms(1000);

		output_bit(PIN_C0, 0); /* Activacion de la SD */
		//escribimos "HOLA MUNDO" en la tarjeta(vea el archivo comandos.h)
		comando24();

		output_bit(PIN_C0,1); /* Desactivacion de la SD */
		spi_write(0xFF);

		output_bit(PIN_C0, 0); /* Activacion de la SD */
		//leemos lo que escribimos
		comando17();

		output_bit(PIN_C0,1); /* Desactivacion de la SD */
		spi_write(0xFF);
		//lo proyectamos al lcd
		for(i=0;i<=11;i++){
			lcd_putc(LETRA[i]);
		}

}
las funciones se encuetran en el archivo de comandos.h

que es este.

Código:
//COMANDO QUE TE PERMITE HCAER UN RESET U PONER EN MODO SPI.
void comando0(void){
		while(data_in!=1)
		{
			spi_write(0x40) ;
			spi_write(0x00) ;
			spi_write(0x00) ;
			spi_write(0x00) ;
			spi_write(0x00) ;
			spi_write(0x95) ;

			for(i=0;i<64;i++)
			{
				spi_write(0xFF);
				data_in = spi_read();

				if(data_in==0x01)
				{
					break;
				}
			}
		}
}

//COMANDO QUE TE SIRVE PARA PONER LA TARGETA EN MODO SPI
void comando1(void){
	while(data_in!=0)
		{
			spi_write(0x41) ;
			spi_write(0x00) ;
			spi_write(0x00) ;
			spi_write(0x00) ;
			spi_write(0x00) ;
			spi_write(0xFF) ;

			for(i=0;i<64;i++)
			{
				spi_write(0xFF);
				data_in = spi_read();

				if(data_in==0x00)
				{
					break;
				}
			}
		}
}

//COMANDO QUE TE PERMITE ESTABLECER CUANTOS BYTES PODEMOS USAR PARA
//ESCRIBIR O LEER.

void comando16(void){

	while(data_in!=0){
		spi_write(0x50) ;
		spi_write(0x00) ;
		spi_write(0x00) ;
		spi_write(0x00) ;
		spi_write(0x00) ;
		spi_write(0xFF) ;
		
	for(i=0;i<64;i++){
			spi_write(0xFF);
			data_in = spi_read();

			if(data_in==0x00){
				break;
			}
		}
	}
}

//COMANDO QUE TE PERMITE ESCRIBIR EN UN SECTOR DE LA MEMORIA
//EN ESTE CASO SU ESCRIBIMOS ALGO, QUE NO CONTEGA LOS 512 BYTES NECESARIOS,
//SOLO LO RELLENAMOS CON OXFF.
void comando24(void){

	while(data_in!=0x00){
		spi_write(0x58) ;
		spi_write(0x00) ;
		spi_write(0x00) ;
		spi_write(0x00) ;
		spi_write(0x00) ;
		spi_write(0xFF) ;

		for(i=0;i<64;i++){
			spi_write(0xFF);
			data_in = spi_read();
			if(data_in==0x00){
				break;
			}
		} 
	}

	spi_write(0xFF) ;
	spi_write(0xFF) ;
	spi_write(0xFE) ;

	//MENSAJE GRABADO

	spi_write('H');
	spi_write('O');
	spi_write('L');
	spi_write('A');
	spi_write(' ');
	spi_write('M');
	spi_write('U');
	spi_write('N');
	spi_write('D');
	spi_write('O');

	for(i=0;i<501;i++){
		spi_write(0xFF);
	}

	spi_write(0xFF) ;
	spi_write(0xFF) ;

	data_in = spi_read(0xFF);

	data_in &=0b00011111;

	if(data_in!=0b00000101){
		output_d(0x0A);		//ESCRITURA MAL
	}
	else{
		output_d(0x02);		//ESCRITURA BIEN
	}

	while(spi_read(0xFF)!=0xFF);
}

//ESTE COMANDO ES DE LECTURA,YA QUE EL PIC16F887
//NO TIENE TANTA MEMORIA SOLO USAREMOS 64 BYTES DEL PIC.
//EL RESTO SOLO LO USAREMOS COMO BASURA.

void comando17(void){

	while(data_in!=0x00){
		spi_write(0x51) ;
		spi_write(0x00) ;
		spi_write(0x00) ;
		spi_write(0x00) ;
		spi_write(0x00) ;
		spi_write(0xFF) ;

		for(i=0;i<64;i++){
			spi_write(0xFF);
			data_in = spi_read();
			if(data_in==0x00){
				break;
			}
		} 
	}

	output_bit(PIN_D2,1);
	while(spi_read(0xFF)!=0xFE);

	for(i=0;i<=11;i++){
		LETRA[i]=spi_read(0xFF);
	}

	for(i=0;i<=53;i++){
		GRABAR[i]=spi_read(0xFF);
	}

	for(i=0;i<=64;i++){
		GRABAR[i]=spi_read(0xFF);
	}
	for(i=0;i<=64;i++){
		GRABAR[i]=spi_read(0xFF);
	}

	for(i=0;i<=64;i++){
		GRABAR[i]=spi_read(0xFF);
	}
	for(i=0;i<=64;i++){
		GRABAR[i]=spi_read(0xFF);
	}

	for(i=0;i<=64;i++){
		GRABAR[i]=spi_read(0xFF);
	}
	for(i=0;i<=64;i++){
		GRABAR[i]=spi_read(0xFF);
	}

	for(i=0;i<=64;i++){
		GRABAR[i]=spi_read(0xFF);
	}
	
	SPI_write(0xFF);		
	SPI_write(0xFF);
	output_bit(PIN_D2,0);
}
 

Adjuntos

#76
este pequeño circuito te permite guardar o leer en la memoria eeprom. en este caso se creo un archivo .bin para simular la memoria de la eeprom.

en el archivo .bin se puede abrir con el notepad de window, para checar que mensaje tiene guardado en la eeprom.


Código:
///////////////////////////////////////
//AUTOR:JORGE ARTURO RODRIGUEZ HERNANDEZ
//TITLE;FUNCIONES DEL CCS C COMPLIER
//DATE:27/ABRIL/2009
///////////////////////////////////////

//CONFIGURACION///////////////////
#include<16f628a.h>
#fuses INTRC_IO,NOWDT,NOLVP,MCLR,NOPROTECT
#use delay(clock=4000000)
#define use_portb_lcd TRUE
#include"LCD.C"

#define EEPROM_SDA  PIN_A0
#define EEPROM_SCL  PIN_A1
#include"24256.C"
void config(void){
		set_tris_a(0x20);
		set_tris_b(0x00);
		setup_comparator(NC_NC_NC_NC);
}

void main(void){
		
		int i;
		int LETRA;

		config();
		init_ext_eeprom();
		lcd_init();

		for(i=0;i<=9;i++){
			LETRA=read_ext_eeprom(i);
			lcd_putc(LETRA);
		}
}
 

Adjuntos

#77
este programa fue hecho en matlab para adquirir la temperatura de un sensor usando un pic12f675.

primero que nada mostramos el programa que contiene el pic12f675

Código:
//------------------------------------
//TITULO: SENSOR DE TEMPERATURA Y ENVIADO A A MATLAB
//AUTOR: JORGE ARTURO RODRIGUEZ HERNANDEZ
//FECHA: 09\AGOSTO\'09
//------------------------------------

#include <12f675.h>
#fuses XT,NOWDT,NOCPD,NOPROTECT,MCLR,NOPUT
#use delay(clock=4000000)
#use rs232(baud=2400,xmit=PIN_A2,rcv=PIN_A1)

unsigned int READ,TEMP;
int ENTER;
void config(void){
		set_tris_a(0x3B);
		setup_comparator(NC_NC_NC_NC);
		setup_adc(ADC_CLOCK_INTERNAL);
		setup_adc_ports(sAN0);
}

void main(void){
		config();

		do{
			ENTER=getc();
			if(ENTER=='E'){
				READ=read_adc();
				TEMP=2*READ;
				printf("%d",TEMP);
			}
		}while(TRUE);
}

ahora vemos que usamos virtual serial port
 

Adjuntos

Arriba