STM8S code examples

STM8S_programming_examples.md

This is a collection of code snippets for various features on the STM8S family microcontrollers (specifically the STM8S003F3). These are written against the STM8S/A SPL headers and compiled using SDCC.

Some of this controller's functions aren't particularly intuitive to program, so I'm dumping samples for future reference here. These are based on the STM8S documentation:

• STM8003 datasheet
• STM8S reference manual

Run at 16MHz

// Configure the clock for maximum speed on the 16MHz HSI oscillator
// At startup the clock output is divided by 8
CLK->CKDIVR = 0x0;

PWM output using TIM1

Note that on the STM8S003F3, TIM1_CH1 output requires configuring an Alternate Pin Function (see next snippet).

const uint16_t tim1_prescaler = 0;
TIM1->PSCRH = (tim1_prescaler >> 8);
TIM1->PSCRL = (tim1_prescaler & 0xFF);

const uint16_t tim1_auto_reload = 16000; // 1KHz assuming at 16MHz clock
TIM1->ARRH = (tim1_auto_reload >> 8);
TIM1->ARRL = (tim1_auto_reload & 0xFF);

const uint16_t tim1_compare_reg1 = 4000; // 25% duty cycle
TIM1->CCR1H = (tim1_compare_reg1 >> 8);
TIM1->CCR1L = (tim1_compare_reg1 & 0xFF);

// Set up compare channel 1
TIM1->CCER1 = TIM1_CCER1_CC1E; // Enable compare channel 1 output
TIM1->CCMR1 = TIM1_OCMODE_PWM1; // Make OC1REF high when counter is less than CCR1 and low when higher

TIM1->EGR |= TIM1_EGR_UG; // Generate an update event to register new settings
TIM1->BKR = TIM1_BKR_MOE; // Enable TIM1 output channels
TIM1->CR1 = TIM1_CR1_CEN; // Enable the counter

Using alternate pin functions (APF)

Some pins on the STM8S003 series are marked as having an "alternate function after remap". These are only documented in the datasheet, with register description under Option bytes.

As option bytes are stored in eeprom, they're a little more involved to set than regular registers. Eeprom can be addressed directly for reading, but needs to be unlocked before it can be written.

Option bytes are intended to be programmed once when uploading code to the chip, but they can be changed "on the fly" as the datasheet mentions:

// Set a bit in the Alternate Function Register (AFR) to switch pin-mapping
// This is stored in flash and is not a directly writable register
{
    const uint32_t AFR_DATA_ADDRESS = 0x4803;
    const uint32_t AFR_REQUIRED_VALUE = 0x1; // Enable TIM1_CH1 pin

    const uint16_t valueAndComplement = FLASH_ReadOptionByte(AFR_DATA_ADDRESS);
    const uint8_t currentValue = valueAndComplement >> 8;

    // Update value if the current option byte is corrupt or the wrong value
    if (valueAndComplement == 0 || currentValue != AFR_REQUIRED_VALUE) {
        FLASH_Unlock(FLASH_MEMTYPE_DATA);
        FLASH_ProgramOptionByte(AFR_DATA_ADDRESS, AFR_REQUIRED_VALUE);
        FLASH_Lock(FLASH_MEMTYPE_DATA);
    }
}

This works in a pinch and avoids an extra programming step, but switching function repeatedly during run-time is probably a bad idea:

• There's likely an endurance issue as each change is written to flash/eeprom (datasheet claims 100k writes).

• Writing some of the option bytes requires two writes: one for the data and one for its complement. If a reset occurs between the two writes, the option bytes need to be reprogrammed before the SWIM interface can program the chip again (stm8flash and ST Visual Programmer can still program the option bytes in this state, but error when trying to program the main flash).

Blocking ADC read

// Set up ADC
ADC1->CSR |= ADC1_CHANNEL_4; // Select channel to read
ADC1->CR2 = ADC1_CR2_ALIGN; // Place LSB in lower register
ADC1->CR1 = ADC1_CR1_ADON; // Power on the ADC

// Trigger single conversion
// (Yes, you write a 1 to the register a second time to do this - super intuitive...)
ADC1->CR1 |= ADC1_CR1_ADON;

