CANChannelInterface.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_CANCHANNELINTERFACE_H_
#define _MLAB_CANCHANNELINTERFACE_H_

#include <utils/Foreach.h>

#include <fw/Framework.h>

#include <can/CANInterface.h>

namespace mira { namespace can {


class CANChannelInterface : public CANInterface
{
public:

    CANChannelInterface(Authority& authority) :
        mAuthority(authority.getNamespace(),
                   authority.getName()+"_CANInterface", Authority::ANONYMOUS | Authority::HIDDEN),
        mLastTime(Time::now())
    {
        mOutChannel = mAuthority.publish<CANMessage>("OutgoingCAN");
        mInChannel =  mAuthority.subscribe<CANMessage>("IncomingCAN",
                                                       &CANChannelInterface::onIncoming, 
                                                       this,
                                                       Duration::seconds(10));
    }


public:

    virtual void sendMessage(const CANMessage& msg)
    {
        // We must use a mutex here, since this function might be called
        // from multiple threads.
        boost::mutex::scoped_lock lock(mOutgoingChannelMutex);

        auto w = mOutChannel.write();
        w->value() = msg;
        Time ts = w->timestamp;
        w.finish();
        onMessageSend(msg, ts);
    }


private:

    void onIncoming(ChannelRead<CANMessage> message)
    {
        ChannelReadInterval<CANMessage> interval =
                mInChannel.readInterval(mLastTime, message->timestamp);
        mLastTime = message->timestamp;
        foreach(const Stamped<CANMessage>& m, interval)
            onMessageReceived(m, m.timestamp);
    }

private:
    Authority mAuthority;
    Time mLastTime;
    Channel<CANMessage> mOutChannel;
    Channel<CANMessage> mInChannel;

    boost::mutex mOutgoingChannelMutex;
};

typedef boost::shared_ptr<CANChannelInterface> CANChannelInterfacePtr;


}} // namespaces

#endif