gregor owen
software engineer

embedded microcontroller-based real-time industrial systems assembly language / c / c++ / mac objective c / delphi pascal documentation

Assembler/machine language, hardware:  38 years
C/C++:  32 years
Delphi Pascal:  20 years
owenlabs@aol.com short resumé



EMBEDDED SOFTWARE: Microcontroller real-time interrupt-driven systems in assembler and C language with multiple stacks and task switching, usually supporting the two or more lines of large-character print in Loveshaw industrial printers but also executing other system tasks — that is, my own custom RTOSs. Most projects included a user interface conducted in the background, from RS232 terminal to PC CRT to bubble keyboard/LCD — the systems were low-rent single-CPU systems that printed and also talked to the operator, often concurrently.

HARDWARE: Bringing new microcontroller-based gadgets to life, finding/fixing hardware flaws, figuring-out operation (or not) from schematics, and writing/integrating firmware into hardware design — and modifying and creating hardware designs including a DMA PC card.

DEBUG: Chip-level PC-based debugging and older ICE equipment — including design / fabrication of a 8048 h/w debugger (cp/m version around 1985) — along with logic analyzers, oscilloscopes, and other test/debug equipment.

ASSEMBLY LANGUAGE / C including Zilog Z80 and EZ80, Intel 8048, 8088 et al, Motorola/Freescale 68HC11, Microchip PIC. Also C language for PC, 68HC11, EZ80, and a Freescale S12-based project, as well as numerous PC utilities.

C++, OBJECTIVE C(++): Borland’s C++Builder and some Microsoft Visual Studio 2005/08/10, + a little Macintosh Xcode. ... Code that compiles in Windows (Visual Studio, C++ Builder and MinGw GNU g++) and the Macintosh (X10.4 g++ — command line and Xcode), including an actual make file that works in both systems! (See C++ ini file demo project, and discussion of Microsoft’s .NET flavor of C++.)

DELPHI PASCAL with Delphi RAD programming environment since 1996, for numerous utilities, printer-control programs, the odd database project, and a TCP/IP client/server PC product. See reflections on Delphi class assignment, the dubious antique OwenShow Windows / Linux project, and MySql Considered Harmful....

*NIX: A few weeks now and then on the Linux/Mac/Unix command-line.

I speak, read, and write English, and have created extensive DOCUMENTATION — see owenhelpmanuals, and diagrams. ... I like to comment code. ... I don’t lose source or documentation, over the years generating numerous BACKUP CDRs, zip and other disks, tapes, thumb drives, and I’ve preserved and used detailed records — source, operator manuals, graphics — from as long ago as 1985. bachelor of science

EDUCATION: BS in Computer Science, New York State Regents External Degree Program, 1984. This institution, now known as “Excelsior” college, probably still provides access to no-classtime all-test (GREs etc.) degree certification, at www.excelsior.edu.

IQ: 131 — at least according to the Tickle online test, which I took after the Monster job site goaded me. Tickle also said

Your Intellectual Type is Visionary Philosopher. This means you are highly intelligent and have a powerful mix of skills and insight that can be applied in a variety of different ways. Like Plato, your exceptional math and verbal skills make you very adept at explaining things to others — and at anticipating and predicting patterns.

Then they offered to sell me a report that would tell me more....

2013 ...

Shameless frivolity, with my virtual organs and silly cameras, in paradise....

... But in the still serenity and beauty ... something was missing. ... Pathetically, shamefully, after the dust cleared ... I missed work! ... So in commemoration of more than a few flawlessly joyful hours designing imaginary printers, I figured I could just as well do that here with my own brand-new enterprise and logo. ... So, a new paradisiacal biz card:












(Below, I preserve in tottery HTML my quaint antediluvian activities of yore....)


1984-8/26/13: Loveshaw (ITW)

