{"id":988,"date":"2020-07-09T12:51:56","date_gmt":"2020-07-09T10:51:56","guid":{"rendered":"https:\/\/retrofixes.it\/?page_id=988"},"modified":"2024-01-18T08:53:27","modified_gmt":"2024-01-18T07:53:27","slug":"dram-tester","status":"publish","type":"page","link":"https:\/\/retrofixer.it\/en\/dram-tester\/","title":{"rendered":"Dram Tester"},"content":{"rendered":"\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t

Come posso testare le DRAM ?<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

Capita di doversi cimentare nel riparare un vecchio computer o console che utilizza queste tipologie di RAM e fortunatamente ci sono dei modi che ci aiutano a trovare il banco (o pi\u00f9) difettoso.
Ma perch\u00e9 le DRAM? Queste RAM dinamiche (da cui il nome) a differenza di quelle statiche hanno necessit\u00e0 di rinfrescare i loro dati memorizzati riscrivendoli spesso ogni tot millisecondi. I dati su queste RAM vengono memorizzati e mantenuti da una carica di un condensatore presente sulla cella di memoria, ma questo condensatore anche se non mantiene la carica per molto tempo e\u00a0 se il dato viene letto la carica si esaurisce molto pi\u00f9 rapidamente, quindi i dati devono essere riscritti sia se si legge (solo la riga letta) che periodicamente (tutti i dati presenti).
Sono state scelte queste RAM per un semplice motivo, il costo!, infatti rispetto alle SRAM questo modello richiede molti meno transistor nella costruzione quindi si possono avere RAM con molta pi\u00f9 capacit\u00e0 al costo di una SRAM 4 volte pi\u00f9 piccola.<\/p>

Beh, ora vediamo come risolvere i problemi di queste memorie, spesso a causa del deterioramento dei condensatori non mantengono pi\u00f9 i dati scritti e un metodo per trovare la RAM guasta pu\u00f2 essere quello di posizionarne un’altra sopra di essa (metodo Piggyback), in questo modo i dati verranno scritti e memorizzati sulle due ram e se un dato va perso sulla ram difettosa, sar\u00e0 recuperato da quella buona.
Attenzione che non \u00e8 un sistema infallibile, infatti se la RAM ha dei pin in corto, quella messa sopra non riuscir\u00e0 a passare nessun dato sulla linea in corto, inoltre se ci sono pi\u00f9 banchi difettosi il computer potrebbe non partire (se non ha un sistema per controllare la RAM all’avvio) e non saprete quale altra \u00e8 rovinata.<\/p>

Questo metodo invece richiede di costruirsi un piccolo tester basato su Arduino, lo schema si trova in rete ed \u00e8 molto semplice, il funzionamento non fa altro che scrivere e leggere diverse volte per verificare che i dati siano effettivamente corretti.
Potete trovare le informazioni e lo schema a questo link:\u00a0https:\/\/forum.defence-force.org\/viewtopic.php?t=1699<\/a><\/p>

Attenzione<\/em>: il firmware di Arduino su questo link contiene un bug su l’indirizzamento della memoria, vi potr\u00e0 dare ram ok mentre invece \u00e8 guasta, perch\u00e9 non testa tutti gli indirizzi. Seguite la guida fino in fondo dove metter\u00f2 il link con il firmware corretto!<\/div>

Visto che lo schema \u00e8 disegnato a mano, ve ne metto uno rifatto seguendo l’originale (by ISS):<\/p>

Tester per 4164<\/h3>

\u00a0<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t

\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t<\/i>\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\tDownload Firmware<\/span>\n\t\t\t\t\t<\/span>\n\t\t\t\t\t<\/a>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/i><\/span>\n\t\t\t\t\t\t\t\t<\/i><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\tCodice sorgente<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t

#include <SoftwareSerial.h><\/p>

#define DI 15 \/\/ PC1
#define DO 8 \/\/ PB0
#define CAS 9 \/\/ PB1
#define RAS 17 \/\/ PC3
#define WE 16 \/\/ PC2<\/p>

#define XA0 18 \/\/ PC4
#define XA1 2 \/\/ PD2
#define XA2 19 \/\/ PC5
#define XA3 6 \/\/ PD6
#define XA4 5 \/\/ PD5
#define XA5 4 \/\/ PD4
#define XA6 7 \/\/ PD7
#define XA7 3 \/\/ PD3
#define XA8 14 \/\/ PC0<\/p>

#define M_TYPE 10 \/\/ PB2
#define R_LED 11 \/\/ PB3
#define G_LED 12 \/\/ PB4<\/p>

#define RXD 0 \/\/ PD0
#define TXD 1 \/\/ PD1<\/p>

#define BUS_SIZE 9 \/\/ impostare a 7 se utilizzato per 4116<\/p>

volatile int bus_size;<\/p>

\/\/SoftwareSerial USB(RXD, TXD);<\/p>

const unsigned int a_bus[BUS_SIZE] = {
XA0, XA1, XA2, XA3, XA4, XA5, XA6, XA7, XA8
};<\/p>

void setBus(unsigned int a) {
int i;<\/p>

\/\/funzione corretta<\/p>

for (i = 0; i < bus_size; i++) {<\/p>

\u00a0\u00a0\u00a0 if (bitRead(a, i)==1) {
\u00a0\u00a0\u00a0\u00a0\u00a0 digitalWrite(a_bus[i], HIGH);
\u00a0\u00a0\u00a0 } else {
\u00a0\u00a0\u00a0\u00a0\u00a0 digitalWrite(a_bus[i], LOW);
\u00a0\u00a0\u00a0 }
\u00a0 }
}<\/p>

void writeAddress(unsigned int r, unsigned int c, int v) {
\/* row *\/
setBus(r);
digitalWrite(RAS, LOW);<\/p>

\/* rw *\/
digitalWrite(WE, LOW);<\/p>

\/* val *\/
digitalWrite(DI, (v & 1)? HIGH : LOW);<\/p>

\/* col *\/
setBus(c);
digitalWrite(CAS, LOW);<\/p>

digitalWrite(WE, HIGH);
digitalWrite(CAS, HIGH);
digitalWrite(RAS, HIGH);
}<\/p>

int readAddress(unsigned int r, unsigned int c) {
int ret = 0;<\/p>

\/* row *\/
setBus(r);
digitalWrite(RAS, LOW);<\/p>

\/* col *\/
setBus(c);
digitalWrite(CAS, LOW);<\/p>

\/* get current value *\/
ret = digitalRead(DO);<\/p>

digitalWrite(CAS, HIGH);
digitalWrite(RAS, HIGH);<\/p>

return ret;
}<\/p>

void error(int r, int c)
{
unsigned long a = ((unsigned long)c << bus_size) + r;
digitalWrite(R_LED, LOW);
digitalWrite(G_LED, HIGH);
interrupts();
Serial.print(” FAILED $”);
Serial.println(a, HEX);
Serial.flush();
while (1)
;
}<\/p>

void ok(void)
{
digitalWrite(R_LED, HIGH);
digitalWrite(G_LED, LOW);
interrupts();
Serial.println(” OK!”);
Serial.flush();
while (1)
;
}<\/p>

void blink(void)
{
digitalWrite(G_LED, LOW);
digitalWrite(R_LED, LOW);
delay(1000);
digitalWrite(R_LED, HIGH);
digitalWrite(G_LED, HIGH);
}<\/p>

void green(int v) {
digitalWrite(G_LED, v);
}<\/p>

void fill(int v) {
int r, c, g = 0;
v %= 1;
for (c = 0; c < (1<<bus_size); c++) {
green(g? HIGH : LOW);
for (r = 0; r < (1<<bus_size); r++) {
writeAddress(r, c, v);
if (v != readAddress(r, c))
error(r, c);
}
g ^= 1;
}
blink();
}<\/p>

void fillx(int v) {
int r, c, g = 0;
v %= 1;
for (c = 0; c < (1<<bus_size); c++) {
green(g? HIGH : LOW);
for (r = 0; r < (1<<bus_size); r++) {
writeAddress(r, c, v);
if (v != readAddress(r, c))
error(r, c);
v ^= 1;
}
g ^= 1;
}
blink();
}<\/p>

void setup() {
int i;<\/p>

Serial.begin(9600);
while (!Serial)
; \/* wait *\/<\/p>

Serial.println();
Serial.print(“DRAM TESTER “);<\/p>

for (i = 0; i < BUS_SIZE; i++)
pinMode(a_bus[i], OUTPUT);<\/p>

pinMode(CAS, OUTPUT);
pinMode(RAS, OUTPUT);
pinMode(WE, OUTPUT);
pinMode(DI, OUTPUT);<\/p>

pinMode(R_LED, OUTPUT);
pinMode(G_LED, OUTPUT);<\/p>

pinMode(M_TYPE, INPUT);
pinMode(DO, INPUT);<\/p>

digitalWrite(WE, HIGH);
digitalWrite(RAS, HIGH);
digitalWrite(CAS, HIGH);<\/p>

digitalWrite(R_LED, HIGH);
digitalWrite(G_LED, HIGH);<\/p>

\/\/ se si usa la memoria 4146 non inserire questo ciclo if (digitalRead)… else ..<\/p>

if (digitalRead(M_TYPE)) {
\/* jumper not set – 41256 *\/
bus_size = BUS_SIZE;
Serial.print(“256Kx1 “);
} else {
\/* jumper set – 4164 *\/
bus_size = BUS_SIZE – 1;
Serial.print(“64Kx1 “);
}<\/p>

Serial.flush();<\/p>

digitalWrite(R_LED, LOW);
digitalWrite(G_LED, LOW);<\/p>

noInterrupts();
for (i = 0; i < (1 << BUS_SIZE); i++) {
digitalWrite(RAS, LOW);
digitalWrite(RAS, HIGH);
}
digitalWrite(R_LED, HIGH);
digitalWrite(G_LED, HIGH);
}<\/p>

void loop() {
interrupts(); Serial.print(“.”); Serial.flush(); noInterrupts(); fillx(0);
interrupts(); Serial.print(“.”); Serial.flush(); noInterrupts(); fillx(1);
interrupts(); Serial.print(“.”); Serial.flush(); noInterrupts(); fill(0);
interrupts(); Serial.print(“.”); Serial.flush(); noInterrupts(); fill(1);
ok();
}<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t

\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

Realizzate questo circuito, programmate Arduino scaricando il file .ino oppure incollando il codice sorgente su di un progetto vuoto dell’ide di Arduino e programmatelo. Con Arduino connesso ad un pc potete vedere tramite il monitor seriale lo stato del test, oppure visibile tramite i led.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t

\n\t\t\t\t
\n\t\t\t\t\t

Funzionamento<\/h3>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

1. Selezionate il tipo di RAM (4164 – 41256) tramite il jumper, se inserito si testano le 4164, se lasciato aperto si testano le 41256.
2. Inserite la RAM da testare facendo attenzione al corretto orientamento (una inversione di polarit\u00e0 vi brucer\u00e0 il banco di RAM).
3. Alimentate Arduino che comincer\u00e0 subito il test, attendete poco pi\u00f9 di un minuto e se tutto ok si accender\u00e0 il led verde, in caso contrario il rosso.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t

\n\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t
\n\t\t\t<\/i>\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t

Un altro esempio di DRAM tester (4164) V1<\/h3>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

Questa \u00e8 una realizzazione di un tester simile a quello descritto sopra.<\/p>

E’ la prima versione che ho realizato e legge solo le 4164-256.
Il funzionamento \u00e8 leggermente diverso e funziona con un display e due pulsanti, uno per scegliere il tipo di RAM da testare e uno per iniziare il test.<\/p>

I vari test effettuati sono visibili nel display come il risultato finale.
In questo caso l’alimentazione della memoria viene gestita da Arduino che provveder\u00e0 ad alimentare la RAM appena\u00a0 si inizia il test e la interromper\u00e0 quando finito. Una piccola sicurezza per evitare di bruciare la RAM se viene posizionata al contrario.<\/p>

Ora tocca a voi inventare un vostro tester personale o pi\u00f9 semplicemente usare quello descritto.<\/p>

IL CODICE PRECEDENTE NON VA BENE PER QUESTO TESTER.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t

\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

Ed ora ecco il nuovo tester adatto anche per le 4116 V2<\/h3>
Il funzionamento \u00e8 identico al precedente solo che queste memorie hanno bisogno oltre della 5v anche di una 12v e una tensione negativa di -5v, oltre ad avere una linea di indirizzi in meno.<\/div>
In questo schema del nuovo tester ho utilizzato un lcd per visualizzare lo stato (come in quello sopra) ed ho aggiunto la parte di alimentazione per il chip 4116 (qui ho usato uno switch a 4 poli per gestire le due memorie, ma ne basta uno da 3 canali, uno l’ho usato per segnalare ad Arduino il tipo di memoria selezionata, anzi anche da 2 poli se non vogliamo controllare lo stato da arduino).<\/div>
Le resistenze da 47ohm sono opzionali, le ho usate come test e anche con queste si riesce a testare correttamente la memoria ed in caso di pin in corto sulla dram si evita di bruciare i pin di Arduino.<\/div>
L’alimentazione deve essere di circa 14V per avere una 12V corretta, altrimenti \u00e8 possibile utilizzare un dc-dc per portare la 5V di Arduino a 12V ed alimentare la ram cos\u00ec da evitare i 7812 e 7805 ed i diodi di protezione. Nella nuova revisione infatti ho alimentato tutto tramite la 5V di Arduino, portata a 12V con un booster e a -5V con il 7660.<\/div>
\u00a0<\/div>
Attenzione! non usate questo schema con il codice precedente, la piedinatura \u00e8 differente sia per la gestionre della ram che per i pulstanti e lcd.<\/div>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

Ed Infine la versione 4<\/h3>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

Questo utilizza l’alimentazione di Arduino e la eleva a 12V con il booster, pin pi\u00f9 crea la -5V con il 7660.
Lo switch \u00e8 stato sostituito con un jumper per evitare di spostarlo accidentalmente e bruciare la ram, per il resto \u00e8 simile alla versione 3.<\/p>

Anche questo PCB non \u00e8 compatibile con il sorgente originale.<\/p>

Se vuoi costruitlo visita la mia pagina github<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t

\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t<\/i>\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\tDram tester V4<\/span>\n\t\t\t\t\t<\/span>\n\t\t\t\t\t<\/a>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

Beta testing versione 4.2<\/h3>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

non finisce qui, in test la versione software per testare anche le ram 4532 (parte alta o bassa), con finale animato! \ud83d\ude42
Questa versione esegue 5 test:
1 scrittua-lettura bit 0-1
2 scrittura-lettura tutti 1
3 solo scrittura tutti 1
4 solo lettura attesi tutti 1 (verifica che i dati vengano mantenuti)
5 scrittura-lettura tutti 0<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t

\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\"\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t<\/div>\n\t\t","protected":false},"excerpt":{"rendered":"

Dram tester per 4116 e 4164!
\nCome costruirlo da soli..<\/p>","protected":false},"author":1,"featured_media":1291,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"categories":[],"tags":[],"class_list":["post-988","page","type-page","status-publish","has-post-thumbnail","hentry"],"_links":{"self":[{"href":"https:\/\/retrofixer.it\/en\/wp-json\/wp\/v2\/pages\/988","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/retrofixer.it\/en\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/retrofixer.it\/en\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/retrofixer.it\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/retrofixer.it\/en\/wp-json\/wp\/v2\/comments?post=988"}],"version-history":[{"count":3,"href":"https:\/\/retrofixer.it\/en\/wp-json\/wp\/v2\/pages\/988\/revisions"}],"predecessor-version":[{"id":8992,"href":"https:\/\/retrofixer.it\/en\/wp-json\/wp\/v2\/pages\/988\/revisions\/8992"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/retrofixer.it\/en\/wp-json\/wp\/v2\/media\/1291"}],"wp:attachment":[{"href":"https:\/\/retrofixer.it\/en\/wp-json\/wp\/v2\/media?parent=988"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/retrofixer.it\/en\/wp-json\/wp\/v2\/categories?post=988"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/retrofixer.it\/en\/wp-json\/wp\/v2\/tags?post=988"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}