DIY Cynthcart for Commodore 64

I’ve wanted to create my own cartridges for the C64 for a while now. I have a few old Commodore cartridge games like Clowns and Kickman that would better serve me as, say, a diagnostic cartridge or Cynthcart. These boards are ASSY 326173-01 and seem to be common so you should be able to pick one up cheap.




The first hurdle was burning EPROMs. I took a chance on eBay and bought a TOP 853 universal programmer. It was shipped from China and arrived in about 3-4 weeks. I was struggling to get it working over USB on my Mac to Virtual Box to a Windows XP VM but I figured it out (hint: disable USB 2.0 (EHCI) Controller for the VM).

I erased the chips using a Pocket Purifier battery operated hand held UV light that I picked up from Amazon. It took anywhere between 30 minutes to 2 hours (most 1 hour) to completely erase the EPROMs. I’m using 27c256 (32 kilobyte) chips which are 28 pins. Cynthcart is an 8 kilobyte ROM so I copied the ROM four times on the chip– only one of the copies will be used. You could add four different 8k ROMs and select one with dip switches on the higher address lines (A13 and A14 I believe).

The C64 cartridges I’m going to use have 24 pin chips on them. This presents a problem. Luckily the pinout is almost the same that it’s rather easy to reroute the pins. I followed the C64 ROM guide on Symlink.dk which had the pinout from the board to the new socket.

24 to 28 pin EPROM

You’ll need to desolder the old chip at U1. I used a 28 pin socket, bent out pins 1, 2, 20, 23, 26, 27, 28 on the socket. I soldered in small wires (from an 80 pin IDE cable) into the board on pins 18, 21, 24. See the schematic above to know which pins connect to which wires. Pay attention to the pin numbering– it will get confusing with the socket on top with different pin numbers. Also, make sure you orient the socket and the chip in the right direction. Pin numbers start upper left of the chip notch, down to bottom left, then to bottom right, then up to upper right.

There are 5 “jumpers” (solder bridge pads) on the board. This forum post on Lemon 64 was a great help but turned out not to work for me 100%. I opened J2, J5 and closed J1, J3, J4. The EPROM is too tall for the case to close completely but the screw will hold it together enough.

There you have it. This should work for any 8 kilobyte game that maps to $8000. Best part is since you’ve used a socket, the software can be easily swapped with something else. Enjoy!

C64 USB Keyboard works with iPad


Just a follow up to the C64 USB keyboard Arduino project that I made last week. I was curious if it would work on the iPad using the iPad Camera Connection kit. So I tried it out and was greeted with the error “Cannot Use Device” and “The connected USB device is not supported.” I dismissed the window and tried anyway and it worked! I was able to type in any application.

Any application that is except the Manomio C64 emulator on the iPad/iPhone. I doubt that any USB keyboard would work there, not just mine. Maybe support for USB keyboards could be added?

Commodore 64 Keyboard Gets The USB Treatment Thanks to Arduino

Recently I’ve been repairing a batch of broken Commodore 64’s that I scored on eBay for cheap. Out of the repairs, two boards were beyond hope but still had some usable parts on them so motherboards became donor boards. That left me with a couple empty cases and keyboards so I decided to make a Commodore 64 USB keyboard.

There’s already a nice product called Keyrah that does just this (plus a lot more) and I recommend you checking it out as it adds Amiga keyboard and joystick support.

But if you’re like me and want the challenge, I decided to go the maker route.

First, I searched for any such projects– no sense in re-inventing the wheel. I found a project by Mikkel Holm Olsen called C64 USB Keyboard. It used an Atmel ATMega-8 chip which I’ve learned is very similar to Arduino’s 168/328P chip. It might work but with some modifications– beyond my skill set today. I shelved this project and continued.

