IETian Arun

State exchange Detection (part Detection) for pushbuttons

2020-05-06T13:50:00.001+05:30

Country exchange Detection (part Detection) for pushbuttons
As soon as you have got a pushbutton running, you frequently want to do a little motion primarily based on how frequently the button is driven. To try this, you want to know whilst the button adjustments state from off to on, and remember how usually this change of state occurs. That is called country change detection or facet detection. In this academic we discover ways to test the state trade, we send a message to the Serial display with the applicable facts and we depend four state modifications to turn on and off an LED.

Hardware Required
Arduino or Genuino Board
Non permanent button or switch
10k ohm resistor
Hook-up wires
Breadboard
Circuit

Join three wires to the board. The primary goes from one leg of the pushbutton through a pull-down resistor (right here 10k ohm) to floor. The second is going from the corresponding leg of the pushbutton to the 5 volt deliver. The 0.33 connects to a digital I/O pin (right here pin 2) which reads the button's state.

Whilst the pushbutton is open (unpressed) there may be no connection among the two legs of the pushbutton, so the pin is connected to ground (via the pull-down resistor) and we read a LOW. While the button is closed (pressed), it makes a connection among its legs, connecting the pin to voltage, in order that we read a high. (The pin is still connected to ground, however the resistor resists the float of cutting-edge, so the path of least resistance is to +5V.)

If you disconnect the virtual I/O pin from the whole thing, the LED may blink inconsistently. This is because the input is "floating" - that is, now not linked to either voltage or floor. It will extra or less randomly return either excessive or LOW. That is why you want a pull-down resistor inside the circuit.

Schematic

Code
The cartoon beneath always reads the button's kingdom. It then compares the button's nation to its nation the closing time thru the principle loop. If the cutting-edge button state isn't like the last button nation and the contemporary button nation is high, then the button changed from off to on. The sketch then increments a button push counter.

The caricature additionally assessments the button push counter's cost, and if it's an even more than one of 4, it turns the LED on pin 13 ON. Otherwise, it turns it off.

/*
state alternate detection (aspect detection)

regularly, you do not need to realize the kingdom of a digital enter all of the time,
but you simply need to recognize while the enter changes from one country to every other.
As an example, you want to recognize when a button goes from OFF to ON. That is called
state alternate detection, or edge detection.

This example suggests a way to locate while a button or button changes from off to on
and on to off.

The circuit:
* pushbutton connected to pin 2 from +5V
* 10K resistor attached to pin 2 from floor
* LED connected from pin 13 to floor (or use the integrated LED on
maximum Arduino forums)

created 27 Sep 2005
modified 30 Aug 2011
with the aid of Tom Igoe

This example code is inside the public domain.

Http://www.Arduino.Cc/en/academic/ButtonStateChange

*/

// this consistent won't alternate:
Const int buttonPin = 2; // the pin that the pushbutton is attached to
Const int ledPin = thirteen; // the pin that the LED is hooked up to

// Variables will exchange:
Int buttonPushCounter = zero; // counter for the range of button presses
Int buttonState = 0; // contemporary country of the button
Int lastButtonState = 0; // previous state of the button

Void setup()
// initialize the button pin as a enter:
pinMode(buttonPin, input);
// initialize the LED as an output:
pinMode(ledPin, OUTPUT);
// initialize serial communique:
Serial.Begin(9600);

Void loop()
// examine the pushbutton enter pin:
buttonState = digitalRead(buttonPin);

// compare the buttonState to its preceding nation
if (buttonState != lastButtonState)
// if the kingdom has modified, increment the counter
if (buttonState == excessive)
// if the modern nation is high then the button
// wend from off to on:
buttonPushCounter++;
Serial.Println("on");
Serial.Print("quantity of button pushes: ");
Serial.Println(buttonPushCounter);
else
// if the modern-day kingdom is LOW then the button
// wend from on to off:
Serial.Println("off");

// delay a little bit to keep away from bouncing
postpone(50);

// save the modern-day nation because the ultimate nation,
//for next time thru the loop
lastButtonState = buttonState;

// turns on the LED each 4 button pushes by means of
// checking the modulo of the button push counter.
// the modulo feature offers you the remainder of
// the department of two numbers:
if (buttonPushCounter % four == zero)
digitalWrite(ledPin, excessive);
else
digitalWrite(ledPin, LOW);

How to make Line Follower Robot using Arduino

2020-04-26T16:26:00.000+05:30

How to make Arduino Line Follower Robot

A line follower robot, as the name suggests, is an automated guided vehicle, which follows a visual line embedded on the floor or ceiling. Typically, the visual line is the path in which the line follower robot goes and it will be a black line on a white surface but another path (a white line on a black surface) is also possible. Some advanced line follower robots use invisible magnetic fields as their paths.

Large line follower robots are commonly used in industries to aid the automated production process. They are also used in military applications, human support purposes, delivery services, etc.

The line follower robot is the first robot to get its first robotic experience with beginners and students. In this project, we have designed a simple line follower robot using Arduino and some other components.

Line Follower Robot 1

Line Follower Robot 2

Line Follower Robot 3

Line Follower Robot 4

How to make Arduino LFR (Line Follower Robot) : Essential components

   1. Arduino UNO (or Arduino Nano) [Buy Here]

    2.L293D Motor Driver IC [Buy Here]

    3. Gear x 2

    4. Robot Chassis

    5. IR sensor module x 2

    6. Black tape (electrical insulation tape)

    7. Connecting the wires

    8. Power Supply

    9. Battery Connector

    10.Battery

How to make Arduino Line Follower Robot : circuit diagram

Arduino Line Follower Robot Circuit