I developed large character ink jet printing (industrial marking) and labeling systems for Loveshaw (a unit of Illinois Tool Works) including software, hardware, and PC Windows programs to control the systems through RS-232/422 ASCII link languages I designed. The devices printed dot-matrix patterns up to 32-dots high, consisting of letters, numbers, bar codes, and user-specified graphics patterns.

Loveshaw thrived in a competitive market with exceptional support, notably my rapid turn-around time on software projects — days and hours, rather than the typical months and years.

The PRINTED CIRCUIT BOARD project used the once-noble EagleCAD capture/PCB program — and finally I made a board, resurrecting a product suffering from through-hole obsolescence. ... I “made” the board in the sense that I paid a pittance to IteadStudio to transform my Eagle Gerber files into actual physical PCBs, which arrived after a month in a little box covered with Chinese writing. ... And, actually, Itead provides their own Eagle “CAM” files to make the Gerber files. ... But I made the simple-minded schematic, and the printed circuit design! ... Although I suppose Eagle’s autorouting helped a little. ... And in the end, it took the massed industrial forces of Loveshaw to actually solder the SMT device onto the board, and thus, it seems, I stumbled on the shoulders of giants....

But then again, I did do the first version (shown here) with the big chip on the wrong side of the PCB so it didn’t actually fit into the units; but all fixed after another Eagle run. ... And a few of these things were built, and somewhere they may actually print. ... It’s almost as good as the reported North Pacific tuna boat printer installation.

... Other LATTER DAY 68HC11-based product maintenance included Basic language and the Qlarity G55 terminal — a handy controller for various Loveshaw gadgets, including third-party printers used with the company’s labeler. It supports an RS232 interface, still common (and cheap) in industrial environments, which was used for utility features in Loveshaw products. The (free!) PC-based programming environment is reassuringly / alarmingly familiar to those of us who have used Visual Basic, Delphi etc.: you get to “paint” the GUI, and then write bits of Basic code to string it all together and actually do something.

THE Z80 YEARS: When I arrived at Loveshaw in 1984 I took over a Z80 assembly language industrial printer project with a bubble QWERTY keyboard and 2-line LCD screen. I typed the assembler code into a CP/M Kaypro microcomputer from printed listings. The design used 556 timers for the central ink valve timing, controlled by thumb wheel potentiometers on the front panel. Which was odd since there was also a Zilog CTC “Counter Timer Circuit” LSI chip with four digital timers. Two of these were squandered on product delays — the interval from photocell trigger to printing, which were set by yet more thumb wheels; I think one timer was used for baud, with one left over. So I did a redesign with the CTC doing the valve timing, and everything else in software — which is why the Deity created microprocessors — and found only a few hardware cuts and jumpers made it work right, suggesting the design may have lost its way once....

The system went on to many glorious permutations over many years, including two advanced CRT terminal versions. Supporting these products were my PC control programs — at first, simple command-line / character-based in MSDOS, and then Windows 3.1, where I ingeniously reused existing C-language code from the character-based programs via a DLL and coroutines.

In this and most of the subsequent printers, a single embedded CPU supports real-time printing via interrupts + implements the user interface (print message editing, menu features) in the background.

In the late ’80s, the company entered the 8088 / 68HC11 era: a 6811 version of the Z80 product was designed, and then a more elaborate 8088-based system. My 6811 assembler code was basically a tidied-up translation of the Z80 products. My 8088 software was assembler + C, including coroutine code for multitasking. I wrote various PC programs to provide access to both the 6811 and 8088 designs. Both units used industrial bubble keyboard / LCD handheld units.

The 6811 won — the hardware design was simpler/cheaper, particularly after the handheld was “absorbed” into the main chassis. Numerous variations on this basic printer continued for years, ranging from 5 dot single-head machines up to 6 heads, + newer technology higher-resolution 32-dot devices. I diverged the software to follow the hardware models — but the basic code was fairly common to all. Along the way, avoiding the endless struggles typical with cross-assemblers, I wrote my own. ...

