kitakkun / arduinocar Goto Github PK

安定した設計・開発を行っていくため、仕様を決定し変更に強い車の制御システムを確立する。

動作検証用にセンサー1個でライントレースするプログラムを作りたい。

車の前方に配置されたセンサー情報を取得し、

• 黒だったら右回転（l_speed > r_speed）
• 白だったら左回転（l_speed < r_speed）

で制御してみる。

誤って左前・左後ろ・右前・右後ろの4つを制御に作ってしまったので、左と右だけの制御に直して欲しい。

概要

今現在、Carクラスのコンストラクタに直接コンポーネントを指定して初期化しているが、これだと左右を間違えたりしやすいという問題があるので、明示的に何を指定しているのかがわかりやすいBuilderクラスを経由してインスタンス生成するようにしたい。

概要

Sensorクラスを継承して、PhotoReflectorクラスを実装する。

背景

現在 util 名前空間に定義される bool isSensorBlack() 関数でフォトリフレクタの白黒判定をしているが、これだと実体がPhotoReflectorでないセンサーについても白黒判定を呼び出せるので、あまり望ましくない（超音波センサーも渡すことができてしまう）。

Sensor *reflector = new Sensor(11);         // フォトリフレクタのインスタンス
Sensor *distanceSensor = new Sensor(10);    // 超音波センサーのインスタンス

util::isSensorBlack(reflector);         // 想定している使い方✅
util::isSensorBlack(distanceSensor);    // 想定していない使い方❌

そこで、この閾値により白黒判定するロジックをPhotoReflectorクラス内に隠蔽したい。

仕様

PhotoReflectorクラスはコンストラクタに指定された閾値を基準に、黒であるかまたは白であるかのBool値を返す bool IsBlack() メソッドと bool IsWhite() メソッドを持つ。

bool IsBlack() の仕様

• this->GetRawValue()の値が閾値より大きければ、黒なのでtrue
• それ以外はfalse

bool IsWhite()の仕様

• 単にthis->IsBlack()の値を!(NOT)演算子で反転したものを返せばよい。

補足

継承のやり方

以下のクラスAを継承することを考える。

class A {
public:
    void Hoge();
};

C++でクラスを継承したいときは、クラスの宣言においてclass クラス名 : 継承したいクラス名 {};の形で宣言する。
例えば、クラスAを継承したBクラスを作るには、

class B : A {
};

とすればよい。しかし、これではBのインスタンスを経由してAのメソッドvoid Hoge()を呼び出すことはできない。

A *a = new A();
a->Hoge();    // 問題なし✅

B *b = new B();
b->Hoge();    // できない❌

これを解決するには、継承するクラス名の前にpublic修飾子をつける。

class B : public A {
};

とすると、

B *b = new B();
b->Hoge();    // 問題なし✅

となる。

クラス内での継承元クラスのメソッド呼び出し

まず、前提として以下のようなクラスA, Bを考える。BはAを継承したクラス。クラスB内のvoid Fuga()でクラスAのvoid Hoge()を呼び出すにはどうすればよいか？

class A {
public:
    void Hoge();
};

class B : public A {
public:
    void Fuga();
};

答えは簡単。クラスの実装部において、thisという特殊なキーワードが使える。thisは自分自身のインスタンスを指す意味合いのキーワードで、例えばクラスBのvoid Fuga()で親クラスのvoid Hoge()を呼び出すには、

void B::Fuga() {
    this->Hoge();
}

とする。

継承元クラスのコンストラクタ呼び出し

例えば、以下のようなクラスA, Bがある。BはAを継承している。これまでと異なるのはAにコンストラクタが存在することである。

class A {
public:
    A(int pin);
};

class B : public A {
public:
    B(int pin, int theta);
};

クラスBはコンストラクタで、Aと同様int pinを受け取るのに加え、int thetaを受け取っている。このような場合で、BのコンストラクタでAの初期化処理も走らせる場合、以下のように記述する。

B::B(int pin, int theta) : A(pin) {
    // Bの初期化処理
}

センサーの情報を簡単に取得するためのクラスSensorProviderを作りたい。

仕様

• 指定したキーに対応するセンサーの数値を返すgetSensorValue関数をメンバーとして持つ。

センサーを1個だけ用いて、ジグザグに移動しながらライントレースするZigZagLineTraceBrainクラスを実装したい。

前提

• Brainクラスを継承して作成する
• CalculateNextInstructionメソッドをオーバーライドして実装

具体的なアルゴリズム

• CarState.front_colorがblackならTorqueLeftInstructionを返す
• CarState.front_colorがwhiteならTorqueRightInstructionを返す

Instructionサブクラスの実装に関して

