Este artigo foi traduzido por máquina.

Windows 8.1

Criando um sensor HID com base em Netduino para o WinRT

Donn Morse

Baixe o código de exemplo

O protocolo de dispositivo de Interface humana (HID) foi originalmente destinado a simplificar o uso de dispositivos como mouses, teclados e joysticks. No entanto, por causa de suas características originais — incluindo a sua natureza auto-descritiva — dispositivo fabricantes utilizam o protocolo para oferecer suporte a dispositivos médicos, dispositivos de saúde e fitness e sensores personalizados. Se você é novo para a API escondeu, consulte o site de informações USB HID (bit.ly/1mbtyTz) para mais informações. Outro grande recurso é o livro de Jan Axelson, "Complete USB: Guia do Devloper, quarta edição"(Lakeview Research LLC, 2009).

Antes do Windows 8.1, se você estivesse escrevendo um aplicativo para um dispositivo HID escreveu um app nativo do Win32. Mas se você fosse uma Web ou um desenvolvedor .NET, a rampa íngreme. Para resolver isso, a Microsoft introduziu o tempo de execução do Windows HID (WinRT) API com Windows 8.1 (bit.ly/1aot1by). Essa nova API permite que você escreva apps da loja do Windows para o seu dispositivo usando Visual Basic, c# ou C++.

Além disso, Microsoft recentemente adicionou o suporte para vários transportes de novos, então você não está limitado a um cabo USB. Hoje, você pode criar um dispositivo HID que transmite e recebe os pacotes sobre I2C, LE Bluetooth , Bluetoothe USB. (Para obter mais informações, consulte "Escondeu transportes" em bit.ly/1asvwg6.)

Neste artigo, mostrarei como você pode construir um sensor de temperatura simples que é compatível com o protocolo HID. Em seguida, descreverei uma amostra Windows Store app que pode exibir dados de temperatura do dispositivo.

Construindo o Sensor de temperatura

O dispositivo de amostra baseia-se a placa de desenvolvimento Netduino (netduino.com). Esta placa de código aberto é usada por hobbyists, acadêmicos e engenheiros industriais para construir dispositivos de protótipo de trabalho. E, porque o Netduino é pino-compatível com o Arduino, você pode anexar seus escudos de Arduino para rapidamente adicionar funcionalidade. (Um escudo é uma placa com funcionalidades específicas, tais como a comunicação sem fio, controle motor, Ethernet, RS232, LCD display e assim por diante). Meu dispositivo de amostra usa um escudo de RS232 para baixar o firmware. Ele usa o conector USB integrado para transmitir e receber dados.

O Netduino suporta o .NET Micro Framework e seu firmware é criado com uma cópia gratuita do Visual C# Express.

Para obter dados de temperatura, o dispositivo de exemplo usa o sensor LM35 de instrumentos de Texas. O sensor toma 5 volts de entrada da Netduino e converte-lo em uma tensão de saída proporcional para o atual Celsius temperatura.

Aqui estão as peças que você precisa para construir seu próprio sensor HID:

  • Netduino 1 ou Netduino Plus 1 (Amazon, amzn.to/1dvTeLh): Uma placa de desenvolvimento com microcontrolador programável que oferece suporte a .NET Micro Framework.
  • Escudo RS232 (CuteDigi, bit.ly/1j7uaMR): O módulo RS232 para download e depuração do firmware. (Este escudo é necessário para a versão beta do firmware sendo usado).
  • Sensor LM35 (DigiKey, bit.ly/KjbQkN): O sensor de temperatura que converte a tensão de entrada de tensão de saída com base na temperatura atual.
  • Cabo conversor RS232 para USB (paralaxe, bit.ly/1iVmP0a): O cabo para fazer o download do firmware do sensor de temperatura através do escudo RS232. (Observe que um chipset da FTDI é necessário para compatibilidade com o escudo).
  • Fonte de alimentação 9V 650mA (Amazon, amzn.to/1d6R8LH): Fonte de alimentação para a placa de Netduino.
  • Cabo Micro-USB para (Amazon, amzn.to/Kjc8Ii): O cabo para o envio de pacotes de HID do Netduino para seu tablet Windows 8.1 ou laptop.

Figura 1 mostra a instalação de sensor de temperatura HID completa.

The Complete HID Temperature Sensor Setup
Figura 1 o completo escondeu a instalação do Sensor de temperatura

O escudo de RS232 é anexado ao topo da Netduino. A tábua de pão contém o sensor LM35, que é anexado ao 5V, terra e pino 0. (Pino 0 é um dos seis analógico-digital [ADC] pinos na placa). Então, vamos começar.

Seu Netduino 1 (ou Netduino Plus 1) vem com o firmware não suporta o protocolo HID. Você precisará configurar a placa de desenvolvimento, instalando a versão 4.1.1 do firmware beta, que inclui suporte para HID. Você encontrará uma pasta zip que contém o firmware beta no bit.ly/1a7f6MB. (Você precisará criar uma conta, registrando com laboratórios secretos a fim de baixar o arquivo).

A página de download no site da Web inclui instruções para a atualização do firmware. No entanto, estas instruções são bastante complexas, especialmente se você é novo para o Netduino. O vídeo no bit.ly/1d73P9x é uma descrição útil e concisa do processo de atualização de firmware.

Depois que você atualizou o firmware em sua placa, você está pronto para começar a construir o circuito do sensor de temperatura. O primeiro passo requer que você anexar o escudo de RS232 para sua placa. (Como já mencionei, o Netduino é pino-compatível com o Arduino, então se você te trabalhado com o Arduino e têm um escudo RS232 à mão, você pode usá-lo.) Encaixe o escudo de RS232 para o Netduino como mostrado no Figura 2.

Attaching the RS232 Shield to the Netduino
Figura 2 anexar o escudo de RS232 para o Netduino

Depois de prenderem o escudo RS232, o próximo passo é para conectar o sensor de temperatura para a fonte de alimentação de 5V, a terra e o pino 0 da Netduino. Figura 3, de folha de TI para o sensor, mostra o conjunto de pinos.

The Sensor Pin-Outs
Figura 3 pinos do Sensor

Instalar o Firmware do Sensor

Existem duas camadas, ou instâncias, do firmware no Netduino. O primeiro é o firmware do fabricante, que inclui o .NET Micro Framework; o segundo é o firmware do seu dispositivo. Firmware do fabricante processa solicitações de firmware do dispositivo. Firmware do fabricante é carregado uma vez no quadro de desenvolvimento e executa cada vez que você ligar o dispositivo. Em contraste, você normalmente atualizar seu firmware de dispositivo várias vezes durante o processo de desenvolvimento e prototipagem.

Para instalar qualquer firmware do dispositivo, é necessário primeiro instalar uma instância do Visual C# Express 2010 na sua máquina de desenvolvimento. Você encontrará um link para o download em bit.ly/1eRBed1.

Na maioria dos projetos de Netduino, você pode baixar e depurar seu firmware utilizando a conexão USB nativa. No entanto, a versão beta do firmware do fabricante requer uma conexão RS232 (que é por isso que o escudo de RS232 é necessário).

Uma vez Visual C# Express é instalado, conecte o cabo RS232 para USB e abra o Gerenciador de dispositivos do Windows para determinar quais janelas de porta COM atribuído a esse cabo.

Quando me acompanha o conversor RS232 para USB paralaxe para minha máquina de desenvolvimento, Windows é mapeado para COM6, como Figura 4 mostra.

The COM Port Assigned to the RS232-to-USB Cable
Figura 4 a porta COM atribuída ao cabo RS232 para USB

Agora que sei a porta COM associado com o conversor, eu posso ligar meu Netduino Plus 1, conecte o cabo RS232 para USB e iniciar uma instância do Visual C# Express para completar o download.

A primeira coisa a fazer depois de começar Visual C# Express é identificar o correto transporte e porta COM. Você fazer isso clicando no nome do projeto no painel Solution Explorer e escolha o menu Propriedades.

Quando aparece a caixa de diálogo Propriedades, escolha a guia .NET Micro Framework e faça as seleções necessárias, conforme mostrado no Figura 5.

Configuring the .NET Micro Framework Properties
Figura 5-configurando as .NET Micro Framework Propriedades

Depois de especificar o transporte e o dispositivo, você pode implantar o firmware. Novamente, o nome do projeto no painel Solution Explorer e, desta vez com o botão direito, escolha implantar.

Quando a implantação for concluída, Visual C# Express apresentará um relatório ao sucesso no painel saída.

Agora você está pronto para anexar seu dispositivo um tablet Windows 8.1 ou laptop e testá-lo com o aplicativo de exemplo de Sensor de temperatura do costume.

Primeiro, solte o cabo RS232, desligue o Netduino e em seguida, reiniciá-lo com fonte de alimentação auxiliar. Dê o dispositivo vários segundos para ligar e em seguida, conecte o cabo USB para o Netduino. Depois de fazer isso, você deve ver seu dispositivo adicionado à coleção de HID dispositivos no Gerenciador de dispositivos. (O VID e PID no Figura 6 correspondem a VID e PID do dispositivo de amostra; Estas são as identificações de produto e fornecedor).

The Vendor and Product IDs of the Sample Device
Figura 6 o fornecedor e IDs de produto do dispositivo de amostra

Uma vez que o dispositivo é instalado em sua máquina Windows 8.1, você vai querer instalar e construir o aplicativo de exemplo. Quando o aplicativo for iniciado, você pode selecionar o sensor e começar a monitorar a temperatura ambiente em seu escritório.

O Firmware do dispositivo

Agora vamos dar uma olhada detalhada o firmware do dispositivo para o sensor de temperatura. No início, eu gostaria de agradecer o pessoal nos laboratórios secretos (os fabricantes da Netduino) para o trabalho que fizeram para apoiar HID sobre USB na plataforma Netduino. O ponto de partida para este firmware foi uma amostra no fórum, o UsbHidEchoNetduinoApp, disponível em bit.ly/1eUYxAM.

Apoiar o transporte USB como observei anteriormente, a Microsoft oferece suporte a dispositivos HID atropelar LE Bluetooth , USB, Bluetoothe I2C. No entanto, o dispositivo de exemplo descrito neste artigo usa o transporte USB. O que isso realmente significa é que os drivers USB estarei movendo os pacotes em ambas as direções: pacotes originários com o dispositivo são passados para o driver HID (que os repassa para a API se há interessados apps); pacotes originários com o driver HID são passados para o dispositivo.

Windows usa emitidos pelo dispositivo aquando da ligação de dados específicos para identificar quais drivers USB ele deve carregar.

Definição das Classes de Firmware o firmware para o dispositivo sensor de temperatura é construído em torno de duas classes: Programa e Sensor. O programa classe oferece suporte a uma único Main rotina é invocado na inicialização. A classe de Sensor define as configurações de USB e HID para o sensor de temperatura. Além disso, oferece suporte os métodos que enviar relatórios de entrada e ler relatórios de saída.

A classe de Sensor contém todo o código necessário para configurar o transporte USB. Isso inclui o código que:

  • Configura um leitura de ponto de extremidade
  • Configura um ponto de extremidade de gravação
  • Especifica o vendor ID (VID)
  • Especifica o produto identificação (PID)
  • Especifica os nomes amigáveis (nome do fabricante, nome do produto e assim por diante)
  • Especifica outras configurações USB necessárias para um dispositivo HID

Maior parte do código de configuração USB encontra-se em configurar­HID método no módulo Sensors.cs. Esse método, por sua vez, cria e inicializa um objeto de configuração (bit.ly/1i1IcQ3) que contém as configurações do dispositivo de USB (pontos de extremidade, VID, PID e assim por diante).

O ponto de extremidade de leitura permite que o dispositivo receber pacotes da API e o driver HID. O ponto de extremidade de gravação permite ao condutor enviar pacotes através da pilha de driver para o API.

O Windows usa o ID do fornecedor, ID do produto e outras configurações de USB (que foram especificadas no método ConfigureHID) para determinar se o dispositivo é um dispositivo USB válido e, em seguida, carregar os drivers apropriados.

A conexão do dispositivo de abertura o Sensor classe inclui um método aberto é chamado de dentro da rotina principal da classe do programa. Como você pode ver na Figura 7, o método aberto:

  • Recupera os controladores USB disponíveis
  • Chama o método ConfigureHID para estabelecer as configurações do dispositivo de USB e HID
  • Invoca o método Start no primeiro controlador disponível
  • Cria um fluxo USB objeto com ler e escrever os pontos de extremidade

Figura 7 o método aberto

public bool Open()
{
  bool succeed = true;
  started = false;
  UsbController[] usbControllers = UsbController.GetControllers();
  if (usbControllers.Length < 1)
  {
    succeed = false;
  }
  if (succeed)
  {
    usbController = usbControllers[0];
    try
    {
      succeed = ConfigureHID();
      if (succeed)
      {
        succeed = usbController.Start();
      }
      if (succeed)
      {
        stream = usbController.CreateUsbStream(WRITE_ENDPOINT,
           READ_ENDPOINT);
      }
    }
    catch (Exception)
    {
      succeed = false;
    }
  }
  started = true;
  return succeed;
}

A classe de Sensor também inclui um método Close, que é chamado quando o dispositivo for retirado o anfitrião laptop ou tablet.

Oferece suporte ao protocolo HID

O protocolo HID baseia-se em relatórios: recurso relatórios, relatórios de entrada e saída de relatórios. Relatórios de recurso podem ser enviados pelo host (ou seja, um laptop conectado ou comprimido) ou o dispositivo. Relatórios de entrada são enviados pelo dispositivo para o host. Relatórios de saída são enviados pelo host para o dispositivo.

No caso de nosso sensor de temperatura da amostra, o relatório de entrada é um pacote simples de dois bytes. O primeiro byte Especifica a temperatura atual em graus Fahrenheit; o segundo byte indica o intervalo de relatório atual em milissegundos­onds. (O firmware do sensor emite um relatório de entrada na freqüência especificada pelo intervalo do relatório).

O relatório de saída para o dispositivo de exemplo é ainda mais simples — é um único byte que especifica o intervalo do relatório. (Este é um número inteiro valor que represen­sents o intervalo em milissegundos.)

Criando o relatório descritor de como mencionado anteriormente, uma das características de um dispositivo HID é sua auto -­relatando a natureza: Após se conectar a um host, o dispositivo fornece uma descrição de sua finalidade, recursos e formato de pacote no que é chamado um descritor de relatório. Este descritor indica onde o aparelho se encaixa no universo HID (que é um mouse, um teclado, um dispositivo definidas pelo fornecedor?). O descritor também especifica o formato dos relatórios de característica individual, relatórios de entrada e saída de relatórios.

O descritor de relatório para o sensor de temperatura é encontrado em Sensors.cs, conforme mostrado no Figura 8.

Figura 8 o descritor de relatório para o Sensor de temperatura

 

hidGenericReportDescriptorPayload = new byte[]
  {
    0x06,0x55,0xFF,     //HID_USAGE_PAGE_VENDOR_DEFINED
    0x09,0xA5,          //HID_USAGE (vendor_defined)
    0xA1,0x01,          //HID_COLLECTION(Application),
    // Input report (device-transmits)
    0x09,0xA7,          //HID_USAGE (vendor_defined)
    0x15,0x00,          //HID_LOGICAL_MIN_8(0), // Minimum temp is 0 degrees F
    0x25,0x96,          //HID_LOGICAL_MAX_8(150), // Max supported temp is
                                                  // 150 degrees F
    0x75,0x08,          //HID_REPORT_SIZE(8),
    0x95,0x01,          //HID_REPORT_COUNT(1),
    0x81,0x02,          //HID_INPUT(Data_Var_Abs),
    0x09,0xA8,          //HID_USAGE (vendor_defined)
    0x15,0x4B,          //HID_LOGICAL_MIN_8(75),   // minimum 75 ms
    0x25,0xFF,          //HID_LOGICAL_MAX_8(255),  // maximum 255 ms
    0x75,0x08,          //HID_REPORT_SIZE(8),
    0x95,0x01,          //HID_REPORT_COUNT(1),
    0x81,0x02,          //HID_INPUT(Data_Var_Abs),
    // Output report (device-receives)
    0x09,0xA9,          //HID_USAGE (vendor_defined)
    0x15,0x4B,          //HID_LOGICAL_MIN_8(75),   // minimum 75 ms
    0x25,0xFF,          //HID_LOGICAL_MAX_8(255),  // maximum 255 ms
    0x75,0x08,          //HID_REPORT_SIZE(8),
    0x95,0x01,          //HID_REPORT_COUNT(1),
    0x91,0x02,          //HID_OUTPUT(Data_Var_Abs),
    0xC0                //HID_END_COLLECTION
   };

As duas primeiras linhas do descritor de informar o host que este dispositivo específico é definido pelo fornecedor:

0x06,0x55,0xFF,     //HID_USAGE_PAGE_VENDOR_DEFINED
0x09,0xA5,          //HID_USAGE (vendor_defined)

Linhas 4 a 15 indicam o formato do relatório de entrada de dois bytes. Linhas 4 a 9 descrevem o primeiro byte do relatório da entrada, que especifica a leitura da temperatura:

0x09,0xA7,          //HID_USAGE (vendor_defined)
0x15,0x00,          //HID_LOGICAL_MIN_8(0), // Minimum temp is 0 degrees F
0x25,0x96,          //HID_LOGICAL_MAX_8(150), // Max supported temp is  
                                              // 150 degrees F
0x75,0x08,          //HID_REPORT_SIZE(8),
0x95,0x01,          //HID_REPORT_COUNT(1),
0x81,0x02,          //HID_INPUT(Data_Var_Abs),

No dia 10, através de 15 linhas descrever o segundo byte do relatório da entrada, que especifica o intervalo de relatório (em milissegundos):

0x09,0xA8,          //HID_USAGE (vendor_defined)
0x15,0x4B,          //HID_LOGICAL_MIN_8(75),   // minimum 75 ms
0x25,0xFF,          //HID_LOGICAL_MAX_8(255),  // maximum 255 ms
0x75,0x08,          //HID_REPORT_SIZE(8),
0x95,0x01,          //HID_REPORT_COUNT(1),
0x81,0x02,          //HID_INPUT(Data_Var_Abs),

O descritor de relatório para o dispositivo de exemplo é incluído como parte do objeto UsbController.Configuration (bit.ly/1cvcq5G) que é criado dentro do método de ConfigureHID em Sensor.cs.

Apoiar o relatório de entrada HID o relatório de entrada é definido como uma estrutura no módulo Sensor.cs:

struct InputReport
{
  public byte Temperature; // Temperature in degrees Fahrenheit
  public byte Interval;    // Report interval (or frequency) in seconds
}

Os problemas de firmware entrada relatórios usando o objeto UsbStream (bit.ly/1kElfUZ) é criado no método Open. Estes relatórios de entrada são emitidos pelo método SendInputReport quando o firmware invoca o fluxo.Método de escrever:

protected void SendInputReport(InputReport report)
{
  byte[] inputReport = new byte[2];
  inputReport[0] = (byte)report.Temperature;
  inputReport[1] = (byte)report.Interval;
  stream.Write(inputReport, 0, 2);
}

Emissão de dados de temperatura com entrada relatórios o Update método na classe de Sensor emite um relatório de entrada para o host conectado:

public int Update(int iTemperature, int iInterval)
{
  InputReport inputReport = new InputReport();
  byte Interval = 0;
  inputReport.Temperature = (byte)iTemperature;
  inputReport.Interval = (byte)iInterval;
  SendInputReport(inputReport);
  Interval = GetOutputReport();
  return (int)Interval;
}

O método de atualização é chamado de dentro de um infinito ao loop, mostrado na Figura 9, que executa em Main rotina do firmware (encontrada em Program.cs).

Figura 9 o Loop While que invoca o método Update

while (true)
{
  // Retrieve the current temperature reading
  milliVolts = (double)voltsPin.Read();  // Read returns a value in the
                                         // specified range
  tempC = milliVolts / 10.0;             // Sensor returns 10mV per  
                                         // degree Centigrade
  tempF = 1.8 * tempC + 32;              // Convert to degrees Fahrenheit
  simpleTemp = (int)tempF;
  // Because there are voltage fluctuations when the external
  // power supply is connected to the Netduino, use a running
  // average to "smooth" the values
  if (firstReading)
  {
    firstReading = false;
    currentTemp = simpleTemp;
    for (i = 0; i < 12; i++)
      tempArray[i] = simpleTemp;
    }
  else
  {
    tempArray = Shift(simpleTemp, tempArray);  // Shift the array elements and
                                               // insert the new temp
    currentTemp = Average(tempArray);          // Compute a running average of
                                               // the last 12 readings
  }
  RequestedInterval = sensor.Update(currentTemp, CurrentInterval);
  // Check for a possible new interval requested via an
  // output report
  if (RequestedInterval != 0)
  {
    CurrentInterval = RequestedInterval;
  }
  led.Write(true);
  Thread.Sleep(CurrentInterval);
  led.Write(false);
  }
}

Apoiar o relatório de saída HID o relatório de saída é definido como uma estrutura no módulo Sensor.cs:

struct OutputReport
{
  public byte Interval; // Report interval (or frequency) in seconds
}

O firmware recebe relatórios de saída através do objeto de UsbStream a mesma que é criada no método Open. Estes relatórios de saída são recebidos dentro do método GetOutputReport:

protected byte GetOutputReport()
{
  byte[] outputReport = new byte[1];
  int bytesRead = 0;
  if (stream.CanRead)
  {
  bytesRead = stream.Read(outputReport, 0, 1);
  }
  if (bytesRead > 0)
  return outputReport[0];
  else
  return 0;
}

Ajuste o intervalo de relatório com relatórios de saída o firmware suporta um intervalo de relatório especificado em milissegundos. O intervalo mínimo suportado é 75 ms; o intervalo máximo é 255 ms. Um aplicativo solicita um novo intervalo, enviando um relatório de saída para o dispositivo. O dispositivo, por sua vez, informa o intervalo atual em cada entrado relatório que envia para qualquer aplicativo conectado.

O firmware aplica-se o intervalo atual, invocando o método Thread. Sleep (bit.ly/LaSYVF) para o número de segundos especificado pelo intervalo atual:

led.Write(true);
Thread.Sleep(CurrentInterval);
led.Write(false);

Por pausando o whileloop durante este período, aplicativos registrados recebem relatórios de entrada no intervalo especificado.

O App HID-Sensor de temperatura

O aplicativo de exemplo demonstra como você pode exibir dados de temperatura de um sensor de temperatura HID anexado usando o WinRT HID novo API para Windows 8.1.  Essa nova API permite que seu aplicativo recuperar dados de dispositivos HID e controlá-los também.

A amostra foi desenvolvida para funcionar com um dispositivo HID anexado que detecta temperaturas de 0 a 150 graus Fahrenheit. O aplicativo monitora e exibe leitura atual do sensor de temperatura.

O aplicativo suporta três "cenários", cada um dos quais mapas para características específicas na interface do usuário do aplicativo. Além disso, cada cenário é mapeado para um arquivo de origem XAML e c# correspondente. A seguinte lista cada cenário, seus módulos correspondentes e sua função:

Dispositivo se conectar (Scenario1_ConnectToSensor.xaml; Scenario1_ConnectToSensor.XAML.cs)

  • Suporta conectando um dispositivo HID para um PC com Windows 8.1.
  • Enumera os sensores de temperatura ligado para que o usuário pode selecionar um.
  • Estabelece um inspetor dispositivo que monitora o status do dispositivo. (O Inspetor dispositivo dispara um evento quando o usuário se desconecta ou reconecta o dispositivo HID selecionado).

Obter dados de temperatura (Scenario2_GetTemperatureData.xaml; Scenario2_GetTemperatureData.XAML.cs)

  • Monitora o sensor de temperatura seleccionada.
  • Retrata um medidor de temperatura e torna a leitura atual usando um controle deslizante.

Definir intervalo de relatório (Scenario3_SetReportInterval.xaml; Scenario3_SetReportInterval.XAML.cs)

  • Permite ao usuário controlar a freqüência na qual o sensor de temperatura informa seu status. (O intervalo padrão é 250 ms, mas os usuários podem escolher intervalos de 75 ms 250 ms).

Conexões de dispositivo de apoio

O dispositivo de conexão cenário permite que vários aspectos de conectar um dispositivo HID para um PC com Windows 8.1: enumerando os dispositivos conectados, estabelecendo um inspetor dispositivo, manipulando a desconexão do dispositivo e manipulação reconexão do dispositivo.

Estabelecer uma conexão de dispositivo o código que manipula a conexão do dispositivo encontra-se em três módulos: Scenario1_ConnectToSensor.XAML.cs, EventHandlerForDevices.cs e DeviceList.cs. (O primeiro módulo contém o código principal para esse cenário; os outros dois contêm funcionalidade suporte.)

A primeira fase da conexão ocorre antes que a interface do usuário é visível. Nesta fase, o aplicativo cria um objeto de DeviceWatcher que notifica o aplicativo quando os dispositivos são adicionados, removidos ou alterados. A segunda fase ocorre depois que a interface do usuário é exibida e o usuário é capaz de escolher os dispositivos HID conectados um dispositivo específico. O aplicativo exibe um dispositivo­string InstanceId para cada dispositivo conectado; a seqüência de caracteres inclui o VID e PID para o dispositivo especificado. No caso do sensor de temperatura da amostra, a seqüência de DeviceInstanceId tem a forma:

HID\VID_16C0&PID_0012\6&523698d&0&0000

Figura 10 mostra o app que aparece depois de enumeração foi concluída e o usuário tem conectado ao dispositivo.

The Windows 8.1 App Connected to a HID Device
Figura 10 o App Windows 8.1 conectado a um dispositivo HID

A primeira fase de conexão do dispositivo aqui são os métodos chamados durante a primeira fase do dispositivo de conexão (antes que a interface do usuário é exibido), juntamente com as tarefas realizadas por cada método:

DeviceConnect (Scenario1_DeviceConnect.xaml.cs) chama o método CustomTemperatureSensor.InitializeComponent, que inicializa os componentes UI do aplicativo como os blocos de texto e botões.

InitializeDeviceWatchers(Scenario1_DeviceConnect.xaml.cs) invoca o método HidDevice.GetDeviceSelector para recuperar uma cadeia de seletor do dispositivo. (O seletor é necessária para criar um inspetor dispositivo.) Uma vez obtido o seletor, o app chama DeviceInformation.CreateWatcher para criar o objeto DeviceWatcher e, em seguida, EventHandler­ForDevice.Current.Add­DeviceWatcher. (Este último método permite que o aplicativo monitorar as alterações no status do dispositivo.)

AddDeviceWatcher (EventHandlerForDevices.cs) cria os manipuladores de eventos para três eventos de dispositivo: Enumeração concluída, dispositivo adicionado e removido.

SelectDeviceInList(Scenario1_DeviceConnect.xaml.cs) verifica se o usuário tiver selecionado um dispositivo e, em caso afirmativo, ele salva o índice para esse dispositivo.

Em termos de API o escondeu, o código primário de interesse encontra-se no método InitializeDeviceWatchers, mostrado na Figura 11. Este código chama o método HidDevice.GetDeviceSelector (bit.ly/1eGQI1k) e passa a UsagePage, UsageId, VID e PID para o sensor de temperatura.

Figura 11 o método de InitializeDeviceWatchers

private void InitializeDeviceWatchers()
{
  // Custom sensor
  var CustomSensorSelector =
    HidDevice.GetDeviceSelector(CustomSensor.Device.UsagePage,
    CustomSensor.Device.UsageId, CustomSensor.Device.Vid,
    CustomSensor.Device.Pid);
  // Create a device watcher to look for instances of the custom sensor
  var CustomSensorWatcher =
    DeviceInformation.CreateWatcher(CustomSensorSelector);
  // Allow EventHandlerForDevice to handle device watcher events that
  // relate or affect the device (device removal, addition, app
  // suspension/resume)
  AddDeviceWatcher(CustomSensorWatcher, CustomSensorSelector);
}

Os valores UsagePage e UsageId são definidos no constants.cs do arquivo:

public class Device
{
  public const UInt16 Vid = 0x16C0;
  public const UInt16 Pid = 0x0012;
  public const UInt16 UsagePage = 0xFF55;
  public const UInt16 UsageId = 0xA5;
}

Esses membros de classe correspondem aos valores especificados no descritor de relatório HID que está definido no firmware do dispositivo:

hidGenericReportDescriptorPayload = new byte[]
{
  0x06,0x55,0xFF,     //HID_USAGE_PAGE_VENDOR_DEFINED
  0x09,0xA5,          //HID_USAGE (vendor_defined)

O método GetDeviceSelector retorna uma seqüência de caracteres da sintaxe de consulta avançada (AQS) na variável CustomSensorSelector. Em seguida, o app usa essa seqüência de caracteres quando ele cria um inspetor dispositivo e quando ele enumera os objetos DeviceInformation.

A segunda fase de conexão do dispositivo a segunda etapa da conexão do dispositivo permite que o usuário faça uma seleção na lista de dispositivos conectados. Nesta fase estabelece o dispositivo selecionado. Aqui estão os métodos (todas em EventHandlerForDevices.cs) chamados e o que cada um faz.

OpenDeviceAsync abre a conexão com o dispositivo.

RegisterForAppEventsregisters para eventos de suspensão e currículo do app.

RegisterForDeviceAccessStatusChange ouve alterações nas permissões de acesso ao dispositivo.

RegisterForDeviceWatcherEvents registra os eventos adicionado e removido.

StartDeviceWatcher inicia o Inspetor dispositivo.

SelectDeviceInListchecks para ver se o usuário tiver selecionado um dispositivo e, em caso afirmativo, salva o índice para esse dispositivo. Ele também grava uma seqüência de caracteres "Atualmente conectado..." para a janela de saída se a conexão for bem-sucedida.

Em termos de API o escondeu, o código principal de interesse é no método OpenDeviceAsync. Este código chama o HidDevice.From­IdAsync método (bit.ly/1hyhVpI), que retorna um objeto HidDevice (bit.ly/1dsD2rR) que o aplicativo usa para acessar o dispositivo, recuperar relatórios de entrada e enviar relatórios de saída:

public async Task<Boolean> OpenDeviceAsync(DeviceInformation deviceInfo,
  String deviceSelector)
  {
    // This sample uses FileAccessMode.ReadWrite to open the device
    // because you don’t want other apps opening the device and  
    // changing the state of the  device.
// FileAccessMode.Read can be used instead.
device = await HidDevice.FromIdAsync(deviceInfo.Id, 
        FileAccessMode.ReadWrite);
...

O Inspetor dispositivo de apoio enumeração de dispositivo ocorre quando o aplicativo é iniciado primeiro e começa antes mesmo da interface do usuário é exibida. Após enumeração completa, o aplicativo monitora o status do dispositivo.

Status do dispositivo é relatado por um objeto DeviceWatcher (bit.ly/1dBPMPd). Como o nome implica, este objeto "relógios" os dispositivos conectados —­se o usuário remove ou conecta seu dispositivo, o observador relata o evento para o aplicativo.  (Esses eventos são relatados somente após terminar o processo de enumeração.)

Recuperar relatórios de entrada

O cenário de recuperação temperatura monitora os entrada relatórios emitidos pelo sensor de temperatura e usa um controle deslizante para exibir a temperatura atual, conforme mostrado na Figura 12. (Nota que este controle é limitado para exibir os dados de temperatura. As propriedades IsDoubleTapEnabled, IsHoldingEnabled, IsRightTapEnabled e IsTapEnabled têm todos sido definidas como False.)

Displaying the Current Temperature
Figura 12 exibir a temperatura atual

O principal método coadjuvante nesse cenário é o OnInput­manipulador de eventos ReportEvent, encontrado em Scenario2_GetTemperature­Data.xaml.cs. O app registra o manipulador de evento quando o usuário escolhe o cenário de dados de temperatura Get e pressiona o registo para botão de detecção da temperatura. O aplicativo registra o manipulador de eventos dentro do método RegisterForInputReportEvents. Além de registrar o manipulador, esse método salva um token de evento, então ele pode cancelar o registro.

private void RegisterForInputReportEvents()
{
  if (!isRegisteredForInputReportEvents)
  {
    inputReportEventHandler = new TypedEventHandler<HidDevice,
      HidInputReportReceivedEventArgs>(this.OnInputReportEvent);
    registeredDevice = EventHandlerForDevice.Current.Device;
    registeredDevice.InputReportReceived += inputReportEventHandler;
    isRegisteredForInputReportEvents = true;
  }
}

Uma vez que o manipulador de evento é registrado, se lê cada entrado relatório emitido pelo sensor e usa o novo valor de temperatura para atualizar o controle de TemperatureSlider. Depois que ele atualiza o controle, esse método grava a temperatura atual e relatório valores de intervalo para a seção de saída do aplicativo, como mostrado em Figura 13.

Figura 13-leitura e exibição de dados do Sensor

private async void OnInputReportEvent(HidDevice sender,
  HidInputReportReceivedEventArgs eventArgs)
{
  // Retrieve the sensor data
  HidInputReport inputReport = eventArgs.Report;
  IBuffer buffer = inputReport.Data;
  DataReader dr = DataReader.FromBuffer(buffer);
  byte[] bytes = new byte[inputReport.Data.Length];
  dr.ReadBytes(bytes);
  // Render the sensor data
  await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
  {
    CurrentReadingText.TextAlignment = TextAlignment.Center;
    CurrentReadingText.Text = bytes[1].ToString();
    TemperatureSlider.Value = (int)bytes[1];
    rootPage.NotifyUser(bytes[1].ToString() + 
     " degrees Fahrenheit, " +
      bytes[2].ToString() +
      " millisecond report-interval", NotifyType.StatusMessage);
  });
}

Envio de relatórios de saída

O cenário de relatório-intervalo envia um relatório de saída para o sensor de temperatura e grava a contagem de bytes, bem como o valor escrito para a área de saída da janela do aplicativo. O app envia um relatório de saída depois que o usuário escolhe o cenário de intervalo do relatório conjunto, seleciona um valor de valor de gravação suspensa e em seguida, pressiona o botão de enviar o relatório de saída.

Figura 14 mostra o cenário de intervalo do relatório conjunto e o menu suspenso que é preenchido com as opções de intervalo de relatório. (Estes valores representam um relatório-intervalo em milissegundos; Então, selecionando a 100, o aplicativo receberá 10 leituras cada segundo.)

Setting the Report Interval
Figura 14 definindo o intervalo de relatório

O método primário do cenário de relatório-intervalo é SetReportIntervalAsync, encontrado no Scenario3_SetReport­Interval.xaml.cs módulo (ver Figura 15). Este método chama o método HidDevice.SendOutputReportAsync (bit.ly/1ad6unK) para enviar um relatório de saída para o dispositivo.

Figura 15 SetReportIntervalAsync

private async Task SetReportIntervalAsync(Byte valueToWrite)
{
  var outputReport =
    EventHandlerForDevice.Current.Device.CreateOutputReport();
  var dataWriter = new DataWriter();
  // First byte contains the report id
  dataWriter.WriteByte((Byte)outputReport.Id);
  dataWriter.WriteByte((Byte)valueToWrite);
  outputReport.Data = dataWriter.DetachBuffer();
  uint bytesWritten =
    await EventHandlerForDevice.Current.Device.
SendOutputReportAsync(outputReport);
  rootPage.NotifyUser("Bytes written:  " + 
    bytesWritten.ToString() + ";
    Value Written: " + valueToWrite.ToString(), 
        NotifyType.StatusMessage);
}

Conclusão

Primeiro, eu lhe dei um rápido olhar para construir um dispositivo HID que monitora a tensão emitida por um sensor simples. Para obter um exemplo de como você pode monitorar um sensor que alterna um pino de I/O digital (ao invés de emiti uma gama de tensões), consulte o exemplo de sensor de movimento no MSDN em bit.ly/1gWOlcC.

Então você deu uma olhada rápida na escrita de um app simples que monitora e controla um dispositivo HID. Para obter mais informações sobre a API do WinRT HID, visite bit.ly/1aot1by.

Donn Morse é um conteúdo desenvolvedor sênior na Microsoft. Contactá-lo no donnm@microsoft.com.

Graças ao especialista técnico seguir para revisar este artigo: Arvind Aiyar (Microsoft)
Arvind Aiyar é engenheiro sênior de desenvolvimento de Software na Microsoft. Entre outras coisas, ele é o desenvolvedor responsável pela criação da nova API do WinRT HID.