Zephyr NINA B1/B3/B4 - VSCODE - NRFCONNECT: NINA B302 - zephyr - Platformio

VEJA ISTO PRIMEIRO

How to install the extension - nRF Connect for VS Code

O objetivo deste BLOG é demonstrar de forma resumida como é possível fazer com que o módulo NINA B302 possa rodar o RTOS Zephry, mas utilizando o Framework NRF Connect + RTOS via Visual Code.

Neste projeto, construiremos um dispositivo BLE (Bluetooth Low Energy) que transmite dados de um Sensor de Qualidade do Ar - CO2 e TVOC - CCS811. Para isso, utilizaremos o Zephyr RTOS na placa EVK-NINA-B302 com base no Nordic nRF52840 SoC. Para programar o utilizaremos o J-LINK.

Você pode fazer "Advertising" de vários sensores

Um LED na IO_1 (P0.13) pode ser colocado para sinalizar a transmissão do pacote ADVERTISING.

Sobre RTOS Zephyr

O sistema operacional Zephyr é baseado em um kernel de pequena dimensão projetado para uso em sistemas com recursos restritos e embarcados: de sensores ambientais incorporados simples e wearables de LED a sofisticados controladores embarcados, relógios inteligentes e aplicativos sem fio IoT.

O Projeto Zephyr RTOS é um esforço recente da Fundação Linux para fornecer ao mundo embarcado um Sistema Operacional em Tempo Real gratuito, seguro e completo. Ele foi projetado desde o início para ser um RTOS moderno, escalável, seguro e responsivo com um foco claro em protocolos e fundações de IoT. Este RTOS de código aberto é licenciado pelo Apache 2.0 e possui um modelo de desenvolvimento totalmente aberto

Recentemente, a Nordic contribuiu com portas para todos os CIs baseados em Cortex-M (nRF51, nRF52832 (NINA B1) e nRF52840 (NINA B3), bem como um Controlador BLE de fonte aberta (Link Layer + HCI) totalmente funcional, altamente otimizado para a família de ICs nRF5x. Isto significa que você pode clonar, construir e executar o Zephyr hoje e aproveitar todos os recursos que ele permite, incluindo muitos perfis BLE padrão, IPv6 sobre BLE e um conjunto rico de APIs e funcionalidades que se esperaria de um RTOS moderno. Além disso, todas as linhas de código, incluindo o Host e o Controlador BLE, são totalmente de código aberto, permitindo que você modifique e modifique seu comportamento ou até mesmo estenda isso à vontade. Você pode até mesmo construir seu próprio controlador e depois usá-lo para controlá-lo de uma pilha Host externa ou executar o resto do RTOS em seu computador utilizando o QEMU!

Características

O Zephyr oferece um grande e crescente número de recursos, incluindo:

Extenso conjunto de serviços do kernel

A Zephyr oferece vários serviços familiares para desenvolvimento:

Serviços de multiencadeamento para encadeamentos cooperativos, com base em prioridade, não preemptivos e preemptivos, com fatiamento de tempo round-robin opcional. Inclui suporte à API compatível com POSIX pthreads.
Serviços de interrupção para registro em tempo de compilação de manipuladores de interrupção.
Serviços de alocação de memória para alocação dinâmica e liberação de blocos de memória de tamanho fixo ou variável.
Serviços de Sincronização Inter-thread para semáforos binários, semáforos de contagem e semáforos mutex.
Serviços de transmissão de dados entre threads para filas de mensagens básicas, filas de mensagens aprimoradas e fluxos de bytes.
Serviços de gerenciamento de energia, como inatividade sem marcas e uma infraestrutura avançada inativa.

Algoritmos de Agendamento Múltiplos

O Zephyr fornece um conjunto abrangente de opções de agendamento de threads:

Programação Cooperativa e Preemptiva
Primeiro Prazo Primeiro (EDF)
Programação de meta-IRQ implementando o comportamento “interromper a metade inferior” ou “tarefa”
Timeslicing: permite a divisão de tempo entre encadeamentos preemptivos de prioridade igual
Várias estratégias de enfileiramento:
Fila pronta de lista vinculada simples
Fila pronta de árvore vermelha / preta
Fila pronta multi-fila tradicional

Altamente configurável / modular para flexibilidade

Permite que um aplicativo incorpore somente os recursos de que precisa, conforme necessário, e especifique sua quantidade e tamanho.

Arquitetura Cruzada

Suporta uma ampla variedade de placas suportadas com diferentes arquiteturas de CPU e ferramentas de desenvolvedor. Contribuições adicionaram suporte para um número crescente de SoCs, plataformas e drivers.

Proteção de Memória

Implementa proteção de estouro de pilha específica para arquitetura configurável, rastreamento de permissão de objeto de kernel e driver de dispositivo e isolamento de thread com proteção de memória em nível de encadeamento em arquiteturas x86, ARC e ARM, espaço de usuário e domínios de memória.

Para plataformas sem MMU / MPU e dispositivos com memória restrita, suporta a combinação de código específico de aplicativo com um kernel personalizado para criar uma imagem monolítica que seja carregada e executada no hardware de um sistema. Tanto o código do aplicativo quanto o código do kernel são executados em um único espaço de endereçamento compartilhado.

Definição de Recurso em Tempo de Compilação

Permite que os recursos do sistema sejam definidos em tempo de compilação, o que reduz o tamanho do código e aumenta o desempenho de sistemas com recursos limitados.

Modelo de driver de dispositivo otimizado

Fornece um modelo de dispositivo consistente para configurar os drivers que fazem parte da plataforma / sistema e um modelo consistente para inicializar todos os drivers configurados no sistema e permite a reutilização de drivers em plataformas que possuem dispositivos comuns / bloqueios de IP

Suporte a árvore de dispositivos

Uso de Device Tree (DTS) para descrever informações de hardware e configuração para placas. As informações do DTS serão usadas somente durante o tempo de compilação. Informações sobre o sistema são extraídas do DTS compilado e usadas para criar a imagem do aplicativo.

Rede Nativa Stack suportando vários protocolos

O suporte de rede é totalmente caracterizado e otimizado, incluindo suporte compatível com sockets LwM2M e BSD. O suporte a OpenThread (em chipsets NORDIC) também é fornecido - uma rede em malha projetada para conectar de forma segura e confiável centenas de produtos ao redor da casa.

Suporte para Bluetooth Low Energy 5.0

Compatível com Bluetooth 5.0 (ESR10) e suporte a controlador de baixa energia Bluetooth (LE Link Layer). Inclui BLE Mesh e um controlador BLE pronto para qualificação Bluetooth.

Perfil genérico de acesso (GAP) com todas as funções possíveis de LE.
GATT (Perfil de Atributo Genérico)
Suporte de emparelhamento, incluindo o recurso Conexões seguras do Bluetooth 4.2
Clara a abstração do driver de HCI
Interface HCI bruta para executar o Zephyr como um Controlador em vez de uma pilha Host completa
Verificado com vários controladores populares
Altamente configurável

Suporte de malha (MESH)

Recursos de relé, nó de amigo, nó de baixa potência (LPN) e proxy do GATT
Ambos os portadores de provisionamento suportados (PB-ADV e PB-GATT)
Altamente configurável, encaixando em dispositivos com pelo menos 16k de RAM

Linux nativo, macOS e Windows Development

Um ambiente de compilação CMake de linha de comando é executado em sistemas populares de sistemas operacionais de desenvolvedores. Uma porta POSIX nativa, permite criar e executar o Zephyr como um aplicativo nativo no Linux e em outros sistemas operacionais, auxiliando no desenvolvimento e nos testes.

Interface de sistema de arquivos virtual com suporte a NFFS e FATFS

Sistema de arquivos Flash Newtron (NFFS) e suporte a FATFS, FCB (Flash Circular Buffer) para aplicativos com restrições de memória e aprimoramentos do sistema de arquivos para criação de log e configuração.

Estrutura poderosa de log de vários back-ends

Suporte para filtragem de log, despejo de objetos, modo de pânico, múltiplos backends (memória, rede, sistema de arquivos, console, ..) e integração com o subsistema shell.

Interface amigável e cheia de recursos do Shell

Um subsistema de shell de várias instâncias com recursos fáceis de usar, como autocompletar, curingas, coloração, metacarys (setas, backspace, ctrl + u, etc.) e histórico. Suporte para comandos estáticos e subcomandos dinâmicos.

Configurações no armazenamento não volátil

O subsistema de configurações fornece aos módulos uma maneira de armazenar a configuração persistente por dispositivo e o estado de tempo de execução. Os itens de configurações são armazenados como sequências de pares de valores-chave.

Armazenamento não volátil (NVS)

O NVS permite o armazenamento de blobs binários, strings, inteiros, longs e qualquer combinação destes.

Porta POSIX nativa

Suporta rodar o Zephyr como um aplicativo Linux com suporte para vários subsistemas e redes.

O que é nRF Connect for Visual Studio Code?

Nordic Semiconductor anunciou recentemente e lançou uma versão de amostra de seu nRF Connect for VS Code.

nRF Connect for VS Code é simplesmente uma extensão do Visual Studio Code. Ele permite que os usuários do nRF Connect SDK e Zephyr RTOS:

Desenvolva seu código de aplicativo
Build e gerar o firmware do aplicativo
Flash a imagem para o dispositivo e
Depurar aplicativos

direto do ambiente do VS Code.

Esta extensão utiliza o nRF Connect SDK e Zephyr RTOS pré-instalados, permitindo aos desenvolvedores alternar entre o código VS ou a linha de comando para o desenvolvimento do projeto. Quão legal é isso :)

Embora esta extensão seja direcionada para nRF Connect SDK e Zephyr RTOS, ela foi construída para fazer uma coisa, e fazer isso direito: tornar o desenvolvimento baseado em Zephyr uma brisa. Para uma experiência perfeita, a extensão fornece recursos extensivos de desenvolvimento e depuração para dispositivos da série Nordic nRF91, nRF53 e nRF52 no Windows, macOS e Linux. A extensão pode reconhecer nRF dev kits com a interface J-Link OB e mostrar seus nomes. Os desenvolvedores também podem usar dispositivos J-Link / Trace autônomos para programar e depurar os respectivos dispositivos.

CCS811

O CCS811 é um sensor digital de gás miniatura de baixa potência para monitoramento da qualidade do ar. Um sensor de óxido de metal (MOX) é integrado para medir o total de compostos orgânicos voláteis equivalentes de TVOCs e CO2, com isso, é possível realizar o monitoramento da qualidade do ar, quando funcionando em conjunto com um microcontrolador Arduino, Raspberry, Pic, ou outros. O módulo é baseado na tecnologia exclusiva de microplacas, ou seja, a placa apresenta uma solução altamente confiável para projetos que exigem o sensor de gás, tempos de ciclo rápidos e uma redução significativa na potência média de consumo. O MCU integrado gerencia os modos de acionamento do sensor e dos dados medidos. O CCS811 suporta algoritmos inteligentes para processar as medições e emitir um valor TVOC ou CO2 equivalentes, além de suportar múltiplos modos de medição que são otimizados para baixo consumo de energia, prolongando assim a vida útil da bateria em dispositivos portáteis.

Principais Características:

Tensão de alimentação: 1,8 à 3,6VDC;

Corrente de alimentação: 30mA;

Potência consumida: 60mW;

Temperatura de operação: -5º ~ 50°C;

Temperatura de armazenamento: -40º ~ 125ºC;

Humidade relativa: 10 ~ 95%;

Interface: I2C;

Datasheet: Sensor de Qualidade do Ar - CO2 e TVOC - CCS811

ESPECIFICAÇÕES:

Principais Características:

Tensão de alimentação: 1,8 à 3,6VDC;

Corrente de alimentação: 30mA;

Potência consumida: 60mW;

Temperatura de operação: -5º ~ 50°C;

Temperatura de armazenamento: -40º ~ 125ºC;

Humidade relativa: 10 ~ 95%;

Interface: I2C;

Datasheet: Sensor de Qualidade do Ar - CO2 e TVOC - CCS811

Resumo de Instalação (PLATFORMIO) e PROJETO ZEPHYR BLE

Ver BLOG

https://zephy-platformio.blogspot.com/2021/09/nina-b302-sendo-programado-com-nrf.html

Abra o exemplo HELLO_WORLD (projeto será reaproveitado), configure para 52840_DK e então cole o exemplo abaixo

Não esquecer de alterar PRJ.CONF para

# nothing here
CONFIG_BT=y

##########
# for i2c
##########
CONFIG_I2C=y

##########
CONFIG_SENSOR=y
CONFIG_CCS811=y

Código fonte

/* * Copyright (c) 2020 Nordic Semiconductor ASA * * SPDX-License-Identifier: Apache-2.0 */ #include <bluetooth/bluetooth.h> #include <bluetooth/hci.h> #include <drivers/sensor/ccs811.h> #include <drivers/gpio.h> #include <sys/printk.h> #include <zephyr/types.h> #define DEVICE_NAME "VISYS-CCS811" #define DEVICE_NAME_LEN (sizeof(DEVICE_NAME) - 1) static volatile unsigned char mfg_data[] = { 0x00, 0x00, 0xaa, 0xbb }; static const struct bt_data ad[] = { BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)), BT_DATA(BT_DATA_MANUFACTURER_DATA, mfg_data, 4) }; /* Set Scan Response data */ static const struct bt_data sd[] = { BT_DATA(BT_DATA_NAME_COMPLETE, DEVICE_NAME, DEVICE_NAME_LEN), }; static void bt_ready(int err) { if (err) { return; } /* Start advertising */ err = bt_le_adv_start(BT_LE_ADV_NCONN, ad, ARRAY_SIZE(ad), sd, ARRAY_SIZE(sd)); if (err) { return; } } const struct device *dev_ccs811; struct sensor_value co2, voc, voltage, current; const struct device *port0; void update_sensor_data() { //sensor_sample_fetch(dev_ccs811); //sensor_channel_get(dev_ccs811, SENSOR_CHAN_CO2, &co2); //sensor_channel_get(dev_ccs811, SENSOR_CHAN_VOC, &voc); //sensor_channel_get(dev_ccs811, SENSOR_CHAN_VOLTAGE, &voltage); //sensor_channel_get(dev_ccs811, SENSOR_CHAN_CURRENT, &current); printk("Co2: %d.%06dppm; VOC: %d.%06dppb\n", co2.val1, co2.val2, voc.val1, voc.val2); printk("Voltage: %d.%06dV; Current: %d.%06dA\n\n", voltage.val1, voltage.val2, current.val1, current.val2); mfg_data[0] = (uint8_t) co2.val1; mfg_data[1] = (uint8_t) co2.val2; mfg_data[2] = (uint8_t) voc.val1; mfg_data[3] = (uint8_t) voc.val2; gpio_pin_set(port0, 13, 0); //IO_1 NO UBLOX NINA B302 k_sleep(K_MSEC(100)); gpio_pin_set(port0, 13, 1); //IO_1 NO UBLOX NINA B302 k_sleep(K_MSEC(100)); gpio_pin_set(port0, 13, 0); //IO_1 NO UBLOX NINA B302 k_sleep(K_MSEC(1000)); } void main(void) { int err; port0 = device_get_binding("GPIO_0"); gpio_pin_configure(port0, 13, GPIO_OUTPUT); //IO_1 NO UBLOX NINA B302 // flash LED gpio_pin_set(port0, 13, 0); //IO_1 NO UBLOX NINA B302 k_sleep(K_MSEC(100)); gpio_pin_set(port0, 13, 1); //IO_1 NO UBLOX NINA B302 k_sleep(K_MSEC(100)); gpio_pin_set(port0, 13, 0); //IO_1 NO UBLOX NINA B302 k_sleep(K_MSEC(1000)); //dev_ccs811 = device_get_binding("CCS811"); /* Initialize the Bluetooth Subsystem */ err = bt_enable(bt_ready); if (err) { } while(1) { k_sleep(K_MSEC(4000)); update_sensor_data(); bt_le_adv_update_data(ad, ARRAY_SIZE(ad), NULL, 0); } }