Latch e a Internet das Coisas: Integração prática com Arduino (VI)

quarta-feira, 9 de dezembro de 2015

Nós já temos quase tudo que você precisa para executar o nosso projeto. Nós preparamos um Arduino com conexão WiFi (e resolvido os problemas relevantes), estudamos a API e Latch e programado nossa própria versão. Deve preparar a saída física com o dispositivo selecionado (neste caso uma campainha). Vejamos como. 

Conexão IoT, a Internet das coisas: entrada e saída para o mundo real 

Sem dúvida alguma, o destaque do Arduino está em seu manuseio das entradas e saídas para o mundo real. Quer digital ou analógico, tem uma grande variedade de software e hardware acessórios para funções de manipulação.Podemos encontrar na internet todos os tipos de exemplos. A integração proposta requer apenas uma entrada para detectar quando tocar a campainha (Knock!), E uma saída para ativar a própria campainha (Bell), dependendo do estado do Latch. 

Neste caso, tanto a entrada e a saída são no mundo real que funciona com a tensão de alimentação, de 220 ​​volts AC ou 110 volts AC, dependendo do país, por isso devem ser tomadas precauções para evitar qualquer risco com essas tensões. 

A gestão com Arduino de saídas que agem para a tensão de alimentação é muito frequente, então há inúmeros módulos e exemplos disponíveis, geralmente usando relés ou outros mecanismos que fornecem algum isolamento. A detecção da tensão de alimentação como entrada é menos comum, mas não implica qualquer dificuldade em obter seguro. 

Em ambos os casos, é recomendável empregar opto-acopladores que proporcionam isolamento completo entre a tensão de alimentação e eletrônica do Arduino. Através de uma presença de foto-transistor da tensão de alimentação na entrada (INPUT) é detectado, eo conjunto de uma foto-triac e poder, este passo para permitir a saída (OUTPUT). 

Detecção e conexão para a saída de 220V AC

De acordo com esta disposição, o circuito recebe apenas a tensão de alimentação através da entrada (INPUT) enquanto estiver pressionando o interruptor de campainha, fazendo com que o Arduino nunca ative a saída (output) se você não está pressionando o interruptor ao mesmo tempo. 

O código de exemplo totalmente funcional é publicado no repositório GitHub: https://github.com/latchdevel/latch-arduino. Pode ser visto que a entrada (Knock!) Responde a uma interrupção arranjado para esta finalidade. A saída (Bell) permanece desligada quando você está conectado à rede e somente se você executou o tempo de sincronização inicial. Ele é ativado somente após consulta de status de Latch. Apenas é percebida porque o tempo de resposta é menos de 500 milissegundos.

Um modo de demonstração se parece com a proposta abaixo: 

Exemplo de montagem

E se lembrar de como funciona, também pode ser visto o vídeo de demonstração:


Nós encorajamos você a usar a comunidade ElevenPaths como um fórum para discutir melhorias, idéias ou qualquer outra invenção que você pode pensar. 


Jorge Rivera
jorge.rivera@11paths.com

traduzido por Leandro Bennaton
leandro.bennaton@11paths.com

Latch e a Internet das Coisas: Integração prática com Arduino (V)

domingo, 6 de dezembro de 2015

No post anterior, estudamos como carregar o firmware no módulo WiFi para atender às nossas necessidades. Agora vamos ver como funciona a API de Latch e como fazer um esboço de Arduino para implementa-lo.

API de Latch

Até agora você sabe que Latch disponibiliza de um padrão API aberta, que pode ser usado por HTTP  através de um tipo convencional de requisições, GET. Você tem todas as informações em https://latch.elevenpaths.com. 

Aqui vamos resumir algumas partes importantes.

Tal como indicado na documentação Latch "todas as solicitações da API de Latch devem ser assinado. O processo de assinatura é uma versão simplificada do protocolo OAuth de duas vias.". Cada pedido deve ser acompanhado de dois cabeçalhos (HTTP headers) de autenticação: "X-11Paths-Date" e "Autorização" nos seguintes formatos: 

X-11Paths-Date: yyyy-MM-dd HH:mm:ss

O cabeçalho X-11Paths-Date contém a data e hora UTC, no momento do pedido, o formato e valor deve ser exatamente o mesmo que o utilizado no processo de criação do pedido.

Authorization: 11PATHS applicationId requestSignature

Onde:
  • 11PATHS é uma constante que determina o método de autenticação.
  • applicationID é um identificador alfanumérico que é obtido ao criar o aplicativo ou operação.
  • requestSignature é uma assinatura derivada da URL, parâmetros, os cabeçalhos personalizados e data da solicitação, assinada pelo algoritmo HMAC-SHA1 com o segredo obtido ao criar o aplicativo, e codificado com Base64.

O ApplicationID e o sigilo são obtidos no momento da criação do aplicativo a partir do Painel de Controle  Web do Desenvolvedor de Latch.

Painel de Controle Web do Desenvolvedor Latch

A operação para obter o estado da Latch que o usuário tenha definido para a aplicação definida no cabeçalho de autorização é uma solicitação GET para o URL:

https://latch.elevenpaths.com/api/1.0/status/{accountId}

A API de Latch retornarum JSON que indica o status correspondente:

{"data":{"operations":{"WFqXXXXXXXXXXXXXXXXXZORO":{“status":"on"}}}}

accountId do usuário é obtida como resultado da operação de emparelhamento. Isto pode ser realizado por um simples script shell Bash como este: 

  #! / Bin / bash

 if [-z "$ 1"];  Em seguida
  echo -e "\ nUsage: $ 0   \ N "
  exit 0
 fi

 ApplicationId = "WFqXXXXXXXXXXXXXXXXXZORO"
 SecretKey = "I8QsZCXXXXXXXXXXXXXXXXXXXXXXXXXXXXHml"

 Servidor = "https://latch.elevenpaths.com"
 URL = "/ api / 1,0 / par / $ 1"

 requestSignature + = "GET \ n"
 date = `date + u% Y-% m-% d% H:% M:% S'`
 requestSignature + = "$ data \ n \ n $ URL"
 assinado -em = `echo" $ requestSignature "|  openssl DGST -sha1 -hmac -binary` "$ secretKey"
 b64signed = `echo -n" $ assinado "| base64`

 auth_header = "Autorização: 11PATHS $ ApplicationId $ b64signed"
 date_header = "X-11Paths-Date: $ date"

 `resposta q = onda --header -N-s" $ auth_header "--header" $ date_header "" Servidor $ $ URL "`

 echo $ response

Se o emparelhamento for bem sucedido, o API de 
Latch retorna um JSON contendo usuário accountId  como mostrado abaixo: 

{"data":{"accountId":"3d86bXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX65dea"}}

Ao fornecer essas informações, você pode consultar a API de Latch para obter o status que o usuário estabelece pela App no ​​seu Smartphone ou Tablet.

  Data: 31/08/2015 13:55:54
 URL: /api/1.0/status/3d86bXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX65dea
 Pedido: GET \ n2015-08-31 13: 55: 54 \ n \ n / api / 1.0 / status / 3d86bXXXXXXXXXXXXXXXXXXX65dea
 Pedido de Assinatura: aPVc83HlPE0CPQz4jR5HJrU3Zyc =
 Cabeçalho: Autorização: 11PATHS WFqRXXXXXXXXXXXXZORO aPVc83HlPE0CPQz4jR5HJrU3Zyc =
 Cabeçalho: X-11Paths-Data: 31/08/2015 13:55:54

Veja como funciona, a programação do sketch de Arduino que compreende basicamente:
  • Conexão a rede sem fio WiFi
  • Obtenção da hora atual
  • Assinatura com HMAC-SHA1
  • Codificação em Base64
  • Pedido HTTP GET

Sketch Arduino

Embora possa parecer baixa complexidade, a implementação exige grande parte dos 2 Kbytes de memória Arduino UNO (ATmega328P), tornando-se necessário o uso regularmente as instalações PROGMEM, F(), strcpy_P(), etc. fornecendo biblioteca AVR libc (AVR / pgmspace.h); imperativo para economizar o uso da SRAM utilizando, sempre que possível, a memória flash (programa de 32 Kbytes) de memória para armazenar todos os dados suscetíveis de este: por exemplo, matrizes de caracteres permanecem inalteradas (constante). Na verdade, o uso de recursos não-ortodoxas, mas é inevitável para economizar memória, independentemente de métodos, mas o consumo de memória alta elegante como Vendedor aJson a Matter Interactive Lab para análise de resposta Latch, a escolha de executar uma simples comparando strings. 

Espdunio 


biblioteca espduino.h fornece uma interface simples de comunicação com módulo ESP82688. Só é necessário para iniciar uma instância ESP com valores da porta serial hardware, porta software para a transmissão de mensagens de depuração de série, e a linha de conexão CH_PD para iniciar o módulo. Uma vez instanciado função wifiConnect com o SSID e senha da rede WiFi que você conecta. Os detalhes deste processo são postados pela porta de depuração para obter informações. 

A API RESTful é implementada na biblioteca rest.h também fácil de usar. Você apenas tem que instanciar RESTO indicado SFE, e iniciá-lo com os valores do servidor de conexão (nome FQDN ou endereço IP), porta TCP e se há ou não a criptografia SSL. 


  // Github.com/tuanpmt/espduino (c) Tuan PM 
 #include biblioteca "espduino.h" // ESP8266 Wifi para usando o protocolo SLIP via porta serial
 #include "rest.h" // código para ESP8266 pode encontrar aqui github.com/tuanpmt/esp_bridge

 // Exemplo Definindo ESP
 ESP (* Fluxo de série, Stream * debug, chip_pd int);  // Esp (HardwareSerial, SoftwareSerial, CH_PD)
 wifiConnect void (SSID const char *, char const * senha);

 // Definindo RESTO instância
 DESCANSO (ESP * e);
 boolean começar (const char * host, porta uint16_t, segurança boolean);

 Setembro // cabeçalho Content-Type
 vazio setHeader (const caractere valor *);  // SetHeaer ("Header1: value1 \ r \ nHeader2: value2 \ r \ n");

 // Obter resposta DESCANSO
 get void (const char * path);
 uint16_t getResponse (char * dados, uint16_t maxLen);

Após a inicialização, você pode usar as funções SetHeader para definir cabeçalhos HTTP personalizados, começa a fazer um pedido GET, e getResponse para obter a resposta. O tempo limite padrão configurável é de 5 segundos. 

TIME 

Para obter a data actual da biblioteca time.h, padrão  do Arduino 



  #include "sha1.h" // github.com/Cathedrow/Cryptosuite criptográfica suíte para Arduino
 
 Ambiente HMAC-SHA1 //
 uint8_t * de hash;

 initHmac void (* const uint8_t segredo, secretLength int);  // Key, e comprimento em bytes da chave
 virtual void write (uint8_t);
 usando Imprimir :: escrever;
A função initHmac é inicializado com o segredo localizado em uma matriz de 40 elementos do tipo uint8_t depois de carregar o pedido, o resultado da assinatura HMAC-SHA1 é armazenado em uma matriz de 20 elementos, também do tipo uint8_t. 

Base64 

A função de codificação Base64 é uma contribuição de Adam Rudd publicada no seu espaço GitHub; a sua utilização é muito simples: 

  #include "base64.h" github.com/adamvr/arduino-base64 // Copyright (C) 2013 Adam Rudd
 
 // Ambiente Base64
 int base64_encode (char * saída, entrada char *, int InputLen);




  # Site de configuração Nginx para o arranjo SSL
 servidor {
         SEU TCP PORT ouvir;
         server_name O nome do servidor ou o IP;
         SSL em;
         sites-enabled ssl_certificate / server.crt;
         sites-enabled ssl_certificate_key / server.key;
         error_page 497 https: // $ host: $ server_port $ request_uri;

         localização / {
                 https://latch.elevenpaths.com:443/$request_uri 301 retorno;
         }
         localização / api / {
                 proxy_set_header Content-Type "";
                 PROXY_PASS https://latch.elevenpaths.com:443;
         }
         location = / X-11Paths-Date {
                 proxy_http_version 1,0;
                 PROXY_PASS http: // localhost: 9000;
         }
 }

Aproveitando a flexibilidade proporcionada por ter um sistema intermediário pelo pedido de configuração último bloco /X-11Paths-Date para um servidor local (httpd) que com um script CGI executado em perl que retorna a data e a hora atual, no formato exigido, evitando assim ter que instanciar novo REST, fazer outro pedido e analisar a resposta.


  #! / Usr / bin / perl -wT
 use strict;
 usar advertências;

 use POSIX qw (strftime);

 meus $ date11paths;
 my $ dateRFC2616;

 $ Date11paths = POSIX :: strftime ("% Y-% m-% d% H:% M:% S", gmtime);
 $ DateRFC2616 = POSIX :: strftime ("% a% d% b% Y% H:% S UTC:% M" gmtime);

 print "Servidor: SSLarrangement / 0,1 \ n";
 print "Data: $ dateRFC2616 \ n";
 print "Content-Length: 19 \ n";
 print "Content-type: text / plain \ r \ n \ r \ n";

 print "$ date11paths";

Tudo isso código estará disponível no Github. 

E, finalmente, vamos ver no capítulo final, como conectar tudo no mundo real. 


Jorge Rivera
jorge.rivera@11paths.com

traduzido por Leandro Bennaton
leandro.bennaton@11paths.com