Big Mess o' Wires

A friend from work gifted me a Raspberry Pi Model B. I was generally familiar with the RPi, but hadn’t had a chance to look at it in detail before now. The specs are impressive: a 700MHz 32-bit ARM CPU, 256MB RAM, USB, audio, composite video, HDMI video, and SD card support. It’s also got GPIO headers as well as headers for I2C and SPI, so you can interface it with various sensors and other external elements.

The Raspberry Pi has proven to be extremely popular since its release, and appears to have made major inroads among the Arduino community. But the further I looked into it, the more confused I became about who this product was intended for. Perhaps the hardware specs are a little too good: it’s nearly the equivalent of a standard Linux PC from 10 years ago. That’s an amazing thing to fit onto a tiny board that costs $35, but is it fun to use?

What I enjoy most about my projects is interfacing with hardware at a very low-level. I get a kick out of bit-banging video, replicating retro electronics, and interfacing with odd hardware with specific timing requirements. I don’t really want to run X-Windows on my embedded project, or use it as a development IDE platform. When it comes to digital bit-twiddling, the lowly Arduino still has more GPIOs, and offers real-time control of the IO pins. The RPi can’t really match that, running garbage-collected Python programs on top of a multi-tasking Linux kernel.

If you’ve got a Raspberry Pi and found it useful, what kind of projects did you use it for, and how do you see the RPi’s strengths and weaknesses in comparison to other embedded hardware?

8 comments

I finally got around to building a proper floppy disk image selection menu. Instead of loading a hard-coded rfloppy.dsk disk image file from the SD card, Floppy Emu now scans the SD card for all files with a .dsk extension, and displays a menu of available disk image files. The PREV/NEXT buttons navigate the menu, and the SELECT button inserts the selected disk image into the virtual floppy drive.

When a disk image is inserted, the LCD displays the name of the Macintosh volume that’s inside the disk image – “System Tools” in the example above. It also shows the current track and side being accessed. For write operations, the LCD displays the track, side, and sector that was written, as well as the time required for the write.

Download the Floppy Emu file archive for the new firmware.

 

No comments

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!

8 comments

Since the Plus Too project hasn’t seen any progress in a year, I’m posting all the design files in the hopes that someone else may want to build on what I’ve done. If you missed the earlier discussions about it, Plus Too is a working replica of a Macintosh Plus, implemented in an FPGA.

Download the Plus Too file archive

What You’ll Need

• An Altera DE1 FPGA development board
• A Windows-based PC
• An old PS/2 mouse from a PC (newer USB-based mice won’t work)
• A VGA monitor capable of displaying 1024 x 768 @ 60Hz

Setup Instructions

1. Download the Control Panel configuration file DE1_USB_API.sof into the FPGA. This file is included on the CD that comes with the DE1 kit. See sections 3.1 and 4.1 of the DE1 user manual for help.
2. Run the DE1_Control_Panel.exe program on your PC. This is also included on the DE1 CD.
3. Click on the Flash tab.
4. Click the Chip Erase button to clear the DE1 Flash memory.
5. In the Sequential Write section, enter 0 for the address and click the File Length checkbox.
6. Click the Write a File to Flash button. When prompted, select the plusrom.bin file from the Plus Too archive, and write the file to the DE1 memory. This is a ROM dump from Macintosh Plus.
7. In the Sequential Write section, enter 20000 (hex) for the address. Confirm the File Length checkbox is still checked.
8. Click the Write a File to Flash button. When prompted, select the Disk608-800K.bin file from the Plus Too archive, and write the file to the DE1 memory. This is a System 6.0.8 boot disk image.
9. Download the Plus Too configuration file plusToo_top.sof into the FPGA. This is included in the Plus Too archive.

You should now be up and running! Connect a PS/2 mouse and a VGA monitor for some retro-computing fun.

Using Plus Too

There’s no support for the keyboard, sound, or SCSI. The floppy disk is read-only.

Watch out! There’s a bug somewhere that causes PlusToo to crash or the mouse to stop working (not sure which) if you move the mouse around too much or too fast. I’m still not sure what the cause is, but I wrote about it more in a previous post.

Along the bottom of the screen you’ll see some debug information, shown in green text. From left to right, these are:

• A – the current value on the address bus
• D1 – the incoming value from the data bus
• D0 – the outgoing value from the data bus
• (not labeled) – the current interrupt level
• AA – the previous value of the address bus
• B – the breakpoint address

You can set the breakpoint address using the DE1 switches. When the current address equals the breakpoint address, Plus Too will halt.

The hardware can be controlled using the four push-button switches on the DE1 board, which are labeled Key0 through Key3, as well as the 10 slide switches labeled SW0 through SW9.

• Key2 inserts a blank disk into the external drive. Useful for debugging only.
• Key1 inserts the System 6.0.8 disk into the internal drive.
• Key0+Key1 together perform a reset.
• SW0 selects between free-running (switch down) and single-step mode (switch up).
• When in single-step mode:
  • Key0 performs a step
  • Key1, Key2, and Key3 load the low, middle, and high bytes of the breakpoint address from switches SW9-SW2.

Making Floppy Disk Images

The Disk608-800.bin file is not a standard floppy disk image file such as you would use with a Mac emulator like Mini vMac or Basilisk II. It’s an encoded file containing data exactly as it would appear on a real floppy disk, complete with sector markers, checksums, and inter-sector timing gaps.

If you want to take an 800K floppy image from your favorite emulator and use it with Plus Too, you’ll need to encode it using my Floppy Encoder utility. It takes a normal floppy image file as input, which usually has a .dsk filename extension, and generates an encoded image file with a .bin extension. The resulting .bin file can then be substituted in step 8 of the setup instructions to run Plus Too with the new floppy image.

Extending Plus Too

The Verilog source files are included in the file archive, for anyone who wants to try taking the project further. The biggest thing it needs now is for someone to set up proper timing constraints. I played around with it a bit, but I didn’t really understand the constraint editor and was eager to move on. PlusToo mostly works without specifying any constraints, but sometimes it will randomly fail to boot up, or exhibit bizarre video bugs. I’ve found that changing the number of signals and sample depth of the Signal Tap logic analyzer setup can fairly predictably make such problems appear and disappear.

The constraints should be:

• External 50 MHz clock
• Internal 32.5 MHz clock synthesized with a PLL. This is the video clock, called clk32 in the Verilog source.
• Internal 8.125 MHz clock named clk8, derived from clk32 with a clock divider. (I couldn’t make this work with a PLL)
• Flash ROM has an address-to-data delay of 70ns. The total delay from clk8 to when all the Flash control and address lines are stable, plus 70 ns, plus whatever the setup time is for the FPGA registers that will receive the Flash data (how do you determine this?), must be less than the clock period of 123ns.
• Similarly for the SRAM, except I believe its address-to-data delay is 10ns (check datasheet). The SRAM should also have additional constraints for write timing.

 

 

5 comments

I’ve posted an archive containing the original Tranz 330 program file dump, my commented disassembly of the original program, and two versions of the Mozart demo in source and binary form. If you can get your hands on a Tranz 330 from a surplus electronics supplier, this should give you an afternoon’s entertainment! You can grab the files here.

3 comments