As you guessed, the problem is that you are creating a new debounced function every time the component is rendered. The multiple debounced functions are unaware of each other's timeouts. If we omit the other code for clarity, the problem is relatively easy to see:

// This function is called on every render
const SensorMeasurements: React.FC = () => {
    //.....

    const setOptionsHandler = // ...

    // This constant is recreated on every invocation of SensorMeasurements
    const setOptionsHandlerThrottled = _.debounce(setOptionsHandler, 5000, true);

    return (
        // The onIonChange event handler is unique on each render
        <IonSegment onIonChange={e => setOptionsHandlerThrottled(e.detail.value as string, "Trigger", "statusSensorHighTrigger")} className="lowercase" color="brand" value={settingsHandler("statusSensorHighTrigger")}>
            <IonSegmentButton value="false">
                <IonLabel>Low</IonLabel>
            </IonSegmentButton>
            <IonSegmentButton value="true">
                <IonLabel>High</IonLabel>
            </IonSegmentButton>
        </IonSegment>
    );
}

The simple solution is to use a class component instead. By creating the debounced function in the constructor, it can be retained between renderings. Most other functions can be free-standing at module scope, since they do not depend on component state.
Do note that if the instance of the component is replaced as a whole (for example because a containing component is re-rendered), the timeout will still be reset. In that case, you might need to lift the debounced function into the larger component.

// Module scope, not inside component

const setOptionsHandler = (value: string, option: string, key: string) => {
    // Same as before
}

const setControlHandler = async (input: string, notify?: boolean) => {
    // Same as before
}

const settingsHandler = (string: string) => {
    // Same as before
}

const trueOrFalse = (array: string[], string: string) => {
    // Same as before
}

// Class component

class SensorMeasurements extends React.Component {
    setOptionsHandlerThrottled: typeof setOptionsHandler;

    constructor() {
        // This debounced function persists throughout the lifetime of the component
        this.setOptionsHandlerThrottled = _.debounce(setOptionsHandler, 5000, true);
    }

    render() {
        return (
            <IonSegment onIonChange={e => this.setOptionsHandlerThrottled(e.detail.value as string, "Trigger", "statusSensorHighTrigger")} className="lowercase" color="brand" value={settingsHandler("statusSensorHighTrigger")}>
                <IonSegmentButton value="false">
                    <IonLabel>Low</IonLabel>
                </IonSegmentButton>
                <IonSegmentButton value="true">
                    <IonLabel>High</IonLabel>
                </IonSegmentButton>
            </IonSegment>
        );
    }
}

export default SensorMeasurements;

A possible alternative to using _.debounce would be to use the debounce operator from RxJS. In that case, a similar consideration would apply that you might need to lift the subject to a larger containing component.
In the comments, you stated that the problem went away when you removed the async / await syntax from the setControlHandler function. I cannot explain this; with your original code, you will create a new debounced function on each render regardless. I suspect some other, unrelated bug is preventing the event handler from triggering again in that case.
As an encore, I would like to show you a cleaner way to write your setControlHandler function:

// The mapping from inputs to sysCommands is entirely static, so you can
// define it in advance.
const inputCommand = {
    Reset: 'R',
    Test: 'T',
    Calibration: 'B',
    Logging: 'L',
    Trigger: 'H',
    Measuring: 'M',
    Unit: 'U',
};

const setControlHandler = async (input: string, notify?: boolean) => {
    // Replacing your switch pyramid by a property lookup
    const sysCommand = inputCommand[input];
    // Remainder as before
}

最后，我最终使用了AwesomeDebouncePromise，因为这是最好的。为了防止每次重新渲染都创建一个新的Debounced函数，我将debounced函数 Package 在一个useMemo中。

const setOptionsHandlerThrottled = useMemo( () => AwesomeDebouncePromise(setOptionsHandler, 3000), [iTrueStates] );