• Domingo 28 de Abril de 2024, 19:30

Mostrar Mensajes

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.


Mensajes - vane_ccs

Páginas: [1]
1
Programación en C / Optimizaciones C18
« 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
Microcontroladores / Memoria De Programa Insuficiente
« 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
Microcontroladores / Trf-2.4g Desesperada
« 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)

Código: Text
  1.  
  2.  
  3. #include <p18F4620.h>
  4. #include <spi.h>
  5.  
  6.  
  7. void config_SPI(void){
  8.  
  9.   OpenSPI( SPI_FOSC_16,
  10.             MODE_00,    
  11.           SMPEND);
  12.  
  13. }
  14.  
  15. void config_SPI1(void){
  16.  
  17.   OpenSPI( SLV_SSOFF,
  18.          MODE_00,    
  19.          SMPEND);
  20. }
  21.  
  22.  
  23. void trasmitiendo_datos(unsigned char data[],int tamano){
  24.  
  25.   signed char i;
  26.  
  27.   for(i=0;i<tamano;i++){                
  28.  
  29.     while(putcSPI(data[i])<0){
  30.       SSPCON1bits.WCOL = 0;
  31.       data[i] = getcSPI();
  32.       &#59;
  33.     }
  34.   }
  35. }
  36.  
  37.  
  38. signed char recibiendo_datos(unsigned char data[],int tamano){
  39.  
  40.     getsSPI(data,tamano);
  41.     return(-1);
  42. }
  43.  
  44.  
  45.  

Este es el codigo del transmisor

Código: Text
  1.  
  2.  
  3. #include <p18F4620.h>
  4. #include <delays.h>
  5. #include <spi.h>
  6. #include <sicc.h>  //creada por mi para la declaracion de las funciones de mi proyecto
  7.  
  8.  
  9. //definicion de los pines del RF
  10. #define TX_CE      PORTBbits.RB7
  11. #define TX_CS      PORTBbits.RB6
  12.  
  13. #define CONFIG_READY PORTBbits.RB0
  14.  
  15. //definicion para configuracion del RF
  16. #define PAYLOAD_SIZE   232
  17. #define ADDR1       11
  18. #define ADDR_CRC_SIZE   0b00100011
  19. #define CH_SHOCK_250_FP 0b01001111
  20. #define RF_CH2_RXEN   0b00010100   //2410MHz
  21.  
  22.  
  23. unsigned char data_TX[7] = "HELLO!";
  24.  
  25. void config_rf_tx(void){
  26.  
  27.   unsigned char config_wd[14];
  28.  
  29.   //valores a la configuration word en ShockBurst
  30.  
  31.   config_wd[0]= PAYLOAD_SIZE; //payload  29Bytes * 8 = 232bits de data
  32.   config_wd[1]= 0;
  33.   config_wd[2]= 0;
  34.   config_wd[3]= 0;
  35.   config_wd[4]= 0;
  36.   config_wd[5]= 0;
  37.   config_wd[6]= 0;
  38.   config_wd[7]= 0;
  39.   config_wd[8]= 0;
  40.   config_wd[9]= 0;
  41.   config_wd[10]= ADDR1; // direccion
  42.   config_wd[11]= ADDR_CRC_SIZE; // 8 bits direccion & 16 bits CRC habilitado
  43.   config_wd[12]= CH_SHOCK_250_FP; // 1 canal de recepcion & ShockBurst & 250kbps & full power
  44.   config_wd[13]= RF_CH2_RXEN; // RF_CH canal 2 RXEN de transmision
  45.  
  46.  
  47.   Delay1KTCYx(15);   // (tpd2stby) 5msec  
  48.  
  49.   TX_CE = 0; TX_CS = 1; CONFIG_READY = 0;
  50.    
  51.                 Delay10TCYx(40);   // (tcs2data) 10usec
  52.  
  53.   trasmitiendo_datos(config_wd,14);
  54.  
  55.   Delay100TCYx(100);
  56.  
  57.     TX_CE = 0; TX_CS = 0; CONFIG_READY = 1;
  58.    
  59.     Delay10TCYx(40);
  60. }
  61.  
  62.  
  63. void Transmision(unsigned char data[],unsigned char rf_address)
  64. {
  65.  
  66.   TX_CE = 1;
  67.    
  68.     Delay10TCYx(40);   // (tce2data) 10usec
  69.    
  70.      trasmitiendo_datos(rf_address,1);
  71.  
  72.     trasmitiendo_datos(data,7);
  73.  
  74.     TX_CE = 0; //Inicio de la transmision  
  75.    
  76.      
  77. }
  78.  
  79.  
  80. void inicio_TX(void)
  81. {    
  82.     config_rf_tx();
  83. }
  84.  
  85. void main(void){
  86.  
  87.   unsigned char rf_address = 10;
  88.  
  89.   TRISAbits.TRISA6 = 0;
  90.   TRISAbits.TRISA7 = 0;
  91.  
  92.   ADCON1 = 0b00001111;
  93.  
  94.   TX_CS = 0;
  95.   TX_CE = 0;
  96.   CONFIG_READY = 0;
  97.  
  98.   //configuro pines como salida CE y CS
  99.   TRISBbits.TRISB7 = 0;
  100.   TRISBbits.TRISB6 = 0;
  101.  
  102.   //configuro el pin RB0 como salida
  103.   //ente indica que la configuracion ha sido realizada
  104.   TRISBbits.TRISB0 = 0;
  105.  
  106.   config_SPI();
  107.  
  108.   inicio_TX();
  109.  
  110.  
  111.  
  112.   while(1){
  113.    
  114.     Transmision(data_TX,rf_address);
  115.     Delay1KTCYx(30);
  116.   }
  117. }
  118.  
  119.  
  120.  


y por ultimo el codigo del receptor


Código: Text
  1.  
  2.  
  3. #include <p18F4620.h>
  4. #include <xlcd.h>
  5. #include <delays.h>
  6. #include <spi.h>
  7. #include <sicc.h>
  8.  
  9.  
  10. //definicion de los pines del RF
  11. #define RX_CE      PORTBbits.RB7
  12. #define RX_CS      PORTBbits.RB6
  13. #define RX_DR1     PORTBbits.RB4
  14.  
  15. //definicion para configuracion del RF
  16. #define PAYLOAD_SIZE   232
  17. #define ADDR1       10
  18. #define ADDR_CRC_SIZE   0b00100011
  19. #define CH_SHOCK_250_FP 0b01001111
  20. #define RF_CH2_RXEN   0b00010101  //2410MHz
  21.  
  22. unsigned char data_RX[7];
  23.  
  24. void config_rf_rx(void){
  25.  
  26.   unsigned char buffer[17]="INICIANDO CONFIG";
  27.   unsigned char buffer1[17]="FIN CONFIG......";
  28.  
  29.   unsigned char config_wd[14];
  30.  
  31.   //valores a la configuration word en ShockBurst
  32.  
  33.   config_wd[0]= PAYLOAD_SIZE; //payload  29Bytes * 8 = 232bits de data
  34.   config_wd[1]= 0;
  35.   config_wd[2]= 0;
  36.   config_wd[3]= 0;
  37.   config_wd[4]= 0;
  38.   config_wd[5]= 0;
  39.   config_wd[6]= 0;
  40.   config_wd[7]= 0;
  41.   config_wd[8]= 0;
  42.   config_wd[9]= 0;
  43.   config_wd[10]= ADDR1; // direccion
  44.   config_wd[11]= ADDR_CRC_SIZE; // 8 bits direccion & 16 bits CRC habilitado
  45.   config_wd[12]= CH_SHOCK_250_FP; // 1 canal de recepcion & ShockBurst & 250kbps & full power
  46.   config_wd[13]= RF_CH2_RXEN; // RF_CH canal 2 RXEN de transmision
  47.  
  48.   Delay1KTCYx(15);    
  49.  
  50.  
  51.     RX_CE = 0; RX_CS = 1;
  52.  
  53.   Delay10TCYx(40);   // (tcs2data) 10usec
  54.  
  55.   trasmitiendo_datos(config_wd,14);
  56.  
  57.     Delay100TCYx(100);
  58.    
  59.     RX_CE = 1; RX_CS = 0;  //empiezo a monitoriar el aire
  60.    
  61.     Delay10TCYx(40);
  62.    
  63. }
  64.  
  65.  
  66. void Recepcion(int tamano)
  67. {  
  68.     RX_CE = 0;
  69.  
  70.   data_RX[0]='\0';
  71.   if(recibiendo_datos(data_RX,tamano)<0);
  72.    
  73.     RX_CE = 1; //Inicio de nuevo monitoreo del aire
  74. }
  75.  
  76.  
  77. void inicio_RX(void)
  78. {
  79.   unsigned char buffer[17]="RF_RX INICIADO.";
  80.  
  81.   config_SPI();
  82.     config_rf_rx();
  83.    
  84. }
  85.  
  86. void main(void){
  87.  
  88.   TRISAbits.TRISA6 = 0;
  89.   TRISAbits.TRISA7 = 0;
  90.  
  91.   ADCON1 = 0b00001111;
  92.  
  93.   //configuro pines como entrada DR1 y salida CE y CS
  94.   TRISBbits.TRISB7 = 0;
  95.   TRISBbits.TRISB6 = 0;
  96.   TRISBbits.TRISB4 = 1;
  97.  
  98.   OpenXLCD(FOUR_BIT & LINES_5X7);
  99.  
  100.   inicio_RX();
  101.  
  102.   while(1){
  103.    
  104.     if(RX_DR1==1){
  105.      
  106.       Recepcion(6);
  107.      
  108.       while(BusyXLCD());
  109.       SetDDRamAddr(0x00);
  110.       putsXLCD(data_RX);
  111.                    
  112.     }
  113.   }
  114. }
  115.  
  116.  

