.NET Micro Framework

2015-08-04

Microsoft .NET Framework en aplicaciones incrustadas

El mundo ha evolucionado mucho desde el editor de código de C contextual de comienzos de los 80. Los lenguajes y herramientas que se desarrollaron inicialmente para aplicaciones de escritorio se han ampliado para abarcar servidores, nube y otros entornos. Microsoft .NET Framework y Visual Studio proporcionan herramientas de última generación que aumentan considerablemente la eficiencia de los programadores. Los lenguajes y herramientas de .NET Framework proporcionan potentes bibliotecas y herramientas de colaboración, y protegen a los programadores frente a los errores más comunes.

Sin embargo, estos avances no han estado disponibles para los desarrolladores que trabajan en dispositivos incrustados. El mercado de herramientas incrustadas carecía de la escala necesaria para atraer el tipo de inversiones que realizaban en herramientas para aplicaciones de PC, servidores y nube. El surgimiento de los "dispositivos inteligentes" de todos los tipos está provocando un cambio en este desequilibrio.

Con .NET Micro Framework, ha habido una nueva oleada de productos, entre los que se incluyen los dispositivos pequeños, que solían requerir un conjunto diferente de habilidades incrustadas para desarrollar el código. En su lugar, personas independientes y equipos con conocimientos de .NET los desarrollaban. Si es un desarrollador de .NET y ha pensado cómo aprovechar los dispositivos incrustados pequeños en sus aplicaciones, espero que este artículo le convenza de que puede utilizar sus conocimientos para participar en la eclosión del Internet de las cosas (IoT) y los dispositivos inteligentes.

¿Por qué deberían importarle? Un análisis reciente prevé que el 94 por ciento de los procesadores que se distribuirán en 2017 no tendrán suficiente capacidad para admitir un entorno tradicional de aplicaciones .NET. Con .NET Micro Framework, puede ampliar su alcance.

.NET Micro Framework se desarrolló inicialmente en el proyecto de inspección SPOT. Ha formado parte de la familia .NET durante los últimos siete años. Se ejecuta en procesadores de 32 bits demasiado pequeños para admitir sistemas operativos completos. En realidad, se trata de .NET que se ejecuta directamente en el hardware con motor de ejecución y el sistema de tipos integrados en la imagen ejecutable.

El objetivo de .NET Micro Framework es ayudar a los desarrolladores de .NET a crear una aplicación que se ejecute en un dispositivo basado en MCU pequeño de 32 bits para aplicaciones incrustadas. En la conferencia Build de 2014, Microsoft describió una gama de plataformas de sistemas operativos que abarcan el IoT con Windows Embedded Standard en el extremo superior y .NET Micro Framework en el extremo de los dispositivos pequeños.

Desarrollo incrustado

Los dispositivos inteligentes tienen capacidad de procesamiento local y pueden comunicarse con otros dispositivos y, potencialmente, con la nube. En este artículo, he creado un pequeño robot móvil que puedo controlar desde un smartphone con el sistema operativo Windows Phone. El objetivo es mostrar que los conocimientos de .NET que se utilizan para la aplicación de Windows Phone se pueden aplicar en el lado de robot. La compatibilidad con los idiomas y herramientas es nueva en este entorno, y el entorno de desarrollo para trabajar hacia delante y atrás entre los dos es transparente.

Conozca a Bert: Bert es un robot móvil con cuatro ruedas accionables (consulte la Figura 1). Incluye un panel Netduino 2 disponible con un precio aproximado de 35 $ a través de Secret Labs. Un controlador simple le permite controlar los motores de cada lado del robot para ir hacia delante y atrás. Sin embargo, hay ningún control de velocidad.

Figura 1. Bert el robot

Para la comunicación, Bert incluye un módulo de Bluetooth que se comunica con el Netduino a través de una interfaz serie. Para asegurarse de que Bert no se choque contra algo o se desprenda por un precipicio, tiene sensores infrarrojos de proximidad que se incluyen en las partes frontal y trasera. También dispone de faros delanteros e intermitentes de giros, solo por diversión.

