Você está na página 1de 82

Microprocessadores

Prof. Pedro Fernandes


Aula 4
Programação e Projetos com
Arduino
O que é o Arduino?

• Uma plataforma de desenvolvimento de microcontroladores que, em junção com seu


Meio de Desenvolvimento Integrado (IDE), permite a criação de diversos dispositivos de
controle de sistemas.

• É uma plataforma Open Source, ou seja, seus arquivos, esquemáticos e códigos estão
disponíveis gratuitamente a todos. Com isso, o Arduino também satisfazer a qualquer
projeto, além de permitir a confecção e venda de clones e o uso de sua biblioteca para
qualquer projeto sem haver necessidade de qualquer permissão para tal.
Como instalar o Arduino
• www.arduino.cc
Fazendo o primeiro programa

• O IDE do Arduino tem linguagem de programação chamado Wiring, baseado em


C/C++;

• Todo código Arduino possui duas partes: setup, com instruções que ocorrerão
somente uma vez; e loop com instruções que se repetem.
Pisca Pisca
1. int led = 13;

2. void setup() {
3. pinMode(led,OUTPUT);
4. }

5. void loop() {
6. digitalWrite(led,HIGH);
7. delay(1000);
8. digitalWrite(led,LOW);
9. delay(1000);
10. }
Explicação do Código

1. Declaração de Variável, nesse caso, do tipo inteiro int. Essa declaração é útil, pois, caso seja necessário alterar o valor
da variável futuramente, é necessário somente alterar essa linha;
2. void setup () é uma das duas funções obrigatórias no Wiring. O que for colocado nesta função ocorrerá somente ao
inicializar o código;
3. pinMode(x,y) é usado para designar os pinos do board. São necessários dois argumentos: o argumento x designa o
pino a ser acionado; y determina se o pino será uma entrada (INPUT) ou saída (OUTPUT);
5. void loop () é a segunda função obrigatória. As instruções colocadas nesta função serão repetidas enquanto o
Arduino estiver ligado;
6. digitalWrite(a,b) é usado para levar uma saída para algum nível lógico: 0 (LOW) ou 1 (HIGH). O argumento a determina o
pino a ser alterado e b o estado para o qual este deve ir;
7. delay(T) faz o programa pausar por T milissegundos.
Acender LED
1. const int led = 9;

2. void setup() {
3. pinMode(led,OUTPUT);
4. digitalWrite(led,HIGH);
5. }

6. void loop() {
7. }
Fazer LED Piscar
1. const int led = 9; 6. void loop() {
2. int i; 7. for(i=100;i<=1000;i=i+100)
8. {
3. void setup() { 9. digitalWrite(led,HIGH);
4. pinMode(led,OUTPUT); 10.delay(1000);
5. } 11.digitalWrite(led,LOW);
12.delay(1000);
13.}
14.}
Explicação do Código

1. Na declaração de variável, além de declarar o tipo inteiro int, pode-se especificar que a variável
é constante const, ou seja, o seu valor não será alterado durante a compilação;

7. O comando for (inicialização;condição;pós-instrução) é uma função de repetição, ou seja, toda


instrução escrita dentro das chaves que seguem o for serão repetidas até alcançarem
determinado critério de parada. O comando for possui três parâmetros:
 inicialização: é possível declarar variáveis e/ou atribuir valores a estas;
 condição: onde é declarada qual condição deve ser satisfeita para que a repetição continue;
 pós-instrução: linha de código que deve ser realizada ao fim de cada repetição das instruções
entre chaves.
Modulação por Largura de Pulso (PWM)

• Caso seja desejado um valor de tensão diferente de 0 ou 5 Volts, é necessário


usar PWM.
• Algumas entradas seletas do Arduino podem gerar sinais PWM que podem
simular entradas analógicas. Esses pinos são discriminados pelo símbolo ~ na
placa, são eles: 3, 5, 6, 9, 10 e 11.
• A saída PWM é um valor digital de 8 bits, ou seja, ele possui valores de 0 até 255
(28-1).
Controle de Ciclo de Trabalho
• Dessa forma, no comando analogWrite(a,b) é indicado qual o valor do ciclo de
trabalho do pulso no parâmetro b;
• O valor 0 indica 0% de ciclo de trabalho, ou seja, o valor do sinal é sempre 0;
• O valor 255 indica 100% de ciclo de trabalho, fazendo do valor ser sempre 1;
• O valor 127 indica 50% de ciclo de trabalho, dessa forma, em metade do
período do pulso o valor será 1 e, na outra metade, o valor será 0;
Fazer LED com Variação de Luminosidade
1. const int led=9; 5. void loop() {
6. for(int i=0;i<256;i++)
2. void setup() { 7. {
3. pinMode(led,OUTPUT); 8. analogWrite(led,i);
4. } 9. delay(10);
10.}
11.for(int i=255;i>=0;i--)
12.{
13. analogWrite(led,i);
14. delay(10);
15.}
16.}
Entradas Digitais

• Muitas vezes é desejado um


controle de acionamento de um
circuito;
• Um dispositivo que pode-se usar é o
botão de controle.
Fazer LED controlado por botão
1. const int led=9; 7. void loop() {
2. int botao=2; 8. if (digitalRead(botao)==LOW)
9. {
3. void setup() { 10. digitalWrite(led,LOW);
4. pinMode(led,OUTPUT); 11.}
5. pinMode(botao,INPUT); 12.else
6. } 13.{
14. digitalWrite(led,HIGH);
15.}
16.}
5. Como a variável botao é uma entrada, então o segundo
parâmetro da instrução pinMode será INPUT

8-15.
O comando if() faz com que as instruções seguintes dependam da
condição colocada entre os parênteses; se a condição não for

Explicação do satisfeita, então as instruções depois do comando else que serão


realizadas.

Código 8. Na condição do if, são é usado ‘==‘ para verificar se duas


variáveis são iguais. Outras comparações são:
• > - Maior
• >=- Maior ou igual
• < - Menor
• <=- Menor ou igual
• != - Diferente
• Se é desejado um circuito onde não é
necessário ficar segurando um botão para que
ele continue aceso, um simples comando if-else
não é o suficiente para tal por causa do efeito
bouncing.
Efeito
Bouncing • Este efeito ocorre pois o botão é um dispositivo
mecânico e, por isso, a transição de um estado
não-pressionado é bastante turbulenta,
ocorrendo transições entre os dois estados no
momento logo depois do acionamento.
1. Guardar os estados anterior e atual do botão
(inicializado em LOW);
2. Ler o estado atual do botão;
3. Se o estado atual for diferente do estado
anterior, esperar 5 ms;

Fazendo o 4. Depois dos 5 ms, reler o estado do botão e


usar essa informação como o estado atual;
Debouncing 5. Se o estado anterior era LOW e agora é HIGH,
trocar o estado do LED;
6. Colocar o estado anterior como sendo igual ao
estado atual;
7. Voltar ao item 2.
Fazer LED com debounce
10. void loop() {
1. const int led = 9; 11. if (anterior != digitalRead(botao))
2. const int botao = 3; 12. {
3. boolean anterior = LOW;
13. delay(100);
4. boolean atual = LOW;
5. boolean ledligado = false; 14. atual = digitalRead(botao);
15. }
6. void setup() { 16. if (anterior == LOW && atual == HIGH)
7. pinMode(led, OUTPUT); 17. {
8. pinMode(botao, INPUT);
18. ledligado = !ledligado;
9. }
19. }
20. anterior = atual;
21. digitalWrite(led, ledligado);
22.}
3-5. Declaração de variável lógicas (boolean) – Podem ser HIGH/LOW, true/false ou
1/0.

10-19.
Função criada para este uso específico, chamado no loop na linha 21. A função é
declarada do seguinte modo:
<tipo de variável de saída> nome da função (declaração das variáveis de entrada)

Explicação do 18. A instrução return declara a saída da função criada.

Código 21. Ao chamar uma função deve-se fazer a seguinte sintaxe:


<variável que irá receber a saída da função> = nome da função(valores para a entrada
da função)

22. No comando if é usado o comando ‘&&’, que significa que as duas condições
impostas devem ser obedecidas para a implementação das instruções que seguem.
Caso fosse necessária apenas uma instrução, usa-se ‘||’.

24. Usa-se a exclamação para trocar valores lógicos. Por exemplo, se a=HIGH, então
!a=LOW.
• Com os conhecimentos de Modulação de
Largura de Pulso e a leitura com “debounce” da
leitura, podemos construir o controle de um
LED RGB;
Controle de
LED RGB • Os LEDs RGB constituem-se de três LEDs com
cátodo compartilhado. Os três LEDs possuem
cores vermelha, verde e azul que podem ser
combinadas para gerar as cores rosa, azul claro,
amarela e branca
Controle de LED RGB
1. const int ledAzul = 9; 14. void loop () {
2. const int ledVerde = 10; 15. if (anterior != digitalRead(botao))
3. const int ledVerm = 11; 16. {
4. const int botao = 2;
17. delay(100);

5. boolean anterior = LOW; 18. atual = digitalRead(botao);


6. boolean atual = LOW; 19. }
7. int estado = 0; 20. if (anterior == LOW && atual == HIGH)
21. {
8. void setup () {
22. estado++;
9. pinMode (ledAzul, OUTPUT);
23. }
10. pinMode (ledVerde, OUTPUT);
11. pinMode (ledVerm, OUTPUT); 24. anterior = atual;
12. pinMode (botao, INPUT); 25. if (estado == 8)
13.} 26. estado = 0;
Controle de LED RGB
27. if (estado == 0) { 42. if (estado == 3) { 57. if (estado == 6) {
28. digitalWrite(ledVerm, LOW); 43. digitalWrite(ledVerm, LOW); 58. digitalWrite(ledVerm, HIGH);
29. digitalWrite(ledVerde, LOW); 44. digitalWrite(ledVerde, LOW); 59. digitalWrite(ledVerde, HIGH);
30. digitalWrite(ledAzul, LOW); 45. digitalWrite(ledAzul, HIGH); 60. digitalWrite(ledAzul, LOW);
31. } 46. } 61. }
32. if (estado == 1) { 47. if (estado == 4) { 62. if (estado == 7) {
33. digitalWrite(ledVerm, HIGH); 48. digitalWrite(ledVerm, HIGH); 63. digitalWrite(ledVerm, HIGH);
34. digitalWrite(ledVerde, LOW); 49. digitalWrite(ledVerde, LOW); 64. digitalWrite(ledVerde, HIGH);
35. digitalWrite(ledAzul, LOW); 50. digitalWrite(ledAzul, HIGH); 65. digitalWrite(ledAzul, HIGH);
36. } 51. } 66. }
37. if (estado == 2) { 52. if (estado == 5) { 67.}
38. digitalWrite(ledVerm, LOW); 53. digitalWrite(ledVerm, LOW);
39. digitalWrite(ledVerde, HIGH); 54. digitalWrite(ledVerde, HIGH);
40. digitalWrite(ledAzul, LOW); 55. digitalWrite(ledAzul, HIGH);
41. } 56. }
Leitura de Potenciômetro
1. const int pot = 0;
2. int val = 0;

3. void setup() {
4. Serial.begin(9600);
5. }

6. void loop() {
7. val = analogRead(pot);
8. Serial.println(val);
9. delay(500);
10.}
Explicação do Código

1. O pino do Arduino conectado ao potenciômetro é o pino A0, porém pode-se declarar somente
0, visto que o Arduino entenderá que é uma entrada analógica
4. A interface serial do Arduino deve ser inicializado na função setup(), com a instrução
Serial.begin(b), onde b é a taxa de transferência que define o número de bits transmitidos por
segundo. A taxa de 9600 bits/s é um valor tipicamente usado.
8. O comando Serial.println(x) faz com que o valor da variável x seja escrita no IDE, passando para
a próxima linha logo depois. É bom colocar um delay() logo depois com um tempo suficiente
para que você possa acompanhar os valores escritos.
• Através de um terminal do IDE Arduino, pode-se acompanhar o valor
da variável sendo escrita.

• O LED denominado TX do Arduino deverá piscar a cada 0,5 segundos


indicando a transmissão de informação via USB.
• LDR (Light Dependent Resistor) é um resistor
variável cujo valor de resistência é inversamente
proporcional à luminosidade que incide sobre o
dispositivo.
• Também são chamados de fotorresistores;
LDR • Em escuridão total, o LDR tem resistência igual
a aproximadamente 200 kΩ;
• Com grande claridade, a resistência chega a
praticamente 0.
Controle de luminosidade com LDR
1. const int led = 9; //(PWM) 9. void loop() {
2. const int ldr = 0; 10. val = analogRead(ldr);
3. const int luzmin = 200; 11. val = map(val,luzmin,luzmax,255,0);
4. const int luzmax = 900; 12. val = constrain(val,0,255);
5. int val = 0; 13. analogWrite(led,val);
14.}
6. void setup() {
7. pinMode(led,OUTPUT);
8. }
11. A função map() altera uma faixa de valor para outra
faixa de maneira linear, no caso, o valor de val deve ser
medido entre 200 e 900, porém a função analogWrite()
só aceita valores entre 0 e 255. Como se deseja uma
Explicação do relação inversamente proporcional (aumentar a
intensidade do LED, quanto mais escuro o ambiente),
Código então a função ficou map(val,200,900,255,0);
12. Como pode acontecer do LDR fornecer valores maiores
que 900 e menores que 200, então é bom evitar que a
função map() crie um número fora do intervalo 0-255.
Esse intervalo é garantido usando a função constrain().
• O som é transmitido pelo ar na forma de onda
de pressão. À medida que um objeto como um
autofalante, tambor ou sino vibra, o ar ao seu
redor vibra na mesma frequência;
• O Arduino pode controlar duas propriedades
Propriedades dessa vibração: a frequência e a amplitude;
do Som • A frequência representa o quão rápida é a
vibração das partículas, enquanto a amplitude
representa a magnitude;
• A frequência da nota dó em uma escala média é de 261,63 Hertz, isso
quer dizer que, em um segundo, são feitas 261,63 oscilações.

• Fazendo as contas, chega-se que um ciclo da onda sonora para o dó


médio dura 3,822 milissegundos.

• Usando o Arduino, é possível gerar uma onda quadrada com a mesma


frequência, simulando digitalmente o tom desejado.

• Para o controle de amplitude, basta controlar a quantidade de


corrente recebido pelo autofalante usando, por exemplo, um
potenciômetro.
• Qualquer autofalante toma vantagem de
propriedades eletromagnéticas para a geração
de vibração;

Autofalante • Um ímã permanente fica atrás de uma bobina e


de um objeto polarizado. Quando uma corrente
(Buzzer) variável passa pela bobina, o ímã é polarizado
de acordo com a variação da corrente, atraindo
e repelindo o objeto polarizado que
consequentemente faz vibrar o diafragma do
autofalante, gerando o som.
1. const int Botao1 = 2; 18. EstadoBotao3 = digitalRead(Botao3);
2. const int Botao2 = 3; 19. if(EstadoBotao1 && !EstadoBotao2 &&
3. const int Botao3 = 4; !EstadoBotao3)
4. const int Buzzer = 10; 20. Tom = 100;
5. int EstadoBotao1 = 0; 21. if(!EstadoBotao1 && EstadoBotao2 &&
!EstadoBotao3)
6. int EstadoBotao2 = 0;
22. Tom = 200;
7. int EstadoBotao3 = 0;
23. if(!EstadoBotao1 && !EstadoBotao2 &&
8. int Tom = 0; !EstadoBotao3)
24. Tom = 500;
9. void setup() { 25. if(Tom>0){
10. pinMode(Buzzer, OUTPUT); 26. digitalWrite(Buzzer,HIGH);
11. pinMode(Botao1, INPUT); 27. delayMicroseconds(Tom);
12. pinMode(Botao2, INPUT); 28. digitalWrite(Buzzer,LOW);
13. pinMode(Botao3, INPUT); 29. delayMicroseconds(Tom);
14.} 30. Tom = 0;
31.}
15.void loop() { 32.}
16. EstadoBotao1 = digitalRead(Botao1);
17. EstadoBotao2 = digitalRead(Botao2);
• O IDE do Arduino possui uma função diretamente para a geração de
sons. Essa função é tone() e ela possui argumentos:

• O primeiro argumento seleciona o pino onde o tom será gerado;

• O segundo argumento faz a escolha da frequência escolhida;

• O terceiro argumento serve para a determinação da duração do


