MCM/70 Reproduction

The MCM/70 computer was conceived, developed, and built in Canada in 1974. It was arguably one of the very first "personal" computers because it was portable, had a built-in keyboard, display, and support for the APL programming language, plus cassette storage. On the other hand, at a cost of $10,000, it was only really accessible to large corporations, the military, governments, and educational institutions.

Inspiration

I've been a vintage/retro computer enthusiast for a quite a while now and thought that I had a pretty good handle on all of the machines available in the 60s and 70s. So imagine my surprise when I saw the Kristina Panos February 23, 2022 Hackaday blog post: INPUTS OF INTEREST: CANADIAN MCM/70 WAS KINDA LIKE THE FIRST CYBERDECK.

Wow. Mind blown. Here was a beautiful Canadian built personal computer from the mid 70s that I had no idea existed. As I read Kristina's post I became more and more intrigued. The MCM/70 was conceived by professor Mers Kutt of Queen’s University in Kingston, Ontario and was manufactured in Kingston. The company he formed to build the devices, Micro Computer Machines (MCM), was located in Toronto, Ontario. I live in Waterloo, Ontario, so all of this took place in my own back yard so to speak. Adding to that there was a ‘devastating power struggle’ between Kutt and some of MCM’s investors that in part ultimately lead to the demise of the company. Well I was hooked. Had to know more.

Research

Kristina's blog post was a good place to start learning about the MCM/70. It's a great summary of the origin of the machine, what it was, and its ultimate fate. I would encourage anyone with an interest in the MCM/70 to start there as I did.

For a more in depth look, the blog post references the book Inventing the PC: the MCM/70 Story by Zbigniew Stachniak. I purchased the book and really enjoyed it. A lot of the book is about the history of the company Micro Computer Machines which I found fascinating. More importantly, towards my goal of making an MCM/70, the book talks a lot about the design of the machine and provides insights into what ultimately led to that design some of which were technical, some practical, and some political.

Another good reference is the MCM/70 Users Guide, an overview of the machine and a great teaching resource for learning the APL language.

After doing a little more digging I discovered that The York University Computer Museum (YUCoM) has an MCM/70 on display. York University is only about 110 kilometers from where I live, about a hour and a half's drive away. Cool. I also learned that the YUCoM has developed a historically accurate software emulator for the MCM/70 and is offering it free to anyone who requests it. So naturally I requested it through an online contact form and who should answer that request, Zbigniew Stachniak the author of Inventing the PC: the MCM/70 Story who also happens to be the curator of YUCoM. Small world. I eventually got to visit the museum. Zbigniew (Ziggy) was very generous with his time and his insights plus the numerous pictures that I took were very helpful in recreating this wonderful machine.

Hardware

Based on the Intel 8008 microprocessor the MCM/70 had 32KB of ROM and up to 8KB of RAM. For output it used a Burroughs Self-Scan module, a 222 column by 7 row dot matrix plasma display, capable of showing 32 5x7 dot characters at a time. Because the MCM/70 supported APL out of the box, the keyboard was based on the IBM 2741 layout. Finally up to two cassette decks were used for offline storage and to implement virtual memory.

Software

The MCM/70's operating system consisted of two modules EASY (External Allocation SYstem), and AVS (A Virtual System) which were built into the ROM. These allowed the user to directly interact with the machine. In addition the ROM contained an MCM/APL interpreter. From cassette, APL application libraries could be loaded for finance, mathematics, statistics, education, and games. There was also printer and plotter support software. 

The Plan

So my plan is to make a full size MCM/70 computer reproduction with a real keyboard and display which I'll integrate into the YUCoM emulator. This physical reproduction will be as accurate as possible but made with modern components and fabrication techniques. For instance, the case will probably be 3D printed. I will add the cassette bays to give an authentic look but they will not contain actual cassette hardware.

Let's Go

As soon as I became aware of the MCM/70 I knew that I had to have one, and given the rarity of these machines that means making one. This Instructable will detail what I did to create my reproduction and hopefully provide enough information for you to make one too should you want to.

Supplies

In addition to the 3D printed parts you will need:

• 4 - HCMS-2972LED DISPLAY 5X7 8CHAR 5MM HER - Digikey
• 2 - SS451A Omnipolar Hall Effect Switches - Digikey (Optional)
• 1 - Raspberry Pi 4 - PiShop (Good luck finding one.)
• 1 - Raspberry Pi 3.3V to 5V 26 I/O Bidirectional Voltage-Level Shifter Module - Amazon
• 1 - GDSTIME 30mm Blower Fan 5V DC Brushless Small Blower Cooling Fan - Amazon
• 1 - A classic ASCII Unified Retro Keyboard and encoder available from Dave at osiweb.org
• 1 - 40 Pin Rainbow Female to Female ribbon cable - Amazon
• 40 - pcs 30 cm Long Female to Female Header Jumper Wire - Amazon
• 4 - feet 1/2 inch round wooden doweling
• 1 - piece 1/2 x 4 x 11 inch pine
• 20 - #6 x 3/4 inch wood screws
• 20 - #6 x 1/2 inch wood screws
• 20 - M3 x 10 mm bolts with nuts
• 10 - M4 x 16 mm bolts with nuts
• 1 - Small proto board (Optional)
• 4 - Round magnets 6 mm in diameter and 3 mm height (Optional)

Step 1: Print the Parts

I printed the parts with no supports and the following settings (unless other wise specified):

Print Resolution: .2 mm

Infill: 20%

Filament: AMZ3D PLA

Notes: Print the parts in their default orientation.

To make an MCM/70 you will need to print the following parts:

• 1 - 8U Spacebar OEM Profile - I printed this at .1 mm
• 1 - Back Panel - Print as one piece if your bed is big enough or two pieces if not.
• 4 - Board Bracket
• 2 - Cassette Frame Bottom
• 2 - Cassette Frame
• 6 - Cassette Half (Optional)
• 4 - Cassette Holder Base
• 8 - Cassette Holder Spring
• 6 - Cassette Magnet Holder (Optional)
• 2 - Cassette Release
• 2 - Cassette Sensor Holder (Optional)
• 2 - Cassette Tape Head
• 1 - Display Bar With Logo - Print black. At the 8.3 mm mark switch filament to white.
• 1 - Display Frame
• 1 - Display Inlay
• 6 - Mounting Bracket
• 1 - Pi 4 Holder
• 1 - Side Panel Left - Print as one piece if your bed is big enough or two pieces if not.
• 1 - Side Panel Right - Print as one piece if your bed is big enough or two pieces if not.
• 1 - Top Panel Display - Print as one piece if your bed is big enough or four pieces if not.
• 1 - Top Panel Keyboard - Print as one piece if your bed is big enough or two pieces if not.

Step 2: Getting the MCM/70 Emulator Running

Look. I would like nothing better than to find a dusty old MCM/70 computer for cheap in some thrift shop and restore it to it's former working glory. Realistically we all know how unlikely this is given that relatively few MCM/70s were ever produced and that it has been close to 50 years since the last one was made. 

So what about recreating the hardware from scratch. Obtain the original schematics and with luck PCB layouts, source the parts, many of which are vintage now and no longer manufactured, and make a replica. While this is might be possible, the endeavor would be very expensive, certainly well beyond the means of the average enthusiast like myself. I am however aware of one individual who is doing just this. I should note though that he was a principle engineer working on the MCM line of computers back in the 70s, so eminently qualified to tackle this project.

Another possibility is to create an emulation of the MCM/70 in software. This is just what the team at the The York University Computer Museum (YUCoM) did. From their web page:

An alternative approach to the direct use of MCM hardware is to write historically accurate software emulators of this computer destined for modern desktop and laptop computers. Although such emulators do not necessarily reflect the computer's hardware on, say, integrated circuit level, they offer a platform for research of general hardware organization, storage organization, systems and applications software, etc.

Software emulation is great and is certainly an important part of preserving these wonderful old machines, but I have found that nothing beats the feel of typing on a physical keyboard and hearing the sounds of the keys clicking. 

The York University Computer Museum MCM/70E Emulator

