Você está na página 1de 39

Vamos construir um

robot com Arduíno

Oficina de Formação
FICHAS DE ATIVIDADE

Alberto Brochado
Fernando Coelho
ÍNDICE
Fazer um circuito com um led. --------------------------------------------------------------------------------------------- 5

Fazer um circuito com um led e com interruptor. ---------------------------------------------------------------------- 5

Circuito série - Fazer um circuito com um led e com interruptores. ----------------------------------------------- 6

Circuito paralelo - Fazer um circuito com um led e com interruptor. --------------------------------------------- 6

Escreva um novo programa(sketch) que permite enviar a mensagem


“HELLO STEM” para o serial monitor. ------------------------------------------------------------------------------------ 7

Escreva um novo programa(sketch) que permita ligar o LED interno


da placa arduino. -------------------------------------------------------------------------------------------------------------- 7

Escreva um novo programa(sketch) que permita ligar um LED


diretamente ligado aos pins do arduino. -------------------------------------------------------------------------------- 8

Escreva um novo programa(sketch) que permita ligar 2 LEDs alternadamente. ------------------------------- 8

Escreva um novo programa(sketch) que permita ligar 1 LED apenas


quando o butão (pushbutton) for premido. ---------------------------------------------------------------------------- 9

Escreva um novo programa(sketch) que permita simular o funcionamento


de 2 semáforos numa avenida. Necessitará de 2 LED’s vermelhos/amarelos/verdes. ---------------------- 10

Ler dados no serial monitor Dado um valor inserido através do


monitor serial, imprimir o resultado. ---------------------------------------------------------------------------------- 11

Com um sensor de luz LDR, caso o ambiente esteja bem iluminado o led verde acenderá, caso a
iluminação do ambiente for mediana o led amarelo acenderá e caso a iluminação seja fraca o led
vermelho acenderá. --------------------------------------------------------------------------------------------------------- 12

Utilizando um sensor ultrassónico (de distância) HC-SR04,ligado


ao Arduíno e enviando dados para o Monitor Serial. ------------------------------------------------------------- 13

Utilizando um sensor ultrassónico (de distância) HC-SR04, ligado


ao Arduíno e enviando dados para um display LCD. --------------------------------------------------------------- 17

Utilizando um sensor de ultrassónico (de distância) HC-SR04, simular


um sensor de obstáculo, utilizando 3 led’s para indicar a distância do obstáculo. ------------------------ 20

Utilizando um sensor de temperatura/humidade DHT11, para simular


uma estação meteorológica e mostrar os resultados no monitor serial. --------------------------------------- 22
Utilizando um potenciômetro para controlar o brilho de um LED
– efeito fade in / fade out e mostrar os resultados no monitor serial. ----------------------------------------- 24

Utilizando um buzzer para construir melodias ou uma sirene de alarme. ------------------------------------- 25

Controlando um motor servo SG90-9G -------------------------------------------------------------------------------- 26

Fazer girar o servo da esquerda para a direita entre 45º e 135º,


com uma pausa de 1 segundo nos 90º -------------------------------------------------------------------------------- 27

Controlando um Servomotor com Arduíno – Micro Servo motor SG90


– através de um potenciómetro. ---------------------------------------------------------------------------------------- 28

Motores de Passo. ---------------------------------------------------------------------------------------------------------- 30

Conectar um motor de Passo 28BYJ-48 5v ao Arduino Uno usando um driver ULN2003. ---------------- 31

O que é uma Ponte H? ----------------------------------------------------------------------------------------------------- 33

Driver motor com Ponte H L298N – Controlando Motores com Arduino. ------------------------------------- 34

SHIELD DRIVER L293D ----------------------------------------------------------------------------------------------------- 37

Utilizando um driver de motor SHIELD DRIVER L293D,


vulgo motor DC Ponte H, para controlar 2 motores de corrente contínua.------------------------------------ 38
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Fazer um circuito com um led.


Material: Arduino, cabo usb, led 5v, resistência 1K e fios.

Fazer um circuito com um led e com interruptor.


Material: Arduíno, cabo usb, led 5v, resistência 1K, interruptor e fios.

P á g i n a |5
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Fazer um circuito com um led e com interruptores.


Material: Arduíno, cabo usb, led 5v, resistência 1K, 2 interruptores e fios.

Circuito paralelo
Fazer um circuito com um led e com interruptor.
Material: Arduíno, cabo usb, led 5v, resistência 1K, 2 interruptores e fios.

P á g i n a |6
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Escreva um novo programa(sketch) que permite enviar


a mensagem “HELLO STEM” para o serial monitor.

void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
Serial.println("HELLO STEM");
}
void loop() {
}
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
Serial.println("Curso de STEM com Robotica");
Serial.println("Hello");
delay(1000);
}

Escreva um novo programa(sketch) que permita ligar o LED


interno da placa arduino. Deverá criar variantes onde o LED
permanece aceso 2 segundos e apagado 0,5 segundos e vice versa.

/* Turns an LED on for one second, then off for one second, repeatedly.
*/
void setup() {
// inicialização do pino digital LED_BUILTIN para o modo output.
pinMode(LED_BUILTIN, OUTPUT);
}
// A função loop é executada sem fim
void loop() {
digitalWrite(LED_BUILTIN, HIGH); // liga o LED colocando a voltagem em HIGH
delay(1000); // espera 1 segundo
digitalWrite(LED_BUILTIN, LOW); // desliga o LED colocando a voltagem em LOW
delay(1000); // espera um segundo
}

