Author: hbradmin

Posted on

The Curious Case of the ETX Amiga 2000: A Debugging Odyssey

What you see on the bench now is a working ETX-form Amiga 2000—but to understand how we got here, we need to rewind a bit. This strange little tale really begins when I picked up the board from Cathers in Cambridge.

The First Setup

Fresh back from Cambridge, I wired it up with a ROM switcher—technically meant for an A600. Not the perfect fit, I’ll admit, but it had all the Kickstart images I needed to investigate the problem for myself. That issue? Something was seriously wrong with the display—especially under Kickstart 2.0 or higher. The colors were just… off. Glitching, corruption, odd effects during animation. It was like looking at a surrealist painting in the middle of Workbench.

Weirdly, Kickstart 1.3 ran fine. The game Grind even loaded up with no trouble—until the screen went totally bonkers once the game actually started.

The Investigation Begins

My first theory: maybe the problem lay in the blitz signal between Agnus and Gary. On the A500 and 500 Plus, this signal goes directly from Agnus to Gary. If that connection isn’t solid, all sorts of weirdness can ensue. I’ve seen it before.

But here’s the twist—in the A2000, there’s extra logic on that line, and it’s designed to ignore the blitz signal if the ROM is enabled. So I decided to bypass that logic and wire the signal directly, A500-style. I pulled out the relevant IC and added a jumper across the pins.

At first, things looked promising. The display behaved better. A quick three-finger salute (Ctrl-Amiga-Amiga) and… nope. The color corruption was still there. The glitching was better, sure, but the issue hadn’t gone away.

So, I reversed course, put the original chip back, and moved on.

Deeper Into the Rabbit Hole

Cathers hadn’t tried swapping out the CPU, so I did. No change.

Next up: the Agnus socket. Maybe it wasn’t making proper contact? With Cathers’ blessing, I removed the old socket and installed a new one—black, like the others, for a clean, uniform aesthetic.

Still nothing.

And yet, all the RAM passed perfectly in DiagROM and Amiga Test Kit. Aside from a few subtle red-line glitches behind the font, everything looked fine. Which, frankly, made no sense. How were these tests passing when the machine clearly wasn’t well?

At this point, I was out of ideas.

The Community Comes Through

So, I did what any self-respecting YouTuber would do: I asked you for help. And wow, did you come through. The comments and suggestions poured in—thank you!

One comment, in particular, stood out. It pointed to the voltage level of a chip. The board was set to 3.3V, as per the BOM, but maybe—just maybe—that wasn’t right.

The Fix

I swapped the 3V component for a 5V-tolerant version and updated the jumper settings accordingly.

And then… success! Well, almost.

With just serial output connected, I noticed that the RAM wasn’t showing up at first—another power issue, but now I knew where to look. A bit more probing revealed an address error: the same location was being read multiple times despite different addresses being sent.

Reflowing for Victory

Time to bring out the hot air and flux. I reflowed all the solder joints, just to be sure every pad was properly connected.

And that, my friends, was the magic bullet.

Running the tests again—everything passed. Clean. Sharp. Glitch-free.

Kickstart 1.3 loaded Grind without a hitch. Kickstart 2.0 and 3.2? Perfect. The colors were bang-on. The glitches were gone. The ETX A2000 was finally behaving itself.

Wrapping Up

Sometimes you reach a point in a project where nothing makes sense. You run out of leads. The logic doesn’t add up. But that’s when you double down. You reflow the joints, dig deeper into documentation, and—most importantly—you ask for help.

Thanks again to everyone who contributed.

Posted on

A600 Upgrades Continue

After completing the restoration of my Amiga 600, I found myself craving a deeper challenge. Sure, I could’ve gone all out with accelerators and high-end mods, but that’s expensive, and honestly, I wasn’t looking for overkill. What I really wanted was a compact machine that stayed true to its roots while still offering a touch of modern convenience—perfect for playing classic games.

Aesthetic Masterpiece

Externally, the A600 is now a thing of beauty. It’s got a two-tone paint job with a gunmetal gray top and a pearlescent candy orange bottom. If I’m being honest, it’s probably one of the nicest case customizations I’ve ever done. But as striking as it looks, internally, it was still just a stock A600. That had to change.

Exploring the 68010 Upgrade

I’d recently come across some fascinating discussions by Linux Jedi about the performance differences between the 68,000 and the 68010 processors. While the 68010 is often dismissed as offering negligible improvements, it does have some notable benefits. For example, it can exit WHDLoad sessions without rebooting the entire system and handles certain Bitmap Brothers games with noticeably better performance.

Inspired, I decided to create my own solution: an adapter to fit a 68010 in a DIP (dual in-line package) format into the PLCC socket of the A600. The process wasn’t overly complicated but involved designing a two-layer PCB to route the address, data, and control lines between the sockets. The finished adapter, which I’ve cheekily named “Well, I’ll Be Dipped,” even features capacitors for decoupling—and as a sneaky bonus, they also act as mechanical standoffs.

Assembling the board was straightforward, and once it was ready, fitting it into the Amiga 600 was a breeze. I even added holes to align with the hard drive mounting points for a secure fit. It’s these small touches that make the project feel complete.

Custom ROM Switcher

Next, I turned my attention to a ROM switcher. My A500 ROM switcher wouldn’t fit in the A600’s compact case, so I designed a new one that relocated the ROM further back in the case. While testing, I used a socket for easy debugging, but for the final version, I soldered the ROM directly to the board to ensure a perfect fit beneath the keyboard.

But what’s a ROM switcher without accessible switches? I needed a way to mount them without drilling into the pristine case. Since I wasn’t planning to use the PCMCIA slot, I repurposed it as a mounting point. My initial plan involved using a piece of plastic, but that proved too brittle for drilling. Then inspiration struck: why not use an old PCB? With a bit of ingenuity and some repurposing, I had the perfect solution.

The Final Build

With everything assembled and back in the case, the A600 is now both beautiful and functional. It’s ready for display and gaming, with custom upgrades that feel right at home in the compact design.

Links

Linux Jedi 000 vs 010

Linux Jedi Blog: https://linuxjedi.co.uk/the-hidden-power-of-the-68010/

The Inspiration for the adaptor: https://www.exxosforum.co.uk/forum/viewtopic.php?f=76&t=3226  

@ReesRambles  Coverage of the event

The A600 Build (Sorry about the sound)

PCBWay Projects

Well I’ll be DIPped: https://www.pcbway.com/project/shareproject/Amiga_600_DIP_64_CPU_Adaptor_I_ll_be_DIPped_1f1a8876.html

ROM Switch: https://www.pcbway.com/project/shareproject/Simple_Amiga_600_ROM_relocator_and_switcher_751aa9b8.html

Posted on

BlueSCSI Setup for Adaptec EZ-SCSI 4 in DOS

https://www.youtube.com/watch?v=4k1i_IFYy0U

Building a Retro PC with BlueSCSI: My Journey

Hi everyone! I wanted to share my recent adventure in building a retro PC setup, complete with a BlueSCSI for storage emulation. What started as a simple idea turned into a learning experience filled with challenges, unexpected twists, and ultimately, a lot of satisfaction

The Vision

I’ve always had a soft spot for old-school PCs. After scratching my nostalgia itch with an IBM 5170, I set my sights on building a DOS gaming machine—something to relive the magic of Doom and Quake.

For this build, I used a Baby AT motherboard. While most had transitioned to ATX by the time my board was released, this one offered a rare mix of PCI, ISA, and AGP slots. My CPU of choice? A Celeron 433, perfectly capable of handling those classic games. For graphics, I couldn’t resist using an ATI Rage Pro—a card I have fond memories of from my early PC days.

The plan didn’t stop there. I wanted top-notch sound for those immersive MIDI soundtracks, so I added a PicoGUS. This little gem allows me to emulate any sound card, including the legendary Gravis Ultrasound and Sound Blaster.

Finally, I needed versatile storage, and that’s where the BlueSCSI came in. I’ve used this device before and absolutely love its ability to emulate hard drives, CD-ROMs, and even floppy drives—all from an SD card.

The BlueSCSI Setup

I hit my first snag early on when I decided to use a purple Raspberry Pi Pico clone I had lying around. These clones are cheap and cheerful, but I didn’t realize they had a completely different pinout compared to the standard Pico.

I soldered the clone to the BlueSCSI board, but when I tried flashing the firmware, it just wouldn’t work. Powering it up was fine, but I couldn’t get the Pico to boot into firmware mode. After some frustrating back-and-forth, I unsoldered it, flashed the firmware directly, and soldered it back on—still no luck.

That’s when I finally noticed the problem. The clone has extra GPIO pins and fewer ground connections, which caused one of the pins to ground permanently. No wonder it wasn’t working! In the end, I reverted to a trusty Pico W, and everything worked flawlessly.

Configuring the BlueSCSI

With the hardware in place, I set up the BlueSCSI SD card. The storage structure is pretty straightforward:

  • CD1 folder for CD-ROM images.
  • FD2 folder for floppy disk images.
  • A raw hard drive image for the main storage.

I wrote a few custom batch scripts to simplify things. One script lists available CD images, another lets me switch between them, and yet another handles floppy disk swapping. I found a clever trick using Adaptec’s EZ-SCSI tools to manage virtual floppy disks.

BlueSCSI Batch filesDownload

You will need to get RMVTOOL.EXE (Removable media Tool) from EZ-SCSI 4 disk / CD (the compressed file is located on DISK 2) you can expand it to your hard disk using the below command

 expand rmvtool.ex_ C:\SCSI\RMVTOOL.EXE

All this works great, but only with Adaptec cards, which is a bit limiting.

Testing the Setup

With everything configured, it was time for the fun part—testing! I loaded up Discworld to check the sound and Doom to see how well the system performed. Both worked beautifully, and hearing those MIDI tracks through the PicoGUS and my Yamaha drum machine was incredibly satisfying.

The BlueSCSI performed like a champ. I could quickly switch between disk images, and the storage emulation was seamless. There was a small quirk with file ordering (images didn’t seem to appear alphabetically), but that’s a minor nitpick for such a versatile device.

What’s Next?

Now that the internals are done, it’s time to tackle the case. I’m going for a steampunk-inspired look, complete with a wooden bezel crafted by my friend Mike. He’s a skilled woodworker and has agreed to help me bring my vision to life. But that’s a story for another day!

Shoutouts and Thanks

A huge thanks to Derek at Flame Lily, the UK distributor for PicoGUS and BlueSCSI. His excellent service made this project so much easier. If you’re into retro computing, definitely check out Flame Lily—you won’t regret it. Flamelily Shop

Posted on

My Journey Modding the VC9900 with GBS Control for HDMI Output

I’ve always loved retro tech, but sometimes working with older video equipment can be… frustrating. That’s why the GBS Control project caught my attention—it takes an affordable video scaler and transforms it into a powerful tool for retro enthusiasts like me. So, when I decided to tackle a long-forgotten V9900 scaler from my project pile, I knew GBS Control was the way to go.

The Problem with Stock Scalers

The GBS 8200, a budget-friendly scaler from the arcade and retro console world, is functional but far from perfect. Latency issues and subpar video quality made it less than ideal for anyone serious about retro displays. Enter GBS Control, an open-source firmware upgrade that changes everything. With just a microcontroller like the ESP8266 or ESP32, you can unlock low latency, improved color accuracy, scan lines, and even web-based remote control.

Why the V9900?

The V9900 isn’t officially supported on the GBS Control wiki, but it seemed close enough to the GBS 8200 to give it a shot. My VC9900 had been sitting around for ages after an initial failed attempt to use it, so I figured it was time to see if I could make it work. Spoiler: it did, and the results are amazing.

Base instructions GBS Control Wiki

The Build Begins

First, I needed an ESP8266. I found one on eBay for an absurdly cheap £3, shipping included. When it arrived, it looked fine despite some shipping damage—nothing a little pin-straightening couldn’t fix.

NodeMCU ESP8266 UK, NodeMCU ESP8266 USA

The first step, according to the GBS Control wiki, was to bypass the RGB input potentiometers. While the instructions suggested a destructive approach, I opted for a cleaner solution by removing the pots and replacing them with simple links, dressed up with heat shrink tubing for a neater finish.

Next, I wired up the debug pin using Dupont cables, which are perfect for temporary connections. The debug signal is sourced from pin 30 of the V9900’s IC6 chip, the MTV230 microcontroller. Once wired, the ESP8266 takes over, unlocking full control of the scaler’s video processor.

Setting Up the ESP8266

