/opt/ros/diamondback/stacks/ethzasl_aseba/asebaros/aseba/svn/medulla/medulla.h

Go to the documentation of this file.

/*
        Aseba - an event-based framework for distributed robot control
        Copyright (C) 2007--2009:
                Stephane Magnenat <stephane at magnenat dot net>
                (http://stephane.magnenat.net)
                and other contributors, see authors.txt for details
                Mobots group, Laboratory of Robotics Systems, EPFL, Lausanne
        
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation, either version 3 of the License, or
        any other version as decided by the two original authors
        Stephane Magnenat and Valentin Longchamp.
        
        This program 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 General Public License for more details.
        
        You should have received a copy of the GNU General Public License
        along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef ASEBA_MEDULLA
#define ASEBA_MEDULLA

#include <dashel/dashel.h>
#include <QThread>
#include <QStringList>
#include <QDBusObjectPath>
#include <QDBusAbstractAdaptor>
#include <QDBusConnection>
#include <QDBusMessage>
#include <QMetaType>
#include <QList>
#include "../msg/msg.h"
#include "../msg/descriptions-manager.h"

typedef QList<qint16> Values;

namespace Aseba
{
        
        class Hub;
        class AsebaNetworkInterface;
        
        class EventFilterInterface: public QObject
        {
                Q_OBJECT
                Q_CLASSINFO("D-Bus Interface", "ch.epfl.mobots.EventFilter")
                
                public:
                        EventFilterInterface(AsebaNetworkInterface* network) : network(network) { ListenEvent(0); }
                        void emitEvent(const quint16 id, const QString& name, const Values& data);
                        
                public slots:
                        Q_SCRIPTABLE Q_NOREPLY void ListenEvent(const quint16 event);
                        Q_SCRIPTABLE Q_NOREPLY void ListenEventName(const QString& name, const QDBusMessage &message);
                        Q_SCRIPTABLE Q_NOREPLY void IgnoreEvent(const quint16 event);
                        Q_SCRIPTABLE Q_NOREPLY void IgnoreEventName(const QString& name, const QDBusMessage &message);
                        Q_SCRIPTABLE Q_NOREPLY void Free();
                
                signals:
                        Q_SCRIPTABLE void Event(const quint16, const QString& name, const Values& values);
                        Q_SCRIPTABLE void Test0(const quint16);
                        Q_SCRIPTABLE void Test1(const QString& );
                        Q_SCRIPTABLE void Test2(const Values& );
                        Q_SCRIPTABLE void Test0_1(const quint16, const QString& );
                        Q_SCRIPTABLE void Test0_2(const quint16, const Values& );
                        Q_SCRIPTABLE void Test1_2(const QString&, const Values& );
                
                protected:
                        AsebaNetworkInterface* network;
        };
        
        class AsebaNetworkInterface: public QDBusAbstractAdaptor, public DescriptionsManager
        {
                Q_OBJECT
                Q_CLASSINFO("D-Bus Interface", "ch.epfl.mobots.AsebaNetwork")
                
                protected:
                        struct RequestData
                        {
                                unsigned nodeId;
                                unsigned pos;
                                QDBusMessage reply;
                        };
                        
                public:
                        AsebaNetworkInterface(Hub* hub, bool systemBus);
                
                private slots:
                        friend class Hub;
                        void processMessage(Message *message, Dashel::Stream* sourceStream);
                        friend class EventFilterInterface;
                        void sendEventOnDBus(const quint16 event, const Values& data);
                        void listenEvent(EventFilterInterface* filter, quint16 event);
                        void ignoreEvent(EventFilterInterface* filter, quint16 event);
                        void filterDestroyed(EventFilterInterface* filter);
                
                public slots:
                        Q_NOREPLY void LoadScripts(const QString& fileName, const QDBusMessage &message);
                        QStringList GetNodesList() const;
                        qint16 GetNodeId(const QString& node, const QDBusMessage &message) const;
                        QStringList GetVariablesList(const QString& node) const;
                        Q_NOREPLY void SetVariable(const QString& node, const QString& variable, const Values& data, const QDBusMessage &message) const;
                        Values GetVariable(const QString& node, const QString& variable, const QDBusMessage &message);
                        Q_NOREPLY void SendEvent(const quint16 event, const Values& data);
                        Q_NOREPLY void SendEventName(const QString& name, const Values& data, const QDBusMessage &message);
                        QDBusObjectPath CreateEventFilter();
                
                protected:
                        virtual void nodeDescriptionReceived(unsigned nodeId);
                        QDBusConnection DBusConnectionBus() const;
                        
                protected:
                        Hub* hub;
                        CommonDefinitions commonDefinitions;
                        typedef QMap<QString, unsigned> NodesNamesMap;
                        NodesNamesMap nodesNames;
                        typedef QMap<QString, Compiler::VariablesMap> UserDefinedVariablesMap;
                        UserDefinedVariablesMap userDefinedVariablesMap;
                        typedef QList<RequestData*> RequestsList;
                        RequestsList pendingReads;
                        typedef QMultiMap<quint16, EventFilterInterface*> EventsFiltersMap;
                        EventsFiltersMap eventsFilters;
                        bool systemBus;
                        unsigned eventsFiltersCounter;
        };
        
        class Hub: public QThread, public Dashel::Hub
        {
                Q_OBJECT
                
                public:
                        Hub(unsigned port, bool verbose, bool dump, bool forward, bool rawTime, bool systemBus);
                        
                        void sendMessage(Message *message, Dashel::Stream* sourceStream = 0);
                        void sendMessage(Message& message, Dashel::Stream* sourceStream = 0);
                        
                signals:
                        void firstConnectionCreated();
                        void messageAvailable(Message *message, Dashel::Stream* sourceStream);
                
                protected slots:
                        void firstConnectionAvailable();
                        void requestDescription();
                        
                private:
                        virtual void run();
                        virtual void connectionCreated(Dashel::Stream *stream);
                        virtual void incomingData(Dashel::Stream *stream);
                        virtual void connectionClosed(Dashel::Stream *stream, bool abnormal);
                        
                private:
                        bool verbose; 
                        bool dump; 
                        bool forward; 
                        bool rawTime; 
        };
        
};

Q_DECLARE_METATYPE(Values);

#endif

---

asebaros
Author(s): $author
autogenerated on Mon Sep 5 08:41:53 2011