Tag Archives: investigation

Building the Electrical Current Model with The Amazing $25 Programmable Power Supply

Not Just For Teaching Robotics

Thanks to the generous donations of supporters of the Physics Academy, we were able to purchase a new set of Arduino Uno micro-controllers for use in this year’s robotics competition. As I was planning out the unit on teaching DC circuits, I realized that some of our DC power supplies might need to be replaced. I got to thinking – could the Arduino replace these hulking, expensive power supplies?

product.exps._hero.001.590.332

The answer has been (with one caveat) – yes. The above power supplies are nice, no doubt about it, but they are big, costly ($199) and they are not as nearly as extensible as a micro-controller.

Arduino_Uno_-_R3

The Arduino micro-controller can act as a fixed 5V power supply, or using its PWM pins, you can vary the voltage from 0V to 5V with a resolution of about 20 mV. The other advantage about using the Arduino is that it gives you a chance to teach a little bit of programming too! In our case, it allows for a great introduction to robotics well before we are ready to start our unit on robotics.

The one disadvantage is that you can’t test any circuits that need over 5V of electrical potential difference, nor can you test things like motors or other higher current (> 40 mA) circuits. We didn’t find this to be a big problem, but if you do, you can actually purchase a shield (an attachment that fits on top of the Arduino) from Adafruit Industries that allows you to use a higher voltage, higher current power supply that is controllable through the Arduino.

Mapping Electrical Potential (Voltage)

One of the first activities that the students do, which is a great activity from the AMTA curriculum repository, is to have the students “map” the voltage between two metal bars that are partially submerged in water.

IMG_1870

Using the Arduino as the power supply, the students use a multimeter to check the voltage at specific locations on a grid that is placed under the transparent pan holding the water. These numbers are recorded into a spreadsheet. Excel has a great tool for doing a 3D map of the values.

potentialmap

What results is a really nice visualization of the potential isolines and the spacial variance of the voltage, and thus the electrical field.

Ohm’s Law – A Flow Model

We then move from voltage maps to flow model. The students investigate how voltage, current and resistance are related to one another. The students begin by investigating the current flowing into and out of a resistor, and most are surprised to find that the current in the same flowing into a resistor as it is flowing out. They expect that current should be “used up” by the resistor – causing a bulb to glow for example. When they find that this is not the case, they either think that they have done the experiment incorrectly or that perhaps the multimeter is not precise enough. This confusion comes from the idea that they are expecting current and energy to be equivalent.

IMG_1918

The hydrology analogy is introduced as a possible model for describing this phenomenon. We discuss the movement of water past a water wheel, and how the water flowing into the wheel is equal to the amount of water flowing “out” from the wheel. Students quickly realize that the wheel still turns, not because the water is “used up”, but because the water looses energy.

The final challenge for the students is to confront the oddity that is parallel circuits. This is made a bit easier by thinking about the flow model, but the confusion with parallel circuits stems from the idea that a battery is a constant current supplier – which of course it is not. The Arduino, just like a battery, will increase the amount of current flowing from its digital output pins when more pathways are added for the current to flow. This is where I would be careful to make sure however that you don’t approach the 40 mA limit. If you do, you can get some weird results in your observations as the Arduino will naturally cut off current draws around this range to protect its electronics.

Conclusion

The switch to the Arduino has been quite successful, and as stated before, it launches the students into the robotics project with a knowledge that the Arduino is simply a controllable power supply. They learn very quickly from that point on that the Arduino can also act like a voltmeter too! Using its analog input and switching the digital pins to be input pins, the Arduino can also mimic the functionality of a multimeter. If you are considering new power supplies, I would recommend looking into this as an option.

Simulating Planetary Motion (Using Code!)

Simulating Newton’s Law of Universal Law of Gravity

Interactive simulations (like those created by the University of Colorado – PhET) can be really nice for impressing students, and giving them a way to explore the dynamics of a simulation. If incorporated into a lesson well, they can add to the active learning process. The question that I always struggle with though is “are the students learning how the simulation works, or are they learning how nature works?”

I have a nagging feeling that the students would possibly get more out of being able to see the simulation source code, specifically the rules of behavior of the simulation, and then through “tweaking” the code, see how those rules govern behavior. I would like to develop curriculum that would allow my students more opportunities to explore the code “behind” the simulations. This presents a few challenges that have been identified by other great physics educators, and if you are thinking about doing the same thing – I would suggest reviewing their insights. I include a quote from Ruth Chabay’s brief, but very interesting article on this topic:

To integrate computation, especially programming, into an introductory course, it is necessary to minimize the amount of non-physics related material that must be taught. To do so it is necessary to teach a minimal subset of programming constructs; employ an environment and language that are easy to learn and use; ensure that program constructs match key physics constructs; provide a structured set of scaffolded activities that introduce students to programming in the con- text of solving physics problems

This was my first attempt at doing just this, and I had some success and realized that I have some work to do.

Which Code?

A popular programming language in the Physics Modeling community is VPython. I have chosen to use a different language to use called Processing. There are reasons I chose this language, but I am sure there are reasons one would choose VPython (or other languages). At this point, I have not had the opportunity to work with VPython, so this post will not attempt to compare Processing to other languages. Perhaps I will do so in the future…

Here are some general reasons why I like Processing:

  1. It’s free and open source.
  2. Because its built on a visual programming interface, its really easy for the students to create visual content on the screen, and it is very easy to create visual animations due to the embedded “draw” loop.
  3. The official website has great examples and tutorials. It is full of great code samples and quick tutorials. You can loose yourself for hours (or days!) just having fun exploring the examples and tutorials.
  4. The IDE is simple and very similar to the Arduino IDE, so if you plan on doing any Arduino programming, the similarity is nice for the students.
  5. There is a nice vector library for doing vector operations (.add, .mult, .norm, .dot, etc.)
  6. Its object oriented so that you can have the added benefit of teaching important programming concepts – though this might be why some people might not like it.

The Simulation

The simulation that the students were introduced to was a simulation that modeled Newton’s Law of Universal Gravitation. The students were given some instructions on the basic structure of the program, and I made sure that there was some guiding comments embedded in the code. This program was inspired/adapted from a similar program created by Daniel Shiffman who has also written an amazing book on simulating nature through code called Nature of Code.

The program defines two classes. First, there is the parent class called Particle. This class defines some basic attributes like location, velocity and acceleration as well as mass. It also has some basic functions that allow it to move and allow it to respond to a force. The second class is the child class called Planet. It can do everything that a Particle can (because it inherits from the Particle class), but it can also exert an attractive force on other Planets.  Here is the code below:

/* A parent class for all moving particles
class Particle {
  PVector location;
  PVector velocity;
  PVector acceleration;
  float mass;

  Particle(float x, float y, float m) {
    mass = m;
    location = new PVector(x, y);
    velocity = new PVector(0, 0);
    acceleration = new PVector(0, 0);
  }
  
  void applyForce(PVector force) {
    // Newton’s second law at its simplest.
    PVector f = PVector.div(force,mass);
    acceleration.add(f);
  }

  void move() {
    velocity.add(acceleration);
    location.add(velocity);
    acceleration.mult(0);
  }
}

/** 
 This class defines an object that behaves like a planet.
 Planet objects extend Mover objects, so they can move. They
 also can attract other planet objects.
 **/
   
class Planet extends Particle {

  float size;
  float G = 1;

  // To create a planet, you need to supply coordinates, mass, and size
  Planet(float x, float y, float m, float s) {
    super(x, y, m);
    size = s;
  }

  // This function allows a planet to exert an attractive force on another planet.
  PVector attract(Planet p) {

    // We first have to figure out the direction of the force
    // This creates a unit vector for the direction
    PVector force = PVector.sub(this.location, p.location);
    float distance = force.mag();
    distance = constrain(distance,size + p.size,500);
    force.normalize();

    // This is where we use Newton's Law of Universal Gravitation!
    // The stength of the attraction force is proportional to the
    // product of the mass of this planet and the mass of the other planet
    // as well as the value of G. It is also inverseley proportional to
    // the distance squared.
    float strength = (G * mass * p.mass) / (distance * distance);
    
    // To get the final force vector, we need to 
    // multiply the unit vector by the scalar strength
    force.mult(strength);

    // Return the force so that it can be applied!
    return force;
  }
  
  // Just displays the planet as a circle (ellipse)
  void display() {
    stroke(255);
    fill(255, 100);
    ellipse(location.x, location.y, size/2, size/2);
  }
  
}


/** 
  This program simulates the gravitational interaction between planet objects
  **/
  
Planet planet1;
Planet planet2;

