0% acharam este documento útil (0 voto)

21 visualizações103 páginas

Arduino 1 PDF

O documento é um curso básico sobre Arduino, abrangendo desde a introdução ao hardware e software até a instalação e configuração do IDE. Ele explora a linguagem de programação do Arduino, componentes eletrônicos, e apresenta diversos projetos práticos envolvendo luz, temperatura e movimento. Além disso, discute aplicações do Arduino em áreas como automação residencial e robótica.

Enviado por

franckrj

Direitos autorais

Levamos muito a sério os direitos de conteúdo. Se você suspeita que este conteúdo é seu, reivindique-o aqui.

Formatos disponíveis

Baixe no formato PDF, TXT ou leia on-line no Scribd

0% acharam este documento útil (0 voto)

21 visualizações103 páginas

Arduino 1 PDF

Enviado por

franckrj

Direitos autorais

Levamos muito a sério os direitos de conteúdo. Se você suspeita que este conteúdo é seu, reivindique-o aqui.

Formatos disponíveis

Baixe no formato PDF, TXT ou leia on-line no Scribd

Curso Bá´sico de Arduino

Sumá´rio

1 Introduç¸ãõ...................................................11
1.1 OqueéÁrduino? 11
1.1. Ohardware.................................................... 1
1 Osoftware..................................................... 1
1.1. Aideia........................................................ 1
2
1.2 ComooArduinofunciona? 13 Aplicaç¸õ˜es 14 Linkparaconsulta 14 2
1.1. 1
1.3
3 Instalaç¸ãõeconfiguraç¸ãõ....................................15 2
1.4
Downloadeinstalaç¸ãõnoWindows 15
2 Configuraç¸ãõ 16
Instalaç¸ãõnoLinuxMint 19
2.1
2.2 PrimeiroSketch...............................................21
2.3 Sobreocó´digo 22
Arduino:hardwareesoftware.................................25
3 AplacadoArduinoUnoR3 25
3.1 AIDEdoArduino 26
4
ALinguagemdoArduino ..................................... 29
4.1 Funcionamentodeumalinguagemdeprogramaç¸ãõ 29
4.2 AlinguagemArduino 30

5
5.1
5.2
5.3 Estr 30
5.4 utura 31
5.4. Variá´veisnumé´ricas..............................................
Variá Variá´veisnãõ-numé 3
1 ´ricas.......................................... Declaraç¸ãõdevariá 1
´veis
5.4. ´veis.......................................... 3
2
5.5 Entrada e saı́´da de dados 2
32
5.4. 3
5.6 Operaç¸õ˜es 34
3 2
5.7 Estrutura de condiç¸ ãõ 36
5.8 Estrutura de repetiç¸ ã˜ o 38
5.8. Comandofor()................................................ 38
1 Comandowhile().............................................. 40
5.8. Funç¸õ˜es 40
2
Criaç¸ãõechamadadefunç¸õ˜es................................... 41
5.9 Funç¸õ˜espredefinidasdoArduino................................... 43
5.9.
5.10 Bibliotecas 45
1
5.11
5.9. Vetoresematrizes 46
5.11.1Vetores........................................................
2 4
5.11.2Matrizes....................................................... 6
4
6 Componenteseletrôˆnicos.....................................51 8
6.1 Amatrizdelinhas 51
6.2 Jumpers 53
6.3 Resistores 53
6.4 Fontes 54
6.5 Corrente,tensãõ,resistêˆnciaeleidasmalhas 54
6.5. Associaç¸ãõderesistores.......................................... 55
1 Leidasmalhas.................................................. 56
6.5. Mais componentes eletrôˆnicos 57
2
Capacitores.................................................... 57
6.6 Diodos........................................................ 60
6.6. LEDs.......................................................... 60
1 Fototransistores................................................. 60
6.6. LDRs.......................................................... 61
2 Relé´s......................................................... 61
6.6. Potenciôˆmetros................................................. 63
3 PZTs........................................................... 66
6.6.
7
4 ProjetosenvolvendoLuz......................................67
6.6.
7.1
5 SincronizandoLEDs 67
6.6.
7.2 SensordeluminosidadecomumLDR 69
6
7.3 Sensordeluminosidadecomumfototransistor 71
6.6. ControlandoaluminosidadedeumLED 73
7.4
7
6.6.
8
5

8 ProjetosenvolvendoTemperatura ............................. 75
8.1 MedindotemperaturacomoSensorLM35 75
8.2 MedindotemperaturacomoSensorDS18B20 77
8.3 Medindoumidade 80

9 Maisopç¸õ˜esdesaı́´dadedados..............................83
OmonitorLCD 83
9.1
OleitordecartãõSD 86
9.2
9.2. Gravandodadosnocartãõ....................................... 8
1 Lendodadosdocartãõ.......................................... 7
9.2.
9.3 Oshieldwifi 89 Oshieldbluetooth 89 8
2 8
9.4
ProjetosenvolvendoMovimento...............................91
10 Medindodistâˆnciaentreobjetos 91
GerandosonscomoPZT 93
10.1
Movimentocomomotordepasso 95
10.2
10.3 Outrasplacas................................................99
RaspberryPi 99
11
11.1
11.1.1OHardware....................................................99
11.1.2Osoftware....................................................100
11.1.3AcendendoeapagandoumLED.................................101
11.2ESP8266eESP32 104
11.2.1Instalaç¸ãõ-ESP8266............................................105
11.2.2FazendoumLEDpiscar..........................................105
Prefácio da primeira edição
1. Introduç¸ ã˜ o

1.1 OqueéÁrduino?
Quando falamos em “Arduino”, podemos estar nos referindo ao hardware Arduino (isto
é´, seus vá´rios modelos de placas), ao software Arduino (isto é´, o ambiente onde
desenvolvemos o có´digo fonteetambé
´malinguagemArduino)ou,aindaàìdeiaArduino(istoé´,adeserumaplataformade
prototipagemeletrôˆnicadebaixocustoedefá
ćiluso).Adefiniç¸ãõmaisgeraldeArduinoengloba esses trêˆs aspectos.
1.1.1 Ohardware
Hojeháúmavariedadeenormedemodelosdeplacas,sendooArduinoUnoR3omodelomais
famoso (Fig. 1.1). É´ por essa placa que quase todos entram no mundo Arduino. Há´
placas maiores, com maior poder de processamento, maior capacidade de armazenar
dados e mais pinos de entrada esaı́´dadedados,comooArduinoMega2560e,ainda,há
áquelasplacasminú´sculas,criadaspara atuarem em projetos pequenos, onde espaç¸o
ou peso sãõ fundamentais, como o Arduino Nano. Há´ també´mplacasparapropó
´sitosespecı́´ficos,comoIoT(InternetdasCoisas)eeletrôˆnicawireless (sem fio), como as
placas Arduino Yúń e a Lilypad Arduino Simple, respetivamente (ver Fig. 1.2).
NaSeç¸ãõ4.1entraremosemdetalhesnohardwaredoArduinoUnoR3.

Figura 1.1: As placas Arduino Uno R3, Arduino Mega 2560 e Arduino Nano.
1.1 O que é´ Arduino? 12

Figura 1.2: As placas Arduino Yú´n e Lilypad Arduino Simple.

1.1.2 Osoftware
É´ atravé´s de um IDE (ambiente de desenvolvimento integrado, Fig. 1.3) que programamos as
placas de Arduino: as variá´veis sãõ declaradas, as instruç¸õ˜es sãõ inseridas dentro das funç¸õ˜es
setup() e loop(), a eletrôˆnica é´ implementada, o hardware é´ conectado e, bingo, seu sensor de
luminosidadecomeç¸aafuncionar.Aprogramaç¸ãõé´,paraamaiorpartedaspessoas,apartemais
difı́ćil para os iniciantes em Arduino. A programaç¸ãõ é´ um conjunto de instruç¸õ˜es para fazer algo,
como calcular o nú´mero π com 20 casas decimais, resolver um sistema de equaç¸õ˜es, permitir o
acessodeumclienteaumservidorremotooumonitoraraquantidadedevagasdisponı́´veisemum
estacionamento de um shopping, por exemplo. No Arduino, esse conjunto de instruç¸õ˜es se chama
“sketch”. Em outros contextos, sãõ simplesmente chamados de có´digo-fonte, ou ainda programa.
Uma breve introduç¸ãõ sobre a linguagem do Arduino pode ser encontrada no Capı́´tulo 5.2;
sobre a IDE, veja a Seç¸ãõ 4.2.

(a) (b)

Figura 1.3: (a) Iniciando a IDE do Arduino no Windows (b) Sketch aberta com o có´digo
10. “AnalogWriteMega”, exemplo contido no IDE.

1.1.3 Aideia
O Arduino foi concebido para ser duas coisas: barato e fáćil, em pé´ de igualdade em
relaç¸ãõ de importâˆncia. Ambos os aspectos levaram a uma rá´pida disseminaç¸ãõ
apó´s 2005, quando a primeira placa foi produzida na Itá´lia [arduino-cc]. Atualmente a
placa mais famosa, a Arduino Uno R3,
1.2 Como o Arduino funciona? 13

pode ser adquirida no Mercado Livre por 40 reais, e um kit bá´sico, contendo, alé´m da
placa, leds, resistores, uma protoboard, jumpers, um relé´, um servo-motor e um
potenciôˆmetro, gira em torno de 120 reais. Há´ inclusive diversas outras placas que
nãõ sãõ Arduino na forma mais abrangente da palavra,poré
´mincorporamosaspectosdasimplicidadee,principalmente,dobaixocusto.Dentre algumas,
podemos citar os microcontroladores ESP32 e ESP8266 (Seç¸ãõ 11.2) e o Raspberry
Pi 3 B+(Seç¸ãõ11.1,Fig.1.4),esteú
´ltimoumcomputadorcompletoquenãõapenaspossuiprocessador quad-core com clock
em 1,4 GHz, 1 Gb de RAM, wifi, bluetooth, como també´m é´ capaz de rodar diversos
sistemas operacionais, como o Raspbian (desenhado para as particularidades dessa
placa), o Linux Ubuntu e o Windows 10 IoT Core (versãõ desse Windows para
sistemas embarcados), por exemplo.

(a) (b)

Figura 1.4: (a) Microcontrolador Esp32. (b) Raspberry Pi 3, modelo B+, lanç¸ado em 2018.

A primeira placa de Arduino foi desenhada para ajudar estudantes de Design que, em geral,
nã˜o possuem conhecimentos bá´sicos de eletrôˆnica e programaç¸ã˜o, para criarem os mais diversos
protó´tipos.Esseconceitofoiextrapoladoparaforadoambienteeducacional;hojeemdia,é´bastante
comumencontraroArduinoemlaborató´riosdepesquisaenaindú´striacomo,porexemplo,para
controlarafrequêˆnciadelasersdediodoemarmadilhasdeá´tomosfrioseemimpressoras3D.

1.2 ComooArduinofunciona?
As placas de Arduino possuem microcontroladores capazes de processar
informaç¸õ˜es. Assim, é´ interessante lembrar que todo o processamento é´ realizado
no microcontrolador da placa, por mais queocó
´digofontesejadigitadonaIDErodandoemumnotebookcomWindowsconectadoviaUSB
com a placa, por exemplo. Entãõ a velocidade do processamento estará´ limitada à`
memó´ria RAM, à` memó´ria flash e ao processador de cada tipo de placa. Uma vez
que o có´digo foi carregado para a placa,láélepermanece,à`princı́
´pio,indefinidamente.Apartirdessemomentoumcomputadorjá´ nãõ é´ mais necessá´rio,
a menos que seja necessá´rio carregar outro có´digo na placa, que é´ escrito sobre o
anterior, ou que vocêˆ nãõ tenha uma fonte de energia pró´pria, que deve fornecer
tensãõ entre 7 e 12 V. Um pouco mais de detalhe sobre esse processo por ser
encontrado na Seç¸ãõ 5.2.
Acriaç¸ãõdeumprojetoArduinoenvolve,deformasimplificada,osseguintespassos:
1. Conexãõ do computador com a placa Arduino via porta USB.
2. Criaç¸ãõ do có´digo fonte. Corresponde à` digitaç¸ãõ das instruç¸õ˜es na IDE do
Arduino.

3.Conexã˜odoscomponenteseletrôˆnicosà`sportasdeentradaesaı́´dadedadosdaplaca.
1.3Aplicaç¸õ˜es 14

4. Veriﬁcaç¸ã˜o de erros e carregamento do có´digo na placa.

Um exemplo de criaç¸ã˜o de um projeto simples pode ser encontrado na Seç¸ã˜o 3.

1.3Aplicaç¸õ˜es
Comoaaplicaç¸ãõdoArduinoé
´vasta,estaseç¸ãõnãõcheganempertodeesgotartodasaspossibili- dades. Listamos
abaixo algumas:
I Impressãõ 3D.
I Automaç¸ãõ residencial.

I Robó´tica.
I Controle de experimentos em laborató´rios de pesquisa.

I Entretenimento.

1.4 Link para consulta

w w w . a r d u i n o . c. É´
Site oficial do projeto Arduino: c uma das fonte de consulta mais completa.
2.Instalaç¸ãõeconfiguraç¸ãõ

Aqui mostraremos a instalaç¸ãõ, a configuraç¸ãõ e as principais funcionalidades do

IDE do Arduino, primeiramente com base no ambiente do Microsoft Windows 10. Na
Seç¸ã˜o 2.3 apresentamos a instalaç¸ã˜onoLinuxMint19.1,Cinnamon.

2.1 Downloadeinstalaç¸ãõnoWindows
O ambiente onde programamos o Arduino (IDE - Integrated Development Environment ou Ambiente
de Desenvolvimento Integrado) é´ um software livre que pode ser baixado h tno
t psite
s://www.
arduino.cc/en/Main/Software. Atualmente ele está´ na versãõ 1.8.3. Para instalá´-lo
no seu computador, basta clicar no executá´vel baixado (arduino-1.8.3-windows.exe) e
proceder como na instalaç¸ãõ de qualquer outro software.

Figura 2.1: Instalaç¸ã˜o da IDE do Arduino.

Em seguida, será´ perguntado se vocêˆ deseja instalar as portas COM e LPT, e o Driver do Arduino.
Clique em Instalar nas trêˆs vezes. Apó´s isso, a instalaç¸ãõ estará´ completa.
2.2 Configuraç¸ãõ 16

COM e LPT.
Figura 2.2: Instalaç¸ã˜o das portas

2.2 Configuraç¸ãõ
Agora vem a configuraç¸ãõ, que é´ uma etapa importante. Primeiramente, clique no ı́
ćone do Arduino que foi criado na á´rea de trabalho. Se o Firewall do Windows
bloquear algum recurso, será
´mostradoumalertadeseguranç¸a.Nessecaso,cliqueemPermitiracesso.Finalmente,
apareceráúmajanelacomaIDEdoArduino.Muitoprovavelmenteosoftwareestaráńoidioma
doseuWindows.Observequeosketchjá´vemcomumesqueletodeumcó
´digoasercriado,com asfunç¸õ˜essetup()eloop()ealgunscomentá
´rioseminglêˆs.Falaremossobreasfunç¸õ˜esna linguagem do Arduino na Seç¸ãõ. 5.9.

Figura 2.3: IDE do Arduino.

AgoravocêˆdeveescolheraplacadoArduinoquevocêˆvaitrabalhar.Paraisso,cliqueem
F e r rPal m
a cean: t‘ a
‘−As→r d u i n o / G e n u i n o U n o ’ ’ e f a ç ¸ a a e s c o l h a a p r o p r i a d a .
2.2 Conﬁguraç¸ã˜o 17

Figura 2.4: Escolhendo a placa a ser usada. Nesse caso, temos apenas a COM4 disponı́´vel.

Apró´ximaescolhadizrespeitoà`portaUSBdocomputador.Paraisso,plugueocaboUSBda
sua placa em uma porta USB do computador. Em seguida, clique em Ferramentas
−→Porta
e selecione uma das portas disponı́´veis.

Figura 2.5: Escolhendo a porta a ser usada.

2.2 Conﬁguraç¸ã˜o 18

Por ﬁm, vamos testar a comunicaç¸ã˜o entre o Arduino e o computador usando um có´digo já´
pronto.CliqueemArquivo − → Exemplos− → 01.Basics Blink.−→

Figura 2.6: Abrindo o có´digo Blink.

Em seguida clique em Carregar. Se tudo der certo, será´ possı́´vel ver uma pequena luz
amarela acendendo e apagando na placa do Arduino.

Figura 2.7: Do lado esquerdo, temos o có´digo sendo carregado. O processo costuma
ser mais rá
´pidoemcomputadorescomSSDemaislentosnaquelesqueaindausamHDs.Doladodireito
vemos o có´digo carregado com sucesso.
2.3Instalaç¸ã˜onoLinuxMint 19

2.3 Instalaç¸ãõnoLinuxMint
É´possı́´velinstalaratravé´sdocomandosudo-apt-get-installnoterminal,masaversãõ
dorepositó´rioestá
´muitodesatualizada(versãõ1.0.5).Assim,recomendamosbaixarosoftware
noendereç¸ohttps://www.arduino.cc/en/Main/Softwareefazerainstalaç
¸ãõpelos
passos abaixo:
I Apó´s baixar, descompacte o arquivo. Observe, pela Fig. 2.8, que estamos usando a

versã˜o
1.8.8 do Arduino.

Figura 2.8: Arquivo baixado e pasta descompactada.

I Em seguida, acesse a pasta criada (em geral, /Downloads/arduino-1.8.8), abra o

terminal e digite ./install.sh.

I SeuIDEjáéstaráínstalado,eumı́ćonedoprogramaestaráńaá

