National Semiconductor COP400
National Semiconductor COP420 in 28-pin plastic DIP. Late 1982 date code.
General information
Launched1977; 47 years ago (1977)
Common manufacturer(s)
Performance
Max. CPU clock rateto 250 KHz
Data width4 (RAM), 8 (ROM)
Address width7 (RAM), 11 (ROM)
Architecture and classification
ApplicationEmbedded
Instruction setCOP400
Number of instructions40
Physical specifications
Package(s)
  • 24, 28, 40-pin DIP
History
Predecessor(s)MM5799 (PMOS COP)
Successor(s)COP8

The COP400 or COP II is a 4-bit microcontroller family introduced in 1977 by National Semiconductor as a follow-on product to their original PMOS COP microcontroller.[1] COP400 family members are complete microcomputers containing internal timing, logic, ROM, RAM, and I/O necessary to implement dedicated controllers.[2] Some COP400 devices were second-sourced by Western Digital as the WD4200 family.[3][4] In the Soviet Union several COP400 microcontrollers were manufactured as the 1820 series (e.g. the COP402 with designation КР1820ВЕ1).[5]

The COP400 is implemented in CMOS or N-channel silicon gate MOS technology. It was typically packaged in 24- or 28-pin DIP packages. Instruction cycle time of the faster family members is 4 microseconds. The COP400 family offered several memory and pinout configurations.

Notable products that used COP400-family chips include the Apple Lisa, Milton Bradley and Mattel electronic games, Coleco Head to Head Basketball, the Grundy Newbrain, and others.

Memory

The COP400 uses separate memory spaces for ROM and RAM. ROM addresses are 11-bit maximum, while data addresses are 7-bit maximum.

National Semiconductor COP410L die image

ROM

Program memory consists of a 512, 1024, or 2048 × 8-bit ROM. ROM bytes may be program instructions, program data, or jump address pointers. Due to the special characteristics associated with the JP and JSRP instructions, ROM must often be conceived of as organized into pages of 64 bytes each. Also, because of the unique operations performed by the LQID and JID instructions, ROM pages must sometimes be thought of as organized into blocks of 256 bytes.

RAM

Data memory consists of a 32, 64, or 128 × 4-bit RAM, organized as several data registers of 16 4-bit digits. RAM addressing is implemented by the 6- or 7-bit B register used as a pointer. The B register's upper 2 or 3 bits (Br) select one of 4 or 8 data registers and lower 4 bits (Bd) select one of 16 4-bit digits in the selected data register. The 4-bit contents of the RAM digit pointed to by the B register are usually loaded into, exchanged with, or operate on the A register.

CPU registers

COP400 registers
10 09 08 07 06 05 04 03 02 01 00 (bit position)
  A Accumulator
  Br Bd B (pointer)
PC (high) PC (page) Program Counter
SA Stack Registers
SB
SC
Status flag
  C Carry Flag

The register configuration shown in the diagram is for the COP400 family members with maximum ROM (2048 × 8 bits) and RAM (128 × 4 bits). Family members with only 512 or 1024 bytes of ROM will have only a 9- or 10-bit PC. Those with 64 or 32 locations of RAM will have only a 2-bit Br register. Some low end family members omit the SC stack register.[6]

The 4-bit A register (accumulator) is the source and destination register for most arithmetic, logic, and data memory access operations. It can also be used to load the Br and Bd portions of the B register, to load and input 4 bits of the 8-bit Q latch data, to input 4 bits of the 8-bit L port and to perform data exchanges with the SIO register.

A 4-bit ALU performs the arithmetic and logic functions, storing results in A. ASC and CASC operations output a carry to the 1-bit C register, most often employed to indicate arithmetic overflow.

All ROM addressing is accomplished via the 9-, 10-, or 11-bit PC register. Its binary value selects one of the bytes contained in ROM, usually the next program instruction. The value of PC is automatically incremented by 1 prior to the execution of the current instruction to point to the next sequential ROM location, unless the current instruction is a transfer of control instruction. In the latter case, PC is loaded with the appropriate non-sequential value to implement the transfer of control operation. The PC automatically rolls over to point to the next 64 byte page or 256 byte block of program memory. The upper 1, 2, or 3 bits of PC are also used in the JID and LQID instructions.

Three levels of subroutine are implemented by the subroutine save registers, SA, SB, and SC, providing a last-in, first-out (LIFO) hardware subroutine stack. Some implementations do not have a SC.

I/O registers and ports

There are no port numbers or memory addresses associated with the COP400 I/O devices. All the physical I/O registers and ports are referenced by the COP400 assembly language directly by name.

Baseline

Nearly all COP400 family devices implement the following:[6]

High end

There are a few high end members of the COP400 family such as the COP440 and COP2440 that have 40-pins. These have additional registers and ports:[7]

Instruction set

The COP400 family is designed to have very compact code. The most frequently used instructions are one byte. In some cases there are special one-byte forms of two byte instructions. Some features that can be used to make object code more compact are:

COP400 family instruction set
Opcode Operand Mnemonic Description Skip
7 6 5 4 3 2 1 0
0 0 0 0 0 0 0 0 CLRA A ← 0
0 0 0 b0 0 0 b1 1 SKMBZ b RAM(B)b = 0
0 0 0 0 0 0 1 0 XOR A ← A RAM(B)
0 0 r 0 1 0 0 XIS r A ↔ RAM(B), Br ← Br r, Bd ← Bd + 1 Bd = 0
0 0 r 0 1 0 1 LD r A ← RAM(B), Br ← Br r
0 0 r 0 1 1 0 X r A ↔ RAM(B), Br ← Br r
0 0 r 0 1 1 1 XDS r A ↔ RAM(B), Br ← Br r, Bd ← Bd - 1 Bd = 15
0 0 r 1 d LBI r,d Br ← r, Bd ← (d + 9) ^ 15 (Br = 0-3, Bd = 9-15, 0) next LBI
0 0 0 1 0 0 0 0 CASC A ← ~A + RAM(B) + C, C ← Carry carry
0 0 0 1 0 0 1 0 XABR A ↔ Br, A3 ← 0
0 0 1 0 0 0 0 0 SKC C = 1
0 0 1 0 0 0 0 1 SKE A = RAM(B)
0 0 1 0 0 0 1 0 SC C ← 1
0 0 1 0 0 0 1 1 0rrrdddd LDD r,d A ← RAM(r,d)
0 0 1 0 0 0 1 1 1rrrdddd XAD r,d A ↔ RAM(r,d)
0 0 1 1 0 0 0 0 ASC A ← A + RAM(B) + C, C ← Carry carry
0 0 1 1 0 0 0 1 ADD A ← A + RAM(B)
0 0 1 1 0 0 1 0 RC C ← 0
0 0 1 1 0 0 1 1 opcode 33H prefix See table below for instructions with this prefix
0 1 0 0 0 0 0 0 COMP A ← ~A
0 1 0 0 0 0 0 1 SKT Skip on timer overflow timer
0 1 0 0 0 0 1 0 RMB 2 RAM(B)2 ← 0
0 1 0 0 0 0 1 1 RMB 3 RAM(B)3 ← 0
0 1 0 0 0 1 0 0 NOP No operation
0 1 0 0 0 1 0 1 RMB 1 RAM(B)1 ← 0
0 1 0 0 0 1 1 0 SMB 2 RAM(B)2 ← 1
0 1 0 0 0 1 1 1 SMB 1 RAM(B)1 ← 1
0 1 0 0 1 0 0 0 RET Pop PC (PC ← SA, SA ← SB, SB ← SC)
0 1 0 0 1 0 0 1 RETSK Pop PC always
0 1 0 0 1 0 1 0 ADT A ← A + 10
0 1 0 0 1 0 1 1 SMB 3 RAM(B)3 ← 1
0 1 0 0 1 1 0 0 RMB 0 RAM(B)0 ← 0
0 1 0 0 1 1 0 1 SMB 0 RAM(B)0 ← 1
0 1 0 0 1 1 1 0 CBA A ← Bd
0 1 0 0 1 1 1 1 XAS A ↔ SIO, SK ← C
0 1 0 1 0 0 0 0 CAB Bd ← A
0 1 0 1 y AISC y A ← A + y (1 ≤ y ≤ 15) carry
0 1 1 0 0 addhi addlo JMP a PC[10:8] ← addhi, PC[7:0] ← addlo
0 1 1 0 1 addhi addlo JSR a Push PC, PC[10:8] ← addhi, PC[7:0] ← addlo
0 1 1 1 y STII y RAM(B) ← y, Bd ← Bd + 1
1 0 addr JSRP a If PC[10:6] ≠ 00010: Push PC, PC[10:6] ← 00010, PC[5:0] ← addr
1 0 1 1 1 1 1 1 LQID Q ← ROM(PC[10:8], A, RAM(B)), SC ← SB
1 1 addr JP a If PC[10:6] ≠ 00010: PC[5:0] ← addr
1 addr JP a If PC[10:7] = 0001: PC[6:0] ← addr
1 1 1 1 1 1 1 1 JID PC[7:0] ← ROM(PC[10:8], A, RAM(B))
7 6 5 4 3 2 1 0 Operand Mnemonic Description Skip
opcodes prefixed with 33H
Opcode Mnemonic Description Skip Non-core Instruction
7 6 5 4 3 2 1 0
0 0 0 b0 0 0 b1 1 SKGBZ b Gb = 0
0 0 0 0 1 0 1 1 XAN A[1:0] ↔ N, A[2:3] ← 0 Y
0 0 0 0 1 1 1 1 CEMA RAM(B) ← EN[7:4], A ← EN[3:0] Y
0 0 0 1 1 0 0 1 LID RAM(B), A ← ROM(PC[10:8], A, RAM(B)) Y
0 0 0 1 1 1 1 1 CAME EN[7:4] ← A, EN[3:0] ← RAM(B) Y
0 0 1 0 0 0 0 1 SKGZ G = 0
0 0 1 0 1 0 0 0 ININ A ← IN
0 0 1 0 1 0 0 1 INIL A ← IL3, 1, 0, IL0 or A ← IL3, CKO, 0, IL0
0 0 1 0 1 0 1 0 ING A ← G
0 0 1 0 1 0 1 1 INH A ← H Y
0 0 1 0 1 1 0 0 CQMA RAM(B) ← Q[7:4], A ← Q[3:0]
0 0 1 0 1 1 0 1 INR RAM(B) ← R[7:4], A ← R[3:0] Y
0 0 1 0 1 1 1 0 INL RAM(B) ← L[7:4], A ← L[3:0]
0 0 1 0 1 1 1 1 CTMA RAM(B) ← T[7:4], A ← T[3:0] Y
0 0 1 1 1 0 1 0 OMG G ← RAM(B)
0 0 1 1 1 0 1 1 OMH H ← RAM(B) Y
0 0 1 1 1 1 0 0 CAMQ Q[7:4] ← A, Q[3:0] ← RAM(B)
0 0 1 1 1 1 0 1 CAMR R[7:4] ← A, R[3:0] ← RAM(B) Y
0 0 1 1 1 1 1 0 OBD D ← Bd
0 0 0 1 1 1 1 1 CAMT T[7:4] ← A, T[3:0] ← RAM(B) Y
0 1 0 1 y OGI y G ← y
0 1 1 0 y LEI y EN ← y
1 r d LBI r,d Br ← r, Bd ← d next LBI
7 6 5 4 3 2 1 0 Mnemonic Description Skip Non-core

Example code

This example code demonstrates several of the space saving features on the instruction set:

 
 
 
 
 
 
040 09     
041 19     
042 2F     

043 15     
044 14     
045 C3     
046 48
; Copy a block of memory from one location to another.
;
; There are three entry points: copyA, copyB, and copyC.
; The values of the LBI instructions are expressed as
; LBI Br, Bd.
;
copyA:      LBI     0,10        ;Copy 6 nybbles starting 0,10 to 1,10
copyB:      LBI     1,10        ;Copy 6 nybbles starting 1,10 to 0,10
copyC:      LBI     2,0         ;Copy 16 nybbles starting 2,0 to 3,0

loop:       LD      1           ;Load src in A. XOR Br with 1 to get dest
            XIS     1           ;Save A in dest. Inc Bd. XOR Br with 1 to get src
            JP      loop        ;loop until Bd goes past last digit location
            RET

Interrupt

Early COP400 devices that have 28 pins or more support a single interrupt. The IN 1 line is used as the interrupt input. Interrupt is enabled by setting bit 1 of the EN register to 1 with a LEI instruction. In response to low-going pulse of at least two instruction cycles long on IN 1, all transfer of control instructions such as JP are completed and all sequential LBI instructions are executed. The PC is then pushed on the subroutine stack and control is transferred to the interrupt handler at address 0xFF. No subroutines may be called in the interrupt service routine.[6] Curiously, later devices such as the COP440 support four interrupt sources and two service routines but only one interrupt source can be selected at a time. Subroutines are supported inside interrupt service routines on devices with a stack pointer.

Architectural extensions

Although the majority of COP400 devices were targeted at low-end applications, several extensions to the architecture were created to address more demanding applications. Dual CPU, a deeper stack in RAM, and larger address spaces were added to some devices by 1985.[7]

Dual CPU

“Dual CPU” versions of the COP400 were announced by National Semiconductor in 1981. These single-chip barrel processors contain two ostensibly independent CPUs that share instructions, memory, and most IO devices. In reality, the CPUs are not fully independent and share hardware resources similar to Intel processors with Hyper-Threading Technology (HTT). Like HTT, the dual CPU version works by duplicating certain sections of the processor—those that store the architectural state—but not duplicating the main execution resources such as ALU, buses, and memory. Separate architectural states for each of the two virtual processors is established with duplicated A (accumulators), B (pointer registers), C (carry flags), N (stack pointers), and PC (program counters).[6]

When the reset is deasserted, both processors start at location 0 which contains a CLRA instruction, then one processor jumps to location 401 (hex) followed an instruction cycle later by the second processor executing location 1. The processors will then alternately execute one byte of code each.

At maximum clock frequency, the instruction execution time (single byte instruction) for each processor is 4 microseconds, hence, the instruction cycle time for either processor is twice that amount, 8 microseconds.

Some dual CPU versions include the 40-pin COP2440N, the 28-pin COP2441N, and the 24-pin COP2442N.

Return stack in RAM

COP400 with stack pointer
10 09 08 07 06 05 04 03 02 01 00 (bit position)
  A Accumulator
  Br Bd B (pointer)
  1 0 0 0 N 0 0 Stack Pointer
PC (high) PC (page) Program Counter
Status flag
  C Carry Flag
(COP440 shown)

Earlier COP400 devices included a two or three level dedicated hardware return stack. Later devices such as the COP440 feature a 4-level return stack implemented with a 2-bit stack pointer and RAM. Dual CPU versions have two separate 4-level return stacks implemented with a two 2-bit stack pointers and two different RAM areas.

Larger address space

The basic COP400 instruction set supports ROM addresses of up to 11-bits (2,048 bytes), while data addresses are 7-bits maximum (128 locations). The so-called group 4 devices extended the memory limit by adding three-byte JMP, JSR, and LBI instructions with more address bits. These support ROM addresses of 15-bits maximum (32,768 bytes), while data addresses are 9-bits maximum (512 locations). Devices that support these instructions include COP408, COP484, COP485, C0P409. It is unclear whether any of these group 4 devices were produced.

Applications

Emulator

There is an open-source MAME emulator for the COP400 family and several hand held games and specialty calculators.[12][13]

See also

References

  1. ^ "National Semiconductor: The COP before the COPS". The CPUSHACK Museum. 27 September 2014. Retrieved 23 December 2021.
  2. ^ "COP400 Microcontroller Family COPS Family User's Guide". National Semiconductor. Retrieved 3 August 2023.
  3. ^ "Western Digital and the COP". The CPUSHACK Museum. 2 October 2015. Retrieved 22 December 2021.
  4. ^ "WD4200/WD4210 Single-Chip N-Channel Microcontroilers". Retrieved 23 December 2021.
  5. ^ "Soviet microprocessors, microcontrollers, FPU chips and their western analogs". www.cpu-world.com. Retrieved 15 November 2022.
  6. ^ a b c d "COPS Microcontrollers Data Book". National Semiconductor. Retrieved 19 January 2022.
  7. ^ a b "The COPS Programming Manual (1985)" (PDF). Vintage Technology Digital Archive. National Semiconductor. Retrieved 23 December 2021.
  8. ^ "Apple Lisa 341-0064A (COP421)". Visual6502. Retrieved 24 December 2021.
  9. ^ "National Semiconductor COP400". Sean Riddle. Retrieved 24 December 2021.
  10. ^ "1983 Components Catalog" (PDF). Western Digital. p. 621. Retrieved 24 December 2021.
  11. ^ "COP420 4-Bit Processor - Newbrain". Retrieved 30 December 2021.
  12. ^ "COP400 libmame repository". Github. Retrieved 23 April 2022.
  13. ^ "Funjacks (example emulated game)". Arcade Database. Retrieved 23 April 2022.