void setup() {
  background(0);
  size(800,800);
  // Inputs for each planet:
  // (x, y, mass, radius)
  planet1 = new Planet(width/2,height/4,6000,60);
  planet2 = new Planet(width/2,height/1.25,6000,60);
  
  // This is where you can change the initial velocities of the planets.
  planet1.velocity.x = 0;
  planet1.velocity.y = 0;
  planet2.velocity.x = 0;
  planet2.velocity.y = 0;
}

void draw() {
  background(0);
  
  // f1 is a force vector that is created by calling the planet's attract function
  PVector f1 = planet1.attract(planet2); 
  // Now apply that force on the other planet.
  planet2.applyForce(f1);
  // Now deal with the opposite force pair
  PVector f2 = PVector.mult(f1, -1);
  planet1.applyForce(f2);
  
  // Allow the planets to now move.
  planet1.move();
  planet2.move();
  
  // Display the planets
  planet1.display();
  planet2.display();
}

Experimenting With The Code

The students could change the initial values of the planets, such as the starting positions, the masses and radii by changing the input values of these two lines of code:

planet1 = new Planet(width/2,height/4,6000,60);
planet2 = new Planet(width/2,height/1.25,6000,60);

The planets initial velocities could also be modified by changing the values assigned in these four lines of code:

planet1.velocity.x = 0;
planet1.velocity.y = 0;
planet2.velocity.x = 0;
planet2.velocity.y = 0;

The code that actually guides the strength of the gravitational attraction between the two planets is actually very simple. This is the magnitude of the force as defined by Newton’s Law of Universal Gravity in code:

float strength = (G * mass * p.mass) / (distance * distance);

There is some slightly complicated code that controls the direction of the force and how that force is then applied to the planet object’s state of motion, but I didn’t have the time to explain this, which was a bit disappointing (see below).

For The Future

I am currently really interested in incorporating programming into the academy program, but have found myself a bit intimidated by the challenges identified by Ruth Chabay. The most significant challenge is time:

In an already full introductory physics curriculum, there is little or no time to teach major programming skills. Students who are new to programming are also new to the process of debugging; teaching debugging strategies requires even more time…Working on programming activities only once a week in a lab or recitation section may not be adequate to keep knowledge of syntax and program structure fresh in the students’ minds.

I plan on taking some time this summer to see how I could integrate computer programming more significantly into the curriculum without causing the learning of Physics to suffer – that would of course defeat the purpose!

Modeling A Rocket’s Journey – A Synthesis

A Synthesis Of All The Models (Thus Far)

In this post I will describe a culminating activity for the first year students in the Academy. This is really the destination that the students have been headed towards since the beginning of the course. Everything they have learned is synthesized in this activity where the students gather data from various observations/experiments and then use the data to predict their own model rocket’s journey.

Note: There were two significant simplifications that we had to make based on the ability level of the students and the physics content covered in class. We had to assume that there was no air resistance force acting on the rocket during the thrust and cruise phases. We also assumed that the mass of the rocket did not change. I intend to have the students reflect on how this might affect the predictions and then analyze the actual performance data. More on this later…

Measuring The Rocket Engine Thrust

We first needed to figure out the average force exerted by the rocket motor on the rockets and the time interval during which that force would be applied. This would give the students both the thrust force and the length of time of the thrust phase. We needed to collect force measurements for the rocket motors that we were using (C6-5). You can actually download this from many different websites, but it was much more fun to actually do it ourselves! Mr. Holt made a neat little rocket motor holder that was attached to a force meter and we went out into the rain to test the motor (see video below – thank’s Gary!):

The force data was then shared out to the students – here is what the graph looked like:

rocket-engine-test

And this is the force vs time graph one retailer posted on their website:

Although the students had not been introduced to the concept of Impulse-Momentum transfer, we can use the average force, and that seems to work out really well. Just to make sure we could do this, I used the Integral tool in LoggerPro to measure the impulse, and it came out to 8.83 N s – really close to what Estes states – 8.8 N s.

A Mini Wind Tunnel Test

The students then needed to measure the drag force on their parachutes (all cut on our new laser cutter) as a function of air speed so that they could estimate the terminal velocity of their rocket during the descent phase.  Next step was to test the parachutes. Luckily, Mr. Holt and I had helped two of our previous students create a really nice wind tunnel. We used a force meter attached to a vertical post inside the tunnel…

parachute_test

…and then we used a little Kestrel anemometer to measure the air speed…

air_speed

Students were able to increase the air speed in the tunnel by turning a rheostat that controlled the fan speed. They then measured the wind velocity and graphed that against the measured force – just like NASA!

Here is some sample data to show how the results came out – not bad!

parachute-test-data

Students now had a way to estimate the descent velocity because they could calculate the gravitational force on their rocket, using the measured mass of their rockets, and then they could use their data to find the corresponding wind speed.

Putting It All Together

As part of their final (50%), the students were asked to then take this data, measure the mass of their model rocket and construct a prediction. The prediction was to include these five elements:

  1. A set of force diagrams for the different phases – thrust, cruise, and descent. The diagrams also had to include accompanying net force equations.
  2. An acceleration vs time graph.
  3. A velocity vs time graph.
  4. A position vs time graph.
  5. Finally a calculation sheet that includes all calculations required to create the motion graphs.

The students have been asked to turn this in before the actual launch.

As we collected the data above, I never explicitly reveal how the data should be used to make these predictions, but I do give them some guiding questions that orients them. They work with their partner’s on this report, but I warn them that they will both be held responsible for understanding the process of creating the prediction report.

Testing the Predictions

Each student rocket will be equipped with a small altimeter (from Apogee Rocketry – love this thing!).

This altimeter records altitude data in 1/10 of a second intervals, and we have found it to be very accurate and reliable. We will be launching next week, so tune in soon for an exciting update on how the launches went!

Building The Net Torque Model – Part 3

Appending The Conservative Models

After investigating the causal relationship between torque and angular acceleration, I introduced the possibility to the class that perhaps we also needed to revisit the Energy Transfer Model and the Momentum Transfer Model. The students agreed that an object that is rotating must have energy. This was pretty easy to demonstrate.

I set up a situation in the class where two of the variable inertia disks that we created on the 3D printers were placed at the top of an inclined ramp. The internal marbles were placed at two different configurations inside the disks and then the students predicted which disk would reach the end of the ramp first. I was pleased to find out that the class appeared to agree that the disk with the marbles located closer to the radius would be the winner. I really think that our investigation with the variable inertia disks solidified the students’ conceptual understanding of rotational inertia and the importance of mass distribution.

I have not yet found a good experiment where students could discover the rotational kinetic energy relationship, so I decided to take them through a derivation based on linear kinetic energy. I then asked the students to do some whiteboard work. I asked them to demonstrate that the disks would indeed reach the end of the ramp at different times. Although this wasn’t strictly a constructivist approach, it was good practice in doing some fairly difficult algebra without numerical values – something the students traditionally are not very good at.

We then moved onto momentum. Again, I started by reviewing the Momentum Transfer Model for a particle. At this point the pattern had been fairly well established. The relationship between angular and linear quantities seemed to have taken hold because the students were quick to propose a mathematical definition for angular momentum. Our next goal was to figure out whether this was a conserved quantity.

Mr Holt and I had created a set of metal disks that could be attached to the rotary sensors. I decided to create our own, rather than (sorry Vernier) buy them as I thought that the commercial kit was over priced. It wasn’t too hard to create the disks, especially when you have access to a CNC plasma cutter!

image1

The students attached one disk to the rotary motion sensor and then got that disk spinning. They then took a second disk that had small magnets attached to it, and dropped this disk onto the spinning disk. The students compared the angular velocity before and after the disks were combined and then calculated the angular momentum of the system before and after. The data we got was quite good with the class getting in the range of only about a 5% to 6% difference.

Wrapping it Up (or Un-Rolling It Down)

As a final deployment, I decided to try the deployment activity that Frank Nochese did with his students. It seemed like a good (and fun) way to wrap up our model (or as I have already argued – models).

Before doing the deployment activity, I reviewed all the model specifics with the students. My point here was to impress on them that what we had not really built a new model, but rather had extended many of the prior particle models to include rigid extended bodies. This generally only required that we consider the moment arm in all the particle models. I think this really helped a number of students see the connection between models that they felt they understood and all this rotational stuff that seemed a bit confusing.

I then set them up with the deployment activity, but I asked them to specifically solve the problem using both energy and net torque. There was some success, but I realized that the task was a bit much for the class. Once again, it is clear that I need to give them more practice with these problems that require multiple steps and that involve algebraic manipulation of symbols without numbers. Plenty of time to practice that!

Building The Net Force Particle Model (Part 1)

