Greysoft (broken)
Hardware and Construction Manual (pdf)
User Tutorial (pdf)
User Disk Reference and Tutorial Manual (pdf)
Quick Reference Guide (pdf)
Technical Reference Manual (pdf)
SSASM Users Manual (Assembler) (pdf)
FORTH manual (pdf)
Document Editor (pdf)
Utilities (pdf)
Disk Co-processor-Card (pdf)
SCSI Hard Disk Supplement (pdf)
Advert: Applix (1)
Advert: Applix (2)
Advert: Mondotronic
ETI December 1986 — page 54
Project 1616
An introduction to the world of 16-bit computing. The Applix-1616 is the highest performance computer design ever published in a magazine.
Andrew Morton & Paul Berger
The 1616 was designed by Paul Berger and Andrew Morton after extensive discussion with ETI staff early in 1986. Berger and Morton run a computer supply and design company called Applix Ltd in the Sydney suburb of Beverly Hills. They are currently working on enhancements to the 1616.
The original overlay image above has an error, the Centronics connector is actually top left and the user I/O is to the right of the Centronics connector. See photo below:
![]() |
THE TROUBLE WITH most kit computers is that once built, tested, and shown off at the local computer club, the user realizes that, as far as a personal computer is concerned, it’s not particularly useful, and the exercise is rationalized as being “very educational”.
The 1616 does not suffer from that problem. It sports similar features and specifications to the latest personal computers, like the Amiga and Atari ST, and the classic design architecture of the Apple II and IBM PC. The difference is that it’s a kit computer. Building your own will, firstly, allow an insight into the workings of the system, and secondly, significantly reduce the overall cost. The fact that it’s a kit does not detract from the performance or features of this machine.
When we started the initial design of the 1616 (the nameless wonder at that stage) we looked around at the various microprocessors used in popular computers. Eight-bit processors were out of the question. They simply were not powerful enough. The Intel 8088/86 (as used in the IBM PC) was an obvious choice, but that would mean that the machine would inevitably be just another IBM-compatible. We didn’t think the world could handle another one and the 8088 is barely a 16-bit microprocessor anyway. The Motorola 68000 is by far a better choice. Most of the new computers are using it including the Apple Macintosh, Commodore Amiga and Atari ST.
The 68000, a true 16-bit microprocessor, has a 16-bit data bus and a 24-bit address bus (giving access to 16 megabytes of memory). Some people call it a 32-bit processor because of its 32-bit wide registers and internal data path.
We thought its architecture was very broad and strong. In addition, we wanted something to support graphics, which the 68000 does particularly well. Our view was that superior graphics is one of the main reasons for upgrading to 16-bit. So 68000 it was!
Motorola 68000. 16/32-bit microprocessor (16-bit external data bus/32-bit internal data path and registers) running at 7.5 MHz.
512K bytes dynamic RAM using 16 standard 41256 memory chips. Expandable to 4.5 megabytes total on board. 8M directly addressable in expansion units of the board. ROM Up to 128K bytes of on-board ROM.
Four modes as standard; 320 x 200 x 16 colours, 640 x 200 any four of 16 colours, software or hardware scroll. Standard 16-colour RGBl interface or composite video with 16 shades of grey.
Stereo sound with output to hi-fi and on-board amplifier for direct connection to speakers.
On-board high speed, block orientated cassette interface with motor control. 'RAM disk' support software in ROM.
Uses standard IBM-style detachable keyboard.
Four 80-pin expansion slots with all 68000 signals; for memory expansion, floppy and hard disk interface, etc. Centronics compatible parallel printer port. Dual seria1 (RS232 as standard) ports using standard Z8530 SCC, with programmable baud rates up to 1 megabit. Analogue two-button joystick port using standard Apple-type controllers. User port; general purpose analogue and digital I/O port for experimenting (i.e., EPROM programmers, speech input, etc).
Powerful monitor, full screen editor, assembler, terminal emulation, communications and operating system (graphics support, etc).
Look at the popular Apple II and IBM PC computers. They both have a motherboard with processor, RAM, ROM, video and lots of expansion slots. Both work in their minimal form and can be expanded to complete systems as required, or finances allow.
The 1616 takes this basic form one step further. It is a single board design which serves as a solid foundation on which to build a complete, low cost, useful personal computer.
The design is based on a mixture of what we wanted, what was needed and what was available. For example, once we had chosen the 68000 processor (which has a 16-bit data bus), and since standard memory chips are only one bit wide, it was obvious that we needed 16. The design could take either 64K or 256K chips so that we would end up with 128K and 512K respectively. As it turns out, 128K is a bit squeezy so the standard on-board RAM is 512K.
Similarly, since ROM chips are eight bits wide, we needed two. Using today’s high capacity ROM chips we ended up with a total on-board ROM of 128K bytes.
We wanted to pack as many features onto the motherboard as possible. We drew up a list of necessary and desirable options and went through them one by one, putting them in and taking them out.
We just had to have colour graphics, and sound was attractive, joystick? Of course! Everyone is into communications nowadays, so serial ports are a must. This also allows the computer to be used as a terminal to something bigger (or smaller). We didn’t want to limit the serial ports to RS232, so the design allows the serial ports to also be used for networking, hooking up a mouse, a MIDI interface, RS422, etc. One would eventually want to add a printer so a parallel printer port is in.
All that’s left is mass storage. It’s tape! This was a major decision. Obviously, a drive is attractive, however, it has a problem. A disk controller on the motherboard raises the complexity considerably. We thought it best to leave this to an expansion board and do the job properly.
A tape system allows you to use the computer at its minimum level without having to go out and buy a disk drive immediately. We have tried to make the tape system as workable as possible, using the available memory as a RAM disk. It is very fast (over 3000 bits per second) and very reliable, and uses a standard cassette recorder.
The other necessary peripherals are also bog standard. The 1616 requires an IBM keyboard, and an Apple power supply. The real thing, or any cheap clone, will do the trick.
The 1616 hardware consists of 68 integrated circuits mounted on a 394 mm x 210 mm double sided, plated through printed circuit board. It is powered by an external power supply providing +5 V, +12 V, -5 V and -12 V similar to that used in the Apple II. The design may be broken up as follows.
The heart of the system is, of course, the 68000 microprocessor. Video generation is controlled by a 6845 CRT controller chip. The 32K bytes of video display data is obtained from the on-board memory and is entirely bit mapped, hence there is no need for a character generation ROM. The display bit map may be located at any 32K address boundary, allowing the use of multiple display pages.
The dynamic memory is refreshed by the continuous reading performed by the video circuitry. A 16R8 PAL (programmable array logic) device, clocked at 30 MHz, resolves the contention between the 68000 and the video circuitry during memory accesses. This same PAL provides most of the system’s timing requirements.
Video data is read 16 bits at a time from main memory and is clocked serially to the video output stage.
The serial bit stream is converted into a four-bit format suitable for display on an RGB I (red/green/blue/intensity) or composite monochrome monitor by another 16R8 PAL and associated circuitry. A control input to the video PAL selects between either 320 or 640 pixels per line.
In 640 mode, a four x four bit register file chip provides a palette of any four colours from the possible 16. A latch provides the border colour around the display area. In 320 mode, 16 colours are available.
The 6522 VIA chip provides the computer with eight bits of general purpose parallel I/O and is used for various functions including cassette, keyboard, sound, Centronics, video and interrupt control.
This section includes sound generation, joystick control, general purpose analogue I/O and cassette I/O. Most of these functions use the eight-bit digital-to-analogue converter chip and CMOS analogue multiplexers.
The 1616 communications chip, the Zilog 8530 SCC (serial communications controller), provides dual synchronous and asynchronous data transfers at a wide range of programmable baud rates. The board has been designed to comply with the RS232C standard, but provision has been made for implementation of virtually any line discipline by the use of an appropriate interface card.
The 1616 has four 80-pin expansion connectors which make available power supplies, all of the 68000’s signals and clocks. These permit peripheral cards such as memory expansion and disk controllers to be connected.
Figure 1. Applix-1616 block diagram
00000000 | Vectors | 1k | 512k User RAM |
00000400 | System Use | 7k | |
00002000 | User/RAM disk | 472k | |
00078000 | Default video | 32k | |
00080000 | Expansion RAM | 4M | |
00500000 | EPROM | 1M | |
00600000 | I/O space | 2M | |
00800000 | Expansion space | 8M | |
01000000 |
Figure 2. Memory map
24-bit address space allows 224 = 16 megabytes
32-bit address space allows 232 = 4 gigabytes
EPROM space is 1 megabyte but EPROM chips are 2 x 64k = 128 kilobytes.
The 64K bytes of software contained in the 1616 ROM went through a similar evolution to the hardware, but there was one other factor involved: time. When designing a computer system, the hardware is usually the easiest part and takes relatively little time. Making the hardware actually do something is the difficult part. That's where the software comes into play.
Most of the 1616 software is written in the C programming language with portions written in 68000 assembler for maximum speed.
A key feature is the RAM disk file management software. This brings the 1616’s operating system closer to a disk system than to a tape one. From 128K to 347K of memory may be used for storing files.
To understand the software better, it can be logically divided into the following sections:
These routines are invoked by the setting of the sense switches. They force the 68000 to perform simple operations which aid the testing of the board during construction.
These manage all input/output devices, most of which are buffered and interrupt-driven. This includes serial I/O, parallel output, keyboard input, cassette I/O, RAM disk file management, video output and system timer ticks, etc.
These are a collection of routines which application programs may call for:
This interprets and acts upon commands typed in by the users. These commands include:
All the operating system commands support full I/O redirection. The output and input for the execution of the command may be directed to and from devices and RAM disk files. Full screen editor. This is a fast WordStar-like editor which operates upon RAM-based files.
A resident assembler which reads standard Motorola mnemonics from a RAM disk text file, producing executable 68000 code.
For transferring files and communicating with other computers.
Full details of the design will be published in up and coming issues of ETI. The hardware, software and full construction and operating instructions will be published in February, March and April next year. Details of supply of the 1616 will be available in the February issue.
ETI February 1987 — page 41
Project 1616
AT THE CENTRE of the 1616 is the 68000 microprocessor, supported by its RAM and ROM. In this article, we take a close look at the 68000 and its operation, and the way it talks to the rest of the circuit.
Motorola’s MC68000 series microprocessor family was first introduced in 1980, at a time when advances in VLSI fabrication and design techniques were permitting manufacturers to put an entire 16-bit microprocessor on a chip.
At this time some manufacturers (most notably Intel) elected to design their 16-bit micros as upgrades to their 8-bit ones. Motorola on the other hand produced an architecture which was derivative of none of its previous microprocessors — it was a multi-register device which was designed from scratch to support high-level compiled languages, multi-tasking operating systems, and multiple processors.
Motorola has excelled in designing microprocessors for the programmer. Its MC6809 was the best of all the 8-bit microprocessors from the programmer’s point of view and the MC68000 family instruction set certainly indicates that the software boys made a large contribution to its design.
The microprocessors in the MC68000 family are:
MC68000: A 64-pin IC, with a 16-bit external data bus, 32-bit internal data bus, 12.5 MHz maximum available clock speed. MC68008: With 48 pins, an 8-bit external data bus, a 32-bit internal data bus and a 12.5 MHz maximum available clock speed the MC68008 was designed to bridge the gap between existing 8-bit subsystems (such as memory and I/O cards) and a 32-bit microprocessor.
Signals with a bar across the top are active low. This means that when the signal is activated, It goes low.
MC68010: This device is very similar to the MC68000, it has some extra instructions some of which have been made more efficient, but the main rationale for the introduction of the MC68010 is probably as a ‘fix’ for a limitation of the MC68000 which prevented it from resuming a program after a memory fault — a capability which is necessary for large operating systems. This MC68010 feature is not needed in a system of the 1616’s size.
MC68020: The MC68020 is a 127-pin microprocessor IC with 32 address pins, 32 data pins, on-board instruction cache, 25 MHz clock speed, dynamic bus sizing, etc, etc. This is a very powerful microprocessor .
MC68030: Rumours abound. This device is apparently being shipped in sample quantities at present and it must go like a free beer.
The MC68000 can address 16 Mbytes of memory. This is a 24-bit address range — the microprocessor’s internal addresses are in fact 32 bits but the eight most significant address lines (A24-A31) never see the light of day due to IC packaging constraints.
As with all of Motorola’s microprocessors, memory and I/O devices are mapped into the memory space. The MC68000 does not use a separate I/O space with its associated special I/O instructions, as do the Intel and Zilog microprocessors. I/O devices are written to and read from in the same way as memory.
There are 16 data lines connecting the microprocessor to its memory.
The MC68000 may read or write data in either 8-bit or 16-bit quantities.
The signals which deter-mine the amount of data to be transferred are U£>S (upper data strobe) and
Although the data bus is 16 bits wide,
the MC68000’s addresses refer to byte (8-bit) quantities.
Bytes which are at even addresses are transferred on data lines D8-D15 (tJDS asserted).
Odd address transfers occur across D0-D7.
This is why the microprocessor has no AO (address line zero) pin; the least significant address bit is kept internally and is used to determine which of
Reading or writing a 16-bit quantity at an odd address would require two memory accesses to two different 16-bit addresses.
The MC68000 does not permit this.
The 32-bit reads and writes are accomplished by doing two accesses to consecutive 16-bit addresses.
Data transfer mechanism The MC68000 uses asynchronous memory transfers.
This means that instead of having a fixed memory access timing scheme, the MC68000 requests access to a memory location and waits until external hardware signals that the memory has responded.
The signals which are used to indicate a memory access are
The asynchronous memory transfer mechanism essentially involves inserting memory wait states into the processor’s bus cycle.
Different types of memory have different access (response) times and so the address decoding circuitry must ascertain from the address what type of memory is being accessed and insert an appropriate wait period.
If the processor attempts to access an address which no external circuitry recognizes, it will never receive a
The mechanism of externally detecting an access to an invalid address by measuring the bus response time is known as a bus error, or a bus timeout, or a memory fault.
6800 device interface The MC68000 signals E (enable clock),
The 1616 uses this mechanism for addressing all of its I/O except the 8-bit output latches. This includes, of course, the 6845 CRTC and the 6522 VIA, both of which have MC6800 compatible bus timing.
Interrupt implementation The MC68000 uses a prioritized interrupt scheme.
It supports eight interrupt levels.
The processor has an internal register which determines its current interrupt priority level.
This ranges from zero (lowest) through to seven (highest).
External hardware requests an interrupt by encoding a number onto the MC68000’s interrupt request pins
Using this scheme, external interrupting devices may be organized according to the urgency with which their interrupt request must be handled. A high priority interrupt request may temporarily pull the processor out of handling a lower priority interrupt. An example of this may be seen in the 1616’s interrupt organization. None of the VIA’s interrupt sources need be serviced with great urgency, so the VIA is put at interrupt priority level two. For high speed communications we wish to respond quickly to the serial I/O interrupts, so the SCC is put at priority level three. This means that if the processor is dealing with a VIA interrupt when the SCC makes its higher priority interrupt request, the VIA interrupt handler will be temporarily suspended whilst the SCC interrupt is processed. The converse does not apply: if an SCC interrupt is being serviced when the VIA requests an interrupt, the VIA request will be ignored because its level is 2 whilst the processor is currently at priority level 3. The level 2 request will be recognized when the processor’s priority returns to level 1 or level 0.
ABOUT PALs
A PAL (programmable logic array) is a 20-or 24-pin IC which may be once-only programmed in a manner similar to bipolar fusible-link PROMs. A PAL may replace as many as 10 catalogue logic ICs when used to implement complicated logic functions.
The 16R8 PALs used in the 1616 consist of an array of AND gates which drive an array of OR gates, the outputs of which are latched and then passed to the outside world. When the device is in its unprogrammed state the inputs and the AND array are connected to all of the IC’s inputs and to all of its outputs. A PAL is programmed by electrically removing some of the internal fuses which connect the AND array to the PAL's inputs and outputs. Designing a PAL fuse map involves selecting those fuses which are required to implement the desired logic function and then blowing all of the others in a suitable programmer.
A useful feature of the 16R8 PAL is its output registers. A group of eight latches on the outputs permit the storage of previous state information for the generation of complex timing sequences. The latches virtually eliminate timing skew between the PAL’s output signals; when the PAL is clocked all of the output changes occur within a very short period, which eliminates many design uncertainties concerning device propagation delays.
The 1616 is a complex circuit and this, in a break from our usual policy, is not a complete description of how the thing works. Since we don’t have an infinity of pages, you’ll have to forgive us. If you are interested in a more detailed description, contact Applix directly.
The EPROM decoding circuitry is very simple. Any address in the range $500000-$5fffff (hex) enables the EPROMs. The flip-flop IC60 is used to get things under way when the processor is reset. The MC68000 requires valid data at addresses $000000 to $000007 immediately after it is reset. This is provided by initially enabling the EPROMs at all addresses throughout the entire memory map. The processor shortly commences execution in the normal EPROM address range at $500000 and the memory map is restored to normal as soon as the processor performs a write operation.
The 1616 sports 512 kilobytes of dynamic RAM on board organized as 256K of 16-bit words. The base address of the on- board RAM may be set at either the 0, 1, 2, 3 or the 4 megabyte boundary using the ‘mem’ strapping block. For software reasons it is intended that all the RAM in the system be in one block, starting from address $000000. Any expansion RAM boards will have either 1, 2, 3 or 4 megabytes of storage, and when they are installed the on-board RAM’s address will be shifted up to the next address beyond the expansion RAM.
The 1616’s memory timing scheme is quite complicated and lies at the very heart of the system.
The complexity of the timing is due to the need to resolve any contention between the MC68000's RAM accesses and those of the video circuitry.
The video absolutely must read 16 bits from the RAMs at a rate of 1.875 MHz or else the display image would be affected.
For this reason the processor access is synchronized to that of the video.
For most of the time the interleaved video/processor memory accesses are quite transparent and the processor runs without any wait states
— the video accesses are squeezed into the first half of the MC68000 bus cycle.
Occasionally the MC68000 will lose synchronism with the video and it must be delayed (by retarding
It should be noted that this synchronization only applies to the on-board RAM. All other devices on the bus are accessed in a more conventional manner. This is possible because the video data paths are isolated from those of the rest of the system by the buffers IC28 and IC30. The video essentially has a private data bus and must only synchronize with the MC68000 when there is to be an exchange of data.
Benchmarks indicate very little speed difference between programs which run in RAM and those in ROM, indicating that the synchronization delays are not significantly slowing the processor.
Note that the MC68000 and the video circuitry accesses result in the on-board RAM being accessed at a continuous rate of 3.75 MHz. There are 7.5 megabytes per second going across the data bus and the RAMs are being cycled at 267 ns. The minimum specified cycle time for 150 ns dynamic RAMs is 250 ns and it is this which limits the 1616’s processor clock frequency to 7.5 MHz.
A 16R8 PAL (IC51) and a 74F74 flip-flop (IC50) are driven at 30 MHz and together they perform the following critical timing functions:
How’s that for two chips?
There is an amount of random logic around the processor which does the following things:
Bus fault timer: IC33 is a retriggerable monostable (or one-shot) which monitors
Reset circuitry: This logic handles the assertion of the MC68000’s
Due to a lack of space on the circuit diagrams, we have not put chip type numbers on the diagram. Use this key to find out.
The MC6854 CRTC video controller generates timing and addressing signals which interact with the timing PAL to load 16 bits of data from the RAMs into the shift registers (IC29 and IC30) every 533 ns. This data is shifted two bits at a time into the video PAL (IC5) at 15 MHz.
The 8-bit video latch (IC16) holds the video border colour (4 bits) and the video display RAM address offset (4 bits). Using this latch the video display RAM may be set to start at any 32K boundary within the on-board RAM. This permits the use of multiple display pages to implement animated displays. The 1616 operating system ROMs frilly support this feature.
640 column mode: In this mode, video data is shifted out at 15 MHz. The two bits coming from the shift registers are used as an index into the 4x4 bit register file, IC4. The 4x4-bit words in the register file are written by the processor and allow the programmer to map each of the four colour combinations into one of the 16 available colours.
320 column mode: In this mode the RGB and I signals are generated by the video PAL, rather than being read from the register file. The PAL simply remembers the previous two bits from the shift registers and presents them alongside the current two. This is essentially a serial-to-parallel conversion and it produces a 7.5 MHz stream of 4-bit words.
The border colour may be any of 16 colours, independent of the video mode.
The data selector IC3 selects the video data from either the PAL or the register file, latches it internally and presents it to the video mixing circuitry.
The video mixing circuitry converts the video data into both a standard IBM RGBI output and into a 16 grey scale composite sync signal.
Memory mapping: In 640 and 320 column mode, each word (16-bit quantity) in the 1616’s video display memory is represented on the screen as below.
15 | 14 | 13 | 12 | 11 | 10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
Pixel (leftmost) |
Pixel | Pixel | Pixel | Pixel | Pixel | Pixel | Pixel (rightmost) |
640 mode
Note that the most significant bits of a word appear toward the left side of the display. The mapping of screen memory addresses to screen coordinate positions is quite complicated. This is due to the use of the MC6845 RS0, RSI and RS2 signals to address the memory, and to the use of the MC6845’s hardware scrolling capabilities. There is extensive software support for video display manipulation in the 1616’s operating system ROMs.
The 1616 video, unlike most computers, has no text-only mode. Due to the speed of the MC68000 it is possible to draw characters onto the screen from a table of character shapes stored in memory. This table is stored in a compressed format in the 1616’s ROM and is transferred into main memory at power on. There are two main advantages to this method. Firstly, it allows an infinite number of display formats, including different font styles and sizes, and secondly, it simplifies the design of the video circuitry.
The use of an MC6845 allows the programmer to select a wide range of video formats, including interlaced mode and variable horizontal and vertical formats. The 1616’s video drivers initialize the CRTC for 640 (or 320) columns, and 200 scan lines. This requires 32K of video RAM. The number of columns and lines may be increased or decreased, but the programmer will have to write his own drivers to support non-standard configurations.
15 | 14 | 13 | 12 | 11 | 10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
Pixel (leftmost) |
Pixel | Pixel | Pixel (rightmost) |
320 mode
The 1616 is available directly from its designers, Applix. As of writing we have been approached by many anxious distributors so you may eventually be able to purchase it elsewhere also.
When designing the 1616 our aim was to make it a useful, cost-effective, high performance kit computer. We have tried to make the kit as appealing and flexible as possible. The response to the introductory article was in a word “overwhelming”, especially as the pricing and distribution had not been finalized.
The Mini Kit costs $239 and includes the 1616 printed circuit board, EPROMs, PALs, 30 MHz oscillator, MC68000 processor and socket, and the user/constructton manual. This kit would be for people who can source their own components and are familiar with a project of this type.
The Basic Kit costs $449 and includes all the components, connectors plus the contents of the Mini Kit. This kit would appeal to most people and works out significantly cheaper than purchasing the Mini Kit and sourcing the components commercially. But it is also important to note that this kit does not include the necessary components to implement the serial, Centronics and user ports, as most people would regard these as optional. It also does not include IC sockets.
The I/O Kit costs $69.95 and includes all the necessary components to implement the serial, Centronics and user I/O ports. The IC Socket Set costs $29.95. Due to the controversial nature of the use and type of IC sockets we have decided to make them available separately. The sockets included in the kit are of sufficient quality for a project of this type. You may use your own (machined, etc) or, if you are brave, use none at all. As stated elsewhere we only offer servlce/repair to fully socketed Basic Kits.
The keyboard is $139. A high quality ‘IBM AT style’ detachable keyboard.
The power supply is $69. Standard ‘Apple type’, switching power supply with suitable power connector.
Applix will also be offering competitive prices on other related products but you are certainly not restricted to buying everything from us.
ETI February 1987
ETI March 1987 — page 54
Project 1616
In part 3 of this project we describe the peripheral parts of the 1616 — the interfacing to keyboard and printer, the analogue input/output and the serial interface. We also begin a discussion of the software.
THIS ARTICLE will describe the peripheral parts of the circuit. The major peripheral function devices of the 1616 apart from the video are the keyboard interface, dual serial channels, parallel printer port, cassette port, analogue interface, sound generation, user port and the expansion connectors.
The IBM-compatible keyboard produces either 10 or 11 bits of clocked serial output depending upon the style of the keyboard. Schmitt triggers in IC34 clean the noise from the incoming clock and data signals. The leading two or three clock pulses from the keyboard are then discarded by the latches IC53 and IC49 and the remaining eight pulses are used to clock the data into the VIA’s internal shift register. Filling this register causes the VIA to interrupt the 68000. Software then reads the incoming data from the VIA and lowers the VIA CLRKBL signal, preparing IC53 to receive the next keycode.
The 1616’s standard serial protocol is RS232C which is obtained by loading the serial drivers and receivers IC6-IC9 and linking pins on the serial jumpers. These jumpers may be wired to accommodate differing serial port pinouts. Other communication protocols such as RS422, MIDI and SDLC may be implemented by mounting a peripheral circuit board containing appropriate logic and drivers onto the serial jumper pins.
The 1616’s serial interface is implemented using the Zilog Z8530 serial communications controller (SCC). The dual four-to-one data selector IC63 is used to generate the SCC’s control signals SCCRD and SCCWR from the MC68000’s bus signals. The SCC has no reset pin but is reset by simultaneously lowering both these signals.
The 3.75 MHz signal from the timing PAL is sufficiently close to the desired 3.6864 MHz for it to be used as the baud rate reference for the SCC. This signal is brought to the serial jumpers for this reason. The parallel printer port The parallel printer port is a minimal Centronics interface. Characters are written to the 8-bit latch IC1, and the VIA CENT-STB signal is pulsed low to send the data to the printer. Centronics-type printers send an acknowledge pulse to the host computer when they are ready for new data. This signal, CENTACK, is buffered and passed to a VIA interrupt input pin.
The printer also transmits a busy signal which is high when the printer is not ready to receive data. This signal is buffered and passed to the VIA CENTBUSY input.
The tape recording format is a simple one: a binary 0 is represented by a 200 microsecond cycle and a binary 1 by a 400 microsecond cycle. To save data on tape the VIA is programmed to generate a stream of interrupts which provide the timing, and the VIA CLRCASIRQ signal is raised and lowered at interrupt time to generate the appropriate signal to be recorded.
Upon playback the recorded square-edged signals are greatly smoothed. The LM301 op-amp IC12 is used as a slope detector to cancel the effects of tape recorder bandwidth limitations. The LM319 comparator retrieves the original signal and produces a TTL compatible level.
The monostable IC33 has a timing period of approximately 300 microseconds and is used to decode the pulse-width modulation recording format: if two rising edges from the comparator are separated by less than 300 microseconds (a binary 0) then the monostable output will be low on the second rising edge; if the separation exceeds 300 microseconds then the monostable output will be high. On each rising edge of the output of IC11 during tape reading three things happen:
The IC33 monostable is retriggered, starting the 300 microsecond timer.
The previous output of the monostable is latched in IC32 and presented to the MC68000 via the input port.
The flip-flop IC32 is clocked and CASIRQ is lowered, interrupting the MC68000. The ECASRIRQ signal enables these cassette read interrupts. The cassette read interrupt software reads the data bit from the input port and resets the inter-rupt status by pulsing CLRCASIRQ low, thus presetting IC32.
Because the cassette I/O is software driven it is important that both the reading and writing interrupts be serviced by the MC68000 without any delay. For this reason the CASIRQ signal is put at a higher priority than any other interrupting device. (See ETI February for a discussion of interrupt priority levels.
During cassette writing CASIRQ is generated by programming one of the VIA’s internal timers to produce a continuous square wave on the PB7 pin. The flip-flop IC49 is clocked by this waveform and requests the interrupt if the ECASWIRQ (enable cassette write interrupt) signal is low.
A bit on IC18, the analogue multiplexer port, is used to drive transistor Q2 and the relay which software uses to stop and start the cassette motor.
Analogue input/output The analogue input/output is centred upon the IC20/IC21 8-bit digital-to-analogue converter circuit (DAC). This DAC is used for the following things:
General purpose analogue output and sound generation. The dual 4-to-1 to analogue multiplexer IC23 switches the buffered output of the DAC onto one of the four holding capacitors C39-C42. Although the voltage held on these capacitors will decay after a period, this technique enables us to produce four analogue signals using one DAC.
Analogue inputs. The 8-to-1 analogue multiplexer IC10 selects an input from amongst the joystick potentiometers and the six general purpose inputs and presents it to the comparator IC11. This comparator compares the selected input with the DAC’s output and a software successive approximations program is used to determine the input voltage level.
Sound output is produced by using the DAC to produce audio waveforms on C40 and C41. These are amplified by the dual audio amplifier IC13 and drive loudspeakers. Stereo sound is produced by quickly switching the output of the DAC between the two amplifiers.
The potentiometers RV1 and RV2 control the left and right output signal level and hence also serve as a balance control.
Low-level signals LEFTSIG and RIGHTSIG are available at the speaker connector for connection to audio equipment such as recorders and amplifiers.
The user port is a 34-way connector which makes available the 1616’s power supplies, eight I/O pins from the VIA, six analogue inputs, two analogue outputs and an interrupt input. This port permits the user to implement his own control and interfacing projects.
The expansion connectors The four 80-way expansion connectors make available various clock signals, the power supplies and all of the MC68000’s signals. They are designed to accept addon cards such as I/O expansion, disk controllers, memory expansion and coprocessors.
The 1616 is supplied with a construction manual which contains parts lists, circuit diagrams, further circuit descriptions and a step-by-step guide to constructing the project. An oscilloscope is highly desirable, however, a multimeter and a logic probe are sufficient tools for assembling the 1616. There are basically two ways to build the 1616. The first way is to simply solder in all the components, plug in all the ICs and turn it on. This may at first seem to be the fastest and easiest way. Unfortunately, the chances of the computer working first go are fairly slim. Neither does it provide the constructor with any insight as to how the computer works or how everything fits together.
The second way is called progressive assembly and test (PAT) and is the method described in the 1616 construction manual. PAT involves breaking the construction into a number of small, simple steps. Essentially breaking the 1616’s complex circuit into a number of smaller ones. As each step is completed, a number of simple checks are done ensuring that that step is working. If something is wrong it is corrected at this stage before proceeding to the next step. The steps are arranged in such a way that each will only work if the ones preceding it work, so you should never continue onto a step until the previous one works. By constructing the 1616 in this fashion, on completion of the last step everything should work. Also, by breaking the circuit up into a number of smaller ones, it gives a better understanding of how the computer functions.
Initial construction involves visual inspection of the board and components, then soldering in the resistors, IC sockets, capacitors and other discrete components. After verifying that this has been done correctly, the constructor proceeds to load the ICs into the sockets. Only 17 ICs are needed to get the MC68000 executing code from the EPROMs, at which stage the test programs in the 1616 EPROMs are used in concert with the construction manual to finish construction.
The setting of the quad DIL switch connected to IC19 is used by the MC68000 to determine which of the eight in-built test and diagnostic programs are to be executed. Some of the test programs generate waveforms for verifying circuit operation and debugging faulty circuitry whilst others perform internal tests and report their results.
The 1616’s EPROM-based operating system software was written by Andrew Morton, the chief designer of the 1616. The operating system (1616/OS) influences the ‘feel’ and the capabilities of programs which run under it, hence it has been designed to impose few limitations on the programmer. This software will be used by implementations of other operating systems such as Digital Research's CP/M 68K, GEM and OS-9.
The command line interface philosophy follows the standard scheme (like CP/M, MS-DOS/PC-DOS, UNIX, etc) of typing in commands followed by the arguments appropriate to the command and receiving some response. It is a disk operating system which can run without any disks — cassette tapes are used to load files into the RAM disk and any changed or new files are archived on tape at the end of the session. Commands are provided which make this a very simple operation. The software is designed to support add-on disks, or other devices with which data may be transferred in 512 byte quantities.
1616/OS includes a powerful line editor for entering commands which incorporates full cursor control, last line recall and an undo command. The keyboard's 10 function keys are user-definable and may contain up to 31 characters. When a command containing wildcards is entered the system scans the disk directory and substitutes any matching file names into the command before it is executed; the wildcard matches any group of characters and *T matches any single character.
When a command name is typed at the command line interface it is compared with the 60 available built-in commands and if it is not found then the operating system searches the disk for a file of that name. If one is found and it is executable, it is loaded into memory and executed. If the file is a text file its contents are executed in batch mode — parameters from the original command line are substituted into wildcard symbols in the text file and the resulting commands are presented to the command interpreter.
The command interpreter supports in-put/output redirection. This is a powerful feature which sets up the input source and output destination of the invoked command. A concept which must be understood is that of standard input and output. Most programs and built-in commands will obtain input from standard input and send output to standard output. Usually these will correspond to the keyboard and the VDU, however, the program does not know (and does not need to know) what physical devices these correspond to — this is up to the user who typed the command.
Standard input and output are reassigned to either I/O devices or disk files in the normal UNIX manner of using the ‘<’ and ‘>’ signs. Physical I/O devices require a character device driver program to be installed in the 1616’s memory before they may be used. A character device driver is identified by a name followed by a colon; the character device drivers available when the 1616 is powered on are:
CON: This driver obtains input from the 1616 keyboard and sends output to the VDU.
SA: The SA: driver obtains input from and sends output to serial channel A.
SB: The SB: driver obtains input from and sends output to serial channel B.
CENT: This driver directs output to the parallel printer port.
As an example let us suppose that we have a program for converting characters from lower case to upper case which resides in the RAM disk file ‘toupper’. This program should read characters from standard input, convert them to upper case and then write them to standard output. If we wish to use this program to convert characters coming into serial port A into an upper case file called ‘myfile’ we would type: toupper <sa: > myfile The command executor first redirects standard input to the SA: driver and opens a file called ‘myfile’ and directs standard output to it, then executes toupper. It is possible to direct standard output to append characters to a file, rather than creating a fresh one by using the ‘>>’ redirection command. Next month we will discuss the software including system calls, the full screen editor, the Assembler and 1616/OS commands in detail as well as some sneak previews of the latest developments . . . Gosh, this is exciting!
The 6522 Versatile Interface Adaptor (VIA) is a very flexible I/O control device. Control of peripherals is handled primarily through two 8-bit bidirectional ports. Each line can be programmed as either an input or output. Several of the I/O lines can be controlled directly from internal interval timers for generating square waves or for counting externally generated pulses. To facilitate control of the many features of this chip, an interrupt flag, interrupt enable and a pair of function control registers are provided.
Two 8-bit bidirectional I/O ports.
Two 16-bit programmable timer/counters.
Serial data port.
Expand handshake capability allows positive control of data transfers.
Latched input and output registers.
The Zilog Z8530 SCC is a dual-channel, multiprotocol data communications chip. The SCC functions as a serlal-to-parallel, parallel-to-serlal converter/controller. The SCC can be software configured to satisfy a wide variety of serial communications applications. The device includes on-chlp baud rate generators, digital PLLs and crystal oscillators that help reduce the need for external logic.
★ Two independent, 0 to 1 Mbit-second, full duplex channels, each with separate baud rate generation and digital PLL for clock recovery.
★ Asynchronous mode with 5 to 8 data bits and 1,1.5 and 2 stop bits per character; programmable clock factor; break detection and generation; parity, overrun, and framing error detection.
★ Synchronous mode with internal or external character synchronization on one or two synchronous characters and CRC generation and checking.
★ SDLC/HDLC mode with frame level control, automatic zero insertion and deletion, 1-field residue, abort, CRC generation and SDLC loop back.
★ Local loopback and auto echo modes.
The 1616 computer has been designed from the very beginning to be as simple to build as possible. We have tried to make the circuit as clean and reliable as possible. It is expected that you have constructed electronic kits before and/or have experience in digital electronics at either a hobbyist or professional level. If you are a complete beginner it might be best to try a smaller project first or make arrangements with a friend to help you just in case you get into trouble.
If you need a little hand-holding, you may wish to take advantage of the construction workshops conducted by Applix. Please contact Applix, 324 King Georges Rd, Beverly Hills, 2209, (02) 756-2688, for further details.
If your built up 1616 fails to operate and you can not troubleshoot the faults) you may wish to take advantage of the Applix ‘Fix it’ guarantee. Our technicians will check and repair your 1616 as required, for the flat fee of $150. This fee includes any necessary component replacements, etc, that may be have been damaged during or after construction. Your 1616 must be unmodified and must be constructed using decent IC sockets to use the ‘Fix It’ service. If a kit is so badly constructed as to make repair impossible we reserve the right to return the computer and the service fee, in the condition received. The ‘Fix It’ fee only covers the actual computer. It does not cover your power supply, keyboard, expansion boards, etc. It is ‘Fix It’ service only, not a construction service. We want to see your 1616 working as much as you do!
If you feel you are not capable of building the 1616 and are not interested in the construction workshops you may wish to return the kit in its original condition and purchase a built and tested 1616 or arrange a refund. We can not accept a return once construction has commenced, if any of the component packs have been opened, or if the kit or cartons have been damaged in any way. Please contact Applix concerning pricing of the built and tested 1616 and returns procedure.
ETI April 1987 — page 68
Project 1616
In this fourth article of this series we examine the operations of the 1616 computer and assess its viability in the market place.
SO FAR IN our series of articles about the 1616 we have completed the discussion of the design philosophy, the description of the electronics and the construction details. The discussion of the computer’s software commenced last month and now continues, with introductions to the 1616’s documentation, the 1616/OS commands, the screen editor, the assembler, and operating system calls.
An important consideration in the design of the 1616’s operating system software was to encourage the development or adaptation of application programs by third party programmers, either professional or enthusiast, for sale or distribution to 1616 owners. What programmers need to bring this about are programming tools and documentation.
The 1616’s documentation covers 206 pages and includes:
The construction manual (59 pages): a step-by-step guide to the construction of the 1616 and description of the 1616 circuitry, connectors, cabling, and the MC6800 bus, with schematic diagrams.
The 1616/OS User’s Manual (50 pages): discussion and documentation of the use of 1616/OS and its commands, including the line editor, the screen editor, disk files, I/O redirection, shell (batch) file programming, etc.
The 1616/OS Programmer’s manual (55 pages): description of the general approach to developing 1616 programs and the resources available to application programs, including the operating system calls.
The 1616 assembler manual (42 pages): all about the use of this MC68000 assembler.
There are 50 commands which are recognized and executed by 1616/OS. Because the actual MC68000 programs which these commands invoke are contained within 1616/OS these are called ‘inbuilt’ commands. Programs which are loaded from disk (or RAM disk) and executed are called ‘transient’ programs because they need only exist in memory as long as they are running, after which they may be overwritten.
EDIT, the 1616/OS inbuilt screen editor has been written so that its commands are compatible with the single line editor which is used for 1616/OS command entry.
The editor is used to read in, modify and then write out a disk-based file. It is very similar to MicroPro’s popular ‘Wordstar’ program in non-document mode. Like virtually all the resources of 1616/OS, the screen editor is accessible from within application programs and it is capable of operating within screen ‘windows’, so the standard screen editor may be integrated into another program running in the 1616. The command to enter the editor is:
EDIT FILENAME 7
The optional number after the file name specifies the width of the editor’s tab stops. With heavily indented files it is sometimes useful to reduce the tab stop width from the default of eight.
Once within the editor you are presented with a status line at the top of the screen. It shows status information, the current position within the file and the name of the current file. This line is also used for prompts during file access, searching and substituting.
An assembler macro is a prototype of a sequence of assembler instructions which is defined in your source file. You give the prototype a name when defining ft and henceforth whenever this name is used as an assembly source instruction the macro’s prototype is expanded out and assembled. Using a macro as an instruction in this manner is known as a ’macro invocation’. A macro invocation statement usually includes operands which modify the way in which the macro is expanded.
Macros are simply a fancy text substitution mechanism; there are various ways of controlling how the substitution occurs, and the eventual output is machine language source containing no macro invocations.
As an example, let us consider a section of 1616 assembler code which draws a diagonal line across the VDU screen:
move.1 #0,d1 * x start move.1 #0,d2 * y start move.1 #639,aO * x end move.1 #199,a1 * y end move.1 #53,d0 * line draw system call number trap #7 * perform the system call
A preferable approach to this is to use macros as follows:
drawline macro * macro prototype definition move.1 1,d0 * x start move.1 2,d2 * y start move.1 3,a0 * x end move.1 4,a1 * y end moveq.1 #53,d0 * call number trap #7 endm
Note that this macro produces no code output when its prototype is defined. We first need to invoke the macro, as follows: drawllne #0,#0,#639,#199 When this invocation is expanded out, each of the operands is slotted into the appropriate place in the prototype and the resulting text is assembled. Macros may be nested, which means that a macro prototype definition may include invocations of other macros.
The editor’s commands are control characters, or characters preceded by a control-Q (▲Q) or a control-K (▲K). The editor’s commands may be categorized as follows:
The cursor movement commands allow you to display and/or alter different parts of the text file by moving to different positions within it.
▲E up one line ▲QE up to top of page ▲R up one page ▲QR to start of file ▲D right one character ▲F right one word ▲QD right 80 characters ▲B start/end of line ▲X down one line ▲QX down to bottom of page ▲C down one page ▲QC to end of file ▲S left one character ▲A left one word ▲QS left 80 characters
The scroll commands move the screen display without altering the relative cursor position. Handy when you are used to them.
▲Z scroll up ▲W scroll down
There are a number of commands for deleting ranges of text before or after the cursor.
▲G delete char forward ▲T delete word forward ▲QY delete line forward ▲H,DEL,BS delete char backward ▲Y delete line ▲V delete line backwards
The block commands are used by marking out the beginning and end of a ‘block’ of text (which is then highlighted on the screen) and then manipulating this block as a whole.
▲KB mark block start ▲KK mark block end ▲KY delete marked block ▲KH hide block ▲KW write block to file ▲QB go to block start ▲QK go to block end ▲KV move marked block to cursor ▲KC copy marked block to cursor
Various file I/O commands and system access commands are available from within the editor.
▲KR read in (merge) a file ▲KX write out file, quit ▲KD write out file, continue editing
The miscellaneous commands include setting and moving to file markers, merging files, partial screen freezing, etc.
▲KQ exit without saving file ▲KE execute a 1616/OS command ▲QG go to line number ▲KF partial screen freeze ▲QF find pattern ▲L repeat last pattern find ▲KI escape to 1616/OS ▲K0- K9 set block markers 0 to 9 ▲Q0- Q9 go to a block marker ▲QA substitute pattern ▲N repeat last substitution
The partial screen freeze feature (▲KF) allows you to display part of the current file on the screen whilst editing a different part. This proves very useful for program editing. The ▲KI and ▲KE commands are particularly useful. They allow you to temporarily leave EDIT and execute a 1616/OS command(s). For instance, you may be editing an assembler source file, temporarily leave the editor and assemble it, then return to the editor exactly where you left off.
Application programs have available around 100 1616/OS internal functions, many of which have several modes of operation. The process of calling one of these functions is referred to as a ‘system call’.
The available system calls are divided into the following broad categories:
These functions alter the configuration of the 1616 or call general purpose internal 1616/OS routines.
The character I/O functions perform input, output and status calls on character device drivers.
These functions include all the standard file control routines as well as block device driver calls.
The video control functions include the simple calls to change colours, etc, as well as the text/graphics window control functions.
The graphics functions are related to the video functions, particularly where windows are defined,
There are a number of system calls which manipulate I/O devices. Use these wherever possible, rather than directly manipulating I/O devices.
A system call is performed by putting the call number into d0 (data register zero) and any required arguments into d1, d2, a0, a1 and a2 and then executing the 68000 ‘TRAP #7’ instruction. If the system call does not require five arguments then not all of these registers need be initialized .
Any return value from the system call will be in d0. If the system call does not return a value then the contents of d0 are undefined. All system calls preserve all registers except d0, however, it is poor programming practice to reply upon this. All parameters passed to system calls are considered to be long integers (32-bit quantities). The returned value is also a long.
Normal 1616 programs will make extensive use of system calls; for this reason an assembler macro package which greatly simplifies the use of system calls comes with the 1616 assembler. An example of a system call is given below.
The 1616 assembler is supplied on tape with the 1616 system. The assembler was written by David Farb of Farbware, Illinois and it was adapted to the 1616/OS environment by Andrew Morton of Ap-plix. SSASM is a two-pass assembler which reads in a source file which contains standard Motorola MC68000 machine code mnemonics and writes out an executable program file. Source files may be produced using the 1616/OS editor.
The assembler supports the use of ‘include files’, which are disk files which contain common storage definitions, label assignments or macro definitions which may be included in programs at assembly time, thus reducing file sizes and promoting consistency in the use of labels and macros. Conditional assembly is also there; the assembler has pseudo-instructions which may be used to control whether or not sections of code should be assembled.
SSASM also sports that most useful feature: assembly macros (see box). There is a file supplied with SSASM which contains macro code for performing each of 1616/OS’s 100-odd system calls. This file may be ‘included’ in other programs so that the programmer can encode system calls in a quicker, more readable and less error-prone manner. The SSASM tape includes some demonstration programs which show the use of the assembler, system calls and the system call macro include file.
It is desirable that 1616 programs blend into the 1616/OS environment by working in a standard, predictable manner. The program conventions which should be observed are:
Programs should, where possible, obtain their user-provided information from the command line arguments.
If a program detects an error on the command line it should print out a usage message in a standard format.
Programs should not produce unnecessary output. Programs which display copyright messages, programmer’s names, version numbers, etc, are often awkward to use in an operating system with the I/O redirection features of 1616/OS.
The standard start address for programs is $4000, however programs may be loaded in at higher addresses. The arguments which were typed on the command line when a program is run are accessible from within that program. These arguments are such things as file names, option selections, numeric data, etc.
A program has available to it all of the memory from $4000 to the bottom of the machine stack. The amount of available memory depends upon the selected RAM disk size. The usual free memory size is 1/4 of a megabyte.
The memory usage map for a 1616 with a 256K RAM disk selected is as follows:
$00000-$003FF machine vector table and some system use $00400-$033ff 1616/OS internal data areas $03400-$03bff unused, free for application programs $03c00-$03fff unused, reserved by Applix $04000-$3fe00 (approx) application program code, data and stack areas $40000-$41fff 1616/OS file buffer area $42000-$7ffff RAM disk storage area and checksum tables
The in-built commands are all listed here as a guide to the features of 1616/OS.
MDB, MDW, MDL: memory dump byte, word, long
MRDB, MRDW, MRDL: memory repetitively dump byte, word, long
MWB, MWW, MWL, MWA, MWAZ: memory write byte, word, long, ASCII, nul-terminated ASCII
MFB, MFW, MFL, MFA: memory fill byte, word, long, ASCII
MCMP: compare memory blocks
MSEARCH: search memory for byte pattern
MMOVE: memory block move
MSAVE: save memory on disk file
MLOAD: load disk file into memory
CHTYPE: change the type of file(s)
COPY: copy and/or join files
DELETE: delete flle(s)
DIR, DIRS: directory listing
RENAME: change a file’s name
LOG: log onto a new block device
TSAVE: save disk file(s) on tape
TARCHIVE: save changed disk files on tape
TLOAD: load a file from tape
ITLOAD: load all files from tape
TVERIFY: verify all files on tape
BASE: convert number(s) to and from binary, decimal or hex
EXPR: evaluate an arithmetic expression
CIO: copy characters from standard input to standard output
ECHO: echo command line arguments onto standard output
EDIT: edit a file
FKEY: reprogram a function key
GO: execute a machine language program
HELP: obtain help about in-built commands
PAUSE: temporarily suspend command processing
QUIT: exit from command interpreter
SERIAL: reprogram a serial port
SETDATE: set current date/time
SREC: load S-records
SSIO: reassign standard input/output devices
SYSCALL: manually perform a system call
TERMA, TERMB: enter serial terminal mode
DATE: display current time/date
The first and most obvious question everyone has asked when enquiring about or purchasing the 1616 is “when will the disk controller be available?”. The answer is, very soon. We have already started work on the controller and will have some definite details, pricing, etc, in the next article.
You must keep in mind that these articles are written six to eight weeks in advance of publishing. As this is being written in early February, it is highly probable that by the time the article is in print a demonstrable prototype will be up and running. Thus if your curiosity gets the better of you, contact Applix directly.
Again, by the time you read this article, a full featued BASIC interpreter will be available. This will run on both tape- and disk-based systems and will cost around $50.
What about disk operating systems? A new release of 1616/OS will be supplied with the disk controller. This is simply a matter of adding a block device driver but we will also be adding some more features. Any programs developed on tape can be simply loaded into the RAM disk and transferred to disk. We are looking at porting a full C compiler to 1616/OS.
Applix will be endeavouring to port Digital Research’s GEM operating system to the 1616. Briefly, GEM is a window-based operating system very similar to that on Apple’s Macintosh. This is the same operating system as the Atari ST series uses, and will allow the 1616 to run many of the commercial software packages available for that machine including many programming languages.
We have a number of third party developers looking at porting Microware’s OS-9 operating system and also Whitesmith’s UNIX look-alike, IDRIS to the 1616.
We were astounded by the variety of people interested in the 1616, and expect to reach our target of 500 units shortly. The more people who buy it, the more opportunity we have to develop new products for it, the better it will be for everyone.
It seems that a lot of people are sick of the typical off-the-shelf, box computers and there is a real demand for down-to-earth, affordable systems.
Any hardware or software developers interested in doing work with the 1616 should contact Applix. We are willing to offer any help or advice to get new products off the ground and to discuss marketing opportunities.