Chapter 1: Introduction to PSoC

From the free online book “Architecture and Programming of PSoC Microcontrollers”

• Introduction
• 1.1 System Overview
• 1.2 CPU
• 1.3 Frequency generator
• 1.4 Microcontroller power consumption
• 1.5 Reset
• 1.6 Digital inputs and outputs
• 1.7 Analog inputs and outputs
• 1.8 Accessing programmable digital blocks
• 1.9 Global input lines

• 1.10 Digital programmable blocks

• 1.11 Analog programmable blocks
• 1.12 Referent voltage generators
• 1.13 Switch mode pump
• 1.14 MAC
• 1.15 Decimator
• 1.16 I2C controller
• 1.17 Interrupt controller
• 1.18 Address space

Introduction
When developing more complex projects, there is often a need for additional peripheral
units, such as operational and instrument amplifiers, filters, timers, digital logic circuits,
AD and DA convertors, etc. As a general rule, implementation of the extra peripherals
brings in additional difficulties: new components take space, require additional attention
during production of a printed circuit board, increase power consumption... All of these
factors can significantly affect the price and development cycle of the project.

The introduction of PSoC microcontrollers has made many engineers’ dream come true
of having all their project needs covered in one chip.

PSoC: Programmable System on Chip

PSoC (Programmable System on Chip) represents a whole new concept in

microcontroller development. In addition to all the standard elements of 8-bit
microcontrollers, PSoC chips feature digital and analog programmable blocks, which
themselves allow implementation of large number of peripherals.
Digital blocks consist of smaller programmable blocks that can be configured to allow
different development options. Analog blocks are used for development of analog
elements, such as analog filters, comparators, intrumentational (non–)inverting
amplifiers, as well as AD and DA convertors.

There’s a number of different PSoC families you can base your project upon, depending
on the project requirements. Basic difference between PSoC families is the number of
available programmable blocks and the number of input/output pins.

Number of components that can be devised is primarily a function of the available

programmable blocks. Depending on the microcontroller family, PSoC chips have 4–16
digital blocks, and 3–12 analog programmable blocks.

Characteristics of PSoC microcontrollers

Some of the most prominent features of PSoC microcontrollers are:

• MAC unit, hardware 8x8 multiplication, with result stored in 32-bit accumulator,
• Changeable working voltage, 3.3V or 5V,
• Possibility of small voltage supply, to 1V,
• Programmable frequency choice.

Programmable blocks allow you to devise:

• 16K bytes of programmable memory,

• 256 bytes of RAM,
• AD convertors with maximum resolution af 14 bits,
• DA convertors with maximum resolution of 9 bits,
• Programmable voltage amplifier,
• Programmable filters and comparators,
• Timers and counters of 8, 16, and 32 bits,
• Pseudorandom sequences and CRC code generators,
• Two Full-Duplex UART’s,
• Multiple SPI devices,
• Option for connection on all output pins,
• Option for block combining,
• Option for programming only the specified memory regions and write protection,
• For every pin there is an option of Pull up, Pull down, High Z, Strong, or Open
pin state,
• Possibility of interrupt generation during change of state on any input/output pin,
• I²C Slave or Master and Multi-Master up to speed of 400KHz,
• Integrated Supervisory Circuit,
• Built-in precise voltage reference.

Is PSoC good enough for my project?

Perhaps the best way to recognize the true value of PSoC microcontrollers is through
comparison with other options.

Major advantages of PSoC microcontroller include the following:

• There is no other microcontroller that has programmable voltage,

instrumentational, inverting, and non-inverting amplifiers;
• Hardware generators of pseudorandom and CRC code, as well as analog
modulators, are unique to PSoC families;
• MAC (Multiply-accumulate) is an essential part of digital signal processors,
which allows implementation of digital signal processing algorithms. It’s worth
noting that hardware accumulator multiplication is not a common feature of 8-bit
microcontrollers;
• Having the advantage of changeable working voltage doesn’t really need a
comment. This feature is particularly important for development of new devices
as it eliminates the need for redesigning the PCB and implementing the level
translator;
• Option for low voltage supply (~1V) is a tremendous advantage in battery
operated systems;
• Timers, counters, and PWM units are more flexible than the usual
implementation;
• Automatic code writing for accessing all the peripherals in use;
• In case you need a larger array of components, there is an option for dynamic
reconfiguration, allowing you to change peripherals during run-time. In this way,
it’s possible to minimize the processor workload at an time, leaving the largest
part of the job to the specialized hardware.

On the other hand, there are certain limitations of PSoC that could influence the choice of
microcontroller for your design.

• In systems which require highly precise or fast measurement, problems may occur
with analog device characteristics. In this case, you should analyze if speed of AD
convertors and offset/noise of analog amplifiers are able to satisfy the project
demands.
• Analog components do not have the ability to work with usual negative supply
voltage. For example, zero voltage for inverting amplifiers is taken to be the
analog ground AGND (usually 2.5V). All voltages above AGND are taken as
positive, while voltages below AGND are taken as negative.
• Most PSoC microcontrollers have 256 bytes of RAM, which could prove to be
insuficient for some projects.

1.1 System overview

PSoC microcontrollers are based on 8-bit CISC architecture. Their general structure with
basic blocks is presented in the following image:
CPU unit is the main part of a microcontroller whose purpose is to execute program
instructions and control workflow of other blocks.

Frequency generator facilitates signals necessary for CPU to work, as well as an array
of frequencies that are used by programmable blocks. These signals could be based on
internal or external referent oscillator.

Reset controller enables microcontroller start action and brings a microcontroller to

regular state in the case of irregular events.

Watch Dog timer is used to detect software dead-loops.

Sleep timer can periodically wake up microcontroller from power saving modes. It could
be also used as a regular timer.

Input-Output pins enable communication between the CPU unit, digital and analog
programmable blocks and outside world.

Digital programmable blocks are used to configure digital programmable components

which are selected by user.
Analog programmable blocks are used to configure analog components, like AD and
DA converters, filters, DTMF receivers, programmable, instrumental, inverting, non-
inverting and operational amplifiers. Interrupt controller handles necessary operations in
the case of interrupts.

I2C controller Enables hardware realization of an I2C communication.

Voltage reference is vital for the work of analog components that reside inside of analog
programmable blocks.

MAC unit is used for operations of hardware signed multiplication of 8-bit numbers.

SMP is a system which can be used as a part of a voltage regulator. For example, it is
possible to supply power to a PSoC microcontroller from a single 1.5V battery.

[back to the top]

1.2 CPU
During the programming, instructions are stored in program (FLASH) memory in a way
which is familiar to microcontroller. CPU fetches one instruction at a time from program
memory, decodes it and executes appropriate operations. CPU unit has internal registers
PC, SP, A, X and F, as well as ALU unit and instruction decoding unit, that are
associated to instruction execution process.

