Este artigo foi traduzido por máquina.

Programação incorporada

Conectado dispositivos usando o .NET Framework Micro

Colin Miller

Baixe o código de exemplo

Hoje em dia, vemos uma proliferação de aplicativos incluem dispositivos conectados. Na verdade, a “ Internet das coisas ” (dispositivos conectados através da Internet) já é estimada para ser maior do que a World Wide Web em termos de pontos de extremidade e é projetada para crescer para uma ordem de magnitude maiores nos próximos anos.

No futuro próximo, vai ser interagir com dispositivos mais inteligentes, em vez de computadores pode ser reconhecidos. Basta procure em torno de sua casa. As coisas que podem ser conectadas útil incluem seus dispositivos (para gerenciamento de energia, as atualizações de software e manutenção);seu carro (para coordenação em seu novo veículo elétrico com a grade, teste automático e as atualizações de software e a manutenção de recarregamento);o sistema de irrigação (para o agendamento com base nos relatórios de meteorologia e gerenciamento de água);os animais de estimação (para determinar o local e configure fencing invisível);seu thermostat (para o controle remoto);e muito mais.

Esses dispositivos são conectados uns aos outros, para controladores smart, o roteador e a nuvem. O que isso significa para os desenvolvedores do Microsoft .NET Framework? À direita agora, os desenvolvedores .net podem produzir aplicativos para todas as partes do sistema ao qual se conectar a dispositivos pequenos. E com o .NET Framework de Micro, os desenvolvedores do .net podem desenvolver o direito de total do sistema para os pequenos dispositivos.

O micro do .NET Framework é uma implementação do .NET Framework, especificamente como destino os dispositivos de menores possíveis com as extensões para atender às necessidades de programação incorporado. Ele é executado diretamente no hardware sem um sistema operacional subjacente para minimizar sua superfície. Informações gerais estão disponíveis em microsoft.com/netmf de e site de comunidade de código-fonte aberto do projeto: netmf.com.

Vários meses atrás, iniciei uma série de artigos no blog do .NET Framework do Micro (blogs.msdn.com/b/netmfteam ) que descreve o processo de criação de um desses dispositivos pequenos — um computador de bicicleta — desde o início usando apenas o Micro .NET Framework, Visual Studio e uma quantidade mínima de aparelhos eletrônicos. Eu queria demonstrar como os desenvolvedores do .NET Framework podem criar aplicativos ricos em dispositivos pequenos. (O primeiro artigo desta série pode ser encontrado em: tinyurl.com/2dpy6rx.)  A Figura 1 mostra que o computador real. Selecionei a um computador de bicicleta porque todas as pessoas são uma especialista do domínio, quando se trata de bicicletas. O aplicativo inclui uma interface do usuário com base em gesto, oferece suporte a vários dos problemas de endereços e os sensores como gerenciar a fonte de alimentação de bateria.

image: The NETMF Bicycle Computer

Figura 1 do computador A NETMF relacionadas a Bicicletas

O blog discute a implementação de cada recurso e o código para o projeto está disponível em CodePlex de netmfbikecomputer.codeplex.com/ . No entanto, eu salvei o melhor para o final — neste artigo, vou me conectar a este dispositivo para um serviço da Web hospedado no Microsoft Windows Azure por Wi-Fi. Este é o cenário: apenas tiver concluído sua ride e trazidos de bicicletas para a garagem. O computador contém dados que ele coletadas durante sua ride: distância, velocidade, cadência, inclinação, tempo e assim por diante. Vire para o modo de exibição de dados e pressione o botão upload. Os dados para seu ride são carregados na nuvem, onde podem ser agregado com todos os seus rides e compartilhado com seus amigos.

Neste artigo, eu me concentrarei em fazer a conexão e carregar os dados em vez de discutir a forma de nuvem serviço ao qual você pode se conectar. Veja exemplos como de bikejournal.com e cyclistats.com para ver quais são as possibilidades para controlar seu progresso bicycling e competindo com seus amigos. Discutirei como é fácil para que a conexão.

Primeiro, Little um plano de fundo

O modelo de serviços da Web é excelente para dispositivos de conexão porque ele oferece suporte a uma ampla gama de interações de dispositivo e serviço talvez não seja totalmente conhecidos na época, criamos um aplicativo. No lado do dispositivo, usamos um subconjunto da estrutura de serviço da Web completo chamado perfil de dispositivos para serviços da Web (DPWS) – consulte en.wikipedia.org/wiki/Devices_Profile_for_Web_Services de para saber mais sobre ele. DPWS é descrito como Universal Plug and Play (UPNP) para dispositivos conectados à rede. No .NET Framework de Micro, DPWS oferece suporte ao WS-Addressing, WS-Discovery, WS-MetaDataExchange e WS-Eventing interfaces e foi construído sobre as tecnologias subjacentes do SOAP, XML, HTTP, MTOM e Base64 codificação.

Com o DPWS, você pode conectar dispositivos de clientes (dispositivos que consomem serviços de outras pessoas) ou servidores (dispositivos que oferecem serviços para que outras pessoas) ou ambos. Pode negociar a você fornecer e o que você pode consumir por meio de metadados, e você pode publicar e assinar as notificações de alterações em outras entidades. A Figura 2 mostra a pilha DPWS.

image: The DPWS Stack

A Figura 2 A pilha DPWS

A implementação do Micro do .NET Framework oferece suporte ao DPWS versão 1. 0, que é compatível com o Windows 7 – e DPWS versão 1. 1 — que é compatível com o Windows Communication Foundation (WCF) 4. Você pode especificar a vinculação, que você pode usar para a conexão: Por exemplo, SOAP sobre HTTP (ws2007HttpBinding) ou uma ligação personalizada que você deseja dar suporte.

Nosso aplicativo para o computador de bicicleta é realmente muito simples — será nós apenas ser carregar dados na nuvem. DPWS realmente pode fazer muito mais. Por exemplo, let’s que minha empresa utilitário instalará um medidor de serviço inteligente que limita os recursos que posso usar a qualquer momento específico. Com isso, instalar um serviço de gerenciamento de energia local me dá controle sobre como usar esses recursos limitados. Posso definir prioridades e heurística que permita que o sistema tomar decisões sobre como limitar o consumo — por exemplo, água quente para chuveiros tem uma prioridade alta.

Agora vou check-out e comprar uma nova louça. Eu colocá-lo em casa e conectá-lo. Em segundo plano, a louça localiza a rede local e “ descobre ” o serviço de gerenciamento. Ela informa que o serviço de seu consumo de energia em vários estados e as regras para como ele pode ser usado. Posteriormente, quando está executando a louça, eu pular no chá de bebê e o Aquecedor de água quente vêm. Mas assim que começar a louça, não quero que ele apenas desativá-la e possui a comida otimizar a segurança de chapas de. Para reduzir o consumo total, o serviço de gerenciamento informa a louça para simplesmente Enxágüe os pratos a cada 15 minutos para mantê-los de equipamentos de desidratação check-out e retomar de onde foi deixada no ciclo de lavar roupa quando eu tenho feito com o chá de bebê. Como você pode ver, esse cenário inteiro pode suportar um conjunto arbitrário de pontos de extremidade com a funcionalidade definida em DPWS.

Plano de fundo suficiente — Let’s Make It trabalho

Configurar o rádio Wi-Fi é muito fácil. Há duas maneiras para fazer isso — um usa o utilitário MFDeploy.exe e a outra é uma interface de programação que contam com o SDK GHI (de GHI Electronics). Comece Let’s MFDeploy.exe, que é uma ferramenta que vem com o .NET Framework do Micro e pode ser encontrada na seção ferramentas da instalação do SDK. No destino | configuração | configuração de rede de caixa de diálogo caixa (veja do Figura 3), se eu ativar o DHCP, selecione o mecanismo de segurança e digite a frase secreta e outros aspectos da configuração da minha rede doméstica.

image: The MFDeploy Network Configuration Dialog

A Figura 3 da caixa de diálogo de configuração de rede MFDeploy

DHCP cuidará de preenchimento no campo Gateway e o DNS, as configurações da rede. Essas informações estão disponíveis para o aplicativo gerenciado por meio do tipo NetworkInterface e seu filho Wireless80211. A pilha HTTP implicitamente usará essas informações ao enviar e receber bytes, mas ele pode ser necessário uma informação adicional para habilitar o uso de um proxy — algo que pode precisar de sua rede. Para ajudar a pilha HTTP a usar o proxy corretamente, é aconselhável adicionar o seguinte para um programa como uma dica ainda mais a onde conectar-se:

WebRequest.DefaultWebProxy = 
  new WebProxy("<router IP Adress>");

Se não houver nenhuma função de proxy explícitas na sua rede, geralmente pode padrão usando o endereço de gateway. Com a interface de programação GHI, você pode usar alguns derivada do código mostrado na do Figura 4.

Figura 4 do Wi-Fi configuração com a interface de programação GHI

// -- Set up the network connection -- //

WiFi.Enable(SPI.SPI_module.SPI2, (Cpu.Pin)2, (Cpu.Pin)26);

NetworkInterface[] networks = NetworkInterface.GetAllNetworkInterfaces();
Wireless80211 WiFiSettings = null;

for (int index = 0; index < networks.Length; ++index)
{
  if (networks[index] is Wireless80211)
  {
    WiFiSettings = (Wireless80211)networks[index];
    Debug.Print("Found network: " + WiFiSettings.Ssid.ToString());
  }
}

WiFiSettings.Ssid = "yourSSID";
WiFiSettings.PassPhrase = "yourPassphrase";
WiFiSettings.Encryption = Wireless80211.EncryptionType.WPA;
Wireless80211.SaveConfiguration(
  new Wireless80211[] { WiFiSettings }, false);

_networkAvailabilityBlocking = new ManualResetEvent(false);

if (!WiFi.IsLinkConnected)
{
  _networkAvailabilityBlocking.Reset();
  while (!_networkAvailabilityBlocking.WaitOne(5000, false))
 {
    if (!WiFi.IsLinkConnected)
    {
      Debug.Print("Waiting for Network");
    }
    else
    break;
  }
}
Debug.Print("Enable DHCP");
try
{
  if (!WiFiSettings.IsDhcpEnabled)
    WiFiSettings.EnableDhcp(); // This function is blocking
  else
  {
    WiFiSettings.RenewDhcpLease(); // This function is blocking
  }
}
catch
{
  Debug.Print("DHCP Failed");
}

O exemplo de 4 da figura pressupõe que você está usando segurança WPA ou WPA2. Também há suporte para o WEP. A primeira coisa a que fazer é identificar as linhas SPI controle e a porta usadas pelo rádio. Esta configuração representa as conexões de hardware, uma placa de FEZ cobra pela GHI. Tudo o que é necessário é configurar o WiFiSettings, salve a configuração e chamar EnableDHCP. Observe que algumas dessas chamadas são bloqueadas, e isso pode levar algum tempo, portanto, você precisará garantir que o usuário saiba o que está acontecendo. Além disso, não é possível nessa interface programática para enumerar as redes disponíveis para que você pode selecionar a partir deles. Eu embutidos as informações de rede no exemplo de 4 da figura.

Para obter uma implementação comercial do computador de bicicleta, eu preciso escrever uma configuração de Wi-Fi integrados da interface do usuário que expõe as informações inseridas na caixa de diálogo mostrada na do Figura 3 e um teclado na tela para inseri-la. Eu pode ter tempo de valorização isso em outro artigo de blogue antes deste artigo for publicado. Estou trabalhando em um artigo do serviço de tempo do que mostra como usar a conexão Wi-Fi para obter a data e hora quando eu iniciar o computador para que eu não tenho que manter o dispositivo em execução para manter as informações ou que o usuário (me) inseri-la na inicialização.

Como configurar a conexão de serviço

Tudo o que resta é a implementação de DPWS. Como um lembrete, vou me concentrar-se no lado do dispositivo. O serviço Windows Azure que uso fornece um modelo simples de “ Hello, World ”. Eu começar com isso e estender o contrato, adicionando os campos que eu preciso para armazenar e as operações, escrevendo as operações de carregamento e Get. Isso cria um serviço que aceite meus dados, armazene-a e devolva-me os últimos dados armazenados. Obviamente, um serviço completo exige muito mais trabalho, mas que é outro artigo. Let’s examine rapidamente o contrato criado para este serviço. O ServiceContract contém duas operações e o DataContract contém os campos (consulte do Figura 5).

Do contrato do serviço, a Figura 5

[ServiceContract]
  public interface IBikeComputerService
  {
    [OperationContract]
    BikeComputerData GetLastComputerData();

    [OperationContract]
    void UploadBikeComputerData(BikeComputerData rideData);
  }


  // Use a data contract as illustrated in the sample below 
  // to add composite types to service operations.
[DataContract]
  public class BikeComputerData
  {
    DateTime _Date;
    TimeSpan _StartTime;
    TimeSpan _TotalTime;
    TimeSpan _RidingTime;
    float    _Distance;
    float    _AverageSpeed;
    float    _AverageCadence;
    float    _AverageIncline;
    float    _AverageTemperature;
    bool     _TempIsCelcius;
            
    [DataMember]
    public DateTime Date…

    [DataMember]
    public TimeSpan StartTime…

    [DataMember]
    public TimeSpan TotalTime…

    [DataMember]
    public TimeSpan RidingTime…

    [DataMember]
    public float Distance…

    [DataMember]
    public float AverageSpeed…

    [DataMember]
    public float AverageCadence…

    [DataMember]
    public float AverageIncline…

    [DataMember]
    public float AverageTemperature…

    [DataMember]
    public bool TemperatureIsInCelcius…
  }

A implementação real do contrato é mínima para suportar o exemplo de computador de bicicleta (consulte do Figura 6).

Da implementação do contrato, a Figura 6

public class BikeComputerService : IBikeComputerService
{
  static BikeComputerData _lastData = null;

  public BikeComputerData GetLastComputerData()
  {
    if (_lastData != null)
    {
      return _lastData;
    }
    return new BikeComputerData();
  }

  public void UploadBikeComputerData(BikeComputerData rideData)
  {
    _lastData = rideData;
  }
}

O WSDL define o serviço

A partir do contrato e esquema que criei, o serviço Windows Azure auto-gera um arquivo WSDL (Web Service Definition Language).Ele contém a definição de SML (Service Modeling Language) do serviço.A especificação do W3C para o documento WSDL pode ser encontrada em w3.org/TR/wsdl de .Ela define as operações e mensagens que o serviço oferece suporte.O WSDL é armazenado como uma descrição de XML em um site da Web, onde é acessível para qualquer pessoa que se conectam ao serviço.Os nossos podem ser encontrados no netmfbikecomputerservice.cloudapp.net/BikeComputerService.svc?wsdl de .A Figura 7 mostra um pequeno instantâneo do arquivo WSDL, portanto, você pode ver sua aparência, mas lembre-se de que esse arquivo é gerado automaticamente e só é consumido por outros programas.Você não precisa escrever esse XML complexa e delicada.

image: The WSDL File
(clique na imagem para ampliar)

A Figura 7 do arquivo WSDL

Você pode ver que o WSDL contém as definições de operações para obtenção e carregamento de dados e mensagens de saída e entrada de dados.Agora que temos nossa interface simples para o serviço definidos e publicados, como posso programar para que?Isso também é bem fácil.

Gerando código com MFSvcUtil.exe

Na área de trabalho, há um utilitário chamado ferramenta de MetadataUtility ServiceModel (svcutil. exe) que pode gerar código de modelo de serviço de documentos de metadados (como o nosso WSDL) e vice-versa.O micro do .NET Framework possui um utilitário semelhante chamado MFSvcUtil.exe.Esta é uma ferramenta de linha de comando é executada melhor no diretório do projeto.Assim, podemos executá-lo apontando a especificação do WSDL publicada:

<SDK_TOOLS_PATH>\MFSvcUtil.exe http://netmfbikecomputerservice.cloudapp.
net/BikeComputerService.svc?wsdl

A ferramenta gera três arquivos (consulte do Figura 8).

image: Executing the MFSvcUtil.exe Command
(clique na imagem para ampliar)

A Figura 8 de executar o comando MFSvcUtil.exe

O arquivo BikeComputerService.cs contém a definição de dados de mensagens, as classes que define as operações de suporte do serviço (como o nosso dispositivo é um cliente) e um número de funções auxiliares para serialização e de-serializing os dados (consulte do Figura 9).

A Figura 9 do Arquivo BikeComputerService.cs

namespace BikeComputer.org
{
  [DataContract(Namespace="http://tempuri.org/")]
  public class GetLastComputerData ...
public class GetLastComputerDataDataContractSerializer : DataContractSerializer…
    
  [DataContract(Namespace="http://tempuri.org/")]
  public class GetLastComputerDataResponse ...
public class GetLastComputerDataResponseDataContractSerializer : DataContractSerializer…
    
  [DataContract(Namespace="http://tempuri.org/")]
  public class UploadBikeComputerData ...
public class UploadBikeComputerDataDataContractSerializer : DataContractSerializer…
    
  [ServiceContract(Namespace="http://tempuri.org/")]
  [PolicyAssertion(Namespace="http://schemas.xmlsoap.org/ws/2004/09/policy",
    Name="ExactlyOne",
    PolicyID="WSHttpBinding_IBikeComputerService_policy")]
  public interface IIBikeComputerService ...
}
namespace schemas.datacontract.org.BikeComputerServiceWebRole...

O arquivo BikeComputerClientProxy.cs contém as interfaces de proxy do serviço da Web:

namespace BikeComputer.org
{
  public class IBikeComputerServiceClientProxy : DpwsClient
  {
    private IRequestChannel m_requestChannel = null;
        
    public IBikeComputerServiceClientProxy(Binding binding,    
      ProtocolVersion version) : base(binding, version)...
public virtual GetLastComputerDataResponse 
      GetLastComputerData(GetLastComputerData req) ...
public virtual UploadBikeComputerDataResponse  
      UploadBikeComputerData(UploadBikeComputerData req) ...
}
}

O terceiro arquivo MFSvcUtil.exe cria é o arquivo BikeComputerServiceHostedService.cs;contém a lógica da interface que é executado no lado do serviço da interface. No nosso caso, o WSDL foi gerado a partir de contratos de serviço e os dados que foram criados para que este arquivo é um “ jogar fora ” para nós. Ela é gerada para abordar situações onde você obtém um WSDL publicado e que deseja replicar um serviço ou em que você deseja executar um serviço em outro dispositivo. Lembre-se de que os dispositivos podem ser clientes, servidores ou ambos. A opção para que dispositivos oferecem serviços para outros dispositivos permite que alguns aplicativos interessantes. Esse é o que BikeComputerServiceHostedService contém:

namespace BikeComputer.org
{
  public class IBikeComputerServiceClientProxy : DpwsHostedService
  {
    private IIBikeComputerService m_service;
        
    public IBikeComputerService(IIBikeComputerService service, 
      ProtocolVersion version) : base(version) ...
public IBikeComputerService(IIBikeComputerService service) :
      this(service, new ProtocolVersion10())...
public virtual WsMessage GetLastComputerData(WsMessage request) ...
public virtual WSMessage UploadBikeComputerData(WsMessage request) ...
}
}

Carregando os dados

Como você viu, todo o código do aplicativo de dispositivo até agora foi gerado automaticamente a partir de WSDL. O que o código, na verdade, há que escrever no cliente para se conectar ao serviço e publicar seus dados e fazer backup somente de leitura para certificar-se de que ele é recebido? Apenas algumas linhas de código são necessárias. Eis o que eu fiz no projeto de computador de bicicleta.

A classe RideDataModel, adicionei o seguinte para o construtor para configurar a conexão com a DPWS:

public RideDataModel()
{
  _currentRideData = new CurrentRideData();
  _summaryRideData = new SummaryRideData();
  _today = DateTime.Now; //change this to the time service later.
//--Setup the Web Service Connection
  WS2007HttpBinding binding = new WS2007HttpBinding(
    new HttpTransportBindingConfig(new Uri
      ("http://netmfbikecomputerservice.cloudapp.
net/BikeComputerService.svc")
     ));

  m_proxy = new
    IBikeComputerServiceClientProxy(
    binding, new ProtocolVersion11());    

  _upload = new 
    UploadBikeComputerData();

  _upload.rideData = new
    schemas.datacontract.org.
BikeComputerServiceWebRole.
BikeComputerData();
  }

Em seguida, criei um método na classe para carregar os dados para o serviço da Web. Essa rotina coloca dados de resumo da ride nos campos do esquema do serviço da Web (referenciado no WSDL e refletidos no BikeComputerService.cs), que é projetada para corresponder ao que os dados. Em seguida, eu chamar o método de UploadBikeComputerData do proxy com os carregamento de dados e recuperar a data da última ride no serviço da Web de validar que meus dados recebidos (consulte do Figura 10).

A Figura 10 de carregamento de dados para o serviço da Web

public bool postDataToWS()
{
  //-- Load the ride summary data into the upload fields --//

  _upload.rideData.AverageCadence = _summaryRideData.averageCadence;
  _upload.rideData.AverageIncline = _summaryRideData.averageIncline;
  _upload.rideData.AverageSpeed = _summaryRideData.averageSpeed;
  _upload.rideData.AverageTemperature = 
    _summaryRideData.averageTemperature;
  _upload.rideData.Date = _summaryRideData.rideDate;
  _upload.rideData.Distance = _summaryRideData.distance;
  _upload.rideData.RidingTime = _summaryRideData.ridingTime;
  _upload.rideData.StartTime = _summaryRideData.startTime;

  //-- Upload the data --//

  m_proxy.UploadBikeComputerData(_upload);

  //-- Validate the upload by retrieving the data and comparing --//

  GetLastComputerData req = new GetLastComputerData();

  GetLastComputerDataResponse back = m_proxy.GetLastComputerData(req);

  if (back.GetLastComputerDataResult.Date == _upload.rideData.Date)
  {
    return false;
  }

  return true;
}

O exemplo pressupõe que você execute apenas uma ride por dia, portanto, se você tirar mais rides, você precisará alterar essa lógica de comparação. Espero que usar o recurso “ Pausar ” no computador de bicicleta e tratar todos os rides em um dia como um conjunto de dados. Já tenho a capacidade de armazenar os dados em um arquivo em uma placa SD em que a bicicleta, como descrito em um artigo anterior no blog. Adicionarei a capacidade de controlar quais conjuntos de dados ride foram lançados para o serviço da Web e lançar os que estão faltando. Isso permite que eu estar fora do intervalo da minha conexão sem fio por algum tempo e ainda ser capaz de atualizar o serviço da Web mais tarde. Outro aperfeiçoamento é permitir a conexão com um Tablet PC como um intermediário quando minha rede doméstica não está disponível.

Portanto, 17 de linhas de código que escrevi no aplicativo (a maioria do mapeamento de dados de resumo para os campos de esquema do serviço) e estou Carregando dados em um serviço e fazer as verificações de validade. Não é ruim.

Agora que encerrar nosso ride conectado

No final de um ride, como eu entram em minha garagem posso navegar para a tela de salvar seus dados com um gesto simples e postar meus dados de backup da nuvem.

Ainda há algum trabalho para fazer esse final para tornar os dados mais úteis, mas essa é outra história.

Dispositivos incorporados foram Ilhas de tecnologia especializada onde facilidade de programação e flexibilidade foram negociada logoff para os requisitos de espaço/baixo custo e de alto desempenho pequenos. Com mais freqüência, estamos vendo pequenos dispositivos conectados a outros dispositivos e a redes para criar soluções interessantes. Ao mesmo tempo, o preço de processadores e a memória continua ir até o ponto onde temos não desista a produtividade de ferramentas Área de trabalho e de idiomas para poder tornar os dispositivos ricos e preços competitivos. O resultado é que os programadores do .net estão mais com as habilidades e as oportunidades de trabalhar em dispositivos pequenos.

O modelo de serviços da Web fornece uma opção de alta segurança para conectar esses dispositivos pequenos, porque a descoberta de serviços remotos, inscrevendo-se em eventos remotos e trocar informações sobre os serviços por meio de metadados permite a conexão flexível de um número de dispositivos. O custo é que a conexão — usando SOAP e XML – é detalhada, portanto, não será mais apropriado em todos os casos.

O projeto de computador de bicicleta demonstra que habilidades de programação do .NET Framework permitem que você escreva atraentes interfaces do usuário para dispositivos pequenos, escrever os drivers para uma variedade de sensores e conectar-se aos dispositivos com a nuvem. À medida que mostrei a você, o trabalho envolve a definição de serviço da Web, e a maioria do código que é executado no dispositivo é gerado automaticamente por MFSvcUtil.exe. Apenas algumas linhas de código adicional foram necessários para carregar os dados. Outros aplicativos podem exigir investigação do serviço da Web (WS_Discovery), inscrever-se em eventos de outros pontos de extremidade (WS_Eventing) ou lidando com dispositivos e serviços dos recursos variáveis (WS_MetaDataExchange). Todos esses recursos podem ser adicionados ao modelo de troca de dados básica conforme necessário.

Como um amigo depois comentado, os programadores do .NET Framework agora podem adicionar “ Embedded programador ” para seus cartões de visita. Adoraríamos saber sobre os dispositivos que você cria com o .net sobre as discussões de de netmf.com, onde eu também pode responder perguntas que têm neste artigo ou no site do blogue.

Cavalo feliz!

Colin Miller iniciado o seu evento com a computação como programador científico, criação de sistemas de controle experimental 8 e 16 bits. Ele desviada de dispositivos pequenos, trabalhando por 25 anos (incluindo 15 na Microsoft) no software de PC, incluindo bancos de dados, área de editoração eletrônica, produtos de cliente, o Word, Internet Explorer, do Passport (LiveID) e serviços on-line. Como o gerente da unidade de produto do .net Micro Framework, ele finalmente (e Felizmente) foi capaz de mesclar essas partes diferentes da sua carreira.

Graças aos seguintes especialistas técnicos para revisão deste artigo: Jane Lawrence e do Patrick Butler Monterde