The previous program was created to be the simplest yet easy to read program (it could be made smaller) to blink a LED from the st8sdiscovery board but it made some assumptions that would not exist in a more extensive program. You may have wondered why we ditched all the generated code the IDE created. It was in order to make things as simple as possible. Now we will look at what should be done in initialising a program and the stm8 MCU so it does not take its revenge on us later.

Steps required to initialise the stm8 CPU

1. Set up the stack pointer to we can call subroutines , use interrupts and perform stack operations.
2. Clear the ram memory so it is in a defined state.
   
3. Set up an interrupt table so interrupts are handled if they should be enabled.

The code has become to big for screenshots so now we will display it in-line.


We have added the include file mapping.inc which was automatically generated for us, It defines stack_segment_end , stack_segment_start and ram_segment_start. We use these to initialise the stack pointer and clear all of the 2k of ram. We have also added a default interrupt handler NonHandledInterupt and set up the interrupt vector table.

Some points to note.

We can only load the Stack Pointer SP from another register not an immediate value , so we load it from the X register which has been set to that value.

The clr(X) (clear) is an example of direct indexed addressing , the X register has the value of the memory location which is cleared to zero then the X Register is incremented to the value of the next memory location and clears that within the loop, This continues until the cpw (compare word) instruction finds that X is greater than the value of stack_segment_end.

The interrupt table is started at the new segment 'vectit' which lies within the flash rom at address 0x8000 the beginning of the flash rom.

The dc.l  directive forces the long word given as its argument into the object code at the current address so the interrupt table is set up from 0x8000 to 0x8080.

The iret instruction is used to return from an interrupt routine back to the code before the interrupt occurred.

Wait a minute shouldn't the LED blink faster ?

Yes it should when the st3s105 boots up it runs on the internal RC oscillator which is set to 1/8 of its frequency @ about 2mhz so in real world application we would probably want this to run as fast a possible as soon as possible.

First lets slow down the LED blinking so if stays on and off for about 8 seconds. Change the code to have another inner loop using the other 16 bit register Y. We will then know if the clock has indeed been set to maximum by the fact the LED will light for about 1 second.

The STM8S105C6 Clock

"The clock controller is designed to be powerful, very robust, and at the same time easy to use. Its purpose is to allow you to obtain the best performance in your application while at the same time get the full benefit of all the microcontroller’s power saving capabilities. You can manage all the different clock sources independently and distribute them to the CPU and to the various peripherals. Prescalers are available for the master and CPU clocks."

4 different clock sources can be used to drive the master clock:
● 1-24 MHz high speed external crystal oscillator (HSE) ( the discovery board is 16mhz)
● Up to 24 MHz high speed user-external clock (HSE user-ext)
● 16 MHz high speed internal RC oscillator (HSI)
● 128 kHz low speed internal RC (LSI)

In order to speed up the internal clock we need to look at the Clock divider register (CLK_CKDIVR).In order to product the final CPU Clock it is divided twice once by HSIDIV and then by CPUDIV.

CLK_CKDIVR  0x50C6

Bit Pos	7	6	5	4	3	2	1	0
	reserved	reserved	reserved	HSIDIV1	HSIDIV0	CPUDIV2	CPUDIV1	CPUDIV0
R/W	rw	rw	rw	rw	rw	rw	rw	rw
Reset Value	0	0	0	1	1	0	0	0

For HSIDIV1: HSIDIV0

00: fMaster = 16mhz
01: fMaster = 16mhz/2 = 8mhz
10: fMaster = 16mhz/4 = 4mhz
11: fMaster = 16mhz/8 = 2mhz

For CPUDIV2: CPUDIV1: CPUDIV0

000: fCpu = fMaster 
001: fCpu = fMaster / 2 
010: fCpu = fMaster / 4 
011: fCpu = fMaster / 8
100: fCpu = fMaster / 16
101: fCpu = fMaster / 32
110: fCpu = fMaster / 64
111: fCpu = fMaster /128

So to get the maximum speed we simply set this register to zero. By setting the maximum divide (0x1F) we can set the CPU clock as low as 15.625khz if we ever wanted to.


So adjust the code to the above and the LED should now blink for 1 second approximately.

Hang on the Discovery has a 16mhz external crystal oscillator wouldn't that be better ?

Yes it should be more stable and accurate than the internal rc clock, here is some code without any explanation ....

Tidying up the code

To make the code more readable we can use symbolic names for the hardware registers rather than refering to the absolute address in memory, to do this we use the EQU directive of the assembler, for instance

We can also make blink a subroutine , we call it blink_one


The subroutine is called from the main loop, loop_forever


What happens here is that the call instruction jumps to blink_once and the delay loops are executed, once it has blinked the LED it will find and execute the ret instruction, this tells the CPU to return to whence it came just after the original call instruction and carry on executing the instructions that follow. In this case it will execute the jra loop_forever instruction. Note that the memory address that the CPU will return to is held on the the stack which is pointed to by the SP register , this is why it is important to set-up the stack and SP at the beginning of the program in order to be able to call subroutines and use the push and pop instructions which we have not covered yet but also use the stack.


The complete code of our tidy version



This code is not very efficient and wastes time and CPU cycels in the delay loop , next we will show how we can have all the time in the world