W65C02 8-bitarsdator med Arduino Mega-emulering

En fristående 8-bitarsdator baserad på mikroprocessorn W65C02S. Arduino Mega 2560 används för att simulera minne och klockcykler i det första utvecklingsskedet.

Detta är en hembyggd 8-bitarsdator där en klassisk W65C02S-mikroprocessor får liv utan att en enda rad maskinkod behöver brännas in i ett EEPROM. Istället agerar en Arduino Mega 2560 som datorns minne och klocka – den läser processorns adressbuss, serverar instruktioner från sitt interna RAM, och fångar upp allt som CPU:n skriver.

Eftersom W65C02S är en CMOS-krets med helt statisk kärna kan klockan stoppas helt utan att processorn glömmer sitt tillstånd. Detta utnyttjas fullt ut: två fysiska knappar låter dig stega igenom programmet – antingen en enskild klockcykel i taget eller en hel instruktion åt gången. En lysdiod pulserar i takt med klockan och en LCD-display visar adressbuss och instruktion i realtid – perfekt för att förstå vad som faktiskt händer inuti en 8-bitars CPU.

Nedan hittar du ett komplett kopplingsschema, detaljerade kopplingstabeller och en stegvis byggplan som tar dig från strömmatning till en fullt interaktiv testbänk.

1. Kopplingsschema

Komplett kopplingsschema i 5 blad — ritat i ren ingenjörsstil med nätetiketter, titelruta och korrekta komponentsymboler. Inspirerat av Ben Eaters klassiska datorbyggen.

📐 Öppna kopplingsschema (5 blad)

Blad 1: Översikt · Blad 2: Adressbuss A0–A15 · Blad 3: Databuss D0–D7 · Blad 4: Kontroll & Ström · Blad 5: I/O-enheter

2. Komponenter

AntalKomponent
1W65C02S (DIP-40 mikroprocessor)
1Arduino Mega 2560 (Plus eller standard)
1LCD1602 med I2C/IIC-backpack
1Lysdiod (röd eller gul för klockindikering)
1220 Ω eller 330 Ω motstånd (strömbegränsning för klock-LED)
53,3 kΩ eller 10 kΩ motstånd (pull-up för CPU-kontrollpinnar)
8100 Ω motstånd (seriemotstånd på databussen)
8Lysdioder (röda, för visuell avläsning av databussen D0–D7)
8220 Ω motstånd (strömbegränsning för databuss-LED:arna)
1104 (100 nF) keramisk kondensator (avkoppling för CPU)
110 µF eller 47 µF elektrolytisk kondensator (strömstabilisering)
2Taktila tryckknappar (för stegning av klocka och instruktioner)
Kopplingsdäck (breadboards) och solid kopplingstråd

3. Kopplingstabeller

Ström och kontrollpinnar

W65C02 (Pin)SignalKopplas tillKommentar
Pin 8VDDArduino 5VStrömmatning
Pin 21GNDArduino GNDGemensam jord
Pin 36PHI2Arduino D2Klockinmatning (genereras av Arduinon)
Pin 34R/WArduino D3Read/Write (Hög = Läs, Låg = Skriv)
Pin 40/RESETArduino D4Styrs av Arduinon för kontrollerad omstart
Pin 7SYNCArduino D7Opcode fetch-indikering (hög vid instruktionshämtning)

Kritiska fasta anslutningar (Pull-up)

Följande pinnar på W65C02 måste dras till 5V via ett 3,3 kΩ eller 10 kΩ motstånd:

Filter och avkoppling

Adressbuss (A0–A15)

W65C02 (Pin)AdressArduino MegaHårdvaruport
Pin 9–16A0 – A7A8 till A15PORTK (låga adressblocket)
Pin 17–20 & 22–25A8 – A15A0 till A7PORTF (höga adressblocket)

Databuss (D0–D7)

Varning – busskollision! När CPU:n skriver data (R/W låg) måste Arduinons PORTA-pinnar vara satta som INPUT (högimpedans) innan PHI2 går hög. Seriemotstånden (100 Ω) begränsar strömmen vid en oavsiktlig kollision.
W65C02 (Pin)DataArduino MegaHårdvaruport
Pin 33D0Digital 22 + 100 ΩPORTA Bit 0
Pin 32D1Digital 23 + 100 ΩPORTA Bit 1
Pin 31D2Digital 24 + 100 ΩPORTA Bit 2
Pin 30D3Digital 25 + 100 ΩPORTA Bit 3
Pin 29D4Digital 26 + 100 ΩPORTA Bit 4
Pin 28D5Digital 27 + 100 ΩPORTA Bit 5
Pin 27D6Digital 28 + 100 ΩPORTA Bit 6
Pin 26D7Digital 29 + 100 ΩPORTA Bit 7

Databuss-LED:ar — visuell avläsning av D0–D7