The keyboard is basically an 8×8 matrix keypad. There’s already a keypad library for Arduino. A couple of things that I discovered while using this library. One, don’t use pin 13 with the C64 keyboard. It’s probably because of the built in resister and LED that causes the pull ups to not work. An outside pull up might fix this. Two, the library only supports single keypresses. This is a bummer since you often will press two keys (i.e. the shift key, control, etc). But I worked around it. I put together a quick harness that will connect the Commodore 64 keyboard to the Arduino, aligning the rows and columns to the right pins. I like to make my projects the least destructive way so I use a lot of tape, jumpers and breadboards.

Getting the Arduino to talk USB makes use of the V-USB library which has been ported to Arduino. I really like this implementation because it’s all handled by the Arduino and needs very little passive glue on the outside to make it work. Below is a diagram of how to hook up USB to the Arduino. The values on the diodes are pretty strict and must be 3.6V 500mW zener diodes (although I hear 250mW is better). More information can be found in the V-USB documentation.

I made a small change to the V-USB code and moved the USB data (-) from Arduino pin 4 to pin 3– just edit usbconfig.h inside the UsbKeyboard library. I also commented out the optional connect/disconnect on pin 5 because I simply don’t have the pins to spare! Connected, the inside looks like this.

Commodore 64 USB Keyboard Inside

Commodore 64 USB Keyboard Arduino

Arduino V-USB Glue

The pin mapping goes like this:
C64 Pin Arduino Pin
Column 0 = 13 -> 4
Column 1 = 19 -> 5
Column 2 = 18 -> 6
Column 3 = 17 -> 7
Column 4 = 16 -> 8
Column 5 = 15 -> 9
Column 6 = 14 -> 10
Column 7 = 20 -> 11
Row 0 = 12 -> 12
Row 1 = 11 -> 0 (This was pin 13 if you’re wondering why the break in continuity)
Row 2 = 10 -> 14 (Analog 0)
Row 3 = 5 -> 15 (Analog 1)
Row 4 = 8 -> 16 (Analog 2)
Row 5 = 7 -> 17 (Analog 3)
Row 6 = 6 -> 18 (Analog 4)
Row 7 = 9 -> 19 (Analog 5)

I power the Arduino via the incoming USB. To get it to be recognized properly by your computer, unplug the USB programming cable from the Arduino and then plug in the USB cable to the V-USB side. Otherwise it will not be recognized. It makes for a lot of cable swapping unfortunately while coding. I also powered the C64 power LED for nostalgia (this may be a good use for pin 13).

Speaking of code, I needed to define some key codes that were missing from the UsbKeyboard library. This was fairly straight-forward by looking them up on the USB HID guide (chapter 10). I also defined “bogus” key codes that I could intercept and do something else with. Most keys on the keyboard can be passed straight through. Others, like the arrow keys, F-keys, quote, asterisk, etc need a little more help since their locations are different than a standard keyboard. I also hacked together to ability to detect a modifier key (shift, control, etc) along with another key (from the keypad library). The resulting code isn’t pretty but I think it’s easy enough to follow. It’s included below for your amusement.

This project is far from perfect but it’s a start.


#include <Keypad.h>
#include <UsbKeyboard.h>

// Define keys that are missing from UsbKeyboard.h
#define KEY_ESCAPE  41
#define KEY_DELETE 42
#define KEY_TAB 43
#define KEY_MINUS 45
#define KEY_EQUAL   46
#define KEY_LEFTBRACKET 47
#define KEY_RIGHTBRACKET 48
#define KEY_BACKSLASH 49
#define KEY_SEMICOLON 51
#define KEY_SINGLE_QUOTE 52
#define KEY_BACKTICK 53
#define KEY_COMMA   54
#define KEY_PERIOD  55
#define KEY_SLASH   56
#define KEY_INSERT  73
#define KEY_HOME    74
#define KEY_PAGEUP 75
#define KEY_PAGEDOWN 78
#define KEY_RIGHTARROW 79
#define KEY_LEFTARROW 80
#define KEY_DOWNARROW 81
#define KEY_UPARROW 82
#define KEY_AT      206

// Bogus key codes, intercepted in code below
#define KEY_PLUS 249
#define LEFT_SHIFT 250
#define RIGHT_SHIFT 251
#define COMMODORE 252
#define CONTROL 253
#define KEY_COLON 254
#define KEY_STAR 255

const byte ROWS = 8;
const byte COLS = 8;
byte mod = 0;

// Define the Keymap
char keys[ROWS][COLS] = {
 {KEY_DELETE, KEY_ENTER, KEY_RIGHTARROW, KEY_F7, KEY_F1, KEY_F3, KEY_F5, KEY_DOWNARROW},
 {KEY_3, KEY_W, KEY_A, KEY_4, KEY_Z, KEY_S, KEY_E, LEFT_SHIFT},
 {KEY_5, KEY_R, KEY_D, KEY_6, KEY_C, KEY_F, KEY_T, KEY_X},
 {KEY_7, KEY_Y, KEY_G, KEY_8, KEY_B, KEY_H, KEY_U, KEY_V},
 {KEY_9, KEY_I, KEY_J, KEY_0, KEY_M, KEY_K, KEY_O, KEY_N},
 {KEY_PLUS, KEY_P, KEY_L, KEY_MINUS, KEY_PERIOD, KEY_COLON, KEY_TAB, KEY_COMMA},
 {KEY_PAGEDOWN, KEY_STAR, KEY_SEMICOLON, KEY_HOME, RIGHT_SHIFT, KEY_EQUAL, KEY_BACKSLASH, KEY_SLASH},
 {KEY_1, KEY_BACKTICK, CONTROL, KEY_2, KEY_SPACE, COMMODORE, KEY_Q, KEY_ESCAPE}
};
byte colPins[COLS] = {4,5,6,7,8,9,10,11};
byte rowPins[ROWS] = {12,0,14,15,16,17,18,19};

// Create the Keypad
Keypad kpd = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup()
{
}

void loop()
{
  UsbKeyboard.update();
  mod = 0;

  // Kludge, find activate modifiers
  // control   [7][2]
  // commodore [7][5]
  pinMode(rowPins[7], OUTPUT);
  digitalWrite(rowPins[7], LOW);
  if (digitalRead(colPins[2]) == LOW) { mod = mod | MOD_CONTROL_LEFT; }
  if (digitalRead(colPins[5]) == LOW) { mod = mod | MOD_ALT_LEFT; }
  pinMode(rowPins[7], INPUT);
  digitalWrite(rowPins[7], HIGH);

  // left shift[1][7]
  pinMode(rowPins[1], OUTPUT);
  digitalWrite(rowPins[1], LOW);
  if (digitalRead(colPins[7]) == LOW) { mod = mod | MOD_SHIFT_LEFT; }
  pinMode(rowPins[1], INPUT);
  digitalWrite(rowPins[1], HIGH);
  
  // right shift[6][4]
  pinMode(rowPins[6], OUTPUT);
  digitalWrite(rowPins[6], LOW);
  if (digitalRead(colPins[4]) == LOW) { mod = mod | MOD_SHIFT_RIGHT; }
  pinMode(rowPins[6], INPUT);
  digitalWrite(rowPins[6], HIGH);
  
  if (mod == 6) {
    UsbKeyboard.sendKeyStroke(0, mod); // This works, but sends 3-4 times. :(
    return;
  }

  char key = kpd.getKey();
  if (key) {
    switch (key) {
      case KEY_STAR:
        UsbKeyboard.sendKeyStroke(KEY_8, MOD_SHIFT_LEFT);
        break;
      case KEY_AT:
        UsbKeyboard.sendKeyStroke(KEY_2, MOD_SHIFT_LEFT);
        break;
      case KEY_PLUS:
        UsbKeyboard.sendKeyStroke(KEY_EQUAL, MOD_SHIFT_LEFT);
        break;
      case KEY_COLON:
        UsbKeyboard.sendKeyStroke(KEY_SEMICOLON, MOD_SHIFT_LEFT);
        break;
      default:
        if (mod == MOD_SHIFT_LEFT || mod == MOD_SHIFT_RIGHT) {
          if (key == KEY_2) { key = KEY_SINGLE_QUOTE; } // "
          if (key == KEY_7) { key = KEY_SINGLE_QUOTE; mod = 0; } // '
          if (key == KEY_6) { key = KEY_7; } // &
          if (key == KEY_9) { key = KEY_0; } // )
          if (key == KEY_8) { key = KEY_9; } // (
          if (key == KEY_DOWNARROW) { key = KEY_UPARROW; mod = 0; }
          if (key == KEY_RIGHTARROW) { key = KEY_LEFTARROW; mod = 0; }
          if (key == KEY_F1) { key = KEY_F2; mod = 0; }
          if (key == KEY_F3) { key = KEY_F4; mod = 0; }
          if (key == KEY_F5) { key = KEY_F6; mod = 0; }
          if (key == KEY_F7) { key = KEY_F8; mod = 0; }
        }
        UsbKeyboard.sendKeyStroke(key, mod);
        break;
    }
  }
}

Converting standard joysticks to wireless infrared for Amiga CDTV and Chameleon 64

The Chameleon 64 is a great cartridge. With each release of the firmware, new features are being unlocked. Recently, the Minimig core was ported to the Chameleon 64 which means you can now have a fully emulated Amiga that fits in the palm of your hand.

To play games using a joystick, you need a CDTV infrared (IR) remote. They are still available for purchase here and here but it would take a few weeks for it to arrive.

I wanted to see if it’s possible to convert a standard joystick to wireless IR communications. I know it can be done– I’ve had some experience using Arduino’s to communicate over IR with a vintage LED sign I have. I reverse engineered the original protocol by using the original remote to the sign. That project taught me a lot.

In this case, I don’t have the remote. So I asked on the forum and got a response from the programmer of the Chameleon IR code with all the info I needed (Thanks Peter!).

This version uses an original Nintendo NES game pad for the joystick but this could be easily changed to support a standard 9-pin Commodore/Amiga/Atari style joystick. The gamepad is connected to the Arduino and decoded into button presses. It then transmits it via infrared signals to the Chameleon. The code uses the Arduino-IRremote library with additions (included) for the CDTV remote type added.

Download CDTV IR Remote

eBay Oddity: Silver Reed EB-50

Silver Reed EB-50 PrinterToday I present to you the Silver Reed EB-50. Made in 1985, this thing has a bit of an identity crisis. It’s a printer, a plotter and a typewriter all in one. The reason I got it was because it uses the same tiny ball-point pens that the Commodore 1520 printer/plotter uses. However, this prints on normal 8.5″ wide paper. It’s also very portable, has a lid that covers the keyboard and a flip out handle. It can run on batteries (5 x D cells OMG heavy) or on DC 7.5V power (center negative in case you want to know). For $9.99 it was a bargain curiosity that I couldn’t pass up.


In normal typewriter mode, you press a key and it will “draw” that character in one of 3 sizes, styles or directions in one of 4 colors. You can position the print head anywhere you’d like to print text. In addition, there are function keys to create graphs, right on the typewriter. Pie charts, bar graphs and line graphs are simple– select the type, enter the data points and it prints a graph at the print head position. Pretty clever for something that works sans computer.

Switch it to printer mode and now a computer takes over via the parallel port. This is where things got weird. I found reference to someone that wrote a program to convert HPGL plotter files to ones that printed on this one. This was key since there was no manual and I ran out of internets. But the file was locked up in a “drivers” ad supported nightmare of a website that had me install some bullshit driver manager on Windows to “install” a C code source file. What-fucking-ever. It’s included below in you want it.


A quick Processing sketch later and I’ve produced some output on it from my Mac using an old PowerPrint serial to parallel adapter via a KeySpan USB to serial adapter. Lots of adaptation, but what do you expect from a nearly 26 year old printer.


# hp2eb50.c
#include <stdio.h>

