Micro-Controller Operating Systems

MicroC/OS (μC/OS)Developer| Micrium, Inc.,
Silicon Labs

|

Written in| ANSI C
Working state| Current
Source model| Open-source as of 2020
Initial release| 1991; 35 years ago (1991)
|Final release|Latest release}}| OS-III / 2016; 10 years ago (2016)
Repository| github.com/weston-embedded/uC-OS3
Marketing target| Embedded devices
Available in| English
Platforms| ARM Cortex-M3, -M4F, ARM7TDMI; Atmel AVR; eSi-RISC, and many others
Kernel type| Real-time microkernel
Default user interface| μC/GUI
License| Apache as of 2020; former Commercial, freeware education use
Official website| weston-embedded.com/micrium/overview
Micrium OSDeveloper| Silicon Labs

|

Written in| ANSI C
Working state| Current
Source model| Open-source
Initial release| 2020; 6 years ago (2020)
|Final release|Latest release}}| Part of Gecko Platform 4.2.0.0,[1] part of Gecko SDK 4.2.0.0[2] / December 14, 2022; 3 years ago (2022-12-14)
Repository| github.com/SiliconLabs/gecko_sdk/tree/gsdk_4.2/platform/micrium_os
Marketing target| Embedded devices
Available in| English
Platforms| exclusively Silicon Labs silicon
Kernel type| Real-time microkernel
License| Apache
Official website| www.silabs.com/developers/micrium-os
Cesium RTOSDeveloper| Weston Embedded Solutions

|

Written in| ANSI C
Working state| Current
Source model| Commercial
Initial release| June 23, 2020; 5 years ago (2020-06-23) (forked from uC/OS-III V3.08.00)[3]
|Final release|Latest release}}| Cs/OS3 3.09.05[3] / April 22, 2025; 12 months ago (2025-04-22)[3]
Marketing target| Embedded devices
Available in| English
Platforms| 50+ unclear whether there is a 1-to-1 overlap with μC/OS
Kernel type| Real-time microkernel
License| Commercial
Official website| weston-embedded.com/products/cesium

Micro-Controller Operating Systems (MicroC/OS, stylized as μC/OS, or Micrium OS) is a real-time operating system (RTOS) designed by Jean J. Labrosse in 1991. It is a priority-based preemptive real-time kernel for microprocessors, written mostly in the programming language C. It is intended for use in embedded systems.

MicroC/OS allows defining several functions in C, each of which can execute as an independent thread or task. Each task runs at a different priority, and runs as if it owns the central processing unit (CPU). Lower priority tasks can be preempted by higher priority tasks at any time. Higher priority tasks use operating system (OS) services (such as a delay or event) to allow lower priority tasks to execute. OS services are provided for managing tasks and memory, communicating between tasks, and timing.[4]

## Contents

* 1 History
* 2 μC/OS-II
* 2.1 Uses in embedded systems
* 2.2 Task states
* 2.3 Kernels
* 2.4 Assigning tasks
* 2.5 Managing tasks
* 2.6 Managing memory
* 2.7 Managing time
* 2.8 Communicating between tasks
* 3 μC/OS-III
* 3.1 Uses in embedded systems
* 3.2 Task states
* 3.3 Round robin scheduling
* 3.4 Kernels
* 3.5 Managing tasks
* 3.6 Managing memory
* 3.7 Managing time
* 3.8 Communicating between tasks
* 4 Ports
* 5 Licensing change
* 6 Documentation and support
* 7 References
* 8 Sources
* 9 External links

## History

The MicroC/OS kernel was published originally in a three-part article in Embedded Systems Programming magazine and the book μC/OS The Real-Time Kernel by Labrosse.[5] He intended at first to simply describe the internals of a portable OS he had developed for his own use, but later developed it as a commercial product in his own company Micrium, Inc. in versions II and III.

In 2016 Micrium, Inc. was acquired by Silicon Laboratories[6] and it was subsequently released as open-source under the Apache license.

Silicon Labs continues to maintain an open-source product named Micrium OS for use on their own silicon[7] and a group of former Micrium, Inc. employees (including Labrosse) provides consultancy and support for both μC/OS and Cesium RTOS, a proprietary fork made just after the open-source release.[8]

## μC/OS-II

Based on the source code written for μC/OS, and introduced as a commercial product in 1998, μC/OS-II is a portable, ROM-able, scalable, preemptive, real-time, deterministic, multitasking kernel for microprocessors, and digital signal processors (DSPs). It manages up to 64 tasks. Its size can be scaled (between 5 and 24 Kbytes) to only contain the features needed for a given use.

Most of μC/OS-II is written in highly portable ANSI C, with target microprocessor-specific code written in assembly language. Use of the latter is minimized to ease porting to other processors.

### Uses in embedded systems

μC/OS-II was designed for embedded uses. If the producer has the proper toolchain (i.e., C compiler, assembler, and linker-locator[clarification needed]), μC/OS-II can be embedded as part of a product.

μC/OS-II is used in many embedded systems, including:

* Avionics
* Medical equipment and devices
* Data communications equipment
* White goods (appliances)
* Mobile phones, personal digital assistants (PDAs), MIDs
* Industrial controls
* Consumer electronics
* Automotive

### Task states

μC/OS-II is a multitasking operating system. Each task is an infinite loop and can be in any one of the following five states (see figure below additionally)

* Dormant
* Ready
* Running
* Waiting (for an event)
* Interrupted (interrupt service routine (ISR))

Further, it can manage up to 64 tasks. However, it is recommended that eight of these tasks be reserved for μC/OS-II, leaving an application up to 56 tasks.[9]

### Kernels

The kernel is the name given to the program that does most of the housekeeping tasks for the operating system. The boot loader hands control over to the kernel, which initializes the various devices to a known state and makes the computer ready for general operations.[10] The kernel is responsible for managing tasks (i.e., for managing the CPU's time) and communicating between tasks.[11] The fundamental service provided by the kernel is context switching.

The scheduler is the part of the kernel responsible for determining which task runs next.[12] Most real-time kernels are priority based. In a priority-based kernel, control of the CPU is always given to the highest priority task ready to run. Two types of priority-based kernels exist: non-preemptive and preemptive. Nonpreemptive kernels require that each task do something to explicitly give up control of the CPU.[12] A preemptive kernel is used when system responsiveness is more important. Thus, μC/OS-II and most commercial real-time kernels are preemptive.[13] The highest priority task ready to run is always given control of the CPU.

### Assigning tasks

Tasks with the highest rate of execution are given the highest priority using rate-monotonic scheduling.[14] This scheduling algorithm is used in real-time operating systems (RTOS) with a static-priority scheduling class.[15]

### Managing tasks

In computing, a task is a unit of execution. In some operating systems, a task is synonymous with a process, in others with a thread. In batch processing computer systems, a task is a unit of execution within a job. The system user of μC/OS-II is able to control the tasks by using the following features:

* Task feature
* Task creation
* Task stack & stack checking
* Task deletion
* Change a task's priority
* Suspend and resume a task
* Get information about a task[16]

### Managing memory

To avoid fragmentation, μC/OS-II allows applications to obtain fixed-sized memory blocks from a partition made of a contiguous memory area. All memory blocks are the same size, and the partition contains an integral number of blocks. Allocation and deallocation of these memory blocks is done in constant time and is a deterministic system.[17]

### Managing time

μC/OS-II requires that a periodic time source be provided to keep track of time delays and timeouts. A tick should occur between 10 and 1000 times per second, or Hertz. The faster the tick rate, the more overhead μC/OS-II imposes on the system. The frequency of the clock tick depends on the desired tick resolution of an application. Tick sources can be obtained by dedicating a hardware timer, or by generating an interrupt from an alternating current (AC) power line (50 or 60 Hz) signal. This periodic time source is termed a clock tick.[18]

After a clock tick is determined, tasks can be:

* Delaying a task
* Resume a delayed task

### Communicating between tasks

Intertask or interprocess communication in μC/OS-II occurs via: semaphores, message mailbox, message queues, tasks, and interrupt service routines (ISRs). They can interact with each other when a task or an ISR signals a task through a kernel object called an event control block (ECB). The signal is considered to be an event.

## μC/OS-III

μC/OS-III is the acronym for Micro-Controller Operating Systems Version 3, introduced in 2009 and adding functionality to the μC/OS-II RTOS.

μC/OS-III offers all of the features and functions of μC/OS-II. The biggest difference is the number of supported tasks. μC/OS-II allows only 1 task at each of 255 priority levels, for a maximum of 255 tasks. μC/OS-III allows any number of application tasks, priority levels, and tasks per level, limited only by processor access to memory.[19][20]

μC/OS-II and μC/OS-III are currently maintained by Micrium, Inc., a subsidiary of Silicon Labs, and can be licensed per product or per product line.

### Uses in embedded systems

The uses are the same as for μC/OS-II

### Task states

μC/OS-III is a multitasking operating system. Each task is an infinite loop and can be in any one of five states (dormant, ready, running, interrupted, or pending). μC/OS-III supports an unlimited number of task priorities but configuring μC/OS-III to have between 32 and 256 task priorities typically suits most embedded systems well.[21]

### Round robin scheduling

When two or more tasks have the same priority, the kernel allows one task to run for a predetermined amount of time, named a quantum, and then selects another task. This process is termed round robin scheduling or time slicing. The kernel gives control to the next task in line if:

* The current task has no work to do during its time slice, or
* The current task completes before the end of its time slice, or
* The time slice ends.

### Kernels

The kernel functionality for μC/OS-III is the same as for μC/OS-II.

### Managing tasks

Task management also functions the same as for μC/OS-II. However, μC/OS-III supports multitasking and allows an application to have any number of tasks. The maximum number of tasks is limited by only the amount of computer memory (both code and data space) available to the processor.

A task can be implemented viarunning to scheduled completion, in which the task deletes itself when it is finished, or more typically as an infinite loop, waiting for events to occur and processing those events.

### Managing memory

Memory management is performed in the same way as in μC/OS-II.

### Managing time

μC/OS-III offers the same time managing features as μC/OS-II. It also provides services to applications so that tasks can suspend their execution for user-defined time delays. Delays are specified by a number of either clock ticks, or hours, minutes, seconds, and milliseconds.

### Communicating between tasks

Sometimes, a task or ISR must communicate information to another task, because it is unsafe for two tasks to access the same specific data or hardware resource at once. This can be resolved via an information transfer, termed inter-task communication. Information can be communicated between tasks in two ways: through global data, or by sending messages.

When using global variables, each task or ISR must ensure that it has exclusive access to variables. If an ISR is involved, the only way to ensure exclusive access to common variables is to disable interrupts. If two tasks share data, each can gain exclusive access to variables by either disabling interrupts, locking the scheduler, using a semaphore, or preferably, using a mutual exclusion semaphore. Messages can be sent to either an intermediate object called a message queue, or directly to a task, since in μC/OS-III, each task has its own built-in message queue. Use an external message queue if multiple tasks are to wait for messages. Send a message directly to a task if only one task will process the data received. While a task waits for a message to arrive, it uses no CPU time.

## Ports

A port involves three aspects: CPU, OS, and board specific (BSP) code. μC/OS-II and μC/OS-III have ports for most popular processors and boards in the market and are suitable for use in safety critical embedded systems such as aviation, medical systems, and nuclear installations. A μC/OS-III port involves writing or changing the contents of three kernel specific files: `OS_CPU.H`, `OS_CPU_A.ASM`, and `OS_CPU_C.C`. Finally create or change a board support package (BSP) for the evaluation board or target board being used. A μC/OS-III port is similar to a μC/OS-II port. There are significantly more ports than listed here, and ports are subject to continuous development. Both μC/OS-II and μC/OS-III are supported by popular SSL/TLS libraries such as wolfSSL, which ensure security across all connections.

## Licensing change

After acquisition by Silicon Labs, Micrium in 2020 changed to open-source model licensing in February 2020. This includes uC/OS III, all prior versions, all components: USB, file system, GUI, TCP/IP, etc.

## Documentation and support

Support is available via a typical support forum, and several comprehensive books, of which some are tailored to a given microcontroller architecture and development platform, as free PDFs, or as low-cost purchase in hard-cover. Paid support is available from Weston Embedded Solutions.

## References

1. ↑ "Gecko Platform 4.2.0.0 GA". 2022-12-14. https://www.silabs.com/documents/public/release-notes/gecko-platform-release-notes-4.2.0.0.pdf.
2. ↑ "gecko_sdk Releases on github.com". https://github.com/SiliconLabs/gecko_sdk/releases.
3. ↑ 3.0 3.1 3.2 "Cs/OS3 Release Notes". Weston Embedded Solutions. https://weston-embedded.com/cesium-release-notes/cs-os3-release-notes.
4. ↑ "NiosII GCC with MicroC/OS". Cornell University. June 2006. https://people.ece.cornell.edu/land/courses/ece5760/NiosII_muCOS/.
5. ↑ Labrosse, Jean J. (15 June 2002). μC/OS The Real-Time Kernel (2nd ed.). CRC Press. ISBN 978-1578201037.
6. ↑ "What is Micrium?". Weston Embedded Solutions. https://weston-embedded.com/about-micrium.
7. ↑ "Micrium Software and Documentation". https://www.silabs.com/developers/micrium.
8. ↑ "Why Cesium RTOS?". Weston Embedded Solutions. https://weston-embedded.com/why-cesium.
9. ↑ Labrosse, Jean J.. MicroC/OS-II: The Real Time Kernel (2nd ed.). p. 77.
10. ↑ Wikiversity:Operating Systems/Kernel Models#Monolithic Kernel
11. ↑ Labrosse, Jean J.. MicroC/OS-II: The Real Time Kernel (2nd ed.). p. 39.
12. ↑ 12.0 12.1 Labrosse, Jean J.. MicroC/OS-II: The Real Time Kernel (2nd ed.). p. 40.
13. ↑ Labrosse, Jean J.. MicroC/OS-II: The Real Time Kernel (2nd ed.). p. 42.
14. ↑ Liu, Chung Lang; Layland, James W. (1973). "Scheduling algorithms for multiprogramming in a hard real-time environment". Journal of the ACM 20 (1): 46–61. doi:10.1145/321738.321743.
15. ↑ Bovet, Daniel. "Understanding The Linux Kernel". Archived from the original on 2014-09-21. https://web.archive.org/web/20140921000832/http://oreilly.com/catalog/linuxkernel/chapter/ch10.html.
16. ↑ Labrosse, Jean J.. MicroC/OS-II: The Real Time Kernel (2nd ed.). pp. 45–49.
17. ↑ Labrosse, Jean J.. MicroC/OS-II: The Real Time Kernel (2nd ed.). pp. 273–285.
18. ↑ Labrosse, Jean J.. MicroC/OS-II: The Real Time Kernel (2nd ed.). pp. 145–152.
19. ↑ "μC/OS-II and μC/OS-III Features Comparison". http://micrium.com/rtos/ucosiii/rtos-comparison/.
20. ↑ "μC/OS-III overview". http://micrium.com/rtos/ucosiii/overview/.
21. ↑ "μC/OS-III™ Real-Time Operating System". https://media.digikey.com/PDF/Data Sheets/Micrium PDFs/UC_OS-III_RTOS.pdf#:~:text=Micrium’s μC/OS-III supports ARM7/9, Cortex-MX, Nios-II, PowerPC, Coldfire,,are available for download from the Micrium website.

## Sources

* Protocol Support for μC/OS-II from Fusion Embedded
* Micrium-uCOS-III-UsersManual 1st Edition
* uC/OS-III: The Real-Time Kernel for the Renesas RX62N

## External links

* Official website
* on GitHub
* Summary of Commonly Used uC/OS-II Functions and Data Structures
* NiosII GCC with MicroC/OS
* μC/OS-II Reference Manual
* How to Get a μC/OS-II Application Running

* v
* t
* e

Real-time operating systems (RTOS)

* Comparison of real-time operating systems

Open-source|

* BeRTOS
* ChibiOS/RT
* Contiki
* eCos
* ERIKA Enterprise
* FreeRTOS
* Fuchsia
* FunkOS
* Mynewt OS
* Nano-RK
* NuttX
* RIOT
* RTAI
* RTEMS
* RTLinux
* RT-Thread
* seL4
* TI-RTOS
* TRON
* Wombat OS
* Xenomai
* Zephyr

Proprietary|

* 4690 OS
* DioneOS
* embOS
* Integrity
* Junos OS
* LynxOS
* µC/OS-II
* MQX
* Nucleus RTOS
* OpenComRTOS
* OSE
* OS-9
* OS2000
* PikeOS
* QNX
* REAL/32
* REX OS
* ScreenOS
* ThreadX
* TPF
* VRTX
* VxWorks
* Windows Embedded Compact

Historic|

* 4680 OS
* Concurrent DOS
* DNIX
* DSOS
* EROS
* FlexOS
* MERT/UNIX-RT
* Multiuser DOS
* pSOS
* RMX
* RSX-11
* RT-11
* Sintran III
* Symbian
* THEOS
* UNOS

* Category

* v
* t
* e

Microkernels-nanokernels

Kernels|

* ADEOS
* EPOC
* EKA1
* EKA2
* Eumel
* Exec
* ExecSG
* EROS
* K42
* L3
* L4
* Little Kernel
* Mac OS nanokernel
* Mach
* GNU Mach
* MicroEmpix
* µ-velOSity
* nucleus
* NuKernel
* Off++
* Opus
* PowerUP
* Quark
* TI-RTOS kernel
* Vanguard
* WarpOS
* Zircon

Operating
systems|

* AmigaOS
* Amoeba
* AROS
* AspireOS
* Broadway
* Icaros Desktop
* ARX
* BeRTOS
* ChibiOS/RT
* ChorusOS
* Copland
* Cosmos
* EROS
* FreeRTOS
* Fuchsia
* Genode
* GNOSIS
* GNU Hurd
* HelenOS
* Hydra
* Integrity
* JX
* JavaOS
* KeyKOS
* Lites
* Classic Mac OS (PowerPC kernel)
* MachTen
* MacMach
* MeikOS
* MERT
* µC/OS
* Midori
* MINIX
* Minix-vmd
* MINIX 3
* MkLinux
* MorphOS
* MQX
* NLTSS
* Nucleus RTOS
* NuttX
* OS2000
* OSE
* Phantom OS
* PikeOS
* QNX
* RC 4000
* Redox
* REX OS
* RIOT
* SharpOS
* Singularity
* SPIN
* Spring
* Symbian
* Taligent OS
* ThreadX
* TI-RTOS
* Tinix
* UNICOS
* V
* Verve
* VRTX
* VSTa
* Wombat OS
* Workplace OS
* Zephyr

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Micro-Controller Operating Systems. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Software:Micro-Controller_Operating_Systems&oldid=3987014"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template