Circuitos Microcontrolados (Arduino) - V2023

Circuitos
Microcontrolados
Circuitos Microcontrolados Welbert O. Silva 1

1. Introdução aos microcontroladores.
Os microcontroladores estão escondidos dentro de inúmeros produtos atualmente. Se um forno de microondas tem
um LED ou visor LCD e teclado, ele contém um microcontrolador. Todos os automóveis modernos contêm ao menos
um microcontrolador (e podem ter até 6 ou 7): o motor é controlado por um microcontrolador, bem como os freios
antitravamento o controle de velocidade de viagem e assim por diante. A maioria dos aparelhos com controle remoto
contém um microcontrolador: TVs, VCRs e sistemas de som de alta fidelidade entram nesta categoria.
Além disso, também têm microcontroladores: câmeras SLR e câmeras digitais, telefones celulares,
filmadoras, impressoras a laser, telefones (as que possuem identificador de chamadas, memória para 20 números,
etc.), pagers, além de refrigeradores, lava-louças, lavadoras de roupas e secadoras (os que possuem visores e
teclados). Basicamente, qualquer produto ou dispositivo que interaja com o usuário possui um microcontrolador
interno.
1.1 Histórico dos Microcontroladores

Em 1969, uma empresa japonesa chamada BUSICOM iniciou um projeto para uma calculadora eletrônica. A história
do microprocessador data a partir deste projeto.
Esta empresa enviou para os Estados Unidos uma equipe de engenheiros responsáveis pelo projeto à procura de
Marcian Hoff, da Intel Corporation. Marcian Hoff que já tinha experiência com computadores e vislumbrou de forma
diferente aquele projeto. Ele pensou de que ao invés de desenvolver um chip que somente seria uma calculadora,
desenvolver algo que funcionasse de acordo com um programa. Após a compra da licença da empresa japonesa, em
1971, a Intel lança o seu primeiro processador de 4 bits, denominado 4004. Esse foi o primeiro processador de 4 bits
e conseguia processar 6000 operações por segundo (6kHz). Já no próximo ano, mais precisamente em Abril de 1972,
a Intel anuncia o seu primeiro processador de 8 bits, o 8008. Este processador, além de ter um barramento de dados
maior, conseguia processar até 300000 operações por segundo. Nesta mesma época, já começam a aparecer os
primeiros concorrentes da Intel, sendo a primeira a Motorola Corporation. Ela lança o 6800. Um engenheiro da
Motorola sai da empresa e entra para a MOS Technology que em 1975, lança o 6501 e o 6502 por um preço muito
mais abaixo do que os processadores da Intel e Motorola. A Motorola, lança um processo contra a MOS Technology
e contra o engenheiro que saiu da Motorola para a concorrente. A MOS fica impossibilitada de comercializar o 6501,
porém o 6502 continua a sua venda normalmente. Devido ao baixo custo do 6502, este torna-se rapidamente utilizado
pelo mercado nos computadores Apple, Comodore e até no Atari! A MOS chegou a vender até 15 milhões de
processadores por ano, porém foi comprada por um grupo de empresas como a Rockwell, Ricoh e Comodore. Outro
engenheiro, porém da Intel, sai da corporação e funda sua própria empresa, a Zilog. Em 1976, a Zilog lança o Z80,
que era compatível com 8080 da Intel e apresentava inúmeras vantagens frente a este.
Uma das grandes vantagens do Z80, é que este além de ser totalmente compatível com o 8080, conseguia rodar os
programas já desenvolvidos para este processador com muito mais vantagens. Neste mesmo ano, a Intel lança uma
versão melhorada do 8080, chamada 8085, porém o Z80 ainda era tão superior a este e tornou-se praticamente padrão
de mercado em processadores.

O PIC é um microcontrolador da arquitetura Harvard modificada fabricados pela Microchip Technology, que
processam dados de 8 bits, de 16 bits e, mais recentemente, de 32 bits. São derivados do PIC16501 originalmente
desenvolvidos pela divisão de microeletrônica da General Instrument. Seu nome é oriundo de "Programmable
Interface Controller" (Controlador de Interface Programável), anteriormente conhecido como "Peripheral Interface
Controller" (Controlador de Interface Periférica), hoje conhecido apenas como PIC. Tem suas raízes na universidade
de Harvard com um projeto para o Departamento de Defesa, mas este foi vencido por um projeto de memória mais
simples (e mais confiável na época) da Universidade de Princeton. A arquitetura Harvard foi primeiramente usada
no 8x300 da Signetics, e foi adotada pela General Instruments para uso como interface controladora de periféricos
(PIC) que foi projetada para compensar o fraco barramento de I/O da sua CPU CP1600 de 16 bits. A divisão de
microeletrônica foi depois transformada na Arizona Microchip Technology (por volta de 1985), com os PICs como
seu produto principal.
O ARDUINO é 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, uma linguagem de programação padrão, a
qual tem origem em Wiring, e é essencialmente C/C++. O objetivo do projeto é criar ferramentas que são acessíveis,
com baixo custo, flexíveis e fáceis de se usar por artistas e amadores. Principalmente para aqueles que não teriam
alcance aos controladores mais sofisticados e de ferramentas mais complicadas.
O projeto ARDUINO iniciou-se na cidade de Ivrea, Itália, em 2005, com o intuito de interagir em projetos escolares
de forma a ter um orçamento menor que outros sistemas de prototipagem disponíveis naquela época. Seu sucesso foi
sinalizado com o recebimento de uma menção honrosa na categoria Comunidades Digitais em 2006, pela Prix Ars
Electronica,16 17 além da marca de mais de 50.000 placas vendidas até outubro de 2008.
1.2 Microcontroladores versus Microprocessadores
Um microcontrolador difere de um microprocessador em vários aspectos. Primeiro e o mais importante, é a sua

funcionalidade. Para que um microprocessador possa ser usado, outros componentes devem ser adicionados, tais
como memória, chipsets e componentes para receber e enviar dados. Em resumo, isso significa que o
microprocessador é o verdadeiro coração do computador. Não há como imaginar um PC sem um microprocessador.
Por outro lado, o microcontrolador foi projetado para ter todas estas funcionalidades em uma única pastilha.
Comumente, um microcontrolador é chamado de um computador em um único chip principalmente por causa deste
motivo. Nenhum dos outros componentes externos são necessários nas aplicações, uma vez que todos os periféricos
necessários já estão contidos nele. Assim, poupamos tempo e espaço na construção de novos projetos.

2. ARDUINO
Os apaixonados por tecnologia certamente já

pensaram em prover soluções eletrônicas que
resolvessem probleminhas do dia a dia. Com o
Arduino, uma placa fabricada na Itália utilizada
como plataforma de prototipagem eletrônica que
torna a robótica mais acessível a todos. Projeto
italiano iniciado em 2005 tinha primeiramente cunho
educacional e interagia com aplicações escolares.
Sua placa consiste em um

microcontrolador Atmel AVR de 8 bits, com
componentes complementares para facilitar a
programação e incorporação para outros circuitos.
Um importante aspecto é a maneira padrão que os
conectores são expostos, permitindo o CPU ser
interligado a outros módulos expansivos, conhecidos
como shields. Os Arduinos originais utilizam a série
de chips mega AVR, especialmente os ATmega8,
ATmega168, ATmega328 e a ATmega1280; porém
muitos outros processadores foram utilizados por
clones deles.
A grande maioria de placas inclui um regulador linear de 5 volts e um oscilador de cristal de

16 MHz (podendo haver variantes com um ressonador cerâmico), embora alguns esquemas como
o LilyPad usam até 8 MHz e dispensam um regulador de tensão embutido, por ter uma forma específica de
restrições de fator. Além de ser microcontrolador, o componente também é pré-programado com
um bootloader que simplifica o carregamento de programas para o chip de memória flash embutido,
comparado com outros aparelhos que usualmente necessitam de um chip programador externo.
Conceitualmente, quando seu software é utilizado, ele monta todas as placas sobre uma programação de
conexão serial RS-232, mas a maneira que é implementado no hardware varia em cada versão. Suas placas
seriais contêm um simples circuito inversor para converter entre os sinais dos níveis RS-232 e TTL.
Atualmente, existem alguns métodos diferentes para realizar a transmissão dos dados, como por placas
programáveis via USB, adicionadas através de um chip adaptador USB-para-Serial como o FTDI FT232.
Algumas variantes, como o Arduino Mini e o não oficial Boarduino, usam um módulo, cabo adaptador
USB, bluetooth ou outros métodos. Nestes casos, são usados com ferramentas microcontroladoras ao invés
do Arduino IDE, utilizando assim a programação padrão AVR ISP.
A maioria dos pinos de E/S dos microcontroladores são para uso de outros circuitos. A versão Diecimila,
que substituiu a Duemilanove, por exemplo, disponibiliza 14 pinos digitais, 6 das quais podem produzir
sinais MLP, além de 6 entradas analógicas. Estes estão disponíveis em cima da placa, através de
conectores fêmeas de 0,1 polegadas (ou 0,25centímetros).
O modelo Nano, Boarduino e placas compatíveis com estas, fornecem conectores machos na parte de
baixo da placa, para serem plugados em protoboards.

O Software Arduino IDE é uma
aplicação multiplataforma escrita em Java derivada
dos projetos Processing e Wiring. É esquematizado
para introduzir a programação a artistas e a pessoas
não familiarizadas com o desenvolvimento de
software. Inclui um editor de código com recursos
de realce de sintaxe, parênteses correspondentes e
identação automática, sendo capaz de compilar e
carregar programas para a placa com um único
clique. Com isso não há a necessidade de
editar Makefiles ou rodar programas em ambientes
de linha de comando.
Tendo uma biblioteca chamada "Wiring", ele possui
a capacidade de programar em C/C++. Isto permite
criar com facilidade muitas operações de entrada e
saída, tendo que definir apenas duas funções no
pedido para fazer um programa funcional:
setup( ) – Inserida no inicio, na qual pode ser usada

para inicializar configuração.
loop( ) – Chamada para repetir um bloco de

comandos ou esperar até que seja desligada.

3. Algoritmo
Um algoritmo é uma sequência finita de instruções bem definidas e não ambíguas, cada uma das quais
pode ser executada mecanicamente em um período de tempo finito e com uma quantidade de esforço
finita.
O conceito de algoritmo é frequentemente ilustrado pelo exemplo de uma receita culinária, embora
muitos algoritmos sejam mais complexos. Eles podem repetir passos (fazer iterações) ou necessitar de
decisões (tais como comparações ou lógica) até que a tarefa seja completada. Um algoritmo corretamente
executado não irá resolver um problema se estiver implementado incorretamente ou se não for
apropriado ao problema.
Um algoritmo não representa, necessariamente, um programa de computador, e sim os passos

necessários para realizar uma tarefa. Sua implementação pode ser feita por um computador, por outro
tipo de autômato ou mesmo por um ser humano. Diferentes algoritmos podem realizar a mesma tarefa
usando um conjunto diferenciado de instruções em mais ou menos tempo, espaço ou esforço do que
outros. Tal diferença pode ser reflexo da complexidade computacional aplicada, que depende de
estruturas de dados adequadas ao algoritmo. Por exemplo, um algoritmo para se vestir pode especificar
que você vista primeiro as meias e os sapatos antes de vestir a calça enquanto outro algoritmo especifica
que você deve primeiro vestir a calça e depois as meias e os sapatos. Fica claro que o primeiro algoritmo
é mais difícil de executar que o segundo apesar de ambos levarem ao mesmo resultado.
O conceito de um algoritmo foi formalizado em 1936 pela Máquina de Turing de Alan Turing e pelo
cálculo lambda de Alonzo Church, que formaram as primeiras fundações da Ciência da computação.
Exemplo: Algoritmo dos 30 minutos de um dia (em forma de fluxograma):

4. Linguagem C
C é uma linguagem de programação compilada de propósito geral, estruturada, imperativa,

procedural, padronizada pela ISO, criada em 1972, por Dennis Ritchie, no AT&T Bell Labs, para desenvolver
o sistema operacional Unix (que foi originalmente escrito em Assembly).
C é uma das linguagens de programação mais populares e existem poucas arquiteturas para as quais
não existem compiladores para C. C tem influenciado muitas outras linguagens de programação, mais
notavelmente C++, que originalmente começou como uma extensão para C.
5. Linguagem C++
C++ (em português lê-se "cê mais mais", em inglês lê-se see plus plus) é uma linguagem de
programação multi-paradigma e de uso geral. A linguagem é considerada de médio nível, pois combina
características de linguagens de alto e baixo níveis. Desde os anos 1990 é uma das linguagens comerciais
mais populares, sendo bastante usada também na academia por seu grande desempenho e base de
utilizadores.
Bjarne Stroustrup desenvolveu o C++ (originalmente com o nome C with Classes, que significa C com
classes em português) em 1983 no Bell Labs como um adicional à linguagem C. Novas características foram
adicionadas com o tempo, como funções virtuais, sobrecarga de operadores, herança múltipla, gabaritos
e tratamento de exceções. Após a padronização ISO realizada em 1998 e a posterior revisão realizada em
2003, uma nova versão da especificação da linguagem foi lançada em setembro de 2011, conhecida
informalmente como C++11 ou C++0x.
Exemplo
#include <cstdlib> Adição de comandos que o
#include <iostream> computador conheça
using namespace std;
int main()
{ Inicio
printf("Programa teste");
cout<<"\n\n\n";
system("PAUSE"); Programa
return EXIT_SUCCESS;
} Fim

6. Programação Arduino
No Arduino utiliza-se a estrutura da programação C++ como base, porem alguns comandos são
próprios para o sistema do Arduino. Ambos são case-sensitive diferenciam letras maiúsculas e minúsculas.
6.1 – Parte 1 – Adicionando as bibliotecas, constantes e variáveis

#include <Biblioteca>
O comando #include é usado para adicionarmos as Bibliotecas, uma biblioteca no arduino seria fazer
o arduino entender algum tipo de comando, como ainda não temos nenhuma noção de arduino vou dar
um exemplo do que seria essas bibliotecas se fossem aplicadas em uma pessoa, nesse momento imagine
que a pessoa não tenha nenhum conhecimento, e vamos adicionar as bibliotecas:
#include <Direção> neste exemplo essa biblioteca faria com que a pessoa passasse a entender o que
é cima, baixo, direita, esquerda, sul, leste, etc.
#include <Português> neste exemplo essa biblioteca faria com que a pessoa passasse a entender o
idioma português.
#include <Matemática> neste exemplo essa biblioteca faria com que a pessoa passasse a entender a
matemática: soma, subtração, multiplicação, seno, tangente, etc.
No caso do arduino muitas bibliotecas já estão inclusas de fábrica, e você só irá precisar de adicionar
uma biblioteca caso coloque algum dispositivo especifico a ele como por exemplo um servo motor ou um
display de LCD.
#define NomeDaConstante Valor
O comando #define permite ao programador criar um nome para um número fixo. Exemplo:
#define welbert 200
Acima foi definido que welbert equivale a 200, sempre que digitarmos welbert nas linhas de
programação posterior a esse comendo, o Arduino entenderá 200.
Mas em que isso é vantajoso? Vamos supor que você precisa formar um quadrado com lado de
tamanho 200 então a programação seria algo assim:
Linha para direita com tamanho 200;

Linha para baixo com tamanho 200;
Linha para esquerda com tamanho 200;
Linha para cima com tamanho 200;
Se precisarmos trocar o tamanho do quadrado acima para 350 teríamos que ir nas 4 linhas de
programação e substituir o 200 por 350.

Agora vamos usar o comando #define nesse mesmo exemplo:
#define welbert 200

Linha para direita com tamanho welbert;
Linha para baixo com tamanho welbert;
Linha para esquerda com tamanho welbert;
Linha para cima com tamanho welbert;
Se precisarmos trocar o valor para 350, faríamos uma única alteração na linha do comando #define.
int NomeDaVariável; ou int NomeDaVariável = ValorInicial;
O comando int serve para criar uma variável numérica inteira (número sem parte decimal), essa
variável pode ou não receber um valor inicial, o valor salvo dentro da variável pode ser trocado a
qualquer momento, exemplo:
int welbert;
welbert = 200;
Linha para direita com tamanho welbert;
Linha para baixo com tamanho welbert;
welbert = 350;
Linha para esquerda com tamanho welbert;
Linha para cima com tamanho welbert;
Dessa vez ao fazer as linhas da direita e baixo elas vão possuir um tamanho de 200, já quando for
feitas as linhas da esquerda e cima elas terão um tamanho de 350. Podemos juntar as duas primeiras
linhas de programação colocando apenas: int welbert = 200;
float NomeDaVariável; ou float NomeDaVariável = ValorInicial;
O comando float tem a mesma funcionalidade do comando int porém o float permite que o número
seja com ou sem parte decimal, com ele podemos por exemplo criar uma variável com valor de 3,14
porem ao digitar usaremos o ponto ao invés de virgula (O programa tem base americana e eles usam
ponto ao invés de virgula).
Como o comando float aceita números inteiros e decimais poderíamos pensar em utiliza-lo sempre
no lugar do int, porem alguns comandos que iremos estudar posteriormente requer que o número seja
inteiro, então se usarmos o comando float no programa dará um erro de programação. Um exemplo
clássico disso seria se tivéssemos que saber se um número é par ou ímpar sabemos que o 2 é par, o 3 é
impar e o 2,5? Números decimais não existe par ou ímpar, logo se formos montar uma programação
onde verifica se o número é par não podemos utilizar a variável do tipo float.
char NomeDaVariável; ou char NomeDaVariável = ‘ValorInicial’;
O comando char é similar ao int e float porem nele é colocado um único caractere, esse caractere deve
ser colocado entre apostrofo. Um caractere pode ser um número (0, 1, 2, ..., 9), uma letra (A, a, B, b, ...,
Z, z) ou um símbolo (!, $, +, ., ...).

const
O comando const tem a mesma função do comando #define, ele vai definir um valor fixo a um nome
qualquer, ele trabalha junto com os comandos int, float e char, exemplo:
const int welbert = 200;
nesse exemplo acima o valor de welbert está definido para 200 e por causa do const no restante da
programação não conseguimos alterar esse valor.
6.2 – Parte 2 – Configurando o hardware

void setup ( ) { }
Após colocarmos as bibliotecas, constantes e variáveis vamos configurar nosso hardware, ou seja,
configurar o que será usado ao arduino, exemplo de componentes que possa ser acoplado ao arduino:
botões, LEDs, reles, sensores, motores de baixa potência, LDRs, potenciômetros, displays, etc. Para isso
usamos uma tarefa de configuração definida como void setup ( ) esse comando é seguido por uma
abertura de chaves e logo depois configuramos cada componente que vamos utilizar em uma linha de
programação (cada tipo de componente tem um código especifico que iremos aprender em outro
momento), após adicionado todos os componentes finalizamos com o fechamento da chaves. Como por
exemplo para adicionarmos um display de lcd, um botão e um led nessa parte da programação, o código
gerado seria desse modo:
void setup( )
{
lcd.begin(16, 2);
pinMode(Bot, INPUT);
pinMode(led, OUTPUT);
}
6.3 – Parte 3 – Programando as funções

void loop ( ) { }
Após configurarmos nosso hardware, vamos programar o que cada componente irá fazer e quando irá
fazer, no caso do arduino todos os comandos devem ser feitos entre as chaves do void loop ( ).
O void loop é uma tarefa cíclica, ou seja, assim que sua programação terminar, ele irá repeti-la novamente
em um ciclo infinito os comandos durante a programação também obedece a um código especifico.

7. Entradas e Saídas digitais no Arduino
O Arduino Uno (versão que utilizaremos em toda a apostila) apresenta 14 pinos (de 0 a 13) que podem
ser usados como entrada ou saídas digitais.
Note que:
Algumas entradas possuem um til (3, 5, 6, 10, 11) essas
saídas podem ser utilizadas como PWM.
Os pinos 0 e 1 são utilizados para comunicação serial,
evite utilizar esses dois pinos nas montagens.
Próximo ao pino 13 existe um LED smd, sempre que o
pino 13 esta como saída e acionamos ele, esse Led acende.
A alimentação de entrada e saída deve ser aproximadamente +5v para nível logico 1 e 0v para nível
logico 0, sendo que o valor máximo de cada pino é de 40mA (para acionarmos cargas com corrente
elevada basta colocarmos um relé na saída desejada).
7.1 – Saídas Digitais

Para saída digital podemos ligar um LED, um relé, um motor de baixa potência, qualquer equipamento
precisa ser ligado, dede que sua corrente não ultrapasse 40mA.
Exemplo: LED conectado ao Arduino
Comando de configuração:
pinMode (NumeroDoPino, OUTPUT);
utilizado para definir que o pino será uma saída.
Comando de função:
digitalWrite (NumeroDoPino, LOW);
utilizado para desligar o LED (podemos substituir a palavra LOW pelo

número 0)
digitalWrite (NumeroDoPino, HIGH);
utilizado para ligar o LED (podemos substituir a palavra HIGH pelo

número 1)

Exemplo 1:
Faça a montagem e programação de um LED que deverá ficar piscando sendo o tempo ligado de 2
segundos e o tempo desligado de 1 segundo.
const int Pedro = 3;
void setup ( )
{
pinMode (Pedro, OUTPUT);
}
void loop ( )
{
digitalWrite (Pedro, 1);
delay (2000);
digitalWrite (Pedro, 0); .
delay (1000);
}
Vamos entender nossa programação:
• Const int Pedro = 3; esse comando define que Pedro vale 3 (este valor é 3 pois o Led foi colocado
no pino 3, o programador resolveu chamar o Led de Pedro).
• void setup ( ) note que após esse comando a uma chaves aberta e ela é fechada duas linhas
abaixo a sua abertura, todos os comandos entre essas chaves pertencem a instrução void setup.
Basicamente nessa parte da programação você deve configurar o que você vai utilizar, através de
outros comandos.
• pinMode (Pedro, OUTPUT); estamos configurando que Pedro vai ser uma saída (OUTPUT= saída
em inglês).
• Void loop ( ) também apresenta as chaves, tudo dentro dessas chaves pertence a esse comando.
É nessa parte que iremos construir como nossos componentes iram funcionar. void significa
função em inglês e Loop significa ciclo, ou seja, tudo que estiver dentro dessas chaves será
repetida em um ciclo infinito, sendo que o Arduino irá ler cada linha e executar sua função
sempre de cima para baixo.
• digitalWrite (Pedro, 1); esse comando faz o Led ligar, Write é escrever em inglês, logo você está
escrevendo 1 em Pedro, em binário 1 significa ligado.
• delay(2000); este comando faz o programa ficar parado nessa linha por 2000 mili segundos (2
segundos), delay significa demora.
• digitalWrite (Pedro, 0); esse comando faz o Led desligar, pois estamos escrevendo 0 em Pedro,
em binário 0 significa desligado.
• delay(1000); este comando faz o programa ficar parado nessa linha por 1 segundo.

Exemplo 2:
Faça a montagem e programação de dois LEDs que deverá ficar piscando sendo o tempo do primeiro
LED ligado é de 2 segundos e o tempo dele desligado de 1 segundo, já o segundo LED deverá funcionar
de forma contrária, quando o primeiro LED está aceso o segundo LED deverá estar apagado e quando o
primeiro LED estiver apagado o segundo LED deverá estar aceso.
const int Pedro = 3, Maria = 12;
void setup ( )
{
pinMode (Pedro, OUTPUT);
pinMode (Maria, OUTPUT);
}
void loop ( )
{
digitalWrite (Maria, 0);
delay (2000);

digitalWrite (Maria, 1);
delay (1000);
}
Obs.: conforme dito anteriormente o programa é Case-sensitive, ou seja, diferencia maiúscula e minúscula
então bastante cuidado ao digitar os comando, como exemplo em digitalWrite note que o W deve ser
maiúsculo e o restante deve ser minúsculo, já o comando OUTPUT deve ser todo maiúsculo, e o comando
delay todo em minúsculo, cada comando tem um jeito único de ser escrito e caso não coloque exatamente
desse jeito o programa acusará que existe erros de programação e sua programação não poderá ser
transferida para o arduino.

8. Comentários
Os comentários servem para escrever algo no programa para ficar mais fácil de entender, os comentários
não são visualizados pelo programa na simulação.
Existem dois modos de adicionar um comentário:
Se o comentário for feito todo em uma única linha basta colocar duas barras antes do comentário
//comentário
Se o comentário for ocupar diversas linhas basta colocar /* para iniciar o comentário e */ para finalizar o
comentário
/* comentário
comentário
comentário
comentário */
Exemplo:
Faça o código de um LED piscando em intervalos de 0,5 segundos
/*
Este programa abaixo é apenas um exemplo
de como aplicar os comentários, sua função
seria piscar um LED.
*/
//Definindo o pino a ser usado

const int LED = 3;
//Configurando o Hardware
void setup ( )
{
pinMode (LED, OUTPUT); //define o LED como saída
}
//Código funcional
void loop ( )
{
digitalWrite (LED, 1); //Faz com que o LED ligue
delay (500); //esperar 0,5 segundos
digitalWrite (LED, 0); //Faz com que o LED desligue
delay (500); //esperar 0,5 segundos
}

