.NET Micro Framework

Artigo
04/07/2015

O Microsoft .NET Framework em aplicativos incorporados

O mundo percorreu um longo caminho desde o primeiro editor de código C com diferenciação de contexto no início dos anos 80. Ferramentas e linguagens desenvolvidas inicialmente para aplicativos de área de trabalho foram estendidas para abranger o servidor, a nuvem e outros ambientes. O Microsoft .NET Framework e o Visual Studio fornecem ferramentas de última geração que aumentam significativamente a eficiência do programador. As ferramentas do .NET Framework e as linguagens fornecem bibliotecas e ferramentas de colaboração avançadas e protegem os programadores dos erros mais comuns.

No entanto, esses avanços não foram disponibilizados para desenvolvedores trabalhando em dispositivos integrados. O mercado de ferramentas incorporadas não teve a dimensão necessária para atrair os tipos de investimentos feitos em ferramentas para computador, servidor e aplicativos de nuvem. O surgimento de "dispositivos inteligentes" de todas as descrições está trazendo uma mudança nesse desequilíbrio.

Com o .NET Micro Framework, houve um novo fluxo de produtos, incluindo pequenos dispositivos que exigiam um conjunto de habilidades incorporadas diferente para desenvolver código. Em vez disso, eles foram desenvolvidos por pessoas e equipes com habilidades em .NET. Se você for um desenvolvedor .NET e pensou em como aproveitar pequenos dispositivos incorporados em seus aplicativos, espero que este artigo o convença de que você pode usar suas habilidades para participar da explosão da Internet das Coisas (IoT) e dispositivos inteligentes.

Por que você deveria se preocupar com isso? Uma análise recente estima que 94% dos processadores que serão lançados em 2017 não terá capacidade suficiente para suportar um ambiente de aplicativo tradicional do .NET. Com o .NET Micro Framework, você pode aumentar seu alcance.

O .NET Micro Framework foi inicialmente desenvolvido no projeto de inspeção SPOT. Ele tem sido parte da família .NET nos últimos sete anos. Ele é executado em processadores de 32 bits muito pequenos para dar suporte a sistemas operacionais completo. É realmente o .NET em execução diretamente no hardware com o mecanismo do sistema e sistema de tipo integrado na imagem executável.

O objetivo do .NET Micro Framework é ajudar os desenvolvedores .NET a criar um aplicativo que seja executado em um pequeno dispositivo baseados em MCU de 32 bits para aplicativos integrados. Na conferência Build em 2014, a Microsoft descreveu uma variedade de plataformas de sistema operacional que abrangem o espaço IoT com o Windows Embedded Standard no high-end e o .NET Micro Framework para dispositivos pequenos.

Desenvolvimento incorporado

Dispositivos inteligentes têm recurso de computação local e podem se comunicar com outros dispositivos e, potencialmente, com a nuvem. Neste artigo, eu criei um pequeno robô móvel que posso controlar por um smartphone executando o sistema operacional Windows Phone. O objetivo é mostrar como as habilidades do .NET usadas para o aplicativo Windows Phone são aplicadas apenas no lado do robô. As ferramentas e o suporte à linguagem são novos neste ambiente e o ambiente de desenvolvimento para trabalhar entre os dois é contínuo.

Conheça Bert — Bert é um robô móvel com quatro rodas ligadas (consulte a Figura 1). Ele inclui uma placa Netduino 2 disponível por aproximadamente US$35 da Secret Labs. Um controlador simples permite controlar os motores em cada lado do robô para ir para frente e para trás. Entretanto, há nenhum controle de velocidade.

Figura 1 Bert o robô

Para comunicação, Bert inclui um módulo de Bluetooth que se comunica com o Netduino por uma interface serial. Para garantir que você não bata Bert em nada ou derrube-o de despenhadeiro, há sensores de proximidade IV incluídos na parte frontal e traseira. Também há faróis e sinais de entrada só por diversão.

