Pulsador con doble proposito

[Ruco]

Buen día amigos.

Estoy haciendo un control dimmer con un pic 12F683 en ccs c. Para lo cual tengo un pulsador que aumenta la el duty para variar la iluminación con la siguiente rutina:

Código: C

1. if(input(pin_A4)==0){   // Si el pulsador se a apretado; aumenta la luminicidad
2.          delay_ms(5);            // Retardo 5 mS
3.          dutyAC += 5;            // Aumneta dutyAC 5 unidades
4.          if(dutyAC >= dutymin){  // unsigned int16 dutyAC; unsigned int16 dutymin = 65422;
5.          dutyAC = dutymin; }     //
6.          }

El pulsador inicia y avanza desde 63200 cuando lo presiono.

El pulsador de doble proposito es que si presiono este pulsador por menos de 200 ms; entonces el foco se encienda al full de inmediato la lampara, es decir el duty sea 65422. y si el pulsador es presionado por mas de este tiempo; entonces funcione como dimmer, es decir que realice la rutina de código que coloque.

Me pueden ayudar un poquitín?. Saludos

[DominusDRR]

Sería más o menos así:

Código: C

1. if(input(pin_A4)==0)// Si el pulsador se a apretado; aumenta la luminicidad
2. {
3.         contador = 0;  
4.     delay_ms(100); //retardo esperando que el usuario suelte el pulsante
5.         do
6.         {
7.                 if(input(pin_A4)==0) // usuario sigue presionando el putch
8.                 {
9.                         contador++;
10.                         delay_ms(1);
11.                         if (contador == 200)
12.                         {
13.                                 // realizaó cualquier proceso por haber mantenido presionado el pulsante por 200 ms
14.                                 break;
15.                         }
16.                 }
17.                 else // implica que A4 está en 1 lógico
18.                 {
19.                         contador = 0;
20.                         break; // el usuario ha soltado el pulsante
21.                 }
22.         }while(1);
23.        
24.         if(0 == contador)
25.         {      
26.                 delay_ms(5);            // Retardo 5 mS
27.                 dutyAC += 5;            // Aumneta dutyAC 5 unidades
28.                 if(dutyAC >= dutymin){  // unsigned int16 dutyAC; unsigned int16 dutymin = 65422;
29.                         dutyAC = dutymin; }     //
30.         }
31. }

Por ahí pueda que me falte algo, con retardos asincrónicos y máquina de estados sería más sencillo.

[Ruco]

Un saludo.

Estube intentando de esa manera y no me resulto. Estaba pensando que tal vez con el timer0 se podría hacer.

Al presionar el pulsador habilitar la l timer0 e iniciar un contador en ms. Si se suelta el pulsador antes de los 200 ms parar el timer0 y realizar una acción. De otra manera si rebasa los 200 ms el timer0, entonces, realice una segunda acción.

Muy similar a como indicas pero con timer0.

[DominusDRR]

Un saludo.

Estuve intentando de esa manera y no me resulto. Estaba pensando que tal vez con el timer0 se podría hacer.

Deberías compartir tu código para determinar, que está mal

Al presionar el pulsador habilitar la l timer0 e iniciar un contador en ms. Si se suelta el pulsador antes de los 200 ms parar el timer0 y realizar una acción. De otra manera si rebasa los 200 ms el timer0, entonces, realice una segunda acción.

Muy similar a como indicas pero con timer0.

Si, puede ser, hay varias maneras de hacerlo.

[Eduardo2]

...
Al presionar el pulsador habilitar la l timer0 e iniciar un contador en ms. Si se suelta el pulsador antes de los 200 ms parar el timer0 y realizar una acción. De otra manera si rebasa los 200 ms el timer0, entonces, realice una segunda acción.

Probá asi:

Código: [Seleccionar]

    if(input(pin_A4)==0){
        int8 cuentas = 20 ;
        do {
            if(cuentas>0){
                cuentas-- ;
            } else {       
                dutyAC += 10 ;
                if(dutyAC > dutymin) dutyAC = dutymin ;         
            } 
            delay_ms(10) ;
        } while(input(pin_A4)==0)  ;       
        if(cuentas > 0) dutyAC = dutymin ;
    }

El delay_ms conviene que sea de más de 5ms para hacerlo menos sensible a los rebotes.

[Ruco]

Gracias a todos por su ayuda incondicional.
No me a funcionado la parte de los pulsadores, por qué no me e dado a entender.

Aquí coloco el código completo:

Código: C++

1. #include <12F683.h>
2.          #FUSES INTRC_IO,NOWDT,PUT,NOMCLR,BROWNOUT,PROTECT,CPD,NOIESO,NOFCMEN
3.          #use delay(clock=8M)
4.          #use fast_io(A)
5.          #zero_ram
6.          #priority timer1        
7.          #define focoAC PIN_A1                                                         // salida del pic
8.          #use rs232(baud=9600, xmit=PIN_A3)  
9.          
10.          const unsigned int16 dutymin = 65410;                                                      // Menor brillo
11.          const unsigned int16 dutymax = 63535;                                                        // Mayor brillo
12.          unsigned int16 dutyAC=0;
13.          
14.          #int_EXT                                                                      // interrup externa
15.          void  EXT_isr(void){
16.          output_low(focoAC);
17.          set_timer1(dutyAC);
18.          }
19.          
20.          #INT_TIMER1
21.          void timer1(void){
22.          output_high(focoAC);
23.          }
24.          
25.          void main(){
26.          setup_oscillator(OSC_8MHZ);
27.          output_a(0);                                                                  // Precargar Latch de Salida
28.          set_tris_a(0b110100);
29.          output_low(focoAC);
30.          delay_ms(100);
31.          set_timer1(0);
32.          
33.          EXT_INT_EDGE(L_TO_H);
34.          ENABLE_INTERRUPTS(INT_EXT_L2H);
35.          disable_interrupts(INT_TIMER0);
36.          setup_timer_0(RTCC_INTERNAL|RTCC_DIV_16);
37.          SETUP_TIMER_1(T1_INTERNAL |T1_DIV_BY_8);                                      // Prescaler = 8
38.          enable_interrupts(INT_TIMER1);
39.          enable_interrupts(GLOBAL);
40.          
41.          while(TRUE){                                                                  
42.          if(input(pin_A4)==0){
43.          delay_ms(5);
44.          dutyAC += 5;
45.          if(dutyAC >= dutymin){
46.          dutyAC = dutymin; }
47.          }
48.          
49.          if(input(pin_A5)==0){
50.          delay_ms(5);
51.          dutyAC -= 5;
52.          if(dutyAC <= dutymax){
53.          dutyAC = dutymax; }
54.          }
55.          
56.          }
57.          }

Y anexo la simulación.

Bueno, aquí explico lo que desde un inicio no me di a entender bien, ya con esto creo que me entenderán mejor...

Dentro de while con:

Código: C++

1. if(input(pin_A4)==0){
2.          delay_ms(5);
3.          dutyAC += 5;
4.          if(dutyAC >= dutymin){
5.          dutyAC = dutymin; }
6.          }

... aumento la iluminación del foco o lampara paso a paso dutyAC += 5; teniendo presionado el pulsador, pero también pretendo que si presiono el pulsador y lo suelto antes de 200ms (por si decirlo, aunque podrían ser 400ms); entonces el dutyAC se valla de inmediato a dutyAC = dutymin como un control ON; que es donde el foco encendió a su máximo nivel y si el pulsador rebaso los 200 ms y no lo solte; entonces que funcione el pulsador como dimmer.

lo mismo para ..

Código: C++

1. if(input(pin_A5)==0){
2.          delay_ms(5);
3.          dutyAC -= 5;
4.          if(dutyAC <= dutymax){
5.          dutyAC = dutymax; }
6.          }

Pero ahora que disminuya de inmediato o como dimmer.

Saludos y espero haberme explicado mejor.

[Ruco]

No me funcionó eduardo2. O tal vez no lo supe plantear en el código. Saludos...

if(input(pin_A4)==0){
        int8 cuentas = 20 ;
        do {
            if(cuentas>0){
                cuentas-- ;
            } else {       
                dutyAC += 10 ;
                if(dutyAC > dutymin) dutyAC = dutymin ;         
            }
            delay_ms(10) ;
        } while(input(pin_A4)==0)  ;       
        if(cuentas > 0) dutyAC = dutymin ;
    }

[DominusDRR]

No me funcionó eduardo2. O tal vez no lo supe plantear en el código. Saludos...

if(input(pin_A4)==0){
        int8 cuentas = 20 ;
        do {
            if(cuentas>0){
                cuentas-- ;
            } else {       
                dutyAC += 10 ;
                if(dutyAC > dutymin) dutyAC = dutymin ;         
            }
            delay_ms(10) ;
        } while(input(pin_A4)==0)  ;       
        if(cuentas > 0) dutyAC = dutymin ;
    }

Parece que no estás considerando el rebote, generalmente necesitas entre 100 a 200 ms, para afirmar que el pulsador está estable. (Sin generar pulsos fantasmas)

Si, A4 pasa a cero, llegas a   delay_ms(10) ; que es muy poco tiempo, y luego se ejecuta while(input(pin_A4)==0)  ;  y es posible que tengas un pulso fantasma igual a 1, y sales del bucle, a pesar que el usuario lo mantenga presionado.

[Eduardo2]

....
No me a funcionado la parte de los pulsadores, por qué no me e dado a entender.
... aumento la iluminación del foco o lampara paso a paso dutyAC += 5; teniendo presionado el pulsador, pero también pretendo que si presiono el pulsador y lo suelto antes de 200ms (por si decirlo, aunque podrían ser 400ms);
.......

No te ha funcionado porque cuando pulsas el Proteus le da un tiempo mínimo de activación levemente mayor de 200ms
--> Por lo tanto, no importa lo rápido del clickeo siempre será mayor de 200ms.   Usando 250ms te habría funcionado.

En el físico no tendrías problemas, los golpes a pulsador rondan los 100ms.

[Ruco]

Eduardo2 funciono!!!  bueno, simulado y colocando int8 cuentas = 40 ; en lugar de 20; por favor explícame más a detalle esa rutina de código que hiciste.

Código: C++

1. if(input(pin_A4)==0){
2.          int8 cuentas = 40 ;
3.          do {
4.          if(cuentas>0){
5.          cuentas-- ;
6.          }
7.          else {
8.          dutyAC += 10 ;
9.          if(dutyAC > dutymin) dutyAC = dutymin ;        
10.          }
11.          delay_ms(10) ;
12.          } while(input(pin_A4)==0)  ;      
13.          if(cuentas > 0) dutyAC = dutymin ;
14.          }