P á g i n a |7
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Escreva um novo programa(sketch) que permita ligar


um LED diretamente ligado aos pins do arduino.

Poderá criar variantes em que o LED pisca a intervalos irregulares.


Seria aconselhável usar uma resistência de 220 ohms

// Definição de variáveis.
int ledPin = 13; // define o pino onde será ligado o LED.
int Tempo = 1000; // define o tempo em que o LED permenecerá aceso/apagado.

// Esta parte do programa executa uma vez só, na inicialização do Arduino.


void setup() {
// inicializar o pino digital que tem o LED conectado no Arduino, como saída.
pinMode(ledPin, OUTPUT);
}

// Esta parte do programa executa repetidamente.


void loop() {
digitalWrite(ledPin, HIGH); // coloca o LED on (ligado)
delay(Tempo); // espera por um tempo
digitalWrite(ledPin, LOW); // coloca o LED off (desligado)
delay(Tempo); // espera por um tempo
}

Escreva um novo programa(sketch) que permita ligar 2 LEDs


alternadamente.

// Definição de variáveis.
int ledPin1 = 13; // define o pino onde será ligado o LED.
int ledPin2 = 12; // define o pino onde será ligado o LED.
int Tempo = 1000; // define o tempo em que o LED permenecerá aceso/apagado.
void setup() {
// inicializar os pinos que têm os LEDs conectados como saída.
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
}

P á g i n a |8
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

void loop() {
digitalWrite(ledPin1, HIGH); // coloca o LED1 on (ligado)
digitalWrite(ledPin2, LOW) // coloca o LED2 off (desligado)
delay(Tempo); // espera por um tempo
digitalWrite(ledPin2, HIGH); // coloca o LED1 on (ligado)
digitalWrite(ledPin1, LOW) // coloca o LED1 off (desligado)
delay(Tempo); // espera por um tempo
}

Escreva um novo programa(sketch) que permita ligar 1 LED


apenas quando o butão (pushbutton) for premido.
Não esquecer as resistências

// Definição de variáveis.
int LedPin = 11;
int PinButton = 2;
void setup() {
// inicializar os pinos
pinMode(LedPin,OUTPUT);
pinMode(PinButton,INPUT_PULLUP);
}
void loop()
{
if(digitalRead(PinButton) == HIGH)
{

digitalWrite(LedPin,LOW);
} else
{
digitalWrite(LedPin,HIGH);
}
}

P á g i n a |9
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Escreva um novo programa(sketch) que permita ligar


ou desligar 1 LED utilizando um butão (pushbutton).

int ledPin = 11;


int buttonPin = 2;
int buttonState = LOW; //Estado do botão
int oldbuttonState = LOW;
int ledState=LOW;

void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP); //Resitor pull-up interno
}
void loop() {
buttonState = digitalRead(buttonPin);
if ( (buttonState == HIGH) && (oldbuttonState == LOW)) {
if (ledState==HIGH) {
ledState=LOW;
}else{ ledState=HIGH; }
}
digitalWrite(ledPin, ledState);
oldbuttonState=buttonState;
}

Escreva um novo programa(sketch) que permita simular o


funcionamento de 2 semáforos numa avenida. Necessitará de 2
LED’s vermelhos/amarelos/verdes.

/* Projeto Arduino 2 sinais de trânsito sincronizados */


void setup() {
pinMode(5,OUTPUT);
pinMode(6,OUTPUT);
pinMode(7,OUTPUT);
pinMode(8,OUTPUT);
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
}

P á g i n a | 10
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

void loop() {
digitalWrite(5,LOW); //apaga o led vermelho (sinal 1)
digitalWrite(7,HIGH); //acende o led verde (sinal 1)
digitalWrite(8,HIGH); //acende o led vermelho (sinal 2)
delay(4000); //espera 4 segundos
digitalWrite(7,LOW); //apaga o led verde (sinal 1)
digitalWrite(6,HIGH); //acende o led amarelo (sinal 1)
delay(2000); //espera 2 segundos
digitalWrite(6,LOW); //apaga o led amarelo (sinal 1)
digitalWrite(5,HIGH); //acende o led vermelho (sinal 1)
digitalWrite(8,LOW); //apaga o led vermelho (sinal 2)
digitalWrite(10,HIGH); //acende o led verde (sinal 2)
delay(4000); //espera 4 segundos
digitalWrite(10,LOW); //apaga o led verde (sinal 2)
digitalWrite(9,HIGH); //acende o led amarelo (sinal 2)
delay(2000); //espera 2 segundos
digitalWrite(9,LOW); //apaga o led amarelo (sinal 2)
}

Ler dados no monitor serial


Dado um valor inserido através do monitor serial, imprimir o
resultado.

int valor = 0;
void setup()
{
Serial.begin(9600); // Definição da velocidade de transmissão
Serial.println("Digite um numero ");
}
void loop()
{
If(Serial.available()>0){
valor = Serial.read(); // leitura de dados do monitor serial
Serial.print("O numero digitado foi: ");
Serial.write(valor);
Serial.println();
} }

P á g i n a | 11
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Com um sensor de luz LDR, caso o ambiente esteja


bem iluminado o led verde acenderá, caso a
iluminação do ambiente for mediana o led amarelo
acenderá e caso a iluminação seja fraca o led
vermelho acenderá.

int sensor = 0; //Pino analógico em que o sensor está conectado.


int valorSensor = 0; //Usada para ler o valor do sensor em tempo real.

const int ledVerde = 8;


const int ledAmarelo = 9;
const int ledVermelho = 10;

void setup(){
//Ativando o serial monitor que exibirá os valores lidos.
Serial.begin(9600);

//Definindo pinos digitais dos leds como de saída.


pinMode(ledVerde,OUTPUT);
pinMode(ledAmarelo,OUTPUT);
pinMode(ledVermelho,OUTPUT); }

P á g i n a | 12
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

void loop(){
//Lendo o valor do sensor.
int valorSensor = analogRead(sensor);
//Valores da luminosidade podem ser alterados conforme necessidade.
//Luminosidade baixa.
if (valorSensor < 750) {
apagaLeds();
digitalWrite(ledVermelho,HIGH);
}
//Luminosidade média.
if (valorSensor >= 750 && valorSensor <= 800) {
apagaLeds();
digitalWrite(ledAmarelo,HIGH);
}
//Luminosidade alta.
if (valorSensor > 800) {
apagaLeds();
digitalWrite(ledVerde,HIGH);
}
//Exibindo o valor do sensor no serial monitor.
Serial.println(valorSensor);

delay(50);
}

//Função criada para apagar todos os leds de uma vez.


void apagaLeds() {
digitalWrite(ledVerde,LOW);
digitalWrite(ledAmarelo,LOW);
digitalWrite(ledVermelho,LOW);
}

P á g i n a | 13
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Utilizando um sensor ultrassónico (de distância) HC-


SR04,ligado ao Arduíno e enviando dados para o
Monitor Serial

O Sensor Ultrassônico HC-SR04 é um componente muito comum em projetos com Arduino, e permite que
você faça leituras de distâncias entre 2 cm e 4 metros, com precisão de 3 mm. Pode ser utilizado simplesmente
para medir a distância entre o sensor e um objeto, como para acionar portas do microcontrolador, desviar um
robô de obstáculos, acionar alarmes, etc.
O funcionamento do HC-SR04 baseia-se no envio de sinais ultrasónicos pelo sensor, que aguarda o retorno
(echo) do sinal, e com base no tempo entre envio e retorno, calcula a distância entre o sensor e o objeto
detetado.
De princípio é enviado um impulso de 10µs, indicando o início da transmissão de dados. Depois disso, são
enviados 8 impulsos de 40 KHz e o sensor então aguarda o retorno (em nível alto/high), para determinar a
distância entre o sensor e o objeto, utilizando a equação Distância = (Tempo echo em nível alto *
velocidade do som) /2

Sensor de Distância Ultrassom - HC-SR04


Estes módulos possuem quatro pinos
Capaz de detetar objetos entre 2 cm e 4 metros de distância
Dois pinos são utilizados para alimentar o sensor , um deles é utilizado para disparar o sinal ultrassônico e o outro
para medir o tempo que ele leva para retornar ao sensor.
VCC : Alimentação do módulo com +5 V.
Trig : Gatilho para disparar o pulso ultrassônico. Para disparar
coloque o pino é HIGH durante pelo menos 10us.
Echo : Gera um pulso com a duração de tempo necessária para o
eco do pulso ser recebido pelo sensor.
Gnd : Terra.
Biblioteca: Ultrasonic.h
Utilização:
Ultrasonic ultrasonic(PinT,PinE)
Esta função devolve:
ultrasonic.timing
ultrasonic.convert

A ligação do sensor ao Arduino no nosso programa vai utilizar, além dos pinos de alimentação, os pinos
digitais 4 para o Trigger, e 5 para o Echo.
A alimentação será feita pelo pino 5V do Arduino.

P á g i n a | 14
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

O programa usa a biblioteca Ultrasonic. Descompacte a mesma e coloque-a dentro da pasta LIBRARIES da
IDE do Arduino.

//Carrega a biblioteca do sensor ultrassonico


#include <Ultrasonic.h>

//Define os pinos para o trigger e echo


#define pino_trigger 4
#define pino_echo 5

//Inicializa o sensor nos pinos definidos acima


Ultrasonic ultrasonic(pino_trigger, pino_echo);

void setup()
{
Serial.begin(9600);
Serial.println("Lendo dados do sensor...");
}

P á g i n a | 15
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

void loop()
{
//Le as informacoes do sensor, em cm e pol
float cmMsec, inMsec;
long microsec = ultrasonic.timing();
cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);
//Exibe informacoes no serial monitor
Serial.print("Distancia em cm: ");
Serial.print(cmMsec);
Serial.print(" - Distancia em polegadas: ");
Serial.println(inMsec);
delay(1000);
}

No programa todo o cálculo é feito por meio da biblioteca Ultrasonic. O sensor é inicializado nos pinos trigger
e echo, e depois efetuamos a leitura dos dados do sensor, atribuindo às variáveis cmMsec e inMsec os valores
das distâncias em centímetros e polegadas, respetivamente. Os dados são visualizados no serial monitor:

P á g i n a | 16
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Utilizando um sensor ultrassónico (de distância) HC-


SR04, ligado ao Arduíno e enviando dados para um
display LCD

A interação deste sensor com Arduino é muito simples.


No setup definiremos dois pinos para utilizarmos como interface com o sensor. Um deles será chamado
de gatilho e será definido como uma saída. O outro será chamado de echo e será definido como entrada.
No loop ficaremos, indefinidamente, a medir a distância entre o sensor e o obstáculo e a mostrar o resultado
no display. A cada iteração faremos o seguinte: instruiremos o sensor a emitir um impulso ultrassónico
colocando o pino do gatilho em HIGH por alguns microssegundos e, depois, mediremos a duração do impulso
no pino echo. De posse da duração do impulso no pino echo basta fazermos algumas contas para descobrir
a distância do objeto (em centímetros e polegadas) e apresentarmos estes valores no display LCD.

P á g i n a | 17
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Necessitamos dos seguintes materiais:


• sensor ultrassónico com quatro pinos (HC-SR04 ou compatível)
• Arduino (UNO R3 ou compatível)
• potenciómetro 10K ohms
• Breadboard
• display LCD 16×4 (você pode usar um display diferente desde que faça as adaptações necessárias
no código)
• jumpers para as conexões
• cabo USB para carregar o programa no Arduino

// biblioteca para o display LCD


#include <LiquidCrystal.h>

// variáveis
int gatilho = 9; // pino TRIG do sensor
int echo = 8; // pino ECHO do sensor
float tempo; // para armazenar o tempo de ida e volta do sinal em microsegundos
float distancia_cm; // para armazenar a distância em centímetros
float distancia_in; // para armazenar a distância em polegadas

// inicialização do display LCD


LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// setup (executado apenas uma vez)


void setup() {
// configura pino GATILHO como saída
pinMode(gatilho,OUTPUT);
// deixa pino em LOW
digitalWrite(gatilho,LOW);
delayMicroseconds(10);

// configura pino ECHO como entrada


pinMode(echo,INPUT);
}

void loop() {
// disparar pulso ultrassônico
digitalWrite(gatilho, HIGH);
delayMicroseconds(10);
digitalWrite(gatilho, LOW);

// medir tempo de ida e volta do pulso ultrassônico


tempo = pulseIn(echo, HIGH);

P á g i n a | 18
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

// calcular as distâncias em centímetros e polegadas


distancia_cm = tempo / 29.4 / 2;
distância_in = tempo / 74.7 / 2;

// apresentar resultados no display LCD


lcd.begin(20, 4);
lcd.setCursor(1,0);
lcd.print("Distancia: ");
lcd.print(distancia_cm);
lcd.print(" cm");
lcd.setCursor(12,1);
lcd.print(distancia_in);
lcd.print(" in");
lcd.setCursor(3,3);
lcd.print("fazedores.com");

// aguardar um pouquinho antes de começar tudo de novo


delayMicroseconds(200);
}

Entendendo o código e os cálculos


Como queremos saber a distância, em centímetros e polegadas respetivamente, tivemos que fazer algumas continhas.
Primeiro calculamos a velocidade do som no ar em centímetros por segundo e em polegadas por segundo.
Isto deu: 34000 cm/s e 13385.8 in/s.

Depois calculamos quantos microssegundos o som leva para percorrer um centímetro e uma polegada. Para isto bastar
resolver a seguinte regra de três:
• 1000000 ms => 34000 cm
• X ms => 1 cm
E obtivemos que são necessários 29.4 ms para o som percorrer um centímetro.
Fazendo o mesmo para polegadas chegamos ao número de 74.4 ms para percorrer uma polegada.

Agora como medimos o tempo em microssegundos para o som ir e voltar ao sensor, basta dividir este tempo por 29.4
e 74.4 para descobrir quantos centímetros e quantas polegadas o som teve que percorrer.

Porém, como o som tem que fazer o trajeto de ida e volta, finalizamos dividindo o resultado por dois para sabermos a
distância entre o sensor e o obstáculo.

P á g i n a | 19
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Utilizando um sensor de ultrassónico (de distância)


HC-SR04, simular um sensor de obstáculo, utilizando
3 led’s para indicar a distância do obstáculo.

Sensor de Distância Ultrassom - HC-SR04


Estes módulos possuem quatro pinos
Capaz de detetar objetos entre 2 cm e 4 metros de distância
Dois pinos são utilizados para alimentar o sensor , um deles é utilizado para disparar o sinal ultrassônico e o outro
para medir o tempo que ele leva para retornar ao sensor.
VCC : Alimentação do módulo com +5 V.
Trig : Gatilho para disparar o pulso ultrassônico. Para disparar
coloque o pino é HIGH durante pelo menos 10us.
Echo : Gera um pulso com a duração de tempo necessária para o
eco do pulso ser recebido pelo sensor.
Gnd : Terra.
Biblioteca: Ultrasonic.h
Utilização:
Ultrasonic ultrasonic(PinT,PinE)
Esta função devolve:
ultrasonic.timing
ultrasonic.convert

P á g i n a | 20
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

//Incluindo biblioteca Ultrasonic.h


#include "Ultrasonic.h"

//criando objeto ultrasonic e definindo as portas digitais do Trigger - 6 - e Echo - 7


Ultrasonic ultrasonic(6,7);

//Declaração das constantes referentes aos pinos digitais.


const int ledVerde = 13;
const int ledAmarelo = 12;
const int ledVermelho = 11;
long microsec = 0;
float distanciaCM = 0;

void setup() {
Serial.begin(9600); //Inicializando o serial monitor

//Definindo pinos digitais


pinMode(ledVerde,OUTPUT); //13 como de saída.
pinMode(ledAmarelo,OUTPUT); //12 como de saída.
pinMode(ledVermelho,OUTPUT); //11 como de saída.
}
void loop() {
microsec = ultrasonic.timing(); //Lendo o sensor
//Convertendo a distância em CM
distanciaCM = ultrasonic.convert(microsec, Ultrasonic::CM);
ledDistancia();
Serial.print(distanciaCM);
Serial.println(" cm");
delay(1000);
}

//Método que centraliza o controle de acendimento dos leds.


void ledDistancia() {

//Apagando todos os leds


digitalWrite(ledVerde,LOW);
digitalWrite(ledAmarelo,LOW);
digitalWrite(ledVermelho,LOW);

P á g i n a | 21
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

//Acendendo o led adequado para a distância lida no sensor

if (distanciaCM > 20) {


digitalWrite(ledVerde,HIGH);
}

if (distanciaCM <=20 and distanciaCM >= 10) {


digitalWrite(ledAmarelo,HIGH);
}

if (distanciaCM < 10) {


digitalWrite(ledVermelho,HIGH);
}
}

Utilizando um sensor de temperatura/humidade DHT11, para


simular uma estação meteorológica e mostrar os resultados no
monitor serial.
Resistência 10K pullup

Sensores DHTxx (xx = 11-21-22-33-44)


Estes sensores possuem geralmente, s pinos, GND, +5V e uma única linha
de dados.
Usa a libraria dht.h, que possui 6 funções básicamente idênticas:
read(PIN), read11(PIN), readxx(PIN)

Utilização:
Signal
Vcc (+)
Ground (-)

DHT.read11(DHT11_PIN); ou DHT.read11(5);
Esta função devolve:
DHTLIB_OK (0) : se o sensor e o checksum está OK.
DHTLIB_ERROR_CHECKSUM (-1) : se o checksum test falhou.
DHTLIB_ERROR_TIMEOUT (-2) : se ocorreu um timeout, communicação
falhou.

DHT.humidity
DHT.temperature
Signal

Ground (-)
Não utilizado
Vcc (+)

P á g i n a | 22
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

