Configurando o Ambiente de Desenvolvimento para QNX

26/04/2024

ÍNDICE DE CONTEÚDO

Este post faz parte da série Sistema Operacional de Tempo Real QNX

Introdução

Desenvolver softwares para o QNX Neutrino RTOS envolve a configuração cuidadosa de um ambiente de desenvolvimento.

Este guia rápido abordará a preparação deste ambiente apresentando os passos para download e instalação do QNX SDP, considerando aspectos como licenciamento e opções disponíveis para projetos comerciais e acadêmicos.

Por fim, demonstraremos dois exemplos práticos de criação de projetos utilizando o ambiente de desenvolvimento integrado e a instalação do sistema operacional QNX em um ambiente virtualizado.

QNX SDP e QNX Momentics Tool Suite

O QNX SDP (Software Development Platform) é a plataforma de desenvolvimento de software que inclui compiladores, linkers e artefatos para todas as arquiteturas de CPU suportadas pelo QNX (ARM v7,v8 e x86_64) e também um ambiente integrado de desenvolvimento (IDE – Integrated Development Environment).

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

Podemos considerá-lo como um toolchain, um conjunto de ferramentas essenciais de compilação cruzada (cross-compiling) para a construção de programas destinados à execução no QNX Neutrino RTOS o qual permitirá compilação e debug de software para o target escolhido.

O QNX Momentics Tool Suite é o ambiente integrado de desenvolvimento baseado em Eclipse e poderosas ferramentas de linha de comando.

*Figura 1: QNX Momentics Tool Suite Fonte:* *QNX Developers*

Segundo a Release Note da versão mais atual, o QNX SDP 8.0 pode ser instalado em hosts desenvolvimento de 64 bits com Microsoft Windows 11, Windows 10, Ubuntu Desktop 22.04 LTS, Ubuntu Desktop 20.04 LTS ou Red Hat Enterprise Linux 9 (esta versão não suporta mais macOS).

Importante: A instalação do QNX SDP requer uma licença! Uma versão de avaliação pode ser obtida em www.qnx.com/products/evaluation/.

Entendendo o ambiente de desenvolvimento

Basicamente HOST é computador de origem onde você vai instalar o QNX SDP, QNX Momentics IDE para criar, compilar e depurar seus programas.

TARGET é a plataforma de destino onde o sistema operacional QNX Neutrino RTOS será implantado para que seus programas sejam executados.

*Figura 2: Ambiente de desenvolvimento (host e target) Fonte:* *QNX Developers*

Existem duas escolhas para o target:

Hardware “físico”: É possível instalar o QNX Neutrino em um sistema embarcado e executar aplicações diretamente na plataforma de destino. O método usado para transferir a imagem inicializável do sistema operacional do Host para o Target depende das tecnologias de armazenamento suportadas pela placa.

Ambiente virtualizado: O QNX Neutrino pode ser executado no QEMU, VMware ou VirtualBox. Essa abordagem flexível permite a definição de configurações específicas incluindo a arquitetura da CPU.

Segundo a documentação do QNX, a partir da versão 7.1 da IDE, o alvo também pode ser uma máquina virtual (VM) QNX.

Instalação do QNX Software Development Platform (SDP) no Host

Se você ainda não se registrou no MyQNX, recomendo que você se registre agora. MyQNX oferece uma riqueza de informações da comunidade de desenvolvedores, exemplos de código, documentação de produtos, designs e demonstrações de referência, benchmarks e white papers.

O download e gerenciamento dos produtos QNX é feita via QNX Software Center encontrado na sessão “Developers” em https://blackberry.qnx.com/.

Depois de instalar o QNX Software Center, use-o para instalar o QNX SDP e o QNX Momentics IDE.

Você deve seguir as instruções do “myQNX License Manager and QNX Software Center User’s Guide”. Lembre-se, você vai precisar de uma conta em myQNX e uma licença válida.

*Figura 3: QNX Software Center Fonte:* *QNX Developers*

Existem duas opções de utilização das licenças QNX, uma versão de avaliação de 30 dias para projetos comerciais e outra acadêmica. Esta última é parte do programa QNX-in-Education como forma de apoio à pesquisa, desenvolvimento e educação continuada.

Implantando uma imagem QNX em um hardware

Vários métodos estão disponíveis para transferir uma imagem QNX para o sistema de destino quando se opta por um hardware não virtualizado.

Monitor ROM

O Monitor ROM é um programa simples, disponível em algumas plataformas, que é executado quando a placa é ligada pela primeira vez. Ele permite a comunicação com a placa através de uma interface de linha de comando, seja por meio de um link serial ou IP. Isso possibilita o download de imagens para a memória da placa e sua gravação em flash.

Terminal serial

O IDE oferece dois mecanismos para a transferência de arquivos de imagem: Terminais seriais e Servidor TFTP.

Em ambos os casos, é necessário que o destino esteja preparado para receber o arquivo da imagem. Leia mais sobre sendnto e Initial Program Loader (IPL).

Servidor TFTP

O Momentics IDE inclui um servidor TFTP para transferir arquivos de imagem para o destino, assumindo que o destino suporta downloads TFTP.

O servidor pesquisa imagens do sistema em todos os projetos do QNX System Builder sempre que recebe solicitações de download de um programa bootloader.

Para usar esse recurso, o destino deve ter sua comunicação IP configurada corretamente. As conexões IP dependem da execução do agente qconn no destino. Para comunicações seriais, o destino deve executar o utilitário de suporte pdebug.

