Embedded Systems/Atmel AVR/Operating systems and task managers

From Wikibooks, open books for an open world
Jump to: navigation, search
Nut/OS Nut/OS is an intentionally simple RTOS for the ATmega128, which provides a minimum of services to run Nut/Net, the TCP/IP stack. It's features include:
  • Non preemptive multithreading
  • Events
  • Periodic and one-shot timers
  • Dynamic heap memory allocation
  • Interrupt driven streaming I/O

Main features of the TCP/IP stack are:

  • Base protocols: ARP, IP, ICMP, UDP, TCP
  • User protocols: DHCP, DNS, HTTP
  • Socket API
  • Host, net and default routing
  • Interrupt driven Ethernet driver

According to website it require at least ATmega128.

Contiki Contiki is an open source, highly portable, multi-tasking operating system for networked memory-constrained networked embedded systems. A typical Contiki configuration is 2 kilobytes of RAM and 40 kilobytes of ROM.

Contiki contains two communication stacks: uIP and Rime. uIP is a small RFC-compliant TCP/IP stack that makes it possible for Contiki to communicate over the Internet. Rime is a lightweight communication stack designed for low-power radios that provides a wide range of communication primitives and protocols, such as multi-hop data collection, multi-hop unicast mesh routing, and reliable multi-hop network flooding.

Contiki is IPv6 Ready Phase 1 certified and therefor has the right to use the IPv6 Ready silver logo.

Contiki consists of an event-driven kernel on top of which application programs are dynamically loaded and unloaded at runtime. Contiki processes use light-weight protothreads that provide a linear, thread-like programming style on top of the event-driven kernel. Contiki also supports per-process optional preemptive multi-threading, interprocess communication using message passing through events, as well as an optional GUI subsystem with either direct graphic support for locally connected terminals or networked virtual display with VNC or over Telnet.

Contiki runs on a variety of platform ranging from embedded microcontrollers such as the MSP430 and the AVR to old homecomputers. Code footprint is on the order of kilobytes and memory usage can be configured to be as low as tens of bytes.

TinyOS TinyOS is an open-source operating system designed for wireless embedded sensor networks. It features a component-based architecture which enables rapid innovation and implementation while minimizing code size as required by the severe memory constraints inherent in sensor networks. TinyOS's component library includes network protocols, distributed services, sensor drivers, and data acquisition tools – all of which can be used as-is or be further refined for a custom application. TinyOS's event-driven execution model enables fine-grained power management yet allows the scheduling flexibility made necessary by the unpredictable nature of wireless communication and physical world interfaces.

TinyOS has been ported to over a dozen platforms and numerous sensor boards. A wide community uses it in simulation to develop and test various algorithms and protocols. New releases see over 10,000 downloads. Over 500 research groups and companies are using TinyOS on the Berkeley/Crossbow Motes. Numerous groups are actively contributing code to the sourceforge site and working together to establish standard, interoperable network services built from a base of direct experience and honed through competitive analysis in an open environment.

PicOS PicOS from Olsonet Communications is a small-footprint operating system for organising multiple activities of embedded reactive applications executed on a small CPU with limited resources. It provides co-operative multitasking (implementable within very small RAM) as well as simple orthogonal tools for inter-process communication.

PicOS can be downloaded and installed on the eCOG1 development kit using the Installation Utility below. Application Note AN009 provides full instructions on the installation process.

PicOS can also be found as a free download from Olsonet's web site and is distributed under the GPL license.

FreeRTOS FreeRTOS is a real-time operating system for embedded devices, being ported

to several microcontrollers.

FreeRTOS is designed to be small and simple. The kernel itself is comprised of only three or four C files. To make the code readable, easy to port, and maintainable, it is written mostly in C, but there are a few assembler functions included where needed (mostly in architecture specific scheduler routines). The download contains prepared configurations and demonstrations for every port and compiler, allowing rapid application design. The FreeRTOS.org site also contains RTOS tutorials, details of the RTOS design and performance comparison results for various microcontrollers.

OpenRTOS OpenRTOS™ is a commercially licensed version of FreeRTOS.org. The OpenRTOS license does not contain any references to the GPL.
AvrX AvrX is a Real-Time Multitasking Kernel.
XMK eXtreme Minimal Kernel is a preemptive multithreaded real-time operating system for microcontrollers. XMK's primary design goal is to be small, extremely small, without sacrificing performance or functionality.  XMK's minimal footprint makes it ideal for running on 8bit microcontrollers, while its feature content makes it a excellent choice for 16bit and 32bit microcontrollers.

XMK is 100% configurable, from a no frills thread scheduler to a full featured RTOS with TCP/IP networking.

According to website it works on: ATmega103, AT90s8515, ATmega128.

JacOS According to forum source can be obtained from author.

It works on: atmega103, atmega603, atmega8, atmega83, atmega85, atmega16, atmega161, atmega163, atmega32, atmega323, atmega64, atmega128.

ChibiOS/RT ChibiOS/RT is a compact and fast RTOS designed for embedded applications. It offers threads, mutexes, semaphores, messages, events, timers, flexible I/O with timeout capability.
SST This is an implementation of a lightweight scheduler so called "Super Simple Tasker" - SST. The idea is taken from the Robert Ward's article - "Practical Real-Time Techniques" http://www.quantum-leaps.com/resources/Ward03.pdf. The SST allows to significantly reduce needs for precious RAM and ROM and still allows to keep a real time characteristic of the scheduler (e.g. tasks prioritization and preemption).
uSmartX uSmartX is a non-preemptive, multitasking, priority based RTOS. It features mechanisms for inter-task communication and basic task and time control functions.
BeRTOS BeRTOS is a real time open source operating system supplied with drivers and libraries designed for the rapid development of embedded software.

Kernel features

  • Preemptive and cooperative round-robin scheduling
  • Heap, for dynamic allocation of processes' memory
  • Stack process monitor, useful to prevent stack overflows
  • Inter-process messaging system. (with very low overhead)
  • Binary semaphores
  • Signals

It supports Arduino Duemilanove.