Thank you for your helpful reply! Unfortunately, changing the library the way you suggested does not seem to work quite as expected. Now, nothing happens with a short press.

Hi again

It still does not work, but I think I'm getting there.

The problem with the code you suggested, is that _samplesTillHeld is defined as 0 (false) at the top.

Thus if (_samplesTillHeld) statement is never true, which is why no short press can ever be recognized.

I tried this instead, but it still does not work.

The idea is that the reloading of _sampleTillHeld only happens when an asserted press is performed and that the deasserted press only can occur if _sampleTillHeld is true (above zero, e.i. haven't been held for 2 seconds)

void isr(void) {
        int currentState = _in->read();
    
        if ( currentState != _prevState ) { // only runs when change occur (switch)
            if ( _samplesTillAssert == 0 ) {
                _prevState = currentState;
                if ( currentState == _assertValue ){ 
                    _callbackAsserted.call();
                    _samplesTillHeld = _samplesTillHeldReload;       // reload held samples only when asserted press
                }
                if ( currentState != _assertValue && _samplesTillHeld ){    // _samplesTillHeld moved here                          
                    _callbackDeasserted.call();
                }
            }
            else {
                _samplesTillAssert--;
            }
        }
        else {
            _samplesTillAssert = _samplesTillAssertReload;
        }

        if ( _samplesTillHeld ) {
            if ( _prevState == currentState ) {
                _samplesTillHeld--;
                if ( _samplesTillHeld == 0 ) {
                    if ( currentState == _assertValue ) 
                        _callbackAssertedHeld.call();
                    else                              
                        _callbackDeassertedHeld.call();
                }
            }
            else {
                _samplesTillHeld = 0;
            }
        }
    }

I'm not entirely sure why the posted change didn't work.

_samplesTillHeld should be 0 normally since the button has been deasserted for more than the hold period. When the button is first pressed no asserted callback will be generated and _samplesTillHeld will be set to the timeout vale.

_samplesTillHeld then counts down. If the button is released before _samplesTillHeld reaches 0 the deasserted callback should be triggered. If the counter reaches 0 the asserted held callback is triggered and the next deasserted callback won't be generated.

Personally I would have said it would be far easier and cleaner to fix it in your code. Set a flag in sw2TransceiveMode_held, in sw2Frequency check the flag, if it's set then clear it and exit otherwise carry on as normal. I make that a total of 5 lines of code.

Thank you for your help - definitely guided me in the right direction! I found a solution by modifying the library as you suggested. I believe it to be the best way to modify the library to operate in a way that I find intuitive (that is, do one thing on a short press, do another on a long press - to me this means "two buttons in one"). I always prefer not to have too many "Flag hacks" in my main code just to make it more readable.

EDIT: Mmm.. still not working as I want actually. Back to the drawing board.

EDIT EDIT: Oh well, this is becoming confusing, I made a simple mistake in my callback function, but, it actually works with the code I posted as a comment to my own question.