Note: We have used a prefabricated IR sensor module consisting of an IR LED and a photo diode. If you do not have it, we have explained how to make yourself.

Project block diagram

The line follower robot manufactured in this project is divided into 4 blocks. The following image depicts the block diagram for the line follower robot.

Block diagram description

Sensor (IR sensor): We have used the IR sensor module as a sensor detection line for the project. It consists of an IR LED and a photo diode and some other components like comparator, LED etc.

IR sensor module

As mentioned earlier, we have used the pre-assembled IR sensor. If you do not have one, you can make your own sensor using the following circuit.

IR Sencer

How to make Arduino Line Follower Robot : IR sensor circuit


IR Sencer Circuit

In this project the function of IR sensor and its scope will be explained in the actual work of line follower robot.

Controller (Arduino UNO): Arduino UNO is the main controller in the project. The data from the sensor (IR sensor) will be passed to the Arduino and it gives the corresponding signal to the motor driver IC.

Motor Driver (L293D): L293D Motor Driver IC is used in this project to drive robot motors. It receives signals from the Arduino based on the information from the IR sensor.

Note: The power supply to the motors must be supplied from the motor driver IC. Therefore, select the appropriate power supply that is sufficient for all components, including motors.

Motors (geared motor): We have used two geared motors behind the line follower robot. These motors provide more torque than normal motors and can also be used to lift some loads.

How to make Arduino Line Follower Robot: Working of Arduino Line Follower Robot

In this project, we have designed an Arduino based line follower robot. The project work is very simple: find the black line on the surface and move along that line. Detailed work is explained here.

As mentioned in the block diagram, we need a sensor to detect the line. For line detection logic, we used two IR sensors, which include IR LED and Photodiode. They are placed in a reflective manner i.e. side-by-side so that whenever they come in proximity to a reflective surface, the light emitted by the IR LED can be detected by the photo diode.

The following image shows the work of a specific IR sensor (IR LED - photodiode pair) in front of a light colored surface and a black surface. Since the reflectance of the light colored surface is high, the infrared light emitted by the IR LED will be reflected maximum and detected by the photodiode.

How to make Arduino Line Follower Robot

IR sensor working

In the case of black surface, which has low reflectance, light is completely absorbed by the black surface and does not reach the photodiode.

Using the same principle, we will setup the IR sensor on a line follower robot, such that two IR sensors are on either side of the black line on the floor. The setup is shown below.

In the IR follower line follower when the robot moves forward, both sensors wait for the line to be detected. For example, if the IR sensor in the above image detects 1 black line, it means that there is a forward right curve (or bend).

The Arduino UNO detects this change and sends the signal to the motorist accordingly. To turn right, the motor on the right of the robot is slowed down using PWM, while the motor on the left is driven at normal speed.

IR follower line follower in left right
Similarly, when the IR sensor 2 first detects the black line, it means that there is a forward left curve and the robot has to turn left. To turn the robot left, the motor on the left side of the robot is slowed down (or can be stopped completely or rotated in the opposite direction) and the motor on the right is driven at normal speed.

The Arduino UNO continuously monitors data from both sensors and turns on the robot according to the line they searched.

How to make Arduino Line Follower Robot: CODE

int mot1=9;
int mot2=6;
int mot3=5;
int mot4=3;

int left=13;
int right=12;

int Left=0;
int Right=0;

void LEFT (void);
void RIGHT (void);
void STOP (void);

void setup()
{
  pinMode(mot1,OUTPUT);
  pinMode(mot2,OUTPUT);
  pinMode(mot3,OUTPUT);
  pinMode(mot4,OUTPUT);

  pinMode(left,INPUT);
  pinMode(right,INPUT);

  digitalWrite(left,HIGH);
  digitalWrite(right,HIGH);
  
  
}

void loop() 
{
 
analogWrite(mot1,255);
analogWrite(mot2,0);
analogWrite(mot3,255);
analogWrite(mot4,0);

while(1)
{
  Left=digitalRead(left);
  Right=digitalRead(right);
  
  if((Left==0 && Right==1)==1)
  LEFT();
  else if((Right==0 && Left==1)==1)
  RIGHT();
}
}

void LEFT (void)
{
   analogWrite(mot3,0);
   analogWrite(mot4,30);
   
   
   while(Left==0)
   {
    Left=digitalRead(left);
    Right=digitalRead(right);
    if(Right==0)
    {
      int lprev=Left;
      int rprev=Right;
      STOP();
      while(((lprev==Left)&&(rprev==Right))==1)
      {
         Left=digitalRead(left);
         Right=digitalRead(right);
      }
    }
    analogWrite(mot1,255);
    analogWrite(mot2,0); 
   }
   analogWrite(mot3,255);
   analogWrite(mot4,0);
}

void RIGHT (void)
{
   analogWrite(mot1,0);
   analogWrite(mot2,30);

   while(Right==0)
   {
    Left=digitalRead(left);
    Right=digitalRead(right);
    if(Left==0)
    {
      int lprev=Left;
      int rprev=Right;
     STOP();
      while(((lprev==Left)&&(rprev==Right))==1)
      {
         Left=digitalRead(left);
         Right=digitalRead(right);
      }
    }
    analogWrite(mot3,255);
    analogWrite(mot4,0);
    }
   analogWrite(mot1,255);
   analogWrite(mot2,0);
}
void STOP (void)
{
analogWrite(mot1,0);
analogWrite(mot2,0);
analogWrite(mot3,0);
analogWrite(mot4,0);
  
}

Note:

To increase the efficiency of black line detection, the number of sensors can be increased. An array of sensors would be more accurate than just two sensors.

In this project (where two sensors are used), the position of the sensor is very important. The width of the black line plays a major role in the placement of the sensor.

Sensors can also be constructed for line detection using an LED and LDR pair.

Line follower robot applications

Line follower robots are commonly used for automation processes in industries, military applications, and consumer applications.

They are very useful as they can operate without any supervision i.e. they operate as automatic guided vehicles.

Line follower robots can be used in driverless cars, with additional features such as obstacle avoidance and other safety measures.

Bare Minimum

2020-04-26T12:09:00.000+05:30

This example contains the bare minimum of code you need for a sketch to compile properly on Arduino Software (IDE): the setup() method and the loop() method.

Hardware Required

Arduino or Genuino Board

Circuit

Only your Arduino or Genuino Board is needed for this example.

The setup() function is called when a sketch starts. Use it to initialize variables, pin modes, start using libraries, etc. The setup function will only run once, after each powerup or reset of the board.

After creating a setup() function, the loop() function does precisely what its name suggests, and loops consecutively, allowing your program to change and respond as it runs. Code in the loop() section of your sketch is used to actively control the board.

The code below won't actually do anything, but it's structure is useful for copying and pasting to get you started on any sketch of your own. It also shows you how to make comments in your code.

Any line that starts with two slashes (//) will not be read by the compiler, so you can write anything you want after it. The two slashes may be put after functional code to keep comments on the same line. Commenting your code like this can be particularly helpful in explaining, both to yourself and others, how your program functions step by step.
void setup() { // put your setup code here, to run once:
} void loop() { // put your main code here, to run repeatedly:

Fade Arduino

2020-04-26T12:08:00.000+05:30

This example demonstrates the use of the analogWrite() function in fading an LED off and on. AnalogWrite uses pulse width modulation (PWM), turning a digital pin on and off very quickly with different ratio between on and off, to create a fading effect.

Hardware Required

Arduino or Genuino board
LED
220 ohm resistor
hook-up wires
breadboard

Circuit

Connect the anode (the longer, positive leg) of your LED to digital output pin 9 on your board through a 220 ohm resistor. Connect the cathode (the shorter, negative leg) directly to ground.

Schematic

After declaring pin 9 to be your ledPin, there is nothing to do in the setup() function of your code.

The analogWrite() function that you will be using in the main loop of your code requires two arguments: One telling the function which pin to write to, and one indicating what PWM value to write.

In order to fade your LED off and on, gradually increase your PWM value from 0 (all the way off) to 255 (all the way on), and then back to 0 once again to complete the cycle. In the sketch below, the PWM value is set using a variable called brightness. Each time through the loop, it increases by the value of the variable fadeAmount.

If brightness is at either extreme of its value (either 0 or 255), then fadeAmount is changed to its negative. In other words, if fadeAmount is 5, then it is set to -5. If it's -5, then it's set to 5. The next time through the loop, this change causes brightness to change direction as well.

analogWrite() can change the PWM value very fast, so the delay at the end of the sketch controls the speed of the fade. Try changing the value of the delay and see how it changes the fading effect.

/*
 Fade

 This example shows how to fade an LED on pin 9
 using the analogWrite() function.

 The analogWrite() function uses PWM, so if
 you want to change the pin you're using, be
 sure to use another PWM capable pin. On most
 Arduino, the PWM pins are identified with
 a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.

 This example code is in the public domain.
 */

int led = 9;           // the PWM pin the LED is attached to
int brightness = 0;    // how bright the LED is
int fadeAmount = 5;    // how many points to fade the LED by

// the setup routine runs once when you press reset:
void setup() {
  // declare pin 9 to be an output:
  pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  // set the brightness of pin 9:
  analogWrite(led, brightness);

  // change the brightness for next time through the loop:
  brightness = brightness + fadeAmount;

  // reverse the direction of the fading at the ends of the fade:
  if (brightness <= 0 || brightness >= 255) {
    fadeAmount = -fadeAmount;
  }
  // wait for 30 milliseconds to see the dimming effect
  delay(30);

}

Digital Input Pullup Serial

2020-04-26T12:01:00.000+05:30

Digital Input Pullup Serial

This case demonstrates the use of INPUT_PULLUP with pinMode(). It monitors the nation of a transfer by organising serial communication between your Arduino and your computer over USB.

Additionally, when the input is excessive, the onboard LED attached to pin thirteen will switch on; whilst LOW, the LED will flip off.

Hardware Required
Arduino Board
A temporary transfer, button, or toggle switch
Breadboard
Hook-up cord
Circuit

Connect wires to the Arduino board. The black cord connects floor to 1 leg of the pushbutton. The second one cord is going from virtual pin 2 to the alternative leg of the pushbutton.

Pushbuttons or switches join factors in a circuit while you press them. While the pushbutton is open (unpressed) there's no connection between the 2 legs of the pushbutton. Because the internal pull-up on pin 2 is energetic and related to 5V, we examine excessive while the button is open. When the button is closed, the Arduino reads LOW due to the fact a connection to ground is finished.

Schematic

Code
In the program under, the very first thing which you do will inside the setup feature is to begin serial communications, at 9600 bits of facts in line with 2nd, among your Arduino and your pc with the road:


Serial.Begin(9600);

 

Next, initialize digital pin 2 as an enter with the internal pull-up resistor enabled:

PinMode(2,INPUT_PULLUP);

The subsequent line make pin thirteen, with the onboard LED, an output :

PinMode(thirteen, OUTPUT);

Now that your setup has been completed, circulate into the principle loop of your code. 

Whilst your button is not pressed, the inner pull-up resistor connects to 5 volts. 

This reasons the Arduino to record "1" or high. While the button is pressed, 

the Arduino pin is pulled to ground, inflicting the Arduino document a "0", or LOW.

The primary thing you want to do within the primary loop of your software is to establish 

a variable to keep the facts coming in out of your transfer. 

For the reason that statistics coming in from the transfer could be both a "1" or a "zero",

you may use an int datatype. Call this variable sensorValue, and set it to identical

anything is being examine on digital pin 2. You could accomplish all this with simply

one line of code:

 

Int sensorValue = digitalRead(2);

Once the Arduino has read the input, make it print this facts back to the computer as 

a decimal (DEC) price. You could do that with the command Serial.Println() in our ultimate

 line of code:

Serial.Println(sensorValue, DEC);

Now, while you open your Serial screen inside the Arduino environment, you may see a 

movement of "zero"s in case your transfer is closed, or "1"s in case your transfer is open.
The LED on pin thirteen will remove darkness from when the transfer is excessive, and

flip off while LOW.

 

 /* input Pullup Serial this situation demonstrates the usage of pinMode(INPUT_PULLUP).

 It reads a

virtual enter on pin 2 and prints the effects to the serial display.

  

The circuit:

 * non permanent switch attached from pin 2 to ground

* built-in LED on pin thirteen
in contrast to pinMode(enter), there may be no pull-down resistor important. An inner

20K-ohm resistor is pulled to 5V. This configuration causes the input to

study excessive when the transfer is open, and coffee when it's far closed.

Created 14 March 2012

by way of Scott Fitzgerald

 

http://www.Arduino.Cc/en/educational/InputPullupSerial
this situation code is within the public area */

 

Void setup()

  //begin serial connection

  Serial.Begin(9600);

  //configure pin2 as an input and enable the internal pull-up resistor

  pinMode(2, INPUT_PULLUP);

  pinMode(13, OUTPUT);

Void loop()

  //study the pushbutton fee into a variable

  int sensorVal = digitalRead(2);

  //print out the cost of the pushbutton

  Serial.Println(sensorVal);

  // keep in mind the pullup method the pushbutton's

  // common sense is inverted. It goes high when it's open,

  // and coffee whilst it's pressed. Turn on pin 13 while the

  // button's pressed, and off while it is now not:

  if (sensorVal == high)

    digitalWrite(thirteen, LOW);

   else

    digitalWrite(thirteen, high);

  postpone(30);

Denounce Arduino

2020-04-26T11:35:00.000+05:30

Pushbuttons frequently generate spurious open/near transitions while pressed, due to mechanical and physical issues: these transitions may be study as more than one presses in a very quick time fooling the program. This case demonstrates the way to debounce an enter, because of this checking twice in a quick time period to make certain the pushbutton is actually pressed. Without debouncing, pressing the button once may additionally purpose unpredictable consequences. This caricature uses the millis() feature to maintain track of the time surpassed because the button was pressed.

Hardware Required

Arduino or Genuino Board

Short-term button or switch

10k ohm resistor

Hook-up wires

Breadboard

Circuit

Schematic

Code

The cartoon beneath is based on Limor Fried's version of debounce, but the common sense is inverted from her example. In her example, the switch returns LOW while closed, and high while open. Right here, the switch returns high while pressed and coffee whilst no longer pressed.

Debounce

 each time the enter pin is going from LOW to high (e.G. Because of a push-button  press), the output pin is toggled from LOW to excessive or high to LOW.  There may be  a minimum postpone between toggles to debounce the circuit (i.E. To disregard  noise).  The circuit:  * LED attached from pin 13 to floor  * pushbutton connected from pin 2 to +5V  * 10K resistor connected from pin 2 to floor  * observe: On most Arduino forums, there's already an LED at the board
 related to pin 13, so that you do not want any greater components for this case.
 Created 21 November 2006
 via David A. Mellis  modified 30 Aug 2011
 by using Limor Fried
 changed 28 Dec 2012
 by Mike Walters
 modified 30 Aug 2016
 with the aid of Arturo Guadalupi


 this situation code is within the public domain.

 Http://www.Arduino.Cc/en/academic/Debounce
 */

// constants might not change. They're used right here to
// set pin numbers:
Const int buttonPin = 2;    // the quantity of the pushbutton pin
Const int ledPin = 13;      // the variety of the LED pin

// Variables will alternate:
Int ledState = high;         // the current nation of the output pin
Int buttonState;             // the present day analyzing from the enter pin
Int lastButtonState = LOW;   // the preceding studying from the enter pin

// the following variables are unsigned lengthy's due to the fact the time, measured in miliseconds,
// will speedy come to be a bigger variety than can be stored in an int.
Unsigned lengthy lastDebounceTime = zero;  // the ultimate time the output pin became toggled
Unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers

Void setup() 
  pinMode(buttonPin, input);
  pinMode(ledPin, OUTPUT);

  // set initial LED state
  digitalWrite(ledPin, ledState);


Void loop() 
  // study the country of the switch into a local variable:
  int studying = digitalRead(buttonPin);

  // take a look at to see in case you just pressed the button
  // (i.E. The input went from LOW to excessive),  and you've waited
  // long enough since the ultimate press to ignore any noise:

  // If the transfer modified, because of noise or pressing:
  if (studying != lastButtonState) 
    // reset the debouncing timer
    lastDebounceTime = millis();
  

  if ((millis() - lastDebounceTime) > debounceDelay) 
    // whatever the analyzing is at, it's been there for longer
    // than the debounce postpone, so take it as the real modern state:

    // if the button kingdom has modified:
    if (reading != buttonState) 
      buttonState = reading;

      // only toggle the LED if the brand new button country is excessive
      if (buttonState == excessive) 
        ledState = !LedState;
      
    
  

  // set the LED:
  digitalWrite(ledPin, ledState);

  // save the studying.  Next time thru the loop,
  // it will likely be the lastButtonState:
  lastButtonState = analyzing;

Blink LED Without Using Delay

2020-04-24T08:55:00.001+05:30

Sometimes you need to do two things at once. For example you might want to blink an LED while reading a button press. In this case, you can't use delay(), because Arduino pauses your program during the delay(). If the button is pressed while Arduino is paused waiting for the delay() to pass, your program will miss the button press.

This sketch demonstrates how to blink an LED without using delay(). It turns on the LED on and then makes note of the time. Then, each time through loop(), it checks to see if the desired blink time has passed. If it has, it toggles the LED on or off and makes note of the new time. In this way the LED blinks continuously while the sketch execution never lags on a single instruction.

An analogy would be warming up a pizza in your microwave, and also waiting some important email. You put the pizza in the microwave and set it for 10 minutes. The analogy to using delay() would be to sit in front of the microwave watching the timer count down from 10 minutes until the timer reaches zero. If the important email arrives during this time you will miss it.

What you would do in real life would be to turn on the pizza, and then check your email, and then maybe do something else (that doesn't take too long!) and every so often you will come back to the microwave to see if the timer has reached zero, indicating that your pizza is done.

In this tutorial you will learn how to set up a similar timer.

Hardware Required

Arduino or Genuino Board
LED
220 ohm resistor

Circuit

To build the circuit, connect one end of the resistor to pin 13 of the board. Connect the long leg of the LED (the positive leg, called the anode) to the other end of the resistor. Connect the short leg of the LED (the negative leg, called the cathode) to the board GND, as shown in the diagram above and the schematic below.

Most Arduino and Genuino boards already have an LED attached to pin 13 on the board itself. If you run this example with no hardware attached, you should see that LED blink.

Schematic

After you build the circuit plug your board into your computer, start the Arduino Software (IDE), and enter the code below.

Code

The code below uses the millis() function, a command that returns the number of milliseconds since the board started running its current sketch, to blink an LED.

/* Blink without Delay

 Turns on and off a light emitting diode (LED) connected to a digital
 pin, without using the delay() function.  This means that other code
 can run at the same time without being interrupted by the LED code.

 The circuit:
 * Use the onboard LED.
 * Note: Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
  it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
  the correct LED pin independent of which board is used.
  If you want to know what pin the on-board LED is connected to on your Arduino model, check
  the Technical Specs of your board  at https://www.arduino.cc/en/Main/Products

 created 2005
 by David A. Mellis
 modified 8 Feb 2010
 by Paul Stoffregen
 modified 11 Nov 2013
 by Scott Fitzgerald
 modified 9 Jan 2017
 by Arturo Guadalupi


 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/BlinkWithoutDelay
 */
// constants won't change. Used here to set a pin number :
const int ledPin =  LED_BUILTIN;// the number of the LED pin

// Variables will change :
int ledState = LOW;             // ledState used to set the LED

// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0;        // will store last time LED was updated

// constants won't change :
const long interval = 1000;           // interval at which to blink (milliseconds)

void setup() {
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the
  // difference between the current time and last time you blinked
  // the LED is bigger than the interval at which you want to
  // blink the LED.
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;

    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW) {
      ledState = HIGH;
    } else {
      ledState = LOW;
    }

    // set the LED with the ledState of the variable:
    digitalWrite(ledPin, ledState);  }

Use a push B button to Controlan LED

2020-04-24T08:55:00.000+05:30

Pushbuttons or switches connect two points in a circuit when you press them. This example turns on the built-in LED on pin 13 when you press the button.

Hardware Required

Arduino or Genuino Board
A momentary switch, button, or toggle switch
10k ohm resistor
hook-up wires
breadboard

Circuit

When the pushbutton is open (unpressed) there is no connection between the two legs of the pushbutton, so the pin is connected to ground (through the pull-down resistor) and we read a LOW. When the button is closed (pressed), it makes a connection between its two legs, connecting the pin to 5 volts, so that we read a HIGH.

You can also wire this circuit the opposite way, with a pullup resistor keeping the input HIGH, and going LOW when the button is pressed. If so, the behavior of the sketch will be reversed, with the LED normally on and turning off when you press the button.

If you disconnect the digital I/O pin from everything, the LED may blink erratically. This is because the input is "floating" - that is, it will randomly return either HIGH or LOW. That's why you need a pull-up or pull-down resistor in the circuit.

Schematic

/* Use a push B button to Controlan LED

 Turns on and off a light emitting diode(LED) connected to digital
 pin 13, when pressing a pushbutton attached to pin 2.

 The circuit:
 * LED attached from pin 13 to ground
 * pushbutton attached to pin 2 from +5V
 * 10K resistor attached to pin 2 from ground

 * Note: on most Arduinos there is already an LED on the board
 attached to pin 13.


 created 2005
 by DojoDave 

<http://www.0j0.org>
 modified 30 Aug 2011
 by Tom Igoe

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/Button
 */

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 2;     // the number of the pushbutton pin
const int ledPin =  13;      // the number of the LED pin

// variables will change:
int buttonState = 0;         // variable for reading the pushbutton status

void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);
}

