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
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