Now that the power supply is ready I decided to move along to the HDMI port. I purchased this panel mount cable for the job.


I picked the Serial port on the back of the Dreamcast case and drilled two holes for the screws.


The cable fit in great.



This step ended up being much simpler than the power unit. The only thing that worries me at this point is getting all of the elements to fit into the case. I was hoping to use the AV Out port on the case to hold the HDMI connector but it ended up being too wide. The Serial fits the connector perfectly but it sits just beneath the power cord port. I might have to get creative with the arraignment of the AC adapter (and the other parts) when I begin installing them.

Well, that sums up the HDMI port step. The next step will be the installation of the USB cables. I’d like to fasten them to the controller ports on the front of the box. This will allow me to plug my USB controllers into the front which will help me to preserve the original look and feel of the case. To do this though I’m going to have to find some USB cables whose female ends will fit into the controller ports. I’ll probably have to buy a couple of test cables to find the correct one for me.

Power Supply

The first two phases of my project are complete. The emulator software is running on my Pi and I’ve prototyped the basic hardware elements. Now I’m moving on to the last and potentially hardest part of the project. Installing all of the project’s elements into my Dreamcast case. I say this is the hardest part because hardware work like this isn’t something I have much experience in. Fortunately I have the internet to help me out.

I’ve been considering for a while where to start with the case installation. I finally decided I would start with the power supply. One of my main goals with this project is to keep the Dreamcast case looking as natural as possible. I’d like to avoid making too many external modifications and instead try to use the existing features (e.g. ports for cable inputs) as much as possible. For this reason I have decided to use the existing power jack and mod it from the inside so I can pass the power from it into my hub’s AC adapter. The Dreamcast uses a standard AC cable that passes power into a board which, I assume, acts as an AC to DC power converter. Here’s a picture of board that came with my Dreamcast case:


The jack is designed to fit perfectly into the case. If I can make this work correctly it will really help to make the case look as natural as possible.

The first step is to remove the jack from the board. Desoldering it was fairly simple.


It’s kind of difficult to see in the picture but the jack has a couple of contacts at the back that extend down and were soldered onto the board. Fortunately they are long enough for me to work with. The jack continues to sit solidly into the case even with the board removed.


The next step is to open up the wall wart style AC converter that came with the powered USB hub. There aren’t any screws on it so I had to resort to brute force. I found a couple of sites that had how-to’s on opening these (you really can find anything on the internet…) and they recommended inserting a knife into the groove between the two halves of the case and using a hammer to crack open the case. It worked:


I clipped the wires that were running to the plug’s contacts and then removed the contacts.


Next I drilled a hole in the upper half of the case to route the wires.


Finally I soldered the wires to the Dreamcast AC jack. It looks like I pulled it off. When I plugged in the cable my hub powered up.


I’m glad it did. This was not an especially simple part of the project since soldering isn’t my greatest skill. Now that this part is done I feel I’ve made some real progress on the installation.

Time to plan for the next step.

Component Tests

Now that the software part of my project is done I’m moving on to the prototyping stage. I’m beginning by testing a couple of the components I purchased. The first is this powered USB hub. In addition to allowing me attach more devices to my Pi it can also power it. This will allow me to run a single power line into my case rather than two (one of the Pi and a second for a powered hub).


I plugged it in and it worked just fine. It successfully powered the Pi and the Pi was able to recognize devices I plugged into the hub.

The next item to test is my shutdown circuit. As anyone who has used a Raspberry Pi is aware it does not have a power button. To power it on you plug in a power source. Shutting it down is a bit more complex though since you have to send a shutdown signal to the OS and allow it to power down before removing the power. I don’t want to deal with that process once I get the Pi installed in my case so I ordered this shutdown switch from Mausberry Circuits. This circuit sits in between the power source and the Pi and connects to an external switch. When the switch is closed the circuit passes the power along to the Pi which allows it to boot. When the switch is opened the circuit sends a shutdown signal to the Pi via GPIO which tells it to shut down the OS. Once the shutdown process is complete the circuit removes power from the Pi. Ultimately I want to attach this circuit to my Dreamcast case’s power switch but for now I’ll just test it by wiring it to a breadboard.

Before I actually wire up the circuit I need to install the program that will watch the GPIO for the circuit’s shutdown signal. Mausberry Circuits provides a bash script that will do this using a while loop to pole the GPIO. However, I’ve heard some complaints that this continuously running loop can steal system resources. After some research I ran across this Python program. It is programmed to wait for the shutdown signal from the GPIO rather than polling the GPIO constantly to see if the signal has been sent.

I’ve installed the program and wired up the circuit. It’s time to test it.


And it works! When I close the switch the Pi boots. When I open the switch the shutdown signal is being interpreted correctly and power is removed when the shutdown is complete.

Two of the main items I chose to run my project are working like I wanted. Time to move on to the next step.

Software Prep

Last week I found out that my existing RetroPie image I setup on my Raspberry Pi model B wouldn’t work on my new model B+. Initially I thought I would just move forward with the hardware part of the project and wait to set up the software later on. I had assumed that since I couldn’t use my old image I would have to compile and install all the components manually. I did some research to see if I could find some instructions on setting thing up manually but discovered that the RetroPie project has a setup script that handles all this for you. I decided to give it a try before giving up and doing things manually.

