Wireless Sensor Network
1.0.0
Crie uma rede de sensores sem fio Wi-Fi / Miwi (15.4) / Lora para monitorar as temperaturas que cobrem uma área ampla como um hotel ou uma planta.
Estudo de caso: Monitoramento de temperatura das salas de aula durante a conferência Microchip Masters, realizada no JW Marriot Desert Ridge, AZ
Veja a demonstração (viva apenas durante a conferência de Masters)
Monitora dados do sensor (temperatura, nível de bateria e RSSI)
Abrange 34-35 locais em uma vasta área de aprox. 1 km2
Comunicação segura com a AWS IoT para Wi-Fi e Miwi
Interface da web independente do dispositivo para visualizar facilmente dados
Fogando de dados no arquivo CSV
Dispositivos operados por bateria
Mostrar diferentes tecnologias abordando a mesma tarefa
Smart seguro conectado
No Masters 2018, monitoramos as temperaturas em toda a conferência usando 3 redes diferentes relatando simultaneamente um único painel de facilidade e facilmente acessível on-line para visualizar as informações de 34 locais. Além disso, para a implementação da LORA, adicionamos um nó de campo de golfe que é colocado fora do hotel para mostrar recursos de longo alcance da Lora.
O sistema está comprometido principalmente por duas partes:
A mesma demonstração e funcionalidade podem ser alcançadas usando qualquer uma das três tecnologias. No entanto, cada tecnologia tem seus próprios pontos fortes e desvantagens. Fornecemos essa explicação e o código de suporte para ajudar os clientes de microchip a escolher a tecnologia que se adapta melhor ao seu aplicativo.
Nota: O código aqui é fornecido como está e não foi testado quanto à qualidade da produção. Ele tem alguns problemas de conhecimento na seção de nuvem que mencionamos mais tarde. Você é totalmente responsável por testar e adaptar o código em seu próprio sistema.
O usuário precisa de um portal para visualizar os dados. Para criar uma exibição independente da plataforma que não requer instalação ou senha, optamos por exibir os dados em uma página da web html + javascript .
A página da Web é apenas uma ferramenta que recupera os dados de um ponto final de dados, pode ser substituído por um aplicativo telefônico ou adicionado a uma visualização por usuário em um produto final.
Para tornar nosso aplicativo modular e independente na implementação do front -end, seja um site ou um aplicativo móvel. Decidimos implementar uma API RESTful usando frasco
Os dados são retornados como objeto JSON do endpoint e podem ser vistos aqui.
Para os fins desta demonstração, usamos a instância do Amazon EC2 Ubuntu Virtual Machine (já que já estávamos usando o AWS IoT Core) para gerenciar facilmente todos os nossos serviços na mesma interface.
No entanto, o mesmo poderia ser alcançado com o Digitalocean como uma alternativa. Em um aplicativo comercial do mundo real, você provavelmente terá seu próprio servidor e esta etapa não é ingênua.
Para o bem desta demonstração, ao usar Wi-Fi ou 802.15.4 (MIWI), decidimos ir com o Amazon AWS IoT Core .
Ao usar a Lora & Lorawan , você deve se registrar e usar um dos provedores de serviços de Lorawan, como ** The Things Network (TTN) ** ou Senet.
Para os fins desta demonstração, fomos com o TTN. Também tivemos sucesso na conversão dessa demonstração para a Senet na Índia, mas isso está fora do escopo desta página.
O design e a tecnologia usados nos nós finais podem ser:
Ao escolher os nós finais que o usuário precisa considerar:
Cada um desses pontos é discutido nas seções do nó final abaixo.
O diagrama acima resume o sistema. Os nós finais estão no modo de suspensão até um determinado momento em que ele acorda, envia os dados para o gateway e depois volta a dormir.
Lora e Miwi precisam de um gateway dedicado para a ponte de Lora/Miwi para Wi-Fi antes de enviar os dados para a nuvem. O Wi-Fi tem uma vantagem de que não precisa de um gateway dedicado se já houver cobertura Wi-Fi, o que é o caso do local do hotel.
Os dados são enviados para o fornecedor do servidor de nuvem. AWS IoT para Wi-Fi e Miwi e Ttn para Lora. Nosso aplicativo de frasco obterá os dados e fornecerá um ponto final de dados modular que nossa página da web pode apresentar. O aplicativo Flask e a interface da Web estão colocando em nossa instância do AWS EC2.
O usuário pode acessar nossa página da Web a partir de qualquer dispositivo em qualquer lugar que ele desejar.
Nesta seção, discutimos como configurar a parte da nuvem da demonstração.
Utilizamos dois serviços da AWS nesta demonstração, a AWS EC2 como uma plataforma de hospedagem de servidor. e AWS IoT para Wi-Fi e Miwi Final nós MQTT Broker.
Para hospedar seu servidor, você precisará criar uma instância do Virtual Machine EC2 antes de implantar o Apache nele. O processo é fácil e direto quando você tiver sua conta AWS pronta.
Para um guia passo a passo, siga o guia da Amazon aqui.
Para a nossa demonstração, fomos de graça este tipo de instância: Ubuntu Server 16.04 LTS Free Tier (atualizado para médio durante a conferência para acomodar a demanda)
Na configuração de segurança, permita o acesso ao tráfego HTTP, HTTPS e SSH de entrada e saída. Você também pode ajustar a configuração de segurança ao seu gosto. Além disso, mantenha a chave privada para acessar a instância segura para que você possa pressionar seus dados e controlar o servidor.
Para acessar seu servidor, siga os guias disponíveis no site da Amazon aqui. Os nós finais Wi-Fi e Miwi da AWS IoT precisarão se conectar ao AWS IoT Core para enviar dados do sensor sobre o MQTT.
Para configurar a AWS IoT Cloud, você pode seguir o Guia do Usuário do AWS Zero Touch Provisioing Kit Project (da instalação da Seção 2 do software até a Seção 5 AWS IoT IoT Just-in Time Setup Setup) precisa criar a função Lambda, a regra da AWS IoT e a função IAM para a provisão da AWS.
O AWS Zero Touch Provisioing Kit é um projeto sobre o provisionamento do kit de provisionamento seguro de toque zero para se conectar e se comunicar com o serviço IoT da Amazon Web Services (AWS). O Guia do Usuário do Projeto Kit de Provisio de Touch AWS Zero pode ser encontrado abaixo: http://microchipdeveloper.com/iot:ztpk
Depois de ter sua instância do EC2 em funcionamento após seguir as etapas acima, você precisará instalar o Apache e apontá -lo para hospedar nossa página da web e o aplicativo Flask.
A instância do EC2 já vem com o Python, certifique -se de que você precisaremos mais tarde. $ sudo apt-get update e sudo apt-get install python3-pip
Primeiro, instale o Flask na sua instância EC2: $ pip3 install Flask
Copie o arquivo "Server/wsn_server.py" para a instância do EC2.
Agora, vamos descrever partes do código que você deseja modificar e adaptar ao seu aplicativo:
Você encontrará dicionários denominados "USMastersNodelocation" e "IndiamastersNodelocation". O motivo é que queríamos que nossas placas fossem reutilizadas para o local da demonstração múltipla sem alterar o código na placa, por isso damos a cada nó um número e usará este dicionário para mapear o nó para a sala que ele colocou no interior.
Por exemplo, o Node4 durante os mestres dos EUA em "Desert Suite 4". Então enviamos o mesmo nó para a Índia e o colocamos na sala "Dominion". Dessa forma, o mesmo nó, com o mesmo código pode ser usado para um local diferente, alterando o aplicativo de frasco sem a necessidade de programar físico o dispositivo.
Atualizar o código fisicamente na placa nem sempre é conveniente no campo. Incentivamos você a pensar em métodos como esse e planejar com antecedência para evitar a atualização do Conselho FW.
#our Rooms database
USMastersNodeLocation = {
"Node1" : "Desert Suite 1" ,
"Node2" : "Desert Suite 2" ,
"Node3" : "Desert Suite 3" ,
"Node4" : "Desert Suite 4" ,
"Node5" : "Desert Suite 5" ,
"Node6" : "Desert Suite 6" ,
"Node7" : "Desert Suite 7" ,
"Node8" : "Desert Suite 8" ,
"Node9" : "Pinnacle Peak 1" ,
"Node10" : "Pinnacle Peak 2" ,
"Node11" : "Pinnacle Peak 3" ,
"Node12" : "Wildflower A" ,
"Node13" : "Wildflower B" ,
"Node14" : "Wildflower C" ,
"Node15" : "Grand Canyon 1" ,
"Node16" : "Grand Canyon 2" ,
"Node17" : "Grand Canyon 3" ,
"Node18" : "Grand Canyon 4" ,
"Node19" : "Grand Canyon 5" ,
"Node20" : "Grand Canyon 9" ,
"Node21" : "Grand Canyon 10" ,
"Node22" : "Grand Canyon 11" ,
"Node23" : "Grand Canyon 12" ,
"Node24" : "Grand Sonoran A" ,
"Node25" : "Grand Sonoran B" ,
"Node26" : "Grand Sonoran C" ,
"Node27" : "Grand Sonoran D" ,
"Node28" : "Grand Sonoran H" ,
"Node29" : "Grand Sonoran I" ,
"Node30" : "Grand Sonoran J" ,
"Node31" : "Grand Sonoran K" ,
"Node32" : "ATE / Grand Canyon 6" ,
"Node33" : "Cyber Cafe / Grand Sonoran G" ,
"Node34" : "Grand Saguaro East/West" ,
"Node35" : "Golf course"
}Armazenamos os dados que recebemos em um arquivo CSV. A localização e o nome do arquivo são especificados na linha 141-143.
###################################
###### Files to store data ########
###################################
wifiFile = open ( '/home/c43071/WSN/wifiData.csv' , 'a' )
miwiFile = open ( '/home/c43071/WSN/miwiData.csv' , 'a' )
loraFile = open ( '/home/c43071/WSN/loraData.csv' , 'a' )
WiFiWriter = csv . writer ( wifiFile )
MiWiWriter = csv . writer ( miwiFile )
LoRaWriter = csv . writer ( loraFile )Para obter notificações do nó final, o aplicativo precisa se inscrever no AWS IoT Core e TTN Servers (ou qualquer servidor que você escolher)
Utilizamos o código Pythond publicly para a AWS IoT. Para usá -lo, vá para o Amazon Github Repo aqui.
Nosso código pode ser usado como é se você substituir o caminho dos certificados pelo seu caminho de certificado.
# For certificate based connection
myMQTTClient = AWSIoTMQTTClient ( "WSNClientID" )
# For TLS mutual authentication with TLS ALPN extension
myMQTTClient . configureEndpoint ( "a3adakhi3icyv9.iot.us-west-2.amazonaws.com" , 443 )
myMQTTClient . configureCredentials ( "/home/c43071/WSN/VeriSign.pem" , "/home/c43071/WSN/WSN_BE_private.pem" , "/home/c43071/WSN/WSN_BE_certificate.pem" )
myMQTTClient . configureOfflinePublishQueueing ( - 1 ) # Infinite offline Publish queueing
myMQTTClient . configureDrainingFrequency ( 2 ) # Draining: 2 Hz
myMQTTClient . configureConnectDisconnectTimeout ( 10 ) # 10 sec
myMQTTClient . configureMQTTOperationTimeout ( 5 ) # 5 sec
myMQTTClient . connect ()O código espera que os tópicos sejam conhecidos e um tópico por tecnologia. O usuário pode usar tópicos diferentes com acesso diferente, se desejar.
myMQTTClient . subscribe ( "/Microchip/WSN_Demo/WiFi" , 1 , WiFiCallback )
myMQTTClient . subscribe ( "/Microchip/WSN_Demo/MiWi" , 1 , MiWiCallback ) O código espera um objeto JSON com o formato: {'nodeID': "Node1", 'Battery': "4.99V", 'Temperature': 81.46, 'RSSI': -55}
A rede de coisas não requer autenticação mútua ou certificados para se conectar como a AWS; em vez disso, eles confiam no nome de usuário e na senha. Portanto, mostramos o caso como conectar -se ao servidor usando o pacote "Flask_mqtt".
from flask_mqtt import Mqtt
app . config [ 'MQTT_BROKER_URL' ] = 'us-west.thethings.network'
app . config [ 'MQTT_BROKER_PORT' ] = 1883
app . config [ 'MQTT_USERNAME' ] = 'jwmarriottdesertridge'
app . config [ 'MQTT_PASSWORD' ] = ''
app . config [ 'MQTT_REFRESH_TIME' ] = 1.0 # refresh time in seconds
mqtt = Mqtt ( app )
@ mqtt . on_connect ()
def handle_connect ( client , userdata , flags , rc ):
print ( "MQTT connected!!! r n " )
mqtt . subscribe ( 'jwmarriottdesertridge/devices/+/up' )
@ mqtt . on_message ()
def handle_mqtt_message ( client , userdata , message ):Você notará que a carga útil da mensagem para Lora é um pouco diferente do Wi-Fi e Miwi, isso se deve ao TTN Gateway adicionar algumas informações à carga útil do nó final e, devido a tentar minimizar a carga de pagamento o máximo possível para diminuir a energia usada e aumentar a eficácia. Consulte a seção Lora abaixo.
###Apache
Há uma infinidade de tutoriais e conteúdo do Apache por aí, apenas mencionamos os desvios aqui.
Primeiro, obtenha Apache e WSGI para Flask: sudo apt-get install apache2 libapache2-mod-wsgi-py3
Crie um arquivo wsgi: vi wsn_demo.wsgi
Coloque isso no arquivo acima:
import sys
sys . path . insert ( 0 , '/var/www/html/WSN' ) Crie um symlink para que o diretório do projeto apareça em/var/www/html: $ sudo ln -sT ~/WSN /var/www/html/WSN
Ativar WSGI: sudo a2enmod wsgi
Configure o Apache (você precisará para sudo para editar o arquivo) $ sudo vi /etc/apache2/sites-enabled/000-default.conf
Criaremos 2 host virtual, um para o ponto final de dados e outro para o site.
Linha 9 e 49 abaixo indicam o nome do seu site. A linha 14 tem o local do arquivo WSGI.
Cole isso em "000-default.conf" depois de fazer as modificações do host, como mencionado acima:
< VirtualHost *:80 >
# The ServerName directive sets the request scheme, hostname and port that
# the server uses to identify itself. This is used when creating
# redirection URLs. In the context of virtual hosts, the ServerName
# specifies what hostname must appear in the request's Host: header to
# match this virtual host. For the default virtual host (this file) this
# value is not decisive as it is used as a last resort host regardless.
# However, you must set it for any further virtual host explicitly.
ServerName demo2.microchip.com
ServerAdmin webmaster@localhost
DocumentRoot /var/www/html
WSGIDaemonProcess WSN threads=5
WSGIScriptAlias / /var/www/html/WSN/wsn_demo.wsgi
< Directory WSN >
WSGIProcessGroup WSN
WSGIApplicationGroup %{GLOBAL}
Order deny,allow
Allow from all
</ Directory >
# Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
# error, crit, alert, emerg.
# It is also possible to configure the loglevel for particular
# modules, e.g.
#LogLevel info ssl:warn
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
# For most configuration files from conf-available/, which are
# enabled or disabled at a global level, it is possible to
# include a line for only one particular virtual host. For example the
# following line enables the CGI configuration for this host only
# after it has been globally disabled with "a2disconf".
#Include conf-available/serve-cgi-bin.conf
</ VirtualHost >
< VirtualHost *:80 >
# The ServerName directive sets the request scheme, hostname and port that
# the server uses to identify itself. This is used when creating
# redirection URLs. In the context of virtual hosts, the ServerName
# specifies what hostname must appear in the request's Host: header to
# match this virtual host. For the default virtual host (this file) this
# value is not decisive as it is used as a last resort host regardless.
# However, you must set it for any further virtual host explicitly.
ServerName demo.microchip.com
ServerAdmin webmaster@localhost
DocumentRoot /var/www/Masters
DirectoryIndex index.html
# Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
# error, crit, alert, emerg.
# It is also possible to configure the loglevel for particular
# modules, e.g.
#LogLevel info ssl:warn
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
# For most configuration files from conf-available/, which are
# enabled or disabled at a global level, it is possible to
# include a line for only one particular virtual host. For example the
# following line enables the CGI configuration for this host only
# after it has been globally disabled with "a2disconf".
#Include conf-available/serve-cgi-bin.conf
</ VirtualHost > Reinicie o servidor: $ sudo apachectl restart
Agora você precisa fazer uma entrada DNS que mapeará de "Demo.microchip.com" & "Demo2.Microchip.com" para o endereço IP público da instância do EC2.
Quando estiver pronto, vá em frente e veja seus dados em um link semelhante a: http://demo2.microchip.com/wsn/data/lora/
E o site será Similr para: (dependendo de como você configurou o Apache e onde você coloca seus arquivos html): http://demo.microchip.com/wsn/masters/
Quando você inspeciona as páginas HTML que fornecemos em "Server US IoT Network IoT Network"
O arquivo importante é "scripts.js" que lêem os dados de nossos pontos de extremidade de dados acima.
O restante é apenas arquivos HTML que contêm uma tabela e arquivos SVG para o mapa de localização.
Nesta seção, descrevemos as etapas necessárias para começar a enviar dados do sensor para a nuvem usando cada tecnologia respectiva.
Razões que você pode querer escolher Wi-Fi como seu nó final:
** Vantagens do wifi **
Razões que tornam o Wi-Fi uma opção menos ideal:
A placa Wi-Fi dorme por um período de tempo configurável. Quando acorda, ele verifica se a leitura do sensor mudou desde o último relatado à nuvem. Se optar por atualizar a leitura, ele se conectará ao módulo Wi-Fi e autenticará com a AWS Cloud usando o chip Crypto-Auth (ECC508) e enviará os valores atualizados.
A placa precisa ser provisada pela primeira vez apenas antes de poder ser usada, examinamos isso abaixo.
Para a demonstração, usamos o sensor IoT Bord, que contém um MCU (SAML21) e um módulo Wi-Fi Microchip (ATWINC1500) e outros sensores.
Para mais informações sobre o HW, vá para esta página aqui.
A placa não está disponível para compra no momento @Microchip Direct. Foi distribuído aos participantes da conferência de Masters gratuitamente e será adicionado posteriormente para a opção de compra. Nesse meio tempo, você pode fazer o mesmo usando o kit de toque zero da AWS.
Para piscar o firmware para o quadro, analise as opções aqui.
Por favor, vá até esta página para instalar as ferramentas necessárias.
Agora. Se você quiser usar o Wi-Fi, as etapas são assim:
O primeiro passo é coberto na seção de nuvem. Você também pode seguir em frente para o AWS.amazon.com e seguir o guia, caso eles mudaram as etapas. Abordaremos as 2ª e 3ª etapas aqui.
O dispositivo ECC608 é o Valut que protege a identidade do seu dispositivo e se autentica com a nuvem da AWS.
Para provisionar seu dispositivo ECC608, siga as etapas aqui.
Depois de terminar as etapas acima, seu ECC608 é provisionado. A parte restante é armazenar o certificado de dispositivo no WINC1500.
Isso pode ser feito programaticamente do lado do aplicativo ligando para: m2m_ssl_send_certs_to_winc O acima é adequado para produção. Uma alternativa é usando a ferramenta neste guia.
Uma vez que o ECC608 e o WINC1500 estiverem provisionados. Você pode finalmente piscar a placa com o aplicativo real.
O exemplo do aplicativo na pasta Wi-Fi contém código de referência para fazê-lo.
Existem projetos lá:
Você pode alterar o AP SSID e a senha para a qual deseja conectar nas linhas 61/63 em main.h
O nome do nó está na linha 73, no main.h
O SAML21 vai dormir e acorda na interrupção do RTC. O MCU irá dormir após uma chamada para: system_sleep(); e acorda quando a interrupção do RTC é recebida. Para controlar a duração da interrupção do RTC, configure a contagem na função "Configure_RTC_Count" no RTC.C ,, A duração do sono depende da frequência com que você deseja atualizar os dados e seu orçamento de energia.
Você deve inserir o ID do cliente MQTT para ser semelhante ao ID do assunto no certificado do seu dispositivo. Digite o ID do cliente na variável "GAWSMQTTCLIENTID" na linha 95 de "winc15x0.c"
É praticamente isso, agora vá para o arquivo main.c, leia a função principal e familiarize -se com ele e, quando estiver pronto, construa e pisque o SAML21 com o código.
Se você estiver conectado ao teste da AWS, assinando o tópico Wi-Fi mencionado acima (/microchip/wsn_demo/wifi), verá uma nova mensagem recebida assim que a placa executar.
INTRODUÇÃO Lora significa Longa Ftange. Lorawan significa redes de área de longo alcance. Lorawan é a rede na qual Lora opera. O Lorawan é um protocolo de camada de controle de acesso à mídia (MAC), mas principalmente é um protocolo de camada de rede para gerenciar a comunicação entre os gateways LPWAN e os dispositivos de nó final como um protocolo de roteamento, mantido pela Lora Alliance. Versão 1.0 da especificação de Lorawan Alguns dos aplicativos que podem ser realizados usando a LORA são estacionamento inteligente e gerenciamento de veículos, instalações e gerenciamento de infraestrutura, detecção e gerenciamento de incêndio, gerenciamento de resíduos, automação doméstica para IoT permite eletrônicos inteligentes, agricultura inteligente e gerenciamento de givestock, temperatura e monitoramento de umidade, sensores de nível de água e controle de irrigação.
Vantagens de Lorawan
A temperatura de introdução da demonstração das salas espalhadas por um enorme resort foi monitorada usando a Lora. Um aplicativo LORA típico pode ser desenvolvido com 4 componentes finais, gateway, servidor de rede e servidor de aplicativos. O dispositivo final com sensor de temperatura (em execução nas baterias) foi usado para demonstrar as vantagens de Lorawan, como baixa potência, segurança e longo alcance.
Hardware
Software
Procedimento passo a passo para replicar a demonstração
Encontre seu arquivo variant.cpp no pacote da placa Sodaq na instalação do Arduino. Meu arquivo variant.cpp estava localizado neste diretório C: Users cxxxx appdata local arduino15 packages sodaq hardware samd 1.6.18 variantes sodaq_explorer. Dependendo da sua instalação e versão do Arduino, pode ser um pouco diferente.
Abra o arquivo variant.cpp com qualquer editor e faça a seguinte adição: Encontre no arquivo, a tabela com este nome: const Pindescription g_apIndescription [] = Após a última linha na tabela, adicione o seguinte: // 48 vbat {Portb, 5, pio_analog, pin_attr_analog, adc_hanNEL13, não_on_on_on_on_nalog, notwin, não, nomatbat {portb, 5, não. // vbat Quando o usuário é feito com as alterações no arquivo, o final da tabela deve se parecer com o seguinte: // Botão 47 {Porta, 14, pio_output, pin_attr_digital, no_adc_channel, não_on_pwm, não_on_timer, externo_int_14, // button_pwm, não_timer {portb}, // button_pwm, portb, //botão 48 VB {NOTB}, // Botão 48 VB: Pin_attr_analog, adc_channel13, não_on_pwm, não_on_timer, extern_int_none}, // vbat
O usuário pode então adicionar a seguinte linha, #Define VBAT_MEUSE (48U) na variante do arquivo.h no mesmo caminho que o variant.cpp ou o usuário provavelmente poderia apenas adicionar #define vbat_measure 48 no esboço principal. Em seguida, salve os arquivos.
Em seguida, o usuário pode ler a tensão da bateria (MV) com este código:
'#define ADC_AREF 3.3f'
'#define BATVOLT_R1 4.7f'
'#define BATVOLT_R2 10.0f'
'#define VBAT_MEASURE 48'
pinMode(VBAT_MEASURE, INPUT);
uint16_t getBatteryVoltage()
{
pinMode(VBAT_MEASURE, INPUT);
uint16_t voltage = (uint16_t)((ADC_AREF / 1.023) * (BATVOLT_R1 + BATVOLT_R2) / BATVOLT_R2 * (float)analogRead(VBAT_MEASURE));
return(voltage);
}
Dicas: Se a tensão relatada estiver um pouco desligada ou variável/barulhenta, o usuário poderá fazer uma média da leitura do ADC
O registro e o provisionamento do gateway que o dispositivo final permitirá que um usuário crie uma conta de servidor de rede, registre seu gateway e dispositivo final. Depois de criar/inscrever -se para uma conta, conecte seu gateway ao servidor de rede das coisas. Siga as etapas no link seguinte para registro de gateway
Depois que o gateway estiver online, "Crie um aplicativo" seguido de "Crie um novo dispositivo" para registrar o aplicativo e o dispositivo final no TTN ao criar o aplicativo e o dispositivo final no TTN. A seguir, são apresentadas as coisas a serem cuidadas ao criar EUI e chaves no TTN para este aplicativo. Escolha criar qualquer aplicativo EUI e Dev EUI automaticamente. A chave do aplicativo (16 bytes) deve ser AppKeyprefix + Dev EUI, que faz parte do código -fonte no Project JW_Marriot_Desert_Ridge Proj. NOTA: A chave do aplicativo pode ser qualquer coisa da escolha do usuário. A demonstração usa um método de cancatação para derivar a chave do aplicativo e não é obrigatório para os desenvolvedores de aplicativos usarem esse método. Por padrão, o appKeyPrefix é {0xff, 0Xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88}; Dev EUI pode ser modificado como destacado na figura
Depois que o dispositivo final é criado no console de rede e as alterações necessárias de código foram feitas no código -fonte do aplicativo para Deveui e Appeui. Usaremos o método OTAA de ingresso para nosso aplicativo.
Antes de programar o código -fonte para o SAMD21 na placa Sodaq, verifique no gerente do conselho que a versão 1.6.11 está instalada para suporte ao pacote da placa para placas Sodaq Xplorer.
Programe o kit Sodaq XPlorer usando o modo Bootloader. Bata redefinir duas vezes em sucessão rápida e programar o kit Sodaq Xplorer usando Arduino. O TTN possui um recurso chamado funções TTN que permite que os usuários alterem bytes, enviados pela rede de coisas, para campos legíveis por humanos. Para adicionar a API para esta demonstração, acesse aplicativos? Xxxx? Formatos de carga útil xxxx indica o nome do seu aplicativo escolhido
Vá para a seção do decodificador e salve a função do decodificador abaixo
function Decoder(bytes, port) {
var length = bytes.length;
if(length == 6){
var temperature = (bytes[0] <<8) | bytes[1];
var battery = (bytes[2] <<8) | bytes[3];
battery = battery/100 + "V";
var time = bytes[4] + ":" + ('0' + bytes[5].toString(10)).slice(-2);
return{
"temperature": temperature /100,
"battery": battery /// 100, // this operation now is done in earlier step
"time": time
};
}else
{
var result = "";
for (var i = 0; i < length; i++) {
result += String.fromCharCode(parseInt(bytes[i]));
}
return {
"msg": result,
};
}
}
Depois de configurar o decodificador e programar a placa com o código -fonte do aplicativo. Os dados do aplicativo devem começar a aparecer.
Introdução Miwi significa Microchip Wireless. O MIWI é um protocolo sem fio proprietário projetado pela tecnologia Microchip que usa pequenos rádios digitais de baixa potência com base no padrão IEEE 802.15.4 para redes de área pessoal sem fio (WPANs). Ele foi projetado para baixas taxas de transmissão de dados e curta distância, redes restritas de custo, como monitoramento e controle industrial, automação de residências e edifícios, controle remoto, sensores sem fio de baixa potência, controle de iluminação e leitura automatizada do medidor. O protocolo Miwi suporta três topologias de rede
Vantagens de Miwi
A temperatura de introdução de demonstração de salas espalhadas por um enorme resort foi monitorada usando a topologia da rede Miwi Star.
Um aplicativo MIWI típico pode ser desenvolvido com 2 componentes. Coordenador de pan e dispositivo final. Os dispositivos finais podem tipo FFD/RFD. Os dispositivos finais da RFD foram usados para os fins desta demonstração devido à capacidade de dormir. O dispositivo final com sensor de temperatura (em execução em baterias) foi usado para demonstrar as vantagens de
Hardware
Software
Informações genéricas O que é AWS IoT? A AWS IoT é uma plataforma de nuvem gerenciada que permite que os dispositivos conectados interajam com facilidade e segurança com aplicativos em nuvem e outros dispositivos. O que é AWS Lambda? O AWS Lambda é um serviço de computação que executa código em resposta a eventos e gerencia automaticamente os recursos de computação exigidos por esse código. Registro do dispositivo: “Jitr” acontece uma vez no início para cada nova função Lambda Função Lambda é uma maneira de automatizar a criação de coisas. A função lambda acionará quando um dispositivo desconhecido com CA conhecido conecta o resumo das coisas da função Lambda lidará com
Procedimento passo a passo para replicar a demonstração da MIWI
Crie uma conta da AWS
Configuração lambda para configuração Lambda Siga as etapas mencionadas na seção “v. AWS IOTJUST-HEMPER SCORMUP
Crie ecossistema de certificado para os fins desta demonstração, criamos nossa própria cadeia de confiança executa os scripts aqui para:
Os seguintes certificados serão gerados root-ca.crt/key signer-ca.crt/key
Registre nossa CA com a AWS IoT no último etapa CA Certificado foi gerado, a AWS exige que o usuário se registre e a ativasse para que ele possa acionar a função Lambda quando um dispositivo usando o CA se conecta a ele. Parte do registro exige que o usuário prove que o usuário tem a chave privada para a CA. Etapas para registro
Para realizar as etapas para o registro, o usuário precisa - configurar as credenciais da AWS da CLI abrem um prompt de comando navegar para “C: Arquivos de Programas Amazon Awscli” Tipo “AwSconfigure” Digite as informações do arquivo de credenciais da conta do usuário - Execute aws_register_signer.py
Provisão ECC608 Para provisionar o usuário do ECC608 precisa:
Gere um par de teclas públicas/privadas do dispositivo e crie uma CSR para certificado de dispositivo.
Abra a solução SAMR30 XPRO ECC no Atmel Studio 7, conecte a placa EDBG USB ATWINC1500-XPRO no ext1 e a placa XPRO ATCRYPTOAUTH-B ON EXT3 do ATSAMR30-XPRO Open Teraterm e estabelecerá o programa PUBLULHO e o Solution c para ATSAMR30-XPro e a Janela Terminal Will terão o Public.
Gerar certificado de dispositivo. Para gerar o certificado de dispositivo WINC:
Armazene os dados do certificado no WINC1500. Para armazenar os dados do certificado para WINC1500
Conecte -se ao AWS IOTCLOUD e publique em um nome de coisa