Internal Registers of CPU

Program counter (PC) is used as a pointer to the next program instruction that should be
executed. With each new instruction value of program counter is being set to point on the
next instruction in program memory, which is going to be decoded and executed.

Stack pointer (SP) points to the address of SRAM memory where data is written to or
read from in case of PUSH and POP instructions respectively. When these instructions
occur value stored in SP is internally incremented or decremented.
Accumulator register (A) is the main register which handles all arithmetical, logical or
data transfer operations.

Index register (X) could behave as register A in large number of instructions. Also,
register X is used in the case of index addressing.

Flag register (F) contains bits which describe result of a previously executed instruction.
It also has a role during selection of a RAM memory page in case when PSoC
microcontroller has more than 256 bytes of RAM. Bit Flag Zero (Z) marks that
accumulator stores a zero, while Carry (C) marks that there has been carrying during
arithmetic or logic operations.

Arithmetic logic unit (ALU) is a standard part of a CPU, which is used for arithmetic
operations like addition, subtracting and shifting (left or right), as well as logic
operations. Data handled by instructions could be stored in internal registers A and X, or
in RAM data memory

[back to the top]

1.3 Frequency generator

Frequency generator is vital to CPU unit functioning, as well as programmable blocks.
Each of programmable components has certain demands regarding speed. PSoC
microcontrollers have a system for generation of different frequency signals, which is
done by graphically selecting appropriate parameters. Picture shows two independent
systems for generating signals SYSCLK and CLK 32k.
SYSCLK is the main internal clock signal with a speed of 24MHz. It is used as a
reference clock for most of other signals.

SYSCLKx2 is a clock signal with double frequency (48MHz) of SYSCLK signal.

24V1 is a signal derived by dividing frequency SYSCLK with parameter N1, which
varies in range from 1 to 16. 24V1 frequency equals SYSCLK/N1, with a frequency from
1.5MHz (N1=16) to 24MHz (N1=1).

24V2 is a signal derived by dividing 24MHz frequency with parameter N1, which varies
in range between 1 and 16. 24V2 signal frequency equals SYSCLK/N1N2., which means
that possible frequency ranges from 93.75kHz (N1,N2=16) to 24MHz (N1,N2=1).

24V3 signal is derived by dividing frequency of one of the signals 24V2, 24V1, SYSCLK
or SYSCLKx2, with number N, in the range from 1 to 256.

CPU_CLK is used as a CPU unit frequency which has a direct impact on instruction
execution speed. CPU_CLK can have any of eight frequencies that are in range from
93.75MHz to 24MHz.

Frequency 24V1, 24V2, 24V3 and CPUCLK selection is done easily, by setting
appropriate parameters in Device Editor or during program runtime by selecting three
lower bits of OSCCR0 register.

CLK32K is a slow signal with a frequency of 32kHz. It can be used as a programmable

component input. It can also be used for Sleep timer wake-up operation in the case when
other SYSCLK derived signals are inactive.

Signal SYSCLK can be acquired using internal main oscillator (IMO), while CLK32K
signal is acquired through internal local oscillator (ILO).

Fault tolerance of 2.5% in the case of internal frequency generation, is the limit factor in
a precise timing applications. In such case external SYSCLK clock reference should be
used. External frequency ranges from 1 to 24MHz. It connects to PSoC through pin
P1[4].

Similar situation is in the case of CLK32K, which also can be generated by internal local
oscillator (ILO), as said before, or more precise external 32kHz oscillator. In the both
cases microcontroller starts with internal frequency generators, after which is necessary
to satisfy appropriate procedure.

[back to the top]

1.4 Microcontroller power consumption

Processor signal frequency CPUCLK is directly connected with the instruction execution
speed of the microcontroller. Doubling the frequency, program executes approximately
twice faster. On the other hand, higher frequency doesn’t necessary always mean better
overall performances. Main disadvantage in rising the frequency is it’s unwanted effect
on microcontroller power consumption, which is one of the main problems it the case of
battery supply. Other disadvantage of higher frequency is more intensive generation of
electromagnetic interference, which may affect on surrounding devices. Because of these
problems general rule should be applied, which says that lowest possible satisfactory
frequency should be used. Default value of PSoC microcontroller signal frequency is
3MHz, which is a compromise between speed and consumption.

To maintain the longest possible uninterrupted work time, it is an imperative to bring

power consumption to its lowest satisfactory functional level in battery operated devices.
Most of microcontrollers operate only periodically, while being in the idle state for the
most of their time. Major power saving can be achieved by bringing microcontroller to
sleep mode while microcontroller does no important role. Saving is achieved because of
all the frequencies, except CPU32K and SLEEP become inactive, while processor stops
instruction execution. Microcontroller could be woken up from sleep mode only by reset
or a interrupt.

Interrupt could be generated by a sleep timer or some digital block which use CPU_32k
frequency. Also GPIO pin or analog column interrupts can be used for CPU waking-up.
Sleep timer represents a special counter whose main role is to generate periodic interrupts
which enable waking microcontroller from power saving mode. Sleep timer frequency
interrupt ranges from 1 to 512Hz. After waking microcontroller does all needed
operations after which it’s being switched back to sleep mode and waits for another sleep
timer interrupt. There is a appropriate type of interrupt needed to wake the
microcontroller from sleep mode. Because of possibility for various irregularities to
occurs during the work of microcontroller there is a need to reset it in those cases, or in
other words, brought to beginning state. Begin state means all internal registers are
initialized and program continues its execution from beginning.

[back to the top]

1.5 Reset
POR

During the work of microcontroller, supply voltage variations occurs. It is very dangerous
if voltage drops beneath certain limit, because microcontroller can make some
unpredictable actions. In the case of such voltage drop detection, microcontroller is
switched into Power on Reset mode in which it remains until voltage stabilizes above
critical limit which is defined by Trip Voltage parameter.

XRES

External reset allows user to bring microcontroller to start state by switching a button.
Reset is achieved when XRES pin reads logic ONE. Simplest reset circuit can be made
with pull-down resistor and one switch.

WDR

Watch dog reset (WDR) is used for avoiding software dead-loops or other irregularities,
bringing the system in the start state. Using WDR, it is watch dog timer (WDT) is
periodically restarted inside of a main program, after which appropriate subprograms are
executed. In normal mode after certain time WDT is being restarted once again and
subprogram cycle continues. But, if program blocks in one of the subprograms WDT is
not reset, and WDR occurs.

[back to the top]

1.6 Digital Inputs and Outputs

Connection between a PSoC microcontroller with an outside world is achieved over
input-output pins. Eight pin group which could be accessed simultaneously are parts of
one port. Although port number differs from the type of the microcontroller, write and
read operations are done in the same way in any case. Port access registers are stored
inside of register address space noted as PRT0DR, PRT1DR, PRT2DR, PRT3DR,
PRT4DR or PRT5DR.
Writing to port

