Curso Básico de Arduino

Prévia do material em texto

Curso Básico de Arduino
Tópicos Avançados de Programação
Marcelo Felipe Moreira Persegona e Luiz Felipe Marcolino Persegona 
Curso Básico de Arduino | Brasília/DF, outubro de 2019
Sumário
O QUE É ARDUINO?	4
O QUE SÃO SHIELDS?	6
COMPONENTES DA PLACA ARDUINO	6
INSTALANDO A IDE DO ARDUINO NO WINDOWS	16
Aula 01 - Hello, World!	18
Aula 02 - LED com botão liga desliga	20
Aula 03 - Controlar um LED com um potenciômetro	26
Aula 04 - Botão que acende LED-s com efeito	32
Aula 05 - Controlando 8 LED-s com CI74HC595 e fazendo contagem binária	39
Aula 06 - Piscar um LED com efeito fader	44
Aula 07 - Sinal de trânsito	48
Aula 08 - Dois sinais de trânsito sincronizados	53
Aula 09 - Controlando LED RGB multicolorido	62
Aula 10 - Controlar as cores de um LED RGB com botões	68
Aula 11 - Sensor de luz LDR com saída de leitura em LED-s	76
Aula 12 - Emitir sons com o buzzer	80
Aula 13 - Controlando dois servomotores com potenciômetros	84
Aula 14 - Controlando um servomotor com potenciômetro	87
Aula 15 - Controlar a velocidade de um motor CC com potenciômetro	90
Aula 16 - Motor CC com controle de velocidade, LED-s medidores de potência e buzzer para alerta de potência máxima	94
Aula 17 - Alarme com sensor de movimentos PIR	98
Aula 18 - Display LCD - Hello World	101
Aula 19 - Display LCD com dois potenciômetros	104
Aula 20 - Display LCD com sensor de temperatura e luminosidade	110
Aula 21 - Display LCD com dois potenciômetros e servomotor controlado com um potenciômetro	116
Aula 22 - Relógio simples com display LCD	121
Aula 23 - Montagem de relógio com módulo DS1302RTC	124
Aula 24 - Sensor de obstáculos ultrassônico HC-SRO4	129
Aula 25 - Carro robótico com sensor de obstáculo e servomotor	134
Aula 26 - Carro robótico controlado com controle remoto infravermelho	138
Aula 27 - Braço robótico com 4 servomotores controlados com potenciômetros	142
Aula 28 - Calculadora	149
Aula 29 – Controle Remoto Infravermelho	153
Aula 29 - Hovercraft	158
Aula 30 - Drone com material reciclado	166
Aula 31 – Robô humanoide	168
Aula 01 - 17DOF RC Robot	176
Aula 01 – PLOTCLOCK	179
Aula 01 – PS2 Controller Sketch for ESCs and Stuff	193
Aula 01 – Braço robótico com 6 servomotores	199
Aula 01 – Senha com teclado	211
Aula 01 – Fechadura com senha via teclado	215
Aula 01 – Mão articulada	221
Aula 01 – Uso de LED-s	243
O QUE É ARDUINO?
O Arduino é uma plataforma eletrônica de código aberto baseada em hardware e software[footnoteRef:1] fáceis de usar em uma plataforma de prototipagem eletrônica de hardware livre e de placa única, projetada com um microcontrolador ATMel AVR com suporte de entrada/saída embutido. Sua linguagem é essencialmente C/C++. [1: Entenda hardware como as placas e software como o programa de computador.] 
Então Arduino é um conjunto de ferramentas para facilitar o desenvolvimento de dispositivos eletrônicos. Nessa plataforma estão incluídos o software de programação, a IDE do Arduino (ou ambiente de desenvolvimento de códigos), e as placas que serão programadas para serem usadas no projeto, como o Arduino UNO. 
Além disso, todas essas ferramentas são de código aberto, ou seja, qualquer pessoa pode replicá-las ou contribuir para o seu aperfeiçoamento, respeitando algumas regras. Isso é o que permite o surgimento de diversas placas compatíveis, melhoradas e para as mais diversas aplicações. São todas essas ferramentas que nos permitem interagir com uma série de componentes eletrônicos para desenvolver uma infinidade de projetos. 
O material aqui coletado ajudará a você aprender sobre essa plataforma que vem revolucionando o aprendizado da eletrônica.
https://www.tinkercad.com/circuits
https://www.arduino.cc
(Caso necessário, Download do drive USB2.0-Serial CH34x)
https://sparks.gogo.co.nz/ch340.html
https://www.robocore.net/loja/shields-para-arduino
http://fritzing.org/download/
O primeiro Arduino surgiu por volta de 2005, na Itália, e a idéia era disponibilizar um microcontrolador barato e fácil de se usar, voltado para hobistas, estudantes e profissionais, que possibilitasse que esse grupo de pessoas construísse sistemas de hardware e software que interagissem com o mundo real por meio de sensores ou outros componentes eletrônicos recebendo as entradas, e por atuadores produzindo as saídas. 
Por exemplo, em um projeto com um servomotor e um potenciômetro no Arduino, tem-se um componente eletrônico recebendo uma entrada que seria a movimentação do seu eixo, e um servomotor, como atuador, produzindo uma saída que são os movimentos do seu braço de acordo com a movimentação do potenciômetro, e o Arduino realizando o processamento que transforma o movimento do eixo do potenciômetro em movimentos do braço do servomotor.
Então, pode-se dizer que o Arduino é um microcontrolador com diversos facilitadores para o microcontrolador ATMega. 
Com um Arduino somos capaz de criar uma infinidade de projetos, como alarmes, controladores de iluminação, braços robóticos, um robô inteiro, controlador de telas sensíveis ao toque, controlar motores e muitas outras coisas.
O conjunto formado pelo: Arduino, IDE de programação e linguagem de programação, é chamado Wiring. O Wiring é open-source e é conhecido como plataforma de desenvolvimento ou plataforma de prototipação. Muitas pessoas confundem a definição de Wiring com a definição do Arduino, contudo, o Arduino faz parte do Wiring e é apenas um microcontrolador com hardware open-source.
Placa Arduino UNO Original da Itália à esquerda e Arduino IDE à direita.
Os programas escritos para o Arduino são chamados de sketch (esboço/rascunho) e são escritos em linguagem C e C++. A IDE do Arduino vem com uma biblioteca composta por um conjunto de funcionalidades que facilitam o trabalho de programação. Escrever programas para o Arduino é fácil, e tratando de modo genérico, precisa-se apenas definir o que o método setup() e o método loop() vão fazer. 
O método setup() é executado uma vez assim que o Arduino é ligado e normalmente é usado para definir configurações iniciais, como por exemplo quais serão os pinos de entrada ou de saída do Arduino. O método loop() é executado após o método setup(), e como diz o próprio nome ele é executado em loop equanto o Arduino estiver ligado. Dentro do método loop é onde normalmente é escrito as funcionalidades do programa, como por exemplo, fazer um LED piscar de dois em dois segundos.
O Arduino possui várias versões, dentre elas pode-se destacar: Arduino UNO, Arduino Leonardo, Arduino Due, Arduino Yún, Arduino Micro, Arduino Mega, Arduino Fio, Arduino Tre, Arduino Zero e muitas outras. E recomendado iniciar com Arduino UNO R3. 
Para começar os projetos com Arduino é necessário uma placa Arduino, um computador para programá-lo, uma protoboard e os componentes eletrônicos necessários para a construção do seu projeto. 
O QUE SÃO SHIELDS?
Os shields são placas de expansão conectadas ao Arduino para obter funcionalidades específicas como: controlar motores, GPS, redes Wi-Fi,  Wireless, leitoras de cartão SD, bluetooth, MP3 player, joystick e muito mais. Vários shields podem ser conectados ao Arduino ao mesmo tempo.
COMPONENTES DA PLACA ARDUINO
Existe uma grande variedade de placas Arduino que podem ser utilizadas para diferentes propósitos. Algumas placas podem ser diferentes da placa abaixo, mas a maioria das placas Arduino possui os componentes listados.
Alimentação (USB/Conector P4)
Cada placa Arduino precisa de uma maneira de ser conectada à uma fonte de energia. O Arduino UNO pode ser alimentado a partir de um cabo USB proveniente do seu computador ou a partir de uma fonte de alimentação de parede que é terminada em um conector P4. Na imagem acima, a conexão USB (2) e a entrada do P4 (7).
A conexão USB também é por onde será carregado o código na placa Arduino. 
NOTA 1: NÃO use uma fonte de alimentação superior a 15 V, pois você irá superar a tensão máxima do seu Arduino e assim irá queimá-lo. A tensão recomendada para a maioria dos modelos Arduino é de 6 V a 12 V.
NOTA 2: quando alimentar a sua placa por uma fonte externa, verifique que o terminalpositivo (+) é o terminal interno do conector P4.
Pinos (5V, 3V3, GND, Analógicos, Digitais, PWM, AREF)
Os pinos na placa Arduino são os lugares onde se conecta os fios para construir um circuito, em conjunto com uma protoboard. O Arduino tem vários tipos diferentes de pinos, cada um dos quais é rotulado na placa e usado para diferentes funções.
GND (3): abreviação de "ground" (terra em inglês). Existem vários pinos de GND no Arduino, qualquer um deles pode ser utilizado para aterrar o circuito.
5V (4) e 3V3 (5): o pino de 5V fornece 5 volts de energia e o pino de 3V3 fornece 3,3 volts. A maioria dos componentes simples usados com o Arduino trabalham felizmente com 5 V ou 3,3 V;
Analógico (6): a área dos pinos rotulada com "ANALOG IN" (A0 a A5 no UNO) é para os pinos analógicos. Esses pinos podem ler o sinal de um sensor analógico (como um sensor de luminosidade) e convertê-lo em um valor digital para usar no código.
Digital (7): a área dos pinos rotulada com "DIGITAL" (0 a 13 no UNO) é para os pinos digitais. Esses pinos podem ser usados tanto para entrada digital (como dizer se um botão está pressionado) como para saída digital (como alimentar um LED).
PWM (8): o til (~) ao lado de alguns dos pinos digitais (3, 5, 6, 9, 10 e 11 no UNO) atuam como pinos digitais normais, mas também podem ser utilizados para algo chamado Modulação por Largura de Pulso (PWM). Esses pinos são capazes de atuar como uma "saída analógica" (podendo controlar a intensidade de um LED, por exemplo).
NOTA: geralmente os pinos analógicos do Arduino podem também ser usados como entrada ou saída digital (isso vale para A0 a A5 no UNO).
Botão de reset
Assim como a Nintendo original, o Arduino possui um botão de reinicialização (9). Empurrando, ele conectará temporariamente o pino de reset (RST) ao GND e reiniciará o programa carregado no Arduino. Isso pode ser muito útil se o seu código não repetir, mas você quer testá-lo várias vezes. 
NOTA: o reset não apaga o código carregado na placa, ele serve para reiniciar a execução do programa.
LED indicador de energia
Ao centro da placa existe um pequeno LED ao lado da palavra "ON" (10). Este LED deve acender sempre que ligar o Arduino a uma fonte de energia. Se esta luz não ligar, há uma boa chance de haver algo errado. Verifique o seu circuito!
LED-s TX e RX
TX é a abreviação para transmitir, o RX é a sigla para receber. Essas marcas aparecem um pouco na eletrônica para indicar os pinos responsáveis pela comunicação serial. No nosso caso, há dois lugares no Arduino UNO onde TX e RX aparecem: uma vez ao lado dos pinos digitais 0 e 1, e uma segunda vez ao lado dos LED-s indicadores TX e RX (11). Esses LED-s nos darão algumas boas indicações visuais sempre que nosso Arduino estiver recebendo ou transmitindo dados. Por exemplo quando estamos carregando um novo programa na placa.
CI principal
O maior componente da placa, com várias pernas metálicas, é um CI, ou circuito integrado (12). É nele que o código é executado e todos os dados são processados. O CI principal no Arduino é diferente entre modelos de placa, mas geralmente é da linha ATmega de microcontroladores da empresa Atmel (agora Microchip).
Reguladores de tensão
Os reguladores de tensão não são realmente algo que se deva mexer no Arduino. Mas é útil saber que estão lá e para que servem. Os reguladores de tensão fazem exatamente o que o nome diz, eles controlam a tensão interna da sua placa Arduino. Ele faz com que a tensão do circuito seja sempre a mesma, independente da tensão de alimentação. 
Módulos para placa Arduino
Geekcreit® UNO R3 
Kit básico de aprendizagem inicial atualização da versão para Arduino
Característica: 
Esta é uma versão atualizado do UNO R3 kit para inicial, adiciona mais componentes para obter mais recursos e experimentar. 
Você aprenderá por meio da construção de vários projetos criativos.
Iniciando o básico da eletrônica, para fazer projetos mais complexos, o kit irá ajudá-lo a controlar o mundo físico com sensor e atuadores.
Incluído no pacote: 
1 x Placa de desenvolvimento UNO R3 compatível com Arduino
1 x Cabo USB
1 x Placa de extensão do protótipo
1 x Mini placa de ensaio
1 x Motor passo a passo 5V
1 x Placa de motorista de motor stepper 2003
10 x LED vermelho
10 x LED verde
10 x LED azul
2 x Sensor de vibração
1 x Sensor de chama
1 x Sensor de temperatura LM35
1 x Receptor infravermelho
3 x Fotorresistor
4 x Tampa da tecla
4 x Interruptor de chave
1 x Potenciômetro ajustável
1 x Buzzer passivo (zumbador piezo)
1 x Buzzer ativo (gerador de tom)
1 x Boné de jumper
1 x Painel grande
1 x Controle Remoto
1 x 1602 Tela
1 x Servos 9G
1 x Caixa de componentes
1 x 10p linha DuPont
30 x Linha de placa de ensaio(aprox.)
1 x Resistência 220ohm
1 x 8*8 matriz de pontos
1 x Tubo de oito dígitos de um dígito
1 x Quatro dígitos tubo de oito segmentos
1 x IC 74HC595
1 x Suporte da bateria
1 x Plug de resistor de 1K
1 x Plug de resistor 10K
1 x Bateria de 9V
1 x 2,54mm cabeçalho de pinos de 40 pinos 
	
	
	
