Hubbry Logo
General Instrument CP1600General Instrument CP1600Main
Open search
General Instrument CP1600
Community hub
General Instrument CP1600
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
General Instrument CP1600
General Instrument CP1600
General Instrument CP1600
View on Wikipedia
from Wikipedia
The Intellivision video game console was the only widespread application of the CP1600 family.

The CP1600 is a 16-bit microprocessor created in a partnership between General Instrument and Honeywell, introduced in February 1975.[1][2] It is one of the first single-chip 16-bit processors. The overall design bears a strong resemblance to the PDP-11.

Honeywell used the CP1600 in a number of process control computers and related systems, but its most widespread use was the CP1610 version in the Intellivision video game console. The 1610 was essentially a slower version of the 1600, running at a maximum speed around 2 MHz instead of the 3 to 5 MHz of the 1600.

The system saw little other use due to General Instrument's marketing philosophy of seeking out customers only with very large orders and ignoring smaller customers. They also did not pursue a second source arrangement, which in the early days of microprocessor designs was a requirement for most potential customers.[3]

Description

[edit]

Physical implementation

[edit]
CP1600 pinout

The CP1600 was implemented in enhancement mode nMOS and required +12, +5, and −3 V power supplies; I/O connections except for the clocks were TTL (5 V) compatible.[a] Each microstate or processor cycle uses four internal time slots generated by two non-overlapping clocks. A 3.3 MHz two-phase clock produces a 600 nanosecond microcycle. A 5 MHz two-phase clock produces a 400 nanosecond microcycle. Due to the voltage requirements of the clock signals, these had to be generated with external circuitry, as was common in this era of microprocessor design.[3]

In order to fit a 16-bit processor into a 40-pin dual in-line package (DIP) chip design, the CP1600 multiplexed its data and address pins. This allowed a set of 16 pins to be used for both address selection and reading and writing data, but to do so required two bus cycles. It also complicated the overall machine layout as buffers were required on the memory bus to latch the address while the processor switched the pins to data mode. The interface to the system was likewise complex, requiring three pins, BDIR, BC1 and BC2, which had to be decoded to understand what state the memory bus was in.[4]

A relatively uncommon feature of the CP1600 was its "external branch" concept. The BEXT instruction opcode left the lower four bits of the code free, leaving it to the programmer to place a number in those four bits. When the opcode was called, any of those four bits set to high (1) would be expressed as high voltages on the external pins EBCA0 through EBCA3. This was normally used to select one of up to 16 external devices. The selected device would then respond by setting the EBCI to high if it wanted to communicate. If EBCI was high, the branch address provided with the BEXT would then be taken, if EBCI was low, the branch would be skipped.[4] This could be used, for instance, to test whether an external device had input data that needed to be processed; the processor could express the value "2" on the EBCA to sample device 2, call the BEXT, and that device would then respond by setting EBCI to true if there was data, causing the processor to jump into the device driver code to read the data from that device.

This contrasts with the typical solution for handling external devices; most systems have the devices raise an interrupt which causes the processor to call special code, the interrupt handler, which then reads additional data to determine which device called the interrupt. This additional data may be presented using dedicated pins on the CPU, but is more commonly presented as a value on the data bus. Based on that value, the interrupt handler code then decides which device driver to call to process the data. The CP1600 can implement this in fewer instructions; the interrupt handler is simply a series of BEXT instructions pointing at the associated drivers which it runs through one at a time until the device in question sets the EBCI and automatically cause the code to branch.[5]

In total, implementing a system using the CP1600 often required additional support chips and logic. This included a system to multiplex sixteen signals into a single pin if the external branching was being used, and a three-bit-to-eight-line converter to avoid having to decode the bus status signals in external parts.[3]

Instruction set and registers

[edit]
CP1600 registers
15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 (bit position)
Main registers
R0 Register 0 / Accum
R1 Register 1 / Indirect
R2 Register 2 / Indirect
R3 Register 3 / Indirect
R4 Register 4 / Autoincrement
R5 Register 5 / Autoincrement
R6 / SP Register 6 / Stack Pointer
R7 / PC Register 7 / Program Counter
Status flags
  S Z OV C Status Flags