My Windows programs for the printers supported message edit/change and other features, including graphics: the letters in a printer graphics font were replaced with images loaded from the PC program .

My industrial RS422 network for the 6811 design allowed multiple printers to connect to a single PC with longer cable runs / less cable, and also alleviated the then-limited supply of PC serial ports. I wrote multi-language “localization” interfaces; in the most elaborate cases including utility software to allow user customization.

PC DMA: In the early 90s, Loveshaw did a comparatively hi-res 32-dot PC architecture-based project, in which I used C and assembler to implement multi-tasking on the PC’s timer, with extensive interrupt and DMA code. Eight ~32K DMA buffers were switched in and out-of a LIMEMS expanded memory frame for imaging, while DMAing at actual physical addresses in extended memory (an article on this technique and the numerous PC memory-standards involved appeared in the 12/95 C/C++ Users Journal p. 27).

The product went through years of variations and customization. In 1994, a costly third-party PC card was replaced with my 68HC11-based hardware design and assembly-language software. In the design the custom chip on the third-party card was replaced by a 68HC11 + software, which was slower but cheaper. Eventually it wound-up in a turnkey PC/104 platform with a handheld bubble keyboard / LCD user interface also controlled by the 68HC11. The circuit emitted a controllable waveform while transferring four bytes via PC DMA at rates up to 10 kHz (100 µS period per 32 bits) with heavily-macroed assembler.

Around 1996, I wrote a Delphi program to provide a graphical Windows 3.1 interface for the printer — i.e., on a separate normal PC running Windows. The program included a cute printing-preview graphics screen. As usual, the Windows program communicated with the printer through an RS-232 link language I created.

LABELS: In 1999, Loveshaw acquired labeler technology and “microcontrollered” the hardware. Using schematics, I converted analog/digital circuitry (four dual 1-shots, some 40xx CMOS and a few transistors) to 6811 software. One-shot logic was translated to elaborate 6811 timer macros, with values based on the resistors/capacitors in the schematic. The potentiometers became software menu items which the operator could easily adjust without a little screwdriver.

The software macros encapsulating input/output and delays look like

    ApSolenoidOn
    waitms ApplSolenoid
    ApSolenoidOff

A variable-to-menu macro system made setting-up the timing and other variables a matter of making entries in a table like

    dataApplyPrint macro ;def, min, max
    makevar ProductDelay,defPD,0,BigMax
    makevar ApplSolenoid,200,50,20000

which were translated into variables for the execution logic, and entries in a menu for the operator.

Along with saving and restoring timing / variable setups, my Windows program for the system could also document / emulate logic event sequences, for debug / verification during system design and test.

The eZ80 is a Zilog microcontroller — and an antique vacuum tube, a popular rectifier in some 60s guitar amplifiers. ... The eZ80 has its nostalgic features: you could run your old CP/M programs in binary Z80 mode, or in the modern style all the original Z80 16-bit registers magically become 24-bits wide; + the eZ80F91 came with 256 kilobytes of flash ROM, ethernet support, timers, 32-bits of general-purpose i/o, uarts, and more. ... In the illustration, I’ve persuaded Zilog’s demo board to talk to an LCD, even ’though the eZ80 is a 3.3 volt part, but cheap LCDs are definitely 5 volts — so I interfaced the LCD with general-purpose i/o bits, and minimized the required bits via the LCD’s 4 bit mode. This worked because (1.) the eZ80 happily tolerated 5 volts on inputs; it’s a feature; and (2.) the LCD sees a “high” for the 3 volts-or-so the eZ80 emits.

... Then in a burst of enthusiasm, I concluded things would go faster if I didn’t have to use the free/slow/cranky Zilog C-language compiler to concoct the user interface, but instead enlist the space-age (© 2000) Borland C++Builder environment in the cause. I compiled the numerous existing C files in a Builder project along with some mixed C/C++ emulation code. ... And it did speed things up, as well as providing a PC “demo” version of the interface for the company....

