6502 Computer minimale (con Arduino MEGA) Parte 3: 7 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Andando oltre, ho aggiunto un Octal Latch, 8 LED rettangolari e un array di resistori da 220 Ohm alla scheda madre. C'è anche un ponticello tra il pin comune dell'array e la massa, in modo che i LED possano essere spenti. Il gate 74HC00 NAND è stato sostituito con un gate 78LS08 AND, anche il cablaggio al gate è stato modificato. Il cancello AND significa che il 6522 si trova ora a $ 6000 invece di $ E000.

C'è anche un pin per il collegamento di un clock esterno per pilotare il 6502. Con questo collegamento, non è necessario che il MEGA fornisca un segnale di clock. Il MEGA continua a monitorare cosa sta succedendo con il processore come prima.

Ho usato un 74HC373 a 20 pin per il fermo perché ne avevo alcuni. Questo andava bene quando era sulla breadboard, ma un 74HC573 è compatibile con il bus e avrebbe risparmiato un sacco di cavi. Anche l'UCN5801A, che è un circuito integrato a 22 pin, potrebbe essere considerato nel circuito, ma il cablaggio sarà leggermente diverso.

Il LED arancione in alto è un indicatore di alimentazione e quello rosso in basso a sinistra indica quando è in corso una scrittura. Quest'ultimo sarà insignificante se la scheda viene utilizzata a velocità più elevate.

Il circuito modificato è sopra (con il 74HC573).

Fase 1: Programmi dimostrativi

Nel monitor 6502 sono inclusi due semplici programmi dimostrativi e il loro codice smontato è qui.

Questo programma carica 1 nel registro 6502 A e lo memorizza nel latch. Quindi aggiunge 1 al registro A e lo memorizza nel latch. Quindi torna a $ 1005 e il processo si ripete per sempre.

* = 1000

1000 A9 01 LDA #$01 1002 8D 00 41 STA $4100 1005 69 01 ADC #$01 1007 8D 00 41 STA $4100 100A 4C 05 10 JMP $1005 100D. END

Questo programma prima imposta il DDR della porta B del 6522 su output. Quindi memorizza $ 55 (B01010101) nella porta e nel fermo. Il registro A quindi ruota di 1 passo a destra e ora contiene $AA (B10101010). Questo è di nuovo memorizzato nella porta B e nel fermo. Il programma torna a $ 1005 e continua per sempre.

* = 1000

1000 A9 FF LDA #$FF 1002 8D 02 60 STA $6002 1005 A9 55 LDA #$55 1007 38 SEC 1008 8D 00 60 STA $6000 100B 8D 00 41 STA $4100 100E 6A ROR A 100F 8D 00 60 STA $6000 1012 8D 00 41 STA $4100 1015 4C 05 10 JMP $1005 1018. END

Gli occhi attenti tra di voi potrebbero notare che i LED colorati mostrano uno schema diverso da quelli verdi. Questo perché il comune è collegato a 5v su quelli colorati e il comune su quelli verdi è collegato a massa.

Cambia questa riga di codice in program2 o program3.

setDataPins(programma3[offset]);

Un 6502 Assembler e Disassembler sono strumenti utili per aiutarti a codificare i tuoi programmi.

Passaggio 2: aggiunta di una EEPROM

Per la scheda EEPROM, ho utilizzato una strip board da 950 x 650 mm e pin di intestazione maschio da 19 mm per consentire alla scheda di eliminare quella sottostante. Questa scheda si collega alla scheda 6502 sottostante. La EEPROM è un ATMEL 28C256 che ha 28 pin e contiene 32k x 8 bit di memoria. Questo è più che adeguato per i piccoli programmi attualmente in uso.

Non ho fatto uno schema elettrico per questa scheda, ma è abbastanza semplice come si collega alla scheda 6502 di seguito. Questi chip EEPROM non sono compatibili con il bus, quindi devono essere cablati ai singoli pin, quindi tutti gli "spaghetti verdi e bianchi". Ho risolto il problema di bridging sulla scheda precedente collegando insieme le linee dati sul lato inferiore della scheda.

I 14 pin di indirizzo della EEPROM si collegano ai pin appropriati sul lato sinistro (fili verdi) e i pin I/O ai pin dati a destra (fili bianchi). Il pin 27 (WE) è collegato al pin 28 (5v), il pin 22 (OE) è collegato a massa e il pin 20 (CE) è collegato a una porta NAND. I 2 ingressi della porta NAND sono collegati a A15 sul scheda principale. Ciò significa che quando questo pin diventa alto, il gate NAND fornisce un segnale basso al pin CE della EEPROM che lo rende attivo. Con questa configurazione significa che la EEPROM può essere letta solo dal 6502.

Poiché la EEPROM risiede nei primi 32k della mappa di memoria, significa che $FFFC e $FFFD possono contenere l'indirizzo iniziale per il 6502 dopo che è stato ripristinato. Con il 6522 che ha i suoi indirizzi tra $ 6000 e $ 600F e il latch è a $ 4100, interrompe qualsiasi conflitto di memoria.

Anche il vettore NMI ($FFFA e $FFFB) e il vettore BRK / IRQ ($FFFE e $FFFF) possono essere scritti allo stesso modo.

Passaggio 3: Programmazione della EEPROM

Per memorizzare un programma sulla EEPROM, è necessario un programmatore. Ne ho ricavato uno da una strip board, un Arduino Pro Mini, un paio di 74HC595 e un socket ZIF. Originariamente, il programmatore è stato creato per un AT28C16 che ha meno linee di indirizzo rispetto all'AT28C256, quindi ha dovuto essere modificato.

Lo schema del circuito mostra come cablare entrambe queste EEPROM. Non è chiaro dalla foto che i due chip 595 siano capovolti e non come mostrato nel diagramma. I pin da 1 a 7 di 595/1 si allineano con A1 a A7 della EEPROM indipendentemente da quale viene utilizzato. Ciò consente di risparmiare 7 fili di collegamento. La scheda ora sembra un po' stretta e questo perché originariamente usavo una presa DIL a 24 pin che ora è stata sostituita dalla presa ZIF a 28 pin molto più grande.

È incluso un programma che funziona con la mia scheda. Il programma funzionerà con qualsiasi Arduino e 595 in un circuito come mostrato. Ho scelto un 5v Pro Mini perché è compatto ed economico abbastanza da poter essere lasciato nel set up.

Passaggio 4: i programmi EEPROM

Ci sono tre semplici programmi nel programmatore EEPROM. Per usarli, decommenta la riga che vuoi usare.

// Leggi dalla porta A di 6522

//const byte data = {0xA9, 0x00, 0x8D, 0x03, 0x60, 0xAD, 0x01, 0x60, 0x4C, 0x05, 0x90, 0x00};

Il programma mostra un dump della memoria al termine. La parte del programma seguente ti dà il pieno controllo di ciò che vuoi scrivere o cancellare, imposta $FFFC e $FFFD e quindi visualizza il contenuto di un determinato intervallo. Basta rimuovere il commento o modificare i parametri come richiesto. Gli indirizzi possono essere inseriti anche in formato decimale.

// cancella EEPROM(422, 930, 0x41); // Usa per cancellare tutta o parte della EEPROM - inizio, fine, byte

Serial.println("Programmazione EEPROM"); quantità = program_numeric_data(0x1000); writeEEPROM(0x7ffc, 0x00); // Imposta $FFFC per 6502 writeEEPROM(0x7ffd, 0x90); // Imposta $FFFD per 6502 //writeEEPROM(0x1000, 0xA9); // Scrive 1 byte di dati Serial.println(" done"); String outline = " Scritto " + (Stringa)importo + " byte"; Serial.println(schema); Serial.println("Lettura EEPROM"); printContents(0x0000, 0x112f); // Imposta l'intervallo per visualizzare printContents(0x7ff0, 0x7fff); // Legge gli ultimi 16 byte su EEPROM

Un output abbreviato del programma è sopra.

Passaggio 5: esecuzione del 6502 dalla EEPROM

La EEPROM programmata può ora essere inserita nella sua scheda e questa si collega alla scheda principale 6502 che si collega alla MEGA. Le foto della vista laterale e dall'alto sopra mostrano come tutto si incastra.

Il 6502 può ora leggere il vettore di avvio da $FFFC e $FFFD (che è $9000) e quindi passare al programma che è memorizzato lì. Il MEGA sta ancora fornendo il segnale di clock e il suo programma deve essere modificato per fornire solo il segnale di clock e monitorare il 6502. Viene fornito un programma modificato per farlo.

La foto in esecuzione mostra questo programma in esecuzione.

9000 LDA #$00 A9 00

9002 STA $6003 8D 03 60 9005 LDA #$FF A9 FF 9007 STA $6002 8D 02 60 900A LDA $6001 AD 01 60 900D STA $6000 8D 00 60 9010 EOR #$FF 49 FF 9012 STA $4100 8D 00 41 9015 JMP $900A 4C 0A 90

Gli switch sono collegati alla porta A e il programma visualizza il valore che sta leggendo sulla porta B e sul 74HC373 (che al momento è oscurato). gli interruttori sono collegati a massa e i led sono collegati a 5v. L'EOR #$FF corregge il problema del latch e della porta B che mostrano modelli diversi capovolgendo i bit prima di scrivere sul latch.

Passaggio 6: segnale orario esterno

Se un segnale di clock viene applicato al pin nella parte superiore della scheda, il 6502 può ora funzionare indipendentemente dal MEGA. Ovviamente necessita anche di alimentazione. Ho sperimentato diversi clock e ho persino eseguito il 6502 a 1MHz con un oscillatore a cristallo. Il MEGA non può tenere il passo con velocità più elevate, quindi deve essere rimosso.

Ho anche provato l'output da un timer 555 ma non funziona. Penso che potrebbe essere perché non è un'onda quadra? Quando è stato collegato a una delle uscite del CD4017, ha pilotato il 6502. Ho collegato uno dei kit sopra per cercare di ottenere un segnale di clock.

Sto ancora esaminando diversi metodi per ottenere un segnale di clock.

Passaggio 7: conclusione

Ho mostrato come costruire alcuni circuiti complessi e far funzionare un "computer" molto semplice con una quantità minima di parti. Certo, il computer non può fare molto al momento o è probabile che lo faccia in futuro.

All'inizio degli anni '80, con il mio VIC20, mi meravigliavo della fantastica macchina e non avevo la prima idea di come iniziare a montarne una. I tempi sono andati avanti e anche la tecnologia, ma è comunque bello tornare alle origini ed essere orgogliosi di qualcosa che hai costruito da zero.

Per sviluppare ulteriormente questo computer, ho intenzione di mettere 2k di SRAM da $ 0000 a $ 2047 e aggiungere un oscillatore da 1 MHz. Probabilmente aggiungerò qualcosa come un CD4040 (contatore/divisore di ondulazione binaria a 12 stadi) in modo da poter attingere a diverse velocità di clock.

Potrebbe anche aggiungere un display LCD per fornire output di testo piuttosto che solo luci lampeggianti. Anche il programmatore EEPROM dovrà essere modificato per gestire i programmi più grandi necessari per eseguire un display LCD.

Anche se il MEGA sta diventando superfluo per il funzionamento del 6502, è comunque utile per il debug del codice macchina. Come tutti sanno, il codice macchina contiene sempre dei bug!