CANOpenNMTMaster.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 MetraLabs GmbH (MLAB), GERMANY.
 * All rights reserved.
 * Contact: info@MetraLabs.com
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MetraLabs.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file.  Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MetraLabs (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
 * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
 * OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLABS" HAS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN
 * "AS IS" BASIS, AND "MLAB" HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
 * SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MLAB_CANOPENNMTMASTER_H_
#define _MLAB_CANOPENNMTMASTER_H_

#include <queue>

#ifndef Q_MOC_RUN
#include <boost/thread/future.hpp>
#endif

#include <can/CANInterface.h>
#include <can/CANOpenDefs.h>

namespace mira { namespace can {


typedef boost::function<void (uint8, CANOpenNodeStatus)> CANOpenHeartbeat;


class CANOpenNMTMaster;


class MLAB_CAN_EXPORT CANOpenNodeStatusFuture
{
public:

    CANOpenNodeStatusFuture() : mNMTMaster(NULL), mRequestID(0) {}

    CANOpenNodeStatusFuture(boost::unique_future<CANOpenNodeStatus> other,
                            CANOpenNMTMaster* master, uint64 requestID) :
        mNMTMaster(master), mRequestID(requestID)
    {
        this->mFuture.swap(other);
    }

    CANOpenNodeStatusFuture(CANOpenNodeStatusFuture&& other) {
        this->swap(other);
    }

    CANOpenNodeStatusFuture& operator=(CANOpenNodeStatusFuture && other) {
        this->swap(other);
        return *this;
    }

    ~CANOpenNodeStatusFuture();

public:
    // delegate to boost future

    bool isReady() const { return mFuture.is_ready(); }

    bool hasException() const { return mFuture.has_exception(); }

    bool hasValue() const { return mFuture.has_value(); }

    void wait() const { mFuture.wait(); }

    template<typename Duration>
    bool timedWait(Duration const& relTime) const {
        return mFuture.timed_wait(relTime);
    }

    bool timedWaitUntil(boost::system_time const& absTime) const {
        return mFuture.timed_wait_until(absTime);
    }

    void swap(CANOpenNodeStatusFuture& other) {
        mFuture.swap(other.mFuture);
        std::swap(mNMTMaster, other.mNMTMaster);
        std::swap(mRequestID, other.mRequestID);
    }

    CANOpenNodeStatus get() { return mFuture.get(); }

protected:
    CANOpenNMTMaster* mNMTMaster;
    uint64 mRequestID;
    boost::unique_future<CANOpenNodeStatus> mFuture;
};


class MLAB_CAN_EXPORT CANOpenNMTMaster
{
    friend class CANOpenNodeStatusFuture;

public:

    CANOpenNMTMaster(CANInterfacePtr iIfc);

    virtual ~CANOpenNMTMaster();


public:

    uint32 addHeartbeatCallback(CANOpenHeartbeat iCallback);

    void removeHeartbeatCallback(uint32 pFuncID);


public:

    void startNode(uint8 iNodeID);

    void stopNode(uint8 iNodeID);

    void preOperationalNode(uint8 iNodeID);

    void resetNode(uint8 iNodeID);

    void resetCommunication(uint8 iNodeID);


public:

    CANOpenNodeStatusFuture getNodeStatus(uint8 iNodeID);


protected:

    void onDestructFuture(uint64 requestID);


private:
    void processNMTMessage(const CANMessage& iMsg);

    void processThread();

private:

    // Internal class for handling node status requests

    class StatusRequest
    {
    public:
        StatusRequest(uint8 iNode) : node(iNode) {}
        virtual ~StatusRequest() {}
    public:
        virtual void setStatus(CANOpenNodeStatus iStatus) {
            promise.set_value(iStatus);
        }
        virtual void setException(const Exception& ex) {
            promise.set_exception(boost::copy_exception(ex));
        }
    public:
        uint8  node;
        boost::promise<CANOpenNodeStatus> promise;
    };

    typedef boost::shared_ptr<StatusRequest> StatusRequestPtr;
    typedef std::map<uint64, StatusRequestPtr> StatusRequestList;

    struct HeartbeatListener {
        uint32           id;
        CANOpenHeartbeat func;
    };

private:
    // The CAN interface
    CANInterfacePtr mCAN;
    uint32 mCallbackID1;
    uint32 mCallbackID2;

    // queue of incoming messages
    std::queue<CANMessage> mMessageQueue;
    boost::mutex mMessageMutex;
    boost::condition_variable mMessageCondition;

    // internal processing thread
    boost::thread mProcessThread;

    // list of heartbeat callbacks
    std::vector<HeartbeatListener> mHeartbeatCbs;
    uint32 mHeartbeatCallbackNextID;
    boost::mutex mHeartbeatMutex;

    // list of pending status requests
    StatusRequestList mStatusRequests;
    boost::mutex mStatusRequestsMutex;
};

typedef boost::shared_ptr<CANOpenNMTMaster> CANOpenNMTMasterPtr;


}} // namespaces

#endif