U-BLOX NINA B302 ACESSING ANYWHERE IN WORLD, .NET, ATMOSPHERE: U-BLOX NINA W106 SENDO PROGRAMADO .NET nanoFramework

U-BLOX NINA W106 SENDO PROGRAMADO .NET nanoFramework - GPIO
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 o exemplo consiste mostrar a execução de várias Threads.

THREADS

É um assunto muito difícil. Somente as informações básicas serão abordados aqui.

Processadores / programas executam uma instrução por vez. Uma única instrução foi executada e o fluxo de então passou para a próxima. Então, como é possível que seu computador pode rodar vários programas ao mesmo tempo? Na verdade, o PC não estão executando ao mesmo tempo.! Ele executa cada programa em um curto período de tempo, pára e executa um outro programa após um curto período de tempo.

Em geral, o multi-tasking não é recomendado para iniciantes, mas algumas coisas são mais fáceis utilizando threads. Por exemplo, você quer um flash LED. Seria bom fazer isso em uma thread e você não precisa se preocupar em seu programa principal.

"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 Blinky

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.Threading;

namespace GCStressTest
{
    public class Program
    {
        private static Timer _timer0;
        private static Timer _timer1;
        private static Timer _timer2;
        private static Timer _timer3;
        private static Timer _timer4;
        private static Timer _timer5;

        private static Random _randomizer;

        private static long _timer0Counter;
        private static long _timer1Counter;
        private static long _timer2Counter;
        private static long _dummyThreadCounter;
        private static long _dummyThreadTimerCounter;

        public static void Main()
        {
            _randomizer = new Random();

            // timer start times (all timers are due to start in the first 2 seconds)
            int start0 = _randomizer.Next(1000 * 2);
            int start1 = _randomizer.Next(1000 * 2);
            int start2 = _randomizer.Next(1000 * 2);
            int start3 = _randomizer.Next(1000 * 2);
            int start4 = _randomizer.Next(1000 * 2);
            int start5 = _randomizer.Next(1000 * 2);


            // timer intervals 
            // half of the timers will have a short period
            int period0 = _randomizer.Next(1000);
            int period1 = _randomizer.Next(1000);
            int period2 = _randomizer.Next(1000);

            // the other half of the timers will have a long period
            int period3 = _randomizer.Next(1000 * 3);
            int period4 = _randomizer.Next(1000 * 3);
            int period5 = _randomizer.Next(1000 * 3);

            // quick timers

            Debug.WriteLine("Starting timer 0 with " + period0 + "ms period, due in " + start0 + "ms.");
            _timer0 = new Timer(new TimerCallback(TimerHandler0), null, start0, period0);
            Thread.Sleep(1);

            Debug.WriteLine("Starting timer 1 with " + period1 + "ms period, due in " + start1 + "ms.");
            _timer1 = new Timer(new TimerCallback(TimerHandler1), null, start1, period1);
            Thread.Sleep(1);

            Debug.WriteLine("Starting timer 2 with " + period2 + "ms period, due in " + start2 + "ms.");
            _timer2 = new Timer(new TimerCallback(TimerHandler2), null, start2, period2);
            Thread.Sleep(1);

            // long timers
            Debug.WriteLine("Starting timer 3 with " + period3 + "ms period, due in " + start3 + "ms.");
            _timer3 = new Timer(new TimerCallback(TimerHandler0), null, start3, period3);
            Thread.Sleep(1);

            Debug.WriteLine("Starting timer 4 with " + period4 + "ms period, due in " + start4 + "ms.");
            _timer4 = new Timer(new TimerCallback(TimerHandler1), null, start4, period4);
            Thread.Sleep(1);

            Debug.WriteLine("Starting timer 5 with " + period5 + "ms period, due in " + start5 + "ms.");
            _timer5 = new Timer(new TimerCallback(TimerHandler2), null, start5, period5);
            Thread.Sleep(1);

            for (; ; )
            {
                Thread.Sleep(100);
            }
        }

        private static void TimerHandler0(object status)
        {
            if(status == null)
            {
                Debug.WriteLine("Hello from timer 0 [" + _timer0Counter++ + "]");

            }
            else
            {
                Debug.WriteLine("Hello from dummy thread timer [" + _dummyThreadTimerCounter++ + "]");
            }

            // create 100 integers interleaved with bytes
            for (int i = 0; i < 100; i++)
            {
                int dummyInt = 0;
                dummyInt += i;

                byte dummyByte = 5;
                dummyByte = (byte)(dummyByte + i);
            }
        }

        private static void TimerHandler1(object status)
        {
            Debug.WriteLine("Hello from timer 1 [" + _timer1Counter++ + "]");

            // create 10 huge arrays
            for (int i = 0; i < 10; i++)
            {
                // create array with random size up to 10.000 elements
                byte[] array = new byte[_randomizer.Next(10000)];

                Debug.WriteLine("Created array with " + array.Length + " elements");

                // do something with each array element
                for (int j = 0; j < array.Length; j++)
                {
                    array[j] += (byte)i;
                }

                Thread.Sleep(10);
            }
        }

        private static void TimerHandler2(object status)
        {
            Debug.WriteLine("Hello from timer 2 [" + _timer2Counter++ + "]");

            // spawn 10 Threads 
            for (int i = 0; i < 10; i++)
            {
                Thread t = new Thread(DummyThread);
                t.Start();
            }
        }

        private static void DummyThread()
        {
            Debug.WriteLine("Hello from dummy thread [" + _dummyThreadCounter++ + "]");

            String dummyString = "";

            for (int i = 0; i < 10; i++)
            {
                String stringBit = "block" + i.ToString();

                dummyString += stringBit;

                Thread.Sleep(_randomizer.Next(500));

                //

                if((i % 2) == 0)
                {
                    // on even pass, spawn a new thread
                    Thread t = new Thread(() => {
                        TimerHandler0(_dummyThreadTimerCounter);
                    });
                    t.Start();

                }
            }

            // make sure the string remains until the end
            dummyString.IndexOf("x");
        }

        static int PinNumber(char port, byte pin)
        {
            if (port < 'A' || port > 'J')
                throw new ArgumentException();

            return ((port - 'A') * 16) + pin;
        }
    }
}