Target.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 TARGET_H
#define TARGET_H

#include <QObject>
#include <valarray>
#include "../compiler/compiler.h"

namespace Aseba
{
        
        struct TargetDescription;
        
        class Target: public QObject
        {
                Q_OBJECT
        
        public:
                enum ExecutionMode
                {
                        EXECUTION_STOP,
                        EXECUTION_RUN,
                        EXECUTION_STEP_BY_STEP,
                        EXECUTION_UNKNOWN,
                };
                
        signals:
                void nodeConnected(unsigned node);
                void nodeDisconnected(unsigned node);
                void networkDisconnected();
                
                void userEvent(unsigned id, const VariablesDataVector data);
                void userEventsDropped(unsigned amount);
                
                void arrayAccessOutOfBounds(unsigned node, unsigned line, unsigned size, unsigned index);
                void divisionByZero(unsigned node, unsigned line);
                void eventExecutionKilled(unsigned node, unsigned line);
                void nodeSpecificError(unsigned node, unsigned line, const QString& message);
                
                void executionPosChanged(unsigned node, unsigned line);
                void executionModeChanged(unsigned node, Target::ExecutionMode mode);
                void variablesMemoryEstimatedDirty(unsigned node);
                
                void variablesMemoryChanged(unsigned node, unsigned start, const VariablesDataVector &variables);
                
                void breakpointSetResult(unsigned node, unsigned line, bool success);
                
                void bootloaderAck(unsigned errorCode, unsigned errorAddress);
                
        public:
                virtual ~Target() { }
        
        /*public slots:
                virtual void connect() = 0;*/
        
        public:
                virtual QString getLanguage() const = 0;
                
                const QString getName(unsigned node) const;
                
                virtual const TargetDescription * const getDescription(unsigned node) const = 0;
                
                virtual void broadcastGetDescription() = 0;
                
                virtual void uploadBytecode(unsigned node, const BytecodeVector &bytecode) = 0;
                
                virtual void writeBytecode(unsigned node) = 0;
                
                virtual void reboot(unsigned node) = 0;
                
                virtual void sendEvent(unsigned id, const VariablesDataVector &data) = 0;
                
                // variables
                
                virtual void setVariables(unsigned node, unsigned start, const VariablesDataVector &data) = 0;
                
                virtual void getVariables(unsigned node, unsigned start, unsigned length) = 0;
                
                // execution
                
                virtual void reset(unsigned node) = 0;
                
                virtual void run(unsigned node) = 0;
                
                virtual void pause(unsigned node) = 0;
                
                virtual void next(unsigned node) = 0;
                
                virtual void stop(unsigned node) = 0;
                
                // breakpoints
                
                virtual void setBreakpoint(unsigned node, unsigned line) = 0;
                
                virtual void clearBreakpoint(unsigned node, unsigned line) = 0;
                
                virtual void clearBreakpoints(unsigned node) = 0;
        
        protected:
                friend class ThymioBootloaderDialog;
                friend class ThymioVisualProgramming;
                                
                virtual void blockWrite() = 0;
                
                virtual void unblockWrite() = 0;
        };
        
}; // Aseba

#endif