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/

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.

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.

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...

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.

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...

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.

                                                                /* ----------------- FORMAT RAM DISK ------------------ */
#if  (defined(RTOS_MODULE_FS_STORAGE_RAM_DISK_AVAIL))
    {
        FS_BLK_DEV_HANDLE  blk_dev_handle;

                                                                /* Format RAM Disk as a FAT volume.                     */
        blk_dev_handle = FSBlkDev_Open(FSMedia_Get("ram0"), &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

                                                                /* Assign cache to this device.                         */
        FSCache_Assign(blk_dev_handle,
                       Ex_FS_DataPtr->CachePtr,                 /* Pointer to cache instance previously created.        */
                       &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

        FS_FAT_Fmt(blk_dev_handle,
                   FS_PARTITION_NBR_VOID,                       /* Only 1 partition.                                    */
                   DEF_NULL,                                    /* Format with default values.                          */
                   &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.

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...

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  
#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.

                                                                /* ----------------- FORMAT RAM DISK ------------------ */
#if  (defined(RTOS_MODULE_FS_STORAGE_RAM_DISK_AVAIL))
{
        FS_BLK_DEV_HANDLE  blk_dev_handle;

                                                                /* Format RAM Disk as a FAT volume.                     */
        blk_dev_handle = FSBlkDev_Open(FSMedia_Get("ram0"), &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

                                                                /* Assign cache to this device.                         */
        FSCache_Assign(blk_dev_handle,
                       Ex_FS_DataPtr->CachePtr,                 /* Pointer to cache instance previously created.        */
                       &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

        FS_FAT_Fmt(blk_dev_handle,
                   FS_PARTITION_NBR_VOID,                       /* Only 1 partition.                                    */
                   DEF_NULL,                                    /* Format with default values.                          */
                   &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.

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...

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  
#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.

                                                                /* ----------------- FORMAT RAM DISK ------------------ */
#if  (defined(RTOS_MODULE_FS_STORAGE_RAM_DISK_AVAIL))
{
        FS_BLK_DEV_HANDLE  blk_dev_handle;

                                                                /* Format RAM Disk as a FAT volume.                     */
        blk_dev_handle = FSBlkDev_Open(FSMedia_Get("ram0"), &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

                                                                /* Assign cache to this device.                         */
        FSCache_Assign(blk_dev_handle,
                       Ex_FS_DataPtr->CachePtr,                 /* Pointer to cache instance previously created.        */
                       &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

        FS_FAT_Fmt(blk_dev_handle,
                   FS_PARTITION_NBR_VOID,                       /* Only 1 partition.                                    */
                   DEF_NULL,                                    /* Format with default values.                          */
                   &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.

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...

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\\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  
#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.

                                                                /* ----------------- FORMAT RAM DISK ------------------ */
#if  (defined(RTOS_MODULE_FS_STORAGE_RAM_DISK_AVAIL))
{
        FS_BLK_DEV_HANDLE  blk_dev_handle;

                                                                /* Format RAM Disk as a FAT volume.                     */
        blk_dev_handle = FSBlkDev_Open(FSMedia_Get("ram0"), &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

                                                                /* Assign cache to this device.                         */
        FSCache_Assign(blk_dev_handle,
                       Ex_FS_DataPtr->CachePtr,                 /* Pointer to cache instance previously created.        */
                       &err);
        APP_RTOS_ASSERT_CRITICAL(err.Code == RTOS_ERR_NONE, ;);

        FS_FAT_Fmt(blk_dev_handle,
                   FS_PARTITION_NBR_VOID,                       /* Only 1 partition.                                    */
                   DEF_NULL,                                    /* Format with default values.                          */
                   &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.

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:

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.

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}"

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.

1. Open rtos_description.h located in your project under "micrium_os/cfg/"
2. 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.