C64 Keyboard Emulation Over Serial

January 14, 2017 by Lewin Day 14 Comments

There’s a lot of reasons you might want to emulate the keyboard on your Commodore 64. The ravages of time and dust may have put the original keyboard out of order, or perhaps you need to type in a long program and don’t fancy pecking away with the less-than-stellar feedback of the standard keys. [podstawek] has come up with the solution: a Commodore 64 keyboard emulator that works over serial.

It’s a simple concept, but one that works well. A Python script accepts incoming keypresses or pre-typed text, then converts them into a 6-bit binary code, which is sent to an Arduino over the serial connection. The Arduino uses the 6-bit code as addresses for an MT8808 crosspoint switch.

MT8808 Functional Diagram from Datasheet

The MT8808 is essentially an 8×8 matrix of controllable switches, which acts as the perfect tool to interface with the C64’s 8×8 keyboard matrix. Hardware wise, this behaves as if someone were actually pressing the keys on the real keyboard. It’s just replacing the original key switches with an electronic version controlled by the Arduino.

[podstawek] already has the setup working on Mac, and it should work on Linux and Windows too. There’s a little more to do yet – modifying the script to allow complex macros and to enable keys to be held – so check out the Github if you want to poke around in the source. Overall it’s a tidy, useful hack to replace the stock keyboard.

The C64 remains a popular platform for hacking — it’s even had a Twitter client since 2009.

Atari Now Runs Java, Thankfully Doesn’t Require Constant Updates

January 2, 2017 by Lewin Day 24 Comments

Java Grinder is a tool that compiles Java programs to run on platforms like microcontrollers and consoles, by outputting native assembly code and using APIs to work with custom hardware like bespoke graphics and sound chips. Amongst other hardware, Java Grinder supports the Commodore 64, which uses a variant of the 6502 CPU. [Michael Kohn] realized the Atari 2600 shares this processor, and figured he’d get started on making Java Grinder work with the Atari by expanding on the C64 work done by [Joe Davisson]. Together, they brought Java to the Atari 2600 and made a game along the way.

According to [Michael], parts of the project were easy, as some Java routines compile down into as little as 1 or 2 instructions on the 6502. Other parts were harder, like dealing with the graphics subsystem, and modifying Java Grinder to output 8-bit bytecode to fit into the Atari’s tiny 4K ROM limit. Even with this tweak, they still couldn’t fit in a game and title screen. In the end they relied on bank switching to get the job done. [Joe]’s game is pretty solid fare for the Atari 2600 — blocky graphics and bleepy sounds — and they’ve uploaded it to the page so you can try it yourself in an emulator.

At the end of the day, porting Java code to a system with 128 bytes of RAM probably isn’t going to be particularly useful. However, as a coding exercise and learning experience, there’s a lot of value here in terms of building your skills as a coder. Other such experiments have shown us Java running on other unexpected devices, like the Sega Genesis or the MSP430. Video after the break.

Continue reading “Atari Now Runs Java, Thankfully Doesn’t Require Constant Updates” →

Slack, Backwards Compatible With 1982

November 29, 2016 by Brian Benchoff 13 Comments

Slack is great, but there are a few small problems with the current implementations. There isn’t a client for Palm, there isn’t a client for the Newton, and there isn’t a client for the Commodore 64. The last of these severe oversights was recently fixed by [Jeff Harris]. He built a native Slack client in 6502 assembly for the Commodore 64.

When dealing with network applications and the C64, the first question that comes to mind is how to talk to the outside world. There are C64 NICs, and ESP dongles, but for this build [Jeff] turned to the C64 Userport. This card edge combination of a serial and parallel port allows the C64 to talk to anything with RS-232, and with a simple adapter, [Jeff] got his old computer talking to a Raspberry Pi connected to the Internet.

The C64 Slack client itself is written in 6502 assembly, and features everything you would expect. The Pi is required to talk to the Slack API, though, and uses a NodeJS app to translate the bits from the C64 to something the API can understand.

Does it work? Of course it does. Slack is just text, after all, and there doesn’t seem to be any PETSCII weirdness here. You can check out a video of the build in action below.

Continue reading “Slack, Backwards Compatible With 1982” →

Building Your Bots The 1980s Way

November 25, 2016 by Jenny List 29 Comments

There are many kits available to today’s hobbyists who wish to try their hand at producing simple computer-controlled robots. Small concoctions of servos and laser-cut acrylic, to which boards such as the Arduino, Raspberry Pi, or Beaglebone can easily be fitted.

In the 1980s though this was a market that was yet to be adequately served. The sheer size of the many 8-bit machines of the day meant they could not be incorporated in your robot, and interfacing to them was a bit more challenging than the easy-to-use GPIOs of their modern counterparts. Then the mechanical hardware of a small robot was something that had not been easily and cheaply packaged for the constructor, making building a physical robotic platform a significant task in itself.

[Jeffery Brace] and [Evan Koblentz] write for IEEE Spectrum about their work at New York City’s World Maker Faire back in October, making a pair of small robots using only components and computers available in the 1980s.

Charlie the robot

[Charlie] is a robot based on the Capsela construction system, a toy consisting of interlocking plastic spheres containing different functions of shafts, gears, and motors. There was a Robotic Workshop kit for Capsella that featured a Commodore 64 interface, and it is through this means that [Charlie]’s three motors are controlled. It includes a ROM that extends Commodore BASIC with extra commands, which allow the robot to be easily controlled.

Artie the robot, with Dacta box in foreground

Meanwhile [Artie] is a Lego robot, using the Dacta TC Logo, a kit sold for the educational market and available at the time with interfaces for the PC and the Apple II. They had a Dacta control box but not the Apple II card to go with it, so had to make do with a functional replica built on a prototyping card. As the name suggests, this was programmed using Logo, and came with the appropriate interpreter software.

