Tutorial 14 for Arduino: Holiday Lights and Sounds Spectacular! Video Lecture | Arduino Programming: Step by Step (to become an Expert) - Electronics and Communication Engineering (ECE)

[Music]
[Music]
[Applause]
[Music]
[Applause]
[Music]
[Applause]
[Music]
[Applause]
hey everyone I'm Jeremy plum and on a
very special holiday edition above my
Arduino tutorial series we're going to
be making this today we're gonna use
these awesome individually addressable
RGB LED strips and some simple audio
processing to get them synced up to
music so you can make an awesome holiday
display guest-hosting with me today I
have my good friend Brian Schiffer who
is a fellow engineering ninja from
Cornell University where I read both
attend college he is really awesome in
electronics you want to tell them about
what you do sure so I work on brain wave
monitors with a startup company called
Zeo it's really really awesome stuff and
so he'll be helping us out with the
tutorial today we're gonna be learning
about using op amps to amplify audio
signals as well as filtering those
signals and then we're gonna actually
feed it into the Arduino and use the
Arduino to take those signals and
actually control the RGB pixels that we
have here it should be a lot of fun
pretty straightforward project and you
can use it to impress all your friends
during the holiday season
so let's get started okay this is the
circuit we're going to be using we're
gonna have to build this twice one for
the left channel and one for the right
channel so we start off with the weak
input signal from the audio jack then we
put this through an amplifier stage
right here and then we put it through a
buffer which finally feeds that into a
low pass filter stage here so now I'm
going to go through each stage
individually and better explain them so
first we start here at the input the
input has a very weak signal based
around zero volts so the signal itself
goes both positive and negative with a
small amplitude the a so this then is
fed through and non-inverting op-amp
which is governed by a set of equations
which I'll specify from here at one so
the first is the gain equation which
basically means that the voltage output
VB from right here is equal to VA times
one
plus r2 over r1 so in this case we went
ahead and made art to a variable
potentiometer so that we could actually
change the game to exactly what we
wanted and we set r1 to be a set
constant of a hundred ohms so
specifically what this means is that if
for instance we had our to our
potentiometer set equal to zero we would
actually get no gain and it would just
be vb is equal to VA on the other hand
if we turned it all the way up to our
max which is 10k R 2 is equal to 10k we
wind up with VB equals to 10k over 100
so that's a hundred plus the 1 so that's
a hundred one VA so one thing important
to note here is just because this claims
that it has a hundred and one game does
not mean you could feed in a small
voltage of maybe one volt and get 100
volts out because the the op-amp itself
has a positive high volt rail and a
negative rail of ground which this means
that basically if it tries to amplify up
to 100 volts it will only actually reach
5 volts at the same time that the tries
to go negative it's only going to
amplify down to ground which brings us
to the next node node B so at node B
first of all we get a game as shown here
so we get a larger signal and also as
mentioned earlier the negative signal
will actually hit the ground rail so we
won't actually see that what this is
called as a half wave rectifier so
whereas before we could see that it went
positive and the negative at negative
it'll instead just stay at ground so
this way we only see a gain from VA up
to VB for only the positive voltages
this is governed by the clipping from
the op-amp so then from here we actually
feed this into what's called a buffer so
the buffer basically directly feeds the
output signal back into the negative
rail so this causes it to just have a
game
one
so the reason why this is useful is
because it helps to separate our gain
stage over here from our filtering stage
over here so this makes sure that our
gain doesn't affect the filter in any
way except providing the initial signal
and also that the filter can't discharge
back through the gain stage so this
brings us to the last note our output
node C which will eventually be fed into
our ADC of the Arduino so at this point
what we are doing is we're using what's
called a low-pass filter here so this
uses a capacitor and a resistor in
parallel in order to try to make sure
that this voltage doesn't actually go
all the way down this allows us to only
look at kind of the overall average of
the amplitude so this graph looks like
this so we have our initial curves from
over here and B and now instead of going
all the way down to ground we instead
have charged up her capacitor here which
will then start discharging across the
resistor over here so we'll charge up
the capacitor and then the capacitor
will start discharging until we begin
going back up and the voltage has
exceeded the voltage of the capacitance
which will then have it go back up and
so on so this allows us to have a
smaller ripple and actually kind of get
an average of the entire signal this is
governed by something called tau which
is basically just the resistance times
the capacitance so in this case tau is
equal to RC and here we're using a 10k
resistor and a 10 micro farad capacitor
which results in tau being 1 over 10
seconds so from here we can now take
this filtered signal and feed it into
our ADC or for testing we also had an
LED hooked up to it that would just
directly luminate based upon if the
magnitude was high enough to provide
voltage to this led another Brian shown
you a general schematic of how the
amplifier works let's go ahead and take
a look at an overview of the entire
system and figure out our power
requirements we know that in each of our
50 pixels we're going to have a total of
three separate LEDs
a red a green and blue LED now each of
these LEDs has a proximate current going
to rid of about 20 milliamps
based on the current limiting resistors
that are in the pixels but we have three
of them so the total output or the total
current requirements of each individual
pixel since these are in parallel are
going to be 60 milliamps per pixel 20
milliamps trivedi but we have 50 pixels
total so we're gonna have 60 milliamps
times 50 pixels which is going to give
us 3 amps of current consumption at 5
volts that's quite a bit of power we
definitely can't power this off the
argument directly so we're going to need
an external power source in our case we
used an all-too computer power supply
which we'll show you in just a minute
but you can also get wall boards like
I've used in previous videos that can
supply up to 3 amps at 5 volts so make
sure you get an appropriate power system
for the LED setup that you have now that
we know that we can kind of draw an
overall system schematic for how we're
gonna wire everything together we're
gonna have wall power at 120 volts like
we always do
now I'll go through some form of power
supply in our case like I mentioned it's
an old computer power supply but in your
case it might be a wall work and then
we'll have the lights hooked up to power
supply into our arena so imagine this is
our long strip of lights and they're all
connected together there's gonna be
couple important things here we're gonna
have a 5 volt signal or a 5 volt power
ran off that's gonna connect to the
power supply here and then of course
there's also going to be ground give me
any mind you always have to connect the
ground signals together and your entire
system so that everything at the same
reference point so those will be
connected like so but then we'll also
have the or Tamiya so if we have the
Arduino down over here
there's two wires that have to connect
from the Arduino to the lights so the
lights have a total of four wires that
come at them there's the power ground
wires and then there's a clock and a
data line so both those will have to go
to arbitrary pins on the Arduino that we
can choose I specified pins 3 & 2 in
line code but you can choose whatever
you want so pin 3 will be the data line
and pin 2 will be the clock line okay
and now let's not forget to make sure
that we connect our grounds together so
I'm sure that the ground is connected to
the lights the Arduino and your 20 120
volt wall power so here's a ground right
here now also going into the right and
we know we're going to need to have the
analog inputs from the rest of our
system so the amplifier that Brian just
showed to us it's down over here this
amplifier circuit which I'll show you
how the breadboard momentarily and
there's gonna be two outputs from that
the left and right amplified signals
those were both feed into analog inputs
on our margolina I chose a zero and any
one and this is going to be getting its
original signal from sometimes stereo so
if you have any stereo system over here
what you will probably want to do is use
a headphone splitter I have one of the
wires go to speakers and you can
actually hear what's playing and have
the other splitter feed into the
amplifier circuit that we just developed
and so there's gonna actually be a total
of three wires that you need here
because it's a stereo signal to be left
and right but each left and white wire
that you could cut out will be will have
a ground signal - you only need to keep
one of them make sure you connect the
grounds in so there'll be a ground left
and right I'll show you how to get
sucked into the system in just a second
so this is our overall system schematic
here and let's go ahead and get it wired
up in the real world and start playing
with it so here we have the modified
computer power supply we're using a
provide power just to the lights so in
order to get one of these power supplies
working you have to connect
the switch line that normally tells it
when to power on directly to ground to
make sure that it constantly stays on so
here we can actually see the four lines
coming from our strip of LEDs we have
power and ground which go directly to
power supply we also have the ground
from the power supply broken out so that
we have a shared ground that's shared
between the LEDs and also between the
Arduino and then in addition we have
these lines right here coming from the
LEDs which is our data and our clock
which is the infected Arduino where
Jamie will now talk about okay so here
we have the circuit all wired up just
like Brian showed in the schematic
earlier first and most important thing
we have our audio signal coming in to
the top here basically we've taken apart
a pair of old headphones and use two
wires to bring them in here so each wire
from the headphones left and right
headphones has a channel in the ground
so you need to bring in both in channels
and just one of the grounds and make
sure you hook it up into the ground of
the rest of your system and don't forget
I know this looks complicated but you'll
build it download the full schematic and
schematic and breadboard view for my
website the link is in the description
here we have the quantization of
amplifier that we're using so there's
four op amps in here the two on the left
are the gain op amp and the buffer op
amp for the left channel and the two on
the right are the gain and buffer op amp
for the right channel down here we have
our two potentiometers which is used to
adjust the gain on each signal so that
we can get it just for everyone and we
have LEDs that indicate the approximate
amplitude level of each stereo signal
along with those we have the resistors
in our capacitors for our RC circuit
which remember is doing a low-pass
filter that allows us to get the overall
amplitude of the system without worrying
about the particular frequency of the
notes so that's really useful for
feeding it into the analog to digital
converter of our Arduino which is then
happening with these two wires right
here they feed into analog pins it's
urine one on the Arduino let's not
forget that this system has to have five
volt power although it's not necessary
to power with the large bulky computer
power supply that we using for the LEDs
though so we're hooking it up to the
five volt
Brown fingered we know that the op-amp
has the power it needs to do all the
amplification and then the last thing
here is don't forget to hook up the
signal and clock lines from our LED
strip that we showed earlier okay now
before you do any program in the new
yard window at all you should be able to
confirm your amplifier circuit is
working correctly
right now the only thing rocks using the
Arduino for is power and ground
basically it's just a power regulator at
this point so we're feeding in the power
and ground there and we have our
headphones feeding into the amplifier
system and you can see that with the
music playing in the background which
you guys can hear that the LEDs are
blinking in accordance with the current
amplitude of the music reminiscing -
which is awesome and don't forget to
check that your pots work you're going
to want to tune these LEDs so that
they're blinking at the appropriate
rightness based on the music so if I
turn this down you can see if the green
LED blinks less than less so you want to
tune it to an appropriate value we're
getting a good amount of brightness
where you'd expect the piece to be and
one set that value that's perfect we can
feed in the arduino do some awesome
programming and they can control the
whole LED strip and it's gonna be really
great now that we have our circuit set
up it's time to run our first simple
program there's a few thing you should
make sure you take care of before you
start to write the program now the first
thing is since my last Arduino tutorial
or do we know has released version 1.0
so make sure you have the newest version
of their programming environment you can
get it from Arduino dot CC click on
download and then make sure you get the
newest version of the programming
environment it changes the extension
name of the file so you won't be able to
open the files I'm uploading unless you
have the newest version the next thing
you'll need is to navigate to a deferred
github repository for their RGB LED
driver library so if you go there you'll
be able to see their github repository
click on the zip file download it and
put it in your library folder of your
heart or in a programming environment
location installation location so that
we can use their library so big thanks
to Adafruit brain and library makes this
whole thing quite a bit easier once you
have those two things you're ready to
start writing your program I've already
written a bunch of it here and then
we'll fill in some of the important
parts you're going to need to include
the SPI library because these lights use
a modified version of the SPI interface
we've talked about in previous videos
you'll also need to include the library
that you downloaded from Attica
website as usual I've defined pretty
names for our analog input pin and our
light control pins so we can reference
them later in the program more easily
the inputs from the amplified audio
signals or an analog input 0 and 1 and
the light control pins are pins 3 and 2
the next thing you want to do is set up
the library as per the instructions for
how how to prove develop it basically
the library is called WS - 800 1 that's
the kind of control chip at the LEDs use
so of that object type we're going to
define something called a stripping
which is the variable we'll use to refer
to our particular strip throughout the
rest of the program there's three
primary that you set up the first one is
the number of lights of the strip ours
has 50 and you also need to set the data
and clock lines and where that's up to
so we define those as pins three and two
earlier so you plug those values in here
instead of you want to set up a serial
connection as we often do so that we can
do some debugging in just a bit and you
also want to initialize the strip if
that begin initializes the strip strip
that show sets up all the LEDs to start
displaying their current values okay now
let's get into the good stuff if you go
into the loop the first thing I've done
here is put in some debugging and some
debugging information basically you'll
notice that these first three things are
print instead of print lines basically
that means that they're not going to the
next line after they print out so it'll
print out an L or Colin to the right of
it it'll print out the value for the
left channel input put some spaces then
put out the right channel output or the
right channel input this will be really
useful for identifying the range of
values that we have to deal with so that
we can more effectively - in our program
to get the maximum range of amplitudes
from the music the next thing you want
to do is go ahead and actually read one
of the channels so that we can do some
good audio processing on it and get it
to control the lights to start off we'll
just focus on the left channel so we're
going to do an analogue read the left
channel just like we did it both
remember to do that you do analog read
and you put in the pin name but we're
going to want to map this value because
it's going to come in as a value between
zero and a thousand 23 but in reality
we're only going to want a hue that
ranges from 0 to 255 and I'll explain
in just a bit but basically our colors
that we send to each LED will be a
number from zero to d5 it represents the
RGB color that you'll be seeing on the
LED so the first thing we'll do is a map
here we'll map the analog read I'm going
to start by guessing and it's going to
be around four or five hundred since
I've already tested this out I can tell
you it's a pretty good guess but
basically what's going to happen is
we're not going to hit the full range of
the analog to digital input it's
generally around 0 to 400 depending on
where you have your potentiometer set
but we'll play with this in just a bit
and you can kind of experiment with this
value
but regardless it'll take the number
from 0 to 400 and convert it to a number
from 0 to 255 by doing a linear
conversion the next thing as I've
mentioned in the past you'll almost
always want to use you constrain
function you do in that project because
this does do extrapolation so if it does
get a value about 400 say 410 it'll map
it to a value of up to 80 55 but having
a value about 20 or 55 is meaningless
because huge can only range from 0 to 55
so let's constrain it to those values
you're a 255 okay perfect the last thing
you should do is set this equal to a
variable that we'll be able to use I'm
going to make it a byte called hue the
reason I'm doing a byte and I'm an
integer is cost it's only a number from
0 to 255 so you can save some space by
calling in a byte because here at 255 is
2 to the 8th or an 8-bit number or a
byte
next up we're going to use one of the
Adafruit helper functions that she
defined on her website which is really
helpful as usual so we're going to use
that function to convert that hue that
guy from 0 to 255 to a 24-bit color
value that the LED strip will actually
understand so the value that we convert
it to is called an unsigned integer
32-bit unsigned integer and this is just
like you would define something as an
inch we're gonna define something as a
you into 32 - and that's just an
unsigned 32-bit integer so we'll call
that color and we'll use the wheel
function which I'll show you in just a
minute to convert that commute if you
scroll down I've already copied some of
adafruit's helper function that they've
put together for this particular RGB LED
pixel strip so the real function takes
the
of a hue that we defined earlier and
outputs it to a 24-bit color value the
only I understand exactly how this works
but basically if you've gone google and
type in color wheel you'll quickly
understand what it is and why it's doing
the conversion it is there's one other
helper function will be using called
color or that you can use that will
convert RGB value to a 24-bit color
right now we're just going to use the
hue functionality okay so we have the
color now the next thing I'm going to do
is go through a for loop go through each
individual pixel and set its color value
based on the hue that we determined from
reading our analog inputs so basically
each amplitude is going to map to a
different view on each OD so I've
already set up off where we're going up
to the maximum number of pixels and
setting a value of each one so we'll do
strip set pixel colored and this is just
a function that's defined in the library
that we're using so for I which is the
particular pixel that we're looking at
right now we'll set it to the value
color that we had just defined earlier
okay so that's all set the last thing we
have to do now is talk to show the strip
and we'll put in a delay between each
run to the loop so that the lights don't
update too quickly and make us nauseous
so now we'll upload that to the arduino
and take a look at the serial output and
tune the system to make it look awesome
so we have our serial debugger running
and we have some music playing now and
we can see it's working quite nicely and
you can also use the kind of tuning LEDs
to adjust the rate with which the lights
respond to the music you can make them
more or less sensitive by just attention
so right now we only care about the left
channel which is the green one so by
just engraved FG on there you can see
that we can change just what the
threshold is for them to respond to
music and you can see that if you look
at the serial monitor it changes the
maximum minimum positive values for the
serial input so before we guess that
would be from 0 to 400 but we can really
see that's going up to 600 so you might
want to consider changing that but
depending on how you tune the
potentiometer you're gonna get different
values so if I turn it down now it's
closer to 0 to 400 although a piece
about it sometimes
that is a pretty nice effect though
right there slowly the potentiometer at
that value and leave the map from 0 to
400 like we had it before and that looks
pretty good so I think now we're ready
to take it to the next step
for the last step here we're going to
try to make this a lot cooler what we'll
do is we'll have a left and right half
of the LED chain to find the left 25
will correspond to the left audio
channel and the right 25 to the right
audio channel what we'll do is we'll
have on each sample the previous sample
propagated away from the middle on the
left and right side and then we'll bring
in a new sample into the middle so what
that's what kind of result in is they'll
be a delay effect as the music comes
through each channel and you'll be able
to sort of see the music propagate
through each channel as it goes from the
middle of the chain to the end of the
chain it should be really cool so to do
this we'll use two arrays of length 25
I've drawn them shorter here just to
make it easier to draw and what we'll do
here is we'll use basically the same
method for the left and right and then
swap one of them at the ends that we
have them both propagating from the
inside to the outside what we'll do on
each run through the loop we'll move the
previous instance one to the left from
the end of the array well the first one
the one that's at the beginning will get
discarded and then we'll pop a new one
onto the end so this will be the most
recent sample and so this will happen on
each go to the loop and then we'll be
able to use both of these bring them
into the final array that controls the
entire LED strip and use it to make a
really neat propagation effect so let's
get this programmed real quick and then
we'll see it in action in favor of
saving some time here I've gone ahead
and already put the program together
that will control this new array system
that we're going to be using remember
you can download all this code on helmet
14 and from my website or my github
account okay so what here's there's just
a few things that kind of change around
here so take a look at them the first
thing was is I defined two new constants
remember we've done this before constant
length 50 because that's the length of
our LED strip and half line cuz you just
length divide it by 2 which is because
we use them in a bunch a bunch of places
for the rest of the program and it made
everything easier so I plugged in length
here where we just had the like 50
before the next thing you want to do is
make sure that you instantiate two
arrays one for each half these are just
gonna be like 25 so we define the length
in here as 25 plus 1/2
25 and remember these are you and 30 to
underscore T's because they're holding
those color values that we talked about
in the last programming run-through I've
gone ahead and removed all of our
debugging serial stuff since we don't
care about anymore we're just going to
look at all the creep colors so you'll
want to make sure on the setup that we
fill in each array the left and right
array with zeros that we don't have
garbage data that we end up propagating
and then you just start the strip like
you did before both of these lines of
code are exactly the same as they were
before except they now refer to Q left
and color left because we now have the
same lines of code for hue right and
color right
so these are just looking at the analog
channels getting a hue and then
converting that hue to a 24-bit color
which is stored in a UN 32 T okay the
next thing we'll do which we just talked
about is we have to shift the current
values so we're going to look through
the entire half array each of each of
the two half arrays and we'll look at
the last value we'll move it one to the
left towards the beginning of the array
and we'll pop in a new value at the end
and we'll do this for both the left and
right or is so what this is doing right
here specifically is moving the previous
value towards the front of the array so
this is what's doing our propagation
here after we have to be propagated we
now have an open spot at the end of the
array at location half minus one right
because leg path is 25 and the array is
0 24 so 1/2 minus 1 is 24 so that
position 24 we pop in our new color left
and color right based on the current
audio amplitudes and at that point our
arrays are both filled and ready to go
and all we have to do is put them on the
LED strip and that's pretty
straightforward this for loop it just
like was before except now it's half
because we only want to go from the
middle to the end but we're going to do
it twice one for left and one for right
so if we left one it's very
straightforward you just go from 0 up to
the half and you just fill in the array
based when we just made the right one is
a little bit more complicated because we
need to flip it around first so at each
eye from 0 to 24 what we're going to do
is we'll look at length minus I minus 1
which basically allows us to profit
backwards through the array as we
increment our number our index numbers
and that will make the nice effect of it
propagating from the inside to the
outside and that's basically everything
else is the same we still have to show
the strip afterwards and then we added
delay I change the delay here to 30 from
before just cuz I thought it looked
nicer but you can play with this value a
lot the sample rate will affect how just
how this trip looks so now I'm going to
go ahead and upload this to our Arduino
and we'll take a look at how awesome it
is so what I've done now is I've put
together a quick little program I put on
my computer and a curvy language called
pure Gaeta which is a graphical
programming language that simply outputs
a frequency on my audio channels so
right now I've had a frequency set and I
can crank up the amplitude a little bit
and turn off you can actually see the
sine wave propagating across the channel
of LEDs it's really cool and as I
increase or decrease the frequency you
can see we started to get an aliasing
effect and if I increase the frequency
enough it becomes a basically solid
color and then I can bring the frequency
back down and you start to be able to
make out the wave again all the way back
down to a frequency of zero and then
adjusting the amplitude inevitably
changes the hue and the color and we get
some really neat effects like that and I
can do the same thing with the right and
left channels but no one wants to listen
to this crap all day so let's go ahead
and listen to some actual music
[Music]
[Music]
[Music]
[Music]
thanks for watching a very special
holiday episode of my art million for
toriel series don't worry there are many
more tutorials to come I'm not gonna
stop making them thanks a lot for Bryan
shippers are helping out today we had a
great time thanks for having me it's
awesome okay so yeah definitely go check
out my website Jeremy Blum comm where I
lament 14 or my github page I have all
the source code schematics everything
you need to put this to rock this
project together hop on there it was a
lot of fun i really suggest you guys
check it out and there might be some
bonus footage from this tutorial coming
around the corner so definitely keep
your eyes peeled on my youtube channel
and on element14 i look forward to
seeing you guys next time thanks a lot
for watching thanks thanks to element14
for helping me to sponsor this video
series they were kind enough to provide
a lot of the materials that I'll be
using to create these tutorials
feel free to go visit their website at
element14.com check out their community
which is a great place to talk to you
about electronics they already know and
basically anything else engineering
related and that's all of a store where
you can buy a lot of the parts that
we'll be using in these videos