Partager via

Cet article a fait l'objet d'une traduction automatique.

.NET Micro Framework

Microsoft .NET Framework dans des applications incorporées

Colin Miller

Téléchargez l'exemple de Code

Le monde a parcouru un long chemin depuis le premier contexte -­éditeur de code C sensible dans les années 1980. Outillage et langues développés initialement pour les applications de bureau ont été étendues pour englober le serveur, de nuages et d'autres environnements. Microsoft .NET Framework et Visual Studio fournissent des outils de state-of-the-art qui augmentent considérablement l'efficacité du programmeur. Les outils du .NET Framework et les langues offrent de riches bibliothèques et outils de collaboration et protègent les programmeurs des erreurs plus communes.

Ces progrès n'ont pas, toutefois, été mis à la disposition de devel­opers travaillant sur incorporé les dispositifs. Le marché des outils embarqués il manquait l'échelle nécessaire pour attirer le genre d'investissements réalisés dans les outils pour les applications PC, serveur et nuage. L'émergence des « dispositifs intelligents » de toutes les descriptions entraîne un changement dans ce déséquilibre.

Avec le Micro de .NET Framework, il y a eu un flux de données de produits, y compris les petits appareils qui nécessitent un ensemble de compétences embarqués à développer un code différent. Au contraire, celle-ci a été développée par les individus et les équipes avec compétences .NET. Si vous êtes un développeur .NET et que vous avez pensé à comment exploiter les petits périphériques intégrés dans vos applications, j'espère que cet article saura vous convaincre que vous pouvez utiliser vos compétences pour participer à l'explosion de l'Internet des objets (IDO) et dispositifs intelligents.

Pourquoi s'en soucier ? Une analyse récente estime que 94 pour cent des processeurs prévue pour 2017 ne sera pas d'une capacité suffisante pour soutenir un environnement d'application .NET traditionnel. Avec le Micro de .NET Framework, vous pouvez étendre votre portée.

Le Micro de .NET Framework a été initialement développé dans le projet de surveillance SPOT. Il a été membre de la famille de .NET pour les sept dernières années. Il fonctionne sur les processeurs 32 bits trop petits pour soutenir les systèmes d'exploitation complet. C'est en réalité .NET s'exécutant directement sur le matériel avec le système de moteur et le type d'exécution intégré dans l'image exécutable.

Le .NET Micro Framework vise à aider les développeurs .NET de créer une application qui s'exécute sur un petit 32-bit MCU-appareil pour les applications embarquées. Lors de la Conférence Build en 2014, Microsoft décrit une plateformes gamme d'OS couvrant l'espace ITO avec Windows Embedded Standard à haut de gamme et le Micro du .NET Framework pour la fin du petit appareil.

Développement embarqué

Des appareils intelligents ont des capacités informatiques locales et peuvent communiquer avec les autres dispositifs et, éventuellement, le nuage. Pour cet article, j'ai créé un petit robot mobile, que je peux contrôler depuis un smartphone sous l'OS de Windows Phone. L'objectif est de montrer comment les compétences .NET que vous utiliser pour l'application Windows Phone sont aussi applicables sur le côté du robot. Les outils et la prise en charge linguistique sont nouveautés dans cet environnement, et l'environnement de développement pour travailler dans les deux sens entre les deux est transparent.

Répondre à Bert — Bert est un robot mobile avec quatre roues (voir Figure 1). Il comprend un Conseil de Netduino 2 disponible pour environ 35 $ par Secret Labs. Un contrôleur simple vous permet de contrôler les moteurs sur chaque côté du robot pour aller vers l'avant et vers l'arrière. Il n'y a aucun contrôle de la vitesse, cependant.

Bert le Robot
Figure 1 Bert le Robot

Pour la communication, Bert comprend un module Bluetooth qui communique avec le Netduino via une interface série. Pour s'assurer que vous ne crash Bert dans quoi que ce soit ou de lui rouler une falaise, il y a des détecteurs de proximité IR inclus à l'avant et l'arrière. Il y a aussi des phares et clignotants, juste pour le plaisir.