O aplicativo simple do Windows Phone é derivado de uma demonstração apresentada na conferência do Build. Ele se conecta ao dispositivo correto e usa o acelerômetro integrado para conduzir Bert enviando comandos via Bluetooth. Você pode ver a interface na Figura 2, com a seleção da lista suspensa na Figura 3. Selecione Enumerate para escolher o dispositivo conectado ao qual você enviará comandos. Os comandos são refletidos nas letras direcionais na tela.

Figura 2 Interface do aplicativo do Windows Phone

Figura 3 Menu suspenso de seleção do dispositivo

Você pode portar o .NET Micro Framework para outra plataforma de hardware com o Kit de Portabilidade do .NET Micro Framework (bit.ly/1wp57qm). Use o kit para gravar as interfaces de baixo nível para o hardware específico no qual você está executando. Isso se assemelha às atividades de programação integrada clássicas. A boa notícia é que os fornecedores já fizeram isso para você. A placa Netduino usada neste aplicativo é um exemplo de ter tudo que você precisa para começar a codificar a placa no SDK do Netduino (bit.ly/1CQygzz).

Netduino é um processador Cortex-M3 da STMicro com 192 KB a 384 KB de Flash e 60 KB a 100 KB de RAM e é compatível com pin das blindagens Arduino. Você pode encontrar outros dispositivos que oferecem suporte ao .NET Micro Framework na GHI Electronics, Mountaineer, Sparkfun, Adafruit, Amazon e outras lojas.

A placa também é hardware de software livre, para que quando você crie seu aplicativo e quiser comercializá-lo, você tenha várias opções. Você pode simplesmente usar a placa Netduino para aplicativos de baixo volume, mas se estiver orientado para um volume mais alto ou tem requisitos específicos, como desejar integrar eletrônicos no mesmo PCB, é possível colocar arquivos de design de software livre para um fabricante da placa e continue a partir dele.

Como eu comecei com a placa Netduino, instalei o SDK do Netduino. Isso inclui o SDK do .NET Micro Framework com modelos do Visual Studio e todo o suporte de biblioteca necessário. Para outras placas de desenvolvimento, você precisará instalar o SDK do .NET Micro Framework separadamente. O SDK é fornecido com um emulador, portanto, você não precisa obter qualquer hardware brincar com .NET Micro Framework, embora o uso de hardware seja mais produtivo se você já souber quais sensores deseja usar.

Criar o aplicativo incorporado

Depois de instalar o SDK do Netduino (que contém o SDK do .NET Micro Framework), iniciar um aplicativo integrado do .NET Micro Framework é como iniciar qualquer outro projeto no Visual Studio. Selecione Novo Projeto e o tipo de aplicativo que deseja iniciar. Conforme mostrado na Figura 4, selecionei um aplicativo Netduino 2 para corresponder à placa no Bert.

Figura 4 Iniciar um aplicativo integrado do .NET Micro Framework

Depois de começar o projeto, você pode ir diretamente para a criação do link de comunicação entre o robô e o telefone.

Como muitos aplicativos incorporados, Bert é executado com baterias. Isso significa que seu código deve ser criado para economizar o consumo de energia. A boa notícia é que o .NET Framework e .NET Micro Framework são perfeitamente adequados para isso. Se não houver nenhum segmento a ser executado, o .NET Micro Framework pode colocar automaticamente o processador em um estado de baixa energia. Também está se tornando comum adicionar um segundo processador eficiente para monitorar as interrupções e colocar o processador principal em um estado de energia ainda menor. Você verá em breve se o .NET Framework é bem adequado para lidar com esse tipo de programação.

O código nesse aplicativo é executado em resposta a um evento externo e apenas o que é necessário para responder. Você verá que toda a execução reside em um manipulador de eventos ou em um thread que está suspenso na maioria das vezes, desta forma:

public class Program
  {
    public static void Main()
    {
      RunRobot myRunRobot = new RunRobot();
      myRunRobot.Start();
      while (true)
      {
        Thread.Sleep(Timeout.Infinite);
      }
    }
  }

O construtor RunRobot inicializa as instâncias de E/S que examinarei em mais detalhes e o método RunRobot.Start inicializa as interrupções que disparam a execução real:

public void Start()
  {
  // Enable interrupts on BT input on the HC-06 radio
  hc06.DataReceived += hc06_DataReceived;
  // Use onboard button to turn on/off accepting commands
  button = new InterruptPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled,
    Port.InterruptMode.InterruptEdgeHigh);
  // Start monitoring for button presses
  button.OnInterrupt += new NativeEventHandler(button_OnInterrupt);
  }

Fazer o bluetooth funcionar

Há três etapas para fazer a comunicação Bluetooth funcionar entre o Bert e o aplicativo do Windows Phone:

Conectar o módulo Bluetooth no robô
Enviar comandos do aplicativo do telefone
Receber esses comandos no Bert

Como o Netduino é compatível com o Arduino, para muitas das conexões, você poderá encontrar um escudo onde é possível conectar que faz todas as conexões necessárias para você. O Arduino é uma plataforma de entusiastas popular que tem um rico ecossistema de periféricos. Você pode criar uma ampla variedade de soluções de módulos existentes.

Se você não deseja gastar tempo com fiação, veja os produtos Gadgeteer da GHI eletrônicos. Com essas placas e componentes, você pode usar um assistente para decidir onde conectar os componentes em conexões padrões (consulte a Figura 5). Portanto, você não precisa de qualquer conhecimento de conexões de fiação. As interfaces do módulo estão em um nível alto semelhante. Como o Arduino, o Gadgeteer tem um rico conjunto de módulos existentes para criar sua solução. Depois de conectar os módulos, você ainda está codificando no .NET Micro Framework. Isso é particularmente útil para a criação de protótipos rapidamente das suas ideias.

Figura 5 O assistente Gadgeteer mostrando as conexões

No caso do Bert, eu não estou usando o Gadgeteer, mas coletando meus próprios módulos. O módulo Bluetooth (HC-06) usa uma interface serial com quatro conexões — VIN, GND, RX e TX. Conecte o VIN (Tensão de Entrada) nas saías de 5V ou 3.3V do Netduino e conecte o GND a uma das conexões GND. Examinando a tabela de E/S para Netduino na Figura 6, você verá para conectar o módulo RX do BT (Recebimento) ao Netduino TX (Transmissão) e o módulo TX do BT ao Netduino RX da porta serial COM1. Se necessário, há vários exemplos para conectar esses módulos aos microcontroladores comuns na Web.

Figura 6 Pinos de E/S do Netduino definidos

Com as conexões feitas, você pode ligar o Netduino (que ativa o módulo BT) e emparelhe o dispositivo com o telefone. O nome padrão para o módulo BT é HC-06, portanto, você pode emparelhar com ele. Alterei o nome para Bert usando comandos AT. Envie uma matriz de bytes com os caracteres "AT+NAMEBert" para alterar o nome do módulo BT. Você também pode usar essa interface para configurar o módulo Bluetooth, inclusive coisas como a taxa de transmissão da comunicação.

Agora você pode usar o telefone para se conectar ao Bert como faria com qualquer outro dispositivo BT e comece a enviar comandos. Primeiro, eu acessei o acelerômetro integrado e configurei um intervalo de relatórios razoável, para não ter uma troca Bert ruim:

accelerometer = Accelerometer.GetDefault();
if (accelerometer != null)
{
  uint minReportInterval = accelerometer.MinimumReportInterval;
  desiredReportInterval = minReportInterval > 250 ? minReportInterval : 250; 
    // Slowing this way down to prevent flooding with commands
  accelerometer.ReportInterval = desiredReportInterval;
    // Add event for accelerometer readings
  accelerometer.ReadingChanged += new TypedEventHandler<Accelerometer,
    AccelerometerReadingChangedEventArgs>(ReadingChanged);
}

O manipulador de eventos ReadingChanged envia comandos, conforme mostrado na Figura 7.

Figura 7 O manipulador de eventos para enviar comandos para o Bert

AccelerometerReading reading = args.Reading;
if (reading.AccelerationX > .4)  // These are arbitrary levels
                                 // set to what seemed easy
{
                        // Send Right
  if( cmdSent != 'R')   // Don’t resend the same command over and over
  {
      // Update the phone display
    txtRight.Text = "On";
    txtLeft.Text = " L";
    txtForward.Text = " F";
    txtBack.Text = " B";
      // Send the command
    packet = Encoding.UTF8.GetBytes("R");
    cmdSent = 'R';
    SendData(packet);
  }

Receber e executar comandos

Agora você pode considerar receber um comando no lado do robô. O módulo BT é conectado à primeira porta serial no Netduino. Crie uma instância SerialPort e um buffer de mensagens, como faria em outras versões do .NET Framework:

SerialPort hc06;                 // The BT radio
byte[] cmdBuffer = new byte[32]; // The input buffer for receiving commands

Configure a porta serial para comunicação com o módulo Bluetooth (9600 bauds é o padrão. Posso redefinir isso usando comandos AT, mas isso será uma comunicação muito simples para simplificar o programa, portanto, velocidades mais rápidas são desnecessárias):

// Set up the Bluetooth radio communication
hc06 = new SerialPort(SerialPorts.COM1, 9600, 
  Parity.None, 8, StopBits.One);
hc06.ReadTimeout = 1000;
hc06.Open();

Em seguida, configurei um manipulador de eventos DataReceived que dispara a maior parte do processamento no aplicativo. Em outras palavras, o Bert ficará suspenso até que ele receba um comando. O processador permanece em funcionamento por tempo suficiente para definir os motores no estado correto e retorna ao modo de suspensão:

// Enable interrupts on BT input
hc06.DataReceived += hc06_DataReceived;

Os comandos de entrada são processados no manipulador de eventos, como mostrado na Figura 8.

Figura 8 Os comandos de entrada para começar a mover o Bert

do
{
  try
  {
    count = hc06.Read(cmdBuffer, 0, 1);  // Should read one byte at a time
  }
  catch (Exception) { }        // Just eat exceptions
  if (count > 0)
  {
    cmd = (char)cmdBuffer[0];
    executeCmd(cmd);   // Execute command immediately
  }
} while (count > 0);

Nenhum código é diferente do que você escreveria na área de trabalho.

Definir Bert em movimento

O controlador motor que uso requer simplesmente a definição de quatro entradas em algum estado lógico para determinar como as rodas giram. A lógica é:

/*        
A2  A1  Motor 1         B2  B1  Motor 2
0   0   Shaft locked    0   0   Shaft locked
0   1   Clockwise       0   1   Clockwise
1   0   Anti-clockwise  1   0   Anti-clockwise
1   1   Shaft locked    1   1   Shaft locked 
*/

Para gravar a eles, eu crio um OutputPort e o vinculo a um dos pinos digitais do Netduino mostrados na Figura 6. OutputPort é uma classe exclusiva no .NET Framework porque dispositivos que executam o .NET Framework completo geralmente não podem resolver as portas de E/S digitais individuais. Há inúmeras novas classes no .NET Micro Framework para lidar com os tipos adicionais de E/E e outros problemas exclusivos para esse espaço de aplicativo como o gerenciamento de energia:

// Motor controller output
A1 = new OutputPort(Pins.GPIO_PIN_D2, false);  
  // A is the left tires when viewed from the front
A2 = new OutputPort(Pins.GPIO_PIN_D3, false);
B1 = new OutputPort(Pins.GPIO_PIN_D4, false);  
  // B is the right tires when viewed from the front
B2 = new OutputPort(Pins.GPIO_PIN_D5, false);
Setting them is as simple as writing true or false:
switch (cmd)
{
  case 'F':
  {
    Debug.Print("Forward");
    A1.Write(false);   // Left forward = false/true
    A2.Write(true);
    B1.Write(true);    // Right forward = true/false
    B2.Write(false);
    break;
  }

Dirija cuidadosamente

Não quero que Bert bata nas coisas para sua própria segurança e para a segurança das coisas e pessoas ao redor dele, portanto, eu instalei sensores infravermelhos de proximidade da Sharp na frente e atrás. Esses sensores retornam um valor de 0,0 a 1,0 dependendo da distância do objeto mais próximo que reflete a luz IV projetada.

O sensor frontal é apontado diagonalmente para baixo detectando o piso em cerca de 18 polegadas na frente do Bert. Isso me permite usar um sensor para detectar objetos, bem como queda do piso se estiver aproximando-se de escadas, por exemplo. Os valores que esses sensores retornam são analógicos, o que significa que eu crio uma instância de outra classe exclusiva no .NET Framework para o .NET Micro Framework — a classe AnalogInput:

AnalogInput foreRange;    // Forward range finder input
AnalogInput backRange;    // Rear range finder input
// Set up range finder for collision and edge avoidance
foreRange = new AnalogInput(Cpu.AnalogChannel.ANALOG_5, 100, 0, -1);
backRange = new AnalogInput(Cpu.AnalogChannel.ANALOG_4, 100, 0, -1);

Esse construtor identifica a porta analógica específica na qual estou me conectando, um multiplicador que posso usar para converter a saída em um intervalo mais conveniente, um deslocamento para modificar a saída para conveniência e a precisão da saída com -1 significando a precisão máxima. Para fazer essas medidas periodicamente e permitir que o processador fique suspenso o máximo possível, as leituras são disparadas por um timer. Eu defino isso quando começo a aceitar comandos do telefone e descartá-los quando não:

// Start timer for rangeFinders
Timer rangeReader = new Timer(new TimerCallback(rangeTimerHandler), 
  null, 0, 100);

Interrupção de finalidade geral

A última nova classe que preciso apresentar é a classe InterruptPort. Isso me permite monitorar alterações na entrada digital e disparos em alterações, como a borda esquerda de uma alteração de Baixo para Alto, por exemplo. Estou usando esse botão na placa Netduino que faz com que o Bert responda aos comandos do telefone. Isso significa que ele ignorará os comandos até que esse botão seja pressionado e os ignora depois de pressioná-lo novamente:

// Use onboard button to turn on/off accepting commands
button = new InterruptPort(Pins.ONBOARD_SW1, false,
  Port.ResistorMode.Disabled,
  Port.InterruptMode.InterruptEdgeHigh);

Pins.ONBOARD_SW1 é a conexão interna para o comutador na placa Netduino. Você pode se conectar a um comutador de qualquer uma das portas digitais listadas na Figura 6. O segundo argumento é se eu preciso de um filtro de problemas aplicado a essa opção do comutador para evitar a vários disparos em uma única pressão do botão.

O próximo parâmetro é se há um resistor de puxar para cima ou para baixo no comutador. Isso define a posição de porta padrão quando o botão não estiver pressionado (Alto ou Baixo). O próximo parâmetro é definido para acionar a interrupção na transição de volta para Alto, para que seu dedo esteja fora do caminho se Bert disparar imediatamente. Com a instância InterruptPort criada, posso atribuir o manipulador de interrupção:

// Start monitoring for button presses
button.OnInterrupt += new NativeEventHandler(button_OnInterrupt);

O manipulador de interrupção inicia o Bert monitorando qualquer comando proveniente do telefone, como você pode ver na Figura 9.

Figura 9 Interromper o monitoramento do comando de ativação do manipulador

private void button_OnInterrupt(uint data1, uint data2, DateTime time)
{
  cmdListenState = !cmdListenState;
  if (cmdListenState)
  {
    // Set up timer for rangeFinders
    rangeReader = new Timer(new TimerCallback(rangeTimerHandler), 
      null, 0, 100);
  }
  else
  {
    rangeReader.Dispose(); // Drop the timer because Bert isn't processing
                          // commands so he shouldn't be moving
  }
  led.Write(cmdListenState);  // The onboard LED indicates whether
                               // Bert is accepting commands
}

Aplicativos incorporados e o .NET Micro Framework

Aplicativos incorporados normalmente executam um conjunto de funções direcionado no hardware criado para atender aos requisitos mínimos. Criar aplicativos incorporados de destino e ajustados exige um investimento inicial mais alto. Esse investimento é compensado durante um ciclo de vida do produto mais longo.

Um dos maiores desafios do desenvolvimento incorporado tradicional é o tempo necessário para concluir projetos. Uma grande parte dos projetos incorporados são abandonados porque o custo se torna muito grande ou os requisitos mudam antes que os projetos possam entrar no mercado.

Várias coisas estão afetando a dinâmica de aplicativos incorporados. Quando a Microsoft lançou pela primeira vez o .NET Micro Framework sete anos atrás, a maioria dos aplicativos incorporados tinham processadores de 8 bits integrados para reduzir custos, atender aos requisitos de desempenho necessários e atender aos requisitos de energia (a capacidade de funcionar com bateria por longos períodos, por exemplo).

Ao mesmo tempo, a maior parte do crescimento no espaço de integrados era orientada para processadores de 32 bits como o ARM7. Esses processadores continuaram a descer no preço e ofereceram um desempenho adequado para muitos aplicativos e o consumo de energia foi melhorado. Os processadores Cortex mais recentes estão continuando a atrair muitos novos aplicativos incorporados à família de 32 bits.

Recentemente, houve mais dispositivos que são parte integral de aplicativos mais amplos, incluindo dispositivos incorporados, gateways, conectividade de nuvem, bancos de dados, aplicativos de business intelligence e assim por diante. Esses novos aplicativos mudam a economia de aplicativos incorporados.

É mais importante aderir aos protocolos de comunicação comuns. Mais desses novos dispositivos estão no território do consumidor, portanto, esperar ciclos de desenvolvimento longos significa maior risco do produto. O tempo de entrega é ainda mais importante para esses aplicativos e durante a próxima explosão de "dispositivos inteligentes".

Outro impacto desses novos tipos de aplicativos é sua abrangência sozinha. Eles potencialmente reúnem o desenvolvedor de área de trabalho e sua experiência em comunicações de grande escala, bancos de dados e análise empresarial e protocolos de nuvem com o desenvolvedor incorporado e sua experiência em hardware e programação de nível baixo. As ferramentas e linguagens ajudam os mesmos conjuntos de habilidades para funcionar em todos os aplicativos para projetos mais eficientes.

Esse era o plano de fundo no qual o .NET Micro Framework foi desenvolvido. No início, essa plataforma foi criada como ferramentas internas para desenvolver aplicativos de inspeção de SPOT da Microsoft (apenas nove anos à frente no mercado). Quando a plataforma tornou-se útil para outros projetos internos, o produto foi arredondado como uma plataforma geral em 2007.

Os drivers de aplicativo incorporado de custo, desempenho e eficiência de energia não deixarão de existir. Quando se trata de aplicativos em que você deseja implantar milhares de sensores em um prédio, o custo se torna ainda mais crítico. Requisitos de desempenho e energia também variam de acordo com o aplicativo. Continuar a aprimorar a variedade de aplicativos que podem ser alcançados com o .NET Micro Framework é uma área de foco contínua para os esforços de desenvolvimento da Microsoft.

Implantar e depurar

Implantar o código para o seu dispositivo é tão fácil quanto conectá-lo e pressionar F5, assim como ocorre com o aplicativo do Windows Phone. No entanto, a instalação é um pouco diferente. Na caixa de diálogo Projeto | Propriedades, há uma guia .NET Micro Framework onde você pode especificar o transporte (USB, serial ou TCP/IP) e identificar o dispositivo. O padrão é USB. Ele identificará automaticamente um dispositivo .NET Micro Framework, portanto, a menos que você esteja conectado a diversos dispositivos, você nunca precisá estar nessa caixa de diálogo. Neste ponto, a solução é criada e os assemblies implantados no dispositivo. Você pode seguir tudo isso na janela Saída no Visual Studio. A execução começa imediatamente e você pode começar a depuração do código em execução no dispositivo.

Você também pode implantar o aplicativo em um emulador em execução em um computador desktop. A diferença é que o Windows Phone tem um número relativamente limitado de permutações, portanto, você pode selecionar o emulador mais próximo de um conjunto fornecido no Visual Studio. Para o .NET Micro Framework, há um emulador da Microsoft genérico. Provavelmente, você precisará criar seu próprio emulador para coincidir com seu hardware. Vale a pena examinar se você deseja começar a codificação antes que seu hardware esteja disponível.

No passado, o cenário para depurar a comunicação entre o robô e o aplicativo Windows Phone pode ter sido feito com um depurador JTAG. Isso é separado do ambiente de desenvolvimento e externo para um desenvolvedor .NET, portanto, você pode ter um desenvolvedor monitorando o que está acontecendo no telefone e um monitorando (em ferramentas separadas) o que está acontecendo no dispositivo incorporado. Você pode monitorar simultaneamente no Visual Studio. Você pode percorrer o código de telefone, dividi-lo na transmissão de comando e ver o que acontece com esse comando no Bert.

Conclusão

O cenário completo de como criar qualquer aplicativo incorporado significativo no .NET Micro Framework levaria um livro inteiro. O objetivo deste artigo era demonstrar que a curva de aprendizado não é muito acentuada para usar suas habilidades em .NET para aplicativos integrados e o .NET Micro Framework.

Esse projeto exige algumas classes que não fazem parte das bibliotecas do .NET completas. Também haverá algumas coisas que você conhece sobre o .NET Framework completo que não puderam fazer parte do .NET Micro Framework, mas o ambiente do Visual Studio é completamente compatível com o IntelliSense, os pontos de interrupção, os pontos de inspeção, a pilha de chamadas e qualquer outra coisa que você está acostumado. Há aplicativos incorporados por aí onde o .NET Micro Framework não é a solução certa. Para muitos, no entanto, ele funciona muito bem. Os esforços continuam a ampliar a aplicabilidade da plataforma para segmentos maiores dessa parte crescente e cada vez mais crucial da ciência da computação.

Agora você está pronto para testar um pequeno projeto como um programador incorporado.

Veja Bert em ação

Agora você sabe como colocar suas habilidades de desenvolvimento em bom uso para algo divertido. Você desenvolveu um aplicativo onde pode controlar um pequeno robô usando um smartphone com o sistema operacional Windows Phone. As habilidades do .NET usadas para desenvolver o aplicativo Windows Phone são igualmente aplicáveis para o robô. O trabalho entre os dois é contínuo. Seu trabalho está concluído, é hora de ver Bert em ação: youtu.be/ypuqTju2w4c.

Colin Miller é o gerente do programa principal na equipe do Internet das Coisas na Microsoft. Entre em contato com ele em colin.miller@microsoft.com. Ele trabalha na Microsoft há 20 anos e trabalhou na Internet das Coisas, inserida, Integrado, Ferramentas de Desenvolvimento, Pesquisa, MSN, Internet Explorer, Word e outros projetos.

Agradecemos ao seguinte especialista técnico da Microsoft pela revisão deste artigo: Lorenzo Tessiore