The smallest unit of addressable and writable memory is the 16-bit word; byte addressing is not supported. The CP1600 can address 64K words, or in modern terms, 128 kbytes. Of the 16-bits available in an instruction opcode, the CP1600 used only 10. The remaining 6 bits were marked "Future Use."[6] The 10-bit instructions meant that code stored in a typical byte-oriented ROM would waste six bits per instruction. In the era of expensive memory, this was a significant issue. To address this, General Instrument also produced special 10-bit ROMs that efficiently stored the instructions. As data and addresses would still require 16-bit values, the 1600 included a special SDBD instruction that pieced together a 16-bit argument from two 10-bit ROM reads.

The unused 6 bits were intended to be used with co-processors, asserting the PCIT line which stalled the CPU until released. Early documentation shows two planned chips in the series, the 1616 which added the "Extended Instruction Set", and the 1618 "Priority Expander".[7]

The system included 87 basic instructions. Instructions might be one to three words long depending on the addressing format and whether 10-bit or 16-bit program memory was being used.[4] The CP1600 did not support memory-memory indirect addressing (offsets), and indexing was implemented using a dedicated adder that performed single-cycle changes to addresses in registers. The arithmetic logic unit (ALU) was 8 bits wide and could add two 16-bit internal registers in 2.4 microseconds, and memory to register adds of 16-bit numbers in 3.2 microseconds.[8]

Like the PDP-11, the CP1600 used eight 16-bit "general purpose" processor registers, although they were not truly general-purpose as in modern designs. Only R0 had no pre-defined purpose and has been described as "the primary accumulator".[9] R1 through R3 could be used data pointers, generally used for register-based addressing ("implied addressing"). R4 and R5 autoincremented after being accessed, which made them useful for looping over collections of data.

R6 was the stack pointer, R7 the program counter. Since both of these registers were visible to the programmer, they could be used to implement multiple stacks, or support more complex branching, among other things. There were no explicit stack PUSH or POP instructions. When R6 was used in a "read" operation it decremented the address and then returned the data being pointed at, the equivalent of a POP; when it was used in a "write" it would write then post-increment (like with the autoincrementing registers R4/R5), simulating a PUSH.

Example code

[edit]

The following assembler source code is for a subroutine CPYMEM that copies words from one location to another. Note that R4 and R5 autoincrement after being accessed. This makes it easy to loop through an array of words. Curiously, the CP1600 has a 16-bit word width but only a 10-bit instruction width. The following assumes 10-bit ROMs are being used.[10] 

 
 
 
 
1000
1000 284
1001 245
1002 013
1003 22C 004
1005 097 
1006

; Copy memory words addressed by R4 to location addressed
; by R5 for a length of R3 words. Return address in R2.
; @@loop is a local label
        ROMW    10           ;Assume 10-bit program memory
CPYMEM  PROC
@@loop: MVI@    R4,R0        ;Get word to copy: MOV (R4)+,R0
        MVO@    R0,R5        ;Save word: MOV R0,(R5)+
        DECR    R3           ;Bump word counter
        BNEQ    @@loop       ;Continue for all words
        JR      R2           ;Return to caller: MOVR R2,PC
        ENDP

I/O

[edit]

As was common for the era, the CP1600 used memory-mapped I/O, as opposed to separate I/O pins as seen on the Intel systems. The use of a multiplexed bus and multi-state bus status made implementing I/O more difficult than would normally be the case on memory-mapped systems. This meant that implementations had to use latches or buffers to be able to interface with the CPU as it changed the bus from indicating an address to data.[9] This both negatively affected I/O performance and increased the complexity of the I/O devices.

To address this problem, GI supplied a series of 164x dedicated I/O chips that implemented the required bus logic. These included, for instance, the 1641 keyboard controller, the 1643 cassette tape controller, and the 1647 display control.[7] Most famous among these is the 1640 "Programmable Interface Controller", or PIC, which was designed to work in concert with the CP1600 and act as a channel controller for the CPU. As with the other 1640 series chips, the PIC internally decoded the bus logic, but also added a very simple processor that could run its own programs to perform I/O and direct memory access. For instance, one might send an instruction to a PIC on a floppy disk card to read data from a given sector on the disk. The PIC would then read the data into its own internal buffer, watch the bus for unused time when the bus status pins were all zero, and then send data to main memory.[7]

General Instrument provided cross-assemblers and simulators/debuggers compatible with 16-bit or larger minicomputers.[10] GI also provided a standalone CP1600 based microcomputer system in the GIC1600.[11]

Uses

[edit]

The CP1610, used in game consoles such as the Champion 2711[12] and most notably the Intellivision, is a compatible member of the 1600 microprocessor family. It uses a 2 MHz two-phase clock producing a 1 microsecond processor cycle. The CP1610 in the NTSC Intellivisions uses a 1.7897725 MHz two-phase clock. Although users of the CP1600 in the traditional computer role were relatively rare, over 3 million Intellivisions were produced from 1980 until the video game crash of 1983 led to the closing of the Intellivision production lines in 1984.[13]

Production of the CP1600 ended in 1985 when General Instrument spun off its microelectronics division to create Microchip Technology. By this point a number of 32-bit designs like the MC68000 were available that limited interest in a 16-bit design like the CP1600, and their main existing customer, the Intellivision, was no longer in production. Many other products were also end-of-lifed at the same time, and their primary product was the PIC.

Notes

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

General Instrument CP1600

View on Grokipedia
from Grokipedia
The CP1600 is a 16-bit microprocessor developed by in partnership with and introduced in 1975 as one of the first commercially available NMOS 16-bit processors. Loosely based on the PDP-11 architecture, it features a single-chip N-channel MOS-LSI design with a 5 MHz two-phase clock, 400 ns processor cycle time, and support for 65,536 words of 16-bit memory addressing. The CP1600 includes eight general-purpose 16-bit registers (R0–R7, with R7 as the and R6 as the stack pointer), an for 16-bit operations, and memory-mapped I/O capabilities, enabling efficient instruction execution in 1.6 to 4.8 µs. Key features of the CP1600 encompass an 87-instruction set with addressing modes including immediate, direct, register indirect, and relative, alongside unique elements like two programmable interrupt lines with priority levels, (DMA) channels, and 16 external sense conditions for conditional branching via the BEXT instruction. Housed in a 40-pin , it operates on +5 V, +12 V, and -3 V supplies and was targeted at industrial process-control applications, such as Honeywell's Multifunction Controllers. A variant, the CP1610, powered the home video game console released in 1979, marking one of its most notable consumer applications. Despite its advanced capabilities for the era, the CP1600 saw limited adoption and was discontinued from General Instrument's catalog in the early due to insufficient design wins and lack of supporting peripheral chips.

History

Development

The development of the CP1600 originated from a joint partnership between Microelectronics and in the early 1970s, aimed at creating a 16-bit tailored for industrial process-control and embedded applications. This collaboration leveraged 's expertise in MOS LSI fabrication and 's needs for reliable control systems, resulting in a design focused on integrating capabilities into a compact form factor. The effort was driven by engineers including Jeff Stein at , who initiated work around 1973 to address demands for programmable controllers in industrial settings. The CP1600's architecture drew loose inspiration from minicomputer designs like the PDP-11, adapting its register-based processing and addressing modes for single-chip implementation. This influence emphasized efficient 16-bit operations while incorporating third-generation minicomputer features, such as multiple general-purpose registers, to support versatile computing tasks. The chip was fabricated using N-channel MOS ion-implant technology, specifically General Instrument's GIANT II process, which enabled high-speed performance through enhanced transistor density and reliability in a 40-pin DIP package. This technological choice facilitated the transition from multi-chip minicomputer systems to a standalone microprocessor suitable for space-constrained environments. Key engineering objectives centered on delivering robust 16-bit processing power with low power consumption and minimal physical footprint, enabling standalone systems for real-time data processing and control. The prioritized simplicity in hardware-software integration, supporting up to 64K words of addressable and multi-level interrupts to handle complex embedded tasks without excessive external components. Development milestones included initial prototyping in 1973, with iterative refinements leading to production readiness by 1975, as documented in General Instrument's user manuals and data catalogs.

Introduction and production

The General Instrument CP1600 was introduced in February 1975 as the first commercially available single-chip 16-bit , developed in partnership with . It debuted as the core component of the Series 1600 family, which encompassed a range of compatible devices designed for high-speed and real-time applications. Full commercial availability of the Series 1600 lineup, including the CP1600 and supporting modules, occurred by fall 1975. The CP1600 was fabricated using NMOS ion implant large-scale integration (LSI) technology and housed in a 40-pin dual in-line ceramic package to enable compact system designs. Initial production focused on achieving viable yields for the complex 16-bit architecture, which required three power supplies (+12V, +5V, and -3V) and multiplexed address/data buses to fit within the pin constraints. As production scaled, expanded the Series 1600 ecosystem to include compatible static RAMs (such as the 256x4 device), mask-programmable ROMs, and peripheral support chips like the CP1680 controller, facilitating complete systems without extensive external logic. Key variants of the CP1600 included the base CP1600 CPU itself and the CP1610, an enhanced iteration optimized for with improved I/O compatibility and processing efficiency for applications like video games. Later production introduced ROM-integrated versions tailored for dedicated tasks, such as in embedded systems, to reduce external memory requirements. In marketing materials, positioned the CP1600 as "the world's most powerful 16-bit ," emphasizing its minicomputer-like capabilities. Prototype units were priced around $150, while volume production in 1975 brought costs down to under $100 per unit in quantities of 500 or more.

Architecture

Physical implementation

The General Instrument CP1600 is implemented as a single-chip MOS-LSI using N-channel ion-implanted enhancement-mode technology based on the GIANT II process. This construction enables high-density integration on a monolithic die, housed in a 40-pin (DIP) made of ceramic for reliability in industrial and embedded applications. Electrically, the CP1600 operates with a two-phase non-overlapping clock input at a maximum of 5 MHz, corresponding to a 400 ns time, with clock pulse widths of at least 70 ns and rise/fall times between 5 ns and 15 ns. It requires three power supplies: +12 V (VDD, 11.4–12.6 V, typical 70 mA draw), +5 V (VCC, 4.75–5.25 V, typical 12 mA draw), and –3 V (VBB, –3.3 to –2.7 V, typical 1 mA draw), resulting in a typical power dissipation of approximately 900 mW. Input/output levels are TTL-compatible, with high-level inputs at 2.4 V minimum (up to VCC), low-level inputs at 0.65 V maximum, high-level outputs at 2.4 V (100 µA source), and low-level outputs at 0.5 V (1.6–2.0 mA sink). The pinout supports a multiplexed 16-bit bidirectional / bus (D0–D15) along with control signals for interfacing. Key pins include:
PinNameFunction
6–15, 16–21D0–D1516-bit bidirectional bus; multiplexed for output during bus available read (BAR) state.
3BC1*Bus control output (active low).
4BC2*Bus control output (active low).
5BDIRBus direction output (high for CPU output).
27INTRM*Maskable input (active low).
28INTR* request input (active low).
37φ2Two-phase clock input 2.
38φ1Two-phase clock input 1.
36VDD+12 V .
34VCC+5 V .
35VBB–3 V .
39GNDGround.
The CP1600 integrates into the Series 1600 ecosystem via its single multiplexed bus, supporting external RAM and ROM up to 64 kilowords () and enabling multi-chip configurations through bus buffering and control signals for expanded systems. This design facilitates direct connection to compatible modules like the RM1600 series without additional address decoding for basic setups.

Registers and data processing

The General Instrument CP1600 features a consisting of eight 16-bit general-purpose registers, labeled R0 through R7, which are fully addressable by the for arithmetic, logical, and movement operations. These registers serve as the core of the processor's data processing architecture, enabling flexible use as accumulators or pointers without dedicated specialization beyond two key roles. Among these, R7 functions as the (PC), automatically incrementing to fetch the next instruction during execution, while R6 acts as the dedicated stack pointer (SP), facilitating push and pop operations on a stack of unlimited depth for subroutine handling and interrupts. The remaining registers (R0 through R5) support general-purpose tasks, with R0 often serving as the primary accumulator, R1 through R3 as data counters, and R4 through R5 as auto-incrementing data counters to aid in traversal. The CP1600 processes data primarily in 16-bit integer format, representing signed values within a 65,536-word , with no native support for . Byte-level handling is achieved by internally treating 16-bit words as two 8-bit bytes, allowing selective access to low or high bytes during operations, though the external data bus transfers full 16-bit words in parallel. At the heart of data processing is the (ALU), an 8-bit wide component that performs operations on 16-bit register contents by processing byte pairs sequentially. The ALU supports and for arithmetic, along with logical operations including AND, OR, and XOR, as well as compare functions to set status flags based on results. Shift operations—encompassing logical, arithmetic, and circular variants in left or right directions—are executed on register pairs, accommodating shifts from 1 to 16 bits to enable efficient across the full word length.

Instruction set

The General Instrument CP1600 instruction set comprises 87 basic instructions, each encoded as a single 16-bit word to facilitate compact program storage and efficient decoding. The 10-bit opcode field in the lower portion of the instruction word specifies the operation, while the remaining bits allocate space for operand selection, such as 3-bit fields for source and destination registers from the 8 available general-purpose registers, and a 3-bit mode field for addressing variants. This format supports flexible operand specification, including register pairs for 16-bit operations and immediate values integrated directly into the instruction, allowing programmers to perform complex tasks without additional fetch cycles for constants. Addressing capabilities are central to the CP1600's versatility, encompassing register-to-register transfers for rapid internal processing, register-indirect modes using an at-sign (@) prefix to dereference a register's contents as a , and immediate modes that embed 8-bit or 16-bit constants directly in the instruction stream. Branching employs relative addressing, where offsets are added to the for conditional or unconditional jumps, promoting . All modes operate within a uniform 16-bit linear spanning 65,536 words (64K), enabling seamless access to the entire memory map without segmentation or banking restrictions. The instruction repertoire is organized into distinct categories to support a range of computational needs. Arithmetic and logic instructions form the core, exemplified by ADD (add source to destination with carry handling), SUB (subtract with borrow), and CMP (compare for equality or magnitude, setting status flags without altering operands); these operations treat data as signed or unsigned 16-bit integers and update flags for conditional branching. Data movement is handled efficiently through LOAD (load immediate or memory value into a register), STORE (write register contents to memory), and EXCH (swap values between two registers or register and memory), minimizing overhead in data handling routines. Control flow instructions enable constructs, with BR providing unconditional or conditional branches based on status flags like zero or carry, CALL initiating subroutines by pushing the return address onto the stack (using register R6), and RET popping the stack to resume execution. Shift instructions such as SHR ( right, filling with zeros) and ASL ( left, preserving the sign bit for signed operations) support and multiplication/division by powers of two, often in a single cycle when operands are registers. These categories collectively allow the CP1600 to execute algorithms ranging from simple arithmetic to nested procedure calls, leveraging the register file for operands as outlined in the processor's architecture. Execution follows a streamlined model optimized for performance: register-to-register instructions complete in a single cycle via direct paths in the ALU, while memory-involved operations span multiple cycles to account for bus contention and address generation. The design relies on hardwired decoding logic rather than , translating opcodes directly to control signals for predictable timing and low latency in embedded applications.

Interfacing

Input/output mechanisms

The CP1600 lacks dedicated input/output ports, relying instead on its 16-bit bidirectional address/data bus for all external through memory-mapped or programmed I/O techniques. This unified addressing scheme treats peripherals as part of the 65,536-location memory space, allowing the CPU to access devices using standard load and store instructions such as MVI (move immediate) and MVO (move output), which target specific bus addresses via direct, indirect, or indexed modes. For example, writing to a peripheral involves outputting an address during the BAR (bus to address register) state, followed by data during the DW (data write) and DWS (data write strobe) states, while reads reverse this process with data input via the DTB (data to bus) state. External devices are supported through dedicated programmable interface controllers, such as the I/O 1600 module, which handles parallel-to-serial conversion and communication with peripherals like teletypes, high-speed readers/punches, or devices. These controllers integrate with the CP1600's bus, providing four channels (two for receivers, two for transmitters) and software-addressable ports for data transfer, enabling full-duplex operations at speeds up to 300 characters per second for reading. The bus employs three primary control signals—BDIR (bus direction), BC1, and BC2—to manage operations, decoding into eight states that include read/write strobes (e.g., DWS* for writes, DTB for reads) and via the SYNC* signal, which aligns external devices with the CPU's time slot 4. Additionally, bus request (BUSRQ*) and acknowledge (BUSAK*) signals facilitate external access, allowing the CPU to relinquish control after completing an instruction. The CP1600's direct I/O performance is limited by its dynamic logic design, which requires wait states via BDRDY* to be shorter than 40 µs to prevent register state loss, often making complex peripheral handling inefficient without assistance. This weakness led to the use of co-processors like the PIC1650 programmable interface controller in later systems, which offloads intelligent I/O tasks such as protocol management and buffering from the main CPU.

Interrupt and DMA support

The CP1600 provides dedicated support for handling through two distinct input lines: the non-maskable INTR* signal, which holds the highest priority and is always honored regardless of the processor's enable state, and the maskable INTRM* signal, which operates at a lower priority and is only processed if the (INTFF) is set via enable/disable instructions. These low-active signals are sampled during every timing state TS1 of the processor cycle, ensuring responsive detection of asynchronous events. vectoring can direct the (, stored in register R7) to either fixed memory locations dedicated for service routines or to addresses specified dynamically by external registers or logic, facilitating flexible routine entry points. Upon detection of an active interrupt, the CP1600 automatically saves the current PC contents to the memory stack, with the stack pointer (register R6) incremented after the push operation to maintain stack integrity. This hardware-managed context save occurs after the completion of the next interruptable instruction, minimizing disruption to ongoing execution. The interrupt processing sequence then involves priority resolution using the INTAK* acknowledge output in a daisy-chain configuration and fetching the service routine address via the interrupt address bus (IAB) inputs, resulting in an overhead of 4 to 8 machine cycles depending on the specific vectoring path and external setup. To terminate the interrupt service routine and restore normal execution, software issues the TCI (Terminate Current Interrupt) instruction, which generates a high-active pulse on the TCI output pin after 4 cycles, signaling external logic to deassert the interrupt request and allowing the stacked PC to be popped back into R7. Direct memory access (DMA) is supported via dedicated bus arbitration pins: the low-active BUSRQ* input, which allows an external DMA controller to request control of the address and data buses, and the corresponding low-active BUSAK* output, which the CP1600 asserts to acknowledge the handover. Upon receiving BUSRQ*, the processor completes its current machine cycle, enters an indefinite wait state by halting further instruction fetches, and tristates its bus drivers, enabling transparent DMA transfers without software intervention or loss of internal state. The CPU resumes operation automatically when BUSRQ* is deasserted, incurring a brief additional delay of 2 non-active (NACT) cycles to re-acquire the bus. This mechanism ensures efficient offloading of high-bandwidth data movement to peripherals while the processor remains in a suspended but recoverable state. For systems requiring more than basic dual-priority interrupts, the CP1600 enables multi-level interrupt capability through integration with external priority encoders or daisy-chain networks connected to the INTAK* and IAB pins. This external hardware performs vector generation and prioritization among multiple sources, supporting up to 16 distinct vectors while preserving the internal non-maskable and maskable priorities. Such configurations allow nested interrupts, where lower-priority routines can be preempted by higher ones, with the processor's automatic stacking ensuring proper context preservation across levels.

Applications

Embedded systems

The General Instrument CP1600 found significant adoption in embedded systems for industrial applications, particularly in programmable controllers and systems by 1976, where its 64K-word addressing capability enabled efficient process monitoring across extensive memory spaces for sensor data and control parameters. Developed in collaboration with , the CP1600 powered process control computers, such as Multifunction Controllers, facilitating real-time oversight in environments like oil refineries and traffic systems. This addressing range supported the integration of multiple input channels for analog-to-digital conversion and data logging, making it suitable for monitoring complex without frequent memory swaps. The processor was often used in process controllers and peripheral controllers, leveraging General Instrument's Series 1600 development kits, such as the GIC1600 System, which provided modular hardware including modules, I/O interfaces, and card files for prototyping control applications. These kits facilitated the connection of peripherals like A/D converters, lines, and tape drives, enabling direct memory-mapped I/O for automated manufacturing and networked industrial equipment. In these systems, the CP1600's supported direct memory-mapped I/O, simplifying the handling of control signals for automated manufacturing and networked industrial equipment. In real-time tasks, the CP1600's 5 MHz two-phase clock, yielding a 400 ns microcycle, enabled execution rates adequate for interfacing and logic control in time-sensitive embedded environments. This performance allowed for rapid polling of inputs and updating of outputs in control loops, with instruction times ranging from 1.6 to 4.8 µs supporting operations like register additions and memory accesses essential for responsive automation. The processor's vectored interrupts and DMA channels further enhanced its suitability for multitasking in dynamic processes. Case studies highlight the CP1600's deployment in intelligent terminals and peripheral controllers, where its 16-register streamlined development by minimizing accesses and enabling efficient manipulation directly in registers. For instance, in terminal applications, it managed CRT displays and keyboard inputs with low-latency , while in peripheral controllers, it handled teletype and cassette interfaces for reliable handling in industrial setups. This register-rich design reduced code complexity, allowing developers to implement control logic with fewer instructions and improved reliability in embedded .

Consumer electronics

The General Instrument CP1600 found significant application in , particularly in early consoles and television systems, where its 16-bit architecture enabled efficient handling of user interfaces and multimedia processing. A prominent example is its use in the , launched in 1979, where a variant known as the CP1610 served as the primary . This processor managed game logic, graphics rendering, and overall system control at clock speeds around 1-2 MHz, supporting sophisticated for the era. In the Intellivision, the CP1610 was integrated with specialized co-processors and interface chips from , such as those in the PIC family, to handle tasks for and . This configuration facilitated a 16-color display palette and three-channel audio synthesis, enabling complex visuals and interactive experiences that distinguished the console from 8-bit competitors. Beyond gaming, the CP1600 powered all-solid-state TV tuners developed by , replacing traditional mechanical rotary systems for channel selection and . These tuners leveraged the processor's instruction set for precise control of electronic tuning circuits, improving reliability and reducing manufacturing costs in home television sets during the late . The CP1600 also appeared in other consumer devices, including programmable calculators and early home entertainment systems, capitalizing on its versatile instruction set for user-friendly interfaces and computational tasks.

Legacy

Technological influence

The General Instrument CP1600, introduced in 1975, represented one of the earliest single-chip 16-bit , utilizing NMOS technology to deliver enhanced processing capabilities compared to prevailing 8-bit designs. This architecture facilitated more efficient handling of complex computations in resource-constrained environments, influencing the transition toward higher-wordsize processors in embedded applications where greater addressable and data manipulation were essential. By providing a complete 16-bit data path and up to 65,536 words of addressable in a compact 40-pin package, the CP1600 demonstrated the viability of scaling microprocessor word lengths for non-general-purpose computing tasks, paving the way for subsequent 16-bit embedded systems that prioritized over minimal pin counts. The CP1600's design also underscored limitations in integrated I/O capabilities, as its memory-mapped I/O approach lacked dedicated peripheral support and required complex , resulting in suboptimal for input/output-intensive operations. This shortfall highlighted the necessity for specialized peripherals to complement central units, spurring innovations in hybrid architectures that integrated microcontrollers with main processors to offload I/O tasks and improve overall system efficiency. addressed this by developing the PIC1650 as an 8-bit I/O controller specifically for the CP1600, which evolved into a foundational line of standalone microcontrollers emphasizing robust peripheral integration and reduced bus complexity. In the market, the CP1600 contributed to broadening the application of microprocessors beyond traditional computing into consumer and industrial domains, notably powering devices like the game console through its variant, the CP1610. This helped establish microcomputers as reliable components for and control systems, demonstrating scalability in production volumes for specialized hardware. Educationally, the CP1600 served as a key reference in early literature, featured prominently in the Osborne 16-Bit Microprocessor Handbook (1981) for its instruction-rich design, including eight general-purpose registers and support for multiply/divide operations, which positioned it as a benchmark for evaluating advanced 16-bit architectures in academic and engineering contexts.

Derivatives and successors