• TorqueLeftInstructionは左のタイヤ速度を指定量amount_だけ落とせばよい。
• TorqueRightInstructionは右のタイヤ速度を指定量amount_だけ落とせばよい。

実験指導書に記載されているサンプルプログラムを実機にインストールし動作検証することで、Arduino言語の仕様を確認する。

ToqueLeftInstructionおよびTorqueRightInstructionは、Wheel::Decelerateを呼び出す形で実装していた。
しかし、実際に使う際は繰り返し呼ばれることがあり、この実装方法だと繰り返し減速していき最終的にタイヤの回転が止まってしまう場合があることを確認した。

この対策として、左に曲がるときは左の回転数を左の回転数 - amount_（右も同様）として再実装したい。

今現在PidFollowControllerなど制御パラメータが多いクラスはコンストラクタが巨大なので、どれがどのパラメータなのかわかりにくい。

    controller = new PidFollowController(
        car,
        5,
        100,
        -4,
        80,
        20,
        0.052,
        0.05,
        0.042,
        0.05
    );

これを解決するためにControllerにもビルダーを入れたい。以下のようなイメージ。

    controller = PidFollowControllerBuilder()
        .SetCar(car)
        .SetBaseDistance(5)
        .SetBaseSpeed(100)
        .SetLRSensorDiff(-4)
        .SetDistanceMaxManipulation(80)
        .SetTorqueMaxManipulation(20)
        .SetDistancePWeight(0.052)
        .SetDistanceDWeight(0.05)
        .SetTorquePWeight(0.042)
        .SetTorqueDWeight(0.05)
        .Build();

概要

右のモータの方が弱くてジグザグにトレースしてしまうので、モータの出力にゲインをかけたい。

トレース車のP値、D値、基準速度などをチューニングしてトレースの挙動を安定させたい。

前提条件

センサーは車の前後左右に一つずつ配置される。

アルゴリズム

• 直進中（左右センサーが白）

• 左のセンサーが黒になったら右の回転数を上げる

• 右のセンサーが黒になったら左の回転数を上げる

概要

現在、各コンポーネントはすべてメインプログラムのグローバル変数として宣言されている。

メリット

• メインプログラム内から各コンポーネントにアクセスするのが容易(どこからでもアクセス可能)

デメリット

• アルゴリズムのファイルを外部化するのが難しい
• コンポーネントがどこでアクセスされているのかわからなくなり、将来的にバグの発生源を特定するのが難しくなる可能性が高い。

メリットよりもデメリットが大きいので、メインプログラムのグローバル変数に色々置くのをやめたい、というのが主題。

詳細

以下に現在のメインプログラムのサンプルを示す。（説明のために一部省略していること、正しいプログラムではないことに注意）

Motor *left_motor;
Motor *right_motor;
Sensor *mid_sensor;
Sensor *left_sensor;
Sensor *right_sensor;

void setup() {
     left_motor = new Motor();
     right_motor = new Motor();
     mid_sensor = new Sensor();
     // 省略
}

void loop() {
     some_algorithm();
}

void some_algorithm() {
    // 各コンポーネントクラスを参照して処理を行う
}

このsome_algorithmを外部化するには、まず初めに、some_algorithmが引数を使って動作するように変更する必要がある。

void some_algorithm(Motor *left_motor, Motor *right_motor, Sensor* mid_sensor, Sensor*right_sensor, Sensor *left_sensor) {
    // do something...
}

引数で受け取る形にしたらあとはこの関数を外部ファイルに定義・実装してインクルードすればよい。これで一応外部かはできたことになる。
でも、グローバル変数への依存は軽減できたけれども、依然としてメインプログラムでグローバル変数は減っていない。そこで次のアーキテクチャを提案する。

新しく採用するアーキテクチャ

現状の問題点

ここまで、説明してきたようにこれまでの設計には以下の問題がある。

• グローバル変数が多すぎる
• アルゴリズムの外部化が難しい

全コンポーネントの仲介クラスでグローバル変数を一つにする

まず、グローバル変数を減らすには、各コンポーネントをまとめる仲介役のクラスを作ればいい。こうすれば、グローバル変数を一つにすることができる。

例えば、ライントレース車だったら、TraceCarクラスを作って、ライントレース車が持つ各コンポーネントをTraceCarクラス内に定義する。TraceCarクラスは各コンポーネントへのをアクセスのみを提供するものとし、アルゴリズム部はこのTraceCarクラスを経由してコンポーネントにアクセスする。

こうすることで、先程のsome_algorithmは以下のように単一変数を受け取る形に書き直せる。ハードウェアに変更が入っても引数の数や型には変更が生じない。