Writing value to PRTxDR initializes register which through init circuit drives the state of
pins. Init circuit can pass the signal from PRTxDR register directly (strong), over pull-up
or pull-down resistors or through open drain output. Beside that, there is a possibility to
isolate value of register from pin state (Hi-Z).

Reading port

Reading value from address PRTxDR digital state of voltage on pins is stored to register
A. In case that voltage is dictated by some external device, read value could differ from
voltage on PRTxDR register.

Drive Mode

Selection of the way in which init register PRTxDR is connected to pins can be set inside
of Device Editor or during runtime initializing registers PRTxDM2, PRTxDM1 and
PRTxDM0. There is eight methods to initialize pins in total, which enables connection to
different types of devices, with considerate smaller amount of external components. Pin
work modes are defined according to the following table depending on contents of
appropriate bit from registers DM2, DM1 and DM0.

DM2 bit DM1 bit DM0 bit Mode Data = 0 Data = 1

0 0 0 Resistive Pull Down Resistive Strong
DM2 bit DM1 bit DM0 bit Mode Data = 0 Data = 1
0 0 1 Strong Drive Strong Strong
0 1 0 High Impedance Hi-Z Hi-Z
0 1 1 Resistive Pull Up Strong Resistive
1 0 0 Open Drain, Drives High Hi-Z Strong (Slow)
1 0 1 Slow Strong Drive Strong (Slow) Strong (Slow)
1 1 0 High Impedance Analog Hi-Z Hi-Z
1 1 1 Open Drain, Drives Low Strong (Slow) Hi-Z

Strong mode is used when it is needed to connect the state on PRTxDR register directly
to pins. This way of connection is applied when pin is used as an input.

Analog Hi-Z mode is used when connecting analog signals, like AD converter input. In
this case, all internal connections between PRTxDR register and pin are disconnected, so
not to interfere with value of brought voltage.

Pull-up or pull-down resistors are used when connecting with buttons or some other
devices which demand this type of components. These resistors are defining the state on
input when button is not pushed.

Open drain mode is used when it is needed to bring several devices to the same line,
when it is needed to add one external pull-up or pull-down resistor. This mode is
convenient for realization of a line which signals if there has been a mistake to one of the
microcontrollers. For example, when used pull-up resistor version when zero (error)
occurs on any of output pins state of this line will be zero. Pins on PSoC microcontroller
allow user to generate interrupt on any pin, when signal changes, or on signal rising or
falling edge.

[back to the top]

1.7 Analog inputs and outputs

Some of input-output pins, beside their standard use can perform analog input or output
operation. Any pin of port P0 as well as lower four pins of port P2 can be used as analog
input. Inputs of port P0 are connected to analog blocks over analog multiplexers, while in
case of port P2 they are connected directly to programmable SC blocks. Pins P2[4] and
P2[6] can serve as external referent voltage inputs. Outputs from analog blocks can be
connected to 4 output buffers, which are connected to P0[2],P0[3],P0[4] and P0[5] pins.

[back to the top]

1.8 Accessing programmable digital blocks

Digital components, which are stored inside of programmable blocks, aren’t connected
directly to input or output pins. It is done in a way shown on following picture, which
depicts group of four digital programmable blocks. As it could be seen, pin connection is
established using global connection lines, multiplexer and lines of programmable blocks.
PSoC microcontrollers can have one, two or four digital programmable block groups like
this one depending on their family.
[back to the top]

1.9 Global input lines

Global input lines establishes connection between the pins and input multiplexers. Global
input lines are divided in two groups, depending on weather they can connect to ports
with odd (GIO) or even (GIE) index. Rule of connection is that it is possible to connect
only between a line and a pin which have the same index. For example, line GIO_0 can
connect only to zero pin of some of the odd index ports (P1[0],P3[0],P5[0]).

Input multiplexers of block lines

Input multiplexer selects one of global lines and connects it to signal carrying line which
leads to programmable blocks. Picture shows that input block lines can be connected to
GIO or GIE lines with same index, or with index with offset four.
[back to the top]

1.10 Digital programmable blocks

Inside of digital programmable blocks user can configure components like timers,
counters, PWM, PRS, CRC generators and devices for SPI, IrDA and UART
communication, which enables custom hardware adjustment of the system for specific
uses. The process of setting and connecting using PSoC Designer is very simple to
understand, but at first is necessary to understand the way those components function.
Most components, like counters, PRS and CRC generators can be stored inside of any
free block. On the other side, communication components like Rx, Tx, UART and SPI
can be set on the right side of the programmable blocks.
The number of necessary blocks which are used for component configuration shown in
the table:

Number of blocks Components

1 Counter8, Timer8, PWM8, PRS8, RX8/TX8, SPIM/SPIS
Counter16, Timer16, PWM16, PRS16, PWMDB8, CRC16, UART,
2
IrDARx/IrDATx
3 Counter24, Timer24, PWMDB16
4 Counter32, Timer32

Frequency signal (CLK)

Frequency signal is needed for digital components to work. Depending on wanted speed
there is a range of several built-in frequencies to choose from:

• internal signal frequency VC1, VC2, VC3, SYSCLKx2, CPU_32

• output from adjacent blocks
• common Broadcast line (BC)
• input (RI) or output (RO) block lines

Most common internal signals are VC1, VC2 and VC3, because when used with different
prescalers, they offer broad range of possible frequencies. In case that signals VC1,VC2
and VC3 could not offer specified frequency, outputs from Counter, Timer or PWM,
which can be used like like additional prescalers. Picture above shows in dotted line
direct way to connect output of previous block with the input of the next block. In case
that signal needs to be routed across several blocks, connection is done over common
frequency line BC.

Component input signal

Most of the components, beside frequency signal, has one or two digital inputs. For
example, in the case of a counter and PWM generator input is used for enabling counting.
There are different possibilities in selection of the component input signal:

• block input lines (RI), which is a case of external signal

• block output lines (RO), in the case of component cascading
• analog block comparator lines
 • signal of logic one(high)
• signal of logic zero (low)

Component output signals

Digital outputs of the component are used for connecting programmable blocks with
output lines RO. Signal could be routed from output lines further toward output of the
microcontroller or input of some other component. Output multiplexers are used for
connecting lines of programmable blocks with global output lines.

Multiplexer

Depending on the state of multiplexer, output (RO) or input (RI) line of programmable
block could be connected.

Logic circuit

Selected signal can be brought to the output of logic circuit. As other input could be used
some of adjacent lines of programmable blocks (RO). Logic circuit can:

• pass one of two signals

• invert input signals
• do logic operations AND, OR or XOR over input signals which could be inverted
previously.

Output drivers

