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.

I really don't know where I'm going with this!

Implementing an FPGA isn't very complicated in itself. Whether on the hardware or software side, all it 'takes' is the right learning and a little (or a lot of) motivation to get there. No, it's rather what comes after that gets tricky. The potential of these types of circuits is so vast that you can consider using them in a huge number of applications. The problem then boils down to development cost. It's tempting to pack as much logic as possible into the FPGA. As a result, you quickly find yourself needing a chip with a good number of I/Os, and therefore a large pin count — and thus, a BGA package.

The development cost of a PCB designed to host a BGA-packaged FPGA is not the same as that of a board equipped with a small microcontroller. Nor are the risks of malfunction.

Considering that my field is more on the 'mixed' side — that is, both digital logic and analog — I find it risky to dive into the design of large PCBs containing a BGA package. I prefer to go the module route. That is, to focus specific efforts on the most precise sub-assemblies possible.

I'll take my process of putting the Drumulator into an FPGA as an example. Designing a relatively large PCB with a BGA seems inappropriate for an amateur-style build. So I decided to create an FPGA module tailored to my needs. I should mention that I've already built this kind of module with GoWin FPGAs, but in a 144-pin package. As a result, I didn't implement any memory on that module at all. However, with the goal of providing a complete computing core, I need memory.

So I went with an implementation using a TRION FPGA coupled with static RAM, an EEPROM for storage, a real-time clock, and a battery for backing up the memory and time.

Obviously, I couldn't get away with a two-layer PCB this time. This time, it's four layers. To keep manufacturing costs acceptable, I'm also forced to use through-hole vias, which complicates the board design.

But anyway, after a certain amount of time, I managed to produce the design for the board I want to build.

 

I have to admit that it took me a while to route the entire board. I think I've done a better job than I did with the MSX cartridge. I suppose that's normal — it takes experience, and experience only comes through iteration.

That said, on this board, I paid particular attention to the connections between the FPGA and the SRAM. The traces are short, and I matched the lengths of all bus signals, so that a fairly high operating frequency can be used.

As for the available I/O connectors, generally speaking, the traces on the 'component' side will be fairly fast since they won't encounter any vias. That should compensate for the signal integrity loss caused by longer trace lengths. The other signals will have at least one via along the path, and some of them two, though the latter case is very rare.

I have no idea how I'm going to actually assemble this board. The PCB manufacturer I work with doesn't stock Efinix FPGAs. So either I find another supplier capable of assembling these FPGAs, or I mount them myself. In which case, I'll need to get a hot plate to solder the main components.

Moreover, I don't know whether the wiring as it stands will actually allow the JTAG programmer to work properly. To figure that out, I need to wait until I implement the MSX cartridge, so I can verify that the power supply I've set up is correctly matched to the FPGA, and that the JTAG connections are properly made.

So, designing this board has already been an adventure. I was really skeptical about whether I'd even get to the end of it. Assembling this board is going to be a new adventure. But hey, if I really want to move beyond the 'Sunday tinkerer' phase, I have to take it to the next level. And since I've now gained a good command of VHDL coding, I no longer have a choice — I have to go for it.

 

And now for something completely different!

While waiting to receive the printed circuit board for the MSX cartridge, I started working on making a compatible USB card for the AKAI S5000/S6000 samplers.

The reason is that I know someone who is developing a new version of AKSYS that works perfectly under Windows 10 & 11. It turns out that not all Akai S5/6000 machines were shipped with this card. That's a shame.

So I studied the card I own and looked into whether it might be possible to create a new version.

It turns out that it is.

On the one hand, a USB component compatible with the one on the original USB card still exists today. And on the other hand, I was able to retrieve the logic equations of the PAL chip that is on this card.

For now, these equations seem to be correct, since I was able to repair another original but faulty USB card using a GAL programmed with my equations. So I am hopeful that this will work, even though the decoding performed by the original PAL is quite unusual.

The card's schematic is also unusual. Without going into too much detail, some functions are implemented by first latching a kind of register — registers made out of resistors and capacitors.

In short, the read and write functions are not direct but require going through other operations first.

In any case, I have completed the schematic and then the PCB for this card :

So, I have no idea whether this new card will work or not. The only way is to test it and compare the signals with the original card if it doesn't work.

Next steps after the first tests....