https://www.tinkercad.com/learn
http://www.comofazerascoisas.com.br/projeto-arduino-led-com-botao-liga-desliga.html
http://www.comofazerascoisas.com.br/marcadores/Arduino+Uno+R3
http://www.comofazerascoisas.com.br/projeto-arduino-controlando-led-rgb-multicolorido.html
http://www.comofazerascoisas.com.br/projeto-arduino-com-display-lcd.html
http://www.comofazerascoisas.com.br/circuito-simples-que-controla-a-velocidade-de-um-motorzinho-como-fazer.html
http://www.comofazerascoisas.com.br/projeto-arduino-com-display-lcd-sensor-de-temperatura-e-sensor-de-luz.html
http://www.comofazerascoisas.com.br/motor-cc-no-arduino-com-controle-de-velocidade-e-leds-medidores-de-potencia.html
http://www.comofazerascoisas.com.br/joystick-controlando-3-servomotores-no-arduino.html
http://www.comofazerascoisas.com.br/guincho-robotico-de-palito-de-picole-com-arduino-e-servomotores-como-fazer.html
http://www.comofazerascoisas.com.br/como-fazer-um-mini-gerador-de-energia-aeolica-versao-2.html
http://www.comofazerascoisas.com.br/como-fazer-um-aviao-bimotor-de-palitos-de-picole.html
http://www.comofazerascoisas.com.br/arduino-com-sensor-de-obstaculos-ultrasonico-HC-SRO4.html
http://www.comofazerascoisas.com.br/como-fazer-um-alarme-com-arduino-sensor-de-movimentos-pir.html
http://www.comofazerascoisas.com.br/controlando-a-velocidade-de-um-motor-cc-no-arduino-com-potenciometro.html
https://www.instructables.com/id/Smartphone-Controlled-RC-Car-Using-Arduino/
https://www.instructables.com/id/Arduino-CNC-Plotter-DRAWING-MACHINE/
https://www.instructables.com/id/Sensor-Stations-Network-for-Lighting-and-Security-/
https://www.instructables.com/id/Arduino-Bluetooth-Controlled-Robot-Car-1/
https://www.instructables.com/id/Arduino-Robot-Arm-3/
https://www.instructables.com/id/Mini-CNC-Laser-Wood-Engraver-and-Paper-Cutter/
https://www.instructables.com/id/DoggoBot-Version-1/
https://www.instructables.com/id/Radar-Gr%C3%A1fico-Con-Arduino-Y-Processing/
https://www.instructables.com/id/Electric-Analog-Piano/
https://www.instructables.com/id/How-to-Build-a-GPS-Guided-Robot/
https://www.instructables.com/id/Arduino-CNC-Drawing-Machine-or-the-Road-to-Success/
https://www.instructables.com/id/How-to-Make-a-Drone-Using-Arduino-Make-a-Quadcopte/
https://www.instructables.com/id/DIY-Arduino-Drawing-Machine/
https://www.instructables.com/id/How-to-Make-a-Line-Follower-Using-Arduino/
https://www.instructables.com/id/Yet-Another-Balancing-Robot/
https://www.instructables.com/id/Arduino-Camera-Stabilizer-DIY/
https://randomnerdtutorials.com/projects/#home-automation
https://www.hackster.io/petoi/opencat-845129
http://www.techmonkeybusiness.com/ps2-controller-sketch-for-escs-and-stuff.html
INSTALANDO A IDE[footnoteRef:2] DO ARDUINO NO WINDOWS [2: Integrated Development Environment (IDE) ou Ambiente de Desenvolvimento Integrado, é um programa de computador que reúne características e ferramentas de apoio ao desenvolvimento de software com o objetivo de agilizar este processo.] 
This document explains how to installthe Arduino Software (IDE) on Windows machines 
Download the Arduino Software (IDE)
Proceed with board specific instructions
Download the Arduino Software (IDE)
Get the latest version from the download page. You can choose between the Installer (.exe) and the Zip packages. We suggest you use the first one that installs directly everything you need to use the Arduino Software (IDE), including the drivers. With the Zip package you need to install the drivers manually. The Zip file is also useful if you want to create a portable installation. 
When the download finishes, proceed with the installation and please allow the driver installation process when you get a warning from the operating system. 
Choose the components to install 
Choose the installation directory (we suggest to keep the default one) 
The process will extract and install all the required files to execute properly the Arduino Software (IDE) 
Proceed with board specific instructions
When the Arduino Software (IDE) is properly installed you can go back to the Getting Started Home and choose your board from the list on the right of the page. 
Aula 01 - Hello, World!
O QUE VAMOS FAZER?
Como acender um LED com o Arduino.
PEÇAS QUE SERÃO UTILIZADAS
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	Resitor de 1000 ohms
	01
	4
	LED vermelho
	01
	5
	Cabo jumper macho curto
	01
	6
	Cabo jumper macho longo
	01
PASSOS DA MONTAGEM DA PROTOBOARD
Segue abaixo o esquema do projeto. A imagem do projeto será a sua referência para a conexão correta dos componentes.
Passo 1 - Conecte a perna positiva (grande) do LED na casa 6e e a negativa (pequena) na casa 5e.
Passo 2 – Conecte o resistor na casa 5b e nos pinos negativos da protoboard.
Passo 3 – Conecte o fio verde na casa 6b da protoboard e no pino digital 8 da placa do Arduino e conecte o fio preto no ponto negativo da protoboard e no pino GND da placa do Arduino.
SCRIPT ARDUINO
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
	/*
Projeto acendendo um LED.
*/
 
void setup()
{
 pinMode(8, OUTPUT);
}
void loop()
{
 digitalWrite(8, HIGH);
 delay(1000); 
 digitalWrite(8, LOW);
 delay(1000);
}
RESULTADO
Após o envio do programa, o LED ficará aceso até o Arduino ser desligado.
COMENTÁRIOS
Aula 02 - LED com botão liga desliga
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-led-com-botao-liga-desliga.html
O QUE VAMOS FAZER?
Como acender um LED com botão no Arduino. 
Este projeto consiste em controlar o funcionamento de um LED, ligando e desligando-o por meio de um push button. 
PEÇAS QUE SERÃO UTILIZADAS
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	Cabo jumper macho curto
	03
	4
	Cabo jumper macho longo
	04
	5
	Resitor de 150 ohms
	01
	6
	Resitor de 100 ohms
	01
	7
	LED vermelho
	01
	8
	Push button
	01
