Raspberry Pi Mouse (以下ラズパイマウス) はアールティが販売している二輪方式の移動ロボットです。 Raspberry Pi を搭載しているため Linux (Raspbian) 等での開発が可能です。
このドキュメントではラズパイマウスでの OpenRTM-aist の利用方法等を紹介します。
ラズパイマウスの仕様 | |
CPU | Raspberry Pi 2 Model B |
モーター | ステッピングモーターST-42BYG020 2個 |
モータードライバー | SLA7070MRPT 2個 |
距離センサー | 赤色LED+フォトトランジスタ(ST-1K3) 4個 |
モニター用赤色LED | 4個 |
ブザー | 1個 |
スイッチ | 3個 |
バッテリー | LiPo3セル(11.1V)1000mAh 1個 |
このページでは RTM講習会での Raspberry Pi Mouse 操作手順を説明します。
Raspberry Pi Mouse (以下ラズパイマウス)はアールティが販売している二輪方式の移動ロボットです。 Raspberry Pi を搭載しているため Linux(Raspbian) 等での開発が可能です。
ラズパイマウスの仕様 | |
CPU | Raspberry Pi 2 Model B |
モーター | ステッピングモーターST-42BYG020 2個 |
モータードライバ | SLA7070MRPT 2個 |
距離センサー | 赤色LED+フォトトランジスタ(ST-1K3) 4個 |
モニター用赤色LED | 4個 |
ブザー | 1個 |
スイッチ | 3個 |
バッテリー | LiPo3セル(11.1V)1000mAh 1個 |
最初に PC側で使用する RTC 等をダウンロードしてください。
ZIPファイルを Lhaplus 等で展開してください。
内側のスイッチが Raspberry Pi の電源スイッチです。 このスイッチをオンにすると電源が投入できます。
電源を切る場合は真ん中のスイッチを1秒ほど押すと OS がシャットダウンするため、その後にスイッチを切ってください。
※スイッチを直接切るのはデータの破損などの危険があるため絶対にやらないでください。
Raspberry Pi へは原則として無線LANで接続するようにしてください。
まずは無線LANアダプタを取り付けた状態で Raspberry Pi Mouse の電源スイッチをオンにしてください。
しばらくすると無線LANアクセスポイントが起動するので、指定の SSID のアクセスポイントに接続してください。
SSID、パスワードは Rasoberry Pi マウスに貼り付けたシールに記載してあります。
アクセスポイントへの接続方法は以下のページを参考にしてください。
まず右下のネットワークアイコンをクリックしてください。
以下の作業は有線で接続する場合の作業なので、無線で接続する場合は不要です。
まず最初にLANケーブルで PC と Raspberry Pi を接続してください。
このページ の手順に従ってネームサーバー、RTシステムエディタを起動してください。 予めネームサーバーを起動してある場合は再起動してください。
またネットワークインターフェースが2つ以上ある場合に通信に失敗する可能性があるため、有線で接続した場合は他のネットワークデバイスを無効にしてからネームサーバーを起動してください。
続いて RTシステムエディタの [ネームサーバー追加] ボタンをクリックして 192.168.11.1 を追加してください。
すると以下の2つの RTC が起動します。
RaspberryPiMouseRTC は名城大学のロボットシステムデザイン研究室で開発されているラズパイマウス制御用の RTコンポーネントです。
RaspberryPiMouseRTC | ||
InPort | ||
名前 | データ型 | 説明 |
target_velocity_in | RTC::TimedVelocity2D | 目標速度 |
pose_update_in | RTC::TimedPose2D | 位置設定 |
buzzer_hz_in | RTC::TimedShort | ブザー |
led4bit_in | RTC::TimedBooleanSeq | LED |
OutPort | ||
名前 | データ型 | 説明 |
current_velocity_out | RTC::TimedVelocity2D | 現在の速度 |
current_pose_out | RTC::TimedPose2D | 現在位置 |
ir_sensor_out | RTC::TimedShortSeq | 距離センサーの計測値 |
switch3bit_out | RTC::TimedBooleanSeq | スイッチのオンオフ |
TimedVelocity2D 型は以下のように定義されています。
struct Velocity2D { double vx; double vy; double va; };
struct TimedVelocity2D { Time tm; Velocity2D data; };
vx、vy、va はロボット中心座標系での速度を表しています。
ラズパイマウスのように2個の車輪が左右に取り付けられているロボットの場合、横滑りしないと仮定すると vy は 0 になります。
vx、va を指定することでロボットの操作を行います。
付属資料のstart_component_raspimouse.batを起動してください。 ※OpenRTM-aist Python版をインストールしていない場合、もしくはインストールに失敗している場合は個別に実行ファイル入りの USBメモリーを配布しますので、start_component_raspimouse_exe.batを利用してください。
すると以下の2つの RTC が起動します。
まずはジョイスティックでラズパイマウスを操作してみます。
動作の前にモーター電源スイッチをオンにしておいてください。動作確認が終了したら、モーター電源はオフにするようにしてください。
RTシステムエディタで RaspberryPiMouseRTC、FloatSeqToVelocity、TkJoyStick を以下のように接続します。
そして RTC をアクティブ化するとジョイスティックでラズパイマウスの操作ができるようになります。
まずは FloatSeqToVelocity の out と RaspberryPiMouseRTC の target_velocity_in のコネクタを切断してください。
FloatSeqToVelocity と RaspberryPiMouseRTC の間に自作の RTC を接続して、距離センサーの値が一定以上になった場合に停止して音を鳴らすようにします。
RTC ビルダを起動してください。
以下のように設定を行ってください。 C++、もしくは Python で作成します。
基本 | ||
モジュール名 | TestRasPiMouseCPP、もしくはTestRasPiMousePy | |
アクティビティ | ||
有効アクション | onInitialize、onExecute、onActivated、onDeactivated | |
データポート | ||
InPort | ||
名前 | データ型 | 説明 |
velocity_in | RTC::TimedVelocity2D | 入力目標速度 |
distance_sensor | RTC::TimedShortSeq | 距離センサーの計測値 |
OutPort | ||
名前 | データ型 | 説明 |
velocity_out | RTC::TimedVelocity2D | 出力目標速度 |
buzzer | RTC::TimedShort | ブザー |
コンフィギュレーション | ||
名前 | 型 | 説明 |
stop_distance | short | 距離センサーで物体を検知した場合に前進しなくなる距離センサーの計測値、デフォルト値は300 |
言語・環境 | ||
言語 | C++、もしくはPython |
[コード生成] ボタンをクリックするとコードが生成されます。
ラズパイマウスの距離センサーは近ければ近いほど大きな値を出力します。
参考までにですが、/dev/rtlightsensor0のデバイスファイルから取得できる数値とセンサーまでの距離との関係は以下のようになっています。
デバイスファイルから取得した数値 | 実際の距離[m] |
1394 | 0.01 |
792 | 0.02 |
525 | 0.03 |
373 | 0.04 |
299 | 0.05 |
260 | 0.06 |
222 | 0.07 |
181 | 0.08 |
135 | 0.09 |
100 | 0.10 |
81 | 0.15 |
36 | 0.20 |
17 | 0.25 |
16 | 0.30 |
コードが生成できたら C++ の場合は CMake で Visual Studio のプロジェクト(Ubuntu の場合は Code::Blocks)を生成してください。
まずCMake (cmake-gui) を起動します。
Where is the source code | RTCBuilder で生成したコードのフォルダー(C:\workspace\TestRasPiMouseCPP) |
Where to build the binaries | RTCBuilder で生成したコードのフォルダーの下に作成した build フォルダー(C:\workspace\TestRasPiMouseCPP\build) |
build ディレクトリーの TestRasPiMouseCPP.sln を開いてください。
次にコードの編集を行います。
Python の場合はまず変数の初期化部分を修正してください。
def __init__(self, manager): #self._d_velocity_in = RTC.TimedVelocity2D(*velocity_in_arg) self._d_velocity_in = RTC.TimedVelocity2D(RTC.Time(0,0),RTC.Velocity2D(0,0,0))
#self._d_distance_sensor = RTC.TimedShortSeq(*distance_sensor_arg) self._d_distance_sensor = RTC.TimedShortSeq(RTC.Time(0,0),[])
#self._d_velocity_out = RTC.TimedVelocity2D(*velocity_out_arg) self._d_velocity_out = RTC.TimedVelocity2D(RTC.Time(0,0),RTC.Velocity2D(0,0,0))
#self._d_buzzer = RTC.TimedShort(*buzzer_arg) self._d_buzzer = RTC.TimedShort(RTC.Time(0,0),0)
まずは onExecute で入力速度をそのまま出力するコードを書いてみます。
C++の場合は以下のようになります。
isNew 関数で新規の入力データが存在するかを確認して、read 関数で変数(m_velocity_in)に格納します。 そして m_velocity_out に出力データを格納してwrite 関数を呼び出すとデータが送信されます。
if (m_velocity_inIn.isNew()) { m_velocity_inIn.read(); //入力速度をそのまま出力 m_velocity_out.data.vx = m_velocity_in.data.vx; m_velocity_out.data.vy = m_velocity_in.data.vy; m_velocity_out.data.va = m_velocity_in.data.va; setTimestamp(m_velocity_out); m_velocity_outOut.write(); }
Pythonの場合は以下のようになります。
if self._velocity_inIn.isNew(): data = self._velocity_inIn.read() #入力速度をそのまま出力する self._d_velocity_out.data.vx = data.data.vx self._d_velocity_out.data.vy = data.data.vy self._d_velocity_out.data.va = data.data.va OpenRTM_aist.setTimestamp(self._d_velocity_out) self._velocity_outOut.write()
次に距離センサーの計測値が一定以上の場合に停止する処理を記述します。
常に距離センサーのデータが入力されるとは限らないので、センサーのデータを格納する変数を宣言します。
C++の場合は TestRasPiMouseCPP.h に記述します。
private: int m_last_sensor_data[4];
Pythonの場合はコンストラクタに記述します。
def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) self._last_sensor_data = [0, 0, 0, 0]
次に onExecute に停止する処理を記述します。
C++の場合は以下のようになっています。
まずインポート distance_sensor に isNew 関数で新規にデータが入力されたかを確認して、入力されている場合は read 関数で読み込みます。そして変数 m_last_sensor_data に格納します。
そしてインポート velocity_in で受信したデータの vx が0以上の場合には前進しているため障害物に接触するかもしれないと判定して、距離センサーの値が一定以上の場合は停止してブザーを鳴らします。
RTC::ReturnCode_t TestRasPiMouseCPP::onExecute(RTC::UniqueId ec_id) { //データを新規に受信した場合に、データを m_last_sensor_data を格納する if (m_distance_sensorIn.isNew()) { m_distance_sensorIn.read(); if (m_distance_sensor.data.length() == 4) { for (int i = 0; i < 4; i++) { m_last_sensor_data[i] = m_distance_sensor.data[i]; } } } if (m_velocity_inIn.isNew()) { m_velocity_inIn.read(); //vxが0以上(前進)のときのみ停止するか判定する if (m_velocity_in.data.vx > 0) { for (int i = 0; i < 4; i++) { //センサーの計測値がstop_distance以上の時に前進しないようにする if (m_last_sensor_data[i] > m_stop_distance) { //停止する m_velocity_out.data.vx = 0; m_velocity_out.data.vy = 0; m_velocity_out.data.va = 0; setTimestamp(m_velocity_out); m_velocity_outOut.write(); //ブザーを鳴らす m_buzzer.data = 50; setTimestamp(m_buzzer); m_buzzerOut.write(); return RTC::RTC_OK; } } } //ブザーを止める m_buzzer.data = 0; setTimestamp(m_buzzer); m_buzzerOut.write(); //入力速度をそのまま出力 m_velocity_out.data.vx = m_velocity_in.data.vx; m_velocity_out.data.vy = m_velocity_in.data.vy; m_velocity_out.data.va = m_velocity_in.data.va; setTimestamp(m_velocity_out); m_velocity_outOut.write(); } return RTC::RTC_OK; }
Pythonの場合は以下のようになっています。
def onExecute(self, ec_id): #データを新規に受信した場合に、データをm_last_sensor_dataを格納する if self._distance_sensorIn.isNew(): data = self._distance_sensorIn.read() if len(data.data) == 4: self._last_sensor_data = data.data[:] if self._velocity_inIn.isNew(): data = self._velocity_inIn.read() #vxが0以上(前進)のときのみ停止するか判定する if data.data.vx > 0: for d in self._last_sensor_data: #センサーの計測値がstop_distance以上の時に前進しないようにする if d > self._stop_distance[0]: #停止する self._d_velocity_out.data.vx = 0 self._d_velocity_out.data.vy = 0 self._d_velocity_out.data.va = 0 OpenRTM_aist.setTimestamp(self._d_velocity_out) self._velocity_outOut.write() #ブザーを鳴らす self._d_buzzer.data = 50 OpenRTM_aist.setTimestamp(self._d_buzzer) self._buzzerOut.write() return RTC.RTC_OK #ブザーを止める self._d_buzzer.data = 0 OpenRTM_aist.setTimestamp(self._d_buzzer) self._buzzerOut.write() #入力速度をそのまま出力する self._d_velocity_out.data.vx = data.data.vx self._d_velocity_out.data.vy = data.data.vy self._d_velocity_out.data.va = data.data.va OpenRTM_aist.setTimestamp(self._d_velocity_out) self._velocity_outOut.write() return RTC.RTC_OK
コードの編集が終わったら C++ の場合はビルドしてください。
ビルドに成功すると build\src\Release(Debug) に TestRasPiMouseCPPComp.exe が生成されます。
TestRasPiMouseCPPComp.exe (TestRasPiMouseCPPComp.py) をダブルクリックして起動してください。
TestRaspiMouseCPP (TestRaspiMousePy) を以下のように接続してください。
最後に RTC をアクティブ化して動作確認してください。
RTシステムを保存する場合は System Diagram 上で右クリックして [Save As...] を選択してください。
復元する場合は [Open and Restore] を選択して、先ほど保存したファイルを選択してください。
RTC を終了する場合はRTシステムエディタ上で RTC を [exit] してください。
このページではシミュレーター上の Raspberry Pi マウスを操作するためのコンポーネントの作成手順を説明します。
まずは資料をダウンロードしてください。
ZIPファイルは Lhaplus 等で展開してください。
インターネットに接続できない環境で講習会を実施している場合がありますので、その場合は配布のUSBメモリーに入れてあります。
シミュレーターは Open Dynamics Engine(ODE) という物理演算エンジンと ODE 付属の描画ライブラリ(drawstuff)を使用して開発しています。 OpenGL が動作すれば動くので、大抵の環境で動作するはずです。
以下の Raspberry Piマウス というロボットのシミュレーションができます。
シミュレーター上の Raspberry Pi マウスの動力学計算、接触応答だけではなく、距離センサーのデータも現実のロボットに近い値を再現するようにしています。
Raspberry Piマウスはアールティが販売している独立二輪駆動型の移動ロボットです。
ラズパイマウスの仕様 | |
CPU | Raspberry Pi 2 Model B |
モーター | ステッピングモーターST-42BYG020 2個 |
モータードライバー | SLA7070MRPT 2個 |
距離センサー | 赤色LED+フォトトランジスタ(ST-1K3) 4個 |
モニター用赤色LED | 4個 |
ブザー | 1個 |
スイッチ | 3個 |
バッテリー | LiPo3セル(11.1V)1000mAh 1個 |
RaspberryPiMouseSimulator コンポーネントと接続してシミュレーター上のロボットを操作するためのコンポーネントです。
GUI(スライダー)によりシミュレーター上のロボットの操作を行い、センサー値が一定以上の時には自動的に停止するコンポーネントの作成を行います。
作成手順は以下の通りです。
以下の環境を想定しています。
RobotController は目標速度を出力するアウトポート、センサー値を入力するインポート、目標速度や停止するセンサー値を設定するコンフィギュレーションパラメーターを持っています。
コンポーネント名称 | RobotController |
InPort | |
ポート名 | in |
型 | TimedShortSeq |
説明 | センサー値 |
OutPort | |
ポート名 | out |
型 | TimedVelocity2D |
説明 | 目標速度 |
Configuration | |
パラメーター名 | speed_x |
型 | double |
デフォルト値 | 0.0 |
制約 | -1.5<x<1.5 |
Widget | slider |
Step | 0.01 |
説明 | 直進速度の設定 |
Configuration | |
パラメーター名 | speed_r |
型 | double |
デフォルト値 | 0.0 |
制約 | -2.0<x<2.0 |
Widget | slider |
Step | 0.01 |
説明 | 回転速度の設定 |
Configuration | |
パラメーター名 | stop_d |
型 | int |
デフォルト値 | 30 |
説明 | 停止するセンサー値の設定 |
2次元平面上の移動ロボットの移動速度を格納するデータ型である TimedVelocity2D 型を使用します。
struct Velocity2D { /// Velocity along the x axis in metres per second. double vx; /// Velocity along the y axis in metres per second. double vy; /// Yaw velocity in radians per second. double va; }; struct TimedVelocity2D { Time tm; Velocity2D data; };
このデータ型にはX軸方向の速度vx、Y軸方向の速度vy、Z軸周りの回転速度vaが格納できます。
vx、vy、vaはロボット中心座標系での速度を表しています。
Raspberry Pi マウスのように2個の車輪が左右に取り付けられているロボットの場合、横滑りしないと仮定するとvyは0になります。
直進速度vx、回転速度vaを指定することでロボットの操作を行います。
Raspberry Pi マウスの距離センサーのデータは物体との距離が近づくほど大きな値を出力するようになっています。
デバイスファイルから取得した数値 | 実際の距離[m] |
1394 | 0.01 |
792 | 0.02 |
525 | 0.03 |
373 | 0.04 |
299 | 0.05 |
260 | 0.06 |
222 | 0.07 |
181 | 0.08 |
135 | 0.09 |
100 | 0.10 |
81 | 0.15 |
36 | 0.20 |
17 | 0.25 |
16 | 0.30 |
シミュレーターではこの値を再現して出力しています。 RobotController コンポーネントではこの値が一定以上の時に自動的に停止する処理を実装します。
RobotController コンポーネントの雛型の生成は、RTCBuilder を用いて行います。
OpenRTP では、各種作業を行うフォルダーを「ワークスペース」(Work Space)とよび、原則としてすべての生成物はこのフォルダーの下に保存されます。
まずは OpenRTP を起動します。
デスクトップのショートカットをダブルクリックして起動してください。
すると、以下のようなWelcomeページが表示されます。
Welcomeページはいまは必要ないので左上の「×」ボタンをクリックして閉じてください。
右上の [Open Perspective] ボタンをクリックしてください。
「RTC Builder」を選択することで、RTCBuilder が起動します。メニューバーに「カナヅチとRT」の RTCBuilder のアイコンが表示されます。
RobotController コンポーネントを作成するために、RTC Builder で新規プロジェクトを作成する必要があります。
左上の [Open New RTCBuilder Editor] のアイコンをクリックしてください。
「プロジェクト名」欄に作成するプロジェクト名 (ここでは RobotController) を入力して [終了] ボタンをクリックします。
指定した名称のプロジェクトが生成され、パッケージエクスプローラ内に追加されます。
生成したプロジェクト内には、デフォルト値が設定された RTC プロファイル XML(RTC.xml) が自動的に生成されます。
RTC.xml が生成された時点で、このプロジェクトに関連付けられているワークスペースとして RTCBuilder のエディタが開くはずです。 もし起動しない場合はパッケージエクスプローラーの RTC.xml をダブルクリックしてください。
まず、いちばん左の「基本」タブを選択し、基本情報を入力します。先ほど決めた RobotController コンポーネントの仕様(名前)の他に、概要やバージョン等を入力してください。 ラベルが赤字の項目は必須項目です。その他はデフォルトで構いません。
次に、「アクティビティ」タブを選択し、使用するアクションコールバックを指定します。
RobotController コンポーネントでは、onActivated()、onDeactivated()、onExecute() コールバックを使用します。下図のように①の onAtivated をクリック後に②のラジオボタンにて [ON] にチェックを入れます。 onDeactivated、onExecute についても同様の手順を行います。
さらに、「データポート」タブを選択し、データポートの情報を入力します。 先ほど決めた仕様を元に以下のように入力します。なお、変数名や表示位置はオプションで、そのままで結構です。
次に、「コンフィギュレーション」タブを選択し、先ほど決めた仕様を元に、Configuration の情報を入力します。 制約条件および Widget とは、RTSystemEditor でコンポーネントのコンフィギュレーションパラメーターを表示する際に、スライダー、スピンボタン、ラジオボタンなど、GUI で値の変更を行うためのものです。
直進速度 speed_x、回転速度 speed_r はスライダーのより操作できるようにします。
次に、「言語・環境」タブを選択し、プログラミング言語を選択します。 ここでは、C++(言語)を選択します。なお、言語・環境はデフォルト等が設定されておらず、指定し忘れるとコード生成時にエラーになりますので、必ず言語の指定を行うようにしてください。
最後に、「基本」タブにあ [コード生成] ボタンをクリックし、コンポーネントの雛型を生成します。
プロジェクトを右クリックして、「表示方法」→「システム・エクスプローラー」を選択するとワークスペースをエクスプローラーで開くことができます。
RTC Builder で生成したコードの中には CMake でビルドに必要な各種ファイルを生成するための CMakeLists.txt が含まれています。 CMake を利用することにより CMakeLists.txt からVisual Studio のプロジェクトファイル、ソリューションファイル、もしくは Makefile 等を自動生成できます。
CMake を利用してビルド環境の Configure を行います。 まずは CMake(cmake-gui) を起動してください。Windows 10の場合は左下の「ここに入力して検索」にCMakeと入力して検索してください。
画面上部に以下のようなテキストボックスがありますので、それぞれソースコードの場所 (CMakeList.txtがある場所) と、ビルドディレクトリーを指定します。
ソースコードの場所は RobotController コンポーネントのソースが生成された場所で CMakeList.txt が存在するディレクトリーです。 デフォルトでは <ワークスペースディレクトリー>/RobotController になります。
このディレクトリーはエクスプローラから cmake-gui にドラックアンドドロップすると手入力しなくても設定されます。
ビルドディレクトリーとは、ビルドするためのプロジェクトファイルやオブジェクトファイル、バイナリを格納する場所のことです。 場所は任意ですが、この場合 <ワークスペースディレクトリー>/RobotController/build のように分かりやすい名前をつけた RobotController のサブディレクトリーを指定することをお勧めします。
Where is the soruce code | C:\workspace\RobotController |
Where to build the binaries | C:\workspace\RobotController\build |
指定したら、下の [Configure] ボタンをクリックします。すると下図のようなダイアログが表示されますので、生成したいプロジェクトの種類を指定します。 今回は Visual Studio 16 2019 とします。Visual Studio 2013や Visual Studio 2019を利用している方はそれぞれ変更してください。 またプラットフォームにはx64を設定します。32bit版をインストールしている場合はWin32を選択してください。
ダイアログで [Finish] ボタンをクリックすると Configure が始まります。 問題がなければ下部のログウインドウに「Configuring done」と出力されますので、続けて [Generate] ボタンをクリックします。 「Generating done」と出ればプロジェクトファイル・ソリューションファイル等の出力が完了します。
なお、CMake は Configure の段階でキャッシュファイルを生成しますので、トラブルなどで設定を変更したり環境を変更した場合は [File] > [Delete Cache] でキャッシュを削除して Configure からやり直してください。
次に先ほど指定した build ディレクトリーの中の RobotController.sln をダブルクリックして Visual Studioを起動します。
※cmake-gui の新しいバージョンでは cmake-gui 上のボタンをクリックすることで起動できます。
RobotController コンポーネントでは、コンフィギュレーションパラメーター(speed_x、speed_y)をスライダーで操作しその値を目標速度としてアウトポート(out)から出力します。 インポート(in) から入力された値を変数に格納して、その値が一定以上の場合は停止するようにします。
onActivated()、onExecute()、onDeactivated() での処理内容を下図に示します。
センサー値を一時的に格納する変数 sensor_data を宣言します。
private: int sensor_data[4]; //センサー値を一時格納する変数
下記のように、onActivated()、onDeactivated()、onExecute() を実装します。
RTC::ReturnCode_t RobotController::onActivated(RTC::UniqueId ec_id) { //センサー値初期化 for (int i = 0; i < 4; i++) { sensor_data[i] = 0; } return RTC::RTC_OK; }
RTC::ReturnCode_t RobotController::onDeactivated(RTC::UniqueId ec_id) { //ロボットを停止する m_out.data.vx = 0; m_out.data.va = 0; m_outOut.write(); return RTC::RTC_OK; }
RTC::ReturnCode_t RobotController::onExecute(RTC::UniqueId ec_id) { //入力データの存在確認 if (m_inIn.isNew()) { //入力データ読み込み m_inIn.read(); for (int i = 0; i < m_in.data.length(); i++) { //入力データ格納 if (i < 4) { sensor_data[i] = m_in.data[i]; } } } //前進するときのみ停止するかを判定 if (m_speed_x > 0) { for (int i = 0; i < 4; i++) { //センサー値が設定値以上か判定 if (sensor_data[i] > m_stop_d) { //センサー値が設定値以上の場合は停止 m_out.data.vx = 0; m_out.data.va = 0; m_outOut.write(); return RTC::RTC_OK; } } } //設定値以上の値のセンサーが無い場合はコンフィギュレーションパラメーターの値で操作 m_out.data.vx = m_speed_x; m_out.data.va = m_speed_r; m_outOut.write(); return RTC::RTC_OK; }
Visual Studioの [ビルド] >「ソリューションのビルド」を選択してビルドを行います。
作成した RobotController をシミュレーターコンポーネントと接続して動作確認を行います。
OpenRTPのパースペクティブを開くのウインドウからRT System Editorを選択して起動します。
コンポーネントの参照を登録するためのネームサービスを起動します。
RT System Editorのネームサービス起動ボタンを押すと起動します。
※ 「Start Naming Service」をクリックしても omniNames が起動されない場合は、フルコンピュータ名が14文字以内に設定されているかを確認してください。
RobotController コンポーネントを起動します。
RobotController\build\src\Debug(もしくは、Release)フォルダーの RobotControllerComp.exe ファイルを実行してください。
このコンポーネントは先ほどダウンロードしたファイル(RTM_Tutorial.zip)を展開したフォルダーの EXE/RaspberryPiMouseSimulatorComp.exe を実行すると起動します。
下図のように、RTSystemEditor にて RobotController コンポーネント、RaspberryPiMouseSimulator コンポーネントを接続します。
RTSystemEditor の上部にあります [Activate Systems] というアイコンをクリックし、全てのコンポーネントをアクティブ化します。 正常にアクティベートされた場合、下図のように黄緑色でコンポーネントが表示されます。
下図のようにコンフィギュレーションビューの [編集] ボタンからコンフィギュレーションを変更することができます。
講習会で Raspberry Pi マウス実機を用意している場合は実機での動作確認が可能ですので、時間に余裕がある人は試してみてください。
手順は以下の通りです。
Raspberry PiマウスにはRaspberry Piの電源スイッチとモーターの電源スイッチの2つがあります。
内側の電源スイッチをオンにするとRaspberry Piが起動します。
Raspberry Piの電源を切る場合は、電源スイッチから直接オフにはしないようにしてください。 3つ並んだボタンの中央のボタンを数秒押すとシャットダウンが始まります。 10秒程度でRaspbianのシャットダウンが終了するため、その後に電源スイッチをオフにしてください。
アクセスポイントへの接続方法は以下のページを参考にしてください。
SSID、パスワードは Rasoberry Pi マウスに貼り付けたシールに記載してあります。
まず右下のネットワークアイコンをクリックしてください。
RT System Editor上でネームサーバーを再起動するには「ネームサービスを起動」ボタンを再度クリックします。
続いてRTシステムエディタの [ネームサーバー追加] ボタンで 192.168.11.1 を追加してください。
すると以下の3つの RTC が見えるようになります。
RaspberryPiMouseRTC は名城大学のロボットシステムデザイン研究室で開発されているラズパイマウス制御用の RTコンポーネントです。
RTシステムエディタで RaspberryPiMouseRTC、RobotController コンポーネントを以下のように接続します。
動作の前に、モーターの電源スイッチをオンにしてください。 モーターの電源はこまめに切るようにしてください。
そして RTC をアクティブ化すると Raspberry Pi マウスの操作ができるようになります。
このページではシミュレーター上の Raspberry Pi マウスを操作するためのコンポーネントの作成手順を説明します。
まずは資料をダウンロードしてください。
インターネットに接続できない環境で講習会を実施している場合がありますので、その場合は配布のUSBメモリーに入れてあります。
シミュレーターは Open Dynamics Engine(ODE) という物理演算エンジンと ODE 付属の描画ライブラリ(drawstuff)を使用して開発しています。 OpenGL が動作すれば動くので、大抵の環境で動作するはずです。
以下の Raspberry Piマウス というロボットのシミュレーションができます。
シミュレーター上の Raspberry Pi マウスの動力学計算、接触応答だけではなく、距離センサーのデータも現実のロボットに近い値を再現するようにしています。
Raspberry Piマウスはアールティが販売している独立二輪駆動型の移動ロボットです。
ラズパイマウスの仕様 | |
CPU | Raspberry Pi 2 Model B |
モーター | ステッピングモーターST-42BYG020 2個 |
モータードライバー | SLA7070MRPT 2個 |
距離センサー | 赤色LED+フォトトランジスタ(ST-1K3) 4個 |
モニター用赤色LED | 4個 |
ブザー | 1個 |
スイッチ | 3個 |
バッテリー | LiPo3セル(11.1V)1000mAh 1個 |
RaspberryPiMouseSimulator コンポーネントと接続してシミュレーター上のロボットを操作するためのコンポーネントです。
GUI(スライダー)によりシミュレーター上のロボットの操作を行い、センサー値が一定以上の時には自動的に停止するコンポーネントの作成を行います。
作成手順は以下の通りです。
Linux (ここでは Ubuntu 18.04 を仮定) 上に開発環境を構築します。
$ wget https://raw.githubusercontent.com/OpenRTM/OpenRTM-aist/master/scripts/pkg_install_ubuntu.sh $ pkg_install_ubuntu.sh -l all --yes
# Ubuntu 18.04、18.10の場合 $ sudo apt-get install openjdk-8-jdk # Ubuntu 16.04の場合 $ sudo apt-get install default-jdk
Ubuntu 18.04、18.10の場合は以下のコマンドでjava8に切り替えます。
$ sudo update-alternatives --config java
openrtp起動後、RTSystemEditor でネームサーバに接続できない場合があります。その場合、/etc/hosts の localhost の行に自ホスト名を追記してください。
$ hostname ubuntu1804 ← ホスト名は ubuntu1804 $ sudo vi /etc/hosts
127.0.0.1 localhost を以下のように変更 127.0.0.1 localhost ubuntu1804
$ sudo apt-get install git
$ sudo apt-get install cmake-qt-gui
Code::Blocks は C/C++ に対応した統合開発環境です。 以下のコマンドでインストールできます。
$ sudo apt-get install codeblocks
最新版を入手したい場合は以下のコマンドを入力します。
$ sudo add-apt-repository ppa:damien-moore/codeblocks-stable $ sudo apt-get update $ sudo apt-get install codeblocks
ODEのビルドに必要です。
$ sudo apt-get install premake4 freeglut3-dev
シミュレーターコンポーネントについては手動でビルドを行います。 以下のコマンドを入力してください。
$ wget https://raw.githubusercontent.com/OpenRTM/RTM_Tutorial/master/script/install_raspimouse_simulator.sh $ sudo sh install_raspimouse_simulator.sh
インターネットに接続できない環境で講習会を実施している場合がありますので、その場合は配布の USBメモリー内のスクリプトを起動してください。
$ sudo sh install_raspimouse_simulator_usb.sh
RobotController は目標速度を出力するアウトポート、センサー値を入力するインポート、目標速度や停止するセンサー値を設定するコンフィギュレーションパラメーターを持っています。
コンポーネント名称 | RobotController |
InPort | |
ポート名 | in |
型 | TimedShortSeq |
説明 | センサー値 |
OutPort | |
ポート名 | out |
型 | TimedVelocity2D |
説明 | 目標速度 |
Configuration | |
パラメーター名 | speed_x |
型 | double |
デフォルト値 | 0.0 |
制約 | -1.5<x<1.5 |
Widget | slider |
Step | 0.01 |
説明 | 直進速度の設定 |
Configuration | |
パラメーター名 | speed_r |
型 | double |
デフォルト値 | 0.0 |
制約 | -2.0<x<2.0 |
Widget | slider |
Step | 0.01 |
説明 | 回転速度の設定 |
Configuration | |
パラメーター名 | stop_d |
型 | int |
デフォルト値 | 30 |
説明 | 停止するセンサー値の設定 |
2次元平面上の移動ロボットの移動速度を格納するデータ型である TimedVelocity2D 型を使用します。
struct Velocity2D { /// Velocity along the x axis in metres per second. double vx; /// Velocity along the y axis in metres per second. double vy; /// Yaw velocity in radians per second. double va; }; struct TimedVelocity2D { Time tm; Velocity2D data; };
このデータ型にはX軸方向の速度vx、Y軸方向の速度vy、Z軸周りの回転速度vaが格納できます。
vx、vy、vaはロボット中心座標系での速度を表しています。
Raspberry Piマウスのように2個の車輪が左右に取り付けられているロボットの場合、横滑りしないと仮定するとvyは0になります。
直進速度vx、回転速度vaを指定することでロボットの操作を行います。
Raspberry Pi マウスの距離センサーのデータは物体との距離が近づくほど大きな値を出力するようになっています。
デバイスファイルから取得した数値 | 実際の距離[m] |
1394 | 0.01 |
792 | 0.02 |
525 | 0.03 |
373 | 0.04 |
299 | 0.05 |
260 | 0.06 |
222 | 0.07 |
181 | 0.08 |
135 | 0.09 |
100 | 0.10 |
81 | 0.15 |
36 | 0.20 |
17 | 0.25 |
16 | 0.30 |
シミュレーターではこの値を再現して出力しています。 RobotController コンポーネントではこの値が一定以上の時に自動的に停止する処理を実装します。
RobotController コンポーネントの雛型の生成は、RTCBuilder を用いて行います。
OpenRTP では、各種作業を行うフォルダーを「ワークスペース」(Work Space)とよび、原則としてすべての生成物はこのフォルダーの下に保存されます。 ワークスペースはアクセスできるフォルダーであれば、どこに作っても構いませんが、このチュートリアルでは以下のワークスペースを仮定します。
まずは OpenRTP を起動します。
$ openrtp
最初にワークスペースの場所を尋ねられますので、上記のワークスペースを指定してください。
すると、以下のような Welcome ページが表示されます。
Welcome ページはいまは必要ないので左上の「×」ボタンをクリックして閉じてください。
右上の [Open Perspective] ボタンをクリックしてください。
「RTC Builder」を選択することで、RTCBuilderが起動します。メニューバーに「カナヅチとRT」の RTCBuilder のアイコンが現れます。
RobotController コンポーネントを作成するために、RTC Builder で新規プロジェクトを作成する必要があります。
左上の [Open New RTCBuilder Editor] のアイコンをクリックしてください。
「プロジェクト名」欄に作成するプロジェクト名 (ここでは RobotController) を入力して [終了] をクリックします。
指定した名称のプロジェクトが生成され、パッケージエクスプローラ内に追加されます。
生成したプロジェクト内には、デフォルト値が設定された RTC プロファイル XML(RTC.xml) が自動的に生成されます。
RTC.xmlが生成された時点で、このプロジェクトに関連付けられているワークスペースとして RTCBuilder のエディタが開くはずです。 もし起動しない場合はパッケージエクスプローラーの RTC.xml をダブルクリックしてください。
まず、いちばん左の「基本」タブを選択し、基本情報を入力します。先ほど決めた RobotController コンポーネントの仕様(名前)の他に、概要やバージョン等を入力してください。 ラベルが赤字の項目は必須項目です。その他はデフォルトで構いません。
次に、「アクティビティ」タブを選択し、使用するアクションコールバックを指定します。
RobotController コンポーネントでは、onActivated()、onDeactivated()、onExecute() コールバックを使用します。下図のように①の onAtivated をクリック後に②のラジオボタンにて [ON] にチェックを入れます。 onDeactivated、onExecute についても同様の手順を行います。
さらに、「データポート」タブを選択し、データポートの情報を入力します。 先ほど決めた仕様を元に以下のように入力します。なお、変数名や表示位置はオプションで、そのままで結構です。
次に、「コンフィギュレーション」タブを選択し、先ほど決めた仕様を元に、Configuration の情報を入力します。 制約条件および Widget とは、RTSystemEditor でコンポーネントのコンフィギュレーションパラメーターを表示する際に、スライダー、スピンボタン、ラジオボタンなど、GUI で値の変更を行うためのものです。
直進速度 speed_x、回転速度 speed_r はスライダーのより操作できるようにします。
次に、「言語・環境」タブを選択し、プログラミング言語を選択します。 ここでは、C++(言語) を選択します。なお、言語・環境はデフォルト等が設定されておらず、指定し忘れるとコード生成時にエラーになりますので、必ず言語の指定を行うようにしてください。
最後に、「基本」タブにある [コード生成] ボタンをクリックし、コンポーネントの雛型を生成します。
※ 生成されるコード群は、OpenRTP起動時に指定したワークスペースフォルダーの中に生成されます。 現在のワークスペースは、[ファイル] > [ワークスペースの切り替え...] で確認することができます。
RTC Builder で生成したコードの中には CMake でビルドに必要な各種ファイルを生成するための CMakeLists.txt が含まれています。 CMake を利用することにより CMakeLists.txt から Visual Studio のプロジェクトファイル、ソリューションファイル、もしくは Makefile 等を自動生成できます。
CMake を利用してビルド環境の Configure を行います。 まずは CMake(cmake-gui) を起動してください。
$ cmake-gui
画面上部に以下のようなテキストボックスがありますので、それぞれソースコードの場所 (CMakeList.txt がある場所) と、ビルドディレクトリーを指定します。
ソースコードの場所は RobotController コンポーネントのソースが生成された場所で CMakeList.txt が存在するディレクトリーです。 デフォルトでは <ワークスペースディレクトリー>/RobotController になります。
このディレクトリーはエクスプローラから cmake-gui にドラックアンドドロップすると手入力しなくても設定されます。
ビルドディレクトリーとは、ビルドするためのプロジェクトファイルやオブジェクトファイル、バイナリを格納する場所のことです。 場所は任意ですが、この場合 <ワークスペースディレクトリー>/RobotController/build のように分かりやすい名前をつけた RobotController のサブディレクトリーを指定することをお勧めします。
Where is the soruce code | /home/ユーザー名/workspace/RobotController |
Where to build the binaries | /home/ユーザー名/workspace/RobotController/build |
指定したら、下の [Configure] ボタンをクリックします。すると下図のようなダイアログが表示されますので、生成したいプロジェクトの種類を指定します。 今回は CodeBlocks - Unix Makefiles を指定します。 Code::Blocks を使わない場合は Unix Makefiles を使ってください。
また cmake-gui を使用しない場合は以下のコマンドでファイルを生成できます。
$ mkdir build $ cd build $ cmake .. -G "CodeBlocks - Unix Makefiles"
ダイアログで [Finish] をクリックすると Configure が始まります。問題がなければ下部のログウインドウに「Configuring done」と出力されますので、続けて [Generate] ボタンをクリックします。 「Generating done」と出ればプロジェクトファイル・ソリューションファイル等の出力が完了します。
なお、CMake は Configure の段階でキャッシュファイルを生成しますので、トラブルなどで設定を変更したり環境を変更した場合は [File] > [Delete Cache] を選択して、キャッシュを削除してから Configure からやり直してください。
次に先ほど指定した build ディレクトリーの中の RobotController.cbp をダブルクリックしてCode::Blocks を起動します。
ヘッダ (include/RobotController/RobotController.h) およびソースコード (src/RobotController.cpp) をそれぞれ編集します。 Code::BlocksのProjectsからRobotController.h、RobotController.cpp をクリックすることで編集画面が開きます。
64bitの環境の場合に Code::Blocks の動作が不安定になることがあります。 その場合は code completion というプラグインを無効化すると動作することがあります。
「Plugins」>「Manage plugins...」を選択します。
「code completion」を選択して [Disable] ボタンをクリックします。
動作しないときはこの手順を試してください。
RobotController コンポーネントでは、コンフィギュレーションパラメーター(speed_x、speed_y)をスライダーで操作しその値を目標速度としてアウトポート(out)から出力します。 インポート(in)から入力された値を変数に格納して、その値が一定以上の場合は停止するようにします。
onActivated()、onExecute()、onDeactivated() での処理内容を下図に示します。
センサー値を一時的に格納する変数 sensor_data を宣言します。
private: double sensor_data[4]; //センサー値を一時格納する変数
下記のように、onActivated()、onDeactivated()、onExecute() を実装します。
RTC::ReturnCode_t RobotController::onActivated(RTC::UniqueId ec_id) { //センサー値初期化 for (int i = 0; i < 4; i++) { sensor_data[i] = 0; } return RTC::RTC_OK; }
RTC::ReturnCode_t RobotController::onDeactivated(RTC::UniqueId ec_id) { //ロボットを停止する m_out.data.vx = 0; m_out.data.va = 0; m_outOut.write(); return RTC::RTC_OK; }
RTC::ReturnCode_t RobotController::onExecute(RTC::UniqueId ec_id) { //入力データの存在確認 if (m_inIn.isNew()) { //入力データ読み込み m_inIn.read(); for (int i = 0; i < m_in.data.length(); i++) { //入力データ格納 if (i < 4) { sensor_data[i] = m_in.data[i]; } } } //前進するときのみ停止するかを判定 if (m_speed_x > 0) { for (int i = 0; i < 4; i++) { //センサ値が設定値以上か判定 if (sensor_data[i] > m_stop_d) { //センサ値が設定値以上の場合は停止 m_out.data.vx = 0; m_out.data.va = 0; m_outOut.write(); return RTC::RTC_OK; } } } //設定値以上の値のセンサーが無い場合はコンフィギュレーションパラメーターの値で操作 m_out.data.vx = m_speed_x; m_out.data.va = m_speed_r; m_outOut.write(); return RTC::RTC_OK; }
Code::Blocksの [ビルド] ボタンをクリックしてビルドを行います。
作成した RobotController をシミュレーターコンポーネントと接続して動作確認を行います。
OpenRTPのパースペクティブを開くのウインドウからRT System Editorを選択して起動します。
コンポーネントの参照を登録するためのネームサービスを起動します。
RT System Editorのネームサービス起動ボタンを押すと起動します。
※ 「Start Naming Service」をクリックしても omniNames が起動されない場合は、フルコンピュータ名が14文字以内に設定されているかを確認してください。
RobotController コンポーネントを起動します。
RobotController/build/srcフォルダーの RobotControllerComp ファイルを実行してください。
$ ./RobotControllerComp
RaspberryPiMouseSimulator コンポーネントをインストールしたディレクトリー({install_raspimouse_simulator.shを実行したディレクトリ}/RasPiMouseSimulatorRTC/build)に移動後、下記のコマンドにて起動できます。
$ ./src/RaspberryPiMouseSimulatorComp
下図のように、RTSystemEditorにて RobotController コンポーネント、RaspberryPiMouseSimulator コンポーネントを接続します。
RTSystemEditor の上部にあります [Activate Systems] というアイコンをクリックし、全てのコンポーネントをアクティブ化します。 正常にアクティベートされた場合、下図のように黄緑色でコンポーネントが表示されます。
下図のようにコンフィギュレーションビューの [編集] ボタンからコンフィギュレーションを変更することができます。
講習会で Raspberry Pi マウス実機を用意している場合は実機での動作確認が可能です。
手順は以下の通りです。
Raspberry PiマウスにはRaspberry Piの電源スイッチとモーターの電源スイッチの2つがあります。
内側の電源スイッチをオンにするとRaspberry Piが起動します。
Raspberry Piの電源を切る場合は、電源スイッチから直接オフにはしないようにしてください。 3つ並んだボタンの中央のボタンを数秒押すとシャットダウンが始まります。 10秒程度でRaspbianのシャットダウンが終了するため、その後に電源スイッチをオフにしてください。
SSID、パスワードは Rasoberry Pi マウスに貼り付けたシールに記載してあるので、その SSID に接続してください。
※ネットワークが切り替わった場合にネームサーバーへのコンポーネントの登録やポートの接続が失敗する場合があるのでネームサーバ、コンポーネントを一旦全て終了してください。 ネットワーク切り替え後に起動した場合には問題ないので、終了させる必要はありません。
RT System Editor上でネームサーバーを再起動するには「ネームサービスを起動」ボタンを再度クリックします。
続いてRTシステムエディタの [ネームサーバー追加] ボタンで 192.168.11.1 を追加してください。
すると以下の2つの RTC が見えるようになります。
RaspberryPiMouseRTC は名城大学のロボットシステムデザイン研究室で開発されているラズパイマウス制御用の RTコンポーネントです。
RTシステムエディタで RaspberryPiMouseRTC、RobotController コンポーネントを以下のように接続します。
動作の前に、モーターの電源スイッチをオンにしてください。 モーターの電源はこまめに切るようにしてください。
そして RTC をアクティブ化すると Raspberry Pi マウスの操作ができるようになります。
このページではRaspberry PiマウスとLEGO Mindstorms EV3を連携したRTシステムの構築を行います。
Raspberry Piマウスをアクセスポイントとして、ノートPCとEV3をアクセスポイントに接続します。
※Raspberry Piマウスと同じ番号のEV3を使用するようにしてください。
EV3 には以下のデバイスが付属しています。
まず、EV3本体を土台に装着します。
Lモーター右 | ポート C | 25cmケーブル |
Lモーター左 | ポート B | 25cmケーブル |
他のデバイスを取り付ける場合は、チュートリアル(EV3)を参考にしてください。
第二部の、実機での動作確認まで完了してください。 この時点でノートPCとアクセスポイントのRaspberry Piが接続されているはずです。
中央のボタンを押せば電源が投入されます。
EV3 の電源を切る場合は最初の画面で EV3 本体の左上の戻るボタンを押して「Power Off」を選択してください。
再起動する場合は最初の画面で EV3 本体の左上の戻るボタンを押して「Reboot」を選択してください。
ev3dev の起動が途中で停止する場合には、中央ボタン、戻るボタン(左上)、左ボタンを同時押ししてください。画面が消えたら戻るボタンを離すと再起動します。
EV3の電源を投入してください。
起動後にRaspberry Piに自動接続します。 自動接続できた場合は、EV3の画面左上にIPアドレスが表示されます。 IPアドレスは192.168.11.yyyが表示されます。
EV3の画面上の操作でネームサーバーとRTCを起動します。
EV3 の操作画面から「File Browser」→「scripts」を選択してください。
ネームサーバー、RTCはstart_rtcs.shのスクリプトを実行することで起動します。
------------------------------ 192.168.11.yyy ------------------------------ File Browser ------------------------------ /home/robot/scripts ------------------------------ ../ Component/ ・・ [start_rtcs.sh ] ------------------------------
RTシステムエディタから、192.168.11.yyyのネームサーバーに接続してください。
この時点でRTシステムエディタのネームサービスビューにはlocalhost、192.168.11.1、192.168.11.yyyのネームサーバーが登録されています。 192.168.11.yyyのネームサーバーに登録されているRTCの名前はEducatorVehicle1となります。
RaspberryPiMouseRTC0(192.168.11.1)とEducatorVehicle1(192.168.11.yyy)をシステムダイアグラム上で接続してください。 EducatorVehicle0の現在の速度出力をRaspberryPiMouseRTC0の目標速度入力に接続することで、EV3の動きにRaspberry Piマウスが追従するようになります。
これで実習は一通り終了ですが、時間が余っている場合は以下のような課題に挑戦してみてください。
EV3のタッチセンサーのオンオフでRaspberry Piマウスを前進後退させるRTシステムを作成します。
EV3とタッチセンサーを35cmケーブルで接続してください。
タッチセンサー右 | ポート 3 | 35cmケーブル |
タッチセンサー左 | ポート 1 | 35cmケーブル |
以下のような仕様のRTCを作成します。
コンポーネント名称 | SampleTouchSensor |
InPort | |
ポート名 | touch |
型 | TimedBooleanSeq |
説明 | タッチセンサーのオンオフ |
OutPort | |
ポート名 | target_velocity |
型 | TimedVelocity2D |
説明 | 目標速度 |
Configuration | |
パラメーター名 | speed |
型 | double |
デフォルト値 | 0.2 |
説明 | タッチセンサがオンの時の直進速度の設定 |
アクティビティでonExecuteを有効にしてください。
SampleTouchSensorのonExecute関数に以下のように記述します。
RTC::ReturnCode_t SampleTouchSensor::onExecute(RTC::UniqueId ec_id) { //新規データの確認 if (m_touchIn.isNew()) { //データの読み込み m_touchIn.read(); //配列の要素数が1以上かを確認 if (m_touch.data.length() == 2) { //0番目のデータがオンの場合は直進する指令を出力 //0番目のデータは右側のタッチセンサに対応 if (m_touch.data[0]) { //目標速度を格納 m_target_velocity.data.vx = m_speed; m_target_velocity.data.vy = 0; m_target_velocity.data.va = 0; setTimestamp(m_target_velocity); //データ出力 m_target_velocityOut.write(); } //1番目のデータがオンの場合は後退する指令を出力 //1番目のデータは左側のタッチセンサに対応 else if (m_touch.data[1]) { //目標速度を格納 m_target_velocity.data.vx = -m_speed; m_target_velocity.data.vy = 0; m_target_velocity.data.va = 0; setTimestamp(m_target_velocity); //データ出力 m_target_velocityOut.write(); } //オフの場合は停止する else { //目標速度を格納 m_target_velocity.data.vx = 0; m_target_velocity.data.vy = 0; m_target_velocity.data.va = 0; setTimestamp(m_target_velocity); //データ出力 m_target_velocityOut.write(); } } } return RTC::RTC_OK; }
データポートを以下のように接続後、タッチセンサをオンオフするとRaspberry Piが前進後退します。
以下GUIジョイスティックでRaspberry Piマウス、EV3を操作するRTシステムを作成します。
ジョイスティックコンポーネントはOpenRTM-aist Python版のサンプルにあります(TkJoyStickComp.py)。 ジョイスティックコンポーネントは、Windows 8.1の場合は「スタート」>「アプリビュー(右下矢印)」>「OpenRTM-aist 1.2.0」>「Python_Examples」をクリックして、エクスプローラーで「TkJoyStickComp.bat」をダブルクリックして起動してください。
TkJoyStickComp.pyのアウトポートのデータ型はTimedFloatSeq型であるため、TimedVelocity2D型に変換するRTCを作成する必要があります。
以下のような仕様のRTCを作成してください。
コンポーネント名称 | FloatSeqToVelocity |
InPort | |
ポート名 | in |
型 | TimedFloatSeq |
説明 | 変換前のデータ |
OutPort | |
ポート名 | out |
型 | TimedVelocity2D |
説明 | 変換後のデータ |
Configuration | |
パラメーター名 | rotation_by_position |
型 | double |
デフォルト値 | -0.02 |
説明 | ジョイスティックのX座標の位置に対する角速度の変化量 |
Configuration | |
パラメーター名 | velocity_by_position |
型 | double |
デフォルト値 | 0.002 |
説明 | ジョイステックのY座標に対する速度の変化量 |
アクティビティはonExecuteをオンにしてください。
onExecute関数を以下のように編集してください。
RTC::ReturnCode_t FloatSeqToVelocity::onExecute(RTC::UniqueId ec_id) { //新規データの確認 if (m_inIn.isNew()) { //データの読み込み m_inIn.read(); //配列のデータ数確認 if (m_in.data.length() >= 2) { //目標速度格納 m_out.data.vx = m_in.data[1] * m_velocity_by_position; m_out.data.vy = 0; m_out.data.va = m_in.data[0] * m_rotation_by_position; setTimestamp(m_out); //目標速度出力 m_outOut.write(); } } return RTC::RTC_OK; }
以下のようにデータポートを接続してください。
EducatorVehicleRTCのsoundという名前のインポートに文字列(TimedString型)を入力すると、EV3が発声します。
以下のような仕様のRTCを作成してください。
コンポーネント名称 | SpeechSample |
OutPort | |
ポート名 | out |
型 | TimedString |
説明 | 発話する文字列 |
アクティビティはonExecuteをオンにしてください。
onExecute関数を以下のように編集してください。
RTC::ReturnCode_t SpeechSample::onExecute(RTC::UniqueId ec_id) { std::cout << "Please input: "; std::string ret; //文字入力 std::cin >> ret; //データに格納 m_out.data = CORBA::string_dup(ret.c_str()); setTimestamp(m_out); //データ出力 m_outOut.write(); return RTC::RTC_OK; }
文字列(const char*)をデータポートで出力する際はCORBA::string_dup関数で文字列をコピーする必要があります。
m_out.data= CORBA::string_dup("abc");
以下のようにデータポートを接続してください。
Raspberry Piマウスを起動すると、OpenCVCameraコンポーネントとarptコンポーネントが起動します。 OpenCVCameraコンポーネントは画像を取得するコンポーネント、artpコンポーネントは画像データからマーカの位置姿勢を計算して出力するコンポーネントです。
まずはカメラをRaspberry Piマウスに装着します。
以下の土台部品をRaspberry Piマウスに取り付けていきます。
以下の仕様でRTCを作成してください。
コンポーネント名称 | testARToolKit |
InPort | |
ポート名 | marker_pos |
型 | TimedPose3D |
説明 | マーカーの位置 |
OutPort | |
ポート名 | target_vel |
型 | TimedVelocity2D |
説明 | ロボットの目標速度 |
Configuration | |
パラメーター名 | x_distance |
型 | double |
デフォルト値 | 0.5 |
説明 | マーカーまでの目標距離(X軸) |
Configuration | |
パラメーター名 | y_distance |
型 | double |
デフォルト値 | 0 |
説明 | マーカーまでの目標距離(Y軸) |
Configuration | |
パラメーター名 | x_speed |
型 | double |
デフォルト値 | 0.1 |
説明 | X軸方向移動速度 |
Configuration | |
パラメーター名 | r_speed |
型 | double |
デフォルト値 | 0.2 |
説明 | 回転方向移動速度 |
Configuration | |
パラメーター名 | error_range_x |
型 | double |
デフォルト値 | 0.1 |
説明 | X軸方向目標距離の許容範囲 |
Configuration | |
パラメーター名 | error_range_y |
型 | double |
デフォルト値 | 0.05 |
説明 | Y軸方向目標距離の許容範囲 |
アクティビティはonExecuteをONにしてください。
onExecuteを以下のように編集してください。
RTC::ReturnCode_t testARToolKit::onExecute(RTC::UniqueId ec_id) { //新規データの確認 if (m_marker_posIn.isNew()) { m_target_vel.data.vx = 0; m_target_vel.data.vy = 0; m_target_vel.data.va = 0; //データの読み込み m_marker_posIn.read(); //マーカーの位置(X軸)が目標距離(X軸)よりも大きい場合 if (m_marker_pos.data.position.x > m_x_distance + m_error_range_x/2.0) { m_target_vel.data.vx = m_x_speed; } //マーカーの位置(X軸)が目標距離(X軸)よりも小さい場合 else if (m_marker_pos.data.position.x < m_x_distance - m_error_range_x/2.0) { m_target_vel.data.vx = -m_x_speed; } //マーカーの位置(Y軸)が目標距離(Y軸)よりも大きい場合 else if (m_marker_pos.data.position.y > m_y_distance + m_error_range_y/2.0) { m_target_vel.data.va = m_r_speed; } //マーカーの位置(Y軸)が目標距離(Y軸)よりも小さい場合 else if (m_marker_pos.data.position.y < m_y_distance - m_error_range_y/2.0) { m_target_vel.data.va = -m_r_speed; } setTimestamp(m_target_vel); //データ書き込み m_target_velOut.write(); } return RTC::RTC_OK; }
データポートを以下のように接続してください。
このページではLibreOffice Calc用RTCによるRTCの動作確認手順について説明します。 Calcのセルの値をInPortに入力、OutPortの出力した値をセルに表示することで対象RTCの挙動を確認できます。
RTM講習会ではUSBメモリでポータブル版LibreOfficeとRTCを配布します。 Windowsで実行できます。 UbuntuはPython3用のomniORBのパッケージがないため実行できません。講習会ではノートPCを貸し出します。
この実習では第2部で作成したRobotControllerコンポーネントを使用します。
表計算、パワーポイント、ワープロ機能等を提供するオフィススイートです。 フリーソフトとして公開されており、今回の講習会では以下のポータブル版を使用します。
配布したUSBメモリ内のポータブル版LibreOffice\run_CalcRTC.batを実行します。
LibreOffice Calcが起動するため、RTC起動ボタンをクリックすることでOOoCalcControlというRTCを起動します。
RobotControllerのOutPortと接続し、Calcで出力データの確認ができるようにします。 Calcの操作ダイアログ起動ボタンをクリックしてください。
まずは出力データを確認するOutPortと接続します。 ツリー表示ボタンを押下してネームサーバーに登録されたRTCのポート一覧を表示後、ツリーからRobotController0のoutを選択します。
次に一部設定を変更します。
列を移動させるのチェックを外してください。 このチェックが有効の場合、データを受信する度にセルの位置が移動するモードで動作します。 グラフに描画する場合は位置が移動するモードを使用しますが、今回は単純に値を確認したいだけのためチェックを外します。
列番号の右のボックスにCと入力してください。 これで2行目のA~C列のセルにOutPortの出力データを表示するようになりました。
設定完了後、作成ボタンを押してください。
RT System Editor上でRTCをアクティブ化して動作を確認してください。
この状態でコンフィギュレーションパラメータを操作してCalcのセルの値が変化するかを確認してください。
RobotControllerのInPortと接続し、Calcからデータの入力を行うようにします。
ツリー表示ボタンを押下してネームサーバーに登録されたRTCのポート一覧を表示後、ツリーからRobotController0のinを選択します。
次に一部設定を変更します。
列を移動させるのチェックを外してください。
列番号の右のボックスにDと入力してください。 これで3行目のA~C列のセルにOutPortの出力データを表示するようになりました。
設定完了後、作成ボタンを押してください。
RT System Editor上でRTCをアクティブ化して動作を確認してください。
この状態でコンフィギュレーションパラメータで前進する速度をOutPortから出力するように操作してください。 その後、Calcの3行目のA~C列のセルに31以上の値を入力するか、30以下の値を入力するかで動作が変化するかを確認してください。
このページではシミュレーター上の Raspberry Pi マウスを操作するためのコンポーネントの作成手順を説明します。
まずは資料をダウンロードしてください。
ZIPファイルは Lhaplus 等で展開してください。
インターネットに接続できない環境で講習会を実施している場合がありますので、その場合は配布のUSBメモリーに入れてあります。
シミュレーターは Open Dynamics Engine(ODE) という物理演算エンジンと ODE 付属の描画ライブラリ(drawstuff)を使用して開発しています。 OpenGL が動作すれば動くので、大抵の環境で動作するはずです。
以下の Raspberry Piマウス というロボットのシミュレーションができます。
シミュレーター上の Raspberry Pi マウスの動力学計算、接触応答だけではなく、距離センサーのデータも現実のロボットに近い値を再現するようにしています。
Raspberry Piマウスはアールティが販売している独立二輪駆動型の移動ロボットです。
ラズパイマウスの仕様 | |
CPU | Raspberry Pi 2 Model B |
モーター | ステッピングモーターST-42BYG020 2個 |
モータードライバー | SLA7070MRPT 2個 |
距離センサー | 赤色LED+フォトトランジスタ(ST-1K3) 4個 |
モニター用赤色LED | 4個 |
ブザー | 1個 |
スイッチ | 3個 |
バッテリー | LiPo3セル(11.1V)1000mAh 1個 |
RaspberryPiMouseSimulator コンポーネントと接続してシミュレーター上のロボットを操作するためのコンポーネントです。
GUI(スライダー)によりシミュレーター上のロボットの操作を行い、センサー値が一定以上の時には自動的に停止するコンポーネントの作成を行います。
作成手順は以下の通りです。
以下の環境を想定しています。
RobotController は目標速度を出力するアウトポート、センサー値を入力するインポート、目標速度や停止するセンサー値を設定するコンフィギュレーションパラメーターを持っています。
コンポーネント名称 | RobotController |
InPort | |
ポート名 | in |
型 | TimedShortSeq |
説明 | センサー値 |
OutPort | |
ポート名 | out |
型 | TimedVelocity2D |
説明 | 目標速度 |
Configuration | |
パラメーター名 | speed_x |
型 | double |
デフォルト値 | 0.0 |
制約 | -1.5<x<1.5 |
Widget | slider |
Step | 0.01 |
説明 | 直進速度の設定 |
Configuration | |
パラメーター名 | speed_r |
型 | double |
デフォルト値 | 0.0 |
制約 | -2.0<x<2.0 |
Widget | slider |
Step | 0.01 |
説明 | 回転速度の設定 |
Configuration | |
パラメーター名 | stop_d |
型 | int |
デフォルト値 | 30 |
説明 | 停止するセンサー値の設定 |
2次元平面上の移動ロボットの移動速度を格納するデータ型である TimedVelocity2D 型を使用します。
struct Velocity2D { /// Velocity along the x axis in metres per second. double vx; /// Velocity along the y axis in metres per second. double vy; /// Yaw velocity in radians per second. double va; }; struct TimedVelocity2D { Time tm; Velocity2D data; };
このデータ型にはX軸方向の速度vx、Y軸方向の速度vy、Z軸周りの回転速度vaが格納できます。
vx、vy、vaはロボット中心座標系での速度を表しています。
Raspberry Pi マウスのように2個の車輪が左右に取り付けられているロボットの場合、横滑りしないと仮定するとvyは0になります。
直進速度vx、回転速度vaを指定することでロボットの操作を行います。
Raspberry Pi マウスの距離センサーのデータは物体との距離が近づくほど大きな値を出力するようになっています。
デバイスファイルから取得した数値 | 実際の距離[m] |
1394 | 0.01 |
792 | 0.02 |
525 | 0.03 |
373 | 0.04 |
299 | 0.05 |
260 | 0.06 |
222 | 0.07 |
181 | 0.08 |
135 | 0.09 |
100 | 0.10 |
81 | 0.15 |
36 | 0.20 |
17 | 0.25 |
16 | 0.30 |
シミュレーターではこの値を再現して出力しています。 RobotController コンポーネントではこの値が一定以上の時に自動的に停止する処理を実装します。
RobotController コンポーネントの雛型の生成は、RTCBuilder を用いて行います。
Eclipse では、各種作業を行うフォルダーを「ワークスペース」(Work Space)とよび、原則としてすべての生成物はこのフォルダーの下に保存されます。 ワークスペースはアクセスできるフォルダーであれば、どこに作っても構いませんが、このチュートリアルでは以下のワークスペースを仮定します。
まずは Eclipse を起動します。 Windows 8.1の場合は「スタート」>「アプリビュー(右下矢印)」>「OpenRTM-aist 1.2.0」>「OpenRTP」をクリックすると起動できます。
最初にワークスペースの場所を尋ねられますので、上記のワークスペースを指定してください。
すると、以下のようなWelcomeページが表示されます。
Welcomeページはいまは必要ないので左上の「×」ボタンをクリックして閉じてください。
右上の [Open Perspective] ボタンをクリックしてください。
「RTC Builder」を選択することで、RTCBuilder が起動します。メニューバーに「カナヅチとRT」の RTCBuilder のアイコンが表示されます。
RobotController コンポーネントを作成するために、RTC Builder で新規プロジェクトを作成する必要があります。
左上の [Open New RTCBuilder Editor] のアイコンをクリックしてください。
「プロジェクト名」欄に作成するプロジェクト名 (ここでは RobotController) を入力して [終了] ボタンをクリックします。
指定した名称のプロジェクトが生成され、パッケージエクスプローラ内に追加されます。
生成したプロジェクト内には、デフォルト値が設定された RTC プロファイル XML(RTC.xml) が自動的に生成されます。
RTC.xml が生成された時点で、このプロジェクトに関連付けられているワークスペースとして RTCBuilder のエディタが開くはずです。 もし起動しない場合はパッケージエクスプローラーの RTC.xml をダブルクリックしてください。
まず、いちばん左の「基本」タブを選択し、基本情報を入力します。先ほど決めた RobotController コンポーネントの仕様(名前)の他に、概要やバージョン等を入力してください。 ラベルが赤字の項目は必須項目です。その他はデフォルトで構いません。
次に、「アクティビティ」タブを選択し、使用するアクションコールバックを指定します。
RobotController コンポーネントでは、onActivated()、onDeactivated()、onExecute() コールバックを使用します。下図のように①の onAtivated をクリック後に②のラジオボタンにて [ON] にチェックを入れます。 onDeactivated、onExecute についても同様の手順を行います。
さらに、「データポート」タブを選択し、データポートの情報を入力します。 先ほど決めた仕様を元に以下のように入力します。なお、変数名や表示位置はオプションで、そのままで結構です。
次に、「コンフィギュレーション」タブを選択し、先ほど決めた仕様を元に、Configuration の情報を入力します。 制約条件および Widget とは、RTSystemEditor でコンポーネントのコンフィギュレーションパラメーターを表示する際に、スライダー、スピンボタン、ラジオボタンなど、GUI で値の変更を行うためのものです。
直進速度 speed_x、回転速度 speed_r はスライダーのより操作できるようにします。
次に、「言語・環境」タブを選択し、プログラミング言語を選択します。 ここでは、C++(言語)を選択します。なお、言語・環境はデフォルト等が設定されておらず、指定し忘れるとコード生成時にエラーになりますので、必ず言語の指定を行うようにしてください。
最後に、「基本」タブにあ [コード生成] ボタンをクリックし、コンポーネントの雛型を生成します。
プロジェクトを右クリックして、「表示方法」→「システム・エクスプローラー」を選択するとワークスペースをエクスプローラーで開くことができます。
RTC Builder で生成したコードの中には CMake でビルドに必要な各種ファイルを生成するための CMakeLists.txt が含まれています。 CMake を利用することにより CMakeLists.txt からVisual Studio のプロジェクトファイル、ソリューションファイル、もしくは Makefile 等を自動生成できます。
CMake を利用してビルド環境の Configure を行います。 まずは CMake(cmake-gui) を起動してください。「スタート」>「アプリビュー(右下矢印)」>「CMake 3.11.2」>「CMake (cmake-gui)」をクリックすると起動できます。
画面上部に以下のようなテキストボックスがありますので、それぞれソースコードの場所 (CMakeList.txtがある場所) と、ビルドディレクトリーを指定します。
ソースコードの場所は RobotController コンポーネントのソースが生成された場所で CMakeList.txt が存在するディレクトリーです。 デフォルトでは <ワークスペースディレクトリー>/RobotController になります。
このディレクトリーはエクスプローラから cmake-gui にドラックアンドドロップすると手入力しなくても設定されます。
ビルドディレクトリーとは、ビルドするためのプロジェクトファイルやオブジェクトファイル、バイナリを格納する場所のことです。 場所は任意ですが、この場合 <ワークスペースディレクトリー>/RobotController/build のように分かりやすい名前をつけた RobotController のサブディレクトリーを指定することをお勧めします。
Where is the soruce code | C:\workspace\RobotController |
Where to build the binaries | C:\workspace\RobotController\build |
指定したら、下の [Configure] ボタンをクリックします。すると下図のようなダイアログが表示されますので、生成したいプロジェクトの種類を指定します。 今回は Visual Studio 15 2017 とします。Visual Studio 2013や Visual Studio 2019を利用している方はそれぞれ変更してください。 またプラットフォームにはx64を設定します。32bit版をインストールしている場合はWin32を選択してください。
ダイアログで [Finish] ボタンをクリックすると Configure が始まります。 問題がなければ下部のログウインドウに「Configuring done」と出力されますので、続けて [Generate] ボタンをクリックします。 「Generating done」と出ればプロジェクトファイル・ソリューションファイル等の出力が完了します。
なお、CMake は Configure の段階でキャッシュファイルを生成しますので、トラブルなどで設定を変更したり環境を変更した場合は [File] > [Delete Cache] でキャッシュを削除して Configure からやり直してください。
次に先ほど指定した build ディレクトリーの中の RobotController.sln をダブルクリックして Visual Studio 2013 を起動します。
※cmake-gui の新しいバージョンでは cmake-gui 上のボタンをクリックすることで起動できます。
RobotController コンポーネントでは、コンフィギュレーションパラメーター(speed_x、speed_y)をスライダーで操作しその値を目標速度としてアウトポート(out)から出力します。 インポート(in) から入力された値を変数に格納して、その値が一定以上の場合は停止するようにします。
onActivated()、onExecute()、onDeactivated() での処理内容を下図に示します。
センサー値を一時的に格納する変数 sensor_data を宣言します。
private: int sensor_data[4]; //センサー値を一時格納する変数
下記のように、onActivated()、onDeactivated()、onExecute() を実装します。
RTC::ReturnCode_t RobotController::onActivated(RTC::UniqueId ec_id) { //センサー値初期化 for (int i = 0; i < 4; i++) { sensor_data[i] = 0; } return RTC::RTC_OK; }
RTC::ReturnCode_t RobotController::onDeactivated(RTC::UniqueId ec_id) { //ロボットを停止する m_out.data.vx = 0; m_out.data.va = 0; m_outOut.write(); return RTC::RTC_OK; }
RTC::ReturnCode_t RobotController::onExecute(RTC::UniqueId ec_id) { //入力データの存在確認 if (m_inIn.isNew()) { //入力データ読み込み m_inIn.read(); for (int i = 0; i < m_in.data.length(); i++) { //入力データ格納 if (i < 4) { sensor_data[i] = m_in.data[i]; } } } //前進するときのみ停止するかを判定 if (m_speed_x > 0) { for (int i = 0; i < 4; i++) { //センサー値が設定値以上か判定 if (sensor_data[i] > m_stop_d) { //センサー値が設定値以上の場合は停止 m_out.data.vx = 0; m_out.data.va = 0; m_outOut.write(); return RTC::RTC_OK; } } } //設定値以上の値のセンサーが無い場合はコンフィギュレーションパラメーターの値で操作 m_out.data.vx = m_speed_x; m_out.data.va = m_speed_r; m_outOut.write(); return RTC::RTC_OK; }
Visual Studioの [ビルド] >「ソリューションのビルド」を選択してビルドを行います。
作成した RobotController をシミュレーターコンポーネントと接続して動作確認を行います。
コンポーネントの参照を登録するためのネームサービスを起動します。
RT System Editorのネームサービス起動ボタンを押すと起動します。
&color(red){※ 「Start Naming Service」をクリックしても omniNames が起動されない場合は、フルコンピュータ名が14文字以内に設定されているかを確認してください。
RobotController コンポーネントを起動します。
RobotController\build\src\Debug(もしくは、Release)フォルダーの RobotControllerComp.exe ファイルを実行してください。
このコンポーネントは先ほどダウンロードしたファイル(RTM_Tutorial_RaspberryPiMouse.zip)を展開したフォルダーの EXE/RaspberryPiMouseSimulatorComp.exe を実行すると起動します。
下図のように、RTSystemEditor にて RobotController コンポーネント、RaspberryPiMouseSimulator コンポーネントを接続します。
RTSystemEditor の上部にあります [All Activate] というアイコンをクリックし、全てのコンポーネントをアクティブ化します。 正常にアクティベートされた場合、下図のように黄緑色でコンポーネントが表示されます。
下図のようにコンフィギュレーションビューの [編集] ボタンからコンフィギュレーションを変更することができます。
講習会で Raspberry Pi マウス実機を用意している場合は実機での動作確認が可能ですので、時間に余裕がある人は試してみてください。
手順は以下の通りです。
Raspberry PiマウスにはRaspberry Piの電源スイッチとモーターの電源スイッチの2つがあります。
内側の電源スイッチをオンにするとRaspberry Piが起動します。
Raspberry Piの電源を切る場合は、電源スイッチから直接オフにはしないようにしてください。 3つ並んだボタンの中央のボタンを数秒押すとシャットダウンが始まります。 10秒程度でRaspbianのシャットダウンが終了するため、その後に電源スイッチをオフにしてください。
アクセスポイントへの接続方法は以下のページを参考にしてください。
SSID、パスワードは Rasoberry Pi マウスに貼り付けたシールに記載してあります。
まず右下のネットワークアイコンをクリックしてください。
続いてRTシステムエディタの [ネームサーバー追加] ボタンで 192.168.11.1 を追加してください。
すると以下の3つの RTC が見えるようになります。
RaspberryPiMouseRTC は名城大学のロボットシステムデザイン研究室で開発されているラズパイマウス制御用の RTコンポーネントです。
RTシステムエディタで RaspberryPiMouseRTC、RobotController コンポーネントを以下のように接続します。
動作の前に、モーターの電源スイッチをオンにしてください。 モーターの電源はこまめに切るようにしてください。
そして RTC をアクティブ化すると Raspberry Pi マウスの操作ができるようになります。
このページではシミュレーター上の Raspberry Pi マウスを操作するためのコンポーネントの作成手順を説明します。
まずは資料をダウンロードしてください。
git clone https://github.com/OpenRTM/RTM_Tutorial_RaspberryPiMouse
インターネットに接続できない環境で講習会を実施している場合がありますので、その場合は配布のUSBメモリーに入れてあります。
シミュレーターは Open Dynamics Engine(ODE) という物理演算エンジンと ODE 付属の描画ライブラリ(drawstuff)を使用して開発しています。 OpenGL が動作すれば動くので、大抵の環境で動作するはずです。
以下の Raspberry Piマウス というロボットのシミュレーションができます。
シミュレーター上の Raspberry Pi マウスの動力学計算、接触応答だけではなく、距離センサーのデータも現実のロボットに近い値を再現するようにしています。
Raspberry Piマウスはアールティが販売している独立二輪駆動型の移動ロボットです。
ラズパイマウスの仕様 | |
CPU | Raspberry Pi 2 Model B |
モーター | ステッピングモーターST-42BYG020 2個 |
モータードライバー | SLA7070MRPT 2個 |
距離センサー | 赤色LED+フォトトランジスタ(ST-1K3) 4個 |
モニター用赤色LED | 4個 |
ブザー | 1個 |
スイッチ | 3個 |
バッテリー | LiPo3セル(11.1V)1000mAh 1個 |
RaspberryPiMouseSimulator コンポーネントと接続してシミュレーター上のロボットを操作するためのコンポーネントです。
GUI(スライダー)によりシミュレーター上のロボットの操作を行い、センサー値が一定以上の時には自動的に停止するコンポーネントの作成を行います。
作成手順は以下の通りです。
Linux (ここでは Ubuntu 18.04 を仮定) 上に開発環境を構築します。
ubuntu 18.04 (64bit) の場合 $ wget https://raw.githubusercontent.com/OpenRTM/OpenRTM-aist/master/scripts/pkg_install_ubuntu.sh $ sudo sh pkg_install_ubuntu.sh
$ sudo apt-get install openjdk-8-jdk
Ubuntu 18.04、18.10の場合は以下のコマンドでjava8に切り替えます。
$ sudo update-alternatives --config java
eclipse起動後、RTSystemEditor でネームサーバに接続できない場合があります。その場合、/etc/hosts の localhost の行に自ホスト名を追記してください。
$ hostname ubuntu1804 ← ホスト名は ubuntu1804 $ sudo vi /etc/hosts 127.0.0.1 localhost を以下のように変更 127.0.0.1 localhost ubuntu1404
$ sudo apt-get install cmake cmake-gui
Code::Blocks は C/C++ に対応した統合開発環境です。 以下のコマンドでインストールできます。
$ sudo apt-get install codeblocks
最新版を入手したい場合は以下のコマンドを入力します。
$ sudo add-apt-repository ppa:damien-moore/codeblocks-stable $ sudo apt-get update $ sudo apt-get install codeblocks
ODEのビルドに必要です。
$ sudo apt-get install premake4
シミュレーターコンポーネントについては手動でビルドを行います。 以下のコマンドを入力してください。
$ wget https://raw.githubusercontent.com/OpenRTM/RTM_Tutorial_RaspberryPiMouse/master/script/install_raspimouse_simulator.sh $ sh install_raspimouse_simulator.sh
インターネットに接続できない環境で講習会を実施している場合がありますので、その場合は配布の USBメモリー内のスクリプトを起動してください。
$ sh install_raspimouse_simulator_usb.sh
RobotController は目標速度を出力するアウトポート、センサー値を入力するインポート、目標速度や停止するセンサー値を設定するコンフィギュレーションパラメーターを持っています。
コンポーネント名称 | RobotController |
InPort | |
ポート名 | in |
型 | TimedShortSeq |
説明 | センサー値 |
OutPort | |
ポート名 | out |
型 | TimedVelocity2D |
説明 | 目標速度 |
Configuration | |
パラメーター名 | speed_x |
型 | double |
デフォルト値 | 0.0 |
制約 | -1.5<x<1.5 |
Widget | slider |
Step | 0.01 |
説明 | 直進速度の設定 |
Configuration | |
パラメーター名 | speed_r |
型 | double |
デフォルト値 | 0.0 |
制約 | -2.0<x<2.0 |
Widget | slider |
Step | 0.01 |
説明 | 回転速度の設定 |
Configuration | |
パラメーター名 | stop_d |
型 | int |
デフォルト値 | 30 |
説明 | 停止するセンサー値の設定 |
2次元平面上の移動ロボットの移動速度を格納するデータ型である TimedVelocity2D 型を使用します。
struct Velocity2D { /// Velocity along the x axis in metres per second. double vx; /// Velocity along the y axis in metres per second. double vy; /// Yaw velocity in radians per second. double va; }; struct TimedVelocity2D { Time tm; Velocity2D data; };
このデータ型にはX軸方向の速度vx、Y軸方向の速度vy、Z軸周りの回転速度vaが格納できます。
vx、vy、vaはロボット中心座標系での速度を表しています。
Raspberry Piマウスのように2個の車輪が左右に取り付けられているロボットの場合、横滑りしないと仮定するとvyは0になります。
直進速度vx、回転速度vaを指定することでロボットの操作を行います。
Raspberry Pi マウスの距離センサーのデータは物体との距離が近づくほど大きな値を出力するようになっています。
デバイスファイルから取得した数値 | 実際の距離[m] |
1394 | 0.01 |
792 | 0.02 |
525 | 0.03 |
373 | 0.04 |
299 | 0.05 |
260 | 0.06 |
222 | 0.07 |
181 | 0.08 |
135 | 0.09 |
100 | 0.10 |
81 | 0.15 |
36 | 0.20 |
17 | 0.25 |
16 | 0.30 |
シミュレーターではこの値を再現して出力しています。 RobotController コンポーネントではこの値が一定以上の時に自動的に停止する処理を実装します。
RobotController コンポーネントの雛型の生成は、RTCBuilder を用いて行います。
Eclipse では、各種作業を行うフォルダーを「ワークスペース」(Work Space)とよび、原則としてすべての生成物はこのフォルダーの下に保存されます。 ワークスペースはアクセスできるフォルダーであれば、どこに作っても構いませんが、このチュートリアルでは以下のワークスペースを仮定します。
まずは Eclipse を起動します。 OpenRTP を展開したディレクトリーに移動して以下のコマンドを入力します。
$ ./openrtp
最初にワークスペースの場所を尋ねられますので、上記のワークスペースを指定してください。
すると、以下のような Welcome ページが表示されます。
Welcome ページはいまは必要ないので左上の「×」ボタンをクリックして閉じてください。
右上の [Open Perspective] ボタンをクリックしてください。
「RTC Builder」を選択することで、RTCBuilderが起動します。メニューバーに「カナヅチとRT」の RTCBuilder のアイコンが現れます。
RobotController コンポーネントを作成するために、RTC Builder で新規プロジェクトを作成する必要があります。
左上の [Open New RTCBuilder Editor] のアイコンをクリックしてください。
「プロジェクト名」欄に作成するプロジェクト名 (ここでは RobotController) を入力して [終了] をクリックします。
指定した名称のプロジェクトが生成され、パッケージエクスプローラ内に追加されます。
生成したプロジェクト内には、デフォルト値が設定された RTC プロファイル XML(RTC.xml) が自動的に生成されます。
RTC.xmlが生成された時点で、このプロジェクトに関連付けられているワークスペースとして RTCBuilder のエディタが開くはずです。 もし起動しない場合はパッケージエクスプローラーの RTC.xml をダブルクリックしてください。
まず、いちばん左の「基本」タブを選択し、基本情報を入力します。先ほど決めた RobotController コンポーネントの仕様(名前)の他に、概要やバージョン等を入力してください。 ラベルが赤字の項目は必須項目です。その他はデフォルトで構いません。
次に、「アクティビティ」タブを選択し、使用するアクションコールバックを指定します。
RobotController コンポーネントでは、onActivated()、onDeactivated()、onExecute() コールバックを使用します。下図のように①の onAtivated をクリック後に②のラジオボタンにて [ON] にチェックを入れます。 onDeactivated、onExecute についても同様の手順を行います。
さらに、「データポート」タブを選択し、データポートの情報を入力します。 先ほど決めた仕様を元に以下のように入力します。なお、変数名や表示位置はオプションで、そのままで結構です。
次に、「コンフィギュレーション」タブを選択し、先ほど決めた仕様を元に、Configuration の情報を入力します。 制約条件および Widget とは、RTSystemEditor でコンポーネントのコンフィギュレーションパラメーターを表示する際に、スライダー、スピンボタン、ラジオボタンなど、GUI で値の変更を行うためのものです。
直進速度 speed_x、回転速度 speed_r はスライダーのより操作できるようにします。
次に、「言語・環境」タブを選択し、プログラミング言語を選択します。 ここでは、C++(言語) を選択します。なお、言語・環境はデフォルト等が設定されておらず、指定し忘れるとコード生成時にエラーになりますので、必ず言語の指定を行うようにしてください。
最後に、「基本」タブにある [コード生成] ボタンをクリックし、コンポーネントの雛型を生成します。
※ 生成されるコード群は、eclipse起動時に指定したワークスペースフォルダーの中に生成されます。 現在のワークスペースは、[ファイル] > [ワークスペースの切り替え...] で確認することができます。
RTC Builder で生成したコードの中には CMake でビルドに必要な各種ファイルを生成するための CMakeLists.txt が含まれています。 CMake を利用することにより CMakeLists.txt から Visual Studio のプロジェクトファイル、ソリューションファイル、もしくは Makefile 等を自動生成できます。
CMake を利用してビルド環境の Configure を行います。 まずは CMake(cmake-gui) を起動してください。
$ cmake-gui
画面上部に以下のようなテキストボックスがありますので、それぞれソースコードの場所 (CMakeList.txt がある場所) と、ビルドディレクトリーを指定します。
ソースコードの場所は RobotController コンポーネントのソースが生成された場所で CMakeList.txt が存在するディレクトリーです。 デフォルトでは <ワークスペースディレクトリー>/RobotController になります。
このディレクトリーはエクスプローラから cmake-gui にドラックアンドドロップすると手入力しなくても設定されます。
ビルドディレクトリーとは、ビルドするためのプロジェクトファイルやオブジェクトファイル、バイナリを格納する場所のことです。 場所は任意ですが、この場合 <ワークスペースディレクトリー>/RobotController/build のように分かりやすい名前をつけた RobotController のサブディレクトリーを指定することをお勧めします。
Where is the soruce code | /home/ユーザー名/RobotController |
Where to build the binaries | /home/ユーザー名/RobotController\build |
指定したら、下の [Configure] ボタンをクリックします。すると下図のようなダイアログが表示されますので、生成したいプロジェクトの種類を指定します。 今回は CodeBlocks - Unix Makefiles を指定します。 Code::Blocks を使わない場合は Unix Makefiles を使ってください。
また cmake-gui を使用しない場合は以下のコマンドでファイルを生成できます。
$ mkdir build $ cd build $ cmake .. -G "CodeBlocks - Unix Makefiles"
ダイアログで [Finish] をクリックすると Configure が始まります。問題がなければ下部のログウインドウに「Configuring done」と出力されますので、続けて [Generate] ボタンをクリックします。 「Generating done」と出ればプロジェクトファイル・ソリューションファイル等の出力が完了します。
なお、CMake は Configure の段階でキャッシュファイルを生成しますので、トラブルなどで設定を変更したり環境を変更した場合は [File] > [Delete Cache] を選択して、キャッシュを削除してから Configure からやり直してください。
次に先ほど指定した build ディレクトリーの中の RobotController.cbp をダブルクリックしてCode::Blocks を起動します。
ヘッダ (include/RobotController/RobotController.h) およびソースコード (src/RobotController.cpp) をそれぞれ編集します。 Code::BlocksのProjectsからRobotController.h、RobotController.cpp をクリックすることで編集画面が開きます。
64bitの環境の場合に Code::Blocks の動作が不安定になることがあります。 その場合は code completion というプラグインを無効化すると動作することがあります。
「Plugins」>「Manage plugins...」を選択します。
「code completion」を選択して [Disable] ボタンをクリックします。
動作しないときはこの手順を試してください。
RobotController コンポーネントでは、コンフィギュレーションパラメーター(speed_x、speed_y)をスライダーで操作しその値を目標速度としてアウトポート(out)から出力します。 インポート(in)から入力された値を変数に格納して、その値が一定以上の場合は停止するようにします。
onActivated()、onExecute()、onDeactivated() での処理内容を下図に示します。
センサー値を一時的に格納する変数 sensor_data を宣言します。
private: double sensor_data[4]; //センサー値を一時格納する変数
下記のように、onActivated()、onDeactivated()、onExecute() を実装します。
RTC::ReturnCode_t RobotController::onActivated(RTC::UniqueId ec_id) { //センサー値初期化 for (int i = 0; i < 4; i++) { sensor_data[i] = 0; } return RTC::RTC_OK; }
RTC::ReturnCode_t RobotController::onDeactivated(RTC::UniqueId ec_id) { //ロボットを停止する m_out.data.vx = 0; m_out.data.va = 0; m_outOut.write(); return RTC::RTC_OK; }
RTC::ReturnCode_t RobotController::onExecute(RTC::UniqueId ec_id) { //入力データの存在確認 if (m_inIn.isNew()) { //入力データ読み込み m_inIn.read(); for (int i = 0; i < m_in.data.length(); i++) { //入力データ格納 if (i < 4) { sensor_data[i] = m_in.data[i]; } } } //前進するときのみ停止するかを判定 if (m_speed_x > 0) { for (int i = 0; i < 4; i++) { //センサ値が設定値以上か判定 if (sensor_data[i] > m_stop_d) { //センサ値が設定値以上の場合は停止 m_out.data.vx = 0; m_out.data.va = 0; m_outOut.write(); return RTC::RTC_OK; } } } //設定値以上の値のセンサーが無い場合はコンフィギュレーションパラメーターの値で操作 m_out.data.vx = m_speed_x; m_out.data.va = m_speed_r; m_outOut.write(); return RTC::RTC_OK; }
Code::Blocksの [ビルド] ボタンをクリックしてビルドを行います。
作成した RobotController をシミュレーターコンポーネントと接続して動作確認を行います。
コンポーネントの参照を登録するためのネームサービスを起動します。
$ rtm-naming
RobotController コンポーネントを起動します。
RobotController\build\srcフォルダーの RobotControllerComp ファイルを実行してください。
$ RobotControllerComp
RaspberryPiMouseSimulator コンポーネントをインストールしたディレクトリーに移動後、下記のコマンドにて起動できます。
$ src/RaspberryPiMouseSimulatorComp
下図のように、RTSystemEditorにて RobotController コンポーネント、RaspberryPiMouseSimulator コンポーネントを接続します。
RTSystemEditor の上部にあります [All Activate] というアイコンをクリックし、全てのコンポーネントをアクティブ化します。 正常にアクティベートされた場合、下図のように黄緑色でコンポーネントが表示されます。
下図のようにコンフィギュレーションビューの [編集] ボタンからコンフィギュレーションを変更することができます。
講習会で Raspberry Pi マウス実機を用意している場合は実機での動作確認が可能です。
手順は以下の通りです。
Raspberry PiマウスにはRaspberry Piの電源スイッチとモーターの電源スイッチの2つがあります。
内側の電源スイッチをオンにするとRaspberry Piが起動します。
Raspberry Piの電源を切る場合は、電源スイッチから直接オフにはしないようにしてください。 3つ並んだボタンの中央のボタンを数秒押すとシャットダウンが始まります。 10秒程度でRaspbianのシャットダウンが終了するため、その後に電源スイッチをオフにしてください。
SSID、パスワードは Rasoberry Pi マウスに貼り付けたシールに記載してあるので、その SSID に接続してください。
※ネットワークが切り替わった場合にネームサーバーへのコンポーネントの登録やポートの接続が失敗する場合があるのでネームサーバ、コンポーネントを一旦全て終了してください。 ネットワーク切り替え後に起動した場合には問題ないので、終了させる必要はありません。
続いてRTシステムエディタの [ネームサーバー追加] ボタンで 192.168.11.1 を追加してください。
すると以下の2つの RTC が見えるようになります。
RaspberryPiMouseRTC は名城大学のロボットシステムデザイン研究室で開発されているラズパイマウス制御用の RTコンポーネントです。
RTシステムエディタで RaspberryPiMouseRTC、RobotController コンポーネントを以下のように接続します。
動作の前に、モーターの電源スイッチをオンにしてください。 モーターの電源はこまめに切るようにしてください。
そして RTC をアクティブ化すると Raspberry Pi マウスの操作ができるようになります。
このページではシミュレーター上の Raspberry Pi マウスを操作するためのコンポーネントの作成手順を説明します。
シミュレーターは Open Dynamics Engine(ODE) という物理演算エンジンと ODE 付属の描画ライブラリ(drawstuff)を使用して開発しています。 OpenGL が動作すれば動くので、大抵の環境で動作するはずです。
以下の Raspberry Piマウス というロボットのシミュレーションができます。
シミュレーター上の Raspberry Pi マウスの動力学計算、接触応答だけではなく、距離センサーのデータも現実のロボットに近い値を再現するようにしています。
RaspberryPiMouseSimulator コンポーネントと接続してシミュレーター上のロボットを操作するためのコンポーネントです。
GUI(スライダー)によりシミュレーター上のロボットの操作を行い、センサー値が一定以上の時には自動的に停止するコンポーネントの作成を行います。
作成手順は以下の通りです。
以下の環境を想定しています。
RobotController は目標速度を出力するアウトポート、センサー値を入力するインポート、目標速度や停止するセンサー値を設定するコンフィギュレーションパラメーターを持っています。
コンポーネント名称 | RobotController |
InPort | |
ポート名 | in |
型 | TimedShortSeq |
説明 | センサー値 |
OutPort | |
ポート名 | out |
型 | TimedVelocity2D |
説明 | 目標速度 |
Configuration | |
パラメーター名 | speed_x |
型 | double |
デフォルト値 | 0.0 |
制約 | -1.0<x<1.0 |
Widget | slider |
Step | 0.01 |
説明 | 直進速度の設定 |
Configuration | |
パラメーター名 | speed_r |
型 | double |
デフォルト値 | 0.0 |
制約 | -2.0<x<2.0 |
Widget | slider |
Step | 0.01 |
説明 | 回転速度の設定 |
Configuration | |
パラメーター名 | stop_d |
型 | int |
デフォルト値 | 30 |
説明 | 停止するセンサー値の設定 |
2次元平面上の移動ロボットの移動速度を格納するデータ型である TimedVelocity2D 型を使用します。
struct Velocity2D { /// Velocity along the x axis in metres per second. double vx; /// Velocity along the y axis in metres per second. double vy; /// Yaw velocity in radians per second. double va; }; struct TimedVelocity2D { Time tm; Velocity2D data; };
このデータ型にはX軸方向の速度vx、Y軸方向の速度vy、Z軸周りの回転速度vaが格納できます。
vx、vy、vaはロボット中心座標系での速度を表しています。
Raspberry Pi マウスのように2個の車輪が左右に取り付けられているロボットの場合、横滑りしないと仮定するとvyは0になります。
直進速度vx、回転速度vaを指定することでロボットの操作を行います。
Raspberry Pi マウスの距離センサーのデータは物体との距離が近づくほど大きな値を出力するようになっています。
デバイスファイルから取得した数値 | 実際の距離[m] |
1394 | 0.01 |
792 | 0.02 |
525 | 0.03 |
373 | 0.04 |
299 | 0.05 |
260 | 0.06 |
222 | 0.07 |
181 | 0.08 |
135 | 0.09 |
100 | 0.10 |
81 | 0.15 |
36 | 0.20 |
17 | 0.25 |
16 | 0.30 |
シミュレーターではこの値を再現して出力しています。 RobotController コンポーネントではこの値が一定以上の時に自動的に停止する処理を実装します。
RobotController コンポーネントの雛型の生成は、RTCBuilder を用いて行います。
Eclipse では、各種作業を行うフォルダーを「ワークスペース」(Work Space)とよび、原則としてすべての生成物はこのフォルダーの下に保存されます。 ワークスペースはアクセスできるフォルダーであれば、どこに作っても構いませんが、このチュートリアルでは以下のワークスペースを仮定します。
まずは Eclipse を起動します。 Windows 8.1の場合は「スタート」>「アプリビュー(右下矢印)」>「OpenRTM-aist 1.1.2」>「OpenRTP」をクリックすると起動できます。
最初にワークスペースの場所を尋ねられますので、上記のワークスペースを指定してください。
すると、以下のようなWelcomeページが表示されます。
Welcomeページはいまは必要ないので左上の「×」ボタンをクリックして閉じてください。
右上の [Open Perspective] ボタンをクリックしてください。
「RTC Builder」を選択することで、RTCBuilder が起動します。メニューバーに「カナヅチとRT」の RTCBuilder のアイコンが表示されます。
RobotController コンポーネントを作成するために、RTC Builder で新規プロジェクトを作成する必要があります。
左上の [Open New RTCBuilder Editor] のアイコンをクリックしてください。
「プロジェクト名」欄に作成するプロジェクト名 (ここでは RobotController) を入力して [終了] ボタンをクリックします。
指定した名称のプロジェクトが生成され、パッケージエクスプローラ内に追加されます。
生成したプロジェクト内には、デフォルト値が設定された RTC プロファイル XML(RTC.xml) が自動的に生成されます。
RTC.xml が生成された時点で、このプロジェクトに関連付けられているワークスペースとして RTCBuilder のエディタが開くはずです。 もし起動しない場合はパッケージエクスプローラーの RTC.xml をダブルクリックしてください。
まず、いちばん左の「基本」タブを選択し、基本情報を入力します。先ほど決めた RobotController コンポーネントの仕様(名前)の他に、概要やバージョン等を入力してください。 ラベルが赤字の項目は必須項目です。その他はデフォルトで構いません。
次に、「アクティビティ」タブを選択し、使用するアクションコールバックを指定します。
RobotController コンポーネントでは、onActivated()、onDeactivated()、onExecute() コールバックを使用します。下図のように①の onAtivated をクリック後に②のラジオボタンにて [ON] にチェックを入れます。 onDeactivated、onExecute についても同様の手順を行います。
さらに、「データポート」タブを選択し、データポートの情報を入力します。 先ほど決めた仕様を元に以下のように入力します。なお、変数名や表示位置はオプションで、そのままで結構です。
次に、「コンフィギュレーション」タブを選択し、先ほど決めた仕様を元に、Configuration の情報を入力します。 制約条件および Widget とは、RTSystemEditor でコンポーネントのコンフィギュレーションパラメーターを表示する際に、スライダー、スピンボタン、ラジオボタンなど、GUI で値の変更を行うためのものです。
直進速度 speed_x、回転速度 speed_r はスライダーのより操作できるようにします。
次に、「言語・環境」タブを選択し、プログラミング言語を選択します。 ここでは、Python(言語)を選択します。なお、言語・環境はデフォルト等が設定されておらず、指定し忘れるとコード生成時にエラーになりますので、必ず言語の指定を行うようにしてください。
最後に、「基本」タブにあ [コード生成] ボタンをクリックし、コンポーネントの雛型を生成します。
※ 生成されるコード群は、eclipse 起動時に指定したワークスペースフォルダーの中に生成されます。現在のワークスペースは、[ファイル] > [ワークスペースの切り替え..]で確認することができます。
<ワークスペースディレクトリー>/RobotController/RobotController.pyをPython用エディタで開いて編集してください。 Pythonに標準で付属しているIDLEを使う場合は、ファイルを右クリックしてEdit with IDLEをクリックするとファイルを開きます。
OpenRTM-aist 1.1.2のRTC Builderを使用している場合は、変数初期化部分を修正する必要があります。(OpenRTM-aist 1.2.0では修正される予定です)
まずは、init関数のself._d_in変数初期化部分を修正してください。
def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) #in_arg = [None] * ((len(RTC._d_TimedShortSeq) - 4) / 2) ←削除 #self._d_in = RTC.TimedShortSeq(*in_arg) ←削除 #以下の行を追加 self._d_in = RTC.TimedShortSeq(RTC.Time(0,0),[])
次にself._d_out 変数初期化部分を修正してください。
#out_arg = [None] * ((len(RTC._d_TimedVelocity2D) - 4) / 2) ←削除 #self._d_out = RTC.TimedVelocity2D(*out_arg) ←削除 #以下の行を追加 self._d_out = RTC.TimedVelocity2D(RTC.Time(0,0),RTC.Velocity2D(0.0,0.0,0.0))
これで完了です。
RobotController コンポーネントでは、コンフィギュレーションパラメーター(speed_x、speed_y)をスライダーで操作しその値を目標速度としてアウトポート(out)から出力します。 インポート(in) から入力された値を変数に格納して、その値が一定以上の場合は停止するようにします。
onActivated()、onExecute()、onDeactivated() での処理内容を下図に示します。
下記のように、onActivated()、onDeactivated()、onExecute() を実装します。
def onActivated(self, ec_id): #センサー値初期化 self.sensor_data = [0,0,0,0] return RTC.RTC_OK
def onDeactivated(self, ec_id): #ロボットを停止する self._d_out.data.vx = 0 self._d_out.data.va = 0 self._outOut.write() return RTC.RTC_OK
def onExecute(self, ec_id): #入力データの存在確認 if self._inIn.isNew(): data = self._inIn.read() #この時点で入力データがm_inに格納される #入力データを別変数に格納 self.sensor_data = data.data[:] #前進するときのみ停止するかを判定 if self._speed_x[0] > 0: for d in self.sensor_data: #センサ値が設定値以上か判定 if d > self._stop_d[0]: #センサ値が設定値以上の場合は停止 self._d_out.data.vx = 0 self._d_out.data.va = 0 self._outOut.write() return RTC.RTC_OK #設定値以上の値のセンサが無い場合はコンフィギュレーションパラメータの値で操作 self._d_out.data.vx = self._speed_x[0] self._d_out.data.va = self._speed_r[0] self._outOut.write() return RTC.RTC_OK
作成した RobotController をシミュレーターコンポーネントと接続して動作確認を行います。
以下より RaspberryPiMouseSimulator コンポーネントをダウンロードしてください。
ZIPファイルは Lhaplus 等で展開してください。
インターネットに接続できない環境で講習会を実施している場合がありますので、その場合は配布のUSBメモリーに入れてあります。
コンポーネントの参照を登録するためのネームサービスを起動します。
「スタート」>「アプリビュー(右下矢印)」>「OpenRTM-aist 1.1.2」の順に辿り、「Start Naming Service」をクリックしてください。
※ 「Start Naming Service」をクリックしても omniNames が起動されない場合は、フルコンピュータ名が14文字以内に設定されているかを確認してください。
RobotController コンポーネントを起動します。
RobotControllerComp.pyファイルをダブルクリックして実行してください。
このコンポーネントは先ほどダウンロードしたファイル(RTM_Tutorial_2017.zip)を展開したフォルダーの EXE/RaspberryPiMouseSimulatorComp.exe を実行すると起動します。
下図のように、RTSystemEditor にて RobotController コンポーネント、RaspberryPiMouseSimulator コンポーネントを接続します。
RTSystemEditor の上部にあります [All Activate] というアイコンをクリックし、全てのコンポーネントをアクティブ化します。 正常にアクティベートされた場合、下図のように黄緑色でコンポーネントが表示されます。
下図のようにコンフィギュレーションビューの [編集] ボタンからコンフィギュレーションを変更することができます。
講習会で Raspberry Pi マウス実機を用意している場合は実機での動作確認が可能です。
手順は以下の通りです。
Raspberry PiマウスにはRaspberry Piの電源スイッチとモーターの電源スイッチの2つがあります。
内側の電源スイッチをオンにするとRaspberry Piが起動します。
Raspberry Piの電源を切る場合は、電源スイッチから直接オフにはしないようにしてください。 3つ並んだボタンの中央のボタンを数秒押すとシャットダウンが始まります。 10秒程度でRaspbianのシャットダウンが終了するため、その後に電源スイッチをオフにしてください。
アクセスポイントへの接続方法は以下のページを参考にしてください。
SSID、パスワードは Rasoberry Pi マウスに貼り付けたシールに記載してあります。
まず右下のネットワークアイコンをクリックしてください。
続いてRTシステムエディタの [ネームサーバー追加] ボタンで 192.168.11.1 を追加してください。
すると以下の2つの RTC が見えるようになります。
RaspberryPiMouseRTC は名城大学のロボットシステムデザイン研究室で開発されているラズパイマウス制御用の RTコンポーネントです。
RTシステムエディタで RaspberryPiMouseRTC、RobotController コンポーネントを以下のように接続します。
動作の前に、モーターの電源スイッチをオンにしてください。 モーターの電源はこまめに切るようにしてください。
そして RTC をアクティブ化すると Raspberry Pi マウスの操作ができるようになります。
このページではシミュレーター上の Raspberry Pi マウスを操作するためのコンポーネントの作成手順を説明します。
まずは資料をダウンロードしてください。
git clone https://github.com/OpenRTM/RTM_Tutorial_RaspberryPiMouse_Python
インターネットに接続できない環境で講習会を実施している場合がありますので、その場合は配布のUSBメモリーに入れてあります。
RaspberryPiMouseSimulator コンポーネントと接続してシミュレーター上のロボットを操作するためのコンポーネントです。
GUI(スライダー)によりシミュレーター上のロボットの操作を行い、センサー値が一定以上の時には自動的に停止するコンポーネントの作成を行います。
作成手順は以下の通りです。
Linux (ここでは Ubuntu 16.04 を仮定) 上に開発環境を構築します。
インストールスクリプトでインストールします。
$ wget http://svn.openrtm.org/OpenRTM-aist/trunk/OpenRTM-aist/build/pkg_install_ubuntu.sh $ sudo sh pkg_install_ubuntu.sh -lpython
こちらのURL から Linux版の OpenRTP (コンポーネント開発ツール、システム開発ツール統合環境) をダウンロード、インストールします。 OepnRTP の実行には Java も必要となりますので default-jre パッケージをインストールします。
$ apt-get install default-jre $ wget http://openrtm.org/pub/openrtp/packages/1.1.2.v20160526/eclipse442-openrtp112v20160526-ja-linux-gtk-x86_64.tar.gz $ tar xvzf eclipse442-openrtp112v20160526-ja-linux-gtk-x86_64.tar.gz
eclipse起動後、RTSystemEditor でネームサーバに接続できない場合があります。その場合、/etc/hosts の localhost の行に自ホスト名を追記してください。
$ hostname ubuntu1404 ← ホスト名は ubuntu1404 $ sudo vi /etc/hosts
127.0.0.1 localhost を以下のように変更 127.0.0.1 localhost ubuntu1404
PyDev等、Python用のエディタをインストールしてください。
シミュレーターコンポーネントについては手動でビルドを行います。 以下のコマンドを入力してください。
$ wget https://raw.githubusercontent.com/Nobu19800/RTM_Tutorial_2017/master/install_raspimouse_simulator.sh $ sudo sh install_raspimouse_simulator.sh
インターネットに接続できない環境で講習会を実施している場合がありますので、その場合は配布の USBメモリー内のスクリプトを起動してください。
$ sudo sh install_raspimouse_simulator_usb.sh
RobotController は目標速度を出力するアウトポート、センサー値を入力するインポート、目標速度や停止するセンサー値を設定するコンフィギュレーションパラメーターを持っています。
コンポーネント名称 | RobotController |
InPort | |
ポート名 | in |
型 | TimedShortSeq |
説明 | センサー値 |
OutPort | |
ポート名 | out |
型 | TimedVelocity2D |
説明 | 目標速度 |
Configuration | |
パラメーター名 | speed_x |
型 | double |
デフォルト値 | 0.0 |
制約 | -1.0<x<1.0 |
Widget | slider |
Step | 0.01 |
説明 | 直進速度の設定 |
Configuration | |
パラメーター名 | speed_r |
型 | double |
デフォルト値 | 0.0 |
制約 | -2.0<x<2.0 |
Widget | slider |
Step | 0.01 |
説明 | 回転速度の設定 |
Configuration | |
パラメーター名 | stop_d |
型 | int |
デフォルト値 | 30 |
説明 | 停止するセンサー値の設定 |
2次元平面上の移動ロボットの移動速度を格納するデータ型である TimedVelocity2D 型を使用します。
struct Velocity2D { /// Velocity along the x axis in metres per second. double vx; /// Velocity along the y axis in metres per second. double vy; /// Yaw velocity in radians per second. double va; }; struct TimedVelocity2D { Time tm; Velocity2D data; };
このデータ型にはX軸方向の速度vx、Y軸方向の速度vy、Z軸周りの回転速度vaが格納できます。
vx、vy、vaはロボット中心座標系での速度を表しています。
Raspberry Piマウスのように2個の車輪が左右に取り付けられているロボットの場合、横滑りしないと仮定するとvyは0になります。
直進速度vx、回転速度vaを指定することでロボットの操作を行います。
Raspberry Pi マウスの距離センサーのデータは物体との距離が近づくほど大きな値を出力するようになっています。
デバイスファイルから取得した数値 | 実際の距離[m] |
1394 | 0.01 |
792 | 0.02 |
525 | 0.03 |
373 | 0.04 |
299 | 0.05 |
260 | 0.06 |
222 | 0.07 |
181 | 0.08 |
135 | 0.09 |
100 | 0.10 |
81 | 0.15 |
36 | 0.20 |
17 | 0.25 |
16 | 0.30 |
シミュレーターではこの値を再現して出力しています。 RobotController コンポーネントではこの値が一定以上の時に自動的に停止する処理を実装します。
RobotController コンポーネントの雛型の生成は、RTCBuilder を用いて行います。
Eclipse では、各種作業を行うフォルダーを「ワークスペース」(Work Space)とよび、原則としてすべての生成物はこのフォルダーの下に保存されます。 ワークスペースはアクセスできるフォルダーであれば、どこに作っても構いませんが、このチュートリアルでは以下のワークスペースを仮定します。
まずは Eclipse を起動します。 OpenRTP を展開したディレクトリーに移動して以下のコマンドを入力します。
$ ./openrtp
最初にワークスペースの場所を尋ねられますので、上記のワークスペースを指定してください。
すると、以下のような Welcome ページが表示されます。
Welcome ページはいまは必要ないので左上の「×」ボタンをクリックして閉じてください。
右上の [Open Perspective] ボタンをクリックしてください。
「RTC Builder」を選択することで、RTCBuilderが起動します。メニューバーに「カナヅチとRT」の RTCBuilder のアイコンが現れます。
RobotController コンポーネントを作成するために、RTC Builder で新規プロジェクトを作成する必要があります。
左上の [Open New RTCBuilder Editor] のアイコンをクリックしてください。
「プロジェクト名」欄に作成するプロジェクト名 (ここでは RobotController) を入力して [終了] をクリックします。
指定した名称のプロジェクトが生成され、パッケージエクスプローラ内に追加されます。
生成したプロジェクト内には、デフォルト値が設定された RTC プロファイル XML(RTC.xml) が自動的に生成されます。
RTC.xmlが生成された時点で、このプロジェクトに関連付けられているワークスペースとして RTCBuilder のエディタが開くはずです。 もし起動しない場合はパッケージエクスプローラーの RTC.xml をダブルクリックしてください。
まず、いちばん左の「基本」タブを選択し、基本情報を入力します。先ほど決めた RobotController コンポーネントの仕様(名前)の他に、概要やバージョン等を入力してください。 ラベルが赤字の項目は必須項目です。その他はデフォルトで構いません。
次に、「アクティビティ」タブを選択し、使用するアクションコールバックを指定します。
RobotController コンポーネントでは、onActivated()、onDeactivated()、onExecute() コールバックを使用します。下図のように①の onAtivated をクリック後に②のラジオボタンにて [ON] にチェックを入れます。 onDeactivated、onExecute についても同様の手順を行います。
さらに、「データポート」タブを選択し、データポートの情報を入力します。 先ほど決めた仕様を元に以下のように入力します。なお、変数名や表示位置はオプションで、そのままで結構です。
次に、「コンフィギュレーション」タブを選択し、先ほど決めた仕様を元に、Configuration の情報を入力します。 制約条件および Widget とは、RTSystemEditor でコンポーネントのコンフィギュレーションパラメーターを表示する際に、スライダー、スピンボタン、ラジオボタンなど、GUI で値の変更を行うためのものです。
直進速度 speed_x、回転速度 speed_r はスライダーのより操作できるようにします。
次に、「言語・環境」タブを選択し、プログラミング言語を選択します。 ここでは、C++(言語) を選択します。なお、言語・環境はデフォルト等が設定されておらず、指定し忘れるとコード生成時にエラーになりますので、必ず言語の指定を行うようにしてください。
最後に、「基本」タブにある [コード生成] ボタンをクリックし、コンポーネントの雛型を生成します。
※ 生成されるコード群は、eclipse起動時に指定したワークスペースフォルダーの中に生成されます。 現在のワークスペースは、[ファイル] > [ワークスペースの切り替え...] で確認することができます。
<ワークスペースディレクトリー>/RobotController/RobotController.pyをPython用エディタで開いて編集してください。
OpenRTM-aist 1.1.2のRTC Builderを使用している場合は、変数初期化部分を修正する必要があります。(OpenRTM-aist 1.2.0では修正される予定です)
まずは、init関数のself._d_in変数初期化部分を修正してください。
def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) #in_arg = [None] * ((len(RTC._d_TimedShortSeq) - 4) / 2) ←削除 #self._d_in = RTC.TimedShortSeq(*in_arg) ←削除 #以下の行を追加 self._d_in = RTC.TimedShortSeq(RTC.Time(0,0),[])
次にself._d_out 変数初期化部分を修正してください。
#out_arg = [None] * ((len(RTC._d_TimedVelocity2D) - 4) / 2) ←削除 #self._d_out = RTC.TimedVelocity2D(*out_arg) ←削除 #以下の行を追加 self._d_out = RTC.TimedVelocity2D(RTC.Time(0,0),RTC.Velocity2D(0.0,0.0,0.0))
これで完了です。
RobotController コンポーネントでは、コンフィギュレーションパラメーター(speed_x、speed_y)をスライダーで操作しその値を目標速度としてアウトポート(out)から出力します。 インポート(in) から入力された値を変数に格納して、その値が一定以上の場合は停止するようにします。
onActivated()、onExecute()、onDeactivated() での処理内容を下図に示します。
下記のように、onActivated()、onDeactivated()、onExecute() を実装します。
def onActivated(self, ec_id): #センサー値初期化 self.sensor_data = [0,0,0,0] return RTC.RTC_OK
def onDeactivated(self, ec_id): #ロボットを停止する self._d_out.data.vx = 0 self._d_out.data.va = 0 self._outOut.write() return RTC.RTC_OK
def onExecute(self, ec_id): #入力データの存在確認 if self._inIn.isNew(): data = self._inIn.read() #この時点で入力データがm_inに格納される #入力データを別変数に格納 self.sensor_data = data.data[:] #前進するときのみ停止するかを判定 if self._speed_x[0] > 0: for d in self.sensor_data: #センサ値が設定値以上か判定 if d > self._stop_d[0]: #センサ値が設定値以上の場合は停止 self._d_out.data.vx = 0 self._d_out.data.va = 0 self._outOut.write() return RTC.RTC_OK #設定値以上の値のセンサが無い場合はコンフィギュレーションパラメータの値で操作 self._d_out.data.vx = self._speed_x[0] self._d_out.data.va = self._speed_r[0] self._outOut.write() return RTC.RTC_OK
作成した RobotController をシミュレーターコンポーネントと接続して動作確認を行います。
以下より RaspberryPiMouseSimulator コンポーネントをダウンロードしてください。
インターネットに接続できない環境で講習会を実施している場合がありますので、その場合は配布のUSBメモリーに入れてあります。
コンポーネントの参照を登録するためのネームサービスを起動します。
$ rtm-naming
RobotController コンポーネントを起動します。
RobotController\build\srcフォルダーの RobotControllerComp ファイルを実行してください。
$ RobotControllerComp
RaspberryPiMouseSimulator コンポーネントをインストールしたディレクトリーに移動後、下記のコマンドにて起動できます。
$ src/RaspberryPiMouseSimulatorComp
下図のように、RTSystemEditorにて RobotController コンポーネント、RaspberryPiMouseSimulator コンポーネントを接続します。
RTSystemEditor の上部にあります [All Activate] というアイコンをクリックし、全てのコンポーネントをアクティブ化します。 正常にアクティベートされた場合、下図のように黄緑色でコンポーネントが表示されます。
下図のようにコンフィギュレーションビューの [編集] ボタンからコンフィギュレーションを変更することができます。
講習会で Raspberry Pi マウス実機を用意している場合は実機での動作確認が可能です。
手順は以下の通りです。
Raspberry PiマウスにはRaspberry Piの電源スイッチとモーターの電源スイッチの2つがあります。
内側の電源スイッチをオンにするとRaspberry Piが起動します。
Raspberry Piの電源を切る場合は、電源スイッチから直接オフにはしないようにしてください。 3つ並んだボタンの中央のボタンを数秒押すとシャットダウンが始まります。 10秒程度でRaspbianのシャットダウンが終了するため、その後に電源スイッチをオフにしてください。
SSID、パスワードは Rasoberry Pi マウスに貼り付けたシールに記載してあるので、その SSID に接続してください。
※ネットワークが切り替わった場合にネームサーバーへのコンポーネントの登録やポートの接続が失敗する場合があるのでネームサーバ、コンポーネントを一旦全て終了してください。 ネットワーク切り替え後に起動した場合には問題ないので、終了させる必要はありません。
続いてRTシステムエディタの [ネームサーバー追加] ボタンで 192.168.11.1 を追加してください。
すると以下の2つの RTC が見えるようになります。
RaspberryPiMouseRTC は名城大学のロボットシステムデザイン研究室で開発されているラズパイマウス制御用の RTコンポーネントです。
RTシステムエディタで RaspberryPiMouseRTC、RobotController コンポーネントを以下のように接続します。
動作の前に、モーターの電源スイッチをオンにしてください。 モーターの電源はこまめに切るようにしてください。
そして RTC をアクティブ化すると Raspberry Pi マウスの操作ができるようになります。
このページ の手順に従ってRaspbian を SDカードに書き込んでください。 ※フルキットに付属の SDカードを使用する場合はこの作業は不要です。
最初に Raspberry Pi に SDカードを挿入してください。一度組み立てると Raspberry Pi を取り外さない限り SDカードの交換はできません。
まずは Raspberry Pi をラズパイマウス本体に載せます。 スペーサーに Raspberry Pi を付属のねじで留めてください。 最後に Raspberry Pi とラズパイマウス本体のピンヘッダに部品を取り付ければ完成です。以下の作業は Rasbian を起動して行います。 まずは Raspberry Pi にディスプレイ、マウス、キーボード、LANケーブルを接続してください。
ラズパイマウスはバッテリー以外にも付属のケーブルでコンセントから電源をとれるのですが、ラズパイマウスに接続するコネクタの向きには注意してください。
ラズパイマウスの電源スイッチは以下の位置にあります。
手前のスイッチがモーター電源で、内側のスイッチが Raspberry Pi の電源です。 内側のスイッチを ON にしてください。
Raspbian が起動したらユーザー名が pi、パスワードが raspberry でログインできるはずなのでログインしてください。 ログインできたら以下のコマンドで X-Window を起動してください。
startx
Raspbian 起動後、以下のコマンドでリポジトリをクローンしてください。
git clone https://github.com/rt-net/RaspberryPiMouse.git
sudo apt-get install git
uname -r
cd RaspberryPiMouse/lib/Pi2B+/4.1.6-v7+/ sudo insmod rtmouse.ko
SPI 機能を有効にしていない場合は以下のコマンド、もしくは [Menu] > [Preference] > [Raspberry Pi Configuration] で表示される画面で設定してください。
sudo raspi-config
上下キーで「Advanced Options」を選択後 Enter キーを押してください。 次に A5 SPI を同じ手順で選択します。 そして左右キーで Yes を選択して OK で Enter キーを押せば有効になります。 元の画面に戻ったら 左右キーで [Finish] を選択して終了してください。 詳しくは このページ を参考にしてください。
※フルキットに付属の SDカードを使用する場合はこの作業は不要です。
Raspbian に C++版 OpenRTM-aist のインストールには以下のコマンドを入力します。
wget http://svn.openrtm.org/OpenRTM-aist/tags/RELEASE_1_1_1/OpenRTM-aist/build/pkg_install_debian.sh sudo sh pkg_install_debian.sh
詳しくは このページ を参考にしてください。
※母艦 PC の OS は Windows を想定しています。 Windows に OpenRTM-aist をインストールする手順については このページ を参考にしてください。 Python版のサンプルコンポーネントも利用するので、Python版もインストールしてください。 またサンプルの RTシステムで rtshell を使用するため、このページ を参考にしてインストールしてください。
Python版のインストールには最初に以下のコマンドを入力してください。
wget http://svn.openrtm.org/OpenRTM-aist-Python/tags/RELEASE_1_1_0/OpenRTM-aist-Python/installer/install_scripts/pkg_install_python_debian.sh sudo sh pkg_install_python_debian.sh
Raspberry Pi にログイン後、コマンドからデバイスファイルを操作することで動作確認を行います。 各デバイスの位置などは ラズパイマウスのマニュアル を参考にしてください。
以下のコマンドで LED が点灯、消灯しているかを確認してください。
echo 1 > /dev/rtled0 echo 0 > /dev/rtled0
echo 1 > /dev/rtled1 echo 0 > /dev/rtled1
echo 1 > /dev/rtled2 echo 0 > /dev/rtled2
echo 1 > /dev/rtled3 echo 0 > /dev/rtled3
スイッチを押した状態、離した状態で以下のコマンドを入力してください。
cat /dev/rtswitch0 cat /dev/rtswitch1 cat /dev/rtswitch2 cat /dev/rtswitch3
以下のコマンドでブザーが鳴るかを確認してください。
echo 440 > /dev/rtbuzzer0 echo 0 > /dev/rtbuzzer0
距離センサーに物体を近づけた状態、離した状態で以下のコマンドを入力してください。
cat /dev/rtlightsensor0
最初にモーター電源スイッチを ON にしてください。
以下のコマンドで車輪が回転するかを確認してください。
echo 1 > /dev/rtmotoren0 echo 400 > /dev/rtmotor_raw_l0 echo -400 > /dev/rtmotor_raw_l0 echo 0 > /dev/rtmotor_raw_l0 echo 400 > /dev/rtmotor_raw_r0 echo -400 > /dev/rtmotor_raw_r0 echo 0 > /dev/rtmotor_raw_r0 echo 0 > /dev/rtmotoren0
終わったらモーター電源スイッチを OFF にしてください。
RaspberryPiMouseRTC は名城大学のロボットシステムデザイン研究室で開発されているラズパイマウス制御用の RTコンポーネントです。
以下のコマンドでインストールできます。
git clone https://github.com/rsdlab/RaspberryPiMouseRTC.git cd RaspberryPiMouseRTC cmake . make
以下の RTC は必要に応じてインストールしてください。
ラズパイマウスの距離センサーが障害物を感知した際に回転して回避する運動を生成する RTC です。
以下のコマンドでインストールできます。
git clone https://github.com/Nobu19800/RaspberryPiMouseController_DistanceSensor cd RaspberryPiMouseController_DistanceSensor cmake . make
RaspberryPiMouseController_DistanceSensor | ||
InPort | ||
名前 | データ型 | 説明 |
target_velocity_in | RTC::TimedVelocity2D | 補正前の目標速度 |
distance_sensor | RTC::TimedShortSeq | 距離センサーの計測値 |
OutPort | ||
名前 | データ型 | 説明 |
target_velocity_out | RTC::TimedVelocity2D | 補正後の目標速度 |
コンフィギュレーションパラメーター | ||
名前 | デフォルト値 | 説明 |
sensor_limit | 10 | 回避運動を開始する距離センサーの計測値 |
rotational_speed | 1.6 | 回避運動の速さ |
stop_velocity | 0.01 | 停止していると判定する直進速度 |
ジョイスティックでラズパイマウスを指定の方角へ制御するための RTC です。 ※この RTC の動作には以下の NineAxisSensor_RT_USB等の方角が計測できる RTC が必須です。
以下のコマンドでインストールできます。
git clone https://github.com/Nobu19800/RaspberryPiMouseController_Joystick cd RaspberryPiMouseController_Joystick cmake . make
RaspberryPiMouseController_Joystick | ||
InPort | ||
名前 | データ型 | 説明 |
joystick_float | RTC::TimedFloatSeq | ジョイスティックの入力 |
joystick_long | RTC::TimedFloatSeq | ジョイスティックの入力 |
orientation | RTC::TimedOrientation3D | センサーなど計測した姿勢 |
OutPort | ||
名前 | データ型 | 説明 |
out | RTC::TimedVelocity2D | 目標速度 |
コンフィギュレーションパラメーター | ||
名前 | デフォルト値 | 説明 |
forward_factor | 0.01 | 入力に対する直進速度の大きさ |
tangential_factor | 1.0 | 入力に対する回転速度の大きさ |
x_reverse | 0 | 1の時はジョイスティックのX座標を反転する |
m_y_reverse | 0 | 1の時はジョイスティックのY座標を反転する |
アールティが販売している USB出力9軸 IMUセンサーモジュール の計測値を出力する RTC です。
以下のコマンドでインストールできます。
git clone https://github.com/Nobu19800/NineAxisSensor_RT_USB cd NineAxisSensor_RT_USB cmake . make
NineAxisSensor_RT_USB | ||
OutPort | ||
名前 | データ型 | 説明 |
acc | RTC::TimedAcceleration3D | 加速度センサーの計測値 |
magn | RTC::TimedDoubleSeq | 地磁気センサーの計測値 |
gyro | RTC::TimedAngularVelocity3D | ジャイロセンサーの計測値 |
temp | RTC::TimedDouble | 温度センサーの計測値 |
rot | RTC::TimedOrientation3D | 姿勢 |
コンフィギュレーションパラメーター | ||
名前 | デフォルト値 | 説明 |
rotOffset | 0 | 姿勢のオフセット(0[rad]を北以外の方角にしたい場合に調整) |
magnOffsetX | -65 | 地磁気センサーのオフセット(X軸) |
magnOffsetY | -60 | 地磁気センサーのオフセット(Y軸) |
magnOffsetZ | -5 | 地磁気センサーのオフセット(Z軸) |
serial_port | COM3(Windows)、/dev/ttyACM0(Linux) | デバイスファイル名 |
地磁気センサーのキャリブレーション用のソフトウェアは以下のコマンドでインストールできます。
git clone https://github.com/Nobu19800/CalibrationUSBNineAxisSensor cd CalibrationUSBNineAxisSensor cmake . make
実行すると10秒カウントを始めるので、センサーをいろんな姿勢になるように回転させてください。 可能ならばスマートフォンの8の字調整の動きを行ってください。
そして最後にX・Y・Z軸の地磁気センサの補正値が表示されるので、その値に-1掛けた数値を NineAxisSensor_RT_USB のコンフィギュレーションパラメーターに反映させてください。
ロボットにセンサーを取り付ける等した場合は再度キャリブレーションを行ってください。
上記の RTC を一括でインストールします。 以下のコマンドを入力してください。
git clone https://github.com/Nobu19800/RaspberryPiMouseRTSystem_script_Raspbian cd RaspberryPiMouseRTSystem_script_Raspbian sh Component/install_rtc.sh
これで RaspberryPiMouseRTSystem_script_Raspbian の Component フォルダー内に各 RTC がインストールされます。 ※キャリブレーション用ソフトウェアはインストールされないので、手動でインストールしてください。
RTC の起動、RTシステムの復元を自動化するためのスクリプトファイルです。 ここ からダウンロードしてください。
ラズパイマウス操作用GUIです。 スクリプトファイルの項目でダウンロードしたファイルの中に同梱されています。
RaspberryPiMouseGUI | ||
InPort | ||
名前 | データ型 | 説明 |
current_velocity | RTC::TimedVelocity2D | 現在の速度 |
current_pose | RTC::TimedPose2D | 現在の位置、姿勢 |
distance_sensor | RTC::TimedShortSeq | 距離センサの計測値 |
orientation | RTC::TimedOrientation3D | 現在の姿勢 |
OutPort | ||
名前 | データ型 | 説明 |
target_velocity | RTC::TimedVelocity2D | 目標速度 |
target_position | RTC::TimedPoint2D | 目標位置(未使用) |
update_pose | RTC::TimedPose2D | 位置再設定 |
サンプルの RTシステムの一部で以下のRTCを使用するためインストールしてください。
ジョイスティックで操作するための RTC です。 以下のサイトからインストーラーをダウンロードして実行してください。
DirectInputRTC のアウトポートからの出力(TimedLongSeq型)を TimedVelocity2D型に変換する RTC です。 以下のサイトからインストーラーをダウンロードして実行してください。
まず最初に Windows でネームサーバー、RTシステムエディタを起動してください。 詳しい手順は このページ を参考にしてください。
Raspbianの 一括インストールの項目 でダウンロードしたファイルの中に rtc.conf があるので、rtc.conf の以下の ppp.pp.pp.ppp の部分を Windows側の IPアドレスに変更してください。
corba.nameservers: ppp.pp.pp.ppp
これで起動したコンポーネントが Windows のネームサーバーに登録されるようになります。
Windows で IPアドレスを確認するには以下のコマンドを入力します。
ipconfig
Windows側のRTCは スクリプトファイルの項目 でダウンロードしたファイルの中に start_component.bat というバッチファイルがあるのでそれを実行すれば以下の RTC が起動します。
DirectInput0 JoystickToVelocity0 RaspberryPiMouseGUI0 TkJoyStick0
※64bit版 Windows、32bit版 OpenRTM-aist を対象にしています。32bit版 Windows の場合は start_component_32.bat、64bit版 OpenRTM-aist を利用する場合は start_component_64.bat を起動してください。 ※Python のインストールしたディレクトリーにパスが通っていない場合、TkJoyStick は起動できません。お手数ですが このページ の手順を参考にして手動で起動してください。
一括インストールの項目 でダウンロードしたフォルダーの中の start_rtc.sh を実行することで起動できます。
cd RaspberryPiMouseRTSystem_script_Raspbian sh start_rtc.sh
これで以下のコンポーネントが起動します。
RaspberryPiMouseRTC0 RaspberryPiMouseController_DistanceSensor0 RaspberryPiMouseController_Joystick0 NineAxisSensor_RT_USB0
Windows側で スクリプトファイルの項目 でダウンロードしたファイルのSimpleControlRasPiMouse フォルダー内の SimpleControlRasPiMouse_resurrect.bat を実行してください。 これでデータポートの接続、コンフィギュレーションパラメーターの設定などが行われます。 次に SimpleControlRasPiMouse_activate.bat を実行すると RTC をアクティブ化します。 SimpleControlRasPiMouseはGUI からラズパイマウスを操作する RTシステムです。
非アクティブにする際は SimpleControlRasPiMouse_stop.bat を起動してください。 SimpleControlRasPiMouse_teardown.bat を起動するとポートの接続を切断します。
SimpleControlRasPiMouse 以外のサンプルも****_resurrect.bat で RTシステム復元、****_activate.bat でアクティブ化、****_stop.bat で非アクティブ化、****_teardown.bat でポートの切断ができます。
ファイル名 | 内容 |
****_resurrect.bat | RTシステム復元 |
****_activate.bat | アクティブ化 |
****_stop.bat | 非アクティブ化 |
****_teardown.bat | ポートの切断 |
このサンプルは GUI によるラズパイマウスの操作に加え、距離センサが物体を検知すると回転して回避を行う RTシステムです。 試しに RaspberryPiMouseController_DistanceSensor0 のコンフィギュレーションパラメーター sensor_limit の値を変更してみると動きが変わると思います。
このサンプルは OpenRTM-aist-Python のサンプルコンポーネント TkJoyStick で傾けた方角にラズパイマウスを操作するRTシステムです。 このサンプルの動作には USB出力9軸 IMUセンサモジュールを Raspberry Pi に接続しておく必要があります。 センサのキャリブレーション はラズパイマウスに装着した状態で行ってください。
このサンプルは TkJoyStick による走行する方角の操作ができることに加えて、距離センサーが物体を検知した際に回避運動を行う RTシステムです。
このサンプルはゲームパッドのアナログスティックで傾けた方向にラズパイマウスを操作する RTシステムです。 Windows側の PC にゲームパッドを接続してから起動してください。
このサンプルはゲームパッドによる走行する方向の操作ができることに加えて、距離センサーが物体を検知した際に回避を行う RTシステムです。
このサンプルはゲームパッドのアナログスティックで傾けた方角にラズパイマウスを操作する RTシステムです。 9軸センサにより現在の姿勢を計算して、アナログスティックの傾けた方角に進むように制御を行います。
このサンプルはゲームパッドによる走行する方角の操作ができることに加えて、距離センサーが物体を検知した際に回避を行う RTシステムです。
新規作成した RTC を RaspberryPiMouseRTC と接続して制御するまでの手順を説明します。
まずは Windows、Ubuntu上で このページ の手順に従って RTC を作成してください。 RTC の仕様は以下のように入力します。
基本 | ||
モジュール名 | RasPiMouseSampleCPP、もしくは RasPiMouseSamplePy | |
アクティビティ | ||
有効アクション | onInitialize、onExecute、onActivated、onDeactivated | |
データポート | ||
InPort | ||
名前 | データ型 | 説明 |
distance_sensor | RTC::TimedShortSeq | 距離センサーの計測値 |
OutPort | ||
名前 | データ型 | 説明 |
target_velocity | RTC::TimedVelocity2D | 目標速度 |
コンフィギュレーション | ||
名前 | 型 | 説明 |
forward_velocity | double | 直進速度、デフォルト値は0.0、制約条件に-0.20<=x<=0.20、Widgetはslider、Stepは0.02 |
rotate_velocity | double | 回転速度、デフォルト値は0.0、制約条件に-1.6<=x<=1.6、Widgetはslider、Stepは0.2 |
stop_distance | short | 距離センサーで物体を検知した場合に、前進しないようにする距離センサーの計測値、デフォルト値は300 |
言語・環境 | ||
言語 | C++、もしくは Python |
この RTC ではコンフィギュレーションパラメーター forward_velocity、rotate_velocity に入力した速度を target_velocity から RaspberryPiMouseRTC に送信します。 さらに distance_sensor で受信した距離センサーの計測値から、物体をある程度まで近づけると前進できなくなるようにします。
※RTC は Raspberry Pi 上で動作させることを前提にしていますが、動作確認や講習会での利用には Windows や Ubuntu上で動作させても問題はないので、その場合はコードの編集をする前に CMake で Visual Studio、もしくは Code::Blocks のプロジェクトを生成しておくことをお勧めします。CMake でプロジェクト生成からビルドまでの手順は以下のページに記載してあります。
プロジェクトが生成できたら Visual Studio の場合は RasPiMouseSampleCPP.sln、Code::Blocks の場合は RasPiMouseSampleCPP.cbp を開いてソースコードの編集を行ってください。
まずは onExecute 関数を編集します。
以下は forward_velocity、rotate_velocity の値を target_velocity から送信するコードです。
C++(src/RasPiMouseSampleCPP.cpp)
RTC::ReturnCode_t RasPiMouseSampleCPP::onExecute(RTC::UniqueId ec_id) { //コンフィギュレーションパラメーターで設定した速度を送信する m_target_velocity.data.vx = m_forward_velocity; m_target_velocity.data.va = m_rotate_velocity; setTimestamp(m_target_velocity); m_target_velocityOut.write(); return RTC::RTC_OK; }
Python(RasPiMouseSamplePy.py)
def onExecute(self, ec_id): #コンフィギュレーションパラメーターで設定した速度を送信する self._d_target_velocity.data.vx = self._forward_velocity[0] self._d_target_velocity.data.vy = 0 self._d_target_velocity.data.va = self._rotate_velocity[0] OpenRTM_aist.setTimestamp(self._d_target_velocity) self._target_velocityOut.write()
一応、非アクティブ状態の時は停止するように onDeactivated で速度0を送信するようにします。
C++(src/RasPiMouseSampleCPP.cpp)
RTC::ReturnCode_t RasPiMouseSampleCPP::onDeactivated(RTC::UniqueId ec_id) { //停止する m_target_velocity.data.vx = 0; m_target_velocity.data.vy = 0; m_target_velocity.data.va = 0; setTimestamp(m_target_velocity); m_target_velocityOut.write(); return RTC::RTC_OK; }
Python(RasPiMouseSamplePy.py)
def onDeactivated(self, ec_id): #停止する self._d_target_velocity.data.vx = 0 self._d_target_velocity.data.vy = 0 self._d_target_velocity.data.va = 0 OpenRTM_aist.setTimestamp(self._d_target_velocity) self._target_velocityOut.write() return RTC.RTC_OK
共通インターフェース仕様書 では進行方向をX軸正方向にしているため、Velocity2D型の vx に直進速度、va に回転速度を入力します。
Python ではさらにコンストラクタの以下の部分を修正してください。
Python(RasPiMouseSamplePy.py)
#self._d_target_velocity = RTC.TimedVelocity2D(RTC.Time(0,0),0) self._d_target_velocity = RTC.TimedVelocity2D(RTC.Time(0,0),RTC.Velocity2D(0,0,0))
※ここまでの作業だけでもラズパイマウスの動作は可能なので、面倒ならば以下の手順は飛ばしてもらっても大丈夫です。
次に距離センサーで物体を検知した場合に停止する処理を書きます。 ここで distance_sensorにonExecute が呼び出された時に新規に受信したデータが必ず存在するとは限らないので、距離センサーのデータを一時的に格納しておく変数を宣言しておきます。
C++(include/RasPiMouseSampleCPP/RasPiMouseSampleCPP.h)
private: int m_last_sensor_data[4]; /*センサーのデータを格納する変数*/
Python(RasPiMouseSamplePy.py)
def __init__(self, manager): OpenRTM_aist.DataFlowComponentBase.__init__(self, manager) #センサーのデータを格納する変数 self._last_sensor_data = [0, 0, 0, 0]
次に onExecute に距離センサーが物体を検知した場合に停止する処理を追加します。
C++(src/RasPiMouseSampleCPP.cpp)
RTC::ReturnCode_t RasPiMouseSampleCPP::onExecute(RTC::UniqueId ec_id) { //ここから //データを新規に受信した場合に、データをm_last_sensor_dataを格納する if (m_distance_sensorIn.isNew()) { m_distance_sensorIn.read(); if (m_distance_sensor.data.length() == 4) { for (int i = 0; i < 4; i++) { m_last_sensor_data[i] = m_distance_sensor.data[i]; } } } //センサーの計測値がstop_distance以上の時に前進しないようにする if (m_forward_velocity > 0) { for (int i = 0; i < 4; i++) { if (m_last_sensor_data[i] > m_stop_distance) { m_target_velocity.data.vx = 0; m_target_velocity.data.vy = 0; m_target_velocity.data.va = 0; setTimestamp(m_target_velocity); m_target_velocityOut.write(); return RTC::RTC_OK; } } } //ここまで //コンフィギュレーションパラメーターで設定した速度を送信する m_target_velocity.data.vx = m_forward_velocity; (以下略)
Python(RasPiMouseSamplePy.py)
def onExecute(self, ec_id): #ここから #データを新規に受信した場合に、データをm_last_sensor_dataを格納する if self._distance_sensorIn.isNew(): data = self._distance_sensorIn.read() if len(data.data) == 4: self._last_sensor_data = data.data[:] #センサーの計測値がstop_distance以上の時に前進しないようにする if self._forward_velocity[0] > 0: for d in self._last_sensor_data: if d > self._stop_distance[0]: self._d_target_velocity.data.vx = 0 self._d_target_velocity.data.vy = 0 self._d_target_velocity.data.va = 0 OpenRTM_aist.setTimestamp(self._d_target_velocity) self._target_velocityOut.write() return RTC.RTC_OK #ここまで #コンフィギュレーションパラメーターで設定した速度を送信する self._d_target_velocity.data.vx = self._forward_velocity[0] (以下略)
一応ですが、onActivate 関数で m_last_sensor_data を0に設定するようにします。
C++(src/RasPiMouseSampleCPP.cpp)
RTC::ReturnCode_t RasPiMouseSampleCPP::onActivated(RTC::UniqueId ec_id) { for (int i = 0; i < 4; i++) { m_last_sensor_data[i] = 0; } return RTC::RTC_OK; }
Python(RasPiMouseSamplePy.py)
def onActivated(self, ec_id): self._last_sensor_data = [0, 0, 0, 0] return RTC.RTC_OK
Raspbianにdoxygen がインストールされていない場合は CMakeLists.txt の以下の部分を修正してください。
#option(BUILD_DOCUMENTATION "Build the documentation" ON) option(BUILD_DOCUMENTATION "Build the documentation" OFF)
編集が完了したら Raspberry Pi にソースコードを転送してください。 Tera Term を使用している場合はZIP等に圧縮して転送してから Raspberry Pi 側で解凍してください。
※Windows、Ubuntuで動作させる場合は転送しないでください。
ソースコードの編集が終了したら C++ の場合はビルドを行います。
※Visual Studio、もしくは Code::Blocks で編集している場合は GUI 上の操作でビルドを行ってください。
ソースコードのあるディレクトリーに移動して以下のコマンドを入力すればビルドできます。
cd RasPiMouseSampleCPP cmake . make
cmakeがインストールされていない場合は以下のコマンドを入力してください。
sudo apt-get install cmake
ビルドが完了したら RTC を起動します。 以下のコマンドで起動できます。
src/RasPiMouseSampleCPPComp -f rtc.conf&
python RasPiMouseSamplePy.py -f rtc.conf&
※Windows上で RTC を起動する場合は RasPiMouseSampleCPPComp.exe(RasPiMouseSamplePy.py)をダブルクリックしてください。
次に RaspberryPiMouseRTC を起動させます。 以下のコマンドで起動してください。
cd RaspberryPiMouseRTC src/RaspberryPiMouseRTCComp -f rtc.conf&
まずは動作確認のためにデータポートの接続を行います。 Windows側で RTシステムエディタを起動してください。 最初に Raspberry Pi で起動しているネームサーバーを RTシステムエディタのビューに追加します。 [ネームサーバー追加] ボタンをクリックして Raspberry Pi の IPアドレスを入力してください。
Raspberry Pi の IPアドレスは以下のコマンドで確認できます。
ifconfig
ネームサーバーを追加したらデータポートを以下のように接続してください。
ポートの接続 | |
RasPiMouseSampleCPP0(RasPiMouseSamplePy0) | RaspberryPiMouseRTC0 |
target_velocity | target_velocity_in |
distance_sensor | ir_sensor_out |
そして RTC をアクティブ化すると動作を開始します。 動作開始前にモーター電源スイッチはONにしておいてください。
まずは RasPiMouseSampleCPP(RasPiMouseSamplePy) のコンフィギュレーションパラメーターを変更する事でラズパイマウスを操作してみます。
RTシステムエディタで RasPiMouseSampleCPP0(RasPiMouseSamplePy0) を選択して、Configuration View の編集を選択してください。
すると以下のウインドウが起動します。
forward_velocity と rotate_velocity のスライダーによりラズパイマウスを操作できます。
次に距離センサーが障害物を検知した場合に停止するかを確認してみます。 forward_velocity を0.2等に設定して前進させてください。その状態で障害物を進行方向に置いて動作を確認してください。
停止した場合は forward_velocity を0未満に設定して後退すれば前進できるようになります。
参考までにですが、/dev/rtlightsensor0のデバイスファイルから取得できる数値とセンサーまでの距離との関係は以下のようになっています。
デバイスファイルから取得した数値 | 実際の距離[m] |
1394 | 0.01 |
792 | 0.02 |
525 | 0.03 |
373 | 0.04 |
299 | 0.05 |
260 | 0.06 |
222 | 0.07 |
181 | 0.08 |
135 | 0.09 |
100 | 0.10 |
81 | 0.15 |
36 | 0.20 |
17 | 0.25 |
16 | 0.30 |
手作業で測った数値なので、あくまで参考までに利用してください。
今回作成したサンプルコードは ここ から入手できます。
ここからはさらに距離センサーで計測した距離が一定以下になった場合に回転のより障害物を回避する動作を実装します。 まず、ラズパイマウスのセンサーは以下のように取り付けられてあります。
このため、右側のセンサーで計測した距離が一定以下の場合は左方向へ、左側のセンサーで計測した距離が一定以下の場合は右方向へ回転運動することで回避運動を行います。
新たに以下のコンフィギュレーションパラメーターを設定します。 前進する速度が stop_velocity 以上で、さらにセンサーの値が sensor_limit 以下の場合に回避運動を行います。
コンフィギュレーション | ||
名前 | 型 | 説明 |
sensor_limit | double | 回避運動を行う距離センサーの値、デフォルト値は10 |
rotational_speed | double | 回転速度、デフォルト値は1.6 |
stop_velocity | double | 前進しているとみなす速さ、デフォルト値は0.01 |
onExecute 関数の実装を以下のように実装します。 ここで 動作確認の項目 で述べたように距離センサーは距離が短くなるほど大きな値を出力するので注意してください。
RTC::ReturnCode_t RaspberryPiMouseController_DistanceSensor::onExecute(RTC::UniqueId ec_id) { //距離センサーのデータを変数に格納 if (m_distance_sensorIn.isNew()) { m_distance_sensorIn.read(); if (m_distance_sensor.data.length() >= 4) { m_ir_sensor_r0 = m_distance_sensor.data[0]; m_ir_sensor_r1 = m_distance_sensor.data[1]; m_ir_sensor_l1 = m_distance_sensor.data[2]; m_ir_sensor_l0 = m_distance_sensor.data[3]; } } //目標速度のデータを変数に格納 if (m_target_velocity_inIn.isNew()) { m_target_velocity_inIn.read(); m_target_vx = m_target_velocity_in.data.vx; m_target_vy = m_target_velocity_in.data.vy; m_target_va = m_target_velocity_in.data.va; }
double vel = sqrt(m_target_vx*m_target_vx); //右側のセンサーの値が一定以上かを判定(動作確認の項で述べた通り、センサーの値は距離が短くなるほど大きな値を出力する) //さらに前進速度が一定以上かを判定 if (((m_ir_sensor_r0 > m_sensor_limit) || (m_ir_sensor_r1 > m_sensor_limit)) && (vel > m_stop_velocity)) { //左回転する速度を出力 m_target_velocity_out.data.vx = 0; m_target_velocity_out.data.vy = 0; m_target_velocity_out.data.va = m_rotational_speed; setTimestamp(m_target_velocity_out); m_target_velocity_outOut.write(); } //右側のセンサーの値が一定以上化か判定 else if (((m_ir_sensor_l0 > m_sensor_limit) || (m_ir_sensor_l1 > m_sensor_limit)) && (vel > m_stop_velocity)) { //右回転する速度を出力 m_target_velocity_out.data.vx = 0; m_target_velocity_out.data.vy = 0; m_target_velocity_out.data.va = -m_rotational_speed; setTimestamp(m_target_velocity_out); m_target_velocity_outOut.write(); } //センサーが何も検知しない場合 else { //入力速度をそのまま出力 m_target_velocity_out.data.vx = m_target_vx; m_target_velocity_out.data.vy = m_target_vy; m_target_velocity_out.data.va = m_target_va; setTimestamp(m_target_velocity_out); m_target_velocity_outOut.write(); } return RTC::RTC_OK; }
RTシステムの保存については RTシステムエディタ上でもできるのですが、rtshell により RTシステムの復元を自動化することができます。 RTシステムエディタでポートの接続、コンフィギュレーションパラメーターを設定後、rtcryo コマンドを実行してください。
rtcryo localhost -o testSystem.rtsys
これで、testSystem.rtsys というファイルにRTシステムの情報が保存されます。
ただし今回の課題のように複数のネームサーバーに登録された RTC を使用する場合、以下のように複数のネームサーバーを指定する必要があります。
rtcryo localhost 192.168.11.1 -o testSystem.rtsys
保存した RTシステムを復元するためには rtresurrect コマンドを使用します。
rtresurrect testSystem.rtsys
RTC をアクティブ化するには rtstart コマンドを使用します。
rtstart testSystem.rtsys
RTC の非アクティブ化は rtstop コマンドを使用します。
rtstop testSystem.rtsys
ポートを切断する場合は rtteardown コマンドを使用します。
rtteardown testSystem.rtsys
注意点として、RTC はデフォルトの設定だとネームサーバーにはホスト名. host_cxt 以下に登録されます。 ホスト名は環境によって違うので、この手順で RTシステムを保存しても他の環境では再現できないという事になります。 このため、rtc.conf を編集してネームサーバーの Root 直下に登録するようにすると、他の環境でも RTシステムの復元ができるようになります。
naming.formats: %n.rtc
このページでは Rapberry Pi マウスのシミュレーターRTC の仕様、利用方法について説明します。
RaspberryPiMouseSimulator | ||
InPort | ||
名前 | データ型 | 説明 |
target_velocity_in | RTC::TimedVelocity2D | 目標速度 |
pose_update | RTC::TimedPose2D | 現在位置の更新 |
OutPort | ||
名前 | データ型 | 説明 |
current_velocity_out | RTC::TimedVelocity2D | 現在の速度 |
current_pose_out | RTC::TimedPose2D | 現在位置 |
ir_sensor_out | RTC::TimedShortSeq | 距離センサーから取得したデータを再現した値 |
ir_sensor_metre_out | RTC::TimedDoubleSeq | 距離センサーで計測した距離 |
コンフィギュレーションパラメーター | ||
名前 | デフォルト値 | 説明 |
sampling_time | -1 | シミュレーションの刻み幅。負の値に設定した場合は実行コンテキストの周期で設定 |
draw_time | 0.01 | 描画の周期 |
sensor_param | 1394,792,525,373,299,260,222,181,135,100,81,36,17,16 | 距離センサーのデータを生データに変換するパラメーター。0.01、0.02、0.03、0.04、0.05、0.06、0.07、0.08、0.09、0.10、0.15、0.20、0.25、0.30[m]に対応した値を設定 |
blocksConfigFile | None | 障害物の配置設定ファイルの名前 |
以下からダウンロードできます。
展開したフォルダーの EXEフォルダー内に実行ファイル(RaspberryPiMouseSimulatorComp.exe)があります。 この EXEファイルを実行すると RTC が起動します。
ir_sensor_out、ir_sensor_metre_out と距離センサーのデータ出力を行うポートが2つありますが、RaspberryPiMouseRTC が距離センサーのデータを直接出力するようになっているため、ir_sensor_out ではシミュレーター上で計測した距離からセンサーのデータを再現して出力するようになっています。 ir_sensor_metre_out はメートル単位で距離を出力します。
blocksConfigFile というパラメーターで障害物の配置を設定する CSVファイルを指定できます。 サンプルとして test.csv というファイルを用意してあります。
このファイルに位置、角度、サイズを記述してください。
位置(X) | 位置(Y) | 位置(Z) | 長さ(L) | 幅(W) | 高さ(H) | 角度(θ) |
0.3 | 0.0 | 0.0 | 0.1 | 1.0 | 0.3 | 0.0 |
ブロックは何個でも設定可能です。
このページでは Ubuntu での Code::Blocks を利用したビルドの方法を説明します。
Code::Blocks は以下のコマンドでインストールできます。
sudo apt-get install codeblocks
そのほか Doxygen、CMake がインストール済みでない場合は以下のコマンドでインストールを行います。
sudo apt-get install doxygen cmake
RTC ビルダで生成したコードのフォルダーに移動して、以下のコマンドを入力すると build フォルダーに各種ファイルが生成されます。
mkdir build cd build cmake . -G "CodeBlocks - Unix Makefiles"
buildフォルダーの~.cbpを開きます。