Logic circuit output can be routed to four output drivers, which can make connection to
one, or more, global output lines. Line of programmable blocks with some index can be
connected to GOO or GOE lines with same or by four higher index. Global output lines
makes connection between drivers and pins. They are separated in two groups, depending
on where they can be connected to ports with odd (FGIO) or even (GIE) index. Rule of
connection says that only lines and pins with the same index can be interconnected.
Beside that there is a possibility to establish a connection between input and output lines,
which enables additional processing of the input signal.
[back to the top]

1.11 Analog programmable blocks

Analog programmable blocks are grouped in columns of three programmable blocks.
Depending on family of microcontroller, there could be 1, 2 or 4 analog columns. Each
column has input multiplexer, one frequency line, output analog and a comparator line.

Analog multiplexers of port P0

Signals from port 0 are connected to analog ACB blocks over appropriate input
multiplexers. Multiplexers can select even (Port0_even) or odd (Port0_Odd) pins, while
two middle columns have the ability to choose either pins of port P0.
Analog inputs of port P2

Beside port P0, as analog inputs could be used four lower pins of port P2. This pins can
be connected directly to analog programmable blocks.

Analog columns

One column of analog blocks is made of three types of blocks: ACB, ASC i ASD.
Outputs of these blocks can be routed to some of adjacent blocks, output analog line or
comparator line.

ACB blocks are used to store amplifiers with rail-to-rail inputs and outputs, digital
controlled resistors and internal multiplexers. Depending on interconnections made inside
of ACB blocks, it is possible to implement inverting, noninverting, instrument amplifier
or comparator. As input to ACB blocks can be used analog multiplexer or output signal
of some of adjacent blocks.

ASC and ASD blocks are of switched capacitor (SC) type. They contains amplifiers with
rail-to-rail input and outputs, condensators and internal multiplexers. AD, DA and analog
filters could be implemented depending on configuration inside of these blocks. As inputs
to SC blocks, input from some adjacent block could be used. It should be noted, that
signals from analog multiplexers couldn’t be brought directly to SC blocks, but over
ACB blocks.

Analog outputs

For every analog column is common to have an AnalogOutBus line. Analog output lines
can be are connected, through a buffer, to four middle pins of port A.
Comparator outputs

Every analog column has one comparator line, to which could be connected digital output
from one of analog blocks. Comparator output could be connected to digital blocks (most
common way of doing it is as counter signal, or timer). Before connecting, there is a
possibility to modify or combine comparator output of some column (A) with next
comparator line (B), using some logic operation.

Frequency signal

Many components, such as AD, DA convertors and filters, need to have a frequency
signal in the specific range, which affects the component’s speed. Frequency signal
selection done over appropriate multiplexers. For each of the columns it is possible to
select:

• internal frequency VC1

• internal frequency VC2
• output over some of the digital blocks, most commonly counter timer and PWM
generator, which is selected through the multiplexer.

[back to the top]

1.12 Referent voltage generators

There are three stable voltage generators in PSoC microcontroller:

• AGND
• RefH
• RefLo

AGND is ground voltage for analog components. Voltage values higher than AGND are
considered as positive, while less are negative. PSoC microcontrollers have one-side
power supply, so value of analog ground is somewhere in between GND and VDD.
AGND value is selected by user.

RefHi and RefLo represent referent higher and lower voltage, for AD and DA
components. PSoC microcontrollers have a system that can generate several referent
signal values AGND, RefHi and RefLo. This enables simple adjustment to different types
of voltage sensors. Referent voltages are made from internal temperature stabilized
bandgap voltage reference Vbg = 1.3V, supply voltage VDD or external signal as shown
in the following table. PSoC microcontrollers are well adjusted to work with battery
supply.

Ref Mux AGND [V] RefLo [V] RefHi [V]

Vdd/2 ± Vbg 2.5/1.65 1.2/0.35 3.8/2.95
Vdd/2 ± Vdd/2 2.5/1.65 0 5.0/3.3
Vbg ± Vbg 1.3 0 2.6
1.6Vbg ± 1.6Vbg 2.08 0 4.16
2Vbg ± Vbg 2.6 1.3 3.9
2Vbg ± P2[6] 2.6 1.6 3.6
P2[4] ± Vbg 2.2 0.9 3.5
P2[4] ± P2[6] 2.2 1.2 3.2
[back to the top]

1.13 Switch Mode Pump

In the case of battery suply Switch Mode Pump (SMP) system can be used. Its operation
is based on principle of BOOSTDC/DC convertor. This type of convertor gives voltage
supply value higher than battery voltage, which makes possible power suplly with 1.5V
battery. For SMP to function properly, it is necessary to connect, beside battery, a diode,
inductivity and a capacitive.

[back to the top]

1.14 MAC
MAC unit is a device that implements operation of hardware multiplication of 8-bit
signed numbers, as well as sum of product. For execution of these operations there is no
special instruction, but all of the work is done by writing to and reading from certain
registers.

Hardware multiplication

Multiplication operation is done by writing 8-bit inputs X and Y into registers MUL_X
and MUL_Y, and reading output from 16-bit result from registers MUL_DH and
MUL_DL.
;file: main.asm
;project: MAC

mov reg[MUL_X],0x64 ;Initialize X = 100

mov reg[MUL_Y],0x0C ;Initialize Y = 12
mov A,reg[MUL_DH] ;Read high byte of result (0x04)
mov A,reg[MUL_DL] ;Read low byte of result (0xB0)

mov reg[MUL_X],0xFE ;Initialize X = -2

mov reg[MUL_Y],0x03 ;Initialize Y = 3
mov A,reg[MUL_DH] ;Read high byte of result (0xFF)
mov A,reg[MUL_DL] ;Read low byte of result (0xFA)

Sum of products

During multiplication, result can be added to previously stored value inside of 32-bit
accumulator. In that way is made sum product operation, which represents most
important operation of digital signal processing for correlations, convolutions and
filtering. Beside that MAC unit allows simple implementation of multibyte
multiplication.

Summing products is done when data X and Y are initialized by writing into registers
MAC_X or MAC_Y. Input data X and Y could also be initialized by writing into
registers MUL_X and MUL_Y, in which case operation of product summing does not
take place. Result of product summing operation is stored inside of registers ACC_DR3,
ACC_DR2, ACC_DR1 i ACC_DR0. Starting value of accumulator is set to zero by
writing any value to register MAC_CL1 or MAC_CL0. In the next example shows
method of initializing input data, as well as operation of summing products.

[back to the top]

1.15 Decimator
Decimator component is component that is used for digital data processing during sigma
delta, as well as some types of incremental AD conversion.

;file: main.asm
;project: MAC

mov reg[MAC_CL0],0 ;Clear Accumulator

;(Acc = 0)

mov reg[MUL_X],5 ;Initialize X

mov reg[MAC_Y],4 ;Initialize Y and execute MAC
;(Acc = 0 + 5 * 4 = 20)

mov reg[MUL_X],6 ;Initialize X

mov reg[MAC_Y],5 ;Initialize Y and execute MAC
;(Acc = 20 + 6 * 5 = 50)

mov reg[MUL_X],3 ;Initialize X

mov reg[MAC_Y],2 ;Initialize Y and execute MAC
;(Acc = 50 + 3 * 2 = 56)

mov reg[MAC_Y],2 ;Initialize Y and execute MAC

;(Acc = 56 + 3 * 2 = 62)

mov reg[MAC_X],4 ;Initialize X and execute MAC

;(Acc = 62 + 4 * 2 = 70)

mov A,reg[Acc_DR0] ;Read low byte of result

;(0x46 = 70dec)

[back to the top]

1.16 I2C Controller

I2C controller implements hardware serial I2C communication, and in that way
minimizes usage of CPU units resources. Most important operations of I2C controller
are:

• Master or Slave, sending or receiving data

• Byte level data processing
• Connected to CPU over interrupts or polling mode.
• Transfer speed: 50K, 100K and 400K
• Frequency synching in case of larger number of masters
 • 7or 10-bit addressing of I2C unit

[back to the top]

1.17 Interrupt Controller

Interrupts are mechanisms inside of a microcontroller that allow responding to some
event immediately after its detection. Events could be internal (timer overrun, end of AD
conversion) or external (character receiving over serial connection, pin state change).
When interrupt occurs program execution is interrupted (hence the name) by jumping to
part of the program that is called interrupt routine. Upon ending of that routine program
continues from place in program where interruption took place. Interrupt controller
makes hardware interrupt detection, program flow interruption by jumping to interrupt
routine, as well as returning to interruption point from the routine. These operations are
executed in several steps:

1. When event that triggers interruption takes place, interrupt controller stores
interrupt type.
2. End of current instruction is awaited.
3. If interrupt is allowed and if global interrupt permit is set to 0ne (GIE = 1),
interrupt processing begins. For later continuing of instructions execution, stack
holds values of PCH, PCL and F registers.
4. New interrupt occurrence is disabled by setting values of register F to zero (GIE =
0).
5. Program counter is set to address of interrupt routine, which is same as interrupt
type, after which execution jumps to interrupt routine address.
6. Program executes interrupt routine instructions.
7. When it gets to instruction reti, which marks return from main program, values of
F register are restored from stack, and program counter is reset to old value before
interrupt occurred.

Register PRTxIF is used as indication of GPIO interrupt on certain port, while

PRTxIC1and PRTxIC0 are appropriate control registers. Every interrupt type can be
masked or deleted, which is done with help of INT_MSK and INT_CLR registers, which
will be discussed in more detail in examples part.

[back to the top]

1.18 Address space
PSoC microcontrollers have three address spaces:

• ROM
• RAM
• registers

As in all Harvard architecture processors access to ROM memory is done with special
lines, so microcontroller is able to acquire instructions and access data at the same time.

Program memory

Program memory is the part of ROM, which is used for storing program code, which is
written in this part of memory written by programming hardware. Program memory is
implemented in FLASH technology, which allows simple development time change of
the program inside of microcontroller. Program memory size depends on the family of
PSoC microcontrollers and is 2, 4, 8, 16 and 32 kB.

Supervisory ROM

Supervisory ROM is part of ROM which is used during start of PSoC microcontroller, as
well as for calibration of components. With special instruction SSC, it is possible access
this part of memory.

RAM

RAM enables storing of variables and stack which are used during work of
microcontroller. Size of RAM, in most PSoC microcontrollers, is 256 bytes. When
microcontrollers have more than 256 bytes of RAM (series CY8C29xx and CY8C21x34),
memory is organized in 256 byte pages, with stack residing on the last page. To access
some variable, user apart from 8-bit address must state appropriate page.

Register

Register address space contains registers used for peripheral's global parameters and
programmable blocks of a PSoC microcontroller. PSoC microcontrollers have 512
registers, which are grouped in two 256 bytes banks. To access some register, beside
stating its name, what is needed is to also state the name of the bank in which resides
wanted register. Access to certain bank is done by using macros M8C_SetBank0 and
M8C_SetBank1, which delete or set bit XIO in CPU_F register.

Chapter 2: PSoC Designer

From the free online book “Architecture and Programming of PSoC Microcontrollers”

• Introduction
• 2.1 Programmable Component Selection
• 2.2 Interconnection View
• 2.2 Application Editor

Introduction
PSoC Designer is program package that leads user through all stages of developing
project. Version discussed here will be 4.2, but this book will still remain competent in
case of newer versions, because differences are shown only in addition of new
programmable components and some minor improvements. The most important for user
is is to get familiar with two main parts of PSoC Designer:

• Device Editor
• Application Editor

Beside these two, there is also a debugger part, but during the course of this book it is
only mentioned as an option, because it demands additional hardware. Device editor
consists of two windows. First one is for selection and is called User Module selection
View. Other, is called Interconnection View. It is used for setting and connecting
components and parameter adjustment. Transfering from one to the other part of the
PSoC Designer is done easily by clicking appropriate icon. To open Interconnection
View or User Module Select windows, Device Editor icon must be selected first. Lower
image shows look of the programmable component choice window.

[back to the top]

2.1 Programmable Component Selection
Most important part of the programmable component selection window is placed on the
left side. Components sorted in several groups, like AD converters, amplifiers, analog
communications, counters, etc. After group selection, necessary component for project
should be selected with double-click, or right-click on select. In the case of successful
selection, appropriate graphical symbol would be shown in selected components slot.

The rest of the window offers some other useful information. Resource Meter shows how
much space is left for new programmable blocks. For example, 16-bit counter takes two
programmable blocks, so it is possible to place 4 counters like this one altogether. During
selection of each of the components, in lower side of the window is opened detailed
instruction, which gives information about block characteristics, usage and code example.
User does not have to know by heart all details about the component he uses, because this
part holds all necessary information.

[back to the top]

2.2 Interconnection View
Previously selected components are still unusable, until they are placed in digital or
analog programmable blocks, and until appropriate parameters are set. This important
part of work can be done in Interconnection View window. Central part of this window is
graphical representation of programmable blocks and connection lines. In the case of
microcontroller of CY8C27xxx series, eight digital and twelve analog programmable
blocks can be used. In the place between blocks there are internal lines for
interconnection, and global purpose input/output lines. Although this scheme looks
complicated at first sight, you can be sure that it isn’t hard to master the way it is all
connected. In some way it resembles PCB routing, but really much simpler.

Global Parameters

