Build Your Own Floppy Emu

Over the past several months, many people have written to me about the Macintosh Floppy Emu, asking if they could buy one, or when the project would be finished. Since I haven’t made any progress on Floppy Emu in ages, I’m doing the next best thing and releasing the design files and build instructions to the community. If you’re skilled with a soldering iron and embedded development tools, you can use these to build your own Floppy Emu, or improve upon its design.

Warning! Building a Floppy Emu requires advanced soldering skills. Almost all the parts are surface mounted, and there are several SMD chips with fine-pitch 0.5 mm pin spacing. These can be soldered by hand, but it’s tedious, error-prone work. If you’ve never done this type of soldering before, think hard before starting this project. Now with that out of the way, let’s get started!

Download the Floppy Emu design file archive

What You’ll Need

• A Windows PC
• AVR Studio 5 software from Atmel. This is free software. AVR Studio 6 probably works too, but I haven’t tried it. AVRDUDE should work as well.
• An AVR programmer, such as the AVRISP mkII
• A high-speed class 10 SD or SDHC card
• Soldering iron
• Patience

Making a PCB

To begin building your Floppy Emu, you’ll need a printed circuit board. There are many on-line services that will make these for you, using a set of layout files called Gerbers. You will find the Floppy Emu Gerbers in the file archive, in the directory eagle\floppyemu\gerbers.zip. I recommend using the Dorkbot PDX PCB Order service to get the PCB manufactured. Send them the Gerber files, and they’ll make three copies of the PCB for about $30, with a turn-around time of a few weeks. The guy who runs the PCB service is very helpful if you have questions.

Getting the Parts

While you’re waiting for the PCB to be manufactured, you can locate all the other parts you’ll need to assemble the Floppy Emu. You’ll find a complete parts list in the file archive. The total parts cost should be about $40, which is dominated by the AVR microcontroller and the Xilinx CPLD.

One of the required parts is a male DB-19 connector, which mates with the Mac’s external floppy port. These can be very difficult to find, and IEC is the only supplier I know that has them. If you can’t find a DB-19 solder type connector, you can still use the Floppy Emu with its alternate IDC20 connector, which is readily available from electronics suppliers. With the IDC20, there are several different connection options:

• Connect the IDC20 to the internal floppy connector inside your Mac (you will need an IDC20 cable)
• Connect the IDC20 to the circuitry inside a real external Apple floppy drive enclosure, after removing the drive guts
• Use an Apple II DB-19 to IDC20 cable

If you don’t already have them, you’ll also need a high speed class 10 SD or SDHC card, and an AVR programmer like the AVRISP mkII.

Assembly

Here’s where things get fun! Refer to the file floppy-emu-layout.png for placement information, or check the schematics.

The first step is to solder and test the AVR.

1. Solder the AVR. Pay attention to the orientation – the dot in the corner of the chip should match the dot on the silkscreen. I recommend using the drag solder technique. Begin by soldering two pins on opposite corners of the chip to tack it in place. Verify that the pins are perfectly aligned with the pads on the board before proceeding. Now goob an absurd amount of solder onto the remaining pins. You will probably bridge most of the pins together – that’s OK. Finally, go back with a solder wick and flux, and wick away all the excess solder. Surface tension will hold the solder onto the pins and pads where it belongs, while the excess is magically wicked away. Use a 10x jeweler’s loupe to visually inspect the pins for tiny bridges or gaps.
2. Solder the crystal, the 18pF capacitors C12-C13, the AVR decoupling capacitors C4-C7 (these are on the back of the board), the voltage regulator, and the regulator capacitors C10-C11. Also solder the DB-19 connector. It fits along the edge of the board, with the thickness of the board fitting between the two rows of solder cups.

The AVR microcontroller should now be functional. You can use AVR Studio to test it out.

1. Install the AVR Studio 5 software on your PC and run it.
2. Connect the Floppy Emu board to your Mac, and turn on the Mac.
3. Connect the AVRISP mkII programmer to your PC.
4. Press the ISP connector into the board, but do not solder it yet. If it is soldered too soon, it will be in the way of your iron later.
5. Connect the AVRISP’s programming cable to the ISP connector on the board.
6. Click on the AVR Programming button in the toolbar. It looks like a chip with a lightning bolt.
7. In the programming dialog, set Tool to AVRISP mkII, Device to ATmega1284P, and Interface to ISP
8. Click the Apply button
9. Where it says Device ID at the top, click the Read button. Push the ISP connector firmly sideways while you do this, to ensure its pins make electrical contact with the board.

If everything is working, the Device ID field should now display 0x1E 0×97 0×05. If it does not, or you encounter an error, review the steps above, then go back and carefully re-check all the solder connections. Do not proceed further until you are able to retrieve the AVR device ID.

The next step is to program the AVR with the Floppy Emu software.

1. Open the AVR Programming dialog again.
2. From the list at the left, click Fuses to display fuse information.
3. Set the fuses:
   • BODLEVEL – disabled
   • OCDEN – off
   • JTAGEN – off
   • SPIEN – on
   • WDTON – off
   • EESAVE – off
   • BOOTSZ – 4096W_F000
   • BOOTRST – off
   • CKDIV8 – off
   • CKOUT – on
   • SUT_CKSEL – EXTXOSC_8MHz_XX_16KCK_65MS
