Curso Arduino Rev02

Curso Arduino
rev. 02 – 20/01/2017
Ulysses C. Fonseca
Engenharia Elétrica
Poços de Caldas
2017
Índice
Licença ................................................................................................................... 7
Sobre o Autor .......................................................................................................... 7
Introdução ............................................................................................................... 8
1. O que é? ..................................................................................................... 8
2. Para que serve? ........................................................................................ 10
3. Como Programar?..................................................................................... 10
4. Funções Principais .................................................................................... 10
4.1. setup()................................................................................................ 10
4.2. loop().................................................................................................. 10
Portas digitais ....................................................................................................... 12
1. O que são Portas Digitais? ........................................................................ 12
2. Portas no modo de Saída .......................................................................... 12
3. Portas no modo de Entrada....................................................................... 12
4.1. pinMode() ........................................................................................... 13
4.2. digitalWrite() ....................................................................................... 13
4.3. digitalRead()....................................................................................... 14
4.4. delay() ................................................................................................ 14
Pratica 01 – Aciona Led..................................................................................... 15
Pratica 02 – Pisca Led ....................................................................................... 17
Pratica 03 – Semáforo ....................................................................................... 19
Pratica04 – Entradas Digitais ............................................................................ 21
PWM ..................................................................................................................... 22
1. O que é? ................................................................................................... 22
2. Para quê serve .......................................................................................... 23
3. Quais pinos são PWM ............................................................................... 23
4.1. analogWrite() ..................................................................................... 24
Pratica 05 – Utilizar PWM para controlar o brilho .............................................. 25
Pratica 06 – Ajustar o brilho de um led com microchaves .................................. 27
ADC ...................................................................................................................... 29
1. O que é? ................................................................................................... 29
2. Para quê serve .......................................................................................... 31
2
3.1. analogReference() ............................................................................. 31
3.2. analogRead() ..................................................................................... 31
Pratica 07 – Controlando o brilho de um led ...................................................... 33
Serial .................................................................................................................... 33
1. O que é? ................................................................................................... 34
2. Para quê serve? ........................................................................................ 34
3. Pinos do Arduino ....................................................................................... 34
4.1. Serial.begin()...................................................................................... 35
4.2. Serial.available() ................................................................................ 35
4.3. Serial.read() ....................................................................................... 35
4.4. Serial.print() ....................................................................................... 36
4.5. Serial.write() ....................................................................................... 36
Prática 08 – Serial “HELLO WORLD” ................................................................ 38
Prática 09 – Sensor de Temperatura ................................................................. 39
Prática 10 – Controle do Arduino pela porta Serial ............................................ 40
Disco Piezo ........................................................................................................... 42
1. O que é? ................................................................................................... 42
2. Para quê serve? ........................................................................................ 42
3.1. tone() ................................................................................................. 42
3.2. noTone() ............................................................................................ 43
Prática 11 – Sonorizador ................................................................................... 44
Prática 12 – Tocar uma melodia ........................................................................ 45
LDR ...................................................................................................................... 47
1. O que é? ................................................................................................... 47
2. Para quê serve? ........................................................................................ 47
Prática 14 – LDR ............................................................................................... 48
Motor CC .............................................................................................................. 49
1. O que é? ................................................................................................... 49
2. Para quê serve? ........................................................................................ 49
Prática 15 - Controle de motor CC.................................................................... 50
Prática 16 - Controlar o motor CC pela Serial - Desafio ..................................... 51
3
LCD ...................................................................................................................... 53
1. O que é? ................................................................................................... 53
2. Para quê serve? ........................................................................................ 53
3. Funções para o LCD ................................................................................. 53
3.1. LiquidCrystal ...................................................................................... 53
3.2. lcd.begin() .......................................................................................... 54
3.3. lcd.print() ............................................................................................ 54
3.4. lcd.setCursor() ................................................................................... 54
3.5. lcd.cursor() ......................................................................................... 55
3.6. lcd.noCursor() .................................................................................... 55
3.7. lcd.blink() ........................................................................................... 55
3.8. lcd.noBlink() ....................................................................................... 55
3.9. lcd.rightToLeft() .................................................................................. 55
3.10. lcd.leftToRight() .................................................................................. 55
3.11. lcd.home() .......................................................................................... 56
3.12. lcd.display() ........................................................................................ 56
3.13. lcd.noDisplay() ................................................................................... 56
Prática 17 – Display LCD................................................................................... 57
Prática 18 – Controles do LCD - Desafio ........................................................... 58
Servo Motor .......................................................................................................... 59
1. O que é? ................................................................................................... 59
2. Para quê serve? ........................................................................................ 59
3.1. Servo ................................................................................................. 59
3.2. servo.attach() ..................................................................................... 59
3.3. servo.detach() .................................................................................... 60
3.4. servo.attached() ................................................................................. 60
3.5. servo.write() ....................................................................................... 60
3.6. servo.read()........................................................................................ 60
Pratica 19 – Servo Motor ................................................................................... 61
Prática 20 – Controles do Servo Motor .............................................................. 62
Motor de Passo ..................................................................................................... 63
1. O que é? ................................................................................................... 63
2. Para quê serve? ........................................................................................ 65
4
3.1. Stepper .............................................................................................. 65
3.2. setSpeed() ......................................................................................... 65
3.3. step().................................................................................................. 66
Pratica 21 – Motor de Passo ............................................................................. 67
Ultrassônico .......................................................................................................... 68
1. O que é? ................................................................................................... 68
2. Para quê serve? ........................................................................................ 69
3.1. Ultrasonic ........................................................................................... 69
3.2. ranging ............................................................................................... 69
3.3. timing ................................................................................................. 70
3.4. pulseIn ............................................................................................... 70
Pratica 22 - Ultrassonico.................................................................................... 70
APENDICE A ........................................................................................................ 72
1. Tipos de dados ............................................................................................ 72
1.1. void .................................................................................................... 72
1.2. Boolean .............................................................................................. 72
1.3. char .................................................................................................... 73
1.4. unsigned char .................................................................................... 73
1.5. byte .................................................................................................... 73
1.6. int ....................................................................................................... 73
1.7. unsigned int........................................................................................ 73
1.8. word ................................................................................................... 74
1.9. long .................................................................................................... 74
1.10. unsigned long..................................................................................... 74
1.11. short ................................................................................................... 74
1.12. float .................................................................................................... 74
1.13. double ................................................................................................ 75
2. if e operadores de comparação ................................................................. 75
3. if / else ...................................................................................................... 75
4. for.............................................................................................................. 76
5. switch / case ............................................................................................. 76
6. while .......................................................................................................... 77
7. do-while..................................................................................................... 77
8. break ......................................................................................................... 78
5
9. continue .................................................................................................... 78
10. return ..................................................................................................... 78
11. goto ....................................................................................................... 79
12. ; - ponto e vírgula ................................................................................... 79
13. {} - Chaves ............................................................................................. 79
14. // e /*- Comentários ................................................................................ 80
15. define .................................................................................................... 80
16. include ................................................................................................... 80
17. Operadores aritméticos ......................................................................... 81
18. Operadores de comparação .................................................................. 81
19. Operadores Booleanos .......................................................................... 81
20. Operadores de ponteiro ......................................................................... 81
APENDICE B ........................................................................................................ 83
1. Cabos (jumpers)........................................................................................ 83
2. Resitor ...................................................................................................... 83
3. Potenciômetro ........................................................................................... 84
4. Led ............................................................................................................ 84
5. Transistor .................................................................................................. 84
6. Chaves ...................................................................................................... 85
7. Protoboard ................................................................................................ 86
8. LDR........................................................................................................... 86
9. LM35 ......................................................................................................... 87
10. LCD ....................................................................................................... 87
11. Buzzer ................................................................................................... 88
Referências ........................................................................................................... 89
6
Licença
Esta obra está sob licença CreativeCommons, e sua publicação total e/ou parcial
deverá ser atribuída ao autor, e sua venda é proibida.
Curso Arduino – rev 02 de Ulysses C. Fonseca está licenciado com uma Licença
CreativeCommons Atribuição-NãoComercial-CompartilhaIgual 4.0 Internacional.
Sugestões, críticas, ou outros, entre em contato com o autor.
Sobre o Autor
Ulysses C. Fonseca
ulysses@sistemaembutido.com.br
Técnico em eletrônica, graduando de Engenharia Elétrica na Pontifica

Universidade Católica de Minas Gerais, cofundador do IEEE no campus em Poços de
Caldas e fundador do site www.sistemaembutido.com.br. Tenho quatro anos de
experiência com sistemas embarcados para processadores desde 8bits até 32bits,
sistemas bare metal, RTOS e Linux embarcado.
7
Introdução
1. O que é?
Arduino é um kit de desenvolvimento voltado para iniciantes. É composto por

hardware e software que facilita a compreensão e o aprendizado de fundamentos
importantes de eletrônica e de programação.
Hardware: O hardware do Arduino é uma pequena placa com entradas e saídas.

É composta por um microcontrolador da série Atmel (na maioria das placas), que
muda em cada modelo de Arduino, um gravador USB e os reguladores de tensão.
Software: O software é a chave do sucesso dessa plataforma. Compilada em

C/C++ uma grande biblioteca, orientada a objetos, abstrai de forma simples e
compacta a maioria das funcionalidades que precisamos para implementar pequenos
protótipos, como:
• Controle de entradas e saídas digitais (I/O)

• Leitura dos conversores analógico-digitais (A/D)
• Geração de sinais modulados em largura (PWM)
• Controle de atuadores, tais como: motor de passo, servo motores.
• Comunicação serial, I2C, 1Wire e SPI
Figura 1 – Dimensões
http://www.embarcados.com.br/wp-content/uploads/2013/11/12-arduino-uno-dimensoes.png
8
Figura 2 – Recursos
http://www.embarcados.com.br/wp-content/uploads/2013/11/13-arduino-uno-RESUMO-660x371.jpg
Figura 3 - Schematic Arduino Uno R3
https://www.arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-schematic.pdf
[http://www.atmel.com/images/Atmel-8271-8-bit-AVR-Microcontroller-ATmega48A-48PA-88A-88PA-
168A-168PA-328-328P_datasheet_Complete.pdf]
9
2. Para que serve?
Serve para realizar prototipagens, para auxiliar em testes de novos conceitos, nova
idéias, sem perder tempo, sem a necessidade de desenvolver um hardware básico
para iniciar o desenvolvimento de um projeto.
3. Como Programar?
O arduino possui uma camada de software open source, que possui diversas
bibliotecas para sensores, baseada em C/C++, o que torna muito mais rápido e fácil o
desenvolvimento. Para utilizar esta camada de software é necessário primeiramente
que a placa possua um bootloader instalado na placa, as placas arduino já vem com
este bootloader gravado de fábrica por padrão.
O outro meio de programar, seria utilizando um compilador específico do fabricante

