Vintage Ohio Scientific Computers
This machine was near-and-dear to me as it was my first real computer, an Ohio Scientific Superboard II. In 1979 I got my machine, a 6502-based single-board computer with a whopping 8K of RAM and BASIC in ROM. The board was completely self-contained, requiring only a 5V, 3A power supply to run (I built my own using a 78H05 regulator).
History of OSI Systems
Ohio Scientific (OSI) started business in 1975 and through the late 1970's and early 1980's produced a series of 6502-based machines called the "Challenger" series.
Like contemporaries (including the Apple and the Commodore machines), OSI systems used the low-cost 6502 processor. Created as a low-cost response to Motorola's 6800 processor, and commercially available (in production quantities) in 1976, the 6502 could use all readily-available and inexpensive 6800 peripheral chips (as OSI did to save cost). The 6502 achieved low costs through a number of design features including the fabrication in NMOS technology and use of "zero-page" memory which allowed reduction of the number of on-chip registers to six. The 6502, in a design reminiscent of the PDP-8 processor, allows fast access to the first 256 bytes of RAM from most instructions (making the 6502 almost RISC-like). The next 256 bytes (0x100 through 0x1FF) are prewired as the stack. All 6502 systems, therefore, require at least 512 bytes of RAM located in the lowest memory page and unlike the contemporary Z-80 processor, programs cannot simply be located at address zero (the 6502 actually fetches a vector for the start program from the highest two bytes - a ROM must be located there).
The earliest catalog I could locate was the spring 1978 issue. That year, OSI offered several models based on a single-board CPU, the model 500 card. This card featured 8K BASIC-in-ROM, 4K of RAM on board, and a serial port interface. In the most basic offering, the C2-0 Model 500 Board ($298), the user was required to add a power supply and a serial terminal for a basic stand-alone system. The C-28K 500 Superkit ($398) consisted of the basic model 500 CPU board, again with 4K RAM and 8K BASIC-in-ROM, along with a 480 8-slot backplane and 440 video board (with 32 by 32 character display) allowing use with a video monitor instead of a terminal. It was an unpackaged, "open" system in which the user added a power supply and an external ASCII parallel keyboard for a complete system. Finally the C2-1 500-1 Terminal Add-On ($498) version was basically a simple model 500 CPU board in a case with power supply and standard EIA (RS-232) connectors intended as a "local" computer to run short programs locally.
FYI: the prices quoted are in US dollars from US catalogs. In 1980, the exchange rate for Canadian dollars was less than favourable at about 1.17 so later figures quoted, in Canadian dollars, will always seem higher.
As well as the systems based on a standalone CPU board, OSI offered more complete cassette-based Challenger-II systems. These early machines were housed in blue and black cases (unlike later machines housed in beige ad brown cases).
Offerings from the Spring 1978 catalog included:
- C2-8S Challenger II ($545)
A CPU board with 8K BASIC-in-ROM, 4K RAM, and a serial port in a large cabinet with power supply and an 8-slot backplane.
- C2-4P Challenger IIP ($598)
A complete system with a CPU with 4K RAM (a model 502 card), video board (the enhanced 540 board with a 32 by 64 character display) and cassette interface. Housed with a power supply and a 4-slot backplane (two slots occupied in the original unit) in a small case with integral keyboard on top of which the monitor usually sat. This is the Challenger 2 - 4P system outlined on this page.
- C2-8P Challenger II ($825)
Same as the above but with an 8-slot backplane (two slots occupied) and housed in a larger case allowing more expansion than the 4P system. Had a separate keyboard attached via ribbon cable. This is the Challenger 2 - 8P system housed in the large blue-and-black box outlined on this page.
The Challenger-II was also offered with various floppy drive options. All floppy-based systems were housed in two larger black-and-blue cases, one for the CPU with an 8-slot backplane and separate keyboard and a second case for the floppy drive(s) which had white fronts. Configurations included: A 16K RAM system with a single 8-inch drive (250K) and a serial port (C2-S1S) for $1990, A similar system except with a video card (C2-S1V) listed for $2490, and a 32K RAM system with a dual floppy drive (C2-S2S) for $3090. Note that many systems utilized serial terminals for user interface in the same manner as contemporary mainframe machines did ... many larger OSI systems were indeed designed to use terminals (the front of the 1978 catalog shows a Challenger II system with two eight inch floppy drives and a Hazeltine 1500 terminal in an office setting).
Finally, the Challenger-III system was also available in 1978 with a triple-CPU board (6502, 6800, and Z80) and a dual floppy drive for $3590. Options for the Challenger-III system included a 74 Megabyte hard drive for $6000 (drive only) - a hard drive was an almost unheard-of option in 1978 and something always associated with a large mainframe computer, not a "personal" machine. Having a Z80 processor, this system could run CP/M!
By 1979, OSI offered three types of systems including the new low-cost Challenger I, as well as Challenger II and III systems.
The new Challenger-I systems for 1979:
- Superboard II ($279)
Also called a model 600 board, and new for 1979, this was a complete entry-level system entirely on a single board with keyboard, 8K BASIC-in-ROM, video (24 by 24 characters displayed), and 4K RAM (expandable to 8K). The user needed to supply a 5V/3A power supply and a video monitor for a complete system which includes cassette interface on board.
- C1P 4K ($349)
A packaged version of the superboard (with 4K RAM) in a metal case with power supply.
- C1P MF ($1259)
The same as above but coupled with a 610 expansion board (with 12K RAM on the 610 board plus the 8K on the superboard for a system total of 20K), floppy controller (part of the 610 board), and a mini-floppy (5.25") drive in a second box connected via ribbon cable. Shipped with OS-65D 3.0 Operating system.
Updated Challenger-II systems for 1979:
- C2-4P ($599)
A cassette-based system housed in a small case with integral keyboard (usually with the monitor on top) and 4-slot backplane. Had 4K of memory and BASIC-in-ROM on the 502 CPU card and a video card leaving two slots free.
- C2-4P MF ($1533)
A mini-floppy version of the above again with a 4-slot backplane. Uses a model 505 CPU with integral floppy controller and hence had a separate RAM card with 20K of system RAM (as well as the usual video card). This system did not have BASIC-in-ROM on the CPU card (it was run from disk).
- C2-8P ($799)
Similar to the C2-4P, a cassette-based system housed in a larger case with separate keyboard and 8-slot backplane allowing more expansion. Had 4K of memory on the CPU card and a video card.
- C2-8P DF ($2597)
A dual eight-inch floppy system consisting of two boxes: a CPU box as above (but with 32K of RAM) and a separate box housing two eight-inch floppy drives.
As well as these systems, listed in the spring 1979 catalog, OSI also offered several Challenger-III systems with up to 48K RAM and several odd versions of the "regular" Challenger lines above including an inexpensive C1P system with a single-sided mini-floppy and 12K of RAM (running P-DOS for "Pico-DOS" since 12K is not enough RAM to run OS-65D) and a C2-4P MF system with colour video, sound, and AC remote control I/O from the factory.
In 1980 OSI changed both the look of their machines, adopting a beige-and-brown colour scheme and renamed their product line from the "C2-4P" to the "C4P" and "C2-8P" to "C8P": none of their computers carried the "Challenger-II" designation anymore (which, of course, created a great deal of confusion amongst owners). The C1P and C4P models had beige metal cases with oiled walnut wood sides.
Offerings were similar to those in the 1979 catalog including the Superboard, Challenger C1P and C1P MF models, Challenger C4P and C4P MF models, and Challenger C8P and C8P DF models. Some models featured more RAM from the factory including the C4P and C8P with 8K, and the C4P MF with 24K. The basic C1P MF model was still shipped with 12K RAM - expansion to 20K on the 610 board allowed use of the newest OS-65D version 3.1.
Not mentioned in their catalogs, but apparently available, were special "OEM" version with deep cases holding both eight-inch floppy drives as well as an 8-slot backplane in the rear.
There are two types of OSI systems on this page, the Superboard/Challenger 1P machine covered below and 500-series (Challenger 2) hardware, which used the OSI 48-line bus, covered further down on the page.
Series 600 Hardware (Challenger 1P / Superboard)
The Superboard II was designed to form a compact and simple single-board computer. Meant as a low-cost entry-level system, this complete computer featured on-board video, and BASIC in ROM for around $300. At the time (late 70's to early 80's) there were a limited number of choices available to hobbyists looking for a computer: there were several systems which were 'machine code only' (usually featuring a keypad and seven-segment displays), but the primary competition for the superboard was the Apple-II and Commodore PET systems, both introduced in 1977, which did everything (including running BASIC) but were particularly expensive at over $1000. Having BASIC-in-ROM was a great feature since it allowed a novice to learn programming without having to invest heavily in a system that featured floppy disks.
The Superboard itself was shipped, ungloriously, wrapped in aluminum foil. Manuals were photocopies. It cost about $400 CDN at the time (circa 1979, about $340 USD using the exchange rate at the time), with the upgrade for 4K more of 2114 SRAM costing an additional $100 or so (in 1979 ... the prices of RAM were quite high then). The advertisement above is circa 1981 (from Electronics Today magazine, April 1981) from the place I bought it from, Arkon Electronics on Queen St. in Toronto. The place later sold Apple and is now no longer there. Click on the small ad above to see the full ad which features pricing of OSI systems as well as other electronics.
Memory, as I said, was expensive at the time. Click Here to see an advertisement for RAM from Exceltronix in Toronto. The reason I had this Ad at all was that I purchased 8K of 2114 a year or so after I got the machine and built my own RAM expansion board (giving me a total of 16K). Two 2114 chips were required for 1K of RAM and so 16 chips were required for 8K of RAM.
Aside from the "bare board" Superboard, these units were also shipped as the packaged Challenger 1P - the identical board in a nice plastic case with a power supply - as pictured in this 1981 Ad from Popular Electronics aimed not at the hobbyist, but the 'serious' computer user.
The Superboard and has several notable elements of hardware design, some quite elegant for the time (remember: this was 1978 and so, for example, 2114 1K*4 RAM chips were standard, perhaps even somewhat advanced since a few years before this the 2102 1K*8 chip was used extensively). All of the comments here refer to the revision B board (circa 1978) but apply equally to newer revisions (however chip numbers will change).
The circuitry was quite simple by today's standards and most chips were 'normal'
74xx series TTL, except for the data bus buffers which were 8T28's (and difficult to obtain at that). The board contained the keyboard, CPU, ROM, RAM (up to 8K on board), a video
section for connection to a monitor or TV via a composite output or an additional RF modulator, and cassette I/O.
Expansion was provided via a 40-pin IC socket. A ribbon-cable jumper allowed this board to connect to a 610 expansion board which also allows connection to an OSI bus (rare, though, to expand a C1P system in this way). The 610 board featured RAM (up to 24K more) and a floppy-disk controller. In my case (i.e. since the expansion board probably cost as much as the original machine), I built my own expansion boards in which the OSI expansion connector was connected to several 44-pin card-edge sockets. I had built an I/O port board for the unit as well as a RAM expansion unit (for 16K of total RAM).
The entire board, like other OSI products, was fabricated on simple plated-through, double-sided printed-circuit board. Traces are fairly wide (by today's standards) making the board both servicable and easy to repair. You might also note several blank prototyping areas on the board allosing easy modifications as required.
Complete schematics for a Revision B (circa 1979) board and diagrams for the Ohio Scientific Model 600 Board:
- Pages 1 and 2 showing the CPU, buffers, and address decoding circuitry
- Pages 3 and 4 showing memory (RAM and ROM)
- Pages 5 and 6 showing memory (ROM) and the ACIA (serial port) used for the cassette
- Pages 7 and 8 showing cassette interface and video RAM circuitry
- Pages 9 and 10 showing clock circuitry and video character generator ROM
- Pages 11 and 12 showing keyboard and related circuitry
- Page 13 showing Keyboard and optional DAC components
- Chip Locations on the PCB
- Connections exteral hookup of the power supply, video, and cassette
- Memory Map detailing the placement of memory and peripherals in the 64K address space
A few pinouts and detailed photos ...
- Connector J2 photograph with pinout. Pin 7 connects to the tape recorder MIC, Pin 10 to the tape recorder EAR, and Pin 12 is composite video output. Pin 11 is usually unused. The two potentiometers in the photo are used for the tape system.
- RS-232 Option shown here installed. Signals are available on J3 beside the power leads. See schematic page 6 for the circuit.
- IO Connector to the 610 expander board (40 pin). The open 16-pin sockets are for 8T28 bidirectional buffers.
- ROMS All for BASIC Roms, the monitor Rom, and the ACIA beside the CPU - here on the left side of the photograph.
- Video RAM for black&white video. Open sockets are for an extra RAM and buffer chip for colour video. These are not shown on the schematic which is for an earlier revision B board (the photo is of a revision D board).
While my original board was a revision B (schematics above), the newer revision D boards - functionally similar to the C1P series II - were enhanced to include RAM for colour video and had an installed RS-232 port. These boards feature a connector (J3) for connection of a 4-pole, 3-position switch allowing connection of the on-board serial port to the cassette, a modem, or a printer. This connector must be installed in order for the cassette to operate. Other features of the rev D board include provisions for colour video and a delayed power-on reset where the BREAK key must be pressed for two seconds to effect a reset.
- J3 Wiring showing the switch required for the cassette, modem, and printer
- Sheet 1 of 5 showing the CPU and the Monitor ROM (including 2716 jumpers)
- Sheet 2 of 5 showing RAM and ROM wiring including 2716 jumpers
- Sheet 3 of 5 showing video clocking, RS232 drivers, and cassette circuitry
- Sheet 4 of 5 showing video circuitry
- Sheet 5 of 5 showing the keyboard
- Chip Placement for the rev D board
Let's now examine individual hardware elements in detail (with reference to the revision "B" board).
One of the best selling features of the Superboard was integrated video. The Superboard featured a 24 by 24 character display (yes, only 24 characters across) held in 1K memory mapped from $D000 to $D3FF. It was arranged in memory as 32*32 characters however not all are visible. From page 8 we can see the video RAM is selected via U55. Signal /WVE (Page 2) selects video RAM into 6502 memory map when A10&A11 are both low.
Essentially, video RAM is dual-ported between the video scan logic and the processor - in typical 6502 fashion, the RAM is connected to the processor only when clock phi-2 in high (i.e. when the processor has the ability to R/W the data bus).
The address decoder (Page 2, U23) Y6 output ($Dxxx with A12 on U20) selects video on U20. U20 output Y7 then selects video RAM for writing when A10 & A11 low, mapping the RAM to location $D000 to $D3FF. The RAM is mapped to the 6502 CPU only during phase-2 clock, where A0 to A9 on the RAM chips are mapped to 6502 CPU lines. Alternately, when not connected to the CPU, these RAM address lines are connected to clock lines C3 to C7 (five lines = 32 characters) and C11 to C15 (five lines = 32 scan lines on the monitor). Clock lines C8 to C10 selects the line (eight rows scan for each complete character) - these are actally connected to A0 to A2 of the character generator ROM to select the row of the character to use with row 0 the top row, and row 7 the bottom row.
Shift register U42 clocks eight pixels (dots) across from the pattern stored in the character generator at the rate of CLK (the crystal frequency of 3.93216MHz = the dot clock). The RAM location is then incremented (address lines C3-C7) and the next eight pixels are scanned across. 256 clock cycles later, lines C8-C10 increment to point the character generator to the next row. The same memory locations are scanned again and the process is repeated for eight rows completing one line of 32 characters. Address lines C11 to C15 then increment and the next line of characters is scanned. This repeats 32 times for 32 rows of characters.
One-shot U65 generates a horizontal sync pulse at the end of each line (C7, at 15.375KHz) and a vertical sync pulse at the end of each frame (C15, at 60.0 Hz).
Upon boot-up, a screen full of random characters appears (the random characters corresponding to the contents of RAM when first powered-up). When the BREAK key is pressed (on the latest revision of the Superboard this happens automatically), the screen clears and a boot prompt appears. The video section is essentially independent of the processor and even with no CPU chip installed should display a screen of random characters as seen here.
For simplicity, static RAM was used. At the time (circa 1978), dynamic RAM existed offering a significantly higher density per chip however DRAM, in those days, required three power supplies (+5, +12, and -5V or -9V) as well as requiring periodic refreshing of memory cells - implementing DRAM on a simple computer such as this would require the addition of significant amount of hardware (although OSI did offer a DRAM board, the 530, for larger bus-based C2 systems).
RAM is simple: 74LS138 decoder U23 (Page 2) decodes the 64K address region into 8K blocks, the lowest of those blocks being the on-board RAM. Further decoding is performed by U22 into 1K blocks for each pair of 2114 RAM chips on Page 3.
The four BASIC ROMs are mapped to $A000 through $BFFF in four 2K blocks via 74LS139 1-of-4 decoder U17.
Monitor (SYNMON) ROM must be mapped to the highest 2K of memory ($F800 through $FFFF) since it contains the reset and interrupt vectors. This is accomplished by combining the highest 8K block selected by U23 with A12 via U15 and A11 via U19.
The Polled keyboard is simply a latch and input port selected via U20 (mapped to $DF00 but in reality mapped to a 1K memory block for simplicity).
The ACIA is mapped to $F000 (and $F001) via U17 (likely used since it is the second half of the decoder already used for the BASIC ROMs).
Normally, the ACIA is used for cassette I/O via the Frequency-shift keyer (FSK) transmitter and receiver on page 7. Baud rate generation is provided by U57 which is 300 baud for the standard cassette port - it may be increased up to 9600 baud by changing the input on pin 2 to a higher clock frequency in the chain of clock dividers (U30/U59). For example, connecting pin 2 to the CLK clock line yields 9600 baud operation (useful when bypassing the cassette altogether and loading programs from a PC).
Using 2716 ROMs
A popular modification, but one I never did to my machine, was to upgrade the SYN600 monitor PROM to a third-party one such as CEGMON. CEGMON gave the user the ability to backspace, for example, while the original monitor lacked this feature. Today, a number of collectors must use 2716 ROMs to replace missing ones on the board (I have one unit like that). When using 2716 ROMs instead of the factory masked 2316 ROMs one must jumper the board as follows:
- Character Generator ROM: Cut traces currently between pin 18 and +5V and between pin 20 and +5V. Run a wire from each pin (18 and 20) to ground (pin 12 on the ROM).
- Monitor ROM: Immediately below the ROM is a jumper - Follow the trace from pin 20 to this jumper. Cut the trace and jumper as shown in the photo below (cut the trace shown, add the trace shown in yellow).
- BASIC ROMs: Follow pin 20 from each ROM and cut the traces before they reach the output of the 74LS04 inverters (U16). Run wires from pin 20 of each ROM directly to the outputs from the 74LS138 decoder (U73) - pins 12-15 as shown in the photo. While the original masked ROMs use active-high selects, 2716 EPROMs require active-low select lines.
One contact on the internet suggested the use of MP3 files to store old tape images and load them back into the machine but a better solution is to use the RS-232 port to load and store BASIC programs to a PC running a terminal emulator package such as Procomm or Hyperterminal. This is facilitated by the fact that typing 'LOAD' or 'SAVE' on the machine simply sends data going to the video display to the ACIA and accepts data arriving at the ACIA as if it were typed on the keyboard - this is one of the stranger features of an OSI C1P system an reminiscent of old PDP-8 teletype-based systems. For a PDP-8 running FOCAL, for example, the user 'saves' programs by listing them to the teletype but first setting the paper-tape punch ON so that received characters are punched to the tape. Similarly, the PDP-8 could not 'tell' whether a user was entering a program manually or via a paper-tape being read by the teletype so simply loading a paper-tape into the teletype and setting the punch to 'read' mode caused characters to be sent to the PDP-8 and the program to be entered.
So, typing 'SAVE' on an OSI C1P system simply routed all text destined for the screen to the serial port as well (ditto for the 'LOAD' command). In that respect, simply replacing the FSK demodulator for the cassette tape system with an RS-232 level converter allows the Superboard to load programs from that port. Note that earlier 500-series systems often used an RS-232 serial connection instead of a video display and keyboard - video display was an added board and an added option.
Revision D boards often come with the RS-232 option already installed, all that is required is a switch on J3 allowing the user to select cassette, RS-232, or modem operation. Revision B boards have wiring on the PC board for the RS-232 level converters however these must be installed by the user. A series of jumpers configures the input to the ACIA to come from the cassette tape's demodulator circuitry or from the RS-232 level converter (useful for connecting, say, a modem or for the output line, a serial printer which I did on my original system). In general, to use the serial port on a revision D board one needs to jumper pins 1 to 9 (to ground the /CTS input allowing the ACIA to transmit), and jumper pins 8 to 10 (for 300 baud operation) or pins 8 to 12 (for 1200 baud operation). Pin 2 is the transmit data output.
The RS-232 interface (for a revision 'B' board) requires the addition of two transistors as shown in the schematic - Q1 is a 2N3906 PNP and Q2 a 2N3904 NPN. As well, several resistors and a diode are required to be installed. Follow the circuit diagram, the photograph, and the top-down placement diagram for details. Note the unusual position of the transistors - leads must be bent in an unusual manner (with the base pin out front) in order to be mounted on the board. Otherwise, assembly is not critical.
Circuit Details ...
Aside from addition of the circuit components, one jumper (a PC board trace) must be cut. The diagrams show two 'W10' jumpers. One, only two wires, is broken to allow full-spec'd RS-232 voltage levels by applying -5 volts to pin 7 of J3. This is normally not required, however, so this jumper may be left alone. In this case, non-standard RS-232 levels of 0 and 5V are used instead of the true bipolar signal - so long as the RS-232 cable is short, most PC's handle the signal properly.
The actual 'W10' jumper which must be cut is located on the bottom side of the board and detailed in the photograph. With this jumper removed, even cassette operation requires a jumper on J3.
Connector J3 Wiring (for Cassette Tape operation):
- Jumper J3 Pin 5 to J3 Pin 6
- Jumper J3 Pin 4 to J3 Pin 6
- J3 Pin 2 (RS-232 Out) to DB-9 Pin 2 (Transmit to PC)
- J3 Pin 3 (RS-232 In) to DB-9 Pin 3 (Receive from PC)
- Board Ground to DB-9 Pin 5 (Ground)
After modification, the system should be tested to ensure the cassette operates then the jumper switched and the RS-232 connection tested. On the PC, run a terminal emulator such as Procomm or Hyperterminal and set it for 300,N,8,1 (300 baud being the normal baud rate of the tape system - this can be changed later). Type 'SAVE' on the OSI. Now, anything typed on the OSI keyboard should be echoed to the PC via the serial port, including program listings (this is, of course, how programs are saved to the PC, by capturing incoming data on the terminal emulator program to a text file).
To load a program from the PC into the OSI, type 'LOAD' on the OSI keyboard. When something is typed on the PC, it will now be entered into the OSI as if it were typed locally. In this manner program files stored in a text file can be uploaded to the OSI. This method will be considerably more reliable than the use of cassette tapes (or MP3 audio files) - even the original tape system had a high error rate and unless everything was just right, loaded programs frequently had an error or two which required the user to manually correct the offending program line - programs ALWAYS came with a full listing allowing the user to correct minor errors which occurred during loading from tape.
Software and System OperationUpon boot-up, the user was presented with a prompt for 'D/C/W/M ?' which allowed you to boot from disk, cold boot, warm boot (and preserve memory contents), or enter the monitor to debug machine-code programs. Few systems had disk drives since floppy disk drives alone sold for $650.00 in 1980, let alone the controller! Don't believe me ... look at one of the advertisements above. If an upgraded third-party monitor called "CEGMON" was installed, a similar boot prompt appears on the top of the screen.
Pressing RETURN to the "Memory Size?" and "Terminal Width?" prompts completes the boot process directly to BASIC which resides on the board in four 2K ROMs (so BASIC was 8K in length). The amount of actual memory is displayed as well. A system with 8K installed shows 7423 bytes since come is required for zero-page, some for the 6502's stack, and some for scratch variables for BASIC. A system with 20K displays 19711 bytes - boot from a Disk, for example HEXDOS, will lower the amount of available memory.
Perhaps the most interesting section of circuitry on the system was the video display which used a meagre 1K of RAM. Video circuitry in the OSI switched the address and data lines of the video RAM from the 6502's bus to an internal clock generator composed of binary counters. When a character was retrieved from the video RAM it was converted to a dot pattern by the character generator ROM (U41 in the schematics) which was output as an analog signal representing video levels (black or white). Although the video RAM could store 1024 characters and the actual video RAM was mapped as 32 lines of 32 characters, the actual display was 24 characters across by 24 lines - peripheral characters were not visible and used as a 'guard band' to prevent off-screen characters. Later revisions of the OSI board included a socket for a third 2114 video RAM which stored colour information. Further add-on boards (available from third-party manufacturers) even allowed bitmapped graphics with resolutions up to 256 by 256 pixels! (This, incidentally, would require at least 8K of video RAM for a monochrome display where each pixel could only be 'on' or 'off' ... more than most OSI systems were shipped with). RAM, in those days, was a precious commodity and were the most expensive chips in the machine.
And as a huge bonus the character generator supported ASCII characters as well as a large number of graphics characters for games. Character zero, for example, was a race-car so where you'd normally drop a character 0x41 into a video memory location to make an "A" appear there (e.g. "POKE 53381,65" would make an "A" appear in the upper left corner), a character zero could cause a race-car to appear. Similarly, characters 248 through 255 depicted a tank in one of eight possible orientations 45-degrees apart, as used in the "tank for two" game (below, left). Some gaming graphics were large and required two side-by-side characters including contemporary Star-Wars fighters, Starship Enterprises (Character codes 9 and 10), and ships and submarines. The machine lacked enough memory to allow true bitmapped pixels.
Software was supplied on cassette tape which loaded at 300 baud. You could actually
watch the data as it was loaded into the machine which took an average of 3-5 minutes
One predominant software supplier for OSI systems was 'Aardvark Services'.
Aardvark's ad from Micro magazine, August 1981 details the myriad of software available for an OSI system at the time, most of it on cassette tape.
Anyone heard of them since?
Early Eighties Computer Hardware:
The early eighties were a time of homebrew computers. Unlike today, where even an amateur can buy a peripheral or upgrade and install it, to upgrade a computer in the early eighties required most users to become quite fluent in hardware (and to own a soldering iron). It was common for users to make extensive modifications to their machines as illustrated below.
Micro magazine was dedicated to the 6502 and 6809 crowd. Featured articles in this issue
(Aug 1981) included the making of a coprocessor board to do complex mathematics (yes,
a real Intel math coprocessor attached to an OSI CIIP!),
adding I/O to the OSI system, and numerous software articles most using machine code.
The magazine covered 6502 systems like the Apple, OSI, and Rockwell AIM-65.
Surprisingly, the magazine was not Apple-centric (as this was the most popular 6502
system at the time) - likely because it was a bit of a 'hardware hacker' magazine.
OVERCLOCKING was popular even with machines such as these. One of the modifications I
made to my original machine was a 'GT' option which increased the clock frequency from
1MHz to 2MHz. I found the original documentation on this and scanned it for your
"GT MODIFICATION FOR 600 BOARD
The CIP or Superboard II as delivered by OSI has a primary clock
frequency of 3.932l60MHZ. This frequency is a multiple of 60 (the
video vertical sync frequency) and also 15,360 (the video horizontal
sync frequency). One cycle of this primary frequency corresponds
to a single dot, or 1/256th of a horizontal scan line on the monitor.
The clock signal fed to pin 37 of the 6502 is the primary frequency
divided by 4, or .98304MHZ. This is within 2% of the nominal lMHZ
which most vendors advertise, for 6502 based systems (KIM, SYM, AIM, APPLE,
Fortunately for us, a clock frequency of 1.96608 MHZ (approx 2 MHZ)
is available in a very convenient spot. With a short length (1" or so)
of small diameter insulated wire, a sharp instrument to cut a trace, and
two simple soldered connections, you too, can be running your 600 Board
at twice normal speed."
The instruction sheet goes on to describe in detail how to connect the clock,
then it warns you as follows:
"Both the basic proms and the monitor prom have fast enough access
to run at the 2MHZ rate. There could be a problem with 2114
memory chips, especially on the CIP because of the enlosure. Chips get a
little warmer when you box them up and don t circulate the air. I have one
chip in my system that gets flaky after about an hour. I'll either replace
it or put in a fan"
A diagram showing how the modification was made to the board (original)
... Some things just haven't changes in over 20 years: computer types are
ALWAYS trying to push their chips past the limit!
Floppy Disk Drives
Ohio Scientific computers employed unique floppy drives which provided separated data and clock signals. In the beginning (1976), OSI used eight-inch drives made by GSI with a 470 controller board which was originally designed to use such a drive. Later eight-inch drives shipped by OSI, made by Siemens and Shugart, also featured data separators on the actual drive . Such drives use pin 30 as clock (separated) and pin 34 as data whereas 'industry standard' drives on many other machines feature a single, combined, output on pin 30 only. These drives also used AC drive motors which ran continually - no motor control was required.
When OSI went from an eight-inch to a 5.25" drive for their smaller machines they chose to ship drives made by Micro Peripherals (MPI) which also have internal data separators. Like their eight-inch predecessors drive spindles also ran continually and OSI made no provision for drive motor control. Note, though, that not all MPI drives feature an internal data separator. Model 52 drives (which are double-sided), for example, feature a connector on the controller board (J5) which is not normally populated - except for an OSI drive where J5 connects to a data separator daughter board. Where the data separator card is not present, pin 3 of J5 should be shorted to pin 5 so that read data appears on pin 30 of the drive connector (and so an external data separator circuit could be used).
Modern drives, which provide combined clock and data on pin 30 of the 34-pin card-edge connector, require an external data separator circuit. One interesting article I've found regarding the interfacing of a 610 board to an actual drive is from the Aardvark Journal, Feb. 1982 in an article entitled "OSI AND THE SHUGART SA400 BY STANLEY WINDES" which described the changes required to add a standard Shugart SA-400 floppy drive to an OSI system.
The author writes: "The first thing that became apparent upon examining the OSI hardware was that the Data Separator was not on the 610 Board and it was not part of the SA400 electronics either. After much searching and head scratching I concluded that since the OSI system never misses inserting the clock pulse before each data pulse that is written on the disk, the Data Separator would be easy and simple to design. Some of the disk writing systems withhold some of the clock pulses written on the disk. This makes the data separator much more difficult. The data separator I came up with, and found to work very well, is shown in figure 3."
I had a disk-drive working with two types of controllers (although problems have developed - read on). The first controller, a third-party disk controller built from plans featured in Elektor magazine in the early 1980s, is connected to an OSI 600 board with 12K of 2114 RAM (4K of which is piggybacked on top of the original 8K chips on the motherboard itself). The drive is an original MPI model-52 5.25" drive, but one without the internal data separator (so any drive like a Shugart SA-400 could theoretically be used here). The controller is almost fully compatible with the OSI 470, 505, and 610 controllers (although the 600 board has been modified to use the controller) and the system was booting HEXDOS (which, when loaded onto the 12K machine shows 8K of free RAM avalable). Like the original OSI floppy system the motor runs continually and it was necessary to jumper the drive to be selected continually.
HEXDOS is a simpler operating system than OSI's standard OS-65D - it is only one track long (occupying only track zero) and uses OSI's Monitor and Basic ROMs to save memory (i.e. it runs OSI's on-board 6-digit BASIC). A 'normal' OSI configuration using a floppy disk was a 24K machine (the extra memory on a 610 expander board) running OS-65D. OS-65D was a complete O/S having it's own BASIC so that BASIC-in-ROM was not required (larger disk-based OSI systems like the C4P-MF often had only a boot PROM installed).
OSI also offered "PicoDOS" which was a smaller version of OS-65D specifically for the C1P which, like HEXDOS, used the internal BASIC on the board adding only "load" and "save" commands which worked on disk files. Unfortunately, PicoDOS could only store eight programs on a disk and all were accessed as a number (1 through 8) so a user would type "LOAD 1" to load the first program on the disk. HEXDOS was far more advanced allowing the use of named files (LOAD "FORMAT") and so it appears it was far more popular with C1P hobbyist users. HEXDOS, in general, appears to have been the prime choice for C1P users while those with larger systems (e.g. C4P machines with 64 column video) primarily used OS-65D.
It was discovered (see the diagnostics below), that the MPI disk drive had become 'flaky' and booted only once every twenty-five tries. On many attempts the drive appears to boot, displays reduced memory (the O/S consuming some 3.5K), then 'hangs'. It was originally thought that the controller was at fault but the actual drive was the issue.
Thinking the controller was at fault, the next logical step was to get the system running with a 610 controller. An external data separator was built according to the article above. Input to the separator is from pin 30 of the disk drive and output connects to pins 10 and 11 on J2 of the 610 board. The controller was calibrated by adjusting the potentiometer to give a 6μs pulse (active high) from the Q output of the 74121 (pin 1). A cable was built as follows which connects the original OSI 610 board (connector J3 - pin 24 is the outermost pin near the edge of the board) to the floppy-disk drive 34-pin connector as follows:
|OSI-610 J3 Pin||Function||FDD Connector Pin|
|3||HSelect Drive 1||10|
|10||Receive Clock||From Data Separator|
|11||Receive Data||From Data Separator|
|12||Ground||All ODD Pins|
|13||Ground||All ODD Pins|
|18||Select Drive 2||12|
The rear of the OSI 610 board, seen here with a SA400 floppy drive. The multicoloured ribbon cable connects the 34-pin connector on the rear of the floppy drive with the connector protruding from the rear of the 610 board.
Also visible in this shot is the data separator in the lower left. This is the simple two-chip circuit described in the article above built on a small piece of perf board.
The system originally worked well with the MPI-52 drive running HEXDOS. Since the 610 has 12K of RAM on it alone, and the 600 board 8K, the system has 20K and so should be able to boot OS-65D DOS. Once again, though, the drive itself is problematic and so an attempt was made to use a Shugart SA-400L drive with this controller. The SA-400 drive boots HEXDOS reliably, however it cannot write to the disk! Time for diagnostics ...
Diagnostics of the Floppy Disk System
Floppy disks use FM encoding in which a clock pulse consists of a single high-going 400nS pulse every 8μS, an a data bit is encoded as two pulses spaced 4μS apart. This can be seen in the timing diagrams that follows.
First, the timing of the one-shots on the 610 board was adjusted as per the procedure outlined in the 610 service documentation from the Sam's PhotoFact (which is available from Dave's OSI repository, along with the original OSI schematics for the 610 board) as follows:
- With the 610 board disconnected from the drive, the pulse at pin 13 of the U68 one-shot is adjusted for a width of 400nS using R18. This is the TxClock signal now transformed into a clock stream.
- Similarly, pin 12 of the same one-shot is adjusted for a negative-going width of 400nS using R9. This adjusts the Tx Clock settings, now for the Read Clock:
- Jumpering J3 pin 9 (Write Data) to J3 pin 10 (Receive Clock), adjust R10 so a 1μS pulse appears at pin 5 of U70 (which produces the clock signal fed to the UART).
- Jumpering J3 pin 9 (Write Data) to J3 pin 11 (Receive Data), adjust R19 so a 6μS low-going pulse appears at pin 4 of U70 (which produces the data signal fed to the UART).
Use of floppy disks with an OSI machine require the addition of a data separator which extracts separate data and clock streams from the incoming data stream from the floppy disk drive. The simple data separator used here consists of a a one-shot and several gates and the operation is illustrated by a analyzer capture of incoming and outgoing signals. The top trace (channel 1) represents data coming from the disk drive and channel 2 the extracted clock stream. For every data bit (whether a logic 0 or a logic 1), a clock pulse (channel 2) is generated at a constant clock rate of 125KHz. Channel 4 shows the low-going pulse from the data separator's one-shot set for approximately 5.2μS. Each blue line in the capture represents 1μS.
The floppy disk system can boot reliably and reads disks fine (i.e. it can load programs on subsequent tracks on the disk so it is reading beyond track 0) however the write function does not currently work, so a logic analyzer was used to verify the timing and operation of the write logic of the 610 board as follows:
- Channel 1 is pin 8 of the U67 7400 gate which consists of the addition of the clock pulses (channel 2) with data signals from the UART (channel 3). It is the exact format specified for floppy drive write data but is inverted.
- Channel 2 is pin 13 of the U67 7400 gate which is a continuous clock stream consisting of 400nS pulses spaced 8uS apart. This clock stream is generated from the master 125KHz clock on the 610 board whoch triggers a 74123 one-shot (U68) to produce 400ns wide pulses. The pulse width is adjusted by R18.
- Channel 3 is the data stream from the UART at pin 8 of the U69 7404 inverter for data. This verifies the operation of the UART and the inverter.
- Channel 4 is the final data stream to the disk drive, which is simply the inverse of channel 1 (inverted by one sixth of U69) and is used to ensure the output drivers on the 610 board are all functioning.
The timing of the signals conforms with that outlined in the Shugart SA400 manual - it was verified by the logic analyzer that the write enable goes low as the index goes from low-to-high with the data line consting of nothing but zero's (clocks, 8μs apart) until at 1.2ms after the index transition data actually appears on the write data line (a logic 1 appears, followed by a zero, and several more 1's). When a known good disk is read with the analyzer on the floppy disk lines, a similar pattern appears (i.e. blank clocks on the read data line until 1.2ms after the index pulse goes high) but when a disk formatted on this drive is read in a similar manner, only clocks appear on the read data line. Finally, it seems that the drive is at fault here.
Observing the operation of the actual drive (with the control PCB moved to the side), one can see that it steps erratically. This may well explain the situation since HEXDOS resides on one track so a drive which cannot step properly would still load! I recall reading in an old PEEK journal that HEXDOS can be set for any step rate however the instructions were for HEXDOS 2.3, not my 4.0 version.
Disassembling HEXDOS in memory (remember, it sits on track zero and so loads even if the drive cannot step properly), one finds the stepping routines as follows (with my comments added):
04D2 48 PHA 04D3 9006 BCC $04DB //If Carry set, step out 04D5 E6D8 INC $D8 //Increment current track # counter 04D7 A9FB LDA #$FB //Step out = PB3 low 04D9 D004 BNE $04DF 04DB C6D8 DEC $D8 //Decrement current track # counter 04DD A9FF LDA #$FF //Step in = PB3 high 04DF 8D02C0 STA $C002 //Output to PIA 04E2 29F7 AND #$F7 //Isolate bit for PB3 (J3 pin5) 04E4 8D02C0 STA $C002 04E7 0908 ORA #$08 04E9 8D02C0 STA $C002 04EC A203 LDX #$03 //Default step rate - this is the problem 04EE 2091FC JSR $FC91 //Time delay (1.25mS times X)
So, by changing the variable at location $04ED from $03 (5mS step) to $25 (50ms step), the drive can step properly. This is done as follows:
- Boot a copy of HEXDOS 4.0
- Hit BREAK and enter Machine code mode (M)
- Enter address "04ED", and the data field should display as "03" (the default delay)
- Press "/" to go to data mode, and enter "25"
- Hit Break again and warm start (W)
- Load FORMAT from the HEXDOS disk (and it will actually step to that track properly now) and format a new disk
Oh yes, one final comment of the use of floppy drives with an OSI: A reader from Florida had a problem recently in using a newer model 52 MPI drive in place of an older model 51. Apparently the 51 has a daughterboard (the data separator) but the 52 does not. He writes the following on changes that must be made to the model 52 drive:
1. Daughterboard connector
2. pin 5 and 9 of the 74LS123
CUT the connection between pin 1 (NAND ) and the 74LS123."
When I examined a old model 51 board I found that trace is cut (right at pin 1 of the NAND, bottom of the board), whereas on the 52 it is intact.
Hopefully that helps someone else trying to make their floppy system work!
Using the HEXDOS Operating System
HEXDOS is a simple operating system residing on a single track. It was written by Steven Hendrix in the early 1980's and was very popular with Superboard users primarily because of the low cost both of the O/S and of the hardware - HEXDOS could run well on a system with only 12K of memory. Unlike OS-65, it does not offer BASIC but rather uses the BASIC residing on the Superboard ROMs - it simply adds LOAD and SAVE functionality. When booted (using the "D" option), HexDOS loads then returns immediately to BASIC - the only indication it has loaded being the display of 2.3K fewer bytes free than a cold boot (i.e. 17407 bytes free on a 20K system, for version 4.0 at least). To get a directory of a disk, the "LOAD/" command is used which loads the directory into memory as a program file. Typing LIST displays the actual contents of the disk as seen to the right.
HexDOS supports named files so a user can type LOAD "FORMAT" to load that program . Like contemporary operating systems of the late 70's, few functions were internal to the operating system and basic functions such as formatting a disk or deleting a file required the user to load a program to accomplish this.
Internals of the HEXDOS Operating System
It is instructive to examine precisely how HEXDOS works by looking at both the command programs (such as FORMAT) and the disk format itself. We begin by examining the essentials of the FORMAT program, written in BASIC, since this program not only formats tracks but also copies the O/S to the disk using O/S calls. For brevity, only essential code is presented here (not, for example, the required "Are You Sure?" code).
This code generates then writes a blank directory to track one 160 DATA0,16,0,24,1,2,0,255 //The data file header region is filled here, 568=char pointer 170 FORI=566TO573:READT:POKEI,T:NEXT 180 REM FILE #4 IS NOW DIRECTORY 190 DATA0,11,1,0,3 //This is actually the first four bytes of the track 1 directory 200 FORI=0TO4:READT:PRINT#4,CHR$(T);:NEXT 210 PRINT#4,A$ //Date and time header is added to the directory 220 PRINT#4,MID$("JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC",3*M-2,3); 230 PRINT#4,D;Y 235 P=PEEK(566)+256*PEEK(567):T=PEEK(568)-PEEK(566)+2:POKEP,T //P=4096, and T=21 by inspection here 236 PRINT#4,CHR$(0);CHR$(T+6); 240 DATA11,2,0,165,0,0,0 250 FORI=0TO6:READT:PRINT#4,CHR$(T);:NEXT 260 SAVE*4 //Write buffer to disk (device #4) This code writes blank tracks 2 through 39 280 B=PEEK(125)+256*PEEK(126)+10 //B is a pointer to the first array, by inspection B=3698 290 DIMA(525) //Empty array - will fill the track with zeroes 300 FORI=2TO39:SAVE#I,B:NEXT This code writes the O/S to track zero from memory 310 POKE2818,0:SAVE#0,768:POKE2818,11 //2818 is the first byte of the FORMAT program - made invisible here //then the O/S is copied from memory to track zero
Although we are not privy to the exact format of the disk header, it is observed that the number at location 568, initialized to 1, increments after each character is printed to device #4. After line 200, for example, it has a value of 5. On line 235, T is found to be 21, although the exact function of the POKE in that line is unknown.
The actual format as written to the disk was investigated by examining the data read directly from a working disk. Using the HEXDOS command "LOAD #n,9000" to load 2048 bytes from track "n" to (in this example) location 9000, the memory was then interrogated to see the exact format of bytes on the disk. This was done for several tracks including zero (where the O/S resides) and one (where the directory resides).
Following the format expected by the OSI boot ROM, track zero is special in that it begins immediately with the load address (high, low address) followed by the actual O/S code as follows (with all numbers in decimal since they were dumped using a BASIC program using PEEK and PRINT statements):
03, 00, 09, 32, 182, 03, 21 ...
The first two bytes specify the address to load HEXDOS into memory as $0300. A total of 2K is loaded so the space $0300 through $0AFF holds the O/S. The third byte, "09", is the number of pages - one would expect (from the OS-65D convention) that this be eight (i.e. eight pages of 256 bytes each for 2K total per track) however a nine was actually read from a working disk - the reason why is a mystery.
The vast majority of the FORMAT program above is hence devoted to forming a directory on track 1 which is then updated by HEXDOS as program files are written to the disk. A working directory (from a disk with several programs on it) was read as follows:
87, 01, 27, 11, 01, 00, 03, 72, 69, 88, 68, 79, 83, 13 ...
As expected, the first two bytes are the sync character ($57) and the track number (the thirs number is once again a mystery). The disk name is seen in the data as "HEXDOS ...". Inspection of that track further reveals directory entries as follows:
... 11, 02, 00, 70, 79, 82, 77, 65, 84 ...
Which spells "FORMAT" which begins on track 2. The actual files on the directory were as follows:
2843 22597 DOS FEB 20 5 2 FORMAT 3 DELETE 4 CREATE 5 DISASSEMBLER 7 REVERSI 9 *
Further tracks contains BASIC programs in "core image" format (i.e. tokenized and as it appears in memory) such as track two which contains the actual BASIC "FORMAT" program:
87, 02, 33, 11, 10, 00, 142, 32, 68, 73, 83, ...
Again, the sync character and track number, (and a mysterious third number), followed by "11" to identify the program as a BASIC program, the BASIC token for the line number (two bytes, in binary, "0010") followed by the BASIC token for a REM statement (142), and the actual text of the remark "DIS ..." since the first line of the program was "10 REM DISK FORMATTER FOR HEXDOS".
Track three contains a program called DELETE for which the first line is "10 FILE DELETE ..." as seen in the following dump of track three:
87, 03, 31, 11, 10, 00, 142, 32, 70, 73, 76, 69 ...
All tracks follow a similar pattern.
My Original C1P System
My superboard was originally used as a single, open board for which I built an external memory board and I/O interface on 44-pin card edge boards. The memory board features 8K of 2114 RAM chips stacked together giving the system a total of 16K. Later, Dad built a wooden box for the system (which I used for some time) and finally I built the system into a PDP-8/A case as pictured to the left. The OSI 48-pin bus was connected to the PDP-8 backframe and I built cards to suit.
In order to fit into the case the keyboard was separated from the single board - it was connected via a large cable (I literally cut the printed-circuit board with a jigsaw). I/O and memory cards were then built which fit into the backframe. The cards pictured here include two parallel I/O interfaces, a sound/voice card featuring an 'SN' chip, and a 24K memory card using newer 2K-by-8 memory chips.
OSI 500-series (Challenger II) Hardware
Prior to (and along with) building the Challenger 1P / Superboard machine, OSI produced several models of computer in the form of multiple boards which plug into a bus. The Challenger 2 models consisted of various configurations from a single board (using a serial port to communicate with a terminal and with on-board RAM) to a system featuring separate cards for the CPU, RAM, video, and floppy-disk interface. OSI went even further to produce a Challenger 3 series which featured three CPUs (6502, 6800, and Z-80) and even a model with a Winchester (hard) drive: a rarity in any personal computer system in the late 1970's.
There is also a confusing bit of nomenclature here as OSI often labelled their Challenger 2 systems as "Challenger 4P" and "Challenger 8P" when, in fact, they were really simply "Challenger 2 - 4P" or "- 8P" ... this was evident when one looked at the front of a box branded "Challenger 8P" to find the model number "C2-8P". So, you'll often see people refer to an "8P" but really, it's a Challenger 2 - 8P".
This 1978 Ad from Popular Electronics is an early advertisement for 500 series systems including the 500 single-board and C2 systems based on the model 500 CPU board coupled with a video card. Pricing is in $US but at the time the exchange rate for $CDN to $US was almost 1:1 anyway.
Challenger 2 - 4P
The smallest Challenger 2 system is the 4P, circa 1977. This system is composed of separate boards including a 502 CPU board, a 540 video card, and a keyboard all mounted in a thin case. With a newer graphics card than older systems, featuring a whopping 2K of video RAM, a 64-by-32 character display was supported. The system featured a four-slot backplane (hence the "4P" designation) of which only two cards were installed in the basic (cassette-based) system allowing further expansion with RAM and floppy-controller cards. The "2P" label identifies this as an older unit (originally branded "2P-4", later "4P").
The system was twice the cost of the superboard but featured three-times the video capability and used the OSI standard 48-line bus allowing easy expansion via plug-in cards. You'll note the 502 CPU card, shown here as the top card in the backplane, features five ROMS (BASIC as well as the monitor, just like the superboard) and 8K of RAM in the form of sixteen 2114 chips. The CPU board also contains a 6850 ACIA used for the cassette interface. The later superboard, then, is really just a 502 board with an integral video section as well as integral keyboard (with a significant cost reduction in the process).
I had received this system in late 2008. It featured the usual bugs expected with an older machine (including power supply issues in the form of failed electrolytic capacitors) as well as a failure in one (or more) of the upper 4K of RAM chips. The on-board RAM was clearly expanded after production as the upper 4K are manufactured by a different company than the lower 4K (which was presumably installed by OSI). Removing the upper 4K of RAM, the system boots! The user is presented with the customary "C/W/M ?" boot prompt and, upon booting to on-board BASIC, a 64-character display appears ... perhaps the best enhancement of such a system over the Superboard. A simple POKE command allows the user to switch between the default 64-character wide display and a 32-character wide mode ... presumably for software compatibility with many games.
You'll note the lack of a disk boot "D" option on start-up. The 502 CPU board had on-card BASIC ROMs as well as 8K of RAM but lacked a floppy controller - it was intended as a cassette-based system only. Upgrades to include a floppy disk interface were, of course, possible by adding a 470 floppy controller card and more RAM in the form of another card (as well, the monitor ROM must be changed - most owners at this stage would have upgraded to CEGMON anyway which gave the Disk-boot option). This would have populated all four slots. As well as the cassette-based 4P configuration above, OSI shipped a system pre-configured for floppy disk in the form of the "4PMF" version for "mini-floppy". That version used a 505 CPU which lacks on-card RAM but features a disk controller on the CPU card. Such a system usually consisted of a 505 CPU, 527 memory board, and 540 video card leaving one slot remaining for expansion.
Challenger 2 - 8P
The next largest system is the Ohio Scientific C2-8P as pictured to the left. The one pictured to the right is how a full-blown system would have appeared (including eight inch disk drives). This older machine (several years before the Superboard II above), packaged in a big blue box, features separate boards for each function like the 4P above however includes a larger expansion box and an 8-slot backplane allowing greater expansion. The 8P was intended as a machine for research, educational, or small business use. I have not tested this unit yet, but intend to work on it as a 'long term' restoration project.
This Challenger-2 box consists of the following:
- 580 Backframe (8 slot)
- 500 CPU (with 32 2102 SRAM chips for a total of 4K of memory on the CPU board) - circa 1977.
- 540 Video Card (with parallel keyboard connector)
- 550 Serial Card (Sixteen 6850 serial ports of which 4 are currently installed)
- 'Micro Interface' memory (24 6116's = 48K SRAM) and printer board - circa 1981
The model 500 CPU card is seen here plugged into the backplane. The CPU is the large chip near the top left and the empty sockets are for optional ROMs (for languages such as BASIC). Also visible are the thirty-two 2102 memory chips at the bottom of the board - totalling a whopping 4K! The 500 CPU board was originally used in older "Challenger 2" and superkit systems and was replaced, in future 8P systems, with the 505 CPU ... this is an odd system using an older CPU card but with an updated memory card using the newest (in 1981) 2K memory chips! As well as the cards in this machine I also have a few spare cards for the unit including a 505 CPU card plus one populated and one unpopulated model 470 floppy controller card (with parallel printer port).
It is interesting to note that the system includes a sixteen port serial card (useful for multi-user systems) and a third-party, non-OSI built memory board.
More Photos of the C2P System ...
- A TOP VIEW of the C2P System
- REAR VIEW of the C2P System showing the RS-232 Connectors. The reason for a larger expansion case becomes obvious when considering the "rats nest" of I/O wiring accompanying expansion boards installed.
Challenger 2P - OEM
A unique machine, this Challenger 2 system is housed in a single, elongated (deep) box - physically it resembles the 8P (below) however the box is twice as deep. It features two 8" floppy drives and has no video card: only a serial port is provided for connection to a serial terminal. The system consists of an 8-slot backplane mounted immediately behind the floppy drives with a 505 CPU, 535 memory card, and a 470 card (used only as a parallel printer port in this system). The 505 CPU has an integrated floppy controller, a single serial port, and a single ROM socket which bootstraps from the disk (the boot options with OS-65 are "H/D/M" since the system could accomodate both floppy disks as well as a hard drive).
The system had minor bugs when powered-up, primarily a short of the 24V supply used to power the floppy drives. The units has two physical power supply modules: one provides +5V to both all cards and the floppy drives, as well as +15V and -12V to the backplane and the second provides +24V for the floppy drives alone. The problem turned-out to be two dead capacitors on the Siemens FDD100-8D drives which were essentially a dead short across the 24V line (dead electrolytic capacitors are unfortunately common on old equipment). Replacement of these capacitors was straightforward, the control circuit board was re-mounted on extra spacers to keep the drive pulley from touching the board (as it did the first time it was powered), and the system booted perfectly .... the system runs OS-65U and OS-65D.
Challenger 2 - 8P DFOn a family vacation to Halifax I picked-up this beautifully-maintained Challenger 2 - 8P Dual floppy machine. Circa 1979, the unit has a 505 CPU and three 16K memory boards - five of the eight slots on the backframe are occupied. Impressively complete, the system had all disks and manuals.
You can see the Insides of the system as well including the three 520 memory cards near the front of the unit, the 505 CPU at the rearmost slot, and the 540 video/interface board below that.
The system features two eight-inch drives (Siemens FDD 100-8 drives) in a box the same size as the CPU and connected via a large ribbon cable. When booted, the screen prompts "H/D/M ?" ... unlike the single-board system this one does not have BASIC-in-ROM on the CPU board (hence the lack of the 'C' cold-start option). BASIC is run from the disk.
The system was is great shape but has the usual problems for a system thirty years old, namely dirty drive mechanicals and loose connectors and chips (chip creep). After a quick cleaning the power supplies were disconnected and output voltages verified to ensure the old supplies would not toast the boards (Old supplies sometimes have old capacitors which fail causing the output voltage to go well beyond that expected - I've seen an old 5V supply producing 7V). Supplies were reconnected and the system booted. At first, the screen showed random characters but after some 'wiggling' of connectors the system was made to boot, once, from the eight-inch floppy drive and was able to perform a 'DIR' as seen on the screen shot to the left. Booting is not reliable yet so a bit more work is likely required on the system - either the drive mechanicals are marginal or perhaps simply all that is required is a recalibration of the electronics (the 470 controller has several analog potentiometers). Since I now have a working 8" drive on the OEM machine, diagnostics and calibration should be trivial.
Challenger 3P - OEM
This perhaps one of the most interesting systems ever built: a floppy-disk based computer featuring three separate processors allowing the user (or even a program) to choose which processor to use from a selection of popular late-1970's processors including the 6502, 6800, and the Z-80. When using the Z-80, for example, the user could run the CP/M operating system (one of the most popular at that time).
I received this system from Tom MacDonald, a friend who works with instrumentation and computer hardware. The system resembles most others offered in the late 1970's by Ohio Scientific: several printed-circuit cards together on a backplane which holds up to eight of which one card is the CPU, and several others memory and I/O including disk interface. The system features two eight-inch floppy drives, the most popular size at the time and with storage capacities far in excess of the very newest 5.25-inch "mini-floppy" drives. This system, a C3-OEM, lacks a video display (becoming popular with "personal" computers) having a serial port instead through which the user interacts with the machine. The terminal could be either a video terminal, connected via an RS-232 serial interface, or a teletype terminal connected via a 20mA current loop (the CPU had both interfaces).
A "typical" high-end machine of the time, the most unusual thing about this particular system is the multi-processor CPU board. This machine, a C3-A, used two floppy drives for storage but an even larger configuration of this machine, the C3-B and C3-C versions, features a hard-disk drive (extraordinarily rare for the time), the controller for which had a dual-port RAM board and a DMA controller based on TTL chips (like the rest of OSI's circuitry).
As received the configuration was as follows: A 510 CPU board (with a 6502, 6800, and Z80 processor), a 470 floppy disk controller, a 522 48K memory card, another 527 memory card with only 8K populated, and a second 470 card used only as a Centronics printer interface. While a "standard" C3 system used different RAM boards (usually three 520 boards containing 16K each), this particular system featured a single 522 memory board utilizing unusual 421D 1K*8 SRAM chips in an 22-pin 0.4" wide DIP package. In addition to the 48K RAM installed (as expected), this system also featured a separate 527 memory card with only 8K installed. This RAM is required to increase the system RAM to 56K to run CP/M or the highest-level of the OS-65U (6502-based) operating system used for multi-user usage. It is mapped at 0xD000 through 0xEFFF.
As usual with an old system, it is best to _not_ trust the power supplies so all cards were first removed and the supplies tested separately. This system features three power supplies: A large Deltron MPS-2 supply which powers cards in the backplane (Supplying +5V, +12V, and -9V), a smaller +5V supply for the floppy disk drives, and a third small +24V supply also for the floppy drives. After the supplies were verified, configuration of the boards was checked before each was reinstalled.
Examination of the CPU card shows a few apparent modifications including the addition of an AND gate on the adjacent 527 memory board which served to disable data bus transceivers prohibiting access to the on-board 6810 memory in the region F0xx as well as the usual FCxx and F7xx ranges (FCxx is used for serial I/O and F7xx for a PIA and so nothing else must be permitted to access these memory areas). Why the region at F0xx must be omitted as well is a mystery. The fact that this CPU board has this extra RAM (128 bytes, normally located at F2xx) indicates it was the "deluxe" version of the 510 board with software-selectable processor (allowing a program to change processors) instead of the simplified version which used a three-position switch. The extra RAM is used to allow a 6800 or 6502 to call and execute programs using a different processor. This RAM is relocatable and under program control can be located at FF00 allowing it to contain restart and interrupt vectors (in place of a normal monitor EPROM). During a switch from one processor to another, this RAM area could be reprogrammed to point to the location of a new program. As for the after-market modification made, it was odd that the 74LS08 gate used was placed on a separate, adjacent, board and connected via three long wires however the 510 board is "stuffed" and lacks the usual prototyping area that most OSI cards have (i.e. a DIP outline in copper allowing addition of circuitry).
Well, the machine was reassembled and works perfectly! OS-65D runs well on the system and in one of the most amazing displays of late 1970's technology, runs CP/M! Take a look below at a capture of a session:
H/D/M?D 49K CP/M Rev. 2.24 for Ohio Scientific C3 Copyright (C) 1980, 81 by Lifeboat Associates A>DIR A: PIP COM : STAT COM : LOAD COM : DDT COM A: XSUB COM : MEMR COM : COPY COM : OSIGEN COM A: FORMAT COM : OSILNKS ASM : WFBIOS COM : ED COM A: SUBMIT COM : ASM COM : DUMP COM : DUMP ASM A>STAT *.* Recs Bytes Ext Acc 64 8k 1 R/W A:ASM.COM 24 3k 1 R/W A:COPY.COM 38 5k 1 R/W A:DDT.COM 33 5k 1 R/W A:DUMP.ASM 3 1k 1 R/W A:DUMP.COM 52 7k 1 R/W A:ED.COM 3 1k 1 R/W A:FORMAT.COM 14 2k 1 R/W A:LOAD.COM 15 2k 1 R/W A:MEMR.COM 8 1k 1 R/W A:OSIGEN.COM 46 6k 1 R/W A:OSILNKS.ASM 58 8k 1 R/W A:PIP.COM 41 6k 1 R/W A:STAT.COM 10 2k 1 R/W A:SUBMIT.COM 20 3k 1 R/W A:WFBIOS.COM 6 1k 1 R/W A:XSUB.COM Bytes Remaining On A: 177k
CP/M is the predecessor to PC-DOS and so, not surprisingly, is easy to use for someone well acquainted with DOS. The actual O/S lacks many of the usual DOS commands such as COPY, for which the "PIP.COM" program is used (it is a generic copying utility). A formatted disk may be made bootable using the "OSIGEN.COM" command which builds a specific version of CP/M for this machine: the main addition being that the 510 CPU boots in "6502" mode which then boots the Z-80 processor to run CP/M.
Of course, most OSI machines ran the OS-65 operating system. This is a relatively primitive track-based O/S providing only the most basic of operations. Although it features a basic command interpreter for "native mode" commands such as "INIT" to format a disk the majority of commands, including external commands, are written in BASIC which is built into the O/S. On boot-up, the O/S runs the BASIC interpreter and executes a BASIC program named "BEXEC*". Being track-based, the O/S lacks a true directory ... in the original versions the user was required to access files by track number directly. A "CALL" command (one of the most fundamental of this O/S) loaded tracks from the disk to memory where they could be executed via the BASIC interpreter or the assembler, also part of the O/S. A corresponding SAVE command writes data in a block of memory to the disk at a specific track and sector.
Disk organization is simple: for an eight-inch disk there are 77 tracks (numbered 0 through 76) and each track can store up to twelve pages of 256 bytes each (total disk capacity is hence 231K). Sectoring is soft and accomplished in software - each track can be broken-up into one or more sectors and each sector can contain any number of pages (the maximum usage of a track being a single sector of twelve pages). A header on each track tells the O/S the track number, and each track also has at least one sector header identifying the sector number and the number of pages in that sector (if more than one sector exists on a track, subsequent sectors with their own headers will be found on that same track - sectoring does consume disk space, though, and so if more than one sector exists per track a maximum of eleven pages can be accomodated per track).
A named directory was possible, however, via a file stored on the ninth track which stored filenames and the starting track. To use the named directory, the user needed to CREATE a file using a utility - this inserted a record into the directory - and the external DIR command could be used to read this file to the screen. The actual code for the "DIR" command was written in BASIC and is shown below:
10 REM DIRECTORY UTILITY FOR OS-65D VERSION 3.2 NMHZ 20 REM 30 NF=0 40 PN=11897 50 DEF FNA(X)=10*INT(X/16)+X-16*INT(X/16) 80 DV=1 : Y=1 : X=PEEK(8994) 90 IF X=<Y THEN 110 100 DV=DV+1 : Y=Y+Y : GOTO 90 110 PRINT "LIST ON LINEPRINTER INSTEAD OF DEVICE #";DV; 120 INPUT A$ 130 IF MID$(A$,1,1)="Y" THEN DV=4 10000 REM 10010 REM PRINT A DIRECTORY OUT 10020 REM 10030 PRINT #DV : PRINT #DV,"OS-65D VERSION 3.2 NMHZ" 10035 PRINT #DV," -- DIRECTORY --" : PRINT #DV 10040 PRINT #DV,"FILE NAME TRACK RANGE" 10050 PRINT #DV,"------------------------" 10060 DISK ! "CALL 2E79=08,1" 10070 GOSUB 11000 10080 DISK ! "CALL 2E79=08,2" 10090 GOSUB 11000 10130 PRINT #DV : PRINT #DV,NF;"ENTRIES FREE OUT OF 64" : PRINT #DV 10140 END 11000 REM 11010 REM READ DIRECTORY OUT OF BUFFER INTO ARRAYS 11020 REM 11040 FOR I=PN TO PN+248 STEP 8 11050 IF PEEK(I)=35 THEN NF=NF+1 : GOTO 11130 11060 N$="" 11070 FOR J=I TO I+5 11080 N$=N$+CHR$(PEEK(J)) 11090 NEXT J 11100 PRINT #DV,N$;TAB(12);FNA(PEEK(I+6));TAB(16);"-"; 11110 PRINT #DV,TAB(17);FNA(PEEK(I+7)) 11130 NEXT I 11140 RETURN
The utility is quite simple and works using a CALL command (an internal OS-65 command) to read the contents of track 08 into memory at location 0x2E79 (11897 decimal). The contents of the memory at this location are then displayed directly on the screen. Similar commands exist to delete and rename files. An example output of this command is shown below:
OS-65D VERSION 3.2 NMHZ -- DIRECTORY -- FILE NAME TRACK RANGE ------------------------ OS65D3 0 - 8 BEXEC* 9 - 9 CHANGE 10 - 10 CREATE 13 - 14 DELETE 15 - 15 DIR 16 - 16 DIRSRT 17 - 17 RANLST 18 - 19 RENAME 20 - 20 SECDIR 21 - 21 SEQLST 22 - 23 TRACE 24 - 24 ASAMPL 27 - 27 COLORS 28 - 28 C-ASM1 29 - 29 C-ASM2 30 - 30 48 ENTRIES FREE OUT OF 64
Debugging a 500-series system ...
A contact on the web recently had an OSI system with various problems and I have made a series of notes regarding debugging a C2/C4/C8 system:
Check the power supply first to ensure the voltages are correct - I have seen an old '5V' power supply putting-out over 7 volts! After that, power-up the system and check for video output: lack of video output might indicate a problem either with the 540 video card or with the CPU card. Checking the CPU card is simple enough: First, though, determine which CPU is in use. The common CPUs available were the 502 (for a 'BASIC in ROM' system like a C4P) and the 505 (for a floppy-based system since the 505 has an on-card disk interface). Aside from the disk interface, the biggest difference is the clock - the 502 has no internal clock. With a 502 board the CPU derives its clock from the OSI bus which is supplied from the 540 video card (which must be installed in this case), with a 505 board an on-card 4MHz crystal is divided by two sections of a 7476 JK flip-flop for the CPU. Either way, a clock must appear at pin 37 on the 6502 chip (phase-0) before anything else will function. With the CPU functioning, the address bus should show a great deal of "random" activity which may be seen on a scope or logic probe.
If the CPU card is running, check the video card - specifically check the waveform of the control lines on the 2114 RAM chips used as video RAM (the two 2114's closest to the character generator ROM) on the 540 video card. Using a logic-analyzer, or a scope, monitor the /WE (pin 10 on the 2114) and /CS (pin 8) lines as the RESET key is pressed. During a RESET (pushing the key on the front panel), one should see a series of write operations to the RAM ... this is how the OSI clears the screen to remove the random 'garbage' which appears on power-up (random RAM contents, displayed as ASCII characters). Note that address lines are always active since they are also used for read operations during video display. As well as a reset, pressing a key on boot-up such as "M" (to enter the monitor) will cause a write to the RAM and in the monitor pressing a key such as "0" or "1" will then cause another write. Verify this and it will assure you that the CPU is running properly.
In the above logic-analyzer output, channel 1 is wired to /WE pin, channel 2 to /CS pin, and channels 3 and 4 to address lines A0 and A1 respectively. When the CPU is running normally, no write operations occur (channel 2 was triggered here since channel 1 is always high). Only read operations take place during data display and, as expected, there is a good bit of activity on the 2114 chip address lines.
It might be noted that the video RAM must be relatively fast: it must be rated at 400ns or faster (i.e. the chips in these sockets will not work if they have a "-5" suffix as this indicates a 500ns chip). Use of slower chips may not allow proper data read/write and so strange patterns may appear on the video screen.
Floppy-based systems usually ran the OS65D system, for most applications, or OS65U for more demanding applications (it featured extensions for timesharing 16 terminals as well as extensions for database management). Both systems were centered around BASIC although an assembler and extended monitor were included allowing the writing of machine-code programs for the system. When the system is booted the kernel loads and immediately runs a BASIC program named 'BEXEC*' on the floppy disk. Usually, the user is either presented with a menu from which the user selects an operation or for development purposes the user may select to run BASIC and is presented with a BASIC prompt. Typing EXIT in BASIC brings the user to the actual O/S command interpreter, usually with a familiar "A" prompt. From the command interpreter the user could execute simple disk operations as well as run BASIC, and assembler, or an extended monitor (and possibly other languages).
Oddly, most utility program included with OS-65D were written in BASIC. Utilities included:
- CREATE a utility which creates a new named file, required before one could simply use it to save a BASIC program (i.e. you CREATEd the empty file first then could save your program or data into it). Without using CREATE first, the user could not use filenames, only access files by track number.
- DELETE used to delete a named file from the disk
- DIR yes, even a simple directory listing required the execution of a program which does this.
If this all looks primitive, remember that OS-65D was created in 1976 and PC-DOS would not appear until quite some time down the road. Original PC's came with BASIC-in-ROM and a cassette port as well ... floppy disks were still expensive in the early 80's and it was not intended that all machines would have drives.
Below is a listing of various OSI cards allowing identification of these should you come across them. It was compiled from various OSI literature. Included are photos of the boards in my collection and schematics for a few select boards.
- 500 C2P CPU Board (6502) The 500 board could be used as a complete 'stand-alone' board featuring 8K BASIC in ROM and 4K of RAM on board or as the CPU board in a larger system. All that was required for stand-alone was an ASCII RS-232 terminal as well as a power supply. It was also available as a 'SuperKit' with this 500 board, a 440 video board, and an 8-slot backplane for these and more cards. For the SuperKit, ROMs were configured to use video and a user-supplied ASCII parallel keyboard instead of the RS-232 terminal (the RS-232 option was not installed on the 500 board for this version).
- 502 CPU Board TOP VIEW of the 502 CPU Board from a C2P
- 505 CPU Board TOP VIEW of the 505 CPU Board
- 510 CIIIP CPU Board with Z80, 6800, and 6502 CPUs
- 560Z Multi-CPU Board
- 520 SRAM Board
- 525 SRAM Board
- 527 24K SRAM Board (fourty-eight 2114 chips)
- 420 Older 2102 SRAM Board TOP VIEW of the 420 Memory Board with 4K Installed
- 530 DRAM Board
- 450 EPROM Board
- 455 SRAM Board
- 430 Audio Cassette I/O Board
- 440 Video Board
- 540 Video Board TOP VIEW of the 540 Video Board
- 550 16 port 6850 Serial Port Board TOP VIEW of the 550 Serial Board
- 470 Floppy Controller with Parallel port Although intended for use as a floppy disk controller, the board was often used as a generic parallel port interface for printers simply by populating only a portion of the card.
- 542 Keyboard Seen on top of the system, this was a simple matrix keyboard scanned under software control.
- 580 Backplane board (8 slot)
- 495 Prototyping card
An updated 500 CPU, this board has similar features to the 500 however features 8K of 2114 RAM on-board. The board includes BASIC and MONitor ROMs for cassette-based configurations.
SIDE VIEW of the 505 CPU Board
This CPU was used on 8P and possibly 4P systems - it features an on-board floppy controller, serial port for a console, and a single ROM socket (and so was always used with a floppy disk system). The board is part of a 3-board set (including a video card and a memory card) to make a complete system. The video card could be omitted if an RS-232 terminal were used for I/O but a memory card is certainly required since the 505 has no provisions for RAM.
Schematics - Page 1 showing the CPU
Schematics - Page 2 showing the single ROM and decoder logic
Schematics - Page 3 showing the integrated floppy controller
Schematics - Page 4 showing the serial UART and baud rate generator
Schematics - Page 5 detailing signal names used on the diagrams
Schematics - Page 6 a top view to identify components
Note that although the circuitry appears to be identical to my 505 board the component placement (see Page 6) is completely different than my photograph reveals. Apparently there were different revisions of this board.
SIDE VIEW of the 420 Memory Board with 4K Installed
This board could also be wired for 12-bit wide RAM , presumably to accomodate the Harris 6100 PDP-8 CPU when the 460Z CPU expander was used (the PDP-8 being one of the most popular CPUs at the time. Running the 6100 would ensure the availability of a huge range of software).
SIDE VIEW of the 540 Video Board
The 540 board could accomodate black&white as well as colour video. It featured a keyboard connector in the form of a 16-pin DIP socket to which a model 542 keyboard was connected
Schematics - Page 1 showing the address decoder
Schematics - Page 2 showing video memory (all 2K of it)
Schematics - Page 3 display counters
Schematics - Page 4 keyboard buffer
Schematics - Page 5 colour memory
Schematics - Page 6 colour output
Schematics - Page 7 AC control (option)
Schematics - Page 8 I/O connector pinout
SIDE VIEW of the 550 Serial Board
TOP VIEW of the 470 Floppy Controller Board
SIDE VIEW of the 470 Floppy Controller Board
Schematics - Page 1 showing latching and buffering logic
Schematics - Page 2 showing wiring and noise (DAC) logic
Schematics - Page 3 showing the key layout on the 8-by-8 matrix
Schematics - Page 4 showing component placement on the PCB
Have a look at the specs and pricing for an OSI system as seen in
Popular Electronics in
1978. Shown are various configurations as well as many I/O boards available
for the OSI.
With Thanks ...
I must conclude with thanks to a few people who have "donated to the cause" including Greg Swick, a colleague of mine, who gave me a 600 board and a bunch of 500 boards. This rekindled my love for these old OSI machines in the first place. Scott Gregory, a buddy of mine who gave me the blue Challenger II seen on this page. Richard Parsons who sent me a number of interesting boards, O/S disks, and documents related to the OSI 500 and 600 series of computers. There's a wealth of information in the Aardvark and TOSIE journals I received including information of connecting disk drives. John Walker, who sent me a 600 and 610 board as well as some excellent docs (including a Sam's Photofact servicing manual) on the system. John Horemans for sending 600/610 circuit data. Jerry Travis who sent me a 600 and 610 board as well as two MPI drives. Russell Cooper from Australia who sent me a 600 and 610 board and some nice docs on OS-65D. Charlie Wainwright from Halifax who gave me the beautifully preserved Challenger 8P unit and docs (we picked-up the unit while on a family trip out East in 2006). Dan Batholic from MN who gave me a C2-OEM and a load of docs. This interesting machine has two 8" drives and was designed to run from a serial port (it has no video card installed) like a C3. Doug Pelletier from MI who gave me a C2-4P unit (a small black and blue unit with integral keyboard) with original docs. Tom MacDonald, a colleague, who got me the Challenger 3 system.
... and a number of other people I've had e-mail contact with who have sent me scans of various documents on OSI boards.