raspberry pi

January 3, 2019 by robert Leave a Comment

Workbench Retro Computer Pt. 3

TL;DR; rPi firmware installation and troubleshooting.

PiGFX is located at: https://github.com/fbergama/pigfx?fbclid=IwAR1-AOMMtR0iOuaQAmUgeQPbty2tmBa8ILsbNYOb5v-wPQC_UYzudv06IYY The “kernel.img” file that you need can be downloaded from this site. The instructions say that “start.elf” and “bootcode.bin” are available in that github /bin directory, but I found that to not be the case. You also have to make a “config.txt” file on the root of the SD card.

After loading up the SD card I popped it into the rPi. I was happy that the original Pi that I had (without ethernet jack) fired up and showed something on screen.

Better than nothing, right? So this was a bit of garbage on the screen. I suspected that it was noise picked up from the open serial input pin. To test this I put a green jumper wire from serial out to serial in.

So with this jumper in place, the text typed on the keyboard should go to the serial output, loop dizzyingly through the green wire, and return to the serial input thus being displayed on the screen.

Resetting the board with the loop back connection (green wire) in place brought up this screen:

Colorful! The startup screen also shows that the USB keyboard that I plugged in to the rPi was found. Oddly, though, when I typed something on the keyboard this time, nothing showed up on the screen. I unplugged the green wire, immediately got noise on the serial input which cleared the startup screen and displayed random characters (like before) and only then anything I typed on the keyboard was displayed.

So the PiGFX firmware waits to receive a character before allowing the keyboard to output a character. This could be rather limiting if the system you connect to waits for a key press before sending anything out the serial port. 🙁

With a successful loop back test performed I connected this hardware to a microcontroller board that I knew was set to communicate at 115200 baud.

And it didn’t work.

After a little bit of troubleshooting, I hooked up a scope to the serial output to verify the baud and it was way off. The reason? I failed to copy the “config.txt” file to the SD card. Without that config information, the serial port runs too fast.

Here is the file for the SD card, so that you can just download it to your own SD card.

config.txt Download

With that file correctly added to the SD card, I was able to communicate with my target. Unfortunately I discovered a problem with the PiGFX terminal code. My microcontroller board depends upon the ability to move the cursor to some absolute screen positions using escape sequences. The PiGFX firmware is supposed to support this, but the original developer assumed that the upper left screen position was location 0,0 when it should be 1,1.

In old terminals that upper left position was line 1, column 1. The screen positioning starts at 1, not at 0. I’ve contacted the person that is maintaining the code with this issue.

The PiGFX itself is still useful. And the PiGFX in this Workbench Retro Computer will still be useful, but it would still be better if this was fixed.

(Part 4 will be coming up after the PiGFX firmware is fixed.)

December 28, 2018 by robert Leave a Comment

Workbench Retro Computer Pt. 2

TL;DR; Adding HDMI output and USB keyboard input to the Workbench Retro Computer using a Raspberry Pi.

There is a project called PiGFX. This project converts a Raspberry Pi into a serial terminal. https://github.com/fbergama/pigfx?fbclid=IwAR1-AOMMtR0iOuaQAmUgeQPbty2tmBa8ILsbNYOb5v-wPQC_UYzudv06IYY

The Pi has an HDMI port that can be connected to an LCD monitor to display a rather colorful output.

From the project description:

“PiGFX is a bare metal kernel for the Raspberry Pi that implements a basic ANSI terminal emulator with the additional support of some primitive graphics functions. It can be driven by pushing characters to the raspi UART. Additional functions like changing text color, moving the cursor or clear the screen can be invoked via ANSI escape codes. The result is that you can easily add an HDMI display output to your embedded project without the hassle of directly generate the video signal.”

Essentially this Pi and the firmware loaded into it can be split into two distinct functions. With a USB keyboard attached to the Pi, characters typed are sent out a 3.3V serial port. Any serial characters received on the serial port of the Pi are displayed on screen (the HDMI output).

The USB-keyboard-to-serial function of the PiGFX hardware/software is of secondary importance in this project, as the former AlphaSmart keyboard will be decoded to provide the serial stream.

The serial-to-HDMI is the essential purpose for the Pi in this project. It might be seen as wasting a lot of processing power using a Pi in this way, but it was an under-powered Pi to begin with, and this is still a low-cost way to add an HDMI “video card” to this project.

Gotta pick a place to begin, and this upper left corner should work OK. I had to carve away some plastic and notch the sides to get it to fit.

The Pi fits in the case rather snugly.

Next blog is the firmware for the Pi to make a terminal.

December 28, 2018 by robert Leave a Comment

Workbench Retro Computer Pt. 1

TL;DR; I’m repurposing these keyboard+cases into a programming and interfacing tool that I can use much like a flexible 8-bit home computer. Serial input/output, HDMI display, more.

I stumbled onto a couple of items called AlphaSmart Pro. At first glance I thought that they were some home computers from the 1980s.

They look a lot like the 8 bit computer-in-a-keyboard that were prevalent at that time. Look at what Google gives you when you search images for 8 bit home computers:

Google image search for 8-bit home computer

The AlphaSmart Pro wasn’t a 1980s general-purpose 8 bit home computer. It has a lot of the 8-bit guts to have been a home computer – 8-bit processor, RAM, ROM, etc. The AlphaSmart Pro was instead used to type text away from a PC and then return to the PC and upload that text through a PS2 keyboard port. Here is a bit of info from Wikipedia: https://en.wikipedia.org/wiki/AlphaSmart

There were quite a few of those 1980s computers that I had thought would be great to have, and I’ve even had a few come through the lab. I did have a TRS80 Model III at one point that I used as an interface (controller) to some electronics. I think that a small 8-bit style of computer would be nice to have on my workbench. Something that can give me I/O lines to control, serial signals, etc.

Eventually it might be a front-end for several different retrocomputer projects. I recently received a single board Z80 computer: https://hackaday.io/project/159973-z80-mbc2-4ics-homemade-z80-computer The z80 was the architecture that I did the most assembly programming on. I have some 6502 chips in storage, too.

Besides the Z80 and 6502 computer modules, this project will be great for interfacing to the CircuitGizmo MicroMite devices. These all run BASIC and are a 32-bit implementation of retrocomputers. I use these at my bench quite often.