´readetrabalho.Conecteo
cabo USB da placa
Ferramentas, na no computador, abra o IDE do Arduino e no menu
I
opç¸ãõPlaca:,escolhaaversãõcorrespondenteà`suaplaca.
I
Ainda no menu Ferramentas, na opç¸ãõ Porta, escolha uma das portas disponı́
´veis. Agora vamos testar um có´digo exemplo. Clique no menu Arquivo
I
→ Exemplos →
01.Basics
I → Blink. can´t open device"/dev/ttyAM0":
comando
Por fim, clique no botãõ Carregar. Será´ possı́´vel sudo luz na placa
ver uma pequena

acender e
apagar em intervalos de um segundo.
Pode acontecer de haver um erro de permissã˜o negada:
permission denied. Nesse caso, com o terminal aberto, digite o
chmod a+rw/dev/ttyACM0e,emseguida,tentecarregarocó´digonovamente.
2.3Instalaç¸ã˜onoLinuxMint 20

Figura 2.9: Instalaç¸ã˜o da IDE do Arduino.

Figura 2.10: IDE aberto.

3. PrimeiroSketch

Nosso primeiro Skecht será´ extremamente simples: vamos fazer um LED acender e
apagar e um intervalo de 1 segundo. Para isso, execute o procedimento abaixo:
I Abra a IDE do Arduino.
I Digite o có´digo abaixo no Sketch, exatamente como está´ escrito. Nos primeiros
contatos
com o Arduino, é´ importante manter a prá´tica de digitar ao invé´s de copiar a colar o
có´digo,
para que seja adquirida a familiaridade com as funç¸õ˜es mais importantes. Observe
1 //Primeiro có´digo! que a
2 numeraç¸ãõàèsquerdaserveparaidentificaralinhadocó´digo,enãõdeveserdigitada.
3 void setup() {
4 pinMode(13, OUTPUT);
5 }
6
7 void loop() {
8 digitalWrite(13, HIGH);
9 delay(1000);
10 digitalWrite(13, LOW);
11 delay(1000);
12 }
13
14 /*
15 Fim do Có´digo
16 */

I Plugue os terminais do LED nas portas 13 e GND do Arduino. Observe que os

LEDs possuem duas pernas com tamanhos diferentes. A perna maior geralmente
é´ o positivo, enquanto que amenoré
´onegativo.Assim,conecteapernamaiornaporta13(quefornece5V,deforma
3.1 Sobre o có´digo 22

que podemos entender como o terminal perna menor na portaGND(que é´ o

positivo) e a terra, subtendida como o terminal
negativo).

Figura 3.1: LED branco de alto brilho.

I Plugue o Arduino na entrada USB do computador e clique no botã˜o carregar da IDE do

Arduino.
Casonãõhajanenhumerrodedigitaç¸ãõ,ocó´digoseráćarregadoparaamemó´riadoArduinoe,
logoapó´s,oLEDacenderáéapagaráémintervalosde1segundo.

Figura 3.2: Arduino carregado com o có´digo acima.

3.1 Sobre o có´digo

Agora vamos tentar entender um pouco sobre o có´digo listado na pá´gina anterior. O
Arduino trabalha com uma linguagem de programaç¸ãõ que pode ser considerada um
dialeto da linguagem C, istoé´,suasintaxeobedeceexatamenteestaú´ltimalinguagem,poré
´mpossuindofuncionalidades adicionais, o que inclui novas funç¸õ˜es e novas
bibliotecas. Alé´m disso, algumas funç¸õ˜es da linguagem C podem nãõ funcionar na
linguagem do Arduino, que poderá´ possuir uma versãõ alternativa para a mesma
funç¸ãõ. Um exemplo é´ a funç¸ãõ printf() da linguagem C, que na linguagem do
Arduino vai aparecer como Serial.print(). Tirando essas particularidades, as
duaslinguagenssãõessencialmenteidêˆnticas,oquesignificaqueaformadedeclararvariá
´veis, bibliotecas,funç¸õ˜esééxatamenteamesma.Quemjá
´possuinoç¸õ˜esdeprogramaç¸ãõemClevará´ pouquı́
´ssimotempoparaseacostumarà`linguagemdoArduino.
Agora vamos analisar cada linha de comando do có´digo.
I Linha 1. Aqui temos um comentá´rio, uma funcionalidade que aparece na maioria das
linguagensdeprogramaç¸ãõ.Afunç¸ãõdocomentá´rioé´deixarocó´digoclarotantopara
outras pessoas como para o pró´prio desenvolvedor. É´ bastante comum um
programador nãõ
se lembrar o que um determinado bloco de instruç¸õ˜es faz apó´s alguns
mesmo meses,
entre
os experientes. Nesse sentido, o comentá´rio serve como um lembrete. Outro uso é´
como
umcabeç¸alho,paraindicaroautoreadatadedesenvolvimentodocó´digo.Observequea
IDE do Arduino ignora todas as linhas comentadas no có´digo. Para comentar uma
linha,
adicionamos duas barras no começ¸o da linha. També´m é´ possı́´vel comentar vá´rias
linhas
3.1 Sobre o có´digo 23

I Linha 3. Aqui temos a funç¸ã˜o setup(). O comando void na frente da funç¸ã˜o

significa
queessafunç¸ãõnãõretornavalores(nalinguagemPascal,porexemplo,osetup()seria
na verdade um “procedimento”, que é´ semelhante a uma funç¸ãõ, mas que nãõ
retorna valores). Por hora, podemos dizer que a funç¸ãõ setup() executa um
conjunto de instruç¸õ˜es (tudo o que está´ entre as chaves - linha 4) uma úńica
vez. Mais sobre funç¸õ˜es pode ser lido na Seç¸ãõ 5.9.
I
Linha 4. A funç¸ãõ pinMode() habilita uma porta do Arduino para entrada ou saı́

I ´da de
dados. Nesse caso, estamos habilitando a porta 13 para saı́´da de tensã˜o.
I Linha 7. A funç¸ã˜o loop() també´m é´ do tipo void. A diferenç¸a é´ que ela executa

as
instruç¸õ˜es dentro das chaves (linhas 8 - 11) infinitas vezes.
Linha 8. A funç¸ãõ digitalWrite() gera uma tensãõ em uma porta especı́´fica do
I
Arduino.
Essatensãõpodeserapenas5V(HIGH)ou0(LOW).Paratensõ˜esentre0e5V,é
ńecessá´rio
um shield especı́´fico. Observe que primeiro precisamos habilitar a porta com o
comando
pinMode.
diferenç¸aNesse projeto, o objetivo da funç¸ãõ digitalWrite() é´ gerar uma
de potencial de 5 V entre os terminais do LED, de forma a acendêˆ-lo.

Linha 9. A funç¸ã˜o delay(n) forç¸a uma pausa de n milissegundos na execuç¸ã˜o

