As far as patents or other rights of third parties are concerned, liability is only assumed for components, not for applications, processes
and circuits implemented within components or assemblies.
The information describes the type of component and shall not be considered as assured characteristics.
Terms of delivery and rights to change design reserved.
For questions on technology, delivery and prices please contact the Semiconductor Group Offices in Germany or the Siemens Companies
and Representatives worldwide (see address list).
Due to technical requirements components may contain dangerous substances. For information on the types in question please contact
your nearest Siemens Office, Semiconductor Group.
Siemens AG is an approved CECC manufacturer.
Packing
Please use the recycling operators known to you. We can also help you – get in touch with your nearest sales office. By agreement we will
take packing material back, if it is sorted. You must bear the costs of transport.
For packing material that is returned to us unsorted or which we are not obliged to accept, we shall have to invoice you for any costs incurred.
Components used in life-support devices or systems must be expressly authorized for such purpose!
Critical components
written approval of the Semiconductor Group of Siemens AG.
1 A critical component is a component used in a life-support device or system whose failure can reasonably be expected to cause the
failure of that life-support device or system, or to affect its safety or effectiveness of that device or system.
2 Life support devices or systems are intended (a) to be implanted in the human body, or (b) to support and/or maintain and sustain hu-
man life. If they fail, it is reasonable to assume that the health of the user may be endangered.
Table header corrected
1
of the Semiconductor Group of Siemens AG, may only be used in life-support devices or systems
The members of the C500 Siemens microcontroller family are basically fully compatible in
architecture and software to the standard 8051 microcontroller family. Especially, they are
functionally upward compatible to the SAB 80C52/80C32 microcontroller. While maintaining all
architectural and operational characteristics of the SAB 80C52/80C32, the C500 microcontrollers
differ in number and complexity of their peripheral units which have been adapted to the specific
application areas.
The goal of this “Architecture and Instruction Set Manual“ is to summarize the basic architecture
and functional characteristics of all members of the C500 microcontroller family. This includes the
description of the architecture and the description of the complete instruction set. Detailed
information about the different versions of the C500 microcontrollers are given in the specific User
Manuals.
Semiconductor Group1-11997-09-01
Fundamental Structure
C500 Family
1.2Memory Organization
The memory resources of the C500 family microcontrollers are organized in different types of
memories (data and program memory), which further can be located internally on the
microcontroller chip or outside of the microcontroller. The memory partitioning of the C500
microcontrollers is typical for a Harvard architecture where data and program areas are held in
separate memory areas. The on-chip peripheral units are accessed using an internal special
function register memory area.
The available memory areas have different sizes and are located in the following five address
spaces:
Table 1-1
C500 Address Spaces
Type of MemoryLocationSize
Program MemoryExternalmax. 64 KByte
Internal (ROM, EEPROM)Depending on C500 version
2K up to 64KByte
Data MemoryExternalmax. 64 KByte
Internal XRAMDepending on C500 version
256 Byte up to 3 KByte
Internal128 or 256 Byte
Special Function RegisterInternal128/256 Bytes
1.2.1 Program Memory
The program memory of the C500 family microcontrollers can be composed of either completely
external program memory, of only internal program memory (on-chip ROM / EEPROM), or of a
mixture of internal and external program memory. lf the EA
level, the C500 microcontrollers execute the program code always out of the external program
memory. Romless C500 derivatives can use this type of program memory only. C500 derivatives
with on-chip program memory typically use their internal program memory only. If the internal
program memory is used the EA
executes instructions internally unless the address exceeds the upper limit of the internal program
memory. If the program counter is set to an address (e.g. by a jump instruction) which is higher than
the internal program memory, instructions are executed out of an external program memory. When
the instruction address again is below the internal program memory size limit, internal program
memory is accessed again.
pin must be put to high level. With EA high, the microcontroller
pin (EA= E xternal A ccess) is held at low
Figure 1-1 shows the typical C500 family microcontroller program memory configuration for the two
cases EA=0 and EA=1. The ROM boundary shown in figure 1-1 , applies to the C501 which has 8K
byte of internal ROM. Other C500 family microcontrollers with different ROM size have different
ROM boundaries.
Semiconductor Group1-21997-09-01
Fundamental Structure
C500 Family
Figure 1-1
Program Memory Configuration (Example of the C501)
1.2.2 Data Memory
The data memory area of the C500 family microcontrollers consists of internal and external data
memory portions. The internal data memory area is addressed using 8-bit addresses. The external
data memory and the internal XRAM data memory are addressed by 8-bit or16-bit addresses.
The content of the internal data memory (also XRAM) is not affected by a reset operation. After
power-up the content is undefined, while it remains unchanged during and after a reset as long as
the power supply is not turned off. The XRAM content is also maintained when the C500
microcontrollers are in power saving modes.
1.2.2.1Internal Data Memory
The internal data memory address space is divided into three basic, physically separate and distinct
blocks: the lower 128 byte of internal data RAM, the upper 128 byte of internal data RAM, and the
128 byte special function register (SFR) area. The lower internal data RAM and the SFR area
further include 128 bit locations each. These bits can be handled by specific bit manipulation
instructions.
Semiconductor Group1-31997-09-01
Fundamental Structure
C500 Family
Figure 1-2 shows the configuration of the three basic internal RAM areas. The lower data RAM is
located in the address range 00H - 7FH and can be addressed directly (e.g. MOV A,direct) or
indirectly (e.g. MOV A,@R0 with address in R0). A bit-addressable area of 128 free programmable,
direct addressable bits is located at byte addresses 20H - 2FH of the lower data RAM. Bit 0 of the
internal data byte at 20H has the bit address 00H while bit 7 of the internal data byte at 2FH has the
bit address 7FH. The lower 32 locations of the internal lower data RAM are assigned to four banks
with eight general purpose registers (GPRs) each. Only one of these banks can be enabled at a
time to be used as general purpose registers.
Figure 1-2
Internal Data Memory Organization
Semiconductor Group1-41997-09-01
Fundamental Structure
C500 Family
While the SFR area and the upper internal RAM area share the same address locations (80H FFH), they must be accessed through different addressing modes. The upper internal RAM can
only be accessed through indirect addressing while the special function registers (SFRs) are
accessible only by direct addressing instructions. The SFRs which are located at addresses with
address bit 0-2 equal 0 (addresses 80H, 88H, 90H, ....F0H, FFH) are bitaddressable SFRs.
1.2.2.2Internal Data Memory XRAM
Some members of the C500 family microcontrollers provide an additional internal data memory
area, called the XRAM. This data memory area is logically located at the upper end of the external
data memory space (except C502), but it is integrated on the chip. Because the XRAM is used in
the same way as external data memory the same instruction types must be used for accessing the
XRAM.
Figure 1-3 shows a typical 256 byte XRAM address mapping of the C500 microcontrollers.
Figure 1-3
XRAM Memory Mapping (256 Byte)
Depending on the C500 derivative, the size of the XRAM area differs from 128 upto 3K byte.
Further, the XRAM can be enabled or disabled. If an internal XRAM area is disabled, external data
memory can be accessed in the address range of the internal XRAM.
Semiconductor Group1-51997-09-01
Fundamental Structure
C500 Family
1.2.2.3External Data Memory
The 64 Kbyte external data memory can be addressed by instructions that use 8-bit or 16-bit indirect
addressing. A 16-bit external memory addressing mode is supported by the MOVX instructions
using the 16-bit datapointer DPTR for addressing. For 8-bit addressing MOVX instructions with the
general purpose registers R0/R1 are used.
1.2.3 Special Function Register Area
The registers of a C500 microcontroller, except the program counter and the four general purpose
register banks, reside in the special function register (SFR) area. The special function register area
typically provides 128 bytes of direct addressable SFRs. The SFRs which are located at addresses
with address bit 0-2 equal 0 (addresses 80H, 88H, 90H, ....F0H, FFH) are bitaddressable SFRs (see
also figure 1-1). For example, the SFR with byte address 80H provides the bit locations with bit
addresses 80H to 87H. The bit addresses of the SFR bits reach from 80H to FFH.
Due to the limited number of 128 standard SFRs, some derivatives of the C500 microcontroller
family provide an additional 128 byte SFR area, called the mapped SFR area. The mapped SFR
area provides the same addressing capabilities (direct addresses, bit addressing) as the standard
SFR area.
Special Function Register SYSCON (Address B1H)
Bit No.MSBLSB
76543210
B1
H
BitFunction
RMAPSpecial function register map bit
––
The functions of the shaded bits are not described in this section.
RMAP = 0 : The access to the non-mapped (standard) special function
RMAP = 1 : The access to the mapped special function register area is
–RMAP–
register area is enabled (default after reset).
enabled.
––
–
SYSCON
As long as bit RMAP is set, mapped special function registers can be accessed. This bit is not
cleared by hardware automatically. Thus, when non-mapped/mapped registers are to be accessed,
the bit RMAP must be cleared/set by software, respectively each. Some registers (e.g. ACC) are
accessed independently of bit RMAP.
Two bits in the program status word, RS0 (PSW.3) and RS1 (PSW.4), select the active register
bank. This allows fast context switching, which is useful when entering subroutines or interrupt
service routines. The 8 general purpose registers of the selected register bank may be accessed
by register addressing. For indirect addressing modes, the registers R0 and R1 are used as pointer
or index register to address internal or external memory (e.g. MOV @R0).
Semiconductor Group1-61997-09-01
CPU Functions
C500 Family
2CPU Architecture
The typical architecture of a C500 family microcontroller is shown in figure 2-1 . This block diagram
includes all main functional blocks of the C500 microcontrollers. The shaded blocks are basic
functional units which are mandatory for each C500 microcontroller. The other functional blocks
such as XRAM, peripheral units, and ROM/RAM sizes are specific to each C500 microcontroller
derivative.
The core block represents the CPU (Central Processing Unit) of the C500 family microcontrollers.
The CPU consists of the instruction decoder, the arithmetic section, the CPU registers, and the
program control section. The housekeeper unit generates internal signals for controlling the
functions of the individual internal units within the microcontroller. Port 0 and port 2 are required for
accessing external code and data memory and for emulation purposes. The external control signals
and the clock generation are handled in the external control block. The access control unit is
responsible for the selection of the on-chip memory resources. The IRAM provides the internal RAM
which includes the general purpose registers. The interrupt requests from the peripheral units are
handled by an interrupt controller unit.
C500 device specific is the configuration of the on-chip peripheral units. Serial interfaces, timers,
capture/compare units, A/D converters, watchdog units, or a multiply/divide unit are typical
examples for on-chip peripheral units. The external signals of these peripheral units are available
at multifunctional parallel I/O ports or at dedicated pins.
Semiconductor Group2-11997-09-01
CPU Functions
C500 Family
The arithmetic section of the core performs extensive data manipulation and is comprised of the
arithmetic/logic unit (ALU), an A register, B register and PSW register. Further, it has extensive
facilities for binary and BCD arithmetic and excels in its bit-handling capabilities. Efficient use of
program memory results from an instruction set consisting of 44% one-byte, 41% two-byte, and
15% three-byte instructions. The ALU accepts 8-bit data words from one or two sources and
generates an 8-bit result under the control of the instruction decoder. The ALU performs the
arithmetic operations add, substract, multiply, divide, increment, decrement, BDC-decimal-addadjust and compare, and the logic operations AND, OR, Exclusive OR, complement and rotate
(right, left or swap nibble (left four)). Also included is a Boolean processor performing the bit
operations as set, clear, complement, jump-if-not-set, jump-if-set-and-clear and move to/from carry.
Between any addressable bit (or its complement) and the carry flag, it can perform the bit operations
of logical AND or logical OR with the result returned to the carry flag.
The program control section of the core controls the sequence in which the instructions stored in
program memory are executed. The 16-bit program counter (PC) holds the address of the next
instruction to be executed. The conditional branch logic enables internal and external events to the
processor to cause a change in the program execution sequence.
2.1Accumulator
ACC is the symbol for the accumulator register. The mnemonics for accumulator-specific
instructions, however, refer to the accumulator simply as A.
2.2B Register
The B register is used during multiply and divide and serves as both source and destination. For
other instructions it can be treated as another scratch pad register.
2.3Program Status Word
The Program Status Word (PSW) contains several status bits that reflect the current state of the
CPU. The bits of the PSW are used for different functions which are: two register bank selection bits,
two carry flags and an overflow flag for arithmetic instructions, a parity bit for the content of the ACC,
and two general purpose flags.
The bit definitions of the PSW are shown on the next page.
Semiconductor Group2-21997-09-01
CPU Functions
C500 Family
Special Function Register PSW (Address D0H) Reset Value : 00
Bit No.
D0
H
BitFunction
CYCarry Flag
Used by arithmetic and conditional branch instruction.
ACAuxiliary Carry Flag
Used by instructions which execute BCD operations.
F0General Purpose Flag
RS1
RS0
Register Bank select control bits
These bits are used to select one of the four register banks.
RS1RS0Function
LSBMSB
01234567
PF1OVRS0RS1F0ACCY
PSW
H
00Registerbank 0 at data address 00H-07H selected
01Registerbank 1 at data address 08H-0FH selected
10Registerbank 2 at data address 10H-17H selected
11Registerbank 3 at data address 18H-1FH selected
OVOverflow Flag
Used by arithmetic instruction.
F1General Purpose Flag
PParity Flag
Always set/cleared by hardware to indicate an odd/even number of "one"
bits in the accumulator, i.e. even parity.
2.4Stack Pointer
The stack pointer (SP) register is 8 bits wide. It is incremented before data is stored during PUSH
and CALL executions and decremented after data is popped during a POP and RET (RETI)
execution, i.e. it always points to the last valid stack byte. While the stack may reside anywhere in
the on-chip RAM, the stack pointer is initialized to 07H after a reset. This causes the stack to begin
a location = 08H above register bank zero. The SP can be read or written under software control.
Semiconductor Group2-31997-09-01
CPU Functions
C500 Family
2.5Data Pointer
8-bit accesses to the internal XRAM data memory or the external data memory are executed using
the data pointer DPTR as an 16-bit address register. Normally, the C500 family microcontrollers
have one data pointer. But some members of the C500 family provide eight data pointers. The
availability of eight data pointers especially supports the programming in high level languages which
have a demand to store data in large external data memory portions.
Special Function Register DPL (Address 82H) Reset Value : 00
Special Function Register DPH (Address 83H) Reset Value : 00
Special Function Register DPSEL (Address D0H) Reset Value : 00
LSBMSB
Bit No.
82
H
H
H
BitFunction
–Reserved bits for future use
01234567
LSB.1.2.3.4.5.6.7
.0.1.2.3.4.5.6MSB83
.0.1.2–––––92
DPL
DPH
DPSEL
H
H
H
DPSEL.2 - 0Data pointer select bits
DPSEL.2-0 defines the number of the actual active data pointer.DPTR0-7.
The standard 8051 architecture provides just one 16-bit pointer for indirect addressing of external
devices (memories, peripherals, latches, etc.). Except for a 16-bit "move immediate" to this
datapointer and an increment instruction, any other pointer handling is to be done byte by byte. For
complex applications with peripherals located in the external data memory space (e.g. CAN
controller) or extended data storage capacity this turned out to be a "bottle neck" for the 8051’s
communication to the external world. Especially programming in high-level languages (PLM51,
C51, PASCAL51) requires extended RAM capacity and at the same time a fast access to this
additional RAM because of the reduced code efficiency of these languages.
2.5.2 How the eight Datapointers of the C500 are realized
Simply adding more datapointers is not suitable because of the need to keep up 100% compatibility
to the 8051 instruction set. This instruction set, however, allows the handling of only one single 16bit datapointer (DPTR, consisting of the two 8-bit SFRs DPH and DPL).
To meet both of the above requirements (speed up external accesses, 100% compatibility to 8051
architecture) the C500 contains a set of eight 16-bit registers from which the actual datapointer can
be selected.
This means that the user’s program may keep up to eight 16-bit addresses resident in these
registers, but only one register at a time is selected to be the datapointer. Thus the datapointer in
turn is accessed (or selected) via indirect addressing. This indirect addressing is done through a
special function register called DPSEL (data pointer select register). All instructions of the C500
which handle the datapointer therefore affect only one of the eight pointers which is addressed by
DPSEL at that very moment.
Figure 5-1 illustrates the addressing mechanism: a 3-bit field in register DPSEL points to the
currently used DPTRx. Any standard 8051 instruction (e.g. MOVX @DPTR, A - transfer a byte from
accumulator to an external location addressed by DPTR) now uses this activated DPTRx.
Figure 2-2
Accessing of External Data Memory via Multiple Datapointers
External Data Memory
MCD00779
2.5.3 Advantages of Multiple Datapointers
Using the above addressing mechanism for external data memory results in less code and faster
execution of external accesses. Whenever the contents of the datapointer must be altered between
two or more 16-bit addresses, one single instruction, which selects a new datapointer, does this job.
lf the program uses just one datapointer, then it has to save the old value (with two 8-bit instructions)
and load the new address, byte by byte. This not only takes more time, it also requires additional
space in the internal RAM.
2.5.4 Application Example and Performance Analysis
The following example shall demonstrate the involvement of multiple data pointers in a table
transfer from the code memory to external data memory.
Start address of ROM source table:1FFF
Start address of table in external RAM:2FA0
H
H
Semiconductor Group2-61997-09-01
CPU Functions
C500 Family
Example 1 : Using only One Datapointer (Code for a C501)
Initialization Routine
MOVLOW(SRC_PTR), #0FFH;Initialize shadow_variables with source_pointer
MOVHIGH(SRC_PTR), #1FH
MOVLOW(DES_PTR), #0A0H;Initialize shadow_variables with destination_pointer
MOVHIGH(DES_PTR), #2FH
Table Look-up Routine under Real Time Conditions
;Number of cycles
PUSHDPL;Save old datapointer2
PUSHDPH;2
MOVDPL, LOW(SRC_PTR);Load Source Pointer2
MOVDPH, HIGH(SRC_PTR);2
;INCDPTRIncrement and check for end of table (execution time
;CJNE…not relevant for this consideration)–
MOVCA,@DPTR;Fetch source data byte from ROM table2
MOVLOW(SRC_PTR), DPL;Save source_pointer and 2
MOVHIGH(SRC_PTR), DPH;load destination_pointer2
MOVDPL, LOW(DES_PTR);2
MOVDPH, HIGH(DES_PTR);2
INCDPTR;Increment destination_pointer
;(ex. time not relevant)–
MOVX@DPTR, A;Transfer byte to destination address2
MOVLOW(DES_PTR), DPL;Save destination_pointer2
MOVHIGH(DES_PTR),DPH;2
POPDPH;Restore old datapointer2
POPDPL;2
;Total execution time (machine cycles) : 28
Semiconductor Group2-71997-09-01
CPU Functions
C500 Family
Example 2 : Using Two Datapointers (Code for a C509)
Initialization Routine
MOVDPSEL, #06H;Initialize DPTR6 with source pointer
MOVDPTR, #1FFFH
MOVDPSEL, #07H;Initialize DPTR7 with destination pointer
MOVDPTR, #2FA0H
Table Look-up Routine under Real Time Conditions
;Number of cycles
PUSHDPSEL;Save old source pointer2
MOVDPSEL, #06H;Load source pointer2
;INCDPTRIncrement and check for end of table (execution time
;CJNE…not relevant for this consideration)–
MOVCA,@DPTR;Fetch source data byte from ROM table2
MOVDPSEL, #07H;Save source_pointer and
;load destination_pointer2
MOVX@DPTR, A;Transfer byte to destination address2
POPDPSEL;Save destination pointer and
;restore old datapointer2
;Total execution time (machine cycles) : 12
The above example shows that utilization of the C500’s multiple datapointers can make external
bus accesses two times as fast as with a standard 8051 or 8051 derivative. Here, four data variables
in the internal RAM and two additional stack bytes were spared, too. This means for some
applications where all eight datapointers are employed that an C500 program has up to 24 byte (16
variables and 8 stack bytes) of the internal RAM free for other use.
Semiconductor Group2-81997-09-01
CPU Functions
C500 Family
2.6Enhanced Hooks Emulation Concept
The Enhanced Hooks Emulation Concept of the C500 microcontroller family is a new, innovative
way to control the execution of C500 MCUs and to gain extensive information on the internal
operation of the controllers. Emulation of on-chip ROM based programs is possible, too.
Each production chip has built-in logic for the support of the Enhanced Hooks Emulation Concept.
Therefore, no costly bond-out chips are necessary for emulation. This also ensure that emulation
and production chips are identical.
The Enhanced Hooks Technology
together with an EH-IC to function similar to a bond-out chip. This simplifies the design and reduces
costs of an ICE-system. ICE-systems using an EH-IC and a compatible C500 are able to emulate
all operating modes of the different versions of the C500. This includes emulation of ROM, ROM
with code rollover and ROMless modes of operation. It is also able to operate in single step mode
and to read the SFRs after a break.
TM
, which requires embedded logic in the C500, allows the C500
Port 0, port 2 and some of the control lines of the C500 based MCU are used by Enhanced Hooks
Emulation Concept to control the operation of the device during emulation and to transfer
informations about the program execution and data transfer between the external emulation
hardware (ICE-system) and the C500 MCU.
Semiconductor Group2-91997-09-01
CPU Functions
C500 Family
2.7Basic Interrupt Handling
Each member of the C500 microcontroller family provides several interrupt sources. These
interrupts are generated typically by external events or by the internal peripheral units. If an interrupt
is accepted by the CPU, the microcontroller interrupts a running program and proceeds the program
execution at an interrupt source specific vector address where the interrupt service routine is
located. After the execution of a RETI (return from interrupt) instruction the program is continued at
the point where it has been interrupted. Figure 2-4 shows an example for the interrupt vector
addresses of a C500 microcontroller (C501). Generally, interrupt vector addresses are located in
the code memory area starting at address 0003H. The minimum distance between two consecutive
vector addresses is always 8 bytes. Therefore, interrupt vectors can be assigned to the following
Figure 2-4
Interrupt Vector Addresses (Example of the C501)
An interrupt source indicates to the interrupt controller an interrupt condition by setting an interrupt
request flag. The interrupt request flags are sampled in each machine cycle. The sampled flags are
polled during the following machine cycle. If one of the flags was in a set condition in the preceeding
cycle, the polling cycle will find it and the interrupt controller will cause the CPU to branch to the
vector address of the appropriate service routine by generating an internal LCALL. This hardwaregenerated LCALL is blocked by any of the following conditions:
1. An interrupt of equal or higher priority is already in progress.
2. The current (polling) cycle is not in the final cycle of the instruction in progress.
3. The instruction in progress is RETI or any write access to interrupt enable or priority registers.
Semiconductor Group2-101997-09-01
CPU Functions
C500 Family
Any of these three conditions will block the generation of the LCALL to the interrupt service routine.
Condition 2 ensures that the instruction in progress is completed before vectoring to any service
routine. Condition 3 ensures that if the instruction in progress is RETI or any write access to interrupt
enable or interrupt priority registers, then at least one more instruction will be executed before any
interrupt is vectored too; this delay guarantees that changes of the interrupt status can be observed
by the interrupt controller.
The polling cycle is repeated with each machine cycle, and the values polled are the values that
were present at the previous machine cycle. Note that if any interrupt flag is active but not being
responded to for one of the conditions already mentioned, or if the flag is no longer active when the
blocking condition is removed, the denied interrupt will not be serviced. In other words, the fact that
the interrupt flag was once active but not serviced is not remembered. Every polling cycle
interrogates only the pending interrupt requests.
The polling cycle/LCALL sequence is illustrated in figure 2-1.
C2C1C3C4C5
S5P2
Interrupt
is latched
Interrupts
are polled
Long Call to Interrupt
Vector Address
Interrupt
Routine
MCT01859
Figure 2-5
Interrupt Detection/Entry Diagram
Note that if an interrupt of a higher priority level goes active prior to S5P2 in the machine cycle
labeled C3 in figure 2-5 then, in accordance with the above rules, it will be vectored to during C5
and C6 without any instruction for the lower priority routine to be executed.
Thus, the processor acknowledges an interrupt request by executing a hardware-generated LCALL
to the appropriate servicing routine. In some cases it also clears the flag that generated the
interrupt, while in other cases it does not; then this has to be done by the user's software.
The program execution proceeds from that location until the RETI instruction is encountered. The
RETI instruction informs the processor that the interrupt routine is no longer in progress, then pops
the two top bytes from the stack and reloads the program counter. Execution of the interrupted
program continues from the point where it was stopped. Note that the RETI instruction is very
important because it informs the processor that the program left the current interrupt priority level.
A simple RET instruction would also have returned execution to the interrupted program, but it
would have left the interrupt control system thinking an interrupt was still in progress. In this case no
interrupt of the same or lower priority level would be acknowledged.
Semiconductor Group2-111997-09-01
CPU Functions
C500 Family
2.8Interrupt Response Time
If an external interrupt is recognized, its corresponding request flag is set at S5P2 in every machine
cycle. The value is not polled by the circuitry until the next machine cycle. If the request is active and
conditions are right for it to be acknowledged, a hardware subroutine call to the requested service
routine will be next instruction to be executed. The call itself takes two cycles. Thus a minimum of
three complete machine cycles will elapse between activation and external interrupt request and the
beginning of execution of the first instruction of the service routine.
A longer response time would be obtained if the request was blocked by one of the three previously
listed conditions. If an interrupt of equal or higher priority is already in progress, the additional wait
time obviously depends on the nature of the other interrupt's service routine. If the instruction in
progress is not in its final cycle, the additional wait time cannot be more than 3 cycles since the
longest instructions (MUL and DIV) are only 4 cycles long; and, if the instruction in progress is RETI
or a write access to interrupt enable or interrupt priority registers the additional wait time cannot be
more than 5 cycles (a maximum of one more cycle to complete the instruction in progress, plus 4
cycles to complete the next instruction, if the instruction is MUL or DIV).
Thus a single interrupt system, the response time is always more than 3 cycles and less than
9 cycles.
Semiconductor Group2-121997-09-01
CPU Timing
C500 Family
3CPU Timing
3.1Basic Timing
A machine cycle consists of 6 states. Each state is divided into a phase 1 half, during which the
phase 1 clock is active, and a phase 2 half, during which the phase 2 clock is active. Thus, a
machine cycle consists of the states S1P1 (state 1, phase 1) through S6P2 (state 6, phase 2).
Depending on the C500 type of microcontroller, each state lasts either one or two periods of the
oscillator clock. Typically, arithmetic and logical operations take place during phase 1 and internal
register-to-register transfers take place during phase 2.
The diagrams in figure 3-1 show the fetch/execute timing related to the internal states and phases.
Since these internal clock signals are not user-accessible, the ALE (address latch enable) signal is
shown for external reference. ALE is normally activated twice during each machine cycle: once
during S1P2 and S2P1, and again during S4P2 and S5P1.
The execution of a one-cycle instruction begins at S1P2, when the opcode is latched into the
instruction register. If it is a two-byte instruction, the second reading takes place during S4 of the
same machine cycle. If it is a one-byte instruction, there is still a fetch at S4, but the byte read (which
would be the next op-code) is ignored (discarded fetch), and the program counter is not
incremented. In any case, execution is completed at the end of S6P2.
Figures 3-1 (a) and (b) show the timing of a 1-byte, 1-cycle instruction and for a 2-byte, 1-cycle
instruction.
Most C500 instructions are executed in one cycle. MUL (multiply) and DIV (divide) are the only
instructions that take more than two cycles to complete; they take four cycles. Normally two code
bytes are fetched from the program memory during every machine cycle. The only exception to this
is when a MOVX instruction is executed. MOVX is a one-byte, 2-cycle instruction that accesses
external data memory. During a MOVX, the two fetches in the second cycle are skipped while the
external data memory is being addressed and strobed. Figure 3-1 (c) and (d) show the timing for
a normal 1-byte, 2-cycle instruction and for a MOVX instruction.
Semiconductor Group3-11997-09-01
CPU Timing
C500 Family
Figure 3-1
Fetch Execute Sequence
Semiconductor Group3-21997-09-01
CPU Timing
C500 Family
3.2Accessing External Memory
There are two types of external memory accesses: accesses to external program memory and
accesses to external data memory. Accesses to external program memory use the signal PSEN
(program store enable) as the read strobe. Accesses to external data memory use the RD or WR
(alternate functions of P3.7 and P3.6) to access the memory.
Fetches from external program memory always use a 16-bit address. Accesses to external data
memory can use either a 16-bit address (MOVX @DPTR) or an 8-bit address (MOVX @Ri).
Whenever a 16-bit address is used, the high byte of the address comes out on port 2, where it is
held for the duration of the read, write, or code fetch cycle.
If an 8-bit address is being used (MOVX @Ri), the contents of the port 2 SFR remain at the port 2
pins throughout the whole external memory cycle. In this case, port 2 pins can be used to page the
external data memory.
In either case, the low byte of the address is time-multiplexed with the data byte on port 0. The
ADDRESS/DATA signal drives both FETS in the port 0 output buffers. Thus, in external bus mode
the port 0 pins are not open-drain outputs and do not require external pullups. The ALE (address
latch enable) signal should be used to latch the address byte into an external latch. The address
byte is valid at the negative transition of ALE. Then, in a write cycle, the data byte to be written
appears on port 0 just before WR is activated, and remains there until WR is deactivated. In a read
cycle, the incoming byte is accepted at port 0 just before the read strobe (RD) is deactivated.
During any access to external memory, the CPU writes FFH to the port 0 latch (the special function
register), thus obliterating the information in the port 0 SFR. Also, a MOV P0 instruction must not
take place during external memory accesses. If the user writes to port 0 during an external memory
fetch, the incoming code byte may be corrupted. Therefore, do not write to port 0 if external memory
is used.
3.2.1 Accessing External Program Memory
External program memory is accessed under two conditions:
1. Whenever signal EA is active (low), or
2. Whenever signal EA
than the internal ROM size (e.g. 1FFFFH for an 8K internal ROM or 3FFFH for an 16K internal
ROM).
This requires that the ROMless versions have always EA wired to Vss to enable the lower 8K, 16K,
or 32K program bytes to be fetched from external memory.
When the CPU is executing out from external program memory (see timing diagram in figure 3-2),
all 8 bits of port 2 are dedicated to an output function and may not be used for general purpose I/O.
During external program fetches they output the high byte of the PC with the port 2 drivers using the
strong pullups to emit bits that are 1´s.
is inactive (high) and the program counter (PC) contains an address greater
Semiconductor Group3-31997-09-01
CPU Timing
C500 Family
Figure 3-2
External Program Memory Fetches
3.2.2 Accessing External Data Memory
The port 2 drivers use the strong pullups during the entire time that they are emitting address bits
that are 1´s. This occurs when the MOVX @DPTR instruction is executed and when external
program fetches are executed. During this time the port 2 latch (the special function register) does
not have to contain 1´s, and the contents of the port 2 SFR are not modified. If the external memory
cycle is not immediately followed by another external memory cycle, the undisturbed contents of the
port 2 SFR will reappear in the next cycle.
Figure 3-3 and 3-4 show in detail the timings of the external data memory read and write cycles.
Semiconductor Group3-41997-09-01
CPU Timing
C500 Family
Figure 3-3
External Data Memory Read Cycle
Figure 3-4
External Data Memory Write Cycle
Semiconductor Group3-51997-09-01
Instruction Set
C500 Family
4Instruction Set
The C500 8-bit microcontroller family instruction set includes 111 instructions, 49 of which are
single-byte, 45 two-byte and 17 three-byte instructions. The instruction opcode format consists of a
function mnemonic followed by a ”destination, source” operand field. This field specifies the data
type and addressing method(s) to be used.
Like all other members of the 8051-family, the C500 microcontrollers can be programmed with the
same instruction set common to the basic member, the SAB 8051.
Thus, the C500 family microcontrollers are 100% software compatible to the SAB 8051 and may be
programmed with 8051 assembler or high-level languages.
4.1Addressing Modes
The C500 uses five addressing modes:
– register
– direct
– immediate
– register indirect
– base register plus index-register indirect
Table 4-1 summarizes the memory spaces which may be accessed by each of the addressing
modes.
Register Addressing
Register addressing accesses the eight working registers (R0 - R7) of the selected register bank.
The least significant bit of the instruction opcode indicates which register is to be used. ACC, B,
DPTR and CY, the Boolean processor accumulator, can also be addressed as registers.
Direct Addressing
Direct addressing is the only method of accessing the special function registers. The lower
128 bytes of internal RAM are also directly addressable.
Immediate Addressing
Immediate addressing allows constants to be part of the instruction in program memory.
Semiconductor Group4-11997-09-01
Instruction Set
C500 Family
Table 4-1
Addressing Modes and Associated Memory Spaces
Addressing ModesAssociated Memory Spaces
Register addressingR0 through R7 of selected register bank, ACC,
B, CY (Bit), DPTR
Direct addressingLower 128 bytes of internal RAM, special
function registers
Immediate addressingProgram memory
Register indirect addressingInternal RAM (@R1, @R0, SP), external data
memory (@R1, @R0, @DPTR)
Base register plus index register addressingProgram memory (@A + DPTR, @A + PC)
Register Indirect Addressing
Register indirect addressing uses the contents of either R0 or R1 (in the selected register bank) as
a pointer to locations in a 256-byte block: the 256 bytes of internal RAM or the lower 256 bytes of
external data memory. Note that the special function registers are not accessible by this method.
The upper half of the internal RAM can be accessed by indirect addressing only. Access to the full
64 Kbytes of external data memory address space is accomplished by using the 16-bit data pointer.
Execution of PUSH and POP instructions also uses register indirect addressing. The stack may
reside anywhere in the internal RAM.
Base Register plus Index Register Addressing
Base register plus index register addressing allows a byte to be accessed from program memory
via an indirect move from the location whose address is the sum of a base register (DPTR or PC)
and index register, ACC. This mode facilitates look-up table accesses.
Boolean Processor
The Boolean processor is a bit processor integrated into the C500 family microcontrollers. It has its
own instruction set, accumulator (the carry flag), bit-addressable RAM and l/O.
The bit manipulation instructions allow:
– set bit
– clear bit
– complement bit
– jump if bit is set
– jump if bit is not set
– jump if bit is set and clear bit
– move bit from / to carry
Addressable bits, or their complements, may be logically AND-ed or OR-ed with the contents of the
carry flag. The result is returned to the carry register.
Semiconductor Group4-21997-09-01
Loading...
+ 94 hidden pages
You need points to download manuals.
1 point = 1 manual.
You can buy points or you can get point for every manual you upload.