The Magnitude of Static Friction

Students learn - better Newton’s second law of motion by experimenting with moving the body down an inclined plane. Friction force is being measured and the coefficient of static friction is determined. For that purpose, a robot is being used alongside a gyro and color sensor from Lego EV3 and a light sensor from Vernier.

Preparing For This Tutorial:

  • The LEGO Mindstorm EV3 Robot that coincides with this tutorial comes from building specific sections found in the LEGO® MINDSTORMS® Education EV3 Software (Science ->Force and Motions ->Friction).

  • First the brick is connected to the computer, then attach the motor and make a ramp as shown in Figure 1. The students continue extending the ramp (Figure 2), connect the sensors and then put some pieces of cardboard over the ramp (Figure 3).

image0 image1

image2 image3

Time constraints:

  • starting from 45 min - single lesson

  • up to 225 min - five lessons (in a row)

Exercise

Physics:

Prepare two experimental exercises, one classic with the use of a stopper, a length measurement tool, a inclined plane, a slip body, a dynamometer. The second experimental setting is with the Lego Robot EV3 and the use of various sensors. The students make the two exercises in parallel. Make a comparison of the two experiments.

Computer science:

Create a program that calculates the static and kinetic friction between two surfaces.

Detailed tasks and questions

  1. Do you know Newton’s second law and where it applies to everyday life?

  2. What does the friction coefficient of a body sliding on substrate depend on?

  3. How is the friction coefficient calculated for a given surface?

  4. If the coefficient of friction between a 35 kg box and the substrate is 0.30, how much horizontal force is needed to move the box to the left at constant speed?

  5. How is the friction coefficient calculated for a given surface?

  6. Create a program that calculates static and kinetic friction between two surfaces of a body sliding along an inclined plane.

    1. Write a program that will print the angle of the gyro sensor while lifting the ramp, thus accurately calibrating the sensor. If the angle is greater than 60 degrees the ramp stops lifting.

    2. Create a program that would lift the robot’s ramp, and the gyro sensor to calculate at what angle the body began to move and passed the first light sensor.

    3. Add a second sensor (color sensor) to register when the body has reached the end of the ramp. This sensor emits red light and when it detects the reflected light from the body it marks the time the body has reached the end of the ramp.

    4. Add a counter that will calculate how long the experiment lasted and the difference between when the body started moving (the time recorded by the first light sensor) and when it reached the end of the ramp (the time of the second sensor, the color sensor).

  7. Using the data from the previous steps in the program, add the equations to calculate the static and dynamic friction coefficients.

  8. Make multiple measurements with different objects (objects of different mass and shape) that move across different surfaces (e.g. wood, aluminum foil, glass, etc.) and compare the results of the measurements.

Theory

What is Static Friction?

The force that has to be overcome in order to get something to move is called static friction. This is the force that prevents an object, placed on a sloped surface, from sliding.

At solid surfaces, the static friction occurs as a consequence of the surface roughness of the objects in contact. Its value depends on the type of the contacting surfaces. It is higher for rough and dry surfaces and lower for wet and smooth ones.

The force necessary to induce motion (i.e. to overcome the static friction), is bigger than the one necessary to continue the motion (i.e. to overcome kinetic friction). So, the coefficient of static friction (μ:sub:s), exceeds the one of kinetic friction (μ:sub:k).

The coefficient of static friction has a constant value for each pair of contacting surfaces (materials). For example, it is 0.74 for steel / steel contact, 0.61 for steel / aluminum contact, etc.

In order to make a stationary object move, we have to overcome the static friction force by an applied force. When a small force is applied to a nonmoving object, the static friction is of equal magnitude, but in the opposite direction to the applied force. When the force is being increased, at a certain point it reaches the maximum static friction value. At that point, the static friction is overcome and the object starts to move.

The maximum static friction (f:sub:smax) equals to:

fsmax = μsFn

where μs is the coefficient of static friction, and Fn – the size of the normal contact force between the surfaces.

