ANALOG HOME

PEOPLE

RETRO GAMES!

FUN STUFF

WHAT MIGHT
HAVE BEEN

LINKS

KLANKY HOME

 

 


Fun Stuff!

Man, do we have some great stories to tell.  ANALOG was a fun place in general because just about everybody there was:

1) A science fiction/fantasy fan
2) A car nut
3) A computer geek
4) Certifiably insane

Well, maybe not number 4.  Anyway, here are some tales of ANALOG, dredged from the horrifying depths of our brains...

Livewire!

SASE Madness!

Rats!

Cover Story

Fire Bug

The ANALOG TCS

The ANALOG TCS, PART 2


Livewire!
by Tom

   ANALOG was a great place to work if you were a programmer, because one of the mandates of the magazine was that we publish "Lots Of Games". Unlike many other programming jobs, at ANALOG you could do just about anything you wanted, as long as it filled magazine pages, was fun to play and fit into a 16K Atari machine. And ANALOG had made a decision early on, because we had several experienced assembly-language programmers, to produce games that were as close to arcade quality as possible using assembly language. Later in the life of the magazine, we started making 32K games because people wanted more, but we really tried to make the software usable by every Atari owner.

   So here comes a little background. Publisher Lee Pappas and I were video game junkies. When we had spare time, we were stuffing quarters non-stop into arcade machines. When out in California for computer shows, most evenings were spent at the Malibu Fun Center south of San Francisco Airport, and by far the game we played more than any other was Atari's "Tempest". I remember walking into the arcade and seeing something like 20 Tempest machines all lined up in a row. It was like a gambler walking into a Vegas casino. We'd jump on those things with a couple rolls of quarters and play until we were out of money. (Actually, those machines used tokens, but you know what I mean). I still have some of those tokens lying around here someplace.  There was a great rush when you got to put your initials in one of the top three slots (these stayed in PROM memory even if the machine was turned off), and Lee and I did that a lot.  Heck, you may actually find an old Tempest machine with "LEE" or "HUD" still sitting in the PROMs...

   Anyway, we loved that game. There was something very appealing in the basic wireframe forms and the 3-D effect of zooming down the tube. I liked the game so much that I bought one while at ANALOG and kept it at the ANALOG offices on "Free Play" for all of us to play. I have a smaller "cabaret"-style case Tempest in my office right now. Like I said, we loved that game.

   So here we are at the 1983 West Coast Computer Faire in San Francisco - Lee, Brian Moriarty and me - And we had a booth for the magazine and our fledgling software company, ANALOG Software. I remember talking to Atari owners who came up, and asking them what they wanted to see in the magazine. They all liked the machine-language arcade games, and I mentioned to one guy how much I'd like to do a "Tempest" game. That got some good reaction, and I figured it would be my next game. As is normal with the way I do things, I started thinking about how I'd approach the game design right away, but in a back-burner kind of way.

   The next thing I knew, the kid I had been talking to about doingTempest was back. He had been over at the "Antic" booth (our primary competition/sworn enemies) and mentioned to them that we were probably going to do Tempest, to which they replied (paraphrasing), "There's no way you can do Tempest on an Atari". The gauntlet was thrown down. I then removed Tempest from the back burner and put it on the front burner on "High". Nobody told me something I wanted to do was impossible - I'd show those Antic bums…

   Back at the hotel, I grabbed my yellow note pad and started diagramming the game. It was always easiest to do tables in computers using base 2, so my Tempest-knockoff game grids would have 16 divisions. I couldn't just copy the Tempest game grids, so I made up a new backstory for the game based around electronics and called it "Livewire", with each level being one of the letters in the name "Livewire". 8 letters was also a handy base 2 number, incidentally. The game tables would be very easy to work up.

   On the plane home, I was writing blocks of code that would run the game and drawing out the grids on graph paper. I was so totally into getting this game written it was unbelievable. When I got back to Massachusetts I was like a coding machine, and I had the game up and running very quickly. Looking at it today, it's no masterpiece, but it played relatively well on a machine with paddles - Nothing as good as the original, but I think people liked it, and I showed those Antic guys…

   This is one of my favorite memories of ANALOG. Being able to do just about anything you wanted to do as long as people wanted to buy the magazine to get it. When you got up in the morning, you couldn't wait to get to work and get started. How many people can say that about their job?


