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

  • Messing Up

    Michael Gardi4 days ago 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.

  • Chess Clocking

    Michael Gardi02/14/2024 at 21:58 2 comments

    The chess clock mode on my CHESSmate Reproduction is now working. It was relatively easy to simulate the 6530-024 Timer by triggering 240 interrupts each minute, which is what the CHESSmate firmware is expecting.

    This accounts for the read to 8B0E (the READ TIMER INTERRUPT register) which clears the current interrupt, and the write to 8B0F (the DIV BY 1024 ENABLE INTERRUPTS register) discovered in my Eureka moment. 

    Number                                     R/W            Program Counter                                       Address                                      Value                    Notes
       1           R           F3908B0EIs Timer Interrupt?    Occurs when a move is made
      2         WF0B28B0FF5 Set Interrupt     Occurs when move is made

    Writing F5 to the 8B0F register starts a 250 millisecond timer that will trigger an interrupt when it expires. Once the interrupt has been processed a read to 8B0E will clear the interrupt. When the interrupt service routine processes 240 such interrupts, the minute timer for the current player is incremented by 1. The fractional part, 1/240th of a minute is retained between moves.

    Chess clock mode is "stand alone" in that you cannot play chess against CHESSmate when you are chess clocking and vice-versa.  You get into chess clock mode by pressing C then ENTER. Pressing H starts WHITE's clock running, then pressing A stops WHITE's clock and start's BLACK's clock.  H then switches back to WHITE, then A BLACK and so on. You can press the E key to stop the current clock then E again to restart it.

    Here we see that BLACK is moving and has used up 2 (+)minutes of their clock. When BLACK is done moving they will press H to switch the clock to WHITE. CHESSmate remembers and applies the fractional part of the time used between moves. 

  • Eureka!

    Michael Gardi02/14/2024 at 01:19 2 comments

    After I convinced myself that the emulator was probably OK, I turned back to the ROM.  But after I found yet another ROM image online, and it turned out to be identical to the other three, I have to rule out bad ROM as well. Just as well as I was reluctant to put my original CHESSmate at risk.

    So that means that my emulation of the CHESSmate hardware must be wrong. However, as  far as I could tell, I was handling all of the reads and writes from the firmware. I knew this because I had code in place to detect unhandled I/O.  And that would have been a valid assumption if I had put the unhandled code in the right place!

    Whoops. Embarrassing.  When I relocated the code to the correct spot I discovered that I had missed a few interactions.

    Number                                    
    R/W            Program
    Counter                                       
    Address                                      Value                    Notes
       1           R           F3908B0EIs Timer Interrupt?    Occurs when a move is
    made
      2         WF0B28B0FF5 Set Interrupt     Occurs when move is made
      3RFEF08009Doesn't matterOccurs constantly. Part of the main keyboard / display loop.
      4RF3058xxxFFOccurs when move made.
      5RF3098xxxFFOccurs when move made.

    So what does this mean?

    1, 2 - 8B0E and 8B0F are part of the RRIOT Control Registers. I was surprised that I was not picking these up.  When I looked at the code I found my second error.

    #define RRIOT_REG_SIZE 12

    There are 16 registers not 12. The 8B0E and 8B0F registers control the RRIOT's Timer. Because of my error, I had not seen these before so I thought that CHESSmate did not use the timer.  I was wrong. I did notice that the chess clock feature was not working though. So I fixed the define and am now processing these interactions but will have to spend some time figuring out how they should work. TODO.

    3 - I'm not sure exactly what this is doing. It's related to this piece of code:

    FEEB 29 7F                AND #$7F
    FEED 2C                 .byte $2C       ; BIT skip next instruction 
    FEEE 09 80       LFEEE    ORA #$80
    FEF0 A0 00                LDY #$00      ; lookup conversion
    FEF2 8C 00 8B             STY SAD       ; turn off segments
    FEF5 8E 02 8B             STX SBD       ; output digit enable
    FEF8 8D 00 8B             STA SAD       ; output segments
    FEFB E8                   INX
    FEFC A0 7F                LDY #$7F      ; delay 500 cycles
    FEFE 88         CONVD1    DEY
    FEFF D0 FD                BNE CONVD1
    FF01 60                   RTS

    The 2C 09 80 sequence is treated as a BIT operation on the absolute address 8009. This sets the Negative flag in status to bit-7 of the byte read, and the Overflow flag in status to bit-6 of the byte read. Since there are no subsequent branch instructions I'm pretty sure this sequence has no effect on the code. This looks like a patch of some sort. Ignored.

    4, 5 - These occur when a move is being made. The address is in the 8xxx range but varies quite a bit. They are associated with this piece of code. 

    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

    So I do the sequence H - ENTER (switch CHESSmate to WHITE), G - ENTER (CHESSmate MOVES). If I return a 0 to these two reads CHESSmate fails returning the move H1 - H1. If I return FF to the reads, CHESSmate plays E2 - E4, the same as the original game.  I think that this has something to do with the opening book. I'll have to dig in a bit to figure it out.  TODO

    The bottom line here is that with these changes the game plays pretty well now. I played a couple of full games today...

    Read more »

  • Hardware Good, Software Not So Much

    Michael Gardi02/12/2024 at 19:40 0 comments

    While I continue to try and determine what's up with my CHESSmate firmware, I'm forging ahead with the hardware. 

    Hardware

    I'm reasonably certain that the CHESSmate PCB and ESP-32 are working as expected from an electronics perspective. So to that end | have designed a daughter board to attach the ESP-32 to the back of the main board via the 22-pin header.

    The idea is that the daughter board will have a 90 degree female header underneath and facing "inwards" to connect with the existing male header on the PCB like a little "back pack". My original thought was to redo the PCB and add the ESP-32 to the board itself, like Oscar Vermeulen did with his KIM Uno project. In the end I decided this way was more flexible, especially if I (or someone else) ends up doing a 6502 based hardware "back pack".

    Software

    On the software side I have tried a few time to play a game through on my reproduction. At first everything seems to be going great. But after five or six moves CHESSmate signals that a move I have made is invalid even when I know it's a good move. There is an option to check the positions of all the pieces on the board (B - ENTER) and when I do this I find that CHESSmate has lost track of one or two of the pieces. Sigh. I have the hardware now to dump the ROM from my original CHESSmate. I sure hope that is the problem because if the ROM is not different from the ones I download I'm not sure where to go next. 

  • 99% Sure It's Not an Emulator Bug

    Michael Gardi02/08/2024 at 17:53 0 comments

    I ported the CHESSmate code to a Raspberry Pi 4 running under a Python based 6502 emulator. One thing that I learned doing this is that this emulator runs way to slow to be a viable option. Perhaps a C based 6502 emulator running on the Pi would fare better.

    To my surprise, CHESSmate exhibited exactly the same errant behavior as it did running on the ESP32 and the Arduino Pro Mini.  So there is  no way that these glitches are a result of a misbehaving emulator. 

    So I guess I'm back to bad ROM images. I guess I'll have to dump the original CHESSmate ROM to know for sure.

View all 26 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