void loop() {
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed.
  // if it is, the buttonState is HIGH:
  if (buttonState == HIGH) {
    // turn LED on:
    digitalWrite(ledPin, HIGH);
  } else {
    // turn LED off:
    digitalWrite(ledPin, LOW);
  }
}

Read Analog Voltage

2020-04-24T05:00:00.000+05:30

Read Analog Voltage

This example shows you how to read an analog input on analog pin 0, convert the values from analogRead() into voltage, and print it out to the serial monitor of the Arduino Software (IDE).

Hardware Required

Arduino or Genuino Board
10k ohm Potentiometer

Circuit

Connect the three wires from the potentiometer to your board. The first goes to ground from one of the outer pins of the potentiometer. The second goes to 5 volts from the other outer pin of the potentiometer. The third goes from the middle pin of the potentiometer to analog input 2.

By turning the shaft of the potentiometer, you change the amount of resistance on either side of the wiper which is connected to the center pin of the potentiometer. This changes the voltage at the center pin. When the resistance between the center and the side connected to 5 volts is close to zero (and the resistance on the other side is close to 10 kilohms), the voltage at the center pin nears 5 volts. When the resistances are reversed, the voltage at the center pin nears 0 volts, or ground. This voltage is the analog voltage that you're reading as an input.

The microcontroller of the board has a circuit inside called an analog-to-digital converter or ADC that reads this changing voltage and converts it to a number between 0 and 1023. When the shaft is turned all the way in one direction, there are 0 volts going to the pin, and the input value is 0. When the shaft is turned all the way in the opposite direction, there are 5 volts going to the pin and the input value is 1023. In between, analogRead() returns a number between 0 and 1023 that is proportional to the amount of voltage being applied to the pin.