Se que el post esta bastante largo, disculpen :losiento: 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
Microcontroladores / Trf-2.4g De Laipac Preguntas
« 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?? :huh:

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
Microcontroladores / Re: Spi Y I2c
« en: Miércoles 25 de Octubre de 2006, 20:00 »
Hola amigos, en un foro encontre que no habia problema ya que el protocolo i2c siempre estara esperando por una condicion de inicio y mientras no se la mande el no se activa..por lo tanto podria trabajar con el SPI tambien...  ;)

Cualquier discordancia con esto..por favor avisenme..

Gracias, :)

Bye

6
Programación en C / Re: Funciones Itoa Y Atoi De Stdlib De Mcc18
« en: Martes 26 de Septiembre de 2006, 21:20 »
Hola, hice lo que me dijiste pero me dan los siguientes errores en esta linea

-->   numero3 = itoa(num3,numero3);
   
   SetDDRamAddr(0x50);
   putsXLCD(numero3);

errores  

-->   Error [1153] cannot assign array type objects
                Error [1102] cannot assign to 'const' modified object
                Error [1131] type mismatch in assignment

Que puedo hacer para solucionar esto???  :(

que otra cosa puedo hacer??? de verdad necesito esta funcion para una parte del proyecto que estoy haciendo...... o por lo menos alguna solucion  :unsure:

Gracias por la ayuda...

7
Programación en C / Re: Funciones Itoa Y Atoi De Stdlib De Mcc18
« en: Martes 26 de Septiembre de 2006, 06:57 »
Hola, ya verifique que la funcion atoi me esta funcionando....el problema es la funcion itoa...

Que podra ser???  Alguna idea??  :huh:

Gracias  :)

8
Programación en C / Funciones Itoa Y Atoi De Stdlib De Mcc18
« 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...

Código: Text
  1.  
  2. #include <p18F4620.h>
  3. #include <xlcd.h>
  4. #include <stdlib.h>
  5. #include <sicc.h>
  6.  
  7.  
  8. void main(void){
  9.  
  10.   char key;
  11.   char numero1[2],numero2[2],numero3[2];
  12.   int i,j,num1,num2,num3;
  13.  
  14.   TRISAbits.TRISA6 = 0;
  15.   TRISAbits.TRISA7 = 0;
  16.  
  17.   OpenXLCD(FOUR_BIT & LINES_5X7);
  18.  
  19.   SetDDRamAddr(0x00);
  20.   for(i=0;i<2;i++){
  21.     key=char_press();
  22.     numero1[i]=key;
  23.     putcXLCD(key);
  24.   }
  25.   numero1[i]='\0';
  26.  
  27.   SetDDRamAddr(0x40);
  28.   for(j=0;j<2;j++){  
  29.     key=char_press();
  30.     numero2[j]=key;
  31.     putcXLCD(key);
  32.   }
  33.   numero2[j]='\0';
  34.    
  35.   num1 = atoi(numero1);
  36.   num2 = atoi(numero2);
  37.   num3 = num1 + num2;
  38.  
  39.   SetDDRamAddr(0x50);
  40.   putsXLCD(itoa(num3,numero3));
  41. }
  42.  
  43.  

Alguien a trabajado con estas funciones y sabe que puede estar pasando???  :huh:

Gracias..

9
Microcontroladores / Spi Y I2c
« 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.  :unsure:   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....  ;)

10
Microcontroladores / Re: Memorias Externas
« en: Jueves 21 de Septiembre de 2006, 16:49 »
Hola Jonathan, GRACIAS....yo tambien estoy en eso... :)    

Sabes que ademas de ese problema...me esta apareciendo otro...creo que si te dije que estaba trabajando con el pic 18f4620...bueno.. ahora estoy soldando el circuito porque estoy trabajando con tambien con el modulo SPI y en el simulador funciona perfect y cuando lo corria en fisico en el protoboard manda basura... bueno soldando el circuito me salio un problema con el circuito de reset.... yo pensaba que estaba bien pues lo estaba haciendo tal cual como dice en el datasheet del pic...pues bien, algo no parece estar funcionando, sin que yo presione el boton de reset el lcd se resetea...  <_<  y a veces no se resetea bien....Por lo menos ahora estoy trabajando con un programa de prueba en el que con un teclado escribo numeros en el LCD....Escribe los numeros bien pero cuando le doy a boton de reset no me borra la primera linea, es decir, no llega a la instruccion inicial bien...

