renamed publish() and connectToDevice() into more specific...

renamed publish() and connectToDevice() into more specific feedToControlSystem()/consumeFromControlSyste() and feedToDevice()/consumeFromDevice()

example/demoApp.cc

@@ -73,7 +73,7 @@ class SimulatorModule : public ctk::ApplicationModule {
 
       while(true) {
         actuator.read();
-        readback = (100*lastValue + actuator)/101.;
+        readback = (100*lastValue + actuator)/100.;
         lastValue = readback;
         std::cout << "SimulatorModule: actuator = " << actuator << std::endl;
         std::cout << "SimulatorModule: readback = " << readback << std::endl;
@@ -96,17 +96,21 @@ class MyApp : public ctk::Application {
     void initialise() {
       mtca4u::BackendFactory::getInstance().setDMapFilePath("dummy.dmap");
 
-      automation.operatorSetpoint.publish("MyLocation/setpoint");
+      automation.operatorSetpoint.consumeFromControlSystem("MyLocation/setpoint");
       automation.loopSetpoint.connectTo(controlLoop.setpoint);
+      automation.loopSetpoint.feedToControlSystem("MyLocation/setpoint_automation");
+
+      controlLoop.actuator.feedToDevice("Dummy0","/MyModule/Variable", ctk::UpdateMode::poll);
+      controlLoop.actuator.feedToControlSystem("MyLocation/actuatorLoop");
+
+      simulator.actuator.consumeFromDevice("Dummy0","/MyModule/Variable", ctk::UpdateMode::poll);
+      //simulator.actuator.feedToControlSystem("MyLocation/actuatorSimulator"); // not allowed, since simulator.actuator consuming
 
-      controlLoop.actuator.connectToDevice("Dummy0","/MyModule/Variable", ctk::UpdateMode::poll);
-      simulator.actuator.connectToDevice("Dummy0","/MyModule/Variable", ctk::UpdateMode::poll);
-      controlLoop.actuator.publish("MyLocation/actuatorLoop");
-      //simulator.actuator.publish("MyLocation/actuatorSimulator"); // not allowed, since this would create a feeding publication
       publishDeviceReadRegister<double>("Dummy0","/MyModule/Variable", ctk::UpdateMode::poll, "MyLocation/actuatorSimulator");
 
       simulator.readback.connectTo(controlLoop.readback);
-      simulator.readback.publish("MyLocation/readback");
+      simulator.readback.feedToControlSystem("MyLocation/readback");
+      simulator.readback.feedToControlSystem("MyLocation/readback_another_time");
     }
 
     virtual ~MyApp() {};

include/Accessor.h

@@ -67,12 +67,17 @@ namespace ChimeraTK {
       template< typename UserType_o >
       void connectTo(Accessor<UserType_o> &targetAccessor);
 
-      /** Publish the variable to the control system under the given name */
-      void publish(const std::string& name);
+      /** Publish the variable to the control system as a control-system-to-application variable under the given name */
+      void consumeFromControlSystem(const std::string& name);
 
-      /** Connect variable to a device register */
-      void connectToDevice(const std::string &deviceAlias, const std::string &registerName,
-          UpdateMode mode);
+      /** Publish the variable to the control system as a application-to-control-system variable under the given name */
+      void feedToControlSystem(const std::string& name);
+
+      /** Connect variable to a device register and request that the variable will "consume" data from the register. */
+      void consumeFromDevice(const std::string &deviceAlias, const std::string &registerName, UpdateMode mode);
+
+      /** Connect variable to a device register and request that the variable will "feed" data to the register.*/
+      void feedToDevice(const std::string &deviceAlias, const std::string &registerName, UpdateMode mode);
 
       virtual bool isFeeding();
 
@@ -110,8 +115,21 @@ namespace ChimeraTK {
   /*********************************************************************************************************************/
 
   template< typename UserType >
-  void Accessor<UserType>::publish(const std::string& name) {
-    Application::getInstance().publishAccessor(*this, name);
+  void Accessor<UserType>::feedToControlSystem(const std::string& name) {
+    assert( _direction == VariableDirection::feeding );
+    VariableNetwork &network = Application::getInstance().findOrCreateNetwork(this);
+    network.addAppNode(*this);
+    network.addConsumingPublication(name);
+  }
+
+  /*********************************************************************************************************************/
+
+  template< typename UserType >
+  void Accessor<UserType>::consumeFromControlSystem(const std::string& name) {
+    assert( _direction == VariableDirection::consuming );
+    VariableNetwork &network = Application::getInstance().findOrCreateNetwork(this);
+    network.addAppNode(*this);
+    network.addFeedingPublication(*this,name);
   }
 
   /*********************************************************************************************************************/
@@ -124,9 +142,23 @@ namespace ChimeraTK {
   /*********************************************************************************************************************/
 
   template< typename UserType >
-  void Accessor<UserType>::connectToDevice(const std::string &deviceAlias, const std::string &registerName,
+  void Accessor<UserType>::consumeFromDevice(const std::string &deviceAlias, const std::string &registerName,
+      UpdateMode mode) {
+    assert( _direction == VariableDirection::consuming );
+    VariableNetwork &network = Application::getInstance().findOrCreateNetwork(this);
+    network.addAppNode(*this);
+    network.addFeedingDeviceRegister(*this, deviceAlias, registerName, mode);
+  }
+
+  /*********************************************************************************************************************/
+
+  template< typename UserType >
+  void Accessor<UserType>::feedToDevice(const std::string &deviceAlias, const std::string &registerName,
       UpdateMode mode) {
-    Application::getInstance().connectAccessorToDevice(*this, deviceAlias, registerName, mode);
+    assert( _direction == VariableDirection::feeding );
+    VariableNetwork &network = Application::getInstance().findOrCreateNetwork(this);
+    network.addAppNode(*this);
+    network.addConsumingDeviceRegister(deviceAlias, registerName, mode);
   }
 
 } /* namespace ChimeraTK */

include/Application.h

@@ -87,13 +87,6 @@ namespace ChimeraTK {
       /** Register a connection between two Accessors */
       void connectAccessors(AccessorBase &a, AccessorBase &b);
 
-      /** Register an accessor to be published under the given name to the control system adapter */
-      void publishAccessor(AccessorBase &a, const std::string& name);
-
-      /** Register a connection of an accessor to a device register */
-      void connectAccessorToDevice(AccessorBase &a, const std::string &deviceAlias,
-          const std::string &registerName, UpdateMode mode);
-
       /** Register a connection between a device read-only register and the control system adapter */
       template<typename UserType>
       void publishDeviceReadRegister(const std::string &deviceAlias, const std::string &registerName, UpdateMode mode,

src/Application.cc

@@ -60,33 +60,6 @@ void Application::connectAccessors(AccessorBase &a, AccessorBase &b) {
 
 /*********************************************************************************************************************/
 
-void Application::publishAccessor(AccessorBase &a, const std::string& name) {
-  VariableNetwork &network = findOrCreateNetwork(&a);
-  network.addAppNode(a);
-  if(a.isFeeding()) {
-    network.addConsumingPublication(name);
-  }
-  else {
-    network.addFeedingPublication(a,name);
-  }
-}
-
-/*********************************************************************************************************************/
-
-void Application::connectAccessorToDevice(AccessorBase &a, const std::string &deviceAlias,
-    const std::string &registerName, UpdateMode mode) {
-  VariableNetwork &network = findOrCreateNetwork(&a);
-  network.addAppNode(a);
-  if(a.isFeeding()) {
-    network.addConsumingDeviceRegister(deviceAlias, registerName, mode);
-  }
-  else {
-    network.addFeedingDeviceRegister(a, deviceAlias, registerName, mode);
-  }
-}
-
-/*********************************************************************************************************************/
-
 template<typename UserType>
 boost::shared_ptr<mtca4u::ProcessVariable> Application::createDeviceAccessor(const std::string &deviceAlias,
     const std::string &registerName, VariableDirection direction, UpdateMode mode) {