U-BLOX NINA W106 PROGRAMADO COM ATMOSPHERE IOT

O objetivo deste BLOG é demonstrar como é possível programar o U-BLOX NINA W106 com o
ATMOSPHERE. Neste exemplo faremos um LED piscar a cada 1 segundo e outro LED ser
controlado por BLE.

About Atmosphere IoT

A Internet das Coisas surgiu como a megatendência da tecnologia de hoje, prometendo reinventar a maneira como as pessoas vivem, trabalham e se divertem. De empolgantes dispositivos inteligentes para o consumidor a sistemas de manufatura ciberfísicos inteiramente novos, os inovadores estão encontrando maneiras de remodelar o comportamento do consumidor e redefinir a vantagem competitiva dos negócios. Os especialistas do setor prevêm que um trilhão de dispositivos estará conectado até 2035.

Se for esse o caso, temos muito trabalho a fazer.

Algumas coisas nos negócios não mudam. O sucesso ainda se concentra em conhecer seu cliente, entender o problema que você está resolvendo e fornecer uma experiência atraente com um forte ROI. No entanto, pode ser assustador para os inovadores envolverem-se em todas as diferentes peças e peças de tecnologia necessárias para criar uma solução IoT completa. Não há respostas que sirvam para todos e há muitos padrões para escolher. Os inovadores de IoT devem ser tecnicamente “multilíngues” - familiarizados com o idioma tecnológico não relacionado de eletrônicos embarcados, sensores, opções de dados sem fio, aplicativos de smartphone, middleware e computação em nuvem. É muito fácil ficar preso na pilha de tecnologia.

É aí que entra o Atmosphere.

Lançado pela primeira vez em 2015 e usado por milhares de inovadores, o Atmosphere oferece aos criadores de soluções IoT a maneira mais rápida e simples de criar, conectar e gerenciar sistemas integrados à nuvem completos. O Atmosphere convida você a entrar na via rápida para criar novos dados de IoT e colocá-los em aplicativos móveis e em nuvem - enquanto oferece a flexibilidade e controle para escolher as melhores “vias” de tecnologia para seu projeto.

Comece a mexer com o Atmosphere IoT Studio, nosso IDE online gratuito de arrastar e soltar, para construir todo o firmware do seu dispositivo, aplicativos móveis e painéis em nuvem com facilidade. Corporações globais líderes da indústria com uma vasta base de clientes de engenharia optaram por colocar uma etiqueta branca no Atmosphere IoT Studio para torná-lo disponível diretamente para suas bases de fãs registradas.

Também trabalhamos (ATMOSPHERE) diretamente com OEMs e integradores de soluções para criar seus próprios aplicativos de IoT gerenciados em nuvem em uma variedade de setores verticais e casos de uso. Servindo como seu hub para o gerenciamento de dispositivos, dados, usuários e aplicativos, o Atmosphere IoT Central permite iniciar implantações de IoT pequenas e escalonáveis. Você pode trazer seu próprio dispositivo e começar com pilotos comerciais de pequena escala sem quebrar seu orçamento. E mude para aplicativos de IoT dimensionados, seguros e com etiqueta branca, feitos sob medida para suas necessidades.

U-BLOX NINA W106

MONTAGEM

Adquirimos então os seguintes componentes

Montado ficou assim

O esquema elétrico é este

Algumas características do Kit

-Botão de RESET;
-Botão de Modo BOOTLOADER (W106);
-Plugável no PROTOBOARD;
-Acesso às várias GPIOS;

Pequena

Abaixo o roteiro para você seguir:

Entre no Ambiente do Atmosphere com sua conta e crie o projeto a seguir (ESP32-DEV-KIT-C, o mesmo core do U-BLOX NINA 106):

https://platform.atmosphereiot.com/

Neste exemplo, 2 elementos são criados, Element BLE GATT CHARACTERISTIC e Embedded Basic INTERVAL.

O primeiro permite que associe à CHARACTERISTIC um GPIO, o qual pode ser escrito via APP MOBILE.

O segundo permite que você associe um INTERVAL para um GPIO, o qual fará um TOGGLE a cada 1 segundo.

Seleção das GPIOS

Click em Program Firmware e será realizado um Download! Você pode também baixar o código fonte gerado (Mbed)

Gravando

Conecte no U-BLOX NINA W106 na serial e identifique a COMx.

ÓTIMA REFERÊNCIA PARA PINOS DO ARDUINO E PINOS (GPIOS) DO NINA W106

Consulte

NINA-W10 series, data sheet (u-blox.com)

Ligue os pino do U-BLOX NINA W106 nos LEDs

	BREAKOUT W106	COMPONENTE
GPIO14	IO14	LED1	GATT
GPIO12	IO12	LED2	INTERVAL
ESP32	UBLOX

MONTAGEM

EXECUÇÃO (INTERVAL)

INTERVAL 1 segundo

EXECUÇÃO (BLE) (LED ALTERADO PARA IO12)

Pode pode também já criar o APP via ATMOSPHERE IOT.

Mas para isto, é necessário que você entre com as credenciais do WIFI via APP da ATMOSPHERE, então será fará o registro no servidor e criar o APP.

APP do Usuário!

Vários sensores podem ser adicionados ao projeto

BME280

Consulte os pacotes da Atmosphere

https://atmosphereiot.com/pricing/

----------------------------------------------------------

Dúvidas:

suporte@smartcore.com.br

Referências:

https://platform.atmosphereiot.com/

Adafruit Mini IoT Home and Atmosphere IoT Studio (digikey.be)

NINA-W10 series, data sheet (u-blox.com)

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

U-BLOX NINA W106 SENDO PROGRAMADO .NET nanoFramework - MQTT CLIENT
Testado no VISUAL STUDIO 2015 e 2019

O objetivo deste BLOG é demonstrar como é possível utilizar o .NET nanoFramework para programar o módulo U-BLOX NINA W106. Foi utilizado o EVK-NINA-W1 para o teste e exemplo consiste em acessar um servidor MQTT (broker.hivemq.com), inscrever em um tópico GLOBAL e então fazer um publish em outro, tempos em tempos. Mensagens enviadas ao tópico serão exibidas.

MQTT

Para os dispositivos de Internet das Coisas (IoT), a conexão com a Internet é um requisito. A conexão com a Internet permite que os dispositivos trabalhem entre si e com serviços de backend. O protocolo de rede subjacente da Internet é o TCP/IP. Desenvolvido com base na pilha TCP/IP, o MQTT (Message Queue Telemetry Transport) tornou-se o padrão para comunicações de IoT.

"Ao contrário do Arduino (por exemplo) você pode fazer debug a sério do código que está executando. Sem necessitar de ligações ou hardware complexo com o JTAG no caso de programação C pura."

.NET nanoFramework é uma plataforma livre e de código aberto que permite a escrita de aplicativos de código gerenciados para dispositivos incorporados restritos. É adequado para muitos tipos de projetos, incluindo sensores de IoT, wearables, prova acadêmica de conceito, robótica, criações de hobistas/fabricantes ou até mesmo equipamentos industriais complexos. Isso torna o desenvolvimento dessas plataformas mais fácil, rápido e menos caro, dando aos desenvolvedores incorporados acesso a tecnologias e ferramentas modernas usadas pelos desenvolvedores de aplicativos desktop.

Os desenvolvedores podem aproveitar o poderoso e familiar Microsoft Visual Studio IDE e seu conhecimento .NET C# para escrever rapidamente código sem ter que se preocupar com os meandros de hardware de baixo nível de um microcontrolador. Os desenvolvedores do Desktop .NET se sentirão "em casa" e poderão usar suas habilidades no desenvolvimento de sistemas embarcados, ampliando o pool de desenvolvedores embarcados qualificados.

Ele inclui uma versão reduzida do CLR (Common Language Runtime, tempo de execução da linguagem comum .NET) e possui um subconjunto das bibliotecas de classe base .NET, juntamente com as APIs mais comuns incluídas na Universal Windows Platform (UWP) permitindo o reaproveitamento de códigos de aplicativos de desktop, aplicativos IoT Core, milhares de exemplos de código e projetos de código aberto.
Usando o Microsoft Visual Studio, um desenvolvedor pode implantar e depurar o código diretamente em hardware real.

O projeto conta com o apoio da Fundação .NET.

Roteiro baseado

https://docs.nanoframework.net/content/getting-started-guides/getting-started-managed.html

Instalando nanoFirmwareFlasher para copiar bootloader

GitHub - nanoframework/nanoFirmwareFlasher: 🛠 nano firmware flasher (nanoFramework toolbox)

É uma ferramenta global .NET Core CLI que permite atualizar um alvo nanoFramework com

nanoBooter, nanoCLR, aplicativo gerenciado ou arquivos de backup. Faz parte da caixa de

ferramentas nanoFramework, juntamente com outras várias ferramentas que são necessárias

no desenvolvimento, uso ou gerenciamento de repositório do nanoFramework. Um vez instalado é

necessário atualizar o UBLOX NINA W106.

Necessita .NET 5.0 Desktop Runtime (v5.0.3) e Download .NET Core 3.1 Runtime

Gravação do Bootloader

Sinal que está Rodando!

Baixe e instale o Visual Studio Community 2017/2019

Habilite o Workload do Desktop com .NET

Workload .NET

Instalando Visual Studio 2017

Habilite a Extension do .NET nanoFramework e instale

Getting Started Guide for managed code (C#) | nanoFramework Documentation

nanoFramework VS2017 Extension - Visual Studio Marketplace

Para o 2017 aparecerá VS2017

Crie um Projeto Blank com .NET nanoFramework (Blank Application nanoFramework)

Abra um repositório GIT para exemplos .NET

https://github.com/nanoframework/Samples.git

Vários exemplos em .NET nanoFramework

Abrindo o exemplo MQTT

Altere o código para

//
// Copyright (c) .NET Foundation and Contributors
// See LICENSE file in the project root for full license information.
//

using System;
using System.Diagnostics;
using System.Net.NetworkInformation;
using System.Text;
using System.Threading;
using uPLibrary.Networking.M2Mqtt;
using uPLibrary.Networking.M2Mqtt.Messages;

namespace TestMqtt
{
    public class Program
    {
        private const string c_SSID = "Andreia Oi Miguel 2.4G";
        private const string c_AP_PASSWORD = "xxxxxxxx";

        public static void Main()
        {
 
            MqttClient client = null;
            string clientId;
            bool running = true;

            // Wait for Wifi/network to connect (temp)
            SetupAndConnectNetwork();

            // Loop forever
            while (true)
            {
                try
                {
                    string BrokerAddress = "18.185.251.59";
                    client = new MqttClient(BrokerAddress);

                    // register a callback-function (we have to implement, see below) which is called by the library when a message was received
                    client.MqttMsgPublishReceived += Client_MqttMsgPublishReceived;
                    client.MqttMsgSubscribed += Client_MqttMsgSubscribed;

                    // use a unique id as client id, each time we start the application
                    //clientId = Guid.NewGuid().ToString();
                    clientId = new Guid(1, 23, 44, 32, 45, 33, 22, 11, 1, 2, 3).ToString();

                    Debug.WriteLine("Connecting MQTT");

                    client.Connect(clientId);

                    Debug.WriteLine("Connected MQTT");
                    // Subscribe topics
                    //     client.Subscribe(new string[] { "Test1", "Test2" }, new byte[] { 2, 2 });

                    byte[] message = Encoding.UTF8.GetBytes("Test message");
                    client.Publish("testtopic/nanoframework", message, MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE, false);

                    string[] SubTopics = new string[]
                    {
                        "testtopic/1"
                    };

                    Debug.WriteLine("Subscribe testtopic/1");
                    client.Subscribe(SubTopics, new byte[] { 2 });

                    Debug.WriteLine("Enter wait loop");
                    while (running)
                    {
                        Thread.Sleep(10000);
                        client.Publish("testtopic/nanoframework", message, MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE, false);
                    }

                    client.Disconnect();
                }
                catch (Exception ex)
                {
                    // Do whatever please you with the exception caught
                    Debug.WriteLine("Main exception " + ex.Message);
                }
                    
                // Wait before retry
                Thread.Sleep(10000);
            }
        }

        private static void Client_MqttMsgSubscribed(object sender, MqttMsgSubscribedEventArgs e)
        {
            Debug.WriteLine("Client_MqttMsgSubscribed ");
        }

        private static void Client_MqttMsgPublishReceived(object sender, MqttMsgPublishEventArgs e)
        {
            string topic  = e.Topic;

            string message = Encoding.UTF8.GetString(e.Message,0,e.Message.Length);

            Debug.WriteLine("Publish Received Topic:" + topic + " Message:" + message);

        }
        public static void SetupAndConnectNetwork()
        {
            NetworkInterface[] nis = NetworkInterface.GetAllNetworkInterfaces();
            if (nis.Length > 0)
            {
                // get the first interface
                NetworkInterface ni = nis[0];

                if (ni.NetworkInterfaceType == NetworkInterfaceType.Wireless80211)
                {
                    // network interface is Wi-Fi
                    Debug.WriteLine("Network connection is: Wi-Fi");

                    Wireless80211Configuration wc = Wireless80211Configuration.GetAllWireless80211Configurations()[ni.SpecificConfigId];
                    if (wc.Ssid != c_SSID && wc.Password != c_AP_PASSWORD)
                    {
                        // have to update Wi-Fi configuration
                        wc.Ssid = c_SSID;
                        wc.Password = c_AP_PASSWORD;
                        wc.SaveConfiguration();
                    }
                    else
                    {   // Wi-Fi configuration matches
                    }
                }
                else
                {
                    // network interface is Ethernet
                    Debug.WriteLine("Network connection is: Ethernet");

                    ni.EnableDhcp();
                }

                // wait for DHCP to complete
                WaitIP();
            }
            else
            {
                throw new NotSupportedException("ERROR: there is no network interface configured.\r\nOpen the 'Edit Network Configuration' in Device Explorer and configure one.");
            }
        }

        static void WaitIP()
        {
            Debug.WriteLine("Waiting for IP...");

            while (true)
            {
                NetworkInterface ni = NetworkInterface.GetAllNetworkInterfaces()[0];
                if (ni.IPv4Address != null && ni.IPv4Address.Length > 0)
                {
                    if (ni.IPv4Address[0] != '0')
                    {
                        Debug.WriteLine($"We have an IP: {ni.IPv4Address}");
                        break;
                    }
                }

                Thread.Sleep(500);
            }
        }


    }
}

Configurando SSID e PASSWORD

Atualize versões dos pacotes

Compile o código

Encontrando o U-BLOX NINA W106 (Device Explorer)

Fazendo ping se está ativo

Transferindo o programa (Deploy)

Execução

Pacotes .NET nanoFramework
NuGet Gallery | nanoframework

LINKS

API docs: https://docs.nanoframework.net/api/Windows.Devices.Adc.html
Browse our samples repository: https://github.com/nanoframework/samples
Check our documentation online: https://docs.nanoframework.net/
Join our lively Discord community: https://discord.gg/gCyBu8T
Report issues: https://github.com/nanoframework/Home/issues
Follow us on Twitter: https://twitter.com/nanoframework
Follow our YouTube channel: https://www.youtube.com/c/nanoFramework