SASE Madness!
by Tom

   Occasionally, ANALOG would have some special offer that asked readers to send in a self-addressed, stamped envelope (SASE). Seems innocent enough, right? Think again.

   Many of our readers were kids, without a lot of spare postage stamps burning holes in their pockets. One day, Pat Kelly walks back into Mike's office and holds out an envelope that's been stamped up and sent in by a reader. We all gasped. The stamps were all a minimum of 25 years old, all something like 3- or 4-cent denominations. They had obviously been a part of their parents' stamp collection and some kid had grabbed them and slapped them onto an envelope! This, of course, absolutely ruined the stamps for any kind of collector value. We were all horrified that we had been the instigators of this destruction.

   I remember Jon and Pat joking that the next envelope would come in with one of the incredibly rare "upside down" airplane stamps (1918 24-cent "Inverted Jenny" airmail stamp).

   We figured this was just an anomaly and life went on at the office, then more SASE's showed up in the days to follow - And a lot of them had pilfered stamp-collection stamps!  Uh-oh…


Rats!
by Tom

   The building that housed ANALOG was incredibly old, and had been many things in its time. The rumor was that it had started out as a dairy barn, and at some point it had been converted into an automotive repair shop. Then it became Bob Deschenes' (Mike's father) art studio (below) and home (above).

   Being an old structure, there were a lot of strange things about the place. There were all sorts of old walls that you could tell had just been plastered over, and one really oddball corner with a shelf that dead-ended into nothing. According to Lee, when they did the initial remodeling that set up the ANALOG retail store, they discovered a set of overhead doors (apparently part of the old auto repair shop) that had simply been rolled up into the ceiling and drywalled over!

   Another "charming" aspect of this old building was that it must have had a zillion little hidden passageways that were just the right size for vermin of various sizes. This includes mice, cute little chipmunks, and yes, rats.

   It wasn't really a surprise to have "issues" with small creatures in ANALOG. One day in early winter, we were working away when we realized that something really smelled bad, and it wasn't one of the computer geeks. This was the kind of smell that you know is associated with real, honest-to-god death. Bob had a not-so-pleasant habit of using rat poison to deal with the vermin population in the building. Rat poison is kind of bad in that the creatures that eat the stuff have an unfortunate tendency to crawl off somewhere and die. The theory is that they will crawl outside, where they can get water, and die there but the reality is that oftentimes, they will crawl somewhere inside the building, where you can't get at them, and die. Most places in the world, they probably went outside and died 90% of the time. At ANALOG, I'd bet they stayed inside and died 90% of the time.

   This was the case on this particular winter day - The rat (or whatever) had croaked inside the south wall of the place and was really starting to reek. There was no way we could get to the rotting corpse to get rid of it. It was all we could do to continue working - I can't begin to describe the smell, and it was pretty cold outside so we really didn't want to open the window. Oh well, we survived it.

   On another occasion, after we had reworked the rear of the building into some pretty slick offices for the programmers, complete with a suspended ceiling and (oooh!!!) carpet, I was working at my desk. We had temporarily removed one of the suspended ceiling panels so that I could run a phone line to my desk. As I was typing away on my Atari 800, some movement above caught my eye. I slowly looked up and saw it - the cutest little chipmunk you've ever seen, peering over the edge of the suspended ceiling frame. We tried a bit to catch him and get him outside, but eventually gave up. I don't recall if we ever got him, I think we just figured he'd get out the same way he got in, and that he wouldn't do that much damage anyway…

   By far the worst incident I ever had with vermin happened one morning when I walked into the programmer's office and when I got to my desk, I looked up and the Snickers candy bar I had left on top of my monitor was gone. Thinking someone in the office had taken it, I started to yell and demand to know who took it. Then I saw them - scraps of plastic wrapper on the desktop and on the floor. My candy bar had been taken, all right, but not by any human. A quick survey of the office revealed some additional damage: Something had gnawed a two-inch hole in the bottom corner of the big wastebasket next to my desk! It didn't take long to figure out what was up - The waste basket had burger and French fry wrappers from Burger King, one of the high-quality establishments where the ANALOG gang got their noontime "nutrition" - That is, when they weren't eating "old man mush meat" (direct quote from Brian Moriarty) from Arby's. Apparently, there was a rat in the building and it had a hankerin' for candy bars and fast food wrappers.

   It had eaten my candy bar. This was war.

   Later that morning, I drove down to Cherry Valley Hardware and bought several rat traps. I had never bought rat traps before, and was amazed. It looked like these things could take down a small dog! And there was this really interesting metal loop, like a big staple, sticking out of one end of the trap. I had no idea what that was for, but I would soon find out.

   So I set the trap up and baited it with - What else? - A chunk of Snickers bar. I set it inside a closet where we suspected the little creep had come from and left the door open a bit. The next morning I strolled into ANALOG, confident that I had whacked the thing. I opened the closet and the trap was gone. No dead rat, no blood - NOTHING.

   A quick conference with the ANALOG crew and Bob (puffing on his pipe, as always) revealed the purpose of the metal loop on a rat trap: You're supposed to tie the darn thing down so that the stinking rat can't CARRY IT AWAY!!! This was now officially creeping me out. I set up another trap, tied it down and baited it with more Snickers. This HAD to work.

   Well, it did. The next day I had a pretty nice-sized trophy to show for my efforts. Pat Kelly was kind enough to pose with the little monster (see photo). I don't recall catching any other rats - Maybe we had struck fear into their filthy little hearts. Yeah, right. I think it was because after that we stopped leaving fast-food wrappers and other stuff lying around the office…

