amaiorano::blog

Lava RGB

2025-09-03T00:00:00+00:00

Back in 2021, I installed an NESRGB on a front loader, which has been working great. For years now, NESRGB was pretty much the only mod available to get RGB out of the NES; but recently, a new mod known as Lava RGB came on the scene from a company in China. I bought one, and in this post I go over how I installed it on another front loader.

I bought the Lava RGB mod off AliExpress from Lava FC Store, specifically from this listing (although I suspect these links will not survive very long). The “color” I bought is the one named “NES senior VER 2.0”, which includes both the mod board itself, along with a replacement power A/V module. Version 2.0 adds a bunch of new features on top of the previous version 1.2, such as 24-bit color output, 8 integrated palettes, the ability to reset the console and change palettes using controller 1, an OSD that displays the palette name when switching them, and a micro usb port that allows for firmware upgrades in the future.

Compared to the NESRGB, Lava RGB 2.0 is definitely a worthy contender. The palette switching OSD, and ability to easily update firmware, are improvements, and I wonder if future firmware updates might add more OSD-based options. However, one thing Lava RGB does not do is process and output audio like the NESRGB. Although not a huge deal, it does mean audio needs to be tapped from the main audio output circuit. This is probably why the latest version now offers a power A/V replacement PCB which routes audio output to its Saturn-style DIN connector.

Although the power module includes a Saturn-style DIN connector, I don’t own a compatible cable, and prefer to use VGA cables. So for my install, I decided to add a SNES multiout port.

Parts

Lava RGB 2.0 mod board and power module - $81.37 CAD
Two 20 rounded pin headers - $16 CAD for ten on Amazon
SNES multiout parts (more on that later)
47K resistor for expansion audio

The Lava RGB kit took about a week to arrive, and was packaged decently well:

The Build

Prepare NES main board

Remove PPU

I picked a front loader with an NES-CPU-10 main board that was in excellent shape. I took it apart, and extracted the main board from the shell:

First order of business was to desolder the PPU:

I started by adding fresh solder, using flux to make it flow into the existing solder:

I then used my trusty desoldering pump to remove all the solder from the pins:

Using a trick I learned from Voultar, I used my finger nails to move each pin back and forth until they moved freely. For the usual more stubborn pins on the thicker ground plane, I added more solder and desoldered again until I was able to move the pins. With that, I extracted the PPU:

Remove power module

Next I needed to remove the original power module to replace it with the new one:

This can be pretty challenging, but with the right tools and technique, it’s not too bad. I started by adding flux to the four large pins that anchor the power module to the main board and use my desoldering gun to remove most of the solder:

Then I use wicking braid to remove the solder lodged around the pins. I added a little more solder and flux to the pins until I was able to wick away most of the remaining solder:

At this point, the gaps around the pins are pretty clear:

The next trick is to desolder the 5 pins visible above - but not from this side, but rather from inside the power module. This is actually necessary for properly installing the new power module that comes with the Lava RGB kit. I pried off the metal plate:

I switched tips on my desoldering gun to one with a larger pitch, and desoldered the 5 pins:

With that done, I grabbed hold of the power module with one hand, while holding the main board with the other, and rocked the power module back and forth until it came free:

We’re left with the 5 pins still attached to the main board, ready to be soldered to the new power module later:

Push main board capacitors flat

As with the NESRGB, the caps on the main board need to be pushed down flat for the Lava RGB PCB to fit:

Normally this is simply a matter of pushing the caps down while heating the vias with a soldering iron. However, as I have a bunch of NES cap kits that I ordered from Console5, I decided to replace them:

I desoldered the three caps:

And replaced them with the new ones, making sure to match the capacitance values, and ensuring the voltage rating is equal or above the original one. When placing the caps, I laid them flat before soldering them in:

Solder wires

At this point, I decided to solder the ends of the Lava RGB wire connector to the power module and to the main board:

What’s nice is that the order of the pads on the power module and on the mod board match, so it’s easy to solder the first eight wires:

I soldered the eight wires to the pads:

The remaining four wires are used to allow controller 1 to perform an in-game reset (IGR) as well as palette swapping using key combos. IGR is performed by holding Select for about 2 seconds, then pressing A; while for palette swapping, you hold Select for 2 seconds and press Up on the dpad. To make this work, the RST wire needs to be wired to the reset line on the main board (where the actual Reset button is wired to), while the CLK, DATA, and LATCH pins need to be wired to their respective pins on the player 1 controller input lines.

I put this handy image together to identify the pins to solder to:

Noting the colors of each pin, I first soldered the RST line:

Then I soldered CLK, DATA, and LATCH. Note that DATA and LATCH are not in the same order as on the Lava RGB PCB:

Power module

As already mentioned, for my install I planned to add a SNES-style multiout. Rather than grab these connections from the Lava RGB mod board itself, I decided to get them from the power module since it’s closer to where the port would be installed. For this, I used an 8 wire ribbon cable:

In retrospect, I should have made this cable longer, as I was limited to where I could place the multiout. Anyway, I soldered the cable to the power module. Conveniently, the power module PCB offers two ways to connect wires to it, pads and vias, so I used the vias for this:

Note that two of the wires, the grey and the purple, are not soldered yet. One of these will be used for 5V, and the other for audio, both of which will be wired later to the PV and PA pins of the 5 pin connector.

I also soldered a wire to GND, and soldered it to the ground plane of the main board:

At this point, I loosely positioned the PCBs to get a sense for where I was heading:

Next, I soldered the power module to the five pins coming from the main board:

And now I could solder the 5V and audio wires to PV and PA respectively:

This is what everything looked like at this point:

Mod board

Next up was installing the mod board:

As can be seen above, the kit includes two 20 square pin headers. Their official instructions expect you to solder the mod board PCB directly to the NES main board using these square pin headers, making sure to first solder the round pin socket onto the mod board itself so that the PPU can be inserted into it. The apparent advantage here is being able to swap out the PPU, but with the major disadvantage that the mod board cannot be removed from the main board, making it difficult to service the mod in the future. So instead of this, I did as is usually done with the NESRGB mod: solder the socket to the main board, and the PPU directly to the mod board. For this, I needed to either get a socket that works with the included square pin headers, or rounded pin headers - I chose the latter.

I soldered the socket to the main board, making sure to line up the notch:

I inserted the two rounded pin headers I purchased separately into the sockets, longer pins down:

Then laid the PCB over the pins, making sure to insert them into the right vias, and soldered them in place:

I carefully detached the mod board from the socket by rocking each edge back and forth. Some care has to be taken here as these rounded pins can bend and break very easily:

Before soldering the PPU to the mod board, I use my flush cutters to cut down the one set of pins that would be underneath the PPU, and then touched them up with the soldering iron. Although not strictly necessary, this allows the PPU to lay flat on the PCB:

I inserted the PPU onto the mod board, making sure to line up the notch, and soldered it in place:

Next, I soldered the wire connector to the mod board:

Now I carefully inserted the mod board back into the socket, making sure to line up the socket pins, while also routing the wires down and to the side, as there isn’t much space between the connector and the expansion port (note that we’re seeing the reflection of the wires on the edge of the expansion port):

First test

At this point, I could finally test the mod out. I hadn’t soldered the multiout yet, and I didn’t have a way to hook up the Saturn-style DIN, so I couldn’t test RGB, but I could test composite. So I loosely put everything together and composite video and audio worked perfectly:

Multiout

For the SNES multiout, I 3D printed Laser Bear’s Multiout Panel Mount Snap In Connector, and used PCBWay to print The Real Pheonix’s PCB. I also needed to order the right #2 x 1/2” screw. Alternatively, one could order the parts directly from Laser Bear and The Real Phoenix. Anyway, here are the parts:

Solder ribbon to multiout PCB

I mapped out the pins I’d need to solder to, along with the specific color wires from my ribbon cable:

I soldered the ribbon cable to the multiout PCB:

For testing, I inserted the PCB into the 3D printed frame and screwed it in:

Second test

Using an old cable I made, I gave it a quick test:

It worked! Although note that the colors aren’t quite right. It turned out that my cable was defective - green wasn’t being passed through. I later used a better cable, and all was fine.

Cut shell for multiout connector

Using the 3D printed bracket, I marked off where I would need to cut into the shell to fit the 3D printed connector:

I made sure to position the hole as to not interfere with the posts. I actually wanted to position it more to the right, but as already mentioned, I had cut the ribbon cable too short, and didn’t feel like redoing it.

Next came the most annoying part for me, since I still don’t own a proper dremel: I used a drill, flush cutters, and filing tools to cut out the hole:

Finally, after way too long, the connector fit in perfectly:

I used the 3D printed clip to hold the connector in place:

The fit was a little snug considering that raised portion inside, but thankfully it was fine:

Expansion audio

Before closing everything up, I also wanted to enable expansion audio. I decided to use Voultar’s PCB because this is what I had done for my NESRGB install. What I didn’t realize at the time was that this wasn’t necessary at all since the Lava RGB doesn’t process audio like the NESRGB. I’ll show my misteps here, and how I corrected it, but this could definitely have been simpler!

