Archive for the ‘Sensores’ Category

Sensor de Vibração Alarme de Vibração

20 ABR
2016

Author: Leonardo Dalla Porta

Pra que serve um Sensor de Vibração?

Geralmente é muito difícil de se identificar um sensor de vibração, eles são pequenos, aplicados com bastante frequência em áreas industriais, para controle de vibração de motores elétricos ou de eixos, entre outros. Um sensor de Vibração obviamente detecta essas oscilações no seu ambiente e envia para o controlador efetuar alguma ação, seja de desativar um motor ou como é o nosso caso apenas gerar um BIP, para informar o usuário de tal fato.

Esta Experiência é muito simples, utilizando um Arduíno o sensor e um Buzzer, lemos a entrada analógica vindo do sensor e convertemos isso para bips, dependendo o nível de vibração, será  a quantidade e continuidade dos Bips.

 

 

 

Você vai precisar de:

  • Módulo Sensor de Vibração
  • Arduino Uno ou similar
  • Buzzer
  • Jumpers
  • Protoboard (Dependendo de seus jumpers)

 

 

 

Ligações:

A ligação do sensor é muito simples, o sensor possui 3 pinos, dos quais da esquerda para a direita são: GND, OUT, VCC. Destes o GND vai ligado ao GND do Arduino, o OUT, na entrada analógica A0 do Arduino, o VCC é ligado ao 5V simplesmente. O buzzer é conectado ao pino 11, lembrando novamente que o buzzer precisa ser com oscilador interno (Só alimenta-lo).

 

 

 

O Código:

O código assim como ja mencionado anteriormente apenas efetua a leitura da porta analógica A0 e Larga pulsos para o Buzzer na porta digital 11 do Arduino. Basta copiar e colar na sua IDE e compilar!

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//**************************************//
//**********Vibracao.INO****************//
//**********Nadiel Comércio*************//
//**Faça um bom uso desde que mantenha**//
//*seu autor e sua fonte!***************//
//*Atenciosamente: Leonardo Dalla Porta*//
//*************07/01/2016***************//
//**************************************//
int var;
 
void setup()
{
pinMode(11, OUTPUT);
}
 
void loop()
{
if(analogRead(A0)<400) { var++; if(var>1000)
  {
    var=0;
    digitalWrite(11, HIGH);
    delay(200);
  }
}
else
{
  digitalWrite(11, LOW);
}
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor PIR no arduino

01 ABR
2016

Author: Leonardo Dalla Porta

Neste tutorial você verá como conectar um Sensor PIR no arduino de forma muito simples, além disso você aprenderá a montar um alarme temporizado utilizando o arduino!

Você vai precisar de:

  • Sensor PIR
  • Arduino UNO
  • Jumpers
  • Protoboard
  • Led
  • Resistor

Ligaçoes:

A fiação é bastante simples, o sensor PIR tem impresso: o + e o – e o sinal. Caso haja duvidas segue a imagem para auxilia-lo:

Imagem de Setup

Código

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/* 
 * //////////////////////////////////////////////////
 * //making sense of the Parallax PIR sensor's output
 * //////////////////////////////////////////////////
 *
 * Switches a LED according to the state of the sensors output pin.
 * Determines the beginning and end of continuous motion sequences.
 *
 * @author: Kristian Gohlke / krigoo (_) gmail (_) com / http://krx.at
 * @date:   3. September 2006 
 *
 * kr1 (cleft) 2006 
 * released under a creative commons "Attribution-NonCommercial-ShareAlike 2.0" license
 * http://creativecommons.org/licenses/by-nc-sa/2.0/de/
 *
 *
 * The Parallax PIR Sensor is an easy to use digital infrared motion sensor module. 
 * (http://www.parallax.com/detail.asp?product_id=555-28027)
 *
 * The sensor's output pin goes to HIGH if motion is present.
 * However, even if motion is present it goes to LOW from time to time, 
 * which might give the impression no motion is present. 
 * This program deals with this issue by ignoring LOW-phases shorter than a given time, 
 * assuming continuous motion is present during these phases.
 *  
 */
 
/////////////////////////////
//VARS
//the time we give the sensor to calibrate (10-60 secs according to the datasheet)
int calibrationTime = 30;        
 
//the time when the sensor outputs a low impulse
long unsigned int lowIn;         
 
//the amount of milliseconds the sensor has to be low 
//before we assume all motion has stopped
long unsigned int pause = 5000;  
 
boolean lockLow = true;
boolean takeLowTime;  
 
int pirPin = 7;    //the digital pin connected to the PIR sensor's output
int ledPin = 8;
 
 
/////////////////////////////
//SETUP
void setup(){
  Serial.begin(9600);
  pinMode(pirPin, INPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(pirPin, LOW);
 
  //give the sensor some time to calibrate
  Serial.print("calibrating sensor ");
    for(int i = 0; i < calibrationTime; i++){ Serial.print("."); delay(1000); } Serial.println(" done"); Serial.println("SENSOR ACTIVE"); delay(50); } //////////////////////////// //LOOP void loop(){ if(digitalRead(pirPin) == HIGH){ digitalWrite(ledPin, HIGH); //the led visualizes the sensors output pin state if(lockLow){ //makes sure we wait for a transition to LOW before any further output is made: lockLow = false; Serial.println("---"); Serial.print("motion detected at "); Serial.print(millis()/1000); Serial.println(" sec"); delay(50); } takeLowTime = true; } if(digitalRead(pirPin) == LOW){ digitalWrite(ledPin, LOW); //the led visualizes the sensors output pin state if(takeLowTime){ lowIn = millis(); //save the time of the transition from high to LOW takeLowTime = false; //make sure this is only done at the start of a LOW phase } //if the sensor is low for more than the given pause, //we assume that no more motion is going to happen if(!lockLow && millis() - lowIn > pause){  
           //makes sure this block of code is only executed again after 
           //a new motion sequence has been detected
           lockLow = true;                        
           Serial.print("motion ended at ");      //output
           Serial.print((millis() - pause)/1000);
           Serial.println(" sec");
           delay(50);
           }
       }
  }

Você pode ver a partir do código, o sensor regula-se primeiro e depois relógios para o movimento. Quando se detecta o movimento, a luz azul acende-se. Você pode assistir no monitor serial para ver quanto tempo dura o movimento.

Imagem de Código

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor magnético A3144 – Sensor Hall

09 FEV
2016

Author: Leonardo Dalla Porta

 Sensor Magnético de efeito Hall

Mais conhecido como Sensor Hall, tem como principio transformar um campo magnético, em um sinal elétrico, assim podendo aplicar em diversos equipamentos de automação e desenvolvimento de sistemas.

 

Um Semicondutor?

Ele é um semicondutor, semelhante a um Transistor a imagem a seguir mostra de forma ilustrada como é o esquema interior do Sensor Hall A3144:

A3144_Hall-Effect-Sensor_Pin-Out_Symbol-Diagram

 

 

Você precisa apenas de:

  • Um Sensor Magnético A3144 (Sensor Hall)
  • Um Resistor de 10K (Para Pull UP)
  • Arduino Uno ou Equivalente
  • Protoboard
  • Jumpers

 

 

Ligações:

 

Na Imagem a seguir você pode ver a ligação do sensor junto ao resistor, onde o pino OUT é conectado ao A0 do arduino e simplesmente conectamos o arduino ao computador:

images

 

Código

Este Código está disponível também no site do Arduino (Arduino.cc), ele simplesmente mostra qual a polaridade do Imã o qual aproximado do sensor, para isso basta fazer Upload do código e abrir o monitor serial:

/*

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 *    FILE: MM01
 *  AUTHOR: Rob van den Tillaart; modified Ralph Martin
 *    DATE: 2012 06 10 
 *     ORIGINAL URL: http://playground.arduino.cc/Code/HallEffect
 *
 * PURPOSE: use an A1301 or A1302 as magnetometer   
 *
 * Pin Layout LH Package
 * =====================
 *  1     VCC 5V
 *  2     signal    connected to Analog 0    
 *  3     GND
 *
 * Pin Layout UA Package
 * =====================
 *  1     VCC 5V
 *  2     GND
 *  3     signal    connected to Analog 0    
 *
 */
 
#define NOFIELD 505L    // Analog output with no applied field, calibrate this
 
// Uncomment one of the lines below according to device in use A1301 or A1302
// This is used to convert the analog voltage reading to milliGauss
#define TOMILLIGAUSS 1953L  // For A1301: 2.5mV = 1Gauss, and 1024 analog steps = 5V, so 1 step = 1953mG
// #define TOMILLIGAUSS 3756L  // For A1302: 1.3mV = 1Gauss, and 1024 analog steps = 5V, so 1 step = 3756mG
 
void setup() 
{
  Serial.begin(9600);
}
 
void DoMeasurement()
{
// measure magnetic field
  int raw = analogRead(0);   // Range : 0..1024
 
//  Uncomment this to get a raw reading for calibration of no-field point
//  Serial.print("Raw reading: ");
//  Serial.println(raw);
 
  long compensated = raw - NOFIELD;                 // adjust relative to no applied field 
  long gauss = compensated * TOMILLIGAUSS / 1000;   // adjust scale to Gauss
 
  Serial.print(gauss);
  Serial.print(" Gauss ");
 
  if (gauss > 0)     Serial.println("(South pole)");
  else if(gauss < 0) Serial.println("(North pole)");
  else               Serial.println();
}
 
void loop() 
{
    delay(1000);
    DoMeasurement();
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor de chama infravermelho no Arduino

15 OUT
2015

Author: Leonardo Dalla Porta

 

Neste tutorial você vai ver como funciona, e como utilizar o sensor de chama utilizando um Arduino, dessa forma você poderá detectar chamas e acionar alarmes de incêndio entre outros.

Materiais necessários:

  • Sensor de Chama (modelo com uma saída analógica)
  • Jumpers
  • Um Arduino
  • Isqueiro ou outra fonte de chama para o teste.

Conhecendo o seu sensor de chama:

Imagem de Conhecer o seu sensor de chama:

Uso:
Estes tipos de sensores são usados ​​para a detecção de curto alcance fogo e pode ser usado para monitorar projetos ou como uma precaução de segurança para cortar dispositivos on / off.

Alcance:

Aproximadamente uns 3 metros

Como funciona:

O sensor de chama é muito sensível ao comprimento de onda IR a 760 nm ~ 1100 nm de luz.

Saída analógica (A0): sinal de tensão de saída em tempo real sobre a resistência térmica.

A saída digital (D0): Quando a temperatura atinge um determinado limiar, a saída elevada e baixo sinal de limiar ajustável através do potenciómetro.

Pinos:

VCC …… entrada positiva de tensão: 3.3v 5v para analógico para digital.

Saída analógica A0 ……….

D0 ……… saída Digital

GND terra …..

Dimensões:

1,18 em x 0,59 em x 0,20 na (3,0 cm x 1,5 cm x 0,5 cm)

Peso:

0,28 oz (8 g)

Teste e solução de problemas:

Imagem de Teste e solução de problemas:

Teste:
Para testar o sensor de chama e garantir que ele está funcionando corretamente ligar o VCC de uma fonte de alimentação 5v e GND. Mover uma fonte de chama com um pé da frente do sensor IR e o LED deve acender.

Solução de problemas:

Se o LED não se acender, verifique o seguinte:

  • É a fonte de alimentação 5v?
  • É a terra ligado?
  • É a chama com um em pé e na linha de visão?

Se nenhuma das opções anteriores faz com que a luz LED D0-up, o sensor pode estar com defeito.

Fiação para o Arduino:

Para conectar o sensor de chama para o Arduino basta conectar o seguinte, como mostrado:

Sensor de chama …………… Arduino

VCC …………………………. 5v

GND GND ………………………….

A0 ……………………………. Analog em 0

Código

Os seguintes mapas de código e lê os valores analógicos dadas pelo sensor de chama (0-1024). O sensor da chama terá a seguinte reação com este código:

  • Se segurando uma chama dentro de 1,5 metros na frente do sensor; “caso 0” será ativada e “** ** Fim Fogo” será enviado para o monitor serial.
  • Se segurando uma chama entre 1,5 pés e 3 metros em frente do sensor; “Caso 1” será ativada e “** ** Fogo Distante” será enviado para o monitor serial.
  • Se for detectada nenhuma chama em frente do sensor; “case 2” será ativada e “No Fire” será enviado para o monitor serial.

* Para visualizar a saída, apontar um monitor serial como Putty em seu Arduino.

* Este código é actualizar constantemente a fim de proporcionar um feedback do sensor de chama em tempo real.

Código: Download aqui

Acelerômetro Gy-521 no arduino

14 OUT
2015

Author: Leonardo Dalla Porta

Eu vou mostrar para você hoje como podemos usar o acelerômetro GY-521 com o Arduino mega 2560 para obter as leituras do sensor.

 

Você vai precisar de:

  • Arduino
  • Acelerômetro GY-521
  • Jumpers
  • Protoboard

 

 

O sensor acelerômetro GY-521 contém um acelerômetro MEMS e um giroscópio MEMS em um único chip. Ele é muito preciso, pois ele contém 16-bits analógico para hardware conversão digital para cada canal. Pelo que capta a x, y, e z de canal ao mesmo tempo.

– Chip: MPU-6050
– Fonte de alimentação: 3.5V (Mas como há um regulador de tensão na placa, você pode usar 5V diretamente)
– Modo de comunicação: protocolo de comunicação padrão IIC, I2C.
– Chip conversor embutido 16bit AD, os dados 16bit saída
– giroscópios variam: +/- 250 500 1000 2000 graus / seg
– gama de Aceleração: +/- 2g, 4g +/-, +/- 8 g, +/- 16g

 

Conexões

  • GY-521 Arduino mega
  • VCC 3,3V ou 5V
  • GND GND
  • SCL Pin0 21 (SCL) Pino Arduino Uno: A5
  • SDA Pin0 20 (SDA) Pino Arduino Uno: A4
  • INT Pin 2 (Interrupção 0)5

Agora para o programa. Como temos uma grande quantidade de recursos sobre o uso do Arduino, vamos tentar o código a partir deles.

Primeiro vamos tentar descobrir se nosso dispositivo está conectado com o Arduino. Para isso, pode utilizar o código Scanner I2C por “Krodal” para descobrir os dispositivos conectados I2C para Arduino.

Compilar o código e enviá-lo para Arduino. Abra o monitor serial e fazer upload para o Arduino.

Download

Ele vai encontrar o seu GY-521 no endereço 0x68 ou 0x69. Se ele não encontrar o IMU nesse local, pode haver um problema com sua fiação. Por favor, verifique novamente.

Agora, podemos utilizar o seguinte código de Krodal para obter os resultados brutos do sensor. O esboço de Krodal podem ser encontradas aqui. Por favor, vá até o final da página e você vai ser capaz de encontrar o código. Também eu estarei postando aqui.

Download

A saída deve ser semelhante a essa:

8

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Sensor de temperatura e umidade DHT11 no arduino

13 OUT
2015

Author: Leonardo Dalla Porta

O DHT11 é um ótimo sensor pois é calibrado em laboratório, sua medição é precisa e estável e a sua saída de sinal é digital. O mais importante de tudo, é relativamente barato para o desempenho dado. Ele é um sensor pequeno e não necessita de muitos componentes para funcionar perfeitamente.

 

Pinos

 

 Pino Nome Descrição
 1  VDD  Fonte de alimentação 3-5,5 V DC
 2  DADOS  Saída de dados seriais
 3  NC  Não conectado
 4  GND  Chão

Ligações

Conecte o sensor ao seu Arduino assim como descrevemos abaixo:

 DHT11  Arduino
 Pin 1  Vcc
 Pin 2  Analog0
 Pin 4  Gnd


Instalar a biblioteca DHT11:

Baixe este arquivo e descompacte no diretório de bibliotecas da pasta Arduino IDE. Após isso, navegue até os exemplos e procure pelos exemplos do DHT11. Feito isso, basta clicar em Upload.

    

                                                                  

  Saída no monitor Serial

No monitor serial teremos algo como:

Sensor de toque Humano

12 OUT
2015

Author: Leonardo Dalla Porta

Este dispositivo usa o seu corpo como parte do circuito. Quando você toca o teclado de sensor, a capacitância do circuito é alterado e é detectado. Essa mudança detectada em resultados de capacitância nos estados de saída em mudança.

 

Conecte o sensor de toque

Este é um real simples configurar. Você vai saber que você tem o poder corretamente aplicada quando o LED verde está aceso.

Arduino Tutorial de sensor de toque capacitivoO Código

O código abaixo fornece uma saída para o seu monitor serial indicando se o sensor está pressionado, ou não.


 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Henry's Bench
// Capacitive Touch Sensor Tutorial
 
// When Sig Output is high, touch sensor is being pressed
#define ctsPin 2 // Pin for capactitive touch sensor
 
int ledPin = 13; // pin for the LED
 
void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);  
  pinMode(ctsPin, INPUT);
}
 
void loop() {
  int ctsValue = digitalRead(ctsPin);
  if (ctsValue == HIGH){
    digitalWrite(ledPin, HIGH);
    Serial.println("TOUCHED");
  }
  else{
    digitalWrite(ledPin,LOW);
    Serial.println("not touched");
  } 
  delay(500);
 
}

Teste

Uma vez que você enviou o esboço, abra o monitor serial. Toque no sensor de almofada enquanto olha para o monitor. Você deverá ver uma saída que é algo como a imagem abaixo.

Arduino Tutorial de sensor de toque capacitivo de saída

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor de Umidade do solo

12 OUT
2015

Author: Leonardo Dalla Porta

Neste tutorial vamos mostrar-lhe como conectar a um Arduino Nano e um sensor de umidade. A informação será exibida com 5 LEDs, conforme for a umidade da terra no sensor, mais leds serão acendidos, caso contrario, eles apagarão.

 

Você vai precisar de:

  • 1 – Protoboard
  • 5 – LEDs
  • 5 – Resistores 1k 
  • Sensor de umidade do solo
  • Arduino
  • Jumpers

Conexões

A0 – Vai conectado ao sensor de umidade do solo
D2: D6 – LEDS 1,2,3,4,5

LED1 – Verde
LED2 – Verde
LED3 – Verde
LED4 – Amarelo
LED5 – Vermelho

Após todos os fios conectados, vamos ao nosso código, ele é muito simples, apenas comparamos valores de condições com o valor lido do sensor e acendemos leds, você pode incrementar este código com diversas outras tarefas

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
int LED1 = 2;
LED2 int = 3;
LED3 int = 4;
int LED4 = 5;
int LED5 = 6;
 
int mostureSensor = 0;
 
void setup () {
// Serial Comece para que possamos ver os dados do sensor mosture na nossa janela de entrada serial.
Serial.begin (9600);
// Definindo os pinos conduzidos às saídas
pinMode (LED1, OUTPUT);
pinMode (LED2, OUTPUT);
pinMode (LED3, OUTPUT);
pinMode (LED4, OUTPUT);
pinMode (LED5, OUTPUT);
}
 
// A rotina de loop é executado uma e outra vez para sempre:
void loop () {
// Ler a entrada no pino analógico 0:
int SensorValue = analogRead (mostureSensor);
// Imprimir o valor que você lê:
 
Serial.println (SensorValue);
 
if (SensorValue> = 820)
{
digitalWrite (LED1, HIGH);
digitalWrite (LED2, HIGH);
digitalWrite (LED3, HIGH);
digitalWrite (LED4, HIGH);
digitalWrite (LED5, LOW);
}
else if (SensorValue> = 615 && SensorValue <820) { digitalWrite (LED1, HIGH); digitalWrite (LED2, HIGH); digitalWrite (LED3, HIGH); digitalWrite (LED4, LOW); digitalWrite (LED5, LOW); } else if (SensorValue> = 410 && SensorValue <615) { digitalWrite (LED1, HIGH); digitalWrite (LED2, HIGH); digitalWrite (LED3, LOW); digitalWrite (LED4, LOW); digitalWrite (LED5, LOW); } else if (SensorValue> = 250 && SensorValue <410) { digitalWrite (LED1, HIGH); digitalWrite (LED2, LOW); digitalWrite (LED3, LOW); digitalWrite (LED4, LOW); digitalWrite (LED5, LOW); } else if (SensorValue> = 0 && SensorValue <250)
{
digitalWrite (LED1, LOW);
digitalWrite (LED2, LOW);
digitalWrite (LED3, LOW);
digitalWrite (LED4, LOW);
digitalWrite (LED5, LOW);
}
atraso (1000); // Atraso de 1 segundo entre lê
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

 

 

Sensor Magnetômetro, Bússola Hmc5883l

10 OUT
2015

Author: Leonardo Dalla Porta

O sensor Magnetômetro HMC5883l é um dispositivo de alta sensibilidade e baixa eixo transversal é projetado para medir tanto a direção e a magnitude dos campos magnéticos da Terra, a partir de mili-gauss a 8 Gauss.

Como é que um magnetômetro? Como funciona?

Um magnetômetro eletrônico como o  HMC5883L  baseia-se na anisotrópica no fenômeno da Magnetorresistência.
Basicamente, a um campo magnético interage com o caminho da corrente que flui através de um material ferroso, de acordo com a Lei de  Lorentz, consequentemente, a resistência do material parece mudar para o observador. Você pode imaginar como se o bar de material ferroso (por exemplo InSb) cresce mais tempo, aumentando a sua resistência elétrica. Portanto, medindo a alteração na resistência pode-se estimar o campo magnética! A equação que governa o fenômeno é na imagem abaixo. Para uma investigação mais aprofundada da questão, especialmente na eletrônica um magnetômetro baseia-se:

Em uma bússola, o campo magnético se mede é a sua terra. É tangente à superfície do planeta e flui de norte a sul. O  HMC5883L  tem três eixos diferentes para calcular as posições, como você pode não saber a inclinação do dispositivo quando você precisar os dados! De qualquer forma para este exemplo, vamos supor que o sensor é plana sobre uma mesa, por isso não precisa se ​​preocupar com a sua inclinação. Portanto, vamos usar apenas eixos X e Y dados.

Vamos assumir Hz = 0

Após entender esta parte, neste link você pode fazer download da biblioteca para o sensor, as ligações são muito simples, pois este sensor é I2C, o que facilita muito na hora de por em pratica, além de ser possível utilizar mais dispositivos ligados juntos, em apenas duas portas de comunicação.

E aqui o Código:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
/*
HMC5883L_Example.ino - Example sketch for integration with an HMC5883L triple axis magnetometer.
 Copyright (C) 2013 BluLemonLabs (bluelemonlabs.blogspot.com)
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the version 3 GNU General Public License as
 published by the Free Software Foundation.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 */
 
// Reference the I2C Library
#include <Wire.h>
// Reference the HMC5883L Compass Library
#include <HMC5883L.h>
 
// Store our compass as an object.
HMC5883L compass;
 
// Record any errors that may occur in the compass.
int error = 0;
 
// Out setup routine, here we will configure the microcontroller and compass.
void setup()
{
  // Initialize the serial port.
  Serial.begin(9600);
 
  Serial.println("Starting the I2C interface.");
  Wire.begin(); // Start the I2C interface.
 
  Serial.println("Constructing new HMC5883L");
  compass = HMC5883L(); // Construct a new HMC5883 compass.
  //The implementation of the class is provided in the library
 
  // Now we have an istance of the class!
  //Let's initializate it...
 
  Serial.println("Setting scale to +/- 1.3 Ga");
  error = compass.SetScale(1.3); // Set the scale of the compass to 1.3Ga
  if(error != 0){ // If there is an error, print it out. 
    Serial.println(compass.GetErrorText(error));
    error =0;
  }
 
  Serial.println("Setting measurement mode to continous.");
  error = compass.SetMeasurementMode(Measurement_Continuous); // Set the measurement mode to Continuous
  if(error != 0) {// If there is an error, print it out.
    Serial.println(compass.GetErrorText(error)); //Todo: Error handling for this method in .h and .cpp
    error=0;
  }
}
 
// Our main program loop. 
void loop()
{
  // Retrieve the raw values from the magnetometer (not scaled).
  MagnetometerRaw raw = compass.ReadRawAxis();
  // Retrieve the scaled values from the magnetometer (scaled to the configured scale).
  MagnetometerScaled scaled = compass.ReadScaledAxis();
 
  // Values are accessed like so:
  int MilliGauss_OnThe_XAxis = scaled.XAxis;// (or YAxis, or ZAxis)
 
  // Calculate heading when the magnetometer is level, then correct for signs of axis.
  // Atan2() automatically check the correct formula taking care of the quadrant you are in
  float heading = atan2(scaled.YAxis, scaled.XAxis);
 
  // Once you have your heading, you must then add your 'Declination Angle',
  // which is the 'Error' of the magnetic field in your location. Mine is 0.0404 
  // Find yours here: http://www.magnetic-declination.com/
 
  // If you cannot find your Declination, comment out these two lines, your compass will be slightly off.
  float declinationAngle = 0.0404;
  heading += declinationAngle;
 
  // Correct for when signs are reversed.
  if(heading < 0)
    heading += 2*PI;
 
  // Check for wrap due to addition of declination.
  if(heading > 2*PI)
    heading -= 2*PI;
 
  // Convert radians to degrees for readability.
  float headingDegrees = heading * 180/M_PI; 
 
  // Output the data via the serial port.
  Output(raw, scaled, heading, headingDegrees);
 
  // By default the HMC5883L reads the data 15 time per second (15Hz)
  // However since we have a long serial out (104ms at 9600) we will let
  // it run at its natural speed.
  // delay(66);
}
 
// Output the data down the serial port.
void Output(MagnetometerRaw raw, MagnetometerScaled scaled, float heading, float headingDegrees)
{
  Serial.print("Raw:\t");
  Serial.print(raw.XAxis);
  Serial.print("   ");   
  Serial.print(raw.YAxis);
  Serial.print("   ");   
  Serial.print(raw.ZAxis);
  Serial.print("   \tScaled:\t");
 
  Serial.print(scaled.XAxis);
  Serial.print("   ");   
  Serial.print(scaled.YAxis);
  Serial.print("   ");   
  Serial.print(scaled.ZAxis);
 
  Serial.print("   \tHeading:\t");
  Serial.print(heading);
  Serial.print(" Radians   \t");
  Serial.print(headingDegrees);
  Serial.println(" Degrees   \t");
}
Na imagem abaixo você pode ver como o título medido com um iPhone 4 é bastante próximo ao que temos lido do Arduino. Existem muitos margem de melhoria.  Além disso, esta protoboard tem um plano de terra de alumínio na sua parte inferior, o que, obviamente, pode tornar mais difícil para a estrutura para detectar o campo magnético e / ou pode derivar-lo e criar um deslocamento.

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor Digital de Temperatura DS18B20

08 OUT
2015

Author: Leonardo Dalla Porta

Esta é uma nova versão do nosso 1-Wire tutorial sensor de temperatura digital, agora com mais sensores de temperatura! Veja como utilizar este maravilhoso sensor de forma muito simples utilizando um arduino. Lembrando que este sensor digital de temperatura pode ser utilizado com inúmeros outros sensores “OneWire”, este tipo de comunicação permite

Este tutorial irá mostrar-lhe como conectar o sensor de temperatura DS18B20 no seu arduino!

 

Código de software utilizado neste tutorial pode ser baixado aqui:

 

Exemplo Sensor de temperatura DS18B20

Biblioteca OneWire

Biblioteca DallasTemperatura

 

 

Hardware utilizado neste tutorial:

 

– DS18B20 Digital Sensor de temperatura

– 4.7k ohm (ou assim) resistor pullup

– Protoboard

– Alguns jumpers

– Placa Arduino (Uno, o Mega, Duemilanove, etc.)

 

Instruções:

 

Use a sua protoboard para fazer as conexões. Todos os sensores de temperatura pode ser DS18B20 ligado ao mesmo pino IO:

conexão DS18B20 arduino

 

* Você só precisa de um resistor 4.7k pullup para todos os dispositivos 1-fio ligado ao Arduino pino 3

** Veja a DS18B20 folha de dados para o diagrama de pinos, e tenha muito cuidado.

 

 

 

Você deve ver algo como:

 

sensor de temperatura DS18B20 arduino

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

 

Módulo Sensor de Chuva no Arduino

25 SET
2015

Author: Leonardo Dalla Porta

Neste tutorial mostraremos como conectar um Módulo Sensor de Chuva ao Arduino de forma muito simples e intuitiva, a partir disso você pode estar desenvolvendo coisas inacreditáveis! A criatividade é sua, e vamos ao tutorial!

 

Materiais necessários:

  • Sensor de chuva (modelo com uma saída analógica)
  • Jumpers
  • Um Arduino
  • Água

 

Conexões

 

  • Saída analógica A0 ……….
  • D0 ……… saída Digital
  • GND terra …..
  • VCC …… tensão positiva (entrada: 3.3v 5v para analógico para digital.)

 

Sensor-Sonda

  • + ………. Sensor placa de conexão A
  • – ……….. Conexão bordo Sensor B
Imagem de Conhecer o seu sensor de chuva:

Funcionamento

Os sensores de chuva são usados ​​na detecção de água além do que um sensor de umidade pode detectar. O sensor de chuva detecta água que completa os circuitos impressos em ligações de seus quadros de sensores. A placa do sensor age como um resistor variável que vai mudar a partir de 100k ohms quando molhado para 2M ohms quando seca. Em suma, quanto mais molhado bordo do mais atual que será conduzida.

 

 

Código

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/* Flame Sensor analog example.
Code by Reichenstein7 (thejamerson.com)
 
For use with a Rain Sensor with an analog out!
 
To test view the output, point a serial monitor such as Putty at your Arduino. 
 
  - If the Sensor Board is completely soaked; "case 0" will be activated and " Flood " will be sent to the serial monitor.
  - If the Sensor Board has water droplets on it; "case 1" will be activated and " Rain Warning " will be sent to the serial monitor.
  - If the Sensor Board is dry; "case 2" will be activated and " Not Raining " will be sent to the serial monitor. 
 
*/
 
// lowest and highest sensor readings:
const int sensorMin = 0;     // sensor minimum
const int sensorMax = 1024;  // sensor maximum
 
void setup() {
  // initialize serial communication @ 9600 baud:
  Serial.begin(9600);  
}
void loop() {
  // read the sensor on analog A0:
	int sensorReading = analogRead(A0);
  // map the sensor range (four options):
  // ex: 'long int map(long int, long int, long int, long int, long int)'
	int range = map(sensorReading, sensorMin, sensorMax, 0, 3);
 
  // range value:
  switch (range) {
 case 0:    // Sensor getting wet
    Serial.println("Flood");
    break;
 case 1:    // Sensor getting wet
    Serial.println("Rain Warning");
    break;
 case 2:    // Sensor dry - To shut this up delete the " Serial.println("Not Raining"); " below.
    Serial.println("Not Raining");
    break;
  }
  delay(1);  // delay between reads
}

 

 

 

A saída

Imagem de Arduino Esboço Exemplo:

Os seguintes mapas de código e lê os valores analógicos dadas pelo sensor de chuva (0-1024). O sensor de chuva terá a seguinte reação com este código:

  • Se o Sensor está completamente encharcado; “caso 0” será ativada e “Flood” será enviado para o monitor serial.
  • Se o Sensor tem gotas de água nela; “Caso 1” será ativada e “Rain Warning” será enviado para o monitor serial.
  • Se a placa do sensor está seco; “caso 2” será ativada e “não está chovendo” será enviado para o monitor serial.

* A saída em “caso 2”, “não está chovendo” é apenas para esta demonstração.Quando eu usei este código na produção omiti a saída para este caso e só tinha o alerta para “Aviso Rain” e “Flood”.

* Para visualizar a saída, apontar um monitor serial como Putty em seu Arduino.

Teste:

Para testar o sensor de chuva e garantir que ele está funcionando corretamente ligar o VCC a uma fonte de alimentação 5v e GND. Experimente colocar algumas gotas de água na placa de detecção do sensor de chuva e o LED deve acender.

 

Solução de problemas:

Se o LED não se acender, verifique o seguinte:

  • É o módulo ligado corretamente?
  • Às vezes, a salinidade é um problema com estas unidades, este funcionou bem com filtrada, garrafas de água, mas em alguns casos você pode ter que adicionar um pouco de sal para aumentar a condução águas.
  • Isso pode ser um pouco mais complicado, mas por algum motivo, dois modelos diferentes por dois fabricantes diferentes tiveram defeitos de suas habilidades de solda. Certifique-se de todo o pouco de SMD e conectores foram soldadas de forma adequada. IE – são realmente soldadas juntas de solda?
  • Se nenhuma das opções anteriores faz com que a luz LED ligue, o sensor pode estar com defeito.

 

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Luximetro com um GY-30 e um Arduino

25 SET
2015

Author: Leonardo Dalla Porta

Luximetro com um GY-30 e um Arduino

Neste circuito simples, nós usamos um pequeno sensor GY-30 e um Arduino para medir a iluminância em lux. Além da aplicação para medir a iluminação de objetos na fotografia, você pode – com uma extensão deste circuito, também facilmente fazer uma iluminação adaptada de quartos ou jardins. Também é possível realizar um controle automático de brilho para monitores, entre muitas outras aplicações.

Conexões

Nós conectamos o nosso Arduino – neste caso, um Arduino – com o (GY-30)  da seguinte forma:

Arduino
(Nano,  Uno, Mini Pro)
Arduino
(Mega,  mega 2560)
GY-30
5V oder 3.3V (VCC) 5V oder 3.3V (VCC) VCC
GND GND GND
A4 (SDA) D20 (SDA) SDA
A5 (SCL) D21 (SCL) SCL

 modulo-gy-30-medidor-de-iluminncia-bh1750fvi-p-arduino-923901-MLB20423186982_092015-O

O código

Como uma biblioteca adicional não é necessária, precisamos apenas fazer o upload do seguinte esboço para o nosso Arduino:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include &lt;Wire.h&gt;
 
int BH1750_address = 0x23; // i2c Addresse
byte buff[2];
 
void setup(){
 
  Wire.begin();
  BH1750_Init(BH1750_address);
 
  delay(200);
  Serial.begin(9600);
  Serial.println("Starte Beleuchtungsstaerkemessung - blog.simtronyx.de");
}
 
void loop(){
 
  float valf=0;
 
  if(BH1750_Read(BH1750_address)==2){
 
    valf=((buff[0]&lt;&lt;8)|buff[1])/1.2;
 
    if(valf&lt;0)Serial.print("&gt; 65535");
    else Serial.print((int)valf,DEC); 
 
    Serial.println(" lx"); 
  }
  delay(1000);
}
 
void BH1750_Init(int address){
 
  Wire.beginTransmission(address);
  Wire.write(0x10); // 1 [lux] aufloesung
  Wire.endTransmission();
}
 
byte BH1750_Read(int address){
 
  byte i=0;
  Wire.beginTransmission(address);
  Wire.requestFrom(address, 2);
  while(Wire.available()){
    buff[i] = Wire.read(); 
    i++;
  }
  Wire.endTransmission();  
  return i;
}

Download do Código Fonte

e depois iniciar o monitor serial, o resultado deve ser semelhante a este:

Medição de iluminância com um BH1750FVI e um Arduino Uno - monitor-blog.simtronyx.de de série

Agora devemos ter uma saída semelhante como mostrado acima. Neste caso, o sensor foi deslocado no tempo ensolarado entre sombra (temporariamente coberto com a mão a uma curta distância) e luz solar direta. Pode ser visto que, em luz solar direta do intervalo de valores do sensor de for excedido muito rapidamente.

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor de Fumaça Mq-2 no arduino

25 SET
2015

Author: Leonardo Dalla Porta

A série de sensores de gases MQ usa um pequeno aquecedor dentro com um sensor eletro-química. Eles são sensíveis a uma gama dos gases e são utilizados em ambientes fechados, à temperatura ambiente. A saída é um sinal analógico e pode ser lido com uma entrada analógica do Arduino.

O módulo de MQ-2 sensor de gás é útil para a detecção de vazamento de gás em casa e na indústria. Pode detectar GPL, i-butano, propano, metano, o álcool, o hidrogênio e o fumo.

Alguns módulos têm uma resistência variável incorporado para ajustar a sensibilidade do sensor.

Nota: O sensor fica muito quente depois de um tempo, não toque nele!

Você vai precisar de:

  • Uno Arduino
  • Placa de ensaio
  • Módulo sensor MQ-2 Gas

 

O Circuito

As conexões são bastante fáceis:

sensor-de-gas-fumaca-mq-2-para-arduino-pic-19890-MLB20178648459_102014-O

 

  • Vcc ao Arduino pino 5V
  • GNG ao Arduino pino GND
  • Saída para pin Arduino analógica A0

O Código

/* Testing MQ-2 GAS sensor with serial monitor
Suitable for detecting of LPG, i-butane, propane, methane ,alcohol, Hydrogen or smoke
Dev: Michalis Vasilakis // Date: 11/6/2015 // www.ardumotive.com */

const int gasPin = A0; //GAS sensor output pin to Arduino analog A0 pin

void setup()
{
Serial.begin(9600); //Initialize serial port – 9600 bps
}

void loop()
{
Serial.println(analogRead(gasPin));
delay(1000); // Print value every 1 sec.
}

 

 

Teste:

Após feito isso, e já feito upload do código basta abrir o monitor serial, e utilizar um isqueiro para testar, ou até mesmo um fósforo, e é só criar!

Dica: Você pode usar este tutorial para ler os valores de todos os sensores de gás MQ (MQ-2, MQ-3, MQ-4, MQ-5, 6-MQ, MQ-7, etc)

 

 

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor Infravermelho Ajustável

24 SET
2015

Author: Leonardo Dalla Porta

Sensor Infravermelho Ajustável

O Sensor Infravermelho Ajustável é um conjunto de transmissor e receptor em um dos sensores fotoelétricos. A distância de detecção pode ser ajustado de acordo com a demanda. O ajustável Interruptor Sensor Infravermelho é pequeno, fácil de usar, barato, fácil de montar e pode ser amplamente utilizado em um robô para evitar obstáculos, mídia interativa, linha de montagem industrial, e muitas outras ocasiões. A saída de sinal de comutação é diferente, de acordo com os obstáculos. Ele continua a ser elevada quando há obstáculos e continua a ser baixa, quando há obstáculos. Há também um LED vermelho na sua parte de trás para indicar o estado do sensor.

Especificação

  • Fonte de alimentação: 5V
  • Corrente de trabalho: <100mA
  • Alcance de detecção ajustável: 3 centímetros – 80 centímetros
  • Pino e descrição:
    • Vermelho – 5V
    • Verde ou Preto – GND
    • Amarelo – Saída digital
  • Saída digital:
    • “0” – barreira encontrada (~ 0V)
    • “1” – nenhuma barreira (~ 4V)
  • Dimensão: 45x18mm

Diagrama de conexão

Caso necessário pode-se utilizar um resistor de 10k entre o pino amarelo e um GND, ou 5V dependendo do caso:

SEN0019 Sensor interruptor Diagrama de Conexão greenGND.png

Código

O código para este sensor é muito simples, e pode ser visto logo abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const int InfraredSensorPin = 4; // Ligue o pino sinal ao pino digital 4
const int LedDisp = 13;
void setup()
{
  Serial.begin(57600);
  Serial.println("Start!"); 
  pinMode(InfraredSensorPin, entradas);
  pinMode(LedDisp, OUTPUT);
  digitalWrite(LedDisp, LOW);
}
void loop()
{
  if(digitalRead(InfraredSensorPin) == LOW)  digitalWrite(LedDisp,HIGH);
  else  digitalWrite(LedDisp,LOW);
  Serial.print("Infrared Switch Status:");
  Serial.println(digitalRead(InfraredSensorPin),BIN);
  delay(50);
}

Resultado

Ao cobrir a frente do sensor com a mão, o LED (Pin13) a bordo acende-se, segure-o em direção a uma área aberta, o LED será desligado. Abra o monitor serial do Arduino, lá você também pode obter o status do sensor infravermelho.

Sen0019 result.png

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Módulo Joystick – Arduino

22 SET
2015

Author: Leonardo Dalla Porta

Conheça o módulo Joystick analógico, um módulo muito pratico, seu modelo é semelhante do console “PlayStation 3”. O módulo é muito fácil de usar com um Arduino e custa muito pouco. Ele utiliza uma resistência variável para cada eixo, portanto somente duas portas analógicas do Arduino!

Visão geral

O módulo tem 5 pinos: SCR, GND, X, Y, SW. Note-se que os rótulos em seu pode ser ligeiramente diferente. Este módulo é analógico e deve fornecer leituras mais precisas do que simples Joysticks direcionais ou os modelos de botões ou interruptores mecânicos.  Além disso, você pode pressionar o Joystick para baixo para ativar uma chave, dessa forma você pode criar menus e navegar neles!

Utilizaremos pinos analógicos do Arduino para ler os dados a partir dos pinos X e Y , e um pino de digital para ler o botão. O pino de chave é ligado ao GND, quando o Joystick é pressionado recebemos leituras no pino Key, ele precisa ser ligado a Vcc através de um resistor de pull-up, ou utilizar os disponíveis nas saídas analógicas do Arduino.

Ligações

As ligações do Joystick são muito simples, não precisa nenhum componente a mais, na figura a seguir mostramos todas as ligações:

2

 

Código de exemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
int xPin = A1;
int yPin = A0;
int buttonPin = 2;
 
int xPosition = 0;
int yPosition = 0;
int buttonState = 0;
 
void setup() {
  // initialize serial communications at 9600 bps:
  Serial.begin(9600); 
 
  pinMode(xPin, INPUT);
  pinMode(yPin, INPUT);
 
  //activate pull-up resistor on the push-button pin
  pinMode(buttonPin, INPUT_PULLUP); 
 
  // For versions prior to Arduino 1.0.1
  // pinMode(buttonPin, INPUT);
  // digitalWrite(buttonPin, HIGH);
 
}
 
void loop() {
  xPosition = analogRead(xPin);
  yPosition = analogRead(yPin);
  buttonState = digitalRead(buttonPin);
 
  Serial.print("X: ");
  Serial.print(xPosition);
  Serial.print(" | Y: ");
  Serial.print(yPosition);
  Serial.print(" | Button: ");
  Serial.println(buttonState);
 
  delay(100); // add some delay between reads
}

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

 

Módulo MMA7361 Acelerometro no arduino

19 SET
2015

Author: Leonardo Dalla Porta

Módulos de sensores de add-on com preços razoáveis ​​são agora amplamente disponíveis, e você pode equipar-se seus próprios projetos de hobby fascinante usando estes módulos pré-montados, ligando-os para microcontroladores adequados. Aqui é uma introdução ao MMA7361.

 Este sensor pode medir estática (gravidade da Terra) ou aceleração dinâmica em todos os três eixos. Aplicação do sensor é em vários campos e muitas aplicações pode ser desenvolvido usando. O nível do acelerômetro medidas de aceleração onde é montado, nos permite medir a aceleração / desaceleração de um objeto, ou inclinação de uma plataforma com respeito ao eixo da terra.

MMA7361LC

Além disso, o sensor fornece saída que detectam queda livre linear. Tecnicamente, MMA7361LC tem um perfil baixo, capacitivo, acelerômetro micro usinado com condicionamento de sinal, um filtro passa-baixa de 1 pólo, compensação de temperatura, auto-teste, 0g-Detect que detecta queda livre linear, e g-Select, que permite a seleção entre 2 sensibilidades. Compensada Zero-g e sensibilidade são ajustados na fábrica e não necessitam de dispositivos externos. O MMA7361LC inclui um Modo de Espera que o torna ideal para portáteis alimentados por bateria eletrônica. O módulo pode ser alimentado diretamente com uma fonte CC 5V. Note-se que ele também pode ser alimentado diretamente a partir de ‘clean’ oferta dc qualquer 3.3V.

Simplificado Acelerômetro Funcional Diagrama de Blocos

Características MMA7361

  • Simples de usar
  • Saída analógica para cada eixo
  • + 5V operação atual @ 1ma
  • Alta Sensibilidade (800mV / g @ 1,5 g)
  • Sensibilidade selecionável (+ – 1,5 g, + – 6g)
  • 0g detectar para detecção de queda livre
  • Design robusto, choque de alta capacidade de sobrevivência
  • Baixo custo

Aplicações MMA7361

  • 3D Gaming: Tilt e Motion Sensing, gravador de Evento
  • HDD MP3 Player: Detecção Freefall
  • Laptop PC: Detecção Freefall, Anti-Theft
  • Telefone celular: Imagem de Estabilidade, Texto Scroll, Movimento Discagem, E-Compass
  • Pedômetro: Motion Sensing / PDA: Scroll Texto
  • Navegação e Dead Reckoning: E-Compass Tilt Compensation
  • Robótica: Motion Sensing

Interface MMA7361 módulo acelerômetro no Arduino UNO

Lá muitos bons recursos lá fora na web para acelerômetros e do Arduino. Aqui está uma cartilha simples que eu encontrei útil. Felizmente, não muitas coisas são necessárias aqui para esta experiência de nível de entrada.

  • Arduino Uno R3
  • MMA7361 Acelerômetro
  • Jumpers

MMA7361LC arduino esquemática

diagrama de fiação

Código para o MMA7361 com Arduino é mostrado aqui. Usando este programa você pode ler a saída de X, Y e Z eixo durante o uso, por meio do Monitor serial!

  1. int x; // x variável do eixo
  2. int y; // variável do eixo y
  3. int z; // variável do eixo Z
  4. vazio de configuração ()
  5. {
  6. Serial. Começar (9600); // abre porta serial, define a taxa de dados de 9600 bps
  7. }
  8. vazio de loop ()
  9. {
  10. x = analogRead (5); // ler entrada pino A5
  11. y = analogRead (4); // ler pino de entrada A4
  12. z = analogRead (3); // ler pino de entrada A3
  13. Serial. Print (“X =”); // print x valor adc
  14. Serial. Println (x);
  15. Serial. Print (“Y =”); // print y valor adc
  16. Serial. Println (y);
  17. Serial. Print (“Z =”); // print z valor adc
  18. Serial. Println (Z);
  19. atraso (100);
  20. }

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Lendo o Sensor ACS712 com Arduino

17 SET
2015

Author: Leonardo Dalla Porta

O sensor ACS712 lê o valor da corrente atual e converte-a em um valor relevante em tensão, o valor que liga as duas medições é  sensibilidade  (você pode encontrá-lo no datasheet),o sensor tem um valor típico de  185mV / A. O sensor pode medir as correntes positivas e negativas (gama  de -30 … 30A), e fonte de alimentação é 5V para o sensor, a tensão de detecção do meio é  2.5V quando não há corrente. E além disso suporta corrente DC e AC!

O valor da leitura para este também é simples, usar a “analogRead” função padrão será suficiente, no entanto, a função gera um valor entre 0  (0V na entrada)  e 1023  (5V na entrada) que é  0,0049V  para cada incremento. Vamos usar a seguinte fórmula para converter o valor de 0 a 1023 para um valor de ampere.

fórmula

No nosso caso o teste, usamos bateria de 9V para fornecer ao Arduino, e o sensor ACS712 ligar à porta Vin deste Arduino.

O código do arduino é muito simples, com exceção da leitura analógica, apenas acrescentar também o cálculo da fórmula, onde a saída é em miliamperes:

1
2
3
4
5
6
7
8
9
10
11
12
void setup() {
Serial.begin(9600);
}
void loop() {
float average = 0;
for(int i = 0; i &lt; 1000; i++) {
average = average + (.0264 * analogRead(A0) -13.51);
delay(1);
}
Serial.print(average);
Serial.println(“mA”);
}

 

A saída no Monitor Serial vai ser algo parecido com isso:

 

-65.14mA
-66.65mA
-65.46mA
-66.57mA
-66.51mA
-66.14mA
-65.59mA

 

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Reed Switch no arduino

12 SET
2015

Author: Leonardo Dalla Porta

O reed switch é interruptor mecânico que é ativado quando um campo magnético é aproximado perto dele. A palheta magnética é fechado em uma ampola de vidro, e tem dois pinos de ligação.

Para obter melhores resultados, use um ímã com um forte campo magnético .Este aumenta a sensibilidade do interruptor de lâminas. Quanto maior a intensidade do campo, quanto mais longe o ímã pode ser e ainda acionar o interruptor. O Reed Switch é um dispositivo muito frágil, se quebra por qualquer pressão ou queda.

 

Conexões

O esboço simples exemplo usa um Reed Switch ligado ao pino Digital 2. O exemplo estendido usa um interruptor de lâminas adicional ligado ao pino Digital 3. Para ligar o segundo Reed Switch no Arduino, anexar o pino digital 3, e a outra para GND, como mostrado na figura:

Reeds2

 

 

O Código:

 

Para usar esse exemplo, fazer o upload do Código ao seu Arduino, em seguida, abra o monitor Serial. Certifique-se que a taxa de transmissão é estabelecido em 9600. Passe um ímã perto do Switch, e ver o valor na janela Monitor.

Quando a chave é fechada (ímã é próximo), o valor é 0 (LOW)
Quando a chave é aberta (ímã é removido), o valor é 1 (HIGH)
A “lógica inversa” do esboço tem a ver com a utilização de resistências pull-up internas da Arduino que estão em cada pino de entrada. Quando ativado – como se mostra no desenho – o pino é normalmente em estado HIGH. Porque a outra extremidade do interruptor está ligado diretamente à terra, quando o interruptor é ativado, o pino vai LOW.

 

1
2
3
4
5
6
7
8
9
10
11
12
const int switchPin = 2; // // Reed interruptor ao pino digital 2
 
void setup () {
pinMode(switchPin, entradas); // SwitchPin é uma entrada
digitalWrite(switchPin, HIGH); // Ative resistor pullup interno
Serial.begin(9600);
}
 
void loop () {
Serial.println(digitalRead (switchPin)); // Mostra valor atual
atraso (200);
}

 

 

O código 2.0:

Este exemplo demonstra uma aplicação mais avançada da utilização de dois interruptores Reed, e comparando o número de vezes que ambos os interruptores são activados. Ele pode ser utilizado, por exemplo, para mostrar um ciclo de movimento completo, tal como um exercício braço, onde é importante que o movimento do braço de uma posição para outra. Coloque um ímã forte em um manguito de tecido, e posicionar um interruptor de lâminas em cada extremo do movimento.

Este código inclui a codificação para evitar Switch “salto”, que ocorre quando a cana abre ou fecha muitas vezes em um período muito curto. Isso é realmente muito comum em todos os interruptores mecânicos. Em muitos casos, os múltiplos saltos criar pouco ou nenhum problema. Mas, no presente exemplo de programação estendida, os saltos causará mis-contagens. O código é adicionado para ignorar fechos de comutação adicional, se ocorrer demasiado cedo após a primeira.

Para usar esse exemplo, fazer o upload do esboço o seu Arduino, em seguida, abra o Monitor serial. Certifique-se que a taxa de transmissão é estabelecido em 9600. Passe um ímã em cada chave, e observar os valores na janela Monitor Serial. A contagem é atualizada a cada vez interruptor 0 é ativado.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// Reed switch repetition counter
 
int sense0 = 2;
int sense1 = 3;
int counter0 = 0;
int counter1 = 0;
long lastDebounce0 = 0;
long lastDebounce1 = 0;
long debounceDelay = 500;    // Ignore bounces under 1/2 second
 
void setup() {
  Serial.begin(9600);
  pinMode(sense0, INPUT);
  digitalWrite(sense0, HIGH);
  pinMode(sense1, INPUT);
  digitalWrite(sense1, HIGH);
  attachInterrupt(0, trigger0, FALLING);
  attachInterrupt(1, trigger1, FALLING);
  Serial.println("Repetition counter");
  Serial.print("Start");
  Serial.print("\t");
  Serial.println("End");
}
 
void loop() {
  // Nothing here
}
 
void trigger0() {
  if( (millis() - lastDebounce0) &gt; debounceDelay){
    counter0++;
    Serial.print(counter0);
    Serial.print(" : ");
    Serial.println(counter1);
    lastDebounce0 = millis();
  }
}
 
void trigger1() {
  if( (millis() - lastDebounce1) &gt; debounceDelay){
    counter1++;
    lastDebounce1 = millis();
  }
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Sensor de temperatura LM35 no arduino

12 SET
2015

Author: Leonardo Dalla Porta

Veja a simplicidade de utilizar o LM35 como sensor de temperatura utilizando o arduino. Com este sensor de temperatura você pode medir temperaturas até 135Cº, sua aplicação é imensa, seu único ponto fraco é a distancia de funcionamento, a distancia das conexões, mas nada que limite seu uso. Vamos conectar este dispositivo maravilhoso no seu arduino! Vamos lá!

Você vai precisar de:

  • ARDUINO
  • LM35 Sensor de temperatura
  • CABO USB
  • Alguns Jumpers
  • Protoboard

 

Conexões:

A ligação é muito simples, utiliza uma porta analógica neste caso “A0”, e somente 5v e o gnd. Como pode-se ver na imagem temos os detalhes deste sensor de temperatura LM35:

LM35_500x500_1_

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int val;
int tempPin = 1;
 
void setup()
{
Serial.begin(9600);
}
void loop()
{
val = analogRead(tempPin);
float mv = ( val/1024.0)*5000;
float cel = mv/10;
float farh = (cel*9)/5 + 32;
 
Serial.print("TEMPRATURE = ");
Serial.print(cel);
Serial.print("*C");
Serial.println();
delay(1000);
 
/*  Descomente esta parte para ler em farhnheit
Serial.print("TEMPRATURE = ");
Serial.print(farh);
Serial.print("*F");
Serial.println();
 
*/
}

Qualquer dúvida deixe seu comentário abaixo, espero ter sido esclarecedor, um abraço e até a próxima!

Faça um bom uso! Att. Equipe Nadiel Comércio.

Barômetro BMP180 no Arduino

09 JUN
2015

Author: Leonardo Dalla Porta

Tecnologias antigas que de forma eletrônica, fazem parte de nosso dia a dia hoje na atualidade, isso, o que estamos falando é o Barômetro, equipamento utilizado para medir pressão atmosférica, que evoluiu muito de um metro, para 10 milímetros aproximadamente!

Com a necessidade de medir a pressão atmosférica, o Evangelista Torricelli, desenvolveu o barômetro, sua primeira versão utilizava mercúrio (Metal Pesado) para realizar esta leitura, e além disso o experimento tinha aproximadamente um metro de altura…

O Barômetro BMP180

O Barômetro BMP180 é um sensor de pressão atmosférica de baixo consumo e de alta precisão, o sensor trabalha com o protocolo I2C, que torna o mais pratico, com seu tamanho reduzido (12mm * 12mm), nos permite posiciona-lo em qualquer local com facilidade. Sua tensão de trabalho é de no mínimo 3v e no Máximo 5v, sendo possível utilizar com qualquer bateria dentro desses valores.

Conectando-o ao Arduino UNO

Como já mencionamos, o sensor trabalha com I2C, dessa forma trabalhamos com apenas 2 portas do Arduino, para o Arduino Uno é as portas analógicas 4 e 5.

BMP180

Software

A biblioteca que utilizamos é a “BMP180” que pode ser encotrada aqui.

Faça download da biblioteca instale-a e execute o código de exemplo a seguir:

Código Download

Espero que tenham compreendido, qualquer duvida deixe seu comentário logo abaixo!

Att. Leonardo Dalla Porta

 

RFID RC522 Utilizando Arduino

05 MAIO
2015

Author: Leonardo Dalla Porta

 

Diariamente deparamos equipamentos cada vez mais tecnológicos, seja em um simples controle de acesso até mesmo a partida dos carros, a tecnologia RFID já esta a um certo tempo entre nós, como por exemplo carros a partir de 1996 vários modelos já contavam com um chip na chave, onde impossibilita o carro de dar partida com chave diferente, mas infelizmente poucas pessoas conhecem esse sistema, que evita muitos furtos de veículos. Mas a parte mais interessante de tudo isso é que isso esta ao seu alcance!

 

Um pouco de sua origem:

Durante a Segunda Guerra mundial, os alemães precisavam identificar os aviões os quais haviam de aterrizar na pista, mas para ter certeza se era um aliado ou inimigo foi aplicado a seguinte tática, antes de chegar próximo á pista de aterrizagem o piloto deveria girar a nave para inverter o sinal recebido pelo radar, onde os operadores do radar ja saberia que era um aliado. Primeiramente esse sistema foi chamado de RFID (Radio Frequency Identification). Tempo depois sob comando de Watson-Watt, foi desenvolvido o IFF (Identify Friend or Foe) assim todos os aviões britânicos que portavam este dispositivo poderiam ser identificados.

Após isso esse sistema evoluiu muito, em 1973, Mario W. Cardullo patenteou o projeto com um chip programável, que foi destinado a trancas eletrônicas. Na decada de 90 alguns engenheiros da IBM, criaram um sistema RFID utilizando a tecnologia UHF, que por sua vez teria um alcance de 6m em ambiente normal. Mas a IBM acabou vendendo esta patente para a Intermec. Que passou a utilizar a tecnologia em diversas áreas, em 1999 um grupo de empresas e professores criaram o Auto-ID Center localizado no Instituto de Massachussets, a partir dai a tecnologia vem sempre avançando para facilitar as coisas.

O que é RFID? Pra que serve?

 RFID ou “Radio Frequency Identification” é um sistema de identificação por aproximação, ou seja, você tem uma “Tag” Transpoder e ela é portadora de um código único, que serve para identificar alguma como por exemplo um Animal, uma pessoa, um produto, etc.

 

Curiosidades

  • Empresas como por exemplo a HP trabalham com RFID para identificar as assistências feitas nas impressoras.
  • Os EUA queriam implantar os chips RFID em todas as pessoas, talvez substituindo pelo “Social Security Card” lá utilizado.
  • No brasil já existem inúmeros animais sendo identificados dessa forma.

 

Funcionamento

 O leitor de RFID possui uma bobina, esta bobina transmite uma pequena quantia de energia, suficiente para alimentar a Tag. A Tag também possui uma bobina que ao receber essa onda eletro-magnética fornecida pelo leitor, alimenta o microchip que transmite o código pela mesma bobina.

 

O projeto

 Estaremos simulando neste projeto, uma tranca eletrônica, utilizando um servo motor, pois é uma tranca que funcionaria até mesmo com uma bateria muito pequena, pois ele não tem necessidade de ficar operando a todo momento, assim ficando até mais ecológico. O sistema consiste no Modulo leitor RFID, no Arduíno e um display de “Bem Vindo”, veja como:

Produtos utilizados:

  • Leitor RFID-RC522
  • Tag ou cartão RFID
  • Arduíno
  • Protoboard
  • Jumpers

 

Firmware

Neste LINK está disponível a biblioteca do Módulo RFID RC522. Tendo esta biblioteca instalada faça download do código, faça upload no seu Arduíno e comece a montagem de seu Hardware!

Código

 

Hardware

 

Arduino-Uno-r3-with-RFID-RC522_bb

Encoders Rotativos

28 ABR
2015

Author: Leonardo Dalla Porta

 

 

Hoje em dia existem dispositivos cada vez mais digitais como em aparelhos de som, Home Theater, auto rádios entre outros, já podemos ver potenciômetros sendo substituídos por Encoders Rotativos, os quais tornam os projetos muito mais econômicos, alem disso através de um só Encoder Rotativo você pode controlar vários menus, tornando tudo muito pratico e acessível.

 

O que é um Encoder?

    O Encoder rotativo, é um dispositivo eletro-mecânico, ele transforma a rotação em sinais elétricos, com mera semelhança com um potenciômetro linear, a diferença entre eles é que o Encoder não tem limite de giro, assim como o potenciômetro é limitado a um certo angulo, o potenciômetro é um dispositivo analógico, já o Encoder digital, ou seja, ele gera ondas quadradas.

 

Funcionamento

     O Encoder gera duas ondas simultâneas, como podemos analisar seu físico ele possui 3 terminais que no meio fica a entrada, e em cada lado podemos dizer que sai uma onda, onde dependendo do lado que esta sendo girado uma esta a um tempo atrasado da outra, dessa forma podemos fazer a leitura utilizando um microcontrolador.

 

Testes:

     Utilizando um osciloscópio podemos visualizar o que acontece dentro de um Encoder, como podemos ver na onda a seguir a onda azul está um pouco adiantada da amarela, o que quer dizer que o Encoder está sendo girado para um lado, isso é determinado pelas ligações dos terminais externos, ao inverter a rotação podemos notar a diferença nas ondas que a situação inverte.

MAP002

     Nesta imagem podemos visualizar o Encoder sendo girado para outro lado, assim intervertendo em relação a outra imagem.

 MAP001

Esse Encoder que estamos utilizando você pode encontrar para compra neste LINK.

Utilizando o Arduíno, vamos criar e navegar em menus utilizando este Encoder, e visualizar isso em um display 16*2, sendo assim, começamos nosso projeto.

 

Produtos a serem utilizados nesse projeto:

  •  Encoder rotativo
  • Arduino
  • Jumpers
  • Display LCD 16×2
  • Protoboard
  • Trimpot
  • Fonte ou mesmo a USB de seu computador

 

Hardware:

 Depois de ter todas as peças em mãos vamos ao circuito, para evitar crises de raiva de não funcionar preste atenção em qualquer ligação que você irá fazer. Logo abaixo disponibilizamos o diagrama de ligações para ser acessível de todos montarem.

Untitled Sketch_bb

Firmware:

O código para este projeto estamos disponibilizando para download, denominado “Teste_Encoder.ino”.

 Download

Após todo o esquema montado, basta fazer upload do código e se divertir programando e estudando seu Encoder Rotativo, com esse código você pode estar desenvolvendo qualquer tipo de projeto relacionado a Encoders.

Sensor óptico reflexivo TCRT5000

21 JUN
2014

Author: Nadiel Comércio

O TCRT5000 é um sensor óptico com saída de transistor muito comumente usado em projetos de robôs seguidores de linha, nessa postagem mostrarei como montar o esquema elétrico e fazer a montagem desse sensor. Para o meio prático usarei um Arduino para testar.

Free-shipping-100PCS-New-TCRT5000L-TCRT5000-Reflective-Optical-Sensor-Photoelectric-switch

Antes de começar, algumas informações muito importantes devem ser ressaltadas, e para isso, ler o DATASHEET do componente é a melhor opção para extrair estas informações.

 

Como Funciona

Este sensor é composto basicamente por um LED emissor de infravermelho (Luz que nesta frequência [Hz] não é visível a olho nu)  e um fototransistor responsável por filtrar a luz natural e captar ou não sinais de infravermelho. Ele possui um escudo que separa o emissor do receptor e dependendo da reflexibilidade da superfície ele é capaz de detectar a cor (Em uma escala PRETO e BRANCO) dessa superfície em questão.

 

Características de Operação

• Dimensões (L x C x A em mm): 10.2 x 5.8 x 7
• Distancia de operação de pico: 2.5mm
• Distancia de operação com eficiência maior que 20%: 0.2mm até 15mm
• Consumo de corrente: 1mA
• Comprimento de onda do emissor: 950nm

TCRT5000 - Pinagem e funcionamento

Perceba que o tipo de objeto que você quer detectar vai influenciar diretamente na operação do sensor, já que, quanto mais reflexivo o material, maior a distância que o sensor vai alcançar. Como exemplo, fiz um teste (sem precisão), onde o sensor foi acionado com um pedaço de papel (branco) à 23 mm, uma régua de metal foi detectada à 30 mm e, com um pedaço de madeira escura, o sensor nem foi acionado.

Para testar esse sensor óptico com o Arduino, vamos primeiramente montar este circuito. Foi utilizado um resistor de 330 ohms para o led infravermelho e de 10K para o transistor :
Sensor Optico - Teste sem led

Carregue este programa, abra o serial monitor e aproxime objetos do sensor até que o objeto seja detectado. No serial monitor, o status muda de “Ausente” para “Detectado” :

Código para Arduino:

 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Programa : Teste sensor óptico reflexivo  
// Autor : Arduino e Cia  
   
int objeto = 0;  
   
void setup()  
{  
  pinMode(7, INPUT); //Pino ligado ao coletor do fototransistor  
  Serial.begin(9600);  
}  
   
void loop()  
{  
  objeto = digitalRead(7);  
  if (objeto == 0)  
  {  
    Serial.println("Objeto : Detectado");  
  }  
  else  
  {  
    Serial.println("Objeto : Ausente !");  
  }  
} 

Gostou?  Confira em nossa loja virtual, no Mercado Livre, NADIEL COMÉRCIO este produto e mais outros componentes eletrônicos.

 

Sensor de temperatura e Humidade DHT22

19 JUN
2014

Author: Nadiel Comércio

Olá a todos,

Hoje vamos falar do clássico DHT22 / AM2303 (que pode ler a temperatura e umidade), com uma placa Arduino Uno.
2841871_140311222645_humidity-temperature-sensor-dht22

Itens necessários para executar este teste:

E isso é tudo 🙂

O sensor de temperatura DHT22 é um dos mais clássicos quando você quiser medir a temperatura com um mínimo de sondas de confiabilidade.

 

Evite usar DHT11 que não vale a pena, mesmo que seja mais barato. Ele é menos preciso e não toma as temperaturas negativas.

 

Então se precisa de precisão Evite-o!!!!

Nosso sensor de DHT22 tem as seguintes especificações:

Entre 3 e entrada de 5V
Reprodução de humidade entre 0 e 100%, com uma precisão de 2% a 5%
Lendo a temperatura de -40 ° C a 80 ° C com uma precisão de cerca de 0,5 ° C

Veja aqui o datasheets
Montagem

Montagem e Arduino DHT22

O sensor tem 4 pernas, mas a terceira não nos servem. Assim, diz os guias de conexão da seguinte forma:

dht22_wyproadzenia
E deve, obviamente, colocar um resistor de 4700 Ohm ao pino 2 e, em seguida, conectar a fonte de alimentação (consulte o meu diagrama, por exemplo).

atmega_dht11_dht22_sample

Arduino-et-DHT22_bb-1024x427

 

Código

Agora que a nossa instalação está concluída, vamos agora tratar do código da peça para obter as informações que estamos procurando: temperatura e umidade.

Felizmente para nós, existem várias bibliotecas na rede de explorar os dados coletados, vamos usar isso de Adafruit  faça o download aqui  para usar nosso sensor .

Considere alterar esta linha para informar o pino que você usou.
# Define DHTPIN 2

Verifique o código, em seguida, compilar e carregar para seu arduino. E pronto, ele funciona.

Abra o monitor serial e você terá algo parecido com isto:

dht22serial

Gostou?  Confira em nossa loja virtual, no Mercado Livre, NADIEL COMÉRCIO este produto e mais outros componentes eletrônicos.

Sensor Ultrassônico HC-SR04

19 JUN
2014

Author: Nadiel Comércio

Um tipo de sensor bastante usado em aplicações industriais é o que faz uso de ultra-sons. Esses sensores podem ser utilizados para detectar a passagem de objetos numa linha de montagem, detectar a presença de pessoas ou ainda de substâncias em diversos estados num reservatório permitindo a medida de seu nível.

Esses sensores se caracterizam por operar por um tipo de radiação não sujeita a interferência eletromagnética e totalmente limpa, o que pode ser muito importante para determinados tipos de aplicações.
Podendo operar de modo eficiente detectando objetos em distâncias que variam entre milímetros até vários metros, eles podem ser empregados para detectar os mais variados tipos de objetos e substâncias.

Princípio de Funcionamento.:

O Sensor Ultrassônico que vamos falar hoje é o HC-SR04 funciona como um detector de objetos e permite medir distâncias mínimas de 2 centímetros podendo chegar a distancias máximas de até 5 metros com uma precisão de 3 milímetros sensor-de-distncia-ultrassnico-codigo-arduino-322-MLB4679409508_072013-O

. Estes sensores emitem um sinal ultrassônico que reflete em um objeto e retorna ao sensor (eco). O sinal de retorno é captado, permitindo-se deduzir a distância do objeto ao sensor tomando o tempo de trânsito do sinal.

Os sensores ultra-sônicos só funcionam se existir uma fonte emissora de ultra-sons. Então, o sensor típico é formado por um emissor de ultra-sons e um microfone ultra-sônico, conforme ilustra a figura abaixo.

sensores_ultra-sonicos_figura_07

 

 

O emissor, que pode ser um cristal piezoelétrico ou ainda uma bobina que excita uma lâmina vibrante, emite um pulso de curta duração de ultrasons. Esse pulso se propaga e reflete no objeto que deve ser detectado, retornando, então, um ou mais pulsos de reflexão que são captados pelo microfone, conforme exemplo .

O formato e o tipo de objetos determinam o padrão de reflexão do ultra-som, e isso é importante nas aplicações práticas. Desse modo, uma superfície plana reflete o som praticamente na mesma direção de onde ele provém, enquanto que objetos com outros formatos podem provocar reflexões com diversos padrões, veja a figura.

 

sensores_ultra-sonicos_figura_08_files_image_thumb_medium600_300

É importante que, para maior rendimento, a maior parte do som seja enviada na direção em que se deseja detectar o objeto.

Vamos a prática :

Pinagem.:

  • VCC : Alimentação 5v
  • TRIG : Pino de Gatilho
  • ECHO : Pino de Eco
  • GND : Terra
prod_sensor_ultrassonico_gde

Montagem.:

1°  – O jumper de cor Preta é ligado ao pino GND (terra) do Arduino e ligado ao pino GND (terra) do sensor.
2°  – O jumper de cor Verde é ligado ao pino 13 do Arduino e ligado ao pino ECHO (eco) do sensor.
3°  – O jumper de cor Amarela é ligado ao pino 12 do Arduino e ligado ao pino TRIG (emissor) do sensor.
4°  – O jumper de cor Vermelha é ligado ao pino de 5V (corrente) do Arduino e ligado ao pino VCC (corrente) do sensor.

arduino-sensor-ultrasonico

Após o montagem do circuito você deverá carregar o código na IDE do Arduino. O código usado foi escrito usando a biblioteca do sensor ultrassônico, o download da biblioteca pode ser feito AQUI.

Código.:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <Ultrasonic.h>
#define echoPin 13 //Pino 13 recebe o pulso do echo
#define trigPin 12 //Pino 12 envia o pulso para gerar o echo
//iniciando a função e passando os pinos
Ultrasonic ultrasonic(12,13);
void setup()
{
Serial.begin(9600); //inicia a porta serial
pinMode(echoPin, INPUT); // define o pino 13 como entrada (recebe)
pinMode(trigPin, OUTPUT); // define o pino 12 como saida (envia)
}
void loop()
{
//seta o pino 12 com um pulso baixo "LOW" ou desligado ou ainda 0
digitalWrite(trigPin, LOW);
// delay de 2 microssegundos
delayMicroseconds(2);
//seta o pino 12 com pulso alto "HIGH" ou ligado ou ainda 1
digitalWrite(trigPin, HIGH);
//delay de 10 microssegundos
delayMicroseconds(10);
//seta o pino 12 com pulso baixo novamente
digitalWrite(trigPin, LOW);
// função Ranging, faz a conversão do tempo de
//resposta do echo em centimetros, e armazena
//na variavel distancia
int distancia = (ultrasonic.Ranging(CM));
Serial.print("Distancia em CM: ");
Serial.println(distancia);
delay(1000); //espera 1 segundo para fazer a leitura novamente
}

Após o código carregado e enviado para o Arduino, abra o monitor serial na IDE do arduino para verificar as saídas do seu projeto. Repare que as distâncias mudam os valores, nesse momento havia um objeto se aproximando e distanciando do sensor.

captura_de_tela-1

CONCLUSÃO

Os sensores ultra-sônicos, pela sua simplicidade e custo relativamente baixo, consistem em excelentes soluções para a detecção de objetos e medidas de pequenas distâncias. Conhecendo o seu princípio de funcionamento, os leitores poderão desenvolver projetos muito interessantes que envolvem desde a contagem de objetos numa linha de montagem até mesmo a detecção de obstáculos por robôs…

Gostou?  Confira em nossa loja virtual, no Mercado Livre, NADIEL COMÉRCIO este produto e mais outros componentes eletrônicos.

 

 
WordPress Themes
WordPress Themes