Quando abrir o Arduino IDE, verá que existe linhas já escritas,

elas se estão lá para auxiliarem você.

//////////////////////////////////////////////////////////////////
void setup()
{
pinMode(13, OUTPUT); // OUTPUT=saída | IMPUT=entrada Usará a
pino 13 como saída
}

void loop()
{
digitalWrite(13, HIGH); // HIGH=ligado(5v) | LOW=desligada(0v).
O pino digital 13 estará ligado
}
//////////////////////////////////////////////////////////////////

O "//" significa que é um comentário. // “void” significa que é

uma função.
No "void setup()" você vai escrever as configurações que serão
executadas uma vez. Que no caso, vamos escrever após a linha "{"
"pinMode" se refere ao modo do pino, ou seja, como o pino estará.

No "void loop()" você vai escrever as configurações que serão

repetidas. Que no caso, vamos escrever após a linha "{"
"digitalWrite" O que será "feito/escrito" na porta digital

Se você utilizar o parâmetro “delay(nº_em_milézimo);”, seu código

esperará o tempo desejado e depois seguirá para a próxima
linha. // É usada em “void loop()”. E lembre-se de pular uma linha
depois de outro comando que já fez. Ex.:
void loop()
{
digitalWrite(13, HIGH);
delay(2000); // 2000=2s
}
“protoboard/placa de ensaio”

1. Nem todas terão a marcação de + e -;

2. A linha que tem o + indica que toda linha horizontal se trata
do +. O mesmo vale para o -;
3. Os pinos do meio indica que na linha vertical há uma
comunicação com ele. Ex.: Existe uma comunicação de “a” até
“e” e existe outra comunicação independente que é da “f” até
“j”;
4. Para alimentá-las é necessário uma bateria de 9v/3v ou um
arduino.
5. Conecte a parte positiva da bateria com a parte positiva da
placa de ensaio e a parte negativa da bateria com a negativa
da bateria. // Lembrando que isso é em apenas um dos pinos de
uma linha horizontal de positivo ou negativo.
6. No arduino a parte positiva para se conectar no protoboard
fica no pino de 5v/3.3v do arduino e a negativa no pino GND
do mesmo;
7. Para energizar a outra linha horizontal de positivo e
negativo. Conecte um fio em um pino de uma linha que receberá
a carga à um pino de outra linha que não estará conectada
diretamente a bateria. // Esse processo deverá ser feito no +
e -;
Para acender um lede, é necessário um resistor que deve estar
conectado na parte negativa do pino e na parte negativa do
protoboard ou estar conectado na parte positiva do pino e na parte
positiva do protoboard. Pode virar o resistor, pois não tem
polaridade.

Siga alguns projetos:

LEI DE OHM(Ω)

1. Tensão(v)
2. Corrente(A)
3. Resistência(omh)

• Os ledes convencionais possui 20mA → 20/1000A;

• E possuem 2v;

Para saber a resistência necessária que o resistor deve ter, use a

fórmula:
V = I*R // V=Volts de quem proverá a tensão – a que o componente
necessita | I=Corrente em A | R=Resistência

DESAFIO: Um lede de 20mA vai ser conectado em um arduino no pino

5v. Qual deverá ser a resistência do resistor?
V=5v-2v=3v I=20mA=20/1000A=0,02A R=?
3 = 0,02*R → R = 3/0,02 → R = 150omh
// Se não conseguir encontrar um Resistor de 150omh, pegue um que
seja mais aproximado. Ex.: Usar um resistor de 220omh.

NAME SYMBOL CONVERSION EXAMPLE

milli-ohm mΩ 1mΩ = 10-3Ω R0 = 10mΩ
ohm Ω - R1 = 10Ω
kilo-ohm kΩ 1kΩ = 103Ω R2 = 2kΩ
mega-ohm MΩ 1MΩ = 106Ω R3 = 5MΩ
ACENDENDO UM LED POR UMA DOS PINOS DO ARDUINO

1. Declare as variáveis indicando o que armazenarão. Ex.: “int

led=10;” // Ele criará uma variável do tipo inteiro que
armazenará o 10. Ex. Na prática:
/////////////////////////////////////////////////////////////
int led=9;
void setup()
{
pinMode(led, OUTPUT);
}

void loop()
{
digitalWrite(led, HIGH);
delay(2000);
digitalWrite(led, LOW);
delay(2000);
}

Veja o projeto:
PARA ACENDER MAIS DE UM LEDE:

• O “#define” servem para criar constantes, ou seja, não serão

mudadas ao decorrer do código, e como “led1”, “led2” e
“led3”, armazenarão apenas o nº do pino, seria um desperdício
de memória transformá-las em variável.
• Para que a função “loop” não ficasse muito grande, foi
necessário criar uma função para cada cor, e depois de
criadas seriam citadas na função loop“void loop()”
• O “int tmp” se refere ao tempo, que no caso armazenará um
número inteiro. O local onde foi posta foi proposital para
mostrar no “void loop”
• O “delay(tmp*1000)” Indica que o número que irei digitar será
multiplicado por 1000, foi deixado assim propositalmente,
pois o “delay” mostra em milésimos e 1000 milésimos = 1
segundo.
• Quando digito “verde(7);” na função loop por exemplo, indica
que estou “chamando” a função/void verde por 7 segundos. Que
no caso, 7 será o valor da variável “tmp” e será multiplicada
por 1000.

VEJA O EXEMPLO DE UM CÓDIGO FUNCIONAL, LOGO ABAIXO:

//////////////////////////////////////////////////////////////////
#define led_verde 9
#define led_amarelo 10
#define led_vermelho 8

void setup()
{
pinMode(led_verde, OUTPUT);
pinMode(led_amarelo, OUTPUT);
pinMode(led_vermelho, OUTPUT);
}

void verde(int tmp)

{
digitalWrite(led_verde, HIGH);
digitalWrite(led_amarelo, LOW);
digitalWrite(led_vermelho, LOW);
delay(tmp*1000);
}

void amarelo(int tmp)

{
digitalWrite(led_verde, LOW);
digitalWrite(led_amarelo, HIGH);
digitalWrite(led_vermelho, LOW);
delay(tmp*1000);
}

void vermelho(int tmp)

{
digitalWrite(led_verde, LOW);
digitalWrite(led_amarelo, LOW);
digitalWrite(led_vermelho, HIGH);
delay(tmp*1000);
}

void loop()
{
verde(7);
amarelo(3);
vermelho(7);
}
//////////////////////////////////////////////////////////////////
PARA FAZER UM LED AUMENTAR OU DIMINUIR GRADUALMENTE:
//////////////////////////////////////////////////////////////////
#define led 3
#define maximo 16 // Como possui 8 bits, pode ser até 255
#define minimo 0 // O 0 é o mínimo
#define tmp 100 // tmp será 100 milésimos

void setup()
{
pinMode(led, OUTPUT);
}

void loop()
{
for(int i=minimo;i<maximo;i++) // Criou-se a variável i que será igual
a minimo e se i for menor que maximo, sempre aumentar_o_i(i++)
{
analogWrite(led, i); // analog para ser em modo analógico

delay(tmp);
}
for(int i=maximo;i>minimo;i--) // Criou-se a variável i que será igual
a maximo e se i for maior que minimo, sempre diminuir_o_i(i--)
{
analogWrite(led, i);
delay(tmp);
}
}
//////////////////////////////////////////////////////////////////

PUSH-BUTTON
Só terá sua eficácia se conectar o fio em forma de diagonal ou em
formato de linha horizontal, pois se conectado em formato de linha
vertical, será como se não tivesse um push-button e se.
VEJA A IMAGEM ABAIXO:
PARA ACENDER UM LEDE USANDO O PUSHBUTTON
//////////////////////////////////////////////////////////////////

