65C02-Tool VS 8-bit-CPU

If you have an Arduino Mega, I highly recommend this one: https://github.com/Nectivio/65C02-Tool

Granted, this exists (and partly inspired my current program), but I wanted something I could actually understand how it works and be able to fix it, should the need arise. Direct port manipulation is still voodoo witchcraft to me and looks like it is more trouble than it is worth, at least for my purposes. I know it's much faster, but I'm planning on stepping through clock cycles one by one for the majority of the time, so I'm willing to sacrifice speed for clarity.

If you have an Arduino mega, I made a tool here that, (among many other things,) can be used as a eeprom programmer.

Just checked. There is a specific paragraph in the git repository discussing about "Enabling or Disabling the Software Data Protection (SDP) of an AT28C256 EEPROM"

This is the tool: https://github.com/Nectivio/65C02-Tool

While browsing this reddit, I found the 65C02-Tool (reddit, Github) written by user u/nectivio being what I was looking for! It features a very robust Monitor, clock generator / measurement, Peek, Poke, EEPROM Read and Write *from Arduino serial monitor UI* (can write from a single-byte up to a 64 bytes IIRC). Icing on the cake: you can program the whole EEPROM in one shot without removing it from the circuit!

I posted a tool here for the Arduino mega that can (among other things) program the eeprom.

I've created a free interactive tool for debugging the 6502 computer with an Arduino Mega.

I later built a version that can read/store a full byte (2 key-presses) and present it to a CPU.

My code is available here, it has evolved since then and I actually abandoned the in-Arduino emulator later (re-wrote that part in Verilog). So it is best viewed at historical tag "emulator_1.0" in the repository.

Mark your data using PROGMEM directive (see example).

My project sources are on GitHub. Theres a lot going on, and it is probably a bit over-engineered. You can start by taking a look at Arduino sketch and client library.

I wrote an emulator for mine, then extended it to test out different designs, before building on hardware. The approach was a bit different, as I started by implementing 74-series logic chips. Then "wired" them together into CPU modules. This way emulator becomes a testable representation of what's possible using logic chips.

I wrote an emulator for my CPU in Verilog. Actually, I made it to test out various aspects before building, real hardware has not yet cached up with it.

The source code was in Python. I was able to debug it using Arduino-based adapter and (by using some "magic") translate into machine code binary. Since then I've switched to CustomAsm for code compilation and have other means to debug (emulator and debugger tool).

If you looking for examples: here's how you create the array (code generated using xxd -i command), and here's how you use the array.

In the beginning of program (on EEPROM), there's a small piece of code that reads all 256 address locations and writes them back. In BOOT mode, this effectively copies contents from ROM into RAM.

Complicated? Perhaps, but do not underestimate the power of automated testing! When you can run a couple dozen tests in just few seconds, at any time, it really gives you confidence about the system. Obviously, one should spend time writing the tests, but it pays back rather quickly.