Schematic

Code
In the program below, the very first thing that you do will in the setup function is to begin serial communications, at 9600 bits of data per second, between your board and your computer with the line:

 Serial.begin9600;

Next, in the main loop of your code, you need to establish a variable to store the resistance value (which will be between 0 and 1023, perfect for an int datatype) coming in from your potentiometer:

sensorValue = analogRead(A0);

To change the values from 0-1023 to a range that corresponds to the voltage the pin is reading, you'll need to create another variable, a float, and do a little math. To scale the numbers between 0.0 and 5.0, divide 5.0 by 1023.0 and multiply that by sensorValue :

voltage= sensorValue * (5.0 / 1023.0);

> Finally, you need to print this information to your serial window as. You can do this with the command Serial .println() in your last line of code:

Serial

.println(voltage) Now, when you open your Serial Monitor in the Arduino IDE (by clicking on the icon on the right side of the top green bar or pressing Ctrl+Shift+M), you should see a steady stream of numbers ranging from 0.0 - 5.0. As you turn the pot, the values will change, corresponding to the voltage coming into pin A0.
/*

 ReadAnalogVoltage
  Reads an analog input on pin 0, converts it to voltage, and prints the result to the serial monitor.
  Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
  Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.

  This example code is in the public domain.
*/
// the setup routine runs once when you press reset:
void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(9600);
}

// the loop routine runs over and over again forever:
void loop() {
  // read the input on analog pin 0:
  int sensorValue = analogRead(A0);
  // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
  float voltage = sensorValue * (5.0 / 1023.0);
  // print out the value you read:
  Serial.println(voltage);
  delay(100);

}

Digital Read Serial

2020-04-20T17:41:00.000+05:30

This example shows you how to monitor the state of a switch by establishing serial communication between your Arduino or Genuino and your computer over USB.

Hardware Required

Arduino or Genuino Board
A momentary switch, button, or toggle switch
10k ohm resistor
hook-up wires
breadboard

Circuit

Connect three wires to the board. The first two, red and black, connect to the two long vertical rows on the side of the breadboard to provide access to the 5 volt supply and ground. The third wire goes from digital pin 2 to one leg of the pushbutton . That same leg of the button connects through a pull-down resistor (here 10k ohm) to ground. The other leg of the button connects to the 5 volt supply.

Pushbuttons or switches connect two points in a circuit when you press them. When the pushbutton is open (unpressed) there is no connection between the two legs of the pushbutton, so the pin is connected to ground (through the pull-down resistor) and reads as LOW, or 0. When the button is closed (pressed), it makes a connection between its two legs, connecting the pin to 5 volts, so that the pin reads as HIGH, or 1.

If you disconnect the digital i/o pin from everything, the LED may blink erratically. This is because the input is "floating" - that is, it doesn't have a solid connection to voltage or ground, and it will randomly return either HIGH or LOW. That's why you need a pull-down resistor in the circuit.

Schematic

In the program below, the very first thing that you do will in the setup function is to begin serial communications, at 9600 bits of data per second, between your board and your computer with the line:

Serial.begin(9600)

;

Next, initialize digital pin 2, the pin that will read the output from your button, as an input:

pinMode(2,INPUT)

;> Now that your setup has been completed, move into the main loop of your code. When your button is pressed, 5 volts will freely flow through your circuit, and when it is not pressed, the input pin will be connected to ground through the 10k ohm resistor. This is a digital input, meaning that the switch can only be in either an on state (seen by your Arduino as a "1", or HIGH) or an off state (seen by your Arduino as a "0", or LOW), with nothing in between.

The first thing you need to do in the main loop of your program is to establish a variable to hold the information coming in from your switch. Since the information coming in from the switch will be either a "1" or a "0", you can use an int datatype. Call this variable sensorValue, and set it to equal whatever is being read on digital pin 2. You can accomplish all this with just one line of code:

int sensorValue = digitalRead(2);

Once the bord has read the input, make it print this information back to the computer as a decimal value. You can do this with the command Serial.println() in our last line of code:

int pushButton = 2;

void setup()

 {

 Serial.begin(9600);

  pinMode(pushButton, INPUT);

 }

 void loop()

 {

  int buttonState = digitalRead(pushButton);

  Serial.println(buttonState);

  delay(100);

}

Blink

2020-04-19T17:11:00.000+05:30

This example shows the simplest thing you can do with an Arduino or Genuino to see physical output: it blinks the on-board LED.

Hardware Required

Arduino or Genuino Board [optional]
LED
220 ohm resistor

Circuit

This example uses the built-in LED that most Arduino and Genuino boards have. This LED is connected to a digital pin and its number may vary from board type to board type. To make your life easier, we have a constant that is specified in every board descriptor file. This constant is LED_BUILTIN and allows you to control the built-in LED easily. Here is the correspondence between the constant and the digital pin.

If you want to lit an external LED with this sketch, you need to build this circuit, where you connect one end of the resistor to the digital pin correspondent to the LED_BUILTIN constant. Connect the long leg of the LED (the positive leg, called the anode) to the other end of the resistor. Connect the short leg of the LED (the negative leg, called the cathode) to the GND. In the diagram below we show an UNO board that has D13 as the LED_BUILTIN value.

The value of the resistor in series with the LED may be of a different value than 220 ohm; the LED will lit up also with values up to 1K ohm.

Schematic

After you build the circuit plug your Arduino or Genuino board into your computer, start the Arduino Software (IDE) and enter the code below. You may also load it from the menu File/Examples/01.Basics/Blink . The first thing you do is to initialize LED_BUILTIN pin as an output pin with the line

pinMode(LED_BUILTIN, OUTPUT);

In the main loop, you turn the LED on with the line:

digitalWrite(LED_BUILTIN, HIGH);

This supplies 5 volts to the LED anode. That creates a voltage difference across the pins of the LED, and lights it up. Then you turn it off with the line:

digitalWrite(LED_BUILTIN, LOW);

That takes the LED_BUILTIN pin back to 0 volts, and turns the LED off. In between the on and the off, you want enough time for a person to see the change, so the delay() commands tell the board to do nothing for 1000 milliseconds, or one second. When you use the delay() command, nothing else happens for that amount of time. Once you've understood the basic examples, check out the BlinkWithoutDelay example to learn how to create a delay while doing other things.

Once you've understood this example, check out the DigitalReadSerial example to learn how read a switch connected to the board
initialize digital pin LED_BUILTIN as an output.

void setup(){

pinMode(LED_BUILTIN, OUTPUT);

 }

//the loop function runs over and over again forever turn the LED on (HIGH is the voltage level)

void loop() { 

  digitalWrite(LED_BUILTIN, HIGH);

//wait for a second 

delay(1000);

//turn the LED off by making the voltage LOW

digitalWrite(LED_BUILTIN, LOW);

delay(1000);  }

Analog Read Serial

2020-04-18T19:12:00.001+05:30

This example shows you how to read analog input from the physical world using a potentiometer. A potentiometer is a simple mechanical device that provides a varying amount of resistance when its shaft is turned. By passing voltage through a potentiometer and into an analog input on your board, it is possible to measure the amount of resistance produced by a potentiometer (or pot for short) as an analog value. In this example you will monitor the state of your potentiometer after establishing serial communication between your Arduino or Genuino and your computer running the Arduino Software (IDE).

Hardware Required

Arduino or Genuino Board
10k ohm Potentiometer

Circuit

Connect the three wires from the potentiometer to your board. The first goes from one of the outer pins of the potentiometerto ground . The second goes from the other outer pin of the potentiometer to 5 volts. The third goes from the middle pin of the potentiometer to the analog pin A0.

By turning the shaft of the potentiometer, you change the amount of resistance on either side of the wiper, which is connected to the center pin of the potentiometer. This changes the voltage at the center pin. When the resistance between the center and the side connected to 5 volts is close to zero (and the resistance on the other side is close to 10k ohm), the voltage at the center pin nears 5 volts. When the resistances are reversed, the voltage at the center pin nears 0 volts, or ground. This voltage is the analog voltage that you're reading as an input.

The Arduino and Genuino boards have a circuit inside called an analog-to-digital converter or ADC that reads this changing voltage and converts it to a number between 0 and 1023. When the shaft is turned all the way in one direction, there are 0 volts going to the pin, and the input value is 0. When the shaft is turned all the way in the opposite direction, there are 5 volts going to the pin and the input value is 1023. In between, analogRead() returns a number between 0 and 1023 that is proportional to the amount of voltage being applied to the pin.

Schematic

Code
In the sketch below, the only thing that you do in the setup function is to begin serial communications, at 9600 bits of data per second, between your board and your computer with the command:

Serial.begin(9600);

int sensorValue = analogRead(A0);

Finally, you need to print this information to your serial monitor window. You can do this with the command Serial .println() in your last line of code:

Serial.println(sensorValue)

Now, when you open your Serial Monitor in the Arduino Software (IDE) (by clicking the icon that looks like a lens, on the right, in the green top bar or using the keyboard shortcut Ctrl+Shift+M), you should see a steady stream of numbers ranging from 0-1023, correlating to the position of the pot. As you turn your potentiometer, these numbers will respond almost instantly.

/*
  AnalogReadSerial
  Reads an analog input on pin 0, prints the result to the serial monitor.
  Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
  Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.

  This example code is in the public domain.
*/

void setup() {

   // initialize serial communication at 9600 bits per second:

Serial.begin(9600);
}

 
// the loop routine runs over and over again forever:

void loop() {

 // read the input on analog pin 0:

   int sensorValue = analogRead(A0);

 
  // print out the value you read:
  Serial.println(sensorValue);
  delay(100);

         // delay in between reads for stability

}

PIR Motion Sensor with Arduino

2020-03-26T16:17:00.002+05:30

In this project, we will learn about PIR Sensor and how can it be used as a Motion Sensor through the Arduino PIR Sensor Tutorial. By going through this project, you can understand how PIR Sensor works and how to hook up a PIR Sensor to Arduino.We have made a project using Arduino, PIR Sensor and GSM Module called GSM based Home Security System using Arduino. If you understand how a PIR Sensor works, then you can many such interesting projects and even more complex ones.

Overview

A PIR Sensor or a Passive Infrared Sensor is an electronic device that measures the infrared (IR) light emitted by the objects in its observable area. The term ‘Passive’ in the PIR Sensor indicates that the sensor actually doesn’t emit any infrared light but rather passively detects it that is emitted by its surrounding objects.
Everyobject, with its surface temperature greater than absolute zero i.e. -273⁰C emits heat in the form of infrared radiation. Humans cannot see this radiation as the radiations are in infrared wavelength.

PIR Sensor

A typical PIR Sensor looks like the one shown in the image below. To connect with external devices, it has only three pins namely VCC, Digital OUT (Data) and GND.

PIR Motion Sensor with Arduino

On the top of sensor board, there is a special type of lens called Fresnal Lens that is covering up the actual Pyroelectric Sensor. The job of the Fresnal Lens is to focus all the infrared radiation onto the pyroelectric sensor.

If you look at the back of the PIR Sensor board, the whole circuitry is housed there. The brain of the PIR Sensor Module is the BISS0001 PIR Motion Detector IC. Near this IC, we have two potentiometers, one for adjusting the Sensitivity and the other is for adjusting the delay time.
Using Sensitivity Adjust, you can control the range of field of view and in our sensor, it is up to 7 meters. Using the Delay Time Adjust, you can control the duration for which the Digital Out will stay HIGH when a moving object is detected.

How PIR Sensor works?

PIR Sensors are complicated than most other sensors. PIR Motion Sensor may seem simple when implemented as all you need to do is check for a HIGH signal on the Digital Out Pin of the Sensor whenever motion is detected.
But, internally, there is a lot going on and the input and output of the sensor are dependent on several variables.
The actual PIR Sensor i.e. the one which is covered with a lens, consists of two slots and both these slots are made up of IR Sensitive materials. Under normal condition where there is no movement in front of the sensor, both the slots in the Sensor detect same amount of infrared radiation.
When there is movement in front of the sensor, like a human or a cat, their radiation is interpreted by one of the slots first and the differential output between the two slots becomes positive.
As the person moves away, the second slot detects the radiation and the differential output will become negative. Based these output pulses, a motion is detected.

Testing the PIR Sensor

Since the Digital Out Pin of the PIR Sensor is either HIGH or LOW based on the movement detected, you can build a simple circuit to test the PIR Sensor.
The first circuit consists of a PIR Sensor and an LED. When the PIR Sensor detects motions, the LED turns ON. The duration for which the LED is ON can be adjusted with the help of Delay Adjust POT.

A similar PIR Sensor testing circuit is shown below but it consists of a buzzer. In order to drive the buzzer, an NPN Transistor like BC547 or 2N2222 can be used. The buzzer will be activated when the sensor detects any movement.

PIR Motion Sensor using Arduino

Let us make a small Motion Sensor or Motion Detector project using Arduino and PIR Sensor. In this project, the PIR Sensor detects any movement in front of it and signals Arduino. Whenever any movement is detected, Arduino will activate an alarm in the form of a Buzzer.
This circuit doesn’t implement a major design but gives an idea about how to interface a PIR Sensor to Arduino and how to can we Arduino to use the data from the PIR Sensor and drive other output devices or loads like relay, GSM Module, buzzer etc.

Components Required

Arduino UNO

PIR Sensor

5V Buzzer

Breadboard

Connecting Wires

Power Supply

Circuit Design

The design of the PIR Motion Sensor using Arduino is very simple. The PIR Sensor Module has three pins: VCC, Digital Out and GND. Connect VCC and GND to +5V and GND respectively. Then connect the Digital Out Pin of the PIR sensor to the digital I/O pin 2 of Arduino.
As we need to indicate the detection of motion by the sensor, connect a buzzer to Pin 3 of the Arduino.

NOTE: Buzzer is connected directly to Arduino. I suggest you to connect it through a transistor as shown in the test circuit.

CODE

	int sensor = 8; int buzzer = 11;
	int led = 13;
	void setup()
	{
	pinMode(buzzer, OUTPUT);
	pinMode(sensor, INPUT);
	pinMode(led, OUTPUT);

	digitalWrite(buzzer,LOW);
	digitalWrite(sensor,LOW);

	digitalWrite(led,LOW);

	while(millis()<13000)
	{
	digitalWrite(led,HIGH);
	delay(50);
	digitalWrite(led,LOW);
	delay(50);
	}
	digitalWrite(led,HIGH);

	}

	void loop()
	{
	if(digitalRead(sensor)==HIGH)
	{
	digitalWrite(buzzer,HIGH);
	delay(3000);
	digitalWrite(buzzer,LOW);
	while(digitalRead(sensor)==HIGH);
	}

	}

Working of Arduino PIR Sensor Motion Detector

The working of this project is very simple. When the system is powered on, the Arduino waits for the PIR Sensor to be calibrated. The calibration period is set to 10 seconds and during this time, there should be no movements in front of the PIR Sensor.
After the calibration, the PIR Sensor will be ready to detect any movement in front of it. If the PIR Sensor detects any movements, its Digital Out pin, which is connected to Pin 2 of Arduino will become HIGH.
Arduino will detect this HIGH Signal and activates the buzzer

Applications

Arduino PIR Sensor Interface can be implemented in a wide range of project but the important one is the Motion Detection System.

A variety of Home Security Systems can be implemented using Arduino and PIR Sensor.