behaviour_sensors.h

Go to the documentation of this file.

// Behaviour Control Framework - Sensor classes
// Author: Philipp Allgeuer <pallgeuer@ais.uni-bonn.de>

// Ensure header is only included once
#ifndef BEHAVIOUR_SENSORS_H
#define BEHAVIOUR_SENSORS_H

// Includes
#include <behaviour_control/classes/behaviour_common.h>

// Behaviour control namespace
namespace behaviourcontrol
{
    class SensorManager
    {
    public:
        // Constants
        static const index_t DEF_SLIST_CAPACITY; 

        // Constructors
        explicit SensorManager(BehaviourLayer* LBase); 
        virtual ~SensorManager(); 

        // Constant properties
        BehaviourManager* const MBase; 
        BehaviourLayer* const LBase; 

        // Initialisation functions
    protected:
        virtual ret_t init() { return RET_OK; } 
    private:
        ret_t initAllBase(); 

    private:
        // Update function
        void updateSensors(); 

        // Sensor declaration function
        template <class SClass> void declareSensor(SClass* sensor); 

        // Sensor list
        std::vector<SensorBase*> SList; 
        
    public:
        // Write data to an external source (used only in interface layers)
        virtual void writeExternalData() {} 

        // Get functions
        SensorManager* getBasePtr() { return this; } 

        // Friend classes
        friend class BehaviourManager;
        friend class BehaviourLayer;
        friend class SensorBase;
    };

    class SensorBase
    {
    public:
        // Constructors
        SensorBase(SensorManager* SMBase, const std::string& signalName); 
        virtual ~SensorBase(); 

        // Constant properties
        BehaviourManager* const MBase; 
        BehaviourLayer* const LBase; 
        SensorManager* const SMBase; 
        const std::string signalName; 

        // Initialisation function
    private:
        ret_t initBase(); 

    public:
        // Template type information
        virtual const std::type_info* getTypeInfo() const = 0; 
        virtual bool isCompatibleWith(const ActuatorBase* ABase) const = 0; 

        // Data bind and update functions
    protected:
        virtual ret_t bindTo(const ActuatorBase* ABase) = 0; 
        virtual void getLatestData() = 0; 
    public:
        virtual bool isBound() const = 0; 

    public:
        // Get functions
        SensorBase* getBasePtr() { return this; } 

        // Friend classes
        friend class SensorManager;
    };

    template <class T>
    class Sensor : public SensorBase
    {
    public:
        // Constructors
        Sensor(SensorManager* SMBase, const std::string& signalName); 
        virtual ~Sensor(); 

        // Template type information
        const std::type_info* const typeInfo;
        virtual const std::type_info* getTypeInfo() const { return typeInfo; }
        virtual bool isCompatibleWith(const ActuatorBase* ABase) const;

        // Data bind, update and read functions
    protected:
        virtual ret_t bindTo(const ActuatorBase* ABase); 
        virtual void getLatestData(); 
    public:
        virtual bool isBound() const { return (sourceAct != NULL); } 
        bool wasWrittenTo() const { return actWasWrittenTo; } 
        const T& read() const { return data; } 

    private:
        // Internal variables
        const Actuator<T>* sourceAct; 
        T data; 
        bool actWasWrittenTo; 
    };
}

#endif /* BEHAVIOUR_SENSORS_H */
// EOF