From “The How” to “The Why”:

One of the three projects that the students will complete this year is a custom designed and fabricated rocket. One of the requirements of this project is for the rockets to carry a small solid state altimeter that collects vertical position data. This year I decided to give the students some data collected by last year’s students. Here is what the data looks like from one typical altimeter reading:

Rocketdata2013

As an introduction to this next model, I presented them with the data and asked them to use both the Constant Velocity Particle Model and the Constant Acceleration Particle Model to describe the motion of the rocket based on the data. Students responded to several questions that I created and they posted their answers through the Learning Management System we use.

A Simple Definition, A Simple Representation

The student investigation teams were then asked to draw velocity vs time graphs on their whiteboards. I was impressed to see that most teams were able to interpret the position data and create a velocity graph that agreed with the data. There was some debate about the graphs, but the students worked through these differences and came to consensus around what the graph would most likely look like. At this point I was thinking about using LoggerPro’s ability to graph the derivative of a data set, but decided that I would leave that for a later date, though next year I might do it earlier.

I then introduced a very basic definition of a force:

“A Force is A Push or A Pull”

And then I proposed that we could represent the force with an arrow, just as we had done with velocity and acceleration. I then asked them to divide the rocket data into four sections based on the answers to the questions we had discussed. The students then drew a representation of the rocket in each stage and the forces acting on the rocket. The stages the students identified were 4) on the ground, 3) descending by parachute, 2) going up without fuel, and 1) going up with fuel. I asked them to draw the diagrams by starting at the end. Here is a typical example of the force diagrams the students drew:

photo 2

The labeling is a standard that is outlined in the Modeling methodology – it reads (type, feeler, dealer).

Constant Velocity Motion and Net Force

We started the class discussion by looking at the forces acting on the rocket when the rocket was on the ground. Students agreed unanimously that there were two forces acting on the rocket – one down, one up – the gravitational force and then the force from the ground. Great. Then on to the descent phase. Certainly less unanimity here. The students again agreed on the number of forces – two – one up from air resistance, one down from gravity. The students quickly got into several back-and-forth arguments about the length of the force vectors. The class was split. Were the forces equal? Or, was gravity “winning”? The big stumbling block was around the question, “if gravity was equal to the air resistance force, then why was the rocket still falling”? A classic example of Aristotelian thinking. I encouraged them to ask the question – “if gravity was winning, why wasn’t the rocket speeding up?” One student proposed that maybe the force of gravity was just ever so slightly larger. Some students pounced in this. They argued that the forces weren’t equal at first, but as the rocket (with parachute) descended, the air resistance force strengthened and eventually became as strong as the gravitational force. the reason the rocket didn’t slow down was because it was already moving when the forces became equal. Awesome. Then a student gave an excellent description of a thought experiment where a box was traveling through space in one direction and convinced the students that the box would not slow down if you pushed equally on both sides of the box. Students reached consensus – the rocket moved at a constant velocity because the forces were equal.

The “Residue” Misconception

We then progressed to the next stage. Things got really interesting. Without exception, ALL the student groups identified an arrow pointing upward, even though they all agreed that the fuel had run out. The question that I think cuts through this the quickest is to ask “who is pushing on the rocket upward?” Most students get that funny look on their faces as their brains begin to realize that they just ran into a logical conundrum. Some students start to respond – “the rocket pushes the rocket.” OK, how? What kind of force is it? A contact force? How does it push or pull itself? The students at this point began to question each other and the room erupted in arguments. Being a bit of a control freak, I’ve had to learn to allow space and time for these chaotic moments, but also realize the importance of catching the class before it descends into something less productive.

At this point, one group erased the upward force. I asked them why they had done this. They responded that they didn’t think a force was needed for the rocket to continue upward, and that gravity and air resistance were slowing the rocket down. This seemed impossible to some of the students. They asked – “but something is left over after the fuel runs out, isn’t there?” The class began to divide up into those that now believed the rocket no longer had any upward force acting on it and those that believed there was some kind of “left-over” force, what I call a “residue”. So, once again, I asked them to identify the dealer of the residue force. The answer is generally – “the fuel”. Ah, but hasn’t the fuel run out? Yes, but the rocket has gained something from the fuel and now that is what is pushing it upward.

This is not such a wild idea, and in fact is not that far from the idea of Kinetic Energy. The students that were in the “no upward force” camp started to explain to the other students in the class that the fuel had “given” the rocket its upward velocity, but now that the fuel was gone, the rocket was now slowing down. We discussed the idea that anything that was slowing down must be experiencing a force pushing in the opposite direction of its velocity. We returned to the thought experiment with the box floating through space. The students debated about whether this box would slow down if the force that had gotten the box moving in the first place disappeared. The students agreed that if there were no forces acting on it to slow it, then it was reasonable to say that it would never slow down. Students then agreed the rocket was no different. It didn’t need a force to continue moving at a constant velocity, but that if it was instead accelerating (in this case in the negative direction) then it would need a force, which was provided by gravity and the air resistance force.  The students began to coalesce around the idea that if a force was a push or a pull, then the rocket that had run out of fuel was not getting pushed any longer, and that although it was moving upward it was indeed accelerating downward.

Making Some Observations

During the next class, I had the students set up a motion detector on one side of a Vernier dynamics track and use a force meter to pull on a low friction cart. They were to also record the velocity of the cart while the students pulled twice in quick succession on a string connected to the cart and force meter.

IMG_0686

The students then shared their graphs with the rest of the class:

IMG_0687

This experiment is meant to re-enforce some of the arguments made during the previous class. The students quickly see that the velocity is measured to change when the force is applied and that the velocity is “constantish” when no force is applied. The students were ready to tackle how the force and acceleration were quantitatively related, but that’s for another post…

Deploying The Constant Acceleration Particle Model (CAPM)

The APT 1 students just recently finished building and testing (deploying) the Constant Acceleration Particle Model. As stated in an earlier post on studying velocity vs. time graphs for a constantly accelerating particle, the students used these graphs to study how the velocity changed, but also how the graph gave the students a way to calculate the change in position of the particle.

Position vs Time Graphs and “Fitting The Function”

Using the Vernier Motion Sensors, the students then collected position data for a cart that was accelerated across the table at a constant rate (using a modified Atwood’s machine setup). This revealed what some of the students had expected – the graphs were curved!

At this point, I could have introduced the process of linearizing data as some other Modelers have done, and perhaps I will do that next year, but this year I went ahead and just asked the student to use the “function fit” tool in LoggerPro. This tool fits a mathematical model to the data, and then displays that model on the screen. I can see why some teachers feel that it is better to get the students to go through the process of linearizing the data because depending on the tool in LoggerPro can lead to some misunderstanding and it encourages the students to depend on the computer to “give them the right answer”.

What Do “A”, “B” and “C” Mean?

The reason I do introduce this tool is because we are going to use it in the future, and it gives me a reason to talk about the coefficients of the fitted function. So, immediately after the students see the fitted function, I direct them to desmos.com to have some fun with quadratic functions – and (re)learn how the coefficients in the quadratic function change the curvature of the graph and the location of the vertex. This allows us to get into a good discussion about how these coefficients are related to physical changes. I ask the students to consider the questions – “How would the graph have changed if the cart had a greater acceleration?” and “What if the cart had accelerated in the opposite direction?” and “What if the cart had started from a different location?”

Cart Jousting

Once they have a solid grasp of this function, and how it can be used to predict the position of an accelerating particle, I set them off on a deployment task – cart jousting!

The students set up two carts a distance of about a meter away from each other. Each cart was on its own track. Once again, a weight hanging on string that passed over a low friction, low mass pulley was connected to each cart. I gave the students different masses for each cart so that the carts would accelerate towards one another at different rates. The students were also asked to attach a pencil to the front of the cart so that the cart would visibly push the other cart as it passed. The students used LoggerPro one more time to get the slope of the velocity vs time graph so that they had the acceleration of each cart. Using the function that outputs the position of an accelerating particle, given a specific time value, the students were able to predict the point of collision.

When I have the students do this, as suggested by modeling pedagogy, it is really important to have the students explain the process by which they established their prediction. This is done on whiteboards. I don’t however have a class discussion unless I think it is going to help certain groups. Otherwise, I take on the role of Socratic inquisitor and allow the teams that are confident, to proceed with the experiment. This allows me to coach certain teams that I know might just otherwise wait to see what other teams have done, and simply follow them.

Students then have fun taking video and sharing the video to me. I’d like to set up some way for the students to post to a social media site, but I am a bit concerned that I would need to be the filter – something I have not yet found.

Well, now its time for us to turn our attention from strictly kinematic models to causal models that describe and represent causal relationships for answering the question – “why do things move the way they do?”

