Simple arduino HC-SR04 (HCSR04) distance detection using interrupts for low latency measurements

hcsr04.ino

#include <Arduino.h>
// Uses https://github.com/PaulStoffregen/TimerOne for sending on a regular interval
#include <TimerOne.h>

// ECHO pin, needs to be a pin that supports interrupts!
#define ULTRASONIC_PIN_INPUT      2
// TRIG pin, can be any output pin
#define ULTRASONIC_PIN_OUTPUT     3
// update interval, make sure to keep it above 20ms
#define ULTRASONIC_TIMER_US       50000 

// the time the pulse was sent
volatile long ultrasonic_echo_start = 0;
// the distance once it's been measured
volatile long ultrasonic_distance = 0;

void ultrasonicPulse(){
    // Sets the trigger on HIGH state for 10 micro seconds to send a series of pulses
    digitalWrite(ULTRASONIC_PIN_OUTPUT, HIGH);
    // blocks 10 microseconds from the interrupt, I think we'll live :)
    delayMicroseconds(10);
    // disable the sending again so we can wait for a response
    digitalWrite(ULTRASONIC_PIN_OUTPUT, LOW);
    // record the send time
    ultrasonic_echo_start = micros();
}

void ultrasonicEcho(){
    // don't do anything if no pulse has been sent
    if(ultrasonic_echo_start != 0){
        // calculate the distance by measuring how long it took to return the sound
        // The speed of sound is 343 m/s and we need half the time it took (since
        // the sound has to travel towards the object _AND_ back). So a single echo does
        // 1/(343/2) = 0.005831 seconds per meter
        ultrasonic_distance = (micros() - ultrasonic_echo_start) / 58;
        ultrasonic_echo_start = 0;
    }
}

void setup(){
    Serial.begin(115200);
  
    // set the echo pin to receive interrupts, on an arduino uno only pin 2 and 3 can link to interrupts
    pinMode(ULTRASONIC_PIN_INPUT, INPUT_PULLUP);
    pinMode(ULTRASONIC_PIN_OUTPUT, OUTPUT);
  
    // set the update interval for sending the trigger
    Timer1.initialize(ULTRASONIC_TIMER_US);
    // link the trigger function to the timer
    Timer1.attachInterrupt(ultrasonicPulse);
    // link the echo function to the echo pin
    attachInterrupt(digitalPinToInterrupt(ULTRASONIC_PIN_INPUT), ultrasonicEcho, RISING);
}

void loop() {
  Serial.print("Distance: ");
  Serial.println(ultrasonic_distance);
  delay(ULTRASONIC_TIMER_US / 1000);
}

Have you test the code and on which HW? Normally, HCR04 send back the pulse with on Echo pin, but what you coded is the delay time between Trigger rising and Echo rising.

I've tried it with this thing and it seemed to work fine: https://wiki.keyestudio.com/Ks0192_keyestudio_4WD_Bluetooth_Multi-functional_Car

I'm not ruling out that there are bugs though... but it seemed to work perfect for a distance range between ~20cm and 1.5m if I remember correctly.

Strangely, I get a constant 8cm distance when using this code. I ended up on this page because I had written my own version and was getting the 8cm issue. Our programs are nearly identical, so I copied yours to see if it worked better. Everything works perfectly fine if I don't use the pin interrupt and instead just use pulseIn during the timer interrupt, but of course that needlessly ties things up. I'll do some more digging tomorrow. Just figured I would mention it in case anybody has a similar problem in the future.

For good practice, add these three lines to the start of ultrasonicPulse() to clear the trigger pin.

    // Clears the trigger Pin
    digitalWrite(ULTRASONIC_PIN_OUTPUT, LOW);
    delayMicroseconds(2);

like so

void ultrasonicPulse(){
    // Clears the trigger Pin
    digitalWrite(ULTRASONIC_PIN_OUTPUT, LOW);
    delayMicroseconds(2);
    // Sets the trigger on HIGH state for 10 micro seconds to send a series of pulses
    digitalWrite(ULTRASONIC_PIN_OUTPUT, HIGH);
    // blocks 10 microseconds from the interrupt, I think we'll live :)
    delayMicroseconds(10);
    // disable the sending again so we can wait for a response
    digitalWrite(ULTRASONIC_PIN_OUTPUT, LOW);
    // record the send time
    ultrasonic_echo_start = micros();
}

Also, the echo is a falling edge (usually), unless the signal has been inverted, so

    attachInterrupt(digitalPinToInterrupt(ULTRASONIC_PIN_INPUT), ultrasonicEcho, RISING);

should be

    attachInterrupt(digitalPinToInterrupt(ULTRASONIC_PIN_INPUT), ultrasonicEcho, FALLING);

One other thing is that there is an assumption made in your code that the echo pin has risen HIGH, when you execute this line:

    ultrasonic_echo_start = micros();

Logically, it should have but it might not be the case.

Aiming to code the same functionality I found this conversation and I thank you for the examples.

I'd like to share my version of the code, where I don't use a timer for the trigger (maybe should be a good pratice...) but I try to improve the accuracy considering only the time between the two echo edges (anyway, the same goal could have been reached by compensating the offset).

#include <TimerInterrupt_Generic.h>

const int trigPin = 4;
const int echoPin = 3; //3x 3.3kOhm used to divide voltage
volatile bool echoFallen = false;
volatile unsigned long echoStart, echoEnd;
unsigned long duration;
unsigned int distance;

void setup(){
    Serial.begin(9600);
    pinMode(echoPin, INPUT);
    pinMode(trigPin, OUTPUT);
    attachInterrupt(digitalPinToInterrupt(echoPin), ultrasonicEcho, CHANGE);
}

void loop() {
  //send trigger
  ultrasonicTrig();
  //wait for falling edge
  if(echoFallen){
    duration = echoEnd - echoStart;
    //s = v*t, sound speed is 343 m/s, wave reaches object and comes back
    distance = .0343*(duration/2);
    //unset falling edge flag
    echoFallen = false;
  }
  //output
  Serial.print("Distance (cm): ");
  Serial.println(distance);
  delay(1000);
}

//trigger
void ultrasonicTrig(){
    //clear pin
    digitalWrite(trigPin, LOW);
    delayMicroseconds(2);
    //send pulse
    digitalWrite(trigPin, HIGH);
    delayMicroseconds(10);
    digitalWrite(trigPin, LOW);
}

//ISR
void ultrasonicEcho(){
  switch(digitalRead(echoPin)){
    case HIGH:
      echoStart = micros();
      break;
    case LOW:
      echoEnd = micros();
      //set falling edge flag
      echoFallen = true;
  }
}