Apostila de Arduino

UNIVERSIDADE DE SÃO PAULO
ESCOLA DE ENGENHARIA DE LORENA
TUTORIAL
Experimentos e conceitos de programação computacional usando o
microcontrolador ARDUINO
SUMÁRIO
Conteúdo Pág.
Projeto 1: LED pisca pisca 1
Projeto 2: Código Morse 6
Projeto 3: Semáforo 9
Projeto 4: Semáforo interativo 10
Projeto 5: Perseguição de LEDs 12
Projeto 6: Efeito interativo de perseguição de LEDs 16
Projeto 7: Lâmpada pulsante 20
Projeto 8: Lâmpada de humor 22
Projeto 9: Efeito fogo de LED 21
Projeto 10: LEDs controlados 28
Projeto 11: Acionando um motor CC 35
Projeto 12: Atuador piezelétrico 38
Projeto 13: Sensor de temperatura com o CI LM35 31
Prof. Carlos Yujiro Shigue
Lorena, SP
2014
Projeto 1 - LED Pisca-Pisca protoboard for nova, o ajuste nos furos fará com
que a inserção dos componentes seja um pouco
Neste projeto vamos configurar e programar o mais dura. Deixar de inserir os componentes com
Arduino para fazer um LED piscar. Vamos usar cuidado pode resultar em danos. Verifique se o
LED vermelho para ensinar alguns conceitos de seu LED está ligado da maneira certa com a perna
eletrônica e de codificação em C ao longo do mais comprida conectada ao pino digital 10. A
caminho. perna longa do LED é o anodo (+) e deve sempre
ir para a alimentação de +5 V (neste caso, que sai
Componentes do pino digital 10) e a perna mais curta é o
catodo (-) e deve ir para o pino terra (GND).
Quando você estiver certo de que tudo está ligado
corretamente, conecte o Arduino ao computador
pelo cabo USB.
A seguir, abra o IDE Arduino e digite o seguinte
código:
// Projeto 1 - LED Pisca-Pisca

int ledPin = 10;
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
digitalWrite(ledPin, HIGH);
delay(1000);
digitalWrite(ledPin, LOW);
delay(1000);
}
Montagem
Primeiro, certifique-se que o seu Arduino está Agora pressione o Verificar / Compilar, botão no
desligado. Você pode fazer isso desconectando o topo da IDE, para se certificar de que não há erros
cabo USB ou tirando o jumper alimentador do em seu código. Se esta for bem sucedida, agora
Arduino. Em seguida, faça as ligações desta você pode clicar no botão Upload para enviar o
maneira: código para o Arduino. Se você tiver feito tudo
certo, você deve ver agora o LED vermelho na
protoboard piscar e desligar a cada 1 segundo.
Agora vamos dar uma olhada no código e no
hardware e descobrir como ambos trabalham.
Descrição do código
// Projeto 1 - LED Pisca-Pìsca
int ledPin = 10;
void setup() {
}
void loop() {
delay(1000);
delay(1000);
}
Então vamos dar uma olhada no código para este

