Universidade Federal de Minas Gerais UFMG

Frmula SAE UFMG

Jeff Aguilar Rodrigues

Guia de Arduino para Iniciantes

Belo Horizonte
2017
Sumrio
Introduo .................................................................................................................................... 3
Cuidados Iniciais ........................................................................................................................... 4
Instalao da IDE .......................................................................................................................... 5
Programao ................................................................................................................................. 9
Estrutura ........................................................................................................................... 9

Setup() ................................................................................................................. 9
Loop()................................................................................................................... 9

Funes() ........................................................................................................... 10

Ponto e Vrgula .................................................................................................. 11

Comentrios em Linha ....................................................................................... 11

Comentrios em Blocos ..................................................................................... 11

Variveis ......................................................................................................................... 12

Declarao de Variveis..................................................................................... 12

Localizao da Declarao de Varivel .............................................................. 13

Tipos de Dados ............................................................................................................... 14

Byte .................................................................................................................... 14

Int....................................................................................................................... 14

Long ................................................................................................................... 14

Float ................................................................................................................... 14

Vetores .............................................................................................................. 15

Aritmtica ...................................................................................................................... 16

Operadores ........................................................................................................ 16

Operadores de Comparao.............................................................................. 17

Operadores Lgicos ........................................................................................... 18

Constantes ..................................................................................................................... 18

True/False .......................................................................................................... 18

High/Low............................................................................................................ 19

Input/Output ....................................................................................................... 4

Controle de Fluxo............................................................................................................. 4

If ......................................................................................................................... 19

For ...................................................................................................................... 21
 While.................................................................................................................. 21
Do While ............................................................................................................ 22

Entradas e Sadas Digitais .............................................................................................. 22

PinMode ............................................................................................................ 22

DigitalRead......................................................................................................... 23

DigitalWrite........................................................................................................ 23

Entradas e Sadas Analgicas ........................................................................................ 24

AnalogRead ........................................................................................................ 24

Tempo ............................................................................................................................ 25

Delay .................................................................................................................. 25

Millis .................................................................................................................. 25

Mnimo e Mximo ......................................................................................................... 26

Min..................................................................................................................... 26

Max .................................................................................................................... 26

Random .......................................................................................................................... 26

Serial............................................................................................................................... 28

Serial.begin ........................................................................................................ 28

Serial.println ...................................................................................................... 28

Extra: Interrupes ........................................................................................................ 29

Conexes Eltricas ............................................................................................. 29

Usando Interrupes ......................................................................................... 29

Extra: Utilizando Bibliotecas ......................................................................................... 32

Bibliotecas ......................................................................................................... 32

Gravando e Compilando ................................................................................................ 38

Bibliografia ..................................................................................................................... 39
Introduo
A plataforma Arduino foi criada em 2005 na Itlia tendo como base o conceito
de software e hardware livre, ou seja, o seu uso est aberto para uso e contribuio de
toda a sociedade.
A placa comunica com um computador hospedeiro de forma serial ou USB, e
basicamente composta por pinos de entrada/sada analgica ou digital e um
microcontrolador, o ATMEL AVR. A programao da placa feita por meio de uma
sintaxe de fcil compreenso, similar as linguagens C e C++, alm disso existe uma vasta
quantidade de bibliotecas com funes que facilitam a interao do usurio com o
dispositivo. Sendo assim, Arduino pode ser entendido como uma unidade de
processamento capaz de mensurar diversas variveis tais como temperatura, vazo,
velocidade, presso entre outras. Tais variveis so transformadas em sinais eltricos
por meio de sensores ligados nos terminais de entrada do Arduino.
Cuidados Iniciais