som. Este terceiro argumento é opcional e, caso ele não seja
colocado, o som vai ser feito por tempo indeterminado ou até
encontrar a função notone().
1. #define C 262 14.void loop() {
2. #define D 294 15. while(digitalRead(botaoC))
3. #define E 330 16. tone(buzzer,C);
4. #define G 392
5. #define A 440 17. while(digitalRead(botaoD))
18. tone(buzzer,D);
6. const int buzzer = 10;
7. const int botaoC = 2; 19. while(digitalRead(botaoE))
8. const int botaoD = 3; 20. tone(buzzer,E);
9. const int botaoE = 4;
10.const int botaoG = 5; 21. while(digitalRead(botaoG))
11.const int botaoA = 6; 22. tone(buzzer,G);

12.void setup() { 23. while(digitalRead(botaoA))


13.} 24. tone(buzzer,A);
25.}
• A função tone(), apesar de muito útil tem suas limitações:

• Como a função usa o mesmo temporizador utilizado para geração


de PWM, os pinos 3 e 11 não conseguem fazer a modulação
apropriadamente, exceção feita ao Arduino Mega;

• A onda sonora do Arduino é quadrada e não senoidal, tornando o


som relativamente desagradável. Para usar sons melhores é
necessário a obtenção de Shields com essa finalidade (Wave Shield
ou SparkFun MP3), ou usar o Arduino Due, que possui uma
biblioteca específica fazendo uso de seus conversores A/D;

• A função tone() só pode ser usada um pino por vez, ou seja, não é
ideal para múltiplos buzzers ou autofalantes.
1. const int ldr = 0; 19. void loop() { 37. if (valorLDR>400)
2. const int buzzer = 6; 20. valorLDR = analogRead(ldr); 38. digitalWrite(led2,HIGH);
3. const int led1 = 13; 21. if (valorLDR>800) 39. else
4. const int led2 = 12; 22. digitalWrite(led6,HIGH); 40. digitalWrite(led2,LOW);
5. const int led3 = 11; 23. else 41. if (valorLDR>300)
6. const int led4 = 10; 24. digitalWrite(led6,LOW); 42. digitalWrite(led6,HIGH);
7. const int led5 = 9; 25. if (valorLDR>700) 43. else{
8. const int led6 = 8; 26. digitalWrite(led5,HIGH); 44. digitalWrite(led6,LOW);
9. int valorLDR = 0; 27. else 45. digitalWrite(buzzer,HIGH);
28. digitalWrite(led5,LOW); 46. }
10. void setup() { 29. if (valorLDR>600) 47. }
11. pinMode(buzzer,OUTPUT); 30. digitalWrite(led4,HIGH);
12. pinMode(led1,OUTPUT); 31. else
13. pinMode(led2,OUTPUT); 32. digitalWrite(led4,LOW);
14. pinMode(led3,OUTPUT); 33. if (valorLDR>500)
15. pinMode(led4,OUTPUT); 34. digitalWrite(led3,HIGH);
16. pinMode(led5,OUTPUT); 35. else
17. pinMode(led6,OUTPUT); 36. digitalWrite(led3,LOW);
18. }
• Usando Vetores:
• Vetor é uma sequência de valores;
• Cada posição de um vetor tem um índice
que começa em zero;
Construindo • Ao declarar um vetor, deve-se determinar o
seu tamanho.
sequências de
sons • Exemplos:
• int valores[4];
• int valores[4] = {-7, 0, 15, 110};
• int valores[]={-7, 0, 15, 110};
• Se, por exemplo, for necessário acessar uma
posição específica de um vetor, basta escrever o
Construindo nome do vetor, seguido da posição desejada
entre colchetes.
sequências de
sons • Exemplos:
• digitalWrite(pino9,valores[1]);
• Para tocar um música, é necessária a criação de dois
Construindo vetores: o primeiro com as notas desejadas e o
segundo com o tempo de duração das notas.
sequências de • Exemplo:
sons • int notas[]={A4, E3,A4,0,A4,E3,A4,0};
• int tempos[]={250,250,250,250,250,250,250,250};
1. #define G6 1568
2. #define C7 2093 13. void loop() {
3. #define E7 2637 14. for (int i = 0; i < 16; i++) {
4. #define G7 3136 15. digitalWrite(led,HIGH);
16. float atraso = 1000000/nota[i]/2;
5. int nota[16] = { E7, E7, 0, E7, 0, C7, E7, 0, G7, 0, 0, 17. float ciclos = nota[i]/tempo[i];
0, G6, 0, 0, 0}; 18. for(int j=0;j<ciclos;j++){
6. int tempo[16] = { 12, 12, 12, 12, 12, 12, 12, 12, 12, 19. digitalWrite(buzzer,HIGH);
12, 12, 12, 12, 12, 12, 12};
20. delayMicroseconds(atraso);
21. digitalWrite(buzzer,LOW);
7. int buzzer=3;
22. delayMicroseconds(atraso);
8. int led=13;
23. }
24. digitalWrite(led,LOW);
9. void setup() {
25. int pausa = 1000 / tempo[i]*1.3;
10. pinMode(buzzer, OUTPUT);
26. delay(pausa);
11. pinMode(led, OUTPUT);
27. }
12. }

