Programacao-Arduino

Prévia do material em texto

Página | 1 
 
 
Programação 
Arduino 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Página | 2 
 
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 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Página | 3 
 
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 | 4 
 
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 (speed)......................................62 
 int Serial.available ()……………………………………63 
 int Serial.read ()…………………………………………64 
 Serial.flush ()……………………………………………..65 
 Serial.print (data)..........................................65 
 Serial.println (data).......................................68Página | 5 
 
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 criar uma 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 | 6 
 
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 | 7 
 
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 | 8 
 
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 | 9 
 
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 breaka 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 | 10 
 
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âmetros 
expressã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 | 11 
 
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 | 12 
 
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 | 13 
 
; 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 | 14 
 
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 | 15 
 
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 | 16 
 
#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 | 17 
 
#include 
#include é usado para incluir outras 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 | 18 
 
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 | 19 
 
% (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 | 20 
 
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ósuma 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 | 21 
 
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 operador booleano "!", 
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 | 22 
 
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 | 23 
 
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 | 24 
 
 
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 | 25 
 
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 = (unsigned int)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 | 26 
 
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 | 27 
 
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 | 28 
 
++ (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 | 29 
 
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 | 30 
 
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 de corrente 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 | 31 
 
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 a9 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 | 32 
 
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 | 33 
 
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 | 34 
 
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 | 35 
 
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 faixa de 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 | 36 
 
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 | 37 
 
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 | 38 
 
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 | 39 
 
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 | 40 
 
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 | 41 
 
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 | 42 
 
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 
 
 
Valor Caractere 
Decimal 
 
32 espaço 
33 ! 
34 " 
35 # 
36 $ 
37 % 
38 & 
39 ' 
40 ( 
41 ) 
42 * 
43 + 
44 , 
45 - 
46 . 
47 / 
48 0 
49 1 
50 2 
51 3 
52 4 
53 5 
54 6 
55 7 
56 8 
57 9 
58 : 
59 ; 
60 < 
61 = 
62 > 
63 ? 
 
 
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 _ 
 
 
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 
* 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 | 43 
 
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 | 44 
 
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 | 45 
 
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 | 46 
 
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