Official Blog of Silicon Labs

Publish

Micrium OS USB-Device VENDOR Class and Demo

Fernando Flores | 01/04/2019 | 01:58 PM
The objective of this blog is to show you the steps necessary to use an existing Micrium OS USBD example and add a different class and demo using the EFM32GG11.

Baseline Project

Since the Gecko SDK currently ships with a ‘micriumos_usbdhidmouse’ project for the SLSTK3701A_EFM32GG11 board, we can make a copy of it and rename it ‘micriumos_usbdvendor’. The convenience of making a copy of the project is to modify it according to our needs without breaking the Gecko SDK default projects. Start by locating the ‘micriumos_usbdhidmouse’ folder in your Simplicity Studio installation. The project location is at ‘C:\SiliconLabs\SimplicityStudio\v4\developer\sdks\gecko_sdk_suite\v2.5\app\mcu_example\SLSTK3701A_EFM32GG11’

Once you found the folder, make a copy of it and rename it ‘micriumos_usbdvendor’. Please make sure to keep the new folder at the same path location of the original. Locate the ‘SLSTK3701A_micriumos_usbdhidmouse.slsproj’ file inside your New Folder ‘micriumos_usbdvendor\SimplicityStudio’ and rename it ‘SLSTK3701A_micriumos_usbdvendor.slsproj’

We will be adding our new workspace, so launch Simplicity Studio and connect the SLSTK3701A_EFM32GG11 board to the PC.

Add workspace by right-clicking anywhere inside the Project Explorer box and Select Import>MCU Project

Use the Browse button to locate the ‘SLSTK3701A_micriumos_usbdvendor.slsproj’ and click Next>

File Location: `C:\SiliconLabs\SimplicityStudio\v4\developer\sdks\gecko_sdk_suite\v2.5\app\mcu_example\SLSTK3701A_EFM32GG11\micriumos_usbdvendor\SimplicityStudio`

Since you already have your board connected, it should all be auto-detected. Leave everything by default making sure that there is an SDK selected, then click Next>

You can either change the name of the project or keep the default, then click Finish.

Configuration Files

We will now need to modify the project configuration files to include Micrium OS USBD Vendor class as part of our build. Start by expanding the Includes section in the Project Explorer panel, then expand the configuration folder as shown in the image below. After that, double-click on the rtos_configuration.h to open it in the editor.

As soon as you try to edit the rtos_description.h, you will be presented a Warning indicating you are editing an SDK file. Click on Edit in SDK.

Add the following #define in rtos_description.h to indicate Micrium OS that you want to use VENDOR class.
```
#define  RTOS_MODULE_USB_DEV_VENDOR_AVAIL
```
Remove the following #define in rtos_decription.h
```
#define  RTOS_MODULE_USB_DEV_HID_AVAIL
```
Tell Micrium OS you want to use the USBD VENDOR demo by modifying ex_description.h. Expand the Includes section in the Project Explorer panel, then expand the project folder as shown in the image below. After that, double-click on the ex_description.h to open it in the editor.

As soon as you try to edit the ex_description.h, you will be presented a Warning indicating you are editing an SDK file. Click on Edit in SDK.

Remove the following #define in ex_description.h
```
#define RTOS_MODULE_USB_DEV_HID_AVAIL
```
Add the following #define in ex_description.h to indicate Micrium OS you want to use VENDOR class.
```
#define  RTOS_MODULE_USB_DEV_VENDOR_AVAIL
```
Adding USBD Class and Demo

Expand the src section in the Project Explorer panel and remove the ‘ex_usbd_hid_mouse.c’ linked file.

Select Import > MCU Project by right-clicking on src section as shown on image below

Choose ‘More Import Options…’ and select File System on the next window that pops-up as shown on the images below

Add ‘ex_usbd_vendor_loopback.c’ example as shown on image below, and click Finish.

File location: 'C:\SiliconLabs\SimplicityStudio\v4\developer\sdks\gecko_sdk_suite\v2.5\app\micrium_os_example\usb\device\all'

Expand the usb>source>device>class section in the Project Explorer panel and right-click on class. Select Import > MCU Project and add the USBD VENDOR class file as shown on images below

Use the Browse button to locate the VENDOR class files to be added as shown below.

File location: 'C:\SiliconLabs\SimplicityStudio\v4\developer\sdks\gecko_sdk_suite\v2.5\platform\micrium_os\usb\source\device\class'

Running the Example

You can now build your application and flash it on the board. Once the application starts running, you should see LED0 on the board blinking which means all the initialization was done correctly; therefore, we can now test the USBD VENDOR demo.

Use a Micro-USB B cable to connect the PC to the EFM32GG11 board. As soon as you connect it, Windows will enumerate the device and display it in 'Universal Serial Bus Devices' as shown in the image below.

Execute the Windows USB application provided in the attachment (Located at 'App\Host\OS\Windows\Vendor\Visual Studio 2010\exe\x86') and provide the number of transfers.
Windows-App.zip
Using mbed TLS in a Micrium OS application

Mark Mulrooney | 12/341/2018 | 06:35 PM
An important aspect of any IoT device is how secure the device is when it communicates with other devices, gateways or the cloud. It is common for developers to secure communications such as TCP/IP connections, Bluetooth or Zigbee. However, if a microcontroller sends sensitive information over a simple interface such as a UART to another microcontroller, it is important to realize that data should also be secured to prevent someone from snooping the UART line.

Silicon Labs offers a hardware CRYPTO module that provides an efficient acceleration of common cryptographic operations and allows these to be used efficiently with low CPU overhead. In addition to the CRYPTO module, Silicon Labs also provides a mbed TLS library to integrate with mbed TLS to allow it to take advantage of the CRYPTO module acceleration.

To use mbed TLS in a Micrium OS based application, first the developer must understand how the mbed TLS library will be used in the application. By default, mbed TLS is intended to be used in a single threaded/bare metal application or used in only a single thread of an RTOS application. For a Micrium OS application, this means if there will only be one task calling mbed TLS functions then no special modifications to the config file are necessary. If mbed TLS will be called from multiple tasks, for example a Bluetooth project that has a UART to communicate to another microcontroller, then a few modifications need to be made to the mbed TLS config header.

The following instructions will show you how to enable thread protection in mbed TLS for a Micrium OS Blink project on the Giant Gecko Series 1 (SLSTK3701A). If you have any difficulty getting the project set up, a .sls file is attached to this post for you to download. If you need further information on the SiLabs’ mbed TLS library, refer to Application Node AN0955.

Open Simplicity Studio and with your GG11 plugged in, select the board under debug adapters and then expand the Software Examples. Select the SLSTK3701A_micriumos_blink project and jump to the Simplicity IDE.

First, mbed TLS must be added to the project as its not already included. You can either download mbed TLS from https://tls.mbed.org or you can grab a copy from your install of Simplicity Studio from: Simplicity Studio install location -> Eclipse -> developer -> sdks -> gecko_sdk_suite -> v2.4 -> util -> third_party -> mbedtls. Place those files into the workspace folder for the SLSTK3701A_micriumos_blink.

Once you have mbed TLS added to the project, you need to add the SiLabs library for mbed TLS to the workspace for SLSTK3701A_micriumos_blink. Under the Simplicity Studio install you can copy the sl_crypto folder and config folder from here: Eclipse -> developer -> sdks -> gecko_sdk_suite -> v2.4 -> util -> third_party -> mbedtls.

After adding the folders to the workspace similar to the image above, include paths need to be added to the project. Under the project properties, go to C/C++ Build -> Settings -> GNU ARM C Compiler -> Includes.

Paths need to be added for the config directory, include directory and the sl_crypto directory. After adding those paths, remain in the project settings and go to Symbols under GNU ARM C Compiler.

At this point, mbed TLS has been added to the project, but it is only set to run in its default configuration. This means it won’t take advantage of the CRYPTO module acceleration and it won’t work from multiple threads. To fix that, add a new symbol that contains the following: MBEDTLS_CONFIG_FILE="config-sl-crypto-all-acceleration.h" then click OK. This will tell all mbed TLS files to look at the new config file, rather than the default config.h file.

Open up the config-sl-crypto-all-acceleration.h under the config directory. This is the default config file for enabling all hardware accelerations supported by SiLabs’ mbed TLS library. Add the following code to the header file to enable threading and remove a requirement for network sockets (unless you plan to use them). This code must be placed directly below the #include “mbedtls/config.h”.
```
/* Include the default mbed TLS config file */
#include "mbedtls/config.h"

/* Add Micrium OS support */
#define MBEDTLS_THREADING_ALT
#define MBEDTLS_THREADING_C
#define MBEDTLS_MICRIUM
#undef MBEDTLS_NET_C

#undef MBEDTLS_TIMING_C
```
Finally, the last piece to enable Micrium OS support in mbed TLS is to initialize threading support before starting Micrium OS. In the file ex_main.c, place the following code in main() anytime after the OSInit() call and before OSStart(). This will initialize the necessary mutexes to provide the protection.
```
// Enable Micrium OS support
#if defined ( MBEDTLS_THREADING_C )
    THREADING_setup();
#endif
```
At this point, after the OSStart() call completes and multitasking has begun, any mbed TLS call can be made safely from any task in Micrium OS.
SLSTK3701A_micriumos_blink.sls
Micrium OS USB-Device CDC-ACM Class and Demo

Fernando Flores | 12/339/2018 | 01:38 PM
The objective of this blog is to show you the steps necessary to use an existing Micrium OS USBD example and add CDC-ACM class and demo using the EFM32GG11.

Baseline Project

Since the Gecko SDK currently ships with a ‘micriumos_usbdhidmouse’ project for the SLSTK3701A_EFM32GG11 board, we can make a copy of it and rename it ‘micriumos_usbdcdcacm’. The convenience of making a copy of the project is to modify it according to our needs without breaking the Gecko SDK default projects.

Start by locating the ‘micriumos_usbdhidmouse’ folder in your Simplicity Studio installation. The project location is at ‘C:\SiliconLabs\SimplicityStudio\v4\developer\sdks\gecko_sdk_suite\v2.4\app\mcu_example\SLSTK3701A_EFM32GG11’

Once you found the folder, make a copy of it and rename it ‘micriumos_usbdcdcacm’. Please make sure to keep the new folder at the same path location of the original.

Locate the ‘SLSTK3701A_micriumos_usbdhidmouse.slsproj’ file inside your New Folder ‘micriumos_usbdcdcacm\SimplicityStudio’ and rename it ‘SLSTK3701A_micriumos_usbdcdcacm.slsproj’

We will be adding our new workspace, so launch Simplicity Studio and connect the SLSTK3701A_EFM32GG11 board to the PC.

Add workspace by right-clicking anywhere inside the Project Explorer box and Select Import > MCU Project

Use the Browse button to locate the ‘SLSTK3701A_micriumos_usbdcdcacm.slsproj’ and click Next>

File location: 'C:\SiliconLabs\SimplicityStudio\v4\developer\sdks\gecko_sdk_suite\v2.4\app\mcu_example\SLSTK3701A_EFM32GG11\micriumos_usbdcdcacm\SimplicityStudio'

Since you already have your board connected, it should all be auto-detected. Leave everything by default making sure that there is an SDK selected, then click Next>

You can either change the name of the project or keep the default, then click Finish.

Configuration Files

We will now need to modify the project configuration files in order to include Micrium OS USBD CDC-ACM class as part of our build.

Start by expanding the Includes section in the Project Explorer panel, then expand the configuration folder as shown in the image below. After that, double-click on the rtos_configuration.h to open it in the editor.

As soon as you try to edit the rtos_description.h, you will be presented a Warning indicating you are editing an SDK file. Click on Edit in SDK.

Add the following #define in rtos_description.h to indicate Micrium OS that you want to use CDC ACM class.
```
#define  RTOS_MODULE_USB_DEV_ACM_AVAIL
#define  RTOS_MODULE_USB_DEV_CDC_AVAIL
```
Remove the following #define in rtos_decription.h
```
#define  RTOS_MODULE_USB_DEV_HID_AVAIL
```
Tell Micrium OS you want to use the USBD CDC-ACM demo by modifying ex_description.h. Expand the Includes section in the Project Explorer panel, then expand the project folder as shown in the image below. After that, double-click on the ex_description.h to open it in the editor.

As soon as you try to edit the ex_description.h, you will be presented a Warning indicating you are editing an SDK file. Click on Edit in SDK.

Remove the following #define in ex_decription.h
```
#define  RTOS_MODULE_USB_DEV_HID_AVAIL
```
Add the following #define in ex_description.h to indicate Micrium OS that you want to use CDC-ACM class.
```
#define  RTOS_MODULE_USB_DEV_ACM_AVAIL
```
Adding USBD Class and Demo

Expand the src section in the Project Explorer panel and remove the ‘ex_usbd_hid_mouse.c’ linked file.

Select Import > MCU Project by right-clicking on src section as shown on image below

Choose ‘More Import Options…’ and select File System on the next window that pops-up as shown on the images below

Use Browse button and add ‘ex_usbd_cdc_acm_terminal.c’ example as shown on image below, and click Finish.

File location: `C:\SiliconLabs\SimplicityStudio\v4\developer\sdks\gecko_sdk_suite\v2.4\app\micrium_os_example\usb\device\all`

Expand the usb>source>device>class section in the Project Explorer panel and right-click on class. Select Import > MCU Project and add the USBD CDC ACM class file as shown on images below

Use the Browse button to locate the CDC-ACM files to be added as shown below.

File location: `C:\SiliconLabs\SimplicityStudio\v4\developer\sdks\gecko_sdk_suite\v2.4\platform\micrium_os\usb\source\device\class`

Running the Example

You can now build your application and flash it on the board. Once the application starts running, you should see LED0 on the board blinking which means all the initialization was done correctly; therefore, we can now test the USBD CDC-ACM demo.

Open Windows Device Manager and expand the 'Ports (COM & LPT)' section.

Use a Micro-USB B cable to connect the PC to the EFM32GG11 board. As soon as you connect it, Windows will enumerate the device and display it in 'Ports (COM & LPT)' as shown in the image below. Keep in mind that Windows is the one assigning the port number (COM7) to my device.

Once you know the serial port number, we can use any serial terminal application and open a terminal window. The images below shows the terminal configurations and the CDC-ACM demo output.
Micrium OS and ASSERTs

Sharbel Bousemaan | 12/339/2018 | 11:14 AM

If you work with Micrium OS, chances are you will eventually encounter some macro prefixed with RTOS_ASSERT which traps your task in an infinite loop. Micrium OS has two types of ASSERTs, Critical ASSERTs and Debugging ASSERTs. The former type of ASSERT is intended to catch severe errors which may prevent the system from functioning normally such as a module failing to initialize correctly. On the other hand, Debugging ASSERTs are used to catch ordinary errors returned from an API call so that they are found quickly while debugging. However, the question naturally arises: should my system crash because I passed a bad delay value to OSTimeDly?

There are a few options to customize how these conditions are handled in your system.

1. You can disable debugging ASSERTs, which will also disable error checking. This is recommended once the project is stable and ready for production.

2. You can force the ASSERTs to return a value, with some caveats.

In order to make these changes, you must modify this section of rtos_cfg.h.

Option 1 requires changing the MASK to RTOS_CFG_MODULE_NONE.

Option 2 requires modifying the DBG macro so that it returns the error value.

However, you must be careful not to use any ASSERT_DBG() macros at the top level of your task; you may unintentionally return from the task if you do so.

For more details on ASSERTs, please refer to the following pages:

https://doc.micrium.com/display/OSUM50500/Micrium+OS+Asserts+Programming+Guide

https://doc.micrium.com/display/OSUM50500/RTOS+Compile-Time+Configuration

Micrium OS Examples: 57 Hidden Gems You May Not Know About

Juan Benavides | 12/339/2018 | 10:32 AM

Background

The Micrium OS Examples in Simplicity Studio are very easy to access: You connect your Starter Kit and Simplicity Studio will display the list of examples as shown below:

**Figure 1.** Micrium OS Examples in Simplicity Studio

For more information on how to access the Micrium OS Examples from Simplicity Studio you can see this document:

https://www.silabs.com/documents/public/training/wireless/micrium-os-examples.pdf

Revealing the 57 Hidden Gems

In this blog, I’m going to show you how to access the additional Micrium OS Examples that are not available from Simplicity Studio's Launcher Perspective.

There are 57 examples that demonstrate how to initialize the Micrium OS modules to perform the most basic operations:

Micrium OS Module		Example
CANopen		CANopen Module Initialization Example
		CANopen Node Start Example
		CANopen Object Dictionary Read/Write Example
File System		File System Module Initialization Example
		File Read/Write Example
		File Read/Write with Posix API Example
		File Multi-Descriptors Example
		Entry Path Example
		Block Device Read/Write Example
		Media Polling Example
Network	FTP Client	Send Data from a buffer to a file on an FTP Server
		Upload a file to an FTP Server
		Receive a file into a buffer
		Download a file from an FTP server
	HTTP Client	HTTP Client Initialization Example
		HTTP Client GET Request Examples
		HTTP Client POST Request Examples
		HTTP Client PUT Request Examples
		HTTP Client Persistent Connection Examples
		HTTP Client Multi-connection Examples
	HTTP Server	HTTP Server Initialization Example
		Simple Server That Uses No File System
		Basic Server That Uses the HTTP Static File System
		Basic Server That Uses Micrium OS File System
		Server That Handles REST Requests
		Server That Handles Webpages, REST Requests and Authentication Support
		Basic Secure Server That Uses SSL-TLS and the HTTP Static File System
	IPerf	IPerf Initialization Example
	MQTT Client	MQTT Client Initialization Example
		MQTT Client Connect Example
		MQTT Client Publish Example
		MQTT Client Subscribe Example
		MQTT Client Echo Example
	Network Core	Network Module(s) Initialization Example
		Network Core Initialization Example
		Start Network Interface(s) Example
	SMTP Client	SMTP Client Initialization Example
	SMTP Client	SMTP Client Send Email Example
	SNTP Client	SNTP Client Initialization Example
	SNTP Client	Basic SNTP Current Time Retrieve
	Telnet Server	Telnet Server Initialization Example
	Telnet Server	Telnet Server Instance Example
	TFTP Client	Download and Upload a File to a TFTP Server
USB Device	Audio Class	USB Device Audio Class Loopback Example
	CDC ACM Class	USB Device CDC ACM Class Terminal Example
	CDC EEM Class	USB Device CDC EEM Class Example
	USB Device Core	USB Device Core Initialization Example
	HID Class	USB Device HID Class Mouse Example
	MSC Class	USB Device MSC Class Ramdisk LUN Example
	MSC Class	USB Device MSC Class Ramdisk Shared Example
	Vendor Class	USB Device Vendor Class Loopback Example
USB Host	Android Accessory Class	USB Host Android Accessory Class Example
	CDC ACM Class	USB Host CDC ACM Class Example
	USB Host Core	USB Host Module Simple Initialization Example
	USB Host Core	Simple Device Port Operation Example
	MSC Class	USB Host MSC Class Example
	USB-to-Serial Class	USB Host USB-to-Serial Class Example
Table 1. The Hidden Micrium OS Examples

How to run the hidden Micrium OS Examples

The process of including, configuring and initializing the examples is the same for all the examples and can be summarized as follows:

Start off with one of the examples available through Simplicity Studio by connecting your Kit and selecting an Example from the list as illustrated in Figure 1.

If the example project does not have the Micrium OS module files, then you need to include them by inserting in your project the folder located at ${StudioSdkPath}/platform/micrium_os/[module]/include and ${StudioSdkPath}/platform/micrium_os/[module]/source/[module] and configuring your compiler's include paths with the new paths.

Locate the header file rtos_description.h and insert the macro necessary to enable the module. For the full list of macros see this document.

Make sure you have in your project all the configuration files located in STUDIO_SDK_LOC\platform\micrium_os\cfg

Explore the examples listed in Table 1, select the one that you want and follow the corresponding hyperlink.

The hyperlink will take you to the example's documentation which provides four things:

Description: Brief description of the example
Configuration: The name of the #define that needs to be defined in ex_description.h
Location: The location of the files that need to be included
API: The API that needs to be called from your application to start the example

Locate the header file ex_description.h and define the corresponding macro if necessary as described in the example's documentation section: Configuration.

Include in your Simplicity Studio project the required files as listed in the example's documentation section: Location. In this step you can either create a link to the original folder or make a copy of the files and place them in your own workspace directory.

Configure your compiler's include paths with the new paths where the header files are located.

Insert a #include in your application, of the header file where the API to start the example is declared and call the API from your application to get the example started as described in the example's documentation section: API.

Example

To illustrate the process, I'm going to provide an example where one is interested in running an HTTP server:

Connect the SLSTK3701A and select the example SLSTK3701A_micriumos_net from Simplicity Studio.

Inspect which modules are included in the project by looking at the folder net in the Project Explorer. There you will notice that the module HTTP Server is missing.

Include the HTTP Server module by creating a new Linked Folder located at STUDIO_SDK_LOC\platform\micrium_os\net\source\http\server

Open the new folder Properties and either include or exclude the folder from compilation as necessary from the section C/C++ Build.

Open the Project Properties and insert the location to the new header files ${StudioSdkPath}/app/micrium_os_example/net/http/server in the section C/C++ General -> Paths and Symbols

Locate and open the header file rtos_description.h and insert the following line to enable the new HTTP Server Module: #define RTOS_MODULE_NET_HTTP_SERVER_AVAIL

Copy the configuration files from STUDIO_SDK_LOC\platform\micrium_os\cfg to your own workspace directory and make sure the compiler is aware of this include path.

Look at Table 1, locate the Example Basic Server That Uses the HTTP Static File System and explore the documentation.

Open the header file ex_description.h and insert the following line to enable the example: #define EX_HTTP_SERVER_INIT_AVAIL

Create a new Folder named Examples and then create a Linked Folder in it that points to STUDIO_SDK_LOC\app\micrium_os_example\net\http\server

Open the Project Properties and insert the path ${StudioSdkPath}/app/micrium_os_example/net in the section C/C++ General -> Paths and Symbols

Open the file ex_main.c and insert the following line at the top: #include "http/server/ex_http_server.h"

From the same file ex_main.c, locate the calls to the functions Ex_NetworkInit() and Ex_Net_CoreStartIF() and insert right after them, a call the following API to get the example started: Ex_HTTP_Server_InstanceCreateStaticFS();

Detecting Task Stack Overflows Through the Kernel's Red Zone Feature

Janos Magasrevy | 11/319/2018 | 04:07 PM
The following blog explains a simple way of detecting task stack overflows while debugging your Micrium OS application.

Micrium OS Kernel Red Zone

The kernel's red zone is a feature that, when enabled through OS_CFG_TASK_STK_REDZONE_EN in os_cfg.h creates a monitored zone at the end of a task's stack. The length of the red zone is user-configurable via the #define OS_CFG_TASK_STK_REDZONE_DEPTH in os_cfg.h. By default, this is set to 8 stack elements (CPU_STK).

When the red zone is enabled, every time a task is switched out, either at the task level or at the interrupt level, the kernel checks if the red zone has been hit. By default, a software exception is thrown with the use of the CPU_SW_EXCEPTION macro in the ARMv7m port. However, if you want more control over what your application should do in the event that the red zone is hit, you can turn on the application hooks by setting OS_CFG_APP_HOOKS_EN to DEF_ENABLED in os_cfg.h.

Using the Red Zone Application Hook

If you decided that you want your application to determine what to do in the event that a task hits the red zone instead of throwing a software exception, then you will have to define a hook function to do so.

A simple example:
```
static  void  RedzoneHitHook (OS_TCB  *p_tcb)
{
	BSP_LedSet(0);
	while(1);
}
```
With that, you can tell that if you see LED0 permanently on and with your code trapped at the while loop you have hit the red zone. You can then check p_tcp->NamePtr in your local variables panel and find what was the task that hit the limit.

Don't forget to assign the red zone hit hook pointer to your custom function. Using the example above:
```
OS_AppRedzoneHitHookPtr = RedzoneHitHook;
```
Make sure that this is added prior to calling OSStart() otherwise the pointer is never assigned to your application hook.

For more details about detecting stack overflows and the red zone, visit the following link: https://www.micrium.com/detecting-stack-overflows-part-2-of-2/
Micrium OS File System RAM Disk on EFM32GG11

Janos Magasrevy | 09/262/2018 | 04:19 PM
The objective of this blog is to show you the steps necessary to add the Micrium OS File System to an EFM32GG11. I'll be focusing on RAM Disk as the storage media while we wait for an SD card example project to become available.

Baseline Project

Since the Gecko SDK currently ships without a stand-alone Micrium OS File System example, we will start with the 'micriumos_usbhmsc' project for the SLSTK3701A_EFM32GG11. The convenience of selecting this project as a baseline is due to the fact that the Micrium OS File System is present as a requirement from USB-Host Mass Storage Class, which is what that example demonstrates.

Start by connecting your SLSTK3701A_EFM32GG11 to the PC and launching Simplicity Studio, then click on File -> New -> Project...

Select Silicon Labs MCU Project and click Next >

Since you already have your board connected, it should all be auto-detected. Leave everything by default making sure that there's an SDK selected, then click Next >

Now select Example - Create a working example for the part. and click Next >

In the search bar, type "SLSTK3701A_micriumos_usbhmsc", then select it and click Next >

Pick a name for your project, in my case, I named the project "SLSTK3701A_micriumos_ramdisk". Make sure you select Copy contents so that we can edit the example files freely. After that, click Finish.

Try to build the project and flash it to make sure that it is functional, remember, this will be our baseline for what's coming next...

Configuration Files

We will now need to modify the project configuration files in order to include Micrium OS FS RAM Disk as part of our build.

For that, start by expanding the Includes section in the Project Explorer panel, then expand the configuration folder as shown in the image below. After that, double-click on rtos_description.h to open it in the editor.

As soon as you try to edit rtos_description.h, you'll be presented a Warning indicating that you are editing an SDK file. Click on Make a Copy so that we can edit this freely in our workspace without affecting other projects in the SDK.

Add the following #define in rtos_description.h to indicate Micrium OS that you want to use the File System RAM Disk implementation:
```
#define  RTOS_MODULE_FS_STORAGE_RAM_DISK_AVAIL
```
Editing the Example Files

At this point, your application is able to create a RAM Disk using the Micrium OS File System. However, we want it to do some more. Let's now perform a simple file read and write. For that, copy the ex_fs_file_rd_wr.c and .h example files located at:
```
C:\SiliconLabs\SimplicityStudio\v4\developer\sdks\gecko_sdk_suite\v2.3\app\micrium_os_example\fs
```
Paste the two files in your workspace folder, at the same level of ex_fs.c, etc. In my case, this would be:
```
C:\Users\<user>\SimplicityStudio\v4_workspace\SLSTK3701A_micriumos_ramdisk\src
```
To make use of the read/write example that we just copied, we have to include its header file in the include section of ex_fs.c:
```
#if  (defined(RTOS_MODULE_FS_STORAGE_RAM_DISK_AVAIL))
#include  <fs/include/fs_ramdisk.h>
#include  "ex_fs_file_rd_wr.h"
#endif
```
Notice that I included the example header within the RTOS_MODULE_FS_STORAGE_RAM_DISK_AVAIL section in case you want to exclude the RAM Disk from your project later on then this also gets excluded.

Finally, let's add the call to Ex_FS_FileRdWr(). You can do this in Ex_FS_Init() in ex_fs.c right at the end of the "FORMAT RAM DISK" section as indicated by the code comments.
```
#if  (defined(RTOS_MODULE_FS_STORAGE_RAM_DISK_AVAIL))
    {
        FS_BLK_DEV_HANDLE  blk_dev_handle;


        blk_dev_handle = FSBlkDev_Open(FSMedia_Get("ram0"), &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

        FSCache_Assign(blk_dev_handle,
                       Ex_FS_DataPtr->CachePtr,
                       &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

        FS_FAT_Fmt(blk_dev_handle,
                   FS_PARTITION_NBR_VOID,
                   DEF_NULL,
                   &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

        FSBlkDev_Close(blk_dev_handle, &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

        Ex_FS_FileRdWr();
}
#endif
```
Running the Example

You can now build your application and flash it on the board. Before running it though, open a terminal application to view the VCOM output from the EFM32GG11 VCOM port.

Since we based this project out of the USB-Host Mass Storage Class example, there will still be USB-related code executing, hence why you'll see those messages in the terminal output.

Once you start running, the File System will be initialized with a default configuration, as well as the RAM Disk as specified by Ex_FS_RAM_Disk_Cfg in ex_fs.c.

Further on, the RAM Disk gets formatted as a FAT volume and one partition is created.

Lastly, the read/write example essentially writes some known data to a specified file, then the data from the file is read and verified for integrity.

If everything ran correctly, you should see the following on your terminal output:
```
*** MicriumOS USB-host Example. ***
FS Example: File rd/wr on 'ram0'...OK


*** MicriumOS USB-host Example -----> Init done. ***

>> Ex_FS_MediaOnConn(): Media 'ram0' connected!
```
Notice the string "FS Example: File rd/wr on 'ram0' ...OK" indicating that the read/write demo ran fine on our RAM Disk.

We hope to have a part 2 of this blog which would be based on an SD card instead of the RAM Disk. For now, this will be good enough to get your hands dirty with the Micrium OS File System.
Micrium OS Network: Exploring the Built-In Performance Measurements

Juan Benavides | 09/260/2018 | 03:31 PM
Introduction

Micrium OS Network collects run-time statistics, error counters and buffer usage information that are optional during compile-time since they require additional code and memory.

Application developers may want to analyze these run-time metrics for various reasons:

Verify Performance

The protocol statistics allow you to verify the performance of your network application by looking at reception and transmission speeds.

Figure 1. Interface Rx/Tx Speed Screen

Detect Errors

Error counters allow you to debug run-time problems such as low memory conditions, slow performance and packet loss.

Figure 2. TCP Resources Screen

Optimize Memory Usage

The buffer statistics allows you to optimize the memory usage and since the examples in Simplicity Studio are configured for general purpose and may have more buffers than necessary, these metrics can help you optimize the memory usage for your specific application needs.

Figure 3. Interface Buffers Screen

Monitor Network Connections

The sockets list screen allows you to see the state of your incoming and outgoing network connections, including the IP addresses, port numbers and the protocol.

Figure 4. Sockets Screen

How to Enable the Micrium OS Network Run-Time Statistics

To enable run-time statistics within Micrium OS Network a few macros need to be defined to DEF_ENABLED as follows.

Run-time Statistics Counters

These statistics are related to the network protocol and interfaces. You may want to analyze statistics counters to verify the performance of your network application on a per interface basis. To enable them, edit the file net_cfg.h and set the following macros to DEF_ENABLED as shown below:
```
    #define  NET_CTR_CFG_STAT_EN                                DEF_ENABLED
```
Run-time Error Counters

Micrium OS Network maintains run-time counters for tracking error conditions within the Network Protocol Stack. You may want to analyze error counters to debug runtime problems such as low memory conditions, slow performance and packet loss. To enable them, edit the file net_cfg.h and set the following macros to DEF_ENABLED as shown below:
```
    #define  NET_CTR_CFG_ERR_EN                                 DEF_ENABLED
```
Network Statistics Pool configuration

These statistics are related to data buffers. You may want to analyze these statistics to optimize the memory usage of your network application. To enable them, edit the file net_cfg.h and set the following macros to DEF_ENABLED as shown below:
```
    #define  NET_STAT_POOL_BUF_EN                               DEF_ENABLED

    #define  NET_STAT_POOL_ARP_EN                               DEF_ENABLED

    #define  NET_STAT_POOL_NDP_EN                               DEF_ENABLED

    #define  NET_STAT_POOL_IGMP_EN                              DEF_ENABLED

    #define  NET_STAT_POOL_MLDP_EN                              DEF_ENABLED

    #define  NET_STAT_POOL_TMR_EN                               DEF_ENABLED

    #define  NET_STAT_POOL_SOCK_EN                              DEF_ENABLED

    #define  NET_STAT_POOL_CONN_EN                              DEF_ENABLED

    #define  NET_STAT_POOL_TCP_CONN_EN                          DEF_ENABLED
```
Internet Group Management Protocol (multicast) layer configuration
```
    #define  NET_MCAST_CFG_IPv4_RX_EN                           DEF_ENABLED
```
How to Analyze the Micrium OS Network Run-Time Statistics

To access these run-time statistics, you can either watch the arrays and variables from your IDE's watch window or call some APIs from your application. However, that quickly proves to be impractical. Instead, you can use uC/Probe, a tool that is integrated in Simplicity Studio that allows you to watch these statistics live in a series of pre-built screens as shown in the following image:

Figure 5. uC/Probe and the Micrium OS Network Screens

Installing uC/Probe

uC/Probe can be installed and integrated in Simplicity Studio by following the next steps:
- Open Simplicity Studio
- Click Help from the top menu
- Select the option Update Software from the Help menu
- Switch to the Tools tab
- Scroll-down and press the button Install next to the option Micrium uC/Probe
Figure 6. Installing uC/Probe from Simplicity Studio

Opening uC/Probe

To open uC/Probe launch a Debug Session for your project and press the button uC/Probe located on the top toolbar of Simplicity Studio as shown below:

Figure 7. Launching uC/Probe from Simplicity Studio

Associating uC/Probe to your Embedded Application

Typically uC/Probe will launch and open your project’s ELF file in the Symbol Browser as shown in the image below:

Figure 8. Symbol Browser in uC/probe

However, if the Symbol Browser is empty, then you need to press the button ELF and locate your project’s output file typically located in your toolchain’s output folder. For example:
- GNU: PROJECT_LOC/GNU ARM vx.x.x - Debug/MyOutputBinary.hex
- IAR: $PROJ_DIR$/[Project Name]/Exe/MyOutputBinary.out
Including the Micrium OS Network Screens

uC/Probe is a Windows tool that lets you associate a virtual indicator and/or control to any of your embedded application’s global variables, and then display the variables values live in a dashboard.

However, for the run-time statics maintained by the Micrium OS Network stack, a series of screens are already designed and configured to display said statistics.

To include the screens, follow the next steps:
- Locate the Workspace Explorer on the top left corner of uC/Probe.
- Click the button Insert Screens
- Select the option Micrium OS Net (TCP/IP)
Figure 9. Inserting the Micriun OS Net Screens

Watching the Run-Time Statistics Live

To start watching the run-time statistics live, ensure that your embedded application is running and press the button Run located on the top toolbar of uC/Probe as shown in the following image:

Figure 10. Running uC/Probe

Conclusion

To ensure the highest level of performance possible, it makes sense to start your Micrium OS Network based application by defining as many buffers as possible and then use uC/Probe and its interface and pool statistics data screens in order to refine the number after having run the application for a while. For example, a busy network will require more receive buffers in order to handle the additional messages that will be received.
Reducing Micrium OS Kernel's RAM footprint

Mark Mulrooney | 09/257/2018 | 05:18 PM
Overview

Micrium has a long history of providing very reliable kernels as seen with uC/OS-II and uC/OS-III, both still sold and used in many products today. Micrium OS Kernel is no exception to this and one common trait seen across all of these kernels is they are extremely configurable. A common question developers ask when evaluating real-time kernels is what is the kernel’s footprint for RAM and ROM. Micrium OS Kernel does not have a set number for RAM or ROM but instead a general range: 6-24KB ROM and 3-4KB of RAM. The reason for this is every part of the kernel, with the exception of the scheduler, can be enabled or disabled through a number of configuration header files.

Micrium OS Kernel by default uses an internal heap to allocate memory for its internal data structures and internal task stacks. The heap provides a simple, convenient way to allow a user to get a kernel project up and running quickly. The drawback to using the heap is there may be some RAM allocated to the heap that ends up not being used. This article will cover how to modify the Giant Gecko Series 1 Starter Kit (SLSTK3701A) Micrium OS Blink example to disable the internal heap and statically allocate memory for the internal data structures and task stacks. Nothing covered in this example is specific to the Giant Gecko Series 1, so these steps can be taken on any Micrium OS Kernel project.

Note: The file that is being modified, ex_main.c, is available for download at the bottom of this post.

Creating the Micrium OS Blink project

These steps assume Micrium OS Kernel is already installed in the most recent SDK version of a Simplicity Studio install. If it is not, go through the Update Software wizard for the Giant Gecko Series 1 to install all of the necessary packages.

Go to File -> New -> Project… to bring up the new project wizard. Select Silicon Labs MCU Project and click Next.

Set the board to the EFM32GG11 Giant Gecko Starter Kit board. This should trigger the Part and SDK to be set. If it does not, set the part as shown above and choose the most recent version of the SDKs. Note: Micrium OS Kernel must already installed before this step.

Select Example and click Next.

Search for the Micrium OS Blink project and click Next.

Select either Link Libraries or copy sources or Copy contents. It Is important that the ex_main.c file is copied into the project so modifications can be made. Click Finish and the project will be loaded into the Simplicity IDE.

Modifying the configuration files

Starting with the blank Micrium OS Blink project, expand the micriumos_blink/cfg folder as shown above under the Includes folder. This folder has all of the Micrium OS configuration files.
```
#define  LIB_MEM_CFG_HEAP_SIZE  0uL
```
The first step is to set the Micrium heap to zero. In common_cfg.h there is a #define for LIB_MEM_CFG_HEAP_SIZE. This value defines the size of the Micrium OS heap and should be changed to 0. After setting the heap value to 0, the project would still compile without error but would fail to run as the memory allocation would fail during OSInit().

If presented with a warning similar to the above, select Make a Copy. Any edits made to header files in the SDK would affect all future Micrium OS projects.
```
#define  RTOS_CFG_EXTERNALIZE_OPTIONAL_CFG_EN  DEF_ENABLED
```
After disabling the heap, Micrium OS needs to be set to disable the default configurations for all internal data structures and task stacks. Open up rtos_cfg.h and locate the #define for RTOS_CFG_EXTERNALIZE_OPTIONAL_CFG_EN. Change it to DEF_ENABLED to disable the default configurations. At this point, compilation of the project will fail due to a number of InitCfg structures not being set.

Configuration Structs

The rest of the code for this walk-through will be written in ex_main.c. There are three structures that must be defined: OS_InitCfg, Common_InitCfg, and PlatformMgr_InitCfg. These structures are used internally in Micrium OS and by setting RTOS_CFG_EXTERNALIZE_OPTIONAL_CFG_EN to DEF_ENABLED, the default configs for these structs has been removed and must be implemented by the developer.

OS Config Structs
```
struct  os_init_cfg {
    OS_STACK_CFG         ISR;
    OS_MSG_SIZE          MsgPoolSize;
    CPU_STK_SIZE         TaskStkLimit;
    OS_STACK_CFG         IdleTask;
    OS_TASK_CFG          StatTaskCfg;
    OS_TASK_CFG          TickTaskCfg;
    OS_TASK_CFG          TmrTaskCfg;
    MEM_SEG             *MemSeg;
};
```
The OS_INIT_CFG structure defines all of Micrium OS Kernel’s runtime configuration. It contains the stack config for all of the internal tasks (Idle, Tick, Timer, Stat), as well as the interrupt stack and an internal memory segment for internal kernel objects. The TaskStkLimit parameter will be set to zero as it is no longer used, but remains for backwards compatibility with previous versions. If an internal task has been disabled in os_cfg.h, that task’s configuration can be omitted from the OS_InitCfg.
```
struct  os_task_cfg {
    CPU_STK             *StkBasePtr;
    CPU_STK_SIZE         StkSize;
    OS_PRIO              Prio;
    OS_RATE_HZ           RateHz;
};
```
The OS_TASK_CFG structure is used to configure the Tick task, Statistics task and the Timer task. Each task will need a stack size and memory allocated for it, a priority set and the rate that the task will run at. Its important to remember that the stack size is not in bytes but stack units which are set to the width of the CPU (32 bits in this case); so a stack size of 128 stack units results in a 512 byte stack. Also, the timer task and stat task can not have a rate higher than the tick task due to being based off of the OS tick rate.
```
struct  os_stack_cfg {
    CPU_STK             *StkBasePtr;
    CPU_STK_SIZE         StkSize;
};
```
The OS_STACK_CFG structure is used for the Idle task and the ISR stack. Neither task has a priority (idle task defaults to the lowest priority, ISR is for interrupt context only) or rate associated with the task, so it only contains the stack size and location.

