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:

CoreChip Manufacturer“C”-compilerSupported CPUsSupported memory models
ARM 7/9/11
Cortex-A5/A8/A9		VariousIAR SystemsARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale, Cortex-A5, Cortex-A8, Cortex-A9All
ARM 7/9/11
Cortex-A5/A8/A9		VariousAtollic TrueStudioARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale, Cortex-A5, Cortex-A8, Cortex-A9All
ARM 7/9/11
Cortex-A5/A8/A9		VariousemIDEARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale, Cortex-A5, Cortex-A8, Cortex-A9All
ARM 7/9/11
Cortex-A5/A8/A9		VariousGNUARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale, Cortex-A5, Cortex-A8, Cortex-A9All
ARM 7/9/11
Cortex-A5/A8/A9		VariousRowleyARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScale, Cortex-A5, Cortex-A8, Cortex-A9All
ARM 7/9/11VariousKEIL MDKARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScaleAll
ARM 7/9/11VariousARM ADS 1.2 toolkitARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScaleAll
ARM 7/9/11VariousARM RVDS 3.0ARM7TDMI, ARM710T, ARM720T, ARM7EJ-S, ARM9TDMI, ARM920T, ARM922T, ARM940T, ARM926EJ-S, XScaleAll
ARM
Cortex-A5/A8/A9		VariousCodeSourceryCortex-A5, Cortex-A8, Cortex-A9All
ARM Cortex MATMELAtmel StudioCortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7All
ARM Cortex MVariousAtollic TrueStudioCortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7All
ARM Cortex MVariousCodeSourceryCortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7All
ARM Cortex MCypressCypress PSoC5Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7All
ARM Cortex MVariousARM DS-5Cortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7All
ARM Cortex MVariousemIDECortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7All
ARM Cortex MVariousIAR SystemsCortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7All
ARM Cortex MVariousKEIL MDKCortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7All
ARM Cortex MVariousRowleyCortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7All
ARM Cortex MVariousTICCCortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7All
ARM Cortex MVariousGNUCortex-M0, Cortex-M1, Cortex-M3, Cortex-M4, Cortex-M4F, Cortex-M7All
AVRATMELIAR SystemsATMEGA103, ATMEGA64, ATMEGA128, ATMEGA2561Small data, small and large code
AVR32 UCATMELAVR32 Studio / GNUAVR32UC3A, AVR32UC3B, AVR32UC3A3All
AVR32 UCATMELIAR SystemsAVR32UC3A, AVR32UC3B, AVR32UC3A3 
AVR32 APATMELAVR32 Studio / GNUAT32AP7000All
C16xInfineonKEILC166, XC166All except TINY
Coldfire V1FreescaleMetrowerks CodeWarriorV1 CoreAll (Near, Far)
ColdfireFreescaleMetrowerks CodeWarriorV2, V3, V4 coreAll (Near, Far)
Coldfire V1/V2/V3FreescaleIAR SystemsV1, V2, V3, V4 coreAll (Near, Far)
CR16CNational SemiconductorIARCR16CMedium / Large / Indexed / Non indexed
F2MC-16LX,
F2MC-16FX		SpansionSpansionF2MC-16LX, F2MC-16FXAll (Small, Medium, Compact, Large)
FR30 / FR50 / FR70SpansionSpansionFR30, FR50, FR70All
H8 / H8SRENESASIAR SystemsH8, H8SAll (Small, Large, Huge)
H8 / H8S / H8SXRENESASHEWH8, H8S, H8SXAll
HCS12FreescaleCodeWarriorHCS12, HCS12XSmall, Banked
M16C/R8CRENESASIAR Systems, compiler for M16CM16C62, M16C62P, R8C1B, …All (Near, Far, Huge)
M16C6XRENESASHEWM16C62, M16C62PAll
M16C/R8CRENESASTaskingM16C62, M16C62P, R8C1B, …All (Small, Medium, Large)
M32C & M16C80RENESASIAR SystemsM32C, MC80All (Near, Far, Huge)
M32C & M16C80RENESASRenesas NC308 ver. 540 and HEW 4M32C, MC80All (Near, Far)
MSP430 & MSP430xTexas InstrumentsIAR SystemsMSP430Fxxx, MSP430XAll, except medium data model for MSP430x
MSP430Texas InstrumentsRowleyMSP430FxxxAll
MSP430 & MSP430xTexas InstrumentsTI Code ComposerMSP430Fxxx, MSP430XAll
NIOS 2ALTERAGNUNIOS 2All
PIC18MicrochipMicrochipPIC18F87xxAll
PIC24F/PIC24H,
PIC30F/dsPIC33F		MicrochipMicrochipPIC24F, PIC24H, PIC30, dsPIC33All
PIC32MicrochipMicrochipPIC32MX360F, PIC32MX795F, …All
PowerPCFreescaleCodeWarriorMPC5645SAll
R32CRENESASHEWR32CAll
R32CRENESASIAR Systems, compiler for R32CR32CAll
R8CRENESASHEWR8C23, R8C1B, …All
RL78RENESASIARRL78/G13, …All
RXRENESASCCRX (Renesas)RX111, RX210, RX610, RX62N, RX630, RX63NAll
RXRENESASKPIT GNURX111, RX210, RX610, RX62N, RX630, RX63NAll
RXRENESASIARRX111, RX210, RX610, RX62N, RX630, RX63NAll
SH2RENESASHEWSH27086All
SH2ARENESASIARSH2A7203, SH7216, SH2A7264, SH2A7286, SH2A7670All
SH2ARENESASHEWSH2A7203, SH7216, SH2A7264, SH2A7286, SH2A7670All
SH2ARENESASGNUSH2A7203, SH7216, SH2A7264, SH2A7286, SH2A7670All
SO8FreescaleCodeWarriorSO8MP, SO8QE, SO8GB, …All
ST7ST MicroelectronicsCOSMIC CXST7ST7long stack
STM8ST MicroelectronicsIARSTM8-A, STM8-SAll code models, medium data model
TLCS900TOSHIBATOSHIBA CC900CC900All
V850 / V850E / V850ESNECIAR SystemsV850, V850E, V850ESAll
V850 / V850E / V850ESNECGREEN HILLSV850, V850E, V850ESAll
V850NECNECV850, V850E, V850ESAll
Z180ZILOGIAR SystemsZ180Small, Banked
64180HITACHIIAR SystemsHD64180Small, Banked
78K0/K0S/K0RNECIAR Systems78K0, K0S, K0RSmall, near, far
78K4NECIAR Systems78K4Large
8051Silicon LabsIAR Systems8051Large

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