|
|
Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.
Temas - vane_ccs
Páginas: [1]
1
« en: Martes 30 de Enero de 2007, 15:12 »
Hola, como estan?
Mi pregunta es si alguien conoce las optimizaciones de MPLAB C18??...yo las estoy tratando de usar porque mi codigo es demasiado extenso y necesito reducirlo...y esa es la unica manera...
El problema es que cuando habilito todas las optimizaciones el pic, cosas que antes de optimizar hacia bien esta haciendolas mal.... por ejemplo... yo estoy trabajandon con una navegacion de un pequeno sistemita... cuando me regreso de una pantalla a la anterior me pone un valor en una variable, que no es...una basura loca que no se de donde sale....
Eso lo hacia bien antes de optimizar.......
A alguien le ha pasado algo parecido??? como lo resolvio??
Muchas Gracias!!!!
2
« en: Lunes 15 de Enero de 2007, 04:30 »
Hola a todos....queria preguntarles sobre las opciones que se tienen en cuanto a memoria de programa..
Estoy haciendo un proyecto en el que interactuo con muchas funcionalidades del pic...usando compilador en C y las librerias i2c.h, xlcd.h, spi.h, usart.h, mas mis propios librerias para el manejo de una navegacion con pantallas....de verdad que esta bastante extenso y hacerlo en ensamblador era muy complejo segun lo que he leido por las cosas que estoy haciendo, aunque ocupa menos espacio..(Yo de verdad no me llevo bien con ensamblador) y ya hice todo en C y esta dificil cambiarlo.
El pic que estoy utilizando es el 18f4620 que tiene una memoria de programa flash de hasta 64K.
El problema es que apenas usando las librerias i2c.h, xlcd.h, y mis librerias para manejo de teclado, las pantallas y la navegacion, mas el programa principal..ya estoy ocupando demasiado espacio... y me falta meter usart.h y spi.h mas agregarle al programa principal la interaccion con ellas.
Como ven la cosa esta dificil....he estado tratando de reducir al maximo las pantallas y todo eso, pero me sigue faltando espacio.
Que opciones me pueden dar para maximizar el espacio en memoria de programa o reducir el codigo en cuanto a las librerias...
Este es mi primer proyecto grande en este aspecto..y no es que haya hecho muchos antes de este ya que soy relativamente nueva.
Espero puedan ayudarme....y me den alguna sugerencia que pueda eliminarme este problema...ya que necesito todas las funcionalidades que mencione.
Gracias de antemano.
3
« en: Viernes 12 de Enero de 2007, 03:50 »
Hola a todos, como estan? Estoy trabajando en mi proyecto de tesis y lo unico que me falta para terminarla es poner a funcionar los RF. (lo cual llevo tratando de hacer hace tiempo) Esta parte es importante en mi proyecto y he aprendido bastante (aunque siempre se aprende algo nuevo)...Tuve que aprender como funcionaba el SPI, ya que vi que habia muchas personas que hacian la comunicacion entre el pic y el rf por ahi, y existia una libreria en mcc18 (lo estoy haciendo en c) que ya tenia todo asi que era mas rapido. (reusabilidad) Mi programa de comunicacion funciona perfecto con el SPI entre dos pic(master/slave)....y he estado tratando de hacer la comunicacion entre el rf y pic asi, pero nada...hice mi codigo para un receptor y un transmisor y el rf receptor no recibe nada, DR1 nunca se pone en uno. He estado pensando en cual podia ser la causa....y esta puede ser que el rf no se esta configurando bien. (por tiempo o por como envio la palabra de configuracion o porque el spi tenga algun problema..) Aqui les coloco el codigo a ver si pueden detectar algun error... Esta es la libreria spi que hice para enviar y recibir datos por SPI. (usando funciones de spi.h mcc18) #include <p18F4620.h> #include <spi.h> void config_SPI(void){ OpenSPI( SPI_FOSC_16, MODE_00, SMPEND); } void config_SPI1(void){ OpenSPI( SLV_SSOFF, MODE_00, SMPEND); } void trasmitiendo_datos(unsigned char data[],int tamano){ signed char i; for(i=0;i<tamano;i++){ while(putcSPI(data[i])<0){ SSPCON1bits.WCOL = 0; data[i] = getcSPI(); ; } } } signed char recibiendo_datos(unsigned char data[],int tamano){ getsSPI(data,tamano); return(-1); }
Este es el codigo del transmisor #include <p18F4620.h> #include <delays.h> #include <spi.h> #include <sicc.h> //creada por mi para la declaracion de las funciones de mi proyecto //definicion de los pines del RF #define TX_CE PORTBbits.RB7 #define TX_CS PORTBbits.RB6 #define CONFIG_READY PORTBbits.RB0 //definicion para configuracion del RF #define PAYLOAD_SIZE 232 #define ADDR1 11 #define ADDR_CRC_SIZE 0b00100011 #define CH_SHOCK_250_FP 0b01001111 #define RF_CH2_RXEN 0b00010100 //2410MHz unsigned char data_TX[7] = "HELLO!"; void config_rf_tx(void){ unsigned char config_wd[14]; //valores a la configuration word en ShockBurst config_wd[0]= PAYLOAD_SIZE; //payload 29Bytes * 8 = 232bits de data config_wd[1]= 0; config_wd[2]= 0; config_wd[3]= 0; config_wd[4]= 0; config_wd[5]= 0; config_wd[6]= 0; config_wd[7]= 0; config_wd[8]= 0; config_wd[9]= 0; config_wd[10]= ADDR1; // direccion config_wd[11]= ADDR_CRC_SIZE; // 8 bits direccion & 16 bits CRC habilitado config_wd[12]= CH_SHOCK_250_FP; // 1 canal de recepcion & ShockBurst & 250kbps & full power config_wd[13]= RF_CH2_RXEN; // RF_CH canal 2 RXEN de transmision Delay1KTCYx(15); // (tpd2stby) 5msec TX_CE = 0; TX_CS = 1; CONFIG_READY = 0; Delay10TCYx(40); // (tcs2data) 10usec trasmitiendo_datos(config_wd,14); Delay100TCYx(100); TX_CE = 0; TX_CS = 0; CONFIG_READY = 1; Delay10TCYx(40); } void Transmision(unsigned char data[],unsigned char rf_address) { TX_CE = 1; Delay10TCYx(40); // (tce2data) 10usec trasmitiendo_datos(rf_address,1); trasmitiendo_datos(data,7); TX_CE = 0; //Inicio de la transmision } void inicio_TX(void) { config_rf_tx(); } void main(void){ unsigned char rf_address = 10; TRISAbits.TRISA6 = 0; TRISAbits.TRISA7 = 0; ADCON1 = 0b00001111; TX_CS = 0; TX_CE = 0; CONFIG_READY = 0; //configuro pines como salida CE y CS TRISBbits.TRISB7 = 0; TRISBbits.TRISB6 = 0; //configuro el pin RB0 como salida //ente indica que la configuracion ha sido realizada TRISBbits.TRISB0 = 0; config_SPI(); inicio_TX(); while(1){ Transmision(data_TX,rf_address); Delay1KTCYx(30); } }
y por ultimo el codigo del receptor #include <p18F4620.h> #include <xlcd.h> #include <delays.h> #include <spi.h> #include <sicc.h> //definicion de los pines del RF #define RX_CE PORTBbits.RB7 #define RX_CS PORTBbits.RB6 #define RX_DR1 PORTBbits.RB4 //definicion para configuracion del RF #define PAYLOAD_SIZE 232 #define ADDR1 10 #define ADDR_CRC_SIZE 0b00100011 #define CH_SHOCK_250_FP 0b01001111 #define RF_CH2_RXEN 0b00010101 //2410MHz unsigned char data_RX[7]; void config_rf_rx(void){ unsigned char buffer[17]="INICIANDO CONFIG"; unsigned char buffer1[17]="FIN CONFIG......"; unsigned char config_wd[14]; //valores a la configuration word en ShockBurst config_wd[0]= PAYLOAD_SIZE; //payload 29Bytes * 8 = 232bits de data config_wd[1]= 0; config_wd[2]= 0; config_wd[3]= 0; config_wd[4]= 0; config_wd[5]= 0; config_wd[6]= 0; config_wd[7]= 0; config_wd[8]= 0; config_wd[9]= 0; config_wd[10]= ADDR1; // direccion config_wd[11]= ADDR_CRC_SIZE; // 8 bits direccion & 16 bits CRC habilitado config_wd[12]= CH_SHOCK_250_FP; // 1 canal de recepcion & ShockBurst & 250kbps & full power config_wd[13]= RF_CH2_RXEN; // RF_CH canal 2 RXEN de transmision Delay1KTCYx(15); RX_CE = 0; RX_CS = 1; Delay10TCYx(40); // (tcs2data) 10usec trasmitiendo_datos(config_wd,14); Delay100TCYx(100); RX_CE = 1; RX_CS = 0; //empiezo a monitoriar el aire Delay10TCYx(40); } void Recepcion(int tamano) { RX_CE = 0; data_RX[0]='\0'; if(recibiendo_datos(data_RX,tamano)<0); RX_CE = 1; //Inicio de nuevo monitoreo del aire } void inicio_RX(void) { unsigned char buffer[17]="RF_RX INICIADO."; config_SPI(); config_rf_rx(); } void main(void){ TRISAbits.TRISA6 = 0; TRISAbits.TRISA7 = 0; ADCON1 = 0b00001111; //configuro pines como entrada DR1 y salida CE y CS TRISBbits.TRISB7 = 0; TRISBbits.TRISB6 = 0; TRISBbits.TRISB4 = 1; OpenXLCD(FOUR_BIT & LINES_5X7); inicio_RX(); while(1){ if(RX_DR1==1){ Recepcion(6); while(BusyXLCD()); SetDDRamAddr(0x00); putsXLCD(data_RX); } } }
Se que el post esta bastante largo, disculpen  pero pienso que es la unica manera de que entiendan que estoy haciendo... Si estoy cometiendo alguna burrada en alguna parte del codigo por favor diganme, escucho cualquier sugerencia. Muchas gracias de antemano.
4
« en: Lunes 30 de Octubre de 2006, 13:43 »
Hola a todos, espero que se encuentren bien..  Se me han presentado algunas dudas en cuanto a este RF...Ojala ustedes puedan sacarme de ellas.. 1.- El modulo TRF-2.4G de laipac detecta uso de portadora antes de iniciar una transmision?? 2.- Estoy utilizando el modulo MSSP del pic 18f4620...Logre hacer funcionar el modulo SPI entre dos pics..(master-slave) Esto lo hice con el fin de utilizar este protocolo de comunicacion serial entre el pic y el RF (No lo he probado aun...porque estoy soldando ya que no puedo usar al protoboard para este tipo de comunicaciones porque causa mucho ruido).... Otro tipo de comunicacion que estoy usando es el modulo UART para la comunicacion entre el pic y la pc... En el pic tengo que verificar si me viene informacion del RF o de UART... para ver que peticion atiendo.... Esto puede causar algun problema???? tratar de verificar entre estos dos modulos cual me esta hablando?? estos pueden trabajar al mismo tiempo??  3.- Esta duda viene por lo del modulo SPI....Estoy usando una memoria externa que lamentablemente la pude conseguir con protocolo I2C...ya que si hubiera sido con SPI hubiera trabajado con el modo esclavo del SPI y hubiera sido mas facil. El problema es que estuve buscando a ver si habia algun problema en utilizar los dos tipos de protocolos....y encontre que no habia problema ya que la memoria (I2C) no iba a atender ningun tipo de comunicacion mientras no se le envie una condicion de START...pero.....el hecho de que estos dos modulos trabajen con el mismo buffer no afecta?? Bueno esas son todas mis dudas hasta ahora...ya que siempre sale una duda mas...  Gracias por su ayuda.......espero que puedan echarme una mano con este problema. 
5
« en: Lunes 25 de Septiembre de 2006, 23:29 »
Hola a todos, espero que esten bien.... Mi problema es que cuando uso cualquiera de estas dos funciones para sumar dos valores y luego mostrar el resultado en un lcd....no hace nada y el lcd no pone el resultado... Este es mi codigo... #include <p18F4620.h> #include <xlcd.h> #include <stdlib.h> #include <sicc.h> void main(void){ char key; char numero1[2],numero2[2],numero3[2]; int i,j,num1,num2,num3; TRISAbits.TRISA6 = 0; TRISAbits.TRISA7 = 0; OpenXLCD(FOUR_BIT & LINES_5X7); SetDDRamAddr(0x00); for(i=0;i<2;i++){ key=char_press(); numero1[i]=key; putcXLCD(key); } numero1[i]='\0'; SetDDRamAddr(0x40); for(j=0;j<2;j++){ key=char_press(); numero2[j]=key; putcXLCD(key); } numero2[j]='\0'; num1 = atoi(numero1); num2 = atoi(numero2); num3 = num1 + num2; SetDDRamAddr(0x50); putsXLCD(itoa(num3,numero3)); }
Alguien a trabajado con estas funciones y sabe que puede estar pasando??? Gracias..
6
« en: Sábado 23 de Septiembre de 2006, 05:31 »
Hola como estan todos? Mi pregunta es la siguiente..... Yo estoy usando el modulo SPI para la comunicacion entre el pic 18f4620 y un TRF-2.4G Transceiver.....y para comunicar el pic con una memoria i2c, estoy usando el modulo I2C. Estos modos de comunicacion me estan funcionando pero por circuitos separados...y al final de todo tengo que unirlos y ponerlos en un solo pic.  Y tengo la duda de que haya algun problema al unirlos ya que tienen lineas en comun... Tendre problemas con esto? Hay alguna manera de que pueda solventar ese problema????....teniendo como ultima opcion el cambiar a i2c la comunicacion entre el pic y el RF. Que es probable que lo mejor sea eso...pero queria saber ya que hice el trabajo con el spi....si habia otra opcion....o si simplemente no hay problema alguno.... Gracias por ayuda....
7
« en: Sábado 16 de Septiembre de 2006, 03:48 »
Hola, estoy tratando de arreglar algo en el codigo de inicializacion de mi lcd...estoy usando una libreria de mcc18 que se llama xlcd.h esta tiene una rutina llama openxlcd a la que le colocas los comandos de inicio del lcd. Bueno antes no le mandaba de cuantas lineas era el lcd y cual era la cantidad de carateres que puede colocarse en cada linea....simplemente colocaba que queria que fuera multilinea. Mandaba a escribir en cada una de las lineas indicando la direccion cualquier cosa y funciona en el simulador (proteus). El problema es cuando lo pruebo en fisico, ya que a veces pone 2 lineas y otras veces 4. Obviamente porque no le estoy pasando el comando que le diga que va a iniciar siempre en 4 lineas. Busque el datasheet del hd44780 y por lo que he leido el habla del comando de entrada del lcd y hay un bit (N) que es para indicar el numero de lineas, pero solo habla de dos opciones que son 1 o 2 lineas segun sea 0 o 1 lo que pongas en ese bit. Pero como hago cuando son 4 lineas????  Estoy estancada en esto y nada no he podido dar con la respuesta... Ojala alguien pueda ayudarme  Gracias.
8
« en: Sábado 9 de Septiembre de 2006, 19:04 »
Hola a todos.... estoy trabajando con una memoria externa (24AA256) y realice unas rutinas para leer y escribir en dicha memoria (desde el pic 18F4620)... las cuales funcionan perfectamente... ahora mi problema es... que no se que hacer para borrar todo lo que escribi y poner la memoria en blanco Las rutinas estan hechas en C... y estoy usando el compilador C18. Gracias de Antemano, Cualquier ayuda que me puedan prestar... se los agradeceria... 
9
« en: Viernes 8 de Septiembre de 2006, 19:09 »
Hola que tal? Estoy empezando a trabajar con una memoria externa 24AA256 I2c y un pic 18F4620.. Estoy utilizando el proteus para simular el circuito y el debbuger I2c de este para observar los datos que pasan de pic a memoria y de memoria a pic. Estoy escribiendo un byte (en este caso una a) en la memoria y luego se supone que leo el byte y lo imprimo en un lcd. Este es mi codigo #include <p18F4620.h> #include <xlcd.h> #include <delays.h> #include <i2c.h> unsigned char data_w = 'a'; unsigned char data_r; void config_I2C(void){ OpenI2C(MASTER, SLEW_ON);// Initialize I2C module SSPADD = 12; //400kHz Baud clock(9) @8MHz } unsigned char LeerBI2C(char Address) // Escribe un byte a un esclavo en I2C { char DATA_I2C; IdleI2C(); // ensure module is idle StartI2C(); // initiate START condition while ( SSPCON2bits.SEN ); // wait until start condition is over WriteI2C( Address ); // Selecciona el dispositivo esclavo IdleI2C(); // Asegura que el modulo este desocupado if ( !SSPCON2bits.ACKSTAT ) // Prueba por la condicion de ACK, si es recibida { DATA_I2C = ReadI2C(); IdleI2C(); // ensure module is idle StopI2C(); // send STOP condition while ( SSPCON2bits.PEN ); // wait until stop condition is over } return DATA_I2C; } void delayms(int tiempo) // delays en ms a 20MHz { int cuenta_ = 0; while ( cuenta_ < tiempo ) { Delay1KTCYx(2); cuenta_++; } } void main(void) { TRISAbits.TRISA6 = 0; TRISAbits.TRISA7 = 0; config_I2C(); OpenXLCD(FOUR_BIT & LINES_5X7); EEByteWrite(0xA0,0x70, data_w); delayms(1000); data_r = LeerBI2C(0x70); SetDDRamAddr(0x00); putcXLCD(data_r); }
La funcion EEByteWrite es de la libreria I2c del compilador C18. Y este es el codigo: unsigned char EEByteWrite( unsigned char control, unsigned char address, unsigned char data ) { IdleI2C(); // ensure module is idle StartI2C(); // initiate START condition while ( SSPCON2bits.SEN ); // wait until start condition is over if ( PIR2bits.BCLIF ) // test for bus collision { return ( -1 ); // return with Bus Collision error } else // start condition successful { if ( WriteI2C( control ) ) // write byte - R/W bit should be 0 { return ( -3 ); // set error for write collision } IdleI2C(); // ensure module is idle if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received { if ( WriteI2C( address ) ) // write word address for EEPROM { return ( -3 ); // set error for write collision } IdleI2C(); // ensure module is idle if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received { if ( WriteI2C( data ) ) // data byte for EEPROM { return ( -3 ); // set error for write collision } } else { return ( -2 ); // return with Not Ack error condition } } else { return ( -2 ); // return with Not Ack error condition } } IdleI2C(); // ensure module is idle StopI2C(); // send STOP condition while ( SSPCON2bits.PEN ); // wait until stop condition is over if ( PIR2bits.BCLIF ) // test for bus collision { return ( -1 ); // return with Bus Collision error } return ( 0 ); // return with no error }
Cuando corro la simulacion lo que recibo es: en la escritura esto: S 41 A E1 A C3 A P que creo que esta bien.. y en la lectura esto: S E1 N Sr 41 A E1 A C3 A P que no se si este bien por el N Y el resultado en el lcd es nada, no escribe cuando le digo que me escriba el mensaje leido... Realmente no se lo que pasa.... Por favor, si alguien tiene alguna idea, le agradeceria que me diera luz Gracias...
10
« en: Jueves 24 de Agosto de 2006, 07:30 »
Hola, soy nueva con la interfaz spi y tengo algunos problemas. Estoy trabajando con la libreria spi.h del compilador C18. Lo que intento hacer es, comunicar dos pics 18f4620 (master y slave) ambos con un oscilador de 20MHz. El master le envia un mensaje "hola" al slave. Este mensaje al ser recibido se imprime en el lcd del slave. Bueno esto supongo que es muy sencillo...pero de verdad ha sido mi dolor de cabeza por muchos dias. El lcd del slave no esta escribiendo nada, lo que me hace suponer que no le esta llegando nada al slave o que estoy haciendo algo mal al recibir el mensaje. No se que pueda ser... Seria muy feliz si me echaran una mano, dandole un vistazo al pequeño codigo de mi slave y mi master a ver si algo les parece que les esta faltando o sobrando. Este es el codigo de mi master #include <p18F4620.h> #include <xlcd.h> #include <spi.h> #include <stdio.h> #include <string.h> //Configuramos el SPI void config_SPI(void){ //configuro el Serial Port SPI Master OpenSPI( SPI_FOSC_16, MODE_11, SMPMID); } void trasmitiendo_datos(void){ char frame[5] = "hola"; char buffer[16]; //enviamos putsSPI((unsigned char *)frame); //Envio un mensaje que diga que la data fue transmitida SetDDRamAddr(0x00); sprintf(buffer,(const rom far char *)"Datos Enviados!"); putsXLCD(buffer); } void main(void){ //salida del clock TRISAbits.TRISA6 = 0; TRISAbits.TRISA7 = 0; OpenXLCD(FOUR_BIT & LINES_5X7); config_SPI(); trasmitiendo_datos(); while(1){ ; } }
Y este es el codigo de mi slave. #include <p18F4620.h> #include <xlcd.h> #include <spi.h> #include <stdio.h> #include <string.h> //string que recibira los datos unsigned char datos[5]; //Configuramos el SPI void config_SPI(void){ OpenSPI( SLV_SSON, MODE_11, SMPMID); } void recibiendo_datos(void){ //recibimos getsSPI(datos,5); //Envio un mensaje que muestre la data recibida SetDDRamAddr(0x00); putsXLCD(datos); } void main(void){ //salida del clock TRISAbits.TRISA6 = 0; TRISAbits.TRISA7 = 0; OpenXLCD(FOUR_BIT & LINES_5X7); config_SPI(); while(1){ recibiendo_datos(); } }
De verdad muchisimas gracias por la ayuda que me puedan prestar. Saludos.
11
« en: Lunes 21 de Agosto de 2006, 07:37 »
Hola a todos, como estan? Tengo un problema. Esto haciendo la comunicacion entre el rf y el pic (18f4620) a traves de la interfaz SPI. Uso la libreria spi.h del compilador c18. El problema es el siguiente...estoy trabajando con un oscilador de 20MHz, eso hace 200ns por cada instruccion. Segun lo que se, el RF necesita minimo 500ns para cada transmision. Por esta razon, pense en usar el oscilador interno a 8MHz, lo que me daria los 500ns necesarios... OSCCON = 0b01110010; //Coloca el oscilador interno a 8MHz while(OSCCONbits.IOFS == 0); //Espera a que se estabilice la frecuencia
El problema con esto es que no hace nada.... el RF no hace nada...ni recibe, ni trasmite, ni comfigura el SPI. Cuando uso los 20MHz...si parece configurar el SPI pero el rf sigue sin funcionar.  Creo que lo que esta afectando es el oscilador, la parte del clock, pero no se exactamente que pueda ser... Aqui esta el codigo del transmisor...para ver que me dicen... Gracias por la ayuda que me puedan dar. Saludos.
Páginas: [1]
|
|
|
Mostrar Mensajes
