driving_physics 0.0.0.3 → 0.0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec6ff08e7731aa8bcb419efee9ab1a96ef7642f3426c7b8a501dae764692d777
-  data.tar.gz: ae217c0e452a764392e5a4df9a0b3280369e21b92d6018ef8d8753c0a6f5f594
+  metadata.gz: 89628c4f71193088741435eb426419edf7c9ac78cad2169c4718f2a365db0881
+  data.tar.gz: a229fa52ed29f6dcb8eab0513e845732e0735dd272e516e4f26603aeabe7f312
 SHA512:
-  metadata.gz: b8844bf3f8c45aae742bc27cbfe8307b7f61f21a600d1eac7f34248aa9a980f9942f6e4ce51ec2b58834978e4ba1a06aa0153ba4323d4e3448b1f038c39495e2
-  data.tar.gz: b41f09936f696ef4afe82f3be701409abddd6b92add4f39d5d1d42a1a412ce4204b08a411818c339bba6820858a0aae3d5324cdbabff76e2b2256e9228ae1120
+  metadata.gz: 42a6061d1ef6e2c989e5fb88141e8a84daaafc3c9a2f31e057d2fb7a384fbaa1c195d05deab18b2703fd5e79b539557543ec8eaf8632cd2a5f776359c7c3e340
+  data.tar.gz: 2860d2b6c17c5d4e9d73868de36bdcf48341d74712666c109d422c97975899b0fde2248b58c060d02e02561ba3dff471d7b66c694a44e5d143108a20f828e477

data/README.md

@@ -6,7 +6,37 @@ Physical simulation of how to make a car go around a track quickly, in pure
 Ruby with minimal dependencies.  Physics from first principles, often
 using `Vector` class from `matrix.rb` in stdlib.
 
-Note, this is very much a **Work In Progress**.
+## Work In Progress
+
+This is very much a **Work In Progress**.  Implemented so far:
+
+### mruby Support
+
+This is big.  This library is primarily a Ruby library, intended for use with
+CRuby (MRI), JRuby, etc.  **mruby** is the redheaded stepchild, with severe
+implications for a codebase that wants to support both sides.  Supporting
+mruby here meant:
+
+1. Editing the codebase (minimally) to remove *mruby-deadends*.
+2. Creating `rake` tasks to process normal .rb files into *mruby-compatible*
+   .rb files
+3. Assembling all needed library .rb files into a master .rb file
+4. Compiling the library to bytecode
+5. Executing a toplevel/main script against the library
+6. Optionally executing toplevel/main bytecode against the library
+
+See the main Rakefile near the top for mruby stuff.
+
+### Library Features
+
+* Spinning: rotational inertia and friction / hysteresis
+* Tires: traction force via friction (static and kinetic) and the normal force
+* Vectors: 2D Vector forces and 3D Vector torques
+* Motor: torque curves, rotating mass with friction
+* Gearbox: gear ratios, final drive, rotating mass with friction
+* Powertrain: combines motor and gearbox
+* Car: 4 tires, powertrain, extra mass presents a load to the powertrain
+* Acceleration: via drive traction from "first principles"
 
 ## Rationale
 

data/Rakefile

@@ -16,6 +16,90 @@ end
 
 task default: :test
 
