Now the firmware or the operating system or whatever is normally on it is loaded through the adapter and the cable. Now you will ask yourself, why this effort.
Actually quite simple. Error made? Somewhere still something must be changed? Apart from the fact that this constant back and forth certainly does not have a positive effect on the components, it always takes a few minutes. So you can test a new firmware at the push of a button without changing anything.
And thanks to external reset lines, the respective device or CPU is automatically reset. But even just testing different firmware in an old computer can be done quite easily. If you want to rebuild the original, you can find plenty of information and ordering options on the above-mentioned website. The entire project can also be found on GitHub. So I made the whole thing a little smaller. For this SMD components were used. Furthermore I integrated the used Arduino directly on the board.
This is how the following board came out: The board here is just lying on a Commodore As you can see, this variant is much smaller and more compact with just under 9x5cm. Technically it does not differ from the original. Only the ATmegap is replaced by a ATmega32u4. The price of both is about the same. The version shown above is my first running prototype. In total this looks like this: The ribbon cable ends in a DIL28 adapter. As you may notice, there is no USB cable connected, but the board is still running.
Practical if you work on a larger computer and the PC is too far away. As you can see on the picture above, one of the cables of the ribbon cable is connected with a clip to the CPU. At the used here PIN 40 is the reset line. And the emulator is connected to it. When a new image is loaded, this automatically resets the floppy. Both variants are provided for the reset, i.
Description On my board are in the main 5 components. That is on the one hand the ATmega32u4. There comes the original firmware on it, which is also used on the original board. On the ATmega there is a corresponding bootloader, so that the board can pretend to be an Arduino Micro. In China you can buy it for just under 1,- Euro per piece. Here in Germany it is between 5,- and 10,- Euro. Then there is the RAM chip. This is actually much too big for this board. Either you take 2x kBit, like on the original board, or you take a much too big one and use only kBit.
With 3,- Euro per RAM chip you can get over this.
Using an Arduino Uno to program EPROMs
The entire process is extremely slow and has to be repeated every time you want to make even a small one bit change! Once you finish testing you can replace the emulator with EPROM chip programmed with the final version of your code. So I was motivated to create something similar to ERMAX , but based on modern microcontroller platform, open source, cross platform control software and free of annoying limitations of my old device more on that later.
The software that controls the emulator is written in Python 3. Schematic diagram of the emulator. Well know and supported in Arduino IDE. In fact, I had quite a few of the memory ICs spare, plus you can still find this type of memory on Digikey so I decided to stick to those. Details on how to build one of those are also in the GitHub repository. This is an unusual configuration, but it allows us to simplify the main routine that shifts the data into the chips, the main loop only needs to do 8 iterations to load all 24 bits 8 of data and 16 of address.
Imagine a situation, where you would like to emulate for example a EPROM, you want to make sure address lines A13, A14 and A15 are ignored in that case, regardless of how they are connected externally to the emulator. This new design fixes the issue. Not an issue when you are writing and debugging your code.
D5 prevents powering the target from the Arduino, the fuse limits the current drawn from the target if something goes wrong. There is some voltage drop on both of those elements. In certain situations you may want to skip, or bypass those. You will need to build the hardware first. For that you should start by getting the PCB. Other components in the cart are at quantities needed to build a single emulator — but remember you will get 5 PCBs from your order, so might be worth increasing the quantities to build 2 or more :.
Also, since you are already paying for the delivery, increase the numbers on some of the common components one can never have enough decoupling nF capacitors.
I recorded a quick introduction video that covers basics of usage. I built the first 5 prototypes and later discovered an issue with the PCB layout, one of the shift registers U11 was getting onto a CMOS latch-up state, even though I had a few bypass caps around the PCB, I was still occasionally getting the issues. I improved the PCB design, re-routed some of the power connections and repositioned some of the components, and released as v1.
In the most recent change, I moved from using two smaller SRAM memory chips to using a single larger one. Firmware and software stays the same for both versions. If you found this helpful and you like the work I do, why not buy me a coffee, thanks!
DIY EEPROM programmer
Not an issue when you are writing and debugging your code. D5 prevents powering the target from the Arduino, the fuse limits the current drawn from the target if something goes wrong.
There is some voltage drop on both of those elements. In certain situations you may want to skip, or bypass those.
Emulate EPROM instead of burning
You will need to build the hardware first. For that you should start by getting the PCB. Other components in the cart are at quantities needed to build a single emulator — but remember you will get 5 PCBs from your order, so might be worth increasing the quantities to build 2 or more :.
Also, since you are already paying for the delivery, increase the numbers on some of the common components one can never have enough decoupling nF capacitors. Step one: Find your ROMs. They look like this: EPROMs are erased by exposing the chip to ultraviolet light, which is why they have that distinctive quartz window you see above. This is so the data in the ROMs can be easily written or updated after the circuit boards are manufactured, and so devices can be patched or upgraded in the field.
Of course, it also makes them easy for us to remove!
27C512 512K 150ns CMOS EPROM – Datasheet
Because they are manufactured in large quantities, they are usually silkscreened with a custom part number, and because sockets are expensive in mass-produced hardware, the chips are often soldered directly into the board. Be aware that schematics are also often haunted. Masked ROMs are clearly bad juju. Step two: Prepare and remove the chip. Electrical tape works well for this.
Cut a small piece and make sure the entire window is covered, as below. You can easily pry a chip out of its socket with a flathead screwdriver. Be gentle and patient! Software on the Arduino The Arduino is programmed to listen on the serial port and accept commands. And it accepts blocks of up to sixteen bytes to write, in the same format. Just copy and paste it into a sketch in the Arduino editor.
You should see the first 16 bytes sent to you in hex, with a checksum. I put off writing a utility for ages — instead resorting to turning a ROM image into a C array, and then embedding that in my Arduino project. Putting-off writing a reasonable toolset is just making your life difficult for yourself.
And then, when I finally got around to it … it turns out that accessing the serial port under Windows is really not that difficult!