28. }
• O servomotor é uma máquina especial para ser
comandada com baixos valores de corrente,
ideal para equipamentos eletrônicos;
• Existem dois tipos de servomotores: o de
posição angular e o de rotação contínua;
• O servo que será utilizado é o de posição
angular, ou seja ele pode ser comandado para
O Servomotor assumir um ângulo entre 0º e 180º.
• O de rotação contínua pode se posicionar em
qualquer ponto em uma rotação completa
(360º) e pode ser utilizado como um motor
convencional.
• Para utilizar o servomotor no Arduino, é
necessária a inclusão da biblioteca Servo.h.
1. #include <Servo.h>

2. Servo Servo1;

3. void setup() {
4. Servo1.attach(3);
5. }

6. void loop() {
7. Servo1.write(90);
8. delay(2000);
9. Servo1.write(45);
10. delay(2000);
11.}
1. #include <Servo.h> 9. void loop() {
10. if (Serial.available()!=0){
2. Servo Servo1; 11. Recebido = Serial.read();
3. int Recebido; 12. if (Recebido == '+'){
4. int posicao=0; 13. posicao = posicao+10;
14. Serial.println(posicao);
5. void setup() { 15. }
6. Servo1.attach(3); 16. if (Recebido == '-'){
7. Serial.begin(9600); 17. posicao = posicao-10;
8. } 18. Serial.println(posicao);
19. }
20. Servo1.write(posicao);
21. }
22.}
• Os motores DC são bastante comuns, sendo
usados em dispositivos giratórios que urilizam
corrente contínua. São geralmente bem baratos
e tem grande variedade de modelos e
tamanhos;
Motor DC • Os motores utilizados na aula utilizam escovas
para a transferência de eletricidade para as
bobinas. Essa eletricidade causa variações
magnéticas que movimentam o rotor.
Ligação do motor DC ao Arduino
• Motores DC normalmente requerem mais corrente do que o Arduino
pode aguentar, uma vez que a natureza indutiva dos motores podem
provocar picos de corrente;
• Para uma ligação segura, é necessário isolar o motor DC do Arduino
usando um transistor;
• O esquemático que segue é importante na ligação do motor.
Ligação do motor DC ao Arduino
• Q1 é um transistor utilizado para ligar o motor à fonte de tensão.
Nesse tipo de conexão ele funciona como chave, permitindo a
passagem de corrente somente quando a base é acionada;
• O resistor de 1 kΩ serve para limitar a corrente que vai para a base do
transistor;
• U1 é o motor DC;
• C1 é um capacitor para reduzir os ruídos causados pelo motor;
• D1 é um diodo usado para proteger o circuito de correntes reversas
causadas pela natureza indutiva do motor.
1. const int pwm = 3; 6. void loop() {
7. for(int x=0;x<=255;x++){
2. void setup() { 8. analogWrite(pwm,x);
3. Serial.begin(9600); 9. delay(50);
4. pinMode(pwm,OUTPUT); 10. Serial.println(x);
5. } 11. }
12. for(int x=255;x<=0;x--){
13. analogWrite(pwm,x);
14. delay(50);
15. Serial.println(x);
16. }
17.}
1. const int pwm = 3;
2. const int pot = 0; 9. void loop() {
3. int valorLidoReal = 0; 10. valorLidoReal = analogRead(pot);
4. int valorLidoMap = 0; 11. valorLidoMap =
map(valorLidoReal,0,1023,0,255);
5. void setup() { 12. analogWrite(pwm,valorLidoMap);
6. Serial.begin(9600); 13. Serial.println(valorLidoMap);
7. pinMode(pwm,OUTPUT); 14.}
8. }
• Muito utilizado para a criação de gráficos de
barra;
Barra de LEDs • Ele é basicamente um conjunto de LEDs, sem
pontos em comum, logo todos devem ser
conectados ao Arduino e ao terra.
• Dispositivo que é conectado junto a um motor
de modo que faça este poder girara para ambos
os lados.
Ponte H
LCD
• Os displays LCD (Liquid Crystal
Display) têm como principal função
facilitar o entendimento visual do
que está acontecendo no circuito;
• Com ele é possível verificar dados
de sensores em tempo real, verificar
acontecimentos no Arduino ou
ainda “conversar” com o circuito
através de botões;
• O LCD do kit é do tipo 16x2, ou seja,
há 16 colunas e 2 linhas para os
dígitos.
LCD
• Um LCD precisa de 10 pinos
soldados para se fazer a ligação a
um protoboard.
PINO NOME PROPÓSITO
1 VSS Ligação ao Terra
2 VDD Conexão à Fonte
3 V0 Ajuste de contraste (Potenciômetro)
4 RS Seleção de Registro
5 R/W Leitura/Escrita
6 EN Ligar o LCD
7 D0 Linha de Dados 0
8 D1 Linha de Dados 1
9 D2 Linha de Dados 2
10 D3 Linha de Dados 3
11 D4 Linha de Dados 4
12 D5 Linha de Dados 5
13 D6 Linha de Dados 6
14 D7 Linha de Dados 7
15 A Ânodo do Backlight
16 K Cátodo do Backlight0
1. #include <LiquidCrystal.h>

2. LiquidCrystal lcd(12,11,5,4,3,2);

3. void setup() {
4. lcd.begin(16,2);
5. lcd.setCursor(0,0);
6. lcd.print("Ola, meu nome e:" );
7. lcd.setCursor(0,1);
8. lcd.print(" xxxx"); //digite seu nome em “xxxx”
9. }

10.void loop() {
11.}
1. #include <LiquidCrystal.h> 8. void loop() {
9. if (Serial.available()!=0){
2. LiquidCrystal lcd(12,11,5,4,3,2); 10. entrada = Serial.read();
3. int entrada,x,y; 11. lcd.print(char(entrada));
12. x=x+1;
4. void setup() { 13. y=y+1;
5. lcd.begin(16,2); 14. if(x>15){
6. Serial.begin(9600); 15. lcd.setCursor(0,2);
7. } 16. x=0;
17. }
18. if(y>31){
19. lcd.setCursor(0,0);
20. y=0;
21. x=0;
22. }
23. }
24.}
#include <LiquidCrystal.h> if (EstadoBotao1 == HIGH){ if(freq >= 100){
int freq = 0; freq = freq + 100; lcd.setCursor(0,1);
int Botao1 = 8; } lcd.print(" ");
int Botao2 = 9; if (EstadoBotao2 == HIGH){ lcd.setCursor(1,1);
int EstadoBotao1 = 0; freq = freq - 100; lcd.print(" ");
int EstadoBotao2 = 0; } lcd.setCursor(2,1);
int Buzzer = 6; if(freq <= 0){ }
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); freq = 0; if(freq >= 1000){
void setup() { } lcd.setCursor(0,1);
lcd.begin(16, 2); if(freq >= 20000){ lcd.print(" ");
lcd.setCursor(0,0); freq = 20000; lcd.setCursor(1,1);
lcd.print("Frequencia = "); } }
lcd.setCursor(6,1); if(freq <= 99){ if(freq >= 10000){
lcd.print("Hz"); lcd.setCursor(0,1); lcd.setCursor(0,1);
pinMode(Botao1, OUTPUT); lcd.print(" "); }
pinMode(Botao2, OUTPUT); lcd.setCursor(1,1); lcd.print(freq);
pinMode(Buzzer, OUTPUT); lcd.print(" "); tone(Buzzer, freq) ;
} lcd.setCursor(2,1); delay(100);
void loop() { lcd.print(" "); }
EstadoBotao1 = digitalRead(Botao1); lcd.setCursor(3,1);
EstadoBotao2 = digitalRead(Botao2); }

Você também pode gostar