One of the great microcontroller families is the MicroChip line of PIC chips, which included the now-obsolete PIC16F877 which I used to create two printer accessories, starting with a port expander project to add-on serial ports and other functionality to our basic printer design.

The second project was an LCD/bubble keyboard terminal, with the goal of reducing the expense of multiple printer purchases with a single operator interface device (i.e., a separate low-rent LCD serial terminal). I found a clever keyboard scanning technique on the web: In the average keyboard scanner circuit, the square root of the number of keys + 1 or so, times 2, is the number of microcontroller pins needed. But using the bi-directional capability of most modern microcontrollers, that can be reduced to the square root of the number of keys times 1, plus 1 or 2 or so, + a forest of diodes and resistors — which generally are cheaper than microcontroller pins....

One of the striking charms of the PICs — aside from their low-rent development equipment — is their utterly barbaric assembler. Fortunately MicroChip has an adequate macro language, essential in such situations.

At the frontiers of industrial science, a TCP Client Server project brought printer control into the 90s with a Win32 Delphi program + a TCP client / server connection.

The printers themselves were stuck in the inexpensive past, with my simple RS232 or RS485 proprietary network designs. The new Windows + Delphi + third-party Internet components + Marshallsoft’s 32-bit serial DLL opened new vistas, supporting ethernet connections as well as USB serial (32 ports — or more!) and, with a little luck, actually running on the next operating system Microsoft© released — and, indeed, it did run without complaint on XP when it showed up — out of the box!

... On the other hand, there are numerous $150 industrial TCP/IP / RS232 / RS485 boxes that apparently do everything my server did, and no PC required. But the Win32 program, which also supplied normal printer control functions through the usual serial link, only took a bit of disciplining to work OK in Vista; and, later, Windows 7!

My SCRAMBLE utility randomly rearranges my link modules to optimally avoid the 68HC11 B600-B7FF EEPROM hole — a discontinuity built-into the program space. ... The EEPROM could be entirely disabled, but only in a special-mode manufacturing procedure ($), a decision Motorola eventually reversed in the “E” series but too late for us....

My linker has an option which bumps a module that might enter this forbidden zone, but that merely works and doesn’t optimize usage in the region. ... So I wrote SCRAMBLE, which would try random rearrangements of modules for the best fit. At first, SCRAMBLE was so optimal, it saved the bytes occupied by the EEPROM hole! — because a coincidental bug in both SCRAMBLE and my linker wouldn’t bump a module if it happened to just hit the B600 boundary (which might explain some mysterious bugs of the past). ... Astonishingly, SCRAMBLE + my linker would fill up that hole over and over again! ... It was like artificial stupidity! ... But I had told it to seek the best solution and, after all, getting 512 bytes in the forbidden EEPROM hole for free was optimal....

After I fixed both programs, the best solution is still when a module hits B600 precisely, so not a byte is wasted before the boundary, but now the linker and SCRAMBLE correctly bump the module to B800. SCRAMBLE does 100,000 iterations — about 3 seconds in 16-bit 1988 Turbo C — but the actual solution takes around 13,000 tries. ... Thank goodness for those Pentiums....

Less amusing was the “E series” imbroglio where I cursed Motorola when my code failed with the 68HC11E but not in an emulator and/or a 68HC11A — and in the end, it was all my foolish pointer! Because it worked seemingly without flaw in the emulator, I burned around 200 EPROMs and resurrected my low-rent logic analyzer + homemade software before coming to the glorious outcome illustrated here.

What did I learn? (1.) Debugging software without a source-level emulator is unpleasant and foolish, although occasionally necessary. (2.) But I’m going to keep a logic analyzer around in case emulation doesn’t work. (3.) Don’t make stupid mistakes: at least a few days before the beautiful trace (<=), I should’ve known where the code was erupting. But I thought I had looked and looked and checked every inch. ... In the end, it was just a stupid code error that I couldn’t see.