The CP1610, introduced in 1979, served as a direct derivative of the CP1600, featuring modifications for enhanced integration in systems, including expanded capabilities tailored for direct (DAC) interfacing to support graphics and sound generation. This variant retained the core 16-bit architecture but optimized timing and power for consumer applications, such as its use in the console unveiled in 1979. Additionally, produced ROM-masked versions of the CP1600 family, where the read-only memory was customized during fabrication for specific embedded applications, reducing costs and size in high-volume production like dedicated TV game circuits. In 1976, General Instrument developed the PIC1650 as an 8-bit microcontroller to complement the CP1600, primarily addressing the original processor's limited bus and I/O performance by acting as a dedicated peripheral controller with on-chip RAM, ROM, and interfacing logic. Featuring a Harvard architecture, 12-bit instructions, and a 2-level stack, the PIC1650 enabled efficient handling of input/output tasks without burdening the main 16-bit CPU. This design evolved into the broader PIC family through subsequent iterations like the PIC1664 and PIC1670, which expanded memory and stack depth, eventually transitioning to CMOS technology in the 1980s and forming the foundation for Microchip Technology's enduring line of programmable microcontrollers after General Instrument's microelectronics division spun off in 1989. The CP1600 lineage influenced later General Instrument product lines, including 8-bit variants derived from the PIC architecture and the AY-3-8xxx series of custom processors for arcade and home systems. Though did not pursue full 32-bit microprocessors. Production of the CP1600 ceased in the early , with the CP1610 variant persisting until the mid- before being phased out amid the shift to more advanced architectures. Post-production support continues through software emulators for systems like the and hobbyist recreations, including FPGA implementations that replicate the processor's behavior for preservation and experimentation. In March 2025, a high-resolution scan with OCR of a CP1610 was released, aiding ongoing historical preservation efforts.

References

  1. https://www.eejournal.com/article/a-history-of-early-microcontrollers-part-9-the-general-instruments-pic1650/
  2. http://spatula-city.org/~im14u2c/chips/GICP1600.pdf
  3. http://www.bitsavers.org/components/gi/CP1600/CP-1600_Microprocessor_Users_Manual_May75.pdf
  4. https://www.gamingalexandria.com/wp/2023/10/interview-with-stephen-maine-early-video-game-pioneer-and-creator-of-intellivision-graphics/
  5. https://mirrors.meulie.net/bitsavers.org/components/gi/_dataBooks/1976_GI_Data_Catalog.pdf
  6. https://direct.mit.edu/books/oa-monograph/chapter-pdf/2478085/c002300_9780262380553.pdf
  7. https://www.edn.com/general-instruments-microprocessor-aimed-at-minicomputer-market/
  8. http://www.bitsavers.org/components/gi/CP1600/GIC1600_Microcomputer_Users_Manuals_Sep75.pdf
  9. http://www.bitsavers.org/components/gi/_dataBooks/1977_GI_Data_Catalog.pdf
  10. http://bitsavers.org/magazines/Microcomputer_Digest/Microcomputer_Digest_v01n10_Apr75.pdf
  11. https://bitsavers.computerhistory.org/components/gi/CP1600/CP-1600_Microprocessor_Users_Manual_May75.pdf
  12. https://bitsavers.trailing-edge.com/pdf/osborne/books/Osborne_16-Bit_Microprocessor_Handbook_1981.pdf
  13. https://intellivisionrevolution.com/intellivision-specs
  14. https://re-enthused.com/information/mattelintellivision/
  15. https://wiki.intellivision.us/index.php/General_Instrument
  16. https://archive.computerhistory.org/resources/access/text/2016/06/500001027-05-01-acc.pdf
  17. https://www.computerhistory.org/siliconengine/microprocessor-integrates-cpu-function-onto-a-single-chip/
  18. https://bitsavers.org/pdf/osborne/books/Osborne_16-Bit_Microprocessor_Handbook_1981.pdf
  19. http://bitsavers.org/components/gi/CP1600/GIC1600_Microcomputer_Users_Manuals_Sep75.pdf
  20. http://bitsavers.org/components/gi/_dataBooks/GIMINI_TV_Game_Circuits_197801.pdf
  21. https://forums.atariage.com/topic/380239-new-datasheet-for-general-instrument-cp1610-cpu-uncovered/
Add your contribution
Related Hubs
User Avatar
No comments yet.