Sistemas Operacionais em

Tempo Real – ScmRTOS

Visão Geral

Kaio Giovanni Pereira dos Santos – 13/0011886

1 Introdução

2
 ScmRTOS

“Single-Chip Microcontroller Real-Time Operating System”

◉ Disponibilidade de microcontroladores com apenas um chip capazes de executar sistemas

operacionais em tempo real.

◉ Microchips capazes de rodar execuções de controles de eventos com prioridade e

preempção sem perder a habilidade de alcançar os objetivos dos aplicativos.

◉ Falta de sistemas operacionais que pudessem trabalhar em 512 bytes na época do começo
de seu desenvolvimento.

3
 Histórico do ScmRTOS

Versão 1 Versão 2 Versão 3 Versão 4

Kernel Preemptivo Modelos de Abertura ao Integridade e
simples para Compiladores C++ público, movido estabilidade
MSP430F149 da embutidos. para o para o uso
Texas usando o Comunicação sourceforge.net. prático através
compilador EC++ entre processos Customização do de correções de
da IAR Systems. usando modelos usuário em timers compatibilidade
Redesign com a C++. Adição do e mudanças de
adição do AVR BlackFin. contexto.

4
 Outras Arquiteturas Informações Disponíveis
Disponíveis

◉ ARM Site oficial

◉ Cortex-M3
◉ Blackfin http://scmrtos.sourceforge.net
◉ AVR Contendo todas os User’s
◉ STM8 Guides das versões anteriores

5
 Recursos do
2
ScmRTOS

6
 Escalonador Debug
Tem um método pratico de
Há duas variantes do definir o consumo da pilha
escalonador encontrado no rodando o programa. No
ScmRTOS: ScmRTOS, essa
◉ Um para o sistema de caracteristica, assim como
fluxo de controle direto as outras ferramentas de
do programa; debug, é ativada na
◉ Outro para o sistema configuração do OS,
de fluxo de controle de configurando a macro
interrupção de scmRTOS_DEBUG_ENABLE
software. para 1.
Timer
System Timer usado para
temporizar as características dos
processos e para temporizar o
próprio sistema através de seus
ticks.
Normalmente, implementado na
base de um dos timers do próprio
Hardware alvo.
Como o Overhead do ScmRTOS é
pequeno, o sistema pode rodar em
uma taxa de 1 a 10 milisegundos.
7
 Comunicação entre
Tarefas
Há uma classe feita para a comunicação entre tarefas do sistema operacional chamada
TService, que implementa a funcionalidade comum de um ICS (Interprocess Comunication
System). Dentro da TService estão disponiveis os seguintes serviços:
◉ TEventFlag: Classe com o objetivo de realizar a sincronização entre processos enviando
um semáforo binário (event flag);
◉ TMutex: Semáforo Binário usado para exclusão mutua quando há acesso de diferentes
processos ao mesmo recursos ao mesmo tempo.
◉ Message: Modelo para criar objetos para mensagens. Mensagem é similar ao event flag,
mas com a adição de conter qualquer objeto (tipicamente uma estrutura).
◉ Channel: Modelo para criar canais arbitrarios. Geralmente usado como uma fila de dados
e mensagens.

8
 TEventFlag
{1} class TEventFlag : public TService Operações da Classe:
{2} {
{3} public: • TEventFlag::wait()
{4} enum TValue { efOn = 1, efOff= 0 }; // prefix 'ef'
means: "Event Flag"
• TEventFlag::signal()
{5}
{6} public:
• TEventFlag::signal_isr()
{7}
{8}
INLINE TEventFlag(TValue init_val = efOff); • TEventFlag::clear()
{9}
{10}
bool wait(timeout_t timeout = 0);
INLINE void signal();
• TEventFlag::is_signaled()
{11} INLINE void clear() { TCritSect cs; Value = efOff;
}
{12} INLINE void signal_isr();
{13} INLINE bool is_signaled() { TCritSect cs; return
Value == efOn; }
{14}
{15} private:
{16} volatile TProcessMap ProcessMap;
{17} volatile TValue Value;
{18} };
9
 Tmutex
{1} class TMutex : public TService Operações da Classe:
{2} {
{3} public: • TMutex::lock()
{4} INLINE TMutex() : ProcessMap(0), ValueTag(0) { }
{5} void lock();
• TMutex::unlock()
{6} void unlock();
{7} void unlock_isr();
• TMutex::unlock_isr()
{8}
{9} INLINE bool try_lock() { TCritSect cs; if(ValueTag) return
• TMutex::try_lock()
false;
{10} else lock(); return true; }
• TMutex::is_locked()
{11} INLINE bool is_locked() const { TCritSect cs; return
ValueTag != 0; }
{12}
{13} private:
{14} volatile TProcessMap ProcessMap;
{15} volatile TProcessMap ValueTag;
{16}
{17} };

10
 Message
{1} class TBaseMessage : public TService {19} {
{2} { {20} public: Operações da Classe:
{3} public:
{4} INLINE TBaseMessage() : ProcessMap(0),
•
{21} INLINE message() : TBaseMessage() { }
{22} INLINE const T& operator= (const T& msg)
TBaseMessage::send()
NonEmpty(false) { }
{5}
{23} {
{24} TCritSect cs;
• TBaseMessage::send_isr()
{6} bool wait (timeout_t timeout = 0);
{7} INLINE void send();
•
{25} *(const_cast<T*>(&Msg)) = msg; return
const_cast<const T&>(Msg);
TBaseMessage::wait()
{8} INLINE void send_isr();
{9} INLINE bool is_non_empty() const { TCritSect cs;
{26} }
{27} INLINE operator T() const
• TBaseMessage::
return NonEmpty; } {28} { is_non_empty()
•
{10} INLINE void reset () { TCritSect cs; NonEmpty = {29} TCritSect cs;
false; } {30} return const_cast<const T&>(Msg); TBaseMessage::reset()
•
{11} {31} }
{12} private: {32} INLINE void out(T& msg) { TCritSect cs; msg = message::operator=()
{13} volatile TProcessMap ProcessMap;
{14} volatile bool NonEmpty;
const_cast<T&>(Msg); }
{33} • message::operator T()
{15} };
{16}
{34} private:
{35} volatile T Msg; • message::out()
{17} template<typename T> {36} };
{18} class message : public TBaseMessage
11
 {21} bool pop (T& item, timeout_t timeout = 0);
{22} bool pop_back(T& item, timeout_t timeout = 0);
{23}
{24} //----------------------------------------------------------------

Channel {25} //
{26} // Service functions
{27} //
{1} template<typename T, uint16_t Size, typename S = uint8_t> {28} INLINE S get_count() const;
{2} class channel : public TService {29} INLINE S get_free_size() const;
{3} { {30} void flush();
{4} public: {31}
{5} INLINE channel() : ProducersProcessMap(0) {32} private:
{6} , ConsumersProcessMap(0) {33} volatile TProcessMap ProducersProcessMap;
{7} , pool() {34} volatile TProcessMap ConsumersProcessMap;
{8} { {35} usr::ring_buffer<T, Size, S> pool;
{9} } {36} };
{10}
{11} //----------------------------------------------------------------
{12} //
Operações da Classe: • channel::read()
{13} // Data transfer functions
{14} //
• channel::push() ◉ channel::get_count()
{15} void write(const T* data, const S cnt);
{16} bool read (T* const data, const S cnt, timeout_t timeout = 0);
• channel::push_front() ◉ channel::get_free_size()
{17}
{18} void push (const T& item);
• channel::pop() ◉ channel::flush()
{19} void push_front(const T& item);
{20}
• channel::pop_back()
• channel::write() 12
 Arquivos

O código fonte do ScmRTOS é contido em oito arquivos:

◉ scmRTOS.h – arquivo principal contendo toda a hierarquia de headers do sistema;
◉ os_kernel.h – definições basicas, declarações e definições do tipo de Kernel do OS;
◉ os_kernel.cpp– declarações e definições do Kernel;
◉ scmRTOS_defs.h – declarações e macros auxiliares;
◉ os_services.h – serviços de intercomunicação;
◉ os_services.cpp – funções dos serviços de intercomunicação;
◉ usrlib.h – biblioteca de suporte auxiliar;
◉ usrlib.cpp – funções da biblioteca de suporte auxiliar;

13
 Outras
Características
◉ O ScmRTOS tem capacidade para rodar 32 processos, cada um com uma prioridade, que
serve de índice na tabela de processos do Sistema Operacional, que contem todos os
endereços dos processos. Um destes 32 processos é o IdleProc, que serve de tarefa de
fundo, contendo uma prioridade única.
◉ Todos os processos são estáticos, ou seja, o número do processo é definido na hora da
compilação e eles não podem ser adicionados ou retirados na hora de rodar. Isso foi feito
por causa dos recursos limitados do microcontrolador de apenas um chip.
◉ Há, de fato, um sistema de gerenciamento de memória eficiente, pois o gerenciamento
comum feito pelas outras ferramentas de software não são compativeis por causa de um
maior Overhead.
◉ O kernel do ScmRTOS ocupa de 8 a 12 + 2*N bytes, sendo N o número de processos, com
os dados dos processos tomando 5 bytes de memória.
14
3 Aspectos Práticos

15
 Compiladores

Como ele é escrito completamente em C++, o

compilador mais comumente usado no ScmRTOS é
o GCC (GNU Compiler Collection).
Outros exemplos podem ser os compiladores
disponibilizados pelos vendedores, como por
exemplo os de Dispositivos Analógicos, o
VisualDSP++, ou do compilador da Texas
Instruments, o Code Composer Studio.

16
 Distribuição
A versão mais recente do RTOS estão ativas e disponível no próprio site da SourceForge,
contendo a seguinte lista: ARM7:
MSP430: AT91SAM7 GCC (4.6.2 Yagarto 20111119) Release
MSP430 IAR (EW430 v5.30) LPC2xxx GCC (Sourcery G++ Lite 2010.09-51 (GCC
Release 4.5.1)) Release
MSP430 GCC (20110716) ADuC70xx GCC (Sourcery G++ Lite 2010.09-51
Release (GCC 4.5.1)) Release

AVR: Cortex-M3:
AVR IAR (EWAVR v5.30) STM32 IAR (EWARM v6.30) Release
Release STM32 GCC (Sourcery G++ Lite 2010.09-51 (GCC
AVR GCC Release 4.5.1)) Release
LPC17XX GCC (Sourcery G++ Lite 2010.09-51 (GCC
Blackfin: 4.5.1)) Release
Blackfin CrossCore
VisualDSP++ (v5.0 Update 9) STM8:
Release STM8 IAR Release
17
4 Conclusão

18
 Comparações entre
TI-RTOS e ScmRTOS
◉ TI-RTOS tem uma variedade muito maior de drivers para os periféricos dos
microcontroladores do que o ScmRTOS, que tem uma atenção mais focada nas funções
básicas de um sistema operacional.
◉ TI-RTOS é mais complexo, contendo diversas interfaces para melhor visualização gráfica
do processo como um todo.
◉ ScmRTOS foi projetado para menores microcontroladores, portanto usa soluções leves e
simplificadas, com resultados mais eficientes por sua maior resistência a Overhead do
que o TI-RTOS.
◉ Por ter uma interface mais simples, o ScmRTOS tem a capacidade de rodar 10 vezes mais
rápido do que o TI-RTOS.
Sendo assim, conclui-se que, na época em que foi desenvolvido, o foco do ScmRTOS era
oferecer soluções simples para microcontroladores simples, usando linguagens de simples
entendimento. Para soluções mais complexas, o TI-RTOS é mais recomendado.
19
Isso é tudo!

Obrigado pela
Atenção! 😉
20
Licença

Este Sistema Operacional é

um projeto de livre
distribuição sob a licença do
MIT, contida na página 18 do
User’s Guide da última
versão lançada

21