An important point about static friction is that its magnitude does not have a fixed value. Instead, it varies from zero to some maximum value. This maximum value is reached at the instant the object starts to move.

If you push on a table with a force of ever-increasing magnitude, you will notice that the table remains at rest until you exceed a critical value. Because of Newton’s second law, the magnitude of the force of static friction must increase as the applied force on the table increases, if the forces are to remain balanced.

Static Friction on a Horizontal Surface

Suppose the applied force acting on the desk in Figure 1. Example 1 demonstrates how to calculate the force of static friction by using a free-body diagram to help write the equation for the net force on the desk. Since Fapp acts at an angle to the surface of the desk, it is convenient to use Cartesian axes to solve this problem.

Static Friction on an Incline

If an object is at rest on an incline, the net force acting on the object is zero, Fnet = 0 N. Let’s first examine the forces acting on the object.

image4

Figure 2 (left) Free-body diagram for an object at rest on an incline; (right) vector addition diagrams for the forces

When working with inclines, it is easier to rotate the reference coordinates so that motion along the incline is described as either uphill or downhill. This means that only the gravitational force needs to be resolved into components, one parallel to the incline Fg and one perpendicular to the incline Fg. Usually, uphill is chosen to be positive unless the object is accelerating downhill.

In Figure 2, if there were no friction, the component Fg would cause the object to accelerate down the incline. So for the object to remain at rest, a balancing force (F:sub:f static) must be acting up the incline.

The equation for the net force acting on the object parallel to the incline would then be

image30

To determine the expression for F g requires using the geometry of a triangle. In Figure 3.75, the angle between F g and F g is 90.0 . Since the angle between F g and F g is 90.0 - θ , the angle between F g and F g is θ

image31

Figure 3

Since the object is not accelerating perpendicular to the incline, the equation for the net force acting on the object in this direction is

image32

What is Kinetic Friction?

Kinetic friction is the retarding force between two objects in contact that are moving against each other. It depends on the type of the contacting surfaces. Kinetic friction is high for rough and dry surfaces and low for wet and smooth ones.

The force necessary to induce motion (i.e. to overcome the static friction), is bigger than the one necessary to continue the motion (i.e. to overcome kinetic friction). So, the coefficient of kinetic friction (μ:sub:k) is lower than the one of static friction (μ:sub:s).

Kinetic friction remains constant between two surfaces, regardless of the relative speed of their movement. The coefficient of kinetic friction has a constant value for each pair of contacting surfaces (materials). For example, it is 0.57 for steel / steel contact, 0.47 for steel / aluminum contact, etc.

The kinetic friction (f:sub:k) equals to:

fk = μkFn

where μk is the coefficient of kinetic friction, and Fn – the size of the normal contact force between the surfaces.

The Direction of Kinetic Friction on an Incline

Suppose you apply a force to the desk in Figure 4 and the desk starts to slide across the floor at constant velocity. In this situation, the force of static friction is not able to balance the applied force, so motion occurs. Now the floor will exert a force of friction on the desk that opposes the direction of motion of the desk. This force is the force of kinetic friction, F f kinetic

image33

Kinetic friction is present any time an object is sliding on another, whether or not another force acts on the sliding object. If you stop pushing the desk once it is in motion, the desk will coast and eventually stop. While the desk is sliding, the floor exerts a force of kinetic friction on the desk. This frictional force is directed backward, and causes the desk to eventually come to a stop.

Accelerating Down an Incline

Let’s first consider the case where an object accelerates downhill (Figure 5). In this situation, F g causes the object to accelerate downhill. The force of kinetic friction acts to oppose the motion of the object. So F f kinetic is uphill as shown below

image9

Figure 5 (left) free-body diagram for an object at accelerating downhill; (right) vector addition diagrams for the || and ⊥ forces

Accelerating Up an Incline

If an object is accelerating uphill, the force of kinetic friction acts downhill to oppose the motion. F g also acts downhill. A force, F app, must act uphill on the object that is great enough to overcome both F f and F g (Figure 5). image10

Figure 5 (left) free-body diagram for an object accelerating uphill; (right) vector addition diagrams for the || and ⊥ forces