Åtta lysdioder (med 220 Ω motstånd) kopplas mellan varje datalinje och GND, på CPU-sidan av 100 Ω-seriemotstånden. När en bit är hög (logisk 1) tänds motsvarande LED. Du kan läsa av hela databussens 8-bitarsvärde binärt i realtid.

DatalinjeLED + motståndAnslutning
D0LED0 + 220 ΩMellan D0 (CPU pin 33) och GND
D1LED1 + 220 ΩMellan D1 (CPU pin 32) och GND
D2LED2 + 220 ΩMellan D2 (CPU pin 31) och GND
D3LED3 + 220 ΩMellan D3 (CPU pin 30) och GND
D4LED4 + 220 ΩMellan D4 (CPU pin 29) och GND
D5LED5 + 220 ΩMellan D5 (CPU pin 28) och GND
D6LED6 + 220 ΩMellan D6 (CPU pin 27) och GND
D7LED7 + 220 ΩMellan D7 (CPU pin 26) och GND

Klockindikering (LED)

Klocklinje (Arduino D2 / CPU Pin 36)
  │
  └───[ 220 Ω eller 330 Ω motstånd ]───►│ (Lysdiod) ───┐
                                                       │
                                                  Arduino GND

Tvåraders display (LCD1602 I2C)

De flesta LCD1602 I2C-backpackar använder adress 0x27 eller 0x3F. Kör en I2C-skanner på Arduinon för att verifiera adressen.

LCD1602 I2C PinKopplas tillKommentar
GNDArduino GNDJord
VCCArduino 5VStrömmatning (+5V)
SDAArduino Pin 20 (SDA)Dataöverföring
SCLArduino Pin 21 (SCL)Klocksynkronisering för I2C

Knappar för manuell stegning

Knapparna använder Arduinons interna pull-up-motstånd och kopplas direkt mellan pinne och jord.

Arduino D5 (Klocksteg) -------[ Knapp ]------- Arduino GND
Arduino D6 (Instruktionssteg) -[ Knapp ]------- Arduino GND
Avstudsning (debounce): Mekaniska knappar studsar vid tryck. Avstudsning måste hanteras i mjukvaran (t.ex. 50 ms spärrtid).

4. Stegvis bygg- och testplan

Steg 1: Strömmatning och grundläggande klocka

  1. Placera W65C02 på kopplingsdäcket.
  2. Koppla 5V och GND från Arduinon till strömskenorna. Montera den elektrolytiska kondensatorn över skenorna.
  3. Koppla Pin 8 (VDD) och Pin 21 (GND). Sätt den keramiska 104-kondensatorn direkt över chippets strömpinnar.
  4. Koppla alla 5 pull-up-motstånd (pinnar 2, 4, 6, 35, 38) till 5V.
  5. Koppla klockan från Arduino D2 till CPU Pin 36 samt LED med motstånd.
  6. Test: Ladda upp ett blink-skript som slår på/av Pin D2 med 1 Hz. Kontrollera att lysdioden blinkar.

Steg 2: Adressbuss och reset-sekvens

  1. Koppla ur strömmen. Koppla in alla 16 adresslinjer (A0–A15) enligt tabellen.
  2. Koppla Arduino Pin D4 till CPU Pin 40 (/RESET).
  3. Skriv ett Arduino-skript som drar /RESET låg i 5 klockcykler vid uppstart, sedan hög.
  4. Test: Verifiera i serieövervakaren att processorn läser från $FFFC och $FFFD (reset-vektorn).

Steg 3: Databuss och minnesemulering

  1. Koppla in de 8 datalinjerna (D0–D7) mellan CPU:n och Arduino Pin D22–D29 via 100 Ω seriemotstånd.
  2. Koppla R/W (CPU Pin 34) till Arduino Pin D3.
  3. Uppdatera Arduino-koden: Skapa en minnes-array. Lägg startadressen (t.ex. $8000) på $FFFC/$FFFD. Lägg en NOP-instruktion ($EA) eller en loop på $8000.
  4. Konfigurera PORTA som utgångar vid läsning (R/W hög) och som ingångar vid skrivning (R/W låg).
  5. Test: Verifiera att processorn läser startvektorn, hoppar till $8000 och exekverar.

Steg 4: Interaktiv stegning och LCD-display

  1. Koppla in knapparna till Arduino Pin D5 och D6 samt SYNC-pinnen till Arduino D7.
  2. Koppla in LCD1602 via I2C till Arduino Pin 20 och 21.
  3. Uppdatera koden så att klockan väntar på knapptryckningar.
  4. Lägg till kod för att formatera adress- och databussvärden till hexadecimal text på LCD-displayen.
  5. Test: Du kan nu trycka på klockknappen för att stega processorn manuellt. Skärmen visar adress och instruktion i realtid.