# Simulating a Flywheel part 1: overview and simulating a motor

Well, the off-season of FIRST Robotics is upon us. A time when young people’s minds turn away from robots and towards other things. Like simulating robots!

To give the team something to play with on the software side, I’m putting together a couple of simulators of robot subsystems to experiment with. The first one is a simple flywheel connected to one motor and encoder.

I’m going to break the discussion of how I did this into two parts. Here, I’ll go over the top-level architecture of the program and how it tries to simulate, and talk about the equations to simulate a DC electric motor. In a follow-up post, I’ll go over the physics of friction simulation.

Full disclosure: I’m a rank amateur at this, putting together half-remembered high school physics, a barely-used robotics minor, and some hazy memories of graphs from my first years playing FIRST Robotics. Definitely room for improvement, and I welcome feedback on this.

You can get the simulator from the GitHub repsitory.

# Overview

## Program structure

The program is a simple `TimedRobot`

operating at the default frequency of 50
times a second. It includes one automatically-running `Flywheel`

subsystem that
lets a motor be turned on and off (at max power or 0 power), which is controlled
by a single joystick button.

In addition to `Flywheel`

, a `SimulatedFlywheel`

class is constructed if the
robot is operating in simulation mode. This class takes in the motor from the
`Flywheel`

and a simulation wrapper around the encoder, allowing us to
explicitly set the encoder’s position and velocity values.

## The simulation

At a high level of abstraction, the torque on a motor-driven flywheel at any moment is simple:

Once we have calculated this torque, we can update the flywheel’s angular
velocity by adding `total torque / moment of inertia`

to the flywheel’s previous
velocity. Then we update the flywheel’s position as well (accounting, in both
cases, for the step of time over which this change is occurring, in our case
20ms between updates).

That’s the high-level approach; let’s drill down on the details.

# Simulating motors

A DC motor is a relatively simple system, but it has a bit of complexity making simulating one interesting.

The basic principle by which a DC motor operates is that half of the motor uses electromagnets, while the other
half uses permanent magnets. Varying the current through the motor’s electromagnets creates moving magnetic
fields that the permanent magnets then “chase,” turning electricity into motion. The highest torque such a motor
can give is when it’s “stalled” (i.e. not moving) and the voltage across it is maximized. At this configuration,
the motor is pushing with its “stall torque” (*note*: It’s generally a bad idea to leave a motor stalled like this;
many DC motors aren’t designed to run current through with no motion, and doing so for long periods of time can
heat up and damage components).

So the total torque a motor can give is equal to some constant times the current through the motor:

Where I is current through the motor and k_{M} is a torque
constant. *Note*: equations for motor behavior are mostly sourced from
here. We
can quickly calculate k_{M} as just the stall torque divided by the
current, but for the purposes of the simulation i find it easier to just consider a relationship between
stall torque and voltage by subsituting current through `V = IR`

, then considering the motor with 12 volts
across it and finding the value of a constant `q`

which is resistance divided by K_{M}:

What’s interesting about electric motors is that when I say “some loops of wire acting as electromagnets near some
permanent magnets,” I’m also describing a type of generator. And indeed, a spinning electric motor tries to induce
a current in the direction opposite the spin! This opposing force, known as “back-EMF” (EMF: electromotive force),
creates a counter-voltage to the voltage across the motor, resulting in a drop in current through the circuit.
The physics of why this happens can be a little confusing, but there’s (I think) an elegant way to remember it:
the fact that motors have back-EMF sort of falls naturally out of conservation of energy once we remember
that motors with a voltage across them don’t spin up to infinite speed. Since a motor spinning at top speed
only needs a little bit of energy to overcome resistance and maintain that speed, and since energy lost
across a component of a circuit is the power (`P=IV`

), we know that when the motor is spinning near top speed,
P across the motor must be small to keep it spinning, so current and/or voltage diminished.

The back-EMF on the motor is proportional to the motor’s rotational speed and some back-EMF constant k_{e}.

```
voltage = rotational speed * back-EMF constant
```

A motor allowed to spin up to full speed under no load and with maximum voltage across it will spin at a “free speed” which varies from motor to motor. At free speed, the back-EMF is approximately equal to the forward voltage, so we can set the voltage and speed in the above equation and re-arrange to solve for the back-EMF constant:

We’re closing in on simulating the torque. The remaining ingredient is the full torque equation.

To approach the final torque equation, we start by considering that the total voltage across the motor is
the `V=IR`

relationship through the motor plus the back-EMF value.

Substituting in the relationship between torque and current, we find

Now we have voltage, motor speed, and motor torque related. Doing the algebra to make torque the dependent variable and
substituting our `q`

constant for resistance divided by k_{M}, we get:

That gives us the motor torque in almost all circumstances, save one: what happens when the voltage is set to zero?

## Brake or coast?

It’s a subtle bit of architecture, but an important one: as we’ve established, a motor acts like a generator. So what happens when the motor should be applying no power?

Motor controllers used in the FIRST Robotics competition are generally configurable to “brake” or “coast” mode. In “brake” mode, the controller short-circuits the motor to itself, allowing the back-EMF to try and drive the motor in reverse. This will resist motion in the motor and drag it to a halt much quicker. The mathematics of this is, honestly, something I don’t know.

“Coast” mode is much easier to model: in “coast” mode, the controller opens the circuit. With no ability for electricity to flow from one end of the motor to the other, the motor basically contributes no torque and the flywheel will spin down normally. So we special-case the zero-voltage condition to eliminate the motor torque, simulating “coast mode.”

# Next steps

This gives us half the flywheel simulation. Next time, we’ll talk about the friction counter-torque (and how annoying friction subtleties are!) and tie it all together with the acceleration and velocity-update logic.

## Comments