Exercício A
1 – SEMAFORO – Faça a montagem de um Arduino com 3 LEDs (1
vermelho, 1 verde, 1 amarelo), e programe-o para funcionar como um
semáforo (acende verde por 4s, amarelo por 2s, vermelho por 5s).
2 – Faça um pisca-pisca com dois leds de forma que eles fiquem iguais, sempre que 1 dos leds estiver
aceso o outro também deverá ficar aceso, e sempre que um tiver apagado o outro também deverá estar
apagado, o valor dos tempos do pisca-pisca fica a seu critério.
3 – Faça um pisca-pisca com dois leds de forma que eles fiquem alternados, sempre que 1 dos leds estiver
aceso o outro deverá estar apagado, o valor dos tempos do pisca-pisca fica a seu critério.
4 – Faça um pisca-pisca com quatro leds de forma que leds 1 e 2 fique iguais, leds 3 e 4 fiquem iguais, e
leds 1 e 3 fiquem alternados, ou seja, leds 1 e 2 acendem depois troca para leds 3 e 4, depois volta para
leds 1 e 2 e assim por diante, o valor dos tempos do pisca-pisca fica a seu critério.
5 – Faça a montagem de um Arduino com 5 LEDs e programe-o para acionar em ciclo de acordo com a
tabela a seguir.
6 – SEMAFORO - Implemente na questão 1 o semáforo do pedestre ficando com seguinte sequência:

• Durante 4 segundos ficará aceso verde para os carros e
vermelho para os pedestres
• Durante 2 segundos ficará aceso amarelo para os carros e
vermelho para os pedestres
• Durante 3 segundos ficará aceso vermelho para os carros e
verde para os pedestres
• Durante 2 segundos ficará aceso vermelho para os carros e
vermelho piscando para os pedestres

7.2 - Entradas Digitais
Para entrada digital podemos por exemplo utilizar botões, sensores ou algum componente que possua
dois estados (aberto e fechado). A montagem pode ser de 3 maneiras:
Pull-Up ou Direta:
Com botão desapertado o arduino entenderá como HIGH (1).
Com o botão pressionado o arduino entenderá como LOW (0).
Pull-Down:
Com botão desapertado o arduino entenderá como LOW (0).
Com o botão pressionado o arduino entenderá como HIGH (1).
Comandos de configuração:
* pinMode (NumeroDoPino, INPUT);
utilizado nos sistemas Pull-Up e Pull-Down para definir o pino como uma entrada.
* pinMode (NumeroDoPino, INPUT_PULLUP);
utilizado no sistema direto para definir o pino como uma entrada.
Comandos de função
* digitalRead (NumeroDoPino)
utilizado para verificar se tem energia ou não chegando ao pino do arduino.

No software que iremos utilizar:
Exemplo: Faça a montagem de um led e um botão conectado a um arduino e na programação faça o led
ligar quando o botão estiver pressionado.
const int LED = 3, BOT = 7;
void setup ( )
{
pinMode (LED, OUTPUT);
pinMode (BOT, INPUT);
}
void loop ( )
{
digitalWrite (LED, digitalRead(BOT));
}
9. if (se), else if (senão se), else (senão)

Em nosso dia a dia tomamos ações diferentes para realizar uma mesma tarefa, basicamente
perguntamos para nós mesmo o “se” ou o “senão”, um exemplo do nosso seria ir ao SENAI, “se” estiver
chovendo você levaria um guarda-chuva, “senão se” tiver possibilidade de chover também levaria um
guarda-chuva, “senão” a possibilidade de chover então não levaria um guarda-chuva. Em programação
muitas das vezes isso vai acontecer, iremos realizar determinada tarefa se uma outra acontecer, para isso
usaremos esses termos porem em inglês.

Exemplo: Faça a montagem e a programação de dois botões retentivos e 3 LEDs ligado ao arduino, e
programe-o com a função:
• Se os dois botões estiverem desapertados os LEDs devem estar apagados.

• Se apenas o primeiro botão estiver pressionado apenas o LED 1 deve ligar.
• Se apenas o primeiro botão estiver pressionado apenas o LED 2 deve ligar.
• Se os dois botões estiverem pressionados apenas o LED 3 deve ligar.
const int led_1=2, led_2=3,

led_3=4, bot_1=7, bot_2=13;
void setup()
{
pinMode(led_1, OUTPUT);
pinMode(bot_1,INPUT);
pinMode(bot_2,INPUT);
}
void loop()
{
if( digitalRead(bot_1)==0 &&
digitalRead(bot_2)==0 )
{
digitalWrite(led_1, 0);
}
if( digitalRead(bot_1)==1 && digitalRead(bot_2)==0 )
{
}
{
}
{
}
}
Vamos analisar o primeiro if, após ele a um parêntese, dentro dele colocamos nossa condição, e
após ele colocamos chaves, todos os comandos que estão dentro dessas chaves só irão ser realizados se
a condição dentro do parêntese for verdadeira. Dentro desse parêntese tem mais dois outros separados
por &&, isso aconteceu porque temos duas condições, e queremos que as duas condições sejam
verdadeiras, nesse primeiro if queremos saber se os dois botões estão desapertados. Como vimos antes
botão desapertado vale zero, então foi perguntado se o botão em especifico vale zero, usando o
símbolo de dois sinais de igual.

Para os comandos de verificação temos a possibilidade dos seguintes símbolos:
• == verifica se é igual • != verifica se é diferente

• < verifica se é menor • > verifica se é maior
• <= verifica se é menor ou igual • >= verifica se é maior ou igual
Podemos separa condições de dois modos:
• && = and = nesse caso as duas tem que ser verdadeiras para que o if seja verdadeiro
• || = or = nesse caso qualquer uma das condições verdadeiras já deixa o if verdadeiro
Através do comando #define visto anteriormente podemos diminuir os comandos da questão anterior
para ficarem mais fácil na hora de criar o código.
#define pm pinMode
#define dr digitalRead
#define dw digitalWrite
const int led_1=2, led_2=3, led_3=4, b1=7, b2=13;
void setup()
{
pm(led_1, OUTPUT);
pm(led_2, OUTPUT);
pm(led_3, OUTPUT);
pm(b1,INPUT);
pm(b2,INPUT);
}
void loop()
{
if( dr(b1)==0 && dr(b2)==0 )
{
dw(led_1, 0);
dw(led_2, 0); Observe que nos #define abreviamos 3 itens:
dw(led_3, 0);
}
• pinMode passou a ser apenas pm
• digitalRead passou a ser apenas dr
if( dr(b1)==1 && dr(b2)==0 ) • digitalWrite passou a ser apenas dw
{
dw(led_1, 1);
dw(led_2, 0);
dw(led_3, 0);
}
Obs: Na declaração de variáveis no software do
if( dr(b1)==0 && dr(b2)==1 )
{ TINKERCAD não se pode usar B1 (com o B
dw(led_1, 0); maiúsculo) este já é um comando interno, e se
dw(led_2, 1); declarado o programa apresentará erro ao tentar
dw(led_3, 0); compilar.
}
if( dr(b1)==1 && dr(b2)==1 )

{
dw(led_1, 0);
dw(led_2, 0);
dw(led_3, 1);
}
}

Podemos ainda neste exemplo anterior trabalhar com os else if e else:
#define pm pinMode else if( dr(b1)==1 && dr(b2)==0 )

#define dr digitalRead {
#define dw digitalWrite dw(led_1, 1);
const int led_1=2, led_2=3, led_3=4, b1=7, dw(led_2, 0);
b2=13; dw(led_3, 0);
void setup() }
{
pm(led_1, OUTPUT); else if( dr(b1)==0 && dr(b2)==1 )
pm(led_2, OUTPUT); {
pm(led_3, OUTPUT); dw(led_1, 0);
pm(b1,INPUT); dw(led_2, 1);
pm(b2,INPUT); dw(led_3, 0);
} }
void loop()
{ else
if( dr(b1)==0 && dr(b2)==0 ) {
{ dw(led_1, 0);
dw(led_1, 0); dw(led_2, 0);
dw(led_2, 0); dw(led_3, 1);
dw(led_3, 0); }
} }
Como temos 2 botões havia 4 possibilidades: os dois despressionados, apenas o primeiro pressionado,
apenas o segundo pressionado e os dois pressionados, como trabalhamos com else if (senão for o
anterior e se for) podemos colocar na última condição apenas else, pois se nenhuma das condições
anteriores não são verdade, logo os dois botões estarão obrigatoriamente pressionados.
Nas condições digitais (0 ou 1) podemos também remover o ==1 quando for perguntar se está em nível
lógico alto, e remover o ==0 desde que adicione uma exclamação antes, conforme o exemplo:
Podemos substituir:
if( dr(b1)==1 && dr(b2)==0 )
Por:
if( dr(b1) && !dr(b2) )

Exercício B
7 – Faça a montagem de um Arduino com 3 LEDs e 4 botões pulsantes, e programe-o para:
• Enquanto o botão 1 estiver sendo pressionado o LED 1 deverá ficar aceso.
• Ao pressionar o botão 2 o LED 2 deverá ligar.
• Ao pressionar o botão 3 o LED 2 deverá desligar.
• Enquanto o botão 4 estiver pressionado o LED 3 deverá ficar piscando.
8 – Faça a montagem de um arduino com 5 leds, 2 botões pulsantes e 2 botões retentivos. E programe-o
para:
• Ao pulsar o botão pulsante 1 o led 1 deverá ligar, e o led 2 deverá desligar.
• Ao pulsar o botão pulsante 2 o led 2 deverá ligar, e o led 1 deverá desligar.
• Se os botões retentivos 1 e 2 estiverem desapertados então os leds 3, 4 e 5 devem desligar.
• Se o botão retentivo 1 estiver pressionado o led 3 deverá ligar.
• Se o botão retentivo 1 estiver desapertado e o botão retentivo 2 estiver pressionado então o led
4 e 5 devem ligar.
• Se os botões 1 e 2 retentivos estiverem pressionados então o led 4 deve desligar e o led 5 deve
ligar.
9 – Faça a montagem de um arduino com 1 leds, 5 botões pulsantes.

• Ao pulsar o botão pulsante 1 o led deverá piscar uma vez.
• Ao pulsar o botão pulsante 2 o led deverá piscar duas vezes.
• Ao pulsar o botão pulsante 3 o led deverá piscar três vezes.
• Ao pulsar o botão pulsante 4 o led deverá piscar quatro vezes.
• Ao pulsar o botão pulsante 5 o led deverá piscar cinco vezes.
Utilize o tempo do pisca-pisca a seu critério.
10 – Faça a montagem de um arduino com 2 leds, 3 botões pulsantes e 1 botão retentivo.
• Se o botão retentivo estiver desapertado então ao:

• Ao pulsar o botão pulsante 1 os leds deveram piscar uma vez juntos.
• Ao pulsar o botão pulsante 2 os leds deveram piscar duas vezes juntos.
• Ao pulsar o botão pulsante 3 os leds deveram piscar três vezes juntos.
• Se o botão retentivo estiver pressionado então ao:

• Ao pulsar o botão pulsante 1 os leds deveram piscar uma vez alternados.
• Ao pulsar o botão pulsante 2 os leds deveram piscar duas vezes alternados.
• Ao pulsar o botão pulsante 3 os leds deveram piscar três vezes alternados.

11 – CAIXA D’AGUA – Uma caixa d’água possui dois
sensores e um bomba conforme indicado na figura, faça
uma lógica de arduino que sempre que o nível de água
da caixa estiver baixo a bomba deve ligar até encher a
caixa. Utilize um led para representar a bomba e botões
retentivos para representar os fins de curso tipo boia.
Implemente também um botão retentivo de modo que
o descritivo acima só funcione se ele estiver ativado, ao
desliga-lo o processo para.
12 – PORTÃO – Faça a lógica para o portão da figura seguinte:
• Ao pressionar abrir se o motor estiver parado então ligará o motorcima, até desatuar o sensor
fim de curso SA.
• Ao pressionar fechar se o motor estiver parado então ligará o motorbaixo, até atuar o sensor fim
de curso SB.
• Ao pressionar o
botão parar o motor
deve desligar
Utilize botões pulsantes

para Abrir, Fechar e Parar.
Botões retentivos para SA e
SB. Leds para Motor cima e
Motor baixo.
13 – MISTURADOR – Quando pressionar o botão de

“LIGA”, realiza o processo:
Coloca-se o produto A no silo até atingir SA.

Coloca-se o produto B no silo até atingir SB.
O motor liga por 5 segundos para misturar.
O liquido misturado é despejado pela saída.
Utilize botão pulsante para LIGA. Botões retentivos para

SA, SB e SV. Leds para VA, VB, VS e MOT.

10. LED RGB
O LED RGB é um LED que possui 4 terminais sendo um terminal comum, um terminal que faz ele
acender na cor vermelha (R = Red), um terminal que faz ele acender na cor verde (G = Green), um terminal
que faz acender ele na cor azul (B = Blue), essas 3 luzes, vermelha, verde e azul são obtidas apenas se ligar
uma cor por vez, ou seja, energizar apenas um dos três terminais, caso energize dois ou os três terminais
no LED aparecerá uma combinação dessas luzes, gerando uma tonalidade diferente, que pode ser:
Na figura acima o LED RGB acenderia na cor amarela se aplicarmos a mesma tensão elétrica nos
pinos vermelho (R) e verde (G), porém se trabalharmos com uma tensão ou corrente variável e aplicarmos
mais tensão no terminal vermelho e um pouco menos no terminal verde, teríamos uma luz terciária, no
caso um laranja, usando uma tensão variável podemos gerar qualquer tipo de cor no nosso LED, mas
nesse momento iremos trabalhar apenas com a parte digital, mas pra frente iremos estudar sobre o PWM
que fará esse controle para gerar as outras cores, conforme mencionado no exemplo da cor laranja.
O pino comum (C) pode ser o terminal anodo (+) ou o terminal catodo (-):
Obs.: No caso do LED RGB no software TINKERCAD só temos a opção de catodo comum.