No se de verdad que pasa. Quizas estoy metiendo la pata con el circuito de reset y por eso me hace esa cantidad de barbaridades  :huh:

Tienes alguna idea???

Saludos y Gracias

11
Microcontroladores / Inicio De Un Lcd 16x4
« 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????  :brickwall:

Estoy estancada en esto y nada no he podido dar con la respuesta...

Ojala alguien pueda ayudarme :D

Gracias.

12
Microcontroladores / Re: Memorias Externas
« en: Sábado 16 de Septiembre de 2006, 02:02 »
Hola jonathan :) gracias por responder... sip me sirve perfecto cuando hago una sola lectura.

Tienes alguna idea de que pueda ser???  :unsure:

Saludos.

13
Microcontroladores / Re: Memorias Externas
« en: Jueves 14 de Septiembre de 2006, 02:59 »
Hola, acabo de hacer una prueba leyendo dos paginas de la memoria, una lectura despues de la otra y pasa lo mismo....

Código: Text
  1.  
  2.                 ReadSQMem(0xA0,0x02,0xC0,data_rd,5);
  3.   SetDDRamAddr(0x00);
  4.   putsXLCD(data_rd);
  5.  
  6.   ReadSQMem(0xA0,0x03,0x80,data_rd,5);
  7.   SetDDRamAddr(0x00);
  8.   putsXLCD(data_rd);
  9.  
  10.  

Pense que podria ser que necesito esperar un tiempo antes de volver a leer pero nop hace lo mismo. <_<

Que puede estar pasando????  :huh:

Por favor, si a alguien se le ocurre algo y tiene mas experiencias con memorias de este tipo....ayudenme un poquito.  ;)

14
Microcontroladores / Re: Memorias Externas
« en: Jueves 14 de Septiembre de 2006, 02:34 »
Hola!, ya hice la rutina que borra la memoria con un bucle...  :bravo:   :gracias:

Ahora tengo otro problema que resolver  :brickwall:   :ouch: .... Como conte en el post inicial ya hice la rutina que lee, pero esta solo lee una pagina dandole la direccion.  

Estoy tratando de leer una serie de paginas de memoria seguidas. Mediante un bucle hago que se pongan automaticamente las direcciones de paginas de manera consecutiva, en orden......

El problema es que cuando corro la simulacion en proteus, me lee nada mas la primera pagina y de la segunda solo muestra la condicion de start....

No se que pueda estar pasando...lo esta haciendo nada mas para la primera pagina.

Lo de las direcciones automaticas consecutivas lo uso tambien para la escritura y funciona bien, por eso me extrana esto.  :think:

Esta es la rutina que estoy usando...

Código: Text
  1.  
  2. void leerTodoMem(void){
  3.  
  4.   signed char i,contador=0;
  5.   unsigned char addressH = 0x00;
  6.   unsigned char addressL = 0x00;  
  7.  
  8.   for(i=0;i<16;i++){  
  9.        
  10.       ReadSQMem(0xA0,addressH,addressL,data_rd,5);
  11.       putsXLCD(data_rd);
  12.                  
  13.     if(contador==3){
  14.       contador = 0;
  15.       addressH = AddH(addressH);      
  16.       addressL = AddL(contador,addressL);
  17.     }
  18.     else{
  19.       contador++;
  20.         addressL = AddL(contador,addressL);  
  21.     }  
  22.   }  
  23. }
  24.  
  25.  

Y estas son las rutinas que uso

Código: Text
  1.  
  2. unsigned char AddH(unsigned char addHActual){
  3.   return(addHActual+1);
  4. }
  5.  
  6. unsigned char AddL(signed char cont,unsigned char addLActual){
  7.  
  8.   switch(cont){
  9.    
  10.     case 0: addLActual = 0b00000000;
  11.           break;
  12.     case 1: addLActual = 0b01000000;
  13.           break;
  14.     case 2: addLActual = 0b10000000;
  15.           break;
  16.     case 3: addLActual = 0b11000000;
  17.           break;
  18.          
  19.   }
  20.   return (addLActual);
  21. }
  22.  
  23.  

Ojala me puedan ayudar  :ayuda:

Saludos.

15
Microcontroladores / Re: Memorias Externas
« en: Martes 12 de Septiembre de 2006, 01:52 »
Gracias Jonathan un millon....lo voy a intentar y aviso...  ;)

Saludos.  :D

16
Microcontroladores / Memorias Externas
« 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  :unsure:  :unsure:  :unsure:

Las rutinas estan hechas en C... y estoy usando el compilador C18.

Gracias de Antemano,

Cualquier ayuda que me puedan prestar... se los agradeceria...  

 :comp:  :comp:  :comp:

17
Programación en C / Memoria I2c
« 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

