Give In To Nostalgia With a Retro Game And Watch

One of the earliest Nintendo products to gain popularity was the Game and Watch product line. Produced by Nintendo between 1980 and 1991, they are a source of nostalgia for many an 80s or 90s kid. These were those electronic handheld games that had pre-drawn monochrome images that would light up to make very basic animations. [Andrew] loved his old “Vermin” game as a kid, but eventually he sold it off. Wanting to re-live those childhood memories, he decided to build his own Game and Watch emulator.

The heart of [Andrew’s] build is a PIC18F4550 USB demo board he found on eBay. The board allows you to upload HEX files directly via USB using some simple front end software. [Andrew] wrote the code for his game in C using MPLAB. His device uses a Nokia 5110 LCD screen and is powered from a small lithium ion battery.

For the housing, [Andrew] started from another old handheld game that was about the right size. He gutted all of the old parts and stuck the new ones in their place. He also gave the housing a sort of brushed metal look using spray paint. The end result is a pretty good approximation of the original thing as evidenced by the video below. Continue reading “Give In To Nostalgia With a Retro Game And Watch”

ShakeIt – an interactive light game

Learning becomes interesting when you make it fun, interactive and entertaining. [Arkadi] built ShakeIt – an interactive game for the Mini MakerFaire in Jerusalem to demonstrate to kids and grownups how light colors are mixed. It is a follow up to his earlier project – Smart juggling balls which we featured earlier.

The juggling balls consist of a 6 dof sensor (MPU 6050), a micro controller, transmitter (NRF24L01+), some addressable RGB LED’s and a LiPo battery. An external magnet activates a reed switch inside the balls and triggers them in to action. The ShakeIt light fixture consists of an Arduino Nano clone, NRF24L01+ with SMA Antenna, buck converter, 74 addressable RGB LED’s, and a bluetooth module. The bluetooth module connects to a smartphone app.

[Arkadi] starts out by handing three juggling balls, each with a predefined color (Red, Green, Blue). When the ball is shaken, the light inside the ball becomes stronger. The ShakeIt light fixture is used as a mixer. It communicates with the balls and receives the value of how strong the light inside each of the smart balls is, mixing them up, and generating the mixed color.

The fun starts when the interactive game mode is enabled. Instead of just mixing the light, the Light fixture generates patterns based on how strong the balls are shaken. At first the light fixture shows all three colors filling up the central ball. The three contenders then fight out to get their color to fill up the sphere completely until only one color remains and the winner is declared.

The kids might be learning some color theory here, but it seems the adults are having a “ball” playing the crazy game. If you’d like to build your own shoulder dislocating ShakeIt game, head over to [Arkadi]’s github repository for the ShakeIt and the Juggling Balls. Check the video below to see the adults having fun.

Continue reading “ShakeIt – an interactive light game”

Mimimalist Arduino Gaming Platform

A pretty color LCD screen, an Arduino, a buzzer and a joystick is all you need for a minimalist gaming console for under $20. At least, that’s all [João Vilaça] needed to get this sweet version of Tetris up and running. He’s working on Breakout right now. His Breakout looks even better. See the postscript below for details.

It’s a testament to the current state of the hardware hacking scene that [João] could put this device together in an afternoon for so cheap, presumably after waiting a while for shipments from China. The 320×240 SPI color TFT LCD screen used to cost twice as much as this whole project did. And wiring it up is a simple matter of connecting this pin to that pin. Almost child’s play.

Equally impressive is the state of open source software. A TFT library from Seeed Studios makes the screen interface a piece of cake. [João] wrote his own sound and joystick code, and of course the Tetris gameplay itself, but it’d be much more than a few weeks’ work without standing on the shoulders of giants. Check out [João]’s Github for the project code and stick with us after the break for a demo video and some of our other favorite Arduino gaming hacks.

Continue reading “Mimimalist Arduino Gaming Platform”

Hackaday Prize Entry: A Pic32 Game Console

The official theme of the 2015 Hackaday Prize is to build something that matters. Solving the challenges facing the world is hard, and retro video games, despite what you read on Hackaday, do not matter.

That doesn’t mean there’s not space for the weird, esoteric builds out there; we have a best product prize that will dump $100k, a six month residency in the Hackaday Design Lab, and contacts with a lot of engineers with expertise in manufacturing. [Alex]’s extremely ow cost game console on a Pic32 is exactly what this prize category is looking for.

[Alex]’s project – XORYA – is based on the Pic32MX170F256, a chip that runs up to 50MHz, has 256kB of flash, and a full 64k of RAM. This is far beyond what the guys at Atari imagined back in the 70s, allowing the XORYA to have some amazing graphics.

Right now most of the build is dedicated to fleshing out the video system, and [Alex] has a great demo: rendering the Mandelbrot set in real time in 16 colors on an NTSC display with a resolution of 160×100. That’s a single-chip game console that’s right up there with the Uzebox, and a great example of the potential of the best product category for this year’s Hackaday Prize.


The 2015 Hackaday Prize is sponsored by:

Building A Modern Retro Console

There are a few dozen classic re-imaginings of classic game consoles, using hardware ranging from the ATMegas of the Uzebox to everyone’s favorite, stuffing some ROMs on a Raspi and calling it a day. You don’t necessarily learn anything doing that, which puts [Mike]’s custom game console head and shoulders above the rest.

The build started off as a plan for a Z80 computer with a dual ATMega GPU. He progressed far enough in the design where it would have been a masterpiece, but the inability to mill double-sided boards at home killed the design. Plans then moved on to an FPGA, then to an ATMega with the Analog Device AD725 PAL/NTSC encoder chip. That idea had a similar architecture to the Uzebox, but [Mike] wanted more power. He eventually settled on a PIC32 with the AD725.

This setup was capable of pumping out some impressive graphics, but for moving bits to a screen, you need DMA. [Mike] ran into a problem where the DMA timer runs at a maximum rate of 3.7 MHz. It’s a problem documented in a few projects, leading [Mike] to change his plan once again, this time to the STM32F4.

The bugs are worked out, and now [Mike] can stream a whole lot of pixels to a screen while still having some processing power left over to play a game. It’s a project that’s more than a year and a half old at this point, and so far he’s learned a lot.

Arduino Tetris on a Multiplexed LED Matrix

[Alex] needed a project for his microcomputer circuits class. He wanted something that would challenge him on both the electronics side of things, as well as the programming side. He ended up designing an 8 by 16 grid of LED’s that was turned into a game of Tetris.

He arranged all 128 LED’s into the grid on a piece of perfboard. All of the anodes were bent over and connected together into rows of 8 LED’s. The cathodes were bent perpendicularly and forms columns of 16 LED’s. This way, if power is applied to one row and a single column is grounded, one LED will light up at the intersection. This method only works reliably to light up a single LED at a time. With that in mind, [Alex] needed to have a very high “refresh rate” for his display. He only ever lights up one LED at a time, but he scans through the 128 LED’s so fast that persistence of vision prevents you from noticing. To the human eye, it looks like multiple LED’s are lit up simultaneously.

[Alex] planned to use an Arduino to control this display, but it doesn’t have enough outputs on its own to control all of those lights. He ended up using multiple 74138 decoder/multiplexer IC’s to control the LED’s. Since the columns have inverted outputs, he couldn’t just hook them straight up to the LED’s. Instead he had to run the signals through a set of PNP transistors to flip the logic. This setup allowed [Alex] to control all 128 LED’s with just seven bits, but it was too slow for him.

His solution was to control the multiplexers with counter IC’s. The Arduino can just increment the counter up to the appropriate LED. The Arduino then controls the state of the LED using the active high enable line from the column multiplexer chip.

[Alex] wanted more than just a static image to show off on his new display, so he programmed in a version of Tetris. The controller is just a piece of perfboard with four push buttons. He had to work out all of the programming to ensure the game ran smoothly while properly updating the screen and simultaneously reading the controller for new input. All of this ran on the Arduino.

Can’t get enough Tetris hacks? Try these on for size.

Repairing and Reviewing a 1976 PONG Clone

Hackaday alum [Todd] has been searching for an old PONG clone for the last two years. This variant is called, “The Name of the Game”. [Todd] has fond memories of playing this game with his sister when they were young. Unfortunately, being the hacker that he is, [Todd] tore the game apart when he was just 14 to build his own Commodore 64 peripherals. He’s been wanting to make it up to his sister ever since, and he finally found a copy of this game to give to his sister last Christmas.

After opening up the box, [Todd] quickly noticed something strange with the power connector. It looked a bit charred and was wiggling inside of the enclosure. This is indicative of a bad solder joint. [Todd] decided he’d better open it up and have a look before applying power to the device.

It was a good thing he did, because the power connector was barely connected at all. A simple soldering job fixed the problem. While the case was still opened, [Todd] did some sleuthing and noticed that someone else had likely made repairs to several other solder joints. He also looked for any possible short circuits, but everything else looked fine. The system ended up working perfectly the first time it was started.

The end of the video shows that even after all this time, simple games like this can still capture our attention and be fun to play for hours at a time. [Todd] is working on part 2 of this series, where he’ll do a much more in-depth review of the system. You can watch part 1 below. Continue reading “Repairing and Reviewing a 1976 PONG Clone”