das linhas
de comando.
segundo) Aqui, fizemos uso dela para que, apó´s 1000 milissegundos (1
aceso,
o LED apague com a instruç¸ãõ da linha 10: digitalWrite(13, LOW);. Sem o uso
dafunç¸ãõdelay()naslinhas9e11,oLEDiriaacendereapagaremumafrequêˆnciatãõ
alta (em uma frequêˆncia pró´xima do clock da placa) que seria impossı́´vel ver a
luz piscar.
4. Arduino: hardware e software

Nestecapı́´tulovamosfalarsobreasprincipaiscaracterı́
´sticasdaplacadoArduinobemcomodo seu IDE (ambiente de desenvolvimento
integrado).
4.1 AplacadoArduinoUnoR3
Nessaseç¸ã˜ofalaremossobreaplacadoArduinoUnoR3,umadasmaispopulares,sendocons
ide- rada uma placa de entrada no mundo do Arduino. As principais partes dessa placa
sã˜o:

Figura 4.1: Placa do Arduino UNO.

I Microcontrolador ATmega328. É´ o cé´rebro da placa, onde todo o processamento de dados

é´ feito. Ele é´ basicamente uma CPU com clock de 20 MHz, 8 bits e 32 kB de memó´ria flash.
Alé´mdisso,éńessecontroladorqueosprogramassãõarmazenados.
I PortaUSB.É´porondeacomunicaç¸ãõcomocomputadoré´feita,equetambé´mservecomo
fonte de alimentaç¸ãõ da placa.
4.2 A IDE do Arduino 26

I Fonte de alimentaç¸ã˜o. Usada quando desejamos operar a placa sem um

computador. Natu- ralmente, um computador é´ necessá´rio em um primeiro
momento para colocar o programa dentro da placa.

I Pinos. Essa placa possui uma sé´rie de pinos, que podem servir tanto para

entrada e saı́´da
de dados
como A0, como
A1, també´m como uma fonte de tensãõ fixa. Os pinos numerados
A2, A3, A4 e A5 sãõ de entrada analó´gica. Os pinos denotados por GND sãõ o
terra e os
pinos de 1 a 13 sãõ para saı́´da da tensãõ. Desses, alguns possuem també´m o
sı́´mbolo
4.2 AIDEdoArduino ∼, que
representamumasaı́
Aqui vamos fazer uma rá´pida passagem sobre as funcionalidades do ambiente de
desenvolvimento integrado do Arduino, ou apenas o software do Arduino.
´dadotipoPWM(modulaç¸ãõporlarguradepulso),queseriaumaforma
Na figura abaixo mostramos todos os botõ˜es da IDE.
de simular uma saı́´da analó´gica.

Figura4.2:Botõ˜esdaIDEdoArduino.

I BotãõVerificar.Compilaosketch,verificandooserrosdesintaxedoseucó´digo.Na
compilaç¸ãõ,aIDEdoArduinotraduzocó´digoescritoemlinguagemCparaalinguagemde
má´quina(sequêˆnciadebits-có´digobiná´rio),preparandoparaoarmazenamentonaplacado
Arduino.
4.2 A IDE do Arduino 27

Figura4.3:Có´digosapó´sumcliquenobotãõVerificar.Naesquerdavemosumacompilaç¸ãõ
finalizada com sucesso, enquanto que na direita o IDE retornou uma mensagem de
erro, que foi causadapelaausêˆnciadeumachavefechandoafunç¸ãõloop().

I Botã˜o Carregar. Compila e, em caso de ausêˆncia de erros de sintaxe, armazena o

có´digo
na placa do Arduino. Em resumo, esse botãõ executa os mesmos procedimentos do
botãõ
Verificar e ainda armazena o có´digo biná´rio no Arduino, o que faz com que a placa
“rode” o seu có´digo logo em seguida.
I Botãõ Novo. Cria uma nova sketch.
I Botãõ Abrir. Abre uma sketch salva previamente.
I Botãõ Salvar. Salva a sketch.
I Botãõ Monitor serial. Abre o monitor serial. O Monitor serial é´ usado, por exemplo,
para ler o valor armazenado em uma dada variá´vel. Ele é´ um recurso extremamente
importante
para testar o có´digo e procurar por erros de ló´gica. Observe que o Monitor serial só´
pode ser
aberto quando a placa do Arduino está´ conectada no computador.

Figura 4.4: IDE com o Monitor serial aberto.

5. A Linguagem do Arduino

Nessecapı́´tuloabordaremososprincipaistó
´picosdeumalinguagemdeprogramaç¸ãõ,como declaraç¸ãõetiposdevariá
´veis,estruturadecondiç¸ãõ,estruturaderepetiç¸ãõ,funç¸õ˜esebibliotecas, com êˆnfase
na linguagem do Arduino.
5.1 Funcionamento de uma linguagem de programaç¸ ãõ
Uma linguagem de programaç¸ãõ é´ uma linguagem formal (no sentido amplo do
termo, contexto queincluimatemá´tica,ciêˆnciadacomputaç¸ãõelinguı́
´stica)ondeumadeterminadatarefapodeser executada mediante o uso de um conjunto de
instruç¸õ˜es, que nessa apostila as vezes chamaremos de comandos. Por exemplo, se
um cientista precisa saber a quantidade de elementos nulos de uma matriz muito
grande, como uma 1000
× 1000, o que é´ uma tarefa á´rdua para ser feita sem o uso de
um computador, ele poderá´ proceder da seguinte forma.

I Criaç¸ã˜o de um algoritmo. A primeira tarefa do cientista é´ pensar como um

computador
poderia contar a quantidade de zeros da matriz. Ele poderia decidir criar uma variá´vel
que iria
percorrer, linha por linha, todos os elemento da matriz. Cada vez que a variá´vel
encontrasse
um zero, por comparaç¸ãõ por exemplo, ele poderia incrementar uma outra variá´vel
em uma
unidade, criada especificamente para este fim. Essa etapa é´ a criaç¸ãõ da “receita de
bolo”, que
é´ o algoritmo. Um exemplo de algoritmo famoso é´ o “mé´todo dos trapé´zios”, que
consiste
emrealizaraintegraç¸ãõnumé´ricadeumafunç¸ãõdividindoointervaloemvá´riostrapé´zios,
calculando a á´rea de cada um deles e realizando a soma total.
ICriaç¸ãõdocó´digo.Aqui,ocientistaprecisaimplementaroalgoritmoemalgumalinguagem
deprogramaç¸ãõ.Entãõ,eledeveráćriarumavariá´velparaleramatriz(entradadedados),
seja diretamente do teclado ou de um arquivo externo, depois outra para contar a
quantidade
de zeros (processamento de dados) e, por fim, uma ú´ltima para informar a quantidade
de zeros
5.2 A linguagem Arduino 30

A escolha da linguagem geralmente é´ feita com base em uma das trêˆs dimensõ˜es:
conhecimento
do programador, dificuldade de implementaç¸ãõ e velocidade de processamento. Se o
problema é´ simples de ser implementado em uma dada linguagem que o programador
conhece bem, ele naturalmente a escolherá´, desde que o có´digo seja executado
rapidamente (por exemplo, em um minuto ou menos). Se o problema demanda muito
tempo para ser executado, o programador deverá
´pesarsevaleapenaumaimplementaç¸ãõdifı́ćilemumalinguagemveloz.Porexemplo,
sistemasalgé
´bricoscomputacionais,comooMapleeoMathematicapossuemumalinguagemde
programaç¸ãõdefá
ćilimplementaç¸ãõ,porquepossuemmuitospacotesprontosvoltadosà`soluç¸ãõ deinú
´merosproblemasdamatemá´tica,dafı́´sicaedaengenharia.NoMapleé´possı́´velresolver
equaç¸õ˜esdiferenciaisnumericamentecomumú
ńicocomando(dsolve).Emcompensaç¸ãõ,elas
sãõextremamentelentasquandocomparadascomlinguagenscomoCeFortran,cujaimplem
entaç¸ãõ é´ um pouco mais difı́ćil e demorada. Por fim, temos como exemplo a
linguagem CUDA-C, de implementaç¸ãõmuitomaisdifı́
ćilqueasduasanteriores,queaindarequerumhardwareespecı́´fico (uma placa de vı́´deo
da Nvidia), mas que é´ extremamente veloz por realizar cá´lculos em paralelo no nú
5.2 AlinguagemArduino
ćleos CUDA da placa.
AA“linguagem”
maior parteArduino é´, atualmente,
das linguagens uma das mais
de programaç¸ãõ, comousadas no mundo,
C, Fortran, Pascal,segundo o
Java, PHP e
ranking publicado
Python, executa as linhas de comando em sequêˆncia, grosso modo, de cima para
pela IEEE em julho de 2017 (Institute of Electrical and Electronics Engineers, ver figura
baixo. abaixo).
É´ assim que o
Entretanto,éćonsensonosfó´runsespecializadosqueoArduinonãõé
iniciante em programaç¸ãõ deve pensar na hora de escrever seu có´digo.
úmalinguagempropriamente dita, e sim um “dialeto” da linguagem C, contendo
funç¸õ˜es especı́´ficas para a programaç¸ãõ no microcontrolador AVR.
De forma simplificada, o processo de compilaç¸ãõ começ¸a quando o IDE do Arduino
faz pequenasalteraç¸õ˜esnosketch,criandoumcó
´digoemC++.Emseguida,ocompiladoravr-gcc converte o có´digo de C++ para linguagem
de má´quina (ou có´digo objeto), para em seguida armazená´-
lonaplacadoArduinoviaUSBcomoumúńicoarquivoIntelhexadecimal.Umpouco
mais de detalhe sobre esse processo pode ser encontrado na Ref. [github-wiki].
Segundo o site oficial do Arduino (www.arduino.cc), os programas escritos em Arduino
podem ser divididos em trêˆs partes: estrutura, variá´veis e funç¸õ˜es.
5.3 Estr utura
A estrutura bá´sica de todo có´digo Arduino é´ composta pelas funç¸õ˜es setup() e
loop(), como pode ser visto nas linhas de comando abaixo. A diferenç¸a entre essas
funç¸õ˜es é´ que todos os comandos localizados dentro da funç¸ãõ setup() sãõ
executados apenas uma vez, ao passo que aqueles localizados dentro da funç¸ãõ
loop() sãõ executados repetidamente, até´ que o programa seja encerrado. Por
exemplo, uma instruç¸ãõ que faz a leitura contı́ńua de dados em um experimento deve
estar dentro de loop(), enquanto que uma declaraç¸ãõ de variá´veis deveria estar em
setup(). Observe que um programa cuja variá´vel seja declarada dentro de loop() ainda
funcionará´, poré´m uma eficiêˆncia menor, visto que haverá´ interminá´veis
redeclaraç¸õ˜es de variá´veis desnecessá
1 void
´rias.Abaixomostramososblocosdeinstruç¸õ˜esdentrodessasduasfunç¸õ˜es.
2 setup() {
3 Comando
4 a1;
Comando
a2;
5.4 Variá´veis 31

5 ...
6
7 }
8
9 void loop()
10 {
11 Comando b1;
12 Comando b2;
13 ...
14 }

Figura 5.1: Ranking de uso das linguagens de programaç¸ã˜o em 2017, com base em
pesquisa do IEEE.

5.4 Variá´veis
Asvariá´veisservemparaarmazenarumdeterminadotipodedado,quepodeserumnú
´meroou caractere.

5.4.1Variá´veisnumé´ricas
Os principais tipo de variá´veis numé´ricas sãõ int, float e double, como mostrado na
tabela abaixo. De forma resumida, se estamos trabalhando com nú´meros inteiros, o
melhor é´ usar a variá´veldotipoint.Senú´meroscompontosãõnecessá
´rios(6.7,3.14159,etc),podemosusaro float.Paraumamelhorprecisãõ,usa-
seodouble,poré´motempodeexecuç¸ãõdoprograma aumenta, pois é´ necessá´ria mais
memó´ria para armazenar os dados nesse tipo de variá´vel. Abaixo
mostramosostrêˆstiposbá´sicosdevariá´veisnumé´ricas,osvaloresmá´ximosemı́
ńimossuportados e a precisãõ em quantidade de casas decimais.
5.5 Entrada e saı́ ´da de dados 32

Tipo Caracterı́ Alcance Precisã˜

int ´stica de −32767a32767 o
inteiros de −3.4 ×1038a 3.4 38 -
float − ×10 de
reais 1.7−10308a 308 6 dı́
double × 1.7 −10 ×
reais ´gitos 10
5.4.2Variá´veisnãõ-numé´ricas dı́´gitos
Nesse caso, o tipo mais usado é´ o char, que armazena tanto letras como nú´meros e sı́
´mbolos (%, ∗,&,etc).Essetipodevariá´velarmazenaumú
ńicocaractere;paramais,considereusarumvetor (veja a Seç¸ãõ 5.11.1).

5.4.3 Declaraç¸ãõdevariá´veis
Adeclaraç¸ãõdeumavariá
´velpodeserentendidapeloexemplo5.1.Nessecaso,declaramosuma variá
´velcomnomenumdotipoint,umavariá´velcomnomedeltadotipofloateumavariá´vel de
nome H do tipo char. Quando declaramos as variá´veis antes da funç¸ãõ setup(), elas
sãõ “variá
´veisglobais”,deformaqueelaspodemserusadastantodentrodafunç¸ãõsetup()como
dentrodafunç¸ãõloop().Variá´veisdeclaradasdentrodeumafunç¸ãõsãõ“variá
Exemplo 5.1
´veislocais”,de forma que elas nãõ podem ser usadas fora dela.
1 int num;
2 float delta;
3 char H;
4
5 void
6 setup() {
7 ...
8 }

5.5 Entrada e saı́´ da de dados

O armazenamento de dados em uma variá´vel é´ feito com o comando de atribuiç¸ã˜o,
representado pelo sı́´mbolo =. Assim, quando escrevemos

1 num = 17;
estamos atribuindo o valor inteiro 17 à` variá´vel num, que deve ter sido previamente
declarada. Umadeclaraç¸ãõcomumaatribuiç¸ãõemumaú
ńicalinhapodeserrealizadadaseguinteforma:
1 int num = 17;

! Osı́´mbolo=temopapelunicamentedeumaatribuiç¸ã˜o.Aigualdadematemá
´ticanosentido comparativoé´representadapeladuplaigualdade==(verSeç¸ã˜o5.6).

O valor de uma variá´vel pode ser mostrado no monitor serial (saı́´da de dados) com as funç¸õ˜es
Serial.print() ou Serial.println(). A diferenç¸a entre elas é´ que a ú´ltima pula uma
linhaapó´saescritadovalordavariá´velnomonitorserial.
Abaixo temos um có´digo ilustrando o uso da funç¸ãõ Serial.println(). Para o uso dessa
funç¸ãõ,éńecessá´rioocarregamentodafunç¸ãõSerial.begin()dentrodafunç¸ãõsetup().
5.5 Entrada e saı́ ´da de dados 33

O valor de 9600 se refere à` taxa de transmissãõ de dados pela porta USB do
computador. Observe que, como a chamada da funç¸ãõ Serial.println() foi feita dentro
da funç¸ãõ loop(), o valordavariá´velnumapareceráńomonitorserialaté
óprogramaserfinalizado.Observetambé´m que o monitor serial pode ser usado apenas
quando o programa for carregado na memó´ria do Arduino, de forma que este deve
estar conectado com o computador via porta USB.
1 int num = 17;
2
3 void setup()
4 {
5 Serial.begin(9600);
6 }
7
8 void loop()
9 {
10 Serial.println(num);
11 delay(2000);
12 }

Figura 5.2: Monitor serial mostrando o valor armazenado na variá´vel num.

També´mé´possı́´vellerumavariá´velinseridanomonitorserial.Issoé´possı́´velcomafunç¸ãõ
Serial.parseInt(), que retorna o nú´mero inteiro digitado no monitor serial. O monitor serial
fica em espera por até´ 1 segundo, e caso esse tempo seja ultrapassado, a funç¸ãõ retorna o valor zero.
Esse tempo de espera pode ser personalizado com a funç¸ãõ Serial.setTimeout(), que faz o
monitor ficar em espera pelo argumento em milissegundos.
Exemplo 5.2 Abaixo temos um có´digo que calcula o valor de (a + b)3, onde a e b sãõ inteiros
digitados pelo usuá´rio.

1 int a,b,resultado;
5.6 Operaç¸õ˜es 34

2
3 void setup()
4 {
5 Serial.begin(9600);
6 Serial.setTimeout(3000);
7
8 Serial . p r i n t l n ( " E s t e p r o g r a m a c a l c u l a o v a l o r d e ( a + b ) ˆ 3 . " ) ;
9
10 Serial . p r i n t ( " a = " ) ;
11 a = Serial . p a r s e I n t ( ) ;
12 Serial . p r i n t l n ( a ) ;
13
14 Serial . p r i n t ( " b = " ) ;
15 b = Serial . p a r s e I n t ( ) ;
16 Serial . p r i n t l n ( b ) ;
17
18 resultado = (a+b)*(a+b)*
19 (a+b); Serial.print("(a + b)ˆ3
20 = ");
21 } Serial.print(resultado);
22
23 void
24 loop() {
25
26 }

5.6 Operaç¸õ˜es
Agora vamos dar inı́´cio ao processamento de dados com as operaç¸õ˜es aritmé´ticas.
O exemplo abaixo é´ bastante ilustrativo.
Exemplo 5.3

1 int a;
2 int b;
3 int soma;
4 int produto;
5
6 void setup()
7 {
8 Serial.begin(9600);
9 a=3;
10 b=4;
11 soma = a + b;
12 produto = a * b;
13
14 Serial.println(soma);
15 Serial.println(produto);
16 }
17
5.6 Operaç¸õ˜es 35

1 void
8 loop() {
1
9 }
2
0
2
1

Figura5.3:Execuç¸ã˜odocó´digoacima.

Comentá´riodocó´digo:

I Linhas 1 - 4. Aqui sã˜o declaradas as variá´veis a, b, soma e produto, todas do tipo int.

I Linhas 9 - 10. Atribuiç¸ã˜o do valor 3 à` variá´vel a e 4 à` variá´vel b.

I Linhas 11 - 12. À` variá´vel soma é´ atribuı́´do o valor da soma de a com b, e à` variá´vel produto
é´atribuı́´doovalordoprodutodeacomb.Essasduaslinhasconté´mtodooprocessamento
de dados desse có´digo.

I Linhas 14 - 15. Por ﬁm, é´ exibido no monitor serial o valor das variá´veis soma e produto.

Observe que, agora, preferimos incluir a chamada da funç¸ã˜o Serial.println() dentro da

funç¸ãõsetup(),deformaqueosvaloresdasvariá´veissomaeprodutoaparecemumaúńicavez
no monitor serial.
Lista resumida de operaç¸õ˜es aritmé´ticas:
5.7 Estrutura de condiç¸ ãõ 36

Operaç¸ãõDescriç¸ãõ
+ adiç¸ãõ
- subtraç¸ãõ
* multiplicaç¸ãõ
/ divisãõ
% restodadivisãõ

Há´, també´m, as operaç¸õ˜es de comparaç¸ã˜o e booleanas, listadas nas tabelas abaixo.

Operadores de comparaç¸ãõ
Operaç¸ãõDescriç¸ãõ
Operadores booleanos
== igual
Operaç¸ãõDescriç¸ãõ
!= diferente
&&e
< menor
||ou>maior
! nãõ
<= menorouigual
>= maiorouigual

5.7 Estrutura de condiç¸ ã˜o

A estrutura de condiç¸ãõ permite obtermos uma quebra no fluxo de execuç¸ãõ do
programa. Isso pode ser necessá´rio quando o programa executa tarefas diferentes
dependendo do valor que uma oumaisvariá´veispossui.Uminteressanteexemploé
ódasoluç¸ãõdeumaequaç¸ãõdosegundo grau. Se estivermos restritos ao corpo dos
nú´meros reais, sabemos que algumas dessas equaç¸õ˜es nãõpossuemsoluç¸ãõ.
Umaequaç¸ãõdosegundograupodeserescritacomo

ax2+bx+c=0,
onde a6= 0, b e c sãõ nú´meros reais. Sabemos que, se ∆ = b2
− 4ac > 0, a equaç¸ãõ possui duas
soluç¸õ˜es;se∆=0aequaç¸ãõpossuiumasoluç¸ãõ;ese∆<0nãõhá
´soluç¸ãõreal.Essasinformaç¸õ˜es
podem
quebra ser resumidas atravé´s do fluxograma da Fig. 5.4, onde é´ possı́´vel observar a
do fluxo
em trêˆs caminhos possı́´veis.
5.7 Estrutura de condiç¸ ãõ 37

Leia as variáveis a, b e c.

Calcule ∆ = b2 – 4ac

∆>0 ∆<0

∆=0
Duas Uma Nenhuma
soluções solução solução

Figura 5.4: Fluxograma representando a quebra de caminho conforme o valor de ∆ em

uma equaç¸ã˜o do segundo grau.

Assim, nosso có´digo deve ter uma instruç¸ã˜o que determina o que o programa deve

fazer
dependendo do valor de ∆.
1 i f ( c o n d i ç ¸ ã ˜ o )
Uma estrutura de condiç¸ãõ é´ formada pelos comandos if-else, cuja sintaxe é´ dada
2 {
3 i n s t r u ç ¸ ã ˜ o a 1 ; por
4 i n s t r u ç ¸ ã ˜ o a 2 ;
5 ...
6 }
7 else
8 {
9 i n s t r u ç ¸ ã ˜ o b 1 ;
10 i n s t r u ç ¸ ã ˜ o b 2 ;
11 ...
12 }
Oesboç¸odecó´digoacimapodeserlidodaseguinteforma:se(if)umadeterminadacondiç¸ãõ
for satisfeita, execute as instruç¸õ˜es entre chaves (instruç¸õ˜es a1, a2, etc), caso contrá
´rio (else),
ouseja,seacondiç¸ãõnãõforsatisfeita,executeosegundoconjuntodeinstruç¸õ˜esentrecha
ves (instruç¸õ˜esb1,b2,etc).
Veja abaixo um có´digo que soluciona uma equaç¸ãõ do segundo grau. A linha 12
calcula o valor
de ∆ com base nos coeficientes a, b e c, e nas linhas 15, 19 e 25 determinamos o que
Exemplo 5.4
acontece no caso de ∆ ser negativo, nulo ou positivo.
1 / / d e c l a r a ç ¸ ã ˜ o d e v a r i á ´ v e i s
2 float a, b, c, delta, x1, x2;
3
5.8 Estrutura de repetiç¸ ãõ 38

4 void setup()
5 {
6 Serial.begin(9600);
7 a=1;
8 b=5;
9 c=4;
10
11 //calcula o valor de delta
12 delta = b*b - 4*a*c;
13
14 / / e s t r u t u r a d e c o n d i ç ¸ ã ˜ o p a r a c a l c u l a r a s s o l u ç ¸ õ ˜ e s
15 if (delta < 0)
16 {
17 S e r i a l . p r i n t ( " A e q u a ç ¸ ã ˜ o n ã ˜ o p o s s u i s o l u ç ¸ õ ˜ e s " ) ;
18 }
19 if (delta == 0)
20 {
21 x1 = -b/(2*a);
22 S e r i a l . p r i n t ( " S o l u ç ¸ ã ˜ o : x 1 = " ) ;
23 Serial.print(x1);
24 }
25 if (delta > 0)
26 {
27 x1 = -b/(2*a) + sqrt(delta)/(2*a);
28 x2 = -b/(2*a) - sqrt(delta)/(2*a);
29 S e r i a l . p r i n t l n ( " S o l u ç ¸ ã ˜ o : " ) ;
Serial.print("x1 = ");
30
Serial.println(x1);
31
Serial.print("x2 = ");
32
Serial.println(x2);
33
34 }
35 }
36
37 void
38 loop() {
39
40 }

5.8 Estrutura de repetiç¸ ã˜ o

A estrutura de repetiç¸ãõ permite que uma sequêˆncia de instruç¸õ˜es seja repetida
quantas vezes o programador desejar. Observe que a funç¸ãõ loop() já´ faz algo
semelhante; a diferenç¸a é´ que comaú
´ltimaoprogramadornãõescolhequantasvezesasinstruç¸õ˜essãõrepetidas.Osprincipais
comandos de repetiç¸ãõ sãõ o for() e o while().
5.8.1 Comando f o r ( )
A sintaxe do comando for() é´ a seguinte:
1 f o r ( i n ı́´ c i o ; c o n d i ç ¸ ã ˜ o p a r a c o n t i n u a r o l o o p ; i n c r e m e n t o )
2 {
5.8 Estrutura de repetiç¸ ãõ 39

3 i n s t r u ç ¸ ã ˜ o a 1 ;
4 i n s t r u ç ¸ ã ˜ o a 2 ;
5 ...
6 }
Asinstruç¸õ˜esentreosparêˆntesesdeterminamquantasvezesasinstruç¸õ˜esentreaschave
ssãõ executadas. Para isso, uma determinada variá´vel (um contador) é´ inicializada e
incrementada, com os comandos entre as chaves sendo repetidos até´ que a
condiç¸ãõ deixe de ser satisfeita.
No exemplo 5.5, a variá´vel “contadora” k começ¸a com o valor 2 e é´ incrementada por
1 a cada passodoloop(ainstruç¸ãõk++é
ómesmoquek=k+1).Quandokultrapassaovalorde15,
acondiç¸ãõk<=15deixadesersatisfeitaearepetiç¸ãõcessa.Assim,oprogramaabaixoimpri
me no monitor serial (comando Serial.println()) o quadrado do valor de k, com k
Exemplo 5.5
variando de
1 2
i nat15:
k ; 4, 9, 25, ...
2
3 void setup()
4 {
5 Serial.begin(9600);
6
7 for(k=2; k<=15; k++)
8 {
9 Serial.println(k*k);
10 }
11 }
12
13 void
14 loop() {
15
16 }

Exercı́ ´cio 5.1Escreva um programa que mostre no monitor serial todos os nú´meros pares entre
150 e 300.

Exercı́ ´cio 5.2Escreva um programa que mostre no monitor serial o valor aproximado
1 1 da seguinte 11
sé´rie: + + +
2 4 ···.816

Exercı́ ´cio 5.3Escreva um programa que mostre no monitor serial a matriz identidade
abaixo:
I10
1 1 0 0 0 0 0 0 0
×10
2 0 0
3 0 1 0 0 0 0 0 0
4 0 0
5 0 0 1 0 0 0 0 0
6 0 0
7 0 0 0 1 0 0 0 0
8 0 0
0 0 0 0 1 0 0 0
0 0
0 0 0 0 0 1 0 0
0 0
0 0 0 0 0 0 1 0
0 0
5.9 Funç¸õ˜es 40

9 0 0 0 0 0 0 0 0
10 1 0
0 0 0 0 0 0 0 0
0 1
5.8.2 Comando while()
A sintaxe do comando while() é´
1 w h i l e ( c o n d i ç ¸ ã ˜ o )
2 {
3 i n s t r u ç ¸ ã ˜ o a 1 ;
4 i n s t r u ç ¸ ã ˜ o a 2 ;
5 ...
6 }
que pode ser “lido” como “enquanto uma condiç¸ãõ for satisfeita, execute o bloco de
instruç¸õ˜es entre as chaves”. Com esse comando, o exemplo 5.5 ficaria assim:
1 int k;
2
3 void setup()
4 {
5 Serial.begin(9600);
6
7 k=2;
8
9 while(k<=15)
10 {
11 Serial.println(k*k);
12 k++;
13 }
14 }
15
16 void loop()
17 {
18
19 }
Observe que a variá´vel contadora k foi previamente inicializada e que o incremento
k++ foi colocado como um comando dentro das chaves. O comando while() é´ mais
usado quando nãõ se sabe ao certo quantas vezes um determinado bloco de
instruç¸õ˜es deve ser repetido para que uma determinada tarefa seja executada.

Exercı́ćio 5.4 Refaç¸a os exercı́ćios 5.1, 5.2 e 5.3 usando a funç¸ãõ while().

5.9 Funç¸õ˜es
Em linguagens de programaç¸ãõ, funç¸õ˜es sãõ blocos de instruç¸õ˜es que podem ser
chamados em qualquer parte do corpo do programa. Com esses blocos de instruç¸õ˜es,
a funç¸ãõ pode ou retornar um valor ou executar uma tarefa. As funç¸õ˜es sãõ usadas
quando os blocos sãõ chamados mais de uma vez, o que evita que eles tenham que
ser digitados duas ou mais vezes, melhorando a esté´tica docó´digo,deixando-
omaisorganizadoe,assim,maisfáćildesercorrigido,compreendidoe melhorado.
5.9 Funç¸õ˜es 41

Asfunç¸õ˜espodemsercriadaspeloprogramadorcomotambé´mpodemserusadasaspredeﬁnidas
pelo Arduino (pinMode(), digitalWrite(), delay(), for(), etc).

5.9.1 Criaç¸ãõechamadadefunç¸õ˜es
Em geral, as funç¸õ˜es sãõ criadas antes da estrutura setup(). A sintaxe é´
1 t i p o - d o - r e t o r n o n o m e ( t i p o v a r i á ´ v e l 1 , t i p o v a r i á ´ v e l 2 , . . . )
2 {
3 d e c l a r a ç ¸ ã ˜ o d e v a r i á ´ v e i s ; ( q u a n d o n e c e s s á ´ r i o )
4
5 i n s t r u ç ¸ ã ˜ o 1 ;
6 i n s t r u ç ¸ ã ˜ o 2 ;
7 ...
8 r e t u r n v a r i á ´ v e l ; ( o p c i o n a l )
9 }
Seafunç¸ãõretornarumvalor,éóbrigató´rioquesejadeterminadootipodoretorno,quepode
serumnú´merointeiro,umnú´merorealoumesmoumcaractere.Asvariá´veisdentrodoparêˆnteses
sãõasvariá´veisdeentrada,cujostipostambé´mdevemserexplicitados.
Exemplo 5.6 Funç¸ãõ de nome “func”, com retorno do tipo float, com variá´veis de entrada
“var1” e “var2”, ambas do tipo inteiro:

1 float func(int var1, int var2)

Já´ as funç¸õ˜es que nãõ retornam valores sãõ do tipo “void”. Em algumas linguagens
de programaç¸ãõ, como Pascal, elas sãõ chamadas de procedimentos (procedures), e
nãõ de funç¸õ˜es. No exemplo 5.7 temos a declaraç¸ãõ da funç¸ãõ que escolhemos
chamar de “pul”, e que nãõ retorna valor. Ela també´mnãõpossuivariá´veisdeentrada.
Exemplo 5.7

1 void pul()
É´possı́´velquevariá´veissejamdeclaradasparausoexclusivodentrodafunç¸ãõ.Nessecaso,cha-
mamos elas de “variá´veis locais”, em contraposiç¸ãõ à`quelas declaradas antes de void setup(),
quesãõ“variá´veisglobais”.Aregraé´quevariá´veislocaissãõ“enxergadas”apenasdentrodafunç¸ãõ
onde foram declaradas, enquanto que as locais sãõ enxergadas em todo o escopo do programa.
A chamada de uma funç¸ãõ pode ser realizada em qualquer parte do programa, até´ mesmo dentro
dapró´priafunç¸ãõ(atributoesteconhecidocomorecursividade,caracterı́´sticodalinguagemC).
Exemplo 5.8 Seja uma funç¸ãõ que retorna o sinc de um nú´mero real. O “sinc” é´ uma funç¸ãõ
matemá´tica muito usada na teoria da difraç¸ãõ, aprecendo també´m em fı́´sica atôˆmica, sendo definida
pelarazãõdosenodeumnú´meropelopró´prionú´mero:

sin(x)
sinc(x) =
x
Vamos criar um programa que retorna o sinc de 4:
1 float sinc(float x) {
2 float f;
3 f = sin(x)/x;
4 return f;
5
5.9 Funç¸õ˜es 42

6 }
7
8 void setup()
9 {
10 Serial.begin(9600);
11 Serial.println(sinc(4));
12 }
13
14 void loop()
15 {
16
17 }
Observe, dentro da funç¸ãõ sinc(), que declaramos uma variá´vel local f, que foi usada apenas
para retornar o valor da funç¸ãõ. Na linha 11 temos a chamada da funç¸ãõ dentro de println().
Exemplo 5.9 Programa que informa se um aluno foi aprovado ou nãõ, com base na sua mé´dia
final.

1 void situacao(float nota)

2 {
3 if (nota>=7)
4 {
5 Serial.println("Aluno aprovado");
6 }
7 if (nota<7)
8 {
9 Serial.println("Aluno reprovado");
10 }
11 }
12
13 void setup()
14 {
15 Serial.begin(9600);
16 float nota = 8.5;
17 situacao(nota);
18 }
19
20 void loop()
21 {
22
23 }

Exercı́ćio5.5Crieumafunç¸ãõquerretornaomenorvalorentredoisnú
´merosinteiros.Natural- mente, a funç¸ãõ deve ter duas variá´veis inteiras de entrada.

Exercı́´cio 5.6 Crie uma funç¸ã˜o quer retorna o fatorial de um nú´mero inteiro.
5.9 Funç¸õ˜es 43

5.9.2 Funç¸õ˜espredefinidasdoArduino
Abordaremos aqui apenas as funç¸õ˜es mais usadas por iniciantes no mundo do
Arduino. Para uma lista completa, consulte o site oficial do Arduino.
I pinMode(): Essa funç¸ãõ habilita uma determinada porta da placa do Arduino para

entrada
pin
1 saı́´da
ou deMdados.
o d e ( pSua
o r tsintaxe
a , m oé´
do);

onde a “porta” pode ser qualquer uma da placa e o modo pode ser paraI N P U )ou
T
entrada ( saı́´da(OUTPUT)dedados.
1Exemplo5.10Porta
0 habilitadaparasaı́´dadetensã˜o:

1 pinMode(10, OUTPUT);

Exemplo 5.11 Porta A5habilitada para entrada de tensã˜o:

1 pinMode(A5, INPUT);

I digitalWrite():Colocaou0ou5Vdetensãõemumaportaespecı́´fica.Éóbrigató´rio que
a porta esteja habilitada para saı́´da de tensãõ com o comando pinMode(). No
Arduino
0 1 3 UnoR3,asportasde a podemserusadascomessepropó´sito.Suasintaxeé´
1 digitalWrite(porta, valor);

Os valores assumidos podem ser HIGH (5 V) ou LOW

(01 3V). Exemplo5.12Porta comtensã˜ode5V:

1 digitalWrite(13, HIGH);

I digitalRead(): Realiza a leitura de tensã˜o de uma determinada porta. É´ obrigató

´rio que a porta esteja habilitada para entrada de tensã˜o com o comando
pinMode(). No Arduino Uno R3, as portas que podem ser usadas sã˜o as de A0 a
A5. Sintaxe:
1 digitalRead(porta);

Normalmente, o valor será´ armazenado em alguma variá´vel. Alé´m disso, o valor

da leitura será´sempreumnú
´meroentre0e1023,correspondendoaoslimites0e5V,respectivamente.
Exemplo 5.13 Armazenamento na variá´vel tensao do valor lido na porta A0:
1 tensao = digitalRead(A0);

I analogWrite(): Faz uma determinada porta ficar sob tensãõ em modulaç¸ãõ por
largura de pulso (Pulse Width Modulation - PWM). Em outras palavras, a funç¸ãõ
simula uma saı́´da analó
´gicaentre0e5Vaofazeratensãõvariarrapidamenteentreessesextremos,deforma
queovalormé´dioéúmafunç¸ãõcontı́ńua.Assim,nãõé´,defato,umasaı́´daanaló
´gica,e sim uma saı́´da digital modulada. Uma saı́´da de tensãõ verdadeiramente
contı́núa entre esses valoresdetensãõé´possı́´velcomshieldsespecı́
´ficos.SegundoositedoArduino,afrequêˆncia
damodulaç¸ãõvariadependendodaporta,podendoser490Hzou980Hz.Apenasaspor
tas indicadas pelo sı́´mbolo
∼ podem ser usadas como PWM.
A sintaxe do comando é´
5.9 Funç¸õ˜es 44

1 analogWrite(porta, valor);

O atributo valor regula a largura temporal do pulso em relaç¸ã˜o ao perı́´odo de

repetiç¸ãõ. Os valores devem estar entre 0 (0%) e 255 (100% do perı́ódo). Isso
faz com que, na mé´dia, a
tensãõvariecontinuamenteentre0e5V,sendoidealpararegularaintensidadedeumLE
D ou para controlar a velocidade de um motor DC. A figura 5.5 ilustra o papel do
atributo valor na geraç¸ãõ dos pulsos.
pulsos de tensão

tensão
média valor = 64

tempo

valor = 128

valor = 192

Figura 5.5: Ilustraç¸ãõ da saı́´da de tensãõ em modulaç¸ãõ por largura de pulso

(PWM). Temos representado o atributo valor em 64, 128 e 196, o que corresponde a
pulsos com largura temporal de 25%, 50% e 75% do perı́´odo, respectivamente. A linha
verde tracejada seria a mé´dia do trem de pulsos quadrados (linhas vermelhas), que
pode ser ajustada entre 0 e 5 V.

I delay(): Faz o ﬂuxo do programa parar por alguns milissegundos. Assim, para fazer o
programa esperar 2 segundos, basta incluir o có´digo delay(2000). É´ ideal para exibir o
valor de uma variá´vel no monitor serial de forma mais lenta.
I delayMicroseconds(): Idem anterior, só´ que em microssegundos.
,
emcos()
I sin() radianos.
e tan(): Funç¸õ˜es matemá´ticas trigonomé´tricas. O argumento deve estar
I ,s q r t ( ) p o w ( ) e a b s ( ) :Funç¸õ˜esmatemá´ticaspararaizquadrada,potêˆnciaevalor
absoluto.
√
Exemplo 5.14 Ocó´digoabaixoexibeosvaloresnumé´ricosde 5, 73 e |− 20|.
5.10 Bibliotecas 45

1 void setup()
2 {
3 Serial.begin(9600);
4
5 Serial . p r i n t l n ( s q r t ( 5 ) ) ;
6 Serial . p r i n t l n ( p o w ( 7 , 3 ) ) ;
7 Serial . p r i n t l n ( a b s ( - 2 0 ) ) ;
8 }
9
10 void loop()
11 {
12
13 }

! Para o uso desses comandos nã˜o é´ necessá´rio o carregamento da

biblioteca (ver Seç¸ã˜o 5.10) <math.h>, como na linguagem C.

5.10 Bibliotecas
Amaneiramaisfáćildeentenderasbibliotecasé´pensá´-
lascomoumtipodefunç¸ãõ.Adiferenç¸aé´ que o bloco de instruç¸õ˜es nãõ fica no escopo
do programa, e sim na pasta libraries do Arduino.
Asbibliotecassãõaplicadasnachamadadeblocosdeinstruç¸õ˜esquesãõusadosmuitasvez
esem diferentesprogramas.Umexemploéábibliotecamath.hdalinguagemC,queconté
´masfunç¸õ˜es sqrt(), pow(), atan(), etc. As bibliotecas també´m podem ser criadas pelo
programador.
loop()
Uma biblioteca padrãõ é´ chamada com a diretiva include antes das estruturas setup()
1 #include<nome-da-biblioteca>
e
:Jáúmabibliotecacriadapelousuá´riosegueasintaxeabaixo:
1 #include "nome-da-biblioteca.h"
Paraacriaç¸ãõdeumabibliotecaéńecessá´rioumIDEdalinguagemC/C++,comooDev-C++,
ou mesmo um editor de texto simples, como o Bloco de Notas do Windows. Usando
este ú´ltimo, basta digitar o có´digo no Bloco de Notas e salvar com a extensãõ h, que
indica uma biblioteca na linguagem C. Feito isso, basta localizar a pasta libraries,
geralmente em C:
\Program
Files (x86)
\Arduino\libraries. Para ficar mais organizado, a biblioteca pode ficar
nesse endereç¸o dentro de uma outra pasta, com o nome que lembre a biblioteca.
Exemplo 5.15 Abaixo temos um programa que calcula o sinc de 4 (compare com o
Exemplo
5.7), mas agora usando uma biblioteca. Para isso, criamos a biblioteca funcaosinc.h,
que
foi colocada dentro da pasta Funcao sinc, localizada na pasta libraries do Arduino. Os
có´digosdabibliotecaedosketchestãõmostradosabaixo.
5.11 Vetores e matrizes 46

Figura 5.6: Pasta criada para a biblioteca funcaosinc.h.

1 / / C ó ´ d i g o d a b i b l i o t e c a
2 float sinc(float x)
3 {
4 float f;
5 f = sin(x)/x;
6 return f;
7 }
1 / / C ó ´ d i g o d o s k e t c h
2 #include "funcaosinc.h"
3
4 void setup()
5 {
6 Serial.begin(9600);
7 Serial.println(sinc(4));
8
}
9
10
void loop()
11
{
12
13
}

Exercı́ ´cio 5.7Escreva uma biblioteca que execute as mesmas instruç¸õ˜es das funç¸õ˜es dos exercı́´cios
5.5 e 5.6.

5.11 Vetoresematrizes
Em diversas linguagens de programaç¸ãõ, existe o que chamamos de variá´veis
multidimensionais, capazes de armazenar nãõ apenas um nú´mero ou um caractere,
mas sim vá´rios deles.
5.11.1 Vetores
Umvetoréúmavariá´velunidimensional.Aformamaisfáćildeentendêˆ-laé
ímaginandoqueela possuivá
´rios“espaç¸os”quepodemseracessadosoupreenchidoscomvaloresnumé´ricosounãõ.
Cadaespaç¸oéúmacomponentedovetor.AFig.5.7ilustraumvetorcom5componentes.
5.11 Vetores e matrizes 47

Figura 5.7: Vetor com 5 componentes.

Adeclaraç¸ã˜odeumavariá´velvetorialé´bastantesemelhanteaodeumavariá´velconvencional;o
quemudaé´queagoraprecisamosinformarotamanhodovetor,istoé´,aquantidadedecomponentes
que ele possui:
1 t i p o - d a - v a r i á ´ v e l n o m e - d a - v a r i a v e l [ t a m a n h o - d o - v e t o r ] ;

Exemplo 5.16 Variá´veldenomevet,dotiporealcom9componentes:

1 float vet[9];
Isso quer dizer que podemos preencher os nove espaç¸os com nú´meros reais do tipo float.
Uma mistura de tipos no mesmo vetor (por exemplo, componentes inteiras com reais) nãõ é´
permitida.
Para acessar um úńico componente do vetor, basta saber a posiç¸ãõ correspondente, lembrando
queaprimeiraposiç¸ãõé´representadapelonú´mero0eaú´ltima,porn-1,ondenéótamanhodo
vetor.
Exemplo 5.17 Agora vamos declarar um vetor de nome v, de 5 componentes inteiras, atribuir
valoresà`scomponentese,porfim,apresentarnomonitorserialasomaprimeiracomaú´ltima
componente.

1 void setup()
2 {
3 / / D e c l a r a ç ¸ ã ˜ o d o v e t o r
4 int v[5];
5 int soma;
6
7 / / A t r i b u i ç ¸ ã ˜ o d e v a l o r e s à ` s c o m p o n e n t e s d o v e t
8 or v[0] = 3;
9 v[1] = 8;
10 v[2] = 11;
11 v[3] = -7;
12 v[4] = 60;
13
14 //Soma da primeira com a ú ´ l t i m a
15 componente soma = v[0] + v[4];
16
17 //Mostrando no monitor serial a o resultado da soma
18 Serial.begin(9600);
19 Serial.println(soma);
20 }
21
22 void loop()
23 {
24
25 }
5.11 Vetores e matrizes 48