Common Config Struct
```
typedef  struct  common_init_cfg {
    MEM_SEG             *CommonMemSegPtr;

#if (RTOS_CFG_LOG_EN == DEF_ENABLED)
    COMMON_CFG_LOGGING   LoggingCfg;
    MEM_SEG             *LoggingMemSegPtr;
#endif
} COMMON_INIT_CFG;
```
The COMMON_INIT_CFG struct is used during the init of the common module. Typically the CommonMemSegPtr is set to DEF_NULL and logging is disabled. For this example, this will also be the case.

Platform Manager Struct
```
typedef  struct  platform_mgr_init_cfg {
    CPU_SIZE_T  PoolBlkQtyInit;
    CPU_SIZE_T  PoolBlkQtyMax;
} PLATFORM_MGR_INIT_CFG;
```
The PLATFORM_MGR_INIT_CFG struct is used for the initialization of the platform manager module. This module is used to describe hardware capabilities of peripherals such as network interfaces, USB interfaces or file systems. Normally the platform manager pulls in memory from the heap but for a kernel-only project no memory is needed so the number of blocks can be set to zero. Unfortunately even though the platform manager is not used in a kernel-only project, a configuration is still required.

Configuring Micrium OS Blink

Using the information covered in the previous section, this part will cover how to configure ex_main.c in the Micrium OS Blink project to use these configuration structures.

Kernel Config Defines

This section covers only using #defines to set configurations. Since all internal tasks are configurable these defines will check to see if the tasks are enabled before adding them to the overall OS config.
```
//////////////////////////////
// Micrium OS Configuration //
//////////////////////////////
#define  TICK_TASK_RATE_HZ                  1000u
#define  STAT_TASK_RATE_HZ	                 100u
#define  TIMER_TASK_RATE_HZ                   10u
#define  MSG_POOL_ELEMENTS                     5u

/////////////////////
// Task Priorities //
/////////////////////
#define  TICK_TASK_PRIO                        0u
#define  TIMER_TASK_PRIO                       4u
#define  STAT_TASK_PRIO                        5u
#define  EX_MAIN_START_TASK_PRIO              21u

//////////////////////
// Task Stack Sizes //
//////////////////////
#define  TICK_TASK_STK_SIZE                  128u
#define  STAT_TASK_STK_SIZE                  128u
#define  TIMER_TASK_STK_SIZE                 128u
#define  IDLE_TASK_STK_SIZE                  128u
#define  ISR_STK_SIZE                        128u
#define  EX_MAIN_START_TASK_STK_SIZE         512u
```
The first step is to set some defines for the kernel configuration. This includes the task stack sizes and priorities, the internal task rates and the message pool elements.
- Task priorities can range from 0 to OS_CFG_PRIO_MAX (defined in os_cfg.h) with 0 being the highest priority.
- The task stack sizes are specified in stack units which correspond to the width of the CPU, not bytes, so it is important to remember that a stack size of 128 stack units is actually 512 bytes.
- The rates for the tick, timer and stat task are specified in hertz. Typical tick rate for the tick task is 1000Hz, typical timer task rate is 100Hz and typical stat task rate is 10Hz.
```
////////////////////////////////
// Message Pool Configuration //
////////////////////////////////

#define  MSG_POOL_SIZE      MSG_POOL_ELEMENTS * sizeof(OS_MSG)
#define  MSG_POOL_CFG       .MsgPoolSize     = MSG_POOL_ELEMENTS, \
							.MemSeg          = &MsgPoolMemSeg,
```
The next section to define is the message pool configuration. The message pool is used for the message queues and the number of message pool elements should always match the total number of queue entries in the entire system. For example if there is one OS Queue that has 10 entries and one OS Task Queue with 20 entries, MSG_POOL_ELEMENTS should be set to 30 to guarantee there is enough entries available for all of the message queues.
```
/////////////////////////////
// Tick Task Configuration //
/////////////////////////////
#if (OS_CFG_TASK_TICK_EN == DEF_ENABLED)
#define  TICK_TASK_CFG                  .TickTaskCfg =                        \
                                        {                                     \
                                            .StkBasePtr = &TickTaskStk[0],    \
                                            .StkSize    = TICK_TASK_STK_SIZE, \
                                            .Prio       = TICK_TASK_PRIO,     \
                                            .RateHz     = TICK_TASK_RATE_HZ   \
                                        },
#else
#define  TICK_TASK_CFG
#endif

/////////////////////////////
// Stat Task Configuration //
/////////////////////////////
#if (OS_CFG_STAT_TASK_EN == DEF_ENABLED)
#define  STAT_TASK_CFG                  .StatTaskCfg =                        \
                                        {                                     \
                                            .StkBasePtr = &StatTaskStk[0],    \
                                            .StkSize    = STAT_TASK_STK_SIZE, \
                                            .Prio       = STAT_TASK_PRIO,     \
                                            .RateHz     = STAT_TASK_RATE_HZ   \
                                        },
#else
#define  STAT_TASK_CFG
#endif

//////////////////////////////
// Timer Task Configuration //
//////////////////////////////
#if (OS_CFG_TMR_EN == DEF_ENABLED)
#define  TIMER_TASK_CFG                 .TmrTaskCfg =                         \
                                        {                                     \
                                            .StkBasePtr = &TimerTaskStk[0],   \
                                            .StkSize    = TIMER_TASK_STK_SIZE,\
                                            .Prio       = TIMER_TASK_PRIO,    \
                                            .RateHz     = TIMER_TASK_RATE_HZ  \
                                        },
#else
#define  TIMER_TASK_CFG
#endif
```
The Tick Task, Stat Task and Timer Task all use the OS_TASK_CFG structure so using the values defined from the Micrium OS Configuration section above, their declarations are fairly similar. The only variable not yet covered in these structs is the stack pointer. The stack pointer variables will be declared a littler farther down in ex_main.c, right now this is just #defines to be included later on.
```
/////////////////////////////
// Idle Task Configuration //
/////////////////////////////
#if (OS_CFG_TASK_IDLE_EN == DEF_ENABLED)
#define  IDLE_TASK_CFG				   .IdleTask =                            \
                                       {                                      \
                                           .StkBasePtr  = &IdleTaskStk[0],    \
                                           .StkSize     = IDLE_TASK_STK_SIZE  \
                                       },
#else
#define  IDLE_TASK_CFG
#endif

///////////////////////
// ISR Configuration //
///////////////////////
#define  ISR_CFG                       .ISR =                                 \
                                       {                                      \
                                           .StkBasePtr  = &ISRStack[0],       \
                                           .StkSize     = ISR_STK_SIZE        \
                                       },
```
The idle task and ISR configuration both use OS_STACK_CFG. Similar to the ones using OS_TASK_CFG, these configs use the stack size defines from the Micrium OS Configuration section above and the stack variables will be defined later on.
```
////////////////////////////////
// Micrium OS  Configurations //
////////////////////////////////
#define  OS_INIT_CFG_APP            {                                \
						                ISR_CFG                      \
							            IDLE_TASK_CFG                \
							            TICK_TASK_CFG                \
							            STAT_TASK_CFG                \
							            TIMER_TASK_CFG               \
                                        MSG_POOL_CFG                 \
                                        .TaskStkLimit = 0u,          \
                                    }

#define  COMMON_INIT_CFG_APP        {                                \
                                        .CommonMemSegPtr = DEF_NULL  \
                                    }

#define  PLATFORM_MGR_INIT_CFG_APP  {                                \
                                        .PoolBlkQtyInit = 0u,        \
                                        .PoolBlkQtyMax  = 0u         \
                                    }
```
Using the #defines for the message pool, internal tasks and the ISR stack, the OS_INIT_CFG_APP define can be set. As mentioned earlier the TaskStkLimit can be set to zero as it is no longer used.

The COMMON_INIT_CFG_APP define only has one variable, CommonMemSegPtr defined. The other variables in the struct are only enabled if the logging module is enabled. Since no modules in common need memory for this application the MemSegPtr will be set to DEF_NULL to signal it is not in use.

The PLATFORM_MSG_INIT_CFG_APP define is similar to COMMON_INIT_CFG_APP, the two fields in it can be set to zero as its not needed for this application.

Kernel Config Variables

Now that the defines have all been set, the stacks need to be created and the config defines need to be set to the necessary variables for Micrium OS Kernel to pull them in.
```
//////////////////////////
// Micrium OS Variables //
//////////////////////////

#if (OS_CFG_TASK_IDLE_EN == DEF_ENABLED)
static  CPU_STK  IdleTaskStk[IDLE_TASK_STK_SIZE];
#endif

#if (OS_CFG_TASK_TICK_EN == DEF_ENABLED)
static  CPU_STK  TickTaskStk[TICK_TASK_STK_SIZE];
#endif

#if (OS_CFG_STAT_TASK_EN == DEF_ENABLED)
static  CPU_STK  StatTaskStk[STAT_TASK_STK_SIZE];
#endif

#if (OS_CFG_TMR_EN == DEF_ENABLED)
static  CPU_STK  TimerTaskStk[TIMER_TASK_STK_SIZE];
#endif

static  CPU_STK  ISRStack[ISR_STK_SIZE];

#if (MSG_POOL_ELEMENTS > 0)
static  MEM_SEG    MsgPoolMemSeg;
static  CPU_INT08U MsgPoolMem[MSG_POOL_SIZE];
#endif

const   OS_INIT_CFG             OS_InitCfg          = OS_INIT_CFG_APP;
const   COMMON_INIT_CFG         Common_InitCfg      = COMMON_INIT_CFG_APP;
const   PLATFORM_MGR_INIT_CFG   PlatformMgr_InitCfg = PLATFORM_MGR_INIT_CFG_APP;
```
The stack variables will only be created if the tasks are enabled in os_cfg.h. If the task is enabled, the size is pulled in from the configuration above. The ISR stack is always created because its needed in every Micrium OS project. The message pool is only created if it is needed.

The OS_INIT_CFG, COMMON_INIT_CFG and PLATFORM_MGR_INIT_CFG structs MUST be named OS_InitCfg, Common_InitCfg and PlatformMgr_InitCfg. This is due to the RTOS_CFG_EXTERNALIZE_OPTIONAL_CFG_EN define set in the rtos_cfg.h. Micrium OS uses variables by these names to initialize the modules and if they are not defined in the user application, there will be compilation errors as the internal default config has been removed by the define in rtos_cfg.h.

Inits in main() and includes

After setting up all of the necessary variables for the config structs, two more changes must be made.
```
#include  
```
The ex_main.c file needs to have the platform manager header file added to its list of includes. A compilation error will occur without this extra include.
```
int  main (void)
{
    RTOS_ERR  err;

#if (MSG_POOL_ELEMENTS > 0)
    Mem_SegCreate(          "Msg Pool Mem",                     /* Create the Message Pool memory segment               */
    		                &MsgPoolMemSeg,
				  (CPU_ADDR)&MsgPoolMem,
				             MSG_POOL_SIZE,
				             LIB_MEM_PADDING_ALIGN_NONE,
				            &err);
    APP_RTOS_ASSERT_DBG((RTOS_ERR_CODE_GET(err) == RTOS_ERR_NONE), 1);
#endif

    ...
}
```
The last change that needs to be made to ex_main.c is the addition of a Memory Segment Create. The OS config only allocates space for a memory segment. When the application starts up, its necessary to make a call to Mem_SegCreate to create the memory segment BEFORE the OSInit call is made. OSInit uses the memory segment and if it has not been initialized the application will fail to run.

Building the new Blink project and comparing results

After all of these changes have been made to the Micrium OS Blink project, the project can be built by right clicking on the project name and selecting Build Project as shown above.

Default Micrium OS Blink project RAM/ROM usage

Micrium OS Blink project RAM/ROM usage after adding external configuration

After building the project the console window will show the final sizes for RAM and ROM. As seen in the images above, the RAM usage is reduced from 24KB to just under 19KB simply by moving the internal tasks from the heap to the external config instead.

The default RAM usage in this project is rather high to begin with because it includes SEGGER's SystemView code and the application task stack size is very large for such a simple project (currently set to 512 stack units/2048 bytes). To further reduce RAM usage in this project its possible to:
- Disable internal tasks that are not needed via os_cfg.h.
- Disable SEGGER SystemView code via os_cfg.h and os_cfg_trace.h
- Shrink the Main Start Task Stack Size
- Reuse CSTACK after the OS has started up
The ex_main.c file is attached to this post and feel free to ask any questions in the forum below.
ex_main.c

Adding Micrium OS on a Flex Gecko

Janos Magasrevy | 06/159/2018 | 06:05 PM

This blog should serve as a guide to adding Micrium OS on a Flex Gecko and get at least one task running on the device.

I will now share with you my experience while going through this exercise.

Getting Started

I decided to perform a clean installation of Simplicity Studio in order to avoid conflicts inflicted by software updates over time. After installing the tool, before even attempting to add anything, I first had to make sure that I had the necessary SDKs. Here's what I installed:

32-bit MCU SDK - 5.5.0.0
Micrium OS - 5.4.0
Flex SDK - 2.3.0.0

I then mounted a Flex Gecko, EFR32FG12 in my case, onto a Wireless Started Kit Mainboard (BRD4001A). After that, I connected it to the PC using the provided USB cable.

Simplicity Studio recognized a Flex Gecko connected to a WSTK and displayed the link to examples from the Flex SDK (see Figure 1).

Loading a Basic Flex SDK Example

As a starting point, I decided to go with the "RAIL: Simple RAIL without HAL" example from the Flex SDK.

You can find this by expanding the list of projects under the "Silicon Labs Flex SDK Examples" link:

Then find and click the example shown in Figure 3 to add it to your workspace:

Figure 3 - RAIL: Simple RAIL without HAL Example

After the example loads on your workspace, you might get a notice as shown in Figure 4. Just click "OK".

You will then be presented with simple_rail_without_hal.isc opened where you can configure RAIL. In my case, I left everything in its default values and simply clicked on "Generate" as shown in Figure 5.

At this point, you should now be set with a basic Flex Gecko example that builds and runs. However, I did find that the default project settings have compiler optimization set to "Optimize for size (-Os)" which will eventually make debugging the project rather difficult. Therefore, I switched optimizations to "None (-O0)".

Adding Micrium OS to the Workspace

Now that you have a basic Flex Gecko example that builds and runs, let's go ahead and start adding the Micrium OS source files into the workspace.

First, locate the Micrium OS directory, it should be in:

C:\SiliconLabs\SimplicityStudio\v4\developer\sdks\gecko_sdk_suite\v2.3\platform\micrium_os

Now drag and drop the "micrium_os" folder into your project (simple_rail_without_hal) in Simplicity Studio. When doing this, make sure that you have "Copy files and folders" selected before clicking "OK" as shown in Figure 7.

Figure 7 - Adding Micrium OS Folder to Project

You will then have to remove all the unnecessary files that get added with Micrium OS (this was tedious).

Here's how your "micrium_os" folder should end up looking:

Finally, the compiler needs to know where to look for the header files so we have to add two compiler include paths to the project settings:

"${workspace_loc:/${ProjName}/micrium_os}"
"${workspace_loc:/${ProjName}/micrium_os/cfg}"

Figure 9 - Micrium OS Compiler Include Paths

Configuring Micrium OS

Now that you have Micrium OS as part of your project, let's go ahead and make some minor adjustments to the default Micrium OS configuration.

Open rtos_description.h located in your project under "micrium_os/cfg/"
Replace the contents of the file with one below:

/*
*********************************************************************************************************
*                                             EXAMPLE CODE
*********************************************************************************************************
* Licensing:
*   The licensor of this EXAMPLE CODE is Silicon Laboratories Inc.
*
*   Silicon Laboratories Inc. grants you a personal, worldwide, royalty-free, fully paid-up license to
*   use, copy, modify and distribute the EXAMPLE CODE software, or portions thereof, in any of your
*   products.
*
*   Your use of this EXAMPLE CODE is at your own risk. This EXAMPLE CODE does not come with any
*   warranties, and the licensor disclaims all implied warranties concerning performance, accuracy,
*   non-infringement, merchantability and fitness for your application.
*
*   The EXAMPLE CODE is provided "AS IS" and does not come with any support.
*
*   You can find user manuals, API references, release notes and more at: https://doc.micrium.com
*
*   You can contact us at: https://www.micrium.com
*********************************************************************************************************
*/

/*
*********************************************************************************************************
*
*                                           RTOS DESCRIPTION
*
*                                      CONFIGURATION TEMPLATE FILE
*
* File : rtos_description.h
*********************************************************************************************************
*/

/*
*********************************************************************************************************
*********************************************************************************************************
*                                               MODULE
*********************************************************************************************************
*********************************************************************************************************
*/

#ifndef  _RTOS_DESCRIPTION_H_
#define  _RTOS_DESCRIPTION_H_


/*
*********************************************************************************************************
*********************************************************************************************************
*                                             INCLUDE FILES
*********************************************************************************************************
*********************************************************************************************************
*/

#include  <common/include/rtos_opt_def.h>


/*
*********************************************************************************************************
*********************************************************************************************************
*                                       ENVIRONMENT DESCRIPTION
*********************************************************************************************************
*********************************************************************************************************
*/

#define  RTOS_CPU_SEL                                       RTOS_CPU_SEL_ARM_V7_M

#define  RTOS_TOOLCHAIN_SEL                                 RTOS_TOOLCHAIN_GNU

#define  RTOS_INT_CONTROLLER_SEL                            RTOS_INT_CONTROLLER_ARMV7_M


/*
*********************************************************************************************************
*********************************************************************************************************
*                                       RTOS MODULES DESCRIPTION
*********************************************************************************************************
*********************************************************************************************************
*/

                                                                /* ---------------------- KERNEL ---------------------- */
#define  RTOS_MODULE_KERNEL_AVAIL


/*
*********************************************************************************************************
*********************************************************************************************************
*                                             MODULE END
*********************************************************************************************************
*********************************************************************************************************
*/

#endif                                                          /* End of rtos_description.h module include.            */

Modifying main.c

We'll be making modifications to the default main.c generated by the "RAIL: Simple RAIL without HAL" example.

Micrium OS requires the following include paths in main.c so go ahead and add them as shown below:

#include  <cpu/include/cpu.h>
#include  <kernel/include/os.h>
#include  <common/include/common.h>
#include  <common/include/rtos_utils.h>
#include  <common/source/kal/kal_priv.h>  /* Private file, use should be limited */

We'll be modifying main.c to initialize Micrium OS and create a start task. For that, you'll need to specify a task stack size and a priority. We typically do this by defining them as constants and passing those in the call to OSTaskCreate().

The start task also requires its own Stack and Task Control Block (OS_TCB) as well as its function prototype. Therefore, add the following to main.c:

#define  START_TASK_PRIO              21u
#define  START_TASK_STK_SIZE         512u
                                                                
static  CPU_STK  StartTaskStk[START_TASK_STK_SIZE];  /* Start Task Stack. */
static  OS_TCB   StartTaskTCB;                       /* Start Task TCB.   */

static  void  StartTask (void  *p_arg);

Here's the body of the StartTask function where the kernel tick gets initialize and as well as the Common module. Note that the function includes an infinite loop at the end with a time delay of 1 second. This is done to yield CPU time to other tasks that are or will eventually run on your system. You can copy and paste the following in your main.c:

static  void  StartTask (void  *p_arg)
{
  RTOS_ERR    err;
  CPU_INT32U  cpu_freq;
  CPU_INT32U  cnts;

  /* Prevent compiler warning. */
  PP_UNUSED_PARAM(p_arg);                                     

  /* Determine SysTick reference freq. */
  cpu_freq =  SystemCoreClockGet();
  /* Cal. SysTick counts between two OS tick interrupts. */
  cnts     = (cpu_freq / (CPU_INT32U)KAL_TickRateGet());

  /* Init uC/OS periodic time src (SysTick). */
  OS_CPU_SysTickInit(cnts);

#if (OS_CFG_STAT_TASK_EN == DEF_ENABLED)
  /* Initialize CPU Usage. */
  OSStatTaskCPUUsageInit(&err);
  /* Check error code. */
  APP_RTOS_ASSERT_DBG((RTOS_ERR_CODE_GET(err) == RTOS_ERR_NONE), ;);
#endif

#ifdef CPU_CFG_INT_DIS_MEAS_EN
  /* Initialize interrupts disabled measurement. */
  CPU_IntDisMeasMaxCurReset();
#endif

  /* Call common module initialization example. */
  Common_Init(&err);
  APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

  while (DEF_ON) {
	  /* Delay Start Task execution for 1000 OS Ticks from now. */
      OSTimeDly(1000, OS_OPT_TIME_DLY, &err);
      /* Check error code. */
      APP_RTOS_ASSERT_DBG((RTOS_ERR_CODE_GET(err) == RTOS_ERR_NONE), ;);
  }
}

Finally, let's modify main() to initialize the CPU, re-assign interrupt handlers as kernel-aware, initialize the kernel, create the Start Task, and start the OS. Here's how main() should end up looking:

int main(void)
{
  uint32_t vtorAddress = SCB->VTOR;
  CPU_FNCT_VOID * vtor = (CPU_FNCT_VOID *)vtorAddress;
  RTOS_ERR  err;

  CPU_Init();

  /* Re-assign previous interrupt handlers as kernel-aware */
  for (uint32_t i = CPU_INT_EXT0; i < CPU_INT_EXT0 + EXT_IRQ_COUNT; i++) {
    CPU_IntSrcHandlerSetKA(i, vtor[i]);
  }

  /* Initialize the Kernel. */
  OSInit(&err);
  /* Check error code. */
  APP_RTOS_ASSERT_DBG((RTOS_ERR_CODE_GET(err) == RTOS_ERR_NONE), 1);

  /* Create the Start Task. */
  OSTaskCreate(&StartTaskTCB,
               "Start Task",
                StartTask,
                DEF_NULL,
                START_TASK_PRIO,
               &StartTaskStk[0],
               (START_TASK_STK_SIZE / 10u),
                START_TASK_STK_SIZE,
                0u,
                0u,
                DEF_NULL,
               (OS_OPT_TASK_STK_CLR),
               &err);
  /* Check error code. */
  APP_RTOS_ASSERT_DBG((RTOS_ERR_CODE_GET(err) == RTOS_ERR_NONE), 1);

  /* Start the kernel. */
  OSStart(&err);
  /* Check error code. */
  APP_RTOS_ASSERT_DBG((RTOS_ERR_CODE_GET(err) == RTOS_ERR_NONE), 1);

  return (1);
}

You are now set to build and run the project. You can put a breakpoint on the Start Task inside the while loop and notice that you'll be hitting that every second (or as specified by the delay you configure in OSTimeDly()).

Please do understand that this is a very basic guide that resembles more a hack rather than an official solution from Silicon Labs. Hopefully, Micrium OS can be part of the Flex SDK in the future, but in the meantime, this is a start.

I hope this was useful to you. Feel free to post any comments or questions regarding this blog post.

Baseline Project

Configuration Files

Adding USBD Class and Demo

Running the Example

Baseline Project

Configuration Files

Adding USBD Class and Demo

Running the Example

Background

Revealing the 57 Hidden Gems

How to run the hidden Micrium OS Examples

Example

Micrium OS Kernel Red Zone

Using the Red Zone Application Hook

Baseline Project

Configuration Files

Editing the Example Files

Running the Example

Introduction

Verify Performance

Detect Errors

Optimize Memory Usage

Monitor Network Connections

How to Enable the Micrium OS Network Run-Time Statistics

Run-time Statistics Counters

Run-time Error Counters

Network Statistics Pool configuration

Internet Group Management Protocol (multicast) layer configuration

How to Analyze the Micrium OS Network Run-Time Statistics

Installing uC/Probe

Opening uC/Probe

Associating uC/Probe to your Embedded Application

Including the Micrium OS Network Screens

Watching the Run-Time Statistics Live

Conclusion

Overview

Creating the Micrium OS Blink project

Modifying the configuration files

Configuration Structs

OS Config Structs

Common Config Struct

Platform Manager Struct

Configuring Micrium OS Blink

Kernel Config Defines

Kernel Config Variables

Inits in main() and includes

Building the new Blink project and comparing results

Getting Started

Loading a Basic Flex SDK Example

Adding Micrium OS to the Workspace

Configuring Micrium OS

Modifying main.c

Tags

Top Authors

Archives