#define led 4
#define btn 3 // A porta em que o nosso botão se encontra.

void setup()
{
pinMode(led, OUTPUT);
pinMode(btn, INPUT);
}

void loop()
{
if(digitalRead(btn)==HIGH) // Lerá o btn e se(if) estiver ligado(==)
{
digitalWrite(led, HIGH); // O led ligará
}
else // Caso contrário(else)
{
digitalWrite(led, LOW); // O led desligará
}
}

//////////////////////////////////////////////////////////////////
LED RGB

O módulo RGB não precisa do resistor, pois o mesmo já está

integrada. No módulo mostra 4 pinos e casa uma tem uma função, o
primeiro é o terra(GND), o segundo: R(red), o terceiro: G(gren) e
o quarto: B(blue).
PARA UM MÓDULO RGB PELO ARDUINO

//////////////////////////////////////////////////////////////////

#define ledG 2
#define ledB 3
#define ledR 4
#define botao 5
#define maximo 3 // Será o máximo de cores

int btnclicado=0;
int btnliberado=0;
int ciclo=0; // Para definir o ciclo da cor

void verde(){ // Função para o led verde

digitalWrite(ledG, 1); // O '1' também significa 'HIGH'
digitalWrite(ledB, 0); // O '0' também significa 'LOW'
digitalWrite(ledR, 0);
}
void azul(){ // Função para o led azul
digitalWrite(ledG, 0);
digitalWrite(ledB, 1);
digitalWrite(ledR, 0);
}
void vermelho(){ // Função para o led vermelho
digitalWrite(ledG, 0);
digitalWrite(ledB, 0);
digitalWrite(ledR, 1);
}
void trocaLed(){
if(ciclo==0){
vermelho();
}else if(ciclo==1){
verde();
}else if(ciclo==2){
azul();
 }
ciclo++; // Enclementa o ciclo em 1
if(ciclo>maximo-1){
ciclo=0;
}
}
void verificaBtn(){
if(digitalRead(botao)==HIGH){
btnclicado=1;
btnliberado=0;
}else{
btnliberado=0;
}
if((btnclicado==1) and (btnliberado==1)){
btnclicado=0;
btnliberado=0;
trocaLed();
}
}

void setup()
{
pinMode(ledR, OUTPUT);
pinMode(ledG, OUTPUT);
pinMode(ledB, OUTPUT);
pinMode(botao, INPUT);
}

void loop()
{
verificaBtn();
}

//////////////////////////////////////////////////////////////////
CLASSES(class) NO C++
Ex.:

#define ledR 2
#define ledG 4
#define ledB 3
#define botao 7
#define botao 8

class Btn{ // Criei uma classe para ‘Btn’

public: // Separe o que será público e o que será privado
int btnclicado,btnliberado,pino;
Btn(int p){
pino=p;
btnclicado=btnliberado=0;
}
bool press(){ // ‘bool’ será uma coisa ou outra
if(digitalRead(pino)==HIGH){
btnclicado=1;
btnliberado=0;
}else{
btnliberado=1;
}
if((btnclicado==1)and(btnliberado=1)){
btnclicado=0;
btnliberado=0;
return true;
}else{
return false;
}
}
};

Btn btn(botao); // Criei um objeto ‘btn’, da classe “Btn” e informei em que

pino está o meu botão físico. Se tivesse outro botão era só criar outra linha e
criar btn2 e informar em que pino está
// Vamos criar agora a classe das cores do led