y si no es mucho pedir como seria esa rutina para if(input(pin_A5)==0){

Gracias 

[Eduardo2]

Código: [Seleccionar]

    if(input(pin_A4)==0){
        int8 cuentas = 40 ;
        do {
            if(cuentas>0){          // Cuando cuentas llega a 0 no se
                cuentas-- ;         // decrementa mas.
            }
            else {                 
                dutyAC += 10 ;      // Se ejecuta solo despues que cuentas llego a 0 
                if(dutyAC > dutymin) dutyAC = dutymin ;         
            }
            delay_ms(10) ;
        } while(input(pin_A4)==0)  ;         // Continua el bucle hasta soltar
                                             // el pulsador.   
        if(cuentas > 0) dutyAC = dutymin ;   // Si cuentas > 0 es porque fue una
                                             // pulsacion corta -> ajusto a dutymin
    }                                       

Para pin_A5 es similar:

Código: [Seleccionar]

    if(input(pin_A5)==0){
        int8 cuentas = 40 ;
        do {
            if(cuentas>0){
                cuentas-- ;
            }
            else {
                dutyAC -= 10 ;
                if(dutyAC < dutymax) dutyAC = dutymax ;         
            }
            delay_ms(10) ;
        } while(input(pin_A5)==0)  ;       
        if(cuentas > 0) dutyAC = dutymax ;
    }


[Ruco]

Funciona, Muchas gracias por su ayuda y compartir sus conocimientos.

[Ruco]

Tengo una consulta después de un tiempo....

Y es que requiero guardar en la EEprom el nivel de iluminación al irse la energía eléctrica.

Aquí me surgen 2 inquietudes.

1.- Sera mejor guardar los valores en la EEprom cuando haya algún cambio con el pulsador que hace aumentar o disminuir el brillo?.

2.- O se alcanzara a guardar en la EEprom los valores de brillo cuando el voltaje del pic empiece a bajar, es decir, cuando detecte que se bajo el voltaje?.

[DominusDRR]

Tengo una consulta después de un tiempo....

Y es que requiero guardar en la EEprom el nivel de iluminación al irse la energía eléctrica.

Aquí me surgen 2 inquietudes.

1.- Sera mejor guardar los valores en la EEprom cuando haya algún cambio con el pulsador que hace aumentar o disminuir el brillo?.

2.- O se alcanzara a guardar en la EEprom los valores de brillo cuando el voltaje del pic empiece a bajar, es decir, cuando detecte que se bajo el voltaje?.

Yo tenía un problema con eso de la EEPROM, la cual es muy lenta para escribir datos (Sobre todo cuando son muchos), y a veces no había suficiente tiempo para guardar la información antes que se vaya del todo.

Una solución engorrosa, era  colocar un supercapacitor para que provea mucha más energía para que el microcontrolador alcance a guardar los datos.

En tu caso, podría ser la opción 1, pero el problema es que estás siempre escribiendo en esa memoria y su vida útil va disminuyendo (tiene un número finito de  veces que puedes escribir en ella).

La opción 2, corres el riesgo de escribir datos inservibles debido a que posiblemente no haya suficiente energía para escribir los datos.

Yo empecé a usar las EERAM, tu escribes y lees sobre la RAM interna (y es rápida por ser RAM), y ante un corte de energía, si es que lo que contiene la RAM es diferente a lo de la EEPROM, se guarda automáticamente, tan solo necesita un capacitor de entre 15 uF a 25 uF.

https://www.microchip.com/en-us/products/memory/serial-eeram

[Ruco]

E puesto las líneas para guardar los datos en la EEprom interna del pic, pero no me guarda los datos. Para que cuando se valla la energía, se quede en el mismo nivel de iluminación en el tiempo anterior de la ausencia eléctrica.

Código: C++

1. #include <12F683.h>
2.          #FUSES INTRC_IO,NOWDT,PUT,NOMCLR,BROWNOUT,PROTECT,CPD,NOIESO,NOFCMEN
3.          #use delay(clock=8M)
4.          #use fast_io(A)
5.          #zero_ram
6.          #priority timer1        
7.          #define focoAC PIN_A1                                                         // salida del pic
8.          #use rs232(baud=4800,rcv=PIN_A0)
9.          #include "internal_eeprom_pic.c"
10.          
11.          #define dutymin 65410                                                         // Menor brillo
12.          #define dutymax 63535                                                         // Mayor brillo
13.          unsigned int16 dutyAC=0;
14.  
15.          #int_EXT                                                                      // interrup externa
16.          void  EXT_isr(void){
17.          output_low(focoAC);
18.          set_timer1(dutyAC);
19.          }
20.          
21.          #INT_TIMER1
22.          void timer1(void){
23.          output_high(focoAC);
24.          }                                                                             // int_ra3 recepcion serial
25.  
26.          void main(){
27.          setup_oscillator(OSC_8MHZ);
28.          output_a(0);                                                                  // Precargar Latch de Salida
29.          set_tris_a(0b110100);
30.          output_low(focoAC);
31.          delay_ms(100);
32.          set_timer1(0);
33.          
34.          EXT_INT_EDGE(L_TO_H);
35.          ENABLE_INTERRUPTS(INT_EXT_L2H);
36.          disable_interrupts(INT_TIMER0);
37.          setup_timer_0(RTCC_INTERNAL|RTCC_DIV_16);
38.          SETUP_TIMER_1(T1_INTERNAL |T1_DIV_BY_8);                                      // Prescaler = 8
39.          enable_interrupts(INT_TIMER1);
40.          enable_interrupts(INT_RA0);                                                   // Interrupcion por cambio de estado usada para Recepción Serial  
41.          enable_interrupts(GLOBAL);  
42.          
43.          dutyAC = read_int16_eeprom(0);   //(address)  
44.          
45.          while(TRUE){
46.          
47.          if(input(pin_A4)==0){
48.          int8 cuentas = 40;
49.          do {
50.          if(cuentas>0){ cuentas--; }
51.          else { dutyAC += 10;
52.          if(dutyAC > dutymin) dutyAC = dutymin;        
53.          }
54.          delay_ms(10);
55.          } while(input(pin_A4)==0);  write_int16_eeprom(0, dutyAC);      
56.          if(cuentas > 0) dutyAC = dutymin ;
57.      
58.          }
59.          
60.          if(input(pin_A5)==0){
61.          int8 cuentas = 40;
62.          do {
63.          if(cuentas>0){ cuentas--; }
64.          else { dutyAC -= 10 ;
65.          if(dutyAC < dutymax) dutyAC = dutymax;        
66.          }
67.          delay_ms(10);
68.          } while(input(pin_A5)==0);  write_int16_eeprom(0, dutyAC);      
69.          if(cuentas > 0) dutyAC = dutymax;
70.          }
71.          
72.          }
73.          }

Este es el codigo. Y las lineas que agrege son write_int16_eeprom(0, dutyAC);  y dutyAC = read_int16_eeprom(0);  .

La librería de la EEprom es esta;

Código: C++

1. #ifndef INTERNAL_EEPROM_UTILITIES
2. #define INTERNAL_EEPROM_UTILITIES
3.  
4. // Used to adjust the address range
5. #ifndef INT_EEPROM_ADDRESS
6. #if getenv("DATA_EEPROM") > 255
7. #define INT_EEPROM_ADDRESS  unsigned int16
8. #else
9. #define INT_EEPROM_ADDRESS  unsigned int8
10. #endif
11. #endif
12.  
13. #ifndef INT_EEPROM_DATA_SIZE
14. #ifdef (__PCD__)
15. #define INT_EEPROM_DATA_SIZE unsigned int16
16. #else
17. #define INT_EEPROM_DATA_SIZE unsigned int8
18. #endif
19.  
20. ////////////////////////////////////////////////////////////////////////////////
21. //// Internal EEPROM Functions
22. ////////////////////////////////////////////////////////////////////////////////
23.  
24. // Purpose:    Write one bit to internal eeprom
25. // Inputs:     1) An eeprom address
26. //             2) The bit position (LSB == 0)
27. //             3) The bit to write
28. // Outputs:    None
29. void write_int1_eeprom(INT_EEPROM_ADDRESS address, unsigned int8 bitPosition, int1 data)
30. {
31.    INT_EEPROM_DATA_SIZE stored_data;
32.  
33.    stored_data = read_eeprom(address);
34.  
35.    if(data)
36.    {
37.       bit_set(stored_data, bitPosition);
38.    }
39.    else
40.    {
41.       bit_clear(stored_data, bitPosition);
42.    }
43.  
44.    write_eeprom(address, stored_data);
45. }
46.  
47.  
48. // Purpose:    Read one bit from internal eeprom
49. // Inputs:     1) An eeprom address
50. //             2) The bit position (LSB == 0)
51. // Outputs:    The bit read from internal eeprom
52. int1 read_int1_eeprom(INT_EEPROM_ADDRESS address, unsigned int8 bitPosition)
53. {
54.    return bit_test(read_eeprom(address), bitPosition);
55. }
56.  
57.  
58. // Purpose:    Write a 16 bit number to internal eeprom
59. // Inputs:     1) An eeprom address. Two eeprom locations will be used.
60. //             2) The 16 bit number to write to internal eeprom
61. // Outputs:    None
62. void write_int16_eeprom(INT_EEPROM_ADDRESS address, unsigned int16 data)
63. {
64.    #ifdef __PCD__
65.    write_eeprom(address,data);
66.    #else
67.    int8 i;
68.  
69.    for(i = 0; i < 2; ++i)
70.    {
71.      write_eeprom(address + i, *((int8 *)(&data) + i));
72.    }
73.    #endif
74. }
75.  
76.  
77. // Purpose:    Read a 16 bit number from internal eeprom
78. // Inputs:     An eeprom address
79. // Outputs:    The 16 bit number read from internal eeprom
80. unsigned int16 read_int16_eeprom(INT_EEPROM_ADDRESS address)
81. {
82.    #ifdef __PCD__
83.    return(read_eeprom(address));
84.    #else
85.    int8  i;
86.    int16 data;
87.  
88.    for(i = 0; i < 2; ++i)
89.    {
90.      *((int8 *)(&data) + i) = read_eeprom(address + i);
91.    }
92.  
93.    return(data);
94.    #endif
95. }
96.  
97.  
98. // Purpose:    Write a 32 bit integer to internal eeprom
99. // Inputs:     1) An eeprom address. Four eeprom locations will be used.
100. //             2) The 32 bit number to write to internal eeprom
101. // Outputs:    None
102. void write_int32_eeprom(INT_EEPROM_ADDRESS address, unsigned int32 data)
103. {
104.    #ifdef __PCD__
105.    write_eeprom(address, &data, 4);
106.    #else
107.    int8 i;
108.    
109.    for(i = 0; i < 4; i++)
110.      write_eeprom(address + i, *((int8 *)(&data) + i));
111.    #endif
112. }
113.  
114.  
115. // Purpose:    Read a 32 bit integer from internal eeprom
116. // Inputs:     An eeprom address
117. // Outputs:    The 32 bit integer read from internal eeprom
118. unsigned int32 read_int32_eeprom(INT_EEPROM_ADDRESS address)
119. {
120.    #ifdef __PCD__
121.    return(read_eeprom(address, 4));
122.    #else
123.    int8  i;
124.    int32 data;
125.  
126.    for(i = 0; i < 4; i++)
127.      *((int8 *)(&data) + i) = read_eeprom(address + i);
128.  
129.    return(data);
130.    #endif
131. }
132.  
133.  
134. // Purpose:    Write a 32 bit floating point number to internal eeprom
135. // Inputs:     1) An eeprom address. Four eeprom locations will be used.
136. //             2) The floating point number to write to internal eeprom
137. // Outputs:    None
138. void write_float_eeprom(INT_EEPROM_ADDRESS address, float32 data)
139. {
140.    #ifdef __PCD__
141.    write_eeprom(address, &data, 4);
142.    #else
143.    int8 i;
144.    
145.    for(i = 0; i < 4; i++)
146.       write_eeprom(address + i, *((int8 *)(&data) + i));
147.  
148.    #endif
149. }
150.  
151.  
152. // Purpose:    Read a 32 bit floating point number from internal eeprom
153. // Inputs:     An eeprom address
154. // Outputs:    The floating point number read from the internal eeprom
155. float32 read_float_eeprom(INT_EEPROM_ADDRESS address)
156. {
157.    float32 data;
158.  
159.    #ifdef __PCD__
160.    read_eeprom(address, &data, 4);
161.    
162.    return(data);
163.    #else
164.    int8 i;
165.    
166.    if (read_eeprom(address) == 255 &&
167.    read_eeprom(address + 1) == 255 &&
168.    read_eeprom(address + 2) == 255 &&
169.    read_eeprom(address + 3) == 255)
170.    {
171.       write_eeprom(address, 0);
172.       write_eeprom(address + 1, 0);
173.       write_eeprom(address + 2, 0);
174.       write_eeprom(address + 3, 0);
175.    }
176.    
177.    for(i = 0; i < 4; i++)
178.      *((int8 *)(&data) + i) = read_eeprom(address + i);
179.  
180.    return(data);
181.    #endif
182. }
183.  
184. #ifdef __PCD__
185. // Purpose:    Write a 48 bit integer to internal eeprom
186. // Inputs:     1) An eeprom address. Six eeprom locations will be used.
187. //             2) The 48 bit number to write to internal eeprom
188. // Outputs:    None
189. void write_int48_eeprom(INT_EEPROM_ADDRESS address, unsigned int48 data)
190. {
191.    write_eeprom(address, &data, 6);
192. }
193.  
194.  
195. // Purpose:    Read a 48 bit integer from internal eeprom
196. // Inputs:     An eeprom address
197. // Outputs:    The 48 bit integer read from internal eeprom
198. unsigned int48 read_int48_eeprom(INT_EEPROM_ADDRESS address)
199. {
200.    return(read_eeprom(address, 6));
201. }
202.  
203.  
204. // Purpose:    Write a 64 bit integer to internal eeprom
205. // Inputs:     1) An eeprom address. Eight eeprom locations will be used.
206. //             2) The 64 bit number to write to internal eeprom
207. // Outputs:    None
208. void write_int64_eeprom(INT_EEPROM_ADDRESS address, unsigned int64 data)
209. {
210.    write_eeprom(address, &data, 8);
211. }
212.  
213.  
214. // Purpose:    Read a 64 bit integer from internal eeprom
215. // Inputs:     An eeprom address
216. // Outputs:    The 64 bit integer read from internal eeprom
217. unsigned int64 read_int64_eeprom(INT_EEPROM_ADDRESS address)
218. {
219.    return(read_eeprom(address, 8));
220. }
221.  
222.  
223. // Purpose:    Write a 48 bit floating point number to internal eeprom
224. // Inputs:     1) An eeprom address. Six eeprom locations will be used.
225. //             2) The floating point number to write to internal eeprom
226. // Outputs:    None
227. void write_float48_eeprom(INT_EEPROM_ADDRESS address, float48 data)
228. {
229.    write_eeprom(address, &data, 6);
230. }
231.  
232.  
233. // Purpose:    Read a 48 bit floating point number from internal eeprom
234. // Inputs:     An eeprom address
235. // Outputs:    The floating point number read from the internal eeprom
236. float48 read_float48_eeprom(INT_EEPROM_ADDRESS address)
237. {
238.    float48 data;
239.  
240.    read_eeprom(address, &data, 6);
241.    
242.    return(data);
243. }
244.  
245.  
246. // Purpose:    Write a 64 bit floating point number to internal eeprom
247. // Inputs:     1) An eeprom address. Eight eeprom locations will be used.
248. //             2) The floating point number to write to internal eeprom
249. // Outputs:    None
250. void write_float64_eeprom(INT_EEPROM_ADDRESS address, float64 data)
251. {
252.    write_eeprom(address, &data, 8);
253. }
254.  
255.  
256. // Purpose:    Read a 64 bit floating point number from internal eeprom
257. // Inputs:     An eeprom address
258. // Outputs:    The floating point number read from the internal eeprom
259. float64 read_float64_eeprom(INT_EEPROM_ADDRESS address)
260. {
261.    float64 data;
262.  
263.    read_eeprom(address, &data, 8);
264.    
265.    return(data);
266. }
267.  
268. #endif
269.    
270.  
271. #endif

Alguien me puede ayudar por favor, por que no e logrado grabar en la EERpom. Gracias