A few months ago I did an episode on this little 6502 computer that is a sort of clone of the
Apple 1 and runs BASIC.
Unfortunately, it was too limited for me to really have any fun with it.
However, I got several emails telling me about a product called the Maximite or Color Maximite.
So, I decided to check it out.
So, it turns out the Maximite isn’t really a specific computer as much as it is an architecture
or platform based around the PIC-32 micro controller.
But it’s the firmware that is loaded onto the micro controller that makes the magic
happen.
There’s no one specific Maximite computer that you can buy.
I ended up buying something called the CGColorMax2.
It’s essentially the same thing, but comes on a prototyping board and it was already
assembled for only $57.
And so here it is.
Now, this is actually considerably larger than some Maximite computers, but the main
reason I bought this one was because it was the cheapest one I found with the VGA connector
already onboard.
And as you can see, it has basically just one chip, the PIC32, which does nearly everything
on this computer.
And on the back, we have a PS/2 keyboard port.
A standard VGA port, and a regular USB mini-B style connector for power.
It also came with this barrel jack that can be soldered in right here to use for power
if you don’t want to use the USB port.
And all of this area is is just prototyping area where you can solder in whatever chips
or other things you want to control.
And here is a slot for a standard SD card.
Although I should mention this is not required for operation.
It has everything it needs already built in.
Also, it does have ready made expansion areas for RS232, RS485, and even CAN-Bus.
Let’s try this thing out.
I’m just going to use an old cheap VGA monitor.
And I’ll use the same little PS/2 keyboard I used on the other little computer.
I’ll just plug these things in, like so.
For power, I’ll just use this regular cell-phone charging cable and adapter.
And let’s see what it does.
First thing we see is this logo screen.
One thing that surprised me is that this was developed back in 2011 to 2013.
So, this is not exactly new.
And it looks like I need to figure out how to set the clock on this thing.
But otherwise, this thing is ready to go.
It’s in BASIC, just like a computer from the 1980s.
And if you want, you can treat it exactly like that.
I’ll do the obligatory looping print statement that everyone has to try in BASIC.
But let’s try something else, something with some graphics.
So, I wrote this little program that puts random colored lines on the screen.
Now, I’ve written similar programs since I was a kid on just about every computer that
can run BASIC.
And before I show you this, I want to show you essentially the same program on the Commodore
128.
The commands are slightly different in Commodore BASIC, so the program isn’t exactly the
same.
But it does the same function.
And as you can see, it just puts random lines on the screen in random colors.
Nothing fancy.
When I was a kid I thought this was really cool.
And if you wait long enough, it will eventually fill the screen solid with lines.
Basic is an interpreted language on this computer, which means every command has to be analyzed
and then executed.
It’s much slower than machine language, and when you run BASIC on a 1 Mhz computer,
this is about the speed you can expect from something like this.
It takes it nearly a minute to fill the entire screen with lines.
Now let’s go back to our Color Maximite computer here running essentially the same
program.
Let’s see how long it takes to fill the screen with lines here.
Well, as you can see that didn’t take long at all.
Even though this is still interpreted BASIC, the PIC32 is over a hundred times faster than
the CPU on the old Commodore.
When I did the episode on the 6502 computer, one of the things I said was that I wanted
to spend a few hours writing a version of Tetris on the computer, but I wasn’t able
to do it due to some of the limitations of the video controller.
Now, down in the comments on that video, a lot of people were scoffing at me, calling
me arrogant that I could make a claim that I could program Tetris in just a few hours.
Well, the truth of the matter is, I already had.
Back in 2014 I wrote Tetris on the Commodore 64 entirely in BASIC as a challenge to myself.
The truth is, I had a working version in just about an hour worth of coding.
The trouble is, it was way too slow to play, and so I spent the next 10 hours trying to
figure out ways to make the code more efficient so it was just barely fast enough to play.
So, I had no doubt that I could create Tetris on the Maximite as well, I mean especially
considering how much faster the Maximite is.
But I also want to take this opportunity to show you another way to code on this computer.
Rather than type in line numbers, you can type the command EDIT, which will take you
to a full screen text editor.
So, this is my Tetris code.
One of the things you might notice about this is that there are no line numbers.
They aren’t required for this version of basic.
And, what you can do is use labels instead, which are much easier to remember.
You can also use indents and stuff like that, which make the code much easier to work with
much like coding on a modern computer.
OK, so let’s run this code.
And here it is.
Believe it or not, this took me about 4 hours to code.
And to be honest, 3 hours of that was probably me trying to figure out the differences in
syntax for this version of BASIC as compared to Commodore Basic.
Every version of BASIC has minor differences in the commands and how you do certain things
and this version is certainly no exception in that regard.
One interesting thing I can tell you about this version of Tetris is that it is running
in Graphics mode.
The pieces are actually drawn using line draw commands.
If I were to write this in Commodore BASIC using graphics commands, it would be so abysmally
slow that it would probably take 10 seconds or more for a piece to move after pressing
a key.
But this thing is so fast, it is just seamless.
There are apparently also commands for sprites and things like blitter, to help speed up
graphics for games and stuff, but I’m not even using any of that.
The computer also has sound, but I would have to solder on a sound port as mine didn’t
come with one.
So I didn’t bother putting any sound in this version of the game.
So, let’s talk a little about how the Maximite generates a video signal.
Now, the original Maximite was monochrome only and it could drive either a VGA or a
composite monitor.
Now, it actually uses the CPU to create the video signal, much like one of these guys
or a Timex Sinclair 1000.
Generating a monochrome video signal only requires a single line to be driven high or
low by the CPU and doing that doesn’t require a huge amount of CPU power, especially on
something as fast as the Maximite.
But, how does it generate color?
Well, if you look at the VGA connector, the first 3 pins are for red, green, and blue.
And you also need horizontal and vertical sync.
And don’t forget a ground.
This is, at its most basic, what is required to drive a VGA monitor.
Now, the red, green, and blue lines are analog.
So on a computer different voltages are sent over these lines to generate different brightness
levels of each color.
But the Maximite treats these lines as digital.
Meaning they are either on or off, there is no in between.
That means, it can generate solid red, green, and blue, as well as all of the combinations
of these.
That gives you a total of 7 possible colors, as well as 8 if you include black.
The Color Maximite offers 4 different video modes.
Mode 1 is essentially the same as the original monochrome maximize.
And the two colors it offers are, of course, black and white.
The screen resolution is bizarre.
And my understanding behind why this resolution was chosen has something to do with the timing
of the PIC32 chip and apparently there weren’t a lot of choices available and this was the
best compromise.
While my LCD monitor here will display it, it doesn’t really display it very clearly
because the resolution is so unusual.
However, if you connect this thing up to an older style CRT monitor, you’ll find the
text to be very nice and clear, since those are all analog and don’t really care that
much what resolution you give them.
The second two modes are essentially just 4 and 8 color versions of the first mode.
Mode 4 is the most interesting because it was designed primarily for games.
It gives the full 8 colors, but it also leaves more video memory open for things like sprites
and also just runs faster in general.
This is the mode my Tetris program runs in.
You can actually change modes on the fly.
So, I’m in mode 3 here and the text is pretty small.
I can change to mode 4, and the text will be huge, like an old 8-bit computer.
The Maximite can also display video on a composite monitor or television.
But you may notice it does not include a composite video connector.
Instead you have to create an adapter for the VGA port.
So, back to our diagram.
If you want to convert this to composite, here’s what you need to do.
You won’t be needing the green or blue pins.
Nor will you need the vertical sync.
The RED pin becomes the main driving signal, and the horinzonal sync connects with a 680
ohm resistor to generate the composite sync pulses.
And ground is still ground.
However, this arrangement alone won’t convert a VGA signal to composite.
You have to tell the Maximite computer that it needs to change its behavior and output
a composite video signal instead.
And the way you do that is by grounding pin 9.
So I decided to build my own composite conversion cable.
I have a spare VGA cable, so I’ll just snip the end off of this and build what I need
right here.
OK, so you can see there are quite a few wires here but we don’t need most of these.
I’ll have to use my multi-meter in continuity mode in order to trace out which wire goes
to which pin.
However, I ran into a problem.
I managed to find all of the wires I needed, except for one problem.
Remember that pin I needed for telling the maximize to switch to composite mode?
Well, it turns out that isn’t a required pin on most VGA monitors, so this cable I
chopped up doesn’t actually have any wires going through it that connect to that pin.
So this was a total waste of time.
In the trash it goes.
Well, if I can’t do this the elegant way, I guess I’ll do it a non elegant way.
I don’t have time to order the correct components for this, so I’ll just stick some paper
clips in there.
And don’t forget some alligator clips.
And there we have it.
A very quick and dirty composite hack.
And don’t laugh because it does work, as you can see!
I’ve got this hooked up to my old Commodore monitor.
Although any television would work as well.
The text is actually very clear.
I have no complaints at all about that.
I’d say this is as sharp or sharper as any computer from the 80s would have displayed.
Now, beyond the fact that this is monochrome, which I expected, I noticed the screen resolution
was also different.
I’m not entirely sure what resolution is output in composite mode, but it is definitely
not the same.
Also, you’ll notice that the various mode commands have absolutely no effect when using
the composite monitor.
That’s because there is literally just one mode for composite.
However, it isn’t bad.
I could certainly write programs and stuff in this mode.
The full-screen editor seems to work really well too.
I thought I’d try out my Tetris program.
Again, it doesn’t work exactly right because the screen resolution is wrong.
In fact, it looks like the pieces fall into a void because you can’t actually see where
they are landing.
Of course, it isn’t a big deal to just go back into the editor and change some code.
Specifically the height of the Tetris pieces.
Making them 2 pixels smaller seems to do the trick.
Now the game plays just fine in composite mode.
While it may not be nearly as colorful as before, it is certainly no less playable.
between the composite mode and VGA monitors, that really gives this computer a wide variety
of cheap displays to use with it.
In fact, I wanted to connect up my video capture device and see how it handled it.
While it didn’t have any problems with syncing the signal, the weird resolution did leave
it a bit fuzzy for some reason.
Still, it is readable.
After some experimenting I was able to figure out the video resolution in NTSC composite
mode is 304 by 180.
Also a bit of a strange resolution.
And I wouldn’t be surprised if PAL mode is different.
OK, Up to this point, I’ve been showing you how to use this more or less as a computer
to play around with BASIC.
But keep in mind, this is still a micro controller and it’s main purpose is to control electronics.
If you’ll notice up here it has quite a few general purpose input/output pins, and
these can all be used to connect up to things.
To make things easier, I'll solder in this pin header.
Ideally you would want one double this size, but this is all I had laying around, so it
will work just for demonstration purposes.
I’ll just solder these in here.
And there we go.
One problem I didn’t realize until after I looked at the schematic is that I am not
getting a ground pin.
That’s one of the pins from the next row that my header didn’t connect to.
Oh well, I will just get ground from the VGA connector here just for testing.
I’ll connect the other wire to PIN 13.
Now, you’ll notice my voltmeter is reading essentially zero voltage here.
Let’s try a few commands.
First, I’ll type SETPIN 13,8.
What this does is configure PIN 8 as an output pin.
Next, I’ll turn on pin 13 with this simple command.
As soon as I press enter, you’ll see the voltage change.
Another neat thing you can play with is pin zero, which doesn’t actually exist as a
pin, rather it controls the power LED.
So I can use a 1 to turn it back on, like so.
So, using these IO lines, you could connect up all kinds of things including little LCD
screens, temperature sensors, servos, basically anything you can connect to an Arduino, you
could connect to this.
So, what’s the bottom line here?
Well, I get a lot of emails from people wanting me to recommend a vintage computer to them
so that they can learn to program in BASIC for whatever reason.
And I usually wind up recommending the Commodore 64 simply because they are very obtainable
and the price is typically reasonable and there’s a lot of documentation on it.
But, to be honest, this is a much better option.
It’s cheaper, it’s probably more reliable, and you can save your programs to an SD card
and even copy them over to your PC if you feel the need.
That really makes it a much better option for a BASIC learning computer.
But, what about as a micro controller?
I’ve never messed much with micro controllers, and part of the reason is because you’ve
got to install this suite of software on your computer.
And then, you’ve got to learn to use that software, learn to use whatever language the
micro controller needs to use, then you’ve got to upload that code into the micro controller
before you can even test to see if it works.
And so, there’s kind of a big learning curve in order to use a micro controller.
The Maximite really solves all of that by making the barrier to entry much, much lower.
And if you need something smaller, you know one of the great things is that you can develop
code on the Maximite and then copy the code over to something like this, like the mini
Maximite when you’re done.
So, this is a really neat device.
I’m glad that it was recommended to me.
I may find further uses for it in the future.
But, that about wraps it up for the moment, so stick around for more retro stuff, and
thanks for watching!