class Cor{
public:
int pinoR,pinoG,pinoB,ciclo,maximo;
Cor(int pr,int pg,int pb):pinoR(pr),pinoG(pg),pinoB(pb){ //
Lista de inicialização
ciclo=0;
maximo=3;
}
void trocaLed(){
if(ciclo==0){
corLed(1,0,0);
}else if(ciclo==1){
corLed(0,1,0);
}else if(ciclo==2){
corLed(0,0,1);
}
ciclo++;
if(ciclo>maximo-1){
ciclo=0;
}
}
private:
void corLed(int r,int g,int b){
digitalWrite(pinoR, r);
digitalWrite(pinoG, g);
digitalWrite(pinoB, b);
};

Btn btn2(botao2);
Cor cor(ledR,ledG,ledB);

void setup(){
digitalMode(botao, INPUT);
 digitalMode(ledR, OUTPUT);
digitalMode(ledG, OUTPUT);
digitalMode(ledB, OUTPUT);
}

void loop(){
if(btn.press()){
cor.trocaLed();
}
}
// Objetos são instâncias das classes
DETECTOR DE INCÊNDIO NO TINKERCAD

Piezo

Sensor de gás
Geralmente é vendido o módulo
do sensor de gás
PORTA ANALÓGICA NO ARDUINO:
• Todas as portas analógicas do arduino são de entrada;

Variação = Volts

•
• As portas PWM tem 256 variações, e usa consome (0v a 5v);
• As portas Digital 0 ou 1, e usa (0v ou 5v);
• Analógica 0 a 1023 (0v a 5v);
• Se liga neste projeto:

•
• O “círculo” azul na placa de ensaio é um potenciômetro, o
pino do meio é o Limpador, que é conectado em uma das portas
analógicas do arduino, os pinos do meios são os terminais que
você pode conectar o GND(negativo) ou 5v(positivo), você
alterar a ordem que mostra na imagem, porém em vez de ir de
0 a 1023, ela irá de 1023 a 0;
• Código:
•
•
//////////////////////////////////////////////////////////////////

#define an5 A0 // "A0" Se refere a porta analógica 0

void setup()
{
pinMode(an5, INPUT);
Serial.begin(9600); // Objeto Serial método begin.
// 9600 será a velocidade que ele irá se comunicar com o monitor
serial do arduino
// Ou seja será a nossa saída
}

void loop()
{
Serial.println(analogRead(an5));
// Chamamos o objeto Serial com o método println
// println vai imprimir a leitura daporta analogica A0 no
console
delay(100);
}

//////////////////////////////////////////////////////////////////

// Se tiver tudo certo, o led TX acenderá, indicando leitura.

// No arduino IDE para acessar o monitor serial, terá que ir em
// ferramenta/monitor serial, logo após verifique se está na
// velocidade certa, que nesse caso é 9600

// OBS: A porta PWM tem ¼ da porta Analógica

CÓDIGO PARA ACENDER O LED COM O POTENCIÔMETRO:

//////////////////////////////////////////////////////////////////

#define potenc A0
#define led 3

void setup(){
pinMode(potenc,INPUT);
pinMode(led,OUTPUT);
}

void loop(){
analogWrite(led, map(analogRead(potenc),0,1023,0,255));
delay(100); // O delay é a gosto
}

//////////////////////////////////////////////////////////////////

// O "map" já vai regular o potenciômetro com o led, logo, não

será necessário fazer cálculo
//
map(leitura,val_min_entrada,val_max_entrada,val_min_saida,val_max_
saida)
// leitura | No caso, vai ler o potenciômetro;
// val_min_entrada | As portas analógicas vão de 0 a 1023, logo,
esse valor será 0;
// val_max_entrada | As portas analógicas vão de 0 a 1023, logo,
esse valor será 1023;
// val_min_saida | As portas PWM vão de 0 a 255, logo esse valor
será 0;
// val_max_saida | As portas PWM vão de 0 a 255, logo esse valor
será 255;
Vai ficar fisicamente assim:

Agora vamos criar esse projeto:

Iremos girar o potenciômetro e dependendo de como giramos, ele

pode acender os ledes de uma em uma e mantê-los até acender tudo,
ou apagar de uma em uma.
Código:
//////////////////////////////////////////////////////////////////
#define potenc A0
int leds[]={2,3,4,5,6,7}; // leds[] é um vetor que criei para não criar um
#define para cada, atravez da inicialização_uniforme('{}')

int valor;

void setup(){
 for(int i=0;i<6;i++){ // 6 é o número de leds começando do 0
pinMode(leds[i],OUTPUT);
}
pinMode(potenc,INPUT);

void acender(int x){

int i;
for(i=0;i<x;i++){
digitalWrite(leds[i],HIGH);
}
for(i=x;i<6;i++){
digitalWrite(leds[i],LOW);
}
}

void loop(){
valor=analogRead(potenc);
acender(map(valor,0,1023,0,6)); // O número máximo de saída foi 6,
pois existem 6 leds
}
// Para acender e apagar os ledes de de um modo “degradê”, é só
colocar todos os ledes na porta PWM e alterar no código “digital”
para “analog”

//////////////////////////////////////////////////////////////////
SENSOR LDR:
É uma sensor que depende de luz, pois dependendo da situação da
luz, ele pode fazer, ou não, uma determinada função. Ex. no dia a
dia: Os postes de luz que acendem quando está de noite, pois eles
têm um sensor.

Isso é um fotorresistor, que não

tem polaridade, porém por padrão é
colocado o GND e 5v, nessa ordem,
pois se inverter, terá que
reconfigurar no seu código, pois
suas configurações mudarão.

Código

//////////////////////////////////////////////////////////////////

#define ldr A0
#define led 2
int vldr=0;

void setup()
{
pinMode(led, OUTPUT);
pinMode(ldr,INPUT);
Serial.begin(9600); // Chame o ele para checar a intensidade da luz
}

void loop()
{
vldr=analogRead(ldr);
if(vldr>900){ // Se o resultado não foi o esperado, veja no painel o valor
que está dando, para assim, poder regular
digitalWrite(led,LOW);
}else{
digitalWrite(led,HIGH);
}
Serial.println(vldr);
delay(100);
}

//////////////////////////////////////////////////////////////////
O projeto físico ficará assim:
VAMOS ENSINAR COM ENVIAR QUALQUER CÓDIGO (PROGRAMA) PARA O
ARDUINO.

1. Você precisará de um computador/notebook, um Arduino Uno, ou

outra placa de Arduino, e um cabo usb.
2. A parte “quadrada” do cabo se conecta ao arduino.
3. A parte usb se conecta no notebook.
4. Acenderá um led de “ON”, que informa que Arduino está ligado.
5. Vamos a tela do computador/notebook.
6. Abra o programa Arduino. Você não instalou o programa? Então
clique aqui e instale o arduino
7. Vamos conferir se o computador/notebook reconheceu o arduino
e selecionar a porta.
8. Coloque o mouse sobre o menu “Ferramentas” -> “Placa”.
9. Selecione o Arduino que você esta usando, no nosso caso é o
“Arduino UNO”.
10. Coloque o mouse sobre o menu “Ferramentas” -> “Porta”.
11. Selecione a porta que aparece para você, no nosso caso é
o “COM6”.
12. As portas “COM” podem alterar em cada placa que você
conecta.
13. Vamos enviar um código de exemplo do arduino.
14. Coloque o mouse sobre o menu “Arquivos” -> “Exemplos” ->
“01.Basics”.
15.
Selecione o “Blink”.
16. Esse é o código do programa, que fará o led da porta 13
piscar.
17. Para enviar o código (programa), clique em “Carregar” (o
simbolo de seta para a direita).
18. Aguarde a compilação e o envio do programa.
19. Quando o programa é transferido para o arduino, os leds
TX e RX piscam até o programa ser enviado por completo.
20. Quando a transferência acaba no Arduino fica escrito
“Carregado” embaixo do programa.

Parabéns, agora você sabe como enviar o programa para o arduino!

Para variar a tensão, é necessário ter mais de um resistor.
Obs.: Se os resistores tiverem a mesma resistência, a tensão de
saída será a metade da que entrou. Ex.: Entrada de 5v e dois
resistores de 10kΩ, gera uma saída de 2,5v

Esta é a fórmula: