quarta-feira, 30 de março de 2022

U-BLOX NINA B112 transmitindo dados via ANT


O objetivo deste BLOG é demonstrar de forma resumida como é possível fazer com que o módulo U-BLOX NINA B112 possa rodar o protocolo de rede ANT e transmitir uma mensagem a cada 1 segundo para PC, o qual possui um conversor ANT para USB.

Ajuda
Qual é a diferença entre ANT e ANT+?

O ANT é um protocolo de rede sem fio de ultrabaixo consumo de energia desenvolvido especificamente para operar a 2,4 GHz. ANT+ é uma implementação do ANT e é um ecossistema de produtos interoperáveis ​​construídos em perfis de dispositivos.

O que é um perfil de dispositivo?

Um perfil de dispositivo ANT+ é uma especificação que define como os nós de rede ANT devem se conectar e compartilhar ou transferir atividades ou dados específicos de aplicativos entre si. Ao criar produtos nos perfis de dispositivos, o ecossistema de produtos ANT+ mantém a interoperabilidade interna que é mais fácil de vender e comprar.

É Bluetooth?

Embora o ANT e o Bluetooth Smart compartilhem muitas características (incluindo alcance e consumo de energia, e ambos rodam a 2,4 GHz), o ANT é seu próprio protocolo. O ANT oferece topologias de rede mais flexíveis e você pode obter chips e módulos capazes de executar ANT e Bluetooth Smart.

O ANT é apenas para aplicações esportivas?

Não, o ANT é geralmente aplicável e é adequado para muitas aplicações residenciais, comerciais e industriais de detecção e controle fora do esporte e fitness. A flexibilidade de topologia do ANT permite que ele se adapte a muitos casos de uso diferentes. O ANT+ é um ecossistema predominantemente para aplicativos de esporte e fitness que é construído e executado no ANT.

Como eu começo?

Existem muitos recursos para ajudá-lo a começar a usar ANT e ANT+.

Visite o site da ANT Wireless para acessar a documentação, ferramentas de desenvolvimento e projetos de referência.
Participe dos fóruns de desenvolvedores ANT para tirar suas dúvidas.
Inscreva-se como um adotante do ANT+ para acessar as especificações do perfil do dispositivo ANT+ e obter acesso a ferramentas de desenvolvimento específicas do ANT+.
Junte-se à ANT+ Alliance como membro para obter descontos na certificação de produtos ou para participar de grupos de trabalho técnicos que colaboram na evolução do portfólio de perfis de dispositivos ANT+.
Existe uma lista de produtos que suportam ANT+?

O site ANT Wireless hospeda um diretório de produtos pesquisável e filtrável que contém mais de 600 listagens de produtos certificados ANT+ disponíveis comercialmente.

Os dispositivos ANT+ e ANT podem se comunicar com a mesma tela?

sim

Dispositivos ANT+ se comunicam com monitores usando perfis de dispositivos. Devido às propriedades exclusivas do ANT, esses dispositivos podem se comunicar com vários monitores ao mesmo tempo. Qualquer monitor que possa entender um perfil de dispositivo ANT+ poderá obter os dados compartilhados desse perfil dos dispositivos aos quais está conectado.
Os dispositivos ANT ainda podem se comunicar com monitores que usam ANT+. Os monitores requerem um aplicativo que entenda como o dispositivo ANT em questão está tentando se comunicar.
O uso do programa de desenvolvedor Connect IQ abre nosso ecossistema de produtos para a comunicação com dispositivos ANT e ANT+ simultaneamente e de forma simples.

licenças

A chave de licença é usada para o próprio dispositivo de software. Os cabeçalhos devem incluir uma chave de licença de avaliação que você pode simplesmente descomentar. Isso simplesmente permite que você use o código.

A chave de rede é um número de 8 bytes que identifica uma rede sem fio no ANT. O fornecido no link acima possui as chaves para ANT+, ANT-FS e a chave pública.

Você precisará da chave de licença para habilitar o software e da chave de rede para ingressar nas redes corretas

Testando no u-blox NINA B112

O que foi utilizado de Hardware

-1 U-BLOX NINA B112
-1 PLACA BREAKOUT
-1 J-LINK SEGGER 


Breakout U-BLOX NINA B112


Adquirimos então os seguintes componentes


Montado ficou assim


O esquema elétrico é este


Algumas características do BREAKOUT

-Botão de RESET;
-Botão de Modo BOOTLOADER (W102).

Use o gravador SEGGER JLINK para gravar o BREAKOUT com módulo U-BLOX NINA B112, conecte nos pinos do SWCLK (pino 7) e SWDIO (pino 9) do SEGGER JLINK nos pinos  SWDCLK e SWDIO do BREAKOUT (pinos nas laterais, próximo à antena). Não esquecer de ligar os GND do BREAKOUT no GND do SEGGER JTAG, bem como alimentar o BREAKOUT com 3.3V.



