Manual Arduino.

A linguagem de programação do Arduino pode ser dividida em três partes

principais: estruturas, valores (variáveis e constantes) e funções.

1 – Funções

Para controlar a placa Arduino e realizar computações.

1 – Entradas e Saídas Digitais

1.1 – digitalRead()

[Digital I/O]

Descrição

Lê o valor de um pino digital especificado, que pode ser HIGH ou LOW.

Sintaxe

digitalRead(pino)

Parâmetros

pino: o número do pino digital do Arduino que você quiser verificar

Retorna

HIGH ou LOW

Código de Exemplo

Aciona o pino 13 para o mesmo valor que o pino 7, declarado como 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 guardar o valor lido

void setup() {
pinMode(ledPin, OUTPUT); // configura o pino digital 13 como saída
pinMode(inPin, INPUT); // configura o pino digital 7 como entrada
}

void loop() {
val = digitalRead(inPin); // lê o pino de entrada
digitalWrite(ledPin, val); // aciona o LED com o valor lido do botão }
Notas e Advertências

Se o pino não está conectado a nada, digitalRead() pode retornar tanto HIGH como LOW (e isso pode
mudar aleatoriamente).

Os pinos de entrada analógica podem ser também usados como pinos digitais, referidos como A0, A1,
etc. As exceções são os pinos A6 e A7 das placas Arduino Nano, Pro Mini, e Mini, que podem ser
usadas apenas como entradas analógicas.

1.2 – digitalWrite()

Aciona um valor HIGH ou LOW em um pino digital.

Se o pino for configurado como saída (OUTPUT) com a função pinMode(), sua tensão será acionada
para o valor correspondente: 5V (ou 3.3V em placas alimentadas com 3.3V como o DUE) para o
valor HIGH, 0V (ou ground) para LOW.

Se o pino for configurado como entrada (INPUT), a função digitalWrite() irá ativar (HIGH) ou desativar
(LOW) o resistor interno de pull-up no pino de entrada. É recomendado configurar pinMode() com
INPUT_PULLUP para ativar o resistor interno de pull-up. Veja o tutorial sobre pinos digitais para mais
informações.

Se você não configurar o pino com pinMode() e OUTPUT, e conectar um LED ao pino, quando
chamar digitalWrite(HIGH), o LED pode aparecer um pouco apagado. Sem configurar
explicitamente pinMode(), digitalWrite() irá apenas ativar o resistor de pull-up interno, que age como
um grande resistor limitador de corrente.

Sintaxe

digitalWrite(pino, valor)

Parâmetros

pino: o número do pino do Arduino

valor: HIGH ou LOW

Retorna

Nada

Código de Exemplo

The código configura o pino digital 13 como OUTPUT e troca seu estado entre HIGH e LOW

void setup() {
pinMode(13, OUTPUT); // configura o pino digital 13 como saída
}

void loop() {
 digitalWrite(13, HIGH); // ativa o pino digital 13
delay(1000); // espera por um segundo
digitalWrite(13, LOW); // desativa o pino digital 13
delay(1000); // espera por um segundo
}

Notas e Advertências

Os pinos de entrada analógica podem ser também usados como pinos digitais, referidos como A0, A1,
etc. As exceções são os pinos A6 e A7 das placas Arduino Nano, Pro Mini, e Mini, que podem ser
usadas apenas como entradas analógicas.

1.3 – pinMode()

Descrição

Configura o pino especificado para funcionar como uma entrada ou saída. Veja a descrição dos pinos
digitais (em Inglês) para mais detalhes sobre a funcionalidade dos pinos.

Desde a versão 1.0.1, é possível ativar os resistores internos de pull-up como o modo INPUT_PULLUP.
Adicionalmente, o modo INPUT explicitamente desativa os resistores pull-up internos.

Sintaxe

pinMode(pino, modo)

Parâmetros

pino: the número do pino do Arduino no qual se quer configurar o modo

modo: o modo do pino. Este pode ser INPUT, OUTPUT ou INPUT_PULLUP; que correspondem
respectivamente a entrada, saída e entrada com pull-up ativado.

Retorna

Nada

Código de Exemplo

The código configura o pino digital 13 como OUTPUT e troca seu estado entre HIGH e LOW

void setup() {
pinMode(13, OUTPUT); // configura o pino digital 13 como saída
}

void loop() {
digitalWrite(13, HIGH); // ativa o pino digital 13
delay(1000); // espera por um segundo
digitalWrite(13, LOW); // desativa o pino digital 13
 delay(1000); // espera por um segundo
}

Notas e Advertências

Os pinos de entrada analógica podem ser também usados como pinos digitais, referidos como A0, A1,
etc.

1.2 – Entradas e Saídas Analógicas

1.2.1 – analogRead()

Descrição

Lê o valor de um pino especificado. A placa Arduino possui um conversor digital 10 b canais de 6

canais (8 canais nos Mini e Nano, 16 no Mega, 7 canais em placas MKR). Isso significa que este irá
mapear entre 0 e tensão operacional (5V ou 3.3V) para valores inteiros entre 0 e 1023. No Arduino
UNO, por exemplo, isso permite uma resolução entre leituras de: 5 volts / 1024 unidades, ou .0049
volts (4,9 mV) por unidade. Veja abaixo os pinos utilizáveis, tabela para operação e resolução máxima
de algumas placas Arduino.

A solução de entrada pode ser mudada e apenas corrigida enquanto a função analógica pode ser
alterada nas placas Zero, usando o analogRead Due MKR .

Em 00 placas UNO, em microcontroladores AVR Mini, ler um valor de leitura10 valores em torno de
10,00 segundos, ler um valor de leitura 1 micros,000 valores de leitura1 micros, então, máxima é
aproximadamente 10,00 segundos.

BORDA TENSÃO OPERACIONAL PINOS UTILIZÁVEIS RESOLUÇÃO MÁXIMA

Uno 5 Volts A0 a A5 10 bits

Mini, Nano 5 Volts A0 a A7 10 bits

Mega, Mega2560, MegaADK 5 Volts A0 a A14 10 bits

Micro 5 Volts A0 a A11* 10 bits

Leonardo 5 Volts A0 a A11* 10 bits

Zero 3,3 Volts A0 a A5 12 bits**

Vencimento 3,3 Volts A0 a A11 12 bits**

Placas da família MKR 3,3 Volts A0 a A6 12 bits**

*A0 a A5 são rotulados na placa, A6 a A11 estão disponíveis respectivamente nos pinos 4, 6, 8, 9, 10 e
12
**A resolução analogRead() padrão para essas placas é de 10 bits, para compatibilidade. Você precisa
usar analogReadResolution() para alterá-lo para 12 bits.

Sintaxe

analogRead(pino)

Parâmetros

pino: o nome do pino de entrada analógica que se quer ler (A0 a A5 na maioria das placas, A0 a A6
em placas MKR, A0 a A7 no Mini e Nano, A0 a A15 no Mega).

Retornar

A leitura analítica no pino (int). No entanto, é limitada a resolução do conversor20 bits digital (0-10
bits para 10 ou 10 para 10 bits).

Código de Exemplo

O código abaixo lê o valor de um pino de entrada analógica e mostra seu valor na série.

int analogPin = A3; // terminal do meio de um potênciometro conectado ao pino analógico 3

// terminais mais externos são conectados um no ground e o outro em +5V
int val = 0; // variável para guardar o valor lido

void setup() {
[Link](9600); // configura a porta serial
}

void loop() {
val = analogRead(analogPin); // lê o pino de entrada
[Link](val); // imprime o valor na porta serial
}

Notas e Propagandas

Se o pino de entrada analógica não estiver conectado a nada, o valor retornado por Read() irá basear-
se numa gama de dados baseados (ex.

1.2.2 – analogReference()

Descrição

Configura a tensão de referência para a entrada analógica (o valor máximo do intervalo de entrada).
As opções são:
 Placas Arduino AVR (Uno, Mega, etc.)

 DEFAULT: a referência analógica padrão de 5 volts (em placas Arduino de 5V) ou 3.3 volts (em placas
Arduino de 3.3V)
 INTERNAL: uma referência interna, igual a 1.1 volts no ATmega168 ou ATmega328P e 2.56 volts no
ATmega8 (Não disponível no Arduino Mega)
 INTERNAL1V1: uma referência interna de 1.1V (apenas Arduino Mega)
 INTERNAL2V56: uma referência interna de 2.56V (apenas Arduino Mega)
 EXTERNAL: a tensão aplicada ao pino AREF (0 a 5V apenas) é usada como referência.

Placas Arduino megaAVR (Uno WiFi Rev2)

 DEFAULT: uma referência interna de 0.55V

 INTERNAL: uma referência interna de 0.55V
 VDD: Vdd do ATmega4809. 5V no Uno WiFi Rev2
 INTERNAL0V55: uma referência interna de 0.55V
 INTERNAL1V1: uma referência interna de 1.1V
 INTERNAL1V5: uma referência interna de 1.5V
 INTERNAL2V5: uma referência interna de 2.5V
 INTERNAL4V3: uma referência interna de 4.3V
 EXTERNAL: a tensão aplicada ao pino AREF (0 a 5V apenas) é usada como referência.

Placas Arduino SAMD (Zero, etc.)

 AR_DEFAULT: a referência analógica padrão de 3.3V

 AR_INTERNAL: uma referência integrada de 2.23V
 AR_INTERNAL1V0: uma referência integrada de 1.0V
 AR_INTERNAL1V65: uma referência integrada de 1.65V
 AR_INTERNAL2V23: uma referência integrada de 2.23V
 AR_EXTERNAL: a tensão aplicada ao pino AREF é usada como referência

Placas Arduino SAM (Due)

 AR_DEFAULT: a referência analógica padrão de 3.3V. Essa é a única opção suportada pelo DUE.

Sintaxe

analogReference(tipo)

Parâmetros

tipo: qual tipo de referência usar (DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56 ou EXTERNAL).

Retorna

Nada

Notas e Advertências

Após mudar-se a referência analógica, as primeiras leituras com analogRead() podem ser imprecisas.
Não use menos que 0V ou mais que 5V como tensão de referência externa no pino AREF! Se você
está usando uma referência externa no pino AREF, deve configurar a referência como EXTERNAL
antes de chamar analogRead(). Do contrário, você irá curto-circuitar a tensão de referência ativa
(gerada internamente) e o pino AREF, possivelmente danificando o microcontrolador da sua placa
Arduino.

Alternativamente, você pode conectar a tensão de referência externa ao pino AREF através de um
resistor de 5K ohm, permitindo-lhe trocar entre tensões de referência externas e internas. Note que o
resistor irá alterar a tensão usada como referência, pois há um resistor interno de 32K ohm no pino
AREF. Os dois em conjunto agem como um divisor de tensão, então, por exemplo, 2.5V aplicados
através do resistor irão fornecer 2.5 * 32 / (32 + 5) = ~2.2V ao pino AREF.

1.2.3 – analogWrite()

Descrição

Aciona uma onda PWM (descrição (Em Ingês)) em um pino. Pode ser usada para variar o brilho de um
LED ou acionar um motor a diversas velocidades. Após a função analogWrite() ser chamada, no pino
haverá uma onda quadrada com o duty cycle (ciclo de trabalho) especificado até a próxima chamada
de analogWrite() (ou uma chamada de digitalRead() ou digitalWrite() no mesmo pino). A frequência
do sinal PWM na maioria dos pinos é aproximadamente 490 Hz. No Uno e placas similares, pinos 5 e 6
usam uma frequência de aproximadamente 980 Hz.

Na maioria das placas Arduino (as placas com o ATmega168 ou ATmega328), essa função funciona nos
pinos 3, 5, 6, 9, 10, e 11. No Arduino Mega, essa funciona nos pinos 2 a 13 e 44 a 46. Placas mais
antigas com o ATmega8 suportam analogWrite() apenas nos pinos 9, 10, and 11.
O Arduino DUE suporta analogWrite() nos pinos 2 a 13, mais pinos DAC0 e DAC1. Diferente dos pinos
PWM, DAC0 e DAC1 são conversores Digital-Analógicos, e saídas analógicas legítimas.
Você não precisa chamar pinMode() para configurar um pino como saída antes de
chamar analogWrite().
A função analogWrite() nada tem a ver com os pinos analógicos ou a função analogRead().

Sintaxe

analogWrite(pino, valor)

Parâmetros

pino: o pino escolhido do Arduino. Tipos de dados permitidos: int.

valor: o duty cycle: entre 0 (sempre desligado) and 255 (sempre ligado). Tipos de dados permitidos:
int

Retorna

Nada

Código de Exemplo

Controla a saída para um LED proporcionalmente a um valor lido de um 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 guradar o valor lido

void setup() {
pinMode(ledPin, OUTPUT); // configura o pino como saída
}

void loop() {
val = analogRead(analogPin); // lê o pino de entrada analógica
analogWrite(ledPin, val / 4); // analogRead retorna valores de 0 a 1023, analogWrite recebe de 0 a 255
}

Notas e Advertências

As ondas PWM generadas nos pinos 5 e 6 terão duty cycles maiores que o esperado. Isso acontece
porque ocorrem interações com as funções millis() e delay(), as quais compartilham o mesmo timer
(temporizador) interno usado para gerar essas saídas PWM. Isso será constatado principalmente em
duty-cycle baixos (ex. 0 - 10) e podem resultar em um valor de 0 não desligando completamente a
saída nos pinos 5 e 6.

1.3 – Funções Temporizadoras

1.3.1 – delay()

Descrição

Pausa o programa por uma quantidade especificada de tempo (em milissegundos). Cada segundo
equivale a 1000 milissegundos.

Sintaxe

delay(ms)

Parâmetros

ms: o número de milissegundos para pausar o programa (unsigned long)

Retorna

Nada

Código de Exemplo

O código pausa o programa por um segundo antes de trocar o estado do pino 13.

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

void setup() {
pinMode(ledPin, OUTPUT); // configura o pino digital como saída
}

void loop() {
digitalWrite(ledPin, HIGH); // acende o LED
delay(1000); // espera por um segundo
digitalWrite(ledPin, LOW); // apaga o LED
delay(1000); // espera por um segundo
}

Notas e Advertências

Mesmo que seja fácil fazer um LED piscar usando a função delay(), e muitos sketches usam delays
pequenos para tarefas como debouncing de botões, o uso de delay() em um sketch possui
desvantagens significantes. Nenhuma leitura de sensores, cálculos matemáticos, ou manipulação de
pinos podem ocorrer durante a função delay(), para resumir, causa a pausa de qualquer atividade.
Para métodos alternativos de controlar temporizações, veja o sketch Blink Sem Delay (Em Inglês) , que
verifica a função millis() até que o tempo suficiente tenha passado. Programadores mais habilidosos
usualmente evitam o uso da função delay() para timing de eventos mais longos que dezenas de
milissegundos, a menos que o sketch Arduino seja muito simples.

No entanto, certas coisas continuam a acontecer enquanto a função delay() está controlando o
microcontrolador, porque a função delay não desativa interrupções. Comunicação serial recebida no
pino RX é armazenada, valores PWM de (analogWrite) e estados dos pinos são mantidos,
e interrupções externas irão funcionar como devem.

1.3.2 – delayMicroseconds()

Descrição

Pausa o programa pela quantidade de tempo especificada como parâmetro (em microssegundos). Há
mil microssegundos em um milissegundo, e um milhão de microssegundos em um segundo.

Atualmente, o maior valor que irá porduzir um delay preciso é 16383. Isso pode mudar em versões
futuras do Arduino. Para delays mais longos que alguns milhares de microssegundos, você deve
usar delay() em vez disso.

Sintaxe

delayMicroseconds(us)

Parâmetros

us: o número emm microssegundos para pausar o programa (unsigned int)

Retorna

Nada
Código de Exemplo

O código abaixo configura o pino 8 para funcionar como pino de saída. Ele então gera um trem de
pulsos com período de 100 microssegundos.

int outPin = 8; // pino digital 8

void setup() {
pinMode(outPin, OUTPUT); // configura o pino digital como saída
}

void loop() {
digitalWrite(outPin, HIGH); // ativa o pino
delayMicroseconds(50); // pausa por 50 microssegundos
digitalWrite(outPin, LOW); // desativa o pino
delayMicroseconds(50); // pausa por 50 microssegundos
}

Notas e Advertências

Essa função funciona bastante precisamente para valores maiores que 3 microssegundos. Não é
possível assegurar que delayMicroseconds() irá funcionar corretamente para valores menores.

A partir da versão Arduino 0018, delayMicroseconds() não mais desativa interrupções.

1.3.3 – micros()

Descrição

Retorna o número de microssegundos passados desde que a placa Arduino começou a executar o
programa atual. Esse número irá sofrer overflow (chegar ao maior número possível e então voltar pra
zero), após aproximadamente 70 minutos. Em placas Arduino 16 MHz (ex. UNO e Nano), essa função
possui uma resolução de quatro microssegundos (isto é, o número retornado é sempre um múltiplo
de quatro). Em placas Arduino 8 MHz (ex. LilyPad), essa função possui uma resolução de oito
microssegundos.

Sintaxe

time = micros()

Parâmetros

Nenhum

Retorna

O número de microssegundos desde que o programa iniciou (unsigned long).

Código de Exemplo

O código abaixo imprime o número de microssegundos passados desde que a placa Arduino foi ligada.

unsigned long time;

void setup() {
[Link](9600);
}
void loop() {
[Link]("Time: ");
time = micros();

[Link](time); // imprime o tempo desde que o programa iniciou

delay(1000); // espera um segundo, para não enviar quantidades massivas de dados
}

Notas e Advertências

Há 1000 (mil) microssegundos em um milissegundo e 1000000 (um milhão) de microssegundos em um

segundo.

1.3.4 – millis()

Descrição

Retorna o número de milissegundos passados desde que a placa Arduino começou a executar o
programa atual. Esse número irá sofrer overflow (chegar ao maior número possível e então voltar pra
zero), após aproximadamente 50 dias.

Sintaxe

time = millis()

Parâmetros

Nenhum

Retorna

O número de milissegundos passados desde que o programa iniciou (unsigned long)

Código de Exemplo

O código imprime na porta serial o tempo em milissegundos passado desde que a placa Arduino
começou a executar o código em si.

unsigned long time;

 void setup() {
[Link](9600);
}
void loop() {
[Link]("Time: ");
time = millis();

[Link](time); // imprime o tempo desde que o programa iniciou

delay(1000); // espera um segundo, para não enviar quantidades massivas de dados
}

Notas e Advertências

Note que o valor retornado por millis() é unsigned long, erros podem ser gerados se o programador
tentar fazer operações matemáticas com outros tipos de dados, como int. Até mesmo o tipo long com
sinal pode causar erros, já que seu valor máximo é metade de sua contraparte sem sinal.

2 – Variáveis

Tipos de dados e constantes da linguagem Arduino.

Constantes

Descrição

Constantes são expressões predefinidas na linguagem Arduino. Essas são usadas para tornar os
programas mais legíveis. As constantes da linguagem Arduino são classificadas nos grupos:

2.1 – HIGH | LOW

Definições de níveis lógicos: HIGH e LOW

Quando lendo-se ou escrevendo-se o estado de um pino digital há apenas dois valores possíveis que
esse pino pode assumir: HIGH e LOW.

HIGH

O significado de HIGH (em relação a um pino) depende se o pino está configurado como entrada ou
saída (INPUT ou OUTPUT). Qaundo um pino é configurado como INPUT com pinMode(), e lido
com digitalRead(), o Arduino (ATmega) irá retornar HIGH se:

 uma tensão maior que 3.0V está presente no pino (em placas 5V)
 uma tensão maior que 2.0V está presente no pino (em placas 3.3V)

Um pino pode também ser configurado como entrada (INPUT) com pinMode(), e posteriormente
colocado em HIGH com digitalWrite(). Isso irá ativar os resistores de 20K internos para pullup, o que
irá forçar o estado do pino para HIGH a menos que esse seja forçado para LOW por um circuito
externo. Isso é exatamente como a opção INPUT_PULLUP funciona, sendo descrita abaixo em mais
detalhes.
 Quando um pino é configurado como saída (OUTPUT) com pinMode(), e colocado em
estado HIGH com digitalWrite(), a tensão no pino é:

 5 volts (em placas 5V)

 3.3 volts (em placas 3.3V)

Nesse estado, o pino pode fornecer corrente (ver limites para sua placa, geralmente 40.0mA). Isso
pode ser usado, por exemplo, para acender um LED que está conecatdo ao ground através de um
resistor limitador de corrente.

LOW

O significado de LOW depende também se o pino está configurado como entrada ou saída
(INPUT ou OUTPUT). Qaundo um pino é configurado como INPUT com pinMode(), e lido
com digitalRead(), o Arduino (ATmega) irá retornar LOW se:

 uma tensão menor que 1.5V está presente no pino (em placas 5V)
 uma tensão menor que 1.0V (aproxidamente) está presente no pino (em placas 3.3V)

Quando um pino é configurado como OUTPUT com pinMode(), e colocado em

estado LOW com digitalWrite(), a tensão no pino é 0 volts (tanto em placas de 5V como 3.3V boards).
Nesse estado o pino pode absorver corrente, o que pode ser usado, por exemplo, para acender um
LED conectado através de um resistor limitador de corrente aos +5 volts (ou +3.3 volts).

2.2 – INPUT | OUTPUT | INPUT_PULLUP

Definições de modos para Pinos Digitais: INPUT, INPUT_PULLUP e OUTPUT

Pinos digitais pode ser usados como entrada, entrada com pull-up ou saída
(INPUT, INPUT_PULLUP ou OUTPUT, respectivamente). Mudar o modo de um pino
com pinMode() muda o comportamento elétrico do pino.

Pinos Configurados como entrada - INPUT

Pinos configurados como INPUT com pinMode() são ditos estarem em um estado de alta-impedância.
Quando configurados como INPUT, esses pinos exigem multíssimo pouco dos circuitos que estão
verificando, equivalente a um resistor de 100 Megohm na frente do pino. Isso faz com que sejam
muito úteis para ler sensores.

Se você configurar um pino como INPUT, e ler o estado de um botão conectado a 5V, por exemplo,
quando o botão estiver em estado aberto, a entrada estará "flutuando", resultando em leituras
imprevisíveis. Isso acontece porque quando o botão está aberto, o pino não está conectado a
nenhuma tensão. Para assegurar uma leitura correta quando o botão está aberto, um resistor de pull-
up ou pull-down deve ser usado. O propósito desse resistor é colocar o pino em um estado conhecido
quando o botão estiver aberto. Um resistor de 10K ohm é usado geralmente, pois possui valor baixo o
suficiente para previnir confiavelmente o estado flutuante, ao mesmo tempo que é grande o
suficiente para não usar muita corrente qaundo o botão estiver fechado. Veja o tutorial Serial e Digital
Read (Em Innglẽs) para mais informações.

Se um resistor de pull-down é usado, o pino de entrada estará em LOW quando o botão estiver aberto
e HIGH quando o btoão estiver pressionado.
Se um resistor de pull-up é usado, o pino de entrada estará em HIGH quando o botão estiver aberto
e LOW quando o btoão estiver pressionado.

Pinos Configuradoos como entrada com pull-up - INPUT_PULLUP

O microcontrolador ATmega na maioria das placas Arduino possui resistores pull-up internos
(resistores conectados a alimentação internamente) que você pode acessar. Se você preferir usar
estes em vez de resistores de pull-up externos, você pode usar o argumento INPUT_PULLUP na
função pinMode().

Veja o tutorial Input Pullup Serial (Em Inglês) para um exemplo do uso desses resistores.

Pinos configurados como entradas com ambos INPUT ou INPUT_PULLUP podem ser danificados ou
destruídos se são conectados a tensões abaixo de zero (tensões negativas) ou acima da tensão de
alimentação (5V ou 3V).

Pinos Configurados como saída - OUTPUT

Pinos configurados como OUTPUT com pinMode() são ditos estarem em um estado de baixa-
impedância. Isso significa que esses podem fornecer uma quantidade substancial de corrente para
outros circuitos. Os pinos de um ATmega podem fornecer ou absorver correntes de até 40 mA
(miliamperes) para/de outros dispositivos/circuitos. Isso faz com que sejam úteis para alimentar LEDs,
pois LEDs tipicamente usam menos de 40 mA. Cargas que exigem mais de 40 mA (ex. motores) irão
reqeurer um transistor ou um outro circuito de interface.

Pinos configurados como saídas podem ser danificados ou destruídos se forem conectados
diretamente ao ground ou na tensão de alimentação.

2.3 – LED_BUILTIN

Definição do LED na placa: LED_BUILTIN

A maioria das placas Arduino possuem um pino conectado a um LED on-board através de um resistor.
A constante LED_BUILTIN é o número do pino ao qual o LED on-board está conectado. Na maioria das
placas, esse LED é conectado ao pino digital 13.

2.4 – true | false

Definições de Constantes Booleanas: true e false

Existem duas constantes usadas para representar verdade e falsidade na linguagem

Arduino: true e false.

false

false é o mais fácil dos dois de ser definido. Sendo definido apenas como 0 (zero).
true

true é freqeuentemente dito ser definido como 1, o que está correto, porém true possui uma
definição mais ampla. Qualquer inteiro que não seja zero é true, em um sentido booleano. Então -1, 2
e -200 são todos definidos como true, também, em um sentido booleano.

Note que as constantes true e false são digitadas em caixa baixa, diferentemente
de HIGH, LOW, INPUT, and OUTPUT.

3 – Estruturas

Os elementos da linguagem Arduino (C++).

3.1 – Sketch

3.1.1 – loop() = ciclo()

Descrição

Depois de criar uma função setup() , qualificar inicial e atribuir os valores iniciais, a função loop()faz
precisamente o que o seu nome sugere, e repete-se continuamente enquanto a placa é permitida,
permitindo que seu programa mude e responda a essas mudanças . Use-a para controlar ativamente
uma placa Arduino.

Código de Exemplo
int buttonPin = 3;

// setup inicializa a porta serial e o pino para o botão

void setup() {
[Link](9600);
pinMode(buttonPin, INPUT);
}

// loop checa o estado do botão repetidamente, e envia

// pela serial um 'H' se este está sendo pressionado
void loop() {
if (digitalRead(buttonPin) == HIGH) {
[Link]('H');
}
else {
[Link]('L');
 }

delay(1000);
}

3.1.2 – setup() = configurar()

Descrição

A função setup()é chamada quando um esboço é iniciado. setup()Use-a para inicializar variáveis,
configurar o modo dos pinos( INPUT ou OUTPUT), inicializar bibliotecas, etc.

Código de Exemplo
int buttonPin = 3;

void setup() {
// Inicializa a porta serial
[Link](9600);
// configura o pino 3 como INPUT
pinMode(buttonPin, INPUT);}

void loop() {
// ...}

3.2 – Estruturas de Controle

3.2.1 – break = pausa

Descrição

breaké usado para sair de um laço for , while ou do…while , ignorando a condição padrão do
loop. Também é usado para sair do comando switch case .

Código de Exemplo

No códgo seguinte, o break quebra o loop forquando o valor do sensor excede o limiar.

int lim = 40;

for (int x = 0; x < 255; x ++) {
analogWrite(PWMpin, x);
sens = analogRead(sensorPin);
if (sens > lim) { // "foge" do o loop `for`
x = 0;
break;
}
delay(50);
}
3.2.2 – continue = prosseguir

Descrição

O comando continue"pula" o resto da iteração atual de um loop ( for , while , ou do…while ). Esse
comando continua a checar a expressão condicional do loop, e procede com quaisquer iterações
subsequentes.

Código de Exemplo

O código abaixo escreve o valor de 0 a 255 ao pino PWMpin, mas pula os valores no intervalo 41 a
119.

for (int x = 0; x <= 255; x ++) {

if (x > 40 && x < 120) { // cria um salto nos valores
continue;
}

analogWrite(PWMpin, x);
delay(50);
}

3.2.3 – do...while

Descrição

O loop do…while funciona da mesma forma que o loop while, com a exceção de a condição ser
testada no final do loop, tal que o loop será executado pelo menos uma vez.

Sintaxe
do {
// bloco de comandos
} while (condição);

A condição é uma expressão booleana que é avaliada como verdadeiro ou falso,

respectivamente true ou false na linguagem Arduino.

Código de Exemplo
int x = 0;
do {
delay(50); // espera os sensores estabilizarem
x = readSensors(); // checa os sensores
} while (x < 100);

3.2.4 – else
Descrição

A combinação if…else permite maior controle sobre o fluxo de código que o comando mais básico if,
por permitir múltiplos testes serem agrupados juntos. Uma cláusula else (se presente) será executada
se a condição do comando if resulta em false. O else pode proceder outro teste if, tal que múltiplos,
testes mutualmente exclusivos podem ser executados ao mesmo tempo.

Cada teste irá proceder para o próximo até um teste que resulte em verdadeiro seja encontrado.
Quando esse teste for encontrado, o bloco de código correspondente a condição é executado, e o
programa então continua a partir da linha seguinte a estrutura if-else completa. Se nenhum teste
resultar em verdadeiro, o bloco else padrão é executado, se um estiver presente, que dita o
comportamento padrão.

Note que um bloco else if pode ser usado sem um bloco else no final e vice-versa. Um número
praticamente ilimitado de blocos else if conectados é permitido.

Sintaxe
if (condição1) {
// faz coisa A
}
else if (condição2) {
// faz coisa B
}
else {
// faz coisa C
}

3.2.5 – for = por

Descrição

O comando forusado para repetir um bloco de código por chaves. Um contador de incremento é
geralmente utilizado para terminar o loop. O comando foré útil para qualquer operação repetitiva, e é
usado frequentemente com vetores para operar em coleções de dados ou pinos.

Sintaxe
for (inicialização; condição; incremento) {
//comando(s);
}

A inicialização ocorre primeiro e apenas uma vez. A cada repetição do loop, a condição é
comprovada; se é verdadeira ( true), o bloco de comandos, e o incremento são realizados. Quando
a condição se torna falsa ( false), o loop termina.

Código de Exemplo
// Varia o brilho de um LED usando um pino PWM
int pinoPWM = 10; // LED em série com um resistor de 470 ohm no pino 10

void setup() {
// setup não necessário
}

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

Notas e Propagandas

O loop forna linguagem C é muito mais rápido que os loops `for` encontrados em outras
linguagens. Os três elementos da sintaxe podem ser omitidos, porém os pontos e a transmissão (';')
são enviados. Além disso, os comandos para inicialização, condição e incremento podem ser
quaisquer comandos válidos em linguagem C, mesmo com variáveis relacionadas não relacionadas ao
loop, e podem usar quaisquer tipos de dados de linguagem, incluindo floats. Esses tipos de
comandos forincomuns podem fornecer soluções rápidas para alguns problemas raros de
programação.

Por exemplo, use uma multiplicação no comando de incremento irá gerar uma progressão
logarítmica:

for (int x = 2; x < 100; x = x * 1.5) {

println(x);
}

Gera: 2,3,4,6,9,13,19,28,42,63,94.

Outro exemplo, Aplica um efeito de desvanecimento crescente e decrescente em um LED com apenas
um loop for:

void loop() {
int x = 1;
for (int i = 0; i > -1; i = i + x) {
analogWrite(pinoPWM, i);
if (i == 255) {
x = -1; // muda a direção no pico
}
delay(10);
}
}

3.2.6 – goto = vamos para

Descrição

Transfere o fluxo do programa para um ponto rotulado no código.

Sintaxe
rótulo:
goto rótulo; // envia o fluxo do programa de volta para o rótulo

Código de Exemplo

O código abaixo "foge" de dentro de todos os laços da leitura no pino mantido 0 seja maior que 250.

for (byte r = 0; r < 255; r++) {

for (byte g = 255; g > 0; g--) {
for (byte b = 0; b < 255; b++) {
if (analogRead(0) > 250) {
goto cancelar;
}
// mais comandos ...
}
}
}

cancelar:
// mais comandos ...

Notas e Propagandas

O uso do comando gotoé projetado na programação em C++, e alguns autores de livros de redação
que o uso do comando gotonunca é necessário, mas se usado judiciosamente ele pode simplificar
certos programas. A qual programadores desaprovam o uso do goto é que com o uso descuidado de
comando goto, é fácil criar um programa com fluxo indefinido, que não pode ser depurado.

Tendo isso, há algumas instâncias em que o comando gotopode ser considerado, por simplificar o
código. Uma dessas situações é sair de laços para profundamente aninhados, ou blocos se , em
determinada condição.

3.2.7 – if

Descrição

O comando if checa uma condição e executas o comando a seguir ou um bloco de comandos

delimitados por chaves, se a condição é verdadeira ('true').

Sintaxe
if (condição) {
//comando(s)
}

Parâmetros

condição: uma expressão booleana, isto é, que pode resultar apenas em true ou false
Código de Exemplo

As chaves podem ser omitidas depois de um comando if. Se isso é feito, a próxima linha (definida pelo
ponto e vírgula) é interpretada como o único comando condicional. Para mais de um comando, use as
chaves para delimitar o bloco de comandos.

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

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

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

if (x > 120) {
digitalWrite(pinoLED1, HIGH);
digitalWrite(pinoLED2, HIGH);
} // todas as formas acima estão corretas

Notas e Advertências

As expressões sendo testadas dentro dos parênteses geralmente requerem o uso de um ou mais dos
operadores mostrados abaixo.

Operadores de comparação:

x == y (x é igual a y)
x != y (x é diferente de 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 para não usar acidentalmente o símbolo de igual simples (ex. if (x = 10) ). O símbolo de igual
simples é o operador de atribuição, se atribui 10 a x (coloca o valor 10 na variável x). Em vez disso, o
símbolo de igual duplo (ex. if (x == 10) ) deve ser usado, que é o operador de comparação, e
testa se x é igaul a 10 ou não. O último é apenas verdadeiro se x é igual a 10, enquanto o primeiro
comando mostrado sempre resultará em verdadeiro.

Isso acontece porque a linguagem C++ interpreta if (x=10) da seguinte forma: 10 é atribuído
a x (Lembre que o símbolo de igual simples é o (operador de atribuição)), então x agora contém 10.
então o comando 'if' testa 10, o que sempre resulta true, desde que qualquer número diferente de
zero resulta em true. Consequentemente, if (x = 10) irá sempre resultar em true, o que não é
desejável ao se usar um comando 'if'. Além disso, a variável x irá receber o valor 10, o que também é
indesejado.

3.2.8 – return
Descrição

Termina uma função e retorna um valor, caso desejado.

Sintaxe
return;

return valor; // ambas as formas são válidas

Parâmetros

valor: qualquer variável ou constante de qualquer tipo de dado

Código de Exemplo

Uma função para comparar a saída de um sensor com um limiar

int checaSensor() {
if (analogRead(0) > 400) {
return 1;
}
else {
return 0;
}
}

A palavra-chave return é útil para testar uma seção de código sem ter que "comentar" grandes seções
de código possivelmente cheio de erros.

void loop() {
return;

// o resto de um esboço disfuncional aqui

// este código nunca será executado
}

3.2.9 – switch...case

Descrição

Da mesma forma que o comando if, o comando switch case controla o fluxo do programa permitindo
ao programador especificar código diferente para ser executado em várias condições. Em particular,
um comando switch compara o valor de uma variável aos valores especificados nos comandos case.
Quando um comando case é encontrado cujo valor é igual ao da variável, o código para esse
comando case é executado.

A palavra-chave break interrompe o comando switch, e é tipicamente usada no final de cada case.
Sem um comando break, o comando switch irá continuar a executar as expressões seguintes
(desnecessariamente) até encontrar um break, ou até o final do comando switch ser alcançado.
Sintaxe
switch (var) {
case valor1:
// comando(s)
break;
case valor2:
// comando(s)
break;
default:
// comando(s)
break;
}

Parâmetros

var: uma variável para ser comparada com os vários cases. Tipos de dados permitidos: int, char
valor1, valor2: constantes. Tipos de dados permitidos: int, char

Retorna

Nada

Código de Exemplo
switch (var) {
case 1:
// faz algo quando var é igual a 1
break;
case 2:
// faz algo quando var é igual a 2
break;
default:
// Se nenhum dos anteriores, faz o caso padrão default
// default é opcional
break;
}

3.2.10 – while

Descrição

Um loop while irá se repetir continuamente, e infinitamente, até a expressão dentro dos parênteses
(), se torne falsa. Algo deve mudar a variável testada, ou o loop while nunca irá encerrar. Isso pode ser
no seu código, por exemplo, uma variável incrementada, ou uma condição externa, como a leitura de
um sensor.

Sintaxe
while (condição) {
// código a ser executado repetidamente
}
A condição é uma expressão booleana que resulta em true ou false.

Código de Exemplo
var = 0;
while (var < 200) {
// faz algo repetitivo 200 vezes
var++;
}

3.3 – Operadores de Comparação

3.3.1 – != (diferente de)

Descrição

Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro
(true) quando os operandos não são iguais. Por favor note que você pode comparar variáveis de tipos
de dados diferentes, mas isso pode gerar resultados imprevisíveis. Por isso é recomendado comparar
variáveis do mesmo tipo de dados incluindo o atributo signed/unsigned.

Sintaxe
x != y; // é falso se x é igual a y e é verdadeiro se x não é igual a y

Parâmetros

x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long

Código de Exemplo
if (x != y) { // testa se x é diferente de y
// faz algo apenas se o resultado da comparação é verdadeiro
}

3.3.2 – < (menor que)

Descrição

Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro
(true) quando o operando à esquerda é menor que o operando à direita. Por favor note que você
pode comparar variáveis de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis.
Por isso é recomendado comparar variáveis do mesmo tipo de dados incluindo o atributo
signed/unsigned.
Sintaxe
x < y; // é verdadeiro se x é menor que y e é falso se x é igual ou maior que y

Parâmetros

x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long

Código de Exemplo
if (x < y) { // testa se x é menor que y
// faz algo apenas se o resultado da comparação é verdadeiro
}

Notas e Advertências

Números positivos são maiores que números negativos.

3.3.3 – <= (menor que ou igual a)

Descrição

Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro
(true) quando o operando à esquerda é menor ou igual ao operando à direita. Por favor note que você
pode comparar variáveis de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis.
Por isso é recomendado comparar variáveis do mesmo tipo de dados incluindo o atributo
signed/unsigned.

Sintaxe
x <= y; // é verdadeiro se x é menor ou igual a y e é falso se x é maior que y

Parâmetros

x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long

Código de Exemplo
if (x <= y) { // testa se x é menor que ou igual a y
// faz algo apenas se o resultado da comparação é verdadeiro
}

Notas e Advertências

Números positivos são maiores que números negativos.

3.3.4 – == (igual a)

Descrição

Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro
(true) quando os dois operandos são iguais. Por favor note que você pode comparar variáveis de tipos
de dados diferentes, mas isso pode gerar resultados imprevisíveis. Por isso é recomendado comparar
variáveis do mesmo tipo de dados incluindo o atributo signed/unsigned.

Sintaxe
x == y; // é verdadeiro se x é igual a y e é falso se x não é igual a y

Parâmetros

x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long

Código de Exemplo
if (x == y) { // testa se x é igual a y
// faz algo apenas se o resultado da comparação é verdadeiro
}

3.3.5 – > (maior que)

Descrição

Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro
(true) quando o operando à esquerda é maior que o operando à direita. Por favor note que você pode
comparar variáveis de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis. Por
isso é recomendado comparar variáveis do mesmo tipo de dados incluindo o atributo
signed/unsigned.

Sintaxe
x > y; // é verdadeiro se x é maior que y e é falso se x é igual ou menor que y

Parâmetros

x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long

Código de Exemplo
if (x > y) { // testa se x é maior que y
// faz algo apenas se o resultado da comparação é verdadeiro
}
Notas e Advertências

Números positivos são maiores que números negativos.

3.3.6 – >= (maior que ou igual a)

Descrição

Compara a variável à esquerda com o valor ou variável à direita do operador. Retorna verdadeiro
(true) quando o operando à esquerda é maior ou igual ao operando à direita. Por favor note que você
pode comparar variáveis de tipos de dados diferentes, mas isso pode gerar resultados imprevisíveis.
Por isso é recomendado comparar variáveis do mesmo tipo de dados incluindo o atributo
signed/unsigned.

Sintaxe
x >= y; // é verdadeiro se x é maior ou igual a y e é falso se x é menor que y

Parâmetros

x: variável. Tipos de dados permitidos: int, float, double, byte, short, long
y: variável ou constante. Tipos de dados permitidos: int, float, double, byte, short, long

Código de Exemplo
if (x >= y) { // testa se x é maior que ou igual a y
// faz algo apenas se o resultado da comparação é verdadeiro
}

Notas e Advertências

Números positivos são maiores que números negativos.

3.4 – Operadores Boleanos

3.4.1 – ! (NÃO lógico)

Descrição

O NÃO lógico resulta em verdadeiro se o operando é falso, e vice-versa. Vale lembrar que condições
verdadeiras e falsas na linguagem Arduino são representadas por true e false respectivamente.

Código de Exemplo

Esse operador pode ser usado dentro da condição de um laço if.

if (!x) { // se x não é true
// código a ser executado
}

Pode ser usado para inverter o valor booleano.

x = !y; // o valor booleano invertido de y é guardado em x

Notas e Advertências

O NÃO bitwise ~ (til) é muito diferente do NÃO booleano ! (ponto de exclamação), mas você ainda
deve ter certeza de qual você precisa usar.

3.4.2 – && (E lógico)

Descrição

O E lógico resulta em verdadeiro, apenas se ambos os operandos são verdadeiros. Vale lembrar que
condições verdadeiras e falsas na linguagem Arduino são representadas
por true e false respectivamente.

Código de Exemplo

Esse operador pode ser usado dentro da condição de um laço if.

if (digitalRead(2) == HIGH && digitalRead(3) == HIGH) { // se AMBOS os botões estão em HIGH

// código a ser executado caso as duas condições sejam verdadeiras
}

Notas e Advertências

Tome cuidado para não confundir o operatdor booleano E, && (e comercial duplo); com operador
bitwise E, & (e comercial único). Eles são usados para propósitos diferentes.

3.4.3 – || (OU lógico)

Descrição

O OU lógico resulta em verdadeiro se pelo menos um dos operandos é verdadeiro. Vale lembrar que
condições verdadeiras e falsas na linguagem Arduino são representadas
por true e false respectivamente.
 Código de Exemplo

Esse operador pode ser usado dentro da condição de um laço if.

if (x > 0 || y > 0) { // se x ou y é maior que zero

// código a ser executado
}

Notas e Advertências

Não confunda o operador OU booleano || (pipe duplo) com o operador OU bitwise | (pipe único).

4 – Bibliotecas

O ambiente Arduino pode ser estendido através do uso de bibliotecas, assim como a maioria das
plataformas de programação. As bibliotecas fornecem funcionalidade extra para uso em esboços, por
exemplo, trabalhar com hardware ou manipular dados. Para usar uma biblioteca em um esboço,
selecione-a em Sketch > Import Library .
Várias bibliotecas vêm instaladas com o IDE, mas você também pode baixar ou criar a sua
própria. Consulte estas instruções para obter detalhes sobre a instalação de bibliotecas. Há também
um tutorial sobre como escrever suas próprias bibliotecas . Consulte o Guia de estilo da API para
obter informações sobre como criar uma boa API no estilo Arduino para sua biblioteca.

Bibliotecas padrão

 EEPROM - leitura e gravação em armazenamento "permanente"

 Ethernet - para conexão à internet usando o Arduino Ethernet Shield, Arduino Ethernet Shield 2 e
Arduino Leonardo ETH
 Firmata - para comunicação com aplicativos no computador usando um protocolo serial padrão.
 GSM - para conectar a uma rede GSM/GRPS 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 comunicação com dispositivos usando o barramento Serial Peripheral Interface (SPI)
 SoftwareSerial - para comunicação serial em qualquer pino digital. A versão 1.0 e posterior do Arduino
incorpora a biblioteca NewSoftSerial de Mikal Hart como SoftwareSerial .
 Stepper - para controlar motores de passo
 TFT - para desenhar texto, imagens e formas na tela TFT do Arduino
 WiFi - para conectar-se à internet usando o escudo WiFi do Arduino
 Fio - Interface de dois fios ( TWI/I2C ) para envio e recebimento de dados através de uma rede de
dispositivos ou sensores.