medulla.h

Go to the documentation of this file.

/*
        Aseba - an event-based framework for distributed robot control
        Copyright (C) 2007--2012:
                Stephane Magnenat <stephane at magnenat dot net>
                (http://stephane.magnenat.net)
                and other contributors, see authors.txt for details
        
        This program 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, version 3 of the License.
        
        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 Lesser General Public License for more details.
        
        You should have received a copy of the GNU Lesser 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