La aplicación simple de Windows Phone deriva de una demostración presentada en la conferencia Build. Se conecta al dispositivo correcto y utiliza el acelerómetro incorporado para conducir a Bert por los alrededores, mediante el envío de comandos a través de Bluetooth. Puede ver la interfaz en la Figura 2, con la selección de lista desplegable en la Figura 3. Seleccione Enumerate para elegir el dispositivo conectado al que enviará comandos. Los comandos se reflejan en las letras direccionales en la pantalla.

Figura 2. Interfaz de la aplicación de Windows Phone

Figura 3. Lista desplegable de selección de dispositivo

Puede portar .NET Micro Framework a otra plataforma de hardware con .NET Micro Framework Porting Kit (bit.ly/1wp57qm). Use el kit para escribir las interfaces de bajo nivel en el hardware específico en el que esté ejecutándose. Esto es más parecido a las actividades clásicas de programación incrustadas. La buena noticia es que los proveedores ya lo han hecho por usted. El panel Netduino usado en esta aplicación es un ejemplo en el que tiene todo lo que necesita para empezar a programar en el panel del SDK de Netduino (bit.ly/1CQygzz).

Netduino es un procesador Cortex-M3 de STMicro que tiene de 192 KB a 384 KB de Flash y de 60 KB a 100 KB de RAM, además de compatibilidad de patillas con los shields de Arduino. Puede encontrar otros dispositivos compatibles con .NET Micro Framework en GHI Electronics, Mountaineer, Sparkfun, Adafruit, Amazon y otras tiendas.

El panel también es hardware de código abierto, por lo que si escribe su aplicación y desea a comercializarla, tiene varias opciones. Solo puede usar el panel de Netduino con aplicaciones de bajo volumen, pero si su objetivo es un volumen elevado o tiene requisitos específicos, como integrar electrónica adicional en el mismo PCB, puede llevar los archivos de diseño de código abierto a un fabricante de placas y trabajar desde ahí.

Dado que comencé con el panel de Netduino, he instalado el SDK de Netduino. Esto incluye el SDK de .NET Micro Framework con plantillas de Visual Studio y toda la compatibilidad de bibliotecas necesaria. Para otros paneles de desarrollo, podría tener que instalar el SDK de .NET Micro Framework por separado. El SDK incluye un emulador, por lo que no necesitará adquirir ningún hardware para jugar con .NET Micro Framework, aunque el uso de hardware es más productivo si ya sabe los sensores que desea utilizar.

Creación de la aplicación incrustada

Tras instalar el SDK de Netduino (que contiene el SDK de .NET Micro Framework), comenzar una aplicación de .NET Micro Framework incrustada es igual que empezar cualquier otro proyecto en Visual Studio. Seleccione Nuevo proyecto y el tipo de aplicación que desea comenzar. Como se muestra en la Figura 4, he seleccionado una aplicación de Netduino 2 para que coincida con el panel de Bert.

Figura 4. Comienzo de una aplicación de .NET Micro Framework incrustada

Cuando haya comenzado el proyecto, puede pasar directo a la creación del vínculo de comunicación entre el robot y el teléfono.

Como muchas aplicaciones incrustadas, Bert funciona con pilas. Esto significa que el código tiene que escribirse para conservar el consumo de energía. Hay buenas noticias, ya que .NET Framework y .NET Micro Framework son perfectos para eso. Si no hay ningún subproceso para ejecutarse, .NET Micro Framework puede colocar automáticamente el procesador en un estado de energía más bajo. También resulta habitual agregar un segundo procesador eficaz para supervisar las interrupciones y poner el procesador principal en un estado de energía aun más bajo. Pronto comprobará si .NET Framework está totalmente indicado para abordar este tipo de programación.

