Arduino C++

Licenciado para - celso bruno junior - 05634201896 - Protegido por Eduzz.
com
TUDO EM UM ÚNICO LUGAR!
GUIA DE
REFERÊNCIA DO
ARDUINO
BRINCANDO COM IDEIAS
Licenciado sob Creative Commons

Attribution-Share Alike 3.0
Licenciado para - celso bruno junior - 05634201896 - Protegido por Eduzz.com
CONTEÚDO
LINGUAGEM
007 ESTRUTURA (ELEMENTOS C++)
061 VARIÁVEIS
146 FUNÇÕES
REFERÊNCIA
PREFÁCIO
295 ÍNDICE DETALHADO MINHA HISTÓRIA E A PAIXÃO POR TECNOLOGIA
299 BIBLIOGRAFIA Comecei a fazer estágio numa empresa

que desenvolvia softwares ... / p3
OPERAÇÕES
CÁLCULOS E DECISÕES
Conheça as diferentes operações
aritméticas responsáveis pelos cálculos
e decisões num programa. / p24
FUNÇÕES
TUDO PARA INVESTIGAR A PLACA E
REALIZAR ATIVIDADES
Conheça as funções para
controlar a plataforma Arduino e
fazer suas computações. / p146
WWW.BRINCANDOCOMIDEIAS.COM
Página 03
PREFÁCIO
AS IDEIAS NÃO VÊM PRONTAS!
PRECISAMOS TRABALHAR NELAS PARA TRANSFORMÁ-LAS
EM REALIDADE!
MARK ZUCKERBERG
A MINHA PAIXÃO PELA TECNOLOGIA

O amor pela tecnologia começou Um certo dia, o Sr. Adelino chegou
bem cedo em minha vida. em casa com um "Telejogo" da
Philco-Ford, emprestado de um
Eu sou eternamente grato ao meu colega. E foi por alguns dias que
pai, Adelino Sobrinho, que desde os brinquei pela primeira vez com um
meus 10 anos de idade, nunca videogame. E então comecei a ficar
poupou esforços para me permitir o curioso pela tecnologia.
contato com novidades
tecnológicas.
Desde as minhas primeiras

lembranças, ele trabalhava na
extinta Philco-Ford de Guarulhos, o
que me permitiu acesso ao mundo
da eletrônica e da informática.
Philco-Ford era uma indústria de

televisores, rádios e alguns outros O Telejogo era apenas um console,
equipamentos eletrônicos de com dois botões giratórios e um fio
última geração da época. para conectá-lo à televisão.
GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

PREFÁCIO Página 04
Ele tinha apenas três jogos: futebol,

tênis e paredão, que já estavam na
memória do console. Era possível
jogar entre duas pessoas ou
sozinho contra o computador.
Na imagem abaixo, repare como o

gráfico do jogo era muito simples.
E foi então meu primeiro

contato com um computador e
com a programação na linguagem
Basic. Isso aumentou ainda mais a
minha fascinação por tecnologia.
O TK85 foi um dos primeiros

computadores pessoais e se
limitava a um teclado compacto,
De vez em quando, meu pai uma fonte para ligá-lo na tomada
trazia alguns componentes e um fio para conectá-lo na
eletrônicos (LEDs, resistores), e eu televisão. E é isso mesmo: todo o
aproveitava para usá-los com circuito do TK85 ficava dentro
pilhas, fios e outros brinquedos. desse teclado.
Imagine só: meu carrinho de Eu passava horas digitando

rolimãs tinha faróis, seta, lanterna e programas em Basic e me divertia
até um painel iluminado com um fazendo perguntas com o comando
velocímetro improvisado de INPUT, avaliando as respostas com
algumas sucatas. o comando IF e mostrando
respostas com o comando PRINT.
Uma vez, meu pai chegou do
trabalho com um TK85! Para salvar os programas que
criava, eu dependia de um gravador
Nossa! Um computador em casa! de fita K7.

Minha única frustração era nunca Nessa época, comecei a fazer

conseguir gravar e recuperar um estágio numa empresa que
programa com sucesso. O que não desenvolvia softwares sob medida.
me impediu de colocar toda minha Também comecei aprender sobre o
curiosidade em prática no TK85. banco de dados DBASE e a
linguagem Clipper. Agradeço muito
Anos depois, voltei a ter acesso à ao Kedson, dono da KCS, pela
computação nas aulas de oportunidade proporcionada e por
informática do meu primeiro ano muitos ensinamentos.
do colegial - que equivale ao atual
primeiro ano do ensino médio. Assim, com meu pai me dando um
empurrãozinho mais uma vez,
Nas aulas, fazia exercícios nos compramos nosso primeiro PC!
Macintosh e esse foi meu primeiro Um 286 com monitor VGA colorido.
acesso à programação gráfica, Era muito top!
ainda na linguagem Basic.
Com dezenas de disquetes, aprendi
a usar um pouco do MS-DOS, Lotus
123, Wordstar e mais alguns
programas famosos na época.
Além disso, treinei muito o Turbo

Pascal e o Clipper que estava
aprendendo na escola e no estágio.
O exercício que mais tive trabalho,

e que me valeu uma boa nota, foi o
de criar uma paisagem gráfica na
tela, representando um deserto e
usando apenas comandos para
desenhar pontos e linhas.
No ano seguinte comecei a ter

aulas de programação em Turbo
Pascal, já no PC XT 8086.

Desde cedo percebi que, para Hoje, após alguns anos

mim, a melhor e mais prazerosa trabalhando, aprendendo e
forma de aprender sobre ensinando sobre Arduino, eu gosto
tecnologia era fazendo e vendo de falar para meus alunos que:
acontecer.
A melhor forma para se aprender
Quando precisei escolher pela sobre todas estas tecnologias é
carreira na faculdade, fiquei colocando a mão nos bits.
indeciso entre duas opções:
eletrônica ou informática. Eu E o Arduino, definitivamente nos
gostava muito das duas, mas tive permite esta sensação.
que decidir por apenas uma. Então
optei pela informática, avaliando
que teria mais oportunidades de
trabalho na época.
Fui muito feliz em minha carreira e

trabalhei em várias empresas.
Algumas pequenas, outras grandes.
Mas sempre senti aquela vontade
de aprender sobre a eletrônica.
Quando conheci o Arduino , fiquei

fascinado imediatamente! Porque
percebi que poderia aplicar os
meus conhecimentos de
informática e ainda conhecer mais
sobre eletrônica.
Rapidamente, percebi o enorme

potencial do Arduino para ajudar
as pessoas a aprenderem sobre
eletrônica, programação e até
informática. E ainda da forma que
eu sempre acreditei ser a melhor:
fazendo e vendo acontecer . Flavio Guimarães.

LINGUAGEM Página 07
ESTRUTURA
EU NÃO FALHEI! APENAS ENCONTREI 10 MIL MANEIRAS QUE NÃO FUNCIONAM
THOMAS EDSON
SKETCH OPERADORES ARITMÉTICOS
24 + (adição)
09 setup( )
25 - (subtração)
10 loop( )
26 * (multiplicação)
11 ; (ponto e vírgula)
27 / (divisão)
12 { } (chaves)
28 % (resto)
ESTRUTURAS DE CONTROLE 29 = (atribuição)
13 if
OPERADORES COMPARAÇÃO
14 else
30 == (igual a)
15 switch...case
31 != (diferente de)
16 while
32 < (menor que)
17 do...while
33 <= (menor que ou igual a)
18 for
34 > (maior que)
20 break
35 >= (maior que ou igual a)
21 continue
22 return
OPERADORES LÓGICOS
23 goto
36 ! (NÃO lógico)
37 && (E lógico)
38 | | (OU lógico)
CONTINUA NA PRÓXIMA PÁGINA ...

CONTINUAÇÃO ...
OPERADORES DE ATRIBUIÇÃO DIRETIVAS DE COMPILAÇÃO
39 ++ (incremento) 49 #define
40 -- (decremento) 50 #include
51 / / (comentário)
41 += (atribuição por adição)
52 /* */ (comentário em bloco)
42 -= (atribuição por subtração)
43 *= (atribuição por multiplicação)
44 /= (atribuição por divisão) OPERADORES DE BIT
45 %= (atribuição por resto) 53 & (E)

46 |= (atribuição por OU) 54 | (OU)
47 &= (atribuição por E) 55 ~ (NÃO)
48 ^= (atribuição por OU EXCLUSIVO) 56 ^ (OU EXCLUSIVO)
57 << (deslocamento à esquerda)
58 >> (deslocamento à direita)
OPERADORES PONTEIROS
59 & (referência ao endereço)
60 * (valor contido no endereço)

SKETCH Página 09
setup( )
A função setup() é chamada quando um sketch inicia. Use-a para
inicializar variáveis, configurar o modo dos pinos(INPUT ou OUTPUT),
inicializar bibliotecas, etc. A função setup() será executada apenas uma
vez após a placa ser alimentada ou acontecer um reset.
Código de Exemplo
int buttonPin = 3;
void setup() {
// Inicializa a porta serial
Serial.begin(9600);
// configura o pino 3 como INPUT
pinMode(buttonPin, INPUT);
}
void loop() {
// ...
}

SKETCH Página 10
loop( )
Depois de criar uma função setup(), a qual inicializa e atribui os valores
iniciais, a função loop() faz precisamente o que o seu nome sugere, e
repete-se consecutivamente enquanto a placa estiver ligada, permitindo o
seu programa mudar e responder a essas mudanças. Use-a para controlar
ativamente uma placa Arduino.
Código de Exemplo
int buttonPin = 3;
// setup inicializa a porta serial e o pino para o botão
void setup() {
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}
// loop checa o estado do botão repetidamente, e envia
// pela serial um 'H' se este está sendo pressionado
void loop() {
if (digitalRead(buttonPin) == HIGH) {
Serial.write('H');
}
else {
Serial.write('L');
}
delay(1000);
}

SKETCH Página 11
; (ponto e vírgula)
Usado para encerrar um comando.
Código de Exemplo
int a = 13;
Notas e Advertências
Se esquecer de encerar uma linha com um ponto e vírgula, irá resultar em
um erro de compilação.
Algumas vezes, a mensagem de erro pode até mencionar a falta de um

ponto e vírgula, contudo nem sempre essa falta será anunciada.
Se um erro de compilação incompreensível ou aparentemente ilógico

aparecer, uma das primeiras coisas a se checar é a falta do ponto e vírgula
no código anterior à linha mencionada na mensagem de erro do
compilador.

SKETCH Página 12
{ } (chaves)
O uso das chaves é uma característica importante da linguagem C++.
Elas são usadas em diversas estruturas diferentes e às vezes podem até
confundir alguns iniciantes.
Uma chave "{" deve ser sempre fechada por outra chave "}". Uma condição
como essa, é frequentemente chamada de "chaves balanceadas".
A IDE Arduino inclui uma forma conveniente de checar o balanço de duas
chaves: escolha uma chave, ou até mesmo clique no ponto de inserção
logo após a chave, assim a outra chave do par será destacada!
É muito comum chaves desbalanceadas resultarem em erros enigmáticos
e, às vezes, dificultar serem encontrados num programa longo.
Por causa de seu uso variado, as chaves são incrivelmente importantes,
uma vez que mover uma chave pode afetar dramaticamente o
funcionamento de um programa.
Código de Exemplo em Funções

void minhafuncao(tipo argumento) {
// comando(s)
}
Código de Exemplo em Laços de Repetição

while (expressão boolena) {
/ / co m a n d o ( s )
}
do {
// comando(s)
} while (expressão boolena);
f o r ( i n i c i a l i z a ç ã o ; c o n d i ç ã o ; i n cr e m e n t o ) {
// comando(s)
}
Código de Exemplo em Condições

if (expressão boolena) {
// comando(s)
}
e l s e i f ( e x p r e s s ã o b o o l e na ) {
// comando(s)
}
else {
// comando(s)
}

ESTRUTURAS DE CONTROLE Página 13
if
O comando if checa uma condição e executa o comando a seguir ou um
bloco de comandos delimitados por chaves, se a condição é verdadeira
('true').
Sintaxe
i f ( c on d i ç ã o ) {
//comando(s)
}
Parâmetros
condição: uma expressão booleana, isto é, que pode resultar apenas
em true ou false.
Código de Exemplo
if (x > 120) {
d i g i ta l W r i t e ( p i n o L E D , H I G H ) ;
}
if (x > 120) {
digitalWrite(pinoLED, HIGH);
}
if (x > 120) {
digitalWrite(pinoLED, HIGH);
}
if ( x > 1 2 0 ) {
digitalWrite(pinoLED1, HIGH);
d i g i t a l Wr i t e ( p i n o L E D 2 , H I G H ) ;
} // todas as formas acima estão corretas
As chaves podem ser omitidas depois de um comando if. Se isso é feito, a
próxima linha (definida pelo ponto e vírgula) é interpretada como o único
comando condicional. Para mais de um comando, use as chaves para
delimitar o bloco de comandos.
As expressões sendo testadas dentro dos parênteses geralmente requerem

o uso de um ou mais dos operadores lógicos ou de comparação.

else
A combinação "if…e lse" permite maior controle sobre o fluxo de código
que o comando mais básico "if", porque concede a múltiplos testes serem
agrupados juntos. Uma cláusula "else" (se presente) será executada caso a
condição do comando "if" resulte em false. O "else" pode prosseguir com
outro teste "if", de modo que vários testes, mutualmente exclusivos, sejam
executados ao mesmo tempo. Cada teste irá proceder para o próximo até
que um teste resultando em verdadeiro (true) seja encontrado. Quando for
encontrado, o bloco de código correspondente à condição será executado
e o programa então continuará, a partir da linha seguinte, uma estrutura
"if-else" completa. Se nenhum teste resultar em verdadeiro, o
bloco else padrão é executado. Note que um bloco "else if" pode ser usado
sem um bloco "else" no final, bem como vice-versa. Um número
praticamente ilimitado de blocos "else if" conectados é permitido.
Sintaxe
i f ( c on d i ç ã o ) {
//comando(s)
}if (condição1) {
// faz coisa A
}
else if (condição2) {
// faz coisa B
}
else {
// faz coisa C
}
Código de Exemplo
if (temperatura >= 70) {
/ / P e r i g o ! D e s l i ga r o s i s t e m a
}
else if (temperatura >= 60 && temperatura < 70) {
//Cuidado! Requerida a atenção do usuário
}
else {
/ / S e g u r o ! C o n ti n u e a s t a r e f a s u s u a i s . . .
}

switch ... case

Da mesma forma que o comando if, o comando switch case controla o
fluxo do programa, permitindo ao programador especificar código
diferente para ser executado em várias condições. Em particular, um
comando switch compara o valor de uma variável aos valores
especificados nos comandos case. Quando é encontrado um
comando case cujo valor é igual ao da variável, o código para esse
comando case é executado. A palavra-chave "break" interrompe o
comando switch e é tipicamente usada no final de cada case. Sem um
comando break, o comando switch irá continuar a executar as expressões
seguintes (desnecessariamente) até encontrar um break, ou até o final do
comando switch ser alcançado.
Sintaxe
s w i t c h ( v a r) {
case valor1:
// comando(s)
break;
case valor2:
// comando(s)
break;
de f a u l t:
// comando(s)
break;
}
Parâmetros
var: uma variável para ser comparada com os vários cases. Tipos de dados
permitidos: int, char
valor1, valor2: constantes. Tipos de dados permitidos: int, char
Código de Exemplo
switch (var) {
case 1:
/ / f a z a l g o q u a n d o va r é i g u a l a 1
break;
case 2:
// faz algo quando var é igual a 1
break;
d e f a u l t:
/ / S e n e n h u m d o s a n t e ri o r e s , f a z o c a s o p a d r ã o d e f a u l t
// default é opcional
break;
}

while
Uma repetição em loop de "while" irá ocorrer continuamente até que a
expressão dentro dos parênteses "( )" se torne falsa. Algo deve mudar a
variável testada, caso contrário o loop while nunca se encerrará. Das
possibilidades, acontece tanto em seu código (com uma variável
incrementada, por exemplo) quanto em uma condição externa (a leitura
de um sensor).
Sintaxe
while (condição) {
// código a ser executado repetidamente
}
Parâmetros
condição: é uma expressão booleana que resulta em true ou false.
Código de Exemplo
var = 0;
w hil e ( v ar < 2 0 0 ) {
/ / f a z a l g o r e pe t iti v o 2 0 0 v e z e s
var++;
}

do ... while
A repetição "do…w hile" funciona da mesma forma que o verificado em
"while", com a diferença de que a condição é testada no final do "loop", tal
que o loop será executado pelo menos uma vez.
Sintaxe
do {
// bloco de comandos
} while (condição);
Parâmetros
condição: é uma expressão booleana que é avaliada como verdadeira ou
falsa, respectivamente true ou false na linguagem Arduino.
Código de Exemplo
int x = 0;
do {
delay(50); / / e s p e r a o s s e n s o r e s e s t a b i li z a r e m
x = readSensors(); // checa os sensores
} while (x < 100);

for
O comando "for" é usado para repetir um bloco de código envolvido por
chaves. Um contador de incremento é geralmente utilizado para terminar
o loop. O comando "for" é útil para qualquer operação repetitiva, e é
usado frequentemente com vetores para operar em coleções de dados ou
pinos.
Sintaxe
for (inicialização; condição; incremento) {
//comando(s);
}
Parâmetros
inicialização: ocorre primeiro e apenas uma vez. Usado para iniciar uma
variável de controle da repetição.
condição: A cada repetição do loop, a condição é testada; se é verdadeira
(true), o bloco de comandos e o incremento são executados. Quando
a condição se torna falsa (false), o loop termina.
Código de Exemplo
/ / V a r i a o b r i l ho d e u m L E D u s a n d o u m p i n o P W M
i n t p i n o P W M = 1 0 ; / / L E D e m s é r i e c o m u m r e s is t or d e 4 7 0 o h m n o p i n o 1 0
void setup() {
// setup não necessário
}
void loop() {
for (int i = 0; i <= 255; i++) {
analogWrite(pinoPWM, i);
delay(10);
}
}
O comando "for" na linguagem C é muito mais flexível que os comandos
"for" encontrados em outras linguagens. Quaisquer dos três elementos da
sintaxe podem ser omitidos, porém o ponto e vírgula (';') é necessário.
Continua na próxima página...

for (continuação)
Além disso, os comandos para inicialização, condição e incremento

podem ser quaisquer comandos válidos na linguagem C (mesmo com
variáveis não relacionadas ao loop) e podem usar todos os tipos de dados
da linguagem, incluindo floats. Esses tipos de comandos "for" incomuns
podem prover soluções rápidas para alguns problemas raros de
programação.
Por exemplo, usar uma multiplicação no comando de incremento irá gerar

uma progressão logarítmica:
f o r (i n t x = 2 ; x < 1 0 0 ; x = x * 1 . 5 ) {
println(x);
}
Gera: 2,3,4,6,9,13,19,28,42,63,94.
Outro exemplo, aplica um efeito de "fading" crescente e decrescente em

um LED com apenas um loop de repetição em "for":
void loop() {
int x = 1;
for (int i = 0; i > -1; i = i + x) {
analogWrite(pinoPWM, i);
if (i == 255) {
x = -1; // muda a direção no pico
}
delay(10);
}
}

break
Este comando é usado para sair de um loop de repetição "for", "while" ou
"do…w hile", ignorando a condição de recorrência. Também é usada para
sair do comando "switch case".
No código seguinte, o break quebra o loop "for" quando o valor do sensor

exceder o limiar.
Código de Exemplo
int lim = 40;

for (int x = 0; x < 255; x ++) {
analogWrite(PWMpin, x);
sens = analogRead(sensorPin);
if (sens > lim) { // "foge" do o loop `for`
x = 0;
b r e a k;
}
delay(50);
}

continue
O comando "continue" serve para pular o resto da iteração atual em um
loop de repetição (for, while, ou do…w hile). Esse comando continua a
checar a expressão condicional do que é repetido e procede com
qualquer iteração subsequente.
O código abaixo escreve o valor de 0 a 255 ao pino PWMpin, mas pula os

valores no intervalo 41 a 119.
Código de Exemplo
for (int x = 0; x <= 255; x ++) {

if (x > 40 && x < 120) { // cria um salto nos valores
c o n t i n u e;
}
analogWrite(PWMpin, x);
delay(50);
}

return
Termina uma função e retorna um valor, caso desejado.
Sintaxe
return;
r e t urn v a l o r ; / / a m b a s a s f o r m a s s ã o v á l i d a s
Parâmetros
valor: qualquer variável ou constante de qualquer tipo de dado
Código de Exemplo
Uma função para comparar a saída de um sensor com um limiar

int checaSensor() {
if (analogRead(0) > 400) {
return 1;
}
else {
return 0;
}
}
O comando "return" é usual para testar um trecho de código sem precisar

"comentar" uma grande seção de código com possíveis erros.
v o i d l o o p () {
return;
// o restante do código com problema, aqui
// este código não será executado
}

goto
Transfere o fluxo do programa para um ponto rotulado no código.
Sintaxe
rótulo:
g o to r ó t u l o ; / / e n v i a o f l u x o d a e x e c u ç ã o d o p r o g r a m a p a r a o r ó t u l o
Código de Exemplo
O código abaixo "foge" de dentro de todos os laços caso a leitura no pino
analógico 0 seja maior que 250.
f o r ( b yt e r = 0 ; r < 2 5 5 ; r + + ) {
for ( b y t e g = 2 5 5 ; g > 0 ; g - - ) {
for (byte b = 0; b < 255; b++) {
if (analogRead(0) > 250) {
goto cancelar;
}
// mais comandos ...
}
}
}
cancelar:
// mais comandos ...
O uso do goto é desencorajado na programação em C++, e alguns autores
de bibliografias especializadas afirmam que sua utilização é raramente
necessária. Entretanto, se usado cuidadosamente, pode simplificar certos
programas! A razão pela qual muitos programadores desaprovam o uso do
goto é que, sem cuidado, é fácil criar um programa com fluxo indefinido,
ou seja, que não pode ser depurado. Tendo dito isso, há algumas
instâncias onde o comando goto pode ser bem-vindo, pois simplifica o
código. Uma dessas situações é sair de loops de repetição em "for"
profundamente aninhados, ou blocos "if" em determinadas condições.

OPERADORES ARITMÉTICOS Página 24
+ (adição)
Adição é uma das quatro operações aritméticas fundamentais. O
operador + (mais) atua em dois operandos para produzir a soma dos
mesmos.
Sintaxe
s o m a = o p e r an d o 1 + o p e r a n d o 2 ;
Parâmetros
soma: variável. Tipos de dados permitidos: int, float, double, byte, short,
long
operando1: variável ou constante. Tipos de dados permitidos: int, float,
double, byte, short, long
Código de Exemplo
i nt a = 5 ;
int b = 10;
int c = 0;
c = a + b; / / A v a r i á v e l ' c ' r e c e b e o v a l or 1 5 d e p o i s q u e e s s a o p e r a ç ã o é e x e c u t a d a
1. A operação de adição pode causar overflow se o resultado for maior
que o armazenado no tipo de dado (ex. adicionar 1 a um int com valor
32,767 resulta em -32,768).
2. Se um dos números (operandos) é do tipo float ou double, a
matemática de ponto flutuante será usada no cálculo.
3. Se os operandos são dos tipos de dado float ou double, e a variável que
armazena a soma é int, então apenas a parte inteira é salva no
resultado. A parte racional é perdida.
f l o at a = 5 . 5 ;
float b = 6.6;
int c = 0;
c = a + b; / / a v a r i á v e l ' c ' g u a r d a o v a l or 1 2 a p e n a s , e m v e z d e 1 2 . 1

- (subtração)
Subtração é uma das quatro operações aritméticas fundamentais. O
operador - (menos) atua em dois operandos para produzir a diferença do
segundo pelo primeiro.
Sintaxe
d i f e r e n ç a = o p e r an d o 1 - o p e r a n d o 2 ;
Parâmetros
diferença: variável. Tipos de dados permitidos: int, float, double, byte,
short, long
Código de Exemplo
i nt a = 5 ;
int b = 10;
int c = 0;
c = a - b; / / A v a r i á v e l ' c ' r e c e b e o v a l or - 5 d e p o i s q u e e s s a o p e r a ç ã o é e x e c u t a d a
1. A operação de subtração pode causar overflow se o resultado for menor
que o armazenado no tipo de dado (por exemplo, subtrair 1 de
um int com valor -32,768 resulta em 32,767).
2. Se um dos operandos (números) for do tipo float ou double, a
3. Se os operandos são do tipo de dado float ou double e a variável que
armazena a diferença é int, então apenas a parte inteira será salva no
resultado. Por outro lado, a parte racional será perdida.
f l o at a = 5 . 5 ;
float b = 6.6;
int c = 0;
c = a - b; / / a v a r i á v e l ' c ' a r m a z e n a o v a l or - 1 e m v e z d o r e s u l t a d o e s p e r a d o - 1 . 1

* (multiplicação)
Multiplicação é uma das quatro operações aritméticas fundamentais. O
operador * (asterisco) atua em dois operandos para produzir o produto
entre eles.
Sintaxe
p r o d u t o = o p e r an d o 1 * o p e r a n d o 2 ;
Parâmetros
produto: variável. Tipos de dados permitidos: int, float, double, byte,
short, long
Código de Exemplo
i nt a = 5 ;
int b = 10;
int c = 0;
c = a * b; / / A v a r i á v e l ' c ' r e c e b e o v a l or 5 0 d e p o i s q u e e s s a o p e r a ç ã o é e x e c u t a d a
1. A operação de multiplicação pode causar overflow se o resultado for
maior que a capacidade que pode ser armazenada no tipo de dado.
2. Se um dos números (operandos) for do tipo float ou double, a
3. Se os operandos forem dos tipos de dados float ou double, e a variável
que armazena o produto é int, então apenas a parte inteira é salva no
resultado e a parte racional é perdida.
float a = 5.5;
float b = 6.6;
int c = 0;
c = a * b; // a variável 'c' armazena o valor 36 em vez do resultado esperado 36.3

/ (divisão)
Divisão é uma das quatro operações aritméticas fundamentais. O
operador / (barra) atua em dois operandos para produzir o resultado.
Sintaxe
r e s u l t a d o = o p e r an d o 1 / o p e r a n d o 2 ;
Parâmetros
resultado: variável. Tipos de dados permitidos: int, float, double, byte,
short, long
Código de Exemplo
i nt a = 5 0 ;
int b = 10;
int c = 0;
c = a / b; / / A v a r i á v e l ' c ' r e c e b e o v a l or 5 d e p o i s q u e e s s a o p e r a ç ã o é e x e c u t a d a
1. Se um dos números (operandos) for do tipo float ou double, a
2. Se os operandos forem dos tipos de dados float ou double, e a variável
que armazena a divisão for int, então apenas a parte inteira será salva
no resultado, enquanto a parte racional será perdida.
float a = 55.5;
float b = 6.6;
int c = 0;
c = a / b; // a variável 'c' armazena o valor 8 em vez do resultado esperado 8.409

% (resto)
Essa operação calcula o resto da divisão de um inteiro por outro. Esse
operador também pode ser chamado de módulo. Apesar do nome, não
confunda o operador módulo da computação (%) com o módulo da
matemática ( |x| ), que na linguagem Arduino é calculado através da
função abs(). O resto é útil para manter uma variável dentro de um
intervalo (ex. o tamanho de um vetor) e o símbolo % (porcentagem) é
usado para realizar suas operações.
Sintaxe
r e s t o = d i v i d en d o % d i v i s o r ;
Parâmetros
resto: variável. Tipos de dados permitidos: int, float, double
dividendo: variável ou constante. Tipos de dados permitidos: int
divisor: variável ou constante diferente de zero. Tipos de dados
permitidos: int
Código de Exemplo
i nt x = 0 ;
x = 7 % 5; / / x a g o r a c on t é m 2
x = 9 % 5; // x agora contém 4
/ * At u a l i z a u m v a l o r d o v e t o r a c a d a v e z e m u m l o o p * /
int values[10];
in t i = 0 ;
void setup() {}
void loop()
{
values[i] = analogRead(0);
i = (i + 1) % 10; // o operador módulo faz a variável i "rolar" pro próximo valor
}
O operador resto não funciona em floats.

= (atribuição)
O sinal de igual "=" na linguagem de programação C++ é chamado
operador de atribuição. Seu significado é diferente das aulas de
matemática, onde ele indica uma equação ou igualdade. O operador de
atribuição indica ao microcontrolador que compute qualquer valor ou
expressão que estiver à direita do sinal de igual, armazenando na variável
à esquerda do sinal de igual.
Código de Exemplo
i nt s e n s V a l ; // declara uma variável inteira chamada sensVal
sensVal = analogRead(0); // armazena a tensão do pino analógico 0 em SensVal
1. A variável à esquerda do operador de atribuição ( sinal = ) precisa ser
um tipo de dado capaz de armazenar o resultado da operação. Se ela
não for grande o suficiente para guardar o valor, o resultado
armazenado será incorreto. Para mais informações sobre seu tamanho,
veja os tipos de dados da linguagem Arduino.
2. Não confunda o operador de atribuição [ = ] (sinal de igual único) com
o operador de comparação [ == ] (sinal de igual duplo), o qual avalia se
se duas expressões são iguais.

OPERADORES DE COMPARAÇÃO Página 30
== (igual a)
Compara a variável à esquerda com o valor ou variável à direita do
operador. Retorna verdadeiro (true) quando os dois operandos são iguais.
Note que você pode comparar variáveis de diferentes tipos de dados, mas
isso pode gerar resultados imprevisíveis. Portanto, é recomendado
comparar variáveis do mesmo tipo de dados incluindo o atributo
signed/unsigned.
Sintaxe
x == y; // é verdadeiro se x é igual a y e é falso se x não é igual a y
Parâmetros
x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double,
byte, short, long
Código de Exemplo
if (x == y) { // testa se x é igual a y
// faz algo apenas se o resultado da comparação é verdadeiro
}

!= (diferente de)
operador. Retorna verdadeiro (true) quando os operandos não são iguais.
Note que você pode comparar variáveis de tipos de dados diferentes, mas
isso pode gerar resultados imprevisíveis. Logo, é recomendado comparar
variáveis do mesmo tipo de dados incluindo o atributo signed/unsigned.
Sintaxe
x != y; // é falso se x é igual a y e é verdadeiro se x não é igual a y
Parâmetros
byte, short, long
Código de Exemplo
if (x != y) { // testa se x é diferente de y
}

