CANOpenSDOClient.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_CANOPENSDOCLIENT_H_
#define _MLAB_CANOPENSDOCLIENT_H_

#include <map>

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

#include <boost/format.hpp>
#endif

#include <error/Exceptions.h>
#include <utils/UUID.h>

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

namespace mira { namespace can {


class MLAB_CAN_EXPORT CANOpenSDOClient : public SDOClientBase
{
public:

    CANOpenSDOClient(CANInterfacePtr iIfc);

    virtual ~CANOpenSDOClient();


public:

    template<typename T>
    SDOFuture<T> read(uint8 node, uint16 index, uint8 subIndex)
    {
        boost::shared_ptr<ReadRequest<T>> request(new ReadRequest<T>(node, index, subIndex));
        boost::mutex::scoped_lock lock(mReadRequestsMutex);
        uint64 requestID = getNextRequestID();
        mReadRequests[requestID] = request;
        sendSDOReadRequest(request);
        return SDOFuture<T>(request->promise.get_future(), this, requestID);
    }

    template<typename T>
    T readSync(uint8 node, uint16 index, uint8 subIndex,
               Duration waitTime = Duration::milliseconds(50),
               uint32 maxTries=5)
    {
        uint32 tries = 0;
        while(tries++ < maxTries)
        {
            auto r = read<T>(node, index, subIndex);
            if (r.timedWait(waitTime))
                return r.get();
        }
        MIRA_THROW(XTimeout, "Timeout during read SDO " << std::hex
                   << "node(0x" << boost::format("%02x") % (int)node << ") "
                   << "index(0x" << boost::format("%04x") % index << ") "
                   << "subindex (0x" << boost::format("%02x") % (int)subIndex << ")");
        return T();
    }

    CANOpenNodeInfo readNodeInfo(uint8 node);


public:

    template<typename T>
    SDOFuture<void> write(uint8 node, uint16 index, uint8 subIndex, T value)
    {
        CANMessage message;
        std::size_t size = CANOpenUtil::write<T>(message, 4, value);

        boost::shared_ptr<WriteRequest> request(new WriteRequest(node, index, subIndex));
        boost::mutex::scoped_lock lock(mWriteRequestsMutex);
        uint64 requestID = getNextRequestID();
        mWriteRequests[requestID] = request;
        sendSDOWriteRequest(request, message, size);
        return SDOFuture<void>(request->promise.get_future(), this, requestID);
    }

    template<typename T>
    SDOFuture<void> writeSync(uint8 node, uint16 index, uint8 subIndex, T value,
                              Duration waitTime = Duration::milliseconds(50),
                              uint32 maxTries=5)
    {
        uint32 tries = 0;
        while(tries++ < maxTries)
        {
            auto w = write<T>(node, index, subIndex, value);
            if (w.timedWait(waitTime))
                return w;
        }
        MIRA_THROW(XTimeout, "Timeout during write SDO " << std::hex
                   << "node(0x" << boost::format("%02x") % (int)node << ") "
                   << "index(0x" << boost::format("%04x") % index << ") "
                   << "subindex (0x" << boost::format("%02x") % (int)subIndex << ")");
    }


public:
    virtual void onDestructFuture(uint64 requestID);

private:
    // Internal base class of SDO uploads (read)

    class ReadWriteRequestBase
    {
    public:
        ReadWriteRequestBase(uint8 iNode, uint16 iIdx, uint8 iSubIdx) :
            node(iNode), idx(iIdx), subIdx(iSubIdx) {}
        virtual ~ReadWriteRequestBase() {}
    public:
        virtual void setMessage(const CANMessage& message, std::size_t offset) = 0;
        virtual void setException(const Exception& ex) = 0;
    public:
        uint8  node;   
        uint16 idx;    
        uint8  subIdx; 
    };

    // Internal template class for handling SDO uploads (read)

    template<typename T>
    class ReadRequest :
        public ReadWriteRequestBase
    {
    public:
        ReadRequest(uint8 iNode, uint16 iIdx, uint8 iSubIdx) :
            ReadWriteRequestBase(iNode, iIdx, iSubIdx) {}
        virtual ~ReadRequest() {}
    public:
        virtual void setMessage(const CANMessage& message, std::size_t offset) {
            T value = CANOpenUtil::read<T>(message, offset);
            promise.set_value(value);
        }
        virtual void setException(const Exception& ex) {
            promise.set_exception(boost::copy_exception(ex));
        }
    public:
        boost::promise<T> promise;
    };

    // Internal class for handling SDO downloads (write)

    class WriteRequest : public ReadWriteRequestBase
    {
    public:
        WriteRequest(uint8 iNode, uint16 iIdx, uint8 iSubIdx) :
            ReadWriteRequestBase(iNode, iIdx, iSubIdx) {}
        virtual ~WriteRequest() {}
    public:
        virtual void setMessage(const CANMessage& message, std::size_t offset) {
            promise.set_value();
        }
        virtual void setException(const Exception& ex) {
            promise.set_exception(boost::copy_exception(ex));
        }
    public:
        boost::promise<void> promise;
    };

    typedef boost::shared_ptr<ReadWriteRequestBase> RequestPtr;
    typedef std::map<uint64, RequestPtr> RequestList;


private:
    void sendSDOReadRequest(RequestPtr iRequest);

    void sendSDOWriteRequest(RequestPtr iRequest,
                             CANMessage& iMessage, std::size_t iSize);

    void processSDOMessage(const CANMessage& iMsg, const Time& time);

    static uint64 getNextRequestID() {
        static uint64 sNextRequestID = 0;
        static boost::mutex sIDMutex;

        boost::mutex::scoped_lock lock(sIDMutex);
        return(sNextRequestID++);
    }

private:
    CANInterfacePtr mCAN;
    uint32 mCallbackID;

    RequestList mReadRequests;
    boost::mutex mReadRequestsMutex;
    RequestList mWriteRequests;
    boost::mutex mWriteRequestsMutex;
};

typedef boost::shared_ptr<CANOpenSDOClient> CANOpenSDOClientPtr;


}} // namespaces

#endif