leggere UV EPROM M27C1001 1 Mb (128Kb x8) con Mega 2560

Salve a tutti :), sono nuovo del forum e mi sono iscritto apposta perché volevo un consiglio su come impostare uno sketch per leggere sul monitor seriale un byte per volta (non voglio leggere tutta la memoria, perché non so se è pratico, inoltre non saprei decifrare cosa contiene vedendo 1'048'576 bit, lo faccio solo per pura didattica, mi accontento di leggere qualche byte a caso, ma se esiste un modo per tirarne fuori qualcosa non mi dispiacerebbe), dopo aver inserito da tastiera i 17 valori binari dell'indirizzo dove è contenuto.
sul datasheet ho controllato la piedinatura per collegare: ingressi indirizzi (A0 - A16), uscite (Q0 - Q7), 3 pin di abilitazione, alimentazione, e infine la procedura (valori di tensione e altre informazioni) di lettura.
se ho dimenticato di dire o fare qualcosa di importante ditemelo.
Grazie in anticipo.

Buona sera e benvenuto sul forum,
essendo il tuo primo post, nel rispetto del regolamento, ti chiedo cortesemente di presentarti QUI (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con MOLTA attenzione il su citato REGOLAMENTO ... Grazie.

Guglielmo

P.S.: Qui una serie di link utili, NON necessariamente inerenti alla tua domanda:
- serie di schede by xxxPighi per i collegamenti elettronici vari: ABC - Arduino Basic Connections
- pinout delle varie schede by xxxPighi: Pinout
- link generali utili: Link Utili

Ho fatto quanto richiesto.

Riguardo al mio problema: ho provato a fare un semplice codice iniziale solo per leggere un byte ma sembra non funzionare perché mi da come risultato 8 zeri (ammesso che la memoria fosse stata vuota, avrebbe dovuto contenere tutti 1 di default).

Sicuramente ho sbagliato qualcosa nel codice, se qualcuno può aiutarmi glie ne sarei molto grato.
Grazie.

// Dichiarazione numeri pin:
  // abilitazioni
const int P = 47;
const int G = 48;
const int E = 49;
  // indirizzi
const int I0 = 22;
const int I1 = 23;
const int I2 = 24;
const int I3 = 25;
const int I4 = 26;
const int I5 = 27;
const int I6 = 28;
const int I7 = 29;
const int I8 = 30;
const int I9 = 31;
const int I10 = 32;
const int I11 = 33;
const int I12 = 34;
const int I13 = 35;
const int I14 = 36;
const int I15 = 37;
const int I16 = 38;
  // dati
const int Q0 = 39;
const int Q1 = 40;
const int Q2 = 41;
const int Q3 = 42;
const int Q4 = 43;
const int Q5 = 44;
const int Q6 = 45;
const int Q7 = 46;

void setup() {
  Serial.begin(9600);
  // dichiarazione Pin Input:
  pinMode(Q0, INPUT);
  pinMode(Q1, INPUT);
  pinMode(Q2, INPUT);
  pinMode(Q3, INPUT);
  pinMode(Q4, INPUT);
  pinMode(Q5, INPUT);
  pinMode(Q6, INPUT);
  pinMode(Q7, INPUT);
  // dichiarazione Pin Output:
    // Pin Controllo:
  pinMode(P, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(E, OUTPUT);
    // Pin Indirizzi:
  pinMode(I0, OUTPUT);
  pinMode(I1, OUTPUT);
  pinMode(I2, OUTPUT);
  pinMode(I3, OUTPUT);
  pinMode(I4, OUTPUT);
  pinMode(I5, OUTPUT);
  pinMode(I6, OUTPUT);
  pinMode(I7, OUTPUT);
  pinMode(I8, OUTPUT);
  pinMode(I9, OUTPUT);
  pinMode(I10, OUTPUT);
  pinMode(I11, OUTPUT);
  pinMode(I12, OUTPUT);
  pinMode(I13, OUTPUT);
  pinMode(I14, OUTPUT);
  pinMode(I15, OUTPUT);
  pinMode(I16, OUTPUT);
  // abilitazione chip
  digitalWrite (P, HIGH);
  digitalWrite (G, LOW);
  digitalWrite (E, LOW);
  // indirizzo casuale (00010001000010001)
  digitalWrite (I0, LOW);
  digitalWrite (I1, LOW);
  digitalWrite (I2, LOW);
  digitalWrite (I3, HIGH);
  digitalWrite (I4, LOW);
  digitalWrite (I5, LOW);
  digitalWrite (I6, LOW);
  digitalWrite (I7, HIGH);
  digitalWrite (I8, LOW);
  digitalWrite (I9, LOW);
  digitalWrite (I10, LOW);
  digitalWrite (I11, LOW);
  digitalWrite (I12, HIGH);
  digitalWrite (I13, LOW);
  digitalWrite (I14, LOW);
  digitalWrite (I15, LOW);
  digitalWrite (I16, HIGH);
  delay (20);
  // lettura bit Cella
  int Bit0 = digitalRead(Q0);
  Serial.println(Bit0);
  delay (1);
  int Bit1 = digitalRead(Q1);
  Serial.println(Bit1);
  delay (1);
  int Bit2 = digitalRead(Q2);
  Serial.println(Bit2);
  delay (1);
  int Bit3 = digitalRead(Q3);
  Serial.println(Bit3);
  delay (1);
  int Bit4 = digitalRead(Q4);
  Serial.println(Bit4);
  delay (1);
  int Bit5 = digitalRead(Q5);
  Serial.println(Bit5);
  delay (1);
  int Bit6 = digitalRead(Q6);
  Serial.println(Bit6);
  delay (1);
  int Bit7 = digitalRead(Q7);
  Serial.println(Bit7);
  }
void loop (){
  
}

A parte l'inversione dei bit dell'indirizzo (I0 dovrebbe essere il bit di destra) e nella stampa (Q0 dovrebbe essere a destra), il procedimento è giusto.

Il pin /P non serve comandarlo, serve solo durante la programmazione, in lettura basta lasciarlo collegato a Vcc come anche il pin Vpp.

Magari quella cella presa per caso contiene effettivamente zero, bisognerebbe provare a stampare ad esempio tutto il primo kbyte.

Claudio_FF:
A parte l'inversione dei bit dell'indirizzo (I0 dovrebbe essere il bit di destra) e nella stampa (Q0 dovrebbe essere a destra)

Hai ragione, I0 è LSB, vanno scritti da destra verso sinistra. (I16,I15,....,I2,I1,I0)

Claudio_FF:
Il pin /P non serve comandarlo, serve solo durante la programmazione, in lettura basta lasciarlo collegato a Vcc come anche il pin Vpp.

Si l'ho letto nel datasheet, al livello logico di /P compare una X (scelta arbitraria) quindi essendo un pin di abilitazione alla programmazione (non necessario per ciò che voglio fare io) lo volevo lasciare disabilitato mettendolo a HIGH (Dato che è a logica invertita).

Vpp l'ho collegato già diretto a Vcc.

Claudio_FF:
Magari quella cella presa per caso contiene effettivamente zero, bisognerebbe provare a stampare ad esempio tutto il primo kbyte.

Ci avevo pensato anche io, poi ho provato 3 o 4 diversi indirizzi (cambiando la combinazione di HIGH e LOW) ma il risultato era sempre 8 zeri, siccome ero insicuro del funzionamento corretto del mio sketch ho pensato che andasse cambiato, ma giustamente potrebbero essere state celle con byte nulli, quindi per accertarmene dovrei (come mi consigli te) stamparne un bel po, solo che non ho idea di come impostare lo sketch, se mi potessi dare qualche idea di procedure (come impostare i cicli di lettura, di che variabili ho bisogno) te ne sarei veramente grato.

Grazie per la conferma e il chiarimento sullo sketch fatto fino ad ora.

Si può usare una variabile di tipo long chiamata ad esempio 'addr', a cui far assumere diversi valori (compresi tra 0 e 131071) tramite un ciclo for.

Per ogni valore i bit di questa variabile vanno scritti sulle uscite I16..I0. Suggerimento: l'LSB si ottiene con addr&1, e i bit di addr possono essere fatti scorrere a destra di una posizione con addr>>=1

Similmente si possono leggere i bit dati da Q7..Q0 ricomponendo un byte 'n' di valore compreso tra 0 e 255. Suggerimento: in questo caso è più semplice partire leggendo Q7 e spostando i bit di 'n' a sinistra.

Ok, credo di aver capito la procedura... non mi intendo molto di programmazione quindi ci impiegherò parecchio per ottenere qualcosa.

Grazie mille per i suggerimenti e la disponibilità.

Comunicherò gli sviluppi.

Non sono riuscito ancora a scrivere il codice, però ho provato a cambiare gli indirizzi sul vecchio sketch e in qualche cella finalmente ho trovato byte diversi da 0.

So che non è molto ma sono soddisfatto che abbia funzionato, se riuscirò a fare uno sketch funzionante per leggerla tutta (o quasi) in un colpo solo, oppure per leggere il byte all'indirizzo inserito di volta in volta da tastiera, lo pubblicherò.

Riesumo questo topic non-troppo-giovane perché recentemente mi sono ritrovato a dover fare qualcosa del genere.

Ho usato un Arduino Uno. Siccome non ha abbastanza pin, ho deciso di usare 2 shift register 74595 in cascata per pilotare il bus indirizzi.

I dati letti vengono trasmessi sulla serial byte per byte, ho provveduto a realizzare un semplice script Python per scrivere su file quanto ricevuto.

Il codice (molto grezzo) è disponibile qua: GitHub - SukkoPera/Arduino-Rom-Dumper: Arduino-based (E)(EP)ROM Dumper. Nelle relative pagine wiki c'è lo schema delle connessioni necessarie per dumpare una ROM 2332 da 4 Kb, ma con semplici modifiche si può usare anche per ROM più grosse. Io sono arrivato fino a una 27128 da 16 Kb.

:slight_smile: