Usando Transistor no Arduino
Usando Transistor no Arduino
Porquê usar transistores?
Os microcontroladores, tais como Atmega, PIC e MSP, são dispositivos lógicos. Eles são usados com o intuito de ser a inteligencia do circuito. Dessa forma, esses componentes não são produzidos para suportar grandes correntes. O Arduino UNO, por exemplo, que usa o Atmega328, suporta um máximo de 40mA em suas portas I/O e fornece uma tensão de 5V.
O Arduino UNO suporta um máximo de 40mA em suas portas I/O
Para muitas aplicações isso não é o suficiente. Segue alguns exemplos:
- Motores DC;
- Fitas de LED;
- Relé;
- Ou qualquer componente que precise de mais de 5V ou 40mA.
A solução pode parecer complicada mas é simples, o nome dela é Transistores.
Nesse Post iremos focar nos transistores BJT (junção bipolar), tentarei ser o mais prático possível, pensando em alguém que não saiba nada de eletrônica. Caso queira saber mais sobre transistores, existe bastante material na internet explicando os vários tipos e suas propriedades de forma mais detalhada.
Um Pouco de História!
Uma das invenções mais importantes do Milênio, os transistores possibilitaram uma revolução tecnológica inimaginável. Agora mesmo, usando o seu computador ou qualquer aparelho eletrônico você está colhendo os frutos dessa invenção.
Antes dos transistores, os computadores funcionavam a partir do uso de válvulas termoiônicas, elas até que funcionavam bem, porém ocupavam muito espaço fazendo com que computadores ocupassem espaços muito grandes. Dessa forma, se viu a necessidade de descobrir uma forma de utilizar um substituto menor.
Em 1947, nos Laboratórios da Bell Telephone, os pesquisadores John Bardeen e Walter Houser Brattain inventaram o primeiro transistor feito de germânio. Em 23 de Dezembro de 1948, foi demonstrado para o mundo por John Bardeen, Walter Houser Brattain e William Bradford Shockley, que ganharam o Nobel de Física em 1956.
Hoje, o material semicondutor mais usado na fabricação de transistores é o silício. O silício é preferível porque possibilita o funcionamento a temperaturas mais elevadas (175 ºC, quando comparado com os ~75ºC dos transistores de germânio) e também porque apresenta correntes de fuga menores. Com a evolução tecnológica existe a necessidade de diminuir cada vez mais o tamanho dos transistores para que se diminua o tamanho dos equipamentos e que se aumente a capacidade de processamento. Uma das novas tecnologias é o chamado transistor 3D que tem dimensões nanométricas.
Como funcionam?
Imagine uma válvula hidráulica, a do seu chuveiro por exemplo, ela tem a função de controlar o fluxo de água que sairá pelo chuveiro, correto? Podemos ter a válvula totalmente fechada, totalmente aberta ou em uma abertura especifica, limitando a corrente de água.
Nessa válvula temos:
- Uma entrada, onde entra a corrente de água;
- Uma saída, nesse caso vai para o chuveiro
- Um elemento de controle de fluxo, no caso o volante da válvula.
O transistor é muito semelhante, porém tratamos de uma corrente de elétrons. O transistor atua como uma válvula. No transistor NPN, temos:
- Uma entrada, chamada coletor, por onde entra a corrente de elétrons;
- Uma saída, chamada emissor, por onde sai a corrente de elétrons;
- E um entrada de controle, chamada base, que no caso é controlada a partir de uma corrente de controle.
Como assim, corrente de controle?
Quando trabalhando no estado Ativo, o transistor aumenta ou reduz o fluxo de corrente entre o coletor e o emissor conforme à corrente de base aumenta ou reduz. Dessa forma, existe uma relação entre corrente do emissor e coletor com a corrente de base. Ela é:
Icoletor ≅ Iemissor ≅ Ibase.hfe
Repare que a corrente de emissor e coletor são aproximadamente iguais (em breve explicaremos porque) e que as duas são proporcionais a corrente de base.
Mas quem é esse hfe?
O hfe, também conhecido como β (beta), é o coeficiente de ganho de corrente. Ele relaciona a corrente de base com a corrente de coletor e emissor. Todo transistor tem o seu valor, esse pode ser consultado na folha de dados do componente (datasheet). Esse valor costuma ser na ordem de centenas. Assim, a corrente de base é muito pequena, em relação às correntes de coletor e de base.
Contudo, a corrente de base tem que fluir para algum lugar. No caso do transistor NPN, ela se junta a corrente de coletor, fluindo em direção ao emissor. Logo, no transistor NPN:
Iemissor = Icoletor + Ibase = Ibase.hfe + Ibase
Iemissor = Ibase.(hfe + 1) ≅ Ibase.hfe
Icoletor ≅ Iemissor
Como hfe >> 1 (muito maior que 1), podemos aproximar o termo (hfe+1) para hfe e assim considerar que as correntes de emissor e coletor são aproximadamente iguais, cometendo um erro inferior a 3% em transistores típicos.
Mas o que acontece se a corrente de base for muito grande?
O transistor entrará em um estado de Saturação. Chega um instante em que a corrente de base é tão grande que a corrente de coletor não consegue ser proporcional a ela. Nesse instante, o transistor libera o máximo de corrente de coletor que pode. É como um registro totalmente aberto.
Icoletor < Ibase . hfe
(Condição de Saturação)
E como restringir toda a corrente?
Quando nenhuma corrente flui entre coletor (c) e emissor (e), podese dizer que o transistor está em corte. Para que possamos entrar nesse estado, algumas condições são necessárias No transistor NPN, as condições são:
- Vb < Vc, Tensão de coletor maior que tensão de base;
- Vb - Ve < 0.7, Tensão de base deve ser 0,7V maior que tensão de Emissor.
Observe que caso o emissor tenha uma tensão de 0V e colocarmos uma tensão de 0V na base, é o suficiente para que o transistor não conduza. Já que a tensão de base não será 0,7V maior que a tensão de emissor.
Será que entendi?
O transistor possui 3 estados de operação, são eles:
- Ativo, Icoletor ≅ Iemissor ≅ Ibase.hfe;
- Corte, Icoletor ≅ Iemissor ≅ 0;
- Saturado, Icoletor < Ibase.hfe (deixa toda a corrente fluir).
Para o transistor NPN funcionar em estado ativo é necessário que:
- Vb < Vc, Tensão de coletor maior que tensão de base;
- Vb - Ve < 0.7, Tensão de base 0,7V maior que tensão de Emissor;
Transistor PNP
Além do transistor NPN, existe também o PNP. Os dois possuem configurações internas diferentes que mudam um pouco o funcionamento deles.
- No transistor NPN a corrente flui do coletor para o emissor, e a corrente de base entra somando junto a contente de emissor, fluindo da base para o emissor.
- No transistor PNP a corrente flui do emissor para o coletor e a corrente de base flui do emissor para a base.
Veja a imagem a seguir:
Além disso, os parâmetros para que não entre em Corte mudam. Para o transistor PNP funcionar, precisamos que:
- Tensão de Base seja maior que tensão de Coletor;
- Tensão de Emissor 0,7V maior que tensão de Base;
Observe que a corrente de base continua sendo muito pequena, considerando Icoletor ≅ Iemissor.
Qual transistor usar?
Para selecionar um transistor, é importante verificar os níveis de corrente, tensão e dissipação de potência em que ele irá trabalhar. Isso é feito na etapa de projeto, utilizando teoria de circuitos ou (quando possível) simulando o comportamento do circuito em softwares específicos. Então, deve-se escolher um dispositivo com capacidade de suportar tais correntes, tensões. Para isso existem duas abordagens principais. A mais comum e simples, é utilizar dispositivos de projetos parecidos (amplamente disponíveis na internet) pois já foram testados por outras pessoas. A abordagem ideal porém mais trabalhosa é consultar a folha de dados (datasheet) dos transistores. Nos datasheets é possível descobrir a SOA (Safety Operation Area) ou 'área de operação segura' dos transistores e assim poder confiar no seu funcionamento correto e na sua durabilidade.
O que devemos verificar:
- Pol: polarização; negativa quer dizer NPN e positiva significa PNP.
- VCEO: tensão entre coletor e emissor com a base aberta.
- VCER: tensão entre coletor e emissor com resistor no emissor.
- IC: corrente máxima do coletor.
- PTOT: é a máxima potência que o transistor pode dissipar (Corrente Máxima de coletor vezes Tensão máxima entre coletor e base)
- hFE: ganho (beta).
- Encapsulamento: a maneira como o fabricante encapsulou o transistor, nos fornece a identificação dos terminais.
Como usar transistores no Arduino?
Veremos agora como usar um transistor NPN junto ao Arduino. Existem varias configurações de circuitos usando transistores, mas vamos nos ater a uma das mais simples. Ela é apresentada na figura a seguir. Nesse caso, estamos controlando um LED através do Arduino com o auxilio do transistor:
Saída Arduino
A saída do Arduino será:
- 5V, quando em nível lógico alto;
- 0V, quando em nível lógico baixo.
Para que o LED acenda, precisamos que quando a saída do Arduino estiver em nível lógico alto, o transistor conduza (Estado Ativo ou Saturado) e que quando estiver em nível lógico baixo, não conduza (Estado de Corte).
Relembrando
O transistor possui 3 estados de operação, são eles:
- Ativo, Icoletor ≅ Iemissor ≅ Ibase.hfe;
- Corte, Icoletor ≅ Iemissor ≅ 0;
- Saturado, Icoletor < Ibase.hfe (deixa toda a corrente fuir).
Para o transistor NPN conduza precisamos que:
- Vb < Vc, Tensão de coletor maior que tensão de base;
- Vb - Ve < 0.7, Tensão de base 0,7V maior que tensão de Emissor;
Transistor em Corte
Como o emissor está conectado ao GND, sua tensão é de 0V. Assim, quando a saída do Arduino estiver em 0V não atenderá um dos requisitos para que o transistor conduza (Tensão de Emissor 0,7V maior que tensão de Base) . Dessa forma o transistor entrará em estado de Corte.
Transistor Conduzindo
Quando o Arduino estiver com 5V em sua saída, sendo a tensão de coletor maior que a tensão de base, teremos o transistor na região ativa ou saturada. Para garantimos que quando em região ativa teremos a corrente de coletor suficiente para acionar o LED precisamos dimensionar os resistores de base(R2) e de coletor(R1) corretamente.
Resistor R1
O resistor R1 tem função de limitar a corrente de coletor. Para acionar um LED, precisamos de uma corrente de pelo menos 10mA. Para uma tensão de 9V um resistor de 150Ohm atende muito bem, veja os cálculos a seguir.
Aplicando a 1ª lei de Ohm considerando uma queda de tensão de 2,5V no LED e desconsiderando a queda de tensão no transistor, temos:
Icoletor-máx = (Vfonte - Queda de tensão no componente) /R = (9-2,5)V/150 Ohm = 43mA
O que é suficiente para alimentar o LED.
Resistor R2 - O mais importante
O resistor R2 tem a função de limitar a corrente de base. Sendo ela responsável por controlar a corrente que irá fluir do coletor para o emissor, temos que escolhe-la com cuidado para garantir a mínima corrente no coletor que conseguirá acender o LED.
Aplicando a 1ª lei de Ohm temos que a corrente de base é:
Ibase = (5-0,7)/R2 = 4,3/R2-max
Mas precisamos que a corrente de coletor seja pelo menos de 10mA, para isso temos que:
Icoletor-min ≅ Iemissor-min ≅ 10mA = 0,01A = Ibase.hfe
0,01A = Ibase-min.hfe
Considerando que estamos usando o transistor BC547A, temos que seu hfe = 110(Consultado na Folha de Dados - datasheet), dessa forma:
0,01A = Ibase.110
Ibase-min=0,01/110 = 0,00009= 0,09mA
Logo:
Ibase-min= 0,00009 = 4,3/R2
R2-max = 4,3/0,00009 =52,2KOhm
Dessa forma, devemos usar um resistor menor que o calculado. Vamos adotar 4,7KOhm. Com esse resistor, teremos:
Ibase=4,3/4,7KOhm=0,9mA
Icoletor'=Ibase.hfe
Icoletor'=0,9mA.110=99mA
Como: Ibase.hfe > Icoletor -> 99mA > 43mA, então:
Transistor Saturado
Resumo dos cálculos
Requisito
Icoletor > 10mA -> Corrente de coletor deve ser maior que 10mA quando o transistor estiver conduzindo para que o LED acenda.
Componentes
- Fonte externa de 9V;
- Transistor BC547A -> hfe=110;
- R1 -> resistor que limitará a corrente de coletor, definindo a corrente máxima;
- R2-> resistor que define a corrente de base que por sua vez define a máxima corrente de coletor.
Especificações
- R1=150 Ohm, Limita a corrente de coletor em 43mA
- R2 < 52,2 kOhm, adotamos R2=4,7 kOhm para corrente de base mínima de 0,09mA, logo a corrente de coletor mínima é 10mA
O que você precisa saber?
Ao projetar um circuito usando o transistor NPN, devemos:
- Escolher qual transistor usar a partir das tensões e correntes máximas;
- Dimensionar os resistores R1 e R2.
Para dimensionar R1, que é o resistor responsável por limitar a corrente de coletor, precisamos saber:
- Qual a tensão da fonte;
- Qual a queda de tensão no componente;
- Qual a corrente necessária para que o componente controlado funcione corretamente (Icoletor-min).
Formula para calculo do R1:
Icoletor-min =(Vfonte - Queda de tensão no componente) /R1-max
R1 não deve ser muito menor que R1-max.
Para dimensionar R2, que é responsável por controlar a corrente de coletor através da corrente de base (Icoletor max = Ibase.hfe), precisamos saber:
- Qual a corrente necessária para que o componente controlado funcione corretamente (Icoletor-min);
- hfe do transistor escolhido.
Formula para calculo do R2:
Ibase = 4,3/R2-max
Ibase = Icoletor/hfe
obs.: É importante dimensionar bem esse resistor para que não se restrinja demais a corrente de coletor do transistor. O ideal, para esse tipo de aplicação, é trabalharmos com o transistor saturado (Icoletor < Ibase.hfe). Para isso, geralmente escolhemos um resistor bem menor que o R2 calculado.
DICAS
Para esse tipo de aplicação, na maioria dos casos, podemos adotar:
- R1 = 150 Ohm;
- R2 = 1 kOhm a 4,7 kOhm
- Fonte externa até 12V para o BC547A
No lugar do LED podemos colocar um relé ou outro componente que consuma até 100mA, caso esteja usando o BC547A
Costumo usar na maioria das vezes os seguintes transistores NPN:
- BC547A (Tensão de coletor máx =45V; Corrente de coletor máx = 100mA ; hfe=110)
- BD137 (Tensão de coletor máx =60V; Corrente de coletor máx =1,5A ; Corrente de Base máx = 500mA; hfe=40)
- TIP122 (Tensão de coletor máx =100V; Corrente de coletor máx = 5A ; Corrente de Base máx = 120mA; hfe= 1000)
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
Display LCD 16x2 com Arduino
Display LCD 16x2 com Arduino
Até aqui, usamos o monitor serial como IHM para a visualização dos valores lidos nos sensores, porém, não é interessante dependermos de um computador para que possamos ler esses valores. Para essa função, podemos usar um Display LCD. Nesse tutorial iremos aprender a usar o display LCD 16x2 com o Arduino Uno ou similar.
As máquinas querem conversar
Por muitas vezes precisamos coletar dados ou interagir com sistemas automatizados. Dessa forma, precisamos de um caminho que torne essa interação possível. O nome desse caminho de comunicação chama-se IHM (Interface Homem Máquina).
IHM é um caminho pelo qual o homem e o computador podem se comunicar e interagir, visando atingir um objetivo comum.
Tipicamente, uma IHM é dada por algum tipo de saída (indicadores de velocidades, monitores, displays, auto-falantes, etc) e algum tipo de entrada (botões, touchscreen, microfone, câmera, dentre outros). Quanto mais fácil for para coletar informações e introduzir entradas em um sistema automatizado, mais trivial será a interação dele com o usuário.
É ai que entram os displays! Boa parte dos dispositivos automatizados que utilizamos possuem displays. O motivo é claro: Eles podem apresentar ao usuário varias informações de forma rápida. Além disso, um display pode apresentar vários tipos de saídas, desde textos ou números até imagens em movimento.
O que é um LCD
O LCD (Display de Cristal Líquido) é um dispositivo gráfico muito poderoso na criação de interfaces com o usuário. Amplamente utilizado nos mais diversos tipos de projetos, esses displays são formados por uma fina camada de cristal líquido entre duas placas de vidro, com uma fonte de luz fluorescente ou de LEDs por baixo de toda essa estrutura. A formação de caracteres e imagens ocorre devido ao fato do cristal líquido, naturalmente transparente, se tornar opaco ao receber uma carga elétrica, impedindo a passagem de luz.
Existem, basicamente, dois tipos de LCDs:
- Caracter: Esses tipos de LCD permitem apenas a escrita de caracteres, números e pequenos símbolos criados pelo usuário. Alguns tamanhos comuns para esse tipo de display são: 8x2, 16x2, 20x4, 24x4, 40x2, entre outros.
- Gráficos: Os LCDs gráficos possuem resoluções bem maiores e permitem a exibição de figuras e imagens. Alguns tamanhos comuns para esse tipo de display são: 122x32, 128x64, 240x64, 240x128, entre outros.
- Display LCD 16x2
Neste tutorial será ensinado como utilizar um display LCD de caracter no Arduino por meio da biblioteca LiquidCrystal, que acompanha o seu IDE. Para isso, será utilizado um display LCD 16X2 (2 linhas e 16 colunas).
A biblioteca LiquidCrystal possui diversas funções para utilização do LCD. Explicaremos as principais funções a seguir. As demais funções podem ser vistas na página de referências da biblioteca, no site do Arduino.
O uso tanto do display LCD 16x2 tanto do display LCD 20x4 é muito semelhante, a diferença entre eles é o numero de caracteres que dispõem na tela. Caso você tenha em suas mão o Display LCD 20x4, você poderá facilmente adaptar o programa usado nesse tutorial para você.
Comunicação I2c
É interessante resaltar aqui sobre as possibilidade de uso deste LCD usando comunicação I2C. Nesse tutorial iremos usar o método convencional para que o Arduino converse com o LCD, gastando muitos pinos.
É possível usar o LCD usando o adaptador I2C de forma que só será necessário o uso de 2 pinos do Arduino. Esse tipo de ligações possui outras vantagens que podem ser conferidas no seguinte tutorial:
Mãos à obra - Exemplo 1 - Montando seu primeiro projeto com um LCD 16x2
Componentes necessários
Os itens que usaremos nessa experiência são:
- Arduino Uno ou placa semelhante
- Display LCD 16x2
- Fios Jumper’s
- Protoboard
- Potenciômetro 10kOhm
Montando o projeto
Monte seu circuito conforme a figura a seguir. Garanta que seu Arduino esteja desligado durante a montagem.
O display LCD 16x2 possui 16 pinos, sendo eles:
| 1 | Vss |
| 2 | Vdd |
| 3 | V0 (Ajuste de Contraste) |
| 4 | RS |
| 5 | R/W (Leitura/Escrita) |
| 6 | Enable (Habilita escrita no LCD) |
| 7 | DB0 |
| 8 | DB1 |
| 9 | DB2 |
| 10 | DB3 |
| 11 | DB4 |
| 12 | DB5 |
| 13 | DB6 |
| 14 | DB7 |
| 15 | Anodo – Luz de Fundo |
| 16 | Catodo – Luz de Fundo |
No nosso exemplo não usaremos os pinos 7,8,9 e 10 do nosso módulo. Dessa forma, teremos os outros pinos conectados da seguinte forma:
Abaixo você pode conferir onde cada pino será conectado:
| Pino LCD | Pino Arduino |
| 1 | GND |
| 2 | 5V |
| 3 | Divisor de Tensão potênciometro |
| 4 | Porta digital 2 |
| 5 | GND |
| 6 | Porta digital 3 |
| 7 | - |
| 8 | - |
| 9 | - |
| 10 | - |
| 11 | Porta digital 4 |
| 12 | Porta digital 5 |
| 13 | Porta digital 6 |
| 14 | Porta digital 7 |
| 15 | 5V |
| 16 | GND |
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Programando
Crie um no programa (sketch) e salve com o nome de “programa_LCD”.
Neste exemplo, utilizaremos a biblioteca LiquidCrystal que já acompanha a IDE Arduino.
Com o seu programa salvo, escreva nele o código a seguir e depois de escrever o código, clique em Upload para que o programa seja transferido para seu Arduino.
#include <LiquidCrystal.h> //inclui biblioteca no programa
LiquidCrystal lcd(2,3,4,5,6,7);
/*Cria objeto lcd da classe LiquidCrystal
RS 2
Enable 3
DB4 4
DB5 5
DB6 6
DB7 7
*/
//Cria um smile
byte smile[8] = {
B11111,
B00000,
B01010,
B00000,
B10001,
B01110,
B00000,
B00100,
};
//Cria outro smile
byte smile2[8] = {
B00000,
B00000,
B01010,
B01010,
B00000,
B10001,
B11111,
B00000,
};
void setup(){
lcd.begin(16,2); //Inicializa display de 2 linhas x 16 colunas
lcd.createChar(0, smile); //Cria o smile e o associa ao 0
lcd.createChar(1, smile2); //Cria o smile2 e o associa ao 1
lcd.home(); //Posiciona cursor no canto superior esquerdo
lcd.print("3 "); //Executa uma pequena contagem regressiva
delay(500);
lcd.print("2 ");
delay(500);
lcd.print("1 ");
delay(500);
lcd.clear(); //Limpa a tela do LCD
lcd.print("Vida de Silício"); //Escreve Vida de Silício
lcd.setCursor(6,1); //Posiciona o cursor na posição (6,1)
lcd.write(byte(0)); //Escreve o smile
lcd.setCursor(8,1); //Posiciona o cursor na posição (8,1)
lcd.write(1); //Escreve smile2
}
void loop(){
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Depois que o Arduino carregar o programa, caso esteja tudo certo, você verá em seu display uma contagem regressiva e por fim o texto “Vida de Silício”.
O resultado será semelhante ao da imagem a seguir:
Entendendo a fundo
Entendendo o Hardware
Nesse exemplo usamos o LCD 16x2, que possui 16 colunas e 2 linhas. Isso quer dizer que esse display pode apresentar 16x2, ou seja, 32 caracteres em sua tela. Na imagem abaixo podemos notar nitidamente a disposição dos caracteres na tela.
Cada caractere é composto de uma matriz de 5 colunas por 8 linhas de pixels. O estado desses pixels, “ligados” ou “desligados”, desenharam o caractere. Veja a seguir como estão dispostos esses pixels em um caractere.
Definimos os estados dos pixels através das entradas DB’s do módulo LCD. O Arduino enviará 8 bytes através dessas portas para que seja definido o caractere.
A seguir você pode verificar como é formado a letra V.
//Letra V
byte V[8] = {
B10001,
B10001,
B10001,
B10001,
B10001,
B10001,
B01010,
B00100,
};
A biblioteca que usamos já possui essas combinações para caracteres alfanuméricos, dessa forma não é necessário definir no programa cada caractere que será usado. Porém, caso você queira criar um caractere personalizado, também será possível, tal como o smile que usamos.
Entendendo o Programa
Para o uso do módulo display LCD 16x2 temos que entender o uso de sua biblioteca. Para esse exemplo, explicaremos a biblioteca LiquidCrystal.
- LiquidCrystal
É o construtor que cria um objeto da classe LiquidCrystal. Ele é sobrecarregado de 4 maneiras diferentes:
LiquidCrystal(RS, Enable, DB4, DB5, DB6, DB7) LiquidCrystal(RS, R/W, Enable, DB4, DB5, DB6, DB7) LiquidCrystal(RS, Enable, DB0, DB1, DB2, DB3, DB4, DB5, DB6, DB7) LiquidCrystal(RS, R/W, Enable, DB0, DB1, DB2, DB3, DB4, DB5, DB6, DB7)
Onde tela, é o nome escolhido para o seu LCD.
Caso o pino R/W não seja passado ao construtor, ele deve ser conectado ao pino terra para permitir a escrita no LCD. Observe que não é necessário enviar todos os pinos de dados ao construtor, pois o Arduino consegue controlar o display utilizando apenas os 4 últimos pinos.
Observe que em nosso exemplo usamos a primeira opção usamos o nome LCD:
LiquidCrystal lcd(2,3,4,5,6,7); /*Cria objeto lcd da classe LiquidCrystal RS 2 Enable 3 DB4 4 DB5 5 DB6 6 DB7 7 */
- begin(colunas, linhas)
Inicializa a interface com o LCD, recebendo como parâmetros o número de colunas e linhas do display. Deve ser chamada antes de qualquer outro método da classe.
lcd.begin(colunas,linhas);
Como nosso display possui 16 colunas e 2 linhas, temos:
lcd.begin(16,2); //Inicializa display de 2 linhas x 16 colunas
Observe que usamos o nome do display, no nosso caso lcd, seguido de ponto e o nome da função que queremos usar. Para o Arduino estamos falando que queremos usar determinada função do objeto mencionado, no nosso caso o lcd.
- setCursor(coluna, linha)
Posiciona o cursor do LCD nas coordenadas passadas pelo parâmetro, para que o texto possa ser escrito na posição desejada.
lcd.setCursor(6,1); //Posiciona o cursor na posição (6,1)
- home()
Posiciona o cursor no canto superior esquerdo do display. Equivale ao setCursor(0,0).
lcd.home(); //Posiciona o cursor na posição (0,0)
- print(conteúdo, base)
Escreve o conteúdo (char, int, string, byte ou long) na tela do LCD, na posição atual do cursor. O parâmetro base é opcional e indica apenas a base em que os números serão impressos (BIN para binário, DEC para decimal, OCT para octal e HEX para hexadecimal).
Ao término da escrita, o cursor é movido para a próxima posição.
lcd.print("Vida de Silício"); //Escreve Vida de Silício
- clear()
Limpa a tela do LCD e posiciona o cursor na extremidade superior esquerda.
lcd.clear(); //Limpa a tela do LCD
- createChar(número, caracter)
Cria um caracter customizado para ser utilizado no display, até, no máximo, 8 caracteres. O símbolo criado é formado por um array de 8 bytes, em que os 5 bits menos significativos de cada byte determinam os pixels de cada linha.
nomedolcd.createChar(numero, caractere);
O parâmetro número recebe um inteiro de 0 a 7, que simboliza qual caractere está sendo criado.
O parâmetro caractere recebe um vetor de 8 bytes que desenham o caractere, tal como apresentado abaixo:
Veja como ficou o no nosso exemplo:
lcd.createChar(0, smile); //Cria o smile e o associa ao 0 lcd.createChar(1, smile2); //Cria o smile2 e o associa ao 1
Onde temos os caracteres smile e smile 2 definidos da seguinte forma:
//Cria um smile
byte smile[8] = {
B11111,
B00000,
B01010,
B00000,
B10001,
B01110,
B00000,
B00100,
};
//Cria outro smile
byte smile2[8] = {
B00000,
B00000,
B01010,
B01010,
B00000,
B10001,
B11111,
B00000,
};
- write(caracter)
Escreve um caractere no LCD na posição atual do cursor, movendo o cursor para a próxima posição.
lcd.write(byte(0)); //Escreve o smile
Para o caractere 0 é necessário que, no momento de imprimi-lo, faça-se um casting do número do caractere criado para um byte.
lcd.write(byte(0)); //Escreve o smile
O que não acontece com os demais.
lcd.write(1); //Escreve smile2
Mãos à obra - Exemplo 2 - Medindo temperatura com um LCD
O próximo exemplo mostra a temperatura ambiente no LCD 16X2, obtida por meio do sensor LM35 já estudado no tutorial LM35 – Medindo temperatura com Arduino
Componentes necessários
- Display LCD 16x2
- LM35
- Fios Jumper’s
- Protoboard
- Potenciômetro 10kOhm
- Placa Arduino Uno ou similar
Montando o projeto
Agora vamos conectar os componentes do projeto. Para isso poderemos aproveitar a montagem da experiência 6 e apenas acrescentar o LM35
Os resistores de 15kΩ e 33kΩ diminuem a tensão de referência do conversor analógico-digital do Arduino para aproximadamente 1,5V, melhorando a resolução do sensor.
Importante: O pino AREF possui, por padrão, uma tensão de 5V (Referência interna do Arduino). Ao conectarmos um pino com uma tensão diferente, iremos criar um curto-circuito entre esses dois pontos. Para evitar que isso ocorra, o Arduino deve ser programado para aceitar uma referência externa antes que a conexão seja feita.
Dica: Tome cuidado em relação ao barramento vermelho e azul de sua protoboard. Muitas vezes ele não é continuo de um lado a outro tal como o do esquemático. Tal como pode ser observado na figura abaixo.
Programando
Crie um no programa (sketch) e salve com o nome de “programa_LCD_LM35”.
Utilizaremos novamente a biblioteca LiquidCrystalque já acompanha a IDE Arduino, tal como na experiência anterior.
Com o seu programa salvo, escreva nele o código a seguir.
#include <LiquidCrystal.h> //Inclui biblioteca no programa
uint32_t timer;
/*
Cria objeto lcd da classe LiquidCrystal
RS 2
Enable 3
DB4 4
DB5 5
DB6 6
DB7 7
*/
LiquidCrystal lcd(2,3,4,5,6,7);
void setup(){
analogReference(EXTERNAL); // Muda a referência para a tensão no pino AREF
lcd.begin(16,2); //Inicializa display de 2 linhas x 16 colunas
}
void loop(){
//Executa a cada 1 segundo
if(millis() - timer > 1000)
{
// Atualiza o valor lido pelo conversor
float valorLido = analogRead(A0);
// Converte a temperatura lida para graus Celsius
float temp = valorLido/1024*1562.5/10;
lcd.clear(); //Limpa o display
//Imprime a temperatura no display
lcd.print("Temperatura: ");
lcd.print(temp);
timer = millis(); //Atualiza a referência
}
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Depois que o Arduino carregar o programa, caso esteja tudo certo, você verá em seu display o valor de temperatura medido pelo LM35.
Desafio
- Faça um sensor de ré usando um sensor ultrassom, um LCD e um buzzer.
- Mostre o valor de distância no display LCD e, caso a distância seja menor que 20 cm, faça o buzzer alarmar.
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
Revisado por Ícaro Lobo
Revisão e edição: Allan Mota
Ponte H L298N - Controlando a velocidade de um motor DC com PWM
Ponte H L298N - Controlando a velocidade de um motor DC com PWM
No último tutorial vimos como se faz para ligar um motor DC no Arduino com o auxílio de um módulo ponte H L298n, usando suas entradas para variar o sentido de giro. Mas na robótica, é comum termos que controlar, além do sentido, a velocidade do motor. Neste tutorial iremos ensinar, de forma simples e didática, como podemos controlar a velocidade de um motor DC usando o Driver motor com Ponte H L298n com Arduino.
[toc]
Como controlar a velocidade de um motor?
Um motor DC gira baseado em campos magnéticos gerados pela corrente que passa em suas bobinas. Para variar a velocidade do motor podemos alterar essa corrente que é diretamente proporcional a tensão sobre elas.
Dessa forma, com a mudança da tensão em cima do motor, teremos uma alteração de velocidade. mas como podemos fazer isso usando o Arduino e a Ponte H? A solução é simples e eficiente e se chama PWM.
O que é PWM?
PWM (Pulse Width Modulation – Modulação por Largura de Pulso) é uma técnica para obter resultados analógicos por meios digitais (Leia mais sobre Grandezas digitais e analógicas e PWM). Essa técnica consiste na geração de uma onda quadrada em uma frequência muito alta em que pode ser controlada a porcentagem do tempo em que a onda permanece em nível lógico alto. Esse tempo é chamado de Duty Cycle(Ciclo de trabalho) e sua alteração provoca mudança no valor médio da onda, indo desde 0V (0% de Duty Cycle) a 5V (100% de Duty Cycle) no caso do Arduino.
O duty cycle é a razão do tempo em que o sinal permanece na tensão máxima (5V no Arduino) sobre o tempo total de oscilação, como está ilustrado na figura abaixo:
Duty Cycle (%) = (x/x+y)*100% = (x/T)*100%
Vmédio = Vmáx*Duty Cycle(%)
O valor do Duty Cycle usado pelo Arduino é um inteiro armazenado em 8 bits, de forma que seu valor vai de 0 (0%) a 255 (100%).
Exemplo.: Para um sinal PWM de valor 200 temos:
Se 255 é 100%, 200 é aproximadamente 78,4%.
Como a tensão máx de saída do Arduino é 5V a tensão média do sinal PWM será:
Vmédio = Vmax*Duty Cycle(%)
Vmédio=5*78,4%
Vmédio=3,92V
Modulando a ponte H
No módulo Ponte H com CI L298N cada ponte H possui um pino que ativa ou não a ponte H. Caso tenha um sinal de 5V inserido nele, a ponte enta ligada, caso seja 0V a ponte esta desligada. Como temos 2 pontes H, temos o Enable A(Ativa A) e o Enable B (Ativa B).
Normalmente o Enable A e B fica em curto com um sinal de 5V da placa através de um jumper.
Se retiramos esse jumper e inserimos um sinal PWM nessa entrada, modularemos a tensão que é enviada para o motor no mesmo formato. Isso ocorre porque a ponte H só ira "funcionar" enquanto o sinal de Enable estive com 5V.
Sendo assim, a saída para o motor será um sinal PWM com um Duty Cycle igual ao do Enable e terá tensão média calculada pela seguinte formula.
Vmédio = Vmax(tensão PonteH)*Duty Cycle(%)
Com essa modulação, podemos variar a velocidade do motor através de PWM.
Mãos à obra - Controle de velocidade com Módulo Ponte H L298N - Arduino
Neste segundo exemplo, vamos verificar o controle de velocidade dos motores A e B.
Componentes necessários
Para este exemplo, utilizaremos:
- Placa Arduino UNO ou similar
- Módulo Ponte H L298N
- 2x Motores DC (pode ser feito com apenas 1)
- Fonte alimentação de 12V
Montando o projeto
Prossiga com a montagem conforme esquema abaixo(caso você use apenas um motor, basta desconsiderar o motor B:
Garanta que seu Arduino e a fonte externa estejam desligados durante a montagem.
Programando
Crie um programa (sketch) e salve com o nome de “exemplo1_Controle_velocidade”.
Agora vamos à implementação do programa. Dessa forma, dentro da IDE Arduino: escreva o seguinte código e ao final clique em Upload para que o programa seja transferido para seu Arduino.
/*Pinagem do arduino*/
//motor_A
int IN1 = 2 ;
int IN2 = 4 ;
int velocidadeA = 3;
//motor_B
int IN3 = 6 ;
int IN4 = 7 ;
int velocidadeB = 5;
//variavel auxiliar
int velocidade = 0;
//Inicializa Pinos
void setup(){
pinMode(IN1,OUTPUT);
pinMode(IN2,OUTPUT);
pinMode(IN3,OUTPUT);
pinMode(IN4,OUTPUT);
pinMode(velocidadeA,OUTPUT);
pinMode(velocidadeB,OUTPUT);
}
void loop(){
/*Exemplo de velocidades no motor A*/
//Sentido 2
digitalWrite(IN1,HIGH);
digitalWrite(IN2,LOW);
//Alta
analogWrite(velocidadeA,230);
//Intermediaria
analogWrite(velocidadeA,150);
//Baixa
analogWrite(velocidadeA,80);
/*Exemplo de variacao de velocidade no motor B*/
//Sentido 2
digitalWrite(IN3,HIGH);
digitalWrite(IN4,LOW);
//velocidade de 0 a 255
while (velocidade < 255){
analogWrite(velocidadeB,velocidade);
velocidade = velocidade + 10;
delay(50);
}
//velocidade de 255 a 0
while (velocidade > 0){
analogWrite(velocidadeB,velocidade);
velocidade = velocidade - 10;
delay(50);
}
}
Colocando para funcionar
Se tudo deu certo, teremos o motores fazendo os seguintes movimentos:
- Motor A gira em velocidade alta
- Motor A gira em velocidade intermediaria
- Motor A gira em velocidade baixa
- Motor B vai de parado para velocidade rápida gradativamente
- Motor B vai da velocidade rápida até totalmente parado gradativamente
Entendendo a fundo
Entendendo o Software
Primeiro definimos as pinos que estão conectados à ponte H para controle de cada motor.
//motor_A int IN1 = 2 ; int IN2 = 4 ; int velocidadeA = 3; //motor_B int IN3 = 6 ; int IN4 = 7 ; int velocidadeB = 5;
Veja que temos 3 pinos para cada motor. 2 para controle de sentido de giro e o terceiro para controle de velocidade.
Movimentando o motor
Para fazer o motor se movimentar, primeiro temos que informar para que direção ele deve girar:
//Motor_A //Sentido 2 digitalWrite(IN1,HIGH); digitalWrite(IN2,LOW);
Aqui vale lembrar da tabela de comandos apresentadas no tutorial Módulo Ponte H L298N – Controlando Motores com Arduino :
Para controlar o sentido, temos as seguintes combinações para o motor A(IN1 e IN2)
É importante ter em mente essas combinações:
//Sentido 1 digitalWrite(IN1,LOW); //0V digitalWrite(IN2,HIGH); //5V //Freia Motor digitalWrite(IN1,HIGH); //5V digitalWrite(IN2,HIGH); //5V //Sentido 2 digitalWrite(IN1,HIGH); //5V digitalWrite(IN2,LOW); //0V
Em seguida definimos a velocidade através de um sinal PWM no pino Enable A. Tal como explicado anteriormente.
//Motor_A //Velocidade Alta analogWrite(velocidadeA,230);
Quando não queremos controlar a velocidade, deixamos esse pinos com um jumper ligado ao 5V da placa. Assim garantimos que a ponte H trabalhe na velocidade máxima.
Como queremos controlar sua velociade, tiramos o Jumper e conectamos a uma porta PWM.
O comando para a saída PWM é:
analogWrite(pino_de_saida,PWM);
Onde PWM , que já foi explicado no inicio do tutorial, é um valor entre 0 à 255. Onde 0 simboliza que o ciclo de trabalho é de 0% (desligado o tempo todo) e 255 simboliza que o ciclo de trabalho é de 100% (ligado o todo).
Ou seja, podemos brincar com a velocidade variando esse valor de PWM.
No exemplo usado temos um pedaço de código onde variamos a velocidade dos motores de parado (PWM=0) até a velocidade mais rápida (PWM=255), subindo de 10 em 10 a velocidade.
//velocidade de 0 a 255
while (velocidadeB < 255){
analogWrite(velocidadeB,velocidade);
velocidade = velocidade + 10;
delay(50);
}
Outra opção de Programa
Caso você queira fazer um código mais enxuto e modularizado, temos este exemplo de implementação um pouco avançado que usa funções. Em breve teremos um tutorial sobre o assunto.
#define MOTOR_A 1
#define MOTOR_B 2
#define HORARIO true
#define ANTIHORARIO false
//inicializa pinos
void setup(){
for (int i = 2; i < 8; i++)
pinMode(i,OUTPUT);
}
void loop(){
acionaMotor(MOTOR_A,HORARIO, 255);
acionaMotor(MOTOR_B,ANTIHORARIO, 255);
}
//funcao para acionamento individual de cada motor
void acionaMotor(int motor, boolean sentido, int velocidade){
if (motor == MOTOR_A){
digitalWrite(2,sentido);
digitalWrite(4,!sentido);
analogWrite(3,velocidade);
}
else if (motor == MOTOR_B){
digitalWrite(6,sentido);
digitalWrite(7,!sentido);
analogWrite(5,velocidade);
}
}
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
Editado por Allan Mota e revisado por Ícaro Lobo
Driver motor com Ponte H L298N - Controle de Motor DC com Arduino
Driver motor com Ponte H L298N - Controlando Motor DC com Arduino
Se você curte robótica, provavelmente deve estar louco para montar seu próprio robô. A ponte H é uma peça chave quando o assunto é robótica. Neste tutorial você aprenderá como controlar um motor DC usando o Driver motor L298n com um Arduino Uno. Esse tutorial é essencial para quem quer montar seu robô com Arduino.
[toc]
O que é uma Ponte H?
Na maioria das abordagens em robótica faz-se necessária a utilização de motores DC em diversos tipos de locomoção de robôs, movimentação de braços mecânicos, etc. Os motores DC (direct current ou corrente continua) são cargas indutivas que, em geral, demandam uma quantidade de corrente superior à que as portas do Arduino conseguem fornecer.
Sendo assim, não devemos ligar estes motores diretamente nas portas do Arduino pois se o motor demandar uma corrente acima de 40mA nas portas digitais (máxima fornecida pelo Arduino) pode queimar a porta e danificar a placa.
Para solucionar a questão da alta corrente poderíamos usar transistores, porem é importante que seja possível controlar o sentido de giro do motor, função que não se faz possível usando apenas um transistor já que para inverter o sentido de giro devemos inverter a polaridade da alimentação do motor (onde era positivo se põe negativo e vice versa). Um transistor só seria suficiente para ligar e desligar o motor.
Para resolver nosso problema utilizamos um famoso circuito conhecido como Ponte H que nada mais é que um arranjo de 4 transistores. Este circuito é uma elegante solução por ser capaz de acionar simultaneamente dois motores controlando não apenas seus sentidos, como também suas velocidades. Além de seu uso ser simples no Arduino.
Mas como funciona a Ponte H? Porque este nome?
As pontes H em possuem este nome devido ao formato que é montado o circuito, semelhante a letra H. O circuito utiliza quarto chaves (S1, S2, S3 e S4) que são acionadas de forma alternada, ou seja, (S1-S3) ou (S2-S4), veja as figuras abaixo. Dependendo da configuração entre as chaves teremos a corrente percorrendo o motor hora por um sentido, hora por outro.
Quando nenhum par de chaves está acionado, o motor está desligado (a). Quando o par S1-S3 é acionado a corrente percorre S1-S3 fazendo com que o motor gire em um sentido (b). Já quando o par S2-S4 é acionado a corrente percorre por outro caminho fazendo com que o motor gire no sentido contrário (c).
Circuito integrado Ponte H L2398N
O CI L298N é muito utilizado para o propósito de controle de motores, ele nada mais é que uma ponte H em um componente integrado. Uma das vantagens do uso desse CI é o menor espaço ocupado, a baixa complexidade do circuito e o fato de ele já possuir dois circuitos H, podendo assim, controlar dois motores. Na figura a seguir você pode conferir o diagrama de blocos do CI L298N retirado de sua folha de dados (folha de dados L298N) :
As funções dos principais pinos desse CI são descritas na tabela a seguir:
Outra vantagem do L298N é a resposta a sinais de PWM. Se no lugar de usar sinais lógicos TTL for usado sinais de PWM, é possível regular a tensão de saída, e dessa forma regular a velocidade dos motores.
O PWM, Pulse Width Modulation (Modulação por Largura de Pulso), consiste basicamente em aplicar uma onda quadrada de amplitude Vcc e frequência alta no lugar da tensão continua Vcc. Leia mais sobre PWM na postagem Grandezas digitais e analógicas e PWM.
Ao usar um sinal de PWM nas entradas IN1 e IN2, por exemplo, teremos uma tensão de saída nos pinos OUT1 e OUT2 em PWM que será igual à Duty Cycle*Vcc. Dessa forma, podemos regular a diferença de potencial média aplicada nos motores, controlando as suas velocidades.
Existem outras opções de CI's de ponte H no mercado, é importante consultar as especificações deles em suas folhas de dados(Datasheet) para saber qual irá lhe atender melhor. Veja algumas opções de ponte H:
- L293D Folha de Dados;
- LMD18200 Folha de dados.
Módulos Driver motor com Ponte H
Esses módulos são muito utilizados em aplicações de robótica. Esses módulos possuem dimensões pequenas e já possuem o circuito básico para o uso do CI, o que facilita na acomodação do módulo no robô ou em outros projetos e a sua utilização.
Existem varias opções disponíveis no mercado, com tamanhos e especificações diferentes. Algumas especificações são importantes ao escolher seu módulo, são elas:
- Especificação de potência máxima fornecida;
- Tensão máxima suportada;
- Corrente máxima suportada;
- Tensão lógica.
Um exemplo desses módulos é o oferecido em nossa loja, sua características são:
- Ci L298N;
- Tensão para os motores: 5 – 35V;
- Corrente máxima para os motores: 2A;
- Potencia máxima: 25W;
- Tensão lógica: 5V;
- Corrente lógica: 0-36mA;
- Dimensões: 43x43x27 mm
- Peso: 30g.
Módulo Driver motor com Ponte H L298N
Agora que já sabemos como a Ponte H funciona, vamos entender na prática como podemos usá-las em conjunto com o Arduino. Para isso iremos usar o Driver motor com Ponte H L298N.
Entradas e saídas
Para começa vamos entender função de cada pino bem como deve ser utilizado.
Motor A e Motor B: Conectores para os dois motores
-
- 6-35V: Porta para alimentação da placa com tensão entre 6 a 35V.
-
- Ativa 5V: Quando jumpeado, a placa utilizará o regulador de tensão integrado para fornecer 5v (na porta 5v) quando a porta 6-35V estiver sendo alimentada por uma tensão entre 6 e 35V. Neste caso, não se deve alimentar a porta 5V pois pode danificar os componentes. A tensão fornecida na porta 5V pode ser usada para alimentar o Arduino, por exemplo.
-
- 5v: Em casos de não haver fonte de alimentação com mais de 6V podemos alimentar a placa com 5V por esta porta.
-
- Ativa MA: Quando jumpeado aciona o motor A com velocidade máxima. Para controlar a velocidade do motor A basta remover o jumper e alimentar o pino com uma tensão entre 0 e 5v, onde 0V é a velocidade mínima (parado) e 5V a velocidade máxima.
-
- Ativa MB: Quando jumpeado aciona o motor B com velocidade máxima. Para controlar a velocidade do motor B basta remover o jumper e alimentar o pino com uma tensão entre 0 e 5v, onde 0V é a velocidade mínima (parado) e 5V a velocidade máxima.
-
- IN1 e IN2:são utilizados para controlar o sentido do motor A;
- IN3 e IN4: são utilizados para controlar o sentido do motor B;
Veja que agora, no lugar das chaves S1-S3 e S2-S4 temos os pinos IN1 e IN2. Onde IN1 corresponde às chaves S1-S3 e a IN2 às chaves S3-S4.
Para controlar o sentido, temos as seguintes combinações para o motor A(IN1 e IN2)
Para o motor B (IN3 e IN4), a tabela funciona da mesma forma.
Mãos à obra – Driver motor com Ponte H L298N - Controlando Motores com Arduino
Vamos fazer um exemplo para testar na pratica a ponte h. Neste primeiro exercício queremos testar o controle do sentido de giro dos motores A e B através do Arduino.
Componentes necessários
Para este exemplo, utilizaremos:
- Placa Arduino UNO ou similar
- Ponte H L298N - driver motor
- 2x Motores DC (pode ser feito com apenas 1)
- Fonte alimentação de 12V ou Fonte alimentação de 9V
Montando o projeto
Prossiga com a montagem conforme esquema abaixo. Caso você use apenas um motor, basta desconsiderar o motor B:
Garanta que seu Arduino e a fonte externa estejam desligados durante a montagem.
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Programando
Crie um programa (sketch) e salve com o nome de “exemplo1_ponteh”.
Em seguida, insira nele o código conforme escrito abaixo:
/*Pinagem do arduino*/
//motor_A
int IN1 = 2 ;
int IN2 = 3 ;
//motor_B
int IN3 = 4 ;
int IN4 = 5 ;
//Inicializa Pinos
void setup(){
pinMode(IN1,OUTPUT);
pinMode(IN2,OUTPUT);
pinMode(IN3,OUTPUT);
pinMode(IN4,OUTPUT);
}
void loop(){
/*Inicio dos Estados do motor A*/
//Sentido 1
digitalWrite(IN1,LOW);
digitalWrite(IN2,HIGH);
delay(5000);
//Freia Motor_A
digitalWrite(IN1,HIGH);
digitalWrite(IN2,HIGH);
delay(5000);
//Sentido 2
digitalWrite(IN1,HIGH);
digitalWrite(IN2,LOW);
delay(5000);
//Freia Motor_A
digitalWrite(IN1,HIGH);
digitalWrite(IN2,HIGH);
delay(5000);
/*Fim dos Estados do motor A*/
/*Inicio dos Estados do motor B*/
//Sentido 1
digitalWrite(IN3,LOW);
digitalWrite(IN4,HIGH);
delay(5000);
//Freia Motor_B
digitalWrite(IN3,HIGH);
digitalWrite(IN4,HIGH);
delay(5000);
//Sentido 2
digitalWrite(IN3,HIGH);
digitalWrite(IN4,LOW);
delay(5000);
//Freia Motor_B
digitalWrite(IN3,HIGH);
digitalWrite(IN4,HIGH);
delay(5000);
/*Fim dos Estados do motor_B*/
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Se tudo deu certo, teremos o motores fazendo os seguintes movimentos:
- Motor A gira em um sentido
- Motor A freia
- Motor A gira no sentido contrario
- Motor A freia
- Motor B gira em um sentido
- Motor B freia
- Motor B gira no sentido contrario
- Motor B freia
Entendendo a fundo
Entendendo o Software
Primeiro definimos os pinos que estão conectados à ponte H para controle de cada motor.
//motor_A int IN1 = 2 ; int IN2 = 4 ; //motor_B int IN3 = 6 ; int IN4 = 7 ;
Veja que temos 2 pinos para cada moto para controle de sentido de giro.
Movimentando o motor
Para fazer o motor se movimentar, primeiro temos que informar para que direção ele deve girar:
//Motor_A //Sentido 1 digitalWrite(IN1,LOW); //0V digitalWrite(IN2,HIGH); //5V
Para controlar o sentido, temos as seguintes combinações para o motor A(IN1 e IN2)
É importante ter em mente essas combinações:
//Sentido 1 digitalWrite(IN1,LOW); //0V digitalWrite(IN2,HIGH); //5V //Freia Motor_A digitalWrite(IN1,HIGH); //5V digitalWrite(IN2,HIGH); //5V //Sentido 2 digitalWrite(IN1,HIGH); //5V digitalWrite(IN2,LOW); //0V
Fechamento
Que tal agora aprender a controlar a velocidade de um motor DC usando um módulo de Ponte H?
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
Referências Bibliográficas
[1] Guimarães, F. A. Desenvolvimento de Robô Móvel Utilizando para a Exploração de Ambientes Hostis – Dissertação de Mestrado em Engenharia de Processos Químicos e Bioquímicos, Escola de Engenharia Mauá do Centro Universitário do Instituto Mauá de Tecnologia, São Caetano do Sul, SP, Brasil, 2007.
Editado por Allan Mota e revisado por Ícaro Lobo
Usando a interrupção externa no seu Arduino
Usando a interrupção externa no seu Arduino
Imagine que você esteja fazendo seu bolo e no meio da receita seu telefone toque. Possivelmente você irá parar o que está fazendo e irá atender o telefone, assim que encerrar a chamada você irá retornar ao ponto que parou em sua receita. Quando estamos executando um tarefa muitas vezes temos que a interromper para resolver outra tarefa importante para só depois retornar do ponto que se parou. Isso se chama interrupção e é usada com frequência na programação de microcontroladores, tais como o Arduino. Uma interrupção tem dois pontos chaves, são eles:
- Condição de interrupção: É a condição que indica uma interrupção. Ela avisa ao programa que é a hora de executar uma tarefa extraordinária. No nosso exemplo, essa condição é o toque do telefone.
- Função a ser executada: Quando algo indica a interrupção, temos que executar uma lista de instruções referentes a essa interrupção. No exemplo dado, temos que parar de fazer o bolo e ir atender ao telefone. A função atender telefone é uma função extraordinária que só é executada pelo fato de ter ocorrido a condição de interrupção, o toque do telefone.
Para aprender como implementar uma interrupção, vamos fazer uma experiência simples para depois explicá-la. Nela você poderá entender melhor esse conceito de interrupção em um microcontrolador.
[toc]
Mãos à obra – Implementando uma interrupção
Componentes necessários
- Arduino Uno ou placa similar
- Botão de pressão
- LED 5mm
- Resistor 1kΩ
- Resistor 470Ω
- Fios Jumper’s
- Protoboard
Montando o projeto
Agora vamos conectar os componentes do projeto. Para isso, monte seu circuito conforme a figura a seguir.
Lembre-se: Garanta que seu Arduino esteja desligado durante a montagem e que o seu LED esteja conectado corretamente, com a perna mais longa (Anodo) conectado ao resistor e a perna menor (catodo) ao GND.
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Programando
Crie um programa (sketch) e salve com o nome de “programa_interrupcao_externa”.
Com o seu programa salvo, escreva nele o código conforme escrito abaixo.
// Daremos um nome ao pino que ficara o LED:
int led = 13;
void interrupcao(){
digitalWrite(led, HIGH); // Liga o LED (HIGH = nível lógico alto)
delay(5000);
}
// Esta função "setup" roda uma vez quando a placa e ligada ou resetada
void setup() {
pinMode(led, OUTPUT); // Configura o pino do led (digital) como saída
attachInterrupt(0,interrupcao,RISING); //Configurando a interrupção
}
// Função que se repete infinitamente quando a placa é ligada
void loop() {
digitalWrite(led, HIGH); // Liga o LED (HIGH = nível lógico alto)
delay(1000); // Espera um segundo
digitalWrite(led, LOW);// Desliga o LED (LOW = nível lógico baixo)
delay(1000); // Espera um segundo
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Caso tenha ocorrido tudo como esperado, o LED deve piscar intermitentemente. Quando você apertar o botão, o LED da protoboard permanecerá aceso por 5 segundos. Caso você não pressione o botão novamente, ele voltará a piscar.
Entendendo a fundo
Entendendo o Hardware
As placas Arduino possuem pinos que podem desempenhar a função de entrada de sinal para interrupção externa. No Arduino UNO são as portas digitais 2 e 3, que para tal função são nomeadas de INT0 e INT1, respectivamente. Veja a tabela a seguir com os pinos de cada placa Arduino que possuem essa qualidade.
| Board | Digital Pins Usable For Interrupts |
| Uno, Nano, Mini, other 328-based | 2, 3 |
| Mega, Mega2560, MegaADK | 2, 3, 18, 19, 20, 21 |
| Micro, Leonardo, other 32u4-based | 0, 1, 2, 3, 7 |
| Zero | all digital pins, except 4 |
| MKR1000 Rev.1 | 0, 1, 4, 5, 6, 7, 8, 9, A1, A2 |
| Due | all digital pins |
| 101 | all digital pins (Only pins 2, 5, 7, 8, 10, 11, 12, 13 work with CHANGE |
| Board | int.0 | int.1 | int.2 | int.3 | int.4 | int.5 |
| Uno, Ethernet | 2 | 3 | ||||
| Mega2560 | 2 | 3 | 21 | 20 | 19 | 18 |
| 32u4 based (e.g Leonardo, Micro) | 3 | 2 | 0 | 1 | 7 | |
| Due, Zero, MKR1000, 101 | interrupt number = pin number | |||||
Dessa forma, para que seja possível o uso da interrupção externa, escolhemos o pino digital 2 (INT0), no qual conectamos o botão.
Entendendo o programa
Considerando que você já sabe o básico , você já pode entender a maioria dos programas. Dessa forma, iremos nos ater às novidades.
Configurando a interrupção externa no Arduino
Para que o Arduino leia uma interrupção, devemos configurá-lo. Para tal usaremos o comando attachInterrupt().
attachInterrupt(INT,FUNCAO,MODO); //Configurando a interrupção
INT: Número da porta usada para a interrupção. No Arduino UNO INT 0 corresponde à porta digital 2 e INT 1 corresponde à porta digital 3; Como explicado anteriormente, numa interrupção temos dois pontos chaves: a condição da interrupção e a função que será executada. Dessa forma, o comando attachInterrupt é usado para informar ao programa esses dados. São eles:
FUNÇÃO: Nome da função que será chamada e executada quando ocorrer a interrupção;
MODO: Define em qual tipo de variação do sinal a interrupção será disparada. As opções são:
- LOW: Dispara a interrupção quando a tensão no pino está em 0V
- CHANGE: Dispara sempre que o sinal no pino muda de estado, borda 0V (0) para 5V(1) ou vice-versa;
- RISING: Dispara somente borda de subida, 0v (0) para 5V (1);
- FALLING: Dispara somente borda de descida, 5V (1) para 0V (0)
Em nosso programa, usaremos esse comando da seguinte forma:
attachInterrupt(0,interrupcao,RISING); //Configurando a interrupção
Portanto, temos como condição de interrupção a mudança de estado de 0V (0) para 5V(1) no pino digital 2 (INT 0) e a função a ser executa se chama interrupção.
Função interrupcao()
Função é um bloco de tarefas a serem executadas pelo programa quando solicitada.
void interrupcao(){ //Função executada quando ocorre a interrupção externa
digitalWrite(led, HIGH); // Liga o LED (HIGH = nível lógico alto)
delay(5000);
}
No nosso caso, a função será solicitada quando ocorrer a interrupção. As tarefas a serem executadas serão: acender o LED e esperar 5 segundos.
Caso você queira saber mais sobre interrupção externa no Arduino, você pode ler sobre ela no site oficial da Arduino. Link
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
Usando o buzzer com Arduino - Transdutor piezo elétrico
Usando o buzzer com Arduino - Transdutor piezo elétrico
Ouvir e falar certamente é uma das habilidades mais importantes que temos. O som é uma forma muito eficiente de comunicação. Então que tal um pouco de som com seu Arduino? Nesse tutorial iremos aprender a usar um dispositivo um tanto quanto barulhento, O sonorizador piezo. Para isso usaremos um buzzer junto ao Arduino.
[toc]
Relembrar é viver
Todo mundo se lembra daqueles cartões de natal que tocavam Jingle Bells, não é? Eu gostava muito! Era intrigante imaginar como era possível sair som de um simples cartão natalino. Estava acostumado a ouvir sons saindo de grandes auto-falantes e, de repente, me deparava com um cartão que era capaz de tocar música.
Alguns anos depois descobri como funcionavam esses cartões, eles usam um dispositivo chamado transdutor piezo elétrico.
Transdutor piezo elétrico
A palavra piezo é de origem grega e significa pressionar, torcer. Piezos são elementos que utilizam o efeito piezoelétrico.
Do famoso portal wikipedia, temos que:
Piezoeletricidade é a capacidade de alguns cristais gerarem tensão elétrica por resposta a uma pressão mecânica.
Sendo assim, alguns materiais possuem a capacidade de gerar tensão elétrica quando são submetidos a uma força externa. Uma das aplicações dele é como sensores de batida, como em baterias elétricas. Outro lugar comum de encontrá-los, é em isqueiros, que transformam o movimento do ignitor em faísca.
O mais interessante é que o contrario também é verdade. Quando inserimos um diferencial de tensão no cristal, o cristal transforma energia elétrica em energia mecânica. Dessa forma, o piezo se mexe.
Através desse efeito, podemos alimentar o transdutor com um tensão variável, com o intuito de obter sons.
O Som
O som é a propagação de uma vibração acústica em um meio material elástico, tal como o ar e a água, que seja perceptível pelo aparelho auditivo humano. Essa vibração gera o movimento das partículas desses materiais que, com isso, transmitem o som.
Como seres humanos, temos como um de nossos principais sensores o sistema auditivo. Além de nos permitir escutar, ele também está intimamente ligado ao equilíbrio do nosso corpo. (Recomendo a todos que estudem sobre os sistemas sensoriais do corpo humano. O que tentamos fazer com robótica, já está pronto na natureza).
Em resumo, o ouvido recebe o som e transforma em impulsos nervosos que serão enviados para nosso cérebro, que terá o trabalho de interpretar a informação.
O nosso aparelho auditivo é capaz de ouvir vibrações com frequência mínima de 20Hz, enquanto a frequência máxima chega a 20.000Hz. Sons cuja frequência seja maior que 20kHz são denominados ultrassons, enquanto que aqueles abaixo de 20Hz são chamados de infrassons.
Sabendo que o som é a propagação de uma vibração entre 20Hz e 20kHz, podemos usar a propriedade do transdutor piezo elétrico de se mexer ao aplicarmos uma tensão elétrica e gerar som.
Para isso, podemos colocar uma onda de tensão na faixa de frequência audível , assim o transdutor vibrará na mesma frequência, emitindo som. Veremos isso na prática durante a experiência.
Como eles são?
Em geral, o piezo é encontrado em formato de disco com dois fios. Um vermelho, o positivo, e um preto, o negativo. Veja um típico piezo na imagem abaixo.
Quando o assunto é Arduino, utilizamos muito o buzzer, que nada mais é que um disco piezo encapsulado em uma proteção plástica.
Podemos usar ele sozinho ou em um módulo, tal como o da GBK robots:
Mãos à obra - Fazendo uma sirene com um buzzer
Componentes necessários
Montando o projeto
Agora vamos conectar os componentes do projeto. Para isso, desligue o cabo USB de seu Arduino e monte seu circuito conforme a figura a seguir. A perna positiva do buzzer ficará no pino 9 e a negativa no GND.
Veja como ficou o nosso:
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Programando
Crie um programa (sketch) e salve com o nome de “programa_buzzer_sirene”.
Com o seu programa salvo, escreva nele o código conforme escrito abaixo.
float seno;
int frequencia;
void setup() {
//define o pino 9 como saída
pinMode(9,OUTPUT);
}
void loop() {
for(int x=0;x<180;x++){
//converte graus para radiando e depois obtém o valor do seno
seno=(sin(x*3.1416/180));
//gera uma frequência a partir do valor do seno
frequencia = 2000+(int(seno*1000));
tone(9,frequencia);
delay(2);
}
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Caso tenha ocorrido tudo como esperado, o buzzer deve começar a "gritar" como uma sirene.
Cuidado: Apesar de surpreendente, não entendedores podem ficar bravos com você devido ao barulho!
Entendendo a fundo
Entendendo o Software
Seno
Para que o nosso buzzer emita o som de uma sirene, precisamos que sua frequência do som emitido aumente e diminua. Dessa forma, o buzzer irá variar de frequências mais graves até frequências mais agudas e vice-versa.
Para isso, usaremos a função seno em conjunto com a variável parâmetro de for, o x, que varia de 0 a 180. A ideia é que x simbolize 0 a 180 graus, como a função sin faz o cálculo usando valores em radianos. Precisamos converter graus para radianos. A variável seno receberá o valor de seno para o ângulo x convertido em radianos.
seno=(sin(x*3.1416/180));
Seno será um valor entre 0 e 1, visto que trabalharemos com um ângulo menor que 180 graus. Dessa forma, multiplicaremos por 1000 para que ele varie de 0 a 1000 e posteriormente somamos a 2000, que será a frequência mínima do som.
frequencia = 2000+(int(seno*1000));
Portanto, teremos a variável frequência variando entre 2000 e 3000 em função de x, que irá variar conforme o bloco for incrementá-lo.
Tone
Por fim, no Arduino, temos uma função que gera uma onda pulsante na frequência desejada. O nome dessa função é tone.
tone(pino,frequência); tone(pino,frequência,duração);
Para usar essa função, devemos definir o pino de saída, a frequência do tom e, caso queira, a duração em milissegundos da onda. Em nossa experiência usamos da seguinte forma:
tone(9,frequencia);
Veja que a frequência de saída irá variar entre 2000Hz e 3000Hz.
Vale lembrar que quando o x for 180, o programa irá sair de for, porem irá executá-lo novamente, devido ao fato de tudo que está dentro da função loop ser executado ciclicamente.
void loop() {
for(int x=0;x<180;x++){
//converte graus para radiando e depois obtém o valor do seno
seno=(sin(x*3.1416/180));
//gera uma frequência a partir do valor do seno
frequencia = 2000+(int(seno*1000));
tone(9,frequencia);
delay(2);
}
}
Entendendo o Hardware
O som da sirene que ouvimos é resultado de um sinal digital de frequência variável na saída do pino 9, que ao energizar a perna positiva buzzer, o mesmo emite um som com frequência igual ao da saída do Arduino.
Para que o som seja o de uma sirene, aumentamos e diminuímos, através do programa, a frequência de saída do Arduino. Caso colocássemos uma frequência fixa, teríamos um som continuo.
Experimente colocar uma frequência contante tal como o código abaixo. Experimente valores entre 0Hz e 30000Hz e veja na prática a faixa de sons audíveis.
int frequencia;
void setup() {
//define o pino 9 como saída
pinMode(9,OUTPUT);
}
void loop() {
frequencia=440; // frequência correspondente a notá Lá
tone(9,frequencia);
}
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
Sensor de Luz com LDR
Sensor de Luz - Aprendendo a usar o LDR com Arduino
Que tal construir um dispositivo que seja capaz de detectar luz? Você pode, por exemplo, fazer uma lâmpada que ligue sozinha durante a noite. Nesse tutorial, iremos aprender a usar um componente simples e barato que pode ser usado em diversos projetos, o LDR, montando um sensor de luz com uma placa Arduino.
Relembrar é viver
Quem nunca se perguntou como as lâmpadas dos postes ligam sozinhas de noite? Quantas vezes, quando éramos crianças, tentamos apagar as lâmpadas deles usando um laser? Possivelmente, muitos de nós já sabíamos qual era o dispositivo que acionava as lâmpadas.
O nome do dispositivo responsável por saber a hora certa de iluminar é conhecido como fotocélula ou relé fotocélula que nada mais é que um sensor de luz. Ele recebe a luz através dessa parte transparente. Como é possível ver na imagem abaixo, a fotocélula possui um LDR que irá medir a luminosidade.
Nessa fotocélula, quando o valor de luminosidade é menor do que o valor desejável, ele comuta uma chave que poderá ligar uma lâmpada, por exemplo.
LDR
O LDR, sigla em inglês de Light-Dependent Resistor, que significa resistor dependente de luz, nada mais é do que o que o próprio nome diz. Tipicamente, quanto maior a luz incidente nesse componente, menor será sua resistência.
O LDR é constituído de um semicondutor de alta resistência, que ao receber uma grande quantidade de fótons oriundos da luz incidente, ele absorve elétrons que melhoram sua condutibilidade, reduzindo assim sua resistência.
Dessa forma, esse semicondutor pode assumir resistências na ordem de mega Ohm no escuro e resistência na ordem de poucas centenas quando exposto a luz.
https://www.youtube.com/watch?v=EvVUemlMsSY
Mãos à obra – Fazendo um sensor de luz com LDR
Componentes necessários:
- LDR - Sensor de Luz
- Fios Jumper’s
- Protoboard
- Arduino Uno Rev3 ou similar
- LED
- Resistor 300Ohm
- Resistor 10kOhm
Montando o projeto
Agora vamos conectar os componentes do projeto na protoboard. Para isso, desligue o cabo USB de seu Arduino e monte seu circuito conforme a figura a seguir.
Veja como ficou o nosso:
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Programando
Crie um programa (sketch) e salve com o nome de “programa_sensor_de_luz”.
Com o seu programa salvo, escreva nele o código conforme escrito abaixo.
//Sensor de luz com LDR
int ledPin = 7; //Led no pino 7
int ldrPin = 0; //LDR no pino analígico 8
int ldrValor = 0; //Valor lido do LDR
void setup() {
pinMode(ledPin,OUTPUT); //define a porta 7 como saída
Serial.begin(9600); //Inicia a comunicação serial
}
void loop() {
///ler o valor do LDR
ldrValor = analogRead(ldrPin); //O valor lido será entre 0 e 1023
//se o valor lido for maior que 500, liga o led
if (ldrValor>= 800) digitalWrite(ledPin,HIGH);
// senão, apaga o led
else digitalWrite(ledPin,LOW);
//imprime o valor lido do LDR no monitor serial
Serial.println(ldrValor);
delay(100);
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Caso tenha ocorrido tudo como esperado, ao cobrir o LDR, o LED irá acender. Abra o monitor serial para verificar o que está sendo lido na entrada A0.
Entendendo a fundo
Entendendo o Hardware
- Resistência
Imagine que a tubulação que une os dois reservatórios tenha uma espessura menor em uma situação A que em outra em uma situação B, como na figura abaixo.
Por intuição, sabemos que, na situação A, a vazão entre os dois reservatórios será menor que na situação B.
O mesmo acontece com a corrente elétrica, existe uma propriedade chamada resistência quem tem como unidade o Ohm representado pelo símbolo grego ômega (Ω).
O nome da unidade da resistência faz homenagem a Ohm que criou as duas leis de Ohm. Uma delas diz que:
"A corrente que flui por um circuito é diretamente proporcional à tensão e inversamente proporcional à resistência."
Traduzindo, a resistência limita a corrente de forma proporcional, visto que para um tensão V fixa teremos um corrente cada vez menor para uma resistência cada vez maior.
V = R * I
Sabemos que energia não se perde ou se cria, ela se transforma. A energia perdida na desaceleração dos elétrons é convertida em calor.
- Divisor de tensão
Quando temos duas resistências associadas em série temos a seguinte situação:
Vin= (R1 + R2)*Ia
Se nossa tensão é fixa (Vin = 5V), temos:
Ia = 5V / (R1 + R2)
Ou seja, a corrente é o resultado da divisão da tensão 5V pela soma da resistências.
Nesse circuitos temos um efeito interessante: temos as mesma corrente para os dois resistores mas temos uma tensão diferente em cada um.
Vr1 = Ia * R1 e Vr2 = Ia * R2
Ou seja, a queda de tensão será maior no resistor maior.
Esse circuito é chamado de divisor de tensão. Como a corrente do circuito é calculada pela divisão da tensão total pela soma dos resistores, teremos a tensão em cima de um resistor igual a resistência desse resistor vezes a tensão total dividida pela soma dos resistores.
Ia = 5V / (R1 + R2) e Vr2 = Ia * R2
Vr2 = (5V / (R1 + R2)) * R2
O exemplo a seguir mostra como funciona o cálculo o para dois resistores.
Quando usamos um LDR, que é uma resistência foto-variável, podemos usar da propriedade do divisor de tensão para medir a variação da queda de tensão em cima do mesmo. Sabemos que a tensão total e a resistência total são fixas. Dessa forma, o divisor de tensão vai variar com a resistência entre A0 e GND.
Levando em conta que quanto menos luz incidir sobre o LDR maior será sua resistência, teremos a tensão sobre o LDR e por conseguinte o valor de A0 maior com um índice de luminosidade incidente menor, isto é, num local mais escuro.
VA0 = (5V / (1K + LDR)) * LDR
- Quanto menor luminosidade maior a resistência do LDR;
- Quanto maior a resistência do LDR, maior a tensão em A0;
- Então: quanto menor a luminosidade maior é a tensão em A0.
Entendendo o Software
- Lendo da entrada analógica
A leitura da entrada analógica é feita com a função analogRead, que recebe como parâmetro o pino analógico a ser lido e retorna o valor digital que representa a tensão no pino. Como o conversor analógico-digital do Arduino possui uma resolução de 10 bits, o intervalo de tensão de referência, que no nosso caso é 5 V, será dividido em 1024 pedaços (2^10) e o valor retornado pela função será o valor discreto mais próximo da tensão no pino.
ldrValor = analogRead(ldrPin); //O valor lido será entre 0 e 1023
O código acima lê o valor analógico de tensão no pino A0 e guarda o valor digital na variável valorLido. Supondo que o pino está com uma tensão de 2V, o valor retornado pela conversão será:
2 x 1024 / 5 = 409,6
O resultado deve ser inteiro para que nosso conversor consiga representá-lo, logo, o valor 410 será escolhido por ser o degrau mais próximo. Esse valor representa a tensão 2,001953125, inserindo um erro de 0,001953125 em nossa medida devido à limitação de nossa resolução.
Você pode ler mais sobre sinal analógico no tutorial Entradas e Saídas Analógicas.
- Lógica do programa
Em resumo, nosso programa lerá qual é o valor do sinal em A0 com o auxílio do comando analogRead(), que retornará um valor entre 0 a 1023, e o comparará com um valor de referência que em nosso caso é 800. Tendo em vista que, quanto mais escuro, maior será o valor de A0, caso A0 seja maior que o valor de referência o programa liga o LED conectado ao pino 7. Do contrário, ele apaga o LED. O programa também imprime o valor de A0 para que possamos verificar a faixa de valores e até mesmo calibrar nosso sensor.
Tente mudar o valor de referência e veja que, quanto maior esse valor, menor será sua sensibilidade.
Desafios
- Crie um alarme usando um buzzer e um LDR, explicado em nosso ultimo tutorial Usando buzzer com Arduino, Quando houver pouca luz, o alarme deve disparar.
- Usando 3 ou mais LED's e um LDR, faça um programa que aumente o numero de LED's acesos conforme a intensidade de luz seja menor.
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
Display LCD Nokia 5110 - Imprimindo uma imagem
Display LCD Nokia 5110 - Imprimindo uma imagem
No último tutorial vimos como fazemos para imprimir textos e desenhos no display LCD Nokia 5110 usando as bibliotecas LCD5110_Basic.h e LCD5110_Graph.h . Nesse tutorial faremos algo ainda mais interessante. Iremos aprender a imprimir uma imagem em nosso display usando uma função da biblioteca LCD5110_Graph.h.
Para o melhor aproveitamento desse tutorial é importante que você já tenha lido o tutorial anterior sobre o Display LCD Nokia 5110.
[toc]
Exemplo 3 - Imprimindo uma imagem no display Nokia 5110
Componentes necessários
Para este exemplo, utilizaremos:
- Placa Arduino UNO ou similar
- Módulo display Nokia 5110 (Azul ou Vermelho)
- Fios jumper's
- Protoboard
- Resistores
- 1 Imagem
Montando o projeto
O circuito desse exemplo é o mesmo do exemplo 1 do tutorial Display LCD Nokia 5110 - Aprenda como utilizá-lo com seu Arduino.
Para o display de placa azul que opera a 5V teremos o seguinte esquema:
Abaixo a tabela com as pinagens:
| Pino | Resistor | Arduino | Cor |
| 1 - RST | - | Pino 12 | Amarelo |
| 2 - CE | - | Pino 11 | Verde |
| 3 - DC | - | Pino 10 | Azul |
| 4 - DIN | - | Pino 9 | Laranja |
| 5 - CLK | - | Pino 8 | Roxo |
| 6 - VCC | - | 5v | Vermelho |
| 7 - LIGHT | 220R | 5v | Vermelho |
| 8 - GND | - | GND | Preto |
Para o display de placa vermelha que opera a 3.3V, precisamos colocar resistores de 10k Ohm nas entradas de sinal uma vez que a saída do Arduino UNO é de 5V. Nesse caso, teremos uma queda de tensão no resistor, diminuindo a tensão que chegará ao módulo.
Veja o esquema:
Abaixo a tabela com as pinagens:
| Pino | Resistor | Arduino | Cor |
| 1 - RST | 10K | Pino 12 | Amarelo |
| 2 - CE | 10K | Pino 11 | Verde |
| 3 - DC | 10K | Pino 10 | Azul |
| 4 - DIN | 10K | Pino 9 | Laranja |
| 5 - CLK | 10K | Pino 8 | Roxo |
| 6 - VCC | - | 3.3v | Vermelho |
| 7 - LIGHT | 220R | GND | Marrom |
| 8 - GND | - | GND | Preto |
Nota: Caso o LCD 5110 de placa vermelha seja utilizado com um Arduino Due não será necessário o uso dos resistores de 10K pois suas portas operam a 3.3V!
Arduino Uno com display placa azul
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Preparando a Imagem
Neste exemplo iremos movimentar uma imagem na tela. Para que uma imagem seja exibida na tela do LCD 5110 será necessário convertê-la para uma arranjo de caracteres hexadecimais, formato suportado pela biblioteca e a tela. Além disso é necessário ajustar as dimensões da imagem para seja igual ou menor que as dimensões da tela (84x48 pixels).
Vamos utilizar esta imagem:
Para editar a imagem usaremos o editor de imagens GIMP que é gratuito e está disponível aqui. Você pode utilizar qualquer outro editor de imagens.
Abra a imagem com o GIMP, vá no menu Imagem e clique em “Redimensionar imagem”
Na janela seguinte coloque o valor 48 para altura e automaticamente ele ajustará a largura para 63. Clique em Redimensionar e a imagem estará com as dimensões ideais para o display.
Depois vá no menu Imagem, clique em “Modo” e em seguida “Indexado...”
Na janela a seguir selecione “Usar paleta preto e branco (1 Bit) e clique em “Converter”
Agora clique no menu Arquivo, vá em “Exportar como”, selecione o formato “Imagem BMP do Windows”, defina um nome(para o exemplo usaremos “vidadesilicio.bmp”) e clique em “Exportar”O resultado será essa imagem:
Agora vamos utilizar o programa LCD Assistant para converter nossa imagem em um arranjo hexadecimal. Para baixa-lo clique aqui.
Abra o programa clique em “File” e em seguida “Load image” e abra a imagem “vidadesilicio.bmp”.
Clique novamente em “File” e clique na opção “Save output”. Salve com o nome “vidadesilicio.c” dentro da pasta exemplo 3.
Programando
Crie um programa (sketch) e salve com o nome de “modulo_5110_ex3”. Com o seu programa salvo, adicione a biblioteca LCD5110_Graph.h
Para baixar as bibliotecas clique aqui. Depois adicione ela à sua IDE Arduino
Para saber como incluir uma biblioteca na IDE Arduino, visite o post Sensores DHT e Uso de Bibliotecas.
Em seguida, insira nele o código conforme escrito abaixo:
#include <LCD5110_Graph.h>
LCD5110 tela(8,9,10,12,11);
//O arranjo gerado pelo programa terá o mesmo nome da imagem
extern uint8_t vidadesilicio[]; //Obtendo o arranjo
void setup()
{
tela.InitLCD();
}
void loop()
{
for (int i=0; i<=160; i++) //laço necessário para o carrinho percorrer a tela toda
{
tela.clrScr(); //limpando a tela e o buffer
tela.drawBitmap(i-63, 0, vidadesilicio, 63, 48); //desenhando a imagem na tela
tela.update(); //atualizando a tela com as informações armazenadas no buffer
delay(100); //Aumentando esse tempo a velocidade diminuirá,
//diminuindo-o a velocidade aumentará
}
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Se tudo deu certo, o resultado deve ser o mesmo apresentado abaixo:
Entendendo a fundo
Entendendo o Software
Para imprimir a imagem no display, utilizamos duas funções, são elas:
drawBitmap(coluna, linha, bitmap, largura, altura)
Esta função desenha na tela um bitmap que deve ser previamente definido como um array hexadecimal. Os valores de coluna e linha definirão em que posição a imagem será desenhada na tela. Os valores de altura e largura correspondem ao tamanho da imagem. Os valores máximos são 84 para largura e 48 para altura.
tela.drawBitmap(coluna, linha, nome da imagem, largura, altura); //desenhando a imagem na tela
Você pode encontrar ela em nosso programa tal como apresentado abaixo. Note que a coluna está em função da variável i, usada no for, e por isso a imagem se mexe na tela.
tela.drawBitmap(i-63, 0, vidadesilicio, 63, 48); //desenhando a imagem na tela
update()
Esta função serve para atualizar a tela, ela será necessária toda vez que alguma alteração na tela seja feita.
tela.update(); //atualizando a tela com as informações armazenadas no buffer
Desafio
- Utilizando o sensor ultrassom HC-SR04 modifique o código do exemplo 3 para que o carrinho pare na tela sempre que a distância for menor que 10cm. Caso a distância seja maior ou igual a 10cm ele deverá continuar andando.
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
Revisado por Ícaro Lobo e editado por Allan Mota
Display LCD Nokia 5110 - Aprenda como utilizá-lo com seu Arduino
Display LCD Nokia 5110 - Aprenda como utilizá-lo com seu Arduino
Já tivemos a oportunidade de explicar sobre o uso do Display LCD de caracter e como utilizá-lo com o Arduino. Apesar de muito útil, esse tipo de tela possui suas limitações. Caso você queira que a experiência do usuário com o seu projeto seja melhor através de funções gráficas esteticamente mais agradáveis, como por exemplo, imprimir uma imagem, é mais interessante a utilização de um display com mais funções tal como o display Nokia 5110 que possui uma resolução de 84x48 pixels. Nesse tutorial iremos aprender como usar o display Nokia 5110. Vamos lá?
[toc]
As máquinas querem conversar
Por muitas vezes precisamos coletar dados ou interagir com sistemas automatizados. Dessa forma, precisamos de um caminho que torne essa interação possível. O nome desse caminho de comunicação chama-se IHM (Interface Homem Máquina).
IHM é um caminho pelo qual o homem e o computador podem se comunicar e interagir, visando atingir um objetivo comum.
Tipicamente, uma IHM é dada por algum tipo de saída (indicadores de velocidades, monitores, displays, auto-falantes, etc) e algum tipo de entrada (botões, touchscreen, microfone, câmera, dentre outros). Quanto mais fácil for para coletar informações e introduzir entradas em um sistema automatizado, mais trivial será a interação dele com o usuário.
É ai que entram os displays! Boa parte dos dispositivos automatizados que utilizamos possuem displays. O motivo é claro: Eles podem apresentar ao usuário varias informações de forma rápida. Além disso, um display pode apresentar vários tipos de saídas, desde textos ou números até imagens em movimento.
O famoso celular Nokia 5110
O Nokia 5110 foi um popular telefone celular lançado pela Nokia em 1998 e fez bastante sucesso por diversos motivos: permitia a troca da tampa frontal por outras de cores diferentes, era de fácil utilização e tinha novas funcionalidades, como jogos e o recebimento de mensagens SMS. Além disso, o aparelho possuía um bom custo-beneficio e uma bateria com duração de vários dias.
A tela não era colorida, porém, tinha uma ótima resolução para época e deu vida ao clássico jogo Snake que fez sua primeira aparição justamente no modelo 5110. A Nokia vendeu milhões de unidades do aparelho, contudo, com o passar do tempo ele foi substituído por lançamentos mais modernos.
Aproveitando a onda de projetos para Arduino algumas fábricas resolveram aproveitar os displays desses milhões de telefones que estavam sem utilização, fazendo as devidas adaptações, para o uso com o Arduino.
Para isso, o display fora colocado em uma placa junto com o chip controlador PCD8544 da Philips. Esses módulos podem ser encontrados em duas versões, entretanto, a única diferença entre elas é que a versão de placa azul funciona em 5V enquanto que a versão de placa vermelha funciona em 3.3V.
Neste tutorial será ensinado como utilizar um display LCD gráfico do Nokia 5110 usando as bibliotecas criadas por Henning Karlsen do site Rinky-Dink Eletronics.
Para baixar as bibliotecas clique aqui. Depois adicione ela à sua IDE Arduino
Para saber como incluir uma biblioteca na IDE Arduino, visite o post Sensores DHT e Uso de Bibliotecas.
Mãos à obra – Exemplo 1 – Escrevendo no Display
Componentes necessários
Para este exemplo, utilizaremos:
- Placa Arduino UNO ou similar
- Módulo display Nokia 5110 (Azul ou Vermelho)
- Fios jumper's
- Protoboard
- Resistores
Montando o projeto
Agora iremos conectar os componentes do projeto. Para isso, desligue o cabo USB de seu Arduino e monte seu circuito conforme a figura a seguir.
Para o display de placa azul que opera a 5V teremos o seguinte esquema:
Abaixo a tabela com as pinagens:
| Pino | Resistor | Arduino | Cor |
| 1 - RST | - | Pino 12 | Amarelo |
| 2 - CE | - | Pino 11 | Verde |
| 3 - DC | - | Pino 10 | Azul |
| 4 - DIN | - | Pino 9 | Laranja |
| 5 - CLK | - | Pino 8 | Roxo |
| 6 - VCC | - | 5v | Vermelho |
| 7 - LIGHT | 220R | 5v | Vermelho |
| 8 - GND | - | GND | Preto |
Para o display de placa vermelha que opera a 3.3V, precisamos colocar resistores de 10k Ohm nas entradas de sinal uma vez que a saída do Arduino UNO é de 5V. Nesse caso, teremos uma queda de tensão no resistor, diminuindo a tensão que chegará ao módulo.
Veja o esquema:
Abaixo a tabela com as pinagens:
| Pino | Resistor | Arduino | Cor |
| 1 - RST | 10K | Pino 12 | Amarelo |
| 2 - CE | 10K | Pino 11 | Verde |
| 3 - DC | 10K | Pino 10 | Azul |
| 4 - DIN | 10K | Pino 9 | Laranja |
| 5 - CLK | 10K | Pino 8 | Roxo |
| 6 - VCC | - | 3.3v | Vermelho |
| 7 - LIGHT | 220R | GND | Marrom |
| 8 - GND | - | GND | Preto |
Nota: Caso o LCD 5110 de placa vermelha seja utilizado com um Arduino Due não será necessário o uso dos resistores de 10K pois suas portas operam a 3.3V!
Veja como ficou a nossa montagem:
Arduino Uno com display placa azul
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Programando
Crie um programa (sketch) e salve com o nome de “modulo_5110_ex1”.
Com o seu programa salvo, adicione a biblioteca LCD5110_Basic.h
Para baixar as bibliotecas clique aqui. Depois adicione ela à sua IDE Arduino
Para saber como incluir uma biblioteca na IDE Arduino, visite o post Sensores DHT e Uso de Bibliotecas.
Em seguida, insira nele o código conforme escrito abaixo:
#include <LCD5110_Basic.h>
LCD5110 tela(8,9,10,12,11);
/*Cria objeto da classe LCD5110
CLK – Pino 8
DIN – Pino 9
DC – Pino 10
RST – Pino 12
CE – Pino 11
*/
//Obtendo as fontes
extern uint8_t SmallFont[];
extern uint8_t MediumNumbers[];
extern uint8_t BigNumbers[];
void setup()
{
tela.InitLCD(); //Inicializando o display
}
void loop()
{
tela.setFont(SmallFont); //Definindo a fonte
//Escreve a palavra vida alinhada à esquerda começando na linha 0
tela.print("Vida", LEFT, 0);
delay(500);
tela.clrScr(); //Apaga o contéudo que estiver na tela
tela.print("de", CENTER, 20);
delay(500);
tela.clrScr();
tela.print("Silicio", RIGHT, 40);
delay(500);
tela.clrScr();
delay(1000);
tela.print("VIDA", LEFT, 0);
tela.print("DE", CENTER, 20);
tela.print("SILICIO", RIGHT, 40);
delay(1000);
tela.clrScr();
tela.print("Numero medio:", LEFT, 0);
tela.setFont(MediumNumbers);
tela.printNumI(123, CENTER, 16);
delay(2000);
tela.clrScr();
tela.setFont(SmallFont);
tela.print("Numero grande:", LEFT, 0);
tela.setFont(BigNumbers);
tela.printNumI(123, CENTER, 16);
delay(2000);
tela.clrScr();
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Se tudo deu certo, o resultado deve ser o mesmo apresentado abaixo:
Entendendo a fundo - Exemplo 1
Entendendo o Hardware
Quando o assunto é displays é importante entendermos como é feita a organização da tela e as informações que serão impressas nela. Em resumo, uma tela é composta por uma matriz de pixels que estão organizados lado a lado. Cada pixel pode assumir uma cor, no caso de uma tela monocromática, cada pixel pode assumir uma cor opaca ou transparente.
Nosso display possui 84 pixels de comprimento e outros 48 pixels de altura. Isso é, ele possui uma matriz de 84 pontos por 48 pontos. Veja como eles são organizados na figura abaixo:
Um ponto importante, é entender como eles estão enumerados. Indo de 0 a 83 da esquerda para direta e de 0 a 47 de cima para baixo. Dessa forma, quando queremos escrever algo no display, é importante saber onde estamos escrevendo, levando em conta essas coordenadas horizontais e verticais, que são denominadas de coordenadas x e y, respectivamente, ao longo do tutorial.
Entendendo o Software
Para o uso do módulo display Nokia 5110 temos que entender o uso de suas bibliotecas. Para esse exemplo, explicaremos a biblioteca que foi usada no exemplo 1, a biblioteca LCD5110_Basic.
Biblioteca LCD5110_Basic
LCD5110
É o construtor que cria um objeto da classe LCD5110. Ou seja, define em quais pinos do Arduino o módulo está conectado.
LCD5110 tela(8,9,10,12,11); /*Cria objeto da classe LCD5110 CLK – Pino 8 DIN – Pino 9 DC – Pino 10 RST – Pino 12 CE – Pino 11 */
Essa é a forma mais comum de utilizá-lo:
LCD5110(CLK, DIN, DC, RST, CE); // CLK: pino do sinal de Clock; // DIN: pino para transferência de dados; // DC: pino de seleção de registros (dados/comandos); // RST: pino para resetar; // CE: pino para seleção do chip.
Em alguns modelos do LCD 5110 o pino “CLK” pode aparecer como “SCK”, o pino “DIN” como “MOSI” e o pino “CE” como “CS”.
InitLCD(valorContraste)
Inicializa o LCD. Deve ser chamada antes de qualquer outra função da classe. O valor de contraste é opcional. Caso nenhum valor seja informado será usada o valor padrão que é igual a 70. O valor do contraste pode ser definido de 0 a 127.
void setup()
{
tela.InitLCD(); //Inicializando o display
}
setContrast(número)
Caso você queira alterar o valor do contraste da tela no meio do programa, você poderá usar essa função. Ela altera o valor de contraste para o valor informado (0 a 127).
tela.setConstrastLCD(); //Alterando o valor de contraste do display
setFont(nomedaFonte)
Esta função deverá ser usada antes de print, printNumF e PrintNumI para definir qual fonte será usada.
tela.setFont(nome da fonte); //Definindo a fonte
São suportadas as fontes “SmallFont”, “MediumNumbers” e “BigNumbers”.
tela.setFont(SmallFont); //Definindo a fonte
print(texto,coluna,linha)
Com esta função você poderá colocar um texto na tela. O texto deverá estar entre aspas e os valores de coluna e linha definirão em qual posição o texto irá começar na tela.
A coordenada de linha só pode assumir os valores: 0, 8, 16, 24, 32 ou 40
tela.print("texto", coluna, linha);
tela.print("texto", alinhamento, linha);
Outra forma de usar essa função é passando o parâmetro de alinhamento. Use LEFT para alinhar à esquerda, CENTER para alinhar ao centro e RIGHT para alinhar à direita.
Veja como foi usada em nosso programa:
[cpp collapse="false"]
//Escreve a palavra vida alinhada à esquerda começando na linha 0
tela.print("Vida", LEFT, 0);
[/cpp]
printNumI(número inteiro,coluna,linha)
Com esta função você poderá colocar um número inteiro na tela. Seu uso é semelhante ao print().
A coordenada de linha só pode assumir os valores: 0, 8, 16, 24, 32 ou 40
tela.print(número,coluna,linha); tela.print(número,alinhamento,linha);
printNumF(número, coluna, linha)
Com esta função você poderá colocar um número não inteiro, Float, na tela.
A coordenada de linha só pode assumir os valores: 0, 8, 16, 24, 32 ou 40
Seu uso é semelhante ao print().
tela.print(número,coluna,linha); tela.print(número,alinhamento,linha);
clrScr()
Apaga o buffer e o que estiver na tela.
tela.clrScr(); //Apaga o conteúdo que estiver na tela
Outras funções
clrRow(coluna_inicio, coluna_fim)
Apaga um intervalo definido de uma coluna.
invert(modo)
Função para inverter a tela, caso o valor informado seja “true” ela inverterá a tela, caso seja falso deixará a tela no modo normal.
update()
Esta função serve para atualizar a tela, ela será necessária toda vez que alguma alteração na tela seja feita.
Exemplo 2 – É hora de desenhar
Este exemplo utiliza a biblioteca Graph para desenhar a bandeira do Brasil.
A montagem é a mesma que a do exemplo anterior. Dessa forma, apenas faremos outro programa.
Programando
Crie um programa (sketch) e salve com o nome de “modulo_5110_ex2”.
Com o seu programa salvo, adicione a biblioteca LCD5110_Graph.h
Em seguida, insira nele o código conforme escrito abaixo:
#include <LCD5110_Basic.h>
#include <LCD5110_Graph.h>
LCD5110 tela(8,9,10,12,11);
/*Define os pinos do Display 5110 e
cria o objeto da classe LCD5110
CLK – Pino 8
DIN – Pino 9
DC – Pino 10
RST – Pino 12
CE – Pino 11
*/
void setup()
{
tela.InitLCD(); //Inicializando o display
}
void loop()
{
tela.clrScr(); //limpando a tela
tela.drawRect(0,0,83,47); //desenhando o retangulo
tela.update(); //atualizando a tela com os dados escritos no buffer
delay(500);
tela.drawLine(0,23,41,0); //desenhando uma linha diagonal com
// as coordenadas (0,23) e (41,0)
tela.drawLine(0,23,41,47);
tela.drawLine(41,0,83,23);
tela.drawLine(41,47,83,23);
tela.update();
delay(500);
tela.drawCircle(41,23,14); //desenhando um circulo centralizado com diâmetro de 14 pixels
tela.update();
delay(500);
tela.drawLine(28,21,56,21); //desenhando uma linha reta mantendo
//as mesmas coordenadas das linhas
tela.drawLine(28,25,56,25);
tela.update();
delay(3000);
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Se tudo deu certo, o resultado deve ser o mesmo apresentado abaixo:
Entendendo a fundo - Exemplo 2
Entendendo o Software
As funções apresentadas no exemplo 1 estão presentes em ambas as bibliotecas, LCD5110_Basic e LCD5110_Graph. Porém existem algumas funções que são específicas da biblioteca Graph.
Biblioteca LCD5110_Graph
Para as funções de desenho a seguir os valores máximos são 83 para coluna e 47 para linha.
drawLine(coluna_inicio, linha_inicio, coluna_fim, linha_fim)
Desenha uma linha de acordo com as coordenadas informadas. Deve-se informar as coordenadas do ponto inicial "X0,Y0" e o ponto Final "X,Y"
tela.drawLine(Xo,Yo,X,Y);
Veja a função sendo usada em nosso exemplo:
tela.drawLine(0,23,41,0); //desenhando uma linha diagonal com // as coordenadas (0,23) e (41,0)
clrLine(coluna_inicio, linha_inicio, coluna_fim, linha_fim)
Apaga uma linha de acordo com as coordenadas informadas.
tela.clrLine(0,23,41,0); //apaga uma linha diagonal com // as coordenadas (0,23) e (41,0)
drawRect(coluna_inicio, linha_inicio, coluna_fim, linha_fim)
Desenha um retângulo de acordo com as coordenadas informadas.
tela.drawRect(Xo,Yo,X,Y); //desenhando um retângulo
Veja a função sendo usada em nosso exemplo:
tela.drawRect(0,0,83,47); //desenhando um retângulo
clrRect(coluna_inicio, linha_inicio, coluna_fim, linha_fim)
Apaga um retângulo de acordo com as coordenadas informadas.
tela.clrRect(Xo,Yo,X,Y); //apagando o retângulo
Veja a função sendo usada em nosso exemplo:
tela.clrRect(0,0,83,47); //apagando o retângulo
drawRoundRect(coluna_inicio, linha_inicio, coluna_fim, linha_fim)
Desenha um retângulo com cantos arredondados de acordo com as coordenadas informadas.
//desenhando um retangulo com cantos arredondados tela.RoundRect(Xo,Yo,X,Y);
Veja a função sendo usada em nosso exemplo:
tela.RoundRect(0,0,83,47);
clrRoundRect(coluna_inicio, linha_inicio, coluna_fim, linha_fim)
Apaga um retângulo com cantos arredondados de acordo com as coordenadas informadas.
//apagando um retangulo com cantos arredondados tela.clrRoundRect(Xo,Yo,X,Y);
Veja a função sendo usada em nosso exemplo:
tela.clrRoundRect(0,0,83,47);
drawCircle(coluna_centro, linha_centro, raio)
Desenha um círculo de acordo com as coordenadas informadas. O circulo é desenhando centralizado no ponto de cordenada Xo e Yo com diâmetro de D pixels.
tela.drawCircle(X0,Y0,D);
Veja a função sendo usada em nosso exemplo:
//desenhando um circulo centralizado no ponto (41,23) com diâmetro de 14 pixels tela.drawCircle(41,23,14);
clrCircle(coluna_centro, linha_centro, raio)
Apaga um círculo de acordo com as coordenadas informadas.
tela.clrCircle(X0,Y0,D);
Veja a função sendo usada em nosso exemplo:
//desenhando um circulo centralizado no ponto (41,23) com diâmetro de 14 pixels tela.drawCircle(41,23,14);
Desafio
- Imprima na tela o valor de distancia lido por um sensor ultrassom;
- Usando um DHT11 ou um LM35, imprima o valor de temperatura lido;
Esperamos que tenham gostado, deixe seu comentário com dúvidas, sugestões ou com a foto ou vídeo de seu projeto!!
Bônus - Aprenda a imprimir uma imagem
Veja nosso próximo tutorial e entenda como imprimir uma imagem no display Nokia 5110. Click na imagem para ler o tutorial Display LCD Nokia 5110 - Imprimindo uma imagem.
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.
Revisado por Ícaro Lobo e editado por Allan Mota
LM35 - Medindo temperatura com Arduino
Sensor de temperatura LM35 - Medindo temperatura com Arduino
Em diversas aplicações temos que fazer a leitura de variáveis físicas, tais como a temperatura, distancia, entre diversas outras. Nesse tutorial iremos aprender como fazer a leitura de temperatura usando o sensor de temperatura LM35, um sensor barato e de ótima precisão com uma placa Arduino.
[toc]
Sistemas autônomos
Quando pensamos em um sistema autônomo, pensamos em um sistema que faça a tarefa designada por conta própria, sem a necessidade de interferência do homem. Para isso, é fundamental que o seu sistema autônomo enxergue as variáveis físicas que serão importantes para o desempenho da atividade.
Pense em uma geladeira ou num ar condicionado. Neles devemos definir o valor de temperatura desejado e a partir desse valor o equipamento deve controlar essa variável. Para que ele tenha capacidade de controlar a temperatura, é fundamental que o sistema possa ler a variável. É ai que entram os sensores.
Sensores
Da famosa enciclopédia online Wikipédia, temos que:
“Um sensor é um dispositivo que responde a um estímulo físico/químico de maneira específica e mensurável analogicamente.”
Ou seja, sensores são dispositivos capazes de ler variáveis físicas ou químicas do ambiente e transformá-las em informação.
Qualquer processo automático possui sensores. Em industrias, onde há processos de produção automatizados, temos muitos tipos de sensores medindo as mais diversas variáveis do processo: temperatura, pressão, peso, pH, dentre muitos outros. Devido a importância da leitura dessas variáveis, existe uma área responsável por instrumentos de medição, a Instrumentação Industrial.
Nós, seres humanos, também somos feitos de vários sensores que nos ajudam a desenvolver nossas tarefas. Os nossos cinco sentidos: Olfato, audição, paladar, tato e visão, nada mais são do que conjuntos de sensores que colhem informações do ambiente para que o cérebro possa tomar decisões adequadas em cada situação.
Usando sensores
Tão importante quanto medir uma variável física é transformá-la em uma informação legível pelo cérebro do sistema autônomo, nosso Arduino, por exemplo. Pensando em eletrônica, essa informação pode ser digital ou analógica (Veja o tutorial Grandezas Digitais e Analógicas e PWM)
- Digital: Quando a informação é passada através de valores lógicos Altos(1) ou valores lógicos baixos(0).
- Analógico: Quando a informação pode assumir qualquer valor dentro de um máximo e um mínimo. Quando trabalhamos com eletrônica, geralmente essa informação é dada por um valor de corrente ou tensão.
LM35 - Sensor de temperatura
O sensor LM35 é um sensor de precisão que apresenta uma saída de tensão linear proporcional à temperatura em que ele se encontrar no momento, tendo em sua saída um sinal de 10mV para cada Grau Célsius de temperatura.
Esse sensor não necessita de qualquer calibração externa para fornecer com exatidão, valores temperatura com variações de ¼ºC ou até mesmo ¾ºC dentro da faixa de temperatura entre –55ºC e 150ºC.
Ele pode ser usado de duas formas, com alimentação simples ou simétrica, dependendo do que se desejar como sinal de saída, mas independentemente disso, a saída continuará sendo de 10mV/ºC.
Em cada uma dessas duas formas de alimentação, o range de temperatura, ou seja, a temperatura máxima e mínima medida com exatidão, é diferente.
Uma vantagem é o fato desse sensor drenar apenas 60μA para estas alimentações. Dessa forma, seu auto-aquecimento é de aproximadamente 0.1ºC ao ar livre e possui um consumo muito baixo.
O sensor LM35 é apresentado com vários tipos de encapsulamentos, sendo o mais comum o TO-92, que mais se parece com um transistor, e oferece ótima relação custo benefício, por ser o encapsulamento mais barato sem diferenças em seu uso ou exatidão.
Veja a folha de dados dele clicando aqui.
Mãos à obra – Medindo temperatura
Componentes necessários:
Montando o projeto
Agora vamos conectar os componentes do projeto. Para isso, desligue o cabo USB de seu Arduino e monte seu circuito conforme a figura a seguir.
Veja como ficou o nosso:
Conectando o Arduino ao computador
Conecte seu Arduino ao computador e abra a IDE Arduino.
Antes de carregar um programa, você precisa selecionar qual porta você deseja usar para fazer carregar o programa no Arduino (upload). Dentro do Arduino IDE, clique no menu Ferramentas (tools) e abra o submenu Porta(Port). Clique na porta que seu Arduino está conectado, tal como COM3 ou COM4. Geralmente aparece o nome da placa Arduino : “COM3 (Arduino/Genuino Uno)”.
Você também precisa garantir que o tipo de placa apropriado está selecionado em Ferramentas(Tools) no submenu Placa (Board).
Programando
Crie um programa (Sketch) e salve com o nome de “programa_sensor_de_temperatura”.
Com o seu programa salvo, escreva nele o código conforme escrito abaixo.
//Sensor de temperatura usando o LM35
const int LM35 = A0; // Define o pino que lera a saída do LM35
float temperatura; // Variável que armazenará a temperatura medida
//Função que será executada uma vez quando ligar ou resetar o Arduino
void setup() {
Serial.begin(9600); // inicializa a comunicação serial
}
//Função que será executada continuamente
void loop() {
temperatura = (float(analogRead(LM35))*5/(1023))/0.01;
Serial.print("Temperatura: ");
Serial.println(temperatura);
delay(2000);
}
Após escrever o código, clique em Carregar (Upload) para que o programa seja transferido para seu Arduino.
Colocando para funcionar
Caso tenha ocorrido tudo conforme esperado, poderemos fazer a leitura da temperatura através do monitor serial. Abra o monitor serial para verificar o que está sendo lido na entrada A0.
O resultado será algo semelhante à imagem a seguir:
Entendendo a fundo
Entendendo o Software
Lendo o valor de temperatura
Primeiramente, em nosso programa usamos o comando de leitura analógica, já estudado no tutorial Entradas e Saídas Analógicas, para fazer a leitura do valor em A0. Além disso, usamos a comunicação serial, também discutida em outro tutorial, Comunicação Serial Arduino . É importante que o leitor entenda como eles funcionam. Experimente ler nossos tutoriais anteriores.
Em resumo, nosso programa lerá qual é o valor do sinal no pino A0, que varia de 0 a 1023, onde 0 corresponde a 0Volts e 1023 corresponde a 5Volts. Como sabemos, 1ºC é igual a 10mV. Sendo assim, temos:
Tensão em A0 = (Valor lido em A0)*(5/1023)
Temperatura = Tensão em A0/10mV
Logo:
Temperatura = [(Valor lido em A0)*(5/1023)]/10mV
Em linguagem de programação, ficará:
temperatura = (float(analogRead(LM35))*5/(1023))/0.01;
Transformando o tipo da variável
Perceba que colocamos o comando de leitura do valor analógico, analogRead, dentro de float(). Você saberia me dizer o motivo?
Quando o Arduino faz uma leitura analógica, ele converte o valor lido, que pode ser um valor de tensão entre 0V e 5V, em um número entre 0 e 1023. Ou seja, o Arduino divide 5Volts, que é o maior valor que ele é capaz de ler, em 1023 partes iguais e lhe informa quantas partes tem o valor que ele está medindo.
Pense que temos uma rampa que vai de 0 à 5V e dividimos essa rampa em 1024 degraus. Então, quando estamos no degrau 0, estamos no que equivale a 0V, quando subimos o primeiro degrau vamos para o que equivale a 5V/1023 (5 Volts dividido pelos 1023 degraus restantes), que é aproximadamente igual à 0,00487V.
O número que o Arduino nos informa é do tipo inteiro, contudo, o valor de temperatura é um numero racional, que pode assumir valores decimais. Por conta disso, no nosso programa, declaramos a temperatura como uma float.
Em programação, quando multiplicamos uma variável inteira por uma variável racional, o programa considera que o resultado deve ser inteiro, eliminando a parte decimal da variável. Dessa forma, para que tenhamos um resultado racional, devemos transformar o número inteiro em um número racional.
Em virtude disso, em nosso código foi necessário colocar o comando de leitura do valor analógico, analogRead, dentro de float().
numeroracional = float(numero); temperatura = (float(analogRead(LM35))*5/(1023))/0.01;
Sempre que for necessário fazer um calculo com o valor analógico, precisamos convertê-lo para uma variável do tipo float.
Em alguns casos, precisamos transformar uma variável qualquer para o tipo inteiro. O procedimento é o mesmo, ou seja, basta colocar o valor ou variável dentro dos parenteses de int();
numerointeiro= int(numero); temperatura = int((float(analogRead(LM35))*5/(1023))/0.01);
Se usamos o int() no calculo de temperatura, tal como mostrado acima, teremos um resultado sem os números decimais. Faça o teste.
Desafios
- Tente retirar o comando float() do calculo de temperatura e veja o resultado. Provavelmente você terá o valor de temperatura igual a zero, descubra o motivo.
- Crie um alarme usando um buzzer e um LM35, explicado em nosso ultimo tutorial Usando buzzer com Arduino, Quando a temperatura estiver muito alta, o alarme deve disparar.
- Usando 3 ou mais LED's e um LM35, faça um programa que aumente o numero de LED's acesos conforme a temperatura seja maior.
Fechamento
Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.