Lazuli
1.0.0
Lazuli ist ein präventives Multitasking-RTOs (Echtzeit-Betriebssystem/Kernel) mit AVR-Mikrocontrollern. Es ermöglicht es, mehrere unabhängige Aufgaben in einem Echtzeitkontext auf AVR-Mikrocontrollern zu programmieren und auszuführen. In seiner grundlegenden Konfiguration hat Lazuli RTOS einen geringen Speicher -Fußabdruck (<4 Kilobyte ROM, <200 Bytes statischer RAM). Lazuli-RTOs können verwendet werden, um eingebettete Anwendungen oder Unternehmenswares zu entwickeln, die starke Echtzeitbeschränkungen aufweisen oder Multitasking auf minimaler Hardware erfordern.
AVR MCUs werden häufig in eingebetteten, industriellen Geräten und Anwendungen verwendet und sind auch bekannt, dass sie auf Arduino -Boards verwendet werden. Bewerbungen über Lazuli RTOS -Anzug sind sowohl Industriesysteme als auch Hobbykreationen.
Lazuli RTOS wird in seinem Quellcodeformular verteilt, um erstellt und statisch mit Ihrer eigenen endgültigen ausführbaren Datei verknüpft zu werden. Auf diese Weise kann der Kernel statisch konfiguriert werden und von Compiler -Optimierungen profitieren.
Das Projekt wird auf Github unter https://github.com/randruc/lazuli gehostet
Der Lazuli -Kernel bietet vorerst die folgenden Funktionen:
SCHED_RR )printf() -implementierungDas Lazuli -Projekt hat sehr spezifische Ziele, die es einzigartig machen. Diese sind:
Lazuli RTOS läuft derzeit auf der ATMEGA328P MCU (die auf dem Arduino verwendet wird), sollte jedoch für andere AVR -Plattformen leicht tragbar sein.
Obwohl Lazuli dazu neigt, ein hohes Maß an Codequalität und -stabilität zu erreichen, entspricht es nicht für sicherheitskritische Systeme, da es nicht für diese spezifischen Verwendungen zertifiziert ist. Weitere Informationen zu den sicherheitskritischen Systemen finden Sie unter https://en.wikipedia.org/wiki/safety-critical_System
Die Dokumentation für das Projekt kann unter https://lazuli.readthedocs.io/en/latest/ gelesen werden
Die API -Dokumentation kann unter https://randruc.github.io/lazuli/doxygen/latest/ gelesen werden
Zwei verschiedene Tools werden verwendet, um das Projekt zu dokumentieren:
sphinx zum Generieren von Benutzerdokumentation aus in restrukturierten Dateien geschriebenen Dateien. Die Quellen befinden sich im DOC/ Verzeichnis.doxygen , um API -Dokumentation aus C -Code -Kommentaren zu generieren. Beispielprogramme, die die Lazuli-RTOs verwenden, finden Sie im Verzeichnis Beispielprogramme/.
Hier wird die klassische blinkende LED gezeigt. Die Hallo Welt der eingebetteten Systeme. Es wird stark kommentiert, um als Einführung in die Lazuli -API zu dienen.
#include <stdint.h>
#include <Lazuli/lazuli.h>
#include <Lazuli/sys/arch/AVR/registers.h>
/*
* This is the Blink task. It simply blinks the built-in LED on Arduino
* platforms.
* This task is scheduled in real-time. It is configured to blink with an exact
* period of 1 second.
*/
void
Blink ()
{
/* On the Arduino, this pin corresponds to the built-in LED */
const uint8_t ledPin = 0x20 ;
DDRB |= ledPin ; /* Set the pin to be an output pin */
PORTB &= ~ ledPin ; /* The initial state of the pin will be 0 */
/* Now this is the main loop of this task */
for (;;) {
/* Wait for the next real-time activation of the task */
Lz_Task_WaitActivation ();
PINB |= ledPin ; /* Toggle the pin */
}
}
void
main ( void )
{
/* Allocate a configuration object on the stack */
Lz_TaskConfiguration configuration ;
/* Initialize the configuration object with default values */
Lz_TaskConfiguration_Init ( & configuration );
/* Configure the Blink task to be cyclic real-time (RMS scheduling) */
configuration . schedulingPolicy = CYCLIC_RT ;
/* The Blink task has a period of 25 time slices. */
/* Our platform has a 16 MHz clock, and the system clock resolution */
/* frequency is configured to 50 Hz. This is an arbitrary value that */
/* can be configured by the user. */
/* With a system clock resolution frequency set to 50 Hz, the system */
/* clock period is then 1 / 50 = 0.02 second. */
/* So 0.02 * 25 = 0.5 second, which corresponds to the half period */
/* of our task. */
configuration . period = 25 ;
/* The Blink task has a completion of 10 time slices (arbitrary here */
/* because our task does almost nothing). */
configuration . completion = 10 ;
/* Register the Blink task to run with the parameters above */
Lz_RegisterTask ( Blink , & configuration );
/* Run the system */
Lz_Run ();
}Lazuli hat keine Abhängigkeit von einem anderen vorhandenen Code. Sie können einfach Ihren eigenen Code schreiben, das System erstellen, es in die Ziel -MCU hochladen und es läuft einfach!
Um sich mit Lazuli zu entwickeln, wird dringend empfohlen, das Lazuli -Docker -Bild zu verwenden. Sie profitieren von einer vollständigen Entwicklungsumgebung, die mit allen erforderlichen Instrumenten ausgestattet ist.
Lazuli RTOS verfügt über eine vollständige und containerisierte Entwicklungsumgebung, die als Docker -Image bereitgestellt wird. Dieses Bild enthält alle Tools, die erforderlich sind, um Ihr eigenes Projekt mit Lazuli -RTOs zu erstellen. Es enthält Compiler und Linker, Build -Tools, binäre Versorgungsunternehmen, Mannseiten usw.
Das offizielle Lazuli Docker -Bild kann von https://hub.docker.com/randruc/lazuli gezogen werden
Lesen Sie mehr, wie Sie die Entwicklungsumgebung in der offiziellen Dokumentation einrichten: https://lazuli.readthedocs.io/en/latest/set_up_environment.html
Lazuli -Entwicklungsumgebung Container Start
Mannseiten im Lazuli -Entwicklungsumfeldbehälter
Der Lazuli -Kernel ist vollständig konfigurierbar. Das Build -System basiert auf CMake. Mit Hilfe von ccmake kann die Konfiguration auch interaktiv in der Konsole erfolgen.
Lesen Sie mehr in der offiziellen Dokumentation: https://lazuli.readthedocs.io/en/latest/developing_your_project.html
Konfiguration mit CCMake
Gebäude mit CMake
Bei AVR MCUS kann avrdude verwendet werden, um die endgültige Binärdatei auf die Zielmaschine hochzuladen. Die Skriptskripte/avr/upload.sh können dafür verwendet werden. Es nimmt die HEX -Datei als Parameter.
Die Interaktion mit der Serienlinie kann mit Hilfe des GNU screen durchgeführt werden. Die Skriptskripte/serial.sh können verwendet werden, um mit der seriellen USB -Linie zu interagieren.
Die Registerkarte Issues (https://github.com/randruc/lazuli/issues) des Projekts muss verwendet werden, um die Fehlerbehebung zu melden oder Vorschläge zu machen.
Beiträge sind willkommen!
Das Projekt wird auf Github gehostet (unter https://github.com/randruc/lazuli), und Github wird verwendet, um alles zu verwalten: Anfrage, Probleme usw. Es spielt keine Rolle, ob Sie einen Fehler beheben, neue Funktionen implementieren oder vorschlagen oder einen Tippfehler/Spelling -Fehler beheben möchten: Jeder Beitrag ist ein Begrüßung!
Lesen Sie mehr, wie Sie in der offiziellen Dokumentation beitragen: https://lazuli.readthedocs.io/en/latest/kernel/contributing.html
Sie können auch die Registerkarte Issues des Projekts" verwenden, um Fragen zu stellen, Funktionen ohne Codierung oder alles, was Sie wünschen, vorzuschlagen!
Das gesamte Projekt wird nur im Rahmen der GNU General Public Lizenz v3.0 verteilt. Eine vollständige Kopie dieser Lizenz ist in der Dateilizenzen/GPL-3.0-TXT verfügbar.
