Tutorial - IoT Coltec - DS

C OLÉGIO T ÉCNICO DA U NIVERSIDADE F EDERAL DE M INAS
G ERAIS
Tutorial - IoT Coltec

Sensores
Dener Augusto de Lisboa Brandão

Humberto Nobuyoshi Honda
Lista de ilustrações
Figura 1 – Download da Arduino IDE . . . . . . . . . . . . . . . . . . . . . . 9

Figura 2 – Arquivos para configuração da Placa do ESP32 . . . . . . . . . . . 10
Figura 3 – Download do Driver para o ESP32 . . . . . . . . . . . . . . . . . . 11
Figura 4 – Selecionado a placa do ESP32 . . . . . . . . . . . . . . . . . . . . 12
Figura 5 – Ícone do IFTTT . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Figura 6 – Ícone do Webhooks . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Figura 7 – Campos de Ação do Google Sheets no IFTTT . . . . . . . . . . . . 17
Figura 8 – Teste do IFTTT . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Figura 9 – Montagem do ESP32 com o sensor DHT11 . . . . . . . . . . . . . 23
Figura 10 – Selecionando o Monitor Serial . . . . . . . . . . . . . . . . . . . . 24
Figura 11 – Selecionando a velocidade da porta serial . . . . . . . . . . . . . . . 25
Figura 12 – Criando uma planilha do Google . . . . . . . . . . . . . . . . . . . 27
Figura 13 – Criando um Formulário do Google . . . . . . . . . . . . . . . . . . 28
Figura 14 – Adicionando Resposta Curva ao Formulário . . . . . . . . . . . . . 28
Figura 15 – Vinculando a Planilha ao Formulário . . . . . . . . . . . . . . . . . 29
Figura 16 – Abrindo Link do Formulário . . . . . . . . . . . . . . . . . . . . . 29
Figura 17 – Tela do Formulário . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Figura 18 – Link do Formulário . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Figura 19 – Inspecionar Elemento . . . . . . . . . . . . . . . . . . . . . . . . . 34
Figura 20 – Selecionar Elemento . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Figura 21 – Alteração da ID do formulário . . . . . . . . . . . . . . . . . . . . 35
Figura 22 – Alteração da Entrada de Dados do formulário . . . . . . . . . . . . 35
Figura 23 – Adicionar novas perguntas ao Formulário . . . . . . . . . . . . . . . 36
Figura 24 – Link do Formulário . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Figura 25 – Inspecionar Elemento . . . . . . . . . . . . . . . . . . . . . . . . . 41
Figura 26 – Selecionar Elemento . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Figura 27 – Alteração no Código para múltiplas respostas . . . . . . . . . . . . 42
Figura 28 – Esquema para montagem de múltiplos sensores . . . . . . . . . . . 42
Figura 29 – Gráficos na Planilha de Sensores . . . . . . . . . . . . . . . . . . . 43
Figura 30 – Tela do Google Sites . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Figura 31 – Campo de Gráficos do Google Site . . . . . . . . . . . . . . . . . . 45
Figura 32 – Visualização do Site . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Figura 33 – Publicar Site . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Figura 34 – Site Publicado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Figura 35 – Criando projeto na GCP . . . . . . . . . . . . . . . . . . . . . . . . 47
Figura 36 – Criando Credencial . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Figura 37 – Criando Credencial: Chave de API . . . . . . . . . . . . . . . . . . 49
Figura 38 – Criando Chave de API . . . . . . . . . . . . . . . . . . . . . . . . . 49
Figura 39 – Acessando a biblioteca de API’s . . . . . . . . . . . . . . . . . . . 50
Figura 40 – Acessando API do Google Sheets . . . . . . . . . . . . . . . . . . . 51
Figura 41 – Ativando API do Google Sheets . . . . . . . . . . . . . . . . . . . . 51
Figura 42 – Criando uma planilha do Google . . . . . . . . . . . . . . . . . . . 52
Figura 43 – Salvando Link da Planilha . . . . . . . . . . . . . . . . . . . . . . . 52
Figura 44 – Alterando API e Link da Planilha . . . . . . . . . . . . . . . . . . . 55
Figura 45 – Tela de API e Link da Planilha . . . . . . . . . . . . . . . . . . . . 55
Figura 46 – Saída do monitor serial mostrando o acesso negado . . . . . . . . . 56
Figura 47 – Tela para compartilhar link . . . . . . . . . . . . . . . . . . . . . . 57
Figura 48 – Definir o link público . . . . . . . . . . . . . . . . . . . . . . . . . 57
Lista de tabelas
Sumário
Lista de ilustrações . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Lista de tabelas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Sumário . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1 INTRODUÇÃO E OBJETIVOS . . . . . . . . . . . . . . . . . . . 7
2 ATIVIDADES - ESP 32 . . . . . . . . . . . . . . . . . . . . . . . 9
2.1 ESP32: Interface com Arduino . . . . . . . . . . . . . . . . . . . 9
2.2 IoT no Google Sheets - Serviço IFTTT . . . . . . . . . . . . . . . 15
2.3 Google Sheets - Escrita de Banco de Dados IoT . . . . . . . . . . 25
2.3.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.3.2 Tutorial - Criando Formulário e Planilha . . . . . . . . . . . . . . . 26
2.3.3 Tutorial - Programação ESP32 . . . . . . . . . . . . . . . . . . . . 30
2.4 Google Sheets - Integração de Sensores . . . . . . . . . . . . . . . 36
2.4.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.4.2 Tutorial - Escrita no Google Sheets . . . . . . . . . . . . . . . . . . 36
2.5 Google Sites - Integração com ESP32 . . . . . . . . . . . . . . . . 43
2.5.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
2.5.2 Tutorial - Google Sites . . . . . . . . . . . . . . . . . . . . . . . . . 43
2.6 Google Sheets - Leitura de Banco de Dados IoT . . . . . . . . . . 47
2.6.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.6.2 Tutorial - Criando Planilha . . . . . . . . . . . . . . . . . . . . . . 47
2.6.3 Tutorial - Programação ESP32 . . . . . . . . . . . . . . . . . . . . 52
REFERÊNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
1 Introdução e Objetivos
Um dos tópicos mais discutidos em Tecnologia da Informação nos últimos anos

é o de Internet of Things (IoT) ou, em português, Internet das Coisas. O conceito
por trás desse tópico é a ideia de conexão de diversos aparelhos e equipamentos à
internet, de forma a aumentar as possibilidades em torno do mesmo. A IoT pode
ser utilizada em vários segmentos: automação residencial, monitoramento e atuação
industrial, mobilidade urbana, entre muitos outros.
O objetivo por trás desse trabalho é apresentar algumas utilizações de IoT desde
a sua fase de implementação até sua utilização de fato. Por se tratar de um campo
extremamente vasto e, portanto, com inúmeros métodos de implementação possíveis, o
foco será dado na utilização da ferramenta Arduino, pela sua maior simplicidade e alta
documentação sobre o tema sem perder, claro, a qualidade do aprendizado em torno do
conceito de IoT.
O módulo utilizado será o ESP32. O ESP32 possui diversos recursos que o
colocam como um dos melhores módulos para se trabalhar com IoT. Dentre eles está
suas comunicações WiFi no padrão 802.11 e Bluetooth Low Energy, que possibilitam a
conexão com a internet e com vários dispotivos. Para interação com sensores e aturadores,
o módulo possui ainda 34 GPIO’s programáveis que contém 18 canais ADC de 12-bits, 2
canais DAC de 8-bits, 10 canais para sensores de toque, 4 canais para comunicação SPI,
2 canais I²S, 2 canais I²C, 3 canais UART, entre outros. Para mais informações sobre o
hardware do módulo ESP32, consulte a referência (Espressif Systems, 2019).
Além de suas características de hardware, o módulo ESP32 pode ter seu software
programado através da Interface de Desenvolvimento do Arduino, que possui diversas
bibliotecas que permitem uma fácil interação entre o módulo e muitos sensores comuns
no mercado.
7
2 Atividades - ESP 32
2.1 ESP32: Interface com Arduino

Para realizar a conexão do ESP32 com a interface de desenvolvimento do Arduino,
deve-se seguir alguns passos.
1. Instalar Arduino IDE.
• De acordo com a versão do seu computador (x64 para 64 bits e x86 para 32
bits), baixe a Arduino IDE em <https://www.arduino.cc/en/main/software>.
Figura 1 – Download da Arduino IDE
• Abrir o Arduino IDE.
2. Configurando o IDE do Arduino.
• Faça o download dos arquivos através do link: <https://github.com/espressif/

arduino-esp32>.
9
Figura 2 – Arquivos para configuração da Placa do ESP32
• Descompacte o arquivo e copie o conteúdo para o seguinte caminho: <C:

/Users/[YOUR_USER_NAME]/Documents/Arduino/hardware/espressif/esp32>.
Obs: caso não exista o diretório “espressif” e “esp32”, basta criá-los normal-
mente.
• Abra o diretório: <C:/Users/[YOUR_USER_NAME]/Documents/Arduino/

hardware/espressif/esp32/tools>. Execute o arquivo “get.exe”.
• Após a finalização do “get.exe”, plugue o ESP32, aguarde os drivers serem

instalados (ou instale manualmente).
3. Instalação Manual do Driver do CP2102.
• Baixar o Driver em <https://www.silabs.com/products/development-tools/

software/usb-to-uart-bridge-vcp-drivers> de acordo com o seu sistema ope-
racional.
Figura 3 – Download do Driver para o ESP32
• Abrir o Zip após o download.

• De acordo com o seu computador, executar o arquivo <CP210xVCPInstaller_
x64.exe> ou <CP210xVCPInstaller_x86.exe>.
4. Selecionar Placa: Na IDE do Arduino, abra a aba Ferramentas, selecione "Placa"e

escolha "ESP32 Dev Module".
Figura 4 – Selecionado a placa do ESP32
5. Crie seu código no Diretório <C:/Users/[YOUR_USER_NAME]/Documents/

Arduino>.
6. Utilize o código abaixo para verificar as redes ao seu redor e testar seu módulo.
OBS: Modificar a linha <#includeC:/Users/ [YOUR_USER_NAME]/Documents/
Arduino/ hardware/ espressif/ esp32/ libraries/ WiFi/ src/ WiFi.h> com o seu nome
de usuário.
1 /*
2 * This sketch demonstrates how to scan WiFi networks.
3 * The API is almost the same as with the WiFi Shield library,
4 * the most obvious difference being the different file you need to include:
5 */
6 #include <Wifi.h>
7
8 String redeSSID = "";
9 int intensidadeSinal = −9999;
10
11 void setup()
12 {
13 // Instrucao para inicializar o Serial
14 // Utilizaremos apenas para log no monitor.
15 Serial.begin(115200);
16
17 // configurando o modo de operacao do WiFi como estacao
18 WiFi.mode(WIFI_STA);
19
20 // desconecta do access point caso ele ja esteja conectado
21 WiFi.disconnect(); //WIFI_STA eh uma constante que indica o modo estacao
22 delay(100);
23 }
24
25 void loop()
26 {
27 // Serial.println("scan start");
28
29 //realiza o escaneamento das redes disponiveis
30 int n = WiFi.scanNetworks();
31 Serial.println("Escaneamento realizado");
32
33 //verifica se encontrou alguma rede
34 if (n == 0) {
35 Serial.println("Nenhuma rede encontrada");
36 } else {
37 redeSSID = "";
38 intensidadeSinal= −9999;
39 Serial.print(n);
40 Serial.println(" redes encontradas\n");
41 for (int i = 0; i < n; ++i) {
42 // imprime no log cada uma das redes encontradas
43 Serial.print("SSID: ");
44 Serial.println(WiFi.SSID(i)); //nome da rede
45 Serial.print("SINAL: ");
46 Serial.print(WiFi.RSSI(i)); //intensidade do sinal
47 Serial.print("\t\tcanal: ");
48 Serial.print((int)WiFi.channel(i));
49 Serial.print("\t\tMAC: ");
50 Serial.print(WiFi.BSSIDstr(i));
51 Serial.println("\n\n");
52
53
54
55 if(abs(WiFi.RSSI(i)) < abs(intensidadeSinal))
56 {
57 intensidadeSinal = WiFi.RSSI(i);
58 redeSSID = WiFi.SSID(i);
59 Serial.print("REDE COM MELHOR SINAL ENCONTRADA: ( ");
60 Serial.print(redeSSID);
61 Serial.print(" ) − SINAL : ( ");
62 Serial.print(intensidadeSinal );
63 Serial.println(" )");
64 }
65
66 delay(10);
67 }
68 }
69 Serial.println("\n−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\n");
70
71 // deixa um intervalo de 10 segundos para fazer um novo escaneamento
72 delay(5000);
73 }
Listing 2.1 – Teste da Conexão Wi-Fi do ESP32

2.2 IoT no Google Sheets - Serviço IFTTT
Nessa seção, será realizada a integração do módulo ESP32 com as planilhas do
Google. A integração direta com o Google Planilhas exige uma certificação HTTPS. Uma
maneira simples de realizar isso é através de um intermediário. Nesse caso, utilizou-se o
IFTTT. A documentação dessa seção foi baseada em (RANDOMNERD, 2019).
O IFTTT ("If This Then That" - "Se isso acontecer, então faça aquilo"em tradução
livre) é um serviço para Web, Android e iOS que permite a conexão de várias contas
diferentes. É possível, por exemplo, tirar uma foto no Instagram e salvá-la automatica-
mente no Dropbox usando o IFTTT como intermediário. Além disso, o serviço tem forte
aplicação em IoT, pois possibilita a conexão de dispotivos a serviços como o Google
Planilhas.
Para utilizar a ferramenta, deve-se primeiro criar uma conta no IFTTT (ifttt.com),
que é gratuita. Em seguida, vamos criar um applet, um pequeno software que vai executar
uma atividade específica que, no caso, é a integração entre o dispositivo e o Google
Planilhas.
1. Clique no ícone da sua conta e em "Create".
2. Clique no ícone +This, conforme figura 5.
Figura 5 – Ícone do IFTTT
3. Procure pelo serviço Webhooks e em seguida selecione o trigger "Receive a web

request".
Figura 6 – Ícone do Webhooks
4. Defina o nome do evento. Nesse exemplo, será definido como "Sensor_TempUmi".
5. Terminada a definição do serviço primário, clique em +That, conforme a figura 5.

Procure pelo Google Sheets e defina a ação "Add a row to spreadsheet"(Adicionar
uma linha à planilha).
6. Complete os campos de ação conforme a figura 7. O primeiro campo é o nome da

sua planilha. O segundo será o formato da linha. No exemplo, está configurado
para escrever, por coluna, o tempo quando ocorreu a atualização, o nome do evento
(no caso, "Sensor_TempUmi") e os valores vindos do sensor. É possível adicionar
ou remover valores. O terceiro e último campo é o diretório do seu Google Drive
onde será salva a planilha. O valor default será mantido.
Figura 7 – Campos de Ação do Google Sheets no IFTTT
7. Vá novamente para a página do Webhooks Service e clique no botão Documenta-

tion. Abrirá uma página conforme a figura 8. Anota sua chave de API exclusiva,
digite o nome do seu evento no link e os valores desejados para testar a conexão.
Figura 8 – Teste do IFTTT
8. Entre no diretório direcionado no seu Google Drive e verifique se está funcionado.
Antes de escrever o código do sensor, deve-se instalar algumas bibliotecas na

IDE do Arduino. São elas:
• DHT sensor library by Adafruit
• ArduinoJSon by Benoit Blanchon
Instaladas as bibliotecas, basta utilizar o código abaixo, alterando os campos:
• SSID_DA_REDE;
• SENHA_DA_REDE;
• resource = /trigger/NOME_DO_EVENTO/with/key/CHAVE_DE_API.
OBS: O item resource pode ser retirado do link obtido na figura 8.

1 /*
2 * Rui Santos
3 * Detalhes completos do projeto: http://randomnerdtutorials.com
4 * Adaptado por Dener Augusto de Lisboa Brandao (Agosto de 2019)
5 */
6 #include <WiFi.h>
7 #include "DHT.h"
8
9 #define DHTPIN 2 // Conectar o pino de dados do DHT11 no pino 2 da placa ESP32
10
11 // Definir o tipo de DHT. No caso, DHT11
12 #define DHTTYPE DHT11 // DHT 11
13 //#define DHTTYPE DHT22 // DHT 22 (AM2302)
15
16 // Inicializar o DHT11
17 DHT dht(DHTPIN, DHTTYPE);
18
19 // Troque pela SSID e senha da sua rede.
20 const char* ssid = "SSID_DA_REDE";
21 const char* password = "SENHA_DA_REDE";
22
23 // Troque por sua URL com a chave API unica e evento
24 const char* resource = "/trigger/NOME_DO_EVENTO/with/key/CHAVE_DE_API";
25
26 // Maker Webhooks IFTTT
27 const char* server = "maker.ifttt.com";
28 uint64_t uS_TO_S_FACTOR = 1000000; // Fator de conversao de microssegundos para
˓→ segundos
29 // Dormir por 30 minutos = 1800 segundos
30 uint64_t TIME_TO_SLEEP = 30;
31
32 void setup() {
33 Serial.begin(9600); // Define a velocidade de comunicacao com a porta serial.
34 initWifi(); // Funcao que inicializa a conexao Wi−fi
35 Serial.println("DHTxx test!");
36 dht.begin();
37 //Realiza a requisicao no IFTTT para escrita no Google Sheets caso esteja conectado.
38 if(WiFi.status() == WL_CONNECTED) {
39 makeIFTTTRequest();
40 }
41 // Habilita o timer para dormir
42 esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
43 Serial.println("\nVou dormir! Desligue a luz, por favor! ZzZzZ...");
44 esp_deep_sleep_start();
45 }
46
47 void loop() {
48 }
49
50 // Estabelece a conexao Wi−Fi com o roteador.
51 void initWifi() {
52 Serial.print("Conectando a rede ");
53 Serial.print(ssid);
54 WiFi.begin(ssid, password);
55
56 int timeout = 10 * 4;
57 while(WiFi.status() != WL_CONNECTED && (timeout−− > 0)) {
58 delay(250);
59 Serial.print(".");
60 }
61 Serial.println("");
62
63 if(WiFi.status() != WL_CONNECTED) {
64 Serial.println("Falha na conexao! Voltando a dormir... ZzZzZ");
65 }
66 else {
67 Serial.print("WiFi conectado em ");
68 Serial.print(millis());
69 Serial.print(", Endereco IP: ");
70 Serial.println(WiFi.localIP());
71 }
72 }
73
74 // Realiza uma requisicao HTTP no servidor Web IFTTT
75 void makeIFTTTRequest() {
76 delay(2000);
77
78 //Faz a leitura da temperatura e da umidade do sensor
79 float umid = dht.readHumidity();
80 float temp = dht.readTemperature();
81
82 if (isnan(umid) || isnan(temp)) {
83 Serial.println("Failed to read from DHT sensor!");
84 return;
85 }
86 else { // Verifica se houve falha na conversao
87 Serial.print("Conversao do sensor realizada com sucesso!");
88 Serial.print("Conectando ao servidor ");
89 Serial.print(server);
90
91 WiFiClient client;
92 int retries = 5;
93 // Realiza a conexao com o servidor Web do IFTTT.
94 while(!!!client.connect(server, 80) && (retries−− > 0)) {
96 }
97 Serial.println();
98 if(!!!client.connected()) {
99 Serial.println("Falha ao conectar ao servidor!");
100 }
101
102 Serial.print("Request resource: ");
103 Serial.println(resource);
104 // Estabelece o objeto JSon que contem os dados do sensor.
105 String jsonObject = String("{\"value1\":\"") + String(temp) + "\",\"value2\":\"" + String(umid)
˓→ + "\"}";
106
107 // Realiza a requisicao HTTP e posta o objeto Json.
108 client.println(String("POST ") + resource + " HTTP/1.1");
109 client.println(String("Host: ") + server);
110 client.println("Connection: close\r\nContent−Type: application/json");
111 client.print("Content−Length: ");
112 client.println(jsonObject.length());
113 client.println();
114 client.println(jsonObject);
115
116 int timeout = 5 * 10; // 5 seconds
117 while(!!!client.available() && (timeout−− > 0)){
118 delay(100);
119 }
120 if(!!!client.available()) {
121 Serial.println("Sem resposta...");
122 }
123 while(client.available()){
124 Serial.write(client.read());
125 }
126
127 Serial.println("\nFechando conexao...");
128 client.stop();
129 }
130 }
Listing 2.2 – Código ESP32 com GSheets
Conecete o sensor após a gravação! Realizada a etapa de criação do serviço

intermediário e gravado o código, será feita a montagem do sensor, conforme figura 9 e a
programação do módulo ESP32. O sensor utilizado será o DHT11 e o resistor será de
4k7Ω) ou próximo.
Figura 9 – Montagem do ESP32 com o sensor DHT11
Observe na sua planilha a atualização dos dados. Para acompanhar a execução

do ESP32, vá em Ferramentas -> Monitor Serial e selecione a mesma velocidade da
inicialização da Serial do ESP32 (no caso, 9600).
Figura 10 – Selecionando o Monitor Serial
Figura 11 – Selecionando a velocidade da porta serial
2.3 Google Sheets - Escrita de Banco de Dados IoT
2.3.1 Introdução
Na última seção, foi possível escrever nas planilhas do Google a partir do serviço
de IFTTT. E como seria feita uma leitura de ujma planilha a partir de um dispositivo
sensor? É possível realizar isso sem o intermediário IFTTT? A resposta é sim! Claro, se
não fosse, pra que começar essa seção, certo? :D
Primeiramente, vamos aprender a escrever no Google Sheets, utilizando o mesmo
como Banco de Dados. Um banco de dados é um conjunto de dados que, geralmente,
possuem um padrão e estão relacionados entre si. Dentre os bancos de dados mais conhe-
cidos, está o MySQL, por exemplo. E por que não utilizá-lo a princípio? Primeiramente,
o MySQL necessita de um servidor para hospedá-lo sempre conectado(o que gera custo),
enquanto o Google Sheets já possui um servidor próprio e muito robusto. Em segundo
lugar está a popularidade do mesmo: por se assemelhar muito ao Excel do MS Office,
o Google Sheets é uma ferramenta de fácil utilização para muitas pessoas. Em terceiro
lugar está a possibilidade fácil de compartilhamento entre usuários, tornando a solução
abrangente e modular.
Bom, para escrever no Google Sheets, vamos usar um outro intermediário, mas
dessa vez em um outro serviço do Google: o Google Forms. Associando um formulário
à uma planilha, consegue-se escrever nela sem problema. "Mas não seria sem um
intermediário?"Sim, é verdade! Porém, o Google Forms nos dá algumas vantagens
importantes! Uma delas é a possibilidade de controle online do formulário, regulando
quando será permitido a escrita no banco de dados sem que haja necessidade de se alterar
a planilha em si. Essa vantagem possibilita que não haja contato direto entre o sensor
e o banco de dados, trazendo segurança em caso de algum tipo de invasão com fins de
se alterar indevidamente os dados no banco. A outra vantagem é que o Google Forms
registra a data e a hora em que a escrita foi feita. Num mundo de sensores com baixo
consumo de energia, reduzir o processamento com Real Time Clock (RTC) e ter mais
espaço para envio de dados se tornam vantagens muito boas!
2.3.2 Tutorial - Criando Formulário e Planilha
O conteúdo desse tutorial foi baseado em (Vida de Silicio, 2017a).
1. Primeiramente, vá ao seu Google Drive e crie uma planilha. Coloque o nome que
desejar para a mesma.
Figura 12 – Criando uma planilha do Google
2. Em seguida, crie um formulário. Coloque o nome que achar melhor também.

Figura 13 – Criando um Formulário do Google
• Utilize a opção "Resposta Curta no formulário".
Figura 14 – Adicionando Resposta Curva ao Formulário

• Vá na aba "Respostas", clique nas três bolinhas e em "Selecionar destino da
Resposta"e selecione a planilha que acabou de criar..
Figura 15 – Vinculando a Planilha ao Formulário
• Por fim, clique no olho no canto superior direito para abrir o link do formulá-
rio. Uma tela como a 17 será aberta.
Figura 16 – Abrindo Link do Formulário

Figura 17 – Tela do Formulário
3. Responda seu formulário e verifique se o mesmo está escrevendo na planilha que

acabou de criar!
2.3.3 Tutorial - Programação ESP32

Feito isso, agora vamos escrever o código para ser compilado no ESP32!
1. Copie o código abaixo para a sua aplicação no Arduino. Não se esqueça de

modificar a SSID e Senha da sua rede!
1 /* Codigo desenvolvido por Jose Morais do portal.vidadesilicio.com.br (2017)

2 * e adaptado por Dener Brandao da Universidade Federal de Minas Gerais (2019)
3 */
4
5 #include <WiFi.h>
6 #include <WiFiClientSecure.h>
7 #include "DHT.h"
8
10
15
18
19
20 WiFiClientSecure client;//Cria um cliente seguro (para ter acesso ao HTTPS)
21 String textFix = "GET /forms/d/e/1
˓→ FAIpQLSfHVmSfkS3pfZc0arM6XU9eBRQE2_b7xEJKGDF1TRLB27ZUdw/
˓→ formResponse?ifq&entry.907560947=";
22 //Essa String sera uma auxiliar contendo o link utilizado pelo GET, para nao precisar ficar
˓→ re−escrevendo toda hora
23
˓→ segundos
27
28 const char* ssid = "SSID_DA_REDE";
30
31 void setup()
32 {
33 Serial.begin(9600); // Define a velocidade de comunicacao com a porta serial.
35 Serial.println("DHTxx test!");
36 dht.begin();
37 //Realiza a requisicao no IFTTT para escrita no Google Sheets caso esteja conectado.
39 makeWriteGSheets();
40 }
45 }
46
47 void loop() {
48 }
49
50
56
59 delay(250);
61 }
63
66 }
67 else {
72 }
73 }
74
75 void makeWriteGSheets(){
76
77 if (client.connect("docs.google.com", 443) == 1)//Tenta se conectar ao servidor do
˓→ Google docs na porta 443 (HTTPS)
78 {
82
84 Serial.println("Failed to read from DHT sensor!");
85 return;
86 }
87 String toSend = textFix;//Atribuimos a String auxiliar na nova String que sera
˓→ enviada
88 toSend += temp;//Adiciona−se o valor da temperatura
89 toSend += "&submit=Submit HTTP/1.1";//Completamos o metodo GET para nosso
˓→ formulario.
90
91 client.println(toSend);//Enviamos o GET ao servidor−
92 client.println("Host: docs.google.com");//−
93 client.println();//−
94 client.stop();//Encerramos a conexao com o servidor
95 Serial.println("Dados enviados.");//Mostra no monitor que foi enviado
96 }
97 else
98 {
99 Serial.println("Erro ao se conectar ao servidor!");//Se nao for possivel conectar no
˓→ servidor, ira avisar no monitor.
100 }
101 }
Listing 2.3 – Código ESP32 para escrita no GSheets
2. Abra seu formulário (no link de respostas) e copie todo o link entre <docs.google.
com> e </viewform>. Salve esse link.
Figura 18 – Link do Formulário

3. Clique com o botão direito onde é inserida a resposta e clique em "Inspecionar"ou
"Inspecionar Elemento (Q)", dependendo do seu navegador.
Figura 19 – Inspecionar Elemento
4. Aqui vamos pegar o número dessa entrada de resposta. Para isso, procure no
código fonte por algo semelhante ao exemplo: entry.473197392.
Figura 20 – Selecionar Elemento
5. Pegue estes dois links e altere apenas as partes destacadas na String textFix do
código, como mostram as figuras 21 e 22.
Figura 21 – Alteração da ID do formulário
Figura 22 – Alteração da Entrada de Dados do formulário
6. Realize a montagem da mesma forma mostrada na figura 9 e teste sua aplicação!
Pronto! Agora você criou um banco de dados que será alimentado pelo sensor de
temperatura acoplado ao ESP32!
DESAFIO: Anexe ao banco de dados um gráfico em linhas atualizado em tempo
real. Como seria possível colocar a umidade no banco de dados também? Faça isso e
anexe um gráfico para a umidade também!
2.4 Google Sheets - Integração de Sensores
2.4.1 Introdução
Em muitas aplicações em IoT é comum que um mesmo módulo possua vários
sensores e atuadores para realizar determinadas ações no sistema. Nessa etapa, faremos a
integração do ESP32 com o DHT11 (sensor de umidade e temperatura), o fototransistor
TCRT5000, muito utilizado em robôs seguidores de linha, por exemplo, e uma buzzer,
na qual iremos atuar.
2.4.2 Tutorial - Escrita no Google Sheets
1. Primeiramente, siga os mesmos passos da seção 2.3 para escrita na planilha. A

única mudança será na criação do formulário, no qual serão colocadas novas
opções de respostas.
Figura 23 – Adicionar novas perguntas ao Formulário
2. Copie o código abaixo para a nova aplicação.

3 */
4
5 #include <WiFi.h>
7 #include "DHT.h"
8
10 #define OpticSensor 5 // Conectar o pino de saida do TCRT5000 no pino 22 da placa
˓→ ESP32
11 #define Buzzer 22 // Define a buzzer como pino de saida 5
12
15
18
19 WiFiClientSecure client; //Cria um cliente seguro (para ter acesso ao HTTPS)
20
˓→ segundos
24
25 const char* ssid = "SSID_DA_REDE"; // Dados da Rede
27
28
29 //Essa String sera uma auxiliar contendo o link utilizado pelo GET, para nao precisar ficar
˓→ re−escrevendo toda hora
30 String textFix = "GET /forms/d/e/1
˓→ FAIpQLSc7rgbi0bS4YDoI202umyG2Us9vnSq95g73Hu2QJ−RcNdoXBA/
˓→ formResponse?ifq";
31 String textFix1 = "&entry.1028824396="; //Entrada da primeira pergunta
32 String textFix2 = "&entry.439146048="; // Entrada da segunda pergunta
33 String textFix3 = "&entry.2063687865="; // Entrada da terceira pergunta
34
35 void setup()
36 {
37 Serial.begin(9600);//Inicia a comunicacao serial
38 pinMode(OpticSensor, INPUT); // Pino para ler o sinal no coletor do fototransistor do
˓→ TCRT5000
39 pinMode(Buzzer,OUTPUT); // Pino para comandar a buzzer (logica inversa)
40 digitalWrite(Buzzer,HIGH); // Inicializando a buzzer desligada
41
43 Serial.println("Testando DHT11");
44 dht.begin();
46 makeWriteGSheets();
47 }
52 }
53
59
62 delay(250);
64 }
66
69 }
70 else {
75 }
76 }
77
78 void loop(){
79 }
80
81 void makeWriteGSheets()
82 {
83 String obst;
84
85 if (client.connect("docs.google.com", 443) == 1)//Tenta se conectar ao servidor do
˓→ Google docs na porta 443 (HTTPS)
86 {
87 boolean leituraSensor = digitalRead(OpticSensor); // Realiza a leitura do
˓→ fototransistor para verificar alguma obstrucao
88
92
94 Serial.println("Falha ao ler o sensor DHT");
95 return;
96 }
97 else{
98 String toSend = textFix;//Atribuimos a String auxiliar na nova String que sera
˓→ enviada
99 toSend += textFix1;
100 toSend += temp;//Adiciona−se o valor da temperatura
101 toSend += textFix2; //Adiciona−se a entrada da segunda resposta do formulario
102 toSend += umid; //Adiciona−se o valor da umidade
103 toSend += textFix3; //Adiciona−se a entrada da terceira resposta do formulario
104 toSend += leituraSensor; // Adiciona se ha obstrucao no momento da medida.
105 toSend += "&submit=Submit HTTP/1.1";//Completamos o metodo GET para
˓→ nosso formulario.
106
107 client.println(toSend);//Enviamos o GET ao servidor−
108 client.println("Host: docs.google.com");//−
109 client.println();//−
110 client.stop();//Encerramos a conexao com o servidor
111 Serial.println("Dados enviados!");//Mostra no monitor que foi enviado
112 digitalWrite(Buzzer,LOW); // A buzzer atuara caso os dados sejam enviados.
113 delay(500);
114 digitalWrite(Buzzer,HIGH);
115 }
116 }
117 else {
118 Serial.println("Erro ao se conectar ao servidor! Tente novamente!"); //Se nao for
˓→ possivel conectar no servidor, ira avisar no monitor.
119 }
120 }
Listing 2.4 – Código para gravação no Arduino da escrita de múltiplos

sensores
3. Abra seu formulário (no link de respostas) e copie todo o link entre <docs.google.com>
e </viewform>. Salve esse link.
Figura 24 – Link do Formulário
4. Em seu formulário, clique com o botão direito onde é inserida a resposta e clique
em "Inspecionar"ou "Inspecionar Elemento (Q)"dependendo do seu navegador.
Figura 25 – Inspecionar Elemento
5. Aqui vamos pegar o número dessa entrada de resposta. Para isso, procure no
código fonte por algo semelhante ao exemplo: entry.473197392.
Figura 26 – Selecionar Elemento
6. Repita o procedimento para as outras duas respostas do formulário. Faça a modifi-

cação no código como mostra a figura abaixo.
Figura 27 – Alteração no Código para múltiplas respostas
7. Realize a montagem conforme a figura 28.
Figura 28 – Esquema para montagem de múltiplos sensores
Pronto! Com isso, o módulo ESP32 agora é responsável por coletar 3 medidas
(temperatura, umidade e tempo entre detecções de obstrução do fototransistor) e possui
um atuador (buzzer).
2.5 Google Sites - Integração com ESP32
2.5.1 Introdução
Com o único módulo, é possível realizar diversas medições e colocar os dados
na rede. Com as planilhas do Google, pode-se ter um pequeno banco de dados. Po-
rém, tais dados possuem visualização muitas vezes complicada, tornando complexa e
desinteressante para o cliente. Dessa forma, colocar os dados em formas de gráficos e
disponibilizar em sites é uma ótima alternativa!
O Google Sites é uma ferramenta simples e com fácil integração com outros
serviços do Google. Nessa atividade, será criado um site que permitirá a visualização
dos dados das planilhas em forma gráfica, para acompanhamento remoto.
2.5.2 Tutorial - Google Sites
1. Primeiramente, crie gráficos em sua planilha dos sensores relacionado o horário e

as medidas.
Figura 29 – Gráficos na Planilha de Sensores

2. Acesse o link <https://sites.google.com/new> e clique no símbolo de + no canto
inferior direito da tela para criar um novo site.
3. Uma tela conforme a figura 30 será aberta em seguida.
Figura 30 – Tela do Google Sites
4. Na coluna da direita, tem-se 3 campos. O campo "Inserir"permite inserir no seu

site textos, imagens, incorporar links e elementos do Google Drive, entre várias
opções, além de determinar os layouts para seu site. No campo "Páginas", pode-se
criar novas páginas ao seu site. Por fim, no campo "Temas", é possível definir um
tema ao seu gosto para o site.
5. No campo "Inserir", desça a barra de rolagem até a opção "Gráficos"

Figura 31 – Campo de Gráficos do Google Site
6. Selecione a sua planilha dos sensores. Selecione um dos gráficos e repita o

procedimento para os outros. Distribua-os da maneira que achar melhor.
7. Altere os dados do seu site da maneira que achar adequada.
8. Visualize o seu site clicando no botão "Visualizar"no canto superior direito da tela.
Figura 32 – Visualização do Site
9. Feche a tela de visualização e clique em publicar. Nessa etapa, é possível adicionar

domínios próprios, mas, no momento, o site será adicionado no próprio servidor
do Google. Defina o endereço da Web do seu site e publique-o!
Figura 33 – Publicar Site
10. Entre em seu domínio e veja seu site publicado!
Figura 34 – Site Publicado

Com isso, seus dados terão uma visualização mais amigável para os usuários,
além de ter fácil acesso!
2.6 Google Sheets - Leitura de Banco de Dados IoT
2.6.1 Introdução
Agora que já aprendemos a escrever nas planilhas do Google, vamos aprender
a ler os dados delas! Para realizar isso, vamos utilizar uma API do Google na sua
plataforma de desenvolvimento: a Google Cloud Platform.
A Google Cloud Platform (GCP) é uma plataforma de desenvolvimento que
integra diversos serviços do Google, possibilitando recursos para criação de aplicati-
vos, análise de dados, aprendizagem de máquina, dentre outros! Para essa aplicação,
utilizaremos uma API, como pode ser vista no tutorial abaixo.
2.6.2 Tutorial - Criando Planilha

O tutorial a seguir foi baseado em (Vida de Silicio, 2017b).
1. Entre na plataforma de gerenciamento de API’s da Google: https://console.developers.google.com/apis,

crie um novo projeto e de um nome qualquer. Este projeto será apenas para “guar-
dar” sua chave com a respectiva API, neste caso, Google Planilhas.
Figura 35 – Criando projeto na GCP

2. Vá em "Credenciais"e "Crie uma Chave de API".
Figura 36 – Criando Credencial

Figura 37 – Criando Credencial: Chave de API
Figura 38 – Criando Chave de API

3. Volte para a página inicial do Google APIs, clique em “Biblioteca“, selecione
“Google Sheets API” e “Ativar“.
Figura 39 – Acessando a biblioteca de API’s

Figura 40 – Acessando API do Google Sheets
Figura 41 – Ativando API do Google Sheets
4. Vá ao seu Google Drive e crie uma planilha. Coloque o nome que desejar para a
mesma.
Figura 42 – Criando uma planilha do Google
5. Salve o link da planilha criada.
Figura 43 – Salvando Link da Planilha
Pronto! Estamos prontos para ler as Planilhas do Google!
2.6.3 Tutorial - Programação ESP32

Agora faremos a programação do ESP32 para realizar a leitura dos dados.
1. Copie o código abaixo para sua aplicação no Arduino. Não se esquecer de alterar
a SSID e Senha da Rede!
3 */
4
5 #include <WiFi.h>
7
8 WiFiClientSecure cl;//Cria um cliente seguro (para ter acesso ao HTTPS)
9 String textFix = "GET /v4/spreadsheets/[SEU_LINK_DA_PLANILHA]/values/";
10 String key = "?key=[SUA_CHAVE_DE_API]";//Chave de API
11 //Essas Strings serao auxiliares, para nao precisar ficar re−escrevendo toda hora
12
13
14 void setup()
15 {
16 Serial.begin(115200);//Inicia a comunicacao serial
17 WiFi.mode(WIFI_STA);//Habilita o modo estacao
18 WiFi.begin("SSID_DA_REDE", "SENHA_DA_REDE");//Conecta na sua rede
19 delay(3000);//Espera um tempo para se conectar no WiFi
20 while (WiFi.status() != WL_CONNECTED)
21 {
23 delay(500);
24 }
25
26 //Se chegou aqui esta conectado
27 Serial.println();
28 Serial.println("Connected");
29
30 }
31
32 void loop()
33 {
34
35 if (cl.connect("sheets.googleapis.com", 443) == true)//Tenta se conectar ao servidor do
˓→ Google APIs na porta 443 (HTTPS)
36 {
37 String toSend = textFix; //Atribuimos a String auxiliar na nova String que sera
˓→ enviada
38
39 toSend += "C2:C5";//Os valores que queremos ler da planilha. Para uma unica celula,
˓→ use algo como "A2"; para ler varios, use algo como "A1:C4".
40 toSend += key;//Adicionamos a chave na String
41 toSend += " HTTP/1.1";//Completamos o metodo GET para nosso formulario.
42
43 cl.println(toSend);//Enviamos o GET ao servidor−
44 cl.println("Host: sheets.googleapis.com");//−
45 cl.println();//−
46
47
48 Serial.println("Dado recebido:\n");
49 //Serial.print(cl.readString()); //Mostra no Serial Monitor todo o pacote recebido.
50 String dados_rec = cl.readString(); // A partir daqui pegaremos apenas os valores
˓→ contidos nas celulas.
51 String string_local = "values"; // Define a string a ser localizada no pacote para
˓→ realizar a contagem a partir dela.
52 int indice_valor = dados_rec.indexOf(string_local); // Procura o indice do pacote em
˓→ que esta localizada a string.
53 dados_rec.replace("'",""); // Retira−se os caracteres indesejados dos valores
54 dados_rec.replace("[","");
55 dados_rec.replace("]","");
56 dados_rec.replace(",","");
57 dados_rec.replace("}","");
58 dados_rec.replace("{","");
59 dados_rec.replace("\n"," ");
60 dados_rec.replace("''"," ");
61
62 Serial.print(dados_rec.substring(indice_valor+8)); // Mostra no Serial apenas os
˓→ valores apos "values".
63
64 cl.stop();//Encerramos a conexao com o servidor.
65 }
66 else
67 {
68 Serial.println("Erro ao se conectar");
69 }
70 delay(10000); // Aguarda 10 segundos para ler novamente.
71
72 }
Listing 2.5 – Código ESP32 para leitura no GSheets
2. Altere os itens [SUA_CHAVE_DE_API] e [SEU_LINK_DA_PLANILHA] com

os links salvos na sub-seção 2.6.2.
Figura 44 – Alterando API e Link da Planilha
O resultado deve ser algo semelhante a figura 45 abaixo.
Figura 45 – Tela de API e Link da Planilha
3. Quando testar o código, verá que não tem permissão para acessar a planilha, como
mostra a figura 46 abaixo. Essa é uma proteção possível com as Planilhas do
Google. A chave de API deve estar com link público. É possível adicionar mais
segurança utilizando recursos de autenticidade por e-mail. Porém, vamos utilizar
algo mais simples.
Figura 46 – Saída do monitor serial mostrando o acesso negado
4. Entre na sua planilha e clique em "Compartilhar"no canto superior direito e, em

seguida, em avançado.
Figura 47 – Tela para compartilhar link
5. Clique em "Alterar...", defina "Ativado: qualquer pessoa com link” e salve.
Figura 48 – Definir o link público
Agora você poderá ler os valores escritos nas células definidas no seu programa!
DESAFIO: Aumente a segurança do seu programa colocando credenciais para
e-mails e não mais link público.
Referências
Espressif Systems. ESP32 Series Datasheet. 2019. Disponível em: <https:

//www.espressif.com/sites/default/files/documentation/esp32\_datasheet\_en.pdf>.
Citado na página 7.
RANDOMNERD. ESP32 Publish Sensor Readings to Google Sheets

(ESP8266 Compatible). 2019. Disponível em: <https://randomnerdtutorials.
com/esp32-esp8266-publish-sensor-readings-to-google-sheets/>. Citado na página 15.
Vida de Silicio. Banco de dados com Google planilhas – ESP. 2017. Disponível em:
<https://portal.vidadesilicio.com.br/banco-de-dados-com-google-planilhas-com-esp>.
Citado na página 26.
Vida de Silicio. Lendo dados do Google planilhas com ESP - Banco

de dados. 2017. Disponível em: <https://portal.vidadesilicio.com.br/
lendo-dados-do-google-planilhas-banco-de-dados>. Citado na página 47.
59

Tutorial - IoT Coltec - DS

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Tutorial - IoT Coltec - DS

Enviado por

Direitos autorais:

Formatos disponíveis

C OLÉGIO T ÉCNICO DA U NIVERSIDADE F EDERAL DE M INAS

Tutorial - IoT Coltec

Dener Augusto de Lisboa Brandão

Figura 1 – Download da Arduino IDE . . . . . . . . . . . . . . . . . . . . . . 9

2.1 ESP32: Interface com Arduino . . . . . . . . . . . . . . . . . . . 9

2.2 IoT no Google Sheets - Serviço IFTTT . . . . . . . . . . . . . . . 15

2.3 Google Sheets - Escrita de Banco de Dados IoT . . . . . . . . . . 25

2.3.2 Tutorial - Criando Formulário e Planilha . . . . . . . . . . . . . . . 26

2.3.3 Tutorial - Programação ESP32 . . . . . . . . . . . . . . . . . . . . 30

2.4 Google Sheets - Integração de Sensores . . . . . . . . . . . . . . . 36

2.4.2 Tutorial - Escrita no Google Sheets . . . . . . . . . . . . . . . . . . 36

2.5 Google Sites - Integração com ESP32 . . . . . . . . . . . . . . . . 43

2.5.2 Tutorial - Google Sites . . . . . . . . . . . . . . . . . . . . . . . . . 43

2.6 Google Sheets - Leitura de Banco de Dados IoT . . . . . . . . . . 47

Um dos tópicos mais discutidos em Tecnologia da Informação nos últimos anos

2.1 ESP32: Interface com Arduino

1. Instalar Arduino IDE.

Figura 1 – Download da Arduino IDE

• Abrir o Arduino IDE.

2. Configurando o IDE do Arduino.

• Faça o download dos arquivos através do link: <https://github.com/espressif/

• Descompacte o arquivo e copie o conteúdo para o seguinte caminho: <C:

• Abra o diretório: <C:/Users/[YOUR_USER_NAME]/Documents/Arduino/

• Após a finalização do “get.exe”, plugue o ESP32, aguarde os drivers serem

3. Instalação Manual do Driver do CP2102.

• Baixar o Driver em <https://www.silabs.com/products/development-tools/

• Abrir o Zip após o download.

4. Selecionar Placa: Na IDE do Arduino, abra a aba Ferramentas, selecione "Placa"e

Figura 4 – Selecionado a placa do ESP32

5. Crie seu código no Diretório <C:/Users/[YOUR_USER_NAME]/Documents/

Listing 2.1 – Teste da Conexão Wi-Fi do ESP32

1. Clique no ícone da sua conta e em "Create".

2. Clique no ícone +This, conforme figura 5.

Figura 5 – Ícone do IFTTT

3. Procure pelo serviço Webhooks e em seguida selecione o trigger "Receive a web

4. Defina o nome do evento. Nesse exemplo, será definido como "Sensor_TempUmi".

5. Terminada a definição do serviço primário, clique em +That, conforme a figura 5.

6. Complete os campos de ação conforme a figura 7. O primeiro campo é o nome da

7. Vá novamente para a página do Webhooks Service e clique no botão Documenta-

8. Entre no diretório direcionado no seu Google Drive e verifique se está funcionado.

Antes de escrever o código do sensor, deve-se instalar algumas bibliotecas na

• DHT sensor library by Adafruit

• ArduinoJSon by Benoit Blanchon

Instaladas as bibliotecas, basta utilizar o código abaixo, alterando os campos:

OBS: O item resource pode ser retirado do link obtido na figura 8.

Listing 2.2 – Código ESP32 com GSheets

Conecete o sensor após a gravação! Realizada a etapa de criação do serviço

Observe na sua planilha a atualização dos dados. Para acompanhar a execução

2.3 Google Sheets - Escrita de Banco de Dados IoT

2.3.2 Tutorial - Criando Formulário e Planilha

O conteúdo desse tutorial foi baseado em (Vida de Silicio, 2017a).

2. Em seguida, crie um formulário. Coloque o nome que achar melhor também.

• Utilize a opção "Resposta Curta no formulário".

Figura 14 – Adicionando Resposta Curva ao Formulário

Figura 15 – Vinculando a Planilha ao Formulário

Figura 16 – Abrindo Link do Formulário

3. Responda seu formulário e verifique se o mesmo está escrevendo na planilha que

2.3.3 Tutorial - Programação ESP32

1. Copie o código abaixo para a sua aplicação no Arduino. Não se esqueça de

1 /* Codigo desenvolvido por Jose Morais do portal.vidadesilicio.com.br (2017)

Listing 2.3 – Código ESP32 para escrita no GSheets

Figura 18 – Link do Formulário

Figura 19 – Inspecionar Elemento