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

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

segunda-feira, 2 de novembro de 2015

No post anterior, estudamos os detalhes técnicos da conexão entre o Arduino e o módulo de WiFi. Nesta edição, vamos ver como carregar o firmware necessário do módulo de WiFi para atender nossas necessidades.

Carregar o firmware do ESP8266

Para usar as bibliotecas espduino do Arduino e estabelecer a comunicação SLIP com o módulo ESP8266, é necessário substituir o firmware original do ESP8266 pelo que é fornecido como parte do espduino, chamado esp_bridge. Também Open Source sob a licença MIT, você pode encontrar o código fonte e documentação no espaço do GitHub.

Para carregar um novo firmware, o módulo de ESP8266 deve iniciar o modo de programação (Flash Mode). Para alcançar este objectivo deve corrigir GPIO-0 ao estado LOW durante a inicialização ou reinicio.

Descrição do pino do módulo de ESP-01

A conexão do módulo ESP8266 ao desktop para carregar o firmware se realiza por meio de um adaptador USB tipo FDTI, ou similar, que respeite a máxima tensão de 3.3 v (LVTTL).

Também é possível usar o próprio Arduino em modo USB-Serial modo bypass. Para conseguir isso deve impedir que o Atmega328p interfira. Podendo ser executado de três formas:
  • Extraindo-o da placa, se for possível.
  • Carregando-o como un sketch inocuo.
  • Colocando-o en estado de reset, levando a LOW sua entrada de RESET e conectando-a ao GND (recomendado).

Diferentes métodos de desativação do Atmega328p

Observe que os pinos 0 e 1 da placa Arduino que normalmente são RX e TX, respectivamente, agora estarão trocados, usando a conexão para o conversor USB-serial do Arduino bypass. Observe a conexão de cor amarela na imagem.


Conexão do Arduino UNO e módulo ESP-01 no modo de programação (Flash Mode)

Como parte do pacote de bibliotecas para espduino, podemos encontrar o firmware esp_bridge já compilado e pronto para ser carregado no módulo ESP8266. Esta dividido em dois arquivos: 0x00000.bin e 0x40000.bin, cujo nome indica o deslocamento (offset) do seu conteúdo no módulo de memória flash.

Para carregar o firmware há várias aplicações para seu computador, seja Windows, Mac OSX ou Linux, no site Eletrodragon lá é uma seção específica, onde você encontrará disponíveis para download.

Processo de carga do firmware com ESP FLASH DOWNLOAD TOOL V1.2
Depois de carregar o firmware esp_bridge, quando o módulo de ESP8266 está em funcionamento normal, a única maneira de se comunicar com ele será através das bibliotecas de espduino estabelece a conexão SLIP.

No seguinte post iremos estudar a API de Latch e finalmente como criar o sketch de Arduino.



Jorge Rivera
jorge.rivera@11paths.com

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

Insegurança na Internet das Coisas

segunda-feira, 26 de outubro de 2015

Nos últimos seis meses, a insegurança potencial no âmbito da Internet das Coisas (IoT) tem saído regularmente nas manchetes de notícias, de aviões hackeados, carros, ou monitores de bebês, a Smart TVs traiçoeiramente ouvindo e transmitindo conversas não criptografadas através da internet. Um relatório consultivo emitido em setembro pelo FBI indicou que a agência também tinham preocupações com as falhas de segurança inerentes à implementação da IoT e advertiu sobre a oportunidade potencial oferecida aos criminosos do espaço cibernético. Enquanto para muitos tal aviso possa parecer prematuro dada a atual penetração no mercado atual, a IoT está em um pico de expectativa e antecipação, essencial para que o conceito seja levado adiante. Nas empresas, a IoT é vista como uma parte integrante do programa para o desenvolvimento do modelo de negócio digital de hoje para a digitalização de toda a cadeia de valor e a adoção no espaço do consumidor da tecnologia vestível (Wearable), que está aumentando rapidamente. 

No entanto, avanços em computação de ponta, redes, big dataanalytics ainda são necessários para que esta tecnologia verdadeiramente disruptiva possa moldar o futuro; e embora a implementação generalizada possa demorar entre 5-10 anos, não abordar as falhas de segurança agora somente agravará o problema no mundo conectado da IoT.




Vulnerabilidades típicas da loT
Tal escopo garante que a Internet das coisas não deva ser pensada como apenas uma "Coisa" em si; trata-se de uma série de tecnologias integradas e apresentadas para fornecer aplicações específicas e vastamente diversificadas.  Entretanto, no âmbito da produção,  um ciclo de vida de desenvolvimento rápido está produzindo dispositivos que estão "sempre on-line" e que frequentemente possuem restrições inerentes às medidas de segurança devido ao tamanho e custo; uma pesquisa indicou que mais de 70% dos dispositivos de IoT normalmente utilizados contêm vulnerabilidades significativas. Por outro lado, manter a confiança do consumidor, regulando a quantidade e natureza dos dados a serem coletados e transmitidos, e também abordar características comportamentais do usuário final representam desafios complexos. Nesta fase incipiente do ciclo de vida, o foco na segurança é muitas vezes ponderado de forma desproporcionada no dispositivo final, esquecendo que este é um componente de um ecossistema maior que tem é tão forte quanto sua ligação mais fraca.

Implicações de segurança
Os métodos para subverter estas tecnologias vão depender tanto da maneira pela qual elas amadurecem, como da segurança que é implementada nos dispositivos mais frequentemente expostos. É preocupante que as primeiras indicações sejam que as lições dos últimos 20 anos sobre rede, aplicativos e nuvem tenham sido frequentemente esquecidas pelos vendedores de tecnologia, e não tenham sido ainda aprendidas pelos fabricantes que agora entram em um novo mercado. Ainda que a exposição ao risco de vetores de loT dê sinais de que vai permanecer baixa em curto prazo para a maioria das empresas, as avaliações de risco podem provar que são maiores do que se pensava. O aumento dos ataques DDoS reflexivos no segundo semestre de 2014 e a composição da botnet do "Lizard Stresser" já aponta para o efeito de uma IoT insegura sendo maliciosamente readaptada. Vazamento de informação não imprevistas do ecossistema estendido IoT também pode agravar o problema de agregação de dados tanto a partir de fontes de consumidores como de empresas, permitindo que os criminosos cibernéticos unam conjuntos de dados para uma ampla gama de objetivos maliciosos.



Mitigação e contramedidas
Por predefinição, deve ser dada maior prioridade ao conceito de segurança para evitar que as ameaças de segurança se agravem com o amadurecimento da IoT, e os adotantes devem estar alertas à integração da IoT em um ambiente menos maduro e vagamente regulamentado, ou depois sofrerão com os custos em espiral. Princípios fundamentais de segurança de dados, aplicativos, rede, sistemas e hardware permanecem aplicáveis, mas a complexidade é maior e as medidas devem ser mais cuidadosas para que não funcionem contra o usuário. 
A IoT será um movimento tecnológico de transformação e ruptura, mas traz um espectro de riscos que não afeta somente o departamento de TI.