*Figura 4: Implantação via servidor TFTP Fonte:* *QNX Developers*

Outros métodos

Se a sua placa de destino não tiver um monitor ROM integrado, você deve usar outro método, que será totalmente dependente do hardware onde se quer implantar o sistema operacional.

Cartão SD / mídia removível – A imagem do QNX pode ser copiada para uma mídia removível como um SD Card. Um bootloader será responsável por localizar e transferir a imagem para a memória do target e então iniciar a execução do QNX.
Programador Flash – Um programador externo pode ser usado para programar manualmente a memória flash do target.
JTAG/ICE/emulador — Também é possível utilizar use esse dispositivo para programar e se comunicar com seu hardware.

Implantando uma imagem QNX em um ambiente virtualizado

O utilitário mkqnximage é um gerador de imagem de máquina virtual do QNX OS e pode gerar imagens para rodar nos seguintes ambientes de virtualização.

É possível gerar uma imagem de máquina virtual diretamente a partir da IDE facilitando o trabalho de configuração, personalização e finalmente a geração desta imagem.

*Figura 5: Disparo da criação de ambiente virtualizado Fonte:* *QNX Developers*

Consulte a documentação para obter informações mais completas de como preparar, construir, gerenciar e executar imagens QNX em um ambiente virtualizado.

Testando o ambiente de desenvolvimento com um exemplo simples

Vamos testar um ambiente de desenvolvimento onde foi instalado o QNX SDP e QNX Momentics IDE em uma máquina Windows (Host) e transferindo a imagem pré-compilada do RTOS QNX para ser executada em um VMware Workstation Player.

Usando o QNX Momentics IDE, crie um novo projeto seguindo os passos a seguir:

No menu File: New > QNX Project, e então QNX Executable.

*Figura 6: Novo QNX Project Fonte:* *QNX Developers*

Clique em Avançar e na caixa de diálogo seguinte, dê um nome ao seu projeto, selecione a linguagem de programação e então a CPU variante de acordo a arquitetura do seu target de acordo com a figura seguinte.

*Figura 7: Configuração inicial do projeto Fonte:* *QNX Developers*

Ao finalizar a criação do projeto, o editor de textos da IDE já escreve um código simples. Um “Hello World”.

Figura 8: Código do projeto na IDE Fonte: Autor

Agora é só compilar e depurar a aplicação diretamente no target.

Você verá no console da IDE a seguinte mensagem “Welcome to the QNX Momentics IDE”. Simples assim!

Figura 9: Código do projeto na IDE Fonte: Autor

Vamos agora criar uma aplicação um pouco mais elaborada que explora alguns recursos demonstrando a aderência do QNX ao padrão POSIX.

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

#define NUM_THREADS 3

pthread_mutex_t mutex;      // Mutex para controlar o acesso concorrente à variável compartilhada
pthread_cond_t cond_var;    // Variável de condição para sinalizar quando os dados são atualizados
int shared_data = 0;        // Variável compartilhada entre as threads


void *thread_function(void *arg) {
    while (1) {
        pthread_mutex_lock(&mutex);      // Bloqueia o mutex para acesso exclusivo à variável compartilhada
        shared_data++;                   // Incrementa o valor compartilhado
        pthread_cond_signal(&cond_var);  // Sinaliza que os dados foram atualizados
        pthread_mutex_unlock(&mutex);    // Libera o mutex para permitir o acesso de outras threads
        sleep(1);                        // Espera 1 segundo antes de continuar
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];  // Array para armazenar os identificadores das threads
    int i;

    // Inicialização do mutex e da variável de condição
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond_var, NULL);

    // Criação das threads
    for (i = 0; i < NUM_THREADS; i++) {
        if (pthread_create(&threads[i], NULL, thread_function, NULL) != 0) {
            perror("pthread_create");  // Em caso de erro, exibe uma mensagem de erro
            exit(EXIT_FAILURE);        // Sai do programa com status de falha
        }
    }

    // Loop principal
    while (1) {
        pthread_mutex_lock(&mutex);           // Bloqueia o mutex para acesso exclusivo à variável compartilhada
        pthread_cond_wait(&cond_var, &mutex); // Aguarda até que os dados sejam atualizados e recebe o sinal
        printf("Valor compartilhado: %d\n", shared_data); // Imprime o valor compartilhado
        pthread_mutex_unlock(&mutex);         // Libera o mutex para permitir o acesso de outras threads
    }

    // Limpeza de recursos (não alcançada devido ao loop infinito)
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond_var);
    return 0;
}

Neste exemplo, criei um programa multithread com a execução de tarefas concorrentes manipulando um recurso (variável compartilhada) entre várias threads.

Na figura a seguir, podemos ver as threads em execução (Debug), a saída (Console) e informações sobre todos os processos (Target Navigator).

Figura 10: Execução do programa multithread Fonte: Autor

Conclusão

Neste artigo, exploramos os elementos básicos para configuração do ambiente de desenvolvimento para o QNX Neutrino RTOS, desde a instalação do QNX SDP e do QNX Momentics IDE até a implantação de imagens QNX em hardware físico ou em ambientes virtualizados.

Demonstramos a dinâmica entre o host e o target, assim como as opções disponíveis para cada um.

Além disso, através de dois exemplos práticos, pudemos demonstrar como criar, compilar e depurar projetos utilizando o QNX Momentics IDE, destacando a simplicidade e a eficiência desse processo.