« anterior próximo »
Páginas: [1]   Ir Abajo

Autor Tema: Escribir en la eeprom interna de un pic18  (Leído 2566 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado NoSepComo

  • PIC18
  • ****
  • Mensajes: 305
Escribir en la eeprom interna de un pic18
« en: 24 de Marzo de 2011, 05:36:56 »
Hola a todos,
Estoy tratando de utilizar las funciones de escritura/lectura en la EEPROM interna del pic18f45k20 a través de las funciones del compilador CCS write_eeprom(direc,dato) y read_eeprom(direc), pero no me funcionan, sin embargo si que lo harían en un PIC16, supongo que debe ser algo del mapeo de memoria y no quiero configurarlo a través de los registros del PIC, porque la ventaja de usar CCS es abstraerte de esas historias.
Alguien me puede decir como se utilizan o si hay que hacer algo especial para poderlas usar (tipo algún #include o algo así).
Disculpad mi inexperiencia en estos temas que cada vez me atraen más.
Gracias por vuestra ayuda y un saludo.
En línea

Desconectado NoSepComo

  • PIC18
  • ****
  • Mensajes: 305
Re: Escribir en la eeprom interna de un pic18
« Respuesta #1 en: 28 de Marzo de 2011, 04:25:17 »
Hola a todos,
por el momento sigo atascado, puesto que tampoco soy capaz de escribir en la eeprom interna de un 16f877, alguién podría pasarme algún código para escribir y leer de la eeprom interna para el CCS?
gracias a todos por adelantado.
En línea

Desconectado MLO__

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 4581
Re: Escribir en la eeprom interna de un pic18
« Respuesta #2 en: 29 de Marzo de 2011, 16:57:39 »
Hola.

Con las funciones write_eeprom(direccion,valor) lo puedes hacer.

Código: C#
  1. write_eeprom(0,'a');

Para leer el dato, usas read_eeprom(direccion)

Código: C#
  1. variable = read_eeprom(0);

Saludos
En línea
El papel lo aguanta todo

Desconectado Miquel_S

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1251
Re: Escribir en la eeprom interna de un pic18
« Respuesta #3 en: 29 de Marzo de 2011, 17:56:18 »
Hola NoSepComo te paso el codigo de un reloj que hice donde podras ver la escritura y lectura de la eeprom interna.

Saludos.
Código: CSS
  1. #include <18f2550.h>
  2. #fuses HS,NOWDT,NOPROTECT,NODEBUG,NOBROWNOUT,NOWRT,NOLVP,NOPUT
  3. #use delay(clock=20000000)
  4. #define RTC_SCL   PIN_B1
  5. #define RTC_SDA   PIN_B0
  6. #use fast_io(b)
  7. //#define use_portb_lcd TRUE            
  8. #include <_ds1307.c>
  9. #include <string.h>
  10. #define LCD_DB4   PIN_C4
  11. #define LCD_DB5   PIN_C5
  12. #define LCD_DB6   PIN_C6
  13. #define LCD_DB7   PIN_C7
  14. //
  15. #define LCD_RS    PIN_C0
  16. #define LCD_RW    PIN_C1
  17. #define LCD_E     PIN_C2
  18. #include <flex_lcd.c>
  19. #include <ds1621.c>
  20.  
  21.  int hr;
  22.  int min;
  23.  int sec;
  24.  int day;
  25.  int mth;
  26.  int year;
  27.  int dow;
  28.  char sdow[11];
  29.  char ValoresLeidos[105];
  30.  Byte value;
  31.  
  32. /*******************************************************************************
  33.                  FUNCIONES ESCRITURA Y LECTURA EEPROM INTERNA
  34. *******************************************************************************/                
  35.  void write_string_eeprom(int address,char *data){
  36.    while(*data!=0){
  37.       write_eeprom(address++,*data);
  38.       data++;
  39.    }
  40.    write_eeprom(address,0);
  41. }
  42.  
  43. void read_string_eeprom(int address,char *sl){
  44.      sl--;
  45.    do{
  46.       sl++;
  47.       *sl=read_eeprom(address++);
  48.    }
  49.    while(*sl!=0);
  50. }
  51.  
  52. /*******************************************************************************
  53.                            FUNCION DE ALARMAS
  54. *******************************************************************************/
  55. void alarma(void)
  56. {
  57.    output_high(PIN_B7);
  58.    delay_ms(5000);
  59.    output_low(PIN_B7);
  60. }
  61. /*******************************************************************************
  62.                               PROGRAMA PRINCIPAL
  63. *******************************************************************************/
  64.                    void main()
  65.                    {
  66.                    char alarmas[105];
  67.                    char alarma1[]="083000";
  68.                    char alarma2[]="090000";
  69.                    char alarma3[]="092500";
  70.                    char alarma4[]="100000";
  71.                    char alarma5[]="102000";
  72.                    char alarma6[]="103000";
  73.                    char alarma7[]="111500";
  74.                    char alarma8[]="113500";
  75.                    char alarma9[]="120000";
  76.                    char alarma10[]="123000";
  77.                    char alarma11[]="124500";
  78.                    char alarma12[]="131500";
  79.                    char alarma13[]="143000";
  80.                    char alarma14[]="153000";
  81.                    char alarma15[]="163000";
  82.                    char *leido=alarmas;
  83.                    
  84. /*******************************************************************************
  85.                    ESCRIBIR ALARMAS EN LA EPROM
  86. *******************************************************************************/
  87.                    write_string_eeprom(0x00,alarma1);
  88.                    write_string_eeprom(0x07,alarma2);
  89.                    write_string_eeprom(0x0E,alarma3);
  90.                    write_string_eeprom(0x15,alarma4);
  91.                    write_string_eeprom(0x1C,alarma5);
  92.                    write_string_eeprom(0x23,alarma6);
  93.                    write_string_eeprom(0x2A,alarma7);
  94.                    write_string_eeprom(0x31,alarma8);
  95.                    write_string_eeprom(0x38,alarma9);
  96.                    write_string_eeprom(0x3F,alarma10);
  97.                    write_string_eeprom(0x46,alarma11);
  98.                    write_string_eeprom(0x4D,alarma12);
  99.                    write_string_eeprom(0x54,alarma13);
  100.                    write_string_eeprom(0x5B,alarma14);
  101.                    write_string_eeprom(0x62,alarma15);
  102.                    
  103. /*******************************************************************************
  104.                    INICIALIZAMOS LCD Y DS 1307
  105. *******************************************************************************/                  
  106.                    lcd_init();
  107.                    //init_temp();
  108.                    printf(lcd_putc,"Reloj ds1307");
  109.                    printf(lcd_putc,"\nMiquel_S 2010");
  110.                    delay_ms(2000);
  111.                    lcd_putc("\f");
  112.                    lcd_gotoxy(2,1);
  113.                    printf(lcd_putc,"CP.BLAI BONET");
  114.                    lcd_gotoxy(5,2);
  115.                    printf(lcd_putc,"SANTANYI");
  116.                    delay_ms(2000);
  117.                    lcd_putc("\f");
  118.                    delay_ms(5);
  119.                    ds1307_init(DS1307_ALL_DISABLED);
  120.                    //Set date for -> 2-Abril-2010 Viernes
  121.                    //Set time for -> 17:32:00
  122.                    ds1307_set_date_time(21,4,10,2,22,14,00);
  123.                    set_tris_b(0x00);            //puerto B como salida B7
  124.                    disable_interrupts(GLOBAL);      //todas interrupciones desactivadas
  125.                    
  126. /*******************************************************************************
  127.                    LEEMOS DS1307 Y VISUALIZAMOS DATOS EN LCD
  128. *******************************************************************************/
  129.                    do
  130.                      {
  131.                      ds1307_get_day_of_week((char*) sdow);
  132.                      ds1307_get_time(hr,min,sec);
  133.                      ds1307_get_date(day,mth,year,dow);
  134.                      lcd_gotoxy(1,1);
  135.                      printf(lcd_putc,"%s %02u-%02u-%02u",sdow,day,mth,year);
  136.                      printf(lcd_putc,"\n%02u:%02u:%02u",hr,min,sec);
  137. /*******************************************************************************
  138.                    LEEMOS Y VISUALIZAMOS TEMPERATURA
  139. *******************************************************************************/                  
  140.                      lcd_gotoxy(10,2);
  141.                      printf(lcd_putc,"Temp:");
  142.                      value = read_temp();
  143.                      printf(lcd_putc,"%02u",value);
  144.                      
  145. /*******************************************************************************
  146.                      LECTURA Y COMPARACION DE LA ALARMA 08:30
  147. *******************************************************************************/
  148.                      read_string_eeprom(0x00,leido);
  149.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  150.                         if(strcmp(ValoresLeidos,leido)==0)
  151.                            alarma();
  152.                            else
  153.                               output_low(PIN_B7);
  154. /*******************************************************************************
  155.                      LECTURA Y COMPARACION DE LA ALARMA 09:00
  156. *******************************************************************************/
  157.                      read_string_eeprom(0x07,leido);
  158.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  159.                         if(strcmp(ValoresLeidos,leido)==0)
  160.                            alarma();
  161.                            else
  162.                               output_low(PIN_B7);
  163. /*******************************************************************************
  164.                      LECTURA Y COMPARACION DE LA ALARMA 09:25
  165. *******************************************************************************/
  166.                      read_string_eeprom(0x0E,leido);
  167.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  168.                         if(strcmp(ValoresLeidos,leido)==0)
  169.                            alarma();
  170.                            else
  171.                               output_low(PIN_B7);
  172. /*******************************************************************************
  173.                      LECTURA Y COMPARACION DE LA ALARMA 10:00
  174. *******************************************************************************/
  175.                      read_string_eeprom(0x15,leido);
  176.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  177.                         if(strcmp(ValoresLeidos,leido)==0)
  178.                            alarma();
  179.                            else
  180.                               output_low(PIN_B7);
  181. /*******************************************************************************
  182.                      LECTURA Y ESCRITURA DE LA ALARMA 10:20
  183. *******************************************************************************/
  184.                      read_string_eeprom(0x1C,leido);
  185.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  186.                         if(strcmp(ValoresLeidos,leido)==0)
  187.                            alarma();
  188.                            else
  189.                               output_low(PIN_B7);
  190. /*******************************************************************************
  191.                      LECTURA Y ESCRITURA DE LA ALARMA 10:30
  192. *******************************************************************************/
  193.                      read_string_eeprom(0x23,leido);
  194.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  195.                         if(strcmp(ValoresLeidos,leido)==0)
  196.                            alarma();
  197.                            else
  198.                               output_low(PIN_B7);
  199. /*******************************************************************************
  200.                      LECTURA Y ESCRITURA DE LA ALARMA 11:15
  201. *******************************************************************************/
  202.                      read_string_eeprom(0x2A,leido);
  203.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  204.                         if(strcmp(ValoresLeidos,leido)==0)
  205.                            alarma();
  206.                            else
  207.                               output_low(PIN_B7);
  208. /*******************************************************************************
  209.                      LECTURA Y ESCRITURA DE LA ALARMA 11:35
  210. *******************************************************************************/
  211.                      read_string_eeprom(0x31,leido);
  212.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  213.                         if(strcmp(ValoresLeidos,leido)==0)
  214.                            alarma();
  215.                            else
  216.                               output_low(PIN_B7);
  217. /*******************************************************************************
  218.                      LECTURA Y ESCRITURA DE LA ALARMA 12:00
  219. *******************************************************************************/
  220.                      read_string_eeprom(0x38,leido);
  221.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  222.                         if(strcmp(ValoresLeidos,leido)==0)
  223.                            alarma();
  224.                            else
  225.                               output_low(PIN_B7);
  226. /*******************************************************************************
  227.                      LECTURA Y COMPARACION DE LA ALARMA 12:30
  228. *******************************************************************************/
  229.                      read_string_eeprom(0x3F,leido);
  230.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  231.                         if(strcmp(ValoresLeidos,leido)==0)
  232.                            alarma();
  233.                            else
  234.                               output_low(PIN_B7);
  235. /*******************************************************************************
  236.                      LECTURA Y ESCRITURA DE LA ALARMA 12:45
  237. *******************************************************************************/
  238.                      read_string_eeprom(0x46,leido);
  239.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  240.                         if(strcmp(ValoresLeidos,leido)==0)
  241.                            alarma();
  242.                            else
  243.                               output_low(PIN_B7);
  244. /*******************************************************************************
  245.                      LECTURA Y ESCRITURA DE LA ALARMA 13:15
  246. *******************************************************************************/
  247.                      read_string_eeprom(0x4D,leido);
  248.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  249.                         if(strcmp(ValoresLeidos,leido)==0)
  250.                            alarma();
  251.                            else
  252.                               output_low(PIN_B7);
  253. /*******************************************************************************
  254.                      LECTURA Y ESCRITURA DE LA ALARMA 14:30
  255. *******************************************************************************/
  256.                      read_string_eeprom(0x54,leido);
  257.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  258.                         if(strcmp(ValoresLeidos,leido)==0)
  259.                            alarma();
  260.                            else
  261.                               output_low(PIN_B7);
  262. /*******************************************************************************
  263.                      LECTURA Y ESCRITURA DE LA ALARMA 15:30
  264. *******************************************************************************/
  265.                      read_string_eeprom(0x5B,leido);
  266.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  267.                         if(strcmp(ValoresLeidos,leido)==0)
  268.                            alarma();
  269.                            else
  270.                               output_low(PIN_B7);
  271. /*******************************************************************************
  272.                      LECTURA Y ESCRITURA DE LA ALARMA 16:30
  273. *******************************************************************************/
  274.                      read_string_eeprom(0x62,leido);
  275.                      sprintf(ValoresLeidos,"%02u%02u%02u",hr,min,sec);
  276.                         if(strcmp(ValoresLeidos,leido)==0)
  277.                            alarma();
  278.                            else
  279.                               output_low(PIN_B7);
  280.                      }
  281.                     While(1);
  282.                    }
En línea
Todos somos muy ignorantes. Lo que ocurre es que no todos ignoramos las mismas cosas.

Desconectado NoSepComo

  • PIC18
  • ****
  • Mensajes: 305
Re: Escribir en la eeprom interna de un pic18
« Respuesta #4 en: 31 de Marzo de 2011, 05:08:05 »
Gracias por vuestros aportes, ya conseguí solucionar mi problema, que no residía en mandar y leer de la eeprom si no en como trataba una interrupcion de puerto serie, ya solucioné todo.
Gracias a todos y un saludo.
En línea

Desconectado MLO__

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 4581
Re: Escribir en la eeprom interna de un pic18
« Respuesta #5 en: 31 de Marzo de 2011, 20:19:57 »
 :huh: :huh: :huh: :huh: :huh: :huh: :huh:

Bueno ... lo bueno fue que lo solucionaras  :mrgreen:
En línea
El papel lo aguanta todo

Desconectado remachi

  • PIC10
  • *
  • Mensajes: 1
Re: Escribir en la eeprom interna de un pic18
« Respuesta #6 en: 11 de Abril de 2011, 19:07:33 »
Hablando de la EEPROM. He escrito un programita con C18 que se supone que grabaria unas cosas en la EEPROM interna de un PIC18F4550. En el MPLAB la simulacion funciona al detalle, en cambio en el PROTEUS, al poner pausa me aparece la EEPROM digamos... virgen. Alguien me puede ayudar? cual de los 2 programas funcionará mal?
En línea

Desconectado Miquel_S

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1251
Re: Escribir en la eeprom interna de un pic18
« Respuesta #7 en: 12 de Abril de 2011, 04:33:18 »
Quizas deberias postear el codigo y la simulacion para poder ver donde estas fallando, ya que con el codigo que he posteado  anteriormente no tuve problemas con la simulacion.
Miquel_S
« Última modificación: 12 de Abril de 2011, 10:36:09 por Miquel_S »
En línea
Todos somos muy ignorantes. Lo que ocurre es que no todos ignoramos las mismas cosas.
Páginas: [1]   Ir Arriba
« anterior próximo »