projeto, nossa primeira linha é:
Não importa se você usa diferentes fios coloridos // Projeto 1 - LED Pisca-Pisca
ou se usa orifícios diferentes sobre a protoboard,
mas necessáriamente os componentes e os fios Isto é simplesmente um comentário no seu código
têm de serem ligados da mesma forma que o e é ignorado pelo compilador (a parte do IDE que
mostrado na Figura acima. Tenha cuidado ao transforma o seu código em instruções do Arduino
inserir os componentes na protoboard. Se a pode compreender antes de carregá-lo). Qualquer
1
texto inserido por trás de um comando // será composto de letras, números e caracteres de
ignorado pelo compilador e simplesmente está lá sublinhado. A linguagem C reconhece as letras
para você, ou qualquer outra pessoa que lê seus maiúscula e minúscula como sendo diferentes.
códigos. Comentários são essenciais em seu E finalmente, você não pode usar as
código para lhe ajudar a entender o que está palavras-chave do C como main, para nomear as
acontecendo e como funciona o seu código. Os variáveis. Palavras-chave são constantes,
comentários também podem ser colocados após os variáveis e nomes de funções que são definidas
comandos como na próxima linha do programa. como parte da linguagem do Arduino. Usar um
Mais tarde, como os projetos se tornam mais nome variável é o mesmo que uma palavra-chave.
complexos e seu código expande-se em centenas Todas as palavras-chave no desenho irão aparecer
ou talvez milhares de linhas, os comentários serão em vermelho.
vitais para torná-lo fácil para você ver como ele Assim, você irá configurar uma área na memória
funciona. Você pode vir até com um espantoso para armazenar um número do tipo inteiro e ter
pedaço de código, mas se você voltar e olhar esses armazenado nessa área o número 10. Imagine uma
códigos dias, semanas ou meses depois, você pode variável como uma pequena caixa onde você pode
esquecer como tudo funciona. Os comentários manter as coisas. Uma variável é chamada de
irão ajudá-lo a compreendê-lo facilmente. variável, porque você pode mudá-la. Mais tarde,
Além disso, se seu código é feito para ser visto vamos fazer os cálculos matemáticos sobre as
por outras pessoas e como todo o ethos do variáveis para ampliar os nossos programas e
Arduino, é de fato fonte aberta à comunidade, fazer coisas mais avançadas.
esperamos que quando você começar a fazer seu Em seguida, temos a nossa função setup()
próprio material com o Arduino, você esteja
disposto a compartilhá-lo com o mundo em void setup() {
seguida, comentários permitirão que as outras }
pessoas entendam o que está acontecendo no seu
código. Você também pode colocar comentários A função setup () é executada uma vez, e apenas
em uma instrução usando em bloco comandos / * uma vez no início do programa, onde você vai
e * /. fazer emitir instruções gerais para preparar o
Por exemplo, /* Todo o texto dentro da barra e os programa antes das corridas loop principal, como
asteriscos é um comentário e será ignorado pelo a criação de modos de pinos, estabelecendo taxas
compilador * / A IDE irá ligar automaticamente a de transmissão de série, etc.
cor de qualquer texto comentado com cinza. Basicamente, uma função é um bloco de código
A próxima linha do programa é: montado em um bloco conveniente. Por exemplo,
se nós criarmos a nossa própria função para levar
int ledPin = 10; a cabo uma série matemática complicada que
tiveram muitas linhas de código, poderia executar
Isto é conhecido como uma variável. Uma
esse código quantas vezes nós gostamos
variável é um local para armazenar dados. Neste simplesmente chamando o nome da função em
caso, você está configurando uma variável do tipo
vez de escrevê-la novamente:
int ou inteiro. Um inteiro é um número na faixa de
- 32.768 a + 32.767.
Em seguida, você atribuiu o nome inteiro de
ledPin e deram-lhe um valor de 10. Nós não
temos que chamá-lo de ledPin, poderíamos tê-lo
chamado de qualquer coisa que quisessemos.
Mas, como queremos que o nosso nome da
variável seja descritivo o chamamos de ledPin
para mostrar que o uso desta variável é para
definir quais os pinos no Arduino vamos usar para
se conectar ao nosso LED. Neste caso, estamos
usando o pino digital 10.
No final desta declaração, é um ponto e vírgula.
Este é um símbolo para dizer ao compilador que
esta declaração está completa. Apesar de Mais tarde, vamos entrar em funções com mais
podermos chamar as nossas variáveis do jeito que detalhes quando começarmos a criar as nossas
quisermos, cada nome de variável em C deve próprias manipulações. No caso do nosso
começar com uma letra, o resto do nome pode ser programa o setup() funciona apenas como uma
2
instrução para realizar alguma tarefa. Outra O void loop() é a função principal do
função começa com: programa e é executado continuamente desde que
o nosso Arduino esteja ligado. Toda declaração
void setup() dentro da função loop() (dentro das chaves) é
realizado, um por um, passo a passo, até que a
e aqui estamos dizendo ao compilador que a nossa parte inferior da função é atingida, e então o laço
função é chamada de configuração(setup), que começa de novo no topo da função, e assim por
não retorna dados (void) e que passamos sem diante para sempre ou até que você desligue o
parâmetros para ele (parênteses vazio). Arduino ou pressione o botão reset.
int myFunc(int x, int y) Neste projeto, queremos que o LED ligue, fique
por um segundo, desligue e permaneça desligado
Neste caso, criamos uma função (ou um bloco de por um segundo, e repita isso. Portanto, os
código) chamado myFunc. Esta função foi comandos para dizerem ao Arduino para fazer o
passada a dois inteiros chamados x e y. Uma vez que está contido dentro do circuito ( ) e funcionar
que a função tem término irá retornar a um valor como desejamos e repetir infinitamente.
inteiro para o ponto depois de onde a nossa função A primeira declaração é:
foi chamada no programa (daí int antes do nome
da função).
Todo o código dentro da função está contido
e este escreve um sinal alto (HIGH) ou um valor
dentro das chaves. Um símbolo { inicia o bloco de
baixo (LOW) para o pino digital na declaração
código e um símbolo } termina o bloco. Qualquer
(neste caso ledPin, que é o pino digital 10).
coisa entre estes dois símbolos é o código que
pertence à função. Quando você definir um pino digital para HIGH
Nós vamos entrar em maiores detalhes sobre as você está mandando 5 volts para o pino. Quando
funções mais tarde assim não se preocupe com você configurá-lo para LOW fica 0 volts.
eles agora. Tudo que você precisa saber é que Depois disso temos:
neste programa temos duas funções: a primeira
delay(1000);
função é chamada de configuração (setup) e sua
finalidade é dar a configuração necessária para o Esta declaração simplesmente diz ao Arduino para
nosso programa para trabalhar antes que o laço esperar 1000 milissegundos (1 segundo) antes de
principal do programa (loop) seja executado. realizar a próxima declaração de que é:
void setup() {
pinMode(ledPin, OUTPUT); digitalWrite(ledPin, LOW);
}
que vai desligar a energia do pino digital 10 e
Nossa função de instalação tem apenas uma portanto, desligar o LED. Há então outro atraso da
declaração que é pinMode. Aqui nós estamos declaração por mais 1000 milisegundos e depois a
dizendo ao Arduino que queremos ajustar o modo função termina. No entanto, como este é o nosso
de um dos nossos pinos digitais de saída para ser laço principal loop(), a função irá agora
saída, em vez de entrada. Dentro do parêntese recomeçar do início. Seguindo a estrutura do
colocamos o número de pinos e o modo (OUTPUT programa passo-a-passo, podemos ver que é muito
ou INPUT). Nosso número de pinos é ledPin, simples.
que foi anteriormente definido para o valor 10 no
nosso programa. Por conseguinte, esta declaração // Projeto 1 - LED Pisca-Pìsca
int ledPin = 10;
irá simplesmente dizer para o Arduino que o pino void setup() {
digital 10 deve ser configurado para o modo saída. pinMode(ledPin, OUTPUT);
}
Como a função setup() é executada somente void loop() {
uma vez, passemos para o circuito principal: delay(1000);
void loop() { delay(1000);
digitalWrite(ledPin, HIGH); }
delay(1000);
delay(1000); Começamos por atribuir uma variável chamada
}
ledPin, dando a essa variável um valor 10.
3
Em seguida, passamos à função setup() que O código Morse é um tipo de codificação que
simplesmente define o modo para o pino digital transmite letras e números usando padrões ON e
10 como saída (OUTPUT). OFF. Ele é, portanto, bem adequado para os
No laço principal do programa que estabelecemos nossos sistemas digitais como podemos
pino digital 10 HIGH, envio de 5 V. Então vamos transformar um LED ligado e fora do padrão
esperar por um segundo e, em seguida, desligar o necessário para soletrar uma palavra ou uma série
5 V do pino 10, antes de esperar outro 1 s. O laço, de caracteres.
em seguida, começa do início e o LED, portanto, Neste caso estaremos sinalizando S.O.S. que no
liga e desliga continuamente enquanto o Arduino alfabeto do código Morse é de três pontos (flash
estiver energizado. curto), seguido por três traços (flash de
Agora que você sabe isso, você pode modificar o comprimento longo), seguido por três pontos
código para ligar o LED em um período diferente novamente.
de tempo e também desligá-lo por um período de Podemos, portanto, agora com código do nosso
tempo diferente. esboço piscar o LED ON e fora deste padrão,
Por exemplo, se quisermos que o LED permaneça sinalizando SOS. Digite o código para criar uma
aceso por dois segundos, em seguida, desligado nova configuração. Verifique se o seu código é
meio segundo nós poderíamos fazer o seguinte: livre de erros e, em seguida, envie-o para o seu
Arduino.
void loop() { Se tudo correr bem você vai ver agora o LED em
delay(2000); flash o código sinal Morse SOS, aguarde 5
digitalWrite(ledPin, LOW); segundos, em seguida, repita. Então, vamos dar
delay(500);
} uma olhada neste código e descobrir como ele
funciona.
ou talvez você gostaria que o LED fique desligado
// Projeto 2 – Codigo Morse SOS
por 5 segundos e, em seguida, piscar rapidamente // LED connected to digital pin 10
(250 ms), como o LED indicador de um alarme de int ledPin = 10;
carro, então você poderia fazer isso: // run once, when the sketch starts
void setup()
void loop() { {
digitalWrite(ledPin, HIGH); // sets the digital pin as output
delay(250); pinMode(ledPin, OUTPUT);
digitalWrite(ledPin, LOW); }
delay(5000); // run over and over again
} void loop()
{
ou fazer o LED ligar e desligar muito rápido: // 3 dits
for (int x=0; x<3; x++) {
void loop() { digitalWrite(ledPin, HIGH); // sets the
digitalWrite(ledPin, HIGH); LED on
delay(50); delay(150); // waits for 150ms
digitalWrite(ledPin, LOW); digitalWrite(ledPin, LOW); // sets the
delay(50); LED off
} delay(100); // waits for 100ms
}
Variando entre ligar e desligar o LED, você pode // 100ms delay to cause slight gap
criar qualquer efeito que desejar. between letters
delay(100);
// 3 traços
for (int x=0; x<3; x++) {
Projeto 2 - Código Morse SOS digitalWrite(ledPin, HIGH); // sets the
LED on
sinalizador delay(400); // waits for 400ms
digitalWrite(ledPin, LOW); // sets the
LED off
Para este projeto, vamos deixar o circuito
delay(100); // waits for 100ms
exatamente do mesmo jeito configurado como no }
Projeto 1, mas teremos algumas diferenças no // 100ms delay to cause slight gap
código para fazer o display LED emitir uma between letters
mensagem em código Morse. Neste caso, faremos delay(100);
// 3 dits again
com que o LED sinalize as letras S.O.S., que é o for (int x=0; x<3; x++) {
código Morse internacional de sinal de socorro. digitalWrite(ledPin, HIGH); // sets the
LED on
4
delay(150); // waits for 150ms Neste caso, o laço será executado enquanto x for
digitalWrite(ledPin, LOW); // sets the
LED off
menor do que (<) 3. O código dentro de um laço
delay(100); // waits for 100ms for será sempre executado uma vez e não
} importa como a condição é definida. O símbolo <
// wait 5 seconds before repeating the é conhecido como um operador de comparação.
SOS signal
delay(5000);
Eles são usados para tomar decisões dentro de seu
} código e comparar dois valores. Os símbolos
utilizados são:
Projeto 2 – Revisão do código
Assim, a primeira parte do código é idêntica ao
último projeto em que inicializa um pino variável
e define-se o pino 10 para ser uma saída. No
código principal, podemos ver o mesmo tipo de
declaração para transformar os LEDs ligados e
desligados por um período definido de tempo,
mas desta vez as declarações estão dentro de três No nosso código estamos comparando x com o
blocos de código separados. valor 3 para ver se é menor do que ele. Se x for
O primeiro bloco é o que gera três piscadas menor que 3, então o código do bloco será
repetido novamente. A declaração final é x++:
for (int x=0; x<3; x++) { esta é uma instrução para aumentar o valor de x
digitalWrite(ledPin, HIGH); em 1. Poderiamos ter digitado também x = x+1,
delay(150);
digitalWrite(ledPin, LOW); o que faria atribuir a x o valor de x + 1. Observe
delay(100); que não há necessidade de colocar um ponto e
} vírgula após esta declaração final, em loop. Você
pode fazer operações matemáticas simples,
Podemos ver que o LED é ligado por 150 ms e usando os símbolos +, -, * e / (adição, subtração,
então desligado 100 ms. Podemos ver que aquelas multiplicação e divisão). Por exemplo:
declarações que estão dentro de um conjunto de
chaves são, portanto, um bloco de código
separado. Mas, quando executamos o sketch,
podemos ver que a luz pisca três vezes e não
apenas uma vez. Isso é feito usando o laço for:
for (int x=0; x<3; x++) {

Assim, o nosso laço para inicializar compara o
Esta declaração é o que torna o código dentro de valor de x com 3, em seguida, é executado o
seu código executar três vezes. Existem 3 código dentro do bloco. Então aumenta o
parâmetros para dar o laço. Estes são de incremento, neste caso adiciona 1 a x.
inicialização, incremento e condição. A Em seguida, verifica se a condição foi atendida, o
inicialização acontece pela primeira vez e que é se x é menor do que 3, e se repete. Então,
exatamente uma vez. Cada vez através do loop, a agora podemos ver em nosso código que há três
condição é testada e, se ele é verdadeiro, o bloco laços, que circulam três vezes e exibe os pontos,
de declaração, e o incremento são executados, em no próximo repete três vezes e exibe os traços,
seguida, a condição é testada novamente. Quando então segue a repetição dos pontos novamente.
a condição se torna falsa, o laço termina. Então, Deve-se notar que a variável x tem um alcance
primeiro precisamos inicializar uma variável para local, o que significa que só pode ser visto pelo
ser o início do loop. Neste caso, configurar a código dentro seu bloco. A menos que você
variável X e configurá-lo para zero. inicialize-o antes da função setup(), caso em
que tem um alcance global e pode ser visto por
int x=0; todo o programa. Se você tentar acessar x fora do
laço você obterá um erro. Entre cada ciclo “for”
Em seguida, definir uma condição para decidir existe um pequeno atraso para fazer uma pequena
quantas vezes o código no loop será executado. pausa visível entre as letras de SOS. Finalmente, o
código espera 5 segundos antes do principal laço
x < 3; do programa e recomeça desde o início.
5
// Projeto 3 - Semáforo
Projeto 3 – Semáforo int ledDelay = 10000; // delay in between
changes
Agora vamos criar um conjunto de semáforos que int redPin = 10;
vai mudar de verde para amarelo e depois int yellowPin = 9;
int greenPin = 8;
vermelho e depois volta novamente, depois de um void setup() {
conjunto período de tempo utilizando os quatro pinMode(redPin, OUTPUT);
estados do sistema. Este projeto poderia ser pinMode(yellowPin, OUTPUT);
utilizado em uma estrada de ferro modelo ou para pinMode(greenPin, OUTPUT);
}
uma minicidade de brinquedo. void loop() {
// turn the red light on
Você precisará de: digitalWrite(redPin, HIGH);
delay(ledDelay); // wait 5 seconds
digitalWrite(yellowPin, HIGH); // turn on
yellow
delay(2000); // wait 2 seconds
digitalWrite(greenPin, HIGH); // turn
green on
digitalWrite(redPin, LOW); // turn red
off
digitalWrite(yellowPin, LOW); // turn
yellow off
delay(ledDelay); // wait ledDelay
milliseconds
digitalWrite(yellowPin, HIGH); // turn
yellow on
digitalWrite(greenPin, LOW); // turn
green off
delay(2000); // wait 2 seconds
digitalWrite(yellowPin, LOW); // turn
yellow off
// now our loop repeats
Montagem: }
No próximo projeto, vamos adicionar a este

projeto um conjunto de luzes de pedestres e
também adicionar um botão de pulso para fazer as
luzes interagirem.
Projeto 4 - Semáforo interativo

Desta vez, vamos estender o projeto anterior de
modo a incluir um conjunto de luzes de pedestre.
Pressionar o botão para atravessar a rua e o
Arduino reagirá quando o botão está pressionado,
alterando o estado das luzes para fazer os carros
pararem e permitir que o pedestre atravesse com
segurança.
Pela primeira vez, somos capazes de interagir com
o Arduino e fazer com que ele faça alguma coisa
Desta vez vamos ligar três LEDs com o anodo de quando nós alterarmos o seu estado (pressione
cada um indo para pinos digitais 8, 9 e 10, através para alterar o estado de aberto para fechado).
de três resistores de 150Ω. Tomamos um fio de Neste projeto você também vai aprender como
terra para o trilho solo no topo da placa de criar suas próprias funções.
montagem e um longo fio que vai a partir da
perna do catodo de cada LED para a trilha O que você precisará:
comum. Digite o código a seguir, verificar e fazer
o upload. Se você leu os Projetos 1 e 2, então este
código deverá ser auto-explicativo assim como o
hardware.
6
tráfego pode continuar. O código deste projeto é
semelhante ao do projeto anterior. No entanto,
existem algumas declarações novas e conceitos
que foram introduzidos. Então, vamos ver:
// Projeto 4 – Semaforo interativo

// Atribue as luzes para os carros
int carRed = 12;
int carYellow = 11;
int carGreen = 10;
int pedRed = 9;
// Atribue as luzes do pedestre
int pedGreen = 8;
int button = 2; // Pino do botao
int crossTime = 5000; // Tempo travessia
unsigned long changeTime; // Tempo desde
Montagem que o botao foi pressionado
void setup() {
pinMode(carRed, OUTPUT);
pinMode(carYellow, OUTPUT);
pinMode(carGreen, OUTPUT);
pinMode(pedRed, OUTPUT);
pinMode(pedGreen, OUTPUT);
pinMode(button, INPUT);
// Acende a luz verde para os carros
digitalWrite(carGreen, HIGH);
digitalWrite(pedRed, HIGH);
}
void loop() {
int state = digitalRead(button);
/* Verifica se o botao foi pressionado ha
mais de 5 s desde a ultima vez */
if (state == HIGH && (millis() -
changeTime) > 5000) {
// Chama a funcao para alterar as luzes
changeLights();
}
}
Digite o código da página seguinte, verificar e void changeLights() {

carregá-lo. digitalWrite(carGreen, LOW); // Desliga o
Quando executar o programa você verá que o verde
digitalWrite(carYellow, HIGH); // Liga o
semáforo para carros começa no verde para amarelo
permitir que os carros passem e a luz de pedestres delay(2000); // Aguarda 2 segundos
está no vermelho. Quando pressionar o botão, o digitalWrite(carYellow, LOW); // Desliga
programa verifica se pelo menos 5 segundos se o amarelo
digitalWrite(carRed, HIGH); // Liga o
passaram desde a última vez que as luzes foram vermelho
alteradas (para permitir o tráfego entrar em delay(1000); // Aguarda 1 s de seguranca
movimento), e assim passa a execução do código digitalWrite(pedRed, LOW); // Desliga o
para a função que nós criamos chamada vermelho do pedestre
digitalWrite(pedGreen, HIGH); // Liga o
changeLights(). Nesta função, as luzes do verde do pedestre
semáforo vão de verde para amarelo e depois delay(crossTime); // Aguarda o tempo
vermelho, em seguida as luzes de pedestres prefixado para travessia do pedestre
tornam-se verde. Após um período de tempo // Pisca o verde do pedestre
for (int x=0; x<10; x++) {
fixado no Crosstime variável (tempo suficiente
digitalWrite(pedGreen, HIGH);
para permitir que os pedestres atravessem) a luz delay(250);
verde para pedestres irá acender e apagar como digitalWrite(pedGreen, LOW);
um aviso para os pedestres para atravessar de delay(250);
pressa e que as luzes estão prestes a mudar de }
// Liga o vermelho do pedestre
volta ao vermelho. Então, o semáforo de pedestres digitalWrite(pedRed, HIGH);
retorna para o vermelho e as luzes do semáforo delay(500);
para veículos vão do vermelho para o verde e o
7
digitalWrite(carYellow, HIGH); // Liga o tempo e tudo ser feito com ele. Bem, a razão é
amarelo
digitalWrite(carRed, LOW); // Desliga o
porque as variáveis ocupam espaço na memória
vermelho assim como os números e isso pode prejudicar o
delay(1000); armazenamento de variáveis.
digitalWrite(carGreen, HIGH); Em seu PC ou laptop você não terá que se
digitalWrite(carYellow, LOW); // Desliga
preocupar com isso, mas em um microcontrolador
o amarelo
// Registra o tempo desde a ultima pequeno como o Atmega328, é essencial usarmos
mudanca do semaforo apenas os menores dados variáveis necessários
changeTime = millis(); para o nosso propósito.
// Retorna ao laco do programa principal Existem vários tipos de dados que podemos usar
}
em nossos sketches e estes são:
Projeto 4 – Descrição do código Tipo de dado RAM Faixa
void keyword N.D. N.D.
Você vai entender e reconhecer a maioria do boolean 1 byte 0 e 1 (falso/verdade)
byte 1 byte 0 a +255
código neste projeto a partir dos projetos char 1 byte -128 a +127
anteriores. No entanto, vamos dar uma olhada em unsigned char 1 byte 0 a +255
algumas palavras-chave e conceitos novos que Int 2 byte -32768 a +32767
unsigned int 2 byte 0 a +65535
foram introduzidas neste sketch. word 2 byte 0 a +65535
long 4 byte -2147483548 a
unsigned long changeTime; +2147483547
unsigned long 4 byte 0 a +4294967295
float 4 byte -3,4028235.10+38 a
Aqui temos um novo tipo de dado (unsigned +3,4028235.10+38
long) para uma variável. Anteriormente criamos double 4 byte -3,4028235.10+38 a
+3,4028235.10+38
tipos de dados inteiros, que podem armazenar um string 1 byte + x Matriz de caracteres
número entre -32.768 e +32.767. Agora, criamos array 1 byte + x Coleção de variáveis
um tipo armazenador de dados longo, que pode
armazenar um número de -2.147.483.648 a Em cada tipo de dado usa-se certa quantidade de
+2.147.483.647. No entanto, especificou-se um memória do Arduino, como pode ser observado
unsigned long, que significa que a variável na Tabela acima. Algumas variáveis usam apenas
não pode armazenar números negativos, de tal 1 byte de memória e outras usam 4 bytes ou mais.
maneira que nos dá um intervalo de 0 a O microcontrolador ATmega168 tem 1 kB (1000
4.294.967.295. Se fosse usar um número inteiro bytes) e o Atmega328 tem 2 kB (2000 bytes) de
para armazenar o período de tempo desde a última SRAM; isto não é muito e em programas de
mudança de luzes, só iria ter um tempo máximo grande porte com muitas variáveis você poderia
de 32 segundos antes de a variável inteira atingir facilmente usar muita memória. A partir da
um número maior do que ele pode armazenar. Tabela acima, podemos ver claramente que o uso
Como numa faixa de pedestres é improvável que do tipo de dados int é um desperdício, pois
seja utilizado tempo pequeno, de no máximo 32 s, utiliza 2 bytes e pode armazenar um número
não queremos o programa falhando devido a inteiro até 32.767. Como temos usado int para
nossa variável transbordando quando se tenta armazenar o número do nosso pino digital, que só
armazenar um número muito maior que o tipo de vai até 13 no Arduino Uno (e até 54 no Arduino
variável inteira. É por isso que usamos um tipo de Mega), temos usado mais memória do que o
variável unsigned long para obter um necessário. Poderíamos ter economizado memória
comprimento de tempo longo o suficiente para utilizando o tipo de dados byte, que pode
travessia de pedestres. armazenar um número entre 0 e 255, que é mais
do que suficiente para armazenar o número de
4.294.967.295 x 1 ms = 4.294.967 segundos pinos de entrada/saída (E/S) do Arduino.
4.294.967 segundos = 71.582 minutos
71.582 minutos = 1.193 horas Em seguida, temos:
1.193 horas = 49 dias
pinMode(button, INPUT);
Como é bastante difícil que em uma faixa de
pedestres o botão não seja pressionado pelo Isto diz ao Arduino que queremos usar o pino
menos uma vez em 49 dias, não devemos ter um digital 2 (button = 2) como INPUT. Nós vamos
problema como este de dados. Você pode usar o pino 2 para o botão pressionado e o seu
perguntar por que nós não temos só um conjunto modo deve ser definido como entrada. No laço
de dados que pode armazenar grandes números de
8
principal do programa verifica o estado do pino
digital 2 com esta declaração: state == HIGH
int state = digitalRead(button); e o cálculo é um exemplo de um operador