Pat the Rat Man -- Click for big version, if you dare!

The trap in 2005!

The original trap, as it appears in 2005, courtesy of Michael Deschenes!


Cover Story
By Tom

   One of the most fun jobs around ANALOG (besides writing whatever video games we wanted) was creating the cover photos for the magazine. Jon Bell was in charge of this process, and would come up with the general design and approach, and I'd do the actual photography. Many times, these covers required multiple exposures, time exposures and other tricks to pull off.

   Note that in the ANALOG days, there was no such thing as Photoshop, high-resolution video monitors cost $5,000, and computers with high-res truecolor video cost many times that.

   Our approach to doing covers was generally to use tried-and-true techniques from movie special effects, which, being sci-fi movie geeks, we were totally familiar with.

   The first cover I worked on with Jon was the one for 1982's issue #5. I wasn't working at ANALOG yet, but Jon needed some help and it looked like it would be fun, so we dug in. The basis of the image was a hand-drawn image that looked like computer "wireframe" graphics. Jon drew the elements separately and pasted them up, then had the final photo-printed as a negative on acetate (what we referred to as a "stat"). We backlit the stat, which now had white lines on a black background, and did a second photo exposure with backlit pinholes and a four-point cross-star filter. As usual with such things, we shot a large number of exposures with various settings so we'd get just what we wanted. The final image was tinted green for the cover.

Issue 5 cover.  Click for larger version!

   ANALOG #8's cover was pretty fun and quick, and looking back on it, we could have done a lot better. This was a simple multiple-exposure setup with an Atari 800 and monitor and a hand (I don't remember whose - Jon?) We too an exposure of the entire setup as normal, but then did a series of additional exposures with a small grain-of-wheat light bulb on the end of a stick that was painted black. While the owner of the hand held it more-or-less still, Jon took the stick and traced out random paths from the fingertips to the computer. Additional exposures with the bulb placed at the fingertips with a cross-star filter completed the work. When the final image was developed, it looked like the hand was shooting out lightning bolts. To me, the hand always looked a bit blurry, but this was the nature of the game back then - You took a lot of exposures and prayed that one would come out OK. Usually one did; I think this was a case where we picked the best of the bunch!

Issue 8 cover.  Click for larger version!

   Issue 9's cover was one of the most fun we ever did, drawing on the total-sci-fi geekiness of several staff members.  Before coming to ANALOG, Jon and I had been massive Space:1999 fans and had created a Moonbase Alpha-like asteroid base model for our never-finished 8mm film, Buck Cosmo: Space Ranger.  Drawing on that experience, we decided to create an "Atari spaceship" and have it sitting on a launch pad that was similar to one of Moonbase Alpha's, with a nifty space background.  By god, if we weren't gonna finish Buck Cosmo, we'd do the next best thing.

Jon got busy making the Atari-shaped spacecraft, starting out with an SR-71 "Blackbird" reconnaissance plane plastic model kit, and doing a hack job on it with a bandsaw.  After drilling some windows and enhancing the Atari-shaped wings with some sheet styrene, he painted it silver.

Next, we whipped up the pad itself using nothing more than a sheet of styrene and some red tape.  The gantry was a beautiful balsa model our modelmaker friend Ed Miarecki had built years before for a model rocket.  He graciously sacrificed it for the magazine.  (Well, we borrowed it and painted it white -- he was not amused).

The various buildings scattered around the lunar landscape were cobbled together from various plastic kit parts, notably bits of a Saturn V launch vehicle.  Lee provided an HO slot-car tower with lights that can be seen in the background.

