PH250_Lab_Manual_1.0

Contents Preface xi Introduction xiii Keeping a Lab Notebook . . . . . . . . . . . . . . . . . . . . . . . xiii Using This Lab Manual . . . . . . . . . . . . . . . . . . . . . . . xiv I Computer Interfacing 1 1 Introduction to the Arduino 3 1.1 Building circuits . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 1.1.1 Temporary circuits: the prototyping board . . . . . . . . 4 1.1.2 Durable circuits: soldering . . . . . . . . . . . . . . . . . . 8 1.2 Arduino Circuit Control . . . . . . . . . . . . . . . . . . . . . . . 14 1.2.1 Attaching the Arduino to the circuit . . . . . . . . . . . . 14 1.2.2 The Arduino sketch: an introduction . . . . . . . . . . . . 16 1.2.3 Compiling and uploading the sketch . . . . . . . . . . . . 19 1.3 Adding More Complexity . . . . . . . . . . . . . . . . . . . . . . 21 2 Electrical Measuring Devices 25 2.1 What We Measure: Voltage . . . . . . . . . . . . . . . . . . . . . 26 2.2 Sources of DC and AC potentials . . . . . . . . . . . . . . . . . . 28 2.2.1 DC Power Supply . . . . . . . . . . . . . . . . . . . . . . 29 2.2.2 Signal Generator . . . . . . . . . . . . . . . . . . . . . . . 30 2.3 Instruments for Measuring Voltage . . . . . . . . . . . . . . . . . 31 2.3.1 Voltmeters . . . . . . . . . . . . . . . . . . . . . . . . . . 31 2.3.2 Oscilloscopes . . . . . . . . . . . . . . . . . . . . . . . . . 33 2.4 Measurement Uncertainty: A Review . . . . . . . . . . . . . . . . 36 2.5 Measuring Something Else: Current . . . . . . . . . . . . . . . . 37 2.5.1 Current is a Flow . . . . . . . . . . . . . . . . . . . . . . . 38 2.5.2 The Physics of Measuring Electric Current . . . . . . . . 40 2.5.3 How to Build an Ammeter . . . . . . . . . . . . . . . . . 45 2.5.4 Testing the New Instrument . . . . . . . . . . . . . . . . . 45 2.6 Propagation of Uncertainty: A Review . . . . . . . . . . . . . . . 47 iii

vi CONTENTS

LIST OF FIGURES ix 6.3 Powering an Arduino with a 9 V battery . . . . . . . . . . . . . . 107 7.1 Ohm’s law . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 7.2 Voltage v. current for a non-Ohmic resistance . . . . . . . . . . . 112 7.3 Measuring the voltage drop across a resistor . . . . . . . . . . . . 113 7.4 Adding a shunt resistor to measure current . . . . . . . . . . . . 114 7.5 Voltage locations needed to test Ohm’s law . . . . . . . . . . . . 115 7.6 Wiring the Arduino to test Ohm’s law . . . . . . . . . . . . . . . 115 7.7 Fractional uncertainty in current v. shunt resistance . . . . . . . 123 7.8 Sample data for testing Ohm’s law . . . . . . . . . . . . . . . . . 124 7.9 A linear fit to the Ohm’s law data . . . . . . . . . . . . . . . . . 125 8.1 Charging and RC circuit. . . . . . . . . . . . . . . . . . . . . . . 130 8.2 The voltage in a charging RC circuit as a function of time . . . . . 131 8.3 Wiring the RC circuit to the Arduino . . . . . . . . . . . . . . . 132 8.4 Sample data for the RC circuit capacitor voltage . . . . . . . . . . 136 8.5 The LoggerPro interface . . . . . . . . . . . . . . . . . . . . . . . . 136 8.6 Capacitor voltage graphed in LoggerPro . . . . . . . . . . . . . . . 137 8.7 The curve fit button and dialog in LoggerPro . . . . . . . . . . . . 137 8.8 The LoggerPro window after completing the fit . . . . . . . . . . 138 8.9 LoggerPro graph options . . . . . . . . . . . . . . . . . . . . . . . 139 8.10 LoggerPro column options . . . . . . . . . . . . . . . . . . . . . . 139 8.11 The final graph, now with error bars . . . . . . . . . . . . . . . . . 140 9.1 A simple model of a solenoid . . . . . . . . . . . . . . . . . . . . . 144 9.2 Schematic diagram for a series RLC circuit . . . . . . . . . . . . . 146 9.3 Energy in a series RLC circuit. . . . . . . . . . . . . . . . . . . . 147 9.4 Peak capacitor voltage v. source frequency for a series RLC circuit.149

xii LIST OF FIGURES

LIST OF FIGURES xv LAB ACTIVITY This is an example of an activity callout box. It will tell you what you need to do at this point in the lab.

1.1. BUILDING CIRCUITS 5 • All of the holes adjacent to each of the red lines are connected. These are typically used for connections to an electrical power source (generally the positive terminal for DC power sources). • Each vertically oriented set of five holes in the center of the board are connected. These connections are illustrated in Figure 1.2. Please note that not all pro- totyping boards are alike, and the connections may vary from board to board. As an example, let’s consider how we might wire together a simple circuit involving a 9 volt battery and an LED using a protyping board. Note that nine volts is usually a little high for powering a single LED, so we are also going to put a resistor in our circuit to keep the current down. First, let’s connect our battery to the red an blue rows of the prototyping board. You don’t necessarily have to connect the power this way (in fact, once you know how the connections in the prototyping board work, you can connect things in any fashion consistent with the circuit you are trying to build), but doing so is generally considered good practice. We can also connect each set of row together, so that we are providing a power source and ground at both the top and bottom of the board. As you know, the color of the wires I use doesn’t make any difference in how the circuit operates, but the colors can help me keep Figure 1.1: An empty prototyping board. Figure 1.2: Typical connections on a prototyping board. The holes adjacent to each of the red and blue lines are connected to each other, as indicated by the red and blue highlights on the figure. The remaining holes are connected in groups of five, as indicated by the grey highlights.

6 CHAPTER 1. INTRODUCTION TO THE ARDUINO track of how I’ve built my circuit. Red is typically used for power sources, and dark blue or black is typically used for ground (or the negative terminal for DC sources). Once I’ve made these connections, my prototyping board looks like Figure 1.3. Figure 1.3: Connecting power to a prototyping board. Note that the positive lead from the battery holder connects to the “red” horizontal line on the prototyping board, and the negative lead (the black wire) connects to the “blue” line. The red and blue wires on the right side connect the two red and blue lines together, respectively. Our next step is to connect the LED to the red power row. LEDs are picky about which lead is connected to power. One of the leads will be longer than the other. This is the lead that should connect to the power. For our circuit, I will plug this long lead directly into one of the holes I’ve provided power to, and the other lead into one of the center strips, as seen in Figure 1.4. At this point, our LED has not lit, because it needs to form a complete circuit, which we could do by connecting a wire from the unconnected lead to ground (one of the blue rows). We don’t want to do this, though, as the full nine volts from the battery is probably too much for our LED. So we’re going to put a resistor in first. I’ll use a 330 Ohm resistor for this exercise. I connect one of the resistor leads into the same five hole group that the LED is connected to, and the other lead into a hole from a different group (putting both leads into holes from the same group would be like connecting the two ends of the resistor together, effectively removing it from the circuit). These connections can be seen in Figure 1.5. Our LED is still not lit. We will now complete the circuit by adding a ground connection. I could have done this by putting the second lead of the resistor

1.1. BUILDING CIRCUITS 7 Figure 1.4: Adding an LED to the prototyping board. The long lead is placed in one of the holes connected to power, and the other lead is connected to a center strip. Figure 1.5: Adding a resistor to the prototyping board. One lead is placed in one of the holes in the same group as the LED lead, and the other lead is connected to a different group.

8 CHAPTER 1. INTRODUCTION TO THE ARDUINO into one of the ground holes, but I’ll instead use a wire to finish the connection. The LED is now lit (Figure 1.6)! Figure 1.6: Completing the simple LED circuit. One end of the yellow wire is connected to the same group as the end of the resistor, and the other end of the wire is connected to the ground (blue) row. Having completed the circuit, the LED is lit. LAB ACTIVITY With the exception of the 9 V battery, build the circuit from this example on a prototyping board. This concludes our example for using a prototyping board to construct a circuit. Before this lab concludes, we are going to use our Arduino as the power source for this circuit, and also have a little fun using the Arduino to control the behavior of the LED. Before we do that, though, we need to talk about soldering. 1.1.2 Durable circuits: soldering If you followed the last example carefully, you may have noted a few things: • Using the prototyping board makes this circuit a lot larger than it needs to be. • We made electrical connections by easily sliding a lead or wire into a hole. The wire or lead can just as easily be removed from the hole.

1.1. BUILDING CIRCUITS 9 • The entire thing looks like it will fall apart if I try to pick it up and move it. It is fairly apparent that prototyping boards are good for designing circuits and building a prototype for testing (hence the name “prototyping board”). But if I am going to put this circuit to any sort of practical use, I need to build it in a more permanent fashion. The way we do this is by electrically “gluing” the connections together with solder. Solder consists of a ductile metal alloy (usually tin, silver, and/or lead) mixed with a small amount of material called flux. Solder has a relatively low melting point, and is also electrically conductive. By melting a little bit of solder between the wires or leads we want to connect, and then letting the solder reset, we can make a mechanically strong connection. In order to make a mechanically strong and electrically sound connection, soldering must be done correctly. The process begins by making sure you have the right equipment and that it has been properly prepared. Figure 1.7 shows the elements of a good soldering station, including (from left to right) • A soldering iron. This provides the heat to melt the solder. • Solder. In this case, it is provided on a spool. • Flux paste. Flux is what helps solder flow. Sometimes solder doesn’t have enough flux, and having a little extra paste handy can make a huge difference. • Tip cleaner. The tip of a soldering iron, after a little use, will start get gummed up with oxides. When this happens, it doesn’t conduct heat very well. Frequent tip cleaning makes your life a lot easier! • Helping hands. This device includes a few clamps that can hold your work in place, and usually also includes a magnifying glass to help you see what you are doing. This piece of equipment is critical! Normally, when soldering a circuit, you need to hold the circuit, the element you are soldering to it, the soldering iron, and the solder all at the same time. Unless you have four hands, you’ll need one of these devices! • Wire wick. Sometimes you make mistakes while soldering. Wire wick, when heated, will sop up solder so you can remove it from your work. In addition to this equipment, it’s also convenient to have a surface to solder our components on, rather than trying to solder them together directly. A common surface is pictured in Figure 1.8, and is called a perfboard. It’s basically just a fiberglass board with a bunch of holes (perforations) drilled in it, and the holes are lined with some sort of conductive material. Now, let’s get started. First we’ll plug the soldering iron in and give it a few minutes to heat up. Once heated, we then want to clean and prepare the tip. This is done by plunging the tip of the soldering iron in and out of the tip cleaner several times. At this point, we’ll also dip the tip very briefly into the

10 CHAPTER 1. INTRODUCTION TO THE ARDUINO Figure 1.7: Soldering equipment. Included here are a soldering iron, solder, flux paste, a tip cleaner, a set of “helping hands”, and wire wick. See the text for a more full description of these items. Figure 1.8: A perfboard, along with some items we will solder together on it.

1.1. BUILDING CIRCUITS 11 flux paste, and then clean the tip again. Finally, we’ll melt a small amount of solder onto the tip, and then clean it a third time. At this point, the tip should be clean and shining with solder, similar to Figure 1.9. Figure 1.9: A clean soldering iron tip, ready for use. The next step is to start putting elements on the perfboard. Components with leads can usually be held in place prior to soldering by bending the leads on the backside of the board. These bent leads can also conveniently be used as wires between components as well. In Figure 1.10, all of the components for the circuit have been placed on the boards, and the leads bent to make electrical connections. Normally you would only add a few components at a time, solder those into place, then add more. Figure 1.10: Components added to a perfboard, ready for soldering. Note how, on the back side of the perfboard, the leads have been bent to hold the components in place as well as act as wires. Now to apply the solder. Rather than trying to hold the entire spool of solder, it’s easiest to use the soldering iron to burn off a three or so inch segment instead. A key thing to remember is that you should heat the work, not the solder . If you just touch the solder with the soldering iron, it will melt, and it

