Usar memoria SIMM de 30 pines con PIC

[albertoxx]

Releyendo un poco, si la búsqueda te está demorando más de 2" me dá la impresión que debe haber algo "más que ineficiente" en tu implementación. Porque no son tantos datos --> no debería demorar tanto.

Lo hice con memoria eeprom 24C32 y segun mis calculos para barrer con toda la informacion de una lista no indexada se tardaria mas de 2 segundos en buscarlas en varias eeprom y por motivos de urgencia se instalo asi pero quiero mejorar los tiempos para hacer esto como se ha dicho mas eficiente.

Y sobre todo usar el inventario con que cuento (muchas memorias simm,dimm) y con eso de que hay memorias en los CD me llama la atencion por que tengo muchos de desguace tambien voy a abrir uno y les cuento que memoria encontre.

Para ir aterrizando yo creo que lo ideal seria tener una lista de datos ordenada y solo el indice manejarlo en ram

 

[Meta]

Hola:

Las EEPROM tipo 24LC32 son mucho más lenta en lectura y escritura que la RAM y se nota la diferencia como se nota que la RAM no deja los datos almacenados cuando pierde la alimentación.

La más moderna y mejoraja ahora es la 24LC32A. Esas son EEPROM preparadas para microcontroladores.

Vamos a sacar la máxima información para hacer el hardware adecuadno al menos en la protoboard.

http://www.hardwarebook.info/30_pin_SIMM

A leer algo básico para entender.
http://es.wikipedia.org/wiki/DRAM
http://www.myplace.nu/avr/dram/index.htm

Una tontería para tener claro mediante programación de alto nivel como el Visual C# como ejemplo, es tener una idea más clara.

https://www.youtube.com/watch?v=blLXcIyqVFw

http://foro.elhacker.net/hardware/guia_basica_sobre_la_memoria_ram-t220084.0.html

¿Aún sigues con intenciones de usar la RAM SIM 30 para hacer pruebas o te lo estás pensando?

Si lo tuviera lo haría en mi caso, jejjejeje.

Saludo.

 

[albertoxx]

Pues mas o menos asi me quedo el codigo pero el refrescamiento a cada rato para que no pierda la info me hace descartar este tipo de memoria. Aqui esta el codigo y segun lo que me tiro si guarda y lee la informacion

void GuardarEnRAM(int Columna,int Fila,int Valor){
  set_tris_a(0);
  output_b(255); //todos high
  output_b( (Fila << 3)+0b110 );
  output_a(Valor);
  output_b( (Columna << 3)+0b00 );
  output_b(255); //todos high  
}

int LeerDeRAM(int Columna,int Fila){
  set_tris_a(1);
  output_b(255); //todos high
  output_b( (Fila << 3)+0b110 );
  output_b( (Columna << 3)+0b100 );
  output_b(255); //todos high  
  return( input_a() );
}

Y en la rutina principal

   delay_ms(50);
   printf("Iniciando\r\n");
   while(1){
     GuardarEnRAM(1,1,1);
     GuardarEnRAM(1,2,2);
     GuardarEnRAM(1,3,3);
     GuardarEnRAM(1,4,4);
     GuardarEnRAM(1,5,5);
     Dato1 = LeerDeRAM(1,5);
     Dato2 = LeerDeRAM(1,4);
     Dato3 = LeerDeRAM(1,3);
     Dato4 = LeerDeRAM(1,2);
     Dato5 = LeerDeRAM(1,1);
     printf("%u %u %u %u %u\r\n",Dato1,Dato2,Dato3,Dato4,Dato5);
     delay_ms(800);
   }

Y el resultado en terminal de windows fue

5 4 5 4 5

Asi que deplano sin el refresco no funciona

 

[Meta]

Hola:

¿Lo que has hecho es un simulador o real con un microcontrolador?

Si lo hiciste funcionar. ¿Puedes subir imágenes del circuito?

Veo interesante estos temas.

Saludo.

 

[Scooter]

El problema de una memoria externa es que no la puedes indizar etc, si se puede hay que usar memoria interna.
Si usas una memoria externa estática de acceso paralelo necesitas al menos tres puertos y además las señales de lectura y escritura para 64k y eso son demasiados pines. Si pones registros de desplazamiento o similares ahorras pines pero gastas mas circuitos... mejor sería una memoria serie.
Al precio y a la velocidad que van las SDs creo que son ideales porque matas dos pájaros de un tiro, vale que el número de escrituras es limitado, pero son millones, si cuidas no machacar un sector creo que podría ir.
Una memoria SD de clase 10 tiene una tasa de escritura de 10MB/s que es mucho mas de lo que un pic "normal" puede enviarle en un uso normal, no se si esa tasa baja mucho en modo SPI, pero sería cuestión de pensar en unsar el interface SD "ancho".

 

