How to build a very cheap but full featured Sound Card Oscilloscope Build Better Electronics Projects By: Steve Garratt

Arduino Distance Sensor Software Sketch Part 2

<< Arduino Distance Sensor

Darlington Transistor Touch Switch Simple Science Project

<< Previous First 2 Last

Arduino Distance Sensor Software Sketch Update

Click to get the full project details by subscribing free to HDE Magazine.

This is an update to the software sketch for the Arduino Distance Sensor Project. You should build the hardware described first before loading the software.

Copy the code sketch below, paste it into your Arduino programming software and load it into your Arduino to run the distance sensor and motion detector project.

If you haven't done already you may also also need to download the timerOne library from https://code.google.com/p/arduino-timerone/downloads/detail?name=TimerOne-v9.zip&can=2&q=

Install the library using the guide https://arduino.cc/en/Guide/Libraries

/*******************************************************
 
arduino_distance_sensor_2
Arduino Uno + 2 x 16 LCD display + HC-SR04

Displays echos from an HC-SR04 ultrasonic distance finder
on the LCD.

13th Jan 2014
********************************************************/
#include <LiquidCrystal.h>                            // LCD module
#include <TimerOne.h>                                 // Header file for TimerOne library
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);                  // select the pins used on the LCD panel
 
// define some values used by the panel and buttons
#define trigPin 12                                    // Pin 12 trigger output
#define echoPin 2                                     // Pin 2 Echo input
#define echo_int 0                                    // Interrupt id for echo pulse
                                                      // Define constants for button presses
#define btnRIGHT  0                                   // Right
#define btnUP     1                                   // Up
#define btnDOWN   2                                   // Down
#define btnLEFT   3                                   // Left
#define btnSELECT 4                                   // Select
#define btnNONE   5                                   // None. No button pressed

#define TIMER_US 50                                   // 50 uS timer duration 
volatile int tick_counts = 4000;                      // define 200mS between trigger pulses
volatile int trigger_time_count = 0;                  // Count down counter to trigger pulse time
int display_mode = 0;                                 // Determine what the display does

volatile long echo_start = 0;                         // Records start of echo pulse 
volatile long echo_end = 0;                           // Records end of echo pulse
volatile long echo_duration = 0;                      // Duration - difference between end and start

#define RANGES 16                                     // Number of ranges
#define MAX_ZONE 18000                                // The last (maximum) zone range in uS
int zones[RANGES];                                    // Array to contain the zone values for each range
volatile int range_hits[RANGES];                      // Array of recent zone hit counts

volatile int range_cm;                                // The distance detected in centimeters

// Define the special characters that will form vertical bar graph lcd charcters
byte bar0[8] = {B00000, B00000, B00000, B00000, B00000, B00000, B00000, B11111};
byte bar1[8] = {B00000, B00000, B00000, B00000, B00000, B00000, B11111, B11111};
byte bar2[8] = {B00000, B00000, B00000, B00000, B00000, B11111, B11111, B11111};
byte bar3[8] = {B00000, B00000, B00000, B00000, B11111, B11111, B11111, B11111};
byte bar4[8] = {B00000, B00000, B00000, B11111, B11111, B11111, B11111, B11111};
byte bar5[8] = {B00000, B00000, B11111, B11111, B11111, B11111, B11111, B11111};
byte bar6[8] = {B00000, B11111, B11111, B11111, B11111, B11111, B11111, B11111};
byte bar7[8] = {B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111};

// Define the special characters that will form horizontal bargraph lcd charcters
byte sbar0[8] = {B00000, B00000, B00000, B00000, B00000, B00000, B00000, B00000};
byte sbar1[8] = {B10000, B10000, B10000, B10000, B10000, B10000, B10000, B10000};
byte sbar2[8] = {B11000, B11000, B11000, B11000, B11000, B11000, B11000, B11000};
byte sbar3[8] = {B11100, B11100, B11100, B11100, B11100, B11100, B11100, B11100};
byte sbar4[8] = {B11110, B11110, B11110, B11110, B11110, B11110, B11110, B11110};
byte sbar5[8] = {B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111};

// --------------------------
// setup() 
// Initialize i/o pins.
// Initialize the timer and attach interrupt.
// Attach interrupt to echo input.
// Initialize the LCD.
// Initialize the serial monitor.
// Create the range_hits[] array.
// Start initial display mode.
// --------------------------
void setup()
{
  int i, zone_diff;
  
  pinMode(trigPin, OUTPUT);                           // Trigger pin set to output
  pinMode(echoPin, INPUT);                            // Echo pin set to input
  
  Timer1.initialize(TIMER_US);                        // Initialise timer 1
  Timer1.attachInterrupt(timerIsr);                   // Attach interrupt to the timer service routine 
  attachInterrupt(echo_int, echo_interrupt, CHANGE);  // Attach interrupt to the sensor echo input

lcd.begin(16, 2);                                   // start the LCD library
  Serial.begin (9600);                                // Initialise the serial monitor output
  
  zone_diff = (MAX_ZONE / RANGES);                    // Size of a distance zone
  for (i = 0; i < RANGES ; i++)                       
  {
     range_hits[i] = 0;                               // initialise the hits array
     zones[i] = zone_diff * (i + 1);                  // Create an array of distance zones
  }

setup_display_cm_mode();                            // Initialise display mode
}

// --------------------------
// loop() 
// Main loop. 
// Keypad buttons are serviced every 50mS.
// Display is updated every 500mS.
// --------------------------
void loop()
{
  static unsigned long print_timer = 0;               // For scheduling LCD updates
  static unsigned long button_timer = 0;              // For scheduling button polling
  int lcd_key     = 0;
  int i;

if ((millis() - button_timer) > 50)                 // Is it time to check the buttons?
  {
    button_timer = millis();                          // Reset the timer
    do_button_input();                                // Handle user input on buttons
  }
  
  if ((millis() - print_timer) > 500)                 // Is it time to update the display?
  {
    print_timer = millis();                           // Reset the timer

switch(display_mode)                              // Call one of the display routines
    {                                                 // depending on the mode.
      case 0:
        display_bar_distance_cm();                    // Histogram + distance in cm
        break;
      case 1:
        display_histogram();                         // Histogram + scale
        break;
      case 2:
        display_line_distance_cm();                  // Line + distance in cm
        break;
    }
  }
}

// --------------------------
// clear_display() Clear the display.
// --------------------------
void clear_display()
{
  char* blank = "                ";
  lcd.setCursor(0, 0);                                // Clear the bottom row;
  lcd.print(blank);                      
  lcd.setCursor(0, 1);                                // Clear the bottom row;
  lcd.print(blank);                      
}

// --------------------------
// create_bargraph_characters() Create the LCD bargraph characters.
// --------------------------
void create_bargraph_characters()
{
  lcd.createChar(0, bar0);                            // Create 8 LCD characters to use
  lcd.createChar(1, bar1);                            // as character sized bargraphs
  lcd.createChar(2, bar2);
  lcd.createChar(3, bar3);
  lcd.createChar(4, bar4);
  lcd.createChar(5, bar5);
  lcd.createChar(6, bar6);
  lcd.createChar(7, bar7);
}

// --------------------------
// create_side_bargraph_characters() Create sideways LCD bargraph characters.
// --------------------------
void create_side_bargraph_characters()
{
  lcd.createChar(0, sbar0);                           // Create 6 LCD characters to use
  lcd.createChar(1, sbar1);                           // as character sized bargraphs
  lcd.createChar(2, sbar2);
  lcd.createChar(3, sbar3);
  lcd.createChar(4, sbar4);
  lcd.createChar(5, sbar5);
}

// --------------------------
// setup_histogram_mode() Initialise for histogram mode.
// --------------------------
void setup_histogram_mode()
{
  create_bargraph_characters();                       // Create LCD mini bargraphs
  lcd.setCursor(0, 1);                                // Print the scale on the bottom
  lcd.print(0);                                       // row of the LCD.
  lcd.setCursor(6, 1);
  lcd.print(150);
  lcd.setCursor(13, 1);
  lcd.print(300);
}

// --------------------------
// setup_display_cm_mode() Initialise for centimeter distance mode.
// --------------------------
void setup_display_cm_mode()
{
  create_bargraph_characters();                        // Create LCD mini bargraphs
}

// --------------------------
// setup_line_cm_mode() Initialise for centimeter line distance mode.
// --------------------------
void setup_line_cm_mode()
{
  create_side_bargraph_characters();                    // Create LCD vertical line graph characters
}

// --------------------------
// display_histogram() Display the echo data in the range_hits[] array
// as a series of 16 bargraphs.
// --------------------------
void display_histogram()
{
  int i;

for (i = 0; i < RANGES; i++)                        // Print each zone as a character bar code
   {
     lcd.setCursor(i, 0);                              // Set the cursor at the start of the top line
 
     switch (range_hits[i])                            // The number of hits in each zone or range
     {                                                 // determines the height of the bargraph
        case 1:                                        // The range values are 0 - 10
          lcd.write(byte(1));                          // The characters have 7 rows
          break;
        case 2:
          lcd.write(byte(2));
          break;
        case 3:
          lcd.write(byte(3));
          break;
        case 4:
          lcd.write(byte(4));
          break;
        case 5:
          lcd.write(byte(5));
          break;
        case 6:
          lcd.write(byte(6));
          break;
        case 7:
          lcd.write(byte(6));
          break;
        case 8:
          lcd.write(byte(7));
          break;
        case 9:
          lcd.write(byte(7));
          break;
        case 10:
          lcd.write(byte(7));
          break;
        default:
          lcd.write(byte(0));
          break;
     }
   }   
}

// --------------------------
// display_distance_cm() 
// Display the echo distance in centimetres.
// --------------------------
void display_distance_cm()
{
  int range = range_cm;                           // Save range in case it changes
  
  if (range > 999) range = 999;                   // Limit the value to 3 digits
  
  lcd.setCursor(0, 1);                            // Set the cursor at the start of the bottom line
  lcd.print("Distance: ");                        // Print the label
  lcd.print(range);                               // The range in centimeters
  lcd.print("cm");                                // Now the units
  
  if (range < 10)                                 // Print an appropriate number of
  {                                               // spaces to clear to end of line.
    lcd.print("   ");                             // The number of spaces varies with the
  }                                               // length of the printed number value.
  else
  {
    if (range < 100) 
    {
      lcd.print("  ");
    }
    else
    {
      lcd.print(" ");
    }
  }
}

// --------------------------
// display_bar_distance_cm() 
// Display the echo distance data and the histogram
// --------------------------
void display_bar_distance_cm()
{
  display_histogram();                           // Display the histogram on the top line
  display_distance_cm();                         // Display distance value on the bottom line
}

// --------------------------
// display_line_distance() 
// Display the echo as a single horizontal bar.
// --------------------------

void display_line_distance()
{
  int range = range_cm;                           // Save range in case it changes
  int range_px;                                   // Range in horizontal pixels 
  int full_chars;                                 // Number of full characters to display
  int part_char;                                  // Value of the end part character 
  int i;                   
  int max_range_cm = 320;                         // Maximum centimetres to display
  int display_px_length = 80;                     // Length of the bar in pixels
  int char_px_length = 5;                         // Number of pixels per character
  
  if (range > max_range_cm) range = max_range_cm; // Limit the value to fit the display
                                                  // Calculate the number of pixels to light
  range_px = (range * display_px_length) / max_range_cm;
  full_chars = range_px / char_px_length;        // Calculate number of complete characters
  
  lcd.setCursor(0, 1);                            // Set the cursor at the start of the top line
  for (i = 0; i < full_chars; i++)                // Print fully populated pixels on left most   
  {                                               // full_chars.
    lcd.setCursor(i, 0);                          // Set the cursor on the top line
    lcd.write(byte(5));                           // All pixels on.
  }
  
  part_char = range_px % char_px_length;          // Calculate the part character value
  lcd.setCursor(i, 0);                            // Set the cursor to the end of the full characters.
  lcd.write(byte(part_char));                     // Select the special char and write it to the display.
  i++;

for (; i < 16; i++)                             // Fill the remainder of the line with spaces.
  {
    lcd.setCursor(i, 0);                          // Set the cursor
    lcd.print(" ");                               // Print a space.
  }
}

// --------------------------
// display_line_distance_cm() 
// Display the horizontal echo bar on the top line
// with the distance value on the bottom.
// --------------------------
void display_line_distance_cm()
{
  display_line_distance();                        // Print the horizontal bar.
  display_distance_cm();                          // Print the distance value.
}
 
// --------------------------
// timerIsr() 50uS second interrupt ISR()
// Called every time the hardware timer 1 times out.
// --------------------------
void timerIsr()
{
    trigger_pulse();                              // Schedule the trigger pulses
}

// --------------------------
// trigger_pulse() called every 50 uS to schedule trigger pulses.
// Generates a pulse one timer tick long.
// Minimum trigger pulse width for the HC-SR04 is 10 us. This system
// delivers a 50 uS pulse.
// --------------------------
void trigger_pulse()
{
      static volatile int state = 0;                 // State machine variable

if (!(--trigger_time_count))                   // Count to 200mS
      {                                              // Time out - Initiate trigger pulse
         trigger_time_count = tick_counts;           // Reload
         
         if (digitalRead(echoPin) == LOW)           // Skip trigger if echo high
         {
           state = 1;                                // Changing to state 1 initiates a pulse
         }
      }
    
      switch(state)                                  // State machine handles delivery of trigger pulse
      {
        case 0:                                      // Normal state does nothing
            break;
        
        case 1:                                      // Initiate pulse
           digitalWrite(trigPin, HIGH);              // Set the trigger output high
           state = 2;                                // and set state to 2
           break;
        
        case 2:                                      // Complete the pulse
        default:      
           digitalWrite(trigPin, LOW);               // Set the trigger output low
           state = 0;                                // and return state to normal 0
           break;
     }
}

// --------------------------
// echo_interrupt() External interrupt from HC-SR04 echo signal. 
// Called every time the echo signal changes state.
//
// Note: this routine does not handle the case where the timer
//       counter overflows which will result in the occassional error.
// --------------------------
void echo_interrupt()
{
  int i;
  int found_hit;
  
  switch (digitalRead(echoPin))                     // Test to see if the signal is high or low
  {
    case HIGH:                                      // High so must be the start of the echo pulse
      echo_end = 0;                                 // Clear the end time
      echo_start = micros();                        // Save the start time
      break;
      
    case LOW:                                       // Low so must be the end of the echo pulse
      echo_end = micros();                          // Save the end time
      echo_duration = echo_end - echo_start;        // Calculate the echo duration
            
      found_hit = RANGES - 1;                       // Default the last zone 
      for(i = 0; i < RANGES - 1; i++)               // Determine the zone for this measurement 
      {
         if ((echo_duration < zones[i]))
         {
           found_hit = i;                           // zone 'found_hit' found
           break;
         }
      }
      
      // Weight the zone corresponding to the distance measured and slowly reduce
      // the other zones.
      range_hits[found_hit] += 3;                   // Add to the isolated zone
      
      for(i = 0; i < RANGES; i++)                   
      {
        // Now decrement all the other zones
        if (i != found_hit)                         
        {
          range_hits[i]--;
        }
        
        // Stop the values going out of bounds
        if (range_hits[i] < 0)
        {
          range_hits[i] = 0;
        }
        
        if (range_hits[i] > 10)
        {
          range_hits[i] = 10;
        }
      }
     
       range_cm = echo_duration / 58;
       
      break;
  }
}

// --------------------------
// read_LCD_buttons() 
// Read the buttons on the LCD mini keypad.
// The buttons are all wired through resistors to an
// analog input channel so which button has been pressed
// can be determined by the value read from the input.
// 
// Note: It may be neccessary to calibrate the keypad input as
//       voltages on your board may differ from those used here.
 //      my buttons when read are centered at these valies: 0, 100, 250, 410, 640
 //      we add approx 50 to those values and check to see if we are close
// --------------------------
int read_LCD_buttons()
{
  int adc_key_in;
 
  adc_key_in = analogRead(0);                          // read the value from the sensor
  
  // Debug code - Uncomment this to send the key value to the serial monitor for calibration.
  /* *******************************
  Serial.println(adc_key_in);
  Debug code End **************** */
  
                                                       // Each key will read a different value.
  if (adc_key_in > 1000) return btnNONE;               // 1st option for speed reasons since it will be the most likely result.
 
  if (adc_key_in < 50)   return btnRIGHT; 
  if (adc_key_in < 150)  return btnUP;
  if (adc_key_in < 300)  return btnDOWN;
  if (adc_key_in < 460)  return btnLEFT;
  if (adc_key_in < 690)  return btnSELECT; 
 
  return btnNONE;                                      // when all others fail, return this...
}

// --------------------------
// do_button_input() 
// Read the buttons on the LCD mini keypad.
// Determine and take appropriate action.
// The buttons are debounced using a simple finite state
// machine which requires the routine to be called frequently.
//
// The debug code prints the state transitions to the serial monitor.
// --------------------------
void do_button_input()
{
  static int button_state = 0;                         // Initialise the state machine to state 0
  int button_down;
  
  button_down = read_LCD_buttons();                    // Read the keypad
  
  switch(button_state)                                 // Begin the finite state machine key debouncer
  {
    case 0:                                            // 0 Normal or idle state. No buttons being pressed.
      if (button_down == btnSELECT)
      {                                                // SELECT button down.
        //* Debug code ********************
        Serial.println("button_state 0 => 1");
        //Debug code End **************** */
        button_state = 1;                              // Go to state 1 to begin the debounce
      }
      break;
      
    case 1:                                            // 1 SELECT was down on the previous call.
      if (button_down == btnSELECT)                    // Is it still down?
      {                                                // Yes, change mode.
        if(++display_mode > 2)
        {
          display_mode = 0;
        }
        
       clear_display();                                  // Clear the display
       
       switch(display_mode)                              // Change to selected mode
       {
          case 0:      
            setup_display_cm_mode();
            break;
          case 1:
            setup_histogram_mode();
            break;
          case 2:
            setup_line_cm_mode();
            break;
       }
        
        //* Debug code ********************
        Serial.print("SELECT DETECTED button_state 1 => 2 display_mode = ");
        Serial.println(display_mode);
        //Debug code End **************** */
      }
      else
      {
        //* Debug code ********************
        Serial.println("BOUNCED button_state 1 => 2");
        //Debug code End **************** */
      }

button_state = 2;                                  // Go to state 2 to wait for no button down
      break;
      
    case 2:                                              // 2 Waiting for btnNONE ensures no further action
      if (button_down == btnNONE)                        // until the button is released and pushed again.
      {
        //* Debug code ********************
        Serial.println("Reset button_state 2 => 0");
        //Debug code End **************** */
        button_state = 0;
      }
      break;
  }
}

Arduino Distance Sensor Part 2 Code Description

<< Previous First 2 Last

Now subscribe to our newsletter and don't miss a thing