Pular para o conteúdo
ThingFace

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.

PlacaSDK em C · chave gerada no chip
ThingFaceguarda a página · repassa bytes
Navegadora sua página, isolada das outras

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 fetch e os formulários da página antiga não chegam à placa; a página troca essas chamadas por send e on, 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ê.