The Ultrasonic Sensor

Loading...

From the course by University of California San Diego

Internet of Things: Sensing and Actuation From Devices

87 ratings

University of California San Diego

Internet of Things: Sensing and Actuation From Devices

87 ratings

Have you wondered how information from physical devices in the real world gets communicated to Smartphone processors? Do you want to make informed design decisions about sampling frequencies and bit-width requirements for various kinds of sensors? Do you want to gain expertise to affect the real world with actuators such as stepper motors, LEDs and generate notifications? In this course, you will learn to interface common sensors and actuators to the DragonBoard™ 410c hardware. You will then develop software to acquire sensory data, process the data and actuate stepper motors, LEDs, etc. for use in mobile-enabled products. Along the way, you’ll learn to apply both analog-to-digital and digital-to-analog conversion concepts. Learning Goals: After completing this course, you will be able to: 1. Estimate sampling frequency and bit-width required for different sensors. 2. Program GPIOs (general purpose input/output pins) to enable communication between the DragonBoard 410c and common sensors. 3. Write data acquisition code for sensors such as passive and active infrared (IR) sensors, microphones, cameras, GPS, accelerometers, ultrasonic sensors, etc. 4. Write applications that process sensor data and take specific actions, such as stepper motors, LED matrices for digital signage and gaming, etc.

From the lesson

DragonBoard™ 410c Monitoring and Control

Its time to expand on what we did in Course 2! That being said, I am sure you all had a blast creating your server and checking the status of various components on your board. What if I told you we can use some of these ideas to also control peripherals on your board! Well that is exactly what we are going to do in this Module. Its time to mix your software knowledge with your hardware skills to create a system that can both receive and send information using HTTP! Buckle up because we are about to introduce you to a new sensor while also providing you with everything you will need to officially use the internet for controlling your things (IoT pun)!

Introduction to Lesson 11:23

The Ultrasonic Sensor6:17

Ultrasonic Application8:26

Ultrasonic Demo7:05

A look back at Lesson 12:34

Meet the Instructors

Ganz Chockalingam
Principal Engineer
Qualcomm Institute of Calit2, UC, San Diego
Harinath Garudadri
Associate Research Scientist
Qualcomm Institute of Calit2, UC, San Diego

As promised we have the ultrasonic sensor here.

Now before we dive into the code and tell you how we got our algorithms written up,

I wanted to kind of explain a little bit about the device itself.

The ultrasonic sensor that we're using for this project.

So, up there on the screen you can see a big image, too big,

that's not how big it is in real life.

[LAUGH] >> Imagine if it was.

>> Yeah I know, right?

Of the ultrasonic sensor that we're using.

Now, this is the HC-SR04.

You can pretty much find it anywhere online,

you type it into Google, a search engine that you use, that you like to use, and

you'll get all sorts of images, resources, you'll find all sorts of cool stuff, code.

Probably people have already written a bunch of code for this thing.

And it'll be very helpful for you to kind of experiment with it, have some fun.

Now if you look at the image you can see that we have four

pins on this particular device.

VCC and ground are at the two ends, and then you have trigger and echo.

The only two, I mean VCC is just your five volt that you get from your board.

Ground is just the common ground at the four corners of your expansion header.

But the two GPIOs, or

the two things that we need to control, are the trigger and the echo.

Now, trigger is something we're going to write to, and

echo is something we're going to read from.

Now, looking at this we need to kind of figure out how the sensor

still is gonna work and how we're going to use these two pins to communicate with it.

So in this next image we have here, you can kind of see how

the sensor is interacting with the environment around it.

So we have it pointed at a wall for instance here in the picture.

One of these little devices here is sending out a ping, or

a sound, in this case at 40 kilohertz, and the other devices is taking it in.

The other side of the device is taking it in.

So considering we're using the trigger as a write device,

we're writing onto the device, and

the echo to read, then when we send a signal to the device,

it shoots out the ping, when the echo comes back we read it into the board.

>> A nice little example I like to think of is pretend you have a ball and

you kinda wanna compute the distance to the other wall,

so what you do is you take the ball and you throw it against the other wall.

And now you're going to have your arms open and waiting for

the ball to come back, and when the ball bounces off the wall then you grab it.

Then you say, oh it took ten seconds for me to get the ball back from

when I first threw it, so then from if you know the speed that you threw it at,

let's say ten miles per hour, or something like that.

>> Yeah, but now let's actually take that analogy, that's a great analogy,

let's take that analogy and apply it to a system that we wanna make sure we get.

What if we throw the ball and it bounces and we miss it?

>> [LAUGH] >> Right, cuz this device isn't moving,

it's not able to reach its arms to the left or

to the right, so- >> And

we're not professional athletes, either, so.

>> Yeah. [LAUGH]

>> We're engineers.

>> Yeah, so what if we miss the ball, right?

We wanna make sure we catch this ball, or at least one of the balls, right?

So look at this diagram up here and you can see now we have these three graphs.

One which is the trigger, one which is the transmitter output, and

one which is the echo output.

Now the trigger is what I said is one of those GPIOs that we write onto the device.

And now this is the cool part.

We write onto the device and we say, voltage high.

The device then says, okay, I'm gonna throw out these balls, right?

Or this ball.

>> [LAUGH] >> Instead of throwing out one ball

though, it throws out eight, right?

So it says, I'm gonna throw out eight balls.

Well I mean technically it's actually eight waves,

eight signals at 40 kilohertz each.

So at that exact moment it also triggers the echo to go high.

>> Basically you're waiting.

>> Yeah so now you're waiting.

You threw the one, you triggered it,

threw eight balls, now you're waiting, echo's high.

It bounces off the wall, eight of them bounce off the wall,

you catch one so you win.

>> Yeah. >> [LAUGH] And then echo goes low,

you take the time, divide it by the speed or yeah,

divide it by the speed and you got it.

All right cool so, there you go.

Now you have a one more little helper here.

We got both of those pictures that we used in the last two slides,

we're gonna merge them together to hopefully get you understanding this

a little better if you didn't already.

So first thing that happens, you have all those little 1s on the screen.

That's what happens first, you- >> Your first event.

>> Your first event.

So we send a GPIO signal, it goes high, trigger goes high,

trigger sparks the internal circuitry, which you can kinda see,

you're not responsible for those eight signals, the circuit does it itself.

Sends out the eight signals, at that same time, echo goes high.

Arah puts in the code to read when echo goes high,

takes the calculation when one of those signals comes back, and

you calculate the time, and this is traveling at the speed of sound, right?

>> Yeah. >> So speed of sound at zero degrees,

is what?

>> 331 meters per second, yeah.

>> 331, right.

So, if we have 331, I know that there's other variations cuz

mostly room temperature 20 degrees Celsius, usually what's used.

So you're gonna have 340 meters per second.

So, you're measuring the time it took for it to leave your device,

bounce off a wall, come back, so that's the distance times two.

It goes there and back so we need to divide that by two.

>> Exactly. >> Right, so

you take the speed of sound, the distance, and you'll get it.

All right, cool, so now that you've kind of understood how the device works

hopefully, you can always check out the procedure documents or

search online a little more about the HC-SR04.

It's time for us to kinda show you the code that Arah developed for

this particular sensor.

Now, I hope you enjoy it, this was a little bonus piece here,

so have some fun with his code.

We're gonna explain that to you right now, enjoy.

Explore our Catalog

Join for free and get personalized recommendations, updates and offers.

Coursera provides universal access to the world’s best education, partnering with top universities and organizations to offer courses online.

© 2019 Coursera Inc. All rights reserved.

Download on the App Store

Get it on Google Play