PASSOS DA MONTAGEM DA PROTOBOARD
Segue abaixo o esquema do projeto. A imagem do projeto será a sua referência para a conexão correta dos componentes.
Passo 1 - Conecte o botão na protoboard, atentando para a sua posição, que pode ser vista na imagem abaixo.
Neste caso conectamos uma perna do botão na coluna 50 e uma na coluna 48 da protoboard.
Passo 2 – Agora, conecte uma perna do resistor de 150 ohms na coluna 48, a mesma do botão, e a outra perna do resistor você vai conectar na coluna 45. Conecte um fio jumper ligando a perna do resistor na coluna 45 (fio preto) a linha horizontal negativa (linha azul da protoboard). Conecte outro fio jumper ligando a perna do botão da coluna 50 (fio vermelho) a linha horizontal positiva (linha vermelha da protoboard).
Passo 3 - Conecte um fio jumper, fio amarelo, entre a perna do botão e a do resistor na coluna 48.
Passo 4 - Agora chegou a hora de ligar o LED na protoboard. Conecte a perna grande do LED na coluna 55 e a perna pequena na coluna 56. Conecte um resistor de 100 ohms entre o LED e o fio jumper, conforme mostra a imagem abaixo.
Passo 5 - Conecte um fio jumper na coluna 56 e na linha negativa da protoboard, ligando a perna pequena do LED com a linha negativa.
Passo 6 - Conecte um fio jumper no início da linha negativa, fio preto, e outro no início da linha positiva, o fio vermelho.
Passo 7 - Conecte a protoboard, juntamente com os seus componentes (LED, botão, resistores) no Arduino. Para facilitar o entendimento e a explicação usarei como referência as cores dos fios jumper usados neste projeto. Segue abaixo os passos para realizar as ligações dos fios jumper da protoboard ao Arduino.
· fio amarelo ao pino digital 2 do Arduino;
· fio azul ao pino digital 8 do Arduino;
· fio vermelho ao pino de alimentação 5V;
· fio preto ao pino GND.
Feito isso seu projeto físico Arduino LED com botão está completo e pronto para funcionar.
SCRIPT ARDUINO
Segue abaixo o código fonte do programa que vai controlar o Arduino, conforme o presionamento do botão, que se estiver apertado acende o LED, se não apaga o LED. 
Neste projeto é introduzido o uso de constantes em programas Arduino. A diferença de uma constante para uma variável é que uma variável pode ter seu valor alterado quantas vezes for necessário dentro do programa. Já a constante, uma vez que se define o valor inicial não se pode mais alterar este valor. 
Neste programa também é utilizado o comando digitalRead que, neste caso, faz a leitura do pino digital 2, detectando se o mesmo está ou não recebendo energia.
Em síntese, este programa captura o estado do botão, pressionado ou não pressionado, e, de acordo com o estado, envia ou não energia para acender o LED. 
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
	/*
Projeto Arduino acendendo e apagando o LED com botão.
Por João Paulo - Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
//Declaração das constantes
const int led = 8;   //constante LED refere-se ao pino digital 8.
const int botao = 2; //constante botão refere-se ao pino digital 2.
 
//Variável que conterá os estados do botão (0 LOW, 1 HIGH).
int estadoBotao = 0;
 
//Método setup, executado uma vez ao ligar o Arduino.
void setup() {
  pinMode(led,OUTPUT);  //Definindo pino digital 8 como de saída.
  pinMode(botao,INPUT); //Definindo pino digital 2 como de entrada. 
}
 
//Método loop, executado enquanto o Arduino estiver ligado.
void loop() {  
  //Lendo o estado do pino 2, constante botao, e atribuindo 
  //o resultado a variável estadoBotao.
  estadoBotao = digitalRead(botao);          
   
  //Verificando o estado do botão para definir se acenderá ou
  //apagará o LED.  
  if (estadoBotao == HIGH) {
    digitalWrite(led,HIGH); //Botão pressionado, acende o LED.
  } else {
    digitalWrite(led,LOW);  //Botão não pressionado, apaga o LED.    
  }       
}
 
Com o programa na IDE do Arduino, agora é só compilar e depois fazer o upload. A imagem abaixo destaca os botões de verificação/compilação e de upload na barra de ferramentas da IDE do Arduino.
 
Após a compilação e upload seu projeto está completamente pronto! Agora é só apertar o botão para acender o LED. 
RESULTADO
COMENTÁRIOS
Aula 03 - Controlar um LED com um potenciômetro
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-como-controlar-um-led-com-potenciometro.html
O QUE VAMOS FAZER?
Controlar um LED com um potenciômetro.
PEÇAS QUE SERÃO UTILIZADAS
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	Cabo jumper macho curto
	03
	4
	Cabo jumper macho longo
	04
	5
	Resitor[footnoteRef:3] de 100 ohms [3: Os resistores são componentes eletrônicos passivos, muito comuns no mundo da eletrônica e a letra R é usada para representá-lo. Os resistores não são polarizados, ou seja, não possuem polo positivo e negativo. A função do resistor é limitar o fluxode corrente elétrica que passa por ele, e a essa limitação se dá o nome de resistência, medida em ohms, e ela define qual a facilidade ou dificuldade que os eletrons terão que enfrentar para passar pelo resistor. Quanto maior o valor da resistência (em ohms) mais difícil será para os eletrons passarem pelo resistor e quanto menor o valor da resistência (em ohms) mais fácil será para os eletrons passarem. A limitação do fluxo da corrente elétrica que o resistor impõe causa também uma queda na tensão.] 
	01
	6
	LED azul
	01
	7
	Potenciômetro[footnoteRef:4] de 10k [4: Potenciômeto é um componente eletrônico que cria uma limitação para o fluxo de corrente elétrica que passa por ele, e essa limitação pode ser ajustada manualmente, podendo ser aumentada ou diminuida. Os potenciômetros e o resistores tem essa finalidade de limitar o fluxo de corrente elétrica em um circuito, a diferença é que o potenciômetro pode ter sua resistência ajustada e o resistor comum não pode pois ele possui um valor de resistência fixo.] 
	01
PASSOS DA MONTAGEM DA PROTOBOARD
Segue abaixo o esquema do projeto. A imagem do projeto será a sua referência para a conexão correta dos componentes.
O primeiro passo é conectar o LED, o potenciômetro e o resistor na protoboard. Neste caso o LED teve a sua perna maior conectada na coluna 55 e a menor conectada na coluna 56. O resistor de 100 ohms apenas uma de suas pernas conectada na coluna 55 e o potenciômetro teve uma perna conectada na coluna 40, outra na 42 e outra na 44. Veja a disposição dos componentes na imagem abaixo.
Usando os fios jumper pequenos conecte uma perna do LED, a da coluna 56, na linha horizontal azul, que será o fio terra do projeto. Conecte a perna da coluna 40 do potenciômetro também na linha horizontal azul e a perna da coluna 44 na linha horizontal vermelha, que fornecerá os 5V do projeto.
Conecte os fios jumper médios na protoboard, um na coluna 42 que é a perna do meio do potenciômetro, no caso do fio azul conecte-o direto na perna do resistor, não é necessário conectar nem esta perna do resistor nem o fio azul na protoboard, a ligação é direta entre o fio azul e uma perna do resistor. Um fio na linha horizontal vermelha (5V) e um na linha horizontal azul (terra).
Abaixo está melhor exemplificado a ligação entre LED, resistor e fio jumper.
Agora chegou a hora de conectar os fios da protoboard no arduino, usarei as cores dos fios usadas neste projeto como referência para explanar esta ligação.
A conexão será feita da seguinte forma:
· fio azul (resistor e LED) no pino digital 8;
· fio verde (perna central do potenciômetro) no pino analógico A2;
· fio preto no pino GND;
· fio vermelho no pino 5V.
O potenciômetro foi ligado ao pino analógico pelo fato deste pino poder assumir valores diversos e não apenas 0 e 1 que é o caso do pino digital.
SCRIPT ARDUINO
Após fazer as ligações entre o arduino e a protoboard o seu projeto físico está pronto, faltando agora a programação que irá controlar o arduino nesta tarefa de piscar o LED em intervalos definidos via potenciômetro. Para programar o arduino conecte-o no seu computador usando um cabo USB e execute a IDE.
Segue abaixo o código fonte deste projeto, que é bem simples e fácil de entender. Copie e cole na IDE do arduino.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
	/*
Pisca um LED, onde a velocidade das piscadas é 
controlada por um potenciômetro.
Por Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
int ledAzul = 8;         
int potenciometro = 2;
int tempoDeEspera = 0;
 
void setup() {
  pinMode(ledAzul,OUTPUT);  
}
 
void loop() {
  //Leitura do valor do potenciômetro que é usada como delay
  tempoDeEspera = analogRead(potenciometro);
   
  digitalWrite(ledAzul, HIGH);
  delay(tempoDeEspera);
  digitalWrite(ledAzul, LOW);
  delay(tempoDeEspera);
}
Em resumo este código fonte define que o tempo de espera entre as piscadas do LED será lido do protenciômetro pelo pino analógico A2 e será aplicado utilizando o comando delay. Após copiar o código fonte do projeto para a IDE do arduino compile e posteriormente faça o upload.
RESULTADO
COMENTÁRIOS
Aula 04 - Botão que acende LED-s com efeito
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-botao-acende-leds-com-efeito.html
O QUE VAMOS FAZER?
Acender LED-s com efeito utilizando um botão.
Acender vários LED-s ao se pressionar um botão. Neste projeto um pequeno efeito é gerado, pois foi definido um intervalo de tempo entre o acendimento de cada LED. Este projeto reforça o projeto LED com botão liga desliga que também usa um botão para acender um LED e que tem uma programação mais simples. 
PEÇAS QUE SERÃO UTILIZADAS
 
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	Cabo jumper macho curto
	05
	4
	Cabo jumper macho longo
	07
	5
	Resitor de 100 ohms
	04
	6
	Resitor de 150 ohms
	01
	7
	LED azul
	01
	8
	LED vermelho
	01
	9
	LED verde
	01
	10
	LED amarelo
	01
	12
	Push button
	01
PASSOS DA MONTAGEM DA PROTOBOARD
Segue abaixo o esquema do projeto. A imagem do projeto será a sua referência para a conexão correta dos componentes.
A primeira coisa a fazer é colocar os LED-s e o botão na protoboard. Neste caso as pernas grandes dos LED-s foram conectadas nas colunas 40, 45, 50, 55. As pernas pequenas dos LED-s foram conectadas nas colunas 41, 46, 51, 56. O botão teve suas perninhas conectadas as colunas 33 e 35.
Agora chegou a vez dos resistores. Conecte os quatros resistores de 100 ohms nas colunas que estão conectadas as pernas grandes dos LED-s (colunas 40, 45, 50 e 55) conforme mostra a imagem abaixo. Os resistores dos LED-s devem ter apenas uma de suas pernas conectadas a protoboard, pois a outra perna do resistor será ligada aos fios jumper que serão conectados ao Arduino. Conecte o resistor de 150 ohms na coluna 33 e na linha horizontal negativa da protoboard (linha azul neste caso) como na imagem abaixo.
Conecte os fios jumper pequenos na linha horizontal negativa da protoboard e nas colunas das pernas pequenas dos LED-s, no caso as colunas 41, 46, 51, 56. Conecte a coluna 35, que esta a perninha do botão um fio jumper ligado a linha horizontal positiva da protoboard, linha vermelha neste caso.
Chegou a hora de conectar os fios jumper maiores na protoboard. Para cada perna grande de um LED vai ligar um fio jumper, neste caso o fio azul esta ligado no resistor da coluna 55, o fio vermelho no resistor da coluna 50, o fio verde no resistor da coluna 45 e o fio amarelo no resistor da coluna 40. Na coluna 33 entre o botão e o resistor você vai ligar outro fio jumper, neste caso é o fio jumper roxo. Para finalizar conecte um fio jumper na linha horizontal negativa azul, neste caso foi o fio preto, e outro fio na linha horizontal positiva vermelha, neste caso foi o fio cinza.
Veja na imagem abaixo outro ponto de vista da protoboard com todos os componentes do projeto arduino com um botão que acende os LED-s com efeito. O próximo passo é conectar os fios jumper grandes no arduino.
Abaixo está melhor exemplificado como deve ser feita a ligação entre cada um dos LED-s, resistores e fios jumper.
Os fios jumpers grandes serão conectados da seguinte forma:
· fio azul no pino digital 11;
· fio vermelho no pino digital 10;
· fio verde no pino digital 9;
· fio amarelo no pino digital 8;
· fio roxo no pino digital 2;
· fio preto no pino GND;
· fio cinza no pino 5V.
Os pinos digitais 8, 9, 10, e 11 do arduino serão responsáveis por enviar a energia para acender os LED-s conectados na protoboard. O pino digital 2 será um pino de entrada, que receberá ou não energia, conforme o presionamento do botão, possibilitando a leitura do estado do botão (pressionado ou não pressionado). O pino GND é o terra do arduino, onde estão conectadas todas as perninhas menores dos LED-s. E o pino 5V é o responsável por mandar energia para o botãopossibilitando o controle do seu estado, juntamente com o pino digital 2 do arduino.
SCRIPT ARDUINO
Segue abaixo o código fonte completo e testado deste projeto. Copie e cole ou faça você mesmo a sua versão do programa de controle do Arduino, compile, e posteriormente faça o upload do programa para o Arduino.
Código fonte comentado do projeto arduino com botão que acende LED-s com efeito.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
	/*
Projeto Arduino acendendo com efeito e apagando os LED-s com botão.
Por Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
//Declaração das constantes referentes aos pinos digitais.
const int ledAmarelo = 8;
const int ledVerde = 9;
const int ledVermelho = 10;
const int ledAzul = 11;
const int botao = 2;
 
//Declaração da variável que possuirá os estados do botão.
int estadoBotao = 0;
 
//Método setup, executado uma vez assim que o Arduino é ligado.
void setup() {
  pinMode(ledAmarelo,OUTPUT);  //Definindo pino 8 como saída.
  pinMode(ledVerde,OUTPUT);    //Definindo pino 9 como saída.
  pinMode(ledVermelho,OUTPUT); //Definindo pino 10 como saída.
  pinMode(ledAzul,OUTPUT);     //Definindo pino 11 como saída.
   
  pinMode(botao,INPUT);        //Definindo pino 2 como entrada.
}
 
//Método loop, executado enquanto o Arduino estiver ligado.
void loop() {
  estadoBotao = digitalRead(botao);
   
  if (estadoBotao == HIGH) {
    //Acendendo os LED-s caso o botão esteja pressionado, com 
    //um intervalo de tempo (delay) entre os acendimentos para 
    //criar um pequeno efeito.
    digitalWrite(ledAmarelo,HIGH);
    delay(200);    
    digitalWrite(ledVerde,HIGH);
    delay(200);    
    digitalWrite(ledVermelho,HIGH);
    delay(200);    
    digitalWrite(ledAzul,HIGH);    
    delay(200);
  } else {
    //Apagando os LED-s caso o botão não esteja pressionado.
    digitalWrite(ledAmarelo,LOW);    
    digitalWrite(ledVerde,LOW);
    digitalWrite(ledVermelho,LOW);
    digitalWrite(ledAzul,LOW);
  }
}
RESULTADO
Em resumo, este programa verifica se o botão está pressionado, e caso esteja acende os LED-s. Caso não esteja pressionado apaga os LED-s.
COMENTÁRIOS
Aula 05 - Controlando 8 LED-s com CI74HC595 e fazendo contagem binária
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/controlando-8-leds-com-arduino-usando-ci74HC595-fazendo-uma-contagem-binaria.html
O QUE VAMOS FAZER?
Fazer um contador binário que usa 8 LED-s para formar um byte, onde um LED aceso representa 1 e o LED apagado representa 0, e esse conjunto de 8 LED-s que forma o byte irá representar um número entre 0 e 255, ou melhor, irá contar de 0 até 255 só que em base binária. O componente principal desse projeto é o circuito integrado 74HC595, que vai ser responsável pelo controle dos 8 LED-s. 
O circuito integrado 74HC595 tem a capacidade de transformar uma entrada serial em uma saída paralela de 8 vias, e cada uma dessas 8 vias da saída paralela irá controlar um LED. E o melhor é que para controlar esses 8 LED-s vamos usar apenas 3 pinos do Arduino.
Neste projeto os números decimais entre 0 e 255 vão ser representados de forma binária. Para entender melhor, segue abaixo uma tabela de equivalência entre binários e decimais.
 00000001 (binário) é igual a 1 (decimal);
 00000010 (binário) é igual a 2 (decimal);
 00100001 (binário) é igual a 33 (decimal);
 11111111 (binário) é igual a 255 (decimal).
Lembro que um LED aceso é igual a 1 e um led apagado é igual a 0.
PEÇAS QUE SERÃO UTILIZADAS
 
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	Cabo jumper macho curto
	17
	4
	Cabo jumper macho longo
	10
	5
	Resitor de 1k ohms
	08
	6
	LED azul
	08
	7
	Push button
	01
	8
	Registrador de deslocamento de oito bits 74HC595
	01
PASSOS DA MONTAGEM DA PROTOBOARD
Segue abaixo o esquema do projeto. A imagem do projeto será a sua referência para a conexão correta dos componentes.
Numa visão geral este projeto funcionará da seguinte forma, o arduino avisa ao CI74HC595 que vai enviar dados, o CI se prepara para receber os bits, então o arduino envia 8 bits, um de cada vez, ou seja sequencialmente, o CI apenas armazena cada um dos 8 bits enviados, o arduino envia um sinal ao CI para que ele libere os 8 bits armazenados, e o CI libera os 8 bits de uma vez, ou seja paralelamente. E esses passos se repetem para a formação de cada um dos números entre 0 e 255.
O CI74HC595 é muito bom para controlar muitos LED-s usando poucos pinos do arduino. O projeto do contador binário apresentado neste post é apenas um exemplo entre milhares de projetos de controle de LED-s que podem ser desenvolvidos com o CI74HC595. 
Segue abaixo o datasheet do CI74HC595, para que você conheça cada um dos pinos do mesmo.
Bem, para começar vamos conectar na protoboard os componentes do projeto, que são os oito LED-s, de 5mm neste caso, o CI74HC595, e os oito resistores de 330 ohms, um em cada perna positiva dos LED-s.
Agora conecte os fios jumper entre os componentes da protoboard e entre a protoboard e o Arduino. O esquema detalhado da ligação dos fios jumpers entre os componentes e o Arduino está detalhado logo abaixo.
· pino 1 do 74HC595 ligado ao positivo do 2º LED;
· pino 2 do 74HC595 ligado ao positivo do 3º LED;
· pino 3 do 74HC595 ligado ao positivo do 4º LED;
· pino 4 do 74HC595 ligado ao positivo do 5º LED;
· pino 5 do 74HC595 ligado ao positivo do 6º LED;
· pino 6 do 74HC595 ligado ao positivo do 7º LED;
· pino 7 do 74HC595 ligado ao positivo do 8º LED;
· pino 8 do 74HC595 ligado ao GND do Arduino;
· pino 9 do 74HC595 sem ligação;
· pino 10 do 74HC595 ligado ao 5V do Arduino;
· pino 11 do 74HC595 ligado ao pino digital 2 do Arduino;
· pino 12 do 74HC595 ligado ao pino digital 3 do Arduino;
· pino 13 do 74HC595 ligado ao GND do Arduino;
· pino 14 do 74HC595 ligado ao pino digital 4 do Arduino;
· pino 15 do 74HC595 ligado ao positivo do 1º LED;
· pino 16 do 74HC595 ligado ao 5V do Arduino.
SCRIPT ARDUINO
Depois de concluir o projeto físico, ou seja, a montagem e as conexões entre Arduino e componentes, chegou a hora de programar o Arduino para que ele faça o que queremos. Então usando o cabo USB conecte o Arduino ao seu computador e execute a IDE do Arduino. Segue abaixo o código fonte comentado deste projeto.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
	/*
Projeto Arduino contador binário 
com saída em 8 LED-s que formam 1 byte.
Por Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
//Constantes associadas aos pinos do Arduino
int const clock = 2; //ligado ao clock do 74HC595
int const latch = 3; //ligado ao latch do 74HC595
int const data  = 4; //ligado ao data do 74HC595
 
void setup() {
  //definindo os pinos como de saída
  pinMode(clock,OUTPUT);
  pinMode(latch,OUTPUT);
  pinMode(data,OUTPUT);
}
 
void loop() {
  //Contando de 0 até 255
  for (int i = 0; i <= 255; i++) {
 
    //permite o fluxo dos dados.    
    digitalWrite(latch,LOW); 
        
    for (int x = 0; x <= 7; x++) {
 
      //pronto para receber o bit.
      digitalWrite(clock,LOW); 
       
      if (i & (1 << x)) {
        digitalWrite(data,HIGH);
      } else {
        digitalWrite(data,LOW);
      }
       
      //grava o bit recebido.
      digitalWrite(clock,HIGH); 
    }    
     
    //finaliza o fluxo dos dados e envia os 8 bits.
    digitalWrite(latch,HIGH); 
     
    //tempo de espera entre a exibição de um 
    //número e o outro.
    delay(100); 
  }
}
RESULTADO
Após introduzir o código fonte deste projeto na IDE do Arduino, compile-o e posteriormente faça o upload. 
Aguarde alguns segundos e logo o seu projeto estará em funcionamento, contando de 0 até 255 em basebinária, e além disso o efeito dos LED-s apagando e acendendo durante a contagem é muito legal.
COMENTÁRIOS
Aula 06 - Piscar um LED com efeito fader
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-como-piscar-led-com-efeito-fader.html
O QUE VAMOS FAZER?
Piscar um LED com efeito fader.
Diferente do acendimento normal que acende e apaga de uma vez o LED, o efeito fader faz com que o LED vá acendendo progressivamente, de uma luizinha bem fraca para uma luz forte, e depois apague da mesma forma. 
O segredo deste projeto está na programação e no uso de um pino digital PWM que pode funcionar como um pino analógico. PWM (Pulse-Width Modulation) ou modulação por largura de pulso é um meio para se obter resultados analógicos em um pino digital. 
Alguns pinos digitais do Arduino possuem esse recurso, no caso do Arduino UNO R3 os pinos digitais 3, 5, 6, 9, 10 e 11 são PWM. Impresso na placa Arduino existe uma indicação de quais pinos são PWM. Veja abaixo que os pinos PWM possuem um til ( ~ ) antes do número do pino.
PEÇAS QUE SERÃO UTILIZADAS
 
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	LED azul
	01
	4
	Resitor de 150 ohms
	01
	5
	Cabo jumper macho curto
	01
	6
	Cabo jumper macho longo
	01
PASSOS DA MONTAGEM DA PROTOBOARD
Segue abaixo o esquema do projeto. A imagem do projeto será a sua referência para a conexão correta dos componentes.
O primeiro passo é conectar o LED e o resistor na protoboard. O resistor deve estar ligado a perna positiva do LED.
Conecte o fio azul na perna positiva do led, antes do resistor, e conecte o fio preto na perna negativa do LED. Veja no exemplo abaixo.
No arduino conecte o fio azul no pino digital 10. Observe que o pino digital 10 é um pino PWM, que pode funcionar como um pino analógico. Conecte o fio preto no pino GND.
Logo abaixo está o esquema do projeto pisca LED com efeito fader.
SCRIPT ARDUINO
Segue abaixo o código fonte completo que pisca um LED com efeito fader. Lembrando que como estamos usando um pino digital, no caso o pino 10, que possui recurso PWM vamos tratá-lo como analógico, usando o comando analogWrite (LED, brilho). 
O intervalo/escala de valores para o pino PWM é de 0 até 255, por isso a variável brilho irá assumirá valores entre 0 e 255 durante a execução do programa. E quanto menor for o valor da variável brilho menor será o brilho do LED, e quanto maior for o valor da variável brilho maior será o brilho do LED. Quando brilho for igual a zero o LED será apagado. Quando brilho for igual a 255 o LED brilhará no máximo.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
	/*
Projeto Arduino acendendo led com efeito fader.
Por Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
//Constante que representa o pino onde o positivo do 
//led será ligado.
const int led = 10;
 
//Controladores do efeito de fader
int brilho = 0;
int fader = 5;
boolean acende = true;
boolean apaga = false;
 
//Método setup, executado uma vez ao ligar o Arduino.
void setup() {
  //Definindo o pino led como de saída.
  pinMode(led,OUTPUT);
}
 
//Método loop, executado enquanto o Arduino estiver ligado.
void loop() {  
  analogWrite(led,brilho);  
   
  //Processo de acendimento do led usando o efeito fader.
  if (acende == true) {
    if (brilho < 255) {
      brilho = brilho + fader; //aumentando o brilho do led.
    } else {     
      acende = false;
      apaga = true;
    }
  }
 
  //Processo para apagar o led com efeito fader.  
  if (apaga == true) {
    if (brilho > 0) {
      brilho = brilho - fader; // diminuindo o brilho do led.
    } else {
      acende = true;
      apaga = false;
    }
  }
   
  delay(20);
}
RESULTADO
Compile o programa na IDE do arduino e depois faça o upload e o seu projeto arduino de piscar um LED com efeito fader está concluído.
COMENTÁRIOS
Aula 07 - Sinal de trânsito
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-sinal-de-transito.html
O QUE VAMOS FAZER?
Montar um sinal de trânsito.
PEÇAS QUE SERÃO UTILIZADAS
 
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	LED vermelho
	01
	4
	LED amarelo
	01
	5
	LED verde
	01
	6
	Cabo jumper macho longo
	04
	7
	Resitor de 100 ohms
	03
PASSOS DA MONTAGEM DA PROTOBOARD
Segue abaixo o esquema do projeto. A imagem do projeto será a sua referência para a conexão correta dos componentes.
O primeiro passo é conectar os LED-s na protoboard. Neste caso o LED vermelho foi conectado na coluna 5 (perna menor) e na coluna 6 (perna maior), o LED amarelo foi conectado na coluna 10 (perna menor) e na coluna 11 (perna maior) e o LED verde foi conectado na coluna 15 (perna menor) e na coluna 16 (perna maior).
Conectar a perna de cada um dos resistores de 100 ohms nas colunas 5, 10, e 15 e a outra perna na linha azul (negativo) da sua protoboard.
Conecte os fios jumper nas colunas 6, 11 e 16 da protoboard.
Usando as cores dos fios jumper da imagem abaixo, conecte o fio jumper preto no pino digital GND do Arduino. Conecte o fio amarelo no pino digital 10 do arduino, o laranjado no pino digital 9 do Arduino e o vermelho no pino digital 8 do Arduino.
SCRIPT ARDUINO
Conecte o seu Arduino ao computador usando o cabo USB. Abra a IDE do Arduino, copie e cole na IDE o código fonte do programa.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
	//Projeto Arduino sinal de trânsito
//Por Jota
//www.comofazerascoisas.com.br
 
//Método setup, assim que o arduino é ligado ele 
//é executado, uma vez apenas.
void setup() {
  pinMode(8,OUTPUT);     //define o pino 8 como saída
  pinMode(9,OUTPUT);     //define o pino 9 como saída
  pinMode(10,OUTPUT);    //define o pino 10 como saída
}
//Método loop, é executado enquanto o arduino estiver ligado.
void loop() {
  //Controle do LED verde
  digitalWrite(8,HIGH);  //acende o LED
  delay(4000);           //espera 4 segundos
  digitalWrite(8,LOW);   //apaga o led
   
  //Controle do LED amarelo
  digitalWrite(9,HIGH);  //acende o LED
  delay(2000);           //espera 2 segundos
  digitalWrite(9,LOW);   //apaga o led
   
  //Controle do LED vermelho
  digitalWrite(10,HIGH); //acende o LED
  delay(4000);           //espera 4 segundos
  digitalWrite(10,LOW);  //apaga o led
}
Agora compile o programa, pressionando o botão Verify (botão com um V) e posteriormente faça o upload do programa para o Arduino pressionando o botão Upload (botão com uma seta apontando para a direita).
RESULTADO
Após o upload do programa para o Arduino, o mesmo já começa a se comportar como um sinal de trânsito, acendento e apagando os LED-s de acordo com a ordem e o tempo definido no programa.
COMENTÁRIOS
Aula 08 - Dois sinais de trânsito sincronizados
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/arduino-uno-projeto-sinais-de-transito-sincronizados.html
O QUE VAMOS FAZER?
Montar dois sinais de trânsito sincronizados.
PEÇAS QUE SERÃO UTILIZADAS
 
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	LED vermelho
	02
	4
	LED amarelo
	02
	5
	LED verde
	02
	6
	Cabo jumper macho longo
	07
	7
	Resitor de 100 ohms
	06
PASSOS DA MONTAGEM DA PROTOBOARD
Segue abaixo o esquema do projeto. A imagem do projeto será a sua referência para a conexão correta dos componentes.
Como fazer dois sinais de trânsito sincronizados. Este tipo de sinal controla o fluxo dos veículos em duas pistas distintas que se encontram, muito comum em qualquer cidade. E também você aprenderá alguns aspectos mais interessantes sobre a programação e o projeto físico do Arduino. 
Quando duas pistas se encontram existe a necessidade de controlar o fluxo de veículos entre elas, para evitar colisões.Neste caso existe a necessidade de dois sinais de trânsito sincronizados para controlar este fluxo de veículos. Este sincronismo entre os sinais significa que enquanto um estiver aberto, luz verde, ou em estado de atenção, luz amarela, o outro deve estar fechado e vice versa. Neste projeto vamos contruir um protótipo que faz esse exatamente este controle, simulando dois sinais de trânsito sincronizados.
A primeira coisa a se fazer é conectar os LED-s na protoboard. Cada grupo de três LED-s (verde, amarelo e vermelho) vai representar um sinal de trânsito. As perninhas menores dos LED-s foram conectadas nas colunas 5, 10, 15, 20, 25, 30. As pernas maiores nas colunas 6, 11, 16, 21, 26, 31.
Agora você deve dobrar as perninhas dos resistores de 100 ohms para conectá-los a protoboard. Se você tiver um alicate de bico use-o para fazer as dobras.
Conecte os resistores na protoboard, onde uma ponta do resistor ficará ligada na mesma coluna da perna pequena do LED e a outra ponta na linha negativa (linha horizontal azul neste caso). Logo os resistores serão conectados nas colunas 5, 10, 15, 20, 25, 30 e na linha negativa (linha horizontal azul neste caso).
Conecte agora os fios jumpers nas mesmas colunas das pernas maiores dos LED-s e um fio jumper na linha negativa (linha horizontal azul neste caso). Logo os fios jumpers ficarão nas colunas 6, 11, 16, 21, 26, 31 e um fio jumper na linha negativa.
Conecte os fios jumpers nos pinos digitais do Arduino UNO da seguinte forma:
Fio jumper da linha negativa (azul) no pino GND.
Consideraremos o primeiro sinal o conjunto de três LED-s da direita, e o segundo sinal o conjunto de três LED-s da esquerda.
Primeiro sinal
LED vermelho no pino 5;
LED amarelo no pino 6;
LED verde no pino 7.
Segundo sinal 
LED vermelho no pino 8;
LED amarelo no pino 9;
LED verde no pino 10;
Para começar a programação conecte o Arduino ao seu computador pelo cabo USB, e no computador execute a IDE do Arduino.
SCRIPT ARDUINO
Copie o código fonte abaixo e cole na IDE do Arduino. Este código fonte faz o controle dos dois sinais de trânsito para que eles funcionem de forma sincronizada, como um sinal de trânsito real. No método setup os pinos de 5 a 10 foram definidos como pinos de saída. 
No método loop cada linha está comentada com a funcionalidade de cada comando.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
	/*
Projeto Arduino 2 sinais de trânsito sincronizados
Por Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
//O método setup é executado apenas uma vez, 
//quando o arduino é ligado
void setup() {  
  //definindo os pinos digitais 5, 6, 7, 8, 9 e 10 
  //como pinos de saída.
  pinMode(5,OUTPUT);    
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT);  
  pinMode(8,OUTPUT);
  pinMode(9,OUTPUT);
  pinMode(10,OUTPUT);
}
 
//o método loop é executado repetidamente enquanto o 
//arduino estiver ligado.
void loop() {    
  digitalWrite(5,LOW);  //apaga o led vermelho (sinal 1)
  digitalWrite(7,HIGH); //acende o led verde (sinal 1)
  digitalWrite(8,HIGH); //acende o led vermelho (sinal 2)
  delay(4000);          //espera 4 segundos
  digitalWrite(7,LOW);  //apaga o led verde (sinal 1)        
   
  digitalWrite(6,HIGH); //acende o led amarelo (sinal 1)
  delay(2000);          //espera 2 segundos
  digitalWrite(6,LOW);  //apaga o led amarelo (sinal 1)
   
  digitalWrite(5,HIGH); //acende o led vermelho (sinal 1)
  digitalWrite(8,LOW);  //apaga o led vermelho (sinal 2)
  digitalWrite(10,HIGH); //acende o led verde (sinal 2)
  delay(4000);          //espera 4 segundos
  digitalWrite(10,LOW); //apaga o led verde (sinal 2)
   
  digitalWrite(9,HIGH); //acende o led amarelo (sinal 2)
  delay(2000);          //espera 2 segundos
  digitalWrite(9,LOW);  //apaga o led amarelo (sinal 2)  
}
RESULTADO
Agora vá no menu Sketch e execute a opção Veriy/Compile (ou pressione as teclas CTRL + R) para realizar a compilação do seu programa. E, posteriormente, vá ao menu File e execute a opção Upload (ou pressione as teclas CTRL + U) para fazer o upload do programa para o Arduino. 
Aguarde alguns segundos e seu Arduino vai começar a funcionar igualzinho a dois sinais de trânsito sincronizados.
COMENTÁRIOS
Aula 09 - Controlando LED RGB multicolorido
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-controlando-led-rgb-multicolorido.html
O QUE VAMOS FAZER?
Controlar LED RGB multicolorido.
O LED RGB (Red, Green and Blue) é um tipo de LED, com quatro perninhas, capaz de emitir diversos tipos de cores. Suas cores básicas são vermelho, verde e azul, e a mistura dessas cores pode formar diversas outras cores. 
No projeto, controlando LED RGB é apresentado uma forma simples e prática de controlar o LED RGB para emitir suas cores básicas e também para emitir cores formadas a partir da combinação de outras cores.
PEÇAS QUE SERÃO UTILIZADAS
 Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	LED RGB
	01
	4
	Cabo jumper macho longo
	04
	5
	Resitor de 330 ohms
	03
PASSOS DA MONTAGEM DA PROTOBOARD
Para facilitar o entendimento segue abaixo o esquema dos LED-s RGB com suas respectivas pernas e cores.
Vamos começar conectando o LED RGB na protoboard, como mostrado na imagem abaixo.
· red cathode coluna 29 da protoboard;
· common anode coluna 30 da protoboard;
· green cathode coluna 31 da protoboard;
· blue cathode coluna 32 da protoboard.
Conecte apenas uma perna dos três resistores de 330 ohms nas colunas 29, 31 e 32 da protoboard, onde cada resistor ficará ligado a uma perna de cada cor do led.
Conecte agora os fios jumper na protoboard da seguinte forma:
· fio vermelho direto na perna do resistor da coluna 29;
· fio preto na coluna 30;
· fio verde direto na perna do resistor da coluna 31;
· fio azul direto na perna do resistor da coluna 32;
Os fios jumper vermelho, verde e azul estão conectados respectivamente nas pernas das cores vermelho, verde e azul do led. E lembro que os resistores têm apenas uma perna ligada na protoboard e a outra ligada direto nos fios.
Outro ponto de vista da ligação dos fios jumper na protoboard.
Agora chegou a hora de conectar os fios jumper no Arduino. Neste projeto iremos utilizar os pinos digitais e o pino GND. Os pinos digitais serão responsáveis por fornecer a energia para acendimento de cada cor do LED e o pino GND será o terra do LED.
Os fios deverão ser conectados da seguinte forma no arduino:
· fio azul no pino digital 8 do arduino;
· fio verde no pino digital 9 do arduino;
· fio vermelho no pino digital 10 do arduino;
· e fio preto no pino GND.
SCRIPT ARDUINO
Primeiramente conecte o Arduino ao seu computador utilizando o cabo USB, execute a IDE do Arduino e insira o código fonte do projeto, que esta logo abaixo.
Código fonte do projeto Arduino controlando LED RGB.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
	/*
Projeto Arduino controla led RGB.
Por Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
//Declaração das constantes
const int ledAzul = 10;//refere-se ao pino digital 10.
const int ledVerde = 9; //refere-se ao pino digital 9.
const int ledVermelho = 8; //refere-se ao pino digital 8.
 
//Método setup, executado uma vez ao ligar o Arduino.
void setup() {
  //Definindo os pinos digitais (8, 9, 10) como de saída.
  pinMode(ledAzul,OUTPUT);   
  pinMode(ledVerde,OUTPUT);   
  pinMode(ledVermelho,OUTPUT);    
}
 
//Método loop, executado enquanto o Arduino estiver ligado.
void loop() {   
  //Acendendo cada cor individualmente.  
  digitalWrite(ledAzul,HIGH);
  delay(500);
  digitalWrite(ledAzul,LOW);
   
  digitalWrite(ledVerde,HIGH);
  delay(500);
  digitalWrite(ledVerde,LOW);
   
  digitalWrite(ledVermelho,HIGH);delay(500);
  digitalWrite(ledVermelho,LOW);    
   
  //Misturando as cores do led para obter cores diferentes.
  digitalWrite(ledAzul,HIGH);     
  digitalWrite(ledVerde,HIGH);
  digitalWrite(ledVermelho,HIGH);
  delay(1500);    
  digitalWrite(ledAzul,HIGH);
  digitalWrite(ledVerde,HIGH);
  digitalWrite(ledVermelho,LOW);  
  delay(1500);      
  digitalWrite(ledAzul,LOW);
  digitalWrite(ledVerde,HIGH);
  digitalWrite(ledVermelho,HIGH);
  delay(1500);      
  digitalWrite(ledAzul,HIGH);
  digitalWrite(ledVerde,LOW);
  digitalWrite(ledVermelho,HIGH);
  delay(1500);
}
Após inserir o código fonte do projeto na IDE do Arduino, compile e faça o upload do programa.
RESULTADO
COMENTÁRIOS
Aula 10 - Controlar as cores de um LED RGB com botões
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/arduino-como-controlar-cores-de-um-led-rgb-com-botoes.html
O QUE VAMOS FAZER?
Controlar as cores de um LED RGB com botões.
Como comtrolar cada uma das cores de um LED RGB usando botões. Neste projeto terá a possibilidade de acender separadamente cada cor do LED e também acender várias cores simultaneamente fazendo uma mistura que cria novas cores tudo isso por meio dos botões. 
PEÇAS QUE SERÃO UTILIZADAS
 Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	LED RGB
	01
	4
	Cabo jumper macho longo
	08
	5
	Cabo jumper macho curto
	04
	6
	Resitor de 150 ohms
	03
	7
	Resitor de 330 ohms
	03
	8
	Push button
	03
PASSOS DA MONTAGEM DA PROTOBOARD
Primeiramente conecte o LED RGB na protoboard, que de acordo com o esquema acima, terá a sua perna azul conectada na coluna 53 da protoboard, a verde na coluna 54, o terra na 55, e a vermelha na 56. Conecte também os três botões, onde o primeiro será conectado nas colunas 50 e 48, o segundo nas colunas 45 e 43 e o terceiro nas colunas 40 e 38. Veja a imagem abaixo.
O próximo passo é conectar os resistores na protoboard. No caso do led você irá conectar em cada perna que representa uma cor um resistor de 330 ohms. E nos botões você irá conectar três resistores de 150 ohms, um na coluna 48, um na coluna 43 e outro na coluna 38 e os resistores de 150 ohms também deverão ser conectados na linha horizontal azul (negativa).
Usando os fios jumpers pequenos conecte os botões a linha horizontal vermelha (positivo) nas colunas 50, 45 e 40. Conecte a perna terra do LED, coluna 55, a linha horizontal azul (negativo).
Agora conecte os demais fios jumpers na protoboard da seguinte forma:
· coluna 38 um fio azul entre o resistor e o botão;
· coluna 43 um fio verde entre o resistor e o botão;
· coluna 48 um fio vermelho entre o resistor e o botão;
· coluna 53 um fio azul após o resistor;
· coluna 54 um fio verde após o resistor;
· coluna 56 um fio vermelho após o resistor;
· um fio vermelho na linha vermelha (positivo)
· um fio preto na linha azul (negativo).
A ligação entre o LED, os 3 resistores e os fios jumpers vermelho, verde e azul seria como mostrado na imagem abaixo.
Conecte os fios da protoboard no Arduino da seguinte forma:
· pino digital 2 fio azul do botão;
· pino digital 3 fio verde do botão;
· pino digital 4 fio vermelho do botão;
· pino digital 8 fio azul do led, fio ligado direto no resistor;
· pino digital 9 fio verde do led, fio ligado direto no resistor;
· pino digital 10 fio vermelho do led, fio ligado direto no resistor;
· pino 5V fio vermelho (positivo);
· pino GND fio preto (negativo).
A perna do resistor do led que vai ligada ao fio dos pinos digitais não é conectada na coluna da protoboard e sim conectada direto no fio.
Após conectar todos os fios, seu projeto físico para controlar as cores de um led RGB pelos botões está pronto. Agora o próximo passo é conectar o Arduino ao seu computador por meio do cabo USB para iniciar a programação das funcionalidades desejadas.
SCRIPT ARDUINO
Segue abaixo o código fonte do projeto.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
	/*
Projeto Arduino controla LED RGB com botões.
Por Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
//Declaração das constantes
const int ledAzul = 8;      //ledAzul refere-se ao pino digital 8.
const int ledVerde = 9;     //ledVerde refere-se ao pino digital 9.
const int ledVermelho = 10; //ledVermelho refere-se ao pino digital 10.
 
const int botaoAzul = 2;     //botaoAzul refere-se ao pino digital 2.
const int botaoVerde = 3;    //botaoVerde refere-se ao pino digital 3.
const int botaoVermelho = 4; //botaoVermelho refere-se ao pino digital 4.
 
//Variáveis que conterão os estados dos botões (pressionados ou não).
int estadoBotaoAzul;
int estadoBotaoVerde;
int estadoBotaoVermelho;
 
//Método setup, executado uma vez ao ligar o Arduino.
void setup() {
  //Definindo os pinos digitais (8, 9, 10) como de saída.
  pinMode(ledAzul,OUTPUT);   
  pinMode(ledVerde,OUTPUT);   
  pinMode(ledVermelho,OUTPUT);    
   
  //Definindo os pinos digitais (2, 3, 4) como de entrada.
  pinMode(botaoAzul,INPUT);
  pinMode(botaoVerde,INPUT);
  pinMode(botaoVermelho,INPUT);
}
 
//Método loop, executado enquanto o Arduino estiver ligado.
void loop() {   
 
  //Lendo o estado dos botões pelos pinos digitais.
  estadoBotaoAzul = digitalRead(botaoAzul);
  estadoBotaoVerde = digitalRead(botaoVerde);
  estadoBotaoVermelho = digitalRead(botaoVermelho);
     
  //Acendendo o led RGB conforme os botões pressionados.
  //Tratando a cor azul
  if (estadoBotaoAzul == HIGH) {
    digitalWrite(ledAzul,HIGH);
  } else {    
    digitalWrite(ledAzul,LOW);
  }
   
  //Tratando a cor verde
  if (estadoBotaoVerde == HIGH) {
    digitalWrite(ledVerde,HIGH);
  } else {
    digitalWrite(ledVerde,LOW);
  }
   
  //Tratando a cor vermelha
  if (estadoBotaoVermelho == HIGH) {
    digitalWrite(ledVermelho,HIGH);
  } else {
    digitalWrite(ledVermelho,LOW);        
  }
}
Após inserir o código fonte na IDE do Arduino compile e faça o upload.
RESULTADO
Pronto! O projeto como controlar as cores de um LED RGB usando botões está concluído. 
Se você pressionar cada botão individualmente o LED acenderá a respectiva cor. 
Se você pressionar mais de um botão de uma vez ocorrerá uma mistura de cores que formará uma nova cor. 
COMENTÁRIOS
Aula 11 - Sensor de luz LDR com saída de leitura em LED-s
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-sensor-de-luz-ldr-com-leds.html
O QUE VAMOS FAZER?
Montar um sensor de luz LDR com saída de leitura em LED-s.
Este projeto faz a leitura da iluminação de um ambiente, pelo LDR (Light Dependent Resistor), e exibe o resultado da leitura do sensor nos LED-s. 
Funciona da seguinte forma, caso o ambiente esteja bem iluminado o LED verde acenderá, caso a iluminação do ambiente for mediana o LED amarelo acenderá e caso a iluminação esteja ruim o LED vermelho acenderá, e você também poderá ver os valores lidos no LDR no serial monitor da IDE do Arduino. 
Você pode alterar a leitura da iluminação aproximando ou afastando a mão do sensor LDR. 
Os intervalos de valores que representam a intensidade da iluminação são fixos e estão definidos dentro do programa que se encontra abaixo. Lembro que estes valores podem ser alterados conforme sua necessidade.
PEÇAS QUE SERÃO UTILIZADAS
 
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	LED vermelho
	01
	4
	LED verde
	01
	5
	LED amarelo
	01
	6
	Cabo jumper macho curto
	07
	7
	Cabo jumper macho longo
	06
	8
	Resitor de 10k ohms
	01
	9
	Resitor de 100 ohms
	03
	10
	Sensor de luz LDR (Light Dependent Resistor), ou seja, fotoresistor
	01
PASSOS DA MONTAGEM DA PROTOBOARD
Conecte o sensor LDR com uma de suas pernas no 5V do Arduino e a outra perna no pino analógico A0. 
Conecte o resistor de 10K ohms com uma perna entreo sensor LDR e o fio jumper do pino digital A0 e a outra perna no pino GND.
Conecte os três LED-s na protoboard e na perna maior (positivo) de cada LED conecte um resistor de 100 ohms e, após o resistor, conecte um fio jumper. 
Ligue a perna menor (negativo) de cada um dos LED-s no GND do Arduino. 
Os fios positivos dos LED-s ficarão nos seguintes pinos digitais do Arduino:
· fio do LED vermelho no pino digital 10;
· fio do LED amarelo no pino digital 9;
· fio do LED verde no pino digital 8.
Veja abaixo as ligações dos fios jumpers no Arduino.
SCRIPT ARDUINO
Abra a IDE do Arduino, conecte ele ao computador pelo cabo USB, insira o código fonte na IDE compile e faça o upload do programa. 
Lembro que os valore lidos no sensor LDR poderão ser visualizados no Serial Monitor da IDE. 
Para acessar o Serial Monitor pressione as teclas Ctrl + Shift + M.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
	/*
Projeto Arduino sensor de luz com saida de LED-s.
Por Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
int sensor = 0; //Pino analógico em que o sensor está conectado.
int valorSensor = 0; //Usada para ler o valor do sensor em tempo real.
 
const int ledVerde = 8;
const int ledAmarelo = 9;
const int ledVermelho = 10;
 
//Função setup, executado uma vez ao ligar o Arduino.
void setup(){
 //Ativando o serial monitor que exibirá os valores lidos no sensor.
 Serial.begin(9600);
 
 //Definindo pinos digitais dos LED-s como de saída.
 pinMode(ledVerde,OUTPUT);
 pinMode(ledAmarelo,OUTPUT);
 pinMode(ledVermelho,OUTPUT);
}
 
//Função loop, executado enquanto o Arduino estiver ligado.
void loop(){
 
 //Lendo o valor do sensor.
 int valorSensor = analogRead(sensor);
 
 
 //Valores da luminosidade podem ser alterados conforme necessidade. 
 
 //Luminosidade baixa.
 if (valorSensor < 300) {
 apagaLeds();
 digitalWrite(ledVermelho,HIGH);
 }
 
 //Luminosidade média.
 if (valorSensor >= 300 && valorSensor <= 500) {
 apagaLeds();
 digitalWrite(ledAmarelo,HIGH);
 }
 
 //Luminosidade alta.
 if (valorSensor > 500) {
 apagaLeds();
 digitalWrite(ledVerde,HIGH);
 }
 
 //Exibindo o valor do sensor no serial monitor.
 Serial.println(valorSensor);
 
 delay(50); 
}
 
//Função criada para apagar todos os LED-s de uma vez.
void apagaLeds() {
 digitalWrite(ledVerde,LOW);
 digitalWrite(ledAmarelo,LOW);
 digitalWrite(ledVermelho,LOW);
}
RESULTADO
Segue abaixo o esquema detalhado do projeto Arduino com sensor de luz LDR com saída de leitura em LED-s.
COMENTÁRIOS
Aula 12 - Emitir sons com o buzzer
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-como-emitir-sons-com-o-buzzer.html
O QUE VAMOS FAZER?
Emitir sons em uma determinada frequência e intervalo de tempo usando um buzzer. 
O buzzer é um pequeno alto-falante capaz de emitir sons em diversas frequências e é normalmente é usado em projetos que necessitam de avisos sonoros, relógios com alarme e até para reproduzir músicas.
PEÇAS QUE SERÃO UTILIZADAS
 
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	Cabo jumper macho longo
	02
	4
	Resitor de 100 ohms
	01
	5
	Buzzer de 5 volts
	01
PASSOS DA MONTAGEM DA PROTOBOARD
O primeiro passo é conectar os componentes e os fios na protoboard. 
Ligue uma perna do resistor na perna positiva do buzzer. 
Ligue o fio preto na perna negativa do buzzer e ligue o fio vermelho na outra perna do resistor. Veja a imagem abaixo.
No Arduino ligue o fio vermelho no pino digital 10 e o fio preto no pino GND.
Projeto físico concluído, provavelmente o seu ficará parecido ou igual ao da imagem abaixo. Agora chegou a hora de programar o seu Arduino. 
Conecte o Arduino ao computador com o cabo USB e execute a IDE do Arduino.
SCRIPT ARDUINO
Segue abaixo o código fonte do projeto com buzzer que faz o mesmo emitir um som de 1500 hz mum intervalor de meio em meio segundo. 
A emissão do som se dá por meio da função tone, onde o segundo parâmetro informa a frequência do som que quer emitir, que neste caso e 1500.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
	/*
Projeto Arduino beep com buzzer.
Por Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
//Constante que representa o pino onde o positivo 
//do buzzer será ligado.
const int buzzer = 10;
 
//Método setup, executado uma vez ao ligar o Arduino.
void setup() {
  //Definindo o pino buzzer como de saída.
  pinMode(buzzer,OUTPUT);
}
 
//Método loop, executado enquanto o Arduino estiver ligado.
void loop() {  
  //Ligando o buzzer com uma frequencia de 1500 hz.
  tone(buzzer,1500);   
  delay(500);
   
  //Desligando o buzzer.
  noTone(buzzer);
  delay(500);  
}
RESULTADO
Após inserir o código fonte na IDE do Arduino compile o programa e faça o upload. Pronto o buzzer vai começar a dar um beep nos intervalos de tempo e na frequência programada. 
Se você for bom em frequências sonoras poderá tocar até uma música usando o Arduino.
E para finalizar segue abaixo o esquema do projeto Arduino com buzzer.
COMENTÁRIOS
Aula 13 - Controlando dois servomotores com potenciômetros
CRÉDITOS DA AULA
https://www.tinkercad.com/things/2TBggrERoFG-copy-of-68-arduino-pan-tilt-joystick/editel?tenant=circuits
O QUE VAMOS FAZER?
Controlar servomotores com potenciômetro.
Controlar o sentido da rotação de dois servomoteres, fazendo com que ele gire conforme a posição do potenciômetro.
PEÇAS QUE SERÃO UTILIZADAS
 
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	Cabo jumper macho longo
	08
	4
	Cabo jumper macho curto
	08
	5
	Potenciômetro
	02
	6
	Micro servo
	02
PASSOS DA MONTAGEM DA PROTOBOARD
SCRIPT ARDUINO
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
	// www.ProgettiArduino.com
// Pan tilt controllato do joystick
#include <Servo.h> 
int ServoHorizontalPin = 3; 
int ServoVerticalPin = 4; 
int HorizontalPotPin = A0; 
int VerticalPotPin = A1; 
int ServoH_Min = 0; 
int ServoH_Max = 180; 
int ServoV_Min = 0; 
int ServoV_Max = 180; 
Servo HorizontalServo; 
Servo VerticalServo; 
int HorizontalPotValue; 
int HorizontalServoPosition; 
int VerticalPotValue; 
int VerticalServoPosition; 
void setup() 
{
 HorizontalServo.attach(ServoHorizontalPin); 
 VerticalServo.attach(ServoVerticalPin); 
}
void loop() 
{
 HorizontalPotValue = analogRead(HorizontalPotPin); 
 VerticalPotValue = analogRead(VerticalPotPin); 
 HorizontalServoPosition = map(HorizontalPotValue, 0, 1023, ServoH_Min , ServoH_Max); 
 VerticalServoPosition = map(VerticalPotValue, 0, 1023, ServoH_Min , ServoH_Max); 
 HorizontalServo.write(HorizontalServoPosition); 
 VerticalServo.write(VerticalServoPosition); 
 delay(20); 
}
RESULTADO
COMENTÁRIOS
Aula 14 - Controlando um servomotor com potenciômetro
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/controlando-um-servomotor-com-potenciometro-no-arduino.html
O QUE VAMOS FAZER?
Controlar um servomotor com um potenciômetro. 
Ao girar o potenciômetro o braço do servomotor responderá fazendo um movimento proporcional a velocidade e ao sentido do giro do potenciômetro. O Arduino usado neste projeto foi um Arduino UNO R3, mas qualquer outra versão poderia ser utilizada. 
O servomotores são componentes muito importantes no mundo da robótica, da mecatrônica, e muito usado também no mundo dos hobbys. Na robótica os servomotores são responsáveis por movimentar braços, pernas e mãos de robôs. No automodelismo os servomotores são usados para virar as rodinhasdianteiras dos carrinhos, para esquerda e direita. No aeromodelismo são usados para controlar os flaps das asas dos aviões. 
Os servomotores são componentes chave em muitos projetos, por isso vamos ensinar o conceito básico de controle de um servomotor, usando um Arduino. 
PEÇAS QUE SERÃO UTILIZADAS
 
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	Cabo jumper macho longo
	06
	4
	Cabo jumper macho curto
	02
	5
	Potenciômetro
	01
	6
	Micro servomotor
	01
PASSOS DA MONTAGEM DA PROTOBOARD
O servomotor usado neste projeto foi um TG9e da Turnigy, um microservo que possui um ótimo custo benefício.
Começe conectando o potenciômetro na protoboard e depois conecte os fios jumper entre os componentes da protoboard, o servomotor e o Arduino. 
Para fazer estas conexões corretamente veja o esquema do projeto.
SCRIPT ARDUINO
Agora vamos programar o Arduino para que ele se comporte como desejamos. Então conecte o Arduino ao seu computador com o cabo USB, abra a IDE do Arduino e programe o Arduino. 
Segue abaixo o código fonte deste projeto todo comentado para facilitar o entendimento de cada parte do código.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
	/*
Projeto Arduino controlando um servomotor com potenciômetro
Por Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
//incluindo biblioteca para controle do servomotor
#include "Servo.h"
  
//Criando um objeto da classe Servo
Servo servoMotorObj;  
  
//pino analógico onde o potenciômetro está conectado
int const potenciometroPin = 0;  
 
//pino digital associado ao controle do servomotor
int const servoMotorPin    = 3;  
 
//variável usada para armazenar o valor lido no potenciômetro
int valPotenciometro;            
  
void setup() { 
  //associando o pino digital ao objeto da classe Servo
  servoMotorObj.attach(servoMotorPin); 
} 
  
void loop() 
{ 
  //lendo o valor do potenciômetro (intervalo entre 0 e 1023)
  valPotenciometro = analogRead(potenciometroPin); 
 
  //mapeando o valor para a escala do servo (entre 0 e 180)
  valPotenciometro = map(valPotenciometro, 0, 1023, 0, 180); 
 
  //definindo o valor/posição do servomotor
  servoMotorObj.write(valPotenciometro); 
  delay(15);   
}
RESULTADO
Após introduzir o código fonte na IDE do Arduino, compile-o e depois faça o upload, aguarde alguns instantes para que a transferência do programa seja realizada. 
Vire o potenciômetro para um lado e veja que o braço do servomotor vai se mover.
COMENTÁRIOS
Aula 15 - Controlar a velocidade de um motor CC com potenciômetro
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/controlando-a-velocidade-de-um-motor-cc-no-arduino-com-potenciometro.html
O QUE VAMOS FAZER?
Controlar a velocidade de um motor CC com potenciômetro.
Motor CC, ou corrente contínua, terá a sua velocidade controlada por um potenciômetro giratório. A medida que gira potenciômetro para o lado esquerdo o motor CC vai aumentando progressivamente a velocidade e quando você gira para a direita vai diminuindo a velocidade até parar. 
Este projeto é um excelente exemplo de manipulação de um motor CC e o primeiro passo para quem deseja trabalhar com projetos Arduino voltados para a robótica, pois motores CC, motores de passo e servo motores são peças chave na construção de robos, carrinhos robóticos, braços robóticos etc. 
PEÇAS QUE SERÃO UTILIZADAS
 
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	Cabo jumper macho longo
	08
	4
	Potenciômetro
	01
	5
	Motor CC de 6v
	01
	6
	Pilha pequena do tipo AA
	04
	7
	Suporte para quatro pilhas
	01
	8
	Diodo 1N4001
	01
	9
	Transistor TIP120
	01
PASSOS DA MONTAGEM DA PROTOBOARD
Segue abaixo o esquema do projeto. A imagem do projeto será a sua referência para a conexão correta dos componentes.
O primeiro passo é conectar os componentes na protoboard. Neste caso o diodo, o TIP120 e o potenciômetro. Quero dar uma atenção especial para o diodo, que neste projeto tem a função de proteger nosso Arduino contra a corrente e tensão inversa gerada pelo motor CC. 
Esteja também atento a posição do diodo observando a barrinha branca em um dos seus polos e seu posicionamento no projeto, conforme nostrado na imagem do esquema do projeto. Isso evitará danos ao Arduino.
Posteriormente, conete os fios jumper na protoboard.
Conecte os fios jumper no Arduino obedecendo o esquema do projeto.
Conecte o motor e as pilhas na protoboard. Apesar do Arduino possuir uma saida de 5V o motor não será ligado diretamente nele pelo fato do Arduino não ter capacidade de fornecer corrente suficiente para o funcionamento do motor. 
Por isso vamos usar pilhas comuns do tipo AA para alimentar o nosso motor CC. Usei um palito de picolé no motor CC para facilitar a visualização da rotação do motor. 
SCRIPT ARDUINO
Conecte-o no seu computador pelo cabo USB e abra a IDE do Arduino. O código fonte comentado deste projeto segue abaixo.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
	/*
Projeto Arduino controlando um motor CC.
Por Jota
----------------------------------------
--=<| www.ComoFazerAsCoisas.com.br |>=--
----------------------------------------
*/
 