void some_algorithm(Car *car) {
    // do something...
}

だいぶ簡素になった。そんなに難しいことはしていなくて、コンポーネントのアクセスにワンクッション挟む感じになっただけ。

// これまで
left_sensor->GetRawValue();
// これから
car->GetLeftSensor()->GetRawValue();

ちょっと記述が長くなるけれど、変更に強くなるメリットを考えれば許容レベルかな。繰り返し参照するなど、長い記述が煩わしい場合は、適宜一時的にポインタ変数を作るなどして対応する。

Sensor* left_sensor = car->GetLeftSensor();
left_sensor->GetRawValue();

アルゴリズムの外部化

グローバル変数を減らしたことで、アルゴリズムの外部化が容易になった。

ここで、また新しい課題点が見えてくる。

アルゴリズム差し替えに関数名差し替えするのはミスが発生しやすいので、避けたい。

例えば、algorithm1で動かしたいとき、メインプログラムのループ関数内では以下のように呼び出す。

algorithm1(car);

次にalgorithm2で動かしたいとき、先程の一行は

algorithm2(car);

に書き換えればいいが、
loop関数は実際のライフサイクルのみの定義に集中すべきであり、setup関数内で動作を完全に決定してしまいたい。(関数名的にもそれが理にかなっている)

アルゴリズム部も差し替えが容易になるように、CarControllerインタフェースを定義する。今やりたいことは、各アルゴリズムの呼び出し方を統一すること。

class CarController {
public:
    virtual void Operate();
};

アルゴリズム実装クラスはすべてこのCarControllerインタフェースの要件を満たしているとしたら、
loop関数に変更は入らず、setup関数内で処理アルゴリズムを差し替えることができる。

CarController *controller;

void setup() {
    Car *car  = new Car();
    controller = new ExampleController(car);    // ここのnewの後ろを変えるとアルゴリズムが切り替わる
}

void loop() {
    controller->Operate();
}

今後の設計方針

概要

車を停止させるInstructionクラスを作成する。

• ForceStopInstructionは強制的に両方の車輪の速度を0にする指示。
• StopInstructionは一定時間をかけて減速する指示。

仕様

• ForceStopInstruction
  • コンストラクタ引数なし
• StopInstruction
  • コンストラクタで目標停止時間duration_millisを受け取る

概要

#65 で述べたように、ライントレース車の各コンポーネントへのアクセスを仲介するTraceCarクラスを実装したい。

ライントレース車は以下の5つのコンポーネントを内部に持つ。

• 左モーター
• 右モーター
• **フォトリフレクター
• 左フォトリフレクター
• 右フォトリフレクター

クラス仕様は既にlib/minimum/trace_car.hに定義済みである。lib/minimum/trace_car.cppに実装部を記述してほしい。

作業ブランチ

feature/trace_car

補足

実装自体はこれまでのCarクラスの実装に近い。

概要

追従車をチューニングしてちゃんと追従するようにしたい

概要

#65 や #67 で述べているように、追従車に関してもコンポーネントを束ねるクラス FollowCar クラスを作成したい。

仕様

• 左のモータ
• 右のモータ
• 左の距離センサー（SonicSensor）
• 右の距離センサー（SonicSensor）

概要

現時点でテストが必要とは思えないが、プログラムの正常な動作を保証しハードウェアチームのデバッグがより円滑に進むよう、各コンポーネントをテスト可能にしたい。（優先度は低めだけど手があいたときに進めていきたい）

CarControllerクラスに偽コンポーネントを束ねたCarクラスを渡して、それを用いてCarControllerの動作をシミューレート・テストできるようになる。

インタフェースと実装の分離 をしたい理由

現時点のSensorクラスの実装は、以下のよう。

class Sensor {
public:
        explicit Sensor(int pin);
        virtual void Update();
        virtual int GetRawValue();
private:
        int pin_;
        int raw_value_;
};

Sensorクラスの実装部ではanalogReadやanalogWriteなど、Arduinoに依存する関数が呼び出されたりする。そのため、Arduinoと切り離してプログラムのロジックをテストすることが困難であるという問題がある。 →結局native環境でテストをするのは難しい＆めんどくさいのでArduino上で動くテストを考える。

Sensorクラスを使う側は、UpdateとGetRawValueしか呼び出さないわけだし、実際の中身がどうかというのには一切関心を向けていない。そのため、インタフェースと実装クラスに分離することが可能であり、そうすると任意の実装クラスをはめ込むことが可能になってテストが容易になる。

上のセンサークラスをインタフェースと実装クラスに分離するのであれば、

class Sensor {
public:
    virtual void Update() = 0;
    virtual int GetRawValue() = 0;
};

