YL-83 Rain Sensor

The YL-83 is a raindrop module that consists of 4 pins: VCC, GND, D0, and A0. The connections are self-explanatory. The LM393 IC acts as a resistive divider. The board comes equipped with a power indicator light and a LED indicating lamp. The potentiometer on the board can be used to adjust the reference voltage. In this simple project, the D0 digital pin is connected to the D7 pin of an Arduino Uno. The A0 analog pin is wired to the Arduino's A0 pin. The output signal from the analog pin gets lower when raindrop is detected. The opposite applies when the sensor is dry.

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

int ledPin=13; int sensorDPin=7; int sensorAPin=A0; int val; void setup() { Serial.begin (9600); pinMode(ledPin,OUTPUT); pinMode(sensorDPin,INPUT); pinMode(sensorAPin,INPUT); } void loop() { val=analogRead(sensorAPin); Serial.println(val); val=digitalRead(sensorDPin); if(val==HIGH){ digitalWrite(ledPin,LOW); } else{ digitalWrite(ledPin,HIGH); } delay(2000); }

KY-028 NTC Temperature Sensor Module

The KY-028 is a thermal sensor module that utilizes an NTC thermistor to detect the temperature of the surrounding environment. NTC or Negative Temperature Coefficient means the resistance of the thermistor decreases with increasing temperature. The passive components that include the LM393 IC create a voltage divider for the thermistor.

The module in this example has analog (A0) and digital (D0) pin connections. Only the analog pin is used here. When the temperature increases, the output voltage that appears on the analog input of the Arduino will drop. The opposite applies when the temperature decreases. The temperature detection threshold can be adjusted through the onboard potentiometer.

1 2 3 4 5 6 7 8 9 10 11 12 13

int sensorPin=A0; int val; void setup() { Serial.begin (9600); pinMode(sensorPin,INPUT); } void loop() { val=analogRead(sensorPin); Serial.println(val); delay(2000); }

ADXL345 3 Axis Accelerometer

The ADXL345 is a 3-axis acceleration module. Playing with Arduino, Wire.h library is included in the skecth to communicate with the module. In this example, the ADXL345 is configured in I2C mode. Pin A4 of the Arduino (Uno) is connected to the SDA (data) while pin A5 is wired to SCL (clock). CS pin is tied high to enable this mode. As no other devices are connected to the I2C bus, external pull-up resistors are not used in this circuit.

Here, the AUTO_SLEEP (D4) and Measure (D3) bits of the 0x2D register are activated by inserting two lines of code "Wire.write(16)" and "Wire.write(8)" (dec 8 = binary 1000 and dec 16 = binary 10000). Register 0x32 to Register 0x37 hold the output data for each axis (X, Y, Z). Put it simply, two registers are used to store the data for each axis.

#include <Wire.h>

#define accel_module (0x53)

void setup(){
  Wire.begin();
  Serial.begin(9600);

  Wire.beginTransmission(accel_module);
  Wire.write(0x2D);
  Wire.write(0);
  Wire.endTransmission();

  Wire.beginTransmission(accel_module);
  Wire.write(0x2D);
  Wire.write(16);
  Wire.endTransmission();

  Wire.beginTransmission(accel_module);
  Wire.write(0x2D);
  Wire.write(8);
  Wire.endTransmission();
}

void loop(){
  int x1reg=0x32;
  int x2reg=0x33;
  int y1reg=0x34;
  int y2reg=0x35;
  int z1reg=0x36;
  int z2reg=0x37;

  int x1pos, x2pos, y1pos, y2pos, z1pos, z2pos;
  
  byte values[6];
  char output[512];

  Wire.beginTransmission(accel_module);
  Wire.write(x1reg); //Move the register pointer back to 0x32
  Wire.endTransmission();

  Wire.beginTransmission(accel_module);
  Wire.requestFrom(accel_module,1);
  values[0]=Wire.read();
  x1pos=(int)values[0];
  sprintf(output,"%d ",x1pos);
  Serial.print(output);
  Wire.endTransmission();


  Wire.beginTransmission(accel_module);
  Wire.write(x2reg);
  Wire.endTransmission();

  Wire.beginTransmission(accel_module);
  Wire.requestFrom(accel_module,1);
  values[1]=Wire.read();
  x2pos=(int)values[1];
  sprintf(output,"%d ",x2pos);
  Serial.print(output);
  Wire.endTransmission();


  Wire.beginTransmission(accel_module);
  Wire.write(y1reg);
  Wire.endTransmission();

  Wire.beginTransmission(accel_module);
  Wire.requestFrom(accel_module,1);
  values[2]=Wire.read();
  y1pos=(int)values[2];
  sprintf(output,"%d ",y1pos);
  Serial.print(output);
  Wire.endTransmission();


  Wire.beginTransmission(accel_module);
  Wire.write(y2reg);
  Wire.endTransmission();

  Wire.beginTransmission(accel_module);
  Wire.requestFrom(accel_module,1);
  values[3]=Wire.read();
  y2pos=(int)values[3];
  sprintf(output,"%d ",y2pos);
  Serial.print(output);
  Wire.endTransmission();


  Wire.beginTransmission(accel_module);
  Wire.write(z1reg);
  Wire.endTransmission();

  Wire.beginTransmission(accel_module);
  Wire.requestFrom(accel_module,1);
  values[4]=Wire.read();
  z1pos=(int)values[4];
  sprintf(output,"%d ",z1pos);
  Serial.print(output);
  Wire.endTransmission();

  Wire.beginTransmission(accel_module);
  Wire.write(z2reg);
  Wire.endTransmission();

  Wire.beginTransmission(accel_module);
  Wire.requestFrom(accel_module,1);
  values[5]=Wire.read();
  z2pos=(int)values[5];
  sprintf(output,"%d ",z2pos);
  Serial.print(output);
  Wire.endTransmission();

  Serial.write(10);

  delay(2000);
}

