See also: Part 1, Part 2, Part 3, Part 4 and full source.

Just because something can be done, doesn’t mean it should.

“Why are you converting thirty year old BASIC programs to C?” you might ask… Well, mostly just to see how easily it could be done, but I admit, nostalgia has a big part in this. I am not quite sure what led me to looking in to my 1983 BBS program, but once I saw it running on the XRoar CoCo emulator, it brought back all kinds of fond memories of sitting in front of a TV set typing in lines of BASIC code.

I believe I got in to computers at the very best time. A few years earlier, and it was punch cards and flip switches. A decade or so later, and computers were becoming appliances. There was a bit of time in between when owning a computer primarily meant programming a computer. I got in to it late enough that I didn’t have to be a hardware guy to build my own computer, and early enough that I was still compelled to figure out what to do at the blinking cursor after the “OK” prompt. There just wasn’t nearly as much off-the-shelf software to buy back then, you see. Especially on my allowance.

I realized tonight that there were many like myself who once wrote their own programs and experimented. As time moved on, most of us ended up with a PC or Mac or even Linux machine, and do little more than run software written by others. Thirty years ago, if we wanted to print up a sheet of return address mailing labels, we would type in a few lines of BASIC and be done.

10 FOR I=1 TO 25
20 PRINT #-2, "Allen C. Huffman"
30 PRINT #-2, "PO Box 22031"
40 PRINT #-2, "Clive IA 50325-94014"
50 PRINT #-2
60 NEXT I

Today, if we don’t have a template for MS-Word, we might end up Googling to find some freeware or shareware offering. (I suppose we have also passed up the pre-Internet times when folks had to go to a computer store like Babbages or CompUSA to look for something on the shelf to buy.)

But what about all those BASIC coders that perhaps haven’t ever written even the simplest line of code for a Windows PC? Did they all just decide they no longer liked it? Or did the environment change enough that programming just wasn’t as accessible?

Certainly, modern computers no longer power up instantly and present you with a place to type and run a program…

My recent exposure to the Arduino has made me want to program for fun again. Just like my TRS-80 Color Computer, I purchased my Arduino UNO R3 at a nearby Radio Shack. But unlike my CoCo, the Arduino required a host PC/Mac/Linux machine to make it do anything, and then you had to know C/C++. Fortunately, I do… I learned it on my CoCo under OS-9 back in the late 1980s! But what about all those non-OS-9 CoCo owners who stuck with Disk Extended Color BASIC? For them, an Arduino would present quite a learning curve.

But could someone who knows BASIC learn enough to write (very poor) C and actually use an Arduino? I think they could.

void program()
{
    for (i = 0; i < = 25; i++)
    {
        Serial.println("Allen C. Huffman");
        Serial.println("P.O. Box 22031");
        Serial.println("Clive IA 50325-9401");
        Serial.println();
    }
}

Tonight, my *ALL RAM* BBS system is fully functional on my Arduino. The code I originally wrote thirty years ago in BASIC was well structured, with subroutines for items like input and output which translated easily to C functions. Program logic was a mess of if statements and gotos, but since C supports both, it was fairly easy to make the jump. But, it wasn’t pretty. Instead of line numbers, I created C lables in the format of “lineXXX:” where XXX was the desired line number:

line120 :
    // 120 KY=KY+1:IFKY>200THENPRINT"Sorry, your time on-line is up.":GOTO210ELSEIFKY>180THENPRINT"Please complete your call soon."
    ky = ky + 1;
if (ky > 200)
{
    Serial.println("Sorry, your time on-line is up.");
    goto line210;
}
else if (ky > 180)
{
    Serial.println("Please complete your call soon.");
}

And, to make things flow a bit better, I created C functions to replicate some of the BASIC keywords:

line130 :
    // 130 LN=INSTR("?CGRSPU%",A$):IFLN=0THENPRINT"*Invalid Command*":GOTO120
    ln = instr("?CGRSPU%", aStr);
if (ln == 0)
{
    print("*Invalid Command*");
    goto line120;
}

Some things did not have a direct equivalent in C, but could be done in a simple, brute-force manner:

//140 ONLN GOTO105,155,205,405,455,305,255,505
if (ln==1) goto line105;
if (ln==2) goto line155;
if (ln==3) goto line205;
if (ln==4) goto line405;
if (ln==5) goto line455;
if (ln==6) goto line305;
if (ln==7) goto line255;
if (ln==8) goto line505;

I was surprised at how well one could program C as if it were BASIC.

As of tonight, *ALL RAM* BBS runs on my Arduino, complete with userlog and message base. Due to limited memory, there is only room for a few users and a few TINY (Twitter-sized) messages, but it all works. I had to do some Arduino tricks to get strings and such moved in to Flash to free up precious RAM, and once I did that, I even had room to use some SD memory card routines for replacing the original cassette tape load/save routines. (Yes, I realize this is rather silly. There’s no reason to run a RAM-based BBS if you have access to disk storage, but I never said this was a practical experiment.)

I even managed to use my Arduino Ethernet shield and telnet in to the micro BBS. The quick modifications I made to allow this weren’t fully baked — once the connection was broken I had to reset the Arduino — but I believe I will work on that next. (Though probably not with SD card support. I just don’t think there’s enough RAM for both.)

So, in coming days or weeks, I will try to find time to share the code, or at least examples of how I created BASIC-like functions in C.

Until then…

P.S. – For the younger ones of you out there, yes, there was a time when lowercase was not available. The original TRS-80 Color Computer presented inverse letters to represent lowercase. It wasn’t until the later model “Tandy” Color Computer 2s that the machine got true lowercase. (My CoCo 1 had an aftermarket lowercase board installed in it…) I feel so old.

See also: Part 1, Part 2, Part 3, Part 4 and full source.

Yesterday, I shared a silly little project I was undertaking where I was going to port a BASIC program to the Arduino, line-by-line. I am glad to say I have successfully done just that, but the practicality of such accomplishment is very questionable.

For programs that were not created to use 21K of RAM for a memory-resident userlog and message base (like my *ALL RAM* BBS program does), it seems fairly easy to port over Microsoft BASIC code and get it running on the Arduino with surprisingly easy changes. I am tempted to find some classic BASIC programs (like ELIZA or Hunt the Wumpus) and try to convert them, as well, just to see if 2K of RAM is enough for hopefully less memory-hungry code.

So let’s talk a bit about memory. The Radio Shack TRS-80 Color Computer came out in 1980 with a 4K model (later generations would support as much as 512K, or megabytes through third party suppliers). In a 4K system, all of the BASIC code took memory, as well as any variables the program used. I expect working in an Arduino is similar to the 1980 experience, except for more program space.

On a 4K computer, if you had a BASIC program that took up 3K, you only had 1K left for variables. On the Arduino UNO, there is 2K of RAM, and 32K of Flash storage to hold the program. So, that same 3K program that only had 1K of RAM for variables on a 4K CoCo would do much better on an Arduino since it could store the 3K program in Flash, then have the full 2K for variables.

Unfortunately, my BBS program was designed to work on a 32K CoCo. These early 8-bit computers, even with 64K upgrades, still had a BASIC that only recognized 32K (without loading some extra patch program). And, on power up, some of that memory was reserved to hold four graphics pages. Thus, a 32K CoCo would show 24874 bytes available in BASIC.

You could adjust the amount of memory reserved for graphics screens higher or lower with the “PCLEAR” command. A “PCLEAR 8” reduced memory down to 18727 bytes. 6K (6144 bytes, or 1.5K per graphics page) was consumed. For programs not making use of these graphics, we wanted to get rid of that reserve and use it ourselves. Unfortunately, the PCLEAR command only allowed going down to “PCLEAR 1”, which gave 29479 bytes free for BASIC. That’s a nice bit of extra, but someone clever figured out how to achieve a PCLEAR 0 and get the most memory we could use without patching BASIC: 31015 bytes free.

Note that, once you plugged in a Radio Shack Disk Controller and added Disk Extended Color BASIC, the memory available went down a bit due to overhead of supporting the disk system. For this article, we are looking strictly at a circa 1980 style CoCo with a cassette recorder only.

And what does this have to do with the Arduino? I wanted to make sure you understood the limits I was facing when trying to port a cassette based BBS program to a machine with only 2K of RAM (and not all of that is usable by the user program).

My end result was a fully functional clone of the *ALL RAM* BBS, but with some rather impractical limits. For my demo system, I only allocated enough space to support about four users. Even I have more friends than that. And for messages, the limit was about four messages, each having just two or three lines. I would make a comment about how useless this would be, but Twitter seems to have proven people will use something that even gives less space than my 2K BBS.

So how did I do it? One word: gotos. Lots and lots of gotos. My translation was literal. Even though there are much better, more efficient ways to write this program (which I plan to undertake), I thought it would be fun to see just how easily BASIC could be coded in C.

I started out by taking an ASCII listing of the BASIC program, and adding “//” comment markers to the start of each line. I pasted that in to a fresh Arduino sketch, so it looked like this:

//0 REM *ALL RAM* BBS System 1.0
//1 REM Shareware / (C) 1983
//2 REM By Allen Huffman
//3 REM 110 Champions Dr, #811
//4 REM Lufkin, TX 75901
//5 CLS:FORA=0TO8:READA$:POKE1024+A,VAL("&H"+A$):NEXTA:EXEC1024:DATAC6,1,96,BC,1F,2,7E,96,A3
//10 CLEAR21000:DIMNM$(200),MS$(19,10),A$,F$,S$,T$,BR$,CL$,NM$,PS$,PW$,A,B,C,CL,LN,LV,MS,NM,KY,UC
//15 CL$=CHR$(12)+CHR$(14):BR$="*==============*==============*":GOSUB555
//20 CLS:PRINTTAB(6)"*ALL RAM* BBS SYSTEM":PRINT"USERS:"NM,"CALLS:"CL:PRINTTAB(5)"SYSTEM AWAITING //25 A$="Welcome To *ALL RAM* BBS!":GOSUB1055:KY=0:CL=CL+1
//30 PRINT:PRINT"Password or 'NEW' :";:UC=1:GOSUB1005:PS$=A$:IFA$=""ORA$="NEW"THEN55ELSEPRINT"Checking: ";:A=0

And thus it began. I would go line-by-line and try to write C code for each statement. All C variables would be made global, just like they were in BASIC, and blocks of code called by GOSUBs would become standard C functions (since they return just like BASIC). But, for GOTOs, I decided to just use the C goto, and added labels in the format of “line125:” so I could later “goto line125;” in C.

It looked like it just might work… (And, since I started this story in reverse, you already know that it did, but I will share some of the ways I did it in a future posting.)

Until then… Enjoy having more than 2K of RAM!

See also: Part 2, Part 3, Part 4 and full source.

• 2014/03/16 Update: The source code to this is now on GitHub. Check the Arduino link at the top of each page of this site.

In 1983, I released a BBS (bulletin board system) for Tandy/Radio Shack TRS-80 Color Computer (CoCo). Unlike all of the other ones available at the time, mine was rather unique. Instead of requiring “3-4 disk drives” to operate, mine would work with… zero disk drives.

The *ALL RAM* BBS system was designed to run on a 32K CoCo with a cassette tape deck. On startup, it would read in the userlog and message base in to RAM, and then as users called in, messages they posted would be stored in memory. When the SysOp (system operator) needed to use the computer, or was ready to shut things down for the day, he would save the system back to tape.

It was small and primitive, but considering how primitive the state-of-the-art was back then, it was still pretty usable.

The software was meant to be marketed by a CoCo software company, but things ended up not happening, and the software was eventually released as freeware (even though, back then, we did not yet have the names “shareware” or “freeware”. I still remember an experiment a software company did for something they called “pass the hat software”… I guess their name just wasn’t catchy enough).

But I digress.

Tonight, thanks to the XRoar Color Computer emulator, I was able to get my thirty year old software running again thanks to the software being available at the wonderful BBS Documentary website.

My oh my. What a simpler time.

Tonight, I wondered how hard it would be to translate Microsoft Extended Color BASIC to Arduino C. After all, C has a “goto” statement…

And here is part of the *ALL RAM* BBS system running on an Arduino:

The userlog and message base is not yet functional, and likely never will be since the Arduino only has 2K of memory versus 32K on the CoCo 1 it was designed for. But, when I have some time, I will finish it up and maybe support a few users, and a few messages. Perhaps I can even use some of the memory saving tricks I have been using on some work projects to compress things quite a bit.

We shall see.

Hello, *ALL RAM*. Nice to see you again.

P.S. – The *ALL RAM* BBS ran in Houston, Texas under the name Cyclops Castle. The version running there was disk enhanced. Instead of loading and saving to cassette, it used a single disk drive. The software was modified to support dozens of separate message bases, and the user could switch them from the menu. It was quite a feat on a single floppy disk. One day I will have to track down the SysOp, Graham, and see what he remembers from this great experiment.