Antes de iniciar os primeiros projetos com o Arduino necessrio saber o que pode
danificar a placa! Observe com ateno:
1- Entregar mais do que 40mA atravs de um output pin (pino de sada).
Um Arduino no capaz de fornecer tal quantidade de corrente eltrica, ento
no possvel conectar motores, alto-falantes e at mesmo um LED (sem um
resistor em srie) diretamente. Portanto, conectar um output pin ao +5v, +3.3v
ou a um pino ground (terra), ir imediatamente curto circuitar a placa.
2- Entregar mais do que 200mA de todos outputs pins juntos.
O chip ATmega pode fornecer no mximo 200mA, ento se conectarmos mais
do que 10 LEDs (cada um consumindo 20mA), por exemplo, iremos
eventualmente danificar a placa.
3- Fornecer mais do que 5v (3.3v) para um input pin (pino de entrada).
Fornecer uma tenso maior do que a tenso de operao do Arduino altamente
perigoso.
4- Fornecer mais do que 12v para o Vin pin.
Existe um regulador de tenso de 5v, o qual ir aquecer e queimar caso for
alimentado com mais de 12v.
5- Entregar mais do que 500mA atravs do 5v pin (quando no se est utilizando
uma fonte externa de tenso).
O regulador de tenso de 5v s pode fornecer 500mA de corrente. O USB 5v
feito para limitar a tenso em 500mA.
6- Entregar mais do que 50mA atravs do 3.3v pin.
O regular de tenso de 3.3v presente na placa pode somente fornecer 50mA de
corrente. Isto significa que voc no pode conectar nenhum dispositivo que exija
mais disso.
7- Inverter a polaridade da fonte.
Se voc trocar o pino de 5v com o pino GND (terra), voc instantaneamente ir
queimar a placa.
8- Conectar uma carga ao pino Vin enquanto usa alimentao USB.
Se voc conectar uma carga ao pino Vin enquanto a alimentao 5v do Arduino
vem da conexo USB, a corrente ir atravessar o regulador de tenso,
danificando-o.
9- Eletricidade Esttica.
A maior parte dos chips possuem diodos de proteo, mas pode ser til utilizar
uma pulseira de proteo.
Instalao da IDE

Todo cdigo de programao ser escrito em uma IDE (Integrated Development

Environment) do Arduino, em que possvel a criao de sketches. Assim
necessrio que se faa o download do software disponvel no site
www.arduino.cc.
Para isso, basta clicar na aba download, escolher o sistema operacional utilizado
pelo usurio, que se iniciar o download do arquivo, como mostra a figura 2.3.

Figura 2.3 - Download da IDE

No caso da instalao no Windows, aps o download deve-se clicar no

arquivo para que se inicie a instalao. Ir abrir uma janela, mostrada na figura
2.4, com a licena do software a ser instalado, para prosseguir basta clicar em
I Agree.
 Figura 2.4 - Instalao da IDE

Aps esse passo, abrir uma janela contendo as opes de instalao, para que
o usurio escolha quais arquivos sero instalados, recomenda-se deixar todas as
opes marcadas e clicar em Next.

Figura 2.5 - Instalao da IDE

Assim, ser aberta uma janela em que se pode alterar o local de onde o software
ser instalado, caso o usurio queira alterar o diretrio, basta clicar em Browse
e escolher a pasta de destino, aps isso, deve-se instalar, clicando em Install.
 Figura 2.6 - Instalao da IDE

Aps a realizao desses passos, aparecer uma mensagem informando que a IDE
foi instalada com sucesso.

Figura 2.7 - Instalao da IDE

Feita a instalao, necessrio abrir a IDE e conectar o Arduino ao computador

com auxlio do cabo USB, para que assim, possa configurar o tipo da placa e a
porta serial utilizada.
Para isso, deve-se clicar na aba Ferramentas, e ir na opo Placas, para
assim, escolher o tipo de Arduino, que nesse tutorial ser o Uno. A configurao
da placa e da porta serial mostrada nas figuras 2.8 e 2.9.
 Figura 2.8 - Configurao da placa

Na mesma aba ferramenta deve-se clicar em porta para configurar a porta serial
que est sendo usada.

Figura 2.9 - Porta serial

Programao

Estrutura

A estrutura bsica da linguagem de programao do Arduino funciona com no mnimo

duas funes. A Setup e a Loop.

Setup()
O setup() est relacionado a preparao, j o loop() est relacionado a execuo do
programa. As duas funes so necessrias para o funcionamento do programa.
A funo setup a primeira funo a ser iniciada, s executada uma nica vez, e
usada para definir os pinos ou inicializar a comunicao serial.

void setup()
{
pinMode(pin, OUTPUT); // define o pin como sada
}

Loop()
A funo loop() , a seguir, inclui o cdigo a ser executado continuamente lendo
entradas, acionando sadas, etc. Esta funo principal de qualquer programa de
Arduino e realiza a maior parte do trabalho.