If memory serves (and I'll ask Jon to help me out here if I'm misremembering), the lunar surface itself was made from styrofoam sheets that we simply spray-painted gray.  When the solvents in spray paint hit styrofoam, they eat it away nicely, leaving a rough surface that'll pass for your typical moon.

The background is one of our handy-dandy rear projection screens with an astronomical photo projected onto it.

The real fun trick in this shot is that all those little lights on the launch pad and buildings aren't really there!  That would have taken a fair bit of time to wire all those up, and frankly, we decided to work smarter, not harder.  Instead of actually putting little grain-of-wheat bulbs in the shot, we had a single bulb on a black stick that we superimposed onto the image at various places using a multiple exposure technique.  Jon had marked the pad with a pencil where the lights were supposed to be, and we just did a number of extra exposures, one for each little light.  It worked like a charm.

We did the shoot in the basement of Lee's parents' house in one night.  Yeah, laugh all you want -- We didn't have dates, but we could kick butt at Tempest and put together cool special effects shots in just a few hours using little more than spit and baling wire!

Check out the rare, behind-the-scenes photos here!

Issue 9 cover.  Click for larger version!

   For the cover of ANALOG #11, which featured a circuit board in the shape of an Atari logo, I got busy in the model shop. I started with pieces of styrene plastic sheet, cut them into an Atari logo shape and painted it a nice circuit-board green, then masked and sprayed a bunch of copper lines to look like circuit traces. Then I drilled holes and inserted various resistors, capacitors and other electronic components and super-glued a bunch of surplus integrated circuits onto the boards. This was mounted onto a sheet of Plexiglas that Jon had painted black with pin striping tape to make a perspective grid. When the grid was backlit with an acetate sheet to diffuse the light, it looked pretty good. We took this model with us to the 1983 West Coast Computer Faire for display in our booth.

Issue 11 cover.  Click for larger version!

   The covers of ANALOG #16 and #26 were an acetate stat technique that was a lot of fun to do. I would use the Atari to create wireframe graphics of various shapes, print them out and Jon would do a paste-up of the elements and get it shot on acetate as a negative. He would then place colored acetate behind the stat with a piece of frosted acetate to diffuse the light. We'd backlight the piece and run different exposures for various elements, such as the "ATARI GRAPHICS" lettering on issue 16's cover. Fun Fact: On issue 26's cover, two buildings on the left look like a "T" and an "H", my initials, and there is a "J" building visible on the right. I'm pretty sure we also did a "B" building to have Jon's initials in there, but it may be obscured by the "Jack Tramiel" banner.

Issue 16 cover.  Click for larger version!     Issue 26 cover.  Click for larger version!

   Probably our most elaborate and outlandish photo cover was the one for ANALOG #30. The Atari ST was coming out soon, but it was pretty much impossible to actually get your hands on one. What to do? Well, we called our good friend and expert modelmaker, Ed Miarecki and asked him to build us a mockup! We got him all the photos we could find of the ST for reference, and he got busy. The final result was a work of art - It looked almost perfect. When we photographed it, it didn't have an operational power LED so we did a simple multiple exposure and threw one in. Since we didn't have a real ST, we couldn't do a proper screenshot, so I used an 8-bit art program and created a mockup of an ST screen. Yes, it was a lot of effort, but we really wanted to get a scoop on Antic, our main competition. Ironically, some time after this issue came out, when we mentioned it to the Tramiels, they said that they would have happily provided an ST for us to use!

Issue 30 cover.  Click for larger version!  Ed building the ST

   In today's world, all of these covers would have been a breeze to do with Photoshop and a good 3D modeling program, such as 3DS Max. But back then, we could only dream of the kinds of art technology available today. We made do with what we had, and it was a lot of fun to overcome the various challenges.


Fire Bug
By Tom

I've already told the story of Livewire, my solo assembly-language game. This is the story of a game that was developed as a collaboration with Kyle Peacock, one of the other programmers at ANALOG.

Recently I was looking at one of the online ANALOG Computing archives and came across the cover to ANALOG #23, which features a diskette framed in a shower of red-orange sparks, with the caption "FIRE BUG – The Ultimate Magazine Game!" Well, you can't say we didn't have a flair for the dramatic at ANALOG.

It all started one day when Kyle and I were sitting around discussing ideas for original games for the magazine. Sure, we had done all sorts of versions of arcade favorites like Fill 'Er Up (Qix) and Livewire (Tempest), but I think we both wanted to go beyond doing knock-offs of other games and come up with some fun original games. We hit on the idea of doing a scrolling game where you would play the role of a subterranean insect protecting its nest of eggs from predators.

I had worked with Kyle in a limited capacity earlier when he wrote a game for ANALOG called Bacterion (FUN FACT: The full title of Bacterion is "Bacterion – The Plague of 2369". 2369 was the street address of the house where I grew up in Springfield, MO) For Bacterion, my only contribution was giving Kyle the code necessary to draw lines and stuff in the special "7+" graphics mode. He did a great job on Bacterion (you can actually find an excellent Java version of the game at this link), and that initial collaboration got us thinking about doing a bigger job together.

I have to admit – At that point in my life, I tended to not like the idea of working with others on projects. In college a couple of years earlier, I had done group projects with other students and typically, I ended up doing most of the work while they sat around and got the credit. So I wasn't really nuts about the idea of a game collaboration – until I saw that Kyle really was a good coder. I was pretty sure he'd hold up his end of a project.

So we started figuring out what code we'd need for this scrolling game, which we decided to call "Fire Bug". One nice thing about the ANALOG programmer's office was that the walls were made from white Masonite paneling, which we used as a huge dry-erase board. The wall next to my desk became a checklist and flowchart for the game. As we went along listing the game's components, we divided up the various tasks between us – Kyle would take on the game's scrolling mechanism, because he had done a huge amount of research into the Atari's smooth-scrolling graphics system – I took on the job of writing the predator bugs' artificial-intelligence routines. Other tasks were divided up between us as we went along.

As I remember it, we did all the game design layout on a Monday, then went to our desks and started working. Kyle was across the room from me, and as we worked, we'd occasionally stop and call out some variable or data item that we'd need to define so that our code could communicate vital information to make the game work. These would get added to the wall so we'd be able to check it off as we completed blocks of code.

Since this was our project, Kyle and I wanted to keep it secret from the rest of the ANALOG staff until we were finished and had a grand unveiling. In a kind of goofy paranoia, anytime someone would walk into the office, Kyle and I would shut off our monitors so nobody would see the work in progress! It made the process really fun and built a sense of anticipation among the others at ANALOG.

We worked on the code separately for several days, and as I recall, sometime on Thursday we were both ready to integrate the code and start final testing of the finished game. There were no networks then, so it was a matter of copying code to a floppy – We got all the code brought over to my machine and because we had been so thorough about working through the variable names and stuff, integration happened very quickly, and the core of the game was up and running faster than I could have imagined!

We playtested the game and tweaked some of the parameters to fine-tune it, then because we had little elbow room left in memory, and because we had both contributed equally to the game code, we added a final fun touch – On the main title screen, the credits for our names are engaged in a fight for top billing, swapping back and forth at random intervals! I seem to remember wanting to add a "punch" sound every time the names swapped positions; if I remember correctly, we were kind of tight on memory and maybe that's why that wasn't done.

Among the ANALOG staff, Fire Bug was an instant hit. You could hear the sounds of fire bug shooting, eggs being devoured and predators getting blasted from all over the building. The game was so popular that they decided to have it be the only thing mentioned on the cover of issue #23! Typically, the cover would have several items listed – games, reviews, utilities and so on – this was a very rare exception.

The game turned out to be pretty popular among our readers as well, and to this day I hear from people saying how much they liked it.

But for me, this game project was an important landmark – One of the best collaborative efforts I was ever part of – A full, original game created in under a week, start to finish.

 

The ANALOG Computing TCS
By Tom

In May of 1985, ANALOG Computing rolled out a custom bulletin board system, which we called the TCS (short for TeleCommunications System).  Back in 1985, the Internet was not exactly something you could just dial up and zoom along at a couple megabytes per second – Most ordinary people were stuck using CompuServe, which was fairly expensive, or free bulletin boards accessed by dialup at 300 or 1200 baud – Agonizingly slow for file uploads or downloads, and terribly error-prone due to phone line noise despite file transfer protocols like Xmodem.

At ANALOG, every month we printed articles with type-in programs, some of which were HUGE.  Especially some of the assembly-language programs I wrote!  We had developed a way that allowed readers to check the BASIC listings for typing accuracy, but still, you had to type in the darn things.  And there was no comparable checking system for verifying typing accuracy on those huge assembly-language listings.

