Objectives:

1. Understand how an ultrasonic distance measurement sensor operates.
2. Learn how to capture and interpret trigger and echo signals using the Red Pitaya oscilloscope.
3. Correlate echo pulse width (or round-trip time) with the measured distance to an object.
4. Perform actual time measurements from the captured signals and calculate the corresponding distances.

• What is a Distance Measurement Sensor?
• Key Functions
• How It Works
• Key Concepts:
• What Is It Used For?
• Hardware Setup
• A. Components:
• B. Circuit Assembly:
• Main Setup & Waveforms
• Generate the Trigger Signal with Arduino
• Observe Echo Signal at Different Distances
• 1) No Object in Front
• 2) Object at 1 m
• 3) Object at 50 cm
• 4) Object at 10 cm
• Arduino Programming: Reading Distance Data
• Upgrade the Arduino Code to Read the Echo Signal
• Calculate Distance and Display It in the Serial Terminal
• Improving Accuracy with Calibration (Exercise)
• Steps
• Example Calibrated Code

What is a Distance Measurement Sensor?

A distance measurement sensor (often ultrasonic) sends out short bursts of sound waves at a frequency above human hearing. These waves reflect off objects and return to the sensor. By measuring how long it takes for the echo to come back, the sensor calculates distance based on the speed of sound.

Key Functions

• Trigger Pulse (Yellow Signal): A short, precise pulse that instructs the sensor to emit an ultrasonic burst.
• Echo Pulse (Green Signal): A returned signal whose duration (or the delay before it appears) indicates the distance of the detected object.

How It Works

1. The microcontroller (or circuit) sends a trigger pulse to start the sensor’s ultrasonic burst.
2. The ultrasonic wave travels outward, reflects off an object, and returns to the sensor.
3. The sensor outputs an echo pulse; its width or the delay from the trigger corresponds to the distance.

Key Concepts:

• Time-of-Flight: Distance

The time it takes for the ultrasonic pulse to travel to an object and back.

The distance is calculated using:

$$\text{Distance} = \frac{\text{Speed of Sound} \times \text{Time-of-Flight}}{2}$$

The division by 2 accounts for the pulse traveling to the object and then back to the sensor.

$$\text{Speed of sound v } \approx 340 \,\text{m/s}$$

What Is It Used For?

• Object Detection: Robots or drones use it to avoid collisions.
• Level Sensing: Monitors fluid levels in tanks or silos.
• Security Systems: Detects movement in restricted areas.
• Educational Projects: Demonstrates practical timing measurements and wave propagation.

Hardware Setup

A. Components:

• Ultrasonic Sensor (HC-SR04 or equivalent):A sensor that measures distance using ultrasonic waves.
• 10 kΩ Resistor (Optional):For signal conditioning, if needed.
• Arduino Uno
• Red Pitaya STEMlab 125-14

B. Circuit Assembly:

1. Connect the Ultrasonic Sensor:
• VCC to Arduino 5V.
• GND to Arduino GND.
• Trigger Pin to Arduino digital pin (e.g., pin 9).
• Echo Pin to Arduino digital pin (e.g., pin 10).
2. For signal analysis with Red Pitaya:
• Connect the Echo Pin to Red Pitaya IN1 to capture the echo signal.

Main Setup & Waveforms

Generate the Trigger Signal with Arduino

1. Procedure:
• Write a simple Arduino sketch that outputs a trigger pulse on a chosen digital pin (for example, pin 9).
• Start with a short pulse (typically 10 µs for an HC-SR04) and a fixed period between pulses.
2. Example Code:
Copy

const int trigPin = 9;

void setup() {
  pinMode(trigPin, OUTPUT);
}

void loop() {
  // Ensure a clean start by setting LOW
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

  // Generate a 10 µs HIGH trigger pulse
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Wait some time before the next pulse (adjust period as needed)
  delay(50);  // 50 ms period for testing
}

3. Verification:
• Connect pin 9 (trigger) to one of the Red Pitaya’s analog input channels (IN1).
• Use the Red Pitaya oscilloscope application to observe the waveform.
• Confirm that the trigger pulse is a clean 10 µs pulse and that pulses are repeated with your chosen period.
4. Echo Signal
• Connect pin 9 (trigger) to one of the Red Pitaya’s analog input channels(IN2).
• Use the Red Pitaya oscilloscope application to observe the waveform.

Observe Echo Signal at Different Distances

1) No Object in Front

• Observation: The sensor does not receive a valid echo, or the echo appears very late/weak, indicating there is no reflective surface within its range.
• Time Measurement: Not applicable (no clear echo).
• Distance: Out of range or no valid reading.

2) Object at 1 m

• Measured Time Delay (Trigger to Echo): ~5.9 ms (example from screenshots)

• Calculation:
$$\text{Distance} = \frac{\text{Speed of Sound} \times \text{Time-of-Flight}}{2}$$

3) Object at 50 cm

• Measured Time Delay (Trigger to Echo): ~2.9 ms
• Calculation:

4) Object at 10 cm

• Measured Time Delay (Trigger to Echo): ~0.58 ms
• Calculation:

Arduino Programming: Reading Distance Data

Upgrade the Arduino Code to Read the Echo Signal

1. Objective:

Once you have confirmed the trigger is working and you have observed the echo on Red Pitaya, upgrade your Arduino code to measure the echo pulse duration.

2. Procedure:
• Use the Arduino function pulseIn() on the echo pin (for example, pin 10).
• Measure the duration of the echo pulse in microseconds.
3. Example Code:
Copy

const int trigPin = 9;
const int echoPin = 10;

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

void loop() {
  // Generate trigger pulse
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Measure the duration of the echo pulse
  unsigned long duration = pulseIn(echoPin, HIGH, 30000); // timeout after 30ms

  // Debug: Print raw echo duration
  Serial.print("Raw Echo Duration: ");
  Serial.print(duration);
  Serial.println(" us");

  delay(100);
}

4. Verification:
• Run the code and observe the serial monitor.
• Confirm that when an object is present at a known distance, the echo pulse duration matches your observations on Red Pitaya.

Calculate Distance and Display It in the Serial Terminal

1. Objective:

Convert the measured echo time into a distance reading and output the result to the serial monitor.

2. Procedure:
• Use the formula:
$$\text{Distance} = \frac{\text{Speed of Sound} \times \text{Time-of-Flight}}{2}$$
• The speed of sound is approximately 0.034 cm/µs.
• Update the code to calculate and print the distance.
3. Example Code:
Copy

const int trigPin = 9;
const int echoPin = 10;

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

void loop() {
  // Ensure a clean trigger start
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

  // Send a 10 µs trigger pulse
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Measure the echo pulse duration (in microseconds)
  unsigned long duration = pulseIn(echoPin, HIGH, 30000);  // timeout set to 30 ms

  // Calculate distance (cm) using standard conversion (0.034 cm/µs)
  float distance = (duration * 0.034) / 2.0;

  // Print the raw duration and calculated distance
  Serial.print("Raw Echo Duration: ");
  Serial.print(duration);
  Serial.print(" us, Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(100);
}

4. Verification:
• Place an object at a known distance and verify the printed distance matches expectations.
• Adjust calibration if necessary based on your sensor’s specifications and observed values.

Improving Accuracy with Calibration (Exercise)

Refine your distance calculation by calibrating the conversion factor. With Red Pitaya, you can precisely measure the echo pulse duration at a known distance. Use these observations to adjust the conversion factor in your code.

Steps

1. Measure at a Known Distance:
• Place an object at a known distance (for example, 8.5 cm).
• Use Red Pitaya to record the echo pulse duration (e.g., suppose you measure 432 µs for an 8.5 cm distance).
2. Calculate the Calibrated Conversion Factor:
• The standard formula is:
$$\text{Conversion Factor} = \frac{2 \times \text{Distance (cm)}}{\text{Echo Duration} (\mu s)}$$$$\text{Conversion Factor} = \frac{2 \times 8.5\,\text{cm}}{432\,\mu s} \approx 0.03935\,\frac{\text{cm}}{\mu s}$$$$\text{Distance} = \frac{\text{Echo Duration} \times 0.03935\,\frac{\text{cm}}{\mu s}}{2}$$
3. Update the Arduino Code:
• Replace the standard conversion factor (0.034 cm/µs) with your calibrated value.
• Optionally, set a maximum range (e.g., if no object is detected beyond 85 cm, clamp the reading).

Example Calibrated Code

const int trigPin = 9;
const int echoPin = 10;

// Calibrated conversion factor based on a measurement at 85 cm with a 5080 µs echo pulse:
const float calibratedConversionFactor = 0.0335; // in cm/µs
const float maxDistanceCm = 85.0;  // maximum measurable distance (cm)

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

void loop() {
  // Generate a trigger pulse
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Measure echo pulse duration (in µs)
  unsigned long duration = pulseIn(echoPin, HIGH, 30000);

  // Calculate distance (cm) using the calibrated conversion factor
  float distance = (duration * calibratedConversionFactor) / 2.0;

  // Clamp the distance to the maximum value if necessary
  if (distance > maxDistanceCm) {
    distance = maxDistanceCm;
  }

  // Output the calibrated distance to the Serial Monitor
  Serial.print("Raw Echo Duration: ");
  Serial.print(duration);
  Serial.print(" us, Calibrated Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(100);
}