---

Maio de 2017

Volume 32 - Número 5

Internet das Coisas - Trabalhando com o Raspberry Pi e o Windows 10

Por Bruno Sonnino

Apesar de trabalhar com software há muito tempo, nunca interagi diretamente com hardware. Desenvolvi diversos softwares que operam bem próximos ao hardware, mas ainda não havia trabalhado com uma placa física de onde posso controlar tudo o que está sendo feito. Por isso, quando tive a oportunidade de trabalhar com o Raspberry Pi, principalmente usando o Windows 10 e o Visual Studio, não pensei duas vezes.

O Raspberry Pi, nas versões 2 e 3, pode usar o Windows 10 como seu sistema operacional (embora não seja a versão completa do sistema operacional, você pode executar aplicativos da Plataforma Universal do Windows [UWP] para controlar os dispositivos do computador). Ele é um computador barato ( custa menos de US$ 35,00) e muito poderoso. O Raspberry Pi 3 tem processador ARM quad-core de 64 bits, vídeo HDMI, conexões de rede Ethernet e Wi-Fi, Bluetooth e quatro portas USB. Você realmente pode fazer várias coisas com ele.

O hardware

Para começar, você pode usar a placa do Raspberry Pi sozinha, mas isso oferece algumas limitações. Usar apenas a placa seria o mesmo que desenvolver para um computador ou um smartphone. Você também precisa usar outros hardwares. Alguns fabricantes criaram kits para complementá-lo: placas de protótipo, resistores, LEDs, potenciômetros, sensores e um cartão de memória. Você pode comprar uma capa para o computador, mas isso não é necessário, porque você precisa mantê-lo aberto para fazer as conexões.

Conhecendo o hardware

Depois que você tiver a placa e o kit, é hora de conhecer o hardware. Primeiro, explore o Raspberry Pi e veja o que ele tem para oferecer. A Figura 1 mostra a placa.

Figura 1: Raspberry Pi 3 modelo B com GPIO

Do lado direito da placa ilustrada na Figura 1, você pode ver quatro portas USB (1) e o conector Ethernet (2). Na parte de baixo, da esquerda para a direita, há uma entrada mini USB (3), o vídeo HDMI (4), a porta da câmera (5) e a saída de áudio (6). Do lado esquerdo da placa estão o slot para cartão micro SD (7) e um conector para monitor LCD (8). Há também o adaptador para Wi-Fi e Bluetooth (9). No meio da placa, você pode ver o processador (10) e o controlador de rede (11). Na parte de cima, está o bloco GPIO (General Purpose Input/Output) (12), onde você faz todas as conexões. Cada pino tem uma finalidade, como mostra a ilustração acima da figura.

O Raspberry Pi usa duas fontes de tensão: 5V e 3,3V. Os pinos pretos são terra e os amarelos são os pinos de GPIO, que você usará em sua programação. Observe que os pinos não estão numerados em ordem. Por isso, a menos que você tenha uma excelente memória, tenha um diagrama como esse sempre à mão (você pode encontrar um em bit.ly/1WcBUS2).

A segunda etapa é estudar o kit. Não falarei sobre o conteúdo do kit, porque ele pode variar muito, dependendo do fabricante (ou do que você pretende comprar). Para este projeto, você precisará de uma placa de ensaio, três LEDs, resistores e fios. Se você quiser saber mais sobre esses componentes e como interagir com eles, leia o artigo “Writing UWP Apps for the Internet of Things”, da coluna Modern Apps, escrito por Frank La Vigne em abril de 2016 em msdn.com/magazine/mt694090.

Montando o primeiro circuito

Depois de conhecer a placa e esses componentes simples, você já pode montar o primeiro circuito. Normalmente, o “Olá, Mundo” de um sistema como este é um programa que faz o LED piscar. Para simplificar isso ao máximo, comece criando um circuito que acenda o LED, em vez de fazê-lo piscar. Para fazer isso, você não precisa de nenhum tipo de programa, apenas entender o circuito que vai construir.

Se você conectar o LED diretamente ao pino de 3,3V do Raspberry Pi, provavelmente ele queimará, pois não suporta a corrente que passará por ele. Usando a lei de Ohm (V = R*I), você precisa adicionar um resistor de 220 Ω (vermelho/vermelho/preto) ao circuito. Caso não tenha um resistor de 220 Ω, você pode usar um maior; com um resistor maior há menos corrente no circuito, portanto o LED não é danificado. O resistor não pode ser muito grande porque se a corrente for pequena demais, o LED não acenderá. No meu caso, usei um resistor de 330 Ω e não tive problemas.