< (menor que)

operador. Retorna verdadeiro (true) quando o operando à esquerda é
menor que o operando à direita. Note que você pode comparar variáveis
de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis.
Assim sendo, é recomendado comparar variáveis do mesmo tipo de dados
incluindo o atributo signed/unsigned.
Sintaxe
x < y; // é verdadeiro se x é menor que y e é falso se x é igual ou maior que y
Parâmetros
byte, short, long
Código de Exemplo
if (x < y) { // testa se x é menor que y
}
Números positivos são maiores que números negativos.

<= (menor que ou igual a)

menor ou igual ao operando à direita. Repare que você pode comparar
variáveis de tipos de dados diferentes, mas isso pode gerar resultados
imprevisíveis. Por isso, é recomendado comparar variáveis do mesmo tipo
de dados incluindo o atributo signed/unsigned.
Sintaxe
x <= y; // é verdadeiro se x é menor ou igual a y e é falso se x é maior que y
Parâmetros
byte, short, long
Código de Exemplo
if (x <= y) { // testa se x é menor que ou igual a y
}

> (maior que)

maior que o operando à direita. Note que você pode comparar variáveis
de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis.
Portanto, é recomendado comparar variáveis do mesmo tipo de dados
incluindo o atributo signed/unsigned.
Sintaxe
x > y; // é verdadeiro se x é maior que y e é falso se x é igual ou menor que y
Parâmetros
byte, short, long
Código de Exemplo
if (x > y) { // testa se x é maior que y
}

>= (maior que ou igual a)

maior ou igual ao operando à direita. Perceba que você pode comparar
variáveis de tipos de dados diferentes, mas isso pode gerar resultados
imprevisíveis. Por isso, é recomendado comparar variáveis do mesmo tipo
de dados incluindo o atributo signed/unsigned.
Sintaxe
x >= y; // é verdadeiro se x é maior ou igual a y e é falso se x é menor que y
Parâmetros
byte, short, long
Código de Exemplo
if (x >= y) { // testa se x é maior que ou igual a y
}

OPERADORES LÓGICOS Página 36
! (NÃO lógico)
O NÃO lógico resulta em verdadeiro se o operando é falso, e vice-versa.
Vale lembrar que condições verdadeiras e falsas na linguagem Arduino são
representadas por true e false, respectivamente.
Código de Exemplo
Esse operador pode ser usado dentro da condição de um laço if.
i f (!x ) { / / s e x n ã o é t r u e
// código a ser executado
}
Pode ser usado para inverter o valor booleano.

x = !y ; / / o v a l o r b o o l e a n o i n v e r t i d o d e y é g u a r d a d o e m x
O NÃO bitwise ~ (til) é muito diferente do NÃO booleano ! (ponto de
exclamação).

&& (E lógico)
O E lógico resulta em verdadeiro apenas se ambos os operandos forem
verdadeiros. Lembrando que condições verdadeiras e falsas na linguagem
Arduino são representadas por true e false, respectivamente.
Código de Exemplo
Esse operador pode ser usado dentro da condição de um loop "if".
if (digitalRead(2) == HIGH && digitalRead(3) == HIGH) { //se AMBOS botões estão em HIGH
// código a ser executado caso as duas condições sejam verdadeiras
}
Tome cuidado para não confundir o operador booleano E, && (e comercial
duplo); com operador bitwise E, & (e comercial único). Eles são usados
para propósitos diferentes.

| | (OU lógico)
O OU lógico resulta em verdadeiro se pelo menos um dos operandos for
verdadeiro. Ressaltamos que as condições verdadeiras e falsas na
linguagem do Arduino são representadas por true e false, respectivamente.
Código de Exemplo
Esse operador pode ser usado dentro da condição de um laço if.
if (x > 0 || y > 0) { // se x ou y é maior que zero

// código a ser executado
}
Não confunda o operador OU booleano || (pipe duplo) com o operador OU
bitwise | (pipe único).

OPERADORES DE ATRIBUIÇÃO Página 39
++ (incremento)
Incrementa o valor de uma variável em 1.
Sintaxe
x+ +; // incrementa x em um e retorna o valor antigo de x
+ +x ; // incrementa x em um e retorna o novo valor de x
Parâmetros
x: variável. Tipos de dados permitidos: int, byte, short, long
Retorna
O valor original ou incrementado da variável, que depende se o operador
está à esquerda ou direita da variável.
Código de Exemplo
x = 2;
y = + +x ; // x agora contém 3, y contém 3
y = x+ +; / / x c o n t é m 4 , m a s y a i nd a c o n t é m 3

-- (decremento)
Decrementa, isto é, "diminui" o valor de uma variável em 1.
Sintaxe
x- -; // decrementa x em um e retorna o valor antigo de x
- -x ; // decrementa x em um e retorna o novo valor de x
Parâmetros
x: variável. Tipos de dados permitidos: int, byte, short, long
Retorna
O valor original ou decrementado da variável, dependendo se o operador
estiver à esquerda ou à direita da variável.
Código de Exemplo
x = 2;
y = - -x ; // x agora contém 1, y contém 1
y = x- -; / / x c o n t é m 0 , m a s y a i nd a c o n t é m 1

+= (atribuição por adição)

Essa é uma abreviação conveniente para realizar a adição de uma variável
com outra variável, ou até mesmo uma constante.
Sintaxe
x += y; // equivalente a expressão x = x + y;
Parâmetros
byte, short, long
Código de Exemplo
x = 2;
x += 4; // x agora contém 6

-= (atribuição por subtração)

Essa é uma abreviação usada para realizar a subtração de uma variável com
outra variável ou constante.
Sintaxe
x -= y; // equivalente a expressão x = x - y;
Parâmetros
byte, short, long
Código de Exemplo
x = 20;
x -= 2; // x agora contém 18

*= (atribuição por multiplicação)

Essa abreviação realiza a multiplicação de uma variável com outra variável
ou constante.
Sintaxe
x *= y; // equivalente a expressão x = x * y;
Parâmetros
byte, short, long
Código de Exemplo
x = 2;
x *= 2; // x agora contém 4

/= (atribuição por divisão)

Essa é uma abreviação utilizada para realizar a divisão de uma variável com
outra variável ou constante.
Sintaxe
x /= y; // equivalente a expressão x = x / y;
Parâmetros
byte, short, long
Código de Exemplo
x = 2;
x /= 2; // x agora contém 1

%= (atribuição por resto)

Esse é um atalho para calcular o resto quando um inteiro é dividido por
outro e, ainda, poder atribuí-lo de volta à variável cujo cálculo foi feito.
Sintaxe
x %= divisor; // equivalente a expressão x = x % divisor;
Parâmetros
x: variável. Tipos de dados permitidos: int
divisor: variável or constante não zero. Tipos de dados permitidos: int
Código de Exemplo
int x = 7;
x %= 5; // x agora contém 2
1. O operador de atribuição de resto não funciona em floats.
2. Se o primeiro operando é negativo, o resultado será negativo ou zero.
Portanto, o resultado de x %= 10 nem sempre estará entre 0 e 9 se x for

negativo.

|= (atribuição por OU)

O operador de atribuição composta bitwise OU |= é frequentemente usado
com uma variável e uma constante para "setar" (mudar pra 1) bits
particulares em outra variável.
Uma revisão do operador bitwise OU |:

0 0 1 1 operando1
0 1 0 1 operando2
----------
0 1 1 1 (operando1 | operando2) - resultado retornado
Sintaxe
x |= y; // equivalente a x = x | y;
Parâmetros
x: variável. Tipos de dados permitidos: char, int, long
y: variável ou constante. Tipos de dados permitidos: char, int, long
Ao lidar com bits em um operador bitwise, é conveniente usar o
modificador binário com constantes na representação. Os números ainda
são os mesmos em outras representações, só não são tão fáceis de
entender. Além disso, B00000000 é mostrado, mas zero em qualquer
outro formato também é zero. Consequentemente, para setar os bits 0 e 1
de um variável, ao mesmo tempo, deixando o resto da variável intocado,
usa-se o operador de atribuição por bitwise OU (|=) com a constante. Por
exemplo: B00000011
1 0 1 0 1 0 1 0 variável
0 0 0 0 0 0 1 1 máscara
----------------------
1 0 1 0 1 0 1 1
Abaixo a mesma representação com os bits da variável substituídos pelo símbolo x
x x x x x x x x variável
0 0 0 0 0 0 1 1 máscara
----------------------
x x x x x x 1 1
Então: meuByte = B10101010;
meuByte |= B00000011; // igual a B10101011;

&= (atribuição por E)

O operador de atribuição composta E &= é usado com uma variável e uma
constante para forçar determinados bits de alguma variável para 0. Isso é
frequentemente chamado de "limpar" ou "resetar" os bits.
Uma revisão do operator bitwise E &:

0 0 1 1 operando1
0 1 0 1 operando2
----------
0 0 0 1 (operando1 & operando2) - resultado retornado
Sintaxe
x &= y; // equivalente a x = x & y;
Parâmetros
Por estarmos lidando com bits de um operador bitwise, é recomendado
usar o modificador binário com constantes na representação. Os números
ainda serão os mesmos em outras representações, só não são tão fáceis de
entender. Também, B00000000 é mostrado para claridade, mas zero em
qualquer outro formato será zero. Por consequência - para limpar os bits
0 e 1 de um variável, ao mesmo tempo deixando o resto da variável
intocado, use o operador de atribuição por bitwise E (&=) com a constante
B11111100
1 0 1 0 1 0 1 0 variável
1 1 1 1 1 1 0 0 máscara
----------------------
1 0 1 0 1 0 0 0
1 1 1 1 1 1 0 0 máscara
----------------------
x x x x x x 0 0
meuByte &= B11111100; // igual a B10101000;

^= (atribuição por OU EXCLUSIVO)

O operador de atribuição composta bitwise OU EXCLUSIVO ^= é
frequentemente utilizado com uma variável e uma constante para "inverter"
(ou trocar) bits particulares de uma variável.
Uma revisão do operador bitwise OU EXCLUSIVO ^:

0 0 1 1 operando1
0 1 0 1 operando2
----------
0 1 1 0 (operando1 ^ operando2) - resultado retornado
Sintaxe
x ^= y; // equivalente a x = x ^ y;
Parâmetros
Por lidar com bits em um operador bitwise, torna-se conveniente usar o
modificador binário com constantes na representação. Os números são os
mesmos em outras representações, só não são tão fáceis de se entender.
B00000000 é mostrado também para esclarecer, mas zero em qualquer
outro formato é zero. Consequentemente, para inverter os bits 0 e 1 de um
variável ao mesmo tempo, deixando o resto da variável intocado, use o
operador de atribuição por bitwise OU EXCLUSIVO (^=) com a constante
B00000011
1 0 1 0 1 0 1 0 variável
0 0 0 0 0 0 1 1 máscara
----------------------
1 0 1 0 1 0 0 1
0 0 0 0 0 0 1 1 máscara
----------------------
x x x x x x ~x ~x
meuByte ^= B00000011; // igual a B10101001;

DIRETIVAS DE COMPILAÇÃO Página 49
#define
#define é uma diretiva muito útil da linguagem C++ que permite ao
programador dar um nome a um valor constante antes do programa ser
compilado. Constantes definidas no Arduino não ocupam espaço na
memória de programa do chip. O compilador irá substituir referências a
essas constantes pelo valor definido no tempo de compilação. No entando,
isso pode ter alguns efeitos colaterais desagradáveis! Por exemplo: se o
nome de uma constante que foi definida com #defined for incluído em
outra constante ou nome de uma variável, o texto seria trocado pelo
número (ou texto) definido com #define. Em geral, a palavra-chave const é
recomendada para se definir constantes e deveria ser usada em vez de
#define.
Sintaxe
#define nomeDaConstante valor
Código de Exemplo
#define pinoLED 3
//O compilador substituirá qualquer menção de pinoLED por 3 no tempo de compilação.
Não há ponto e vírgula após a diretiva #define. Se você incluir uma, o
compilador irá acusar erro.
Similarmente, incluir sinal de igual após #define também resultará em
erros.
#define pinoLED 3; // isso é inválido
#define pinoLED = 3 // também é inválido

#include
A diretiva #include é usada para incluir bibliotecas externas ao seu sketch.
Isso dá acesso a um grande número de bibliotecas em formato padrão da
linguagem C (grupos de funções prontas), além de bibliotecas escritas
especialmente para a linguagem Arduino.
Note que #include, similarmente a #define, não é terminado com um ponto

e vírgula. O compilador mostrará mensagens de erro se você adicionar um.
Código de Exemplo
Esse exemplo inclui a biblioteca Servo para que suas funções possam ser
usadas para controlar um servomotor.
#include <Servo.h>
Servo meuservo; // cria um objeto do tipo Servo para controlar um servomotor
void setup() {
meuservo.attach(9); // associa o motor no pino 9 ao objeto meuservo
}
void loop() {
for (int pos = 0; pos <= 180; pos += 1) { // vai de 0 graus a 180 graus
// em passos de 1 grau
meuservo.write(pos); // diz ao servo para ir para a posição na variável
'pos'
delay(15); // espera 15ms para que o servo chegue a posição
}
for (int pos = 180; pos >= 0; pos -= 1) { // // vai de 180 graus a 0 graus
meuservo.write(pos); // diz ao servo para ir para a posição na variável
'pos'
delay(15); // espera 15ms para que o servo chegue a posição
}
}

/ / (comentário)
Comentários são textos no programa que são usados para informar você e a
outros a forma como o programa funciona. Eles são ignorados pelo
compilador e não fazem parte do arquivo gravado no chip, então não
ocupam nenhum espaço na memória flash do microcontrolador. O
propósito dos comentários é lhe ajudar a entender (ou lembrar) como
funcionam partes do seu código, ou informar a outros também como o seu
programa funciona.
Um comentário de uma só linha começa com // (duas barras adjacentes).

Esse tipo de comentário termina automaticamente no final da linha. O que
quer que seja que estiver após // até o final da linha será ignorado pelo
compilador.
Código de Exemplo
Há duas formas diferentes de se usar um comentário de uma só linha:
// O pino 13 tem um LED conectado na maioria das placas Arduino.

// Dá um nome para esse LED:
int led = 13;
digitalWrite(led, HIGH); // acendo o LED (HIGH é o nível da tensão)
Quando experimentar com código, "comentar" partes de seu programa é
uma forma conveniente de remover partes problemáticas do seu código
temporariamente. Isso mantém as linhas de código, mas as transformam
em comentários, de modo que o compilador apenas as ignora. Isso pode
ser útil quando você estiver procurando um problema, ou quando um
programa se recusar a compilar e o erro de compilação for enigmático, ou
inútil.

/* */ (comentário em bloco)
Comentários são textos no programa usados para informar você e outros
sobre como ele funciona. São ignorados pelo compilador e não fazem parte
do arquivo gravado no chip. Portanto, não ocupam nenhum espaço na
memória flash do microcontrolador. O propósito dos comentários ajuda a
entender (ou lembrar) o funcionamento das partes de seu código ou
informar outros como o seu programa funciona.
O começo de um comentário em bloco, ou comentário de múltiplas linhas,
é marcado pelo símbolo /* enquanto */ marca seu final. Esse tipo de
comentário é chamado de bloco, pois pode se estender por mais de uma
linha, uma vez que o compilador encontre o símbolo /* ele ignora o texto
seguinte até encontrar um */.
Código de Exemplo
/* Esse é um comentário válido */
/*
Blink
Acende um LED por um segundo, depois apaga por um segundo, repetidamente.
Esse código encontra-se um domínio público.
(outro comentário válido)
*/
/*
if (gwb == 0) { // Comentários de única linha não permitidos dentro de um comentário
em bloco
x = 3; /* Mas outro comentário de múltiplas linhas, não. Esse comentário é
inválido */
}
// Não esqueça o símbolo para "fechar" o comentário - deve estar balanceado!
*/
Quando utilizar códigos, o ato de comentar partes de seu programa é uma
forma conveniente de remover fragmentos problemáticos de modo
temporário. Isso mantém as linhas de código, mas as transforma em
comentários (o que faz o compilador apenas as ignorar). Sua utilidade
vem quando estiver procurando um problema, ou quando um programa se
recusar a compilar e o erro de compilação for enigmático, ou inútil.

OPERADORES DE BIT Página 53
& (E)
O operador bitwise E em C++ é um único & (e comercial ou ampersand),
usado entre duas expressões inteiras. O operador E bit-a-bit atua em cada
bit dos operandos de forma independente, segundo a regra: se ambas
entradas forem 1, a saída resultante será 1, do contrário o resultado será 0.
Outra forma de expressão disso é:
0 0 1 1 operando1
0 1 0 1 operando2
----------
0 0 0 1 (operando1 & operando2) - resultado retornado
No Arduino, o tipo int é um valor 16-bit, então & usado entre dois operandos

do tipo int causa 16 operações bit-a-bit E simultâneas.
Código de Exemplo
Em um fragmento de código do tipo:
int a = 92; // em binário: 0000000001011100
int b = 101; // em binário: 0000000001100101
int c = a & b; // resultado: 0000000001000100, ou 68 em decimal.
Cada um dos 16 bits em a e b são processados com o operador &, e todos os

16 bits resultantes são armazenados em c, resultando no valor binário
01000100, que é 68 em decimal.
Um dos usos mais comuns da operação bit-a-bit E é selecionar um bit

particular (ou bits) de um valor inteiro, frequentemente chamado
de masking. Veja abaixo um exemplo (específico para arquitetura AVR):
PORTD = PORTD & B00000011;

// apaga os bits 2 - 7, deixando o valor dos pinos PD0 e PD1 intocados (xx & 11 == xx)

| (OU)
O operador bitwise OU em C++ é o caractere | (barra vertical). Da mesma
forma que o operador &, esse opera independentemente em cada bit dos
dois operandos. O resultado da operação OU entre dois bits é 1 se qualquer
um ou ambos os bits de entrada forem 1, do contrário é 0.
Explicado de outra forma:
0 0 1 1 operando1
0 1 0 1 operando2
----------
0 1 1 1 (operando1 | operando2) - resultado retornado
Código de Exemplo
int a = 92; // em binário: 0000000001011100
int b = 101; // em binário: 0000000001100101
int c = a | b; // resultado: 0000000001111101, ou 125 em decimal.
Um dos usos mais comuns do OU bit-a-bit é "setar" um ou mais bits em um

valor.
// Nota: Esse código é específico para a arquitetura AVR

// configura os bits de direção para os pinos 2 a 7, deixa 0 e 1 intocados (xx | 00 ==
xx)
// Equivale a pinMode(pino, OUTPUT) para os pinos 2 a 7 no Arduino Uno ou Nano
DDRD = DDRD | B11111100;
// o mesmo que pinMode(pino, OUTPUT) para os pinos 2 a 7

~ (NÃO)
O operador NÃO bit-a-bit em C++ é o caractere til ~. Diferentemente
de & e |, o operador bitwise NÃO é aplicado a um único operando a sua
direita. O NÃO Bitwise muda cada bit para seu valor oposto: 0 se torna 1, e 1
se torna 0.
Em outras palavras:
0 1 operando1
-----
1 0 ~o p e r a n d o 1
Código de Exemplo
int a = 103; // binário: 0000000001100111
i n t b = ~a ; // binário: 1111111110011000 = -104
Você pode ficar surpreso ao ver um número negativo como -104 no
resultado dessa operação. Isso acontece porque o bit mais significativo de
um valor int é o chamado bit de sinal. Se esse bit é 1, o número é
interpretado como negativo. Essa codificação de números positivos e
negativos é referido como complemento de dois. Para mais informações,
veja o arquivo da Wikipédia a respeito do complemento de dois.
Um comentário adicional: é interessante notar que para qualquer inteiro

x, ~x é o mesmo que -x - 1.
Às vezes, o bit de sinal em uma expressão pode causar alguns efeitos

indesejados, veja a página do operador de deslocamento à direita (>>), por
exemplo, para mais detalhes.

^ (OU EXCLUSIVO)
Na linguagem C++ existe um operador um pouco incomum chamado de OU
EXCLUSIVO, também conhecido como XOR (pronunciado "écs-ór", em
inglês) bit-a-bit. O operador XOR bitwise é escrito usando o símbolo ^. Uma
operação XOR bit-a-bit resulta em 1 somente se os bits de entrada forem
diferentes. Se iguais, o resultado será zero. Precisamente:
0 0 1 1 operando1
0 1 0 1 operando2
----------
0 1 1 0 (operando1 ^ operando2) - resultado retornado
Código de Exemplo
int x = 12; // binário: 1100
int y = 10; // binário: 1010
int z = x ^ y; // binário: 0110, ou decimal 6
O operador ^ é frequentemente utilizado para trocar (isto é, mudar de 0

para 1, ou 1 para 0) alguns dos bits em uma expressão inteira. Em uma
operação XOR se há um 1 no bit da máscara, aquele bit é invertido; se há
um 0, o bit não é invertido e continua o mesmo.
// Nota: Esse código usa registradores específicos para microcontroladores

// AVR (Uno, Nano, Leonardo, Mega, etc.)
// Ele não irá compilar para outras arquiteturas
void setup() {
DDRB = DDRB | B00100000;
// configura PB5 (pino 13 no Uno/Nano, pino 9 no Leonardo/Micro, pino 11 no Mega)
// como OUTPUT
Serial.begin(9600);
}
void loop() {
PORTB = PORTB ^ B00100000; // inverte PB5, deixa os outros bits intocados
delay(100);
}

<< (deslocamento à esquerda)

O operador de deslocamento à esquerda << faz os bits do operando à
esquerda do operador serem deslocados para a esquerda pelo número de
posições especificadas no operando à direita do operador.
Sintaxe
v ar i á v e l < < n u m e r o _ d e _ b i t s ;
Parâmetros
variável: variável a ser modificada. Tipos de dados permitidos: byte, int,
long
numero_de_bits: um número menor ou igual 32. Tipos de dados
permitidos: int
Código de Exemplo
int a = 5; // binário: 0000000000000101
int b = a << 3; // binário: 0000000000101000, ou 40 em decimal
Quando você desloca um valor x por y bits (x << y), os y bits mais a
esquerda em x são perdidos, literalmente deslocados para fora da
existência:
int x = 5; // binário: 0000000000000101
int y = 14;
int resultado = x << y; // binário: 0100000000000000

>> (deslocamento à direita)

O operador de deslocamento à direita >> faz os bits do operando à
esquerda do operador serem deslocados à direita pelo número de posições
especificadas no operando à direita do operador.
Sintaxe
v ar i á v e l > > n u m e r o _ d e _ b i t s ;
Parâmetros
variável: variável a ser modificada. Tipos de dados permitidos: byte, int,
long
numero_de_bits: um número menor ou igual 32. Tipos de dados
permitidos: int
Código de Exemplo
int a = 40; // binário: 0000000000101000
int b = a >> 3; // binário: 0000000000000101, ou 5 em decimal
Quando você desloca x à direita por y bits (x >> y), e o bit mais
significativo em x é 1, o comportamento depende do tipo de dado de x. Se
x é do tipo int, o bit mais significativo é o bit de sinal, determinando se x
é negativo ou não, como pode ser visto com detalhes na página do tipo de
dado int. Nesse caso, o bit de sinal é copiado para os bits menos
significativos quando o valor é deslocado, por razões históricas:
int x = -16; // binário: 1111111111110000
int y = 3;
int resultado = x >> y; // binário: 1111111111111110
Esse comportamento, chamado extensão do sinal, é frequentemente

indesejável. Em vez disso, você pode querer que zeros sejam deslocados
da esquerda. Acontece que as regras do deslocamento à direita são
diferentes para expressões unsigned int, então você pode usar casting
para impedir que uns sejam copiados da esquerda:
int x = -16; // binário: 1111111111110000
int y = 3;
int resultado = (unsigned int)x >> y; // binário: 0001111111111110

OPERADORES DE PONTEIRO Página 59
& (referência ao endereço)

Referência é uma das características da linguagem C para uso
especificamente com ponteiros. O operador & ('e' comercial ou ampersand)
é utilizado para esse propósito. Se x é uma variável, então &x representa o
endereço da variável x.
Código de Exemplo
int *p; // declara um ponteiro para uma variável do tipo int
int i = 5, resultado = 0;
p = &i ; // agora 'p' contém o endereço de 'i'
resultado = *p; // 'resultado' recebe o valor contido no endereço apontado por 'p'
// isto é, recebe o valor de 'i', que é 5
Ponteiros são um dos assuntos mais complicados para iniciantes
aprenderem na linguagem C, e é possível escrever a grande maioria dos
sketches Arduino sem nunca encontrar ponteiros. No entanto, para
manipular certas estruturas de dados, o uso de ponteiros pode simplificar
o código. O conhecimento da manipulação de ponteiros é vantajoso de se
ter no seu kit de ferramentas.

OPERADORES DE PONTEIRO Página 60
* (valor contido no endereço)

Este operador é uma das características da linguagem C para uso
especificamente com ponteiros. O operador "*" (asterisco) é utilizado para
esse propósito. Se p é um ponteiro, então *p representa o valor contido no
endereço apontado por p.
Código de Exemplo
int *p; // declara um ponteiro para uma variável do tipo int
int i = 5;
int resultado = 0;
p = &i; // agora 'p' contém o endereço de 'i'
r e s u l t a d o = *p ; / / ' r e s u l t a d o ' r e c e b e o v a l o r c o n t i d o n o e n d e r e ç o a p o n t a d o p o r ' p '
// isto é, recebe o valor de 'i', que é 5
Ponteiros são um dos assuntos mais complicados para iniciantes
aprenderem na linguagem C, e é possível escrever a grande maioria dos
sketches Arduino sem nunca encontrar ponteiros. No entanto, para
manipular certas estruturas de dados, o uso de ponteiros pode simplificar
o código. O conhecimento da manipulação de ponteiros é vantajoso de se
ter em seu kit de ferramentas.

VARIÁVEIS
UMA PESSOA QUE NUNCA COMETEU UM ERRO, NUNCA TENTOU NADA DE NOVO
ALBERT EINSTEIN
TIPOS DE DADOS OPERADORES DE STRING

109 [] 113 > 117 !=
62 bool, boolean 110 + 114 >=
72 string 111 += 115 <
e byte
112 == 116 <=
75 unsigned char
63 char UTILITÁRIOS
76 unsigned int
64 double 118 PROGMEM
unsigned long
78
65 float 122 sizeof( )
79 vetor
67 int CONSTANTES
81 void
69 long 124 HIGH / LOW
82 word
70 short 126 INPUT / OUTPUT / INPUT_PULLUP
83 String () LED_BUILTIN
71 size_t 128
129 true / false

FUNÇÕES DE STRING
130 Constantes de ponto flutuante
85 charAt() 97 replace() Constantes inteiras

131
86 comparteTo() 98 reserve()
CONVERSÃO
87 concat() 99 setCharAt() 134 byte( )
88 c_str() 100 startsWith() 135 char( )
89 endsWith() 101 substring() 136 float( )
90 equals() 102 toCharArray() 137 int( )
91 equalsIgnoreCase() 103 toDouble() 138 long( )
92 getBytes() 104 toFloat() 139 word( )
93 indexOf() 105 toLowerCase() ESCOPO E QUALIFICADORES

140 const
94 lastIndexOf() 106 toUpperCase()
141 escopo
95 length() 107 trim()
142 static
96 remove() 108 toInt()
144 volatile
TIPOS DE DADOS Página 62
bool, boolean e byte

- bool pode armazenar dois valores: true or false.
- boolean é um termo para tipos de dados "não padrão" para bool definido
pelo Arduino.
- byte armazena valores numéricos de 8-bit sem sinal, de 0 a 255.
Sintaxe
bool var = val;
byte var = val;
Parâmetros
var: nome da variável
val: valor a ser atribuído à variável
Códigos de Exemplo (para bool e boolean)

O código abaixo mostra como usar o tipo de dado bool:
int LEDpin = 5; // LED no pino digital 5

int switchPin = 13; // botão conectado ao pino 13 e o outro terminal ao ground
bool running = false; //variável de tipo booleano
void setup() {
pinMode(LEDpin, OUTPUT);
pinMode(switchPin, INPUT);
digitalWrite(switchPin, HIGH); // ativa o resistor pull-up
}
void loop() {
if (digitalRead(switchPin) == LOW) {
// botão foi pressionado, o pull-up mantém o pino em HIGH internamente
delay(100); // delay para fazer o debounce no botão
running = !running; // troca o valor da variável running
digitalWrite(LEDpin, running); // indica via LED
}
}
O código abaixo mostra a diferença para o dado boolean:
boolean running = false; //variável do tipo boolean

void loop()
{
if (digitalRead(switchPin) == LOW)
{ // botão foi pressionado, o pull-up mantém o pino em HIGH internamente
delay(100); // delay para fazer o debounce no botão
running = !running; // troca o valor da variável running
digitalWrite(LEDpin, running); // indica via LED
}
}

char
É um tipo de dado usado para armazenar um caractere. Caracteres literais
são escritos em aspas simples, dessa forma: 'A' (para múltiplos caracteres -
ou seja, strings - use aspas duplas: "ABC").
No entanto, caracteres são armazenados como números. Você pode ver a
codificação na tabela ASCII. Isso significa que é possível fazer aritmética
com caracteres, na qual o valor ASCII para o caractere é usado (ex. 'A' + 1
tem valor 66, pois o valor ASCII da letra maiúscula A é 65). Veja a referência
de Serial.println para mais sobre como caracteres são traduzidos para
números.
O tipo de dado char ocupa ao menos 8 bits. É recomendado que se
utilize char apenas para armazenar caracteres. Para um tipo de dado sem
sinal, de um byte (8 bits), use o tipo de dado byte.
Sintaxe
c h ar v a r = v a l ;
Parâmetros
Código de Exemplo
char myChar = 'A';
char myChar = 65; // ambas as formas são equivalentes

double
Número de Ponto flutuante Double. No UNO e outras placas baseadas no
ATMEGA, ocupa 4 bytes. Isto é, nesses a impelmentação do double é
exatamente a mesma do float, sem nenhum ganho em precisão.
No Arduino Due e outras placas com SAMD, doubles usam 8 bytes, ou seja,
precisão de 64 bits.
Sintaxe
d o u b l e v a r = v a l ;
Parâmetros
Usuários que pegam código de outras fontes que inclua variáveis double
podem desejar examinar o código para conferir se a precisão é diferente
do que realmente é alcançado nas placas Arduino baseadas em
microcontroladores ATMEGA.

float
Tipo de dado para números de ponto flutuante, ou seja, um número
racional. Números de ponto flutuante são frequentemente usados para
aproximar valores analógicos a contínuos, porque possuem maior resolução
que inteiros (int). Números de ponto flutuante podem ser tão grandes
quanto 3.4028235E+38 ou pequenos quanto -3.4028235E+38.
Floats são armazenados em 32 bits (4 bytes) de memória e possuem apenas
6-7 dígitos decimais de precisão. Isso para o número total de dígitos, não
de dígitos à direita do ponto decimal. Diferentemente de outras
plataformas, onde se pode ter mais precisão usando-se um double (até 15
dígitos), no Arduino, o double possui o mesmo tamanho que float.
Números de ponto flutuante não são exatos, e podem gerar resultados
estranhos quando comparados. Por exemplo, 6.0 / 3.0 pode não ser igual a
2.0. Você deveria, em vez disso, checar se o valor absoluto da diferença
entre dois números é menor que algum número.
A matemática em números de ponto flutuante também é muito mais lenta
que em inteiros ao se realizar cálculos, então deve ser evitada se, por
exemplo, um loop tem que ser executado em alta velocidade para uma
função de tempo crítico. Programadores frequentemente fazem o possível
para converter cálculos em números flutuantes para matemática em
inteiros para aumentar a velocidade, mas sacrificando precisão.
Quando fizer cálculos com floats, você precisa adicionar um ponto decimal,
do contrário o número será tratado como um int. Veja a página
sobre constantes de ponto flutuante para mais detalhes.
Sintaxe
f l o a t v a r = v a l ;
Parâmetros

float (continuação)
Código de Exemplo
float myfloat;
float sensorCalbrate = 1.117;
int x;
int y;
float z;
x = 1;
y = x / 2; // y agora contém 0, ints não podem guardar frações
z = (float)x / 2.0; // z agora contém 0.5 (você deve usar 2.0, não 2)

int
Ints (integer ou inteiros) são os tipos dos dados primários para
armazenamento de números.
No Arduino Uno (e outras placas baseadas em micros ATmega) um int
armazena um valor 16-bit (2 bytes). Isso garante um intervalo de -32,768 a
32,767 (um valor mínimo de -2^15 e um valor máximo de (2^15) - 1). No
Arduino Due e outras placas baseadas em micros SAMD (como o MKR1000 e
Zero), um int armazena um valor 32-bit (4 bytes). O que garante um
intervalo de -2,147,483,648 a 2,147,483,647 (um valor mínimo de -2^31 e um
valor máximo de (2^31) - 1).
Variáveis int armazenam números negativos com uma técnica chamada
(Complemento de 2). O bit mais significativo, as vezes chamado de o "bit de
sinal", indica que o número é negativo. O resto dos bits são invertidos e 1 é
adicionado.
O Arduino cuida dos detalhes nas operações com números negativos por
você, tal que operações aritméticas funcionam transparentemente na
maneira esperada. No entanto, pode-se haver uma complicação ao lidar
com o operador de deslocamento de bits a direita (>>).
Sintaxe
i n t v a r = v a l ;
Parâmetros

int (continuação)
Código de Exemplo
int contador = 0; //cria uma variável integer chamada 'contador'
void setup() {
Serial.begin(9600); // usa a porta serial para imprimir o número
}
void loop() {
contador++; // soma 1 ao int contador a cada execução do loop
Serial.println(contador); // Imprime o estado atual do contador
delay(1000);
}
Quando variáveis com sinal são forçadas a exceder sua capacidade
máxima ou mínima, elas estouram; ou do Inglês, sofrem overflow. O
resultado de um overflow é imprevisível, então isso deve ser evitado. Um
sintoma típico de um overflow é a variável "rolar" de sua capacidade
máxima para a mínima ou vice-versa, mas não é sempre o caso. Se você
deseja esse comportamento, use o tipo unsigned int.

long
Variáveis long são variáveis de tamanho extendido para armazenamento de
números, armazenam 32 bits (4 bytes), de -2,147,483,648 a 2,147,483,647.
Ao se fazer cálculos com inteiros, pelo menos um dos números deve ser
seguido por um L, forçando-o a ser um long. Veja a página sobre Constantes
Inteiras para detalhes.
Sintaxe
l o n g v a r = v a l ;
Parâmetros
Código de Exemplo
l o n g s p e e d O f Li g h t = 1 8 6 0 0 0 L ; // veja a página sobre constantes inteiras para uma
explicação sobre o 'L'

short
O tipo short é um tipo de dado 16-bit.
Em todos os Arduinos (baseados no ATMega ou ARM) um short armazena
um valor 16-bit (2 bytes). Isso fornece um intervalo de -32,768 a 32,767 (valor
mínimo de -2^15 e valor máximo de (2^15) - 1).
Sintaxe
s h o r t v a r = v a l ;
Parâmetros
Código de Exemplo
sh o r t l e d P i n = 1 3

size_t
Size_t é um tipo de dado capaz de representar o tamanho de qualquer
objeto em bytes. Exemplos do uso de size_t são o tipo do retorno
de sizeof() e Serial.print().
Sintaxe
s i z e _ t v a r = v a l ;
Parâmetros

string
As strings de texto podem ser representadas de duas maneiras. Você pode
usar o tipo de dado String, que é parte do core desde a versão 0019, ou
você pode fazer uma string com um vetor do tipo char e terminá-lo em
null. Essa página descreve o segundo método. Para mais detalhes sobre o
objeto String, que possui mais funcionalidades ao custo de mais memória
ocupada, veja a página sobre os objetos String.
Sintaxe
Todos as declarações seguintes são válidas para strings.
char Str1[15];
char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};
char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
char Str4[] = "arduino";
char Str5[8] = "arduino";
char Str6[15] = "arduino";
Possibilidades para declarar strings

- Declarar um vetor de chars sem inicializá-lo, como em Str1
- Declarar um vetor de chars (com um char extra) e o compilador irá
adicionar o caractere null requerido, como em Str2
- Adicionar o caractere null explicitamente, Str3
- Inicializar uma string constante em aspas; o compilador irá ajustar o
tamanho do vetor para a string mais o caractere null terminador, como em
Str4
- Inicializar o vetor com o tamanho explícito e a string constante, Str5
- Inicializar o vetor, deixando espaço extra para uma string maior, Str6

string (continuação)
Terminação em null
Geralmente, strings são terminadas com um caractere null (código ASCII 0).
Isso permite que funções (como Serial.print()) saibam onde está o final de
uma string. Do contrário, essas funções continuariam lendo bytes
consequentes da memória que não fazem parte da string.
Isso significa que sua string precisa ter espaço para mais um caractere
além do texto que você quer que ela contenha. Por isso que Str2 e Str5
precisam ter oito carcteres, mesmo que "arduino" seja apenas sete - a
última posição é automaticamente preenchida com um caractere null. Str4
é automaticamente ajustada para oito caracteres, sendo um para o null
extra. Em Str3, o caractere null foi explicitamente incluído, adicionando-se
'\0'.
Note que é possível criar uma string sem uma caractere null no final (ex. se
se você tivesse especificado o tamanho de Str2 como sete em vez de oito).
Porém isso irá quebrar a maioria das funções que usam strings, então você
não deve fazê-lo intencionalmente. Se você notar algo se comportando
estranhamente no seu programa (operando em caracteres fora da string),
isso pode ser o problema.
Aspas simples ou aspas duplas?

As strings são sempre definidas envoltas em aspas duplas ("Abc") e
caracteres são sempre definidos envoltos em aspas simples('A').
Escrevendo strings muito longas

Você pode escrever uma string muito longa em várias linhas, da seguinte
forma:
c h a r m y S t r i n g [ ] = " Es s a é a p r i m e i r a l i n h a "
" Essa é a segunda linha"
" etcetera";

string (continuação)
Vetores de strings
Frequentemente é conveniente, quando lidando-se com grandes
quantidades de texto como um projeto com um display LCD, configurar um
vetor de strings. Como strings por sí próprias já são vetores, isso é na
verdade um exemplo de um vetor bidimensional.
No código abaixo, o asterisco depois do tipo de dado char “char*” indica
que esse é um vetor de "ponteiros". Todos os nomes de vetores são na
verdade ponteiros, então isso é necessário para criar um vetor de vetores.
Ponteiros são uma partes mais esotéricas da linguagem C++ para inicinates
entenderem, mas não é necessário entender ponteiros profundamente para
usá-los efetivamente aqui.
Código de Exemplo
c h a r * m y S t r i n g s [ ] = { " Th i s i s s t r i n g 1 " , " T h i s i s s t r i n g 2 " , " T h i s i s s t r i n g 3 " ,
"This is string 4", "This is string 5", "This is string 6"
};
void setup() {
Serial.begin(9600);
}
void loop() {
for (int i = 0; i < 6; i++) {
Serial.println(myStrings[i]);
delay(500);
}
}

unsigned char
Um tipo de dado sem sinal, que ocupa um byte na memória. O mesmo que
o tipo de dado byte. O tipo de dado unsigned char armazena valores de 0 a
255.
Para consistência do estilo de programação Arduino, o tipo de dado byte é
preferido.
Sintaxe
u n s i g n e d c h a r v a r = v a l ;
Parâmetros
Código de Exemplo
O trecho de código abaixo cria uma variável do tipo unsigned char
u n s i g n e d ch a r m y C h a r = 2 4 0 ;

unsigned int
No UNO e outras placas baseadas nos microcontroladores ATmega,
unsigned ints (inteiros sem sinal) são o mesmo que o tipo int no que esses
também armazenam um valor de 2 bytes. Em vez de guardar números
negativos, no entanto, esses apenas armazenam valores positivos,
garantindo um intervalo útil de 0 a 65,535 ((2^16) - 1).
O Due e outras placas ARM armazenam um unsigned int em 4 bytes (32
bits), de 0 a 4,294,967,295 (2^32 - 1).
A diferença entre unsigned ints e ints (com sinal), está na forma como o bit
mais significativo, as vezes chamado de o bit "de sinal", é interpretado. No
tipo int do Arduino (que possui sinal), se o bit mais significativo é "1", o
número é interpretado como um número negativo, e os outros 15 bits são
interpretados com (complemento de 2).
Sintaxe
u n s i g n e d i n t v a r = v a l ;
Parâmetros
Código de Exemplo
O trecho de código abaixo cria uma variável unsigned int chamada ledPin e
a atribui o valor 13.
unsigned int ledPin = 13;

unsigned int (continuação)
Quando variáveis unsigned tem sua capacidade máxima excedida, elas
"estouram" e voltam para 0, e também o contrário. Exemplo:
unsigned int x;
x = 0;
x = x - 1; // x agora contém 65535
x = x + 1; // x agora contém 0
A matemática com variávies unsigned pode produzir resultados

inesperados, mesmo se a variável unsigned nunca estourar.
O microcontrolador aplica as seguintes regras:
O cálculo é feito de acordo com a variável de destino. Exemplo, se a
variável destino possui sinal, ele irá realizar o cálculo levando em conta o
sinal, mesmo que ambas as variáveis de entrada sejam unsigned.
No entanto, em um cálculo que requer um resultado intermediário, o
escopo da variável intermediária não é especificado pelo código. Nesse
caso, o micro irá usar matemática sem sinal para o resultado intermediário,
porque ambas as entradas são unsigned!
unsigned int x = 5;
unsigned int y = 10;
int resultado;
resultado = x - y; // 5 - 10 = -5, como esperado
resultado = (x - y) / 2; // 5 - 10 com matemática unsigned é 65530! 65530/2 = 32765
// solução: usar variáveis com sinal, ou fazer o cálculo passo a passo.
resultado = x - y; // 5 - 10 = -5, como esperado
resultado = resultado / 2; // -5/2 = -2 (matemática inteira, casas decimais não são
consideradas)
Então porque usar variáveis sem sinal?

- Quando o comportamento de estouro é desejado, ex. contadores
- A variável com sinal é muito pequena, e se quer evitar a perda de
memória e performance de long/float.

unsigned long
Variáveis unsigned long são variáveis de tamanho extendido para
armazenamento de números, que armazenam 32 bits (4 bytes).
Diferentemente de longs padrão, unsigned longs não guardam números
negativos, o que faz com que possam armazenar valores de 0 a
4,294,967,295 (2^32 - 1).
Sintaxe
u n s i g n e d l o n g v a r = v a l ;
Parâmetros
Código de Exemplo
O código abaixo cria uma variável do tipo long para guardar o número de
milissegundos desde que o programa iniciou.
unsigned long time; //variável do tipo long
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print("Time: ");
time = millis();
//imprime o tempo desde que o programa iniciou, em milissegundos
Serial.println(time);
// espera um segundo, para não enviar quantidades massivas de dados
delay(1000);
}

vetor
Um vetor (array) é uma coleção de variáveis que são acessadas com um
número índice. Vetores na linguagem C++, na qual o Arduino é baseado,
podem ser complicados, mas usar vetores simples é relativamente fácil.
Criando um Vetor
Todos os métodos abaixo são formas válidas de criar (declarar) um vetor.
int meusInts[6];
int meusPinos[] = {2, 4, 8, 3, 6};
int meusValSens[6] = {2, 4, -8, 3, 2};
char mensagem[6] = "hello";
Você pode declarar um vetor sem inicializá-lo, como em meusInts.

Em meusPinos, nós declaramos um vetor sem explicitamente escolher um
tamanho. O compilador conta os elementos e cria um vetor de tamanho
apropriado.
Finalmente você pode inicializar e também especificar o tamanho do vetor,
como em meusValSens. Note que quando declarar um vetor do tipo char,
um elemento a mais que sua inicialização é requerido, para armazenar o
caractere null necessário.
Acessando um Vetor
Vetores são indexados a partir de 0, isto é, referindo-se a inicialização dos
vetores acima, o primeiro elemento do vetor está no índice 0, então:
m e u s V a l Se n s [ 0 ] = = 2 , m e u s V a l S e n s [ 1 ] = = 4 ,
e assim por diante.

Isso também significa que em um vetor com dez elementos, o índice nove é
o último elemento. Então:
i n t m e u Ve t o r [ 1 0 ] = { 9 , 3 , 2 , 4 , 3 , 2 , 7 , 8 , 9 , 1 1 } ;
// meuVetor[9] contém 11
// meuVetor[10] é inválido e contém informação aleatória (endereço de memória fora do
vetor)

vetor (continuação)
Por esse motivo, você deve ser cuidadoso ao acessar vetores. Acessar um
elemento depois do final de um vetor (usar um índice maior que o tamanho
declarado - 1) é ler de uma parte da memória que pode estar em uso para
outros propósitos. Ler desses locais provavelmente não vai fazer mais que
retornar dados inválidos. Escrever em locais aleatórios da memória é
definitivamente uma má ideia e pode frequentemente levar a péssimos
resultados como crashes ou mal funcionamento do programa. Isso pode
também ser um bug difícil de encontrar.
Diferentemente de BASIC ou JAVA, o compilador C++ não faz checagem
para confirmar se o acesso a um elemento está dentro dos limites do
tamanho declarado do vetor.
Para atribuir um valor a um elemento do vetor:

meusValSens[0] = 10;
Para ler um elemento de um vetor:

x = mySensVals[4];
Vetores e loops For

Vetores são frequentemente manipulados dentro de loops for, onde o
contador do loop é usado como o índice para cada elemento. Por exemplo,
para imprimir os elementos de um vetor através da porta serial, você pode
fazer algo do tipo:
for (byte i = 0; i < 5; i = i + 1) {
Serial.println(meusPinos[i]);
}

void
A palavra chave void é usada apenas em declarações de funções. Ela indica
que é esperado que a função não retorne nenhuma informação para a
função da qual foi chamada.
Código de Exemplo
O código mostra como usar a palavra chave void.
// são realizadas ações nas funções "setup" e "loop"
// porém não é retornada nenhuma informação quando as mesmas são executadas
void setup() {
// ...
}
void loop() {
// ...
}

word
Uma variável word armazena um número sem sinal de ao menos 16 bits, de
0 A 65535.
Sintaxe
w o r d v a r = v a l ;
Parâmetros
Código de Exemplo
O trecho de código abaixo cria uma variável do tipo word.
word w = 10000;

String()
Constrói uma instância da classe String. Há múltiplas versões que
constroem Strings a partir de diferentes tipos de dados (ex. formatam-nos
como uma sequência de caracteres), incluindo:
- uma string constante de caracteres, em aspas duplas (ex. um vetor de
caracteres)
- um único caractere constante, em aspas simples
- uma outra instância de um objeto String
- um int constante ou long int
- um int constante ou long int, usando uma base especificada
- uma variável int ou long int
- uma variável int ou long int, usando uma base especificada
- um float ou double, usando um número especificado de casas decimais
Nesse texto, sequências de caracteres são chamadas strings, enquanto
instâncias da classe String (objetos) são chamados String.
Construir uma String a partir de um número resulta em uma String que
contém a representação ASCII desse número. A base padrão é dez, então:
String thisString = String(13);
Fornece a String "13". No entanto, você pode usar outras bases. Por exemplo,
String thisString = String(13, HEX);
que fornece a String "D", que é a representação hexadecimal do valor 13. Ou
se você preferir binário,
String thisString = String(13, BIN);
fornece a String "1101", que é a representação binária de 13.
Sintaxe
S t r i n g( v a l )
S t r i n g( v a l , b a s e )
S t r i n g( v a l , d e c i m a l P l a c e s )

String() (continuação)
Parâmetros
val: a variável a ser formatada como String - Tipos de dados
permitidos: string, char, byte, int, long, unsigned int, unsigned long, float,
double
base (opcional): a base na qual formatar valores
inteiros decimalPlaces (apenas se val é float ou double): o número desejado
de casas decimais
Retorna
Uma instância da classe String.
Código de Exemplo
Todas a seguir são declarações válidas para Strings.
String stringOne = "Hello String"; // usando uma string constante
String stringOne = String('a'); // convertendo um caractere
constante para uma String
S t r i n g s t r i n g T w o = S t r i n g ( " Th i s i s a s t r i n g " ) ; // convertendo uma string
constante para um objeto String
String stringOne = String(stringTwo + " with more"); // concatenando duas strings
String stringOne = String(13); // usando um inteiro constante
String stringOne = String(analogRead(0), DEC); // usando um int e uma base
especificada (decimal)
String stringOne = String(45, HEX); // usando um int e uma base
especificada (hexadecimal)
String stringOne = String(255, BIN); // usando um int e uma base
especificada (binário)
String stringOne = String(millis(), DEC); // usando um long e uma base
especificada
String stringOne = String(5.698, 3); // usando um float e o número de
casas decimais

FUNÇÕES DE STRING Página 85
charAt()
Acessa um caractere em uma determinada posição na String.
Sintaxe
minhaString.charAt(n)
Parâmetros
minhaString : uma variável do tipo String
n : a posição do caractere a ser lido da String
Retorna
O caractere na posição n da String.

compareTo()
Compara duas Strings, testando se uma vem antes da outra na tabela ASCII,
ou se são iguais. As Strings são comparadas caractere por caractere, usando
os valores ASCII dos caracteres. Isso significa, por exemplo, que 'a' vem
antes 'b', em ordem alfabética, mas depois de 'A' e 'B' etc. Números vem
antes das letras.
Sintaxe
minhaString.compareTo(minhaString2)
Parâmetros
minhaString2 : outra variável do tipo String
Retorna
um número negativo : se minhaString vem antes de minhaString2
0 : se minhaString é igual a minhaString2
um número positivo : se minhaString vem depois de minhaString2

concat()
Adiciona o parâmetro ao final da String.
Sintaxe
minhaString.concat(param)
Parâmetros
param : Tipos de dados permitidos String, string, char, byte, int, unsigned
int, long, unsigned long, float, double, e a __FlashStringHelper(macro F()) .
Retorna
true : sucesso
f alse : falha ( em qual a String é deixada como antes).

c_str()
Converte o conteúdo de um objeto String para uma string estilo C,
terminada em null. Note que isso dá acesso direto ao buffer da String e
deve ser usado com cuidado. Em particular, você não deve modificar a
string através do ponteiro retornado. Quando você modificar o objeto
String, ou quando esse é destruído, qualquer ponteiro previamente
retornado por c_str() se torna inválido e não deve ser mais utilizado.
Sintaxe
minhaString.c_str()
Parâmetros
Retorna
Um ponteiro para a versão em estilo C do objeto String.

endsWith()
Testa se uma String termina ou não com os caracteres de outra String.
Sintaxe
minhaString.endsWith(minhaString2)
Parâmetros
minhaString2 : outra variável do tipo String
Retorna
true : se minhaString termina com os carcateres de minhaString2
false : do contrário

equals()
Verifica se duas Strings são iguais. A comparação é case-sensitive (letras
maiúsculas e minúsculas são diferenciadas), o que significa que a String
"hello" não é igual a String "HELLO".
Sintaxe
minhaString.equals(minhaString2)
Parâmetros
minhaString, minhaString2 : variáveis do tipo String
Retorna
true : se minhaString é igual a minhaString2

equalsIgnoreCase()
Verifica se duas strings são iguais. A comparação, nesse caso, não é case-
sensitive, o que significa que a String "hello" é dada como igual a the String
"HELLO".
Sintaxe
minhaString.equalsIgnoreCase(minhaString2)
Parâmetros
Retorna
true : se minhaString é igual a minhaString2 (sem diferenciar maiúsculas e
minúsculas)
false : otherwise

getBytes()
Copia os caracteres da String para o buffer fornecido.
Sintaxe
minhaString.getBytes(buf, len)
Parâmetros
buf : o buffer no qual os caracteres devem ser copiados (byte [])
len : o tamanho do buffer (unsigned int)
Retorna
Nada

indexOf()
Localiza um caractere ou String dentro de outra String. Por padrão, busca
desde o começo da String, mas pode também começar de uma
determinada posição, permitindo encontrar todas as instâncias do
caractere ou String.
Sintaxe
minhaString.indexOf(string2)
minhaString.indexOf(string2, desde)
Parâmetros
string2 : a string a ser procurada - char ou String
desde : a posição a partir da qual iniciar a busca
Retorna
A posição da minhaString especificada dentro do objeto String, ou -1 se não
for encontrada.

lastIndexOf()
Localiza um caractere ou String dentro de outra String. Por padrão, busca
desde o final da String, mas pode também começar de uma determinada
posição, permitindo encontrar todas as instâncias do caractere ou String.
Sintaxe
minhaString.lastIndexOf(string2)
minhaString.lastIndexOf(string2, desde)
Parâmetros
string2 : a string a ser procurada - char ou String
from : a posição a partir da qual iniciar a busca (do final para o começo)
Retorna
A posição da string especificada dentro do objeto String, ou -1 se não for
encontrada.

length()
Retorna o comprimento da String, em caracteres. (Note que isso não inclui
caracteres null no final da String.)
Sintaxe
minhaString.length()
Parâmetros
Retorna
O comprimento da String em caracteres.

remove()
Modifica uma String, removendo os caracteres a partir de determinado
índice até o final da String, ou determinado número de caracteres a partir
do índice fornecido.
Sintaxe
minhaString.remove(index)
minhaString.remove(index, count)
Parâmetros
index : índice a partir do qual remover os caracteres -int
count : o número de caracteres a serem removidos a partir do indíce - int
Retorna
Nada
Código de exemplo
String greeting = "hello";
g r e et i n g . r e m o v e ( 2 , 2 ) ; // greeting agora contém "heo"

replace()
A função replace() permite substituir todas as instâncias de um
determinado caractere por outro caractere. Você pode também substituir
substrings de uma String com uma substring diferente.
Sintaxe
minhaString.replace(substring1, substring2)
Parâmetros
minhaString : Uma variável do tipo String
substring1 : Outra variável do tipo String
substring2 : Outra variável do tipo String
Retorna
Nada

reserve()
A função reserve() permite alocar um buffer de memória no objeto String
para manipular strings.
Sintaxe
minhaString.reserve(tamanho)
Parâmetros
tamanho : número de bytes na memória a serem reservados para
manipulação de strings - unsigned int
Retorna
Nada
Código de exemplo
String myString;
void setup() {
// Inicializa a Serial e espera a porta abrir:
Serial.begin(9600);
while (!Serial) {
; // Espera até a porta serial conectar. Necessário em placas com USB nativa
}
/ / R e s e r v a 2 6 b y t e s n o o b j et o m y S t r i n g e o s p r e e n c h e c o m o u t r a s s u b s t r i n g s
myString.reserve(26);
myString = "i=";
myString += "1234";
myString += ", is that ok?";
// imprime a String:
Serial.println(myString);
}
void loop() {
// nada a ser feito aqui
}

setCharAt()
Coloca um caractere em determinada posição da String. Não tem efeito em
índices fora do tamanho da String existente.
Sintaxe
minhaString.setCharAt(index, c)
Parâmetros
index : a posição a se escrever o caractere
c : o caractere a ser armazenado na posição dada
Retorna
Nada

startsWith()
Testa se uma String começa ou não com os caracteres de uma outra String.
Sintaxe
minhaString.startsWith(minhaString2)
Parâmetros
Retorna
true : se minhaString começa com os caracteres de minhaString2

substring()
Retorna uma substring de uma String. O índice do início é inclusivo (o
caractere correspondente é incluído na substring), mas o índice finalizador
opcional é exclusivo (o caractere correspondente não é incluído na
substring). Se o índice finalizador é omitido, a substring continua até o final
da String.
Sintaxe
minhaString.substring(inicio)
minhaString.substring(inicio, fim)
Parâmetros
minhaString : a variable of type String
inicio : o índice no qual começar a substring (inclusivo)
fim (optional): o índice no qual terminar a substring (exclusivo)
Retorna
A substring.

toCharArray()
Copia os caracteres da String para o buffer fornecido.
Sintaxe
minhaString.toCharArray(buf, compr)
Parâmetros
minhaString : umavariável do tipo String
buf : the buffer no qual os caracteres devem ser copiados(char [])
compr : o comprimento do buffer (unsigned int)
Retorna
Nada

toDouble()
Converte uma String válida para um double. A String fornecida deve
começar com um dígito. Se a String contém caracteres não-dígitos, a
função não faz a conversão. Por exemplo, as Strings "123.45", "123" e
"123peixe" são convertidas para 123.45, 123.00, e 123.00 respectivamente.
Note que "123.456" é aproximado como 123.46. Note também que floats
possuem apenas 6-7 digitos de precisão e que Strings mais longas podem
ser truncadas.
Sintaxe
`minhaString.toDouble()`
Parâmetros
Retorna
O número contido na String - float
Se não foi possível realizar uma conversão válida, porque a String não
começa com um número inteiro, o valor zero é retornado.

toFloat()
Converte uma String válida para um float. A String fornecida deve começar
com um dígito. Se a String contém caracteres não-dígitos, a função não faz
a conversão. Por exemplo, as Strings "123.45", "123" e "123peixe" são
convertidas para 123.45, 123.00, e 123.00 respectivamente. Note que "123.456"
é aproximado como 123.46. Note também que floats possuem apenas 6-7
digitos de precisão e que Strings mais longas podem ser truncadas.
Sintaxe
minhaString.toFloat()
Parâmetros
Retorna
O número contido na String - float

toLowerCase()
Converte uma String para sua versão composta apenas de letras
minúsculas. Antes da versão 1.0, toLowerCase() retornava um ponteiro para
uma nova String em vez de modificar o objeto String.
Sintaxe
minhaString.toLowerCase()
Parâmetros
Retorna
Nada

toUpperCase()
Converte uma String para sua versão composta apenas de letras
maiúsculas. Antes da versão 1.0, toUpperCase() retornava um ponteiro para
uma nova String em vez de modificar o objeto String.
Sintaxe
minhaString.toUpperCase()
Parâmetros
Retorna
Nada

trim()
Remove quaisquer espaços no começo ou final da String. Antes da versão
1.0, trim() retornava um ponteiro para uma nova String em vez de modificar
o objeto String.
Sintaxe
minhaString.trim()
Parâmetros
Retorna
Nada

toInt()
Converte uma String válida para um valor inteiro. A String deve começar
com um número inteiro. Se a String conter números não inteiros, a função
não irá realizar a conversão.
Sintaxe
minhaString.toInt()
Parâmetros
Retorna
O valor inteiro contido na String - long

OPERADORES DE STRING Página 109
[]
Permite acessar os caracteres de uma String individualmente.
Sintaxe
char thisChar = minhaString1[n]
Parâmetros
char thisChar - uma variável char
minhaString1 - uma variável String
int n - a posição do caractere a ser lido da String
Retorna
O carctere na posição n da String. O mesmo que charAt().

+
Combina, ou concatena duas Strings em uma única String. A segunda
String é anexada a primeira, e o resultado é colocado em uma nova String.
Funciona da mesma forma que string.concat().
Sintaxe
minhaString3 = minhaString1 + minhaString2
Parâmetros
minhaString1, minhaString2, minhaString3 - variáveis do tipo String
Retorna
Uma String que é a combinação das duas Strings originais.

+=
Acrescenta uma String no final de outra.
Sintaxe
minhaString += string2
Parâmetros
minhaString - uma variável do tipo String
Retorna
Nada

==
Verifica se duas Strings são iguais. A comparação é case-sensitive (letras
maiúsculas e minúsculas são diferenciadas), o que significa que a String
"hello" não é igual a String "HELLO". Possui a mesma funcionalidade que
string.equals().
Sintaxe
minhaString1 == minhaString2
Parâmetros
minhaString1, minhaString2 - variáveis do tipo String
Retorna
true : se as Strings passadas como parâmetros são iguais

>
Testa se a String à esquerda é maior que a String à direita. Esse operador
avalia Strings em ordem alfabética, no primeiro caractere no qual as duas
diferem. Então, por exemplo "b" > "a" e "2" > "1", mas "999" > "1000" porque 9
vem depois de 1.
Cuidado: Operadores de comparação de Strings podem ser confusos
quando você está comparando Strings numéricas, porque os numerais são
tratados como strings e não números. Se você precisa comparar números
numericamente, compare-os como ints, floats ou longs, e não como Strings.
Sintaxe
minhaString1 > minhaString2
Parâmetros
Retorna
true : se a String à esquerda é maior que String à direita

>=
Testa se a String à esquerda é maior que, ou igual, a String à direita. Esse
operador avalia Strings em ordem alfabética, no primeiro caractere no qual
as duas diferem. Então, por exemplo "b" >= "a" e "2" >= "1", mas "999" >=
"1000" porque 9 vem depois de 1.
Sintaxe
minhaString1 >= minhaString2
Parâmetros
Retorna
true : se a String à esquerda é maior que, ou igual, a String à direita

