diff --git a/src/Oncilla.cpp b/src/Oncilla.cpp index 289d59e..af18ae4 100644 --- a/src/Oncilla.cpp +++ b/src/Oncilla.cpp @@ -1,130 +1,131 @@ /* * Oncilla.cpp * * Created on: 15 dec. 2011 * Author: Alexandre Tuleu, Arne Nordmann */ #include "Oncilla.h" #include "OncillaTrunk.h" #include "OncillaL0.h" #include "OncillaL1L2.h" #include "OncillaL3.h" #include "OncillaL4.h" #include "BackendFactory.h" namespace rci { namespace oncilla { +OncillaSynchronizerPtr Oncilla::s_synchronizer; Oncilla::LegNames Oncilla::s_legNames; const std::string & Oncilla::nameOfLeg(Leg l){ if(s_legNames.empty()){ s_legNames.push_back("Left Fore"); s_legNames.push_back("Right Fore"); s_legNames.push_back("Left Hind"); s_legNames.push_back("Right Hind"); s_legNames.push_back("Undefined"); } if(l >= NUM_LEGS){ return s_legNames.back(); } return s_legNames[l]; } -Oncilla::Oncilla() +Oncilla::Oncilla(){ + if(!s_synchronizer){ + BackendFactory::EntryPtr e = BackendFactory::Instance().HighestPriorityBackend(); + if( e == 0){ + throw std::runtime_error("No backend for liboncilla were found. Are you" + " sure you are linking your program with a backend like " + "'liboncilla-webots' or 'liboncilla-hw' ?."); + } - : d_synchronizer(){ - BackendFactory::EntryPtr e = BackendFactory::Instance().HighestPriorityBackend(); - if( e == 0){ - throw std::runtime_error("No backend for liboncilla were found. Are you" - " sure you are linking your program with a backend like " - "'liboncilla-webots' or 'liboncilla-hw' ?."); + s_synchronizer = (*e)(); + init(); } - d_synchronizer = (*e)(); - - init(); } Oncilla::~Oncilla() { } #define CREATE_NODES(LegName)do{\ d_L0s.push_back(OncillaL0Ptr(new OncillaL0(LegName " Oncilla L0" )));\ - d_L1s.push_back(OncillaL1Ptr(new OncillaL1L2(*d_synchronizer,\ + d_L1s.push_back(OncillaL1Ptr(new OncillaL1L2(*s_synchronizer,\ LegName " Oncilla L1")));\ - d_L2s.push_back(OncillaL2Ptr(new OncillaL1L2(*d_synchronizer,\ + d_L2s.push_back(OncillaL2Ptr(new OncillaL1L2(*s_synchronizer,\ LegName " Oncilla L2")));\ d_L3s.push_back(OncillaL3Ptr(new OncillaL3(LegName " Oncilla L3")));\ d_L4s.push_back(OncillaL4Ptr(new OncillaL4(LegName " Oncilla L4")));\ }while(0) #define REGISTER_NODES(Type)do{\ for(std::vector < Oncilla ## Type ## Ptr >::const_iterator n = d_ ## Type ## s.begin();\ n != d_ ## Type ## s.end();\ ++n){\ Oncilla::Leg l = static_cast(n - d_ ## Type ## s.begin());\ - d_synchronizer->register ## Type ## Node(l,*n);\ + s_synchronizer->register ## Type ## Node(l,*n);\ }\ }while(0) void Oncilla::init() { d_L0s.reserve(4); d_L1s.reserve(4); d_L2s.reserve(4); d_L3s.reserve(4); d_L4s.reserve(4); CREATE_NODES("Left Fore"); CREATE_NODES("Right Fore"); CREATE_NODES("Left Hind"); CREATE_NODES("Right Hind"); d_trunk = OncillaTrunkPtr(new OncillaTrunk("Oncilla Trunk")); REGISTER_NODES(L0); REGISTER_NODES(L1); REGISTER_NODES(L2); REGISTER_NODES(L3); REGISTER_NODES(L4); - d_synchronizer->registerTrunkNode(d_trunk); + s_synchronizer->registerTrunkNode(d_trunk); } OncillaL0Ptr Oncilla::getL0(Leg l) const { return this->d_L0s[l]; } OncillaL1Ptr Oncilla::getL1(Leg l) const { return this->d_L1s[l]; } OncillaL2Ptr Oncilla::getL2(Leg l) const { return this->d_L2s[l]; } OncillaL3Ptr Oncilla::getL3(Leg l) const { return this->d_L3s[l]; } OncillaL4Ptr Oncilla::getL4(Leg l) const { return this->d_L4s[l]; } OncillaTrunkPtr Oncilla::getTrunk() const { return this->d_trunk; } OncillaSynchronizerPtr Oncilla::getSynchronizer() const { - return this->d_synchronizer; + return this->s_synchronizer; } } } diff --git a/src/Oncilla.h b/src/Oncilla.h index 0ad52bd..1cf2015 100644 --- a/src/Oncilla.h +++ b/src/Oncilla.h @@ -1,81 +1,81 @@ /* * Oncilla.h * * Created on: 15 dec. 2011 * Author: Alexandre Tuleu, Arne Nordmann */ #pragma once #include #include #include namespace rci { namespace oncilla { class Oncilla; typedef std::tr1::shared_ptr OncillaPtr; class OncillaSynchronizer; typedef std::tr1::shared_ptr OncillaSynchronizerPtr; class OncillaTrunk; typedef std::tr1::shared_ptr OncillaTrunkPtr; class OncillaL0; typedef std::tr1::shared_ptr OncillaL0Ptr; class OncillaL1L2; typedef std::tr1::shared_ptr OncillaL1Ptr; typedef std::tr1::shared_ptr OncillaL2Ptr; class OncillaL3; typedef std::tr1::shared_ptr OncillaL3Ptr; class OncillaL4; typedef std::tr1::shared_ptr OncillaL4Ptr; class Oncilla { public: enum Leg { LEFT_FORE = 0, RIGHT_FORE = 1, LEFT_HIND = 2, RIGHT_HIND = 3, NUM_LEGS = 4 }; static const std::string & nameOfLeg(Leg l); Oncilla(); virtual ~Oncilla(); OncillaL0Ptr getL0(Leg l) const; OncillaL1Ptr getL1(Leg l) const; OncillaL2Ptr getL2(Leg l) const; OncillaL3Ptr getL3(Leg l) const; OncillaL4Ptr getL4(Leg l) const; OncillaTrunkPtr getTrunk() const; OncillaSynchronizerPtr getSynchronizer() const; private: typedef std::vector LegNames; static LegNames s_legNames; void init(); - OncillaSynchronizerPtr d_synchronizer; + static OncillaSynchronizerPtr s_synchronizer; std::vector d_L0s; std::vector d_L1s; std::vector d_L2s; std::vector d_L3s; std::vector d_L4s; OncillaTrunkPtr d_trunk; }; } } diff --git a/src/OncillaSynchronizer.cpp b/src/OncillaSynchronizer.cpp index 9fbddba..c38f093 100644 --- a/src/OncillaSynchronizer.cpp +++ b/src/OncillaSynchronizer.cpp @@ -1,40 +1,23 @@ #include "OncillaSynchronizer.h" #include using namespace std; namespace rci { namespace oncilla { OncillaSynchronizer::OncillaSynchronizer(const std::string &sname) - : Synchronizer(sname) - , d_mode(INTERNAL){ + : Synchronizer(sname){ } OncillaSynchronizer::~OncillaSynchronizer() { } double OncillaSynchronizer::latestProcessLoopDuration() const { - if(d_mode == EXTERNAL){ - throw std::runtime_error("If synchronization is external," - "I am not aware of any time!"); - } return latestProcessLoopDurationPrimpl(); } -OncillaSynchronizer::Synchronization OncillaSynchronizer::synchronizationMode() const { - return d_mode; -} - -void OncillaSynchronizer::setSynchronizationMode(Synchronization s){ - if (s == d_mode){ - return; - } - d_mode = s; - this->switchToSynchronizationModeHook(); -} - } } diff --git a/src/OncillaSynchronizer.h b/src/OncillaSynchronizer.h index 8a9cb80..5d376f8 100644 --- a/src/OncillaSynchronizer.h +++ b/src/OncillaSynchronizer.h @@ -1,98 +1,86 @@ #pragma once #include #include #include #include #include "Oncilla.h" namespace rci { namespace oncilla { class OncillaSynchronizer; typedef std::tr1::shared_ptr OncillaSynchronizerPtr; class OncillaTrunk; typedef std::tr1::shared_ptr OncillaTrunkPtr; class OncillaL0; typedef std::tr1::shared_ptr OncillaL0Ptr; class OncillaL1L2; typedef std::tr1::shared_ptr OncillaL1Ptr; typedef std::tr1::shared_ptr OncillaL2Ptr; class OncillaL3; typedef std::tr1::shared_ptr OncillaL3Ptr; class OncillaL4; typedef std::tr1::shared_ptr OncillaL4Ptr; /** * OncillaSynchronizer * Different OncillaSynchronizers may be for example: * * Update with a given frequency * ** Send data every time * ** Send only if new data * * Update only if new data (event-based) * * Triggered from robot side (e.g. FRI) */ class OncillaSynchronizer: public Synchronizer { public: - enum Synchronization { - INTERNAL, - EXTERNAL - }; OncillaSynchronizer(const std::string &name); virtual ~OncillaSynchronizer(); /** * Registers a trunk node. */ virtual void registerTrunkNode(OncillaTrunkPtr node) = 0; /** * Registers an L0 node. */ virtual void registerL0Node(Oncilla::Leg l, OncillaL0Ptr node) = 0; /** * Registers an L1 node. */ virtual void registerL1Node(Oncilla::Leg l, OncillaL1Ptr node) = 0; /** * Registers an L2 node. */ virtual void registerL2Node(Oncilla::Leg l, OncillaL2Ptr node) = 0; /** * Registers an L3 node. */ virtual void registerL3Node(Oncilla::Leg l, OncillaL3Ptr node) = 0; /** * Registers an L4 node. */ virtual void registerL4Node(Oncilla::Leg l, OncillaL4Ptr node) = 0; /** * */ friend std::ostream & operator<<(std::ostream& os, const OncillaSynchronizer& val); double latestProcessLoopDuration() const; - Synchronization synchronizationMode() const; - - void setSynchronizationMode(Synchronization s); - protected : virtual double latestProcessLoopDurationPrimpl() const = 0; - - virtual void switchToSynchronizationModeHook() = 0; - - Synchronization d_mode; }; } }