Três peças, um caminho só.
A placa conecta para fora, a nuvem guarda a página e liga cada navegador à placa certa, e a sua página fala com o firmware por mensagens.
Na placa: o SDK
Uma biblioteca em C que roda no ESP-IDF, no Arduino e no PlatformIO. Ela abre uma conexão TLS de saída para gw.thingface.com, prova quem é a placa com uma chave gerada no próprio chip e mantém a conexão de pé: se o Wi-Fi cai ou o roteador muda, ela reconecta automaticamente. A placa nunca recebe conexão de fora, então não há porta para abrir nem para atacar.
Na nuvem: guardar e repassar
A página (HTML, CSS, JavaScript e imagens) é publicada no produto pela linha de comando e vale para todas as placas dele: o firmware não precisa levá-la, e nenhuma placa muda a interface do produto. Quem prefere que cada placa sirva o que carrega marca a interface do produto como no dispositivo, e a placa sobe a própria página, até 512 KB. A nuvem guarda a página e a serve num endereço só da placa, isolado das outras. Quando alguém abre a página com login, a nuvem liga aquele navegador à placa e passa a repassar as mensagens nos dois sentidos, sem ler nenhuma.
No navegador: a sua página
A página fala com a placa por uma biblioteca de JavaScript de duas funções:
import { connect } from '/_devui/v1.js';
const placa = await connect();
placa.on('message', (m) => mostrar(m));
placa.send({ led: true });
E, na placa:
static void on_msg(const devui_msg_t *m, void *ctx) {
/* m->data, m->len: o que a página mandou */
}
devui_on_message(on_msg, NULL);
devui_send(DEVUI_ALL, estado, tamanho, DEVUI_STATE); /* para todas as páginas abertas */
Exemplo completo
Um projeto ESP-IDF com três arquivos: a página, o firmware e o CMake que embute a página no firmware (a interface no dispositivo; com a interface na nuvem, o CMake não embute nada e a página sai pelo devui publish). O Wi-Fi vem do exemplo comum do SDK (examples/comum).
web/index.html: a página
<!doctype html>
<html lang="pt-BR">
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Luz</title>
<p>Luz: <strong id="estado">…</strong></p>
<button id="botao" disabled>Acender</button>
<script type="module">
import { connect } from '/_devui/v1.js';
const placa = await connect();
const estado = document.getElementById('estado');
const botao = document.getElementById('botao');
let aceso = false;
// o estado vem sempre da placa: ao abrir a página e a cada mudança
placa.on('message', (m) => {
aceso = m.led;
estado.textContent = aceso ? 'acesa' : 'apagada';
botao.textContent = aceso ? 'Apagar' : 'Acender';
});
// o botão só funciona com a placa conectada
const conexao = (s) => { botao.disabled = s !== 'online'; };
placa.on('state', conexao);
conexao(placa.state);
botao.onclick = () => placa.send({ led: !aceso });
</script>
main/main.c: a placa
#include <stdbool.h>
#include <string.h>
#include "devui.h"
#include "devui_bundle.h"
#include "driver/gpio.h"
#include "esp_app_desc.h"
#include "esp_log.h"
#include "exemplo_wifi.h"
#include "nvs_flash.h"
#define LED GPIO_NUM_2
static const char *TAG = "luz";
static bool aceso;
/* o estado inteiro da placa, para uma página (a sessão dela) ou para todas (DEVUI_ALL) */
static void envia_estado(uint16_t sessao)
{
const char *estado = aceso ? "{\"led\":true}" : "{\"led\":false}";
devui_send(sessao, estado, strlen(estado), DEVUI_TEXT | DEVUI_STATE);
}
/* a página mandou {"led":true} ou {"led":false} */
static void on_msg(const devui_msg_t *m, void *ctx)
{
aceso = m->len == 12 && memcmp(m->data, "{\"led\":true}", 12) == 0;
gpio_set_level(LED, aceso);
envia_estado(DEVUI_ALL);
}
static void on_event(const devui_event_t *ev, void *ctx)
{
if (ev->type == DEVUI_EV_SESSION_OPEN) {
envia_estado(ev->session); /* quem acabou de abrir a página já vê o LED como está */
} else if (ev->type == DEVUI_EV_PAIR_CODE) {
ESP_LOGI(TAG, "abra para parear: %s", ev->pair_url);
}
}
void app_main(void)
{
ESP_ERROR_CHECK(nvs_flash_init());
gpio_reset_pin(LED);
gpio_set_direction(LED, GPIO_MODE_OUTPUT);
exemplo_wifi_start(); /* antes do devui_start: a chave da placa nasce com o rádio ligado */
devui_config_t cfg = DEVUI_CONFIG_DEFAULT();
cfg.bundle = devui_bundle, cfg.bundle_size = devui_bundle_size; /* a página, embutida pelo CMake */
cfg.manifest = devui_manifest, cfg.manifest_size = devui_manifest_size;
cfg.fw_version = esp_app_get_description()->version;
devui_on_message(on_msg, NULL);
devui_on_event(on_event, NULL);
ESP_ERROR_CHECK(devui_start(&cfg));
/* sem dono ainda: pede o código de pareamento (o link sai no evento DEVUI_EV_PAIR_CODE) */
esp_err_t r = devui_pair_begin();
if (r != ESP_OK && r != DEVUI_ERR_HAS_OWNER) {
ESP_LOGW(TAG, "pareamento: %s", esp_err_to_name(r));
}
}
main/CMakeLists.txt
idf_component_register(SRCS "main.c"
PRIV_REQUIRES devui comum driver esp_app_format nvs_flash)
# embute a pasta web/ no firmware (interface no dispositivo): a placa sobe a página para a nuvem ao conectar
devui_add_bundle(${COMPONENT_LIB} "${CMAKE_CURRENT_LIST_DIR}/../web" --product luz --version 0.1.0)
E se a placa estiver desligada?
A página abre mesmo assim e diz que a placa está fora. Se você ligar o último estado, a placa marca uma mensagem como estado (até 4 KB) e a nuvem a entrega a quem abrir depois: a página já aparece com os últimos valores.
O que a nuvem não faz
- Não é VPN: ninguém ganha acesso à rede da placa.
- Não é túnel HTTP: os
fetche os formulários da página antiga não chegam à placa; a página troca essas chamadas porsendeon, ou usa o adaptador do ESPUI ou do ESP-DASH. - Não guarda histórico, não desenha gráfico, não dispara alerta por valor: para isso, a nuvem teria de ler as suas mensagens, e ela não lê.
