Programando NINA B302 com Openthread, B112 COM ANT, ANT+

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

Baseado no link Raspi IoT | Home Smart Mesh

Por favor, participe do FORUM

Issues · nRFMesh/nRF52_Mesh (github.com)

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)

-1 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

nRF Connect for Desktop - Downloads - nordicsemi.com

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.

Thread | Home Smart Mesh

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

https://devzone.nordicsemi.com/cfs-file/__key/communityserver-discussions-components-files/4/7853.pca10059_5F00_bootloader_5F00_mbr_5F00_v1.0.1.hex

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

NRFCONNECT PARA DESKTOP

https://www.homesmartmesh.com/data/ot-rcp-com-1.2-usb_27.08.2021.hex.zip

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

Thread | Home Smart Mesh

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.

nRF5 SDK for Thread and Zigbee - nordicsemi.com

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.

Comandos do OpenThread

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.

Veja em Thread network technology - 03 Sniffing IEEE 802.15.4 packages (Thread and ZigBee) with Wireshark - YouTube

Requer BOOTLOADER já gravado

Grave com SEGGER J-LINK

https://devzone.nordicsemi.com/cfs-file/__key/communityserver-discussions-components-files/4/7853.pca10059_5F00_bootloader_5F00_mbr_5F00_v1.0.1.hex

Grave com NRFPROGRAMMER

HARDWARE

NCP conectado no RASPBERRY (serial)

SNIFFER conectado no PC (serial)

Alguns excelentes links

udp_example_sourcecode.zip - Google Drive

nRF5 SDK for Thread and Zigbee - nordicsemi.com

Wireshark · Go Deep.

NordicSemiconductor/nRF-Sniffer-for-802.15.4: nRF-based 802.15.4 sniffer (firmware and software) (github.com)

nRF Connect for Desktop - nordicsemi.com

Downloads

threads

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

ses.zip

Zephyr RTOS (NRFCONNECT) (VISUAL STUDIO CODE)

openthread_dongle.zip

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.

http://192.168.100.XXX:1880/ui/

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:

Construir uma rede Thread com placas nRF52840 e OpenThread

https://openthread.io/
https://www.threadgroup.org/What-is-Thread
https://github.com/openthread/openthread/tree/master/examples/apps/cli
https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.threadsdk.v0.8.0%2Fthread_cli_example.html
https://www.nordicsemi.com/Software-and-Tools/Software/nRF5-SDK-for-Thread-and-Zigbee
https://github.com/openthread/openthread/blob/2bce9557e62c451307d1a4d944c3eaf69f71573c/src/cli/README.md
https://codelabs.developers.google.com/codelabs/openthread-hardware/#6
https://store.makerdiary.com/blogs/tutorials/build-a-thread-network-with-nrf52840-mdk
https://blog.makerdiary.com/build-a-thread-network-with-nrf52840-mdk/

How can I restore the original bootloader of a pca10059? - Nordic Q&A - Nordic DevZone - Nordic DevZone (nordicsemi.com)

https://store.makerdiary.com/blogs/tutorials/build-a-thread-network-with-nrf52840-mdk

Comissionamento Externo para Android | OpenThread

memoria.pdf (upc.edu)

https://www.silabs.com/documents/public/training/wireless/hands-on-tutorial-with-openthread.pdf

nRF5 SDK for Thread and Zigbee - nordicsemi.com

Nordic Semiconductor Infocenter

pitaya-go/openthread-border-router.md at master · makerdiary/pitaya-go (github.com)

Nordic nRF52840 QR Code based Thread Commissioning · electronut

Thread network technology - 02 OpenThread CLI Example with Nordic nRF52840-dk - YouTube

External ping with border router implementation (google.com)

Teste de conectividade | OpenThread

Thread network technology - 03 Sniffing IEEE 802.15.4 packages (Thread and ZigBee) with Wireshark - YouTube

NINA-B3 series Data sheet (octopart.com)

OpenThread with Zephyr - building network - LPN Plant

Thread is the Future of Wireless Mesh - DevOps.com

https://nodered.org/docs/getting-started/windows

https://nodered.org/docs/getting-started/

http://jsonviewer.stack.hu/

--https://flows.nodered.org/node/node-red-dashboard

Thanks to all support

Wassim

nRFMesh/nRF52_Mesh: nRF52 custom RF mesh sensors and dongle firmware using nRF SDK (github.com)

WST & IoT

WSN & IoT - YouTube

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

Programando NINA B302 com Openthread, B112 COM ANT, ANT+

quarta-feira, 30 de março de 2022

U-BLOX NINA B112 transmitindo dados via ANT

quarta-feira, 9 de março de 2022

U-BLOX NINA B302 transmitindo dados via UDP com OpenThread