Building The Net Torque Model – Part 2

Investigating An Unbalanced Net Torque

We started by looking at the fact that a disk experiencing a net unbalanced torque also experienced a change in rotational or angular velocity. The students used a rotary motion sensor to measure the angular position and the angular velocity of a disk experiencing a constant torque and the students immediately recognized the similarity between a particle experiencing constant linear acceleration and a rigid body experiencing constant angular acceleration.

IMG_0704

So, the natural next step in our investigation was to determine the causal relationship between a net unbalanced torque and the angular motion state of a rigid body. The students discussed how we might set up an investigation that would help us understand this relationship, and I helped guide them towards a final investigation design where we used a rotary motion sensor attached to the wooden disk we had used in a previous investigation.

The rotary sensors from Vernier are rather expensive, but also quite nice. They come with a plastic spindle with three different pulley radii. The only issue that I have with these is that they do not include a useful screw for attaching objects to the pulley – they expect you to purchase their completely over priced accessory kit. I don’t suggest this. Instead, you can create your own and then use a 6/32 screw to attach them to the pulley – just be careful not strip the threads!

IMG_0703

Working off a similar investigation when studying the causal relationship between a net unbalanced force and linear acceleration, the students recognized that we needed to include a force sensor for measuring the applied force. The students then had LoggerPro plot the points for the calculated torque (using a calculated column) and the measured angular acceleration.  The data isn’t super clean, but its good enough for the students to conclude that the relationship is most likely linear.

Dimensional Analysis – Inferring Rotational Inertia

I was amazed to discover that some students in the class set off to understand what the units of the slope could be reduced to. They immediately saw that the proportional constant (slope) included kg (mass) but that wasn’t all. After some work, the class had determined that the units for the slope were kg * m^2.

This led to a qualitative discussion about the inertia of rotating objects. We discussed hoops and disks primarily, and the class seemed to agree that the units made sense. Although I didn’t have any hoop-disk sets like the ones you can buy from various vendors, we did perform some thought experiments around mass distribution and rotation, but we needed to be sure that we were on the right track.

A Better Variable Inertia Disk

So last year I was looking for an investigation that would really help the students discover the importance of mass distribution for a rotating object. Reading the material on the AMTA website regarding the unit on rotational motion, the researches stressed the importance of connecting mass distribution to the rotational inertia. I found this variable inertia disk from Fischer Scientific and decided to purchase it. I commend these guys on making this, but frankly I decided that I could make a better one.

My colleague and I set about redesigning these disks. The improvements we made included a) better compartments for the metal marbles so that they didn’t move around, b) an index and lip so that the two sides fit more securely together, and c) more compartments so that we can test more mass configurations. After we made our designs, we used our Makerbot 3D printer to print out ten copies of the disks.

IMG_0707 IMG_0708

With these disks attached to the rotary motion sensors, the students were able to confirm that although the total mass of the disk did not change, the angular acceleration declined as the mass was moved outward from the radius of rotation. This was more of a qualitative investigation, but I think the students were able to clearly see how moving the mass farther from the axis affected the rotational inertia of the disk.

Deploying The Model (So far)

Now that the students had built a predictive model that described the quantitative relationship between rotational inertia, angular acceleration and net torque, they were ready to test it.

We returned to the investigation setup with the disk, but this time attached a hanging mass to the string and they attempted to predict the angular acceleration. The students immediately made the mistake (as I thought they might) in considering only the disk in the system. This gave me a chance to review with them the following process:

  1. Identify the system schema (now it includes things that can rotate!)
  2. Draw your force vector (free body/particle) diagrams and now also your force-moment arm (rigid body) diagrams.
  3. Write the summation of forces AND the summation of torques for the system.
  4. Do some algebra.

The trickiest part to figuring this out is getting the signs right due to interaction pairs and making sure that they agree. I ask the students to start with a diagram and then go through and label each force + or – by picking a force and then finding its partner and then making sure that the rest of the force directions agree.

Once they were able to get a prediction that we all agreed seemed correct, they ran the experiment. The class was able to predict the angular acceleration within about 10% error. We discussed the possible reason for discrepancy which led to some interesting discussions around modeling the rotational inertia of the attachment screw and washer, and also the frictional forces at work.

The students were pretty convinced that the model worked, and so next stop – energy and momentum in systems with rotational motion.