On the upper left side can be found Global Resources window. It is used for general
parameters selection.This method of setting is similar to configuration words on other
microcontrollers, but with more versatility. Click on any of the parameters opens pull-
down menu with given options.
All global parameters have default values, which means that even without setting
microcontroller will be able to work. For example supply voltage can be 5V or 3,3V,
depending on selection in parameter Supply Voltage. If user does not make selection,
Supply Voltage parameter would be set on it's default value of 5V. When higher
frequency precision is necessary it is possible to add external oscillator on lower two pins
of port 1, and choose external as option in mentioned parameter. Most important
parameters for our examples are internal frequency prescaler values of V1, V2 and V3.
Signals V1, V2 and V3 are used by various analog and digital programmable blocks. V1
signal frequency value can be derived by dividing system frequency of 24MHz with
prescaler N1. V2 signal frequency value is aquired by dividng signal V1 with N2.
Acquiring signal V3 is done in similar fashion, by dividing some signal with value in N3,
with possibility to choose from several different signals the one that will be divided.
CPU_Clock represents frequency value, based on who are processed instructions of
microcontroller.

Component Parameters

Central window on the left side is designated as User Module Parameters. Peripherals in
PSoC microcontroller are very flexible, so it is required to set the way of their operation.
Typically this is done by selecting frequency of the signal, connecting it with some other
blocks and internal connection lines. Also, component specific parameters can be set.
Such parameters are component specific, and it will be more discussed in chapter 5. In
the picture below example for setting up component PWM16 is represented. In this case
frequency signal is VC2. Time interval of impulse and pause is 32000 and 16000,
respectively, of chosen frequency signal. Obligatory part of parameter are signals that are
entering, and exiting programmable components. This operation can also be done in
graphical mode, clicking inputs and outputs on set component. Picture holds example of
adjusting signal frequency on component PWM16. Click on black triangle, which
represents signal input, enables selection of possible clock signals. Specific parameters
like impulse and pause interval, enable and similar are not obligatory to be set in this
window, but is however desired. At a later point, while writing program in Application
Editor, there is possibility for changing these values by calling specific procedures.

Pin Parameters

Lower left side holds pin parameter options. In order to protect external devices from
unexpected signals, default pin state of PSoC microcontrollers is Analog Hi-Z, in which
microcontroller cannot change pin states. Pin drive mode selection can be done
graphically by selecting appropriate parameters in column Drive or software by setting
appropriate registers.

Option select is used for choosing the way pins are driven. If selected option is StdCPU,
then pin have standard input/output function, and is disconnected from programmable
blocks. If pin is supposed to be connected to appropriate global lines over which is
established connection with peripherals it is expected to be done by user. Easiest way to
do it is graphical, as it will be explained in next section of the book.

Column Drive is used for pin drive mode settings. Options pull-up or pull-down activate
internal resistors, which set default logic state of pin to ONE, or ZERO, respectively.
This is of importance while working with devices like push-button switches, because they
allow direct connection to PSoC microcontroller without need for external resistors. Pull-
up or pull-down resistors must not be used on analog inputs, like input of AD convertor
because they can have impact on input voltage level. In such case state of high
impedance, marked with Hi-Z Analog, should be chosen.

Third column is used when in the case of pin interrupts. It is possible to to select interrupt
on rising edge, falling edge or state change depending on previous readout. For example,
one of efficient ways to measure signal interval could be allowing interrupt on rising edge
of signal. In interrupt routine is then started a timer, and following that, is allowed
interrupt on falling edge, where timer is stopped in interrupt routine.
Placement

Free locations for setting programmable blocks are represented by grey rectangles.
Clicking some of selected components, marks placement space in graphical part. In case
that communication from selected block, and intended pin could not be established, next
available location could be selected, using icon Next Allowed Placement. Component
placement is done by selecting component, and then right-clicking on Place, or shorter,
using icon Place. During the placement of analog and digital components, general rule
applies, that components that are to be connected should be placed in adjacent blocks.
Components of upper four digital blocks are more easily connected among themselves,
than with components from lower four blocks. Similarly, it is easier to connect analog
components that are placed inside of one column.

Digital Components Interconnection

For start, the most important thing is to get to know the basic elements of programmable
blocks. Digital blocks are grouped in two entireties of four blocks, as shown on picture.
On the upper side of each row there are four input lines to digital blocks, marked in red,
and from the lower side of each block are four output lines marked in blue. Digital blocks
aren’t connected directly to output pins, but over multiplexer and global input or output
lines. Global lines are marked in green. Second letter in name tells about direction of the
line I - input, O - output. Last letter in name gives information if lines could be connected
only to E - even or O - odd ports. For example, GIE represents global input line that can
only be connected to ports with even index (i.e. Port 0, Port 2...).

Global input lines are placed on the left side, while global output lines are placed at the
right side. Procedure of connection global lines to pins is very simple. When certain line
is clicked on, a external pin name, or interconnecting input and output global lines, is
shown. Selecting option Pin, pins of ports with according index will be offered. For
example, global line GIO4 can be connected only with fourth pin of odd number ports.
Global lines are connected with digital lines from programmable components over the
multiplexer.
Multiplexer has a function to choose one input signal that will be connected with his
output. Graphically, it is represented with a small square. There are input and output
multiplexers, depending on connecting input or output lines. Clicking on some of input
lines of digital programmable blocks, opens window with possible choice of connection.
Connectiong on global output lines is a little bit more complicated than in previous case.
The selected output line is taken, which is routed to output buffers. On upper left side is
positioned multiplexer, which can select optionally connecting shown input line.
Connection to global lines is established by clicking on appropriate buffer, which is
represented in shape of triangle.

If this step is done correctly, buffer will be painted blue as well as line that goes out from
it. As additional element there appears a possibility for implementing logic functions with
adjacent lines. Selection of logical functions is done by clicking on small square, and by
choosing one of the options, after which is shown appropriate symbol. All digital
components have input for frequency. Frequency signal is marked with black triangle.
With left-click menu with possible selection of signal frequencies is shown. Some of
possibilities are 48MHz, 32kHz, V1, V2, V3, as well as signals from some of global
lines, BC lines or adjacent blocks. There are two groups of common lines marked as BC1
and BC0. Beside frequency input, other input/output lines could be found, depending on
component type.
Analog Components Interconnection

Analog blocks are placed on lower side of the graphic part of the window. Four analog
columns and several multiplexers can be noticed. In every of columns, upper block ACB
is used for analog amplifiers realization, while lower two are used for AD and DA
convertors. Routing is done graphically, by connecting frequency signal, and input signal
to the same analog column. Pins with analog input/output of ports 0 and 2 are shown on
the left side, which could serve as analog inputs or outputs. Columns on far left or right
side could be connected only to odd or even pins of port 0, respectively. With help of two
additional multiplexers there could be connected two middle analog columns to any pin
of port 0. Each of analog columns can have one output that leads to one of four pins of
port 0. Connection is established by using buffer that resides on bottom of every column.
[back to the top]

2.3 Application Editor

Application Editor is used for writing programs, which can be done using assembly or C.
Application Editor itself, bears much resemblance to IDE-s of other standard 8-bit
microcontrollers. Left side window holds list of files that are contained in current project.
Most important file for users is called main.

This is the place of user code start. Include files are generated automatically based on
selected programmable blocks in Device Editor, clicking on icon Generate Application.
For example, if set programmable blocks are adcinc12, pga, and lcd, PSoC Designer
automatically generates files with data and subprograms for their usage. So in the case of
AD conversion, programming is done as simply as calling subprogram with start
instruction call ADCINC12_Start and result readout with call ADCINC12_GetSamples.
File Boot.asm is should not be changed because it is automatically rewritten during each
new configuration. Names of available subprograms in part Library Source are in file
with according name. When process of programming is done, compiling is started by
clicking icon Build. In case of succesful compiling there will be shown message in lower
window 0 Errors. At the same time, in folder output of the current project, .hex file will
be shown which can be programmed into microcontroller.

Chapter 3: Quick Start

From the free online book “Architecture and Programming of PSoC Microcontrollers”

• Introduction
• 3.1 Creating a Project

Introduction
Every beginning is the hardest part of every job. Because of that, it is very important to
write complete project that works, as soon as possible. What else could be in a
microcontroller world than LED blinking? Basic idea is that we implement LED blinking
by using PWM16 component, with the same signal/pause ratio. It is done in a very simple
way, by selecting frequency of 32kHz with period set to 32000, and impulse to 16000, for
base frequency of PWM16. User just should connect output of PWM component to
output pin Port_1_0 to where is LED connected, and write simple code to start PWM
component. All the steps are similar in more complex projects.

[back to the top]

3.1 Creating a Project

Click on the New Project icon opens a New project Wizard, where user should specify
name, and location of the project.

Left side of the window is used to choose the way that new project will be formed. Most
common choice is to start new project by click on Create New Project icon. If there was a
need to modify already existing project, or change of microcontroller type of some
previous design, one of lower two choices should be selected.

Click on the Next, new window with assembler or C selection is opened. Option
Assembler is available to all users, while for C one needs license. For this example,
microcontroller CY8C27643 and Assembler should be selected.
Button Finish opens Device Editor window where user can select programmable
components. Component PWM16 can be found in PWMs section. Importing it to the
project is done simply, by marking its icon, and right-click selection. As a result of this
operation, graphical simbol of PWM16 block will appear in selected components slot,
automatically named as PWM16_1. This name can be changed by user.

Note that resource window shows that component PWM16 takes two digital blocks,
which means that it is possible to place a maximum of three blocks like this. After
component selection, we go to interconnection window by click on the icon Interconnect
View.

Component placement in a marked free locations is simply done by right click on the
component.
Next step is to adjust parameters of PWM16 component. Period and width of PWM
impulse is set in window User Module Parameters. Parameter value of 32000 with input
frequency CPU_32_KHz results in one second period. For equal length of signal and
pause, Pulse Width is set to half of period, e.g. 16000. Final view of the User Module
Parameter window is illustrated in the figure below.

PWM16 output signal CompareOut is connected to output pin P1[0] in three steps. As a
first, since LED has been connected to pin Port_1_0, PWM16 output CompareOut
should be connected to digital output line with index 0, in this case Row_0_Output_0.
Click on this line opens output digital multiplexer settings, where should be done
connection to a global output line by enabling appropriate buffer.
Since LED is placed on odd Port_1_0, it is necessary to make connection trough Odd
buffer line GOO_0 as it was illustrated in a figure above.

Final link with output pin is accomplished by click on Global_OUTOdd_0 linije and
selecting pin Port_1_0.

When component is placed, and connected to output pin user can start to write code.
Before that, Generate Application icon should be clicked, which starts automatic
generation of files for PWM16 component.

Application editor selection is done by appropriate icon click, which is shown in the
figure below.
On the left side of Application Editor, list of all automatic generated files can be found.
Click on file main.asm from Source Files section, opens the main program window. For
PWM16 to start working, all necessary is to call Start procedure PWM16_1_Start. List of
all other subprograms that could be used for given component is found by opening .asm
file with the same name as the component in Library Source section, or in appropriate
component manual. Click on pwm16_1.asm opens a window with all subprograms. All
available subprograms from this file are declared with directive extern.

After code is written, compiling should be started by clicking on icon Build. In case when
code does not contain any mistakes, compiling will be succesfully, and blink.hex file will
be generated in the folder output.

Chapter 4: Assembly Language

From the free online book “Architecture and Programming of PSoC Microcontrollers”

• Introduction
 • 4.1 Instruction types
• 4.2 Operators
• 4.3 Constants
• 4.4 Instruction set
• 4.5 Directives
• 4.6 Addressing modes

Introduction
Complete set of 37 basic instructions, which makes with their sub-variants total number
of 136 instructions, are explained in this chapter. Reason for such large number of
instructions lies in the fact that this is a CISC architecture microcontroller, whose
instructions allow pretty much conform programming. One disadvantages is that
instructions are not optimized for speed, because their execution takes several instruction
cycles.

4.1 Instruction types

Data transfer

Data transfer is done by instructions MOV, MVI and SWAP. MOV represents basic
transfer instruction, which offers large number of arguments. First argument is
destination location, while second source location. There are 21 types of MOV
instruction in total, in dependence of data types. Shortest execution time is in the case
when data is transferred trough internal registers A and X, while it is the longest when
transferring contents of two variables. Instruction MVI is optimized for data transfer
between accumulator A and array of sequential data locations. Aside from transferring
data, at the same time initialization, which is needed for acquiring next element, takes
place. One of the arguments is register A, and other is the value of variable that has a role
of pointer to array, i.e. which holds address of the first array element. Instruction SWAP
is used for direct exchange between registers A,X and a value of some variable Beside
that, there’s also a possibility of exchange of values in registers A and SP.

Arithmetic and logic

PSoC as well as other microcontrollers has built-in support for arithmetic operations, like
addition or subtraction. Instructions ADD and SUB are two basic operations. Value of the
first argument is added or subtracted with other argument, and result is stored in the first
value Beside basic operations of adding and subtracting, there are also existing their
modifications. There are instructions INC and DEC, which implements increment (add 1)
or decrement (subtract 1) operations. ADC and SBB makes addition or subtraction
operation, while Carry Flag is added to the result, which allows simple multi-byte
operations. MAC unit allows operation of hardware multiplication. There are no special
instructions for this operation, since all the work is done in special multiplication
registers. Values that are multiplying are transferred to registers MUL_X and MUL_Y
with MOV instruction, and then high end, and low end bytes are read from registers
MUL_DH and MUL_DL.

