Linguagem Arduino I

Prévia do material em texto

Linguagem Arduino I 
 
 
 
 
 
 
 
 
 
v.2.2 
agosto/2013 
 
Leonardo Henrique Day de Toledo 
Robson Paes Machado 
Leandro Ramos 
 
 
 
 
 
A obra Linguagem Arduino foi licenciada com uma Licença Creative Commons - Atribuição - 
Uso Não Comercial - Partilha nos Mesmos Termos 3.0 Não Adaptada. 
Com base na obra disponível em www.eaduino.com.br. 
 
 
 
 
 
1 INTRODUÇÃO ................................................................................................................................. 1 
1.1 FUNDAMENTOS ............................................................................................................................ 1 
1.2 CONVENÇÃO ................................................................................................................................ 2 
1.3 O AMBIENTE DE DESENVOLVIMENTO ARDUINO ........................................................................... 2 
1.4 ESTRUTURA DE UM SKETCH ......................................................................................................... 6 
1.4.1 setup() ................................................................................................................................. 6 
1.4.2 loop() .................................................................................................................................. 6 
1.4.3 { } (chaves) ......................................................................................................................... 8 
1.4.4 ; (ponto e vírgula) .............................................................................................................. 8 
1.4.5 / * ... * / (comentários em bloco) ........................................................................................ 8 
1.4.6 / / (comentários em linha) ................................................................................................. 9 
2 VARIÁVEIS E CONSTANTES .................................................................................................... 10 
2.1 CONSTANTES PRÉ-DEFINIDAS .................................................................................................... 10 
2.1.1 false e true ........................................................................................................................ 10 
2.1.2 INPUT e OUTPUT ........................................................................................................... 11 
2.1.3 HIGH e LOW.................................................................................................................... 11 
2.2 ESCOPO ...................................................................................................................................... 12 
2.3 VOID .......................................................................................................................................... 12 
2.4 TIPOS DE DADOS ........................................................................................................................ 12 
2.4.1 boolean ............................................................................................................................. 12 
2.4.2 char .................................................................................................................................. 12 
2.4.3 unsigned char ................................................................................................................... 14 
2.4.4 byte ................................................................................................................................... 14 
2.4.5 int ..................................................................................................................................... 14 
2.4.6 unsigned int ...................................................................................................................... 14 
2.4.7 word ................................................................................................................................. 14 
2.4.8 long................................................................................................................................... 15 
2.4.9 unsigned long ................................................................................................................... 15 
2.4.10 float .................................................................................................................................. 15 
2.4.11 double ............................................................................................................................... 15 
2.5 ARRAYS ..................................................................................................................................... 16 
3 OPERADORES ............................................................................................................................... 17 
3.1 ARITMÉTICOS ............................................................................................................................ 17 
3.2 OPERADORES COMPOSTOS......................................................................................................... 17 
3.3 RELACIONAIS ............................................................................................................................. 18 
3.4 LÓGICOS .................................................................................................................................... 18 
3.5 SIZEOF........................................................................................................................................ 18 
4 COMUNICAÇÃO ........................................................................................................................... 20 
4.1 SERIAL ....................................................................................................................................... 20 
4.1.1 begin() .............................................................................................................................. 20 
4.1.2 end() ................................................................................................................................. 20 
4.1.3 available() ........................................................................................................................ 20 
4.1.4 read() ................................................................................................................................ 20 
4.1.5 print() ............................................................................................................................... 21 
4.1.6 println() ............................................................................................................................ 21 
4.1.7 write() ............................................................................................................................... 21 
5 ESTRUTURAS DE CONTROLE ................................................................................................. 23 
5.1 IF / IF...ELSE ............................................................................................................................... 23 
5.2 SWITCH…CASE .......................................................................................................................... 24 
5.3 FOR ............................................................................................................................................ 24 
5.4 WHILE ........................................................................................................................................ 25 
5.5 DO... WHILE ................................................................................................................................ 25 
6 FUNÇÕES INTERNAS ..................................................................................................................27 
 
 
6.1 PINMODE (PINO, MODO) ............................................................................................................. 27 
6.2 DIGITALREAD (PINO) ................................................................................................................. 27 
6.3 DIGITALWRITE (PINO, VALOR) ................................................................................................... 27 
6.4 ANALOGREAD (PINO) ................................................................................................................. 27 
6.5 ANALOGWRITE (PINO, VALOR)................................................................................................... 28 
6.6 DELAY(MS) ................................................................................................................................ 28 
6.7 RANDOMSEED(SEMENTE)........................................................................................................... 28 
6.8 RANDOM([MIN], MAX)................................................................................................................ 29 
6.9 MAP(VALOR, DEMINIMO, DEMAXIMO, PARAMINIMO, PARAMAXIMO) ....................................... 29 
7 ATIVIDADES ................................................................................................................................. 31 
7.1 LER STATUS DE UMA CHAVE TÁCTIL (BOTÃO) ............................................................................. 32 
7.2 MANTER O LED APAGADO ENQUANTO O BOTÃO ESTIVER PRESSIONADO................................... 34 
7.3 EXIBIR A TENSÃO PROPORCIONAL A RESISTÊNCIA DO LDR ....................................................... 36 
7.4 EXIBIR A TENSÃO CONFORME A POSIÇÃO DO POTENCIÔMETRO .................................................. 38 
7.5 MUDAR O ESTADO DO LED ATRAVÉS DO BOTÃO ....................................................................... 40 
7.6 LIGAR/DESLIGAR UM BUZZER .................................................................................................... 42 
7.7 AUMENTAR E DIMINUIR O BRILHO DE UM LED .......................................................................... 44 
7.8 LED RGB .................................................................................................................................. 46 
7.9 AUMENTAR E DIMINUIR O BRILHO DE UM LED COM POTENCIÔMETRO ...................................... 48 
7.10 CORES ALEATÓRIAS COM LED RGB ......................................................................................... 50 
7.11 MOTOR DC ................................................................................................................................ 52 
7.12 SERVO MOTOR .......................................................................................................................... 54 
7.12.1 attach( pino ) .................................................................................................................... 54 
7.12.2 write( angulo ) .................................................................................................................. 54 
8 CONCLUSÃO ................................................................................................................................. 56 
Linguagem Arduino I 
www.EADuino.com.br 
1 
 
1 Introdução 
 
1.1 Fundamentos 
 
O microcontrolador na placa Arduino é programado com a linguagem de programação 
Arduino, baseada na linguagem Wiring. O ambiente de desenvolvimento Arduino (IDE - 
Integrated Development Environment ou Ambiente Integrado de Desenvolvimento), é baseado 
no ambiente Processing. Wiring e Processing são projetos que surgiram antes do Arduino. 
Estes projetos são escritos/desenvolvidos em JAVA, C e C++. 
 
O ambiente de desenvolvimento do Arduino é um software que contém um editor de texto para 
escrever o programa, uma área de mensagens, uma barra com botões para funções mais comuns, 
e uma série de menus. Este software se conecta a placa do Arduino, através de um cabo USB, e 
transfere o programa para o mesmo. Os programas escritos para Arduino são chamados de 
sketches (esboços). 
 
Muitas coisas acontecem antes do sketch ser transferido para a placa Arduino. Primeiro é 
verificado se código está sintaticamente correto. Em seguida, o código é passado para o 
compilador avr-gcc (compilador apenas para os microcontroladores da ATMEL), transformando 
o sketch em um arquivo intermediário, conhecido como arquivo objeto. Este código é 
combinado com as bibliotecas padrão Arduino que fornecem funções básicas como 
digitalWrite(), pinMode(), etc. O resultado final é um arquivo que contém códigos 
compreensiveis pelo microcontolador. 
 
As bibliotecas (libraries) padrão Arduino são um conjunto de funções que facilitam a 
programação, evitando assim que tenhamos que escrever muito para, por exemplo, enviar um 
dado para a tela do computador ou fazer uma pausa na execução do sketch. Não precisamos nos 
preocupar em incluir estas bibliotecas padrão, pois o compilador faz isto sozinho. Porém, no 
curso Introdução à plataforma Arduino, fizemos uso de uma biblioteca não padrão, math.h, 
para usarmos a função log(). Esta e muitas outras funções são escritas para diminuir o nosso 
esforço na programação e felizmente há algumas bibliotecas que estão incluídos com o software 
Arduino e tantas outras desenvolvidas pela comunidade 
(http://arduino.cc/en/Reference/Libraries). 
 
Toda linguagem de programação, inclusive a linguagem Arduino, possui regras na escrita 
(sintaxe) que devem ser respeitadas. Muita atenção deve ser dada quando uma palavra reservada 
da linguagem possuir caracteres maiúsculos ou minúsculos. 
 
Quer saber mais sobre a plataforma Arduino e suas origens? Visite: 
 
Wiring 
http://wiring.org.co/about.html 
 
Processing 
http://processing.org/about/ 
 
Arduino 
http://arduino.cc/en/Guide/Introduction 
 
Download da última versão da IDE 
http://arduino.cc/en/Main/Software 
 
Linguagem Arduino I 
www.EADuino.com.br 
2 
 
1.2 Convenção 
 
Ao longo desta apostila adotaremos a seguinte convenção: quando alguma função ou comando 
exigir um parâmetro, este será envolvido pelos caracteres < e >, e quando for opcional pelos 
caracteres [ e ]. 
 
1.3 O ambiente de desenvolvimento Arduino 
 
Assumindo que estamos com o software devidamente instalado (ambiente Windows), localize e 
execute o arquivo arduino.exe. 
 
Obs. As telas capturadas nesta apostila são da versão 1.0.3 e a última da série 1.0.x é a 1.0.5. 
Não há diferenças entre estas versões para o que vai ser apresentado. 
 
 
 
Figura 1-1 – exemplo com o local dos arquivos Arduino em ambiente Windows. 
 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
3 
 
Após a tela de apresentação o ambiente (IDE) é carregado. 
 
 
 
Figura 1-2 – ambiente de desenvolvimento Arduino 
 
 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
4 
 
A partir da versão 1.0.1, lançada em maio de 2012, a IDE foi traduzida para diversos idiomas, 
inclusive o Português (Brasil e Portugal). Para alterar, vá até o menu File, Preferences. 
 
Na tela Preferences, clique em Editor language e selecione o idioma desejado e em seguida no 
botão OK. 
 
 
 
Figura 1-3 – tela de ajustes/preferências do ambiente 
 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
5 
 
As operações mais usuais possuem atalhos na forma de botões. 
 
 
Figura 1-4 – botões (atalhos) para as operações mais comuns 
 
 
 
 
Verify 
Verifica se não há erros sintáticos no sketch. 
 
 
Upload 
Compila e envia o sketch para a placa Arduino. 
 
 
New 
 
Cria um novo sketch.Open 
 
Apresenta uma lista de sketches do seu sketchbook ou permite você escolher a pasta que 
contém o sketch desejado. 
 
 
Save 
 
Salva o sketch. 
 
 
Serial Monitor 
 
Abre a tela do monitor serial. 
 
Linguagem Arduino I 
www.EADuino.com.br 
6 
 
1.4 Estrutura de um sketch 
 
Um sketch (esboço) é um conjunto de códigos, instruções e declarações válidas na linguagem 
Arduino. Este agrupamento de códigos, instruções, etc, é conhecido como programa ou script 
em outras linguagens. 
 
Neste momento você precisa saber que existem duas funções especiais e obrigatórias que 
fazem parte de todo sketch Arduino: setup() e loop(). 
 
Mas o que são funções? Uma função é um bloco de código que possui um nome e uma 
sequencia de instruções/comandos (declarações) que são executados quando a função é 
chamada. Além destas duas funções obrigatórias, podemos ter as nossas próprias funções. As 
funções ajudam a organizar o código, tornando-os mais estruturados e em muitas vezes, 
evitando que tarefas repetitivas sejam escritas novamente. 
 
Uma função é declarada atribuindo um tipo, um nome e opcionalmente os parâmetros que serão 
passados para dentro da função. Mesmo que uma função não possua parâmetros de entrada, o 
uso do ( e ), abre e fecha parênteses, é obrigatório. 
 
tipo nomeDaFunção (parâmetros) { 
 declarações; 
} 
 
A estrutura acima será explicada ao seu tempo. Com os exemplos, você verá que é 
relativamente simples usar/criar funções. 
 
 
1.4.1 setup() 
 
Esta função é executada logo após o inicio do sketch. O que estiver no bloco setup(), é 
executado apenas uma vez, ou toda vez que o Arduino for reiniciado (pressionando um botão 
específico na placa ou quando da falta de energia). 
 
1.4.2 loop() 
 
Após a execução da função setup(), o controle do programa vai para o bloco loop() e como o 
nome sugere, fica “eternamente” neste bloco. Aqui, efetivamente, instruímos o Arduino a fazer 
o que queremos. 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
7 
 
Exemplo 
 
Estas duas funções são tão importantes e obrigatórias que a equipe do Arduino colocou como 
exemplo um sketch somente com este conteúdo. Clique no botão Open e selecione 01. Basics, 
BareMinimum. 
 
 
Figura 1-5 – menu de exemplos 
 
 
 
 
Figura 1-6 – estrutura mínima de um sketch 
 
Linguagem Arduino I 
www.EADuino.com.br 
8 
 
1.4.3 { } (chaves) 
 
As chaves definem o início e o fim de blocos de funções ou blocos de instruções. 
Uma chave de abertura { deve possuir o seu correspondente, uma chave de fechamento }. 
Chaves não balanceadas, sem o seu par correspondente, geram erros no momento da compilação 
do sketch. 
 
O IDE facilita a localizar a outra chave (abertura ou fechamento) simplesmente posicionando o 
cursor em uma chave e a sua corrrespondente será destacada. Porém se o sketch for muito 
extenso, localizar uma chave de fechamento pode ser muito trabalhoso. Como boa prática de 
programação toda vez que abrir uma chave, tecle ENTER para abrir uma nova linha e 
imediatamente feche a chave. Assim evitamos aborrecimentos futuros. 
 
 
 
Figura 1-7 – abertura e fechamento de um bloco 
 
 
 
1.4.4 ; (ponto e vírgula) 
 
O ; deve ser usado para terminar uma declaração. Também é usado para separar os elementos 
de uma estrutura for. 
 
Linhas terminadas sem um ponto e vírgula, irão gerar erros de compilação. 
 
 
1.4.5 / * ... * / (comentários em bloco) 
 
Comentários em bloco são áreas de textos usados para esclarecer certos trechos do código. Isto 
facilita em muito a manutenção de um sketch longo. Em resumo, é uma forma de documentar o 
projeto. 
Todo texto que estiver / * e * / será ignorado pelo compilador, ou seja, não irá ocupar o espaço 
da memória destinada ao sketch. Então, use e abuse deste recurso. 
 
 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
9 
 
 
1.4.6 / / (comentários em linha) 
 
Qualquer texto que estiver após o // será considerado comentário e sendo assim, ignorado pelo 
compilador. Comentários de linha são muitas vezes utilizados após uma declaração válida para 
dar detalhes sobre esta declaração. 
 
 
 
Figura 1-8 – tipos de comentários 
 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
10 
 
2 Variáveis e Constantes 
 
Uma variável é uma maneira de nomear e armazenar um valor na memória do microcontolador 
para uso posterior pelo sketch. Como o termo sugere, as variáveis podem ter seu conteúdo 
continuamente alterado. A variável precisa ser declarada (tipo e nome) e, opcionalmente, 
receber um valor. 
 
Variáveis devem ser nomeadas para indicar a sua finalidade, para tornar o código mais legível e 
consequentemente mais fácil de ser mantido. Evite usar nomes com apenas um caractere. 
 
Uma variável pode ser declarada em vários locais ao longo do sketch. O local onde essa 
definição se dá, determina a sua visibilidade, ou seja, o seu escopo (abrangência). 
 
Exemplo 
 
int pino = 5; 
 
int é o tipo do dado 
pino é o nome da variável 
= é o sinal de atribuição 
5 é o valor atribuído a pino 
 
 
Já uma constante, é um local na memória cujo valor não se altera. Após a declaração não 
podemos alterar o seu valor. A constante precisa ser declarada (tipo e nome) e 
obrigatóriamente receber um valor. Para esta finalidade, usamos a palavra chave reservada 
const. 
 
Exemplo 
 
const int pino = 5; 
 
const é a palavra chave que qualifica a variável como constante 
int é o tipo do dado 
pino é o nome da variável 
= é o sinal de atribuição 
5 é o valor atribuído a pino 
 
 
2.1 Constantes pré-definidas 
 
A linguagem Arduino possui algumas constantes pré-definidas. Elas são usadas para tornar os 
programas mais legíveis. 
 
2.1.1 false e true 
 
Dois estados lógicos indicando respectivamente falso e verdadeiro. Atribuimos estes valores 
em variáveis do tipo boolean para sinalizar certas condições no sketch. 
 
Obs.: na linguagem Arduino qualquer número inteiro diferente de zero é verdadeiro e zero é 
falso. 
 
Linguagem Arduino I 
www.EADuino.com.br 
11 
 
2.1.2 INPUT e OUTPUT 
 
Os pinos digitais podem ser configurados como entrada ou saída. A função para mudar o estado 
de um pino digital é pinMode(). 
 
 
2.1.3 HIGH e LOW 
 
Um de dois valores possíveis (níveis de tensão) que um pino digital pode ser configurado. As 
funções para alterar estes níveis são: digitalWrite() e digitalRead(). 
 
HIGH 
 
Quando um pino é configurado como INPUT e lido com digitalRead(), o microcontrolador irá 
informar HIGH se uma tensão de 3 volts ou mais estiver presente neste pino. 
 
Quando um pino é configurado como OUTPUT e definido como HIGH com digitalWrite(), este 
pino estará com 5 volts. 
 
LOW 
 
Quando um pino é configurado como um INPUT e lido com digitalRead(), o microcontrolador 
irá informar LOW se uma tensão de 2 volts ou menos estiver presente no pino. 
 
Quando um pino é configurado como OUTPUT e definido como LOW com digitalWrite(), o 
pino estará com 0 volts. 
 
 
Obs: as constantes true e false são digitados em letras minúsculas, o que não ocorre com 
HIGH, INPUT, LOW, e OUTPUT. 
 
Exemplos 
 
pinMode( 12, INPUT ); // configura o pino 12 como entrada 
pinMode( 13, OUTPUT ); // configura o pino 13 como saída 
digitalWrite( 13, HIGH ); // coloca 5V no pino 13 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
12 
 
2.2 Escopo 
 
Uma variável pode ser declarada no início do sketch, antes de void setup (), localmente dentro 
defunções (setup() ou loop() por exemplo), ou em uma estrutura for. 
 
Se for declarada no início do sketch, o seu escopo será dito global. Variáveis globais são vistas 
por todas as funções. Se for declarada dentro de uma função ou como parte de uma estrutura 
for, será dito local, ou seja, só é visível e só pode ser usada dentro da função em que foi 
declarada. Portanto, é possível ter duas ou mais variáveis de mesmo nome em diferentes 
funções, pois são tratadas em locais diferentes na memória, apesar de não ser uma prática 
comum. As variáveis de escopo locais asseguram que apenas aquela função onde a variável foi 
declarada pode manipular o seu conteúdo. 
 
2.3 void 
 
A palavra chave void (vazio, nulo) é utilizada apenas nas declarações de função. Ele indica que 
a função não irá retonar valor algum. 
 
Exemplo 
 
void setup() { 
} 
 
 
2.4 Tipos de Dados 
 
2.4.1 boolean 
 
Neste tipo de dado podemos ter apenas os valores 0 ou 1, ou ainda as constantes, false ou true. 
Este tipo de dado ocupa um byte de memória. 
 
Exemplo 
 
boolean ativo = false; 
 
 
2.4.2 char 
 
O tipo de dado char armazena caracteres como o caractere A, por exemplo, na forma numérica, 
isto é, o correspondente numérico do caractere que queremos armazenar. A faixa de valores 
para este tipo de dado (na forma numérica) é de -128 a 127 e o espaço ocupado em memória é 
de um byte. 
 
Neste exemplo, o caractere maiúsculo A corresponde ao valor 65 na tabela ASCII (American 
Standard Code for Information Interchange), um padrão desenvolvido nos anos 1960 para 
representar textos em computadores. A tabela ASCII padrão vai de 0 a 127. 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
13 
 
Neste endereço http://arduino.cc/en/Reference/ASCIIchart , você tem a tabela ASCII com todos 
os caracteres que podem ser representados e armazenados no tipo de dado char. Reproduzimos 
abaixo o conjunto de caracteres mais comuns: 
 
 
valor decimal caractere valor decimal caractere valor decimal caractere 
33 ! 66 B 99 c 
34 " 67 C 100 d 
35 # 68 D 101 e 
36 $ 69 E 102 f 
37 % 70 F 103 g 
38 & 71 G 104 h 
39 ' 72 H 105 i 
40 ( 73 I 106 j 
41 ) 74 J 107 k 
42 * 75 K 108 l 
43 + 76 L 109 m 
44 , 77 M 110 n 
45 - 78 N 111 o 
46 . 79 O 112 p 
47 / 80 P 113 q 
48 0 81 Q 114 r 
49 1 82 R 115 s 
50 2 83 S 116 t 
51 3 84 T 117 u 
52 4 85 U 118 v 
53 5 86 V 119 w 
54 6 87 W 120 x 
55 7 88 X 121 y 
56 8 89 Y 122 z 
57 9 90 Z 123 { 
58 : 91 [ 124 | 
59 ; 92 \ 125 } 
60 < 93 ] 126 ~ 
61 = 94 ^ 
62 > 95 _ 
63 ? 96 ` 
64 @ 97 a 
65 A 98 b 
 
 
Os valores iniciais desta tabela (0 a 31) são códigos de controle usados em vários equipamentos 
de impressão, vídeo, comunicação, etc, e o código 32 representa o espaço em branco. 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
14 
 
Para atribuir um valor a uma variável do tipo char, podemos usar o seu valor numérico presente 
na tabela ASCII ou o próprio caractere envolvido por aspa simples. Então, caractere = 65 é o 
mesmo que caractere = ‘A’. 
 
Como char armazena um valor numérico, podemos fazer operações aritméticas com este tipo de 
dado, apesar de não ser algo comum. Então, caractere = 65 + 1 é o mesmo que caractere = 
‘B’. 
 
Exemplos 
 
char caractere; // declara a variável caractere, tipo char 
char novoCaractere; // declara a variável novoCaractere, tipo char 
caractere = 65; // atribui o valor 65 a variável caractere 
novoCaractere = caractere + 1; // atribui o resultado da operação a variável 
 novoCaractere 
caractere = ‘C’; 
novoCaractere = caractere - 2; 
 
 
2.4.3 unsigned char 
 
O mesmo que char, exceto que o qualificador unsigned altera a faixa de valores possíveis: 0 a 
255. Com esta faixa podemos estender o conjunto de caracteres, porém é altamente dependente 
da configuração do ambiente operacional onde o software Arduino é executado. 
 
 
2.4.4 byte 
 
Este tipo de dado armazena valores numéricos inteiros de 0 a 255. Ocupa um byte de memória. 
 
 
2.4.5 int 
 
int manipula números inteiros, sem casas decimais, na faixa de 32767 a -32768. Este tipo de 
dado ocupa dois bytes de memória. 
 
 
2.4.6 unsigned int 
 
O mesmo que int, exceto que o qualificador usigned altera a faixa de valores: 0 a 65535. 
 
Exemplo 
 
unsigned int totalLeitura = 50000; 
 
 
2.4.7 word 
 
O mesmo que unsigned int. 
 
Exemplo 
 
word totalLeitura = 50000; 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
15 
 
2.4.8 long 
 
Um tipo de dado que manipula valores inteiros na faixa de -2147483648 a 2147483647 e ocupa 
quatro bytes de memória. 
 
Exemplo 
 
long totalLeitura; 
 
 
2.4.9 unsigned long 
 
O mesmo que long, exceto que o qualificador unsigned altera a faixa de valores: 0 a 
4294967295. 
 
Exemplo 
 
unsigned long totalLeitura; 
 
 
2.4.10 float 
 
O tipo float permite manipular números em ponto flutuante (ponto decimal). Use somente este 
tipo de dado onde números inteiros não se aplicam. Ocupa quatro bytes de memória e faixa de 
valores é de -3.4028235E+38 a 3.4028235E+38. 
 
Exemplo 
 
float totalLeitura = 3.16; 
 
 
2.4.11 double 
 
O tipo double, assim como o float, permite manipular números em ponto flutuante (ponto 
decimal). Até o momento, na linguagem Arduino estes tipos são exatamente iguais. 
 
Exemplo 
 
double totalLeitura = 234.56; 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
16 
 
2.5 Arrays 
 
Uma array é uma coleção de valores numéricos ou caracteres. Um item qualquer desta coleção 
é acessado através de um número que indica a posição deste item dentro da coleção, conhecido 
por índice. A declaração de um array inicia com o tipo de dado, um nome e opcionalmente o 
número de elementos que compõe esta coleção. É importantíssimo saber que arrays na 
linguagem Arduino iniciam em zero, ou seja, o primeiro item da coleção tem o índice zero. 
 
Exemplos 
 
int numeros[4]; // numeros é uma coleção de quatro inteiros 
 cujo índice inicia em 0 e termina em 3 
 
Outra forma de declarar um array, sem indicar o número de elementos: 
 
int numeros[] = {2, 4, 8, 3, 6, 0}; 
 
Declarando um array de caracteres: 
 
char caracteres[] = {‘a’, ‘t’, ‘8’, ‘3’}; 
 
Uma forma de armazenar uma cadeia de caracteres, conhecido como string: 
 
char mensagem[] = "Curso Linguagem Arduino"; 
 
Importante acrescentar que quando uma string é atribuída a um array, o seu tamanho será a 
quantidade de caracteres na string mais o caractere terminador null (‘\0’) que é anexado 
automaticamente. O mesmo não ocorre quando você atribui caractere a caractere a um array. 
A linguagem Arduino não faz o controle dos limites de um tipo de dado, principalmente de um 
array. Se você ultrapassa as fronteiras de um tipo de dado, resultados inesperados são esperados 
. 
Mais adiante veremos uma estrutura (for) que facilitará em muito a navegação pelos elementos 
de um array. 
 
Obs.: a linguagem Arduino permite o uso de arrays de múltiplas dimensões. Veremos como no 
curso Linguagem Arduino II. 
 
Linguagem Arduino I 
www.EADuino.com.br 
17 
 
3 Operadores 
 
Operadores são símbolos que agregados às constantes e variáveis, formam as expressões. 
 
Os operadores que veremos a seguir são agrupados conforme seu uso/aplicação. São eles: 
 Aritméticos 
 Relacionais 
 Lógicos 
 
 
3.1 Aritméticos 
 
Operadoresaritméticos incluem adição, subtração, multiplicação e divisão. A expressão retorna 
a soma, diferença, produto ou quociente dos operandos. Neste grupo temos ainda o operador de 
atribuição e resto de uma divisão. 
 
 = (atribuição) 
 + (adição) 
 - (subtração) 
 * (multiplicação) 
 / (divisão) 
 % (módulo – resto da divisão) 
 
 
3.2 Operadores Compostos 
 
Este é um recurso bem interessante. Os operadores compostos permitem combinar uma 
operação com uma atribuição de variável ou incremento/decremento do valor de uma variável. 
 
 ++ (incremento) 
 -- (decremento) 
 += (adição composta) 
 -= (subtração composta) 
 *= (multiplicação composta) 
 /= (divisão composta) 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
18 
 
3.3 Relacionais 
 
Estes operadores permitem fazermos comparações entre uma variável e um valor ou entre 
variáveis. São eles: 
 
 == (igual a) 
 != (diferente, não igual a) 
 < (menor que) 
 > (maior que) 
 <= (menor ou igual a) 
 >= (maior ou igual a) 
 
 
 
Obs: não confunda o operador de atribuição = com o operador relacional == (dois sinais de 
iguais). Este é erro muito comum para os que estão iniciando. 
 
 
 
3.4 Lógicos 
 
Os operadores lógicos ou booleanos são usados para “ligar” duas ou mais comparações e o 
resultado desta comparação sempre será true ou false. Existem três operadores lógicos: 
 
 && (and - e) 
 || (or - ou) 
 ! (not - não) 
 
 
3.5 sizeof 
 
sizeof(variável) 
 
O operador sizeof retorna o número de bytes (tamanho) que representa o tipo de dado da 
variável. Este operador é muito útil com arrays e aqui vale lembrar que se o array for de 
caracteres, o tamanho será o total mais um para o terminador null (‘\0’). 
 
 
No exemplo a seguir vamos utilizar os tópicos apresentados anteriormente. Estude, com muita 
tranquilidade , e se ficar alguma dúvida escreva para suporte@eaduino.com.br. 
 
 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
19 
 
Exemplo 01 
 
Digite o sketch abaixo ou copie e cole na IDE do Arduino e veja o resultado no monitor serial. 
 
/* 
 Linguagem Arduino I - Exemplo 01 
 */ 
 
float numero = 5; 
float resultado; 
int numero_inteiro = 123.45; 
char texto[] = "Arduino"; 
 
void setup() { 
 Serial.begin(9600); 
 resultado = 4 + numero; 
 exibeResultado(); 
 resultado = numero * 2; 
 exibeResultado(); 
 resultado = 47 / 2.5; 
 exibeResultado(); 
 resultado = (int) numero % 2; 
 exibeResultado(); 
 resultado = numero_inteiro; 
 exibeResultado(); 
 Serial.println("----------"); 
 resultado++; 
 exibeResultado(); 
 resultado--; 
 exibeResultado(); 
 resultado -= 3; 
 exibeResultado(); 
 resultado *= 5; 
 exibeResultado(); 
 Serial.println("----------"); 
 resultado = sizeof( numero ); 
 exibeResultado(); 
 resultado = sizeof( numero_inteiro ); 
 exibeResultado(); 
 resultado = sizeof( texto ); 
 exibeResultado(); 
} 
 
void loop() { 
} 
 
void exibeResultado() { 
 Serial.println( resultado ); 
 return; 
} 
Linguagem Arduino I 
www.EADuino.com.br 
20 
 
 
4 Comunicação 
 
4.1 Serial 
 
Este objeto é usado para comunicação serial entre a placa Arduino e qualquer outro dispositivo 
que aceite comunicação serial. Quando em uso, o Arduino utiliza os pinos digitais 0 (RX - 
recepção) e 1 (TX - transmissão) para a comunicação, portanto não use estes pinos para entrada 
ou saída. Veremos os seguintes métodos: 
 
 begin() 
 end() 
 available() 
 read() 
 print() 
 println() 
 write() 
 
4.1.1 begin() 
 
Serial.begin( <velocidade> ) inicia a comunicação com os pinos seriais na velocidade 
informada. A unidade é bps (bits por segundo). Esta é a velocidade que a placa Arduino irá 
enviar os dados para o computador e os valores possíveis são: 300, 1200, 2400, 4800, 9600, 
14400, 19200, 28800, 38400, 57600, ou 115200. Porém, pode-se colocar outro valor caso o 
dispositivo com o qual você quer comunicar exija uma configuração diferente. 
 
Exemplo 
 
Serial.begin( 9600 ); // inicia a comunicação a 9600bps 
 
 
4.1.2 end() 
 
Serial.end() desativa a comunicação serial, permitindo que os pinos 0 e 1 possam ser usados 
para entrada e saída. Para reativar a comunicação serial use Serial.begin (). 
 
 
4.1.3 available() 
 
Serial.available() obtém o número de bytes disponíveis para leitura. Os dados que chegam pela 
serial são armazenados em uma pequena área (buffer) de memória, cujo tamanho é de 64 bytes. 
 
 
4.1.4 read() 
 
Serial.read() lê o primeiro byte da entrada serial. Retorna -1 caso não haja dado. 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
21 
 
4.1.5 print() 
 
Serial.print( <dados> [,<formato>]) envia dados para o monitor serial e opcionalmente 
formatados como os seguintes parâmetros: BIN (binário ou base 2), OCT (octal ou base 8), 
DEC (decimal ou base 10) e HEX (hexadecimal ou base 16). Este método também aceita 
alguns caracteres de controle para o auxilio da impressão. Caracteres de controle são códigos da 
tabela ASCII que por si só não imprimíveis. 
 
 
Obs.: neste nosso contexto, impressão significa os dados exibidos no monitor serial. 
 
Algumas características importantes: 
 
 Após a impressão, o cursor fica posicionado na próxima coluna. 
 Os caracteres de controle \n (new line – nova linha) e \r (carriage return – retorno do 
cursor para primeira coluna) avançam o cursor para a próxima linha 
 Um caractere de controle muito útil para formatar a saída de dados é o \t (TAB – 
tabulação). O avanço é de oito posições. 
 Números float são exibidos, por padrão, com apenas duas casas decimais. 
 
 
4.1.6 println() 
 
O mesmo que Serial.print(), exceto que após a impressão o cursor vai a próxima linha. 
 
4.1.7 write() 
 
Serial.write( <dados> ) envia dados binários para a porta serial. Estes dados são enviados 
como um byte ou uma série de bytes. Este método retorna o número de bytes enviados. 
 
 
Obs.: O controle e manipulação de dados via serial não é algo tão simples de implementar. Este 
curso tem o objetivo de introduzi-lo na linguagem e por isso não nos aprofundamos no assunto. 
No curso Linguagem Arduino II há um capítulo dedicado com mais exemplos. 
 
Linguagem Arduino I 
www.EADuino.com.br 
22 
 
Exemplo 02 
 
Digite o sketch abaixo ou copie e cole na IDE do Arduino e veja o resultado no monitor serial. 
 
 
 
/* 
 Linguagem Arduino I - Exemplo 02 
*/ 
 
void setup() { 
 Serial.begin(9600); 
 int valor = 65; 
 Serial.print(valor); 
 Serial.print("\t"); 
 Serial.print(valor, DEC); 
 Serial.print("\t"); 
 Serial.print(valor, HEX); 
 Serial.print("\t"); 
 Serial.print(valor, OCT); 
 Serial.print("\t"); 
 Serial.print(valor, BIN); 
 Serial.println(' '); 
 Serial.write(45); 
 Serial.println(' '); 
 int bytesEnviados = Serial.write("Arduino"); 
 Serial.print("\tnumero de caracteres = "); 
 Serial.println( bytesEnviados ); 
} 
 
void loop() { 
 
} 
 
Linguagem Arduino I 
www.EADuino.com.br 
23 
 
5 Estruturas de Controle 
 
As estruturas de controle determinam o fluxo que o sketch deve seguir baseado em testes e 
comparações. A estrutura mais simples e comum é a sequencial, onde as instruções são executas 
uma após a outra sem interrupção. Porém se não houve outras como repetição e teste, o nossosketch não poderá “tomar uma decisão” baseado nos valores que os circuitos eletrônicos, por 
exemplo, enviam para a placa Arduino. Na linguagem Arduino temos: 
 
 if / if...else 
 switch case 
 for 
 while 
 do... while 
 
 
5.1 if / if...else 
 
if(<expressão> ) { 
 
} 
[ else { 
 
} ] 
 
Esta estrutura avalia a expressão estabelecida no comando. Caso ela seja verdadeira, isto é, se o 
resultado da avaliação atender a condição, as declarações que estiverem dentro do bloco serão 
executadas. A estrutura if possui um elemento auxiliar, opcional, que é a condição contrária a 
avaliação feita pelo if, ou seja, se a condição for falsa as declarações que estiverem dentro do 
bloco else serão executadas. 
 
Exemplo 
 
int pinoLED = 13; 
int estadoBotao; 
 
if (estadoBotao == HIGH) { 
 digitalWrite(pinoLED, HIGH); 
} 
else { 
 digitalWrite(pinoLED, LOW); 
} 
 
 
 
Obs.: Atenção mais uma vez ao sinal == que representa o operador de comparação. 
 
Linguagem Arduino I 
www.EADuino.com.br 
24 
 
5.2 switch…case 
 
switch ( <variável> ) { 
 case <valor>: 
 // declarações 
 break; 
 case <valor>: 
 // declarações 
 break; 
 . 
 . 
 . 
 [ default: 
 // declarações ] 
} 
 
Esta estrutura é muito interessante. É uma alternativa a estrutura if quando temos muitos itens 
para serem testados. break desvia o fluxo para o fim da estrutura switch...case. Se não 
colocarmos este “ponto de ruptura”, todos os cases serão executados até o fim da estrutura. 
default se assemelha ao else da estrutura if, se nenhum case for satisfeito default é executado. 
 
Exemplo: 
 
 var = analogRead( 0 ); 
 switch (var) { 
 case 1: 
 // faça alguma coisa se o valor for 1 e após vá para o fim de switch...case 
 break; 
 case 2: 
 // faça alguma coisa se o valor for 2 e após vá para o fim de switch...case 
 break; 
 default: 
 // caso contrário faça isto... 
 Serial.println( var ); 
 } 
 
 
5.3 for 
 
for( [início] ; [condição] ; [incremento] ) { 
 
} 
 
A estrutura for é uma das mais versáteis da linguagem Arduino. As declarações (dentro deste 
bloco) são repetidas até que a condição estabelecida seja verdadeira. 
 
Exemplo 
 
int intensidade; 
for( intensidade = 0 ; intensidade <= 255; intensidade++) { 
 Serial.println( intensidade ); 
} 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
25 
 
5.4 while 
 
while( <expressão> ){ 
 // declarações 
} 
 
A estrutura while repete as declarações enquanto a expressão resultar e um valor verdadeiro, ou 
seja, esta estrutura só termina quando a expressão se tornar falsa. 
 
Exemplo 
 
var = 0; 
while(var < 200){ 
 var++; 
 Serial.println( var ); 
} 
 
 
5.5 do... while 
 
do { 
 // declarações 
} while( <expressão> ); 
 
do...while executa pelo menos uma vez as declarações para então avaliar a expressão. Se 
verdadeira, continua a executar até que a expressão se torne falsa. 
Exemplo 
 
var = 0; 
do { 
 Serial.println( var ); 
 var++; 
} while(var < 200); 
 
 
Obs.: for, while e do...while são estrutras de repetição (loop – laço) e o comando break, apesar 
de muito usado na estrutura switch...case, também pode ser aplicado nas estruturas de repetição 
para interromper um laço. 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
26 
 
Exemplo 03 
Digite o sketch abaixo ou copie e cole na IDE do Arduino e veja o resultado no monitor serial. 
 
/* 
 Linguagem Arduino I - Exemplo 03 
 */ 
 
char texto[] = "Linguagem Arduino I"; 
int tamanho = sizeof( texto ) - 1; 
 
void setup() { 
 Serial.begin(9600); 
 Serial.print("Tamanho da string = "); 
 Serial.println( tamanho ); 
 
 for( int i = 0; i < tamanho; i++ ) { 
 Serial.print( texto[i] ); 
 Serial.print( ' ' ); 
 } 
 
 Serial.println( ' ' ); 
 for( int i = tamanho - 1; i >= 0 ; i-- ) { 
 Serial.print( texto[i] ); 
 Serial.print( ' ' ); 
 } 
} 
 
void loop() { 
 
} 
 
Linguagem Arduino I 
www.EADuino.com.br 
27 
 
6 Funções Internas 
 
6.1 pinMode (pino, modo) 
 
Usado na função setup() para configurar um pino no modo de entrada ou saída. 
 
Os pinos digitais, por padrão são configurados para entrada e não precisam ser declarados. 
Normalmente o fazemos para manter o sketch mais fácil de ser lido. 
 
O modo é uma das duas constantes pré-definidas: INPUT ou OUTPUT. 
 
Exemplo 
 
pinMode( 5, OUTPUT ); // configura o pino 5 como saida 
pinMode( 9, INPUT ); // configura o pino 9 como entrada 
 
 
6.2 digitalRead (pino) 
 
Lê o valor de um pino digital. O retorno será um dos dois valores possíveis: HIGH ou LOW. 
 
Exemplo 
 
byte retorno; 
pinMode( 9, INPUT ); // configura o pino 9 como entrada 
retorno = digitalRead( 9 ); // le o valor do pino 9 
 
 
6.3 digitalWrite (pino, valor) 
 
Escreve um valor HIGH ou LOW em pinos digitais. 
 
Exemplo 
 
byte saida = HIGH; 
pinMode( 9, OUTPUT ); // configura o pino 9 como saida 
digitalWrite( 9, saida ); // escreve no pino 9 
 
 
6.4 analogRead (pino) 
 
Lê o valor de um pino analógico. O retorno estará entre 0 e 1023, sendo que 0 representa 0 volts 
e 1023 representa 5 volts, ou seja, temos 1024 intervalos de 0.004882 volts. 
 
Exemplo 
 
int leitura; 
leitura = analogRead( 0 ); // le o valor do pino analogico 0 
 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
28 
 
6.5 analogWrite (pino, valor) 
 
Escreve um valor pseudo-analógico nos pinos digitais 3, 5, 6, 9, 10 e 11 (estes pinos são válidos 
para as placas que utilizam o microcontrolador ATmega168 e Atmega328), utilizando uma 
técnica conhecida com PWM (pulse width modulation – modulação por largura de pulso). 
 
Qualquer valor intermediário vai gerar uma tensão proporcional a este valor. Por exemplo, veja 
a tabela abaixo: 
 
Valor PWM Volts 
0 0 
64 1,25 
127 2,5 
191 3,75 
255 5 
 
Exemplo 
 
byte saida = 127; 
analogWrite( 9, saida ); // escreve no pino 9 o correspondente a 2,5 volts 
 
 
6.6 delay(ms) 
 
Pausa um sketch para a quantidade de tempo especificado. Este tempo é em milissegundos, 
onde 1000 é igual a 1 segundo. 
 
Exemplo 
 
delay( 3000 ); // pausa a execução do sketch por 3 segundos 
 
 
6.7 randomSeed(semente) 
 
Esta função inicializa o gerador de números pseudo aleatórios usando como parâmetro a 
semente. Se semente é um valor fixo, a sequência gerada será sempre a mesma. 
 
Exemplos 
 
randomSeed( 1000 ); 
randomSeed(analogRead(0)); // esta e uma tecnica comumente utilizada 
 que aproveita o ruido gerado pelos pinos 
 analogicos quando nao ha nada conectado 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
29 
 
6.8 random([min], max) 
 
Esta é a função que efetivamente gera o número “aleatório”. Retorna um número do tipo long 
entre min (inclusive) e max (exclusive). 
 
Exemplo 
 
long numAleatorio; 
randomSeed(analogRead(0)); // inicia o gerador com o valor lido no pino 0 
numAleatorio = random(300); // gera um número entre 0 e 299 
Serial.println(numAleatorio); // imprime o número gerado 
 
 
6.9 map(valor, deMinimo, deMaximo, paraMinimo, paraMaximo) 
 
Mapeia um valor de um intervalo para outro. 
 
Exemplo 
 
byte pinoLED = 9; 
int pinoLDR = 0; 
int valorLidoLDR = analogRead(pinoLDR); 
byte brilhoLED = map(valorLidoLDR,0, 1023, 0, 255); // os valores entre 0 e 1023 
 sao mapeados para 0 e 255 
analogWrite(pinoLED, brilhoLED); 
 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
30 
 
Exemplo 04 
Digite o sketch abaixo ou copie e cole na IDE do Arduino e veja o resultado no monitor serial. 
 
 
 
/* 
 Linguagem Arduino I - Exemplo 04 
 */ 
 
long numeroAleatorio; 
 
void setup(){ 
 Serial.begin(9600); 
 delay(3000); 
 randomSeed(analogRead(0)); 
} 
 
void loop() { 
 numeroAleatorio = random(0, 256); 
 Serial.println(numeroAleatorio); 
 delay(100); 
} 
 
Linguagem Arduino I 
www.EADuino.com.br 
31 
 
7 Atividades 
 
A seguir, temos uma série de circuitos e sketches para você praticar a linguagem Arduino. No 
site www.EADuino.com.br temos outros exemplos que serão uteis para complementar este 
curso. Quaisquer dúvidas utilize o fórum ou envie mensagem para suporte@eaduino.com.br. 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
32 
 
7.1 Ler status de uma chave táctil (botão) 
 
Material necessário 
 Um resistor de 10K ohms (marrom, preto, laranja) 
 Uma chave táctil (uma chave botão sem trava) 
 Diversos fios jumpers 
 
 
Figura 7-1 - diagrama da atividade 01 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
33 
 
 
Figura 7-2 - interligando os componentes com a placa Arduino 
 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 Ler status de uma chave tactil 
 ---------------------------------- 
 Atividade01 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
byte pinoBotao = 12; 
 
void setup() { 
 pinMode(pinoBotao , INPUT); 
 Serial.begin(9600); 
 delay(1000); 
} 
 
void loop() { 
 byte statusBotao = digitalRead(pinoBotao); 
 Serial.print("status do pinoBotao = "); 
 Serial.println(statusBotao,DEC); 
 delay(200); 
} 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
34 
 
7.2 Manter o LED apagado enquanto o botão estiver pressionado 
Material necessário 
 Um resistor de 10K ohms (marrom, preto, laranja) 
 Um resistor de 220 ohms (vermelho, vermelho, marrom) 
 Uma chave táctil (uma chave botão sem trava) 
 Um LED de qualquer cor 
 Diversos fios jumpers 
 
 
 
Figura 7-3 - diagrama da atividade 02 
 
Linguagem Arduino I 
www.EADuino.com.br 
35 
 
 
Figura 7-4 - interligando os componentes com a placa Arduino 
 
 
 
 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 Manter o LED apagado enquanto o 
 botao estiver pressionado 
 ---------------------------------- 
 Atividade02 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
byte pinoBotao = 12; 
byte pinoLED = 13; 
 
void setup() { 
 pinMode(pinoBotao, INPUT); 
 pinMode(pinoLED, OUTPUT); 
} 
 
void loop() { 
 byte statusBotao = digitalRead(pinoBotao); 
 digitalWrite(pinoLED, statusBotao); 
 delay(200); 
} 
Linguagem Arduino I 
www.EADuino.com.br 
36 
 
7.3 Exibir a tensão proporcional a resistência do LDR 
Material necessário 
 Um resistor de 100K ohms (marrom, preto, amarelo) 
 Um LDR 
 Diversos fios jumpers 
 
 
Figura 7-5 - diagrama da atividade 03 
 
Linguagem Arduino I 
www.EADuino.com.br 
37 
 
 
Figura 7-6 - interligando os componentes com a placa Arduino 
 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 Exibir a tensão proporcional a 
 resistência do LDR 
 ---------------------------------- 
 Atividade03 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
byte pinoLDR = 0; 
 
float tensaoLida = 0; 
 
void setup() 
{ 
 pinMode(pinoLDR, INPUT); 
 Serial.begin(9600); 
 delay(1000); 
} 
 
void loop() 
{ 
 // valor lido sera entre 0 e 1023, cada unidade corresponde a 
0.0048828125 volts 
 // ou arredondando: 0.0049 
 tensaoLida = analogRead( pinoLDR ) * 0.0049; 
 Serial.print( tensaoLida ); 
 Serial.println( " volts."); 
 delay(200); 
} 
Linguagem Arduino I 
www.EADuino.com.br 
38 
 
7.4 Exibir a tensão conforme a posição do potenciômetro 
 
Material necessário 
 Um potenciômetro de 100K ohms 
 Diversos fios jumpers 
 
 
Figura 7-7 - diagrama da atividade 04 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
39 
 
 
Figura 7-8 - interligando os componentes com a placa Arduino 
 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 Exibir a tensao conforme a posicao 
 do potenciometro 
 ---------------------------------- 
 Atividade04 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
byte pinoPOT = 0; 
 
float tensaoLida = 0; 
byte saidaPWM = 0; 
 
void setup() 
{ 
 pinMode(pinoPOT, INPUT); 
 Serial.begin(9600); 
 delay(1000); 
} 
 
void loop() 
{ 
 // valor lido sera entre 0 e 1023, cada unidade corresponde a 
0.0048828125 volts 
 // ou arredondando: 0.0049 
 tensaoLida = analogRead( pinoPOT ) * 0.0049; 
 Serial.print( tensaoLida ); 
 Serial.println( " volts."); 
 delay(200); 
} 
 
Linguagem Arduino I 
www.EADuino.com.br 
40 
 
7.5 Mudar o estado do LED através do botão 
 
Material necessário 
 Um resistor de 10K ohms (marrom, preto, laranja) 
 Um resistor de 220 ohms (vermelho, vermelho, marrom) 
 Uma chave táctil (uma chave botão sem trava) 
 Um LED de qualquer cor 
 Diversos fios jumpers 
 
 
 
 
Figura 7-9 - diagrama da atividade 05 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
41 
 
 
 
Figura 7-10 - interligando os componentes com a placa Arduino 
 
 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 Mudar o estado do LED atraves do botao 
 ---------------------------------- 
 Atividade05 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
byte pinoLED = 13; 
byte pinoBOT = 12; 
 
boolean statusLED = false; 
 
void setup(){ 
 pinMode(pinoLED, OUTPUT); 
 pinMode(pinoBOT, INPUT); 
} 
 
void loop() 
{ 
 if (digitalRead(pinoBOT) == LOW) { 
 delay(150); 
 statusLED = !statusLED; // inverte o estado lógico da 
variável 
 digitalWrite(pinoLED, statusLED); 
 } 
} 
 
Linguagem Arduino I 
www.EADuino.com.br 
42 
 
7.6 Ligar/desligar um buzzer 
 
Material necessário 
 Um BUZZER com oscilador interno 
 Diversos fios jumpers 
 
 
 
 
Figura 7-11 - diagrama da atividade 06 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
43 
 
 
 
Figura 7-12 - interligando os componentes com a placa Arduino 
 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 Ligar/desligar um buzzer 
 ---------------------------------- 
 Atividade06 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
byte pinoBUZ = 12; 
byte repete; 
 
void setup() { 
 pinMode (pinoBUZ, OUTPUT); 
} 
 
void loop() { 
 for(repete = 0; repete < 3; repete++){ 
 digitalWrite(pinoBUZ,HIGH); 
 delay(100); 
 digitalWrite(pinoBUZ,LOW); 
 delay(100); 
 } 
 delay(1000); 
} 
 
Linguagem Arduino I 
www.EADuino.com.br 
44 
 
7.7 Aumentar e diminuir o brilho de um LED 
 
Material necessário 
 Um resistor de 220 ohms (vermelho, vermelho, marrom) 
 Um LED de qualquer cor 
 Diversos fios jumpers 
 
 
Figura 7-13 - diagramada atividade 04 
 
 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
45 
 
 
 
Figura 7-14 - interligando os componentes com a placa Arduino 
 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 Aumentar e diminuir o brilho de um LED 
 ("fade in" e "fade out") 
 ---------------------------------- 
 Atividade07 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
byte brilhoLED = 0; 
char passo = 5; 
 
void setup() { 
 pinMode(9, OUTPUT); 
} 
 
void loop() { 
 analogWrite(9, brilhoLED); 
 brilhoLED = brilhoLED + passo; 
 if (brilhoLED == 0 || brilhoLED == 255) { 
 passo = -passo ; 
 } 
 delay(30); 
} 
 
Linguagem Arduino I 
www.EADuino.com.br 
46 
 
7.8 LED RGB 
 
Material necessário 
 Um resistor de 220 ohms (vermelho, vermelho, marrom) 
 Um LED RGB 
 Diversos fios jumpers 
 
 
 
Figura 7-15 - diagrama da atividade 08 
 
Linguagem Arduino I 
www.EADuino.com.br 
47 
 
 
 
Figura 7-16 - interligando os componentes com a placa Arduino 
 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 LED RGB 
 ---------------------------------- 
 Atividade08 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
byte pinoLED_1 = 9; 
byte pinoLED_2 = 10; 
byte pinoLED_3 = 11; 
int pausa = 500; 
 
void setup() { 
 pinMode(pinoLED_1, OUTPUT); 
 pinMode(pinoLED_2, OUTPUT); 
 pinMode(pinoLED_3, OUTPUT); 
} 
 
void loop() { 
 digitalWrite(pinoLED_1, HIGH); 
 delay(pausa); 
 digitalWrite(pinoLED_1, LOW); 
 digitalWrite(pinoLED_2, HIGH); 
 delay(pausa); 
 digitalWrite(pinoLED_2, LOW); 
 digitalWrite(pinoLED_3, HIGH); 
 delay(pausa); 
 digitalWrite(pinoLED_3, LOW); 
} 
 
Linguagem Arduino I 
www.EADuino.com.br 
48 
 
7.9 Aumentar e diminuir o brilho de um LED com potenciômetro 
 
Material necessário 
 Um potenciômetro de 100K ohms 
 Um resistor de 220 ohms (vermelho, vermelho, marrom) 
 Um LED de qualquer cor 
 Diversos fios jumpers 
 
 
Figura 7-17 - diagrama da atividade 09 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
49 
 
 
 
Figura 7-18 - interligando os componentes com a placa Arduino 
 
 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 Aumentar e diminuir o brilho de um LED 
 ("fade in" e "fade out") com 
 pontenciômetro e função map() 
 ---------------------------------- 
 Atividade09 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
byte brilhoLED; 
byte pinoPOT = 0; 
byte pinoLED = 9; 
 
void setup() { 
 pinMode(pinoLED, OUTPUT); 
} 
 
void loop() { 
 brilhoLED = map(analogRead(pinoPOT), 0, 1023, 0, 255); 
 analogWrite(pinoLED, brilhoLED); 
} 
 
Linguagem Arduino I 
www.EADuino.com.br 
50 
 
7.10 Cores aleatórias com LED RGB 
 
Material necessário 
 Um resistor de 220 ohms (vermelho, vermelho, marrom) 
 Um LED RGB 
 Diversos fios jumpers 
 
 
 
Figura 7-19 - diagrama da atividade 10 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
51 
 
 
 
Figura 7-20 - interligando os componentes com a placa Arduino 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 Cores aleatorias com LED RGB 
 ---------------------------------- 
 Atividade10 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
long numeroAleatorio; 
byte pinoLED_1 = 9; 
byte pinoLED_2 = 10; 
byte pinoLED_3 = 11; 
 
void setup() { 
 randomSeed(analogRead(0)); 
 pinMode(pinoLED_1, OUTPUT); 
 pinMode(pinoLED_2, OUTPUT); 
 pinMode(pinoLED_3, OUTPUT); 
} 
 
void loop() { 
 byte pwm_1 = geraNumero(); 
 byte pwm_2 = geraNumero(); 
 byte pwm_3 = geraNumero(); 
 
 analogWrite(pinoLED_1, pwm_1); 
 analogWrite(pinoLED_2, pwm_2); 
 analogWrite(pinoLED_3, pwm_3); 
 delay(500); 
} 
 
byte geraNumero() { 
 numeroAleatorio = random(0, 256); 
 return numeroAleatorio; 
} 
 
Linguagem Arduino I 
www.EADuino.com.br 
52 
 
7.11 Motor DC 
 
Material necessário 
 Um resistor de 1K ohms (marrom, preto, vermelho) 
 Um motor DC 6 volts 
 Um diodo 1N4001 
 Um transistor de potência TIP120 
 Diversos fios jumpers 
 
 
Figura 7-21 - diagrama da atividade 11 
 
 
Linguagem Arduino I 
www.EADuino.com.br 
53 
 
 
Figura 7-22 - interligando os componentes com a placa Arduino 
 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 Motor DC 
 ---------------------------------- 
 Atividade11 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
byte pinoMotor = 9; 
byte valorPWM = 127; 
 
void setup() { 
 pinMode(pinoMotor, OUTPUT); 
} 
 
void loop() { 
 analogWrite(pinoMotor, valorPWM); 
} 
Linguagem Arduino I 
www.EADuino.com.br 
54 
 
7.12 Servo Motor 
 
Neste exemplo temos um elemento extra na programação, o uso da biblioteca Servo.h. No curso 
Introdução à plataforma Arduino, você já foi introduzido ao assunto quando utilizamos um 
NTC (sensor de temperatura). Foi preciso fazer cálculos usando a função log(), que não está 
presente na biblioteca padrão Arduino. Bom, aqui vamos usar uma biblioteca pronta para 
controlar servo motores. Para incluir uma biblioteca no sketch usamos a diretiva #include. 
 
Obs.: A biblioteca Servo.h suporta até 12 motores nas placas Duemilaenove/UNO e seus 
compatíveis. O uso desta biblioteca desativa a funcionalidade PWM nos pinos 9 e 10, 
existindo ou não um servo motor nestes pinos. 
 
Aqui vamos explorar dois métodos do objeto Servo: attach() e write(). 
 
7.12.1 attach( pino ) 
 
Conecta o objeto ao pino especificado. 
 
7.12.2 write( angulo ) 
 
Movimenta o eixo do servo no angulo especificado, em graus. Tipicamente um valor entre 0 e 
180. 
 
Material necessário 
 Um servo motor 
 Diversos fios jumpers 
 
 
 
Figura 7-23 - diagrama da atividade 12 
 
Linguagem Arduino I 
www.EADuino.com.br 
55 
 
 
Figura 7-24 - interligando os componentes com a placa Arduino 
 
 
/* 
 Curso Linguagem Arduino 
 ---------------------------------- 
 Servo Motor 
 ---------------------------------- 
 Atividade12 
 ---------------------------------- 
 www.EADuino.com.br 
 */ 
 
#include <Servo.h> 
 
Servo servoMotor; 
byte posicao = 0; 
byte pinoServo = 9; 
 
void setup() { 
 servoMotor.attach(pinoServo); 
} 
 
void loop() { 
 for(posicao = 0; posicao < 180; posicao++) { 
 servoMotor.write(posicao); 
 delay(15); 
 } 
 delay(100); 
} 
Linguagem Arduino I 
www.EADuino.com.br 
56 
 
8 Conclusão 
 
Chegamos ao final do curso Linguagem Arduino I. Naturalmente o assunto não se encerra aqui. 
Há outros comandos e funções que não foram explorados nesta apostila pelo motivo de exigir 
um conhecimento mais sólido da linguagem e também para não tornar este curso longo e 
cansativo. 
 
Acessem regularmente o site www.EADuino.com.br e acompanhem as novidades. 
 
Até a próxima. 
 
Equipe EADuino.