Ocó´digoacimapodesermelhorcompreendidocomoﬂuxogramadaﬁguraabaixo.

Atribuição dos valores às

componentes do vetor
Declaração do vetor v
Declaração da
variável soma

3 8 11 7 60

Soma da primeira com a

última componente

Apresentação da variável 3 8 11 -7 60
soma no monitor serial

Figura 5.8: Fluxograma do Exemplo 5.17.

! Lembre-se, sempre, de efetuar as operaç¸õ˜es usando as componentes do vetor,

e nã˜o o vetor em si. O mesmo vale para a declaraç¸ã˜o e o acesso.

O uso de vetores, quando apropriado, tem muitas vantagens. Imagine que uma pessoa precise
monitorar e regular a temperatura de 12 salas de uma empresa. Poderiam ser declaradas 12 variá´veis
para cada sala:
1 float T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12;
É´bastanteó´bvioqueessanã˜oé´umaboaescolha,já´queé´possı́´velfazerdaseguinteforma:

1 float T[12];
onde T [ 0 ] éátemperaturadasala01,T[1]dasala02eassimpordiante.NaSeç¸ãõ7.1,que
descreve um projeto envolvendo o controle de 5 leds, há´ um exemplo de uso de um
vetor.
5.11.2 Matrizes
Ageneralizaç¸ãõdevetoresparaduasoumaisdimensõ˜esé
ćhamadadematriz.Assim,emvezde umúńicoı́ńdice,matrizesusamvá´rios.
Exemplo5.18

Declaraç¸ã˜odeumamatrizdenomematde3dimensõ˜es,detamanho4x5x6,de
1 variá´veisdotipochar:
char mat[4][5][6];
5.11 Vetores e matrizes 49

A forma como manipulamos matrizes é´ aná´loga à` forma como usamos os vetores.
Escreva
Exemplo 5.19 um programa que mostre no monitor serial a matriz identidade 10 x 10
abaixo:

1 1 0 0 0 0 0 0 0 0 0
2 0 1 0 0 0 0 0 0 0 0
3 0 0 1 0 0 0 0 0 0 0
4 0 0 0 1 0 0 0 0 0 0
5 0 0 0 0 1 0 0 0 0 0
6 0 0 0 0 0 1 0 0 0 0
7 0 0 0 0 0 0 1 0 0 0
8 0 0 0 0 0 0 0 1 0 0
9 0 0 0 0 0 0 0 0 1 0
10 0 0 0 0 0 0 0 0 0 1

1 int ident[10][10];
2 int k,p;
3
4 void setup()
5 {
6 Serial.begin(9600);
7
8 //Cria a matriz identidade
9 for (k=0; k<=9; k++)
10 for (p=0; p<=9; p++)
11 {
12 if (k == p) ident[k][p] = 1;
13 if (k != p) ident[k][p] = 0;
14
}
15
16
//Escreve no monitor serial a matriz
17
identidade for (k=0; k<=9; k++)
18
{
19
20
Serial.println();
21
for (p=0; p<=9; p++)
22 {
23 Serial.print(ident[k][p]);
24 Serial.print(" ");
25 }
26 }
27 }
28
29 void loop()
30 {
31
}
5.11 Vetores e matrizes 50

Exercı́ ´cio 5.8Escreva um programa que mostre no monitor serial a matriz abaixo.
1 1 0 0 0 0 0
2 0
3 1 2 0 0 0 0
4 0
5 1 1 3 0 0 0
6 0
7 1 1 1 4 0 0
0
1 1 1 1 5 0
0
1 1 1 1 1 6
0
1 1 1 1 1 1
7
6. Componentes eletrôˆnicos

Apresentaremos aqui o funcionamento dos dispositivos bá´sicos na eletrôˆnica usados

nessa apostila, em particular:
I A matriz de linhas
I Jumpers

I Resistores
I Fontes

I Capacitores
I LED’s

I Fototransistores
I LDR’s

I Relé´s
I Potenciôˆmetros

I PZT’s

6.1 Amatrizdelinhas
A matriz de linhas, protoboard ou matriz de contato é´ uma placa de ensaios para
montagens de circuitoseletrôˆnicos.Elaé
ćompostaporfuroscomconexõ˜esinternas,peloqualé´possı́´velfazera
ligaç¸ãõentrediversosdispositivos,evitandosolda.
Os furos da placa sãõ conectados obedecendo algumas regras. Como mostrado na
Fig. 6.1, os pinos centrais (denotados pelas linhas a, b, c, ..., j) possuem ligaç¸õ˜es na
vertical. Por exemplo,
6.1 A matriz de linhas 52

todos os furos indicados pelas coordenadas (10, a), (10, b), (10, c), (10, d) e (10, e)
sãõ conectados e, portanto, nos circuitos, todos eles estarãõ sob a mesma tensãõ.
De forma aná´loga, todos os furos da linha indicada por + (e també´m
−)estãõconectadosentresi.Essesdoisú´ltimosconjuntosde
furossãõmuitousadosparaconectarumafontedetensãõ(furos+)eoterra(furos
−), apesar de
isso nãõ ser uma obrigaç¸ãõ.

Figura 6.1: Representaç¸ã˜o de uma matriz de linhas com alguns furos que estã˜o conectados entre si.

No exemplo baixo temos um circuito RC nas representaç¸õ˜es convencional de livros didá´ticos e

na matriz de linhas.
Exemplo 6.1

Figura 6.2: Duas representaç¸õ˜es do mesmo circuito. Legenda: R - resistor, C -

capacitor, V - fonte detensã˜o.
Abaixo temos um circuito mais complexo, feito de forma aleató´ria para exempliﬁcar o

uso da
Exemplo 6.2
matriz de linhas.
6.2 Jumpers 53

Figura 6.3: Duas representaç¸õ˜es do mesmo circuito. Legenda: R - resistor, C -

capacitor, V - fonte de tensã˜o, L - LED, D - Diodo.

6.2 Jumper s
Os jumpers sãõ os fios que usamos para conectar os componentes eletrôˆnicos na
protoboard. Basicamente,há´jumpersdetrêˆstipos:macho-macho,macho-fêˆmeaefêˆmea-
fêˆmea.Emcircuitos muito complexos, a quantidade de jumpers pode ser muito grande e
uma padronizaç¸ãõ pode facilitar na hora de modificar o projeto. Em geral, fios
vermelhos sãõ usados para o terminal positivo da tensãõ, os fios pretos sãõ
reservados para o terra e os fios de outras cores sãõ para leitura e escrita de dados.

Figura 6.4: Jumpers macho-macho de diversas cores.

6.3 Resistores
O resistor, designado pela letra R, é´ um componente eletrôˆnico que obedece à` lei de
Ohm quando atravessado por por uma corrente elé´trica i, de forma que podemos
escrever

V=iR, (6.1)
ondeV representa uma queda de tensã˜o elé´trica no sentido da corrente.
6.4 Fontes 54

Figura 6.5: Resistor e sua representaç¸ã˜o em circuitos elé´tricos.

6.4 Fontes
Fontesdetensãõ,ousimplesmentefontes,sãõosdispositivosquegeramumadiferenç¸adep
otencial elé´trico (ou, novamente, tensãõ) entre seus terminais. As tensõ˜es podem ser
contı́ńuas, quando o valor da tensãõ permanece constante no tempo, ou alternada,
quando a tensãõ oscila periodicamente.

Figura 6.6: Exemplo de fonte de tensã˜o (uma bateria de 9 V) e um exemplo de

representaç¸ã˜o de fontecontı́´nua(há´muitasvariaç¸õ˜es).

Exemplo 6.3 Exemplo de fontes contı́´nuas: pilhas AA e AAA (1,5 V), baterias de 9 V,

fontes de
tensã˜oDCsintonizá´veiseplacasdeenergiasolar.
Exemplo 6.4 Exemplo de fontes alternadas: tomadas residenciais (110 ou 220 V de

tensãõ
senoidal
amplituderms) e geradores de funç¸õ˜es (quadrada, triangular ou senoidal com
variá´vel).
! Nãõtenteusarumatomadaresidencialcomofontedetensãõemnenhumexemplodest
a apostila.
As fontes A tensãõ
de tensãõ, elevada
junto com gera correntes altas,
os capacitores levando asãõ
carregados, riscoas
defontes
choques
de elé
energia
´tricos e incêˆndios devido ao excesso de calor em fios de pouca espessura.
Priorize o uso de baixas tensõ˜es contı́ńuas (15 V ou menos).
do circuito
elé´trico,semosquaisnãõhaveráćorrenteelé´trica.
6.5 Corrente,tensãõ,resistêˆnciaeleidasmalhas
O conhecimento da fı́´sica de circuitos elé´tricos a nı́´vel de Ensino Mé´dio é´
fundamental para a criaç¸ãõdeprojetosArduino.
Segundo a lei de Ohm, a corrente i em materiais dito “ôˆmicos” é´ proporcional a
diferenç¸a de
potencial V aplicado nos seus terminais:
V
R i=. (6.2)
6.5 Corrente, tensãõ, resistêˆncia e lei das malhas 55

Entã˜o, quanto maior sua resistêˆncia, menor a corrente elé´trica que o atravessa. Esse
é´ um ponto muito importante para ser levado em conta na criaç¸ã˜o dos projetos, visto
que diversos componentes eletrôˆnicossuportamumacertacorrentemá´xima.

6.5.1 Associaç¸ã˜oderesistores
Dois ou mais resistores em sé´rie (veja a Fig. 6.7) se comportam como se fosse um só´,
mas com
resistêˆnciaequivalenteReqigualà`somadasresistêˆnciasindividuais.Matematicamente:
···
Req=R1+R2+R3+ (6.3)

Figura 6.7: Trêˆs resistores em sé´rie, com valores de 1 kΩ, 2 kΩ e 3 kΩ, e o resistor
equivalente, comresistêˆncia6kΩ.Emalgunssoftwareselivros,osı́
´mboloΩpodeestaromitido.

Para resistores em paralelo (veja a Fig. 6.8), a resistêˆncia equivalente é´ o inverso da

soma dos
···
R q Matematicamente:
inversos das resistêˆncias individuais:
1 1 1 1
=+++ (6.4)
e R1 R2 R3

Figura 6.8: Trêˆs resistores em paralelo, com valores de 1 kΩ, 2 kΩ e 3 kΩ, e o resistor
equivalente,
comresistêˆnciadeaproximadamente0,55kΩ,tomandoporbaseosterminaisaebindicados.

Em seus projetos, vocêˆ pode combinar resistores até´ obter uma resistêˆncia

apropriada. Assim,
se um como
sé´rie resistor de 6 kΩ nã˜o estiver disponı́´vel, vocêˆ pode combinar trêˆs resistores em
indicado na Fig. 6.7. É´ possı́´vel també´m obter tensõ˜es diferentes das fontes disponı́
´veis (veja o
Exemplo 6.6.).
6.5 Corrente, tensã˜o, resistêˆncia e lei das malhas 56

6.5.2 Lei das malhas

A lei das malhas permite calcular as correntes no circuito. Ela pode ser enunciada da
seguinte forma: quando percorremos o circuito fechado até´ completá´-lo, a soma das
diferenç¸as de potencial é´zero.
Exemplo 6.5 Calcule a corrente no circuito abaixo.

Figura 6.9: Exemplo de circuito.

Percorrendo a malha no sentido horá´rio a partir da fonte, temos:

12
−i×2000−i×8000 = 0
10000i = 12
12
i =
10000
i = 1,2mA
Exemplo 6.6 Vamos supor que queremos uma tensãõ de exatamente 2,7 V nos terminais de
um dado dispositivo, identificado pela letra D no circuito da Fig. 6.10. Qual é´ valor do resistor R
que devemos usar, supondo que nãõ podemos alterar o valor da tensãõ da fonte? A resistêˆncia do
dispositivo vale 50 Ω.

Figura 6.10: Exemplo de circuito.

Pela lei das malhas, a corrente que atravessa o dispositivo D deve ser

2,7 = i×50
i = 54mA
6.6Maiscomponenteseletrôˆnicos 57

Entã˜o,novamentepelaleidemalhas,temos

9
−0,054×50−0,054×R = 0
0,054R = 9
− 0, 054 × 50
R
≈ 166Ω
Essecomponentes
6.6 Mais valor de resistêˆncia pode ser obtido com um potenciôˆmetro (ver Seç¸ãõ 6.6.7).
eletrôˆnicos
6.6.1 Capacitores
Um capacitor é´ um dispositivo eletrôˆnico de dois terminais composto por dois
condutores separados porumaregiãõnãõ-condutora,quearmazenaenergiaelé
´tricanocampoelé´triconessaregiãõ.Em um capacitor ideal, se uma diferenç¸a de
potencial elé´trico V é´ aplicada em seus terminais, cargas Q demesmomó
´duloesinaisopostossãõcriadasemsuasplacassegundoaequaç¸ãõ
Q = CV,
onde C é´ a “capacitâˆncia” do dispositivo (dada geralmente em µF), uma constante que
unidades de depende do seu material e da sua geometria.

Figura 6.11: Um capacitor de 82 µF e sua representaç¸ã˜o em circuitos eletrôˆnicos.

Os capacitores sãõ usados em circuitos eletrôˆnicos principalmente como filtros (passa banda
e passa baixa), estabilizadores de tensãõ e també´m osciladores eletrôˆnicos, sintonizando onda de
rá´dio em frequêˆncias especı́´ficas. Com capacitores també´m é´ possı́´vel bloquear corrente contı́ńua
enquanto é´ permitida a passagem de corrente alternada.
Aqui vamos aproveitar para apresentar um simples projeto onde mediremos a tensãõ em um
dado ponto de um circuito RC (circuito com um capacitor e um resistor) em funç¸ãõ do tempo,
conforme chaveamos uma fonte de tensãõ de 5 V (veja a figura abaixo). Vamos ligar e desligar
a fonte em intervalos pré´-determinados, de forma que o capacitor seja periodicamente carregado
e descarregado. Para isso, precisamos de uma porta de saı́´da digital (usaremos a porta 11 do
Arduino). A medida de tensãõ será´ feita entre os terminais do resistor e do capacitor (por razõ˜es
ó´bvias), e assim precisamos també´m de uma porta de entrada analó´gica (usaremos a A5).
O tempo de carga de um capacitor é´ da ordem da constante caracterı́´stica τ de um circuito RC,
definida por

τ = RC.
Escolhemos usar um resistor de R = 3,8 kΩ e um capacitor de 82 µF, de forma que obtemos
τ
≈ 300 ms. Assim, para ver a carga e a descarga completa, vamos modular a tensã˜o de 5 V em
500 ms.
6.6Maiscomponenteseletrôˆnicos 58

Figura 6.12: Na esquerda temos a representaç¸ã˜o de um circuito RC com fonte e na direita as

conexõ˜esusandooArduino.Desenhadosnossites e
https://easyeda.com https://www.
tinkercad.com, respectivamente.

Ocó´digoestá´mostradoabaixo.Asportasdeentradaesaı́´daestãõdefinidasnaslinhas1e2
e escolhemos pegar 500 pontos em cada carga e descarga (linha 3) com intervalos de 1 segundo
(linha 4). Nas linhas 10-12 habilitamos as portas e o monitor serial. O chaveamento é´ feito dentro
dafunç¸ãõloop().Iniciamoscomafonteem0V(linha17)e,500vezes(linha18),armazenamos
o valor lido na porta A5 (linha 20) e convertemos em tensãõ (linha 21), para em seguida apresentar
no monitor serial (linha 22). O mesmo processo é´ feito quando a tensãõ está´ em 5 V (linhas 26-33),
reiniciando o ciclo.
1 int saida = 11;
2 int entrada = A5;
3 int pontos = 500;
4 int tempo = 1;
5 int valor, k;
6 float tensao;
7
8 void setup()
9 {
10 pinMode(saida, OUTPUT);
11 pinMode(entrada, INPUT);
12 Serial.begin(9600);
13 }
14
15 void loop()
16 {
17 digitalWrite(saida, LOW);
18 for (k=1; k<=pontos; k++)
19 {
20 valor = analogRead(entrada);
21 tensao = float(valor)*5/1023;
22 Serial.println(tensao);
23 delay(tempo);
24 }
25
26 digitalWrite(saida, HIGH); for
27 (k=1; k<=pontos; k++)
6.6Maiscomponenteseletrôˆnicos 59

2 {
8 valor = analogRead(entrada);
2 tensao = float(valor)*5/1023;
9 Serial.println(tensao);
3 delay(tempo);
0 }
3 }
1
3
2
3
3
3
4

Figura 6.13: Arduino executando o có´digo acima.

Para ficar mais ilustrativo, copiamos as tensõ˜es lidas no monitor serial (ver figura 6.14) e
colamos em um software grá´fico, onde pode ser observado claramente (figura 6.15) os ciclos de
carga e descarga do capacitor.

Figura 6.14: Monitor serial apresentando as tensõ˜es lidas.

6.6Maiscomponenteseletrôˆnicos 60

5
4
3

Tensão (V)
2
1
0
500 1000 1500 2000
Tempo (ms)

Figura 6.15: Carga e descarga de um capacitor conectado a um resistor e a uma fonte

de 5 V modulada em 1,0 Hz.

Exercı́ćio 6.1 Introduza um LED no circuito acima e faç¸a uma modificaç¸ãõ no có

´digo para que o

6.6.2 Diodos
LED acenda quando o capacitor fique com carga acima de 80% da sua carga má´xima.
Diodossãõcomponentesquepermitemapassagemdacorrenteemapenasumsentido.Sãõ
importantes para evitar danos a dispositivos que nãõ aceitam corrente reversa. Tem
aplicaç¸õ˜es també´memfiltrospassabandaepassabaixa,eemretificadoreselé´tricos.

Figura 6.16: Um diodo e sua representaç¸ã˜o em circuitos elé´tricos.

6.6.3 LEDs
LED’s (Light-Emitting Diode - diodo emissor de luz) sãõ dispositivos semicondutores
que emitem luzquandoumadiferenç¸adepotencialelé´tricoé
áplicadoemseusterminais.Oefeitoportrá´sé´ aeletroluminescêˆncia,ondealuzé
émitidaviarecombinaç¸ãõelé´tron-buraco.Elessãõencontra- dos em praticamente
todas as cores, e també´m no infravermelho e no ultravioleta, sendo que o
desenvolvimento na cor azul resultou no Prêˆmio Nobel de Fı́´sica em 2014.
Na figura abaixo temos um LED e sua representaç¸ãõ em circuitos eletrôˆnicos. Na
perna maior
deve ser conectado o polo positivo, e na menor o negativo (ou o terra). Projetos
6.6.4 envolvendo LED’s podem ser encontrados no Cap. 7.
Fototransistores
Fototransistoressãõtransistoressensı́´veisà`luz.Naprá
´tica,elessãõdispositivosqueconvertemluz emcorrenteelé
´trica.Assim,umusobastantecomuméémfotodetectores.Suaeficiêˆnciadepende do
comprimento de onda da luz incidente, que por sua vez depende do semicondutor do
qual ele é´ feito. Por exemplo, fotodiodos de silı́ćio sãõ eficientes na faixa 190 - 1100
nm, enquanto que os de InGaAs(ı́ńdioarsenetodegá
´lio)operammelhorentre800nme2,6µm.Umprojetoenvolvendo um fototransistor como um
sensor de luz se encontra na Sec. 7.3.
6.6Maiscomponenteseletrôˆnicos 61

Figura 6.17: Um LED vermelho e sua representaç¸ã˜o em circuitos eletrôˆnicos.

Figura 6.18: Um fototransistor e sua representaç¸ã˜o em circuitos eletrôˆnicos.

6.6.5 LDRs
LDR’s (Light-Dependent Resistor - resistores dependentes da luz) sã˜o dispositivos cuja
resistêˆncia varia com a intensidade da luz que incide sobre eles. Na verdade, a
resistêˆncia diminui com o aumento da intensidade da luz. Abaixo temos um LDR e sua
representaç¸ã˜o em circuitos. Um projeto envolvendo um LDR como um sensor de luz
se encontra na Sec. 7.2.

Figura 6.19: LDR e sua representaç¸ã˜o em circuitos eletrôˆnicos.

6.6.6 Relé´s
Oreléé́
úmachaveeletrôˆnica.Nessedispositivo,basicamente,algumasportaspodemserchaveada
s (istoé´,tersuatensãõreguladaouem0Vouemumatensãõmá
´xima)dependendodatensãõem uma terceira porta.
Para ilustrar o seu funcionamento, usaremos o relé´ de um canal de 5 V em um projeto
onde controlaremos a luz de dois LED’s. Esse relé´ suporta uma corrente má´xima de
10 A e uma tensãõ má
´ximade240Vemcorrentealternada,epossuiseisportasdetensãõ,conformemostraatabela
e
a figura abaixo. Duas dessas portas (+/
−)sãõdealimentaç¸ãõparaoseufuncionamento,devendo
ser de 5 V para esse relé´. A porta S é´ a que é´ usada para o chaveamento das portas
NO e NC. Quando
aportaSestáémHIGH,aportaNOestáćomtensãõenquantoqueaportaNCestá
´sem.Quandoa
portaSestá
émLOW,astensõ˜esnasportasNOeNCseinvertem.NaportaCOMdeveserligadoo
positivo
portas NOque
e alimentará´
NC as portas NO e NC. Assim, se tivermos 220 V no COM, as
serãõchaveadas(digitalmente)entre0e220V.
6.6Maiscomponenteseletrôˆnicos 62

+/ − Alimentaç¸ã˜o em 5 V e terra
S Switch (chave)
COM Comum (Tensã˜o comum)
NO Normal Open (aberta normal)
NC Normal Closed (normal fechada)

Figura 6.20: Relé´ de um canal de 5 V. À` esquerda podemos ver +

as/ portas
− e S, e na direita, as
portas NO, COM e NC.

! As−portas
e COM+/podem (e normalmente sãõ) originadas de fontes externas ao Arduino.
AúńicaportaquedeveobrigatoriamenteserligadaaoArduinoéáS,podeondeochaveamento
é´feito.

Agora vamos ao projeto. Faremos dois LED’s acederem e apagarem de forma alternada. É´
claro que isso pode ser feito com duas portas digitais do Arduino operando de forma independente.
O que faremos aqui, entretanto, é´ usar apenas uma porta do Arduino (a 3) e um relé´ para chavear
astensõ˜esnosterminaisdosLED’s.Abaixopodemosveroesquemadasligaç¸õ˜es.Escolhemos
alimentar os LED’s com 3,3 V, indicado na ﬁgura pelo ﬁo laranja.

Figura 6.21: Esquema das ligaç¸õ˜es do Arduino com o relé´ e os LED’s. Desenhado no site
https://www.tinkercad.com.
6.6Maiscomponenteseletrôˆnicos 63

Abaixo temos o có´digo. Basta apenas colocar 0 (LOW) ou 5 V (HIGH) na porta 3 de forma
alternada, que o relé´ fará´ o resto, chaveando a tensã˜o nos terminais dos LED’s.
1 void setup()
2 {
3 pinMode(3, OUTPUT);
4 }
5
6 void loop()
7 {
8 digitalWrite(3, HIGH);
9 delay(1000);
10 digitalWrite(3, LOW);
11 delay(1000);
12 }

Figura 6.22: Arduino executando o có´digo acima.

6.6.7 Potenciôˆmetros
Opotenciôˆmetroé´resistorvariá´veldetrêˆsterminais,quepodeserajustadocomoauxı́
´liodeum
botãõgirante(verfiguraabaixo).Narealidade,quandoapenasdoisdosseusterminaissãõusa
dos, ele age como um simples resistor variá´vel (reostato), enquanto que quando todos
os trêˆs sãõ usados, eleagecomoumdivisordetensãõajustá´vel.
6.6Maiscomponenteseletrôˆnicos 64

Figura 6.23: Um potenciôˆmetro de 10 kΩ e sua representaç¸ã˜o em circuitos eletrôˆnicos.

Em um potenciôˆmetro de 10 kΩ, a resistêˆncia entre o pino central e o pino de uma das

extremidades varia entre 0 e 10 kΩ conforme o botãõ é´ girado. Dessa forma, é´ possı́´vel usar esse
dispositivo para obter uma saı́´da de tensãõ ajustá´vel quando conectamos uma tensãõ positiva em
um dos pinos das extremidades e o terra no pino da outra extremidade, enquanto usamos o pino
central como uma fonte de tensãõ que pode ser regulada. Assim, se usarmos 5 V e o terra nas
extremidades, teremos uma tensãõ ajustá´vel entre 0 e 5 V.
No projeto esquematizado abaixo usamos o raciocı́ńio discutido no pará´grafo anterior para
leratensãõgeradapelopinocentraldeumpotenciôˆmetroapartirdeumadasportasdeentrada
analó´gicadoArduino(escolhemosaA0).

Figura 6.24: Conexõ˜es entre o potenciôˆmetro, a matriz de linhas e as portas do Arduino. Desenhado
no site https://www.tinkercad.com.

O có´digo, que está´ discutido abaixo, é´ simples. Declaramos duas variá´veis (valor e tensao -
linhas 1 e 2) e habilitamos a porta A0 para entrada de dados (linha 7). Em seguida, armazenamos a
tensãõ lida pela porta A0 na variá´vel valor (linha 12) e convertemos para uma tensãõ entre 0 e 5
V, usando para isso a variá´vel tensao (linha 13). Por fim, mandamos imprimir o valor da variá´vel
tensao no monitor serial (linhas 15-17).
1 int valor;
2 float tensao;
3
4 void setup()
5 {
6 Serial.begin(9600);
6.6Maiscomponenteseletrôˆnicos 65

7 pinMode(A0, INPUT);
8 }
9
10 void loop()
11 {
12 valor = analogRead(A0);
13 tensao = float(valor)*5/1023;
14
15 Serial.print("Tensã˜o=");
16 Serial.print(tensao);
17 Serial.println(" V");
18 }

Figura 6.25: Arduino executando o có´digo acima.

6.6Maiscomponenteseletrôˆnicos 66

Figura 6.26: Conforme giramos o botã˜o do potenciôˆmetro, podemos observar a

tensã˜o sendo variada com o auxı́´lio do monitor serial.

6.6.8 PZTs
O PZT (ou piezo) é´ uma cerâˆmica que tem propriedades piezoelé´tricas. Esses
materiais sofrem expansãõquandoumatensãõelé´tricaé
áplicadasobreelee,deformainversa,geramtensãõquando eleé
´submetidoaumapressãõ.AbaixotemosumPZTtı́´picofacilmenteencontradonomercado.

Figura 6.27: PZT com ﬁos conectando seus terminais.

7. Projetos envolvendo Luz

Abordaremos aqui trêˆs projetos:

I Sincronizando LEDs

I Sensor de luminosidade com LDR’s

I Sensor de luminosidade fototransistores

I Controlando a luminosidade de um LED

7.1 Sincronizando LEDs

Nesse projeto vamos colocar cinco LEDs piscando em sincronia, da seguinte forma: o
primeiro LEDacenderá
énquantoosoutrosestarãõapagados.Emseguida,oprimeiroLEDapagaenquanto o
segundo acende, e assim sucessivamente, formando uma espéćie de propagaç¸ãõ da
luz entre os LEDs, mantendo apenas um LED aceso por vez.
Primeiramente vamos fazer as conexõ˜es entre os LEDs, a matriz de linhas e as portas
do Arduino. Como os LEDs sãõ independentes, precisaremos de 05 portas de saı́´da.
Escolheremos as portas 11, 9, 7, 5 e 2. Cada perna maior dos LEDs deve estar
conetado a uma dessas portas, mas as pernas menores podem compartilhar o mesmo
terra. Entãõ as conexõ˜es vãõ ficar como mostrado
na figura abaixo.
7.1 Sincronizando LEDs 68

Figura 7.1: Conexõ˜es entre os LEDs, a matriz de linhas e as portas do Arduino. Desenhado no site
https://www.tinkercad.com.
Agora vamos decidir como escrever o có´digo. Vamos definir como 200 ms o tempo no qual cada
LEDficarááceso.Entãõteremosnocó´digoaseguintelinhadecomando:inttempo=200;.
Osnú´merosdasportasserãõarmazenadosemumvetorde05componentesinteiras(verSeç¸ãõ
5.11.1), de forma que colocaremos no có´digo o comando int pino[5];. Para fazermos os LEDs
acenderem alternadamente, colocaremos os comandos digitalWrite(pino[k], HIGH);
e dentrodeumloopfor,deparadospelachamadada
digitalWrite(pino[k], LOW);
funç¸ãõ .Ocó´digocompletosegueabaixo.
delay()
1 int tempo = 200;
2 int pino[5];
3
4 void setup()
5 {
6 pino[0] = 11;
7 pino[1] = 9;
8 pino[2] = 7;
9 pino[3] = 5;
10 pino[4] = 2;
11
12 for(int k=0; k<=4; k++)
13 {
14 pinMode(pino[k], OUTPUT);
7.2 Sensor de luminosidade com um LDR 69

1 }
5 }
1
6 void loop()
1 {
7 for(int k=0; k<=4; k++)
1 {
8 digitalWrite(pino[k], HIGH);
1 delay(tempo);
9 digitalWrite(pino[k], LOW);
2 }
0 }
2
1
2
2
2
3
2
4
2
5
2
6

Figura 7.2: Arduino executando o có´digo acima.

Exercı́ćio 7.1 Nesse projeto fizemos os LEDs acenderem alternadamente, mas apenas em um
sentido. Modifique o có´digo para observar o pulso de luz percorrer o LED nos dois sentidos de
forma alternada, isto é´, primeiro da esquerda para a direita, depois da direita para a esquerda, e
assim por diante.

7.2 Sensor de luminosidade com um LDR

Nesse projeto faremos um sensor de luminosidade com o auxı́´lio de um LDR (esse
dispositivo foi abordadonaSeç¸ãõ6.6.5).ComooLDRé
´basicamenteumresistordependentedaluminosidade, adiferenç¸adepotencialelé
´tricoentreseusterminaisvariadependendodaintensidadedaluzque incide sobre ele.
Entãõ a ideia aqui é´ usar uma das portas de entrada analó´gica (como a A1) para
leratensãõemumdeseusterminais,tendocomoreferêˆnciaoterra.Essatensãõlidaserá
´,portanto, proporcional à` intensidade da luz incidente no LDR.
7.2 Sensor de luminosidade com um LDR 70

Naturalmente, precisamos de um resistor para ser ligado em sé´rie com o LDR. Um dos
terminais
do resistor será´ ligado no terra (tensãõ 0) e o outro na porta A1 (tensãõ variá´vel,
dependendo da luz que incide no LDR). A figura abaixo ilustra as conexõ˜es. Uma
escolha importante é´ o valor do resistor, que dará´ a sensibilidade do sensor. Tenha
em mente que o LDR usado nesse projeto possui uma resistêˆncia de
∼ 50 kΩ na luz ambiente, e de ∼ 0 kΩ sob a luz de uma lanterna, de forma que
oidealé´queoresistortenhaalgunskΩderesistêˆncia.Escolhemosportantoumresistorde
≈ 2 kΩ.

Figura 7.3: Conexõ˜es entre os LEDs, a matriz de linhas e as portas do Arduino. Desenhado no site
https://www.tinkercad.com.

Ocó´digodesseprojeto,queé´bemsimples,segueabaixo.Basicamente,atensã˜olidanaporta
A1é´armazenadanavariá´velvalor(linha12)e,nalinha13,ovalorarmazenadonessavariá´velé´
exibida no monitor serial.
1 int porta = A1;
2 int valor;
3
4 void setup()
5 {
6 Serial.begin(9600);
7 pinMode(porta, INPUT);
8 }
9
10 void loop()
11 {
12 valor = analogRead(porta);
13 Serial.println(valor);
14 }
7.3 Sensor de luminosidade com um fototransistor 71

Figura 7.4: Arduino executando o có´digo acima.

Exercı́ćio 7.2 Modifique o circuito acima para mudando o resistor por um potenciôˆmetro, de
forma que esse projeto possa funcionar em todos os ambientes mediante ajuste nesse componente.
Exercı́ćio 7.3 Modifique o có´digo e o circuito acima para incluir um LED, que deve acender se o
ambiente estiver escuro e apagar se o ambiente estiver claro. Como “claro” e “escuro” sãõ bastante
relativos,vocêˆdevedecidirquandoumambientepodeserconsideradoclaroouescuro(dica:crie
uma variá´vel para decidir entre a interface claro/escuro).

7.3 Sensor de luminosidade com um fototransistor

Agora faremos um projeto de um sensor de luminosidade usando o fototransistor
PT334-6C da Everlight(verFig.7.5).Comoeleéúmfototransistordesilı́
ćio,suafaixadeoperaç¸ãõestáéntre 400 e 1100 nm, com o pico em 940 nm, de forma
que ele pode ser usado para detecç¸ãõ de luz visı́´vel.

Figura 7.5: Fototransistor PT334-6C (à` esquerda) e sua sensibilidade espectral (à` direita). Fonte:
datasheet em http://www.everlight.com/file/productfile/pt334-6c.pdf.
7.3 Sensor de luminosidade com um fototransistor 72

Figura 7.6: Conexõ˜es entre o fototransistor, a matriz de linhas, o resistor e as portas do Arduino.
Desenhado no site https://www.tinkercad.com.

Abaixo temos o esquema das ligaç¸õ˜es. Basicamente colocamos o fototransistor em

sé´rie com
um resistor de 2,7 kΩ, com a perna menor do fototransistor conectado na porta de 5 V
do Arduino e o terminal do resistor no terra. Entre o resistor e o fototransistor lemos a
tensã˜o na porta A0.
E abaixo temos o có´digo, que é´ bem simples. O valor lido pela porta A0 é´
1 int tensao;
armazenado na
2
variá´veltensaoeposteriormenteimpressanomonitorserial.
3 void setup ()
4 {
5 pinMode(A0, INPUT);
6 Serial.begin(9600);
7 }
8 void loop ()
9 {
10 tensao = analogRead(A0);
11 Serial.println(tensao);
12 delay(100);
13 }
7.4 Controlando a luminosidade de um LED 73

Figura 7.7: Arduino executando o có´digo acima.

7.4 ControlandoaluminosidadedeumLED
Neste projeto vamos controlar a luminosidade de um LED usando uma das portas PWM
do Arduino. Conforme visto na Seç¸ãõ 5.9.2, essas portas geram uma tensãõ
modulada em uma dada frequêˆncia. Ainda que a amplitude de tensãõ continue sendo
5 V, a tensãõ mé´dia varia conforme variamos a largura dos pulsos. Em altas
frequêˆncias, isto é´, acima de
∼ 60 Hz, o olho humano nãõ
consegue distinguir entre um LED aceso ou apagado, de forma para nó´s o LED estará´
sempre
aceso.Asensaç¸ãõdeluminosidadedoLEDseraproporcionalà`tensãõmé
´diaentreosterminaisdo
dispositivo.
Esseprojetoééxtremamentesimples.BastaligarosterminaisdoLEDemumaportadesaı́´da
PWM (vamos escolher a 11) e o terra. Vamos fazer as ligaç¸õ˜es diretamente no
Arduino, como
mostrado na figura abaixo.

Agora vem a parte do có´digo, que está´ mostrado abaixo. Vamos usar Sa efunç¸ã˜o
rial.parseInt()
para ler um inteiro que o usuá´rio vai digitar e armazenar na variá´vel valor (linha 18),
converter o range dessa variá´vel de 0 a 100 para 0 a 255 (que corresponde a 0 - 5 V,
linha
P WM 23) e jogar na porta
(linha 24).
1 int valor;
7.4 Controlando a luminosidade de um LED 74

2 int brilho;
3 int porta = 11;
4
5 void setup()
6 {
7 pinMode(porta, OUTPUT);
8 Serial.begin(9600);
9
1 S e r i a .lp r i n t l n ( " D i g i t e u m v a l o r e n t r e 0 ( b r i l h o m ı́´ n i m o ) e 1 0 0
0 ( b r i l h o m á ´ x i m o ) : " ) ;
S e r .ip
arl i n t l n ( ) ;
1 }
1
1 void loop()
2 {
1 if (Serial.available() > 0)
3 {
1 valor = Serial.parseInt();
4
1 Serial.print("Valor lido: ");
5 Serial.println(valor);
1
6 brilho = valor*2.55;
1 analogWrite(porta, brilho);
7 }
1 }
8
Exercı́ćio 7.4 Modifique o có´digo acima para fazer a luminosidade do LED variar
1
periodicamente com o tempo. Dica: use a uma funç¸ãõ perió´dica para isso.
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
8. Projetos envolvendo Temperatura

Neste capı́´tulo apresentaremos projetos envolvendo temperatura e calor:

I Medindo temperatura com o Sensor LM35

I Medindo temperatura com o Sensor DS18B20

I Medindo umidade

8.1 MedindotemperaturacomoSensorLM35
Este projeto faz uso do sensor de temperatura LM35 (ver figura abaixo). O LM35 é´ um
sensor de baixo custo; suas especificaç¸õ˜es téćnicas estãõ mostradas na tabela
abaixo:

Figura 8.1: Sensor de temperatura LM35.

Tensãõdealimentaç¸ãõ:
4a30V
Faixademediç¸ãõ: -55 oC a 150
Precisãõ: oC ±0,5
Corrente: menor que 60
Fator de escala: µA 10 mV por
oC
Tabela 8.1: Fonte:Datasheetdo sensor LM35: h t t p : / / w w w . t i . c o m / l i t / d s / s y m l i n k /
lm35.pdf.
8.1 Medindo temperatura com o Sensor LM35 76

Há´ dois modos de operar esse sensor. No modo bá´sico, que é´ o que usaremos aqui, o pino VS
(ver figura 8.2) deve ser conectado a uma tensãõ entre 4 e 20 V, o pino VOUT é´ o pino de dados
(que no nosso caso, conectaremos a uma das portas de entrada analó´gica do Arduino) e o pino
GND ao terra. Esse modo de operaç¸ãõ permite um range de temperatura entre 2 e 150 oC. O outro
modo possui um range maior, poré´m necessita de um resistor especı́´fico para operar. Com essas
informaç¸õ˜es,fizemosasconexõ˜esqueestãõilustradasnafigura8.3:opinoVSfoinaportade5V,
o pino VOUT foi em uma porta analó´gica (escolhemos a A2) e o pino GND foi em uma porta GND
do Arduino.

Figura 8.2: Terminais do sensor LM35. Note que essa é´ uma visãõ de baixo. VS,
VOUT e GND se referemà`tensãõdealimentaç¸ãõ,tensãõdesaı́
´da(dados)eaoterra,respectivamente.Fonte:Texas
Instruments - http://www.ti.com/lit/ds/symlink/lm35.pdf.

Figura 8.3: Conexõ˜es entre os terminais do sensor LM35DZ, a matriz de linhas e as

portas do Arduino. Desenhado no site https://www.tinkercad.com.
Agora passemos ao có´digo, que é´ relativamente simples. Basta habilitar a porta A2

para entrada
de
lidadados (INPUT) e armazenar em uma variá´vel (criamos a variá´vel valor) a tensãõ
pelo pino
VOUT por meio da funç¸ãõ analogRead(). O úńico trabalho é´ a conversãõ da

tensãõ lida em
temperatura.
para cada 1 oC Pelo
dedatasheet, sabemos que a tensãõ de saı́´da aumenta em 10 mV
temperatura que aumenta. Sabemos, també´m, que o zero da funç¸ãõ analogRead()
corresponde
a 0 V e 1023 corresponde a 5 V. Assim, a conv

(ersãõentre)tensãõetemperaturaé´dadapelafó´rmula100×5temperatura=×tensãõ1023
Assim, apresentamos abaixo o có´digo.
8.2 Medindo temperatura com o Sensor DS18B20 77

1 int porta = A2;

2 int tempo = 1000;
3 int valor;
4 float temperatura;
5
6 void setup()
7 {
8 Serial.begin(9600);
9 pinMode(porta, INPUT);
10 }
11
12 void loop()
13 {
14 valor = analogRead(porta);
15 temperatura = float(valor)*100*5/1023;
16
17 Serial.print("Temperatura = ");
18 Serial.print(temperatura, 1);
19 Serial.println(" oC");
20 delay(tempo);
21 }

Figura 8.4: Arduino executando o có´digo acima.

Exercı́ćio 8.1 Introduza um LED no circuito acima e faç¸a uma modificaç¸ãõ no có´digo para que o
LED acenda quando a temperatura medida ultrapasse 45oC.

8.2 MedindotemperaturacomoSensorDS18B20
Este projeto faz uso do sensor de temperatura DS18B20 (ver ﬁgura abaixo). Esse
sensor é´ baseado no chip DS18B20, e possui as seguintes especiﬁcaç¸õ˜es
relevantes:
8.2 Medindo temperatura com o Sensor DS18B20 78

Tensãõdealimentaç¸ãõ:
3a5,5V
Faixademediç¸ãõ: -55 oC a 125 oC
Precisãõ: ±0,5 oC entre -10 oC e
Fio vermelho: 85 oC Alimentaç¸ãõ
Fio preto: Terra
Fio amarelo: Dados

Figura 8.5: Sensor de temperatura DS18B20.

Mais detalhes podem ser consultados em seu datasheet

h tno
t psite
://datasheets.maximintegrated.
com/en/ds/DS18B20.pdf.
Asconexõ˜essãõrelativamentesimples.Comomostradonatabelaacima,ofiopretodeveirno
terra (GND), o fio vermelho na alimentaç¸ãõ em 5 V e o fio amarelo em uma porta de saı́´da de tensãõ
digital (escolhemos a 10). Entre os fios amarelo e vermelho deve estar conectado um resistor de
4,7 kΩ (colocamos dois em sé´rie, sendo umkΩ
≈ 3,7 de e outro de ≈ 1,0 kΩ). Abaixo temos uma
ilustraç¸ãõcomessasconexõ˜es.

Figura 8.6: Conexõ˜es entre os ﬁos do sensor DS18B20, a matriz de linhas, os

resistores e as portas do Arduino. Desenhado no site https://www.tinkercad.com.
8.2 Medindo temperatura com o Sensor DS18B20 79

Já´ a parte do có´digo é´ bem mais complicada. O chip DS18B20 se comunica com o
Arduino via duasbibliotecas:aOneWire.hea
D a l l a s T e m p e r a t u r.ConformemencionadonaSeç¸ãõ
e.h
5.10,
h t t pessas
: / / w wduas
w . hbibliotecas
a c k t r o n idevem
cs.com ser/ cbaixadas
ode/ (
e
DallasTemperature.zip
h t t p ): /e/ w
colocadas
w w . p j r na
c . cpasta
o m / tde
e ebibliotecas
nsy/ardu doi nArduino
o _ l i b rem
a r iseu
e s / computador.
O n e W i r e .Essas
z i p duas
bibliotecas trabalham em conjunto em dispositivos feitos pela Maxim/Dallas, como
sensores de temperatura e botõ˜es e memó´ria.
Abaixo mostramos o có´digo. As instruç¸õ˜es dentro da funç¸ãõ void servem para obter
o
endereç¸odosfiosdosensordetemperatura.
1 #include <OneWire.h>
2 #include <DallasTemperature.h>
3
4 int porta = 10; //Porta do fio amarelo (dados)
5 i n t t e m p o = 2 0 0 0 ; / / t e m p o d e a t u a l i z a ç ¸ ã ˜ o d a t e m p e r a t u r a
6
7 / / I n s t r u ç ¸ õ ˜ e s l i g a d a s à ` s b i b l i o t e c a s a c i m
8 a OneWire oneWire(porta);
9 DallasTemperature sensors(&oneWire);
10 DeviceAddress sensor1;
11
12 void setup()
13 {
14 Serial.begin(9600);
15
16 sensors.begin();
17 Serial.println("Localizando sensor DS18B20 ...");
18 if (!sensors.getAddress(sensor1, 0))
19 S e r i a l . p r i n t l n ( " S e n s o r n ã ˜ o e n c o n t r a d o ! " ) ;
20 S e r i a l . p r i n t ( " E n d e r e ç ¸ o d o s e n s o r : " ) ;
21 enderecoSensor(sensor1);
22 Serial.println();
23 Serial.println();
24 }
25
26 / / f u n ç ¸ ã ˜ o q u e e s c r e v e o e n d e r e ç ¸ o d o s e n s o r
27 void enderecoSensor(DeviceAddress
28 deviceAddress) {
29 for (int k=0; k<8; k++)
30 {
31 if (deviceAddress[k]<16) Serial.print("0");
32 Serial.print(deviceAddress[k], HEX);
33 }
34 }
35
36 void loop()
37 {
38 sensors.requestTemperatures();
39 float temperatura = sensors.getTempC(sensor1);
40
8.3 Medindo umidade 80

4 Serial.print("Temperatura: ");
1 Serial.print(temperatura, 1);
4 Serial.println(" oC");
2
4 delay(tempo);
3 }
4
4
4
5
4
6

Figura 8.7: Arduino executando o có´digo acima.

Exercı́ćio 8.2 Introduza um LED no circuito acima e faç¸a uma modificaç¸ãõ no có´digo para que o
LED acenda quando a temperatura medida ultrapasse 45oC.

8.3 Medindoumidade
Neste projeto usaremos o sensor de umidade higrôˆmetro para monitorar a umidade de
um determinado meio (ver Fig. 8.8). Ele consiste de uma sonda e de um chip
comparador, modelo LM393, que possui dois comparadores de tensã˜o independentes,
conformes especiﬁcaç¸õ˜es do seu datasheet.
8.3 Medindo umidade 81

Figura 8.8: Sensor de umidade, contendo o chip comparador (à` esquerda) e a sonda (à` direita).

O esquema das ligaç¸õ˜es é´ bem simples (ver Fig. 8.9). A dupla de pinos do chip comparador
deve ser ligado aos terminais da sonda, enquanto que trêˆs do conjunto de quatro pinos devem ser
ligadosà`sportasdaplacaArduino,seguindoanomenclaturaqueé´bastanteó´bvia:oVCCéópino
positivodealimentaç¸ãõ(5V),GNDéóterraeA0éópinoparaleituradosdados.

Figura 8.9: Diagrama das ligaç¸õ˜es entre o sensor de umidade e o Arduino.

Ocó´digotambé´mééxtremamentesimples,comopodeservistoabaixo.Basicamente,aleitura
é´feitacomafunç¸ãõanalogRead()eposteriormentearmazenadanavariá´velvalor.Emseguida,
é´ feita uma conversãõ para que o intervalo da variá´vel valor (0 a 1023, devido ao retorno da funç¸ãõ
analogRead()) seja convertido em um intervalo de 0 a 100, com esses extremos denotando
umidade nula e altı́´ssima umidade, respectivamente. Como pôˆde ser observado na linha 13, houve
umainversãõdovalorlido,porqueosensoré´programadodefá´bricapararetornarumvaloralto
em baixa umidade e um valor baixo em alta umidade.

! Há´ duas formas de regular a sensibilidade da leitura da umidade. A primeira é´

usando o
potenciôˆmetrodochipcomparador,quepodeserajustadocomumachaveestrela.Aoutr
a formaé´alterandoovalor100dalinha13doprograma.

1 int valor;
2 float umidade;
3
4 void
5 setup() {
8.3 Medindo umidade 82

6 pinMode(A0,
7 INPUT);
8 } Serial.begin(9600)
9 ;
10 void loop()
11 {
12 valor = analogRead(A0);
13 umidade = 100-valor*100.0/1023.0;
14
15 Serial.print("Umidade: ");
16 Serial.println(umidade);
17 }

Figura 8.10: Arduino executando o có´digo acima.

9. Mais opç¸ õ˜es de saı́ ´da de dados

Abordaremos aqui os seguintes dispositivos:

I Monitor LCD

I Leitor de cartã˜o SD

9.1 OmonitorLCD
O monitor LCD, ou display LCD, é´ uma excelente alternativa ao uso do monitor serial,
visto que possibilita uma independêˆncia quase completa do Arduino em relaç¸ã˜o ao
computador. Neste projeto, usaremos um dos mais simples displays LCD, com
tamanho de 16
× 2 caracteres (16
colunas e duas linhas - ver ﬁgura abaixo).

Figura
×2. 9.1: Monitor LCD tamanho 16

Esse display possui um total de 16 pinos, sendo que neste projeto usaremos apenas 12 deles. Na
tabela abaixo podemos ver as funç¸õ˜es desses pinos. Basicamente há´ dois pinos de alimentaç¸ã˜o
em 5 V junto com dois pinos terra, um pino que controla a leitura e a escrita de dados, oito pinos
responsá´veispelos8bitsdoscaracteresaseremescritosnateladoLCDeumpinoresponsá´vel
pela regulagem do contraste da tela.

Pino VSSVDD V0 RS RW E A K
Funç¸ã˜o Terra 5V Contraste Registro Leitura/escrita Habilitar 5V Terra
9.1 O monitor LCD 84

Pino D0 D1 D2 D3 D4 D5 D6 D7
Funç¸ã˜oBit0Bit1Bit2Bit3Bit4Bit5Bit6Bit7

Com base nessas informaç¸õ˜es, mostramos abaixo as conexõ˜es necessá´rias para exibir um texto
simples no display LCD. Note que colocamos um potenciôˆmetro conectado ao pino V0 para uma
regulagem do contraste do display (o que nã˜o é´ obrigató´rio). Alé´m disso, deixamos metade dos
pinos dos bits (D0 a D3) desconectados.
I VSS-GND
I VDD-5V

I V0 - Pino central de um potenciôˆmetro

I RS - Porta 12

I RW-GND
I E - Porta 11

I D0 - Sem conexã˜o
I D1 - Sem conexã˜o

I D2 - Sem conexã˜o
I D3 - Sem conexã˜o

I D4 - Porta 5
I D5 - Porta 4

I D6 - Porta 3
I D7 - Porta 2

I A-5V
I K-GND

Abaixo mostramos uma ilustraç¸ã˜o dessas conexõ˜es.

9.1 O monitor LCD 85

Figura 9.2: Conexõ˜es entre o monitor LCD, a matriz de linhas, o potenciôˆmetro e as

portas do Arduino. Desenhado no site https://www.tinkercad.com.

Abaixo mostramos o có´digo. Para trabalhar com o display LCD é´ necessá´rio o uso da

biblioteca
LiquidCrystal.h, que é´ padrãõ do Arduino (nãõ precisa ser instalada). Nas linhas 3-8
escolhemos as portas do Arduino e na linha 10 chamamos a funç¸ãõ LiquidCrystal (que
está´
contida
funç¸ãõna biblioteca mencionada). Dentro da funç¸ãõ setup() temos 3 chamadas de
diferentes: lcd.begin(), lcd.print() e lcd.setCursor(). As duas
1 p# ri n
imc leuid
r aes <sLãi ˜
qou i d C r y s t a l . h >
2 equivalentesà`sjáćonhecidasfunç¸õ˜esSerial.begin()eSerial.print()(verSeç¸ãõ5.5).
3 int RS = 12;
Jááú´ltimaserveparaposicionarocursoremumdadopontododisplay.Fizemosusodelapara
4 i n t E Nem= a1 1string
centralizar
coluna ; “DEFIJI - UNIR” na linha de baixo da tela, deslocando a linha e a
5 iuma
nt D 4 = 5 ;
unidade em relaç¸ãõ ao ponto (0, 0) - ver figura 9.3.
6 int D5 = 4;
7 int D6 = 3;
8 int D7 = 2;
9
10 LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
11
12 void setup()
13 {
14 lcd.begin(16, 2);
15 lcd.print("Curso de Arduino");
16 lcd.setCursor(1, 1);
17 lcd.print("DEFIJI - UNIR");
18 }
19
9.2 O leitor de cartãõ SD 86

2 void loop()
0 {
2
1 }
2
2
2
3

Figura 9.3: Arduino executando o có´digo acima.

Exercı́´cio 9.1 Modiﬁque o có´digo acima para que o Arduino crie uma palavra (a sua
escolha) que se mova no display LCD.

9.2 OleitordecartãõSD
Se com o display LCD conseguimos uma certa independêˆncia de um computador, com
o leitor de cartãõ conseguimos uma razoá´vel independêˆncia de uma pessoa por
perto. Isso porque um dos usos do leitor de cartãõ é´ gravar dados que necessitem de
um longo perı́ódo para serem finalizados, como, por exemplo, a coleta da temperatura
a cada hora do dia em uma cidade.
Neste projeto usaremos o MicroSD Card Adapter, mostrado na figura abaixo. Ele possui
seis pinos, sendo dois para alimentaç¸ãõ (5 V) e quatro para transferêˆncia de dados.
O esquema das ligaç¸õ˜es,mostradonatabelaabaixo,segueabibliotecaSD.h,queé
´padrãõdoArduinoeportanto nãõ necessita de instalaç¸ãõ. Das quatro portas de
dados, apenas a porta CS pode ser escolhida para
ser diferente; todas as outras devem seguir a tabela.
PinodoCartãõ MISOMOSI SCK CS
PortadoArduino12 11 SCK13 digitalàèscolha
9.2 O leitor de cartãõ SD 87

Figura 9.4: Adaptador para cartã˜o micro SD usado no projeto.

Abaixomostramosodiagramadasligaç¸õ˜es.

Figura9.5:Diagramadasligaç¸õ˜esentreoAdaptadordecartã˜omicroSDeasportasdoArduino.

Agora vamos ao có´digo. Para trabalharmos com arquivos, precisamos do seu nome interno
e externo. O nome interno é´ usado apenas dentro do có´digo, enquanto que o externo é´ o nome
do arquivo onde os dados serãõ lidos/gravados, por exemplo, texto.txt. Para o nome interno
usamos a sintaxe abaixo, que deve ser declarado, em geral, fora das funç¸õ˜es setup() e loop():
1 File nome-interno;
ParahabilitarousodocartãõSD,usamosainstruç¸ãõabaixo:
1 SD. b e g i n ( 1 0 ) ;
que tem o papel aná´logo aoSde
e r i a l . b e g i n ( ) para o monitor serial.

9.2.1 Gravando dados no cartã˜o

Para gravar dados, primeiramente habilitamos o arquivo para escrita, conforme a sintaxe abaixo:
1 SD. o p e n ( " n o m e - e x t e r n o . e x t e n s ã ˜ o " ,
nome-interno-escolhido =
FILE_WRITE);
onde precisamos do nome interno declarado previamente e do nome externo do
arquivo. Em seguida, as informaç¸õ˜es já´ podem ser gravadas no arquivo com a
sintaxe abaixo:
1 n o m e - i n t e r n o - e s c o l h i d o . p r i n t l n ( " A l g u m t e x t o o u v a r i á ´ v e l . . . " ) ;
Por ﬁm, o arquivo precisa ser fechado de acordo com a seguinte sintaxe:
9.2 O leitor de cartã˜o SD 88

1 arquivo.close();
Abaixo mostramos o có´digo completo, que cria um arquivo com nome externo texto.txt e
gravaneleasfrases“OláÁrduino!”e“Funciona!”.Apó´sexecutarocó´digo,confiraoconteú´do
do arquivo no seu computador, conectando o cartãõ de memó´ria nele. Deverá´ haver o arquivo
.t e x t o . t x t
1 # i n c l u d e SD. h >
2
<
3 File arquivo;
4
5 void setup()
6 {
7 Serial.begin(9600);
8 SD.begin(10);
9
10 arquivo = SD.open("texto.txt", FILE_WRITE);
11 arquivo.println(" ");
12 a r q u i v o . p r i n t l n ( " O l á ´ A r d u i n o ! " ) ;
13 arquivo.println("Funciona!");
14 arquivo.close();
15 }
16
17 void
18 loop(void) {
19
20 }

9.2.2 Lendo dados do cartã˜o

Algumas vezes precisamos ler os dados previamente gravados no cartãõ, e em
seguida exibi-los no monitor serial ou em um display LCD. O có´digo completo para a
leitura de um arquivo chamada dados.txt se encontra abaixo. Antes de tudo, é´ preciso
criar um arquivo no cartãõ SD com o nome dados.txt, e é´ preciso inserir algum conteú
´do nele. Dessa vez, escolhemos o nome interno arq para o arquivo. Observe que o có
´digo para a leitura é´ um pouco mais elaborado, visto que precisamos ler caractere por
caractere. Assim, os comandos das linhas 12-15 escrevem no monitor serial os
caracteres lidos enquanto ainda existirem caracteres no arquivo.
1 # i n c l u d e <SD. h >
2
3 File arq;
4
5 void setup()
6 {
7 Serial.begin(9600);
8 SD.begin(10);
9
10 arq= SD. o p e n ( " d a d o s . t x t " ) ;
11
12 while (arq.available())
13 {
14 Serial.write(arq.read());
9.3O shield wifi 89

1 }
5
1 arq.close();
6 }
1
7 void
1 loop(void) {
8
1 }
9
2
0
2
1
2
2
2
3

Figura 9.6: Arduino executando os có´digos acima.

9.3O shield wiﬁ

9.4O shield bluetooth
10. Projetos envolvendo Movimento

Abordaremos aqui os seguintes projetos:

I Medindo distâˆncia entre objetos

I Gerando sons com o PZT

I Movimento com o motor de passo

10.1 Medindodistâˆnciaentreobjetos
Este projeto usa o sensor de movimento ultrassôˆnico modelo HC-SR04 (ver Fig. 10.1).
Segundo o seu datasheet, ele funciona com base em uma alimentaç¸ãõ em 5 V e é´
capaz de medir desde 2 cm até´ 4mdedistâˆncia,comincertezade3mm.Seuprincı́
´piodefuncionamentoé´razoavelmentesimples: um emissor (cilindro esquerdo, T) emite
pulsos sonoros curtos (
∼ 10 µs) em uma frequêˆncia de 40
kHz (ultrassom) que batem no objeto a ser medido e sãõ refletidos, sendo captados
pelo receptor
(cilindro
m/s, e doesquerdo, R). A distâˆncia é´ medida atravé´s da velocidade do som no ar, 340
tempo gasto no percurso.

Figura 10.1: O shield ultrassôˆnico modelo HC-SR04.

Abaixo temos o diagrama das ligaç¸õ˜es. O pino VCC deve ser ligado na porta de 5 V do Arduino,
o G no
N Dterra e pinos Trig e Echo em duas portas de saı́´da digital.
10.1 Medindo distâˆncia entre objetos 92

Figura 10.2: Conexõ˜es entre o shield ultrassôˆnico, a matriz de linhas e as portas do Arduino.
Desenhado no site https://www.tinkercad.com.

Ocó´digo,mostradoabaixo,fazusodabibliotecaUltrasonic.h,quedeveserbaixadae
instalada na pasta libraries do Arduino, conforme instruç¸õ˜es da Sec. 5.10. Primeiramente
definimosasportasdoArduinoqueserãõconectadascomospinosTrigeEcho,oqueé´feito
com a chamada da funç¸ãõ ultrasonic(). Em seguida, o intervalo de tempo decorrido entre a
emissãõeadetecç¸ãõdospulsosultrassôˆnicosé´medidoatravé´sdafunç¸ãõultrasonic.timing
(, )que por fim é´ usada para medir a distâˆncia. O có´digo completo segue abaixo.
1 #include <Ultrasonic.h>
2
3 int portaTrig = 7;
4 int portaEcho = 6;
5 int tempo;
6 float distancia;
7
8 Ultrasonic ultrasonic(portaTrig, portaEcho);
9
10 void setup()
11 {
12 Serial.begin(9600);
13 }
14
15 void loop()
16 {
17 tempo = ultrasonic.timing();
18 distancia = ultrasonic.convert(tempo, Ultrasonic::CM);
19
20 S e r i a l . p r i n t ( " D i s t â ˆ n c i a = " ) ;
21 Serial.print(distancia);
22 Serial.println(" cm");
23 delay(500);
24 }
10.2 Gerando sons com o PZT 93

Figura 10.3: Arduino executando o có´digo acima.

Exercı́ćio 10.1 Inclua um LED no circuito acima e modifique o có´digo para que esse
LED acenda toda vez que um objeto ficar a menos de 5 cm de distâˆncia do sensor.

10.2 Gerando sons com o PZT

Neste projeto usaremos um PZT (ver Sec. 10.2) para gerar sons com o auxı́´lio do
Arduino. A ideia é´ inserir uma tensãõ modulada nos terminais do PZT, de forma que a
sua vibraç¸ãõ gere uma onda
depressãõquesepropaguenoar,chegandoaosnossosouvidos.Paraisso,tenhaemmenteq
uea audiç¸ãõhumanaé
ćapazdedetectarsonsentre20Hz(grave,fronteiracomoinfrassom)e20kHz (agudo,
fronteira com ultrassom) de frequêˆncia.

Figura 10.4: PZT com ﬁos conectando seus terminais.

Aideiaé´usarumpotenciôˆmetroparasintonizarafrequêˆnciadosom.Oesquemadasligaç¸õ˜es
segue na Fig. 10.5. Os terminais do PZT sã˜o conectados nas portas 13 e GND do Arduino, e um
10.2 Gerando sons com o PZT 94

potenciôˆmetroéúsadoparacolocarumatensãõespecı́´fica(entre0e5V)naportadeentrada
analó´gica A5. A tensãõ nessa porta é´ usada para que possamos escolher a
frequêˆncia da modulaç¸ãõ
datensãõnoPZT,deformaaproduzirdiversostiposdesons.Ocó´digocompletoestá
´mostrado abaixo.

Figura 10.5: Esquema das ligaç¸õ˜es do Arduino com o PZT (à` direita) e o potenciôˆmetro (à` esquerda).
Desenhado no site https://www.tinkercad.com.

Agora vamos ao có´digo, que é´ bastante simples. O valor da tensãõ lida pelo pino central
dopotenciôˆmetroéármazenadonavariá´velvalor,queéúsadacomoargumentodafunç¸ãõ
delayMicroseconds(). Dessa forma, é´ possı́´vel regularmos a frequêˆncia da modulaç¸ãõ
datensãõ.Comoafunç¸ãõanalogRead()retornaumvalorinteiroentre0e1023,afrequêˆncia
da onda sonora gerada vai estar compreendida entre 489 Hz e 500 kHz (inaudı́´vel), seguindo uma
funç¸ãõhiperbó´licacomoâˆngulodegirodopotenciôˆmetro.
1 int valor;
2
3 void setup()
4 {
5 pinMode(10, OUTPUT);
6 pinMode(A5, INPUT);
7 Serial.begin(9600);
8 }
9
10 void loop()
11 {
12 valor = analogRead(A5);
13 Serial.println(valor);
14
15 digitalWrite(10, HIGH);
16 delayMicroseconds(valor);
17 digitalWrite(10, LOW);
18 delayMicroseconds(valor);
19 }
10.3 Movimento com o motor de passo 95

Figura 10.6: Arduino executando o có´digo acima.

Exercı́ćio 10.2 Modifique o có´digo e as ligaç¸õ˜es acima para que um LED varie sua luminosidade
de acordo com a frequêˆncia da onda sonora emitida pelo PZT.
Exercı́ćio10.3Modifiqueocó´digoeasligaç¸õ˜esacimaparaoPZTgerarassetenotasmusicasem
sequêˆncia.Vocêˆpodeconsiderarqueassetenotascorrespondemasseguintesfrequêˆncias:264Hz
(dó´),297Hz(ré´),330Hz(mi),352Hz(fá´),396Hz(sol),440Hz(lá´)e495Hz(si).

10.3 Movimentocomomotordepasso
O motor de passo é´ um tipo de motor onde é´ possı́´vel controlar precisamente a
rotaç¸ãõ do balancete. Seu funcionamento parte do princı́´pio onde uma rotaç¸ãõ
completa (360o) é´ dividida em vá´rias partes iguais, que seria o “passo” do motor.
Assim, o passo corresponde ao âˆngulo mı́ńimo que o balancete pode girar, que varia
conforme as especificaç¸õ˜es do motor.
Nesse projeto usaremos o motor de passo 28BYJ-48 (em conjunto com o seu driver, ver
figura
10.7), cuja volta completa é´ composta por 2048 passos, dando um âˆngulo de
≈ 0,18o por passo.
10.3 Movimento com o motor de passo 96

Figura 10.7: Motor de passo modelo 28BYJ-48 (à` esquerda) e o driver controlador (à`
direita). O controle pelo Arduino é´ feito atravé´s dos pinos IN1 até´ IN4, que é´
passado ao motor de passo atravé´sdosoquetebranco.

Para controlar o motor de passo, usamos o driver baseado no microcontrolador

ULN2003. O
uso desse
inverter a driver é´ obrigató´rio principalmente porque o Arduino UNO nãõ é´ capaz de
tensãõentreseuspinos,deformaquenãõseriapossı́
´velfazeromotorgiraremdoissentidossem
ter queArduino
os do mudar o circuito a todo instante. O esquema das ligaç¸õ˜es dos seus pinos com
é´mostradonatabelaenafiguraabaixo,ondedecidimosusarasportas8a11.

IN1, IN2, IN3 e IN4 Portas digitais do Arduino

+
− /Alimentaç¸ã˜o(5Vem+eGNDem−)

Figura 10.8: Conexõ˜es entre o motor de passo, o driver e as portas do Arduino. Desenhado no site
https://www.tinkercad.com.

Agora vamos ao có´digo necessá´rio para controlar o motor de passo. Primeiramente precisamos
declarar a biblioteca Stepper.h, que é´ padrãõ do Arduino é´ portanto já´ está´ na sua pasta
libraries. Essa biblioteca trabalha em conjunto com a funç¸ãõ myStepper(). É´ nessa funç¸ãõ
quesãõdefinidasasquatroportasdigitaisdoArduinoquevãõcontrolaromotor.Asuasintaxeé´
1 S t e p p e r m y S t e p p e r ( p a s s o s - p o r - r e v o l u ç ¸ ã ˜ o , I N 1 , I N 3 , I N 2 , I N 4 ) ;
Assim, no có´digo abaixo escolhemos 500 passos por revoluç¸ãõ 8
e , 9 , 1 0 e 1 1 para
as portas serem ligadas à`s portas IN1, IN3, IN2 e IN4,
respectivamente.
10.3 Movimento com o motor de passo 97

Comafunç¸ãõsetSpeed()controlamosavelocidadedomotor,ecomafunç¸ãõstep()
controlamos a quantidade de passos que o motor deve dar. Dessa forma, o motor no có´digo abaixo
tem sua velocidade fixada em 60 e ele dá´ 1/4 de volta (giro de 90o) a cada 2 segundos.

! Afunç¸ã˜ostep()també´maceitanú
´merosnegativosemseuargumento.Nessecaso,omotor irá´girarnosentidooposto.

1 #include<Stepper.h>
2
3 Stepper myStepper(500, 8,10,9,11);
4
5 void setup()
6 {
7 myStepper.setSpeed(60);
8 }
9
10 void loop()
11 {
12 myStepper.step(512);
13 delay(2000);
14 }

Figura 10.9: Arduino executando o có´digo acima.

Exercı́ćio 10.4 Faç¸a uma modificaç¸ãõ no có´digo acima para que o motor dêˆ meia volta em um
sentido, espere 1 segundo, e depois dêˆ uma volta completa no outro sentido, esperando novamente
1 segundo. Deve fazer isso continuamente.

Exercı́ćio 10.5 Faç¸a uma modificaç¸ãõ no có´digo acima para que o motor dêˆ uma volta completa
com velocidade crescendo linearmente desde 0 até´ a sua velocidade má´xima.
Exercı́ćio 10.6 Faç¸a uma modificaç¸ãõ no có´digo e no circuito acima para que o motor dêˆ uma
volta completa e espere 1 segundo, repetindo o processo. Enquanto o motor estiver girando, um
LED deve ficar aceso.
11. Outras placas

11.1 Raspberry Pi
O Raspbetty Pi é´ na verdade um computador completo em uma placa com tamanho
aproximado do Arduino Uno R3, fundado na Inglaterra em 2012 pela Raspberry Pi
Foundation. Todos os componentes de um computador convencional estãõ soldados
na placa: processador, memó´ria RAM, entradas USB, HDMI, etc, e o sistema
operacional roda em um cartãõ memó´ria adquirido à` parte.Háúmasé
´riedeplacascompoderesdeprocessamentoepreç¸osdistintos,sendooRaspberry Pi 3 B+
(ver Fig. 11.1) o modelo mais recente e mais poderoso, lanç¸ado em 2018. Seu preç¸o
no site do revendedor oficial do Brasil é´ de R$ 279,00.

Figura 11.1: Raspberry Pi 3 B+.

11.1.1 OHardware
Seu hardware é´ o seguinte:

I Processador Broadcom BCM2837B0, com 64 bits em 1.4 GHz

11.1 Raspberry Pi 100

I Memó´ria 1GB LPDDR2 SDRAM

I Rede sem ﬁo 2,4 GHz e 5 GHz IEEE 802.11.b/g/n/ac

I Porta Ethernet (rede com ﬁo) Gigabit USB 2.0 em 300 Mbps

I 40 pinos GPIO

I 1 porta HDMI

I 4 portas USB 2.0

I Entrada para câˆmera e para tela sensı́´vel ao toque

I Porta de saı́´da de som

I Entradaparacartã˜omicroUSB

I Alimentaç¸ã˜o em 5 V/2,5 A

Os 40 pinos GPIO podem ser usados como entrada e saı́´da de dados, assim como no Arduino.
O mouse e o teclado podem ser conectados nas portas USB e um monitor pode ser conectado na
saı́´da HDMI.

! Como pode ser visto na Fig. 11.1, os pinos sã˜o “para fora”, e nã˜o para dentro
como no caso do Arduino Uno R3. Assim, é´ preciso ter um cuidado adicional com
curtos que podem ser ocasionados ao conectar dois desses pinos com algum
objeto metá´lico. Isso pode queima a placa.

11.1.2 Osoftware
Comojá
´mencionado,aplacaRasbperryrodaumsistemaoperacional(SO).Ossistemassuportados
sãõosseguintes:
I NOOBS – Como o nome já´ indica, é´ um sistema de fáćil instalaç¸ãõ e operaç¸ãõ,

I Raspbian indicado
para novatos.
I Snappy Ubuntu Core
– Rapsberry + Debian. Sistema operacional oﬁcial da placa.
I Windows 10 IOT Core
– Voltado para desenvolvedores.
I OSMC
– Windows 10 para IoT.
I LibreELEC
– Open Source Media Center. Sistema operacional para mı́´dia.
I PiNet

I RIC OS –Distribuiç¸ã˜onã˜oLinux.

I Weather Station

I IchogoJam RPi
11.1 Raspberry Pi 101

Ainstalaç¸ãõdoNOOBSé´bemsimples.BstabaixaroSOatravé´sdolink https://www.
raspberrypi.org/downloads/noobs/, que vem dentro de uma pasta zipada. Em seguida,
basta extraı́´-la, copiar o conteú´do para o cartãõ de memó´ria e ligar a placa, que deve
estar conectada ao mouse, ao teclado e ao monitor.
O SO NOOBS (Fig. 11.2) já´ vem com diversos programas voltados à` programaç¸ãõ e
ao ambienteacadêˆmico,alé´mdasuı́
´teLibreOfficeedealgunsjogossimples.Podemosdestacaro famoso software de
modelagem Mathematica (Fig. 11.3), o compilador gcc e diversas IDE’s para
programaç¸ãõ,comoScratch,PythoneJava.Há´també
´monavegadorCromiumeprogramaspadrãõ
paravisualizaç¸ãõdeimagens,vı́´deosearquivospdf.

Figura 11.2: NOOBS rodando no Raspberry, mas sendo visualizado pelo Windows
atravé´s de software de acesso remoto.
Nãõéńecessá´rianenhumapreparaç¸ãõparaacompilaç¸ãõdeprogramasescritosemC,já
gcc nome-do-arquivo.c
´que,
como mencionado, o sistema vem com gcc. Basta execuç¸ãõ dos comandos
- o n o m e - d o - e x e c u t á ´ v e l e . / n o m e - d o - e x e c u t á ´ v e l n o t e r m i n a l e
pronto (Fig. 11.4).
O Raspberry pode ser acessado remotamente, como mostrado na Fig. 11.2. Isso elimina
a
necessidade do mouse, do teclado e de um monitor, tornando a configuraç¸ãõ da placa
mais prá´tica.
11.1.3 Acendendo
O seedá´
acesso este apagando
por SSHum LED softwares como TeamViewer ou VNC Viewer, por
ou pelos
exemplo,
Nesse projeto simples, exemplificaremos o uso do Raspberry para executar um
ú´ltimojáínclusonoSO.ElepodeseracessadoemMenu
programa que acende e apaga um LED e intervalos → I n de
t e r1nsegundo,
et → VNC como
V i eno
w eprimeiro
r. Em
Sketch apresentado no Cap. 3. O Raspberry Pi, por ser um computador,
seguida, basta criar uma conta, instalar o VNC també´m no computador ou no tabletpode ser usado
e
para programar uma placa Arduino; entretanto, usaremos o pró´prio processador da
pronto, seu
placa Raspberry para isso.
Raspberry pode os
Conecte serterminais
acessadodetanto na rede
um LED em local como
dois fios em qualquer
jumper parte doemundo.
fêˆmea-fêˆmea, estes aos
terminais 6 e
12 da placa. Observe a numeraç¸ãõ das portas na Fig. /reffig11-5. Veja que, assim
como na placa do Arduino, as portas do Raspberry tem usos diferentes. Nãõ
entraremos em detalhes aqui, porque
11.1 Raspberry Pi 102

x = 4 + (3 cosv)sinu,y=4+(3+cosv)cosu,z=4+sinv
Figura 11.3: Superfı́´cies paramé´tricas
ex=8+(3+cosv)cosu,y=3+sin, vz+ = 3 4+ cosv)sinv,comambasasvariá
[0,2π], criadas no Mathematica. ( + ´veisnointervalo

Figura 11.4: Có´digo do Exemplo 5.19 sendo executado no Raspberry Pi, mas agora na
linguagem C. Abaixo temos a monitoraç¸ã˜o da temperatura do processador.
11.1 Raspberry Pi 103

todos os detalhes dessa placa daria assunto para outra apostila completa. Para esse
projeto, mbasta saber que a porta 6 terra e a porta 12 é´ uma GPIO.

2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40
1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39

Figura 11.5: Ordem dos pinos GPIO da placa Raspberry Pi 3B+.

À` respeito da programaç¸ãõ, a melhor opç¸ãõ no Raspberry é´ usar o Python, uma linguagem
simplesporé´mpoderosa,queéúmadasmaisusadasnomundoatualmente.Assim,abraoIDEdo
Python em Menu
→ Desenvolvimento → Python 3 (IDLE), dentro do SO da placa. No
menu File, clique em New File e lá´, insira o có´digo Python mostrado abaixo. Por fim, clique
e m→RRunu n Module para executar o có´digo. Outra opç¸ãõ é´ usar o terminal, inserindo o
có´digoemumeditordetexto,salvandocomonome-do-arquivo.pyedigitando,noterminal,
a i n s t r u ç ¸ ã ˜ o p y bt h
#Declaraç¸ãõda i bol n
i ont o
e cma e -da
do -arquivo.py.
GPIO
import RPi.GPIO as GPIO

#Declaraç¸ã˜oda biblioteca time

import time
GPIO.setmode(GPIO.BOARD)

# H a b i l i t a o pino 12 para s a i d a de dados

GPIO. setup (12 , GPIO.OUT)

#Aná´logo da funç¸ã˜o while() ou mesmo loop() do Arduino

w h( i1l e) :
#Gera 3,3 V no pino 12 aná´logodafunç¸ã˜odigitalWrite
GPIO.output(12, 1) −

#Aná´logoda funç¸ã˜o d e l a y ( )
time . sleep (1)

#Gera 0 V no pino 12
GPIO.output(12, 0)
11.2 ESP 8266 e ESP32 104

time . sleep (1)

Figura 11.6: LED acendendo e apagando.

11.2 ESP 8266 e ESP32

As ESP8266 e ESP32 sãõ pequenas placas microcontroladoras de baixo custo e baixo
consumo de energia, criadas e desenvolvidas pela empresa chinesa Espressif Systems.
A ú´ltima é´ a sucessora da primeira, apresentando mais performance e possuindo
bluetooth embutido, e ambas possuem wifi. Elassãõvoltadastantoparadispositivosmó
´veis,eletrôˆnicaeIoT,comotambé´mparaoambiente industrial, podendo trabalhar entre
−40o e 150oC. Elas possuem aplicaç¸õ˜es em reconhecimento de
voz,automaç¸ãõresidencialeindustrial,agriculturainteligente,medicinaemais.

Figura 11.7: Placa ESP8266.

A partir deste ponto focaremos na placa ESP8266. Suas especiﬁcaç¸õ˜es té´cnicas

sã˜o as seguintes: I

MicroprocessadorL10632de32bitsRISCXtensaDiamondStandard106Microcomclock
em 80 MHz
11.2 ESP 8266 e ESP32 105

I Memó´riaRAM(32kBinstruç¸õ˜es,32kBcachedeinstruç¸õ˜es,80kBdedadose16kBdo
sistema)

I Wiﬁ 802.11 b/g/n (2,4 GHz)

I 16 pinos GPIO

11.2.1 Instalaç¸ãõ-ESP8266
A ESP8266 pode ser programa usando o IDE do Arduino apó´s uma configuraç¸ãõ
simples. Primei- ramente, com o IDE do Arduino aberto, clique em Arquivo
→ P r e f e r ê ˆ n c i a s . N a j a n e l a q u e
abrir, procure o campo URLs Adicionais para Gerenciadores de
Placas e cole o
endereç¸oabaixo:
http://arduino.esp8266.com/stable/package esp8266com index.json
Cliquenobotãõaoladodocampoedêênter.Emseguida,nomenu,acesseFerramentas
→
Placa: ‘‘Arduino/GenuinoUNO’’
→Gerenciador de Placas... Nocampo
de busca, digite esp8266 e clique em instalar. Será´ baixado um arquivo com tamanho
aproxi-
11.2.2 Fazendo um LED piscar
mado
ESP8266de 44
noMB e a instalaç¸ãõ estará´ finalizada. Em seguida, para trabalhar com a
Assim como no Raspberry Pi, faremos aqui o projeto mais simples, que consiste em
IDE doum
deixar Arduino, basta ir em
LED piscando emFerramentas
intervalos de 1 segundo. O có´digo é´ o mesmo usado no
Cap. 3, que mostramos abaixo novamente: → Placa: e selecionar a opç¸ãõ NodeMCU 1.0
(ESP-12E Module).
1 void setup()
2 {
3 pinMode(13, OUTPUT);
4 }
5
6 void loop()
7 {
8 digitalWrite(13, HIGH);
9 delay(1000);
10 digitalWrite(13, LOW);
11 delay(1000);
12 }
Aú
ńicamudanç¸adizrespeitoà`sportasdessaplaca,quesãõdiferentes.Nãõentraremosemde
talhes aqui; basta saber que a porta 13 (usada no có´digo acima) corresponde à` porta
D7 do ESP8266, assim como a porta GND está´ identificada apenas pela letra G. Basta
conectar as pernas do LED e pronto.
! O carregamento do có´digo na placa (ver Fig. 11.8) é´ bem lento na ESP8266
quando comparado comoArduinoUnoR3.Issoestá
´ligadoaofatodequeaESP8266nãõfoiotimizadaparaa linguagem do Arduino.
11.2 ESP 8266 e ESP32 106

Figura 11.8: ESP8266 carregando o có´digo que faz um LED piscar.

Bibliograﬁa