//pino analógico onde o potenciômetro está conectado.
int const potenciometro = 0; 
 
//pino digital onde o TIP120 está conectado.
int const transistor = 9;    
 
//armazenará o valor lido no potenciômetro.
int valPotenciometro = 0;    
 
//função setup é executada uma vez quando o Arduino é ligado.
void setup() {
 
  //definindo o pino digital 9 como de saída.
  pinMode(transistor, OUTPUT); 
}
 
//Função loop é executada repetidamente enquanto 
//o Arduino estiver ligado.
void loop() {    
   
  //lendo o valor do potenciômetro (0 até 1023) e 
  //dividindo por 4 para obter um valor entre 0 e 255
  //que são valores adequados para a base do TIP120.
  valPotenciometro = analogRead(potenciometro) / 4;
   
  //atribuindo o valor lido no potenciômetro 
  //a base do TIP120.  
  analogWrite(transistor, valPotenciometro); 
} 
RESULTADO
Depois de inserir o código fonte na IDE, agora é só compilar e fazer o upload do mesmo para o Arduino. Aguarde alguns instantes para a conclusão do upload e logo poderá girar o potenciômetro para ambos os lados e ver o seu motor CC aumentar e diminuir a velocidade de rotação.
COMENTÁRIOS
Aula 16 - Motor CC com controle de velocidade, LED-s medidores de potência e buzzer para alerta de potência máxima
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/motor-cc-no-arduino-com-controle-de-velocidade-e-leds-medidores-de-potencia.html
O QUE VAMOS FAZER?
Montar um motor CC com controle de velocidade, LED-s medidores de potência e buzzer para alerta de potência máxima.
Neste projeto Arduino vamos desenvolver um controle de velocidade de rotação para um motor de corrente contínua e além disso vamos introduzir um medidor da potência aplicada usando LED-s e e buzzer para alerta de potência máxima. 
Este projeto Arduino funciona assim, a medida que o potenciômetro é girado para um lado a velocidade de rotação do motor CC aumenta e os LED-s vão acendendo de acordo com a potência aplicada, se o motor estiver girando no máximo todos os LED-s ficarão acesos e, quando a luz vermelha acender, a buzina vai soar para indicar a potência máxima foi atingida e vai parar de soar quando a luz vermelha apagar. 
PEÇAS QUE SERÃO UTILIZADAS
Para fazer este projeto, serão necessários os seguintes componentes:
	Nr O
	Material
	Qtde
	1
	Arduino UNO R3
	01
	2
	Protoboard
	01
	3
	Cabo jumper macho longo
	08
	4
	Potenciômetro
	01
	5
	Motor CC de 6v
	01
	6
	Pilha pequena do tipo AA
	04
	7
	Suporte para quatro pilhas
	01
	8
	Diodo 1N4007
	01
	9
	Transistor TIP120
	01
	10
	LED vermelho
	01
	11
	LED verde
	01
	12
	LED