Segger embOS – Compact & affordable RTOS for Microcontrollers

sightsys > Real Time Operating Systems > Segger embOS – Compact & affordable RTOS for Microcontrollers

For more information:

Ohad Beit-On

ohad@sightsys.co.il

054-2584032

embOS is Segger’s Real-Time Operating Systems (RTOS)

embOS is a priority-controlled real time operating system, designed to be used as foundation for the development of embedded real-time applications. It is a zero interrupt latency*, high-performance RTOS that has been optimized for minimum memory consumption in both RAM and ROM, as well as high speed and versatility. Throughout the development process of embOS, the limited resources of microcontrollers have always been kept in mind. The internal structure of embOS has been optimized in a variety of applications with different customers, to fit the needs of different industries. embOS is fully source-compatible on different platforms (8/16/32 bits), making it easy to port applications to different CPUs. Its’ highly modular structure ensures that only those functions that are needed are linked, keeping the ROM size very small. Tasks can easily be created and safely communicate with each other using a complete palette of communication mechanisms such as semaphores, mailboxes, and events. Interrupt Service Routines (ISRs) can also take advantage of these communication mechanisms. 
* High priority interrupts are never disabled by embOS. 
 
With embOS  you can build your embedded systems with additional SW components and options:
 
 
 

embOS Features

  • Preemptive scheduling: Guarantees that of all tasks in READY state, the one with the highest priority executes, except for situations where priority inversion applies.
  • Round-robin scheduling for tasks with identical priorities.
  • Preemptions can be disabled for entire tasks or for sections of a program.
  • Thread local storage support.
  • Thread safe system library support.
  • No configuration needed
  • Unlimited priorities: Every task can have an individual priority => the response of tasks can be precisely defined according to the requirements of the application.
  • Unlimited number of tasks (limited only by available memory).
  • Unlimited number of event flags.
  • Unlimited number of semaphores (limited only by available memory).
  • Unlimited number of message queues (limited only by available memory).
  • Unlimited number of mailboxes (limited only by available memory).
  • Size and number of messages can be freely defined.
  • Unlimited number of software timers (limited only by available memory).
  • Mutexes with full priority inheritance.
  • Time resolution tick can be freely selected (default is 1ms).
  • High resolution time measurement (more accurate than tick).
  • Power management: Unused CPU time can automatically be spent in halt mode, minimizing power consumption.
  • Full interrupt support: Most API functions can be used from within the Interrupt Service Routines (ISRs).
  • Zero interrupt latency time.
  • Nested interrupts are permitted.
  • Start application and projects (BSPs) for an easy start.
  • Debug build performs runtime checks, simplifying development.
  • High precision per task profiling.
  • Real time kernel viewer (embOSView) included.
  • Very fast and efficient, yet small code.
  • Minimum RAM usage.
  • Core written in assembly language.
  • All API functions can be called from C /C++/assembly.
  • Initialization of microcontroller hardware as sources.
  • BSP for any unsupported hardware with the same CPU can easily be written by user.

Profiling using embOSView

embOSView is a very helpful tool for analysis of the running target application in real time. It displays the state of a running application using embOS. All communication is done from within the communication interrupt routines. This means that the communication is none intrusive if embOSView is not connected and minimum intrusive while embOSView is connected. In the profiling build, embOS collects precise timing information for every task, which enables embOSView to show the CPU load.

embOS Plug-in for IAR Embedded Workbench

The embOS plug-in for the IAR Embedded Workbench™ provides embOS awareness during debugging sessions. The state of several embOS objects such as the tasks, resource semaphores, mailboxes, or timers can be inspected.More info…

Typical applications for embOS

embOS can be used in any application from battery-powered, single chip products to systems demanding ultra-fast response, flexibility and multiple tasks. Typical fields are: Industrial equipment Test and Measurement equipment Telecommunication Medical equipment Consumer electronics…

Technical info

  • kernel size (ROM) 1100 – 1600 byte*
  • kernel RAM usage 18 – 25 byte *
  • kernel CPU usage at 1 ms Interrupts with 10MHz M16C : less than .3%
  • RAM usage mailbox 9 – 15 byte *
  • RAM usage binary and counting semaphore 3 byte
  • RAM usage resource semaphore 4 – 5 byte *
  • RAM usage timer 9 – 11 byte *
  • RAM usage event 0
  • Basic time unit (One Tick) Default 1 ms, can be configured, Min. 100 µs (M16C@10MHz) *
  • task activation time independent of no. of tasks(e.g. typ. 12 us M16C@10MHz)
  • zero interrupt latency
  • No. of tasks : Unlimited (by available RAM only)
  • No. of mailboxes : Unlimited (by available RAM only)
  • No. of semaphores : Unlimited (by available RAM only)
  • No. of s/w timers : Unlimited (by available RAM only)
  • Max. no. of priorities : 255
  • Max. no. of tasks with identical priorities (Round robin scheduling) Unlimited

* Depends on CPU, compiler and library model used

Libraries and source code

embOS is available as library or source code; the source code version includes libraries and the source code of the libraries. Both versions come with ready to go start projects, BSPs and embOSView. Different builds of libraries are also included: Release/stack check build, typically used in the release build of the application program; Debug/profiling build typically used in the development phase. The libraries offer the full functionality of embOS including all supported memory models of the compiler, the debug libraries and the source code for idle task and hardware initialization. However, the libraries do not allow source-level debugging of the library routines and the kernel. The full source version provides the ultimate options: embOS can be recompiled for different data sizes; different compile options give full control of the generated code, making it possible to optimize the system for versatility or minimum memory requirements. The entire system can be debugged and modified.

 

embOS Ports

All processors can be supported.

The kernel is written in “C” and assembly language. It is very efficient and can be ported to any processor for which an ANSI compliant “C”-compiler exists. These are basically all 8, 16 and 32-bit processors. However, one certain restriction applies: There is very little sense in having a real-time operating system for a processor that has a stack-area which is too limited to hold multiple stacks, because in this case the stack would have to be copied every time a task is activated or deactivated thereby limiting the real-time capabilities of the system. This is only the case for very few older, low-end 8-bit processors. We are working on supporting the entire range of 8- and 16- bit as well as certain 32-bit Microcontrollers. If you are interested in a particular processor, please do not hesitate to contact us.

embOS since version 3.06 includes API call trace even in the free full functional trial version.

For various processors the current embOS version is available as full functional trial version and can be downloaded here. All trial versions contain a complete ready to go start project, the users manual and embOSView tool which can also be downloaded separately from our download page.
All new versions of embOS support API- and user-function call trace that can be displayed via embOSView.

Check it out and get your first multi tasking application running within five minutes!

Of course there are some limitations for the trial version: The maximum number of tasks is limited to 3. You are not allowed to use this version in a product. Customer support is not included.

An embOS trial version for each listed processor can be downloaded here.

 The following processors and compiler are currently supported by embOS:

Core Chip Manufacturer “C”-compiler Supported CPUs Supported memory models
ARM 7/9/11
Cortex-A5/A8/A9		 Various IAR Systems ARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale, Cortex-A5, Cortex-A8, Cortex-A9 All
ARM 7/9/11
Cortex-A5/A8/A9		 Various Atollic TrueStudio ARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale, Cortex-A5, Cortex-A8, Cortex-A9 All
ARM 7/9/11
Cortex-A5/A8/A9		 Various emIDE ARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale, Cortex-A5, Cortex-A8, Cortex-A9 All
ARM 7/9/11
Cortex-A5/A8/A9		 Various GNU ARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale, Cortex-A5, Cortex-A8, Cortex-A9 All
ARM 7/9/11
Cortex-A5/A8/A9		 Various Rowley ARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale, Cortex-A5, Cortex-A8, Cortex-A9 All
ARM 7/9/11 Various KEIL MDK ARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale All
ARM 7/9/11 Various ARM ADS 1.2 toolkit ARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale All
ARM 7/9/11 Various ARM RVDS 3.0 ARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale All
ARM
Cortex-A5/A8/A9		 Various CodeSourcery Cortex-A5, Cortex-A8, Cortex-A9 All
ARM Cortex M ATMEL Atmel Studio Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 All
ARM Cortex M Various Atollic TrueStudio Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 All
ARM Cortex M Various CodeSourcery Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 All
ARM Cortex M Cypress Cypress PSoC5 Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 All
ARM Cortex M Various ARM DS-5 Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 All
ARM Cortex M Various emIDE Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 All
ARM Cortex M Various IAR Systems Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 All
ARM Cortex M Various KEIL MDK Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 All
ARM Cortex M Various Rowley Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 All
ARM Cortex M Various TICC Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 All
ARM Cortex M Various GNU Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7 All
AVR ATMEL IAR Systems ATMEGA103, ATMEGA64, ATMEGA128, ATMEGA2561 Small data, small and large code
AVR32 UC ATMEL AVR32 Studio / GNU AVR32UC3A, AVR32UC3B, AVR32UC3A3 All
AVR32 UC ATMEL IAR Systems AVR32UC3A, AVR32UC3B, AVR32UC3A3  
AVR32 AP ATMEL AVR32 Studio / GNU AT32AP7000 All
C16x Infineon KEIL C166, XC166 All except TINY
Coldfire V1 Freescale Metrowerks CodeWarrior V1 Core All (Near, Far)
Coldfire Freescale Metrowerks CodeWarrior V2, V3, V4 core All (Near, Far)
Coldfire V1/V2/V3 Freescale IAR Systems V1, V2, V3, V4 core All (Near, Far)
CR16C National Semiconductor IAR CR16C Medium / Large / Indexed / Non indexed
F2MC-16LX,
F2MC-16FX		 Spansion Spansion F2MC-16LX, F2MC-16FX All (Small, Medium, Compact, Large)
FR30 / FR50 / FR70 Spansion Spansion FR30, FR50, FR70 All
H8 / H8S RENESAS IAR Systems H8, H8S All (Small, Large, Huge)
H8 / H8S / H8SX RENESAS HEW H8, H8S, H8SX All
HCS12 Freescale CodeWarrior HCS12, HCS12X Small, Banked
M16C/R8C RENESAS IAR Systems, compiler for M16C M16C62, M16C62P, R8C1B, … All (Near, Far, Huge)
M16C6X RENESAS HEW M16C62, M16C62P All
M16C/R8C RENESAS Tasking M16C62, M16C62P, R8C1B, … All (Small, Medium, Large)
M32C & M16C80 RENESAS IAR Systems M32C, MC80 All (Near, Far, Huge)
M32C & M16C80 RENESAS Renesas NC308 ver. 540 and HEW 4 M32C, MC80 All (Near, Far)
MSP430 & MSP430x Texas Instruments IAR Systems MSP430Fxxx, MSP430X All, except medium data model for MSP430x
MSP430 Texas Instruments Rowley MSP430Fxxx All
MSP430 & MSP430x Texas Instruments TI Code Composer MSP430Fxxx, MSP430X All
NIOS 2 ALTERA GNU NIOS 2 All
PIC18 Microchip Microchip PIC18F87xx All
PIC24F/PIC24H,
PIC30F/dsPIC33F		 Microchip Microchip PIC24F, PIC24H, PIC30, dsPIC33 All
PIC32 Microchip Microchip PIC32MX360F, PIC32MX795F, … All
PowerPC Freescale CodeWarrior MPC5645S All
R32C RENESAS HEW R32C All
R32C RENESAS IAR Systems, compiler for R32C R32C All
R8C RENESAS HEW R8C23, R8C1B, … All
RL78 RENESAS IAR RL78/G13, … All
RX RENESAS CCRX (Renesas) RX111, RX210, RX610, RX62N, RX630, RX63N All
RX RENESAS KPIT GNU RX111, RX210, RX610, RX62N, RX630, RX63N All
RX RENESAS IAR RX111, RX210, RX610, RX62N, RX630, RX63N All
SH2 RENESAS HEW SH27086 All
SH2A RENESAS IAR SH2A7203, SH7216, SH2A7264, SH2A7286, SH2A7670 All
SH2A RENESAS HEW SH2A7203, SH7216, SH2A7264, SH2A7286, SH2A7670 All
SH2A RENESAS GNU SH2A7203, SH7216, SH2A7264, SH2A7286, SH2A7670 All
SO8 Freescale CodeWarrior SO8MP, SO8QE, SO8GB, … All
ST7 ST Microelectronics COSMIC CXST7 ST7 long stack
STM8 ST Microelectronics IAR STM8-A, STM8-S All code models, medium data model
TLCS900 TOSHIBA TOSHIBA CC900 CC900 All
V850 / V850E / V850ES NEC IAR Systems V850, V850E, V850ES All
V850 / V850E / V850ES NEC GREEN HILLS V850, V850E, V850ES All
V850 NEC NEC V850, V850E, V850ES All
Z180 ZILOG IAR Systems Z180 Small, Banked
64180 HITACHI IAR Systems HD64180 Small, Banked
78K0/K0S/K0R NEC IAR Systems 78K0, K0S, K0R Small, near, far
78K4 NEC IAR Systems 78K4 Large
8051 Silicon Labs IAR Systems 8051 Large

How do we port the system to an other target and test it:

We need a documentation of the CPU/MPU and an overview on all members of that series that shall be supported, an ANSI-compliant “C”-compiler and – preferably – an emulator. The following steps are taken and – if necessary – repeated:

  1. Making sure the documentation of the CPU/MPU is complete
  2. Start of a new project for this processor
  3. Design of a processor board to host the CPU/MPU and interface our test and demonstration hardware
  4. Design of the processor dependent header file
  5. Design of the processor dependent asm file
  6. Writing batch files to automatically build and generate all libraries based on the proven “C”-code
  7. Manual test of the RTOS step by step, debugging
  8. Automated test of the RTOS with a software only
  9. Automated test of the RTOS in the demonstration hardware with complete analysis of result
  10. Writing of documentation
  11. Verification of documentation

Since the system is based on a proven “C”-code, the system is reliable when it has undergone the final testing. This final testing is designed to capture all problems that can possibly occur when porting the system to a new target !

We are porting our OS to more and more targets.

If you are interested in a particular target, please let us know !

Compilers for C/C++Real Time Operating SystemsDebuggers & JTAG EmulatorsEmbedded Software Testing solutionsEvaluation Boards & Starter KitsMiddleware & SW componentsHW Testing solutions – Boundary-Scan (JTAG) & FunctionalProtocol and Bus Analyzers & StimulatorsHome of CANopen, EtherCAT, PowerLink, ProfiNet– SW Protocols, devices & SolutionsIn-Circuit/Parallel Engineering & Production Device Programmers (Flash/EPROMs/CPLDs…)Video & Audio SW CODECs components

For more information: Ohad Beit-On ohad@sightsys.co.il 054-2584032