Código: Text
  1.  
  2. #include <p18F4620.h>
  3. #include <xlcd.h>
  4. #include <delays.h>
  5. #include <i2c.h>
  6.  
  7. unsigned char data_w = 'a';
  8. unsigned char data_r;
  9.  
  10. void config_I2C(void){
  11.  
  12.   OpenI2C(MASTER, SLEW_ON);// Initialize I2C module
  13.   SSPADD = 12; //400kHz Baud clock(9) @8MHz
  14.  
  15. }
  16.  
  17.  
  18. unsigned char LeerBI2C(char Address) // Escribe un byte a un esclavo en I2C
  19. {
  20.    char DATA_I2C;
  21.   IdleI2C();                      // ensure module is idle
  22.   StartI2C();                     // initiate START condition
  23.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  24.   WriteI2C( Address );      // Selecciona el dispositivo esclavo
  25.   IdleI2C();                      // Asegura que el modulo este desocupado
  26.   if ( !SSPCON2bits.ACKSTAT )     // Prueba por la condicion de ACK, si es recibida
  27.   {
  28.     DATA_I2C = ReadI2C();
  29.     IdleI2C();                   // ensure module is idle
  30.     StopI2C();                   // send STOP condition
  31.     while ( SSPCON2bits.PEN );   // wait until stop condition is over
  32.   }
  33.   return DATA_I2C;
  34. }
  35.  
  36. void delayms(int tiempo)      // delays en ms a 20MHz
  37. {
  38.   int cuenta_ = 0;
  39.   while ( cuenta_ < tiempo )
  40.   {
  41.     Delay1KTCYx(2);
  42.     cuenta_++;
  43.   }
  44. }
  45.  
  46. void main(void)
  47. {
  48.  
  49.   TRISAbits.TRISA6 = 0;
  50.   TRISAbits.TRISA7 = 0;
  51.  
  52.   config_I2C();
  53.  
  54.     OpenXLCD(FOUR_BIT & LINES_5X7);
  55.  
  56.   EEByteWrite(0xA0,0x70, data_w);
  57.  
  58.  
  59.   delayms(1000);
  60.  
  61.   data_r = LeerBI2C(0x70);
  62.   SetDDRamAddr(0x00);      
  63.   putcXLCD(data_r);
  64.  
  65. }
  66.  
  67.  
  68.  

La funcion EEByteWrite es de la libreria I2c del compilador C18. Y este es el codigo:

Código: Text
  1.  
  2. unsigned char EEByteWrite( unsigned char control, unsigned char address, unsigned char data )
  3. {
  4.   IdleI2C();                      // ensure module is idle
  5.   StartI2C();                     // initiate START condition
  6.   while ( SSPCON2bits.SEN );      // wait until start condition is over
  7.   if ( PIR2bits.BCLIF )           // test for bus collision
  8.   {
  9.     return ( -1 );                // return with Bus Collision error
  10.   }
  11.   else                            // start condition successful
  12.   {
  13.     if ( WriteI2C( control ) )    // write byte - R/W bit should be 0
  14.     {
  15.       return ( -3 );              // set error for write collision
  16.     }
  17.  
  18.     IdleI2C();                    // ensure module is idle
  19.     if ( !SSPCON2bits.ACKSTAT )   // test for ACK condition received
  20.     {
  21.       if ( WriteI2C( address ) )  // write word address for EEPROM
  22.       {
  23.         return ( -3 );            // set error for write collision
  24.       }
  25.  
  26.       IdleI2C();                  // ensure module is idle
  27.       if ( !SSPCON2bits.ACKSTAT ) // test for ACK condition received
  28.       {
  29.         if ( WriteI2C( data ) )   // data byte for EEPROM
  30.         {
  31.           return ( -3 );          // set error for write collision
  32.         }
  33.       }
  34.       else
  35.       {
  36.         return ( -2 );            // return with Not Ack error condition  
  37.       }
  38.     }
  39.     else
  40.     {
  41.       return ( -2 );              // return with Not Ack error condition  
  42.     }
  43.   }
  44.  
  45.   IdleI2C();                      // ensure module is idle  
  46.   StopI2C();                      // send STOP condition
  47.   while ( SSPCON2bits.PEN );      // wait until stop condition is over
  48.   if ( PIR2bits.BCLIF )           // test for bus collision
  49.   {
  50.     return ( -1 );                // return with Bus Collision error
  51.   }
  52.   return ( 0 );                   // return with no error
  53. }
  54.  
  55.  

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....  :huh:

Por favor, si alguien tiene alguna idea, le agradeceria que me diera luz  ;)

Gracias...  ;)

18
Programación en C / Re: Nueva Con Spi
« en: Martes 5 de Septiembre de 2006, 00:51 »
Hola a todos....

