Início > Tutoriais > Como configurar e usar o BRTOS

Como configurar e usar o BRTOS

Neste post iremos apresentar uma introdução as principais configurações do BRTOS e descrever os passos básicos para utilizá-lo em uma aplicação básica. As informações contidas neste tutorial são compatíveis com a versão 1.4 e superiores do BRTOS.

1. Configuração do BRTOS

A quantidade de RAM necessária para as tarefas dependerá da CPU escolhida (CPUs RISC necessitam maior espaço em RAM, pois possuem maior número de registradores), do número de interrupções habilitadas e das necessidades da tarefa (variáveis e chamadas de funções). Por exemplo, em um microcontrolador Coldfire V1 com aninhamento de interrupções ativado, com 3 interrupções habilitadas, devemos calcular a memória de uma tarefa da seguinte maneira:

  • 72 bytes para a primeira interrupção e  32 bytes para cada uma das próximas interrupções.
  • reservar o espaço para as variáveis locais da tarefa. Não esqueça o alinhamento da memória no processador, ou seja, 1 byte declarado seguido de 2 int ocuparão 8 bytes em um processador de 32 bits (ao invés dos 5 bytes que irão ser ocupados).
  • reservar memória para a chamada de serviços do sistema e funções. O aninhamento de funções exige mais memória. Por exemplo, se uma função fizer a chamada de outra função haverá a ocupação aninhada do endereço de retorno e das variáveis locais. A ocupação de memória para as funções depende do número de parâmetros e variáveis locais utilizada pelas função.

Antes de iniciar o desenvolvimento da aplicação é preciso configurar alguns parâmetros do sistema. Estas configurações devem ser realizadas no arquivo BRTOSConfig.h.

  • O arquivo BRTOSConfig.h possui definições relativas a memória, clock e o microcontrolador utilizado. Ainda, define quais eventos / serviços do sistema serão utilizados (semáforos, mutex, mailbox e filas de mensagem). Também irá determinar a quantidade de instâncias possíveis para um determinado serviço.

O arquivo BRTOSConfig.h apresentará a seguinte estrutura:

/// Define if simulation or DEBUG
#define DEBUG 1

/// Define if verbose info is available
#define VERBOSE 0

/// Define if error check is available
#define ERROR_CHECK 0

/// Define if whatchdog is active
#define WATCHDOG 1

/// Define if compute cpu load is active
#define COMPUTES_CPU_LOAD 1

// Define Number of Priorities
#define NUMBER_OF_PRIORITIES 32

// Define CPU Stack Pointer Size
#define SP_SIZE 32

// Define the number of Task to be Installed
// must always be equal or higher to NumberOfInstalledTasks
#define NUMBER_OF_TASKS 6

// Define if OS Trace is active
#define OSTRACE 1

// Define if TimerHook function is active
#define TIMER_HOOK_EN 1

// Habilita o serviço de semáforo do sistema
#define BRTOS_SEM_EN           1

// Habilita o serviço de mutex do sistema
#define BRTOS_MUTEX_EN         1

// Habilita o serviço de mailbox do sistema
#define BRTOS_MBOX_EN          1

// Habilita o serviço de filas do sistema
#define BRTOS_QUEUE_EN         1

// Define o número máximo de semáforos (limita a alocação de memória p/ semáforos)
#define BRTOS_MAX_SEM          4

// Define o número máximo de mutex (limita a alocação de memória p/ mutex)
#define BRTOS_MAX_MUTEX        4

// Define o número máximo de Mailbox (limita a alocação de memória p/ mailbox)
#define BRTOS_MAX_MBOX         1

// Define o número máximo de filas (limita a alocação de memória p/ filas)
#define BRTOS_MAX_QUEUE        1

// TickTimer Defines
#define configCPU_CLOCK_HZ          (INT32U)24000000
#define configTICK_RATE_HZ          (INT32U)1000
#define configTIMER_PRE_SCALER      0

// Stack Size of the Idle Task
#define IDLE_STACK_SIZE             (INT16U)192

/// Stack Defines
/// Coldfire with 8KB of RAM: 40 * 128 bytes = 5KB of Virtual Stack
#define HEAP_SIZE 40*128

// Queue heap defines
// Configurado com 1KB p/ filas
#define QUEUE_HEAP_SIZE 8*128
  • DEBUG é utilizado em algumas plataformas que possuem diferenciações entre o simulador e o debugger. Desta forma o código se adapta a condição desejada. DEBUG = 1 indica modo debugger / flash write.
  • VERBOSE habilita informação extra ao contexto das tarefas, facilitando a depuração do código em execução. Normalmente está opção é desabilitada em produtos finais, diminuindo assim o overhead do sistema operacional. VERBOSE = 1 indica modo verbose ativo.
  • ERROR_CHECK habilita a verificação de inconsistência de dados nas funções do BRTOS. Exemplos destas inconsistências são ponteiros nulos, valores inválidos, etc. Se não existem erros de programação esta opção pode ser desabilitada. ERROR_CHECK = 1 indica verificação ativa.
  • WATCHDOG indica se o watchdog do sistema estará ativo. WATCHDOG = 1 indica watchdog ativo.
  • COMPUTES_CPU_LOAD habilita o cálculo de ocupação da CPU pelo BRTOS. COMPUTES_CPU_LOAD = 1 indica cálculo de ocupação de CPU ativo.
  • NUMBER_OF_PRIORITIES configura o número de prioridades aceito pelo sistema. O padrão é 32 prioridades para microcontroladores de 16 e 32 bits e 16 ou 8 prioridades para microcontroladores de 8 bits.
  • SP_SIZE é utilizado para informar ao compilador o tamanho do registrador stack pointer do processador em bits. Para Stack Pointer menor ou igual a 16 bits, utilize SP_SIZE = 16. Para Stack Pointer menor ou igual a 32 bits, utilize SP_SIZE = 32.
  • NUMBER_OF_TASKS indica quantas tarefas podem ser instaladas em uma aplicação. O valor máximo para este define é 31. Esta definição permite que uma menor quantidade de memória seja alocada para estrutura de contexto de tarefas. Utilize este recurso para reduzir o consumo de memória do sistema quando um número pequeno de tarefas for instalado.
  • OSTRACE indica se o trace do sistema está ativo ou não. O trace de sistema é utilizado para monitorar o comportamento do sistema.
  • TIMER_HOOK_EN indica se a função de âncora de timer está ativa. Se sim, é possível executar um pequeno trecho de código a partir da interrupções de tick timer do sistema. É um recurso importante para implementar pequenas verificações de tempo, como timeouts.
  • configCPU_CLOCK_HZ indica a freqüência de barramento utilizada pelo microcontrolador em hertz.
  • configTICK_RATE_HZ define o Timer Tick (marca de tempo) do sistema, ou seja, a resolução do gerenciador de tempo do RTOS. Valores entre 1ms (1000 Hz) e 10ms (100 Hz) são recomendados. Nunca esqueça que a resolução do gerenciamento de tempo é de + ou – 1 Timer Tick.
  • configTIMER_PRE_SCALER pode ser utilizado no port do sistema para a configuração do hardware responsável pelo Timer Tick.
  • IDLE_STACK_SIZE determina a quantidade de memória alocada como pilha virtual para a Idle Task. A Idle Task é instalada na chamada BRTOSStart, sendo que a quantidade de memória utilizada por esta tarefa será alocada no HEAP.
  • HEAP_SIZE determina a quantidade de memória alocada como pilha virtual das tarefas. Sempre que uma tarefa é instalada, a quantidade de memória utilizada pela tarefa será alocada no HEAP.
  • QUEUE_HEAP_SIZE determina a quantidade de memória alocada para a criação de filas, em bytes. Sempre que uma fila é criada, a quantidade de memória utilizada pela fila será alocada neste HEAP.
  • Os defines BRTOS_SEM_EN, BRTOS_MUTEX_EN, BRTOS_MBOX_EN e BRTOS_QUEUE_EN determinam se os serviços de semáforo, mutex, mailbox e filas, respectivamente, estarão ou não disponíveis para a aplicação. O valor 1 determina que o serviço estará disponível.
  • Os defines BRTOS_MAX_SEM, BRTOS_MAX_MUTEX, BRTOS_MAX_MBOX e BRTOS_MAX_QUEUE determinam a quantidade máxima de instâncias que poderão ser criadas para os serviços de semáforo, mutex, mailbox e fila, respectivamente.

