EMU SP-12 non funziona

[Ctec]

16V8, combinatoria. Se protetta, ci vuole pazienza, ma è fattibile. Quelle con la R al posto della V sono sequenziali, possono essere parecchio complicate.

Quando tutto funzionerà, metti una bella foto della scheda con tutti chip, e anche dell'oggetto in funzione.

 

[ez9]

 

 

Ri aggiorno dopo alcuni mesi di assenza dove non ho avuto proprio tempo di guardare l'EMU, provo a rimettermi al lavoro per completare i test e...con grande sorpresa l'EMU si accende ma non carica piu' la rom di debug, non capisco il perche', sono sicuro che dopo aver sostituito il PAL la rom di debug veniva letta ,ho anche una foto che conferma sul display il boot in debug "Diagnostic 1.8 Enter Test #". ora non piu', sul display mi da "SP-12 Turbo vers. 2.6 1/20/87". Con  la rom originale parte correttamente e mi chiede di selezionare la traccia da suonare. Pensavo quindi alla rom di debug rovinata, mi sono procurato un lettore di ROM ho provato a leggere la rom di debug con un file trovato in rete ed e' identica, ho poi anche programmato un'altra ROM 74C64 con il file preso dalla rete e messo su, ma non carica piu' la diagnostica...non capisco quale possa essere il problema.

Ora mi mangio le mani per non aver fatto le diagnosi prima quando la leggeva ma purtroppo non ho avuto tempo.

com'e' possibile che legga una ROM si e l'altra no?

 

Allego la foto della board principale montata

 

[ez9]

Buongiorno! torno dopo mesi ad occuparmi dell EMU (purtroppo il tempo per giocare e' sempre poco)

A questo punto visto che il boot normale va ma in diagnostica no e il problema non e' la ROM, penso che ci sia qualche RAM che non funziona correttamente.

in questa configurazione Turbo ci sono 29 chip 8464-15L 64K RAM a 8 Bit. Tensione di alimentazione e massa arriva correttamente a tutti i chip.

Ho pensato di procedere con un tester per le ram.

Ho preso un arduino Mega per avere tutte le uscite ingressi necesari e mi ho fatto un loop per testare tutti gli indirizzi.

Ho fatto un loop che scrive e poi legge per ogni singolo indirizzo della RAM da 0 a 8191 una sequenza di bit variabili in questo modo:

 

00000000

00000001

00000011

00000111

.....

11111111

01111111

00111111

...

0000000

 

in pratica sono 17 scritture/ letture per ogni indirizzo

 

Ho letto qualcosa a riguardo e questa dovrebbe essere una procedura corretta per minimizzare i i cicli di lettura/scrittura e velocizzare il test.

Secondo voi puo' essere un test attendibile fatto in questo modo?

l'ho fatto partire su una ram ma dopo circa 10 min era solamente a meta'... ho messo un delay di 2 millisecondi ad ogni cambio dello stato tra lettura e scrittura, forse potrei scendere a 1 in teoria la RAM dovrebbe avere tempo di accesso di 150 nS

 

[Ctec]

Sono zoccolate, non hai un semplice programmatore di Eprom che testa anche le RAM?

Altrimenti, per fare prima, scrivi in ogni indirizzo 0x55 e poi rileggilo con una piccola pausa. Se va  bene passa al successivo. Al termine, scrivi e rileggi da capo 0xAA. Se per ogni scrittura/lettura impieghi 1us, ci dovresti mettere un totale di 131ms per entrambe le operazioni (sono in tutto 65536x2 scritture/letture).

Ma anche nel tuo caso, 17 operazioni diciamo a 500ns (150n+pausa+150n), dovresti fare 17x65536 cicli = 1,114,112 cicli => 556ms.

Ma mettendo un ritardo di 2ms tra ciclo e ciclo, hai in totale 2.23s solo per le pause, quindi non mi torna lo stesso come mai il test è così lento.

 

Ah, perché quei due valori? 0x55 è 01010101b e 0xAA è 10101010, come si vede si alternano i bit di ogni byte, quindi con due soli valori si testano i cambi di stato di tutti e 8 i bit.

Modificato: 12 gennaio da Ctec

[ez9]

No purtroppo no non ho tester per le ram. Comunque posso provare a ridurre i cicli di scrittura come da te suggerito poi posso sempre rifare i test se ho dubbi con cicli più lunghi 

[ez9]

Allora ho fatto qualche test ma praticamente tutte le RAM mi danno qualche errore (circa 100-170 errori) su un ciclo di 2 scritture totali quindi 16382 letture/scritture

 

Inizio a dubitare che il test non sia affidabile, ho provato anche ad allungare i tempi ma non cambia nulla.

 

inizialmente avevo messo scritte sul serial output su ogni operazione ma poi ho visto che rallenta molto e quindi ho lasciato solo in caso di errore.

 

il test fa una scrittura completa di tutta la Ram con valore 0x55, poi ripassa a leggere per verifica, poi riscrive tutta la ram con 0xAA e verifica di nuovo.

Ripetendo il test non sempre gli errori capitano sugli stessi indirizzi.

Ho provato anche a testare un singolo indirizzo segnalato dagli errori e provando tutte le combinazioni da da 0 a 255 e a volte e' passato senza problemi

 

metto qui il loop di scrittura:

 

void writeData (int addressCounter, byte dataCounter)

{

  //Set data Pin modes to output

  for (int i=0;i<8;i++)

  {

    pinMode (dataPins[i], OUTPUT);

  }

  // Disable Outputs

  digitalWrite(GPin, HIGH);

  // Enable CE1 Outputs

  digitalWrite(E1Pin, LOW);

  // Enable CE2 Outputs

  digitalWrite(E2Pin, HIGH);

  // Setup address Bits

  for (int i=0;i<13;i++)

  {

    if (bitRead(addressCounter, i)==1)

    {

      digitalWrite(addPins[i],HIGH);

    }

    else

    {

      digitalWrite(addPins[i],LOW);

    }  

  }

   // Setup Data Bits

  for (int i=0;i<8;i++)

  {

    if (bitRead(dataCounter, i)==1)

    {

      digitalWrite(dataPins[i],HIGH);

    }

    else

    {

      digitalWrite(dataPins[i],LOW);

    }  

  }

// Set Write mode

digitalWrite(WPin, LOW);

delay (2);

// Set Read mode

digitalWrite(WPin, HIGH);

// Disable CE1 Outputs

  digitalWrite(E1Pin, HIGH);

  // Disable CE2 Outputs

  digitalWrite(E2Pin, LOW);

}

 

Allego ciclo di scrittura della Ram 8464

 

Si puo' allegare il codice arduino? vedo che negli allegati accetta solo formati immagine

Modificato: 29 gennaio da ez9

[Livio Orsini]

Non è detto che siano le memorie difettose, ci possono essere problemi sul bus, anzi per mia esperienza è più facile che si tratti di spikes e rumori sul bus e sull'alimentazione

Io solitamente usavo cicli di scrittura di un byte = 55h alternato a AAh,al termine rileggevo; poi ripetevo partendo con AAh alternato a 55H. Questo permette di capire ancora meglio se ha problemi la memoria. Se è un problema di memoria trovi esempre i medesimi errori ai medesimi indirizzi; se gli errori e gli indirizzi variano è molto probabile che sia un problema legato al bus o all'eccesiva "rumorosità".

Mi è capitato, con alimentazione non ben filtrata, di avere numerosi errori random dovuti a spikes presenti sull'alimentazione.

[ez9]

ok, grazie del consiglio, al momento sto alimentato la RAM con l'uscita di arduino, che e' alimentato dalla USB del pc. vedo di rifare i test usando un alimentatore esterno

[ez9]

Ho provato a rifare i test con un alimentazione esterna e la situazione e' un pochino migliorata sono sceso da una media di 180 errori a circa 50 errori, su circa 16300 letture/scritture.

Quello che non capisco che all'improvviso si creano dei distrurbi su tutte le uscite/ingressi si Arduino che mi falsano il risultato. visibili anche con l'oscilloscopio, qui in foto anche non molto evidenti ma a volte i picchi sono molto pronunciati.

PS. la ram l'ho montata su una breadboard e i fili per collegare il bus e gli indirizzi saranno lunghi al max 10 cm. potrebbe essere questo il problema?

sinceramente pensavo fosse piu' semplice testarle con arduino.

 

magari potrei introdurre un loop di scrittura lettura che se entro 3-5 tentativi non riesce ad ottenere il dato corretto mi fallisce il test e passa all'indirizzo successivo, pero' se i distrubi permangono temo che anche questo ulteriore controllo possa fallire.

 

 

 

Modificato: 1 febbraio da ez9

[Livio Orsini]

Arduino lo alimenti da usb?

prova ad alimentarlo esternamente tramite un alimentatore serio e ben filtrato; usa un alimentatore che eroghi circa 9V e possa erogare almeno 0,5A di corrente.

Anche il collegamento con fili volanti potrebbe raccogliere disturbi.

 

Sono verifiche delicate dove anche il layout del sistema di test ha influenza.

[ez9]

Inizialmente si, alimentavo da USB, poi ho messo alimentatore stabilizzato  (0-70V regolabile max 10A ) e' un alimentatore professionale.

Ho anche scollegato la USB, in numero di errori e' sceso molto ma anche cosi qualche errore lo da. (circa una media di 50 errori) su 16000 letture/scritture

 

 

 

Modificato: 1 febbraio da ez9

[Livio Orsini]

Sono sempre propenso a considerare i disturbi come causa degli errori. Gli errori, se fossero dovuti a difetti delle memorie, serebbero sempre algi stessi indirizzi. Se, come hai scritto, si presentano ad indirizzi differenti allora è questione di disturbi, o di comandi non ben sincronizzati con i dati e gli indirizzi. Per esempio se hai del jitter sul comando di write e sei un po' al limite con i tempi, ti può capitare di scrivere male.

[ez9]

Salve,

 

torno su queste ram perche' non mi convincono, ma non riesco a capire se sbaglio io a testarle oppure sono difettose.

 

ho messo su arduino un pulsante per scrivere e uno per leggere, ma non capisco perche' dopo una scrittura se provo diversi cicli di lettura ottengo valori sempre diversi cosa sto sbagliando?

ho provato a fare letture sia con ritardi molto bassi (1 millisec ) che con ritardi molto lunghi ( 1 sec e oltre)

 

per esempio scrivo 01010101

leggo: 01010101

poi:  11110111

poi: 11110111

11110111

11110111

poi 11111111

 oppure valori random

 

il ciclo di lettura e' questo:

 

imposto gli indirizzi, attivo E1 basso, attivo E2 alto e abilito gli output con G basso, poi letto e riporto G alto

 

void readData (int addressCounter, byte dataCounter)

{

  //Set data Pin modes to input

  for (int i=0;i<8;i++)

  {

    pinMode (dataPins[i], INPUT);

  }

  delay (2);

   //Setup address Bits

   for (int i=0;i<13;i++)

   {

     if (bitRead(addressCounter, i)==1)

     {

      digitalWrite(addPins[i],HIGH);    

     }

     else

     {

       digitalWrite(addPins[i],LOW);

     }  

   }

   // Set Read Mode

   digitalWrite(WPin, HIGH);

   // Enable E1 Outputs

   digitalWrite(E1Pin, LOW);

   delay(1);

   // Enable E2 Outputs

   digitalWrite(E2Pin, HIGH);

   delay(1);

   // Enable Output

   digitalWrite(GPin, LOW);

   delay(1);

   //Data is now Valid

   //Read data bits

   for (int i=0;i<8;i++)

  {

    byte b;

    b=digitalRead(dataPins[i]);

    bitWrite(dataBus,i,b);

  }

  if (dataCounter != dataBus)

  {

    Serial.print("ERROR AT ADDRESS ");Serial.print(addressCounter);Serial.print('\n');

    Serial.print(bitRead(dataCounter,7));Serial.print(bitRead(dataCounter,6));Serial.print(bitRead(dataCounter,5));Serial.print(bitRead(dataCounter,4));Serial.print(bitRead(dataCounter,3));Serial.print(bitRead(dataCounter,2));Serial.print(bitRead(dataCounter,1));Serial.print(bitRead(dataCounter,0));Serial.print(" <---DATA WRITTEN = ");Serial.print(dataCounter);Serial.print('\n');

    Serial.print(bitRead(dataBus,7));Serial.print(bitRead(dataBus,6));Serial.print(bitRead(dataBus,5));Serial.print(bitRead(dataBus,4));Serial.print(bitRead(dataBus,3));Serial.print(bitRead(dataBus,2));Serial.print(bitRead(dataBus,1));Serial.print(bitRead(dataBus,0));Serial.print(" <---DATA READ = ");Serial.print(dataBus);Serial.print('\n');

    Error++;

  }

  else {Serial.print(dataBus);Serial.print('\n');}

  Serial.print("read completed ");Serial.print('\n');

  delay(1);

    // Disable Outputs

  digitalWrite(GPin, HIGH);

    //Serial.print('\n');

}

 

 

 

[Livio Orsini]

Scusa ma tu leggi e scrivi le memorie con arduino?

[Ctec]

Quello che non mi piace troppo è questo:

  for (int i=0;i<8;i++)

  {

    byte b;

    b=digitalRead(dataPins[i]);

    bitWrite(dataBus,i,b);

  }

cioè leggi un bit alla volta, cosa che potrebbe dare problemi in caso di disturbi.

Meglio se separi le operazioni in differenti funzioni. Una per scrivere l'indirizzo, una per dare la sequenza della lettura, una per la lettura vera e propria di tutti gli 8 bit contemporaneamente e rimettere a riposo i bit di controllo. Poi una finale per la ricomposizione (se necessaria) della sequenza bit dati.

Se non sei sicuro dei rumori, potrebbe essere una buona idea usare dei latch per memorizzare l'indirizzo e il byte dati (tipo un 74LS373 o 74LS374 o 74LS573), in modo che si scrive e legge da arduino ai latch, che fanno da buffer verso la RAM.

[ez9]

38 minutes ago, Livio Orsini said:

Scusa ma tu leggi e scrivi le memorie con arduino?

Si non saprei come testarle in altro modo

[ez9]

18 minutes ago, Ctec said:

Quello che non mi piace troppo è questo:

  for (int i=0;i<8;i++)

  {

    byte b;

    b=digitalRead(dataPins[i]);

    bitWrite(dataBus,i,b);

  }

cioè leggi un bit alla volta, cosa che potrebbe dare problemi in caso di disturbi.

Meglio se separi le operazioni in differenti funzioni. Una per scrivere l'indirizzo, una per dare la sequenza della lettura, una per la lettura vera e propria di tutti gli 8 bit contemporaneamente e rimettere a riposo i bit di controllo. Poi una finale per la ricomposizione (se necessaria) della sequenza bit dati.

Se non sei sicuro dei rumori, potrebbe essere una buona idea usare dei latch per memorizzare l'indirizzo e il byte dati (tipo un 74LS373 o 74LS374 o 74LS573), in modo che si scrive e legge da arduino ai latch, che fanno da buffer verso la RAM.

 

e come potrei fare per leggere tutti e 8 i pin contemporaneamente? c'e' una funzione su Arduino per leggere piu' ingressi simultaneamente?

[Ctec]

17 minuti fa, ez9 ha scritto:

come potrei fare per leggere tutti e 8 i pin contemporaneamente?

 

Beh, se li metti tutti in una porta (che so, la porta C), puoi scrivere

byte = PORTC;

e li leggi tutti contemporaneamente, oppure 

PORTC = byte;

e li scrivi tutti contemporaneamente. Se non sono in fila (0..7), basta poi che li riorganizzi con una funzione dedicata.

Oppure il "trucco" dei latch. Magari un latch seriale, così usi meno pin (a questo ci ho pensato ora).

 

Ah, mi raccomando, occhio che i segnali I/O siano TTL 5V.

Modificato: 22 marzo da Ctec

[Livio Orsini]

4 ore fa, Ctec ha scritto:

Se non sei sicuro dei rumori, potrebbe essere una buona idea usare dei latch per memorizzare l'indirizzo e il byte dati (tipo un 74LS373 o 74LS374 o 74LS573), in modo che si scrive e legge da arduino ai latch, che fanno da buffer verso la RAM.

 

Concordo in tutto, anche se io userei lo 74HCT573 .

Scrivendo e leggendo in quel modo gli errori non credo proprio dipendano dalle memorie.

Io "latcherei" sia gli indirizzi che i dati.

[ez9]

ok grazie!

Vedro' di fare un test usando le porte, vediamo cosa salta fuori

Sto usando un Arduino Mega, vedo di trovare il pin out delle porte in modo da usare una porta digitale cosi dovrei avere gia' i segnali TTL.

[Ctec]

Guardando il datasheet del AtMEGA (che è il micro del Arduino Mega) e quello delle M8464 Fujitsu, noto questo:

AtMega                           M6484

Voh = 4.2Vmin @5V       Vih = 2.2Vmin         quindi ok

Vol = 0.9Vmax @5V       Vil = 0.8Vmax          quindi potrebbero esserci problemi

 

Ricordo che i livelli TTL sono:

 

Quindi il livello basso potrebbe andare nella zona indeterminata della RAM, soprattutto data l'età degli oggetti...

Metti dei latch 74LS se vuoi evitare problemi di livello.

[Livio Orsini]

19 minuti fa, Ctec ha scritto:

Quindi il livello basso potrebbe andare nella zona indeterminata della RAM, soprattutto data l'età degli oggetti...

Metti dei latch 74LS se vuoi evitare problemi di livello.

 

Se usa la serie 74HCTxx questo problema non si pone.

[Ctec]

Pensavo agli LS perché quelle memorie sono dell'era loro. Non ho citato gli HCT perché non penso che il consumo sia un problema...

L'importante è che siano TTL (quindi niente HC)

[Livio Orsini]

Quando si mescolano le tecnologie, purtroppo sorgono di questi problemi; problemi che, a volte, non vengono considerati in partenza e poi ci si ritrovano strani comportamenti.

[Claudio F]

Essendo una memoria statica, dove per definizione i livelli rimangono stabili a tempo indeterminato, leggere i bit tutti in un colpo o uno alla volta per me è indifferente. Se ci sono disturbi non è che dobbiamo "cercare di schivarli". Non ho mai avuto problemi a leggere e scrivere memorie (CMOS) con ArduinoMega un bit alla volta.

 

Per sicurezza misurerei la tensione alta e bassa di un'uscita di Arduino collegata alla memoria, così ci togliamo il dubbio sui livelli.

 

Per l'accesso partirei da una situazione iniziale del bus dati+indirizzi+controlli impostata nel setup:

 

    pinMode(E1Pin, OUTPUT);
    digitalWrite(E1Pin, HIGH);  // Disable E1
    pinMode(E2Pin, OUTPUT);
    digitalWrite(E2Pin, LOW);   // Disable E2
    pinMode(WPin, OUTPUT);
    digitalWrite(WPin, HIGH);   // Disable write
    pinMode(GPin, OUTPUT);
    digitalWrite(GPin,  HIGH);  // Disable Output
    // Data BUS IN
    for (int i=0; i<8; i++) 
        pinMode (dataPins[i], INPUT);
    // Address bus OUT
    for (int i=0; i<13; i++)
        pinMode(addPins[i], OUTPUT);

 

e due funzioni che una volta terminate lasciano i bus nella condizione di riposo:

 

byte readData (unsigned int address)
{
    //Setup address bus
    for (int i=0; i<13; i++)
        digitalWrite(addPins[i], bitRead(address, i));
   
    digitalWrite(E1Pin, LOW);   // Enable E1
    digitalWrite(E2Pin, HIGH);  // Enable E2
    digitalWrite(GPin,  LOW);   // Enable Read

    delayMicroseconds(5);

    byte data;
    for (int i=0; i<8; i++)
        bitWrite(data, i, digitalRead(dataPins[i]));
       
    digitalWrite(GPin,  HIGH);  // Disable Read
    digitalWrite(E2Pin, LOW);   // Disable E2
    digitalWrite(E1Pin, HIGH);  // Disable E1

    // Reset address bus
    for (int i=0; i<13; i++) 
        digitalWrite(addPins[i], 0);  

  return data;
}

 

void writeData (unsigned int address, byte data)
{
    // Data BUS out
    for (int i=0; i<8; i++) 
        pinMode (dataPins[i], OUTPUT);

    // Setup Data bus
    for (int i=0; i<8; i++) 
        digitalWrite(dataPins[i], bitRead(data, i));

    // Setup address bus
    for (int i=0; i<13; i++) 
        digitalWrite(addPins[i], bitRead(address, i));

    digitalWrite(E1Pin, LOW);    // Enable E1
    digitalWrite(E2Pin, HIGH);   // Enable E2
    digitalWrite(WPin, LOW);     // Enable write

    delayMicroseconds(5);

    digitalWrite(WPin, HIGH);    // Disable write
    digitalWrite(E2Pin, LOW);    // Disable E2
    digitalWrite(E1Pin, HIGH);   // Disable E1

    // Reset address bus
    for (int i=0; i<13; i++) 
        digitalWrite(addPins[i], 0);
  
    // Data BUS in
    for (int i=0; i<8; i++) 
        pinMode (dataPins[i], INPUT);
}

 

I delay non dovrebbero neppure servire, le digital read/write impiegano già circa 5 µs ciascuna.

 

 

 

 

Modificato: 23 marzo da Claudio F