[Eduardo]

No entiendo por que preferís complicar el hardware para poder usar un algoritmo pedorro (una lectura secuencial) en lugar de mejorar el algoritmo. Hay veces que no se puede, pero en este caso, un índice de apenas 16 o 32 entradas ya te acelera drásticamente el proceso.

 

[albertoxx]

Aqui va la foto que pidio Meta, funciona dos tres, pero totalmente no adecuada para un pic como dice scooter se comio todos los pines del pic y eso que solo use 3 pines para address, ademas del refresco que tiene que tener cada 64ms minimo y no es que prefiera complicarme sino que no sabia como se usaban esas memorias, si tenia muchas de desguase pues economicamente pense que me podian servir, ahora 2 preguntas viendo ya como funcionan los simms como le hace la computadora para calcular cuanta memoria le han puesto y la segunda estaba viendo la memoria SD el CCS ya trae librerias para accesar a esa memoria o hay que buscar algunas de las que andan por el internet?

 

[Meta]

Muy buenas la foto.

Ver el archivo adjunto 93417

Esas memorias son rápidas para un PIC, hay PIC32 que te funciona de maravilla. Por cierto, si te preocupa de los pines, hay de 40, 60, 80 y 100 pines, también puedes entrelazar varios PIC para ese módulo.

Lo bueno es saber si realmente, aunque use las DDR3 o futuras DDR4 funcionen con un PIC tipo 16F887 o el 18F4550 a una lenta velicidad, eso es lo que no se.

http://www.pcactual.com/articulo/laboratorio/especiales/9780/todo_sobre_memoria_ram_ddr3.html

En cuanto del PC, como sabe la RAM que tiene instalada y la marca incluida.

http://www.yio.com.ar/imprimir.php?sid=176

En cuanto el PC sabe que marca tiene instalada y la capacidad sin leer todas las celdas de memoria es porque está grabada en una EEPROM, por cierto, puedes modificarla hasta con un TE20x.

Fíjate que tiene 5 integrados, uno en el centro muy pequeño y 4 iguales que son IC de RAM. El pequeño del centro es la EEPROM. Hay otros elementos como condensadores SMD para estabilizar las tensiones de la RAM. Antes había como un multiplexor en el módulo de RAM, luego lo pusieron en la placa base. Así escoge el IC de RAM adecuado como intenta hacer nuestro amigo @albertoxx.

Intenta usar un PIC de 40 pines, a lo mejor te da. En esta vida hay memorias en serie y en paralelo.

En serie suelen ser más lenta, requiere protocolo de comunicación y más electrónica. En paralelo es mucho más rápida pero requiere mucho cableado y pines a cambio de menos electrónica. Hay ventajas y desventajas. Luego hay que saber si esas memorias son unificadas, todoas en un mismo segmentos o memorias segmentadas como los PIC a la hora de programarlos que tienes que cambiar de banco cada dos por tres, menos mal que en C no pasa esto.

Ahora puedes hacer más pruebas de lectura escritura.

Si tienes intención de hacer pruebas con las SIMM 30, puedes usar un PIC con más pines y experimentar, agradezco las imágenes. Por cierto, ¿usas CCS o el C18?

 

[albertoxx]

Con razon las pcs antiguas al no traer esa eeprom se ponian a barrer la memoria antes de encender para ver cuanto de ram tenian por que las simm de 30 pines no traen la eeprom sino directamente los modulos de memoria, con respecto a tu pregunta Meta lo hize en ccs.

Salu2

 

[Meta]

Buenas:

Algunas BIOS modernas (las nuevas se llaman UEFI) tiene la capacidad de testear la RAM completa paso a paso, puede tardar hasta media hora ya que pureba escritura y lectura en cada posición de memoria.

Adios a la BIOS, bienvenida la UEFI que acelera el arranque del ordenador

http://www.tusequipos.com/2010/10/0...a-uefi-que-acelera-el-arranque-del-ordenador/

Cierto, en los PC antiguos leía al encender dichos módulos de RAM y lo podíamos ver. Había posibilidad de hacer el test o no en la BIOS.

En cuanto a la RAM del PC, estaba haciendo algunas pruebas con estos ejemplos.
http://www.jarloo.com/reading-and-writing-to-memory/
http://stackoverflow.com/questions/588817/c-sharp-memory-address-and-variable

Ahora te toca rellenar toda posición de la memoria con un solo dato, el 0x33 por poner un ejemplo. Se que la smemorias actuales tienen direcciones de hasta 64 bits, con usar pues a poner solo 0x3333333333333333 si es en PC con DDR3, ejjejee.

En CCS:

/*Ejemplos básicos para la simulación.

Empleo del direccionamiento indirecto para rellenar un área de memoria con un
mismo valor. El área o buffer de memoria está comprendida entre las posiciones
0x30 y 0x3F. */

#include <16f886.h>                        //Incluir definiciones en C para el PIC16F886

int Valor;                                //Valor de relleno
int Contador;                            //Variable de contaje

int Buffer[16];                            //Reserva para el buffer a rellenar

main()
{
    for(Contador=0;Contador<16;Contador++)    //Repetir 16 veces
        Buffer[Contador]=Valor;                //Almacenar en buffer el valor de relleno
}

En asm:

;Ejemplos básicos para la simulación.
;
;Empleo del direccionamiento indirecto para rellenar un área de memoria con un
;mismo valor. El área o buffer de memoria está comprendida entre las posiciones
;0x30 y 0x3F.
        
            List    p=16F886        ;Tipo de procesador
            include    "P16F886.INC"    ;Definiciones de registros internos

            cblock 0x20                ;Reserva de variables a partir de 0x20
                Valor                ;Valor de relleno
                Contador            ;Variable de contaje
            endc

            org    0x00
            goto    Inicio            ;Vector de reset
            org    0x05    

;Programa principal
Inicio        movlw    .16    
            movwf    Contador        ;Un contador se carga con el nº de bytes de relleno

            movlw    0x30
            movwf    FSR                ;Inicia el registro índice con 1ª dirección del buffer
Loop_1        movf    Valor,W            ;Carga en W el valor de relleno
            movwf    INDF            ;Lo almacena en el buffer
            incf    FSR,F            ;Siguiente dirección del buffer
            decfsz    Contador        ;Es el último byte a rellenar ??
            goto    Loop_1            ;No, siguiente byte

            goto    Inicio            ;Si. Ejecutar de nuevo

            end                        ;Fin del programa fuente

Espero que puedas hacer pruebas con las SIMM 30 que posees con un PIC mayor en pines o usas dos más de los pequeños.

 

[albertoxx]

Lei el articulo de jardoo y hacer eso me suena como tutorial para crakear o hacker alguna aplicacion, aunque windows si no estoy mal maneja memoria protegida y no deja que tu aplicacion acceseda a esta memoria de echo ya en el windows xp no deja accesar directamente a las interrupciones tal y como se hacia en DOS

 

[Meta]

No me acordaba esa parte de la protección. Hay distribuiciones Linux que te dejan hacer de todo. Lo hacen así para dificultar a los hacker las lecturas de la RAM, claro que no es imposible y MicroSoft lo sabe.

Si lo vas a usar con un PIC, pues no tendrás esos problemas porque el Windows está diseñado así adrede por protección.

 

[Gudino Roberto duberlin]

Hola gente, no quise abrir un nuevo hilo al encontrar éste, aunque el mismo tiene mucho tiempo sin actividad, si los moderadores prefieren trasladarlo, está más que aceptado, en fin.

Me he encontrado hace unos días con la necesidad de utilizar un memoria dinámica ( DRAM ).
Cómo no hay mucha información, empecé a investigar sobre la hoja de datos de una cualquiera que encontré, precisamente la MT 4C4256, de 4bits de datos.
Decidí controlarla con un PIC, el 16F877, así que armé un pequeño programa, que se encarga obviamente de realizar todas las operaciones, tanto refresco, lectura y escritura.
Aquí lo más importante es el ciclo de refresco, según la hoja de datos para ésta memoria, debe realizarse dentro de los 8ms.
El resultado fué satisfactorio!
Claro que corriendo el PIC a 4Mhz, va sobrado para llevar a cabo todo el control, quizás en un programa extenso, estemos en problemas, así que seguramente habrá que utilizar una fcia. mayor de OSC o bien destinar un PIC sólamente para realizar la gestión de control, y transferir los datos al exterior para ser accedidos por otro medio.
Adjunto código y esquema.

#include <16F877.h>
#fuses NOWDT, NOPROTECT, XT
#use delay (clock=4000000)
#use fast_io(a)
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)
#byte addrin = 0x06
#bit write = 0x05.3
#define WE pin_e2
#define RAS pin_e1
#define CAS pin_e0
void main(void)
{
 set_tris_a(0b00001000);
 set_tris_b(0b00001111);
 set_tris_c(0b00000000);
 set_tris_d(0b00000000);
 set_tris_e(0b00000000);
 long ADDR=0;
 output_bit(WE,1);                   // E2 =WE
 output_bit(RAS,1);                  // E1 =RAS
 output_bit(CAS,1);                  // E0 =CAS
 delay_ms(10);
      
     output_bit(CAS,1);
     delay_us(2);
     output_bit(RAS,1);
     delay_us(2);
while(true)
     {
    
////////////////////////////// Refresh/////////////////////////////////////////////     
    
     if(ADDR<511)ADDR++;else ADDR=0;
     output_c(ADDR);
     output_d(ADDR>>8);
     delay_us(1);
     output_bit(RAS,0);
     delay_us(1);
     output_bit(RAS,1);

///////////////////////////////////////////////////////////////////////////////////
       output_c(addrin);
       output_d(0);
    
     if(!write)
       {
        delay_us(1);           // WRITE
        output_bit(RAS,0);
        delay_us(1);
        output_bit(WE,0);
        output_c(0);
        output_d(0);
        delay_us(1);
        output_bit(CAS,0);
        delay_us(1);         
        output_bit(WE,1);
        delay_us(1);         
        output_bit(CAS,1);
        delay_us(1);         
        output_bit(RAS,1);
       }
     else                      // READ
       {
        delay_us(1);
        output_bit(RAS,0);
        delay_us(1);
        output_c(0);
        output_d(0);
        delay_us(1);
        output_bit(CAS,0);
        delay_us(1);         
        output_bit(CAS,1);
        delay_us(1);         
        output_bit(RAS,1);
       }
     }
        delay_us(1);
}

 

[Scooter]

Llamadme raro, pero al precio que está la RAM estática no veo la ventaja de usar dinámica.
A no ser que quieras usar varios GB para lo cual un pic va a ir muy muy corto.

Como curiosidad o experimento me parece muy bien.

 

[Gudino Roberto duberlin]

Llamadme raro, pero al precio que está la RAM estática no veo la ventaja de usar dinámica.
A no ser que quieras usar varios GB para lo cual un pic va a ir muy muy corto.

Como curiosidad o experimento me parece muy bien.

En mi caso, necesito 4Mb. por eso acudí a usar una DRAM.

 

[D@rkbytes]

Para 4 Mb yo hubiera optado por una memoria Flash SPI W25Q32

 

[Gudino Roberto duberlin]

Para 4 Mb yo hubiera optado por una memoria Flash SPI W25Q32

Lamentablemente tengo que usar lo que tengo a mano.

 

[Hellmut1956]

Tengo en mi inventario montón de viejas memorias DRAM. Pero siempre he evitado meterme en esto. Respeto. Pero condiderando que llenar los megas de memoria flash en los controladores y tener mas SRAM integrado en los controladores de lo que he necesitado hasta el día de hoy, no he visto aún la necesidad de meterme en esto. Pero eso si, duele pensar de todas estas memorias DRAM de viejos PCs que caban su existencia cuando me decido de ponerlos en la basura.

 

[D@rkbytes]

Lamentablemente tengo que usar lo que tengo a mano.

Esas memorias son usadas en la mayoría de tarjetas de televisores LED (Sobre todo en las chinas)
Posiblemente tengas alguna tarjeta dañada que la tenga.
Sin embargo, son más baratas que una DRAM y mucho más pequeñas. (SMD SOIC8)



Y si requieres más capacidad, están las W25Q64 de 8 Mb o mayores.

 

[Gudino Roberto duberlin]

Esas memorias son usadas en la mayoría de tarjetas de televisores LED (Sobre todo en las chinas)
Posiblemente tengas alguna tarjeta dañada que la tenga.
Sin embargo, son más baratas que una DRAM y mucho más pequeñas. (SMD SOIC8)

Ver el archivo adjunto 180168

Y si requieres más capacidad, están las W25Q64 de 8 Mb o mayores.

Excelente dato! Pero necesito que sea RAM.
Lo que necesito es capturar una trama de datos extensa, analizar descartar y volver a repetir lo anterior.

Tengo en mi inventario montón de viejas memorias DRAM. Pero siempre he evitado meterme en esto. Respeto. Pero condiderando que llenar los megas de memoria flash en los controladores y tener mas SRAM integrado en los controladores de lo que he necesitado hasta el día de hoy, no he visto aún la necesidad de meterme en esto. Pero eso si, duele pensar de todas estas memorias DRAM de viejos PCs que caban su existencia cuando me decido de ponerlos en la basura.

Me sucede lo mismo amigo Hellmut, tengo montañas de tarjetas SIMM/DIMM/ EDO y demás de esa época. Da pena tirarlas.
Usando un PIC para gobernarlas la ventaja que tengo es que sólo debo colocar, dirección/dato y leer o grabar, cómo si fuese un SRAM.
Sólo me falta añadir una bandera en el programa que me indica que la dirección y el dato fueron aceptados. Con eso sincronizo.