Open8S208Q80

EX-STM8-Q48a-105

STM8/128-EVAL

STM8L101-EVAL

Getting started with STM8 development using free software: Serial output on the STEVAL-ISA164V1

This short tutorial presents a simple "Hello World" program for the STMicroelectronics STEVAL-ISA164V1 board.
The author used a Debian GNU/Linux system, but the tutorial should work for other Linux distributions, *BSD or other Unices.

The tools we use are

The SDCC compiler, version 3.5.0 or later to compile C programs for the STM8.

stm8flash, to write programs onto devices.

Hardware setup

The STEVAL-ISA164V1 is connected to power and for the serial interface via the mini-USB port (we use the integrated USB-to-serial converter of the STEVAL-ISA164V1 board). To write our program to the board, an ST-LINK/V2 is attached to the SWIM port. The host computer is running a terminal program configured for 9600 baud, no parity, 8 bits, 1 stop bit and no flow control. We used gtkterm.

Get SDCC

Depending on your operating system there might be an easy way to install SDCC 3.5.0 or newer using a package system or similar (e.g. apt-get install sdcc on Debian). While SDCC 3.4.0 should be sufficient for this tutorial, you might want to try a newer version in case you encounter any bugs. In particular, SDCC 3.4.0 has an issue with the library search path; this can be worked around by explicitly specifying the path to the standard library when linking.

Get stm8flash

The stm8flash source can be found at its GitHub location, where there is also a download link for a zip archive of the sources. To compile it, a C compiler, such as gcc, pkg-config and libusb need to be installed. Unzip the archive (e.g. using unzip stm8flash-master.zip) change into the directory stm8flash-master and type make. In case there are any errors, such as header files not found, check that pkg-config and development files for libusb are installed.

The Demo

We present a simple Demo that repeatedly outputs "Hello World!" on UART1. This demonstrates setting up and using the UART for serial I/O. Here is the C code:

SDCC is a freestanding, not a hosted implemenatation of C, and allows main to return void. Note that in older versions of SDCC putchar() takes char and returns void. This was not standard compliant has been changed in current SDCC versions.
The printf() from the standard library uses putchar() for output. Since putchar() is device-specific we need to supply it. In this case we want it to output data using the USART.

The demo can be compiled simply by invocing SDCC using sdcc -mstm8 --std-c99 serial.c assuming the C code is in serial.c. The option -mstm8 selects the target backend (stm8). An .ihx file with a name corresponding to the source file will be generated.

Put the demo onto the board

Assuming stm8flash and serial.ihx are in the same directory, the board is attached through an ST-Link/v2 device, ./stm8flash -c stlinkv2 -p stnrg388a -w serial.ihx will write the demo onto the board. You can see the "Hello world" by using a terminal program configured for 9600 baud, no parity, 8 bits, 1 stop bit and no flow control.

More about stm8flash

stm8flash was written by Valentin Dudouyt. It works both with stlink (including the one integrated on the discovery boards) and stlinkv2 devices. The programmer can be selected using -c stlink or -c stlinkv2. The target device is selected using the -p option (to get a list of target devices, use the -p option with an option argument that is not an stm8 device, e.g. -p help. stm8flash will treat filenames ending in .ihx or .hex as Intel hex, and other filenames as binaries.

More about SDCC

SDCC was initially written by Sandeep Dutta for the MCS-51, and has a relatively conservative architecture (see Sandeep Dutta, "Anatomy of a Compiler", 2000). It has been extended by various contributors and more recently, incorporated some cutting-edge technologies, in particular in register allocation (see Philipp Klaus Krause, "Optimal Register Allocation in Polynomial Time", 2013). The stm8 backend was mostly written by Philipp Klaus Krause for his research into bytewise register allocation and spilling (see Philipp Klaus Krause, "Bytewise Register Allocation", 2015).