Homily ...

... And isn’t life like that?! ... We struggle and suffer, only to discover there was a simple answer before us all the time? ... When the dust settled, it seems the broken pointer was something like $0102, a location where the E-series 68HC11 has RAM and the A-series doesn’t, perhaps explaining the pathological randomness of the E-series failures — although I can’t help but feel that reading random bytes from nothing ought to have been at least as unpredictable....

Subsequently, I modified my assembler to detect suspicious absolute references — i.e. because “ldaa 20h” (load from memory location 20 hex) should almost always be “ldaa #20h” (load the constant 20 hex) — which, I hope, will tend to discourage this kind of thing — although sadly, I don’t remember exactly how....

A class diagram

I advanced technology with an up-to-date printer parameter class. ... This sort of thing is obviously necessary, and charts of previous C-language primitive structures would be equally intricate — without the fabulously object-oriented methods in the illustration . ... But it certainly isn’t beautiful, although I always felt the Delphi chart had a certain poignant charm....

Reverse Engineering: Yet another Delphi Windows program communicated with a third-party printer via the MarshallSoft WSC32 add-on serial DLL (and see my latter-day free RS232 code). Source / documentation for the printer was scarce, so with Windows 95 comm port spy software, I analyzed printer comm traffic in the printer’s existing PC program and ascertained control and checksum algorithms.


a screen shotFonts: Two PC programs involved Windows bit-mapped “FON” files and the creation of numbers of special-purpose fonts — to emulate printing, for instance, as in the figure; for which I also wrote utility software to translate 68000 assembler font files.

And of course numerous printers required font support and I wrote numerous “ascii-to-font” programs, where patterns like


are converted to the bits and bytes needed by the printer.

AD-HOC Debug: I created a debugging environment for an 80C166-based (Siemens) printer with download and breakpoint features. I wrote the debugger mostly in Turbo C and wrote C software to translate the output of this 8088 compiler to 80C166 assembler.

In 1997, I used the Numega SoftIce tool to write a VxD (Virtual Device Driver) and Delphi program to demonstrate feasibility of manipulating DMA physical memory under Windows/W95. ... And the software is functional today! (Thursday, February 9, 2006) — under Windows 98 SE, to be sure....

I created hardware and software for two 68HC11-based PC cards. The first is described above; a second card did not require DMA performance, but involved more on-card intelligence and used 68HC11 C and assembly-language + 8048 assembly language. It included hardware / software for multiprocessor communication + coroutines, and used three PLDs.

Ancient days: 1978-1984

5/88-6/88: A month off from Loveshaw was foolishly wasted at a burglar alarm company. When I returned, Loveshaw had all but destroyed the product source code (5¼’’ diskettes) while moving to a beautiful new building, and provided at that location an astonishingly spartan closet for the resumption of my endeavors, contrasting alarmingly with my previous spacious garage-style accommodations out by the forklifts. ... We wound-up moving my office to my attic — where I had thoughtfully saved copies of the source — and all was well for many happy years of toil and strife....

8/83-8/84, Intelligent Business Communications (IBC): I wrote a communications language in 8085 macros that was used by myself and others to implement protocols in a distributed-processing telephone switch.

5/83-7/83, Artec Systems: Restored corrupted source for an Apple II card product using disassembler etc., and fixed printed circuit layout errors, in an orphaned project. ... All H/W, S/W for 8048-based BCD-to-RS-232 interface card, + Epson PX-8 laptop computer handler. Turbo Pascal interface to RS-232.

11/82-5/83, Satellite Transmission Systems (STS): Created tech documentation for existing undocumented input/output card. Using only schematics, I described unsuspected timing bugs in the device, and the defects I predicted caused failure in subsequently-installed systems. (The design used TTL for cable runs of tens of feet, which doesn’t work. I eventually re-engineered with RS-422, fixed timing, and field-modified several non-working units to a functional level.)

3/82-11/82, Burroughs (née Redactron): I created all s/w + h/w for a 10-chip interface to connect a proprietary word-processor’s badly-documented I/O chip to a CP/M 8’’ diskette drive (the industry standard in those days). ... I used a field programmable logic array (FPLA) in the design to hardware-translate the LSI-chip signals to a UPD765 disk controller IC. Created software system to automate FPLA programming. When the Burroughs/Redactron unit closed its doors, I was working on a comparable RS232 interface. ... Much later I learned Redactron’s founder was Evelyn Berezin, a lovely Long Island Jewish lady who designed the world’s first word processor — and the occasional airline reservation system apparently — which may explain the sometimes-haunted tone of the old-guard all-male-of-course management....

7/81-3/82, Applied Digital Data Systems (ADDS): I wrote a hard disk surface analysis program in Z8000 assembler to manufacturing specs; with elaborate defect table, track relocation, and documentation still intelligible today (!) — this for a Pick-based minicomputer. I never did much with the Pick operating system itself, but still retain a vague dread of char(253) and 254, which were data delimiters (also 252) in the fiercely database-oriented os.

11/78-7/81, Ithaca InterSystems aka “Ithaca Audio”: When the Z8000 was young, I created an assembler in Z80 macros in which I wrote a Z8002 monitor for card test, including Intel hex download. ... associate certified electronics technicianI fixed a hard-disk SASI (pre-SCSI) controller card; + large diagnostic / test program which consistently failed a hard disk vendor’s unit, revealing faults in the vendor’s firmware — I thought that was pretty cool then, but since I’ve come to realize it’s perfectly normal (the second rule). ... In 1980, I wasted weeks writing add-on subroutines to convert programs written in the company’s proprietary “K2” operating system so they would run under the up-and-coming CP/M. ... I reached the august rank of Associate Certified Electronics Technician during my capacitor stuffing days at the company, + achieved greatness with my notorious memory test which failed our premier microcomputer product: Z80 processors have a short instruction fetch and my program, merrily relocating itself throughout the system, executed code in nose-bleed regions up to then only used for data storage which, sadly, didn’t work for code. The engineer said it was cheating.

... I advanced the state of the art at Lansing Research (1978) with a wooden test jig to clamp-down high-voltage cables — instead of leaving them strewn around the bench during laser control-amplifier calibration procedures.

Before 1978: Phototypesetting in NYC, first at Enlightenment Press and then at Catherine Graphics, with paper punch tape and mechanical strike-on type (i.e., automated electric typewriters) at weekly community newspaper’s cold-type startup. When I left the field, Catherine Graphics’ latest Compugraphic phototypesetting equipment used the advanced 8080 microprocessor — and, of course, punched tape. ... The newspaper is where I developed valuable skills in manual octal long division, to calculate layout column widths for the Compugraphic thumb wheels — before cheap programmers’ calculators.

Articles in consumer/enthusiast tech magazines: “Doing 32-Bit DMA on a PC,” 12/95 C/C++ Users Journal, p. 27. My tech tips in Windows Developer’s Journal “Change Directory and Get Current Directory in Windows 95,” 11/96 page 31; “Loading Font Files in Delphi,” 5/97 page 49; and “Forgetting to Call FindClose()” 12/01 page 63. 9/84 Micro/Systems Journal page 114, “Co-Power-88, the SWP 8088 Coprocessor,” on adding MSDOS to your CP/M Kaypro, and ibid 10/86 page 66, “Using SYMDEB with NMI Breakpoints”.

a drawingDrawings: The more drawings I make, and the more detail in them, the more likely it is my hardware prototypes will work. I used standard PC programs like Paint Shop Pro and Corel Draw; i.e. I made no attempt to integrate with schematic / layout — the objective was more to keep an accurate set of notes of what I thought I was doing.

The Linux Desktop: I am mostly without clue in the magical World of Linux, although I managed to get NFS and Samba working in the Computer Attic — but nevertheless I am a Linux (utterly obsolete) Kylix expert: not only did I write my Linux/Windows open-source OwenShow program with Kylix, I’ve written a few bash (shell) scripts, including one I used to update the OwenShow source between Linux and my smb-mounted XP system.

I’ve written a few C programs with emacs and gcc, although I almost lost it when I discovered the frolicsome tricks the world-famous GNU editor played on my text in “stupid c-mode”; since then I found the Linux “Joe” editor in its “jstar” incarnation with WordStar keys was a lot more fun. ... I used the “ddd” debugger a few times, a seemingly-harmless GUI front-end for Linux dbg. ... And I wrote a C program I actually used in my bash script.... But my truly towering triumph was getting cute little icons to appear on the Linux desktop. ... Poignantly, my wizard’s cap doesn’t get much use these days, at least until I get Linux running again on something....

My Father’s Packaging Machines: Before me my father toiled in the higher-class pharmaceutical packaging biz. Little bottles would march down the vibrating tables and have useful things happen to them. This => was a small model he built of his “Schering D21” or so it says on it. I visited the enterprise several times in my impressionable youth and can’t say I developed a life-long ambition to emulate his inspiring success.

Random acronyms I have known: 80X86, Z80/8080, 80C166 (Siemens RISC micro), 68HC11, 6809, 6800, 6502, 8048, 68---, Z8001/8002 assembly language; HTML, FTP, TTL, PLD; Basic, CP/M, MSDOS WordPerfect, WordStar, Word, PCWrite, HP LaserJet, RS-232/422, SASI (pre-SCSI); CP/M-86, MP/M-80, Apple II, Tandy M100, PX-8, Intel MDS, Futuredata, Motorola Exorset, Motorola RMS-09, VGA, MIDI, SQL, BDE. ... I dabbled in PHP, Java; web editors and HTML hackery; FTP, Intranet + Servers; Visual Basic; Delphi + Fujitsu Cobol DLLs.

See my insightful discussion of Windows / Linux ticks. HW/SW for 25-IC 8048 emulator controlled by PC-based C software (notes, schematics in The Computer Journal starting 1/95, page 32). MIDI systems — hardware, translators, linker, performance program — for various hosts. MSDOS (early PC) TSRs: filter for disk read / writes to Hercules screen (DMA didn’t work with the Hercules circuit); bug-fix for Gateway / Phoenix BIOS keyboard lock-up problem; VGA dimmer; simple lap top battery timer; “WS4EVER” “diamond” control-key support. Wrote / use assembler-linkage package for 8048, 68HC11 and 80C166, including my own primitive source-tracing emulator software. Antique Tube-based test equipment, including tube testers, various meters, set testers. Numerous cranky letters-to-the-editor in technical magazines.

1992 MIDI add-on for a 32-note AGO pedal board. My minimal design is a wall wart, 7805 power, 8748 CPU, 74LS244 buffer, 32 microswitches and diodes, + a lot of wire. I use the built-in pull-ups in the 8748 to read the pedals with a standard keyboard matrix, and “bit-bash” the MIDI output to the 244 buffer. The result supported multiple notes (two feet) — and produced, as I deluded myself, plausible baroque-organ pedal sounds I programmed into a Casio CZ-101 synthesizer, at least after the result, along with my other dubious keyboards, went through a cheap-but-good-enough Alesis Microverb II as I ineptly brought Buxtehude to a kind of life. And it did this at least through 2013! ... You might download pedal.zip with (sadly obsolete) 8748 source, a kind-of schematic, and an antique charm — but it’d be far wiser to google for “MIDI kit” and get an Arduino project or something....

Golden days at Burroughs, bracketed by visitor’s passes; the second ’82 pass would be for the standard post-employment consultant call-back.


home


Friday 11/17/17 9:00 am