OBS: A partir da versão 1.1 do BRTOS quanto maior o valor de prioridade associado a uma tarefa, maior sua prioridade no sistema.

O arquivo HAL.h contêm além das informações de port do sistema, a definição de interrupções aninhadas e do processador utilizado, com a seguinte estrutura:

// Define if nesting interrupt is active
#define NESTING_INT 0

/// Supported processors
#define COLDFIRE_V1		1u
#define HCS08			2u
#define MSP430			3u
#define ATMEGA			4u
#define PIC18			5u
#define RX600			6u
#define ARM_Cortex_M3	        7u
#define ARM_Cortex_M4	        8u
#define ARM_Cortex_M0	        9u

/// Define the used processor
#define PROCESSOR 		ARM_Cortex_M0

#define OS_CPU_TYPE 	        INT32U

/// Define if the optimized scheduler will be used
#define OPTIMIZED_SCHEDULER     0

/// Define if 32 bits register for tick timer will be used
#define TICK_TIMER_32BITS       1
      • NESTING_INT indica se o aninhamento de interrupções é suportado no sistema.
      • PROCESSOR define o tipo de processador utilizado. Esta definição é utilizada em alguns pontos específicos do port.
      • OS_CPU_TYPE define o tipo de dados proporcional ao tamanho do barramento de dados do microcontroladores (8, 16 ou 32 bits). Esta definição é muito importante para manter o correto alinhamento na declaração das variáveis do sistema.
      • OPTIMIZED_SCHEDULER é utilizado em alguns processadores para acelerar o processo de escalonamento das tarefas no BRTOS. Normalmente esta otimização é implementada por uma instrução especial existente somente em processadores coldfire e ARM. No caso do coldfine esta instrução é a FF1 (Find-First-One) e no caso do ARM é a CLZ (count leading zeros).
      • TICK_TIMER_32BITS alguns microcontroladores, como por exemplo a linha ARM Cortex-M, possuem um periférico de timer especial para o tick do sistema. No caso dos ARM este timer é de 32 bits. Em qualquer caso em que o timer utilizado para implementar o tick do sistema for de 32 bits esta definição deve ser marcada para 1.

2. Iniciando uma aplicação

A seqüência de inicialização do sistema deve seguir uma ordem bem determinada. Os seguintes passos devem ser realizados:

    • Inicialização dos registradores principais do microcontrolador
    • Inicialização dos serviços / eventos (caso sejam utilizados)
    • Inicialização do hardware interno do microcontrolador
    • Inicialização do hardware externo ao microcontrolador
    • Inicialização das tarefas
    • Inicialização do escalonador

A seguir é apresentado um exemplo de inicialização de uma aplicação utilizando o microcontrolador Freescale Coldfire V1:

// Declara ponteiros para os blocos de controle dos serviços / eventos do BRTOS

// Declara ponteiro p/ serviço de filas
BRTOS_Queue  *Serial;
// Declara ponteiro p/ serviço de semáforo
BRTOS_Sem    *Teclado;

// Declara ponteiro p/ serviço de caixa de mensagem
BRTOS_Mbox   *ConversorAD;