class SensorImpl : public Sensor {
public:
    explicit SensorImpl(int pin);
    void Update() override;
    int GetRawValue() override;
private:
    int pin_;
    int raw_value_;
};

みたいになる。こうすると、Sensorクラスを受け取るクラスに、以下のようなFakeSensorクラスを渡して、

class FakeSensor : public Sensor {
public:
    explicit FakeSensor();
    void Update() override;
    int GetRawValue() override;
    void SetRawValue(int raw_value);    // テスト用に新規追加
private:
    int raw_value_;
};

適宜SetRawValueを呼び出して任意の値をセンサーに入れてどのような挙動をするのかシミュレートしやすくなる。

やりたいこと

既存の実装コードを、インタフェースと実装部に分離して、テスト用のコンポーネントクラスを作り、プログラムにバグがないことを事前に保証できるテストコードを書くことが目的である。

Instructionには一定の時間をかけて実行する形式のものが存在する。
しかし、特定のInstructionを実行中に別の処理を緊急で割り込みしたいというケースも想定されるので、

• Instructionのキャンセル機構
• Instructionの割り込み機構

の仕様を策定する必要がある。AceRoutineのコルーチンライブラリを上手く活用して実装するつもりがあるが、具体的にどのように処理の中断(suspend)・再開(resume)するかまだ決まっていない。

できるだけ小さくて軽量かつ拡張性の高いプログラムを目指してみよう。

これまでの反省点

• プログラムの消費電力が大きすぎる
• 構造化されすぎて全体像を把握するのに時間がかかる

方針

インスタンス生成

• setup関数ではOK
• loop関数ではNG

クラスの作成

• 最低限センサークラスとモータークラスは必要（ピンの概念を隠蔽したい）
• その他のクラスはなるべく作らない => クラス分けしたほうがメリットがでかいところは積極的にクラス分けしよう！

アルゴリズム作成部

• とりあえずloop関数内にアルゴリズムを書いてもいいことにする。 => Controllerインタフェースの実装クラス内に書こう！

まずやりたいこと

• Motorクラスの作成 -> 完了✅
• Sensorクラスの作成 -> 完了✅

概要

超音波センサーに対応するクラスを実装したい。

仕様

超音波センサーは、電波を発射して、反射して電波を観測してその間の時間で距離を計測する。

• 発射と同時に実行時間を記憶
• 音波検出センサーがHIGHになるので、LOWになるまでコルーチンをループさせる
• 音波検出センサーがLOWになったら、現在の実行時間と電波を発射した時の実行時間の差に音速をかけて、2で割って距離を出す（2で割るのは往復分を考慮している）。

イメージ↓

int Update() {
    COROUTINE_LOOP() {
         SendPulse();
         while(/* 音波検出センサーがHIGH */) ;
         this->rawValue_ = /* (現在の実行時間 - 発射時の時間) x (音速) / 2 */
    }
}

void SendPulse() {
    // 信号発射処理とメンバへの時間記憶
}

容易に車を制御するためにいくつかの手続きをまとめたラップ関数を定義する。

仕様

• ぶつからないように距離を調整する制御
• 追従できるように左右の回転差を調整する制御

それぞれをPID制御で作る

概要

過去のアーキテクチャで作ったPID制御のアルゴリズムを、作り直したプログラムに適合するように移植したい。

#52 こちらのIssueが該当のPID制御部を作成したPull Requestである。ここのPidLineTraceBrainの実装を参考に現在のアーキテクチャに適合するものを作ってほしい。

概要

デバッグログを取るためのDebuggerクラスを作りたい。

仕様

とりあえずFollowCarのデバッガはFollowCarDebuggerとし、TraceCarのデバッガはTraceCarDebuggerとしよう。

以下の仕様のCarクラスを考える。（説明のためのもので、実際にはTraceCarとかになる。細かい内部実装は省略）

class Car {
private:
    Motor *left_motor_;
    Motor *right_motor_;
    Sensor *left_sensor_;
    Sensor *right_sensor_;
};

この場合CarDebuggerクラスはたとえばこんな感じ。

class CarDebugger {
public:
    explicit CarDebugger(Car *car);
    void DebugSensors();
    void DebugMotors();
private:
    Car *car_;
};

概要

左右の車輪速度に差を生じさせ、車の進路を曲げるTorqueLeftInstructionおよびTorqueRightInstructionを実装したい。

仕様

• どちらもInstructionクラスの実装クラスである。
• コンストラクタでforceパラメータを受け取り、トルクの強さを変更できるものとする。
• 左車輪か右車輪の速度を調整することにより、車の進路を曲げることができればよい。