Gleykson Henrique Norte de Macedo

A estrutura bsica da linguagem de programao do Arduino bastante simples; ela

formada por dois blocos de funes que carregam outros blocos de funes escritas em
linguagem C/C++.
O primeiro bloco de funes forma a funo setup( ) ; o segundo ,a funo loop ( ).

Funes: Em linguagens de programao so como sub-rotinas ou procedimentos; so
pequenos blocos de programas usados para monta o programa principal. Elas so
escritas pelo programador para realizar tarefas repetitivas, ou pode ser importadas
prontas para o programa em forma de bibliotecas.

setup ( ) : Essa a primeira funo a ser chamada quando o programa inicia. E
executada apenas nessa primeira vez. Esta uma funo de preparao: ela dita o
comportamento dos pinos do Arduino e inicializa a porta serial.

Loop ( ): A funo chamada logo a seguir e todas as funes embarcadas nela so
repetidamente executadas. Ela fica lendo os pinos de entrada do Arduino e comanda os
pinos de sada e a porta serial.

Exemplo:
// aes so realizadas nas funes "Setup" e "Loop"
// Mas nenhuma informao comunicada ao programa maior

void setup ()
{
// ...
}

void loop ()
{
// ...
}

Pinmode: Configura o pino especificado se comportar tanto como uma entrada ou uma
sada. Veja a descrio dos pinos digitais para obter detalhes sobre a funcionalidade dos
pinos.
A partir do Arduino 1.0.1, possvel ativar os resistores pull-up internas com a
INPUT_PULLUP modo. Alm disso, o modo de entrada desativa explicitamente os pullups
internos.

Exemplo:

int ledPin = 13; // LED conectado ao pino digital 13

void setup ()
{
pinMode (ledPin, OUTPUT); // define o pino digital como sada
}

void loop ()
{
digitalWrite (ledPin, HIGH); // define o LED
atraso (1000); // aguarda uma segunda
digitalWrite (ledPin, LOW); // define o LED
atraso (1000); // aguarda uma segunda
}


Digitalread: L o valor de um pino digital especificado, ou ALTA ou BAIXA .

Exemplo:
Define o pino 13 para o mesmo valor que o pino 7, declarada como uma entrada.
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 (ledPin, OUTPUT); // define o pino digital 13 como sada
pinMode (inPin, INPUT); // define o pino digital 7 como entrada
}

void loop ()
{
val = digitalRead (inPin); // ler o pino de entrada
digitalWrite (ledPin, val); // define o LED para o valor do boto
}


digitalwrite: Escreva uma ALTA ou BAIXA valor a um pino digital.
Se o pino foi configurado como uma sada com pinMode (), a tenso ser definido como o
valor correspondente: 5V (ou em placas de 3.3V 3.3V) em alta, 0V (terra) para LOW.
Se o pino configurado como um INPUT, digitalWrite () ir permitir (HIGH) ou desabilitar
(baixo) o pull-up interno no pino de entrada. Recomenda-se a definir o pinMode ()
para INPUT_PULLUP para habilitar o resistor de pull-up interno.

Exemplo

int ledPin = 13; // LED conectado ao pino digital 13

void setup ()
{
pinMode (ledPin, OUTPUT); // Ajusta o pino de sada digital como
}

void loop ()
{
digitalWrite (ledPin, HIGH); // Define o LED
delay (1000); // Aguarda uma segunda
digitalWrite (ledPin, LOW); // Define o LED
delay (1000); // Aguarda uma segunda
}


Analogreference: Configura a tenso de referncia utilizada para a entrada analgico
(isto , o valor utilizado como a parte superior do intervalo de entrada). As opes so:
PADRO: a referncia analgica padro de 5 volts (em placas de 5V do Arduino) ou 3,3
volts (em placas Arduino 3.3V)
INTERNO: um built-in de referncia, igual a 1,1 volts no ATmega168 ou ATmega328 e
2,56 volts na ATmega8 (no disponvel no Arduino mega)
INTERNAL1V1: uma referncia 1.1V built-in (Arduino mega s)
INTERNAL2V56: um built-in 2.56V de referncia (Arduino mega s)
EXTERNO: a tenso aplicada ao pino AREF (0 a apenas 5 V) usado como a referncia.

Analogread: L o valor do pino analgico especificado. A placa Arduino contm um 6
canais (8 canais no Mini e Nano, 16 na mega), 10-bit conversor analgico-digital. Isso sig-
nifica que ele ir mapear tenses de entrada entre 0 e 5 volts em valores inteiros entre 0 e
1023 Isso gera uma resoluo entre as leituras de: 5 volts / 1024 unidades, ou 0,0049
volts (4,9 mV) por unidade. O alcance ea resoluo de entrada pode ser alterada utilizan-
do analogReference ().
Demora cerca de 100 microssegundos (0,0001 s) para ler uma entrada analgica, ento a
taxa mxima de leitura de cerca de 10 mil vezes por segundo.

Exemplo:

int analogPin = 3; // do potencimetro (terminal central) ligado ao pino analgico 3
// Exterior leva ao cho e + 5V
int val = 0; // varivel para armazenar o valor lido
void setup ()
{
Serial comear (9600);. // Srie de configurao
}
void loop ()
{
val = analogRead (analogPin); // ler o pino de entrada
. Serial println (val); // valor de depurao
}

Analogwrite : Grava um valor analgico ( onda PWM ) a um pino. Pode ser usado para
acender um LED em diferentes brilhos ou acionar um motor em vrias velocidades. Aps
uma chamada para analogWrite (), o pino ir gerar uma onda quadrada constante do ciclo
de trabalho especificado at a prxima chamada para analogWrite () (ou uma chamada
para digitalRead () oudigitalWrite () no mesmo pino). A frequncia do sinal PWM na maio-
ria dos pinos de aproximadamente 490 Hz. Nas placas Uno e similares, pinos 5 e 6 tm
uma freqncia de cerca de 980 Hz. Pinos 3 e 11 sobre o Leonardo tambm executar em
980 Hz.
Na maioria das placas Arduino (aqueles com os ATmega168 ou ATmega328), essa fun-
o funciona nos pinos 3, 5, 6, 9, 10 e 11 No Arduino Mega, que funciona nos pinos 2-13
e 44 - 46 Older Arduino placas com um ATmega8 suportam apenas analogWrite () nos
pinos 9, 10 e 11.
O Arduino Devido suporta analogWrite () nos pinos 2 a 13, alm de pi-
nos DAC0 e DAC1. Ao contrrio dos pinos PWM,DAC0 e DAC1 so de digital para anal-
gico, e agir sadas analgicas como verdadeiros.
Voc no precisa chamar pinMode () para definir o pino como uma sada antes de chamar
analogWrite ().
A funo analogWrite no tem nada a ver com os pinos analgicos ou a fun-
o analogRead.


Exemplo:
Define a sada para a proporcional LED para o valor lido do potencimetro.



Int ledPin = 9; // LED conectado ao pino digital 9
int analogPin = 3; // potencimetro conectado ao pino analgico 3
int val = 0; // varivel para armazenar o valor lido
void setup ()
{
pinMode (ledPin, OUTPUT); // define o pino como sada
}
void loop ()
{
val = analogRead (analogPin); // ler o pino de entrada
analogWrite (ledPin, val / 4); // analogRead valores vo de 0 a 1023, os valores analo-
gWrite 0-255

}


Delay: Interrompe o programa para a quantidade de tempo (em milisegundos) especifica-
do como parmetro. (Existem 1.000 milissegundos em um segundo.)
Exemplo:
int ledPin = 13; // LED conectado ao pino digital 13

void setup ()
{
pinMode (ledPin, OUTPUT); // define o pino digital como sada
}

void loop ()
{
digitalWrite (ledPin, HIGH); // define o LED
atraso (1000); // aguarda uma segunda
digitalWrite (ledPin, LOW); // define o LED
atraso (1000); // aguarda uma segunda

Mills ( ) : Retorna o nmero de milissegundos desde a placa Arduino comeou a executar
o programa atual. Este nmero vai transbordar (voltar para zero), aps cerca de 50 dias.

Exemplo
longo perodo de tempo sem assinatura;
void setup ()
{Serial.begin (9600);
}
Void loop () {
Serial.print ("Time:");
tempo = Millis (); // Imprime o tempo desde que o programa comeou Serial.println (tem-
po); // Espere um segundo, de modo a no enviar grandes quantidades de dados delay
(1000); }


Bibliotecas : O ambiente Arduino pode ser estendido atravs da utilizao de bibliotecas,
assim como a maioria das plataformas de programao. As bibliotecas proporcionam fun-
cionalidade extra para uso em esboos, por exemplo, trabalhar com hardware ou manipu-
lao de dados. Um nmero de bibliotecas vm instalados com o IDE, mas voc tambm
pode fazer o download ou criar o seu prprio. Veja as instrues para obter detalhes so-
bre a instalao de bibliotecas. H tambm um tutorial sobre como escrever suas prprias
bibliotecas .
Consulte o Guia de Estilo API para obter informaes sobre como fazer uma boa API Ar-
duino estilo para a sua biblioteca.
Para usar uma biblioteca em um esboo, selecione-o esboo> Import Library.
Bibliotecas Padro
EEPROM - leitura e escrita para armazenamento "permanente"
Ethernet - para conexo com a internet usando o Arduino Ethernet Shield
Firmata - para se comunicar com os aplicativos no computador, utilizando um protocolo
serial padro.
GSM - para conectar a uma rede / GRPS GSM com o escudo GSM.
LiquidCrystal - para controlar telas de cristal lquido (LCDs)
SD - para ler e escrever cartes SD
Servo - para controlar servo motores
SPI - para se comunicar com dispositivos que utilizam a Interface Perifrica Serial (SPI)
Bus
SoftwareSerial - para comunicao serial em qualquer pinos digitais. Verso 1.0 e poste-
rior do Arduino incorporar Mikal Hartbiblioteca NewSoftSerial 's como SoftwareSerial.
Stepper - para controlar motores de passo
TFT - para o desenho de texto, imagens e formas na tela do Arduino TFT
WiFi - para se conectar internet usando o escudo Arduino WiFi
Fio - Dois Fios Interface (TWI / I2C) para enviar e receber dados atravs de uma rede de
dispositivos ou sensores.
As bibliotecas de Matrix e Sprite no fazem mais parte da distribuio do ncleo.


# include : usado para incluir bibliotecas externas em seu esboo. Isto d o acesso
programador para um grande grupo de bibliotecas padro C (grupos de funes pr-
fabricados), e tambm bibliotecas escrito especialmente para Arduino.
Exemplo:
Este exemplo inclui uma biblioteca que utilizado para colocar os dados na mem-
ria flash espao programa, em vez decarneiro. Isso economiza o espao de memria
RAM para as necessidades de memria dinmica e faz grandes tabelas de pesquisa mais
prtica.
# include <avr / pgmspace.h>

myConstants prog_uint16_t [] PROGMEM = {0, 21140, 702, 9128, 0, 25764, 8456,
0,0,0,0,0,0,0,0,29810,8968,29762,29762,4500};


#define: um componente til C que permite que o programador para dar um nome a um
valor constante antes do programa ser compilado. Constantes definidas na arduino no
ocupam qualquer espao de memria programa no chip.O compilador ir substituir as re-
ferncias a essas constantes com o valor definido em tempo de compilao.
Isto pode ter alguns efeitos colaterais indesejados que, se, por exemplo, um nome cons-
tante que tinha sido #defined est includo em qualquer outro nome constante ou vari-
vel. Nesse caso, o texto poderia ser substitudo pelo nmero #defined (ou texto).
Em geral, o const palavra-chave a preferida para as constantes que definem e deve ser
utilizado em vez de #define.
Arduino define tm a mesma sintaxe de C define:

Exemplo:
#define ledPin 3
// O compilador ir substituir qualquer meno de ledPin com o valor 3 em tempo de
compilao.


LiquidCrystal.h : Esta biblioteca permite que uma placa Arduino para controlar
exibe LiquidCrystal (LCD) com base na Hitachi HD44780(ou compatvel) chipset, que
encontrado na maioria dos LCDs baseadas em texto. A biblioteca funciona com no modo
de 4 ou 8 bits (isto , usando quatro ou oito linhas de dados para alm das rs, permitir, e,
opcionalmente, as linhas de controlo rw).


Variveis: Uma varivel uma forma de nomear e guardar um valor para usar
depois pelo programa, como dados de um sensor, ou ainda, um valor intermedirio
de um clculo.
Declarando Variveis
Antes de serem utilizadas, as variveis devem ser declaradas. Declarar uma varivel
significa definir seu tipo, e opcionalmente, configurar um valor inicial (iniciar a varivel).
Variveis no precisam ser iniciadas (conferidas um valor) quando estas so declaradas,
mas muitas vezes se faz til.
int inputVariable1; // iniciando varivel
int inputVariable2 = 0; // iniciando e atribuindo valor
Programadores devem considerar o tamanho dos nmeros que desejam guardar,
escolhendo o tipo da varivel. Variveis sobrecarregam quando o valor excede o espao
designado para guard-lo. Veja abaixo por exemplo.
Escopo da Varivel
Outra escolha importante que os programadores enfrentam onde declarar as variveis?
O lugar especfico que as variveis so declaradas influencia como vrias funes do
programa aenxergaro. Isto chamado de escopo.
Iniciando Variveis
Variveis devem ser iniciadas (designadas um valor) no momento que elas so
declaradas ou depois. sempre uma boa prtica de programao verificar que uma
varivel tenha dados vlido dentro dela, antes de ser utilizada.
Exemplo:
int calibrationVal = 17; // declara calibrationVal e configura seu valor
// inicial
Sobrecarga da Varivel
Quando variveis tm seu valor excedido pela capacidade mxima do seu tipo, elas
sobrecarregam e voltam para seu valor mnimo. Isto acontece em ambas direes.
int x
x = -32,768;
x = x - 1; // x contm 32,767 - sobrecarrega na direo negativa
x = 32,767;
x = x + 1; // x contm -32,768 sobrecarrega
Usando Variveis
Uma vez que variveis tenham sido declaradas, elas podem ser usadas configurando a
varivel para o valor que se deseja armazenar, atravs do operador de atribuio (um
sinal de igual). O operador de atribuio diz ao programa para atribuir o que estiver do
lado direito do sinal de igual, dentro da varivel que deve ficar do lado esquerdo do sinal
de igual.
inputVariable1 = 7; // configura varivel chamada inputVariable1
// atribuindo o valor 7
inputVariable2 = analogRead(2); // configura varivel chamada inputVariable2
// atribuindo a voltagem lida de uma porta
// analgica 2
Exemplos:
int lightSensVal;
char currentLetter;
unsigned long speedOfLight = 186000UL;
char errorMessage = {"escolha outra impresso"}; // vide: string

Uma vez que a varivel tenha sido configurada (conferida um valor), voc pode testar seu
valor para verificar se atende determinada condio, ou usar seu valor diretamente. Por
exemplo, o cdigo a seguir testa se o valor da varivel inputVariable2 menor que 100,
ento configurando um atraso (delay) baseado no valor de inputVariable2, que no
mnimo 100.
if (inputVariable2 < 100)
{
inputVariable2 = 100;
}

delay(inputVariable2);

Este exemplo mostra todas as trs operaes teis que se pode fazer com variveis. Ele
testa a varivel (if (inputVariable2 < 100)), configura o valor 100 caso o teste tenha
passado(inputVariable2 = 100), e utiliza o valor armazenado na varivel como parmetro
de entrada na funo delay(delay(inputVariable2)).

Escopo das Variveis
Variveis na linguagem C, que o Arduino usa, tem uma caracterstica conhecida
por escopo. Isto um contraste com linguagens como BASIC que qualquer varivel
uma varivelglobal.
Uma varivel global uma que pode ser vista por qualquer funo dentro de um
programa. Variveis locais so apenas visveis para a funo na qual foram declaradas.
No ambiente do Arduino, qualquer varivel declarada fora de uma funo (ex. setup, loop,
etc.), considerada uma varivel global.
Quando programas comeam a ficar grandes e mais complexos, variveis locais so teis
para garantir que apenas uma funo ter acesso apenas as suas prprias variveis. Isso
evita erros de programao quando uma funo inadvertidamente, modifica o valor de
variveis utilizadas por outra funo.
Algumas vezes til declarar e iniciar uma varivel interna para umlao (loop). Assim
criamos uma varivel que possa apenas ser acessada na parte interna das chaves {}
do lao-for.
Exemplo:
int gPWMval; // qualquer funo acessa essa varivel

void setup()
{
// ...
}

void loop()
{
int i; // "i" apenas "visvel" dentro da funo "loop"
float f; // "f" apenas "visvel" dentro da funo "loop"
// ...

for (int j = 0; j <100; j++){
// varivel j pode ser apenas
// acessada dentro das chaves do lao-for

Os operadores booleanos: Estes podem ser usados dentro da condio de um caso comunicado.
&& (AND lgico)
Verdadeiro somente se ambos os operandos so verdadeiros, por exemplo,
if (digitalRead (2) == ALTA && digitalRead (3) == HIGH) {// ler dois interruptores
// ...
}
verdadeiro somente se ambas as entradas so altas.
|| (Ou lgico)
True se o operando verdade, por exemplo,
se (x> 0 || y> 0) {
// ...
}
verdade que ou x ou y maior do que 0.
! (No)
True se o operando falso, por exemplo,
if (! x) {
// ...
}
verdadeiro se x falsa (ou seja, se x igual a 0).


If: sempre utilizado em conjunto com os operadores de comparao, ele testa se um
certa condio foi alcanada, como por exemplo se uma varivel atingiu um certo valor. O
formato para testes com o (if) o seguinte:
if (algumaVariavel > 50)
{
// faa algo aqui
}

O programa testa pra ver se algumaVariavel maior do que 50. Se for, o programa exe-
cuta uma determinada ao. Ou seja, se o que estiver declarado nos parnteses for ver-
dadeiro, as instrues entre as chaves so executadas. Se no, o programa pula para a
prxima parte do cdigo.
Caso voc omitas as chaves aps a declarao do if, apenas uma instruo ser execu-
tada apos o teste condicional, veja os exemplos:
if (x > 120) digitalWrite(pinoLED, HIGH);
/*notem que no existe chaves, isto implica que caso a
condio x>120 for verdadeira, apenas o comando digitalWrite ser executado */

if (x > 120)
digitalWrite(pinoLED, HIGH);

if (x > 120){ digitalWrite(pinoLED, HIGH); }

if (x > 120){
digitalWrite(LEDpino1, HIGH);
digitalWrite(LEDpino2, HIGH);
} // todas as formas esto corretas


As declaraes que esto sendo verificadas dentro dos parnteses requerem o uso de um
ou mais 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 que ou igual a y)
x >= y (x maior que ou igual a y)
For: A instruo for usada para repetir um bloco de instrues definido entre as
chaves. Geralmente utiliza-se um contador para incrementar e finalizar o loop. A
instruo for til para quaisquer operaes repetitivas.
for (inicializao; condio; incremento)
{
//instruo(ou instrues);

}

A inicializao ocorre primeiramente e somente uma vez. A cada interao do loop, acon-
dio testada; se for verdadeira a instruo dentro do bloco e o incremento so execu-
tados, caso contrrio , se a condio for falsa o loop terminado.
Exemplo:
// Dimmer de um LED usando um pino PWM como sada

int pinoPWM = 10; // LED ligado em srie com um resistor de 1k ao pino 10

void setup()
{
// no necessrio setup
}

void loop()
{
for (int i= 0; i <= 255; i++){
// a varivel i incrimentada at que valha 255,
//depois o loop terminado
analogWrite(pinoPWM, i);
//o valor de i escrito no pinoPWM
delay(10);
}
}




if : O que usado em conjuno com um operador de comparao, os testes se uma de-
terminada condio tem sido alcanado, tal como uma entrada de estar acima de um cer-
to nmero de. O formato para um caso de teste :
if (someVariable> 50)
{
// Fazer algo aqui
}
Os testes do programa para ver se someVariable maior do que 50 Se for, o programa
toma uma aco especfica. Dito de outra forma, se a declarao em parnteses verda-
de, as instrues dentro dos colchetes so executados. Se no, o programa salta sobre o
cdigo.
Os suportes podem ser omitidos aps uma instruo if. Se isso for feito, a prxima linha
(definido pelo ponto e vrgula) torna-se a nica declarao condicional.

if (x> 120) digitalWrite (ledPin, HIGH);

se (x> 120)
digitalWrite (ledPin, HIGH);

if (x> 120) {digitalWrite (ledPin, HIGH); }

se (x> 120) {
digitalWrite (LEDpin1, HIGH);
digitalWrite (LEDpin2, HIGH);
} // Todos esto corretos

As declaraes a ser avaliado dentro dos parnteses requerem o uso de um ou mais ope-
radores:


if / else: Permite maior controle sobre o fluxo de cdigo do que o bsico se instruo,
permitindo que vrios testes sejam agrupados. Por exemplo, uma entrada analgica, po-
dem ser testadas e uma aco feita se a entrada foi de menos de 500, e uma outra aco
feita se a entrada foi de 500 ou maior. O cdigo ficaria assim:
if (pinFiveInput <500)
{
A ao //
}
mais
{
// Ao B
}
mais pode proceder de outra, se teste, de modo que vrias, testes mutuamente exclusivos
pode ser executado ao mesmo tempo.
Cada teste vai avanar para a prxima at que um teste verdadeiro encontrado. Quando
um teste verdadeiro encontrado, seu bloco associado de cdigo executado, e em se-
guida, o programa salta para a linha seguinte inteira if / else construo. Se nenhum
teste prova ser verdadeiro, o mais padro do bloco executado, se estiver presente, e
define o comportamento padro.
Note-se que uma outra se o bloco pode ser usada com ou sem um outro bloco de termi-
nais e vice-versa. Um nmero ilimitado de tais else if ramos permitido.
if (pinFiveInput <500)
{
// Fazer Coisa A
}
else if (pinFiveInput> = 1000)
{
// Faz coisa B
}
mais
{
// Faz coisa C
}



if / else: permite maior controle sobre o fluxo de cdigo do que o bsico se instruo,
permitindo que vrios testes sejam agrupados. Por exemplo, uma entrada analgica, po-
dem ser testadas e uma aco feita se a entrada foi de menos de 500, e uma outra aco
feita se a entrada foi de 500 ou maior. O cdigo ficaria assim:
if (pinFiveInput <500)
{
A ao //
}
mais
{
// Ao B
}
mais pode proceder de outra, se teste, de modo que vrias, testes mutuamente exclusivos
pode ser executado ao mesmo tempo.
Cada teste vai avanar para a prxima at que um teste verdadeiro encontrado. Quando
um teste verdadeiro encontrado, seu bloco associado de cdigo executado, e em se-
guida, o programa salta para a linha seguinte inteira if / else construo. Se nenhum
teste prova ser verdadeiro, o mais padro do bloco executado, se estiver presente, e
define o comportamento padro.
Note-se que uma outra se o bloco pode ser usada com ou sem um outro bloco de termi-
nais e vice-versa. Um nmero ilimitado de tais else if ramos permitido.
if (pinFiveInput <500)
{
// Fazer Coisa A
}
else if (pinFiveInput> = 1000)
{
// Faz coisa B
}
mais
{
// Faz coisa C
}


For: O comando for usado para repetir um bloco de instrues entre chaves. Um conta-
dor de incremento normalmente usado para aumentar e terminar o loop. O comando
for til para qualquer operao repetitiva, e frequentemente usado em combinao
com matrizes para operar em colees de dados / pinos.
Existem trs partes para o cabealho para loop:
for ( initialization ; condition ; increment ) {
//statement(s);
}

A inicializao acontece primeiro e exatamente uma vez. Cada vez atravs do loop,
a condio testada; se for verdade, o bloco de declarao, eo incremento executada,
ento a condio testada novamente. Quando a condio se torna falsa, o loop termina.
Exemplo
// Dim um LED usando um pino PWM
int PWMpin = 10; // LED em srie com 470 ohm resistor no pino 10

void setup ()
{
// Nenhuma instalao necessria
}

void loop ()
{
for (int i = 0; i <= 255; i ++) {
analogWrite (PWMpin, i);
atraso (10);
}
}


Switch case: Controla o fluxo de programas, permitindo que programadores especificar
cdigo diferente que deve ser executada em vrias condies. Em particular, uma instru-
o switch compara o valor de uma varivel para os valores especificados nas declara-
es de caso. Quando uma instruo case encontrada cujo valor corresponde ao da
varivel, o cdigo em que a declarao caso executado.
A palavra-chave break sai a instruo switch, e normalmente usado no final de cada
caso. Sem uma instruo break, o switch ir continuar a executar as seguintes expres-
ses ("cair-through"), at que uma pausa, ou o fim da instruo switch atingido.
Exemplo:
switch (var) {
case 1:
// Fazer algo quando var igual a 1
break;
case 2:
// Fazer algo quando var igual a 2
break;
default:
// Se nada mais partidas, faa o padro
// Default opcional
}


While: Ir repetir continuamente e infinitamente, at que a expresso dentro dos parnte-
ses, () torna-se falsa. Algo precisa mudar a varivel testada, ou o loop while nunca vai
sair. Este poderia ser o seu cdigo, como uma varivel incrementado, ou uma condio
externa, tais como teste de um sensor.
Exemplo:
var = 0;
enquanto (var <200) {
// fazer algo repetitivas 200 vezes
var ++;
}
do-while: A fazer obras circular da mesma maneira como o lao enquanto, com a excep-
o de que a condio testada no final do ciclo, de modo a fazer circular
ir sempre executar, pelo menos, uma vez.
fazer
{
// Bloco de declarao
} Enquanto (condio de teste);

Exemplo
fazer
{
atraso (50); // Esperar para sensores para estabilizar
x = readSensors (); // Verificar os sensores

} while (x <100);


Referncia:


http://renatoaloi.blogspot.com.br/2011/11/variaveis-do-arduino.html
http://arduino.cc/en/