Connecting the ESP8266 was straightforward using the diagrams and instructions from the GBS Control wiki. I made custom cables for power and data, skipping optional add-ons like clock generators and OLED displays for now. I wanted to confirm everything worked before adding complexity.

You will also need to close the jumper to put the MTV230 in it’s place, jumper is located next to the two headers to the side of IC6.

The colored blocks, boxed in pink, on the pin out diagram below reflect the wiring and colors I used in my build. For clarity I use White for Vin and Grey for ground connecting to the 5v header.

Installing the GBS Control software was simple as long as I followed the instructions carefully. With everything connected, I ran initial tests using my Amiga 500. Cycling through ROMs and booting up a few games showed promising results—beautiful, crisp visuals with none of the latency issues I’d experienced before.

I powered the board with a Zip-Drive 5v supply, but any regulated 5v supply with a Centre positive barrel jack should work fine.

GBS Control software install

Making It Practical

While the setup worked, it wasn’t practical—just two boards loosely connected by wires. To fix this, I built a mounting board from leftover plastic from another project (thanks, A2000 undertray!). After marking, cutting, and drilling, I mounted the V9900 and ESP8266 securely.

The result? A compact, reliable solution that handles retro video signals beautifully and outputs them via HDMI. All for less than £25 ($30)—a fraction of the cost of high-end alternatives like the OSSC or RetroTINK.

The Results

The difference is night and day. My repair footage now looks professional, and retro games come to life on modern displays. This build is perfect for anyone looking to upgrade their retro experience on a budget.

Posted on

Flashing PCIe X1900GT for G5 Mac

I did this to install MorphOS on a PCIe G5 PowerMac

Required Hardware

  • Mac-specific 6-pin PCIe power cable
  • Radeon X1900GT 256Mb, these are getting rarer but do come up on eBay and Thrift shops
  • PC setup with PCIe Slot and power (Capable of booting from USB)
  • USB Drive ton install a DOS image on

Flashing Steps

  • Setup a USB device to boot the PC from with MS DOS 6.2.2 (FreeDOS doesn’t work)  balenaEtcher can be used to restore an image of onto a spare USB Drive.

MS-DOS Boot Disk Download

Click “Show older versions”

4.07 (Versions not in order)

  • Create an ATI directory/folder in the root of the DOS USB Drive
  • Move ‘atiflash.exe‘ to the ATI directory on your prepared DOS USB drive. Rename ‘Radeon X1900 GT rev 109.rom‘ to ‘x1900GT.rom‘, and move that to the same place.
I have a pre made disk image here Dos6.22 ATI.img
  • Install X1900GT into the PCIe of the x86 PC. The X1900 GT itself can provide the video output from here on; using an additional PCI graphics card is not necessary. If the PC’s power supply does not have a 6-pin PCIe power cable available, use an adaptor; these are available from the common online stores!
  • Plug the DOS USB drive in, and boot from it.

at the prompt type

cd ATI

then to check the contents type

dir

You should see ‘X1900GT.ROM’ and ‘ATIFLASH.EXE’ listed.

We need to know the adaptor number, type

atiflash -i 

note the adapter number of the installed X1900 GT, which is identifiable by the ‘R580+’ tag in the middle column.

Usually, the adapter number to the far left of the ‘R580+’ will read ‘0’, provided the card was installed to the PC’s first (or only) PCIe x16 slot.

Note In the following steps it assumes the adaptor number to be ‘0’, replace the 0 with the correct adaptor number if it differs.

Optional If you want to backup the X1900’s original ROM to the current directory, type 

atiflash -s 0 x19back.rom

To flash the card type 

atiflash -p -f 0 x1900GT.rom
  • -p tells atiflash to program the card’s ROM
  • -f tells it to force the program
  • 0 tells it which adapter to program (change this if your adaptor number differs)
  • x1900GT.rom is the ROM it should use to program the card with

Your screen may flicker for a couple of seconds. Afterward, it should tell you that the flash was successful, at which point use the power down the machine.

Remove the newly-flashed X1900 GT from the PC, and install it into the G5.

If all went well, the Apple logo should come up, and you should now be in Mac OS X. Verify the GPU information via Graphics / Displays in System Profiler, and rejoice!

You have successfully flashed a graphics card completely on your own, and now possess a Radeon X1900 GT PPC Mac Edition.

Cookie Consent Banner by Real Cookie Banner