For this reason, ANALOG started making the magazine’s program listings available on floppy disk and cassette, for an extra charge.  This was great for readers, but boy, was it a huge pain to do!  The diskettes weren’t that bad, since they could be done quickly.  But the cassettes were AWFUL – We had a bank of several cassette recorders that were set up to duplicate tape masters, and guess who had to run the duplicating process - ME!  And when I was babysitting cassette recorders, I wasn’t doing what I really wanted to do, which was writing code.

So I started thinking of ways to get around having to duplicate all those cassettes and diskettes…

What I came up with was a one-of-a-kind, multi-user system based on Atari 8-bit computers and a fantastic piece of equipment that ANALOG had recently acquired – A Corvus 10-megabyte hard drive.

Corvus hard drive

The Corvus drive was awesome – 10 megabytes of data storage that was organized as a bunch of what looked to the computer like floppy disks.  It was not only a massive amount of data storage for its time, but the interface between the computer and the drive was blazingly fast, several times faster than the Atari’s serial (SIO) interface that was used for the other peripherals.

I had been using the drive for development for the magazine and loved the thing.  It made my life so much easier that I quickly got spoiled by it.  I think it made programming tasks go so much faster that the thought of doing something mundane like cassette duplication seemed even worse by comparison!

So I started thinking about how we might be able to set up a really advanced bulletin board system that would use the data storage of the Corvus drive to provide ANALOG readers with easily downloadable programs from the magazine.  And while I was thinking about it, I was looking at a really cool idea – making the system accessible by multiple users at one time, and make it a full bulletin board system ala CompuServe with discussions as well as simple file downloads.  This was potentially possible because the Corvus drive was set up so that it could support up to (if memory serves) 8 computers connected at a time!

Supporting multiple users was a potential technical minefield – Any time you want to have a device shared by multiple users with writing privileges, the device needs to be able to deal with the possibility that two users will try to write to the thing at the same time!  The Corvus drive was definitely NOT set up for this possibility – The manual, in fact, expressly cautioned against attempting this sort of thing, as it could cause the data on the device to be corrupted.  Not good!

So technically, I couldn’t set up a bulletin board system that would allow multiple systems to access the drive by writing to it at the same time, meaning that my idea for discussion forums wasn’t possible.  I really didn’t like that idea, and started working on a way to get around the limitation.

Another limitation was budgetary.  We already had the Corvus drive and one of the interface boxes necessary for the computer to talk to it, but additional interface boxes were not cheap – I seem to recall them being well over $100 each, so getting seven additional interfaces would be a big chunk of cash.  One of the ideas behind the TCS would be that people would buy a subscription to it like they did with the cassette and disk subscriptions, and the company would actually MAKE MONEY from the proposition.  What a novel concept!  Shelling out a load of cash for a bunch of expensive interface boxes wasn’t high up on our list of things we wanted to do.

Here’s a fun fact – One of the other ANALOG programmers, Charles Bachand, is a very competent electronic hobbyist.  In the time I was at ANALOG, he taught me quite a bit about working with digital electronics and we had collaborated on several fun electronic projects.  I still have a HeathKit oscilloscope I bought from him.

So here we were, needing 7 interface boxes for the Corvus in order to have the additional computers talk to the drive.  We cracked open the interface box we had and looked at the components and construction.  It was a fairly simple circuit, as those things go – About a dozen off-the-shelf integrated circuits that we could get at a local supplier, and a pair of nine-pin connectors that plugged into joystick ports 3 and 4 on the front of the Ataris.  The only real trick was that the circuit boards were two-sided, and we had never made double-sided printed circuit boards before.  But Charlie and I were motivated by this challenge – We could build up the interfaces for a fraction of the cost of buying them from the company!

While we were figuring out how to duplicate the interface boxes, Charlie and I discussed how to get around the problem of multiple computers accessing the Corvus at potentially the same time.  What we came up with was, I think, pretty cool – A custom circuit that would act as a traffic cop of sorts, regulating which computer would have access to the Corvus drive at any given time.  The Corvus interface used joystick ports 3 and 4 – Our “traffic cop” circuit would use three of the four data lines on joystick port 2 to regulate access.

At this point, we were using three of the four joystick ports and had one left – We came up with a really radical idea for this one: Use the four data lines on port 1 as a communication channel between the computers and the one left over on port 2 as a data “strobe” line.  The idea was to set up a “chat” function like CompuServe’s “CB Simulator” chat rooms and use the joystick ports to transmit the information between the machines!

The last piece of the puzzle was to set up the TCS so that it would have dialup access.  I wanted to have up to 7 computers on the TCS, but it would be a huge pain for users to have to dial alternate numbers if they got a busy signal dialing, say, computer number 1.  It would be cool to have something set up where you could dial one just one access number, corresponding to the first computer, then if it was busy, the phone company would route the caller to the first available computer.  Luckily for us, the phone company had already thought of this – It’s called “hunting” and was not a big deal to set up.  It looked like we were in business!

Charlie and I got busy putting the system together.

The ANALOG Computing TCS, Part 2
By Tom

Our first task was to build up the interfaces that would let multiple TCS computers access the Corvus hard drive.  To do this, we basically had to copy the interface that came from Corvus (we had no shame whatsoever).  This basically consisted of writing down the part numbers from the integrated circuit chips and noting the values of the various capacitors on the circuit board, and taking a trip to Active Electronics a couple of towns over in Westborough to pick those up, and making up custom double-sided printed circuit boards to mount everything on.

Charlie and I had made circuit boards before, but never double-sided ones, which were necessary for this project.  Fortunately, working at a magazine, we had access to equipment that could turn out transparencies with our circuit layout artwork, which we then used to expose the photo-sensitive coating on the circuit boards.  As we did up the artwork for the knock-off boards, ANALOG’s managing editor, Jon Bell, couldn’t resist doing a little in-joke on the pattern – He made up the translation for “Corvus Clone” in Russian and added it!

The only real trick here was that we were making double-sided boards, with pretty close tolerances, which meant that we had to be sure the circuit patterns on both sides were aligned darn near perfectly.  We came up with a technique that actually worked pretty well – Making matching alignment marks on the patterns for each side, then drilling tiny holes corresponding to those locations, then placing the artwork very carefully with the alignment marks over the holes and exposing the boards to UV light.  Then it was a matter of developing and etching the things.  A lot of trouble and time—But we were able to produce enough boards for the TCS very inexpensively.

I remember we had some initial problems getting the cloned interface boards to work – After assembly, there were some access problems and the test computer couldn’t access the drive.  We ended up getting them to work with a little tweaking, swapping out some ICs, etc.  My guess is that the timing on the chips was pretty finicky.  I remember a couple of extra trips to Active Electronics where I came back with little plastic baggies with new capacitors and ICs (“monostable multivibrators”!) to try out.  It turned out that the tolerances on the components really made a difference.

Once we had the computers talking to the drive, it was time to set up our “traffic cop” (TC) board.  This was my baby – Charlie had taught me a lot about digital electronics and I was eager to tackle a complex project like this.  I would simply use standard gate ICs and timers to do the job.  The design worked like this:

Any time one of the computers wanted to write to the Corvus drive, it would turn on a REQUEST line on one of the front joystick ports.  The TC board was constantly polling up to 8 computers, watching for any of the REQUEST lines to go on.  When it would see one of these lines go on, it would give that computer clearance to use the drive via a “GO AHEAD” line.  While one computer had the go-ahead signal, the others were ignored.  This allowed the computer with clearance to write to the Corvus without any risk of collision with the other computers in the system.  There was actually an additional layer in there – Once a computer received clearance, what it actually did was write to an access flag table on the Corvus, with a flag for each of the virtual floppies within the drive.  So in actuality, each computer could write to the device at the same time as another, as long as they weren’t trying to access the same virtual drive.

The system worked like a charm, and the only way it could really fail was if one of the computers crashed while sitting there with its REQUEST signal on, which would cause the TC board to get stuck.  In general, though, it was a pretty robust system.

The second part of this system was an envelope-pushing communications channel that I wanted so that we could have a chat room system like CompuServe’s “CB Simulator”.  Like a modern chat room, the idea was to have real-time conversations between people who were logged in to the separate systems.  Because there was no networking available for the 8-bit machines, I had to come up with a custom solution.

My idea was to connect data lines from all the computers to a common data bus that each computer could write to and read from.  The problem was, the bidirectional data lines were limited to four each on the four joystick ports for 16 lines total.  Ports 3 and 4 were used by the Corvus, and I was using three lines on port 2, leaving only 5 lines available for my communications system.  One of these lines would be needed for a STROBE line, which is used to indicate that the data lines are set, leaving only 4 lines for data.  When you’re dealing with 8-bit data, that presents a challenge.  Here’s how I dealt with it:

The first part of the problem was that I only had four data lines for data transmission, which wasn’t a huge deal.  I’d simply split each byte into two four-bit chunks and send them separately, then reassemble them when they were read.  I’d set the data, then set the STROBE line, wait a short period, clear the STROBE, then set the next four bits of data, set the STROBE and move to the next byte.

Timing was a bit finicky.  This system was totally asynchronous (there was no master clock signal synchronizing the computers) so the computer sending the data had to leave the data up long enough for the other computers to read it.  My solution was to have all the timing handled by the Atari’s vertical blank interrupt – It was the one thing on the Atari that was guaranteed to happen at a certain interval.  So I had the sending computer put up the data and leave it up for two vertical blank intervals.  This guaranteed that the other computers that were in the chat room mode would see the data STROBE as they monitored the line during their vertical blank interrupts.

The system wasn’t the fastest in the world, but all we were dealing with was short message data that was being typed by users – Not huge amounts of information – So the data rate was more than adequate.  Looking back on it, I guess I could have made it faster by setting up additional interrupts in the display list, but what the heck.

My memory is a little bit fuzzy as to how I managed access to the chat system, which was necessary because only one computer could have write access to the communication bus at any given time – I must have set up a special flag in the Corvus access table for this.

I remember having to tweak the chat system timing a bit to get the reliability to an acceptable level, but it ended up working pretty well for a goofy, asynchronous, serial-parallel hybrid hack!

The last big challenge in this system was all the software necessary to tie it all together, which wasn’t trivial.  I had designed the system to essentially emulate the CompuServe messaging forum system, with the same command syntax, editing controls and so on.  This would make it seem familiar to anyone who had used CompuServe and ease the learning curve.  I ended up writing a fully custom assembly-language package to do the job.  The computers we were using were all 16K machines; most were Atari 400s we either had sitting around or picked up for cheap so we could set up the system.  With the DOS and special Corvus driver code all loaded, memory started to get somewhat limited.  As I was writing the code, I started running into memory limitations and had to start thinking outside of the box to make the thing work.

This was the most complicated thing I had ever written in assembly language on the Atari, because I was accessing the complete I/O system, disk files, keyboard and so on.  A far cry from simple games like “Livewire”!  As I ran into the memory limits, I came up with an approach that worked pretty well – Paging in sections of code as needed.

To do this, I built each code module – chat, file download, message forum, etc. – as an assembly-language block with the same memory origin, making a crude code overlay system.  So if I needed the chat module, the main code block would load the CHAT.OBJ file then jump to the entry point.  If I needed the file download code, I’d load DOWNLOAD.OBJ and jump to the same entry point.  With this simple system in place, all my memory restriction issues disappeared.  I had worked with automated overlay linkers on IBM and Burroughs systems while in school, but this was the first time I had done anything like it on personal computers, and it was a lot of fun.

The system went online and it was a hit pretty much from the start.  We took credit-card information online and processed it manually, which was a lot of work for the staff.  We had our share of kids dialing up and entering bogus credit card information, but we found a way to screen out obvious fakes and quickly implemented that.  In short order, the TCS had brought in somewhere around $30,000.  For users, it was a great deal, because a disk subscription cost $130 and a cassette subscription $90 a year, versus $20 for 20 hours of TCS usage.

For the programming staff, it meant more time spent in TCS support, going online every morning and responding to messages, but it was really cool to walk in and see several users on the system, with the lights on the “traffic cop” board blinking away as users accessed the Corvus drive.

The ANALOG TCS
The four-system TCS as it appeared in summer 1985
in the corner of the programmers' office
(click for larger view)

I ended up leaving ANALOG in late August of 1985, and eventually the TCS was retired, its functions moved over to CompuServe’s SIG*Atari section.  Some time later, I found out that the custom TCS hardware found new life down in Texas at a BBS system called CompuTalk.  I seem to remember talking to Kris Meier, the CompuTalk sysop, at one point, giving him some tech support on how the TC board worked.  Antic magazine wrote an article about the system in 1987 (see http://www.atarimagazines.com/v6n4/computalk.html).  From the article, it sounds like he modified his existing BBS software to use the traffic cop board but didn’t use the software I wrote.

The TCS was an example of how versatile the Atari hardware was.  Having the Corvus hard drive available was the key to going beyond the usual bounds of the hardware and doing something really cool.  And I certainly appreciated all the electronic knowledge I gained from working with Charles Bachand at ANALOG, who was not only a great at programming, but a nice guy willing to share what he knew about electronic design.

 

Klanky the Robot® TM & Copyright 1975-2013 Tom Hudson

 

Powered by WebRing.