TorqueSensorModule

TorqueSensorModule is the signal-conditioning chain for a joint torque sensor. It converts raw sensor counts to engineering units, corrects the sensor’s non-linearity, removes its dominant noise frequency, and then splits the result into two signals: a slow one that is the load the joint is carrying, and a fast one that is the structure vibrating around it.

That split is the point. The two need different treatment — the load goes to a force controller, the vibration drives an active-damping correction that this block also produces.

flowchart LR
    i1(["sensorTorqueActual — raw sensor counts"]) --> B["TorqueSensorModule"]
    i2(["sensorTorqueReference — commanded torque"]) --> B
    i3(["disable"]) --> B
    B --> o1(["staticTorqueActual — the load"])
    B --> o2(["dynamicTorqueActual — the vibration"])
    B --> o3(["disturbanceCorrection — damping output"])
    B --> o4(["isEnabled"])

The chain is: counts → engineering units → non-linearity correction → notch filter → split. The static branch low-passes the result. The dynamic branch subtracts sensorTorqueReference first, then high-passes it, so it measures deviation from what was commanded. That deviation drives a controller whose smoothed output is disturbanceCorrection.

Almost everything is configured below this block, in seven sub-trees. This page’s own eight paths are the wiring; the tuning is in the sub-trees.

disturbanceCorrection reads zero until you configure the controller sub-tree. Its gains all default to zero. The two torque outputs work regardless.

Signals

Inputs

Outputs

Parameters

One parameter at this level. The configuration lives in seven sub-trees:

enable is persistent and survives a restart, as is everything in the sub-trees.

Setup

1. Set enable false. Both torque outputs still report, so the whole conditioning chain can be commissioned with nothing reaching the machine.

2. Configure transducer with your sensor’s counts-per-newton-metre. Apply a known load and confirm staticTorqueActual reads the right value in N·m.

3. Tare the sensor with no load applied. This needs an application call — there is no parameter for it. If your application does not offer one, work around it with an offset in the transducer sub-tree.

4. If the sensor is non-linear, configure polynomialCorrection. Check it against known loads across the range, not at one point.

5. Trace staticTorqueActual with the joint held still and look for a dominant noise frequency. If there is one, design a notch for it and write the coefficients into the IIRFilter sub-tree. Design them for your task rate — those coefficients are in samples, not seconds.

6. Set the split: staticTorqueFilter’s cut-off decides what counts as load, and dynamicTorqueFilter’s decides what counts as vibration. Start with both around the frequency where your structure rings.

7. Feed sensorTorqueReference from your torque command and confirm dynamicTorqueActual sits near zero while the joint tracks that command.

8. Configure the controller sub-tree. Set its output limits and integrator limits before any gain — its integrator bounds default to ±0.1, which binds almost at once.

   Step 8 is what makes the block act on the machine. Until now every output has been observation only. Set enable true last, and raise the controller’s gains from zero with the joint clear.

Tuning

1. Get the units right before anything else. If staticTorqueActual is not in real newton-metres, every downstream number is wrong.
2. Tune the notch against a measurement, not a guess. Trace the raw signal at rest, find the peak, and design for that frequency.
3. Set the split frequency from the structure, not from feel. Below your structure’s ringing frequency is load; above it is vibration. If the two overlap, this block cannot separate them.
4. Check the split works: apply a steady load and confirm it appears on staticTorqueActual and not on dynamicTorqueActual. Then excite the structure and confirm the reverse.
5. Tune the controller last, and as a controller — set its output limits and integrator limits first, then raise the proportional gain until the ringing is damped, then back off.
6. Watch disturbanceCorrection on a trace while you do it. If it saturates or sits pinned, the controller’s integrator limits are too tight.
7. Re-check the notch coefficients after any task-rate change. They are defined in samples, so the same coefficients are a different filter at a different rate.

Read the split off the two curves: the load appears on one and the ringing on the other.

A starting point for a joint whose structure rings near 25 Hz on a 1 ms task, with the correction path not yet active:

enable = false
transducer:          configure counts per Nm for your sensor
polynomialCorrection: leave at its pass-through default at first
IIRFilter:           leave as pass-through until a noise peak is measured
staticTorqueFilter:  omega = 63.0     (10 Hz)
dynamicTorqueFilter: omega = 157.0    (25 Hz), beta = 1.0
controller:          kp = 0, ki = 0, kd = 0, output limits set first

Then work Setup step 8. This is a starting point, not a final tuning.

Limits and errors

The block raises no errors or warnings and logs nothing. Every failure above shows as a value on a trace, not as a message.

Verified against motorcortex-control3 3.30.0 (bc348fd).