Resurrected Entertainment

Beelink Gemini N41 as a simple gaming console?

January 13, 2019

I took a chance on this little Windows computer to solve a couple of problems:

  • I needed a portable Windows game platform
  • I needed something small with an appropriate number of USB ports (for joystick support)
  • I wanted it to be quiet with very few zero fans whirring and humming

Right out of the gate, I was impressed with this machine. Forget about gaming for a second, this is an excellent machine for those wanting a Windows “desktop” computer without wanting or needing a large machine or laptop. This machine is so small you could easily attach it to the back of most monitors. It has friendly set-up process that everyone in your family should be able to follow with little difficulty (assuming they’ve touched a Windows computer in the last 5 years). The performance is excellent for those wanting to do a little e-mail, web browsing, etc. I have an interest in using it for games, but nothing 3D or with extremely heavy weight processing requirements.


TurboGrafx 16 Homebrew SD Card

May 27, 2017

turbo-everdrive-v24A new device graces my doorstep yesterday: the Turbo Everdrive! For years, I have been using an old device that allowed me to load up home-brew software for the TG-16 via a parallel cable, and old version of Windows, and some obsolete software. With this new device, I can now simply copy the software onto the SD card and away I go. If you get the same device, be aware that it comes pre-set for a PCE device and not a TG-16 game console, so you will simply see a white screen until you toggle the tiny little switch on the right of the card. Also note, that you will need to create a “TGED” directory at the root of the SD card with the device’s operating system file copied into it.

Custom Pac-Man Themed Arcade

January 17, 2016

I began work on this unit several months ago. I am a father of three beautiful, very active young girls, and a husband to a gorgeous wife who likes to do renovations, so my free time is not what it use to be. Like so many projects nearing completion, I am overwhelmed by the sheer number of things which could be improved or done differently. Indeed, if I were going to do it all over again, I would do things differently and I imagine I would save a great deal of time, money, and headache. But that’s why people who love to build things dive right in, yes we make mistakes, yes the quality may not be top notch (but this is something that improves the more you build) and yes it may be expensive but the alternative is to sit on the sidelines and not do anything, or do it so slowly that it never gets finished.

This project had many pieces to it and it’s still not 100% finished. The first step was to source and figure out what the first set of materials was going to be. The project as of a few weeks ago looked something like this:

Arcade Mania!

Arcade Mania!

It consists of a themed wall panel, mounted flat screen high-definition television, an extended shelf, an X-Arcade Tank Stick, 257 individually addressable RGB LEDs on the inside edge of the panel, cup holders and a few decorations. The software driving the arcade is custom and consists of the primary server that controls the execution of the games, a mobile client application for selecting the games to play, and another server driving the decorative elements.

The first steps in designing the physical exterior for the arcade involved selecting appropriate materials. This process can vary a lot between projects, but I usually start by determining the theme and any special features or effects I want to add. For example, I knew that I wanted to place LEDs on the inside edge of the frame, so I needed to choose a material that was thick enough and could be easily cut into pieces that were less than an inch wide. I also needed that material to be easily mountable to the outside edge of the frame. I wanted the light from the LEDs to diffuse through the pieces on the board, thus creating an illuminated display. I bought a few 24×12 pieces of clear acrylic. Before doing that, I had researched some acrylic material that was built for optimal diffusion, but it turned out to be too expensive, so I chose to stick with clear acrylic.

The panel was assembled in a more complicated way than I would have liked. I was trying to reuse some plywood so instead of buying a piece of wood that was exactly the size I needed, I chose to assemble the pieces of plywood and glue them against a backing panel made of MDF. That worked, but it consumed considerably more time and there was fussiness around getting the edges lined up (due to the slight inaccuracies from various cutting tools). Anyway, after the pieces were glued, screwed, sanded, and trimmed, I painted the panel with a mat black undercoat. First using latex paint, then switching to oil based. I switched because the latex just wasn’t giving me the kind of mat finish I wanted. Whether or not the paint was acrylic or oil-based likely didn’t matter, it was probably the formulation for that brand that had the most impact on the finish. I happened to have oil based black on hand, so I used that rather than spending more money on a different brand of latex paint.


The board pieces needed to be designed before the acrylic material could be cut. I used Adobe Illustrator to design the pieces to be cut from 12×24 inch panels. The laser cutter available to me through the public library requires that the thickness of the lines in the design be less than 0.001 inches. When cutting acrylic be aware that the smell is quite unpleasant and should be ventilated. It takes about a day for most of it to dissipate from the cut pieces; I left it out in the garage overnight.