void loop()
{
digitalWrite(pin, HIGH); // liga o pin
delay(1000); // pausa o programa por um segundo
digitalWrite(pin, LOW); // desliga o pin
delay(1000); // pausa o programa por um segundo
}
Funes
A funo um bloco de cdigo que possui um nome e comandos que so executados
quando chamada.
Funes podem ser escritas para realizar tarefas repetitivas e/ou melhorar a
organizao do programa. A declarao de uma funo comea pela declarao do seu
tipo, isto , o tipo do valor que retornado pela funo, como int para um tipo inteiro.
Se a funo no retorna nenhum valor ela categorizada como uma funo void. Depois
do tipo necessrio declarar o nome dado a ela e dentro dos parntesis qualquer
parmetro que deva ser passado a funo.

type nomedafuno(parmetros)
{
comandos;
}

A funo tipo inteira delayVal() usada definir um valor em um programa atravs da

leitura do valor de um potencimetro. Primeiramente declarado uma varivel local v
cujo valor definido para o valor analgico do potencimetro, entre 0 e 1023, em
seguida este valor dividido por 4, resultando em um valor final localizado entre 0 e 255
que finalmente retornado ao programa principal.

Int delayVal()
{
Int v; // criar um varivel temporria
v = analogRead(pot); // ler o valor do potencimetro
v /= 4; // converter o intervalo 0-1023 para 0-255
return v; // retornar o valor principal
}

Chaves
Chaves definem o incio e o fim dos blocos de funo e tambm dos comandos for e if.

Tipo de funo()
{
Comandos;
}
Uma chave de incio { deve sempre ser seguida de uma chave de fim }. A interface de
desenvolvimento automaticamente checa se as chaves esto corretamente
posicionadas. Selecionando-se uma chave, o seu par ser imediatamente destacado,
facilitando a visualizao.

; Ponto e Vrgula
O ponto e vrgula deve sempre ser utilizado para finalizar um comando e separar os
elementos de um programa. Ele tambm usado para separar os elementos em um
um loop for.

int x = 13; // define a varivel x como inteiro 13

Dica: Esquecer de finalizar um linha com ; ir gerar um erro de compilao.

// Comentrios em linha
Um simples comentrio em linha se inicia com // e termina com o incio da prxima
linha de cdigo. Assim como comentrios em blocos, eles so ignorados pelo programa
e no ocupam espao na memria.

//Frmula UFMG 2017! No se esquea de fechar o comentrio!

/*...*/ Comentrios em Blocos

Comentrios em blocos, ou comentrios em vrias linhas so rea de texto que iro
ser ignoradas pelo programa. Estas reas tm como finalidade armazenar descries
ou comentrios que facilitem o entendimento do cdigo. Eles iro comear com /* e
acabar com */ e podem ser utilizados em diversas linhas.

/* Frmula UFMG 2017

no se esquea de fechar o
comentrio!
*/
Variveis

Variveis so locais onde armazenamos valores na memria. Toda varivel

caracterizada por um nome, que a identifica em um programa, e por um tipo, que
determina o que pode ser armazenado naquela varivel. O cdigo a seguir declara uma
varivel chamada inputVariable e atribui o valor obtido na entrada analgica pin 2.

Int inputVariable = 0; // declara uma varivel e atribui o valor 0 a ela

inputVariable = analogRead(2); // define a varivel para o valor analgico do pin 2

Declarao de Variveis
Todas variveis tm de ser declaradas antes de ser usadas. Declarar uma varivel
significa definir o seu tipo, como int, long, float, entre outros... o seu nome e
opcionalmente atribuir um valor inicial. Este procedimento s necessrio uma nica
vez em um programa, mas o valor pode ser alterado a qualquer momento, por meio de
operaes aritmticas e comandos diversos.
O exemplo a seguir declara que a varivel Giroscopio um inteiro com valor inicial igual
a zero.

int Giroscopio = 0;
Localizao da Declarao da Varivel
Uma varivel pode ser declarada nos mais variados lugares, como no incio do programa,
antes da funo void setup(), dentro de funes criadas, e as vezes dentro de repeties.
A localizao da declarao da varivel restringe o seu acesso por determinadas partes
do programa.
Uma varivel global pode ser vista e usada por qualquer funo e comando em um
programa. Esta varivel declarada no incio do programa, antes da funo setup().
Uma varivel local pode ser definida dentro de uma funo ou como parte de um alguma
repetio. Ela s visvel e s pode ser utilizada dentro da funo na qual foi declarada.
possvel ter duas ou mais variveis com o mesmo nome em diferentes partes de um
programa onde cada uma contm um valor diferente.
O exemplo a seguir mostra como declarar diferentes tipos de variveis:

int valor; // valor visvel para qualquer funo

void setup()
{
// Neste caso o setup no necessrio.
}

void loop()
{
for (int i=0; i<20;) // i s est visvel dentro da repetio do for
{
i++;
}
float f; // f s est visvel dentro da repetio loop;
}
Tipos de dados

Byte
O byte armazena um valor numrico, sem decimais, em um espao na memria de 8
bits, com o intervalo de 0 a 255.

byte algumaVariavel = 180; // declara algumaVariavel como tipo byte

Int
O int o principal tipo de dado de armazenamento numrico sem decimais. Ele ocupa
16 bits, com o intervalo de -31,768 a 32,768.
Dica: Adicionar (int) desta forma: i = (int)3.6, ir tornar i igual a 3.

int algumaVariavel = 1500; // declara algumaVariavel com o

tipo // inteiro

Long
utilizado para representar inteiros extensos, que no possuem decimais, ocupando 32
bits com o intervalo de -2,147,483,647 a 2,147,483,648.

long algumaVariavel = 90000; // declara algumaVariavel

com o tipo // long

Float
utilizado para representar nmeros decimais ocupando um espao de 32-bits. Ele tem
um intervalo de representao de -3.4028235E+38 a 3.4028235E+38.

long algumaVariavel = 90000; // declara algumaVariavel como tipo long

Vetores
Um vetor uma coleo de variveis de mesmo tipo, acessveis com um nico nome e
armazenados contiguamente na memria.
A individualizao de cada varivel de um vetor feita atravs do uso de ndices.

int Vetor[5]; // declara um vetor de 5 posies

Para acessar os elementos de um vetor usa-se ndices. O ndice define a posio da

varivel dentro do vetor. Em todos os vetores tem o primeiro elemento na posio 0
(zero). Assim, se tomarmos "K" como sendo o tamanho do vetor a ltima posio a de
ndice "K-1"

Vetor[0] = 4; // Coloca 4 na primeira posio de

// "Vetor"
Vetor[4] = 8; // Coloca 8 na ltima posio de
// "Vetor"
Vetores so frequentemente utilizados em repeties. O exemplo a seguir usa um vetor
para piscar um LED. Usando uma repetio for, o contador comea no 0, escreve o valor
contido na posio 0 do vetor piscador, neste caso 180, para a sada PWM pin 10,
espera por 200ms, e ento vai at a prxima posio do vetor.

int ledPin = 10; // LED no pino 10

byte piscador[] = {180, 30, 255, 200, 10, 90, 150, 60};
// Criou-se um vetor de 8 posies
void setup()
{
pinMode(ledPin, OUTPUT); // Define o pino de sada
}

void loop()
{
for(int i=0; i<7; i++) // A repetio igual ao nmero de
// valores no vetor
{
analogWrite(ledPin, piscador[i]); // Escreve o valor armazenado no
vetor
delay(200); // Espera 200ms
}
}

Aritmtica

Operadores
Operadores aritmticos incluem adio, subtrao, multiplicao e diviso. Eles
retornam a soma, diferena, produto ou o quociente (respectivamente) de dois
operandos.

y = y + 3;
x = x 7;
i = j * 6;
r = r / 5;
A operao obedece o tipo de dado dos operandos, ento se efetuamos a diviso de
dois inteiros o resultado tambm ser um inteiro, 9/4 = 2, ao invs de 2.25 (pois os
inteiros so incapazes de armazenar nmeros decimais).
Se os operandos so de diferentes tipos, o tipo maior usado no clculo. Por exemplo,
se um dos nmeros do tipo float e o outro do tipo int, o floating point ser usado para
o clculo.
necessrio ateno na escolha do tipo de dados, pois, utilizar um tipo de dados que
no seja capaz de armazenar um determinado valor ir desencadear um srie de erros
no programa.
Dicas:
x ++ // Tem o mesmo resultado de realizarx = x + 1, ou incrementar x em 1
x -- // Tem o mesmo resultado de realizar x = x 1, decrementar x em 1
x += y // Tem o mesmo resultado de realizar x = x + y, ou incrementar x em y
x -= y // Tem o mesmo resultado de realizar x = x y, ou decrementar x em y
x *= y // Tem o mesmo resultado de realizar x = x * y, ou multiplicar x por
y
x /= y // Tem o mesmo resultado de realizar x = x / y, ou dividir x por y

