IOT123 - ASSIMILATE SENSOR HUB: ICOS10 PERSONALIZAÇÃO WEBSEREVER: 11 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Os escravos ASSIMILATE SENSOR / ACTOR incorporam metadados que são usados para as visualizações de definição no Crouton. Esta construção adiciona um servidor web ao ESP8266 Master, serve alguns arquivos de configuração que podem ser modificados pelo usuário, então usa esses arquivos para redefinir as visualizações. Portanto, os nomes dos cartões do painel e a maioria das propriedades configuráveis podem ser alterados. Isso foi necessário, por exemplo o DHT11 publica as propriedades de Temperatura e Umidade: se um local tiver vários nós com sensores DHT11 separados, todos eles não podem ser chamados de Temperatura (Temp. Garagem, Temp. Pátio…). A restrição de comprimento de metadados definida pelo Barramento I2C (16 caracteres) não existe e valores mais ricos podem ser aplicados (até 64 caracteres).

A autenticação básica opcional é cofigurável para a página da Web de edição, bem como uma lista de exclusão da autenticação para outros recursos.

Um switch low-side que desliga os escravos quando necessário, também foi desenvolvido em uma placa-filha existente.

Como uma nota técnica, antes de iniciar esta construção, a pegada de memória era de 70% por causa de um gráfico de objeto de metadados global. A biblioteca AssimilateBus mais recente teve mudanças significativas que separam a variável global em arquivos JSON menores salvos em SPIFFS. Isso trouxe a pegada de volta para ~ 50%, o que é mais seguro para toda a análise / construção JSON. A biblioteca AssimilateBusSlave permanece a mesma (ASSIM_VERSION 2) durante essas mudanças.

RECURSOS E VISÃO

Atualmente, os escravos (sensores e atores) são independentes e contam com mensagens I2C baseadas em convenção para ler propriedades ou agir em comandos. O Master coleta os metadados e propriedades dos escravos e os envia para um broker MQTT. Ele também inicia um servidor da web e fornece arquivos JSON que podem ser editados para configurar o mestre e personalizar os metadados / propriedades que eventualmente são consumidos pelo Crouton. Os sensores / atores individuais são lidos / comandados via Crouton sem que o mestre tenha qualquer conhecimento prévio do que os escravos fazem.

Um dos objetivos da ASSIMILATE IOT NETWORK é personalizar o Crouton para que os editores de mashup servidos pelos servidores da web IOT NODE (como esta compilação) sejam adicionados como componentes da web que darão controle completo do que a coisa faz, ou seja, o mestre não está programado, os escravos têm conjuntos de recursos básicos, mas o painel do Crouton incorpora todas as regras de negócios necessárias para executar a coisa!

O garfo Crouton é visto como uma opção para o controle / configuração descentralizada das coisas. Em essência, qualquer combinação de cliente / GUI MQTT pode administrar suas coisas, já que cada função (sensores e atores) são expostos como terminais MQTT.

Etapa 1: pão torrado

Crouton. https://crouton.mybluemix.net/ Crouton é um painel que permite visualizar e controlar seus dispositivos IOT com configuração mínima. Essencialmente, é o painel mais fácil de configurar para qualquer entusiasta de hardware IOT usando apenas MQTT e JSON.

Os ASSIMILATE SLAVES (sensores e atores) possuem metadados e propriedades embutidos que o mestre usa para construir o pacote deviceInfo json que Crouton usa para construir o painel. O intermediário entre ASSIMILATE NODES e Crouton é um broker MQTT compatível com websockets: o Mosquito é usado para a demonstração.

À medida que ASSIMILATE MASTER (esta construção) solicita propriedades, ele formata os valores de resposta no formato necessário para atualizações de Crouton.

Etapa 2: O servidor / editor da Web

Quando o Master é inicializado (esta construção), um servidor da web embutido é iniciado. O endereço IP é enviado para o console serial; eventualmente, isso será publicado no painel do Crouton.

Quando você navegar até o URL indicado, o ACE EDITOR será carregado:

Ace é um editor de código embutido escrito em JavaScript. Corresponde aos recursos e desempenho de editores nativos, como Sublime, Vim e TextMate.

O Ace é popular entre os servidores da web embutidos e oferece uma boa interface para editar e salvar os arquivos JSON.

Clicar em um nome de arquivo à esquerda irá ler o arquivo de SPIFFS no ESP8266 e carregar o conteúdo para edição à direita. O arquivo pode ser salvo na barra de ferramentas superior.

Para fazer upload de um arquivo:

1. Escolha Arquivo em seu sistema de arquivos local.
2. Insira um caminho de pasta (se necessário) na caixa de texto.
3. Clique em Upload.
4. Recarregue a página.

Etapa 3: Personalização do dispositivo

A configuração do dispositivo (o ESP8266) é acionada por meio do arquivo device.json.

Algumas dessas entradas (wifi_ssid, wifi_key) precisarão ser modificadas antes de enviar os dados para SPIFFS (ESP8266 Sketch Data Upload).

Navegue até a raiz do servidor da web (mostrado na saída do console como

EDITANDO

No ACE EDITOR, escolha config / device.json.

As entradas são:

• www_auth_username: nome de usuário de autorização para arquivos do servidor web (vazio para não autorização).
• www_auth_password: senha de autorização para arquivos do servidor web (se nome de usuário definido).
• www_auth_exclude_files: lista delimitada por ponto e vírgula de caminhos de arquivos a serem excluídos das verificações de autorização (se o nome de usuário estiver definido).
• sensor_interval: os milissegundos entre publicações de dados no MQTT Broker.
• ntp_server_name: o nome do servidor de horário a ser usado.
• time_zone: a diferença em horas para seu horário local.
• wifi_ssid: o SSID do seu ponto de acesso local.
• wifi_key: a chave a ser usada para o SSID.
• mqtt_broker: o endereço do broker MQTT.
• mqtt_username: o nome de usuário a ser usado para o broker MQTT (vazio para nenhuma conta necessária).
• mqtt_password: a senha a ser usada a partir do nome de usuário MQTT.
• mqtt_port: a porta do broker MQTT.
• mqtt_device_name: o nome a ser usado para tópicos MQTT e identificação de Crouton.
• mqtt_device_description: a descrição do dispositivo mostrado no Crouton.
• viz_color: a cor para identificar os cartões de dispositivo em Crouton (na versão bifurcada)

Etapa 4: Personalização da propriedade

Cada um dos escravos tem uma matriz de struct nvc definida no arquivo settings.h:

// --------------------------------------- PROPRIEDADES PUBLICADAS

nvc props [2] = {{"Umidade", "", verdadeiro}, {"Temperatura", "", falso}}; // --------------------------------------- PROPRIEDADES PUBLICADAS FIM

Cada uma das entradas possui um índice com o primeiro sendo 0 (zero).

A customização do nome da propriedade é acionada por meio do arquivo user_props.json.

Navegue até a raiz do servidor da web (mostrado na saída do console como

EDITANDO

No ACE EDITOR, escolha config / user_props.json (ou carregue um).

A estrutura é:

A primeira chave é o endereço do escravo no arquivo settings.h conforme identificado por:

#define ADDRESS_SLAVE XX

• O próximo nível de chaves é o índice da propriedade.
• O valor dessa chave é o nome da propriedade a ser usado no Crouton em vez do nome da propriedade definido no arquivo de definições.

Etapa 5: Personalização de Metadados

Devido à quantidade de personalizações possíveis, cada escravo possui seu próprio arquivo de modificação de metadados. Os arquivos devem estar no formato user_metas_.json.

O endereço do escravo é encontrado no arquivo settings.h nos esboços ATTINY85:

#define ADDRESS_SLAVE XX

Os metadados são definidos no mesmo arquivo desta forma:

const static char viz1 PROGMEM = "VIZ_CARD_TYPE";

const static char viz2 PROGMEM = "2: gráfico-donut"; const static char viz3 PROGMEM = "1";

A primeira linha é o nome do item de metadados.

A segunda linha é o valor. Geralmente, tem um sufixo de índice de propriedade.

A terceira linha é a bandeira de continuação. 1 - continuar, 0 - fim dos metadados (VCC_MV).

Navegue até a raiz do servidor da web (mostrado na saída do console como

EDITANDO

No ACE EDITOR, escolha config / user_metas_SLAVE_ADDRESS.json (ou carregue um). A estrutura é:

• Uma matriz de pares de nome / valor.
• Nome é o nome do item de metadados a ser alterado.
• O valor é a mudança. O sufixo do índice é verificado para a substituição.

Etapa 6: Materiais e Ferramentas

ICOS10 (IDC) Shell Bill of Materials

1. D1M BLOCK Pin Jig (1)
2. Base e alojamento D1M BLOCK (1)
3. Wemos D1 Mini (1)
4. Wemos D1 Mini Protoboard Shield (1)
5. Cabeçalhos 40P fêmeas (8P, 8P, 9P, 9P)
6. Cabeçalho macho 90º (3P, 3P, 3P, 2P, 1P, 2P)
7. 1 "Protoboard dupla face (2)
8. 2N7000 NFET (1)
9. Cabeçalho macho IDC envolto de 6 pinos (1)
10. Fio de conexão (~ 10)
11. Fio estanhado de 0,5 mm (~ 4)
12. Parafusos autorroscantes de cabeça de botão 4G x 15mm (2)
13. Parafusos escareados autorroscantes 4G x 6mm (~ 20)
14. Solda e Ferro (1)

Etapa 7: Preparação de MCU

Nesta compilação, estamos usando o Wemos D1 Mini. Se você construiu anteriormente um BLOCO WIFI D1M, pode usá-lo para o componente de hardware modular. Caso contrário, siga, no mínimo, a próxima seção.

SOLDANDO OS PINOS DO CABEÇALHO NO MCU (usando o PIN JIG) Se você não consegue imprimir um PIN JIG, basta seguir as instruções e improvisar: a altura (deslocamento) do PIN JIG é de 6,5 mm.

1. Imprima / obtenha um PIN JIG nesta página.
2. Alimente os pinos de cabeçalho pela parte inferior da placa (TX direita-esquerda) e no gabarito de solda.
3. Pressione os pinos em uma superfície plana e dura.
4. Pressione a placa firmemente no gabarito.
5. Solde os 4 pinos de canto.
6. Reaqueça e reposicione a placa / pinos se necessário (placa ou pinos não alinhados ou prumo).
7. Solde o resto dos pinos.

FAZENDO O UPLOAD DO FIRMWARE

O repositório de código pode ser encontrado aqui (instantâneo).

Um ZIP da biblioteca pode ser encontrado aqui (instantâneo).

Instruções para "Importar uma biblioteca ZIP" aqui.

Assim que a biblioteca estiver instalada, você pode abrir o exemplo "mqtt_crouton_esp8266_customization_webserver".

Instruções para configurar o Arduino para o Wemos D1 Mini aqui.

Dependências: ArduinoJson, TimeLib, PubSubClient, NeoTimer (veja os anexos se houver alterações nos repositórios).

CARREGAR PARA SPIFFS

Depois que o código foi carregado no IDE do Arduino, abra device.json na pasta data / config:

1. Modifique o valor de wifi_ssid com seu SSID WiFi.
2. Modifique o valor de wifi_key com sua chave WiFi.
3. Modifique o valor de mqtt_device_name com sua identificação de dispositivo preferida (sem necessidade de junção).
4. Modifique o valor de mqtt_device_description com sua descrição de dispositivo preferida (em Crouton).
5. Salve device.json.
6. Faça upload dos arquivos de dados para SPIFFS.

Etapa 8: Preparação da carcaça MCU

O MCU Housing expõe cabeçalhos para o D1 Mini conectar e cabeçalhos para placas-filha que se comunicam com o circuito de soquete (sensores e atores).

CABEÇALHOS DE HOSPEDAGEM Baseado em um Mini Protoboard D1, e quebra estes pinos:

1. Pinos para o D1M WIFI BLOCK / D1 Mini para conectar.
2. Breakouts diretos das 2 filas de contatos do D1M WIFI BLOCK / D1 Mini. Eles estão disponíveis apenas por conveniência durante a prototipagem. Espera-se que as placas-filha bloqueiem todo o acesso a esses cabeçalhos.
3. 4 Separações dos pinos específicos usados pelas placas-filha.

Para adicionar os contatos D1M ao CABEÇALHO DA HABITAÇÃO:

1. Assista ao vídeo SOLDER USANDO O SOCKET JIG.
2. Alimente os pinos de cabeçalho pela parte inferior da placa (TX superior esquerdo no lado superior).
3. Alimente o gabarito sobre o coletor de plástico e nivele ambas as superfícies.
4. Vire o gabarito e o conjunto e pressione firmemente a plataforma em uma superfície plana e dura.
5. Pressione a placa firmemente no gabarito.
6. Solde os 4 pinos de canto usando o mínimo de solda (apenas alinhamento temporário dos pinos).
7. Reaqueça e reposicione a placa / pinos se necessário (placa ou pinos não alinhados ou prumo).
8. Solde o resto dos pinos.
9. Remova o gabarito.
10. Corte os pinos acima das soldas.

Para adicionar os Breakouts da placa filha:

1. Corte 4 cabeçalhos 9P Fêmea.
2. Na parte superior, insira os cabeçalhos 9P conforme mostrado e solde na parte inferior.

Para adicionar Breakouts diretos:

1. Corte 2 cabeçalhos 8P Feminino.
2. Na parte superior, insira os conectores 8P conforme mostrado e solde na parte inferior.

Para conectar os cabeçalhos, na parte inferior com o pino TX orientado para cima:

1. Rastreie e solde do pino RST em 4 pinos.
2. Rastreie e solde do pino A0 em 4 pinos.
3. Rastreie e solde do pino D1 em 4 pinos.
4. Rastreie e solde do pino D2 em 4 pinos.
5. Rastreie e solde do pino D0 para baixo em 2 fileiras e em 4 pinos.
6. Rastreie e solde do pino D7 em 4 pinos.
7. Rastreie e solde do pino GND em 4 pinos.
8. Rastreie e solde do pino 5 V em 4 pinos.
9. Rastreie e solde do pino 3V3 para baixo 45 ° em 4 pinos.

MONTAGEM DO FIXTURE

Os CABEÇALHOS DA HABITAÇÃO são afixados à HABITAÇÃO MCU e esta é afixada à PLACA BASE.

1. Com o lado comprido dos CABEÇALHOS DA HABITAÇÃO apontado para o orifício, insira os CONTATOS D1M nas aberturas da CAIXA MCU e empurre para baixo nivelado.
2. Insira a MCU nos CONTATOS da MCU durante a fixação para garantir o alinhamento correto.
3. Coloque o HEADER FRAME sobre o topo dos acessórios de montagem e fixe com 2 parafusos 4G x 16mm.
4. Coloque os acessórios montados com o orifício apontado para o lado curto e fixe com os parafusos 4G x 6mm.

Etapa 9: Construindo o Interruptor do lado inferior dos escravos / placa filha de RESET

Este é um aprimoramento da placa filha REST desenvolvida na última construção. Isso adiciona uma chave de baixo que conecta os escravos ao GROUND. Se o mestre for reiniciado, os escravos também o farão, e a inicialização que propaga os metadados começará novamente.

CONJUNTO

1. No interior, insira os cabeçotes macho 9P 90 ° (1), o cabeçote macho 1P 90 ° (2), o 2N7000 (3) e solde do lado de fora.
2. No interior, trace um fio amarelo de YELLOW1 a YELLOW2 e solde.
3. No interior, trace um fio desencapado de PRATA1 a PRATA2 e solde.
4. No interior, trace um fio desencapado de PRATA3 a PRATA4 e solde.

Etapa 10: montagem dos componentes principais

1. Certifique-se de que o SHELL foi construído e o circuito testado (cabo e tomadas).
2. Troque o cabeçote 2P Macho no 3V3 I2C DAUGHTER-BOARD por um 2P 90º 1P Cabeçalho Macho.
3. Insira o 3V3 I2C DAUGHTER-BOARD, com o pino 3V3 na extremidade irregular dos cabeçalhos (ver foto).
4. Insira o BOTÃO BAIXO / RESET DAUGHTER-BOARD, com o fio para dentro (ver foto).
5. Rastreie uma derivação Dupont entre o Cabeçalho Macho 90º 1P no RESET DAUGHTER-BOARD até o 3V3 I2C DAUGHTER-BOARD.
6. Insira o soquete IDC do CABO SHELL no cabeçalho IDC da PLACA-FILHA 3V3 I2C.
7. Insira cuidadosamente o FILHO-PLACA / ALOJAMENTO entre os cabos no SHELL e alinhe os orifícios da base.
8. Fixe o CONJUNTO DA BASE ao SHELL com os parafusos 4G x 6mm.
9. Anexe quaisquer SENSORES ASSIMILADOS que você tenha feito.

Etapa 11: Próximas etapas

1. Aponte seu navegador para
2. Certifique-se de que o corretor seja test.mosquitto.org.
3. Clique em Conectar.
4. Insira a entrada do nome do dispositivo como mqtt_device_name no arquivo /config/device.json.
5. Clique em Adicionar dispositivo.
6. Clique em Conexão automática.
7. Ligue seu ICOS10 (5V MicroUSB).
8. Verifique por meio do painel do Crouton.