11. Void (função)
Como vimos anteriormente a programação do arduino tem que ter duas funções a de configuração (void
setup) e a de realização (void loop), além dessas duas funções podemos criar outras funções para deixar
o programa mais organizado, e também economizar linhas de programação casa algo repita varias
vezes, essas funções (void) podem conter qualquer nome ainda não usado.
Exemplo: Faça a montagem de um LED RGB e um botão pulsante conectado ao arduino, e programa-o
para quando o botão for pressionado o LED acenda na cor amarela, após 1 segundo mude para cor azul,
após 3 segundos mude para cor amarela, após 2 segundos mude para cor azul, após 1 segundo mude
para cor amarela e após 4 segundos apague.
• Sem voids adicionais • Com outras voids
const int botao=10, vm=5, az=3, vd=2; const int botao=10, vm=5, az=3, vd=2;
void setup() void setup()
{ {
pinMode(botao, INPUT); pinMode(botao, INPUT);
pinMode(vm, OUTPUT); pinMode(vm, OUTPUT);
pinMode(az, OUTPUT); pinMode(az, OUTPUT);
pinMode(vd, OUTPUT); pinMode(vd, OUTPUT);
} }
void loop() void amarelo()
{ {
if(digitalRead(botao)==1) digitalWrite(vm, 1);
{ digitalWrite(az, 0);
digitalWrite(vm, 1); digitalWrite(vd, 1);
digitalWrite(az, 0); }
digitalWrite(vd, 1); void azul()
delay(1000); {
digitalWrite(vm, 0);
digitalWrite(vm, 0); digitalWrite(az, 1);
digitalWrite(az, 1); digitalWrite(vd, 0);
digitalWrite(vd, 0); }
delay(3000); void desligar()
{
digitalWrite(vm, 1); digitalWrite(vm, 0);
digitalWrite(az, 0); digitalWrite(az, 0);
digitalWrite(vd, 1); digitalWrite(vd, 0);
delay(2000); }
void loop()
digitalWrite(vm, 0); {
digitalWrite(az, 1); if(digitalRead(botao)==1)
digitalWrite(vd, 0); {
delay(1000); amarelo();
delay(1000);
digitalWrite(vm, 1); azul();
digitalWrite(az, 0); delay(3000);
digitalWrite(vd, 1); amarelo();
delay(4000); delay(2000);
azul();
digitalWrite(vm, 0); delay(1000);
digitalWrite(az, 0); amarelo();
digitalWrite(vd, 0); delay(4000);
} desligar();
} }
}

Exercício C
14 – Faça a montagem de um Arduino com 1 LED RGB e 8 botões pulsantes, e programe-o:
• Ao pressionar o botão 1 o LED deverá ficar verde.

• Ao pressionar o botão 2 o LED deverá ficar ciano.
• Ao pressionar o botão 3 o LED deverá ficar azul.
• Ao pressionar o botão 4 o LED deverá ficar magenta.
• Ao pressionar o botão 5 o LED deverá ficar vermelho.
• Ao pressionar o botão 6 o LED deverá ficar amarelo.
• Ao pressionar o botão 7 o LED deverá ficar branco.
• Ao pressionar o botão 8 o LED deverá apagar.
15 – Faça a montagem de um Arduino com 1 LED RGB e 7 botões pulsantes, e programe-o:
• Enquanto pressionado o botão 1 o LED deverá ficar verde.

• Enquanto pressionado o botão 2 o LED deverá ficar ciano.
• Enquanto pressionado o botão 3 o LED deverá ficar azul.
• Enquanto pressionado o botão 4 o LED deverá ficar magenta.
• Enquanto pressionado o botão 5 o LED deverá ficar vermelho.
• Enquanto pressionado o botão 6 o LED deverá ficar amarelo.
• Enquanto pressionado o botão 7 o LED deverá ficar branco.
• Se nenhum botão estiver pressionado o led deverá apagar.
16 – Faça a montagem de um Arduino com 1 LED RGB e 2 botões retentivos, e programe-o:
• Se os dois botões estiverem pressionados o LED deverá ficar transparente

• Se apenas o botão 1 estiver pressionado então o LED deverá ficar alternando entre as cores verde e
vermelho.
• Se apenas o botão 2 estiver pressionado então o LED deverá ficar alternando entre as cores azul e
magenta.
• Se os dois botões estiverem desapertados o LED deverá ficar alternando entre as cores ciano e amarelo.
17 – DESAFIO – Faça a montagem de um Arduino com 1 LED RGB e 7 botões retentivos, e programe-o:
• Se apenas 1 botão aleatório estiver pressionado o LED deverá ficar verde.

• Se apenas 2 botões aleatórios estiverem pressionados o LED deverá ficar ciano.
• Se apenas 3 botões aleatórios estiverem pressionados o LED deverá ficar azul.
• Se apenas 4 botões aleatórios estiverem pressionados o LED deverá ficar magenta.
• Se apenas 5 botões aleatórios estiverem pressionados o LED deverá ficar vermelho.
• Se apenas 6 botões aleatórios estiverem pressionados o LED deverá ficar amarelo.
• Se todos os botões estiverem pressionados o LED deverá ficar branco.
• Se nenhum botão estiver pressionado o LED deverá apagar.

12. Estrutura de repetição: while (enquanto)
Outro comando muito utilizado em programação C++ é o while esse comando permite o programa ficar
preso a um grupo de instruções se uma determinada condição for verdadeira, seu jeito de aplicação é
similar ao if, porém no if se a condição for verdadeira ele irá fazer os comandos após o parêntese uma
única vez, já no while enquanto a condição for verdadeira ele irá repetir os comandos.
Exemplo: Faça a montagem de um arduino com um botão retentivo e 2 LEDs, e programa-o para:
• com o botão desapertado os LEDs devem estar apagados.

• Com o botão pressionado o LED 1 deve ligar e após 2 segundos o LED 1 apaga e o LED 2 acende
permanentemente.
#define dr digitalRead
const int led_1=3, led_2=4, b1=7;
void setup()
{
pinMode(b1,INPUT);
}
void loop()
{
if(dr(b1)==0)
{
dw(led_1, 0);
dw(led_2, 0);
}
if(dr(b1)==1)
{
dw(led_1, 1);
delay(2000);
while(dr(b1)==1)
{
dw(led_1, 0);
dw(led_2, 1);
}
}
}

13. goto (ir para)
O goto é um comando utilizado para mudar de uma linha de programação para outra linha qualquer,
para isso usamos:
• goto NomeQualquer; para poder sair da linha

• NomeQualquer: para a linha de destino (mesmo nome colocado na linha do goto)
No exemplo anterior vamos fazer a Obs: Quando temos apenas uma linha de
programação substituindo o while pelo goto: programação dentro de um if ou um while
podemos eliminar as chaves.
#define dr digitalRead #define dr digitalRead

#define dw digitalWrite #define dw digitalWrite
const int led_1=3, led_2=4, b1=7; const int led_1=3, led_2=4, b1=7;

{ {
pinMode(led_1, OUTPUT); pinMode(led_1, OUTPUT);
pinMode(led_2, OUTPUT); pinMode(led_2, OUTPUT);
pinMode(b1,INPUT); pinMode(b1,INPUT);
} }
void loop() void loop()

{ {
if(dr(b1)==0) if(dr(b1)==0)
{ {
dw(led_1, 0); dw(led_1, 0);
dw(led_2, 0); dw(led_2, 0);
} }
if(dr(b1)==1) if(dr(b1)==1)
{ {
dw(led_1, 1); dw(led_1, 1);
delay(2000); delay(2000);
while(dr(b1)==1) xis:
{ dw(led_1, 0);
dw(led_1, 0); dw(led_2, 1);
dw(led_2, 1); if(dr(b1)==1)
} goto xis;
} }
} }
Obs: Neste último if não foi necessário abrir e
fechar parênteses pois só temos uma linha de
código.

14. for (para)
O comando for inicializa uma variável, realiza um loop enquanto uma função for verdadeira, e sempre
que chega ao seu final executa um comando.
for ( “iniciar variável” ; “condição de loop” ; “comando de final” )
Exemplo faça um programa que ao pressionar um botão pisque um led 30 vezes.
Sem usar o comando for: Usando o comando for:
#define dr digitalRead #define dr digitalRead

#define dw digitalWrite #define dw digitalWrite
const int led=3, b1=7; const int led=3, b1=7;
int xis; int xis;

{ {
pinMode(led, OUTPUT); pinMode(led, OUTPUT);
pinMode(b1, INPUT); pinMode(b1, INPUT);
} }
void loop() void loop()

{ {
if(dr(b1)==1) if(dr(b1)==1)
{ {
xis=0; for(xis=0; xis<30; xis++)
while(xis<30) {
{ dw(led, 1);
dw(led, 1); delay(1000);
delay(1000); dw(led, 0);
dw(led, 0); delay(1000);
delay(1000); }
xis++; }
} }
}
}
Exercício D
18 – Faça a montagem de um Arduino com 3 LEDs e 2 botões retentivos, e programe-o para:
• Enquanto os botões estiverem ambos desapertados ou ambos pressionados os LEDs devem estar
apagados.
• Se apenas o botão 1 estiver pressionado então o LED 1 deverá ligar e após 1s o LED 2 deverá ligar
e após mais um segundo o LED 3 deverá ligar.
• Se apenas o botão 2 estiver pressionado então o LED 2 deverá acender por 1s, após isso o LED 2
apaga e o LED 1 e 3 devem acender.

19 – Faça a montagem de um arduino com 1 led e 3 botões pulsantes.
• Ao pulsar o botão pulsante 1 o led deverá piscar dez vez.

• Ao pulsar o botão pulsante 2 o led deverá piscar cinquenta vezes.
• Ao pulsar o botão pulsante 3 o led deverá piscar cem vezes.
20 – Faça a montagem de um Arduino com 1 led, 2 botões retentivos e 1 botão pulsante, e programe-o para:
• Enquanto os botões retentivos estiverem ambos desapertados o LED deve estar apagado.
• Se o botão 1 retentivo estiver pressionado e o botão 2 retentivo estiver desapertado então o LED deverá
ficar piscando em intervalos de 1 segundo aceso e 1 segundo apagado, e enquanto segurar o botão
pulsante o LED para de piscar e deverá ficar apenas aceso.
• Se o botão 2 retentivo estiver pressionado e o botão 1 retentivo estiver desapertado então o LED deverá
ficar piscando em intervalos de 2 segundo aceso e 2 segundo apagado, e enquanto segurar o botão
pulsante o LED para de piscar e deverá ficar apenas apagado.
• Enquanto os botões retentivos estiverem ambos apertados o LED deve piscar 3 vezes em intervalos de 1,5
segundo ligado e 1,5 segundo desligado e logo depois ficar apenas aceso.
21 – DESAFIO – Faça a montagem de um arduino com 5 leds, 1 botão pulsante. E programe-o para:
• Ao pulsar o botão a primeira vez o led 1 deverá ligar.

• Ao pulsar o botão a segunda vez o led 2 deverá ligar.
• Ao pulsar o botão a terceira vez o led 3 deverá ligar.
• Ao pulsar o botão a quarta vez o led 4 deverá ligar.
• Ao pulsar o botão a quinta vez o led 5 deverá ligar.
• Ao pulsar o botão a sexta vez todos os leds devem desligar.
22 – ELEVADOR – Monte no arduino o circuito e programe-o para:
• Ao pressionar o botão “D1”, significa que uma pessoa está dentro do elevador querendo descer, então a
lâmpada “LB2” deve acender, e depois de 2 segundos o elevador começa a descer, quando o elevador chegar
em “S1” ele deverá parar de descer, e desligar “LB1”.
• Ao pressionar o botão “D2”, significa que uma pessoa está dentro do elevador querendo subir, então a
lâmpada “LB1” deve acender, e depois de 2 segundos o elevador começa a subir, quando o elevador chegar
em “S2” ele deverá parar de subir, e desligar “LB2”.
• Ao pressionar o botão “F1”, significa que uma pessoa está
no 1º andar querendo subir, então a lâmpada “LB2” deve
acender, e depois de 2 segundos o elevador começa a
descer, quando o elevador chegar em “S1” ele deverá parar
de descer, e desligar “LB1”.
• Ao pressionar o botão “F2”, significa que uma pessoa está
no 2º andar querendo descer, então a lâmpada “LB1” deve
acender, e depois de 2 segundos o elevador começa a subir,
quando o elevador chegar em “S2” ele deverá parar de
subir, e desligar “LB2”.
Motor cima e motor baixo devem ser representados por LEDs,

LB1 e LB2 simulam a porta do elevador, também serão LEDs.

