# Verifying motor selection calculations

I'm trying to select a brushed DC motor for a project. I tried following the advice on sizing electric motors, mentioned in this question, but a few details were missing, and I'm unsure if I properly followed the procedure.

For my application, I need:

• Nm = number of motors = 2
• Wd = wheel diameter = 12 cm
• Wp = estimated weight of platform = 5 kg
• Minc = maximum incline under load = 5 degrees
• Vmax = maximum velocity under load = 5 km/hr
• Fpush = maximum pushing force = 1.25 kg
• Ur = coefficient of rolling friction = 0.015

These are my calculations:

Step 1: Determine total applied force at worst case.

Ftotal = Wp * (Ur*cos(Minc) + sin(Minc)) + Fpush = 1.7604933161 kilogram


Step 2: Calculate power requirement.

Vradps = maximum velocity under load in radians/second = 23.1481481481 radian / second

Pmotor = required power per motor = (Ftotal * Vradps * Wd/2)/Nm = 1.22256480284 kilogram * meter * radian / second


Step 3: Calculate torque and speed requirement.

Tmotor = required torque per motor = Pmotor/Vradps = 5281.47994829 centimeter * gram = 73.345953832 inch * ounce
RPMmin = required revolutions per minute per motor = Vradps / 0.104719755 = 221.048532325 rev / minute


Are my calculations correct? Intuitively, the final Tmotor and RPMmin values seem right, but my calculation for Pmotor doesn't exactly match the one used in the link, which doesn't explicitly do the conversion to radians / second and therefore doesn't result in the proper units.

Here's my Python script for reproducing the above calculations:

from math import *
#http://pint.readthedocs.org/en/0.6/tutorial.html
from pint import UnitRegistry

ureg = UnitRegistry()

def velocity_to_rpm(v, r):
kph = v.to(kilometer/hour)
r = r.to(kilometer)
d = r*2
rpm = (kph / (2*pi*r)) * ((1*hour)/(60.*minute)) * rev
return rpm

def velocity_to_radps(v, r):
return velocity_to_rpm(v, r).to(radian/second)

# Units
km = kilometer = ureg.kilometer
meter = ureg.meter
newton = ureg.newton
cm = centimeter = ureg.centimeter
hr = hour = ureg.hour
mm = millimeter = ureg.millimeter
rev = revolution = ureg.revolution
minute = ureg.minute
sec = second = ureg.second
kg = kilogram = ureg.kilogram
gm = gram = ureg.gram
deg = degree = ureg.degree
rad = radian = ureg.radian
oz = ureg.oz
inch = ureg.inch

# Conversions.
km_per_mm = (1*km)/(1000000.*mm)
hour_per_minute = (1*hour)/(60.*minute)
minute_per_second = (1*minute)/(60*sec)
minute_per_hour = 1/hour_per_minute
gm_per_kg = (1000*gm)/(1*kg)
cm_per_km = (100000*cm)/(1*km)

# Constraints
target_km_per_hour = (5*km)/(1*hour) # average walking speed
estimated_platform_weight = 5*kg
maximum_incline_degrees = 5*deg
maximum_incline_radians = maximum_incline_degrees * ((pi*rad)/(180*deg))
maximum_pushing_force = estimated_platform_weight/4.
maximum_velocity_at_worst_case = (5*km)/(1*hour)
rolling_friction = 0.015 # rubber on pavement
velocity_under_max_load = target_km_per_hour
number_of_powered_motors = 2

# Variables
wheel_diameter_mm = 120*mm
wheel_radius_mm = wheel_diameter_mm/2
wheel_radius_km = wheel_radius_mm * km_per_mm
rev_per_minute_at_6v_unloaded = 33*rev/(1*minute)
rev_per_minute_at_6v_loaded = rev_per_minute_at_6v_unloaded/2.
mm_per_rev = (wheel_diameter_mm * pi)/(1*rev)
target_rpm = velocity_to_rpm(target_km_per_hour, wheel_radius_mm)
target_radps = velocity_to_radps(target_km_per_hour, wheel_radius_mm)

# Calculate total applied force at worst case.
total_applied_force_worst_case = estimated_platform_weight * (rolling_friction*cos(maximum_incline_radians) + sin(maximum_incline_radians)) + maximum_pushing_force
print 'Ftotal:',total_applied_force_worst_case

# Calculate power requirement.
vel_in_radps = velocity_to_radps(velocity_under_max_load, wheel_radius_mm)
print 'Vradps:',vel_in_radps
required_power = total_applied_force_worst_case * velocity_to_radps(velocity_under_max_load, wheel_radius_mm) * wheel_radius_mm.to(meter)
required_power_per_motor = required_power/number_of_powered_motors
print 'Pmotor:',required_power_per_motor

# Calculate torque and speed requirement.
required_angular_velocity = velocity_under_max_load/wheel_radius_km * hour_per_minute * minute_per_second * rad #rad/sec
required_rpm = required_angular_velocity / 0.104719755 * (rev/rad) * (sec/minute)
required_torque_per_motor = (required_power_per_motor/required_angular_velocity).to(gm*cm)
print 'Tmotor: %s, %s' % (required_torque_per_motor, required_torque_per_motor.to(oz*inch))
print 'PRMmin:',required_rpm


## 1 Answer

I think your Pmotor calculation is correct. The reason for the difference with the CIRC link is in the P=F*v equation they are referring to the linear velocity. Your conversion is converting the rotational velocity back into linear velocity.

I don't think the Ftotal calculation is correct because your estimated weight isn't correct. Kg is a unit of mass, not weight. To convert to weight, you need to multiply by the gravitational pull of the earth (9.8 m/s^2). This is also why the units on your power estimate isn't in Watts. Your torque units should then be N*m or equivalently oz(force)*in. Note that this is ounce force not the sometimes used ounce mass. It is important to distinguish between mass and force even though the ounce unit is sometimes abused to ambiguously mean either in one Earth gravity environments.