Como usar a USB Host Shield no Arduino

Introdução

Neste tutorial iremos aprender como usar uma shield bastante interessante para o Arduino: a USB Host Shield, que permite fazer a conexão com vários dispositivos USB, como mouse, teclado, Smartphone Android, câmera USB, pendrive, HD externo, leitores biométricos, controles de video-game, e uma vasta gama de dispositivos USB, utilizando USB 2.0 e tendo total capacidade de fazer conexões em alta velocidade..

Com a shield conectada, o Arduino passa operar como host USB, que é um gerenciador (servidor) da conexão USB, onde, ele poderá gerenciar os periféricos USB. A função de um Host USB é alimentar os periféricos e controlar eles via protocolo USB. Assim, podemos incrementar nos nossos projetos vários componentes presentes no nosso cotidiano, fazendo os projetos ficarem ainda mais inteligentes e integrados.

A shield faz a conexão com o Arduino via protocolo SPI, sendo assim, ela é compatível com os modelos de Arduino mais comuns no mercado, como o Uno e o Mega.

Configurando a IDE Arduino

Como toda Shield, para fazer a instalação dela no Arduino encaixando ela por cima da placa, tendo muito cuidado e verificando se todos os pinos estão encaixados. Se algum pino eventualmente estiver torto, desentorte um pouco, e tente encaixar novamente.

Abra a IDE Arduino, e lá vá em “Ferramentas>Gerenciar Bibliotecas”

E busque por “USB Host Shield” na guia de pesquisas. Instale a biblioteca USB Host Shield Library 2.0, do Oleg Mazurov.

E com isso, poderemos fazer o uso dessa shield e explorar as vantagens que ela pode trazer para os nossos projetos.

Conectando um teclado USB

Essa biblioteca tem a vantagem de possuir vários exemplos bastante completos para o uso, e para acessar estes exemplos, basta ir em:

“Arquivo > Exemplos > USB Host Shield Library 2.0”

Aqui nós usaremos o exemplo do uso do teclado USB, para isso, copie o código ou vá em: “Arquivo > Exemplos > USB Host Shield Library 2.0 > HID > USBHIDBootKbd”

#include <hidboot.h>
#include <usbhub.h>

// Satisfy the IDE, which needs to see the include statment in the ino too.
#ifdef dobogusinclude
#include <spi4teensy3.h>
#endif
#include <SPI.h>

class KbdRptParser : public KeyboardReportParser
{
    void PrintKey(uint8_t mod, uint8_t key);

  protected:
    void OnControlKeysChanged(uint8_t before, uint8_t after);

    void OnKeyDown	(uint8_t mod, uint8_t key);
    void OnKeyUp	(uint8_t mod, uint8_t key);
    void OnKeyPressed(uint8_t key);
};

void KbdRptParser::PrintKey(uint8_t m, uint8_t key)
{
  MODIFIERKEYS mod;
  *((uint8_t*)&mod) = m;
  Serial.print((mod.bmLeftCtrl   == 1) ? "C" : " ");
  Serial.print((mod.bmLeftShift  == 1) ? "S" : " ");
  Serial.print((mod.bmLeftAlt    == 1) ? "A" : " ");
  Serial.print((mod.bmLeftGUI    == 1) ? "G" : " ");

  Serial.print(" >");
  PrintHex<uint8_t>(key, 0x80);
  Serial.print("< ");

  Serial.print((mod.bmRightCtrl   == 1) ? "C" : " ");
  Serial.print((mod.bmRightShift  == 1) ? "S" : " ");
  Serial.print((mod.bmRightAlt    == 1) ? "A" : " ");
  Serial.println((mod.bmRightGUI    == 1) ? "G" : " ");
};

void KbdRptParser::OnKeyDown(uint8_t mod, uint8_t key)
{
  Serial.print("DN ");
  PrintKey(mod, key);
  uint8_t c = OemToAscii(mod, key);

  if (c)
    OnKeyPressed(c);
}

void KbdRptParser::OnControlKeysChanged(uint8_t before, uint8_t after) {

  MODIFIERKEYS beforeMod;
  *((uint8_t*)&beforeMod) = before;

  MODIFIERKEYS afterMod;
  *((uint8_t*)&afterMod) = after;

  if (beforeMod.bmLeftCtrl != afterMod.bmLeftCtrl) {
    Serial.println("LeftCtrl changed");
  }
  if (beforeMod.bmLeftShift != afterMod.bmLeftShift) {
    Serial.println("LeftShift changed");
  }
  if (beforeMod.bmLeftAlt != afterMod.bmLeftAlt) {
    Serial.println("LeftAlt changed");
  }
  if (beforeMod.bmLeftGUI != afterMod.bmLeftGUI) {
    Serial.println("LeftGUI changed");
  }

  if (beforeMod.bmRightCtrl != afterMod.bmRightCtrl) {
    Serial.println("RightCtrl changed");
  }
  if (beforeMod.bmRightShift != afterMod.bmRightShift) {
    Serial.println("RightShift changed");
  }
  if (beforeMod.bmRightAlt != afterMod.bmRightAlt) {
    Serial.println("RightAlt changed");
  }
  if (beforeMod.bmRightGUI != afterMod.bmRightGUI) {
    Serial.println("RightGUI changed");
  }

}

void KbdRptParser::OnKeyUp(uint8_t mod, uint8_t key)
{
  Serial.print("UP ");
  PrintKey(mod, key);
}

void KbdRptParser::OnKeyPressed(uint8_t key)
{
  Serial.print("ASCII: ");
  Serial.println((char)key);
};

USB     Usb;
//USBHub     Hub(&Usb);
HIDBoot<USB_HID_PROTOCOL_KEYBOARD>    HidKeyboard(&Usb);

KbdRptParser Prs;

void setup()
{
  Serial.begin( 115200 );
#if !defined(__MIPSEL__)
  while (!Serial); // Wait for serial port to connect - used on Leonardo, Teensy and other boards with built-in USB CDC serial connection
#endif
  Serial.println("Start");

  if (Usb.Init() == -1)
    Serial.println("OSC did not start.");

  delay( 200 );

  HidKeyboard.SetReportParser(0, &Prs);
}

void loop()
{
  Usb.Task();
}

Envie o programa e quando ele for carregado no Arduino, conecte o teclado e abra o Monitor Serial, configure o Baud Rate para a velocidade de 115200, embaixo da janela, e então verifique que é demonstrado quando uma tecla é pressionada, solta, e qual tecla corresponde.

Corrigindo um problema

Um problema comum de ocorrer com essa Shield é que quando encaixamos ela no Arduino, toda a placa para de responder e não é possível enviar os programas, e os programas já enviados param de responder também. Este problema se dá porque a tensão de operação da shield não foi selecionada, e para resolver isso é relativamente simples.

Observe que existem 4 terminais próximos ao botão de reset. Eles são feitos para fazer a configuração da placa. Quando essa configuração não é feita, esse problema ocorre.

Coloque uma gota em cima desses 3 terminais destacados em vermelho na imagem acima, e o problema irá cessar.

Se gostou da shield e as possibilidades que ela nos traz para os projetos, deixa um joinha!

Qualquer dúvida, deixe nos comentários abaixo!

Abraços!