Client.hpp

Go to the documentation of this file.

#ifndef CLIENT_HPP
#define CLIENT_HPP

#include <string>
#include <asio.hpp>
#include <thread>
#include <condition_variable>
#include <map>

#include "types.hpp"

namespace msp {

class PeriodicTimer {
public:
    typedef unsigned int uint;

    PeriodicTimer(const std::function<void()> funct, const double period_seconds);

    void start();

    void stop();

    double getPeriod() {
        return period_us.count()/1.e6;
    }

    void setPeriod(const double period_seconds);

private:
    std::shared_ptr<std::thread> thread_ptr;
    std::function<void()> funct;
    std::chrono::duration<uint, std::micro> period_us;
    bool running;
};

} // namespace msp

namespace msp {
namespace client {

class SubscriptionBase {
public:
    SubscriptionBase(PeriodicTimer *timer=NULL) : timer(timer) { }

    virtual ~SubscriptionBase() {
        if(timer!=NULL) { delete timer; }
    }

    virtual void call(const msp::Request &req) = 0;

    bool hasTimer() {
        // subscription with manual sending of requests
        return !(timer->getPeriod()>0);
    }

    void setTimerPeriod(const double period_seconds) {
        timer->setPeriod(period_seconds);
    }

    void setTimerFrequency(const double rate_hz) {
        timer->setPeriod(1.0/rate_hz);
    }

protected:
    PeriodicTimer *timer;
};

template<typename T, typename C>
class Subscription : public SubscriptionBase {
public:
    typedef void(C::*Callback)(const T&);

    Subscription(const Callback caller, C *const context_class)
        : funct(caller), context(context_class) {
    }

    Subscription(const Callback caller, C *const context_class, PeriodicTimer *timer)
        : SubscriptionBase(timer), funct(caller), context(context_class)
    {
        this->timer->start();
    }

    void call(const msp::Request &req) {
        (*context.*funct)( dynamic_cast<const T&>(req) );
    }

private:
    Callback funct;
    C *const context;
};

enum MessageStatus {
    OK,         // no errors
    FAIL_ID,    // message ID is unknown
    FAIL_CRC    // wrong CRC
};

struct ReceivedMessage {
    uint8_t id;
    std::vector<uint8_t> data;
    MessageStatus status;
};

class Client {
public:
    Client();

    ~Client();

    void setPrintWarnings(const bool warnings) {
        print_warnings = warnings;
    }

    void connect(const std::string &device, const uint baudrate=115200);

    void waitForOneMessage();

    void waitForOneMessageBlock();

    void start();

    void stop();

    uint8_t read();

    bool sendData(const uint8_t id, const ByteVector &data = ByteVector(0));

    bool sendRequest(const uint8_t id) {
        return sendData(id, ByteVector());
    }

    bool sendRequest(const msp::ID id) {
        return sendData(uint8_t(id), ByteVector());
    }

    bool sendResponse(const msp::Response &response) {
        return sendData(uint8_t(response.id()), response.encode());
    }

    int request(msp::Request &request, const double timeout = 0);

    int request_raw(const uint8_t id, ByteVector &data, const double timeout = 0);

    bool respond(const msp::Response &response, const bool wait_ack=true);

    bool respond_raw(const uint8_t id, const ByteVector &data, const bool wait_ack=true);

    template<typename T, typename C>
    SubscriptionBase* subscribe(void (C::*callback)(const T&), C *context, const double tp = 0.0) {

        if(!std::is_base_of<msp::Request, T>::value)
            throw std::runtime_error("Callback parameter needs to be of Request type!");

        if(!(tp>=0.0))
            throw std::runtime_error("Period must be positive!");

        const msp::ID id = T().id();

        std::lock_guard<std::mutex> lock(mutex_callbacks);

        // register message
        if(subscribed_requests.count(id)) { delete subscribed_requests[id]; }
        subscribed_requests[id] = new T();

        // register subscription
        subscriptions[id] = new Subscription<T,C>(callback, context,
            new PeriodicTimer(
                std::bind(static_cast<bool(Client::*)(msp::ID)>(&Client::sendRequest), this, id),
                tp
            )
        );

        return subscriptions[id];
    }

    bool hasSubscription(const msp::ID& id) {
        return (subscriptions.count(id)==1);
    }

    SubscriptionBase* getSubscription(const msp::ID& id) {
        return subscriptions.at(id);
    }

    void processOneMessage();

private:
    uint8_t crc(const uint8_t id, const ByteVector &data);

private:
    // I/O
    asio::io_service io;
    asio::serial_port port;
    asio::streambuf buffer;
    // threading
    std::thread thread;
    bool running;
    std::condition_variable cv_request;
    std::condition_variable cv_ack;
    std::mutex mutex_cv_request;
    std::mutex mutex_cv_ack;
    std::mutex mutex_request;
    std::mutex mutex_callbacks;
    std::mutex mutex_send;
    std::mutex mutex_buffer;
    // message for request method
    std::unique_ptr<ReceivedMessage> request_received;
    // subscriptions
    std::map<msp::ID, SubscriptionBase*> subscriptions;
    std::map<msp::ID, msp::Request*> subscribed_requests;
    // debugging
    bool print_warnings;
};

} // namespace client
} // namespace msp

#endif // CLIENT_HPP