Embed Size (px)
Citation preview
Gleykson Henrique Norte de Macedo
A estrutura básica da linguagem de programação do Arduino é bastante simples; ela é
formada por dois blocos de funções que carregam outros blocos de funções escritas em
linguagem C/C++.
O primeiro bloco de funções forma a função setup( ) ; o segundo ,a função loop ( ).
Funções: Em linguagens de programação são como sub-rotinas ou procedimentos; são
pequenos blocos de programas usados para monta o programa principal. Elas são
escritas pelo programador para realizar tarefas repetitivas, ou pode ser importadas
prontas para o programa em forma de bibliotecas.
setup ( ) : Essa é a primeira função a ser chamada quando o programa inicia. E é
executada apenas nessa primeira vez. Esta é uma função de preparação: ela dita o
comportamento dos pinos do Arduino e inicializa a porta serial.
Loop ( ): A função é chamada logo a seguir e todas as funções embarcadas nela são
repetidamente executadas. Ela fica lendo os pinos de entrada do Arduino e comanda os
pinos de saída e a porta serial.
Exemplo:
// ações são realizadas nas funções "Setup" e "Loop"
// Mas nenhuma informação é comunicada ao programa maior
void setup ()
{
// ...
}
void loop ()
{
// ...
}
Pinmode: Configura o pino especificado se comportar tanto como uma entrada ou uma
saída. Veja a descrição dos pinos digitais para obter detalhes sobre a funcionalidade dos
pinos.
A partir do Arduino 1.0.1, é possível ativar os resistores pull-up internas com a
INPUT_PULLUP modo. Além 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 saída
}
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; // botão conectado ao pino digital 7
int val = 0; // variável para armazenar o valor lido
void setup ()
{
pinMode (ledPin, OUTPUT); // define o pino digital 13 como saída
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 botão
}
digitalwrite: Escreva uma ALTA ou BAIXA valor a um pino digital.
Se o pino foi configurado como uma saída com pinMode (), a tensão 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 saída 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 tensão de referência utilizada para a entrada analógico
(isto é, o valor utilizado como a parte superior do intervalo de entrada). As opções são:
PADRÃO: a referência analógica padrão de 5 volts (em placas de 5V do Arduino) ou 3,3
volts (em placas Arduino 3.3V)
INTERNO: um built-in de referência, igual a 1,1 volts no ATmega168 ou ATmega328 e
2,56 volts na ATmega8 (não disponível no Arduino mega)
INTERNAL1V1: uma referência 1.1V built-in (Arduino mega só)
INTERNAL2V56: um built-in 2.56V de referência (Arduino mega só)
EXTERNO: a tensão aplicada ao pino AREF (0 a apenas 5 V) é usado como a referência.
Analogread: Lê o valor do pino analógico especificado. A placa Arduino contém um 6 canais (8 canais no Mini e Nano, 16 na mega), 10-bit conversor analógico-digital. Isso sig-nifica que ele irá mapear tensões de entrada entre 0 e 5 volts em valores inteiros entre 0 e 1023 Isso gera uma resolução entre as leituras de: 5 volts / 1024 unidades, ou 0,0049 volts (4,9 mV) por unidade. O alcance ea resolução de entrada pode ser alterada utilizan-do analogReference ().
Demora cerca de 100 microssegundos (0,0001 s) para ler uma entrada analógica, então a
taxa máxima de leitura é de cerca de 10 mil vezes por segundo.
Exemplo:
int analogPin = 3; // do potenciômetro (terminal central) ligado ao pino analógico 3
// Exterior leva ao chão e + 5V
int val = 0; // variável para armazenar o valor lido
void setup ()
{
Serial começar (9600);. // Série de configuração
}
void loop ()
{
val = analogRead (analogPin); // ler o pino de entrada
. Serial println (val); // valor de depuração
}
Analogwrite : Grava um valor analógico ( onda PWM ) a um pino. Pode ser usado para
acender um LED em diferentes brilhos ou acionar um motor em várias velocidades. Após
uma chamada para analogWrite (), o pino irá gerar uma onda quadrada constante do ciclo
de trabalho especificado até a próxima chamada para analogWrite () (ou uma chamada
para digitalRead () oudigitalWrite () no mesmo pino). A frequência do sinal PWM na maio-
ria dos pinos é de aproximadamente 490 Hz. Nas placas Uno e similares, pinos 5 e 6 têm
uma freqüência de cerca de 980 Hz. Pinos 3 e 11 sobre o Leonardo também 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, além de pi-
nos DAC0 e DAC1. Ao contrário dos pinos PWM,DAC0 e DAC1 são de digital para analó-
gico, e agir saídas analógicas como verdadeiros.
Você não precisa chamar pinMode () para definir o pino como uma saída antes de chamar
analogWrite ().
A função analogWrite não tem nada a ver com os pinos analógicos ou a fun-
ção analogRead.
Exemplo:
Define a saída para a proporcional LED para o valor lido do potenciômetro.
Int ledPin = 9; // LED conectado ao pino digital 9
int analogPin = 3; // potenciômetro conectado ao pino analógico 3
int val = 0; // variável para armazenar o valor lido
void setup ()
{
pinMode (ledPin, OUTPUT); // define o pino como saída
}
void loop ()
{
val = analogRead (analogPin); // ler o pino de entrada
analogWrite (ledPin, val / 4); // analogRead valores vão de 0 a 1023, os valores analo-
gWrite 0-255
}
Delay: Interrompe o programa para a quantidade de tempo (em milisegundos) especifica-
do como parâmetro. (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 saída
}
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 número de milissegundos desde a placa Arduino começou a executar
o programa atual. Este número vai transbordar (voltar para zero), após cerca de 50 dias.
Exemplo
longo período de tempo sem assinatura;
void setup ()
{Serial.begin (9600);
}
Void loop () {
Serial.print ("Time:");
tempo = Millis (); // Imprime o tempo desde que o programa começou Serial.println (tem-
po); // Espere um segundo, de modo a não enviar grandes quantidades de dados delay
(1000); }
Bibliotecas : O ambiente Arduino pode ser estendido através da utilização de bibliotecas,
assim como a maioria das plataformas de programação. As bibliotecas proporcionam fun-
cionalidade extra para uso em esboços, por exemplo, trabalhar com hardware ou manipu-
lação de dados. Um número de bibliotecas vêm instalados com o IDE, mas você também
pode fazer o download ou criar o seu próprio. Veja as instruções para obter detalhes so-
bre a instalação de bibliotecas. Há também um tutorial sobre como escrever suas próprias
bibliotecas .
Consulte o Guia de Estilo API para obter informações sobre como fazer uma boa API Ar-
duino estilo para a sua biblioteca.
Para usar uma biblioteca em um esboço, selecione-o esboço> Import Library.
Bibliotecas Padrão
EEPROM - leitura e escrita para armazenamento "permanente"
Ethernet - para conexão com a internet usando o Arduino Ethernet Shield
Firmata - para se comunicar com os aplicativos no computador, utilizando um protocolo
serial padrão.
GSM - para conectar a uma rede / GRPS GSM com o escudo GSM.
LiquidCrystal - para controlar telas de cristal líquido (LCDs)
SD - para ler e escrever cartões SD
Servo - para controlar servo motores
SPI - para se comunicar com dispositivos que utilizam a Interface Periférica Serial (SPI)
Bus
SoftwareSerial - para comunicação serial em qualquer pinos digitais. Versão 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 através de uma rede de
dispositivos ou sensores.
As bibliotecas de Matrix e Sprite não fazem mais parte da distribuição do núcleo.
# include : é usado para incluir bibliotecas externas em seu esboço. Isto dá o acesso
programador para um grande grupo de bibliotecas padrão C (grupos de funções pré-
fabricados), e também bibliotecas escrito especialmente para Arduino.
Exemplo:
Este exemplo inclui uma biblioteca que é utilizado para colocar os dados na memó-
ria flash espaço programa, em vez decarneiro. Isso economiza o espaço de memória
RAM para as necessidades de memória dinâmica e faz grandes tabelas de pesquisa mais
prática.
# 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 não
ocupam qualquer espaço de memória programa no chip.O compilador irá substituir as re-
ferências a essas constantes com o valor definido em tempo de compilação.
Isto pode ter alguns efeitos colaterais indesejados que, se, por exemplo, um nome cons-
tante que tinha sido #defined está incluído em qualquer outro nome constante ou variá-
vel. Nesse caso, o texto poderia ser substituído pelo número #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 têm a mesma sintaxe de C define:
Exemplo:
#define ledPin 3
// O compilador irá substituir qualquer menção de ledPin com o valor 3 em tempo de
compilação.
LiquidCrystal.h : Esta biblioteca permite que uma placa Arduino para controlar
exibe LiquidCrystal (LCD) com base na Hitachi HD44780(ou compatível) 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 além das rs, permitir, e,
opcionalmente, as linhas de controlo rw).
Variáveis: Uma variável é uma forma de nomear e guardar um valor para usar
depois pelo programa, como dados de um sensor, ou ainda, um valor intermediário
de um cálculo.
Declarando Variáveis
Antes de serem utilizadas, as variáveis devem ser declaradas. Declarar uma variável
significa definir seu tipo, e opcionalmente, configurar um valor inicial (iniciar a variável).
Variáveis não precisam ser iniciadas (conferidas um valor) quando estas são declaradas,
mas muitas vezes se faz útil.
int inputVariable1; // iniciando variável
int inputVariable2 = 0; // iniciando e atribuindo valor
Programadores devem considerar o tamanho dos números que desejam guardar,
escolhendo o tipo da variável. Variáveis sobrecarregam quando o valor excede o espaço
designado para guardá-lo. Veja abaixo por exemplo.
Escopo da Variável
Outra escolha importante que os programadores enfrentam é onde declarar as variáveis?
O lugar específico que as variáveis são declaradas influencia como várias funções do
programa aenxergarão. Isto é chamado de escopo.
Iniciando Variáveis
Variáveis devem ser iniciadas (designadas um valor) no momento que elas são
declaradas ou depois. É sempre uma boa prática de programação verificar que uma
variável tenha dados válido dentro dela, antes de ser utilizada.
Exemplo:
int calibrationVal = 17; // declara calibrationVal e configura seu valor
// inicial
Sobrecarga da Variável
Quando variáveis têm seu valor excedido pela capacidade máxima do seu tipo, elas
sobrecarregam e voltam para seu valor mínimo. Isto acontece em ambas direções.
int x
x = -32,768;
x = x - 1; // x contém 32,767 - sobrecarrega na direção negativa
x = 32,767;
x = x + 1; // x contém -32,768 – sobrecarrega
Usando Variáveis
Uma vez que variáveis tenham sido declaradas, elas podem ser usadas configurando a
variável para o valor que se deseja armazenar, através do operador de atribuição (um
sinal de igual). O operador de atribuição diz ao programa para atribuir o que estiver do
lado direito do sinal de igual, dentro da variável que deve ficar do lado esquerdo do sinal
de igual.
inputVariable1 = 7; // configura variável chamada inputVariable1
// atribuindo o valor 7
inputVariable2 = analogRead(2); // configura variável chamada inputVariable2
// atribuindo a voltagem lida de uma porta
// analógica 2
Exemplos:
int lightSensVal;
char currentLetter;
unsigned long speedOfLight = 186000UL;
char errorMessage = {"escolha outra impressão"}; // vide: string
Uma vez que a variável tenha sido configurada (conferida um valor), você pode testar seu
valor para verificar se atende determinada condição, ou usar seu valor diretamente. Por
exemplo, o código a seguir testa se o valor da variável inputVariable2 é menor que 100,
então configurando um atraso (delay) baseado no valor de inputVariable2, que é no
mínimo 100.
if (inputVariable2 < 100)
{
inputVariable2 = 100;
}
delay(inputVariable2);
Este exemplo mostra todas as três operações úteis que se pode fazer com variáveis. Ele
testa a variável (if (inputVariable2 < 100)), configura o valor 100 caso o teste tenha
passado(inputVariable2 = 100), e utiliza o valor armazenado na variável como parâmetro
de entrada na função delay(delay(inputVariable2)).
Escopo das Variáveis
Variáveis na linguagem C, que o Arduino usa, tem uma característica conhecida
por escopo. Isto é um contraste com linguagens como BASIC que qualquer variável é
uma variávelglobal.
Uma variável global é uma que pode ser vista por qualquer função dentro de um
programa. Variáveis locais são apenas visíveis para a função na qual foram declaradas.
No ambiente do Arduino, qualquer variável declarada fora de uma função (ex. setup, loop,
etc.), é considerada uma variável global.
Quando programas começam a ficar grandes e mais complexos, variáveis locais são úteis
para garantir que apenas uma função terá acesso apenas as suas próprias variáveis. Isso
evita erros de programação quando uma função inadvertidamente, modifica o valor de
variáveis utilizadas por outra função.
Algumas vezes é útil declarar e iniciar uma variável interna para umlaço (loop). Assim
criamos uma variável que possa apenas ser acessada na parte interna das chaves {}
do laço-for.
Exemplo:
int gPWMval; // qualquer função acessa essa variável
void setup()
{
// ...
}
void loop()
{
int i; // "i" é apenas "visível" dentro da função "loop"
float f; // "f" é apenas "visível" dentro da função "loop"
// ...
for (int j = 0; j <100; j++){
// variável “j” pode ser apenas
// acessada dentro das chaves do laço-for
Os operadores booleanos: Estes podem ser usados dentro da condição de um caso comunicado.
&& (AND lógico)
Verdadeiro somente se ambos os operandos são verdadeiros, por exemplo,
if (digitalRead (2) == ALTA && digitalRead (3) == HIGH) {// ler dois interruptores
// ...
}
é verdadeiro somente se ambas as entradas são altas.
|| (Ou lógico)
True se o operando é verdade, por exemplo,
se (x> 0 || y> 0) {
// ...
}
É verdade que ou x ou y é maior do que 0.
! (Não)
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 comparação, ele testa se um
certa condição foi alcançada, como por exemplo se uma variável atingiu um certo valor. O
formato para testes com o (if) é o seguinte:
if (algumaVariavel > 50)
{
// faça algo aqui
}
O programa testa pra ver se algumaVariavel é maior do que 50. Se for, o programa exe-
cuta uma determinada ação. Ou seja, se o que estiver declarado nos parênteses for ver-
dadeiro, as instruções entre as chaves são executadas. Se não, o programa pula para a
próxima parte do código.
Caso você omitas as chaves após a declaração do if, apenas uma instrução será execu-
tada apos o teste condicional, veja os exemplos:
if (x > 120) digitalWrite(pinoLED, HIGH);
/*notem que não existe chaves, isto implica que caso a
condição 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 estão corretas
As declarações que estão sendo verificadas dentro dos parênteses requerem o uso de um
ou mais operadores:
Operadores de comparação:
x == y (x é igual a y)
x != y (x não é igual a y)
x < y (x é menor que y)
x > y (x é maior que y)
x <= y (x é menor que ou igual a y)
x >= y (x é maior que ou igual a y)
For: A instrução for é usada para repetir um bloco de instruções definido entre as
chaves. Geralmente utiliza-se um contador para incrementar e finalizar o loop. A
instrução for é útil para quaisquer operações repetitivas.
for (inicialização; condição; incremento)
{
//instrução(ou instruções);
}
A inicialização ocorre primeiramente e somente uma vez. A cada interação do loop, acon-
dição é testada; se for verdadeira a instrução dentro do bloco e o incremento são execu-
tados, caso contrário , se a condição for falsa o loop é terminado.
Exemplo:
// Dimmer de um LED usando um pino PWM como saída
int pinoPWM = 10; // LED ligado em série com um resistor de 1k ao pino 10
void setup()
{
// não é necessário setup
}
void loop()
{
for (int i= 0; i <= 255; i++){
// a variável 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 conjunção com um operador de comparação, os testes se uma de-
terminada condição tem sido alcançado, tal como uma entrada de estar acima de um cer-
to número 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 acção específica. Dito de outra forma, se a declaração em parênteses é verda-
de, as instruções dentro dos colchetes são executados. Se não, o programa salta sobre o
código.
Os suportes podem ser omitidos após uma instrução if. Se isso for feito, a próxima linha
(definido pelo ponto e vírgula) torna-se a única declaração 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 estão corretos
As declarações a ser avaliado dentro dos parênteses requerem o uso de um ou mais ope-
radores:
if / else: Permite maior controle sobre o fluxo de código do que o básico se instrução,
permitindo que vários testes sejam agrupados. Por exemplo, uma entrada analógica, po-
dem ser testadas e uma acção feita se a entrada foi de menos de 500, e uma outra acção
feita se a entrada foi de 500 ou maior. O código ficaria assim:
if (pinFiveInput <500)
{
A ação //
}
mais
{
// Ação B
}
mais pode proceder de outra, se teste, de modo que várias, testes mutuamente exclusivos
pode ser executado ao mesmo tempo.
Cada teste vai avançar para a próxima até que um teste verdadeiro é encontrado. Quando
um teste verdadeiro é encontrado, seu bloco associado de código é executado, e em se-
guida, o programa salta para a linha seguinte à inteira if / else construção. Se nenhum
teste prova ser verdadeiro, o mais padrão do bloco é executado, se estiver presente, e
define o comportamento padrão.
Note-se que uma outra se o bloco pode ser usada com ou sem um outro bloco de termi-
nais e vice-versa. Um número 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 código do que o básico se instrução,
permitindo que vários testes sejam agrupados. Por exemplo, uma entrada analógica, po-
dem ser testadas e uma acção feita se a entrada foi de menos de 500, e uma outra acção
feita se a entrada foi de 500 ou maior. O código ficaria assim:
if (pinFiveInput <500)
{
A ação //
}
mais
{
// Ação B
}
mais pode proceder de outra, se teste, de modo que várias, testes mutuamente exclusivos
pode ser executado ao mesmo tempo.
Cada teste vai avançar para a próxima até que um teste verdadeiro é encontrado. Quando
um teste verdadeiro é encontrado, seu bloco associado de código é executado, e em se-
guida, o programa salta para a linha seguinte à inteira if / else construção. Se nenhum
teste prova ser verdadeiro, o mais padrão do bloco é executado, se estiver presente, e
define o comportamento padrão.
Note-se que uma outra se o bloco pode ser usada com ou sem um outro bloco de termi-
nais e vice-versa. Um número 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 instruções entre chaves. Um conta-
dor de incremento é normalmente usado para aumentar e terminar o loop. O comando
for é útil para qualquer operação repetitiva, e é frequentemente usado em combinação
com matrizes para operar em coleções de dados / pinos.
Existem três partes para o cabeçalho para loop:
for ( initialization ; condition ; increment ) {
//statement(s);
}
A inicialização acontece primeiro e exatamente uma vez. Cada vez através do loop,
a condição é testada; se for verdade, o bloco de declaração, eo incremento é executada,
então a condição é testada novamente. Quando a condição se torna falsa, o loop termina.
Exemplo
// Dim um LED usando um pino PWM
int PWMpin = 10; // LED em série com 470 ohm resistor no pino 10
void setup ()
{
// Nenhuma instalação necessária
}
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
código diferente que deve ser executada em várias condições. Em particular, uma instru-
ção switch compara o valor de uma variável para os valores especificados nas declara-
ções de caso. Quando uma instrução case é encontrada cujo valor corresponde ao da
variável, o código em que a declaração caso é executado.
A palavra-chave break sai a instrução switch, e é normalmente usado no final de cada
caso. Sem uma instrução break, o switch irá continuar a executar as seguintes expres-
sões ("cair-through"), até que uma pausa, ou o fim da instrução 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, faça o padrão
// Default é opcional
}
While: Irá repetir continuamente e infinitamente, até que a expressão dentro dos parênte-
ses, () torna-se falsa. Algo precisa mudar a variável testada, ou o loop while nunca vai
sair. Este poderia ser o seu código, como uma variável incrementado, ou uma condição
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 laço enquanto, com a excep-
ção de que a condição é testada no final do ciclo, de modo a fazer circular
irá sempre executar, pelo menos, uma vez.
fazer
{
// Bloco de declaração
} Enquanto (condição de teste);
Exemplo
fazer
{
atraso (50); // Esperar para sensores para estabilizar
x = readSensors (); // Verificar os sensores
} while (x <100);
Referência: http://renatoaloi.blogspot.com.br/2011/11/variaveis-do-arduino.html http://arduino.cc/en/
