Lazuli
1.0.0
O Lazuli é um RTOS multitarefa preventivo (sistema operacional/kernel em tempo real), visando microcontroladores AVR. Ele permite programar e executar várias tarefas independentes em um contexto em tempo real nos microcontroladores AVR. Em sua configuração básica, o Lazuli RTOs possui uma pegada de baixa memória (<4 kilobytes de ROM, <200 bytes da RAM estática). Os Lazuli RTOs podem ser usados para desenvolver aplicativos ou empresas firmes incorporadas que possuem fortes restrições em tempo real ou exigem multitarefa, em hardware mínimo.
O AVR MCUS é amplamente utilizado em dispositivos e aplicações industriais incorporados e também são conhecidos por serem usados nas placas Arduino. As aplicações escritas no topo da Lazuli RTOs se adequam aos sistemas industriais, bem como às criações de entusiastas.
O Lazuli RTOS é distribuído em seu formulário de código -fonte, a ser construído e estaticamente vinculado ao seu próprio executável final. Isso permite que o kernel seja configurado estaticamente e se beneficie das otimizações do compilador.
O projeto está hospedado no Github em https://github.com/randruc/lazuli
Por enquanto, o kernel Lazuli fornece as seguintes funcionalidades:
SCHED_RR )printf()O projeto Lazuli tem metas muito específicas que o tornam único. Estes são:
Atualmente, o Lazuli RTOs é executado no ATMEGA328P MCU (usado no Arduino), mas deve ser facilmente portátil para outras plataformas AVR.
Embora a Lazuli tenda a atingir um alto nível de qualidade e estabilidade do código, ele não combina com os sistemas críticos de segurança, pois não é certificado para esses usos específicos. Para mais informações sobre o que são sistemas críticos de segurança, leia https://en.wikipedia.org/wiki/safety-critical_system
A documentação do projeto pode ser lida em https://lazuli.readthedocs.io/en/latest/
A documentação da API pode ser lida em https://randruc.github.io/lazuli/doxygen/latest/
Duas ferramentas diferentes são usadas para documentar o projeto:
sphinx para gerar documentação do usuário a partir de arquivos gravados no reestruturado Text. As fontes estão no Doc/ Diretório.doxygen para gerar documentação da API a partir de comentários do código C. Exemplo de programas que usam os Lazuli RTOs podem ser encontrados nos programas de exemplo de diretório/.
Aqui é mostrado o LED clássico piscando. O Hello World of Incordded Systems. É fortemente comentado para servir como uma introdução à 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 não depende de nenhum outro código existente. Você pode simplesmente escrever seu próprio código, construir o sistema, carregá -lo para o MCU de destino e ele é executado!
Para desenvolver com Lazuli, é altamente recomendável usar a imagem do Docker Lazuli. Você se beneficiará de um ambiente de desenvolvimento completo, fornecido com todas as ferramentas necessárias.
O Lazuli RTOS vem com um ambiente de desenvolvimento completo e contêiner, fornecido como uma imagem do Docker. Esta imagem inclui todas as ferramentas necessárias para criar seu próprio projeto usando o Lazuli RTOs. Inclui compiladores e ligantes, ferramentas de construção, serviços públicos binários, páginas de homem, etc.
A imagem oficial do Lazuli Docker pode ser retirada de https://hub.docker.com/r/randruc/lazuli
Leia mais sobre como configurar o ambiente de desenvolvimento na documentação oficial: https://lazuli.readthedocs.io/en/latest/set_up_environment.html
Container de ambiente de desenvolvimento de Lazuli Iniciando
Páginas de homem em contêiner de ambiente de desenvolvimento lazuli
O kernel lazuli é totalmente configurável. O sistema de construção depende do cmake. Com a ajuda do ccmake , a configuração também pode ser feita interativamente no console.
Leia mais na documentação oficial: https://lazuli.readthedocs.io/en/latest/developing_your_project.html
Configuração usando ccmake
Construção usando cmake
No AVR MCUS, avrdude pode ser usado para fazer upload do binário final para a máquina de destino. Os scripts scripts/avr/upload.sh podem ser usados para isso. Ele toma o arquivo hexadecimal como um parâmetro.
A interação com a linha serial pode ser feita com a ajuda da screen GNU. Os scripts scripts/serial.sh podem ser usados para interagir com a linha serial USB.
A guia Issues (https://github.com/randruc/lazuli/issues) do projeto deve ser usada para relatar a solução de problemas ou fazer sugestões.
As contribuições são bem -vindas!
O projeto está hospedado no Github (em https://github.com/randruc/lazuli), e o Github é usado para gerenciar tudo: retire a solicitação, problemas etc. Não importa se você deseja corrigir um bug, implementar ou sugerir novos recursos ou corrigir um erro de digitação/ortografia: qualquer tipo de contribuição é bem -vindo!
Leia mais sobre como contribuir na documentação oficial: https://lazuli.readthedocs.io/en/latest/kernel/contributing.html
Você também pode usar a guia Issues do projeto para fazer perguntas, sugerir recursos sem codificação ou qualquer coisa que desejar!
Todo o projeto é distribuído apenas sob a licença pública geral da GNU v3.0. Uma cópia completa desta licença está disponível nas licenças de arquivo/GPL-3.0-ly.txt.