Ligue os pinos SWD DIO e CLK ...
...nestes pinos da placa BREAKOUT

O que foi utilizado de Software

Segger Studio
-->Instale o SEGGER J-Link
-->Instale o SEGGER STUDIO
-->Baixe o SDK da NORDIC
-->Execute o SEGGER STUDIO

Tenha em mãos o SoftDevice S212 (podes gravar antes com J-FLASH)





Gravando SoftDevice

Basicamente foi seguido o Roteiro do link abaixo


Recebendo Pacotes a cada 1 segundo (contador)

Digikey - Dongle

Driver Dongle


Suporte: suporte@smartcore.com.br (dúvidas básicas)

Fontes:


Thanks to all support
Curtis Malainey

Sobre a SMARTCORE

A SmartCore fornece módulos para comunicação wireless, biometria, conectividade, rastreamento e automação.
Nosso portfólio inclui modem 2G/3G/4G/NB-IoT/Cat.M, satelital, módulos WiFi, Bluetooth, GNSS / GPS, Sigfox, LoRa, leitor de cartão, leitor QR code, mecanismo de impressão, mini-board PC, antena, pigtail, LCD, bateria, repetidor GPS e sensores.
Mais detalhes em www.smartcore.com.br

quarta-feira, 9 de março de 2022

U-BLOX NINA B302 transmitindo dados via UDP com OpenThread

U-BLOX NINA B302 transmitindo dados via UDP com OpenThread


O objetivo deste BLOG é demonstrar de forma resumida como é possível fazer com que o módulo U-BLOX NINA B302 possa rodar o OpenThread e transmitir uma mensagem via UDP para o Raspberry. Foram utilizados 3 módulos Breakout U-BLOX NINA B302 para os testes, um como NCP e outro como FTD.

Não é MESH

Exemplos com CLI, SEGGER e ZEPHYR NRFCONNECT


Por favor, participe do FORUM


A Internet das Coisas (IoT) visa transformar a vida das pessoas através de casas inteligentes e empresas. Em casa, o objetivo é uma rede de aparelhos conectados, luzes, controles climáticos, segurança e sistemas de entretenimento, que trabalham juntos para tornar a vida mais conveniente e gratificante para os consumidores. Em edifícios comerciais, a IoT visa melhorar a eficiência, funcionalidade, automação e segurança de edifícios, como escritórios, instalações de saúde, hotéis e escolas.

O encadeamento foi desenvolvido para atender aos desafios exclusivos de interoperabilidade, segurança, energia e arquitetura da IoT.

Thread traz a Internet para a Internet das Coisas (IoT). É por isso que o Thread foi projetado com os padrões abertos e comprovados da Internet para criar uma rede de malha baseada em IPv6 (Internet Protocol versão 6), com a 6LoWPAN como base.

As interfaces padronizadas e os protocolos IP do Thread beneficiam os desenvolvedores de ecossistema da IoT de várias maneiras:

Construa um sistema sem fio rapidamente. Como uma rede IP completa de ponta a ponta, o Thread acelera o ritmo no qual os aplicativos e serviços são desenvolvidos, já que o mesmo conjunto avançado de ferramentas disponíveis para a Internet pode ser usado para desenvolver dispositivos e sistemas Thread.

Produtos e plataformas à prova de futuro. O thread é independente da camada de aplicativos, o que significa que a camada de aplicativo e os serviços de nuvem nos dispositivos Thread podem ser alterados com o tempo. Os dispositivos de thread podem crescer e evoluir com os ecossistemas e o setor, enquanto a base principal de IP será bem suportada indefinidamente.

Crie facilmente um ecossistema flexível, independente de plataforma. Os desenvolvedores podem selecionar várias pilhas certificadas, plataformas de silício ou módulos para criar produtos Thread ou escolher entre muitos produtos de thread certificados para criar um ecossistema. De qualquer forma, o ecossistema aberto, interoperável e diversificado da Thread oferece flexibilidade de longo prazo.

Fique conectado aos usuários finais e dados. O thread é baseado em IP, permitindo que os dispositivos falem diretamente com a nuvem, além de outros produtos IoT, controladores de automação residencial e predial e dispositivos móveis. Ter essa conexão direta permite que os fabricantes mantenham uma conexão com seus produtos e seus usuários, ao mesmo tempo em que possibilita acesso valioso a dados de uma ampla variedade de dispositivos inter-setoriais conectados.