Both robots are reported to have been a success in terms of working in the first place, then demonstrating the 1980s technology and providing entertainment and engagement with the faire’s visitors.

We have covered numerous Lego robots over the years, as a search of our site will confirm. But this is only the second time we’ve featured a Capsela project, the first being this Arduino rover from 2011. [Mike] mused why we don’t see Capsela more often, and the same sentiment is true today. Do you have a Capsela set gathering dust somewhere that could make a robotic project?

Via Hacker News.

Commodore Home – Your Smart Home For 1983

November 20, 2016 by Brian Benchoff 14 Comments

The Internet of Things is a horrific waste of time, even though no one knows exactly what it is. What would make it better? Classic Commodore gear, of course. Now you can run your smart home with a Commodore 64 and Commodore Home, the newest smart home framework from [retro.moe].

Commodore Home comes with the standard smart home features you would expect. The home lighting solution is a dot matrix printer, a few gears, and string tied to the light switch. Activate the printer, and the lights turn on and off. Brilliant. Multiple light switches can be controlled by daisy chaining printers.

Security is important in the smart home, and while the intruder alarm isn’t completely functional, future versions of Commodore Home will dial a modem, log into a BBS, and leave a message whenever an authorized person enters your home.

All of this is possible thanks to advances in UniJoystiCle technology, also from [retro.moe]. This device takes a standard ESP8266 WiFi module and turns it into a smartphone-to-joystick port bridge for the Commodore 64.

Unlike every other piece of IoT hardware being sold today, Commodore Home won’t stop working when the company behind it goes belly up; Commodore has been dead for twenty years already. You can grab all the software for Commodore Home over on the Githubs, or you can check out the video below.

Continue reading “Commodore Home – Your Smart Home For 1983” →

Computer Emulation In The Manner Of A Turducken

November 2, 2016 by Jenny List 39 Comments

If you come from somewhere with a tradition of eating a meal of roast turkey or goose to celebrate Christmas, Thanksgiving, or other holidays, then maybe you’ve encountered the three-bird roast, or Turducken. A deboned duck is stuffed with a deboned chicken, and in turn the combination is stuffed into a turkey All the gaps are filled with sausage meat stuffing, and the resulting combination is roasted for a serious meat-fest. Vegetarians, please look away.

It’s something of an excess of poultry, but the three-bird roast is a delicacy that definitely works. We’re not so sure about the link that prompted this journey into celebration poultry dishes by reminding us of a turducken, but we’ll leave the verdict to you the reader. Someone has created an unholy turducken-style chain of emulators that delivers a Sinclair ZX Spectrum on a Linux machine via Windows, DOS, and the Commodore 64. If it had its own word like the poultry dish it might be a Linwindoscomtrum, but let’s not go there.

The linwincomtrum in all its glory. — The linwindoscomtrum in all its glory.

So how have they done it? First, they took Lubuntu, and installed WINE. (OK, Wine Is Not an Emulator, we know that, but go with the story for a moment) Then they installed DOSBox under WINE for a DOS command prompt, and ran no$C64, a Commodore 64 emulator. On that they ran the c642spec Sinclair ZX Spectrum emulator, and finally arrived in a ZX BASIC prompt.

The author does make the point at the start of the write-up that it’s a waste of ten minutes, but even though the result is an overly complex way to slowly emulate an archaic home computer on a modern one we’ll still give them ten out of ten for the effort.

Incidentally, the author does not identify themself and there is little clue in the form of the rest of the site to identify them, so unusually for a Hackaday piece we can not give credit where it is due. We do however salute the anonymous emulator pilot for their glorious folly.

If the ZX piques your interest, we’ve featured a coding tutorial for the rubber-keyed British micro in the past, as well as a later one having a tape-drive-ectomy, and of course the hellzxschreiber amateur radio Hellschreiber receiver.

Via Hacker News. ZX Spectrum image: Bill Bertram [CC BY-SA 2.5], via Wikimedia Commons.

The Immersive, VR, Internet Of Things Unicycle

April 27, 2016 by Brian Benchoff 13 Comments

Want something that you’ll try for fifteen minutes before realizing it’s extremely stupid and has limited utility before throwing it in the back of a closet to eventually sell at a yard sale? No, it’s not the Internet of Things, but good guess. I’m speaking, of course, about unicycles.

[retro.moe] is a unicycle and Commodore 64 enthusiast, and being the enterprising hacker he is, decided to combine his two interests. This led to the creation of the Uni-Joysti-Cle, the world’s first unicycle controller for the Commodore 64, and the first video game to use this truly immersive, better-than-an-Oculus unicycle controller.

The build began with the creation of Uni Games, the unicycle-enabled video game for the Commodore 64. This game was coded purely in 6502 assembly and features realistic physics, cutting edge graphics, and two game modes. It’s available on [retro.moe]’s site for the C64 and C128 jin PAL and NTSC formats.

Every game needs a controller, and for this [retro.moe] turned to his smartphone. A simple Android app with a few buttons to send up, down, left, and right commands to an ESP8266 chip attached to the C64’s joystick connector.

While a smartphone transmitting controller commands may seem like a vastly over-engineered joystick, there’s at least one thing a smartphone can do that a joystick cannot: poll an accelerometer. When the joystick senses movement, it transmits movement commands to the video game. Strap this phone to the pedal of a unicycle, and it’s the world’s first unicycle controller for a video game. Brilliant, and [retro.moe] can ride that thing pretty well, too.

Thanks [nfk] for sending this one in.

Continue reading “The Immersive, VR, Internet Of Things Unicycle” →