12 CHAPTER 1. INTRODUCTION TO THE ARDUINO might even transfer onto the parts you are trying to solder. However, the flux tends to move to the surface of hot metal, and you’ll basically end up with a ball of solder that is insulated from the work by a thin layer of flux. This is referred to as a cold solder joint, and will likely not provide a lasting electrical connection. By heating the work and then melting the solder onto the work, you’ll end up with good connections. Figure 1.11: Heat the work, not the solder! Once the iron is removed from the working area, the solder will cool and set very quickly. This process is repeated for each of the connections. Figure 1.12 shows the results with just a few connections left to solder. In this figure, you’ll note that one of the clamps on the helping hands is holding the wire in place. Figure 1.12: The soldering project near completion. The connections to the 9 V battery connector still need to be soldered. Note that one of the clamps of the helping hands is holding the red wire in place. Once all of the soldering is complete, you’ll have some tails of wire and component lead sticking out. Use a set of close clipping wire cutters to remove these extra and unnecessary pieces of metal. Now our project is complete (see Figure 1.13. Note that the finished product is significantly more durable than what we had on the prototyping board, and also significantly smaller. (The perfboard used here is 4 cm by 6 cm, and clearly a much smaller board could have been used. When a particular circuit needs to be produced in large amounts, someone will usually design and produce a printed circuit board, or PCB. A PCB consists

1.1. BUILDING CIRCUITS 13 of several layers of conductors, insulating substrates, and inks. The conducting layers make the connections between circuit elements, so one only needs to solder the circuit elements in place, and not worry about wiring the connections between them. An example of a PCB can be seen in Figure 1.14. The conducting layers are most obviously visible in the lower left portion of the PCB. The type of soldering presented here is called “through hole” soldering, so named because leads from the components are placed through holes and then soldered into place. Smaller circuit elements are often soldered directly to pads Figure 1.13: The completed soldering project. Figure 1.14: An example of a printed circuit board, populated with components. The conducting layers are highly visible in the lower left portion of the board.

14 CHAPTER 1. INTRODUCTION TO THE ARDUINO on the surface of a PCB. This type of soldering is called “surface mount”, and is somewhat more difficult to perform. We will not be doing any surface mount soldering in this lab. Both through hole and surface mount connections can be seen in Figure 1.14. The diodes, resistors, and inductors (all cylindrically shaped components with one or more bands around their circumferences) have been connected with through hole soldering. The ICs (the black boxes) are connected via surface mount. Should you ever need to remove an item that has been soldered into the circuit, you simply reheat the solder that holds it in place with the soldering iron, and then remove the item before the solder resets. (Be careful, as the item will probably be quite hot. A pair of tweezers is helpful.) When neeed, you can also absorb the liquid solder from the board using solder wick. We will not be doing any “unsoldering” in our lab today, but if it is needed later in the semester, your instructor can help. LAB ACTIVITY Successfully complete three or more soldering connections. Now that we’ve seen how to design, build, and solder circuits, let’s look at controlling our circuit using an Arduino. 1.2 Arduino Circuit Control Let’s start our study of computer control by controlling something simple with an Arduino DAQ: the LED circuit that we constructed earlier on the prototyping board. Our objective is to use the Arduino to turn the LED on and off. 1.2.1 Attaching the Arduino to the circuit Connecting the Arduino to our LED circuit built earlier is quite simple. We will be using the digital I/O ports found on one side of the Arduino, as seen in Figure 1.15. In this figure, you will see that these ports are numbered, starting from the left, 1-13, GND, AREF, SDA, and SCL. Of those ports, the ones of greatest interest to us today are the numbered ports and the GND port (GND stands for “ground”). The numbered ports will be our voltage source, and the GND port will be our ground connection (akin to the negative terminal of a battery). 1 To connect the Arduino to our circuit, we place a wire into port 13 (or any of the other numbered ports, but for the example here we’re going to use port 13), and the other end of the wire into the red row of our prototyping board. This is the same way we connected the positive terminal of the battery 1 You will note that the Arduino is assembled on a printed circuit board. Can you identify which components were attached by through hole v. surface mount soldering?

1.2. ARDUINO CIRCUIT CONTROL 15 earlier. A second wire connects the GND port of the Arduino to the blue row, where we had previously connected the negative terminal of the battery. These connections can be seen in Figure 1.16. A discussion about “ground” is warranted here. The name “ground” is quite literal, in a way. The Earth is big, and can act as a giant sink for electric Figure 1.15: The digital ports on an Arduino. Figure 1.16: The Arduino connected to the LED circuit. The connections are described in the text.

16 CHAPTER 1. INTRODUCTION TO THE ARDUINO potential. More importantly for us, the ground provides a reference that we can measure electric potentials with respect to. The numbered ports on the Arduino are going to provide five Volts of potential relative to ground. How does the Arduino know what the “ground” is? Because it will also be connected to our computer. The plug on our computer has a “ground” prong (the round prong), which (if the building you are in is wired to applicable codes) is electrically connected to a copper rod that has been pounded down into the ground. From this point on, we will no longer provide pictures of the circuits that we build (usually). Circuits are typically represented using schematic diagrams instead of pictures. A schematic diagram is a simplified representation of a circuit. Each type of component has a symbol associated with it. Connections between components are represented with lines. Connections to things outside of the circuit are represented by pins. As an example, the circuit we have just built is represented in Figure 1.17. The rectangle labeled with “R1” is our resistor, and you can see the resistance value next to the label. The arrowhead terminating on a line, labeled “D1”, represents a diode. The smaller arrows leaving the diode indicate that this is a light emitting diode, or LED (also indicated by the label). The pinouts to the Arduino are labeled “J1” and “J2”, and their intended connections are also included on their labels. Part of the fun of building electric circuits is constructing a physical circuit from the information given in the schematic! Figure 1.17: Schematic diagram for the blink circuit. The rectangle symbol represents the resistor, and the other symbol represents the LED. The pinouts to the Arduino are labeled at the ends. See the text for a more full description. At this point, the LED is still out. There are two reasons for this. First, we have not yet provided power to the Arduino. Second, we have not yet told the Arduino to turn on the LED. Providing power to the Arduino can be done in several ways. For today, we will simply connect the Arduino to our computer using a USB cable. (We need this USB connection in order to program the Arduino, also.) 1.2.2 The Arduino sketch: an introduction We now have our “hardware” built for a blinked LED. We still need to give instructions to our Arduino so it knows how to use pin 13 and GND to make the LED blink. The Arduino has a small computer on board, and we need to upload a computer program to the Arduino in order to tell it what to do.

1.2. ARDUINO CIRCUIT CONTROL 17 You have likely already written programs at some point in your education. Common programming languages include Python, Java, and C++. Arduino programs are similar to other programming languages 2 . They have loops and conditional statements, but additionally have special code for controlling the Arduino. Most Arduino codes are very short. For today’s code, we just need to tell the Arduino what to turn on and when, and when to turn it back off again. Every Arduino program has two required parts: the setup() function and the loop() function. When the Arduino is powered on, the setup() function is executed once. As the name of the function implies, it is typically used to set up variables or environments that the rest of the program will use. Once the setup() function has been executed, the loop() function is executed. This is where most of the action happens in the program. This function is repeated over and over again until the Arduino is powered down. Let’s introduce the commands we will use for this lab. Each digital output on the Arduino has a number. The code will need to know which pin number we are working with. There are two ways we can do this. The first is to define a variable of type integer (int) and set it equal to the pin number. The code to do this would typically be written before the setup() function, and would look something like this: int ledPin=13; The other way we can do this is with a #define statement at the beginning of the code, before the setup() function. A #define statement simply tells the compiler (the thing that turns our human readable code into binary code that the processor understands) to replace the defined name with whatever follows in the definition. Such a definition would look something like this: #define ledPin 13 As stated before, most of the action of the program happens in the loop() function. In our case, our loop function needs to turn on the digital pin our LED is connected to, wait for a short while, turn it off again, and then wait some more. A digital pin on the Arduino can be set to a LOW voltage (zero Volts relative to ground) or a HIGH voltage (+5 V relative to ground). Each digital pin that we use also needs to be set up for output or input. This is done with a “pinMode” statement. For example, to set pin 13 to output, I would use the following in my setup() function, recalling that we had previously set ledPin to a value of 13: pinMode (ledPin, OUTPUT ); If I had wanted to set up the pin for input, I would simply replace the OUTPUT with INPUT . To set the pin to LOW or HIGH voltage, use a digitalWrite command: 2 The Arduino programming language is essentially C++ with some modification. If you are already familiar with C or C++, Arduino programming will feel quite comfortable.

18 CHAPTER 1. INTRODUCTION TO THE ARDUINO digitalWrite (ledPin, LOW ); digitalWrite (ledPin, HIGH ); And, finally, to leave the light on (or off) for a while, we can use a delay com- mand, where the argument to the command gives the delay time in milliseconds: delay (100); Altogether, our Arduino code for blinking lights would read as follows: #define ledPin 13 void setup () { pinMode (ledPin, OUTPUT ); } void loop () { digitalWrite (ledPin, HIGH ); delay (100); digitalWrite (ledPin, LOW ); delay (100); } There are a few things to note about the syntax. First, every line of command within the code is terminated with a semicolon. This tells the compiler that the command is complete, and also allows us to continue a command onto a second or third line when needed. The only exception is the #define statement. Sec- ond, any grouped set of command, be that in a function, a loop, or a conditional statement (the latter two do not appear in this code) are encapsulated in a set of curly braces. Once again, this tells the compiler where the set of commands begins and ends. The code above, while it will make the Arduino behave the way we want, is not ideal. It is missing a very critical part: comments. You should always include abundant comments in your code, including a comment block at the top describing what the code does overall, comments describing each variable you declare or define, and comments that describe each part of the algorithm in the code. Why do you want so many comments? Some people would say that you include comments to help other people understand what your code is doing. The reality is, though, that you put the comments in your code so that you can remember what your code is doing when you come back to it weeks or months later. For this lab course, comments are required in all of your code. In the Arduino language, single line comments can be started with a dou- ble forward slash “//”. Block comments can also be started with a “/*” and ended with a “*/”. Once I’ve included adequate comments, my code will look something like this

1.2. ARDUINO CIRCUIT CONTROL 19 ///////////////////////////////////////////////////////// // Arduino sketch to blink one LED // Written by (your name would go here) // Feb. 6, 2017 ///////////////////////////////////////////////////////// // Define the pin we are using for output #define ledPin 13 ///////////////////////////////////////////////////////// // The arduino setup function comes next. We need to set // up pin 13 for output. ///////////////////////////////////////////////////////// void setup () { pinMode (ledPin, OUTPUT ); } ///////////////////////////////////////////////////////// // Now comes the loop function. We simply turn on the // LED, wait for a while, turn off the LED, and wait // some more. ///////////////////////////////////////////////////////// void loop () { digitalWrite (ledPin, HIGH ); // Turn on the LED delay (100); // Wait 100 ms digitalWrite (ledPin, LOW ); // Turn off the LED delay (100); // Wait 100 ms } 1.2.3 Compiling and uploading the sketch So that’s how you write Arduino code. How do you get it to your Arduino? There is a special integrated development environment (IDE) for programming our Arduino. The IDE can be seen in Figure 1.18. We will need to install this IDE before we can communicate with our Ar- duino. To do so we use a web browser to go to https://www.arduino.cc/en/Guide/HomePage

20 CHAPTER 1. INTRODUCTION TO THE ARDUINO and choose to install the Arduino IDE for your computer. In the figure, you will see two important buttons on the left side of the toolbar. One is the “compile” button. The Arduino cannot interpret the human readable code that we write in the IDE. It needs to have the code translated into binary (ones and zeroes) that digital logic circuits understand. This translation process is called “comiling”. As the code is compiled, the Arduino software looks for errors in the code. If there are errors, it will tell you at this point. This way we can correct the errors before we send the compiled instructions to the Arduino. Figure 1.18: The Arduino IDE. The compile and upload buttons are found at the left side of the tool bar. We also need a way to send our code to our Arduino and that is what the upload to Arduino button does. Once the code is compiled without errors, connect the USB cable to the Arduino and push the upload button. Once the code is uploaded to the Arduino, we should see some blinking lights! One last thing to note: Arduino programs are called “sketches”. As you keep your lab notebook, you should always include a copy of your sketch, along with notes on how you got it to work. It’s also a good idea to include pictures and schematics of any circuits you have constructed. LAB ACTIVITY Build your own clone of the blinking light circuit described in this section by doing each of the following: • Construct the LED circuit on a prototyping board. • Connect the Arduino to the LED circuit and to your computer. • Write, compile, and upload the “blink” sketch to the Arduino.

1.3. ADDING MORE COMPLEXITY 21 • Verify that the circuit is working correctly. 1.3 Adding More Complexity Now it’s your turn to practice these skills by designing a building a new circuit. Our objective is to build an Arduino controlled circuit that does the following: • Increments a counter every half second. • Turns on a red LED only when the counter is an even number. • Turns on a yellow LED only when the counter is a multiple of three. • Turns on a green LED only when the counter is a multiple of five. • Turns on a blue LED only when the counter is a multiple of seven. Most of hardware setup will be the same, but we will be using multiple digital pins on the Arduino (one for each LED). We will have to abandon our nice +5V top row on our prototyping board as our connection to pin 13, because we need multiple pins and we need them to operate independently. Instead, we can wire pin 13 of our Arduino directly to the top lead of one LED, wire pin 12 to the top lead of another LED, and so on. It’s OK for each branch of this circuit to share the same ground connection. To do this, we will need a counter variable. The variable i is a common choice. You’ll want to declare this variable as an integer at the beginning of your sketch, and set its value equal to zero. At the end of the loop statement, you can increment the counter using i=i+1; or i++; You will also need to make the Arduino to some math. Specifically, you’ll need to test whether the counter is currently a multiple of the desired number. This can be done using a conditional statement. In the Arduino language, conditional statements will take on the following form: if (a<b) { firstFunction(); delay (100); secondFunction(); } else if (a<c)

22 CHAPTER 1. INTRODUCTION TO THE ARDUINO { anotherFirstFunction(); delay (200); } else { finalFunction(); } Each part of the condition includes a test statement found in the parentheses. If the statement is true, the code included in the curly braces that follow will be executed. In this example, if a>b evaluates true, then the firstFunction , delay , and secondFunction will be executed in order. It will then skip over the rest of the code in the example. If a>b evaluates false, the code will procede to the else if portion of the conditional, executing the anotherFirstFunction and delay functions provided that a<c evaluates true. If neither of those test statements evaluate true, then the finalFunction function will be evaluated. You will need to use conditional statements in this exercise. You will also want to use a mathematical operator called the modulus, rep- resented by a “ % ” symbol. The operator divides the first operand by the second and returns the remainder. For example, 23%5 would return 3 . This operator can be used in a conditional statement to see if one number is a multiple of another as in if (i%3==0) { // The variable i is a multiple of 3. } else { // The variable i is not a multiple of 3. } Again, save your sketch and take a photo of your hardware. Place a copy of both in your lab notebook along with notes on how you got it to work. Make sure others at your table are able to get their circuit to work also. LAB ACTIVITY Using the Arduino and prototyping board, construct a circuit with all of the following characteristics: • Increments a counter every half second. • Turns on a red LED only when the counter is an even number. • Turns on a yellow LED only when the counter is a multiple of three. • Turns on a green LED only when the counter is a multiple of five.

1.3. ADDING MORE COMPLEXITY 23 • Turns on a blue LED only when the counter is a multiple of seven.

24 CHAPTER 1. INTRODUCTION TO THE ARDUINO

Chapter 2 Electrical Measuring Devices OBJECTIVES At the conclusion of these laboratory activities, you should be able to do each of the following: • Demonstrate the use of a DC power supply and a signal generator. • Use a multimeter to measure DC voltage and current. • Demonstrate the basic functionality of an oscilloscope, including channel selection, setting the volts per division, the time per divi- sion, and the triggering level. • Use an oscilloscope to measure DC voltage and AC frequency and voltage. • Demonstrate how current measurements are derived from voltage measurements by building a simple ammeter device, utilizing a stand alone volt meter. • In each of these activities, identify and quantify the sources of uncertainty in your measurements. 25

26 CHAPTER 2. ELECTRICAL MEASURING DEVICES ITEMS TO REVIEW Please review the following concepts as part of your preparation for this lab. • Electric potential and potential difference. • Electric current. • Resistance and Ohm’s law. • AC and DC potentials. Last week we tackled very simple computer control, but we said we also want to transfer data from our experiment to our computer. In order to understand how to do that, we need to know what things we can measure with electronic devices. We will take on this question today, but we will get practice making these measurements with special equipment designed just for making these mea- surements. These devices won’t send the data they measure to our computers, but they will display it so we can see the data. Once we know how to make some basic measurements with these stand-alone instruments, then we can consider how we would make a new instrument to measure something else. We will build a current measuring device, an ammeter out of electrical components and a voltmeter . This will be something we do over and over again - building new instruments using instruments we already know and some electrical equipment. This lab consists of a large pre-reading section that will give you background information. It will describe the various stand-alone devices, along with some electromagnetic theory. Scattered throughout, you will be asked to practice making these measurements with our equipment. 2.1 What We Measure: Voltage Ultimately, all of our electronic sensors measure one thing: voltage. You may want to measure something else, say relative humidity. To record relative hu- midity on our computer we need to first (somehow) convert relative humidity into a voltage. Voltage is really “electrical potential difference,” which is the difference be- tween electrical potential energy per unit charge at two different circuit loca- tions. Last lab we said voltage was a comparison, and this is the comparison. We compare the potential energy at two different circuit locations, only we divide the potential energy by the charge of an electron. To get a feel for how this works, think of a change in gravitational potential energy, Δ U g . If we wanted to measure the difference in potential energy between the top of a hill and the bottom of a hill, we would need to place some sort of device both at the top and at the bottom of the hill, as in Figure 2.1.

2.1. WHAT WE MEASURE: VOLTAGE 27 Figure 2.1: Gravitational energy difference. In order to measure the difference in gravitational potential energy from the bottom of the hill to the top, we would need to know the altitude at each position. Note that the difference in the two potential energies is independent of where zero point of the y coordinate is. We have to do the same thing in our electrical case. We need two “probes,” one placed at the high potential and one placed at the low potential. For example, we could have the circuit that you see in Figure 2.2. The positive end Figure 2.2: Electric potential difference. As with gravitational energy, we mea- sure the potential at two different points and compare the two measurements. of the battery is like the top of the hill. It provides a high electrical potential energy. So we put one probe at the top of the “hill” or the plus side of the battery, and the other on the bottom of the “hill” or minus side of the battery. The negative side of the battery provides a low electrical potential energy. With this we measure how high our potential “hill” is. The difference between these two measurements is called voltage. You should ask yourself “what would happen if you got the probes back- ward?” The potential difference is the same, but the probe we thought was at

28 CHAPTER 2. ELECTRICAL MEASURING DEVICES the high potential is at the low potential, and vice-versa . The result is that our reading will change by a negative sign. In Figure 2.3 you can see how to actually perform this voltage measurement with one of our meters. Figure 2.3: Measuring voltage with a multimeter. The red probe is placed on the lead of the resistor connected to the high potential of the power source, and the black probe is placed on the lead connected to the low potential of the power source. We say we measure voltage “across” a circuit element. This makes some sense if you consider that we very seldom stand batteries up so their electric potential is greater in the same direction as their gravitational potential. Bat- teries, resisters, capacitors, etc., often lie down, and we measure “across” them by putting the positive probe on the high potential side and the negative probe on the low potential side. Even though the battery is lying down, we are still measuring a higher and lower potential energy difference. Knowing a little about voltage, let’s now look at our devices that produce voltages and then the devices that measure voltages. 2.2 Sources of DC and AC potentials In today’s lab we will study four hardware devices. A power supply, a signal generator, a multimeter,and an oscilloscope. We will call these “stand alone” instruments because they are independent boxes that do their job of measuring or generating signals without a computer connected to them. The power supply

2.2. SOURCES OF DC AND AC POTENTIALS 29 and the signal generator make voltage signals. The other two devices measure them. Let’s look at the power supply and signal generator first, then take on the measuring devices. 2.2.1 DC Power Supply When most people think about sources of DC potentials, they will first think about batteries. Of course, we use batteries in many applications in today’s world, and they power circuits designed to work on a single, specific DC voltage. A DC power supply is like an adjustable battery. An example can be seen in Figure 2.4. Usually a power supply takes electrical energy from a wall outlet and converts that energy into the specific voltage range that we want for our experiment. So it is like a battery, but must be plugged into the wall. Our power supplies are designed to keep us safe. They are current limited, meaning that they try not to give too much charge flowing through our wires. (Sometimes this is a problem because they are too limited.) There is a current limiting knob that you can turn to allow a little more current. Be careful when you use this. The voltage may jump wildly when you turn the current knob! It is best to turn all the knobs down as low as they will go before you turn on the power supply. Then, after turning on the power supply, increase the current knob about half a turn and then slowly turn the voltage knob up to your desired voltage. If the voltage stops increasing, turn the voltage knob back down a bit, and turn up your current limiter knob some more. Then try your voltage knob again. Other devices are typically connected to a power supply using wires with “banana” connectors at the end. Figure 2.4: A DC power supply.

30 CHAPTER 2. ELECTRICAL MEASURING DEVICES Some of our electrical devices are quite delicate, and will literally burn up if you apply too much current or voltage. In today’s lab, we will practice using our power supply so we are prepared when the delicate components come out later. 2.2.2 Signal Generator The signal generator is basically a fancy power supply. An example can be seen in Figure 2.5. It makes voltages that change over time in sine, square, and triangle patterns. These time-varying signals have a maximum voltage (called the amplitude). We will use both the wave output and a timing signal that the wave generator creates. Each has their own Bayonet Neill–Concelman connector (usually just called a BNC connector) on the front of the signal generator. You will need a cable with BNC connectors on one end (and maybe alligator clips on the other end) to use this device. There is an amplitude knob on the front of the signal generator. Because the signal generator makes a voltage that changes in time, the amplitude of the signal must be in voltage units. We should be careful not to set the signal amplitude (voltage) too high or we run the risk of destroying our measuring devices. Again turn the amplitude (voltage) down before you connect the box to our electrical components. Then turn up the voltage to what you want in a safe way. Figure 2.5: A signal generator. Different brands and types of signal generators are operated differently. We will focus on the one shown in Figure 2.5. There are frequency range buttons (using the shift button) near the middle of the device panel. To change the frequency, you use the shift and range buttons to set which digit you are adjust- ing, then turn the frequency knob to make the change. An annoying feature of our frequency generators is that you must push the “output on” button or they don’t output a signal. When everything is set up right, we get a sine wave (or square wave, or triangle wave) out. Figure 2.6 shows a signal from the signal generator displayed on one of our measuring devices, the oscilloscope. A household power outlet is also a source of sinusoidally varying voltage, but

2.3. INSTRUMENTS FOR MEASURING VOLTAGE 31 Figure 2.6: Sine wave output from a signal generator, displayed on an oscillo- scope. with two limitations. First, the amplitude of the signal is (hopefully) always at the same set value (170 Volts in the United States), and the sine wave always has the same frequency (60 Hz in the United States). A signal generator provides far more flexibility in both the amplitude and frequency of the signal, as well as the wave form. 2.3 Instruments for Measuring Voltage Now that we’ve met a few sources of voltages, lets consider some stand alone devices that can measure those voltages. 2.3.1 Voltmeters Our first measurement device is voltmeter. It measures the electric potential (voltage) between its two leads (sometimes called “probes”). Figure 2.7 shows an example of a multimeter set to measure voltage. The display is set to read voltage by turning the dial to the V position. There are often two voltage set- tings. The one that has a wavy line next to it is alternating current (AC) voltage. The one that has a straight line with three dots under it is the direct current (DC) voltage. For now, we will just use the DC voltage setting. The leads (probes) should be connected to the COM (common) and VΩHz connectors. Note that connecting your probe leads to the wrong position can blow the fuse (or worse) in your meter, causing the meter to stop working altogether

32 CHAPTER 2. ELECTRICAL MEASURING DEVICES Figure 2.7: A multimeter set to measure DC voltage. or display incorrect measurements. You should make sure you don’t do this, and watch to make sure someone else has not done this before you. If the meter seems to be behaving oddly, it may be an indication someone who used it before you connected the probes incorrectly! For reference, Figure 2.8 shows a picture of a different model of multimeter. Figure 2.8: A different model of multimeter, also set to measure DC voltage. You will notice that multimeters have other settings besides volts. They are

2.3. INSTRUMENTS FOR MEASURING VOLTAGE 33 designed to be able to measure more than one thing. Ultimately, however, each of these other measurements are in actuality derived from voltage measurements. We will likely use some of the other settings on the multimeter during the semester. 2.3.2 Oscilloscopes Our next device, the oscilloscope, is just a fancy voltmeter. A voltmeter only displays a single number, giving us no additional details other that what the currently measured voltage is. The oscilloscope measures voltage as a function of time , providing us with significantly more information. The downside is that, where a multimeter is pretty simple to set up and use, an oscilloscope is a far more complex peice of equipment. The oscilloscope can accurately and precisely measure changing voltages and usually has a way to graph the changing voltage as a function of time. A sinusoidally varying voltage should look something like Figure 2.9 when plotted. This plot represents what our oscilloscope does. We should see something like Figure 2.9 on the oscilloscope screen. In figure 2.6, found in our discussion of the signal generator, you know that this is just what we see. Figure 2.9: Sinusoidally varying voltage. This is the type of information an oscilloscope is designed to display. If the changing voltage is periodic, the oscilloscope has a way to use this fact to stabilize the graph so you can see the details more clearly. This stabilization is called “triggering” and on our oscilloscopes there are buttons and knobs on the right hand side of the oscilloscope that adjust the triggering to make the graph more stable (or less stable). The photograph of the sine wave found in Figure ?? was taken by stabilizing a sine wave from a signal generator. The oscilloscope starts plotting at the same part of the wave each time, so the periodic signal seems to stand still. To do this we must “trigger” the graph at some good

34 CHAPTER 2. ELECTRICAL MEASURING DEVICES starting point. Our oscilloscopes have a built-in circuit that can watch for the same part of a signal and start the graph in the same place each time. One of the knobs adjusts the trigger point. This knob can be seen in Figure 2.10. Figure 2.10: Some of the controls on an oscilloscope, including the scale adjust- ments and triggering controls. The other labeled controls in Figure 2.10 adjust the horizontal and vertical axes. The vertical axis is voltage, and the voltage axis control is next to the signal input toward the bottom middle of the front panel. To the right of this is the horizontal axis control, which is time. You can choose how many volts per division with one knob and how many seconds (or fractions of seconds) per division you have on your graph with another knob. In addition to displaying the measured voltage signal, the oscilloscope screen shows us information about the settings of the oscilloscope. In Figure 2.11, at the lower left hand corner, there is a red dot next to a number. This number tells us the voltage represented by each vertical division (square) on the display. When the picture in Figure 2.11 was taken, the voltage knob was set to 2 V per division, so the amplitude of this signal is somewhere around 3 V. Most oscilloscopes have two signal inputs, meaning we can look at two dif- ferent voltage signals at the same time. Each signal input is called a “channel.” Each channel has it’s own voltage scale knob and voltage scale indicator in the bottom left-hand corner. They share the same time scale. The channel inputs

2.3. INSTRUMENTS FOR MEASURING VOLTAGE 35 Figure 2.11: The display of an oscilloscope, with the volts per division set to 2 V. The signal seen on the generator has an amplitude of approximately 1.5 divisions, or 3 V. each have a BNC connector. We use oscilloscope probes connected to these connectors. If we want to measure two voltages at once, we need two sets of probes! To check that our oscilloscope is working correctly we can measure a known voltage, say, the voltage of a regular battery for example. What would we expect to see? Since the battery provides a constant voltage, we should simply see a straight line on the oscilloscope, with the position of the line corresponding to the voltage of the battery. For example, if I was using a 1.5 V battery, and had the oscilloscope set to 0.5 Volts per division, I would expect to see a straight line at the third division on the display. Sometimes the oscilloscope does not get the right voltage. If this happens we need to calibrate the oscilloscope. (Every time we use an oscilloscope it is a good idea to check it to make sure it working well.) Our oscilloscopes have a test voltage to use just for this purpose. The location of the calibration signal source can be seen in Figure 2.12. The calibration source makes a 5V square wave. By connecting the channel probes to the calibration source, a square wave should be seen on the display (you may have to change the time per division to see the wave form). If the top of the wave crosses at 5V on the display, and the bottom of the wave crosses at the voltage axis, then the oscilloscope is properly calibrated. If the oscilloscope is not properly calibrated, you can find the procedures for doing so in the user manual (search online for the manual of the model you are using).

36 CHAPTER 2. ELECTRICAL MEASURING DEVICES Figure 2.12: Oscilloscope calibration source, built in to the oscilloscope. The source produces a 5V square wave, which can be tested using the channel probes. 2.4 Measurement Uncertainty: A Review As you are aware, every measurement comes with some uncertainty, and voltage measurements are no exception. The multimeters only display voltages to a specific decimal point, leaving us uncertain of what the next digit would be. Thus, the precision of the last digit of the display is the minimum amount of uncertainty we would have in that measurement. There are potentially other sources of uncertainty as well. If I was using an analog voltmeter (something we won’t do in this lab), I would be making a judgment about which mark on the scale the needle was the closest to. This is akin to using a ruler to measure a distance. Digital multimeters, such as ours, operate using an analog-to-digital con- verter (ADC). We’ll be learning more about ADCs later in the semester. For now, it is sufficient to note that an ADC introduces some additional uncertainty into measurements obtained using digital voltmeters. (However, the relative size of these ADC uncertainties in a modern digital voltmeter is probably far less than the uncertainty from the limited number of digits on the display). Note that at this point we haven’t even considered the question of whether the meters are reading accurately or not. It is always a good idea to check the calibration of your equipment! The oscilloscope presents some additional challenges when it comes to un- certainty. It doesn’t provide a nice digital readout like the multimeter. When we “read” voltages or times from the oscilloscope, we are making a judgment as to which division the signal is the closest to. Even if I’m pretty good at making judgments, I probably can’t depend on my measurement being any more precise than the smallest division mark on the screen. Keep these uncertainties in mind as you complete the following activities.

2.5. MEASURING SOMETHING ELSE: CURRENT 37 LAB ACTIVITY Practice measuring voltage using a multimeter and an oscilloscope. • Measure the voltage of a D cell or 9V battery using the multimeter. How certain is this measurement? What measurement do you get if you reverse the probes of the multimeter? (Remember that by “reversing” the probes, it means you touch the ends of the probes to the “wrong” sides of the battery. Do not reverse the ports that the probes are plugged into on the multimeter!) • Build the circuit from Figure 2.3, and provide a modest amount of voltage to the resistor using the power supply. (If you put too much current through a resistor, it will literally burn up. Keep the current down to a few hundred milliamps at most.) Use the multimeter to measure the voltage across the resistor. Compare this reading to the voltage reading on the power supply. Do they agree? Do they agree within the uncertainties? If they did not agree, which reading would you trust more? Why? • Measure the voltage of a battery using an oscilloscope. How certain is this measurement? Can you improve the relative precision of the measurement by changing the settings on the oscilloscope? What happens to the measurement if you reverse the probes? Which device is typically better for measuring battery voltage: the mul- timeter or the oscilloscope? Why? • Generate a sinusoidal signal using a signal generator. Display the signal on the oscilloscope. Report the amplitude and frequency of the signal as measured by the oscilloscope, along with their uncer- tainties. Compare these readings to those indicated by the signal generator. 2.5 Measuring Something Else: Current Our multimeters have a current setting as well as a voltage setting. Current is a flow of charge. This is like a water current, which is a flow of water, only we have charge flowing instead of water. We can write the flow of charge as I = Δ Q Δ t (2.1) where for us Δ Q is the amount of charge that has gone by in the time Δ t. Physicists normally use the letter I to represent electrical current. We should take a minute to think about what to expect when we allow charge to flow. Think of a garden hose. If the hose is full of water, then when we open the faucet, water immediately comes out. The water that leaves the faucet is

38 CHAPTER 2. ELECTRICAL MEASURING DEVICES far from the open end of the hose, though. We have to wait for it to travel the entire length of the hose. But we get water out of the hose immediately! Why? The new water coming in causes a pressure change that is transmitted almost instantly through the hose, and the water at the open end is pushed out. You can tell this is the case because the water immediately leaving the hose is warm and tastes like plastic hose. After a while, the water is colder and cleaner. Current behaves in the same way. When we flip a light switch, the electrons near the switch start to flow. But there are already free electrons in the wire. These experience a push that makes the light turn on almost instantly. But the electrons that turn on the light are not the ones that just went through the switch. Pictured another way, turning on the switch connects the wires to an electric potential. This potential results in an electric field propagating very quickly (like at speeds close to the speed of light) through the wires. As soon as that electric field hits any point of the wire, the free electrons there begin to move. 2.5.1 Current is a Flow Because current is a flow, to measure current we must put a meter into that flow. In a house, if you want to measure how much water is used, you connect the pipe from the city water system to a meter. The water flows through the meter and then goes into the pipe that brings water to the house. That way, the meter can’t miss any of the water (and the city can’t miss any of your payment!). The same is true for electrical current. To measure electrical current, we need to break open the circuit and install a meter through which all of the current must flow, as in Figure 2.13. In this diagram, you can see that the electric current must go through the current meter. In fact, it couldn’t go anywhere else because part of the original circuit wire is missing. This is just what we want. To actually perform this measurement with one of our multimeters you could set up a circuit like the one in Figure 2.14. There is one more important thing to do to make this work. We need to change the meter settings. And there are two separate changes. The first is to switch the probe connections. One probe stays in the COM or common connector, but the other needs to move to the connector marked with an “A” ˙ The “A” stands for the standard unit of electrical current, the Ampere or Amp. With the multimeter set up like this we would call it an ammeter . Ammeters measure electrical current. Figure 2.15 shows the probe connections for measuring current with two kinds of multimeters. Many multimeters have two ports for measuring current, one for milliamps (mA), and one for Amps (A). If you don’t know what the current is that you are trying measure, it’s always a good idea to start with the probe connected to the port designed to measure Amps. Too high a current will burn a fuse in the multimeter, or worse yet, destroy the multimeter.

2.5. MEASURING SOMETHING ELSE: CURRENT 39 Figure 2.13: Measuring current. The current meter must be positioned such that all of the current flows through the meter. Figure 2.14: Measuring current with a multimeter.

40 CHAPTER 2. ELECTRICAL MEASURING DEVICES Figure 2.15: Two multimeters prepared for measuring current. 2.5.2 The Physics of Measuring Electric Current We said before that physicists like to change any measurement they can into a voltage measurement, because, ultimately, that is the only thing that we can measure with electronics. So, if we want to measure current, the first thing we need to do is transform a current into a voltage. This is true not only for current, but for any other quantity that we would like to measure electroncially. In order to build a new instrument, we need to understand the physics of the thing that we really want to measure. Ohm’s Law Let’s keep thinking of current like water in a hose. Will there be any friction associated with the water traveling through the hose? Of course there will! We usually call friction in fluids viscosity . But it is a form of friction, and we can use our intuition about friction to see how it would work. Think of having two hoses, one twice as long as the other. Which would you expect to have more friction? Our friction experience says that the longer the path, the more the current interacts with the hose. The more the current interacts with the hose, the more friction it will experience. Electrical currents are like this. Longer wires give more friction. George Simon Ohm noticed that with long metal wires, there seemed to be a linear relationship between the potential difference (voltage), the current, and the length of the wire. The longer the wire, the less current a given voltage would produce. His work was confirmed and expanded on by others, who found that not only length mattered, but also the diameter of the wire mattered. The relationship is now expressed as Δ V = IR (2.2)

2.5. MEASURING SOMETHING ELSE: CURRENT 41 an equation referred to as Ohm’s law . The Δ V is our old friend, voltage, and the I represents current. The R in the equation represents the “friction” provided by the ciruit. Experiments show that this constant R depends on the material. It is like our viscosity in hoses. It is the friction. The more the friction, the harder it is to get the current through the wire. But like we don’t call viscosity “friction,” we also don’t use the word “friction” for this friction-like term. We call it resistance. We could solve for this resistance R = Δ V I (2.3) or we could plot Δ V vs. I and the slope of this line would be the resistance. Either way, this relationship tells us that it takes more potential energy to get the same current if there is more resistance. Ohm’s law holds well for metals and many materials, but, like Hooke’s law, this “law” does not always hold. Devices that do provide a constant resistance coefficient R are called resistors . In schematic diagrams, resistors are usually represented by zig-zag lines or by rectangles. In reality, they look more like Figure 2.16. Figure 2.16: A resistor. The colored bands indicate the resistance. Resistor Code Many commercially produced resistors come conveniently marked with a color code that helps you identify their resistance. The basics of the color code are seen in Figure 2.17. To use the code, do the following: 1. Find the tolerance code band. This band is usually brown in our kit resistors and often is set off from the others a little more. 2. Read the first color band from the side opposite the tolerance band. This will be the first digit of your resistance. I think the example resister on the chart has a yellow first color band, so the first digit of our resistance is 4 . 3. Read the second color band. This will be the second digit of your resis- tance. I think the second band of our example resistor is orange, so the second digit would be a 3 , making our resistance so far 43 4. Read the third color band. This will be the third digit of your resistance. I think the second band of our example resistor is red, so the second digit would be a 2 , making our resistance so far 432

42 CHAPTER 2. ELECTRICAL MEASURING DEVICES Figure 2.17: Resistor code. The use of this code is described in the text. 5. Read the forth color band. This is a multiplier. You multiply the first three digits by this amount. For our example resistance, I think the third band is black. Then we multiply 432 by 1Ω to get 432Ω . This is our resistance. 6. The tolerance band gives the uncertainty in this value. Our example resistor seems to have a brown tolerance band, which tells us our value is good to ± 1% . For our example resistance, 1% would be 0 . 01 × 432Ω = 4 . 32Ω , so our resistance is (432 ± 4Ω) . We won’t memorize the resistor code, but you should be able to find a resistance using the code. If you are in doubt about what color you see on a resistor, our multimeters can measure resistance directly. Place the red probe in the connector with a Ω marked on it and turn the dial to the Ω setting, as seen in Figure 2.18. Place the probes on either side of the resistance to be measured. Be careful/ You are a resistor too. If you touch your hands to the probes (common mistake while you try to hold the resistor on the probe ends) you may measure your resistance instead of the resistor’s! You have a resistance of around half a megaohm. This is a general concern, every time you measure resistance with a meter you need to take the circuit element (resistor, light bulb, whatever) out of the circuit and measure it on it’s own. Otherwise, you might be measuring the resistance of the rest of the circuit. Alligator clips are useful for this.

2.5. MEASURING SOMETHING ELSE: CURRENT 43 Figure 2.18: Multimeters prepared to measure resistance. A Note on the Direction of Current Flow There is a historical oddity with current flow. That is that the current direction is the direction positive charges would flow. This may seem strange, since in good conductors electrons are doing the flowing and they are negative! The electrons go the opposite way the current goes. Figure 2.19: Electron flow v. current flow. The usual charge carriers in circuits, the electrons, are negatively charged, and move opposite the direction of the conventional current. The truth is that it is very hard to tell the difference between positive charge

44 CHAPTER 2. ELECTRICAL MEASURING DEVICES flow and negative charge flow the other direction. As it turns out, mathemat- ically, the flow of electrons one direction is equivalent to the flow of positive charges the other direction, as seen in Figure 2.20. Why don’t we then just redefine current to be the flow of negative charge. For one thing, there are cases where it is positive charges that the charge carriers in a current. In biological systems, it is positive ions that flow, thus the resulting current arises from pos- itive charge carriers. Moreover, in semiconductors (special electronic devices in all computers and in our Arduinos) it is positive charge that flows. In many electrochemical reactions both positive and negative charges flow. Figure 2.20: Mathematical equivalence of positive and negative charge carriers flowing in opposite directions Ben Franklin chose the direction we now use. He had a 50% chance of making it easy for our electronics lab. But he got it backwards for us (but right for biology–and how many electronic things did Ben Franklin have anyway?). All this shows just how hard it is to deal with all these things we can’t see or touch that we study electricity and magnetism. We will stick with the convention that the current direction is the direc- tion that positive charges would flow regardless of the actual charge carrier motion. This may seem a little backwards at first, but we all get used to it. What makes the electrons or positive charges want to flow in the first place? We know the answer to this from earlier in this lab reading. It is potential energy. When we connect a metal wire to the terminals of a battery we know that the

2.5. MEASURING SOMETHING ELSE: CURRENT 45 charges in the metal wire ends will experience a difference in potential energy. The potential energy difference will set up an electric field inside the conductor. This field causes the free charges to experience a force, which subsequently causes their motion. We won’t have to measure any fields in our lab today, but you should know they are there. The important thing is to realize that voltages produce currents. And the amount of current is proportional to the amount of voltage, which is just Ohm’s law once again. 2.5.3 How to Build an Ammeter Ohm’s law gives us a way to relate current to voltage, provided that we have a resistor of known resistance. Knowing how to measure voltage, we can therefore also measure current. Consider adding an additional small resistor to our previous circuit (Figure 2.3), as seen in Figure 2.21. If we take a small resistance (one that is small compared to all the other resistances in the circuit) and put it in the circuit, it will slow the current more, but not by very much. If the resistance is small enough, we won’t even notice the change. Then if we measure the voltage across that small resistor with a voltmeter, we could mathematically calculate how much current we have. Let’s give this additional small resistor a name. Let’s call it the “shunt resistor.” Notice that this instrument design has two parts. The first is adding some new hardware to our voltmeter (a resistor) and the second is adding in some calculation to get our voltmeter reading converted into current. I = Δ V meter R shunt (2.4) Today we will do the calculation by hand. In future labs, we will use code to carry out calculations, so it happens automatically. Remember that when we try to make any sort of measurement using elec- tronics, the first step is to convert the thing we are trying to measure into a voltage, as we have done here. 2.5.4 Testing the New Instrument Any time we build a new instrument, we need to verify that it is working correctly. In this case, we are fortunate that our multimeters can also measure current. By comparing the current we measure with our new instrument to the current indicated by the multimeter, we can validate our new instrument. Remember that in order for a multimeter to measure current, the current must flow through it. We have to break the circuit somewhere and place the multimeter into the flow, as done in Figures 2.13, 2.14, and 2.21. Also remember that when you are using a multimeter to measure current, you want to start by assuming that the current will be high. Turn the dial of the multimeter to the highest current setting, and make sure that the red probe is connected to the right port on the multimeter. If the multimeter reads zero

46 CHAPTER 2. ELECTRICAL MEASURING DEVICES Figure 2.21: Building an ammeter. The process includes adding a shunt re- sistor to the ciruit and measuring the voltage across the shunt resistor. When this measured voltage is known along with the shunt resistance, current can be calculated. The portion of this circuit constituting the ammeter is enclosed in the dotted red line. In this circuit, an additional multimeter, measuring current directly, is included.

2.6. PROPAGATION OF UNCERTAINTY: A REVIEW 47 current, it could mean (a) that the fuse in the multimeter is blown (you can check this by trying to measure a known current, say from a DC power source that displays the current as well), or (b) the current is smaller than what the multimeter can read on the current setting. In the latter case, you will need to change the dial on the multimeter to a lower current setting and reconnect the red probe to a different port. As it turns out, when a multimeter measures current, it uses the same method we have been discussing. The multimeter includes a few networks of small, known resistances. The current is sent through the appropriate resistor network, and the voltage across that network is measured. The multimeter then calculates the current and displays it. After we calculate the current from our known shunt resistance and measured voltage across the shunt resistor, we can compare it to the current displayed by the multimeter. It the two numbers agree, we can be confident that our newly built ammeter is working properly. However, there is a complication. Recall that every measurement carries an amount of uncertainty, and current measurements are no different. It’s pretty easy for us to judge the amount of uncertainty that the multimeter reading has, but our calculated value for current has uncertainty coming from two sources: the resistance of the shunt resistor and the measured voltage across the shunt resistor. Now is probably a good time to review how measurement uncertainty propagates into our calculations. 2.6 Propagation of Uncertainty: A Review Every measurement has an uncertainty, so any quantity calculated from a mea- surement has an uncertainty also. If there are multiple measurements going into a calculation, we have to account for multiple uncertainties. This is most easily done using derivatives. The derivative of a function at a particular point tells us how quickly the function is changing at that point. Imagine that we have some function y ( x ). The derivative of the function with respect to time, dy/dx , at a particular position x , can be represented by the tangent line that goes through the point y ( x ), as seen in Figure 2.22. Now suppose there is an uncertainty δx in the position x . Because of that uncertainty in x , I would also have some uncertainty in y . I have two ways I could determine the range of possible values that y ( x ) could take on: 1. I could simply calculate the value of y ( x ) at the extreme possible values of x , i.e. calculate y ( x - δx ) and y ( x + δx ). These two values are represented by the red dots in Figure 2.22. As long as y ( x ) is monotonically increasing or decreasing in the range x ± δx , then these two values of will represent the highest and lowest possible values of y ( x ) for the range of possible values in x . 2. As long as δx is small, I could approximate the function y ( x ) as a line. The

48 CHAPTER 2. ELECTRICAL MEASURING DEVICES Figure 2.22: Using derivatives to approximate uncertainties. The black dot represents the value of the function at a specific point. The red dots represent the values of the function at two other points bracketing the uncertainty in the independent variable. The blue points show the same two values on the tangent line. values of the function at the extreme ends of our range of x are represented by the blue dots in Figure 2.22. The equation of this tangent line is f ( x ) = mx + b (2.5) where the slope m is the derivative of y ( x ) at x , i.e. f ( x ) = dy dx x + b (2.6) It is understood, in this equation and those that follow, that the derivative dy/dx is evaluated at our particular x . The intercept b is unknown at this point, but it turns out we won’t need it anyway. If I now wanted to estimate how much y ( x ) changes as I go from x to x + δx , I could make use of this line: y ( x + δx ) - y ( x ) ≈ f ( x + δx ) - f ( x ) = dy dx ( x + δx ) + b - dy dx x + b = dy dx x + dy dx δx + b - dy dx x - b

2.6. PROPAGATION OF UNCERTAINTY: A REVIEW 49 In the last line of this equation, the two dy dx x cancel, as do the two unknown intercepts b , leaving us with y ( x + δx ) - y ( x ) ≈ dy dx δx or simply y ( x + δx ) ≈ y ( x ) + dy dx δx (2.7) Similarly, if we considered the value of y ( x ) at x - δx , we would obtain y ( x - δx ) ≈ y ( x ) - dy dx δx (2.8) We can see that in this approximation, an uncertainty δx in the vari- able x yields a consistent variation in y ( x )). Consequently, we write the uncertainty in y ( x ) as δy ≈ dy dx δx (2.9) Since our measurement uncertainties will almost always be relatively small, we will be making use of the second method almost exclusively. What if our calculated value depends on more than one measurement? In other words, what if instead of an y ( x ) I have an y ( x, z ), where x and z both represent measured quantities with uncertainties δx and δz ? We can easily find the uncertainty that arises in y ( x, z ) from each of the two measurements independently by using partial derivatives. We would obtain δy x ≈ ∂y ∂x δx (2.10) δy z ≈ ∂y ∂z δz (2.11) The question now remains, how to we “add” these two uncertainties together? If x and z are independent variables, then we would end up adding the two uncertainties in quadrature (which is a fancy way of saying we’ll use the Pythagorean theorem). The reason for this can be seen in Figure 2.23. If I had a variation in both x and z , the total variation would be represented by a diagonal line, and the three lines together would form a right triangle. The result is that our total uncertainty in y ( x, z ) becomes δy = p δy 2 x + δy 2 z = s ∂y ∂x δx 2 + ∂y ∂z δz 2 (2.12) If our calculated value had more than two measurements associated with it, we would just iterate this process a few more times. the result would be δy = v u u t X i ∂y ∂x i δx i 2 (2.13)

50 CHAPTER 2. ELECTRICAL MEASURING DEVICES Figure 2.23: Variation in a function of two variables where the x i and δx i would represent the measurements and their respective uncertainties. Tie to statistics For experiments where we repeat the same experiment over and over again, our outcome can be given by the mean value an our uncertainty can be given by the standard deviation. We need to tie our statistical ideas into what we have learned about error propagation. Lets go back to our function y ( x, z ) the error is given by δy = s ∂y ∂x δx 2 + ∂y ∂z δz 2 If instead of uncertainties in x and z , what we had were standard deviations σ x and σ z , we would find the standard deviation in y as σ y = s ∂y ∂x σ x 2 + ∂y ∂z σ z 2 When measured values are subject to fluctuation, one way to get an estimate of uncertainty like δx or δz above is to make many measurements, and use the standard deviation σ x as an estimate for δx and σ z for δz. This is usually not too far off.

2.7. CALCULATING THE UNCERTAINTY IN CURRENT 51 2.7 Calculating the Uncertainty in Current Getting back to our home brewed ammeter now, we were calculating the current from a known resistance and measured voltage, via the equation I = V m R s (the m subscript indicates “measured” and the s subscript indicates “shunt”). The resistors we are using typically have a tolerance of about 5%, meaning that the relative uncertainty in the resistance (as read from the colored bands on the resistor) is 5%, or δR s = 0 . 05 R s . The uncertainty in our voltage reading is (probably) just the precision of the multimeter display for that measurement. To find the uncertainty in the current, I would need to know the partial derivatives ∂I ∂V m = 1 R s ∂I ∂R s = - V m R 2 s and the uncertainty in the current would therefore be δI = s 1 R s δV m 2 + V m R 2 s δR s 2 (2.14) where we’ve dropped the negative sign for the derivative with respect to R s , since it will go away when squaring that term anyway. LAB ACTIVITY Build an ammeter from a shunt resistor and voltmeter. • Choose a resistor in the 10-50 kΩ range. Use this as the resistor for the primary part of the circuit. • Choose a shunt resistor with maybe a few hundred Ohms of re- sistance. Use the colored bands to determine the resistance and tolerance of this resistor. • Set up the circuit in Figure 2.21. • Turn on the DC power supply to provide voltage. Record the volt- age drop across the shunt resistor along with its uncertainty, as well as the current read by the second multimeter and its uncertainty. • Calculate the current, and its associated uncertainty, from your shunt resistance and measured voltage.

52 CHAPTER 2. ELECTRICAL MEASURING DEVICES • Compare your calculated current to the reading on the second mul- timeter. How well did your ammeter work?

Chapter 3 First DAQ Measurements: Voltage OBJECTIVES At the conclusion of these laboratory activities, you should be able to do each of the following: • Describe the function of an analog to digital converter, and identify the limitations of analog to digital conversion. • Calculate the uncertainty in a voltage measurement arising from analog to digital conversion. • Identify the voltage limits of the Arduino, and how one can avoid exceeding those limits. • Build a voltmeter using the ADC on an Arduino that can measure 0-5 Volts. • Build a voltmeter using the ADC on an Arduino that can measure 0-30 Volts. ITEMS TO REVIEW Please review the following concepts as part of your preparation for this lab. • Electric potential and voltage. Let’s review what we learned last week. When we are making measurements electronically, we are ultimately measureing voltages. If the data is not a voltage, 53

54 CHAPTER 3. FIRST DAQ MEASUREMENTS: VOLTAGE we must convert it into a voltage. We have already converted current into a voltage (using a shunt resistor). What is a voltage? Let’s review quickly. In the last lab we said that voltage is a measure of electrical potential energy. It is also likely that you are familiar with the word “voltage” because we live in a world that has electricity everywhere. You probably know that your house or apartment has wires in the walls that carry “110 Volts”, and you probably realize that “voltage” is a measure of how much energy there is in the wires. For today, the key things for us to remember are (1) that voltage is propor- tional to an electrical potential energy difference, and (2) that when we measure voltage we are measuring something proportional to energy. Because voltage is proportional to a difference in electrical potential energy, a voltage measurement really is a combination of two measurements. Think of gravitational potential energy. If we ask for the potential energy difference as Super Guy jumps from the bottom of a building to the top we need two measurements, one at the bottom and one at the top (Figure 3.1). The potential energy difference is then found by taking the difference in energies at the top and bottom of the building: Δ U g = U g top - U g bottom Figure 3.1: Gravitation potential energy difference is found by taking the differ- ence of potential energies between the initial and final position. We will do something very similar in measuring voltages. We will measure the potential energy at two places. For example, suppose we have an electric circuit as shown in Figure 3.2. The circuit is very simple, just a battery and a resistor. A battery is just a source of electric potential energy, and a resistor is just a piece of material that has lots of electrical friction, or “resistance” that makes it hard for electrons to go through it. If we want to measure the voltage across the resistor, we have to measure on the top and bottom of the resistor. That will give us a measurement proportional to the potential energy difference from one side to the other of the resistor.

3.1. BUILDING A VOLTMETER 55 Figure 3.2: Measuring electric potential energy difference, or voltage. Two mea- surements are required, one where the potential is high, and one where the po- tential is low. The voltage is the difference between these two measurements. As we saw in the last lab, most meters that measure voltage (“voltmeters”) have two “probes”. The meter reads a potential from each probe and completes the difference calculation internally. These meters are called voltmeters and we used them last week. In today’s world, voltmeters are usually just one function provided by multimeters. We learned to use a stand-alone voltmeter in the last lab. Now we also need to read in voltages in a way that the data can be transferred automatically to a computer. To do this, we will use the analog pins on our Arduino board. Before we begin, we need a warning. We absolutely must not wire up the analog pins on our Arduino backwards! This can (and probably will) destroy the pin circuitry inside our Arduino. So we will need to be careful in wiring for this part of our lab. Where this could be a problem a warning sign (seen in Figure 3.3) will appear in the text, just to remind you to be careful! You may see quite a few of these in this lab. Figure 3.3: An example warning sign. Wiring an Arduino incorrectly can de- stroy parts of the Arduino. When this is a possibility, you will see this warning sign. 3.1 Building a Voltmeter To act like a voltmeter that communicates with a computer, the Arduino needs to do three things: 1. Read the voltage signal. 2. Convert the voltage signal to a number.

56 CHAPTER 3. FIRST DAQ MEASUREMENTS: VOLTAGE 3. Send the data to the computer. Let’s look at these in greater detail. 3.1.1 Analog Pins on the Arduino Analog signals are read at the analog pins on the Arduino. These can be seen in Figure 3.4, and are labeled A0 through A5. You will also note that there are two ground (GND) connections on this side of the Arduino. When measuring voltages with the Arduino, the wires that we use as our probes will go into one of the A0 to A5 pins and into one of the GND pins, or into two of the A0 to A5 pins. Figure 3.4: The analog pins on the Arduino, seen on the right side and labeled A0 through A5. 3.1.2 Analog to Digital Conversion Our Arduino has a device on board called an Analog to Digital converter (ADC). That is, it takes analog voltage signals that could have any value, and it maps them into a set of discrete values and sort of rounds to the nearest whole discrete value. The word “analog” might not be familiar. Think of our power supply. It has a knob that adjusts the voltage. The knob can produce any voltage from 0 to about 30V. This is an analog signal. The voltage can take on any value in that range. We represent an analog value with a real number. We might have a voltage of exactly 4 . 3276854325532573457V

3.1. BUILDING A VOLTMETER 57 and this would be perfectly valid for an analog signal. A battery, on the other hand, does not work this way. It has a fixed voltage. The common AA and AAA batteries have a fixed voltage of 1 . 5V. Two AA batteries could be used together to make 3V . But you can’t use AA batteries to get 2 . 25V . The batteries come in discrete units. Our Arduino analog pin is designed to measure voltages in the range 0 to 5V . Anything more than 5V will more than likely destroy part (or all) of your Arduino, so we have to be careful! But there is more to the ADC than just a voltage range. This is necessary if we are to store the voltage value digitally. Digital devices, like computers, work with numbers in binary. As you may know, binary is a number system where each digit of a number is either a one or a zero. Binary numbers are easy for computers to work with, since computers only store information in “bits” that are either on or off. The more bits you have, the larger the number you can represent. The ADC on the Arduino has a 10 bit register for storing data. The largest number that can be represented by ten binary digits is 1023 (all ten digits are ones), and the lowest number that can be represented by ten binary digits is zero (all ten digits are zeroes). Thus, the Arduino must take the 0-5 Volt range as chop it into 1024 voltage divisions. Each division is then Δ v min = 5V 1024 = 4 . 9mV These divisions are represented in Figure 3.5. Figure 3.5: Discretization of voltage measurements on an Arduino. The Ar- duino can measure a range of 0-5 Volts, but the digital representation of that measurement is stored in a limited number of bits. As a result, the continuous 5 Volt range is chopped up into smaller divisions. Changes in voltage that are less than 4 . 9mV cannot be measured by an

58 CHAPTER 3. FIRST DAQ MEASUREMENTS: VOLTAGE Arduino, since it takes a whole 4 . 9mV to get a different division. So if we give our Arduino 8mV this is not enough to fill the second 4 . 9mV division, so our Arduino would still read only 4 . 9mV . If we gave it 11mV it would then read 9 . 8mV because 9 . 8mV = 2 × 4 . 9mV and 9 . 8 is the closest whole unit of 4 . 9mV . This is called “discretization” or more commonly “digitization” or even “ quantization.” We have taken a signal that might have any value between 0 to 5V and we output a signal that will be rounded to the nearest n × 4 . 9mV . A helpful analogy is to think about a ramp next to a set of stairs. The ramp is like the analog signal. You can be at any elevation between the bottom and the top of the ramp. The stairs are like the digital representation of that signal. There are only discrete elevations that you can obtain. When we convert an analog signal to a digital signal, we basically just report whatever “step” is closest to the analog value. As a second example, consider using our Arduino to measure a voltage of 3 . 793V. We can only measure in steps of 4.9 mV, and if we divide our voltage by that minimum step size, we get 3 . 793V 4 . 9mV = 774 . 08 The Arduino has to record this ratio as an integer value, so the 0.08 would be dropped, and the ADC would simply report that the measurement is on step 774, which corresponds to 774 × 4 . 9mV = 3 . 7926V. Similarly, let’s consider the 4 . 3276854325532573457V from our hypothetical power supply. Following the same method, the Arduino finds that this is closest to “step” 883 in the ADC, which corresponds to 4.3267 Volts. (Make sure you can see how this result is obtained!) All of this means that, when we measure voltages with our Arduino, we can be off in our voltage measurements as much as 4 . 9mV! In dividing up our voltage range into 1024 pieces we have introduced some error, but we have divided our 0 to 5V into numeric values that we can use in our computer, so it is worth the cost of some error. The amount of error depends on how many different values the ADC con- verter has. Since breaking an analog signal into discrete values is called quanti- zation, we call this source of error quantization error. It is the source of much of the error we see in electronic measuring devices. We could say that our new voltmeter has an uncertainty of at least the voltage resolution δV signal = Δ V min = 4 . 9mV but of course it could be larger if there are other sources of error. One way to reduce the amount of quantization error in a measurement like this is to use a data register with more bits. A ten bit register has 1024 (2 10 ) discrete values. A twelve bit register would have 2 12 = 4096 discrete values. Modern computer chips work with 64 bit registers, which have 2 64 = 1 . 845 × 10 19 discrete values! Of course, the only way we could increase the number of bits available on the Arduino’s ADC would be to start replacing physical elements on the Arduino

3.1. BUILDING A VOLTMETER 59 board. We’re not going to attempt that, so we’ll just have to live with our 4.9 mV quantization uncertainty. It’s important to note at this point that the ADC does not record the voltage. Rather, it records which “step” the voltage corresponds to. This integer value is sometimes referred to as an ADC unit. If we have a signal voltage of 9 . 8mV, the ADC doesn’t provide us with a “9 . 8”, but instead it provides a “2” because 9 . 8mV = 2Δ V min . The ADC units are the number of Δ V min sized units that are in our signal voltage. To get back to voltage units, we need to multiply the ADC units by Δ V min . In our code we will do this before sending the value to the computer. 3.1.3 Sending the Data to the Computer The Arduino reads voltage in discrete steps, but can also do further processing with the ADC values. Of course, we would like to record the voltage that we measure rather than the ADC value. There is a simple way to do this in the Arduino sketch, and that is simply multiplying the ADC value by the Δ V min . The voltage values we calculate can be sent to our computer through the serial cable. We will need an Arduino sketch with some additional setup and some additional loop commands. One of these commands will turn our ADC units into volts. Before we look at the entire sketch, let’s introduce the new commands that we will need. To get the Arduino to communicate with the computer we use the command Serial.begin(9600); in the setup portion, and in the loop func- tion we use the command Serial.print(); . The Serial.begin(9600); instructs the Arduino to start sending data out through the serial port (phys- ically, this is the USB cable that you connect to your computer). The 9600 argument to this function tells the Arduino to send this data at 9,600 bits per second (a.k.a. 9,600 baud). (As a side note, we will be sending text to the serial port in today’s activities. The text characters are represented by an eight digit - or eight bit - binary number. Consequently, each text character requires eight bits to be sent to the serial port.) Both ends of the serial communication - in this case our Arduino and the computer - need to know what the baud rate is for the communication. If my Arduino is sending information at 9,600 bits per second, but my computer is only expecting to read 4,800 bits per second, the computer will “miss” half of the data the Arduino is sending! The serial monitor built into the Arduino IDE (which is where we’re sending our serial data today) expects data at 9,600 bits per second, which is why we are sending the information at 9,600 baud. The Serial.print() function translates the character string passed as an argument into binary and sends it down the serial port pipeline. We also need to know that computers make a distinction between integer and real numbers. Our voltages will be real numbers, so we need to tell the Arduino that we want a real number. The data type for real numbers is the word “float.” For example, float delta v min=0.0049; defines a real number variable named “delta v min” and sets it to the value 0 . 0049 . If we want an integer

60 CHAPTER 3. FIRST DAQ MEASUREMENTS: VOLTAGE number we use the data type “int.” For example int value = 0; defines an integer variable named “value” and sets it equal to 0. If you are familiar with Python, you know that creating a list of variables near the beginning of your code is a good idea, not only so you can be sure that all of your variables are properly initialized, but because it also makes it a lot easier to decipher your code later on. With the Arduino (as with C or C++), if you don’t declare your variables up front, the code will not compile, and the Arduino software will spit out an error message. We also need special commands to read our Arduino analog pins. The special Arduino command analogRead(); will do this. The whole Arduino sketch might look like this: ///////////////////////////////////////////////////////// // very simple voltmeter // will measure 0 to 5V only! // Voltages outside 0 to 5V will destroy your Arduino!!! // Don’t wire this backwards! ///////////////////////////////////////////////////////// // define a variable that tells which analog pin we will // use int AI0 = 0; //AI0 stands for analog input zero // define a variable that holds our Delta_v_min float delta_v_min=0.0049; // volts per A2D unit // define a variable for our A2D version of our signal int ADC_value = 0; // define a variable for our voltage version of our signal float voltage = 0.0; ///////////////////////////////////////////////////////// void setup () { // put your setup code here, to run once when your // Arduino starts up: // // Initiate Serial Communication, so we can see the // voltage on our computer Serial . begin (9600); //9600 baud rate } ///////////////////////////////////////////////////////// void loop () { // Read in the voltage in A2D units form the serial port // remember that AI0 is the pin number to read from ADC_value = analogRead (AI0); // Let’s print out our A2D version of our signal Serial . print ( " A2D " ); Serial . print (ADC_value);

3.1. BUILDING A VOLTMETER 61 // Now convert to voltage units using delta_v_min voltage = ADC_value * delta_v_min; // And print out our voltage version of our signal Serial . print ( " voltage " ); // Print the voltage with 4 significant figures) Serial . println (voltage, 4); } ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// Make sure you understand every line of this code. Write it in the Arduino IDE and run it to help see what the lines do. Remember that lines that begin with two slashes, “//,” are comments. The Arduino will ignore these lines, but you shouldn’t! The comments tell you, the programmer, what the code is doing. It’s a good habit to include comments for every line. If there is any part of this sketch that is mysterious, work with your group to resolve the mystery and if it is still mysterious, call your instructor over to discuss the sketch with you. 3.1.4 Wiring the simple voltmeter Now we’re ready to build our voltmeter. You knew that was coming, didn’t you? We must be very careful to wire our Arduino correctly. Our Arduino can measure 0 to 5V . But if we switch the 5V and the 0V by plugging them into the wrong pin, our Arduino will be damaged and will never work the same way again (probably won’t work at all!). So wire first, then before you connect the Arduino have a group member check your wiring, then check the wiring with a stand-alone meter (that is why we learned to use them last time). Also remember, signals of more than 5V (or less than 0V) will damage the Arduino. So only put in voltages in the range 0V to 5V . We need one wire attached to the pin marked A0. We need another wire attached to one of our Arduino ground pins marked GND. And we connect the first wire to the positive output of our signal source (say, our power supply) and the GND wire to our negative output of our signal source (say the negative or ground connection on our power supply). That is all there is to it! 3.1.5 Seeing the data Once the code is compiled and uploaded, the Arduino will send data to the serial port. The serial monitor can display the data. The serial monitor is found under

62 CHAPTER 3. FIRST DAQ MEASUREMENTS: VOLTAGE the Arduino Software Tools menu (Figure 3.6). Figure 3.6: Serial Monitor location in the Arduino IDE. When activated, the serial monitor will look something like Figure 3.7 Figure 3.7: The Serial Monitor window. The Arduino Software can also plot the data from the serial port. This is accessed just below the serial monitor in the Arduino IDE menu. Figure 3.8 shows a plot of the same data that we saw in Figure 3.7. In this image, we are

3.1. BUILDING A VOLTMETER 63 plotting both our voltage values and our ADC values. This makes the voltage values hard to see (since they are very small, numerically, in comparison with the ADC values). We could fix this by commenting out the lines that print the ADC values (putting “//” at the beginning of the line), so that those lines won’t be executed by the Arduino. Then we get just the voltage (Figure 3.9. Notice that the horizontal axis does not represent the exact time. It is just a data point number. We could convert this to time with some calculation if we know how often the Arduino sends us a data point. This will be left as an exercise. Figure 3.8: The Serial Plotter window. Figure 3.9: The serial plotter with voltage only. The Arduino is now measuring the voltage (or rather the voltage ADC value), converting it to usable data, and sending it to our computer! Eventually we will want to be able to save this data to a file, so it can be used later. That will be a topic for the next lab period.

64 CHAPTER 3. FIRST DAQ MEASUREMENTS: VOLTAGE LAB ACTIVITY Build and use a simple Arduino voltmeter. 1. Build a circuit with a power supply and a resistor as in Figure 3.2. You can choose any resistor. 2. Write the simple voltmeter sketch. 3. Wire the Arduino across the resistor, and measure the voltage across the resistor using the Arduino and the serial monitor. Be careful to stay in the 0 to 5V range! 4. Calculate the uncertainty due to quantization error for your Ar- duino simple voltmeter 5. Compare your calculated uncertainty to the measured uncertainty that you see in your device output. (This is tricky, does the power supply give a truly constant voltage?) 3.2 Extending our voltmeter with a voltage di- vider This Arduino-based voltmeter that we have built is great, but will only let us measure voltages in the range 0 to 5V . That seems a little restrictive. We would like to extend our voltmeter to a larger range, say, 0 to 20V . To do this, we will need to add some electronic components and think about what we have learned about voltage, resistance, and current. Let’s consider the circuit in Figure 3.2, which consisted of a battery and a single resistor. We have a battery, which will make the current flow much like a pump makes water move through pipes. The water in a pipe system (Figure 3.10) gains potential energy as it moves up. In our circuit we will find that electric charge gains potential energy as we move it across a battery. Then the charge will move down the wire like water moves down a pipe until it is out of potential energy. Notice that the water in a pipe system will lose all the potential energy that it gained when the pump raised it to the upper tank (see Figure 3.10). That is true of electric charge too. The electric current travels from the battery through the resistor, but in doing so it loses all the potential energy that the battery gave it by the time it returns

3.2. EXTENDING OUR VOLTMETER WITH A VOLTAGE DIVIDER 65 Figure 3.10: Water pump analogy for a simple resistor circuit. The pump and the battery play the same role. to the battery. Now suppose we have two resistors in a circuit, as in Figure 3.11. Figure 3.11: A two-resistor circuit. The two resistors in series are also called a voltage divider. Our water analogy can still help us understand what will happen. Suppose that we have two turbines in our pipe system, as in Figure 3.12 The water leaves the high potential energy part of the pump, and is put to work turning the first turbine. The resistance of the turbine will slow the water current. So when the water leaves the turbine, it will have lost some potential energy. Since we have a second turbine the current will again be slowed and more potential energy will be lost. How much potential energy do we lose as the water falls? All of the potential energy that the pump gave it! We must end up with the water at the bottom back at the low potential energy. We will find this to be true for our electric circuit as well. We will lose some potential energy as the electrical energy “falls” from the high electric potential “down” the first resistor. After the second resistor, we can guess that we must be back at the low electric potential we started with. In summary, the electric potential supplied by a battery (or any other source

66 CHAPTER 3. FIRST DAQ MEASUREMENTS: VOLTAGE Figure 3.12: A water pump system with two turbines, analogous to a two resistor circuit. of potential) will be entirely “used up” by the time the current goes through the entire circuit. When I have two resistors in series with a battery, as in 3.11, only part of the potential is used up in the first resistor, and the rest is used up in the second resistor. Consequently, if our power source was a 9.0 V battery, and the two resistors had equal resistance, the potential would only drop 4.5 V in the first resistor, and then the remaining 4.5 volts in the second resistor. We have effectively divided a (larger) voltage into two smaller parts, and consequently these two resistors in series are known as a voltage divider . Note that you don’t have to use two resistors with equal resistance in a voltage divider. The fraction of the voltage “used up” in each resistor ends up being proportional to the resistance (in comparison with the total resistance) as we will see. For example, if we had a 30 V power source (more than sufficient to send our Arduino to the scrap bin) combined with a voltage divider consisting of a 1000 Ohm resistor and 5000 Ohm resistor, the total resistance would be 6000 Ohms. The fraction of the voltage that will be used up in the first 1000 Ohm resistor is (1000 Ohm)/(6000 Ohm), or 1/6. 1/6 of 30 V is 5 V - a potential difference that is safe for our Arduino! The remaining 25 V of potential will be used up across the 5000 Ohm resistor. Let’s take a look at the math in a little more detail. We know that electric potential is a potential energy per unit charge, and energies just add up. If Δ V = RI is satisfied, then we would expect that adding two resistors would just linearly add the effects of the two resistors together Δ V total = Δ V 1 + Δ V 2 = R 1 I + R 2 I Note that the same current must flow through each of the resistors, since the

3.2. EXTENDING OUR VOLTMETER WITH A VOLTAGE DIVIDER 67 current leaving R 1 is the current flowing into R 2 . Then Δ V total = ( R 1 + R 2 ) I Our current will be I = Δ V total R 1 + R 2 Figure 3.13: Measuring voltage in a voltage divider. But suppose we measure the potential change across just resistor R 2 , as in Figure 3.13. What would we expect to get? We lost voltage across both Δ V 1 and Δ V 2 so Δ V total = Δ V 1 + Δ V 2 because we must lose all the Δ V total given to the current by the battery. And Δ V 2 = IR 2 from Ohm’s law. So Δ V 2 = Δ V total R 1 + R 2 R 2 This is only part of the total voltage, and if we have two different resistors so that R 1 6 = R 2 then we can choose for Δ V 2 to be nearly as much as Δ V total or nearly as little as 0 by carefully choosing our two resistances. We call a set of two resistors like this a “voltage divider” because it divides the battery voltage between the two resistors. If R 1 is bigger than R 2 then Δ V 1 is bigger than Δ V 2 . Remember that the input can only withstand 0 to 5V . More than that can destroy the board! But we want to measure a voltage that varies from 0 to 20V . We now have a way to do this. We will use a voltage divider. The voltage across both resistors will be as much as 20V , but we will measure the voltage across only one of the resistors. We will choose our resistor so that when the total voltage is 20V but the voltage across our resistor is 5V (or less). Since we will know the resistances, we can use a little math to calculate what the total voltage was using the voltage measurement from just one of the resistors. This is like what we did to measure current last lab. We used a voltmeter and a resistor and some math to make an ammeter. Today we will use two resistors, our Arduino voltmeter, and some math to make a new voltmeter that can measure higher voltages. We just need to choose our resistors so that we map our 0 to 20V to 0 to 5V . Once choice might be R 1 = 40kΩ R 2 = 10kΩ

68 CHAPTER 3. FIRST DAQ MEASUREMENTS: VOLTAGE Let’s try it. We would get Δ V 2 max = 20V 40kΩ + 10kΩ (10kΩ) = 4 . 0V when Δ V total = 20V and Δ V 2 min = 0V 40kΩ + 10kΩ (10kΩ) = 0V when Δ V total = 0V . Notice that this really didn’t work. We only got a maximum voltage of 4V . But this gives us a margin of safety. If we give our Arduino more than 5V we can burn it up. If we plan our circuit so we don’t get too close to 5V we are safer. So this set of resistors is not a terrible choice. To report out our voltage we need to do this conversion backwards. Say we have Δ V total = 10V that we are measuring with our new instrument. Then Δ V 2 = 10V 40kΩ + 10kΩ (10kΩ) = 2V The 2V is what we actually measure at the A0 input. But we know that this represents 10V across both resistors, so we want the Arduino program to print out 10V . So we report Δ V reported = Δ V 2 R 2 ( R 1 + R 2 ) or for our case, since we measured 2V across our resistor, 10V = 2V (10kΩ) (40kΩ + 10kΩ) We will have to write this math in our code. There is a further complication. The Arduino A0 input is giving us a number that represents 0 to 4V for our setup. But that is not what we see on the serial port. We see a number from 0 to 1024. We know the 1024 represents 5V and the 0 represents 0V . So we need to multiply the number that comes from our Arduino by δV = 4 . 9mV once again to get our Arduino output into voltage units. So our reported voltage equation is something like this. Δ V reported = A 2 D × δV 2 × 1 R 2 ( R 1 + R 2 ) All this calculation to get our reported voltage must do something to our measurement uncertainty. We could do our usual math to find the reported un- certainty, but instead, let’s think. Every small voltage Δ V 2 would be multiplied

3.2. EXTENDING OUR VOLTMETER WITH A VOLTAGE DIVIDER 69 by 1 R 2 ( R 1 + R 2 ) to map it into our original 0V to 20V range. That should work for our smallest voltage that we can detect, namely δV = 4 . 9mV . That is the smallest value Δ V 2 could have. So in our 0V to 20V range the smallest value this can map to is δV reported = ( δV ) 1 R 2 ( R 1 + R 2 ) The first term in parenthesis is essentially 1 digitizer unit multiplied by Δ V 2 and the second term in parenthesis converts the Δ V 2 value into actual volts measured across both resistors. The quantity δV reported gives us our quantization error value for our new instrument. Our output will be in multiples of V reported = n × δV reported Putting in numbers gives δV reported = ( 4 . 884 × 10 - 3 V ) 1 10kΩ (40kΩ + 10kΩ) = 0 . 024 42V = 24 . 42mV This is much bigger than our 4 . 9mV uncertainty for the simple voltmeter. This is the cost of using a voltage divider to extend our voltage range. For the bigger voltage range we get a bigger uncertainty. Let’s try another example. Suppose we wish to measure 0 to 20V and we look in our case of resistors and find we have the following two resistors to use: R 1 = 98kΩ R 2 = 15kΩ We would expect that our 0 to 20V would be mapped to a smaller range. Let’s find that range. Δ V 2 max = 20V 98kΩ + 15kΩ (15kΩ) = 2 . 654 9V So our voltage range at the Arduino A0 input will be 0V to 2 . 65V . This set of resistors won’t use the full Arduino 0V to 5V range. But it will measure 0 to 20V . The minimum detectable voltage for this new instrument design for our 0 to 20V source will be δV reported = ( δV 2 ) 1 R 2 ( R 1 + R 2 ) = ( 4 . 880 3 × 10 - 3 V ) 1 (15kΩ) (98kΩ + 15kΩ) = 3 . 676 5 × 10 - 2 V = 37mV

70 CHAPTER 3. FIRST DAQ MEASUREMENTS: VOLTAGE This uncertainty is much bigger than the uncertainty for our last choice of resistors. So 98kΩ and 15kΩ are not great choices even though they technically work. For your version of the voltmeter in lab, you will choose the resistor values to use. Here is an Arduino sketch to implement this extended volt meter. In it are the not-so-good 98kΩ and 15kΩ , but of course you should change the sketch to have your resistor values . ///////////////////////////////////////////////////////// // Extended Voltmeter // This voltmeter with the values given below // is designed to measure a 0 to 20V range with 1024 // discrete values of with an uncertainty of about 0.02V ///////////////////////////////////////////////////////// //set up a variable to represent Analog Input 0 int AI0 = 0; // Resistance of R1(put in your actual value here) float R1 = 98000.0; // Resistance of R2(put in your actual value here) float R2 = 15000.0; int ADC_value = 0; // Place to put the A2D values float voltage = 0.0; // calculated signal voltage //mV Arduino’s minimum detectable voltage float delta_v_min = 0.0049 ///////////////////////////////////////////////////////// void setup () { //Initiate Serial Communication Serial . begin (9600); //9600 baud rate } ///////////////////////////////////////////////////////// void loop () { // read the serial data from AI0 ADC_value = analogRead (AI0); // if you want to, print out the channel A2D values. // Uncomment if you want them. //Serial.print("analog channel value "); //Serial.print(ADC_value); // calculate the signal voltage voltage=ADC_value * (delta_v_min) * (R1+R2)/R2; // print out the signal voltage Serial . print ( " voltage " ); Serial . println (voltage, 4); }

3.3. PRACTICE PROBLEMS 71 ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// Of course you will want to have another person check your math and wiring, and you should check your output voltage with a stand-alone meter before you plug into your Arduino. 3.3 Practice Problems Here is an example for you to work out on your own before class. Do this and compare your result to the results of the other people in your lab group as you come into class on lab day. Suppose we wish to measure 0 to 15V and we look in our case of resistors and find we have the following two resistors to use: R 1 = 43 . 2kΩ R 2 = 15 . 2kΩ What range of voltages would we see at the Arduino, and what is the quanti- zation error for our measurement?

72 CHAPTER 3. FIRST DAQ MEASUREMENTS: VOLTAGE LAB ACTIVITY Build an extended voltmeter using a voltage divider. 1. Build the voltage divider using two resistors as described in Section 3.2. You will have to think about which resistors from our set will work best. Discuss this with your group, or have group members try the calculations with different combinations. 2. Use a multimeter to verify that the output of the voltage divider is never more than 5V and never less than 0V . Take your power supply all the way from 0V to 20V (or whatever the maximum of the power supply is) and watch the multimeter to ensure it stays in the 0 to 5V . range. Do this with a multimeter before you hook up your Arduino. You are making sure everything works so you won’t destroy your Arduino! 3. Write the sketch and then hook the output of your voltage divider to the A0 pin and the other side of R 2 to a GND pin. Your volt- meter should now be set up. Compile and load the sketch and use the Serial Plotter to watch the voltage values as you take the power supply from 0 to 20V using the serial monitor or plotter. 4. What is the quantization error for this voltmeter? Check to see if this matches your values on the serial monitor. (The values on the serial monitor should “jump” in steps with a size equal to the quantization error).

Chapter 4 AC Voltages and the Arduino OBJECTIVES At the conclusion of these laboratory activities, you should be able to do each of the following: • Use an Arduino to measure AC voltages. • Describe the problem of “aliasing”, and how it can be mitigated. In the second lab of the semester, we learned how to use an oscilloscope to measure AC voltages. We would like to be able to do this with the Arduino as well. Some complications arise, however, when we try to use an Arduino as an oscilloscope: • The Arduino can only handle input voltages up to 5 Volts (we’ve already learned how to mitigate this issue via the use of a voltage divider). • The Arduino cannot handle negative voltages (which can - and probably will - destroy the Arduino). • The Arduino may not be able to sample voltages fast enough. In this lab, we will see how we can get around these issues. 4.1 The Instrument The first challenge we face is that the voltage from the RLC circuit is sometimes negative (see Figure 4.1). We will have truly negative voltages compared to our ground. Can we send a negative voltage into our Arduino? The answer is an 73

74 CHAPTER 4. AC VOLTAGES AND THE ARDUINO Figure 4.1: The AC signal coming from an RLC circuit. emphatic NO! Negative voltages will destroy our Arduino, just as easily as high voltages. But we really have a sinusoidal signal. The easiest way to fix this problem is, once again, to use a voltage divider - only this time we will fix each end at a different voltage. We will need one end at a positive voltage. The other can then go as negative as the first end is positive. Let’s take a concrete example to show how this works. Suppose we want to measure a voltage that could be as negative as - 5V or as positive as +5V . We still need to map this to our 0 to 5V Arduino range. Consider the voltage divider seen in Figure 4.2. Let’s start by setting R 1 = R 2 . Then, any voltage at the junction between R 1 and R 2 should be midway between the voltages input on the top of R 1 and the Bottom of R 2 . We put in +5V from our power supply on the top. And suppose we hook - 5V to the bottom (say, from our signal generator). We expect the voltage divider to divide the total voltage difference in half. We have 10V range from - 5V to +5V. We expect the junction between R 1 and R 2 to be right in the middle of that range. So we expect to see 0V on pin A0 when the signal generator outputs - 5V . So far so good! Now suppose the signal generator gives us +5V . Half way between +5V and +5V is still +5V. This is just what we want! Any voltage from the signal generator between +5V and - 5V will end up between 0V and +5V at input A0. For example, say we have - 2V from the signal generator. The at A 0 we will have a voltage half way between +5V and - 2V . Pin A0 would have 1 . 5V . We must be very careful to get this voltage divider wired correctly before we hook it to our Arduino. We also need to make sure our signal generator and power supply are plugged into grounded outlets, or otherwise share a common

4.1. THE INSTRUMENT 75 Figure 4.2: Using a voltage divider to positive bias a signal. ground. It is always a good idea to test the voltages at the midpoint of the voltage divider with an oscilloscope, prior to attaching it to pin A0 on the Arduino! The oscilloscope, power supply, and signal generator are all grounded through their grounded plugs, but our Arduino is not. We need to tie all the grounds of all our equipment together. The way to do this is to put a wire on the power supply negative output and wire it with an alligator clip to the grounded exte- rior of the signal generator TTL BNC connector. Then take another wire and connect it to the power supply negative output and wire this to a GND pin on the Arduino. This should ensure that all three devices have the same ground point (so we won’t get a spark from one to another). Before we hook this bit of electronics to our Arduino, we want to check it using an oscilloscope. Our oscilloscopes have two channels where we can hook probes. Let’s use one to measure the signal as it comes directly from the signal generator. Let’s use the other to measure at the junction in between R 1 and R 2 right were we will connect pin A0. That should be our output. A schematic of the entire circuit, with the voltage divider attached, can be seen in Figure 4.3. Figure 4.3: Schematic diagram of the circuit, with the voltage divider attached, grounds properly connected, and the oscilloscope in place. When the circuit is built and functioning, the signals on the oscilloscope should appear as in Figure 4.4. The red trace is the voltage at the signal

76 CHAPTER 4. AC VOLTAGES AND THE ARDUINO generator. The yellow trace is the voltage from the midpoint of the voltage divider. Notice that in this figure the capacitor voltage alternates between -5 V and +5 V, while the output from the voltage divider is from 0 to +5 V, as desired. The yellow trace can be raised or lowered by changing the voltage output from the DC power source. Figure 4.4: Oscilliscope signal for the capacitor voltage and output signal from the voltage divider. Of course in our sketch, we have to do a little math to convert our output signal of 0 V to +5 V back into the the capacitor voltage of -5 V to +5 V. Basically, we just have to undo our mapping. We multiply our ADC units by two, and then subtract 5 V. Δ V measured = 2Δ V ADC - 5V (4.1) Notice that our minimum detectable voltage difference of Δ V ADC min = 4 . 9mV will map to δV = 2 (4 . 9mV) = 9 . 8mV so that the minimum uncertainty in our voltage readings will be 9.8 mV. This higher uncertainty is the price we pay for being able to measure both positive and negative voltages.

4.1. THE INSTRUMENT 77 Once again, make sure that you use the oscilloscope to measure the output voltage from the voltage divider prior to attaching the Arduino. We can set up our circuit and clip the oscilloscope probe to either side of the capacitor, as seen in Figure 4.3. Once we have this working on our oscilloscope, we can try it on our Arduino. Of course we need a sketch for this. Here is a simple example. ///////////////////////////////////////////////////////// // Extended Voltmeter for plus and minus five volts // This voltmeter with the values given below // is designed to measure a-5V0 to +5V range with 1014 // discrete values of with an uncertainty of about 98mV. // A voltage divider is use with equal resistances. // +5V is given to one side and our +-5V signal to the // other side. The output voltage is taken in between the // two resistors. I think we need to wire all the voltage // devices to the GND pin to keep common ground. ///////////////////////////////////////////////////////// //set up a variable to represent Analog Input 0 int AI0 = 0; int value = 0; // Place to put the A2D values float voltage = 0.0; // calculated signal voltage ///////////////////////////////////////////////////////// void setup () { //Initiate Serial Communication Serial . begin (9600); //9600 baud rate } ///////////////////////////////////////////////////////// void loop () { // read the serial data from AI0 value = analogRead (AI0); // if you want to, print out the channel A2D values. // Uncomment if you want them. //Serial.print("analog channel value "); //Serial.print(value); // calculate the signal voltage voltage=(2 * value * (5.0/1024.0))-5; // print out the signal voltage Serial . print ( " voltage " ); Serial . println (voltage, 4); } ///////////////////////////////////////////////////////// /////////////////////////////////////////////////////////

78 CHAPTER 4. AC VOLTAGES AND THE ARDUINO 4.2 Sampling Theory, a complication Before we finish, we need to think about another limitation of our Arduino devices, which is that they can only take up to 2000 measurements in a second. We say they have a maximum sampling rate of 2000Hz . To try to understand this, consider trying to measure a sine wave with a frequency of 1000 Hz, as seen in Figure 4.5. The sine wave has a value for every one of the infinietly many possible times depicted in the graph. That is, V ( t ) = sin ( ωt ) has a defined value for every t at all. In an ideal situation, if we were measuring this sine wave, we could measure the voltage at an infinite number of times between 0 and 1s so that we would not miss any V ( t ) values. Figure 4.5: A 1000 Hz sine wave. In reality, the Arduino can’t take an infinite number of values. It an only take up to 2000 values a second, or two values for every cycle of our sine wave. What we see in our measurement suddenly becomes very sensitive to where the measurements begin! If my first measurement occurred at the first peak in Figure 4.5, the next measurement would occur at the first trough, and I would be getting an accurate view of how much the voltage fluctuated. However, consider what happens if that first measurement does not occur at the first peak, as in Figure 4.6. In this image, the red dots correspond to the measurements we take. The red dots are all we would see, and the green line represents what is actually happening. From our measurements, we would see that the signal is oscillating, and we would probably even deduce the right oscillation frequency. However, what we would perceive as the maximum voltage would be very wrong! The situation can get even worse. Suppose our first sample happened to occur at time t = 0. This measurement, as well as all subsequent measurements, would fall on the nodes of the sine wave, as seen in Figure 4.7. We would only get measurements of zero voltage! Consequently, we would believe we were measuring a constant zero voltage.

4.2. SAMPLING THEORY, A COMPLICATION 79 Figure 4.6: Measuring a 1000 Hz signal with a 2000 Hz sampling rate, where the samples do not occur at the true extrema of the sine wave. Figure 4.7: Another measurement of a 1000 Hz signal with a 2000 Hz sampling rate. In this case, all of the measured voltages would be zero.

80 CHAPTER 4. AC VOLTAGES AND THE ARDUINO The solution to this problem is to lower our signal frequency so that we have more points per signal period. Say, we have a sine wave with a frequency of 250Hz, but still with a sampling rate of 2000 Hz. This will give us eight samples per period, and our measurements would look more like Figure 4.8. With more samples per period, it is easier to see the character of the sine wave. Even if our measurements were offset just a little in time, we would still be able to distinguish both the frequency and amplitude of this wave. Figure 4.8: Measuring a 250 Hz signal with a 2000 Hz sampling rate. Suppose we just plot our measurements from this last case, as in Figure 4.9. We could still tell it was a sine wave. Granted, it doesn’t look great (it’s not terribly smooth), but we wouldn’t mistake it for a straight line. Figure 4.9: Connecting the measurements from the 250 Hz signal. This problem of having to take measurements faster than our signal changes is called aliasing (because if you get it wrong, it looks like the wrong function came from the signal generator). To avoid issues with aliasing, we need to make sure our signal frequency is much lower (like ten times lower) than the frequency at which we can take measurements, or we run the risk of being fooled by our measurements.

4.2. SAMPLING THEORY, A COMPLICATION 81 LAB ACTIVITY 1. Obtain a signal generator, and build the circuit in Figure 4.3. At- tach the two leads of an oscilloscope, and tie all of the grounds together. 2. Turn on the signal generator, and set the frequency to 1 Hz. Ad- just the DC voltage on the power supply, and make sure your oscilloscope displays an image similar to Figure 4.4. Note that the oscilloscope channels will both need to be set to use a DC cou- pling, and you will want to adjust the output amplitude of the signal generator so that it puts out a maximum of five volts. 3. Load the appropriate code onto the Arduino. 4. Once you are satisfied that the voltages between the two resistors in the voltage divider range only between zero and five volts, connect the analog input lead of the Arduino between the resistors, and connect the ground of the Arduino to the other grounds in the circuit. 5. Using the Serial Plotter in the Arduino IDE, observe the alternat- ing voltage read by the Arduino, and verify that your Arduino is “reading” the signal generator voltages correctly. 6. Begin increasing the frequency of the signal generator, while watch- ing the output on the Serial Plotter. At some point, you will notice that your output no longer looks like a nice clean sine wave. Record the frequency at which this happens. 7. Investigate even higher frequencies, and observe the aliasing effect on the output of your “Arudino oscilloscope”.

82 CHAPTER 4. AC VOLTAGES AND THE ARDUINO

Chapter 5 Getting Data to the Computer OBJECTIVES At the conclusion of these laboratory activities, you should be able to do each of the following: • Have a working Python installation on your computer. • Use Python to retrieve Arduino data from the serial port of a computer. ITEMS TO REVIEW Please review the following concepts as part of your preparation for this lab. • Basic Python syntax. We now have voltage data coming from our Arduino into the computer serial port, and we can see that data with the Arduino serial port monitors. But suppose we want to analyze our data in another program. How would we get the data into Excel or LoggerPro, or SPSS or Python? There are lots of ways to do this, but an easy way is to use Python to write a simple code using the Python serial port library. That is what we are going to do in this lab. 83

84 CHAPTER 5. GETTING DATA TO THE COMPUTER 5.1 How to get Python Python is a programming language. The code that we write in Python is de- signed to work on our computer, itself. This is just what we want for getting the data ready for analysis on our computer. If you already have Python, that is fine, you could skip ahead. If you don’t, the next steps show how to get Python on your computer and how to get the Python serial library so you have the commands to read the serial port. There are many different distributions of Python, and any distribution will work just fine. In the instructions that follow, we are going to focus on the Anaconda distribution. 5.1.1 Getting Anaconda Python The Anaconda distribution of Python is designed for scientific work, so it has most of the science libraries of functions already installed. It can be found at https://www.continuum.io/downloads. There is an install link for Windows, Mac, and Linux. Choose the one for your operating system 1 . When you click on a link, it will likely bring up a dialog box will come up telling you that you are downloading something. In windows, it looks like Figure 5.1 Figure 5.1: Anaconda download confirmation. Choose “Save File” and when the file is downloaded open it to start the installation. You should see something like Figure 5.2. Choose “Next” and follow the installation instructions. If all goes well, you should have a new set of apps. Figure 5.3 shows what these apps look like in the start menu of Windows 10. The list of the apps has an app called Spyder. This is the integrated devel- opment environment (IDE) that comes packaged with Anaconda, and is where we will do most of our work. The interface for Spyder can be seen in Figure 5.4 1 If you have a Linux computer, it is likely that you will want to actually see if Anaconda is in your distribution’s repository. If you are not a Linux user, you have no idea what that means and can ignore it.

5.1. HOW TO GET PYTHON 85 Figure 5.2: The Anaconda installer welcome screen. Figure 5.3: Anaconda apps on the Windows 10 start menu.

86 CHAPTER 5. GETTING DATA TO THE COMPUTER Figure 5.4: The Spyder IDE. Python code is written in the frame on the left. The code is executed by clicking on the “Run” button, and the resulting output appears on the frame at the lower right. What we get is something like the Arduino program that we have been using to write Arduino sketches. Spyder is a place to write and run Python commands. Only this time there is no checking and uploading the code, because the Python code will run on our computer, not on an Arduino. In Figure 5.4, the command just says to print “hello new python users!” and that is all. When it runs, it prints our message on the small window to the right. But of course Python can do much more than print silly messages in little windows. We will have our Python system read a serial port and save our data to a file. But we need an additional piece of Python to do this. We need functions that can handle serial ports. These functions are already written by someone, and put together in a package called a “library.” But this library isn’t included in what we have downloaded. So we need to fix this next. 5.1.2 Getting the PySerial library for Anaconda Now that we have Python, we need to update it with the PySerial library so that we can read our data from the computer serial port. If you have installed the Anaconda package as your Python distribution, follow along here. If you are using a different Python distribution, ask your instructor for help. We will use the Anaconda prompt to get the PySerial library. The Ana- conda prompt is an app that lets us modify the Python libraries that we have installed. The Anaconda prompt is found in the list of apps that were installed in Anaconda. If you are using Windows, you might find it in your app list, as can be seen in Figure 5.3. Once you launch the Anaconda prompt it just looks like a big black box. We can type commands in that box that will modify the Anaconda Python programs that we installed. In our case we want to type in the command conda install pyserial , as seen in Figure 5.5.

5.2. GETTING DATA FROM THE ARDUINO 87 Figure 5.5: Installing Pyserial in the Anaconda Prompt window. . Notice that the Anaconda prompt app responds to our command. What it responds will depend on your computer and your Python distribution. You need a network connection to install new libraries, so if you get an error, you may just not be connected to a network. If you already have PySerial installed, you will be told so, or asked if you wish to update it if an update is available. If you don’t have PySerial, it will ask you if you want to install it. Answer “yes” and PySerial will be installed. If any error messages are generated, ask for help from your instructor. Hopefully you will see a happy end result like in Figure 5.6, and you will be all ready to start writing code to get data from the serial port. 5.2 Getting data from the Arduino It might help to know how a serial port works. The serial port in the computer takes in data from the serial cable. It stores the data in a temporary place in memory called a buffer . Whatever data comes into the port goes into that memory location. This process is illustrated in Figure 5.7. Suppose that we set up our Arduino to send data to the port. The Arduino sends data every few milliseconds. But, suppose we only want data every few seconds, i.e. we only want some of the data that the Arduino has sent. In Figure 5.7, this data is indicated by the red arrows. The computer has placed every data point sent by the Arduino into it’s buffer, and the buffer must be read in sequence. You can’t skip data values. But this is just what we want to do, skip some data values and take a value every few seconds. A way to do this is to

88 CHAPTER 5. GETTING DATA TO THE COMPUTER Figure 5.6: Pyserial installation complete. Figure 5.7: A representation of data at the serial port. The Arduino may send more data to the serial port than we need. In the examples in the text, we only want to retrieve the data indicated by the red arrows.

5.2. GETTING DATA FROM THE ARDUINO 89 continuously read in data, but only store it every few seconds. We will use this technique in the code that follows. Just for fun, let’s think of an actual data collection scenario. Suppose we want to measure a voltage from our Arduino, but we want to measure it many times, each time five seconds apart. This way we are looking at how the voltage changes over time. Suppose we also want to retrieve a total of 10 measurements. You might be an expert Python programmer, and if so you can probably see how to write this code. If so, go ahead and do so. But if not, let’s introduce some of the Python code elements we will need, and then give an example code. The first new code piece is making files for our data. We create a file with a line like this (see the actual code below): fileObject = open ( "C:\\Users\\rtlines\\Documents\\data.txt" , "w" ) The “fileObject” is a variable that contains all the file information like the path and file name. It is way easier to type than to include all that information each time we use a file. So we will use fileObject variables. In the code below I named the fileObject variable “dataFile.” Of course, you will have to choose your own path where you will place the data file (you can’t use mine, because you don’t have my computer!) and you will need to choose your own file name. Notice the weird double slashes “ \\ .” ˙ Normally, the Windows operating system delineates directories with a single backslash. However, in Python, the backslash character is used to instruct the computer that the character that follows is special. The double backslash simply tells Python that the special character it needs is a backslash. This is a quirk in most programming languages when you need to include backslashes in a string of characters, and you need to write the path this way. The other new code piece is dealing with serial ports. Like with our Arduino code, we have to set up the serial port. We do that with the line like this (also see the actual code below). ser = serial.Serial( ’COM6’ , baudrate = 9600, timeout = 1) Note that when I was using this code my Arduino was connected to the port COM6, but that might not be true for you. Use the Arduino app to find out where your Arduino is connected, as in Figure ?? . The port in our Python code must match the port indicated in the Arduino IDE. Ports are named differently on a Mac or on Linux, but is much the same. Once the serial port is set up, a line like arduinoData = ser.readline().decode( ’ascii’ ) will read data from the serial port and “decode it” so that it is text that we can use in another program. The rest of the code writes the data point to a file. I have it calculating the time since the beginning of our data collection (we might just need that in a future lab) and outputting that into the file as well. We are going to want a name for the amount of time in between data points. In the example code, the amount of time to delay in between data points is named sleeptime and the number of data points is named N .

90 CHAPTER 5. GETTING DATA TO THE COMPUTER Figure 5.8: Finding which serial port the Arduino is connected to. At the end of the program we close the file fileObject.close() We also absolutely must close the serial port with ser.close() so that the port will be ready to use next time. Your complete code might look something like this. #--------------------------------------------------------------------- # Python Code to read a stream of data from the serial port # and save it to a file #--------------------------------------------------------------------- # The idea is to read a series of voltages from an Arduino # connected to the serial port where the Arduino is being # used as the Analog to Digital converter. Both the voltage # and the time the voltage was taken are sent to the serial port. # # We will use two libraries, serial and time # The serial library is used to read the serial port # The time library is used to space out our data collection by # adding a delay in between data points. The amount of time # to wait in between data points is called "timeBetween." # # We may have to install the serial library. If you have the # Anaconda Python for Windows, you can open an Anaconda # window and use the command ’conda install pyserial’ # This must be done before the code can run. #

5.2. GETTING DATA FROM THE ARDUINO 91 # Debugging issues: The Anaconda Python distribution tends to # hang on to the serial port even if the program does not run. # If this happens, try sending the python command ser.close() # at the command prompt. If this doesn’t work, You may have to # restart Python. # In windows, closing (after saving) the IDE and reopening it # might be enough. #--------------------------------------------------------------------- # import libraries import serial import time # define variables for the delay time we wait between data points timeBetween = 5 #seconds # define the number of data points to collect N = 20 #the next line opens a file and creates a pointer or handle for that file # to use as a reference. You have to use double slashes in the path. # The pointer, "dataFile" takes the place of all the path and file # name so it is easier to use in the code below # This line worked for Brother Lines, but won’t work for you as it is. # You need to replace "rtlines" with your username at a minimum. dataFile = open ( ’C:\\Users\\rtlines\\Documents\\data2.txt’ , ’w’ ) #the next line opens the serial port for communication ser = serial.Serial( ’COM3’ , baudrate = 9600, timeout = 1) #there will be a delay before the first data point comes from the # serial port, warn the user so they don’t worry. print ( ’getting started...’ ) # set our index to zero i = 0 # Now for N points, collect data and write it to a file while (i < N) : #Begin data collection loop #We will take data every "timeBetween" seconds. We need to know # when we start waiting so we can tell if it is time to collect # data yet. Use the time.time() to get the current time in seconds # since Jan 1,1970. Yes that is a weird way to measure time, but # computers do it this way. waitStart = time.time() #Data comes to the serial port fast. We will continually read # the data as fast as it comes, but only save it every timeBetween # seconds. The next while loop keeps us reading in data, but only # when the current time - waitStart >= timeBetweem will we use # the data. while (time.time() - waitStart < timeBetween) : #Begin Data read loop # Get data from the serial port # it should have a time and a voltage arduinoData = ser.readline().decode( ’ascii’ )

92 CHAPTER 5. GETTING DATA TO THE COMPUTER # end of the Data read loop # the next line just prints the voltage point on the console so the user # feels like something is happening. print (arduinoData) # This next line writes combines the time since we started and the Arduino # value from the serial port into one string writeString = str (arduinoData) #+ " \n" # The next line writes our time plus Arduino value to the file. dataFile.write(writeString) # and finely we increment the loop counter i = i + 1 # end Data collection loop # Print out a message saying we are done print ( "done with data collection, closing the file and the serial port" ) # Close the file dataFile.close() # Close the serial port ser.close() #--------------------------------------------------------------------- #--------------------------------------------------------------------- Make sure you understand what each line does. Discuss each line with a group member or with the instructor. Python code runs one line at a time. That is different than our Arduino code that must be checked and translated before it goes to the Arduino. Errors in Python code show up as the code runs. If you use the Spyder IDE, the errors show up in the little output box to the right. We can modify the simple voltmeter sketch from the last lab to give the time that the data was taken and to send both the time and the voltage to the serial port. Here is the updated sketch (remember since it is a simple voltmeter it can only handle 0V to +5V . ) ///////////////////////////////////////////////////////// // very simple voltmeter that also returns the time since // the data collection started with the voltage. // will measure 0 to 5V only! // Voltages outside 0 to 5V will destroy your Arduino!!! ///////////////////////////////////////////////////////// int AI0 = 0; float delta_v_min=0.0049; // volts per A2D unit int value = 0; float voltage = 0.0; ///////////////////////////////////////////////////////// void setup () { // put your setup code here, to run once: //Initiate Serial Communication

5.3. GETTING PYSERIAL IF YOU HAVE A MAC 93 Serial . begin (9600); //9600 baud rate } ///////////////////////////////////////////////////////// void loop () { // read in the voltage // in A2D units form the serial port value = analogRead (AI0); Serial . print ( " time in milliseconds " ); // the millis() function gives the time // in milliseconds since the sketch started Serial . print ( millis ()); // convert to voltage units using delta_v_min voltage = value * delta_v_min; Serial . print ( " voltage " ); Serial . println (voltage, 4); } ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// Only one process can connect to a serial port at any given time. Conse- quently, you can’t simultaneously use the Arduino serial monitor and get data from the serial port using Python. Turn off the serial monitor if it is running. Now that we have our data in a file, we can analyze it. You might try opening the file in Excel or another spreadsheet program and plotting the data. If you know Python, you could add more code to plot the data right in the code that takes it from the serial port. But, if you are new to Python, you could plot the data in something like a Excel or LoggerPro. Ask for help if you don’t know how to do this. We will plot data in future labs. 5.3 Getting Pyserial if you have a Mac Of course, we have a diversity of computers on campus. The instructions I gave above are for a PC type computer. 5.3.1 Anaconda Mac Users 4.1.2 Go to the Anaconda Prompt and type in: conda install -c anaconda pyserial . This will install pyserial -v3.4. If this does not work for some reason, try going to the Anaconda Navigator, on the left hand side, click Environments. Next, on the right hand side, change the drop-down from Installed to Not Installed. Then enter serial in the search box. Check the box for pyserial and click the Apply button. If you have Spyder running, then relaunch Spyder.

94 CHAPTER 5. GETTING DATA TO THE COMPUTER 5.3.2 Manually install Pyserial using the Terminal app This is kind of a “last resort” approach, so only try this if the other methods above fail. 1. First, go to https://pypi.python.org/pypi/pyserial and download pyserial- 3.4.tar.gz or the version that correlates with the version of python you are using. If you are using python 2 then instead of 3.4, you should look for a file that starts with 2.x; however, if you are using python 3 then 3.4 is the correct version of pyserial you are looking for (but please consider using python 3.x!). 2. Be sure that you downloaded to your Downloads folder. 3. Go to your search bar and type in terminal and open that application. 4. Type into the command line cd Downloads then press enter. 5. Next, type in tar -xzf pyserial-3.4.tar.gz then press enter. Type in cd pyserial-3.4 , press enter 6. Then type in sudo python3 setup.py install . 7. If you are using python 2 then only type in python where it says python3 . After that you are ready to use the serial library in python. 5.3.3 Mac Paths and Port Notation Mac computers list paths to files differently than PC computers. In fact, Mac computers don’t make file locations obvious to users at all! But our python code needs to know where to put the files we build, so we will need to understand how to do this. On the line of code that starts with dataFile you will replace it with dataFile = open(“/Users/rtlines/Documents/data.csv”,“w”) . This is in the form of /User- s/username/folder name/(optional if you have a folder within the previous folder) folder name/file name + extension (e.g. .csv or .txt). You can find your username by going to your download folder then right click on any file in there and select Get Info . Next make sure that the arrow to the left of General is pointing down. Once it is pointing down look at the line that reads, Where: Macintosh HD → Users → your username will be here → Downloads . Mac Port Mac computers also deal with serial ports differently. So we need to change that next line of code after the dataFile line that begins with ser = serial... . The line of code will need look something like ser = serial.Serial(‘/dev/cu.usbmodem1411’, baudrate = 9600, timeout = 1) . However, yours may vary slightly by a different

5.3. GETTING PYSERIAL IF YOU HAVE A MAC 95 usbmodem number. To find out what to place in between the apostrophes is by going to your arduino code, click on Tools , scroll down to Port and write down what is written there minus what is in the parenthesis. #--------------------------------------------------------------------- # Python Code to read a stream of data from the serial port # and save it to a file #--------------------------------------------------------------------- # The idea is to read a series of voltages from an Arduino # connected to the serial port where the Arduino is being # used as the Analog to Digital converter. Both the voltage # and the time the voltage was taken are sent to the serial port. # # We will use two libraries, serial and time # The serial library is used to read the serial port # The time library is used to space out our data collection by # adding a delay in between data points. The amount of time # to wait in between data points is called "timeBetween." # # We may have to install the serial library. If you have the # Anaconda Python for Windows, you can open an Anaconda # window and use the command ’conda install pyserial’ # This must be done before the code can run. # # Debugging issues: The Anaconda Python distribution tends to # hang on to the serial port even if the program does not run. # If this happens, try sending the python command ser.close() # at the command prompt. If this doesn’t work, You may have to # restart Python. # In windows, closing (after saving) the IDE and reopening it # might be enough. #--------------------------------------------------------------------- # import libraries import serial import time # define variables for the delay time we wait between data points timeBetween = 5 #seconds # define the number of data points to collect N = 20 #the next line opens a file and creates a pointer or handle for that file # to use as a reference. You have to use double slashes in the path. # The pointer, "dataFile" takes the place of all the path and file # name so it is easier to use in the code below # This line worked for Brother Lines, but won’t work for you as it is. # You need to replace "rtlines" with your username at a minimum. # PC version next: # dataFile=open("C:\\Users\\rtlines\\Documents\\data.txt","w") # MAC version next dataFile = open ( ’/Users/rtlines/Documents/data.csv’ , ’w’ ) #the next line opens the serial port for communication # PC version next

96 CHAPTER 5. GETTING DATA TO THE COMPUTER #ser=serial.Serial(’COM3’, baudrate = 9600, timeout=1) # MAC version next ser = serial.Serial( ’/dev/cu.usbmodem1411’ , baudrate = 9600, timeout = 1) #there will be a delay before the first data point comes from the # serial port, warn the user so they don’t worry. print ( ’getting started...’ ) # set our index to zero i = 0 # Now for N points, collect data and write it to a file while (i < N) : #Begin data collection loop #We will take data every "timeBetween" seconds. We need to know # when we start waiting so we can tell if it is time to collect # data yet. Use the time.time() to get the current time in seconds # since Jan 1,1970. Yes that is a weird way to measure time, but # computers do it this way. waitStart = time.time() #Data comes to the serial port fast. We will continually read # the data as fast as it comes, but only save it every timeBetween # seconds. The next while loop keeps us reading in data, but only # when the current time - waitStart >= timeBetweem will we use # the data. while (time.time() - waitStart < timeBetween) : #Begin Data read loop # Get data from the serial port # it should have a time and a voltage arduinoData = ser.readline().decode( ’ascii’ ) # end of the Data read loop # the next line just prints the voltage point on the console so the user # feels like something is happening. print (arduinoData) # This next line writes combines the time since we started and the Arduino # value from the serial port into one string writeString = str (arduinoData) #+ " \n" # The next line writes our time plus Arduino value to the file. dataFile.write(writeString) # and finely we increment the loop counter i = i + 1 # end Data collection loop # Print out a message saying we are done print ( "done with data collection, closing the file and the serial port" ) # Close the file dataFile.close() # Close the serial port ser.close() #--------------------------------------------------------------------- #---------------------------------------------------------------------

5.3. GETTING PYSERIAL IF YOU HAVE A MAC 97 Make sure you understand each line of this code. Most of the code is com- ments, so don’t be discouraged by the length. LAB ACTIVITY 1. Finish any part of the last lab that you haven’t done. 2. Using Python, Save Arduino data to a file on your computer (a) Wire up a simple voltmeter and load its sketch. Build a simple circuit to test like we did back in section (2.1). Start your Arduino and check to make sure voltages are going to the serial port by looking at the serial monitor or plotter. (b) Check with your group members to make sure their simple voltmeters are working. Help if they are not. (c) Start your Python system and write the program to read the serial port and save the data to a file. (d) Close the serial monitor and/or serial plotter. Then run your Python code. Check to make sure that the file of data is written properly. The voltages written in the file should match what your power supply and circuit provided. (e) Make sure you save this program and record what you did in your lab notebook. (f) Make sure your lab group members all have Python programs that run and save data correctly. Help if they do not. 3. Together with your group, brainstorm some ideas for your design project later in the semester.

98 CHAPTER 5. GETTING DATA TO THE COMPUTER

Chapter 6 DataLogging OBJECTIVES At the conclusion of these laboratory activities, you should be able to do each of the following: • Explain what an Arduino shield is. • Use a datalogging shield to record Arduino data to an SD card. • Use an external power source with the Arduino. It today’s lab, we are going to measure temperature. We will use a transducer that turns temperature (energy of the air molecules around us) into a voltage (no surprise here, since that’s what all of our electronic measuring devices must do). Our focus is to build an independent system to measure temperature, one that doesn’t have to be connected to our computer. Up to this point, our Arduino has been powered via the USB connection to our computers, and the data has been recorded directly on our computers. Often we need to have a data collection device that can operate far from our computer, but still save data for later use. For example, if you needed to send a sensor into the atmosphere via a high altitude balloon, you would not want (or even be able) to send your laptop up with it. 6.1 Arduino Shields Today we all need to be able to have our Arduino collect data and save it with no computer attached. We will do this using a shield. An Arduino shield fits over the top of your Arduino, connecting to the necessary pins to do its job. The other pins are still available to use for other measurements. 99

100 CHAPTER 6. DATALOGGING Arduino shields are a simple way to add specific functionality to your Ar- duino. There are many different shields with many different features. Some shields have additional integrated circuit (IC) chips on them that can add ad- ditional computational power. Others are extremely simple and are designed so you can have a more solid electrical connections with your experiment. Figure 6.1 shows an example of a simple prototyping shield (basically like our proto- typing boards, but with the intention that circuit elements will be soldered to the board). Notice the long wire pins on the bottom. These are designed to be plugged directly into the Arduino. (When the shield is not in use, these pins should be pushed into the conductive foam block. This will not only protect them from getting bent, but will also protect the electrical circuits on the shield from static shocks.) Figure 6.1: An arduino prototyping shield. The upper image shows the top of the shield, and the lower image shows the bottom of the shield.

6.2. DATA LOGGER SHIELD 101 Many shields are compatible with other shields such that they can be stacked on top of each other. Whether or not two shields are compatible depends on which pins each shield is using, and on the physical placement of both the bottom and top pins. Because shields are designed for a specific functionality, the manufactures will often provide example code that utilizes those features. This code can then be modified and/or combined with other code to get your Arduino to do what ever you want. While working with shields, you must be aware of which pins the shield is using. Otherwise, you might interfere with the operation of the shield. 6.2 Data Logger Shield Data logging is one of the most important parts of any experiment. In addition to collecting the information from our sensors, we also often want to record the time at which that data was collected. The data logger shield allows us to not only save the data to an SD card, but we can also save the time along with it. This is because it has a built in real time clock (RTC). Take a close look at the data logging shield shown in Figure 6.2. You will notice that the SD card slot (right next to the words ”Data logger Shield”) is close to an IC. That IC (a black rectangle) controls the SD card. There is also a battery holder. It has a battery in it, but the image also shows a piece of blue paper covering both sides of the battery. This is for shipping so that the battery isn’t drained while not in use. The battery is needed for the real time clock, so that it keeps time even if there is no other power to the board. The electronics for the RTC are right next to the battery. Note the smaller IC and the silver cylinder. The cylinder holds a small quartz crystal tunning fork that keeps oscillating. These oscillations are counted by the IC and are used to keep time. The pins on the shield are labeled, just like on your Arduino. Notice, though, that some of the pins are labeled with a white square and a black number. These pins (A4, A5, 9,11,12 and 13) are the pins that the shield uses for its functions. Make sure that your experiment doesn’t use these pins. Pins A4 and A5 are used for the RTC and pins 9,11,12 and 13 are used for the SD card. The bottom of shield gives additional labels to these pins that describe their function. 6.3 Setting up the data logging shield The data logger shield uses a set of pre-written code, known as a “library”. To get that library follow these steps in the Arduino software: 1. Under “Tools” go to “Manage Libraries ...” 2. Search for “RTClib” 3. Find the library by Adafruit and install it.

102 CHAPTER 6. DATALOGGING Figure 6.2: A data logging shield, with the top side shown. The first time the software is run on the Arduino with the data logger shield, the RTC needs to be set. Pull out the paper that keeps the battery from contacting, and put the battery back if it is still there. Then upload the code below. Check the serial monitor. If it says that the “RTC has not been set!”, or if the date and time are incorrect, then you will need to remove the comment back slashes on the line rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0)); The arguments to the DateTime function are the year, month, day of the month, hour (24 hour time), minute, and second. Change the numbers to match the current date and time, then upload the code again. This should set the clock. This only needs to be done once, as the battery will keep time from then on. So put the comment back slashes back in and upload the code again. // =================================================== // RobotDyn SD/RTC Arduino shield example // Nolan Chandler // Last revised: 2020-11-18 // // Meant to serve as a starting point for data logging // using both a real-time clock (RTC) and a microSD // card. // // Collects data at a given rate, and saves them with // a timestamp on the SD card to files called // "LOG000.TXT", "LOG001.TXT", etc. A new file is // opened every N samples to collect another N samples. // ===================================================

6.3. SETTING UP THE DATA LOGGING SHIELD 103 #include <SPI.h> #include <SD.h> // by Adafruit. Must be manually installed #include "RTClib.h" const int SD_PIN = 9; File logfile; RTC_DS1307 rtc; float data; int i = 0; int N = 50; // Number of samples per file int waittime_ms = 500; // milliseconds between samples // ==================================================== void setup () { // Open serial communications Serial . begin (9600); init_RTC(); // (note 24-hour time: 3pm -> 15) // This line sets the RTC with an // explicit date & time, for example: // to set January 21, 2014 at 3:18pm // you would use the following line: // rtc.adjust(DateTime(2014, 1, 21, 15, 18, 0)); init_SD(); logfile = open_next_logfile(); } // ================================================== void loop () { if (i < N) { // generate a random number data = random (-100, 100);

104 CHAPTER 6. DATALOGGING DateTime now = rtc.now(); // Write the date, time and data to log file // Same as printing to Serial! logfile. print (now.year()); logfile. print ( ’-’ ); logfile. print (now.month()); logfile. print ( ’-’ ); logfile. print (now.day()); logfile. print ( ’ ’ ); logfile. print (now.hour()); logfile. print ( ’:’ ); logfile. print (now.minute()); logfile. print ( ’:’ ); logfile. print (now.second()); logfile. print ( ’,’ ); logfile. print (data); logfile. println (); // write same data to serial Serial . print (now.year()); Serial . print ( ’-’ ); Serial . print (now.month()); Serial . print ( ’-’ ); Serial . print (now.day()); Serial . print ( ’ ’ ); Serial . print (now.hour()); Serial . print ( ’:’ ); Serial . print (now.minute()); Serial . print ( ’:’ ); Serial . print (now.second()); Serial . print ( ’,’ ); Serial . print (data); Serial . println (); delay (waittime_ms); //ms i++; } // Reached N samples, open the next log // file to record N more else { logfile.close(); // comment out the next two lines to stop // recording after the first file