I already had a base Raspbian image ready for my B+ so I slapped it on an SD card and ran the script. Unfortunately it didn’t work correctly for me. It failed about three or four times throwing errors about missing dependencies. Each time I installed the missing programs/library files and restarted. Finally it finished but when I booted up the system Emulation Station didn’t start. I’m sure the problem is with my image not the script itself. My B+ base image is a very stripped down installation of Raspbian designed to fit onto small SD cards. I’m assuming that it was lacking some of the dependencies that the script needed but might not have been programed to check for.

I decided to give a pre-created image one last try. I downloaded the card image offered by RetroPie and booted it up on my B+. Fortunately it worked. I guess it’s not always true that B images won’t work on B+ models. Either that of the RetroPie project has prepped this one so it would. Either way I’m happy. Especially since they had just updated their image so it included the latest version of Emulation Station. It is much more slick that the earlier version and it has more options.

The next step will be testing the individual parts of my setup and prototyping them.

SD Card Image Test

I’m now ready to begin constructing my emulator. The first step is to test my existing SD card image. When I initially used the RetroPie Project to create an emulator I downloaded an existing SD card image from the project’s home page and ran it from the Raspberry Pi model B that I had. If possible I wanted to use this existing image on the new Raspberry Pi model B+ I purchased. This also gave me a chance to test out a cool little item I ran across when buying parts for my emulator: an SD card extension cable.


My plan is to mount my Raspberry Pi to the plate at the bottom of the Dreamcast case. This extension cable will allow me to easily access my SD card. It has the added bonus of acting as an SD to SD micro adapter. I originally purchased a standard size SD card for the project since I was using my model B. However, the B+ I purchased has an SD micro slot. The cable I got has the male end sized to fit into my B+’s slot but the female end accepts standard SD cards. This will allow me to use my existing card rather than having to buy an SD micro card.

My first test was on the extension cable itself. I took an existing SD card image that I knew worked with the B+ and plugged it directly into the Pi. After confirming that it booted up and worked I plugged it into the Pi using the extension cable.


It worked perfectly. I’m glad it did because even though I purchased this cable off of Amazon it took about a month to arrive since it was shipped from China. I guess the don’t make many of these sort of things in the US. The only negative about the cable is that the Pi doesn’t keep a tight hold of the SD micro side. I think I can work with that though. When I had the Pi running I jiggled the cable and made sure that it wasn’t too lose to work. I actually had to start pulling it out of the slot before the connection to the SD card was lost. I should be able to find a way to secure the cable in the Pi when I get around to mounting it in the Dreamcast case.

After testing the cable I popped in the SD card with RetroPie already installed. Unfortunately it didn’t boot. Honestly, I’m not too surprised. I had read that SD card images created on model B’s don’t work in B+’s. I wanted to confirm this myself though. I guess I’ll be going ahead and installing all of the software from scratch after all. When it comes down to it this isn’t really going to slow down my progress much. I already have an SD card image with a standard Raspbian installation that I can use for now. I don’t really need to have RetroPie up and running while I’m doing the hardware work. As long as I can boot the Pi into a working OS I’m good to go.

Emulator Build Plan

I have pretty much all of the parts I need to build out my emulator now so I’m making some general construction plans. I’ve mentally divided the process up into three different phases:

The first phase will be prepping the software. The RetroPie Project, which is what I’ll be using to power my emulator, is a set of programs running on the Raspbian Linux distro. Ultimately I want to prep a clean installation of Raspbian and compile the emulator software manually but for now I think I’ll just use the existing image I already have. I don’t want to get too bogged down in setup and lose steam in the project as a whole. Besides, I can always rework the software side of the things after the hardware part is done. The only thing is I’ll have to test my existing SD card image to make sure it will work correctly on my new Raspberry Pi. The image was setup to work on the Raspberry Pi B but the new Raspberry Pi I bought to dedicate to the project is a B+.

The second phase will be prototyping the guts of the project outside of the case. At least one of the components requires soldering. Before committing to that I’ll be wiring everything up to a breadboard to work out any problems with my design.

If all goes well with my prototyping phase I can move onto phase three: installation in the case.

Building an Emulator

I created this blog to document an emulator project I’m working on. I’m going to try to install a Raspberry Pi powered emulator into a video game console case.

I got interested in building an emulator thanks to Mario Kart. My wife and I were looking around for some video games we could play together and decided to give Mario Kart Wii a try. Seeing all those references to old Mario games really got me in the mood to go back and play them. I had seen some info about the RetroPie project and decided to install it on my Raspberry Pi. The process itself was pretty simple since it only involved copying a provided image onto an SD card. I ordered this SNES style USB controller to use with it.

During the setup process I found a couple of sites describing how people had taking their Raspberry Pi and installed it into an NES case. I thought I would give this a try myself. I haven’t ever done any computer hardware working beyond replacing drives but I figured it will be a good way to learn.

I found a store near where I live that does some video game console repair and asked if they had any broken consoles. They didn’t have anything as old as an NES or Super NES but they did have a Sega Dreamcast. It’s not a Nintendo console but since I’m planning on using it to emulate non-Nintendo systems as well I figure it will work fine. Besides, it definitely has that retro look:


The case was pretty beat up but cleaned up fairly well. After stripping out the innards I found that it has a removable metal plate at the bottom:



This should work really well for fastening the components inside the case.

Now that I have the case I’m in the process of researching what it will take to build this out. I’ll update this once I’m ready to move to the next step.