receiver.h

// Copyright (C) 2008,2009,2010 by Philipp Münzel. All rights reserved.
// Released under the terms of the license described in license.txt

#ifndef RECEIVER_H
#define RECEIVER_H

#include "dllexport.h"

#include <map>
#include <boost/function.hpp>

#include "canaerometadata.h"
#include "datareference.h"
#include "canaerobusconnector.h"
#include "canaerodatamanager.h"

namespace SCS {

class DLL_PUBLIC Receiver : public CanAeroDataManager
{
public:

    Receiver(uint8_t required_software_revision,
             uint8_t own_node_id = 255,
             const std::string& host_addr = "239.40.41.42");


    Receiver(uint8_t required_software_revision,
             NetworkConnector<can_t>* connector,
             uint8_t own_node_id = 255);


    virtual ~Receiver();


    void requestData(can_Id_t can_id, TypelessDataReference* dataref);


    void requestData(can_Id_t can_id, int32_t* t);

    void requestData(can_Id_t can_id, float* t);

    void requestData(can_Id_t can_id, double* t);

    void requestData(can_Id_t can_id, bool* t);

    void requestData(can_Id_t can_id, char4* t);

    void requestData(can_Id_t can_id, std::string* t);

    void requestData(can_Id_t can_id, std::vector<float>* t);


    void requestData(can_Id_t can_id, boost::function<void (int32_t)> f, int32_t* t);

    void requestData(can_Id_t can_id, boost::function<void (float)> f, float* t);

    void requestData(can_Id_t can_id, boost::function<void (double)> f, double* t);

    void requestData(can_Id_t can_id, boost::function<void (bool)> f, bool* t);

    void requestData(can_Id_t can_id, boost::function<void (char4)> f, char4* t);

    void requestData(can_Id_t can_id, boost::function<void (const std::string&)> f, std::string* t);

    void requestData(can_Id_t can_id, boost::function<void (const std::vector<float>&)> f, std::vector<float>* t);


    void requestData(can_Id_t can_id, boost::function<void (int32_t)> f);

    void requestData(can_Id_t can_id, boost::function<void (float)> f);

    void requestData(can_Id_t can_id, boost::function<void (double)> f);

    void requestData(can_Id_t can_id, boost::function<void (bool)> f);

    void requestData(can_Id_t can_id, boost::function<void (char4)> f);

    void requestData(can_Id_t can_id, boost::function<void (const std::string&)> f);

    void requestData(can_Id_t can_id, boost::function<void (const std::vector<float>&)> f);


    void sendData(can_Id_t can_id, int32_t t);

    void sendData(can_Id_t can_id, float t);

    void sendData(can_Id_t can_id, double t);

    void sendData(can_Id_t can_id, bool t);

    void sendData(can_Id_t can_id, char4 t);

    void sendData(can_Id_t can_id, const std::string& t);

    void sendData(can_Id_t can_id, const std::vector<float>& t);


    void sendData(can_Id_t can_id);

//    /**
//      * Offer data to be requested by other participants on the bus.
//      * @param can_id_29bit the CAN id in 29bit adress range which others have to request to get this data
//      * @param t pointer where data should be read if someone requests it and is written if someone sends it
//      */
//    void offerData(uint32_t can_id_29bit, int32_t* t);

//    void offerData(uint32_t can_id_29bit, boost::function<void(int32_t)> readfunc, boost::function<int32_t()> writefunc);


    void run(bool do_log_output = true);


    void requestModule(uint8_t node_id, uint16_t module, uint16_t mode = 1);


    TypelessDataReference* get(can_Id_t can_id);


protected:

    virtual void handleSTS();

    virtual void handleMCS(uint16_t module, uint16_t mode);

    virtual uint32_t handleMIS();

    virtual bool handleDRS(uint32_t) ;


private:
    void incomingData(const can_t&);

    void changeNodeId(uint8_t node_id);

private:
    class ReceiverImpl;
    ReceiverImpl* m_pimpl;
    friend class CanAeroBusConnector;
};

}

#endif // RECEIVER_H