// Wait until conversion is done
while ((ADC1->CSR & ADC1_CSR_EOC) == 0);

// Clear done flag
ADC1->CSR &= ~ADC1_CSR_EOC;

// Load ADC reading (least-significant byte must be read first)
uint16_t result = ADC1->DRL;
result |= (ADC1->DRH << 8);

ADC conversions driven by TIM1

This uses TIM1's compare channel 1 to trigger ADC readings. This can be slightly simpler if TRGO is configured to trigger on timer reset instead.

void init_adc(void)
{
    // Configure ADC to do conversion on timer 1's TRGO event
    ADC1->CSR = ADC1_CSR_EOCIE | // Enable interrupt at end of conversion
                ADC1_CHANNEL_4; // Convert on ADC channel 4 (pin D3)

    ADC1->CR2 = ADC1_CR2_ALIGN | // Place LSB in lower register
                ADC1_CR2_EXTTRIG; // Start conversion on external event (TIM1 TRGO event)

    ADC1->CR1 = ADC1_PRESSEL_FCPU_D18 | // ADC @ fcpu/18
                ADC1_CR1_ADON; // Power on the ADC


    // Configure TIM1 to trigger ADC conversion automatically
    const uint16_t tim1_prescaler = 16000; // Prescale the 16MHz system clock to a 1ms tick
    TIM1->PSCRH = (tim1_prescaler >> 8);
    TIM1->PSCRL = (tim1_prescaler & 0xFF);

    const uint16_t tim1_auto_reload = 69; // Number of milliseconds to count to
    TIM1->ARRH = (tim1_auto_reload >> 8);
    TIM1->ARRL = (tim1_auto_reload & 0xFF);

    const uint16_t tim1_compare_reg1 = 1; // Create a 1ms OC1REF pulse (PWM1 mode)
    TIM1->CCR1H = (tim1_compare_reg1 >> 8);
    TIM1->CCR1L = (tim1_compare_reg1 & 0xFF);

    // Use capture-compare channel 1 to trigger ADC conversions
    // This doesn't have any affect on pin outputs as TIM1_CCER1_CC1E and TIM1_BKR_MOE are not set
    TIM1->CCMR1 = TIM1_OCMODE_PWM1; // Make OC1REF high when counter is less than CCR1 and low when higher
    TIM1->EGR = TIM1_EGR_CC1G; // Enable compare register 1 event
    TIM1->CR2 = TIM1_TRGOSOURCE_OC1REF; // Enable TRGO event on compare match

    TIM1->EGR |= TIM1_EGR_UG; // Generate an update event to register new settings

    TIM1->CR1 = TIM1_CR1_CEN; // Enable the counter
}

void adc_conversion_irq(void) __interrupt(ITC_IRQ_ADC1)
{
    // Clear the end of conversion bit so this interrupt can fire again
    ADC1->CSR &= ~ADC1_CSR_EOC;

    // Load ADC reading (least-significant byte must be read first)
    uint16_t result = ADC1->DRL;
    result |= (ADC1->DRH << 8);

    // Use result ...
}

Crude delay function

These assume the clock is running at 16MHz and ok for crude blocking timing.

void _delay_us(uint16_t microseconds) {
    TIM4->PSCR = TIM4_PRESCALER_1; // Set prescaler

    // Set count to approximately 1uS (clock/microseconds in 1 second)
    // The -1 adjusts for other runtime costs of this function
    TIM4->ARR = ((16000000L)/1000000) - 1;


    TIM4->CR1 = TIM4_CR1_CEN; // Enable counter

    for (; microseconds > 1; --microseconds) {
        while ((TIM4->SR1 & TIM4_SR1_UIF) == 0);

        // Clear overflow flag
        TIM4->SR1 &= ~TIM4_SR1_UIF;
    }
}

void _delay_ms(uint16_t milliseconds)
{
    while (milliseconds)
    {
        _delay_us(1000);
        milliseconds--;
    }
}

Pin change interrupt

void init(void)
{
    // Configure pin change interrupt on pin B4
    EXTI->CR1 |= 0x04; // Rising edge triggers interrupt
    GPIOB->DDR &= ~(1<<4); // Input mode
    GPIOB->CR1 |= (1<<4);  // Enable internal pull-up
    GPIOB->CR2 |= (1<<4);  // Interrupt enabled
}

void portb_pin_change_irq(void) __interrupt(ITC_IRQ_PORTB)
{
    // Do something...
}

Good morning , i am using stm8s003f3 for programming , i am using cosmic complier for programming,

Statement : i want to create a millis() function so that i can calculate timer between events.

i have done some programming but not able to create millis(), project bulid succesfully. but there is no output.

below i am attaching my code…..

tim4millis.c

#include "tim4millis.h"

//__IO uint32_t current_millis = 0; //–IO: volatile read/write

volatile uint32_t current_millis = 0;

//this entire function using ST’s code
void TIM4_init(void)
{
    CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1); //f_master = HSI = 16Mhz

    /* TIM4 configuration:
       – TIM4CLK is set to 16 MHz, the TIM4 Prescaler is equal to 128 so the TIM1 counter
       clock used is 16 MHz / 128 = 125 000 Hz
       – With 125 000 Hz we can generate time base:
       max time base is 2.048 ms if TIM4_PERIOD = 255 –> (255 + 1) / 125000 = 2.048 ms
       min time base is 0.016 ms if TIM4_PERIOD = 1 –> ( 1 + 1) / 125000 = 0.016 ms
       – In this example we need to generate a time base equal to 1 ms
       so TIM4_PERIOD = (0.001 * 125000 – 1) = 124 */

    /* Time base configuration /
       TIM4_TimeBaseInit(TIM4_PRESCALER_128, TIM4_PERIOD);
       / Clear TIM4 update flag /
       TIM4_ClearFlag(TIM4_FLAG_UPDATE);
       / Enable update interrupt */
    TIM4_ITConfig(TIM4_IT_UPDATE, ENABLE);

    /* enable interrupts */
    enableInterrupts();

    /* Enable TIM4 */
    TIM4_Cmd(ENABLE);

}

uint32_t millis(void)
{
    return current_millis;
}

//Interupt event, happen every 1 ms
INTERRUPT_HANDLER(TIM4_UPD_OVF_IRQHandler, 23)
{
    //increase 1, for millis() function
    current_millis ++;

    TIM4_ClearITPendingBit(TIM4_IT_UPDATE);
}

tim4millis.h

#ifndef TIM4MILLIS_H_
#define TIM4MILLIS_H_

#include "stm8s.h"

#define TIM4_PERIOD 124
//volatile uint32_t current_millis

void TIM4_init(void);

uint32_t millis(void);

#endif

main.c

#include "stm8s_conf.h"
#include "tim4millis.h"

#define blinkInterval 100

uint32_t lastBlink = 0;

uint16_t currentTime = 0;
int main( void )
{
    //setup clock
    // CLK_DeInit();

    TIM4_init(); //already setup f_Master = HSI/1 = 16MHz

    GPIO_DeInit(GPIOB);
    GPIO_Init(GPIOB, GPIO_PIN_5, GPIO_MODE_OUT_PP_LOW_SLOW);

    while(1)
    {
        currentTime = millis();
        if (currentTime - lastBlink >= blinkInterval)
        {
            GPIO_WriteLow(GPIOB, GPIO_PIN_5);
            lastBlink = currentTime;
        }

    }

    // return 0; //remove Warning[Pe111]
}

please help me out……….

thanks and regards
Ankur Bhatt

Moderator edit: collapsed code sections

@ankurbhatt123 I don't have a dev board with me to test your code, but a couple of notes:

• It looks like you want to use GPIO_WriteReverse, which will toggle the pin each call. Your code always sets PB5 low, so you'll never see any change.
• PB5 is a "true open-drain" pin, meaning it can't output a high signal without an external pull-up (mentioned under pin descriptions in the datasheet). If you're using a dev board with an LED on this pin, this should be handled, but it's worth noting.

You'd be best to ask in the STM8 section of the ST Forum if you can't get this working.

Code

#include "stm8s.h"

volatile uint32_t millis_counter = 0; // Stores elapsed milliseconds

const uint16_t tim1_prescaler = 15;   // Prescaler to 16 (16MHz / 16 = 1MHz)
const uint16_t tim1_auto_reload = 999; // Auto-reload for 1ms (1MHz / 1000 = 1kHz)
uint16_t compare = 0;

void tim1_start(void);
void tim1_init(void);

@far @interrupt void TIM1_UPD_OVF_IRQHandler(void) 
{
		millis_counter++;  // Increment milliseconds counter
		GPIO_WriteHigh(GPIOB,GPIO_PIN_5);
	///	GPIOB->ODR ^= (1 << 5); // Toggle LED (Debugging)
    TIM1->SR1 &= ~TIM1_SR1_UIF;  // Clear update interrupt flag
}
// ? Return the current milliseconds count
uint32_t millis(void)
{
    uint32_t ms;
    disableInterrupts();
    ms = millis_counter;
    enableInterrupts();
    return ms;
}

void tim1_set_compare(uint16_t compare)
{
    // Load compare value for channels 3 and 4
    const uint8_t highByte = (compare >> 8);
    const uint8_t lowByte = (compare & 0xFF);

    TIM1->CCR3H = highByte;
    TIM1->CCR3L = lowByte;

    TIM1->CCR4H = highByte;
    TIM1->CCR4L = lowByte;

    // These values are now in shadow registers. They won't take effect until
    // the next update event (UEV), which happens automatically when the timer
    // hits the auto-reload value and rolls over (assuming UDIS is not set in
    // TIM1_CR1 to disable this).
    //
    // It probably make sense to set UDIS while changing multiple compare registers
    // so a UEV can't occur between the updating of channel 3 and 4 and cause
    // unexpected behaviour.
}

void tim1_init()
{
    TIM1->PSCRH = (tim1_prescaler >> 8);
    TIM1->PSCRL = (tim1_prescaler & 0xFF);

    TIM1->ARRH = (tim1_auto_reload >> 8);
    TIM1->ARRL = (tim1_auto_reload & 0xFF);

    // Set up compare channel 3 and 4 180 degrees out of phase This uses two
    // extra compare channels rather than the dedicated complementary output mode
    // to avoid configuring alternative pin mappings as that increases complexity.

    TIM1->CCER2 = TIM1_CCER2_CC3E | TIM1_CCER2_CC4E; // Enable compare channels 3 and 4

    
    TIM1->CCMR3 = TIM1_OCMODE_PWM1 | // Channel 3 low when counter is less than CCR3, otherwise high
                  TIM1_CCMR_OCxPE; // Preload enable: require a UEV event to load new compare values
    TIM1->CCMR4 = TIM1_OCMODE_PWM2 | // Channel 4 high when counter is less than CCR4, otherwise low
                  TIM1_CCMR_OCxPE;

    TIM1->EGR |= TIM1_EGR_UG; // Generate an update event to register new settings
    TIM1->BKR = TIM1_BKR_MOE; // Enable TIM1 output channels
		enableInterrupts();
}

void tim1_start()
{
    TIM1->CR1 |= TIM1_CR1_CEN; // Enable the counter
}

void tim1_stop()
{
    TIM1->CR1 &= ~TIM1_CR1_CEN; // Disable the counter
}
void led_init(void) {
    GPIOB->DDR |= (1 << 5);  // Set PB5 as output
    GPIOB->CR1 |= (1 << 5);  // Push-pull mode
    GPIOB->ODR &= ~(1 << 5); // Start with LED OFF
}

// ? Toggle LED Every 1 Second
void loop(void) 
{
    static uint32_t previousMillis = 0;
    if (millis() - previousMillis >= 1000) { // Check if 1 second has passed
        previousMillis = millis(); // Update last toggle time
        GPIOB->ODR ^= (1 << 5); // Toggle PB5 LED
    }
}

int main(void)
{
    // Configure the clock for maximum speed on the 16MHz HSI oscillator
    // At startup the clock output is divided by 8
    CLK->CKDIVR = 0x0;

    compare = tim1_auto_reload / 2;

    tim1_init();
    tim1_set_compare(compare);
    tim1_start();
		
    while (1) 
    {
        loop(); // Run LED toggle logic
    }

}

I am using above code and for checking millis() but not working....i have also used for toggling led for checking my millis() is working or not...but code is not working.

Moderator edit: collapsed code sections