void main(void){
  ////////////////////////////////////////////////////////////
  /////      Inicialização dos registradores principais  /////
  /////      do microcontrolador utilizado               /////
  ////////////////////////////////////////////////////////////
  MCU_init();

  ////////////////////////////////////////////////////////////
  /////      Inicialização do BRTOS                        /////
  ////////////////////////////////////////////////////////////
  BRTOS_Init(); 

  // Exemplo de criação de uma fila
  // Cria um gerenciador de eventos p/ a porta serial
  // onde os dados gerenciados por este evento
  // estão em buffer circular, chamado de SerialPortBuffer

  if (OSQueueCreate(&SerialPortBuffer,512,&Serial) != ALLOC_EVENT_OK)
  {
    // Oh Oh
    // Não deveria entrar aqui !!!
    while(1){};
  };

  // Exemplo de criação de um semáforo
  // No caso, o semáforo é utilizado para sincronizar a interrupção de teclado
  // com uma tarefa
  if (OSSemCreate(0,&Teclado) != ALLOC_EVENT_OK)
  {
    // Oh Oh
    // Não deveria entrar aqui !!!
    while(1){};
  };

  // Exemplo de criação de uma caixa de mensagem
  // No caso será utilizado para acordar uma tarefa que está
  // a espera de um novo valor do conversor A/D
  if (OSMboxCreate(&ConversorAD,(INT16U *)0) != ALLOC_EVENT_OK)
  {
    // Oh Oh
    // Não deveria entrar aqui !!!
    while(1){};
  };

  ////////////////////////////////////////////////////////////
  /////      Inicialização do Hardware                   /////
  ////////////////////////////////////////////////////////////

  // Inicializa as portas utilizadas na aplicação
  PortSetup();

  // Inicializa uma porta como teclado
  Keyb2Setup(0x0F);

  // Configura / Inicializa um conversor A/D
  ADSetup(HighSpeed, ShortSampleTime, 12);

  // Configura / Inicializa uma saída PWM
  // PWM = Frequency 10Khz
  // Center Align
  // Channell 0 = Duty 40%
  // Polarity = Positive
  // Channell 1 = Duty 40%
  // Polarity = Negative
  PWM3Setup(10000,CenterAlign,1,40,NegativeDutyCyclePolarity);

  // Inicia uma porta serial a 19200 bauds
  // Teto de prioridade do recurso = 4 (Note que esta prioridade deve estar
  // disponível e ser pelo menos um nível maior do que a máxima prioridade
  // das tarefas que irão utilizar o recurso.
  // O protocolo utilizado no mutex do RTOS associado a este recurso
  // utiliza como parâmetro a maior prioridade das tarefas que irão utilizar
  // o recurso para evitar inversões de prioridade e deadlocks.
  init_SCI2(4);

  ////////////////////////////////////////////////////////////
  /////      Inicialização do Hardware Externo           /////
  ////////////////////////////////////////////////////////////

  // Inicializa um Display LCD 16x2
  init_lcd();
  // Teto de prioridade do recurso LCD = 16
  init_lcd_resource(16);

  ////////////////////////////////////////////////////////////
  /////      Inicialização das tarefas                   /////
  //////////////////////////////////////////////////////////// 

  // Instala todas as tafefas no seguinte formato:
  // (Endereço da tarefa, Nome da tarefa, Número de Bytes do Stack Virtual,
  //  Prioridade da Tarefa)

  // Cada tarefa deve possuir uma prioridade
  // A instalação de uma tarefa em um prioridade ocupada gerará uma exceção

  if(InstallTask(&System_Uptime,"System Uptime",100,31) != OK)
  {
    // Oh Oh
    // Não deveria entrar aqui !!!
    while(1){};
  };

  if(InstallTask(&Task_2,"GLCD Handler",100,15) != OK)
  {
    // Oh Oh
    // Não deveria entrar aqui !!!
    while(1){};
  };

  if(InstallTask(&Task_3,"Serial Handler",200,3) != OK)
  {
    // Oh Oh
    // Não deveria entrar aqui !!!
    while(1){};
  };

  if(InstallTask(&Task_4,"Teclado e PWM",100,5) != OK)
  {
    // Oh Oh
    // Não deveria entrar aqui !!!
    while(1){};
  };

  ////////////////////////////////////////////////////////////
  /////    Inicialização do escalonador                  /////
  /////    A partir deste momento as tarefas instaladas  /////
  /////    começam a ser executadas                      /////
  //////////////////////////////////////////////////////////// 

  // Start Task Scheduler
  if(BRTOSStart() != OK)
  {
    // Oh Oh
    // Não deveria entrar aqui !!!
    while(1){};
  };
}

As tarefas da aplicação devem ser criadas no arquivo tasks.c. A seguir é apresentada a estrutura de uma tarefa:

//  Tarefa para gerenciamento de um RTC da aplicação

