RAM dinámica con PIC

[Robert76]

Hola gente, quiero compartir algo de información, ya que lo que encontré en la red es escaso, y los temas aquí publicados llevan tiempo sin movimiento, en fin, si los Sres. moderadores creen conveniente moverlos al sitio correspondiente, es aceptado totalmente.

Hace unos días me doy con la necesidad de utilizar memorias DRAM,(requería 4Mb aprox.) por lo cuál al no encontrar buena o suficiente información, decidí analizar una hoja de datos de la memoria MT4C4256 que tenía a mano, he hice un pequeño programa, que gestiona el refresco, lectura y grabado de la misma.

Cómo lo más importante a cuidar en éstas memorias es el ciclo de refresco, en éste caso debe hacerse antes de los 8ms.
Utilizando un 16F877 a 4Mhz, va de sobra y el resultado fué excelente!
Pero claro, si el PIC gestionará a la memoria , más todo el programa al que estará relacionado, pues seguramente se quedará corto, sino se hacen maniobras por interrupción, aumentar la fcia. de OSC al máximo posible, o bien organizar al programa para que sea lo más dinámico posible, aquí usar un delay de varios "ms" sería catastrófico!
A continuación adjunto diagrama de prueba y programa.

Código: C

1. #include <16F877.h>
2. #fuses NOWDT, NOPROTECT, XT
3. #use delay (clock=4000000)
4. #use fast_io(a)
5. #use fast_io(b)
6. #use fast_io(c)
7. #use fast_io(d)
8. #use fast_io(e)
9. #byte addrin = 0x06
10. #bit write = 0x05.3
11. #define WE pin_e2
12. #define RAS pin_e1
13. #define CAS pin_e0
14. void main(void)
15. {
16.  set_tris_a(0b00001000);
17.  set_tris_b(0b00001111);
18.  set_tris_c(0b00000000);
19.  set_tris_d(0b00000000);
20.  set_tris_e(0b00000000);
21.  long ADDR=0;
22.  output_bit(WE,1);                   // E2 =WE
23.  output_bit(RAS,1);                  // E1 =RAS
24.  output_bit(CAS,1);                  // E0 =CAS
25.  delay_ms(10);
26.      
27.      output_bit(CAS,1);
28.      delay_us(2);
29.      output_bit(RAS,1);
30.      delay_us(2);
31. while(true)
32.      {
33.      
34. ////////////////////////////// Refresh/////////////////////////////////////////////    
35.      
36.      if(ADDR<511)ADDR++;else ADDR=0;
37.      output_c(ADDR);
38.      output_d(ADDR>>8);
39.      delay_us(1);
40.      output_bit(RAS,0);
41.      delay_us(1);
42.      output_bit(RAS,1);
43.  
44. ///////////////////////////////////////////////////////////////////////////////////
45.        output_c(addrin);
46.        output_d(0);
47.      
48.      if(!write)
49.        {
50.         delay_us(1);           // WRITE
51.         output_bit(RAS,0);
52.         delay_us(1);
53.         output_bit(WE,0);
54.         output_c(0);
55.         output_d(0);
56.         delay_us(1);
57.         output_bit(CAS,0);
58.         delay_us(1);        
59.         output_bit(WE,1);
60.         delay_us(1);        
61.         output_bit(CAS,1);
62.         delay_us(1);          
63.         output_bit(RAS,1);
64.        }
65.      else                      // READ
66.        {
67.         delay_us(1);
68.         output_bit(RAS,0);
69.         delay_us(1);
70.         output_c(0);
71.         output_d(0);
72.         delay_us(1);
73.         output_bit(CAS,0);
74.         delay_us(1);          
75.         output_bit(CAS,1);
76.         delay_us(1);        
77.         output_bit(RAS,1);
78.        }
79.      }
80.         delay_us(1);
81. }

[KILLERJC]

Pero no te hace falta los delays... Incluso con un PIC18 a 64Mhz seguis estando por encima de los tiempos minimos de pulsos.

Creo que el problema esta entre la lectura de un valor y el refresco.. Si las lecturas se hacen demasiado rapidas que no de tiempo para el refresco adecuado.
Ese es el punto que seria bueno analizar.

[Robert76]

La prueba que hice fué, realizar el ciclo de refresco que en éste caso son 512 pasos, repartidos entre las lecturas o escrituras que se demanden.
Pienso utilizar una bandera en 1, que indica el comienzo de la lectura, y cuándo el dato sea leído vuelve a cero.
El mismo concepto para la escritura.
Según el datasheet de ésta memoria, aunque NO será la que voy a utilizar, porque me decanto por una SIMM o DIMM.
Los tiempos de acceso rondan los 15ns, así que son suficientemente rápidas cómo para NO lograr acceder a la lectura/escritura.