Programação Arduino

Programao
Arduino
Pgina | 1
Sumrio:
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
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
+= (adio composta)..................................28
-= (subtrao composta)...............................28
*= (multiplicao composta)..........................28
/= (diviso composta)...................................28
; (ponto e vrgula)...................................13
{} (chaves).............................................13
// (linha de comentrio)...........................15
/* */ (bloco de comentrio)......................15
#define..................................................16
#include.................................................17
Operadores aritmticos
= (igualdade).........................................18
+ (adio)..............................................18
- (subtrao)..........................................18
* (multiplicao).....................................18
/ (diviso)..............................................18
% (resto da diviso)...............................19
Operadores de comparao
== (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
! (no)....................................................21
Pgina | 2
Variveis
Variveis so expresses que voc pode usar em
programas para armazenar valores como a
leitura de um sensor em um pino analgico.
Constantes
Constantes so valores particulares com
significados especficos.
HIGH | LOW...........................................29
INPUT | OUTPUT....................................29
true | false.............................................29
Constantes inteiras.................................31
Tipos de dados
Variveis podem ser de vrios 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
Converso
char()....................................................41
byte()....................................................41
int().......................................................41
long()....................................................41
float()....................................................42
Referncia
Tabela ASCII..........................................42
Pgina | 3
Funes
Entrada e sada digital
Comunicao serial
pinMode (pin, mode).....................................43
Usado para comunicao entre a placa Arduino e
digitalWrite (pin, value).................................44
um computador ou outros dispositivos. Esta
int digitalRead (pin).......................................45
comunicao ocorre atravs dos conectores

serial ou USB da placa Arduino e nos pinos
Entrada e sada analgica
digitais 0 (RX) e 1 (TX). Assim, se voc utilizar
int analogRead (pin)......................................46
estas funes no poder utilizar os pinos 0 e 1
analogWrite (pin, value) PWM....................47
para entrada e sada digital.
Entrada e sada avanada
shiftOut (dataPin, clockPin, bitOrder, value).48

unsigned long pulseIn (pin, value).49
Tempo
Serial.begin (speed)......................................62
int Serial.available ()63
int Serial.read ()64
Serial.flush ()..65
Serial.print (data)..........................................65
Serial.println (data).......................................68
unsigned long millis()....................................50

unsigned long micros()..50
delay(ms)..51
delayMicroseconds(s)..52
Matemtica
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
Nmeros aleatrios
randomSeed (seed).60
long random (max).......................................61
long random (min, max)..61
Pgina | 4
setup()
A funo setup() chamada quando um programa pomea a rodar. Use esta funo para inicializar as sua
variveis, os modos dos pinos, declarar o uso de livrarias, etc. Esta funo ser executada apenas uma
vez aps a placa Arduino ser ligada ou ressetada.
Exemplo
int buttonPin = 3;
void setup()
{
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}
void loop()
{
// ...
}
loop()
Aps criar uma fuo setup() que declara os valores iniciais, a funo loop() faz exatamente o que seu
nome sugere, entra em looping (executa sempre o mesmo bloco de cdigo), permitindo ao seu programa
fazer mudanas e responder. Use esta funo para controlar ativamente a placa Arduino.
Exemplo
int buttonPin = 3;
// setup inicializa o serial e o pino do button (boto)
void setup()
{
beginSerial(9600);
pinMode(buttonPin, INPUT);
}
// loop checa o boto a cada vez,
// e envia o serial se ele for pressionado
void loop()
{
if (digitalRead(buttonPin) == HIGH)
serialWrite('H');
else
serialWrite('L');
delay(1000);
}
Pgina | 5
if (condicional) e ==, !=, <, > (operadores de

comparao)
if, que usado juntamente com um operador de comparao, verifica quando uma condio satisfeita,
como por exemplo um input acima de um determinado valor. O formato para uma verificao if :
if (algumaVariavel > 50)
{
// faa alguma coisa
}
O programa checa se algumaVariavel (colocar acentos em nomes de variveis no uma boa idia)
maior que 50. Se for, o programa realiza uma ao especfica. Colocado de outra maneira se a sentena
que est dentro dos parntesis verdadeira o cdigo que est dentro das chaves roda; caso contrrio o
programa salta este bloco de cdigo.
As chaves podem ser omitidas aps uma sentena if se s houver uma nica linha de cdigo (definida pelo
ponto e vrgula) 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 so corretos
A sentena que est sendo verificada necessita o uso de pelo menos um dos operadores:
Operadores de comparao:
x == y (x igual a y)
x != y (x no 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 precauo com o uso acidental de apenas um sinal de igual (e.g. if (x = 10) ). O sinal de igual
simples um operador de designao e coloca o valor 10 na varivel x. Ao contrrio o sinal de igal duplo
(e.g. if (x == 10) ), que um operador de comparao, verifica se x igual a 10 ou no. A ltima sentea
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 sentena (x=10) do
seguinte modo: 10 colocado na varivel x (lembre o sinal de igual simples um operador de
designao), ento x agora contm 10. Ento o condicional 'if' atribui um valor a 10, que ser sempre
verdadeiro (TRUE), desede que nmeros diferentes de zero so sempre equiparados verdadeiro.
Consequentemente, if (x = 10) ser sempre verdadeiro, que no o que pretendemos quando usamos
um 'if'. Adcionalmente o valor 10 ser guardado na varivel x que tambm no o que pretendemos.
if tambm pode ser usado como parte de uma estrutura de controle ramificada atravs da
construo if..else.
Pgina | 6
if / else
if/else permite um controle maior sobre o fluxo de cdigo do que a sentena if bsica, tornando possvel
que mltiplos testes sejam agrupados. Por exemplo, uma entrada analgica poderia ser verificada e uma
ao especfica seria tomada se o valor de input fosse menor que 500 e outra ao seria tomada se o
input fosse 500 ou mais. O cdigo seria assim:
if (pinFiveInput < 500)
{
// ao A
}
else
{
// ao B
}
else pode preceder outro teste if , e assim mltiplos testes, mutuamente exclusivos, podem ser realizados
ao mesmo tempo.
Cada teste precede o prximo at que um teste com vavlor verdadeiro encontrado. Quando um teste
com valor verdadeiro encontrado o seu bloco de cdigo associado execuatod e ento o programa salta
para a sequencia aps 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 nmero ilimitado destes
ramos else if permitido.
if (pinFiveInput < 500)
{
// faa a coisa A
}
else if (pinFiveInput >= 1000)
{
// faa a coisa B
}
else
{
// faa a coisa C
}
Outro modo de fazer testes de ramificaes mutuamente exclusivas atravs da sentena switch case.
Pgina | 7
sentena for
Descrio
A sentena for utilizada para repetir um bloco de cdigo delimitado por chaves. Um contador com
incremento normalmente usado para controlar e finalizar o loop. A sentena for util para quanquer
operao repetitiva, e frequentemente usada com arrays para operar em conjuntos de dados ou de
pinos.
H trs partes no cabealho do for:
for (inicializao; condio; incremento) {
//sentena(s);
}
A inicializao ocorre primeiro e apenas uma vez. Cada vez que o circuto executado a condio
verificada; se for verdadeira o bloco de cdigo e o incremento so executados, e ento a condio
testada novamente. Quando a condio se torna falsa o circuto termina.
Exemplo
// Aumentar o brilho de um LED usando um pino PWM
int PWMpin = 10; // um LED em srie com um resisotr de 1k no pino 10
void setup()
{
// nenhum setup necessrio
}
void loop()
{
for (int i=0; i <= 255; i++){
analogWrite(PWMpin, i);
delay(10);
}
}
Dica de programao
Na linguagem C o circuito for muito mais flexvel que os circuitos for encontrados a algumas outras
linguagens de programao, incluindo BASIC. Qualquer dos elementos do cabealho pode ser omitido,
embora os ";" sejam necessrios. Qualquer destes elementos tambm podem ser substituidos por
qualquer sentena vlida em C com varveis no correlatas. Estes tipos no usuais de sentenas for as
vezes podem ser a soluco para alguns problemas raros de programao.
Pgina | 8
sentena switch / case

Do mesmo modo que as sentenas 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 vaivel de teste e executa o cdigo se
encontrar um valor idntico.
Switch / case um pouco mais flexvel que uma estrutura if/else de modo que o programador pode
determinar se a estrutura switch deve continuar checando por valores idnticos na lista dos "caosos"
aps encontrar um valor idntico. Se a sentena break no encontrada aps a execuo do bloco de
cdigo selecionado por um dos "casos", ento o programa vai continuar a checar por mais valores
idnticos entre os "casos" restantes. Se uma sentena break encontrada o cdigo sai da estrutura do
mesmo modo que em uma construo if/else if.
Parmetros
var - a varivel para a qual voc busca valores idnticos
default - se nenhuma outra condio for satisfeita o cdigo que est no default executado
break - sem o break a sentena switch vai continuar checando as outras sentenas case para quanquer
outro possvel valor idntico. Se algum for encontrado ser executado do mesmo modo, o que pode no
ser o que voc deseja. Break indica ao switch para parar de procurar por outros valores idnticos e sai da
sentena switch.
Exemplo
switch (var) {
case 1:
//faa alguma coisa quando var == 1
break;
// break is optional
case 2:
//faa alguma coisa quando == 2
break;
default:
// se nenhum valor for idntico, faa o default
// default opcional
}
Pgina | 9
while
Descrio
while far com que o bloco de cdigo entre chaves se repita continua e indefinidamente at que a
expresso ente parentesis() se torne falsa. Algo tem que provocar uma mudana no valor da varivel que
est sendo verificada ou o cdigo vai sempre ficar dando voltas dentro do while. Isto poderia ser o
incremento de uma varivel ou uma condio externa como o teste de um sensor.
Syntax
while(expresso){
// cdigo
}
Parmetros
expresso - uma sentena boolena em C que possa ser verificada como verdadeira ou falsa
Exemplo
var = 0;
while(var < 200){
// algum cdigo que se repete 200 vezes
var++;
}
do - while
O do funciona da mesma maneira que o while loop, com a exceo de que a condio testada no final
do bloco de cdigo. Enquanto no while, se a condio for falsa, o bloco de cdigo no ser executado,
no do ele sempre ser executado pelo menos uma vez.
do
{
// bloco de cdigo
} while (condio);
Exemplo
do
{
delay(50);
// espera para que os sensores se estabilizem
x = readSensors(); // verifica o sensor

} while (x < 100);
Pgina | 10
continue
continue usado para saltar pores de cdigo em blocos do, for, ou while. Ele fora com que o cdigo
avance at o teste da condio saltando todo o demais.
Exemplo
for (x = 0; x < 255; x ++)
{
if (x > 40 && x < 120){
// criar saltos de execuo
continue;
}
digitalWrite(PWMpin, x);
delay(50);
}
return
Finaliza uma funo e retorna um valor, se necessrio.
Sintaxe:
return;
return valor; // ambas formas so vlidas
Parmetros
valor: alguma varivel ou constante
Exemplos:
Uma funo 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 seo de cdigo sem ter que transformar em "comentrio"
um grande e possivelmente defeituoso bloco de cdigo.
void loop(){
// aqui, uma brilhante idia de programao
return;
// restante do bloco de cdigo no funcional
// este cdigo nunca ser executado
}
Pgina | 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 programao C e inclusive alguns autores afirmam que o goto nunca
realmente necessrio, mas usado com cautela pode simplificar alguns programas. A razo pela qual
muitos programadores desaprovam seu uso que com o uso indiscriminado fcil de se criar um
programa com um fluxo indefinido e muito difcil de ser depurado.
No entanto, h casos em que o goto pode ser til e simplificar o cdigo. Uma destas situaes provocar
uma sada de um grupo de loops aglutinados ou de blocos lgicos if com uma determinada condio.
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:
Pgina | 12
; ponto e vrgula
Usada para terminar uma sentena.
Exemplo
int a = 13;
Dica
Esquecer de finalizar uma linha com ponto e vrgula causa um erro de compilao. O texto sobre o erro
pode ser bvio e se referir a um ponto e vrgula faltando, ou no. Se ocorrer um erro de compilao
impenetrvel ou aparenetemente ilgico uma das primeiras coisas a checar um ponto e vrgula faltando
na vizinhana, precedendo a linha indicada pelo compilador.
{} Chaves
Chaves so uma parte essencial da linguagem de programao C. Elas so usadas em muitas construes
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 condio como equilibrio entre as chaves. A IDE (integrated development environment ou ambiente
de desenvolvimento integrado) do Arduino inclui uma caracterstica prtica para checar o equilibrio das
chaves. Apenas com o selecionar de uma chave ou clicar no ponto imediatamente posterior faz com que
sua companheira lgica seja destacada.
No presente momento esta caracterstica 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 sentena
RETURN em uma subrotina(funo), a sentena ENDIF em uma condicional e a sentena NEXT em um
FOR.
Por que o uso das chaves to variado, uma boa prtica de programao digitar o fecha-chaves "}"
logo aps digitar o abre-chaves "{" quando estiver fazendo uma construo que as requer. Inserte ento
alguns "ENTER" entre as chaves e comece a digitar o cdigo. Agindo assim suas chaves nunca ficaro
desequilibradas.
Chaves desequilibradas causam erros de comilao bastante enigmticos e que podem ser difceis de
rastrear em um programa longo. Por causa de seus usos variados, as chaves so tambm incrivelmente
importantes para a sintaxe de um programa e mover uma chave uma ou duas linhas pode alterar
completamente o seu significado.
Pgina | 13
Os principais usos das chaves

Funes
void myfunction(datatype argument){
sentena(s)
}
Loops
while (expresso booleana)
{
sentena(s)
}
do
{
sentena(s)
} while (expresso booleana);
for (inicializao; condio de trmino; expresso de incremento)
{
sentena(s)
}
Sentenas condicionais
if (expresso booleana)
{
sentena(s)
}
else if (expresso booleana)
{
sentena(s)
}
else
{
sentena(s)
}
Pgina | 14
Comentrios
Comentrios so linhas no programa que so usados para informar a voc mesmo ou outras pessoas
sobre o modo como o progama trabalha. Elas so ignoradas pelo compilador e no so exportadas para o
processador e portanto no ocupam a memria do chip ATmega.
O nico propsito dos comentrios so ajudar a entender (ou relembrar) como o programa funciona. H
dois modos diferentes de marcar uma linha como um comentrio.
Exemplo
x = 5; // Esta uma linha simples de comentrio. Qualquer coisa depois das barras um
comentrio
// at o fim da linha
/* este um bloco de comentrio - usado para "comentar" blocos inteiros de cdigo
if (gwb == 0){ // no h problema em uma linha simples dentro de um bloco de comentrio
x = 3;
/* mas outro bloco de comentrio invlido */
}
// no esquea de fechar o bloco de comentrio, eles tm que ser equilibrados
*/
Dica
Quando estiver experimentando com o cdigo "comentar" partes do programa um modo conveniente de
remover linhas que podem conter problemas. Este procedimento mantm as linhas no cdigo mas as
trasnforma em comentrios de modo que o compilador as ignora. Isto pode ser especialmente til quando
tentamos localizar um problema, ou quando um programa apresenta erros de compilao cujas
explicaes so obscuras ou inteis.
Pgina | 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 no ocupam espao em
memria no chip. O compilador substitui referancias a estas constantes pelo valor definido no momento
da compilao.
Isto pode causar alguns efeitos indesejveis se, por exemplo, um nome de constante que tenha sido
defindo por um #define incluido em alguma outra constante ou nome de varivel. Neste caso o texto
deve ser substituido pelo valor (ou texto) do #define.
Em general, a palavra chave const prefervel para definir constatntes e deve ser usada ao invs de
#deine.
A sintaxe do #define na linguagem Arduino a mesma da linguagem C:
Sintaxe
#define nomeDeConstante valor
Verifique que o # necessrio.
Exemplo
#define ledPin 3
// O compilador vai substituir quanquer meno a ledPin pelo valor 3 no momento da
compilao.
Dica
No h ponto e vrgula aps a declarao #define. Se voc incluir um o compilador vai lanar erros crticos
no final do programa.
#define ledPin 3;
// isto um erro
Do mesmo modo o compilador gerar erros se aps o #define houver um =.

#define ledPin = 3 // isto tambm um erro
Pgina | 16
#include
#include usado para incluir outras bibliotecas no seu programa. Isto permite ao programador acessar
um grande nmero de bibliotecas padro da linguagem C (grupos de funes pr-definidas), e tambm
bibliotecas desenvolvidas especificamente para o Arduino.
A pgina principal de referncia para as bibliotecas C AVR (AVR a referncia aos chips Atmel nos quais o
Arduino est baseado) est aqui.
Verifique que #include, de modo similar ao #define, no leva ponto e vrgula no final.
Exemplo
Este exemplo inclui uma biblioteca que utilizada para armazenar dados na memria flash ao invs de na
ram. Isto economiza espao na ram para as necessidades de memria dinmica e torna o uso de grandes
tabelas mais prtico.
#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 designao (sinal de igual simples)

Armazena o valor do que est direita do sinal de igual na varivel que est esquerda.
O sinal de igual simples na linguagem de programao C chamdo operador de designao. Ele tem um
significado diferente daquele utilizado em lgebra, no qual indica uma equao ou iguladade. O operador
de designao indica ao microcontrolador para calcular o valor da expresso direita do sinal de igual e
armazenar este valor na varivel 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
analgico 0 em sensVal
Dicas de programao
A varivel esquerda necessita ser capaz de reter o valor que se quer armazenar. Se ela no for grande o
suficiente o valor armazenado pode ser incorreto.
No confunda o operador de designao [ = ] (sinal de igual simples) com o operador de comparao [
== ] (sinal de igual duplo), que calcula quando duas expresses so iguais ou no.
Pgina | 17
Adio, subtrao, multiplicao e diviso

Descrio
Estes operadores retornam a soma, diferena, profuto, ou quciente(respectivamente) de dois operandos.
A operao feita usando o tipo de dado dos operadores, assim, por exemplo 9/4 resulta em 2, desde
que 9 e 4 so inteiros. Isto tambm significa que uma operao 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
clculo.
Se um dos operandos for do tipo float ou do tipo double, ento a matemtica de ponto flutuante ser
usada para o clculo.
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;
Parmetros:
value1: qualquer varivel ou constante
value2: qualquer varivel ou constante
Dicas de programao
Saiba que constantes inteiras so consideradas int, portanto alguns cculos com constantes podem
extrapolar (e.g. 60 * 1000 resultar em um nmero negativo).
Escolha tamanhos de variveis que sejam grandes o suficiente para reter os maiores resultados possveis
dos clculos.
Conhea o ponto em que sua varivel pode "dar a volta" e tambm o que ocorre no sentido contrrioe.g.
(0 - 1) ou (0 - 32768).
Para matemtica que necessita de fraes use variveis do tipo float, mas tenha em conta seus pontos
negativos: tamanho maior e menor velocidade de computao.
Use o operador de modelagem para converter diretamente um tipo de varivel em outro e.g.
(int)meuFloat.
Pgina | 18
% (resto da diviso)
Descrio
Calcula o resto da diviso quando um inteiro dividido por outro. til para manter uma varivel dentro
de um patamer especfico (e.g. o tamanho de um array).
Sintaxe
resultado = dividendo % divisor
Parmetros
dividendo: o nmero que ser dividido
divisor: o nmero a dividir por
Retorna
o restante
Exemplo
x = 7 % 5; // x agora comtm 2
Cdigo 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 diviso atualiza a varivel
}
Dica
O operador de resto da diviso no funciona com variveis tipo float.
Pgina | 19
if (condicional) e ==, !=, <, > (operadores de

comparao)
if, que usado juntamente com um operador de comparao, verifica quando uma condio satisfeita,
como por exemplo um input acima de um determinado valor. O formato para uma verificao if :
if (algumaVariavel > 50)
{
// faa alguma coisa
}
O programa checa se algumaVariavel (colocar acentos em nomes de variveis no uma boa idia)
maior que 50. Se for, o programa realiza uma ao especfica. Colocado de outra maneira se a sentena
que est dentro dos parntesis verdadeira o cdigo que est dentro das chaves roda; caso contrrio o
programa salta este bloco de cdigo.
As chaves podem ser omitidas aps uma sentena if se s houver uma nica linha de cdigo (definida pelo
ponto e vrgula) 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 so corretos
A sentena que est sendo verificada necessita o uso de pelo menos um dos operadores:
Operadores de comparao:
x == y (x igual a y)
x != y (x no 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 precauo com o uso acidental de apenas um sinal de igual (e.g. if (x = 10) ). O sinal de igual
simples um operador de designao e coloca o valor 10 na varivel x. Ao contrrio o sinal de igal duplo
(e.g. if (x == 10) ), que um operador de comparao, verifica se x igual a 10 ou no. A ltima sentea
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 sentena (x=10) do
seguinte modo: 10 colocado na varivel x (lembre o sinal de igual simples um operador de
designao), ento x agora contm 10. Ento o condicional 'if' atribui um valor a 10, que ser sempre
verdadeiro (TRUE), desede que nmeros diferentes de zero so sempre equiparados verdadeiro.
Consequentemente, if (x = 10) ser sempre verdadeiro, que no o que pretendemos quando usamos
um 'if'. Adcionalmente o valor 10 ser guardado na varivel x que tambm no o que pretendemos.
if tambm pode ser usado como parte de uma estrutura de controle ramificada atravs da
construo if..else
Pgina | 20
Operadores Booleanos
Estes operadores podem ser usados dentro da condio em uma sentena if.
&& ("E" lgico)
Verdadeiro apenas se os dois operandos forem verdadeiros, ou seja a primeira condio "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" lgico)
Verdadeiro se algum dos operandos for verdadeiro, ou seja se a primeira "ou" a segunda condio for
verdadeira e.g.
if (x > 0 || y > 0) {
// ...
}
verdadeiro apenas se x ou y forem maiores que 0.
! (negao)
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 no confundir o operador booleano "E" representado por "&&" e o operador lgico de bits
"E" representado apenas por "&". Eles so animais completamente diferentes.
Do mesmo modo no confunda o booleano "OU" representado por "||" e o operador lgico de bits "|".
O operador lgico de bits "NO" representado por um "~" no 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
Pgina | 21
Operadores de bits AND (&), OR (|), XOR (^)

Operadores de bits
Os operadores de bits realizam clculos ao nvel de bits das variveis. Eles ajudama resolver uma grande
quantidade de problemas de programao. 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 expresses inteiras. Ele
realiza uma operao entre cada bit de cada uma destas expreses de acordo com a seguinte regra: se os
dois bits de entrada forem 1 o resultado da operao tambm 1, caso contrrio 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 expresses int faz com
que ocorram 16 operaes AND simultneas. Em um fragmento de cdigo:
int a = 92;
int b = 101;
// em binario: 0000000001011100
// em binario: 0000000001100101
int c = a & b; // resultado:
0000000001000100, ou 68 em decimal.
Cada um dos 16 bits em a AND b so processados usando este operador, e todos os 16 bits resultantes
so armazenados em c resultado o valor 0000000001000100, que 68 na notao decimal.
Um dos usos mais comuns do operador de bits AND selecionar alguns bits de um valor inteiro,
freqentemente chamado de mscara. Veja o exemplo abaixo para um exemplo.
Operador de bits OR (|)
O operador de bits OR (ou) em C++ o smbolo de barra vertical, |. Como o operador & ele realiza
clculos com cada bit de duas expresses seguindo a seguinte regra: o resultado da oprao 1 se um
dos bits de entrada for 1, caso contrrio 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 cdigo:
int a = 92;
int b = 101;
// in binario: 0000000001011100
// 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-ModificarEscrever em uma porta. Em microcontroladores uma porta um nmero de 8 bits que representa algo
sobre a condio dos pinos. Escrevendo em um controle de porta todos os pinos de uma vez.
PORTD uma constante pr-construda que se refere aos estados de sada dos pinos digitais
0,1,2,3,4,5,6,7. Se h um 1 em algum dos bits, ento este pino est em HIGH. (os pinos ainda precisam
ser defindos como pinos de sada 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 so usados pelo Arduino na comunicao serial, ou seja, interferimos nesta
comunicao.
Pgina | 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;
// varivel 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
e1
PORTD = PORTD | j;
// combina a informao da porta com a nova informao para os
pinos dos LEDs

Serial.println(PORTD, BIN); // debug para verificar a mscara
delay(100);
}
}
Operador de bits XOR (^)
H um operador um pouco raro em C++ chamado EXCLUSIVE OR (ou exclusivo) tambm conhecido por
XOR (em ingls se pronuncia "equis-or"). Este operador escrito com o smbolo do acento circunflexo ^.
O resultado desta operao 1 se os dois bits de entrada forem diferentes, caso contrrio retorna 0:
0 0 1 1
operando1
0 1 0 1
operando2
---------0 1 1 0
(operando1 ^ operando2) - resultado de retorno
Um simpples cdigo de exemplo:

int x = 12;
// binario: 1100
int y = 10;
// binario: 1010
int z = x ^ y; // binario: 0110, or decimal 6

O operador XOR freqentemente utilizado para inverter alguns dos bits de uma expresso inteira. Na
mscara 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
// demonstrao para o Exclusive OR
void setup(){
DDRD = DDRD | B00100000; // marca o pino digital 5 como saida.
Serial.begin(9600);
}
Pgina | 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 (no) em C++ o acento til do portugus ~. 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 nmero negativo como resultado desta operao. Isto ocorre por
que o bit mais elevado em uma varivel int chamdo de bi de sinal. Se este bit 1 o nmero negativo.
Este modo de encodar positivos e negativos chamado de complemento para dois. Mais informaes
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 expresso inteira pode causar algumas surpresas indesejadas.
Pgina | 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 nmero
especificado de bits no operando da direita.
Sintaxe
variavel << numero_de_bits
variavel >> numero_de_bits
Parmetros
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 nmero de bits (x<<Y) os bits mais a esquerda em
x so 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 espao , 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 potncias de 2 as segintes expresses podem ser
utilizadas:
1 << 0 ==
1 << 1 ==
1 << 2 ==
1 << 3 ==
...
1 << 8 == 256
1 << 9 == 512
1 << 10 == 1024
...
Quando voc desvia para a direita um valor x um y nmero 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
no. Neste caso o bit do sinal copiado para os bits inferiores por razes histricas esotricas:
int x = -16;
// binario: 1111111111110000
int y = x >> 3; // binario: 1111111111111110

Este comportamento chamado extenso do sinal e freqentemente no o comportamento desejado.
Entretanto, voc pode desejar desviar preenchendo o espao com zeros. Neste caso voc deve utilizar
uma alterao do tipo de dados que possui uma regra diferente para inteiros no assinalados:
int x = -16;
// binario: 1111111111110000
int y = (unsigned int)x >> 3; // binario: 0001111111111110

Se voc for cauteloso em evitar a extenso do sinal, voc pode usar o operador de desvio para a direita
>> como um modo de dividir um nmero por potncias de 2. Por exemplo:
int x = 1000;
int y = x >> 3; // diviso inteira de 1000 por 8, resultado y=125.
Pgina | 25
operadores de bits compostos AND (&=) e OR (|=)

Os operadores de bits compostos realizam seus clculos no nvel de bit das variveis. So freqentemente
utilizados para limpar ou marcar bits especficos.
Veja o operador de bits AND(&) e o operador de bits OR(|) para detalhes sobre seu funcionamento.
operador de bits composto AND (&=)

Descrio
O operador de bits composto AND (&=) freqentemente utilizado entre uma varivel e uma constante
para forar que alguns bits em particular da varivel sejam marcados como LOW (como 0). Este conceito
aparece em manuais de programao como "limpeza" ou "resetting" de bits.
Sintaxe:
x &= y; // equivalente a x = x & y;
Parmetros:
x: uma varivel do tipo char, int ou long
y: uma constante do tipo char, int, ou long
Exemplo:
Primeiro, uma reviso 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 so limpados para 0. Posrtanto se myByte uma
varivel do tipo byte myByte & B00000000 = 0.
Bits que passam pelo operador AND com um operando 1 se matm como esto. Portanto myByte &
B11111111 = myByte.
Consequentemente para limpar (marcar como zero) alguns dos bits de uma varivel deixando os demais
como esto s usar o operador de bits composto AND (&=) com uma constante por exemplo B11111100
1 0 1 0 1 0 1 0
varivel
1 1 1 1 1 1 0 0
mscara
---------------------1 0 1 0 1 0 0 0
varivel no modificada
bits limpos
Aqui est a mesma representao com os bits da varivel subtituidos pelo smbolo x
x x x x x x x x
varivel
1 1 1 1 1 1 0 0
mscara
---------------------x x x x x x 0 0
Pgina | 26
varivel no modificada
bits limpos
portato se:
myByte = 10101010;
myByte &= B1111100 == B10101000;
operador de bits composto OR (|=)