void System_Uptime(void)
{
  // Configuração da tarefa
  // Este código será executado somente na inicialização do sistema
  OSResetTime(&Hora);

  // Loop principal da tarefa
  // Uma tarefa opera como um aplicativo independente,
  // utilizando o conceito de super laço ou laço infinito
  for (;;)
  {
      // Código da tarefa
      OSUpdateUptime(&Hora,&Data);
      PTHD_PTHD0 = ~PTHD_PTHD0;
      DelayTask(1000);
  }
}

3. Como determinar a prioridade associada a cada tarefa

Algumas regras podem ser seguidas para determinar prioridades de tarefas em um sistema operacional preemptivo baseado em prioridades. Algumas delas são:

            1. Tarefas que gerenciam dispositivos de I/O devem possuir alta prioridade. Um dos motivos é que estas tarefas devem receber / tratar os dados mais rápido do que a fonte dos dados está enviando novos dados. Em um sistema operacional de grande porte, como Linux e windows, pode-se notar que quanto maior o acesso a dispositivos de I/O (hard disk, por exemplo), mais o operador sente a redução de performance para outras tarefas. Isto deve-se aos serviços do sistema que gerenciam I/Os serem de alta prioridade.
            2. Alguns algoritmos sugerem que tarefas que são realizadas de forma rápida devem possuir maior prioridade, enquanto que tarefas mais lentas recebem menores prioridades. Desta forma uma tarefa lenta pode ser interrompida diversas vezes durante sua operação por tarefas de maior prioridade. O principal algoritmo desta linha de pensamento é o Rate Monotonic (RM).
            3. Tarefas que não interferem diretamente na operação do sistema embarcado, como atualizar um display, por exemplo, podem ter prioridades baixas.
