Arduino senses the environment by receiving inputs from add-on devices such as sensors, and can control the world around it by adjusting lights, motors, and other actuators. In this class you will learn how and when to use the different types of sensors and how to connect them to the Arduino. Since the external world uses continuous or analog signals and the hardware is digital you will learn how these signals are converted back-and-forth and how this must be considered as you program your device. You'll also learn about the use of Arduino-specific shields and the shields software libraries to interface with the real world. Please note that this course does not include discussion forums.
Lecture 2.3 - Pulse Width Modulation
Loading...
來自 University of California, Irvine 的課程
Arduino 接口
1324 個評分
從本節課中
Module 2
This module introduces sensors and actuators and discusses how to interface with them. We’ll examine different classes of sensors and actuators. For each type of sensor/actuator, we’ll examine the circuitry needed to interface with it. Additionally, we’ll take a look at the Arduino code needed to communicate with the sensors and actuators.
與講師見面
Ian HarrisProfessor
Department of Computer Science
[MUSIC]
So there are actuators that need analog voltages to do what they need to do.
They need to be controlled with analog voltage.
But an Arduino, or most microcontrollers, cannot supply analog voltages directly.
So instead, it is common to use pulse width modulation.
So there are many actuators that normally take analog voltage,
but you can basically fool them with a pulse width modulated signal.
And pulse width modulated signals can be generated from Arduinos and
from most microcontrollers.
So basically what a pulse width modulation signal is, it's the idea that look,
we assume we can only output digital.
Zero and five volts, zero volts, five volts, let's say.
So how do we fake out, essentially fool the actuator to think that
it's getting some arbitrary voltage in between?
Say we wanna supply it with 2.5 volts, right?
But we can only give out zero and five volts.
So what we can do is just alternate between zero and five volt, very quickly.
So just, we output a square wave.
Zero volts at the bottom and then five volts at the top.
And if it's a 50 50, 50% duty cycle.
So if it's high half the time and
low half the time, then on average you'll be sending out 2.5 volts.
And now whether that works or not depends on the actuator.
But if you make this square wave go very quickly,
have a high frequency and then the actuator doesn't respond quickly, right?
Normal actuators don't respond that quickly.
Then this is satisfactory.
This will work.
And that's usually, most actuators.
There are a lot of actuators that will accept pulse with modulated signals as
a replacement for actual analog voltage.
So you're sending out a square wave.
Zero volts, five volts.
But the thing that you're changing is the pulse width,
basically what percentage of the time the signal is high.
So duty cycle is a percent of the time that the pulse is high.
So, if you have a 50% duty cycle,
that's the middle signal in that wave format you're seeing there.
It's high half the time, and low half the time.
But, if you want the perceived voltage to be higher, then you have,
maybe, a 75% duty cycle.
And then you'd get what you see at the top, where it's high 75% of the time, so
the voltage that, the average voltage is going to be higher.
Or you could go down 25% duty cycle, then the average voltage is lower.
So you can change the perceived voltage by changing the width of this pulse.
Now analogWrite() does exactly this, it generates a pulse width modulated signal.
So it generates a square wave on a pin, it's 490 hertz.
Now hertz is cycles per second, right?
So how many clock pulses?
490 clock pulses every second.
That's how fast this clock is changing, how fast the square wave is changing.
Okay, this analogWrite() takes two arguments.
The first argument is a pin number.
The pin that you wanna generate the pulse width modulated signal on.
And just as a note, Arduino only allows you to generate the pulse width
modulated signal on a subset of the pins.
If you look at your Arduino, the numbers of the pins, there'll be a little tilde,
squiggle mark,
next to the pins that you're allowed to do pulse width modulation on.
Okay, so the first argument is the pin number.
The second argument is the pulse width, or an indication of the pulse width.
So the second argument in a number from 0 to 255.
And that number indicates how wide the pulse is.
So, 0 means you have a 0% duty cycle, which means it's low all the time.
255 is the max, so that would mean 100% duty cycle.
If you wanted 50% duty cycle, you'd do halfway in between.
So, 128 and 127.
That'd be 50% duty cycle.
And you can change duty cycle by changing that second argument.
The pin number has to be a pulse width modulated pin,
it has a little tilde symbol.
They're marked on the Arduino.
So an example, you might say analogWrite(3, 128).
That would say on pin 3 we're going to drive that with a square wave.
And 128 is it's duty cycle.
Now since that's halfway between, or almost halfway between 0 and
255, you'd expect a 50% duty cycle for that.
Now, here's an example piece of code.
This is actually in your example, so if you open up your Arduino IDE.
Go to file, examples, I believe this is in the basics.
File examples, basics.
There's one called Fade, and that's this.
I've taken out all the comments to make it shorter, but this is basically the code.
So, first notice there the normal two functions, the setup and the loop.
All this does, just to zip right to what it does, there is an LED.
It assumes that there is an LED connected on one of the pins.
Actually I must have left out that.
LED is a variable in here that refers to a particular pin that you've
wired an LED on to.
Let's assume it's pin 13, okay?
Say it's pin 13, cuz we know there's an LED on that pin.
So what all this does is it calls analogWrite
on that pin you can see highlighted in red.
It called analogWrite on that pin.
So it generates a square wave on that pin.
And the second argument which is the duty cycle.
Which is the indication of the duty cycle, that's the brightness.
So the idea is that if you have a large duty cycle, 100% duty cycle,
then you're gonna get a very bright LED.
But if you have a very small duty cycle,
it's only high a very small fraction of the time, then you get a very dim LED.
And so what this function does, if you look at the loop, it does the analogWrite
with a certain brightness, starting at brightness 0, so it would be off.
Then it increments brightness,
brightness = brightness + fadeAmount, which is something small, say five.
Then, if brightness equals 0, or brightness equals 255.
So if it reaches an extreme.
So you're counting up, right.
So you start off with brightness equals 0, then 5, then 10, then so on.
Every pass through, cuz this is in a loop, it gets bigger, brighter, and brighter.
Then, once it hits the maximum, once it's 255, then it has to change direction.
And the fade amount, if it was five,
it should become negative five now, so that it gets dimmer.
And then if it was -5 and you hit 0, then it should reverse direction and
become positive 5.
So what this function will do is actually make the LED get brighter and
then dimmer, brighter and dimmer over and over.
Notice the delay(30).
That slows the process down a little bit so you could see it.
But that's what this function does, and
it uses analogWrite to send a pulse width modulated signal to the LED.
Thank you.
[MUSIC]