A Internet é executada em IP. De telefones a roteadores a conexões em todo o mundo, o IP é a tecnologia que permite que os dispositivos se comuniquem diretamente entre si, independentemente de quais tecnologias de conectividade eles usam (por exemplo, ethernet, Wi-Fi, 4G e LTE). E, muitas vezes, suas comunicações viajam sem problemas por todas essas tecnologias de rede, interligadas por meio de IP.

Thread traz conectividade IP para os dispositivos sem fio de baixa potência que compõem a IoT, seja em casas inteligentes ou edifícios comerciais.

Os dispositivos thread integram-se perfeitamente a redes IP maiores, tornando-se parte integrante de dispositivos como Ethernet, Wi-Fi, celular ou várias outras opções de rede IP.
Os dispositivos de thread não precisam de gateways ou tradutores proprietários, mas podem fazer conexões diretas com os outros dispositivos com os quais estão interagindo e com a Internet.

Isso reduz as necessidades e investimentos em infraestrutura, possíveis pontos de falha e encargos de manutenção, ao mesmo tempo em que permite a segurança de ponta a ponta do dispositivo para a nuvem. Também facilita a conexão de produtos Thread a dispositivos pessoais, como telefones celulares e tablets.

O Thread é um protocolo de rede de malha sem fio de baixa potência, baseado no protocolo IP (protocolo de Internet) universalmente suportado e construído usando padrões abertos e comprovados.
O segmento permite comunicações de dispositivo para dispositivo e de dispositivo para a nuvem e conecta de forma confiável centenas (ou milhares) de produtos e inclui recursos de segurança obrigatórios.
As redes de encadeamentos não têm ponto único de falha, podem se auto-recuperar e reconfigurar quando um dispositivo é adicionado ou removido, e são simples de configurar e usar.
O encadeamento é baseado no padrão de rádio IEEE 802.15.4 amplamente aceito, projetado desde o início para consumo de energia extremamente baixo e baixa latência.

Um facilitador chave para a IoT é a interoperabilidade. O segmento aborda esse desafio fornecendo um programa de certificação que valida a conformidade de um dispositivo com a especificação, bem como sua interoperabilidade em relação a uma rede combinada composta de várias pilhas certificadas.
 OpenThread liberado pelo Nest é uma implementação de código aberto do Thread®. A Nest lançou o OpenThread para tornar a tecnologia de rede usada nos produtos Nest mais amplamente disponível para os desenvolvedores, a fim de acelerar o desenvolvimento de produtos para a casa conectada.

Com uma camada de abstração de plataforma estreita e um pequeno espaço de memória, o OpenThread é altamente portátil. Ele suporta designs de sistema no chip (SoC) e de coprocessador de rede (NCP).


Mais sobreThread!

O Thread® é um protocolo de rede baseado em IPv6 projetado para dispositivos de Internet das Coisas de baixa potência em uma rede de malha sem fio IEEE 802.15.4-2006, comumente chamada de Wireless Personal Area Network (WPAN). Thread é independente de outros protocolos de rede de malha 802.15.4, como ZigBee, Z-Wave e Bluetooth LE.

Os principais recursos do segmento incluem:

Simplicidade - Instalação, inicialização e operação simples

Segurança - Todos os dispositivos em uma rede Thread são autenticados e todas as comunicações são criptografadas

Confiabilidade - Rede de malha de autorecuperação, sem ponto único de falha, e técnicas de espalhamento espectral para fornecer imunidade à interferência

Eficiência - Dispositivos de rosca de baixa potência podem dormir e operar com energia da bateria por anos

Escalabilidade - redes de encadeamento podem escalar até centenas de dispositivos

Se você é novo no Thread, entender os fundamentos é fundamental para usar o OpenThread em seus próprios aplicativos. O objetivo deste blog é explicar os conceitos por trás do Thread e como ele funciona e fornecer um trampolim para o desenvolvimento do OpenThread.

Supõe-se que você tenha um bom conhecimento prático do seguinte:

IEEE 802.15.4
Conceitos de rede e roteamento

IPv6

O protocolo de rede Thread foi projetado para facilitar e conectar com segurança centenas de dispositivos uns aos outros e a nuvem usando protocolos reais da Internet por um baixo consumo de energia, rede de malha sem fio. Construído em padrões abertos e com Protocolos IPv6 / 6LoWPAN, a abordagem da Thread para redes sem fio rede oferece uma rede de malha segura e confiável sem ponto único de falha, conectividade simples e baixa potência. o Padrão de linha é uma pilha construída sobre o bem estabelecido protocolos e tecnologias, como IEEE 802.15.4, 6LoWPAN, IPv6 e UDP. Thread fornece meios para segurança de rede e comissionamento, mas não especifica o protocolo da aplicação. É um protocolo de rede semelhante ao WiFi, mas projetado para baixo potência e recursos dispositivos restritos. No entanto, o Thread Grupo tem vários contatos com diferentes camadas de aplicação por exemplo, OCF, Zigbee dotdot