El código de esta aplicación se ejecuta en respuesta a un evento externo y, a continuación, solo ejecuta lo necesario para responder. Por lo que observará que toda la ejecución reside en un controlador de eventos o en un subproceso que está suspendido la mayoría del tiempo, como se muestra a continuación:

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

El constructor RunRobot inicializa las instancias de E/S que veremos con más detalle y el método RunRobot.Start inicializa las interrupciones que desencadenan la ejecución 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);
  }

Conexión funcional de Bluetooth

Existen tres pasos para conseguir que la comunicación por Bluetooth entre Bert y la aplicación de Windows Phone funcione:

Conectar el módulo de Bluetooth en el robot
Enviar comandos desde la aplicación del teléfono
Recibir esos comandos en Bert

Puesto que el Netduino es compatible con Arduino, para muchas de las conexiones, es posible que encuentre un shield que pueda conectar para que realice por usted todas las conexiones necesarias. Arduino es una conocida plataforma de aficionados que tiene un rico ecosistema de dispositivos periféricos. Puede crear una amplia gama de soluciones a partir de los módulos existentes.

Si no desea dedicar tiempo al cableado, busque los productos Gadgeteer de GHI Electronics. Con estas placas y componentes, puede usar un asistente para decidir dónde se deben conectar los componentes con conexiones estándares (consulte la Figura 5), por lo que no necesita conocimientos sobre las conexiones del cableado. Las interfaces del módulo se encuentran de igual forma a un nivel alto. Al igual que Arduino, Gadgeteer tiene un amplio conjunto de módulos existentes con los que puede crear su solución. Cuando los módulos estén conectados, todavía estará escribiendo código en .NET Micro Framework. Esto es especialmente útil para crear rápidamente prototipos con sus ideas.

Figura 5. El asistente de Gadgeteer muestra las conexiones

En el caso de Bert, no utilizo Gadgeteer, sino que recopilo mis propios módulos. El módulo de Bluetooth (HC-06) utiliza una interfaz serie con cuatro conexiones: VIN, GND, RX y TX. Conecte la conexión VIN (entrada de voltaje) bien a la salida de 5 V o a la de 3,3 V del Netduino y, después, conecte GND una de las conexiones GND. Si examina la tabla de E/S del Netduino de la Figura 6, verá que debe conectar RX (recepción) del módulo de BT a TX (transmisión) del Netduino y TX del módulo de BT a RX del Netduino del puerto serie COM1. Si es necesario, hay una serie de ejemplos para conectar estos módulos con los microcontroladores comunes en la web.

Figura 6. Las patillas de E/S de Netduino definidas

Con las conexiones realizadas, puede encender el Netduino (que alimenta el módulo de BT) y emparejar el dispositivo con el teléfono. El nombre predeterminado del módulo de BT es HC-06, por lo que puede emparejarse con ese. He cambiado el nombre a Bert con comandos AT. Envíe una matriz de bytes con los caracteres "AT+NAMEBert" para cambiar el nombre del módulo BT. También puede utilizar esta interfaz para configurar el módulo de Bluetooth, incluidos aspectos como la velocidad en baudios de la comunicación.

Ahora puede utilizar el teléfono para conectarse a Bert como lo haría con cualquier otro dispositivo BT y empezar a enviar comandos. En primer lugar, se debe acceder al acelerómetro incorporado y configurar un intervalo razonable de informes, para evitar que el pobre de Bert se desborde:

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);
}

El controlador de eventos ReadingChanged envía comandos, como se muestra en la Figura 7.

Figura 7. El controlador de eventos enviando comandos a 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);
  }

Recepción y ejecución de comandos

Ahora puede recibir un comando en el lado de robot. El módulo de BT está conectado al primer puerto serie en el Netduino. Cree una instancia de SerialPort y un búfer de mensajes, como lo haría en otras versiones de .NET Framework:

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