Operadores de Comparao
Comparaes entre variveis e constantes tambm so utilizadas para verificar se uma
condio especfica verdade.

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
Operadores Lgicos
Operadores lgicos so usualmente utilizados para comparar duas expresses e
retornar VERDADEIRO ou FALSO. Existem trs operadores, AND, OR, e NOT, que so
utilizados nos comandos de if:

Lgica AND:
if ( x > 0 && x < 5) // Verdadeiro se as duas expresses so verdadeiras

Lgica OR:
if (x > 0 || y > 0) // Verdadeiro se uma das duas expresses for verdadeira

Lgica NOT:
If (!x > 0) // Verdadeiro somente se a expresso for falsa

Constantes

A linguagem de programao do Arduino possui alguns valores predefinidos, os quais

so chamados de constantes. Eles so usados para facilitar a leitura dos programas. As
constantes so classificadas em grupos.

True/false
Estas so constantes booleanas que definem nveis lgicos. FALSE definido como 0
(zero) enquanto TRUE normalmente definida como 1, mas tambm pode ser qualquer
coisa diferente de 0. Desta forma, na viso booleana, -1, 2, e -200 tambm so definidos
como TRUE.

If ( b== TRUE);
{
fazAlgo;
}
High/Low
Estas constantes definem nveis de pinos como HIGH (alto ou ligado) ou LOW (baixo ou
desligado) e so usados quando estamos lendo ou escrevendo em pinos digitais. HIGH
definido como nvel lgico 1, ou 5 volts, enquanto o nvel lgico LOW definido como
0, ou 0 volts.

digitalWrite(13, HIGH);

Input/Output
Constantes so usadas com a funo pinMode() para definir o modo de um pino digital
como INPUT (entrada) ou OUTPUT (sada);

pinMode(13, OUTPUT);

Controle de Fluxo

If
O comando If funciona da seguinte forma: a condio verificada a cada passagem pela
estrutura IF. Se a condio for satisfeita (V), ento a lista de instrues que se encontra
entre chaves ser feita. Se a condio NO for satisfeita (F), ento sero feitas as
instrues existentes logo aps o fechamento das chaves.
Dica: Cuidado ao utilizar acidentalmente o = dentro do if, como por exemplo em if
(x=10), o que tecnicamente vlido, no entanto esta declarao atribui o valor 10 a x e
no testa se x igual a 10. Para realizar esse teste deve ser feito if (x==10).
O if pode tambm ser usado em conjunto com o comando else. O comando else atua
como uma espcie de seno, ou seja, se a condio do if no for verdadeira ele ir
realizar outra ao (especificada dentro das chaves).

if (inputPin == HIGH)
{
faaA;
}
else
{
faaB;
}

O else tambm pode ser precedido por outros testes condicionais, que devem ser
mutuamente exclusivos.

if (inputPin < 500)

{
faaA;
}

else if (inputPin >= 1000)

{
faaB;
}

else
{
faaC;
}
For
O comando for repete o bloco comandos enquanto a condio se manter verdadeira. A
parte de inicializao realizada apenas 1 vez, no incio da execuo do comando. A
seguir, a condio testada, e caso verdadeira, os comandos so executados. Aps a
execuo dos comandos mas antes de testar a condio, a parte incremento do
comando for executada.
O exemplo a seguir inicia com i igual a 0, testa se ele ainda menor do que 20 e caso
verdadeiro, incrementa o i em 1 e executa os comandos internos.

for (int i=0; i<20; i++) // declara i, e testa se menor do que 20,
incrementar
{ // incrementa i em 1 (somente no fim do ciclo)
digitalWrite(13, HIGH); // liga o pino 13
delay(250); // espera por de segundo
digitalWrite(13,LOW); // desliga o pino 13
delay(250); // espera por de segundo
}

While
Laos While iro continuar infinitamente at a expresso dentro dos parnteses se
tornar falsa. O exemplo a seguir testa se algumaVariavel menor do que 200 e se for
verdade executa os comandos entre as chaves continuadamente at algumaVariavel se
tornar igual ou maior que 200.

while (algumaVariavel < 200) // testa se menor que 200

{
FazIsso; // executa o comando;
algumaVariavel++; // incrementa a varivel em 1
}
Do...While
A diferena principal do lao Do...While e do lao While normal que a condio, no lao
Do...While, ser testada somente no fim do lao, permitindo que o conjunto de
comandos interno do lao seja executado pelo menos uma nica vez.
O exemplo a seguir atribui o valor de readSesnsors() para a varivel x, pausa por 50
milissegundos, e ento repete indefinidamente at que x no seja mais menor que 100.

do
{
X = readSensors(); // define o valor de readSensors() para x
delay(50); // pausa por 50 milissegundos
} while ( x < 100 ); // repete se x menor que 100

Entradas e Sadas Digitais

PinMode(pin, mode)
Utilizado na funo void setup () para configurar se um pino especfico ir se comportar
como INPUT (entrada) ou OUTPUT (sada).

pinMode(pin, OUTPUT); // define pin como OUTPUT

Os pinos digitais do Arduino so por padro definidos como inputs (entradas), ento eles
no precisam ser declarados explicitamente como inputs com pinMode(). Pinos
configurados como INPUT tambm so caracterizados como pinos em um estado de alta
impedncia.
Dependendo da situao (quando se utiliza um interruptor em um input, por exemplo)
pode ser conveniente utilizar um resistor pullup de 20KOhms. Felizmente, estes
resistores esto disponveis internamente no Atmega Chip (microcontrolador do
Arduino) e podem ser acessados por Software da seguinte maneira:

pinMode(pin, INPUT); // defini pin como input

digitalWrite(pin, HIGH); // liga o resistor de pullup
Pinos configurados como OUTPUT (sada) tambm so caracterizados como estando em
um estado de baixa impedncia e podem fornecer 40 mA de corrente para outros
dispositivos/circuitos. Isto suficiente para acender um LED (no esquea de utilizar um
resistor em srie, afim de limitar a corrente), mas no suficiente para acionar rels,
solenoides ou motores.
Alta corrente em pequenos circuitos conectados aos pinos do Arduino pode destruir um
pino de output, ou danificar um por completo um chip Atmega. uma boa prtica
sempre que conectar um pino OUTPUT a um dispositivo externo adicionar, em srie, um
resistor com 470Ohms ou 1KOhms.

DigitalRead(pin)
Realiza a leitura de um pino digital especfico com o resultado HIGH ou LOW. O pino
tambm pode ser especificado como uma varivel ou uma constante (0-13).

valor = digitalRead(pin); // define valor igual ao pino de input

DigitalWrite(pin, value)
Output podem definir nvel HIGH ou LOW (ligado ou desligado) em um pino digital
especfico. O pino tambm pode ser especificado como uma varivel ou uma constante
(0-13).

digitalWrite(pin, HIGH); // liga o pin

O exemplo a seguir l um boto conectado a uma input digital e liga um LED conectado
a uma output digital quando o boto pressionado.

int led = 13; // conectar o LED ao pino 13

int pin = 7; // conectar o boto ao pino 7
int valor = 0; // varivel para guardar e ler o valor

void setup()
{
pinMode(led, OUTPUT); // define o pino 13 como output
pinMode(pin, INPUT); // define o pino 7 como input
}
void loop()
{
valor = digitalRead(pin); // define valor igual ao pino de input
digitalWrite(led, valor); // atribui a led o valor do boto
}

Entradas e Sadas Analgicas

AnalogRead(pin)
L o valor de um pino analgico especfico com uma resoluo de 10 bits. Essa funo
s funciona com os pinos analgicos (0-5). O resultado ser um valor na faixa de 0 a
1023.

valor = analogRead(pin); // valor ser igual a pin

Dica: Pinos analgicos ao contrrio dos digitais, no necessitam ser declarados como
INPUT ou OUTPUT.
O exemplo a seguir faz a leitura de um valor analgico de um pino de entrada, converte
o valor dividindo por 4, e enviar um sinal PWM em um pino PWM.

int led = 10; // LED com um resistor de 220 no pino 10

int pin = 0; // potencimetro no pino analgico 0
int valor; // valor para leitura

void setup(){} // no necessrio setup

void loop()
{
valor = analogRead(pin); // defini valor igual a pin
valor =/ 4; // converte 0-1023 para 0-255
analogWrite(led, valor); // envia o sinal PWM para o led
}

Tempo

Delay(ms)
Pausa o programa pelo tempo especificado em milissegundos, onde 1000 igual a 1
segundo.

delay(1000); // Waits for one second

Millis()
Retorna o tempo de milissegundos desde que o Arduino comeou a executar o
programa.

tempo = millis(); // define valor igual a millis()

Dica: Depois de aproximadamente 9 horas o valor ir sofrer um overflow (voltar ao

zero).
Mnimo e Mximo

Min(x,y)
Calcula o mnimo de dois nmeros de qualquer tipo de dado e o retorna.
A = min(A, 100); // Define A como o menor entre A e 100

Max(x,y)
Calcula o mximo de dois nmeros de qualquer tipo de dado e o retorna.
A = max(A, 100); // Define A como o maior entre A e 100

Random (Aleatrio)

RandomSeed(seed)
Define um valor, ou seed, como o ponto inicial para a funo random().

randomSeed (valor); // define valor

O Arduino incapaz de criar um nmero aleatrio de verdade, assim a randomSeed

permite que voc utilize uma varivel, constante, ou outra funo dentro de uma funo
random (aleatria), o que ajuda a gerar nmeros aleatrios. Existe uma variedade de
diferentes seeds, ou funes, que podem ser utilizadas nesta funo, incluindo millis()
ou at mesmo analogRead() para realizar a leitura de um barulho eltrico de um pino
analgico.
Random(max) Radom(min,max)
A funo random permite retornar nmeros pseudo-aleatrios dentro de uma faixa
especificada por valores mnimos e mximos.

A = random(100, 200); // Define A como um nmero aleatrio entre 100

e 200

Dica: Use isto depois de usar a funo randomSeed().

O exemplo a seguir cria um nmero aleatrio entre 0-255 e envia um sinal PWM em
um pino PWM igual ao valor aletrio.
int randNumber; // varivel para guardar o valor aleatrio
int led = 10; // LED com um resistor de 220 no pino 10

void setup() {} // setup no necessrio

void loop()
{
randomSeed(millis()); //define millis() como seed
randNumber = random(255); // nmero aleatrio de 0 a 255
analogWrite(led, randNumber); // enviar o sinal PWM
delay(500); // pausa por segundo
}
Serial

Serial.begin(rate)
Abre a porta serial e define a taxa de transmisso para a transmisso de dados. A taxa
tpica utilizada para a comunicao com o computador 9600 apesar de outras
velocidades serem suportadas.
void setup()
{
Serial.begin(9600); // opens serial port
}
Dica: Quando se est usando comunicao serial, pinos digitais 0 (RX) and 1 (TX) no
podem ser utilizados ao mesmo tempo.

Serial.println(data)
Imprime na porta serial (serial port). Este comando tem a mesma forma que Srial.print(),
mas mais fcil de ler data no Serial Monitor.
Serial.println(analogValue); // enviar o valor de analogValue
O exemplo a seguir realiza a leitura do pino analgico 0 e envia seus dados para o
computador a cada segundo.
void setup ()
{
Serial.begin(9600); // define a taxa de transferncia para 9600
}
void loop()
{
Serial.println(analogRead(0)); // Enviar o valor analgico
Delay(1000); // pausa por 1 segundo
}
Extra: Interrupes

Uma interrupo um sinal que interrompe o que quer que o processador esteja a
calcular naquele momento, para executar outra funo distinta. A interrupo pode
acontecer atravs de um sinal externo (por exemplo, o pressionar de um boto) ou de
um sinal interno (por exemplo, um temporizador ou um sinal de software). Uma vez
chamada, a interrupo pausa o que o processador estiver a fazer naquele momento, e
faz com que se execute uma outra funo conhecida como Rotina de Servio de
Interrupo (ou pela sigla em ingls, ISR). Uma vez que a ISR tenha finalizado, o
programa volta funo, que estava a correr anteriormente.

Conexes Elctricas
O nmero de pinos que podem ser utilizados como interrupts depende da placa que
estivermos a utilizar. Para o Arduino Uno e derivados, so 2, e encontram-se nos pinos
2 e 3, correspondendo ao interrupt 0 e interrupt 1 respectivamente.

Usando as interrupes

Para utilizar as interrupes, em primeiro lugar temos que declarar que interrupo
queremos utilizar. No nosso caso utilizaremos a interrupo 0, que est no pino
nmero 2. Para isso declaramos:
int interrupcao = 0;

Agora, no setup, temos que especificar que funo ir ser chamada no caso de ocorrer
a interrupo. Para isso, utilizamos a funo attachInterrupt, que tem a seguinte
sintaxe:

attachInterrupt(interrupt, ISR, mode);

Os argumentos da funo attachInterrupt so:

Interrupt: nmero da interrupo, ou seja, em que pino devemos escutar para esperar
pela interrupo.
ISR: funo que ir ser chamada, no caso de ocorrer a interrupo.
Mode: define como a ISR ser lanada, ou seja, o que tem que acontecer para que se
execute a interrupo. Os diferentes modos so:
LOW: executa-se sempre que o valor no pino seja 0.
CHANGE: executa-se sempre que se produza uma alterao.
RISING: executa-se enquanto o valor v de 0 at 1 (ou de 0 at 5 Volts).
FALLING: executa-se enquanto o valor v de 1 a 0 (ou de 5 at 0 Volts).
H que ter em conta que necessrio escrever os modos, com letras maisculas, se no
vai produzir-se um erro. No nosso caso, utilizamos

attachInterrupt(interrupcao, funcionInterrupcao, FALLING);

que detectar quando deixamos de pressionar o boto. Por outro lado, temos que
definir a funo que se ir chamar quando for detectada a interrupo. Neste caso,
chammos a funo funcionInterrupcao, e vamos defini-la com o mesmo nome que
colocmos em attachInterrupt. A funo :

void funcionInterrupcao()
{
Serial.print("Interrupo nmero ");
Serial.println(numInterrupt);
numInterrupt++;
}

Aqui imprimimos atravs do monitor srie, o nmero de vezes que ocorreu a

interrupo. Uma das particularidades das interrupes que no podem ter nenhum
argumento na sua definio nem devolver nenhum valor, e por isso, para assegurar que
a ISR tenha um bom acesso s variveis, temos que utilizar uma varivel de tipo volatile,
e neste caso, de tipo int. Outra das restries das interrupess que, enquanto
estivermos dentro de uma ISR, o resto das outras interrupes no sero detectadas,
no funcionar o delay e no se atualizar o valor de millis, e por isso importante que
as ISR sejam o mais curtas possvel.
Bibliotecas

As bibliotecas tem terminao ".h" e tem com tarefa informar dados e permitir uso de
funes. Basicamente, na linguagem de programao possvel criar vrias pginas com
cdigos "ocultos" que podem ser usados por outros programas. Dessa forma o
desenvolvimento facilitado pelo compartilhamento de cdigos. No exemplo abaixo
iremos utilizar a biblioteca MsTimer2. No cdigo teremos
include MsTimer2 incluindo a biblioteca MsTimer2 no cdigo abaixo.

Em seguida iremos adiciona-la.

Inicialmente temos uma biblioteca que desejamos usar.
Ela j est pronta, mas preciso baixar no computador e colocar na pasta correta da
IDE do Arduino, permitindo ser acessada.
Veja a foto abaixo onde possvel encontrar esta biblioteca.

possvel notar o arquivo pra download que est compactado (.zip).

Clique no link e inicie o download e escolha uma pasta para salvar esse arquivo.
Aps baixar. Clicar com boto direito e descompactar o arquivo.
Assim que descompactar, uma pasta surgir referente a biblioteca desejada.
Neste caso a MsTimer2

Vamos ento para a pasta onde o "Arduino se encontra" que voc instalou para usar a
IDE(interface de desenvolvimento). Procure no seu PC.
Observe a pasta: libraries. nesta que o arquivo descompactado deve ser posicionado.
Transfira a pasta MsTimer2 para a pasta: libraries

Veja como fica:

Agora execute a IDE do Arduino para conferir se deu tudo certo.

Siga as setas e observe que a biblioteca foi adicionada.

Agora voc est pronto para usar as funes desta biblioteca ou de qualquer outra que
desejar.
Gravando e compilando

Para gravar ou compilar, basta usar os botes que esto na IDE, os quais esto ilustrados
na figura 2.10:

Figura 2.10 - Gravando e compilando

O primeiro boto compila o cdigo, ou seja, verifica se existe algum erro de sintaxe no cdigo,
j o segundo grava o sketch no Arduino, faz o upload do cdigo. Aps clicar em algum desses
botes ir abrir uma janela para que salve o arquivo.
Bibliografia

http://forefront.io/a/beginners-guide-to-arduino/ < Acesso em 16/04/17 >

http://www.instructables.com/id/A-Beginners-Guide-to-Arduino/ < Acesso em 16/04/17 >

Arduino bsico 2 Edio - Michael McRoberts

Practical Arduino Jonathan Oxer

Beginning C for Arduino Jack Purdum

https://www.embarcados.com.br/arduino-entradasaidas-digitais/ < Acesso em 17/04/17 >