Mostre Apreciação a Motoristas Corteses

Componentes e Materiais

Arduino MKR1000	1
Módulo Bluetooth SparkFun BlueSMiRF Silver	1
Conversor de Nível Lógico Bidirecional I2C 4 Canais Adafruit BSS138	1
Matriz Flexível Adafruit DotStar 8x32 - 256 LEDs RGB	1
Conjunto Cabo JST SM 4 pinos Adafruit	1
Conector Barril DC 2.1mm	1
Adaptador AC 5V @ 4A	1
Header Masculino 4 posições (0.1")	1
Protoboard (genérica)	1
Caixa de Projeto	1
Compensado Báltico 1/4" x 4.5" x 15"	1
Fita para Marcenaria, 1" x 50'	1

Ferramentas e Máquinas Necessárias

Ferro de Solda (genérico)

Pistola de Cola Quente (genérica)

Broca Forstner

Furadeira

Lixa (grão 120 para remover arestas vivas)

Aplicativos e Serviços Online

Arduino IDE

Virtual Shield for Arduino

Adafruit DotStar

Sobre o Projeto

Há quanto tempo dirijo, sempre quis poder me comunicar de forma mais significativa com os motoristas aleatórios ao meu redor. Parecia-me que um pisca de faróis, um aceno de mão, um gesto envolvendo muito mais que um aceno, uma buzinada ou uma freada brusca acabavam sendo mecanismos de comunicação muito rudimentares.

A inspiração para isso foi um filme do James Bond onde, na cena de abertura, ele tinha um texto exibido no vidro traseiro de seu Aston Martin. Pensei: eu poderia realmente dizer (não apenas expressar com mãos acenando) ao motorista do outro veículo exatamente o que estava pensando.

Aqui está uma demonstração no banco de testes:

E uma demonstração quase em ação real:

Aqui está o esboço do conceito:

Este projeto teve um desafio adicional porque o MKR1000 é uma placa de pré-lançamento e não há documentação formal. Há um excelente ponto de partida no Hackster:

Arduino MKR1000 Getting Started

Passo 1: Fazer o MKR1000 Comunicar

Tive sorte de entrar no fórum patrocinado pelo arduino.cc, que tinha um fórum privado para nós, proprietários de placas de pré-lançamento. Após um sábado sólido, consegui programar a placa e fazer todos os componentes funcionarem.

Minha configuração atual envolve a Arduino IDE versão 1.6.9 build hourly. Se você é como eu, usar builds "hourly" em um projeto deixa você "desconfortável" no mínimo.

Uma vez instalada a IDE, baixei os drivers da placa com o Gerenciador de Placas da IDE. Também carreguei as seguintes bibliotecas usando o Gerenciador de Bibliotecas da IDE: Adafruit DotStar, Adafruit DotStarMatrix, Adafruit GFX, ArduinoJson, e Windows Virtual Shields for Arduino.

Quando esta placa for lançada oficialmente, o processo será muito mais simples. Por isso, não vou detalhá-lo aqui. Há uma referência a um projeto para ajudá-lo a fazer isso no final do artigo.

Regra número 1 de construir eletrônicos: Nunca deixe a fumaça mágica sair do circuito!

O MKR1000 é uma placa baseada em 3.3V. Não tendo toda a documentação que gostaria, não sabia se eram tolerantes a 5 volts. Não apenas isso, alguns componentes realmente querem ter 5 volts disponíveis para estabelecer níveis lógicos 1 e 0 adequados.

Isso trouxe a necessidade do conversor de nível bidirecional de 4 canais da Adafruit. Tanto o cartão Bluetooth quanto especialmente a matriz DotStar realmente gostam de 5 volts completos. Portanto, tenha cuidado ao conectar estas coisas.

Verifique se os Componentes Funcionam

Antes de me preocupar em fazer tudo funcionar junto, queria ter certeza de que todos os componentes funcionavam.

Comecei com a Matriz Adafruit 8x32 DotStar. Descobri que as conexões que tinha eram um pouco instáveis. Para tornar isso não um problema, usei alguns pinos header que tinha por aí e apenas os soldei.

Com os pinos header firmemente anexados, roteie o Data e Clock In para os pinos SPI marcados SDA e SCL no MKR1000.

Carreguei o sketch de exemplo "File > Examples > Adafruit DotStarMatrix > matrixtest" na IDE. Ajustei o DATAPIN para 11 e CLOCKPIN para 12 no código. Compilei e carreguei a solução. Após um pouco de ajustes nas opções da matriz, acabei com um display funcionando.

Em seguida, fazer o Virtual Shield funcionar sobre o adaptador Bluetooth. Foi realmente simples. Segui as instruções mencionadas no repositório GitHub https://github.com/ms-iot/virtual-shields-arduino. A única mudança que tive que fazer foi nos pinos TX e RX. São os pinos 14 e 13 conforme marcados na minha placa.

Observo que em encarnações anteriores eu tinha que desconectar os pinos TX/RX para carregar novos sketches. Fico feliz em informar que este não é mais o caso.

Percorrendo o Código

Agora que tudo está funcionando, vou dedicar um momento para percorrer o código específico deste projeto.

Para acessar todas as funções, você precisa incluir o seguinte:

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_DotStarMatrix.h>
#include <Adafruit_DotStar.h>
#include <ArduinoJson.h>
#include <VirtualShield.h>
#include <Text.h>
#include <Graphics.h>
#include <Recognition.h>
#include <Colors.h>

Os primeiros 5 includes devem ser autoexplicativos.

O VirtualShield.h contém a funcionalidade base para comunicação sobre o adaptador Bluetooth. É necessário não importa qual dos sensores você deseja acessar.

O arquivo Text.h obtém melhor manipulação de texto, ou seja, tratamento de String.

Os arquivos Graphics.h, Recognition.h e Colors.h contêm a funcionalidade que você precisa para acessar a tela virtual e habilitar o reconhecimento de voz. Embora não finalizado para este desafio, codificarei os recursos de voz no futuro.

Próximo na lista de linhas importantes de código, inicializando a matriz DotStar e inicializando o objeto Shield:

Adafruit_DotStarMatrix matrix = Adafruit_DotStarMatrix(
  32, 8, DATAPIN, CLOCKPIN, 
  DS_MATRIX_TOP + DS_MATRIX_LEFT + DS_MATRIX_COLUMNS + DS_MATRIX_ZIGZAG, 
  DOTSTAR_GBR);
const uint16_t colors[] = {
  matrix.Color(255, 0, 0), matrix.Color(0, 255, 0), matrix.Color(0, 0, 255),
  matrix.Color(255, 0, 255), matrix.Color(255, 0, 106), matrix.Color(255, 255, 255)
};
VirtualShield shield;
Graphics screen = Graphics(shield);
Recognition speech = Recognition(shield);

A primeira linha informa à biblioteca DotStar o tamanho e layout da matriz. Consulte o exemplo matrixtest ou o arquivo Adafruit_DotStarMatrix.h para as várias opções.

As cores são para a biblioteca DotStar.

As últimas 3 linhas iniciam o shield e inicializam os objetos para trabalhar com os sensores do telefone.

Em seguida, como todos os sketches Arduino, precisamos lidar com o método setup()

void setup() {
  matrix.begin();
  matrix.setTextWrap(false);
  matrix.setBrightness(40);
  matrix.setTextColor(colors[0]);
  DisplayText("Initializing...", 4, 10);
  // configura eventos do virtual shield:
  shield.setOnRefresh(refresh);
  speech.setOnEvent(onSpeech);
  screen.setOnEvent(screenEvent);
  // inicia a comunicação do shield (também chama refresh()).
  shield.begin(); // assume baudrate 115200 Bluetooth
  DisplayText("Initializing...finished", 3, 10);
}

As linhas "matrix" são bastante autoexplicativas e, com essas linhas executadas, isso me dá a capacidade de agora emitir algumas mensagens informativas para a matriz.

As linhas "shield" agora configuram métodos de callback. Esses métodos serão chamados conforme necessário quando eventos acontecerem.

Agora o método mais complicado de todo o sketch

void loop() {
  // checkSensors() verifica eventos de retorno e os lida (chamando callbacks).
  // Este é o único método loop() do VirtualShield.
  shield.checkSensors();
}

Sim, você entendeu. Verificamos continuamente se algum dos sensores disparou um evento que precisa ser tratado.

Ok, agora vamos realmente lidar com alguns eventos. O primeiro é o método refresh(). Ele será chamado quando vários eventos diferentes acontecerem. O evento que nos interessa no momento é quando o Bluetooth está conectado. Precisamos do evento para que possamos redesenhar a tela para que ela pareça como deveria.

void refresh(ShieldEvent* shieldEvent) {
  // coloque seu código de refresh aqui
  // isto roda sempre que o Bluetooth conecta, sempre que shield.begin() executa, ou o botão 'refresh' é pressionado no app:
  screen.clear(ARGB(123,86,204));
  screen.drawAt(0,0, "");
  thanksId = screen.addButton(10, 50, ". Thank you .");
  welcomeId = screen.addButton(10, 100, ". Welcome .");
  turnLeftId = screen.addButton(10, 150, ". Left .");
  stoppingId = screen.addButton(175, 50, ". Stopping .");
  startingId = screen.addButton(175, 100, ". Starting .");
  turnRightId = screen.addButton(175, 150, ". Right .");
  backoffId = screen.addButton(10, 225, ". Back Off .");
  calling911Id = screen.addButton(10, 290, ". Calling 911 .");
}

Este método limpa a tela com um fundo roxo claro e prossegue colocando os vários botões na tela. Observe o espaçamento ao redor das palavras. Esta é uma limitação atual da funcionalidade do virtual shield, pois eu realmente queria centralizar as coisas para que ficassem bonitas.

Então, o que acontece quando toco em um desses botões? Um evento é disparado e é tratado no seguinte pedaço de código.

void screenEvent(ShieldEvent* shieldEvent) {
  if(screen.isPressed(thanksId)) {
    DisplayText("Thank You", 5, 100);
  }
  if(screen.isPressed(welcomeId)) {
    DisplayText("You're welcome", 2, 100);
  }
  if(screen.isPressed(backoffId)) {
    DisplayText("Please back off", 4, 100);
  }
  if(screen.isPressed(stoppingId)) {
    DisplayText("...stopping...", 0, 100);
  }
  if(screen.isPressed(startingId)) {
    DisplayText("...starting...", 1, 100);
  }
  if(screen.isPressed(turnLeftId)) {
    DisplayText("Turning LEFT", 3, 100);
  }
  if(screen.isPressed(turnRightId)) {
    DisplayText("Turning RIGHT", 3, 100);
  }
  if(screen.isPressed(calling911Id)) {
    DisplayText("Calling 911", 0, 100);
  }
}

Um evento entra, o código verifica qual botão foi pressionado e chamamos o método DisplayText com o conteúdo a mostrar.

E finalmente, como o texto sai para a matriz? O método DisplayText cuida disso para você.

void DisplayText(String message, int colorIndex, int currDelay) {
  int x = matrix.width();
  int maxX = -1 * (message.length() * 5 + message.length());
  matrix.setTextColor(colors[colorIndex]);
  while(x > maxX) {
    matrix.fillScreen(0);
    matrix.setCursor(x, 0);
    matrix.print(message);
    --x;
    matrix.show();
    delay(currDelay);
  }
}

Este método descobre quão larga esta string realmente é. Precisamos saber, para que possamos garantir que a string seja totalmente rolada para dentro e para fora da visualização. As letras têm 5 de largura + 1 para o espaço entre as letras.

Construa o Gabinete

A construção foi bastante direta. Encontrei uma caixa de tamanho decente que era maior que a pegada da matriz. Peguei um pedaço de compensado báltico de 1/4" que era maior do que eu precisava e cortei no tamanho certo.

Usando a mesma técnica da serra de mesa. Comece colocando a matriz no compensado. Após posicionada, marque os centros horizontal e vertical das conexões (incluindo a conexão de energia auxiliar). Tudo o que você precisa fazer agora é conectar as linhas para encontrar o centro dos furos que você está prestes a furar.

Sim, eu disse 'furar', não 'perfurar'. A última vez que estava "perfurando" furos em plástico, tive resultados muito insatisfatórios. Desta vez usei brocas Forstner. Tenho uma foto delas abaixo. Observe como a borda é para corte e o centro tem um raspador para remover a madeira indesejada. Faz um "furo" muito mais bonito. Agora, vá em frente e 'fure' e provavelmente você vai querer furar os furos de suspensão.

Pegue uma lixa de grão 120 e lixe levemente toda a peça. Certifique-se de 'amaciar' as bordas da placa, incluindo todos os furos que foram feitos. Certifique-se de limpar a placa, para que não haja serragem ou outra "sujeira" na placa.

Agora é hora de trabalhar na caixa de plástico.

Fure dois furos em cada extremidade da caixa. Estes são para o conector de energia e a conexão com a matriz. Não fure o furo de energia auxiliar da matriz ainda.

Agora, aplique algumas tiras da fita dupla-face na parte de trás da caixa e fixe a caixa no compensado. Como esta é fita "reposicionável", eu realmente queria que isso grudasse para sempre. Coloquei alguns livros pesados em cima e deixei por 24 horas. Por que 24 horas? As instruções da fita dizem para não fazer isso. Foi um motivo bom o suficiente para mim.

Hora daquele último furo. Agora você deve ter uma posição exata para o furo de conexão de energia auxiliar. Fure-o, aproveite seu trabalho 'preciso'.

Coloque a Inteligência na Caixa

Parece que a protoboard era do tamanho certo para a caixa, mas eu queria poder conectar/desconectar o conector USB do MKR1000. Então, tive que tornar a protoboard mais curta.

Ok, depois desse trauma, remova a proteção traseira da protoboard e cole-a. Certifique-se de evitar o furo de conexão de energia auxiliar.

Anexe a matriz na frente do compensado passando as conexões pelos furos. Fixe a matriz com um pouco de cola quente.

Vamos Falar de Energia

Embora eu tenha o brilho definido a 40%, a corrente máxima se eu acender todos os 256 pixels é de cerca de 7.5 Amperes. Muito mais do que o MKR1000 poderia fornecer. Felizmente para mim, nenhum dos displays é estático e não estou acendendo nem perto da matriz completa. A conexão de energia auxiliar vem ao resgate. Estou fornecendo até 4A. Como não é sustentado e não é estático, a fonte de alimentação deve ser boa.

Também tinha um wall-wart sobressalente que usei a ponta para fornecer energia ao MKR1000 quando alimentado no veículo.

Estava pensando em construir um conversor de energia no projeto para pegar 12V do carro e entregar 5V ao projeto. Após muito pensamento, foi melhor em todos os aspectos conseguir um adaptador AC 5V 4A por $5.00 e usar um conversor AC que já tinha. Simples é geralmente melhor quando se trata dessas coisas.

Pendurando a Placa

Planejei usar "cabos elásticos com bola" e ventosas para fixar isso no vidro traseiro. Vamos apenas dizer, tenho mais trabalho a fazer nessa área.

Código

Código "Say Thanks"

https://github.com/pulcher/mkr1000_challenge

Esquemáticos

O MKR1000 é apenas um micro, pois o MKR1000 real ainda não foi lançado.