VAL() takes a string and converts it in to a floating point numerical variable. The value of “1E39” is a number in scientific notation, and this appears to cause a problem.
In Microsoft BASIC, the notation “1E39” represents the number 1 multiplied by 10 raised to the power of 39. This is also known as scientific notation, where the “E” indicates the exponent to which the base (10 in this case) is raised. So, “1E39” is equal to 1 * 10^39, which is an extremely large number:
File: PONGTEST.TXT - Revision 1.1 (5/16, 5/18/93) - By Allen C. Huffman
In the beginning there was...
XXXX XXX X X XXXX
X X X X XX X X
XXXX X X X X X X XX
X X X X XX X X
X XXX X X XXXX (tm)
And now, two decades later, Pong(tm) will live again...
[DISCLAIMER: The game name "Pong(tm)" is a TRADE MARK of Atari
Corporation. None of us have anything to do with Atari and we are using
this name strictly as a term to define a video game concept. Read at your
own risk.]
And to think...this rather bizarre idea all started with an impromptu
P.A. announcement at the 2nd Annual "Last" Chicago CoCoFest in May, 1993.
The announcement, written by Sub-Etha founding partner Terry Todd, went
something like this:
Sub-Etha Software, in voluntary cooperation with StG
Net, StrongWare, Intelligent Algorithms, Dave Myers,
BARSoft, Burke & Burke, HawkSoft, the National OS9 Users
Group of Australia, and more of the rest of the CoCo
Community will be sponsoring a programming competition in
which each participant will create a unique, original
PONG(tm)-type game. This contest is open to all who wish
to enter. The programs will be impartially judged at the
1991 Atlanta CoCoFest on the basis of Memory Efficiency,
Speed Efficiency, Originality, Special Effects, and
Playability. The programmer judged best in each category
will receive a cashiers check in the amount of ONE DOLLAR!
THE BEGINNING
Video games all started with Atari's original PONG(tm) game. This
tabletop two-player game, reportedly created in 1972 with a production of
8000 units (see "The Killer List of Video Games", Dec 1992 version, in
text-file format available from various sources), became an instant
success. The original PONG(tm) units are rumored to have broken down
their first day(s) in service...from jammed coin mechanisms. (Atari could
not be reached to comment on this bit of video game lore...)
It occurs to me, though, that many of our fellow CoCo/OS9 users might
not have even been BORN or, if born, might not have even been old enough
to have ever seen a PONG(tm) game either as a console game or the later
home versions (before the Atari 2600, even). For those...a bit of
background...
WHAT IS PONG(tm)?
PONG(tm) was a digital version of table tennis. A black and white
image consisted of a dotted line down the middle of the screen
(representing the net), with a small vertical line on each side of the
screen representing the paddles. A small square represented the ball,
which would bounce back and forth, hopefully to be deflected by a paddle.
Score was kept it the upper corners and typical tennis rules applied -
the first one to 21 won.
It was simple, and it was amazing. (I first remember seeing a
PONG(tm) game in a Shakey's Pizza Parlor in Houston...) Sadly, many
people only remember this classic as a cartridge that used to be available
for the old Atari 2600 called "Video Olympics" (or something like
that...it's been awhile)! Even the original stand-alone home game
machines that did nothing but play PONG(tm) (or the many numerous clones)
have long since been forgotten...until now.
WHAT'S THE DEAL?
It occurred to us that PONG(tm), one of the simplest video games of
all time, might be an interesting target of a programming contest. A
PONG(tm)-type game could be written in BASIC and be quite playable, or
souped up in assembly for some real speed. What we propose is an open
challenge for programmers. What would YOU do with a PONG(tm)-type game?
Perhaps a "classic" version (how close can you make it to the original,
"beep" sounds and everything?) or an updated colorized version, perhaps
with better sounds? Maybe something completely different - a
PONG(tm)-type game with "power-ups" or weapons. Let your imagination take
control. Points will be awarded in a number of categories. Just follow a
few basic rules.
THE RULES
There aren't any, really. Your version of a PONG(tm)-type game must
run on a CoCo under Basic or Assembly (either 6809 or 6309), or under OS9
('C', Basic09, whatever) or even under OSK (MM/1, TC70, etc...). If
enough entries are received, categories will be created for as many
"types" as possible.
To qualify as a PONG(tm)-type game, it must follow a few guidelines.
First, you should have a bouncing ball. Second, you should have two
paddles (and support one or two players) with which to bounce the ball
back and forth. Scoring should go until 21 with whoever gets there first
being the winner. The ball should start from the middle of the screen and
head towards one side. Whoever scores a point gets to "serve" again, and
the ball will launch towards the opponent, just like in tennis. That's
it! The "net" I guess would be optional. <grin>
To summarize: Make it recognizable as a PONG(tm)-type game then use
your imagination!
JUDGING
All received entries will be judged at the Atlanta CoCoFest (which
will probably be held in October) by an impartial individual or group.
Several categories have been established, with more added later if
necessary. These categories are as follows:
o Memory Efficiency
Awarded to whoever writes the "smallest" PONG(tm)-type game.
o Speed Efficiency
Awarded to whoever writes the fastest PONG(tm)-type game!
o Originality
Anything goes! This will be awarded for the most original
twist on the old classic.
o Special Effects
The game with the most "bells and whistles" will get a prize,
too! Music, graphics, whatever...basically, the version that
looks/sounds the best.
o Playability
No matter how memory or speed efficient, original, or "special"
a game may be, if it's no fun to play, it's not a good game.
The will be one overall winner of all entries judged to be the
"funnest".
THE PRIZE
The "press release" states an award of ONE DOLLAR for winners in each
category. This may not sound like much of a prize, so let's make things a
bit more interesting. Al Dages of the Atlanta Computer Society has
decided to throw in a TEN DOLLAR prize to the overall winner, and
(although maybe jokingly) Dave Myers talked about chipping in an extra
BUCK too. If $13 for top honors still doesn't appeal, let's go a bit
further.
Marketing, my friends! We will attempt to compile a disk (or disks)
of all winning entries and a "reasonable fee" will be charged for this
disk. Funds generated will be split amongst the programmers. Sub-Etha
Software (with hopeful support from other vendors) will "foot the bill"
for the disks, labels, and duplication costs.
If that's still not enough, there MAY be more! We will be talking to
other vendors and see about getting together more prizes for the winners.
This part of the contest will depend entirely on the response from other
vendors (who are, by the way, ALLOWED to enter, too!). It may never be as
good as winning the lottery, but it certainly should be fun!
HOW CAN I ENTER?
Simply write a PONG(tm)-type game and get it to Sub-Etha Software!
As mentioned earlier, you can write it under BASIC, 6309 or 6809 assembly,
OS9, or even OSK. "Cheating" is allowed for all versions, by the way. We
are more concerned with the outcome than "how it got there"...just make
sure it doesn't do anything too bad!
The competition should be interesting. Several "well known" CoCo
programmers are rumored to be interested in working on PONG(tm)-type games
for this "for the fun of it" contest. Don't let that discourage you,
though! We'll do our best to try to make it as fun as possible for all
involved! So...ready? Then let's get started! The clock is ticking.
Get those balls bouncing, and let's have some fun!
DISCLAIMER
Please note that we are in no way connected with Atari Corporation
and have neither their permission or praise to hold a PONG(tm)-type
contest. The game name, PONG(tm), apparently remains property of Atari
but, over the years, has fallen into such common usage that we felt we
should be able to get away with using it to describe this contest without
fear of a nasty lawsuit. (BUT, it is NOT acceptable to call a game simply
"PONG(tm)". That has been used... ;)
Of special interest, though, will be my attempts to contact someone
at Atari for more official information on the history of PONG(tm) as well
as possible "official" permission to actually use the name legally. Who
knows! Maybe we'll be able to take the winner and have it released as a
"real" PONG(tm) game with Atari's blessing...but don't hold your breath.
Let's just have some fun.
THE END
Terry, just look what you have started! Any vendors interested in
upping the stakes can try to contact me via electronic mail
(COCO-SYSOP@GENIE.GEIS.COM) or leave a message on the Sub-Etha OSK Midwest
Division line at (815) 748-6638 (24 hours a day) and it will be relayed to
me. Of course, U.S. Mail is always available...
Sub-Etha Software
P.O. Box xxxx42
Lufkin, Texas 75915
Have fun! I will be looking forward to your entries! (OSK entries
can be directed to Joel Hegberg and perhaps might even be better mailed
directly to Joel...Leave a message to JOELHEGBERG@DELPHI.COM to get
instructions on how to get something to him...) Thanks!
ADDENDUM
On 5/18/93, I received a return phone call from a lady at the Legal
Department of Atari. She is currently checking into some "official"
PONG(tm) history for me, as well as finding out some legal guidelines for
using the name PONG(tm) in this text file. Suffice it to say that I had
to revise this file and make sure that the TRADE MARK was clearly visible.
To further disclaim all of this...we are NOT writing PONG(tm)...but games
that are PONG(tm)-like. (Thus, all the changes in this document from
Revision 1.0...)
There is a classic Commodore one-liner program that prints a maze. I have discussed it on this site several times in the past:
10 PRINT CHR$(205.5+RND(1));GOTO 10
I converted it to use CoCo ASCII “/” and “\” characters:
10 PRINT CHR$(47+(RND(2)-1)*45); : GOTO 10
I have since noticed that the 10 PRINT book even has a version for the CoCo in it:
https://10print.org/10_PRINT_121114.pdf page 55
Recently, Jim Gerrie posted a video of a new one-liner MC-10 version of the maze that truly fit on one 32-column line of the MC-10:
https://www.youtube.com/watch?v=7FQ_ht5u2y4
His approach of using MID$() looked much simpler than the CHR$ version of the Commodore original. I am pretty sure my VIC-20 had MID$ so surely the C64 had it as well. Why wasn’t it used? Perhaps this was an example of code obfuscation. “Type in this mysterious code and see what you get!”
Indeed, in a quick test, using MID$() is smaller and faster:
Now, doing the MC-10 version with CHR$() would be longer on the CoCo since we can’t type those characters like the MC-10 allows. We’d have to use CHR$(140)+CHR$(138) embedded in the MID$ to make that work (and be much slower since it would parse those numbers for every byte of the maze it prints). But…
0 PRINTMID$(CHR$(140)+CHR$(138),RND(2));:GOTO
…does work.
To make it faster, we’d need two lines and a string:
Even with that, the GOTO is slower than the MC-10 version since it has to parse a number, and then has to skip a line each time. You could get around that by doing it like this, and starting it with “RUN 1”:
I recently shared the story about my first commercial CoCo product, the Huffman K1 Librarian. This was a MIDI librarian for the Kawai K1 synthesizer. In that article, I mentioned that I later sold my K1 to buy a more-better Kawai K4 synthesizer. What I did not remember is that I apparently made a K4 librarian, as well!
The K4 version was very similar to the K1 original, but the menu was updated to reflect how patches were organized on the K4. It appears the K4 has single patches, blocks of patches, and a way to transfer everything at once.
It also had the same disk command menu.
This version shows a 1991 copyright, so two years after the K1 original in 1989. Although the title screen references Rulaford Research, I do not recall it ever being a product they sold. I’m not sure if anyone ever had a copy of it other than myself. If you know otherwise, please leave a comment.
Thirty two years later and I am still (re)discovering stuff.
Earlier this year, I had the opportunity to experience the Back to the Future “escape room” experience by Universal Studios. I have been aware of escape rooms for some time, and while I thought they sounded interesting, I was never interested enough to try one. But this one was different… I had no idea how different it was until I visited a traditional escape room later.
Universal Studios’ experience is automated, and the puzzles involved pressing buttons and plugging things in. Not once did I have to find some four digit code written on the brim of a hat hanging on the wall in order to open a box that would leave me to another four digit code.
But I digress.
At Universal, your experience begins with a preshow (video of the rules), then you enter the initial room. This is where they set up the story through a video presentation (which featured Christopher Lloyd voicing his Doc Brown character from the movies). The room would have various puzzles that were randomized (allowing for re-playability) and if you got stuck, the show system would give hints. Eventually, a door would open and you’d go in to the next room (even if you didn’t solve anything).
Since each room had several levels of puzzles, you might get none, or all, but you still get to proceed. If I recall, this experience featured five (or six?) different rooms, and kept you moving.
There was great sound, music, effects, lights and even smoke.
And that set the bar too high.
Recently, we went through an unlicensed (*cough* copyright infringement *cough*) E.T. the Extra Terrestrial escape room in Branson, Missouri. We spent an hour in two rooms, mostly trying to find codes to various combination locks.
Retromania – Branson, Missouri
Most were four digit number locks. One was a five letter combination lock. And one was a school-locker style three digit combination lock.
That was the majority of the experience! Tryingto find (mostly) four numbers that opened a lock!
There was one different bit where you used a magnet on a string to retrieve a key from the end of a pipe (after you found the pipe), and another puzzle involving getting a code by counting blinking lights. The final puzzle, where time ran out on us, were a few knobs that displayed numbers in LED panels. We couldn’t figure that one out before the hour expired.
What I am curious about is — how many escape rooms are mostly just looking for four digit codes and opening locks? We did a local one, ran by a friend, and it did feature many four digit codes, but it had alot more puzzles and was vastly more interesting.
verb: phreak; 3rd person present: phreaks; past tense: phreaked; past participle: phreaked; gerund or present participle: phreaking; noun: phreaking hack into telecommunications systems, especially to obtain free calls. “a few old-time hackers still phreak casually just to keep their hand in”
noun: phreak; plural noun: phreaks a person who hacks into telecommunications systems, especially to obtain free calls. “the nation’s most clever cellular phone phreaks”
– Oxford Languages via BING search for “define phreak”
I expect most of us have some life changing event we could cite that forever changed the direction of our existence. For example, looking through a telescope for the first mite might have led to a career in astronomy. To me, it was when I was in 7th grade English class and I quoted a line from a PBS TV show I had just watched (“The Hitchhikers Guide to the Galaxy“). A nearby student recognized the quote (“you watched that too?”), and introduce me to the books of Douglas Adams.
Jimmy also introduced me to computers, and helped me learn BASIC programming via books he had. We’d go down to the local Radio Shack to type in the programs we’d written down on paper. This led me to wanting a computer instead of an Intellivison (its baseball program could talk!) or ColecoVision (it came with Donkey Kong!), which started my career as a programmer.
In addition to Douglas Adams and computers, Jimmy also exposed me to the world of phone phreaking — though not at any “WarGames” level. It was just a bunch of junior high kids that learned how to make free phone calls from the school’s payphone, or talk with random kids via “loop lines”. (This made me search for “loop line” to see just what those phone numbers were for. I found a Wikipedia entry about “loop around” which does appear to be what I am referring to. #TheMoreYouKnow).
I remember kids all over Houston, Texas were making use of codes that allowed “free” long distance phone calls. This let them dial in to bulletin board systems out of state without the parents throwing a fit when they received a phone bill.
There was a higher level of phreaking that involved devices that would generate special tons that the old phone system would respond to. They were known as “boxes” and identified by a color. The “red box” simulated a tone that told the phone company a coin was inserted in to a payphone. This allowed making free calls from payphones. I see today’s Wikipedia has an entire category on these boxes with colors I never heard of back then. I think I’d only heard of red, blue (2600 Hz tone generator used for free long distance), and silver (four extra buttons on a standard touch tone keypad labeled A, B, C and D). I recall the “D tone” would knock an operator off the line, for some reason.
I actually had a silver box — something my dad found at a store. I remember him telling me (over the phone) that he found a phone that extra buttons on it that were going to be used for future phone services. He said they were labeled A, B, C and D. Somewhere, I still have that phone. I have no idea why this phone existed in stores, and I never knew how to use it for anything, but somewhere I still have it.
Popular computers like the Apple 2s had tons of phreaking software. The Tandy Color Computer had some, as well, including during the CoCo 3 days. Here’s one called “Super Phreak” by “Mr. Bill”:
It seems to be a software implementation of the phreak boxes, though it doesn’t make any sounds for me (at least not in an emulator).
There was one for the earlier Color Computers, called “BOX.BAS”, but based on the menu screen it may have been called “Phreak Operator.”
I wonder who “S Y N T A X” was, and how the licensing worked.
This one does produce tones, so it must have some assembly language audio routine embedded in it as the CoCo BASIC could only do one tone voice at a time.
But I digress…
In addition to loop lines, hardware boxes, and using codes for free long distance, there were other things lumped together with phreaking, such as having a computer dial numbers looking for other computers. This went by many names (we called it simply “modem scanning”) at the time, but today I see the Wikipedia refers to it as wardialing.
A famous example of this comes from the 1983 movie WarGames where David Lightman (played by a young Matthew Broderick) has his computer scanning for modems, and ends up finding the W.O.P.R. (War Operation Plan Response) supercomputer at NORAD.
WarGames wardialing clip
Unlike the infamous payphone scene, the movie was quite accurate on this. I expect folks wrote replica programs to recreate the user interface:
It does make me wonder how much the wardialing cost his parents. It sure sounded like his computer was just dialing a bunch of long distance numbers in area code 311 ;-)
The Radio Shack Color Computer also had programs that did this. I have two versions of “Modem Scanner” that used a Hayes-compatible modem hooked up to the Serial I/O port of the CoCo. In BASIC, the program would send dial commands to the modem using PRINT #-2 (as if they were going to a serial printer), and then it would use PEEK to look for the carrier detect pin to go high on the port. If a CD was not detected after some time, it would send the hangup command and move on to the next number.
It looked like this:
Above, you can see it would list the status of every number dialed, similarly to the WarGames program.
Using the “print to file” feature of the XRoar emulator, here is what was being sent to the modem:
+++ATZ
ATT C0 E0 M1 Q1
ATDT 555-0000
ATH
ATDT 555-0001
ATH
ATDT 555-0002
ATH
ATDT 555-0003
ATH
ATDT 555-0004
ATH
ATDT 555-0005
ATH
ATDT 555-0006
ATH
ATDT 555-0007
ATH
ATDT 555-0008
ATH
ATDT 555-0009
ATH
ATDT 555-0010
ATH
ATDT 555-0011
At the top, the “+++ATZ ATT C0 E0 M1 Q1” sequence was the initializing modem part. Looking at the list of Hayes modem commands on wikipedia, I can see that…
“+++” followed by a pause was the escape code that made a Hayes smart modem go from communications mode to command mode. In command mode you could change settings, dial numbers or hang up.
“ATH” was the hang up command. (Hayes commands start with “AT” for attention.)
“ATT C0 E0 M1 Q1” – This was “T” for tone dialing, “C” was not listed as a standard command (not sure what it did), “E” turned off auto-echo so commands did not echo back when typing them, “M” turned ON the modem speaker (geesh, that should have been a settable option), and “Q” turned on quit mode so the modem did not echo back “OK” after each command.
Looking at the BASIC source code shows this notice at the top:
And these version notes at the bottom:
The full source code is here:
0 ' +------------------------+
1 ' ! MODEM SCANNER V1.1 !
2 ' ! BY ZIGLWALD X. MALUSHI !
3 ' ! HAYES COMPATABLE !
4 ' ! MODEM REQUIRED !
5 ' +------------------------+
6 ' MODEM MUST BE ON AND READY
7 ' WHEN PROGRAM IS RAN
8 '
9 '
10 PCLEAR1:CLEAR10000:DIM MD$(1000)
15 CLS:PRINT@7,"MODEM SCANNER V1.1":PRINTSTRING$(32,131)
20 PRINT@64," THIS PROGRAM WILL DIAL A RANGE OF NUMBERS YOU SPECIFY AND REPORT ANY MODEM CARRIERS IT FINDS.":PRINT
25 PRINT" warning: CALLS PLACED BY THIS PROGRAM ARE CONSIDERED PRANK CALLS AND ARE PUNISHABLE BY A FINE OF UP TO $1000 AND/OR A JAIL TERM OF UP TO 180 DAYS."
30 PRINT:PRINT" ****USE AT YOUR OWN RISK!!****":PRINTSTRING$(32,140)TAB(9)"PRESS ANY KEY:";
35 IFINKEY$=""THEN35
40 CLS:PRINT@7,"MODEM SCANNER V1.1":PRINTSTRING$(32,131)
45 PRINT@68,"***INITIALIZING MODEM***"
50 POKE65315,48:POKE65314,249:POKE65315,52:POKE65314,0:POKE150,180:MD=0
55 FORA=1TO2000:NEXTA:PRINT#-2,"+++";:FORA=1TO2000:NEXTA:PRINT#-2,"ATZ":FORA=1TO1000:NEXTA:PRINT#-2,"ATT C0 E0 M1 Q1"
59 PRINT@128,"SCAN 800'S? (Y/N) :";:LINEINPUTA$:IFA$="Y"THENAC$="1-800-"ELSEAC$=""
60 PRINT@160,"ENTER PREFIX (###) :";:LINEINPUTPF$:IFLEN(PF$)<>3THEN60
65 PRINT@192,"START RANGE (####) :";:LINEINPUTST$:IFLEN(ST$)<>4THEN65
70 PRINT@226,"END RANGE (####) :";:LINEINPUTEN$:IFLEN(EN$)<>4ORVAL(EN$)<VAL(ST$)THEN70
75 PRINT@288,"SCAN FROM "AC$PF$"-"ST$:PRINT@327,"TO "AC$PF$"-"EN$:PRINT@392,"IS THIS CORRECT? ";:LINEINPUTA$:IFLEFT$(A$,1)<>"Y"THEN59
80 CLS:FORNM=VAL(ST$)TOVAL(EN$):'FORA=1TO10000:NEXTA
82 PRINT@511:PRINT@0,TAB(7)"MODEM SCANNER V1.1":PRINTSTRING$(32,131):PRINT@69,;:IFAC$=""THENPRINT"LOCAL";ELSEPRINT"1-800";
83 PRINT" SCAN IN PROGRESS":PRINT@96,"SCANNED:"NM-VAL(ST$),"CARRIERS:"MD:PRINTSTRING$(32,131):PRINT@448,;
85 NM$=AC$+PF$+"-0000":NN$=RIGHT$(STR$(NM),LEN(STR$(NM))-1):MID$(NM$,1+LEN(NM$)-LEN(NN$),LEN(NN$))=NN$
90 PRINTNM$" - ";:PRINT#-2,"ATDT "NM$
95 CD=PEEK(&HFF20):FORTM=1TO1000:CD=PEEK(&HFF21):IF(CD AND 128)=128 THEN105 ELSENEXTTM
100 PRINT"NOTHING":PRINT#-2,"ATH":FORA=1TO3000:NEXTA:NEXTNM:GOTO120
105 PRINT"*CARRIER*":MD$(MD)=NM$:MD=MD+1
110 FORA=1TO2000:NEXTA:PRINT#-2,"+++";:FORA=1TO2000:NEXTA:PRINT#-2,"ATH":FORA=1TO2000:NEXTA
115 NEXTNM
120 CLS:PRINT@4,"TOTAL CARRIERS FOUND:"MD:PRINTSTRING$(32,131)
125 FORA=0TOMD:PRINTMD$(A),:IF(A/18)=INT(A/18)THEN135
130 NEXTA:PRINT@424,"END OF NUMBERS":END
135 PRINT@425,"PRESS ANY KEY:";
140 IFINKEY$=""THEN140ELSEFORZ=1TO12:PRINT@32+Z*32:NEXTZ:PRINT@96,;:GOTO130
150 '
151 'PROGRAM UPDATES
152 '
155 'OCTOBER 1987 (V1.0)
156 'FEBRUARY 1988 (FOR 800'S)
160 '
I believe the POKEs in line 50 are what made BASIC not wait for the printer to be ready (since that would never happen when using a modem) and setting the printer baud rate to 300 baud.
Line 95 is related to the carrier detect, though I don’t know what it’s doing specifically.
At 120 it appears to display all of the modem numbers found, with a pause at the end of the screen. I see no provision for writing this list out to tape or disk, so I guess the user would have just had to write them down. And, most likely, when scanning 10,000 numbers (0000-9999), how many of them would have actually been modems anyway?
I had a friend who did modem scanning back in the late 1980s, though I don’t know if he used this program. I do know that his parent’s got a phone call from the phone company, reporting that something was wrong on their other phone number and it was making too many calls. His dad went up to the room where the computer was and knew enough about it to hit the read BREAK key and stop the program.
I do not know if I ever used this program, but I do have a story to tell about getting in trouble for dialing in to a number that was found through modem scanning. But that’s a story for another time…
Until then…
For further research…
A disk image containing these programs may be found on the Color Computer archive site:
Although I was “this close” to having my *ALLRAM* BBS sold by a well-known CoCo company back in 1983 it wasn’t until 1989 that something I wrote appeared for sale in the pages of Rainbow Magazine.
Rainbow Magazine, November 1989, Page 111.
I had gotten my first musical keyboard (a Suzuki Keyman PK-61) during high school, and then acquired a Casio CZ-101 synthesizer. After graduation in 1987, I purchased the CoCo MIDI interface from Rulaford Research. This started my love for MIDI and creating keyboard music which I still enjoy today (just without MIDI, as it’s been replaced by virtual instruments on a computer and USB piano keyboards).
There were two main types of MIDI programs. A sequencer allowed recording the keys pressed on a MIDI keyboard and playing them back. This was a high-tech player piano, but instead of a roll of paper with holes punch in it triggering hammers hitting strings, it was serial byte codes going to a synthesizer or sound module playing notes. Lester Hands’ sequencer was quite an achievement for a 64K CoCo.
The second type of program was called a librarian. These programs would use special messages the synthesizer supported to download sound data (the “patch” or “voice” as keyboards called them) and save it to tape or disk. You could later upload that information back. This allowed saving out all the sounds a keyboard made, and loading in new ones. Or, backing up custom sounds you created.
There was a third type know as an editor, but I never had any of those so I cannot really comment on them.
I recall buying a Casio CZ-101 Librarian from Rulaford Research.
I eventually saved up enough to buy a Kawai K1 full-size synthesizer. I learned enough about how the CoCo MIDI hardware pak worked (thanks to my Commodore friend Mark finding the data sheet) to create routines to read and write data through it. This, and some technical information on the SysEx (system exclusive) MIDI messages of the K1 led me to create a librarian for that synth. I had been in communication with Cecil Houk of Rulaford Research and he suggested putting my name in the title so it would be an instantly unique title (rather than something generic like “Kawai K1 Librarian”).
The end result was the Huffman K1 Librarian, shown here at version 1.2. I have no recollection of what changed between 1.0, 1.1 and this version.
At the time, while many of us had copies of software we did not purchase, I didn’t like having copies of anything that asked me to not copy it. I included the message “Support the future of music on the Color Computer. Please do not pirate this program.” on the title screen.
The main menu allows sending a single patch (voice) to and from the K1, or a block (which was a bank of many patches).
I do not recall much about how the K1 LCD screen looked, but I know it used an uppercase “I” or “E” (internal/external) as well as lowercase “i” or “e” for the singles voices.
The voices were divided up in to four banks (lettered A to D) with 8 patches in each. It was basically octal! This is the only time I’ve seen base-8 numbering used (though in this case, it would be like A1-A8 to D1-D8 rather than 00-38 in octal).
To dump (upload) a patch to the synthesizer, you had to type the name of the patch file. I built-in a Directory command similar to how the Casio Librarian did it.
This may have been the first time I ever made use of DSKI$ to manually parse the directory table of the CoCo’s disk format.
I also added a disk menu to give a fuller directory, kill files, rename files, and copy files.
Here was my copyright notice in REMarks at the top of the program. From looking at the CLEAR command, that reminds me that my assembly language MIDI routines loaded at &H7000.
Also note I set a variable DR (current drive) with a PEEK, rather than hard-coding a default of drive 0. This meant if the user had done a “DRIVE 1” and was running it from that drive, it would default to using drive 1. I had forgotten about this technique.
I guess I typed too soon. At the end of my programmer version notes, so now I know about 1.1 (add error checking) and 1.2 (more error checking). Nice.
Beyond looking at the menu screens, today I have no way to do anything with this program. I sold my Kawai K1 long ago, and upgraded to a K4 :) I eventually sold that and replaced it with a Yamaha W7.
Humble beginnings, and fun times. I hope you enjoyed this look back at my earliest commercial product.
I feel dumb for not knowing this, but I was under the impression that today’s Visual Studio only built things like C#, C++, etc. — since those are the things listed when you make a new project.
I happened to ask ChatGPT about building C in Studio, and it told me I could just make C++ project and save the file out as a .c and get a C project. I had no idea.
I have only tried this under Windows, but I plan to see if the Mac version of Visual Studio supports the same. I’ve tried to get C code building in VS Code, but it’s klunky (makefiles!).
Awhile back, I posted a note about some weird behavior with DATA statements in Color BASIC. The issue was that you really couldn’t have anything else on a line after the DATA keyword other than data.
I recently mentioned this to Alex Evans so he could make sure his BASIC utilities were not combining DATA statements together. He mentioned something to me that demonstrated this issue even more:
100 DATA 1,2,3:PRINT "FOO"
110 DATA -1
If you RUN that program, it should print “FOO” and do nothing else, proving that the interpreter does scan the entire line looking for things after a DATA statement.
BUT, if you try to USE that DATA, it will continue reading after the 3 and error out, since the data it finds is not an ASCII number:
Above, the “?SN ERROR” is caused by trying to read a numeric variable from what is NOT a string (the token value for PRINT followed by FOO in quotes). Altering the program to use A$ instead of A (and print one item read per line) shows this a bit better:
Alex explained it like this:
Basically, for the purposes of READ everything after the DATA keyword is part of the data statements, but the interpreter executes the line properly.
– Alex Evans
You can see it appears to treat the colon as a DATA separator, since it does not appear as part of the read DATA.
This is a quirk I do not expect many of us ever encountered, since most of us probable grouped all our DATA together, without mixing commands in with them:
100 DATA 1,2,3,-1
I bet all of this was discovered and covered back in the 1980s in various CoCo magazines and newsletters, but the behavior surprised me when I stumbled upon it so I guess I never saw it.
The later model CoCo 2s used an upgrade MC6847 video display generator chip. This chip provided an updated font with true lowercase, as well as the ability to change the border color and inverse the video.
The original 6847 had a hardware pin that could inverse video, and I recall taking the VDG out of my CoCo 1 to pull up a pin then re-insert it. That gave me the nice inverted display I often use in the XRoar emulator:
In the nearly-forty years since I did that modification I had forgotten that it could only be done in hardware. I thought there was probably a POKE or something, since many programs I had used the inverted video mode.
I couldn’t figure it out, and the bits that made the updated 6847T1 show inverse video did not work on the original 6847.
I wrote a program to go through the 6847 T1 VDG text modes, which includes lowercase, changing the border, and inverting the screen.
I’ve seen programs on the CoCo (like GRABBER) that invert/reverse the screen in software, but the bits to do that on the T1 don’t seem to do anything on the 6847.
Does anyone know of a reference that would show me how to do this? Thanks, much!
There is an inverse video pin on the chip. But it is not hooked up. I think.
– tim lindner, 2/15/2023
With that in mind, I decided to do some quick tests. This test PRINTs every possible visible character on the screen:
10 CLS:PRINT
20 FOR C=32 TO 255:PRINT CHR$(C);:NEXT
30 GOTO 30
I skipped the first line and I started printing with CHR$(32) (a space) because the values below that are non-visible characters.
BUT, if you POKE to the screen, you get more characters. Here is an update that will POKE the values 0-255 to the bottom half of the screen:
10 CLS:PRINT
20 FOR C=32 TO 255:PRINT CHR$(C);:NEXT
30 FOR C=0 TO 255:POKE 1280+C,C:NEXT
40 GOTO 40
Comparing the PRINT versus POKE characters, you can see PRINT has 64 ASCII-printable characters starting at 32-96. After that are 32 inverted characters. There are 32 characters that you cannot print in inverse.
When you POKE, values 0-63 represent the inverted full ASCII character set, and 64-127 are the uppercase.
PRINT POKE
------- -------
32-96 64-127 Space to Left Arrow
96-127 0-31 Inverse "@" to Inverse Left Arrow
32-63 Inverse Space to Inverse "Left Arrow"?"
From that table, you can see it’s impossible to PRINT thirty two of the available inverse characters in the 6847, but you can POKE them.
I thought it might be fun to write a routine that would PEEK through the screen memory and invert all the characters. Since there are 32 non-inverted characters from 32-96, and 32 inverted characters from 96-127, it seems all I needed to do is PEEK each location and if it was from 96-127, subtract 64 and POKE it back.
We start with this slow program, complete with some benchmarking timing code:
10 ' FILL SCREEN WITH STUFF
20 CLS:FOR C=32 TO 255:PRINT CHR$(C);:NEXT
30 TIMER=0
40 FOR L=1024 TO 1536
50 V=PEEK(L):IF V>63 AND V<128 THEN POKE L,V-64
60 NEXT
70 PRINT TIMER
This prints 631 for me. One of the first speedups we can do is change the decimal numbers in line 50 to hex.
10 ' FILL SCREEN WITH STUFF
20 CLS:FOR C=32 TO 255:PRINT CHR$(C);:NEXT
30 TIMER=0
40 FOR L=1024 TO 1536
50 V=PEEK(L):IF V>&H3F AND V<&H80 THEN POKE L,V-&H40
60 NEXT
70 PRINT TIMER
That simple change takes the time down to 490. And, since variable lookups (when there aren’t a ton of variables) is faster than parsing a hex number in source code, we can change those values to variables and make it even faster:
10 ' FILL SCREEN WITH STUFF
20 CLS:FOR C=32 TO 255:PRINT CHR$(C);:NEXT
25 X=&H3F:Y=&H80:Z=&H40
30 TIMER=0
40 FOR L=1024 TO 1536
50 V=PEEK(L):IF V>X AND V<Y THEN POKE L,V-Z
60 NEXT
70 PRINT TIMER
This drops to 475.
And, any time you use “IF this AND that”, it can be sped up by doing “IF this THEN IF that”. Let’s try that…
10 ' FILL SCREEN WITH STUFF
20 CLS:FOR C=32 TO 255:PRINT CHR$(C);:NEXT
25 X=&H3F:Y=&H80:Z=&H40
30 TIMER=0
40 FOR L=1024 TO 1536
50 V=PEEK(L):IF V>X THEN IF V<Y THEN POKE L,V-Z
60 NEXT
70 PRINT TIMER
In this case, it really did not change anything — I see 474. Okay, that was a fail. I guess it doesn’t always help.
Since the math we are doing is a subtract 64, we should see if we can do that by using AND to remove the bit that represents 64. We don’t want to do that if it is a graphics character (128-255) so we’ll need to retain on IF:
10 ' FILL SCREEN WITH STUFF
20 CLS:FOR C=32 TO 255:PRINT CHR$(C);:NEXT
25 X=&H3F:Y=&H80:Z=&H40
30 TIMER=0
40 FOR L=1024 TO 1536
50 V=PEEK(L):IF V<Y THEN POKE L,V AND &H3F
60 NEXT
70 PRINT TIMER
That shows 367 for me. Better!
I did test to see if checking for the 8th bit (V AND 128) was faster than just comparing a value (A > 127) and the “>” check was faster, so we’ll stick with that.
At this point, the routine to inverse the screen while leaving graphics characters alone is getting close to twice as fast as the original version.
Can we do better? At least a bit, by removing spaces and combining lines (and even though it only parses the FOR values once, I’ll switch them to hex):
10 ' FILL SCREEN WITH STUFF
20 CLS:FOR C=32 TO 255:PRINT CHR$(C);:NEXT
25 X=&H3F:Y=&H80
30 TIMER=0
40 FORL=&H400 TO&H5FF:V=PEEK(L):IFV<Y THENPOKEL,V AND&H3F
50 NEXT
70 PRINT TIMER
That prints 356. (There were a few spaces that could not be removed due to needing them so the BASIC parser knows where a variable ends and a keyword begins.)
Now we could make a subroutine that would invert the screen, slowly.
While it might be a neat “effect” for a title screen to watch it painting the screen, it’s not fast enough to use in a program that you want the output to always be inverted.
Some thoughts…
If no semigraphics characters were being used, the check for them could be removed:
10 ' FILL SCREEN WITH STUFF
20 CLS:FOR C=32 TO 127:PRINT CHR$(C);:NEXT
25 X=&H3F:Y=&H80
30 TIMER=0
40 FORL=&H400 TO&H5FF:V=PEEK(L):POKEL,V AND&H3F
50 NEXT
70 PRINT TIMER
That prints 304 — twice as fast as the original, though it will corrupt semigraphics blocks by changing them.
Another approach might be to only do the portion of the screen that has been PRINTed to by changing the range that the L loop scans. For example, you could call a routine to invert just the last line of the screen every time something is PRINTed there.
Or, perhaps a custom “print reverse” routine might make more sense. We’d also want a special CLS routine that cleared the screen to inverse spaces.
10 CLS
20 GOSUB 1100
30 P=0:A$="This is in REVERSE video!":GOSUB 1000
40 P=32:A$="And this one is, too.":GOSUB 1000
50 P=480:A$="Hello, bottom line!":GOSUB 1000
999 GOTO 999
1000 ' PRINT@ REVERSE
1010 L=&H3FF+P:FOR I=1 TO LEN(A$)
1020 V=ASC(MID$(A$,I,1)):IF V>95 THEN V=V-96 ELSE IF V>64 THEN V=V-64
1030 POKE L+I,V:NEXT:RETURN
1100 ' CLS REVERSE
1110 P=0:FOR L=&H400 TO &H5FF:POKE L,&H20:NEXT:RETURN
To use the function set P to the PRINT@ location, assign the string to A$, then GOSUB 1000. Not much to it.
Handling scrolling the screen would be more work (and slower), but could also be done. Perhaps the routine could track the PRINT@ position internally, so every time you print it increases P by 32 (next line) and if it gets to the end of the screen, it could scroll everything up… slowly…
10 CLS
20 GOSUB 1200
30 A$="This is in REVERSE video!":GOSUB 1000
40 A$="And this one is, too.":GOSUB 1000
50 A$="PRINT;":GOSUB 1100
60 A$="NEXT TEXT":GOSUB 1100
70 P=480:A$="BOTTOM LINE":GOSUB 1000
80 A$="AND THIS":GOSUB 1000
999 GOTO 999
1000 ' PRINT@ REVERSE
1010 GOSUB 1100:P=P+32-I+1:IF P<512 THEN 1050
1020 ' SCROLL
1030 FOR L=&H400 TO &H5E0:POKE L,PEEK(L+&H20):NEXT
1040 FOR L=&H5E0 TO &H5FF:POKE L,&H20:NEXT:P=P-32
1050 RETURN
1100 ' PRINT@; REVERSE
1110 L=&H3FF+P:FOR I=1 TO LEN(A$)
1120 V=ASC(MID$(A$,I,1)):IF V>95 THEN V=V-96 ELSE IF V>64 THEN V=V-64
1130 POKE L+I,V:NEXT:P=P+I-1
1140 RETURN
1200 ' CLS REVERSE
1210 P=0:FOR L=&H400 TO &H5FF:POKE L,&H20:NEXT:RETURN
To clear the screen, GOSUB 1200.
To do a normal PRINT, set the string in A$ and GOSUB 1000.
To do a PRINT with a semicolon at the end, set the string in A$ and GOSUB 1100.
To simulate a PRINT@, set P to the screen position then GOSUB 1000 or 1100.
This program does NOT handle printing past position 512 at the bottom right of the screen.
IT CAN POKE PAST SCREEN MEMORY AND CAUSE A CRASH!
A simple check could be done before line 1130 to see if L+I is going to be past the end of screen memory (1536) and adjust accordingly.
If there is any interest (leave a comment), we can look at how we might do that in a future article.
Is this useful?
If we really wanted to use inverse video in BASIC, I guess it would be useful. Can you make it faster in BASIC? What would you suggest? Leave a comment.
But, doing inverse text would be a simple thing for some assembly language routines that could be called easily from BASIC.
OR, perhaps there would be a simple way to just hook in to the output vector used by Color BASIC and do it there.