do microcontrolador. No microcontrolador da Atmel, pode se utilizar o Atmel Studio, e
este não necessita de nenhum bootloader.
O software é portável de um modelo de arduino para outro na maioria dos casos,

salvo em recursos muito específicos.
4. Funções Principais
Estas são as funções básicas para o funcionamento de um código arduino.
4.1. setup()
A função setup() é chamada quando um programa começa a rodar. É usada para
inicializaras variáveis, os tipos dos pinos, declarar o uso de bibliotecas, entre outros.
Esta função será executada apenas uma vez após a placa Arduino ser ligada ou
reiniciada.
Exemplo:
int buttonPin= 3;
void setup(){
Serial.begin(9600);
pinMode(buttonPin,INPUT);
}
void loop(){
// ...
}
[https://www.arduino.cc/en/Reference/Setup]
4.2. loop()
Após criar uma função setup() que declara os valores iniciais, a função loop() faz
exatamente o que seu nome sugere, entra em looping (executa sempre o mesmo
bloco de código), permitindo ao seu programa fazer mudanças e responder. Esta
função é usada para controlar ativamente a placa Arduino.
10
Exemplo:
Int buttonPin= 3;
// setup inicializa o pino do butão

void setup(){
pinMode(buttonPin,INPUT);
}
// loop checa o botão a cada vez

void loop(){
if (digitalRead(buttonPin) ==HIGH){
// ....
}
else{
// ...
}
delay(1000);
}
[https://www.arduino.cc/en/Reference/Loop]
11
Portas digitais
Para criar interface externa com motores, relés, lâmpadas, e válvulas vamos
precisar entender melhor as saídas digitais.
1. O que são Portas Digitais?
Portas digitais são aquelas que podem assumir apenas dois níveis lógicos bem
definidos, nível alto e baixo. Normalmente, o nível lógico alto é a tensão de
alimentação do Arduino (5V ou 3.3V, dependendo do modelo) e nível lógico baixo é 0V
(pino conectado ao GND). As portas digitais são comumente chamadas de I/O
ports, que em inglês significa “portas de entrada e saída”. Esse nome vem do fato que
uma porta digital pode assumir dois possíveis modos de operação, o modo de entrada
e o modo de saída.
2. Portas no modo de Saída
Quando setamos uma porta digital para o modo de saída podemos controlar qual o
estado lógico que ela apresenta. Tornando possível, assim, controlar dispositivos
externos como lâmpadas, atuadores, relés etc. É importante lembrar que jamais
poderemos exceder a corrente máxima de saída, que é aproximadamente 20mA
(verifique o datasheet do microcontrolador). Se colocarmos cargas que drenam mais
corrente iremos danificar o pino de saída e, nos casos em que necessitamos de mais
corrente, é necessário o uso de algum buffer digital de potência com transistores ou
portas lógicas.
3. Portas no modo de Entrada
São portas em que podemos conectar um dispositivo externo e ler, no código, qual
o nível presente. Utilizaremos essas portas para ler sensores digitais como botões,
chaves fim de curso, sensores de nível ou até protocolos de comunicação.
Normalmente para realizar a leitura da porta utiliza um resistor como pull-up ou pull-
down, que ‘força’ um nível, alto ou baixo, para que a porta não fique em um nível
intermediário, podendo deixar a leitura incorreta.
12
4.1. pinMode()
Configura um pino específico para definir o comportamento entre input ou output.
No Arduino, é possivel habilitar os resistores internos pullup no modo
INPUT_PULLUP. O modo INPUT explicitamente desabilita os pull-up’s internos.
Sintaxe:
pinMode(PINO, MODO);
PINO: número do pino a ser utilizado
MODO: INPUT, OUTPUT, INPUT_PULLUP
Exemplo:
pinMode(14,OUTPUT); //configura o pino 14 como saída
pinMode(2,INPUT); //configura o pino 2 como entrada
[https://www.arduino.cc/en/Reference/PinMode]
4.2. digitalWrite()
Define o valor de um pino de saída em alto (HIGH), ou baixo (LOW), quando
definido o pinMode() deste pino como OUTPUT. Quando definido como INPUT, esta
função habilita (HIGH) ou desabilita (LOW), o resistor de pull-up interno.
Sintaxe:
digitalWrite(PINO, VALOR);
PINO: número do pino a ser utilizado
VALOR: HIGH, LOW
Exemplo:
digitalWrite(9,HIGH); //coloca em nivel lógico alto o pino 9
digitalWrite(9,LOW); //coloca em nivel lógico baixo o pino 9
[https://www.arduino.cc/en/Reference/DigitalWrite]
13
4.3. digitalRead()
Realiza a leitura de um pino digital especifico.
Sintaxe:
digitalRead(PINO);
PINO: pino que será feita a leitura digital
retorna HIGH ou LOW;
Exemplo:
//Realiza a leitura do pino 8
// e salva seu valor na variavelbotao
botao = digitalRead(8);
[https://www.arduino.cc/en/Reference/DigitalRead]
4.4. delay()
Faz com que o microcontrolador fique aguardando por um tempo em
milissegundos.
Sintaxe:
delay(MS);
MS: tempo em milissegundos da pausa (unsigned long)
Exemplo:
delay(150); //aguarda 150 milisegundos em pausa
[https://www.arduino.cc/en/Reference/Delay]
14
Pratica 01 – Aciona Led
Nesta pratica iremos realizar a montagem do circuito para o acionamento de um

led, limitando sua corrente com um resistor, e então iremos escrever um software para
acender e manter aceso o led.
Componentes necessários
Protoboard, led, resistor, fios jumper, placa arduino, cabo usb.
Montagem
De posse dos components acima, faça a montagem conforme a imagem abaixo:
Figura 4 - Montagem Pratica_01
Código fonte
int LED = 9; //PINO DO ARDUINO UTILIZADO PARA O LED
void setup() {
pinMode(LED,OUTPUT); //DEFINE QUE O PINO LED SERÁ SAÍDA
}
void loop() {
digitalWrite(LED,HIGH); //COLOCA O PINO LED EM NIVEL ALTO
// digitalWrite(LED,LOW); //COLOCA O PINO LED EM NIVEL BAIXO
}
15
Gravando o software no Arduino
Conecte o cabo USB na placa Arduino, e em seguida conecte na porta USB no

seu computador. Pode ser que ao conectar o arduino no PC demore alguns minutos
para ser reconhecido. Após vá em ‘Ferramentas->Porta’ e selecione a porta que seu
arduino se encontra, neste caso o arduino está na porta ‘COM6 (Arduino/Genuino
Uno).
Agora selecione qual arduino você está utilizando, vá em ‘Ferramentas->Placa’ e

selecione Arduino/Genuino Uno, em futuros projetos verifique sempre se o arduino
utilizado é o que está selecionado, pois caso esteja um diferente poderá não funcionar
ou até mesmo funcionar de maneira inesperada.
Após configurado corretamente, pressione o botão ‘Verify/Compile’ (CTRL+R) no

topo do IDE, para se certificar que não há erros no seu código. Se não houver erros,
clique no botão ‘Upload’(CTRL+U), para fazer o upload do código para o seu Arduino.
16
Pratica 02 – Pisca Led
Nesta pratica iremos criar aquele famoso pisca-pisca de um led só.
Montagem
De posse dos componentes acima, faça a montagem conforme a imagem abaixo:
17
Código fonte
int LED =9; //PINO DO ARDUINO UTILIZADO PARA O LED
//INTERVALOS PARA QUE O LED FIQUE ACESO E APAGADO

int led_aceso= 500;
int led_apagado= 500;
voidsetup() {
pinMode(LED,OUTPUT); //DEFINE QUE O PINO LED SERÁ SAÍDA
}
voidloop() {
digitalWrite(LED,HIGH); //COLOCA O PINO LED EM NIVEL ALTO
delay(led_aceso); //AGUARDA PELO TEMPO DE 'led_aceso' EM MILISEGUNDOS
digitalWrite(LED,LOW); //COLOCA O PINO LED EM NIVEL BAIXO
delay(led_apagado); //AGUARDA PELO TEMPO DE 'led_apagado' EM MILISEGUNDOS
}
Com isto o led deverá piscar a cada 500 milisegundos.
18
Pratica 03 – Semáforo
Vamos agora construir um semáforo, utilizando os conceitos mostrados

anteriormente.
Protoboard, três (03) leds, três (03) resistores, fios jumper, placa arduino, cabo
usb.
Montagem
Figura 6- Montagem Pratica_03
19
Código fonte
int RED =12; //PINO DO ARDUINO UTILIZADO PARA O LED
int YELLOW =10; //PINO DO ARDUINO UTILIZADO PARA O LED
int GREEN =8; //PINO DO ARDUINO UTILIZADO PARA O LED
//INTERVALOS PARA QUE O LED FIQUE ACESO E APAGADO

int tempo_red= 1500;
int tempo_yellow= 500;
int tempo_green= 1000;
void setup() {
pinMode(RED,OUTPUT); //DEFINE QUE O PINO LED SERÁ SAÍDA
pinMode(YELLOW,OUTPUT); //DEFINE QUE O PINO LED SERÁ SAÍDA
pinMode(GREEN,OUTPUT); //DEFINE QUE O PINO LED SERÁ SAÍDA
}
void loop() {
digitalWrite(RED,HIGH); //COLOCA O PINO LED EM NIVEL ALTO
digitalWrite(YELLOW,LOW); //COLOCA O PINO LED EM NIVEL BAIXO
digitalWrite(GREEN,LOW); //COLOCA O PINO LED EM NIVEL BAIXO
delay(tempo_red); //AGUARDA PELO TEMPO DE 'led_aceso' EM MILISEGUNDOS
digitalWrite(RED,LOW); //COLOCA O PINO LED EM NIVEL ALTO

digitalWrite(YELLOW,LOW); //COLOCA O PINO LED EM NIVEL BAIXO
digitalWrite(GREEN,HIGH); //COLOCA O PINO LED EM NIVEL BAIXO
delay(tempo_green); //AGUARDA PELO TEMPO DE 'led_apagado' EM MILISEGUNDOS
digitalWrite(RED,LOW); //COLOCA O PINO LED EM NIVEL ALTO

digitalWrite(YELLOW,HIGH); //COLOCA O PINO LED EM NIVEL BAIXO
digitalWrite(GREEN,LOW); //COLOCA O PINO LED EM NIVEL BAIXO
delay(tempo_yellow); //AGUARDA PELO TEMPO DE 'led_apagado' EM MILISEGUNDOS
}
20
Pratica04 – Entradas Digitais
Nesta prática iremos realizar a leitura do estado lógico de uma microchave e

acionar um led.
Protoboard, um (01) led, uma (01) microchave, um (01) resistor 150Ω, um (01)
resistor 1KΩ ou 10KΩ, fios jumper, placa arduino, cabo usb.
Montagem
Figura 7 - Montagem Prática_04
Código fonte
int button= 13;
int led = 6;
char bt=0;
// the setup routine runs once when you press reset:

void setup() {
// initialize the digital pin as an output.
pinMode(led,OUTPUT);
pinMode(button,INPUT);
}
// the loop routine runs over and over again forever:

void loop() {
if(digitalRead(button)==HIGH){
bt=!bt;
while(digitalRead(button)==HIGH);
}
digitalWrite(led,bt);
21
PWM
1. O que é?
Pulse WidthMudulation, é uma técnica utilizada por sistemas digitais para a

variação do valor médio de uma forma de onda periódica. A técnica consiste em
manter a frequência de uma onda quadrada fixa e variar o tempo que o sinal fica em
nível lógico alto, esse tempo é chamado de dutycycle, o ciclo ativo da forma de onda.
O Arduino trabalha com uma frequência de 490Hz, ou seja 2 milisegundos cada
ciclo,alguns pinos podem chegar a um valor maior.
Figura 8 - PWM
https://www.arduino.cc/en/Tutorial/PWM
A tensão média de saída poderá ser calculada da seguinte forma:
Vout = (dutycycle/100)*Vcc
• Vout - tensão de saída em V;

• dutycycle - valor do ciclo ativo do PWM em %;
• Vcc - tensão de alimentação em V.
22
2. Para quê serve
O PWM pode ser utilizado para aplicações como:
• controle de velocidade de motores;

• variação da luminosidade de leds;
• geração de sinais analógicos;
• geração de sinais de áudio.
3. Quais pinos são PWM
Nem todos os pinos da placa Arduino podem ser utilizados para PWM, existem pinos
específicos para esta função, e estes pinos são marcados com o caracter “ ~ ” na frente do
número do pino.
Figura 9 - Pinos PWM
Primeiramente o pino que será utilizado deve se configurar como saída digital.
23
4.1. analogWrite()
Escreve um valor analógico (onda PWM) em um pino especificado. Pode ser
utilizado para controlar a intensidade de um led, a velocidade de um motor.
Sintaxe:
analogWrite(PINO, VALOR);
PINO: número do pino utilizado
VALOR: valor do dutycicle de 0 a 255
Exemplo:
analogWrite(11, 255/2); //PWM em 25%
[https://www.arduino.cc/en/Reference/AnalogWrite]
24
Pratica 05 – Utilizar PWM para controlar o brilho
Vamos agora realizar o ajuste do brilho de um led utilizando o PWM, esta prática
poderá ser utilizada também para ajustar a velocidade de um motor, ou até mesmo
para gerar um sinal sonoro.
Montagem
Código fonte
25
int LED = 11;
int tempo =200;
unsignedchar dutty= 0;
char passo= 5;
void setup() {
pinMode(LED,OUTPUT);
}
void loop() {
analogWrite(LED,dutty);
delay(tempo);
dutty+=passo;
if((dutty>=255 && passo>0) || (dutty<=0 && passo<0)){
passo= passo * (-1);
}
}
26
Pratica 06 – Ajustar o brilho de um led com microchaves
Vamos agora realizar o ajuste a intensidade do brilho de um led utilizando o PWM,

e duas microchaves.
Protoboard, um (01) led, duas (02) microchaves, um (01) resistor 150Ω, um (01)
resistor 1KΩ ou 10KΩ, fios jumper, placa arduino, cabo usb.
Montagem
27
Código fonte
int BT_MAIS = 10;
int BT_MENOS = 13;
int LED = 5;
int dutty= 0;
char passo=5;
void setup() {
pinMode(BT_MAIS,INPUT);
pinMode(BT_MENOS,INPUT);
}
void loop() {
if(digitalRead(BT_MAIS)==HIGH){
if(dutty<255){
dutty+=passo;
}
while(digitalRead(BT_MAIS)==HIGH);
}
if(digitalRead(BT_MENOS)==HIGH){
if(dutty>0){
dutty-=passo;
}
while(digitalRead(BT_MENOS)==HIGH);
}
analogWrite(LED,dutty);
}
28
ADC
1. O que é?
Conversor analógico-digital, consiste em um driver contido na placa arduino que

realiza a conversão de um sinal analógico em um sinal digital correspondente. Um
conversor analógico-digital trabalha com resolução de bits específica, determinando
assim a exatidão da leitura realizada do sinal analógico. O sinal analógico que o
conversor será capaz de medir será de uma tensão contínua que pode variar, sem ter
um potencial negativo, e tendo como limiar máximo um sinal de referência, que
depende da especificação do microcontrolador, de até o valor de VCC.
Figura 12 – ADC
http://www.robotplatform.com/knowledge/ADC/ADC_samples_wave.jpg
Na placa arduino Uno, por exemplo, que utiliza um microcontrolador da Atmel,

o Atmega328P, possui seis (06) pinos para conversão ADC, que são identificados por
Ax, sendo x o número do pino AD. Este microcontrolador possui o driver ADC
internamente, mas existem casos que devido a precisão e custo, opta se por utilizar
um chip ADC externo. O Atmega328P trabalha com uma resolução máxima de 10bits.
29
Figura 13 - Pinos ADC
Após realizar a leitura de um pino AD, no caso de 10bits, será obtido um valor
entre 0 e 1023. Poderá ser necessário realizar a conversão para o valor de tensão
“aproximado” do valor adquirido. Para saber qual o valor da resolução em volts basta
utilizar a seguinte equação:
Vref
resolução
2
Vref – tensão de referência para a conversão AD
n – número de bits do conversor
O Atmega328P possui basicamente dois tipos de tensão de referência:
• Referência interna de 1.1v;

• Referência externa no pino AREF de 0 a 5v.
Por exemplo, se utilizar 5volts como referência:
5
solução 4,88mV
1023
Isto significa que cada bit valerá 4,88mV.Se, por exemplo, na leitura do AD
obter um valor de 120, o valor em volts será de:
120 ∗ 0.00488 585,6mV
30
2. Para quê serve
O ADC pode ser utilizado para:
• Realizar leitura de um sensor de temperatura analógico;

• Ler o potencial de um divisor de tensão ou um amplificador operacional;
• Captar um sinal de audio.
Primeiramente deve se configurar o pino como entrada digital.
3.1. analogReference()
Configura a tensão de referência usada pela entrada analógica, ou seja o valor
máximo de entrada permitido.
Sintaxe:
analogReference(TIPO);
TIPO: qual tipo de referência será utilizado
DEFAULT Referência padrão 5v ou 3.3v

Referência 1.1v Atmega168 ou
INTERNAL Atmega328 e 2.56v Atmega8 (exceto
ArduinoMega)
INTERNAL1V1 Referência 1.1v (ArduinoMega)
INTERNAL2V56 Referência 2.56v (ArduinoMega)
EXTERNAL Valor do pino AREF (0 a 5v)
Exemplo:
analogReference(DEFAULT);
[https://www.arduino.cc/en/Reference/AnalogReference]
3.2. analogRead()
Faz a leitura de valores de um pino analógico. A placa possui 6 canais de 10 bits
no conversor analógico para digital. Isso significa que as tensões de entrada serão
mapeadas em valores entre 0 e 5 volts para valores inteiros de 0 a 1023. Demora
cerca de 100 microssegundos para ler uma entrada analógica.
Sintaxe:
31
analogRead(PIN);
PIN: pino analógico a ser lido
Retornan o valor decimal da leitura realizada.
Exemplo:
int temp = analogRead(A0);
[https://www.arduino.cc/en/Reference/AnalogRead]
32
Pratica 07 – Controlando o brilho de um led
Utilizando um potênciometro, iremos realizar a leitura do divisor de tensão gerado

no potenciômetro e com este valor iremos ajustar a intensidade do brilho de um led.
Protoboard, um (01) led, um (01) potenciômetro, um (01) resistor 150Ω, fios

jumper, placa arduino, cabo usb.
Montagem
Código fonte
int LED = 8;
int POTENCIOMETRO = A0;
int sensor = 0;
void setup() {
pinMode(POTENCIOMETRO,INPUT);
}
void loop() {
sensor=analogRead(POTENCIOMETRO);
analogWrite(LED,sensor/4);
}
Serial
33
1. O que é?
Transmissão e Recepção Assincrona/Sincrona Universal (UART ou USART), éuma

comunicação digital serial, que pode transmitir e receber ao mesmo tempo, que
depende de um clock sincronizado entre os dispositivos que estão se comunicando,
esse clock é chamado de Baud Rate.
2. Para quê serve?
A comunicação uart pode ser utilizada para:
• Interface entre um hardware e um computador;

• Comunicação entre um hardware e um leitor de código de barras;
• Comunicação entre um inversor de frequência.
3. Pinos do Arduino
O Arduino Uno possui apenas uma porta de comunicação serial, esta possui os
pinos TX(pino de transmissão) e RX(pino de recepção). Para uma comunicação
correta o pino de TX do arduino deverá ser ligado no pino RX do dispositivo que será
feita a comunicação, por exemplo um computador, e o pino de RX do arduino no pino
de TX. Lembrando que os níveis de tensão do arduino e da porta serial do computador
são diferentes, o arduino trabalha na faixa de 5Vcc, já a serial do computador trabalha
na faixa de 12Vcc, se realizar a conexão deverá ser utilizado um transceiver para
converter os níveis de tensão, ou poderá queimar tanto o arduino quanto a porta serial
do computador. Poderá também ser feita uma comunicação serial através da porta
USB, pois devido a características de hardware da placa isto é permitido.
Figura 15 - Pinos Serial
A biblioteca arduino para serial possui várias funções que são:
34
4.1. Serial.begin()
É a primeira função a ser utilizada, ela configura a taxa de transmissão (baud rate)
e define a quantidade de bits, paridade e stop bits.
Sintaxe:
Serial.begin(VEL, CONFIG);
Serial.begin(VEL);
VEL: velocidade em bits por segundo (baud rate) da transmissão
Tabela 1 - Valores Baud Rate
300 600 1200 2400

4800 9600 14400 19200
28800 38400 57600 1115200
CONFIG: tipo de configuração a ser utilizada, como a quantidade de bits, paridade

e stop bits. Por padrão é configurado com oito bits, sem paridade, e um bit de stop
(SERIAL_8N1).
Exemplo:
Serial.begin(9600, SERIAL_8N1);
Serial.begin(9600);
[https://www.arduino.cc/en/Serial/Begin]
4.2. Serial.available()
Retorna a quantidade de bytes disponível no buffer de leitura, podendo retornar
no máximo 64 bytes.
Exemplo:
int cont_buffer = Serial.available();
[https://www.arduino.cc/en/Serial/Available]
4.3. Serial.read()
Retorna o byte mais recente disponível no buffer, caso não haja nenhum dado
disponível será retornado -1.
35
Exemplo:
char buffer[64];
buffer[0] = Serial.read();
[https://www.arduino.cc/en/Serial/Read]
4.4. Serial.print()
Escreve na serial um valor especificado, e retorna o número de bytes escritos.
Sintaxe:
Serial.print(VAL, TIPO);
Serial.print(VAL);
VAL: valor a ser escrito na serial
TIPO: base numérica a ser utilizada: BIN(binário), OCT(octal),

HEX(hexadecimal), DEC(decimal).
Exemplo:
Serial.print(78, BIN);
Serial.print("hello world");
[https://www.arduino.cc/en/Serial/Print]
4.5. Serial.write()
Escreve um byte, ou uma sequência de bytes na porta serial, podendo receber
vários tipos de parâmetros.
Sintaxe:
Serial.write(VAL);
Serial.write(STR);
Serial.write(BUF, LEN);
VAL: envia um valor enviando como um único byte
STR: envia uma string pela porta serial
BUF: buffer com uma sequência de bytes agrupados
LEN: valor máximo de BUF que será enviado
36
Exemplo:
Serial.write(0x0A);
Serial.write("Valor");
char buf[7] = {0x0F, 15, 0b00001111, 0,0,0,0};

Serial.write(BUF, 2);
[https://www.arduino.cc/en/Serial/Write]
37
Prática 08 – Serial “HELLO WORLD”
Utilizar a placa arduino para realizar uma comunicação com o computador.
Placa arduino, cabo usb.
Código fonte
void setup() {
Serial.begin(9600,SERIAL_8N1);
}
void loop() {
Serial.print("Hello World\n");
}
Procedimento
Após realizar a gravação do software acima na placa arduino, vá em

‘Ferramentas’->’Monitor Serial’ e verifique se está sendo exibida a mensagem.
38
Prática 09 – Sensor de Temperatura
Utilizar a placa arduino para realizar a temperatura do sensor LM35 e enviar o

valor de temperatura para a porta serial a cada um (01) segundo.
Protoboard, um (01)sensor LM35, fios jumper, placa arduino, cabo usb.
Montagem
Código fonte
int LM35 = A0; // Define o pino que lera a saída do LM35
float temp[10],temperatura; // Variável que armazenará a temperatura medida
int p=0;
//Função que será executada uma vez quando ligar ou resetar o Arduino
void setup() {
Serial.begin(9600); // inicializa a comunicação serial
}
void loop() {
int sensor = analogRead(LM35);
temp[p] = (float(sensor)*5/(1023))/0.01;
p++;
if(p>=10){p=0;}
for(int i=0; i<10; i++){
temperatura += temp[i];
}
temperatura = temperatura / 10;
Serial.print("Temperatura: ");
Serial.println(temperatura);
delay(500);
}
39
Prática 10 – Controle do Arduino pela porta Serial
Nesta prática iremos enviar comandos pela porta serial para o controlar nosso
dispositivo Arduino, de quando iremos querer realizar a leitura do sensor de
temperatura LM35. Este conceito será útil para uma interface entre o arduino e um
computador, para o controle e supervisão remoto.
Protoboard, um (01) sensor LM35, fios jumper, placa arduino, cabo usb.
Montagem
40
Código fonte
int LM35 = A0;
float temp[10],temperatura; // Variável que armazenará a temperatura medida
int p=0;
int cont_buffer=0;
char buffer[64];
int i=0;
void setup() {
Serial.begin(9600);
}
void loop() {
int sensor = analogRead(LM35);
temp[p] = (float(sensor)*5/(1023))/0.01;
p++;
if(p>=10){p=0;}
for(int i=0; i<10; i++){
temperatura += temp[i];
}
temperatura = temperatura / 10;
cont_buffer=Serial.available();
if(cont_buffer>0){
for(i=0;i<cont_buffer;i++){
buffer[i] =Serial.read();
}
if(buffer[0]=='T'){
Serial.print("\nTemperatura: ");
Serial.print(temperatura);
}
}
}
41
Disco Piezo
1. O que é?
Um disco piezo funciona quando uma corrente elétrica passa pelo material
cerâmico do disco, fazendo com que ele mude de forma e produza um som. O disco
também funciona de forma inversa, ou seja, quando houver uma variação de pressão,
a força no material provoca a geração de uma corrente elétrica.
2. Para quê serve?
Pode ser utilizado para gerar sinais sonoros, e também para captar sinais sonoros.
3.1. tone()
Gera uma onda quadrada da frequência especificada em um pino. A duração pode
ser especificada, caso contrário, o sinal irá continuar até que uma chamada para
noTone (). O pino pode ser ligado a um vibrador piezo elétrico ou um alto falante para
reproduzir tons.
Apenas um tom pode ser gerado de cada vez. Utilização da função de tone () irá
interferir com a saída PWM nos pinos 3 e 11 (por razões diferentes do
microcontrolador).
Sintaxe:
tone(PIN, FREQ);
tone(PIN, FREQ, DUR);
PIN: pino que irá gerar o som
FREQ: freqüência do som em hertz
DUR: duração do som em milisegundos
[https://www.arduino.cc/en/Reference/Tone]
42
3.2. noTone()
Para a geração de uma onda quadrada gerada por tone().
Sintaxe:
noTone(PIN);
PIN: pino que deseja para a geração de som.
[https://www.arduino.cc/en/Reference/NoTone]
43
Prática 11 – Sonorizador
Desenvolver um emissor de áudio em determinada frequência.
Protoboard, um (01) disco piezo, fios jumper, placa arduino, cabo usb.
Montagem
Código fonte
int PIEZO = 8;
int frequencia=31;
void setup() {
pinMode(PIEZO,OUTPUT);
}
void loop() {
tone(PIEZO,frequencia);
delay(2);
frequencia+=10;
if(frequencia>65535){frequencia=31;}
}
44
Prática 12 – Tocar uma melodia
Desenvolver um emissor de áudio que possa reproduzir uma melodia.
Protoboard, um (01) disco piezo, fios jumper, placa arduino, cabo usb.
Montagem
45
Código fonte
#define NOTA_C3 131
#define NOTA_CS3 139
#define NOTA_D3 147
#define NOTA_DS3 156
#define NOTA_E3 165
#define NOTA_F3 175
#define NOTA_FS3 185
#define NOTA_G3 196
#define NOTA_GS3 208
#define NOTA_A3 220
#define NOTA_AS3 233
#define NOTA_B3 247
#define NOTA_C4 262
#define NOTA_CS4 277
#define NOTA_D4 294
#define NOTA_DS4 311
#define NOTA_E4 330
#define NOTA_F4 349
#define NOTA_FS4 370
#define NOTA_G4 392
#define NOTA_GS4 415
#define NOTA_A4 440
#define NOTA_AS4 466
#define NOTA_B4 494
#define INTEIRO 1
#define MEIO 0.5
#define QUARTO 0.25
#define OITAVO 0.125
#define DECIMASEXTA 0.0625
int PIEZO=8;
int musica[] = { NOTA_C4, NOTA_C4, NOTA_C4, NOTA_C4, NOTA_C4, NOTA_B3, NOTA_G3, NOTA_A3,
NOTA_C4, NOTA_C4, NOTA_G3, NOTA_G3, NOTA_F3, NOTA_F3, NOTA_G3, NOTA_F3, NOTA_E3,
NOTA_G3,
NOTA_C4, NOTA_C4, NOTA_C4, NOTA_C4, NOTA_A3, NOTA_B3, NOTA_C4, NOTA_D4};
float duracao[] = { OITAVO, QUARTO+OITAVO, DECIMASEXTA, QUARTO, QUARTO, MEIO, MEIO,

MEIO, QUARTO, QUARTO, MEIO+QUARTO, QUARTO, QUARTO, QUARTO, QUARTO+OITAVO, OITAVO,
QUARTO, QUARTO, OITAVO, OITAVO, QUARTO, QUARTO, QUARTO, QUARTO, MEIO+QUARTO};
int tamanho=0;
void setup(){
tamanho = sizeof(musica)/sizeof(musica[0]);
}
void loop(){
for(int x=0; x<tamanho; x++){
tone(PIEZO, musica[x]);
delay(1500*duracao[x]);
noTone(PIEZO);
}
delay(5000);
}
46
LDR
1. O que é?
O LDR(light dependent resistor) é um resistor dependente de luz, ou fotoresistor.

Quando a luz atinge o material fotocondutor, ele diminui sua resistência, permitindo
que uma corrente maior passe por seus terminais.
2. Para quê serve?
Pode ser utilizado para identificar a presença ou a intensidade de luz.
A leitura do LDR deverá ser feita como se fosse um potenciômetro, então a função
a ser utilizada será a analogRead(). Caso tenha alguma dúvida volte na sessão que
trata da leitura dos sinais do ADC.
47
Prática 14 – LDR
Nesta prática deverá ser feita a leitura do sinal gerado pelo LDR e com o sinal lido
gerar um sinal sonoro em um disco piezo.
Protoboard, um (01) disco piezo, (01) ldr, fios jumper, placa arduino, cabo usb.
Montagem
Código Fonte
int LDR = A0;
int PIEZO = 8;
int ldr= 0;
void setup() {
pinMode(LDR,INPUT);
}
void loop() {
ldr = analogRead(LDR);
tone(PIEZO,1000);
delay(25);
noTone(PIEZO);
delay(ldr);
}
48
Motor CC
1. O que é?
É uma máquina capaz de converter energia mecânica em energia elétrica.
2. Para quê serve?
Pode ser utilizado para controle de velocidade de um ‘carrinho’, para a locomoção

de objetos, etc.
Para acionamento de motores, é necessário utilizarmos um circuito externo capaz

de gerar as correntes necessárias para o acionamento, neste caso deveremos utilizar
um transistor. Um motor cc pode ser ligado utilizando um sistema de ON/OFF, ou seja,
desligado ou ligado em sua velocidade máxima.
Porém em vários casos se faz necessário a utilização de velocidades variadas.

Para isto temos um recurso muito interessante, o PWM. Caso tenha alguma dúvida
volte até a sessão que tratamos sobre a geração de sinais PWM.
49
Prática 15 - Controle de motor CC
Nesta prática iremos realizar o controle de velocidade de um motor cc, indo da

velocidade zero, e aumentando gradativamente até seu valor máximo.
Protoboard, um (01) motor cc, fios jumper, placa arduino, cabo usb.
Montagem
Código fonte
int TIP = 9;
int motor = 0;
void setup() {
pinMode(TIP,OUTPUT);
}
void loop() {
analogWrite(TIP, motor);
delay(200);
motor+=10;
if(motor>255){motor=0;}
}
50
Prática 16 - Controlar o motor CC pela Serial - Desafio
Nesta prática você deverá ajustar a velocidade do motor cc utilizando a interface

serial.
Protoboard, um (01) motor cc, fios jumper, placa arduino, cabo usb.
Montagem
Código fonte
int TIP = 9;
int motor = 0;
int cont_buffer=0;
char buffer[64];
int i=0;
void setup() {
pinMode(TIP,OUTPUT);
Serial.begin(9600);
}
void loop() {
cont_buffer=Serial.available();
if(cont_buffer>0){
for(i=0;i<cont_buffer;i++){
buffer[i] =Serial.read();
}
switch((buffer[0]-48)){
case 0: motor=0; break;
case 4: motor=100;break;
51
}
}
analogWrite(TIP, motor);
}
52
LCD
1. O que é?
É um display de cristal liquido (LCD), que consiste de um líquido polarizador da

luz, eletricamente controlado, que se encontra comprimido dentro de ‘celas’ entre duas
lâminas transparentes polarizadoras.
2. Para quê serve?
É utilizado para exibir informações em modo gráfico ou texto.
3. Funções para o LCD
Para trabalharmos com o display LCD deveremos primeiramente incluir em nosso

código a biblioteca LiquidCrystal.h, esta biblioteca irá prover todos os recursos
necessários para podermos trabalhar com o display.
3.1. LiquidCrystal
Utilizada para criar um objeto que irá referenciar o display com os pinos do
Arduino.
Sintaxe:
LiquidCrystal(RS, RW, EN, D4, D5, D6, D7);
LiquidCrystal(RS, EN, D0, D1, D2, D3, D4, D5, D6, D7);
LiquidCrystal(RS, RW, EN, D0, D1, D2, D3, D4, D5, D6, D7);
RS: número do pino do Arduino utilizado pelo rs do LCD
RS: número do pino do Arduinoutilizado pelo rw do LCD
EN: número do pino do Arduinoutilizado pelo en do LCD
D0~D7: número dos pinos do Arduino utilizado pelo barramento de dados do LCD
Exemplo:
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
[https://www.arduino.cc/en/Reference/LiquidCrystal]
53
3.2. lcd.begin()
Esta função é utilizada para inicializar o display, deverá ser chamada toda vez que
o display for energizado.
Sintaxe:
lcd.begin(COL, LIN);
COL: número de colunas que o display possui
LIN: número de linhas que o display possui
Exemplo:
lcd.begin(16, 2);
[https://www.arduino.cc/en/Reference/LiquidCrystalBegin]
3.3. lcd.print()
Função utilizada para imprimir valores no display.
Sintaxe:
lcd.print(VAL);
lcd.print(VAL, BASE);
DADO: dado a ser impresso no display
BASE: tido do dado impresso, BIN, OCT, DEC, HEX
Exemplo:
lcd.print("Temperatura ");
lcd.print(25, DEC);
[https://www.arduino.cc/en/Reference/LiquidCrystalPrint]
3.4. lcd.setCursor()
É utilizada para posicionar o cursor, onde será escrito um novo valor.
Sintaxe:
lcd.setCursor(COL, LIN);
COL: número da coluna desejada
LIN: número da linha desejada
[https://www.arduino.cc/en/Reference/LiquidCrystalSetCursor]
54
3.5. lcd.cursor()
Função utilizada para mostrar o cursor no display.
lcd.cursor();
[https://www.arduino.cc/en/Reference/LiquidCrystalCursor]
3.6. lcd.noCursor()
Função utilizada para ocultar o cursor no display.
lcd.noCursor();
[https://www.arduino.cc/en/Reference/LiquidCrystalNoCursor]
3.7. lcd.blink()
Função utilizada para piscar o cursor no display.
lcd.blink();
[https://www.arduino.cc/en/Reference/LiquidCrystalBlink]
3.8. lcd.noBlink()
Funções utilizadas para não piscar o cursor no display.
lcd.noBlink();
[https://www.arduino.cc/en/Reference/LiquidCrystalNoBlink]
3.9. lcd.rightToLeft()
Função utilizada para mover todo o conteúdo do display da direita para a
esquerda.
lcd.rightToLeft();
[https://www.arduino.cc/en/Reference/LiquidCrystalRightToLeft]
3.10. lcd.leftToRight()
Função utilizada para mover todo o conteúdo do display da esquerda para a
direita.
lcd.leftToRight();
[https://www.arduino.cc/en/Reference/LiquidCrystalLeftToRight]
55
3.11. lcd.home()
Posiciona o cursor na linha superior na primeira coluna.
lcd.home();
[https://www.arduino.cc/en/Reference/LiquidCrystalHome]
3.12. lcd.display()
Função utilizada para ligar o display.
lcd.display();
[https://www.arduino.cc/en/Reference/LiquidCrystalDisplay]
3.13. lcd.noDisplay()
Função utilizada para desligar o display.
lcd.noDisplay();
[https://www.arduino.cc/en/Reference/LiquidCrystalNoDisplay]
56
Prática 17 – Display LCD
Nesta prática iremos aplicar a utilização do display LCD.
Protoboard, um (01) display lcd, fios jumper, placa arduino, cabo usb.
Montagem
Código fonte
#include<LiquidCrystal.h>
// Inicializa a biblioteca com os números dos pinos de interface
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Cria um objeto lcd e atribui os pinos
void setup() {
lcd.begin(16, 2); // Define o display com 16 colunas e 2 linhas
}
void loop() {
lcd.setCursor(0, 0); //Posiciona o cursor na primeira coluna e linha do LCD
lcd.print("Ola Jovem!"); //Escreve no LCD
lcd.setCursor(0, 1);
lcd.print("Padauam");
}
57
Prática 18 – Controles do LCD - Desafio
Utilizando a teoria apresentada anteriormente, pratique todas as funções

apresentadas sobre o display LCD.
Protoboard, um (01) display lcd, fios jumper, placa arduino, cabo usb.
Montagem
Código fonte
void setup() {
// escreva seu código aqui
}
void loop() {
}
58
Servo Motor
1. O que é?
É uma máquina eletromecânica, que apresenta movimento proporcional a um

comando, que verifica sua posição atual para controlar seu movimento indo para a
posição desejada. Tem um eixo com liberdade de apenas 180º graus, porém preciso
em sua posição.
2. Para quê serve?
É utilizado para geração de movimento mais precisos.
Para a utilização do servo motor, precisamos primeiramente incluir a biblioteca

servo.h, que é responsável pelos tratamentos de comandos a serem enviados para o
motor.
3.1. Servo
Objeto criado para poder referenciar o servo motor no código.
Exemplo:
#include <Servo.h>
Servo servo1;
[https://www.arduino.cc/en/Reference/Servo]
3.2. servo.attach()
Utilizado para referenciar o pino conectado ao servo motor ao objeto de referência
em código.
Sintaxe:
servo1.attach(PIN, MIN, MAX);
servo1.attach(PIN);
PIN: pino a ser utilizado para controle do servo motor;
MIN: largura do pulso, em microssegundos referente ao menor ângulo possível;
MAX: largura do pulso, em microssegundos referente ao maior ângulo possível.
[https://www.arduino.cc/en/Reference/ServoAttach]
59
3.3. servo.detach()
Utilizado para remover a referência entre o pino do servo motor e o objeto de
referência em código.
servo1.detach();
[https://www.arduino.cc/en/Reference/ServoDetach]
3.4. servo.attached()
Utilizado para verificar se o objeto já está referenciado, retornando true se
verdadeiro, ou false caso não esteja referenciado.
servo1.attached();
[https://www.arduino.cc/en/Reference/ServoAttached]
3.5. servo.write()
Envia o comando para o servo motor posicionar no ângulo desejado, sendo um
valor entre 0 e 180.
Sintaxe:
servo1.writte(ANG);
ANG: ângulo desejado
Exemplo:
servo1.writte(40);
[https://www.arduino.cc/en/Reference/ServoWrite]
3.6. servo.read()
Realiza a leitura do servo motor, retornando o ângulo em que este se encontra.
servo1.read();
[https://www.arduino.cc/en/Reference/ServoRead]
60
Pratica 19 – Servo Motor
Nesta pratica iremos realizar a configuração e a movimentação aleatória do servo

motor.
Protoboard, um servo motor, fios jumper, placa arduino, cabo usb.
Montagem
Código fonte
#include<Servo.h>
Servo servo1;
int passo=0;
void setup() {
servo1.attach(5);
}
void loop() {
servo1.write(random(180));
delay(300);
}
61
Prática 20 – Controles do Servo Motor
Utilizando a teoria apresentada anteriormente, pratique todas as funções

apresentadas sobre o Servo Motor.
Protoboard, um servo motor, fios jumper, placa arduino, cabo usb.
Montagem
Código fonte
void setup() {
}
void loop() {
}
62
Motor de Passo
1. O que é?
É um tipo de motor elétrico usado quando se necessita de um posicionamento

muito preciso, ou um ângulo exato.
Os motores mais comuns possuem de 3 a 72 passos/revolução. Controladores

avançados para motores de passo, utilizam modulação por largura de pulso para
realizarem micropassos, obtendo maior resolução.
Suponhamos um motor de passo de 100 passos por revolução, isto significa que
este terá uma resolução de 3,6º.
Acionamos a solenoide 1, o eixo será atraído para esta posição e irá ficar fixo até
que seja alterada a solenoide acionada.
Figura 27 - MOTOR DE PASSO
Agora desenergizamos a solenoide 1 e acionamos a solenoide 2. Isto resultará na

rotação do eixo para o pólo magnetizado, resultando em uma rotação de 3,6º.
63
Figura 28 - MOTOR DE PASSO
Então desenergizamos a solenoide 2 e acionamos a solenoide 3, resultando em

outra rotação e mais 3,6º.
Figura 29- MOTOR DE PASSO
Este processo é chamado de passo completo, ou seja, é acionada apenas um

solenoide por vez, que deverá ser repetido até que seja obtida a posição desejada.
Outro método também utilizado é o meio passo, que resulta no acionamento de duas
solenoides na transição de um solenoide para outra, para obter um passo
intermediário.
Outro fator será a frequência de troca/acionamento dos solenoides, pois os

motores de passo possuem uma frequência máxima, que se não for respeitada irá
gerar desgastes e até a queima do motor.
64
2. Para quê serve?
São muito utilizados para o controle de posicionamento preciso, como em

máquinas CNC.
3.1. Stepper
Esta chamada cria um objeto que irá referenciar o motor de passo, junto com os
pinos utilizados, e com as funções de controle, para que seja possível utilizar mais de
um motor de passo, e poder controlá-los individualmente.
Sintaxe:
Stepper stepper(STEP, PIN1, PIN2);
Stepper stepper(STEP, PIN1, PIN2, PIN3, PIN4);
STEP: quantidade de passos que o motor possui;
PINx: pino do arduino utilizado para controle do motor
Exemplo:
#include <Stepper.h>
Stepper motorp(100, 8, 9, 10, 11);
[https://www.arduino.cc/en/Reference/StepperConstructor]
3.2. setSpeed()
Esta função define qual será a velocidade do motor em rpm(rotações por minuto).
Sintaxe:
motorp.setSpeed(VEL);
VEL: velocidade do motor em rotações por minuto (long)
Exemplo:
motorp.setSpeed(60);
[https://www.arduino.cc/en/Reference/StepperSetSpeed]
65
3.3. step()
Esta função define quantos passos deverão ser dados com a velocidade setada
anteriormente, e após parar.
Sintaxe:
motorp.step(STEP);
STEP: quantidade de passos que serão dados pelo motor.
Exemplo:
motorp.step(10); //10 passos sentido horario
motorp.step(-10); //10 passos sentido anti-horario
[https://www.arduino.cc/en/Reference/StepperStep]
66
Pratica 21 – Motor de Passo
Nesta pratica faça a movimentação de um motor de passo, alternando entre

velocidades e posições.
Protoboard, um motor de passo, um driver para o motor de passo, fios jumper,

placa arduino, cabo usb.
Montagem
Figura 30 – Montagem Prática_21
http://blog.filipeflop.com/wp-content/uploads/2013/02/Circuito_Uno_Motor_de_passo_5v1.png
Código Fonte
#include<Stepper.h>
Stepper motorp(500, 8, 10, 9, 11);
void setup() {
}
void loop()
{
motorp.step(500);
delay(2000);
motorp.step(-500);
delay(2000);
motorp.setSpeed(5);
motorp.step(10);
delay(2000);
motorp.step(-10);
delay(2000);
}
67
Ultrassônico
1. O que é?
É um sensor que se baseia no principio de funcionamento da pastilha piezo

elétrica. Em um momento o sensor envia um sinal sonoro em uma frequência
conhecida, então este sinal viaja ao longo do ambiente. Quando este chega a um
objeto, esta onda sonora é refletida para o transmissor, que estará aguardando a
leitura deste sinal para que se possa determinar a qual distância o objeto. A distância
é determinada com base na velocidade do som.
∗ !/2
D - Distância entre o transmissor e o objeto
Te – Tempo do echo em nível alto
Vs – Velocidade do som (340m/s)
A resposta é dividida por dois, por conta que este tempo é o tempo que a onda
sonora leva para atingir o objeto e voltar.
Figura 31 - Sensor Ultrassônico
http://blog.filipeflop.com/wp-content/uploads/2015/07/HC_SR04_Trigger_Echo.jpg
68
Figura 32- Sensor Ultrassônico
http://blog.filipeflop.com/wp-content/uploads/2015/07/Diagrama-tempo-hc-sr04.png
2. Para quê serve?
Pode ser utilizado como radar, para a detecção de objetos, determinar a distância
que se encontra um objeto.
Para trabalhar com o sensor ultrassônico, primeiramente precisaremos baixar a

biblioteca que está no link abaixo:
https://github.com/SistemaEmbutido/Ultrassonico_lib
Após feito o download, descompacte a pasta e coloque-a dentro da pasta

LIBRARIES, do diretório do IDE do arduino.
Primeiramente adicione no projeto a biblioteca:
3.1. Ultrasonic
Cria um objeto que referencia o sensor.
Sintaxe:
Ultrasonic ultrasonic(TR, EC, TO);
Ultrasonic ultrasonic(TR, EC);
TR: pino de trigger
EC: pino de echo
TO: tempo máximo de resposta (timeout)
Exemplo:
#include <Ultrasonic.h>
Ultrasonic ultra(9, 8);
3.2. ranging
Retorna a distância calculada pelo sensor.
69
Sintaxe:
ultra.Ranging(SIS);
SIS: sistema de métrico (1- centímetros[CM], 0 – Polegadas[INC])
Retorna um long contendo a distância.
Exemplo:
dist = ultra.Ranging(1);
3.3. timing
Retorna o tempo gasto pela onda sonora.
Sintaxe:
ultra.Timing();
Retorna um long contendo o tempo em milissegundos.
Exemplo:
tempo = ultra.Timing();
3.4. pulseIn
Retorna o tempo de duração de um pulso em um determinado pino, sendo este
pulso em nível lógico baixo ou alto.
Sintaxe:
pulseIn(PIN, VAL);
pulseIn(PIN, VAL, TO);
PIN: pino que será detectado o pulso
VAL: nível lógico do pulso
TO: tempo máximo para leitura do pulso (timeout)
Pratica 22 - Ultrassonico
Nesta pratica faça a leitura do sensor ultrassônico e envie o valor detectado pela
serial.
70
Protoboard, sensor ultrassonico HC-SR04, fios jumper, placa arduino, cabo usb.
Montagem
http://blog.filipeflop.com/wp-content/uploads/2015/07/Arduino_HC_SR04_bb.png
Código Fonte
#include<Ultrasonic.h>
Ultrasonicultrasonic(4,5);
void setup() {
Serial.begin(9600);
}
void loop()
{
Serial.print(ultrasonic.Ranging(CM));
Serial.println(" cm" );
delay(100);
}
71
APENDICE A
Este apêndice tem por objetivo apresentar alguns conceitos de programação que
poderão ser necessários no desenvolvimento deste curso.
1. Tipos de dados
As variáveis podem assumir diferentes tipos de dados, tais tipos determinarão sua
capacidade e numeração que poderá ser utilizada. Os tipos básicos de dados são
apresentados a seguir:
1.1. void
A palavra reservada void é usada em declarações de funções. Este tipo indica que
a função não retorna nenhum valor quando é executada.
Exemplo:
// as funções setup e loop não retornam valores quando são executadas
void setup(){
// ...
}
void loop(){
// ...
}
1.2. Boolean
O tipo boolean pode representar valores booleanos, verdadeiro(true) ou
falso(false). Um tipo boolean ocupa um byte da memória.
Exemplo:
int LEDpin = 5; // LED no pino 5
int switchPin = 13; // chave no 13
boolean running = false; //variável booleana
void setup(){
pinMode(LEDpin, OUTPUT); //conficura pino como saída
pinMode(switchPin, INPUT); //configura pino como entrada
digitalWrite(switchPin, HIGH); //Liga pullup dno pino
}
void loop(){
if (digitalRead(switchPin) == LOW){ //se pino em nível baixo
delay(100); // delay to debounce switch
running = !running; // toggle running variable
digitalWrite(LEDpin, running) // indicate via LED
}
}
72
1.3. char
O tipo char armazena valores de 1 byte. Caracteres são codificados em um único
byte e são especificados na tabela ASCII. O tipo char é sinalizado e representa
números de -128 a 127. Para números não sinalizados usa-se o tipo byte.
Exemplo:
char myChar = 'A';
char myChar = 65; // valor em decimalda letra A na tabela ASCII
1.4. unsigned char

unsigned char armazena valores de 1 byte não sinalizados, é mesmo que utiliza o
tipo byte. A faixa de valores vai de 0 a 255.
Para programação consistente no estilo Arduino o tipo byte é preferido para esse
tipo de dado.
Exemplo:
unsigned char myChar = 240;
1.5. byte
Armazena valores de 8 bits não sinalizados de 0 a 255.
Exemplo:
byte b = B10010; // B10010 = 18 decimal
1.6. int
Inteiros são tipos primários de armazenamento. No Arduino Uno( e em outras
placas baseadas em ATMEGA) um int armazena valores de 16 bits(2 bytes). Esse tipo
compreende valores de -32768 a 32767. Já no Arduino Due, um int armazena valores
de 32 bits( 4 bytes) que compreende valores de -2147483648 a 2,147483647.
Exemplo:
int x;
x = -32768; //atribui o valor mínimo a variável x
x = x - 1; // x agora contém o valor máximo: 32,767
x = 32767;
x = x + 1; // x agora contém o valor mínimo: -32,768
1.7. unsigned int

No Arduino UNO e em outras placas baseadas em ATMEGA armazenam valores
de 16 bits não sinalizados, ou seja, apenas valores positivos de 0 a 65535.
O Arduino DUE armazena valores de 32 bits não sinalizados, e compreende a

faixa de 0 a 4294967295.
73
Exemplo:
unsigned int ledPin = 13;
1.8. word
O tipo armazena valores de 16 bis não sinalizados que compreendem valores de 0
a 65535.
Exemplo:
word w = 10000;
1.9. long
O tipo de dado long armazena valores inteiros sinalizados de 32 bits (4 bytes) que
compreendem a faixa de -2147483648 a 2147483647.
Exemplo:
long speedOfLight = 186000L
1.10. unsigned long

O tipo unsigned long armazena valores de 32 bits(4 bytes) não sinalizados que
compreendem a faixa de 0 a 429967295.
Exemplo:
unsigned long time;
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print("Time: ");
time = millis();
Serial.println(time);
delay(1000);
}
1.11. short
O tipo short armazena valores de 16 bits (2 bytes) sinalizados.
Exemplo:
short ledPin = 13;
1.12. float
O tipo float armazena valor em ponto flutuante, ou seja, um valor que possui casas
decimais. O tipo float armazena valores de 32 bits(4 bytes) e compreendem a faixa de
-3,4028235 E+38 a 3,4028235 E+38.4.
A matemática em ponto flutuante requer muito processamento, por exemplo, se for

feita uma operação em ponto flutuante dentro de um loop, ocorrerá um atraso maior,
74
do que se fosse feita uma operação com inteiros. Deve-se ficar atento ao uso do tipo
float tanto na questão de espaço de memória quanto no processamento. As funções
de manipulação do tipo float requerem muito processamento.
Exemplo:
float myfloat;
float sensorCalbrate = 1.117;
1.13. double
O tipo double também armazena valores de ponto flutuante, porém no Arduino Uno
e outras placas baseadas em ATMEGA esse tipo é exatamente o mesmo que o tipo
float, sem ganho de precisão, já no Arduino Due o tipo double pussui 64 bits (8 bytes)
provendo maior precisão, seu valor máximo pode chegar a 1,7976931348623157 x
10308.
2. if e operadores de comparação
Essa estrutura, que é usada em conjunto com um operador de comparação, testa

alguma condição imposta pelo programador. Para testar se o valor de uma variável é
maior do que 100 por exemplo:
if (variavel > 100){
// faça algo aqui
}
O programa testa se variável é maior do que 100. Se for, o programa executa a

ação seguinte. Caso contrário, o programa ignora a ação dentro das chaves e segue a
rotina. Caso a ação tenha apenas uma linha, as chaves podem ser omitidas. Para
fazer as comparações, é necessária a utilização dos operadores da Tabela 1.
Tabela 2 - Operadores de comparação.
== Igual a (comparação)
!= Diferente de
< Menor que
> Maior que
<= Menor ou igual a
>= Maior ou igual a
3. if / else
A estrutura if/else fornece um controle maior sobre o código do que simplesmente

o if, permitindo múltiplos testes agrupados. Por exemplo, uma entrada analógica
poderia ser testada e uma ação executada caso o valor for menor do que 500. Caso
seja maior ou igual a 500, executaria a segunda ação.
if (analog < 500){
// ação A
}
else{
// ação B
}
75
Também é possível colocar uma condição logo após o else. Não há limites de
condições a serem colocadas.
if (analog < 500){
// ação A
}
else if (analog >= 1000){
// ação B
}
else{
// ação C
}
Outra forma de se fazer condições é com a estrutura do switch case.
4. for
É chamada de estrutura de laço, pois cada bloco de programa se repete uma

determinada quantidade de vezes. Um contador é normalmente usado para terminar e
dar ritmo ao loop. É útil para qualquer operação que se repita. Uma aplicação comum
é operações com vetores.
Sintaxe:
for (inicialização; condição; incremento){
// ação
}
A inicialização começa pela primeira e única vez. Cada vez que iniciará um novo
loop, a condição é testada. Se for verdadeira, a ação é executada e a variável de
passo incrementada. Quando a condição se tornar falsa, o loop termina.
Exemplo:
int PWMpin = 10;
void setup(){
void loop(){
for (int i=0; i<=255; i++){
analogWrite(PWMpin, i);
delay(10);
}
}
5. switch / case
Como a estrutura if, switch...case controla os programas permitindo aos

programadores especificar diferentes códigos que poderão ser executados em
diferentes condições. Em particular, a estrutura do switch compara o valor da variável
com o valor em cada caso específico. Quando o caso é encontrado, ou seja, o valor é
o da variável, a ação correspondente é executada. A palavra reservada break
interrompe o switch, e é tipicamente usado no final de cada case. Sem o break, a
76
estrutura do switch irá ser executada até encontrar uma interrupção, ou o final das
comparações.
Exemplo:
switch (var) {
case 1:
// faça algo quando 'var' é igual a 1
break;
case 2:
// faça algo quando 'var' é igual a 2
break;
default:
// se nenhuma condição acima for satisfeita
}
6. while
O laço do while acontece infinitamente até que a expressão dentro dos parênteses
se torne falsa. Algo deve ser modificado ao testar a variável para o término do loop,
caso contrário ele nunca terminará.
Sintaxe:
while (expressão){
// ação
}
Parâmetros:
expressão - A estrutura (booleana)de C que verifica se é verdadeiro ou falso.
Exemplo:
int var = 0;
while (var < 200){
// faça algo duzenttas vezes
var++;
}
7. do-while
Muito parecido com o while, o do-while possui a diferença que sua condição é
testada ao final do loop, assim executando a ação garantidamente uma vez.
Sintaxe:
do{
// ação
} while(expressão);
77
Exemplo:
do{
delay(50);
x = readSensores();
} while(x < 100);
8. break
Interrompe alguma condição de loop. Também é usado na estrutura de switch.
Exemplo:
for (x=0; x < 255; x++){
digitalWrite(PWMpin, x);
sens = analogRead(sensorPin);
if (sens > threshold){
x = 0;
break;
}
delay(50);
}
9. continue
Ignora o resto da iteração atual de um loop. continue continua marcando a

expressão condicional do loop, e prossegue com as iterações subsequentes.
Exemplo:
for (x = 0; x < 255; x++){
if (x > 40 && x < 120){
continue;
}
digitalWrite(PWMpin, x);
delay(50);
}
10. return
Termina a função e retorna um valor de uma função para a função de chamada.
Sintaxe:
return valor;
Parâmetros:
valor: qualquer variável ou constante, de qualquer tipo.
Exemplo:
78
int checkSensor(){
if(analogRead(A0) > 400){
return 1;
}
else{
return 0;
}
}
11. goto
Transfere o fluxo do programa para um ponto específico do mesmo programa.
Exemplo:
label:
goto label; //envia o fluxo do programa para o label
12. ; - ponto e vírgula
Usado ao terminar uma linha.
Exemplo
int a = 13;
13. {} - Chaves
As chaves são largamente usadas na programação em C. Possuem diversas

aplicações, descritas abaixo, que podem causar confusão em iniciantes. Toda chave
de abertura ({) deve ser fechada (}). Essa é a condição que se refere às chaves
estarem balanceadas. A IDE (Integrated Development Enviroment, em inglês) do
Arduino inclui um artifício que confere se as chaves estão devidamente balanceadas.
Para isso, deve-se apenas selecionar uma chave que a correspondente irá ser
destacada. Atualmente, esse artifício possui um pequeno bug onde ele também
destaca (incorretamente) as chaves que estão comentadas. Programadores iniciantes
e programadores que habituados com BASIC normalmente encontram dificuldades
com o uso de chaves. Não obstante, as chaves substituem a instrução RETURN em
uma sub-rotina (função), a estrutura ENDIF por uma condicional e a instrução Next por
um loop for. Por conta do uso das chaves ser bem variado, uma dica para praticar é
imediatamente após se abrir uma chave é fechá-la. Chaves desbalanceadas causam
muitos erros de compilação. Muitas vezes fica complicado encontrar o erro de sintaxe
em um código de muitas linhas. Por conta de seu largo uso, as chaves são muito
importantes para a sintaxe do programa. Movendo uma ou duas linhas de lugar, o
sentido do código pode-se alterar drasticamente.
Funções
void minhaFuncao(param){
// ações
79
}
Loops
while (expressao){
// ações
}
do{
// ações
} while(expressao);
for (incializa; condicao; expressao incremento){

// ações
}
14. // e /*- Comentários
Comentários são linhas de programa que são usadas para informar o próprio
programador ou outra pessoa que venha a usar o código como o programa funciona.
Essas linhas são ignoradas pelo compilador e nem são enviadas para o processador,
logo, não ocupam espaço no chip do Atmega. Comentários possuem o propósito de
ajudar o programador a entender (ou lembrar) como o programa funciona ou para
informar a outros. Existem duas formas diferentes de comentar:
int x = 5 // linha de comentario
/*
Bloco de comentários
*/
15. define
Permite ao programador nomear um valor de uma constante antes do programa

ser compilado. Constantes nomeadas por define não usam memória do chip. O
compilador irá fazer referências para essas constantes com o valor definido no
momento da compilação. Isso pode causar alguns efeitos indesejáveis como o nome
definido por define ser incluído em outra constante ou nome de variável. Nesse caso o
texto deverá ser trocado pelo número ou texto que se usou o define. Em geral, a
palavra reservada const é melhor para se definir constantes do que o define. A sintaxe
do Arduino é a mesma que em C:
Sintaxe:
#define nomedaconstante valor
16. include
É usado para incluir bibliotecas. Possibilita ao programador usar um largo grupo de

funções pré-denidas. Existem bibliotecas escritas especialmente para Arduino. A
página de referência de bibliotecas de C da AVR(AVR é a referência dos chips da
80
Atmel, os quais o Arduino é baseado).Note que o include é similar ao define, não há
ponto e vírgula para terminar a linha, causando assim um erro de sintaxe caso seja
colocado.
Exemplo:
Esse exemplo inclui a biblioteca que é usada para colocar informações no espaço
de memória flash ao invés da ram. Isso guarda espaço da ram para a mamória
dinâmica e faz a procura por tabelas mais prática.
#include <avr/pgmspace.h>
17. Operadores aritméticos

Tabela 3 - Operadores Aritiméticos
= Atribuição
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Resto da divisão inteira
18. Operadores de comparação

Tabela 4 - Operadores de comparação
== Igual a
!= Diferente de
< Menor que
> Maior que
<= Menor ou igual a
>= Maior ou igual
19. Operadores Booleanos
Tabela 5 - Operadores booleanos
&& E (and)
|| OU (or)
! Negação (not)
20. Operadores de ponteiro

Tabela 6 - Operadores de ponteiro
& Referencia
81
* Desreferencia
82
APENDICE B
Este apêndice tem por objetivo apresentar conceitos de eletrônica que poderão ser
utilizados neste curso.
1. Cabos (jumpers)
Os jumpers são utilizados para conectar componentes sem a necessidade de

solda. Geralmente utilizados em protótipos, em protoboards e são construídos de
material condutor envolto de um material isolante.
Figura 34 - JUMPER
2. Resitor
Figura 35 - RESISTOR
Os resistores oferecem uma oposição à passagem de corrente elétrica. Esta

oposição é chamada de resistência elétrica ou impedância, e possui a unidade de
medida ohm(Ω). Estes componentes causam uma queda de tensão, determinada por:
#∗$
Onde V é a tensão em volts(V), R a resistência em ohms(Ω), e I a corrente elétrica em

ampéres(A).
83
3. Potenciômetro
Figura 36 - POTENCIÔMETRO
Potenciômetros são resistores que possuem sua resistência elétrica variável.

Geralmente possuem três conectores, dois laterais e um central, onde a resistência
varia entre os pinos laterais e o central.
4. Led
Figura 37 - LED
Led (light emittingdiode) é um diodo emissor de luz. O diodo é um componente

semicondutor, ou seja, permite a circulação de corrente em um sentido com muito
mais facilidade do que no outro. Seu funcionamento baseia-se em um material
contendo cargas negativas extras, chamado de material tipo-N, que fica separado por
uma certa distância (chamada de zona vazia) de um outro material contendo cargas
positivas extras, chamado de material tipo-P. Ao conectar o catodo (tipo-P) ao polo
positivo, e o anodo (tipo-N) no pólo negativo, essas cargas irão se repelir, fazendo
com que haja circulação de corrente elétrica no circuito, e no caso do led, haverá
emissão de luz.
5. Transistor
Transistores são dispositivos semicondutores usados como amplificadores ou

chaves. Existem diversos tipos de transistores, mas focaremos nos transistores de
junção bipolar, BJT (Bipolar Junction Transistor), com polaridade PNP e NPN.
84
Figura 38 - TRANSISTOR
Os transistores possuem três terminais: base, coletor e emissor.
Seu funcionamento é baseado na corrente que circula entre os terminais base e

emissor.
$ $% & $'
$' ( ∗ $%
Onde β é uma constante que indica o máximo ganho do componente.
6. Chaves
Figura 39 - MICROCHAVE
São utilizados para fechar ou abrir um circuito, permitindo ou não a passagem de

corrente. Existem vários tipos de chaves, um tipo bastante utilizado é a pushbuttom
que ao ser pressionada permite a passagem de corrente elétrica, pode ser chamada
de NA (normalmente aberta), outro tipo de chave é que ao pressiona-la a passagem
de corrente é interrompida, pode também ser chamada de NF (normalmente fechada).
85
7. Protoboard
Figura 40 - PROTOBOARD
É uma placa utilizada para prototipação, ou seja, ensaio de montagem de circuitos

eletrônicos. Sua vantagem é a facilidade de inserção e remoção de componentes, uma
vez que não é necessário a soldagem destes.
8. LDR
Figura 41 - LDR
Sensor que varia a resistência elétrica devido a intensidade de luz detectada.
86
9. LM35
Figura 42 - LM35
É um sensor de temperatura semicondutor, que varia a passagem de corrente

elétrica de acordo com a temperatura detectada.
10. LCD
Figura 43 - LCD
São interfaces utilizadas para representar informações de forma visual. É possível

exibir informações do programa, como por exemplo, uma mensagem, a leitura de um
sensor. Existem vários modelos de display lcd, como 16x2 (16 linhas e 2 colunas) e
20x4, sendo que alguns possuem backlight, uma luz de fundo para melhorar a
visualização das informações contidas no display.
Um cuidado a ter é que a pinagem dos displays não é padrão, e pode variar de
fabricante para fabricante.
87
11. Buzzer
Figura 44 - BUZZER
É um dispositivo utilizado para a emissão de áudio, pode ser mecânico, eletrônico

ou piezoelétrico.
88
Referências
1. https://www.arduino.cc/en/Reference/Setup
2. https://www.arduino.cc/en/Reference/Loop
3. https://www.arduino.cc/en/Reference/PinMode
4. https://www.arduino.cc/en/Reference/DigitalWrite
5. https://www.arduino.cc/en/Reference/DigitalRead
6. https://www.arduino.cc/en/Reference/Delay
7. https://www.arduino.cc/en/Tutorial/PWM
8. https://www.arduino.cc/en/Reference/AnalogWrite
9. http://www.robotplatform.com/knowledge/ADC/ADC_samples_wave.jpg
10. https://www.arduino.cc/en/Reference/AnalogReference
11. https://www.arduino.cc/en/Reference/AnalogRead
12. https://www.arduino.cc/en/Serial/Begin
13. https://www.arduino.cc/en/Serial/Available
14. https://www.arduino.cc/en/Serial/Read
15. https://www.arduino.cc/en/Serial/Print
16. https://www.arduino.cc/en/Serial/Write
17. https://www.arduino.cc/en/Reference/Tone
18. https://www.arduino.cc/en/Reference/NoTone
19. https://www.arduino.cc/en/Reference/LiquidCrystal
20. https://www.arduino.cc/en/Reference/LiquidCrystalBegin
21. https://www.arduino.cc/en/Reference/LiquidCrystalPrint
22. https://www.arduino.cc/en/Reference/LiquidCrystalSetCursor
23. https://www.arduino.cc/en/Reference/LiquidCrystalCursor
24. https://www.arduino.cc/en/Reference/LiquidCrystalNoCursor
25. https://www.arduino.cc/en/Reference/LiquidCrystalBlink
26. https://www.arduino.cc/en/Reference/LiquidCrystalNoBlink
27. https://www.arduino.cc/en/Reference/LiquidCrystalRightToLeft
28. https://www.arduino.cc/en/Reference/LiquidCrystalLeftToRight
29. https://www.arduino.cc/en/Reference/LiquidCrystalHome
30. https://www.arduino.cc/en/Reference/LiquidCrystalDisplay
31. https://www.arduino.cc/en/Reference/LiquidCrystalNoDisplay
32. https://www.arduino.cc/en/Reference/Servo
33. https://www.arduino.cc/en/Reference/ServoAttach
34. https://www.arduino.cc/en/Reference/ServoDetach
35. https://www.arduino.cc/en/Reference/ServoAttached
36. https://www.arduino.cc/en/Reference/ServoWrite
37. https://www.arduino.cc/en/Reference/ServoRead
38. https://www.arduino.cc/en/Reference/StepperConstructor
39. https://www.arduino.cc/en/Reference/StepperSetSpeed
89
40. https://www.arduino.cc/en/Reference/StepperStep
41. https://github.com/SistemaEmbutido/Ultrassonico_lib
42. http://blog.filipeflop.com/wp-
content/uploads/2013/02/Circuito_Uno_Motor_de_passo_5v1.png
content/uploads/2015/07/Arduino_HC_SR04_bb.png
44. https://fbseletronica.wordpress.com/2013/05/19/curso-arduino-tipos-de-
dados/
45. http://www.embarcados.com.br/wp-content/uploads/2013/11/12-arduino-
uno-dimensoes.png
46. http://www.embarcados.com.br/wp-content/uploads/2013/11/13-arduino-
uno-RESUMO-660x371.jpg
47. https://www.arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-
schematic.pdf
48. https://www.arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-
schematic.pdf
content/uploads/2015/07/HC_SR04_Trigger_Echo.jpg
50. http://blog.filipeflop.com/wp-content/uploads/2015/07/Diagrama-tempo-
hc-sr04.png
51. https://upload.wikimedia.org/wikipedia/commons/thumb/f/f8/Stepper_mot
or_1.png/241px-Stepper_motor_1.png
52. https://pt.wikipedia.org/wiki/Ficheiro:Stepper_motor_2.png
90

Curso Arduino Rev02

Enviado por

Dados do documento

Descrição original:

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 Arduino Rev02

Enviado por

Direitos autorais:

Formatos disponíveis

Curso Arduino

Sugestões, críticas, ou outros, entre em contato com o autor.

Técnico em eletrônica, graduando de Engenharia Elétrica na Pontifica

Arduino é um kit de desenvolvimento voltado para iniciantes. É composto por

Hardware: O hardware do Arduino é uma pequena placa com entradas e saídas.

Software: O software é a chave do sucesso dessa plataforma. Compilada em

• Controle de entradas e saídas digitais (I/O)

Figura 3 - Schematic Arduino Uno R3

O outro meio de programar, seria utilizando um compilador específico do fabricante

O software é portável de um modelo de arduino para outro na maioria dos casos,

Estas são as funções básicas para o funcionamento de um código arduino.

// setup inicializa o pino do butão

// loop checa o botão a cada vez

1. O que são Portas Digitais?

2. Portas no modo de Saída

3. Portas no modo de Entrada

PINO: número do pino a ser utilizado

MODO: INPUT, OUTPUT, INPUT_PULLUP

PINO: número do pino a ser utilizado

VALOR: HIGH, LOW

PINO: pino que será feita a leitura digital

retorna HIGH ou LOW;

MS: tempo em milissegundos da pausa (unsigned long)

Nesta pratica iremos realizar a montagem do circuito para o acionamento de um

Protoboard, led, resistor, fios jumper, placa arduino, cabo usb.

De posse dos components acima, faça a montagem conforme a imagem abaixo:

Figura 4 - Montagem Pratica_01

Conecte o cabo USB na placa Arduino, e em seguida conecte na porta USB no

Agora selecione qual arduino você está utilizando, vá em ‘Ferramentas->Placa’ e

Após configurado corretamente, pressione o botão ‘Verify/Compile’ (CTRL+R) no

Nesta pratica iremos criar aquele famoso pisca-pisca de um led só.

Protoboard, led, resistor, fios jumper, placa arduino, cabo usb.

De posse dos componentes acima, faça a montagem conforme a imagem abaixo:

Figura 5 - Montagem Pratica_02

//INTERVALOS PARA QUE O LED FIQUE ACESO E APAGADO

Com isto o led deverá piscar a cada 500 milisegundos.

Vamos agora construir um semáforo, utilizando os conceitos mostrados

Figura 6- Montagem Pratica_03

//INTERVALOS PARA QUE O LED FIQUE ACESO E APAGADO

digitalWrite(RED,LOW); //COLOCA O PINO LED EM NIVEL ALTO

digitalWrite(RED,LOW); //COLOCA O PINO LED EM NIVEL ALTO

Nesta prática iremos realizar a leitura do estado lógico de uma microchave e

Figura 7 - Montagem Prática_04

// the setup routine runs once when you press reset:

// the loop routine runs over and over again forever:

Pulse WidthMudulation, é uma técnica utilizada por sistemas digitais para a

A tensão média de saída poderá ser calculada da seguinte forma:

• Vout - tensão de saída em V;

O PWM pode ser utilizado para aplicações como:

• controle de velocidade de motores;

3. Quais pinos são PWM

Figura 9 - Pinos PWM

PINO: número do pino utilizado

VALOR: valor do dutycicle de 0 a 255

Protoboard, led, resistor, fios jumper, placa arduino, cabo usb.

Figura 10 - Montagem Prática_05

Vamos agora realizar o ajuste a intensidade do brilho de um led utilizando o PWM,

Figura 11 - Montagem Pratica_06

Conversor analógico-digital, consiste em um driver contido na placa arduino que

Na placa arduino Uno, por exemplo, que utiliza um microcontrolador da Atmel,

Vref – tensão de referência para a conversão AD

n – número de bits do conversor