Lazuli
1.0.0
Lazuli est un RTOS multitâche préemptif (système d'exploitation en temps réel / noyau), ciblant les microcontrôleurs AVR. Il permet de programmer et d'exécuter plusieurs tâches indépendantes dans un contexte en temps réel sur les microcontrôleurs AVR. Dans sa configuration de base, les lazuli RTOS ont une empreinte de mémoire faible (<4 kilobytes de ROM, <200 octets de RAM statique). Les RTO Lazuli peuvent être utilisés pour développer des applications embarquées ou des wares fermes qui ont de solides contraintes en temps réel ou exiger le multitâche, sur un matériel minimal.
Les MCA AVR sont largement utilisés dans les dispositifs et applications industriels intégrés, et sont également connus pour être utilisés sur les planches Arduino. Les applications écrites en plus des RTO Lazuli conviennent les systèmes industriels ainsi que les créations amateurs.
Lazuli RTOS est distribué dans son formulaire de code source, à construire et lié statiquement à votre propre exécutable final. Cela permet au noyau d'être configuré statiquement et de bénéficier des optimisations du compilateur.
Le projet est hébergé sur github à https://github.com/randruc/lazuli
Pour l'instant, le noyau Lazuli fournit les fonctionnalités suivantes:
SCHED_RR )printf()Le projet Lazuli a des objectifs très spécifiques qui le rendent unique. Ce sont:
Lazuli RTOS s'exécute actuellement sur l'ATMEGA328P MCU (qui est utilisé sur l'Arduino), mais il devrait être facilement portable sur d'autres plates-formes AVR.
Bien que les Lazuli aient tendance à atteindre un niveau élevé de qualité et de stabilité du code, il ne convient pas aux systèmes critiques de sécurité car il n'est pas certifié pour ces utilisations spécifiques. Pour plus d'informations sur les systèmes de sécurité-critique, veuillez lire https://en.wikipedia.org/wiki/Safety-critical_system
La documentation du projet peut être lue sur https://lazuli.readthedocs.io/en/latest/
La documentation de l'API peut être lue sur https://randruc.github.io/lazuli/doxygen/latest/
Deux outils différents sont utilisés pour documenter le projet:
sphinx pour générer une documentation utilisateur à partir de fichiers écrits en texte restructuré. Les sources sont dans le répertoire DOC /.doxygen pour générer une documentation API à partir des commentaires du code C. Des exemples de programmes qui utilisent les RTO lazuli peuvent être trouvés dans les examples de répertoires / programmes /.
Voici la LED classique clignotante. Le monde bonjour des systèmes intégrés. Il est fortement commenté pour servir d'introduction à l'API Lazuli.
#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 ne dépend de aucun autre code existant. Vous pouvez simplement écrire votre propre code, construire le système, le télécharger sur le MCU cible et il s'exécute!
Pour se développer avec les Lazuli, il est fortement recommandé d'utiliser l'image Docker Lazuli. Vous bénéficierez d'un environnement de développement complet, fourni avec tous les outils nécessaires.
Lazuli RTOS est livré avec un environnement de développement complet et conteneurisé fourni sous forme d'image Docker. Cette image comprend tous les outils nécessaires pour créer votre propre projet à l'aide de lazuli RTOS. Il comprend des compilateurs et des liens, des outils de construction, des services publics binaires, des pages d'homme, etc.
L'image officielle de Docker Lazuli peut être retirée de https://hub.docker.com/r/randruc/lazuli
En savoir plus sur la création de l'environnement de développement dans la documentation officielle: https://lazuli.readthedocs.io/en/latest/set_up_environment.html
Lazuli Development Environment Container Démarrage
Pages d'homme dans un conteneur d'environnement de développement lazuli
Le noyau Lazuli est entièrement configurable. Le système de construction repose sur Cmake. À l'aide de ccmake , la configuration peut également être effectuée de manière interactive dans la console.
En savoir plus dans la documentation officielle: https://lazuli.readthedocs.io/en/latest/developing_your_project.html
Configuration à l'aide de ccmake
Bâtiment à l'aide de cmake
Sur AVR MCUS, avrdude peut être utilisé pour télécharger le binaire final sur la machine cible. Les scripts de script / avr / upload.sh peuvent être utilisés pour cela. Il prend le fichier hexadécimal en tant que paramètre.
L'interaction avec la ligne série peut être effectuée à l'aide de screen GNU. Le script scripts / serial.sh peut être utilisé pour interagir avec la ligne de série USB.
L'onglet Issues (https://github.com/randruc/lazuli/issues) du projet doit être utilisé pour signaler le dépannage ou pour faire des suggestions.
Les contributions sont les bienvenues!
Le projet est hébergé sur GitHub (sur https://github.com/randruc/lazuli), et Github est utilisé pour gérer tout: requête, problèmes, etc., peu importe que vous souhaitiez corriger un bogue, mettre en œuvre ou suggérer de nouvelles fonctionnalités, ou corriger une erreur de frappe / orthographe: tout type de contribution est la bienvenue!
En savoir plus sur la façon de contribuer dans la documentation officielle: https://lazuli.readthedocs.io/en/latest/kernel/contributing.html
Vous pouvez également utiliser l'onglet Issues du projet pour poser des questions, suggérer des fonctionnalités sans codage ou tout ce que vous souhaitez!
Tout le projet est distribué dans le cadre de la licence publique générale GNU V3.0 uniquement. Une copie complète de cette licence est disponible dans les licences de fichiers / GPL-3.0-Only.txt.