booleano. Para ver o que nós queremos dizer com
Este inicializa um inteiro (sim, um desperdício e isso, vamos dar uma olhada em todos os
nós deveríamos usar uma variável booleana), em operadores booleanos.
seguida, define o valor de estado para ser o valor
do pino digital 2. A declaração digitalRead lê && E lógico (AND)
o estado do pino digital dentro do parêntese e || OU lógico (OR)
! NÃO (NOT)
retorna para os números inteiros que foram
atribuídos a ele.
Estas são afirmações lógicas que podem ser
Podemos, então, verificar o valor no estado para
usadas para testar diversas condições em if. O
ver se o botão foi pressionado ou não.
operador && significa verdadeiro se ambos os
if (state == HIGH && (millis() - operadores são verdadeiros, por exemplo,
changeTime) > 5000) {
changeLights(); if (x == 5 && y == 10) {…
}
Esta declaração if vai executar o seu código se e
A instrução if é um exemplo de uma estrutura de somente se x for igual a 5 e também se y for igual
controle e sua finalidade é verificar se uma a 10. | | significa verdadeiro se o operando for
determinada condição foi cumprida ou não, e se verdadeiro. Por exemplo
sim, para executar o código dentro do seu bloco
de código. Por exemplo, se quiséssemos if (x == 5 || y == 10) {…
transformar um LED em uma variável chamada x
e subir acima do valor de 500 podemos escrever: Será executado se x for 5 ou se y for 10.
if (x>500) {digitalWrite(ledPin, HIGH); if (!x) {…
Quando lemos um pino digital usando o comando Será executado se x for falso, ou seja igual a zero.
digitalRead, o estado do pino irá ser HIGH ou Você pode também reunir condições com
LOW. Assim, o comando if em nosso sketch é: parênteses, por exemplo:
if (state == HIGH && (millis()- if (x==5 && (y == 10 || z == 25)) {…

changeTime) > 5000)
Neste caso, as condições dentro do parêntese
O que estamos fazendo aqui é verificar se duas interno são processadas separadamente e tratadas
condições foram satisfeitas. A primeira é que a como uma única condição e, em seguida,
variável chamada estado é elevada. Se o botão foi comparada à segunda condição. Assim, se
pressionado vai ser elevada como já definido para quisermos desenhar uma tabela verdade simples
ser o valor lido no pino digital 2. Estamos desta afirmação, podemos ver como funciona.
verificando também se o valor de millis()-
changeTime é maior que 5000 (utilizando os x y z Falso/Verdade?
operadores lógicos &&). A função millis() é
4 9 25 FALSO
uma construção dentro da linguagem Arduino e
retorna ao número de milissegundos desde que o 5 10 24 VERDADE
Arduino começou a executar o programa atual. 7 10 25 FALSO
Subtraindo o valor da variável changeTime do 5 10 25 VERDADE
valor millis() atual, podemos verificar se 5
segundos se passaram desde a última
changeTime() definida. O cálculo do O comando dentro da declaração
millis()- changeTime é colocado dentro do
seu próprio conjunto de parênteses para assegurar if (state == HIGH && (millis() -
a comparação do valor de estado e o resultado changeTime) > 5000) {
deste cálculo e não o valor de milissegundos por
é
conta própria.
O estado: changeLights();
9
Este é um exemplo de uma chamada de função.
Uma função é simplesmente um bloco de códigos
separado que foi dado um nome. No entanto, nas
funções podem ser passados os parâmetros e / ou
dados de retorno também.
Vamos entrar em mais detalhes mais tarde, sobre
a passagem de parâmetros e retorno de dados de
funções.
Quando changeLights() é chamado, o código
executa saltos a partir da linha atual para a função,
executa o código dentro dessa função e, em
seguida, retorna ao ponto no código depois que a
função foi chamada. Insira o código:
// Projeto 5 – Efeito perseguicao com LED
Assim, neste caso, se as condições previstas na // Criar matriz para os pinos dos LEDs
instrução if forem satisfeitas, em seguida o byte ledPin[] = {4, 5, 6, 7, 8, 9, 10,
programa executa o código dentro da função e 11, 12, 13};
int ledDelay(65); // Atraso entre mudança
depois retorna para a próxima linha após int direction = 1;
changeLights(); em if. O código dentro da int currentLED = 0;
unsigned long changeTime;
função simplesmente muda as luzes de veículos
para vermelho, em seguida, torna a luz de void setup() {
// Configurar todos os pinos de saida
pedestre verde. Após um período de tempo for (int x=0; x<10; x++) {
definido pela variável Crosstime a luz pisca um pinMode(ledPin[x], OUTPUT); }
tempo pequeno para alertar o pedestre que seu changeTime = millis();
}
tempo está prestes a esgotar-se; então a luz de
pedestre vai para o vermelho e a luz de veículo void loop() {
// if it has been ledDelay ms since last
vai de vermelho para verde, e assim retorna para o change
seu estado normal. O programa principal if ((millis() - changeTime) > ledDelay) {
simplesmente verifica continuamente se o botão changeLED();
changeTime = millis();
de pedestre foi pressionado ou não e se há tempo }
suficiente desde que as luzes de pedestres foram }
void changeLED() {
acionadas da última vez (maior do que 5 // turn off all LED's
segundos). for (int x=0; x<10; x++) {
digitalWrite(ledPin[x], LOW);
}
// turn on the current LED
digitalWrite(ledPin[currentLED], HIGH);
Projeto 5 - Efeito perseguição com // increment by the direction value
LEDs currentLED += direction;
// change direction if we reach the end
if (currentLED == 9) {direction = -1;}
Faremos agora uma seqüência de LEDs (10 no if (currentLED == 0) {direction = 1;}
}
total) fazer um efeito de perseguição de LED e
dessa maneira introduzir o conceito muito
importante de matrizes. Projeto 5 – Descrição do código
O que você precisa Nossa primeira linha no sketch é
byte ledPin[] = {4, 5, 6, 7, 8, 9,

10, 11, 12, 13};
Esta é uma declaração de uma variável do tipo

matriz de dados. Uma matriz é uma coleção de
variáveis que são acessados usando um número de
Monte o circuito: índice. Em nosso esboço nós declaramos um array
de byte de tipo de dados e chamamos de ledPin.
Temos então iniciada a matriz com 10 valores,
que são de 4 pinos digitais até o número 13. Para
acessar um elemento da matriz basta
10
simplesmente se referir ao número de índice do No entanto, você tem que parar o programa e
elemento. No entanto, em nossa matriz de manualmente alterar o valor de ledDelay e então
elemento 10, o índice dos números são de 0 a 9. refazer o upload do código alterado para ver as
Neste caso, o 3º elemento (ledPin[2]) tem o alterações. Não seria mais agradável ser capaz de
valor de 6 e o 7º elemento (ledPin[6]) tem um ajustar a velocidade, enquanto o programa está
valor de 10. Você tem que dizer o tamanho da funcionando?
matriz, se não inicializar com os primeiros dados. Sim, seria. Então vamos fazer exatamente isso no
No nosso esboço não fizemos explicitamente a próximo projeto, através da introdução de uma
escolha de um tamanho, como o compilador é forma que interaja com o programa e ajuste a
capaz de contar os valores que já atribuídos para a velocidade usando um potenciômetro.
matriz e trabalhar com tamanho de 10 elementos.
Se tivéssemos declarado a matriz, mas não
inicializado com valores ao mesmo tempo, seria Projeto 6 – Efeito interativo de
preciso declarar uma dimensão, para exemplo,
poderíamos ter feito isso:
perseguição com LEDs
byte ledPin[10]; Iremos agora fazer uma sequência de LEDs (10

no total) produzindo um efeito de perseguição de
Em seguida carregado dados nos elementos mais LED, que também será maneira introduzir o
tarde. Para recuperar um valor do array faríamos conceito de matrizes.
algo como este:
O que você precisa
x = ledPin[5];
Neste exemplo x teria agora um valor 8.

Em nosso programa, começamos declarando e
inicializando um array que armazenou 10 valores,
que são os pinos digitais utilizados para as saídas
dos 10 LEDs. Em nosso laço verificamos que
alguns milissegundos do ledDelay se passam Montagem:
desde a última mudança de LEDs e, assim
acontece o controle para a nossa função.
A função que criamos é
void changeLED() {
for (int x=0; x<10; x++) {
}
currentLED += direction;
if (currentLED == 0) {direction = 1;}
}
E o trabalho desta função é passar todos os LEDs

para desligados e em seguida, liga-los (isso é feito
tão rápido que você não verá que isso acontece),
através da variável currentLED.
Esta variável, em seguida, tem a direção
adicionada. Como a direção só pode ser +1 ou -1,
então o número irá aumentar (+1) ou diminuir (-1)
(currentLED + (-1)).
Temos então, um comando if para verificar se
Este é o mesmo circuito do Projeto 5, mas com a
atingimos o fim da linha de LEDs e, em seguida,
adição de um potenciômetro, que estará conectado
inverter a direção.
à fonte de 5 V e à porta analógica do Pino 2.
Ao alterar o valor de ledDelay você pode fazer
com que o LED vá de frente para trás em
velocidades diferentes. Tente valores diferentes Projeto 6 - Visão geral do código
para ver o que acontece.
// Cria a matriz de pinos dos LEDs
11
byte ledPin[] = {4, 5, 6, 7, 8, 9, 10, do potenciômetro em ledDelay. Observe que
11, 12, 13};
int ledDelay; // Atraso entre mudancas nós não precisamos definir um pino analógico
int direction = 1; para ser uma entrada ou saída como nós
int currentLED = 0;
unsigned long changeTime; precisamos de um pino digital.
int potPin = 2; // Pino de entrada do
potenciometro ledDelay = analogRead(potPin);
void setup() {
// Configura os pinos de saida Essa leitura é feita durante o funcionamento do
for (int x=0; x<10; x++) { nosso circuito principal e por isso é
pinMode(ledPin[x], OUTPUT); }
changeTime = millis(); constantemente lido e ajustado. Ao transformar o
} botão você pode ajustar o valor de atraso entre 0 e
void loop() { 1023 milissegundos (ou pouco mais de um
// Leitura do valor do pot segundo) e portanto, tem total controle sobre a
ledDelay = analogRead(potPin); velocidade do efeito. OK, vamos descobrir o que
// Verifica se ocorreu ledDelay desde a
ultima mudança é um potenciômetro e como funciona.
if ((millis() - changeTime) > ledDelay) {
changeLED();
changeTime = millis();
}
}
Projeto 6 - Visão geral do hardware
A única peça adicional de hardware utilizado
void changeLED() { neste projeto foi o potenciômetro 4K7 (4700Ω).
// Desliga todos os LEDs
for (int x=0; x<10; x++) {
}
// Desliga o LED corrente
// Mude a direcao
currentLED += direction;
// Mude a direcao se chegar ao final
if (currentLED == 0) {direction = 1;}
} O potenciômetro é simplesmente um resistor
ajustável com um intervalo de 0 a um valor
O código para este projeto é quase idêntico ao do definido (escrito no lado de baixo dele). No kit
projeto anterior. Nós simplesmente acrescentamos utilizou-se um potenciômetro de 4K7 ohm (ou
um potenciômetro ao nosso hardware e o código 4.700 Ω), que significa que a sua faixa de
tem adições para habilitar-nos a ler os valores do resistência varia de 0 a 4.700 ohm. O
potenciômetro e utilizá-los para ajustar a potenciômetro tem três pernas. Ao conectar duas
velocidade do LED com o efeito de perseguição. pernas adjacentes no potenciômetro, ele torna-se
Primeiro, devemos declarar uma variável para o um resistor variável. Ao ligar todas as três pernas
pino do potenciômetro: e aplicando uma voltagem nas pernas mais
externas, o potenciômetro torna-se um divisor de
int potPin = 2; tensão. Isto é o que nós utilizamos em nosso
circuito. Um lado é ligado a terra, a outra a 5 V e
O potenciômetro estará conectado ao pino do centro fixa o nosso pino analógico. Ao ajustar
analógico 2. Para ler o valor de um pino analógico o botão, uma tensão entre 0 e 5 V irá ser
usamos o comando analogRead. distribuída a partir do pino central e podemos ler o
O Arduino tem seis portas analógicas de valor que a tensão do Pino 2 analógico distribuiu e
entrada/saída de 10-bits cada, para o conversor usar o seu valor para alterar a taxa de atraso do luz
digital (vamos discutir os bits mais tarde). Isto efeito.
significa que os pinos analógicos podem ler O potenciômetro pode ser muito útil para
tensões entre 0 e 5 volts em valores inteiros entre proporcionar um meio para ajustar um valor de 0
0 (0 volts) e 1023 (5 volts). Isso nos dá uma a um valor definido de resistência. Por exemplo, o
resolução de 5 volts/1024 unidades ou volume de um rádio ou o brilho de uma lâmpada.
0,0049 volts (4,9 mV) por unidade. Na verdade, interruptores dimmer (que variam a
Precisamos definir o nosso atraso usando o intensidade da luz) para as lâmpadas de sua casa
potenciômetro; assim, vamos simplesmente usar são um tipo de potenciômetro.
os valores de leitura direta a partir do pino para
ajustar o atraso entre 0 e 1023 milissegundos.
Fazemos isso para ler diretamente o valor do pino Projeto 7 - Lâmpada pulsante
12
Vamos agora aprofundar ainda mais o método de Projeto 7 – Descrição do código
controle dos LEDs. Até agora, vimos
simplesmente o LED ligado ou desligado. Que tal O código para este projeto é muito simples, mas
ser capaz de ajustar o brilho, também? Podemos requer alguma explicação.
fazer isso com um Arduino? Sim, podemos. É Primeiro configuramos as variáveis para ledPin
hora de voltar ao básico. como float (tipo de dados ponto flutuante) para
um valor de onda senoidal e ledVal que vai conter
O que você precisa: o valor inteiro e enviar ao Pino 11.
O conceito aqui é que estamos criando uma onda
senoidal e fazendo o brilho do LED seguir o
caminho dessa onda. Isto é o que faz pulsar a luz e
dessa forma desaparecer o brilho total e reacender
novamente.
Usamos a função sin(), que é uma função
Conecte: matemática para realizar o trabalho angular
através do seno de um ângulo. Precisamos
transformar a função de graus a radianos. Nós
temos um laço for-end que vai de 0 a 179, pois
não queremos ir além dos valores positivos.
Acima deste valor nos levaria a valores negativos
e o valor do brilho necessita ser entre 0 e 255.
A função sin() requer o ângulo em radianos e
não em graus, de modo que a equação
x*3.1412/180 irá converter o ângulo em radianos.
Em seguida, transferir o resultado para ledVal,
multiplicando-o por 255 e nos dará o valor do
brilho. O resultado da função sin() será um
número entre -1 e 1; por isso precisamos
multiplicar por 255 para nos dar o valor do brilho.
Nós convertemos o valor em ponto flutuante de
Sinval em um número inteiro através da função
int() na instrução.
ledVal = int(sinVal*255);
Digite o código no IDE Em seguida, enviar esse valor para o Pino 11

// Projeto 7 – Lampada pulsante utilizando a afirmação:
int ledPin = 11;
float sinVal;
int ledVal; analogWrite(ledPin, ledVal);
void setup() {
pinMode(ledPin, OUTPUT); Mas, como podemos enviar um valor analógico
}
void loop() { para um pino digital? Bem, se dermos uma olhada
for (int x=0; x<180; x++) { no Arduino e olharmos para os pinos digitais você
// Converte graus para radianos poderá ver que seis desses pinos (pino 3, 5, 6, 9,
// entao calcula os valores de seno 10 e 11) têm PWM escrito ao lado deles. Esses
sinVal = (sin(x*(3.1412/180)));
ledVal = int(sinVal*255); pinos diferem dos pinos digitais restantes porque
analogWrite(ledPin, ledVal); são capazes de enviar um sinal PWM.
delay(25); PWM é a sigla em inglês de modulação por
} largura de pulso (pulse width modulation). É
}
uma técnica para obtenção de resultados
Verifique e faça o upload. Você vai ver agora o analógicos a partir de sinais digitais. Esses pinos
LED pulsar e desligar de forma contínua. Em vez do Arduino enviam uma onda quadrada trocando
de um simples liga/desliga (on/off) de estado, o o sinal do pino dentro muito rápido (on/off). O
programa está agora ajustando o brilho do LED. padrão on/off pode simular uma tensão variando
Vamos descobrir como isso funciona. entre 0 e 5 V. Ele faz isso alterando a quantidade
13
de tempo que a saída permanece elevada (on)
versus baixa (off). A duração do tempo é
conhecida como largura de pulso.
Por exemplo, se for enviado o valor 0 para o pino
11 usando analogWrite(), o período ON seria
zero, ou teria um ciclo de 0%. Se fosse enviado
um valor de 64 (correspondendo a 25% de 255) o
pino seria ON para 25% do tempo e OFF para o
restante 75% do tempo. O valor 191
corresponderia a um ciclo de trabalho de 75%,
enquanto que um valor de 255 corresponderia a
um ciclo de trabalho de 100%. Os impulsos
ocorrem a uma frequência de aproximadamente
500 Hz ou a duração de 2 ms cada.
Assim, podemos ver em nosso sketch que o LED
está sendo ligado e desligado muito rápido. Se o
ciclo de trabalho for de 50% (valor de 127), o
LED irá pulsar de forma ligado e desligado em
500 Hz e mostrará a metade do brilho máximo.
Basicamente é uma ilusão de ótica que podemos
usar a nosso favor, permitindo utilizar pinos
digitais para a saída de um valor simulando um
sinal analógico para o nosso LED.
Note que apesar de apenas seis dos pinos terem a
função PWM, você pode facilmente escrever um
programa para fornecer uma saída PWM a todos
os pinos digitais, se desejar.
Mais tarde, vamos revisitar a função PWM e
utilizá-la para criar tons audíveis usando uma
sirene piezelétrica. Conecte o LED RGB, que poderá formar diversas
cores, da forma que desejar apenas alternando a
intensidade luminosa de cada cor.
Projeto 8 – Lâmpada do humor // Projeto 8 – Lampada do humor
float RGB1[3];
No projeto anterior, vimos que podemos ajustar o float RGB2[3];
brilho de um LED utilizando as capacidades de float INC[3];
int red, green, blue;
PWM do chip Atmega. int RedPin = 11;
Vamos agora aproveitar essa capacidade int GreenPin = 10;
utilizando um LED vermelho, verde e azul (RGB) int BluePin = 9;
e pela mistura das cores criarmos qualquer cor void setup()
{
que desejarmos. Serial.begin(9600);
A partir disso, vamos criar uma lâmpada de randomSeed(analogRead(0));
humor semelhante ao tipo que você vê à venda em RGB1[0] = 0;
todo o lugar hoje em dia. RGB1[1] = 0;
RGB1[2] = 0;
RGB2[0] = random(256);
O que você precisa RGB2[1] = random(256);
LED tricolor RGB }
void loop()
{
randomSeed(analogRead(0));
for (int x=0; x<3; x++) {
INC[x] = (RGB1[x] - RGB2[x])/256; }
3x220 Ω resistores for (int x=0; x<256; x++) {
red = int(RGB1[0]);
green = int(RGB1[1]);
blue = int(RGB1[2]);
Montagem: analogWrite (RedPin, red);
analogWrite (GreenPin, green);
14
analogWrite (BluePin, blue); variáveis inteiras que irão armazenar os nossos
delay(100); valores RGB, bem como um valor de incremento.
RGB1[0] -= INC[0];
RGB1[1] -= INC[1];
RGB1[2] -= INC[2]; float RGB1[3];
} float RGB2[3];
for (int x=0; x<3; x++) { float INC[3];
RGB2[x] = random(556)-300; int red, green, blue;
RGB2[x] = constrain(RGB2[x], 0, 255);
delay(1000); Na função de configuração temos
}
}
randomSeed(analogRead(0));
Quando você executar o programa, verá as cores
O comando randomSeed é utilizado para criar
mudarem lentamente. Pronto, você fez a sua
números aleatórios (na verdade, pseudo
própria lâmpada do humor.
aleatórios). Chips de computador não são capazes
de produzir números aleatórios de modo que
Descrição do código tendem a olhar para dados numa parte da sua
memória que podem ser diferentes ou olhar para
Os LEDs que constituem a lâmpada humor são de uma tabela de valores diferentes e utilizá-las como
cores vermelho, verde e azul. Da mesma forma um número pseudo-aleatório. Neste caso, o do
que o seu monitor de computador é feito de cores valor que será dado ao randomSeed é um valor
vermelho minúsculo, verde e (RGB) pontos azuis, lido a partir do pino analógico 0. Como nós não
o mapa pode gerar diferentes cores, ajustando o temos nada ligado ao pino analógico 0 tudo o que
brilho de cada um dos três LEDs de tal maneira será lido é um número aleatório criado pelo ruído
que nos dê um valor RGB e tons de cores analógico.
diferentes. Uma vez que tenhamos definido um início para o
Um valor RGB de “255,0,0” nos daria o vermelho nosso número aleatório, esse poderá criar outro
puro. O valor “0,255,0” daria verde puro e número usando a função random(). Em seguida,
“0,0,255” a cor azul pura. Ao misturar essas cores temos dois conjuntos de valores RGB
dos LEDs, podemos obter diversas cores. Você armazenados em um elemento de três matrizes.
ainda pode fazer diferentes cores, como nesta RGB1 são os valores RGB que queremos que a
tabela com alguns exemplos de combinação de lâmpada comece (neste caso, todos em zero ou
cores: desligados).
RGB1[0] = 0;
RGB1[1] = 0;
RGB1[2] = 0;
Em seguida, a matriz RGB2 é um conjunto de

valores aleatórios RGB que queremos que a
lâmpada tenha para produzir o efeito aleatório:
Neste caso, teremos um conjunto de números

aleatórios (256) que vai dar um número entre 0 e
Ao ajustar o brilho usando PWM, podemos obter 255 inclusive (como o número sempre varia de
também todas as outras cores. Ao colocar os zero para cima).
LEDs juntos e misturando seus valores, o espectro Se indicarmos um número para a função
de luz das três cores somadas faz uma única cor. random(), ele então irá processar um valor entre
A gama total de cores que podemos fazer usando 0 e 1 a menos do que o número indicado, por
a saída PWM é de 0 a 255 é 16.777.216 cores exemplo, random(1000) irá retornar um número
(256x256x256), sendo este valor muito maior do entre 0 e 999.
que nós precisamos. Caso queira um intervalo definido de números,
No código, começamos desligados (pontos com forneça os dois números como parâmetros, dessa
valor 0), declarando alguns pontos flutuantes
forma: random(50,400). Então, random irá
(float) da matriz de pontos e também algumas prodessar um número aleatório entre o menor
15
número e o máximo número (-1). Por exemplo, O número aleatório é escolhido num intervalo
random(10,100) irá retornar um número entre 0 e 556 (256 + 300) e, em seguida é
aleatório entre 10 e 99. subtraído de 300. A razão pela qual fazemos isso
No loop principal do programa que vimos é para tentar produzir cores primárias de tempos
primeiro no início e terminar valores RGB e em tempos para garantir que nem sempre
descobrir o que é valor necessário. tenhamos somente tons pastel.
No entanto, é necessário um incremento para que Temos 300 chances fora de 556 de obter um
haja a mundaça de um valor para o outro e utilizar número negativo e, portanto, forçando à uma
as 256 combinações (com o valor de PWM tendência de termos um ou mais de dois canais de
podemos combinar entre 0 e 255). Fazemos isso cor.O próximo comando faz certeza de que os
assim: números enviados para os pinos PWM não são
negativos usando a função constrain().
for (int x=0; x<3; x++) { A função de restringir constrain() requer três
INC[x] = (RGB1[x] - RGB2[x]) / 256; }
parâmetros - x, a e b como constrain(x,a,b),
onde x é o número queremos restringir, a é a
Este loop define os valores pelo incremento nos
extremidade inferior da gama e b é a extremidade
canais R, G e B por meio do resultado da
superior. Assim, a função constrain() observa
diferença entre os dois valores de brilho e
o valor de x e garante que ele se encontra dentro
dividindo-os por 256.
do intervalo entre a e b. Se é menor que a, então o
Temos, então, outro laço for
define para a, se é maior do que b o define para b.
for (int x=0; x<256; x++) { No nosso caso, teremos certeza de que o número
red = int(RGB1[0]); está entre 0 e 255, que é o intervalo da nossa saída
green = int(RGB1[1]); PWM.
blue = int(RGB1[2]); Como usamos números aleatórios [(556) -300]
analogWrite (RedPin, red);
analogWrite (GreenPin, green); para os nossos valores RGB, alguns desses
analogWrite (BluePin, blue); valores serão menores que zero e a função
delay(100); constrain() garante que o valor enviado para o
RGB1[0] -= INC[0]; PWM não é menor que zero.
RGB1[1] -= INC[1];
RGB1[2] -= INC[2]; Aplicando uma tendência para uma ou mais cores
} assegurando tons mais vibrantes e menos cores
pastel e assegurando também que ao longo do
Isso define as cores vermelho, verde e azul para tempo um ou mais canais estão desligados
os valores da matriz RGB1, e transfere esses completamente dando uma mudança mais
valores para os pinos 9, 10 e 11, depois deduz o interessante de luzes (ou humores).
valor do incremento, em seguida, repete este
processo 256 vezes até desaparecer lentamente a
partir de uma cor aleatória para o próximo passo. Projeto 9 - Efeito fogo com LED
O atraso de 100 ms entre cada passo garante uma
lenta e constante progressão das combinações de O Projeto 9 vai utilizar LEDs piscando
cores. É possível ainda ajustar esse valor para aleatoriamente produzindo um belo efeito,
mais lento ou mais rápido ou podemos ainda utilizando novamente a saída PWM para recriar o
adicionar um potenciômetro para permitir que um efeito de uma chama.
usuário defina a velocidade que desejar. Se o conjunto for colocado dentro de um ambiente
Depois de ter tomado 256 passos lentos de uma apropriado (uma minilareira, por exemplo),
cobinação de cor para outra, a matriz RGB1 terá poderia criar um efeito especial de fogo, ou ainda
os mesmos valores (quase) como a matriz RGB2. pode-se colocá-lo em uma farsa casa em chamas
Precisamos agora decidir sobre outro conjunto de para dar um efeito de fogo. Este é um simples
três valores aleatórios prontos para a próxima vez. exemplo de como os LEDs podem ser utilizados
Fazemos isso com outro for: para criar efeitos para filmes, peças teatrais,
novelas, etc.
for (int x=0; x<3; x++) {
RGB2[x] = random(556)-300;
RGB2[x] = constrain(RGB2[x], 0, 255); O que você precisa
delay(1000);
}
16
int ledPin1 = 9;
int ledPin2 = 10;
int ledPin3 = 11;
Em seguida, configurá-los para serem saídas.
pinMode(ledPin1, OUTPUT);
Montagem pinMode(ledPin3, OUTPUT);
O laço principal do programa, em seguida, envia

um valor aleatório entre 0 e 120 e, em seguida,
adiciona 135 a ele para obter o máximo de brilho
dos LEDs, para os pinos de PWM conectados aos
números 9, 10 e 11.
analogWrite(ledPin1, random(120)+135);
Então, finalmente, temos um atraso aleatório

proposital entre ligado e o tempo de 100 ms.
delay(random(100));
Abra o IDE Arduino e digite o seguinte código: O laço principal, em seguida, começa novamente
causando o efeito de luz que se pode ver.
// Projeto 9 – Efeito de LED de fogo Utilizando um cartão branco onde possa se refletir
int ledPin1 = 9;
int ledPin2 = 10; as luzes ou uma armação como um abajur você
int ledPin3 = 11; poderá ver um efeito de chama muito realista.
void setup()
{ Como a construção do hardware é bem simples,
pinMode(ledPin1, OUTPUT); vamos pular para o próximo Projeto.
}
void loop()
{ Projeto10 – LEDs controlados
analogWrite(ledPin2, random(120)+135); Para este projeto utilizaremos o mesmo circuito
delay(random(100)); anterior (Projeto 9), mas agora vamos mergulhar
} no mundo da comunicação serial e controlar a
nossa luz, enviando comandos a partir do PC para
Agora pressione o botão Verificar / Compilar no o Arduino usando o “Serial Monitor” no IDE
topo da IDE para se certificar de que não há erros Arduino, que é uma tela de interface com o
em seu código. Se este é bem sucedido agora você hardware do arduino. Este projeto também
pode clicar no botão Upload para carregar o introduz como manipular sequências de texto.
código para o Arduino. Então deixe a configuração do hardware do
Se tudo estiver certo poderemos ver agora os mesmo jeito de antes e introduza o novo código:
LEDs em cintilação de uma maneira aleatória para
simular uma chama ou efeito de fogo. // Projeto 10 – Lampada RGB controlada
Agora vamos dar uma olhada no código e char buffer[18];
hardware e descobrir como ambos trabalham. int red, green, blue;
int RedPin = 11;
int GreenPin = 10;
Descrição do código int BluePin = 9;
void setup()
Primeiro nós declaramos e inicializamos algumas {
variáveis inteiras que conterão os valores para os Serial.begin(9600);
pinos digitais que vamos conectar os nossos Serial.flush();
LEDs, como já foi realizado em projetos pinMode(RedPin, OUTPUT);
pinMode(GreenPin, OUTPUT);
anteriores.
17
pinMode(BluePin, OUTPUT); Na janela de texto “Serial Monitor” você pode
}
entrar com os valores de R, G e B para cada um
void loop() dos três LEDs manualmente e o brilho dos LEDs
{ será alterado e a cor de efeito resultante será a que
if (Serial.available() > 0) { você programar.
int index=0;
Por exemplo, Se você digitar R255 o LED
delay(100); // Aguarda encher o buffer
int numChar = Serial.available(); vermelho irá exibir pleno brilho.
if (numChar>15) { Se você digitar R255, G255, em seguida, os
numChar=15; LEDs vermelho e verde irão exibir brilho
} máximo.
while (numChar--) {
buffer[index++] = Serial.read(); Agora entre com os comandos R127, G100, B255,
} e você obterá uma cor aparentemente arroxeada.
splitString(buffer); Se você digitar, r0, g0, b0 todos os LEDs serão
} desligados.
}
O texto de entrada é projetado para aceitar tanto
void splitString(char* data) { uma letra minúscula ou maiúscula caso de R, G e
Serial.print("Data entered: "); B e, em seguida, um valor entre 0 e 255.
Serial.println(data); Quaisquer valores acima de 255 serão descartados
char* parameter;
parameter = strtok (data, " ,"); para no máximo 255. Você pode inserir uma
while (parameter != NULL) { vírgula ou um espaço entre os parâmetros e você
setLED(parameter); pode entrar 1, 2 ou 3 valores de LED em qualquer
parameter = strtok (NULL, " ,"); momento um. Por exemplo,
}
// Limpa o texto e os buffers seriais
for (int x=0; x<16; x++) { R255 b100, r127 b127 G127, G255 B0,
buffer[x]='\0'; B127, R0, G255 .
}
Serial.flush();
}
Descrição do código
void setLED(char* data) { Este projeto apresenta uma série de conceitos
if ((data[0] == 'r') || (data[0] == 'R')) novos, incluindo a comunicação serial, ponteiros e
{
int Ans = strtol(data+1, NULL, 10);
manipulação de textos. Então, mantenha-se
Ans = constrain(Ans,0,255); atento, pois teremos várias explicações.
analogWrite(RedPin, Ans); Primeiro vamos definir uma matriz de char
Serial.print("Red is set to: "); (caracteres) para manter nossa cadeia de texto.
Serial.println(Ans);
}
Fizemos de 18 caracteres, cujos são mais longos
if ((data[0] == 'g') || (data[0] == 'G')) do que o máximo de 16, o que nos permitirá
{ garantir que não teremos erros de sobrecargas ao
int Ans = strtol(data+1, NULL, 10); sistema.
Ans = constrain(Ans,0,255);
analogWrite(GreenPin, Ans);
char buffer[18];
Serial.print("Green is set to: ");
} Em seguida, iremos configurar os números
if ((data[0] == 'b') || (data[0] == 'B')) inteiros para manter os valores das cores
{ vermelho, verde e azul, bem como os valores para
Ans = constrain(Ans,0,255); os pinos digitais.
analogWrite(BluePin, Ans);
Serial.print("Blue is set to: "); int red, green, blue;
Serial.println(Ans); int RedPin = 11;
} int GreenPin = 10;
} int BluePin = 9;
Uma vez que você verificou o código, enviá-lo Na nossa configuração definiremos os três pinos
para o seu Arduino. digitais para serem saídas. Mas, antes disso temos
Agora, quando você carregar o programa nada o comando Serial.begin:
parece acontecer. Isto porque o programa está
esperando por sua entrada. Inicie o “Serial void setup()
{
Monitor” clicando no respectivo ícone na barra de Serial.begin(9600);
tarefas no IDE do Arduino.
18
Serial.flush(); função Serial.available terá imediatamente
pinMode(RedPin, OUTPUT);
pinMode(GreenPin, OUTPUT); um valor superior a zero e a função if começará
pinMode(BluePin, OUTPUT); a ser executada. Se não houvesse o atraso, o
} código dentro do if começaria a ser executado
antes de toda a informação de texto ter sido
Serial.begin diz ao Arduino para começar a recebida e o dados seriais poderiam ser apenas os
comunicação serial e o número dentro dos primeiros caracteres de texto inserido.
parêntesis, neste caso 9600, define a taxa de Depois de ter esperado 100 ms, para preencher o
transmissão (caracteres por segundo) que a linha buffer serial com os dados enviados, nós então
serial irá comunicar. declaramos e inicializamos o inteiro numChar
Obs.: Você deve alterar a taxa de transmissão no para ser o número de caracteres dentro do texto.
Serial Monitor para 9600 baud. Por exemplo, se enviamos este texto para o
O comando Serial.flush irá limpar qualquer monitor: R255, G255, B255.
caractere indevido na linha de série e deixá-lo Em seguida, o valor de numChar é 17 e não 16,
vazio e pronto para a entrada/saída de comandos. como no final de cada linha de texto, onde há um
A linha de comunicação serial é simplesmente caractere invisível chamado de “NULL” . Este é
uma forma de o Arduino se comunicar com o um símbolo de vazio e simplesmente diz ao
mundo exterior, neste caso através do PC e do Arduino que o fim da linha de texto foi atingido.
IDE Arduino Serial Monitor para o hardware A próxima instrução if verifica se o valor de
construído. numChar é superior a 15 ou não e se assim se
No circuito principal, temos uma instrução if. A define como sendo de 15. Isso garante que nós
condição é verificar não estouraremos o array char buffer [18];
Depois vem um comando while. É um comando
if (Serial.available() > 0) {
que nós ainda não nos deparamos antes, então
O comando Serial.available verifica se caracteres segue a explanação.
foram enviados para a linha do monitor serial. Se Nós já usamos o laço for, que irá percorrer um
qualquer caractere foi recebido, em seguida, as determinado número de vezes numa sequência. A
condição e declarações do código dentro do bloco instrução while é também um laço, mas que
if é executada. executa somente enquanto uma condição é
verdadeira.
if (Serial.available() > 0) { A sintaxe é:
int index=0;
delay(100); // let the buffer fill up while(expression) {
int numChar = Serial.available(); // statement(s)
if (numChar>15) { }
numChar=15;
}
while (numChar--) { Em nosso código ficou como:
buffer[index++] = Serial.read();
} while (numChar--) {
splitString(buffer); buffer[index++] = Serial.read();
} }
}
A condição é verificada simplesmente através do
Um inteiro chamado index é declarado e numChar, portanto, em outras palavras, é verificar
inicializado como zero. Este inteiro vai manter a se o valor armazenado no inteiro numChar não é
posição de um ponto para os caracteres dentro da zero. Isto é conhecido como um pós-decremento.
matriz de char, como uma referência. Em outras palavras, o valor é decrementado
Em seguida, define-se um atraso de 100. O depois que é usado. No nosso caso, o loop while
propósito disto é assegurar que o serial buffer (o verifica o valor de numChar e, em seguida,
lugar na memória onde os dados são recebidos e subtraí uma unidade a partir dele. Se o valor de
armazenados antes do processamento) está cheio numChar não era zero antes do decremento, então
antes de continuar o processo com os dados. Se executa o código. Está definido para o
não fizer isso, é possível que a função execute e comprimento da seqüência de texto que entraram
começe a processar o comando enviado, antes de na janela do Monitor Serial. Assim, o código
termos enviado todos os dados. A linha de dentro do loop while irá ser executado muitas
comunicação serial é muito lenta em comparação vezes. O código dentro do laço while é:
com a velocidade do resto do código de execução.
Quando você envia uma sequência de dados, a
19
buffer[index++] = Serial.read(); Assim, nós declaramos uma variável do tipo de
dados char e chamamos de dados, mas o
Que define cada elemento da matriz tampão para símbolo *, isso significa que está apontando para
cada caractere lido a partir da linha de série. Em o valor armazenado dentro do buffer.
outras palavras, ele enche o buffer array com os Quando chamamos splitString enviamos para
dados que inserimos na janela do Serial Monitor. o seu conteúdo o buffer (na verdade o parâmetro
O comando Serial.read() lê a série de dados para ele, como vimos acima).
de entrada, um byte de cada vez.
Portanto, agora que a nossa matriz de caracteres splitString(buffer);
foi preenchida com os dados que entraram no
Serial Monitor, o while terminará assim que Então nós chamamos a função e passamos para o
numChar chegar a zero. Depois temos: seu conteúdo a matriz de caracteres do buffer.
O primeiro comando é
splitString(buffer);
Serial.print("Data entered: ");
Que é uma chamada para uma das duas funções
que criamos e chamamos de splitString(). e esta é a nossa forma de enviar dados de volta do
Essa função é descrita a seguir: Arduino para o PC. Neste caso, o comando de
impressão envia o que está dentro do parêntese
void splitString(char* data) { para o PC, através do cabo USB, onde podemos
Serial.print("Data entered: "); ler no Serial Monitor.
Serial.println(data);
char* parameter; Neste caso, já enviámos as palavras "Data
parameter = strtok (data, " ,"); entered:". O texto deve ser colocado entre
while (parameter != NULL) { aspas " ". A linha seguinte é semelhante
setLED(parameter);
parameter = strtok (NULL, " ,");
} Serial.println(data);
for (int x=0; x<16; x++) {
buffer[x]='\0'; E mais uma vez, enviou dados para o PC. Por
} exemplo:
Serial.flush();
}
R255 G127 B56
Podemos ver que a função não retorna nenhum
tipo de dado, portanto podemos ver que seu tipo Em seguida,
foi criado para anular possíveis continuidades.
Serial.println(data);
Passamos o parâmetro de uma função que é um
tipo de char(caractere) e que trataremos como de
Este comando irá enviar essa sequência de texto
dados. No entanto, nas linguagens de
para o PC e imprimi-lo na janela do Serial
programação C e C++ você não tem permissão
Monitor, se algo for digitado na janela do Serial.
para enviar uma matriz de caracteres para uma
Desta vez, o comando de impressão tem “ln” no
função. Temos que contornar isso, usando um
fim torná-lo println. Isto simplesmente significa
parâmetro. Nosso parâmetro será um asterisco (*)
impressão/imprimir na linha do Serial Monitor.
e foi adicionada ao (*) o nome de dados variáveis.
Quando imprimir utilizando o comando print, o
Parâmetros são bastante avançados no C de modo
cursor (o ponto onde o símbolo irá aparecer)
que não vamos entrar em muitos detalhes sobre
permanece no final de tudo o que tenha
eles. Tudo que você precisa saber agora é que por
imprimido.
declaração de dados como um parâmetro,
Quando usamos o comando println um
simplesmente uma variável aponta para outra
variável. comando de avanço de linha é emitido ou em
Você pode apontá-lo para o endereço que a outras palavras, as impressões de texto e, em
variável é armazenada na memória usando o seguida, o cursor cai para a linha seguinte.
símbolo &, ou em nosso caso, para o valor
Serial.print("Data entered: ");
armazenado a esse endereço de memória usando o Serial.println(data);
símbolo *. Usaremos isso para enganar o sistema,
como nós não temos permissão para enviar um Se olharmos para os nossos dois comandos de
caractere à matriz para uma função. No entanto, impressão, o primeiro imprime "Os dados
estamos autorizados a enviar um indicador para inseridos:" e então o cursor permanece no final do
uma matriz de caracteres para a nossa função.
20
texto. A próxima impressão vai imprimir os seguida, daremos um comando de fim de
dados, ou em outras palavras, o conteúdo da comando.
matriz chamado tampão e depois emitir uma linha
de alimentação, ou deixar cair o cursor para a while(parameter != NULL) {
próxima linha. Isto significa que, se emitir outra
impressão ou declaração println após isso tudo Dentro do loop que chamamos de nossa segunda
que é impresso na janela do Serial Monitor será função
exibido na próxima linha por baixo da última.
Em seguida, criamos um novo tipo de dados setLED(parameter);
char chamado parâmetro.
Que veremos mais tarde. Em seguida, ele define o
Char* parameter; parâmetro variável para a próxima parte da
seqüência para o próximo espaço ou vírgula.
e como vamos usar essa variável para acessar Fazemos isso passando para strtok um parâmetro
elementos da matriz de dados, ele deve ser do NULL
mesmo tipo, portanto o símbolo *. Você não pode
parameter = strtok(NULL, " ,");
passar dados de um tipo de variável para outro
tipo de variável, os dados devem ser convertidos Isso informa ao programa para continuar de onde
em primeiro lugar. Esta variável é outro exemplo parou.
de alguém que tem o escopo local. Pode ser visto Então, temos toda essa parte da função:
apenas pelo código dentro dessa função. Se você
tentar acessa-la fora parâmetro da variável função char* parameter;
splitString você obterá um erro. parameter = strtok(data, " ,");
Em seguida, usamos um comando strtok, que é while (parameter != NULL) {
setLED(parameter);
um comando muito útil para nos capacitar para parameter = strtok(NULL, " ,");
manipular textos de comando. strtok é a junção }
do nome de string e Token e o seu objetivo é
dividir um texto usando símbolos. No nosso caso é simplesmente a cadeia de comandos que permite
o símbolo que estamos procurando é um espaço ajustar a próxima função chamada setLED().
ou uma vírgula. Ele é usado para dividir A parte final desta função simplesmente preenche
sequências de caracteres de texto em partes o buffer com conjunto dos caracteres, que é feito
menores e legíveis ao programa. Passamos a com o “/0” símbolo que nivela e em seguida, os
matriz de dados para o comando strtok como o dados de série estão prontos para o próximo
primeiro argumento e os símbolos (incluído o conjunto de dados que poderão ser inseridos.
dentro das aspas) como o segundo argumento. Por
isso: // Clear the text and serial buffers
for (int x=0; x<16; x++) {
buffer[x]='\0';
parameter ´strtok(data,”,“); }
Serial.flush();
E ele divide a sequência nesse ponto. Portanto,
estamos a usá-lo para ajustar o parâmetro a ser a A função setLED() vai identificar cada parte da
parte da cadeia até um espaço ou uma vírgula. sequência de texto e definir o LED
Então, se a nossa cadeia de texto foi correspondente à cor que se escolher. Assim, se a
sequência de texto é:
R127 G56 B98
G125 B55
Então, após esta declaração o valor do parâmetro
será A função splitString() divide o texto em dois
componentes separados
R127
G125
O comando strtok simplesmente divide a B55
sequência digitada para a primeira ocorrência de
um espaço ou de uma vírgula. e envia essa seqüência de texto abreviado para o
Depois de ter definido o parâmetro variável para a setLED() da função, que vai lê-lo, definir o LED
parte da cadeia de texto que queremos retirar (ou que escolhido e configurá-lo para o brilho
seja, o bit do primeiro espaço ou vírgula) em correspondente do valor.
21
Então vamos dar uma olhada na segunda função inteiro (NULL) e, em seguida, a base que, no
chamada setLED(): nosso caso é base igual a 10, como estamos
usando números decimais normais (ao contrário
void setLED(char* data) { de binário, octal ou hexadecimal que seriam de
if ((data[0] == 'r') || (data[0] == base 2, 8 e 16, respectivamente). Assim, em
'R'))
{ outras palavras, declaramos uma série de
int Ans = strtol(data+1, NULL, 10); comandos que identificarão um inteiro e irão
Ans = constrain(Ans,0,255); configurá-lo para o valor de brilho do led
analogWrite(RedPin, Ans); escolhido.
Serial.print("Red is set to: ");
Serial.println(Ans); Usamos o comando constrain (restringir) para
} certificar-se que o número em Ans vai de 0 a 255
if ((data[0] == 'g') || (data[0] == e não mais que isso. Em seguida, o comando
'G'))
{ analogWrite envia para o pino de saída e o
int Ans = strtol(data+1, NULL, 10); valor de Ans. As outras duas declarações if
Ans = constrain(Ans,0,255); executam comandos idênticos ao explicado.
analogWrite(GreenPin, Ans); É necessário que se estude mais a fundo os
Serial.print("Green is set to: ");
Serial.println(Ans); comandos citados até aqui, pois têm diversas
} outras aplicações e funções diferentes, além das
if ((data[0] == 'b') || (data[0] == utilizadas até agora. Tivemos uma introdução
'B'))
{ básica de novos conceitos nestes projetos.
analogWrite(BluePin, Ans);
Serial.print("Blue is set to: "); Projeto 11 – Acionamento de um
Serial.println(Ans); motor CC
}
}
Este projeto trabalhará com acessórios diferentes,
Podemos ver que esta função contém três como fontes, motores, diodos, etc.
comandos muito semelhantes de if. Por isso
vamos dar uma olhada em apenas um deles, pois O que você precisa
os outros dois são quase idênticos.
if ((data[0] == 'r') || (data[0] ==

'R')) {
analogWrite(RedPin, Ans);
Serial.print("Red is set to: ");
}
A instrução if verifica se o primeiro caractere no

campo de dados da sequência ( data[0] ) é uma
letra r ou R (maiúscula ou minúsculas são
totalmente diferentes para a linguagem em C).
Usamos o comando lógico OR cujo símbolo é ||
para verificar se a letra é maiúscula ou minúscula.
Sabendo que é um r ou um R, a instrução if irá
agora dar o comando de brilho do LED vermelho
e assim executa o código dentro da sequência.
Primeiro nós declaramos um inteiro chamado Ans
(que tem valor temporário) e usamos o comando
strtol para converter os caracteres após a letra
digitada inicialmente, sendo ela r ou R, para
valores inteiros.
O comando strtol tem três parâmetros que são
levados em consideração; estes são: a sequência
que estamos utilizando, um ponto após o caractere
22
ao transistor e ao valor lido a partir do
potenciômetro.
Na função setup () vamos configurar o pinMode
do pino do transistor para saída.
O potValue do loop principal está definido para
ler o valor lido a partir do pino analógico 0
(potPin) e, em seguida, é dividido por 4.
Temos que dividir o valor lido por 4, para fazer a
relação com o valor analógico que irá variar de 0 a
0 volts a 1023 para 5 volts. O valor do pino do
transistor só pode variar de 0-255, de modo que
dividindo o valor do pino analógico 0 (max 1023)
por 4 obtemos o valor máximo de 255 para a
fixação do pino digital 11 (usando analogWrite
por isso estamos usando PWM).
O código, em seguida, escreve para o pino do
transistor o valor ajustado no potenciômetro. Em
outras palavras, quando você gira a
potenciômetro, diferentes valores são lidos
(variam de 0 a 1023) e estes são convertidos para
a faixa de 0 a 255 e, em seguida, esse valor é
int potPin = 0; // Analog in 0 escrito (via PWM) para o pino digital 11 que
connected to the potentiometer muda a velocidade do motor de corrente contínua.
int transistorPin = 11
; // connected to the base of the Gire o potenciômetro todo para a esquerda e o
transistor motor desliga, vire para a direita e ele acelera até
int potValue = 0; // value returned que atinja a velocidade máxima.
from the potentiometer
void setup() {
// set the transistor pin as output: Visão geral do hardware
pinMode(transistorPin, OUTPUT);
}
void loop() { O hardware para o Projeto 11 é como abaixo:
// read the potentiometer, convert it
to 0 - 255:
potValue = analogRead(potPin) / 4;
// use that to control the
transistor:
analogWrite(transistorPin, potValue);
}
Antes de ligar o circuito, verifique se tudo foi

conectado corretamente e em especial o diodo que
tem polarização. Se ligá-lo de maneira errada, isso
pode resultar em danos permanentes ao o Arduino
e componentes. Quando estiver certo que as
ligações estão corretas, faça o upload do seu
código.
int potPin = 0;
int transistorPin = 11;
int potValue = 0;
void setup() {
pinMode(transistorPin, OUTPUT);
}
void loop() { O circuito é essencialmente dividido em duas
potValue = analogRead(potPin) / 4; seções: (a) A seção 1 é o nosso potenciômetro,
analogWrite(transistorPin, potValue); que está ligado à +3,3 V e ao terra com o pino
} central de entrada no pino analógico A0. Como o
potenciômetro é giratório, a variação de
Este código é muito simples. Declaramos 3 resistência permite tensões de 0 a 3,3 V, onde o
inteiros que armazenam os valores dos pinos que valor é lido usando o pino analógico A0. (b) A
se ligam ao nosso potenciômetro, ao pino que liga
23
segunda seção é a que controla o motor. Os pinos no diodo indica o lado que se liga no terra. Ele
digitais do Arduino fornecem um máximo de filtra o fluxo a partir do lado positivo para o lado
40 mA. O motor requer em torno de 500 mA para negativo. O diodo irá funcionar como uma válvula
funcionar em alta velocidade e isto é, obviamente para impedir refluxo de corrente. O diodo em
muito alto para o Arduino. Se fôssemos tentar nosso circuito é, portanto, inserido para proteger o
conduzir o motor diretamente a partir de um pino Arduino.
do Arduino um grave e permanente dano poderia
ocorrer. Portanto, precisamos encontrar uma
maneira de fazê-lo de maneira indireta.
Este projeto controla a velocidade do motor, por
isso precisamos de uma maneira de controlar essa
tensão para acelerar ou retardar o motor. Este é o
lugar onde o transistor TIP-120 atua.
Um transistor é essencialmente um comutador
digital. Ele também pode ser utilizado como um
amplificador de potência. O símbolo eletrônico
para um transistor bipolar é mostrado a seguir:
Circuito equivalente do transistor TIP120.
Projeto 12 – Atuador piezelétrico

Neste projeto vamos usar um simples circuito para
produzir sons usando um Arduino e uma sirene
piezelétrica.
O transistor tem três pernas, uma é a base, outra é
O que você precisa
o coletor e a terceira é o emissor. Estes são
identificados como B, C e E na figura abaixo.
No nosso circuito, temos 3,3 volts indo para o

coletor através do motor. A base é ligada através
de um resistor de 1 kΩ ao pino digital 11. O
emissor é ligado ao pino terra. Enviamos pulsos
via PWM ao pino 11, e esta tensão é reduzida
usando um resistor de 1 kΩ. Sempre que se aplica
uma tensão à base, através do pino 11, o que
permite que corrente flua através do coletor ao
emissor e, portanto, acionar o motor, que está
ligado em série com este circuito.
Um motor é um eletroímã que tem um campo
magnético induzido enquanto uma tensão é
fornecida. Quando a energia é removida, o Montagem
colapso do campo magnético pode produzir uma
tensão reversa. Isso pode danificar seriamente o Quando você executar esse código o Arduino fará
seu Arduino e é por isso que o diodo foi soar um som muito semelhante aos irritantes
introduzido no circuito. A listra branca marcada cartões de aniversário que você pode comprar em
qualquer banca de jornais e que quando são
24
abertos tocam uma música. Vamos dar uma
olhada neste código e ver como funciona e
descobrir o que é um disco piezo.
A música que vamos tocar é composta de 15
Descrição do código notas.
// Projeto 12 – Atuador piezeletrico

int speakerPin = 9;
int length = 15; // Numero de notas As notas da melodia são armazenadas em uma
char notes[] = "ccggaagffeeddc "; //
Espaco representa uma pausa matriz de caracteres como um texto.
int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1,
1, 1, 1, 1, 1, 2, 4 };
int tempo = 300;
void playTone(int tone, int duration) { Outra matriz, desta vez de números inteiros, é
for (long i=0; i < duration*1000L; configurada para armazenar o comprimento de
i+=tone*2) { cada nota.
digitalWrite(speakerPin, HIGH);
delayMicroseconds(tone);
digitalWrite(speakerPin, LOW);
}
} E, finalmente, definir um tempo para a música a
ser tocada:
void playNote(char note, int duration) {
char names[] = { 'c', 'd', 'e', 'f', 'g',
'a', 'b', 'C' };
int tones[] = { 1915, 1700, 1519, 1432,
1275, 1136, 1014, 956 }; Em seguida, você vai perceber que nós
// Toca o tom corresponde ao nome da nota declaramos duas funções antes do nosso setup() e
for (int i = 0; i < 8; i++) {
if (names[i] == note) {
loop() . Não importa se colocarmos nossas
playTone(tones[i], duration); próprias funções, antes ou depois setup () e loop
} (). Quando o programa é executado, o código
} dentro dessas duas funções não será executado
}
antes do setup () pois ainda não chamamos essas
void setup() { funções ainda.
pinMode(speakerPin, OUTPUT); Vamos olhar para as funções de configuração e
} loop antes de olharmos para o playTone e funções
playNote. Tudo o que acontece no setup () é que
void loop() {
for (int i = 0; i < length; i++) { atribuir o alto-falante no pino (9) como uma saída.
if (notes[i] == ' ') {
delay(beats[i] * tempo); // rest
} else {
playNote(notes[i], beats[i] * tempo);
}
// Pausa entre notas No loop principal do programa, temos um if / else
delay(tempo / 2); declaração dentro de um loop for.
}
}
Neste projeto estamos fazendo sons usando um

disco piezelétrico. Um disco piezo pode fazer
nada mais do que uma vibração quando se aplica
uma tensão ao mesmo. Assim, para obter os tons
que podemos ouvir, precisamos fazer várias Como você pode ver, a primeira instrução “if ”
vibrações e muitas vezes num instante rápido o tem como condição, que o elemento da matriz [i]
suficiente para que ele realize uma nota contém um caractere de espaço.
reconhecível e que seja audível.
O programa começa por estabelecer as variáveis
necessárias. No piezo de sirenes, o cabo vermelho
é positivo e é ligado ao pino 9 do Arduino.
25
Se for verdadeiro, então o código de dentro do seu Dois parâmetros foram passados para a função e
bloco é executado. dentro da função à estes foram dados os nomes
das notas (names - caracteres) e duração
(duration-inteiro).
A função cria uma matriz local variável de dado.
e isso simplesmente provoca um atraso nas notas. Esta variável tem locais de escopo que só é visível
Temos, então, outra declaração. para essa função e não fora dela.
Em seguida, criar outra matriz de dados do tipo
inteiro e esta matriz armazena os números que
correspondem à frequência dos tons, em kilohertz,
de cada uma das notas nos nomes da matriz.
Depois de uma afirmação se pode estendê-lo
int tones[] = { 1915, 1700, 1519, 1432, 1275,
como outra declaração. Um else é executado se o
1136, 1014, 956 };
condição dentro do if é falsa. Assim, por
exemplo, vamos dizer que tivemos um teste
Depois de configurar as duas matrizes existe um
inteiro e seu valor era de 10 e esta declaração if /
loop que olha através das 8 notas e compara com
else:
a nota enviada para a função.
for (int i = 0; i < 8; i++) {

if (names[i] == note) {
playTone(tones[i], duration);
}
}
Então se o teste teve um valor de 10 o ledPin seria
definido como Alto. Se o valor do teste foi A música que é enviada para este função é
diferente de 10, o código dentro da outra “Ccggaagffeeddc” para a primeira nota será um
declaração seria realizada e em vez disso o ledPin meio C.
seria definido como Baixo. O loop for compara a nota com as notas da matriz
A declaração adiante chama uma função chamada e se houver uma correspondência, chama a
playNote e passa dois parâmetros. O primeiro segunda função, chamada playTone, para jogar o
parâmetro é o valor das notas [i] e o segundo é o tom correspondente.
valor calculado a partir de batidas [i] ritmo *. A segunda função é chamado playTone.
void playTone(int tone, int duration)

Após instrução if /else realizada, há um atraso {
cujo valor é calculado dividindo ritmo por 2. for (long i = 0; i < duration *
1000L; i +=
tone * 2) {
Vamos agora dar uma olhada nas duas funções digitalWrite(speakerPin, HIGH);
que criamos para este projeto. delayMicroseconds(tone);
A primeira função que é chamada a partir do digitalWrite(speakerPin, LOW);
programa principal loop é playNote. delayMicroseconds(tone);
}
void playNote(char note, int duration) { }
char names[] = { 'c', 'd', 'e', 'f', 'g',
'a',
'b', 'C' };
Dois parâmetros são passados para esta função. O
int tones[] = { 1915, 1700, 1519, 1432, primeiro é o tom (em quilohertz) que queremos
1275, que o piezo altofalante reproduza e a segunda é a
1136, 1014, 956 }; duração (composto por cálculo através da função
// play the tone corresponding to the beats [i] * ritmo. A função inicia um loop
note name
for (int i = 0; i < 8; i++) {
if (names[i] == note) { for (long i = 0; i < duration *
playTone(tones[i], duration); 1000L; i += tone * 2)
}
} À medida que cada loop deve ter de um
}
comprimento diferente para fazer com que cada
nota tenha a mesma duração (como o atraso difere
26
entre vibrações para produzir a frequência
desejada) o loop será executado e a duração
multiplicada por 1000 e o incremento do loop é o
valor de tonalidade multiplicado por dois.
Dentro do loop podemos observar que
simplesmente o pino conectado ao ao piezo-
elétrico tem uma ordem de sinal de saída ALTO,
espera-se um curto período de tempo, em seguida,
é enviado um sinal BAIXO, então espera-se mais Exercícios
um curto período de tempo, depois o processo é 1. Alterar as notas e batidas para fazer outras
retomado. músicas, como feliz Aniversário ou Feliz Natal.
2. Escreva um programa para fazer um tom
digitalWrite(speakerPin, HIGH); subindo e descendo do piezo, semelhante a um
delayMicroseconds(tone); alarme de carro ou sirene da polícia.
digitalWrite(speakerPin, LOW);
Esses cliques repetitivos, de comprimentos Projeto 13 – Sensor de temperatura

diferentes e com diferentes pausas (de com o CI LM35
microssegundos apenas) entre os intervalos, faz
com que o piezo produza um som gerado a partir Neste projeto mostraremos como construir um
de diferentes frequências. sensor de temperatura usando o circuito integrado
LM35.
Visão geral do hardware
O que você precisa
A única parte de hardware utilizada neste projeto Circuito integrado LM35
é uma sirene piezoelétrica ou piezelétrica. Este
dispositivo simples é constituído por uma fina
camada de cerâmica ligada a um disco metálico.
Materiais piezelétricos, são alguns cristais e
cerâmica, que têm a habilidade de produzir
eletricidade a partir da tensão (stress) mecânica
quando aplicado a eles. Montagem:
Têm aplicações, tais como a produção e detecção
de som, a geração de elevada tensões, geração de
frequência eletrônica, microbalanças e trabalho
em ultrafinas de focagem ópticas.
O efeito também é reversível, em que, se um
campo elétrico é aplicada através do material
piezelétrico irá fazer com que o material mude de
forma (por menos que seja 0,1% em alguns
casos).
Para produzir os sons de um disco piezo, um
campo elétrico é ligado e desligado muito rápido,
para fazer o material mudar de forma e, portanto, Um sensor de temperatura embutido no CI LM35
causar uma vibração (como um tambor pequeno). lê uma resistência elétrica, que é processada no CI
Por mudar a frequência dos pulsos, o disco e convertida no valor de temperatura em ºC.
deforma-se centenas ou milhares de vezes por O CI LM35 é um circuito integrado que é
segundo e, consequentemente, causando o som. alimentado com tensão de +5 Vcc. Esta tensão é
Ao alterar a frequência das vibrações e o tempo adequada para o Arduino já que ele possui um
entre eles, notas específicas podem ser pino de saída de 5 V. O CI possui três terminais:
produzidas. dois para alimentação de 5 V e um terceiro do
sinal de saída analógico.
O terminal de saída analógica fornece uma tensão
que é diretamente proporcional à temperatura em
ºC. De acordo com a Figura abaixo, o terminal 2
27
fornece uma saída de 1 mV/0,1ºC (ou 10 mV/ºC).
Assim, para determinar a temperatura em ºC deve-
se ler a tensão em mV do terminal 2 e dividir por
10 para ter o valor de temperatura em ºC. Por
exemplo, se o terminal 2 fornece uma leitura de
tensão de 315 mV corresponderá a temperatura de
31,5ºC.
Visão do hardware
Projeto 13 – Descrição do código
O terminal 1 do CI recebe a tensão +5 V e o
terminal 3 é aterrado no pino GND do Arduino. O // Define o pino de saída do CI LM35
int outpin= 0;
terminal 2 é conectado ao pino A0 de entrada
analógica do Arduino, conforme mostra a Figura void setup()
abaixo. {
Serial.begin(9600);
}
// Laço principal
void loop()
{
int rawvolt= analogRead(outpin);
float milivolt= (rawvolt/1024.0) * 5000;
float celsius= milivolt/10;
Serial.print(celsius);
Serial.print(" graus Celsius, ");
delay(5000);
}
O sinal de tensão de saída do CI LM35 é lido na

variável rawvolt. Este valor é proporcional à
tensão de 5000 mV, dividido por 1024 (que é o
máximo valor inteiro lido pela porta analógica do
Arduino). O valor resultante de tensão (em mV) é
gravado na variável milivolt. Por último, a
O mesmo circuito pode ser esquematizado como temperatura em ºC é calculada dividindo
segue. milivolt por 10 (fator de conversão de tensão
em mV para temperatura ºC).
No final do sketch é colocado um atraso de 5 s
para leitura da temperatura do sensor LM35. Este
valor pode ser ajustado conforme a necessidade.
Projeto 14 - Sensor de temperatura

Termistor NTC 10 kΩ
28
comportamento exponencial, como pode ser visto
Neste projeto mostraremos como construir um no gráfico abaixo.
sensor de temperatura usando o termistor NTC de
10 kΩ.
O que você precisa

Termistor NTC 10 kΩ
Montagem
Tensão de saída do circuito

Para este circuito divisor de tensão determina-se a
equação para o sinal de saída injetado ao
microcontrolador da seguinte maneira:
Termistores
Termistores são resistores termicamente sensíveis.
Os termistores são muito utilizados em aplicações
que necessitem de uma alta sensibilidade com
mudança à temperatura, pois eles são
extremamente sensíveis a mudanças relativamente
pequenas de temperaturas.
Todavia não são lineares. A resposta da variação
de temperatura não é linear à variação de sua
resistência, mas pode-se obter a relação entre a
resistência e a temperatura para faixas pequenas
de variação de temperatura através da equação de
Steinhart-Hart.
Existem dois tipos de termistores: o PTC Como a tensão de saída Vout = VR1, temos:
(Coeficiente Positivo de Temperatura) e o NTC
(Coeficiente Negativo de Temperatura), essa
distinção é devida ao material de sua construção.
Esses dispositivos são construídos a partir de
Como Vout do circuito é igual à Vin da entrada
misturas de óxidos semicondutores, como titanato
analógica do Arduino, pode-se adaptar a equação
de bário para os PTCs e óxidos de magnésio,
e inseri-la ao código do programa para determinar
níquel, cobalto, titânio, ferro e cobre para os
corretamente o valor da resistência do NTC. Este
NTCs.
valor de resistência será utilizado na equação de
Os termistores NTC são sensíveis a variações de
Steinhart-Hart:
temperatura. Sua resistência diminui à medida que
a temperatura aumenta. Desenvolvidos com
uma tecnologia que permite tolerância de variação
de 1%.
São usados principalmente para faixas de
medições entre -55º a 150ºC. Devido ao baixo
custo e ao excelente desempenho, o termistor
NTC possui uma ampla utilização nas indústrias,
seja para refrigeração, condicionamento de ar, em Equação de Steinhart-Hart
automóveis, controle de temperatura, sistemas de Analisando o gráfico da curva resistiva
detecção e alarmes contra incêndio, dentre outras. característica de um termistor NTC 10 kΩ,
A curva que define o comportamento da observa-se que a resposta do sensor à variação da
resistência em função da temperatura tem um temperatura medida não é linear, desta forma, a
29
interpretação do sinal de entrada injetado ao
microcontrolador precisar ser tratada através de
uma equação que torne precisa qualquer
temperatura medida.
A relação entre resistência e temperatura no NTC
é dada pela equação de Steinhart-Hart:
Para utilizá-la, selecionam-se as constantes a, b e

c definidas no manual do fabricante do Termistor
NTC ou através de medições realizadas em ensaio
quando estas informações não estiverem
disponíveis.
As constantes para o sensor do kit são:
a = 0,0011303
b = 0,0002339
c = 0,00000008863
Basta agora aplicar estes valores à fórmula
inserida no programa do microcontrolador para
determinar a correta leitura de temperatura em
tempo real.
Projeto 13 – Descrição do código

// Termistor_10k Sensor de temperatura
int sensorPin = 1;
void setup()
{
Serial.begin(9600);
}
void loop()
{
float Valor = analogRead(sensorPin);
float Volt = 5*Valor/1024;
float Res=(10000*Volt/(5-Volt));
Serial.print("Resistencia = ");
Serial.print(Res,0);
Serial.print(" ohm\n");
// Constantes da equação de Steinhart-
Hart
float a = 0.0011224922;
float b = 0.0002359132;
float c = 0.000000074995733;
float X = b*(log(Res));
float Y =
c*(log(Res))*(log(Res))*(log(Res));
float Temp = 1.0/(a + X + Y) - 273;
Serial.print("Temperatura = ");
Serial.print(Temp,2);
Serial.print(" graus C\n");
Serial.print("\n");
delay(1000);
}
30
Referências
McROBERTS, M. R. Arduino starter kit manual.
A complete beginners guide to the Arduino.
Earthshine Design, 2009.
FREETRONICS Experimenters kit project guide

v.1.4. Freetronics, Austrália, 2014. Disponível
online em: <www.freetronics.com/expkit>
ROBOCORE. Arduino kit iniciante v.6.1.

Disponível online em: <http://www.robocore.net>
ELECTRONICS PROJECTS. Learning about

electronics. Disponível online em:
<http://www.learningaboutelectronics.com/Projec
ts/>
MICROCONTROLANDO. Utilizando um sensor

de temperatura – Termistor NTC 10k no PIC.
Disponível online em:
<http://microcontrolado.com/termistor-ntc-10k-
no-pic/>
31
Projeto 15 – Controle de 8 LEDs The “ledCount” variable specifies how many
LEDs are connected, so you can use this same
usando dois laços de repetição sketch with fewer or more LEDs if you like.
The “ledPins” variable is an “array”, which you
can think of as being like a list: in this case it’s a
list of the pins that the LEDs are connected to.
Later in the sketch we’ll refer to the list to turn
different LEDs on and off.
The “ledDelay” variable just sets the number of
milliseconds to leave each LED on for. To make
the scanner run faster, make the number smaller.
To slow it down, make the number bigger.
The setup() function is where things get
interesting. It could alternatively have been
written with a series of eight nearly identical lines,
each one using pinMode() to set one of the LED
pins to OUTPUT mode, but that’s not a
convenient way to write longer programs. Instead
it uses a “for” loop, which runs pinMode() eight
times but with a different value each time.
The first argument passed to the “for” loop sets
the name of the variable that will be used as the
“loop counter”. In this example the loop counter is
a number called “thisLed”, and it’s given a
starting value of 0.
The second argument sets the terminating
condition so the “for” loop will know when it
should stop running. The loop will keep repeating
Descrição do código itself until the condition fails, so in this case the
loop will repeat until the value of “thisLed” is
int ledCount = 8; equal to the value of “ledCount”. We’ve set
int ledPins[] = { 6, 7, 8, 9, 10, 11, 12, ledCount to 8, so it will keep running until ledPin
13 }; is equal to 8.
int ledDelay = 300;
The third and final argument is an action that the
void setup() { loop will perform each time it runs. The “++”
for (int thisLed = 0; thisLed < operator is a shorthand way of saying to take a
ledCount; thisLed++) { variable and add 1 to it, so in this case the
pinMode(ledPins[thisLed], OUTPUT);
}
“thisLed” variable will get bigger by 1 every time
} the loop executes.
When you put those three arguments together, you
void loop() { have a loop that will behave in a certain
for (int thisLed = 0; thisLed <
ledCount-1; thisLed++) {
predictable way. It starts out with a variable with
digitalWrite(ledPins[thisLed], HIGH); a value of 0, increases that value by 1 each time it
delay(ledDelay); runs, and when the value reaches 8 it stops. It’s a
digitalWrite(ledPins[thisLed], LOW); very concise way of saying “do this particular
}
for (int thisLed = ledCount-1; thisLed thing 8 times, slightly differently each time”
> 0; thisLed--) { without having to write each one out individually.
digitalWrite(ledPins[thisLed], HIGH); The loop itself is interesting, but what’s happening
delay(ledDelay);
digitalWrite(ledPins[thisLed], LOW); inside it is also interesting. You’ll see it references
} “ledPins[thisLed]”, which looks a bit confusing.
} You’ll remember that the variable “ledPins” is an
array, or list, containing a series of values.
This sketch introduces a couple of important Referencing it this way allows us to look at
concepts in programming: arrays and loops. positions in the list without having to know what
happens to be on the list in that position. Imagine
32
you have a restaurant menu with a list of dishes, cryptic at first glance, but when you break it down
and each one has a number next to it: you don’t into its major sections it’s fairly simple.
need to state the name of the dish, you can just It’s really just two more “for” loops, one after the
say “I’ll have number 4, please” because the other, that operate just like the “for” loop we
position (or number) of the entry is an easy way to looked at a moment ago.
reference that item on the menu. The first loop increments a counter to step
In arrays, the position in the list is called the forwards through the list using the “++” operator
“array index”, and it’s a number that specifies explained previously. It begins at the start of the
what position in the array we want to examine. list of LEDs, and for each one it turns it on, waits
Unlike typical restaurant menus, though, array for a delay period, then turns it off again before
indices don’t start at 1: they start at 0, so the first moving on to the next one.
position in the array is referenced as index 0. The Once the first loop finishes, the second loop
second position is index 1, and so on. begins. The second loop is almost the same, but it
So when the value of “thisLed” is 0, it’s the same runs backwards! It starts at the last position in the
as referencing “ledPins[0]”, which is position 0 list of LEDs, and each time through it uses the “”
(the first item) on the list. The original code looks operator to decrease the position value by 1. It’s
like this: like reading the restaurant menu backwards,
starting at the last item.
pinMode(ledPins[thisLed], OUTPUT); When it reaches the start of the list, the second
loop finishes and the program jumps back to the
The value for thisLed is 0 on the first pass through start to begin the first loop all over again.
the loop, so to understand what’s going on we can
imagine the variable has been replaced by its
value, like this: Projeto 16 – Controle de 8 LEDs
pinMode(ledPins[0], OUTPUT); usando apenas um laço de repetição
But of course “ledPins[0]” is really just pointing
to the first position in the list. Looking back at the To help understand how the array works, try
definition of the ledPins array, we can see that the swapping some of the values in it around. You’ll
first item on the list has a value of “6”. That see that the counter will still faithfully step
means the command that is really being executed through the list in order, and the LEDs will turn
the first pass is this: on in the order you specify in the array.
Or you could consider other ways to structure this
pinMode(6, OUTPUT); sketch. For example, think about how you could
make it scan from side to side but only use one
Then on the next pass through the loop, the value “for” loop instead of two. At first glance that may
of “thisLed” has increased to 1, so we’re seem impossible, but by thinking about how the
referencing “ledPins[1]”, which is the second item array is used as a list to step through the LEDs in
on the list. Then if you look at the second item on sequence it’s actually quite easy. For example,
the list and substitute it in, the end result is that instead of having a simple list of pins and
what will really be executed on the second pass stepping through it first one way and then the
through the loop is this: other, you could make a longer array that specifies
the complete sequence for an upandback scan, and
pinMode(7, OUTPUT); just loop over it once, like this:
And so on. Descrição do código

Arrays can be a tricky concept, but they’re very
powerful and can make your sketches much int ledCount = 14;
simpler by allowing you to define lists of things int ledPins[] = { 6, 7, 8, 9, 10, 11, 12,
and then step through the list, instead of 13, 12, 11, 10, 9, 8, 7 };
int ledDelay = 300;
specifying similar but slightly different operations
over and over again and taking many more lines void setup() {
to achieve the same end result. for (int thisLed = 0; thisLed < ledCount;
Next we get into the “loop()” part of the program, thisLed++) {
pinMode(ledPins[thisLed], OUTPUT);
which will continue indefinitely. It might look }
}
33
void loop() {
for (int thisLed = 0; thisLed <
ledCount1;
thisLed++) {
digitalWrite(ledPins[thisLed], HIGH);
delay(ledDelay);
digitalWrite(ledPins[thisLed], LOW);
}
}
Yes, we’ve told the sketch that we have 14 LEDs

when we really only have 8, but that doesn’t
matter.
The 14 LED positions count up from 6 to 13 and
then back down again, repeating some of the
positions. Of course this means that setup() will
call pinMode() multiple times on the repeated
pins, but that doesn’t matter. No harm will be
done, and the loop can then step through the list as
if it’s a linear sequence when in fact the list
doubles back on itself.
Projeto 17 – Controle de 8 LEDs

usando o CI 74HC595
Descrição do hardware
Microcontrollers have a limited number of input
and output pins available for use in your projects, If this is your first time using an IC (Integrated
and it’s not unusual to run out of pins when you Circuit) it may seem a bit scary because it has so
want to control many things at once. A simple many pins, but working with ICs is an important
solution is a device called a “shift register”, which skill to learn.
has many outputs that can be controlled Before you begin assembly there is one very
individually using just three pins from your important thing to remember about most ICs: they
Arduino. By sending different values to the shift can be damaged by invisible static electricity that
register you can turn its outputs on or off at will. builds up on your skin, clothes, and workbench.
You can even connect multiple shift registers Simply touching the IC in the wrong way can be
together in a row called a “daisy chain”, giving enough to kill it forever. Some ICs aren’t
you the ability to control a huge number of susceptible to static electricity damage, but many
outputs while still using just three pins on the are, so the safest thing to do is to assume that all
Arduino. ICs are staticsensitive unless specified otherwise.
Don’t worry, it’s not as bad as it sounds. As long
Montagem as you follow some simple precautions you’ll be
fine.
Professional electronics labs often have special
work surfaces and antistatic wrist straps, but for
experiments on your kitchen table you don’t need
to go that far. The important thing is to minimize
contact with the pins of the IC once it has been
removed from its protective foam. Grasp the IC
by the ends of the package, and don’t touch the
pins to anything that may have a static charge.
Once you’ve removed the 74HC595 from its
protective foam you’ll notice something
annoying: the pins aren’t straight! IC pins are
made to splay out slightly so that they can be
inserted into circuit boards with a special tool that
squeezes the pins together, and then when the tool
34
is released the pins spring back out a bit to hold it yellowvioletbrowngold) which also connects to
firmly in place prior to soldering. That means GND.
you’ll need to bend the pins a bit before you can The final three connections are the control lines
fit the IC into a solderless breadboard. from the Arduino, the vital links that will tell the
To bend the pins, hold the IC package side on shift register which outputs should be turned on.
against a hard surface such as a wooden table top
and push down hard. They’ll be quite difficult to IN (input) to Arduino digital I/O pin D2.
bend but you don’t want to bend them too far, so LCLK (latch clock) to Arduino digital I/O pin D3.
the trick is pushing hard enough but not too hard! CLK (clock) to Arduino digital I/O pin D4.
Try to bend both sides in just enough that they are
parallel to each other. Once it’s all connected up you’ll notice there is
Next, check the orientation of the IC and then one remaining pin on the shift register that doesn’t
push it into the solderless breadboard so that the have anything connected to it: OUT. That’s OK,
two rows of pins are on either side of the centre it’s meant to remain unconnected for this project.
line and the dimple or dot near one end is at the
top. This will allow you to easily connect jumper
wires to any pin of the IC. Descrição do código
The 74HC595 shift register has a few different
features that we’re not going to use, so the first int dataPin = 2;
thing to do is connect various pins to either GND int latchPin = 3;
int clockPin = 4;
or 5V to make the chip operate correctly. void setup() {
pinMode(dataPin, OUTPUT);
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
}
void loop() {
for (int currentValue = 0; currentValue <
256; currentValue++) {
// Disable the latch while we clock in
data
digitalWrite(latchPin, LOW);
// Send the value as a binary sequence to
the module
shiftOut(dataPin, clockPin, MSBFIRST,
currentValue);
// Enable the latch again to set the
output states
digitalWrite(latchPin, HIGH);
delay(200);
}
}
Como o software funciona

With the chip oriented as described above, you’ll
The explanation behind this sketch may sound a
notice that the bottom left pin connects to GND
bit brainbending at first, but once you understand
and the top right pin connects to 5V. This is a
what’s going on you’ll see it’s not really that
loose standard used by most ICs that have two
complicated.
rows of pins. Use jumper wires to connect those
The short version is that the 8 outputs of the shift
pins to the GND and 5V rails on the solderless
register represent the individual “bit” values of a
breadboard.
single “byte” of data. A “byte” is a value that
There are two more pins we need to set to specific
consists in binary form of 8 bits, with each bit
values: RESET and OUTPUT ENABLE. Use
having double the place value of the previous bit
another jumper wire to connect RESET to 5V, and
when read from right to left.
OUTPUT ENABLE to GND.
Sound confusing? OK, let’s break it down.
Now we’re ready to connect up all the LEDs to
the outputs of the chip. The outputs are labelled A One “byte” can be represented in binary form as 8
through H, and each needs to connect to the + bits. Each bit can have one of only two values:
(anode) side of an LED. The (cathode) side of either 0 or 1, off or on. Just like with regular
each LED then needs to connect to a 470 Ohm decimal numbers, the position of each digit
resistor (yellowvioletblackblackbrown, or changes its value: the number “50” in decimal
35
means “five tens”, and it’s a bigger number than You can use this same technique to figure out how
“5”, which means “five ones”. In just the same to turn on any combination of outputs, and then
way, the binary number “100” (which is not one map it down to a single value in either decimal or
hundred in decimal, by the way!) has a different binary that will achieve that end result.
value to the binary number “10”, because the
place value of the digits is different. Now with those principles in mind, look at the
sketch again and it may make a bit more sense.
Posição 4 3 2 1 First it sets up the connections to the shift register
Valor decimal 1000 100 10 1
Valor posição binária 8 4 2 1
input, and to the CLK (clock) and LCLK (latch
clock) pins.
Posição 8 7 6 5 Then, in the main loop, it uses a “for” loop to
Valor decimal 10000000 1000000 100000 10000 repeat over an incrementing number. The “for”
Valor posição 128 64 32 16 loop starts with a variable called “currentValue”
binária
which begins with a value of 0, and keeps
Since a byte has eight bits, and each bit can have a repeating as long as the value is less than 256.
maximum value of 1, the biggest possible number Each time it repeats, the value increases by 1, so it
that can fit inside one byte is the binary number will go through with a value of 0, then a value of
“11111111”, which is equivalent to a decimal 1, then a value of 2, then a value of 3, and so on
value of 255: 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1. until the value reaches 255.
One byte can therefore store any number between On the next time through the value will reach 256,
0 and 255 decimal. which hits the limit that has been set and causes
Now stop for a second and look at that binary the program to move on from the “for” loop.
number again. That’s eight bits, all in a row, and After the “for” loop has finished there are no more
every bit can have the value of either 0 or 1. Now commands, so the main loop then just goes back
imagine that each one of those bits is wired up to to the start, and begins all over again running the
one of the eight outputs (A through H) of the shift “for” loop from scratch with a starting value of 0
register, so that if that particular bit is set to 1 then again.
the output is on, and if that particular bit is set to 0 That just repeats forever, so what the sketch does
then the output is off. is count from 0 to 255, then go back and do it
Got it? Well, that’s exactly how a shift register again.
works! The eight outputs are just physical But the interesting bit is what the sketch does with
representations of the state of each of the eight that value each time it runs through the “for” loop.
bits inside that byte. And by sending a different Inside the “for” loop are three commands: first to
value for the byte, we can manipulate which change the state of the “LCKL” (latch clock) pin,
outputs are turned on and which are turned off. then a command to send the current value to the
Remember that the bits are counted from the right register using the IN pin, then to change the state
in increasing place value (just like decimal of LCLK back again.
numbers) so to set a specific set of outputs on, you Those three commands, in that sequence, will
just work out the bits to represent those outputs. cause the Arduino to take the value of the
Want to turn on outputs A, C, and E, and leave all “currentValue” variable and send it to the shift
the others off? Easy, just map it out like this, register to set the state of all the outputs.
remembering that digits to the left have higher Using the "shiftOut" command we can clock a
place value so we’ll label it starting with “A” on byte of data (value 0 to 255) to the module, setting
the right and working to the left like we would the state of each output appropriately. For
with a decimal number: example, sending a value of "0" decimal will set
all the outputs LOW. Sending a value of "255"
H G F E D C B A decimal will set all of the outputs HIGH. Sending
0 0 0 1 0 1 0 1 a value of 1, 2, 4, 8, 16, 32, 64, or 128 decimal
will set only output A, B, C, D, E, F, G, or H
That’s binary “00010101”, and from the previous HIGH respectively.
table we can add up the place values of those bits The sketch below counts from 0 to 255 and sends
(16 + 4 + 1) to give a decimal value of “21”. So if each consecutive value to the shift register.
you send a value of 21 to the shift register, it will
turn on outputs A, C, and E, and turn all the others
off. Projeto 17 – Usando múltiplos CIs
74HC595
36
transition this pin causes the values loaded into
If you want to be able to manipulate individual the shift register to be applied to the outputs.
outputs from within your sketch without affecting Connect to a digital I/O pin of your
the state of other outputs, the most convenient microcontroller.
method is probably to store the current value of
the shift register as a 1byte variable and apply Clock: On a LOW-to-HIGH transition this pin
bitwise operators to it. The Arduino website has a causes the value currently applied to the Serial IN
good introduction to bitwise operators at pin to be read into the shift register, and all other
http://www.arduino.cc/playground/Code/BitMath. values moved along one position.
Sometimes eight outputs aren’t enough! You can Output Enable: Active LOW. When pulled HIGH,
connect multiple shift registers together in a row all outputs are disabled and placed in a high
(called a “daisy chain”) so that you can pass impedance state. When pulled LOW, all outputs
values down the chain to each of the modules are enabled. For minimal pin usage this can be
individually. That way you can control 16, 24, 32, tied to GND to permanently enable the outputs,
or even more separate outputs with the same three but this will have the effect that they may start in
outputs from your Arduino. an unknown state at powerup. Connect to a digital
To daisychain multiple shift registers, begin with I/O pin of your microcontroller if you want to
the simple example above. Then connect a second explicitly enable outputs from software, otherwise
shift register so that the VCC, GND, RST, OE, connect to GND.
CLK, and LCLK connections are all linked to the
same place as the first shift register. Finally, run a Reset: Active LOW. When pulled LOW, the shift
jumper wire from the OUT connection on the first register is cleared and all stored values are lost.
shift register to the IN connection on the second Pull HIGH for normal operation. For minimal pin
shift register. usage this can be permanently tied to 5V to
Once you have two shift registers daisychained disable reset, but this will require you to explicitly
together, setting their outputs is just as easy as set all 8 bits in order to reset the outputs if they
addressing a single register except that you have are not in a known state. Connect to a digital I/O
to send two bytes of data instead of one. The first pin of your microcontroller if you want to be able
byte sent will pass down the chain to the last to reset the state with a single pulse, but generally
register, and the second byte sent will then go to it's simplest to connect to 5V.
the first register: think of it as pushing messages
down a pipe. The first one you push in will go GND: Connect to GND (0V) on your
towards the end, and the second message will go microcontroller.
in right behind it.
Using three or more shift registers follows the VCC: Connect to 5V on your microcontroller.
exact same principle: simply daisychain more Outputs A to H: Outputs to your other devices.
together linking the OUT connection of each into Can be driven LOW, HIGH, or be set into a high
the IN connection of the next in the chain, and impedance state by setting Output Enable to
send as many bytes of data as you have shift LOW.
registers in the chain.
Addendum:
Understanding Shift Register Connections
Serial OUT: Passes serial data back out to another

module. Can be connected to the Serial IN of
another module to daisychain them together and
control even more outputs. Typically left
unconnected.
Serial IN: Data sent from the microcontroller to

set the state of the output pins. Connect to a
digital I/O pin of your microcontroller.
Latch: Also sometimes referred to as the "storage

clock" or "latch clock". On a LOW-to-HIGH
37

Apostila de Arduino

Enviado por

Direitos autorais:

Formatos disponíveis

Apostila de Arduino

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila de Arduino

Enviado por

Direitos autorais:

Formatos disponíveis

UNIVERSIDADE DE SÃO PAULO

ESCOLA DE ENGENHARIA DE LORENA

Prof. Carlos Yujiro Shigue

// Projeto 1 - LED Pisca-Pisca

Então vamos dar uma olhada no código para este

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

No próximo projeto, vamos adicionar a este

Projeto 4 - Semáforo interativo

// Projeto 4 – Semaforo interativo

Digite o código da página seguinte, verificar e void changeLights() {

int state = digitalRead(button); e o cálculo é um exemplo de um operador

if (x>500) {digitalWrite(ledPin, HIGH); if (!x) {…

if (state == HIGH && (millis()- if (x==5 && (y == 10 || z == 25)) {…

O que você precisa Nossa primeira linha no sketch é

byte ledPin[] = {4, 5, 6, 7, 8, 9,

Esta é uma declaração de uma variável do tipo

byte ledPin[10]; Iremos agora fazer uma sequência de LEDs (10

Neste exemplo x teria agora um valor 8.

E o trabalho desta função é passar todos os LEDs

Digite o código no IDE Em seguida, enviar esse valor para o Pino 11

Em seguida, a matriz RGB2 é um conjunto de

Neste caso, teremos um conjunto de números

Em seguida, configurá-los para serem saídas.

O laço principal do programa, em seguida, envia

Então, finalmente, temos um atraso aleatório

if ((data[0] == 'r') || (data[0] ==

A instrução if verifica se o primeiro caractere no

Antes de ligar o circuito, verifique se tudo foi

Circuito equivalente do transistor TIP120.

Projeto 12 – Atuador piezelétrico

No nosso circuito, temos 3,3 volts indo para o

// Projeto 12 – Atuador piezeletrico

Neste projeto estamos fazendo sons usando um

for (int i = 0; i < 8; i++) {

void playTone(int tone, int duration)

Esses cliques repetitivos, de comprimentos Projeto 13 – Sensor de temperatura

O sinal de tensão de saída do CI LM35 é lido na

Projeto 14 - Sensor de temperatura

O que você precisa

Tensão de saída do circuito

Para utilizá-la, selecionam-se as constantes a, b e

Projeto 13 – Descrição do código

FREETRONICS Experimenters kit project guide

ROBOCORE. Arduino kit iniciante v.6.1.

ELECTRONICS PROJECTS. Learning about

MICROCONTROLANDO. Utilizando um sensor

And so on. Descrição do código

Yes, we’ve told the sketch that we have 14 LEDs

Projeto 17 – Controle de 8 LEDs

Como o software funciona

Serial OUT: Passes serial data back out to another

Serial IN: Data sent from the microcontroller to

Latch: Also sometimes referred to as the "storage

Você também pode gostar