Operating principle

My first indoor training sessions brought to me the observation/hypothesis that there is a unique relationship between speed and the power needed to hold that speed constant. So my first thoughts were:

1. To mount a classic speed sensor to my rear wheel in order to measure speed. This way I could guess my training zones based on speed instead of power.
2. To put a stroboscope onto the flywheel with patterns for two or three target speeds.

The obvious problem with the two approaches emerged immediately: The relationship between power and speed is most probably nonlinear, therefore the usual setup of training zones in terms of speed wouldn't be straightforward. So although it would be possible to use speed as a measure of training intensity, it would basically require to measure the speed-power relationship. Some resources are already available for that. PowerCurve offers a sensor that turns basic indoor trainer to a power based one [PCS]. A reference to PowerCurve together with additional insight and problems of this approach are given in an answer at stackexchange [SX]. Vpower converts the output of a speed sensor into power and sends it using ANT+ to your head-unit [VPOWER].

My understanding of the above solutions is, however, that they only use the quasi-static speed-power relationship (it is explicitly stated in [VPOWER], but I only guess in the case of [PCS]). Considering the dynamic effects (inertia of the trainer+bike system) not only makes the measurement more accurate, especially in the case of short intervals or other speed changes, but also enables easy calibration. The governing equation of the quasi-static case is simply

where P is power and v stands for speed, i.e. power is a function of speed. With the consideration of inertia, one can use the motion equation (using generalized coordinates)

where F is the generalized force acting on the system, m is the reduced mass (inertia of the traner+bike system), a stands for acceleration, and F_T is the generalized force-speed function. The quasi-static case may be obtained assuming a = 0:

It is however necessary, to determine speed and acceleration in order to employ the above stated equation. I used an optical gate to measure time between light pulses.

Electronics

I bought an LTH 301-07 opto-gate and built a circuit based on the information at [MCE]. There I found a working scheme and resistance values for use with an Arduino board. I used a Raspberry Pi, since I had two of them lying round, and its GPIO pins for connecting the circuit (namely the 3V3 pin, Ground pin, and ce1 pin (#17), see [GPIO]).

I did the initial testing using a breadboard. However, the cables came loose during harder riding, so I soldered the circuit using a universal circuit board.

Software

Python showed to be a viable solution together with the pigpio library [pigpio]. Registering the pulses and saving the data is done using a callback function:

import pigpio

last = [None]
cb = [None]

def get_cbf(file_name):
    def _cbf(gpio, level, tick):
        if last[0] is not None:
            diff = pigpio.tickDiff(last[0], tick)
            print(f'G={gpio} l={level} d={diff}')
            with open(file_name, 'ab') as tf:
                tf.write(struct.pack('d', diff)
        last[0] = tick

    return _cbf

def main(pin=17, filename='time_deltas.dat'):
    pi = pigpio.pi()

    if not pi.connected():
        exit()

    cb[0] = pi.callback(pin, pigpio.RISING_EDGE, get_cbf(filename))

    try:
        while True:
            time.sleep(.1)
    except KeyboardInterrupt:
        print('\nTidying up')
        for c in cb:
            c.cancel()

    pi.stop()

The struct module from the standard python library is used in order to keep the size of data files minimal. This way, each time-delta measurement only takes 8 bytes.

Reading from the file is done similiarly:

with open(file_name, 'rb') as tf:
    dts = tf.read()

time_deltas = struct.unpack(
    'd' * (len(dts) // struct.calcsize('d')), dts)

NOTE: The above code shows the basic principle, the actual code includes power calculation and bluetooth communication.

def get_speed_and_acceleration_avg(
        time_deltas,
        speed_const = .139 / 2,
):
    speeds = speed_const / time_deltas
    accs = (speeds[2:] - speeds[:-2]) / (
        time_deltas[2:] + time_deltas[:-2])
    avg_speed = np.mean(speeds)
    avg_acc = np.mean(accs)
    return avg_speed, avg_acc

FTM_COEFS = [-5.17781e-3, .38950767, .71346973, -.71051168]
REDUCED_MASS = 7.5
def default_resistance(speed):
    """speed in [m/s]"""
    return np.polyval(FTM_COEFS, speed) * REDUCED_MASS

def get_power(
        speed, acceleration,
        resistance_function=default_resistance,
        mass=REDUCED_MASS,
):
    return resistance_function(speed) + mass * acceleration * speed

Enclosure

The housing for the electronics is 3D printed (but a piece of wood/plastic/... would also do the job) and mounted to the body of the trainer using zip ties. Its main design objectives were to stay in place and to hold the opto-gate close to the trainer's flywheel. A rotor is glued to the flywheel so that it periodically blocks or opens the opto-coupler.

The speed sensor, mounted on the trainer.

References

Appendix 1

Assuming F = 0, the motion equation becomes

Assuming non-zero reduced mass m, one can rearrange the terms and divide by m to obtain

Appendix 2

Accelerating the system by means of a known weight m₁ pulled by gravity (g = 9.81  N ⁄ kg), the motion equation changes to

Rearranging the terms and dividing by m:

This step is performed in order to obtain the known quantity F_T ⁄ m. From the above equation, m is expressed as