Wireless Sensor Network 2019
1.0.0
Crie uma rede de sensores sem fio Wi-Fi / Miwi (15.4) / Lorawan 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
Interface da web independente do dispositivo para visualizar facilmente dados
Exibição da topologia de malha Miwi na GUI do Monitor WSN
Fogando de dados no arquivo CSV
Dispositivos operados por bateria
Mostrar diferentes tecnologias abordando a mesma tarefa
Smart seguro conectado
No Masters 2019, 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 Wi-Fi da AWS IoT precisarão se conectar ao CORE AWS IoT 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.
Lora significa Longa Fanging. 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. Algumas das aplicações que podem ser realizadas usando o LORA são gerenciamento inteligente de estacionamento e veículos, instalações e gerenciamento de infraestrutura, detecção e gerenciamento de incêndio, gerenciamento de resíduos, automação residencial para IoT, permite que aparelhos inteligentes, agricultura inteligente e gerenciamento de gado, monitoramento de temperatura e umidade, sensores de nível de água e controle de irrigação.
A temperatura 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. Os usuários que são novos no desenvolvimento de aplicativos usando Lorawan podem encontrar uma visão geral da arquitetura do sistema de Lorawan aqui.
Verifique se o gateway está conectado ao servidor de rede das coisas - etapas mencionadas aqui
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
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.
Para ativar a medição da tensão da bateria, verifique se o PA15 está em curto para GND. O saltador de E/S e o jumper MCU devem ser
Conecte o ATSAMR34-XPRO ao PC usando um cabo micro USB através da fonte de alimentação EDBG. O ATSAMR34-XPRO enumerará como uma porta COM. Usando um aplicativo de terminal @ baudrate 115200, dados - 8 bits, paridade - nenhum, pare - 1 bit e controle de fluxo - nenhuma configuração permitirá que um usuário monitore as informações do exemplo do firmware
Abra o projeto - APPS_ENDDEVICE_DEMO usando o Atmel Studio Configure o Deveui, AppKey e Appeui usando o arquivo conf_app.h disponível no diretório a seguir - /src /config
Se o aplicativo desenvolvido estiver usando bandas de Na/Au, o uso pode escolher uma sub -banda em que o gateway está ouvindo. Como a banda NA/Au permite até 64 canais de uplink. Gateways baratos populares aqui em apenas 8 canais, portanto, é necessária uma opção de sub -banda. O Gateway das Coisas ouve na Subband - 2 para NA chamado US902, de acordo com os parâmetros regionais de Lorawan. Para a demonstração, usamos a metodologia OTAA (sobre a ativação do ar) em Lorawan
Programe a demonstração usando a opção "Start Without Depurging" no Atmel Studio. Após a programação da demonstração, o dispositivo final (ATSAMR34-XPRO) tentará ingressar no Lorawan Network Server (The Things Network). Se o gateway estiver online e conectado ao servidor de rede do Things, a solicitação de ingresso resultará em uma aceitação imediata.
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, vá para aplicativos -> xxxx -> Formatos de carga útil xxxx denota o nome do aplicativo dos usuários, vá para a seção Decoder 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 na janela do terminal e no console de rede de coisas
As transmissões subsequentes de sensores acontecem a cada 15 minutos
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 da demonstração de salas espalhadas por um enorme resort foi monitorada usando a topologia da rede de malha Miwi.
Um aplicativo típico de malha MIWI pode ser desenvolvido com 3 componentes.
O coordenador e o coordenador do PAN é do tipo FFD (dispositivo de função completo) e são capazes de rotear os pacotes que os dispositivos finais podem ser FFD (dispositivo de função completa) / RFD (dispositivo de função reduzido). 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 nas baterias) foi usado para demonstrar as vantagens da rede de malha Miwi, como baixa potência, auto -cura etc.
O nó pan-coordenador está conectado à placa SAMA5D2 XPRO e possui uma conectividade WILC3000 para Wi-Fi (Internet). Essa combinação de dispositivos é chamada de ponte Miwi nesta demonstração. Os roteadores e dispositivos finais enviam dados periódicos para o pan-coordenador. O SAMA5D2 lê os dados do pan-coordenador e envia o mesmo para a instância do AWS EC2. A instância do AWS EC2 envia os dados recebidos para a ferramenta WSN Monitor e para o servidor da web. A ferramenta de monitor WSN mostra a topologia de malha formada a partir dos dados recebidos do roteador, nós do sensor e coordenador pan. O monitor WSN também pode ser usado para monitorar a rede MIWI.
Hardware
Software
At91Sama5D27 no Linux
Módulos e firmware ATWILC3000
$ /root do pacote Buildroot. O firmware é adicionado em $ /lib/firmware/mchp .Serviços de instância do AWS Cloud EC2
Ferramenta de monitor WSN
Procedimento passo a passo para replicar a demonstração miwi sama5d2 linux configuração
Traga a interface WiFi e a conexão WiFi
$ root como nome de usuário.$/root/mchp/ PASTER CONTREM o módulo Driver WILC3000.$/root/mchp contém o módulo de driver WILC3000.$ /lib/firmwae/mchp/wilc1000_wifi_firmware.bin$ vi para credenciais do roteador.Configuração da instância do AWS Cloud EC2, utilizamos os serviços EC2 (Amazon Elastic Compute Cloud) para esta demonstração. A instância do EC2 hospeda os dois servidores TCP para a ferramenta Miwi Network Bridge e WSN Monitor. A instância do AWS EC2 para hospedar o servidor Python requer máquina virtual do AMI Linux. A instância do Amazon EC2 fornecerá a máquina Linux virtual. O processo é fácil e direto quando você tiver sua conta AWS pronta.
nohup python miwi_wsn_server_4.py & cd iot nohup python iot_publish_2.py &Configuração do Miwi
Para a demonstração do MIWI WSN, programe-coordenador de programa com arquivo de projeto disponível em/miwi/samr30/pan_cord_mod. Programe os nós do coordenador com o arquivo de projeto disponível em/miwi/samr30/cord_mod1 e programe a placa do sensor com o arquivo de projeto disponível em/miwi/samr30/sensor_mod1.
Ferramenta de monitor WSN
A ferramenta de monitor WSN é uma ferramenta proprietária de microchip para 802.15.4 Monitor de rede e contorno. Nesta ferramenta, a conexão da rede MIWI com os respectivos nós será exibida. O pedágio do WSN Monitor também exibe a temperatura, o RSSI Vlaue dos nós da rede e a notificação de energia da bateria. Para conectar -se ao servidor EC2, é necessário o endereço IP público da instância do EC2. O endereço IP público da instância do EC2 está disponível na página da instância do EC2, como mencionado acima. O número da porta para a conexão da ferramenta de monitor WSN é de $ 8080 assim que a ferramenta de monitor WSN conectada, o servidor EC2 encaminhará o pacote que é recebido da rede Miwi Clinet.
Após a conexão bem -sucedida com o servidor EC2, o WSN Monitor começa a receber os dados e exibições da rede MIWI.