#define SCAL(x) (((x)+halfscale)/scale)
#define NUMV(x) ((x)=='-' || ((x) <= '9' && (x) >= '0'))
#define SP ('S'<<8)+'P'
#define PU ('P'<<8)+'U'
#define PD ('P'<<8)+'D'
#define PA ('P'<<8)+'A'
#define IW ('I'<<8)+'W'
#define SC ('S'<<8)+'C'
#define LB ('L'<<8)+'B'

FILE *source, *plotter;
short c,i,j,pen,scale,x1,x2,y1,y2,hx,hy,halfscale;
short befehl,ende,rot, colour[] = {0,1,2,3,0,1,2,3};
char param[100], *output;

void upcase(s)
   char *s;
  {
   register char c;
   register int  i=0;

   while ((c = *(s++)) && i<99)
     {
      param[i++] = (c>='a' && c<='z')? c-'a'+'A' : c;
     }
   param[i] = 0;
  }

short get_num()
  {
   register short c,x=0;
   short s;

   if (ende) return(0);
   else
     {
      while(((c = getc(source)) & 0x1ff) <= ' ');
      if (c == '-')  
        {
         s=-1;
         c = getc(source);
        }
      else s=1;
      while (c >= '0' && c <= '9')
	{
	 x = x*10+c-'0';
         while(((c = getc(source)) & 0x1ff) <= ' ');
	}
      if (c == ';') ende = -1;
      return(x*s);
     }
  }

void rotate()
  {
   register short h;

   if (rot)
     {
      y2 = y1;
      h = x1; x1 = y1; y1 = -h;
     }
  }

main(argc,argv)
   int argc;
   char *argv[];
  {
   if (argc<2)
     {
      printf("Usage: %s <hpgl-file> [SCALE <scale>] [ROT] [COLOUR <n1..n8>] [TO <output filename>]n",argv[0]);
      exit(0);
     }

   rot = 0;
   output = "par:";
   for (i=2;i<argc;i++)
     {
      upcase(argv[i]);
      if (!strcmp(param,"ROT")) rot=1;
      if (!strcmp(param,"SCALE") && i<argc-1)
	{
	 scale = atol(argv[++i]);
	 if (scale == 0) scale = 1;
	}
      if (!strcmp(param,"TO") && i<argc-1) output = argv[++i];
      if (!strcmp(param,"COLOUR") && i<argc-1)
	{
	 for (i++,j=0;j<8;j++) colour[j]=(argv[i][j]-'0') & 0x03;
	}
     }
   halfscale = scale/2;

   if (!(source = fopen(argv[1],"r")))
     {
      puts("Sorry - Can't open file!");
      exit(0);
     }
   if (!(plotter = fopen(output,"w")))
     {
      puts("Sorry - Can't open output file");
      fclose(source);
      exit(0);
     }

   pen = 0;
   fputc(18,plotter);  
   puts(" Command no.:");
   j = 1;
   do
     {
      i = ende = 0;

      do
	{
	 c = getc(source);
	} while (((c < 'A') || (c > 'Z')) && (c != -1));
      befehl = (c==-1)? 0 : (c & 0xff)<<8 | (getc(source) & 0xff);

      printf("2331A23313C %5dn",j++);   

      switch(befehl)
        {
         case SP : {
		    x1 = get_num();
		    if (x1)
                      fprintf(plotter,"C%d;n",colour[(x1-1)&7]);
                    break;
		   }
         case PU : {
         	    pen = 0;
		    break;
		   }
         case PD : {
		    pen = 1;
		    break;
		   }
         case PA : {
		    while (!ende)
		      {
		       x1 = SCAL(get_num());
		       if (!ende)
			{
		  	 y1 = SCAL(get_num());
			 rotate();
		         if (pen==1) 
                             fprintf(plotter,"D%d,%d;n",x1,y1);
		           else 
                             fprintf(plotter,"M%d,%d;n",x1,y1);
			}
		      }
		    break;
		   }
	 case LB : {
		    fputc('P',plotter);
	            while((c = getc(source)) >= 32) 
		      putc(c,plotter);
		    putc(13,plotter);
		    putc(10,plotter);
		    break;
		   }
         case SC : {
		    x1 = get_num();
		    if (ende) break; 
		    x2 = get_num();
		    y1 = get_num(); y2 = get_num();		    
		   }
         case IW : {
		    if (befehl==IW)
		      {
		       x1 = get_num(); y1 = get_num();
		       y2 = get_num(); y2 = get_num();
		      }
		    hx = (x2-x1+999)/1000;
		    hy = (y2-y1+999)/1000;
		    hx = (hx>hy)? hx : hy;
		    if (scale<hx)
		      {
		       scale = hx;
		       halfscale = scale/2;
		       printf("New scale: %dn2331A",scale);
		      }
		    rotate();
		    fprintf(plotter,"M%d,%d;nI;n",SCAL(-x1),SCAL(-y2));
		   }
        }
     } while (c!=-1);
   fputc(17,plotter);
   fclose(source);
   fclose(plotter);
   puts("nReady.n");
  }

 

Commodore 1520 Printer Plotter

NOTE! Split gears causing causing or plot errors? New replacement Alps gears for the Commodore 1520, Atari 1020, etc are now available! Click here to order your set.

Commodore 1520 Printer PlotterMy first computer was a Commodore VIC-20. I got it as a Christmas present from my parents in 1982. I’m pretty sure they picked it up at Montgomery Ward, which was still around at the time. Shortly there after, I got my first printer to go with it. A Commodore 1520 Printer Plotter.

Commodore 1520 PensThis printer was great. Firstly, it was tiny for a printer. It was smaller than the computer! Everything about it was tiny. It used tiny 4.5″ wide paper that was on a roll. It used tiny ball-point pens (yes, pens!) of four colors that it could selectively choose. I used it well, mostly printing nonsense I’m sure. Time passes and the printer disappears. I think I may have “taken it apart” which for me at that time usually meant destroying it. In any case, the original never followed me.

Fast forward to 2001 when I bought two from eBay. One came with the box and some extra pens (which proved to be the most elusive consumable). But irritatingly, the printer seemed to have fits when it was asked to print something. The motors would make an unpleasant noise and the print head would vibrate in place. The paper advance was also acting up.

Commodore 1520 GearUpon further inspection and some help from the interwebs, I found the culprit. A very tiny gear connects the stepper motor to the rest of the gearing to move both in the X (print head left and right) and Y (paper up and down). These two gears, made of nylon or plastic, have shrunk over time and split, causing the teeth of the gear to get jammed. Commodore sourced the plotter mechanism from ALPS (as did Tandy, Atari and Mattel for their plotters). Likely all plotters using this mechanism are suffering the same fate. Frustrated, I shelved it.

Fast forward to 2009 when I take a course in historical computers, I decided to revisit the printer to see if I can repair it. I found a terrific resource on a Commodore 128 forum from user “airship” he calls The 1520 Plotter Survival Guide written in 2007. It lists sources for the paper, the pens and possible help in fixing the gears.

ALPS Plotter MechsTo fix the gear issue, I decide to take the repair route. A company called Electronic Goldmine has the ALPS plotter mechanism (surplus) that Commodore used (at $1.49 ea!). I buy 10, hoping that at least a couple of the gears will be good. All of the gears are split– time has not been good to them. But the good news is the mechanisms make great replacements if the original motors are bad. Plus it gives me 20 gears to try and fix various ways.

To repair the gears, I first remove them from the stepper motor. They’re just pressure fitted so they slide off. I used some super glue to fix the split back together and clamp it together overnight. I then use a 1/16″ drill bit to drill out a tiny amount of the center of the gear. This will relieve the strain and prevent further splitting when the gear is back on the motor shaft. Next, I dry test the gear on the motor and see if it works. If it does, I use super glue to attach the gear to the shaft.

The result:

It works! I keyed in a demo program from the manual and produced this:
Commodore 1520 Geometric Design Plot
Coming up in another post I’ll show you what it looks like when it plots text (with slow motion video).

NOTE! Split gears causing causing or plot errors? New replacement Alps gears for the Commodore 1520, Atari 1020, etc are now available! Click here to order your set.