Descrio
O operador de bits composto OR (|=) frequentemente utilizado entre uma varivel e uma constatnte
para forar que alguns bits em particular sejam marcados como 1.
Sintaxe:
x |= y; // equivalente a x = x | y;
Parmetros
x: uma varivel 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 so mantidos como esto, portanto se myByte
uma varivel tipo byte,
myByte | B00000000 = myByte;
Bytes que passam pelo operador OR com um operando 1 so marcados com 1:
myByte & B11111111 = B11111111;
Consequentemente para marcar os bits 0 e 1 de uma varivel deixando o restante sem mudanas use o
operador de bits composto OR (|=) com a constante B00000011
1 0 1 0 1 0 1 0
varivel
0 0 0 0 0 0 1 1
mscara
---------------------1 0 1 0 1 0 1 1
variivel no modificada
bits alterados
Aqui a mesma representao com as variveis substituidas pelo smbolo x
x x x x x x x x
varivel
0 0 0 0 0 0 1 1
mscara
---------------------x x x x x x 1 1
variivel no modificada
bits alterados
So if:
myByte = B10101010;
myByte |= B00000011 == B10101011;
Pgina | 27
++ (incremento) / -- (decremento)
Descrio
Incrementar ou decrementar uma varivel (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
Parmetros
x: uma variavel do tipo integer ou long (possivelmente no assinalada)
Retornos
O original ou recentemente incrementedo / decrementedo valor da varivel.
Exemplos
x = 2;
y = ++x;
y = x--;
// x agora contm 3, y contm 3

// x contm 2 de novo, y ainda contm 3
+= , -= , *= , /=
Descrio
Realiza uma operao matemtica em uma varivel com outra constante ou varivel. O operador += (e os
outros) so apenas abreviaes prticas da sintaxe expandida listada abaixo:
Sintaxe
x += y; // equivalente expresso x = x + y;
x -= y; // equivalente expresso x = x - y;
x *= y; // equivalente expresso x = x * y;
x /= y; // equivalente expresso x = x / y;
Parmetros
x: qualquer tipo de varivel
y: qualquer tipo de varivel ou constante
Exemplos
x = 2;
x += 4;
x -= 3;
x *= 10;
x /= 2;
// x agora contm 6
// x agora contm 3
// x agora contm 30
// x agora contm 15
Pgina | 28
Constantes
Constantes so variveis pre-definidas na linguagem Arduino. Elas so usadas para tornar os programas
mais facilmente legveis. Ns classificamos as constantes em grupos.
Definindo nveis lgicos, 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 definio mais ampla.
Qualquer inteiro que no zero TRUE, emum modo booleano. Assim, -1, 2 e -200 so todos definidos
como true.
Note que true e false so digitadas com minsculas diferente de HIGH, LOW, INPUT, e OUTPUT.
Definindo nveis 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 referncia a um pino) pode variar um pouco dependendo se este pino uma
entrada (INPUT) ou sada (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 tambm 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 no ser que ela seja alterada para low por um circuto 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 srie ao terra, ou a outro pino configurado como OUTPUT e marcado como
LOW.
LOW
O significado de LOW tambm 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 srie 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 eltrico.
Pinos configurados como Inputs
Os pinos do Arduino (Atmega) configurados como INPUT com pinMode() esto em um estado de alta
impedncia. Um modo de explicar que os pinos configurados como INPUT fazem demandas
Pgina | 29
extremamente pequenas ao circuto do qual esto tomando amostras, algo como um resistor de 100
Megaohms em srie com o pino. Sendo assim til para ler um sensor mas no para energizar um LED.
Pinos configurados como outputs

Pinos configurados como OUTPUT com pinMode() esto em um estado de baixa impedncia. Isto significa
que eles podem fornecer grandes quantidades de corrente para outros circutos. Os pinos do Atmega
podem fornecer corrente positiva ou drenar corrente negativa at 40 mA (milliamperes) de/para outros
dispositivos ou circutos. Isto faz com que eles sejam teis para energizar um LED mas disfuncionais para
a leitura de sensores. Pinos configurados como outputs tambm 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 tambm no suficiente para ativar muitos rels e motores e, neste caso, algum circuto
de interface ser necessrio.
Pgina | 30
Constantes inteiras
Constantes inteiras so nmeros usados diretamente no cdigo. Por padro estes nmeros so tratatados
como int's, mas voc pode alterar este comportamento com os modificadores U e L (veja abaixo).
Normalmente constantes inteiras so tratadas na base 10 (decimal), mas formatadores especiais podem
ser usados para entrar nmeros em outras bases.
Base
10 (decimal)
2 (binrio)
8 (octal)
Exemplo
Formatador
123
nenhum
B1111011
0173
16 (hexadecimal)
Comentrio
'B' inicial somente valores de 8 bits (0 a 255) caracteres vlidos 0-1

'0' inicial
0x7B
'0x' inicial
caractres vlidos: 0-7

caractres vlidos: 0-9 A-F, a-f
Decimal so na base 10. Esta a matemtica do senso comum com a qual voc est acostumado.
Constatntes sem outros prefixos so asumidas como decimais.
Exemplo:
101
// o mesmo que 101 decimal ((1 * 10^2) + (0 * 10^1) + 1)
Binrios so na base 2. Apenas os caracteres 0 e 1 so vlidos.

Exemplo:
B101
// o memso que 5 decimal ((1 * 2^2) + (0 * 2^1) + 1)
O formatador binrio trabalha apenas com bytes (8 bits) entre 0 (B0) e 255 (B11111111). Se for
conveniente entrar um nmero de 16 bits na forma binria 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;
myInt = (B11001100 * 256) + B10101010;
// entrada invlida
// B11001100 o primeiro byte e B10101010 o
segundo
Octais so na base oito. Apenas caracteres entre 0 e 7 so vlidos. Valores octais so indicados pelo
prefixo "0".
Exemplo:
0101
// o mesmo que 65 decimal ((1 * 8^2) + (0 * 8^1) + 1)
Cuidado
possivel gerar um erro difcil de encontrar (no intencional) incluindo um zero frente de uma
constatnte o que far com que o compilador interprete o valor como octal.
Hexadecimais (ou hex) so na base 16. Caracteres vlidos so de 0 a 9 e as letras de A a F; A vale 10,
B vale 11 at F que vale 15. Valores hexadeciamis so indicados pelo prefixo "0x". Note A-F pode ser
escrito tanto com maiusculas quanto com minsculas (a-f).
Exemplo:
0x101 // o mesmo que 257 decmal ((1 * 16^2) + (0 * 16^1) + 1)
Formatadores U e L
Por padro uma constante inteira tratada como um int com as limitaes pertinentes nos valores. Para
especificar uma constante inteira com outro tipo de dado proceda assim:
um 'u' ou 'U' para forar a constante como do tipo no assinalado (unsigned). Exemplo: 33u
um 'l' ou 'L' para forar a constante como do tipo longo (long). Exemplo: 100000L
um 'ul' ou 'UL' para forar a constante como do tipo longo no assinalado (unsigned long).
Exemplo: 32767ul
Pgina | 31
Variveis booleanas *
variveis 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 mantm "levantado"
delay(100);
running = !running;
// espera para filtrar rudo da chave

// inverte o valor da varivel running
digitalWrite(LEDpin, running)
// indica via LED
}
}
* assim chamadas em homenagem a George Boole
char
Descrio
Um tipo de dado que ocupa 1 byte de memria e armazena o valor de um caractere. Caracteres literais
so escritos entre ' ' (em ingls estes caracteres se chamam single quotes, no consigo imaginar como
possa ser em portugus) como este: 'A' (para cadeias de caracteres - strings - use aspas: "ABC").
Entretanto caracteres so armazenados como nmeros. Voc pode ver o cdigo especfico na tabela
ASCII. Isto significa que possvel realizar operaes artimticas com caracteres, nos quais o valor ASCII
do caractere utilizado (e.g. 'A' + 1 vale 66, desde que o valor ASCII do A miusculo 65). Veja a
referencia do Serial.println para mais informao de como os caracteres so traduzidos em nmeros.
O tipo de dado char tambm do tipo assinalado, isso quer dizer que possvel codificar nmeros de -128
a 127. Para um tipo de dado no assinalado de 1 byte (8 bits) use o tipo de dado byte.
Exemplo
char myChar = 'A';
char myChar = 65;
// ambos so equivalentes
Pgina | 32
byte
Descrio
Um byte armazena um nmero de 8 bits no assinalado, de 0 a 255.
Exemplo
byte b = B10010; // "B" o formatador binrio (B10010 = 18 decimal)
int
Descrio
Inteiro o principal tipo de dado para armazenamento numrico capaz de nmeros de 2 bytes. Isto
abrange a faixa de -32.768 a 32.767 (valor mnimo de -2^15 e valor mximo de (2^15) -1).
Ints armazenam nmeros negativos com uma tcnica chamada Complemento para dois. O bit mais alto,
as vezes chamado de bit de "sinal", e sinaliza se o nmero positivo ou negatico.
O Arduino cuida da manipulao de nmeros nagativos para voc, assim as operaes aritmticas
funcionam de modo transparente e esperado. Entretanto pode ocorrer uma complicao inesperada na
manipulao operador para deslocar bits direita (>>).
Exemplo
int ledPin = 13;
Sintaxe
int var = val;
var - o nome da varivel int

val - o valor designado para a varivel
Dica de programao
Quando uma varivel excede seu valor mximo de que capaz ela "decai" ao valor mnimo de que
capaz. Note que isso ocorre nas duas direes.
int x
x = -32,768;
x = x - 1;
// x agora contm 32,767 - decaindo na direo negativa
x = 32,767;
x = x + 1;
// x agora contm -32,768 - decaido
Pgina | 33
int no assinalado (unsigned int)

Descrio
Ints no assinalados (inteiros sem sinal) so o mesmo que ints no modo como armazenam valores de 2
bytes. Entretanto, ao invs de armazenar nmeros negativos, armazenam somente valores positivos
abrangendo a faixa de 0 a 65.535 ((2^16)-1).
A diferena entre ints e ints no assinalados est no modo como o bit mais alto interpretado.No Arduino
o tipo int (que assinalado), se o bit mais elevado 1, o nmero interpretado como negativo.
Exemplo
unsigned int ledPin = 13;
Sintaxe
unsigned int var = val;
var - nome da varivel do tipo int no assinalado

Dica de programao
Quando variveis excedam sua capacidade mxima elas "decaem" para o valor de sua capacidade mnima.
Note que isso ocorre nas duas direes.
unsigned int x
x = 0;
x = x - 1;
x = x + 1;
// x agora contm 65535 - decaindo na direo negatica

// x now contains 0 - decaindo
long
Descrio
Variveis do tipo Long tm um tamanho ampliado para armazenamento de nmeros, e so 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 explicao do 'L'
Sintaxe
long var = val;
var - o nome da varivel de tipo long

Pgina | 34
long no assinalado (unsigned long)

Descrio
Longs no assinalados (longos sem sinal) so variveis de tamanho ampliado para armazenamento
numrico. Diferente dos longs padro, os no assinalados no armazenam nmeros 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 comeou a rodar
Serial.println(time);
// espera um segundo de modo que o programa no envie quantidades absurdas de dados
delay(1000);
}
Sintaxe
unsigned long var = val;
var - o nome de sua varivel tipo long

Pgina | 35
float
Descrio
Tipo de dado para nmeros de ponto flutuante, um nmero que tem um ponto decimal. Nmeros de
ponto flutuante so freqentemente usados para aproximar valores anlogos e contnuos porque tm mais
resoluo que os inteiros. Nmeros de ponto flutuante abrangem a faixa de 3,4028235E+38 a 3,4028235E+38. Eles so armazenados em 32 bits (4 bytes) de informao.
Nmeros de ponto flutuante no so exatos e podem gerar resutados estranhos quando comparados. Por
exemplo 6.0 / 3.0 pode no ser igua a 2.0. Voc deve, em vez disso, verificar que o valor absoluto da
diferena entre os nmeros menor que um valor pequeno pr-determinado.
A matemtica de ponto flutuante tambm muito mais lenta que a dos inteiros na realizao de clculos,
deve portanto ser evitada se, por exemplo, um loop tem que rodar a velocidade mxima para uma funo
em que o tempo cr'tico. Programadares freqentemente se esforam para converter clculos com
pontos flutuantes em matemtica de inteiros para aumentar a velocidade.
Exemplos
float myfloat;
float sensorCalbrate = 1.117;
Sintaxe
float var = val;
var - o nome da sua varivel de ponto flutuante

Cdigo de exemplo
int x;
int y;
float z;
x = 1;
y = x / 2;
// y agora contm 0, inteiros no suportam fraes
z = (float)x / 2.0; // z agora contm .5 (voce deve usar 2.0, no 2)

Dica de programao
Serial.println() trunca os floats (despreza as fraes) em inteiros quando enviando comunicao serial.
Multiplique por potncias de 10 para preservar a resoluo.
Pgina | 36
double
Descrio
Nmero de ponto flutuante de preciso dupla. Ocupa 4 bytes.
A implementao do double no Arduino atualmente exatamente a mesma do float, sem ganho de
preciso.
Dica
Usurios que utilizam cdigos de outras fontes que incluem varivei do tipo double devem examinar o
cdigo para para verificar se a preciso implicada diferente daquela realmente alcanada pelo Arduino.
string
Descrio
Strings so representadas como arrays do tipo de dado char e terminadas por null (nulo).
Exemplos
Todos os seguintes so declaraes vlidas 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 declarao 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 necessrio
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 espao extra para uma string maior como em Str6
Terminao em Null
Geralmente strings so terminadas com o caractere null (cdigo ASCII 0). Isto permite s funes (como
Serial.print()) saber onde est o final da string. De outro modo elas continuariam lendo os bytes
subsequentes da memria que de fato no pertencem string.
Isto significa que sua string deve ter espao para um caractere a mais do que o texto que ela contm.
por isso que Str2 e Str5 precisam ter 8 caracteres, embora "arduino" tenha apenas 7 - a ltima posio
automaticamente preenchida com o caracatere null. Str4 ter o tamanho determinado automaticamente
como 8 caracteres, um extra para o null. Na Str3 ns incluimos explicitamente o caractere null (escrito
como '\0').
Note que possvel ter uma string sem o caractere final null (e.g. se voc tivesse especificado o tamanho
da Str2 com sete ao invs de oito). Isto vai danificar a maioria das funes que usam strings, portanto
voc no deve fazer isso intencionalmente. Entretanto se voc notar algo se comportando de maneira
estranha (operaes em caracteres que no pertencem string) este poderia ser o problema.
Aspas ou apstrofos?
Strings so sempre definidas com aspas ("Abc") e caracteres sempre definidos com apstrofos('A').
Envolvendo strings longas
Voc pode envolver strings longas desse modo:
Pgina | 37
char myString[] = "This is the first line"

" this is the second line"
" etcetera";
Arrays de strings
Freqentemente 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 cdigo abaixo os asteriscos aps o tipo de dado char "char*" indica que se trata de um array de
"ponteiros". Todos os nomes de array so de fato ponteiros, e assim so requeridos para se configurar um
array de arrays. Ponteiros so uma das partes mais esotricas da linguagem C que os principiantes tm
que entender, mas necessrio 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);
}
}
Pgina | 38
Arrays
Um array uma coleo de variveis que so acessadas com um ndice numrico. Arrays na liguagem de
programao C, na qual o Arduino baseado, podem ser complicados, mas o uso de arrays simples
relativamente operacionalizvel.
Criando (Declarando) um Array
Todos os mtodos abaixo so modos vlidos 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 necessrio para armazenar o caractere null
de finalizao.
Acessando um Array
Arrays so indexados a partir do zero, ou seja, fazendo referncia inicializao de arrays acima, o
primeiro elemento do array est no ndice 0, assim:
mySensVals[0] == 2, mySensVals[1] == 4,
e assim por diante.
Isso tambm 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]
contm 11
// myArray[10] invlido e contm informao aleatria (outro endereo de memria)

Por esta razo voc deve acessar arrays cuidadosamente. Acessar um array aps o seu final (usando um
ndice maior do que o declarado) ler uma faixa de memria que est sendo utilizada para outros
propsitos. Ler destes locais provavelmente no vai gerar nada alm de dados invlidos. Escrever em
locais de memria aleatrios decididamente no uma boa idia, e provavelmente conduzir a maus
resultados como malfuncionamento ou travamento do programa. Isto tambm pode ser um bug difcil de
rastrear.
Diferente de algumas verses do BASIC, o compilador C no 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 so freqentemente manipulados dentro da sentena for, nas quais o contador usado com ndice
para cada elemento. Por exemplo, para imprimir os elementos de um array atravs da porta serial voc
poderia fazer alguma coisa assim:
int i;
for (i = 0; i < 5; i = i + 1) {
Serial.println(myPins[i]);
}
Pgina | 39
void
A palavra-chave void usada apenas em declaraes de funes. Ela indica que a funo no deve enviar
nenhuma informao de retorno funo que a chamou.
Exemplo:
// aes so realizadas nas funes "setup" e "loop"
// mas nenuma informao enviada ao programa mais amplo
void setup()
{
// ...
}
void loop()
{
// ...
}
Pgina | 40
char()
Descrio
Converte um valor para o tipo de dado char.
Sintaxe
char(x)
Parmetros
x: um valor de qualquer tipo
Retorno
char
byte()
Descrio
Converte um valor para o tipo de dado byte.
Sintaxe
byte(x)
Parmetros
Retorno
byte
int()
Descrio
Converte um valor para o tipo de dado int.
Sintaxe
int(x)
Parmetros
Retorno
int
long()
Descrio
Converte um valor para o tipo de dado long.
Sintaxe
long(x)
Parmetros
Retorno
long
Pgina | 41
float()
Descrio
Converte um valor para o tipo de dado float.
Sintaxe
float(x)
Parmetros
Retorno
float
Tabela ASCII
O cdigo ASCII (American Standard Code for Information Interchange) est em uso desde a dcada de
1960. Ele o modo padro para codificar texto numericamente.*
Note que os primeiros 32 caracteres (0-31) so caracteres no imprimveis, tambm chamados de
caracteres de controle. Os caracteres mais importantes foram nomeados na tabela abaixo:
Valor
Decimal
0
1
2
3
4
5
6
7
8
9
10
11
12
13
return
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Caractere
null
tab
line feed
carriage
Valor
Decimal
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
Caractere
espao
!
"
#
$
%
&
'
(
)
*
+
,
.
/
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
Valor
Decimal
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
Caractere
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
^
_
Valor
Decimal
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
Caractere
`
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
{
|
}
~
* Nota do tradutor: O cdigo ASCII um padro para codificar texto numericamente e embora tenha
muita importncia histrica, vem sendo gradativamente substituido por padres mais amplos como o UTF,
em suas diversas variantes, e os conjuntos de caracteres (charset) definidos pela ISO (International
Organization for Standardization).
Pgina | 42
pinMode()
Descrio
Configura o pino especificado para que se comporte ou como uma entrada (input) ou uma sada (output).
Veja a descrio depinos digitais para mais detalhes.
Sintaxe
pinMode(pin, mode)
Parmetros
pin: o nmero 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 sada
}
void loop()
{
digitalWrite(ledPin, HIGH); // acende o LED
delay(1000);
// espera um segundo
digitalWrite(ledPin, LOW);
delay(1000);
// apaga o LED
}
Nota
Os pinos de entrada analgica podem ser usados como pinos digitais e devem ser referenciados com os
nmeros de 14 (entrada analgica 0) a 19 (entrada analgica 5).
Pgina | 43
digitalWrite()
Descrio
Escreve um valor HIGH ou um LOW em um pino digital. Se o pino foi configurado como uma sada
(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)
Parmetros
pin: o nmero do pin
valor: HIGH oo LOW
Retorno
nenhum
Exemplo
int ledPin = 13;
void setup()
{
// determia o pino digital como uma sada
}
void loop()
{
delay(1000);
delay(1000);
// apaga um led
}
Nota
Pgina | 44
digitalRead()
Descrio
L o valor de um pino digital especificado, HIGH ou LOW.
Sintaxe
digitalRead(pin)
Parmetros
pin: o nmero 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; // boto conectado ao pino digital 7
int val = 0;
// varivel para armazenar o valor lido
void setup()
{
pinMode(inPin, INPUT);
// pr-determina o pino digital 13 como uma sada

// 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 no estiver conectado a nada digitalRead() pode retornar tanto HIGH como LOW (e isso pode
variar aleatoriamente).
Pgina | 45
analogRead()
Descrio
L o valor de um pino analgico especificado. A placa Arduino contm um conversor analgico-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 resoluo entre leituras de 5 volts /
1024 unidades ou 0,0049 volts (4.9 mV) por unidade.
So necessrios aproximadamente 100 s (0.0001 s) para ler uma entrada analgica, portanto a
velocidade mxima de leitura de aproximadamente 10.000 vezes por segundo.
Sintaxe
analogRead(pin)
Parmetros
pin: o nmero do pino analgico 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 analgico no 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 analgicas, a distncia de sua
mo placa, etc.). Na prtica um valor aleatrio.
Exemplo
int analogPin = 3;
// perna do meio de um potencimetro conectada ao pino analgico 3
// pernas externas conectadas ao terra e ao +5V

int val = 0;
void setup()
{
Serial.begin(9600);
// inicial a comunicao serial
}
void loop()
{
val = analogRead(analogPin);
Serial.println(val);
// l o pino de entrada
// informa o valor lido
Pgina | 46
analogWrite()
Descrio
Escreve um valor analgico (onda PWM) em um pino. Pode ser usado para acender um LED variando o
brilho ou girar um motor a velocidade varivel. Depois de realizar um analogWrite(), o pino vai gerar
uma onda quadrada estvel com o ciclo de rendimento especificado at que o
prximo analogWrite() seja realizado (ou que seja realizado um digitalRead() oudigitalWrite() no
mesmo pino). A freqncia do sinal PWM de aproximadamente 490Hz.
Nas novas placas Arduino (incluindo o Mini e o BT) com o chip ATmega168 esta funo 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)
Parmetros
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
No necessrio realizar um pinMode() para pr-determinar o comportamento do pino como sada antes
de realizar um analogWrite().
As sadas PWM geradas pelos pinos 5 e 6 tero rendimento de ciclo acima do esperado. Isto se deve s
interaes com as funes millis() e delay(), que compartilham o mesmo temporizador interno usado para
gerar as sadas PWM.
Exemplo
Torna o brilho de um LED proporcional ao valor lido em um potencimetro.
int ledPin = 9;
int analogPin = 3; // potentimetro conectado ao pino analgico 3

int val = 0;
void setup()
{
pinMode(ledPin, OUTPUT); // pr-determina o pino como sada
}
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
}
Pgina | 47
shiftOut()
Descrio
Envia um byte para a sada um bit de cada vez. Pode comear tanto pelo bit mais significativo (mais
esquerda) quano pelo menos significativo (mais direita). Os bits vo sendo escritos um de cada vez um
pino de dados, em sincronia com as alteraes de um pino de clock que indica que o prximo bit est
disponvel.
Isto conhecido como protocolo serial sincrnico e um modo comumente usado para que os
microcontroladores se comuniquem com sensores e com outros microcontroladores. Os dois sispositivos se
mantm sincronizados a velocidades prximas da mxima desde que ambos compartilhem a mesma linha
de clock. Normamlemte esta caracterstica descrita comoSerial Peripheral Interface (SPI). na
documentao dos chips.
Sintaxe
shiftOut(dataPin, clockPin, bitOrder, value)
Parmetros
dataPin: o pino no que ser a sada 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 informao a enviar para a sada. (byte)
Retorno
Nenhum
Note
O dataPin e clockPin devem estar configurados como output pela funo pinMode().
Exemplo
Para o circuto de referncia 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);
}
Pgina | 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()
Descrio
L um pulso (tanto HIGH como LOW) em um pino. Por exemplo, se valor for HIGH, pulseIn() espera
que o pino v paraHIGH, inicia a cronometragem, e ento espera que o pino v para LOW e para a
cronometragem. Retorna a durao do pulso em microsegundos. Desiste e retorna 0 se nenhum pulso
iniciar dentro de um tempo especificado.
O tempo desta funo 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 nmero do pino no qual voc deseja ler o pulso. (int)
valor: tipo de pulso a ler: tanto HIGH como LOW. (int)
tempo (opcional): o nmero de microsegundos a esperar para que o pulso comece; o padro um
segundo (unsigned long)
Returno
a durao 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);
}
Pgina | 49
millis()
Descrio
Retorna o nmero de milisegundos desde que a placa Arduino comeou a rodar o programa. Este nmero
extrapolr (voltar ao zero) depois de aproximamente 50 dias.
Parmetros
Nenhum
Retorno
O nmero de milisegundos desde que o programa comeou a rodar como um tipo longo no assinalado.
Exemplo
unsigned long time;
void setup(){
Serial.begin(9600);
}
void loop(){
time = millis();
//imprime o tempo desde que o programa comeou
Serial.println(time);
// espera um segundo para no ficar enviando quantidades absurdas de dados
delay(1000);
}
Dica:
Verifique o retorno para o millis um longo no assinalado. Erros podem ocorrer se um programador
tentar realizar clculos com outros tipos de dados, como inteiros.
micros()
Descrio
Retorna o nmero de microsegundos desde que a placa Arduino comeou a rodar o programa. Este
nmero extrapolr (voltar ao zero) depois de aproximamente 70 minutos. Nas placas Arduino de 16 MHz
(e.g. Duemilanove e Nano), esta funo tem uma resoluo de 4 microsegundos (o valor de retorno ser
sempre um mltiplo de 4) Nas placas Arduino de 8MHz (e.g. LilyPad), esta funo tem uma resoluo de 8
microsegundos.
Nota: em 1 milisegundo h 1.000 microsegundos e 1.000.000 de microsegundos em 1 segundo.
Parmetros
Nenhum
Retorno
O nmero de microsegundos desde que o programa comeou a rodar como um tipo longo no assinalado.
Pgina | 50
Exempl0
unsigned long time;
void setup()
{
Serial.begin(9600);
}
void loop()
{
time = micros(); //imprime o tempo desde que o programa comeou a rodar
Serial.println(time); //espera um segundo para no ficar enviando quantidades absurdas de
dados
delay(1000);
}
delay(ms)
Descrio
Suspende a execuo do programa pelo tempo (em milisegundos) especificado como parmetro. (Em um
segundo h 1.000 milisegundos.)
Parmetros
ms (unsigned long): o nmero de milisegundos em que o programa ficar com a execuo em suspenso.
Retorno
nenhum
Exemplo
int ledPin = 13;
void setup()
{
// marca o pino digital como sada
}
void loop()
{
delay(1000);
// espera por um segundo
delay(1000);
// apaga o LED
// espera por um segundo
}
Cuidado
Embora seja fcil criar um LED piscando com a funo delay(), e muitos programas usam intervalos curtos
para tarefas como a de filtrar rudos, o uso do delay() em um programa tem aspectos negativos
importantes. Nenhuma leitura de sensores, clculo matemtico, ou manipulao de pinos pode seguir
durante a execuo desta funo, portanto muitas outras funes ficam em espera. Para controles de
tempo alternativos veja a funo millis() e e seu programa de exemplo. Programadores com mais
conhecimento normalmente evitam o uso de delay() para cronometrar eventos mais logos do que 10
milisegundos, a no ser que o programa seja muito simples.
Pgina | 51
Algumas coisas de fato continuam acontecendo enquanto a funo delay() est controlando o chip
ATmega porque as interrupes no so desabilitadas. A comunicao que aparece no pino RX continua
sendo gravada. os pinos e as leituras de PWM (analogWrite) so mantidos, e as interrupes continuam
funcionando.
delayMicroseconds(s)
Descrio
Suspende a execuo do programa pelo tempo (em microsegundos) especificado como parmetro. Um 1
milisegundo h 1.000 microsegundos e em 1 segundo h 1 milho.
Atualmente o maior valor que produzir uma suspeno precisa 16383. Isto pode mudar em
distribuies futuras do Arduino. Para suspenes maiores que milhares de microsegundo voc deve
utilizar a funo delay().
Parmetros
s: o nmero de microsegundos da suspeno.
Retorno
Nenhum
Exemplo
int outPin = 8;
// digital pino 8
void setup()
{
pinMode(outPin, OUTPUT);
}
void loop()
{
digitalWrite(outPin, HIGH); // ativa o pino
delayMicroseconds(50);
// suspeno de 50 microsegundos
digitalWrite(outPin, LOW);
// desativa o pino
}
configura o pino 8 para trabalhar como uma sada. Envia uma cadeia de de pulsos com um perodo de 100
microsegundos.
Cuidados e problemas conhecidos
Esta funo funciona com bastante preciso na faixa dos 3 microsegundos e acima. No podemos nos
assegurar que funcione com preciso para tempos de suspeno menores.
Para assegurar suspenes mais precisas esta funo desabilita as interrupes durante sua operao.
Isto significa que algumas coisas (como o recebimento de informaes seriais, ou que a atualizao do
valor de retorno da funo mills() ) no funcionaro. Desse modo, voc deve usar esta funo apenas
para suspenes curtas, e usar delay() para as mais longas.
delayMicroseconds(0) gerar uma suspano muito maior do que a esperada (~1020 s) bem como se o
parmetro for um nmero negativo.
Pgina | 52
delayMicroseconds(s)
Descrio
Suspende a execuo do programa pelo tempo (em microsegundos) especificado como parmetro. Um 1
milisegundo h 1.000 microsegundos e em 1 segundo h 1 milho.
Atualmente o maior valor que produzir uma suspeno precisa 16383. Isto pode mudar em
distribuies futuras do Arduino. Para suspenes maiores que milhares de microsegundo voc deve
utilizar a funo delay().
Parmetros
s: o nmero de microsegundos da suspeno.
Retorno
Nenhum
Exemplo
int outPin = 8;
// digital pino 8
void setup()
{
pinMode(outPin, OUTPUT);
}
void loop()
{
digitalWrite(outPin, HIGH); // ativa o pino
digitalWrite(outPin, LOW);
// desativa o pino
}
configura o pino 8 para trabalhar como uma sada. Envia uma cadeia de de pulsos com um perodo de 100
microsegundos.
Cuidados e problemas conhecidos
Esta funo funciona com bastante preciso na faixa dos 3 microsegundos e acima. No podemos nos
assegurar que funcione com preciso para tempos de suspeno menores.
Para assegurar suspenes mais precisas esta funo desabilita as interrupes durante sua operao.
Isto significa que algumas coisas (como o recebimento de informaes seriais, ou que a atualizao do
valor de retorno da funo mills() ) no funcionaro. Desse modo, voc deve usar esta funo apenas
para suspenes curtas, e usar delay() para as mais longas.
delayMicroseconds(0) gerar uma suspano muito maior do que a esperada (~1020 s) bem como se o
parmetro for um nmero negativo.
Pgina | 53
min(x, y)
Descrio
Calcula o mnimo entre dois nmeros.
Parmetros
x: o primeiro nmero, de qualquer tipo de dado
y: o segundo nmero, de qualquer tipo de dado
Retorno
O menor dos dois nmeros.
Exemplos
sensVal = min(sensVal, 100); // assinala varivel sensVal o mnimo entre seu prrio valor e
100
// assegurando que seu valor nunca seja menor que 100
Nota
Talvez, de modo no-intuitivo, max() frequentemente utilizado para restringir o valor mais baixo de uma
varivel, enquanto min() utilizado para restringir o valor mais alto.
Cuidado:
Devido ao modo como a funo min() foi implementada voc deve evitar utilizar outras funes dentro
dos parnteses, isto pode levar a resultados incorretos
min(a++, 100); // evite isso
a++;
min(a, 100);
// usse isso, mantenha outros clculos fora da funo
Pgina | 54
max(x, y)
Descrio
Calcula o mximo entre dois nmeros
Parmetros
x: o primeiro nmero, de qualquer tipo de dado
y: o segundo nmero, de qualquer tipo de dado
Retorno
O maior dos dois nmeros
Exemplo
sensVal = max(senVal, 20); // assinala varivel sensVal o mximo entre seu prrio valor e
20
// assegurando que seu valor seja pelo menos 20
Nota
Talvez, de modo no-intuitivo, max() frequentemente utilizado para restringir o valor mais baixo de uma
varivel, enquanto min() utilizado para restringir o valor mais alto.
Cuidado
Devido ao modo como a funo max() foi implementada voc deve evitar utilizar outras funes dentro
dos parnteses, isto pode levar a resultados incorretos
max(a--, 0); // evite isso
a--;
// use isso, mantenha outros clculos fora da funo
max(a, 0);
Pgina | 55
abs(x)
Descrio
Calcula o valor absoluto de um nmero.
Parmetros
x: o nmero
Retorno
x: se x for maior ou igual a 0
-x: se x for menor que 0.
Cuidado
Devido ao modo como a funo abs() foi implementada voc deve evitar utilizar outras funes dentro dos
parnteses, isto pode levar a resultados incorretos
abs(a++); // evite isso
a++;
// use isso, mantenha outros clculos fora da funo
abs(a);
constrain(x, a, b)
Descrio
Restring um nmero dentro de uma faixa.
Parmetros
x: o nmero a restringir, todos os tipos de dados
a: o extremo inferior da faixa, todos os tipos de dados
b: o extremo superior da faixa, todos os tipos de dados
Retorno
x: se x estiver entre a e b
a: se x for menor que a
b: se x for mairo que b
Exemplo
sensVal = constrain(sensVal, 10, 150);
// limita o valor da varivel sensVal a valores entre 10 e 150
Pgina | 56
map(value, fromLow, fromHigh, toLow, toHigh)

Descrio
Re-mapeia um nmero de uma faixa de valores para outra. Isto , um valor de fromLow mapeado para
toLow, um valor fromHigh para toHigh, e valores intermedirios da primeira faixa para a segunda faixa,
mantendo-se a proporo entre eles.
No restringe valores dentro da faixa, porque valores que extrapolem podem ser teis e intencionais. A
funo constrain() pode ser utilizada tantes antes como depois desta funo se limites para as faixas
forem necessrios.
Verifique que os limites inferiores de uma faixa podem ser maiores ou menores que os limites superiores.
Desse modo a funo map() pode ser utilizada para colocar em ordem reversa uma faixa de valores, como
por exemplo:
y = map(x, 1, 50, 50, 1);
A funo tambm pode utilizar nmeros negativos como neste exemplo:
y = map(x, 1, 50, 50, -100);
A funo map() utiliza nmeros inteiros e no gera fraes. Quando o resultado for fracionrio ele ser
truncado e no arredondado.
Parmetros
value: o nmero a ser mapeado
fromLow: limite inferior da faixa atual de value
fromHigh: limite superior da faixa atual de value
toLow: limite inferior da faixa para a qual se quer mapear
toHigh: limite superior da faixa para a qual se quer mapear
Retorno
O valor mapeado.
Exemplo
/* Mapear uma entrada analgica de 10 bits para uma sada analgica de 8 bits (0 a 255) */
void setup() {}
void loop()
{
int val = analogRead(0);
val = map(val, 0, 1023, 0, 255);
analogWrite(9, val);
}
Apndice
Para aqueles com inclinao matemtica aqui est a funo completa:
long map(long x, long in_min, long in_max, long out_min, long out_max)
{
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
Pgina | 57
pow(base, expoente)
Descrio
Calcula o valor de um nmero elevado a uma potncia. Pow() pode ser utilizado com uma potncia
fracionria. til para gerar mapeamentos exponenciais de valores ou curvas.
Parmetros
base: o nmero(float)
expoente: a potncia qual a base elevada (float)
Retorno
Oresultado da exponeciao (double)
Exemplo
Veja a funo fscale na bibliteca de cdigo.
sq(x)
Descrio
Calcula o quadrado de um nmero. O nmero multiplicado por ele mesmo.
Parmetros
x: o nmero, qualquer tipo de dado
Retorno
o quadrado do nmero
sqrt(x)
Descrio
Calcula a raz quadrada de um nmero.
Parmetros
x: o nmero, qualquer tipo de dado
Retorno
double, a raz quadrada do nmero.
Pgina | 58
sin(rad)
Descrio
Calcula o seno de um ngulo (em redianos). O resultado ser entre -1 e 1.
Parmetros
rad: o ngulo em radianos (float)
Retorno
o seno do ngulo (double)
Nota
Serial.print() e Serial.println() atualmente no suportam floats.
cos(rad)
Descrio
Calcula o cosseno de um ngulo (em redianos). O resultado ser entre -1 e 1.
Parmetros
Retorno
o cosseno do ngulo (double)
Nota
tan(rad)
Descrio
Calcula a tangente de um ngulo (em redianos).
Parmetros
Retorno
a tangente do ngulo (double)
Nota
Pgina | 59
randomSeed(seed)
Descrio
randomSeed() inicializa um gerador de nmeros pseudo-aleatrios, fazendo com que a seqncia gerada
comece por um ponto arbitrrio de uma seqncia aleatria. Esta seqncia , embora muito longa e
aleatria, sempre a mesma.
Se for importante para uma seqncia de valores gerados pela funo random() ser diferente, a cada
execuo de um programa, use randomSeed() para inicializar o gerador de nmeros aleatrios a partir de
um valor tambm aleatrio, como um analogRead() de um pino que no esteja conectado.
De modo semelhante, pode ocasionalmente ser til usar seqncias pseudo-aleatrias que se repetem
exatamente a cada execuo de um programa. Isto pode ser obtido atravz da funo randomSeed() de
um nmero fixado, antes de se iniciar a seqncia aleatria.
Parmetros
long, int - um nmero para gerar o incio da seqncia.
Retorno
nenhum
Exemplo
long randNumber;
void setup(){
Serial.begin(9600);
randomSeed(analogRead(0));
}
void loop(){
randNumber = random(300);
Serial.println(randNumber);
delay(50);
}
Pgina | 60
random()
Descrio
A funo random gera nmeros pseudo-aleatrios.
Sintaxe
long random(max)
long random(min, max)
Parmetros
min - limite inferior do valor aleatrio, inclusivo (opcional)
max - limite superior do valor aleatrio, exclusivo
Retorno
long - um nmero aleatrio entre min e (max-1)
Note:
Se for importante para uma seqncia de valores gerados pela funo random() ser diferente, a cada
execuo de um programa, use randomSeed() para inicializar o gerador de nmeros aleatrios a partir de
um valor tambm aleatrio, como um analogRead() de um pino que no esteja conectado.
De modo semelhante, pode ocasionalmente ser til usar seqncias pseudo-aleatrias que se repetem
exatamente a cada execuo de um programa. Isto pode ser obtido atravz da funo randomSeed() de
um nmero fixado, antes de se iniciar a seqncia aleatria.
Exemplo
long randNumber;
void setup(){
Serial.begin(9600);
// se o pino de entrada analgica 0 no estiver conectado, rudo analgico
// aleatrio far com que a funo randomSeed() gere
// diferente nmeros de incio cada vez que o programa for executado.
// randomSeed() ir embralhar a funo random.
randomSeed(analogRead(0));
}
void loop() {
// imprime um nmero aleatrio entre 0 e 299
randNumber = random(300);
// imprime um nmero aleatrio entre 10 e 19
randNumber = random(10, 20);
delay(50);
}
Pgina | 61
Serial.begin(int velocidade)
Descrio
Ajusta o taxa de transferncia em bits por segundo (baud) para transmisso de dados pelo padro serial.
Para comunicao com um computador use uma destas taxas: 300, 1200, 2400, 4800, 9600, 14400,
19200, 28800, 57600, 115200. Voc pode, entretanto, especificar outras velocidades por exemplo para
comunicao atravs dos pinos 0 e 1 com um componente que requer uma taxa especfica.
Parameters
int velocidade, em bits por segundo (baud)
Retorno
nenhum
Exemplo:
void setup() {
Serial.begin(9600); // abre a porta serial e ajusta a taxa de transferncia de dados
para 9600 bps
}
void loop() {}
Exemplo para o Arduino Mega:
// Arduino Mega usando as quatro portas seriais simultaneamente
// (Serial, Serial1, Serial2, Serial3),
// com diferentes taxas de transferncia:
void setup(){
Serial.begin(9600);
Serial1.begin(38400);
Serial.println("Hello Computer");
Serial1.println("Hello Serial 1");
}
void loop() {}
Pgina | 62
int Serial.available()
Descrio
Obtem o nmero de bytes (caracteres) disponveis para leitura atravs da porta serial.
Parmetros
Nenhum
Retorno
O nmero de bytes disponveis para leitura no buffer serial. O buffer serial pode armazenar at 128 bytes.
Exemplo
int incomingByte = 0;
// para dados seriais que esto entrando
void setup() {
Serial.begin(9600); // abre a porta serial e ajusta a taxa de transferncia para
9600 bps
}
void loop() {
// envia dados apenas quando dados forem tambm recebidos:
if (Serial.available() > 0) {
// l o byte que est entrando:
incomingByte = Serial.read();
// diga o que voc recebeu:
Serial.print("Eu recebi : ");
Serial.println(incomingByte, DEC);
}
}
Exemplo para o Arduino Mega:
void setup() {
Serial.begin(9600);
}
void loop() {
// l na porta 0 e envia para a porta 1:
if (Serial.available()) {
int inByte = Serial.read();
Serial1.print(inByte, BYTE);
}
// l na porta 1 e envia para a porta 0:
if (Serial1.available()) {
int inByte = Serial1.read();
Serial.print(inByte, BYTE);
}
}
Pgina | 63
int Serial.read()
Descrio
L dados que estejam entrando pela porta serial.
Parmetros
Nenhum
Retorno
o primeiro byte disponvel na entrada da porta serial (ou -1 se no hover dados disponveis) int
Exemplo
int incomingByte = 0;
// para entrada serial
void setup() {
Serial.begin(9600); // abre a porta serial e ajusta a velocidade para 9600 bps
}
void loop() {
// envia dados apenas quando recebe dados:
if (Serial.available() > 0) {
// l o primeiro byte disponvel:
incomingByte = Serial.read();
// imprime na tela o byte recebido:
Serial.print("Eu recebi: ");
Serial.println(incomingByte, DEC);
}
}
Pgina | 64
Serial.flush()
Descrio
Esvasia o buffer de entrada da porta serial. Isto , qualquer chamada Serial.read() ou Serial.avaiable
somente retornaro dados recebidos aps a ltima chamada Serial.flush().
Parmetros
nenhum
Returns
nenhum
Serial.print(data)
Serial.print(data)
Descrio
Envia dados pela porta serial.
Parmetro
data: todos os tipos inteiros incluindo caracteres
Sintaxe
Este comando pode assumir diversas formas:
Serial.print(b) sem nenhum formato especificado, imprime b como um nmero decimal em uma string
ASCII. Por exemplo:
int b = 79;
Serial.print(b);
imprime a string ASCII "79".
Serial.print(b, DEC) imprime b como um nmero decimal em uma string ASCII. Por exemplo:
int b = 79;
Serial.print(b, DEC);
imprime a string ASCII "79".
Serial.print(b, HEX) imprime b como um nmero hexadecimal em uma string ASCII. Por exemplo:
int b = 79;
Serial.print(b, HEX);
imprime a string string "4F".
Serial.print(b, OCT) imprime b como um nmero octal em uma string ASCII. Por exemplo:
int b = 79;
Serial.print(b, OCT);
imprime a string "117".
Serial.print(b, BIN) imprime b como um nmero binrio em uma string ASCII. Por exemplo:
int b = 79;
Serial.print(b, BIN);
imprime a string "1001111".
Serial.print(b, BYTE) imprime b como um byte nico. Por exemplo:
int b = 79;
Serial.print(b, BYTE);
imprime a string "O" que o caractr ASCII representado pelo valor 79. Para mais informaes veja
a Tabela ASCII.
Pgina | 65
Serial.print(str) se str for uma string ou um array de chars imprime uma string ASCII. Por exemplo:
Serial.print("Hello World!");
imprime a string "Hello World!".
Parmetros
b: o byte a imprimir, ou
str: a string a imprimir
Retorno
Nenum
Exemplo:
/*
Usa um bloco FOR para dados e imprime um nmero em vrios formatos.
*/
int x = 0;
// varivel
void setup() {
Serial.begin(9600);
// abre a porta serial e ajusta a velocidade para 9600 bps
}
void loop() {
// imprime etiquetas
Serial.print("SEM FORMATO");
Serial.print("\t");
// imprime uma etiqueta
// imprime um tab
Serial.print("DEC");
Serial.print("\t");
Serial.print("HEX");
Serial.print("\t");
Serial.print("OCT");
Serial.print("\t");
Serial.print("BIN");
Serial.print("\t");
Serial.println("BYTE");
for(x=0; x< 64; x++){
// apenas parte da tabela ASCII
// imprime em vrios formatos

Serial.print(x);
Serial.print("\t");
// imprime um ASCII decimal - o mesmo que "DEC"

// imprime um tab
Serial.print(x, DEC); // imprime um ASCII decimal

Serial.print("\t");
// imprime um tab
Serial.print(x, HEX); // imprime um ASCII hexadecimal

Serial.print("\t");
// imprime um tab
Pgina | 66
Serial.print(x, OCT); // imprime um ASCII octal

Serial.print("\t");
// imprime um tab
Serial.print(x, BIN); // imprime um ASCII binario

Serial.print("\t");
// imprime um tab
Serial.println(x, BYTE);
// imprime como um byte nico e adciona um "cariage return"
//
com o "println"
delay(200);
// espera 200 millisegundos
}
Serial.println("");
// imprime outro carriage return
}
Dicas de programao e problemas conhecidos
Serial.print() no funciona com floats, portanto voc precisa fazer uma converso para um tipo inteiro,
perdendo a informao dos valores fracionrios. Em algumas situaes til multiplicar um float por uma
potncia de 10 para preservar (ao menos em parte) a informao fracionria.
Seja cuidadoso ao fazer clculos desntro dos parntesis e.g.
Serial.print(x-2, DEC);
Os tipos de dados unsigned char, e byte iro gerar resultados incorretos e atuar como se fossem do tipo
de dado assinalado.
A funo Serial.print envia os dados para um buffer. Ele esperar que um caractere seja enviado antes de
seguir para o prximo. Entretanto a funo envia o retorno antes de enviar o ltimo caractere
Pgina | 67
Serial.println()
Descrio
Imprime os dados para a porta serial como legvel texto ASCII seguido por um caractere retorno de carro
(ASCII 13, ou '\ r') e um caractere nova linha (ASCII 10, ou '\ n'). Este comando tem as mesmas formas
como Serial.print ().
Sintaxe
Serial.println (val)
Serial.println (val, formato)
Parmetros
val: o valor para impresso - qualquer tipo de dados
formato: especifica o nmero base (para tipos de dados integrais) ou o nmero de casas decimais (para
tipos de ponto flutuante)
Retorna
Nenhum
Example:
/*
Analog input
reads an analog input on analog in 0, prints the value out.
created 24 March 2006

by Tom Igoe
*/
int analogValue = 0;
// variable to hold the analog value
void setup() {
// open the serial port at 9600 bps:
Serial.begin(9600);
}
void loop() {
// read the analog input on pin 0:
analogValue = analogRead(0);
// print it out in many formats:

Serial.println(analogValue);
// print as an ASCII-encoded decimal
Serial.println(analogValue, DEC); // print as an ASCII-encoded decimal

Serial.println(analogValue, HEX); // print as an ASCII-encoded hexadecimal
Serial.println(analogValue, OCT); // print as an ASCII-encoded octal
Pgina | 68
Serial.println(analogValue, BIN); // print as an ASCII-encoded binary

Serial.println(analogValue, BYTE); // print as a raw byte value
// delay 10 milliseconds before the next reading:

delay(10);
}
break
break usado para sair de um bloco do, for, ou while, se sobrepondo condio normal de verificao.
Tambm usado para sair de uma sentena switch.
Examplo
for (x = 0; x < 255; x ++)
{
digitalWrite(PWMpin, x);
sens = analogRead(sensorPin);
if (sens > threshold){
// checar a deteco por um sensor
x = 0;
break;
}
delay(50);
}
Pgina | 69
Apostila feita por Eduardo Almeida (nareba).

A fonte dessa apostila foi tirada toda do site: http://multilogica-shop.com/Referencia que foi escrita por
Andr.
Pgina | 70

Programação Arduino

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Programação Arduino

Hochgeladen von

Copyright:

Verfügbare Formate

Programao

void setup ().............................................5

Entrada e sada digital

pinMode (pin, mode).....................................43

Usado para comunicao entre a placa Arduino e

digitalWrite (pin, value).................................44

um computador ou outros dispositivos. Esta

int digitalRead (pin).......................................45

comunicao ocorre atravs dos conectores

Entrada e sada analgica

digitais 0 (RX) e 1 (TX). Assim, se voc utilizar

int analogRead (pin)......................................46

estas funes no poder utilizar os pinos 0 e 1

analogWrite (pin, value) PWM....................47

para entrada e sada digital.

Entrada e sada avanada

shiftOut (dataPin, clockPin, bitOrder, value).48

unsigned long millis()....................................50

min (x, y).....................................................54

if (condicional) e ==, !=, <, > (operadores de

sentena switch / case

var - a varivel para a qual voc busca valores idnticos

// espera para que os sensores se estabilizem

x = readSensors(); // verifica o sensor

// criar saltos de execuo

Os principais usos das chaves

/* mas outro bloco de comentrio invlido */

Do mesmo modo o compilador gerar erros se aps o #define houver um =.

= operador de designao (sinal de igual simples)

// declera uma variavel do tipo inteiro com o nome de sensVal

// armazena o valor da voltagem (digitalizado) no pino

Adio, subtrao, multiplicao e diviso

if (condicional) e ==, !=, <, > (operadores de

Operadores de bits AND (&), OR (|), XOR (^)

(operando1 & operando2) - resultado de retorno

int c = a & b; // resultado:

(operando1 | operando2) - resultado de retorno

0000000001111101, ou 125 em decimal.

Nosso algoritmo para este programa deve:

// desvia os bits da variavel 2 bits para a esquerda para evitar os pino 0

// combina a informao da porta com a nova informao para os

pinos dos LEDs

(operando1 ^ operando2) - resultado de retorno

Um simpples cdigo de exemplo:

int z = x ^ y; // binario: 0110, or decimal 6

Operador de bits NOT (~)

// binario: 1111111110011000 = -104

desvio de bits para a esquerda (<<) e para a direita

int b = a << 3; // binario: 0000000000101000, ou 40 em decimal

int b = a << 14; // binario: 0100000000000000 - o primeiro 1 em 101 descartado

int y = x >> 3; // binario: 1111111111111110

int y = (unsigned int)x >> 3; // binario: 0001111111111110

operadores de bits compostos AND (&=) e OR (|=)

operador de bits composto AND (&=)

(operando1 & operando2) - resultado de retorno

operador de bits composto OR (|=)

(operando1 | operando2) - resultado de retorno

// x agora contm 3, y contm 3

Definindo nveis lgicos, verdadeiro e falso (constantes booleanas)

Definindo nveis de pinos, HIGH e LOW

Definindo pinos digitais, INPUT e OUTPUT

Pinos configurados como outputs

'B' inicial somente valores de 8 bits (0 a 255) caracteres vlidos 0-1

caractres vlidos: 0-7