L'application simple de Windows Phone est dérivée d'une démo présentée à la Conférence Build. Il se connecte à l'appareil et utilise l'accéléromètre embarqué pour diriger Bert autour en envoyant des commandes via Bluetooth. Vous pouvez voir l'interface en Figure 2, avec la sélection de liste déroulante dans Figure 3. Sélectionnez Enumerate pour sélectionner l'appareil connecté à qui vous allez envoyer des commandes. Les commandes sont consignées dans les lettres directionnelles à l'écran.

Windows Phone Interface App
Figure 2 Windows Phone Interface App

Device Selection liste déroulante
Figure 3 Device Selection liste déroulante

Vous pouvez transférer le .NET Micro Framework à une autre plate-forme matérielle avec le Kit de Portage .NET Micro Framework (bit.ly/1wp57qm). Le kit permet d'écrire des interfaces bas niveau pour le matériel spécifique sur lequel vous êtes en cours d'exécution. C'est plus proche des activités de programmation incorporées classiques. Les bonnes nouvelles sont vendeurs ont déjà fait cela pour vous. Le jury Netduino utilisé dans cette application est un exemple d'avoir tout ce vous avez besoin pour commencer à coder au Conseil dans le SDK Netduino (bit.ly/1CQygzz).

Netduino est un processeur Cortex-M3 de STMicro, avec 192 ko à 384 Ko de Flash et 60 Ko à 100 Ko de RAM et brochage compatible avec Arduino shields. Vous pouvez trouver d'autres périphériques prenant en charge le .NET Micro Framework à GHI Electronics, alpiniste, Sparkfun, Adafruit, Amazon et autres magasins.

Le Conseil est également matériel opensource, donc une fois que vous écrivez votre application et que vous souhaitez commercialiser, vous disposez de plusieurs options. Vous pouvez simplement utiliser le jury Netduino pour des applications de faible volume, mais si vous ciblez un volume plus élevé ou qui ont des exigences spécifiques telles que de vouloir intégrer l'électronique supplémentaire sur le même PCB, vous pouvez prendre l'open source des fichiers de conception à un fabricant de la carte et à partir de là.

Parce que j'ai commencé avec le jury Netduino, j'ai installé le SDK Netduino. Cela inclut le .NET Micro Framework SDK avec les modèles Visual Studio et tout le soutien nécessaire de bibliothèque. Pour d'autres conseils de développement, vous devrez peut-être installer .NET Micro Framework SDK séparément. Le SDK est livré avec un émulateur, donc vous n'avez pas besoin d'obtenir n'importe quel matériel de jouer avec le Micro de .NET Framework, bien que l'utilisation de matériel est plus productif si vous savez déjà quelles sondes à utiliser.

Créer l'Application embarquée

Après avoir installé le SDK Netduino (qui contient le kit de développement .NET Micro Framework), à partir d'un Micro de .NET Framework application embarquée est tout comme à partir d'autres projets au sein du Visual Studio. Vous sélectionnez Nouveau projet et le type d'application que vous souhaitez démarrer. Comme le montre Figure 4, j'ai sélectionné une Application de 2 Netduino pour faire correspondre le jury sur Bert.

Start a .NET Framework Micro Application Embedded
Figure 4 Start a .NET Framework Micro Application Embedded

Une fois que vous avez commencé le projet, vous pouvez sauter à droite dans la création de la liaison de communication entre le robot et le téléphone.

Comme beaucoup d'applications embedded, Bert fonctionne sur piles. Cela signifie que votre code doit être écrit pour économiser la consommation d'énergie. La bonne nouvelle est le .NET Framework et le .NET Micro Framework conviennent parfaitement pour ça. S'il n'y a aucun thread à exécuter, le Micro de .NET Framework peut mettre automatiquement le processeur dans un état de puissance inférieur. Il devient aussi courant d'ajouter un second processeur efficace pour surveiller les interruptions et mettre le processeur principal dans un état d'alimentation encore plus bas. Vous verrez bientôt si le .NET Framework est bien adapté pour traiter ce type de programmation.

Le code de cette application s'exécute en réponse à un événement extérieur et ensuite seulement ce qui est nécessaire pour répondre. Donc vous ne verrez pas l'exécution de tous réside dans un gestionnaire d'événements ou dans un thread qui a suspendu la plupart du temps, comme suit :

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

Le constructeur RunRobot Initialise les instances d'e/s que je vais regarder plus en détail et définit la méthode de RunRobot.Start les interruptions qui déclenchent l'exécution réelle :

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

Faire fonctionner Bluetooth

Il y a trois étapes pour obtenir la communication Bluetooth travaillant entre Bert et l'application Windows Phone :

  1. Relier le module Bluetooth sur le robot
  2. Envoyer des commandes de l'application téléphone
  3. Recevoir ces commandes sur Bert

Parce que le Netduino est compatible Arduino, pour la plupart des connexions, vous pourriez être en mesure de trouver un bouclier, que vous pouvez brancher qui rend toutes les connexions nécessaires pour vous. L'Arduino est une plate-forme populaire amateur qui a un riche écosystème de périphériques. Vous pouvez artisanat une large gamme de solutions de modules existants.

Si vous ne voulez pas passer du temps avec câblage, regarder dans les produits Gadgeteer de GHI Electronics. Avec ces cartes et les composants, vous pouvez utiliser un Assistant pour décider où brancher les composants dans des connexions standard (voir Figure 5), de sorte que vous n'avez pas besoin d'aucune connaissance de branchements. Les interfaces du module sont à un niveau élevé de la même façon. Comme Arduino, Gadgeteer possède un riche ensemble de modules existants pour créer votre solution. Une fois que vous avez les modules connectés, vous utilisez toujours le codage dans le Micro de .NET Framework. Ceci est particulièrement utile pour le prototypage rapidement vos idées.

Assistant Gadgeteer montrant connexions
Figure 5 Assistant Gadgeteer montrant connexions

Dans le cas de Bert, je ne suis pas à l'aide de Gadgeteer, mais recueillir mes propres modules.  Le module Bluetooth (HC-06) utilise une interface série avec quatre connexions — VIN, GND, RX et TX. Connectez le VIN (tension dans) le 5V ou 3.3V est diffusé par le Netduino, puis connecter une des connexions GND GND. En regardant le tableau de I/O pour la Netduino dans Figure 6, vous verrez pour connecter le module BT RX (réception) à le Netduino TX (transmission) et le Module BT TX RX Netduino du port série COM1. Si nécessaire, il y a un certain nombre d'exemples de connexion de ces modules pour microcontrôleurs commune sur le Web.

Netduino IO Pins définies
Figure 6 Netduino IO Pins définies

Avec ces connexions effectuées, vous pouvez allumer le Netduino (qui alimente le module BT) et jumeler l'appareil avec le téléphone. Le nom par défaut du module BT est HC-06, donc vous pouvez coupler avec ça. J'ai changé le nom de Bert à l'aide de commandes AT. Envoyer un tableau d'octets avec les caractères « AT + NAMEBert » de changer le nom du module BT. Vous pouvez également utiliser cette interface pour configurer le module Bluetooth , y compris des choses comme la vitesse de transmission de communication.

Vous pouvez maintenant utiliser le téléphone pour se connecter à Bert, comme vous le feriez pour n'importe quel autre BT dispositif et commencer à envoyer des commandes. Tout d'abord, j'ai accéder l'accéléromètre embarqué et mettre en place un intervalle de rapport raisonnable, pour éviter la mauvais Bert des marais :

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

Le gestionnaire d'événements ReadingChanged envoie des commandes, comme indiqué dans Figure 7.

Figure 7 le gestionnaire d'événements pour envoyer des commandes à 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);
  }

Recevoir et exécuter des commandes

Maintenant vous pouvez envisager de réception d'une commande sur le côté du robot. Le module BT est câblé sur le premier port série sur le Netduino. Créez une instance de SerialPort et un tampon de messages, comme vous le feriez sur d'autres versions du .NET Framework :

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

Puis configurer le port série pour la communication avec le module Bluetooth (9600 bauds est la valeur par défaut ; Je pourrais cela réinitialiser à l'aide de commandes AT, mais il s'agit d'une communication très clairsemée de simplifier le programme, donc des vitesses plus rapides sont inutiles) :

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

Puis j'ai mis en place un gestionnaire d'événement DataReceived qui déclenche l'essentiel du traitement au sein de l'app. En d'autres termes, Bert dort jusqu'à ce qu'il reçoive une commande. Le processeur reste debout longtemps assez pour définir les moteurs dans l'état de droit et se rendort :

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

Commandes entrantes sont traitées dans le gestionnaire d'événements, comme le montre Figure 8.

Figure 8 les commandes entrantes pour démarrer Bert se déplaçant

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

Aucun de ce code est différent de ce que vous écririez sur le bureau.

Bert Set in Motion

Le contrôleur de moteur que j'utilise simplement m'oblige à définir quatre entrées dans certains état logique pour déterminer comment les roues tournent. La logique est :

/*        
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 
*/

Pour écrire à ces derniers, j'ai créer un OutputPort et attachez-le à l'une des broches numériques Netduino montrés dans Figure 6. OutputPort est une classe unique dans le .NET Framework, car les périphériques qui exécutent la version complète de .NET Framework en général ne peut pas résoudre les différents ports d'e/s numériques. Il y a une poignée de nouvelles classes dans le .NET Micro Framework pour gérer les types de I/O supplémentaires et autres questions propres à cet espace d'application comme la gestion de l'alimentation :

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

Conduisez prudemment

Je ne veux pas de Bert pour fonctionner dans les choses pour lui-même et pour la sécurité des choses et des gens autour de lui, alors j'ai installé des détecteurs de proximité infrarouge Sharp dans le recto et le verso. Ces capteurs renvoyer une valeur de 0.0 à 1.0 selon la distance à l'objet le plus proche qui reflète la lumière infrarouge projetée.

Le capteur avant est pointé en diagonale vers le bas de télédétection au sol d'environ 18 pouces devant Bert. Cela me permet d'utiliser un capteur pour détecter des objets, ainsi que le terrain apostasie si il s'approche un ensemble d'escaliers, par exemple. Les valeurs de retournent de ces capteurs sont analogiques, ce qui signifie que je crée une instance d'une autre classe unique dans le .NET Framework pour le Micro de .NET Framework, la 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);

Ce constructeur identifie le port analogique spécifique auquel je me connecte, un multiplicateur, je peux utiliser pour convertir la sortie d'une gamme plus commode, un décalage de modifier la sortie pour la commodité et la précision de la sortie avec -1, ce qui signifie que la précision maximale. Pour effectuer ces mesures périodiquement et laisser le sommeil processeur autant que possible, les lectures sont déclenchées par une minuterie. J'ai mis cela lorsque j'ai commencer à accepter les commandes depuis le téléphone et la jeter quand je ne suis pas :

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

Interruption d'usage général

La dernière classe de nouveau que j'ai besoin de mettre en place est la classe InterruptPort. Cela me permet de surveiller les changements dans les entrées numériques et des déclencheurs sur les modifications comme l'avant-garde d'un changement de Low à élevé, par exemple. J'utilise ceci pour le bouton sur le bord de Netduino qui obtient Bert pour répondre aux commandes du téléphone. Cela signifie qu'il ignore les commandes jusqu'à ce que ce bouton est enfoncé et après avoir appuyé à nouveau sur elle les ignore :

// 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 est la connexion interne pour l'interrupteur sur le tableau de Netduino. Vous pouvez connecter un commutateur à l'un des ports numériques énumérés dans Figure 6. Le second argument est que si j'ai besoin d'un filtre de glitch appliqué à cet interrupteur d'entrée afin d'éviter plusieurs déclencheurs d'un bouton unique.

Le paramètre suivant est de savoir s'il existe une traction vers le haut ou le tirer vers le bas de la résistance sur l'interrupteur. Cela définit la position de port par défaut lorsque le bouton n'est pas pressé (haute ou Low). Le paramètre suivant est défini pour déclencher l'interruption sur la transition vers la haute donc votre doigt est à l'écart si Bert décolle immédiatement. Avec l'instance de InterruptPort créé, je peux assigner le gestionnaire d'interruption :

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

Le gestionnaire d'interruption commence Bert contrôle toutes les commandes venant du téléphone, comme vous pouvez le voir dans Figure 9.

Figure 9 interrompre gestionnaire d'activer le suivi de commande

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
}

Les Applications embarquées et .NET Micro Framework

Applications embarquées effectuent généralement un ensemble ciblé de fonctions sur un matériel conçu pour répondre aux exigences minimales. Artisanat ciblées et à l'écoute des applications embarquées nécessite un investissement initial plus élevé. Cet investissement est récupéré sur un plus long cycle de vie.

Un des plus grands défis pour le développement embarqué traditionnel est le temps que nécessaire pour effectuer des projets. Intégrer une grande partie des­­ded projets sont abandonnés car le coût devient trop important, ou les spécifications changent avant que les projets peuvent accéder au marché.

Un certain nombre de choses influent sur la dynamique des appli incorporé­cations. Lorsque Microsoft a publié Premièrement .NET Micro Framework sept ans il y a des applications plus embarquées ont été construites sur les processeurs 8-bits pour réduire les coûts, satisfaire aux exigences de performance requises et répondre aux exigences de puissance (la capacité à fonctionner sur une batterie pendant de longues périodes, par exemple).

Dans le même temps, la croissance dans l'espace inclus ciblées processeurs 32 bits comme l'ARM7. Ces processeurs continuaient de descendre dans le prix et a offert une performance adéquate pour de nombreuses applications et amélioration de la consommation d'énergie. Les nouveaux processeurs Cortex continuent d'attirer de nombreuses nouvelles applications embarquées à la famille de 32 bits.

Récemment, il y a eu plus d'appareils qui font partie intégrante des applications plus larges, y compris les appareils embarqués, passerelles, connectivité cloud, bases de données, les applications décisionnelles, et ainsi de suite. Ces nouvelles applications changent l'économie des applications embarquées.

Il devient plus important d'adhérer aux protocoles de communication communs. Plusieurs de ces nouveaux appareils sont dans le domaine de la consommation, donc attend les cycles de développement longs signifie produit une augmentation de risques. Délais de commercialisation est encore plus important pour ces applications et lors de l'explosion qui viennent des « dispositifs intelligents. »

L'autre impact de ces nouveaux types d'applications est leur largeur seul. Potentiellement, ils réunissent le bureau développeur et son expertise en communication haut de gamme, bases de données et analytique de l'entreprise et protocoles avec le développeur embarqué et son expertise dans le matériel et programmation bas niveau des nuages. Les outils et langages aident même-compétences nécessaires pour travailler dans les applications complètes pour des projets plus efficaces.

C'est dans ce contexte, pour lesquels le .NET Micro Framework a été développé. Les débuts de cette plateforme ont été créés comme des outils internes pour développer des applications de Microsoft SPOT montre (seulement neuf ans d'avance sur le marché). Lorsque la plate-forme est devenu utile pour d'autres projets internes, le produit a été complété comme une plate-forme générale en 2007.

Les pilotes de l'application embarquée de coût, de performance et d'efficacité énergétique n'ont pas disparu. Au contraire, quand vous parlez des applications où vous voulez déployer des milliers de capteurs dans un bâtiment, le coût devient encore plus critique. Exigences de performance et de puissance varient selon l'application, aussi bien. Continuer à améliorer la gamme des applications qui peuvent être atteints avec le Micro de .NET Framework est un domaine en cours d'activité pour les efforts de développement de Microsoft.

Déployer et déboguer

Déploiement de code de votre appareil est aussi simple que de brancher et en appuyant sur F5, tout comme avec l'application Windows Phone. Toutefois, le programme d'installation est un peu différent. Dans le projet | Boîte de dialogue Propriétés, il ya un onglet .NET Micro Framework où vous pouvez spécifier le transport (USB, série ou TCP/IP) et l'identification de l'appareil. La valeur par défaut est USB. Elle identifiera automatiquement un périphérique .NET Micro Framework, sauf si vous êtes connecté à plusieurs appareils, vous devrez peut-être jamais être dans cette boîte de dialogue. À ce stade, la solution est construite et les assemblys déployés dans l'appareil. Vous pouvez suivre tout cela dans la fenêtre sortie dans Visual Studio. L'exécution commence immédiatement et vous pouvez commencez à déboguer le code qui s'exécute sur l'appareil.

Vous pouvez également déployer l'application à un émulateur en cours d'exécution sur un ordinateur de bureau. La différence, c'est que Windows Phone a un nombre relativement limité de permutations, ainsi vous pouvez choisir l'émulateur plus proche d'un ensemble fourni dans Visual Studio. Pour le Micro de .NET Framework, il y a un émulateur générique de Microsoft. Très probablement, vous devrez créer votre propre émulateur pour correspondre à votre matériel. Cela vaut vraiment la peine de regarder dans si vous voulez commencer à coder avant que votre matériel soit disponible.

Dans le passé, le scénario pour le débogage de la communication entre le robot et l'application Windows Phone aurait pu être fait avec un débogueur JTAG. C'est séparée de l'environnement de développement et étrangers pour un développeur .NET, donc vous pourriez avoir un développeur suivi ce qui se passe sur le téléphone et un suivi (dans outils distincts), ce qui se passe sur l'appareil embarqué. Vous pouvez surveiller tous les deux en même temps dans le Visual Studio. Vous pouvez parcourir le code téléphone et Rodez sur la transmission de la commande, puis entrez dans ce qui se passe à cette commande sur Bert.

Récapitulation

Le tableau complet de création de toute application embarquée significative sur le .NET Micro Framework prendrait un livre entier. L'objectif de cet article était de démontrer que la courbe d'apprentissage n'est pas très raide à utiliser vos compétences .NET pour les applications embarquées et le Micro de .NET Framework.

Ce projet nécessite un peu de classes qui ne font pas partie des bibliothèques .NET complètes. Il y aura aussi des choses que vous connaissez sur le .NET Framework complet que vous ne pouvait pas serrer dans le Micro de .NET Framework, mais l'environnement Visual Studio est complètement pris en charge avec IntelliSense, points d'arrêt, les points de la montre, pile des appels et tout ce que vous avez l'habitude de. Il y a des applications embarquées là-bas pour lesquels le .NET Micro Framework n'est pas la bonne solution. Pour beaucoup, cependant, cela fonctionne plutôt bien. On continue d'élargir l'applicabilité de la plate-forme à plus grands segments de la présente partie croissante et de plus en plus critique de l'informatique.

Alors maintenant vous êtes prêt à essayer un petit projet comme un programmeur incorporé.

Voir Bert en Action

Maintenant vous savez comment mettre vos compétences de développement à bon escient pour quelque chose d'amusant. Vous avez développé une application avec laquelle vous pouvez contrôler un petit robot à l'aide d'un smartphone sous l'OS de Windows Phone. Les compétences .NET que vous permettant de développer l'application Windows Phone sont également applicables pour le robot. Travaillant dans les deux sens entre les deux est sans couture. Votre travail est fait, il est temps de voir Bert en action : youtu.be/ypuqTju2w4c.

Colin Miller est responsable de programme principal de l'équipe Internet of Things chez Microsoft. Le contacter au colin.miller@microsoft.com. Il est depuis 20 ans chez Microsoft et a travaillé sur l'Internet des objets, Embedded, outils de développement, recherche, MSN, Internet Explorer, Word et autres projets.

Merci à l'expert technique suivante de Microsoft pour l'examen de cet article : Lorenzo Tessiore