KY-026 IR Based Flame Detector

The 3-pin module detects the infrared in the flame in the range 760 to 1100nm. Aiming a TV remote control at the sensor will also work. Digital pin DO produces high or low electric level signal output. There is no analog output on the module used here. Sensitivity is adjustable via the onboard blue potentiometer. This module also comes equipped with a power supply indicator lamp and a comparator output indicator lamp. When the a certain threshold is reached, the comparator lamp lights up.

In the circuit below, the Arduino pin 12 that acts as digital input is connected to the digital pin DO on the sensor. When flame is detected, the onboard green LED on Arduino will illuminate. Keep in mind that the output from the board used here is HIGH when no flame or infrared emission is detected.

int ledPin=13;
int sensorPin=12;
int val;

void setup() {
  pinMode(ledPin,OUTPUT);
  pinMode(sensorPin,INPUT);
}

void loop() {
  val=digitalRead(sensorPin);
  if(val==HIGH){
    digitalWrite(ledPin,LOW);
  }
  else{
    digitalWrite(ledPin,HIGH);
  }
  //delay(500);
}

BMP180 Barometric Pressure Sensor

This sensor module can be used to calculate temperature, pressure, and altitude. There are five pin connections on this module that include VCC, GND, SCL, SDA, and 3.3. In the circuit below, the 3.3 pin is left unconnected. The I2C pins, SDA (Serial Data) and SCL (Serial Clock), connect to pin A4 and pin A5 of Arduino. The module's VCC pin is connected to the Arduino's 5V supply pin. BMP180 modules from other manufacturers may require different connections. Boards with four or six pins are available in the market.

This example uses the SFE_BMP180 library from SparkFun that can be downloaded here. One of the two examples from the library (SFE_BMP180_example) is then executed. The output can be seen on the serial monitor.

SW-18010P Vibration Sensor Module

This module uses SW-18010P spring type vibration switch to detect vibration of the surrounding environment. It does not require a large amount of vibration to generate triggering effect. A green LED light on the module will turn on when the module is shaken or external force is applied to the sensor. Sensitivity is adjustable via the blue digital potentiometer.

In the circuit below, the module's digital pin D0 connects to the the Arduino's digital pin 12. Put it simply, pin 12 is used to detect the high and low level. The Arduino's built-in LED light will be activated when vibration is detected. Keep in mind that when there is no vibration, the output from the sensor is HIGH. The opposite applies when the sensor detects vibration.

int ledPin=13;
int sensorPin=12;
int sensorValue=0;
 
void setup ()
{
  pinMode(ledPin,OUTPUT) ;
  digitalWrite(ledPin,LOW);
  pinMode(sensorPin,INPUT) ;
}
 
void loop ()
{
  sensorValue=digitalRead(sensorPin);
  if(sensorValue==HIGH)
  {
    digitalWrite(ledPin,LOW);
  }
  else
  {
    digitalWrite(ledPin,HIGH);
  }  
}

KY-038 Sound Detection Module

Designed for sound detection, the KY-038 is equipped with an electret microphone. The connections of the module is straightforward. It only has four pins that include + , G, A0 (Analog), and D0 (Digital). There are two red LEDs on the module, one for power and the other will light up when sound reaches a certain value.

In the circuit below, only the analog pin connects to the Arduino. The KY-038 seems to have low sensitivity. The potentiometer on the module is utilized to adjust the sensitivity of the sensor. The default sensor value (when everything is quiet) is 500. This makes it more responsive to the incoming signals. When signal comes above 550 or below 500, the value will be displayed on the serial monitor. The second red LED on the module will also illuminate.

int sensorPin = A0;
int sensorValue = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  sensorValue = analogRead(sensorPin);    
  if(sensorValue>550){
    Serial.println(sensorValue);
  }
  if(sensorValue<500){
    Serial.println(sensorValue);
  }
  //delay(100);
}

YL-69 Soil Moisture Sensor

The YL-69 (Probes) and the YL-38 (Interface) both make up a resistance sensor that is often used to measure soil moisture. The YL-38 acts as a middle man circuit or a bridge that connects the YL-69 sensor to the Arduino. It is fitted with a commonly used comparator LM393 and a digital potentiometer that can be used to alter the sensitivity of the sensor. There are four pins on the board that includes VCC (3.3/5V), GND, D0 (Digital Output) and A0 (Analog Output).

The digital output only produces HIGH or LOW value. In the circuit below, only the analog output is used in order to get a more accurate value. It connects to the Arduino analog input (A0). When the soil is dry, the resistance between the two electrodes or the sensor probes is high, the A0 port of the YL-38 bridge outputs a high level. When the two electrodes are in contact with water, more current will be passed across them. The analog port of the bridge produces low.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

void setup() { Serial.begin(9600); pinMode(A0, INPUT); } void loop() { int A0Value = analogRead(A0); Serial.print(A0Value); Serial.print(" - "); if(A0Value < 1000 && A0Value >= 700) { Serial.println("Dry soil"); } if(A0Value < 700 && A0Value >= 300) { Serial.println("Humid soil"); } if(A0Value < 300) { Serial.println("In water"); } delay(1000); }

HC-SR04 Ultrasonic Sensor

The HC-SR04 is a simple module that is often used in distance measurement projects. It can detect objects up to 4 meters. The minimum detection range is 2 cm. The sensor has a relatively narrow beam angle of 15 degrees and an accuracy of 2 mm. One of the great things about the HC-SR04 is as it utilizes ultrasonic sound (sonar) instead of light to operate, its performance is not affected by sun ray.

The module has four pin connections (VCC, Trigger, Echo, and GND). It can be powered from a 5V DC supply. The working current of the HC-SR04 is 15 mA. The HC-SR04 is an ultrasonic transmitter and receiver sensor all in one. When the Trigger pin is given a HIGH pulse of at least 10 microseconds and there is an object within range, the Echo pin on the sensor will go from LOW to HIGH for a certain period. From here, the echo duration is used to calculate distance to the object.

In the example below, the HC-SR04 will activate one of the three LED lights based on the distance between the sensor and the object. If the calculated distance is over 100 cm, the green light illuminates. When the object gets closer (50-100 cm), the yellow light will turn on. Closer than that, the red light will come on. Three 330 ohm resistors limit the current flowing through the LEDs.

const int triggerPin=12;
const int echoPin=11;

const int greenledPin=10;
const int yellowledPin=9;
const int redledPin=8;

long duration;
int distance;

void setup() {
  pinMode(triggerPin,OUTPUT);
  pinMode(echoPin,INPUT);
  pinMode(greenledPin,OUTPUT);
  pinMode(yellowledPin,OUTPUT);
  pinMode(redledPin,OUTPUT);
}

void loop() {
   //Reset the Trigger pin to ensure a clean HIGH pulse.
  digitalWrite(triggerPin,LOW); 
  delayMicroseconds(2);

  //Start a ping by providing HIGH pulse on the Trigger pin for 10µs.
  digitalWrite(triggerPin,HIGH); 
  delayMicroseconds(10);
  digitalWrite(triggerPin,LOW); 

  //Gets the echo duration.
  duration=pulseIn(echoPin,HIGH);

  //duration is converted into distance
  //Speed of sound in air = 340 m/s = 0.034 cm/µs => 29.412 µs/cm
  //The result is divided by 2 as the sound travels back and forth 
  distance=(duration/2)/29.412;
  
  if(distance<=100&&distance>=50){
    digitalWrite(redledPin,LOW);
    digitalWrite(yellowledPin,HIGH);
    digitalWrite(greenledPin,LOW);
  }
  if(distance<50&&distance>=0){
    digitalWrite(redledPin,HIGH);
    digitalWrite(yellowledPin,LOW);
    digitalWrite(greenledPin,LOW);
  }
  if(distance>100||distance<0){
    digitalWrite(redledPin,LOW);
    digitalWrite(yellowledPin,LOW);
    digitalWrite(greenledPin,HIGH);
  }
  delay(1000);
}