Close
0%
0%

Commodore CHESSmate Reproduction

The plan is to make a reproduction of the dedicated chess computer CHESSmate released by Commodore in 1978.

Similar projects worth following
CHESSmate was developed by Peter Jennings, author of the KIM-1 MicroChess program, under contract with Commodore International. The CHESSmate’s hardware is based on the venerable KIM-1, but the ROMs are loaded with a custom MicroChess 1.5 image not the KIM’s monitor.

CHESSmate units are extremely hard to find, understandable given that 45 years have passed since they were introduced. My hope is to build a working CHESSmate computer using modern fabrication techniques and components, and to produce a comprehensive set of instructions with modeling files (PCB, 3D Print, etc.) so that anyone else could make one as well.

Motivation

On Tuesday November 14th, 2023 I was invited to an event at York University to celebrate

 "the momentous appearance of the MCM/70 computer - a technological marvel that offered an early glimpse of a new digital reality. 

You can see my "trip report" on the MCM/70 @ 50 event here. I was honored to have been asked to bring my MCM/70 Reproduction to demonstrate at the event. The reproduction was inspired by this post by .

At the event I was delighted to meet Peter R. Jennings, author of MicroChess. Written originally for the KIM-1, MicroChess was ported to many other computers of the day such as the TRS-80Apple IICommodore PET and Atari 8-bit family. Later Peter went on to form VisiCorp,  which released VisiCalc the first electronic spreadsheet for PCs and Visi On the first GUI for the IBM PC.

Images from the MCM/70 @ 50 event. In the rightmost photo above I am chatting with Peter R. Jennings of MicroChess and VisiCorp fame.

It turns out that Peter was/is a huge APL fan. APL is the language built-in to the MCM/70 computer. Around the time he was working on MicroChess he wrote a 6502 assembler in APL. I think he had fun exercising his APL skills on the reproduction. 

The very next day November 15th,  posted  THE QUAINT HISTORY OF THE COMMODORE CHESSMATE to Hackaday. Now I'm not really a superstitious guy, and I know this was just a coincidence, but it sure felt like fate to me. I decided right there and then that I would like to create a CHESSmate reproduction. I got in touch with Peter to make sure he was OK with the idea and he was. He even graciously offered to loan me an original CHESSmate unit on which to base my reproduction. For someone that is used to just working from photos this is a rare treat for me.

Not only did Maya's post help me pick my next project, it inspired Peter to write down his recollections of the origins of CHESSmate, which can be found here.

Hardware

The hardware for the CHESSmate closely matches the KIM-1 SBC that it was based on.

  • 6504 CPU (28-pin 6502)
  • 8K addressable memory
  • On-chip clock @ 1MHz
  • 6530-0024 RIOT (64 bytes RAM, 1KB ROM, 2 I/O ports, 8-bit timer) 
  • 6332 4k ROM 
  • 4 7-element LED displays 
  • 4 dome indicator LEDs
  • Piezoelectric beeper
  • 19 membrane keys

I'm not going into a lot of detail here as there is a great post on Nightfall with more information.

Software

The software consists of a custom MicroChess 1.5 image and the firmware necessary to interface with the keys, display, LEDs , and beeper.

Game Plan

My plan is to make a clearly recognizable working Commodore CHESSmate, but using modern fabrication techniques. It should be relatively easy for an average person with access to a 3D printer and some soldering ability to make one based on my plans and the modelling files I will release.

I'm still in the research and thinking stage, but for sure I'll be 3D printing the case. The good news there is that the dimensions of the CHESSmate at 22 x 16 x 5 cm will allow me to print the top and bottom case parts on my Prusa MK3S whole, without having to split them into smaller pieces.

The next big component is the membrane keyboard. I'm hoping that a rigid PCB with low profile physical or dome switches combined with a color printed and laminated "membrane" will do the trick. Definitely more research and testing is required here to flesh out this plan.

And finally, what will MicroChess run on under the covers. The Nightfall article goes into some detail on why directly reproducing the CHESSmate electronics would be difficult, mainly because the RIOT chips used were pretty much custom made for the CHESSmate and are no longer available (although a fairly close analog could be designed with modern components). 

I was a software guy my whole career, so I'm more comfortable...

Read more »

  • 1 × ESP32 ESP-WROOM-32 NodeMCU Development Board This is a 38 pin ESP-32 board with a 22.86 mm spacing between the rows of pins. It's important to get the right footprint if you want to use the backpack daughter board PCB. Amazon: https://a.co/d/amiKdym
  • 4 × Common Cathode 7 Segment 10 Pin 1 Bit 2.1V 0.36" Digit Height LED Display Module Be sure to get the common cathode variety. Amazon: https://a.co/d/5QGyIi5
  • 19 × Momentary Tact Tactile Push Button Switch 12 x 12mm x 8mm 4 Pin DIP w Cap You don't have to get switches with caps, which could be easily 3D printed. Amazon: https://a.co/d/8qKJreo
  • 4 × 2N2222 NPN Transistor Metal Can TO-18 You don't need to get the more expensive metal version, but you do have to be careful getting the leads right with other variants. Amazon: https://a.co/d/8cMk6sU
  • 4 × 5 mm Red LEDs

