Adding Character To The C64

June 8, 2017 by Lewin Day 5 Comments

The venerable Commodore 64, is there anything it can’t do? Like many 1980s computer platforms, direct access to memory and peripherals makes hacking easy and fun. In particular, you’ll find serial & parallel ports are ripe for experimentation, but the Commodore has its expansion/cartridge port, too, and [Frank Buss] decided to hook it up to a two-line character LCD.

Using the expansion port for this duty is a little unconventional. Unlike the parallel port, the expansion port doesn’t have a stable output, as such. The port contains the data lines of the 6510 CPU and thus updates whenever RAM is read or written to, rather then updating in a controlled fashion like a parallel port does. However, [Frank] found a way around this – the IO1 and IO2 lines go low when certain areas of memory are written to. By combining these with latch circuitry, it’s possible to gain up to 16 parallel output lines – more than enough to drive a simple HD44780 display! It’s a testament to the flexibility of 74-series logic.
It’s all built on a C64 cartridge proto-board of [Frank]’s own design, and effort was made to ensure the LCD works with BASIC for easy experimentation. It’s a tidy mod that could easily be built into a nice enclosure and perhaps used as the basis for an 8-bit automation project. Someone’s gotta top that Amiga 2000 running the school district HVAC, after all!

Building A Replica Final Cartridge III

May 20, 2017 by Lewin Day 25 Comments

The Commodore 64 was the computer of the 8-bit era, and remains the highest selling computer of all time. In addition to disk and tape drives, it also had a cartridge interface. A popular extension cartridge was the Final Cartridge III, which offered a variety of disk utilities and a GUI. [Greisi] was in possession of a no longer functional cartridge, and decided to reverse engineer the device.

[Greisi] started by desoldering all the ICs and mapping out a schematic for the board. The design centers around common parts for the era, such as a UV-erasable EPROM and some 74-series logic. [Greisi] decided to then modernise the design and make some improvements. Adding a fuse should avoid the cartridge catching on fire, and a bunch of decoupling capacitors on all the ICs should reduce noise. A FLASH chip is used instead of the old school UV-erasable part, which makes writing to the device much easier.

It’s a great build performed in a stunningly tidy workshop, and [Greisi] has provided the schematics and PCB designs to the public here. That means that many more users can build their own Final Cartridge III without having to hunt for original hardware which is growing scarcer. You can learn more about the Final Cartridge III on Wikipedia.

We’ve actually seen the Final Cartridge III before – used in this blinkenwall installation. Video below the break.

[Thanks Adrian!]

Continue reading “Building A Replica Final Cartridge III” →

Flappy Bird Is The New “Does It Run Doom?”

March 10, 2017 by Donald Papp 57 Comments

Back in 2014 [Johan] decided to celebrate BASIC’s 30 50 year anniversary by writing his own BASIC interpreter. Now, a few years later, he says he feels he has hit a certain milestone: he can play Flappy Bird, written in his own version of BASIC, running on his own home-built computer, the BASIC-1.

Inside the BASIC-1 is an Atmel XMega128A4, a keyboard from a broken Commodore 64, a joystick port, a serial to TV out adapter, and an SD card adapter for program storage. An attractively laser-cut enclosure with kerf bends houses the keyboard and hardware. The BASIC-1 boots into BASIC just like many of its home computer counterparts from the 80s.

Continue reading “Flappy Bird Is The New “Does It Run Doom?”” →

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” →

Refurbishing Six Commodore 64s In Parallel

August 7, 2016 by Gerrit Coetzee 12 Comments

[Drygol] found himself with six Commodore 64’s in various states of disrepair. Because batch work is often more efficient, he detailed the process of restoring all of them in parallel in this one-, two-, three-part series.

The first step was to whiten the cases. Old cases turn yellow from the degradation of the fire retardant additives in the plastic. The proven method to fix this is with a paste called Retr0bright. [Drygol] used hair bleaching paste which is very similar. The cases came out nicely whitened from their treatment.

Next he repaired the keyboard PCB and whitened the keys as well. Drinking was involved, but it all came out okay. The circuit boards were cleaned and inspected. There were a few corroded spots, broken chips, and bad solder joints to be repaired. A few common mods were also installed.

In the final part of the series two of the C64s have SD cards installed into them. A few interesting fixes were done to repair broken plastics. Lastly the two worst cases were painted. In the end [Drygol] found himself with six perfectly working and attractive C64s. Who know’s what he’ll do with them, but we all know that was not the point.