Probe lo de la coneccion y logre que enviara el mensaje bien...por ejemplo hola no llega como hodd ni nada por el estilo, sino como hola....pero sigo teniendo el mismo problema con la basura...ya que me manda el mensaje + basura  ?????  :huh:  

Alguien tiene alguna idea de que pueda ser?? :unsure:

Muchas gracias por la ayuda que dan  ;)

Saludos!!! :)

19
Programación en C / Re: Nueva Con Spi
« en: Sábado 26 de Agosto de 2006, 19:28 »
Hola a todos, ya pude hacer funcionar el spi enviando y recibiendo string..pero eso solo en el simulador proteus... el problema era que habia colision ya que quizas estaba entrando una palabra al buffer para ser enviada mientras que se habia recibido otra.

PERO  :angry:  Cuando voy a hacerlo en fisico, a veces me escribe el hola que quiero y a veces escribe pura basura..., no se que es lo que pasa de verdad....ya estoy verde.

Esto fue lo que modifique del codigo anterior del master

Código: Text
  1.  
  2. void trasmitiendo_datos(void){
  3.  
  4.   signed char i;
  5.  
  6.   esclavo = 0;
  7.  
  8.   SetDDRamAddr(0x00);
  9.   for(i=0;i<4;i++)            
  10.     {
  11.     while(putcSPI(contador[i])<0);          
  12.        while(!SSPSTATbits.BF);  
  13.     putcXLCD(contador[i]);
  14.     }
  15.  
  16.   esclavo = 1;
  17.  
  18. }
  19.  
  20.  

el slave queda igual...

