#include <float.h> // for fabs
#include <hardware_access.h> // This is for setRotateDir/setDuty/getVoltage/VOLT2OMEGA
 
class Motor {
  private:
    bool m_CCW;
  public:
    Motor(): m_CCW(false) {}
 
    ~Motor() {}
 
    void setCCW(const bool CCW) { m_CCW = CCW; }    
 
    void setRotateDirection(const bool CW) {
      if ((CW &amp;&amp; !m_CCW) || (!CW &amp;&amp; m_CCW)) {
        ::setRotateDir(1); // CW
      } else {
        ::setRotateDir(0); // CCW
    }
 
    void setPWMDuty(const double ratio) {
      if (ratio &lt; 0) { setRotateDirection(false); // CCW }
      else { setRotateDirection(true); // CW }
      ::setDuty( fabs(ratio) );
    }
 
    double getRotateVelocity() {
      double voltage = ::getVoltage(); // Voltage of PotentioMeter
      return voltage * VOLT2OMEGA;
    }
};

import math
import hardware_access # This is for setRotateDir/setDuty/getVoltage/VOLT2OMEGA
 
class Motor:
  def __init__(self):
    self._CCW = false
    pass
 
  def setCCW(self, ccw):
    self._CCW= ccw
    pass
 
  def setRotateDirection(self, cw):
    if (cw and (not self._CCW)) or ((not cw) and self._CCW): # EXOR
      hardware_access.setRotateDir(1) # CW
    else:
      hardware_access.setRotateDir(0) # CCW
    pass
 
  def setPWMDuty(self, ratio):
    if ratio < 0: 
      self.setRotateDirection(false) # CCW
    else:
      self.setRotateDirection(true) # CW
    hardware_access.setDuty( math.abs(ratio) )
    pass
 
  def getRotateVelocity(self):
    voltage_ = hardware_access.getVoltage() # Voltage of PotentioMeter
    return voltage_ * hardware_access.VOLT2OMEGA

import Math;
import HardwareAccess;
 
class Motor {
  private boolean m_CCW;
 
  public Motor() {
    m_CCW = false;
  }
 
  public void setCCW(boolean CCW) { 
    m_CCW = CCW;
  }    
 
  public void setRotateDirection(boolean CW) {
    if ((CW && !m_CCW) || (!CW && m_CCW)) { // EXOR
      HardwareAccess.setRotateDir(1); // CW
    } else {
      HardwareAccess.setRotateDir(0); // CCW
  }
 
  public void setPWMDuty(const double ratio) {
    if (ratio < 0) { 
      HardwareAccess.setRotateDirection(false); // CCW 
    }
    else { 
      setRotateDirection(true); // CW 
    }
    HardwareAccess.setDuty( Math.abs(ratio) );
  }
 
  public double getRotateVelocity() {
    double voltage = HardwareAccess.getVoltage(); // Voltage of PotentioMeter
    return voltage * HardwareAccess.VOLT2OMEGA;
  }
};

#include "motor.h"
 
class TwoWheelMobileRobot {
  private:
    Motor m_RightMotor;
    Motor m_LeftMotor;
  public:
    TwoWheelMobileRobot() {
      m_LeftMotor.setCCW(true);
    }
 
    ~TwoWheelMobileRobot() {}
 
    void moveForwared(const double ratio) {
      m_RightMotor.setPWMDuty(ratio);
      m_LeftMotor.setPWMDuty(ratio);
    }
 
    void rotate(const double ratio) {
      m_RightMotor.setPWMDuty(ratio);
      m_LeftMotor.setPWMDuty(-ratio);
    }
};

import motor
 
class TwoWheelMobileRobot:
  def __init__(self):
    self._rightMotor = motor.Motor()
    self._leftMotor = motor.Motor()
    self._leftMotor.setCCW(True)
    pass
 
  def moveForward(self, ratio):
    self._rigthMotor.setPWMDuty(ratio)
    self._leftMotor.setPWMDuty(ratio)
 
  def rotate(self, ratio):
    self._rightMotor.setPWMDuty(ratio)
    self._leftMotor.setPWMDuty(-ratio)

import Motor;
 
class TwoWheelMobileRobot {
  private Motor m_RightMotor;
  private Motor m_LeftMotor;
  public TwoWheelMobileRobot() {
    m_LeftMotor.setCCW(true);
  }
 
  public void moveForwared(const double ratio) {
    m_RightMotor.setPWMDuty(ratio);
    m_LeftMotor.setPWMDuty(ratio);
  }
 
  public void rotate(const double ratio) {
    m_RightMotor.setPWMDuty(ratio);
    m_LeftMotor.setPWMDuty(-ratio);
  }
}

#include "twowheelrobot.h"
#include <windows.h> // For Sleep
int main(void) {
  auto robot = new TwoWheelMobileRobot();
 
  robot->moveForward(1.0);
  Sleep(1000); // [ms]
  robot->rotate(1.0);
  Sleep(1000); // [ms]
  robot->moveForward(0.0); // Stop
  return 0;
}

import twowheelmobilerobot
import time
def main():
  robot = TwoWheelMobileRobot()
  robot.moveForward(1.0)
  time.sleep(1.0)
  robot.rotate(1.0)
  time.sleep(1.0)
  robot.moveForward(0.0)
  pass
 
if __name__ == '__main__':
  main()

import TwoWheelMobileRobot;
import Thread;
 
class Main {
 
  public static void main(String[] args) {
    try {
      TwoWheelMobileRobot robot = new TwoWheelMobileRobot();
      robot.moveForward(1.0);
      Thread.sleep(1000); // [ms]
      robot.rotate(1.0);
      Thread.sleep(1000); // [ms]
      robot.moveForward(0.0);
    } catch (InterruptedException ex) {
      System.out.println("Exception: " + ex);
    }
  }
}

#include <rtm/basicdatatypeskel.h>
#include <rtm/manager.h>
#include <rtm/dataflowcomponentbase.h>
#include <rtm/corbaport.h>
#include <rtm/datainport.h>
#include <rtm/dataoutport.h>
 
using namespace RTC;
 
boolean initialized; // Global Variable
double old_data; // Global Variable
 
class TestRTC
  : public RTC::DataFlowComponentBase
{
public:
  TestRTC(RTC::Manager* manager): 
    m_inIn("in", m_in), m_outOut("out", m_out) {}
  virtual ~TestRTC() {}
  virtual RTC::ReturnCode_t onInitialize() {省略}
  virtual RTC::ReturnCode_t onActivated(RTC::UniqueId ec_id) {
    initialized = false;
    return RTC::RTC_OK;
  }
 
  virtual RTC::ReturnCode_t onExecute(RTC::UniqueId ec_id) {
    if (m_inIn.isNew()) { // データが来ていれば
      m_inIn.read();      // 読み込んで
      if (initialized) {  // もし最初のデータが来ていればold_dataが使えるので
        m_out.data = m_in.data - old_data; // 差分を計算する
        setTimestamp<rtc::timeddouble>(m_out);
        m_outOut.write();   // 出力する
      }
      old_data = m_in.data; // 受信したデータをold_dataに保存しておく
      initialized = true;   // 初期化されましたよーというフラグを立てる
    }
    return RTC::RTC_OK;
  }
private:
  RTC::TimedDouble m_in;
  RTC::InPort<rtc::timeddouble> m_inIn;
  RTC::TimedDouble m_out;
  RTC::InPort<rtc::timeddouble> m_inIn;
};

import sys
import time
sys.path.append(".")
 
import RTC
import OpenRTM_aist
 
・・・省略・・・
 
initialized = False # グローバル変数
old_data = 0 # グローバル変数
 
class TestRTC(OpenRTM_aist.DataFlowComponentBase):
 
  def __init__(self, manager):
    OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
 
    self._d_in = RTC.TimedLong(RTC.Time(0, 0), 0)
    self._inIn = OpenRTM_aist.InPort("in", self._d_in)
    self._d_out = RTC.TimedLong(RTC.Time(0, 0), 0)
    self._outOut = OpenRTM_aist.OutPort("out", self._d_out)
 
  def onInitialize(self):
    self.addInPort("in", self._inIn)
    self.addOutPort("out", self._outOut)
    return RTC.RTC_OK
 
  def onActivated(self, ec_id):
    initialized = False
    return RTC.RTC_OK
 
  def onExecute(self, ec_id):
    global old_data, initialized # これからグローバル変数つかうよー宣言
    if m_inIn.isNew():           # データが来ていれば
      m_in = m_inIn.read()       # 受信して
      if initialized:            # もし初期化フラグが立っていれば
        m_out.data = m_in.data - old_data # 差分を計算して
        m_out.write()            # 出力
      old_data = m_in.data       # 現在受信したデータをold_dataに格納して
      initialized = True         # 初期化されましたよーフラグを立てる
      return RTC.RTC_OK

#include <basicdatatypeskel.h>
#include <rtm/manager.h>
#include <rtm/dataflowcomponentbase.h>
#include <rtm/corbaport.h>
#include <rtm/datainport.h>
#include <rtm/dataoutport.h>
 
using namespace RTC;
 
 
class TestRTC
  : public RTC::DataFlowComponentBase
{
public:
  TestRTC(RTC::Manager* manager): 
    m_inIn("in", m_in), m_outOut("out", m_out) {}
  virtual ~TestRTC() {}
  virtual RTC::ReturnCode_t onInitialize() {省略}
  virtual RTC::ReturnCode_t onActivated(RTC::UniqueId ec_id) {
    m_initialized = false;
    return RTC::RTC_OK;
  }
 
  virtual RTC::ReturnCode_t onExecute(RTC::UniqueId ec_id) {
    if (m_inIn.isNew()) { // データが来ていれば
      m_inIn.read();      // 読み込んで
      if (m_initialized) {  // もし最初のデータが来ていればold_dataが使えるので
        m_out.data = m_in.data - m_oldData; // 差分を計算する
        setTimestamp<rtc::timeddouble>(m_out);
        m_outOut.write();   // 出力する
      }
      m_oldData = m_in.data; // 受信したデータをold_dataに保存しておく
      m_initialized = true;   // 初期化されましたよーというフラグを立てる
    }
    return RTC::RTC_OK;
  }
private:
  RTC::TimedDouble m_in;
  RTC::InPort<rtc::timeddouble> m_inIn;
  RTC::TimedDouble m_out;
  RTC::InPort<rtc::timeddouble> m_inIn;
 
  boolean m_initialized; // Member Variable
  double m_oldData; // Member Variable
};

import sys
import time
sys.path.append(".")
 
import RTC
import OpenRTM_aist
 
・・・省略・・・
 
 
class TestRTC_py(OpenRTM_aist.DataFlowComponentBase):
 
  def __init__(self, manager):
    OpenRTM_aist.DataFlowComponentBase.__init__(self, manager)
 
    self._d_in = RTC.TimedLong(RTC.Time(0, 0), 0)
    self._inIn = OpenRTM_aist.InPort("in", self._d_in)
    self._d_out = RTC.TimedLong(RTC.Time(0, 0), 0)
    self._outOut = OpenRTM_aist.OutPort("out", self._d_out)
 
 
    self._initialized = False # メンバ変数
    self._oldData = 0 # メンバ変数
 
  def onInitialize(self):
    self.addInPort("in", self._inIn)
    self.addOutPort("out", self._outOut)
    return RTC.RTC_OK
 
  def onActivated(self, ec_id):
    self._initialized = False
    return RTC.RTC_OK
 
  def onExecute(self, ec_id):
    if m_inIn.isNew():           # データが来ていれば
      m_in = m_inIn.read()       # 受信して
      if self._initialized:            # もし初期化フラグが立っていれば
        m_out.data = m_in.data - self._oldData # 差分を計算して
        m_out.write()            # 出力
      self._oldData = m_in.data       # 現在受信したデータをold_dataに格納して
      self._initialized = True         # 初期化されましたよーフラグを立てる
      return RTC.RTC_OK