#include <dht.h>
dht DHT;
#define DHT11_PIN 5
void setup() {
Serial.begin(115200);
Serial.println("DHT - PROGRAMA TESTE“);
Serial.print(“Formação STEM com Robótica”);
Serial.println();
Serial.println("Tipo,\tstatus,\tHumidade (%),\tTemperatura (C)");
}
void loop() {
// Leitura de dados
Serial.print("DHT11, \t");
int chk = DHT.read11(DHT11_PIN);
switch (chk)
{
case DHTLIB_OK:
Serial.print("OK,\t");
break;
case DHTLIB_ERROR_CHECKSUM:
Serial.print("Checksum error,\t");
break;
case DHTLIB_ERROR_TIMEOUT:
Serial.print("Time out error,\t");
break;
default:
Serial.print("Unknown error,\t");
break;
}
// Visualizar dados
Serial.print(DHT.humidity, 1);
Serial.print(",\t");
Serial.println(DHT.temperature, 1);
delay(2000);
}

P á g i n a | 23
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Utilizando um potenciômetro para controlar o brilho


de um LED – efeito fade in / fade out e mostrar os
resultados no monitor serial

Este exercício serve para demonstrar o funcionamento dos pinos digitais PWM e a utilização da função map(), para
mapear valores analógicos da porta analógica para uma porta digital.

const int analogInPin = A0; // pin análógico entrada


const int analogOutPin = 9; // pin analógico de saída
int sensorValue = 0; // valor lido pelo sensor
int outputValue = 0; // valor enviado para a saída analógica

void setup() {
Serial.begin(9600); // inicializar comunicações em 9600 bps
}

void loop() {
sensorValue = analogRead(analogInPin); // ler valor analógico
outputValue = map(sensorValue, 0, 1023, 0, 255);
analogWrite(analogOutPin, outputValue); // alterar o valor de saída
Serial.print("sensor = "); // mostra os valores no Serial Monitor
Serial.print(sensorValue);
Serial.print("\t output = ");
Serial.println(outputValue);
// aguarda 2 millisegundos antes do próximo ciclo analógico-digital
delay(2);
}

P á g i n a | 24
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Utilizando um buzzer para construir melodias ou uma


sirene de alarme.

Funções do Buzzer ou Piezo buzzer


tone(Pin, Frequência, Duração)
noTone(Pin)

void setup()
{
pinMode(12,OUTPUT);
}

void loop()
{
tone(12,261);
delay(500);
tone(12,277);
delay(500);
tone(12,294);
delay(500);
tone(12,311);
delay(500);
tone(12,330);
delay(500);
tone(12,349);
delay(500);
tone(12,370);
delay(500);
tone(12,392);
delay(500);
tone(12,415);
delay(500);
tone(12,440);
delay(500);
}

P á g i n a | 25
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Controlando um motor servo SG90-9G


O Servo Motor SG90 é um motor de elevada qualidade e muito utilizado em projetos de robótica com o
Arduino, PIC, Raspberry, entre outros. É ideal para a utilização em aeromodelismo, controlando de forma
precisa os movimentos.

O Servo Motor SG90 é um módulo que apresenta movimentos proporcionais aos comandos indicados,
controlando o girar e a posição, diferente da maioria dos motores. Possui um ângulo de rotação de 180 graus
e é acompanhado de um cabo de 3 pinos referente à alimentação/controlo e diversos acessórios (3 tipos de
braços + parafusos).

O Servo Motor SG90 9g Tower Pro é um motor compacto, pesa apenas 9g e oferece um torque máximo de
~1.6kg, mostrando-se ideal para as mais diversas aplicações em projetos robóticos e eletrónicos.

Especificações:
• Servo motor SG90;
• Tensão da Operação: 3,0 - 7,2V;
• Ângulo de rotação: 180 graus;
• Velocidade: 0,12 seg/60Graus (4,8V) sem carga;
• Torque: 1,2 kg.cm (4,8V) e 1,6 kg.cm (6,0V);
• Temperatura da Operação: -30C ~ +60C;
• Tamanho do cabo: 245mm;
• Dimensões: 32 x 30 x 12mm;
• Peso: 9g.

Entre os atuadores este é um motor bem especial. De forma simplificada, um servomotor é um motor na qual
podemos controlar sua posição angular através de um sinal PWM.

Como funciona?

Um servomotor é um atuador eletromecânico utilizado para posicionar e manter um objeto em uma


determinada posição. Para isso, ele conta com um circuito que verifica o sinal de entrada e compara com a
posição atual do eixo.

Como você pode ver na figura, o ângulo do servomotor é


proporcional ao Duty Cycle (tempo em que o sinal é
positivo) do sinal PWM.
Diferente dos motores de corrente continua ou motores de
passo que podem girar indefinidamente, o eixo de um
servo possui a liberdade de apenas 180º. Existem ainda
alguns servos que são adaptados para girar
indefinidamente.

P á g i n a | 26
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Controlando um motor servo SG90-9G.


Fazer girar o servo da esquerda para a direita entre
45º e 135º, com uma pausa de 1 segundo nos 90º.

Biblioteca: Servo.h
Alimentação positiva (vermelho) – 5V;
Terra (Preto ou Marrom) – GND;
(Amarelo, Laranja ou Branco) –Pino digital de entrada e saída;

#include <Servo.h>
int servoPin = 9;
Servo servo;
int servoAngle = 0; // servo position in degrees

void setup(){
Serial.begin(9600);
servo.attach(servoPin);
}
void loop(){
//control the servo's direction and the position of the motor
servo.write(45); // Turn SG90 servo Left to 45 degrees
delay(1000); // Wait 1 second
servo.write(90); // Turn SG90 servo back to 90 degrees (center position)
delay(1000); // Wait 1 second
servo.write(135); // Turn SG90 servo Right to 135 degrees
delay(1000); // Wait 1 second
servo.write(90); // Turn SG90 servo back to 90 degrees (center position)
delay(1000); }

P á g i n a | 27
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Controlando um Servomotor com Arduíno – Micro


Servo motor SG90 – através de um potenciómetro.
Componentes necessários
Micro Servo motor SG90 ou outro Servomotor
Placa Arduino Uno ou similar
Fios Jumper’s
Breadboard
Potenciómetro

O microservo tem três fios saindo dele. Um será vermelho e irá para os +5 V. Outro, preto ou marrom, irá para o GND.
O terceiro, branco, amarelo ou laranja, será conectado ao pino digital 8.
Ligue o potenciómetro com os seus pinos externos conectados um no +5 V e o outro no GND e o pino do meio ao pino
analógico A0.

Biblioteca: Servo.h

#include <Servo.h>
Servo servo1; // cria um objeto servo1

// Esta função "setup" roda uma vez quando a placa e ligada ou resetada
void setup() {
servo1.attach(5); // anexa o servomotor (físico), no pino 5, ao objeto servo1 (lógico)
}

void loop() {
int angulo = analogRead(0); // Lê o valor do potenciômetro
angulo = map(angulo, 0, 1023, 0, 180); // Mudança de Escala
servo1.write(angulo); // Escreve o ângulo para o servomotor
delay(20); // Espera de 20ms, Suficiente para que o servomotor atinja a posição
}

P á g i n a | 28
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Micro Servo MG90S TowerPro destaca pela construção das engrenagens


em metal, o que aumenta a vida útil do motor e permite movimentos mais
precisos e confiáveis, conferindo mais força ao conjunto.

O servo SM-S4306R é um servo de rotação contínua (360°) e capaz de


entregar um alto torque de 6,2Kg.cm quando alimentado em 6V.
Uma excelente opção para para modelismo ou projetos mecatrônicos.

O TowerPro MG995 é um servo de ótima qualidade e alto torque, perfeito


para modelismo e projetos de robótica que exijam um servo mais
resistente. Todas as suas engrenagens são metálicas, possui faixa de
rotação de 180 graus.

P á g i n a | 29
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Motores de Passo.

Os motores de passo são usados numa infinidade de equipamentos modernos, tais como: impressoras, scanners,
automatismos diversos, robótica e mecatrónica.
Evidentemente, encontramos estes motores em muitas aplicações que envolvem posicionamento preciso de
peças e dispositivos associados. Conhecer o funcionamento destes motores é de vital importância para qualquer
profissional da área.

O que são os motores de passo?

Podemos dizer que os motores de passo, assim como os motores comuns, são dispositivos que convertem
energia elétrica em energia mecânica disponível na forma de torque.

No entanto, os motores de passo possuem algumas características próprias que os diferencia dos motores
comuns, a saber:

a) os motores de passo funcionam como dispositivos posicionadores, pois podem parar numa posição
perfeitamente controlada.

b) os motores de passo também podem funcionar como motores de velocidade perfeitamente controlada,
sendo energizados numa determinada ordem.

Estas características são ainda acrescidas a outras que os tornam ideais para aplicações em informática, eletrónica
industrial e de controle, robótica e mecatrónica:

a) Eles podem ter seu eixo posicionado em um ângulo proporcional ao número de impulsos de entrada.

b) Os erros que ocorrem no posicionamento do seu eixo são muito pequenos e não são cumulativos. Um
motor de passo pode ser posicionado com uma precisão de 1 milésimo de radiano tipicamente.

P á g i n a | 30
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Conectar um motor de Passo 28BYJ-48 5v


ao Arduino Uno usando um driver
ULN2003.

Ligar o motor ao Arduino obedecendo a seguinte sequência:


IN1 ao pino 8 do Arduino
IN2 ao pino 9 do Arduino
IN3 ao pino 10 do Arduino
IN4 ao pino 11 do Arduino
O circuito de ligação do motor ao Arduino Uno ficará assim:

O ambiente de programação Arduíno vem com uma biblioteca de funções para controlar um motor de passo:
Biblioteca Stepper.h

Escreva um programa que fará com que o motor de passo gire no sentido horário 4 vezes em ângulos de 90
graus, depois 3 vezes no sentido horário, em ângulos de 120 graus, e por último vai girar o motor e aumentar a
velocidade gradualmente.
Depois de 2 segundos, o processo é reiniciado.

P á g i n a | 31
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

#include <Stepper.h>

const int stepsPerRevolution = 500;

//Inicializa a biblioteca utilizando as portas de 8 a 11 para


//ligacao ao motor
Stepper myStepper(stepsPerRevolution, 8,10,9,11);

void setup()
{
//Determina a velocidade inicial do motor
myStepper.setSpeed(60);
}

void loop()
{
//Gira o motor no sentido horario a 90 graus
for (int i = 0; i<=3; i++)
{
myStepper.step(-512);
delay(2000);
}

//Gira o motor no sentido anti-horario a 120 graus


for (int i = 0; i<=2; i++)
{
myStepper.step(682);
delay(2000);
}

//Gira o motor no sentido horario, aumentando a


//velocidade gradativamente
for (int i = 10; i<=60; i=i+10)
{
myStepper.setSpeed(i);
myStepper.step(40*i);
}
delay(2000);
}

P á g i n a | 32
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

O que é uma Ponte H?


na maioria das abordagens em robótica, é necessário mencionar a utilização de motores DC em
diversos tipos de locomoção de robôs, movimentação de braços mecânicos, etc.

Assim, os motores DC (direct current ou corrente continua) são cargas indutivas que, em geral,
necessitam de uma quantidade de corrente superior aquela que as portas do Arduino conseguem
fornecer. Sendo assim, não devemos ligar estes motores diretamente nas portas do Arduino pois se o
motor necessitar de uma corrente acima de 40mA nas portas digitais (máxima fornecida pelo Arduino)
pode queimar a porta e danificar a placa.

Para solucionar a questão da alta corrente poderíamos utilisar transistores, porem é importante que
seja possível controlar o sentido de rotação do motor, função que não é possível usando apenas um
transistor já que para inverter o sentido de rotação devemos inverter a polaridade da alimentação do
motor (onde era positivo colocamos negativo e vice versa). Um transistor só seria suficiente para ligar
e desligar o motor.

Para resolver nosso problema utilizamos um famoso circuito conhecido como Ponte H que nada mais
é que um arranjo de 4 transistores. Este circuito é uma elegante solução por ser capaz de acionar
simultaneamente dois motores controlando não apenas os seus sentidos, como também as suas
velocidades, para além de seu uso ser simples no Arduino.

Mas como funciona a Ponte H? Porque este nome?

As pontes H possuem este nome devido ao formato em que é montado o circuito, semelhante a letra
H. O circuito utiliza quarto chaves (S1, S2, S3 e S4) que são acionadas de forma alternada, ou seja, (S1-
S3) ou (S2-S4), veja as figuras abaixo. Dependendo da configuração entre as chaves teremos a corrente
percorrendo o motor ora num sentido, ora noutro.

Circuito Ponte H

Quando nenhum par de chaves está acionado, o motor está desligado (a). Quando o par S1-S3 é
acionado a corrente percorre S1-S3 fazendo com que o motor gire em um sentido (b). Já quando o par
S2-S4 é acionado a corrente percorre por outro caminho fazendo com que o motor gire no sentido
contrário (c).

P á g i n a | 33
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Mãos à obra – Driver motor com Ponte H L298N –


Controlando Motores com Arduino

P á g i n a | 34
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Crie um programa (sketch) e salve com o nome de “exemplo1_ponteh”.

/*Pinagem do arduino*/

//motor_A
int IN1 = 2 ;
int IN2 = 3 ;