Logic unit of PSoC microcontroller has ability to handle standard logical operations
AND, OR, XOR, negation (CPL), shifting (ASL, ASR) and rotation (RLC, RRC). For
operations that have two arguments holds rule that operation is executing on according
bits of both arguments, and the result is stored in first argument. In case of CPL
instruction content of accumulator is completed bit by bit, so that every zero is replaced
by one, and opposite. Instructions of shifting and rotation moves bits one space to the left
(toward bit 7) or one space to the right (toward bit 0), while the bit that exits register is
written into Carry Flag of F register. There are differences in the way how are set bit 0 or
bit 7. ASL and ASR instructions are used for signed multiplication and dividing by
number 2. In the case of ASL zero bit is set to 0, and in the case of ASR, bit seven is not
changed. Rotation instructions RLC and RRC are writing bit exiting register Carry Flag
into which is later written to bit on opposite side of register.

Comparation instructions

Because of need to compare arguments, there are two instructions CMP and TST. These
instructions have two comparing arguments that don't change their value. Result of these
instructions represents state of Z and C flags in F register.

Instruction CMP is used to compare two values. If both arguments are equal, Z flag will
be set to one. If first argument is lower than the other C flag will be set to one, in every
opposite case C and Z flags will be set to zero.

TST instruction is doing AND operation between the first argument, and eight-bit
constant, during which the result is not written in first argument, like in case of AND
operation. If result of AND operation is zero, then flag Z will be set to one. TST
instruction gives possibility to test if certain bit of some register is set to zero or one. As
eight-bit constant should be taken mask value, which has all zeroes, and one in position
where are test bits. In this case, flag Z shows that bit is set to one. PSoC microcontrollers
support conditional, unconditional and subprogram jumps.

Decision and Control statements

Instructions of relative jumps allow us to continue program execution from given label if
condition for that jump is met, which means that appropriate flag is set - C, for jumps JC
and JNC, and Z for JZ and JNZ jumps. If condition is not met, program continues to
execute the next instruction.

Unconditional jumps use two sets of instructions, depending on how far jump address is.
For close jumps instructions JMP and JACC are used, while instruction LJMP is used for
far jumps.
Instructions JACC uses offset jump relative to given label, whose value is stored in
register A.

Calling routine (CALL) and return (RET) from subprogram, as well as returning from
interrupt (RETI) are executed the same way as in other microcontrollers. Instructions for
stack operations Instructions PUSH and POP are, in standard ways, allowing storing
values of important registers inside of stack during procedure calling. PUSH instruction
is copying value of register A and X, while instruction POP returns values in opposite
order. Stack is LIFO ordered, which means Last In First Out, which explains a little bit
more the way PUSH and POP instructions function. Stack is positioned in upper part of
RAM, so it wouldn’t overlap with defined variables. Beside holding important registers,
these instructions allow transporting procedure parameters over stack, by storing
parameter using PUSH before procedure call, and taking it from stack by calling PUSH
instruction from inside of procedure. Instructions PUSH and POP with help of index
addressing allow realization of local variables inside procedures, which will be discussed
later in examples part.

Accessing ROM Data that is stored in ROM can be accessed with help of instructions
INDEX and ROMX. INDEX is of special importance during look-up table reading.
Offset of the element that is being accessed is previously stored in accumulator A, while
the label of look-up table is called as argument. Result of read value is stored in register
A.

Other instructions Of other instructions, most important one is NOP, which does no
special operation, but is used for time delaying that lasts four instruction cycles.

4.2 Operators
Among instructions, where constants appear, it is possible to form statements with help
of assembler operators for arithmetic and logic functions. Execution of operators has
nothing with work of microcontroller, because that work is being done by compiler
during program translation. Next table gives comprehensive list of assembly operators.

4.3 Constants
Decimal constants are written without any prefixes, while hexadecimal ones have prefix
0x or $, while binary ones have 0b or %. Constant character arrays are written inside of
quotation marks.

4.4 Instruction set

(work in progress)

4.5 Directives
Directives represent useful elements in assembly that give various information of interest
for program translation. Some of more important directives will be covered further.

DB

DB directive is convenient for look-up table forming where bytes are used as data. Binary
values of constants are written inside of ROM memory at the address specified by label.

Table1: DB 1,2,3

DW, DWL

When it is needed to form look-up tables with word type elements, then it is possible to
use directives DW and DWL, depending on which byte do they store first, lower then
higher or contrary.

Table2: DW 0x1234,0x1235
Table3: DWL 0x1234,0x1235

DS

During the work with serial communication or writing data on LCD, it is often needed to
use ASCII values instead of binary. Directive DS writes to program memory ASCII
values of constant array of characters that are written inside the quotes. In the case of
character “0”, in memory will be written character ASCII value 48.

Table4: DS “0123456789”

When all elements of constant character array are loaded in memory, there is a need to
somehow detect an end of array. Because of that it is common to add ASCII character
NULL to an end of array, which is represented as binary 0.

Table5: DS “HelloWorld” DB 0

INCLUDE

include "filename" Directive include is used to insert content of given .asm or .inc files.
In this way it is possible to combine several files which contain different parts of
program, thus improving code readability and reusability. There is a directive in the
beginning of main program include “m8c.inc” which enables access to microcontrollers
registers. File PSoCAPI.inc is used as a connection towards files that contain procedures
for working with selected programmable blocks.

; Assembly main line

include "m8c.inc" //
include "memory.inc" // Constants & macros for SMM/LMM and Compiler
include "PSoCAPI.inc" // PSoC API definitions for all User Modules
include "User.inc"
export _main

_main:
call PWM16_1_Start
.terminate: jmp .terminate

EXPORT

export procedure_name

Directive EXPORT is being used to mark that the procedure written in current file can be
used in other files. Directive Export is put before procedure implementation, usually in
the begging of that file. As an example is given file with procedures for programmable
component PWM16.

EQU

equ value

Directive EQU enables giving constant name to some value Before compiling that name
is automatically changed into according constant value.

4.6 Addressing modes

There are several ways to fetch data during instruction execution, which are all called
under one name addressing methods Depending on whether data is a constant, RAM
variable or register variable, there are immediate, direct, index and indirect addressing
method. Beside these complicated looking names, very simple procedures are hidden.

Immediate addressing

When data is a constant value, then it is considered as immediate addressing. For

example: Data could be RAM variable, or a register. Easiest way to access value of that
variable is by putting it’s name inside of brackets. If we didn't put those brackets, we
would access address of that variable, instead of its value.

Register addressing

When accessing register, beside brackets, it is also needed to put registered word reg,
which shows that it is done in register address space.

Index addressing

One other thing that also happens very often is the need to access continuous memory
locations. In that case we could some help from register X, which has a possibility of
index addressing. Index register X is used to store address of some variable. Incrementing
and decrementing values of the index register it is possible, in a simple way, to access
elements of an array.

Using instruction MVI, it is no longer needed to continuously increment register X. In

this case variable which plays role of a pointers used instead of register X. Its value is
previously initialized to hold address of the variable that is being accessed. MVI transfers
values between accumulator A and value of the variable, with initialization of pointer-
variable so it stores address of next variable in array.