Características

O OpenThread implementa todas as camadas de rede Thread (IPv6, 6LoWPAN, IEEE 802.15.4 com segurança MAC, estabelecimento de link de malha, roteamento de malha) e funções de dispositivo, bem como suporte a roteador de borda.

SERVIÇOS DE APLICAÇÃO

Configuração IPv6 e interface de dados brutos
Soquetes UDP
Cliente e servidor CoAP
Cliente e servidor DHCPv6
Cliente DNSv6

BORDER ROUTER
Web UI para configuração e gerenciamento
Agente de limite de linha para apoiar um comissário externo
NAT64 para se conectar a redes IPv4

Módulos Utilizados

-1 NCP Dongle (conectado na USB do Raspberry) - U-BLOX NINA B302
-1 U-BLOX NINA B302 (FTD)
-U-BLOX NINA B302 (SNIFFER)
Breakout U-BLOX NINA B302

Resumo de Instalação

Instale o SEGGER J-Link

Usamos o SEGGER J-Link para programar as placas U-BLOX NINA B302, que possuem módulos JTAG onboard. 
Baixe o pacote apropriado para sua máquina e instale-o no local adequado. 

Instalar as ferramentas de linha de comando nRF5x

OpenThread 

Antes de começar, você pode querer percorrer o OpenThread Simulation Codelab, para se familiarizar com os conceitos básicos do Thread e com o OpenThread CLI.

Terminais de porta serial

Qualquer outro software de terminal pode ser usado, no caso foi utilizado  o Teraterm.

BorderRouter (Raspberry)

Baixe uma imagem do Linux para Raspberry, coloque ele na rede e então execute
curl https://raw.githubusercontent.com/HomeSmartMesh/raspi/master/get_raspi.sh -o get_raspi.sh && sudo bash get_raspi.sh
cd raspi
sudo bash setup.sh
O Raspberry solicitará boot algumas vezes! Aguarde a instalação!

Pronto, todas as ferramentas para OpenThread foram instaladas e OTBR (OpenThread Border Router) server está pronto para ser acessado, permitindo conecta uma rede Thread a outras redes baseadas em IP, como Wi-Fi ou Ethernet. 

O Border Router destina-se a fins de desenvolvimento, para facilitar que os desenvolvedores conectem sua rede Thread à Internet na fase de desenvolvimento. Ele também suporta o procedimento de comissionamento nativo thread utilizando NFC para iniciar o processo. Também é suportada a funcionalidade do Border Router, que permite a realização de um procedimento de comissionamento externo.

Agora será necessário que você tenha um DONGLE RCP OpenThread conectado na USB do seu raspberry, no caso, utilizei o U-BLOX NINA B302 via USB.


Grave o firmware  com o Segger J-LINK no U-BLOX NINA B302


Será então criado um Disco Virtual...com o NRFCONNECT DESKTOP - PROGRAMMER, ache o disco virtual e copie o arquivo

NRFCONNECT PARA DESKTOP


Pronto, agora conecte no USB do seu Raspberry e com o comando lsusb voce é verá o DONGLE RCP na lista de dispositivos USB.


Siga o roteiro abaixo para criar a Rede Thread (FORM)

NETWORK FORM 


Configurando os FTDs (end devices que querem entrar na tua rede Thread)

Você pode pegar o exemplo no OpenThread no SDK OpenThread a Nordic, compilar e gravar com o SEGGER STUDIO, já com função USB nativa, criando assim uma COMM virtual para interagir com NCP.

C:\openthread\examples\thread\cli\ftd\usb\pca10056\blank\ses\thread_cli_ftd_usb_pca10056.ses

SEGGER STUDIO

O USB nativo permite o uso do USB CDC ACM como um transporte serial entre o U-BLOX NINA B302 e o host, no caso, um terminal burro,  o Teraterm.
Circuito construído (FTD e NCP)

Da esquerda para direita, NCP e FTD

NCP no RASPBERRY

Vamos por em prática

Use a GUI da Web

Agora, você pode usar a GUI da Web do OpenThread Border Router (OTBR) para configurar e formar, ingressar ou verificar o status de uma rede Thread.

Conecte-se à rede Wi-Fi BorderRouter-AP e acesse a GUI da Web visitando o endereço IPv4 local do OTBR em um navegador móvel:

Formar uma rede de threads

Use a opção de menu Formulário para criar uma nova rede Thread.

FORM

Preparar o dispositivo FTD

Conecte a nova placa U-BLOX NINA B302 ao seu PC usando o cabo USB. Abra o terminal burro (Teraterm) para ter acesso à ela.

> panid 0x1234
Done
> channel 15
Done
> networkname OpenThreadDemo
Done
> extpanid 1111111122222222
Done
> masterkey
00112233445566778899aabbccddeeff
Done
> ifconfig up
Done
> thread start
Done
> state
child
Done
> ipaddr
fd11:1111:1122:0:0:ff:fe00:4800
fd11:22:0:0:f8f8:d11:2fe1:64c
fd11:1111:1122:0:86ab:6ec9:2c76:b685
fe80:0:0:0:a8f7:dc05:2d33:c107
> udp send ff02::1 4243 miguelito
Done

MANDANDO DADO VIA UDP

Algum tempo depois (após o primeiro udp send ???)

> state
router
Done

No lado do Raspberry

pi@raspberrypi:~$ sudo ot-ctl
> udp open
Done
> udp bind :: 4243
Done
> 32 bytes from fe80:0:0:0:f850:8951:37a0:a4ff 49155 miguelito


Testes contínuos



Verifique a conectividade com a Internet

Teste a conectividade entre o dispositivo FTD na rede Thread e a Internet executando ping em um endereço IPv4 público. Para alcançar o endereço IPv4 do dispositivo Thread, um prefixo conhecido de 64:ff9b::/96e um endereço IPv4 do destino são usados.

Por exemplo, para pingar o DNS do Google 8.8.8.8 a partir do endereço IPv6, anexe uma forma hexadecimal do IPv6 ao prefixo conhecido, resultando em: 64:ff9b::808:808.

> ping 64:ff9b::808:808
 > 16 bytes de 64:ff9b:0:0:0:0:808:808: icmp_seq=1 hlim=43 time=234ms

PING PARA DNS DA GOOGLE

> ping 64:ff9b::808:808
 > 16 bytes de 64:ff9b:0:0:0:0:808:808: icmp_seq=2 hlim=43 time=229ms

> ping 64:ff9b::808:808
 > 16 bytes de 64:ff9b:0:0:0:0:808:808: icmp_seq=3 hlim=44 time=225ms

> ping 64:ff9b::808:808
 > 16 bytes de 64:ff9b:0:0:0:0:808:808: icmp_seq=4 hlim=45 time=221ms

Enviando pacotes UDP como OPENCPU no SEGGER STUDIO - Nordic OpenThread SDK. Neste exemplo, quando você forcar o GPIO1, GPIO2, GPIO3 ou GPIO4 do U-BLOX NINA B302, será enviado o texto "MIGUEL"

Altere PCA10056.h para

#define LEDS_LIST { LED_1, LED_2, LED_3, LED_4 }

#define LEDS_INV_MASK  LEDS_MASK

#define BSP_LED_0      24
#define BSP_LED_1      25
#define BSP_LED_2      32
#define BSP_LED_3      3

#define BUTTONS_NUMBER 4

#define BUTTON_1       13
#define BUTTON_2       14
#define BUTTON_3       15
#define BUTTON_4       16
#define BUTTON_PULL    NRF_GPIO_PIN_PULLUP

U-BLOX NINA B302 GPIO

Uma vez criado uma rede com FORM, pegue o IPV6 (Threads) do Raspberry, compile o programa abaixo e force um dos pinos para GROUND.



BROADCASTING

pi@raspberrypi:~$ sudo ot-ctl
> ipmaddr
ff02:0:0:0:0:0:0:16
ff33:40:fd56:3f11:7605:c795:0:1
ff32:40:fd56:3f11:7605:c795:0:1
ff02:0:0:0:0:0:0:2
ff03:0:0:0:0:0:0:2
ff02:0:0:0:0:0:0:1
ff03:0:0:0:0:0:0:1
ff03:0:0:0:0:0:0:fc
Done
> udp open
Done
> udp bind :: 4567
Done
> 6 bytes from fe80:0:0:0:40e0:d64b:ade7:336 49154 MIGUEL
6 bytes from fe80:0:0:0:40e0:d64b:ade7:336 49155 MIGUEL
6 bytes from fe80:0:0:0:40e0:d64b:ade7:336 49156 MIGUEL
6 bytes from fe80:0:0:0:40e0:d64b:ade7:336 49157 MIGUEL

O programa compilado no SEGGER foi este abaixo, alterei

C:\openthread\examples\thread\cli\ftd\uart\pca10056\blank\ses

#include "app_scheduler.h" #include "app_timer.h" #include "nrf_log_ctrl.h" #include "nrf_log.h" #include "nrf_log_default_backends.h" #include "bsp.h" #include "thread_utils.h" #include <openthread/thread.h> #include <openthread/udp.h> #include <openthread/cli.h> #define SCHED_QUEUE_SIZE 32 /**< Maximum number of events in the scheduler queue. */ #define SCHED_EVENT_DATA_SIZE APP_TIMER_SCHED_EVENT_DATA_SIZE /**< Maximum app_scheduler event size. */ #define MY_THREAD_PANID 0x1234 #define MY_THREAD_EXT_PANID {0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22} #define MY_THREAD_NETWORK_NAME "OpenThreadDemo" static void timer_init(void){ uint32_t err_code = app_timer_init(); APP_ERROR_CHECK(err_code); } static void log_init(void){ ret_code_t err_code = NRF_LOG_INIT(NULL); APP_ERROR_CHECK(err_code); NRF_LOG_DEFAULT_BACKENDS_INIT(); } static void thread_instance_init(void){ thread_configuration_t thread_configuration = { .radio_mode = THREAD_RADIO_MODE_RX_ON_WHEN_IDLE, .autocommissioning = false, .autostart_disable = true, }; thread_init(&thread_configuration); thread_cli_init(); } static void scheduler_init(void){ APP_SCHED_INIT(SCHED_EVENT_DATA_SIZE, SCHED_QUEUE_SIZE); } void setNetworkParameter(void){ otInstance * myOtInstance = thread_ot_instance_get(); if(!otDatasetIsCommissioned(myOtInstance)){ otOperationalDataset aDataset; memset(&aDataset, 0, sizeof(otOperationalDataset)); aDataset.mActiveTimestamp = 0; aDataset.mComponents.mIsActiveTimestampPresent = true; aDataset.mChannel = 15; aDataset.mComponents.mIsChannelPresent = true; aDataset.mChannelMask = (otChannelMask)0x7fff800; aDataset.mComponents.mIsChannelMaskPresent = true; aDataset.mPanId = (otPanId)MY_THREAD_PANID; aDataset.mComponents.mIsPanIdPresent = true; uint8_t extPanId[OT_EXT_PAN_ID_SIZE] = MY_THREAD_EXT_PANID; memcpy(aDataset.mExtendedPanId.m8, extPanId, sizeof(aDataset.mExtendedPanId)); aDataset.mComponents.mIsExtendedPanIdPresent = true; uint8_t key[OT_MASTER_KEY_SIZE] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}; memcpy(aDataset.mMasterKey.m8, key, sizeof(aDataset.mMasterKey)); aDataset.mComponents.mIsMasterKeyPresent = true; static char aNetworkName[] = MY_THREAD_NETWORK_NAME; size_t length = strlen(aNetworkName); ASSERT(length <= OT_NETWORK_NAME_MAX_SIZE); memcpy(aDataset.mNetworkName.m8, aNetworkName, length); aDataset.mComponents.mIsNetworkNamePresent = true; uint8_t meshLocalPrefix[OT_MESH_LOCAL_PREFIX_SIZE]= {0xfd, 0x56, 0x3f, 0x11, 0x76, 0x05, 0xc7, 0x95}; memcpy(aDataset.mMeshLocalPrefix.m8, meshLocalPrefix, sizeof(aDataset.mMeshLocalPrefix)); aDataset.mComponents.mIsMeshLocalPrefixPresent = true; otDatasetSetActive(myOtInstance, &aDataset); } } static void thread_network_start(void){ otInstance *myInstance; myInstance = thread_ot_instance_get(); /* Start the Thread network interface (CLI cmd > ifconfig up) */ otIp6SetEnabled(myInstance, true); /* Start the Thread stack (CLI cmd > thread start) */ otThreadSetEnabled(myInstance, true); } static void udp_send(void){ otError error = OT_ERROR_NONE; const char *buf = "MIGUEL"; otInstance *myInstance; myInstance = thread_ot_instance_get(); otUdpSocket mySocket; otMessageInfo messageInfo; memset(&messageInfo, 0, sizeof(messageInfo)); otIp6AddressFromString("ff02::1", &messageInfo.mPeerAddr); messageInfo.mPeerPort = 4567; do{ error = otUdpOpen(myInstance, &mySocket, NULL, NULL); if (error != OT_ERROR_NONE){ break; } otMessage *test_Message = otUdpNewMessage(myInstance, NULL); error = otMessageAppend(test_Message, buf, (uint16_t)strlen(buf)); if (error != OT_ERROR_NONE){ break; } error = otUdpSend(&mySocket, test_Message, &messageInfo); if (error != OT_ERROR_NONE){ break; } error = otUdpClose(&mySocket); }while(false); if (error == OT_ERROR_NONE){ otCliOutputFormat("Send.\0"); }else{ NRF_LOG_INFO("udpSend error: %d\r\n", error); } } /*Button handler*/ static void bsp_event_handler(bsp_event_t event){ switch (event) { case BSP_EVENT_KEY_0: udp_send(); break; case BSP_EVENT_KEY_1: udp_send(); break; case BSP_EVENT_KEY_2: udp_send(); break; case BSP_EVENT_KEY_3: udp_send(); break; default: return; // no implementation needed } } int main(int argc, char *argv[]){ log_init(); scheduler_init(); timer_init(); thread_instance_init(); setNetworkParameter(); thread_network_start(); uint32_t err_code = bsp_init(BSP_INIT_BUTTONS, bsp_event_handler); APP_ERROR_CHECK(err_code); while (true) { thread_process(); app_sched_execute(); if (NRF_LOG_PROCESS() == false) { thread_sleep(); } } }


Depurando Protocolo

Você pode instalar um DONGLE com o U-BLOX NINA B302 contendo um SNIFFER e abri-lo com WIRESHARK.


Requer BOOTLOADER já gravado
Grave com SEGGER J-LINK
Grave com NRFPROGRAMMER

HARDWARE

NCP conectado no RASPBERRY (serial)
SNIFFER conectado no PC (serial)

Alguns excelentes links


Downloads

Testes com Visual Code + NRFCONNECT (ZEPHYR)

NRFCONNECT ZEPHYR NO VISUAL STUDIO CODE

Abaixo o programa exemplo, a cada 3 segundos envia o MAC do U-BLOX NINA B302 mais um  Contador

#include <zephyr.h> #include <logging/log.h> #include <net/socket.h> #include <net/net_if.h> #include <stdio.h> #include <drivers/gpio.h> #include <net/openthread.h> #include <openthread/thread.h> #include "hal/nrf_radio.h" #include "udp_client.h" LOG_MODULE_REGISTER(main, LOG_LEVEL_DBG); #define SLEEP_TIME_MS 10000 void main(void) { long unsigned int id0 = NRF_FICR->DEVICEID[0];//just for type casting and readable printing long unsigned int id1 = NRF_FICR->DEVICEID[1]; int count = 0; //todo udp bind, listen and print while (1) { char message[250]; int size = sprintf(message,"thread_dongles/%04lX%04lX{\"alive\":%d}",id0,id1,count); send_udp(message,size); printf("%s\n",message); count++; k_sleep(K_MSEC(3000)); } }

Em  udp_client.c  altere

#define CONFIG_PEER_PORT 4567

Abaixo o configuração do Projeto (prj.conf)

# Logging CONFIG_LOG=y CONFIG_LOG_BACKEND_RTT=y CONFIG_LOG_BACKEND_UART=y CONFIG_BOOT_BANNER=y CONFIG_USE_SEGGER_RTT=y CONFIG_CONSOLE=y CONFIG_UART_CONSOLE=y CONFIG_RTT_CONSOLE=y #printf CONFIG_NEWLIB_LIBC=y CONFIG_NEWLIB_LIBC_FLOAT_PRINTF=y CONFIG_PRINTK=y # Network CONFIG_NETWORKING=y CONFIG_NET_L2_OPENTHREAD=y # Full Thread Device CONFIG_OPENTHREAD_SHELL=n CONFIG_OPENTHREAD_FTD=y CONFIG_OPENTHREAD_POLL_PERIOD=600000 CONFIG_OPENTHREAD_MANUAL_START=n CONFIG_OPENTHREAD_CHANNEL=15 CONFIG_OPENTHREAD_PANID=4660 CONFIG_OPENTHREAD_NETWORK_NAME="OpenThreadDemo" CONFIG_OPENTHREAD_XPANID="11:11:11:11:22:22:22:22"
#Colocado no Kconfig #CONFIG_OPENTHREAD_MASTERKEY="00:11:22:33:44:55:66:77:88:99:aa:bb:cc:dd:ee:ff"
#alterado no udp_client.c #CONFIG_NET_CONFIG_MY_IPV6_ADDR="fdde:ad00:beef::1" #CONFIG_NET_CONFIG_PEER_IPV6_ADDR="ff02::1" #CONFIG_PEER_PORT=4242 # Disable certain parts of Zephyr IPv6 stack CONFIG_NET_IPV6_NBR_CACHE=n CONFIG_NET_IPV6_MLD=n # Kernel options CONFIG_MAIN_STACK_SIZE=2048 CONFIG_INIT_STACKS=y # Generic networking options CONFIG_NET_UDP=y CONFIG_NET_TCP=n CONFIG_NET_SOCKETS=y CONFIG_NET_SOCKETS_POSIX_NAMES=y CONFIG_NET_SOCKETS_POLL_MAX=4 CONFIG_NET_CONNECTION_MANAGER=n # Network buffers CONFIG_NET_PKT_RX_COUNT=16 CONFIG_NET_PKT_TX_COUNT=16 CONFIG_NET_BUF_RX_COUNT=80 CONFIG_NET_BUF_TX_COUNT=80 CONFIG_NET_CONTEXT_NET_PKT_POOL=y # IP address options CONFIG_NET_IF_UNICAST_IPV6_ADDR_COUNT=3 CONFIG_NET_IF_MCAST_IPV6_ADDR_COUNT=4 CONFIG_NET_MAX_CONTEXTS=10










































WireShark


RaspBerry


Envio dos Pacotes

Novos testes - SOCAT

-1 NCP Dongle (conectado na USB do Raspberry) - U-BLOX NINA B302
-3 U-BLOX NINA B302 (FTD)

Com SOCAT

pi@raspberrypi:~$ socat UDP6-LISTEN:4567,fork STDOUT
-bash: socat: command not found
pi@raspberrypi:~$ socat
-bash: socat: command not found
pi@raspberrypi:~$ sudo apt-get install socat
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
The following NEW packages will be installed:
  socat
0 upgraded, 1 newly installed, 0 to remove and 0 not upgraded.
Need to get 333 kB of archives.
After this operation, 1,326 kB of additional disk space will be used.
Get:1 http://raspbian.c3sl.ufpr.br/raspbian bullseye/main armhf socat armhf 1.7.4.1-3 [333 kB]
Fetched 333 kB in 2s (218 kB/s)
Selecting previously unselected package socat.
(Reading database ... 73698 files and directories currently installed.)
Preparing to unpack .../socat_1.7.4.1-3_armhf.deb ...
Unpacking socat (1.7.4.1-3) ...
Setting up socat (1.7.4.1-3) ...
Processing triggers for man-db (2.9.4-2) ...
pi@raspberrypi:~$



Projetos (source code)

Segger
Zephyr RTOS (NRFCONNECT) (VISUAL STUDIO CODE)

Novos testes - NODE-RED

O código fonte do projeto do NRFCONNECT Visual Code (ZEPHYR)  acima foi  modificado para enviar o seguinte JSON

int size = sprintf(message,"{\"Fio\": \"%04lX%04lX\",\"Voltas\": %d}",id0,id1,count);


{"Fio": "MAC","Voltas:",XXX}


Foi então criado uma aplicação no NODE-RED que fica escutando na porta UDP 4567 e encaminhando para o uma aplicação DASHBOARD dentro do próprio NODE-RED (deve ser ser instalado - node-red-contrib)



var msg_mac = { payload: msg.payload.Fio };
var msg_voltas = { payload: msg.payload.Voltas };
return [ msg_mac, msg_voltas];



Projeto Node-Red

[
    {
        "id": "b363b80001c6c454",
        "type": "ui_numeric",
        "z": "8e5f7aac6a2798e4",
        "name": "",
        "label": "numeric",
        "tooltip": "",
        "group": "6a1f86f641546c76",
        "order": 1,
        "width": "6",
        "height": "3",
        "wrap": false,
        "passthru": true,
        "topic": "topic",
        "topicType": "msg",
        "format": "{{msg_voltas}}",
        "min": 0,
        "max": "99999",
        "step": 1,
        "className": "",
        "x": 710,
        "y": 560,
        "wires": [
            []
        ]
    },
    {
        "id": "6a1f86f641546c76",
        "type": "ui_group",
        "name": "Default",
        "tab": "f3e5de20f6237cf4",
        "order": 1,
        "disp": true,
        "width": "6",
        "collapse": false,
        "className": ""
    },
    {
        "id": "f3e5de20f6237cf4",
        "type": "ui_tab",
        "name": "Home",
        "icon": "dashboard",
        "disabled": false,
        "hidden": false
    }
]

Como resultado tem-se

Interface de Sensores (Dashboard) no servidor WEB sendo acessado localmente.

Pacote Dashboard para NODE-RED

Node-Red recebendo pacotes de 3 nina u-blox B302


Suporte: suporte@smartcore.com.br (dúvidas básicas)

Fontes:


Thanks to all support
Wassim

WST & IoT

Sobre a SMARTCORE

A SmartCore fornece módulos para comunicação wireless, biometria, conectividade, rastreamento e automação.
Nosso portfólio inclui modem 2G/3G/4G/NB-IoT/Cat.M, satelital, módulos WiFi, Bluetooth, GNSS / GPS, Sigfox, LoRa, leitor de cartão, leitor QR code, mecanismo de impressão, mini-board PC, antena, pigtail, LCD, bateria, repetidor GPS e sensores.
Mais detalhes em www.smartcore.com.br