Buscar

Programação Arduino

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 3, do total de 70 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 6, do total de 70 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 9, do total de 70 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Prévia do material em texto

Programação 
Arduino 
Página | 1 
Sumário: 
Estrutura 
• ​void setup ().............................................5 
• ​void loop ()...............................................5 
Estruturas de controle 
• ​if............................................................6 
• ​if...else...................................................7 
• ​for..........................................................8 
• ​switch case.............................................9 
• ​while.....................................................10 
• ​do... while..............................................10 
• ​break.....................................................69 
• ​continue.................................................11 
• ​return.....................................................11 
• ​goto.......................................................12 
Elementos de sintaxe 
• ​; (ponto e vírgula)...................................13 
• ​{} (chaves).............................................13 
• ​// (linha de comentário)...........................15 
• ​/* */ (bloco de comentário)......................15 
• ​#define..................................................16 
• ​#include.................................................17 
Operadores aritméticos 
• ​= (igualdade).........................................18 
• ​+ (adição)..............................................18 
• ​- (subtração)..........................................18 
• ​* (multiplicação).....................................18 
• ​/ (divisão)..............................................18 
• ​% (resto da divisão)...............................19 
Operadores de comparação 
• ​== (igual a)...........................................20 
• ​!= (diferente de).....................................20 
• ​< (menor que).......................................20 
• ​> (maior que)........................................20 
• ​<= (menor ou igual a)............................20 
• ​>= (maior ou igual a).............................20 
Operadores booleanos 
• ​&& (e)....................................................21 
• ​|| (ou)....................................................21 
• ​! (não)....................................................21 
Operadores de bits 
• ​& (operador de bits AND)..............................22 
• ​| (operador de bits OR).................................22 
• ​^ (operador de bits XOR)..............................22 
• ​~ (operador de bits NOT)..............................24 
• ​<< (desvio à esquerda).................................25 
>> (desvio à direita).....................................25 
&=(de bits composto AND)............................26 
=(de bits composto OR)...............................26 
Operadores compostos 
++ (incrementar).........................................28 
- (decrementar)..........................................28 
+= (adição composta)..................................28 
= (subtração composta)...............................28 
*= (multiplicação composta)..........................28 
= (divisão composta)...................................28 
Variáveis 
Variáveis são expressões que você pode usar em 
programas para armazenar valores como a leitura 
de um sensor em um pino analógico. 
Constantes ​Constantes são valores 
particulares com significados específicos. 
• ​HIGH | LOW...........................................29 
• ​INPUT | OUTPUT....................................29 
• ​true | false.............................................29 
• ​Constantes inteiras.................................31 
Tipos de dados ​Variáveis podem ser 
de vários tipos: 
• ​boolean..................................................32 
• ​char.......................................................32 
• ​byte.......................................................33 
• ​int..........................................................33 
• ​unsigned int............................................34 
• ​long.......................................................34 
• ​unsigned long.........................................35 
• ​float........................................................36 
• ​double....................................................37 
• ​string......................................................37 
• ​array.......................................................39 
• ​void........................................................40 
Conversão 
• ​char()....................................................41 
• ​byte()....................................................41 
• ​int().......................................................41 
• ​long()....................................................41 
• ​float()....................................................42 
Referência 
• ​Tabela ASCII..........................................42 
Página | 3 
Funções 
Entrada e saída digital 
• ​pinMode (pin, mode).....................................43 
• ​digitalWrite (pin, value).................................44 
• ​int digitalRead (pin).......................................45 
Entrada e saída analógica 
• ​int analogRead (pin)......................................46 
• ​analogWrite (pin, value) – ​PWM....................47 
Entrada e saída avançada 
• ​shiftOut (dataPin, clockPin, bitOrder, value)....48 
• ​unsigned long pulseIn (pin, value)...................49 
Tempo 
• ​unsigned long millis()....................................50 
• ​unsigned long micros()......................................50 
• ​delay(ms)...........................................................51 
• ​delayMicroseconds(μs)......................................52 
Matemática 
• ​min (x, y).....................................................54 
• ​max (x, y)..........................................................55 
• ​abs (x).........................................................56 
• ​constrain (x, a, b).........................................56 
• ​map (​value, fromLow, fromHigh, toLow, toHigh​)............57 
• ​pow (base, exponent)...................................58 
• ​sq (x).................................................................58 
• ​sqrt (x).........................................................58 
Trigonometria 
• ​sin (rad).......................................................59 
• ​cos (rad)......................................................59 
• ​tan (rad)......................................................59 
Números aleatórios 
• ​randomSeed (seed)...........................................60 
• ​long random (max).......................................61 
• ​long random (min, max)...................................61 
Comunicação serial ​Usado para comunicação 
entre a placa Arduino e um computador ou outros 
dispositivos. Esta comunicação ocorre através dos 
conectores serial ou USB da placa Arduino e nos 
pinos digitais 0 (RX) e 1 (TX). Assim, se você utilizar 
estas funções não poderá utilizar os pinos 0 e 1 
para entrada e saída digital. 
• ​Serial.begin (s
nt Serial.available ()..........................................63 
nt Serial.read ()................................................64 
Serial.flush ().....................................................65 
Serial.println (data).......................................68 
• ​Serial.print (data)..........................................65 
Página | 4 
setup() 
A função setup() é chamada quando um programa pomeça a rodar. Use esta função para inicializar as sua 
variáveis, os modos dos pinos, declarar o uso de livrarias, etc. Esta função será executada apenas uma vez 
após a placa Arduino ser ligada ou ressetada. 
Exemplo ​int 
buttonPin = 3; 
void setup() { 
Serial.begin(9600); 
pinMode(buttonPin, INPUT); } 
void loop() ​{ 
// ... } ​loop() 
Após criaruma fução setup() que declara os valores iniciais, a função loop() faz exatamente o que seu nome 
sugere, entra em looping (executa sempre o mesmo bloco de código), permitindo ao seu programa fazer 
mudanças e responder. Use esta função para controlar ativamente a placa Arduino. ​Exemplo ​int buttonPin = 
3; 
// setup ​inicializa o serial ​e o pino do button (botão) void 
setup() { 
beginSerial(9600); pinMode(buttonPin, 
INPUT); } ​// loop checa o botão a cada vez, 
// e envia o serial se ele for pressionado 
void loop() { 
if (digitalRead(buttonPin) == HIGH) 
serialWrite('H'); else 
serialWrite('L'); 
delay(1000); } 
Página | 5 
if (condicional) e ==, !=, <, > (operadores de 
comparação) 
if​, que é usado juntamente com um operador de comparação, verifica quando uma condição é satisfeita, 
como por exemplo um input acima de um determinado valor. O formato para uma verificação if é: 
if (algumaVariavel > 50) { 
// faça alguma coisa } ​O programa checa se algumaVariavel (colocar acentos em nomes de variáveis não é 
uma boa idéia) é ​maior que 50. Se for, o programa realiza uma ação específica. Colocado de outra maneira 
se a sentença que está dentro dos parêntesis é verdadeira o código que está dentro das chaves roda; caso 
contrário o programa salta este bloco de código. 
As chaves podem ser omitidas após uma sentença ​if ​se só houver uma única linha de código (definida pelo 
ponto e vírgula) que será executado de modo condicional: 
if (x > 120) digitalWrite(LEDpin, HIGH); 
if (x > 120) digitalWrite(LEDpin, 
HIGH); 
if (x > 120) {digitalWrite(LEDpin, HIGH);} // todos são corretos 
A sentença que está sendo verificada necessita o uso de pelo menos um dos operadores: 
Operadores de comparação: 
x == y (x é igual a y) x != y (x é não 
igual a y) x < y (x é menor que y) x > 
y (x é maior que y) x <= y (x é menor 
ou igual a y) x >= y (x é maior ou 
igual a y) 
Cuidado: ​Tenha precaução com o uso acidental de apenas um sinal de igual (e.g. if (x = 10) ). O sinal de 
igual simples é um operador de designação e coloca o valor 10 na variável x. Ao contrário o sinal de igal 
duplo (e.g. if (x == 10) ), que é um operador de comparação, verifica se x é igual a 10 ou não. A última 
senteça só é verdadeira se x for igual a 10, mas a anterior sempre será veraddeira. Isto ocorre por que a 
linguagem C (na qual o Arduino é baseado) atribui um valor à sentença (x=10) do seguinte modo: 10 é 
colocado na variável x (lembre o sinal de igual simples é um operador de designação), então x agora contém 
10. Então o condicional 'if' atribui um valor a 10, que será sempre verdadeiro (TRUE), desede que números 
diferentes de zero são sempre equiparados à verdadeiro. Consequentemente, if (x = 10) será sempre 
verdadeiro, que não é o que pretendemos quando usamos um 'if'. Adcionalmente o valor 10 será guardado na 
variável x que também não é o que pretendemos. ​if ​também pode ser usado como parte de uma estrutura de 
controle ramificada através da construção if..else. 
Página | 6 
if / else 
if/else ​permite um controle maior sobre o fluxo de código do que a sentença ​if ​básica, tornando possível que 
múltiplos testes sejam agrupados. Por exemplo, uma entrada analógica poderia ser verificada e uma ação 
específica seria tomada se o valor de input fosse menor que 500 e outra ação seria tomada se o input fosse 
500 ou mais. O código seria assim: 
if (pinFiveInput < 500) { 
// ação A } ​else ​{ 
// ação B } ​else ​pode preceder outro teste ​if ​, e assim mltiplos testes, mutuamente exclusivos, podem ser 
realizados ​ao mesmo tempo. 
Cada teste precede o próximo até que um teste com vavlor verdadeiro é encontrado. Quando um teste com 
valor verdadeiro é encontrado o seu bloco de código associado é execuatod e então o programa salta para a 
sequencia após todo o bloco if/else. Se a nenhum teste é atribuido o valor verdadeiro o bloco que estiver no 
else sozinho é executado, se houver algum. 
Note que um bloco ​else if ​pode ser usado com ou sem um bloco ​else ​final. Um número ilimitado destes 
ramos ​else if ​é permitido. 
if (pinFiveInput < 500) { 
// faça a coisa A } ​else if (pinFiveInput 
>= 1000) ​{ 
// faça a coisa B } ​else ​{ 
// faça a coisa C } ​Outro modo de fazer testes de ramificações mutuamente exclusivas é através da 
sentença switch case. 
Página | 7 
sentença for 
Descrição 
A sentença ​for ​é utilizada para repetir um bloco de código delimitado por chaves. Um contador com 
incremento normalmente é usado para controlar e finalizar o loop. A sentença ​for ​é util para quanquer 
operação repetitiva, e é frequentemente usada com arrays para operar em conjuntos de dados ou de 
pinos. 
Há três partes no cabeçalho do ​for​: 
for ​(​inicialização​; ​condição​; ​incremento​) { //sentença(s); } ​A ​inicialização ​ocorre primeiro e apenas uma 
vez. Cada vez que o circuíto é executado a ​condição ​é ​verificada; se for verdadeira o bloco de código e o 
incremento ​são executados, e então a ​condição ​é testada novamente. Quando a condição se torna falsa 
o circuíto termina. 
Exemplo // Aumentar o brilho de um LED usando um pino PWM int PWMpin = 10; 
// um LED em série com um resisotr de 1kΩ no pino 10 
void setup() { 
// nenhum setup é necessário } ​void 
loop() ​{ 
for (int i=0; i <= 255; i++){ 
analogWrite(PWMpin, i); delay(10); 
} } ​Dica de programação 
Na linguagem C o circuito ​for ​é muito mais flexível que os circuitos for encontrados a algumas outras 
linguagens de programação, incluindo BASIC. Qualquer dos elementos do cabeçalho pode ser omitido, 
embora os ";" sejam necessários. Qualquer destes elementos também podem ser substituidos por 
qualquer sentença válida em C com varáveis não correlatas. Estes tipos não usuais de sentenças ​for ​as 
vezes podem ser a solucão para alguns problemas raros de programação. 
Página | 8 
sentença switch / case 
Do mesmo modo que as sentenças ​if​, as ​switch / case ​controlam o fluxo dos programas. ​Switch/case 
permite ao programador construir uma lista de "casos" dentro de um bloco delimitado por chaves. O 
programa checa cada caso com a vaiável de teste e executa o código se encontrar um valor idêntico. 
Switch / case ​é um pouco mais flexível que uma estrutura ​if/else ​de modo que o programador pode 
determinar se a estrutura ​switch ​deve continuar checando por valores idênticos na lista dos "caosos" após 
encontrar um valor idêntico. Se a sentença ​break ​não é encontrada após a execução do bloco de código 
selecionado por um dos "casos", então o programa vai continuar a checar por mais valores idênticos entre 
os "casos" restantes. Se uma sentença ​break ​é encontrada o código sai da estrutura do mesmo modo que 
em uma construção ​if/else if​. 
Parâmetros 
• ​var - a variável para a qual você busca valores idênticos 
• ​default - se nenhuma outra condição for satisfeita o código que está no default é executado 
• ​break - sem o break a sentença ​switch ​vai continuar checando as outras sentenças ​case ​para quanquer outro 
possível valor idêntico. Se algum for encontrado será executado do mesmo modo, o que pode não ser o que 
você deseja. Break indica ao switch para parar de procurar por outros valores idênticos e sai da sentença switch. 
Exemplo 
switch (var) { 
case 1: 
//faça alguma coisa quando var == 1 break; // 
break is optional case 2: 
//faça alguma coisa quando == 2 break; 
default: 
// se nenhum valor for idêntico, faça o default // default 
é opcional } 
Página | 9 
while 
Descrição 
while ​fará com que o bloco de código entre chaves se repita continua e indefinidamente até que a expressão 
ente parentesis() se torne falsa. Algo tem que provocar uma mudança no valor da variável que está sendo 
verificada ou o código vai sempre ficar dando voltas dentro do ​while​. Isto poderia ser o incremento de uma 
variável ou uma condição externa como o teste de um sensor. 
Syntax 
while(expressão){ 
// código } 
Parâmetrosexpressão - uma sentença boolena em C que possa ser verificada como verdadeira ou falsa 
Exemplo var = 0; 
while(var < 200){ 
// algum código que se repete 200 vezes var++; } 
do - while 
O ​do ​funciona da mesma maneira que o ​while ​loop, com a exceção de que a condição é testada no final do 
bloco de código. Enquanto no ​while​, se a condição for falsa, o bloco de código não será executado, no ​do 
ele sempre será executado pelo menos uma vez. 
do ​{ 
// bloco de código } while 
(condição); 
Exemplo do 
{ 
delay(50); // espera para que os sensores se estabilizem x = 
readSensors(); // verifica o sensor 
} while (x < 100); 
Página | 10 
continue 
continue ​é usado para saltar porções de código em blocos ​do​, ​for​, ou ​while​. Ele força com que o código 
avance até o teste da condição saltando todo o demais. 
Exemplo for (x = 0; x < 255; x 
++) { 
if (x > 40 && x < 120){ // criar saltos de execução 
continue; } 
digitalWrite(PWMpin, x); 
delay(50); } ​return 
Finaliza uma função e retorna um valor, se necessário. 
Sintaxe: 
return; 
return valor; // ambas formas são válidas 
Parâmetros 
valor: alguma variável ou constante 
Exemplos: 
Uma função para comparar o valor de um sensor com um limite 
int checkSensor(){ 
if (analogRead(0) > 400) { 
return 1; else{ 
return 0; } } ​A palavra-chave ​return ​é útil para testar uma seção de código sem ter que transformar em 
"comentário" ​um grande e possivelmente defeituoso bloco de código. 
void loop(){ 
// aqui, uma brilhante idéia de programação 
return; 
// restante do bloco de código não funcional // este 
código nunca será executado } 
Página | 11 
goto 
Transfere o fluxo do programa para um outro ponto etiquetado 
Sintaxe 
label: 
goto etiqueta; // envia o fluxo do programa para etiqueta 
Dica 
O uso do ​goto ​é desencorajado em programação C e inclusive alguns autores afirmam que o ​goto ​nunca é 
realmente necessário, mas usado com cautela pode simplificar alguns programas. A razão pela qual muitos 
programadores desaprovam seu uso é que com o uso indiscriminado é fácil de se criar um programa com um 
fluxo indefinido e muito difícil de ser depurado. 
No entanto, há casos em que o ​goto ​pode ser útil e simplificar o código. Uma destas situações é provocar 
uma saída de um grupo de loops aglutinados ou de blocos lógicos ​if ​com uma determinada condição. 
Exemplo for(byte r = 0; r < 255; 
r++){ 
for(byte g = 255; g > -1; g--){ 
for(byte b = 0; b < 255; b++){ 
if (analogRead(0) > 250){ goto bailout;} // more 
statements ... } } } ​bailout: 
Página | 12 
; ponto e vírgula 
Usada para terminar uma sentença. 
Exemplo int a 
= 13; 
Dica 
Esquecer de finalizar uma linha com ponto e vírgula causa um erro de compilação. O texto sobre o erro pode 
ser óbvio e se referir a um ponto e vírgula faltando, ou não. Se ocorrer um erro de compilação impenetrável 
ou aparenetemente ilógico uma das primeiras coisas a checar é um ponto e vírgula faltando na vizinhança, 
precedendo a linha indicada pelo compilador. 
{} Chaves 
Chaves são uma parte essencial da linguagem de programação C. Elas são usadas em muitas construções 
diferentes, descritas abaixo, e isto pode algumas vezes ser confuso para iniciantes. 
Uma chave abrindo "{" deve sempre ser seguida por uma fechando "}". Frequentemente nos referimos a 
esta condição como equilibrio entre as chaves. A IDE (​integrated development environment ​ou ambiente 
de desenvolvimento integrado) do Arduino inclui uma característica prática para checar o equilibrio das 
chaves. Apenas com o selecionar de uma chave ou clicar no ponto imediatamente posterior faz com que 
sua companheira lógica seja destacada. 
No presente momento esta característica é um pouco defeituosa e a IDE frequentemente encontrará 
(incorretamente) uma chave em um bloco de texto que tenha sido comentado. 
Programadores principiantes e programadores vindos das linguagens C e do BASIC frequentemente 
consideram o uso das chaves confuso ou desalentador. Afinal as mesmas chaves substituem a sentença 
RETURN em uma subrotina(função), a sentença ENDIF em uma condicional e a sentença NEXT em um 
FOR. 
Por que o uso das chaves é tão variado, é uma boa prática de programação digitar o fecha-chaves "}" logo 
após digitar o abre-chaves "{" quando estiver fazendo uma construção que as requer. Inserte então alguns 
"ENTER" entre as chaves e comece a digitar o código. Agindo assim suas chaves nunca ficarão 
desequilibradas. 
Chaves desequilibradas causam erros de comilação bastante enigmáticos e que podem ser difíceis de 
rastrear em um programa longo. Por causa de seus usos variados, as chaves são também incrivelmente 
importantes para a sintaxe de um programa e mover uma chave uma ou duas linhas pode alterar 
completamente o seu significado. 
Página | 13 
Os principais usos das chaves 
Funções 
void myfunction(datatype argument){ 
sentença(s) } 
Loops 
while (expressão booleana) { 
sentença(s) } 
do { 
sentença(s) } while (expressão 
booleana); 
for (inicialização; condição de término; expressão de incremento) { 
sentença(s) } ​Sentenças 
condicionais 
if (expressão booleana) { 
sentença(s) } 
else if (expressão booleana) { 
sentença(s) } else { 
sentença(s) } 
Página | 14 
Comentários 
Comentários são linhas no programa que são usados para informar a você mesmo ou outras pessoas sobre 
o modo como o progama trabalha. Elas são ignoradas pelo compilador e não são exportadas para o 
processador e portanto não ocupam a memória do chip ATmega. 
O único propósito dos comentários são ajudar a entender (ou relembrar) como o programa funciona. Há 
dois modos diferentes de marcar uma linha como um comentário. 
Exemplo 
x = 5; // Esta é uma linha simples de comentário. Qualquer coisa depois das barras é um comentário 
// até o fim da linha 
/* este é um bloco de comentário - usado para "comentar" blocos inteiros de código 
if (gwb == 0){ // não há problema em uma linha simples dentro de um bloco de comentário x = 3; /* mas 
outro bloco de comentário é inválido */ } ​// não esqueça de fechar o bloco de comentário, eles têm que 
ser equilibrados ​*/ ​Dica 
Quando estiver experimentando com o código "comentar" partes do programa é um modo conveniente de 
remover linhas que podem conter problemas. Este procedimento mantém as linhas no código mas as 
trasnforma em comentários de modo que o compilador as ignora. Isto pode ser especialmente útil quando 
tentamos localizar um problema, ou quando um programa apresenta erros de compilação cujas explicações 
são obscuras ou inúteis. 
Página | 15 
#define 
#define é um componente muito útil da linguagem C que permite ao programador dar um nome a uma 
constatnte antes que o programa seja compilado. Constantes definidas no Arduino não ocupam espaço em 
memória no chip. O compilador substitui referêancias a estas constantes pelo valor definido no momento da 
compilação. 
Isto pode causar alguns efeitos indesejáveis se, por exemplo, um nome de constante que tenha sido 
defindo por um #define é incluido em alguma outra constante ou nome de variável. Neste caso o texto 
deve ser substituido pelo valor (ou texto) do #define. 
Em general, a palavra chave ​const ​é preferível para definir constatntes e deve ser usada ao invés de 
#deine. ​A sintaxe do #define na linguagem Arduino é a mesma da linguagem C: 
Sintaxe ​#define nomeDeConstante 
valor 
Verifique que o # é necessário. 
Exemplo #define ledPin 3 // O compilador vai substituir quanquer menção a ledPin pelo valor 
3 no momento da compilação. Dica 
Não há ponto e vírgula após a declaração #define. Se você incluir um o compilador vai lançar erros críticos no 
final do programa. 
#define ledPin 3; // isto é um erro 
Do mesmo modo o compilador gerará erros se após o #define houver um =. 
#define ledPin = 3 // isto também é um erro 
Página | 16 
#include 
#include ​é usado para incluiroutras bibliotecas no seu programa. Isto permite ao programador acessar um 
grande número de bibliotecas padrão da linguagem C (grupos de funções pré-definidas), e também à 
bibliotecas desenvolvidas especificamente para o Arduino. 
A página principal de referência para as bibliotecas C AVR (AVR é a referência aos chips Atmel nos quais o 
Arduino está baseado) está aqui. 
Verifique que ​#include​, de modo similar ao ​#define​, não leva ponto e vírgula no final. 
Exemplo 
Este exemplo inclui uma biblioteca que é utilizada para armazenar dados na memória flash ao invés de na 
ram. Isto economiza espaço na ram para as necessidades de memória dinâmica e torna o uso de grandes 
tabelas mais prático. 
#include <avr/pgmspace.h> 
prog_uint16_t myConstants[] PROGMEM = {0, 21140, 702 , 9128, 0, 25764, 8456, 
0,0,0,0,0,0,0,0,29810,8968,29762,29762,4500}; 
= operador de designação (sinal de igual simples) 
Armazena o valor do que está à direita do sinal de igual na variável que está à esquerda. O sinal de igual 
simples na linguagem de programação C é chamdo operador de designação. Ele tem um significado 
diferente daquele utilizado em álgebra, no qual indica uma equação ou iguladade. O operador de 
designação indica ao microcontrolador para calcular o valor da expressão à direita do sinal de igual e 
armazenar este valor na variável que está à esquerda. ​Exemplo 
int sensVal; // declera uma variavel do tipo inteiro com o nome de sensVal senVal = analogRead(0); // 
armazena o valor da voltagem (digitalizado) no pino analógico 0 em sensVal Dicas de programação ​A 
variável à esquerda necessita ser capaz de reter o valor que se quer armazenar. Se ela não for grande o 
suficiente o valor armazenado pode ser incorreto. Não confunda o operador de designação [ = ] (sinal de 
igual simples) com o operador de comparação [ == ] (sinal de igual duplo), que calcula quando duas 
expressões são iguais ou não. 
Página | 17 
Adição, subtração, multiplicação e divisão 
Descrição ​Estes operadores retornam a soma, diferença, profuto, ou quciente(respectivamente) de dois 
operandos. A operação é feita usando o tipo de dado dos operadores, assim, por exemplo 9/4 resulta em 2, 
desde que 9 e 4 são inteiros. Isto também significa que uma operação pode extrapolar se o resultado for 
maior do que o que pode ser armazenado no tipo de dado. (e.g. adicionado 1 a um int com o valor de 
32.767 resulta gives -32.768). Se os operandos forem de tipos de dados diferentes o tipo maior é usado no 
cálculo. Se um dos operandos for do tipo float ou do tipo double, então a matemática de ponto flutuante será 
usada para o cálculo. ​Exemplos y = y + 3; x = x - 7; i = j * 6; r = r / 5; Sintaxe result = value1 + value2; 
result = value1 - value2; result = value1 * value2; result = value1 / value2; Parâmetros: ​value1: 
qualquer variável ou constante value2: qualquer variável ou constante ​Dicas de programação 
• ​Saiba que constantes inteiras são consideradas int, portanto alguns cáculos com constantes podem 
extrapolar (e.g. 60 * 1000 resultará em um número negativo). 
• ​Escolha tamanhos de variáveis que sejam grandes o suficiente para reter os maiores resultados possíveis dos 
cálculos. 
• ​Conheça o ponto em que sua variável pode "dar a volta" e também o que ocorre no sentido contrárioe.g. (0 - 1) 
ou (0 - 32768). 
• ​Para matemática que necessita de frações use variáveis do tipo float, mas tenha em conta seus pontos 
negativos: tamanho maior e menor velocidade de computação. 
• ​Use o operador de modelagem para converter diretamente um tipo de variável em outro e.g. 
(int)meuFloat. 
Página | 18 
% (resto da divisão) 
Descrição ​Calcula o resto da divisão quando um inteiro é dividido por outro. É útil para manter uma variável 
dentro de um patamer específico (e.g. o tamanho de um array). ​Sintaxe ​resultado = dividendo % divisor 
Parâmetros ​dividendo: o número que será dividido divisor: o número a dividir por ​Retorna ​o restante 
Exemplo x = 7 % 5; // x agora comtém 2 x = 9 % 5; // x agora comtém 4 x = 5 % 5; // x agora comtém 0 
x = 4 % 5; // x agora comtém 4 Código de exemplo /* atualizar os valores de um array um de cada vez 
em um bloco */ 
int values[10]; int i 
= 0; 
void setup() {} 
void loop() { 
values[i] = analogRead(0); i = (i + 1) % 10; // operador de resto de divisão 
atualiza a variável } ​Dica ​O operador de resto da divisão não funciona com 
variáveis tipo float. 
Página | 19 
if (condicional) e ==, !=, <, > (operadores de 
comparação) 
if​, que é usado juntamente com um operador de comparação, verifica quando uma condição é satisfeita, 
como por exemplo um input acima de um determinado valor. O formato para uma verificação if é: ​if 
(algumaVariavel > 50) { 
// faça alguma coisa } ​O programa checa se algumaVariavel (colocar acentos em nomes de variáveis não é 
uma boa idéia) é ​maior que 50. Se for, o programa realiza uma ação específica. Colocado de outra maneira 
se a sentença que está dentro dos parêntesis é verdadeira o código que está dentro das chaves roda; caso 
contrário o programa salta este bloco de código. As chaves podem ser omitidas após uma sentença ​if ​se só 
houver uma única linha de código (definida pelo ponto e vírgula) que será executado de modo condicional: ​if 
(x > 120) digitalWrite(LEDpin, HIGH); 
if (x > 120) digitalWrite(LEDpin, 
HIGH); 
if (x > 120) {digitalWrite(LEDpin, HIGH);} // todos são corretos ​A sentença que está 
sendo verificada necessita o uso de pelo menos um dos operadores: ​Operadores de 
comparação: 
x == y (x é igual a y) x != y (x é não igual a y) x < y (x é menor que y) x > y (x é maior que y) x <= y (x é 
menor ou igual a y) x >= y (x é maior ou igual a y) Cuidado: ​Tenha precaução com o uso acidental de 
apenas um sinal de igual (e.g. if (x = 10) ). O sinal de igual simples é um operador de designação e coloca o 
valor 10 na variável x. Ao contrário o sinal de igal duplo (e.g. if (x == 10) ), que é um operador de comparação, 
verifica se x é igual a 10 ou não. A última senteça só é verdadeira se x for igual a 10, mas a anterior sempre 
será veraddeira. Isto ocorre por que a linguagem C (na qual o Arduino é baseado) atribui um valor à sentença 
(x=10) do seguinte modo: 10 é colocado na variável x (lembre o sinal de igual simples é um operador de 
designação), então x agora contém 10. Então o condicional 'if' atribui um valor a 10, que será sempre 
verdadeiro (TRUE), desede que números diferentes de zero são sempre equiparados à verdadeiro. 
Consequentemente, if (x = 10) será sempre verdadeiro, que não é o que pretendemos quando usamos um 'if'. 
Adcionalmente o valor 10 será guardado na variável x que também não é o que pretendemos. ​if ​também 
pode ser usado como parte de uma estrutura de controle ramificada através da construção if..else 
Página | 20 
Operadores Booleanos 
Estes operadores podem ser usados dentro da condição em uma sentença if. 
&& ("E" lógico) ​Verdadeiro apenas se os dois operandos forem verdadeiros, ou seja a primeira condição 
"e" a segunda forem verdadeiras, e.g. ​if (digitalRead(2) == 1 && digitalRead(3) == 1) { // ler dois 
interruptores 
// ... } ​é verdadeiro apenas se os dois interruptores estiverem fechados. 
|| ("OU" lógico) ​Verdadeiro se algum dos operandos for verdadeiro, ou seja se a primeira "ou" a 
segunda condição for verdadeira e.g. ​if (x > 0 || y > 0) { 
// ... } ​é verdadeiro apenas se x ou y forem maiores que 0. 
! (negação) ​Verdadeiro apenas se o operando for falso e.g. ​if (!x) { // ... } ​é verdadeiro apenas se x for 
falso (i.e. se x for igual a 0). ​Cuidado ​Certifique-se de não confundir o operador booleano "E" representado 
por "&&" e o operador lógico de bits "E" representado apenas por "&". Eles são animais completamente 
diferentes. Do mesmo modo não confunda o booleano "OU" representado por "||" e o operador lógico de bits 
"|". O operador lógico de bits "NÃO" representado por um "~" não se parece com o operadorbooleano "!", 
mas mesmo assim tenha certeza de estar usando o que você deseja. ​Exemplos if (a >= 10 && a <= 20){} // 
verdadeiro se a estiver entre 10 e 20 
Página | 21 
Operadores de bits AND (&), OR (|), XOR (^) 
Operadores de bits ​Os operadores de bits realizam cálculos ao nível de bits das variáveis. Eles ajudama 
resolver uma grande quantidade de problemas de programação. Muito do material abaixo é de um excelente 
tutorial sobre este tema que pode ser encontrado aqui. 
Operador de bits AND (&) ​O operador de bits AND (e) em C++ é um simples & usado entre duas outras 
expressões inteiras. Ele realiza uma operação entre cada bit de cada uma destas expresões de acordo com a 
seguinte regra: se os dois bits de entrada forem 1 o resultado da operação também é 1, caso contrário é 0. 
Outro modo de expressar esta regra é: 
0 0 1 1 operando1 0 1 0 1 operando2 ---------- 0 0 0 1 (operando1 & operando2) - resultado de retorno ​Em 
Arduino o tipo int (inteiro) é um valor de 16 bits, portanto usando & entre duas expressões int faz com que 
ocorram 16 operações AND simultâneas. Em um fragmento de código: 
int a = 92; // em binario: 0000000001011100 int b = 101; // em binario: 0000000001100101 int c = a & 
b; // resultado: 0000000001000100, ou 68 em decimal. ​Cada um dos 16 bits em a AND b são 
processados usando este operador, e todos os 16 bits resultantes são armazenados em c resultado o 
valor 0000000001000100, que é 68 na notação decimal. Um dos usos mais comuns do operador de bits 
AND é selecionar alguns bits de um valor inteiro, freqüentemente chamado de máscara. Veja o exemplo 
abaixo para um exemplo. 
Operador de bits OR (|) ​O operador de bits OR (ou) em C++ é o símbolo de barra vertical, |. Como o 
operador & ele realiza cálculos com cada bit de duas expressões seguindo a seguinte regra: o resultado 
da opração é 1 se um dos bits de entrada for 1, caso contrário é 0. Em outras palavras: 
0 0 1 1 operando1 0 1 0 1 operando2 ---------- 0 1 1 1 (operando1 | 
operando2) - resultado de retorno ​Em um fragmento de código: 
int a = 92; // in binario: 0000000001011100 int b = 101; // in binario: 0000000001100101 int c = a | b; // 
resultado: 0000000001111101, ou 125 em decimal. Programa de Exemplo ​Um uso comum para os 
operadores de bits AND e OR é o que os programadores chamam Ler-Modificar- Escrever em uma porta. 
Em microcontroladores uma porta é um número de 8 bits que representa algo sobre a condição dos pinos. 
Escrevendo em um controle de porta todos os pinos de uma vez. PORTD é uma constante pré-construída 
que se refere aos estados de saída dos pinos digitais 0,1,2,3,4,5,6,7. Se há um 1 em algum dos bits, então 
este pino está em HIGH. (os pinos ainda precisam ser defindos como pinos de saída pelo comando 
pinMode()). Deste modo se escrevemos PORTD = B00110001; o que fazemos é colocar os pinos 2,3 e 7 
em HIGH. Um efeito colateral é que mudamos o estado dos pinos 0 e 1 que são usados pelo Arduino na 
comunicação serial, ou seja, interferimos nesta comunicação. 
Página | 22 
Nosso algoritmo para este programa deve: 
• ​Ler o PORTD e limpar somente os bits que queremos controlar (com o operador AND). 
• ​Combinar o valor modificado de PORTD com o novo valor dos pinos que queremos controlar (com o 
operador OR). ​int i; // variável do contador int j; 
void setup(){ DDRD = DDRD | B11111100; // marca a direcao dos bits para os pinos 2 a 7 deixando o 0 
e o 1 intocados (xx | 00 == xx) // o mesmo que pinMode(pin, OUTPUT) para os pinos 2 a 7 
Serial.begin(9600); } ​void loop(){ ​for (i=0; i<64; i++){ 
PORTD = PORTD & B00000011; // limpa os bits de 2 - 7, deixa os pinos 0 e 1 intocados (xx & 11 == xx) j 
= (i << 2); // desvia os bits da variavel 2 bits para a esquerda para evitar os pino 0 e 1 PORTD = PORTD 
| j; // combina a informação da porta com a nova informação para os pinos dos LEDs 
Serial.println(PORTD, BIN); // debug para verificar a máscara delay(100); 
} } ​Operador de bits XOR (^) ​Há um operador um pouco raro em C++ chamado EXCLUSIVE OR (ou 
exclusivo) também conhecido por XOR (em inglês se pronuncia "equis-or"). Este operador é escrito com o 
símbolo do acento circunflexo ^. O resultado desta operação é 1 se os dois bits de entrada forem diferentes, 
caso contrário retorna 0: 
0 0 1 1 operando1 0 1 0 1 operando2 ---------- 0 1 1 0 (operando1 ^ 
operando2) - resultado de retorno ​Um simpples código de exemplo: 
int x = 12; // binario: 1100 int y = 10; // binario: 1010 int z = x ^ y; // binario: 0110, or decimal 6 ​O 
operador XOR é freqüentemente utilizado para inverter alguns dos bits de uma expressão inteira. Na 
máscara deste operador se há um 1 o bit correspondente é invertido, se há um zero o bit é mantido como 
está. Abaixo há um programa para piscar o pino digital 5. ​// Piscar_Pino_5 // demonstração para o 
Exclusive OR void setup(){ DDRD = DDRD | B00100000; // marca o pino digital 5 como saida. 
Serial.begin(9600); } 
Página | 23 
void loop(){ PORTD = PORTD ^ B00100000; // inverte o bit 5 (digital pino 5), mantem os 
demais intocados. delay(100); } ​Operador de bits NOT (~) 
O operador de bits NOT (não) em C++ é o acento til do português ~. Diferente dos operadores & e | este 
operador é aplicado sobre apenas 1 operando e retorna o valor inverso de cada bit. Por exemplo: 
0 1 operando1 ---------- 
1 0 ~ operando1 int a = 103; // binario: 0000000001100111 int b = ~a; // binario: 1111111110011000 = 
-104 ​Talvez você se surpreenda ao ver um número negativo como resultado desta operação. Isto ocorre por 
que o bit mais elevado em uma variável int é chamdo de bi de sinal. Se este bit é 1 o número é negativo. 
Este modo de encodar positivos e negativos é chamado de complemento para dois. Mais informações na 
Wikipedia. De modo complementar, é interessante notar que para qualquer inteiro x, ~x é o mesmo que -x-1. 
As vezes, o bit de sinal em uma expressão inteira pode causar algumas surpresas indesejadas. 
Página | 24 
desvio de bits para a esquerda (<<) e para a direita 
(>>) 
Há dois operadores de desvio de bits em C++: o de desvio para a esquerda << e o para a direita >>. 
Estes operadores fazem com que os bits no operando da esquerda sejam desviados o número 
especificado de bits no operando da direita. ​Sintaxe ​variavel << numero_de_bits variavel >> 
numero_de_bits ​Parâmetros ​variavel - (byte, int, long) numero_de_bits inteiro <= 32 ​Exemplo: 
int a = 5; // binario: 0000000000000101 int b = a << 3; // binario: 0000000000101000, ou 40 em decimal 
int c = b >> 3; // binario: 0000000000000101, ou de volta ao 5 como no inicio ​Quando você desvia para a 
esquerda um valor x um y número de bits (x<<Y) os bits mais a esquerda em x são perdidos: 
int a = 5; // binario: 0000000000000101 int b = a << 14; // binario: 0100000000000000 - o primeiro 1 em 
101 é descartado ​Se você tem certeza de que nenhum dos 1 em um valor vai ser deviado para fora do 
espaço , um modo simples de pensar no operador para a esquerda é que ele multiplica o operando da 
direita por 2 elevado ao operador da esquerda. Por exemplo para gerar potências de 2 as segintes 
expressões podem ser utilizadas: 
1 << 0 == 1 1 << 1 == 2 1 << 2 == 4 1 << 3 == 8 ... 1 << 8 == 256 1 << 9 == 512 1 << 10 == 1024 ... ​Quando 
você desvia para a direita um valor x um y número de bits (x>>y), o comportamento depende do tipo de 
dados de x. Se x é do tipo int, o bit mais elevado é o bit de sinal que determina se x é negativo ou não. Neste 
caso o bit do sinal é copiado para os bits inferiores por razões históricas esotéricas: 
int x = -16; // binario: 1111111111110000 int y = x >> 3; // binario: 1111111111111110 ​Este 
comportamento é chamado extensão do sinal e freqüentemente não é o comportamento desejado. 
Entretanto, você pode desejar desviar preenchendo o espaço com zeros. Neste caso você deve utilizar 
uma alteração do tipo de dados que possui uma regra diferente para inteiros não assinalados: 
int x = -16; // binario: 1111111111110000 int y = (unsignedint)x >> 3; // binario: 0001111111111110 ​Se 
você for cauteloso em evitar a extensão do sinal, você pode usar o operador de desvio para a direita >> 
como um modo de dividir um número por potências de 2. Por exemplo: 
int x = 1000; int y = x >> 3; // divisão inteira de 1000 por 8, resultado 
y=125. 
Página | 25 
operadores de bits compostos AND (&=) e OR (|=) 
Os operadores de bits compostos realizam seus cálculos no nível de bit das variáveis. São freqüentemente 
utilizados para limpar ou marcar bits específicos. Veja o operador de bits AND(&) e o operador de bits OR(|) 
para detalhes sobre seu funcionamento. 
operador de bits composto AND (&=) 
Descrição ​O operador de bits composto AND (&=) é freqüentemente utilizado entre uma variável e uma 
constante para forçar que alguns bits em particular da variável sejam marcados como LOW (como 0). Este 
conceito aparece em manuais de programação como "limpeza" ou "resetting" de bits. 
Sintaxe: x &= y; // equivalente a x = x & y; 
Parâmetros: ​x: uma variável do tipo char, int 
ou long y: uma constante do tipo char, int, ou 
long 
Exemplo: ​Primeiro, uma revisão do operador de bits 
AND (&) 
0 0 1 1 operando1 0 1 0 1 operando2 ---------- 0 0 0 1 (operando1 & 
operando2) - resultado de retorno 
Bits que passam pelo operador AND um operando 0 são limpados para 0. Posrtanto se myByte é uma 
variável do tipo byte myByte & B00000000 = 0. Bits que passam pelo operador AND com um operando 1 
se matém como estão. Portanto myByte & B11111111 = myByte. 
Consequentemente para limpar (marcar como zero) alguns dos bits de uma variável deixando os demais 
como estão é só usar o operador de bits composto AND (&=) com uma constante por exemplo 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 
variável não modificada 
bits limpos 
Aqui está a mesma representação com os bits da variável subtituidos pelo símbolo x 
x x x x x x x x variável 1 1 1 1 1 1 0 
0 máscara ---------------------- x x x x 
x x 0 0 
Página | 26 
variável não modificada 
bits limpos 
portato se: ​myByte = 10101010; myByte &= 
B1111100 == B10101000; 
operador de bits composto OR (|=) ​Descrição ​O operador de bits composto OR (|=) é 
frequentemente utilizado entre uma variável e uma constatnte para forçar que alguns bits em particular 
sejam marcados como 1. ​Sintaxe: x |= y; // equivalente a x = x | y; Parâmetros ​x: uma variável do tipo 
char, int ou long y: uma constante do tipo char, int, ou long ​Exemplo: ​First, a review of the Bitwise OR (|) 
operator 
0 0 1 1 operando1 0 1 0 1 operando2 ---------- 0 1 1 1 (operando1 | operando2) - resultado de retorno 
Bits que passam pelo operador OR com um operando 0 são mantidos como estão, portanto se myByte é 
uma variável tipo byte, myByte | B00000000 = myByte; Bytes que passam pelo operador OR com um 
operando 1 são marcados com 1: myByte & B11111111 = B11111111; Consequentemente para marcar os 
bits 0 e 1 de uma variável deixando o restante sem mudanças use o operador de bits composto OR (|=) 
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 1 1 
variiável não modificada 
bits alterados 
Aqui a mesma representação com as variáveis substituidas 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 
variiável não modificada 
bits alterados ​So if: ​myByte = 
B10101010; myByte |= B00000011 == 
B10101011; 
Página | 27 
++ (incremento) / -- (decremento) 
Descrição ​Incrementar ou decrementar uma variável (adcionar ou 
subtrair 1) ​Sintaxe x++; // incrementa x em 1 e retorna o antigo 
valor de x ++x; // incrementa x em 1 e retorna o novo vaor de x 
x-- ; // decrementa x em 1 e retorna o antigo valor de x --x ; // decrementa x 
em 1 e retorna o novo valor de x Parâmetros ​x: uma variavel do tipo integer 
ou long (possivelmente não assinalada) ​Retornos ​O original ou recentemente 
incrementedo / decrementedo valor da variável. ​Exemplos x = 2; y = ++x; // x 
agora contém 3, y contém 3 y = x--; // x contém 2 de novo, y ainda contém 
3 
+= , -= , *= , /= 
Descrição ​Realiza uma operação matemática em uma variável com outra constante ou variável. O operador 
+= (e os outros) são apenas abreviações práticas da sintaxe expandida listada abaixo: ​Sintaxe x += y; // 
equivalente à expressão x = x + y; x -= y; // equivalente à expressão x = x - y; x *= y; // equivalente à 
expressão x = x * y; x /= y; // equivalente à expressão x = x / y; Parâmetros ​x: qualquer tipo de variável y: 
qualquer tipo de variável ou constante ​Exemplos x = 2; x += 4; // x agora contém 6 x -= 3; // x agora 
contém 3 x *= 10; // x agora contém 30 x /= 2; // x agora contém 15 
Página | 28 
Constantes 
Constantes são variáveis pre-definidas na linguagem Arduino. Elas são usadas para tornar os programas 
mais facilmente legíveis. Nós classificamos as constantes em grupos. 
Definindo níveis lógicos, verdadeiro e falso (constantes booleanas) 
Há duas constantes usadas para representar verdade ou falsidade na linguagem 
Arduino: ​true ​(verdadeiro), e ​false ​(falso). 
false 
false é a mais simples das duas e é definida como 0 (zero). 
true ​true é frequentemente definida como 1, o que é correto, mas true tem uma definição mais ampla. 
Qualquer inteiro que não é zero é TRUE, emum modo booleano. Assim, -1, 2 e -200 são todos definidos 
como true. Note que true e false são digitadas com minúsculas diferente de HIGH, LOW, INPUT, e 
OUTPUT. 
Definindo níveis de pinos, HIGH e LOW 
Quando estamos lendo ou escrevendo em um pino digital há apenas dois valores que um pino pode 
ter: ​HIGH ​(alto) e ​LOW​(baixo). 
HIGH 
O significado de HIGH (em referência a um pino) pode variar um pouco dependendo se este pino é uma 
entrada (INPUT) ou saída (OUTPUT). Quando um pino é configurado como INPUT com pinMode, e lido com 
um digitalRead, o microcontrolador considera como HIGH se a voltagem for de 3 volts ou mais. Um pino 
também pode ser configurado como um INPUT com o pinMode, e posteriormente receber um HIGH com um 
digitalWrite, isto vai "levantar" o resistor interno de 20KΩ que vai manter a leitura do pino como HIGH a não 
ser que ela seja alterada para low por um circuíto externo. Quando um pino é configurado como OUTPUT 
com o pinMode, e marcado como HIGH com o digitalWrite, ele está a 5 volts. Neste estado ele pode enviar 
corrente como por exemplo acender um LED que está conectado com um resistor em série ao terra, ou a 
outro pino configurado como OUTPUT e marcado como LOW. 
LOW 
O significado de LOW também pode variar dependendo do pino ser marcado como INPUT ou OUTPUT. 
QUando um pino é configurado como um INPUT com o pinMode, e lido com o digitalRead, o 
microcontrolador considera como LOW se a voltagem for de 2 volts ou menos. Quando um pino é 
configurado como OUTPUT com pinMode, e marcado como LOW com o digitalWrite, ele está a 0 volts. 
Neste estado ele pode "drenar" corrente como por exemplo para acender um LED que está conectado com 
um resistor em série ao +5 volts, ou a outro pino configurado como OUTPUT e marcado como HIGH. 
Definindo pinos digitais, INPUT e OUTPUT 
Pinos digitais podem ser tanto de ​INPUT ​como de ​OUTPUT​. Mudar um pino de INPUT para OUTPUT com 
pinMode() muda drasticamente o seu comportamento elétrico. ​Pinos configurados como Inputs ​Os pinos 
do Arduino (Atmega) configurados como ​INPUT ​com pinMode() estão em um estado de alta impedância. Um 
modo de explicar é que os pinos configurados como INPUT fazem demandas 
Página | 29 
extremamente pequenas ao circuíto do qual estão tomando amostras, algo como um resistor de 100 
Megaohms em série com o pino. Sendo assim é útil para ler um sensor mas não para energizar um LED. 
Pinos configurados como outputs 
Pinos configurados como ​OUTPUT ​com pinMode() estão em um estado de baixa impedância. Isto significa 
que eles podem fornecer grandes quantidades decorrente para outros circuítos. Os pinos do Atmega podem 
fornecer corrente positiva ou drenar corrente negativa até 40 mA (milliamperes) de/para outros dispositivos ou 
circuítos. Isto faz com que eles sejam úteis para energizar um LED mas disfuncionais para a leitura de 
sensores. Pinos configurados como outputs também podem ser danificados ou destruidos por curto-circuitos 
com o terra ou com outros pontos de 5 volts. A quantidade de corrente fornecida por um pino do Atmega 
também não é suficiente para ativar muitos relês e motores e, neste caso, algum circuíto de interface será 
necessário. 
Página | 30 
Constantes inteiras 
Constantes inteiras são números usados diretamente no código. Por padrão estes números são tratatados 
como int's, mas você pode alterar este comportamento com os modificadores U e L (veja abaixo). 
Normalmente constantes inteiras são tratadas na base 10 (decimal), mas formatadores especiais podem ser 
usados para entrar números em outras bases. ​Base Exemplo Formatador Comentário 
10 (decimal) 123 nenhum 
2 (binário) B1111011 'B' inicial somente valores de 8 bits (0 a 255) caracteres válidos 0-1 
8 (octal) 0173 '0' inicial caractres válidos: 0-7 
16 (hexadecimal) 0x7B '0x' inicial caractres válidos: 0-9 A-F, a-f Decimal ​são na base 10. Esta é a 
matemática do senso comum com a qual você está acostumado. Constatntes sem outros prefixos são 
asumidas como decimais. Exemplo: ​101 // o mesmo que 101 decimal ((1 * 10^2) + (0 * 10^1) + 1) Binários 
são na base 2. Apenas os caracteres 0 e 1 são válidos. Exemplo: ​B101 // o memso que 5 decimal ((1 * 2^2) 
+ (0 * 2^1) + 1) ​O formatador binário trabalha apenas com bytes (8 bits) entre 0 (B0) e 255 (B11111111). Se 
for conveniente entrar um número de 16 bits na forma binária você pode fazer isso seguindo o algoritmo 
abaixo: The binary formatter only works on bytes (8 bits) between 0 (B0) and 255 (B11111111). If it is 
convenient to input an int (16 bits) in binary form you can do it a two-step procedure such as: ​myInt = 
B1100110010101010; // entrada inválida myInt = (B11001100 * 256) + B10101010; // B11001100 é o 
primeiro byte e B10101010 o segundo Octais ​são na base oito. Apenas caracteres entre 0 e 7 são válidos. 
Valores octais são indicados pelo prefixo "0". Exemplo: ​0101 // o mesmo que 65 decimal ((1 * 8^2) + (0 * 
8^1) + 1) ​Cuidado É possivel gerar um erro difícil de encontrar (não intencional) incluindo um zero à frente de 
uma constatnte o que fará com que o compilador interprete o valor como octal. ​Hexadecimais (ou hex) ​são 
na base 16. Caracteres válidos são de 0 a 9 e as letras de A a F; A vale 10, B vale 11 até F que vale 15. 
Valores hexadeciamis são indicados pelo prefixo "0x". Note A-F pode ser escrito tanto com maiusculas quanto 
com minúsculas (a-f). Exemplo: ​0x101 // o mesmo que 257 decmal ((1 * 16^2) + (0 * 16^1) + 1) 
Formatadores U e L ​Por padrão uma constante inteira é tratada como um int com as limitações pertinentes 
nos valores. Para especificar uma constante inteira com outro tipo de dado proceda assim: 
• ​um 'u' ou 'U' para forçar a constante como do tipo não assinalado (unsigned). Exemplo: 33u 
• ​um 'l' ou 'L' para forçar a constante como do tipo longo (long). Exemplo: 100000L 
• ​um 'ul' ou 'UL' para forçar a constante como do tipo longo não assinalado (unsigned long). 
Exemplo: 32767ul 
Página | 31 
Variáveis booleanas * 
variáveis boolenas podem ter apenas dois valores verdadeiro (true) e falso (false). 
Exemplo int LEDpin = 5; // LED no pino 5 int switchPin = 13; // interruptor no, 
outro lado conectado ao terra. 
boolean running = false; 
void setup() { 
pinMode(LEDpin, OUTPUT); pinMode(switchPin, INPUT); 
digitalWrite(switchPin, HIGH); // "levanta" o resistor } ​void loop() 
{ 
if (digitalRead(switchPin) == LOW) { // interruptor é pressionado - resistor se 
mantém "levantado" delay(100); // espera para filtrar ruído da chave running 
= !running; // inverte o valor da variável running digitalWrite(LEDpin, 
running) // indica via LED } ​} ​* assim chamadas em homenagem a George 
Boole 
char 
Descrição ​Um tipo de dado que ocupa 1 byte de memória e armazena o valor de um caractere. Caracteres 
literais são escritos entre ' ' (em inglês estes caracteres se chamam single quotes, não consigo imaginar como 
possa ser em português) como este: 'A' (para cadeias de caracteres - strings - use aspas: "ABC"). Entretanto 
caracteres são armazenados como números. Você pode ver o código específico na tabela ASCII. Isto significa 
que é possível realizar operações artiméticas com caracteres, nos quais o valor ASCII do caractere é utilizado 
(e.g. 'A' + 1 vale 66, desde que o valor ASCII do A máiusculo é 65). Veja a referencia do Serial.println para 
mais informação de como os caracteres são traduzidos em números. O tipo de dado char é também do tipo 
assinalado, isso quer dizer que é possível codificar números de -128 a 127. Para um tipo de dado não 
assinalado de 1 byte (8 bits) use o tipo de dado ​byte​. ​Exemplo 
char myChar = 'A'; char myChar = 65; // ambos são 
equivalentes 
Página | 32 
byte 
Descrição ​Um byte armazena um número de 8 bits não assinalado, de 
0 a 255. ​Exemplo 
byte b = B10010; // "B" é o formatador binário (B10010 = 18 decimal) 
int 
Descrição ​Inteiro é o principal tipo de dado para armazenamento numérico capaz de números de 2 bytes. 
Isto abrange a faixa de -32.768 a 32.767 (valor mínimo de -2^15 e valor máximo de (2^15) -1). Ints 
armazenam números negativos com uma técnica chamada Complemento para dois. O bit mais alto, as 
vezes chamado de bit de "sinal", e sinaliza se o número é positivo ou negatico. O Arduino cuida da 
manipulação de números nagativos para você, assim as operações aritméticas funcionam de modo 
transparente e esperado. Entretanto pode ocorrer uma complicação inesperada na manipulação operador 
para deslocar bits à direita (>>). ​Exemplo 
int ledPin = 13; Sintaxe 
int var = val; 
• ​var - o nome da variável int 
• ​val - o valor designado para a variável ​Dica de programação ​Quando uma variável excede seu valor 
máximo de que é capaz ela "decai" ao valor mínimo de que é capaz. Note que isso ocorre nas duas 
direções. 
int x x = -32,768; x = x - 1; // x agora contém 32,767 - decaindo na direção 
negativa 
x = 32,767; x = x + 1; // x agora contém -32,768 - decaido 
Página | 33 
int não assinalado (unsigned int) 
Descrição ​Ints não assinalados (inteiros sem sinal) são o mesmo que ints no modo como armazenam 
valores de 2 bytes. Entretanto, ao invés de armazenar números negativos, armazenam somente valores 
positivos abrangendo a faixa de 0 a 65.535 ((2^16)-1). A diferença entre ints e ints não assinalados está no 
modo como o bit mais alto é interpretado.No Arduino o tipo int (que é assinalado), se o bit mais elevado é 1, 
o número é interpretado como negativo. ​Exemplo 
unsigned int ledPin = 13; Sintaxe 
unsigned int var = val; 
• ​var - nome da variável do tipo int não assinalado 
• ​val - o valor designado para a variável ​Dica de programação ​Quando variáveis excedam sua capacidade 
máxima elas "decaem" para o valor de sua capacidade mínima. Note que isso ocorre nas duas direções. 
unsigned int x x = 0; x = x - 1; // x agora contém 65535 - decaindo na direção 
negatica x = x + 1; // x now contains 0 - decaindo 
long 
Descrição ​Variáveis do tipo Long têm um tamanho ampliado para armazenamento de números, e são 
capazes de armazenar 32 bits (4 bytes), de -2.147.483,648 a 2.147.483.647. ​Exemplo 
long speedOfLight = 186000L; // veja Constantes inteiras para a explicação do 'L' Sintaxe 
long var = val; 
• ​var - o nome da variável de tipo long 
• ​val - o valor designado para a variável 
Página | 34 
long não assinalado (unsigned long) 
Descrição ​Longs não assinalados (longos sem sinal) são variáveis de tamanho ampliado para 
armazenamento numérico. Diferente dos longs padrão, os não assinalados não armazenam números 
negativos, abrangendo a faixade 0 a 4.294.967.295 (2^32 - 1). ​Exemplo unsigned long time; 
void setup() { 
Serial.begin(9600); } ​void 
loop() ​{ 
Serial.print("Time: "); time = millis(); //imprime o tempo desde que o programa começou a rodar 
Serial.println(time); // espera um segundo de modo que o programa não envie quantidades absurdas 
de dados delay(1000); } ​Sintaxe 
unsigned long var = val; 
• ​var - o nome de sua variável tipo long 
• ​val - o valor designado para a variável 
Página | 35 
float 
Descrição ​Tipo de dado para números de ponto flutuante, um número que tem um ponto decimal. Números 
de ponto flutuante são freqüentemente usados para aproximar valores análogos e contínuos porque têm mais 
resolução que os inteiros. Números de ponto flutuante abrangem a faixa de 3,4028235E+38 a - 
3,4028235E+38. Eles são armazenados em 32 bits (4 bytes) de informação. Números de ponto flutuante não 
são exatos e podem gerar resutados estranhos quando comparados. Por exemplo 6.0 / 3.0 pode não ser igua 
a 2.0. Você deve, em vez disso, verificar que o valor absoluto da diferença entre os números é menor que um 
valor pequeno pré-determinado. A matemática de ponto flutuante também é muito mais lenta que a dos 
inteiros na realização de cálculos, deve portanto ser evitada se, por exemplo, um loop tem que rodar a 
velocidade máxima para uma função em que o tempo é cr'tico. Programadares freqüentemente se esforçam 
para converter cálculos com pontos flutuantes em matemática de inteiros para aumentar a velocidade. 
Exemplos 
float myfloat; float sensorCalbrate = 
1.117; Sintaxe 
float var = val; 
• ​var - o nome da sua variável de ponto flutuante 
• ​val - o valor designado para a variável 
Código de exemplo 
int x; int y; 
float z; 
x = 1; y = x / 2; // y agora contém 0, inteiros não suportam frações z = (float)x / 2.0; // z agora 
contém .5 (voce deve usar 2.0, não 2) Dica de programação ​Serial.println() trunca os floats (despreza 
as frações) em inteiros quando enviando comunicação serial. Multiplique por potências de 10 para 
preservar a resolução. 
Página | 36 
double 
Descrição ​Número de ponto flutuante de precisão dupla. Ocupa 4 bytes. A implementação do double no 
Arduino é atualmente exatamente a mesma do float, sem ganho de precisão. ​Dica ​Usuários que utilizam 
códigos de outras fontes que incluem variávei do tipo double devem examinar o código para para verificar 
se a precisão implicada é diferente daquela realmente alcançada pelo Arduino. 
string 
Descrição ​Strings são representadas como arrays do tipo de dado char e terminadas por 
null (nulo). ​Exemplos ​Todos os seguintes são declarações válidas de 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 de declaração de strings 
• ​Declarar um array de chars sem inicializar como em Str1 
• ​Declarar um array de chars (com um char a mais) e o compilador vai adcionar o caractere null necessário como 
em Str2 
• ​Adcionar explicitamente o caractere null como em Str3 
• ​Inicializar com uma string constante entre aspas; o compilador determina o tamanho de modo a 
armazenar a string e o caractere null final como em Str4 
• ​Inicializar o array com uma string constante e o tamanho explicitos como em Str5 
• ​Inicializar o array deixando espaço extra para uma string maior como em Str6 ​Terminação em Null ​Geralmente 
strings são terminadas com o caractere null (código ASCII 0). Isto permite às funções (como Serial.print()) saber 
onde está o final da string. De outro modo elas continuariam lendo os bytes subsequentes da memória que de 
fato não pertencem à string. Isto significa que sua string deve ter espaço para um caractere a mais do que o texto 
que ela contém. É por isso que Str2 e Str5 precisam ter 8 caracteres, embora "arduino" tenha apenas 7 - a última 
posição é automaticamente preenchida com o caracatere null. Str4 terá o tamanho determinado automaticamente 
como 8 caracteres, um extra para o null. Na Str3 nós incluimos explicitamente o caractere null (escrito como '\0'). 
Note que é possível ter uma string sem o caractere final null (e.g. se você tivesse especificado o tamanho da Str2 
com sete ao invés de oito). Isto vai danificar a maioria das funções que usam strings, portanto você não deve 
fazer isso intencionalmente. Entretanto se você notar algo se comportando de maneira estranha (operações em 
caracteres que não pertencem à string) este poderia ser o problema. ​Aspas ou apóstrofos? ​Strings são sempre 
definidas com aspas ("Abc") e caracteres sempre definidos com apóstrofos('A'). ​Envolvendo strings longas 
Você pode envolver strings longas desse modo: 
Página | 37 
char myString[] = "This is the first line" " this is the second line" " etcetera"; Arrays de strings 
Freqüentemente é conveniente, quando se está trabalhando com grandes quantidades de texto, como em um 
projeto com um display de LCD, configurar um array de strings. Devido ao fato de as strings serem elas 
mesmas arrays, este é de fato um exemplo de um array bi-dimencional. No código abaixo os asteriscos após 
o tipo de dado char "char*" indica que se trata de um array de "ponteiros". Todos os nomes de array são de 
fato ponteiros, e assim são requeridos para se configurar um array de arrays. Ponteiros são uma das partes 
mais esotéricas da linguagem C que os principiantes têm que entender, mas é necessário entender os 
ponteiros em detalhe para fazer um uso efetivo deles neste caso. ​Exemplo char* myStrings[]={"This is 
string 1", "This is string 2", "This is string 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); } } 
Página | 38 
Arrays 
Um array é uma coleção de variáveis que são acessadas com um índice numérico. Arrays na liguagem de 
programação C, na qual o Arduino é baseado, podem ser complicados, mas o uso de arrays simples é 
relativamente operacionalizável. ​Criando (Declarando) um Array ​Todos os métodos abaixo são modos 
válidos para criar (declarar) um array. 
int myInts[6]; int myPins[] = {2, 4, 8, 3, 6}; int mySensVals[6] = {2, 4, -8, 3, 2}; char message[6] = 
"hello"; ​Você pode declarar um array sem inicializar como em myInts. Em myPins declaramos um array sem 
escolher explicitamente um tamanho. O compilador conta os elementos e cria o array do tamanho 
apropriado. Finalmente, você pode inicializar e especificar o tamanho do array como em mySensVals. Note 
que quando declarar um array do tipo char, um elemento a mais é necessário para armazenar o caractere 
null de finalização. ​Acessando um Array ​Arrays são indexados a partir do zero, ou seja, fazendo referência 
à inicialização de arrays acima, o primeiro elemento do array está no índice 0, assim: ​mySensVals[0] == 2, 
mySensVals[1] == 4, ​e assim por diante. 
Isso também significa que em um array de 10 elementos o índice do último elemento é 9, assim: ​int 
myArray[10]={9,3,2,4,3,2,7,8,9,11}; 
// myArray[9] contém 11 // myArray[10] é inválido e contém informação aleatória (outro endereço de 
memória) ​Por esta razão você deve acessar arrays cuidadosamente. Acessar um array após o seu final 
(usando um índice maior do que o declarado) é ler uma faixa de memória que está sendo utilizada para 
outros propósitos. Ler destes locais provavelmente não vai gerar nada além de dados inválidos. Escrever em 
locais de memória aleatórios decididamente não é uma boa idéia, e provavelmente conduzirá a maus 
resultados como malfuncionamento ou travamento do programa. Isto também pode ser um bug difícil de 
rastrear. Diferente de algumas versões do BASIC, o compilador C não checa para ver se um acesso a um 
array está dentro das margens legais do tamanho com que o array foi declarado. ​Designar um valor para 
um array: mySensVals[0]= 10; Recuperar um valor de um array: x = mySensVals[4]; Arrays e FOR 
Arrays são freqüentemente manipulados dentro da sentença ​for​, nas quais o contador é usado com índice 
para cada elemento. Por exemplo, para imprimir os elementos de um array através da porta serial você 
poderia fazer alguma coisa assim: ​int i; for (i = 0; i < 5; i = i + 1) { Serial.println(myPins[i]); } 
Página | 39 
void 
A palavra-chave void é usada apenas em declarações de funções. Ela indica que a função não deve enviar 
nenhuma informação de retorno à função que a chamou. ​Exemplo: // ações são realizadas nas funções 
"setup" e "loop" // mas nenuma informação é enviada ao programa mais amplo 
void setup() { 
// ... } ​void loop() 
{ 
// ... } 
Página | 40 
char() 
Descrição ​Converte um valor para o tipo de 
dado char. ​Sintaxe ​char(x) ​Parâmetros ​x: um 
valor de qualquer tipo ​Retorno ​char 
byte() 
Descrição ​Converte um valor para o tipo de 
dado byte. ​Sintaxe ​byte(x) ​Parâmetros ​x: um 
valor de qualquer tipo ​Retorno ​byte 
int() 
Descrição ​Converte um valor para o tipo de 
dado int. ​Sintaxe ​int(x) ​Parâmetros ​x: um 
valor de qualquer tipo ​Retorno ​int ​long() 
Descrição ​Converte um valor para o tipo de 
dado long. ​Sintaxe ​long(x) ​Parâmetros ​x: um 
valor de qualquer tipo ​Retorno ​long 
Página | 41 
float() 
Descrição ​Converte um valor para o tipo de 
dado float. ​Sintaxe ​float(x) ​Parâmetros ​x: um 
valor de qualquer tipo ​Retorno ​float 
Tabela ASCII 
O código ASCII (American Standard Code for Information Interchange) está em uso desde a década de 
1960. Ele é o modo padrão para codificar texto numericamente.* Note que os primeiros 32 caracteres 
(0-31) são caracteres não imprimíveis, também chamados de caracteres de controle. Os caracteres mais 
importantes foram nomeados na tabela abaixo: 
Valor Caractere Decimal 
0 null 1 ​2 3 4 5 6 7 8 9 tab ​10 
line feed 11 ​12 13 carriage 
return 14 ​15 16 17 18 19 20 21 
22 23 24 25 26 27 28 29 30 31 
re Decimal 
! 34 " 35 # 
& 39 ' 40 ( 41 
, 45 - 46 . 47 
2 51 3 52 4 
56 8 57 9 
61 = 62 > 63 
Valor Caractere Decimal 
Valor Caractere Decimal 
64 @ 65 A 66 B 67 C 68 
D 69 E 70 F 71 G 72 H 
73 I 74 J 75 K 76 L 77 M 
78 N 79 O 80 P 81 Q 82 
R 83 S 84 T 85 U 86 V 
87 W 88 X 89 Y 90 Z 91 
[ 92 \ 93 ] 94 ^ 95 _ 
64 @ 65 A 66 B 67 C 68 
D 69 E 70 F 71 G 72 H 
73 I 74 J 75 K 76 L 77 M 
78 N 79 O 80 P 81 Q 82 
R 83 S 84 T 85 U 86 V 
87 W 88 X 89 Y 90 Z 91 
[ 92 \ 93 ] 94 ^ 95 _ 
Valor Caractere Decimal 
Valor Caractere Decimal 
Valor Caractere Decimal 
96 ` 97 a 98 b 99 c 100 
d 101 e 102 f 103 g 104 
h 105 i 106 j 107 k 108 l 
109 m 110 n 111 o 112 
p 113 q 114 r 115 s 116 
t 117 u 118 v 119 w 120 
x 121 y 122 z 123 { 124 
| 125 } 126 ~ 127 
96 ` 97 a 98 b 99 c 100 
d 101 e 102 f 103 g 104 
h 105 i 106 j 107 k 108 l 
109 m 110 n 111 o 112 
p 113 q 114 r 115 s 116 
t 117 u 118 v 119 w 120 
x 121 y 122 z 123 { 124 
| 125 } 126 ~ 127 
96 ` 97 a 98 b 99 c 100 
d 101 e 102 f 103 g 104 
h 105 i 106 j 107 k 108 l 
109 m 110 n 111 o 112 
p 113 q 114 r 115 s 116 
t 117 u 118 v 119 w 120 
x 121 y 122 z 123 { 124 
| 125 } 126 ~ 127 
* Nota do tradutor: O código ASCII é um padrão para codificar texto numericamente e embora tenha muita 
importância histórica, vem sendo gradativamente substituido por padrões mais amplos como o UTF, em suas 
diversas variantes, e os conjuntos de caracteres (charset) definidos pela ISO (International Organization for 
Standardization). 
Página | 42 
pinMode() 
Descrição ​Configura o pino especificado para que se comporte ou como uma entrada (input) ou uma saída 
(output). Veja a descrição depinos digitais para mais detalhes. ​Sintaxe ​pinMode(pin, mode) ​Parâmetros ​pin: 
o número do pin o qual você deseja predeterminar. mode: pode ser INPUT ou OUTPUT ​Retorno ​Nenhum 
Exemplo int ledPin = 13; // LED conectado ao pino digital 13 
void setup() { 
pinMode(ledPin, OUTPUT); // predetermina o pino digital como uma saída } ​void loop() ​{ 
digitalWrite(ledPin, HIGH); // acende o LED delay(1000); // espera um segundo digitalWrite(ledPin, 
LOW); // apaga o LED delay(1000); // espera um segundo } ​Nota ​Os pinos de entrada analógica podem 
ser usados como pinos digitais e devem ser referenciados com os números de 14 (entrada analógica 0) a 
19 (entrada analógica 5). 
Página | 43 
digitalWrite() 
Descrição ​Escreve um valor HIGH ou um LOW em um pino digital. Se o pino foi configurado como uma 
saída (output) com o pinMode(), sua voltagem será determinada ao valor correspondente: 5V (ou 3.3V nas 
placas de 3.3V) para HIGH, 0V (terra) para LOW. Se o pino está configurado como uma entrada (input) 
escrever um HIGH levantará o resistor interno de 20KΩ (tutorial de pinos digitais). Escrever um LOW 
rebaixará o resistor. ​Sintaxw ​digitalWrite(pin, valor) ​Parâmetros ​pin: o número do pin valor: HIGH oo LOW 
Retorno ​nenhum ​Exemplo 
int ledPin = 13; // LED conectado ao pino digital 13 
void setup() { 
pinMode(ledPin, OUTPUT); // determia o pino digital como uma saída } ​void loop() ​{ 
digitalWrite(ledPin, HIGH); // acende o LED delay(1000); // espera um segundo digitalWrite(ledPin, 
LOW); // apaga um led delay(1000); // espera um segundo } ​Nota ​Os pinos de entrada analógica podem 
ser usados como pinos digitais e devem ser referenciados com os números de 14 (entrada analógica 0) a 
19 (entrada analógica 5). 
Página | 44 
digitalRead() 
Descrição ​Lê o valor de um pino digital especificado, HIGH 
ou LOW. ​Sintaxe ​digitalRead(pin) ​Parâmetros ​pin: o número 
do pin digital que você quer ler (​int​) ​Retorno ​HIGH ou LOW 
Exemplo 
int ledPin = 13; // LED conectado ao pino digital 13 int inPin 
= 7; // botão conectado ao pino digital 7 int val = 0; // 
variável para armazenar o valor lido 
void setup() { 
pinMode(ledPin, OUTPUT); // pré-determina o pino digital 13 como uma saída 
pinMode(inPin, INPUT); // pré-determina o pino dgital 7 como uma entrada } ​void loop() ​{ 
val = digitalRead(inPin); // lê o pino de entrada digitalWrite(ledPin, val); // acende ou apaga o LED de 
acordo com o pino de entrada } ​Transfere para o pino 13 o valor lido no pino 7 que é uma entrada. ​Nota 
Se o pino não estiver conectado a nada digitalRead() pode retornar tanto HIGH como LOW (e isso pode 
variar aleatoriamente). Os pinos de entrada analógica podem ser usados como pinos digitais e devem ser 
referenciados com os números de 14 (entrada analógica 0) a 19 (entrada analógica 5). 
Página | 45 
analogRead() 
Descrição ​Lê o valor de um pino analógico especificado. A placa Arduino contém um conversor 
analógico-digital de 10 bits com 6 canais (8 canais no Mini e no Nano). Com isto ele pode mapear voltagens 
de entrada entre 0 e 5 volts para valores inteiros entre 0 e 1023. Isto permite uma resolução entre leituras de 
5 volts / 1024 unidades ou 0,0049 volts (4.9 mV) por unidade. São necessários aproximadamente 100 μs 
(0.0001 s) para ler uma entrada analógica, portanto a velocidade máxima de leitura é de aproximadamente 
10.000 vezes por segundo. ​Sintaxe ​analogRead(pin) ​Parâmetros ​pin: o número do pino analógico que se 
deseja ler (0 a 5 na maioria das placas, 0 ta 7 no Mini e no Nano) ​Retorno ​int (0 a 1023) ​Note ​Se o pino 
analógico não estiver conectado a nada o valor de retorno do analogRead() vai variar de acordo com uma 
grande quantidade de fatores (e.g. os valores de outras entradas analógicas, a distância de sua mão à placa, 
etc.). Na prática é um valor aleatório. ​Exemplo 
int analogPin = 3; // perna do meio de um potenciómetro conectada ao pino analógico 3 
// pernas externas conectadas ao terra e ao +5V int val = 0; 
// variável para armazenar o valor lido void setup() { 
Serial.begin(9600); // inicial a comunicação serial } ​void loop() ​{ 
val = analogRead(analogPin); // lê o pino de entrada 
Serial.println(val); // informa o valor lido } 
Página | 46 
analogWrite() 
Descrição ​Escreve um valor analógico (onda PWM) em umpino. Pode ser usado para acender um LED 
variando o brilho ou girar um motor a velocidade variável. Depois de realizar um ​analogWrite()​, o pino vai 
gerar uma onda quadrada estável com o ciclo de rendimento especificado até que o próximo ​analogWrite() 
seja realizado (ou que seja realizado um ​digitalRead() ​ou​digitalWrite() ​no mesmo pino). A freqüência do 
sinal PWM é de aproximadamente 490Hz. Nas novas placas Arduino (incluindo o Mini e o BT) com o chip 
ATmega168 esta função é eficiente nos pinos 3,5,6,9,10 e 11. Placas Arduino mais antigas com um 
ATmega8 suportam o analogWrite() apenas nos pinos 9,10 e 11. ​Sintaxe ​analogWrite(pin, valor) 
Parâmetros ​pin: o pino no qual se deseja escrever valor: o rendimento do ciclo: entre 0 (sempre desligado) e 
255 (sempre ligado). ​Retorno ​nenhum ​Notas e problemas conhecidos ​Não é necessário realizar um 
pinMode() para pré-determinar o comportamento do pino como saída antes de realizar um analogWrite(). As 
saídas PWM geradas pelos pinos 5 e 6 terão rendimento de ciclo acima do esperado. Isto se deve às 
interações com as funções millis() e delay(), que compartilham o mesmo temporizador interno usado para 
gerar as saídas PWM. ​Exemplo ​Torna o brilho de um LED proporcional ao valor lido em um potenciómetro. 
int ledPin = 9; // LED conectado ao pino digital 9 int analogPin = 3; // 
potentiómetro conectado ao pino analógico 3 int val = 0; // variável para 
armazenar o valor lido 
void setup() { 
pinMode(ledPin, OUTPUT); // pré-determina o pino como saída } ​void 
loop() ​{ 
val = analogRead(analogPin); // lê o pino de entrada analogWrite(ledPin, val / 4); // os valores do 
analogRead variam de 0 a 1023, os valores do analogWrite variam de 0 a 255 
} 
Página | 47 
shiftOut() 
Descrição ​Envia um byte para a saída um bit de cada vez. Pode começar tanto pelo bit mais significativo 
(mais à esquerda) quano pelo menos significativo (mais à direita). Os bits vão sendo escritos um de cada vez 
um pino de dados, em sincronia com as alterações de um pino de clock que indica que o próximo bit está 
disponível. Isto é conhecido como protocolo serial sincrônico e é um modo comumente usado para que os 
microcontroladores se comuniquem com sensores e com outros microcontroladores. Os dois sispositivos se 
mantêm sincronizados a velocidades próximas da máxima desde que ambos compartilhem a mesma linha de 
clock. Normamlemte esta característica é descrita comoSerial Peripheral Interface (SPI). na documentação 
dos chips. 
Sintaxe ​shiftOut(dataPin, clockPin, bitOrder, value) ​Parâmetros ​dataPin: o pino no que será a 
saída de cada bit (​int​) clockPin: o pino que é alterado quando um novo valor foi enviado ao 
dataPin ​(​int​) bitOrder: qual é a ordem de envio dos bits, pode ser ​MSBFIRST LSBFIRST​. (Mais 
significativo primeiro ou menos significativo primeiro) value: a informação a enviar para a saída. 
(​byte​) ​Retorno ​Nenhum ​Note ​O ​dataPin ​e ​clockPin ​devem estar configurados como output pela 
função pinMode(). ​Exemplo ​Para o circuíto de referência deste exemplo veja tutorial on 
controlling a 74HC595 shift register. ​//**************************************************************// // 
Name : shiftOutCode, Hello World // // 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 // //**************************************************************** 
//Pin connected to ST_CP of 74HC595 int 
latchPin = 8; //Pin connected to SH_CP of 
74HC595 int clockPin = 12; ////Pin connected 
to DS of 74HC595 int dataPin = 11; 
void setup() { 
//set pins to output because they are addressed in the main loop 
pinMode(latchPin, OUTPUT); pinMode(clockPin, OUTPUT); 
pinMode(dataPin, OUTPUT); } 
Página | 48 
void loop() { 
//count up routine for (int j = 0; j < 
256; j++) { 
//ground latchPin and hold low for as long as you are transmitting 
digitalWrite(latchPin, LOW); shiftOut(dataPin, clockPin, LSBFIRST, j); 
//return the latch pin high to signal chip that it //no longer needs to listen for 
information digitalWrite(latchPin, HIGH); delay(1000); } ​} ​PulseIn() 
Descrição ​Lê um pulso (tanto HIGH como LOW) em um pino. Por exemplo, se ​valor ​for ​HIGH​, ​pulseIn() 
espera que o pino vá para​HIGH​, inicia a cronometragem, e então espera que o pino vá para ​LOW ​e para a 
cronometragem. Retorna a duração do pulso em microsegundos. Desiste e retorna 0 se nenhum pulso 
iniciar dentro de um tempo especificado. O tempo desta função foi determinado empiricamente e 
provavelmente dará erro em pulsos longos. Funciona com pulsos entre 10 microsegundos e 3 minutos. 
Syntaxe ​pulseIn(pino, valor) pulseIn(pino, valor, tempo) ​Parameters ​pino: o número do pino no qual você 
deseja ler o pulso. (​int​) valor: tipo de pulso a ler: tanto HIGH como LOW. (​int​) tempo (opcional): o número 
de microsegundos a esperar para que o pulso comece; o padrão é um segundo (​unsigned long​) ​Returno 
a duração do pulso (em microsegundos) ou 0 se nehum pulso iniciar antes do tempo especificado 
(​unsigned long​) 
Exemplo int pin = 7; 
unsigned long duration; 
void setup() { 
pinMode(pin, INPUT); } ​void 
loop() ​{ 
duration = pulseIn(pin, HIGH); } 
Página | 49 
millis() 
Descrição ​Retorna o número de milisegundos desde que a placa Arduino começou a rodar o programa. Este 
número extrapolrá (voltará ao zero) depois de aproximamente 50 dias. ​Parâmetros ​Nenhum ​Retorno ​O 
número de milisegundos desde que o programa começou a rodar como um tipo longo não assinalado. 
Exemplo unsigned long time; 
void setup(){ 
Serial.begin(9600); } ​void 
loop(){ 
Serial.print("Time: "); time = millis(); //imprime o tempo desde que o programa começou 
Serial.println(time); // espera um segundo para não ficar enviando quantidades absurdas de dados 
delay(1000); } ​Dica: ​Verifique o retorno para o ​millis ​é um longo não assinalado. Erros podem ocorrer se 
um programador tentar realizar cálculos com outros tipos de dados, como inteiros. 
micros() 
Descrição ​Retorna o número de microsegundos desde que a placa Arduino começou a rodar o programa. 
Este número extrapolrá (voltará ao zero) depois de aproximamente 70 minutos. Nas placas Arduino de 16 
MHz (e.g. Duemilanove e Nano), esta função tem uma resolução de 4 microsegundos (o valor de retorno será 
sempre um múltiplo de 4) Nas placas Arduino de 8MHz (e.g. LilyPad), esta função tem uma resolução de 8 
microsegundos. Nota: em 1 milisegundo há 1.000 microsegundos e 1.000.000 de microsegundos em 1 
segundo. Parâmetros Nenhum Retorno O número de microsegundos desde que o programa começou a rodar 
como um tipo longo não assinalado. 
Página | 50 
Exempl0 unsigned long time; void setup() { ​Serial.begin(9600); ​} ​void loop() ​{ ​Serial.print("Time: "); 
time = micros(); //imprime o tempo desde que o programa começou a rodar Serial.println(time); 
//espera um segundo para não ficar enviando quantidades absurdas de dados ​delay(1000); ​} 
delay(ms) 
Descrição ​Suspende a execução do programa pelo tempo (em milisegundos) especificado como parâmetro. 
(Em um segundo há 1.000 milisegundos.) ​Parâmetros ​ms (unsigned long): o número de milisegundos em 
que o programa ficará com a execução em suspenso. ​Retorno ​nenhum ​Exemplo int ledPin = 13; // LED 
conectado ao pino digital 13 
void setup() { 
pinMode(ledPin, OUTPUT); // marca o pino digital como saída } ​void loop() 
{ 
digitalWrite(ledPin, HIGH); // acende o LED delay(1000); // espera por um segundo digitalWrite(ledPin, 
LOW); // apaga o LED delay(1000); // espera por um segundo } ​Cuidado ​Embora seja fácil criar um LED 
piscando com a função delay(), e muitos programas usam intervalos curtos para tarefas como a de filtrar 
ruídos, o uso do delay() em um programa tem aspectos negativos importantes. Nenhuma leitura de sensores, 
cálculo matemático, ou manipulação de pinos pode seguir durante a execução desta função, portanto muitas

Outros materiais