Memo-1

In the series "other distracting activities during the heatwave," I looked into the very simple development by a "local guy"—that is, a Frenchman—who created a small computer based on the 6502 processor, with the particularity of being able to connect to the French Minitel. I always appreciate seeing this precursor of networked computing, the Minitel, being put to use. The capabilities of this machine were very limited. The major consequence was that for more than fifteen years, very simple and highly standardized "digital" applications were developed, which enabled French businesses to rapidly increase their efficiency. Imagine: a very simple interface whose learning curve—just a few dozen minutes—was enough to acquire the reflexes needed for a significant boost in usage efficiency. No stress for the user, the "graphical" interface never introduced any uncertainty. And what about security? Point-to-point connections with no possibility of hacking, unless one broke into Transpac distribution points, which were moreover equipped with non-standard hardware to even attempt sniffing a communication. How things have changed. Using Microsoft's online typewriter, um... yes... why not! And will this still be useful with AI?

I suggest you take a quick look at his YouTube page: Memo-1

I grabbed a few screenshots from his YouTube page.

Charming little board, isn't it?

As usual, its format is proprietary. The author took as an example the format of the old cardboard programming cards that were found on virtually all programmable computers of the era, notably the 80-column IBM cards. The problem with all these cards in incompatible formats is that once the board is assembled and tested, well, you put it away and move on... to the next one. As a result, you accumulate these boards and end up forgetting about them. And when you take them out of the drawers again, you still have to find or rediscover the specific connectors, the power supply, the USB-to-serial converter, etc.

So, for the past few months now, I have decided to take the boards I found interesting and remake them in the Euro RACK format. That way, it will "just" be a matter of getting a RACK with a backplane board and a standard power supply, and the boards can be inserted into the available slots, remaining easily accessible at all times, and, of course, stored in the same place. I have always found the TI99/4A's bus expansion system particularly interesting.

Gorgeous!

So I took the MEMO‑1 schematic and redrew it, replacing the expansion connector with a backplane bus connector. I also added a real‑time clock connected to the VIA via the I²C bus, which will need to be implemented using the VIA's I/O ports. This will require some specific programming that can be done later. As for the backplane bus pinout, I adopted the EuroBEEB format, since that system also used a 6502. This results in a board that is fairly easy to build and has a compact form factor.
 

On the original MEMO‑1 system, the expansion connector is designed to accept a cartridge. This will obviously not be possible with the backplane bus. It will therefore be necessary to design another small board that brings the essential signals to the front face of the rack, fitted with a cartridge connector. 

Regarding the Cody computer, which I also mention in this blog, I intend to convert it to a rack format as well. Since Cody has even fewer components, this shouldn't be very difficult, even if I incorporate the USB keyboard adapter.

These two systems, as well as the EuroBEEB board, are all based on the 6502, or its more modern version, still available from the Western Design Center. For now, I have nothing planned based on the Z80 processor, since it is no longer in production. However, since I have used Z80 cores in FPGAs in the past, I might be able to perform the same kind of conversion for Sergey Kiselev's CP/M-compatible board : Easy_z80 .

CODY computer

Between two "high-tech" developments, back to pure 80s style. This is about adapting a USB keyboard to the computer developed by Frederick John Milens, which I have already mentioned on this blog.

And no, for now I haven't done anything at all with this machine. I just built one copy because I think the whole package created by Frederick is absolutely brilliant. And I mean it. For anyone who wants to acquire the basics of digital electronics and fundamental computing, the machine, along with its documentation, is absolutely brilliant.

Moreover, the creator of Cody uses a whole ecosystem that is easy to get to grips with and completely free. Since all the sources are provided on GitHub, it is relatively easy to modify all or part of the design. And that is what I am going to present here.

As for me, I did not build the machine's keyboard. It is an extra cost and I prefer to use a basic USB keyboard. This is a purely personal choice. I am not interested in taking the retro concept all the way to the end. For me, the spirit matters above all.

So, to adapt a USB keyboard to this machine, the tactic I use is that of the cuckoo. Yes, the one that steals other birds' nests to build its own.

The idea is therefore to slightly modify the computer's hardware as well as the software that runs the machine. 

The concept of my build is very simple.
I use a USB keyboard to serial port converter module.
I use a small processor to convert this serial code into parallel code, which I then present on the Cody's data bus using a bus driver circuit. 

I am modifying Frederick's BASIC, written in 6502 assembly, to take into account not the scanning of its matrix keyboard, but rather the data coming from my small adapter board. Since the source is well documented, it is easy to make this type of modification. Although I have never used 6502 assembly before, I must say it is incredibly simple, even compared to the Z80. I am using TASM to assemble the source.

My system.

There are no modifications to be made in the Cody SPIN source, because the VIA that normally handles the keyboard matrix has a 256-byte address range, whereas only 16 are actually used. So I took bit A4 of the address bus to differentiate between an access to the VIA or to my board. This is the only physical modification I made.

In the ASM 6502 source, I added a constant representing the base address of my board. From then on, the function that retrieves a valid key code from the matrix keyboard boils down to:

KEYDECODE LDA KBD_CTRL     ; Reads the controller output into A
                         STA KEYCODE        ; Stores A into KEYCODE
                         RTS

Moreover, the KEYTOCHR function no longer does anything and returns immediately since there is no code conversion to perform, as I am doing this conversion directly on my small processor board.

Note that since I don't really know how the two special modifier keys are used, I may have to modify my system accordingly. 

But for now, this is enough for me to validate that my setup works.

The final procedure therefore consists, from a software standpoint, of assembling the BASIC source using TASM, recompiling the Cody SPIN project using Parallax's Propeller Tool, and loading the result into the Cody board. What's great about the Propeller chip is that all tests can be run in RAM, before saving the final code to EEPROM. Parallax's tool is remarkably easy to use.

I am using a RISC-V processor and its associated development IDE, MounRiver Studio. I have completed a number of projects with these tools and I must say that the latest version of the IDE is even more efficient, practical, and pleasant to use. In short, I don't regret the time I spent a few years ago discovering these processors.

Anyway, once everything is set up, it is fairly easy to achieve the expected result. I only spent a few hours of pure hobby time developing this adapter.

Validation of my concept.

And there you have it, the basics are working. All that remains for me to do is to complete the software part to fully emulate the original keyboard.