Difference Between Kinetic and Static Friction

1) Definition of Kinetic and Static Friction

Kinetic Friction: The retarding force between two objects in contact that are moving against each other is called kinetic friction.

Static Friction: The force that has to be overcome in order to get something to move is called static friction.

2) Formula for Kinetic and Static Friction

Kinetic friction: The kinetic friction (fk) equals to fk = μkn, where μk is the coefficient of kinetic friction, and n – the size of the normal contact force between the surfaces.

Static friction: The maximum static friction (fs max) equals to fsmax = μsn, where μs is the coefficient of static friction, and n – the size of the normal contact force between the surfaces.

3) Magnitude of Kinetic and Static Friction

Kinetic Friction: The force necessary to induce motion is always bigger than the one necessary to continue the motion. So the kinetic friction coefficient is smaller than the static friction one.

Static Friction: The coefficient of static friction exceeds the one of kinetic friction.

Summary of Kinetic and Static Friction:

  • The tangential component of the force of interaction between two surfaces in contact is called friction. It leads to resistance against movement between the surfaces and can cause mechanical deformation and heating.

  • The retarding force between two objects that are moving against each other is called kinetic friction. The force that has to be overcome in order to get something to move is called static friction.

  • Friction depends on the type of the contacting surfaces. It is high for rough and dry surfaces and low for wet and smooth ones.

  • The force necessary to induce motion (i.e. to overcome the static friction), is bigger than the one necessary to continue the motion (i.e. to overcome kinetic friction). So the coefficient of static friction (μ:sub:s), exceeds the one of kinetic friction (μ:sub:k).

  • The kinetic friction (f:sub:k) equals to fk = μkFn, where μk is the coefficient of kinetic friction, and Fn – the size of the normal contact force between the surfaces in contact. The maximum static friction (f:sub:smax) equals to fsmax = μsFn, where μs is the coefficient of static friction, and Fn – the size of the normal contact force between the surfaces in contact.

Short help on programming

Commands/functions needed for the exercise

Physics Computer science

If the coefficient of friction between a 35 kg box and the substrate is 0.30, how much horizontal force is needed to move the box to the left at constant speed? Write a program that calculates static and kinetic friction between two surfaces of a body sliding along an inclined plane Write a program that will print the angle of the gyro sensor while lifting the ramp, thus accurately calibrating the sensor. If the angle is greater than 60 degrees the ramp stops lifting.

  1. #!/usr/bin/env python3

Body resting on a inclined plane is being examined. Then, the Newtonian equations are solved…?

  1. from ev3dev.ev3 import *

Finally, we get simple equations:

  1. import time

\(\overrightarrow{F_{a}} = \ \mu\ m\ \overrightarrow{g}\)

  1. import math

The coefficient of static friction is calculated with the formula:

  1. import os

The coefficient of dynamic friction is calculated with the formula:

  1. If we measure the angle of the inclined plane when the body starts to slide (Figure 4), we also determine the coefficient of friction (Figure 5)!

  2. Setting up the motors and sensors

image11

#!/usr/bin/env python3

os.system("clear")

print("Connecting the IO ports...")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    main_motor = MediumMotor("outA")

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gyro_sensor = GyroSensor()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gyro_sensor.mode = 'GYRO-ANG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ### -----------------------------------------------

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    angle = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prev = 0 # this is the previous gyro value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    motor_working = True

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    firsttime = True

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while True:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          print("Angle:", angle)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if angle > 60 and not firsttime:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           main_motor.stop()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           motor_working = False

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           break

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if motor_working:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            main_motor.run_forever(speed_sp = -100)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            # ----------- Gyro Sensor -------------

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            gyro_value = gyro_sensor.value()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            currValue = gyro_value – prev

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if not firsttime:

        angle += abs(currValue)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prev = gyro_value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            # -------------------------------------

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            firsttime = False

Create a program that would lift the robot’s ramp, and the gyro sensor to calculate at what angle the body began to move and passed the first light sensor. 40.

#!/usr/bin/env python3


# ----------- Start Sensor Handling ---------------

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if obj_start_sensor.value() < 1000: # assumed threshold value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          print("Sensor Threshold Hit!")

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          main_motor.stop()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          motor_working = False

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          print("Angle in which it fell down", angle)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if motor_working:                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           main_motor.run_forever(speed_sp = -100)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              # --------------------------------------------------

Add a second sensor (color sensor) to register when the body has reached the end of the ramp. 51.

#!/usr/bin/env python3

### ------ Setting up the motors and sensors -------

os.system("clear")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    print("Connecting the IO ports...")

main_motor = MediumMotor("outA")

gyro_sensor = GyroSensor()

gyro_sensor.mode = 'GYRO-ANG'

obj_start_sensor = Sensor("in1")

obj_fall_sensor = ColorSensor("in3")

obj_fall_sensor.mode = 'COL-REFLECT'

### -----------------------------------------------

# ----------- End Sensor Handling ---------------

if obj_fall_sensor.reflected_light_intensity > 1: #calculated threshold

    print(" ----- DONE ----- ")

        print("Angle at which it fell down", angle)

    time.sleep(10)

        input("Press any key to continue!")

    break

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                # --------------------------------------------------

Add a counter that will calculate how long the experiment lasted and the difference between when the body started moving (the time recorded by the first light sensor) and when it reached the end of the ramp (the time of the second sensor, the color sensor).

#!/usr/bin/env python3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    from ev3dev.ev3 import *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import time
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import math
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import os                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ### ------ Setting up the motors and sensors -------
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    os.system("clear")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    print ("Connecting the IO ports...")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    main_motor = MediumMotor("outA")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gyro_sensor = GyroSensor()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gyro_sensor.mode = 'GYRO-ANG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ramp_level = TouchSensor("in4")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    obj_start_sensor = Sensor("in1")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    obj_fall_sensor = ColorSensor("in3")                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            obj_fall_sensor.mode = 'COL-REFLECT'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ### ------------------------------------------------

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    print ("Starting the experiment!")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prev = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    angle = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    speed = 100
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    firsttime = True
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    direction = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startTime = None
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prevTime = time.time()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeCounter = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    motor_working = True
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        while True:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            # ----------- Time Handling ---------------
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            currTime = time.time()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            timeCounter += (currTime - prevTime)

        prevTime = currTime

        # -----------------------------------------

        # ----------- Start Sensor Handling ---------------

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if obj_start_sensor.value() < 1000:

        print ("Sensor Threshold Hit!")

        main_motor.stop()

        motor_working = False

        startTime = timeCounter

    if motor_working:

        main_motor.run_forever(speed_sp = -speed)

        # --------------------------------------------------

        # ----------- Gyro Sensor -------------

        gyro_value = gyro_sensor.value()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            currValue = gyro_value - prev
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if not firsttime:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    angle += abs(currValue)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   prev = gyro_value

                # -------------------------------------

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          # ----------- End Sensor Handling ---------------

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          if obj_fall_sensor.reflected_light_intensity > 1:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              main_motor.stop()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              print (" ----- DONE ----- ")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              print ("Time Counter since the experiment started:", timeCounter)

          print ("Start Time:", startTime)

          print ("Time took to fall down:", timeCounter - startTime)

          print ("Angle at which it fell down", angle)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          time.sleep(10)

      input("Press any key to continue!")

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        break

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  # --------------------------------------------------

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        firsttime = False

Using the data from the previous steps in the program, add the equations to calculate the static and dynamic friction coefficients. 52.

#!/usr/bin/env python3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    # ------------ Calculations ---------------

t = timeCounter - startTime

s = 0.3

a = 2*s/(t*t)

g = 9.81

ms = math.tan(math.radians(angle))

m = ms - (a / (g \* math.cos(math.radians(angle))))

print ("The static coefficient of friction is:", ms)

print ("The kinetic coefficient of friction is:", m)

# -----------------------------------------
Next Section - Fan controlled by a temperature sensor