Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/flit/argon-rtos
Argon RTOS: tiny embedded C/C++ RTOS for Cortex-M
https://github.com/flit/argon-rtos
cortex-m embedded kernel rtos
Last synced: about 1 month ago
JSON representation
Argon RTOS: tiny embedded C/C++ RTOS for Cortex-M
- Host: GitHub
- URL: https://github.com/flit/argon-rtos
- Owner: flit
- License: bsd-3-clause
- Created: 2013-12-26T16:56:18.000Z (almost 11 years ago)
- Default Branch: master
- Last Pushed: 2021-12-18T20:14:25.000Z (almost 3 years ago)
- Last Synced: 2023-04-04T22:21:33.361Z (over 1 year ago)
- Topics: cortex-m, embedded, kernel, rtos
- Language: C
- Homepage:
- Size: 17.8 MB
- Stars: 58
- Watchers: 8
- Forks: 12
- Open Issues: 9
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
Awesome Lists containing this project
README
Argon RTOS
==========
Small embedded RTOS with clean C and C++ APIs for Arm Cortex-M-based microcontrollers.
*Version*: 1.3.0
*Status*: Actively under development. Mostly stable API. Well tested in several real applications.
### Overview
Argon is designed to be a very clean preemptive RTOS kernel with a C++ API. A plain C API upon which the C++ API is built is also available. It is primarily targeted at microcontrollers with Arm Cortex-M processors. A primary goal is for the source code to be highly readable, maintainable, and well commented.
The kernel objects provided by Argon are:
- Thread
- Semaphore
- Mutex
- Queue
- Channel
- Timer
- Run Loop
Argon takes advantage of Cortex-M features to provide a kernel that never disables IRQs (except for CM0+1).
Timers run on runloops, which lets you control the thread and priority of timers. Runloops enable very efficient use of threads, including waiting on multiple queues.
Mutexes are recursive and have priority inheritance.
A memory allocator is not provided, as every Standard C Library includes malloc.2
There are no limits on the number of kernel objects. You may create as many objects as you need during runtime via dynamic allocation using `new` or `malloc()`. However, dynamic memory is not required under any circumstance. All kernel objects can be allocated statically, which is often important for determining application memory requirements at link time.
### Documentation
The Argon documentation is [available online](https://flit.github.io/argon-rtos/doc/).
You can also generate it locally with Doxygen. The config file is doc/Doxyfile.
### Example
Here's a simple example of the C++ API.
~~~cpp
Ar::ThreadWithStack<2048> myThread("my", thread_fn, 0, 100, kArSuspendThread);
Ar::Semaphore theSem("s");
void thread_fn(void * param)
{
while (theSem.get() == kArSuccess)
{
// do something
}
}
void main()
{
myThread.resume();
}
~~~
And the same example using the plain C API:
~~~c
uint8_t stack[2048];
ar_thread_t myThread;
ar_semaphore_t theSem;
void thread_fn(void * param)
{
while (ar_semaphore_get(theSem, kArInfiniteTimeout) == kArSuccess)
{
// do something
}
}
void main()
{
ar_thread_create(&myThread, "my", thread_fn, 0, stack, sizeof(stack), 100, kArSuspendThread);
ar_semaphore_create(&theSem, "s", 1);
ar_thread_resume(&myThread);
}
~~~
### Requirements
Requires a Cortex-M based microcontroller.
- ARMv6-M
- ARMv7-M
Tested cores:
- Arm Cortex-M0+
- Arm Cortex-M4
- Arm Cortex-M4F
Supported toolchains:
- IAR EWARM
- Keil MDK (armcc)
- GNU Tools for Arm Embedded Processors (gcc)
Language requirements:
- C99
- C++98
### Portability
The Cortex-M porting layer only accesses standard Cortex-M resources (i.e., SysTick, NVIC, and SCB). It should work without modification on any Cortex-M-based MCU.
The kernel itself is fairly architecture-agnostic, and should be easily portable to other architectures. All architecture-specific code is isolated into a separate directory.
### Source code
The code for the Argon kernel is in the `src/` directory in the repository. Public headers are in the `include/` directory.
The argon-rtos repository is intended to be usable as a submodule in other git repositories.
The kernel code is written in C++, but mostly uses a C-like style to implement the C API directly. The emphasis is on as little overhead as possible for both C and C++ APIs.
### Contributions
Contributions are welcome! Please create a pull request in GitHub.
### Licensing
The Argon RTOS is open source software released with a BSD three-clause license. See the included LICENSE.txt file for details.
The repository also includes code with other copyrights and licenses. See the source file headers for licensing information of this code.
Copyright © 2007-2018 Immo Software.
Portions Copyright © 2014-2018 NXP
1 Cortex-M0+ cores are an exception since they don't have the required ldrex/strex instructions. Even so, IRQs are disabled for only a few cycles at a time.
2 Even though it may not be the smallest code, and doesn't support block allocation.