driving_physics 0.0.1.2 → 0.0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef486c39982798a7331f49f601e648d520a65977161180631cc4c5d3340a9011
-  data.tar.gz: 9e30b74ae34cb77a711d5d9631983b0c070872900123a1dde2d3dd03bdab854b
+  metadata.gz: 9b9159b499a0082d5af3ef926fceab925572552978b50d020b71bc51df7506fb
+  data.tar.gz: 183eaae3e07e24f38bb1417d96a6310eebfd288a1300d4e8bab96f008abbf3e5
 SHA512:
-  metadata.gz: 46eaf512dad64ca39ec20451d7acce1b1819ecd64125ee858f92c26e5edd7b0ec0e7ef01af8f73daa0d37868e0ffd76bd3b29478093219cd906d8d9e38026bcd
-  data.tar.gz: ae2e01ae8e7986c9d2e659ff5a0934ed5359e20cf2757d7724118bb59e0fb0199180249815f2f28f55f48a2336511a0b43f0d6fab042ed5d20a5ab6a897baef1
+  metadata.gz: 9a19ba4646abe21f30ca12c88f43e9ddc7083028e96504260f0277b167af5374364967b1617ab83744f824d6d2aa513ef38627d23ad5e9ccc8ff7e017b8a2ac8
+  data.tar.gz: 5357970cd547b12727bfc20c408df27a07d3aaac5d5b9042cbb10fc98c85484eb7bf054e140158f7e8695ef6c30eb18961fdd6979b4d0e3ab6c343f7767fc296

data/README.md

@@ -10,14 +10,36 @@ using `Vector` class from `matrix.rb` in stdlib.
 
 This is very much a **Work In Progress**.  Implemented so far:
 
+### Library Features
+
 * Spinning: rotational inertia and friction / hysteresis
-* Tires: traction force via friction and the normal force
+* 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"
+* Variable clutch and throttle
+* Engine braking
+* Power and Energy
+
+### mruby Support
+
+This library is primarily a Ruby library, intended for use with CRuby (MRI),
+JRuby, etc.  **mruby** is the redheaded stepchild, with significant
+implications for a codebase that wants to support both sides.  Supporting
+mruby here meant:
+
+1. Editing the codebase (minimally) to avoid and 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.
 
 ## 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[cli environment imperial power timer
+     disk tire motor gearbox powertrain car pid_controller].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 pid_controller].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.1.2
+0.0.3.1

data/demo/car.rb

@@ -1,4 +1,5 @@
 require 'driving_physics/car'
+require 'driving_physics/cockpit'
 require 'driving_physics/imperial'
 require 'driving_physics/cli'
 
@@ -10,13 +11,16 @@ puts env
 tire = Tire.new(env)
 motor = Motor.new(env)
 gearbox = Gearbox.new(env)
-powertrain = Powertrain.new(motor, gearbox)
+powertrain = Powertrain.new(motor: motor, gearbox: 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
+
+cockpit = Cockpit.new(car)
+puts cockpit
 CLI.pause
 
 duration = 120
@@ -31,16 +35,20 @@ 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
+rev_match = :ok
 phase = :ignition
+gearbox.clutch = 0.0 # clutch in to fire up motor
 flag = false
-rpm = 0
+
+rpm, crank_torque = 0, 0
+axle_torque, drive_force, net_force = 0, 0, 0
+ar, rr, rf, ir = 0, 0, 0, 0
+
 puts <<EOF
 
 #
@@ -51,24 +59,15 @@ 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(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
+    if rpm > motor.idle
+      flag = true
+      cockpit.gear = 1
+      cockpit.throttle_pedal = 1.0
       phase = :running
 
       puts <<EOF
@@ -79,23 +78,19 @@ num_ticks.times { |i|
 
 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
-
+  elsif phase == :running or phase == :off_throttle
     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
+    drive_force = car.drive_force(rpm, axle_omega: tire_omega)
+    net_force = drive_force + ar + rr + rf
 
-    ir = car.tire_inertial_force(force)
-    force += ir
+    ir = car.tire_inertial_force(net_force)
+    net_force += ir
 
-    acc = DrivingPhysics.acc(force, car.total_mass)
+    acc = DrivingPhysics.acc(net_force, car.total_mass)
     speed += acc * env.tick
     dist += speed * env.tick
 
@@ -105,71 +100,89 @@ EOF
 
     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(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)
+    new_rpm = gearbox.crank_rpm(tire_omega, crank_rpm: rpm)
+    new_rev_match, clutch, proportion = Cockpit.rev_match(rpm, new_rpm)
 
-    if new_clutch != clutch
+    if new_rev_match != rev_match
       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
+      puts format("Rev Match: [%s] %d RPM is %.1f%% from %d RPM",
+                  new_rev_match, new_rpm, proportion * 100, rpm)
+      # puts format("Recommend clutch to %.1f%%", clutch * 100)
+      rev_match = new_rev_match
     end
 
-    case new_clutch
-    when :ok
-      rpm = new_rpm
-    when :mismatch
+    clutch_diff = clutch - gearbox.clutch
+    if clutch_diff.abs > 0.1
       flag = true
-      puts '#'
-      puts '# LURCH!'
-      puts '#'
-      puts
-      rpm = new_rpm
+      puts format("Clutch: %.1f%%  Recommended Clutch: %.1f%%",
+                  gearbox.clutch * 100, clutch * 100)
     end
-    next_gear = car.powertrain.gearbox.next_gear(rpm)
-    if next_gear != gearbox.gear
+    # the clutch pedal will reflect this change
+    gearbox.clutch += clutch_diff * 0.5
+
+    # update the motor RPM based on new clutch
+    new_rpm = gearbox.crank_rpm(tire_omega, crank_rpm: rpm)
+    rpm = new_rpm if new_rpm > motor.idle
+
+    new_gear = cockpit.choose_gear(rpm)
+    if new_gear != cockpit.gear
+      flag = true
+      puts "Gear Change: #{new_gear}"
+      cockpit.gear = new_gear
+    end
+
+    # cut throttle after 60 s
+    if i > 60 * env.hz and car.throttle == 1.0
       flag = true
-      puts "Gear Change: #{next_gear}"
-      car.gear = next_gear
-      paused += CLI.pause
+      phase = :off_throttle
+      cockpit.throttle_pedal = 0
     end
 
     # maintain idle when revs drop
-    if car.throttle == 0 and rpm < motor.idle_rpm
+    if cockpit.throttle_pedal == 0 and rpm < motor.idle
       phase = :idling
       car.gear = 0
-      paused += CLI.pause
     end
 
+    print "===\n\n" if flag
 
   elsif phase == :idling
-    # fake
-    rpm = motor.idle_rpm
+    # fake; exit
+    rpm = motor.idle
     break
   end
+
+  if flag or (i < 5000 and i % 100 == 0) or (i % 1000 == 0)
+    puts Timer.display(ms: i)
+    puts format("  Phase: %s", phase)
+    puts format("   Tire: %.3f r/s/s  %.2f r/s  %.1f r",
+                tire_alpha, tire_omega, tire_theta)
+    puts format("    Car: %.3f m/s/s  %.2f m/s  %.1f m  (%.1f MPH)",
+                acc, speed, dist, Imperial.mph(speed))
+    if phase == :ignition
+      puts format("  Motor: %d RPM  Starter: %d Nm  Friction: %.1f Nm",
+                  rpm, motor.starter_torque, motor.friction(crank_omega))
+    else
+      crank_torque = car.powertrain.motor.torque(rpm)
+      puts format("  Motor: %d RPM  %.1f Nm  Friction: %.1f Nm",
+                  rpm, crank_torque, motor.friction(crank_omega))
+    end
+    puts format("Gearbox: %s", gearbox.inputs)
+    if phase != :ignition
+      axle_torque = car.powertrain.axle_torque(rpm, axle_omega: tire_omega)
+      puts format("   Axle: %.1f Nm (%d N)  Net Force: %.1f N",
+                  axle_torque, drive_force, net_force)
+    end
+    puts        " Resist: " + format(%w[Air Roll Spin Inertial].map { |s|
+                                       "#{s}: %.1f N"
+                                     }.join('  '), ar, rr, rf, ir)
+    puts        cockpit
+    puts
+    paused += CLI.pause if flag
+    flag = false
+  end
 }
 
 puts Timer.summary(start, num_ticks, paused)

data/demo/gearbox.rb

@@ -21,10 +21,11 @@ alpha = 0.0
 omega = 0.0
 theta = 0.0
 
+num_ticks = duration * env.hz + 1
 start = Timer.now
-paused = 0
+paused = 0.0
 
-(duration * env.hz + 1).times { |i|
+num_ticks.times { |i|
   # just for info, not used in the simulation
   friction = gearbox.spinner.rotating_friction(omega)
 
@@ -41,7 +42,7 @@ paused = 0
     (i < 100 and i % 10 == 0) or
     (i < 1000 and i % 100 == 0) or
     i % 1000 == 0
-    puts Timer.display(i)
+    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)

data/demo/motor.rb

@@ -48,7 +48,7 @@ motor.throttle = 1.0
 puts
 puts "Now, the simulation begins..."
 puts "---"
-puts "* Spin the motor up to #{motor.idle_rpm} RPM with the starter motor."
+puts "* Spin the motor up to #{motor.idle} RPM with the starter motor."
 puts "* Rev it up with the throttle."
 puts "* Let it die."
 CLI.pause
@@ -82,15 +82,14 @@ num_ticks.times { |i|
   omega += alpha * env.tick
   theta += omega * env.tick
 
-  net_torque = motor.implied_torque(alpha)
+  # prevent silly oscillations due to ticks or tiny floating point errors
+  omega = 0 if omega < 0.0001
 
-  # prevent silly oscillations due to tiny floating point errors
-  omega = 0 if omega < 0.00001
+  net_torque = motor.implied_torque(alpha)
   rpm = DrivingPhysics.rpm(omega)
-
   power = DrivingPhysics.power(net_torque, omega)
 
-  if rpm > motor.idle_rpm and status == :ignition
+  if rpm > motor.idle and status == :ignition
     status = :running
     flag = true
   end
@@ -107,10 +106,13 @@ num_ticks.times { |i|
     flag = true
   end
 
+  # we don't need no PID control
   if status == :idling
-    if rpm < 999
+    if rpm.round <= 999
       motor.throttle += (1.0 - motor.throttle) * 0.005
-    elsif rpm > 1001
+    elsif rpm.round == 1000
+      motor.throttle += (rand - 0.5) * 0.0005
+    else
       motor.throttle -= motor.throttle * 0.005
     end
   end
@@ -122,7 +124,7 @@ num_ticks.times { |i|
     (i < 10_000 and i % 500 == 0) or
     (i % 5000 == 0) or
     (status == :idling and i % 100 == 0)
-    puts Timer.display(i)
+    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),
@@ -130,7 +132,7 @@ num_ticks.times { |i|
                 torque,
                 power / 1000,
                 motor.spinner.rotating_friction(omega))
-    puts format("%d rad  %.1f rad/s  %.1f rad/s/s", theta, omega, alpha)
+    puts format("%.3f rad/s/s  %.2f rad/s  %.1f rad", alpha, omega, theta)
     puts
 
     paused += CLI.pause if flag

data/demo/mruby/car.rb

@@ -0,0 +1,184 @@
+
+include DrivingPhysics
+
+env = Environment.new
+puts env
+
+tire = Tire.new(env)
+motor = Motor.new(env)
+gearbox = Gearbox.new(env)
+powertrain = Powertrain.new(motor: motor, gearbox: 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
+
+cockpit = Cockpit.new(car)
+puts cockpit
+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
+
+start = Timer.now
+paused = 0.0
+num_ticks = duration * env.hz + 1
+
+rev_match = :ok
+phase = :ignition
+gearbox.clutch = 0.0 # clutch in to fire up motor
+flag = false
+
+rpm, crank_torque = 0, 0
+axle_torque, drive_force, net_force = 0, 0, 0
+ar, rr, rf, ir = 0, 0, 0, 0
+
+puts <<EOF
+
+#
+# IGNITION
+#
+
+EOF
+
+num_ticks.times { |i|
+  if phase == :ignition
+    crank_alpha = motor.alpha(motor.starter_torque, omega: crank_omega)
+    crank_omega += crank_alpha * env.tick
+
+    rpm = DrivingPhysics.rpm(crank_omega)
+
+    if rpm > motor.idle
+      flag = true
+      cockpit.gear = 1
+      cockpit.throttle_pedal = 1.0
+      phase = :running
+
+      puts <<EOF
+
+#
+# RUNNING
+#
+
+EOF
+    end
+  elsif phase == :running or phase == :off_throttle
+    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
+    drive_force = car.drive_force(rpm, axle_omega: tire_omega)
+    net_force = drive_force + ar + rr + rf
+
+    ir = car.tire_inertial_force(net_force)
+    net_force += ir
+
+    acc = DrivingPhysics.acc(net_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
+
+    # tire_omega determines new rpm
+    new_rpm = gearbox.crank_rpm(tire_omega, crank_rpm: rpm)
+    new_rev_match, clutch, proportion = Cockpit.rev_match(rpm, new_rpm)
+
+    if new_rev_match != rev_match
+      flag = true
+      puts format("Rev Match: [%s] %d RPM is %.1f%% from %d RPM",
+                  new_rev_match, new_rpm, proportion * 100, rpm)
+      # puts format("Recommend clutch to %.1f%%", clutch * 100)
+      rev_match = new_rev_match
+    end
+
+    clutch_diff = clutch - gearbox.clutch
+    if clutch_diff.abs > 0.1
+      flag = true
+      puts format("Clutch: %.1f%%  Recommended Clutch: %.1f%%",
+                  gearbox.clutch * 100, clutch * 100)
+    end
+    # the clutch pedal will reflect this change
+    gearbox.clutch += clutch_diff * 0.5
+
+    # update the motor RPM based on new clutch
+    new_rpm = gearbox.crank_rpm(tire_omega, crank_rpm: rpm)
+    rpm = new_rpm if new_rpm > motor.idle
+
+    new_gear = cockpit.choose_gear(rpm)
+    if new_gear != cockpit.gear
+      flag = true
+      puts "Gear Change: #{new_gear}"
+      cockpit.gear = new_gear
+    end
+
+    # cut throttle after 60 s
+    if i > 60 * env.hz and car.throttle == 1.0
+      flag = true
+      phase = :off_throttle
+      cockpit.throttle_pedal = 0
+    end
+
+    # maintain idle when revs drop
+    if cockpit.throttle_pedal == 0 and rpm < motor.idle
+      phase = :idling
+      car.gear = 0
+    end
+
+    print "===\n\n" if flag
+
+  elsif phase == :idling
+    # fake; exit
+    rpm = motor.idle
+    break
+  end
+
+  if flag or (i < 5000 and i % 100 == 0) or (i % 1000 == 0)
+    puts Timer.display(ms: i)
+    puts format("  Phase: %s", phase)
+    puts format("   Tire: %.3f r/s/s  %.2f r/s  %.1f r",
+                tire_alpha, tire_omega, tire_theta)
+    puts format("    Car: %.3f m/s/s  %.2f m/s  %.1f m  (%.1f MPH)",
+                acc, speed, dist, Imperial.mph(speed))
+    if phase == :ignition
+      puts format("  Motor: %d RPM  Starter: %d Nm  Friction: %.1f Nm",
+                  rpm, motor.starter_torque, motor.friction(crank_omega))
+    else
+      crank_torque = car.powertrain.motor.torque(rpm)
+      puts format("  Motor: %d RPM  %.1f Nm  Friction: %.1f Nm",
+                  rpm, crank_torque, motor.friction(crank_omega))
+    end
+    puts format("Gearbox: %s", gearbox.inputs)
+    if phase != :ignition
+      axle_torque = car.powertrain.axle_torque(rpm, axle_omega: tire_omega)
+      puts format("   Axle: %.1f Nm (%d N)  Net Force: %.1f N",
+                  axle_torque, drive_force, net_force)
+    end
+    puts        " Resist: " + format(%w[Air Roll Spin Inertial].map { |s|
+                                       "#{s}: %.1f N"
+                                     }.join('  '), ar, rr, rf, ir)
+    puts        cockpit
+    puts
+    paused += CLI.pause if flag
+    flag = false
+  end
+}
+
+puts Timer.summary(start, num_ticks, paused)