In order to transfer the Pac-Man like game board pattern to the painted base, I chose to tape the entire surface using painter’s tape. Following that, the acrylic pieces need to be laid out and traced, including all of the pellets from the pattern. Once traced, I cut them out with an X-Acto knife, and then created a special, circular drill bit to cut out the pellets. I chose to use those threaded wire funnels that come with light fixtures, but I needed to grind the bit for the edges to become sharp. Once the tape for the board pieces was cut out and removed, this exposed the flat black surface for paint.


The painting process was tedious and not very interesting, so I am not going to belabor it anymore. This whole approach worked, but it was very time consuming and error prone as the paint needed to be touched up in many areas due to bleeding. I would recommend taking a different approach, if you were to do something similar.


The gluing process was almost as tedious as the painting process since the glue could not be applied on top of the painted area as it would have been visible if it sat between the painted surface and the clear acrylic. It also wouldn’t have dried because the type of glue I used, Weldbond, requires exposure to air for curing. Instead, I applied the glue to the edges of the game board pieces (except for the pellets) using a needle. Ouch. The recommended approach above would have also made gluing the pieces to the board a lot easier as I could have used any kind of glue, rather than searching high and low for a specific kind of glue that was both strong and dried clear.

In retrospect, the result would have been faster and  higher quality if I had thought to paint the underside of the board pieces in the desired color first before gluing them to the board. This would have made the painting and the glue selection process a lot easier and is the approach I would take if I were to build another one.

I modded a couple of Ikea shelves to provide an extended platform so that my Tank Stick could sit comfortably, provide enough room for drinks and extra gamepads for other systems if necessary. It also provided some distance away from the screen so that players didn’t feel too close to it. I fastened them together using some latching hardware and strong clips so that the shelf could be folded if desired.

The panel was mounted flush with the wall using four metal clasps screwed into each corner. I wanted the arcade to have more of a built-in feel, encompassing the joystick shelf and the panel, so I painted a region around the arcade giving it more of a framed in look.

The television was mounted using a leveled bracket. I wanted it to be as close as possible to the panel and for the bracket to not be easily visible when standing next to the arcade on either side. I found a mounting system suitable for my needs and at a relatively cheap price at Ikea. When designing the panel in Adobe Illustrator, you must leave enough space for the bracket, otherwise you’ll be peeling off some acrylic pieces later and making some last minute cuts and holes.

I included a few characters in the design such as Pac-man and the ghosts: Inky, Blinky, Pinky and Clyde. The were cut from acrylic and then painted on their opposite sides using some colorful latex paints. The Home Depot sells small “tester” paint samples which are far too small for a wall, but perfect for small projects like this one. I painted the undersides of the characters (by this point I had caught on to the better approach) and mounted them on the wall next to the arcade using some crazy glue in gel form.

I also bought some black, textured plastic sheets from a plastics company called Canus Plastics. The sheets were about 1/8″ thick and could be cut with an X-Acto blade. After cutting them into strips, I used them as trim around the perimeter of the panel, which give it a more finished look and help to shield some of the light coming from the LED strips. The RGB LED strips were installed in a gap between the main panel and the edging. I bought a 5-foot length from a seller in China for a reasonable price. You can find them for sale in North America but the price can be much higher. The strip must be powered and driven by a micro-controller, so a little time must be spent on what to do with the wires. I have my arcade mounted on a wall that is finished on one side, so it was easy to hide a lot of the wiring for power, input devices, and video cables through the wall. If you were trying to install this on a wall that was finished on both sides, or which covered a foundation wall, then you may want to consider routing the cables through a hole and down the inside of the wall to another location.

There are many multi-cade system’s in the market these days. I like the look of some of them and many are closed systems where expansion and experimentation are difficult. However, I have never enjoyed navigating through the various menus and settings from the arcade screen itself. I did not want to have a keyboard and mouse installed when I need to select a game, or to try and use a joystick to navigate around. As a side note, you can use the X-Arcade buttons and a trackball as a mouse, if you’re interested. Anyway, basically I wanted the system to be simple and intuitive without all of the difficulties around emulation and desktops. I wanted my father to be able to use this system without needing to know what a ROM image was or what sort of commands were needed to load a game or fire up an emulator. I also wanted other players to be able to look through the games and see what’s available while others were using the arcade. I tried other front ends that try to abstract the underlying emulators like Maximus Arcade, but I found that their application was unstable (at the time) and required tedious tuning of mapping the underlying emulator to it’s execution scheme.

