Creating a ticker thread - version 2
Here are some things that may help you further improve your code.

Clearly separate interface and implementation

The Ticker.hpp includes two headers, ipc/Client.hpp and ipc/Message.hpp which are not actually part of the interface.  They're part of the implementation and so those #includes should be moved to the .cpp file instead.

Don't throw an exception from a destructor

A destructor really really shouldn't throw an exception, but yours might.  Consider this simple main():  

int main() {
    sdp::Ticker t(1);
    t.stop();
}


This will throw an error because stop attempts to set the done_promise value and then the destructor calls stop and attempts to set it again.  That second attempt is guaranteed to throw an error.  

Set an exception in the promise

It seems likely that your code for constructing and sending a message could throw an exception.  If they do, the program will seem to silently fail.  Consider using std::promise::set_exception to propagate the error out to the caller so that it could be handled.  

In particular, the code for tickfunction might include something like this:

    try { 
        throw runtime_error("aaaah!");
    } catch (...) {
        valuePosted = true;
        throw;
    }


The calling function could then include something like this:

try {
    t.get();
} catch (std::exception &amp;err) {
    std::cout &lt;&lt; err.what() &lt;&lt; '\n';
}


This allows you to catch an exception that might have been thrown within the spawned thread.

Consider making the class generic

One can easily imagine that doing something on a regular basis (i.e. every x seconds) might be useful beyond this singular usage.  For that reason, it might be useful to think about either passing a void function into the constructor or creating a template that uses a Callable type for later invocation.