 |
Life with dooroos |
|
|
|
|
|
dooroos.embedded > KERNEL |
|
| |
 |
KERNEL | |
| |
 |
Profile |
 |
The nano-kernel of dooroos.embedded is the most important part,
responsible for very small and powerful features and the core of the kernel,
is especially connected and works directly with the hardware (HAL layer) and
is connected directly.
It connects the kernel to the kernel, and passes the hardware interrupts,
such as the trap to the driver or kernel.
In addition, It provides the basic functionality to the various kernel server running on
the top of the features of the nano-kernel.
|
|
The other servers uses the kenrel API and library provided by nano-kernel and
will operate on the nano-kernel. dooroos.embedded will be in charge of
the important kernel features.
The supported features of this servers is needed in most embedded system,
and connects the above kernel servers to the nano-kernel services,
and implements the library's functions exported from nano-kernel completely.
In addition, a complete implementation of multi-threading has the ability to do only with this servers.
Of course, all the modules are the server in the form of nano-kernel, is
operated on the message-based communications of nano-kernel.
The this servers is divided into three servers, time server,
synchronization/communication server and device server to implement the functions.
|
 |
 |
|
Multi-thread kernel |
|
dooroos.embedded supports multi-thread.
|
 |
Unlimited muilti-thread support. |
|
Fast context switch between threads |
|
Configuration for real-time processing |
|
Real-time scheduling |
|
dooroos.embedded provides the perfect hard-real-time.
|
|
Support the fixed priority-based pre-emptive scheduling |
|
Support the round-robin scheduling in the same priority |
|
Support the wide priority range(0-255) |
|
Interrupt structure for real-time processing |
|
For the minimum delay, dooroos.embedded provides the best of the interrupt structure.
|
|
Convert hardware interrupt to the virtual interrupt. |
|
Support the dual strucure for interrupt minimum delay (interrupt low latency) |
|
Support the interrupt through the thread. |
|
Support the control of the interrupt priority through driver thread |
|
Message management |
|
dooroos.embedded provides capabilities for communicating a message bus
to the variety servers.
|
|
Support the quick message forwarding function |
|
Support passing the interrupt through the message-passing |
|
Support the port concept for sending and receiving messages |
|
Support channel concepts for message sending and receiving server. |
|
Modularization of the kernel features through the message bus |
|
Provides synchronization between threads |
|
dooroos.embedded provides the synchronization of threads.
|
|
Support the critical-section function |
|
Various API support |
|
dooroos.embedded provides the API for real-time function.
|
|
API support through system call |
|
Real-time API support through the library call |
|
Support the various library for kernel-servers. |
|
Time Server |
|
Time Server is responsible for the time and time synchronization.
Time Server implements the management for the time, Time-Out, Watch-Dog timer and the Thread's quantum management.
This server is run on the tick timer interrupt or the request of other modules.
|
|
Functions for time of operating system through the tick timer. |
|
Functions for API for time. |
|
Functions for timer support of thread. |
|
Synchronization Server |
|
The synchronization and communication between the dooroos.embedded threads is
provided in synchronization server.
Synchronization server supports the tools; semaphore, mutex, Event mechanism.
And critical-section features is not serviced directly from the server,
but it is serviced by system call of nano-kernel.
When you use this synchronization features, there is a significant additional burden (overhead) in real-time applications.
So, the proper use of this features can lead to prevent the burden.
On writing applications using this resources available here,
all the problems caused to the user should be prevented by the user.
For example, threads waiting for the event resources that
is given by other threads will continue running after the event receving.
If that event is not given, these thread does not perform forever.
Also, when multiple threads are running at the same time,
deadlock may occur.
In conclusion, the user using the services provided by the server
will need considerable attention.
|
|
Semaphore |
|
Mutex |
|
Event |
|
Conditional Variables |
|
Message Queue |
|
CriticalSection : Nano-kernel function |
|
Device (Driver) Server |
|
Device server of the dooroos.embedded provides the attachment / detachment of the device driver.
The device driver can be attached or detached to the dooroos.embedded freely without re-boot.
The device server manages the access handle. All other parts can acquire the access handle from the device server.
All device driver should be registered to the device driver to be accessed.
|
|
Device Driver attach/detach function. |
|
Access handle management to device driver. |
|
|
|
is