Si alguien tiene alguna idea de lo que pueda ser, le estaria muy agradecida de que me la hiciera saber...ya estoy harta de que algo que puede ser sencillo me este trayendo tantos problemas, y atrasandome en todo mi proyecto.  :(

Gracias por la ayuda.

20
Programación en C / Re: Nueva Con Spi
« en: Sábado 26 de Agosto de 2006, 06:36 »
Hola Huguen_aus_Tirol, como estas? soy yo otra vez   :hitcomp:

Ahora estoy tratando de trabajar con string y estoy teniendo problemas  :( .... no se algo pasa con el clock del spi.... estoy usando estas funciones para obtener un string del buffer y colocar un string en el buffer para enviarlo al otro pic.

Código: Text
  1.  
  2. void getsSPI( unsigned char *rdptr, unsigned char length )
  3. {
  4.   while ( length )                // stay in loop until length = 0
  5.   {
  6.     *rdptr++ = getcSPI();         // read a single byte
  7.     length--;                     // reduce string length count by 1
  8.   }
  9. }
  10.  
  11.  

y

Código: Text
  1.  
  2. void putsSPI( unsigned char *wrptr )
  3. {
  4.   while ( *wrptr )                // test for string null character
  5.   {
  6.      SSPBUF = *wrptr++;           // initiate SPI bus cycle
  7.      while( !SSPSTATbits.BF );    // wait until 'BF' bit is set
  8.   }
  9. }
  10.  


Lo que estoy tratando de hacer ahora es enviar un "hola" de un pic a otro. Pero si pongo que solo transmita y reciba una vez, no lo hace..es decir, no se coloca nada en el lcd del slave....si coloco que envie varias veces el master y el slave solo reciba una vez, me salen las letras pero asi por lo menos HOAH.....Parece un problema de sincronizacion...que no entiendo porque el slave deberia usar el clock del master para recibir los bytes del string... :huh:

este es el codigo...

master

Código: Text
  1.  
  2. void config_SPI(void){
  3.  
  4. //configuro el Serial Port SPI Master
  5. OpenSPI( SPI_FOSC_16,
  6.          MODE_11,    
  7.          SMPEND);
  8.  
  9. }
  10.  
  11. void trasmitiendo_datos(void){
  12.  
  13.   esclavo = 0;
  14.  
  15.   putsSPI(contador);
  16.  
  17.   esclavo = 1;
  18.  
  19.   putsXLCD(contador);
  20. }
  21.  
  22. void main(void){
  23.  
  24.   //salida del clock
  25.   TRISAbits.TRISA6 = 0;
  26.   TRISAbits.TRISA7 = 0;
  27.  
  28.   TRISBbits.TRISB7 = 0;
  29.  
  30.   config_SPI();
  31.  
  32.   OpenXLCD(FOUR_BIT & LINES_5X7);
  33.  
  34. //  trasmitiendo_datos();
  35.  
  36.   while(1){
  37.     trasmitiendo_datos();
  38.   }  
  39. }
  40.  

slave

Código: Text
  1.  
  2. unsigned char data[];
  3.  
  4. //Configuramos el SPI
  5. void config_SPI(void){
  6.  
  7. OpenSPI( SLV_SSOFF,
  8.        MODE_11,    
  9.        SMPEND);
  10.  
  11. }
  12.  
  13. void recibiendo_datos(void){
  14.  
  15.   if(PORTAbits.RA5 == 0)
  16.     getsSPI(data,4);
  17.  
  18.   SetDDRamAddr(0x00);
  19.   putsXLCD(data);  
  20. }
  21.  
  22. void main(void){
  23.  
  24.   //salida del clock
  25.   TRISAbits.TRISA6 = 0;
  26.   TRISAbits.TRISA7 = 0;
  27.  
  28.   config_SPI();
  29.  
  30.   OpenXLCD(FOUR_BIT & LINES_5X7);
  31.  
  32.   recibiendo_datos();
  33.  
  34.   while(1){
  35.    &#59;
  36.   }
  37. }
  38.  
  39.  

Disculpa que ponga todo el codigo pero es que quiero que entiendas bien que estoy haciendo para ver si tu o cualquier otra persona me pueda dar luz....

Para mi es un problema con la sincronizacion, pero no entiendo por que??.. :(

Gracias por la ayuda de verdad.....  ya estoy fastidiosa.... lo mas triste es que pienso que debe ser una estupidez porque de verdad la logica me parece que esta bien....no?  :huh:

Gracias  ;)

21
Programación en C / Re: Nueva Con Spi
« en: Sábado 26 de Agosto de 2006, 00:23 »
Hola,  ;)  acabo de probar algo y funciono....lo que pasa es que no se por que no funcionaba de la otra manera..

Lo que hice fue cambiar en la configuracion del slave para que fuera SLV_SSOFF es decir, segun la libreria spi.h, estuviera el ss habilitado. y le coloque que cuando recibiera verificara primero si el master activa el ss.

if(PORTAbits.RA5 == 0){
       PORTD = getcSPI();

Lo que no entiendo es que si yo tengo un solo esclavo...tengo necesidad de estar habilitando y trabajando con el pin ss??? es que creo haber leido que no necesariamente tenias que trabajar con ss cuando tenias un solo esclavo.

Que me dicen al respecto??

Saludos,  ;)

22
Programación en C / Re: Nueva Con Spi
« en: Viernes 25 de Agosto de 2006, 23:51 »
Hola Huguen_aus_Tirol, como estas?

Revice los pines, y estan bien conectados. SDO.SDI y SCK.

Luego el codigo lo cambie para que el master le enviara un byte al slave... y nada lo deja en 0....cuando hago la simulacion en Proteus, parece que si se esta pasando la data del master al slave, pero no veo los resultados...

Aqui te pongo el codigo....no se si es que estoy utilizando mal la librería spi.h o que?

MASTER

Código: Text
  1.  
  2. unsigned char contador = 0b01010101;
  3.  
  4. //Configuramos el SPI
  5. void config_SPI(void){
  6.  
  7. //configuro el Serial Port SPI Master
  8. OpenSPI( SPI_FOSC_16,
  9.    MODE_11,    
  10.    SMPMID);
  11.  
  12. }
  13.  
  14. void trasmitiendo_datos(void){
  15.  
  16.   //enviamos
  17.   while(putcSPI(contador)<0);
  18.    
  19. }
  20.  
  21. void main(void){
  22.  
  23. //salida del clock
  24. TRISAbits.TRISA6 = 0;
  25. TRISAbits.TRISA7 = 0;
  26.  
  27. config_SPI();
  28.  
  29. while(1){
  30.   trasmitiendo_datos();
  31. }  
  32. }
  33.  
  34.  


SLAVE

Código: Text
  1.  
  2. //Configuramos el SPI
  3. void config_SPI(void){
  4.  
  5. OpenSPI( SLV_SSON,
  6.    MODE_11,    
  7.    SMPMID);
  8.  
  9. }
  10.  
  11. void recibiendo_datos(void){
  12.  
  13.   //recibimos
  14.   PORTD = getcSPI();
  15.  
  16. }
  17.  
  18. void main(void){
  19.  
  20.   //salida del clock
  21.   TRISAbits.TRISA6 = 0;
  22.   TRISAbits.TRISA7 = 0;
  23.  
  24.   TRISD = 0;
  25.   PORTD = 0;
  26.  
  27.   config_SPI();
  28.  
  29.   while(1){
  30.     recibiendo_datos();
  31.   }
  32. }
  33.  

No puede ser que la cosa mas tonta no la haga....ya estoy mal  :(  estoy tratando de hacer mi tesis que tiene un parte de comunicacion y no he podido salir de este punto...y pasan los dias....he intentado de todo y nada. De pana que lo que tengo me parece logico y no se por que no funciona.  :huh:


Estas son las funciones que uso, como estan en la libreria...




unsigned char putcSPI( unsigned char data_out )
{
  SSPBUF = data_out;           // write byte to SSPBUF register
  if ( SSPCON1 & 0x80 )        // test if write collision occurred
   return ( -1 );              // if WCOL bit is set return negative #
  else
  {
    while( !SSPSTATbits.BF );  // wait until bus cycle complete
  }
  return ( 0 );                // if WCOL bit is not set return non-negative#
}



unsigned char getcSPI( void )
{
  SSPBUF = 0x00;                  // initiate bus cycle
  while ( !SSPSTATbits.BF );      // wait until cycle complete
  return ( SSPBUF );              // return with byte read
}


Quizas tu o cualquier otra persona que vea el post pueda ver que cualquier cosa que yo no estoy viendo, por el estres. jiji

Bueno muchisimas gracias por su ayuda.

Por favor respondan  ;)

23
Programación en C / Nueva Con Spi
« 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.  :huh:

Este es el codigo de mi master

Código: Text
  1.  
  2.  
  3.  
  4. #include <p18F4620.h>
  5. #include <xlcd.h>
  6. #include <spi.h>
  7. #include <stdio.h>
  8. #include <string.h>
  9.  
  10.  
  11. //Configuramos el SPI
  12. void config_SPI(void){
  13.  
  14.  
  15.  
  16.  //configuro el Serial Port SPI Master
  17.  OpenSPI( SPI_FOSC_16,
  18.     MODE_11,    
  19.     SMPMID);
  20.  
  21.  
  22. }
  23.  
  24.  
  25.  
  26. void trasmitiendo_datos(void){
  27.  
  28.  
  29.  
  30.  char frame[5] = "hola";
  31.  char buffer[16];
  32.  
  33.  //enviamos
  34.  putsSPI((unsigned char *)frame);
  35.  
  36.  
  37.  
  38.  //Envio un mensaje que diga que la data fue transmitida
  39.  SetDDRamAddr(0x00);
  40.  sprintf(buffer,(const rom far char *)"Datos Enviados!");
  41.  putsXLCD(buffer);
  42.  
  43. }
  44.  
  45.  
  46. void main(void){
  47.  
  48.  
  49.  
  50.  //salida del clock
  51.  TRISAbits.TRISA6 = 0;
  52.  TRISAbits.TRISA7 = 0;
  53.  
  54.  
  55.  
  56.  OpenXLCD(FOUR_BIT & LINES_5X7);
  57.  
  58.  
  59.  
  60.  config_SPI();
  61.  
  62.  
  63.  
  64.  trasmitiendo_datos();
  65.  
  66.  
  67.  
  68.  while(1){
  69.  &#59;
  70.  }
  71. }
  72.  
  73.  
  74.  


Y este es el codigo de mi slave.

Código: Text
  1.  
  2.  
  3.  #include <p18F4620.h>
  4. #include <xlcd.h>
  5. #include <spi.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8.  
  9.  
  10. //string que recibira los datos
  11. unsigned char datos[5];
  12.  
  13.  
  14.  
  15. //Configuramos el SPI
  16. void config_SPI(void){
  17.  
  18.  
  19.  
  20.  OpenSPI( SLV_SSON,
  21.     MODE_11,    
  22.     SMPMID);
  23.  
  24. }
  25.  
  26.  
  27.  
  28. void recibiendo_datos(void){
  29.  
  30.  
  31.  
  32.  //recibimos
  33.  getsSPI(datos,5);
  34.    
  35.  //Envio un mensaje que muestre la data recibida
  36.  SetDDRamAddr(0x00);
  37.  putsXLCD(datos);
  38.  
  39.  
  40.  
  41. }
  42.  
  43.  
  44.  
  45. void main(void){
  46.  
  47.  
  48.  
  49.  //salida del clock
  50.  TRISAbits.TRISA6 = 0;
  51.  TRISAbits.TRISA7 = 0;
  52.  
  53.  
  54.  
  55.  OpenXLCD(FOUR_BIT & LINES_5X7);
  56.  
  57.  
  58.  
  59.  config_SPI();
  60.  
  61.  
  62.  while(1){
  63.   recibiendo_datos();
  64.  }
  65. }
  66.  
  67.  
  68.  
  69.  

De verdad muchisimas gracias por la ayuda que me puedan prestar. ;)

Saludos.

24
Microcontroladores / Re: Trf-2.4g E Intreface Spi
« en: Lunes 21 de Agosto de 2006, 07:39 »
Aqui esta el codigo del transmisor...vamos a ver si ahora si lo pone.

25
Microcontroladores / Trf-2.4g E Intreface Spi
« 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...

Código: Text
  1.  
  2.  
  3.  OSCCON = 0b01110010; //Coloca el oscilador interno a 8MHz
  4.     while(OSCCONbits.IOFS == 0); //Espera a que se estabilice la frecuencia
  5.  
  6.  
  7.  

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.  :angry:

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]