Anúncios
  1. 24/10/2011 às 1:07

    Hi there!! I want to thank you for making BRTOS, and the Colduino looks amazing!! Great work!! I am a beginner with RTOS and I was wondering if you are thinking about making the documentation for BRTOS in english language? English is not my native language, but I understand it, and it is very spread. Anyway, great work , as I am newbie, I have only run BRTOS in a kwikstik but I could not make anything 😛 Please continue such a great work!!

    • 25/10/2011 às 10:58

      Hi Juan,

      We are glad that you liked the BRTOS project.
      Regarding your request, we always think in a BRTOS manual available in english. The only problem is time.
      We will provide as soon as possible documentation in english.

      Best regards,
      Gustavo

  2. Juan
    23/11/2011 às 12:01

    Excuse me for such a delayed response. Thanks for have in mind an english manual, and thanks for replaying to posts. I really would like to know how to use rtos in general and use BRTOS in my projects, but brazilian is a bit hard for me (and for google translator hahah 😀 ), I will doing what I can, and will be waiting for a manual in english, or maybe only this page about “how to configure and use BRTOS” (if not translated incorrectly) .

    • 23/11/2011 às 12:06

      Juan, we will provide the page “How to configure and use BRTOS” in english as soon as possible, ok?

  3. 23/11/2011 às 23:53

    Juan, we quickly translate the page “how to configure and use BRTOS” to english in order to provide a BRTOS starting documentation in english. Some errors may persist, but we think that it is a good start.

    Best regards,
    Gustavo

  4. Wilson Barros
    02/12/2011 às 15:43

    Galera, parabéns!
    É um prazer ver um projeto como esse “made in Brazil”!
    Agora, como faço para portar o BRTOS para o MCF51EM256, de que disponho de um kit?
    E mais uma vez, valeu!

    • 02/12/2011 às 16:33

      Olá Wilson,

      Que bom que gostou do projeto.
      Bom, quanto a sua pergunta, o BRTOS já está portado para qualquer MCF51XX (coldfire v1).
      Você somente deve iniciar um projeto no CodeWarrior e configurar o clock para sua aplicação.
      Depois disso é só configurar alguns dados no BRTOSConfig.h e incluir os arquivos do BRTOS e do HAL no projeto.
      E por fim, você deve seguir os passos descritos neste tutorial para iniciar o sistema e as tarefas.

      Espero ter ajudado e bem-vindo ao projeto BRTOS !!!

  5. faccan
    07/12/2011 às 12:42

    Pessoal, Gostaría parabenizar a voces pelo projeto. É muito interessante o jeito que o mesmo e apresentado e documentado.
    Agora mesmo estou lendo os todas as informacoes ja que acho que o BRTOS pode me ajudar (e muito) no desenvolvimento do meu projeto de formatura na universidade.
    Atenciosamente, desde Buenos Aires Argentina.

    • 09/12/2011 às 8:58

      Ficamos muito contestes de vocë tenha gostado do projeto. Conte com nossa ajuda se tiveres qualquer dúvida.
      Abraço, Gustavo.

  6. Raphael Marques Franco
    30/04/2012 às 22:17

    Adorei o projeto BRTOS! Estou aqui aprendendo e vendo o que poderia realizar para ampliar para meu kit demo 52233 da Freescale. Trata-se de um coldfire V2, não suportado pelo projeto.
    Possuo uma outra placa adquirida em http://www.ebay.ca/itm/ws/eBayISAPI.dll?ViewItem&item=160487852877&ssPageName=ADME:X:RTQ:CA:1123
    uma Freescale Motorola HC08 Evaluation Demo Board; LCD BDM a qual nunca consegui dar vida e simular algum código pois acredito que não consegui instalar corretamente o suporte USB/BDM corretamente. Ela possui um cabo usb, e os drivers eram para windows xp OSBDM, por falta de tempo deixei de lado.
    Utilizo o CodeWarrior 10.2 num Ubuntu 11.04-64bits, alguma dica de pessoas que estão enfrentando estas versões seria uma ótima oportunidade de trocar ideias. Fiquei muito curioso ao ver algumas ferramentas para linux rodando em ambiente puramente gnu. Sinceramente adoraria estar programando no emacs e vendo o debug no gdb, mas as configurações do gdb-server e como fazer isto ainda não encontrei algo certo.
    Um grande abraço!

    • 02/05/2012 às 10:56

      Olá Raphael. Que legal que você gostou do BRTOS. O coldfire V2 realmente não é suportado, mas simplesmente pq nunca tivemos acesso a um kit com um V2. No entanto, o port deve ser muito parecido com o do V1. Quanto ao suporte ao OSBDM em sistemas 64 bits e linux é limitado mesmo.

  7. Rogério Lima
    05/01/2016 às 23:35

    Prezado Gustavo,

    Muito legal o projeto BRTOS, parabéns!. Gostaria de saber se o mesmo ainda está ativo.

    Estou com uma dúvida e talvez você possa me ajudar. Estou tentando portar o BRTOS do TI Stellaris LM4F120 (EK-LM4F120XL) para o Tiva C Series TM4C123G (EK-TM4C123GXL) usando o Code Composer Studio v5.5. No entanto, quando se executa a função “BRTOSStart()” que por sua vez chama em sequência as duas outras funções “ChangeContext()” e “OSExitCritical()”, ocorre um problema e o código vai para a “FaultISR()”.

    Você tem alguma ideia do que possa ser esse problema?

    Obrigado,

    Rogério.

    • 10/01/2016 às 11:35

      Olá Rogério,

      Que bom que você gostou do projeto BRTOS. Ainda estamos ativos sim, inclusive estamos para lançar a versão 2.0 esse ano, mesmo que grande parte das novidades já estejam disponíveis na última versão disponível no git. Como o google code deixou de operar, estamos utilizando o git para manter o código fonte. Disponível em:
      https://github.com/brtos/brtos

      Quanto ao suporte ao Tiva C, já temos muitos demos implementados. No entanto, não recomendo que você utilize a versão 5.5 do Code Composer. O compilador da Texas não é muito amigo dos ports de RTOS (dependendo da versão do compilador o port pode deixar de operar). Você pode estar enfrentando problemas vinculados ao compilador ou ainda por não ter registrado as interrupções do BRTOS no vetor de interrupções (visto que você deve ter criado um projeto novo).

      Tanto a Texas percebeu o problema do compilador que começou a disponibilizar o gcc nas versões mais novas do Code Composer. Recomendo que você utilize a última versão (6.1.2) marcando a opção do gcc na instalação. Se você optar por isso, o demo para o EK-TM4C123GXL está disponível em: https://github.com/brtos/brtos/tree/master/Demos

      Qualquer dúvida estamos a disposição.
      Abraço,
      Gustavo

      • Rogério Lima
        10/01/2016 às 20:58

        Prezado Gustavo,

        muito obrigado pela resposta! O projeto é muito legal mesmo.

        Comecei a busca por RTOS’s para sistemas embarcados recentemente para uma empresa na qual eu desenvolvo trabalhos de pesquisa. Eu atualmente trabalho com sistemas embarcados, mas até então não tinha tido nenhuma experiência com RTOS. Daí fiz uma busca por tais OS’s e encontrei o BRTOS. Vi que existem vários outros disponíveis, mas o que chamou a atenção para o BRTOS é que ele é brasileiro!

        Vou seguir sua sugestão e usar uma versão mais nova do CCS usando o GCC para realizar os testes planejados.

        Se surgir alguma dúvida, espero poder contar com a sua ajuda. E espero em breve poder também contribuir para o projeto de alguma forma.

        Atenciosamente,

        Rogério.

      • Rogério Lima
        10/01/2016 às 21:23

        Gustavo,

        mais uma pergunta: você têm referências (livros, artigos, links) sobre RTOS para sistemas embarcados? Se souber e puder me indicar, eu agradeço!

        Atenciosamente,

        Rogério.

  8. 11/01/2016 às 14:08

    Rogério, mudei o demo do Git para a última versão do BRTOS, caso já tenha feito o download. Também lembrei de te avisar que quando se utiliza o gcc no Code Composer é necessário fazer um reset depois de gravar o código pelo debug (utilize o botão de reset da interface de depuração do CCS). Caso contrário você deverá parar em uma interrupção de falha de hardware (isso é uma falha do CCS).

    Quanto a referências, posso te recomendar o livro do Jean Labrosse do uC-OS-III. Apesar de focar em um RTOS, tem os conceitos bem definidos.

    Ainda, se tudo der certo poderemos ter uma novidade esse ano com relação a bibliografia sobre o assunto. Eu aviso caso se concretizar 😉

    Abraço.

    • Rogério Lima
      12/01/2016 às 18:54

      Gustavo,

      muito obrigado pelas informações! Eu baixei o novo código que você mencionou, e usando o a versão 6.1.2 do Code Composer Studio no Windows 8 eu consegui compilar, gravar e depurar o código normalmente. Não precisei resetar o kit e o código não caiu em nenhuma FaultISR durante a depuração.

      A única alteração que tive de fazer foi alterar o endereço do TivaWare que no port original faz referência a versão “2.0.1.11577” para a versão que tenho instalada no meu pc, que é a “2.1.0.12573”. Por conta dessa diferença de versão, inicialmente tive problemas com algumas macros que usavam os termos “BLIZZARD” e “SNOWFLAKE” na versão antiga para fazer referência aos uC “TM4C123” e “TM4C129”, respectivamente, na nova versão.

      Por exemplo no cabeçalho “hw_ints.h” da versão “2.0.1.11577” do TivaWare tem-se a seguinte macro:

      #define INT_GPIOA_BLIZZARD 16 // GPIO Port A

      quando no mesmo cabeçalho da versão “2.1.0.12573” do TivaWare tem-se a mesma macro com a definição diferente:

      #define INT_GPIOA_TM4C123 16 // GPIO Port A

      Daí eu substituí cada arquivo do projeto que tinha alguma referência a essas macros por arquivos do novo TivaWare.

      No mais, tudo funcionou perfeitamente!

      Um abraço,

      Rogério.

      • 13/01/2016 às 18:33

        Que bom que deu certo Rogério. Já atualizei os demos para a última versão da TivaWare, que é a 2.1.1.71.

        Abraço.

      • 13/01/2016 às 19:15

        Mais um detalhe, migramos todos os demos para um novo repositório no git:
        https://github.com/brtos/demos

        Esse diretório será o oficial para demos, contendo inclusive todos os demos antigos.

  9. 08/06/2016 às 9:53

    Olá, tudo certo?

    Existe algum endereço de e-mail para trocar algumas dúvidas sobre o projeto BRTOS?
    Sou estudante e atualmente faço pesquisa na área de RTOS e gostaria se possível de algumas dicas.

    Aguardo retorno, obrigado.

  1. No trackbacks yet.

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: