Curso - Robótica Sensores e Atuadores V1

CURSO DE ROBÓTICA
ROBOTECH
APOSTILA DO CURSO DE ROBÓTICA DA ROBOTECH
(VERSÃO EM DESENVOLVIMENTO)
Robotech
DATA: 29/06/2023
Sumário
I. Programação Básica do ESP32 .............................................................................................................................................4
1.1. Que é o ESP32? ......................................................................................................................................................................4
1.2. Caraterísticas do ESP32.....................................................................................................................................................4
1.3. Como simular circuitos no Tinkercad – Primeiros Passos........................................................................... 6
1.4. Circuitos simples de bateria e resistores Tinkercad ....................................................................................... 11
1.5. Programas Básicos no TinkerCad............................................................................................................................. 13
Pisca-Pisca com um Led ....................................................................................................................................... 13
Pisca-Pisca com dois Leds ................................................................................................................................... 14
Usando chaves para ligar e desligar um Led ........................................................................................... 15
1.6. Instalação de Programas ............................................................................................................................................... 15
1.7. Programas práticos e básicos usando o Esp32 – Vamos pra práticas ............................................... 19
II. Revisão, leds e botões............................................................................................................................................................... 20
2.1. Como fazer um pisca pisca de dois Leds com e sem Delay ................................................................... 20
2.1.1. Pisca Pisca de dois Leds com Delay .................................................................................................................. 20
2.1.2. Pisca Pisca de dois Leds sem Delay .............................................................................................................. 23
2.2. Como usar botões no Esp32 ....................................................................................................................................... 25
2.2.1. Uso de botões com Delay .................................................................................................................................... 25
2.2.2. Uso de botões com detecção de borda...................................................................................................... 28
2.2.3. Uso de botões usando tempo anti debounce ........................................................................................ 29
2.2.4. Uso de botões usando tempo anti debounce usando a biblioteca ezButton ................... 30
III. Entradas Analógicas .............................................................................................................................................................. 31
3.1. Como realizar a leitura de uma entrada analógica e visualizar no monitor serial ..................... 31
3.2. Controlando a velocidade de um sequencial de 5 leds usando uma entrada analógica .... 33
3.3. Ligando 5 leds em função do nível de tensão de uma entrada analógica ................................... 35
3.4. Plotando 3 entradas analógicas usando o serial plotter ........................................................................... 36
3.5. Uso do Display OLED ....................................................................................................................................................... 39
IV. Sensores ....................................................................................................................................................................................... 42
4.1. Sensor de Luminosidade – LDR ................................................................................................................................ 42
4.2. Ultrassom ................................................................................................................................................................................44
4.3. NTC – Resistor sensível à temperatura ................................................................................................................. 46
4.3.1. NTC – Resistor sensível à temperatura ........................................................................................................ 46
4.3.2. NTC – Mostrando a temperatura num Display OLED........................................................................ 49
4.4. O DHT22 – Sensor de Umidade e Temperatura ............................................................................................... 51
4.4.1. Programa Básico do DHT22..................................................................................................................................... 51
4.4.2. Mostrando a umidade e temperatura medida pelo DHT22 num display OLED .............. 53
4.4.3. Medição da umidade e temperatura usando o DHT22 e DHT11 num display OLED ..... 55
www.gaintech.com.br
Robotech
DATA: 29/06/2023
4.5. O Max98DHT22 – Sensor de Umidade e Temperatura .............................................................................. 58

V. Atuadores ......................................................................................................................................................................................... 62
5.1. O PWM, modulação por largura de pulso ................................................................................................................ 62
5.1.1. Controlando a luminosidade de um Led usando o PWM ....................................................................... 62
5.2. Usando o PWM e entradas Analógicas ................................................................................................................ 65
5.3. Como usar um Led RGB ................................................................................................................................................ 68
5.4. Buzzer Passivo, produzindo SOM ............................................................................................................................. 71
5.5. Buzzer Passivo, construindo um mini piano .................................................................................................... 72
5.6. Buzzer Passivo, o hino de um time de futebol ................................................................................................ 75
5.7. Como ligar um motor de corrente continua usando o LD298 ............................................................. 75
5.8. Ligando um servomotor – controlando a posição de uma haste ....................................................... 75
5.9. Ligando um servomotor – controlando sua velocidade............................................................................ 75
VI. Projetos Finais .......................................................................................................................................................................... 76
6.1. Montagem de um robô móvel usando motores CC.................................................................................... 76
6.2. Montagem de um robô móvel usando servomotores ............................................................................... 76
6.3. Montagem de um robô que mexe cabeça e braços, e tem olhos piscando. ............................... 76
www.gaintech.com.br
Robotech
DATA: 29/06/2023
I. Programação Básica do ESP32

1.1. Que é o ESP32?
O ESP32 é um microcontrolador desenvolvido pela Espressif Systems que possui uma vasta gama
de aplicações no campo de Internet das Coisas (IoT) e robótica, devido às suas capacidades
avançadas de conectividade que conta com Wi-Fi e Bluetooth e alto poder de processamento com
dois núcleos de 32 bits. Além disso, o ESP32 oferece uma variedade de recursos, como interfaces
para periféricos, conversores analógico-digital (ADC), interfaces de comunicação serial, GPIOs
(General Purpose Input/Output), dentre outros.
Uma das principais vantagens do ESP32 é sua flexibilidade e capacidade de integração, podendo
ser programado usando o Arduino IDE, Micropython, ESP-IDF (Espressif IoT Development
Framework), dentre outras opções de desenvolvimento, o que facilita a criação de projetos de
robótica.
1.2. Caraterísticas do ESP32

Característica Descrição
Arquitetura Xtensa LX6 (Dual-Core)
Frequência de clock Até 240 MHz
520 KB de SRAM (Static Random-Access Memory)
Memória 448 KB de ROM (Read-Only Memory)
4 MB de Flash SPI (Serial Peripheral Interface)
Wi-Fi 802.11 b/g/n
Conectividade
Bluetooth (Classic e BLE - Bluetooth Low Energy)
GPIOs (General Purpose Input/Output)
UART (Universal Asynchronous Receiver-Transmitter)
I2C (Inter-Integrated Circuit)
SPI (Serial Peripheral Interface)
ADC (Analog-to-Digital Converter)
Interfaces
DAC (Digital-to-Analog Converter)
PWM (Pulse Width Modulation)
I2S (Integrated Interchip Sound)
SD/MMC (Secure Digital/Multimedia Card)
USB (Universal Serial Bus)
Linguagens de programação suportadas Arduino IDE, Micropython, ESP-IDF (Espressif IoT Development Framework)
Tensão de operação: 2,2V a 3,6V
Alimentação
Consumo de energia baixo
Internet das Coisas (IoT)
Automação residencial
Monitoramento e controle de dispositivos
Aplicações
Wearables (Dispositivos Vestíveis)
Sistemas de segurança
Robótica
www.gaintech.com.br
Robotech
DATA: 29/06/2023
A seguinte figura mostra a distribuição dos pinos para o modelo do Espduino que tem formato de
um Arduino Uno.
A seguinte figura mostra a distribuição dos pinos para o modelo do Esp32 DevKit V1 – 30 pinos.
www.gaintech.com.br
Robotech
DATA: 29/06/2023
Algumas caraterísticas do Esp32:
▪ Processadores:
▪ CPU: Xtensa dual-core (or single-core) 32-bit LX6 microprocessor, opera em 160 or
240 MHz
▪ Ultra low power (ULP) co-processor
▪ Memoria: 520 KiB SRAM
▪ Wireless conectividade:
▪ Wi-Fi: 802.11 b/g/n
▪ Bluetooth: v4.2 BR/EDR and BLE (shares the radio with Wi-Fi)
1.3. Como simular circuitos no Tinkercad – Primeiros Passos
O software Tinkercad é o ambiente que utilizaremos para efetuar simulações e colocar em prática
a teoria estudada. Ele é um software gratuito desenvolvido pela Autodesk, que pode ser utilizado
para modelar projetos em 3D de forma rápida e fácil, além de permitir executar simulações de
circuitos projetados e até mesmo preparar projetos para impressão 3D. Abaixo segue o tutorial de
acesso e criação de conta no ambiente:
1. Acesse https://www.Tinkercad.com e clique em inscrever-se.
Figura 1: Imagem 1 referente ao passo a passo para executar o Tinkercad
www.gaintech.com.br
Robotech
DATA: 29/06/2023
2. Clique em Criar uma conta pessoal.
3. Escolha uma opção se tiver uma conta do google (Gmail). Caso faça login com o GMail pule os
passos abaixo.
www.gaintech.com.br
Robotech
DATA: 29/06/2023
4. Caso você tenha escolhido a opção “Entrar com o e-mail” (opção em azul), siga escolhendo o país
e sua data de nascimento.
5. Coloque seu e-mail e escolha uma senha para acessar o Tinkercad e clique em CRIAR CONTA.
6. Parabéns! Você criou sua conta.
www.gaintech.com.br
Robotech
DATA: 29/06/2023
Tutorial: Como fazer login?
1. Clique no botão indicado.
www.gaintech.com.br
Robotech
DATA: 29/06/2023
2. Clique no link indicado.
3. Escolha uma opção de sua preferência.
4. Agora você está pronto para utilizar o software, projetando circuitos e as simulações que desejar.
www.gaintech.com.br
Robotech
DATA: 29/06/2023
1.4. Circuitos simples de bateria e resistores Tinkercad
Após finalizar o tutorial e efetuar o login no Tinkercad, vamos clicar em novo projeto e selecionar
circuito, como mostra o tutorial abaixo.
Passo 1: Após efetuar o login no site clique em “Novo”, como mostra a figura abaixo.
Figura 10: Como criar um novo circuito no Tinkercad
Passo 2: Depois de efetuar o passo 1, selecione “circuito” e o ambiente para modelagem e simulação
será aberto.
Figura 11: Como criar um novo circuito no Tinkercad - Parte 2
Dentro deste ambiente vamos começar a montar nossos primeiros circuitos. Em nosso primeiro
exemplo vamos ligar uma bateria em série com um resistor e efetuar a medição da corrente. Ao
lado direito do painel que é apresentado para o usuário estão todos os componentes que podemos
www.gaintech.com.br
Robotech
DATA: 29/06/2023
utilizar. Para este caso será necessário uma bateria de 3 volts, um resistor, que será mantido com o
valor de 1 KΩ, além de um multímetro que utilizaremos para efetuar a medição da corrente.
Execute a montagem como mostra a figura abaixo e verifique se a medição apresentada é
condizente com valor encontrado na fórmula da corrente, 𝐼 = 𝑉 ÷ 𝑅.
Figura 12: Circuito com 1 resistor
Agora, adicione um novo resistor ao circuito construído e verifique o novo valor da corrente medida.
Figura 13: Circuito com 2 resistores
www.gaintech.com.br
Robotech
DATA: 29/06/2023
Ratifique que o valor apresentado no multímetro estará conforme o esperado nesse novo caso.
Como temos uma nova resistência de 1 KΩ no circuito, a resistência total se torna maior e a corrente
que circula se torna menor. É possível notar o valor de 1,49 mA apresentado pelo software,
enquanto no primeiro caso a medição foi de 2,97 mA. Como foi observado, é preciso ligar o
multímetro em série com o circuito para efetuar a medição da corrente. Porém, no caso de efetuar
a medição da tensão em cima do resistor é necessário efetuar a medição em paralelo.
1.5. Programas Básicos no TinkerCad

Pisca-Pisca com um Led
Lista de Componentes:
- Led, Resistência de 180 Ω e Arduino Uno
Circuito:
www.gaintech.com.br
Robotech
DATA: 29/06/2023
Código:
void setup(){
pinMode(2, OUTPUT);//Saida: OUTPUT, Entrada:INPUT
}
void loop()
{
digitalWrite(2, HIGH); //Liga pino 2, envia 3,3V para o pino 2
delay(1000); // Espera 1000 mseg ou 1 segundo
digitalWrite(2, LOW); //Desliga o pino 2, envia 0v para o pino 2
delay(1000); // Wait for 1000 millisecond(s)
}
Pisca-Pisca com dois Leds
Lista de Componentes: - 2 LedS, 2 Resistêncisa de 180 Ω e Arduino Uno
Código:
#define pinLed1 2
#define pinLed2 4
void setup() {
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
}
void loop() {
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
delay(500);
digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, HIGH);
delay(500);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
Usando chaves para ligar e desligar um Led
Lista de Componentes:
- 1 LedS
- 1 Resistêncisa de 180 Ω
- 2 micro chaves
- Arduino Uno
1.6. Instalação de Programas
O software que será utilizado para programar a ESP-32 será o Arduino IDE, onde se pode programar
o ESP-32 utilizando a linguagem C++. Para fazer a instalação do Arduino IDE, podemos seguir os
seguintes passos:
Passo 1: Acesse o site oficial do Arduino em https://www.arduino.cc/.
Passo 2: Clique na seção "Software" no menu principal.
www.gaintech.com.br
Robotech
DATA: 29/06/2023
Passo 3: Na página do software, você verá as opções de Download do "Arduino IDE para Windows,
macOS e Linux. Escolha a versão adequada ao seu sistema operacional e clique no link
correspondente.
Passo 4: Após o download do arquivo de instalação, abra-o e siga as instruções do instalador.
Passo 5: Durante a instalação, você poderá escolher o local de instalação e outras opções, como a
adição de atalhos na área de trabalho.
www.gaintech.com.br
Robotech
DATA: 29/06/2023
Passo 6: Após a conclusão da instalação do ambiente de programação (IDE) do Arduino é

necessário incluir um endereço eletrônico (URL) para que o programa tenha o caminho para incluir
a placa de desenvolvimento do ESP32. Assim, entre no menu “Arquivo/Preferências” e na opção:
“URLs do Gerenciador de Placas Adicionais” preencher:
https://dl.espressif.com/dl/package_esp32_index.json
Passo 7: Instalar a placa ESP32. Clicar na opção do menu: Ferramentas/Placa/Gerenciador de

Placas. Posteriormente aparece uma janela no lado esquerdo uma janela para facilitar a instalação
da placa. Escreva “Esp32” e selecione a opção “INSTALAR”
www.gaintech.com.br
Robotech
DATA: 29/06/2023
Agora SIM, entre as opções de placas deve aparecer o ESP32, como se mostra na seguinte figura.
Passo 8: Baixar os driver e instalar, pode baixar o driver diretamente do site do fabricante
acessando: https://www.wch.cn/downloads/CH343SER_EXE.html . O site está em chinese, desta
forma recomendo usar a ferramenta de tradução do seu navegador.
Acessar ao Gerenciador de dispositivos para verificar se o Windows reconheceu corretamente a

placa de desenvolvimento ESP32. É só digitar “Gerenciador de Dispositivos” em pesquisar no lado
inferior esquerdo da tela.
www.gaintech.com.br
Robotech
DATA: 29/06/2023
No Gerenciador de Dispositivos do Windows, após conectar a placa no cabo e numa porta USB do
computador, você deve observar que o Windows reconheceu corretamente tua placa.
1.7. Programas práticos e básicos usando o Esp32 – Vamos pra práticas
Neste livro, veremos como fazer alguns programas básicos utilizando o ESP-32 a fim de treinarmos
conceitos e componentes importantes. Inicialmente, faremos uma revisão e aprenderemos sobre
o controle de leds e de botões conectados ao ESP-32. Posteriormente, serão abordados os temas
de entradas analógicas, sensores e atuadores. Para finalizar, há um projeto fina que engloba todos
os conceitos aprendidos no curso.
www.gaintech.com.br
Robotech
DATA: 29/06/2023
II. Revisão, leds e botões

2.1. Como fazer um pisca pisca de dois Leds com e sem Delay
Nesta seção, veremos como fazer um pisca-pisca utilizando LEDs. Primeiramente, vamos utilizar a
função delay, que faz com que o sistema aguarde sem realizar nenhuma operação.
Posteriormente, faremos o mesmo pisca-pisca sem utilizar a função delay, utilizando a contagem
de tempo da função millis.
2.1.1. Pisca Pisca de dois Leds com Delay
No código abaixo, declaramos os pinos do led verde e do led amarelo, representado

respectivamente pelas variáveis ledPinVerde e ledPinAmarelo, cujos valores são respectivamente
2 e 4. O estado do led é declarado na linha seguinte pela variável ledState e é iniciado com o valor
0, ou seja, led apagado. Em seguida, é declarada a variável do contador, que se inicia com zero.
A seguir, temos a função setup, que roda uma única vez dentro do microcontrolador ESP-32 e serve
para fazer as configurações iniciais. Nesta função os pinos do led vermelho e led amarelo,
respectivamente declarados pelas variáveis ledPinVerde e ledPinAmarelo são definidos como pino
de saída por meio da função pinMode. Além disso, é configurada velocidade de comunicação serial
em 9.600bps.
Posteriormente, há a função loop que roda continuamente. A primeira linha da função loop, inverte
o estado da variável ledState e retorna para ela mesma. A seguir, as duas próximas linhas
configuram o valor dos leds verde e amarelo para o valor de ledState e o inverso do valor de
ledState. Após isso, o sistema aguarda 1000 ms, ou seja, 1 s, e depois a variável contador é
incrementada em uma unidade. Para finalizar e voltar ao loop, o sistema envia para a porta serial o
valor do contador que pode ser lida pelo monitor serial.
/*
* Programando um pisca pisca com delay no Esp32
* Nosso canal no Youtube: https://www.youtube.com/@RoboTech-ProfeMC
*/
const int ledPinVerde = 2; // pino do esp32 ligado ao Led verde
const int ledPinAmarelo = 4; // pino do esp32 ligado ao Led Amarelo
bool ledState = 0; // variável que representa o estado do Led
int Contador = 0;
void setup() {
pinMode(ledPinVerde, OUTPUT); //Definição do pino do Led como saída
pinMode(ledPinAmarelo, OUTPUT); //Definição do pino do Led como saída
// Inicialização da comunicação serial 9600 bps:
Serial.begin(9600);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
void loop() {
ledState = !ledState;
digitalWrite(ledPinVerde, ledState); //atualiza o valor do Led
digitalWrite(ledPinAmarelo, !ledState); //atualiza o valor do Led
delay(1000);
Contador = Contador + 1;
Serial.println(Contador);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
2.1.2. Pisca Pisca de dois Leds sem Delay
Neste exemplo, veremos como podemos fazer o mesmo processo realizado no código anterior,
porém sem a utilização da função delay. Para isso, vamos definir uma variável usada para
armazenar o último valor do tempo (em milissegundos), no qual o led mudou de estado, chamada
de previousMillis e iniciada com zero. Além disso, é declarada a variável interval, que é o
intervalo de tempo em que os leds irão piscar, ou seja, 1000 ms ou 1 s.
Para realizar a contagem de tempo dentro da função loop, primeiro declaramos uma variável
inteira, chamada de currentMillis e atribuímos a ela o valor retornado da função millis. Esta
função retorna o valor do tempo atual e servirá para fazermos o cálculo da passagem de tempo.
Em seguida, comparamos o valor de currentMillis com o valor de previousMillis, fazendo a

subtração currentMillis – previousMillis. Observe que essa diferença é justamente a passagem
de tempo e é feita uma verificação para ver se essa diferença é maior ou igual ao valor interval
definido previamente. Caso seja, o valor de previousMillis recebe o valor de currentMillis e o
estado do led é trocado, isto é, se estiver aceso, ele apaga e vice-versa, assim como no exemplo
anterior.
Note que apenas quando a diferença de tempo é maior ou igual a 1 s, que o sistema troca o estado
dos leds. Então o currentMillis volta para a contagem de tempo e apenas depois de passar mais
um segundo que o led troca de estado. Esta é uma abordagem em que é feita a contagem de
tempo para que seja feito o controle do pisca-pisca. No exemplo anterior, isso é feito esperando 1 s
passar por meio da função delay.
/*
* Programando um pisca pisca sem delay no Esp32
*/
const int ledPinVerde = 2; // pino do esp32 ligado ao Led verde
const int ledPinAmarelo = 4; // pino do esp32 ligado ao Led Amarelo
int Contador = 0;
// variável usada para armazenar o último valor do tempo em que o Led mudou de estado
unsigned long previousMillis = 0;
const long interval = 1000; // intervalo de tempo em milisegundos
void setup() {
pinMode(ledPinVerde, OUTPUT); //Definição do pino do Led como saída
pinMode(ledPinAmarelo, OUTPUT); //Definição do pino do Led como saída
Serial.begin(9600);
www.gaintech.com.br
Robotech
DATA: 29/06/2023
void loop() {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {

// armazena o valor do tempo
previousMillis = currentMillis;
// o estado atual, será o negado do anterior

digitalWrite(ledPinVerde, ledState); //atualiza o valor do Led
digitalWrite(ledPinAmarelo, !ledState); //atualiza o valor do Led
}
Serial.println(Contador);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
2.2. Como usar botões no Esp32
Os botões são uma interface de entrada no ESP-32, sendo importante para pegar informações do
usuário e colocar dentro do sistema. Os botões alteram o valor lógico nos pinos de entrada que
estão conectados, levando assim a informação desejada para dentro do sistema. Vamos ver
diferentes formas de tratar os botões, que é a utilização de delay, detecção de borda e utilização
de anti-debouncing. Esses recursos são importantes para garantir uma leitura estável do botão e
evitar que seja acionado de forma incorreta.
2.2.1. Uso de botões com Delay
/*
* Código para testar o uso simples de um button
* neste exemplo será possível visualizar o problema do debouce
* ao apertar o botão uma vez, o uC detecta isto como se o botão tivesse sido apertado
várias vezes
* Código para uma placa Esp32
*/
#define BUTTON_PIN 26 // Pino 26 Conectado ao Button

#define LedPino2 2 // Pino do Led
//Vairáveis
int currentState; // O estado atual do button
int Contador = 0;
void setup() {
Serial.begin(9600);
// Inicializando o pino do Button como entrada e com resistência PullUp
// Nesta configuração existe uma resistância para 3.3 V, assim quando o button esteja
//pressionado a leitura do pino de entrada será HIGH ou "1" e ao apertar o buttos o valor
será LOW ou "0"
pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(LedPino2, OUTPUT);
}
void loop() {
// Leitura do valor atual do button
currentState = digitalRead(BUTTON_PIN);
if (currentState == LOW)
{
www.gaintech.com.br
Robotech
DATA: 29/06/2023
Serial.print("Apertou o botão ");
Serial.print(Contador);
Serial.println(" Vezes ");
digitalWrite(LedPino2, ledState);
delay(100);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
2.2.2. Uso de botões com detecção de borda

/*
*/

//Vairáveis
int lastState = LOW; // O estado anterior do pino de entrada ou button
int Contador = 0;
void setup() {
Serial.begin(9600);
// Nesta configuração existe uma resistência para 3.3 V, assim quando o button esteja
//sem apertar o botão o estado do pino será HIGH ou "1" e ao apertar o button o valor será LOW ou "0"
}
void loop() {
if (lastState == HIGH && currentState == LOW)

{
delay(50);
}
// salva o valor atual em outra vairável, para que depois seja o estado anterior do button
lastState = currentState;
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
2.2.3. Uso de botões usando tempo anti debounce

/*
*/

//Vairáveis
int lastState = LOW; // O estado anterior do pino de entrada ou button
int Contador = 0;
void setup() {
Serial.begin(9600);
// Nesta configuração existe uma resistência para 3.3 V, assim quando o button esteja
//sem apertar o botão o estado do pino será HIGH ou "1" e ao apertar o button o valor será LOW ou "0"
}
void loop() {
if (lastState == HIGH && currentState == LOW)

{
delay(50);
}
// salva o valor atual em outra vairável, para que depois seja o estado anterior do button
lastState = currentState;
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
2.2.4. Uso de botões usando tempo anti debounce usando a biblioteca ezButton
/*
#include <ezButton.h>
#define DEBOUNCE_TIME 40 // the debounce time in millisecond, increase this time if it still chatters
ezButton button(26); // create ezButton object that attach to pin GIOP26
void setup() {
Serial.begin(115200);
button.setDebounceTime(DEBOUNCE_TIME); // set debounce time to 50 milliseconds
}
void loop() {
button.loop(); // MUST call the loop() function first
if (button.isPressed())
Serial.println("The button is pressed");
if (button.isReleased())
Serial.println("The button is released");
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
III. Entradas Analógicas

3.1. Como realizar a leitura de uma entrada analógica e visualizar no monitor serial
/*
* Código que demonstra como usar uma entrada analógica no Esp32
* mostra o valor analógico de um potenciômetro no monitor serial
*/
#define AN_Pot1 2
int AN_Pot1_Resultado = 0;
#define Led1Menor 14
#define Led2Maior 17
void setup()
{
pinMode(Led1Menor, OUTPUT);
pinMode(Led2Maior, OUTPUT);
}
void loop()
{
AN_Pot1_Resultado = analogRead(AN_Pot1);
Serial.println(AN_Pot1_Resultado);
if (AN_Pot1_Resultado < 400)
digitalWrite(Led1Menor, HIGH);
else
digitalWrite(Led1Menor, LOW);
if (AN_Pot1_Resultado > 600)

digitalWrite(Led2Maior, HIGH);
else
digitalWrite(Led2Maior, LOW);
delay(100);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
3.2. Controlando a velocidade de um sequencial de 5 leds usando uma entrada analógica

/*
#define AN_Pot1 2
#define LedAz 25
#define LedVerde 17
#define LedAmar 16
#define LedLaran 27
#define LedVerm 14
int Tempo = 0;
int AN_Pot1_Result = 0;
void setup()
{
pinMode(LedAz, OUTPUT);
pinMode(LedVerde, OUTPUT);
pinMode(LedAmar, OUTPUT);
pinMode(LedLaran, OUTPUT);
pinMode(LedVerm, OUTPUT);
}
void loop()
{
AN_Pot1_Result = analogRead(AN_Pot1);
Serial.println(AN_Pot1_Result);
Tempo = AN_Pot1_Result/4;
for (int i = 0; i <= 4; i++) {
digitalWrite(LedAz, i==0);
digitalWrite(LedVerde, i==1);
digitalWrite(LedAmar, i==2);
digitalWrite(LedLaran, i==3);
digitalWrite(LedVerm, i==4);
delay(Tempo);
}
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
3.3. Ligando 5 leds em função do nível de tensão de uma entrada analógica

#define AN_Pot1 2
#define LedAz 25
#define LedVerde 17
#define LedAmar 16
#define LedLaran 27
#define LedVerm 14
int AN_ValDig = 0;
double Volts = 0; //pode usar float também
void setup()
{
pinMode(LedAz, OUTPUT);
pinMode(LedAmar, OUTPUT);
pinMode(LedLaran, OUTPUT);
pinMode(LedVerm, OUTPUT);
}
void loop()
{
AN_ValDig = analogRead(AN_Pot1);
Serial.print("Valor Digital: ");
Serial.print(AN_ValDig);
Volts = AN_ValDig*3.3/4095;
Serial.print(" Tensão: ");
Serial.println(Volts);
digitalWrite(LedAz, Volts <= 0.66);

digitalWrite(LedVerde, (Volts >= 0.66) && (Volts <= 1.32));
digitalWrite(LedAmar, (Volts >= 1.32) && (Volts <= 1.98));
digitalWrite(LedLaran, (Volts >= 1.98) && (Volts <= 2.64));
digitalWrite(LedVerm, Volts >= 2.64);
delay(500);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
3.4. Plotando 3 entradas analógicas usando o serial plotter

#define AN_Pot1 2
#define AN_Pot2 4
#define AN_Pot3 35
double Volts1 = 0, Volts2 = 0, Volts3 = 0; //pode usar float também
void setup()
{
}
void loop()
{
Volts1 = AN_Pot1_Resultado*3.3/4095;
Serial.print(Volts1);
Serial.print(" ");
Serial.print(" ");
Serial.println();
delay(300);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
3.5. Uso do Display OLED

// Uso do Display OLED SSD1306
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display largura, em pixels

#define SCREEN_HEIGHT 64 // OLED display altura, em pixels
#define AN_Pot1 2
float tensao = 0;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
void setup() {
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3D for 128x64
Serial.println(F("SSD1306 allocation failed"));
for(;;);
}
display.clearDisplay();
display.setTextSize(1); display.setTextColor(WHITE); display.setCursor(33, 0);
display.println("Oi, Brasil!");
display.drawRect(10, 16, 106, 12, WHITE);

display.drawCircle(10, 16, 8, WHITE);
display.drawCircle(116, 16, 8, WHITE);
display.fillCircle(26, 16, 8, WHITE);
display.fillCircle(100, 16, 8, WHITE);
display.fillRoundRect(35, 19, 56, 6, 2, WHITE);

display.drawLine(0, 30, 127, 30, WHITE);
display.setCursor(3, 36); display.setTextSize(2); display.println("Prof Marco");

display.display();
delay(4000);
}
void loop() {
tensao = analogRead(AN_Pot1)*3.3/4095;
Serial.print("V : ");
Serial.println(tensao);
display.setCursor(2, 0); display.setTextSize(2); display.println("Prof Marco");

// mostra o valor da tensão no display OLED
display.setCursor(5, 20); display.print("V:"); display.print(tensao);
display.fillRoundRect(5, 50, tensao*118/3.3, 10, 2, WHITE);
display.display();
delay(300);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
IV. Sensores
4.1. Sensor de Luminosidade – LDR

//Exemplo LDR (Light Dependent Resistor)
#define LedVermelho 26
#define LedLaranja 25
#define LedAmarelo 17
#define LedBranco 16
#define pino_SensorLuz 14
int sensorLuz;
void setup()
{
Serial.begin(115200); //Inicialização da porta serial
pinMode(LedVermelho, OUTPUT);
pinMode(LedLaranja, OUTPUT);
pinMode(LedAmarelo, OUTPUT);
pinMode(LedBranco, OUTPUT);
}
void loop()
{
sensorLuz = analogRead(pino_SensorLuz); // read analog input pin 0
Serial.println(sensorLuz, DEC); // prints the value read
digitalWrite(LedBranco, sensorLuz <= 1500);

digitalWrite(LedAmarelo, sensorLuz <= 1700);
digitalWrite(LedLaranja, sensorLuz <= 1800);
digitalWrite(LedVermelho, sensorLuz <= 2000);
delay(700); // wait 100ms for next reading

}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
4.2. Ultrassom
const int trigPin = 27;
const int echoPin = 26;
#define LedVerde 12
#define LedVermelho 13
//definindo a velocidade do som em cm/uS

#define SOUND_SPEED 0.034
long duration;
float distanceCm;
float distanceInch;
void setup() {
Serial.begin(115200); // Starts the serial communication
pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
pinMode(echoPin, INPUT); // Sets the echoPin as an Input
pinMode(LedVermelho, OUTPUT);
}
void loop() {
// Clears the trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// Leitura do pino echoPin, tempo que demorou em ir e voltar
duration = pulseIn(echoPin, HIGH);
// Cálculo da Distância
distanceCm = duration * SOUND_SPEED/2;
// Mostra a distância através da comunicação Serial

Serial.print("Distância (cm): ");
Serial.println(distanceCm);
digitalWrite(LedVerde, distanceCm>=12 && distanceCm<=20 );

digitalWrite(LedVermelho, distanceCm<12 || distanceCm>20);
delay(1000);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
4.3. NTC – Resistor sensível à temperatura
4.3.1. NTC – Resistor sensível à temperatura

// NTC B3950 Thermistor
// the formula for temp in kelvin is
// 1
// T = ----------------------------
// 1/To + (1/beta) * ln(Rt/Ro)
//
// https://en.wikipedia.org/wiki/Thermistor
int NTCPin = 26;
double R1 = 10000.0; // voltage divider resistor value

double Beta = 3950.0; // Beta value
double To = 273.15+25.0; // Temperature in Kelvin for 25 degree Celsius
double Ro = 10000.0; // Resistance of Thermistor at 25 degree Celsius
void setup() {
}
void loop() {
double Vout, Rt = 0;
double T, Tc, Tf = 0;
double adc = 0;
adc = analogRead(NTCPin);
Vout = adc * 3.3/4095.0;
Rt = R1 * Vout / (3.3 - Vout);
T = 1/(1/To + log(Rt/Ro)/Beta); // Temperatura em Kelvin
Tc = T - 273.15; // Celsius
Tf = Tc * 9 / 5 + 32; // Fahrenheit
if (Tc > 0) Serial.println(Tc);
Serial.println(adc);
delay(1000);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
4.3.2. NTC – Mostrando a temperatura num Display OLED

// NTC B3950 Thermistor
// the formula for temp in kelvin is
// 1
// T = ----------------------------
// 1/To + (1/beta) * ln(Rt/Ro)
//
// https://en.wikipedia.org/wiki/Thermistor
//Bibliotecas para o OLED display
#include <Wire.h>

int NTCPin = 26;
double R1 = 10000.0; // voltage divider resistor value

double Beta = 3950.0; // Beta value
double To = 273.15+25.0; // Temperature in Kelvin for 25 degree Celsius
double Ro = 10000.0; // Resistance of Thermistor at 25 degree Celsius
const double rx = Ro * exp(-Beta/To);
void setup() {

for(;;);
}
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(33, 0);
// Oled siplay 128x64
display.println("Oi, Brasil!");
display.fillRoundRect(35, 19, 56, 6, 2, WHITE);

display.drawLine(0, 30, 127, 30, WHITE);
display.println("Prof Marco");
display.display();
delay(4000);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
void loop() {
double Vout, Rt = 0;
double T, Tc, Tf = 0;
double adc = 0;
adc = analogRead(NTCPin);
Vout = adc * 3.3/4095.0;
Rt = R1 * Vout / (3.3 - Vout);
T = 1/(1/To + log(Rt/Ro)/Beta); // Temperature in Kelvin

//T = Beta/log(Rt/rx);
Tc = T - 273.15; // Celsius
Tf = Tc * 9 / 5 + 32; // Fahrenheit
if (Tc > 0) Serial.println(Tc);
Serial.println(adc);
display.print("T:");
display.print(Tc);
display.fillRoundRect(5, 50, Tc*118/50, 10, 2, WHITE);
display.display();
delay(1000);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
4.4. O DHT22 – Sensor de Umidade e Temperatura

4.4.1. Programa Básico do DHT22
/*
* This ESP32 code is created by esp32io.com
*
* This ESP32 code is released in the public domain
*
* For more detail (instruction and wiring diagram), visit
https://esp32io.com/tutorials/esp32-temperature-humidity-sensor
*/
#include <DHT.h>
#define DHT_SENSOR_PIN 26 // ESP32 pin GIOP21 connected to DHT22 sensor
#define DHT_SENSOR_TYPE DHT22
DHT dht_sensor(DHT_SENSOR_PIN, DHT_SENSOR_TYPE);
void setup() {
dht_sensor.begin(); // initialize the DHT sensor
}
void loop() {
// read humidity
float humi = dht_sensor.readHumidity();
// read temperature in Celsius
float tempC = dht_sensor.readTemperature();
// read temperature in Fahrenheit
float tempF = dht_sensor.readTemperature(true);
// check whether the reading is successful or not

if ( isnan(tempC) || isnan(tempF) || isnan(humi)) {
Serial.println("Failed to read from DHT sensor!");
} else {
Serial.print("Humidity: ");
Serial.print(humi);
Serial.print("%");
Serial.print(" | ");
Serial.print("Temperature: ");
Serial.print(tempC);
Serial.print("°C ~ ");
Serial.print(tempF);
Serial.println("°F");
}
delay(2000); // wait a 2 seconds between readings

}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
4.4.2. Mostrando a umidade e temperatura medida pelo DHT22 num display OLED
#include <DHT.h>
#define DHT_SENSOR_PIN 26 //Pino de dados do Sensor DHT22
#define DHT_SENSOR_TYPE DHT22
DHT dht_sensor(DHT_SENSOR_PIN, DHT_SENSOR_TYPE);
//Bibliotecas para o OLED
#include <Wire.h>
void setup() {
dht_sensor.begin(); // Inicializando o Sensor DHT
delay(500);
for(;;);
}
display.setTextSize(2); display.setTextColor(WHITE);
display.setCursor(0, 0); display.println("Oi-Brasil!");
display.setCursor(3, 36); display.setTextSize(2);
display.display();
delay(4000);
}
void loop() {
float humi = dht_sensor.readHumidity(); // Leitura de Umidade
float tempC = dht_sensor.readTemperature(); // Leitura de temperatura em Celsius
if ( isnan(tempC) || isnan(humi)) { // Verificação da leitura correta de umidade e temp.

Serial.println("Failed to read from DHT sensor!");
} else {
Serial.print("Umidade: "); Serial.print(humi); Serial.print("%");
Serial.print("Temperatura: "); Serial.print(tempC); Serial.println("°C");
display.clearDisplay(); display.setCursor(5, 0); display.println("Prof Marco");

display.print("U: "); display.print(humi); display.println("%");
display.print("T: "); display.print(tempC); display.println("C");
display.fillRoundRect(5, 50, tempC*118/50, 10, 2, WHITE);
display.display();
}
delay(2000); // Espera 2 segundos entre as leituras
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
4.4.3. Medição da umidade e temperatura usando o DHT22 e DHT11 num display OLED
#include <Wire.h>
#include <DHT.h>
#define DHT22_SENSOR_PIN 26
#define DHT11_SENSOR_PIN 25
DHT dht22_sensor(DHT22_SENSOR_PIN, DHT22);

DHT dht11_sensor(DHT11_SENSOR_PIN, DHT11);
void setup() {
dht22_sensor.begin(); // Inicializando o sensor DHT22
dht11_sensor.begin(); // Inicializando o sensor DHT11
for(;;);
}
display.setTextSize(2); display.setTextColor(WHITE);
display.setCursor(0, 0); display.println("Oi-Brasil!");
display.setCursor(3, 36); display.println("Prof Marco");
display.display();
delay(4000);
}
void loop() {
// Leitura da umidade
float umid22 = dht22_sensor.readHumidity();
float umid11 = dht11_sensor.readHumidity();
// Leitura da temperatura em celsius
float tempC22 = dht22_sensor.readTemperature();
float tempC11 = dht11_sensor.readTemperature();
// Checagem da leitura correta da umidade e temperatura

if ( isnan(tempC22) || isnan(tempC11) || isnan(umid22)|| isnan(umid11)) {
Serial.println("Erro na leitura dos sensores!");
} else {
Serial.print("Umid22: "); Serial.print(umid22); Serial.print("%");
Serial.print("Umid11: "); Serial.print(umid11); Serial.print("% ");
Serial.print("Temp22: "); Serial.print(tempC22); Serial.print("°C ~ ");
www.gaintech.com.br
Robotech
DATA: 29/06/2023
Serial.print("Temp11: "); Serial.print(tempC11); Serial.println("°C");
display.setTextSize(2); display.setCursor(5, 0); display.println("Prof Marco");
display.setCursor(3, 25); display.setTextSize(1);
display.print("U1:"); display.print(umid11);
display.print(" | U2:"); display.print(umid22); display.println("%");
display.fillRoundRect(5, 35, tempC11*118/50, 3, 2, WHITE);
display.print("T1:"); display.print(tempC11);
display.print(" | T2:"); display.print(tempC22); display.println("C");
display.fillRoundRect(5, 60, tempC22*118/50, 3, 2, WHITE);
display.display();
}
// Aguarda 2 segundos para a próxima leitura
delay(2000);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
4.5. O Max98DHT22 – Sensor de Umidade e Temperatura

# neste exemplo usamos o max 9814
#define AN_Pot1 2
#define pinLed 23
int SOM = 0;
void setup()
{
pinMode(pinLed, OUTPUT);
}
void loop()
{
SOM = analogRead(AN_Pot1);
Serial.println(SOM);
delay(1);
if((SOM > 2800)||(SOM<250)){
digitalWrite(pinLed, !digitalRead(pinLed));
delay(300);
}
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
V. Atuadores
5.1. O PWM, modulação por largura de pulso
5.1.1. Controlando a luminosidade de um Led usando o PWM

#define pinoLedPWM 23
void setup()
{
pinMode(pinoLedPWM, OUTPUT);
ledcAttachPin(pinoLedPWM, 0);//Atribuímos o pino 23 ao canal 0.

ledcSetup(0, 1000, 10);//Atribuímos ao canal 0 a freq.de 1000Hz com resolucão de 10bits.
}
void loop()
{
for (int i = 0; i < 1024; i++)
{
ledcWrite(0, i);//Escrevemos no canal 0, o duty cycle "i".
delay(4);
}
for (int i = 1023; i > 0; i--)

{
ledcWrite(0, i);
delay(4);
}
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
5.2. Usando o PWM e entradas Analógicas

5.2.1. Regular a luminosidade de um Led com PWM usando um potenciômetro
#define AN_Pot1 2
#define pinoLedPWM 23
int AN_Pot1_Result = 0;
void setup()
{
pinMode(pinoLedPWM, OUTPUT);
ledcAttachPin(pinoLedPWM, 0);//Atribuimos o pino 2 ao canal 0.
ledcSetup(0, 1000, 12);//Atribuimos ao canal 0 a frequencia de 1000Hz com resolucao de
10bits.
}
void loop()
{
AN_Pot1_Result = analogRead(AN_Pot1);
Serial.println(AN_Pot1_Result);
ledcWrite(0, AN_Pot1_Result);//Escrevemos no canal 0, o duty cycle "i".
delay(100);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
5.3. Como usar um Led RGB

#define PIN_RED 5 // GIOP19
#define PIN_GREEN 18 // GIOP18
#define PIN_BLUE 19 // GIOP05
void setup() {
ledcAttachPin(PIN_RED, 0);//Atribuimos o pino 5 ao canal 0.
ledcSetup(0, 1000, 8);//Canal 0 com f=1000Hz e resolucao de 8bits.
ledcAttachPin(PIN_GREEN, 1);//Atribuimos o pino 18 ao canal 1.

ledcAttachPin(PIN_BLUE, 2);//Atribuimos o pino 18 ao canal 2.

}
void loop() {
//Mostrando primeiro o Vermelho
ledcWrite(0, 255);
ledcWrite(1, 0);
ledcWrite(2, 0);
delay(1000);
// Verde
ledcWrite(0, 0);
ledcWrite(1, 255);
ledcWrite(2, 0);
delay(1000);
// Azul
ledcWrite(0, 0);
ledcWrite(1, 0);
ledcWrite(2, 255);
delay(1000);
// Amarelo = Verde e Vermelho

ledcWrite(0, 255);
ledcWrite(1, 255);
ledcWrite(2, 0);
delay(1000);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
5.4. Buzzer Passivo, produzindo SOM

int freq = 2000;
int canal = 0;
int resolucao = 8;
void setup() {
ledcSetup(canal, freq, resolucao);
ledcAttachPin(33, canal);
}
void loop() {
for (int dutyCycle = 0; dutyCycle <= 255; dutyCycle=dutyCycle+10){
Serial.println(dutyCycle);
ledcWrite(canal, dutyCycle);
delay(1000);
ledcWrite(canal, 0);
delay(100);
}
ledcWrite(canal, 125);
for (int freq = 255; freq < 10000; freq = freq + 250){
Serial.println(freq);
ledcWriteTone(canal, freq);
delay(100);
}
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
5.5. Buzzer Passivo, construindo um mini piano

//No esp32 30 pinos: com pull up interno são os GPIOs: 14, 16, 17, 18, 19, 21, 22 e 23
#define pinoBuzzer 4
int freq = 1000, canalBuzzer = 0, resolucao = 10;
const int buttonPins[] = { 18, 19, 21, 22, 23};
const note_t buttonTones[] = {
NOTE_C, NOTE_D, NOTE_E, NOTE_F, NOTE_G };
const int numTones = 5;
note_t nota;
void setup() {
for (int i = 0; i < numTones; i++) {
pinMode(buttonPins[i], INPUT_PULLUP);
}
pinMode(pinoBuzzer, OUTPUT);
ledcSetup(canalBuzzer, freq, resolucao);
ledcAttachPin(pinoBuzzer, canalBuzzer);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
void loop() {
note_t nota; bool butApertou = 0;
for (int i = 0; i < numTones; i++) {
if (digitalRead(buttonPins[i]) == LOW) {
nota = buttonTones[i];
butApertou = 1;
delay(10);
}
}
if (butApertou) {
ledcWriteNote(canalBuzzer, nota, 5);
}
else {
ledcWriteTone(canalBuzzer, 0);
}
Serial.println(butApertou);
}
www.gaintech.com.br
Robotech
DATA: 29/06/2023
www.gaintech.com.br
Robotech
DATA: 29/06/2023
5.6. Buzzer Passivo, o hino de um time de futebol
5.7. Como ligar um motor de corrente continua usando o LD298
5.8. Ligando um servomotor – controlando a posição de uma haste
5.9. Ligando um servomotor – controlando sua velocidade
www.gaintech.com.br
Robotech
DATA: 29/06/2023
VI. Projetos Finais

6.1. Montagem de um robô móvel usando motores CC
asdfasdf
6.2. Montagem de um robô móvel usando servomotores

Asdfasdf
6.3. Montagem de um robô que mexe cabeça e braços, e tem olhos piscando.
Asdfasdf
www.gaintech.com.br

Curso - Robótica Sensores e Atuadores V1

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Curso - Robótica Sensores e Atuadores V1

Enviado por

Direitos autorais:

Formatos disponíveis

CURSO DE ROBÓTICA

APOSTILA DO CURSO DE ROBÓTICA DA ROBOTECH

4.5. O Max98DHT22 – Sensor de Umidade e Temperatura .............................................................................. 58

I. Programação Básica do ESP32

1.2. Caraterísticas do ESP32

Algumas caraterísticas do Esp32:

1.3. Como simular circuitos no Tinkercad – Primeiros Passos

1. Acesse https://www.Tinkercad.com e clique em inscrever-se.

Figura 1: Imagem 1 referente ao passo a passo para executar o Tinkercad

2. Clique em Criar uma conta pessoal.

Figura 2: Imagem 2 referente ao passo a passo para executar o Tinkercad

Figura 3: Imagem 3 referente ao passo a passo para executar o Tinkercad

Figura 4: Imagem 4 referente ao passo a passo para executar o Tinkercad

Figura 5: Imagem 5 referente ao passo a passo para executar o Tinkercad

6. Parabéns! Você criou sua conta.

Figura 6: Imagem 6 referente ao passo a passo para executar o Tinkercad

Tutorial: Como fazer login?

1. Clique no botão indicado.

Figura 7: Imagem 7 referente ao passo a passo para executar o Tinkercad

2. Clique no link indicado.

Figura 8: Imagem 8 referente ao passo a passo para executar o Tinkercad

3. Escolha uma opção de sua preferência.

Figura 9: Imagem 9 referente ao passo a passo para executar o Tinkercad

1.4. Circuitos simples de bateria e resistores Tinkercad

Figura 10: Como criar um novo circuito no Tinkercad

Figura 11: Como criar um novo circuito no Tinkercad - Parte 2

Figura 12: Circuito com 1 resistor

Figura 13: Circuito com 2 resistores

1.5. Programas Básicos no TinkerCad

- Led, Resistência de 180 Ω e Arduino Uno

Pisca-Pisca com dois Leds

Lista de Componentes: - 2 LedS, 2 Resistêncisa de 180 Ω e Arduino Uno

Usando chaves para ligar e desligar um Led

1.6. Instalação de Programas

Passo 1: Acesse o site oficial do Arduino em https://www.arduino.cc/.

Passo 2: Clique na seção "Software" no menu principal.

Passo 4: Após o download do arquivo de instalação, abra-o e siga as instruções do instalador.

Passo 6: Após a conclusão da instalação do ambiente de programação (IDE) do Arduino é

Passo 7: Instalar a placa ESP32. Clicar na opção do menu: Ferramentas/Placa/Gerenciador de

Acessar ao Gerenciador de dispositivos para verificar se o Windows reconheceu corretamente a

1.7. Programas práticos e básicos usando o Esp32 – Vamos pra práticas

II. Revisão, leds e botões

2.1.1. Pisca Pisca de dois Leds com Delay

No código abaixo, declaramos os pinos do led verde e do led amarelo, representado

2.1.2. Pisca Pisca de dois Leds sem Delay

Em seguida, comparamos o valor de currentMillis com o valor de previousMillis, fazendo a

if (currentMillis - previousMillis >= interval) {

// o estado atual, será o negado do anterior

2.2. Como usar botões no Esp32

2.2.1. Uso de botões com Delay

#define BUTTON_PIN 26 // Pino 26 Conectado ao Button

2.2.2. Uso de botões com detecção de borda

#define BUTTON_PIN 26 // Pino 26 Conectado ao Button

if (lastState == HIGH && currentState == LOW)

2.2.3. Uso de botões usando tempo anti debounce

#define BUTTON_PIN 26 // Pino 26 Conectado ao Button

if (lastState == HIGH && currentState == LOW)

ezButton button(26); // create ezButton object that attach to pin GIOP26

III. Entradas Analógicas

if (AN_Pot1_Resultado > 600)

3.2. Controlando a velocidade de um sequencial de 5 leds usando uma entrada analógica

3.3. Ligando 5 leds em função do nível de tensão de uma entrada analógica

digitalWrite(LedAz, Volts <= 0.66);