4. Click the Program button in the fuse panel. Push against the ISP connector with your finger while you do this.
5. From the list at the left, click on Memories to display AVR memory information
6. Under Flash, verify that “Erase device before programming” is checked
7. For the Flash filename, choose AVR\release\floppyemu.hex from the file archive
8. Under Flash, click the Program button. Push against the ISP connector with your finger while you do this.
9. Remove the ISP connector from the board.

Congratulations, the AVR setup is now complete! The next step is the Nokia LCD.

1. Solder the level converter (the 74LVC244), its decoupling capacitor C8, and the 10K resistor R4.
2. Solder the two 8-pin male 0.1 inch headers to the Nokia LCD.
3. Solder the top 8-pin female 0.1 inch header to the board. Place the bottom header in the board, but do not solder it yet.
4. Connect the LCD to the Floppy Emu board. The thicker part of the LCD bezel should be at the top.

The LCD should now be functional. Connect the Floppy Emu to your Mac, and turn the Mac on. If everything is working, the LCD should show “SD Card init error”.

The SD card reader is next.

1. Solder the SD connector, and its decoupling capacitor C9.
2. Insert the SD card into your PC.
3. Format the SD card as a FAT32 disk.
4. Copy all the files from the SD files directory in the file archive onto the SD card. Don’t copy the directory itself, only the files that are in it.
5. Put the SD card into the Floppy Emu.

Connect the Floppy Emu to you Mac, and turn the Mac on. If everything is working, the LCD should show “no disk 79/0″.

The final assembly step is the CPLD.

1. Solder the CPLD. Pay attention to the orientation – the dot in the corner of the chip should match the dot on the silkscreen. Use the same technique for soldering the CPLD that you used for the AVR.
2. Solder the CPLD’s decoupling capacitors, C1-C3. These are on the back of the board.
3. Solder the LEDs and their resistors, R1-R3. The silkscreen shows the proper orientation for the LEDs.
4. Solder the four tactile switches.
5. Solder the remaining connectors into place.

Now it’s time to program the CPLD. The unfilled JTAG header footprint on the board could be used to program it directly with a Xilinx programmer, but it’s not used by this version of Floppy Emu. Instead, the AVR programs the CPLD indirectly, using a firmware file stored on the SD card.

1. Ensure the file firmware.xvf is on the SD card. This is part of the SD files collection that you should have copied to the card earlier.
2. Put the SD card into the Floppy Emu.
3. While your Mac is turned off, connect the Floppy Emu to the Mac.
4. Hold down both the PREV and NEXT buttons, then turn on the Mac.
5. Follow the instructions on the LCD to load the firmware file to the CPLD.

That’s it! Turn the Mac off, then on once more, and you’re done.

Using the Floppy Emu

When it’s turned on, the Floppy Emu scans the root of the SD card for files with a .dsk extension, and shows a menu of available disk images. It begins with the disk “out of the drive”. Use the PREV/NEXT buttons to select a disk image file, then press the SELECT button to insert it. After the disk is inserted, the LCD display shows the current track number and side of the emulated disk drive head.

You can use other floppy image files in addition to the ones included in the archive – just copy them onto the SD card. The Floppy Emu expects raw 400K or 800K disk images without any headers or other information, so a disk image file should be exactly 409,600 or 819,200 bytes. If you have some 400K or 800K disk images that you’ve been using with Mini vMac or another Macintosh emulator, they should work with Floppy Emu as well. Only 400K and 800K disk image files are supported – 1.4MB images will not work.

With a high-speed class 10 SD card, all your standard read and write operations to the floppy will work, just as if it were a real external floppy disk. You can boot the computer, save documents from MacPaint, or copy files in the Finder. Read operations will also work OK with a slower SD card, but write operations may fail.

Formatting or initializing the floppy in the Finder is not supported on any type of SD card, and will fail. If you need a blank disk image file, create one using a Macintosh emulator program and then copy it to the SD card. Certain kinds of bulk transfer write operations are also unsupported, such as using a disk copy program to copy data to the floppy.

Extending Floppy Emu

The C source code for the microcontroller program is provided in the file archive. You can build it with AVR Studio, generate a new floppyemu.hex file, and load it to the microcontroller using the AVRISP mkII.

For the ambitious, the ATMEGA1284P microcontroller that’s used here has much more RAM than is needed by the current program. It could be used to implement some kind of sector buffering scheme, which could enable slower SD cards to support writes reliably, and all cards to support formatting and disk copying.

The Verilog source code for the CPLD is also provided. You’ll need Xilinx’s free ISE WebPACK to build it. Export an XSVF file, and rename it to firmware.xvf. Then copy the file to the SD card, and load it onto the CPLD as you did before. I’m not sure why you’d need to change the CPLD design, but maybe you’ll find a reason.

The CadSoft EAGLE schematics and board files are included in the file archive too, for anyone who wants to experiment with changing the hardware design. You can use the freeware version of EAGLE.

Happy hacking!