• Introdução à estrutura da parte 1 e 2 desse capítulo;
• Introdução à biblioteca HTTPSRedirect.h;
• Criação das funções de setup e validação de requisições HTTP;
• Envio de payload json via requisição HTTP para o servidor Google Apps Script para armazenar dados em uma planilha (Google Sheets);

Começando agora oficialmente o ano de 2024 (ou será que só começa depois do carnaval? 🤔😂), vou também dar início à segunda parte do projeto: a etapa de organização e armazenamento dos dados!

Na primeira etapa, explorei algumas possibilidades da biblioteca FS.h para ESP8266, onde preparei o terreno para fazer uso de suas funcionalidades no projeto como forma de backup local do último dado de monitoramento do meu sistema para manter os dados sempre consistentes, mesmo em caso de queda de energia.

Nessa segunda etapa, irei utilizar a biblioteca HTTPSRedirect.h para realizar redirecionamentos HTTP pra poder me conectar ao servidores da Google e enviar meus dados para serem armazenados no sheets. Essa foi uma forma simples que encontrei de armazenar os dados fazendo requisições públicas em HTTP, atualizando uma tabela privada no Sheets.

Normalmente, para fazer um banco de dados simples, se usa o formato .csv, entretanto isso tornaria o projeto um pouco mais complexo, visto que a ideia é ter como utilizar os dados gerados pela ESP6 para fazer análise de dados em um computador, e exportar arquivos da SPIFFS para algum meio que disponibilizasse o download deste arquivo adiciona uma complexidade desnecessária.

Usando a HTTPSRedirect.h, eu posso simplesmente mandar os dados via requisição para um arquivo Sheets do Google via json e os dados já ficarão organizados lá.

Além disso, por estar usando um método de redirecionamento, eu não preciso registrar um API Token na minha conta Google para enviar os arquivos, apenas preciso autorizar as requisições vindas do meu dispositivo, que nesse caso, é uma ESP8266.

Introduções à parte, vamos ao que interessa. A estrutura do planejamento dessa primeira parte, que será executada pela ESP8266 é a seguinte:

• Primeiro eu preciso criar um objeto de redirecionamento;
• Depois, configurar a conexão com o servidor do host;
• Configurar a minha payload com os dados da leitura do sensor;
• E por fim, realizar o envio do payload;

Na segunda parte, irei preparar a recepção dos dados, que será feita pelo próprio Sheets. Para isso, utilizarei a plataforma Google Apps Script.

Para quem não conhece, o Google Apps Script é uma plataforma da Google que permite que você desenvolva scripts de automação ou até mesmo aplicações e extensões inteiras utilizando uma linguagem baseada no JavaScript. Essa plataforma é 100% integrada com a suíte Google, ou seja, você pode utilizá-la para desenvolver integrações com qualquer serviço da súite Google, como Google Drive, Google Docs, Google Sheets, Gmail, etc.

Nessa parte, que vai ficar para o próximo artigo, irei criar uma função que responde a uma requisição HTTP (realizada pela ESP), interpreta o conteúdo dessa requisição, e realiza o parsing dos dados que estão sendo recebidos e, ao final, adiciona esses dados na tabela.

Então vamos começar com o programa da ESP que realizará as requisições para os servidores da Google.

Primeiro, vou declarar o básico para utilizarmos a biblioteca:

#include "ESP8266WiFi.h"
#include "HTTPSRedirect.h"
const char* nome_wifi = "sua_rede_wifi";
const char* senha_wifi = "senha_rede_wifi";
HTTPSRedirect* cliente;

Além disso, vou também já criar algumas variáveis de apoio que irão armazenar informações importantes para o funcionamento das requisições:

String id_implementacao = "";
const char* host = "script.google.com";
const int porta_http = 443;

String payload_dados = "{\"command\": \"adicionar_linha\", \"sheet_name\": \"Página1\", \"values\": ";
String payload;
String url = "";
int sensor1 = 0;

Explicando um pouquinho sobre as variáveis:

• id_implementacao → o ID único da implementação do script do Google Apps Script a ser gerado na plataforma;
• host → host (duh) do Google Apps Script;
• porta_http → porta HTTP utilizada para as requisições/respostas;
• payload_dados → string contendo o json com as instruções que iremos enviar para o Google Apps Script (pode também ser feito de forma mais “bonitinha” utilizando ArduinoJson.h). na estrutura do json, eu utilizo a chave sheet_name como “Página1” pois esse é o nome default que uma planilha é criada no sheets;
• payload → payload final onde vou concatenar todos os dados que irei enviar junto com a variável payload_dados;
• url → url que irei criar concatenando a informação armazenada em id_implementacao. essa url é onde a requisição será feita pela ESP.
• sensor1 → variável que armazenará os dados de leitura do sensor (que nesse código, será simulado com a função random();

Aproveitando que ainda estou nos preparos iniciais, já criei a função que lidará com a conexão da ESP com a WiFi (de praxe, né?):

void setup_wifi(const char* rede, const char* senha) {
  WiFi.begin(rede, senha);
  Serial.println("");

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(". ");
  }

  Serial.println(" ");
  Serial.print("Conectado na rede: ");
  Serial.println(rede);
}

Agora vou destrinchar cada etapa do processo de redirecionamento HTTP.

1. Popular o objeto cliente e tentar conexão com o servidor:

void setup_http(HTTPSRedirect* cliente, int porta_http) {
  cliente = new HTTPSRedirect(porta_http);
  cliente->setInsecure();
  cliente->setPrintResponseBody(true);
  cliente->setContentTypeHeader("application/json");
  Serial.println("Conectando ao servidor Google. . .");

  bool flag = false;

  for (int i = 0; i < 5; i++) {
    int valor_retorno = cliente->connect(host, porta_http);

    if (valor_retorno == 1) {
      flag = true;
      Serial.println("Conectado ao servidor com sucesso.");
      break;
    } 
  else {
      Serial.println("Erro ao conectar no servidor.");
    }
  }

  if (!flag) {
    Serial.print("Erro ao conectar no host ");
    Serial.println(host);
  }

  delete cliente;
  cliente = nullptr;
}

Essa talvez seja a parte mais complicada do código, mas vamos lá.

Primeiro estou dizendo que minha variável cliente será um objeto do tipo HTTPSRedirect. Esse objeto passará por alguns settings através de alguns métodos. O método setInsecure() permite que eu realize a requisição sem precisar validá-la todas as vezes. A validação da requisição é realizada pelo id armazenado em id_implementacao. O método setPrintResponseBody() permite a impressão da resposta da requisição na porta serial da ESP, então podemos verificar as respostas de erro/sucesso sem precisar tratá-las no nosso código. Por fim, o método setContentTypeHeader() define padrão em que o header está sendo preenchido, que no nosso caso é no formato json.

Na segunda parte dessa função, o cliente tentará se conectar ao servidor. Coloquei em um for loop de 5 tentativas, mas você pode fazer com menos, com mais, ou nem tentar mais de uma vez também. E no fim, eu deleto o cliente e faço ele apontar para um espaço nulo.

Nessa parte final, eu preciso resetar o conteúdo do cliente, pois esse objeto é recriado e repopulado a cada chamada da próxima função (checa_conexao()), mas não entendi muito bem porque eu preciso resetar o e recriar o conteúdo desse objeto. Tentei de algumas formas realizar a persistência desse objeto, mas sempre acabava quebrando o código e causando um erro de memória, então… em time que tá ganhando não se mexe (por enquanto).

2. Checar e validar a conexão:

void checa_conexao(HTTPSRedirect* cliente, int porta_http) {
  static bool flag = false;

  if (!flag) {
    cliente = new HTTPSRedirect(porta_http);
    cliente->setInsecure();
    cliente->setPrintResponseBody(true);
    cliente->setContentTypeHeader("application/json");
    flag = true;
  }

  if (cliente != nullptr) {
    if (!cliente->connected()) {
      cliente->connect(host, porta_http);
    }
  } else {
    Serial.println("Erro ao conectar no servidor http");
  }
}

Essa função é quem valida a conexão antes de fazer o envio do payload para o host. Então inicio criando uma variável booleana que se torna true se o objeto cliente ainda não tiver sido corretamente criado ou populado. Caso ela já seja verdadeira, checamos se cliente está apontando para um ponteiro nulo (conforme fazemos no final da função setup_http()). Caso verdade, se checa se o cliente já está conectado. Caso não esteja, realiza a conexão.

3. Enviar o payload:

void envia_payload() {
  payload = payload_dados + "\"" + String(sensor1) + "\"}";

  if (cliente->POST(url, host, payload)) {
      Serial.println("Dados enviados para o servidor.");
    }    
    else {
      Serial.println("Erro ao enviar dados para o servidor.");
    }
}

Já essa função, tem como papel realizar o envio do payload. Caso a função setup_http() ou checa_conexao() falhem, obviamente a função envia_payload() não vai funcionar também.

Nessa função, eu concateno as informações da variável payload_dados com a leitura do sensor que será ralizada no void_loop(), e então faço uma requisição do tipo POST e passo como parâmetro as variáveis url, host, e payload.

Com essa primeira parte finalizada, basta organizarmos agora o código na estrutura da Arduino IDE, com o void_setup() e void_loop():

• Bibliotecas e variáveis:

#include "ESP8266WiFi.h"
#include "HTTPSRedirect.h"


// ## variaveis
unsigned long previousMillis = 0;
const char* nome_wifi = "sua_rede_wifi"; // alterar para uma rede wi-fi real
const char* senha_wifi = "senha_rede_wifi"; // alterar para a senha da rede wi-fi

HTTPSRedirect* cliente;

String pega_id_implementacao = ""; // alterar com id da implementação do Google Apps Script
String id_implementacao = "";

const char* host = "script.google.com";
const int porta_http = 443;
String payload_dados = "{\"command\": \"adicionar_linha\", \"sheet_name\": \"Página1\", \"values\": ";
String payload;
String url = "";
int sensor1 = 0;

observação: criei uma variável previousMillis para poder realizar um controle de tempo nas requisições sem usar interrupções com delay().

• void_setup():

void setup() {
  Serial.begin(9600);
  setup_wifi(nome_wifi, senha_wifi);  
  setup_http();
  checa_conexao();
}

No void_setup(), faço a conexão com a WiFi, o setup inicial da requisição e valido a conexão com o servidor.

• void_loop():

void loop() {
  sensor1 = random(0, 101);

  if (millis() - previousMillis >= 10000) {
    previousMillis = millis();
    checa_conexao();
    envia_payload();
  }
}

Aqui no void_loop(), atribuo um valor de leitura aleatório à minha variável sensor1 e determino o tempo em que irei executar as funções responsáveis para o envio do payload.

Finalizando então essa primeira parte sobre a biblioteca HTTPSRedirect.h, o código produzido é capaz de gerar dados aleatórios e enviá-los a cada 10 segundos para serem interpretados por um script (baseado no ID armazenado na variável id_implementacao) e serem dispostos na planilha.

Na parte 2 desse artigo, que irei postar até o fim da semana, pretendo demonstrar o processo de desenvolvimento e aplicação de um script no Google Apps Script para integrar a ESP com a minha planilha no sheets.

Lembrando que todos os códigos dessa segunda parte do projeto estão disponíveis no repositório do projeto em: ronaldneves/ESP8266_SHEETS.

Vejo vocês em breve e até logo!

Para finalizar o tema memória flash, o último mini-projeto desse primeiro capítulo que tem como objetivo armazenar algum dado para que, caso haja uma queda de energia, esse dado seja rapidamente recuperado.

A vantagem disso é que se torna possível recuperar uma variável de controle antes do sistema entrar no void loop().

Neste exemplo, criei uma variável chamada contador_evento, que serve para armazenar quantas vezes um tanque chegou ao nível mínimo durante o tempo em que a ESP ficou em operação. Porém, por se tratar de uma variável armazenada em memória dinâmica, ela se perde caso a ESP seja reiniciada, então fiz o código pensando em guardar e recuperar esse valor em caso de reinício.

Então vamos direto ao assunto.

Diferente do mini-projeto anterior, neste exemplo eu só utilizei a biblioteca FS.h mesmo, já que é um caso de uso mais simples.

Começando com a declaração de bibliotecas e variáveis:

#include "FS.h"


int leitura_sensor = 0;
int contador_evento = 0;
int comparador_evento = 1; // 1 significa tanque vazio. quero contar quantas vezes o tanque ficou vazio
unsigned long millis_sensor = 0;
unsigned long tempo_sensor = 2000;
unsigned long tempo_backup = 5000;
unsigned long millis_backup = 0;
const char* nome_do_arquivo = "/backup.txt";

Além da variável contador_evento, também adicionei uma variável de controle, que é a variável que será comparada com a leitura do sensor para que o sistema registre aquele evento. Como eu estou monitorando o tanque vazio, eu simulei a leitura do sensor com a função random() tendo como valores limite 1 e 3, ou seja, quando o sensor retornar 1, seria o equivalente ao evento que eu quero monitorar (tanque vazio).

As variáveis do tipo unsigned long serão utilizadas para controle do tempo de execução das rotinas. Eu escolhi 2000ms (ou 2s) como tempo de leitura do sensor e 5000ms (ou 5s) como tempo de backup.

Primeiro eu criei a função responsável por checar se já existe um arquivo de backup com dados disponíveis, de forma similar à forma que eu tratei os arquivos de log do projeto anterior (link caso queira dar uma olhada), então não vou entrar muito em detalhes. Mas basicamente, eu solicito uma busca pelo arquivo declarado na variável nome_do_arquivo e checo se há algum valor armazenado nele. Caso exista, eu converto essa variável em um tipo int e entrego como retorno da função.

int restaura_backup(const char* nome_do_arquivo, int contador) {
  if (SPIFFS.exists(nome_do_arquivo)) {
    Serial.println("Arquivo de backup encontrado. Restaurando valor do contador.");
    File backup = SPIFFS.open(nome_do_arquivo, "r");

    while(backup.available()) {
      String linha = backup.readStringUntil('\n');
      contador = linha.toInt();        
    }
  }
  return contador;
}

Essa conversão é importante pois, após o retorno da função, eu vou utilizar esse valor pra dar continuidade no meu contador de eventos.

Depois de checar se o arquivo de backup já existia, os próximos passos são: simular a leitura do sensor, realizar a contagem dos eventos e guardar esse dado no arquivo .txt.

Para simular o sensor, fiz uma simples função com random():

int simulador_sensor(int sensor) {
  sensor = random(1, 4); // 4 não incluso. ele conta de 1 a 3 (1, 2, 3)
  return sensor;
}

e para a função de registrar quando o tanque está vazio:

int contador(int sensor, int contador_evento, int comparador) {
  if (sensor == comparador) {
    contador_evento += 1;
    Serial.print("Evento detectado. ");
  }
  return contador_evento;
}

e por fim, a função responsável por fazer o backup:

void salva_backup(int contador, const char* nome_do_arquivo) {
  File backup = SPIFFS.open(nome_do_arquivo, "w");
  backup.println(contador);
  backup.close();

  Serial.println("Backup realizado com sucesso.");
}

Sendo assim, no void setup() eu inicializo a serial, a SPIFFS e chamo a função restaura_backup() para verificar se já tinha algum valor de backup na memória.

void setup() {
  Serial.begin(9600);
  SPIFFS.begin();
  contador_evento = restaura_backup(nome_do_arquivo, contador_evento);
}

E no void loop() eu adiciono os controles de tempo para leitura e para backup. Conforme declarado nas variáveis no começo do código, são 2000ms de tempo de espera para a leitura do sensor e 5000ms para que esse valor seja armazenado no arquivo de backup.

void loop() {
  if ((millis() - millis_sensor) > tempo_sensor) {
    millis_sensor = millis();
    leitura_sensor = simulador_sensor(leitura_sensor);
    Serial.print("Valor de leitura do sensor da caixa d'água: ");
    Serial.println(leitura_sensor);
    Serial.print("Valor do contador de eventos: ");
    contador_evento = contador(leitura_sensor, contador_evento, comparador_evento);
    Serial.println(contador_evento);
  } 

  if ((millis() - millis_backup) > tempo_backup) {
    millis_backup = millis();
    salva_backup(contador_evento, nome_do_arquivo);
  }
}

Com esse código, a cada 2 segundos a ESP requere um valor do nosso simulador, e a cada 5 segundos o backup do último valor retornado pelo simulador é armazenado num arquivo .txt. Em caso de reinício, o último valor salvo em backup é recuperado, permitindo que o sistema não perca esse dado e dê continuidade à contagem de eventos.

Lembrando que todos os códigos desse primeiro capítulo do projeto estão disponíveis no repositório do projeto em ronaldneves/ESP8266_SPIFFS!

No próximo capítulo, vou iniciar a integração da ESP com o Google Sheets, para que possamos armazenar e acessar os dados gerados de forma online.

Até logo e boas festas a todos!

Na última livestream que fiz na twitch, desenvolvi dois projetos de caso de uso prático para entendermos melhor como podemos utilizar a biblioteca FS.h na ESP8266: um sistema de controle de acesso, onde um log era criado toda vez que uma pessoa entrava ou saía de um local, substituindo o sensor de presença por um botão que foi utilizado para simular os inputs. O segundo projeto, foi um sistema de backup, onde o último dado de uma série de leituras de sensores era armazenado na memória flash da ESP, para em caso de queda de energia, o último valor de leitura seja recuperado, evitando que o sistema execute alguma ação inesperada até realizar uma nova leitura.

No post de hoje, vou falar do sistema de log.

Para a criação do sistema de log, eu utilizei, em conjunto com a biblioteca FS.h, as bibliotecas NTPClient.h e TimeLib.h para que também pudessem ser gerados dados de hora e data para salvar no log em conjunto à informação do botão.

Para a criação dessa “timestamp”, primeiro declaro as variáveis e objetos necessários para trabalhar com essas bibliotecas:

#include "ESP8266WiFi.h"
#include "NTPClient.h"
#include "TimeLib.h" // biblioteca para fazer conversões de tempo para data
#include "WiFiUdp.h"

const char* nome_wifi = ""; // substituir por nome da wifi
const char* senha_wifi = ""; // substituir por senha da wifi
const char* servidor_ntp = "pool.ntp.org";
unsigned long ajuste_fuso = (-3 * 3600);
WiFiUDP udp;
NTPClient cliente_tempo(udp, "pool.ntp.org", ajuste_fuso);
String hora_data = "";

As variáveis nome_wifi e senha_wifi devem ser alteradas de acordo com a rede que você desejar se conectar!

As demais variáveis são de configuração, como a criação de um objeto udp para ser passada como argumento na obtenção de dados de tempo NTP e uma variável String para armazenar o nosso timestamp.

Depois disso, eu criei a função que pega os dados de data e hora. Nesse caso, não vou entrar em muitos detalhes, pois é um método bem padrão, que pode ser lido com mais tranquilidade checando a documentação da biblioteca TimeLib.h.

String pega_data_hora(NTPClient cliente) { 
  unsigned long epochTime = cliente.getEpochTime(); // epochTime = estrutura de tempo unix, conta segundos passados desde 1900
  struct tm *ptm = gmtime((time_t *)&epochTime);
  tmElements_t tm;
  breakTime(epochTime + (7 * 24 * 3600), tm); // criação do objeto dia / mês / ano
  int dia = (tm.Day);
  int mes = (tm.Month);
  int ano = (tm.Year + 1970);
  String data = (String(dia) + "/" + String(mes) + "/" + String(ano));
  String hora = cliente_tempo.getFormattedTime();
  String data_hora = (hora + " " + data);
  return data_hora;
}

Obviamente, também criei uma função que se torna responsável pela conexão com a rede wi-fi:

void setup_wifi(const char* rede, const char* senha) {
  WiFi.begin(rede, senha);
  Serial.println("");

  while (WiFi.status() != WL_CONNECTED) {
    delay(300);
    Serial.print(".");
  }
  Serial.print("Conectado na rede: ");
  Serial.println(rede);
}

Agora na parte de simular o sistema de acesso com um push-button, fica um pouquinho complicado, caso você não tenha muito conhecimento em prototipagem eletrônica com microcontroladores.

Basicamente, eu precisei criar uma função que calcula o debounce do push button, que tem como objetivo evitar erros de leitura no pressionamento do botão. Basicamente, seria como se eu adicionasse um período de espera quando o botão é pressionado, para garantir de que a leitura desse botão só seria realizada quando ele realmente tivesse sido pressionado.

Além disso, para evitar mais de uma leitura, criei uma função que trata da leitura da mudança de estado do botão, para que só fosse contabilizado o momento de pressionamento do botão, e não quando ele fosse “despressionado”.

int botao_acesso = 4;
int estado_botao = 1;
int ultimo_estado_botao = 1;
unsigned long debounce_delay = 50;
unsigned long debounce = 0;
int botao_com_debounce = 0;

int debounce_botao(int porta_do_botao) {
  int leitura_botao = digitalRead(porta_do_botao);
  
  if (leitura_botao != ultimo_estado_botao) {
    debounce = millis();
  }
  if ((millis() - debounce) > debounce_delay) {
    if (leitura_botao != estado_botao) {
      estado_botao = leitura_botao;      
      }
    }
  ultimo_estado_botao = leitura_botao;
  return estado_botao;
}

Para finalizar, criei algumas funções que já conhecemos com a biblioteca FS.h.

Primeiro uma função que checa se o arquivo de log já existe na memória. Caso não exista, cria um novo:

void checa_arquivo(const char* nome_do_arquivo) {
  if (!SPIFFS.exists(nome_do_arquivo)) {
    File arquivo_inicial = SPIFFS.open(nome_do_arquivo, "w");
    arquivo_inicial.println("Início do Log de Acesso.");
    arquivo_inicial.close();
    Serial.println("Arquivo base criado com sucesso.");
  }
  else {
    Serial.println("Arquivo base encontrado na memória.");
  }
}

E por fim, uma função que recebe os dados do arquivo e de log para salvar os dados na memória:

void salva_log(const char* nome_arquivo, String log_hora_data) {
  File arquivo = SPIFFS.open(nome_arquivo, "a");
  arquivo.println(log_hora_data);
  arquivo.close();
  Serial.println("Log gerado.");
}

Com essas funções criadas, o escopo do void setup() e do void loop() ficaram da seguinte maneira:

void setup() {
  Serial.begin(9600);
  pinMode(botao_acesso, INPUT_PULLUP);
  setup_wifi(nome_wifi, senha_wifi);

  cliente_tempo.begin();
  SPIFFS.begin();
  checa_arquivo(nome_do_arquivo);
}

void loop() {
  cliente_tempo.update();  
  botao_com_debounce = debounce_botao(botao_acesso);
  if (botao_com_debounce == 0 && controle_impressao == 0) {
    log_template = "Botão pressionado: " + pega_data_hora(cliente_tempo);
    salva_log(nome_do_arquivo, log_template);
    controle_impressao = 1;  // controle de impressão
  }  
  else if (botao_com_debounce != 0) {
    controle_impressao = 0;  // reset do controle 
  }
}

No void setup(), a ESP configura o push button, se conecta na rede wi-fi, inicializa a SPIFFS com a biblioteca FS.h, inicializa o cliente de tempo da biblioteca NTPClient.h e, por fim, executa a função checa_arquivo().

Já no void loop(), chamo o método .update() do cliente de tempo e faço uma pequena lógica de controle de estado para evitar leituras duplicadas do estado do botão.

Com esse programa, cada vez que o botão é pressionado, um registro é armazenado no nosso arquivo /log.txt com a hora e data que o botão foi pressionado.

Caso tenha interesse em ver o código completo, ele está disponível no repositório do projeto em ESP8266_SPIFFS/spiffs_log/spiffs_log.ino.

No próximo post, vou trazer como desenvolver um sistema de backup com a biblioteca FS.h, então fiquem ligados. 😉

Agora, pra finalizar essa etapa inicial, em que aprendemos os métodos básicos de objetos criados com o auxílio dessa biblioteca, vamos aprender mais alguns destes métodos.

Vamos começar com a listagem de arquivos.

Observação: para esta demonstração, utilizarei a Arduino IDE 2.1.1, e a configuração de placa selecionada para NodeMCU 1.0 (ESP-12E).

Observação 2: nos testes de demonstração dos códigos de hoje, minha ESP estava imprimindo caracteres de lixo na saída serial. Esse output não atrapalha as funcionalidades implementadas pelos códigos.

Para listar arquivos, primeiro precisamos criar um objeto do tipo Dir. Essa classe permite a atribuição de alguns elementos interessantes para lidarmos com informações da memória flash e de seus arquivos, como o endereço dos arquivos, seus nomes e até mesmo a data de criação dos mesmos.

O primeiro passo para listarmos os nomes dos arquivos que estão na nossa memória flash, precisamos criar nosso objeto do tipo Dir. Então vamos começar fazendo o setup inicial que já estamos acostumados a fazer:

#include "FS.h"

void setup() {
 Serial.begin(9600);
 SPIFFS.begin();

 Dir diretorio = SPIFFS.openDir("/");
}

Nesse primeiro momento, estamos criando um objeto do tipo Dir chamado diretório, que vai receber todo o conteúdo que está sendo aberto no nosso diretório base da memória flash, representado por uma barra.

Agora, podemos utilizar um dos métodos de checagem do nosso diretório: o .next(). Esse método “lê” o conteúdo da memória flash da ESP8266 que está na nossa variárel diretorio e retorna um booleano para indicar se existem arquivos ou não naquele diretório que foi aberto. Caso o retorno seja True, ele passa para o próximo arquivo, até chegar ao fim.

Nesse processo de checar a existência dos arquivos, a variável diretório passa a apontar, temporariamente, para valores que possuem informações desse arquivo, como seu nome, por exemplo.

Então, para pegarmos os nomes de todos os arquivos .txt na memória flash do nosso dispositivo, podemos criar um while loop, cujo controle será realizado pelo próprio objeto diretório e, durante cada iteração do objeto, iremos extrair o nome do arquivo para qual esse objeto está temporariamente apontando utilizando o método .fileName().

while (dir.next()) {
 Serial.println(dir.fileName());
}

Podemos então finalizar esse código da seguinte maneira:

#include "FS.h"
String nome_do_arquivo = "";

void setup() {
  Serial.begin(9600);
  SPIFFS.begin();  

  Dir dir = SPIFFS.openDir("/");

  while (dir.next()) {
    Serial.println(dir.fileName());
  }

  Serial.println("Listagem de arquivos concluída.");
}

void loop() {
}

Dessa forma, ao executar o código, a ESP8266 irá imprimir o nome de todos os arquivos armazenados em sua memória flash na saída serial. Adicionei um Serial.println extra no final apenas para dar uma embelezada.

Além de podermos criar, listar, ler e editar arquivos .txt na memória flash da ESP, vou passar rapidamente por mais algumas funções úteis dessa biblioteca.

Checar a existência de arquivos específicos

Ao invés de sempre listar e buscar arquivos de forma hard coded, você pode checar pela existência de um arquivo específico usando o método .exists(path), onde “path” pode ser substituído por uma variável do tipo string ou const char*. Seu conteúdo precisa ser o local onde o arquivo está. Então, se quisermos checar se o arquivo “teste.txt” que criamos anteriormente, de fato existe, basta utilizarmos este método.

#include "FS.h"
String nome_do_arquivo = "/teste.txt";

void setup() {
 Serial.begin(9600);
 SPIFFS.begin();

 if (SPIFFS.exists(nome_do_arquivo)) {
  Serial.println("Arquivo " + nome_do_arquivo + " encontrado!");
 }
}

void loop() {
}

Apagar arquivos:

Para apagar arquivos, utilizamos o método .remove(path). Então, por exemplo, se quisermos apagar o arquivo “log.txt”, que está presente na nossa memória, basta utilizarmos o método .remove(), que funciona de forma similar ao .exists(). Adicionarei uma listagem de arquivos após a remoção para checarmos se o arquivo “log.txt” foi corretamente apagado.

#include "FS.h"
String nome_do_arquivo = "/log.txt";

void setup() {
 Serial.begin(9600);
 SPIFFS.begin();

 SPIFFS.remove(nome_do_arquivo);

 Dir dir = SPIFFS.openDir("/");

  while (dir.next()) {
    Serial.println(dir.fileName());
  }

  Serial.println("Listagem de arquivos concluída.");
}

void loop() {
}

Formatar a memória flash:

Caso não queira listar e buscar para apagar arquivos individualmente, você também pode simplesmente usar o método .format() e apagar tudo de vez!

#include "FS.h"

void setup() {
 Serial.begin(9600);
 SPIFFS.begin();

 SPIFFS.format();
}

void loop() {
}

Agora que já sabemos como manipular arquivos e seus conteúdos na memória flash da ESP, no próximo capítulo iremos criar um projeto com essa biblioteca! Vamos criar um sistema de log, que irá armazenar os dados de um sensor de forma local, em um arquivo .txt na memória flash da ESP.

Além disso, esse projeto também será desenvolvido em livestream! A live será no dia 01/12 (sexta-feira), às 21h, no meu canal da twitch: ronaldohcorreia — Twitch.

Mas não se preocupe caso não possa acompanhar ao vivo. Também postarei a gravação (editada) no youtube e farei a transcrição por aqui. 🙂

Para mais detalhes, acesse o repositório do projeto: ronaldneves/ESP8266_SPIFFS (github.com)

Observação: para esta demonstração, utilizarei a Arduino IDE 2.1.1, e a configuração de placa selecionada para NodeMCU 1.0 (ESP-12E).

Já que temos o nosso arquivo “teste.txt” salvo na memória, vamos começar então chamando a biblioteca FS.h e criando a nossa variável que armazenará o nome do arquivo que vamos buscar e nosso objeto do tipo File e definir o método de manipulação desse arquivo como “r” (read):

#include "FS.h"
String nome_do_arquivo = "/teste.txt";

void setup() {
  Serial.begin(9600);
  SPIFFS.begin();
  File arquivo = SPIFFS.open(nome_do_arquivo, "r");
}

Vou aproveitar esse momento também para explicar algo que esqueci no post anterior: a minha escolha de tipagem para a variável nome_do_arquivo. Eu cheguei a citar no primeiro post dessa série que o método .open() recebe dois argumentos: o caminho do arquivo e o método da manipulação do arquivo, e pode ser tanto no formato const char* quanto String, conforme a biblioteca define o método:

File open(const char* path, const char* mode);
File open(const String& path, const char* mode);

Porém, como para o projeto que estou desenvolvendo, essa variável terá seu valor dinamicamente alterado em versões futuras dessa aplicação, fica mais fácil trabalhar com a variável nome_do_arquivo sendo do tipo String.

Dando continuidade, já criamos nosso objeto do tipo File e demos o nome de arquivo. Agora vamos checar se esse arquivo pôde ser aberto e imprimir o seu conteúdo na saída serial da ESP8266 — que nesse caso será pela IDE do Arduino.

if (arquivo) {
    Serial.println("Conteúdo do arquivo:");

    while (arquivo.available()) {
      Serial.write(arquivo.read());
    }
  }
  arquivo.close();

É importante sempre lembrar de fechar o arquivo com .close() ao final da execução do algoritmo.

O if checa se a variável arquivo não tem valor nulo, o que significa que ela está corretamente carregando os dados do nosso arquivo “teste.txt”. Já o while loop, utiliza o método .available() que retorna quantos bytes ainda estão disponíveis para leitura no arquivo a cada iteração do loop. Então, enquanto houverem bytes disponíveis, eles serão impressos na saída serial.

E com esse código, podemos imprimir o conteúdo do arquivo “teste.txt” na saída serial da ESP8266!

#include "FS.h"
String nome_do_arquivo = "/teste.txt";

void setup() {
  Serial.begin(9600);
  SPIFFS.begin();

  File arquivo = SPIFFS.open(nome_do_arquivo, "r");
  
  if (arquivo) {
    Serial.println("Conteúdo do arquivo:");

    while (arquivo.available()) {
      Serial.write(arquivo.read());
    } 
  }  
  arquivo.close();
}

void loop() {
}

No próximo post, vamos listar todos os arquivos armazenados na memória flash da ESP8266, acessá-los e imprimir seus conteúdos na saída serial.

Para mais detalhes, acesse o repositório do projeto: ronaldneves/ESP8266_SPIFFS (github.com)

Para armazenar e ler dados em arquivos .txt ou até mesmo .json de forma dinâmica, sem gastar os ciclos de gravação da EEPROM, eu gosto de utilizar a biblioteca FS.h, inclusa no repositório de bibliotecas de núcleo do Arduino para ESP32/ESP8266.

Observação: para esta demonstração, utilizarei a Arduino IDE 2.1.1, e a configuração de placa selecionada para NodeMCU 1.0 (ESP-12E).

Essa biblioteca nos permite interagir com a SPIFFS (SPI Flash File System) de um controlador ESP, possibilitando que dados que não serão enviados para um servidor na nuvem, mas que precisam persistir em caso de queda de energia, sejam armazenados localmente, na memória do controlador.

Para trabalhar com arquivos na SPIFFS, precisamos criar objetos do tipo File, que possui métodos para leitura e escrita de arquivos, similar ao método open presente em linguagens como python.

A criação de um objeto do tipo File segue a seguinte sintaxe:

#include "FS.h"
String nome_do_arquivo = "/teste.txt";

void setup() {
 SPIFFS.begin();
 File novo_arquivo = SPIFFS.open(nome_do_arquivo, "w");
}

O primeiro argumento da função é o nome do arquivo, que pode ser tanto uma variável String dinâmica ou const char*, caso o arquivo a ser lido seja sempre o mesmo durante a execução do programa.

O segundo argumento da função é o método de interação com o arquivo. Existem 3 principais métodos, que seguem a nomenclatura read (“r”), write (“w”) e append (“a”). Entretanto, vale notar que o método write sempre sobrescreve o conteúdo do arquivo. Para casos em que informações serão adicionadas, deve-se utilizar o método append.

Após criar o arquivo do tipo objeto File e definir o como será a interação com o arquivo, iremos utilizar os métodos desse tipo de objeto para ler o arquivo. No primeiro momento, criamos um objeto do tipo File de nome “arquivo”.

Vamos então, criar um novo arquivo .txt com o texto “Hello World!” e armazená-lo na SPIFFS.

if (novo_arquivo) {
  novo_arquivo.print("Hello world!");
  novo_arquivo.close();
}

É feita uma checagem se a variável “aquivo” é um objeto válido do tipo File. Após essa checagem, caso verdadeira, utilizamos o método .print() para escrever a string “Hello World” dentro do nosso arquivo. Ao final da execução, o arquivo é fechado com .close().

Então, um código simples para criar um novo arquivo no formato .txt que e armazena-lo na SPIFFS seria algo mais ou menos assim:

#include "FS.h"
String nome_do_arquivo = "/teste.txt";

void setup() {
  SPIFFS.begin();
  File novo_arquivo = SPIFFS.open(nome_do_arquivo, "w");
  
  if (novo_arquivo) {
    novo_arquivo.print("Hello world!");
    novo_arquivo.close();
  }
}

void loop() {
}

No próximo post, irei demonstrar como listar e ler os arquivos e armazenados na SPIFFS de um controlador do tipo ESP e interagir com seus conteúdos.

Para mais detalhes, acesse o repositório do projeto: ronaldneves/ESP8266_SPIFFS (github.com)

Em 2021, álbuns importantes, esperados e inesperados foram lançados. Foi um ano diferente pra mim, em diversos aspectos. E, por incrível que pareça, ouvi menos música (em geral) do que em 2020. Entretanto, a diversidade do que ouço aumentou ainda mais em relação ao ano passado — o que pra mim, é bom.

Então, sem mais delongas, seguem meus destaques de 2021.

Duda Beat — Te Amo Lá Fora

Três anos após lançar seu primeiro álbum, que teve como maior sucesso a música “Bixinho”, Duda lança Te Amo Lá Fora, cuja única semelhança com seu predecessor é a mistura de ritmos e a temática de relacionamento, comum à cantora.

Nesse álbum, Duda traz mais ritmos nordestinos em suas canções, como o piseiro, ritmo que se tornou bastante popular em todo o Brasil nos últimos anos, além de também trazer em suas faixas a mistura desses ritmos com o trap, algo que fica bastante em evidência na música Nem Um Pouquinho.

Músicas destaque pra mim:
Meu Pisêro
Nem Um Pouquinho
50 Meninas
Decisão de Te Amor

The Killers — Pressure Machine

Pouco menos de um ano após lançar Imploding The Mirage, os matadores lançam Pressure Machine, um álbum que é, de uma certa forma, diferente de tudo que a banda já havia lançado anteriormente. Com uma pegada mais folk, o álbum trata de contos inspirados na infância do vocalista Brandon Flowers no interior de Utah. Pressure Machine também é, o primeiro álbum desde o Battle Born, a ter todos os membros originais da banda envolvidos em sua produção.

Apesar de o álbum ser bem diferente do que estamos acostumados com a banda, ele não abandona por completo a ideia de seguir o caminho de criar músicas com refrões marcantes para tocar em estádios lotados, como prova In The Car Outside.

Num contexto geral, Pressure Machine é um álbum íntimo, sobre as memórias e sentimentos nostálgicos de Brandon, acompanhado pelos instrumentais de seus amigos de 20 anos de estrada.

Músicas destaque para mim:
Quiet Town
Sleepwalker
Runaway Horses
In The Car Outside

Twenty One Pilots — Scaled and Icy

Twenty One Pilots. Muito difícil passar um lançamento da minha banda favorita sem falar a respeito. Eu já tinha escrito minhas primeiras impressões sobre SAI aqui no Medium quando ele saiu (https://ronaldohcorreia.medium.com/scaled-and-icy-4faff6bb9d2d) e minha opinião sobre algumas de suas músicas e do conceito geral do álbum mudou um pouco de lá para cá.

Duas coisas que mudaram bastante minha opinião e até mesmo minha interpretação de algumas das músicas desse álbum foram a Live Experience e ver a gravação de alguns shows que fizeram durante essa retomada da música ao vivo pós-pandemia.

Essas duas coisas me permitiram perceber melhor qual e como são as histórias que eles tentam contar com esse álbum, que continuo afirmando ser muito diferente dos anteriores.

Entretanto, eu mantenho minha opinião de que esse definitivamente não é dos melhores trabalhos deles, pois precisou se apoiar bastante nas narrativas sendo contadas através dos clipes, dos shows e da live experience para “fazerem sentido”.

Porém, gostaria de deixar claro aqui que eu tenho gostado bastante do que eu tenho visto nos shows, como estão conseguindo linkar as narrativas dos álbuns anteriores com os atuais.

Músicas destaque para mim:
Good Day
Saturday
Mulberry Street
Redecorate

Lil Nas X — MONTERO

Álbum de estreia do Lil Nas X (7 é um EP), Montero nasce — literalmente, dentro de diversas controvérsias na vida do cantor. Nos anos que precederam o lançamento do álbum, Lil Nas X declarou ser gay, produziu um clipe que gerou polêmica por dançar lap dance no colo do capiroto, um projeto de tênis modificado da Nike que possuía um pouco de seu sangue embutido nele e ter postado fotos com uma prótese de barriga para dizer que estava “grávido” do álbum.

Antes de lançar o álbum, o próprio cantor brincou com isso com um vídeo super bem humorado para comentar o que todo mundo já sabia: na verdade boa parte da reclamação por parte da mídia e dos críticos tinham mais a ver com o fato dele ser gay.

Montero é um álbum em que Lil Nas X explora mais sua capacidade criativa, tanto na produção quanto nas letras e nos estilos envolvidos. Diferente do EP 7, cujo estilo predominante é o trap, em Montero temos algo mais pop, um pouco de guitarras e baterias acústicas, com temáticas bastante pessoais da vida do artista, além de hits indiscutíveis como MONTERO e INDUSTRY BABY.

É com certeza um dos meus álbuns favoritos desse ano, mas gostaria que HOLIDAY também tivesse sido incluído na setlist, porém consigo imaginar o porquê de não ter sido.

Músicas destaque para mim:
MONTERO (call me by your name)
INDUSTRY BABY
LOST IN THE CITADEL
SUN GOES DOWN
AM I DREAMING

Tyler The Creator — CALL ME IF YOU GET LOST

Seguindo o processo de evolução musical iniciado em Flower Boy e na sua sequência, IGOR, Tyler continua surpreendendo e crescendo enquanto artista. Apesar de não ter sido quase um trabalho de um homem só, como IGOR, o recente trabalho do rapper demonstra como sua capacidade de escrita e composição só tem melhorado ao longo do ano. Como todo álbum de Tyler, CMIYGL possui o já clássico “jeito Tyler” de se montar uma música, misturando trilhas de piano, samples de músicas antigas e beats agressivos, fofos e diferentões. Além disso, o álbum tem toda uma estética acompanhada por pôsteres, encartes, uma linha de perfumes e esmaltes, também produzidos por Tyler. Pra mim, esse é o álbum do ano.

Músicas destaque para mim:
CORSO
WUSYANAME
LUMBERJACK
MASSA
SWEET / I TOUGHT YOU WANTED TO DANCE

Billie Eilish — Happier Than Ever

Depois de indiscutivelmente ter bombado com seu primeiro álbum, Billie Eilish lança Happier Than Ever com uma escolha difícil: explorar um pouco mais o estilo musical em que ela se lançou originalmente e ficou conhecida, com beats de trap e seu canto sussurrado ou atingir novos horizontes. No fim, a cantora optou pela segunda opção. Em Happier Than Ever, Billie Eilish fala sobre crescer, abuso emocional, assédio e relacionamentos abusivos em faixas bem diferentes do que imaginaríamos a cantora, apesar de músicas com um estilo similar ao seu álbum de estreia também estarem presentes nesse álbum.

Apesar da mudança, eu acho que Happier Than Ever ainda não demonstra o potencial da cantora em suas letras e menos ainda em sua capacidade vocal. Entretanto, a qualidade das composições melhorou consideravelmente, o que demonstra um amadurecimento da cantora, algo que foi extremamente necessário, considerando que os temas abordados nesse álbum não poderiam ter sido explorados de forma suficientemente aceitável se suas letras fossem desenvolvidas similarmente ao álbum When We All Fall Asleep Where Do We Go, apesar de faixas como My Future e Therefore I Am seguirem mais esse estilo.

Músicas destaque para mim:
Getting Older
my future
Lost Cause
Happier Than Ever

Men I Trust — Untourable Album

Men I Trust foi uma banda que acabei conhecendo em 2020 enquanto eu navegava infinitamente madrugada adentro pelos recomendados do youtube e foi mais uma grata surpresa. Com um estilo que consegue ser, ao mesmo tempo relaxante e animado, os dois últimos álbuns de Men I Trust são perfeitos pra quem quer tanto ficar deitado numa rede quanto focar no trabalho ou ler um livro. As letras variam entre temas existenciais e historias simples sobre a vida ou relacionamentos, e suas faixas são sempre agradáveis de se ouvir. Apesar de ter escolhido apenas 4 músicas em destaque, raramente eu não ouço o álbum inteiro, pois é muito bom mesmo.

Músicas destaque para mim:
Oh Dove
Sugar
Tree Among Shrubs
Always Lone

Kanye West — Donda

Cercado de polêmicas, tretas, ameaças de processos e hype, Kanye (agora Ye) lança mais um álbum com temática pessoal e religiosa, seguindo o que foi estabelecido em seu álbum anterior, Jesus Is King. Donda foi adiado algumas vezes e teve alguns shows de “audição”, que consistiam em basicamente um público convidado ouvir as músicas do álbum ainda em processo de mixagem e pós-produção junto com Kanye, pra avaliar se elas já estavam prontas o suficiente. Entretanto, por conta de conflitos entre o artista e a gravadora sobre a data de lançamento do álbum, acabou que as músicas foram lançadas do jeito que foram apresentadas nas audições.

Eu não acho que Donda seja o melhor trabalho de Ye. Temos algumas músicas repetidas e outras excessivamente longas com instrumentais repetitivos, mas esse álbum foi lançado num processo muito conturbado em que ele vivia — seu divórcio e a exploração de sua espiritualidade, o que ele tem feito desde o álbum anterior e, por conta disso, me tocou bastante.

Músicas destaque para mim:
Jail
Hurricane
Praise God
Jesus Lord
Pure Souls

Dayglow — Harmony House

Mesmo quem nunca ouviu nada de Dayglow, bem provavelmente já deve ter se deparado com o clipe de Can I Call You Tonight no youtube. Se nunca teve vontade ou incentivo para assisti-lo, assista. É bem engraçado e a música é boa.

Em seu primeiro álbum, Sloan já tinha como objeto de inspiração a nostalgia. Tanto os ritmos quanto a direção de arte dos clipes parecem ser tirados diretamente de um filme de romance adolescente dos anos 90. Em Harmony House, Sloan volta ainda mais no tempo, nos anos 80. Quer sintetizadores enfadonhos? Tem. Quer reverb a torto e a direita? Tem também. Até os vlogs da turnê do álbum foram filmados de forma a parecer um diário de estrada dos anos 80. Pra quem gosta de pop indie e também curte essa vibe anos 80 que muitos artistas estão surfando, pode ir sem medo em Harmony House.

Musicas destaque para mim:
Medicine
Close To You
Crying On The Dancefloor
Woah Man

Lorde — Solar Power

Solar Power, ou como ficou popularmente conhecido no twitter, “xerecão da Lorde”, foi motivo de diversas tretas na internet e dividiu seus fãs. Mas pra deixar bem claro, ninguém questionou a qualidade do álbum e de suas músicas. O motivo da discussão foi sobre a temática do álbum, que se distanciou do que fez a cantora famosa. Seus dois primeiros álbuns tratavam muito de temas como melancolia, perda e até mesmo auto sabotagem.

Em Solar Power, os temas de saúde mental ainda estão presentes, mas a cantora trás novas perspectivas sobre sua visão de mundo, sua relação com a fama e com a vida. Em seus clipes também fica bem claro como Solar Power é um divisor de águas, com cores mais vibrantes e quentes, ambientação mais vívida, muitas flores e muito sol.

Músicas destaque para mim:
Solar Power
Stoned at the Nail Saloon
Secrets from a Girl (Who’s Seen It All)

Silk Sonic — An Evening With Silk Sonic

Sendo bem sincero, eu acho que esse provavelmente foi um dos álbuns mais aguardados do ano e dispensa comentários. Depois do lançamento de Leave The Door Open como primeiro single, hype era o que não faltava para essa nova parceria entre Bruno Mars e Anderson .Paak. O álbum é bom do começo ao fim, e eu queria colocar todas as músicas como destaque. Sério, apenas vá ouvir.

Músicas destaque para mim:
Leave The Door Open
Fly As Me
Smokin Out The Window
777

Menções Honrosas:

eat ya veggies — bbno$
Man’s Best Friend — Cavetown
Planet Her — Doja Cat
= — Ed Sheeran
LET’S JUST SAY THE WORLD ENDED A WEEK FROM NOW, WHAT WOULD YOU DO? — HONNE
LP! — JPEGMAFIA
Civilisation — Kero Kero Bonito

Mas você tem dúvidas ainda sobre porque a vacinação é o melhor caminho pra gente sair dessa pandemia? Venho então te trazer alguns dados mastigados pra você.

A CoronaVac hoje, é a vacina com menor taxa prática (baseada em dados da vida real e não testes clínicos ou de laboratório) de proteção contra covid-19. Os dados do recente experimento de vacinação em massa realizado na cidade de Serrana no interior de São Paulo apontam que a CoronaVac possui cerca de 80% de efetividade contra casos sintomáticos, ou seja, das pessoas desenvolverem sintomas da doença, mesmo que leves. Já nos dados coletados no Chile, esse número cai pra 67%. Porém, em ambos os casos, há uma constante comum: a redução na taxa de hospitalizações por COVID foi de quase 75%. Ou seja, de todo mundo que tomou duas doses da CoronaVac, só 1/4 das pessoas desenvolveram sintomas que mais graves.

Hoje no Brasil, a CoronaVac é a responsável por quase 60% das pessoas vacinadas contra COVID, então estima-se que o numero de vacinados com CoronaVac no Brasil é de cerca de 24 milhoes de pessoas.

Dados recentes de mortalidade por COVID de pessoas após vacinadas com as duas doses mostram que apenas 0,004% dos vacinados com a CoronaVac vieram a óbito por COVID, dentro dos 25 mil dessa amostragem que vieram a contrair a doença mesmo depois de vacinados.

E de acordo com o último estudo sobre a eficácia da CoronaVac, ela possui uma eficácia prática de 50%, ou seja, metade das pessoas vacinadas com a segunda dose ainda podem se contaminar num período de até 1 mês após a segunda dose. Passado esse período de um mês, essa eficácia sobe para quase 100%.

Porém, dessa quase metade que pode contrair a doença nesse período de um mês após a segunda dose, só 0,004% vieram a óbito, sendo que desses 0,004% que vieram a óbito, todos possuíam alguma comorbidade crônica ou idade avançada, que diminuem a imunidade da pessoa e a efetividade da vacina.

Ou seja, mesmo que ainda existam óbitos registrados após a vacinação, esse número é muitíssimo baixo e eles ainda podem ser melhorados com a melhoria da qualidade de vida dessas pessoas, como acompanhamento médico constante e respeitando o tempo que o corpo leva para desenvolver a imunidade pós-vacinação.

E isso levando em consideração dados apenas da CoronaVac. Os dados de taxa de eficácia e proteção das vacinas da AstraZeneca, Pfizer e Oxford são ainda melhores e mais animadores que os da CoronaVac.

E o que eu quero dizer com tudo isso? Que a vacinação está mostrando seus frutos, e que é o único caminho viável comprovado para realmente sairmos dessa pandemia. Os outros países já estão dando seu exemplo. Estados Unidos, Israel e o Reino Unido são países que focaram na vacinação rápida e eficiente de sua população e já permitem que as pessoas circulem sem máscaras em alguns ambientes públicos.

Uma vacinação veloz, eficaz e eficiente, poderia ter evitado centenas de milhares de mortes. Poderia ter evitado o colapso no sistema de saúde e na economia do país. Poderia inclusive ter evitado a necessidade de um novo Auxílio Emergencial e Benefício Emergencial, que o governo reclamou tanto em estender.

Se hoje temos novas variantes, toques de recolher, lockdowns mais pesados, fechamento do comércio, desemprego acima da média e inflação, é por conta da demora para se adquirir e distribuir vacinas para os brasileiros. É por conta de nós termos ficado mais tempo expostos ao vírus do que o necessário.

Então vamos pedir por mais vacinas e vamos nos vacinar!
Vacinem-se assim que puderem.

Para muitos fãs, principalmente os que conheceram a banda através do álbum Blurryface, SAI foge completamente das expectativas — de uma forma ruim. Indo mais pro pop e com um álbum menos coeso musicalmente, SAI é realmente um ponto fora da curva para a banda.

Mas sejamos honestos, SAI não é um álbum ruim. Talvez a lore criada em Blurryface e desenvolvida posteriormente em Trench nos deixou com expectativas muito altas para o que poderia vir a ser o terceiro capítulo da história. Mas a realidade é que não consideramos se Tyler e Josh, enquanto artistas, gostariam de seguir esse caminho.

Tendo isso em mente, é possível perceber como SAI é um álbum que eles queriam testar coisas novas. A grande questão é que, nesse processo, a banda passou a soar um pouco menos como ela própria, lançando músicas que se apresentadas a pessoas que não conhecem a banda, jamais adivinhariam que se trata de Twenty One Pilots. A identidade da banda de sempre surgir com ideias originais, tanto na sonoridade quanto nas letras, foi deixada um pouco de lado para experimentar a construção de uma nova, mesmo que isso signifique não fugir do óbvio.

Ainda com essa exposição inicial, reitero: SAI não é um álbum ruim.

Acredito que se a proposta do álbum era experimentar novos estilos e musicalidades, ele faz isso muito bem. Os fãs vão sentir falta das letras mais existencialistas, sobre as conspirações de DEMA e dos Banditos, que foram substituídas por músicas mais alegres como Good Day (but the lyrics are so down) e Saturday. Formidable vem pra preencher a cota de “música bonita sobre amor e sua pessoa especial”. Never Take It, Bounce Man e Redecorate se destacam no álbum de 11 faixas por serem músicas que realmente demonstram a capacidade do Tyler de integrar estilos diferentes numa mesma composição.

Temos que levar em consideração também um fator muito importante, principalmente se tratando de uma banda como Twenty One Pilots, que é uma banda que costuma escrever em suas músicas como eles se sentem atualmente. Isso explica muito boa parte das letras e dos ritmos, visto que foi um álbum majoritariamente produzido durante uma pandemia que já chega no seu segundo ano (Saturday é um ótimo exemplo de música de quarantine feelings) e além disso, Tyler se tornou pai, que é algo que muda e MUITO sobre a forma que as pessoas passam a enxergar o mundo ao seu redor.

Penso que dada a temática mais leve e a curta duração do álbum, provavelmente veremos coisas novas num futuro próximo. SAI definitivamente não entra como meu álbum favorito da banda, mas possui uma sonoridade diferente e explora bem novos horizontes que podem vir a agregar bastante nos próximos trabalhos da banda.

Na verdade, de acordo com meu perfil na last.fm (https://www.last.fm/pt/user/RonaldNeves), esse foi o ano que mais ouvi música desde 2012, tendo ouvido cerca de 3.200 faixas a mais que 2019.

Segue aqui então os álbuns que mais gostei e foram lançados esse ano, seja por ter me identificado com a temática ou por ser um álbum muito bem feito mesmo.

Boy Pablo — Wachito Rico

Apesar de já ser velho conhecido da galera que acompanha essa vertente da música independente que ficou conhecida como “bedroom pop”, eu só fui conhecer Boy Pablo esse ano. No começo da quarentena, acabei diversificando mais o que eu ouvia e Boy Pablo foi um dos artistas que tive o prazer de conhecer. O que eu não esperava, no entanto, é que seu primeiro álbum seria lançado esse ano, o que foi, pra mim, uma surpresa agradável.

Com uma vibe muito boa e com cara de álbum de verão, nesse novo álbum Pablo mostra um pouco das suas raízes chilenas inserindo diversos trechos em espanhol nas músicas, o que achei bem legal. Além disso, antes do lançamento do álbum, foram lançados 5 singles com clipes que contavam uma historinha que se encaixam muito bem com as músicas.

Músicas destaque para mim:
i hope she loves me back
leave me alone!
rest up
wachito rico

The Killers — Imploding The Mirage

3 anos (e muitas entrevistas sobre novo álbum) após Wonderful Wonderful, The Killers também volta com um álbum novo em 2020. Imploding The Mirage é um álbum que, por conta da quarentena, atrasou um pouco, mas também permitiu uma certa interação entre os fãs da banda e seus atuais “cabeças”, Brandon Flowers e Ronnie Vannucci.

Durante a quarentena, diversas lives foram feitas nas redes sociais para falar sobre o novo álbum e seu processo de produção, além de músicas terem sido mostradas antes da hora, como o caso de “Dying Breed”. Nesse álbum, a banda tenta mostrar um processo de evolução, tanto em aspectos da vida pessoal do vocalista Brandon Flowers, quanto na música, trazendo de volta os famosos sintetizadores da era Hot Fuss e novos refrões perfeitos para cantar em arenas lotadas.

Músicas destaque para mim:
My Own Soul’s Warning
Dying Breed
Imploding The Mirage

The Strokes — The New Abnormal

Provavelmente meu álbum favorito de 2020, The New Abnormal traz um Strokes repaginado, com letras mais profundas e composições (nem sempre) complexas e extremamente envolventes. Álbum de retorno da banda, 7 longos anos após Comedown Machine, The New Abnormal é um álbum completo. Possui 9 músicas com 45 minutos e essa linda capa com o quadro “Bird On Money”, do artista Basquiat.

Suas músicas contam histórias da vida pessoal do vocalista Julian Casablancas através de metáforas e analogias, sem perder sua característica clássica de muitas vezes escrever letras sem sentidos e frases soltas de forma poética.

A forma que o álbum foi montado passa a sensação de estarmos dentro de um filme bem produzido, com começo meio e fim. E que fim! Ode To The Mets, começando logo após Not The Same Anymore, fecha o álbum com chave de ouro, sendo minha música favorita da banda dos últimos tempos. A música começa devagar, os instrumentos aos poucos são introduzidos, com direito a uma frase candidata a ícone da banda (drums, please, Fab?).

Eu gosto de dizer que Ode To The Mets é como escalar uma montanha, em que à medida que você vai subindo, você vai olhando os arredores e tendo mais vontade de continuar, ao ponto que quando chega no final, você está em êxtase contemplando a vista proporcionada pela escalada.

The New Abnormal fez com que eu me reapaixonasse pela banda e foi o segundo álbum que eu mais ouvi durante esse ano.

Músicas destaque para mim:
Selfless
Why Are Sundays So Depressing
Ode To The Mets

Joji — Nectar

Duas vezes adiado e quase esquecido por mim, Nectar foi um dos poucos álbums em que eu estava ansioso e/ou com altas expectaticas, visto que BALLADS1 jogou Joji para os braços abertos do público mainstream e agora ele tinha uma importante missão: manter o hype rolando. Nectar tem de tudo. De tudo mesmo. Beat de trap clássica estilo trap de soundcloud, músicas super produzidas, músicas que parecem que foram criadas na fila do banco, vários feats e muitos, mas muitos dos falsetes característicos do Joji. No álbum de 18 músicas e 53 minutos, sobrou espaço até para uma música mais no estilo Pink Guy, relembrando os tempos de youtuber do Joji.

Seus singles Sanctuary, Run, Gimme Love e Upgrade possuem clipes com histórias que se conectam, com os fãs criando várias teorias sobre o que o artista quer explicar com elas, sendo algo bem interessante de se acompanhar.

Outra coisa legal de se citar é a participação do renomado DJ Diplo na faixa Daylight, que inclusive é a faixa mais bem produzida do álbum, fugindo daquele estilo mais lo-fi que as músicas do Joji costumam ter.

Músicas destaque para mim:
Tick Tock
Daylight
Gimme Love
Pretty Boy

Cavetown — Sleepyhead

Cavetown também entra pra lista de artistas que conheci esse ano por conta da quarentena. Não tive tempo de ouvir muito da obra do artista até então, me limitando ao recém lançado Sleepyhead e seu trabalho prévio, o Animal Kingdom. Cavetown possui um som calmo e relaxante, com poucos instrumentos, porém muito bem produzido. Possui letras fofinhas, e relativamente fáceis de se identificar, abordando diversos temas da vida de um jovem adulto.

Músicas destaque para mim:
Sweet Tooth
Trying
Things Tha Make It Warm

DAY6 — The Book of Us: The Demon

Banda que eu descobri da forma mais aleatória possível. Observe o fluxo dos acontecimentos: assisti vídeos de Among Us do Disguised Toast no youtube e conheci o Jae (ou eaJ) → Rich Brian lança uma versão de Love In My Pocket com participação do Jae → eu descubro que ele é músico → eu descubro DAY6.

Fui procurar ouvir o trabalho dele sem muitas expectativas, visto que eu tenho uma certa resistência com a indústria pop coreana por questões políticas e ideológicas, e me surpreendo positivamente. A banda possui um som de rock alternativo que lembra os primeiros trabalhos de Foo Fighters e Paramore, só que em coreano e obviamente com alguns aspectos específicos do pop coreano.

Músicas destaque para mim:
Day and Night
Tick Tock
Afraid

HYUKOH — Through Love

Banda apresentada à mim por um amigo alguns anos atrás, me apaixonei desde a primeira escutada. Se você acha que música coreana se resume aos pops da vida, recomendo sair um pouco da bolha do mainstream e escutar Hyukoh.

Nesse álbum (que não é bem um álbum, tá mais pra EP), a banda experimenta ainda mais na sua sonoridade, trazendo elementos de bossa nova, slow blues e até alguns upbeats mais eletrônicos, porém sem perder aquela sonoridade “chill” característica da banda. Vale muito a pena ouvir a discografia dos caras, é uma música muito gostosinha de se ouvir.

Músicas destaque para mim:
Help
Silverhair Express
New born

Phoebe Bridgers — Punisher

Artista que tem literalmente uns 2 meses que descobri, após ter visto a música I Know The End aparecendo nos recomendados do youtube, possui uma sonoridade que me agrada muito, misturando elementos de bedroom pop e rock indie alternativo. Phoebe Bridgers que antes fazia parte do grupo boygenius, se lançou como artista solo no álbum Stranger in the Alps, onde conseguiu alcançar sucesso quase que imediato entre os amantes do gênero. Ouvir Punisher é muito agradável, mesmo as músicas mais agitadas como Kyoto conseguem passar uma sensação de conforto ao ouvir.

Além do álbum Punisher, Bridgers também lançou um EP intitulado If We Make It Through Decembrer, que eu ainda não ouvi, mas com certeira ouvirei antes do ano novo pra entender o EP dentro do contexto que as músicas foram feitas para serem ouvidas.

Músicas destaque para mim:
Kyoto
Punisher
ICU
I Know The End

Rich Brian — 1999

Rich Brian, artista que conheci ainda com seu antigo e ofensivo nome artístico, desde seu álbum de estreia em 2018, não passou um ano em branco sem lançar um álbum ou EP, característica de muitos rappers. Fugindo um pouco da sonoridade experimental e orgânica de seu álbum The Sailor e partindo pra algo mais mainstream, flertando um pouco com o trap pop estilo Post Malone. 1999 é um EP que não foge do “estilo Rich Brian” quando se trata de letras, conseguindo viajar, na mesma música, entre temas como sentimentos, riqueza, ostentação e um pouco de seu ego.

Minha grande crítica a esse álbum é não ter a versão de Love In My Pocket com Jae nele, estando apenas disponível no youtube. Brincadeiras à parte, essa música é o grande destaque do EP, tendo cerca de 4 videoclipes, além dos diversos clipes não-oficiais que fizeram parte da brincadeira promovida pelo artista no clipe original.

Músicas destaque para mim:
Don’t Care
DOA
Love In My Pocket

Vivendo do Ócio — Vivendo do Ócio

5 anos após seu interessantíssimo álbum Selva Mundo, Vivendo do Ócio lança seu self-titled em 2020, com a sonoridade mais madura que ouvi da banda até então. O álbum mostra como é o processo de evolução de uma banda que consegue ser uma síntese dela mesma. É um álbum que faz a gente sentir que está ouvindo aquela primeira Vivendo do Ócio que lançou Som Luzes e Terror durante Cê Pode e magicamente somos teletransportados para O Amor Passa no Teste com sua sonoridade mais moderna, com sintetizadores e linhas de baixo marcantes.

Nesse álbum, não tiveram medo de experimentar e muito menos de sofrer com aquele problema clássico do nicho do rock de serem acusados de “não serem mais tão rock quanto antes”, e essa coragem tornou possível ouvirmos um álbum gostoso de se ouvir, com músicas para todos os momentos e moods, sem abandonar o bom e velho rock and roll.

Músicas destaque para mim:
O Amor Passa no Teste
Evolução
Nova Ordem
Il Tempo

Menções honrosas — álbuns que valem a pena serem escutados:

JPEGMAFIA — EP!
Djonga — Histórias da Minha Área
Declan McKenna — Zeros
Wallows — Remote