Thanks to the hard working folks at York University, I have a great head start with this project, a working MCM/70 Emulator. Not just working, but because it is intended for research purposes, an emulator "with high historical accuracy". From the MCM/70E web page:

In 2019, YUCoM offered its emulator of the MCM/70 as free software. The emulator is the result of an extensive study of the MCM/70 hardware and of a software recovery project that has preserved MCM software from approximately 100 digital MCM cassettes donated to the museum. It emulates the original MCM/70 hardware with 8Kbytes of RAM with high historical accuracy. In particular, the memory management as well as tape, keyboard, and display functionality are emulated accurately. The emulator operates under the original systems software and is using the original tape storage organization (reconstructed during the above mentioned software preservation project).

There is a great document, the MCM/70E Guide, that accompanies the software that tells you how to install and run the emulator.

MCM/70E is written in C and is available for Linux only at this time. It is delivered as source in a .tgz archive and must be compiled on the target machine. OpenGL and the GLUT utility toolkit are required for the emulator to compile. In addition I will be using the pigpio library to access the display and keyboard through the Pi's GPIO pins. Pigpio is installed by default on the Raspberry Pi OS. The library is referenced in the code through the pigpio header file.

#include <pigpio.h>

My intention is to run the emulator on a Raspberry Pi 4. I installed the latest Raspberry Pi OS (Version 11 (bullseye)) onto a Model 4B to which I had attached a monitor, keyboard, and mouse. I then downloaded and exploded the MCM70E.tgz file that I obtained from York University creating a /MCM70E_v2.1_distr folder. From within that folder I executed the following commands:

sudo apt-get install freeglut3-dev
apt-get install libncurses-dev
gcc mcm.c -lGL -lglut -lpigpio -o mcm

Notice that in order to get the emulator to compile under Raspberry Pi OS I had to install the ncurses library in addition to the GLUT library. Then it's a simple matter of running the emulator.

./mcm

If all you wanted to do is to kick the tires on an MCM/70 or maybe learn a little APL the emulator is all you need so feel free to stop now. If you are like me and want a more immersive experience let's carry on.

Step 3: Build the Display Module

For output the MCM/70 used a Burroughs Self-Scan Model C4047 plasma display. These Self-Scan displays were an important stepping-stone technology between teletype terminals of the 1960s and the widespread use of CRTs from the mid-1970s on.

The display was arranged as a 222 column by 7 row dot matrix. An MCM/70 would use these dots to render 32 characters of 5x7 dots with two blank columns between each. Now a single line of text with 32 characters doesn't sound like much, but considering that the Altair 8800 released that same year just had front panel blinkenlights out of the box, it was quite a step up.

Here's the problem. These plasma displays are no longer manufactured. You can occasionally find one on eBay but they are pretty expensive. Even if I could source one, to tell you the truth the high voltages required for the plasma elements (250V) scare me a bit (even though I know the amperage is low).

So I spent a lot of time looking for a suitable replacement with a little luck I found one, the Broadcom HCMS-2972.

Packaged as 8 5x7 dot matrix arrays these modules operate at a nice safe 3.3V and can be cascaded together side by side to create the 32 x 1 character display desired here. Furthermore the viewing area for the 32 characters measures 171.7 mm x 4.57 mm while the Self-Scan viewing area is 181.61 mm x 4.98 mm. So very very close. Before I committed to the HCMS-2972 I setup a quick test using an Arduino Nano I had kicking around. Here is what it looks like fired up.

Display Carrier Board

When thinking about how to organize four HCMS-2972s into a 32 x 1 character display my first idea was to design a PCB to hold all four parts. Then I realized that JCLPCB is going to ship a minimum of five boards anyway, so I came up with a carrier board for a single HCMS-2972 that can be easily daisy chained together with others. You can find a KiCad 6 PCB file for this board here.

Pretty simple. I used a couple of IC sockets (a 14 pin and a 12 pin) to hold the HCMS-2972s in place (these parts are like $60 a piece so I'm not taking any chances with them). Based on the Broadcom HCMS-2972 parts and the display carrier board PCBs that I made, I now have a working MCM/70 display.

The carrier boards worked out great. Just had to wire them together. With the display in hand, I was able to integrate it with the York University MCM/70 emulator using the Wiring Pi library to access the Raspberry Pi's GPIO pins.

Display Assembly

The display assembly consists of three printed parts:

• Display Bar With Logo
• Display Frame
• Display Inlay

plus a Display Window that I laser cut from 3 mm clear acrylic (DXF file attached).

Here is how they are assembled.

 It's now ready to be wired and dropped into the case.

Step 4: Build the Keyboard

I knew that producing an authentic looking keyboard for this project would be a challenge in two parts. First getting the physical keyboard layout right with the MCM/70 keys. The second challenge would be to obtain a keycap set with the special APL symbols (legends). The photo above is an original MCM/70 keyboard.

The Keyboard

After looking at many many keyboards online I found the following.

This is a keyboard for Ohio Scientific (OSI) computers that were popular in the mid to late 70s. It's a very close match layout wise to the MCM/70. One small difference is that the OSI spacebar is only 8U compared to the MCM/70's 9U size. Also the MCM/70 has an ISO style Return (rotated L shaped) key, but if you remove and ignore the OSI's Repeat and Break keys and replace the Return key with the 1.5U model and the Repeat key with a blank keycap, it's a practically perfect replacement.

So how does this help? Aren't OSI vintage keyboards just as hard to find as MCM/70 keyboards? Well yes and no. Yes originals are hard to find, but thanks to Dave from osiweb.org replacement keyboards are not. I used Dave's Sol-20 reproduction keyboard for my Sol-20 Reproduction and it worked out great. If you check out Dave's Unified Retrocomputer Keyboard Project on GitHub you will see that he also offers keyboards for Apple I, Apple II/II+, Generic ADM/3A teletypes, and most importantly to me OSI computers. So I ordered an OSI keyboard PCB, a Futaba stabilizer, an encoder, and a set of Futaba MD-4PCS keys.

The Keycaps

To say that the MCM/70 keyboard is unique would be an understatement. Because it supports APL out-of-the-box there are twenty plus keys that have special shifted characters like α and ∆. Not to mention that the more standard special character keys are in different places than on a modern keyboard. Plus I don't know if I've ever seen italicized letter key legends.

There are a number of options for creating custom keycaps:

1. Waterslide Decals. Key legends are printed on special waterslide paper and transferred by first soaking them in water then sliding the clear top layer with the glyph and some adhesive to the keycap. 
2. Dye Sublimation. Key legends are printed (reversed) with special dye sublimation ink. The glyphs are then positioned directly on the keycap and transferred by applying heat (400 F - can be accomplished with a hair curler) and pressure. 
3. Laser Etching. While directly etching the legends onto a keycap has not worked very well, DIYers have had success by coating the keycap surface with print toner or dye sublimation ink then using laser etching to fuse the glyphs to the surface. Once done the excess toner or ink is washed away.
4. Purchase. A number of vendors will now allow you to submit SVG files with your keycap legends and produce the keys for you.  

At the end of the day I decided to purchase the keycaps. While learning how to make DIY keycaps I'm sure would be very rewarding, it felt to me like it was a whole separate time consuming project. Plus I had discovered KROME Keycaps a UK supplier of custom keycaps.

To have a set of custom keycaps made you first have to create SVG versions of the legends that can be scaled to fit the keycaps. I used Inkscape to create these glyphs for the MCM/70 keyboard.

I filled in the Creation Form on the KROME Keycaps site and attached the above SVG file and was contacted in short order. Over the course of a couple of days we worked out the details of the order and I was issued a mockup and a quote of about $100 (US). Given how much work making my own would have been I thought this was a pretty reasonable ask.

The keycaps arrived in a couple of weeks. KROME Keycaps did a fabulous job and were great to work with. I'm very happy with the result.

I have attached the keycap legends SVG file that I used. Should you desire a set for your own project I suggest that you contact me first as I can probably arrange a discount for you.

Keyboard Assembly

I'm not going to detail the process here since it was mostly identical to the work I did on my Sol-20 Reproduction. For details check out:

• The Keyboard Encoder (Sol-20 Reproduction - Step 6: Assemble the Keyboard Encoder)
• Keyboard Construction (Sol-20 Reproduction - Step 5: Assemble the Keyboard)(Note that the newer keyboard PCB has the discrete diodes and resistors pre-populated on the board. A real time saver. Thanks Dave.)

Here they are. Notice that the 40 pin headers on both the keyboard and the encoder are male headers facing downwards so they can be connected via a ribbon cable underneath the frame.

And with the custom keycaps.

So the keyboard is ready to go.

Step 5: Build the Cassette Decks

So I'm adding mostly placebo cassette decks to my MCM/70 reproduction and you might be wondering why. Couple of reasons. 

First of all the YUCoM software that I am using emulates a machine that has two cassette decks. When I visited the the York University Computer Museum Zbigniew Stachniak (Ziggy) mentioned that MCM did ship a model with no cassette decks and one with a cassette deck and a modem, but that without cassettes the machine was basically just an APL calculator. So I could have saved some time and still been historically accurate I guess. 

More importantly though, virtually all of the online images of the MCM/70 feature the two tape deck model. It's important to me that my reproduction is clearly recognizable as an MCM/70 so placebo cassette decks it is.

To build the two cassette decks you will need the following printed parts:

• Cassette Frame Bottom (x2)
• Cassette Frame (x2)
• Cassette Holder Base (x4)
• Cassette Holder Spring (x8)
• Cassette Release (x2)
• Cassette Tape Head (x2)

The assembly should be pretty straight forward based on this photo.

A couple of notes:

• The lid is held in place by a couple of short (15mm) lengths of stiff wire that act as the hinges.
• Similarly the tape eject rocker holders are glued into place and similarly hinged with stiff wire to the eject rocker.
• The two screws are cosmetic only.
• The cassette holder base, springs, and tape head are also glued in place.
• I cut the cassette lid windows from 3 mm acrylic. The DXF file to do this is attached.

Step 6: Adding a Cassette Sensor (optional)

The wonderful York University Computer Museum MCM/70 Emulator allowed the user to manipulate the cassette drives through the onscreen interface. From the MCM/70 Emulator manual:

The MCM/70 computers were equipped with up to two digital cassette drives. Their purpose was not only to store APL objects but also to offer virtual memory to extend user’s workspace to over 100KB. (In the early 1970s, the virtual memory was available only on some mainframe computers such as the IBM System\370 Models 158 and 168.)

Tape mounting. Follow these steps:

1. Start MCM/70E.
2. Left click the selected tape drive to open its lid.
3. Right click the selected drive to access tape menu.
4. Select a tape.
5. Left click the selected tape drive to close its lid.

Note: The emulator requires that tape names are at most 16-character long. It will not load tapes with longer names.

Ejecting a tape. To eject a tape:

1. Left click the selected tape drive to open its lid.
2. Access tape menu by right clicking the selected drive.
3. Select ”eject”.
4. Left click the selected tape drive to close its lid.

By ejecting a tape, its content will be saved in the tape’s file located in the tapes directory Tapes of the emulator. 

In the first image above I have done a left click to open the lid of the first cassette drive and then right clicked to bring up the tapes menu. Notice that in addition to eject there are three tapes that ship with the emulator: utils.tp, empty.tp, and demo.tp. In the second image I have selected the demo tape.

I've already stated that I have added the cassette bays to give my MCM/70 an authentic look. Even though I am using an emulator under the covers, I like for my reproductions to also provide as authentic a user experience as possible. So to that end I have added a physical interface for one of the underlying virtual cassettes. I didn't think that doing both cassettes added a lot of value.

To add this functionality you will have to print:

• Cassette Half (x6)
• Cassette Magnet Holder (x6)
• Cassette Sensor Holder (x2)

Identifying Tapes

I had been playing around lately with the RC522 RFID reader/writer so my first though was to use one to read RFID tags that I would embed into my fake cassette tapes. This would have the advantage of allowing a large number of different tapes, but would add significant complexity to the build. For instance I would have to find and integrate an RFID library into the emulator code. Since the emulator only ships with three different virtual tapes anyway, I decided to go a simpler route and use hall effect sensors to detect magnets that I would embed into fake cassettes. I already have the pigpio library installed for the keyboard and display so reading the sensors is no problem.

I stared by creating three new "cassettes". I 3D printed some new fake cassette bodies, and created some plugs to hold the magnets (round 6 mm in diameter and 3 mm height) that could be slotted into the cassette holes.

The plugs marked with the red dots do not have a magnet. I put the cassettes together and added some vintage looking labels.

With a small proto board I made a "reader" based on two SS451A Omnipolar Hall Effect Switches. These sensors are either on or off depending to the presence or absence of a magnetic field. Omnipolar means that it it doesn't matter what the magnet's polarity is. 

I mounted the reader by gluing some 3D printed standoffs (Cassette Sensor Holder) to the back of one of the fake cassette decks so the the sensors would align with the magnets in the cassettes, and added some leads to eventually connect it to the Raspberry Pi. Use the picture below as a guide to position the sensor.

Step 7: Build the Case

I created a template to cut out the "in"side panel pieces for the MCM/70 frame.

The outside line represents the side panels as printed, while the inside outline is 3 mm smaller and is used to make an inner frame to support the top panels. Holes indicate positions where screws (#6 x 3/4 inch) will be used to attach the printed side panels to the inner frame (black dots), and attach flanges for 1/2 inch doweling to the inside frame (#6 x 1/2 inch screws). I laser cut the template from a scrap of acrylic I had lying around to use as a positioning guide for the screw holes.

The Frame

Then I laser cut four of the smaller inside pieces from 6 mm plywood. The DXF file to do this is attached.

I designed and printed six flanges to anchor 1/2 inch dowels. 

Then I glued two panels together for each inside frame and mounted the flanges based on the template.

The dowels were cut so that the width of the machine from the outside edges of the inner frames is exactly 13.25 inches just as it is in the original.

Side Panels

To make the side panels you need to print:

• Side Panel Left
• Side Panel Right

Each can be printed as one or two pieces depending on the size of your print bed.

Once printed, I attached the side panels to the inner frame pieces and inserted the dowels.

I printed four Board Bracket parts and attached them to the 4 inch board. The dowels (center to center) will be 75 mm apart so mount the brackets accordingly.

This platform will snap on to the two lower 1/2 inch dowels and be used to mount the electronics.

The Top Panel

To make the top panel you need to print:

• Top Panel Display
• Top Panel Keyboard
• Back Panel

Top Panel Display can be printed as one piece or four pieces depending on the size of your print bed. Similarly the Top Panel Keyboard and Back Panel can be printed as one or two pieces. My build required eight pieces. I attached the keyboard panel pieces and the top panel pieces with a good CA glue and added a brace to the front part of the keyboard panel.

I printed the Back Panel as two pieces and bolted them together with a couple of M4 - 16 mm bolts. I attached the back panel to the frame with four 1/2 inch screws.

And that pretty much finishes off the case.

Step 8: Do the Wiring

Unless otherwise specified, I used 30 cm long female to female jumper wires to make the following connections.

Keyboard

As with my Sol-20 project, the keyboard encoder is expecting 5V while the Raspberry Pi 4 operates at 3.3V. So to overcome this I purchase a Voltage-Level Shifter Module from Amazon. Here is what it looks like.

I am using the Sol-20 header on the encoder and the pinout looks like this.

So here is how I wired the keyboard. Note that for the exception of +5V and GND lines which are wired to the 3.3V side or the level shifter, all of the other connections are wired to the 5V side.

Encoder   Raspberry Pi   Description
~~~~~~~   ~~~~~~~~~~~~   ~~~~~~~~~~~
+5V          5V          Power
GND          GND         Ground
D0          GPIO5        Key 0 bit (low)
D1          GPIO6        Key 1 bit
D2          GPIO12       Key 2 bit
D3          GPIO13       Key 3 bit
D4          GPIO19       Key 4 bit
D5          GPIO16       Key 5 bit
D6          GPIO26       Key 6 bit
D7          GPIO20       Key 7 bit (high)
STROBE      GPIO4        Key ready on falling edge.

Display

The display has the following pinouts.

All of the following connections are wired to the 3.3V side of the level shifter.

Display Raspberry Pi Description
~~~~~~~ ~~~~~~~~~~~~ ~~~~~~~~~~~
 3.3V      3.3V      Power
 GND       GND       Ground
 data     GPIO21     Data Pin
select    GPIO22     Register Select Pin
clock     GPIO23     Clock Pin
enable    GPIO24     Chip Enable Pin
reset     GPIO25     Reset Pin

Cassette Sensor (Optional)

If you made the tape sensor module wire it to the Raspberry Pi as follows.

Tape Sensor Module Raspberry Pi Description
~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~ ~~~~~~~~~~~
5V                    5V        Power
GND                   GND       Ground
S1                    GPIO17    Data Pin for Hall Effect Sensor 1
S2                    GPIO27    Data Pin for Hall Effect Sensor 2

Step 9: Final Assembly

With all the pieces done it was time to put it all together, but first I did one final check of the integrated electronics.

All good.

I printed a Pi 4 Holder, a caddy, to secure the Raspberry Pi to the frame.

Next:

• I installed the keyboard.
• Attached the keyboard encoder to the platform at the back of the case with some two sided tape.
• Connected the keyboard and encoder with the 40-pin ribbon cable.
• Positioned the 3D printed caddy for the Raspberry Pi on the platform as far back as it would go. (until the blue power connector hits the support dowel) and in a position where the PI power, HDMI, and A/V Jack line up with the slot in the Back Panel. Attach the caddy and Raspberry Pi in place with two sided tape. 

Then:

• Placing the top cover on it's side I carefully attached the display unit and left hand tape deck. I used a little blue tape along the opening edges for the cassette deck and display to ensure a tight fit.
• I ran the wires from the tape deck out through the back of the case.
• I also installed a little muffin fan (30x30x10 mm) on to the Raspberry Pi caddy and powered it from the 5V side of the Pi hat.

.

I positioned the Top Panel in place being careful not to the pull or pinch any of the wires. I attached the tape deck to the Raspberry Pi. I did a little cable management as well.

Finally I installed the Back Panel with the cutout for the PI power, HDMI, and A/V Jack.

And that's it. The hardware is done!

Step 10: Setup Autostart

One of the finishing touches I wanted on this project is to make the Raspberry Pi boot directly into the MCM/70 emulator on startup. 

I created an autostart folder on my Pi and switched to that folder. Note that xxxxx is the logon user name for the Pi and will be different for your system.

mkdir /home/xxxxx/.config/autostart
cd /home/xxxxx/.config/autostart

Into the autostart folder just created I added the following two files.

runMCM-70

cd /home/xxxxx/MCM70E_v2.1_distr
sudo ./mcm

MCM70E_v2.1_distr is the folder when the emulator gets built. For some reason the pigpio library requires root access hence the sudo.

MCM-70.desktop

[Desktop Entry]
Type=Application Name=MCM-70
Exec=/home/xxxxx/.config/autostart/runMCM-70 

In addition the runMCM-70 file must be made executable with the following command:

sudo chmod 777 runMCM-70

The next time you reboot the system the MCM/70 Emulator will start automatically. Unless you want to make changes to the system or to interact with the software emulator you should no longer have attach a keyboard, mouse, or display to the Raspberry Pi.

Step 11: Final Thoughts

With it's oddball and unobtainable plasma display and APL keyboard, building an MCM/70 reproduction was probably the most challenging project I have tackled so far. Having said that, it was also the most rewarding to finish. As a proud Canadian, being able to shed some light onto this uniquely Canadian and IMHO pretty unique computer, was pretty cool.

Being able to employ an existing working emulator was certainly a major leg up when tackling an already difficult project. Also having some access to an original MCM/70 and a domain expert in Zbigniew Stachniak was invaluable. Thanks Ziggy for all the help.