CANOpenBus.hpp

/***************************************************************************
  tag: Peter Soetens  Mon Jan 19 14:11:21 CET 2004  CANOpenBus.hpp

                        CANOpenBus.hpp -  description
                           -------------------
    begin                : Mon January 19 2004
    copyright            : (C) 2004 Peter Soetens
    email                : peter.soetens@mech.kuleuven.ac.be

 ***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/

#ifndef CANOPENBUS_HPP
#define CANOPENBUS_HPP

#include "CANBusInterface.hpp"
#include "CANControllerInterface.hpp"
#include "CANMessage.hpp"

#include <list>
#include <algorithm>
#include <rtt/os/rtstreams.hpp>

namespace RTT
{namespace CAN
{
    using std::list;
    using std::find;

    class CANOpenBus
        :public CANBusInterface
    {
        CANMessage syncMsg;

        public:
        CANOpenBus()
            : controller( 0 )
        {
            syncMsg.setStdId( 0x80 );
        }

        void sync()
        {
            this->write( &syncMsg );
        }

        void setController(CANControllerInterface* contr)
        {
            controller = contr;
        }

        virtual bool addDevice(CANDeviceInterface* dev)
        {
            if ( devices.size() < MAX_DEVICES)
                devices.push_back(dev);
            else
                return false;
            return true;
        }

        virtual bool addListener(CANListenerInterface* dev)
        {
            if ( listeners.size() < MAX_DEVICES)
                listeners.push_back(dev);
            else
                return false;
            return true;
        }

        virtual void removeDevice(CANDeviceInterface* dev)
        {
            list<CANDeviceInterface*>::iterator itl;
            itl = find(devices.begin(), devices.end(), dev);
            if ( itl != devices.end() )
                devices.erase(itl);
        }

        virtual void removeListener(CANListenerInterface* dev)
        {
            list<CANListenerInterface*>::iterator itl;
            itl = find(listeners.begin(), listeners.end(), dev);
            if ( itl != listeners.end() )
                listeners.erase(itl);
        }

        virtual void write(const CANMessage *msg)
        {
            //rt_std::cout <<"Writing...";
            // All listeners are notified.
            list<CANListenerInterface*>::iterator itl = listeners.begin();
            while ( itl != listeners.end() )
                {
                    list<CANListenerInterface*>::iterator next = (++itl)--;
                    (*itl)->process(msg); // eventually check the node id (in CANOpenBus)
                    itl = next;
                }

            if ( controller == 0 )
                return;
            if ( msg->origin != controller )
                {
                    //rt_std::cout <<"to controller !\n";
                    controller->process(msg);
                }
            else
                {
                    //rt_std::cout <<"to devicelist !\n";
                    list<CANDeviceInterface*>::iterator itd = devices.begin();
                    while ( itd != devices.end() )
                        {
                            list<CANDeviceInterface*>::iterator _next = (++itd)--;
                            (*itd)->process(msg); // eventually check the node id (in CANOpenBus)
                            itd = _next;          // XXX What if itd just removed _next (or everything)?
                                                  // can be 'solved' if only self-removal is allowed.
                        }
                }
        }

        static const unsigned int MAX_DEVICES = 127;
    protected:
        list<CANDeviceInterface*> devices;
        list<CANListenerInterface*> listeners;

        CANControllerInterface* controller;
    };

}}


#endif

---