23 – CAIXA D’AGUA – Existem duas bombas que enchem a caixa
d’agua ao lado, sendo que o controle deve ser realizado da
seguinte forma:
Quando o nível da água estiver em 50% a bomba 1 deverá ligar

até que a caixa d’água encha completamente. Se o consumo de
água da casa estiver grande a bomba 1 não conseguirá manter o
nível de água na caixa d’água, então existe uma bomba de
segurança, esta bomba 2 deve ser ligada apenas quando o nível
estiver muito baixo, no caso abaixo de 25%, e ela deve ser desligada quando o nível de água estiver
razoável, no caso 75%.
Deverá haver um botão retentivo com a função automático/manual, estando em automático funcionará
conforme descrito acima, estando em manual dois botões pulsantes farão o controle de ligar a bomba
ignorando o nível do sensor, ou seja, enquanto o botão pulsante 1 estiver pressionado a bomba 1 deve
ficar ligada e enquanto o botão pulsante 2 estiver pressionado a bomba 2 deve estar acionada.
24 – ESTACIONAMENTO – Desenvolva a lógica de um estacionamento, conforme descrito a seguir:
• Quando um carro atuar “S1” e houver vagas a cancela referente ao M1 deverá levantar (“S4” indica
cancela de “M1” totalmente levantada), após o carro passar pelo sensor “S2” a cancela deverá fechar
(“S3” indica cancela de “M1” totalmente abaixada).
• Quando um carro atuar “S6” a cancela referente ao M2 deverá levantar (“S8” indica cancela de “M2”
totalmente levantada), após o carro passar pelo sensor “S5” a cancela deverá fechar (“S7” indica cancela
de “M2” totalmente abaixada).
• Se houver 6 carros dentro do estacionamento então não poderá mais entrar (pois o estacionamento
estará lotado).
25– ESTACIONAMENTO – Adicione no estacionamento da questão anterior um botão retentivo, com a

função de desligar, quando ele estiver ativo não será permitido a entrada de carros.
26 – ESTACIONAMENTO – Adicione no estacionamento da questão anterior um botão retentivo, com a

função emergência, ao acioná-lo as duas cancelas devem abrir, e ficar aberta até que o botão seja
desativado.

15. Display de 7 segmentos:
É um display composto de 7 leds colocados de forma estratégica para conseguir formar qualquer número
do sistema decimal, esse led também é capaz de exibir algumas letras.
Exemplo: Monte um circuito com arduino com um display de 7 segmentos anodo comum que faça a
contagem continua dos números de 0 a 3, alternando de 1 em 1 segundo.
const int A=11, B=10, C=12, D=3, E=4, F=5, G=4;
void setup() void dois()
{ {
pinMode(A, OUTPUT); dw(A, LOW);
pinMode(B, OUTPUT); dw(B, LOW);
pinMode(C, OUTPUT); dw(C, HIGH);
pinMode(D, OUTPUT); dw(D, LOW);
pinMode(E, OUTPUT); dw(E, LOW);
pinMode(F, OUTPUT); dw(F, HIGH);
pinMode(G, OUTPUT); dw(G, LOW);
} }
void zero() void tres()
{ {
dw(A, LOW); dw(A, LOW);
dw(B, LOW); dw(B, LOW);
dw(C, LOW); dw(C, LOW);
dw(D, LOW); dw(D, LOW);
dw(E, LOW); dw(E, HIGH);
dw(F, LOW); dw(F, HIGH);
dw(G, HIGH); dw(G, LOW);
} }
void um() void loop()
{ {
dw(A, HIGH); zero();
dw(B, LOW); delay(1000);
dw(C, LOW); um();
dw(D, HIGH); delay(1000);
dw(E, HIGH); dois();
dw(F, HIGH); delay(1000);
dw(G, HIGH); tres();
} delay(1000);
}

Podemos também usar um decodificador para display de 7 segmentos, sua função é converter o código BCD
(binário de 0 a 9) em um código de 7 segmentos, a vantagem de sua utilização é o fato de podermos trabalhar
com apenas 4 saídas ao invés de 7, e sua desvantagem é o fato de podermos usar apenas os números de 0 a 9 no
display. Existem decodificadores para display anodo e catodo comum, mas o do software Tinkercad modelo
CD4511 é apenas para o display catodo comum.
Exemplo: Monte um circuito com arduino

com um display de 7 segmentos anodo comum
que faça a contagem continua dos números
de 0 a 3, alternando de 1 em 1 segundo.
const int A=10, B=13, C=12, D=11;

void setup()
{
pinMode(10, OUTPUT);
}
void zero()
{
digitalWrite(A, 0);
digitalWrite(B, 0);
digitalWrite(C, 0);
digitalWrite(D, 0);
}
void um()
{
digitalWrite(A, 1);
digitalWrite(B, 0);
digitalWrite(C, 0);
digitalWrite(D, 0);
}
void dois()
{
digitalWrite(A, 0);
digitalWrite(B, 1); void loop()
digitalWrite(C, 0); {
digitalWrite(D, 0); zero();
} delay(1000);
void tres() um();
{ delay(1000);
digitalWrite(A, 1); dois();
digitalWrite(B, 1); delay(1000);
digitalWrite(C, 0); tres();
digitalWrite(D, 0); delay(1000);
} }

32
Exercício E
27 – Faça a montagem de um Arduino com 1 display de 7 segmentos com 1 botão retentivo, 2 pulsantes e
programe-o:
• Quando o botão retentivo estiver desapertados e pulsar o botão pulsante 1 então o display deverá
mostrar “1”, após 2 segundos “2”, após mais 2 segundos “3”, após 2 segundos apagar.
• Quando o botão retentivo estiver desapertados e pulsar o botão pulsante 2 então o display deverá
mostrar “3”, após 2 segundos “2”, após mais 2 segundos “1”, após 2 segundos apagar.
• Quando o botão retentivo estiver pressionado e pulsar o botão pulsante 1 então o display deverá
mostrar “A”, após 2 segundos “B”, após mais 2 segundos “C”, após 2 segundos apagar.
• Quando o botão retentivo estiver pressionado e pulsar o botão pulsante 2 então o display deverá
mostrar “C”, após 2 segundos “B”, após mais 2 segundos “A”, após 2 segundos apagar.
28 – Faça a montagem de um Arduino com 1 display de 7 segmentos e 2 botões retentivos, e programe-o:
• Se os dois botões estiverem pressionados o display não deve mostrar nada.

• Se apenas o botão 1 estiver pressionado então o display deve mostrar “4”, “5” e “6” alternando a
cada 2 segundos em ciclo.
• Se apenas o botão 2 estiver pressionado então o display deve mostrar “7” depois “8” e depois “9”
onde fica exibindo o “9” até que mude a posição dos botões, o tempo para trocar cada número
deverá ser de 3 segundos.
• Se os dois botões estiverem desapertados o display deverá piscar o “E” três vezes, e depois
permanecer mostrando o “E” até que seja apertado algum botão, o tempo do pisca-pisca pode ser
definido pelo programador.
29 – Faça a montagem de um Arduino com 1 display de 7 segmentos e 3 botões retentivos e um

decodificador, e programe-o:
• Se o botão retentivo 1 estiver pressionado e:

• Os botões retentivos 2 e 3 estiverem apertados então deverá mostrar 4 no display.
• Apenas um dos botões 2 e 3 pressionados então deverá mostrar 2 no display.
• Os botões retentivos 2 e 3 estiverem desapertados então deverá mostrar 1 no display.
• Se o botão retentivo 1 estiver desapertado e:

• Os botões retentivos 2 e 3 estiverem apertados então deverá mostrar 7 no display.
• Apenas um dos botões 2 e 3 pressionados então deverá mostrar 9 no display.
• Os botões retentivos 2 e 3 estiverem desapertados então deverá mostrar 0 no display.

33
30 – Faça a montagem de um arduino com um display de 7 segmentos, (decodificador opcional), e 3 botões
pulsantes, e programe-o:
• O display deve exibir os números de 0 a 9.

• A cada pulso no botão 1 o display deve aumentar 1 número.
• A cada pulso no botão 2 o display deve diminuir 1 número.
• Sempre que pulsar o botão 3 o display deve voltar para o número zero.
Obs: se o display estiver no nove e der um pulso em botão 1 então ele deverá ir para o 0, e se tiver no zero e der
um pulso no botão 2 ele deve ir para o 9.
31 – SEPARADOR: Após pressionar B1 liga o processo, que só deligará ao pressionar B2, o botão B3 deverá zerar o
display de 7 segmentos. O Processo funcionará da seguinte forma:
Será colocado uma garrafa na posição I (inicial), se ela for metálica a esteira deve move-la para direita até cair na
caixa, se ela não for metálica a esteira deverá move-la para esquerda até cair na caixa. Só será colocada uma
garrafa por vez.
S1, S3 e S4 são sensores capacitivos (detectam qualquer garrafa), S2 é um sensor indutivo (detecta apenas
garrafas metálicas).
Caso o display chegue a 9, após a próxima garrafa cair na caixa ele deverá ir para zero, e começa o processo cíclico
32 – CAIXA D’AGUA – Uma caixa d’água possui dois

sensores, uma bomba, 1 botão de liga-desliga e um
display de 7 segmentos conforme indicado na figura,
faça uma lógica de arduino que sempre que o nível de
água da caixa estiver baixo e o botão estiver ativo a
bomba deve ligar até encher a caixa. O display de 7
segmentos deverá mostrar:
• “d” quando estiver desligada.

• “L” quando estiver ligada, mas não enchendo.
• Ficar alternando entre “L” e “E” quando estiver ligada e enchendo.

34
16. Motor de corrente continua
Os motores de corrente continua (CC) são capazes de girar o eixo de acordo com a tensão colocada nos seus
terminais, ou seja, um motor CC de 5v/1000RPM, atinge uma velocidade de 1000 rotações por minuto se aplicados
5v entre seus terminais, a tensão é proporcional a velocidade, ou seja, se aplicarmos 2,5v o eixo do motor atingirá
500RPM (isso desprezando as perdas internas e perdas externas). Caso invertamos a polaridade o eixo do motor
rodará no sentido contrário.
A corrente máxima fornecida pelos pinos do arduino é de 40mA, como a corrente do motor costuma exceder este
valor o ideal é usar uma fonte externa para energizar o motor, outra vantagem da fonte externa é que poderemos
trabalhar com valor de tensão superior a 5v.
Relé
O relé consiste em uma bobina que quando energizada irá mudar um ou vários contatos, ao desligarmos sua bobina
os contatos voltam a sua posição de repouso. No caso ao colocarmos um relé no arduino devemos escolher um que
sua bobine ative com 5v.
L293D
Consiste em um circuito integrado

capaz de controlar dois motores
simultaneamente com o sistema
ponte H interno, com corrente
máxima de 600mA.

35
Para o exemplo abaixo se deixarmos os pinos 10 e 11 ambos desligados não haverá diferença de potencial nos
terminais do motor, fazendo-o ficar parado. Se energizarmos a saída 10 apenas haverá uma diferença de potencial
onde o pino 10 é o positivo e o pino 11 o negativo então o motor rodará em um sentido. Se energizarmos a saída
11 apenas haverá uma diferença de potencial onde o pino 11 é o positivo e o pino 10 o negativo então o motor
rodará no outro sentido.
Exemplo: Se o botão 1 estiver pressionado o

motor rodará em sentido horário, se o botão
2 estiver pressionado o motor rodará em
sentido anti-horário. O motor usado será de
12v.
int md=11, me=10, b1=6, b2=2;
void setup()
{
pinMode(md, OUTPUT);
pinMode(me, OUTPUT);
pinMode(b1, INPUT);
pinMode(b2, INPUT);
}
void loop()
{
if(digitalRead(b1)==0 &&
digitalRead(b2)==0)
{
digitalWrite(md, 0);
digitalWrite(me, 0);
}
if( digitalRead(b1)==1 &&
digitalRead(b2)==0 )
{
}
if( digitalRead(b1)==0 &&
digitalRead(b2)==1 )
{
}
}

36
Exercício F
33 – Faça a montagem de um arduino com um motor CC e 3 botões.
• Ao pressionar bot2 o motor gira em sentido horário, se ele estiver parado.

• Ao pressionar bot3 o motor gira em sentido anti-horário, se ele estiver parado.
• Ao pressionar bot1 o motor desliga.
34 – Faça a montagem de um arduino com um motor CC e 5 botões.
• Ao pressionar bot2 o motor gira em sentido horário, e só parará quando pressionar bot1.
• Enquanto segurar bot3 o motor gira em sentido horário.
• Ao pressionar bot4 o motor gira em sentido anti-horário, e só parará quando pressionar bot1.
• Enquanto segurar bot5 o motor gira em sentido anti-horário.
35 – BRAÇO TEMPORIZADO – o braço robótico é composto por 3 motores, motor 1 faz o movimento direita,
esquerda, motor 2 faz o movimento subir e descer, motor 3 faz o movimento abrir e fechar garra, usar o motor CC
para eles. No projeto há o sensor S1 que indica se a mais garrafas dentro da caixa, e dois outros sensores
posicionados na esteira movimentada por um motor conforme a figura seguinte, ao pressionar o botão liga inicia
o processo cíclico até que as garrafas da caixa sejam colocadas todas na esteira, o processo consiste:
• O braço movimenta para esquerda

por 2 segundos (ME)
• O braço desce por 3 segundos (MB)
• A garra fecha (FECHAR) e depois de
1 segundo
• O braço sobe por 3 segundos (MC)
• O braço movimenta para direita por
2 segundos (MD)
• O braço abaixa por 2 segundos
• A garra abre (ABRIR) e depois de 1
segundo
• O braço sobe por 2 segundos (MC)
• A esteira movimenta (até S3 ser
atuado)

37
17. Serial Monitor:
O arduino é capaz de comunicar com o computador enquanto executa o programa, caso esteja conectado
de alguma forma, a comunicação é feita através do serial monitor, para isso devemos utilizar os
comandos:
Na void setup( ) identificar que vai usá-lo através do comando:
Serial.begin(9600);
Para escrever na tela do computador utilizamos o comando:
Serial.print("texto a ser exibido"); //antes da abertura do parêntese podemos utilizar ln

para assim que exibir o texto descer para linha debaixo.
Para verificarmos se algo foi digitado usamos o comando:

Serial.available()
Para ver o que foi digitado usamos o comando:
Serial.read()
Exemplo: Faça um programa em arduino que peça ao usuário para digitar a letra A e informe quando ele
acertar.
char letra;
void setup()
{
Serial.begin(9600);
Serial.println("Digite a letra A");
}
void loop()
{
if (Serial.available())
{
letra=Serial.read();
if(letra=='a')
{
Serial.println("a minusculo nao e valido");
}
else if(letra=='A')
{
Serial.println("Obrigado");
}
else
{
Serial.print("voce digitou ");
Serial.print(letra);
Serial.println(" essa nao foi a letra solicitada");
}
}
}

38
Exercício G
36 - Faça a montagem de um arduino com 1 led RGB. E programe-o para quando o usuário digitar no serial
monitor:
• V = o led acenda a cor vermelho
• A = o led acenda a cor amarelo
• Z = o led acenda a cor azul
• D = o led acenda a cor verde
• R = o led acenda a cor magenta
• B = o led acenda a cor branco
• T = o led apague deixando em sua forma original transparente
• Qualquer outra coisa deverá ser exibido código invalido.
37 – Faça a montagem de um arduino com um led. E programe-o para quando o usuário digitar no serial monitor:
• L = o led deverá ficar ligado
• D = o led deverá ficar apagado
• T se o led estiver apagado = o led acenderá por apenas um segundo depois desligará.
• T se o led estiver aceso = o led apagará por apenas um segundo depois acenderá.
• Qualquer outra coisa deverá ser exibido código invalido.
38 - Faça a montagem de um arduino com 1 led RGB e 3 botões pulsantes. E programe-o para quando o usuário
digitar no serial monitor:
• V = o led acenda a cor vermelho

• A = o led acenda a cor amarelo
• Z = o led acenda a cor azul
• Ao pressionar B1 = o led acenda a cor Branco
• Ao segurar B2 = o led acenda piscando entre as cores rosa e verde
• Ao Pressionar B3 = o led apague deixando em sua forma original transparente
• Caso digite qualquer outra letra no serial monitor deverá ser exibido código invalido.
39 - Faça a montagem de um arduino conectado à 2 botões retentivos (BR1, BR2), 2 botões pulsantes (BP1, BP2),
1 Display de 7 segmentos, 1 LED e programe para:
• Se BR1 e BR2 estiverem desapertados e pressionar BP1 então o LED deverá ligar e o display mostrará a
letra “U”
• Se BR1 e BR2 estiverem desapertados e pressionar BP2 então o LED deverá desligar e o display mostrará a
letra “P”
• Se BR1 estiver pressionado e BR2 estiver desapertado o display deverá aparecer a letra “H” e o LED
deverá ficar piscando (intervalo de 200ms ligado e 200ms desligado).
• Se BR1 estiver desapertado e BR2 estiver pressionado o display deverá aparecer a letra “L” e o LED deverá
ficar aceso.
• Se BR1 e BR2 estiverem pressionados e digitar no serial monitor:
• “A” então aparecerá a letra A no display de 7 segmentos
• “B” então aparecerá a letra B no display de 7 segmentos
• “L” então o led deverá ligar
• “D” então o led deverá apagar

39
18. Entrada Analógica
As entradas analógicas são capazes de ler a tensão de um determinado ponto e

transforma em um código binário de 10bits (Conversor A/D de 10bits) a tensão máxima
é +5v a mínima 0v, ou seja se a tensão neste pino for de +5v o Arduino intenderá como
1023 (1023 (decimal) = 1111111111 (binário)) , se a tensão for de 2,5v por exemplo o
arduino intenderá como 512, assim sucessivamente.
LDR
O LDR (Light Dependent Resistor) consiste em uma resistência dependente da luz, ou
seja, quando a incidência de luz sobre ele o componente apresenta uma baixa resistência
(apenas algumas dezenas de ohms), quando ele está em um ambiente escuro sua
resistência aumenta (podendo chegar a alguns mega ohms).
Exemplo: Faça um circuito que ligue uma lâmpada quando o ambiente estiver escuro.
int lamp=12;
void setup()
{
pinMode(lamp, OUTPUT);
}
void loop()
{
if(analogRead(A0)<200)
digitalWrite(lamp, 1);
if(analogRead(A0)>=200)
digitalWrite(lamp, 0);
Obs: Nesse exemplo foi colocado uma

resistência de 1k em serie com o LDR,
usando esse valor de resistência neste
software de simulação temos:
* O LDR no mais escuro, arduino
intendendo cerca de 27,7mv = 5,67
numérico.
* O LDR no mais claro, arduino
intendendo cerca de 3,32v = 679,936
numérico.

40
19. Comando map
O comando map remapeia um número de um intervalo para outro.
map(valor, deMenor, deMaior, paraMenor, paraMaior);
Exemplo:
y = map(x, 0, 50, 100, 200);
o valor de y será um valor entre 100 e 200, pois ele recebe o valor de x que pode variar proporcionalmente entre
0 e 50, ou seja:
• Se x vale 0 então y valerá 100

Exercício H
40 - Faça uma montagem de um arduino com um LDR, uma lâmpada, um botão retentivo e dois botões
pulsantes.
• Se o botão retentivo estiver desapertado significa modo manual então:
• Ao pressionar bot_pul_1 a lâmpada deve ligar
• Ao pressionar bot_pul_2 a lâmpada deve desligar
• Se o botão retentivo estiver pressionado significa modo automático então:

• Quando a luminosidade for menor que 50% deve acender uma lâmpada.
• Quando a luminosidade for maior que 50% deve apagar uma lâmpada.
41 – Faça uma montagem de um arduino com um LDR e uma lâmpada. O arduino deve utilizar o serial
monitor para informar a luminosidade do ambiente de 0 a 100% e quando for menor que 40% acender
uma lâmpada, quando for maior que 40% apagar a lâmpada.
42 – CORTINA – Faça a montagem e programação de uma cortina automatizada controlada por arduino,
com as seguintes configurações:
• Haverá um botão retentivo que definirá o tipo de controle manual/automático.
• Ao colocar no modo automático:
• Se estiver escuro a cortina deverá fechar (haverá um sensor
que indicará quando a cortina fechar totalmente)
• Se estiver claro a cortina deverá abrir (haverá um sensor que
indicará quando a cortina abrir totalmente)
• Ao colocar no modo manual os 4 botões pulsantes passará a
funcionar:
• Botão 1 = ao ser pulsado a cortina fechará totalmente
• Botão 2 = enquanto for segurado a cortina fechará
• Botão 3 = ao ser pulsado a cortina abrirá totalmente
• Botão 4 = enquanto for segurado a cortina abrirá

41
20. PWM
PWM, do inglês Pulse Width Modulation, é uma técnica utilizada por sistemas digitais para variação do valor
médio de uma forma de onda periódica. A técnica consiste em manter a frequência de uma onda quadrada fixa e
variar o tempo que o sinal fica em nível lógico alto. Esse tempo é chamado de duty cycle, ou seja, o ciclo ativo da
forma de onda. No gráfico abaixo são exibidas algumas modulações PWM:
Analisando as formas de onda nota-se que a

frequência da forma de onda tem o mesmo valor
e varia-se o duty cycle da forma de onda. Quando
o duty cicle está em 0% o valor médio da saída
encontra-se em 0 V e consequentemente para
um duty cycle de 100% a saída assume seu valor
máximo, que no caso é 5V. Para um duty cycle de
50% a saída assumirá 50% do valor da tensão, 2,5
V e assim sucessivamente para cada variação no
duty cycle. Portanto, para calcular o valor médio
da tensão de saída de um sinal PWM pode-se
utilizar a seguinte equação:
Vout = (duty cycle/100)* Vcc
Onde:
• Vout – tensão de saída em V;

• duty cycle – valor do ciclo ativo do PWM
em %;
• Vcc – tensão de alimentação em V.
PWM pode ser usada para diversas aplicações, como por exemplo:
• controle de velocidade de motores;

• variação da luminosidade de leds;
• geração de sinais analógicos;
• geração de sinais de áudio.
A placa Arduino Uno possui pinos específicos para saídas PWM e são indicados pelo carácter ‘~’ na frente de seu
número, conforme exibido a seguir:

42
21. Função analogWrite()
A função analogWrite() escreve um valor de PWM em um pino digital que possui a função PWM. Após a chamada
dessa função, o pino passa a operar com uma onda quadrada de frequência fixa e com duty cycle conforme valor
passado pela função. A frequência dessa onda, na maioria dos pinos é em tordo de 490 Hz, porém, os pinos 5 e 6
da Arduino UNO operam em 980 Hz.
Para utilizar a função analogWrite() , deve-se configurar o pino correspondente como saída digital. É interessante
notar que essas saídas não são conversores digital-analógico como o nome sugere, e estes pinos não estão
relacionados às entradas analógicas.
A função analogWrite deve ser utilizada da seguinte forma:
analogWrite(pino, valor);
Onde:
• pino corresponde ao pino que será gerado o sinal PWM;

• valor corresponde ao duty cycle, ou seja, o valor que permanecerá em nível alto o sinal.
O valor deve ser de 0 a 255 onde com 0 a saída permanece sempre em nível baixo e 255 a saída permanece
sempre em nível alto.
Exemplo: faça o controle do brilho de um LED usando um potenciômetro.
const int led=3;

int valor;
void setup()
{
}
void loop()
{
valor = map(analogRead(A5), 0, 1023, 0, 255);
analogWrite(led, valor);
}

43
Exercício I
43 – Faça a montagem de um arduino com 1 led RGB e 3 potenciômetros, onde cada potenciômetro
deverá controlar a cor de um dos pinos do led RGB.
44 – Faça a montagem de um arduino com um motor DC e 5 botões pulsantes, e programe-o para:
• Ao pulsar bot1 o motor deverá girar com 25% de sua velocidade total
• Ao pulsar bot4 o motor deverá girar com 100% de sua velocidade
• Ao pulsar bot5 o motor deverá parar
45 – Faça a montagem de um arduino com um motor DC e 6 botões pulsantes, e programe-o para:
• Ao pulsar bot1 o motor deverá girar com 30% de sua velocidade total para direita
• Ao pulsar bot2 o motor deverá girar com 65% de sua velocidade total para direita
• Ao pulsar bot3 o motor deverá girar com 100% de sua velocidade para direita
• Ao pulsar bot4 o motor deverá girar com 50% de sua velocidade total para esquerda
• Ao pulsar bot5 o motor deverá girar com 100% de sua velocidade para esquerda
• Ao pulsar bot6 o motor deverá parar
46 – Faça a montagem de um arduino com um motor DC e um potenciômetro e um botão retentivo, e

programe-o para que o gire do potenciômetro controle a velocidade do motor, sendo que:
• Se o botão retentivo estiver desapertado o motor funcionará apenas no sentido horário, e:

• Se o potenciômetro estiver todo para a esquerda o motor deverá estar parado e à medida que vai
girando-o para a direita o motor vai aumentando a velocidade proporcionalmente, quando o
potenciômetro estiver no máximo para a direita o motor também deverá estar com velocidade máxima.
• Se o botão retentivo estiver apertado o motor funcionará apenas no sentido anti-horário, e:

• Se o potenciômetro estiver todo para a esquerda o motor deverá estar parado e à medida que vai
girando-o para a direita o motor vai aumentando a velocidade proporcionalmente, quando o
potenciômetro estiver no máximo para a direita o motor também deverá estar com velocidade máxima.
47 – Faça a montagem de um arduino com um motor DC e um potenciômetro, e programe-o para que o

gire do potenciômetro controle a velocidade do motor, sendo que:
• Se o potenciômetro estiver todo para a esquerda o motor deverá estar na velocidade máxima para a
esquerda, à medida que for girando o potenciômetro para direita o motor vai diminuindo sua velocidade
proporcionalmente, quando o potenciômetro estiver no meio o motor deverá ficar parado, e se continuar
girando o potenciômetro para a direita o motor vai aumentando a velocidade proporcionalmente girando
para direita, quando o potenciômetro estiver no máximo para a direito o motor também deverá estar com
velocidade máxima para a direita.

44
22. Interrupção: attachInterrupt()
A interrupção pode ser usada através de um pino digital definido como entrada, ao receber uma mudança de
estado neste pino ele executará um programa feito em uma void e depois volta ao programa principal.
Obs: Nesta void o tempo passa de forma diferente e um delay(1000) não corresponde a 1 segundo, então não é
comum usar o comando delay dentro de uma void de interrupção.
Nem todos os pinos digitais podem ser usados para interrupção, os pinos e quantidade variam de acordo com o
modelo usado, segue alguns modelos com os possíveis pinos:
Para criarmos a interrupção dentro da função void setup inserimos a linha de código:
attachInterrupt(digitalPinToInterrupt(pino), ISR, modo);
ISR (Interrupt Service Routine) = nome da void que deseja chamar.
modo: define quando a interrupção deve ser ativada. Quatro constantes estão predefinidos como valores válidos:
• LOW acionar a interrupção quando o estado do pino for LOW,

• CHANGE acionar a interrupção quando o sempre estado do pino mudar
• RISING acionar a interrupção quando o estado do pino for de LOW para HIGH apenas,
• FALLING acionar a interrupção quando o estado do pino for de HIGH para LOW apenas.
Alguns modelos de arduino suportam também:
• HIGH acionar a interrupção quando o estado do pino for HIGH.
Obs: caso o programa possua duas interrupções ele executará uma de cada vez, por ordem de acionamento.

45
Exemplo: Faça um programa que contenha dois botões pulsantes e dois leds, ao pressionar o botão 1 o led 1
deverá ligar por 2 segundos, se durante esses dois segundos o botão 2 for acionado então assim que o led 1
apagar o led 2 deverá ligar por 2 segundos.
const int b1=2, b2=3, verm=11, verd=12;

int xis;
void setup() {
attachInterrupt(digitalPinToInterrupt(b2), welbert, HIGH);
pinMode(verm, OUTPUT);
pinMode(verd, OUTPUT);
pinMode(b1, INPUT);
pinMode(b2, INPUT);
}
void welbert() {
xis=1;
}
void loop() {
if (digitalRead(b1)==1)
{
xis=0;
digitalWrite(verm, 1);
delay(2000);
digitalWrite(verm, 0);
if (xis==1)
{
digitalWrite(verd, 1);
delay(2000);
digitalWrite(verd, 0);
}
}
}
Exercício J
Faça as questões deste exercício usando Interrupção, não é valido usar o comando millis();
48 - Faça um programa que contenha dois botões pulsantes e um led, e faça:
• Ao pressionar o botão 1 o led deverá ligar por 5 segundos.

• Se durante os 5 segundos for pressionado o botão 2, então o led deve apagar nesse mesmo instante.
49 - Faça um programa que contenha dois botões pulsantes e dois leds, e faça:
• Ao pressionar o botão 1 o led 1 deverá ligar por 2 segundos

• Se o botão 2 for pressionado enquanto o led 1 estiver ligado então o led 2 deverá ligar no mesmo instante
e desligar apenas quando o led 1 desligar.

46
23. Tempo
No arduino temos 4 comandos que utilizam o tempo, são eles:
• delay (“tempo”); = Pausa o programa por um tempo, este tempo é colocado em milissegundos, ou seja, se
colocar tempo de 1000 equivalerá a 1 segundo.
• delayMicroseconds (“tempo”); = Pausa o programa por um tempo, este tempo é colocado em
microssegundos, ou seja, se colocar tempo de 1000 equivalerá a 0,001 segundo. O valor máximo é de
16383.
• millis(); = Retorna quanto tempo se passou em milissegundos desde que o arduino foi ligado, esse tempo
é reiniciado caso o arduino fique aproximadamente 50 dias ligado.
• micros(); = Retorna quanto tempo se passou em microssegundos desde que o arduino foi ligado, esse
tempo é reiniciado caso o arduino fique aproximadamente 70 minutos ligado. Observação o arduino não
contará de 1 em 1 microssegundos, o valor pode ser de 4 em 4 microssegundos, 8 em 8 microssegundos,
ou outro valor dependerá do modelo de seu arduino.
Obs: para variáveis inteiras normalmente usávamos o “int”, porem para o comando millis é aconselhável usar o
comando “unsigned long”, devido o número gerado poder exceder o comportado em um número do tipo “int”,
as variáveis funcionam com a seguinte capacidade:
• int = armazena números de valores -32.768 à +32.767 o que corresponde a 16 bits

• unsigned int = armazena números de valores 0 à +65.535 o que corresponde a 16 bits
• long = armazena números de valores -2.147.483.648 à +2.147.483.647 o que corresponde a 32 bits
• unsigned long = armazena números de valores 0 à +4.294.967.295 o que corresponde a 32 bits
Exemplo: Faça a montagem de um arduino com dois botões pulsantes e um led, e faça uma programação que
ligue o led por 8 segundos caso o botão 1 seja pressionado, porem se o botão 2 for pressionado durante os 8
segundos o led deverá apagar no mesmo instante.
const int b1=13, b2=9, led=3;

unsigned long tempo;
void setup()
{
pinMode(b1, INPUT);
pinMode(b2, INPUT);
}
void loop()
{
if (digitalRead(b1)==1)
{
tempo = millis();
while (digitalRead(b2)==0 && (millis()-tempo)<8000)
digitalWrite(led, 1);
digitalWrite(led, 0);
}
}

47
Exercício K
Faça as questões deste exercício usando o comando millis(); não é valido usar Interrupção.
50 - Faça um programa que contenha dois botões pulsantes e um led, e faça:
• Ao pressionar o botão 1 o led deverá ligar por 5 segundos.

• Se durante os 5 segundos for pressionado o botão 2, então o led deve apagar nesse mesmo instante.
51 - Faça um programa que contenha dois botões pulsantes e dois leds, e faça:
• Ao pressionar o botão 1 o led 1 deverá ligar por 2 segundos

• Se o botão 2 for pressionado enquanto o led 1 estiver ligado então o led 2 deverá ligar no mesmo instante
e desligar apenas quando o led 1 desligar.
52 – Faça um programa que contenha dois botões pulsantes, 1 botão retentivo e 2 Leds, e faça:
• Quando o botão retentivo estiver desapertado o led 1 deve estar desligado.

• Quando o botão retentivo estiver atuado o led 1 deverá ficar piscando em intervalos de 1 segundo ligado
e 1 segundo desligado.
• Ao pressionar o botão pulsante 1 o led 2 deve ligar.
• Ao pressionar o botão pulsante 2 o led 2 deve desligar.
24. Sensores
Ultrassônico HC-SR04
O Sensor Ultrassônico é um sensor usado para medir distância entre ele e o objeto à frente dele, o modelo HC-
SR04 permite que você faça leituras de distâncias entre 2 cm e 4 metros, com precisão de 3 mm.
O funcionamento se baseia no envio (trigger) de sinais ultrassônicos pelo sensor, que aguarda o retorno (echo) do
sinal, e com base no tempo entre envio e retorno, calcula a distância entre o sensor e o objeto detectado.

48
Exemplo: Faça um circuito que mostre a distância de um objeto em relação ao ultrassônico em centímetros no
serial monitor.
const int trig = 4, echo = 3;

float distancia;
void setup()
{
pinMode (trig, OUTPUT);
pinMode (echo,INPUT);
digitalWrite(trig, 0);
Serial.begin (9600);
}
void loop()
{
delay(10);
distancia = pulseIn (echo, HIGH);

distancia = distancia/58;
Serial.print (distancia);
Serial.println (“cm”);
}
Foi usando no programa um comando novo, o pulseIn, seu funcionamento:
O comando conta o tempo em nível lógico alto (HIGH ou 1) ou o tempo em nível logico baixo (LOW ou 0), no
exemplo acima está contando o tempo de nível logico alto que o pino echo recebe, quando o pino recebe nível
lógico alto ele começa a contar o tempo em microssegundos, ao mudar o nível logico para baixo ele retorna o
valor do tempo em distância. Esse comando consegue contar tempos de 10 microssegundos a 3 minutos de
duração.
Ao invés de distancia/58 é comum encontramos um calculo como distancia*0.0170145 que é similar, pois dividir
por 58 é o mesmo que multiplicar por 0,017, mas de onde vem esse número? Basicamente o sensor envia um
sinal que trabalha com a velocidade do som que é 340,29 m/s, como estamos trabalhando com milissegundos ao
invés de segundos e centímetro ao invés de metro o valor a ser multiplicado devia ser 0,034 porem o sinal é
enviado bate no objeto para depois voltar, ou seja, o tempo está dobrado pois está contando ida e volta do sinal,
então dividido 0,034 por 2 temos 0,017.
Ultrassônico PING))) da Parallax
Este sensor basicamente junta os pinos Trigger e Echo do

sensor ultrassônico HC-SR04 em um único pino
denominado Signal.

49
Exemplo: Faça um circuito que mostre a distância de um objeto em relação ao ultrassônico em centímetros no
serial monitor.
const int sig = 2;

float distancia;
void setup()
{
pinMode (sig, OUTPUT);
Serial.begin (9600);
digitalWrite(sig, 0);
}
void loop()
{
pinMode(sig, OUTPUT);
digitalWrite(sig, HIGH);
delay(10);
digitalWrite(sig, LOW);
pinMode(sig, INPUT);
distancia = pulseIn(sig, HIGH);
distancia = distancia/58;
Serial.print (distancia);
Serial.println ("cm");
}
Sensor de Umidade
O Sensor de umidade (1) é usado para medir a umidade presente no
solo, sua ligação é similar ao de leitura de um potenciômetro, ou seja,
possui 3 pinos +Vcc, GND e Sinal, o pino de sinal irá em um pino de
entrada analógica do arduino.
Sensor de Força
O Sensor de força (2) é usado para medir a força que está sendo
aplicada a ele, sua ligação é similar ao de LDR, ou seja, possui 2 pinos
então é necessário acrescentarmos um resistor para termos os 3
pontos +Vcc (pino isolado do sensor), GND (Pino isolado do resistor) e
Sinal (pino comum entre resistor e sensor), o pino de sinal irá em um
pino de entrada analógica do arduino.
Sensor Flexível
O Sensor Flexível (3) é usado para medir o ângulo da inclinação entre
sua ponta e sua base, sua ligação é similar ao de LDR, ou seja, possui 2
pinos então é necessário acrescentarmos um resistor para termos os 3
pontos +Vcc (pino isolado do sensor), GND (Pino isolado do resistor) e
Sinal (pino comum entre resistor e sensor), o pino de sinal irá em um
pino de entrada analógica do arduino.

50
Exercício L
53 – Faça a montagem de um arduino e um sensor ultrassônico e programe-o:
• O arduino deve mostrar no serial monitor a distância em centímetros, que ele se encontra do objeto,
porem ele só deverá mostrar valores quando sofrer alteração, ou seja, se ele medir um objeto a 15cm e
este objeto não mover, ele não poderá ficar repetindo 15cm, ele só mostrará outro valor após esse objeto
afastar ou aproximar.
54 – Faça a montagem de um arduino com um sensor de umidade, um sensor de força e um sensor flexível, e
programe-o para aparecer no serial monitor:
• Umidade Baixa: Quando a umidade estiver abaixo de 20%

• Umidade Aceitável: Quando a umidade estiver de 20% a 80%
• Umidade Alta: Quando a umidade estiver acima de 80%
• Valor da força em Newtons que está sendo aplicada no sensor de força
• Valor da inclinação em graus que está sendo aplicado no sensor flexível
55 – PORTÃO – Faça a lógica de um portão conforme descrito a seguir (SP será um sensor ultrassônico)
• Ao pressionar o BOT com o portão aberto, então o portão deverá fechar.

• Ao pressionar o BOT com o portão fechado, então o portão deverá abrir.
• Se o portão estiver fechando e o sensor SP detectar algo passando o portão deverá parar de fechar e deverá
abrir para evitar colidir com algo que esteja passando pelo portão (a abertura do portão é de 2m).
• Se o portão estiver totalmente aberto a mais
de 30 segundos, então o portão deverá
fechar.
• Ao pressionar o BOT com o portão em
movimento, então o portão deverá parar, e
após pressionar o BOT novamente ele
deverá mover no sentido oposto ao qual
estava indo.
56 – MISTURADOR: Quando pressionar o botão de “LIGA”, realiza o

processo em ciclo:
• Coloca-se o produto A no silo até atingir 60cm no ultrassônico.

• Coloca-se o produto B no silo até atingir 10cm no ultrassônico.
• O motor liga por 5 segundos para misturar.
• O liquido misturado é despejado pela saída até atingir 110cm
no ultrassônico.
Ao pressionar desligar o processo deve funcionar até o silo esvaziar e

depois parar.

51
57 – BIMANUAL – Os bimanuais serve para o operador de uma maquina utilize as duas mãos no momento de seu
acionamento, assim evita com que ele tente usar uma das mão no botão e a outra na máquina, o que pode
ocasionar acidente, porem não podemos em uma lógica de bimanual simplesmente colocar os dois botões em
série, pois fazendo isso basta o operador prender um dos dois botões com um fita ou algo pesado e utilizar o
acionamento apenas com uma das mão através no outro botão, para evitar essa situação faça a lógica de
operação desse bimanual com as seguintes especificações, utilize um led para representar a máquina.
• Se o botão de emergência estiver acionado a

máquina não pode ligar.
• Se os dois botões de acionamento forem
pressionados com menos de 1 segundo de
diferença, então a máquina é acionada e
ficará ligada enquanto os dois botões
estiverem sendo pressionados.
58 – ESTACIONAMENTO: Faça a lógica de um estacionamento conforme descrito a seguir (S1 será um sensor
ultrassônico de 4 pinos e S2 um sensor ultrassônico de 3 pinos)
• Entrada de Carros: O carro atua “S1” a cancela referente ao

M1 deverá levantar (Sensor flexível em 0° indica cancela de
“M1” totalmente levantada), após o carro passar totalmente
pelo sensor “S2” a cancela deverá fechar (Sensor flexível em
180° indica cancela de “M1” totalmente abaixada).
• Saída de Carros: O carro atua “S2” a cancela referente ao M1

deverá levantar (Sensor flexível em 0° indica cancela de “M1”
totalmente levantada), após o carro passar totalmente pelo
sensor “S1” a cancela deverá fechar (Sensor flexível em 180°
indica cancela de “M1” totalmente abaixada).
• Se o estacionamento estiver em funcionamento (botão

“DESLIGAR” não pressionado) e não houver 6 carros dentro do
estacionamento então os carros podem entrar e sair.
• Se houver 6 carros dentro do estacionamento (estacionamento estará

lotado) ou se o estacionamento estiver fora de funcionamento (botão
“DESLIGAR” pressionado), então os carros podem apenas sair.
• Ao pressionar o botão “EMERGENCIA”, a cancela deve abrir para que

os carros possam sair do estacionamento.
• Ao soltar o botão “EMERGENCIA” a cancela deve fechar e o

estacionamento deverá voltar a funcionar normalmente.

52
25. Display LCD 16x2:
Consiste em um display capaz de escrever

números e letras em uma matriz com 16
colunas e 2 linhas:
Comandos a ser usado na programação do

arduino:
• No inicio
#include <LiquidCrystal.h>
LiquidCrystal lcd(A, B, C, D, E, F);
Obs: As letras de A à F devem ser substituídas por:

A = Numero do pino do arduino que foi conectado no Register Select (RS) do display
B = Numero do pino do arduino que foi conectado no Enable (E) do display
C = Numero do pino do arduino que foi conectado no Data 4 (DB4) do display
D = Numero do pino do arduino que foi conectado no Data 5 (DB5) do display
E = Numero do pino do arduino que foi conectado no Data 6 (DB6) do display
F = Numero do pino do arduino que foi conectado no Data 7 (DB7) do display
• Na void setup() devemos informar o display para que o arduino o reconheça, com o comando:
lcd.begin(16, 2);
• Instruções para escrita:

lcd.clear(); //serve para apagar tudo que estiver escrito no display
lcd.setCursor(numero_da_coluna, numero_da_linha); //move o cursor
lcd.print("texto a ser escrito"); //Escreve o texto no display
Exemplo: Monte um circuito com 1 arduino, 3 botões e um display de LCD 16x2, e faça:
Ao iniciar o display pedirá ao usuário para apertar o segundo botão e:

Se o usuário apertar o segundo botão o display informara que ele acertou.
Se o usuário apertar outro botão o display informara que ele errou.

53
if(dr(b2)==1)
#define pm pinMode {
#define dr digitalRead lcd.clear();
while(dr(b2)==1)
LiquidCrystal lcd(8, 9, 10, 11, 12, 13); {
lcd.setCursor(0, 0);
int b1=2, b2=3, b3=4; lcd.print("Obrigado");
lcd.setCursor(0, 1);
void setup() lcd.print("Voce acertou");
{ }
lcd.begin(16, 2); lcd.clear();
pinMode(b1,INPUT); }
pinMode(b2,INPUT); if( dr(b1)==1 || dr(b3)==1 )
pinMode(b3,INPUT); {
} lcd.clear();
while( dr(b1)==1 || dr(b3)==1 )
void loop() {
{ lcd.setCursor(0, 0);
lcd.setCursor(0, 0); lcd.print("Voce errou");
lcd.print("Pressione B2"); lcd.setCursor(0, 1);
lcd.setCursor(0, 1); lcd.print("tente outra vez");
lcd.print("Por favor"); }
lcd.clear();
}
}

54
Existe também o display de LCD com uma placa I2C acoplada.
A placa I2C converte os pinos usados no display para dois únicos pinos denominados SDA e SCL, assim
podemos usar essas respectivas portas do arduino para o display, e liberar os pinos digitais para as demais
ligações que o circuito poderá prover.
Considerando o exemplo anterior apenas trocaríamos as linhas:

LiquidCrystal lcd(8, 9, 10, 11, 12, 13);
Por:
#include <Adafruit_LiquidCrystal.h>
Adafruit_LiquidCrystal lcd(0);

55
Exercício M
59 – Faça a montagem de um arduino com um display LCD de 16x2, 2 botões pulsantes e programe-o:
• Se os botões estiverem desapertados deve aparecer pressione um botão.

• Ao pressionar o botão 1 no display aparecerá você está apertando o botão 1.
• Ao pressionar o botão 2 no display aparecerá você está apertando o botão 2.
60 – Faça a montagem de um arduino com um display LCD de 16x2, 3 botões pulsantes e programe-o:
• O display inicialmente mostrará o número 0.

• Sempre que pulsar o botão 1 no display o número mostrado deverá aumentar.
• Sempre que pulsar o botão 2 no display o número mostrado deverá diminuir.
• Sempre que pulsar o botão 3 no display o número voltará para 0.
61 - Faça a montagem de um arduino conectado à 1 display de LCD, 2 botões pulsantes, 1 LED RGB e
programe para:
• No display aparecerá na 1ª linha (cor selecionada:) e na 2ª linha (“cor atual que o led está exibindo”)
• Os botões devem trocar as cores do LED, sendo:
• Botão 1 avança as cores
• Botão 2 retorna as cores
• A ordem das cores serão (Transparente, Vermelho, Azul Escuro, Azul Claro, Amarelo, Verde, Rosa, Branco)
• As cores devem rodar em ciclo, ou seja, se der mais um pulso após chegar na cor Branca, ele deve voltar
ao Transparente.
62 – CALCULADORA: Faça a montagem de um arduino com um display LCD de 16x2, 3 botões

pulsantes (BPsobe, BPdesce, BPenter), e programe-o para funcionar como uma calculadora sendo que:
I. Na primeira linha aparecerá: “Escolher numero:”, na segunda linha

aparecerá inicialmente o numero zero e poderá altera-lo para mais
ou para menos com os botões BPdesce e BPsobe.
II. Depois de escolhido o primeiro numero aperte enter.
III. Na primeira linha aparecerá: “Operação:”, na segunda linha
aparecerá inicialmente o sinal de mais e poderá altera-lo na ordem
(+,–, *, /) com os botões BPdesce e BPsobe.
IV. Depois de escolhida a operação aperte enter.
V. Na primeira linha aparecerá: “Escolher numero:”, na segunda linha
aparecerá inicialmente o numero zero e poderá altera-lo para mais
ou para menos com os botões BPdesce e BPsobe.
VI. Depois de escolhido o segundo numero aperte enter.
VII. Na primeira linha aparecerá: “1º numero escolhido” “sinal da
operação escolhida” “2º numero escolhido” e na segunda linha
deverá aparecer o resultado.
VIII. Ao pressionar enter o processo reinicia.

56
63 – DESAFIO – JOGO GENIUS: Faça a montagem de um arduino com um display LCD de 16x2, 5
botões pulsantes (BL1, BL2, BL3, BL4, Binicio), e 4 led’s, e programe-o para:
• Cada botão corresponde a um led. O quinto botão inicia

um novo jogo.
• Um dos led irá acender e apagar a pessoa deve apertar o
botão correspondente ao que acendeu, para marcar pontos.
• O led que havia acendido antes irá acender e apagar
novamente, e outro led irá acender e apagar logo após
(poderá repetir o led se desejar) a pessoa deverá apertar os
botões correspondente aos leds na ordem que eles
acenderam, para marca ponto.
• O jogo continua sempre aumentando uma cor a cada
rodada até que a pessoa erre a sequência, nesse momento
o jogo finaliza.
• O display deve exibir o recorde do jogo na primeira linha,
e a pontuação atual do jogador na segunda linha.
64 – DESAFIO – JOGO GENIUS 2: O jogo funcionará similar ao anterior porém a cada rodada ele não
deve repetir a sequência anterior e aumentar mais uma cor, nesta versão a cada rodada os leds devem ser
escolhidos aleatoriamente, mas sempre aumentando um a cada rodada.

57

Circuitos Microcontrolados (Arduino) - V2023

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Circuitos Microcontrolados (Arduino) - V2023

Enviado por

Direitos autorais:

Formatos disponíveis

Circuitos

Circuitos Microcontrolados Welbert O. Silva 1

1.1 Histórico dos Microcontroladores

Circuitos Microcontrolados Welbert O. Silva 2

1.2 Microcontroladores versus Microprocessadores

Um microcontrolador difere de um microprocessador em vários aspectos. Primeiro e o mais importante, é a sua

Circuitos Microcontrolados Welbert O. Silva 3

Os apaixonados por tecnologia certamente já

Sua placa consiste em um

A grande maioria de placas inclui um regulador linear de 5 volts e um oscilador de cristal de

Circuitos Microcontrolados Welbert O. Silva 4

setup( ) – Inserida no inicio, na qual pode ser usada

loop( ) – Chamada para repetir um bloco de

Circuitos Microcontrolados Welbert O. Silva 5

Um algoritmo não representa, necessariamente, um programa de computador, e sim os passos

Exemplo: Algoritmo dos 30 minutos de um dia (em forma de fluxograma):

Circuitos Microcontrolados Welbert O. Silva 6

C é uma linguagem de programação compilada de propósito geral, estruturada, imperativa,

Circuitos Microcontrolados Welbert O. Silva 7

6.1 – Parte 1 – Adicionando as bibliotecas, constantes e variáveis

#define NomeDaConstante Valor

#define welbert 200

Linha para direita com tamanho 200;

Circuitos Microcontrolados Welbert O. Silva 8

#define welbert 200

int NomeDaVariável; ou int NomeDaVariável = ValorInicial;

float NomeDaVariável; ou float NomeDaVariável = ValorInicial;

char NomeDaVariável; ou char NomeDaVariável = ‘ValorInicial’;

Circuitos Microcontrolados Welbert O. Silva 9

const int welbert = 200;

6.2 – Parte 2 – Configurando o hardware

6.3 – Parte 3 – Programando as funções

Circuitos Microcontrolados Welbert O. Silva 10

7.1 – Saídas Digitais

Exemplo: LED conectado ao Arduino

pinMode (NumeroDoPino, OUTPUT);

utilizado para definir que o pino será uma saída.

digitalWrite (NumeroDoPino, LOW);

utilizado para desligar o LED (podemos substituir a palavra LOW pelo

digitalWrite (NumeroDoPino, HIGH);

utilizado para ligar o LED (podemos substituir a palavra HIGH pelo

Circuitos Microcontrolados Welbert O. Silva 11

const int Pedro = 3;

Vamos entender nossa programação:

Circuitos Microcontrolados Welbert O. Silva 12

const int Pedro = 3, Maria = 12;

digitalWrite (Pedro, 0);

Circuitos Microcontrolados Welbert O. Silva 13

Existem dois modos de adicionar um comentário:

Faça o código de um LED piscando em intervalos de 0,5 segundos

//Definindo o pino a ser usado

Circuitos Microcontrolados Welbert O. Silva 14

6 – SEMAFORO - Implemente na questão 1 o semáforo do pedestre ficando com seguinte sequência:

Circuitos Microcontrolados Welbert O. Silva 15

Com botão desapertado o arduino entenderá como HIGH (1).

Com o botão pressionado o arduino entenderá como LOW (0).

Com botão desapertado o arduino entenderá como LOW (0).

Com o botão pressionado o arduino entenderá como HIGH (1).

* pinMode (NumeroDoPino, INPUT);

* pinMode (NumeroDoPino, INPUT_PULLUP);

utilizado no sistema direto para definir o pino como uma entrada.

utilizado para verificar se tem energia ou não chegando ao pino do arduino.

Circuitos Microcontrolados Welbert O. Silva 16

const int LED = 3, BOT = 7;