<
Testa se a String à esquerda é menor que a String à direita. Esse operador
avalia Strings em ordem alfabética, no primeiro caractere no qual as duas
diferem. Então, por exemplo "a" < "b" e "1" < "2", mas "999" > "1000" porque 9
vem depois de 1.
Sintaxe
minhaString1 < minhaString2
Parâmetros
Retorna
true : se a String à esquerda é menor que a String à direita

<=
Testa se a String à esquerda é menor que, ou igual, a String à direita. Esse
operador avalia Strings em ordem alfabética, no primeiro caractere no qual
as duas diferem. Então, por exemplo "a" ⇐ "b" e "1" ⇐ "2", mas "999" >=
"1000" porque 9 vem depois de 1.
Sintaxe
minhaString1 <= minhaString2
Parâmetros
Retorna
true : se a String à esquerda é maior que, ou igual, a String à direita

!=
Verifica se duas Strings são diferentes. A comparação é case-sensitive
(letras maiúsculas e minúsculas são diferenciadas), o que significa que a
String "hello" é diferente da String "HELLO". Possui funcionalidade
semelhante a função string.equals(), porém de maneira inversa.
Sintaxe
minhaString1 != minhaString2
Parâmetros
Retorna
true : se a as duas Strings são diferentes (case-sensitive)

UTILITÁRIOS Página 118
PROGMEM
Armazena dados na memória flash (memória de programa) em vez da
SRAM. Uma descrição dos vários tipos de memória das placas Arduino pode
ser encontrada (Em Inglês) nessa página.
A palavra-chave PROGMEM é um modificador de variáveis, que pode ser
usada apenas com os modificadores de variáveis definidos em pgmspace.h.
Ela diz ao compilador "armazene essa informação na memória flash", em
vez da SRAM, onde seria normalmente armazenada.
PROGMEM é parte da biblioteca pgmspace.h. Essa biblioteca é incluída
automaticamente em versões modernas da IDE, porém se você estiver
usando uma versão da IDE anterior à 1.0 (2011), iŕa precisar incluir ela no
topo do seu sketch, da seguinte forma:
#include <avr/pgmspace.h>
Sintaxe
const dataType variableName[] PROGMEM = {data0, data1, data3…
};
Onde:
dataType - qualquer tipo de dados
variableName - o nome do seu vetor de dados
Note que porque PROGMEM é um modificador de variável, não há uma
regra rigorosa de onde ele deve ir, então o compilador aceita todos os tipos
de definição abaixo, que também são sinônimos. Mesmo assim,
experimentos indicaram que, em várias versões do Arduino (relacionado a
versão do GCC), PROGMEM pode funcionar em uma localização e não em
outra. O exemplo da "tabela de strings" abaixo foi testado com a versão 13
do Arduino. Versões mais antigas da IDE podem funcionar melhor se
PROGMEM for incluído depois do nome da variável.
const dataType variableName[] PROGMEM = {}; // - use essa forma
const PROGMEM dataType variableName[] = {}; // - ou essa
const dataType PROGMEM variableName[] = {}; // - mas não essa

PROGMEM (continuação)
Enquanto PROGMEM pode ser usada em uma única variável, realmente só

vale a pena o trabalho de usá-lo se você tiver um bloco de dados maior
para ser armazenado, o que geralmente é mais fácil de fazer com vetores
(ou outra estrutura de dados da linguagem C++ fora do escopo da nossa
discussão atual).
Usar PROGMEM é também um procedimento realizado em dois passos.
Depois de resgatar os dados da memória flash, são requeridas funções
especiais, também definidas na biblioteca pgmspace.h, para ler os dados
da memória de programa para a memória SRAM, tal que possamos fazer
algo com eles.
Código de Exemplo
Os fragmentos de código abaixo ilustram como ler e escrever unsigned
chars (bytes) e ints (2 bytes) com PROGMEM.
// armazena alguns unsigned ints
const PROGMEM uint16_t conjunto[] = {65000, 32796, 16843, 10, 11234};
// armazena alguns chars
const char mensagem[] PROGMEM = {"Um pequeno jabuti xereta viu dez cegonhas felizes"};
unsigned int displayInt;
char meuChar;
void setup() {
Serial.begin(9600);
while (!Serial); // Espera a porta serial conectar. Necessário para placas com USB
nativa
// Lê da memória flash um int (2-bytes, ou word)
for (byte k = 0; k < 5; k++) {
displayInt = pgm_read_word_near(conjunto + k);
Serial.println(displayInt);
}
Serial.println();
// Lê um caractere da flash
for (byte k = 0; k < strlen_P(mensagem); k++) {
meuCHar = pgm_read_byte_near(mensagem + k);
Serial.print(meuCHar);
}
Serial.println();
}
void loop() {
//Nada aqui
}

Vetores de strings
É frequentemente conveniente, quando se trabalha com grandes
quantidade de texto como um projeto com display LCD, por exemplo,
preparar vetores de strings. Porque strings por si próprias já são vetores,
este é genuinamente um exemplo de um vetor bidimensional.Essas
estruturas tendem a ser muito grandes, de forma que colocá-las na
memória pode ser desejável. O código abaixo ilustra a ideia.
/*
demo com strings e PROGMEM
Como armazenar uma tabela de strings na memória de programa (flash),
e recuperá-los.
Informação resumida de:
http://www.nongnu.org/avr-libc/user-manual/pgmspace.html
Preparar uma tabela (vetor) de strings na memória de programa é relativamente
complicado,
mas esse template pode ser seguido.
P r e p a r a r a s s t r i n g s é u m p r oc e s s o e m d o i s p a s s o s . O p r i m e i r o é d e f i n i r a s s t r i n g s .
*/
#include <avr/pgmspace.h>
const char string_0[] PROGMEM = "String 0"; // "String 0" etc são as strings a serem
armazenadas - adapte ao seu programa.
const char string_1[] PROGMEM = "String 1";
// Então crie uma tabela para apontar para as suas strings.

const char *const string_table[] PROGMEM = {string_0, string_1, string_2, string_3,
string_4, string_5};
char buffer[30]; // Tenha certeza que esse buffer é grande o suficiente para armazenar
a maior string
void setup() {
Serial.begin(9600);
while (!Serial); // Espera a porta serial conectar. Necessário para placas com USB
nativa
Serial.println("OK");
}
void loop() {
/* Usar a tabela de strings da memória de programa requer o uso de funções especiais
para recuperar os dados.
A função strcpy_P copia uma string do espaço de programa para uma string na RAM
(em um "buffer").

Tenha certeza que o seu buffer na RAM é grande o suficiente para armazenar o que quer
q ue se j a q u e v o c ê e s t i v e r l e n d o d a m e m ó r i a d e p r o g r a m a . * /
for (int i = 0; i < 6; i++) {

strcpy_P(buffer, (char *)pgm_read_word(&(string_table[i]))); // Casts e
d e s r e f e r ê n ci a n e c e s s á r i o s , a p e n a s c o p i e .
S e r i a l . p r i n t l n ( bu f f e r ) ;
delay(500);
}
}
Por favor note que as variáveis devem ser definidas globalmente OU com a
palavra-chave static, para funcionarem com PROGMEM.
O código a seguir não funcionará dentro de uma função:
const char long_str[] PROGMEM = "Olá, gostaria de falar um pouco sobre mim mesmo.\n";
O código a seguir irá funcionar, mesmo se definido localmente dentro de

uma função:
const static char long_str[] PROGMEM = "Olá, gostaria de falar um pouco sobre mim
mesmo.\n";
A macro F()
Quando uma instrução do tipo:
S e r ia l . p r i n t ( " E s c r e v e a l g o n o M o n i t o r S e r i a l " ) ;
é usada, a string a ser impressa é normalmente salva na RAM. Se o seu

sketch imprime muita coisa no Monitor Serial, você pode facilmente
encher a RAM. Se você tiver espaço livre na memória flash, você pode
facilmente indicar ao compilador que a string deve ser salva na FLASH
usando a sintaxe:
S e r i a l . p r i n t ( F ( " Es s e t e x t o f o i g u a r d a d o n a m e m ó r i a f l a s h d o A r d u i n o " ) ) ;

sizeof()
O operador sizeof retorna o número de bytes de uma variável, ou o número
de bytes ocupados em um vetor.
Sintaxe
sizeof(variável)
Parâmetros
variável : uma variável ou vetor de qualquer tipo (ex: int, float, byte)
Retorna
O número de bytes em uma variável ou o número de bytes ocupados em
um vetor. (size_t)
Código de Exemplo
O perador sizeof é útil para manipular arrays (tais como strings), onde é
conveniente ser possível mudar o tamanho do vetor sem quebrar outras
partes do programa.
O programa abaixo imprime um string um caractere de cada vez. Tente
mudar o texto da frase.
char minhaStr[] = "Esse é um teste";
void setup() {
Serial.begin(9600);
}
vo i d l o o p ( ) {
for (byte i = 0; i < sizeof(minhaStr) - 1; i++) {
Serial.print(i, DEC);
Serial.print(" = ");
Serial.write(minhaStr[i]);
Serial.println();
}
delay(5000); // espera 5 segundos
}

sizeof() (continuação)
Note que sizeof retorna o número total de bytes. Então, para vetores de
tipos de dados maiores, como int, o loop for parece algo do tipo abaixo.
int meusValores[] = {123, 456, 789};
// this for loop works correctly with an array of any type or size
for (byte i = 0; i < (sizeof(meusValores)/sizeof(meusValores[0])); i++) {
// fazer algo com meusValores[i]
}
Note também que uma string apropriadamente formatada é encerrada com

o símbolo NULL, que tem valor ASCII 0.

CONSTANTES Página 124
Constantes
Constantes são expressões predefinidas na linguagem Arduino. Essas são
usadas para tornar os programas mais legíveis. As constantes da linguagem
Arduino são classificadas nos grupos:
Definições de níveis lógicos: HIGH e LOW

Quando lendo-se ou escrevendo-se o estado de um pino digital há apenas
dois valores possíveis que esse pino pode assumir: HIGH e LOW.
HIGH
O significado de HIGH (em relação a um pino) depende se o pino está
configurado como entrada ou saída (INPUT ou OUTPUT). Qaundo um pino é
configurado como INPUT com pinMode(), e lido com digitalRead(), o
Arduino (ATmega) irá retornar HIGH se:
- uma tensão maior que 3.0V está presente no pino (em placas 5V)
- uma tensão maior que 2.0V está presente no pino (em placas 3.3V)
Um pino pode também ser configurado como entrada (INPUT)
com pinMode(), e posteriormente colocado em HIGH com digitalWrite().
Isso irá ativar os resistores de 20K internos para pullup, o que irá forçar o
estado do pino para HIGH a menos que esse seja forçado para LOW por um
circuito externo. Isso é exatamente como a opção INPUT_PULLUP funciona,
sendo descrita abaixo em mais detalhes.
Quando um pino é configurado como saída (OUTPUT) com pinMode(), e
colocado em estado HIGH com digitalWrite(), a tensão no pino é:
- 5 volts (em placas 5V)
- 3.3 volts (em placas 3.3V)
Nesse estado, o pino pode fornecer corrente (ver limites para sua placa,
geralmente 40.0mA). Isso pode ser usado, por exemplo, para acender um
LED que está conecatdo ao ground através de um resistor limitador de
corrente.

Constantes (continuação)
LOW
O significado de LOW depende também se o pino está configurado como
entrada ou saída (INPUT ou OUTPUT). Quando um pino é configurado
como INPUT com pinMode(), e lido com digitalRead(), o Arduino (ATmega)
irá retornar LOW se:
- uma tensão menor que 1.5V está presente no pino (em placas 5V)
- uma tensão menor que 1.0V (aproximadamente) está presente no pino (em
placas 3.3V)
Quando um pino é configurado como OUTPUT com pinMode(), e colocado
em estado LOW com digitalWrite(), a tensão no pino é 0 volts (tanto em
placas de 5V como 3.3V boards). Nesse estado o pino pode absorver
corrente, o que pode ser usado, por exemplo, para acender um LED
conectado através de um resistor limitador de corrente aos +5 volts (ou +3.3
volts).

Constantes
Definições de modos para Pinos Digitais:

INPUT, INPUT_PULLUP e OUTPUT
Quando lendo-se ou escrevendo-se o estado de um pino digital há apenas
dois valores possíveis que esse pino pode assumir: HIGH e LOW.
Pinos Configurados como entrada - INPUT

Pinos configurados como INPUT com pinMode() são ditos estarem em um
estado de alta-impedância. Quando configurados como INPUT, esses pinos
exigem multíssimo pouco dos circuitos que estão verificando, equivalente a
um resistor de 100 Megohm na frente do pino. Isso faz com que sejam
muito úteis para ler sensores.
Se você configurar um pino como INPUT, e ler o estado de um botão
conectado a 5V, por exemplo, quando o botão estiver em estado aberto, a
entrada estará "flutuando", resultando em leituras imprevisíveis. Isso
acontece porque quando o botão está aberto, o pino não está conectado a
nenhuma tensão. Para assegurar uma leitura correta quando o botão está
aberto, um resistor de pull-up ou pull-down deve ser usado. O propósito
desse resistor é colocar o pino em um estado conhecido quando o botão
estiver aberto. Um resistor de 10K ohm é usado geralmente, pois possui
valor baixo o suficiente para previnir confiavelmente o estado flutuante, ao
mesmo tempo que é grande o suficiente para não usar muita corrente
qaundo o botão estiver fechado. Veja o tutorial Serial e Digital Read (Em
Inngl ẽ s) para mais informações.

Constantes (continuação)
Se um resistor de pull-down é usado, o pino de entrada estará

em LOW quando o botão estiver aberto e HIGH quando o btoão estiver
pressionado.
Se um resistor de pull-up é usado, o pino de entrada estará
em HIGH quando o botão estiver aberto e LOW quando o btoão estiver
pressionado.
Pinos Configurados como entrada com pull-up -

INPUT_PULLUP
O microcontrolador ATmega na maioria das placas Arduino possui resistores
pull-up internos (resistores conectados a alimentação internamente) que
você pode acessar. Se você preferir usar estes em vez de resistores de pull-
up externos, você pode usar o argumento INPUT_PULLUP na
função pinMode().
Veja o tutorial Input Pullup Serial (Em Inglês) para um exemplo do uso
desses resistores.
Pinos configurados como entradas com
ambos INPUT ou INPUT_PULLUP podem ser danificados ou destruídos se
são conectados a tensões abaixo de zero (tensões negativas) ou acima da
tensão de alimentação (5V ou 3V).
Pinos Configurados como saída - OUTPUT

Pinos configurados como OUTPUT com pinMode() são ditos estarem em um
estado de baixa-impedância. Isso significa que esses podem fornecer uma
quantidade substancial de corrente para outros circuitos. Os pinos de um
ATmega podem fornecer ou absorver correntes de até 40 mA (miliamperes)
para/de outros dispositivos/circuitos. Isso faz com que sejam úteis para
alimentar LEDs, pois LEDs tipicamente usam menos de 40 mA. Cargas que
exigem mais de 40 mA (ex. motores) irão reqeurer um transistor ou um
outro circuito de interface.
Pinos configurados como saídas podem ser danificados ou destruídos se
forem conectados diretamente ao ground ou na tensão de alimentação.

Constantes
Definição do LED na placa: LED_BUILTIN

A maioria das placas Arduino possuem um pino conectado a um LED on-
board através de um resistor. A constante LED_BUILTIN é o número do pino
ao qual o LED on-board está conectado. Na maioria das placas, esse LED é
conectado ao pino digital 13.

Constantes
Definições de Constantes Booleanas: true e

false
Existem duas constantes usadas para representar verdade e falsidade na
linguagem Arduino: true e false.
false
false é o mais fácil dos dois de ser definido. Sendo definido apenas como 0
(zero).
true
true é freqeuentemente dito ser definido como 1, o que está correto, porém
true possui uma definição mais ampla. Qualquer inteiro que não seja zero
é true, em um sentido booleano. Então -1, 2 e -200 são todos definidos
como true, também, em um sentido booleano.
Note que as constantes true e false são digitadas em caixa baixa,
diferentemente de HIGH, LOW, INPUT, and OUTPUT.

Constantes de Ponto Flutuante

Similar as constantes inteiras, constantes de ponto flutuante são usadas
para tornar o código mais legível. Constantes de ponto flutuante são
trocadas em tempo de compilação para o valor calculado para a expressão.
Código de Exemplo
n = 0.005; / / 0 . 0 0 5 é u m a co n s t a n t e d e p o n t o f l u t u a n t e
Constantes de ponto flutuante podem ser também expressas em uma
variedade de notações científicas. 'E' e 'e' são ambas aceitas como
indicadores de expoente.

Constantes Inteiras
Constantes Inteiras são números usados diretamente em um sketch, como
123. Por padrão, esses números são tratados como int mas você pode mudar
isso com os modificadores U e L (ver abaixo).
Normalmente, constantes inteiras são tratadas como inteiros na base 10
(decimais), mas notações especiais (modificadores) podem ser usados para
escrever-se números em outras bases.
Decimal (base 10)

Essa é a matemática de senso comum a qual você já está acostumado.
Constantes sem prefixos são assumidas como valores decimais.
Código de Exemplo
n = 101; // o mesmo que 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)
Binário (base 2)
Apenas os caracteres 0 e 1 são válidos.
Código de Exemplo
n = B101; // o mesmo que 5 decimal ((1 * 2^2) + (0 * 2^1) + 1)
O modificador binário funciona apenas em bytes (8 bits), ou seja, entre 0

(B0) e 255 (B11111111). Se for conveniente inserir um int (16 bits) em formato
binário, você pode fazê-lo com um procedimento em dois passos, como:
meuInt = (B11001100 * 256) + B10101010; // B11001100 é o byte mais significativo

Constantes Inteiras (continuação)
Octal (base 8)
Apenas os caracteres 0 a 7 são válidos. Valores octais são indicados pelo
prefixo "0" (zero).
Código de Exemplo
n = 0101; // o mesmo que 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)
Cuidado: é possível criar um bug difícil de encontrar (acidentalmente),

caso seja inserido um zero antes de uma constante, fazendo com que o
compilador interprete sua constante como octal.
Hexadecimal (base 16)

Os caracteres válidos são 0 a 9 e as letras A a F; A possui valor 10, B é 11, até
o F, que é 15. Valores hexadecimais são indicados pelo prefixo "0x". Note
que as letras A-F podem ser também iseridas em minúsculo (a-f).
Código de Exemplo
n = 0x101; // o qmesmo que 257 decimal ((1 * 16^2) + (0 * 16^1) + 1)

Constantes Inteiras (continuação)
Modificadores 'U' e 'L':
Por padrão, uma constante inteira é tratada como int com as mesmas
limitações desse tipo de dado. Para especificar uma constante inteira com
outro tipo de dado, termine-a com:
- um 'u' ou 'U' para forçar a constante para formato unsigned (sem sinal).
Exemplo: 33u
- um 'l' ou 'L' para forçar a constante para formato long. Exemplo: 100000L
- um 'ul' ou 'UL' para forçar a constante para formato unsigned long.
Exemplo: 32767ul

CONVERSÃO Página 134
byte()
Converte um valor para o tipo de dado byte.
Sintaxe
byte(x)
Parâmetros
x : um valor de qualquer tipo
Retorna
o valor passado para a função, convertido para o tipo byte

char()
Converte um valor para o tipo de dado char.
Sintaxe
char(x)
Parâmetros
Retorna
o valor passado para a função, convertido para o tipo char

float()
Converte um valor para o tipo de dado float.
Sintaxe
float(x)
Parâmetros
Retorna
o valor passado para a função, convertido para o tipo float
Veja a página da referência para o tipo float para detalhes sobre a
precisão e limitações dos números de ponto flutuante no Arduino.

int()
Converte um valor para o tipo de dado int.
Sintaxe
int(x)
Parâmetros
Retorna
O valor passado para a função, convertido para o tipo int

long()
Converte um valor para o tipo de dado long.
Sintaxe
long(x)
Parâmetros
Retorna
O valor passado para a função, convertido para o tipo long

word()
Converte um valor para o tipo de dado word.
Sintaxe
word(x)
word(h, l)
Parâmetros
h : o byte mais significativo (mais à esquerda) da palavra
l : o byte menos significativo (mais à direita) da palavra
Retorna
O valor passado para a função, convertido para o tipo word

const
A palavra-chave const é uma abreviação de constante. É um qualificador de
variáveis que modifica o comportamento da variável, fazendo com que a
variável seja de "apenas-leitura". Isso significa que a variável pode ser usada
como qualquer outra variável de seu tipo, mas seu valor não pode ser
mudado. Você terá um erro de compilação se tentar atribuir um valor a
uma variável const.
Constantes definidas com a palavra chave const obedecem as regras dos
escopos de variáveis que governam variáveis. Isso, e as armadilhas de se
usar #define, fazem com que o modificador const um método superior de
se definir constantes e é favorecido em lugar de se usar #define.
Código de Exemplo
const float pi = 3.14;
float x;
// ....
x = pi * 2; // constantes podem ser usadas em cálculos
pi = 7; // ilegal - você não pode modificar o valor de uma constante
#define ou const
Você pode usar ambos const ou #define para criar constantes numéricas
ou strings constantes. Para vetores, você irá precisar usar const. Em geral,
const é favorecido em lugar de #define ao se definir constantes.

escopo
Variáveis na linguagem de programação C++, a qual o Arduino usa, possuem
uma propriedade chamada escopo. Isso contrasta com antigas versões de
linguagens como o BASIC onde toda variável era uma variável global.
Uma variável global é uma que pode ser vista por todas as funções de um
programa. Diferentemente, variáveis locais são visíveis apenas às funções
nas quais são declaradas. No ambiente Arduino, qualquer variável
declarada fora de uma função (ex. setup(), loop(), etc. ), é uma variável _
global_.
Quando programas começam a ficar muito longos e complexos, variáveis
locais são uma forma útil de garantir que apenas uma função tenha acesso
as suas próprias variáveis. Isso previne erros de programação quando uma
função inadvertidamente modifica variáveis usadas por outra função.
Às vezes também é vantajoso declarar e inicializar uma variável dentro de
um loop for. Isso cria uma variável que pode ser acessada apenas dentro do
próprio bloco do loop for.
Código de Exemplo
int gPWMval; // qualquer função poderá acessar essa variável
vo i d s e t u p ( ) {
// ...
}
void loop() {
int i; // "i" é "visível" apenas dentro de "loop"
float f; // "f" é "visível" apenas dentro de "loop"
// ...
f o r (i n t j = 0 ; j < 1 0 0 ; j + + ) {
// a variável j pode ser acessada apenas dentro das chaves do loop for
}
}

static
A palavra-chave static é usada para criar variáveis que são visíveis para
apenas uma função. No entanto, diferentemente de variáveis locais, que são
criadas e destruidas toda vez que uma função é chamada, variáveis static
persistem entre chamadas da função, preservando seu valor.
Variáveis declaradas como static são criadas e inicializadas apenas a
primeria vez que uma função é chamada.
Código de Exemplo
/* RandomWalk
Paul Badger 2007
RandomWalk wanders up and down randomly between two
endpoints. The maximum move in one loop is governed by
the parameter "stepsize".
A static variable is moved up and down a random amount.
This technique is also known as "pink noise" and "drunken walk".
*/
#define randomWalkLowRange -20
#define randomWalkHighRange 20
int stepsize;
int thisTime;
int total;
S e r i a l. b e g i n ( 9 6 0 0 ) ;
}
void loop() {
// test randomWalk function
stepsize = 5;
thisTime = randomWalk(stepsize);
Serial.println(thisTime);
delay(10);
}
int randomWalk(int moveSize) {
static int place; // variable to store value in random walk - declared static so that
it stores
/ / v a l u e s i n b e t w e e n f u n c t i o n c a l l s , b u t n o o t h e r f u n c ti o n s c a n c h a n g e i t s v a l u e
place = place + (random(-moveSize, moveSize + 1));
if (place < randomWalkLowRange) { // check lower and
upper limits

static (continuação)
place = randomWalkLowRange + (randomWalkLowRange - place); // reflect number back in

positive direction
}
else if (place > randomWalkHighRange) {
place = randomWalkHighRange - (place - randomWalkHighRange); // reflect number
back in negative direction
}
re t u r n p l a c e ;
}

volatile
A palavra chave volatile é conhecida como um qualificador de variáveis, e é
geralmente usada antes do tipo de dado da variável, para modificar a forma
com qual o compilador e o programa tratam a variável.
Declarar uma variável como volatile é uma diretiva para o compilador. O
compilador é o software que traduz seu código C/C++ em linguagem de
máquina, que são as instruções reais entendidas pelo chip
microcontrolador na placa Arduino.
Especificamente, essa diretiva faz com que o compilador carregue a
variável da RAM e não de um registrador, que é uma localização temporária
da memória onde variáveis do programa são guardadas e manipuladas. Sob
certas circunstâncias, o valor de uma variável armazenada em registradores
pode ser impreciso.
Uma variável deve ser declarada volatile quando seu valor pode ser mudado
por algo além do controle da seção de código na qual ela aparece, como
uma thread paralela. No Arduino, o único lugar do código onde isso pode
ocorrer é em seções associadas com interrupções, chamadas de rotina de
serviço de interrupção (interrupt service routine).
variáveis volatile int ou long

Se a variável volatile é maior que um byte (ex. um int de 16 bits ou long de
32 bits), o microcontrolador não é capaz de lê-la em apenas um passo,
porquê é um microcontrolador 8 bits. Isso significa que enquanto a seção
principal do seu código (ex. seu loop) lê o primeiro ou os primeiros bytes da
variável, a interrupção pode mudar os outros bytes. Isso irá produzir valores
inesperados na variável.
Solução:
Enquanto a variável é lida, as interrupções são desativadas, de forma que
estas não podem bagunçar as variáveis durante a leitura. Há algumas
formas de se fazer isso:
1. noInterrupts
2. usar a macro ATOMIC_BLOCK. Operações atômicas são operações únicas
para o microcontrolador - a menor unidade possível.

volatile (continuação)
Código de Exemplo
// muda o estado do LED quando o estado do botão é mudado
int pin = 13;
vo l a t i l e i n t s t a t e = L O W ;
pi n M o d e ( p i n , O U T P U T ) ;
attachInterrupt(digitalPinToInterrupt(2), blink, CHANGE);
}
digitalWrite(pin, state);
}
v oi d b li n k ( ) {
state = !state;
}
#include <util/atomic.h> // essa biblioteca inclui a macro ATOMIC_BLOCK.
A T OM I C _ B L O C K ( A T O M I C _ R E S T O R E S T A T E ) {
// código com interrupções bloqueadas (operações atômicas consecutivas não irão ser
interrompidas)
}

FUNÇÕES
UMA PESSOA QUE NUNCA COMETEU UM ERRO, NUNCA TENTOU NADA DE NOVO
ALBERT EINSTEIN
ENTRADAS E SAÍDAS DIGITAIS 173 constrain()
175 map()
148 digitalRead()
177 max()
150 digitalWrite()
178 min()
152 pinMode()
179 pow()
180 sq()
ENTRADAS E SAÍDAS ANALÓGICAS
181 sqrt()
154 analogRead()
157 analogReference()
FUNÇÕES TRIGONOMÉTRICAS
159 analogWrite()
182 cos()
183 sin()
FUNÇÕES TEMPORIZADORAS
184 tan()
161 delay()
163 delayMicroseconds()
CARACTERES
165 micros()
185 isAlpha()
167 millis()
186 isAlphaNumeric()
NÚMEROS ALEATÓRIOS 187 isAscii()
188 isControl()
169 random()
189 isDigit()
171 randomSeed()
190 isGraph()
FUNÇÕES MATEMÁTICAS 191 isHexadecimalDigit()
172 abs()
CONTINUA NA PRÓXIMA PÁGINA ...

CONTINUAÇÃO ...
192 isLowerCase() APENAS ZERO, DUE E FAMÍLIA

MKR
193 isPrintable()
194 isPunct() 212 analogReadResolution()
195 isSpace() 214 analogWriteResolution()
196 isUpperCase()
ENTRADAS E SAÍDAS
197 isWhitespace()
AVANÇADAS
217 noTone()
BITS E BYTES
218 pulseIn()
198 bit() 220 pulseInLong()
199 bitClear() 222 shiftIn()
200 bitRead()
223 shiftOut()
201 bitSet()
226 tone()
202 bitWrite()
203 highByte() COMUNICAÇÃO
204 lowByte()
227 Serial
256 Stream
INTERRUPÇÕES EXTERNAS
205 attachInterrupt() USB
209 detachInterrupt()
270 Keyboard
285 Mouse
INTERRUPÇÕES
210 interrupts()
211 noInterrupts()
ENTRADAS E SAÍDAS DIGITAIS Página 148
digitalRead()
Lê o valor de um pino digital especificado, que pode ser HIGH ou LOW.
Sintaxe
digitalRead(pino)
Parâmetros
pino : o número do pino digital do Arduino que você quiser verificar
Retorna
HIGH ou LOW
Código de Exemplo
Aciona o pino 13 para o mesmo valor que o pino 7, declarado como entrada.
int ledPin = 13; // LED conectado ao pino digital 13
int inPin = 7; / / b o t ã o c o n e c t a d o a o p i n o d i gi t a l 7
int val = 0; // variável para guardar o valor lido
v oi d s e t u p ( ) {
pinMode(ledPin, OUTPUT); // configura o pino digital 13 como saída
pinMode(inPin, INPUT); // configura o pino digital 7 como entrada
}
void loop() {
val = digitalRead(inPin); // lê o pino de entrada
digitalWrite(ledPin, val); // aciona o LED com o valor lido do botão
}

digitalRead() (continuação)
Se o pino não está conectado a nada, digitalRead() pode retornar tanto
HIGH como LOW (e isso pode mudar aleatoriamente).
Os pinos de entrada analógica podem ser também usados como pinos
digitais, referidos como A0, A1, etc. As exceções são os pinos A6 e A7 das
placas Arduino Nano, Pro Mini, e Mini, que podem ser usadas apenas
como entradas analógicas.

digitalWrite()
Aciona um valor HIGH ou LOW em um pino digital.
Se o pino for configurado como saída (OUTPUT) com a função pinMode(),
sua tensão será acionada para o valor correspondente: 5V (ou 3.3V em
placas alimentadas com 3.3V como o DUE) para o valor HIGH, 0V (ou
ground) para LOW.
Se o pino for configurado como entrada (INPUT), a função digitalWrite() irá
ativar (HIGH) ou desativar (LOW) o resistor interno de pull-up no pino de
entrada. É recomendado configurar pinMode() com INPUT_PULLUP para
ativar o resistor interno de pull-up. Veja o tutorial sobre pinos digitais para
mais informações.
Se você não configurar o pino com pinMode() e OUTPUT, e conectar um LED
ao pino, quando chamar digitalWrite(HIGH), o LED pode aparecer um pouco
apagado. Sem configurar explicitamente pinMode(), digitalWrite() irá
apenas ativar o resistor de pull-up interno, que age como um grande
resistor limitador de corrente.
Sintaxe
digitalWrite(pino, valor)
Parâmetros
pino : o número do pino do Arduino
valor : HIGH ou LOW
Retorna
Nada

digitalWrite() (continuação)
Código de Exemplo
The código configura o pino digital 13 como OUTPUT e troca seu estado
entre HIGH e LOW
pinMode(13, OUTPUT); // configura o pino digital 13 como saída
}
v oi d l o o p ( ) {
digitalWrite(13, HIGH); // ativa o pino digital 13
delay(1000); // espera por um segundo
digitalWrite(13, LOW); // desativa o pino digital 13
}
digitais, referidos como A0, A1, etc. As exceções são os pinos A6 e A7 das
placas Arduino Nano, Pro Mini, e Mini, que podem ser usadas apenas
como entradas analógicas.

pinMode()
Configura o pino especificado para funcionar como uma entrada ou saída.
Veja a descrição dos pinos digitais (em Inglês) para mais detalhes sobre a
funcionalidade dos pinos.
Desde a versão 1.0.1, é possível ativar os resistores internos de pull-up como
o modo INPUT_PULLUP. Adicionalmente, o modo INPUT explicitamente
desativa os resistores pull-up internos.
Sintaxe
pinMode(pino, modo)
Parâmetros
pino : the número do pino do Arduino no qual se quer configurar o modo
modo : o modo do pino. Este pode ser INPUT, OUTPUT ou INPUT_PULLUP;
que correspondem respectivamente a entrada, saída e entrada com pull-up
ativado.
Retorna
Nada
Código de Exemplo
The código configura o pino digital 13 como OUTPUT e troca seu estado
entre HIGH e LOW

pinMode() (continuação)
pinMode(13, OUTPUT); // configura o pino digital 13 como saída
}
v oi d l o o p ( ) {
digitalWrite(13, HIGH); // ativa o pino digital 13
digitalWrite(13, LOW); // desativa o pino digital 13
}
digitais, referidos como A0, A1, etc.

ENTRADAS E SAÍDAS ANALÓGICAS Página 154
analogRead()
Lê o valor de um pino analógico especificado. A placa Arduino possui um
conversor analógico-digital 10 bts de 6 canais (8 canais nos Mini e Nano, 16
no Mega, 7 canais em placas MKR). Isso significa que este irá mapear
tensões entre 0 e a tensão operacional (5V or 3.3V) para valores inteiros
entre 0 e 1023. No Arduino UNO, por exemplo, isso permite uma resolução
entre leituras de: 5 volts / 1024 unidades, ou .0049 volts (4.9 mV) por
unidade. Veja a tabela abaixo para os pinos utilizáveis, tensão de operação
e resolução máxima para algumas placas Arduino.
O intervalo de entrada pode ser mudado atrvés da função
analogReference(), enquanto a resolução pode ser mudada (apenas nas
placas Zero, Due e MKR) usando-se analogReadResolution().
Em placas baseadas em microcontroladores AVR (UNO, Nano, Mini, Mega),
ler um valor analógico leva em torno de 100 microssegundos (0.0001 s),
então a taxa de leitura máxima é aproximadamente 10,000 leituras por
segundo.
*TABELA*
*A0 through A5 are labelled on the board, A6 through A11 are respectively
available on pins 4, 6, 8, 9, 10, and 12**The default analogRead() resolution
for these boards is 10 bits, for compatibility. You need to use
analogReadResolution() to change it to 12 bits.

analogRead() (continuação)
Sintaxe
analogRead(pino)
Parâmetros
pino : o nome do pino de entrada analógica que se quer ler (A0 a A5 na
maioria das placas, A0 a A6 em placas MKR, A0 a A7 no Mini e Nano, A0 a
A15 no Mega).
Retorna
A leitura analógica no pino (int). No entanto esta é limitada a resolução do
conversor analógico digital (0-1023 para 10 bits ou 0-4095 para 12 bits).
Código de Exemplo
O código abaixo lê o valor de um pino de entrada analógica e mostra seu
valor na porta serial.
int analogPin = A3; // terminal do meio de um potênciometro conectado ao pino analógico
3
// terminais mais externos são conectados um no ground e o outro em
+5V
int val = 0; // variável para guardar o valor lido
void setup() {
Serial.begin(9600); // configura a porta serial
}
void loop() {
val = analogRead(analogPin); // lê o pino de entrada
Serial.println(val); // imprime o valor na porta serial
}

analogRead() (continuação)
Se o pino de entrada analógica não estiver conectado a nada, o valor
retornado por analogRead() irá flutuar baseado numa gama de fatores (ex.
o valor de outros pinos analógicos, quão próxima suu mão está da placa,
etc.).

analogReference()
Configura a tensão de referência para a entrada analógica (o valor máximo
do intervalo de entrada). As opções são:
Placas Arduino AVR (Uno, Mega, etc.)

- DEFAULT: a referência analógica padrão de 5 volts (em placas Arduino de
5V) ou 3.3 volts (em placas Arduino de 3.3V)
- INTERNAL: uma referência interna, igual a 1.1 volts no ATmega168 ou
ATmega328P e 2.56 volts no ATmega8 (Não disponível no Arduino Mega)
- INTERNAL1V1: uma referência interna de 1.1V (apenas Arduino Mega)
- INTERNAL2V56: uma referência interna de 2.56V (apenas Arduino Mega)
- EXTERNAL: a tensão aplicada ao pino AREF (0 a 5V apenas) é usada como
referência.
Placas Arduino megaAVR (Uno WiFi Rev2)
- DEFAULT: uma referência interna de 0.55V
- INTERNAL: uma referência interna de 0.55V
- VDD: Vdd do ATmega4809. 5V no Uno WiFi Rev2
- INTERNAL0V55: uma referência interna de 0.55V
- EXTERNAL: a tensão aplicada ao pino AREF (0 a 5V apenas) é usada como
referência.
Placas Arduino SAMD (Zero, etc.)
- AR_DEFAULT: a referência analógica padrão de 3.3V
- AR_INTERNAL: uma referência integrada de 2.23V
- AR_INTERNAL1V0: uma referência integrada de 1.0V
- AR_EXTERNAL: a tensão aplicada ao pino AREF é usada como referência
Placas Arduino SAM (Due)
AR_DEFAULT: a referência analógica padrão de 3.3V. Essa é a única opção
suportada pelo DUE.

analogReference() (continuação)
Sintaxe
analogReference(tipo)
Parâmetros
tipo : qual tipo de referência usar (DEFAULT, INTERNAL, INTERNAL1V1,
INTERNAL2V56 ou EXTERNAL).
Retorna
Nada
Após mudar-se a referência analógica, as primeiras leituras com
analogRead() podem ser imprecisas.
Não use menos que 0V ou mais que 5V como tensão de referência externa
no pino AREF! Se você está usando uma referência externa no pino AREF,
deve configurar a referência como EXTERNAL antes de chamar
analogRead(). Do contrário, você irá curto-circuitar a tensão de referência
ativa (gerada internamente) e o pino AREF, possivelmente danificando o
microcontrolador da sua placa Arduino.
Alternativamente, você pode conectar a tensão de referência externa ao
pino AREF através de um resistor de 5K ohm, permitindo-lhe trocar entre
tensões de referência externas e internas. Note que o resistor irá alterar a
tensão usada como referência, pois há um resistor interno de 32K ohm no
pino AREF. Os dois em conjunto agem como um divisor de tensão, então,
por exemplo, 2.5V aplicados através do resistor irão fornecer 2.5 * 32 / (32 +
5) = ~2.2V ao pino AREF.

analogWrite()
Aciona uma onda PWM (descrição (Em Ingês)) em um pino. Pode ser usada
para variar o brilho de um LED ou acionar um motor a diversas velocidades.
Após a função analogWrite() ser chamada, no pino haverá uma onda
quadrada com o duty cycle (ciclo de trabalho) especificado até a próxima
chamada de analogWrite() (ou uma chamada de digitalRead() ou
digitalWrite() no mesmo pino). A frequência do sinal PWM na maioria dos
pinos é aproximadamente 490 Hz. No Uno e placas similares, pinos 5 e 6
usam uma frequência de aproximadamente 980 Hz.
Na maioria das placas Arduino (as placas com o ATmega168 ou ATmega328),
essa função funciona nos pinos 3, 5, 6, 9, 10, e 11. No Arduino Mega, essa
funciona nos pinos 2 a 13 e 44 a 46. Placas mais antigas com o ATmega8
suportam analogWrite() apenas nos pinos 9, 10, e 11.
O Arduino DUE suporta analogWrite() nos pinos 2 a 13, mais pinos DAC0 e
DAC1. Diferente dos pinos PWM, DAC0 e DAC1 são conversores Digital-
Analógicos, e saídas analógicas legítimas.
Você não precisa chamar pinMode() para configurar um pino como saída
antes de chamar analogWrite().
A função analogWrite() nada tem a ver com os pinos analógicos ou a função
analogRead().
Sintaxe
analogWrite(pino, valor)
Parâmetros
pino : o pino escolhido do Arduino. Tipos de dados permitidos: int.
valor : o duty cycle: entre 0 (sempre desligado) and 255 (sempre ligado).
Tipos de dados permitidos: int

analogWrite() (continuação)
Código de Exemplo
Controla a saída para um LED proporcionalmente a um valor lido de um
potenciômetro.
int analogPin = 3; // potenciômetro conectado ao pino analógico 3
int val = 0; // variável para guradar o valor lido
void setup() {
pinMode(ledPin, OUTPUT); // configura o pino como saída
}
void loop() {
val = analogRead(analogPin); // lê o pino de entrada analógica
analogWrite(ledPin, val / 4); // analogRead retorna valores de 0 a 1023, analogWrite
recebe de 0 a 255
}

FUNÇÕES TEMPORIZADORAS Página 161
delay()
Pausa o programa por uma quantidade especificada de tempo (em
milissegundos). Cada segundo equivale a 1000 milissegundos.
Sintaxe
ae
d nl
aaly
o(gm
Wsr)
ite(pino, valor)
Parâmetros
ms : o número de milissegundos para pausar o programa (unsigned long)
Retorna
Nada
Código de Exemplo
O código pausa o programa por um segundo antes de trocar o estado do
pino 13.
void setup() {
pinMode(ledPin, OUTPUT); // configura o pino digital como saída
}
void loop() {
d i g i ta l W r i t e ( l e d P i n , H I G H ) ; / / a c e n d e o L E D
digitalWrite(ledPin, LOW); // apaga o LED
}

delay() (continuação)

delayMicroseconds()
Pausa o programa pela quantidade de tempo especificada como parâmetro
(em microssegundos). Há mil microssegundos em um milissegundo, e um
milhão de microssegundos em um segundo.
Atualmente, o maior valor que irá porduzir um delay preciso é 16383. Isso
pode mudar em versões futuras do Arduino. Para delays mais longos que
alguns milhares de microssegundos, você deve usar delay() em vez disso.
Sintaxe
ae
d nl
aaly
oMgi
Wcrr
iots
ee(c
poind
os,(u
vsa)
lor)
Parâmetros
us : o número emm microssegundos para pausar o programa (unsigned int)
Retorna
Nada
Código de Exemplo
O código abaixo configura o pino 8 para funcionar como pino de saída. Ele
então gera um trem de pulsos com período de 100 microssegundos.
int outPin = 8; // pino digital 8
void setup() {
pinMode(outPin, OUTPUT); // configura o pino digital como saída
}
void loop() {
d i g i ta l W r i t e ( o u t P i n , H I G H ) ; / / a t i v a o p i n o
delayMicroseconds(50); // pausa por 50 microssegundos
digitalWrite(outPin, LOW); // desativa o pino
delayMicroseconds(50); // pausa por 50 microssegundos
}

delayMicroseconds() (continuação)
Essa função funciona bastante precisamente para valores maiores que 3
microssegundos. Não é possível assegurar que delayMicroseconds() irá
funcionar corretamente para valores menores.
A partir da versão Arduino 0018, delayMicroseconds() não mais desativa
interrupções.

micros()
Retorna o número de microssegundos passados desde que a placa Arduino
começou a executar o programa atual. Esse número irá sofrer overflow
(chegar ao maior número possível e então voltar pra zero), após
aproximadamente 70 minutos. Em placas Arduino 16 MHz (ex. UNO e Nano),
essa função possui uma resolução de quatro microssegundos (isto é, o
número retornado é sempre um múltiplo de quatro). Em placas Arduino 8
MHz (ex. LilyPad), essa função possui uma resolução de oito
microssegundos.
Sintaxe
ai
t nm
aelo=
gWm
ric
treo
(sp(
i)no, valor)
Parâmetros
Nenhum
Retorna
O número de microssegundos desde que o programa iniciou (unsigned
long).
Código de Exemplo
O código abaixo imprime o número de microssegundos passados desde que
a placa Arduino foi ligada.
u n si g n e d l o n g t i m e ;
void setup() {
S e ri a l . b e g i n ( 9 6 0 0 ) ;
}
void loop() {
S e r ia l . p r i n t ( " T i m e : " ) ;

micros() (continuação)
ti m e = m i c r o s ( ) ;
S e ri a l . p r i n t l n ( t i m e ) ; / / i m p r i m e o t e m p o d e s d e q u e o p r o g r a m a i n i c i o u
delay(1000); / / e s p e ra u m s e g u n d o , p a r a n ã o e n v i a r q u a n t i d a d e s m a s s i v a s d e
dados
}
Há 1000 (mil) microssegundos em um milissegundo e 1000000 (um
milhão) de microssegundos em um segundo.

millis()
Retorna o número de milissegundos passados desde que a placa Arduino
começou a executar o programa atual. Esse número irá sofrer overflow
(chegar ao maior número possível e então voltar pra zero), após
aproximadamente 50 dias.
Sintaxe
ai
t nm
aelo=
gWm
ril
tlei
(sp(
i)no, valor)
Parâmetros
Nenhum
Retorna
O número de milissegundos passados desde que o programa iniciou
(unsigned long)
Código de Exemplo
O código imprime na porta serial o tempo em milissegundos passado desde
que a placa Arduino começou a executar o código em si.
u n si g n e d l o n g t i m e ;
void setup() {
S e ri a l . b e g i n ( 9 6 0 0 ) ;
}
void loop() {
S e r ia l . p r i n t ( " T i m e : " ) ;
time = millis();
Serial.println(time); // imprime o tempo desde que o programa iniciou
delay(1000); // espera um segundo, para não enviar quantidades massivas de
dados
}

millis() (continuação)
Note que o valor retornado por millis() é unsigned long, erros podem ser
gerados se o programador tentar fazer operações matemáticas com outros
tipos de dados, como int. Até mesmo o tipo long com sinal pode causar
erros, já que seu valor máximo é metade de sua contraparte sem sinal.

NÚMEROS ALEATÓRIOS Página 169
random()
A função random() gera números pseudoaleatórios.
Sintaxe
aa
r nn
adlom
g(Wm
raix
t)e(r
paind
oo,m(
vmai
lno,
r)max)
Parâmetros
min - menor limite do valor aleatório, inclusivo e opcional (long)
max - maior limite do valor aleatório, exclusivo (long)
Retorna
Um número inteiro aleatório entre min e max-1 (long) .
Código de Exemplo
O código abaixo gera números aleatórios e os imprime na porta serial.
long randNumber;
void setup() {
S e ri a l . b e g i n ( 9 6 0 0 ) ;
// Se o pino de entrada analógica 0 é deixado desconectado,
/ / o r u í d o a l e a t ó r i o a na l ó g i c o i r á c a u s a r a c h a m a d a d e r a n d o m S e e d ( )
// gerar sementes aleatórias diferentes cada vez que o sketch roda.
// randomSeed() basicamente "embaralha" a função random().
randomSeed(analogRead(0));
}
void loop() {
// imprime um número aleatório entre 0 e 299
randNumber = random(300);
Serial.println(randNumber);
// imprime um valor aleatório entre 10 e 19
randNumber = random(10, 20);
delay(50);
}

random() (continuação)
Se é importante que uma sequência de valores gerados por random() seja
diferente em execuções subsequentes de um sketch, use randomSeed()
para inicializar o gerador de números aleatórios com uma entrada
significantemente aleatória, como analogRead() em um pino
desconectado.
Por outro lado, pode ser ocasionalmente útil usar sequências
pseudoaleatórias exatamente repetidas. Isso pode ser conseguido
chamando-se randomSeed() com um número fixo, antes de começar a
usar a sequência aleatória.
O parâmetro max deve ser escolhido de acordo com o tipo de dado da
variável na qual o valor será guardado. De qulquer forma, o valor máximo
absoluto é limitado pela natureza long (32 bit - 2,147,483,647) do valor
gerado. Escolher um valor max maior que isso não irá gerar erros durante
a compilação, mas durante a execução do sketch, os números gerados irão
se comportar de forma impredizível.

randomSeed()
randomSeed() inicializa o gerador de números pseudoaleatórios, fazendo
começar em um ponto arbitrário em sua sequência aleatória. Essa
sequência, enquanto muito longa, e aleatória, é sempre a mesma.
Se é importante que uma sequência de valores gerados por random() seja
diferente em execuções subsequentes de um sketch, use randomSeed()
para inicializar o gerador de números aleatórios com uma entrada
significantemente aleatória, como analogRead() em um pino desconectado.
Por outro lado, pode ser ocasionalmente útil usar sequências
pseudoaleatórias exatamente repetidas. Isso pode ser conseguido
chamando-se randomSeed() com um número fixo, antes de começar a usar
a sequência aleatória.
Parâmetros
seed - número para inicializar a sequência pseudoaleatória (long).
Retorna
Nada
Código de Exemplo
O código abaixo imprime números aleatórios na porta serial.
long randNumber;
void setup() {
// inicializa a porta serial.
S e ri a l . b e g i n ( 9 6 0 0 ) ;
// inicializa o gerador de números aleatórios.
/ / u m p i n o a na l ó g i c o d e s c o n e c t a d o i r á r e t o r n a r u m
// valor aleatório de tensão em analogRead()
randomSeed(analogRead(0));
}
void loop() {
// calcula o próximo número aleatório entre 0 e 299
randNumber = random(300);
// imprime o valor na porta serial
delay(50);
}

FUNÇÕES MATEMÁTICAS Página 172
abs()
Calcula o módulo (ou valor absoluto) de um número.
Sintaxe
ab
nsa(
lxo)
gWrite(pino, valor)
Parâmetros
x : o número do qual se deseja saber o módulo
Retorna
x : se x é maior ou igual a 0.
-x : se x é menor que 0.
Por causa da forma em que a função abs() é implementada, evite usar
outras funções dentro dos parênteses, isso pode levar a resultados
incorretos.
a b s ( a + + ) ; / / e v i t a r i s s o - c a u s a r e s u l t a d o s i nc o r r e t o s
abs(a); // Ao invés disso, usar esta forma

a++; // manter a aritmética fora da função

constrain()
Restringe um número a ficar dentro de um intervalo.
Sintaxe
ao
c nn
aslt
orga
Wirn
i(tx
e,(pa
i,nob
,)valor)
Parâmetros
x : o número a se restringir, qualquer tipo de dado
a : o extremo inferior do intervalo, qualquer tipo de dado
b : o extremo superior do intervalo, qualquer tipo de dado
Retorna
x : se x está entre a e b
a : se x é menor que a
b : se x é maior que b
Código de Exemplo
O código limita os valores de uma variável com a leitura de um sensor entre
10 e 150.
se ns V a l = c o n s t r a i n ( se n s V a l , 1 0 , 1 5 0 ) ; // limita os valores entre 10 e 150

constrain() (continuação)
Por causa da forma como a função constrain() é implementada, evite usar
outras funções dentro dos parênteses, pois isso pode levar a resultados
incorretos.
Esse código gerará resultados incorretos:
i n t c o n s t r a i ne d I n p u t = c o n s t r a i n ( S e r i a l . p a r se I n t ( ) , m i n i m u m V a l u e , m a x i m u m V a l u e ) ; //
evite isso
Faça essa forma:

int input = Serial.parseInt(); // manter outras operações fora da função constrain()
i n t c o n s t r a i ne d I n p u t = c o n s t r a i n ( i n p ut , m i n i m u m V a l u e , m a x i m u m V a l u e ) ;

map()
Remapeia um número de um intervalo para outro. Isto é, um valor de
deMenor seria mapeado para paraMenor, um valor de deMaior para
paraMaior, valores dentro de uma faixa para volores dentro da outra faixa,
etc.
Não restringe valores a ficar dentro do intervalo, porque valores fora do
intervalo são as vezes úteis e pretendidos. A função constrain() pode ser
usada tanto antes como depois dessa função, se limites para os intervalos
são desejados.
Note que os "limites mínimos" de cada intervalo podem ser maiores ou
menores que os "limites máximos" tal que a função map() pode ser usada
para reverter um intervalo de números, por exemplo
y = map(x, 1, 50, 50, 1);
A função também funciona bem com números negativos, tal que esse
exemplo
y = map(x, 1, 50, 50, -100);
também é valido e funciona bem.
A função map() usa números inteiros e não irá gerar números fracionários,
quando a matemática indicar que deveria. Resíduos fracionários são
truncados e não são arredondados.
Sintaxe
am
= nap
l(ov
gaWl
roir
t,e(d
peiM
neon
,or
v,ald
oerM
)aior, paraMenor, paraMaior);
Parâmetros
valor : o número a ser mapeado
deMenor : o menor limite do intervalo atual do valor
deMaior : o maior limite do intervalo atual do valor
paraMenor : o menor limite do intervalo alvo
paraMaior : o maior limite do intervalo alvo

map() (continuação)
Retorna
O valor mapeado para o novo intervalo.
Código de Exemplo
/ * M a p e i a u m v a l o r a n a l ó g ic o p a r a 8 b i t s ( 0 a 2 5 5 ) * /
void setup() {}
void loop() {
int val = analogRead(0);
va l = m a p ( v a l , 0 , 1 0 2 3 , 0 , 2 5 5 ) ;
analogWrite(9, val);
}
Apêndice
Para os matematicamnete interessados, aqui tem-se o código da função:
l o n g m a p ( l o n g x , l o n g i n _ m in , l o n g i n _ m a x , lo n g o u t _ m i n , l o n g o u t _ m a x ) {
re t u r n ( x - i n _ m i n ) * ( o u t _ m a x - o u t _ m i n ) / ( i n _ m a x - i n _ m i n ) + o u t _ m i n ;
}
Como mencionado anteriormente, a função map() usa matemática inteira.
Então frações podem ser suprimidas devido a isso. Por exemplo, frações
como 3/2, 4/3, 5/4 irão ser retornadas como 1 pela função map(), apesar de
os valores esperados serem diferentes. Então, se seu projeto requer
cálculos precisos (ex. tensão elétrica com precisão de três decimais), por
gentileza considere evitar a função map() e implementar os cálculos
manualmente no seu código.

max()
Calcula o maior de dois números.
Sintaxe
aa
m nx
a(lx
o,gWy
r)ite(pino, valor)
Parâmetros
x : o primeiro número, qualquer tipo de dado
y : o segundo número, qualquer tipo de dado
Retorna
O maior dos dois números passados para a função.
Código de Exemplo
O código garante que o valor de sensVal seja pelo menos 20.
se ns V a l = ma x ( se n s V a l , 2 0 ) ; / / a t r i b u i a s e n s V a l o m a i o r v a l o r , s e j a s e n s V a l o u 2 0
// (efetivamente garantindo que sensVal seja ao menos 20)
Talvez contraintuitivamente, max() é constantemente usada para
restringir o extremo inferior do intervalo de uma variável, enquanto min()
é usado para restringir o extremo superior do intervalo.
Por causa da forma em que a função max() é implementada, evite usar
incorretos.
max(a--, 0); / / e v i t a r i s s o - c a u s a re s u l t a do s i n c o r r e t o s
max(a, 0); // ao invés disso, usar esta forma
a--; // manter a aritmética fora da função

min()
Calcula o menor de dois números.
Sintaxe
ai
m nn
a(lx
o,gWy
r)ite(pino, valor)
Parâmetros
x : o primeiro número, qualquer tipo de dado
y : o segundo número, qualquer tipo de dado
Retorna
O menor dos dois números passados para a função.
Código de Exemplo
O código garante que o valor de sensVal nunca é maior que 100.
se ns V a l = m i n( se n s V a l , 1 0 0 ) ; // atribui a sensVal o menor valor, seja sensVal ou 100
// garantindo que esse nunca seja maior que 100.
Talvez contraintuitivamente, max() é constantemente usada para
restringir o extremo inferior do intervalo de uma variável, enquanto min()
é usado para restringir o extremo superior do intervalo.
Por causa da forma em que a função max() é implementada, evite usar
incorretos.
min(a++, 100); / / e v i t a r i s s o - c a u s a re s u l t a do s i n c o r r e t o s
min(a, 100); // ao invés disso, usar esta forma
a++; // manter a aritmética fora da função

pow()
Calcula o valor de um número elevado a uma potência. pow() pode ser
usada para transformar um número em uma potência fracionária. Isso pode
ser útil para gerar mapeamentos exponenciais de valores ou curvas.
Sintaxe
ao
p nw
a(lb
oags
Wer,
itex
(po
ienn
ot,e)
valor)
Parâmetros
base : o número (float)
expoente : a potência a qual o número deve ser elevado (float)
Retorna
O resultado da exponenciação (double)
Código de Exemplo
Z recebe o valor de x elevado a y:
z = p o w( x, y ) ;
Veja o sketch (fscale) para um exemplo mais complexo do uso de pow().

sq()
Calcula o quadrado de um número: o número multiplicado por si mesmo.
Sintaxe
aq
s n(
axl)
ogWrite(pino, valor)
Parâmetros
x : o número que se deseja calcular o quadrado, qualquer tipo de dados
Retorna
O quadrado do número. (double)
Por causa da forma como a função sq() é implementada, evite usar outras
funções dentro dos parênteses, pois isso pode levar a resultados
incorretos.
Esse código gerará resultados incorretos:
i n t i n p u t S q u a re d = s q ( S e r i a l . p a r se I n t ( ) ) ; / / e v i t e i s s o
Faça dessa forma:

int input = Serial.parseInt(); // manter outras operações fora da função sq()
i n t i np u t S q u a r e d = s q ( i n p ut ) ;

sqrt()
Calcula a raiz quadrada de um número.
Sintaxe
aq
s nr
atl(
oxg)
Write(pino, valor)
Parâmetros
x : o número a se calcular a raiz quadrada, qualquer tipo de dados
Retorna
A raiz quadrada do número. (double)

FUNÇÕES TRIGONOMÉTRICAS Página 182
cos()
Calcula o cosseno de um ângulo (em radianos). O resultado é dado entre -1
e 1.
Sintaxe
ao
c ns
a(lr
oagd
W)rite(pino, valor)
Parâmetros
rad : O ângulo em radianos (float).
Retorna
O cosseno do ângulo (double).

sin()
Calcula o seno de um ângulo (em radianos). O resultado é dado entre -1 e 1.
Sintaxe
ai
s nn
a(lr
oagd
W)rite(pino, valor)
Parâmetros
Retorna
O seno do ângulo (double).

tan()
Calcula a tangente de um ângulo (em radianos). O resultado é dado entre -
infinito e +infinito (limitado pela tamanho do tipo de dado double).
Sintaxe
aa
t nn
a(lr
oagd
W)rite(pino, valor)
Parâmetros
Retorna
A tangente do ângulo (double).

CARACTERES Página 185
isAlpha()
Analisa se um caractere é alfabético (isto é, se é uma letra). Retorna true
(verdadeiro) se thisChar contém uma letra.
Sintaxe
as
i nA
alp
ohga
W(rt
ihti
es(C
phia
nro)
, valor)
Parâmetros
thisChar : variável. Tipos de dados permitidos: char
Retorna
true : se thisChar é um caractere alfabético.
Código de Exemplo
if (isAlpha(meuChar)) { // testa se a variável meuChar é uma letra
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s a l e t t e r " ) ;
}
else {
Serial.println("The character is not a letter");
}

isAlphaNumeric()
Analisa se um caractere é alfanumérico (isto é, uma letra ou um número).
Retorna true (verdadeiro) se thisChar contém ou uma letra ou um número.
Sintaxe
as
i nA
alp
ohga
WNru
imter
(ipc
i(nt
oh,is
vCah
laor)
Parâmetros
Retorna
true : se a variável thisChar é uma letra ou um número.
Código de Exemplo
if (isAlphaNumeric(meuChar)) { // testa se meuChar é uma letra ou um número
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s a l p h a n u m e r i c " ) ;
}
else {
Serial.println("The character is not alphanumeric");
}

isAscii()
Analisa se um caractere é Ascii. Retorna true se a variável thisChar contém
um caractere Ascii.
Sintaxe
as
i nA
aslc
oigi
W(rt
ihti
es(C
phia
nro)
, valor)
Parâmetros
Retorna
true : se thisChar é um caractere Ascii.
Código de Exemplo
if (isAscii(meuChar)) { // testa se meuChar é um caractere Ascii
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s A s c i i " ) ;
}
else {
Serial.println("The character is not Ascii");
}

isControl()
Analisa se uma caractere é um caractere de controle. Retorna true
(verdadeiro) se thisChar é um caractere de controle.
Sintaxe
as
i nC
aoln
otgr
Worl
i(tt
eh(i
psiC
nhoa
,r)
valor)
Parâmetros
Retorna
true : se thisChar é um caractere de controle.
Código de Exemplo
if (isControl(meuChar)) { // testa se a variável meuChar é um caractere de controle
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s a c o n t r o l c h a r a c t e r " ) ;
}
else {
Serial.println("The character is not a control character");
}

isDigit()
Analisa se uma caractere é um digito (isto é, um número). Retorna true
(verdadeiro) se thisChar é um número.
Sintaxe
as
i nD
ailg
oigt
W(rt
ihti
es(C
phia
nro)
, valor)
Parâmetros
Retorna
true : se thisChar é um número.
Código de Exemplo
if (isDigit(meuChar)) { // testa se meuChar é um digito
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s a n u m b e r " ) ;
}
else {
Serial.println("The character is not a number");
}

isGraph()
Analisa se um caractere é imprimível com algum conteúdo (espaços são
imprimíveis, mas não possuem conteúdo). Retorna true se thisChar é
imprimível.
Sintaxe
as
i nG
arla
opgh
W(rt
ihti
es(C
phia
nro)
, valor)
Parâmetros
Retorna
true : se thisChar é imprimível.
Código de Exemplo
if (isGraph(meuChar)) { // testa se meuChar é um caractere imprimível mas não um
espaço.
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s p r i n t a b l e " ) ;
}
else {
Serial.println("The character is not printable");
}

isHexadecimalDigit()
Analisa se uma caractere é um digito hexadecimal (A-F, 0-9). Retorna true
se thisChar contém um digito hexadecimal.
Sintaxe
as
i nH
aelx
oagd
Werc
iitm
ea(l
pDii
ngoi
,t(
vtah
lios
rC)har)
Parâmetros
Retorna
true : se thisChar é um digito hexadecimal.
Código de Exemplo
if (isHexadecimalDigit(meuChar)) { // testa se meuChar é um digito hexadecimal
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s a n h e x a d e c i m a l d i g i t " ) ;
}
else {
Serial.println("The character is not an hexadecimal digit");
}

isLowerCase()
Analisa se uma caractere é minúsculo (isto é, uma letra minúscula). Retorna
true se thisChar contém uma letra minúscula.
Sintaxe
as
i nL
aolw
oegr
WCra
iste(t
phii
nsoC
,ha
vra)
lor)
Parâmetros
Retorna
true : se thisChar é minúsculo.
Código de Exemplo
if (isLowerCase(meuChar)) { // testa se meuChar é uma letra minúscula
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s l o w e r c a s e " ) ;
}
else {
Serial.println("The character is not lower case");
}

isPrintable()
Analisa se uma caractere é imprimível (isto é, qualquer caractere que
produz uma saída, até mesmo um espaço). Retorna true se thisChar é
imprimível. Por impimível diz-se os caracteres que pode ser impressos,
como letras e números. Alguns caracteres são para controle e não podem
ser impressos como o new line ('\n') e o tab ('\t').
Sintaxe
ah
t ni
aslC
ohga
Wr:
itv
ea(r
piá
nvoe
,l.
vaT
liop
ro)s de dados permitidos: char
Parâmetros
Retorna
true : se thisChar é imprimível.
Código de Exemplo
if (isPrintable(meuChar)) { // testa se meuChar é imprimível
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s p r i n t a b l e " ) ;
}
else {
Serial.println("The character is not printable");
}

isPunct()
Analisa se uma caractere é pontuação (isto é, uma vírgula, um ponto-e-
vírgula, um ponto de exlamação etc). Retorna true se thisChar é um
caractere de pontuação.
Sintaxe
as
i nP
auln
ocgt
W(rt
ihti
es(C
phia
nro)
, valor)
Parâmetros
Retorna
true : se thisChar é um caractere de pontuação
Código de Exemplo
if (isPunct(meuChar)) { // testa se meuChar é um caractere de pontuação
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s a p u n c t u a t i o n " ) ;
}
else {
Serial.println("The character is not a punctuation");
}

isSpace()
Analisa se uma caractere é o caractere de espaço. Retorna true se thisChar
contém um espaço.
Sintaxe
as
i nS
apla
ocge
W(rt
ihti
es(C
phia
nro)
, valor)
Parâmetros
Retorna
true : se thisChar é o caractere de espaço.
Código de Exemplo
if (isSpace(meuChar)) { // testa se meuChar é o caractere de espaço
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s a s p a c e " ) ;
}
else {
Serial.println("The character is not a space");
}

isUpperCase()
Analisa se uma caractere é maiúsculo (isto é, uma letra maisúcula). Retorna
true se thisChar é uma letra maiúscula.
Sintaxe
as
i nU
aplp
oegr
WCra
iste(t
phii
nsoC
,ha
vra)
lor)
Parâmetros
Retorna
true : se thisChar é uma letra maiúscula.
Código de Exemplo
if (isUpperCase(meuChar)) { // testa se meuChar é uma letra maiúscula
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s u p p e r c a s e " ) ;
}
else {
Serial.println("The character is not upper case");
}

isWhitespace()
Analisa se um caractere é um espaço em branco, isto é o próprio caractere
de espaço (' '), formfeed ('\f'), nova linha ('\n'), retorno ('\r'), tab horizontal
tab ('\t') e tab vertical ('\v')). Retorna true se thisChar contém um espaço
em branco.
Sintaxe
as
i nW
ahli
otge
Wsrp
iatc
ee((
ptih
nios
,Ch
var
l)or)
Parâmetros
Retorna
true : se thisChar é um caractere de espaço em branco.
Código de Exemplo
if (isWhitespace(meuChar)) { // testa se meuChar é um caractere de espaço em branco
S e r i a l . p r i n t l n( " T h e c h a r a c t e r i s a w h i t e s p a c e " ) ;
}
else {
Serial.println("The character is not a white space");
}

BITS E BYTES Página 198
bit()
Computa o valor do bit especificado (o bit 0 é igual a 1, bit 1 igual a 2, bit 2
igual a 4, etc.).
Sintaxe
ai
b nt
a(ln
o)gWrite(pino, valor)
Parâmetros
n : o bit o qual se deseja computar o valor
Retorna
O valor do bit.

bitClear()
Limpa (escreve um 0) em um bit de uma variável numérica.
Sintaxe
ai
b nt
aCll
oega
Wr(
ixt,
e(n
p)ino, valor)
Parâmetros
x : a variável numérica da qual se deseja limpar um bit
n : qual bit limpar, começando em 0 para o bit menos significativo (o bit
mais à direta)
Retorna
Nada.

bitRead()
Lê o valor de um bit em um número.
Sintaxe
ai
b nt
aRle
oagd
W(rx
i,ten
()pino, valor)
Parâmetros
x : o número do qual se quer ler o bit
n : qual bit ler, começando em 0 para o bit menos significativo (mais à
direita)
Retorna
O valor do bit (0 ou 1).

bitSet()
Ativa (escreve 1 em) um bit de uma variável numérica.
Sintaxe
ai
b nt
aSle
otg(
Wxr,
itn
e)(pino, valor)
Parâmetros
x : a variável numérica cujo bit se quer ativar
n : qual bit ativar, começando em 0 para o bit menos significativo (mais à
direita)
Retorna
Nada

bitWrite()
Escreve em um bit especificado de um valor numérico.
Sintaxe
ai
b nt
aWlr
oigt
Wer(
ixt,
e(n
p,inb
o), valor)
Parâmetros
x : a variável numérica cujo bit se deseja escrever
n : qual bit do número a ser escrito, começando em 0 para o bit menos
significativo (mais à direita)
b : o valor a ser escrito no bit (0 ou 1)
Retorna
Nada
Código de Exemplo
O código a seguir demonstra o use de bitWrite ao imprimir uma variável no
Monitor Serial antes e depois do uso de bitWrite().
void setup() {
Serial.begin(9600);
while (!Serial) {} // espera a porta serial conectar. Necessário apenas em placas
com USB nativa
byte x = 0b10000000; // o prefixo 0b indica uma constante binária
S e r i a l . p r i n t l n( x , B I N ) ; / / 1 0 0 0 0 0 0 0
bitWrite(x, 0, 1); / / E s c r e v e 1 n o b i i t m e n o s s i g n i f i c a n te d e x
Serial.println(x, BIN); // 10000001
}
void loop() {}

highByte()
Extrai o byte mais significativo (o mais à esquerda) de uma word (valor de
16 bits), ou o segundo byte menos significativo de um tipo de dado maior.
Sintaxe
ai
h ng
ahlB
oygt
Wer(
ixt)
e(pino, valor)
Parâmetros
Retorna
Byte

lowByte()
Extrai o byte menos significativo (mais à direita) de uma variável (ex. uma
word).
Sintaxe
ao
l nw
aBly
otge
W(rx
i)te(pino, valor)
Parâmetros
Retorna
Byte

INTERRUPÇÕES EXTERNAS Página 205
attachInterrupt()
Pinos Digitais com Interrupções
O primeiro parâmetro de attachInterrupt() é o número da interrupção. É

recomendado usar digitalPinToInterrupt(pino) para converter o número do
pino digital para o número específico da interrupção. Por exemplo, se você
usar o pino 3, passe digitalPinToInterrupt(3) como o primeiro parâmetro de
attachInterrupt().
*Tabela
Para as placas Uno WiFiRev.2, Due, Zero, Família MKR e 101, número da
interrupção = número do pino.
Nota
Dentro da função associada, delay() não funcionará e o valor retornado
por millis() não será incrementado. Dados recebidos na porta serial
enquanto a interrupção é executada podem ser perdidos. Você deve
declarar como volatile quaisquer que você modificar dentro da função
associada. Veja a seção sobre ISRs abaixo para mais informação.
Usando Interrupções
Interrupções são úteis para fazer coisas automaticamente em programas de
microcontroladores, e podem ajudar a resolver problemas de temporização.
Boas tarefas para se udar uma interrupção podem icnluir a leitura de um
codificador rotativo, ou monitorar entradas de dados pelo usuário.

attachInterrupt() (continuação)
Supomos que você quisesse ter certeza que um programa sempre captura
os pulsos de um codifcador rotativo, sem nunca perder um pulso, seria
muito complicado criar um programa que pudesse fazer qualquer outra
coisa além disso, porque o programa precisaria checar constantemente os
pinos do codificador, para capturar os pulsos exatamente quando eles
ocorreram. Outros sensores são similarmente dinâmicos também, como um
sensor de som que pode ser usado para capturar um clique, ou um sensor
infravermelho (foto-interruptor) para capturar a queda de uma moeda. Em
todas essas situações, usar uma interrupção pode permitir o
microcontrolador trabalhar em outras tarefas sem perder a interrupção.
Usando Interrupções
ISRs são tipos especiais de funções que possuem algumas limitações únicas
que as outras funções não possuem. Uma ISR não recebe argumentos, e não
devem retornar nada.
Geralmente, uma ISR deve ser o mais curta e rápida possível. Se o seu
sketch usa múltiplas ISRs, apenas uma pode ser executada de cada vez,
outras interrupções serão executadas após a atual terminar, em uma ordem
que depende de sua prioridade. millis() depende de interrupções para
contar, então essa nunca irá incrementar dentro de uma ISR. Como delay()
também depende de interrupções, não irá funcionar dentro de uma ISR.
micros() funciona inicialmente, mas começará a se comportar
erraticamente após 1-2 ms. delayMicroseconds() não usa nenhum contador,
então funciona normalmente.
Tipicamente variáveis globais são usadas para passar dados entre uma ISR e
o programa principal. Tenha certeza que variáveis compartilhadas entre
uma ISR e o programa principal são atualizadas corretamente, para isso, as
declare usando o modificador volatile.

Sintaxe
attachInterrupt(digitalPinToInterrupt(pino), ISR, modo
(Recomendado)attachInterrupt(interrupção, ISR, modo); (Não
recomendado)attachInterrupt(pino, ISR, modo); (Não recomendado. Além disso, essa
sintaxe só funciona em placas Arduino SAMD, Uno WiFi Rev2, Due, e 101)
Parâmetros
interrupção: o número da interrupção (int)pino: o número do pino do
ArduinoISR: a ISR a ser chamada quando a interrupção ocorre; essa função
deve não tomar nenhum parâmetro nem retornar nada. Essa função é
chamada de rotina de serviço da interrupção ou ISR (do Inglês, interrupt
service routine).modo: define quando a interrupção deve ser ativada.
Quatro constantes estão predefinidas como valores válidos:
- LOW acionar a interrupção quando o estado do pino for LOW,
- CHANGE acionar a interrupção quando o sempre estado do pino mudar
- RISING acionar a interrupção quando o estado do pino for de LOW para
HIGH apenas,
- FALLING acionar a interrupção quando o estado do pino for de HIGH para
LOW apenas.Placas Due, Zero e MKR1000 suportam também:
- HIGH acionar a interrupção quando o estado do pino for HIGH.
Retorna
Nada
Código de Exemplo
O código abaixo usa uma interrupção para capturar a mudança no estado
do pino 2 e acender o LED de acordo.

const byte ledPin = 13;

const byte interruptPin = 2;
volatile byte state = LOW;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(interruptPin, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(interruptPin), blink, CHANGE);
}
void loop() {
digitalWrite(ledPin, state);
}
void blink() {
state = !state;
}
Números das Interrupções

Normalmente você deve usar digitalPinToInterrupt(pino), em vez de colocar
diretamente o número da interrupção no seu sketch. Os pinos específicos
para interrupções, e seu mapeamento para o número da interrupção variam
para cada tipo de placa. O uso direto dos números das interrupções pode
parecer mais simples, porém pode causar problemas de compatibilidade
quando seu sketch for executado em uma placa diferente.
Mesmo assim, sketches mais antigos frequentemente têm os números das
interrupções usados diretamente. Frequentemente o número 0 (para o pino
digital 2) ou o número 1 (para o pino digital 3) foram usados. A tabela
abaixo mostra os pinos com interrupções disponíveis em cada placa.
Note que na tabela abaixo, os números das interrupções se referem aos
números a serem passados para attachInterrupt(). Por razões históricas,
essa numeração nem sempre corresponde diretamente a numeração do
chip ATmega (ex. int.0 corresponde à INT4 no chip ATmega2560).
*Tabela
Para as placas Due, Zero, MKR1000 e 101 o número da interrupção = número

do pino.

detachInterrupt()
Desativa a interrupção especificada.
Sintaxe
detachInterrupt(digitalPinToInterrupt(pino)) (Recomendado)detachInterrupt(interrupt)
(Não recomendado)detachInterrupt(pino) (Não recomendado. Além disso, essa sintaxe só
funciona em placas Arduino SAMD, Uno WiFi Rev2, Due, e 101)
Parâmetros
interrupt : o número da interrupção a ser desativada (veja attachInterrupt()
para mais detalhes).
pino : o número do pino do Arduino cuja interrupção deve ser desativada
Retorna
Nada

INTERRUPÇÕES Página 210
interrupts()
Reativa interrupções (quando elas tiverem sido desativadas por
nointerrupts(). Interrupções permitem certas tarefas importantes
acontecerem ao fundo e são, por padrão, ativadas. Algumas funções não
irão funcionar enquanto as interrupções estiverem desativadas, e dados
recebidos podem ser ignorados. Interrupções podem levemente interferir
no timing do código, no entanto, e podem ser desativadas em seções
particulamente críticas do código.
Sintaxe
interrupts()
Parâmetros
Nothing
Retorna
Nada
Código de Exemplo
O código abaixo mostra como desativar e reativar interrupções.
void setup() {}
void loop() {
noInterrupts();
// código crítico e sensível ao tempo aqui
i n t e r r u p t s( ) ;
// códigos regulares aqui
}

INTERRUPÇÕES Página 211
noInterrupts()
Desativa interrupções (você pode reativá-las com interrupts()). Interrupções
permitem certas tarefas importantes acontecerem ao fundo e são, por
padrão, ativadas. Algumas funções não irão funcionar enquanto as
interrupções estiverem desativadas, e dados recebidos podem ser
ignorados. Interrupções podem levemente interferir no timing do código,
no entanto, e podem ser desativadas em seções particulamente críticas do
código.
Sintaxe
noInterrupts()
Parâmetros
Nothing
Retorna
Nada
Código de Exemplo
O código abaixo mostra como desativar e reativar interrupções.
void setup() {}
void loop() {
noInterrupts();
// código crítico e sensível ao tempo aqui
i n t e r r u p t s( ) ;
// códigos regulares aqui
}

APENAS ZERO, DUE E FAMÍLIA MKR Página 212
analogReadResolution()
analogReadResolution() é um extensão da API Analog para o Arduino Due,
Zero e família MKR.
Configura o tamanho (em bits) do valor retornado por analogRead(). O
padrão é 10 bits (retorna valores entre 0-1023) para compatibilidade com
placas baseadas em microcontroladores AVR.
As placas Due, Zero e da família MKR possuem um conversor analógico
digital (ADC) com capacidade 12-bits que pode ser acessado, em
completude, mudando-se a resolução para 12. Isso fará com que os valores
retornados por analogRead() estejam entre 0 e 4095.
Sintaxe
analogReadResolution(bits)
Parâmetros
bits : determina a resolução (em bits) dos valores retornados pela função
analogRead(). Você pode configurar esse valor entre 1 e 32. Você pode
escolher resoluções mais altas que 12, porém assim, valores retornados por
analogRead() irão sofrer aproximação. Veja a nota abaixo para detalhes.
Retorna
Nada
Código de Exemplo
O código abaixo mostra como usar o conversor analógico digital com
resoluções diferentes.
void setup() {
// abre a conexão serial
Serial.begin(9600);

analogReadResolution() (continuação)
}
void loop() {
// lê o valor no pino A0 na resolução padrão (10 bits)
// e o envia pela conexão serial
analogReadResolution(10);
Serial.print("ADC 10-bit (padrão) : ");
S e r i a l . p r i n t ( a n a lo g R e a d ( A 0 ) ) ;
// muda a resolução para 12 bits e lê o pino A0
Serial.print(", 12-bit : ");
Serial.print(analogRead(A0));
// muda a resolução para 16 bits e lê o pino A0
Serial.print(analogRead(A0));
// muda a resolução para 8 bits e lê o pino
S e ri a l . p r i n t l n ( a n a l o g R e a d ( A 0 ) ) ;
// um pequeno delay para não enviar dados muito rapidamente para o Serial Monitor
delay(100);
}
Se você configurar o valor de analogReadResolution() para um valor maior
que a capacidade de sua placa, o Arduino irá retornar apenas na sua
resolução máxima, preenchendo os bits extras com zeros.
Por exemplo: usando-se o DUE com analogReadResolution(16) irá retornar
um número 16-bit aproximado, com os primerios 12 bits contendo a leitura
real do ADC e os últimos 4 bits preenchidos com zeros.
Se você configurar o valor de analogReadResolution() para um valor menor
que a capacidade de sua placa, os bits menos significantes extras lidos do
ADC serão descartados.
Usar uma resolução de 16 bits (ou qualquer resolução mais alta que as
capacidades reais do hardware) permite escrever sketches que
automaticamente suportam dispositivos com uma resolução do ADC mais
alta quando estes estiverem disponíveis em placas futuras, sem a
necessidade de se fazer mudanças no código.

analogWriteResolution()
analogWriteResolution() é uma extensão da API Analog para os Arduinos
Due, Zero e MKR.
analogWriteResolution() configura a resolução da função analogWrite(). O
padrão é 8 bits (valores entre 0-255) para compatibilidade com placas
baseadas em microcontroladores AVR.
O Due possui as seguintes capacidades em seu hardware:
- 12 pinos com PWM de 8-bit por padrão, como as placas baseadas em AVR.
Estes podem ser mudados para resolução 12-bits.
- 2 pinos com DAC 12-bit (Do Inglês, Digital-to-Analog Converter).
Ao configurar a resolução para 12 bits, você pode usar analogWrite() com
valores entre 0 e 4095 para tirar vantagem da resolução completa do DAC
ou do sinal PWM.
O Zero possui as seguintes capacidades em seu hardware:
- 1 pinos com DAC 12-bit (Do Inglês, Digital-to-Analog Converter).Ao
configurar a resolução para 10 bits, você pode usar analogWrite() com
valores entre 0 e 1023 para tirar vantagem da resolução completa do DAC.
A família MKR de placas possui as seguintes capacidades em seu hardware:
- 1 pino com DAC 10-bit (Do Inglês, Digital-to-Analog Converter).
Ao configurar a resolução para 12 bits, você pode usar analogWrite() com
valores entre 0 e 4095 para sinais PWM; Use 10 bits no pino do conversor
digital-analógico para tira vantagem da resoulção completa de 1024 valores
do DAC.
Sintaxe
analogWriteResolution(bits)

analogWriteResolution() (continuação)
Parâmetros
bits : determina a resolução (em bits) dos valores usados na função
analogWrite(). Se você escolher uma resolução maior ou menor que a
capacidade do hardware da sua placa, o valor usado em analogWrite() será
ou truncado se é muito grande ou completo com preenchido com zeros se
for muito pequeno. Veja a nota abaixo para detalhes.
Retorna
Nada
Código de Exemplo
O código configura a resolução da saída PWM para diferentes valores.
void setup() {
// inicia a porta serial
Serial.begin(9600);
// configura os pinos digitais 11 a 13 como saída
pinMode(11, OUTPUT);
}
void loop() {
// Lê o valor analógico em A0 e mapeia-o para
// um pino PWM com um LED conectado
int sensorVal = analogRead(A0);
Serial.print("Analog Read) : ");
Serial.print(sensorVal);
// a resolução PWM padrão
analogWriteResolution(8);
analogWrite(11, map(sensorVal, 0, 1023, 0, 255));
Serial.print(" , 8-bit PWM value : ");
Serial.print(map(sensorVal, 0, 1023, 0, 255));
// Muda a reolução PWM para 12 bits
// A resolução completa de 12 bits é suportada
// apenas no Due
Serial.print(" , 12-bit PWM value : ");
Serial.print(map(sensorVal, 0, 1023, 0, 4095));

analogWriteResolution() (continuação)
// Muda a reolução PWM para 4 bits

Serial.print(", 4-bit PWM value : ");
Serial.println(map(sensorVal, 0, 1023, 0, 15));
delay(5);
}
Se você configurar analogWriteResolution() com um valor maior que a
capacidade de sua placa, o Arduino irá descartar os bits extras. Por
exemplo: ao configurar o Due com analogWriteResolution(16) em um pino
DAC 12-bit, apenas os primeiros 12 bits dos valores passados para
analogWrite() serão usados e os outros 4 bits serão descartados.
Se você configurar analogWriteResolution() com um valor menor que a
capacidade de sua placa, os bits ausentes serão completos com zeros para
preencher o tamanho requerido pelo hardware. Por exemplo: ao configurar
o Due com analogWriteResolution(8) em um pino DAC 12-bit, o Arduino irá
adicionar 4 bits zero a esquerda do valor 8-bit usado em analogWrite() para
obter os 12 bits requeridos.

ENTRADAS E SAÍDAS AVANÇADAS Página 217
noTone()
Interrompe a geração de uma onda quadrada iniciada pela função tone().
Não tem nenhum efeito se nenhum tom está sendo gerado.
Sintaxe
ao
n nT
aoln
oeg(
Wprin
toe)
(pino, valor)
Parâmetros
pino : o pino do Arduino no qual se quer parar de gerar um tom.
Retorna
Nada
Se você quiser tocar tons diferentes em múltiplos pinos, você precisa
chamar noTone() em um pino antes de chamar tone() no próximo pino.

pulseIn()
Captura a duração de um pulso em um pino (que pode ser HIGH ou LOW).
Por exemplo, se o valor HIGH é passado para a função, a função pulseIn()
espera o pino ir para do estado 'LOW' para HIGH, começa a temporizar,
então espera o pino ir para o estado LOW e para de temporizar. Retorna o
tamanho do pulso em microssegundos ou desiste e retorna 0 se não
receber nenhum pulso dentro de um tempo máximo de espera
especificado.
A temporização dessa função foi determinada empiricamente e irá
provavelmente mostrar erros em pulsos mais longos. funciona em pulsos de
10 microssegundos a 3 minutos de duração.
Sintaxe
au
p nl
asle
oIgn
W(rp
iitn
eo(,
piv
naol
,or
v)alor)
pulseIn(pino, valor, tempo_de_espera)
Parâmetros
pino : o número do pino no Arduino no qual se quer capturar a duração de
um pulso. (int)
valor : tipo de pulso a ser lido: pode ser HIGH ou LOW. (int)
tempo_de_espera (opcional): o número de microssegundos a se esperar
pelo começo do pulso; o padrão é um segundo. (unsigned long)
Retorna
A duração do pulso (em microssegundos) ou 0 se nenhum pulso começar
antes de se esgotar o tempo de espera (unsigned long).

pulseIn() (continuação)
Código de Exemplo
O exemplo abaixo imprime a duração de um pulso no pino 7.
int pino = 7; //pino para a entrada do pulso
unsigned long duracao; //variável para guardar a duração do pulso
vo i d s e t u p ( )
{
Serial.begin(9600);
pinMode(pino, INPUT);
}
v o id l o o p ( )
{
duracao = pulseIn(pino, HIGH);
S e r i a l . p r i n t l n ( d ur a c a o ) ;
}

pulseInLong()
pulseInLong() é uma alternativa à função pulseIn(), sendo melhor para lidar
com pulsos longos e situações afetadas por interrupções.
Reads a pulse (either HIGH or LOW) on a pin. For example, if value is HIGH,
pulseInLong() waits for the pin to go HIGH, starts timing, then waits for the
pin to go LOW and stops timing. Returns the length of the pulse in
microseconds or 0 if no complete pulse was received within the timeout.
A temporização dessa função foi determinada empiricamente e irá
provavelmente mostrar erros em pulsos mais curtos. Funciona em pulsos de
10 microssegundos a 3 minutos de duração. Por favor note que se a função
for configurada para recebr um pulso HIGH e o pino já estiver no estado
HIGH quando a função for chamada, essa irá primeiro esperar o pino ir para
estado LOW e então HIGH antes de começar a contar. Essa função pode ser
utilizada apenas quando interrupções estiverem ativadas. Além disso,
resoluções maiores são alcançadas com intervalos maiores.
Sintaxe
au
p nl
asle
oIgn
WLro
intg
e(pino, valor)
pulseInLong(pino, valor, tempo_de_espera)
Parâmetros
pino : o número do pino do Arduino no qual se quer capturar a duração de
um pulso. (int)
valor : tipo de pulso a ser lido: pode ser HIGH ou LOW. (int)
tempo_de_espera (opcional): o número de microssegundos a se esperar
pelo começo do pulso; o padrão é um segundo. (unsigned long)
Retorna
A duração do pulso (em microssegundos) ou 0 se nenhum pulso começar
antes de se esgotar o tempo de espera (unsigned long).

pulseInLong() (continuação)
Código de Exemplo
O exemplo abaixo imprime na porta serial a duração de um pulso no pino
7.
int pino = 7; // pino para a entrada do pulso
unsigned long duracao; // variável para guardar a duração do pulso
Serial.begin(9600);
pinMode(pino, INPUT);
}
v o id l o o p ( ) {
duracao = pulseInLong(pino, HIGH);
S e r i a l . p r i n t l n ( d ur a c a o ) ;
}
Essa função depende da função micros(), então não pode ser usada quando
interrupções estiverem desativadas com noInterrupts().

shiftIn()
Recebe um byte de dados, um bit de cada vez. Começa com ou o bit mais
significante (o mais à esquerda) ou o menos significante (mais à direita).
Para cada bit, o pino de clock é colocado em estado em HIGH, o próximo
bit é lido no pino de dados (data), e então o pino é colocado em estado
LOW novamente.
Se está conectando um dispositivo que funciona a partir da borda de
subida sinal de clock, você irá precisar garantir que o pino de clock está em
estado LOW antes da primeira chamada de shiftIn(), ex. chamando
digitalWrite(clockPin, LOW).
Nota: essa é uma implementação por software; O Arduino também provê
uma biblioteca SPI que faz a implementação em hardware, que é mais
rápida, mas apenas funciona em pinos específicos.
Sintaxe
ay
b nt
aeloi
gnWc
roim
tien
(gpi=
nos
,hi
vfat
lIon
r()dataPin, clockPin, bitOrder)
Parâmetros
dataPin : o pino no qual receber cada bit (int).
clockPin : o pino alternado para sinalizar uma leitura de dataPin.
bitOrder : em que ordem receber os bits; pode ser MSBFIRST ou LSBFIRST.
Correspondendo respectivamente a primeiro o bit mais significativo (Most
Significant Bit First), ou o primeiro o bit menos significativo (Least
Significant Bit First)
Retorna
O valor lido (byte).

shiftOut()
Transfere um byte de dados um bit de cada vez. Começa com ou o bit mais
significante (o mais à esquerda) ou o menos significante (mais à direita).
Cada bit é escrito em sequência em um pino data, logo após o pino clock é
pulsado (colocado em HIGH, depois LOW) para indicar que aquele bit está
disponível.
Nota - se você está conectando um dispositivo que é sincronizado pela
borda de subida do clock, irá precisar fazer com que o pino clock seja low
antes de chamar shiftOut(), ex. com digitalWrite(clockPin, LOW).
Essa é uma implementação por software; O Arduino também provê uma
biblioteca SPI que faz a implementação em hardware, que é mais rápida,
mas apenas funciona em pinos específicos.
Sintaxe
ah
s ni
aflt
oOgu
Wtr(
idta
et(a
pPii
nno, c
vlao
lcok
rP)in, bitOrder, value)
Parâmetros
dataPin : o pino no qual transferir cada bit (int)
clockPin : o pino a ser pulsado uma vez que o pino data estiver com o bit a
ser trasnferido (int)
bitOrder : em que ordem receber os bits; pode ser MSBFIRST ou LSBFIRST.
Respectivamente, primeiro o bit mais significativo (Most Significant Bit
First), ou o primeiro o bit menos significativo (Least Significant Bit First)
value : o valor a ser transferido. (byte)
Retorna
O valor lido (byte).

shiftOut() (continuação)
Código de Exemplo
Para o circuito, ver o tutorial sobre o controle de um registrador de
deslocamento 74HC595 (Em Inglês).
//**************************************************************//
// Name : s hi f t O u t C o d e , H e l l o W o r l d //
// Author : Carlyn Maw,Tom Igoe //
// Date : 25 Oct, 2006 //
// Version : 1.0 //
// Notes : Code for using a 74HC595 Shift Register //
// : to count from 0 to 255 //
//****************************************************************
//Pino conectado a ST_CP no 74HC595
int latchPin = 8;
//Pino conectado a SH_CP no 74HC595
int clockPin = 12;
//Pino conectado a DS no 74HC595
int dataPin = 11;
//configura os pinos usados no loop principal como saídas
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}
//rotina de contagem de 0 até 255
for (int j = 0; j < 256; j++) {
//coloca e mantém o pino latch em low enquanto ocorre a transmissão
digitalWrite(latchPin, LOW);
//transmite o valor de j, a começar pelo bit menos significativo
shiftOut(dataPin, clockPin, LSBFIRST, j);
//retorna o pino latch para high para sinalizar ao chip
//que esse não precisa mais esperar por informação
d i g i t a l Wr i t e ( l a t c h P i n , H I G H ) ;
delay(1000);
}
}
Os pinos data e clock devem ser configurados como saídas com uma
chamada de pinMode().

shiftOut() (continuação)
A função shiftOut() atualmente funciona para transferir apenas 1 byte (8

bits) então requer uma operação em dois passos para transferir valores
maiores que 255.
// Para serial MSBFIRST, faça:
int data = 500;
// transfere o byte mais significativo
s hi f t O u t ( d a t a P i n , c l o c k , M S B F I R S T , ( d a t a > > 8 ) ) ;
// trasnfere o byte menos significativo
shiftOut(dataPin, clock, MSBFIRST, data);
// Para serial LSBFIRST, faça:
data = 500;
// transfere o byte menos significativo
shiftOut(dataPin, clock, LSBFIRST, data);
// transfere o byte mais significativo
s hi f t O ut ( d a t a P i n , c l o c k , L S B F I R S T , ( d a t a > > 8 ) ) ;

tone()
Gera uma onda quadrada na frequência especificada (e duty cycle 50%) em
um pino. A duração pode ser especificada, do contrário a onda continua até
uma chamada de noTone(). O pino pode ser conectado a um buzzer piezo
ou outro speaker para tocar tons.
Apenas um tom pode ser gerado de cada vez. Se um tom já está tocando
em um pino diferente, a chamada de tone() não terá efeito. Se o tom está
tocando no mesmo pino, a chamada irá mudar sua frequência para a nova
especificada.
Uso da função tone() irá interferir com saída PWM nos pinos 3 e 11 (em
placas diferentes do Mega).
Não é possível gerar tons de freqeuência mais baixa que 31Hz. Para detalhes
técnicos, veja as notas de Brett Hagman’s(Em Inglês).
Sintaxe
ao
t nn
ael(
opgi
Wnro
i,tef
(rpe
iqnu
oê,nc
viaa
l)or)
tone(pino, frequência, duração)
Parâmetros
pino : o pino do Arduino no qual gerar o tom
frequência : a frequência do tom em Hertz - unsigned int
duração : a duração do tom em milissegundos (opcional) - unsigned long
Retorna
Nada
Se você quiser tocar tons diferentes em múltiplos pinos, você precisa
chamar noTone() em um pino antes de chamar tone() no próximo pino.

COMUNICAÇÃO Página 227
Serial
Usada para comunicação entre uma placa Arduino e um computador ou
outros dispositivos. Todas as placas Arduino possuem pelo menos uma
porta serial (também conhecida como UART ou USART), enquanto alguns
possuem várias.
*Tabela
No Uno, Nano, Mini, e Mega, pinos 0 e 1 são usados para comunicação com
o computador. Conectar qualquer coisa a esses pinos pode interferir nessa
comunicação, incluindo causar falhas na gravação da placa.
Você pode usar o monitor serial integrado na IDE do Arduino para
comunicar-se com uma placa Arduino. Clique no botão do monitor serial
(lupa) na barra de ferramentas e escolha a mesma taxa de transmissão
usada na chamada de begin().
Você pode usar o monitor serial presente na IDE do Arduino para se
comunicar com uma placa Arduino. Clique no botão do monitor serial na
barra de ferramentas e escolha e usar a mesma taxa de transferência (baud
rate) usada na chamada de begin().
Comunicação serial nos pinos TX/RX usa níveis lógicos TTL (5V ou 3.3V
dependendo da placa). Não conecte esses pinos diretamente um uma porta
serial RS232; esses operam em +/- 12V e podem danificar sua placa Arduino.
Para usar esses pinos para comunicar com seu computador pessoal, você
vai precisar de um adaptador USB-serial extra, pois esses pinos não são
conectados ao adaptador USB-serial do Arduino Mega. para usá-los para
comunicar com um dispositivo serial TTL externo, conecte o pino TX do
Arduino ao pino RX do dispositivo, o pino RX ao pino TX do dispositivo, e o
ground de seu Mega ao ground do dispositivo.

SERIAL Página 228
if(Serial)
Indica se a porta serial especificada está pronta.
Nas placas com USB nativa, if (Serial), ou if(SerialUSB) no Due, indica se a
conexão serial USB CDC está aberta. Para todas as outras placas, e portas
seriais não USB CDC, isso irá sempre retornar true.
Essa função foi introduzida na IDE Arduino 1.0.1.
Sintaxe
af
i na(
lSoe
grWi
rail
t)e(pino, valor)
Parâmetros
Nenhum
Retorna
bool : retorna true se a porta serial especificada está disponível. Irá retornar
false apenas caso verificada a conexão serial USB CDC do Leonardo antes
que a mesma esteja pronta.
Código de Exemplo
O código abaixo inicializa uma porta serial e espera a mesma conectar.
void setup() {
// Inicializa a porta erial
Serial.begin(9600);
// Espera ela estar pronta
while (!Serial) {
; // Espera a porta serial conectar. Necessário para USB nativa
}
}
void loop() {
//porcede normalmente
}

SERIAL Página 229
Serial.available()
Retorna o número de bytes (caracteres) disponíveis para leitura da porta
serial. Esses são dados que já chegaram e foram guardados no buffer de
recebimento (o qual armazena 64 bytes).
A função Serial.available() é herdada da classe Stream.
Sintaxe
ae
S nr
aila
olg.
Warv
iati
el(a
pbil
neo(
,)valor)
Parâmetros
Serial : objeto porta serial. Veja a lista de portas seriais disponíveis em cada
placa no Serial - Página principal
Retorna
O número de bytes disponíveis para leitura.
Código de Exemplo
O código abaixo devolve um caractere recebido na porta serial.
int incomingByte = 0; // para dados recebidos na porta serial
void setup() {
Serial.begin(9600); // abre a porta serial, taxa de transmissão 9600 bps
}
void loop() {
// enviar resposta apenas quando receber dados:
if (Serial.available() > 0) {
// lê o dado recebido:
incomingByte = Serial.read();
// responder o que foi recebido:
Serial.print("Eu recebi: ");
Serial.println(incomingByte, DEC);
}
}

SERIAL Página 230
Serial.available() (continuação)
O código abaixo transfere os dados de uma porta serial do Arduino Mega

para outra. Isso pode ser usado para conectar um dispositivo serial ao
computador através da placa Arduino.
Exemplo para o Arduino Mega:

void setup() {
Serial.begin(9600);
Serial1.begin(9600);
}
void loop() {
// Lê da porta 0, envia para porta 1:
if (Serial.available()) {
int inByte = Serial.read();
Serial1.print(inByte, DEC);
}
// Lê da porta 1, envia para porta 0:
if (Serial1.available()) {
int inByte = Serial1.read();
Serial.print(inByte, DEC);
}
}

SERIAL Página 231
Serial.availableForWrite()
Retorna o número de bytes (caracteres) livres no buffer de transmissão
serial que podem ser ocupados sem bloquear a operação de trasnmissão.
Sintaxe
ae
S nr
aila
olg.
Warv
iati
el(a
pbil
neoF
,or
vWar
liot
re)()
Parâmetros
Retorna
O número de bytes livres no buffer de transmissão.

SERIAL Página 232
Serial.begin()
Configura a taxa de transferência em bits por segundo (baud rate) para
transmissão serial. Para comunicação com um computador, através do
Monitor Serial da IDE, use uma das taxas listadas no canto inferior direito
de sua janela. Você pode, no entanto, especificar outras taxas - por
exemplo, para comunicar nos pinos 0 e 1 com um componente que requer
uma taxa de transferência peculiar.
Um segundo argumento opcional configura o número de bits no dado,
paridade, e bits de parada (stop bits). Caso esse argumento não seja
especificado, o padrão é 8 bits de dados, sem paridade e um stop bit.
Sintaxe
ae
S nr
aila
olg.
Wbre
igti
en((
psip
neoe
,d)
vaS
leori
)al.begin(speed, config)
Parâmetros
speed : a taxa de transmissão em bits per second (baud rate) - (long)
config : configuração do número de bits por transmissão, paridade, e stop
bits. Opções válidas são:
SERIAL_5N1
SERIAL_6N1
SERIAL_7N1
SERIAL_8N1 (o padrão)
SERIAL_5N2
SERIAL_6N2
SERIAL_7N2
SERIAL_8N2
SERIAL_5E1
SERIAL_6E1
SERIAL_7E1

SERIAL Página 233
Serial.begin() (continuação)
SERIAL_8E1
SERIAL_5E2
SERIAL_6E2
SERIAL_7E2
SERIAL_8E2
SERIAL_5O1
SERIAL_6O1
SERIAL_7O1
SERIAL_8O1
SERIAL_5O2
SERIAL_6O2
SERIAL_7O2
SERIAL_8O2
Retorna
Nada
Código de Exemplo
O código abaixo inicia a porta serial a 9600 bps.
void setup() {
Serial.begin(9600); // inicia a porta serial, configura a taxa de dados para 9600
bps
}
}
Exemplo para o Arduino Mega:

O código abaixo inicia todas as portas seriais no Arduino Mega com
diferentes taxas de trasnmissão.
// Exemplo por Jeff Gray (originalmente em Inglês)
// Arduino Mega usando todas suas quatro portas seriais
// (Serial, Serial1, Serial2, Serial3),
// com baud rates diferentes:

SERIAL Página 234
Serial.begin() (continuação)
void setup() {
Serial.begin(9600);
Serial.println("Hello Computer");
Serial1.println("Hello Serial 1");
}
}
Para portas seriais USB CDC (ex. Serial no Leonardo), Serial.begin() é
irrelevante. Você pode usar qulquer taxa de transmissão e configuração
para comunicação serial com essas portas específicas. Veja a lista de portas
seriais disponíveis para cada plana na página principal da classe Serial.

SERIAL Página 235
Serial.end()
Desativa a comunicação serial, permitindo os pinos RX e TX serem usados
novamente como entradas e saídas digitais. Para re-ativar a comunicação
serial, chame Serial.begin().
Sintaxe
ae
S nr
aila
olg.
Wern
idt(
e)(pino, valor)
Parâmetros
Retorna
Nada

SERIAL Página 236
Serial.find()
Serial.find() lê dados do buffer serial de recebimento até a string
especificada ser encontrada. A função retorna true se a string denominada
é encontrada, false se ocorre time-out.
A função Serial.find() é herdada da classe Stream.
Sintaxe
ae
S nr
aila
olg.
Wfrin
tde(t
pair
ngoe
,t)
valor)
Serial.find(target, length)
Parâmetros
target : a string para ser procurada no buffer (char[])
length : comprimento da string procurada (size_t)
Retorna
true ou false (tipo booleano)

SERIAL Página 237
Serial.findUntil()
Serial.findUntil() lê dados do buffer serial até uma string especificada de
dado tamanho ou um terminador serem encontrados.
A função retorna true se a string especificada é encontrada, false se ocorre
time-out.
A função Serial.findUntil() é herdada da classe Stream.
Sintaxe
ae
S nr
aila
olg.
Wfrin
tdeU
(npt
iinl
o(,st
vra,
lot
re)rminal)
Parâmetros
str : a string a ser procurada (*char)
terminal : a string terminadora da busca (*char)
Retorna
Se a string foi ou não encontrada no buffer - bool

SERIAL Página 238
Serial.flush()
Espera a transmissão de dados seriais enviados terminar.(Antes do Arduino
versão 1.0, em vez disso removia qualquer dados recebidos armazenados no
buffer).
flush() herda da classe Stream.
Sintaxe
ae
S nr
aila
olg.
Wfrl
iuts
eh((
p)ino, valor)
Parâmetros
Retorna
Nada

SERIAL Página 239
Serial.parseFloat()
Serial.parseFloat() retorna o primeiro número válido de ponto flutuante do
buffer serial. parseFloat() é terminada pelo primeiro caractere que não é
um número de ponto flutuante. A função retorna se acabar o tempo limite
(veja Serial.setTimeout()).
A função Serial.parseFloat() é herdada da classe Stream.
Sintaxe
ae
S nr
aila
olg.
Wpra
irts
ee(F
plio
naot
,()
vaS
leori
)al.parseFloat(lookahead)
Serial.parseFloat(lookahead, ignore)
Parâmetros
lookahead : the modo usado ao se procurar um número de ponto flutuate
na stream. Tipos de dados permitidos: LookaheadMode. + Valores de
lookahead pemitidos:
- SKIP_ALL: Todos os caracteres exceto o sinal de menos (-), ponto decimal,
ou numerais são ignorados durante a busca na stream por um número de
ponto flutuante. Esse é o modo padrão.
- SKIP_NONE: Nada é ignorado, e a stream não é tocada a menos que o
primeiro caractere a espera seja válido.
- SKIP_WHITESPACE: Apenas tabulações, espaços, feeds de linha ('\n'), e
retornos de linha ('\r') são ignorados.
ignore : usado para ignorar o caractere indicado durante a busca. Udado
por exemplo para pular o separador de milhares. Tipos de dados
permitidos: char
Retorna
O primeiro número válido float no buffer de recebimento. (float)

SERIAL Página 240
Serial.parseInt()
Procura o próximo inteiro válido no buffer de recebimento serial. A função
retorna se acabar o tempo limite (veja Serial.setTimeout()).
A função Serial.parseInt() é herdada da classe Stream.
Em particular:
- Caracteres iniciais que não são dígitos ou um sinal de menos, são
ignorados;
- O Parsing termina quando caractetes não foram lidos em um time-out
configurável, ou um valor não-digito é lido;
- Se nenhum dígito válido foi lido quando ocorre o time-out (ver
Serial.setTimeout()), 0 é retornado;
Sintaxe
ae
S nr
aila
olg.
Wpra
irts
ee(I
pnit
n(o)
, S
vear
lioa
rl).parseInt(char skipChar)
Parâmetros
skipChar : usado para ignorar o caractere indicado na busca. Usado, por
exemplo, para ignorar o ponto em "2.000.000".
Retorna
O próximo inteiro válido - long.

SERIAL Página 241
Serial.peek()
Retorna o próximo byte (caractere) de dados seriais recebidos sem o
remover do buffer serial interno. Isto é, successivas chamadas de peek() irão
retornar o mesmo caractere, assim como irá a próxima chamada de read().
A função `Serial.peek()` é herdada da classe link:../../stream[Stream].
Sintaxe
ae
S nr
aila
olg.
Wpre
ietk
e()
pino, valor)
Parâmetros
Retorna
O primeiro byte dos dados seriais recebidos disponível (ou -1 se não há
dados disponíveis) - int

SERIAL Página 242
Serial.print()
Imprime dados na porta serial em como texto ASCII (facilmente legível,
diferentemente dos valores binários). Essa função pode assumir várias
formas. números são impressos usando um caractere ASCII para cada
dígito. Floats são similarmente impressos como dígitos ASCII, padronizados
com duas casas decimais. Bytes são enviados como um único caractere.
Caracteres e strings são enviados normalmente, pois já estão em formato
ASCII. Por exemplo:
- Serial.print(78) imprime "78"
- Serial.print(1.23456) imprime "1.23"
- Serial.print('N') imprime "N"
- Serial.print("Hello world.")
imprime "Hello world."Um segundo parâmetro opcional especifíca a base
(formato) a ser usada; valores permitidos são BIN(binário, ou base 2),
OCT(octal, ou base 8), DEC(decimal, ou base 10), HEX(hexadecimal, ou base
16). Para números de ponto flutuante, esse parâmetro especifica o número
de casas decimais a serem impressas. Por exemplo:
- Serial.print(78, BIN) imprime "1001110"
- Serial.print(78, OCT) imprime "116"
- Serial.print(78, DEC) imprime "78"
- Serial.print(78, HEX) imprime "4E"
- Serial.print(1.23456, 0) imprime "1"
- Serial.print(1.23456, 2) imprime "1.23"
- Serial.print(1.23456, 4) imprime "1.2346"
Você pode passar strings armazenadas na memória flash para a função
Serial.print() envolvendo as com F(). Por exemplo:
Serial.print(F(“Hello World”))
Para enviar dados, sem convertê-los para texto ASCII, use Serial.write().
Sintaxe
ae
S nr
aila
olg.
Wprr
iitn
et((
pvia
nlo)
, valor)
Serial.print(val, formato)

SERIAL Página 243
Serial.print() (continuação)
Parâmetros
val : o valor a ser impresso - qualquer tipo de dados
formato : especifica a base do numeral (para tipos de dados int) ou número
de casas decimais (para tipos de dados float)
Retorna
print() retorna o número de bytes escritos, porém a leitura desse número é
opcional - `size_t
Código de Exemplo
O código abaixo imprime um valor na porta serial em vários formatos.
/*
Usa um loop for para dados e imprime cada número em vários formatos.
*/
int x = 0; // variable
void setup() {
Serial.begin(9600); // abre a porta serial a 9600 bps:
}
void loop() {
// imprime rótulos para cada base
Serial.print("NUMERO"); // imprime um rótulo
Serial.print("\t"); // imprime uma tabulação (TAB)
Serial.print("DEC");
Serial.print("\t");
Serial.print("HEX");
Serial.print("\t");
Serial.print("OCT");
S e ri a l . p r i n t ( " \ t " ) ;
Serial.print("BIN");
Serial.println("\t");
for (x = 0; x < 64; x++) { // apenas uma parte da tabela ASCII, edite para mais ou
menos valores

SERIAL Página 244
Serial.print() (continuação)
// imprime cada número em vários formatos:

Serial.print(x); // imprime como decimal codificado em ASCII- o mesmo que
"DEC"
S e ri a l . p r i n t ( " \ t " ) ; // imprime uma tabulação
Serial.print(x, DEC); // imprime como decimal codificado em ASCII
Serial.print("\t"); // imprime uma tabulação
Serial.print(x, HEX); // imprime como hexadecimal codificado em ASCII
Serial.print("\t"); // imprime uma tabulação
Serial.print(x, OCT); // imprime como octal codificado em ASCII
S e ri a l . p r i n t ( " \ t " ) ; // imprime uma tabulação
Serial.println(x, BIN);// imprime como binário codificado em ASCII
//então adiciona o retorno (enter) com "println"
delay(200); // delay de 200 milissegundos
}
Serial.println(); // imprime outro retorno
}
Desde a versão 1.0 da IDE do Arduino, a trasmissão serial é assíncrona. Para
mais informações sobre a assincronicidade de Serial.print(), veja a seção
Notas e Advertências da página de referência da função Serial.write().

SERIAL Página 245
Serial.println()
Imprime dados na porta serial como texto ASCII seguido pelo caratere de
retorno de carruagem (ASCII 13, ou '\r') e um cactere de nova linha (ASCII
10, ou '\n'). Essa função assume as mesmas formas que Serial.print().
Sintaxe
ae
S nr
aila
olg.
Wprr
iitn
et(l
pni(
nvoa
,l)
valor)
Serial.println(val, formato)
Parâmetros
val : o valor a ser impresso - qualquer tipo de dados
formato : especifica a base do numeral (para tipos de dados int) ou número
de casas decimais (para tipos de dados float)
Retorna
size_t: println() retorna o número de bytes escritos, porém a leitura desse
número é opcional
Código de Exemplo
O código abaixo faz a leitura de um valor analógico a cada 10 ms e
imprime esse valor na porta serial em vários formatos.
/*
L ê u m v a l o r a n a l ó g i c o n o p i n o d e e n t r a d a a n a l ó g i c a 0 , i m pr i m e e s s e d a d o n a p o r t a
serial.
criado em 24 de Março de 2006 por Tom Igoe
Tradução em 29 de Novembro de 2017
*/
int analogValue = 0; / / v a r i á v e l p a r a g u a r da r a l e i t u r a a n a l ó g i c a

SERIAL Página 246
Serial.println() (continuação)
// abre a porta serial a 9600 bps:

Serial.begin(9600);
}
void loop() {
// Lê o valor analógico no pino 0:
analogValue = analogRead(0);
// Imprime a leitura em vários formatos:
Serial.println(analogValue); // imprime como decimal (padrão) codificado em
ASCII
S e ri a l . p r i n t l n ( a n a l o g V a l u e , D E C ) ; // imprime como decimal codificado em ASCII
Serial.println(analogValue, HEX); // imprime como hexadecimal codificado em ASCII
S e r i a l . p r i n t l n ( a n a l o g Va l u e , O C T ) ; // imprime como octal codificado em ASCII
S e ri a l . p r i n t l n ( a n a l o g V a l u e , B I N ) ; // imprime como binário codificado em ASCII
// espera 10 milissegundos antes da próxima leitura:
delay(10);
}
Desde a versão 1.0 da IDE do Arduino, a trasmissão serial é assíncrona.; Para
mais informações sobre a assincronicidade de Serial.print(), veja a seção
Notas e Advertências da página de referência da função Serial.write().

SERIAL Página 247
Serial.read()
Lê dados recebidos na porta serial.
A função Serial.read() é herdada da classe Stream.
Sintaxe
ae
S nr
aila
olg.
Wre
iatd
e()
pino, valor)
Parâmetros
Retorna
O primeiro byte de dados recebidos disponível (ou -1 se não há dados
disponíveis) - int.
Código de Exemplo
O código abaixo devolve um dado recebido na porta serial.
int incomingByte = 0; // variável para o dado recebido
void setup() {
S er i a l . b e g i n ( 9 6 0 0 ) ; / / a b r e a p o r t a s e r i a l , c o n f i g u r a a t a x a d e t r a n s f e r ê n c i a p a r a
9600 bps
}
void loop() {
// apenas responde quando dados são recebidos:
if (Serial.available() > 0) {
// lê do buffer o dado recebido:
i n c o m i n g B y te = S e r i a l . r e a d ( ) ;
/ / r e s p o n d e c o m o da d o r e c e b i d o :
Serial.print("I received: ");
Serial.println(incomingByte, DEC);
}
}

SERIAL Página 248
Serial.readBytes()
Serial.readBytes() lê caracteres da porta serial e os move para um buffer. A
função termina se a quantidade de bytes determinada foi lida, ou se ocorre
time-out (ver Serial.setTimeout()).
Serial.readBytes() retorna o número de caracteres colocados no buffer. Um
valor 0 indica que dados não foram encontrados.
A função Serial.readBytes() é herdada da classe Stream.
Sintaxe
ae
S nr
aila
olg.
Wre
iatd
eB(y
ptie
nso(
,bu
vfaf
leor,
) length)
Parâmetros
buffer : o buffer para se armazenar os bytes (char[] ou byte[])
length : o número de bytes a serem lidos (int)
Retorna
o número de bytes colocados no buffer (size_t)

SERIAL Página 249
Serial.readBytesUntil()
Serial.readBytesUntil() lê caracteres da porta serial e os move para um
buffer. A função termina se o caractere terminador foi encontrado, se a
quantidade de bytes determinada foi lida, ou se ocorre time-out (ver
Serial.setTimeout()). A função retorna os caracteres até o último antes do
caractere terminador especificado. O caractere terminador não é movido
para o buffer.
Serial.readBytesUntil() retorna o número de caracteres colocados no buffer.
Um valor 0 indica que dados não foram encontrados.
A função Serial.readBytesUntil() é herdada da classe Stream.
Sintaxe
ae
S nr
aila
olg.
Wre
iatd
eB(y
ptie
nsoU
,nt
vial(
ocrh
)aracter, buffer, length)
Parâmetros
Serial: objeto porta serial. Veja a lista de portas seriais disponíveis em
cada placa no Serial - Página principal
character : o charactere que encerra a busca (char)
buffer: o buffer para se armazenar os bytes (char[] ou byte[])
Retorna
o número de bytes colocados no buffer (size_t)
O caractere terminador é descartado do buffer serial.

SERIAL Página 250
Serial.readString()
Serial.readString() lê caracteres do buffer serial e os move para uma String.
A função termina se ocorre time-out (ver setTimeout()).
A função Serial.readString() é herdada da classe Stream.
Sintaxe
ae
S nr
aila
olg.
Wre
iatd
eS(t
prii
nnog
,()
valor)
Parâmetros
Retorna
Uma String lida do buffer serial

SERIAL Página 251
Serial.readStringUntil()
Serial.readString() lê caracteres do buffer serial e os move para uma String.
A função termina se ocorre time-out (ver setTimeout()).
A função Serial.readString() é herdada da classe Stream.
Sintaxe
ae
S nr
aila
olg.
Wre
iatd
eS(t
prii
nnog
,Un
vtai
llo(
rt)erminador)
Parâmetros
terminador : o caractere que encerra a busca (char)
Retorna
A String completa lida do buffer serial, até o caractere terminador.

SERIAL Página 252
Serial.setTimeout()
Serial.setTimeout() configura o número máximo de milissegundos a se
esperar por dados seriais. O valor padrão é de 1000 milisegundos.
A função Serial.setTimeout() é herdada da classe Stream.
Sintaxe
ae
S nr
aila
olg.
Wsre
itT
ei(m
peio
nuot
,(t
veam
lpoo
r)
Parâmetros
tempo : tempo limite em milisegundos (long).
Retorna
Nada
Funções da classe Serial que usam o valor de tempo limite configurado via
Serial.setTimeout():
- Serial.find()
- Serial.findUntil()
- Serial.parseInt()
- Serial.parseFloat()
- Serial.readBytes()
- Serial.readBytesUntil()
- Serial.readString()
- Serial.readStringUntil()

SERIAL Página 253
Serial.write()
Escreve dados binários na porta serial. Esses dados são enviados como um
byte ou séries de bytes; para enviar os caracteres representando os dígitos
de um número, use em vez disso a função print().
Sintaxe
Serial.write(val)
Serial.write(str)
Serial.write(buf, len)
Parâmetros
val : o valor a ser enviado como um único byte.
str : uma string a ser enviada como uma série de bytes .
buf : um vetor a ser enviado como uma série de bytes.
Retorna
O número de bytes escritos na porta serial - size_t
write() irá retornar o número de bytes escritos, apesar de ler esse valor ser
opcional
Código de Exemplo
O código abaixo usa a função Serial.write() para escrever um valor e uma
string na porta serial.
void setup() {
S er i a l . b e g i n ( 9 6 0 0 ) ;
}
void loop() {
Serial.write(45); // envia um byte com valor 45 (0b101101)
i n t b y te s S e n t = S e r i a l . w r i t e ( “ h e l l o ” ) ; //envia a string “hello” e retorna o tamanho
da string.
}

SERIAL Página 254
Serial.write() (continuação)
Desde a versão 1.0 da IDE do Arduino, a trasmissão serial é assíncrona. Se
há espaço livre suficiente no buffer de tranmissão, Serial.write() irá retornar
antes que quaisquer caracteres sejam transmitidos pela serial. Se o buffer
de transmissão estiver cheio, então Serial.write() irá bloquear o programa
até que exista espaço livre suficiente no buffer de transmissão. Para evitar
chamadas de Serial.write() que possam bloquear a execução, você pode
checar primeiro a quantidade de espaço livre no buffer de tranmissão
usando availableForWrite().

SERIAL Página 255
serialEvent()
Chamada quando dados estão disponíveis no buffer serial. Use Serial.read()
para ler esses dados.
Sintaxe
void serialEvent() {
/ / c ó di g o
}
Para placas com portas seriais adicionais (veja a lista de portas seriais
disponíveis para cada placa no Serial - Página principal):
void serialEvent1() {
//código
}
//código
}
/ / c ó di g o
}
Parâmetros
código : quaisquer linhas de código válidas
Retorna
Nada
serialEvent() não funciona no Leonardo, Micro ou Yún.
serialEvent() e serialEvent1() não funcionam nas placas Arduino SAMD.
serialEvent(), serialEvent1(), serialEvent2(), e serialEvent3() não funcionam
no Arduino Due.

COMUNICAÇÃO Página 256
Stream
Stream é a classe base para streams de caracteres ou binárias. Não é
chamada diretamente, mas invocada quando você usa uma função que
depende dessa classe.
Stream define as funções de leitura no Arduino. Quando usar qulquer
funcionalidade core que usa read() ou um método similar, você pode
assumir seguramente que essa faz chamadas a classe Stream. Para funções
como print(), a classe Stream herda da classe Print.
Algumas das bibliotecas que dependem da classe Stream são:
- Serial
- Wire
- Ethernet
- SD

STREAM Página 257
Stream.available()
Stream.available() retorna o numero de bytes disponíveis na stream. Apenas
para bytes que já foram recebidos.
Essa função é parte da classe Stream, e pode ser chamada por qualquer
classe que herda da mesma (Wire, Serial, etc). Veja a página principal da
classe Stream para mais informações.
Sintaxe
stream.available()
Parâmetros
stream : uma instância de uma classe que herda da classe Stream.
Retorna
int: o número de bytes disponíveis para leitura

STREAM Página 258
Stream.read()
read() Lê caracteres recebidos em uma stream.
Sintaxe
stream.read()
Parâmetros
Retorna
O primeiro byte de dados recebidos disponível (ou -1 se nenhum dado está
disponível).

STREAM Página 259
Stream.flush()
flush() espera até que todos os caracteres em um buffer de trasnmissão
sejam enviados.
Sintaxe
stream.flush()
Parâmetros
Retorna
Nada.

STREAM Página 260
Stream.find()
find() lê dados da stream até a string specificada ser encontrada. A função
retorna true se a string especificada é encontrada, false se ocorre time-out
(veja Stream.setTimeout()).
Sintaxe
stream.find(target)
stream.find(target, length)
Parâmetros
target : a string a ser procurada (char[])
length : comprimento da string procurada (size_t)
Retorna
bool

STREAM Página 261
Stream.findUntil()
findUntil() lê dados da stream até a string especificada ou terminador
serem encontrados. A função termina se acabar o tempo limite (veja
Stream.setTimeout()).
Essa função retorna true se a string é encontrada, false se ocorre time-out.
Sintaxe
stream.findUntil(target, terminal)
Parâmetros
target : a string a ser procurada.
terminal : uma string para encerrar a busca.
Retorna
bool

STREAM Página 262
Stream.peek()
Lê um byte de um arquivo sem avançar para o próximo. Isto é, chamadas
sucessivas de peek() irão retornar o mesmo valor, assim como irá a próxima
chamada de read().
Sintaxe
stream.peek()
Parâmetros
Retorna
O próximo byte (ou caractere), ou -1 se não há caracteres disponíveis.

STREAM Página 263
Stream.readBytes()
readBytes() lê caracteres de uma stream para um buffer. A função termina
se o número de bytes especificado foi lido, ou se ocorre time-out (ver
setTimeout()).
readBytes() retorna o número de bytes colocados no buffer. Um valor 0
indica que não foram encontrados dados válidos.
Sintaxe
stream.readBytes(buffer, length)
Parâmetros
buffer : o buffer para se guardar os bytes (char[] ou byte[])
length : o número de bytes a serem lidos read(int)
Retorna
O número de bytes colocados no buffer (size_t)

STREAM Página 264
Stream.readBytesUntil()
readBytesUntil() lê bytes de uma stream para um buffer. A função termina
se o carctere terminador é encontrado, o número de bytes determinado foi
lido, ou ocorre time-out (ver setTimeout()). A função retorna o caractere até
o último caractere antes o terminador fornecido. O terminador em si não é
retornado no buffer.
readBytesUntil() retorna o número de bytes colocados no buffer. Um valor 0
indica que não foram encontrados dados válidos.
Sintaxe
stream.readBytesUntil(character, buffer, length)
Parâmetros
character : o caractere para encerra a busca (char)
buffer : o buffer para armazenar os bytes (char[] ou byte[])
Retorna
O número de bytes colocados no buffer.

STREAM Página 265
Stream.readString()
readString() lê caracteres de uma stream em uma String. A função termina
se ocorre timeout (ver setTimeout()).
Sintaxe
stream.readString()
Parâmetros
Retorna
Uma String lida da stream.

STREAM Página 266
Stream.readStringUntil()
readStringUntil() lê caracteres de uma stream para uma String. A função
termina se o caractere terminador é detectado ou se ocorre time-out (ver
setTimeout()).
Sintaxe
stream.readString(terminator)
Parâmetros
terminator : o caractere para encerrar a busca (char)
Retorna
A String completa da Stream, até o caractere terminador.

STREAM Página 267
Stream.parseInt()
parseInt() retorna o primeiro número inteiro (long) válido da stream.
Caracteres iniciais que não são dígitos (ou o sinal de menos) são ignorados.
Em particular:
- Caracteres iniciais que não são dígitos ou um sinal de menos, são
ignorados;
- O parsing para quando nenhum caractere foi lido em um time-out de
valor confgurável, ou um caractere não-dígito é lido;
- Se nehum digito válido foi lido quando ocorre time-out (ver
Stream.setTimeout()), é retornado 0;
Sintaxe
stream.parseInt(list)
stream.parseInt(''list', char skipchar')
Parâmetros
list : a stream a se checar por ints (char)
skipChar : usado para ignorar o carctere indicado na busca. Usado, por
exemplo, para ignorar o ponto em "2.000.000".
Retorna
long

STREAM Página 268
Stream.parseFloat()
parseFloat() retorna o primeiro número de ponto flutuante da posição atual.
parseFloat() é terminada pelo primeiro caractere que não é um digito
encontrado após o número. A função retorna se acabar o tempo limite (veja
Stream.setTimeout()).
Sintaxe
stream.parseFloat()
stream.parseFloat(lookahead)stream.parseFloat(lookahead, ignore)
Parâmetros
lookahead: the modo usado ao se procurar um número de ponto flutuate
na stream. Tipos de dados permitidos: LookaheadMode. + Valores de
lookahead pemitidos:
- SKIP_ALL: Todos os caracteres exceto o sinal de menos (-), ponto decimal,
ou numerais são ignorados durante a busca na stream por um número de
ponto flutuante. Esse é o modo padrão.
- SKIP_NONE: Nada é ignorado, e a stream não é tocada a menos que o
primeiro caractere a espera seja válido.
- SKIP_WHITESPACE: Apenas tabulações, espaços, feeds de linha ('\n'), e
retornos de linha ('\r') são ignorados.
ignore : usado para ignorar o caractere indicado durante a busca. Udado
por exemplo para pular o separador de milhares. Tipos de dados
permitidos: char
Retorna
float

STREAM Página 269
Stream.setTimeout()
setTimeout() configura o número máximo de milissegundos a se esperar por
dados. O valor padrão é de 1000 milisegundos.
Sintaxe
stream.setTimeout(time)
Parâmetros
time : duração do timeout em milissegundos (long).
Retorna
Nada
Funções da classe Stream que usam o valor de tempo limite configurado
via setTimeout():
- find()
- findUntil()
- parseInt()
- parseFloat()
- readBytes()
- readBytesUntil()
- readString()
- readStringUntil()

USB Página 270
Keyboard
As funções da biblioteca Keyboard permitem placas baseadas nos micros
32u4 ou SAMD funcionar como um teclado e enviar sinais de teclas
pressionadas a um computador conectado através da porta micro USB
nativa.
Nota: Nem todo caractere ASCII, particularmente os não imprimíveis,
podem ser enviados com a biblioteca Keyboard.
A biblioteca suporta o uso de teclas modificadoras. Teclas modificadoras
mudam o comportamento de outra tecla quando pressionadas
simultaneamente. Veja aqui informações adicionais sobre as teclas
suportadas e seu uso.
As bibliotecas core permitem as placas baseadas nos micros 32u4 e SAMD
(Leonardo, Esplora, Zero, Due e família MKR) aparecer em um computador
conectado como um mouse e/ou teclado nativo.
Uma nota as bibliotecas Mouse e Keyboard : se a biblioteca Mouse ou
Keyboard estiver rodando constantemente, será difícil programar a sua
placa. Funções como Mouse.move() e Keyboard.print() irão mover o cursor
ou enviar teclas ao computador conectado e devem ser chamadas apenas
quando você estiver pronto para usá-las. É recomendado se usar um
sistema de controle para ativar a funcionalidade USB, como um botão físico
ou apenas responder a entradas específicas que você pode
controlar.Confira os exemplos sobre as bibliotecas Mouse e Keyboard para
algumas formas de fazer isso.
Quando usar as bibliotecas Mouse ou Keyboard, pode ser melhor testar sua
saída primeiro utilizando Serial.print(). Dessa forma, você pode ter certeza
de quais valores estão sendo relatados.

KEYBOARD Página 271
Keyboard.begin()
Quando usado com uma placa com USB nativa, como o Leonardo ou Due,
Keyboard.begin() começa a emulação de um teclado conectado ao
computador. Para encerrar o controle, use Keyboard.end().
Sintaxe
Keyboard.begin()
Parâmetros
Nenhum
Retorna
Nada
Código de Exemplo
#include <Keyboard.h>
void setup() {
// Configura o pino 2 como entrada e ativa
// o resistor pull-up tal que o pino seja HIGH
// a menos que conectado ao ground:
pinMode(2, INPUT_PULLUP);
//Inicia a emulação de um teclado USB
Keyboard.begin();
}
void loop() {
//se o botão for pressionado
if (digitalRead(2) == LOW) {
//envia a mensagem
Keyboard.print("Hello!");
}
}

Keyboard.end()
Encerra a emulação de um teclado USB conectado a um computador. Para
iniciar a emulação de um teclado, use Keyboard.begin().
Sintaxe
Keyboard.end()
Parâmetros
Nenhum
Retorna
Nada
Código de Exemplo
void setup() {
//inicia a emulação de um teclado USB
Keyboard.begin();
//envia uma mensagem como se fosse teclada em um teclado real
//encerra a emulação do teclado
Keyboard.end();
}
void loop() {
//não faz nada aqui
}

Keyboard.press()
Quando chamada, Keyboard.press() funciona como se uma tecla fosse
pressionada e segurada no seu teclado. Útil quando usando-se as teclas
modificadoras. Pra liberar a tecla, use Keyboard.release() ou
Keyboard.releaseAll().
É necessário chamar Keyboard.begin() antes de se usar press().
Sintaxe
Keyboard.press(char)
Parâmetros
char : a tecla a ser pressionada
Retorna
size_t: o número de teclas pressionadas enviadas.
Código de Exemplo
// use essa opção para OSX:
// char ctrlKey = KEY_LEFT_GUI;
// use essa opção para Windows e Linux:
char ctrlKey = KEY_LEFT_CTRL;
void setup() {
// inicializa o controle do teclado virtual:
Keyboard.begin();
}
void loop() {
while (digitalRead(2) == HIGH) {
// não faz nada até que o pino 2 esteja LOW
delay(500);

Keyboard.press() (continuação)
}
delay(1000);
// novo documento:
Keyboard.press(ctrlKey);
Keyboard.press('n'); //equivalente ao atalho control + n
delay(100);
Keyboard.releaseAll();
// espera uma nova janela abrir no computador:
delay(1000);
}

Keyboard.print()
Envia uma tecla pressionada, ou uma sequência de teclas, para um
computador conectado.
Keyboard.print() deve ser chamada após a inicialização com
Keyboard.begin().
Sintaxe
Keyboard.print(caractere)
Keyboard.print(caracteres)
Parâmetros
caractere : um char ou int a ser enviado ao computador como se fosse uma
tecla pressionada no teclado.
caracteres : uma string a ser enviada ao computador como se fosse uma
palavra ou frase digitada no teclado.
Retorna
size_t : número de bytes enviados.
Código de Exemplo
void setup() {
// inicializa a emulação de um teclado USB
Keyboard.begin();
}
void loop() {
// se o botão for pressionado
// envia a mensagem
}
}

Keyboard.print() (continuação)
Quando você usa a função Keyboard.print(), o Arduino toma o controle do
computador! Tenha certeza que você tem controle de quando as
mensagens vão ser enviadas antes de usar essa função. Pode ser difícil
gravar um novo código no Arduino se ele estiver digitando algo o tempo
todo. Um botão para ativar/desativar o controle do teclado é bastante
efetivo.

Keyboard.println()
Envia uma tecla pressionada, ou uma sequência de teclas, para um
computador conectado, seguido dos carcteres newline e carriage return.
Keyboard.println() deve ser chamada após a inicialização com
Keyboard.begin().
Sintaxe
Keyboard.println(caractere)
Keyboard.println(caracteres)
Parâmetros
caractere : um char ou int a ser enviado ao computador como se fosse uma
tecla pressionada no teclado., seguido dos caracteres newline e carriage
return.
caracteres : uma string a ser enviada ao computador como se fosse uma
palavra ou frase digitada no teclado, seguida dos caracteres newline e
carriage return.
Retorna
size_t : número de bytes enviados.
Código de Exemplo
void setup() {
// inicializa a emulação de um teclado USB
Keyboard.begin();
}

Keyboard.println() (continuação)
// envia a mensagem, automaticamnete seguida de \n e \r
Keyboard.println("Hello!");
}
}
Quando você usa a função Keyboard.println(), o Arduino toma o controle do
efetivo.

Keyboard.release()
Libera, ou "solta", uma tecla especificada que está segurada. Veja
Keyboard.press() para mais informações.
Sintaxe
Keyboard.release(tecla)
Parâmetros
tecla : a tecla a ser liberada. char
Retorna
size_t : o número de teclas liberadas
Código de Exemplo
void setup() {
// Inicia a emulação de um teclado USB
Keyboard.begin();
}
void loop() {
// não faz nada até que o pino 2 esteja em LOW
delay(500);
}
delay(1000);
// novo documento:

Keyboard.release() (continuação)
K e y b o a rd . p r e s s ( c t r l K e y ) ;
K e yb o a r d . p r e s s ( ' n ' ) ;
delay(100);
Keyboard.release(ctrlKey);
Keyboard.release('n');
delay(1000);
}

Keyboard.releaseAll()
Libera todas as teclas seguradas. Veja Keyboard.press() para mais
informações.
Sintaxe
Keyboard.releaseAll()
Parâmetros
Nenhum
Retorna
Nada
Código de Exemplo
void setup() {
Keyboard.begin();
}
void loop() {
// não faz nada até que o pino 2 esteja em LOW
delay(500);
}
delay(1000);
// novo documento:

Keyboard.releaseAll() (continuação)
K e y b o a rd . p r e s s ( c t r l K e y ) ;
K e yb o a r d . p r e s s ( ' n ' ) ;
delay(100);
Keyboard.releaseAll();
delay(1000);
}

Keyboard.write()
Envia uma tecla pressionada para um computador conectado. Isso é similar
a pressionar e soltar uma tecla do seu teclado. Você pode enviar alguns
caracteres ASCII ou as teclas modificadoras e especiais adicionais.
Apenas caracteres ASCII que estão no teclado são suportados. Por exemplo,
o caractere ASCII 8 (backspace) funciona, mas o caractere ASCII 25
(Substituição) não. Ao enviar letras maiúsculas, Keyboard.write() envia o
comando shift mais o caractere desejado, da mesma forma que quando se
digita em um teclado comum. Se um tipo numérico é enviado, este é
interpretado como o caractere ASCII correspondente (ex.
Keyboard.write(97) irá enviar 'a').
Para uma lista completa de caracteres ASCII, veja asciitable.com.
Sintaxe
Keyboard.write(character)
Parâmetros
character : um char ou int a ser enviado ao computador. Pode ser enviado
em qualquer notação que é aceitável para um char. Por exemplo, todas as
formas abaixo são aceitáveis e enviadas como o mesmo valor, 65 ou ASCII
A:
Keyboard.write(65); // envia o valor ASCII 65, ou A
Keyboard.write('A'); // mesma coisa, mas como um caractere entre
aspas simples
Keyboard.write(0x41); // mesma coisa, porém em notação hexadecimal
Keyboard.write(0b01000001); // mesmo valor, mas em binário (escolha
estranha, mas funciona)
Retorna
size_t: o número de bytes enviados.

Keyboard.write() (continuação)
void setup() {
Keyboard.begin();
}
// envia o caratere ASCII 'A',
Keyboard.write(65);
}
}
Quando você usa a função Keyboard.write(), o Arduino toma o controle do
efetivo.

USB Página 285
Mouse
As funções da biblioteca mouse permitem placas baseadas nos micros 32u4
ou SAMD controlar o movimento do cursor em um computador conectado
através da porta micro USB nativa. Quando a posição do cursor é
atualizada, essa é sempre relativa a sua posição anterior.
As bibliotecas core permitem as placas baseadas nos micros 32u4 e SAMD
(Leonardo, Esplora, Zero, Due e família MKR) aparecer em um computador
conectado como um mouse e/ou teclado nativo.
Uma nota as bibliotecas Mouse e Keyboard: se a biblioteca Mouse ou
Keyboard estiver rodando constantemente, será difícil programar a sua
placa. Funções como Mouse.move() e Keyboard.print() irão mover o cursor
ou enviar teclas ao computador conectado e devem ser chamadas apenas
quando você estiver pronto para usá-las. É recomendado se usar um
sistema de controle para ativar a funcionalidade USB, como um botão físico
ou apenas responder a entradas específicas que você pode controlar.
Confira os exemplos sobre as bibliotecas Mouse e Keyboard para algumas
formas de fazer isso.
Quando usar as bibliotecas Mouse ou Keyboard, pode ser melhor testar sua
saída primeiro utilizando Serial.print(). Dessa forma, você pode ter certeza
de quais valores estão sendo relatados.

MOUSE Página 286
Mouse.begin()
Começa a emular o mouse conectado a um computador. begin() deve ser
chamado antes de controlar o computador. Para encerrar o controle, use
Mouse.end () .
Sintaxe
Mouse.begin()
Parâmetros
Nenhum.
Retorna
Nada.
Código de Exemplo
#include <Mouse.h>
void setup() {
pinMode(2, INPUT);
}
void loop() {
//initiate the Mouse library when button is pressed
if (digitalRead(2) == HIGH) {
Mouse.begin();
}
}

MOUSE Página 287
Mouse.click()
Envia um clique momentâneo para o computador na localização do cursor.
Isso é o mesmo que pressionar e soltar imediatamente o botão do mouse.
Mouse.click() o padrão é o botão esquerdo do mouse.
Sintaxe
Mouse.click()
Mouse.click(button)
Parâmetros
button: qual botão do mouse deve ser pressionado. Tipos de dados
permitidos: char.
MOUSE_LEFT (predefinição)
MOUSE_RIGHT
MOUSE_MIDDLE
Retorna
Nada.
Código de Exemplo
#include <Mouse.h>
void setup() {
pinMode(2, INPUT);
//initiate the Mouse library
Mouse.begin();
}
void loop() {
//if the button is pressed, send a left mouse click
Mouse.click();
}
}
Quando você usa o Mouse.click()comando, o Arduino assume o controle do
mouse! Certifique-se de ter controle antes de usar o comando. Um botão
para alternar o estado de controle do mouse é eficaz.

MOUSE Página 288
Mouse.end()
Finaliza a emulação do mouse conectado a um computador. Para iniciar o
controle, use Mouse.begin ()
Sintaxe
Mouse.end()
Parâmetros
Nenhum.
Retorna
Nada.
Código de Exemplo
#include <Mouse.h>
void setup() {
pinMode(2, INPUT);
Mouse.begin();
}
void loop() {
//if the button is pressed, send a left mouse click
//then end the Mouse emulation
Mouse.click();
Mouse.end();
}
}

MOUSE Página 289
Mouse.move()
Move o cursor em um computador conectado. O movimento na tela é
sempre relativo à localização atual do cursor. Antes de usar
Mouse.move()você deve chamar Mouse.begin ()
Sintaxe
Mouse.move(xVal, yVal, wheel)
Parâmetros
xVal: quantidade para mover ao longo do eixo x. Tipos de dados permitidos:
signed char.
yVal: quantidade para mover ao longo do eixo y. Tipos de dados permitidos:
signed char.
wheel: quantidade para mover a roda de rolagem. Tipos de dados
permitidos: signed char.
Retorna
Nada.
Código de Exemplo
#include <Mouse.h>
const int xAxis = A1; //analog sensor for X axis
const int yAxis = A2; // analog sensor for Y axis
int range = 12; // output range of X or Y movement
int responseDelay = 2; // response delay of the mouse, in ms
int threshold = range / 4; // resting threshold
int center = range / 2; // resting position value
int minima[] = {1023, 1023}; // actual analogRead minima for {x, y}
int maxima[] = {0, 0}; // actual analogRead maxima for {x, y}
int axis[] = {xAxis, yAxis}; // pin numbers for {x, y}
int mouseReading[2]; // final mouse readings for {x, y}
void setup() {
Mouse.begin();
}
void loop() {
// read and scale the two axes:
int xReading = readAxis(0);
int yReading = readAxis(1);
// move the mouse:
Mouse.move(xReading, yReading, 0);
delay(responseDelay);
}

MOUSE Página 290
Mouse.move() (continuação)
/*
reads an axis (0 or 1 for x or y) and scales the
analog input range to a range from 0 to <range>
*/
int readAxis(int axisNumber) {
int distance = 0; // distance from center of the output range
// read the analog input:
int reading = analogRead(axis[axisNumber]);
// of the current reading exceeds the max or min for this axis,
// reset the max or min:
if (reading < minima[axisNumber]) {
minima[axisNumber] = reading;
}
if (reading > maxima[axisNumber]) {
maxima[axisNumber] = reading;
}
// map the reading from the analog input range to the output range:
reading = map(reading, minima[axisNumber], maxima[axisNumber], 0, range);
// if the output reading is outside from the
// rest position threshold, use it:
if (abs(reading - center) > threshold) {
distance = (reading - center);
}
// the Y axis needs to be inverted in order to
// map the movemment correctly:
if (axisNumber == 1) {
distance = -distance;
}
// return the distance for this axis:
return distance;
}
Quando você usa o Mouse.move()comando, o Arduino assume o controle do
mouse! Certifique-se de ter controle antes de usar o comando. Um botão
para alternar o estado de controle do mouse é eficaz.

MOUSE Página 291
Mouse.press()
Envia um pressionamento de botão para um computador conectado.
Pressionar é equivalente a clicar e segurar continuamente o botão do
mouse. Um pressionamento é cancelado com Mouse.release () .
Mouse.press() o padrão é pressionar o botão esquerdo. Antes de usar
Mouse.press(), você precisa iniciar a comunicação com Mouse.begin () .
Sintaxe
Mouse.press()
Mouse.press(button)
Parâmetros
permitidos: char.
MOUSE_LEFT (default)
MOUSE_RIGHT
MOUSE_MIDDLE
Retorna
Nada.
Código de Exemplo
#include <Mouse.h>
void setup() {
//The switch that will initiate the Mouse press
pinMode(2, INPUT);
//The switch that will terminate the Mouse press
pinMode(3, INPUT);
Mouse.begin();
}
void loop() {
//if the switch attached to pin 2 is closed, press and hold the left mouse button
Mouse.press();
}
//if the switch attached to pin 3 is closed, release the left mouse button
Mouse.release();
}
}
Quando você usa o Mouse.press()comando, o Arduino assume o controle do
mouse!

MOUSE Página 292
Mouse.release()
Envia uma mensagem informando que um botão pressionado
anteriormente (invocado por meio de Mouse.press () ) foi liberado.
Mouse.release()o padrão é o botão esquerdo.
Sintaxe
Mouse.release()
Mouse.release(button)
Parâmetros
permitidos: char.
MOUSE_LEFT (predefinição)
MOUSE_RIGHT
MOUSE_MIDDLE
Retorna
Nada.
Código de Exemplo
#include <Mouse.h>
void setup() {
pinMode(2, INPUT);
pinMode(3, INPUT);
Mouse.begin();
}
void loop() {
//if the switch attached to pin 2 is closed, press and hold the left mouse button
Mouse.press();
}
//if the switch attached to pin 3 is closed, release the left mouse button
Mouse.release();
}
}
Quando você usa o Mouse.release()comando, o Arduino assume o controle
do mouse.

MOUSE Página 293
Mouse.isPressed()
Verifica o status atual de todos os botões do mouse e relata se algum foi
pressionado ou não.
Sintaxe
Mouse.isPressed();
Mouse.isPressed(button);
Parâmetros
Quando não há valor passado, verifica o status do botão esquerdo do
mouse.
button: qual botão do mouse deve ser verificado. Tipos de dados
permitidos: char.
MOUSE_LEFT (default)
MOUSE_RIGHT
MOUSE_MIDDLE
Retorna
Retorna verdadeiro se um botão for pressionado ou não. Tipo de dados:
bool.
Código de Exemplo
#include <Mouse.h>
void setup() {
pinMode(2, INPUT);
pinMode(3, INPUT);
//Start serial communication with the computer
Serial.begin(9600);
Mouse.begin();
}

MOUSE Página 294
Mouse.isPressed() (continuação)
void loop() {
//a variable for checking the button's state
int mouseState = 0;
//if the switch attached to pin 2 is closed, press and hold the left mouse button and
save the state ina variable
Mouse.press();
mouseState = Mouse.isPressed();
}
//if the switch attached to pin 3 is closed, release the left mouse button and save
the state in a variable
Mouse.release();
mouseState = Mouse.isPressed();
}
//print out the current mouse button state
Serial.println(mouseState);
delay(10);
}

GUIA DE REFERÊNCIA DO ARDUINO Página 295
ÍNDICE DETALHADO
QUALQUER TECNOLOGIA SUFICIENTEMENTE AVANÇADA É INDISTINGUÍVEL DA MAGIA!
ARTHUR C. CLARKE
PREFÁCIO - 03
ESTRUTURA - 07
09 setup( ) 30 == (igual a)
10 loop( ) 31 != (diferente de)
11 ; (ponto e vírgula) 32 < (menor que)
12 { } (chaves) 33 <= (menor que ou igual a)
13 if 34 > (maior que)
14 else 35 >= (maior que ou igual a)
15 switch...case 36 ! (NÃO lógico)
16 while 37 && (E lógico)
17 do...while 38 | | (OU lógico)
18 for 39 ++ (incremento)
20 break 40 -- (decremento)
21 continue 41 += (atribuição por adição)
22 return 42 -= (atribuição por subtração)
23 goto 43 *= (atribuição por multiplicação)
24 + (adição) 44 /= (atribuição por divisão)
25 - (subtração) 45 %= (atribuição por resto)
26 * (multiplicação) 46 |= (atribuição por OU)
27 / (divisão)
47 &= (atribuição por E)
28 % (resto)
48 ^= (atribuição por OU EXCLUSIVO)
29 = (atribuição)

CONTINUAÇÃO ...
49 #define 79 vetor
50 #include 81 void
51 / / (comentário) 82 word
52 /* */ (comentário em bloco) 83 String ()
53 & (E) 85 charAt()

54 | (OU) 86 comparteTo()
55 ~ (NÃO) 87 concat()
56 ^ (OU EXCLUSIVO) 88 c_str()
57 << (deslocamento à esquerda) 89 endsWith()
58 >> (deslocamento à direita) 90 equals()
59 & (referência ao endereço) 91 equalsIgnoreCase()
60 * (valor contido no endereço) 92 getBytes()
93 indexOf()
VARIÁVEIS - 61
94 lastIndexOf()
62 bool, boolean
e byte 95 length()
63 char 96 remove()
64 double 97 replace()
65 float 98 reserve()
67 int 99 setCharAt()
69 long 100 startsWith()
70 short 101 substring()
71 size_t 102 toCharArray()
72 string 103 toDouble()
75 unsigned char 104 toFloat()
76 unsigned int 105 toLower Case()
78 unsigned long 106 toUpperCase()

CONTINUAÇÃO ...
107 trim() 140 const
108 toInt() 141 escopo
109 [] 142 static
110 + 144 volatile
111 +=
FUNÇÕES - 146
112 ==
148 digitalRead()
113 >
150 digitalWrite()
114 >=
152 pinMode()
115 <
154 analogRead()
116 <=
157 analogReference()
117 !=
159 analogWrite()
118 PROGMEM
161 delay()
122 sizeof( )
163 delayMicroseconds()
124 HIGH / LOW
165 micros()
126 INPUT / OUTPUT / INPUT_PULLUP
167 millis()
128 LED_BUILTIN
169 random()
129 true / false
171 randomSeed()
130 Constantes de ponto flutuante
172 abs()
131 Constantes inteiras
173 constrain()
134 byte( ) 175 map()
135 char( ) max()

177
136 float( ) min()
178
137 int( ) pow()
179
138 long( ) sq()
180
139 word( ) sqrt()
181

CONTINUAÇÃO ...
182 cos() 210 interrupts()
183 sin() 211 noInterrupts()
184 tan() 212 analogReadResolution()
185 isAlpha() 214 analogWriteResolution()
186 isAlphaNumeric() 217 noTone()
187 isAscii() 218 pulseIn()
220 pulseInLong()
188 isControl()
222 shiftIn()
189 isDigit()
223 shiftOut()
190 isGraph()
226 tone()
191 isHexadecimalDigit()
192 isLowerCase() 227 Serial
193 isPrintable() 256 Stream
270 Keyboard
194 isPunct()
isSpace()
285 Mouse
195
196 isUpperCase() ÍNDICE DETALHADO - 295
197 isWhitespace() BIBLIOGRAFIA- 299
198 bit()
199 bitClear()
200 bitRead()
201 bitSet()
202 bitWrite()
203 highByte()
204 lowByte()
205 attachInterrupt()
209 detachInterrupt()

BIBLIOGRAFIA
EU NÃO TENHO MEDO DE COMPUTADORES. EU TENHO MEDO É DA FALTA DELES!
ISAAC ASIMOV
SITES DE REFERÊNCIA
https://www.arduino.cc/
https://www.arduino.cc/en/Guide/Introduction
https://www.arduino.cc/en/Guide/Introduction#how-do-i-use-
arduino
https://www.arduino.cc/education
https://www.arduino.cc/reference/en/
https://www.arduino.cc/reference/en/#functions
https://www.arduino.cc/reference/en/#variables
https://www.arduino.cc/reference/en/#structure
https://www.arduino.cc/glossary/en/
https://www.arduino.cc/reference/en/libraries/

GUIA DE
REFERÊNCIA DO
ARDUINO
BRINCANDO COM IDEIAS
ACESSE O CANAL E NOSSOS CURSOS:

YOUTUBE.COM/BRINCANDOCOMIDEIAS

CURSO DE ARDUINO
CURSO DE ROBÓTICA
Licenciado sob Creative Commons

Attribution-Share Alike 3.0

Arduino C++

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Arduino C++

Enviado por

Direitos autorais:

Formatos disponíveis

Licenciado para - celso bruno junior - 05634201896 - Protegido por Eduzz.

TUDO EM UM ÚNICO LUGAR!

Licenciado sob Creative Commons

007 ESTRUTURA (ELEMENTOS C++)

299 BIBLIOGRAFIA Comecei a fazer estágio numa empresa

A MINHA PAIXÃO PELA TECNOLOGIA

Desde as minhas primeiras

Philco-Ford era uma indústria de

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

Ele tinha apenas três jogos: futebol,

Na imagem abaixo, repare como o

E foi então meu primeiro

O TK85 foi um dos primeiros

Imagine só: meu carrinho de Eu passava horas digitando

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

Minha única frustração era nunca Nessa época, comecei a fazer

Além disso, treinei muito o Turbo

O exercício que mais tive trabalho,

No ano seguinte comecei a ter

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

Desde cedo percebi que, para Hoje, após alguns anos

Fui muito feliz em minha carreira e

Quando conheci o Arduino , fiquei

Rapidamente, percebi o enorme

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

SKETCH OPERADORES ARITMÉTICOS

ESTRUTURAS DE CONTROLE 29 = (atribuição)

CONTINUA NA PRÓXIMA PÁGINA ...

OPERADORES DE ATRIBUIÇÃO DIRETIVAS DE COMPILAÇÃO

43 *= (atribuição por multiplicação)

44 /= (atribuição por divisão) OPERADORES DE BIT

45 %= (atribuição por resto) 53 & (E)

57 << (deslocamento à esquerda)

58 >> (deslocamento à direita)

59 & (referência ao endereço)

60 * (valor contido no endereço)

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

Algumas vezes, a mensagem de erro pode até mencionar a falta de um

Se um erro de compilação incompreensível ou aparentemente ilógico

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

Código de Exemplo em Funções

Código de Exemplo em Laços de Repetição

Código de Exemplo em Condições

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

ESTRUTURAS DE CONTROLE Página 13

As expressões sendo testadas dentro dos parênteses geralmente requerem

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

ESTRUTURAS DE CONTROLE Página 14

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

ESTRUTURAS DE CONTROLE Página 15

switch ... case

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

ESTRUTURAS DE CONTROLE Página 16

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

ESTRUTURAS DE CONTROLE Página 17

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

ESTRUTURAS DE CONTROLE Página 18

GUIA DE REFERÊNCIA DO ARDUINO Brincando com Ideias ®

ESTRUTURAS DE CONTROLE Página 19

Além disso, os comandos para inicialização, condição e incremento

Por exemplo, usar uma multiplicação no comando de incremento irá gerar

Outro exemplo, aplica um efeito de "fading" crescente e decrescente em