Il presente articolo è stato tradotto automaticamente.

Micro Framework .NET

Microsoft .NET Framework in applicazioni Embedded

Colin Miller

Scarica il codice di esempio

Il mondo ha percorso una lunga strada dal primo contesto -­editor di codice C sensibile nei primi anni ottanta. Utensileria e lingue sviluppati inizialmente per le applicazioni desktop sono state estese per includere altri ambienti, cloud e server. Microsoft .NET Framework e Visual Studio forniscono strumenti dello stato-of-the-art che aumentano notevolmente l'efficienza del programmatore. .NET Framework strumenti e linguaggi forniscono ricche librerie e strumenti di collaborazione e proteggono i programmatori dagli errori più comuni.

Questi progressi non, tuttavia, è stato reso disponibile a devel­pers lavorando su dispositivi embedded. Il mercato per strumenti incorporati è mancata la scala necessaria per attirare il tipo di investimenti in strumenti per applicazioni PC, server e nube. L'emergere di "dispositivi intelligenti" di tutte le descrizioni sta portando un cambiamento in questo squilibrio.

Con il Micro Framework .NET, c'è stato un nuovo flusso di prodotti, compresi i dispositivi di piccole dimensioni che richiedono un diverso insieme di competenze incorporate per sviluppare il codice. Invece queste sono state sviluppate da individui e team con competenze .NET. Se sei uno sviluppatore .NET e avete pensato a come sfruttare piccoli dispositivi incorporati nelle vostre applicazioni, speriamo che questo articolo vi convincerà che è possibile utilizzare le vostre abilità a partecipare all'esplosione del Internet of Things (IoT) e dispositivi intelligenti.

Perché dovrebbe interessarti? Una recente analisi stima dei processori il 94 per cento previsto spedire nel 2017 non sarà di capacità sufficiente a supportare un ambiente di applicazione .NET tradizionale. Con il Micro Framework .NET, è possibile estendere la vostra portata.

Il Micro Framework .NET è stato inizialmente sviluppato nel progetto Guarda SPOT. È stato parte della famiglia .NET negli ultimi sette anni. Gira su processori a 32 bit troppo piccoli per sostenere OSes completo. È effettivamente .NET in esecuzione direttamente su hardware con il sistema motore e tipo di esecuzione integrato nell'immagine eseguibile.

L'obiettivo di Micro Framework .NET è per aiutare gli sviluppatori .NET creare un'applicazione che gira su un piccolo dispositivo basato su MCU a 32-bit per applicazioni embedded. Alla conferenza Build nel 2014, Microsoft ha descritto un piattaforme gamma di OS che copre lo spazio IoT con Windows Embedded Standard alla fascia alta e .NET Micro Framework per l'estremità piccola del dispositivo.

Embedded Development

Dispositivi intelligenti hanno la capacità di elaborazione locale e possono comunicare con altri dispositivi e, potenzialmente, la nuvola. Per questo articolo, ho creato un piccolo robot mobile che posso controllare da uno smartphone che eseguono il sistema operativo Windows Phone. L'obiettivo è quello di mostrare come sono appena come applicabile sul lato robot competenze .NET che si utilizza per le app di Windows Phone. Gli strumenti e il supporto del linguaggio sono nuovi in questo ambiente, e l'ambiente di sviluppo per lavorare avanti e indietro tra i due è senza soluzione di continuità.

Incontrare Bert — Bert è un robot mobile con quattro ruote alimentati (vedere Figura 1). Egli include una scheda Netduino 2 disponibile per circa $35 di segreto Labs. Un semplice controller consente di comandare i motori su ogni lato del robot di andare avanti e indietro. Non non c'è nessun controllo di velocità, però.

Figura 1 Bert il Robot

Per la comunicazione, Bert include un modulo Bluetooth che comunica con il Netduino tramite un'interfaccia seriale. Si non impattare Bert nulla o correre a lui da un dirupo, ci sono sensori di prossimità IR inclusi nella parte anteriore e posteriore. Ci sono anche i fari e i segnali di girata solo per divertimento.

Il semplice app Windows Phone è derivato da una demo presentata alla conferenza Build. Si collega al dispositivo corretto e utilizza l'accelerometro integrato per sterzare Bert intorno con l'invio di comandi tramite Bluetooth. Potete vedere l'interfaccia in Figura 2, con la selezione a discesa in Figura 3. Selezionare Enumerate scegliere il dispositivo collegato al quale potrai inviare comandi. I comandi si riflettono nelle lettere direzionale sullo schermo.

Figura 2 Windows Phone App interfaccia

Figura 3 dispositivo selezione a discesa

Si può porta .NET Micro Framework per un'altra piattaforma hardware con il Framework .NET Micro Kit di Porting (bit.ly/1wp57qm). Utilizzare il kit per scrivere le interfacce di basso livello hardware specifico su cui si sta eseguendo. Questo è più vicino alla classica attività di programmazione incorporato. La buona notizia è che fornitori hanno già fatto per voi. La scheda Netduino utilizzata in questa applicazione è un esempio di avere tutto il necessario per iniziare la codifica a bordo in Netduino SDK (bit.ly/1CQygzz).

Netduino è un processore Cortex-M3 da STMicro, con 192KB a 384KB di Flash e 60 KB per 100KB di RAM ed è pin-compatibile con Arduino scudi. Potete trovare altri dispositivi che supportano la Micro .NET Framework a GHI Electronics, alpinista, Sparkfun, Adafruit, Amazon e altri negozi.

La scheda è anche hardware open source, quindi una volta che si scrive dell'applicazione e voglia di commercializzare esso, hai diverse opzioni. È possibile utilizzare solo la scheda Netduino per applicazioni a basso volume, ma se il targeting un volume maggiore o specifici requisiti ad esempio di voler integrare elettronica supplementare sul PCB stesso, può prendere l'open source file di progettazione per un fornitore e passare da lì.

Perché ho iniziato con il bordo del Netduino, ho installato il SDK Netduino. Questo include .NET Micro Framework SDK con modelli di Visual Studio e tutto il supporto delle librerie necessarie. Per altre schede di sviluppo, potrebbe essere necessario installare .NET Micro Framework SDK separatamente. il SDK viene fornito con un emulatore, pertanto non è necessario per ottenere qualsiasi hardware per giocare con il Micro Framework .NET, anche se utilizzando l'hardware è più produttivo se sai già cosa sensori che si desidera utilizzare.

Creare l'applicazione Embedded

Dopo aver installato il Netduino SDK (che contiene il .NET Micro Framework SDK), iniziando un .NET Micro Framework applicazione embedded è proprio come qualsiasi altro progetto interno Visual Studiodi partenza. Si seleziona il nuovo progetto e del tipo di applicazione che si desidera avviare. Come mostrato Figura 4, ho selezionato un'applicazione di 2 Netduino far corrispondere la pensione su Bert.

Figura 4 inizio un .NET Micro Framework Embedded Application

Una volta che hai iniziato il progetto, si può saltare a destra in creando il collegamento tra il robot e il telefono.

Come molte applicazioni embedded, Bert gira sulle batterie. Questo significa che il codice deve essere scritto per risparmiare il consumo energetico. La buona notizia è il Framework .NET e .NET Micro Framework sono perfettamente adatti per quello. Se non non c'è nessun thread per eseguire, .NET Micro Framework può mettere automaticamente il processore in uno stato di alimentazione inferiore. Inoltre sta diventando comune per aggiungere un secondo processore efficiente per monitorare gli interrupt e mettere il processore principale in uno stato ancora più basso di potenza. Si vedrà presto se .NET Framework è particolarmente adatto per affrontare questo tipo di programmazione.

Il codice in questa applicazione viene eseguito in risposta a un evento esterno e quindi solo ciò che è necessario rispondere. Così vedrete tutti esecuzione risiede in un gestore eventi o in un thread che ha sospeso la maggior parte del tempo, in questo modo:

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

RunRobot costruttore inizializza le istanze IO guarderò più dettagliatamente e il metodo di RunRobot.Start gli interrupt che scatenano l'esecuzione effettiva:

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

Far funzionare Bluetooth

Ci sono tre passi per ottenere la comunicazione Bluetooth tra Bert e le app di Windows Phone:

1. Cablare il modulo Bluetooth sul robot
2. Inviare comandi dal telefono app
3. Ricevere tali comandi su Bert

Perché il Netduino è compatibile con Arduino, per molte delle connessioni, potrebbe essere in grado di trovare uno scudo è possibile collegare che rende tutte le connessioni necessarie per voi. Arduino è una piattaforma popolare hobbista che ha un ecosistema ricco di periferiche. Si può creare una vasta gamma di soluzioni da moduli esistenti.

Se non vuoi spendere tempo con cablaggio, esaminare i prodotti Gadgeteer da GHI Electronics. Con queste schede e componenti, è possibile utilizzare una procedura guidata per decidere dove inserire i componenti nella connessioni standard (vedere Figura 5), così non hai bisogno di alcuna conoscenza di cablaggio. Il interfaccia di modulo è a un livello altrettanto elevato. Come Arduino, Gadgeteer ha un ricco set di moduli esistenti con cui creare la vostra soluzione. Una volta che avete i moduli collegati, ancora codice in .NET Micro Framework. Ciò è particolarmente utile per una rapida prototipazione vostre idee.

Figura 5 connessioni visualizzando Gadgeteer guidata

Nel caso di Bert, non sto usando Gadgeteer, ma raccogliendo i miei propri moduli.  Il modulo Bluetooth (HC-06) utilizza un'interfaccia seriale con quattro connessioni — VIN, GND, RX e TX. Collegare il VIN (In tensione) per entrambi i 5V o 3.3 v uscite dal Netduino, quindi collegare una delle connessioni GND GND. Guardando la tabella I/O per il Netduino in Figura 6, vedrete per collegare il modulo BT RX (ricezione) il Netduino TX (trasmissione) e il modulo BT TX a RX Netduino della porta seriale COM1. Se necessario, ci sono un certo numero di esempi di questi moduli di collegamento al microcontroller comuni sul Web.

Figura 6 Netduino IO Pins definito

Con quelle connessioni effettuate, si può accendere il Netduino (che alimenta il modulo BT) e accoppiare il dispositivo con il telefono. Il nome predefinito per il modulo BT è HC-06, quindi può abbinare con quello. Ho cambiato il nome Bert utilizzando comandi AT. Invia una matrice di byte con i caratteri "AT + NAMEBert" per modificare il nome del modulo BT. È anche possibile utilizzare questa interfaccia per configurare il modulo Bluetooth , compreso le cose come il baud rate di comunicazione.

Ora è possibile utilizzare il telefono per connettersi a Bert come si farebbe con qualsiasi altro BT dispositivo e avviare l'invio di comandi. Innanzitutto, l'accelerometro integrato di accesso e impostare un ragionevole intervallo di report, così come non a Bert poveri di palude:

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

Il gestore di eventi ReadingChanged invia comandi, come mostrato nella Figura 7.

Figura 7 il gestore eventi per l'invio di comandi 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);
  }

Ricevere ed eseguire comandi

Ora si può considerare la ricezione di un comando sul lato di robot. Il modulo BT è collegato alla prima porta seriale sul Netduino. Creare un'istanza di SerialPort e un buffer dei messaggi, proprio come si farebbe su altre versioni di .NET Framework:

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

Quindi configurare la porta seriale per comunicazione con il modulo Bluetooth (9600 baud è l'impostazione predefinita; Questo potrei ripristinare tramite comandi AT, ma questa sarà una comunicazione molto sparsa per semplificare il programma, quindi velocità più veloci sono inutili):

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

Poi ho creato un gestore di evento DataReceived che innesca la maggior parte dell'elaborazione all'interno della app. In altre parole, Bert dorme fino a quando non riceve un comando. Il processore rimane in su lungo abbastanza per impostare i motori nello stato giusto e torna a dormire:

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

Comandi in ingresso vengono elaborati nel gestore eventi, come mostrato Figura 8.

Figura 8 i comandi in ingresso per avviare Bert in movimento

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

Nessuno di quel codice è diverso rispetto a quello che vuoi scrivi sul desktop.

Mettere in moto le Bert

Il controller del motore che usare semplicemente mi richiede di impostare quattro ingressi in qualche stato logico per determinare come girare le ruote. La logica è:

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

Per scrivere queste, creo un OutputPort e legarlo ad uno dei pin digitali Netduino mostrato Figura 6. OutputPort è una classe unica in .NET Framework perché i dispositivi che eseguono in genere completa di .NET Framework non possono affrontare le singole porte dei / o digitali. Ci sono una manciata di nuove classi in .NET Micro Framework per gestire i tipi di I/O supplementari e altri problemi di questo spazio di applicazione come gestione del potere:

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

Guidare con prudenza

Non voglio Bert imbattersi in cose per il suo bene e per la sicurezza di cose e persone intorno a lui, così ho installato i sensori di prossimità a infrarossi da forte nella parte anteriore e posteriore. Questi sensori di restituiscono un valore da 0.0 a 1.0 a seconda della distanza all'oggetto più vicino che riflette la luce IR proiettata.

Il sensore anteriore è puntato diagonalmente verso il basso la terra circa 18 pollici davanti a Bert di rilevamento. Questo mi permette di utilizzare un sensore per rilevare gli oggetti, come pure al suolo cadendo lontano se sta avvicinando un set di scale, per esempio. I valori di ritorno di questi sensori sono analogici, che significa creare un'istanza di un'altra classe unica in .NET Framework .NET Micro 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);

Questo costruttore identifica specifica porta analogica alla quale sto connettendo, un moltiplicatore che posso usare per convertire l'output in una gamma più conveniente, un offset per modificare l'output per la comodità e la precisione dell'output con -1 significato di massima precisione. Per fare queste misurazioni periodicamente e lasciare che il sonno processore in quanto possibile, le letture sono innescate da un timer. Ho impostato questo quando comincio ad accettare comandi dal telefono e smaltirla quando non sono:

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

Scopo generale Interrupt

L'ultimo nuovo che devo introdurre è il InterruptPort classe. Questo mi permette di monitorare le modifiche in ingresso digitale e trigger su cambiamenti, come il bordo di un cambiamento dal Low all'alto, per esempio. Sto usando questo per il pulsante sulla scheda Netduino che ottiene Bert a rispondere ai comandi dal telefono. Ciò significa che egli ignora comandi fino a quando questo pulsante viene premuto e li ignora dopo premendo nuovamente:

// 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 è il collegamento interno per l'interruttore sulla scheda Netduino. È possibile collegare un interruttore a una qualsiasi delle porte digitali elencate Figura 6. Il secondo argomento è che se ho bisogno di un filtro di glitch applicato a questo interruttore di ingresso per evitare più trigger per un singolo tasto.

Il parametro successivo è se c'è un pull up o tirare giù il resistore sull'interruttore. Indica la posizione di porta predefinito quando non è premuto il pulsante (alta o Low). Il parametro successivo è impostato per far scattare l'interrupt sulla transizione al alta così il dito è allontanato se Bert si toglie immediatamente. Con l'istanza di InterruptPort creato, posso assegnare il gestore di interrupt:

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

Il gestore di interrupt inizia Bert monitoraggio tutti i comandi provenienti dal telefono, come si può vedere Figura 9.

Figura 9 interrompere gestore attivando il comando di monitoraggio

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
}

Applicazioni embedded e .NET Micro Framework

Applicazioni embedded in genere eseguono un set di funzioni di destinazione su hardware predisposto per soddisfare i requisiti minimi. Lavorazione mirate e sintonizzate applicazioni embedded richiede un maggiore investimento iniziale. Che l'investimento è recuperato sopra un più lungo ciclo di vita del prodotto.

Una delle più grandi sfide per lo sviluppo embedded tradizionale è il tempo che necessario per completare i progetti. Una grande proporzione di incorporare­­ded progetti vengono abbandonate perché il costo diventa troppo grande o i requisiti cambiano prima che i progetti possono ottenere sul mercato.

Un certo numero di cose colpiscono la dinamica dell'applicazione embedded­cationi. Quando Microsoft rilasciato .NET Micro Framework sette anni fa, più embedded applicazioni sono state costruite su processori a 8 bit per ridurre i costi, ottenere i requisiti prestazionali necessari e soddisfare i requisiti di potenza (la possibilità di eseguire una batteria per lunghi periodi, ad esempio).

Allo stesso tempo, la maggior parte della crescita nello spazio incorporato mirati processori a 32 bit come l'ARM7. Questi processori sono state continuando a scendere di prezzo e offerto prestazioni adeguate per molte applicazioni e stava migliorando i consumi. I più recenti processori Cortex continuano ad attrarre molte nuove applicazioni embedded alla famiglia a 32-bit.

Recentemente, ci sono stati ulteriori dispositivi che sono parte integrante delle applicazioni più ampie, compresi dispositivi embedded, gateway, nube connettività, database, applicazioni di business intelligence e così via. Queste nuove applicazioni cambiano l'economia di applicazioni embedded.

Diventa più importante aderire ai protocolli di comunicazione comuni. Più di questi nuovi dispositivi sono nel Regno dei consumatori, quindi aspetta i cicli di sviluppo lungo significa prodotto aumentato i rischi. Tempo di mercato è ancora più importante per queste applicazioni e durante i prossimo esplosione di "dispositivi intelligenti".

L'altro impatto di questi nuovi tipi di applicazioni è la loro larghezza da solo. Potenzialmente riunire lo sviluppatore desktop e la sua esperienza nella comunicazione su larga scala, i database e analitica di affari e nube protocolli con lo sviluppatore incorporato e la sua perizia nell'hardware e programmazione a basso livello. Strumenti e linguaggi aiutano set di stesso-abilità a lavorare in tutta l'intere applicazioni per progetti più efficiente.

Questo era lo sfondo per il quale è stato sviluppato il Micro Framework .NET. Gli inizi di questa piattaforma sono stati creati come strumenti interni per lo sviluppo di applicazioni di Microsoft SPOT orologio (solo nove anni più avanti il mercato). Quando la piattaforma è diventato utile per altri progetti interni, il prodotto era arrotondato come una piattaforma generale nel 2007.

I driver di applicazione embedded di costo, prestazioni ed efficienza di potere non sono andato via. Semmai, quando si parla di applicazioni di cui si desidera distribuire migliaia di sensori in un edificio, il costo diventa ancora più critica. Requisiti di prestazioni e potenza variano con l'applicazione, come pure. Continuando a migliorare la gamma di applicazioni che può essere raggiunto con il Micro Framework .NET è un'area in corso di messa a fuoco per gli sforzi di sviluppo Microsoft.

Distribuzione e Debug

Distribuire il codice dispositivo è facile come collegarlo e premendo F5, proprio come con le app di Windows Phone. Tuttavia, l'installazione è un po' diverso. Nel progetto | Finestra di dialogo Proprietà, c'è una scheda .NET Micro Framework dove è possibile specificare il trasporto (USB, seriale o TCP/IP) e identificare il dispositivo. Il valore predefinito è USB. Identificherà automaticamente un dispositivo .NET Micro Framework, quindi a meno che non sei connesso a diversi dispositivi, non può mai devi essere in questa finestra di dialogo. A questo punto, la soluzione è costruita e gli assembly distribuiti al dispositivo. Potete seguire tutto questo nella finestra di Output in Visual Studio. L'esecuzione inizia immediatamente e si può avviare il debug il codice in esecuzione sul dispositivo.

È inoltre possibile distribuire l'applicazione a un emulatore in esecuzione su un PC desktop. La differenza è che Windows Phone ha un numero relativamente limitato di permutazioni, è possibile selezionare l'emulatore più vicina da un set fornito in Visual Studio. Per il Micro Framework .NET, c'è un emulatore generico di Microsoft. Molto probabilmente dovrete creare il tuo emulatore per abbinare il vostro hardware. Questo è sicuramente merita di essere esaminata se volete iniziare la codifica prima che l'hardware è disponibile.

In passato, lo scenario di debug la comunicazione tra il robot e l'app Windows Phone avrebbe potuto fare con un debugger JTAG. Questo è separato dall'ambiente di sviluppo e stranieri a uno sviluppatore .NET, pertanto potrebbe essere uno sviluppatore monitoraggio di ciò che sta accadendo al telefono e uno di monitoraggio (in strumenti separati) ciò che sta accadendo sul dispositivo incorporato. È possibile monitorare sia simultaneamente in Visual Studio. È possibile eseguire il codice del telefono e rompere sulla trasmissione comando, poi passo in ciò che accade a quel comando su Bert.

Avvolgendo

Il quadro completo di come creare qualsiasi significativa applicazione embedded su .NET Micro Framework richiederebbe un intero libro. L'obiettivo di questo articolo era di dimostrare che la curva di apprendimento non è molto ripida per utilizzare le vostre abilità di .NET per applicazioni embedded e .NET Micro Framework.

Questo progetto richiede poche classi che non fanno parte delle librerie .NET completa. Ci saranno anche alcune cose che hai familiarità con il .NET Framework completo che lei non poteva spremere in .NET Micro Framework, ma l'ambiente di Visual Studio è completamente supportato con IntelliSense, interruzione, punti di Guarda, nello stack di chiamate e quant'altro siete abituati a. Ci sono applicazioni embedded là fuori per cui il Micro Framework .NET non è la soluzione giusta. Per molti, però, funziona abbastanza bene. Sforzi continuano ad ampliare l'applicabilità della piattaforma ai segmenti più grande di questa parte crescente e sempre più critica dell'informatica.

Così ora sei pronto per provare un piccolo progetto come un programmatore incorporato.

Vedere Bert in azione

Ora sapete come mettere la vostra abilità di sviluppo a buon uso per qualcosa di divertente. Hai sviluppato un app con cui è possibile controllare un piccolo robot utilizzando uno smartphone che eseguono il sistema operativo Windows Phone. Le competenze di .NET che è stato utilizzato per sviluppare le app di Windows Phone sono ugualmente applicabili per il robot. Lavorare avanti e indietro tra i due è senza soluzione di continuità. Il lavoro è fatto — è il momento di vedere Bert in azione: youtu.be/ypuqTju2w4c.

---

Colin Miller è principal program manager del team di Internet of Things in Microsoft. Contattarlo al colin.miller@microsoft.com. Egli è stato a Microsoft per 20 anni e ha lavorato sull'Internet delle cose, Embedded, strumenti di sviluppo, ricerca, MSN, Internet Explorer, Word e altri progetti.

Grazie al seguente Microsoft esperto tecnico per la revisione di questo articolo: Lorenzo Tessiore