I soldered a 1K and 47K resistor to the PCB:

I positioned the PCB on pins 2 and 9 on the expansion port pins and soldered the PCB in place:

It was at this point that I tested expansion audio and realized it wasn’t working. After chatting with Toxic_Tripod0 on Discord, I realized my mistake. To enable expansion audio without NESRGB, all that’s needed is a 47K resistor between pins 3 and 9. This PCB is expressly designed to route expansion audio to the NESRGB for processing. At this point, I could have removed the PCB, but I realized I could fix this relatively easily by removing the 1K resistor, and soldering a wire from the exposed pad to pin 3:

As required, pins 3 and 9 were now connected via a 47K resistor:

I tested expansion audio, and it worked! If I were to redo this, I’d probably just connect a 47K throughole resistor between pins 3 and 9 instead.

Closing everything up

It was finally time to put everything back together:

I attached the power and controller cables to the main board:

I inserted the multiout PCB into the connector and screwed it in:

I reattached the cartridge slot to the main board, and carefully inserted the main board into the bottom shell. The new power module is only held by those 5 pins to the main board, so some care has to be taken when fitting it in place:

I decided not to put in the RF shielding as it’s not really necessary, and would pinch and possibly short the reset and controller 1 wires used for IGR and palette switching. I put in all the screws, including the ones in the posts used for the RF shielding:

I screwed on the top shell, and was finally done! Here it is in all its glory:

Final test

With everything back together, I hooked it up using my SNES2VGA with a VGA cable to my gbs-control:

Looking good in RGB:

Interestingly, the colors don’t exactly match the composite output:

Using the palette switching control (hold select + Up on dpad), I cycled through the palettes, which displays the name of the palette for a few seconds. Here are some samples:

Thoughts

I’ve been playing with this modded NES for a few days now, and it works and looks great. The Lava RGB 2.0 is definitely a worthy contender to the NESRGB, especially for the price. Although it doesn’t process audio, tapping the NES-produced audio out from the new power module works fine, and the sound is very clean.

It’s worth noting that this mod doesn’t require the new power module at all, especially in my case as I added the SNES-style multiout. However, for those who don’t want the multiout, and want a no-cut mod, this is a nice way to do it. In my case, the power module made it easier to wire up the multiout, and possibly improved the audio output as the older power modules are known to add interference to the audio signal.

I just wanted to give a quick shout out to the folks on the ConsoleMods discord, especially Toxic_Tripod0, manadream, and RobStrange for their help.

Adding “VGA Audio” to my gbs-controls

2024-02-08T00:00:00+00:00

In my recent post about my build of the SNES2VGA dongle, I mentioned how the dongle exposes the stereo audio signal in two ways: from the headphone jack, as well as via two unused pins on the VGA port, which I’m dubbing VGA audio. In this post, I’ll share how I modified my two gbs-controls to extract these audio signals from the DB15 port.

My Setup

As a reminder, I have two gbs-controls, one that I use to output HDMI to my modern LCD TV, and another that outputs YPbPr to my CRT:

Before making the SNES2VGA dongle, I used these custom cables that I made to connect my SNES and N64 to my gbs-controls:

This worked, but as I wrote last time, making these cables was fiddly, the connections weren’t great, and the audio RCA connections were starting to flake out on me recently.

With the SNES2VGA dongles, I can now use nice, solid VGA cables to pass the video signal through, but I’m forced to also use a stereo RCA cable to pass the audio signal from the dongle to my gbs-control:

The idea is to get rid of that audio cable altogether by taking advantage of the signals that’s being passed through the VGA cable.

The Build

The SNES2VGA PCB passes the left and right audio signals via pins 12 and 15, respectively. Note that this isn’t clearly explained on Jeff’s SNES2VGA page, but it appears in his other guides, such as for the PS2VGA.

So the plan is simple: tap pins 12 and 15 on the input DB15 connector, and wire them up to the left and right audio input jacks inside my custom gbs-control cases.

First I tackled the gbs-control with HDMI out:

Here you can see the two audio input jacks with ground wires (black) and signal wires (red and white) that are soldered to the HDMI output board. The goal is to splice the signals from pins 12 and 15 to these:

I took everything apart to be able to gain access to the underside of the GBS board, as there’s no other way to access pins 12 and 15:

This is the area we need to work in. Before doing anything, I made sure that both pins 12 and 15 are actually not connected to anything, including ground. Luckily they weren’t, as it’s not always possible to isolate pins like this:

I soldered two wires to the pins:

I decided to pass the wires through this hole nearby, where part of the plastic shell around the component input jacks is held:

The hole was a bit small, so I decided to snip off a bit of the plastic. This doesn’t really affect the strength of the connector, as it’s held down quite strongly by several soldered pins:

With the wires passed through, I flipped the board:

Next, I needed some ground wires for the audio signal. The DB15 input connection has ground on both pins 5 and 10, and since these are simply connected to the ground plane of the GBS board, I could tap any ground connection on the board. I decided to use these two vias where the original RGB pots used to be:

All four wires were now soldered and ready to be hooked up:

I spliced in the left (white) and right (red) signal wires together:

And then the ground wires:

Here’s a side shot:

And with that, I was done!

Testing

I gave it a test, and it worked perfectly:

Of course, you can’t hear it working in the screenshots above, so I uploaded this video to demonstrate:

I then did pretty much the same thing on my other gbs-control, the one with YPbPr outputs:

Here they are, back in their place:

Thoughts

I’m super happy with this mod! Since the GBS board leaves pin 12 and 15 disconnected, it’s easy to tap into them and take advantage of this cool feature of Jeff Chen’s VGA dongles. In his documentation, Jeff warns that the audio signal may be affected sometimes depending on the video signal passing through, but so far I haven’t noticed buzzing or anything.

It’s really convenient to be able to connect a single VGA cable from my consoles to the scalers. Now I just need to VGA-ify the rest of my consoles!

SNES2VGA

2024-02-05T00:00:00+00:00

A while ago, I made a custom cable with a SNES/N64-style multiout connector on one end, and on the other end, a VGA connector to carry the video signal, along with two RCA connectors to carry the audio signal. I use this cable to connect my SNES or N64 to my gbs-control scaler, and although it mostly works, I’ve had a few connection issues recently. I eventually stumbled upon the SNES2VGA project by Jeff Chen, which is a much better solution, and in this post, I’ll go over how I built one.

The SNES2VGA is a dongle that adapts the SNES/N64 multiout to a VGA-style female connector. This allows one to use a standard VGA cable to connect the console to the video input medium (e.g. scaler). The dongle also includes a female headphone jack so that a standard headphone wire can be used to connect the audio signal. Alternatively, the dongle also passes audio through two typically unused pins on the VGA connector, allowing only the VGA cable to be used alone if the receiving end can support it.

Parts

Here are the parts I used to make this dongle (prices converted to USD). (Check out the official BOM for links):

2 PCBs
- Main - 3x for $5.60 from OSHPark
- Sub - 3x for $1.10 from OSHPark
Multiout plug - 2x for $6.70 from AliExpress
Female VGA port - 10x for $3.84 from AliExpress
Headphone jack - 5x for $2.43 from AliExpress
3D-printed shell: top and bottom - printed with my Prusa
1x M3x20mm screw and nut - $0.03 each from a 500 piece kit I bought from Amazon
SMD components (common)
- 2x 0603 10uF 6.3V caps - $0.02 each from a kit from Ali Express
SMD components for NTSC configuration + CSYNC
- 3x 1206 220uF 6.3V caps - $0.50 each from a kit from AliExpress
- 1x 0603 470 Ohm resistor - $0.003 each from a kit from AliExpress

For a single dongle, the total cost is about $8 each, not counting the 3D-printing cost.

Note that for the SMD components, what you need depends on whether you’re building for a NTSC or PAL system, as well as what type of sync signal you intend to use. Definitely check out the official BOM.

The Build

PCBs

First, I used some flush cutters to cut the little spacers off the edges of the PCBs. This is important as the fit within the 3D-printed shell is very tight:

Next, I soldered the castellated edges of the sub PCB to the main one. I used some Kapton tape to help hold the sub PCB down:

I added flux to help the solder flow:

Then carefully soldered each castellated edge:

The PCB should be well aligned on all sides:

Multiout connector

Next up was soldering the multiout connector:

First, I bent the pins down towards each other using the edge of a table:

Then I wedged the PCB into the connector, making sure the notched side of the connector is oriented towards the “Top” of the PCB:

Before soldering, I inserted the PCB and connector into the top shell to make sure everything was perfectly aligned:

While in the shell, I soldered the exposed pins to the PCB:

With that side done, I removed the PCB from the shell, and soldered the pins on the other side:

SMD components

Next, I soldered the three 220uF capacitors to C3, C4, and C5. These coupling caps filter out any DC signal so that only the AC color signal (RGB) passes through:

Next, I soldered the two 10uF capacitors to C4 and C5. These connect the left and right audio signals to VGA output pins 12 and 15 respectively. These DC-decoupling caps protect the equipment on the other end if they’re incompatible with these signals:

As I decided to use the CSYNC signal for sync, I soldered a 470 ohm resistor to R1. This resistor attenuates the TTL CSYNC signal to what most input devices expect:

Note that instead of CSYNC, you can also either enable sync on composite (CVBS) or on luma by soldering one of the pads to the center JP1 pad in the picture above, along with shorting J2.

VGA connector and headphone jack

Next up was soldering the VGA connector:

Then the headphone jack:

I had almost forgotten to solder in the VGA ground anchors:

Shell

Finally, it was time to put it all together into the shell:

Fitting the top was a little challenging, as there isn’t much room in the shell, but eventually it all came together:

I popped in the nut:

Then pushed the screw through the other side, and tightened it up:

All done!

Testing

The dongle inserted easily into the back of the SNES:

I connected a standard VGA cable, along with a headphone to RCA splitter:

With the other end of the VGA cable connected to my gbs-control, and audio directly to my TV, everything worked perfectly:

The video quality is at least as good as it was with my custom cable, although probably better:

3D Printing

Before ending this post, I wanted to share my experience 3D printing the shell. I tried three different ways to print them, each with its advantages and disadvantages.

Officially, Jeff recommends printing the top and bottom shell with the split face facing downwards, with full supports enabled. I tried this first:

Removing the supports took a long time:

After removing supports, the inside wasn’t great:

But the outside was perfect:

Next, I tried printing with the outside faces facing downwards:

There were a lot less supports, and they were easier to remove:

I’m missing a pic of the inside, but as expected, printing this way made the inside perfect. However, the outside looked less good:

Finally, after discussing with some folks in the RetroRGB Discord (thanks SeeThruHead and cray.io), I tried placing them on one of the diagonal faces with minimal tree supports:

The supports came right off:

The result was pretty good, and is what I used in this post:

Although this last option was very easy to clean up, and looked pretty good, printing at an angle did create some minor distortions that may have made fitting the assembled PCBs inside a little more challenging. Next time, I would try this again, but instead of using 0.3 mm layer heights as I did, I would try 0.2 mm or 0.1 mm.

Thoughts

Overall, I think this project is really great! Jeff’s design is very well done: it’s both compact and versatile, supporting NTSC and PAL, as well as different sync methods. I also love that the audio signal is passed through the VGA cable, which is something I intend to take advantage of (stay tuned for a future post on this!).

SNES2VGA is actually part of a larger series of Console VGA Dongles that Jeff has designed. Personally, I think going the route of using VGA for all my old consoles makes a lot of sense because VGA cables are cheap, and many scalers support it, and there are some pretty cool VGA switches out there, like the Extron MVX ones.

SNES 2-Chip RGB Filter Mod: SNS-CPU-GPM and SNS-CPU-RGB

2024-01-23T00:00:00+00:00

A while back, I posted about how I modded my 2-chip SNES, model SHVC-CPU-01, to improve the video output quality using Buttersoft’s filter board, then later posted how user axmcxx performed a similar mod on his SNS-CPU-RGB-02. Well, another user on the ConsoleMods Discord named Toxic_Tripod0 reached out after modding various SNS-CPU-GPM-01/02 models, and graciously shared his pics and steps with me so that I can share it with the community on my blog. He also performed this mod on SNS-CPU-RGB-01/02 models, and we’ll go over some of the improvements he made for these.

Parts

The list of parts is about the same as for the SHVC-CPU-01, with these differences/extras:

Cap Kit - $4.95 on Console5
35V In 5V Out 2A linear voltage regulator - ~$1.10 each from Mouser
470uF 6.3V electrolytic capacitor - included in the Console5 cap kit, or $1.21 for 10 on AliExpress
1x 22uF X5R 0805 ceramic caps - $2.90 for 100 on AliExpress
11x 10uf X7R 0805 ceramic caps (instead of 8x) - $1.80 for 100 on AliExpress

Note that the voltage regulator is difficult to find as they are no longer in production. Look on Mouser, Digikey, eBay, or AliExpress, and make sure it’s rated for 2A - most are 0.5A or 1A, and also rated for 35V input - most are 6.5V. The higher current rating means it runs cooler.

The Build

Toxic_Tripod0 took apart his SNES, and then recapped it using a capacitor kit from Console5. He recommends this, especially after seeing that upon removal, most caps had leaked underneath. Leaking capacitors indicates that they are no longer working optimally, which not only affect their performance, but can erode and cause damage to the main board. Unfortunately, I don’t have any pics of the recap, but Console5 provides excellent documentation and images to follow.

Next, he followed the steps on my first post on how to populate the filter board PCB. As with the SHVC-CPU-01, he removed and transferred the 3 transistors - this time at locations Q3, Q7, and Q5 - to the PCB, and wired them up:

Next, he stacked the eleven 10uF ceramic caps on top of the existing ones at these locations (he actually recommends replacing them entirely rather than stacking):

In the picture above, we can also see that the 5V supply for the PCB is connected to the right-hand side of C83, while the board’s ground is connected to the top of C91.

Here is where we diverge from the previous posts. The original voltage regular is known to produce enough noise or ripple that it can result in a single thick white vertical line across the screen. To address this, Toxic_Tripod0 replaced the regulator with a new one:

Finding a new regulator can be difficult, so another option, as described on RetroRGB, is to add a 470uF electrolytic capacitor between the 5V and GND pins of the regulator, and to replace the 1uF cap next to it with a 22uF one. Toxic_Tripod0 had already replaced the regulator, so doing this mod was not really necessary, but since the Console5 cap kit came with the 470uF cap, he went ahead and did it anyway:

Note that even if the SNES does not display the thick white line, Toxic_Tripod0 found that doing this mod helped to dim the faint vertical lines (“jailbars”) that he was seeing.

Finally, he lifted pin 27 on PPU2, as this has the greatest impact on reducing jailbars:

Note that Toxic_Tripod0 did not lift pin 3 on PPU2 because he did not notice any diagonal lines, as is common on SNS-CPU-RGB models. Lifting pin 3 results in the composite and s-video signals losing their color signal, so it’s better if it can be avoided.

Here’s a complete picture of all the mods made to the underside of the main board:

As I’ve already covered axmcxx’s mod of a SNS-CPU-RGB-02 before, we’ll focus on the differences here.

Parts

As usual, get the parts listed for the SHVC-CPU-01, with these differences/extras:

Cap Kit - $4.95 on Console5
3x extra transistors (2SA1037AKT146Q) - $0.30 each from Digikey
35V In 5V Out 2A linear voltage regulator - ~$1.10 each from Mouser
470uF 6.3V electrolytic capacitor - included in the Console5 cap kit, or $1.21 for 10 on AliExpress
1x 22uF X5R 0805 ceramic caps - $2.90 for 100 on AliExpress
12x 10uf X7R 0805 ceramic caps (instead of 8x) - $1.80 for 100 on AliExpress

Unlike the SHVC-CPU and SNS-CPU-GPM models, we need to leave the 3 transistors on the main board, which is why 3 more need to be bought.

The Build

Toxic_Tripod0 took apart his SNES and recapped it using the kit from Console5. Next, he followed the steps on my first post to populate the filter board PCB, this time installing the three new transistors on the PCB.

On the main board, he lifted the ‘base’ leg of each of the three transistors at Q1, Q2, and Q3, and then wired up to the mod board as follows:

Here’s a pic from axmccx’s install that shows more clearly how to lift the transistor legs, using some kapton tape to ensure it doesn’t short with the pad on the main board:

Next, he replaced the twelve 10uF ceramic caps at the following locations:

Above, we can also see that the 5V supply for the PCB is connected to the right of C63, while ground is connected to the left of C64. Also, the 10uF cap that sits between R9 and C10 is actually floating - there are no pads to solder to:

Toxic_Tripod0 used a wire to bridge the gap between the two locations, as the cap is too small. If you have a 1206 10uF capacitor, it might fit better. The reason for this capacitor is that on the schematics for the SHVC-CPU model, there is a filter cap between the green line at that point and ground, but this cap is missing from the SNS-CPU-RGB models entirely.

As with the SNS-CPU-GPM, he then replaced the voltage regulator:

On the underside of the board, where the three pins of the voltage regulator are soldered, he added a 470uF electrolytic capacitor on the 5V and GND pins of the regulator, and also replaced the 1uF ceramic cap at C61 with a 22uF X5R:

Finally, he lifted pins 3 and 27 on PPU2, to fix diagonal lines and jailbars respectively:

Here’s a complete picture of all the mods made to the underside of the main board:

Summary

I thought it might be useful to summarize all the mods made along with what they fix in a table:

Modification	What it fixes
Recapping the top side of the board	Saves main board from damage, and may clean up signals.
Installing the filter board	Reduces blur and ghosting in video output.
Replacing/stacking 10uF ceramic caps	Further helps in reducing noise in video output.
Replacing voltage regulator	Helps reduce thick white line across the screen, as well as jailbars. Also runs less hot, so may prolong lifetime of caps underneath the regulator’s heatsink.
470uF cap on voltage regulator	Can be used instead of replacing the original voltage regulator, though less effective.
Replacing 1uF cap with 22uF cap next to regulator	Further helps in reducing the thick white line across the screen.
Lifting pin 3 on PPU2	Reduces diagonal lines. NOTE: composite and s-video output lose their color signal.
Lifting pin 27 on PPU2	Most effective at reducing jailbars.

Thoughts

Unfortunately, Toxic_Tripod0 did not take before/after pics, as he felt that it was difficult to see the differences this way. However, we can expect that the differences should be at least as good as what I’ve shown in the previous two posts, if not better considering the extra mods that were made. Toxic_Tripod0 told me that in person, the video output from his modded SNS-CPU-GPM looks identical to the 1-chip or the Jr.

Anyway, our hope is that this post is useful to those looking to perform a similar mod. Huge thanks to Toxic_Tripod0 for sharing his pics and experience!

DaisyDrive64

2024-01-06T00:00:00+00:00

DaisyDrive64 is an N64 cartridge emulator by nopjne (aka Scorp0rX0r on Discord), that uses a Daisy Seed board. It’s similar to the PicoCart64, except that by using a more powerful MCU with more memory, is able to offer a more complete flash cart experience, including support for loading all official N64 games from SD card, as well as saving savestates. In this blog post, I’ll go over how I built this very cool project.

Parts

DaisyDrive64 PCB - $10 (see below for how to get one)
Daisy Seed (65MB, comes with headers) - ~$25 + shipping from Electrosmith
SD card slot - $2.42 + shipping from Mouser
SD card (128 GB is good) - $7.50 from Amazon
N64 cartridge shell - $5 from AliExpress

At the time of this writing, the only way to get the PCB is to join the Dubious Technology Discord server, and ask Scorp0rX0r for one.

All told, this cost me around $70 USD, when taking shipping to Canada into account. For US residents, this would probably be closer to $60 USD.

The Build

Soldering parts to the PCB

First, I soldered the SD card slot to the board:

Once I aligned the pins, I used some Kapton tape to hold it in place:

Using flux, I then proceeded to solder the pins and anchor points to the pads on the PCB:

Initially, I didn’t realize that I had applied too much solder to the anchor point on the right side of the pins:

With this much solder there, I could not insert an SD card. I wicked away this blob, and touched up the outside of the anchor point with much less solder:

Next up was soldering the Daisy Seed board to the PCB. First, I inserted the headers into the board and soldered them to the underside of the PCB:

Then I placed the Daisy Seed board onto the header pins and soldered them in place:

The last step is to bridge the Q1 connection underneath the PCB with a bit of wire:

This connection was originally designed for a mosfet to protect against the N64 sinking current from the Seed’s USB connection; however, it isn’t necessary as the Seed has its own circuitry to prevent this issue, so we simply bridge the connection as shown above. Note that sinking current through the GPIO pins is still an issue when the firmware is halted, and therefore it’s recommended to take the cart out when flashing firmware through the USB port.

And with that, the PCB soldering is done.

Flashing the Daisy Seed’s firmware

With the hardware bit all done, it was time to flash the Daisy Seed with the firmware that Scorp0rX0r developed. Ideally, we’d follow the build steps on the GitHub page to build the very latest firmware and related software, or download the latest build from the releases page. However, the version on the GitHub repo lags behind the version Scorp0rX0r makes available on Discord.

At the time of this writing, the latest GitHub release is a build from Jan 5 2023. On Discord, Scorp0rX0r has made a more recent Nov 11 2023 build available, which, among other things, adds full support for FlashRam and SRAM savestates. I downloaded this file, DaisyDrive64_111423.zip, and extracted the two files in there:

DaisyDrive64_data.bin
DaisyDrive64_fw.bin

To flash these files, I connected the Daisy Seed to my PC using a micro-USB to USB-A cable with data pins connected. Note that some USB cables are only used for charging, and are missing the data pins. When data pins are connected in the cable, Windows will play the “device connected” chime, and display the device in the Device Manager.

When I connected the Seed to my Windows machine, the board was recognized right away. However, when I put the Seed into DFU mode by holding the Boot button, then pressing and releasing the Reset button, the device now showed up as unrecognized in Device Manager:

This meant that I needed to install the driver for it. To do this, I downloaded Zadig, and with the Seed in DFU mode, I selected “DFU in FS Mode” from the pull-down (this is the same name as seen in the Device Manager), and pressed “Install Driver”:

Once installed, Device Manager no longer showed the yellow exclamation icon.

With the drivers properly installed, it was time to flash the two files I downloaded earlier using the browser-based Programmer. Here are the steps to do so:

Put the Seed into DFU mode by holding the Boot button, and pressing and releasing the Reset button.
From the Programmer, click “Connect” and select “DFU in FS Mode”.
Scroll down, click on “Advanced…”, which should reveal a “Flash Bootloader Image” button. Click on it. This will go through a few steps, and then eventually print “Done!”.
Get the Seed out of DFU mode by disconnecting the USB cable, and reconnecting it.
From the Programmer, click “Connect” and select “Daisy boot loader”.
Click on “Choose File” and select the file “DaisyDrive64_data.bin”.
Click on “Program”.
Put the Daisy back into DFU mode again, “Connect” to it, click “Choose File” and this time, select the file “DaisyDrive64_fw.bin”.

With that, the Daisy Seed was now fully flashed and ready to go.

Preparing the SD card

With the Seed’s firmware flashed, I now needed to setup the SD card with the right files and folders:

OS64P.z64 –> This is a modified version of the Altra64 menu rom. This goes at the root of the SD card. As with the firmware, the latest version is not available on GitHub, but can be downloaded from Discord from the June 17 2023 build. Only copy the “OS64P.z64” from this zip file.
DD64EC/ –> Create a folder named “DD64EC” at the root of the SD card.
DD64EC/CFG/ –> And within the “DD64EC” folder, create another folder named “CFG”.

The last step, of course, is to copy some N64 roms to the SD card. These can be placed anywhere, such as in the root, or into folders. I copied some roms into a folder named “roms”. Note that the rom files must not be zipped.

Testing

At this point, I could finally test everything. I inserted the SD card into the slot, and carefully inserted the PCB into my N64:

Success! Actually, it was not an immediate success. Initially, my SD card was not being read properly, and I experienced one of the coolest features of the DaisyDrive64: when it detects an error, it plays an error message through the audio output of the N64! In my case, “SD card initialization failed” came out of my TV speakers over and over. After reflowing the solder joints on the SD card connector, the message was gone, and everything worked.

Cart Shell

With the PCB all working, the last thing I did was place it into an N64 cartridge shell. Unfortunately, this didn’t go as smoothly as I would have liked, but it still turned out alright.

First, I opened up the shell and got rid of the metal RF shielding, which can’t be used because the PCB with the Daisy Seed soldered onto it doesn’t fit otherwise:

Unfortunately, getting rid of the shield is not that simple because apart from RF shielding, it also serves another purpose: there are 4 slots at the base of each side of the shell that the shield fills in:

These slots need to be filled in, otherwise we risk breaking the N64’s cart slot. To do this, I filled in the 4 slots on each side of the shell with epoxy:

I let it cure for 24 hours:

Although it was fully cured, my epoxy remained a little soft and tacky. This isn’t great, but it seems to work fine. When I discussed this with Scorp0rX0r, he said he used a UV-light curing epoxy that, once cured, was hard as plastic. I would definitely recommend going this route instead.

Finally, even with the RF shield removed, the PCB still doesn’t quite fit in the shell because of the debug header pins on top of the Seed:

The simplest solution is to cut them off with flush cutters, or to bend them to the sides. I opted to use my heat gun to remove them, being careful to cover up the buttons with Kapton tape so that they wouldn’t melt, and being careful not to accidentally remove the small pull-up resistor right next to the header:

After cleaning up the solder with some wick:

It’s worth mentioning that Scorp0rX0r has a work-in-progress design where the Seed is soldered flush to the PCB, which adds the necessary clearance for the debug header, and would avoid the need to remove or modify it as I did above. This PCB is not yet available, but it would certainly help make the install a easier.

Finally, I was able to put it all together in the shell:

This is when I found out that the screws AliExpress sent me were too large for the screw posts:

There wasn’t much I could do about that one, but for the second one, I used my drill to make the hole larger, and managed to screw in at least one side of the PCB (on the left):

The screws for the outside of the case also didn’t fit, so I ended up using some wood screws I had lying around:

Despite the issues with the screws, I think it looks pretty good:

And here it is looking great in the N64:

Thoughts

This is a really awesome project. I’ve been playing a bunch of N64 games over the past couple of weeks, and the DaisyDrive64 has been working really well. For a project that cost me around $70 USD (including shipping and the SD card), I’d say it’s well worth it for a fully functioning flash cart.

It’s worth noting that the DaisyDrive64 can also be used for N64 game development, and actually supports advanced debugging features if wired up correctly. For those interested in this, I would recommend hitting up the Discord server. It’s a nice community, and Scorp0rX0r is always ready to help.

SFC Controller 8BitDo Mod Kit

2024-01-01T00:00:00+00:00

After BlueRetro-fying most of my consoles, I realized that I much prefer using original controllers. 8BitDo makes some really great “mod kits” that are PCB replacements for controllers with Bluetooth support and rechargeable batteries. In this post, I’ll go over how I installed their mod kit for SNES/SFC controllers.

Parts

I had originally wanted four SNES controllers, but it turns out that SNES controllers are actually pretty expensive at around $20 each on Marketplace or eBay. Instead, I opted for Super Famicom (SFC) controllers, which are generally less expensive. SFC controllers are slightly different from their SNES counterpart in a couple of ways: the buttons are colored differently, all four buttons are convex while Y and X are concave on the SNES controller, and the cable is significantly shorter. The differences in button color and shape don’t bother me at all, and since I’m going to be replacing the PCB with a Bluetooth one, the cable length doesn’t matter.

I bought a single lot of 6 SFC controllers on eBay that cost me a total of $42.56 USD, or around $7 each:

I also bought four mod kits from 8BitDo for $100 USD in total, or $25 each:

Cleaning

The SFC controllers were pretty dirty and yellowed, so they needed cleaning and retrobriting. I started with taking them all apart, then giving everything a good clean:

The button membranes were particularly gross:

The dpad and buttons were also pretty grimy:

The screws and shoulder button posts weren’t too bad, so I just gave them a quick bath in IPA and scrubbed them with a toothbrush:

Retrobring - “Vapor Method”

As mentioned earlier, the controllers were pretty yellowed:

Instead of the usual retrobrite method of submerging the plastics in a hydrogen peroxide solution, I decided to try out a new method shared by Simon Lock that has come to be known as the “vapor method”. This method consists of pouring a much smaller amount of the solution in the bottom of a container, placing plastics onto a stand within the container, then sealing the container. As usual, UV light from a lamp or the sun is required, but the key is that we use a lot less solution, and the plastics are not in direct contact with the hydrogen peroxide solution.

I used 35% food grade hydrogen peroxide, which I diluted down to about 12% (2 parts water, 1 part peroxide). I used about half a bottle:

After pouring the solution in the bottom of my transparent container, I placed the controller parts onto some baskets within:

I then sealed the container and placed my 50W UV lamp on top:

The results were great. Here are some before/after shots.

Before:

After:

Before:

After:

In the pic above, you can see how some pieces were particularly stubborn. So I placed these last pieces back in for about two more days:

Getting better:

The last few very stubborn pieces:

A day later:

The final result:

Without a doubt, the vapor method is definitely the way to go. Because I wasn’t submerging the plastics, I wasn’t worried about leaving the parts in there for a few days until all yellowing was gone.

Putting it all together

With everything cleaned and retrobrited, all I had left to do was to put the controllers back together using the 8BitDo mod kits.

This is what the PCB looks like:

First, I attached the charging port ribbon cable to the PCB:

I put back the buttons and membranes into the front face of the controller:

Then installed the PCB, being careful to route the charging port where the controller cable normally goes:

Finally, I put back the shoulder buttons, and closed it all up:

Rinse and repeat for the other three controllers:

I also put together the extra two controllers with original cables, which may come in handy at some point:

Thoughts

I am definitely a fan of 8BitDo’s mod kits. Nothing beats the feel of the original controllers for me, and 8BitDo’s PCBs are perfectly shaped so as not to change that feel in any way. The only downside I can think of is the fact that the charge port is proprietary, so you definitely don’t want to lose the charging cables they include with the kit. But I personally don’t think this is a big deal.

I’m also super happy with how well the controllers cleaned up and retrobrited. They look practically new! The vapor method is great, and will be my go-to method from now on. Based on this experience, I also added this section to the ConsoleMods wiki about the vapor method.

gbs-control - Take 2

2023-11-07T00:00:00+00:00

A while ago, I wrote about how I built a gbs-control scaler. Although that post covers the basics, I mostly glossed over the details, expecting the reader to watch Voultar’s video. In this post, I’ll go over how I built a second gbs-control in a lot more detail, which should help anyone who wants to build one, and who prefers a web page to a video.

The Build

As before, I ordered the parts I needed:

GBS8200 board - V4.0 only (eBay $22 USD)
ESP8266 “NodeMCU” board (AliExpress $4 USD)
Si5351A Clock Breakout Board (AliExpress $4 USD)
0805 SMD 10uF caps (AliExpress $2 USD for 100 pcs)
VGA male to HDMI female converter (AliExpress $4.30 USD)
A good 5V 2A DC power adapter (Amazon $15 USD)

Note that I highly recommend getting a V4.0 GBS8200. Other variants, like the V5.0, also work, but produce a noisy picture. Unfortunately, I know that this is true from experience. I built two gbs-controls, one with a V4 and one with a V5, and the latter produces such a noisy picture that I ordered a third V4 to replace it. In this build, I’ll be using the V4.

GBS8200 Prep

The first thing we need to do is make some modifications to the GBS8200 board itself. We start by removing the three RGB input potentiometers. These pots can be used to tweak the brightness of the RGB values coming in on the DB15 input. This step is technically not required, but even with the pots turned all the way down, they still apply a little resistance, making the video output slightly darker.

These are the caps we want to remove:

Using my desoldering gun, I desoldered the three legs of each pot underneath the board:

I used a piece of wire that I stripped and tinned, and then cut into three to bridge the connections where the pots were:

The next step is to stack some 10uF capacitors on top of existing ones to add more capacitance for power supply bypassing, which can reduce some forms of visible noise:

We start with C23:

Add flux and solder to both sides of the cap:

Then stack one of the 0805 10uF caps on top, and touch each side with the soldering iron:

We do the same with C41 and C42:

And C48:

Next, we remove C11, which should help LDO oscillation problems with power supplies > 5V (though in this build, we really should only use a 5V power supply to avoid damaging the VGA to HDMI adapter):

As we’ll be mounting the ESP8266 to the edge of the GBS board, we need to remove these connectors at P5, P6, and P8, which I did with my desoldering gun:

To allow the gbs-control to actually override the default GBS functionality, we need to bridge the programming port at P8. I did this by soldering a small wire between the two vias underneath the board. This ensures that it doesn’t get in the way of mounting the ESP8266 along that edge:

That’s it for the board prep.

ESP8266 Programming and Install

Now we tackle the brains of the operation: the ESP8266. This device basically overrides the built-in firmware of the GBS8200, providing many features such as a web-based GUI that you can control from your phone or computer. The gbs-control firmware is written by ramapcsx2 (Robert Neumann) and is open source and available on GitHub.

My ESP8266 came with pin headers installed, so first thing I did was desolder them:

Then, I followed the detailed Software Setup steps to install the Arduino IDE, along with the ESP8266 support libraries, etc. Then I downloaded the gbs-control firmware and installed it onto the ESP8266 from my laptop:

At this point, while still connected to the PC, you should be able to test that the firmware is installed properly by searching for WiFi networks and looking for one named “gbscontrol”. You can connect to it, using the default password qqqqqqqq (that’s 8 q’s), then opening http://gbscontrol to access the control panel UI. If this works, you’re good! You can optionally configure the ESP8266 to connect to your home WiFi, which I recommended, as it allows you to easily control the system without disconnecting from your home network every time.

With the ESP8266 programmed, I proceeded to install it onto the GBS board using Voultar’s method - that is, installing it sideways along the edge of the board, lining up the GND vias:

I stripped back some wire and tinned it, then threaded it through both GND vias of the ESP8266 and GBS board:

Holding the ESP8266 in place, I added more solder to the bit of wire between the two to make a strong connection, and to make it hold in place:

There is a second GND via on the board that also lines up with the ESP8266, so I did the same thing with that:

Once both GNDs are connected, the ESP8266 shouldn’t move:

Next, we have a few connections to make between the ESP8266 and the GBS.

First, I connected the “Debug Pin” from the controller IC to “D6” on the ESP8266, which allows the gbs-control to enable automatic image positioning and timing adjustments:

Next, I connected the two I2C bus wires SCL to D1, and SDA to D2:

Finally, I connected a wire from the right side of D2 to Vin, which will supply 5V to the board once powered:

Clock Generator Install

The Si5351 clock generator board is optional, but recommended to allow the gbs-control to output precise frequencies:

First, I stuck some kapton tape to the underside, making sure to keep the vias uncovered:

Using hot glue, I then stuck that kapton-covered part onto the edge of the heat sink-covered TrueView chip:

Now to connect the clock generator, I started by soldering a wire from pin 40 of the TrueView to the center CLK0 pad:

Next, I connected the CLK2 edge pad to C41 for the ground connection:

Note that the official instructions suggest connecting the CLK2 pad to ground sides of C47 or C48; however, C41 is closer and works just as well.

To power the clock generator, I soldered a wire from the positive side of C41 to the unlabelled capacitor near the edge:

Finally, we need to connect two wires between the MTV230 chip and the TrueView chip: from pin 25 to SCL, and from pin 26 to SDA:

Note that the wires actually cross over each other:

At this point, I’m done with all the soldering on the GBS itself:

VGA to HDMI Adapter

The VGA to HDMI adapter that we got needs to be powered by 5V, and comes with a short micro-USB power cable for just that reason. Instead of hooking it up to an external source, we’ll modify the cable so that we can connect it directly to the GBS board. We do this by using the red and black power connector that comes with the board itself:

I hooked up the adapter to the VGA output port, then measured out the USB cable so that the other end lines up with the 2-pronged power jack:

I cut the cable there, stripped it back, then stripped and tinned the two wires inside:

I used my multimeter to make sure I knew which wire was GND and which was 5V, then proceeded to solder the cable to GBS power connector (black is ground, red is 5V):

And with that, I can now easily power the adapter from the board itself:

Testing

I hooked up my SNES to the gbs-control, and hooked up the HDMI output to my TV, and played some Super Metroid:

The picture quality is really quite good!

Thoughts

Of course, my opinion on the gbs-control hasn’t changed since the first one I build. It’s an excellent scaler, especially for the price!

If this post helps you to build one of your own, then please let me know!

Also check out my posts about how I made gbs-control cases here and here.

BlueRetro AIO

2023-11-06T00:00:00+00:00

I love the BlueRetro project, and on this blog, I’ve shown how I’ve made multiple DIY HW1 adapters for different consoles by soldering wires to DB25 connectors, and wrapping them up in DB25 shells. In this blog post, I’m going to cover a different way to make these adapters using PCBs and 3D-printed shells designed by pmgducati known as BlueRetro AIO Units.

My Setup

Before getting into how I made these AIO units, I thought I’d share what my final setup looks like with them, so that you know where we’re headed. I currently have 6 BlueRetro AIO adapters, and one receiver (connected to the NES adapter in these pics):

I also have an array of Bluetooth controllers as well:

When I want to play a different system, I simply disconnect and reconnect the receiver to that system’s adapter. It’s quick, and since I have only one receiver, I only have one device to configure and update.

Alright, let’s get into the how I made these.

Making BlueRetro AIO Units

Making BlueRetro AIO units requires a few parts:

PCB

For the PCBs, I personally use JLCPCB because it’s cheaper for me than most other options. Simply download the Gerber files for the system you need, and uploaded them to JLCPCB, sticking to default options (except board color). Note that the BlueRetro “receiver” - the part that holds the ESP32 devkit board - is called “Main_<date>.zip”. The file names for each console-specific PCB has the name of the console in it (e.g. “SNES_<date>.zip”).

3D-printed shell

For the 3D-printed shells, the STL files can be downloaded from here. The way it works is that there are two parts, the top and the bottom. For the receiver, you’ll want to print this top and this bottom.

For each console adapter, select the top that’s specific to the console. The only difference here is that each one has a nice logo embedded into it (see the SNES one, for example). For the bottom part, you’ll need to choose from one of the “Aux Bottom - <N> Player.STL” files, where <N> is the number of controllers you intend to connect. This basically translates into how many holes the bottom case will have for the controller cables to pass through. You don’t have to match the number of ports on the target console; for instance, the N64 supports up to four controllers, but I decided to only connect two, as I don’t expect to play four player games. See this BOM for what you’d typically want to print for each console.

Controller cables and other components

Finally, you’ll also need controller cables, and depending on the console, potentially some other components, such as through-hole level-shifter ICs. For controller cables, I normally buy extension cables from AliExpress that I can cut, keeping the console plug side intact. See this very detailed BOM for the parts you’ll need per console.

The Builds

Receiver

Let’s start with the receiver, which is the part that connects to each adapter.

Parts:

3D printed shell
PCB
ESP32-DEVKITC-32E (aka ESP32-WROOM-32E)
DB25 connector (female, 90 degrees)
2x 19 position pin sockets
Optional:
- Blue LED (470nm 3.3V 1206)
- 84.5 ohm resistor (SMD 1206)

Here are the main parts:

Along with the 3D-printed shell:

And the optional LED and resistor:

To save money, instead of buying two 19-pin sockets, I bought a bunch of 4-pin ones from AliExpress. Unfortunately, when inserting them into the PCB, I realized that they didn’t quite fit well together:

So I ended up filing the edges of each one with some sandpaper until they fit well enough:

After inserting 4 of them on one side, the last one needed to be 3 pins wide, so I cut off the extra one with flush cutters:

I did the same for the other side, and to hold everything in place, I inserted the ESP32 board into them:

(Note that the ESP32 board is actually inserted the wrong way in the pic above, as this was only temporary to solder in the sockets).

I soldered the pins to the underside:

This worked out okay, but I would recommend just getting the 19-pin sockets instead.

Next, I soldered the female DB25 connector to the PCB. Note that the AIO BOM suggests using a male connector for the receiver, and female ones for each console adapter. I went the opposite way, which is totally fine:

I removed the two screw posts from the DB25 connector. The 3D printed shells are made such that these posts should be removed, though the metal plate that is held by the screw posts is kept:

Finally, I placed the board into the shell, and closed it up:

At this point, we can stop. However, I got the optional LED and resistor, which are useful for showing the status of the BlueRetro receiver (e.g. it flashes in pairing mode). I soldered on the LED and the resistor to the underside of the PCB:

The LED shows through the hole in the 3D-printed cover:

Here it is in action:

N64

The N64 is probably the easiest adapter to build, so let’s start with that one.

Parts:

PCB
3D-printed shell
DB25 connector (male, 90 degrees)
N64 extension cables (1, 2, or 4)

The N64 supports up to 4 controllers, but as I don’t expect to play 4 player games very often, I decided to only build a 2-player adapter.

First, I undid my existing DIY adapter. If starting from scratch, you’d want to cut and strip the ends of the extension cables, and tin each end:

I inserted the two cables into the 2-player bottom shell:

I then soldered the DB25 connector to the PCB:

Next up was wiring the cables to the PCB. I referred to the schematic I had printed before where I had identified which color wire each of the three pins mapped to:

In my case, white is data, red is 3V3, and black in ground. So I soldered the three wires from the first controller to P1DATA, P13V3, and P1GND respectively. I then did the same for the second controller:

Since I decided not to connect player 3 and player 4 cables, as per the assembly instructions, I needed to connect P3DATA and P4DATA to 3V3. This is how the BlueRetro knows that these are not connected. I did this by soldering a short (pink) wire to P23V3 on one end, and the other end to both P3DATA and P4DATA:

With the wiring done, it was time to put it all together:

To avoid the wires being ripped off the PCB, I used a couple of small zip ties that I tied very tightly to the ends of the cables:

I then threaded the cables out, positioned the PCB in the shell, and closed it all up:

Done!

GameCube

The GameCube adapter is about as easy as the N64 one, only with a few more wires to solder.

Parts:

PCB
3D-printed shell
DB25 connector (male, 90 degrees)
GameCube extension cables (1, 2, or 4)

First, I undid my existing adapter. If starting from scratch, you’d want to cut and strip the ends of the extension cables, and tin each end:

I inserted the two cables into the 2-player bottom shell:

Next, I soldered the DB25 connector to the PCB:

Now for wiring the cables to the PCB. I referred to the schematic I had printed before where I had identified which color wire each of the three pins mapped to:

In my case, red is DATA, white is 5V, black and blue are GND, and green is 3V3, which is not used in this adapter.

I started off by soldering the black and blue GND wires for player 1 and 2 to their respective pads, P1GND and P2GND:

I then soldered the rest of the wires, player 1 red and white to P1DATA and P15V, and player 2 red and white to P2DATA and P25V:

Similar to the N64 adapter, because I wasn’t connecting player 3 and 4 cables, I needed to connect P3DATA and P4DATA high, so I used a short piece of orange wire to connect these two pads to P25V. Note that the assembly instructions actually say to connect these to 3V3, which I could have done by hooking up the 2 green wires to these two pads; but the ESP32 module should be able to handle the 5V on these two pins.

With the wiring done, I used zip ties to create strain reliefs:

Once again, the screw posts on the DB25 connector need to be removed, though the metal face plate remains:

Done!

Here it is, hooked up to the receiver:

PSX/PS2

The PSX/PS2 adapter is also straightforward to build.

Parts:

PCB
3D-printed shell
DB25 connector (male, 90 degrees)
PSX/PS2 extension cables (1 or 2)

First, I undid my existing adapter. If starting from scratch, you’d want to cut and strip the ends of the extension cables, and tin each end:

Next, I soldered the DB25 connector to the PCB:

I threaded the cables through the bottom shell:

Now it was time to wire the cables to the PCB. I referred to the schematic I had printed before, where I had identified which color wire maps to which of the controller 9 pins:

The PCB has all the player 1 pads on one side, and player 2 pads on the other side. I soldered the player 1 wires to each pad:

Then flipped the PCB and soldered the player 2 wires:

Note that on both sides, I did not solder anything to pads P1-3 and P2-3. This is because Pin 3 is 8V and Pin 5 is 3V3, and you should only solder one of these, not both for BlueRetro to work properly. I chose to solder to pin 5, and left the white wire (pin 3) disconnected.

With wiring done, it was time to close things up:

I removed the screw posts. Note that the metal face plate should be kept on the DB25 connector, unlike in this pic:

I used zip ties to create strain reliefs:

Then closed everything up:

Done!

SNES - 2 Player

The first time I made the SNES adapter, it only supported 2 players. I also didn’t have my 3D printer yet, so this build was a little bare-boned.

Parts:

PCB
DB25 connector (male, 90 degrees)
SNES extension cables (x2)
74AHCT125N quad level-shifters (x2 for 2-player)

Looking at the schematic, it initially looks like we need to wire up 7 wires for the first controller, and 6 for the second, because the LATCH (pin 3) is not required for player 2:

However, the rest of the schematic outlines connections in blue that only need to be made if you want multitap support:

In this build, we’re only interested in supporting 2 players, so we don’t need to connect P1-SEL, P2-SEL, P1-D1, and P2-D1. We also don’t need a third level-shifter. So that means we only need 5 wires for the first controller, and 4 for the second. In fact, it turns out that SNES controllers (and extension cables) only have 5 wires in them. The other pins are left unpopulated, and were there for third-party adapters, such as the light gun and the multitap.

Alright, on with the build!

First, I cut, stripped, and tinned the extension cables:

Using my multimeter, I identified the mapping of each pin to each wire color. You can see how there are only 5 wires:

Next, I soldered in the 2 level-shifters to the PCB:

Then I soldered the DB25 connector:

If I had the 3D-printed shells, I would normally have inserted the controller cables into them here. But I didn’t, so I proceeded to solder each one to the PCB:

Player 1 side:

Player 2 side:

Note that the player 2’s latch wire (white) is not soldered to the board:

In retrospect, I realize that one thing I forgot to do is to “connect IO21 & IO25 to GND”, as per the assembly instructions, since we’re not enabling multitap support. Concretely, this means I should have soldered the P1-D1 and P2-D1 pads to one of the GND pads.

As I didn’t have my 3D printer yet, I used a couple of zip ties to secure the wires:

And with that, I was done. In the next section, I convert this one to support 4-player multitap mode, and add a proper shell.

SNES - Multitap

Making a multitap BlueRetro adapter is a bit more work because SNES controllers/extensions only have 5 wires in them, but we need 7 for the first player, and 6 for the second. This means we need a 7 wire cable for each controller, as well as 3 extra pin ends to insert into the SNES controller ends. All of this will be made clearer below.

Parts:

PCB
DB25 connector (male, 90 degrees)
7 wire cable (can use a PSX/PS2 controller cable)
SNES controllers/extensions (3x)
74AHCT125N quad level-shifters (x3 for 4-player)

First, I took apart the 2-player version I had made, and soldered in the third level-shifter:

I had bought a lot of Super Famicom controllers on eBay with the intention of converting four of them into Bluetooth controllers using 8BitDo mod kits. As I didn’t need the cables, I decided to use the controller ends from two of them:

It turns out it’s really heard to open up the controller end. I made myself a little tool using one of those paper clips:

This was still really hard, so I ended up using a blade to cut off the two plastic pegs on the other side. Once cut, and using my tool, I was finally able to pry off the end:

Lifting up the plastic “door”, we can see how SNES controllers only have 5 wires in them, leaving 2 pins empty:

Our goal is to cut off all those metal pins and resolder them to a 7-cable wire. But for that, I needed 3 more pins, which I got from one of the extension cables:

I cut off all the ends, keeping a little bit of the wire:

7 wires for player 1 (top), and 6 for player 2 (bottom):

I used an 8-wire cable I had lying around. Another alternative is to use a PSX/PS2 controller cable, which has 7 wires in it:

I soldered the controller end pins to each cable:

I then reinserted the pins back into the controller ends, making sure they matched up with the schematic.

I slid the cap back on, but left it loose until the very end. It was a pain to remove, so I wanted to make sure everything worked first:

I inserted the player 2 cable wires, which is missing the LATCH wire (third from left):

These cables were pretty thick, so to insert them into the bottom shell, I needed to make the hole bigger by manually twisting a drill bit through the holes:

I soldered the player 1 wires to one side of the PCB:

Then player 2:

To close things up, I needed to add some kind of strain relief to the cable end:

This didn’t quite fit in the little cavity inside the cable end cover, so I snipped a little off the zip tie, and that worked:

I also put the usual strain reliefs on the other end of the cables so that they stay inside the shell:

And closed everything up:

Done!

NES

The last build I’m covering is the NES one. This one is simpler that the SNES one, but I cover it afterwards because I ended up using a SNES PCB instead of an NES one. The reason for this is that the NES and SNES controllers are very similar, as are the PCBs for both. Since JLPCB requires a minimum order of 5 PCBs, this also allowed me to save money and avoid printing 5 more for the NES.

Parts:

PCB
DB25 connector (male, 90 degrees)
NES extension cables (x2)
74AHCT125N quad level-shifters (x2)

The first thing I did was compare the two PCBs online, and map out the differences:

Basically, the pads map this way:

NES	SNES
P1-D0	P1-D0
P1-CUP	P1-CLK
OUT0	LATCH
GND1	GND1
5VIN1	5VIN1

P2-D0	P2-D0
P2-CUP	P2-CLK
GND2	GND2
5VIN2	5VIN2

The other important part is how the BlueRetro identifies that it’s the NES that’s connected, and not the SNES. The way it does this is by looking at pin 22 of the DB25 connector: if it’s tied to GND, then it’s a SNES, if it’s tied to 3V3, it’s an NES. The SNES PCB is designed to tie pin 22 to GND, so we need to address this.

First, I soldered the two level-shifters to the PCB:

Now here is where we address pin 22 that needs to be tied to 3V3. What I did was bend pin 22 across this way:

Then I soldered the connector to the PCB. Notice how one of the vias has no pin coming through it:

That pin 22 I lifted is visible on the other side:

Since we need this to be tied to 3V3, I soldered a short wire from that pin to the 3V3 leg of one of the level shifters:

For the cables, I took apart the DIY adapter I had made before:

I stripped and tinned the wires, then passed the cables through the bottom shell:

I soldered the wires to the PCB, starting with player 1:

And player 2:

Finally, I removed the screw posts, added zip tie strain reliefs, and put it all together:

All done!

Thoughts

I’ve already mentioned multiple times how much I love the BlueRetro project, so I’ll share my thoughts on the difference between these AIO units over the standard DIY through-hole method.

Overall, the main advantages to the AIO units are:

They’re easier to build, as you get to solder wires to a PCB rather than to pins of a DB25 connector or level shifter.
It’s easier to get the orientation right when connecting the receiver to the adapter, since the 3D-printed shell has a very clear “top” side that you need to line up.
They just look nicer with the 3D-printed shell.

The disadvantages are:

They’re more expensive to make, as you need to get the PCBs and 3D-printed parts made.
The 3D-printed part models don’t print as nicely with FDM printers. The general shape and small grooves results in long bridges, which despite my best efforts, never looked as beautiful as I hoped.

Having said all that, I’m actually quite happy with these AIO units, and would definitely recommend them!

gbs-control Case for YPbPr Out

2023-03-15T00:00:00+00:00

In my last post, I went over how I designed and built a case for my gbs-control used for up-scaling with HDMI output. This post will be about my second case, designed for the gbs-control I use for down-scaling/transcoding with RGB/YPbPr out.

Design

My second gbs-control is used for transcoding and down-scaling input signals, usually from RGB to YPbPr, using a custom DB-15 to RCA cable to feed the YPbPr signal to my CRT, along with a stereo RCA extension for audio:

Here were my design goals for this second case:

Keep the VGA out connector, but also add 5 RCA output jacks to the back panel to carry YPbPr (or RGB) along with left/right audio. This would allow me to hook up this gbs-control directly to my CRT using regular RCA cables, rather than my custom one.
As with the HDMI case, I wanted the same reset button and status LED on the front panel.

Having made the back panel a separate piece in my original design, all I had to do was design a new one:

I decided to label each of the RCA output holes because finding RCA jacks of the right color isn’t easy.

Parts

Here are all the parts I needed to build this:

A fully assembled gbs-control with the Node MCU positioned along the edge - see my post here.
A green LED
100 ohm throughole resistor for the LED
#4 x 3/8” wood screws (846-020) - 6x total: 4 to attach the GBS to the case, and 2 to attach the back plate to the case.
Momentary button - the “hole diameter” must be 10mm. The ones I bought were from a local store, but I’ve linked one on AliExpress that I think should work.
7x RCA female socket connectors - the “hole diameter” should be 5.6mm. In this post, I used 2 larger ones for the front, but I’ve since updated my design so that the 2 in the front panel, and the 5 in the back panel, are all the same size.
4x rubber feet to stick underneath the case
3D printed case

The Build

This process went smoother than the for the HDMI case. The one hitch was that I had two versions of the gbs board, a V4 and a V5, and I didn’t realize that they weren’t exactly the same size. I had to make the case a little smaller for the V4 used in this build. But apart from that, it was pretty smooth sailing.

I printed all the parts again:

This is the V4 board destined for this case:

I desoldered this header that shares the connections from the VGA output connector next to it:

I soldered a ribbon cable to the exposed pads. This time, I only needed the red, green, blue, along with three ground connections:

As before, I soldered a resistor to one of the legs of a LED:

One leg (green wire) is connected to D7, and the other (pink) is connected to ground:

For the reset button, I soldered two wires to the RST and ground pins:

The board was now ready to be put into the case:

Here’s the new back panel:

I bought a set of 20 RCA connectors off Amazon for the back panel for $14 ($0.70 each), which was a lot cheaper than the ones I had bought for the front ($2 each):

I screwed them into the back panel:

I oriented the ground tabs away from the power and VGA output connectors:

I soldered up the red, green, and blue connections. For the gbs-control, when YPbPr mode is enabled, red maps to Pr, green to Y, and blue to Pb:

For audio, I used another ribbon cable:

Next I installed the reset button and audio input jacks:

I slid the board into the case and screwed it into place in the four corners:

I soldered up the reset button:

Then screwed in the back panel:

And finally soldered the other end of the audio ribbon cable to the RCA input jacks, being careful to swap the ends so that left and right are correctly oriented:

All done, and looking mighty clean:

Here it is hooked up with regular RCA cables for YPbPr and audio going straight to my CRT:

Success!

Thoughts

Building this second case went a lot smoother than the first one, both because it was my second go-around, and also because I didn’t have to mess around with the VGA-to-HDMI adapter.

As with the first one, I would definitely make the case walls thicker so that they don’t bend when pushing in cables to connect them. Another thing I would consider doing is adding some artificial weight to the cases so that they don’t move around so easily.

Having said all that, I’m super happy with the final result for both cases. They look great in my setup – definitely a lot better than the exposed PCBs screwed into blocks of wood!

gbs-control Case for HDMI Out

2023-03-14T00:00:00+00:00

A little while ago, I built a gbs-control to up-scale up video signals from my old consoles to my LCD TV. I eventually built a second one to use as a down-scaler/transcoder to my CRT, and made a custom cable for it. The final missing touch for both these projects was a nice case. In this first post, I’ll go over how I designed, printed, and assembled a case for the HDMI out gbs-control. My next post will cover the second case.

Design

My first gbs-control is the one I use to up-scale RGB and YPbPr input signals to HDMI out:

As you can see, the PCB is screwed into a piece of wood I cut, and there’s a VGA-to-HDMI adapter hanging off the back, along with female RCA cables for stereo audio input that connect to the same adapter.

My goals for this case were:

Get rid of the ugly adapter hanging out the back. Inspired by this case design, I’d incorporate the adapter inside the case, and expose only the HDMI port out the back.
Add a reset button to the front. Sometimes the gbs-control gets in a weird state when disconnecting and connecting devices, and I’ve found it useful to be able to press the reset button on the NodeMCU board. Since this will be tucked in the case, I decided to expose it at the front of the case.
Display a status LED on the front. The gbs-control source code turns the NodeMCU on-board LED on to indicate when a proper signal has been detected, and off otherwise. I’ve found this useful as well, and similar to the reset button, decided to expose it on the front of the case since the NodeMCU would no longer be visible.

Case

After spending many hours (mostly learning) Fusion 360, here’s what I came up with for the case itself:

You can see that the front panel has holes for the gbs board’s inputs, along with a top row of holes for audio inputs, reset button, and the status LED. On the side is the HDMI “cradle”, used to hold the VGA-to-HDMI PCB in place against the back panel.

Note how the back panel is a separate piece. I decided to do this because I knew I’d want a different back panel for my second gbs-control. As it turned out, it also made it much easier to slide in the gbs board into the case.

Reset and Status LED

To be able to reset the gbs-control from the front panel, I bought a momentary switch:

Resetting the NodeMCU is done very simply by connecting the RST pin to ground:

For the status LED, it’s slightly more complicated. The NodeMCU’s LED state is connected to D0 (GPIO16), but it’s an “active low” signal, meaning that when the LED is on, D0 is low (GND), and when the LED is off, D1 is high (Vin). This is the opposite of what we need for our external LED. One solution would be to build an inverter circuit, or to use an inverter IC.

Instead, I decided to fix it in software by modifying the gbs-control code to output the non-inverted status on an unused pin, like D7, which is exactly what I did (you can see my changes here). The crux of the change was to modify the LEDON AND LEDOFF macros to also write the opposite level to D7:

#define LEDON                         \
    pinMode(LED_BUILTIN, OUTPUT);     \
    digitalWrite(LED_BUILTIN, LOW);   \
    pinMode(D7, OUTPUT);    /* NEW */ \
    digitalWrite(D7, HIGH); /* NEW */
#define LEDOFF                        \
    digitalWrite(LED_BUILTIN, HIGH);  \
    pinMode(LED_BUILTIN, INPUT);      \
    digitalWrite(D7, LOW); /* NEW */  \
    pinMode(D7, INPUT)     /* NEW */

So now, I could simply wire up a LED with one end connected to D7 (with a resistor in series), and the other to ground:

Parts

Here are all the parts I needed to build this:

A fully assembled gbs-control with the Node MCU positioned along the edge - see my post here.
VGA to HDMI adapter
A green LED
100 ohm throughole resistor for the LED
#4 x 3/8” wood screws (846-020) - 8x total: 4 to attach the GBS to the case, 2 to attach the HDMI cradle clamp, and 2 to attach the back plate to the case.
#4 x 1/2” wood screws (197-543) - 2x to attach the HDMI cradle to the back plate
Momentary button - the “hole diameter” must be 10mm. The ones I bought were from a local store, but I’ve linked one on AliExpress that I think should work.
2x RCA female socket connectors - the “hole diameter” should be 5.6mm. The ones I used in this post are actually larger, but I’ve updated my design to fit the more commonly available connectors from AliExpress that I’ve linked here.
4x rubber feet to stick underneath the case
3D printed case

The Build

As a novice to 3D printing and designing, I spent a fair bit of time iterating and printing tests to make sure everything fit:

Finally, with everything ironed out, I printed out the pieces for the case:

With the case printed, it was time to prep the gbs board. First I desoldered the VGA output connector off the back of the board:

Next up was getting the VGA-to-HDMI adapter PCB out of its case, and removing a few components off of it:

Using a hot air rework station, I carefully removed the audio input jack:

As well as the micro-usb power connector:

And finally, the VGA input connector:

With all that done, it was time to solder the adapter to the gbs board. Using ribbon cable, I soldered the R, G, and B pads, as well as ground:

And on the other side, the H-sync and V-sync pads:

The other end of the ribbon cable was soldered to the pins that sat behind the VGA output connector I removed:

Note that ground wire isn’t connected above. You’ll see it connected in later pics.

I soldered a red and white wire - for right and left audio, respectively - to the adapter where the audio input jack used to be:

On the other end, I soldered two ground wires for the audio signals:

You’ll see these four wires getting hooked up to the RCA input jacks at the front of the case later below.

To power the adapter, I soldered a yellow wire for 5V and black for ground to this component:

Then soldered the other ends to the gbs board:

I placed the gbs board into the case, and screwed in the four corners:

Next up were the status LED and reset button:

The other ends are connected to the NodeMCU board as shown below. The purple reset wire is tied to the RST pin (obscured in the pic), with the black ground wire next to it. For the LED, the green wire is tied to pin D7, and the brown to ground:

With the LED and reset buttons done, I screwed in the RCA audio input jacks:

Next, I placed the HDMI adapter into its cradle, and screwed it to the back panel:

I then screwed the back panel to the case:

Finally, I soldered the audio wires coming from the HDMI adapter to the RCA jacks:

And with that, I was done!

Here it is, with my N64 hooked up to it:

Thoughts

I have to say that I’m really happy with the way this case turned out! This was practically my first time designing something more complicated for 3D printing, and although it took quite some time, I learned a great deal and had fun doing it.

The case isn’t perfect. For instance, the walls are a bit thin at 2mm, and I can feel them bending a little when I push in cables into it, especially on the back. I’d definitely try making it a little thicker. But apart from minor things like that, overall, I’m quite happy with the result.

In the next post, I’ll go over how I made a similar case for my second gbs-control that I use for down-scaling/transcoding.