+#
+# mruby
+#
+
+MRBLIB_DIR = File.join %w[mruby mrblib]
+MRBLIB_FILE = File.join(MRBLIB_DIR, 'driving_physics.rb')
+MRBLIB_MRB = File.join(MRBLIB_DIR, 'driving_physics.mrb')
+MRUBY_DEMO_DIR = File.join %w[demo mruby]
+
+def write_mruby(input_file, output_file = MRBLIB_FILE, append: false)
+  file_obj = File.open(output_file, append ? 'a' : 'w')
+  line_count = 0
+
+  File.readlines(input_file).each { |line|
+    next if line.match /\A *(?:require|autoload)/
+    file_obj.write(line)
+    line_count += 1
+  }
+  file_obj.close
+  line_count
+end
+
+file MRBLIB_FILE do
+  line_count = write_mruby(File.join(%w[lib driving_physics.rb]), MRBLIB_FILE)
+  %w[mruby environment imperial power
+     disk tire motor gearbox powertrain car].each { |name|
+    file = File.join('lib', 'driving_physics', "#{name}.rb")
+    line_count += write_mruby(file, MRBLIB_FILE, append: true)
+    puts "wrote #{file} to #{MRBLIB_FILE}"
+  }
+  puts "wrote #{line_count} lines to #{MRBLIB_FILE}"
+end
+
+file MRBLIB_MRB => MRBLIB_FILE do
+  rb_file  = File.join(%w[mruby mrblib driving_physics.rb])
+  mrb_file = File.join(%w[mruby mrblib driving_physics.mrb])
+  sh 'mrbc', rb_file
+  puts format("%s: %d bytes (created %s)",
+              mrb_file, File.size(mrb_file), File.birthtime(mrb_file))
+end
+
+file MRUBY_DEMO_DIR do
+  mkdir_p MRUBY_DEMO_DIR
+end
+
+desc "Map/Filter/Reduce lib/**/*.rb to mruby/mrblib/driving_physics.rb"
+task mrblib: MRBLIB_FILE
+
+desc "Compile mruby/mrblib/driving_physics.rb to .mrb bytecode"
+task mrbc: MRBLIB_MRB
+
+%w[disk tire motor gearbox powertrain car].each { |name|
+  demo_file = File.join(MRUBY_DEMO_DIR, "#{name}.rb")
+  demo_mrb = File.join(MRUBY_DEMO_DIR, "#{name}.mrb")
+
+  file demo_file => MRUBY_DEMO_DIR do
+    write_mruby(File.join('demo', "#{name}.rb"), demo_file)
+  end
+
+  file demo_mrb => demo_file do
+    sh 'mrbc', demo_file
+  end
+
+  desc "run demo/#{name}.rb via mruby"
+  task "demo_#{name}" => [demo_file, MRBLIB_MRB] do
+    sh 'mruby', '-r', MRBLIB_MRB, demo_file
+  end
+
+  desc "run demo/#{name}.rb via mruby bytecode"
+  task "mrb_#{name}" => [demo_mrb, MRBLIB_MRB] do
+    sh 'mruby', '-r', MRBLIB_MRB, '-b', demo_mrb
+  end
+}
+
+desc "Remove generated .rb and .mrb files"
+task :clean do
+  [MRBLIB_DIR, MRUBY_DEMO_DIR].each { |dir|
+    Dir[File.join(dir, '*rb')].each { |file|
+      rm file unless File.directory?(file)
+    }
+  }
+end
+
+
 #
 # METRICS
 #

data/VERSION

@@ -1 +1 @@
-0.0.0.3
+0.0.2.1

data/demo/car.rb

@@ -0,0 +1,178 @@
+require 'driving_physics/car'
+require 'driving_physics/imperial'
+require 'driving_physics/cli'
+
+include DrivingPhysics
+
+env = Environment.new
+puts env
+
+tire = Tire.new(env)
+motor = Motor.new(env)
+gearbox = Gearbox.new(env)
+powertrain = Powertrain.new(motor, gearbox)
+car = Car.new(tire: tire, powertrain: powertrain) { |c|
+  c.body_mass = 850.0
+  c.frontal_area = 2.5
+  c.cd = 0.5
+}
+puts car
+CLI.pause
+
+duration = 120
+
+acc = 0.0
+speed = 0.0
+dist = 0.0
+
+tire_alpha = 0.0
+tire_omega = 0.0
+tire_theta = 0.0
+
+crank_alpha = 0.0
+crank_omega = 0.0
+crank_theta = 0.0
+
+start = Timer.now
+paused = 0.0
+num_ticks = duration * env.hz + 1
+
+clutch = :ok
+phase = :ignition
+flag = false
+rpm = 0
+
+
+
+puts <<EOF
+
+#
+# IGNITION
+#
+
+EOF
+
+num_ticks.times { |i|
+  if phase == :ignition
+    # ignition phase
+    crank_alpha = motor.alpha(motor.starter_torque, omega: crank_omega)
+    crank_omega += crank_alpha * env.tick
+    crank_theta += crank_omega * env.tick
+
+    rpm = DrivingPhysics.rpm(crank_omega)
+
+    if i % 100 == 0 or rpm > motor.idle_rpm
+      puts Timer.display(ms: i)
+      puts format("%d rad  %d rad/s  %d rad/s/s",
+                  crank_theta, crank_omega, crank_alpha)
+      puts format("%d RPM  %d Nm starter torque", rpm, motor.starter_torque)
+      puts
+    end
+
+    if rpm > motor.idle_rpm
+      car.gear = 1
+      car.throttle = 1.0
+      phase = :running
+
+      puts <<EOF
+
+#
+# RUNNING
+#
+
+EOF
+    end
+  elsif phase == :running
+    # track crank_alpha/omega/theta
+
+    # cut throttle after 60 s
+    car.throttle = 0 if i > 60 * env.hz and car.throttle == 1.0
+
+    ar = car.air_force(speed)
+    rr = car.tire_rolling_force(tire_omega)
+    rf = car.tire_rotational_force(tire_omega)
+
+    # note, this fails if we're in neutral
+    force = car.drive_force(rpm) + ar + rr + rf
+
+    ir = car.tire_inertial_force(force)
+    force += ir
+
+    acc = DrivingPhysics.acc(force, car.total_mass)
+    speed += acc * env.tick
+    dist += speed * env.tick
+
+    tire_alpha = acc / car.tire.radius
+    tire_omega += tire_alpha * env.tick
+    tire_theta += tire_omega * env.tick
+
+    crank_alpha = tire_alpha / car.powertrain.gearbox.ratio
+    crank_omega += crank_alpha * env.tick
+    crank_theta += crank_omega * env.tick
+
+    axle_torque = car.powertrain.axle_torque(rpm)
+    crank_torque = car.powertrain.motor.torque(rpm)
+
+    if flag or (i < 5000 and i % 100 == 0) or (i % 1000 == 0)
+      puts Timer.display(ms: i)
+      puts format("  Tire: %.1f r/s/s  %.2f r/s  %.3f r",
+                  tire_alpha, tire_omega, tire_theta)
+      puts format("   Car: %.1f m/s/s  %.2f m/s  %.3f m  (%.1f MPH)",
+                  acc, speed, dist, Imperial.mph(speed))
+      puts format(" Motor: %d RPM  %.1f Nm", rpm, crank_torque)
+      puts format("  Axle: %.1f Nm (%d N)  Net Force: %.1f N",
+                  axle_torque, car.drive_force(rpm), force)
+      puts        "Resist: " + format(%w[Air Roll Spin Inertial].map { |s|
+                                        "#{s}: %.1f N"
+                                      }.join('  '), ar, rr, rf, ir)
+      puts
+      flag = false
+    end
+
+    # tire_omega determines new rpm
+    new_rpm = car.powertrain.crank_rpm(tire_omega)
+    new_clutch, proportion = car.powertrain.gearbox.match_rpms(rpm, new_rpm)
+
+    if new_clutch != clutch
+      flag = true
+      puts format("Clutch: [%s] %d RPM is %.1f%% from %d RPM",
+                  new_clutch, new_rpm, proportion * 100, rpm)
+      clutch = new_clutch
+      paused += CLI.pause
+    end
+
+    case new_clutch
+    when :ok
+      rpm = new_rpm
+    when :mismatch
+      flag = true
+      puts '#'
+      puts '# LURCH!'
+      puts '#'
+      puts
+      rpm = new_rpm
+    end
+    next_gear = car.powertrain.gearbox.next_gear(rpm)
+    if next_gear != gearbox.gear
+      flag = true
+      puts "Gear Change: #{next_gear}"
+      car.gear = next_gear
+      paused += CLI.pause
+    end
+
+    # maintain idle when revs drop
+    if car.throttle == 0 and rpm < motor.idle_rpm
+      phase = :idling
+      car.gear = 0
+      paused += CLI.pause
+    end
+
+
+  elsif phase == :idling
+    # fake
+    rpm = motor.idle_rpm
+    break
+  end
+}
+
+puts Timer.summary(start, num_ticks, paused)

data/demo/disk.rb

@@ -0,0 +1,83 @@
+require 'driving_physics/disk'
+require 'driving_physics/cli'
+
+include DrivingPhysics
+
+env = Environment.new
+disk = Disk.new(env)
+
+puts env
+puts disk
+puts
+
+axle_torque = 50
+alpha = disk.alpha(axle_torque)
+drive_force = disk.force(axle_torque)
+
+puts [format("Axle torque: %.1f Nm", axle_torque),
+      format("      Alpha: %.1f rad/s/s", alpha),
+      format("Drive force: %.1f N", drive_force),
+     ].join("\n")
+puts
+
+puts "* Spin up the disk with #{axle_torque} Nm of torque"
+puts "* Cut the power at some point"
+puts "* Observe"
+CLI.pause
+
+duration = 750 # sec
+
+dist = 0.0  # meters
+speed = 0.0 # meters/s
+
+theta = 0.0 # radians
+omega = 0.0 # radians/s
+
+paused = 0.0 # seconds
+num_ticks = duration * env.hz + 1
+flag = false # to display current stats
+start = Timer.now
+
+num_ticks.times { |i|
+  # shut off the powah!
+  if i == 18_950
+    flag = true
+    puts '#'
+    puts '# CUT POWER'
+    puts '#'
+    puts
+    axle_torque = 0
+  end
+
+  rotating_friction = disk.rotating_friction(omega)
+  net_torque = axle_torque + rotating_friction
+  net_force = disk.force(net_torque)
+
+  # rotational kinematics
+  alpha = disk.alpha(net_torque)
+  omega += alpha * env.tick
+  omega = 0.0 if omega.abs < 0.0001
+  theta += omega * env.tick
+
+  if flag or i < 10 or
+    (i < 20_000 and i%1000 == 0) or
+    (i % 10_000 == 0) or
+    i == duration * env.hz - 1
+
+    puts Timer.display(ms: i)
+    puts format(" Torque: %.1f Nm (%d Nm)  Friction: %.1f Nm",
+                net_torque, axle_torque, rotating_friction)
+    puts format("Radians: %.1f r  %.2f r/s  %.3f r/s^2", theta, omega, alpha)
+    puts format("   Revs: %d revs  %d revs/s  %d rpm",
+                DrivingPhysics.revs(theta),
+                DrivingPhysics.revs(omega),
+                DrivingPhysics.rpm(omega))
+    puts
+    if flag
+      paused += CLI.pause
+      flag = false
+    end
+  end
+}
+
+puts Timer.summary(start, num_ticks, paused)

data/demo/gearbox.rb

@@ -0,0 +1,53 @@
+require 'driving_physics/gearbox'
+require 'driving_physics/cli'
+
+include DrivingPhysics
+
+env = Environment.new
+gearbox = Gearbox.new(env)
+
+torque = 30
+duration = 30
+
+puts env
+puts gearbox
+puts
+puts "Spin up the gearbox with #{torque} Nm of input torque"
+puts "How fast will it go in #{duration} seconds?"
+CLI.pause
+
+# rotational kinematics
+alpha = 0.0
+omega = 0.0
+theta = 0.0
+
+num_ticks = duration * env.hz + 1
+start = Timer.now
+paused = 0.0
+
+num_ticks.times { |i|
+  # just for info, not used in the simulation
+  friction = gearbox.spinner.rotating_friction(omega)
+
+  # update rotational kinematics
+  # gearbox.alpha incorporates friction and inertia
+  alpha = gearbox.alpha(torque, omega: omega)
+  omega += alpha * env.tick
+  theta += omega * env.tick
+
+  net_torque = gearbox.implied_torque(alpha)
+
+  # periodic output
+  if i < 10 or
+    (i < 100 and i % 10 == 0) or
+    (i < 1000 and i % 100 == 0) or
+    i % 1000 == 0
+    puts Timer.display(ms: i)
+    puts format("RPM %d  Torque: %.3f Nm (%d Nm) Friction: %.3f Nm",
+                DrivingPhysics.rpm(omega), net_torque, torque, friction)
+    puts format("%.1f rad  %.1f rad/s  %.1f rad/s/s", theta, omega, alpha)
+    puts
+  end
+}
+
+puts Timer.summary(start, num_ticks, paused)

data/demo/motor.rb

@@ -0,0 +1,140 @@
+require 'driving_physics/motor'
+require 'driving_physics/cli'
+require 'driving_physics/power'
+
+# next fun idea: PID controller
+
+include DrivingPhysics
+
+env = Environment.new
+motor = Motor.new(env)
+puts env
+puts motor
+puts
+
+puts "Rev it up!"
+motor.throttle = 1.0
+[:torque, :power].each { |run|
+  puts
+  puts run.to_s.upcase + ':'
+
+  800.upto(7000) { |rpm|
+    next unless rpm % 200 == 0
+    omega = DrivingPhysics.omega(rpm)
+    torque = motor.torque(rpm)
+    case run
+    when :torque
+      count = (torque.to_f / 10).round
+      char = 'T'
+      val = torque.round.to_s.rjust(5, ' ')
+      fmt = "%s Nm"
+    when :power
+      power = DrivingPhysics.power(torque, omega)
+      kw = power.to_f / 1000
+      count = (kw / 5).round
+      char = 'P'
+      val = kw.round(1).to_s.rjust(5, ' ')
+      fmt = "%s kW"
+    else
+      raise "unknown"
+    end
+    puts format("%s RPM: #{fmt}\t%s",
+                rpm.to_s.rjust(4, ' '),
+                val,
+                char * count)
+  }
+}
+
+puts
+puts "Now, the simulation begins..."
+puts "---"
+puts "* Spin the motor up to #{motor.idle_rpm} RPM with the starter motor."
+puts "* Rev it up with the throttle."
+puts "* Let it die."
+CLI.pause
+
+alpha = 0.0
+omega = 0.0
+theta = 0.0
+
+duration = 60
+
+status = :ignition
+rpm = 0
+
+paused = 0.0
+num_ticks = duration * env.hz + 1
+start = Timer.now
+
+num_ticks.times { |i|
+  # this is an input torque; alpha is determined after inertia and friction
+  torque = case status
+           when :ignition
+             motor.starter_torque
+           when :running, :off_throttle, :idling
+             motor.torque(rpm)
+           else
+             0
+           end
+
+  # Motor#alpha incorporates inertia and friction
+  alpha = motor.alpha(torque, omega: omega)
+  omega += alpha * env.tick
+  theta += omega * env.tick
+
+  # prevent silly oscillations due to ticks or tiny floating point errors
+  omega = 0 if omega < 0.0001
+
+  net_torque = motor.implied_torque(alpha)
+  rpm = DrivingPhysics.rpm(omega)
+  power = DrivingPhysics.power(net_torque, omega)
+
+  if rpm > motor.idle_rpm and status == :ignition
+    status = :running
+    flag = true
+  end
+
+  if rpm > 7000 and status == :running
+    status = :off_throttle
+    motor.throttle = 0.0
+    flag = true
+  end
+
+  if rpm < 1000 and status == :off_throttle
+    status = :idling
+    motor.throttle = 0.06
+    flag = true
+  end
+
+  if status == :idling
+    if rpm < 999
+      motor.throttle += (1.0 - motor.throttle) * 0.005
+    elsif rpm > 1001
+      motor.throttle -= motor.throttle * 0.005
+    end
+  end
+
+  if flag or
+    (i < 10) or
+    (i < 100 and i % 10 == 0) or
+    (i < 1000 and i % 100 == 0) or
+    (i < 10_000 and i % 500 == 0) or
+    (i % 5000 == 0) or
+    (status == :idling and i % 100 == 0)
+    puts Timer.display(ms: i)
+    puts format("Throttle: %.1f%%", motor.throttle * 100)
+    puts format("%d RPM  %.1f Nm (%d Nm)  %.1f kW   Friction: %.1f Nm",
+                DrivingPhysics.rpm(omega),
+                net_torque,
+                torque,
+                power / 1000,
+                motor.spinner.rotating_friction(omega))
+    puts format("%.3f rad/s/s  %.2f rad/s  %.1f rad", alpha, omega, theta)
+    puts
+
+    paused += CLI.pause if flag
+    flag = false
+  end
+}
+
+puts Timer.summary(start, num_ticks, paused)

data/demo/mruby/disk.rb

@@ -0,0 +1,81 @@
+
+include DrivingPhysics
+
+env = Environment.new
+disk = Disk.new(env)
+
+puts env
+puts disk
+puts
+
+axle_torque = 50
+alpha = disk.alpha(axle_torque)
+drive_force = disk.force(axle_torque)
+
+puts [format("Axle torque: %.1f Nm", axle_torque),
+      format("      Alpha: %.1f rad/s/s", alpha),
+      format("Drive force: %.1f N", drive_force),
+     ].join("\n")
+puts
+
+puts "* Spin up the disk with #{axle_torque} Nm of torque"
+puts "* Cut the power at some point"
+puts "* Observe"
+CLI.pause
+
+duration = 750 # sec
+
+dist = 0.0  # meters
+speed = 0.0 # meters/s
+
+theta = 0.0 # radians
+omega = 0.0 # radians/s
+
+paused = 0.0 # seconds
+num_ticks = duration * env.hz + 1
+flag = false # to display current stats
+start = Timer.now
+
+num_ticks.times { |i|
+  # shut off the powah!
+  if i == 18_950
+    flag = true
+    puts '#'
+    puts '# CUT POWER'
+    puts '#'
+    puts
+    axle_torque = 0
+  end
+
+  rotating_friction = disk.rotating_friction(omega)
+  net_torque = axle_torque + rotating_friction
+  net_force = disk.force(net_torque)
+
+  # rotational kinematics
+  alpha = disk.alpha(net_torque)
+  omega += alpha * env.tick
+  omega = 0.0 if omega.abs < 0.0001
+  theta += omega * env.tick
+
+  if flag or i < 10 or
+    (i < 20_000 and i%1000 == 0) or
+    (i % 10_000 == 0) or
+    i == duration * env.hz - 1
+
+    puts Timer.display(ms: i)
+    puts format(" Torque: %.1f Nm (%d Nm)  Friction: %.1f Nm",
+                net_torque, axle_torque, rotating_friction)
+    puts format("Radians: %.1f r  %.2f r/s  %.3f r/s^2", theta, omega, alpha)
+    puts format("   Revs: %d revs  %d revs/s  %d rpm",
+                DrivingPhysics.revs(theta),
+                DrivingPhysics.revs(omega),
+                DrivingPhysics.rpm(omega))
+    puts
+    if flag
+      paused += CLI.pause
+      flag = false
+    end
+  end
+}
+
+puts Timer.summary(start, num_ticks, paused)