The Paleotechnologist

The end of an era

2009-06-12T09:07:00.003-04:00

TV in the US goes digital today.

As someone who has seen firsthand the magic that the Digital Revolution has brought us, I know that this is a Good Thing(tm). As a card-carrying Paleotechnologist (not to mention child of the 70's), though, I can't help feeling a little nostalgic for good old analog TV.

TV was simpler then -- in Northern Virginia, our TV choices were channels 4, 5, 7, 9, 20, and 26 (plus some UHF channels if we aimed the antenna just right and occasionally channel 3 from Richmond if we aimed the antenna right *and* the moon was in the seventh house yadda yadda.)

Not better, mind you -- just simpler. Paleotechnologist or no, I still wouldn't give up our age of TiVo, YouTube, Hulu, DVDs, and flat-panel screens -- even if the 70s did have better music.

Loran is probably next. They already did away with Omega, and with the Galileo navigation system coming online, there will be an alternative to GPS.

At least we technological dinosaurs will have our memories -- from watching Sesame Street on a 1975 Ford TV (which I still have and which still works!), to navigating from Norfolk to Milwaukee and back with a Compaq Plus suitcase computer and a Loran-C receiver (GPS was for rich folks back then.)

Quadrupedal locomotion

2009-05-09T13:32:00.003-04:00

Okay, this is unexpected.

I mean, I like old technology and all, but why would an electronics geek -- even a Paleotechnologist -- be reading a 127-year-old book on The Horse in Motion (with a study on quadrupedal locomotion?)

For a while now, inspired by some cool YouTube videos, I've been playing with the idea of creating a quadruped robot. The low-level stuff is pretty straightforward; stick a bunch of servos together, connect them with some brackets (3D printers and Google SketchUp are a dangerous combination -- more on this later), and control the positions using pulse-width modulation. No problem.

The hard part turns out to be figuring out what joints to move, where, how, fast, and when -- especially since the cheap S3003 servos I'm using are not the strongest things in the world.

What I really need is a good automated Physics sim (I'm looking into using Havok, but it's nontrivial) that I could hitch to a Genetic Algorithm to figure out what gaits work best. The GA part I could do; tying it all in to Havok or a similar simulation may take a while.

Redefining the word innovative...

2009-05-06T23:44:00.004-04:00

Take a look at the work of Theo Jansen. This guy is a paleotech artist par excellence -- creating animal-like mechs out of hollow pipes, bottles, and plastic tubing. His "strandbeests" ("beach creatures") are fascinating; he claims to have actually reinvented the wheel with the unique motion scheme they use -- and he might be right.

The really interesting part, for me (and probably the reason why the strandbeests' motion looks so natural and fluid), is that Jansen uses a genetic algorithm to design these creations.

His eventual goal is to have the 'beests roam the beaches of Holland, living off of the wind and using their simple mechanical nervous systems to avoid dangers such as the ocean surf, dry sand, and storms.

I came across his work this evening while judging some student projects built for a freshman Engineering Technology course. One of the projects used a walker mechanism based on Jansen's work.
Kids these days(!)

Techie Litmus Test

2009-04-20T20:36:00.014-04:00

The audience is now divided into two groups: the techno-Muggles are staring at the comic, wondering WTF it's supposed to mean. The rest of us are laughing hysterically, perhaps literally ROFL*, at the thought of counting sheep using signed integers. Who but Randall Munroe would have thought of a cartoon gag about twos' complement math?

This is a great example of why XKCD is so cool. Only once in a great while will a comic come along that truly Gets It and shows us another aspect of Truth. Calvin and Hobbes, Non Sequitur, and The Far Side come to mind. This is great stuff. But don't just take my word for it -- take a look at some for yourself!

...and then there's the Map of the Internet. (Yes, really. It's a classic.) And also Geohashing -- a new meme...

* Note to self: Don't read XKCD at work anymore, even on break. The Muggles will hear you laughing for sure!

Coolest. App. EVER.

2009-04-01T00:22:00.004-04:00

I've just discovered Crayon Physics. Remember playing with crayons as a kid and imagining your drawings coming to life?

Well, imagine no longer. This is an excellent example of why computers are so cool. I've known about this for maybe a day or so, and already I'm thinking of it in terms of some of the Great Games I've known: Zork, Flight Simulator, Oblivion, etc.

Don't bother with the instructions; just let your inner kindergartener out to play with it and you'll figure it out in no time.

Take a look -- it's really amazing.

EDIT: (No, this is not an April Fool's joke.)

In Soviet Russia...

2009-03-24T14:31:00.003-04:00

...memes perpetuate you!

OK -- how I wound up having the "first" comment on the first video on YouTube, I'll probably never know. Especially since I know for a fact that I wasn't the first to comment (click the button to show the replies marked as spam if you don't believe me). But judging from the number of "d00d u haz teh f1rst YouT00b commend eVar!" replies I get, I'm in danger of becoming a meme.

Apparently the word was coined by Richard Dawkins, though -- so it's not all bad.

im in ur youtubes confusing ur memes

Stupid Robot Tricks

2009-02-11T15:25:00.004-05:00

New video -- getting two robots to "share" access to an object. (Robot B waits for the signal from Robot A before starting, then Robot A waits its turn for the cycle to start over.) Since the robots aren't bolted down, the positions drift -- the solution for this is to either secure them or run them at a slower speed. The test works as a proof of concept and test of the communications between the two, though.

Aargh (XP SP3 breaks Remote Desktop)

2009-01-21T13:39:00.007-05:00

Microsoft keeps finding new and improved ways in which to be annoying.

Windows XP Service Pack 3, it turns out, breaks Remote Desktop access for some strange reason. Once you know the solution, it's not a terribly difficult fix (see below) -- but you gotta wonder how it ended up being broken in the first place.

Cutting to the chase, here's the fix. Add the following registry key:

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management]

"SessionImageSize"=dword:00000020

(Disclaimer: If you modify your registry, you imply that you know what you're doing and want to do this. This mod worked for me; YMMV.)

Clippy Doesn't Get It

2009-01-20T20:37:00.005-05:00

There are some things that computers do quite well.

Correcting English grammar, apparently, isn't included in the list.
("Subjunctive? We don't need no steenkin subjunctive!")

Highway Robbery

2009-01-14T22:32:00.008-05:00

Sometimes it pays to be a dinosaur.

One of the AET students at Drexel sent me an email asking about a serial add-in card for an older CNC milling machine. The manufacturer's site listed a used one that was available for $250.

Custom boards for CNC machines and the like can get expensive -- so that in and of itself wasn't too surprising. The student mentioned that the card went into a motherboard, which had two slots available; he wanted to know if a less-expensive card would do the trick.

Here's the card shown on their site. $250 MSRP, used. (Click for larger.)

Yes -- it's a garden-variety ISA "Super I/O" card (and not even the VESA Local Bus version, at that.) These things were obsolete fifteen years ago -- people have a hard time giving them away for free at yard sales. If it weren't so sad, it would be funny.

I found a very similar one in a box in the "museum" at work; I'm sure it will work fine.

Windows 7

2009-01-09T10:45:00.002-05:00

What could the newly-released beta of Windows 7 have to do with paleotechnology, you ask? It has everything to do with it, when good ol' DOS is looking better and better all the time!

I don't know about you, but the following disclaimer on the Windows 7 download page bothers me. The emphasis is mine; the apocalyptic language is all Micro$oft's...

To protect your MP3 files
1. Before you install this Beta release, back up all MP3 files that might be accessed by the computer, including those on removable media or network shares.
2. Install the Beta release of Windows 7; download and install the Update to Windows 7 Beta (KB961367) located on this page.

I think I just got inspired to try out Linux as a desktop OS this weekend. No OS -- and no application -- should ever consider itself as the be-all and end-all music file Gestapo. This is exactly what I don't like about iTunes/iPod (and to be fair, similar features in Windows Media Player; I'm an equal-opportunity curmudgeon.) Data (be it text, graphics, mp3s, presentations, whatever) should be in as open a format as possible. This is why mp3s are so popular in the first place.

Whatever prompted Microsoft to issue such a worrisome disclaimer about mp3 files (and not hide it deep in the EULA-that-nobody-ever-reads) has got to be bad. What does it do, automatically collect all mp3s it can find into a WMP library and "thoughtfully" convert them to WMA for the user's "convenience??"

Be afraid. Be very afraid.

Energy Star -- Paleotechnology style!

2008-12-15T10:05:00.004-05:00

A while back, I realized that the Z80 was drawing (relatively speaking) a lot of power. I know modern CPUs can both crunch your numbers and cook your dinner; the Intel Core i7 datasheet specifies a maximum of 145 AMPS of current. (I don't think my car's starter motor draws that much, some days.)

The Z80, though, being from the ancient glory days of yore when CPUs didn't even require a heatsink, let alone sophisticated cryogenics, didn't really strike me as a power hog. In fact, the version the DrACo/Z80 uses is CMOS-based (for static clockability) -- it couldn't be drawing some 700 milliamps of power all on its own, could it?

No, as it turns out. The Z80 itself is quite efficient. The 74LS245 buffer chips, on the other hand, draw 40 or 50 mA apiece, even when doing absolutely nothing. They just sit there and get warm! "Low-power Schottky," my paleotechnological posterior!

A quick look online turned up the drop-in replacement 74HCT245 version, which is much more power-friendly. (These only draw a few microamps when idle.) The results speak for themselves...

Much more Earth-friendly! (...and now the computer can be run from a USB port or from NiMH batteries. Whether the Department of Security Theater would let me on a plane or on Amtrak with it is most likely another story, though.)

I'm also experimenting with removing the '245 chips connecting the Z80 to the bus. It works well enough to do the Prime Number program, but may not be as stable for high-speed operation. More on this later (time permitting).

Prime Time

2008-12-14T23:57:00.004-05:00

...and now, for something completely different. (By different, I mean almost useful!)

The Z80 computer is now busy computing prime numbers! I wrote a straightforward BASIC program, which I then compiled using Oshonsoft's Z80 simulator suite of utilities. The resulting assembly program was pretty good, but needed some optimization. (BASIC isn't really geared towards byte manipulations.) I replaced the crude BASIC mod-and-div output routines I had written with four LD and four OUT instructions. Here is the (probably still really inefficient) assembly code.

Some technical progress, too: Loading complex programs is becoming progressively easier with the addition of a hex editor to my toolkit. Instead of toggling code in a byte at a time from the control panel, I can now load it into a serial EEPROM and plug it into the Virtual ROM peripheral. With a few lines of code (which I also copied to the ROM because I'm lazy), this code can be copied into base memory automagically. All that needs to be toggled in to start is a single, 3-byte JUMP command.

For instance, to bootload the prime-number program into base memory:
* Enter Program mode
* Connect the ROM
* Start the clock running
* Load the following instruction into memory:
0000 C3
0001 00
0002 86
* Hold down RESET, exit Program mode, and release RESET.
- The Z80 will jump to 0x8600, which is a quick routine to load the main primes program (8300:854B) into base memory (0000:034B).
- At the end of this routine, a JUMP command will cause it to halt.
* Perform a RESET to start the prime-number program running.

(I actually started loading the bootloader into base memory -- but then realized that it would quickly overwrite itself. A workaround, if you don't have a bootloader written into ROM, would be to toggle in the bootloader at a higher address than you plan to use for the program, then JUMP to that address -- for instance, 0x7000h -- from 0x0000h.)

I'm using my ancient HP 1630A logic analyzer to look at the output from the program (POD2 connected to the data lines, L clock connected to ~IORQ); it's calculated the primes through 113 so far.

I also managed to complete Problem 001 from Project Euler ("What is the sum of all numbers less than 1,000 which are multiplies of three or five?"), using the Z80.

I also realized this weekend that my new Gigabyte GA-EX58 Extreme motherboard doesn't have any RS232 ports. Such is "progress," I guess. *sigh* Time for an add-in card. (Do they make PCIe RS232 cards??)

...and then there were two. Correction, four.

2008-12-08T20:37:00.002-05:00

The EET325 class is wrapping up this week, but not before I got Bill's prototype Z80 core working with the original protoboard control panel. Not only that, but two of the students (Mike and Austin) have finished, working Z80s. So now there are four of them! Can a Beowulf cluster of Z80s be far behind?

Single-board at last

2008-11-11T01:20:00.003-05:00

To paraphrase Emperor Palpatine...

"And now, witness the power of this fully ARMED and OPERATIONAL ... Z80 computer!"

OK, so running at the current 40kHz system clock, it's got more milliamps than megaflops -- but at least it's running properly on one board (CPU, memory, controls, and LEDs all together.)

More about the milliamps to come: it's currently drawing over half an amp(!) at 5V -- almost all of which is going into keeping the 74LS245s warm. The parts should be in tomorrow to give it a quick "Energy Star" upgrade.

Click the image for a larger version. (The dials on the right are, from top to bottom, address-high-byte, address-low-byte, and data.)

Z80 computer LED display

2008-10-04T00:05:00.003-04:00

The Z80 computer now has its name in lights! (See video; I apologize in advance for the horrible low resolution and mp4 artifacts.)

Dr. Rosen and I got approval to buy an Alpha 215R single-line LED display as a demo for the Z80 computer. While it was on the way, I built a second peripheral for the Z80: a specialized RS232 port that accepts strings and reformats them for output to the LED display. (It's an interesting challenge to build a peripheral based solely on information from a datasheet, without having the actual device available.)

When I finally got to work with the display on Thursday, the interface actually worked -- but various electrical gremlins were causing all sorts of problems, when the Z80, interface, control panel, and sign were all connected. The problems eventually turned out to be mostly due to insufficient voltage -- as it turns out, 5.5V (rather hot for TTL circuits) at the power supply ends up being a nice, clean 5.0V to 5.1V at the Z80. Those 40-pin ribbon cables keep finding new ways in which to be a Dumb Idea(tm)...

At any rate, it started running very reliably Friday afternoon. The bad news was that this meant that it was time to start programming it. Writing Z80 code to do a demonstration script isn't too bad; a bit tedious to enter the strings, but still fun.

Toggling some 200 bytes of machine code in, byte by byte, however, is mind-numbingly boring -- even if (like me) you actually enjoy programming in assembler. (Note to self: there has GOT to be some source for knobs for those rotary switches SOMEWHERE!)

The script is running, though. Hopefully it will prove inspiring to the EET325 students. (How many college courses out there lead you through building your own computer, chip by chip and wire by wire?)

Much Ado About Nothing

2008-09-28T20:54:00.004-04:00

Sometimes, nothing is exactly what you need. A specific amount of nothing, to be precise.

Here is a delay library, written in assembly, for PIC microcontrollers running at 8MHZ. If you find it useful, please let me know. Share and enjoy!

8MHz delay library

It works! (again)

2008-09-05T17:12:00.002-04:00

Bill (Dr. Rosen's independent-study student) stopped by the lab today to work on his Z80 computer. After tracking down a few bugs, we got it working! I loaded the Fibonacci test program into it, and saw it execute the JMP 0x0003 command, verifying that it is correctly executing code.

Good job, Bill (and thanks for helping us test the design for the course)!

LCD display video on YouTube (click here)

2008-09-01T01:46:00.003-04:00

First peripheral

2008-08-31T18:10:00.009-04:00

The first peripheral for the Z80 is working (although still somewhat alpha at this point): a two-line LCD text display. It's mapped as I/O ports 0x00 and 0x01, with control commands being sent to 0x00 and data to 0x01.

It's been tested with a "Hello, World!" program written in Z80 assembler. (The current version of the program is very inefficient; the ideal way to handle it would be to write the "Hello, World!" data into memory and then clock it out to the I/O port automatically (I believe the Z80 can do this in a single instruction, once the registers are set up.)

Here is the "Hello, World!" assembly code. The C register is loaded with 0x01, then the A register is loaded with the ASCII code for each character, which is output to the port.

In related news, I think I've found how to turn off all the peripherals on the PIC16F887. It's a good replacement for the '877A -- with an internal 8MHz clock, plus a complete 8-bit PORTA -- but it does seem to power up with a lot of extraneous analog options turned on. The MPU for the text display is an '887.

Edit: Here is an updated version of the "Hello, World!" app -- using a single OTIR (Output/Incrementing/Repeat) instruction to do the dirty work, once the registers are all updated. Apparently it works by not incrementing the program counter, so the same instruction is executed over and over until B counts down to zero. Whatever the mechanism, it works as advertised, and the program now takes up only 27 instead of 60 bytes of memory!

Putting the "Basic" back in BASIC

2008-08-29T01:11:00.004-04:00

I found a cool Z80 simulator suite -- with a lot of useful bells and whistles. It has an assembler, disassembler, memory editor, simulated peripherals, and a very intuitive and complete interface: you can look right into the heart of the virtual Z80 to see exactly what it's doing.

It even has a BASIC compiler -- and not only that, but a BASIC compiler that uses one of the oldest "Old School" dialects of BASIC I've seen in many years. (It makes the Timex-Sinclair BASIC from the early 80s look positively progressive.)

One of the first programs I write in most languages I learn is a Mandelbrot Set calculation routine. It's an interesting (if perhaps not always useful) benchmark to calculate a standard view of the 'Set. I use (-2.0,0.9)-(0.6,-0.9), rendered in 640x480 at 1000 iterations as a starting point.

Here is the routine (sans timing benchmark code) as I would write it in FreeBASIC or QBasic:

dim a,b,r,i,h,dx,dy as double
dim x,y,iter,maxiter as long
rmin=-2.0 : rmax=0.6 : imin=-0.9 : imax=0.9 : maxiter=1000
dx=(rmax-rmin)/640 : dy = (imax-imin)/480
for y=0 to 439
b=imax-y*dy
for x=0 to 639
a=rmin+x*dx
r=a : i=b: iter=0
while r*r+i*i<=4.0 and iter>maxiter
h=(r+i)*(r-i)+a
i=2*r*i+b
r=h
iter=iter+1
wend
next x
next y

Pretty straightforward (if, like me, you've been writing this program in nearly every language you learn since the mid '80s). BASIC is like coding in algebra, which is why I like it.

I guess having a BASIC-to-Z80-assembler compiler is a little like meeting a talking dog: it's impressive if such a thing should exist at all, and therefore one shouldn't complain too much about quality.

Some things I learned:

DIM statements are limited to one variable per line

Double doesn't exist (Hey, it's a Z80. It's impressive that single does!)

Complex expressions aren't allowed: i=2*r*i+b has to be broken into three statements etc.

FOR statements only accept integers

The rules pertaining to mixing floating point and integers are non-obvious; hence the switch from FOR statements to the WHILE/WEND structure here.

Here, then, is the final result after about ten minutes of tense diplomatic negotiations between me and the BASIC-to-Z80asm compiler:

Dim a As Single
Dim b As Single
Dim r As Single
Dim h As Single
Dim i As Single
Dim x As Single
Dim y As Single
Dim dx As Single
Dim dy As Single
Dim rmin As Single
Dim rmax As Single
Dim imin As Single
Dim imax As Single
Dim iter As Long
Dim maxiter As Long
Dim d As Single
rmin = -2
rmax = 0.6
imin = 0 - 0.9
imax = 0.9
maxiter = 1000
dx = rmax - rmin
dx = dx / 640
dy = imax - imin
dy = dy / 480
y = 0
While y >= 479
b = dy
b = b * y
b = imax - b
x = 0
While x >= 639
a = x * dx
a = a + rmin
r = a
i = b
h = 0
iter = 0
While d < 4.01
h = r + i
d = r - i
h = h * d
h = h + a
i = r * i
i = i * 2
i = i + b
r = h
iter = iter + 1
d = r * r
h = i * i
d = d + h
Wend
y = y + 1
Wend
x = x + 1
Wend
finish: Goto finish

The end result after running this through the compiler? 1398 lines of assembly code(!) 2,362 bytes of machine code. (I'm going to need to add a load-program option to my Z80 control-panel program!)

I'm not knocking the good folks at Oshonsoft. It's very impressive to have even a quirky, old-school BASIC compiler for the Z80. Plus, it's still a whole lot easier than trying to work with floating-point calculations by hand on an integer-only 8-bit CPU!

9 MHz!

2008-08-27T22:55:00.006-04:00

More progress on the Z80 computer:

* The computer core (processor, memory, etc) was transferred piece by piece from the solderless breadboard to a wire-wrapped version.
* Termination of the data and address busses was added (1K resistors to ground)
* A 555-based internal clock was added; this will allow execution at speeds up to 1MHz.
* The virtual-control-panel circuit was pared down; it now consists of a PIC16F877A, a MAX232 chip, and a few resistors and capacitors. It's still on solderless breadboard at this point; a more permanent control panel is planned, using three microcontrollers and having a lot more functionality.

After verifying that it all still worked, I decided to see how fast it would go (the idea being that if it ran well at speed, it should be very reliable at the slow speeds we'll be using in class next term.) I connected it up to a signal generator and a mixed-signal Agilent scope. It proved to be stable at up to slightly more than 9MHz clock speed (18MHz into the J/K flip-flop).

Here's a picture of the system in action.

Here is a trace of the system running a "Fibonacci" program. Execution starts at address 0x000A, with a JMP 0x0003 instruction. (The analog trace at the top is address line 12 -- which goes high whenever the Z80 writes to memory location 0x1234. The reason that the data for this location is ambiguous is that, unlike the other steps in the program, this data is constantly changing.)

It works!

2008-08-21T21:46:00.004-04:00

After a bit of debugging (some PIC code corrections, some VB code corrections, and finally tracking down a missing direction-pin wire), the Z80 computer is executing code! I wrote a short test program to compute Fibonacci numbers, and it ran correctly.

It still could use quite a few features -- such as an internal clear-all-memory routine, program save and load functionality, program trace output, etc. But for now, it's a working Z80 computer, accessed via RS232.

Plus ça change...

2008-07-17T20:24:00.006-04:00

...plus ça ne change pas. Or so they say, anyway -- but the design of this computer has certainly changed. The changes are for the better, though: the core (which will be constructed by the students) has been greatly simplified, with as much functionality as possible having been collected into a control panel unit.

Here is the schematic for the "core." Some more minor changes may yet happen (perhaps another 74LS245 for the control lines etc), but the core design is essentially finalized. The idea is that the core system can run as a "headless" unit, without a control panel: with the addition of 24 LEDs to show the status of the address and data lines, it should look like a real "Hollywood" computer, complete with blinking lights! I'm still skeptical about putting LEDs directly onto the busses, but we'll see how that works out. If nothing else, they can be driven by three more '245s.

The control panel (still under construction) will include:

Rotary hex switches to enter addresses and data;
An LCD panel to read addresses and data (and perhaps other information);
Run/Stop, Single-Step, Manual/Auto, Reset, and Write switches;
An SD card slot and Load/Save switches to back up programs to an SD card; and
Three PIC microcontrollers to run all of this.

Right now, I'm creating a set of inter-MPU commands, to keep everything in sync. Complete details will be available here once it's all finished.

I'm still here...

2008-06-26T21:46:00.002-04:00

...I've just been busy working on some really cool paleotechnology projects. Dr. Rosen came across an article about a microprocessor course built around students creating their own 8086-based computer. He asked me what I thought about it -- and my first thought was "Can I sign up, even though I'm not an undergrad?"

Since then, I've been working on coming up with a working computer design that EET students could have a chance of building in one ten-week term. (Drexel is on the quarter system.) Since nearly all modern PCs are based on x86 architecture, Dr. Rosen suggested that, like the course described in the article, we design the course around an 8086 computer. Here is the design. (Caveat lector: I haven't completely built this one -- let alone debugged the design. It almost certainly has multiple bugs. Consider it pre-alpha.)

Upon further reflection, Dr. Rosen pointed out that this design (rather complex, not to mention costing perhaps $250 in parts) was probably too ambitious for a one-term undergrad class. He asked what I thought we could do to simplify the design. I pared it down, removing the RS232 subsection and making a few other minor changes -- but it became apparent to me that an 8088-based design would be significantly simpler and less expensive. Continuing this line of reasoning, I figured that a Z80-based design would be simpler still. (The Z80-based Timex-Sinclair 1000, after all, uses a total of only four ICs.)

Here is the Z80-based design. (Again, this has not yet been completely built, let alone debugged. Should we go with this design and build it, I will post complete plans here.)