Safe, legal fun with breadboards

1
Safe, legal fun with breadboards
2
introduction
Breadboards are a simple and useful way to
quickly assemble and play around with different
circuits. Today we'll be using breadboards to
put together some simple circuits that closely
relate to the final boards the University wants
you to assemble. This is going to be super
educational! Building circuits with a breadboard
is as simple as sticking wires and components
into the holes. The holes themselves are
connected according to the diagram at
left(thanks, Wikipedia!).
3
Getting started
Since we want to run an attiny2313
microcontroller (more on that later) on this
board, the first thing we need is a power supply.
We want the rails on either side to be 5 volts
() and ground (-). The first thing I've done
here is connected the two sets of rails together.
Notice that I've used a red wire for the 5V
line and a black wire for the ground line. I'm
told that this is a good practice.
4
Circuit symbols
Hopefully this list isn't really new information
for anybody. We'll be looking at a lot of
circuit layouts, so knowing the symbols is super
essential. Of course, access to a complete list
of circuit elements is as close as google, so I
wouldn't worry too much.
A few circuit element symbols
5
The power supply
Below is a schematic of the power supply we'll be
making. This presentation has photos of the
assembly process but you'll want this diagram to
be your authoritative source on what connects to
where it has the advantage of being unambiguous).

-
6
Important caveat!
Do not put the capacitors in backwards! You will
notice that the capacitors have a long leg and a
short leg. The long leg is always the anode, or
positive lead. Make sure to put the anode on the
positive line. If the capacitor is inserted
incorrectly, when a current is applied it will be
ruined and will possibly even EXPLODE. (science
is cool!)? You don't need to worry about which
direction resistors face because they're
symmetrical. If you put the diode in backwards,
the circuit won't work. If you put the
capacitors in backwards, bad things will happen.
7
Assembly step 1
This is the beginnings of the power supply. The
two wires running off to the left will be
connected to a nine volt battery. If you look
closely, you will also note that I've inserted to
diode backwards. Ha ha! Ouch for me! We want
the current to flow through the diode from left
to right, so the little silver stripe should be
on the right-hand side. Don't make the same
confusing mistake that I did.
8
Assembly 2
I've added both capacitors and the 7805 voltage
regulator. It's hard to see exactly how things
fit together from a photograph so use the diagram
as your guide. Note once again the use of red
wire for 5V and black wire for ground.
9
Indicator light
The power supply was already complete, but I've
added an LED, connected to both power and ground.
Notice that I used a resistor to connect the led
to ground. Leds have little intrinsic
resistance, so if you connect them to a circuit
without adding resistors then they'll pull a lot
of current, and may damage themselves. The
reason I even put the led in is to make sure the
power supply is working. If the led lights up,
we have power. Now is a good time to attach the
battery and make sure everything works. Use eye
protection in case a capacitor explodes.
Seriously.
10
Radical! IEEE Approved! (i think)? Does math!
Now we can add the attiny2313 microcontroller.
These guys are just about the coolest things
ever. They're extremely versatile,
fast(potentially), and you can program them
fairly easily, using standard C code. You'll
soon be learning how. There's a notch at one end
of the 2313. Make sure that end points toward
the top of the board. Also, the picture shows
the 2313 with its first pin on row five, but I'm
actually going to recommend you put it on row 10.
The pin on the upper right (pin 20), and the pin
on the lower left (pin 10), are connected to 5V
and ground respectively.
11
In which a riddle is proposed
I'm reasonably sure that the attinys we're giving
you are preprogrammed with a simple code that
will make an led blink. So let's go ahead and
build the apparatus for that. It's super easy
pretty much just an led with a resistor like we
used for the power indicator. All the pins on
the right-hand side of the chip except the top
and bottom one collectively constitute Port B.
You can wire the led to any one of them and it
will light up. Different pins will cause the led
to blink at different speeds. Can you think of a
simple reason why this might be? (Hint
computers use binary code and they loooove to
count things.)? I think this might actually be a
pretty hard riddle, so feel free to ask for the
answer.
12
This is where it starts getting tricky.
This is the diagram for the circuit that will
actually program the 2313. The tricky part is
that it doesn't show exactly what we're doing.
We won't be using an ICSP port we're just going
to connect the wires directly to the 2313. We'll
be handing out copies of this diagram you'll
need 'em. Make sure you remove the battery
before messing with your breadboard.
13
The final product
This is what the programmer will look like when
done. I built it right next to the power supply
to make room for future features. The wires
going off to the right connect to (from top to
bottom) pin 2, pin 19, pin 17, pin 18. See next
slide.
14
Here is the same view with the red wires removed.
Wire A connects the left pin of the transistor
to wire B. Resistor A connects the middle pin of
the transistor to wire B. The band on the diode
faces the transistor. The flat side of the
transistor faces down. With this information,
you should be able to replicate the design
exactly.
15
Making a cable
The next step is to make a cable to connect the
breadboard to your computer's serial port. This
involves soldiering, which I'm not even going to
try to explain in powerpoint. Someone will teach
you. Soldier wires onto pins 3, 4, 5, and 8.
Soldier the same wire to pins 6 and 7(As shown in
the diagram on slide 12). You can connect the
two pins with a blob of soldier orbettera
fragment of wire. The wires should be long
enough to reach from the breadboard to the
computer's serial port. Crimp /////s onto the
other ends of the wires. They can now be placed
onto the xxxxxs.
16
Attaching the pins
Now you can plug the wires you've made onto the
pins on the breadboard. You can ignore the stuff
behind the wires in the photo we're not there
yet. Attach the wires as follows the top
breadboard pin (on the right in the picture)
attaches to the wire that runs to pin 4 in the
DB9. The next one attaches to pins 6 and 7. The
middle one attaches to pin 3. The fourth one
attaches to pin 5. The last one(on the left in
the picture) attaches to pin 8. Now plug the DB9
head into your computer's serial port and you can
program the attiny 2313.
17
rgb leds
Now we can write a program that will cycle
through the colors of an rgb led. Take out the
apparatus for the single-color led (if you
haven't already done so) and build the
configuration seen at left. Note that the long
pin of the led should be the one not connected to
a resistor. In the picture, the wires for power
and the programmer cannot be seenthis is just
for clarity, so you can see exactly what to add.
Do not remove the power or programming wires from
your chip. Make sure the board is powered on and
plugged into the computer. It's time to program
it.
18
programming
The software tools we'll be using to program the
attiny 2313 chips are WinAVR and PonyProg2000.
They should hopefully be installed on your
computers already. Now that we have the
programmer assembled and the led in place, the
first thing we're going to do is use ponyprog to
download a new program to the attiny2313. First,
fire up PonyProg2000. Disable the startup noise
(it's super annoying) and close the launch
window. The main function of ponyprog is to read
and write data (in the intel
hex format) to and from the built-in program
memory on the attiny. The first thing we need to
do is make sure the device is communicating.
Click on the setup menu, and select interface
setup.... This will bring up a new window.
Make it look like this, then click Probe. It
should pop up a little window that says test
OK. If not, there is a problem. Just raise
your hand, probably.
19
The PonyProg2000 interface
The most useful buttons in the interface are
defined above. Make sure that AVR micro and
Attiny2313 are selected in the drop down menus to
the right. Then go to the setup menu, click on
calibration, and select yes in the window that
pops up. It should tell you Calibration OK.
Now you're ready to program. Test that things
are working by pushing the read device button.
It should pull up the program already on the chip
and put in in the main window. The programs are
in hex format, so don't worry if they're totally
incomprehensible.
20
Programming continued
Time to write a new program to the chip. Press
the open program file button, and select the
file main.hex in the folder tiny2313_led0.
Then just push the write device button. The
program is written to the device and the light
comes on! I think we can all agree that this is
pretty cool. So now let's look at the source
code. The application to do that with is
programmer's notepad. So fire that up. Before
we look at the RGB code we just installed, let's
check out the simple monochrome blinking that was
on the chip to begin with. It's the file
main.c in the folder tinyblink. I sure hope
everyone understands basic c syntax if not, the
next slide contains most of the terms used in the
code. The code itself is pretty well commented
you should be able to figure out what's going on.
The main idea is that the pins making up port b
collectively express a numerical value in binary
code. This value, called countval is counted
repeatedly from 0 to 255. Suppose countval was
155. In binary that's 10011011. So on the
physical chip, pins 12, 13, 15,16, and 19 would
be pulled high while pins 14, 17 and 18 would
not. You can see how, as countval changes, an
led attached to a single pin will blink on and
off.
21
C syntax (or, what's going on)?
A complete explanation of the c programming
language would be outside the scope of this
lesson, but I will try to explain the basic terms
used in the tinyblink program. Really though, if
you've never used C, you're going to need more
information than it makes sense to put into this
presentation. You can find a good introduction
to C programming at http//www.cprogramming.com/tu
torial.htmlctutorial So here are a few lines
from the code, with explanations

• uint8_t countval //the keyword uint8_t declares
  that the next term will be the name of a new
  unsigned 8-bit integer. All variables must be
  declared in this manner before they can be used.
• int main(void) ... //This defines a function
  called main which consists of the contents of the
  curly brackets. The main function is what is
  executed when the program runs. Read the
  turtorials linked above.
• DDRB 0xff //The commands DDRB and PORTB aren't
  part of standard C they're device-specific
  functions that the microcontroller-focused
  compiler we're using understands. These
  functions allow us to write data directly to
  specific locations in the chip's memory. What is
  being written is a numerical value in hex digits.
  The 0x at the front of the number only means
  that the following two symbols are in
  hexadecimal. See http//en.wikipedia.org/wiki/He
  xadecimal

22
Further discussion of the code

• While(1) ... //While commands are one way to do
  loops in C. When the program reaches the while
  command, it decides whether the expression in the
  parentheses is logically true. If it is, the
  code in the curly brackets is executed. When the
  end of the curly-bracketed code is reached, the
  computer again evaluates whether the expression
  in the parentheses is true. If so, the bracketed
  code is executed again at infinitum. Because 1
  is considered to be a true statement always, the
  program will loop forever.
• if(countvalgt255) countval 0 // If statements
  cause the command following them to be executed
  only if the expression in the parenthesis is
  logically true. In this case, the variable is
  being reset to zero when it reaches 255.

23
Talkin' bout the colors now
So now let's turn our attention to the RGB
program. Open it up and take a look at the code.
The overall structure is pretty much the same
the difference is in what values are being
broadcast over port B. I'll try to explain the
logic behind them. You can physically see that
the cathodes controlling the color of the led are
connected to pins 14, 15, and 16, or in other
words, the fours, eights, and sixteens place of
port B. We want the program to cycle through
every possible configuration of those three pins.
Hence a variable is run from 0 to 7 and
multiplied by 4. (The multiplying by 4 shifts
the digits two spaces up, just like multiplying
by 100 would in base 10. Chew on that for a
minute.)? The other commands use boolean logic
to turn the ones digitpin 12on and off
respectively. Pin 12 provides power to the anode.
24
Compiling
Just for the fun of it, let's change the program
a little. Change the value that the variable
waitcounter is initialized to from ten million to
five million. This will make the colors cycle
twice as fast. After the source code has been
changed, we still need to compile it into a
format the attiny understands and then download
it to the chip. Here's how. Start by going to
the tools menu and clicking make clean, then make
all. This will cause WinAVR to clear the old
output and then compile the new code. It does so
according to instructions contained in the
makefile, which we'll return to shortly. One of
the files you just created was a new main.hex
file. Open it up in PonyProg2000 and write it to
the device. You should notice the change in led
behavior. Outstanding!
25
Makefiles
All of the demo program folders we've given you
contain a file called makefile. The makefile is
a plain text file that the compiler refers to
when it compiles the program. The makefile
contains information such as what compiler
version to use, what file should be used as the
source code, what the output files should be
named, and what kind of device the code will be
written to. You can open up the makefile with
notepad and take a look at what's in there. The
only lines you really need to make sure you
understand are the first few. (Fortunately)?
26
9 led RGB array
Actually, it's not really an array since they're
all in a line. But it's still going to be pretty
cool. Start by putting a column of nine rgb leds
on the furthest-left column on the board. Make
sure that the anode (again, the longest pin) of
the led is the second from the bottom in each
case if all the leds aren't facing in the same
direction then you'll have problems. The three
cathodes on the leds each control one color. We
want every led to have its cathodes connected to
the corresponding cathodes of every other led.
That was really confusing, sorry just look at
the picture. Pin one connects to pin 1, pin 3
connects to pin 3, and pin 4 connects to pin 4.
The pin 2s are anodes, and we'll deal with them
later.
27
My condolences
Continue making the same braid pattern
established in the last slide until every led is
connected. Make sure that you use three
different colors, and use them consistently.
This part takes awhile and is sort of
mind-numbing be strong.
28
Nearly there
This picture really isn't the greatest but it
should be pretty clear what I've added. The led
cathodes have been connected to the chip via
resistors. Notice that I've used the same color
wire on both sides of the resistors(you can't
really see the black one). The wires connect to
pins 14-16. The magnitudes of the resistors,
starting with the one closest to the chip, are
500, 620, and 240 Ohms. This is actually the
same resistor and pin configuration as was used
for the single RGB led, so hopefully you already
have it in place.
29
The big finish
The last step is just to connect all the anodes
to various pins on the chip. The circuit diagram
we handed out will tell you which led to connect
to each pin. Once you're done, the circuit is
ready to be programmed.
30
The 9 LED program
The code for this configuration is found in the
folder tiny2313_led1. I think you know by now
how to put it on the chip, so I'll just talk
briefly about what it does. It's actually pretty
much based on the same ideas as the last program
was. All of the leds are designated one after
the other according to pretty much the same rule
as before. Notice that they're all different
colors, so the color defining variable is offset
by one in each successive led. The on and off
commands correspond to the various pins we
attached anodes to. I know the bitwise operators
that turn the anodes off and on are sort of
confusing. The following reference explains how
they work really well. http//www.gamedev.net/ref
erence/articles/article1563.asp