Once I knew I needed to write my own arcade front-end, I knew I wanted it to be a service that could accept commands from different clients running on different operating systems. The primary purpose of the server is to allow the user to play games, so it needed to run games made for hardware other than personal computers, such as the Super Nintendo Entertainment System (SNES), TurboGrafx 16 (TG-16), or an Arcade game. This requirement meant that the host platform (the machine and the OS running the server software) needed to emulate the other hardware, so it needed to be capable of running a game like Star Fox and the server software at the same time. The software emulating these other platforms are called, naturally, emulators and there are sometimes different program options available for the same system. The all have various technical limitations so some thought must be given as to which software you should use for your arcade.

The basic interaction model I wanted was a client application running on one or more mobile devices and a server installed on the machine running the arcade, which is just waiting to launch a game when one has been selected on the client. In addition, the server needed to be relatively easily to extend so that new emulation platforms could be added later. There are basically three primary pieces to the overall server platform:

  1. A database to hold and manage the information about the platforms, games, and the system.
  2. A server to drive the communication with the client, read content from the database, and to launch and control the emulation software.
  3. Scripts to wrap and control the life-cycle of the emulation software. These are executed by the service when a game has been selected on the client.

I chose to use Qt as the primary windowing, communications, and UI SDK in case I wanted to move the server application to Mac OS X or Linux at some point in the future. I also consider the API to be one of the best cross-platform APIs around for desktop applications. As it turned out, I ended up implementing platform specific functionality as some of the third-party software required particular bits of functionality in order for them to work together with the system I was building.

The service does several things, but the most important responsibilities are list below (in no particular order):

  • Provide the clients with a list of supported emulation platforms and games, including image content.
  • Provide some safe guards around multiple clients accessing and attempting to control the arcade at the same time.
  • Launch and terminate the emulation applications so that the arcade always returns to the same ready state when someone finishes playing a game.
  • Communicate with other services so that decorative elements can be synchronized with the games and platforms being used.

The client is an Android application, since I wanted it to work on the Ouya platform as well. The client presents the users with a simple connection method to the server (multiple servers are supported), platform selection, and game selection. I wanted to keep the client relatively simple so that game selection is fast and easy. As a minor feature, I wanted to the ability to take a screen shot of the currently running game, for high scores and other awesome feats, and then save it to the device so that it can be browsed and shared later.

There is a decorative component to the arcade that gives it a bit of bling and acts as an attract mode. The LED strips mentioned earlier require a micro-controller to control them. I wrote a service that runs on a Raspberry Pi and it receives commands from the game server when various events happen, such as launching a game. The commands are simple and usually contain a payload like an RGB color. This allows the server to send different colors for each platform when a game is selected.

Battletoads: Terra Tubes!

July 15, 2015

Without a doubt, this is one of the most difficult levels I have ever played for any game on the NES — incidentally, I don’t think I have ever finished it. Here is someone who played it through with barely a nick:

Zelda Mural: The Adventure!

May 10, 2015

I have recently finished a small Ode-to-Zelda techno-art project that involved some readily available construction materials like plastic moulding, foam board, and 3/16″ MDF board, as well as some less common parts like custom circuits, Pixel Blocks, and laser cut acrylic pieces. In the end, it took around 4 months to complete the project, but someone else who has access to more free time could complete it much sooner, and by not ordering parts from China on eBay (it usually took 4-5 weeks to arrive). It was very enjoyable and a good learning experience even though the result is not something I would want to sell, due to the lack of polish. Here is a photo of the scene in the game and the finished project:

It’s a representation of the first cave you come across in Nintendo’s pilot Legend of Zelda game. The scene illuminates with the flick of a switch on the left side of the frame. There is a flickering fire effect which is implemented via a couple of small circuits (5V) that are each driven by an Atmel ATTiny13-20PU 8-bit microcontroller and a series of low-power LED strips (12V). Since I wanted to drive the circuit with only one power supply, the project needed a small power regulation circuit to drive both loads.

Programming the flickering fire effect using the Atmel microcontroller can be tricky because it lacks a floating point unit and only has 1 KB of program space. This means that you can’t use decimal calculations lest the compiler pull in routines for floating point emulation, which result in a program too large to fit in the microcontroller. The solution was to employ a fancy sounding algorithm called a Linear Congruential Generator, which essentially provides the required randomness via a calculation that makes clever use of prime numbers. Early computers used this technique to achieve pseudo-random number generation at low computational cost.

The borders of the frame were printed using the graphics tiles copied from the game; the panels were sealed with rubberized paint spray and raised in a 3D effect using foam board, which itself has been painted and sealed for added strength and a semi-gloss, darker look. The letters have been laser cut from white acrylic using the font from the game; just a warning if you laser cut acrylic, it generates a nasty smell that is more than likely toxic, so get those laser cut pieces out in the open as soon as possible. I found the smell to dissipate after a few hours in the garage.

Keyboard or Joystick: You Decide!

April 19, 2015

For those who don’t like playing DOS games using their keyboard, there is a nifty little software package called “JoyEmu“. It allows you to map keyboard keys to joystick input (2 or 4 button joysticks), along with the axial directions. It has a great configuration utility to help you set this up, and allows you to save keyboard mappings and joystick assignments as files. These files can be loaded manually alongside a batch file wrapper, if you desire,  so that playing your favourite games is quick and easy. It also allows for mappings to your mouse and a truck load of documentation; you really couldn’t ask for a better utility of this type!

Alone in the Dark for DOS

I have been playing that game recently and researching different aspects of its history; I ran across a thread on the ScummVM message board that said you can enter the text “benjaminyaelfred” at the copy protection screen and it will let you play the game, if you don’t have the code book that came with the game. The last part of the text “yaelfred” is from one of the original artists of the game, Yaël Barroz, and the original engine programmer, Frédérick Raynal.

8-bit Christmas

December 27, 2014

I have recently finished the book entitled “8-bit Christmas” by Kevin Jakubowski. It was a very enjoyable read with many similarities to my childhood along with many differences; it was fun to read about another person’s perspective on that period. My brothers and I all wanted a Nintendo after we played one at a relative’s house during the Christmas break. The trouble being, of course, that we would have to wait until next Christmas to get one. Luckily, I had a birthday in July!

Supercharge Your Life!

December 21, 2014

The Arcadia (or Starpath) Supercharger is a device which allows you to play beefed up games on your Atari 2600. Games ship on cassettes and are loaded onto the system via an audio cable that connects to a tape player. The other way is to hook up the cable to your computer and pipe a sound file to the device. For 2K and 4K games, you can use a tool called “makewav” which encodes an Atari 2600 binary ROM file into a WAV encoded audio file. I have “ported” the utility so that it can be built on Mac OS X; I use the term loosely since I had to do very little to get it to build. You’ll want to run it like this once it is built:

$ makewav -ts atarigame.bin

Which will produce a WAV file of the same name + a “.wav” extension. You may also want to locate a CD called Stella Gets a New Brain, which is a complete compilation of the games released for the Supercharger. If you decide to rip the audio tracks to an MP3 file, be sure to use a very low compression for maximum fidelity and open the file in a piece of software like Audacity to make sure that the audio is duplicated on both channels; this is because your laptop has stereo output but the Supercharger only accepts mono. You will likely need an interface adapter which converts your stereo signal to a mono signal, but a better way might be to simply find yourself an old stereo audio cable, cut it and the wire going to the Supercharger, and solder one signal line from your stereo cable + ground to the mono cable’s signal line + ground. While attempting to use my Supercharger, I found the noise introduced by the adapter and the oxidized cable from the 30+ year old device was causing a lot of interference, after I cut out the middle man things worked perfectly.

Once that is done, try The Official Frogger by Sega — it’s awesome!

DOS Software Development Environment

December 12, 2014

I love writing software for Microsoft’s DOS. I didn’t cut my teeth programming on this platform, that was done on an Atari 800 XL machine. However, it was on this platform that I was first exposed to languages like C and Assembly Language, and thus sparked my torrid love affair for programming which lasts to this day. The focus of this post is about DOS software development and remote debugging.

If you have done any development for iOS or Android, then you have already been using remote debugging — unless you are some kind of masochist who still clings to device logging even when it is not necessary. The basic concept is that a programmer can walk through the execution of a program on one machine via the debugger client, and trace the execution of that program through a debug server running on another machine.