A continuación, configure el puerto serie para la comunicación con el módulo Bluetooth (9600 baudios es el valor predeterminado; esto se podría restablecer con comandos AT, pero se trata de una comunicación muy escasa para simplificar el programa, por lo que no son necesarias velocidades más rápidas):

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

A continuación, se configura un controlador de evento DataReceived que desencadena la mayor parte del procesamiento dentro de la aplicación. En otras palabras, Bert se suspende hasta que recibe un comando. El procesador se mantiene durante el tiempo suficiente para establecer los motores en el estado correcto y vuelve al modo de suspensión:

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

Los comandos entrantes se procesan en el controlador de eventos, como se muestra en la Figura 8.

Figura 8. Los comandos entrantes para iniciar el movimiento de 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);

No hay nada distinto en ese código respecto a lo que se escribiría en el escritorio.

Poner a Bert en movimiento

El controlador del motor que utilizo necesita que establezca cuatro entradas en algún estado lógico para determinar cómo activar las ruedas. La lógica es:

/*        
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 escribir en ellas, creo un elemento OutputPort y lo asocio a una de las patillas digitales de Netduino que se muestran en la Figura 6. OutputPort es una clase única en .NET Framework porque los dispositivos que ejecutan .NET Framework completo normalmente no pueden abordar puertos de E/S digitales individuales. Hay una serie de clases nuevas en .NET Micro Framework para controlar los tipos de E/S adicionales y otros problemas exclusivos de este espacio de aplicación, como la administración de energía:

// 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;
  }

Conduzca con cuidado

No quiero que Bert se choque con cosas por su propio bien y por la seguridad de los objetos y las personas en torno a él, por lo que he instalado sensores infrarrojos de proximidad de Sharp en las partes delantera y trasera. Estos sensores devuelven un valor que va de 0,0 a 1,0 dependiendo de la distancia con el objeto más cercano que refleje la luz infrarroja proyectada.

El sensor delantero apunta en diagonal hacia abajo, por lo que detecta objetos que se encuentren aproximadamente 45 centímetros por delante de Bert. Esto me permite usar un sensor para detectar objetos, así como el principio de un desnivel, por ejemplo si se está acercando a unas escaleras. Los valores que devuelven estos sensores son analógicos, lo que significa que se debe crear una instancia de otra clase única en .NET Framework para .NET Micro Framework, la clase 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);

Este constructor identifica el puerto analógico específico al que me estoy conectando, un multiplicador que puedo usar para convertir el resultado en un intervalo más adecuado, un desplazamiento para modificar el resultado por comodidad y la precisión del resultado con -1, lo que implica máxima precisión. Para realizar estas medidas periódicamente y permitir la suspensión de procesador tanto como sea posible, un temporizador desencadena las lecturas. Se establece cuando se empiezan a aceptar comandos desde el teléfono y se desecha cuando no:

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

Interruptor de propósito general

La última clase nueva que debo presentar es la clase InterruptPort. Esta clase me permite supervisar los cambios en la entrada digital y desencadenar cambios como la tecnología punta de un cambio de baja a alta, por ejemplo. Utilizo esto para el botón en el panel del Netduino que hace que Bert responda a los comandos del teléfono. Esto significa que omite los comandos hasta que se presiona este botón y los omite al presionarlo de nuevo:

// 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 es la conexión interna del conmutador en el panel del Netduino. Puede conectar un conmutador a cualquiera de los puertos digitales que se muestran en la Figura 6. El segundo argumento es si se necesita aplicar un filtro de problemas a esta entrada del conmutador para evitar que se desencadene varias veces al presionar el botón una única vez.

El siguiente parámetro es si hay una resistencia de subida o bajada en el conmutador. Define la posición del puerto predeterminada cuando no se presiona el botón (alta o baja). El siguiente parámetro se establece para desencadenar la interrupción en la transición de vuelta a alta, para que su dedo no esté por medio si Bert se mueve de inmediato. Con la instancia de InterruptPort creada, puedo asignar el controlador de interrupción:

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

El controlador de interrupción inicia la supervisión por parte de Bert de los comandos procedentes del teléfono, como puede ver en la Figura 9.

Figura 9. El controlador de interrupción activando la supervisión de los comandos

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
}

Aplicaciones incrustadas y .NET Micro Framework

Normalmente, las aplicaciones incrustadas realizan un conjunto de funciones de destino en hardware diseñado para cumplir los requisitos mínimos. Para diseñar aplicaciones incrustadas de destino y ajustadas, se requiere una mayor inversión inicial. Esa inversión se recupera con un ciclo de vida del producto más largo.

Uno de los mayores desafíos del desarrollo incrustado tradicional es el tiempo que se tarda en completar los proyectos. se abandona una gran cantidad de proyectos incrustados porque el coste se vuelve demasiado elevado o porque los requisitos cambian antes de que los proyectos puedan llegar al mercado.

Una serie de cuestiones afectan a la dinámica de las aplicaciones incrustadas. Cuando Microsoft publicó por primera vez .NET Micro Framework hace siete años, la mayoría de aplicaciones incrustadas se creaban en procesadores de 8 bits para reducir el coste, lograr los requisitos de rendimiento necesarios y cumplir los requisitos de alimentación (por ejemplo, la capacidad de ejecución con la batería durante largos períodos).

Al mismo tiempo, la mayor parte del crecimiento en el espacio incrustado tenía como objetivo los procesadores de 32 bits, como el ARM7. El precio de estos procesadores continuaba bajando, ofrecían un rendimiento adecuado para muchas aplicaciones y se mejoró el consumo de energía. Los procesadores más recientes de Cortex siguen atrayendo muchas aplicaciones incrustadas a la familia de 32 bits.

Recientemente, ha habido más dispositivos que forman parte integral de aplicaciones más amplias, entre los que se incluyen los dispositivos incrustados, las puertas de enlace, la conectividad en la nube, las bases de datos, las aplicaciones de inteligencia empresarial, etc. Estas nuevas aplicaciones cambian la economía de las aplicaciones incrustadas.

Resulta más importante cumplir con los protocolos de comunicación comunes. Cada vez hay más de dispositivos nuevos de este tipo que están en el ámbito de los consumidores, por lo que al esperar ciclos de desarrollo largos, se presentan mayores riesgos de producto. El tiempo de comercialización es incluso más importante para estas aplicaciones y durante la expansión que se avecina de los "dispositivos inteligentes".

El otro impacto de estos nuevos tipos de aplicaciones es su amplitud por sí sola. Potencialmente, juntan al desarrollador de escritorio y su experiencia en las comunicaciones de gran escala, las bases de datos y los análisis de negocios, con los protocolos en la nube con el programador incrustado y su experiencia en hardware y programación a bajo nivel. Los lenguajes y herramientas ayudan a que los conjuntos de las mismas habilidades trabajen a lo largo de todas las aplicaciones para que los proyectos sean más eficaces.

Este era el trasfondo en el que se desarrolló .NET Micro Framework. Los comienzos de esta plataforma se crearon como herramientas internas para desarrollar aplicaciones de inspección de Microsoft SPOT (solo nueve años por delante del mercado). Cuando la plataforma resultó útil para otros proyectos internos, el producto se completó como una plataforma general en 2007.

Los aspectos que impulsan las aplicaciones incrustadas siguen siendo el coste, el rendimiento y la eficiencia de energía. En todo caso, cuando piense en aplicaciones donde desee implementar miles de sensores en un edificio, el coste se vuelve incluso más importante. Los requisitos de potencia y rendimiento también varían con la aplicación. La continua mejora de la gama de aplicaciones que se pueden abarcar con .NET Micro Framework es un área donde Microsoft está centrando los esfuerzos de desarrollo.

Implementación y depuración

Implementar código en su dispositivo es tan fácil como conectarlo y presionar F5, al igual que con la aplicación de Windows Phone. Sin embargo, la instalación es un poco diferente. En el diálogo Proyecto | Propiedades, hay una pestaña .NET Micro Framework donde puede especificar el transporte (USB, serie o TCP/IP) e identificar el dispositivo. El valor predeterminado es USB. Automáticamente identificará un dispositivo .NET Micro Framework, por lo que a menos que esté conectado a varios dispositivos, nunca tendrá que estar en este cuadro de diálogo. En este punto, la solución se compila y los ensamblados se implementan en el dispositivo. Puede seguir todo esto en la ventana Resultados de Visual Studio. La ejecución comienza inmediatamente y puede empezar a depurar el código que se ejecuta en el dispositivo.

También puede implementar la aplicación en un emulador que se ejecute en un equipo de escritorio. La diferencia es que Windows Phone tiene un número relativamente limitado de permutaciones, para que pueda seleccionar el emulador más cercano de un conjunto que se proporciona en Visual Studio. Para .NET Micro Framework, hay un emulador genérico de Microsoft. Probablemente tendrá que crear su propio emulador para que coincida con su hardware. Definitivamente vale la pena analizarlo si desea comenzar a codificar antes de que el hardware esté disponible.

En el pasado, el escenario de depuración de la comunicación entre el robot y la aplicación de Windows Phone podría haberse hecho con un depurador JTAG. Esto es independiente del entorno de desarrollo y externo a un desarrollador .NET, por lo que podría disponer de un desarrollador supervisando lo que ocurre en el teléfono y otro supervisando (con herramientas independientes) lo que ocurre en el dispositivo incrustado. Es posible supervisar simultáneamente los dos en Visual Studio. Puede recorrer el código de teléfono e interrumpirlo en la transmisión de comandos para, a continuación, recorrer paso a paso lo que ocurre con ese comando en Bert.

Resumen

Para explicar de forma completa cómo crear cualquier aplicación incrustada importante en .NET Micro Framework, haría falta un libro completo. El objetivo de este artículo es demostrar que la curva de aprendizaje no es muy pronunciada para poder utilizar sus conocimientos de .NET con aplicaciones incrustadas y .NET Micro Framework.

Este proyecto requiere algunas clases que no forman parte de las bibliotecas de .NET completas. También habrá algunas cosas con las que ya esté familiarizado en .NET Framework completo que no se puedan aprovechar en .NET Micro Framework, pero el entorno de Visual Studio es totalmente compatible con IntelliSense, los puntos de interrupción, los puntos de inspección, la pila de llamadas y con cualquier otra cosa a que esté acostumbrado. Existen algunas aplicaciones incrustadas para las que .NET Micro Framework no es la solución adecuada. Para muchas, sin embargo, funciona bastante bien. Los esfuerzos seguirán ampliando la aplicabilidad de la plataforma con segmentos más grandes de esta parte cada vez mayor y más crucial de la informática.

Ahora ya está listo para probar un proyecto pequeño como programador incrustado.

Vea a Bert en acción

Ahora ya sabe cómo puede poner en práctica sus habilidades de desarrollo para hacer algo divertido. Ha desarrollado una aplicación con la que puede controlar un pequeño robot con un smartphone que tenga el sistema operativo Windows Phone. Los conocimientos de .NET utilizados para desarrollar la aplicación de Windows Phone son igualmente aplicables para el robot. Trabajar hacia delante y atrás entre los dos es transparente. El trabajo está hecho, es el momento de ver Bert en acción: youtu.be/ypuqTju2w4c.

Colin Miller es un director de programas principal en el equipo de Internet de las cosas en Microsoft. Su dirección de correo electrónico de contacto es colin.miller@microsoft.com. Lleva en Microsoft 20 años y ha trabajado en el Internet de las cosas, sistemas incrustados, herramientas de desarrollo, investigación, MSN, Internet Explorer, Word y otros proyectos.

Gracias al siguiente experto técnico de Microsoft por revisar este artículo: Lorenzo Tessiore

Compartir a través de