Ola pessoal neste tutorial vamos aprender como ligar o sensor de nível de líquidos com uma bomba de água, com este projeto sera possível automatizar seu aquário, como por exemplo fazer com que a bomba desligue sozinha quando ele estiver cheio.
Primeiramente vamos entender como funciona o sensor de nível de líquidos Switch.
Dentro do sensor de líquidos Switch há um componente chamado Chave Reed Switch, que e composta por uma capsula de vidro preenchida por um gás inerte e dentro desta capsula há duas paletas metálicas que se tocam, quando aproximamos um imã, fazendo com que a corrente prossiga de um lado para o outro, quando retiramos o imã as paletas se abrem interrompendo a corrente. Resumindo a chave Switch funciona como um rele magnético. Veja os exemplo abaixo.
Seguindo a linha de raciocínio, o corpo do sensor de nível possui uma chave Switch dessa, já a boia possui um imã, e funciona exatamente como esta figura acima, quando a boia se movimenta o imã abre e fecha a chave.
O projeto que fiz é exatamente como esta figura acima, enquanto a boia esta baixa o rele recebe corrente, e como a conexão e feita em NO (normalmente aberto) faz com que a bomba permaneça ligada, já quando a boia sobe a corrente que alimenta o rele e desligada, fazendo com que a bomba desligue.
Este é o "projetinho" que fiz, só que usando uma bomba de 5v.
Vamos agora as etapas com a mini bomba .
Você vai precisar de ;
-1X fonte de celular de 5v.
-1x Modulo rele de 5v.
-1x mini bomba de 5v.
-2x borrachinas (usei sonda de aspiração n°14) acha em casa de produtos hospitalares
-fios
Esquema de conexão
As linhas vermelhas representam a parte positivas e as pretas as negativas ....
Ola pessoal neste projeto estaremos aprendendo como controla um micro servo utilizando um modulo Joystick aquele mesmo que tem nos controles de vídeo games, o interessante deste projeto e que ele pode ser aplicado em diversos outros projetos, como controle de carrinhos , na movimentação de câmeras de segurança dentre muitos outros , lembrando que o micro servo só e capaz de fazer giros de até 180°. Para este projeto só estaremos usando apenas o eixo X do Joystick.
Vamos agora as etapas de integração do Joystick com o Arduíno e micro servo.
Você vai precisar de ;
-1x arduino
-1x modulo Joystick
1x micro servo
-5x fios jumpers macho x macho
-3x fios jumpers macho x fêmea
Esquema de conexão;
Esquema de conexão Joystick;
Esquema de conexão micro servo;
Copie o código fonte abaixo para seu Arduíno.
//-----------------------------------------Inicio do código-------------------------------------//
/* Conexoes
Eixo X liga na entrada analogica A0 do arduino
Servo motor liga na entrada digital 3 do arduino
*/
#include <Servo.h>
Servo motor;
//----------Var de armazenamento joystich---------------//
int EixoX = 0; // Eixo X
void setup()
{
motor.attach(3); // determina que pino digital 3 para servo motor
Serial.begin(9600);
}
void loop()
{
//Le o valor do potenciometro ligado à porta analogica A0 - Eixo X
EixoX = analogRead(0);
//Mostra o valor do eixo X no serial monitor
Serial.print("X:");
Serial.print(EixoX , DEC);
//Testa o valor do Eixo Y e aciona o lado correspondente
if (EixoX > -1 & EixoX <200)
{
motor.write(0); ////Alavanca para direita move o motor para direita
}
if (EixoX > 300 & EixoX <600)
{
motor.write(90); ////Alavanca para o centro move o motor para o centro
}
if (EixoX > 800 & EixoX <1200)
{
motor.write(180);//Alavanca para esquerda move o motor para a esquerda
}
delay(50);
}
//-----------------------------------------Fim do código-------------------------------------//
Ola pessoal neste próximo projeto iremos controlar um modulo rele de quatro canais com uma manete(modulo Joystick) , aquela mesma que tem nos vídeo games como xbox e playstation, o funcionamento se da pela seguinte maneira, toda vez que a manete e posicionada para um dos lados um dos rele e acionado e quando ela pressionada para baixo os quatro reles ligam simultaneamente. sem mais vamos ao projeto.
Vamos agora as etapas de integração do Joystick com o Arduíno.
Você vai precisar de ;
-1x arduino
-1x modulo Joystick
-11x fios jumpers
1x modulo rele 4 canais
Esquema de conexão;
Esquema de conexão Joystick;
Esquema de conexão Modulo rele;
Copie o código fonte abaixo para seu Arduíno.
//-----------------------------------------Inicio do código-------------------------------------//
/* Conexões
Eixo X liga na entrada analogica A0 do arduino
Eixo Y liga na entrada analogica A1 do arduino
Botao sw liga na entrada analogica A2 do arduino
*/
//----------Var de armazenamento joystich---------------//
int EixoX = 0; // Eixo X
int EixoY = 0; // Eixo Y
int BotaoZ = 0; // Botao Z Var armazenamento
//-------------Var LED---------------//
int esquerda = 2; //Pino rele2
int superior = 3; //Pino rele4
int direita = 4; //Pino rele1
int inferior = 5; //Pino rele3
int todos = 6; //Pino liga todos os reles
void setup()
{
Serial.begin(9600);
pinMode(esquerda,OUTPUT);
pinMode(superior,OUTPUT);
pinMode(direita,OUTPUT);
pinMode(inferior,OUTPUT);
pinMode(todos,OUTPUT);
}
void loop()
{
//As linhas abaixo apagam todos os leds
digitalWrite(esquerda,HIGH);
digitalWrite(superior,HIGH);
digitalWrite(direita,HIGH);
digitalWrite(inferior,HIGH);
digitalWrite(todos,HIGH);
//Le o valor do potenciometro ligado à porta analogica A0 - Eixo X
EixoX = analogRead(0);
//Mostra o valor do eixo X no serial monitor
Serial.print("X:");
Serial.print(EixoX , DEC);
//Testa o valor do Eixo X e aciona o led correspondente
if ( EixoX > -1 & EixoX <200)
{
digitalWrite(inferior, LOW); ////Alavanca para inferior acende o rele3
}
if ( EixoX >600 & EixoX <1025)
{
digitalWrite(superior, LOW); ////Alavanca posicionada para superior acende o rele4
}
//Le o valor do potenciometro ligado à porta analogica A1 - Eixo Y
EixoY= analogRead(1);
//Mostra o valor do eixo Y no serial monitor
Serial.print(" | Y:");
Serial.print(EixoY, DEC);
//Testa o valor do Eixo Y e aciona o led correspondente
if (EixoY > 20 & EixoY <200)
{
digitalWrite(direita, LOW); ////Alavanca para direita acende o rele1
}
if (EixoY > 600 & EixoY <1025)
{
digitalWrite(esquerda, LOW); //Alavanca para esquerda acende o rele2
}
//Le o valor do Botao ligado à porta analogica A2 - Eixo Y
BotaoZ= analogRead(2);
//Mostra o valor do Eixo Z no serial monitor
Serial.print(" | Z: ");
Serial.println(BotaoZ, DEC);
//Caso o botão Z seja pressionado, liga todos os reles
if (BotaoZ <10 )
{
digitalWrite(todos, LOW);
digitalWrite(esquerda,LOW);
digitalWrite(superior,LOW);
digitalWrite(direita ,LOW);
digitalWrite(inferior ,LOW);
digitalWrite(todos ,LOW);
}
delay(50);
}
//-----------------------------------------Fim do código-------------------------------------//
Ola pessoal neste post iremos abordar todo o processo de conexões ao código fonte, para elaborar um sistema de segurança utilizando Arduíno sensor PIR(presença), LED e um Buzzer(mini auto falante) .
O sensor PIR possui ajustes de tempo e distancia, verifique na imagem abaixo.
Neste simples projeto, utilizaremos um Sensor PIR que ao detectar qualquer movimento humano ou animal acionara uma campainha e um LED.
Com este mesmo projeto você poderá acionar lampadas, fechaduras eletrônica ou varias outras coisas, para isso basta substituir o Buzzer ou o LED por um Modulo rele, e fazer as devidas conexões do rele. Sem mais vamos ao passo a passo.
Para este projeto iremos precisar de
1x Arduíno.
1x Modulo sensor de presença PIR.
1x Protoboard.
1xBuzzer.
1x LED.
4x fios jumpers macho x macho.
3x fios jumpers macho x femea.
Montagem;
Sensor PIR
Buzzer
LED
Apos realizar as conexõescopie o código fonte abaixo para seu Arduíno.
//-----------------------------------------Inicio do código-------------------------------------//
//Declaração das variáveis dos pinos digitais.
int pinBuzzer = 7;
int pinSensorPIR = 8;
int pinLed = 9;
int valorSensorPIR = 0;
void setup() {
Serial.begin(9600); //serial monitor
// Pinos como de entrada e de saída
pinMode(pinBuzzer,OUTPUT);
pinMode(pinSensorPIR,INPUT);
pinMode(pinLed,OUTPUT);
}
void loop() {
// Leitura do valor do sensor que pode ser 1 quando detecta movimento e 0 quando não detecta movimento.
valorSensorPIR = digitalRead(pinSensorPIR);
Serial.print("Leitura do Sensor PIR: "); //Mostra a leitura do sensor PIR na Serial.
Serial.println(valorSensorPIR);
//Se ocorrer movimentos o alarme sera ligado.
if (valorSensorPIR == 1) {
ligarAlarme();
} else {
desligarAlarme();
}
}
void ligarAlarme() { //Metodo para ligar alarme
//Ligando o led
digitalWrite(pinLed, HIGH);
tone(pinBuzzer,500);
delay(100);
tone(pinBuzzer,800);
delay(100);
tone(pinBuzzer,1000);
delay(100);
tone(pinBuzzer,1200);
//Ligando o buzzer com uma frequencia d;
delay(5000); //tempo que o led fica acesso e o buzzer toca
desligarAlarme(); //Metodo para desligar alarme
}
void desligarAlarme() {
//Desligando o led
digitalWrite(pinLed, LOW);
//Desligando o buzzer
noTone(pinBuzzer);
}
//-----------------------------------------Fim do código-------------------------------------//
Ola pessoal neste novo projeto estarei mostrando como fazer uma mini estação meteorológica utilizando Arduíno, LCD, sensor de chuva e um termômetro com higrômetro. O projeto e bem simples e com custo relativamente baixo podendo ser aperfeiçoado futuramente se adicionando alarmes e outras coisas mais. Vamos ver abaixo a relação de peças que vai precisar.
Para este projeto iremos precisar de
1x Arduíno.
1x LCD com modulo I2C (para quem não conhece o modulo I2C acesse este LINK).
1x Protoboard.
1x Sensor de chuva(com saída digital).
1x Sensor de temperatura e umidade DHT11.
2x fios jumpers macho x macho.
10x fios jumpers macho x femea.
Sera necessário utilizar a Biblioteca I2C .
Baixar Biblioteca I2C .
Descompacte com winzip e copia para pasta libraries dentro da pasta arduino.
Abaixo esta o esquema em planilha das conexões de modulo por modulo conecte exatamente como mostrado.
Conexões do Modulo I2C do LCD com Arduíno;
Conexões do Sensor de temperatura com Arduíno;
Conexões do Sensor de Chuva com Arduíno;
Apos realizar as conexõescopie o código fonte abaixo para seu Arduíno.
aqui
//-----------------------------------------Inicio do código-------------------------------------//
#include <Wire.h>
#include <LiquidCrystal_I2C.h> //Biblioteca I2C
LiquidCrystal_I2C lcd(0x27,16,2); // Seta o endereco do display 0x27, para 16 caracteres e 2 linhas o display
#include <dht.h>
#define dht_dpin A0 //Pino DATA do Sensor ligado na porta Analogica A1
dht DHT; //Inicializa o sensor
int SensorChuva = 7;
int ArmazenaChuva = 0;
void setup()
{
lcd.init(); // Inicializa o LCD.
lcd.backlight();
Serial.begin(9600);
// delay(1000);//Aguarda 1 seg antes de acessar as informações do sensor
pinMode(SensorChuva,INPUT);
}
void loop()
{
ArmazenaChuva = digitalRead(SensorChuva);
if (ArmazenaChuva == LOW){
lcd.clear();
lcd.print("Esta chovendo");
lcd.setCursor(0,1);
lcd.print("neste momento");
delay(3000); }
else {
lcd.clear();
lcd.print("Sem chuva");
lcd.setCursor(0,1);
lcd.print("neste momento");
delay(3000);
}
DHT.read11(dht_dpin); //Lê as informações do sensor
lcd.clear();
lcd.print("Umidade:");
lcd.print(DHT.humidity);
lcd.println("% ");
lcd.setCursor(0,1);
lcd.print("Temperat:");
lcd.print(DHT.temperature);
lcd.println("C ");
delay(3000); //Não diminuir muito este valor. O ideal é a leitura a cada 2 segundos
}
//----------------------------------------Fim do código-------------------------------------//
Ola pessoal neste próximo projeto estaremos mostrando como acionar um modulo rele com 4 canais utilizando um teclado matricial ou Matrix, que e aquele teclado tipo membrana fininho que pode ser colado em uma superfície lisa. Por se tratar de um projeto que utiliza reles, sera possível utiliza-lo em uma ampla gama de projetos que utilizam alta tensão (110v)ou(220v) ,como acionamento de motores lampadas, ventiladores etc..
OBS: caso utilize alta tensão tome cuidado para não tomar choques elétricos pois pode ser perigoso. E sempre bom contactar um eletricista nestes casos.
Vamos agora as etapas de integração do teclado com o Arduíno.
Primeiramente terá de baixar a biblioteca Keypad que é onde estão os arquivos necessários para seu funcionamento Biblioteca Keypad .
Apos baixar,descompacte o arquivo ZIP e copie para pasta libraires que esta dentro da pasta Arduíno em Arquivos e programas.
Para este projeto iremos precisar de
1x arduino.
1x teclado matrix com 16 teclas.
1x Modulo Rele 4 canais.(pode ser usado também reles de 1 ou 2 canais para isso basta usar uma protoboard para alimenta-los)
8x fios jumpers macho x macho.
6x fios jumpers macho x femea.
Conexões do teclado com Arduíno;
Conexões do Rele com Arduíno;
O teclado terá os seguintes comandos;
Tecla 1 -> liga 1° rele.
Tecla 2 -> liga 2° rele.
Tecla 3 -> liga 3° rele.
Tecla 4 -> liga 4° rele.
Tecla 5 -> desliga 1° rele.
Tecla 6 -> desliga 2° rele.
Tecla 7 -> desliga 3° rele.
Tecla 8 -> desliga 4° rele.
Tecla (*) -> liga todos os reles.
Tecla (#) -> desliga todos os reles.
Veja o vídeo.
Copie o código fonte abaixo para seu Arduíno.
//-----------------------------------------Inicio do código-------------------------------------//
#include <Keypad.h> // Biblioteca Keypad.
const byte ROWS = 4; // Definição das linhas .
const byte COLS = 4; // Definição das colunas.
// Define o Keypad (mapa do teclado).
char keys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
// Conecta o teclado matricial em linha 0, linha 1, linha 2, linha 3 e linha 4 dos pinos do arduino.
byte rowPins[ROWS] = { 9, 8, 7, 6 };
// Conecta o teclado matricial em coluna 0, coluna 1, coluna 2, coluna 3 e coluna 4 do arduino.
byte colPins[COLS] = { 5,4,3,2 };
// Cria um objto Keypad.
Keypad kpd = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
//-------------Variaveis dos reles-------------//
#define Rele1 10
#define Rele2 11
#define Rele3 12
#define Rele4 13
void setup()
{
//---------Define rele como saida-----------------//
pinMode(Rele1,OUTPUT);
pinMode(Rele2,OUTPUT);
pinMode(Rele3,OUTPUT);
pinMode(Rele4,OUTPUT);
// Define o pino 13 como sendo de saída.
//digitalWrite(Rele1, HIGH); // incializa com o led ligado.
Serial.begin(9600); // Inicia o Serial Monitor.
}
void loop()
{
char key = kpd.getKey();
if(key) // CVerifica se um botão foi precionado.
{
switch (key)
{
case '1': // Caso seja precionado botao 1.
digitalWrite(Rele1, HIGH); // o rele 1 liga.
break; // Parada, aguardando precionar outro botão.
case '2':
digitalWrite(Rele2, HIGH);
break;
case '3':
digitalWrite(Rele3, HIGH);
break;
case '4':
digitalWrite(Rele4, HIGH);
break;
case '5':
digitalWrite(Rele1, LOW);
break;
case '6':
digitalWrite(Rele2, LOW);
break;
case '7':
digitalWrite(Rele3, LOW);
break;
case '8':
digitalWrite(Rele4, LOW);
break;
//------Se (*) for pressionado desliga os 4 reles---//
case '*':
digitalWrite(Rele1, HIGH);
digitalWrite(Rele2, HIGH);
digitalWrite(Rele3, HIGH);
digitalWrite(Rele4, HIGH);
break;
//------Se (#) for pressionado liga os 4 reles---//
case '#':
digitalWrite(Rele1, LOW);
digitalWrite(Rele2, LOW);
digitalWrite(Rele3, LOW);
digitalWrite(Rele4, LOW);
break;
default:
Serial.println(key);
}
}
}
//-----------------------------------------Fim do código-------------------------------------//