//motor_B
int IN3 = 4 ;
int IN4 = 5 ;

//Inicializa Pinos
void setup(){
pinMode(IN1,OUTPUT);
pinMode(IN2,OUTPUT);
pinMode(IN3,OUTPUT);
pinMode(IN4,OUTPUT);
}
......
void loop(){ /*Inicio dos Estados do motor B*/
//Sentido 1
/*Inicio dos Estados do motor A*/ digitalWrite(IN3,LOW);
//Sentido 1 digitalWrite(IN4,HIGH);
digitalWrite(IN1,LOW); delay(5000);
digitalWrite(IN2,HIGH);
delay(5000); //Freia Motor_B
digitalWrite(IN3,HIGH);
//Freia Motor_A digitalWrite(IN4,HIGH);
digitalWrite(IN1,HIGH); delay(5000);
digitalWrite(IN2,HIGH);
delay(5000); //Sentido 2
digitalWrite(IN3,HIGH);
//Sentido 2 digitalWrite(IN4,LOW);
digitalWrite(IN1,HIGH); delay(5000);
digitalWrite(IN2,LOW);
delay(5000); //Freia Motor_B
digitalWrite(IN3,HIGH);
//Freia Motor_A digitalWrite(IN4,HIGH);
digitalWrite(IN1,HIGH); delay(5000);
digitalWrite(IN2,HIGH);
delay(5000); /*Fim dos Estados do motor_B*/
/*Fim dos Estados do motor A*/ }
. . . .

P á g i n a | 35
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Se tudo deu certo, teremos os motores fazendo os seguintes movimentos:

• Motor A gira num sentido


• Motor A trava
• Motor A gira no sentido contrário
• Motor A trava
• Motor B gira em num sentido
• Motor B trava
• Motor B gira no sentido contrário
• Motor B trava

P á g i n a | 36
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

SHIELD DRIVER L293D

Este é um shield controlador de motores de 4 canais para arduino baseado no L293D. Com este
controlador pode-se usar motores DC e tensões de alimentação de 25V cm um máximo de corrente
de 600mA por canal. O L293D é um controlador em ponte H.

Características:

• Controla 4 motores DC ou 2 motores de passo ou 2 servos


• Até 4 motores DC bi-direcionais com 8 bits de seleção individual de velocidade
• Até 2 motores de passo (unipolar ou bipolar) com bobine simples, bobine dupla ou passo
intercalado
• 4 Ponte-H: fornece 600mA por canal (1.2A currente de pico) com proteção térmica, podendo
controlar motores de 4.5V até 25V DC
• Resistências Pull-Down mantêm os motores desabilitados quando se liga o controlador
(power-up)
• Botão de Reset
• 2 interfaces de alimentação externa para separação de alimentação do controlo e dos
motores
• Compatível com Arduino Uno, Mega, Diecimila & Duemilanove

P á g i n a | 37
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

Utilizando um driver de motor SHIELD DRIVER


L293D, vulgo motor DC Ponte H, para controlar 2
motores de corrente contínua.
Usar a libraria: AFMotor.h
motor.setSpeed(velocidade) 0…255
motor.run(sentido) FORWARD; BACKWARD; RELEASE

o Motor Shield L293D que integra alta tensão, alta corrente e controlo de 4 canais numa só
placa! Basicamente isto significa que pode ligar motores DC e uma fonte de tensão de mais de
36V que este chip se encarrega de fornecer uma corrente máxima de 600mA por canal.

O chip L293D também é conhecido como um tipo de Ponte H que é tipicamente um circuito
elétrico que permite uma tensão ser aplicada numa carga em qualquer direção para uma saída,
como por exemplo um motor.

O Motor Shield Driver L293D Arduino foi desenvolvido com a finalidade de controlar a
velocidade e o sentido de rotação de até quatro motores DC independentes, ou ainda, dois
motores de passo ou dois servomotores.

O chip L293D possui internamente 2 Ponte H e suporta uma corrente de saída de 600mA por
canal, ou seja, será possível controlar até 2 motores com 600mA cada, visto que neste Shield
temos 2 chips. Tensão suportada de 4,5-36V.

Este Motor Shield L293D é compatível com Arduino Uno e Arduino Mega.

P á g i n a | 38
Oficina de Formação
“Vamos Construir um robot com Arduino”
FICHAS DE ATIVIDADE

#include <AFMotor.h>
// Define o motor1 ligado a conexao 1
AF_DCMotor motor1(1);
// Define o motor2 ligado a conexao 4
AF_DCMotor motor2(4);

void setup()
{
// Define a velocidade maxima para os motores 1 e 2
motor1.setSpeed(255);
motor2.setSpeed(255);
}

void loop()
{
// Aciona o motor 1 no sentido horario
motor1.run(FORWARD);
// Aciona o motor 2 no sentido anti-horario
motor2.run(BACKWARD);

// Aguarda 5 segundos
delay(5000);
// Desliga os 2 motores
motor1.run(RELEASE);
motor2.run(RELEASE);
// Aciona o motor 1 no sentido anti-horario
motor1.run(BACKWARD);
// Aciona o motor 2 no sentido horario
motor2.run(FORWARD);

// Aguarda 5 segundos
delay(5000);

// Desliga os 2 motores
motor1.run(RELEASE);
motor2.run(RELEASE);
}

P á g i n a | 39