Para ver como ficou a montagem na placa de ensaio, veja a Figura 2. A imagem foi criada com um programa de software livre chamado “Fritzing”, que pode ser baixado em fritzing.org.

Figura 2: Circuito montado

Depois de montar o circuito (faça isso com a fonte de alimentação do Raspberry Pi desconectada para evitar que algum componente queime), conecte a fonte de alimentação. Se você tiver montado o circuito corretamente, o LED acenderá. Se o LED não acender, verifique se seus polos estão nas posições corretas. O polo positivo (fio mais longo) e a conexão com o pino de 3,3V no Raspberry Pi devem estar na mesma linha horizontal. O polo negativo e o resistor (neste caso não há polarização) devem estar na mesma linha. O segundo fio do resistor deve estar conectado à linha que vai até o pino terra no Raspberry Pi. Se tudo estiver certo, verifique se o LED está queimado. Se estiver, substitua-o por um novo. Quando o LED acender, você já pode seguir para a próxima etapa: criar um programa que controle o LED.

Instalando e usando o Windows 10

Até agora, você não precisou de um sistema operacional, porque não foi necessário programar o Raspberry Pi, mas você precisará usar um pouco de programação para continuar com sua exploração. Para isso, você usará o Windows 10. Você pode baixar e instalar o Windows 10 para o Raspberry Pi gratuitamente que, embora ele não seja exatamente a mesma versão executada em desktops e tablets, permite a execução de programas para a UWP sem a necessidade de fazer qualquer alteração.

A primeira etapa é baixar e instalar o Windows 10 no cartão SD. Para isso, baixe e instale a ferramenta Painel do Windows 10 Internet das Coisas (IoT) Core em bit.ly/2lPXrRc.

Para instalar o Windows 10 no Raspberry Pi, você precisa ter um cartão micro SD compatível com pelo menos 8 GB. Em seguida, selecione a opção “Configurar um novo dispositivo” no painel para baixar e instalar o Windows 10 no cartão SD. Você precisará usar seu computador para gravar os dados nesse cartão. Se você não tiver um leitor de cartão, compre um leitor de cartão USB.

Selecione o tipo de dispositivo, o sistema operacional e a unidade em que o cartão SD está. Atribua um nome ao computador e selecione uma senha de administrador. Marque a caixa de seleção para aceitar os termos de licença e clique no botão Instalar. Depois de baixar e gravar os dados no cartão, o Windows 10 estará instalado e pronto para ser usado. Remova-o do leitor de cartão do computador e coloque-o no slot do Raspberry Pi. Conecte-o à rede usando um cabo Ethernet, ou via Wi-Fi se você estiver usando o Raspberry Pi 3 ou 2 com um dongle Wi-Fi. Ligue o dispositivo.

Depois que o Windows 10 tiver sido reiniciado, você poderá ver o dispositivo conectado em Meus dispositivos no Painel do IoT Core.

Você pode abrir o portal de dispositivos no navegador usando o endereço IP mostrado para o dispositivo conectado na porta 8080. No meu caso, posso abri-lo com o endereço http://192.168.1.199:8080. Ele solicitará a senha de administrador que você definiu antes de abrir o portal, como mostra a Figura 3.

Figura 3: Portal de dispositivos

Aqui, você pode configurar o dispositivo, ver os aplicativos instalados nele e verificar o desempenho e o armazenamento do dispositivo. A última opção, Remoto, permite que você tenha acesso remoto ao dispositivo. Essa opção é útil se não houver um monitor conectado ao dispositivo, possibilitando que você o controle remotamente por seu computador. Marque a caixa de seleção “Habilitar Servidor Remoto do Windows IoT” para habilitar o acesso remoto ao dispositivo e baixar o aplicativo de controle remoto para Windows 10 na loja.

Depois de instalar e executar o aplicativo Windows IoT Remote, você poderá controlar o dispositivo e interagir com ele remotamente.

Agora, você já pode começar a desenvolver para o Raspberry Pi usando o Windows 10.

Desenvolvendo para o Raspberry Pi com o Visual Studio

Para desenvolver para o Raspberry Pi usando o Visual Studio, você precisa ter certeza de que instalou as ferramentas. Para confirmar isso, selecione “Instalação personalizada” e marque a caixa de seleção Ferramentas de Desenvolvimento de Aplicativo Universal do Windows na seção Recursos.

Depois disso, as ferramentas serão instaladas, e você poderá começar a desenvolver para o Raspberry Pi usando o Windows 10. Crie um novo projeto e selecione o aplicativo “em branco” da UWP.

Isso criará um aplicativo em branco para você criar um aplicativo que mostra o nome da máquina atual na tela principal. No arquivo Main­Page.xaml, adicione o seguinte código:

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
  <TextBlock FontSize="32" x:Name="MachineText"
    HorizontalAlignment="Center"
    VerticalAlignment="Center"/>
</Grid>

Depois, no arquivo MainPage.xaml.cs, adicione esse código para obter e mostrar o nome da máquina:

public MainPage()
  this.InitializeComponent();
  Windows.Security.ExchangeActiveSyncProvisioning.EasClientDeviceInformation eas =
    new Windows.Security.ExchangeActiveSyncProvisioning.EasClientDeviceInformation();
  MachineText.Text = eas.FriendlyName;
}

Se você executar esse aplicativo em sua máquina local, ele exibirá uma janela com o nome da sua máquina.

Em seguida, execute o Raspberry Pi. No menu suspenso Plataforma da Solução, selecione ARM, e no menu suspenso Dispositivo, selecione Máquina Remota. Uma caixa de diálogo é exibida para você selecionar a máquina remota.

Selecione o dispositivo Raspberry Pi e execute o aplicativo. O aplicativo será implantado no Raspberry Pi, e você poderá vê-lo sendo executado na janela de controle remoto. Observe que o nome da máquina exibido na janela deve ser o mesmo nome que você definiu quando formatou o cartão SD e instalou o Windows 10 nele.

Você pode depurar esse aplicativo como faria com aplicativos locais: definindo os pontos de interrupção, analisando as variáveis, etc. Se encerrar o aplicativo no Visual Studio, você verá que o aplicativo é fechado e a janela principal é exibida no Raspberry Pi. Se você acessar o portal do navegador, verá que o aplicativo ainda está instalado e pode ser executado com o botão Executar, como mostra a Figura 4.

Figura 4: Portal de aplicativos mostrando o aplicativo instalado

Estou surpreso com o nível de compatibilidade dos aplicativos da UWP. Para mostrar o potencial disso, usarei um aplicativo que não foi criado para o Raspberry Pi. Usarei o aplicativo de exemplo para o Kit de Ferramentas de Comunidade UWP, um kit de ferramentas com componentes desenvolvidos pela Microsoft e a comunidade, que definitivamente vale a pena conhecer em bit.ly/2b1PAJY.

Se você baixar e compilar o pacote, poderá implantá-lo no Raspberry Pi e executá-lo (sim, você pode executar o programa exatamente como faria em um desktop). E por falar nisso, experimente usar os controles no dispositivo; eles funcionam bem.

Interagindo com a placa

Depois que seus programas estiverem em execução, você já pode começar a interagir com a placa. Você criará um controlador de semáforo. Ele terá três LEDS (um vermelho, um amarelo e um verde) e é possível definir tempos diferentes para cada luz.

Para operar os LEDs na placa, você precisa obter o controlador GPIO, abrir o pino que deseja controlar e configurá-lo como desejar. Na Figura 1, você pode ver que o oitavo pino no bloco GPIO (na segunda linha) é o pino 22. Você usará os pinos 22, 9 e 19, e o circuito resultante será igual ao mostrado na Figura 5.

Figura 5: Circuito para o semáforo

Depois de concluir esse circuito, crie um novo aplicativo da UWP em branco. No arquivo MainPage.xaml, adicione o código mostrado na Figura 6.

Figura 6: Código no arquivo Main Page xaml mostrando o semáforo

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
  <Border BorderBrush="Black" BorderThickness="3" HorizontalAlignment="Center"
      VerticalAlignment="Center" CornerRadius="5">
    <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
      <Ellipse Width="50" Height="50" Fill="Red" Opacity="0.5"
        Margin="20,20,20,10" x:Name="RedLed" Stroke="Black"
        StrokeThickness="1"/>
      <Ellipse Width="50" Height="50" Fill="Yellow" Opacity="0.5"
        Margin="20,10,20,10" x:Name="YellowLed" Stroke="Black"
        StrokeThickness="1"/>
      <Ellipse Width="50" Height="50" Fill="LimeGreen" Opacity="0.5"
         Margin="20,10,20,20" x:Name="GreenLed" Stroke="Black"
         StrokeThickness="1"/>
    </StackPanel>
  </Border>
</Grid>

Você verá o semáforo na placa e na tela, para saber o que está acontecendo na tela com acesso remoto. O código-fonte no arquivo Mainpage.xaml.cs é mostrado na Figura 7.

Figura 7: Código-fonte para acender o semáforo em intervalos especificados

private int _currentLight;
private DispatcherTimer _timer;
private int[] _pinNumbers = new[] { 22, 9, 19 };
private GpioPin[] _pins = new GpioPin[3];
public MainPage()
{
  this.InitializeComponent();
  if (InitGPIO())
    InitTimer();
}
private void InitTimer()
{
  var intervals = new[] { 6000, 2000, 6000 };
  var lights = new[] { RedLed, YellowLed, GreenLed };
  _currentLight = 2;
  _timer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(500) };
  _timer.Tick += (s, e) =>
  {
    _timer.Stop();
    lights[_currentLight].Opacity = 0.5;
    _pins[_currentLight].Write(GpioPinValue.High);
    _currentLight = _currentLight == 2 ? 0 : _currentLight + 1;
    lights[_currentLight].Opacity = 1.0;
    _pins[_currentLight].Write(GpioPinValue.Low);
    _timer.Interval = TimeSpan.FromMilliseconds(intervals[_currentLight]);
    _timer.Start();
  };
  _timer.Start();
}

Para executar esse código, você precisa adicionar uma referência às extensões de IoT. Clique com o botão direito do mouse no nó Referências do Gerenciador de Soluções, clique em Adicionar Referências, navegue até Extensões e adicione as Extensões do Windows IoT para UWP.

Você cria um temporizador que acenderá cada LED em um intervalo definido pela matriz de intervalos (no seu caso, 6 segundos, 2 segundos e 6 segundos). A opacidade das elipses na tela foi definida para 0,5, por isso elas aparecem esmaecidas. A opacidade de cada uma delas será definida para 1 quando a luz estiver acesa. O temporizador só será definido se você puder configurar a GPIO para a placa, com a função InitGPIO, como mostra a Figura 8.

Figura 8: Código para inicializar a GPIO e configurar os pinos de LED para saída

private bool InitGPIO()
{
  var gpio = GpioController.GetDefault();
  if (gpio == null)
    return false;
  for (int i = 0; i < 3; i++)
  {
    _pins[i] = gpio.OpenPin(_pinNumbers[i]);
    _pins[i].Write(GpioPinValue.High);
    _pins[i].SetDriveMode(GpioPinDriveMode.Output);
  }
  return true;
}

Abra os três pinos para saída e configure-os como Alta, para que os LEDs apaguem. Quando você atribui a configuração Baixa para um pino, a corrente flui pelo circuito e o LED acende. Ao executar o programa, você verá uma tela com um semáforo, cujas luzes acendem e apagam como em um semáforo real, e a placa terá a aparência da foto na Figura 9.

Figura 9: Placa com semáforo durante a execução do programa

Conclusão

Como você pode ver, é muito simples criar programas que interagem com o Raspberry Pi. Conhecendo a programação do Windows 10, você já sabe tudo o que precisa para programar um Raspberry Pi (sim, interagir com a placa é outra história, mas já estamos na metade do caminho). Você pode criar seus programas como criaria qualquer programa do Windows 10 (na verdade, os programas da UWP são executados sem nenhuma alteração no Raspberry Pi). A única diferença é que você tem o controlador de GPIO para configurar e obter dados. Se você quiser ampliar seus conhecimentos e experimentar outros projetos, há vários exemplos em bit.ly/2llecFZ. Isso abrirá uma ampla gama de oportunidades, e você poderá combinar um hardware avançado com um software excelente e produtivo. Essa é uma combinação imbatível.

---

Bruno Sonnino é Microsoft MVP desde 2007. Ele é desenvolvedor, consultor e escritor com diversos livros e artigos publicados sobre desenvolvimento no Windows. Você pode segui-lo no Twitter (@bsonnino) ou ler seu blog em blogs.msmvps.com/bsonnino.

Agradecemos ao seguinte especialista técnico da Microsoft pela revisão deste artigo: Rachel Appel