The really cool part of this technology is that it’s available for all sorts of platforms, including DOS! Using the right tool chain, we can initiate a remote debugging session from one platform (Windows XP in this case), and debug our program on another machine which is running DOS! The client program can even have a relatively competent UI. For this project, the toolset we are going to use is available through the OpenWatcom v1.9 project, and the tools found inside that wonderful package will allow us to write 16-bit or 32-bit DOS applications and debug them on an actual DOS hardware target! In addition, we can apply similar techniques but this time our server can be hosted within a customized DOSBox emulator, which is also really cool since it allows you to debug your code more easily on the road.

The first scenario is the one I prefer, since it is the faster of the two approaches, but before we get into the details how to set this up, let’s consider some of the broader requirements.

You’ll need two machines for scenario number one. The DOS machine will need to be a network enabled machine, meaning it should have a network interface card and a working packet driver. I would recommend testing your driver out with tools like SSH for DOS, or the PC/TCP networking software originally sold by FTP Software. In order to use the OpenWatcom IDE, you’ll need a Windows machine. I use VirtualBox and a Windows XP Professional installation; my host machine is a Macbook Pro running Max OS X 10.7.5 with 4 GB of RAM.

The second scenario involves using the same virtual machine configuration, but running the DOSBox emulator within that environment. You will need to use this version of the DOSBox emulator, which has built-in network card emulation. They chose to emulate an NE2000 compatible card for maximum compatibility, and also because the original author of the patch was technically familiar with it. After installation, you’ll need to associate a real network card with the emulated one, and then load up the right packet driver (it comes bundled with the archive).

For reference, the network interface card and the associated packet driver I am using on the DOS machines is listed below:

  • D-Link DFE-538TX

These are the steps I have used to initiate a remote debugging session on the DOS machine:

  • Using Microsoft’s LAN Manager, I obtain an IP address. For network resolution speed and simplicity, I have configured my router to assign a static IP address using the MAC address of my network card; below is the config.sys and autoexec.bat configurations for my network
    rem - By Windows 98 Network - NET START WORKSTATION
    rem - By Windows 98 Network - NET LOGON michael *
  • Load the D-Link Packet driver
  • I load a TSR program, which I have built from a Turbo Assembly module, which can kill the active DOS process. I do this because the TCP server provided with OpenWatcom v1.9 does not exit cleanly all of the time, and will often lock up your machine. In the end, your packet driver may not be able to recover anyway, and you will need to reboot the machine, unless you can find a way to unload it and reinitialize. Incidentally, the packet driver does have a means to unload it, but when I attempt to do so after the process has been killed, it reports that it cannot be unloaded. The irony of the situation will make you laugh too, I am sure.
  • Navigate to my OpenWatcom project directory, then I start the TCP server which uses the packet driver and your active IP address to start the service. The service will wait for a client connection; in my case, the client is initiated from my Windows XP virtual machine using the OpenWatcom Windows IDE.
    • Ensure that the values for “sockdelay” and “datatimeout” are both “9999”, and make sure the “inactive” value is “0” in your WATTCP.CFG file. Even though the documentation says that a value of “0” for the “datatimeout” field is essentially no timeout, I did not find that to be the case. The symptom of the timeout can be onbserved when you launch the debug session from the OpenWatcom IDE and you see the message “Session started” on your DOS machine, but then the IDE reports a message the the debug session terminated.

These are the steps for the DOSBox emulator running within the Windows XP guest installation:

  • Install the special network enabled build of DOS Box mentioned above;
  • Fire up the NE2000 packet driver  (c:\NE2000 -p 0x60);
  • Start the TCP service
    • Note that I configured a static IP address on my router using the Ethernet address reported by the packet driver. You should not be able to ping that address successfully until the TCP server is running in DOSBox. While the process worked, I found the time it took for the session to be established and the delay between debug commands to be monstrously slow (45-90 seconds to establish the connection, for example) and as a result, made this solution unusable.

While working on a project, it can be really useful to create the assets on a modern machine and then automatically deploy them to the DOS machine without needing to perform a lot of extra steps. It can also be useful to have the freedom to edit or tweak the data on the DOS machine without needing to manually synchronize them. The solution which came immediately to my mind was a Windows network share. This is possible in DOS via the Microsoft LAN Manager software product and has been discussed before in a previous post.