Até aqui, o sistema percebe o ambiente, calcula e controla componentes localmente. Agora surge uma nova necessidade: trocar informações com outros dispositivos. O mesmo projeto vai evoluir passo a passo, sem criar um circuito novo para cada tecnologia.
Use este quadro para não tentar reproduzir no simulador um recurso que ele não oferece.
| Etapa | ESP32 física | Wokwi com gateway público |
|---|---|---|
| Circuito / Blink | ✓ Teste completo | ✓ Teste completo |
| Bluetooth | ✓ Bluetooth Classic/SPP real com Android | △ O rádio Bluetooth não é simulado; testamos a lógica pelo Monitor Serial |
| Wi-Fi | ✓ Teste completo em rede 2,4 GHz compatível | ✓ Teste completo com Wokwi-GUEST |
| HTTP — cliente | ✓ Faz requisição para outro servidor | ✓ Conexões de saída funcionam no gateway público |
| HTTP — servidor | ✓ Navegador controla o LED na mesma rede | △ Navegador só entra no servidor com Private IoT Gateway |
| mDNS | ✓ Pode ser testado na rede local; depende também do sistema e da rede | — Não é um teste confiável no gateway público |
| Tunelamento | ✓ Teste completo com um computador na mesma rede | — Não é prática do Wokwi padrão |
O Arduino Uno já nos ensinou a base. Agora vamos observar apenas o que muda ao trabalhar com o ESP32.
| Arduino Uno | ESP32 DevKit |
|---|---|
| Lógica digital de 5 V | Lógica digital de 3,3 V |
| Sem Wi-Fi e Bluetooth integrados | Wi-Fi e Bluetooth integrados |
| Pinos mais simples de reconhecer no início | GPIOs com várias funções possíveis |
| Recursos mais enxutos | Mais recursos internos e possibilidades de comunicação |
O que continua igual: ainda teremos entradas, saídas, pinMode(), digitalWrite(), sensores, atuadores e lógica de programação.
GPIO vem de General Purpose Input/Output, ou entrada/saída de uso geral. É o nome dado aos pinos do microcontrolador que podem receber ou enviar sinais.
Nomes como GPIO 23, GPIO 18 e GPIO 4 identificam esses sinais internos. O número do GPIO não indica a posição física do pino na placa; por isso, os números impressos ao lado dos conectores não aparecem necessariamente em sequência.
Além disso, um mesmo GPIO pode assumir funções diferentes, como entrada/saída digital, leitura analógica, PWM ou comunicação.
GND vem de ground (terra). É a referência elétrica comum do circuito e o caminho de retorno da corrente. Os vários pinos GND da placa pertencem ao mesmo terra elétrico e existem para facilitar as conexões durante a montagem.
Nas práticas deste bloco, escolha o GND que deixar o circuito mais simples e organizado.
Atenção: um sensor alimentado com 5 V pode entregar um sinal de 5 V. Antes de ligar sua saída ao ESP32, confira se é necessária adaptação de nível.
Wi-Fi e Bluetooth já fazem parte do ESP32. Eles não ocupam um GPIO específico e não precisam de um módulo externo para funcionar.
No módulo ESP32-WROOM-32, a antena integrada fica em uma das extremidades do módulo e é responsável pela comunicação sem fio.
Não é preciso decorar o pinout. Em cada prática indicaremos os GPIOs apropriados.
Agora que reconhecemos as diferenças essenciais do ESP32, vamos montar um LED no GPIO 23 e confirmar o funcionamento da placa antes de iniciar a comunicação sem fio.
Antes da comunicação sem fio, vamos confirmar o GPIO 23 com um LED.
Já reconhecemos as principais diferenças do ESP32. Antes de usar Bluetooth ou Wi-Fi, vamos confirmar a montagem e o controle de uma saída simples: um LED no GPIO 23.
pinMode() configura o pino.digitalWrite() altera uma saída digital.HIGH e LOW continuam representando os estados digitais.delay() ainda pode ser usado em testes simples.Com o LED funcionando, o próximo passo será deixar de controlar a saída apenas pelo próprio programa e começar a receber comandos por Bluetooth e pela rede Wi-Fi.
Se a porta não aparecer: confira primeiro o cabo USB, a conexão física e o driver USB-serial utilizado pela sua placa.
Para manter compatibilidade com Bluetooth Classic: use a placa deste percurso, baseada no ESP32 original / ESP32-WROOM-32. ESP32-C3, S2 e S3 são famílias diferentes e não devem ser escolhidas para reproduzir esta prática de BluetoothSerial.
const int LED = 23;
void setup() {
pinMode(LED, OUTPUT);
}
void loop() {
digitalWrite(LED, HIGH);
delay(1000);
digitalWrite(LED, LOW);
delay(1000);
}O LED acende por um segundo e apaga por um segundo continuamente.
O ESP32 já controla o LED. Mas ainda é o próprio programa que decide quando isso acontece. Como enviar uma ordem sem fio a partir de um dispositivo próximo?
O celular envia um comando, o ESP32 interpreta e o circuito reage.
Controles próximos, configurações de equipamentos, comandos enviados por um celular e comunicação entre dispositivos no mesmo ambiente são exemplos em que uma conexão direta pode ser suficiente. No nosso protótipo, o LED representa qualquer saída que precise obedecer a um comando recebido sem fio.
Bluetooth permite comunicação sem fio a curta distância. Aqui usaremos Bluetooth Classic com SPP (Serial Port Profile, perfil de porta serial), que cria um canal parecido com uma comunicação serial.
O celular envia um caractere, o ESP32 lê esse caractere e decide o que fazer. Não é necessário roteador, endereço IP ou rede Wi-Fi para essa comunicação direta.
Use o circuito da etapa Preparação — Circuito. Não há nova montagem: o LED e o resistor de 220 Ω continuam em série entre o GPIO 23 e o GND.
Comparação: em um Arduino Uno é comum acrescentar um HC-05 ou HC-06 para obter Bluetooth serial. No ESP32 utilizado aqui, o Bluetooth já está integrado.
#include "BluetoothSerial.h"
BluetoothSerial SerialBT;
const int LED = 23;
void setup() {
pinMode(LED, OUTPUT);
digitalWrite(LED, LOW);
Serial.begin(115200);
SerialBT.begin("MBB-ESP32");
Serial.println("Bluetooth iniciado.");
Serial.println("Conecte-se ao dispositivo MBB-ESP32.");
}
void loop() {
if (SerialBT.available()) {
char comando = SerialBT.read();
if (comando == 'L' || comando == 'l') {
digitalWrite(LED, HIGH);
Serial.println("LED ligado.");
SerialBT.println("LED LIGADO");
}
if (comando == 'D' || comando == 'd') {
digitalWrite(LED, LOW);
Serial.println("LED desligado.");
SerialBT.println("LED DESLIGADO");
}
}
}#include "BluetoothSerial.h" disponibiliza a comunicação Bluetooth serial.
BluetoothSerial SerialBT; cria o objeto usado para enviar e receber dados.
SerialBT.begin("MBB-ESP32") inicia o Bluetooth com o nome que será procurado no celular.
SerialBT.available() verifica se há dado recebido e SerialBT.read() lê um caractere.
Compare com Serial.available() e Serial.read(): a lógica é parecida; muda a origem do dado.
L e observe o LED acender.D e observe o LED apagar.O celular envia L ou D, o ESP32 executa a ação e devolve uma confirmação. Assim, a comunicação ocorre nos dois sentidos.
| Problema | O que conferir |
|---|---|
O código não compila com BluetoothSerial.h | Confirme que a placa selecionada é baseada no ESP32 original / ESP32-WROOM-32. Não use ESP32-C3, S2 ou S3 para reproduzir esta prática de Bluetooth Classic/SPP. |
| O nome MBB-ESP32 não aparece | Confirme se o programa foi carregado, se a placa é ESP32-WROOM-32 e se o Bluetooth do celular está ativo. |
| Conecta, mas o LED não responde | Envie apenas os caracteres L ou D e confira o GPIO 23. |
| O aplicativo não oferece terminal serial | Use um aplicativo compatível com Bluetooth Classic/SPP. BLE (Bluetooth Low Energy) usa outro modelo de comunicação. |
| Estou tentando pelo iPhone/iPad | Esta prática usa o perfil serial clássico SPP e foi planejada para Android. Para iOS/iPadOS, a alternativa didática adequada seria outra implementação, normalmente baseada em BLE. |
Bluetooth resolveu a comunicação próxima. Mas e se o ESP32 precisar fazer parte de uma rede, como um computador ou celular?
O dispositivo deixa de depender apenas de uma conexão direta e passa a ter um endereço dentro da rede.
O ESP32 deixa de conversar apenas com um dispositivo próximo e passa a participar da mesma infraestrutura usada por celulares e computadores. Isso prepara o caminho para páginas Web, APIs, envio de dados e outros serviços de rede que veremos a partir daqui.
O ESP32 entrará na rede como uma estação, isto é, como mais um dispositivo conectado ao ponto de acesso ou roteador.
Em uma rede comum, o roteador normalmente fornece esse endereço IP automaticamente quando o ESP32 se conecta.
Rede Wi-Fi não é sinônimo de Internet. Dois dispositivos podem se comunicar pela mesma rede local mesmo que ela não tenha acesso à Internet.
O circuito continua igual. O LED permanece no GPIO 23, mas nesta etapa ele não é o foco. O resultado observável será a conexão mostrada no Monitor Serial.
Para o primeiro teste: use uma rede Wi-Fi de 2,4 GHz simples, sem página de login e sem autenticação corporativa. Redes escolares e redes de visitantes podem impor restrições adicionais. Não publique nem compartilhe o código depois de substituir SENHA_DA_REDE por uma senha real.
#include <WiFi.h>
const char* ssid = "NOME_DA_REDE";
const char* senha = "SENHA_DA_REDE";
const int LED = 23;
void setup() {
Serial.begin(115200);
pinMode(LED, OUTPUT);
digitalWrite(LED, LOW);
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, senha);
Serial.print("Conectando ao Wi-Fi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("Wi-Fi conectado.");
Serial.print("Endereco IP: ");
Serial.println(WiFi.localIP());
}
void loop() {
}WiFi.mode(WIFI_STA) coloca o ESP32 em modo station (estação), para entrar em uma rede existente.
WiFi.begin(ssid, senha) inicia a tentativa de conexão usando o nome e a senha da rede.
WiFi.status() permite verificar se a conexão já foi estabelecida.
WiFi.localIP() mostra o endereço IP recebido pelo ESP32 dentro daquela rede.
NOME_DA_REDE e SENHA_DA_REDE.Conectando ao Wi-Fi.... Wi-Fi conectado. Endereco IP: 192.168.1.37
O endereço será diferente em cada rede.
| Problema | O que conferir |
|---|---|
| Fica somente nos pontos | Nome da rede, senha, sinal e compatibilidade com 2,4 GHz. |
| Rede da escola aparece, mas não conecta | Ela pode usar página de login, WPA2/WPA3-Enterprise ou outra política que este exemplo simples não trata. Para o primeiro teste, use uma rede 2,4 GHz simples ou um hotspot de teste. |
| Monitor Serial mostra caracteres ilegíveis | Configure o Monitor Serial para 115200. |
No Wokwi, use a rede virtual Wokwi-GUEST. Execute a simulação e observe no Monitor Serial a confirmação da conexão e o endereço IP recebido.
ESP32 física: o Monitor Serial deve mostrar “Wi-Fi conectado” e um IP da rede usada. Wokwi: o Monitor Serial deve mostrar a conexão ao Wokwi-GUEST e, no gateway público, normalmente o IP 10.10.0.2.
Conseguimos colocar o ESP32 na rede e identificá-lo por um endereço IP. Isso é necessário, mas ainda não entrega nenhuma interface ao usuário. Agora precisamos escolher uma forma de conversa que o navegador já entenda. É aí que entra o HTTP.
HTTP significa Hypertext Transfer Protocol. É um protocolo de aplicação usado para organizar pedidos e respostas entre clientes e servidores.
Primeiro o ESP32 oferecerá uma pequena página: o celular pede, o ESP32 responde e o LED muda de estado. Depois inverteremos os papéis para perceber uma ideia importante: o ESP32 pode tanto oferecer um serviço quanto consumir um serviço de outro sistema.
O cliente inicia um pedido (request). O servidor recebe esse pedido e devolve uma resposta (response). O papel depende da situação:
| Situação | Cliente | Servidor |
|---|---|---|
| Celular abre a página do ESP32 | Celular | ESP32 |
| ESP32 consulta uma página na Web | ESP32 | Servidor Web |
Importante: HTTP não exige que a comunicação atravesse a Internet. Ele também pode funcionar somente dentro da rede local, como no servidor criado pelo ESP32.
Problema: pelo Bluetooth enviávamos L e D. Agora queremos abrir uma página no navegador e tocar em links para controlar o mesmo LED.
#include <WiFi.h>
#include <WebServer.h>
const char* ssid = "NOME_DA_REDE";
const char* senha = "SENHA_DA_REDE";
const int LED = 23;
WebServer servidor(80);
String criarPagina() {
String estado;
if (digitalRead(LED) == HIGH) {
estado = "LIGADO";
} else {
estado = "DESLIGADO";
}
String pagina = "<!DOCTYPE html>";
pagina += "<html><head><meta charset='UTF-8'>";
pagina += "<meta name='viewport' content='width=device-width, initial-scale=1'>";
pagina += "<title>Ambiente MbB</title></head><body>";
pagina += "<h1>Ambiente MbB</h1>";
pagina += "<p>Estado do LED: <strong>";
pagina += estado;
pagina += "</strong></p>";
pagina += "<p><a href='/ligar'>Ligar LED</a></p>";
pagina += "<p><a href='/desligar'>Desligar LED</a></p>";
pagina += "</body></html>";
return pagina;
}
void mostrarPagina() {
servidor.send(200, "text/html", criarPagina());
}
void ligarLED() {
digitalWrite(LED, HIGH);
mostrarPagina();
}
void desligarLED() {
digitalWrite(LED, LOW);
mostrarPagina();
}
void setup() {
Serial.begin(115200);
pinMode(LED, OUTPUT);
digitalWrite(LED, LOW);
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, senha);
Serial.print("Conectando");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.print("Abra no navegador: http://");
Serial.println(WiFi.localIP());
servidor.on("/", mostrarPagina);
servidor.on("/ligar", ligarLED);
servidor.on("/desligar", desligarLED);
servidor.begin();
Serial.println("Servidor HTTP iniciado.");
}
void loop() {
servidor.handleClient();
}WebServer servidor(80) cria o servidor HTTP na porta 80, porta padrão usada por HTTP sem criptografia.
servidor.on("/", ...), servidor.on("/ligar", ...) e servidor.on("/desligar", ...) associam caminhos do endereço a funções do programa.
Quando o navegador pede /ligar, a função correspondente acende o LED e devolve a página atualizada.
servidor.send(200, "text/html", ...) envia a resposta: 200 indica sucesso e text/html informa que o conteúdo é uma página HTML.
servidor.handleClient() verifica continuamente se chegaram novos pedidos.
http://IP_DO_ESP32.A página mostra o estado do LED. Ao tocar em Ligar LED ou Desligar LED, o navegador faz um pedido ao ESP32, que executa a ação e devolve uma nova página.
Agora vamos inverter a conversa. Em muitos projetos IoT, o dispositivo não fica esperando alguém abrir sua página: ele próprio envia ou busca informações em um serviço externo. Para perceber essa mudança de papel, agora o ESP32 fará o pedido.
#include <WiFi.h>
#include <HTTPClient.h>
const char* ssid = "NOME_DA_REDE";
const char* senha = "SENHA_DA_REDE";
void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, senha);
Serial.print("Conectando");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("Wi-Fi conectado.");
HTTPClient http;
http.begin("http://example.com/");
int codigo = http.GET();
Serial.print("Codigo HTTP: ");
Serial.println(codigo);
if (codigo > 0) {
String resposta = http.getString();
Serial.println("Resposta recebida:");
Serial.println(resposta);
}
http.end();
}
void loop() {
}HTTPClient http cria o cliente HTTP.
http.begin() informa a URL (endereço do recurso) que será consultada.
http.GET() envia um pedido do tipo GET, usado para solicitar um recurso.
O valor retornado por GET() permite observar o código de resposta HTTP; 200, por exemplo, indica uma resposta bem-sucedida.
http.getString() lê o conteúdo recebido e http.end() libera os recursos usados pela conexão.
No Wokwi padrão, este teste também é possível: o pedido parte do ESP32 simulado para a Internet. O endereço example.com é usado apenas como destino simples; a resposta pode variar com o serviço, portanto o objetivo é verificar se houve um código HTTP positivo e conteúdo recebido.
| Problema | O que conferir |
|---|---|
| A página do ESP32 não abre | Celular/computador e ESP32 devem estar na mesma rede e o endereço deve usar o IP mostrado no Monitor Serial. Redes de escola, empresa ou “guest” podem isolar os clientes e impedir que um dispositivo acesse o outro; nesse caso, teste em uma rede simples que permita comunicação local. |
| O servidor abre, mas o LED não muda | Confira o GPIO 23 e se os caminhos /ligar e /desligar estão corretos. |
| A requisição do cliente retorna erro | Confirme primeiro se o Wi-Fi está conectado e se a rede permite acesso à Internet. |
Já conseguimos controlar o LED pelo navegador. Tecnicamente funciona, mas ainda dependemos de um número que pode mudar: o endereço IP. O próximo passo não é criar outro servidor; é tornar o servidor que já existe mais fácil de encontrar.
mDNS significa Multicast DNS. Ele permite descobrir nomes dentro da rede local sem depender de um servidor DNS configurado manualmente.
192.168.1.37 funciona, mas é pouco amigável e esse número pode mudar. Em vez de decorar endereços, queremos procurar o dispositivo por um nome. É aqui que o mDNS faz sentido: ele melhora a forma de encontrar o ESP32 dentro da rede local, sem mudar o circuito nem o servidor HTTP.Durante o desenvolvimento, copiar o IP do Monitor Serial é aceitável. Para alguém usar o sistema no dia a dia, porém, lembrar um nome como ambiente-mbb.local é muito mais natural. Nesta etapa não acrescentamos uma nova função ao LED; melhoramos a forma de chegar ao serviço que já existe.
DNS (Domain Name System) relaciona nomes a endereços IP. O mDNS leva essa ideia para a própria rede local usando mensagens multicast.
O nome facilita encontrar o dispositivo; ele não substitui o endereço IP internamente.
| Antes | Com mDNS |
|---|---|
http://192.168.1.37 | http://ambiente-mbb.local |
Nada muda no circuito nem no servidor HTTP. O mDNS acrescenta apenas uma forma mais fácil de localizar o ESP32 na rede local.
.local é local: esse nome não é um endereço público da Internet.
#include <WiFi.h>
#include <WebServer.h>
#include <ESPmDNS.h>
const char* ssid = "NOME_DA_REDE";
const char* senha = "SENHA_DA_REDE";
const int LED = 23;
WebServer servidor(80);
String criarPagina() {
String estado;
if (digitalRead(LED) == HIGH) {
estado = "LIGADO";
} else {
estado = "DESLIGADO";
}
String pagina = "<!DOCTYPE html>";
pagina += "<html><head><meta charset='UTF-8'>";
pagina += "<meta name='viewport' content='width=device-width, initial-scale=1'>";
pagina += "<title>Ambiente MbB</title></head><body>";
pagina += "<h1>Ambiente MbB</h1>";
pagina += "<p>Estado do LED: <strong>";
pagina += estado;
pagina += "</strong></p>";
pagina += "<p><a href='/ligar'>Ligar LED</a></p>";
pagina += "<p><a href='/desligar'>Desligar LED</a></p>";
pagina += "</body></html>";
return pagina;
}
void mostrarPagina() {
servidor.send(200, "text/html", criarPagina());
}
void ligarLED() {
digitalWrite(LED, HIGH);
mostrarPagina();
}
void desligarLED() {
digitalWrite(LED, LOW);
mostrarPagina();
}
void setup() {
Serial.begin(115200);
pinMode(LED, OUTPUT);
digitalWrite(LED, LOW);
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, senha);
Serial.print("Conectando");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("Wi-Fi conectado.");
if (!MDNS.begin("ambiente-mbb")) {
Serial.println("Falha ao iniciar mDNS.");
} else {
MDNS.addService("http", "tcp", 80);
Serial.println("mDNS iniciado.");
Serial.println("Abra: http://ambiente-mbb.local");
}
servidor.on("/", mostrarPagina);
servidor.on("/ligar", ligarLED);
servidor.on("/desligar", desligarLED);
servidor.begin();
}
void loop() {
servidor.handleClient();
}#include <ESPmDNS.h> disponibiliza os recursos de mDNS.
MDNS.begin("ambiente-mbb") registra o nome-base; o acesso será feito como ambiente-mbb.local.
MDNS.addService("http", "tcp", 80) anuncia que o dispositivo oferece HTTP na porta 80 usando TCP (Transmission Control Protocol). O papel do TCP será aprofundado no módulo de Protocolos.
http://ambiente-mbb.local.O mesmo servidor HTTP passa a ser acessado por um nome local legível, sem precisar digitar o endereço IP.
ambiente-mbb.local também abrir, a etapa está completa. Se o IP funciona e .local não, o código do servidor pode estar correto e a limitação pode estar na resolução mDNS do dispositivo ou da rede.| Problema | O que conferir |
|---|---|
| O IP funciona, mas .local não | O servidor HTTP pode estar correto. O dispositivo, sistema operacional ou rede pode não resolver mDNS da forma esperada. |
| Nem IP nem .local funcionam | Volte ao teste de Wi-Fi e confirme que os dispositivos estão na mesma rede. |
O nome ambiente-mbb.local melhorou a experiência, mas ainda existe uma fronteira: a rede local. Se o celular estiver em outra rede, esse nome não chega até o ESP32. Para um teste externo temporário, precisaremos criar outro caminho.
Um serviço local pode ser exposto temporariamente por meio de um túnel criado por um computador da mesma rede.
.local não resolvem isso. O túnel entra justamente para criar um caminho temporário de fora para dentro, sem transformar esta experiência didática em uma publicação permanente. E, ao fazer isso, surge naturalmente a próxima preocupação: segurança.Um túnel pode ser útil para demonstrar temporariamente um protótipo, testar o acesso a partir de outra rede ou permitir que alguém autorizado veja um serviço local por um período curto. Ele não é uma solução automática para publicar um produto definitivo; aqui serve para compreender a passagem de acesso local para acesso externo.
Um túnel cria um caminho intermediário entre um endereço acessível pela Internet e um serviço que continua dentro da rede local. Neste exemplo, usamos SSH (Secure Shell) para manter esse caminho.
O ESP32 não fica diretamente na Internet. O computador da mesma rede cria o túnel e encaminha as requisições recebidas até o servidor HTTP da placa.
http://IP_DO_ESP32.Usaremos localhost.run, um serviço que recebe a conexão SSH do computador e fornece um endereço público temporário. Outras ferramentas de tunelamento existem, mas não precisamos trocar de serviço para compreender o caminho dos dados.
ssh -V
ssh -R 80:192.168.1.37:80 localhost.run
Troque 192.168.1.37 pelo IP real do seu ESP32.
-R cria um encaminhamento remoto: o endereço público recebido pelo serviço será encaminhado pelo computador até a porta 80 do ESP32.
localhost.run e confirme para continuar.Ctrl+C para encerrar o túnel.A página do ESP32 pode ser alcançada temporariamente a partir de outra rede enquanto o túnel estiver ativo. Ao encerrar o comando SSH, o caminho público deixa de encaminhar as requisições para o ESP32.
| Problema | O que conferir |
|---|---|
| O comando SSH não existe | Confira se o cliente OpenSSH está disponível no sistema. |
| O túnel abre, mas a página não | Confirme que o computador ainda consegue abrir diretamente o IP do ESP32. |
| A URL parou de funcionar | O túnel depende do terminal aberto e a URL gratuita é temporária. |
| A rede bloqueia a conexão SSH | Teste em outra rede ou use outra ferramenta de tunelamento permitida no ambiente. |
Exponha somente o LED didático. Não use esta atividade para abrir temporariamente fechaduras, portões, câmeras, relés de potência ou dados pessoais. Tornar um serviço acessível externamente cria também uma nova pergunta: quem pode acessá-lo?
O sistema deixou de ser apenas local. Agora consegue conversar com dispositivos próximos, entrar em uma rede, atender ou fazer requisições Web, ser encontrado por nome e, em uma experiência controlada, ser acessado temporariamente de fora da rede.
Temos um objeto físico, um programa embarcado e conectividade. Quando esse conjunto passa a ser considerado Internet das Coisas? O que diferencia um dispositivo conectado de um sistema IoT? Essa será a próxima etapa.