Se você assistiu The Big Bang Theory, já viu o Sheldon usando esse instrumento. O teremim é um dos primeiros instrumentos musicais completamente eletrônicos sem qualquer tipo de contato físico entre o músico e o instrumento. Ele foi batizado em homenagem ao seu inventor, o Russo Léon Theremim, que patenteou esse instrumento em 1928. Esse aparelho é controlado por duas antenas de metal que percebem a posição das mãos do tocador.
O músico se posiciona de frente ao instrumento e move suas mãos perto das antenas de metal. Uma das mãos controla a frequência das notas musicais e a outra manipula o volume do som. A distância entre uma das antenas determina a frequência (pitch), e entre a outra controla a amplitude (volume). Na maioria das vezes, a mão direita controla a frequência e a esquerda controla o volume, embora esta disposição seja invertida por alguns artistas. Assim, o músico não precisa tocar no aparelho.
Alguns teremins de baixo custo utilizam um controle de volume simples, operado com um potenciômetro e possuem apenas a antena de frequência. Essa antena é diferente das antenas de transmissão de rádio, por exemplo. Elas atuam como um sensor de proximidade. Notas musicais agudas são tocadas quando a mão fica mais perto da antena.. Nessa aula, vamos usar um resistor sensível a luz para construir nosso Theremim. Assim, quanto mais perto colocarmos nossa mão perto do sensor, mais aguda será a nota musical tocada.
Vamos usar o uma resistor dependente de luz (LDR). Também chamado de fotoresistor. A diferença desse resistor para os que vimos, até agora, é que o valor de resistência do LDR muda de acordo com a luminosidade. Se a luminosidade de um ambiente está alta, a resistência do LDR diminui. Analogamente, quando a intensidade de luz está baixa, a resistência aumenta. Dessa forma, baseado na luminosidade de um ambiente, podemos controlar o brilho de nossos LEDs, por exemplo. Para usá-lo com o Arduíno, temos que fazer o circuito divisor de tensão, ou seja, um circuito parecido com o do botão. A imagem abaixo ilustra esse circuito.
Vamos precisar de:
fotoresistor LDR
Arduíno
Protoboard
Resistor de 10 kΩ
Simulação
Monte o circuito abaixo no tinkercad para entender como o LDR funciona. Escreva na barra de busca ao lado “fotorresistor” e adicione ao circuito junto com o Arduíno, protoboard, um LED e um resistor de 1 kΩ conforme indicado na figura abaixo.
Na programação, vamos usar o monitor serial para mostrar o valor lido pelo Arduíno ao mesmo tempo em que controlamos o brilho de um LED.
Até agora, nós ligamos LEDs individualmente. Mas se quisermos formar um número com esses LEDs?
Com base nessa ideia simples, vamos aprender a mexer em um componente que possui vários LEDs embutidos que, quando ligados corretamente, nos mostram um número. Esse componente chama-se Display de Sete Segmentos.
Como esses display é feito com vários LEDs, eles funcionam da mesma aforma que os LEDs da aula anterior. Só que desta vez eles são menores e estão todos juntos dentro da mesma caixinha. Para entender o funcionamento desse display, você deve lembrar, da aula passada, como funciona os terminais dos LEDs. O terminal conectado na base do triangulo deitado chama-se Anodo e nós o conectamos no pino de 5 V do Arduíno. Enquanto isso, o Catodo foi conectado, não diretamente, no pino GND do Arduíno. Além disso, você deve lembrar que cada triangulo deitado representa um LED.
Existem dois tipos de Displays de Sete segmentos, o anodo comum e o Catodo Comum. A diferença entre eles está no terminal conectado em comum com todos os LEDs internos. Perceba que no Display de Anodo comum, todos os fios que saem da base dos triângulos estão conectados diretamente. Analogamente, no display de catodo comum, a ponta do triangulo de todos os LEDs estão conectados por fios, ou seja, estão conectados diretamente.
Vamos precisar de:
1 Display de sete segmentos de anodo comum.
7 resistores de 470 Ω e 1 Resistor de 1kΩ.
Protoboard.
Arduíno.
Esses displays de sete segmentos são utilizados desde 1910. No entanto, naquela época, como não haviam inventado o LED, usava-se lampadas incandescentes para representar cada segmento.
Como era muito difícil de usar esse modelo com lâmpadas, esse tipo de display de sete segmentos nunca foi tão utilizado. Mas, com a invenção do LED nos anos 70, o display de sete segmentos tornou-se mais comum. Até hoje, ele pode ser encontrado na construção de alguns relógios.
Nossos circuitos vão utilizar o display de sete segmentos como uma forma de mostrar números para o usuário. Por exemplo, queremos saber quantas vezes uma senha foi digitada incorretamente. Assim, podemos usar nosso Arduíno para nos mostrar quantas vezes tentaram abrir nosso cofre!
No circuito que vamos montar, a seguir, cada pino do display representa um LED e, por isso, vamos conectar cada LED em uma porta diferente do Arduíno. Assim, vamos utilizar 7 portas para controlar todos os LEDs. Devemos, portanto, colocar um resistor para cada porta do Arduíno e mais um resistor na entrada comum para proteger o display. De forma semelhante aos LEDs, é necessário colocar um resistor por que a voltagem de 5 V do Arduíno é muito alta e o display pode queimar se conectado diretamente com o Arduíno.
A imagem abaixo ilustra qual pino controla cada segmento. O pino central representa o pino comum a todos os LEDs internos e o pino DP representa o ponto no display de sete segmentos. Para que o circuito mantenha-se organizado e fácil de programar, é importante que você conecte, na mesma ordem, os pinos do display nas portas do Arduíno.
Simulação
Para começar a montar o circuito básico do display, escreva visor na barra de pesquisa ao lado e coloque-o na protoboard. Lembre-se que é necessário colocar o display bem no meio da protoboard, já que cada LED precisa ser conectada em uma trilha vertical diferente. Em seguida, escolha qual vai ser a polaridade do pino comum, ou seja, se o pino comum vai ser do tipo anodo ou catodo. Nesse exemplo, vamos usar o display de anodo comum, já que ele é mais fácil de ser encontrado.
Seguindo o mesmo procedimento da aula anterior, conecte um resistor na mesma trilha de cada pino do display. Dessa forma, você estará ligando um resistor na saída de cada LED do display.
Repita o procedimento para cada LED e coloque um resistor de 1 kΩ na entrada comum do display, ou seja, no pino central do display. Agora, faça as conexões de cada LED com o Arduíno e a conexão do pino central do display com a entrada de 5 V do Arduíno. Se precisar, revise, no conteúdo da primeira aula, como funciona as conexões internas de cada trilha da Protoboard. Assim, terminamos a montagem do circuito. Por isso,é importante que você entenda por que as ligações foram feitas dessa maneira antes de começar a programar.
Como terminamos de montar o circuito, vamos começar a programar!!
Para que o código fique mais fácil de ser analisado, vamos colocar, ao lado da definição dos pinos, quais segmentos estão conectados em cada pino. Essa forma é interessante para que, no futuro, fique mais fácil de analisar o código.
Como o display de sete segmentos é composto,internamente, por LEDs, definimos os pino de 2 a 8 como saídas do Arduíno no “setup()”, isto é, nas configurações iniciais. Em seguida, no “loop()”, desligamos o LED escrevendo, dentro do “digitalWrite()”, o pino que queremos desligar e a palavra HIGH. Na imagem abaixo, escolhemos desligar o LED A.
Nota: Ao contrário da aula com LEDs convencionais, a palavra HIGH vai desligar o display de sete segmentos de anodo comum. Se o seu display for de catodo comum, HIGH vai ligar os LEDs.
void setup(){
pinMode(2, OUTPUT); //PINO 2 -> SEGMENTO A
pinMode(3, OUTPUT); //PINO 3 -> SEGMENTO B
pinMode(4, OUTPUT); //PINO 4 -> SEGMENTO C
pinMode(5, OUTPUT); //PINO 5 -> SEGMENTO D
pinMode(6, OUTPUT); //PINO 6 -> SEGMENTO E
pinMode(7, OUTPUT); //PINO 7 -> SEGMENTO F
pinMode(8, OUTPUT); //PINO 8 -> SEGMENTO G
}
void loop(){
digitalWrite(A,HIGH);
}
Até agora, nós usamos a palavra HIGH ou LOW para ligar ou desligar um LED. O Arduíno, entretanto, não trabalha com palavras. Ele traduz HIGH para o número 1 e LOW para Zero. Dentro dele, o número 1 mostra que ele deve mandar uma tensão de 5 V para o pino que você indicar. De forma similar, se você escolher um pino e escrever Zero, ele entende que deve deixar a tensão do pino em 0 V. Na imagem abaixo, mostramos que você pode fazer a mesma coisa que a imagem anterior. Mas falando na mesma linguagem do Arduíno.
void setup(){
pinMode(2, OUTPUT); //PINO 2 -> SEGMENTO A
pinMode(3, OUTPUT); //PINO 3 -> SEGMENTO B
pinMode(4, OUTPUT); //PINO 4 -> SEGMENTO C
pinMode(5, OUTPUT); //PINO 5 -> SEGMENTO D
pinMode(6, OUTPUT); //PINO 6 -> SEGMENTO E
pinMode(7, OUTPUT); //PINO 7 -> SEGMENTO F
pinMode(8, OUTPUT); //PINO 8 -> SEGMENTO G
}
void loop(){
digitalWrite(A,1);
}
Agora, individualmente, desligue os LEDs do display de sete segmentos até que eles formem os números de Zero a Nove. Na imagem abaixo, começamos desligando o LED central para ter o Zero.
DICA: Para desligar mais LEDs, basta adicionar mais linhas de “digitalWrite();” e desligar quem você desejar.
void setup(){
pinMode(2, OUTPUT); //PINO 2 -> SEGMENTO A
pinMode(3, OUTPUT); //PINO 3 -> SEGMENTO B
pinMode(4, OUTPUT); //PINO 4 -> SEGMENTO C
pinMode(5, OUTPUT); //PINO 5 -> SEGMENTO D
pinMode(6, OUTPUT); //PINO 6 -> SEGMENTO E
pinMode(7, OUTPUT); //PINO 7 -> SEGMENTO F
pinMode(8, OUTPUT); //PINO 8 -> SEGMENTO G
}
void loop(){
digitalWrite(G,1);
}
Para saber mais:
Existe uma outra forma desligar e ligar os LEDs. Para isso, criamos um vetor computacional na linha 1 da imagem acima. Esse vetor tem as seguintes características:
A palavra “int” diz para o Arduíno que o vetor é feito de números inteiros.
O “numero_zero_display” é o nome do vetor.
“[7]” diz para o Arduíno quanto números eu vou colocar dentro do vetor.Assim, dentro do vetor tem 7 números. Eles vão de Zero a Seis.
“{0,0,0,0,0,0,1}” diz para o Arduíno quais números estarão em cada posição. Assim, na posição Zero temos zero. Nas demais posições temos, também, zeros. Mas, na posição Seis temos o número 1.
A estratégia desses código é associar cada posição desse vetor a um segmento de LED do display de sete segmentos. O Arduíno é indexado em zero, ou seja, toda contagem começa em Zero. Desse jeito, se você quer acessar a segunda posição de um vetor, por exemplo, deve pegar o número 1. Assim, a posição Zero do vetor é equivalente ao segmento A, a posição 1 é equivalente ao segmento B e, assim, por diante. Dessa forma, vamos criar duas variáveis e usar o Loop “for” para acessar as posições desse vetor que criamos. Esse Loop “for” tem as seguintes características:
Linha 17: “pino = 2” faz com que a variável pino comece com o valor 2.
Linha 17:”pino < 9″ faz com que esse loop acabe quando o valor de pino chegar a 8. Assim, as instruções dentro do loop “for” vão ser executadas 7 vezes. Exatamente a quantidade pinos do display.
Linha 17:”pino++” faz com que a variável pino some uma unidade cada vez que as instruções dentro do loop acabarem.
Linha 18: “digitalWrite(pino, numero_zero_display [contador])” escreve na porta do Arduíno o valor que está dentro da posição “contador” no vetor numero_zero_display. Assim, no display de anodo comum, se dentro de uma posição do vetor ter o valor zero, o LED do segmento ligado na porta do Arduino vai permanecer acesso. Analogamente, se dentro da posição do vetor tem o número 1, o LED vai ser desligado. Na primeira vez que esse código for executado, o valor do pino é 2 e ele vai pegar o número da posição zero do vetor.
Linha 19: “contador++” soma uma unidade no valor do contador. Isso faz com que o “digitalWrite” acesse a próxima posição do vetor quando esse comando for executado novamente. Assim, a segunda vez que o “digitalWrite” for executado, ele vai escolher a posição 1 do vetor e vai associar o valor dentro dessa posição a porta 3 do Arduíno.
int numero_zero_display [7] = {0,0,0,0,0,0,1};
void setup(){
pinMode(2, OUTPUT); //PINO 2 -> SEGMENTO A
pinMode(3, OUTPUT); //PINO 3 -> SEGMENTO B
pinMode(4, OUTPUT); //PINO 4 -> SEGMENTO C
pinMode(5, OUTPUT); //PINO 5 -> SEGMENTO D
pinMode(6, OUTPUT); //PINO 6 -> SEGMENTO E
pinMode(7, OUTPUT); //PINO 7 -> SEGMENTO F
pinMode(8, OUTPUT); //PINO 8 -> SEGMENTO G
}
void loop(){
int pino = 0;
int contador = 0;
for(pino = 2; pino < 9; pino++ ){
digitalWrite(pino,numero_zero_display[contador]);
contador++;
}
}
As tentativas de previsão ao futuro acontecem desde quando há registros históricos. Essas “consultas espirituais” tem ocorridos de várias formas e em diversas culturas, por exemplo, cartas de tarô, astrologia, oráculos, entre outros. Para as pessoas que afirmam conseguir prever o futuro, um dos métodos utilizados são bolas de cristal, que fornecem informações sobre a finanças, amor, casamento e negócios.
Nesta aula, vamos criar uma bola mágica com o Arduino que mostra previsões do futuro … na verdade vai exibir informações aleatórias pré escolhidas (alguma semelhança com a realidade?).
Imagens meramente ilustrativas
O display de LCD (Liquid-crystal display) que vamos usar nessa aula, é feito de cristal líquido, mas não possui propriedades mágicas ou exotéricas.
Esse display é muito utilizado e é um gigantesco um avanço tecnológico comparado com os displays de sete segmentos. Nesse display, é possível mostrar para o usuário as informações que estávamos mostrando, apenas, no monitor serial do Arduíno. Os displays são vendidos baseados na quantidade de caracteres que podem ser exibidos em cada linha e na quantidade de linhas disponíveis.Por exemplo, na imagem acima, o display é de 20×04, já que cada linha pode ter 20 caracteres e há 4 linhas disponíveis. De forma análoga, o display abaixo é 16×02, pois possui capacidade para exibir 16 caracteres em cada linha e 2 linhas para exibir seu conteúdo.
Já viu esse filme?
Para fazer a atividade prática desta aula, vamos utilizar o modelo 1602 sem o circuito integrador I2C. Isso significa que ele é 16×02 e não possui esse módulo I2C. No entanto, na sessão “Para saber mais” também vamos mostrar como configurar e utilizar o o display LCD 1602 I2C. A partir desse módulo, a pinagem, isto é, o significado de cada pino torna-se extremamente importante. Por isso, deve-se ter em mãos o datasheet do componente escolhido.
Quanto a pinagem desse componente, vamos analisar a figura ao lado:
O pino 1 e 2 se referem a alimentação do display, ou seja, os pinos que fazem o componente funcionar.
O pino 3 é utilizado para definir o contraste da tela.
O pino 4 possibilita a seleção entre o envio de dados e os comandos que são fornecidos ao componente.
O pino 5 possibilita a seleção entre a escrita e o leitura de dados pelo LCD.
O pino 6 habilita o funcionamento do display.
Os pinos 7-10 não serão utilizados.
Os pinos 11-14 transmitem os dados para mostrar no display.
O pino 15 é o anodo dos LEDs presentes na luz de fundo do LCD.
O pino 16 é o catodo dos LEDs presentes na luz de fundo do LCD.
Importante: Nunca ligue a fonte de alimentação diretamente nos terminais de backlight (pino 15).
Isto provocará o aquecimento excessivo do display e a queima prematura do componente.
Durante a programação do display de LCD, você vai precisar entender como a biblioteca enxerga o display. Para isso, vamos analisar a imagem abaixo e a função “lcd.setCursor(coluna,linha);”que descreve o posicionamento do cursor. Como visto anteriormente, o Arduino é indexado em Zero. Assim, os componentes compatíveis com ele também são, ou seja, o display de LCD tem espaço para 16 caracteres e para escrever nesses espaços devemos escolher escolher as posições de Zero a 15. Para escrever na primeira posição do display, precisamos escolher a posição (0,0).
Novos componentes:
Resistores variáveis:
Dentro do grupo de resistores variáveis, temos os potenciômetros comuns, reostatos, trimpots, potenciômetros deslizantes e potenciômetros digitais. A diferença entre eles está no tamanho, aplicação ou mecânico. Nesta aula, vamos te usar o potenciômetro comum. No entanto, o funcionamento dos outros é o mesmo. Todos são resistências como as que já conhecemos, mas a resistência deles não é fixa, ou seja, você pode a mudar a resistência de Zero até o valor máximo permitido. Por exemplo, o potenciômetro da imagem ao lado é de 10 kΩ. Assim, a resistência elétrica dele vai de Zero a 10 kΩ. Mas como que liga essas três perninhas no circuito?
Como demonstrado na figura abaixo, existem 3 formas de ligar o potenciômetro no circuito:
Potenciômetro A: Nessa configuração, o potenciômetro vai de Zero a até seu valor máximo. Quando gira-se o eixo para esquerda, a resistência diminui e chega mais próxima de Zero. Analogamente, quando roda-se o mesmo eixo para a direita, a resistência aumenta até o valor máximo.
Potenciômetro B: Dessa maneira, o potenciômetro continua indo de Zero até o valor máximo. No entanto, quando vira-se o eixo, ocorre, exatamente, o oposto da configuração anterior, ou seja, rodar o eixo para a esquerda faz com que a resistência aumente e quando gira-se o eixo para direita, a resistência diminui.
Potenciômetro C: Com esse ajuste, o giro do eixo não importa e o valor da resistência é sempre o máximo.
Na imagem ao lado, vemos como o potenciômetro é construído. Perceba que, quando ligamos no terminal 2, podemos ajustar a resistência dele. Nesse caso, o cursor move-se pelo material resistivo quando rodamos o eixo. Assim, quanto maior for a quantidade de material resistivo envolvido pelo cursor, maior é a resistência ajustada. Analogamente, quanto mais próximo o terminal 2 estiver do 1, ou seja, o cursor inclui pouco material resistivo, menor é a resistência ajustado no potenciômetro. Mas se ligamos o terminal 1 e o 3, a resistência fica fixada no valor máximo. Esse componente é utilizado em vários projetos. No exemplo a seguir, ele vai ser usado para controlar o contraste do display. Além disso, esse componente pode ser usado para controlar braços robóticos e a velocidade de motores, por exemplo.
CI PCF8574
Esse código estranho que está escrito acima é o módulo que facilita nossa vida com o display de LCD. A função dele é diminuir o número de portas utilizadas no Arduíno. Com esse módulo, você consegue controlar um display LCD, seja ele 16×2 ou 20×4, utilizando apenas dois pinos analógicos do Arduíno: o pino analógico 4 (SDA) e o pino analógico 5 (SCL), que formam a interface de comunicação I2C. Para saber mais sobre esse componente, consulte o datasheet dele.
Nesta aula, você vai precisar:
Display LCD com I2C ou sem I2C.
Arduíno
Protoboard
Jumper macho-macho
Resistor de 220 Ω
Potenciômetro 10 kΩ
Simulação
Vamos começar conectando a alimentação do Arduíno e o backlight do LCD, isto é, a luz de fundo do LCD. Assim como em outras aulas, Usamos os jumpers pretos e vermelhos para conectar os pinos de alimentação na protoboard. Para ligar o backlight, conecte o anodo do LED e um resistor de 220Ω na trilha de 5 V da protoboard. Para não queimar o LCD, é necessário colocar esse resistor. O pino de catodo no LCD é conectado no GND do circuito.
Agora, vamos ligar a voltagem no LCD e conectar o pino de contraste. Para conectar a alimentação do LCD, conecte os pinos Vcc e GND do LCD nas portas 5 V e GND do Arduíno, respectivamente. O contraste é ajustado com um potenciômetro. Assim, conecte os fios Vcc e GND nas extremidades do potenciômetro e, no terminal central, coloque o pino do Arduíno.
Nesse momento, vamos ligar os pinos de transmissão de dados. Para facilitar a programação, colocamos os pinos de 4 a 7 do LCD nas portas correspondentes do Arduino, isto é, porta 7 do Arduino no pino 7 do LCD e, assim, em diante.
Para terminar a montagem do LCD no circuito, temos que ligar os pinos RS, RW e o Enable. Escolhemos a porta 11 para o RS e a porta 12 para o Enable. O pino RW deve ser conectado no GND.
Colocamos o mesmo botão PULL-DOWN das aulas anteriores no pino 2 do Arduíno. Assim, a resposta da bola mágica aparecerá quando apertarmos o botão.
A biblioteca dos cristais líquidos sem I2C já estão pré instaladas no Arduíno, ou seja, não precisa baixar uma nova biblioteca para controlar o display. Mesmo assim, para programar, é necessário incluir a biblioteca em cada novo programa. Como em aulas anteriores, é recomendável que se escreva em quais portas do Arduíno os pinos do LCD estão conectados. Mais tarde, fica mais fácil para analisar o que foi feito. Em seguida, para iniciar o display é necessário escrever em que porta do Arduíno estão conectados os pinos de dados, RS e Enable. Se você quiser mudar o posicionamento dos fios, vai precisar informar o Arduíno da mudança. Para isso na linha 13, altere o posicionamento das portas dentro da função. No entanto, lembre-se que essa linha deve ser escrita da seguinte forma: “LiquidCrystal lcd(RS, E, D4, D5, D6, D7);”.
Para programar as configurações iniciais do display de LCD, temos que usar a função “lcd.begin(caracteres por linha, linhas)”. Nessa função, temos que fornecer a quantidade de caracteres e a quantidade de linhas do nosso display. Como nosso display tem 16 caracteres e 2 linhas, vamos atribuir esses valores na função. Em seguida, temos que iniciar o botão. Para isso, precisamos escrever em que pino o botão está conectado e defini-lo como entrada, já que é ele quem vai fornecer informações para o Arduíno.
Com isso, terminamos de definir as configurações iniciais do Arduino. Agora, vamos começar a programar as instruções que vão ser executadas para sempre. Assim, definimos uma variável para guardar a informação se o botão está ou não pressionado. Para escrever a mensagem inicial no LCD, vamos usar a função “lcd.print(“Mensagem”);”. Essa função, simplesmente, escreve uma mensagem no display de LCD. Lembre que nosso display só tem 16 caracteres de espaço visível e essa biblioteca não tem suporte para acentuação. Como usamos todos os espaços na primeira linha, usamos a função “lcd.set.Cursor(0,1)” para mudar o cursor para escrever na segunda linha. Para posicionar o cursor é necessário lembrar que o display é indexado em Zero e o primeiro número se refere a coluna do display e a segunda linha se refere a linha do display. Assim, escrevemos (0,1) para colocar o cursor no inicio da segunda linha. Agora, colocamos na variável “estado_botao” a condição em que está o botão, ou seja, se o botão está pressionado ou não.
A estratégia desse código será associar cada mensagem do mostrada na tela a um número. Por exemplo, vinculamos para a resposta “sim” o número Zero. Dessa forma, vamos usar a função “random” do Arduino para gerar números aleatórios. Assim, o Arduino vai gerar um número aleatório toda vez que o usuário apertar o botão. Esse número aleatório estará vinculado com uma mensagem no Arduino e essa mensagem será mostrada para o usuário.
Então, antes de começar a programar o que acontece quando o botão é pressionado, vamos declarar uma variável para armazenar o número aleatório que será dada para o usuário. Queremos que a mensagem do Arduino mágico mude quando o botão seja pressionado. Então, colocamos o condicional “if” com a condição HIGH, para que a instruções dentro do “if” só sejam executadas quando o botão for apertado. A primeira instrução dentro do “if” será para limpar o display e, para tanto, usamos a função “lcd.clear();”. Como o cursor estava colocado no inicio da segunda linha, temos que faze-lo voltar para a primeira com o comando “setCursor(0,0);”.Escrevemos a mensagem com o comando “lcd.print(“Mensagem”);” e deslocamos o cursor para escrever a resposta na segunda linha. Em seguida, colocamos o resultado da função “random(0,7);” na variável “resposta”. A função “random(0,7);” gera um número aleatório entre Zero e 6,ou seja, 7 possibilidades.
Depois de colocar um número aleatório na variável “resposta”, temos que checar qual número o Arduino nos forneceu. Para isso, vamos usar uma sequencia de “if”, um para número aleatório que a função “random” pode nos dar. Por exemplo, no primeiro “if” nós verificamos se o número dentro da variável “resposta” é o número Zero e escrevemos “sim” se for. Em seguida, repetimos esse trecho de código para todos as possibilidades. No final do código colocamos um delay de 2000 milisegundos, ou seja, 2 segundos. Assim, a mensagem fica travada na tela durante esse tempo e dá tempo par que o usuário leia. No final, limpamos o display novamente com o comando “lcd.clear();”para que a mensagem “Pergunte para o Arduino Mágico” apareça novamente na tela.
Abaixo, temos o código final do programa:
#include <LiquidCrystal.h>
/*
LCD RS no pino 11;
LCD Enable no pino 12;
LCD D4 no pino 4;
LCD D5 no pino 5;
LCD D6 no pino 6;
LCD D7 no pino 7;
*/
LiquidCrystal lcd(11,12,4,5,6,7);
void setup()
{
lcd.begin(16,2); //Inicia o LCD com 16 caracteres e 2 linhas
pinMode(2,INPUT);// Inicia o botão no pino 2
}
void loop()
{
int estado_botao;
lcd.print("Pergunte para o");// Mostra a mensagem no display
lcd.setCursor(0,1);//muda o cursor para o primeiro espaço da segunda linha.
lcd.print("Arduino Magico!!");// Mostra a mensagem no display
estado_botao = digitalRead(2);
int resposta = 0;
if( estado_botao == HIGH){
lcd.clear(); // Limpa o display
lcd.setCursor(0,0); // coloca o cursor na primeira posição da primeira linha
lcd.print("A bola diz:");// Mostra a mensagem no display
lcd.setCursor(0,1);//muda o cursor para o primeiro espaço da segunda linha.
resposta = random(0,7);// associa um número qualquer entre 0 e 6
if(resposta == 0){
lcd.print("Sim");
}
if(resposta == 1){
lcd.print("Nah");
}
if(resposta == 2){
lcd.print("Talvez");
}
if(resposta == 3){
lcd.print("Com certeza");
}
if(resposta == 4){
lcd.print("Provavelmente");
}
if(resposta == 5){
lcd.print("As vezes");
}
if(resposta == 6){
lcd.print("Jamais");
}
delay(2000);
lcd.clear(); // Limpa o display
}
}
Para saber mais:
Da mesma forma como foi feito em programas anteriores, vamos retirar a declaração de variáveis e colocar os comandos diretamente no dentro do “if”. Isso poupa memória do Arduino para execução do código. Além dessa mudança, mudamos a sequencia de “if” para uma nova sintaxe condicional semelhante ao “if”, o “switch… case”. Como o “if”, essa sintaxe também necessita de uma condição, mas ela é mais eficiente para comparar valores pre determinados. Assim, pode-se colocar a variável resposta dentro da condição do switch e fazer a mesma análise que fizemos da primeira vez.
#include <LiquidCrystal.h>
/*
LCD RS no pino 11;
LCD Enable no pino 12;
LCD D4 no pino 4;
LCD D5 no pino 5;
LCD D6 no pino 6;
LCD D7 no pino 7;
*/
LiquidCrystal lcd(11,12,4,5,6,7);
void setup()
{
lcd.begin(16,2); //Inicia o LCD com 16 caracteres e 2 linhas
pinMode(2,INPUT);// Inicia o botão no pino 2
}
void loop()
{
lcd.print("Pergunte para o");// Mostra a mensagem no display
lcd.setCursor(0,1);//muda o cursor para o primeiro espaço da segunda linha.
lcd.print("Arduino Magico!!");// Mostra a mensagem no display
int resposta = 0;
if( digitalRead(2) == HIGH){
lcd.clear(); // Limpa o display
lcd.setCursor(0,0); // coloca o cursor na primeira posição da primeira linha
lcd.print("A bola diz:");// Mostra a mensagem no display
lcd.setCursor(0,1);//muda o cursor para o primeiro espaço da segunda linha.
resposta = random(0,7);// associa um número qualquer entre 0 e 6
switch (resposta){
case 0:
lcd.print("Sim");
break;
case 1:
lcd.print("Nah");
break;
case 2:
lcd.print("Talvez");
break;
case 3:
lcd.print("Com certeza");
break;
case 4:
lcd.print("Provavelmente");
break;
case 5:
lcd.print("As vezes");
break;
case 6:
lcd.print("Jamais");
break;
}
delay(2000);
lcd.clear(); // Limpa o display
}
}
O uso do “Switch…case “tem o mesmo resultado do que o uso de “if”. Mas com o “switch…case”, temos um código mais eficiente, enxuto e fácil de entender. Perceba que retiramos, no código acima, a variável “estado_botao” e colocamos o comando do Arduino diretamente no primeiro “ïf”. Por fim, vamos fazer a mesma coisa com a variável “resposta”. Assim, seu programa deve ficar semelhante ao código abaixo.
#include <LiquidCrystal.h>
/*
LCD RS no pino 11;
LCD Enable no pino 12;
LCD D4 no pino 4;
LCD D5 no pino 5;
LCD D6 no pino 6;
LCD D7 no pino 7;
*/
LiquidCrystal lcd(11,12,4,5,6,7);
void setup()
{
lcd.begin(16,2); //Inicia o LCD com 16 caracteres e 2 linhas
pinMode(2,INPUT);// Inicia o botão no pino 2
}
void loop()
{
lcd.print("Pergunte para o");// Mostra a mensagem no display
lcd.setCursor(0,1);//muda o cursor para o primeiro espaço da segunda linha.
lcd.print("Arduino Magico!!");// Mostra a mensagem no display
int resposta = 0;
if( digitalRead(2) == HIGH){
lcd.clear(); // Limpa o display
lcd.setCursor(0,0); // coloca o cursor na primeira posição da primeira linha
lcd.print("A bola diz:");// Mostra a mensagem no display
lcd.setCursor(0,1);//muda o cursor para o primeiro espaço da segunda linha.
switch (random(0,7)){
case 0:
lcd.print("Sim");
break;
case 1:
lcd.print("Nah");
break;
case 2:
lcd.print("Talvez");
break;
case 3:
lcd.print("Com certeza");
break;
case 4:
lcd.print("Provavelmente");
break;
case 5:
lcd.print("As vezes");
break;
case 6:
lcd.print("Jamais");
break;
}
delay(2000);
lcd.clear(); // Limpa o display
}
}
Para futuros projetos,disponibilizamos todas as funções disponíveis na biblioteca “LiquidCrystal.h”. Assim, quando quiser fazer alguma coisa diferente o display de LCD, veja o que a biblioteca é capaz de fazer.
Sabia que os aquários devem ter uma iluminação apropriada para que as plantas sobrevivam?
Vários fatores influenciam na sobrevivência das plantas e dos peixes dentro de um aquário. Por isso, todos devem ter bombas, um sistema de filtro, para remover resíduos químicos que são letais para os peixinhos,uma série de decorações diferentes e outros animais como esponjas, moluscos e corais. Além disso tudo, habitantes do aquário precisam de um sistema de iluminação adequado. Nesta aula, vamos ver como, a partir de um relógio, controlar LEDs de forma mais confortável para nossos peixinhos.
Me chamou?
Então, as plantas precisam de 10 a 12 horas de exposição, diária, a luz. Mas não é qualquer luz que elas gostam. Também é importante que a luz fornecida as plantas seja mais pro vermelho e azul. O truque aqui é simular dentro do aquário, da melhor forma possível, o que acontece na natureza. Tudo isso pode ser feito manualmente, ou seja, liga-se as lampadas por algumas horas e depois você vai ter que lembar de desligar. No entanto, a melhor forma de fazer isso é automatizando esse processo. Assim, pode-se controlar por quanto tempo as luzes vão ficar ligadas e ajustar o brilho para que não fique tanto tempo na intensidade máxima.
Até agora, vimos como mexer com LEDs, display de sete segmentos e usamos, pela primeira vez, um sensor para sentir a temperatura dos ambientes. Vamos usar um componente usado para mostrar as horas, data e dia da semana, ou seja, vamos criar um relógio digital. Como todo relógio digital, esse módulo também vem com lugar para por bateria. Assim, você pode programar seus robôs para funcionarem na hora que você desejar, comprovar que horas tentaram abrir a porta da sua casa ou regar suas plantas na hora certa.
A figura mostra o que vem escrito no módulo RTC. Nos nossos projetos, vamos usar, como sempre, o VCC e o GND para a alimentação do componente. Além dos pinos responsáveis por alimentar o componente, ou seja, para deixar ele funcionando, os outros pinos servem para transferir as informações do componente para o Arduino de forma sincronizada. Do mesmo modo que o sensor de temperatura e umidade, o pino que transfere dados para o Arduino é o SDA e o pino que sincroniza as informações na tela do usuário é o SCL. Esse pino chama-se, na eletrônica, de “clock”. Quanto maior o “clock” de um componente, mais fácil fica para fazer essa sincronização dos dados. Como o módulo RTC gera muita informações diferentes, ele organiza e sincroniza as informações para que o Arduino nos mostre essas informações. Lembre-se que, para saber mais sobre o componente, consulte o datasheet.
Você vai precisar de:
Módulo RTC DS3231.
Protoboard
Arduino.
Montagem Prática
Nessa montagem, exploraremos todas as funcionalidades do módulo RTC, ou seja, vamos fazer ele mostrar as horas, data e dia da semana. Além disso, como na ultima aula, usaremos o monitor serial do Arduino para nos mostrar esses resultados. Novamente, tanto o Fritzing quanto o tinkercad não tem o módulo RTC DS3231. Por isso, nem tente simular o circuito, use a imagem abaixo como referência para fazer a montagem.
A imagem abaixo ilustra o passo a passo da montagem prática do circuito acima. Na imagem 1 temos os componentes utilizados e, na imagem 2, conectamos os jumpers de alimentação do circuito. Da mesma forma que a montagem da aula passada, ligamos o jumper vermelho no pino 3,3 V e o jumper preto no pino GND do Arduino. Na imagem 3 colocamos um jumper branco na saída de dados, SDA, e na porta A4. Em seguida, conectamos um jumper amarelo no pino de sincronização, SCL, no pino A5.
Com o circuito montado, vamos começar a programação.
#include <Wire.h>
#include <DS3231.h>
DS3231 rtc;
bool Century;
bool h12;
bool PM;
void setup() {
Wire.begin();
Serial.begin(9600);
// O bloco abaixo define a data e a hora de partida do sensor
rtc.setDate(26);
rtc.setMonth(10);
rtc.setYear(20);
rtc.setDoW(5);// Domingo = 1 ... Sábado = 7
rtc.setHour(19);
rtc.setMinute(15);
rtc.setSecond(50);
}
void loop() {
//O bloco abaixo escreve o horário, a data e a temperatura na tela.
Serial.print(rtc.getDate());
Serial.print('-');
Serial.print(rtc.getMonth(Century));
Serial.print('-');
Serial.print("20");
Serial.print(rtc.getYear());
Serial.print(' ');
Serial.print(rtc.getHour(h12,PM));
Serial.print(':');
Serial.print(rtc.getMinute());
Serial.print(':');
Serial.println(rtc.getSecond());
Serial.print("Temperatura = ");
Serial.println(rtc.getTemperature());
// O bloco abaixo escreve o dia da semana na tela.
if(rtc.getDoW()== 1){
Serial.println("Domingo");
}
if(rtc.getDoW()== 2){
Serial.println("Segunda");
}
if(rtc.getDoW()== 3){
Serial.println("Terça");
}
if(rtc.getDoW()== 4){
Serial.println("Quarta");
}
if(rtc.getDoW()== 5){
Serial.println("Quinta");
}
if(rtc.getDoW()== 6){
Serial.println("Sexta");
}
if(rtc.getDoW()== 7){
Serial.println("Sábado");
}
}
Nas duas primeiras linhas, temos que incluir duas bibliotecas para que a comunicação entre o sensor e o Arduino seja bem sucedida. Na quarta linha, adicionamos a variável “rtc” do tipo “DS3231”. Esse tipo de variável é especifica do RTC3231 e só vai ser utilizada na presença desse componente. Nas linhas 6, 7 e 8, declaramos 3 variáveis do tipo “bool”. Esse tipo de variável guarda um valor lógico, ou seja, verdadeiro ou falso. Essas variáveis são necessárias para guardar os valores das horas.
No “void setup()”, temos que iniciar a biblioteca “Wire.h” e definir a taxa de transmissão do monitor Serial. Essa ações são realizadas pelo Arduino nas linhas 11 e 12. É necessário, nas linhas seguintes, definir a data e a hora de partida do RTC. Por isso, nas linhas 16 a 22, usamos as funções da biblioteca “DS3231” para definir a data e a hora inicial.
Linha 16: define o dia como 26.
Linha 17: define o mês como 10.
Linha 18: define o ano como 20.
Linha 19: define o dia da semana como Quinta. Os dias da semana são indexados de 1 a 7. Começando com Domingo e terminando com sábado.
Linhas 20: define as horas como 19.
Linha 21: define os minutos como 15.
Linha 22: define os segundos como 50.
No “void loop()”, vamos escrever todos os dados do RTC no monitor serial. Começamos com a data e temperatura e, ao fim, usamos um novo recurso de programação para mostrar o dia da semana.
Linha 30: procura, no módulo, o valor corresponde ao dia e imprime.
Linhas 31: Imprime um traço.
Linha 32: procura, no módulo, o valor correspondente ao mês e imprime.
Linhas 33: Imprime um traço.
Linhas 34: Imprime o valor 20. O módulo retorna um valor de 1 a 99. Por isso, para imprimir “2020” temos que escrever 20 antes do valor vindo do RTC.
Linha 35: procura, no módulo, o valor correspondente ao ano e imprime.
Linha 36: imprime um espaço vazio.
Linha 37: procura, no módulo, o valor corresponde a hora e imprime.
Linha 38: imprime dois pontos.
Linha 39: procura, no módulo, o valor corresponde aos minutos e imprime.
Linha 40: imprime dois pontos.
Linha 41: procura, no módulo, o valor corresponde aos segundos, imprime e pula para a próxima linha.
Linha 42 imprime “Temperatura =”.
Linha 43: procura, no módulo, o valor corresponde a temperatura, imprime e pula para a próxima linha.
Para escrever o dia da semana precisamos pegar o valor armazenado dentro do RTC, verificar qual é esse valor e imprimir na tela o dia da semana equivalente. Para isso, usamos a ferramenta condicional “if” vista em aulas anteriores.
Linha 47: O condicional “if” verifica se o valor armazenado no RTC é o número 1.
Linha 48: Se o número armazenado for o 1, imprime na tela “Domingo”.
Linha 49: O condicional “if” verifica se o valor armazenado no RTC é o número 2.
Linha 50: Se o número armazenado for o 2, imprime na tela “Segunda”.
Todos os outros “if” do código fazem a mesma coisa, isto é, pesquisam o valor armazenado e imprimem o dia da semana equivalente.
Para saber mais:
Podemos usar outra ferramenta de programação para não escrever tantos “ïf”. Essa ferramenta chama-se “Switch, case” e torna-se útil em situações em que temos apenas uma condição e diferentes resultados. Por isso, ela é ideal no nosso código.
#include <Wire.h>
#include <DS3231.h>
DS3231 rtc;
bool Century;
bool h12;
bool PM;
void setup() {
Wire.begin();
Serial.begin(9600);
// O bloco abaixo define a data e a hora de partida do sensor
rtc.setDate(26);
rtc.setMonth(10);
rtc.setYear(20);
rtc.setDoW(5);// Domingo = 1 ... Sábado = 7
rtc.setHour(19);
rtc.setMinute(15);
rtc.setSecond(50);
}
void loop() {
//O bloco abaixo escreve o horário, a data e a temperatura na tela.
Serial.print(rtc.getDate());
Serial.print('-');
Serial.print(rtc.getMonth(Century));
Serial.print('-');
Serial.print("20");
Serial.print(rtc.getYear());
Serial.print(' ');
Serial.print(rtc.getHour(h12,PM));
Serial.print(':');
Serial.print(rtc.getMinute());
Serial.print(':');
Serial.println(rtc.getSecond());
Serial.print("Temperatura = ");
Serial.println(rtc.getTemperature());
// O bloco abaixo escreve o dia da semana na tela.
switch (rtc.getDoW()){
case 1:
Serial.println("Domingo");
break;
case 2:
Serial.println("Segunda");
break;
case 3:
Serial.println("Terça");
break;
case 4:
Serial.println("Quarta");
break;
case 5:
Serial.println("Quinta");
break;
case 6:
Serial.println("Sexta");
break;
case 7:
Serial.println("Domingo");
break;
}
}
Linha 47: usamos o “switch” e colocamos dentro dos parênteses dele o valor armazenado do dia da semana.
Linha 49: verifica se o valor da condição dentro dos parênteses do “Switch” é o número 1.
Linha 50: Se o valor armazenado no RTC for o número 1, imprime “Domingo”.
Linha 51: O “break” fecha o “switch” impedindo de checar os outros casos.
Nas linhas seguintes, o código verifica cada valor de 1 a 7 e para quando encontrar o valor armazenado no RTC.
Para saber mais:
Além do “Switch,case”, podemos usar os vetores computacionais para imprimir os dias da semana. Essa ferramenta é utilizada para guardar informações que seriam necessárias várias variáveis para fazer o mesma coisa. No nosso caso, como temos apenas 7 dias da semana e o RTC indexa valores em ordem de 1 a 7, podemos usar essa mesma ferramenta para armazenar o caracteres dos dias da semana e usar o “for” para acessar esses caracteres dentro desses vetores. Os vetores, no Arduino, são indexados em zero, ou seja, a primeira posição é a posição Zero. Dessa forma, quando criamos um vetor de 5 posições, elas vão de Zero a 4. Além disso, mudamos o bloco que escreve a data e o horário. Perceba que não é necessário pular uma linha toda vez que colocamos um ponto e vírgula (;).
#include <Wire.h>
#include <DS3231.h>
DS3231 rtc;
bool Century;
bool h12;
bool PM;
char dias_da_semana [7][8] = {"Domingo","Segunda","Terca", "Quarta", "Quinta", "Sexta", "Sabado"};
void setup() {
Wire.begin();
Serial.begin(9600);
// O bloco abaixo define a data e a hora de partida do sensor
rtc.setDate(26);
rtc.setMonth(10);
rtc.setYear(20);
rtc.setDoW(2);// Domingo = 1 ... Sábado = 7
rtc.setHour(19);
rtc.setMinute(15);
rtc.setSecond(50);
}
void loop() {
//O bloco abaixo escreve o horário, a data e a temperatura na tela.
Serial.print(rtc.getDate()); Serial.print('-'); Serial.print(rtc.getMonth(Century));Serial.print('-');Serial.print("20");Serial.print(rtc.getYear());
Serial.print(' ');
Serial.print(rtc.getHour(h12,PM));Serial.print(':');Serial.print(rtc.getMinute());Serial.print(':');Serial.println(rtc.getSecond());
Serial.print("Temperatura = ");Serial.println(rtc.getTemperature());
// O bloco abaixo escreve o dia da semana na tela.
for(int i = 1; i <= 7; i++){
Serial.print (dias_da_semana [rtc.getDoW()-1] [i-1]);
}
Serial.println();
delay(1000);
}
Linha 10: criamos 7 vetores com 8 espaços para caracteres e colocamos os dias da semana nesses vetores. Escolhemos 7 vetores porque temos 7 dias da semana e 8 caracteres porque o dia da semana com mais caracteres é “Domingo”.
Linha 32: escreve a data.
Linha 34: escreve as horas e pula uma linha.
Linha 35: escreve a temperatura e pula uma linha.
Linha 39: “for” para acessar os caracteres dentro dos vetores. Como os valores armazenados dentro do RTC vão de 1 a 7, a variável “i” começá em 1, termina em 7 e é incrementada de 1 em 1.
Linha 40: imprime o dia da semana acessando os caracteres dentro dos vetores criados na linha 10. Os colchetes são utilizados para definir qual vetor e qual posição dentro desse vetor vamos acessar. Lembre-se que os vetores no Arduino são indexados em Zero. Assim, o primeiro colchete ( [rtc.getDoW () – 1] ) pega o valor armazenado no RTC e diminui uma unidade. Fazemos isso para acessar o dia da semana correto. O segundo colchete ([i – 1]) acessa os caracteres dentro dos vetores. Temos que diminuir uma unidade, já que os vetores começam em Zero. Perceba que o “for” possibilita a impressão dos dias da semana por caracteres individuais.
Linha 41: Fecha as chaves do “for”.
Linha 42: Pula uma linha.
Linha 43: Espera 1000 milissegundos, isto é, 1 segundo.
Agora que sabemos como trabalhar com o módulo RTC, vamos construir o circuito para nossos peixinhos. Não podemos nos esquecer deles!
Nesta montagem, mantemos as ligações do exemplo anterior e adicionamos dois LEDs, um vermelho e outro Azul. Veja o desenho esquemático abaixo para auxiliar na montagem do circuito.
A imagem abaixo mostra como devemos montar esse circuito. A única mudança em relação primeiro circuito é a adição de mais dois passos. Assim, no mesmo circuito do exemplo anterior, adicione os dois resistores de 470 Ω e dois LEDs, um azul e outro vermelho, conforme mostrado no passo 4. A imagem 5 mostra o circuito em funcionamento após fazer o upload da programação adiante.
Para ligar e desligar os LEDs, vamos adicionar no código a configuração inicial dos LEDs e as condições para ligar esses LEDs. Recomenda-se que as luzes do aquário estejam ligadas por 8 horas, ou seja, queremos que os LEDs liguem e permaneçam ligados por 8 horas. Para isso, definimos que os LEDs liguem as 7 da manhã e desliguem as 15 da tarde.
#include <Wire.h>
#include <DS3231.h>
DS3231 rtc;
bool Century;
bool h12;
bool PM;
char dias_da_semana [7][8] = {"Domingo","Segunda","Terca", "Quarta", "Quinta", "Sexta", "Sabado"};
void setup() {
Wire.begin();
Serial.begin(9600);
// O bloco abaixo define a data e a hora de partida do sensor
rtc.setDate(26);
rtc.setMonth(10);
rtc.setYear(20);
rtc.setDoW(2);// Domingo = 1 ... Sábado = 7
rtc.setHour(6);
rtc.setMinute(59);
rtc.setSecond(45);
// O bloco abaixo configura os LEDs
pinMode (2,OUTPUT);
pinMode (4,OUTPUT);
}
void loop() {
//O bloco abaixo escreve o horário, a data e a temperatura na tela.
Serial.print(rtc.getDate()); Serial.print('-'); Serial.print(rtc.getMonth(Century));Serial.print('-');Serial.print("20");Serial.print(rtc.getYear());
Serial.print(' ');
Serial.print(rtc.getHour(h12,PM));Serial.print(':');Serial.print(rtc.getMinute());Serial.print(':');Serial.println(rtc.getSecond());
Serial.print("Temperatura = ");Serial.println(rtc.getTemperature());
// O bloco abaixo escreve o dia da semana na tela.
for(int i = 1; i <= 7; i++){
Serial.print (dias_da_semana [rtc.getDoW()-1] [i-1]);
}
Serial.println();
delay(1000);
if((rtc.getHour(h12,PM) == 7)&& ((rtc.getMinute() == 0))){
digitalWrite(2,HIGH);
digitalWrite(4,HIGH);
}
if((rtc.getHour(h12,PM) == 15)&& ((rtc.getMinute() == 0))){
digitalWrite(2,LOW);
digitalWrite(4,LOW);
}
}
Linhas 28 e 29: definem os pinos 2 e 4 como saída para os LEDs.
Linha 51: “if” que verifica se os valores, armazenados no RTC, correspondentes as horas é são os números 7 e Zero.
Linhas 52 e 53: liga os LEDs nos pinos 2 e 4.
Linha 56: “if” que verifica se os valores, armazenados no RTC, correspondentes as horas é são os números 15 e Zero.
Linhas 57 e 58: desliga os LEDs nos pinos 2 e 4.
Dessa forma, os LEDs ligarão as 7 da manha e desligarão as 15 da tarde.
Nesse projeto aprenderemos sobre um novo componente: o sensor de temperatura e umidade DHT11. Esse componente possui uma propriedade termométrica, ou seja, quando há uma pequena variação da temperatura, também há uma pequena alteração na quantidade de eletricidade. Depois que você aprender a utilizar esse sensor, vai poder medir a temperatura do local que desejar. Não recomendamos por esse circuito em lugares muito úmidos, já que pode danificar algum dos componentes.
A medição de temperatura e umidade são parâmetros muito utilizados na nossa sociedade. Com certeza, você conhece alguém que só sai de casa após saber a temperatura do dia. Da mesma forma, a medição de umidade é importante para quem tem problemas respiratórios, já que um clima mais seco torna a respiração mais difícil para esse público. Com o Arduino, você pode medir a temperatura dentro do seu robô e ver se ele não está superaquecendo e, assim, evitar um desastre.
Imagens reais de uma pessoa no inverno de Cuiabá
Para usar esse sensor com o Arduino, temos que entender como funciona a pinagem desse componente, ou seja, qual é a função de cada pino. Para isso, nós pegamos as informações do datasheet, ou seja, do manual de instruções desse componente e colocamos na imagem ao lado. No entanto, quando você for utilizar um componente que não está presente neste curso ou que seja recém fabricado, sempre olhe o datasheet do componente e observe as especificações técnicas e a pinagem. Para encontrar o datasheet de qualquer componente, basta escrever o código escrito no componente e “datasheet” no google.
Como fizemos nas ultimas aulas, o pino 1 tem que ser ligado na tensão de 5 V e o pino 4 deve ser conectado no pino GND, conforme especificado pelo fabricante. A novidade aqui está no incremento do pino “Dados”. Esse pino é quem transmitir as informações do sensor para o Arduino. Como a temperatura é um valor que varia no tempo, nós temos que liga-lo na portas analógicas do Arduino. As portas analógicas são aquelas em que possuem um “A” na frente do número. O pino “N.C.” não é utilizado nas ligações com o Arduino.
Além dessa mudança nas ligações, a programação também será diferenciada. Teremos que adicionar a biblioteca especifica para esse sensor. Em computação, bibliotecas são utilizadas quando o microcontrolador, o Arduino ou qualquer outro microcontrolador, não possui recursos para entender a linguagem usada no componente externo. Assim, como o Arduino não entende, sozinho, as configurações internas do DHT11, temos que colocar um biblioteca especifica desse sensor. Depois disso, o Arduino consegue se comunicar o sensor sem problemas.
Mesmo com a introdução de novas bibliotecas, temos que achar uma maneira de mostrar o resultado para o usuário. Até agora, nós conhecemos apenas duas formas de fazer o Arduino se comunicar com o usuário: LEDs e display de sete segmentos. Mas essas duas ferramentas não são boas nesse caso. Então, vamos usar o monitor Serial do próprio Arduino. Para isso, clique na lupa no canto superior direito da sua tela. Lembre-se que o Arduino deve estar conectado com o computador par que isso o monitor abra.
Vamos ver as características do sensor:
Modelo: DHT11 Faixa de medição de umidade: 20 a 90% UR – Faixa de medição de temperatura: 0 ºC a 50 ºC – Alimentação: 3-5 V – Corrente: 200 uA a 500 mA – Precisão de umidade de medição: ± 5,0% – Precisão de medição de temperatura: ± 2.0 ºC – Tempo de resposta: 2 segundos – Dimensões: 23 x 12 x 5 mm (incluindo terminais)
Você vai precisar de:
Protoboard
Arduino
3 LEDs: Vermelho, Amarelo e Azul
Sensor de temperatura e umidade DHT11
Simulação
Esse componente não está disponível no tinkercad ou no Fritzing. Por isso, não se preocupe em reproduzir essa simulação. Abaixo, temos como deve ser feita a ligação do DHT11 na protoboard.
Antes de começar a programar esse sensor, precisamos instalar a biblioteca dele. Para isso, abra o Arduino IDE e clique na aba “Sketch”. Então, passe para “include library” e, então , clique em “manage libraries”. Se quiser, pode-se usar o atalho de teclado Ctrl + Shift + i.
Agora, escreva o código do sensor no espaço de busca. Perceba que existem varias pessoas que escreveram códigos de comunicação do Arduino com o DHT11. Aqui, nós vamos utilizar o código do Winlin. Então, clique em “Install”.
Ao usar uma biblioteca diferente das previamente instaladas no Arduino, é recomendável procurar quais são as funções que ela suporta , isto é, o que é possível de ser feito com ela. A forma mais fácil de descobrir essas funções é buscando, nos exemplos, do Arduino IDE. Neste curso, vamos mostrar como utilizar os sensores mais comuns. No entanto, quando for usar um sensor novo, faça os exemplos, é a forma mais fácil de entender quais são as funções mais importante e como utilizá-las. Na imagem abaixo, mostramos o caminho para achar os exemplos da biblioteca “SimpleDHT”.
Para utilizar uma biblioteca que não está embutida no Arduino, deve-se incluí-la antes do “void setup()” como na linha 1 do código abaixo. A inclusão dessa biblioteca vai mostrar para o Arduino qual é a linguagem que o sensor entende e, assim, possibilita a comunicação entre o Arduino e o sensor. Sempre que colocamos um novo sensor no circuito, temos que, na programação, adicionar a biblioteca desse sensor. Na linha 5, usamos a linguagem do sensor para configurar onde o DHT11 está ligado. No “void setup()”, temos que definir a taxa de transferência de dados entre o programa e o Monitor Serial. Os valores possíveis para essa transmissão estão exibidos dentro do monitor Serial. Para acessar o monitor clique Ctlr+M ou no símbolo indicado pelo círculo vermelho da imagem abaixo. Nesta aula, não temos que colocar um valor especifico, ou seja, não faz diferença qual valor do monitor você escolher, desde que o “Serial.begin()” na linha 8 da programação seja o mesmo.
Para escrever nesse Monitor do Arduino, usamos duas funções. O “Serial.print()” escreve o que estiver dentro dos parênteses quando estiver entre aspas. O “Serial.println()” faz a mesma coisa e pula para a linha abaixo. Agora, vamos analisar o que ocorrendo dentro do “void loop()”:
Linha 13 e 14: Escrevemos no Monitor e pulamos uma linha.
Linha 16 e 17: declaramos duas variáveis do tipo “byte” para armazenar os valores de temperatura e umidade.
NOTA: A biblioteca no “SimpleDHT” determina que a leitura dos valores de temperatura e umidade seja feita em uma variável do tipo “byte”. Por isso, temos que declarar a variável desse tipo e depois, para imprimir na tela, temos que transformá-la em “int”, ou seja, em inteiro. Essa transformação foi feita nas linhas 27 e 28.
Linha 18: Declaramos uma variável do tipo “int”e guardamos nela a leitura dos dados.
Linha 20: Usamos a condição “if” para avaliar se a leitura foi feita com sucesso.
NOTA: A biblioteca fornece a função “SimpleDHTErrSuccess” que avalia se a leitura foi feita de forma correta.
Linha 21: Imprime uma mensagem de erro no Monitor se houver erro na leitura dos dados.
Linha 26, 27 e 28: Imprime os valores de temperatura e umidade na tela.
NOTA: Perceba que para imprimir o valor dentro de uma variável, não coloca-se as aspas.
#include <SimpleDHT.h>
int pino_DHT11 = 2; // Define o pino conectado no terminal Dados do DHT11
SimpleDHT11 dht11(pino_DHT11);
void setup() {
Serial.begin(115200);// Define a taxa de transferência de dados para o monitor Serial
}
void loop() {
Serial.println("=================================");
Serial.println("Amostra DHT11...");
byte temperatura = 0;
byte umidade = 0;
int leitura = dht11.read(&temperatura, &umidade, NULL);
if (leitura != SimpleDHTErrSuccess) {
Serial.print("Falha na leitura do DHT11, leitura="); Serial.println(leitura);
delay(1000);
return;
}
Serial.print("Amostra OK: ");
Serial.print((int)temperatura); Serial.print(" *C, ");
Serial.print((int)umidade); Serial.println(" H");
delay(1500);
}
DICA: É comum usar o monitor serial para fazer um debug do código, isto é, imprimir, por exemplo, variáveis no monitor, para descobrir se os valores são coerentes com o previsto.
1) Montagem Prática
Esses são os componentes necessários para montar o circuito.
Alimente a protoboard com 5 V e o Terra. Conecte um jumper vermelho no pino de 5 V do Arduino e na protoboard. Depois, ligue um jumper preto no pino GND do Arduino e na protoboard.
Coloque o DHT11 conforme indicado na figura e, com outros jumpers, faça as conexões de alimentação, ou seja, conecte um lado do jumper vermelho na trilha do terminal Vcc do DHT11 e o outro lado na trilha 5 V da protoboard. Analogamente, conecte um lado do jumper preto no terminal GND do DHT11 e o outro lado do jumper na trilha GND da protoboard.
Por fim, conecte mais um jumper no pino 2 do Arduino e na trilha do terminal de dados do DHT11.
https://roboteducation.com.br/wp-content/uploads/dribbble-ardusat.gif600800Thiagohttps://roboteducation.com.br/wp-content/uploads/logo-robot-education-wide.pngThiago2021-07-02 10:45:172022-10-01 11:28:20Medidor de temperatura
Voltando para as sirenes, você acha difícil ouvir o som das sirenes nas ruas?
Então, a polícia de Nova York acha que sim. Para entender a situação deles, imagine uma situação na qual você está distraído enquanto dirige com som alto e falando no celular. Além desse comportamento ser ilegal, você pode não ouvir a sirene das ambulâncias. Para contornar o problema, a polícia de Nova York está implantando uma tecnologia chamada “The Rumbler”. Com esse novo projeto, as sirene vão, além do barulho, emitir “sons” que vão “chacoalhar” o veículo e o motorista, fazendo com que elas sejam literalmente sentidas. De acordo com os responsáveis, as vibrações podem ser notadas a uma distância de até 60 metros, mesmo com as janelas do carro fechadas. Esse novo sistema já está recebendo críticas, já que pode assustar os motoristas as pessoas que perto de de rodovias em que o carros de policia passam.
Ueun x30
Nessa aula, vamos ver como criar sons com o Arduino utilizando um buzzer. Esse buzzer também é chamado de transdutor piezoelétrico. Os buzzers funcionam transformando a energia elétrica do Arduino em vibrações que geram som. Os auto falantes convencionais funcionam da mesma forma. O som que ouvimos é a vibração de partículas no ar. Nossos ouvidos captam esse som e transforma em impulsos nervosos para o cérebro interpretar. Uma das características que todo tem, junto com o volume, é a frequência. Nosso corpo consegue entender frequências de 20 Hz a 20.000 Hz. Quanto mais próximo de 20, chamamos de sons graves. Se a frequência está mais próxima de 20.000 Hz, denominamos esses sons de agudos. Não conseguimos ouvir sons abaixo de 20 Hz e acima de 20.000 Hz, mas chamamos esses sons de infrassom e ultrassom, respectivamente.
Na imagem acima, temos um buzzer típico encontrado no mercado de produtos eletrônicos Na imagem abaixo temos o buzzer encapsulado. Os dois são iguais em termos de funcionamento. Então, a única diferença entre eles é estético.
Vamos precisar de:
Arduino
Protoboard
Buzzer piezoelétrico encapsulado
LEDs de diferentes cores
4 resistores de 220 Ω
Montagem Prática
Como não é possível ouvir o buzzer tocando através do simulador, vamos partir diretamente para a construção do circuito simples apenas com a presença do Buzzer e o Arduino. Para isso, monte o circuito conforme a figura abaixo.
É na programação onde vamos determinar os sons que o buzzer vai emitir. No código abaixo escolhemos tocar todas as frequências sonoras fundamentais. Para isso, usamos a função “tone (pino, frequência)”. Fique a vontade para mudar as frequências do código e ouvir os mais variados sons. Lembre-se que nós, humanos, só podemos ouvir sons com frequência entre 20 Hz e 20.000 Hz.
void setup() {
pinMode(3,OUTPUT);
}
void loop() {
tone(3,440); // Do
delay (150);
tone(3,494); // Re
delay (150);
tone(3,523); // Mi
delay (150);
tone(3,587); // Fa
delay (150);
tone(3,659); // Sol
delay (150);
tone(3,698); // La
delay (150);
tone(3,784); // Si
delay (150);
}
Linha 2: Definimos o pino 3 como saída.
Linha 6: Emite som com 440 Hz de frequência no pino 3.
Linha 8: Emite som com 494 Hz de frequência no pino 3.
Linha 10: Emite som com 523 Hz de frequência no pino 3.
Linha 12: Emite som com 587 Hz de frequência no pino 3.
Linha 14: Emite som com 659 Hz de frequência no pino 3.
Linha 16: Emite som com 698 Hz de frequência no pino 3.
Linha 18: Emite som com 784 Hz de frequência no pino 3.
Sirene de polícia
Para programar a sirene de polícia, precisamos que frequência varie do agudo para o grave e vice-versa. Para isso, construímos um loop para alterar o valor de frequência até o máximo desejado e depois construímos outro loop para variar esse mesmo valor até o mínimo desejado.
int freq = 0;
void setup(){
pinMode(3,OUTPUT); //Pino do buzzer
}
void loop(){
for (freq = 2000; freq < 3000; freq++) {
tone(3, freq);
delay(2);
}
for (freq = 3000; freq > 2000; freq--) {
tone(3, freq);
delay(2);
}
}
Linha 1: Cria a variável “freq” do tipo inteiro que armazenará o valor de frequência.
Linha 4: Define o pino 3 como saída.
Linha 9: A variável “freq” começa em 2000, vai até 3000 e é incrementada uma unidade por vez.
Linha 11: Emite o Som no pino 3 e na frequência do valor armazenado em “freq”.
Linha 14: A variável “freq” começa em 3000, vai até 2000 e é decrementada uma unidade por vez.
Linha 16: Emite o Som no pino 3 e na frequência do valor armazenado em “freq”.
Para saber mais:
Perceba que o valor armazenado em “freq” varia de 2000 a 3000, ou seja, a frequência emitida pelo buzzer vai variar de 2000 Hz até 3000 Hz. Então, podemos usar a função seno para representar essa oscilação nos valores de frequência. No código abaixo, fizemos a mesma sirene do exemplo anterior, mas usando a função seno.
void setup(){
pinMode(3, OUTPUT);
}
void loop(){
int freq = 0;
float seno = 0;
for(int i = 0; i < 180; i++){
//converte graus para radiando e depois obtém o valor do seno
seno = sin(i*3.1416/180);
// Com base no valor do Seno, criamos uma frequencia entre 2000 Hz e 3000Hz
freq = 2000 + (int(seno*1000));
tone(3,freq);
delay(2);
}
}
// Crédito para Allan Mota do site "vida de silício".
Linha 2: Declaramos o pino 3 como saída.
Linhas 7 e 8: Criamos a variável “freq” do tipo “int” e inicializamos com Zero. Criamos a variável “seno” do tipo “float” e iniciamos com Zero.
Linha 10: Criamos a variável “i” e inicializamos com Zero. Essa variável vai de Zero a 180 sendo incrementada em uma unidade a cada iteração.
Linha 12: Transformamos o valor de “i” em radianos e calculamos o seno desse valor. Então, colocamos esse valor na variável “Seno”.
Linha 14: colocamos na variável “freq” o valor de frequência desejado. Esse valor vai variar de 2000 até 3000, já que a variável “seno” tem, necessariamente, um valor entre o e 1 e estamos multiplicando esse valor por 1000. Em seguida, como a variável “freq” é do tipo “int” e a variável “seno” é do tipo “float”, temos que transformar o resultado da multiplicação “seno*1000” em um valor inteiro. Por isso, colocamos a multiplicação em parenteses e adicionamos “int” ao lado.
Linha 15: Emite som com um valor de frequência armazenado dentro da variável “freq” no pino 3.
Sirene de Policia 2.0
Agora que sabemos fazer sons no Buzzer, refaça o circuito da sirene na segunda aula e adicione o buzzer. Abaixo temos o passo a passo da forma como devemos construir esse circuito. Na imagem 1 temos os componentes necessários para construção desse circuito e na imagem seguinte mostramos a montagem do buzzer na protoboard. A imagem 3 representa as conexões necessárias para ligar os LEDs.
Na programação, basta adicionar o código da segunda aula no código dos exemplos acima. No entanto, precisamos alterar o tempo em que o LED ficará ligado. Por isso, mudamos de 200 milissegundos para 15 milissegundos para que os LEDs pisquem mais rápido na linha 17.
void setup()
{
for(int i= 8;i < 12; i++){
pinMode(i, OUTPUT);
}
pinMode(3, OUTPUT);
}
void loop()
{
int freq = 0;
float seno = 0;
for(int i = 8; i <= 10; i++ ){
digitalWrite(i, HIGH);
digitalWrite(i+1, HIGH);
delay(15);// Espera 15 milisegundos
digitalWrite(i, LOW);
digitalWrite(i+1, LOW);
}
for(int i = 0; i < 180; i++){
//converte de graus para radianos e depois obtém o valor do seno
seno = sin(i*3.1416/180);
// Com base no valor do Seno, criamos uma frequencia entre 2000 Hz e 3000Hz
freq = 2000 + (int(seno*1000));
tone(3,freq);
delay(2);
}
}
https://roboteducation.com.br/wp-content/uploads/dribbble-ardusat.gif600800Thiagohttps://roboteducation.com.br/wp-content/uploads/logo-robot-education-wide.pngThiago2021-07-01 16:03:072022-10-01 11:31:30Sirene de polícia
Você sabia que a sirene foi criada como instrumento musical e que significa sereia?
Pois é. Foi o escocês Josh Robinson quem a criou no final do século 18. A origem do significado remete a mitologia grega. As sereias cantavam com muita doçura e atraiam os navios que passavam por elas. O canto delas era hipnótico e seduzia os marinhos a ponto deles baterem o navios e afundassem. Odisseu, personagem da Odisseia, de Homero, conseguiu salvar-se delas porque colocou cera nos ouvidos dos seus marinheiros e amarrou-se ao mastro de seu navio, para poder ouvi-las sem aproximar-se delas. Foi essa a ideia do francês Charles Cagniard de la Tour, em 1819, quando ele batizou e aprimorou esse equipamento tão usado hoje me dia. O termo “sirene” foi importado do idioma francês. Mesmo sendo um aparelho antigo, ele foi popularizado mais tarde.
No Reino Unido, o som das sirenes foi incorporado pelos bombeiros em 1964. Antes de ficar popular em veículos de emergência, os bombeiros usavam sinos, apitos e chocalhos para abrir caminho e alertar a população, além dos sinais luminosos.
Nessa aula com Arduino vamos construir, com LEDs, o mesmo efeito dos sinalizadores rotativos intermitentes (esse é o nome correto, mas a gente conhece por “giroflex”).
Ueum [x30]
Materiais necessários:
Arduino
Protoboard
4 resistores de 220 Ω.
1 Resistor de 10kΩ.
4 LEDs de qualquer cor.
Chave Táctil.
Vamos para o Arduino daqui a pouco, mas quero falar um pouco de cada um dos componentes usados nesta aula.
Resistor
Como visto anteriormente, o resistor é um limitador de corrente elétrica, ou seja, quando adicionamos um resistor no circuito, a corrente diminui. Nesse projeto, vamos utilizar o resistor de 470Ω.
De acordo com a tabela de cores, seu resistor deve ter o seguinte padrão de cores:
1 Faixa: Amarelo, para indicar o numero 4
2 Faixa:Violeta, para indicar o numero 7
Multiplicador: Marrom, para indicar que o número acima deve ser multiplicado por 10.
Tolerância: Normalmente, Ouro, para indicar uma tolerância de 5% para mais ou para menos.
LED
A sigla LED vem, do inglês, Light-Emitting-Diode. Isso significa Diodo Emissor de Luz. O diodo é todo componente que tem polaridade anodo(A) e catodo (K), conforme indicado na figura ao lado. Agora, pegue o seu diodo. Você vai perceber que ele é redondo na base, mas tem um lado em que está reto, ou seja, esse lado tem um chanfro. O lado que você achou o chanfro, como na figura, é o catodo. Nós temos que ligar o catodo no GND da placa do Arduino. Alem disso, o LED não vai funcionar se invertermos o posicionamento correto dele.
O desenho do triângulo de lado é a representação dele em esquemas elétricos. Esse desenho é feito toda vez que queremos mostrar que utilizamos o diodo no nosso circuito.
Outra forma de avaliar quem é o anodo e o catodo de um LED é observar o tamanho dos terminais, ou seja, das “perninhas” do LED. Alem disso, o Anodo (A) e catodo(K) também podem ser chamados de Positivo e Negativo, respectivamente. Perceba que existem várias formas de se referir a um LED. Por isso, é importante conhecer todas elas.
Botão Táctil
Esse botão também tem vários nomes. Ele pode ser chamado de Chave táctil ou Push Button. Os botões são um componentes muito utilizados em qualquer circuito eletrônico. Ele pode iniciar ou terminar um processo dependendo de como são feitas as ligações ou de como o botão vai ser programado. Além desse tipo de botão, existem muitos outros modelos e estilos e formar de funcionamento. Aqui, vamos focar no uso do botão ao lado.
Esse botão é fácil de conectar. Mas é necessário que você saiba como ele foi construído. Por isso, temos a imagem abaixo para que você confira como as ligações são feitas internamente. Assim, para que o botão funcione, é necessário que você ligue os terminais opostos ao simbolo da chave no seu circuito.
Simulação 1
Vamos começar esse exemplo no ambiente da simulação. Para isso, Abra o programa Tinkercad. Após fazer seu cadastro e clicar em “Novo Circuito”, procure por “placa de ensaio” no espaço de pesquisa. Essa é a tela em que vamos criar nosso circuito. Agora, pegue e a Placa de ensaio, ou seja, a Protoboard e coloque no espaço ao lado.
Em seguida faça a mesma com o Arduino. Escreva, no espaço de pesquisa, a “Arduino Uno” e arraste-o para a tela ao lado.
Para ocupar menos espaço na tela, colocamos o Arduino em cima da placa. Mas isso não é necessário. Agora procure o LED e repita o procedimento anterior.
Nesse momento, vamos começar a fazer as ligações na placa. Clique no pino de 5 V do Arduino e faça o fio chegar até o pino selecionado na figura. Para fazer com que o fio faça curvas, basta clicar na tela enquanto move o fio de um pino para o outro. Se você conectar o fio de 5 V no mesmo pino da figura, lembre-se que todos os pinos ao lado estão conectados entre si, ou seja, os 5 V estão em todos os pinos da linha horizontal. Quando você terminar de fazer a ligação, mude a cor do fio para vermelho. Esse é um padrão que vamos adotar para saber quais fios tem a tensão do Arduino.
Em seguida, faça as ligações do GND e do LED, conforme demonstrado na figura abaixo. É recomendável que o fio GND seja sempre preto. Assim, saberemos quais fios tem 0 V. A ligação do LED no Arduino deve ser feita com o terminal Anódico. Passe o mouse por cima das “Perninhas” do LED. O Tinkercad vai te mostrar qual é o terminal catódico e o anódico. Agora, procure o resistor na barra de pesquisa ao lado. Quando você arrasta-lo para a tela ao lado, mude o valor de resistência de “1” para “470”. Não se esqueça de mudar, também, de kΩ para Ω.
Para terminar as ligações, coloque o resistor no terminal catódico do LED e depois ligue o outro terminal do resistor no GND.
Como dito anteriormente, o Arduino é um microcontrolador que, para funcionar, precisa de uma ligação entre componentes e a programação dessas entradas. Neste estágio, vamos programar o Arduino para que ele mande o LED ligar e desligar de 1 em 1 segundo. Para começar, vamos dizer para o Arduino que o LED está ligado no pino 8 e que ele deve controlar esse LED. Para isso, clique no botão escrito”código” ao lado de “Iniciar Simulação” . Clique onde diz “bloco” e mude para “texto”. O comando “pinMode(8,OUTPUT);” escrito no código abaixo, diz para o Arduino que no pino 8 há uma saída de dados.
As linhas de programação dentro das chaves de “void setup ()” vão ser executadas apenas uma vez. Elas funcionam como as configurações iniciais do Arduino. Sempre temos que dizer pra ele em qual pino o sensor ou LED está ligado. Da mesma forma, sempre temos que informar se o Arduino vai controlar ou vai receber dados do componente. Se o Arduino controla o componente, vamos colocar na programação, “OUTPUT”. Enquanto isso, se o Arduino é quem recebe informações do componente, na programação, temos que escrever “INPUT”. Por exemplo, um LED vai sempre ser controlado pelo Arduino e o botão sempre vai informar pro Arduino se ele tá acionado ou não, ou seja, o LED sempre é OUTPUT e o Botão sempre é INPUT.
Nas próximas linhas de programação, vamos falar para o Arduino o que ele deve fazer para sempre. Para isso, devemos escrever essas linhas de código dentro das chaves de “void loop ()”. Como queremos que o LED pisque, precisamos pedir para o Arduino ligar, esperar 1 segundo e desligar.
Como essas linhas de programação estão dentro das chaves “void loop ()”vão ser executadas enquanto o Arduino estiver ligado no seu computador ou em uma alimentação externa, ou seja, se você não mudar o código ou desligar o Arduino, ele vai ficar ligando e desligando o LED para sempre.
A linha 8 “digitalWrite (8, HIGH);”: faz com que o Arduino mande uma tensão de 5 V no LED.
A linha 9 “delay (1000);”: faz com que o Arduino espere 1 segundo.
A linha 10 “digitalWrite (8, LOW)”: faz com que o Arduino mude a tensão no LED para 0 V.
A linha 11 “delay (1000);”: faz com que o Arduino espere 1 segundo.
Acabou. Seu primeiro programa com Arduino está pronto. Agora, clique em “Iniciar Simulação” par ver se tudo está funcionando. O LED deve estar piscando lentamente.
DICA: O programa deve ser escrito, exatamente, como está no exemplo. O Arduino é bem chato com a linguagem de programação. Tudo deve estar do jeito que ele entende.
Existe uma outra forma mais elegante de falar pra o Arduino onde está o LED que você conectou. Para isso, vamos usar o comando “#define LED 8”. Então, podemos mudar todo lugar que tem o número 8 para a palavra LED. Desse jeito, fica mais fácil de entender o seu código.
Seguindo a mesma ideia do exemplo anterior, vamos começar a colocar mais LEDs no ambiente de simulação. Depois, mostramos a montagem do circuito. Assim, coloque no circuito mais 3 LEDs. Nós vamos piscar um LED de cada vez. Tome cuidado para coloca-los em trilhas verticais diferentes um do outro. Em seguida, faça as ligações dos terminais anódicos com as entradas do Arduino. Você pode escolher as entradas que desejar. No entanto, a programação vai ficar mais fácil se você conectar nos mesmos pinos que nós conectamos. Por fim, conecte o terminal catódico de cada LED no mesmo terminal GND. Para isso, basta conecta-los na mesma linha horizontal. Como mostrado na figura.
DICA: Veja como os pinos da protoboard estão conectados para entender por que colocamos todos os fios pretos na mesma linha.
Para programar todos esses LEDs, basta repetir as linhas que usamos no programa anterior e adicionar as configurações dos novos LEDs. Da mesma forma, precisamos adicionar o pisca para cada novo LED. Nesse programa, diminuímos o tempo em que o LED pisca para 0,5 segundos. Assim, o programa vai ficar como na imagem abaixo.
Da mesma forma que o programa anterior, existe uma forma melhor dar esses comandos para o Arduino sem precisar escrever tantas linhas de código. Para isso, vamos usar o “for”. Essa estrutura de repetição é muito utilizada na programação. Ela tem 3 modos de funcionamento:
Determinação de um valor inicial para uma variável.
Critério para limitar a repetição desse laço e, consequentemente, os comandos dentro das chaves desse laço.
Incremento do valor dessa mesma variável.
Portanto, o uso do laço “for” serve para que os comandos dentro desse laço se repitam enquanto o valor de “i” não chega no limite pré definido. Nesse exemplo, esse “i” é uma variável criada no inicio do código com o valor de zero. As variáveis são necessárias para colocar diferentes valores dentro dela enquanto executamos o código. Por convenção, sempre quando declaramos uma variável, colocamos o valor Zero dentro dela. Mas isso não é regra.
Como base nesse laço “for” fizemos com que os LEDs pisquem um de cada vez do mesmo jeito que no código anterior. Agora, vamos analisar, no código acima, o que cada linha está fazendo:
A linha 1 “int i=0;” declara uma variável “i” que recebe o valor Zero.
O “for” da linha 4 fixa o número 8 na variável “i”, limita a repetição dos comandos dentro do laço “for” até que o valor da variável chegue a 11 e soma uma unidade ao valor de “i” cada vez que os comandos dentro das chaves do laço “for” terminem. Perceba que abrimos as chaves do laço “for” logo depois de escrever as condições dentro dele. Assim, todos os comandos dentro do dessa nova chave vão ser executados enquanto a condição dentro do dele for verdadeira, ou seja, até chega no número 11.
O comando “pinMode (i, OUTPUT);”, faz com que o Arduino controle o pino de “i”. Só que o valor de “i” muda. No início, “i” vale 8. Mas esse valor é somado em uma unidade toda vez que o comando “pinMode (i, OUTPUT);” for acionado. Assim, na segunda vez que esse comando for acionado, o “i” vai valer 9 e vai definir o pino 9 como saída do Arduino. Portanto, toda vez que esse comando for executado, no valor de “i” vai ser somado uma unidade. Isso vai ocorrer até que o valor chegue a 11. Lembre-se de fechar as chaves desse “for”.
Da mesma forma que o “for” anterior, o “for” da linha 10 fixa o número 8 na variável i, limita a repetição dos comandos dentro do laço “for” até que o valor da variável chegue a 11 e soma uma unidade ao valor de “i” cada vez que os comandos dentro do laço “for” terminem. A forma em que isso foi escrito é diferente, mas o efeito é o mesmo.
Os comandos dentro desse segundo “for” seguem a mesma lógica do primeiro. No entanto, dentro das chaves desse “for” existem 4 diferentes comandos. Mesmo assim, quando o Arduino terminar de piscar o LED com o valor de i=8, ele vai piscar o LED com valor de i = 9 e, assim, sucessivamente, até chegar no valor de i = 11.
NOTA: Temos as chaves do “void loop()” e a do “for”. A chave do “void loop()” é sempre a primeira e ultima de qualquer programa. Quando os comandos que vão ser repetidos acabarem, lembre-se de fechar as chaves dos “for”.
https://roboteducation.com.br/wp-content/uploads/dribbble-ardusat.gif600800Thiagohttps://roboteducation.com.br/wp-content/uploads/logo-robot-education-wide.pngThiago2021-07-01 15:57:222022-10-01 11:37:56Giroflex de polícia
Não vai pegar fogo desse jeito, apenas ficar muito quente, sair uma fumaça e, claro, parar de funcionar.
Antes de começar a trabalhar com esse equipamento é importante saber os erros mais comuns que podem danificar a sua placa.
A seguir os itens que você vai escrever na parede e repetir todos os dias antes de trabalhar
“Eu nunca vou ….”:
Ligar, diretamente, os pinos de 5V e/ou 3,3V nos pinos GND (-V), ou seja, fazer um curto circuito na placa.
Ter uma corrente superior a 40 mA em um pino. Ou seja, ligar um motor direto nas saídas. Vamos mostrar, mais tarde, como fazer essa conta.
Ter uma corrente superior a 200 mA em todos os pinos somados. Por exemplo, se você ligar 10 LEDs de 20 mA cada, eventualmente, sua placa será danificada.
Ligar uma fonte externa superior a 12 V pode esquentar demais a placa e queima-la. Acima de 20 V, com certeza, vai queimar a placa. A faixa recomendada para uma fonte externa é entre 7 – 12V
Se ligar uma fonte externa, a corrente no pino de 5V nao pode passar de 500 mA.
Queimei meu arduino
Ainda há uma esperança. Em muitos casos apenas o regulador de tensão sofreu sobrecarga e o vídeo abaixo te ensina a substituir. Caso não seja esse o problema, provavelmente queimou o chip do microcrolador, e daí provavelmente não vai valer a pena trocar e você vai precicar de uma placa nova.
Como o Arduino é um mini computador (não exatamente, mas podemos chamar assim) e nós precisamos escrever um código para que o Arduino entenda e execute o que você quer. O código que entende deve ser escrito no Arduíno IDE. O mesmo que você instalou anteriormente. Para que o Arduino execute seus comandos, você deve conectá-lo, pela porta USB, no seu computador. Nesse curso, vamos mostrar como programar o Arduino para fazer o que desejamos.
Quando você abrir o Arduino IDE, vai ver a tela abaixo. Vamos analisar o que cada botão desta tela inicial:
Verificar: Analisa se o código que você escreveu no local da programação está certo.
Upload: Transfere os comandos escritos no local da programação para que o Arduino execute.
Novo: Abre um novo local de programação.
Salvar: Salva os comandos escritos abaixo.
Monitor: Usado para escrever na tela do seu computador o que você escrever no área de programação. Para isso, precisa usar o comando “Serial.print”. Mas não se preocupe, vamos ver, em breve, como usar esse monitor.
Local da Programação: Essa é a área em que você vai escrever seus comandos para o Arduino.
Simulação
Antes de você montar seu projeto, é importante testar se as conexões ou a programação em que você está pensando funcionam. Por isso, vamos te mostrar alguns lugares em você pode simular seu circuito antes de montar.
Esse site é mais utilizado para checar, rapidamente, se o circuito está trabalhando sem problemas. Ao clicar no link acima, você vai precisar fazer o cadastro no site. Então, comece direto com as simulações ou faça o tutorial para aprender a mexer no site deles.
Nos próximos projetos, vamos mostrar como montar os circuitos no tinkercad e na prática. Assim, você,também, estará pronto para criar seus projetos no ambiente de simulação interativa. No entanto, o tinkercad não é perfeito e alguns componentes estão em falta. Por isso, o programa abaixo deve ser instalado no seu computador.
Caso queria baixar um programa para fazer as simulações, temos o Fritzing. O software Fritzing também é bastante utilizado. Mas você vai ter que baixar e instalar com o link acima. Ao clicar no link acima, abra o arquivo instalado e clique em “Fritzing.exe”.
Para começar, clique em Protoboard, escolha os componentes usados em seu projeto pelo desenho ao lado ou escrevendo o nome do componente no espaço de busca. Depois, clique na aba “Janela” e em “Abrir janela de programação”. Para ligar os componentes, basta conectar as extremidades de cada um na placa da protoboard e no Arduino.
https://roboteducation.com.br/wp-content/uploads/dribbble-ardusat.gif600800Thiagohttps://roboteducation.com.br/wp-content/uploads/logo-robot-education-wide.pngThiago2021-07-01 15:19:532022-10-01 17:45:45Primeiros passos com o software
Basicamente tudo se resume a resistores, capacitores, indutores e transistores combinados.
Você vai aprender agora sobre alguns componentes eletrônicos que se relacionam com o uso do Arduino. Vamos a eles:
1) Protoboard
Também chamada de “Breadboard“, “placa de ensaio” ou “matriz de contato”. Ela é utilizada para conectar, de forma muito prática, outros componentes eletrônicos entre si e ao Arduino. Sem este componente nosso trabalho seria muito maior e haveriam muitos problemas de mau contato.
Mas como devemos conectar os componentes?
No positivo, você vai ligar,com os “Jumpers”, o pino “5V” do Arduino e no negativo, você vai ligar o “Terra” do Arduino. O meio da protoboard separa dois lados independentes da placa, serve também como uma bom lugar para conectar os componentes. A figura baixo mostra como cada pino da protoboard está ligado entre si pelas linhas coloridas. Note que o buraco 1a está ligado com: 1b, 1c, 1d e 1e, mas não está ligado com 1f. Isso quer dizer que ao colocarmos fios nos buracos 1a, ou 1b, ou 1c, ou 1d e ou 1e seria o mesmo que enrolar os fios e unir todos juntos. O mesmo acontece com as linhas horizontais em verde.
Se você abrir sua protoboard, vai perceber que os pinos da alimentação estão conectados na horizontal. Enquanto os pinos da área de trabalho estão ligados na vertical, por dentro ela é exatamente como descrevemos: os buracos estão interligados porque na verdade são uma só lâmina de metal. Mas, agora que abrimos a nossa, você não precisa abrir a sua, isso pode danificar a protoboard.
Nenhuma protoboard sofreu danos nessa foto. O barramento de pinos da linha 2 passa bem.
2) Jumper
São os cabos utilizados para conectar os pinos do Arduino na Protoboard.
O nome de batismo é jumper, mas todo mundo chama de fio cabinho
3) Resistor
É um componente utilizado para limitar o fluxo de eletricidade, ou seja, a corrente elétrica. Eles são utilizados para ajudar a proteger partes mais valiosas do seu circuito e também para regular o fluxo para outros componentes. Fazem isso transformando energia elétrica em calor, portanto é também usado para o que foi inicialmente criado: esquentar.
Na prática, tudo é uma resistência, até um fio de cobre que conduz muito bem. Nenhum condutor é perfeito e todos os componentes possuem perdas, a diferença é que este componente foi projetado para isso e é composto por misturas de carbono que conduzem menos ou mais, por isso têm resitência maior ou menor.
Aposto R$ 1.000.000.000.000,00 que isso está presente em todos os eletrônicos.
Cada resistor tem um valor de resistência. Quanto maior esse valor, maior é a capacidade desse resistor de limitar a corrente de um circuito. Para diferenciar um do outro, os resistores tem cores que indicam o valor de resistência. Então, para facilitar nossa vida, foi criada uma tabela de cores para resistores. Não se preocupe em decorar a tabela. Vamos ensinar a mexer nela mais tarde. Mesmo assim, sempre tenha ela mãos para conferir se os resistores que você está utilizando são os corretos. Em cada aula, vamos ensinar a conferir o resistor com a tabela de cores.
