Curso de introdução à programação de Microcontroladores
- Introdução
- Introdução a Microcontroladores
- Interfaces de programação
- Programação em C++
- Tutorial sensores básicos
Introdução
Objetivos
Esta apostila tem como objetivo principal oferecer uma base sólida para os leitores sobre o universo dos microcontroladores, com ênfase nos dispositivos ESP32 e Arduino. Os objetivos específicos incluem:
-
Apresentar os conceitos de microcontroladores:
Fornecer uma visão geral sobre o funcionamento, a estrutura e as aplicações dos microcontroladores no mundo real. -
Ensinar o uso de plataformas de programação e simulação:
Introduzir ferramentas populares como IDEs (Ambientes de Desenvolvimento Integrado) e simuladores que auxiliam no desenvolvimento e teste de projetos com microcontroladores. -
Ensinar conceitos básicos de programação de microcontroladores:
Abordar a escrita de códigos simples e eficientes para controlar diferentes periféricos e executar tarefas específicas. -
Demonstrar o uso de diversos tipos de sensores:
Capacitar o leitor a integrar sensores de temperatura, umidade, pressão, entre outros, para coletar dados ambientais e processá-los em projetos práticos. -
Permitir a criação de uma estação meteorológica:
Ensinar como construir uma estação meteorológica funcional utilizando microcontroladores, sensores e técnicas aprendidas ao longo da apostila.
Com essa abordagem, espera-se que o leitor desenvolva as competências necessárias para criar projetos práticos e criativos utilizando os microcontroladores ESP32 e Arduino, desde a concepção até a execução.
Introdução a Microcontroladores
Introdução a Microcontroladores
O que são microcontroladores?
Os microcontroladores são dispositivos eletrônicos altamente integrados que combinam em um único chip um processador (CPU), memórias (RAM e ROM/Flash), periféricos de entrada e saída (I/O) e outros componentes necessários para controlar sistemas embarcados. Eles são projetados para realizar tarefas específicas em dispositivos eletrônicos, como controlar motores, sensores, displays e outros elementos de um sistema.
Devido à sua simplicidade e eficiência, os microcontroladores são amplamente utilizados em aplicações como eletrodomésticos, automação industrial, dispositivos médicos, sistemas automotivos, brinquedos eletrônicos, entre outros. Sua principal característica é a capacidade de operar de forma autônoma, sem a necessidade de componentes adicionais complexos.
Diferença entre Microcontroladores e Microprocessadores
Embora os termos "microcontrolador" e "microprocessador" sejam frequentemente confundidos, eles se referem a componentes distintos com finalidades diferentes:
Microprocessadores: Um microprocessador é essencialmente a unidade central de processamento (CPU) de um sistema. Ele é responsável por executar instruções e processar dados, mas depende de componentes externos, como memórias (RAM e ROM), controladores de entrada e saída e outros periféricos, para funcionar.
São comumente usados em sistemas de maior complexidade, como computadores pessoais, laptops e servidores, onde a capacidade de processamento e expansibilidade é essencial.
Microcontroladores: Um microcontrolador, por outro lado, é uma solução "tudo-em-um", que inclui a CPU, memórias, e periféricos integrados no mesmo chip. Essa integração permite o desenvolvimento de sistemas compactos, de baixo custo e baixa potência.
São ideais para aplicações embarcadas, onde o foco é realizar tarefas específicas com eficiência e simplicidade.
Exemplo Prático: Considere um termostato inteligente usado para controlar a temperatura de um ambiente. Um microcontrolador é a escolha ideal porque pode integrar sensores de temperatura, controles de relé para o sistema de aquecimento/resfriamento e comunicação com outros dispositivos, tudo em um único chip. Em contrapartida, um microprocessador seria mais adequado para uma aplicação como um computador de bordo em um automóvel, onde é necessária maior capacidade de processamento e a integração com diversos sistemas complexos.
Compreender essas diferenças é essencial para escolher o componente mais adequado para cada projeto, garantindo desempenho, custo-benefício e eficiência no uso dos recursos.
Tipos de Entradas e Saídas
Os microcontroladores, como o Arduino e o ESP32, são dispositivos versáteis capazes de interagir com o mundo externo por meio de pinos configuráveis como entradas ou saídas. Esses pinos são os principais canais de comunicação entre o microcontrolador e sensores, atuadores ou outros dispositivos eletrônicos.
Compreender os diferentes tipos de entradas e saídas é essencial para aproveitar todo o potencial de um microcontrolador. Saber como configurar e utilizar esses recursos é o primeiro passo para desenvolver projetos inovadores, desde sistemas simples de automação até aplicações mais complexas em IoT (Internet das Coisas). A seguir, vamos explorar os diferentes tipos de entradas e saídas que você encontrará em microcontroladores.
Entradas Digitais
As entradas digitais permitem que o microcontrolador detecte o estado lógico de um sinal:
- Nível ALTO (HIGH): Geralmente corresponde a uma tensão próxima ao valor da alimentação (ex.: 3.3V ou 5V).
- Nível BAIXO (LOW): Normalmente representa 0V ou GND.
Essas entradas são usadas para ler sinais de botões, interruptores e sensores digitais que operam com lógica binária. Exemplo de uso: Um botão pressionado conecta o pino a GND, mudando o estado de HIGH para LOW.
Entradas Analógicas
As entradas analógicas permitem medir sinais de tensão variáveis. Esses sinais são convertidos em valores digitais através de um conversor Analógico-Digital (ADC).
Resolução: O número de bits do ADC determina a precisão da medição. Por exemplo, um ADC de 10 bits em um Arduino gera valores entre 0 e 1023. O intervalo de tensão depende do microcontrolador. No Arduino UNO, por exemplo, é de 0 a 5V.
Exemplo de uso: Leitura de um potenciômetro ou sensor de luz (LDR).
Saídas Digitais
As saídas digitais são usadas para controlar dispositivos que operam em dois estados: LIGADO (HIGH) ou DESLIGADO (LOW).
Podem acionar LEDs, relés, buzinas, entre outros dispositivos binários.
Muitas saídas podem fornecer corrente limitada (ex.: 20mA no Arduino UNO), necessitando de transistores ou módulos de driver para controlar dispositivos de maior potência.
Exemplo de uso: Acender um LED ou ligar/desligar um motor através de um relé.
Saídas Analógicas (PWM)
Embora a maioria dos microcontroladores não tenha saídas analógicas puras, eles podem simular sinais analógicos usando PWM (Pulse Width Modulation).
PWM: Uma técnica que controla a largura do pulso em uma série de sinais digitais para variar a potência ou tensão efetiva. Usado para controlar a intensidade de LEDs, a velocidade de motores ou criar sinais analógicos aproximados. Exemplo de uso: Ajustar o brilho de um LED ou controlar a velocidade de um motor.
Entradas e Saídas de Comunicação
Os microcontroladores possuem pinos dedicados para comunicação com outros dispositivos, incluindo:
- UART (Serial): Para comunicação serial, amplamente usada para debugar códigos ou comunicar com módulos externos, como módulos Bluetooth.
- I2C: Protocolo para conectar vários dispositivos com apenas dois pinos (SDA e SCL).
- SPI: Um protocolo mais rápido que I2C, mas que exige mais pinos (MISO, MOSI, SCLK e CS).
Exemplo de uso: Conectar um display OLED via I2C ou comunicar com um sensor IMU via SPI.
Entradas e Saídas Especiais
Pinos de interrupção: Permitem que o microcontrolador reaja imediatamente a um evento externo, ignorando o fluxo normal do programa.
- Entradas capacitivas (ESP32): Usadas para criar botões touch sensíveis ao toque.
- Conversores Digital-Analógico (DAC): Disponíveis em alguns microcontroladores, como o ESP32, para gerar sinais analógicos reais.
Microcontroladores comuns
ESP32
Arquitetura
Abaixo temos uma imagem mostrando os tipos de conexões suportadas para cada porta da ESP32, as principais que serão usadas ao longo dessa apostila são: as entradas analógicas (ADC), digitais (GPIO) e as de comunicação I2C (GPIO21 E GPIO22).
Guia de conexão
-
Baixar 2 drivers de USB para comunicação com a placa pelo Windows: CP210x e CH341SER. (Para o segundo driver, é necessário que a placa esteja conectada em uma porta USB para funcionar)
-
Com o aplicativo Arduino IDE (download na secção 1.1.1) será possível ver que, após a instalação dos drivers, uma nova porta COM aparecerá e ela é a que deve ser utilizada.
-
Para ver as portas disponíveis, abra o menu Tools $->$ Port: (figura \ref{fig: Econex1})
- Escolher o modelo de placa que você está usando no menu de escolha de porta e placa (“Select other board and port…”): (figura \ref{fig: Econex2})
Arduino
Arquitetura
Abaixo temos uma imagem mostrando os tipos de conexões suportadas para cada porta dO aRDUINO, as principais que serão usadas ao longo dessa apostila são: as entradas analógicas (ANALOG PIN), digitais (DIGITAL PIN) e as de comunicação I2C (SCL e SDA).
Guia de Conexão
-
Fazer o download da interface Arduino IDE;
-
Com a IDE aberta, a placa Arduino que for conectada deve ser reconhecida imediatamente pelo programa que fará a conexão automática no sistema, pronta para uso.
Interfaces de programação
Interface Arduino IDE
A Arduino IDE (Integrated Development Environment) é uma plataforma de desenvolvimento fundamental para programar placas Arduino e outros microcontroladores compatíveis. Sua principal função é oferecer um ambiente simples e intuitivo para escrever, compilar e enviar códigos (sketches) para os dispositivos físicos. A IDE suporta a linguagem de programação baseada em C/C++ e integra bibliotecas que facilitam a criação de projetos eletrônicos, desde automações simples até sistemas complexos de IoT. Sua importância reside na acessibilidade que proporciona a iniciantes e profissionais, tornando o desenvolvimento de soluções embarcadas mais ágil, didático e eficiente.
Download
Para fazer o download da interface de programação Arduino IDE entre no site https://www.arduino.cc/en/softwaree selecione a opção correspondente ao computador em que o aplicativo está sendo instalado.
Menus e Funções
A Arduino IDE possui uma grande diversidade de funções e opções em seus menus, aqui abordaremos algumas das principais funções e onde elas se encontram. Começando com os menus no topo esquerdo da tela. Temos primeiramente o menu Files abaixo que é onde encontram-se as funções de criar novos sketchs ou abrir existentes no seu computador, abrir o menu de exemplos prontos da própria arduino IDE ou de bibliotecas que você pode baixar e as opções de salvar os sketchs.
Em seguida, temos o menu Edit, onde é possível encontrar os principais atalhos como copiar, colar, desfazer, etc, e algumas opções para alteração de tamanho da fonte.
Por fim, temos a interface principal com as funções:
- Verify / Upload (Verificar / Carregar): Compila e envia seu código para a placa.
- Select Board and Port (Selecionar Placa e Porta): Placas Arduino detectadas automaticamente aparecem aqui, junto com o número da porta.
- Sketchbook: Aqui você encontrará todos os seus sketches armazenados localmente no computador. Além disso, é possível sincronizar com a Arduino Cloud e acessar sketches do ambiente online.
- Boards Manager (Gerenciador de Placas): Explore pacotes da Arduino e de terceiros que podem ser instalados.
- Library Manager (Gerenciador de Bibliotecas): Explore milhares de bibliotecas Arduino criadas pela Arduino e pela comunidade.
- Debugger (Depurador): Teste e depure programas em tempo real.
- Search (Pesquisar): Busque por palavras-chave no seu código.
- Open Serial Monitor (Abrir Monitor Serial): Abre a ferramenta Monitor Serial em uma nova aba no console.
Para Informações mais detalhadas de funcionamento ou tirar dúvidas, entre no guia completo da Arduino clicando em help no topo do aplicativo ou acessando o site de documentação https://docs.arduino.cc/
Interface WOKWI: Introdução à simulações
O site Wokwi é uma ferramenta poderosa para fazer testes de códigos e circuitos para aqueles que não possuem acesso a microcontroladores e sensores ou apenas precisam de uma forma mais prática de testar suas ideias. Nele, é possível montar circuitos com microcontroladores como a ESP32 e o Arduino e fazer o teste de programas neles em simulações que recriam o que ocorre num sistema. Para acessar o site, pesquise "Wokwi" no seu navegador ou acesse o site: https://wokwi.com/
Interface e funções
Quando o site é aberto, a primeira coisa que aparece são as opções de microcontrolador que se deseja simular (neste curso utilizaremos principalmente a ESP32, mas o conteúdo deve funcionar para qualquer um dos microcontroladores sabendo-se a arquitetura dos mesmos). Descendo a página inicial, estão expostos alguns exemplos criados pela comunidade de montagens mais avançadas que podem ser utilizadas como referência em códigos mais complexos ou por curiosidade.
Após escolher o microcontrolador que deseja, a nova página mostrará exemplos específicos daquele microcontrolador, e abaixo terá a opção de escolher o modelo desejado e começar um novo template para simular. para este curso, recomenda-se escolher o primeiro template para ESP32 padrão.
Com o template escolhido, será aberta a interface principal, que será utilizada para adicionar sensores e o código na placa a fim de simula-los:
Na metade direita da tela, temos a seção onde é feita a montagem do circuito. Para adicionar componentes como sensores e leds, basta clicar no botão azul com o sinal de mais e escolher o que é preciso. Para mover os componentes apenas clique e segure e arraste ele para a posição desejada, e para conectar fios entre os itens posicionados, apenas clique na perna do componente e depois clique onde deseja conectá-lo.
Na metade esquerda temos a parte de programação da placa, é nela em que deve ser inserido o código que deseja carregar nela. Nesta parte, também temos o menu de configuração de bibliotecas, basta clicar na aba "library manager" no topo da tela e na interface que aparecer, pesquise as bibliotecas que deseja adicionar (as bibliotecas que utilizaremos ao longo do curso são possíveis de encontrar diretamente no site sem a necessidade de baixá-las manualmente.
Após realizar a montagem dos componentes e escrever o código necessário para utilizá-los, clique no botão de "play" verde do lado direito e o site ira simular o funcionamento do que foi montado, mostrando os dados do monitor serial em um monitor que aparecerá no lado direito.
Para Informações mais detalhadas de funcionamento ou tirar dúvidas, entre no guia completo do próprio site clicando em "Docs" no topo direito do site ou acesse a documentação em https://docs.wokwi.com/pt-BR/
Programação em C++
Funções e variáveis
Agora que foi apresentado sobre as interfaces de programação que são utilizadas para configurar e simular microcontroladores, mostraremos nesta seção como funciona a linguagem C++ e o básico para que seja possível compreender os códigos das próximas seções e como criar os seus próprios.
Funções Básicas
No ambiente de programação do Arduino, as funções principais são setup
e loop
. Ambas têm papéis específicos na estrutura do programa e são essenciais para o funcionamento do código.
A função setup prepara o ambiente de execução. A função loop mantém o microcontrolador em operação contínua, executando tarefas de forma cíclica. Essa separação simplifica o desenvolvimento, organizando o código de forma clara e eficiente.
Função Setup
A função setup é executada apenas uma vez, logo após o microcontrolador ser ligado ou reiniciado. Ela é usada para configurar o ambiente inicial do programa, como:
- Configurar pinos como entrada ou saída.
- Inicializar comunicações seriais (ex.: Serial.begin(9600);).
- Configurar periféricos e bibliotecas necessárias para o funcionamento do programa.
Exemplo:
Função Loop
A função loop é executada continuamente após a conclusão da setup. Todo o código que define o comportamento repetitivo ou contínuo do microcontrolador deve ser implementado aqui.
Exemplo:
Tipos de variáveis em C++ e seus principais usos
Ao programar em C++ para aplicações de microcontroladores, é essencial entender os diferentes tipos de variáveis disponíveis. Cada tipo de variável é projetado para armazenar dados de formas específicas, otimizando o uso de memória e garantindo a eficiência do código. Abaixo, explicamos os principais tipos de variáveis em C++ e seus usos mais comuns:
Variáveis Inteiras
Variáveis inteiras são usadas para armazenar números inteiros (positivos, negativos ou zero), sem casas decimais.
-
Tipo "int": É o tipo inteiro mais utilizado. Armazena valores entre -32.768 e 32.767 (em sistemas de 16 bits) ou entre -2.147.483.648 e 2.147.483.647 (em sistemas de 32 bits).
Uso: Contadores, índices de laços, medições que não requerem frações. -
Tipo "short": Um tipo inteiro menor, que ocupa menos memória.
Uso: Ideal para situações onde a memória é limitada e o intervalo de valores é pequeno. -
Tipo "long" e "long long": Usados para armazenar números inteiros muito grandes.
Uso: Cálculos que exigem maior precisão ou intervalos mais amplos. -
Modificador "unsigned": Indica que a variável não armazenará valores negativos, dobrando o limite superior.
Uso: Contagem de eventos ou medições sempre positivas, como leituras de sensores.
Variáveis de Ponto Flutuante
Usadas para representar números reais (com casas decimais).
-
Tipo "float": Representa números com precisão simples (32 bits).
Uso: Cálculos que exigem precisão moderada, como medições analógicas ou coordenadas em um sistema. -
Tipo "double": Representa números com precisão dupla (64 bits).
Uso: Cálculos mais complexos que exigem maior precisão.
Nota: Em microcontroladores com recursos limitados, é importante usar float
ou double
apenas quando necessário, pois essas variáveis consomem mais memória e poder de processamento.
Variáveis de Caractere
- Tipo "char": Usado para armazenar um único caractere (como 'A', '1', ou '?') ou valores numéricos pequenos (de 0 a 255 no caso de
unsigned char
).
Uso: Representa caracteres individuais ou pequenos números inteiros, como códigos ASCII.
Variáveis Booleanas
- Tipo "bool": Armazena valores lógicos, ou seja,
true
(verdadeiro) oufalse
(falso).
Uso: Controle de fluxos lógicos, como verificar se uma condição foi atendida.
Variáveis Compostas
-
Tipo "array": Conjunto de variáveis do mesmo tipo armazenadas em sequência.
Uso: Armazenar múltiplos valores relacionados, como leituras de um sensor ao longo do tempo. -
Estruturas (struct): Agrupam variáveis de diferentes tipos sob um único nome.
Uso: Representação de objetos mais complexos, como as informações de um dispositivo.
Ponteiros
- Tipo "int", "float", etc.:** Variáveis que armazenam o endereço de memória de outra variável.
Uso: Manipulação direta de memória, comunicação com periféricos ou passagem eficiente de dados entre funções.
Considerações Importantes
Ao trabalhar com microcontroladores, é essencial escolher o tipo de variável adequado para:
- Otimizar o uso de memória: Microcontroladores geralmente têm recursos limitados.
- Garantir eficiência: Variáveis menores permitem operações mais rápidas.
- Evitar erros: Certifique-se de que o intervalo de valores suportado pela variável é suficiente para a aplicação.
Comunicação serial
Comunicação serial
A comunicação serial é um dos meios mais simples e eficientes para enviar e receber dados entre o microcontrolador e outros dispositivos, como computadores ou módulos externos. No Arduino, a biblioteca Serial
facilita esse tipo de comunicação utilizando o protocolo UART.
Como Funciona
- Velocidade de Comunicação: Definida em bauds (ex.: 9600, 115200), representa o número de bits transferidos por segundo.
- Transmissão e Recepção: Usa dois pinos — TX (transmissão) e RX (recepção) ou comunicação direta com o computador na IDE por cabo.
- Formato de Dados: Tipicamente, cada pacote de dados inclui 8 bits, 1 bit de parada e nenhum bit de paridade.
Configuração inicial
Antes de utilizar a comunicação serial, é necessário inicializá-la na função setup
com o comando:
Serial.begin(9600);
Envio e recebimento de dados
Para enviar dados do microcontrolador, utiliza-se o comando:
Serial.print("Mensagem"); // Envia uma mensagem sem pular linha
Serial.println("Mensagem"); // Envia uma mensagem e adiciona uma nova linha
Para receber dados, é possível verificar se há informações disponíveis com:
if (Serial.available() > 0) {
char dado = Serial.read(); // Lê um byte disponível
Serial.println(dado); // Ecoa o dado recebido
}
Exemplo completo
void setup() {
Serial.begin(9600); // Inicializa a comunicação serial
Serial.println("Iniciando comunicação serial...");
}
void loop() {
if (Serial.available() > 0) {
char recebido = Serial.read();
Serial.print("Você enviou: ");
Serial.println(recebido);
}
delay(100); // Pequena pausa para evitar sobrecarga
}
Aplicações comuns
- Depuração e monitoramento de código.
- Comunicação com módulos Bluetooth, Wi-Fi, ou GPS.
- Envio de comandos para o microcontrolador a partir de um computador ou outro dispositivo.
Compreender a comunicação serial é essencial para criar projetos interativos e para monitorar o comportamento do microcontrolador durante a execução de um programa.
Tutorial sensores básicos
Sensores Estação meteorológica
Nesta seção, serão utilizados os conceitos de programação e arquitetura de microcontroladores dos módulos anteriores de forma aplicada para poder se conectar e comunicar corretamente com alguns dos principais sensores utilizados na OBSAT. Primeiro, introduziremos a comunicação I2C, uma modalidade muito importante para o uso de múltiplos sensores em uma mesma porta do microcontrolador, e em seguida, serão abordados cada um dos sensores individualmente, mostrando como é feita a conexão correta com o microcontrolador e como funcionam os códigos para obter os dados deles.
Comunicação I2C
A comunicação I2C (Inter-Integrated Circuit) é um protocolo de comunicação usado para interconectar dispositivos eletrônicos dentro de um sistema. O protocolo I2C permite que vários dispositivos compartilhem a mesma linha de comunicação, consistindo em duas linhas principais:
- SDA (Serial Data Line): Esta linha é usada para transmitir os dados entre os dispositivos.
- SCL (Serial Clock Line): Essa linha é responsável por sincronizar a transferência de dados.
Esse tipo de comunicação com múltiplos sensores nas mesmas portas só é possível pela diferenciação em "endereços" específicos para cada sensor que são definidos no código. Nos exemplos abaixo, mostra-se como iniciar e configurar essa modalidade de comunicação nos códigos e quais sensores a utilizam.
Sensores
BMP280 - Pressão e temperatura
- Conectar o sensor nas portas de comunicação I2C da seguinte maneira:
- Baixar a biblioteca “Adafruit BMP280 Library” no menu de bibliotecas da Arduino IDE:
- Com o circuito conectado corretamente e com a biblioteca baixada, utilizar o código abaixo na IDE:
#include <Wire.h> // Biblioteca para comunicacao I2C
#include <Adafruit_BMP280.h> // Biblioteca do sensor BMP280
#include <Arduino.h>
#define SDA_PIN 21 // Define o pino SDA
#define SCL_PIN 22 // Define o pino SCL
Adafruit_BMP280 bmp; // Cria o objeto do sensor BMP280
#define SEALEVELPRESSURE_HPA (1013.25) //Defini a pressao para nivel do mar
void setup() {
Serial.begin(9600); // Inicializa a comunicacao serial
// Inicializa a comunicacao I2C com os pinos definidos
Wire.begin(SDA_PIN, SCL_PIN);
// Inicializa o BMP280 com o endereco I2C padrao (0x76 ou 0x77)
if (!bmp.begin(0x76)) {
Serial.println("Nao foi possivel inicializar o sensor BMP280!");
while (1);
}
// Configura o sensor BMP280
bmp.setSampling(Adafruit_BMP280::MODE_NORMAL, // Modo de medicao normal
Adafruit_BMP280::SAMPLING_X2, // Oversampling da temperatura
Adafruit_BMP280::SAMPLING_X16, // Oversampling da pressao
Adafruit_BMP280::FILTER_X16, // Filtro
Adafruit_BMP280::STANDBY_MS_500); // Tempo de espera em modo standby
}
void loop() {
// Le a temperatura e pressao
float temperature = bmp.readTemperature();
float pressure = bmp.readPressure() / 100.0F; // converte para hPa
float altitude = bmp.readAltitude(SEALEVELPRESSURE_HPA); // calcula altitude aproximada pela pressao
// Exibe os valores no monitor serial
Serial.print("Temperatura: ");
Serial.print(temperature);
Serial.print(" C, Pressao: ");
Serial.print(pressure);
Serial.print(" hPa, Altitude: ");
Serial.print(altitude);
Serial.println(" m");
delay(2000); // Aguarda 2 segundos entre as medicoes
}
-
Clicar no ícone de setinha para a direita no topo da IDE e o programa será carregado para ESP32. (Caso a ESP32 esteja com o MicroPython instalado, esse processo o removerá e mudará a placa para C++ automaticamente.)
-
Para receber as informações, basta abrir o monitor serial com a velocidade definida no código; nesse caso, é 9600.
Referência: https://www.instructables.com/How-to-Connect-BMP-280-to-ESP32-Get-Pressure-Tempe/
DHT11 - Umidade e temperatura
- Conectar o sensor DHT11 de acordo com a figura abaixo em uma porta digital, no exemplo foi utilizada a porta GPIO4.
- Com o sensor corretamente conectado, baixar a biblioteca " DHT sernsor library " by Adafruit e todas as suas dependências que a IDE sugerir.
- Carregue na placa o código abaixo e abra o monitor serial para ver os resultados.
#include "DHT.h"
#define DHTPIN 4 // Define qual pino esta sendo usado
#define DHTTYPE DHT11 // Define o tipo de DHT (DHT11 ou DHT22)
DHT dht(DHTPIN, DHTTYPE); // configura o sensor para as opcoes definidas acima
void setup() {
Serial.begin(9600);
dht.begin(); // inicializa o sensor
}
void loop() {
// Espera alguns segundos entre as leituras.
delay(2000);
// Leitura dos dados do sensor
float h = dht.readHumidity(); // Le o valor de humidade
float t = dht.readTemperature(); // Le o valor de temperatura em Celcius (padrao)
float f = dht.readTemperature(true); // Le a temperatura em Fahrenheit
// Checa se alguma das leituras falhou e sai do loop mais cedo para tentar novamente
if (isnan(h) || isnan(t) || isnan(f)) {
Serial.println(F("Failed to read from DHT sensor!"));
return;
}
// Calcula sensacao termica em Fahrenheit (por padrao)
float hif = dht.computeHeatIndex(f, h);
// Calcula sensacao termica em Celsius (isFahreheit = false)
float hic = dht.computeHeatIndex(t, h, false);
// Imprime os valores lidos no monitor serial
Serial.print(F("Humidade: "));
Serial.print(h);
Serial.print(F("%, Temperatura: "));
Serial.print(t);
Serial.print(F(" Celcius "));
Serial.print(f);
Serial.print(F(" Fahreheit, Sensacao termica: "));
Serial.print(hic);
Serial.print(F(" Celcius "));
Serial.print(hif);
Serial.println(F(" Fahreheit"));
}
Referência: https://randomnerdtutorials.com/esp32-dht11-dht22-temperature-humidity-sensor-arduino-ide/
MPU6050 - Giroscópio e acelerômetro
- Conectar o MPU6050 da forma representada na figura abaixo nas portas I2C:
- Baixar a biblioteca “Adafruit MPU6050” e todas as suas dependências que a IDE sugeri:
- Com a biblioteca instalada, basta utilizar o código a seguir:
// Codigo basico de leitura da Adafruit MPU6050
// Bibliotecas utilizadas
#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>
Adafruit_MPU6050 mpu;
void setup(void) {
Serial.begin(115200); // Definindo velocidade do monitor serial
while (!Serial)
delay(10); // Pausa a placa para esperar o console abrir
Serial.println("Adafruit MPU6050 test!");
// Teste de conexao com o sensor
if (!mpu.begin()) {
Serial.println("Falha ao encontrar sensor MPU6050");
while (1) {
delay(10);
}
}
Serial.println("MPU6050 Encontrado!");
// Definindo amplitude do acelerometro
mpu.setAccelerometerRange(MPU6050_RANGE_8_G);
Serial.print("Accelerometer range set to: ");
switch (mpu.getAccelerometerRange()) {
case MPU6050_RANGE_2_G:
Serial.println("+-2G");
break;
case MPU6050_RANGE_4_G:
Serial.println("+-4G");
break;
case MPU6050_RANGE_8_G:
Serial.println("+-8G");
break;
case MPU6050_RANGE_16_G:
Serial.println("+-16G");
break;
}
// Definindo amplitude do giroscopio
mpu.setGyroRange(MPU6050_RANGE_500_DEG);
Serial.print("Gyro range set to: ");
switch (mpu.getGyroRange()) {
case MPU6050_RANGE_250_DEG:
Serial.println("+- 250 deg/s");
break;
case MPU6050_RANGE_500_DEG:
Serial.println("+- 500 deg/s");
break;
case MPU6050_RANGE_1000_DEG:
Serial.println("+- 1000 deg/s");
break;
case MPU6050_RANGE_2000_DEG:
Serial.println("+- 2000 deg/s");
break;
}
// Definindo filtro de largura de banda
mpu.setFilterBandwidth(MPU6050_BAND_5_HZ);
Serial.print("Filter bandwidth set to: ");
switch (mpu.getFilterBandwidth()) {
case MPU6050_BAND_260_HZ:
Serial.println("260 Hz");
break;
case MPU6050_BAND_184_HZ:
Serial.println("184 Hz");
break;
case MPU6050_BAND_94_HZ:
Serial.println("94 Hz");
break;
case MPU6050_BAND_44_HZ:
Serial.println("44 Hz");
break;
case MPU6050_BAND_21_HZ:
Serial.println("21 Hz");
break;
case MPU6050_BAND_10_HZ:
Serial.println("10 Hz");
break;
case MPU6050_BAND_5_HZ:
Serial.println("5 Hz");
break;
}
Serial.println("");
delay(300);
}
void loop() {
/* Get new sensor events with the readings */
sensors_event_t a, g, temp;
mpu.getEvent(&a, &g, &temp);
/* Imprimindo valores */
Serial.print("Acceleration X: ");
Serial.print(a.acceleration.x);
Serial.print(", Y: ");
Serial.print(a.acceleration.y);
Serial.print(", Z: ");
Serial.print(a.acceleration.z);
Serial.println(" m/s^2");
Serial.print("Rotation X: ");
Serial.print(g.gyro.x);
Serial.print(", Y: ");
Serial.print(g.gyro.y);
Serial.print(", Z: ");
Serial.print(g.gyro.z);
Serial.println(" rad/s");
Serial.println("");
delay(750);
}
-
Conectar a placa ao computador na porta COM selecionada
-
Compilar o código para a placa ESP32;
-
Abrir o monitor serial para a configuração definida no código.
TEMT6000 - Luminosidade
- Conectar o sensor TEMT6000 da forma representada na figura abaixo em alguma porta analógica, no exemplo abaixo utilizou-se a porta 34.
- Com o sensor conectado corretamente, não é necessário instalar nenhuma biblioteca adicional, basta utilizar o código abaixo e as leituras devem aparecer no monitor serial.
#define TEMT6000 34 //PINO conectado no TEMT6000
void setup()
{
// PIN MODE
pinMode(TEMT6000, INPUT);
Serial.begin(9600);
}
void loop() {
// Leitura de luminosidade - TEMT6000
analogReadResolution(10); // define resolucao da leitura na porta analogica
float volts = analogRead(TEMT6000) * 5 / 1024.0; // Converte leitura analogica para VOLTS
float VoltPercent = analogRead(TEMT6000) / 1024.0 * 100; //Leitura em porcentagem da tensao
//converte a leitura em LUX
float amps = volts / 10000.0; // converte para ampere considereando resitencia de 10,000 Ohms
float microamps = amps * 1000000; // Converte para Microampere
float lux = microamps * 2.0; // Converte para lux
delay(1000);
// Output no monitor Serial
Serial.print("LUX - ");
Serial.print(lux);
Serial.println(" lx");
Serial.print(VoltPercent);
Serial.println("%");
Serial.print(volts);
Serial.println(" volts");
Serial.print(amps);
Serial.println(" amps");
Serial.print(microamps);
Serial.println(" microamps");
delay(1000);
}
Referência: https://github.com/CraftzAdmin/esp32/blob/main/Sensors/TEMT6000/README.md
Projeto final
Agora que você sabe como funciona a arquitetura de um microcontrolador, como funciona a programação em C++ e como utilizar cada um dos sensores acima, teste seus conhecimentos montando a estação meteorológica completa. A montagem da estação meteorológica completa consiste em conectar todos os sensores simultaneamente às mesmas portas utilizadas nos exemplos apresentados na seção anterior e criar um código que consiga imprimir no monitor serial todos os dados.
É importante destacar que os sensores BMP280 e MPU6050 compartilham as mesmas portas de comunicação. Contudo, isso não representa um problema, pois o protocolo de comunicação I2C permite a utilização de múltiplos dispositivos na mesma linha de dados. No código, os endereços específicos de cada sensor são utilizados para diferenciar e realizar a leitura simultânea de ambos.