Linux Quick Start

Installing the required software

Install the Miosix Toolchain

To be able to compile the Miosix kernel and your application, you need a patched version of the GCC compiler called Miosix Toolchain. This page explains how to install the precompiled Miosix Toolchain. If you prefer compiling GCC from sources, see Building GCC from sources. The commands to run are as follows, where you'll need to replace <version> with the (usually latest) version found in the Miosix Toolchain page.

wget https://miosix.org/toolchain/MiosixToolchainInstaller<version>.run
sh MiosixToolchainInstaller<version>.run

The installer will ask for your root password to copy the compiler to the /opt directory, and put symlinks to /usr/bin. If you later want to uninstall the compiler, as part of the installation process an uninstall.sh script is placed together with the compiler in /opt/arm-miosix-eabi. Uninstalling the previous compiler is done automatically when upgrading to a newer version.

If you do not trust the installer and want to verify its content, or you want to install it locally (in your home folder instead of system-wide), it is possible to extract the content of the installer with the following command. This operation also extracts, without running it, the installer.sh installation script.

sh MiosixToolchainInstaller<version>.run --noexec --keep

For a local install you will need to set the PATH environment variable to include the extracted arm-miosix-eabi/bin directory.

Install a flashing tool

With the installed Miosix toolchain you'll be able to compile the kernel, but you'll also need a way to transfer it to your microcontroller. This operation is usually called 'flashing' the microcontroller. Miosix can work with any flashing utility that accepts as input raw binary files, so pick whatever your GNU/Linux distro of choice provides. Here is a list of suggestions for the most common microcontrollers used with Miosix: Linux flashing tools.

Serial port setup

Miosix redirects stdin/stdout to a serial port by default on most boards, so to see the boot log and the output of printf() in your application you need a program to interact with the serial port. A common one is GNU screen, but there are alternatives such as minicom or tio.

sudo apt install screen # For Ubuntu/Debian
sudo pacman -S screen   # For Arch Linux

On most Linux distros serial ports, both the physical ones like /dev/ttyS0 and the USB to serial adapters like /dev/ttyUSB0, are owned by the dialout group, so to avoid the need to use sudo every time you run screen you need to add your user to that group before you can access them.

sudo usermod -a -G dialout `id -un` # Add yourself to the dialout group

Note that you may need to reboot your computer before the change takes effect.

Downloading and configuring the Miosix kernel

To download the Miosix kernel you need git. If you do not already have it installed you can install it now

sudo apt install git # For Ubuntu/Debian
sudo pacman -S git   # For Arch Linux

This is a stripped down guide with the bare minimum to get you started, we also have a full guide about Miosix and git workflow. Following the tutorial in this page, your project directory will not be under version control (git). The Miosix and git workflow page shows how to create a git repository for your project and add the Miosix kernel as a submodule.

Before downloading the kernel, however, you first have to create a directory for your project (in this case, the hello world), and then clone the kernel as a subdirectory.

mkdir hello
cd hello
git clone https://github.com/fedetft/miosix-kernel.git

Initializing a Miosix project

For reasons explained in dept in the Miosix and git workflow page, you'll need to copy the Miosix configuration directory from the kernel sources to your project directory, as well as create a template project where you can start writing code.

This can be automated with a [Perl] script called init_project_out_of_git_tree.pl.

perl miosix-kernel/tools/init_project_out_of_git_tree.pl

You should run the script from the directory where you want to initialize your empty project, such as the hello directory in this tutorial. A successful run of the script produces the following output:

Successfully created Miosix project
Target directory: hello
Kernel directory: hello/miosix-kernel/miosix

Although Perl is pre-installed in almost all GNU/Linux distros, this script depends on the File::Copy::Recursive Perl module which often is not. If you get errors running the script, install the missing module as follows and try again:

sudo apt install libfile-copy-recursive-perl # For Ubuntu/Debian

Your project directory should look like this:

Configuring and compiling the kernel

More in-depth information on how to configure the kernel for your board can be found in the Board list, but for now we will assume you have an stm32f4discovery, which is a common board, and briefly show how to get to a blinking LED example.

Top-level directory

First of all the miosix-kernel directory is often referred to as the top-level directory of the kernel. It contains, among other, the main.cpp file which is where you can start writing your application code, the Makefile where you can add additional C++ and C source files to be compiled, and the miosix directory which contains the kernel.

All paths in this wiki, unless they start with a '/' (for Linux) or 'C:\' (For Windows), are intended relative to Miosix's top-level directory, so if we're talking about the 'miosix/config/Makefile.inc' file you can find it within the directory where you have downloaded the kernel from git.

Configuring the kernel

The kernel is configured by editing two files, named miosix/config/Makefile.inc and miosix/config/miosix_settings.h. Open the first one, and select your board. To do so, look for the OPT_BOARD section of the file, which looks like this:

##
## Target board, choose one. This also implicitly select the target
## architecture
##
#OPT_BOARD := lpc2138_miosix_board
OPT_BOARD := stm32f103ze_stm3210e-eval
#OPT_BOARD := stm32f103ve_mp3v2
#OPT_BOARD := stm32f100rb_stm32vldiscovery
#OPT_BOARD := stm32f103ve_strive_mini
#OPT_BOARD := stm32f103ze_redbull_v2
#OPT_BOARD := stm32f407vg_stm32f4discovery
#OPT_BOARD := stm32f207ig_stm3220g-eval
#OPT_BOARD := stm32f207zg_ethboard_v2
#OPT_BOARD := stm32f207ze_als_camboard
#OPT_BOARD := stm32l151_als_mainboard
#OPT_BOARD := stm32f407vg_bitsboard
#OPT_BOARD := stm32f205rg_sony-newman

In Makefile syntax a '#' sign denotes a comment, so to select a board you have to comment out (by prepending a '#') the default board selected, and uncomment (by removing the '#' at the start of the line) your board, in this case, which in this example will assume is the stm32f407vg_stm32f4discovery.

Next, edit the miosix_settings.h file and uncomment (by removing the '//' at the start of the line) the following line

//#define JTAG_DISABLE_SLEEP

(which is towards the end of the file). This is a C++ header file, so the comment syntax is '//'. More information on the meaning of this line can be found in miosix_settings.h, but a short summary is that this line prevents the kernel from putting shutting down the CPU when it has nothing to do, which saves power but interferes with the programming/debugging protocol used to program the board via QSTLink2.

Also, comment out the #error line towards the beginning of the file. This line exists to cause a compilation error if the user forgets to edit the miosix_settings.h file. The result should look like this:

// Before you can compile the kernel you have to configure it by editing this
// file. After that, comment out this line to disable the reminder error.
// The PARSING_FROM_IDE is because Netbeans gets confused by this, it is never
// defined when compiling the code.
#ifndef PARSING_FROM_IDE
//#error This error is a reminder that you have not edited miosix_settings.h yet.
#endif //PARSING_FROM_IDE

Blink a LED

Open the main.cpp file in the top-level directory, and replace its content with the following program:

#include <miosix.h>
using namespace miosix;
int main()
{
    for(;;)
    {
        ledOn();
        Thread::sleep(1000);
        ledOff();
        Thread::sleep(1000);
    }
}

The Miosix board support package defines the ledOn() and ledOff() functions to control a LED on the board for all the boards that have at least one software-accessible LED.

Compiling

To compile the kernel, open a terminal in the Miosix top-level directory and type make. If all goes well, the result should look like this.

File:Makeoutputlinux.png

Otherwise, compiler errors will appear in the shell. The number that appears under text in the make output is the size in bytes of your application plus the kernel. If you think that 90KBytes is a bit too much for a blinking led, don't worry. The kernel by default includes support for C stdio functions, filesystem code including Unicode support and the C++ exception handling runtime, all of which can be disabled to significantly reduce code size.

Programming

To program the stm32f4discovery board you can use the st-flash tool. Using this tool requires you to know the base address of the FLASH memory that for STM32 microcontrollers is 0x08000000.

st-flash write main.bin 0x08000000

Alternatively, with QSTlink2

Once you start it, you have to click on Connect, and it should find your stm32f4discovery board. After that, click on Send and select the main.bin file in the Miosix top-level directory.

Note that, regardless of using QSTLink2 form the shell or the GUI, there is a bug that in some circumstances blocks the microcontroller until the next powercycle. Therefore, after having programmed the microcontroller, is is recomended to unplug and reconnect the USB cable to powercycle the stm32f4discovery board. At that point, you shuold see the red LED blinking.