View all 13 components

  • A Software Only CHESSmate

    Michael Gardi2 days ago 0 comments

    I said I was not going to jump into a software only CHESSmate right away but it turns out I couldn't resist. 

    My starting point was a Python based 6502 emulator that I had used for my Challenger 4P project. My decision was based on Python's portability, my current infatuation with Python, and my positive experience with this particular 6502 emulator (solid). 

    It turns out that making a software only emulation was more challenging than I thought it would be. With my hardware reproduction, the CHESSmate emulation consisted of observing the CHESSmate program's interaction with the 6530-0024 RRIOT chip (which controlled all the I/O to the 7-Segment displays, buttons, buzzer, and LEDs) and mapping those interactions the to the correct ESP-32 I/O lines that controlled my reproduction hardware. When I finally got the mapping correct everything just worked. 

    A software emulation is a different beast. In this case, you have to map the CHESSmate program's interaction with the 6530-0024 RIOT chip to an on screen CHESSmate representation. There are three major areas that have to be addressed, the Display, Keyboard, and Sound.

    Display

    Since I already had an Inkscape created SVG file for the CHESSmate "membrane", the first part of creating a program was pretty easy. I'm using PyGame to create the software interface. With a few lines of code I was able to create a "window" and load the membrane SVG as a background image. Great start, but it's just a static image. To bring to life, I had to be able to light up the on screen 7-Segment displays and the LEDs. 

    For the 7-Segment displays, my first thought was to create graphics for each of the seven segments and "light them up" by drawing them on the background based directly on the which lines of the virtual 6530-0024 RRIOT chip were enabled, but this felt like a lot of complexity. Then I discovered that there was a 7-Segment TrueType font available. I ended up downloading the file DSEG7ClassicMini-BoldItalic.ttf and using PyGame's built in font engine to render the display characters all at once based on the which seven virtual 6530-0024 RRIOT chip lines were enabled. 

    The LEDs were much simpler. Just draw a red circle in the appropriate spot and size when the RRIOT code indicated that a particular LED was to be lit. 

    For both the 7-Segment displays and LEDs, at system startup before anything had been written to the background image, I captured and saved small image "patches" of the areas that were to be overdrawn, and bitted them back to the screen to "erase" the character or LED when required. 

    Keyboard

    For the keyboard I recorded the coordinates of the 19 on screen buttons, and monitored PyGame mouse click events to see if they were within one of the button rectangles when a click occurred.  It was then relatively easy to map those clicks back to the appropriate RRIOT register response. In addition I used PyGame keyboard events to also map the following physical keys: A, B, C, D, E, F,G, H, 1, 2, 3, 4, 5, 6, 7, 8, Return (ENTER), Backspace (CLEAR) and Esc (NEW GAME).

    Sound

    Sound turned out to be the most work. With the hardware emulation I just had to connect the two leads of a piezo "buzzer" to two RRIOT mapped pins. Done.  With software emulation I ended having to create WAV files for each of the 14 unique sounds that CHESSmate uses. To determine when a sound was starting I monitored the two RRIOT sound pins for  "activity" (one or the other pin set high). Note that when no sound was playing both pins would be set low. The sound to be played was set as a number in a zero page data byte ($69). Based on that number I used the PyGame sound library to play the appropriate wave file. Calls to play a sound return immediately and the sounds play asynchronously with continued program execution (nice). To determine when the CHESSmate program is finished playing the sound the activity on the RRIOT sound pins will stop (both low) for...

    Read more »

  • Another Minimalist Frame

    Michael Gardi03/16/2024 at 14:56 0 comments

    I had already designed an alternate frame to support the CHESSmate should one not want to go the the extra work of printing the reproduction's case. Problem is I didn't like it and it wasn't growing on me. Too rushed, too clunky. So I took another run at it and this is what I came up with.

    It's even more minimal and IMHO more ascetically pleasing.

    I populated a second CHESSmate PCB and attached it to the new frame with eight M3 x 6 mm bolts and nuts.

    This time I used bare buttons without the caps to accentuate the minimalist vibe. I'm much happier with this version.

  • Final Assembly

    Michael Gardi03/14/2024 at 16:35 4 comments

    The new and improved backpack PCB arrived. Better late than never I guess. I started by soldering on some headers.

    I soldered a couple of female straight headers to hold the ESP-32, a couple of male pins to connect to the +5V and GND on the ESP, and a 90 degree Female header to attach the backpack to the CHESSmate PCB. In the rightmost image I have mounted the ESP-32 onto the board.

    With the backpack ready I attached the stack comprised of the:

    1. Membrane
    2. 3D printed standoff with cutouts for the displays, LEDs, and buttons
    3. CHESSmate PCB 

    to the case with eight M3 x 14mm bolts.

    Then I mounted the backpack CPU.

    Once it was in place I connected the micro USB connector power leads to the backpack PCB and mounted the piezo speaker to the case with two sided tape.  

    Popped the bottom of the case on, applied power, and viola a working CHESSmate reproduction.

  • Lost In Translation

    Michael Gardi03/06/2024 at 15:21 0 comments

    My replacement backpack PCBs appear to be lost somewhere between Memphis, TN and me. Sigh. So I decided while I wait to try and use one of my messed up boards after all.

    The tricky part was to carefully pry the leads on the ESP-32 apart an additional 2.54 mm. Since they are now at an angle, getting them into the holes on the PCB was tricky and they ended up being pretty shallowly in place, which made soldering difficult. But I got it done and then proceeded to fix the power traces that I had crossed.

    I had to install the 90 degree header such that the CPU board would extend straight back from the CHESSmate board so that I could solder the jumper wires.

    The alternative is to install the header rotated 180 degrees so that the daughter board tucks underneath the CHESSmate board. I think that I kind of like the setup as pictured above where you can see all of the components including the ESP-32 board. For installing inside the CHESSmate case I will probably go the other way.

  • Messing Up

    Michael Gardi02/26/2024 at 17:37 4 comments

    I'll admit that when I get close to finishing a project I can get a little careless. That was the case when I sent the CPU backpack daughter board in for fabrication. There were two issues.

    1. The footprint that I used for the ESP-32 WROOM development board was wrong. The two rows of 19 pins were 2.45 mm too far apart.  No excuses, I usually print a PCB layout on paper when done and set the parts on top to check this. This time I did not and got burned. I love the ESP-32 but I get that distinct impression that there is a lot more variance between boards than there is in the Arduino world. Be careful.
    2. Worse perhaps is that I reversed the VCC and GND lines going to the CHESSmate PCB header. If this was the only problem I could have salvaged the boards with a couple of trace snips and some jumper wires, but with the pins offset wrong there's no point.

    At any rate here is the fixed PCB that I just sent off for fabrication.

    Sigh. At least I was able to add a power header to the board that I missed in the first version.

  • Re Openings

    Michael Gardi02/18/2024 at 16:32 0 comments

    In a previous log I said, "I'm not going to overthink this. Random selection from the chess openings is working.". Well I lied. I am going to overthink this. (Well at least think it.)

    Something I should have done when working on the opening moves was to actually see what they were. So I dumped the 32 chess openings in a format I could read.  Here is the Python script I used:

    col_table = ['H','G','F','E','D','C','B','A']
    row_table = ['1','2','3','4','5','6','7','8']
    
    with open("Opening Book.bin", 'rb') as f:
        buffer = f.read()
       
        # For each line.
        ent_file = []
        even = 0
        address = 0x8C00
        for i in range(0,len(buffer),2):
            if i % 32 == 0:
                ent_file.append("\n")
                ent_file.append(hex(address))
                ent_file.append(": ")
                address += 32
            # Assume bytes are contiguous.
            if (even % 2) == 0:
                ent_file.append(col_table[buffer[i]&0x0F]+row_table[buffer[i]>>4]+"-"+
                                col_table[buffer[i+1]&0x0F]+row_table[buffer[i+1]>>4] +", ")   
            else:
                ent_file.append(col_table[7-(buffer[i]&0x0F)]+row_table[7-(buffer[i]>>4)]+"-"+
                                col_table[7-(buffer[i+1]&0x0F)]+row_table[7-(buffer[i+1]>>4)] +", ")
            even += 1     
        ent_file.append('\n')
        
        # Output the result.
        with open("Opening Book Dump.txt", 'w') as f:
            f.write(''.join(ent_file))

    It wasn't to hard to figure out the format.

    8c00: E2-E4, E7-E5, G1-F3, B8-C6, B1-C3, G8-F6, F1-B5, F8-B4, E1-G1, E8-G8, D2-D3, D7-D6, C1-G5, B4-C3, B2-C3, D8-E7
    8c20: D2-D4, D7-D5, C2-C4, D5-C4, G1-F3, G8-F6, E2-E3, E7-E6, F1-C4, C7-C5, E1-G1, A7-A6, D1-E2, B8-C6, B1-C3, C5-D4 
    8c40: F2-F4, D7-D5, E2-E3, G8-F6, G1-F3, C7-C5, B2-B3, E7-E6, C1-B2, B8-C6, F1-B5, C8-D7, E1-G1, F8-D6, D2-D3, D8-C7 
    8c60: E2-E4, E7-E5, F1-C4, G8-F6, D2-D4, E5-D4, G1-F3, F6-E4, D1-D4, E4-F6, C1-G5, F8-E7, B1-C3, C7-C6, E1-C1, D7-D5 
    8c80: E2-E4, C7-C5, G1-F3, B8-C6, D2-D4, C5-D4, F3-D4, G8-F6, B1-C3, D7-D6, F1-E2, G7-G6, C1-E3, F8-G7, E1-G1, E8-G8 
    8ca0: E2-E4, C7-C5, B1-C3, B8-C6, G2-G3, G7-G6, F1-G2, F8-G7, D2-D3, E7-E6, C1-E3, D7-D6, G1-E2, C6-D4, E1-G1, G8-E7
    8cc0: E2-E4, E7-E5, G1-F3, B8-C6, F1-C4, F8-C5, C2-C3, G8-F6, D2-D4, E5-D4, C3-D4, C5-B4, B1-C3, F6-E4, E1-G1, E4-C3 
    8ce0: G1-F3, G8-F6, C2-C4, C7-C5, D2-D4, C5-D4, F3-D4, E7-E6, B1-C3, F8-B4, C1-D2, E8-G8, E2-E3, B8-C6, F1-E2, D7-D5 
    8d00: E2-E4, E7-E5, G1-F3, G8-F6, F3-E5, D7-D6, E5-F3, F6-E4, D2-D4, D6-D5, F1-D3, F8-D6, E1-G1, E8-G8, C2-C4, C7-C6 
    8d20: D2-D4, G8-F6, C2-C4, E7-E6, G2-G3, D7-D5, F1-G2, D5-C4, D1-A4, B8-D7, A4-C4, A7-A6, G1-F3, B7-B5, C4-C6, A8-A7
    8d40: E2-E4, G8-F6, E4-E5, F6-D5, D2-D4, D7-D6, C2-C4, D5-B6, F2-F4, D6-E5, F4-E5, B8-C6, C1-E3, C8-F5, B1-C3, E7-E6 
    8d60: D2-D4, F7-F5, C2-C4, E7-E6, G1-F3, G8-F6, G2-G3, F8-E7, F1-G2, E8-G8, E1-G1, D7-D5, B1-C3, C7-C6, C1-F4, D8-E8 
    8d80: E2-E4, E7-E5, G1-F3, B8-C6, F1-C4, G8-F6, D2-D4, E5-D4, E1-G1, F6-E4, F1-E1, D7-D5, C4-D5, D8-D5, B1-C3, D5-A5 
    8da0: D2-D4, G8-F6, C2-C4, E7-E6, B1-C3, F8-B4, D1-C2, B8-C6, G1-F3, D7-D6, C1-D2, E6-E5, A2-A3, B4-C3, D2-C3, D8-E7 
    8dc0: E2-E4, B8-C6, D2-D4, D7-D5, E4-D5, D8-D5, G1-F3, E7-E5, B1-C3, F8-B4, C1-E3, C8-G4, F1-E2, E8-C8, E1-G1, D5-A5 
    8de0: D2-D4, D7-D5, C2-C4, E7-E6, B1-C3, G8-F6, C1-G5, B8-D7, G1-F3, F8-B4, C4-D5, E6-D5, E2-E3, C7-C5, F1-D3, D8-A5
    8e00: D2-D4, D7-D5, C2-C4, C7-C6, G1-F3, G8-F6, B1-C3, D5-C4, A2-A4, C8-F5, F3-E5, B8-D7, E5-C4, D8-C7, G2-G3, E7-E5
    8e20: E2-E4, E7-E5, G1-F3, B8-C6, F1-B5, D7-D6, D2-D4, C8-D7, B1-C3, G8-F6, E1-G1, F8-E7, F1-E1, E5-D4, F3-D4, E8-G8 
    8e40: D2-D4, D7-D5, C2-C4, E7-E6, B1-C3, C7-C5, C4-D5, E6-D5, G1-F3, B8-C6, G2-G3, G8-F6, F1-G2, C5-D4, F3-D4, F8-C5 
    8e60: E2-E4, E7-E5, G1-F3, B8-C6, F1-B5, A7-A6, B5-C6, D7-C6, D2-D4, E5-D4, D1-D4, D8-D4, F3-D4, C8-D7, B1-C3, E8-C8 
    8e80: D2-D4, C7-C5, D4-D5, D7-D6, C2-C4, G7-G6, B1-C3, F8-G7, E2-E4, G8-F6, F1-E2, E7-E6, C1-G5, E8-G8, G1-F3, E6-D5 
    8ea0: E2-E4, E7-E5, G1-F3, B8-C6, D2-D4, E5-D4, F3-D4, G8-F6, B1-C3, F8-B4, D4-C6, B7-C6, F1-D3, D7-D5, E4-D5, C6-D5 
    8ec0: D2-D4, G8-F6, C2-C4, G7-G6, B1-C3, F8-G7, E2-E4, D7-D6, F2-F3, E7-E5, D4-D5, E8-G8, C1-G5, H7-H6, G5-E3, F6-H5 
    8ee0: E2-E4, C7-C6, D2-D4,...
    Read more »

  • CHESSmate Lite

    Michael Gardi02/17/2024 at 20:40 0 comments

    I guess I'm getting a little antsy waiting for the daughterboard PCB to arrive (it has been shipped). To pass the time I thought I would try out an idea I had for a stripped down version of CHESSmate. My goal of course is to make a full blown reproduction that provides a truly authentic CHESSmate experience, but that may not be everyone's aesthetic. To that end I present CHESSmate Lite, a minimalist take on the 1976 classic.

    When I laid out the PCB, I made sure that all of the labels from the membrane were copied onto the silkscreen layer. This allows one to make a working version of CHESSmate without the membrane. In fact you could just make a version that had only the main PCB with the CPU daughterboard attached to the back and nothing else. The only problem with this configuration is that the daughterboard prevents the combined unit from lying flat. So to fix that I designed this minimal frame.

    Not much to it. You attach the PCB to the frame with eight 3M x 4mm bolts. There is a platform on the back onto which the piezo speaker can be mounted with two sided tape. With the daughterboard attached, power would be provided via the ESP-32's USB-C connector. The rubber feet work well keeping the unit from sliding as keys are pressed. 

    I like that the insides are on the outside. It's a great look IMHO. Not having to print the case and make the membrane cuts considerable time and effort off of the build. I have added the frame design along with the other models to GitHub.

  • Manual Intervention

    Michael Gardi02/16/2024 at 16:51 0 comments

    One thing that I try to do with my projects is to make an authentic looking reproduction of the manuals as well. For instance I was especially pleased with the way that this ZX80 Operating Manual turned out. 

    Making a CHESSmate Operation Instructions manual was pretty trivial. It's an 8 page (2 sheets of 8.5 x 11 inch paper) booklet with a simple staple binding. The hardest part was figuring out how to setup the print dialog to produce the desired result. 

    Once the booklet was together I had to trim 1/4 of an inch off the top and bottom edges to get the dimensions right. The PDF for the manual has been added to the GitHub for this project.

  • Random Thoughts

    Michael Gardi02/15/2024 at 23:11 0 comments

    When I was looking at the opening book issue I read this in the little 8 page CHESSmate Operation Instructions:

    CHESSmate contains a collection of 32 familiar chess openings. Out of these it chooses one at random and tries to follow it for 16 moves. 

    It then lists the 32 openings by name.

    What jumped out at me was "chooses one at random". I had not really noticed this. Sure enough if you push the following sequence of buttons on the original:

    1. NEW GAME
    2. H - ENTER (CHESSmate plays WHITE.)
    3. G - ENTER (CHESSmate moves)

    CHESSmate will make the following opening moves (randomly ?) plus others:

    • E2-E4
    • D2-D4
    • C2-C4

    Now it's hard to tell because it's random after all, but the moves tend to skew towards E2-E4 and D2-D4. That is to say that they seem to come up more frequently. The others much less frequently.

    My reproduction only ever played E2-E4 when CHESSmate plays first.

    So how is random working? I looked for other RRIOT reads happening around the same time as the opening book lookups. I noticed a read to the 8B0E register (labeled READ TIMER INTERRUPT) that I had assumed was to clear interrupts (since the current player was switching), but maybe is does more. I was always just returning FF from this read. 

    On a hunch I started returning a random number between 0 and 31 inclusive instead and guess what, I'm getting random behavior now very similar to what is happening on the original machine. My guess is that the value being returned by the RRIOT is the "time" remaining before the next interrupt will be triggered.

    I'm not going to overthink this. Random selection from the chess openings is working. 

    That was the last item on my firmware TODO list. I believe at this point that I have a very accurate CHESSmate software experience. All that's left is to put the whole package together. For that I'll wait until my ESP-32 backpack daughter board arrives (it's in final inspection at the fabricator). Light at the end of the tunnel and all that.

  • Booking It

    Michael Gardi02/15/2024 at 20:04 0 comments

    On to the next mystery "eureka" reads.  A reminder.

    Number                                     R/W            Program Counter                                       Address                                      Value                    Notes
      4RF3058xxxFFOccurs when move made.
      5RF3098xxxFFOccurs when move made.

    When I dumped the information from each of these I started to see a pattern.

    The FFs are what I return no matter what. 

    When CHESSmate moves first.
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
    R F305 8C00 FF
    R F309 8C01 FF
    
    When CHESSmate moves second.
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    R F305 8C00 FF
    R F309 8C01 FF
    R F305 8C20 FF
    R F309 8C21 FF
    R F305 8C40 FF
    R F309 8C41 FF
    R F305 8C60 FF
    R F309 8C61 FF
    R F305 8C80 FF
    R F309 8C81 FF
    R F305 8CA0 FF
    R F309 8CA1 FF
    R F305 8CC0 FF
    R F309 8CC1 FF
    R F305 8CE0 FF
    R F309 8CE1 FF
    R F305 8D00 FF
    R F309 8D01 FF
    ...
    
    R F305 8FE0 FF
    R F309 8FE1 FF

    Now the 8xxx address space implies that this has something to do with the 6530-024 RRIOT chip, but I had been led to believe that the 1K RRIOT ROM was not being used by CHESSmate.  Here is the only place in the code again that makes these reads.

    F303 B1 76       LF303     LDA ($76),Y
    F305 48                    PHA
    F306 C8                    INY
    F307 B1 76                 LDA ($76),Y
    F309 85 2A                 STA $2A
    F30B 68                    PLA
    F30C A2 11                 LDX #$11

    You will notice that the two reads are made (indirectly) through a memory address. This would make it difficult to determine what memory was actually being accessed by just looking at the code, hence the misleading no RRIOT ROM assumption. 

    The pattern of the reads suggest a search, skipping 32 bytes after each step.  The CHESSmate manual suggests that the game has a cache of 32 classic chess openings for up to 16 moves each. So the RRIOT ROM most likely contains these opening moves since (32 bytes per opening) x (32 openings) = 1024 the size of the ROM. I had always assumed that the opening moves was part of the main ROM.

    Another little eureka moment for me. Of the four sites that had CHESSmate ROMs only one of them had a second 1K "additional" ROM. I assumed this must be the opening book so I included it in the emulator and mapped it to the 8C00 to 8FFF memory space, and it worked

    When I make my first move of the game now, by dumping the read info I can see CHESSmate searching through the book until it finds my move. You can tell it's "in book" because it will counter move immediately without the blinking the display while "thinking". Different opening moves show a different search "depth".

    Another mystery solved.

View all 30 project logs

Enjoy this project?

Share

Discussions

Peabody1929 wrote 12/20/2023 at 18:09 point

There are 4 screws on the bottom of the case.  There are brass inserts in the plastic to accept the 4 macine screws so don't worry about taking the screws out and stripping the plastic hole.  I have pix of the PCB inside the case if you are interested.

  Are you sure? yes | no

Michael Gardi wrote 12/20/2023 at 19:18 point

Thanks for the tip. I’ll be looking inside shortly. I’d like to see your pictures. It might be interesting to see if there is any difference between my UK version and (I’m assuming) the North American version you have. I have DM’d  you my email address. 

  Are you sure? yes | no

Dave's Dev Lab wrote 12/15/2023 at 19:03 point

awesome new project!

  Are you sure? yes | no

Michael Gardi wrote 12/17/2023 at 17:16 point

Thanks Dave.

  Are you sure? yes | no

Tom Nardi wrote 12/14/2023 at 08:26 point

What a lovely story, glad to hear your work on the MCM/70 was recognized. Sounds like it was a great time at the event. Looking forward to seeing this project progress, your replicas are always a source of inspiration.

  Are you sure? yes | no

Michael Gardi wrote 12/14/2023 at 11:08 point

Thanks Tom. 

  Are you sure? yes | no

GeoNomad wrote 12/12/2023 at 18:45 point

I am really looking forward to seeing your progress on this project!

  Are you sure? yes | no

Michael Gardi wrote 12/14/2023 at 11:12 point

Thanks again for your interest. Probably not much going on for the next couple of weeks but full steam ahead after that. 

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates