組込みに近いものをTDDで開発してみる〜デザインパターン編〜

googletest/googlemockを使って、組込みLinux上で動作するソフトウェアをTDDで開発しています。
実際にTDDで開発している手順をリアルタイムでそのまま書いているため、行き当たりばったりな部分があります
過程も楽しんで頂ければ幸いです。
不明な点、間違っている点があれば、コメント下さい。励みになります。

これまでの経緯を詳しく知りたい方は、前回までの記事をご覧下さい。
[組込みに近いものをTDDで開発してみる〜準備編〜](https://qiita.com/tomoyuki-nakabayashi/items/23b064e3cea11dcc4152)
[組込みに近いものをTDDで開発してみる〜問題提起編〜](https://qiita.com/tomoyuki-nakabayashi/items/45bd4700c8e081107bd1)
[組込みに近いものをTDDで開発してみる〜file open編〜](https://qiita.com/tomoyuki-nakabayashi/items/648109594612fd4b518a)
[組込みに近いものをTDDで開発してみる〜libevdev初期化/終了処理編〜](https://qiita.com/tomoyuki-nakabayashi/items/c139c181151de3ae433a)
[組込みに近いものをTDDで開発してみる〜キー入力検知編〜](https://qiita.com/tomoyuki-nakabayashi/items/c139c181151de3ae433a)
[組込みに近いものをTDDで開発してみる〜中間振り返り編〜](https://qiita.com/tomoyuki-nakabayashi/items/1aa7a2ef7442e30382bc)
[組込みに近いものをTDDで開発してみる〜インタフェース継承編〜](https://qiita.com/tomoyuki-nakabayashi/items/95d98fd746d240b6eeb1)

いよいよ大詰めです。
前回、次の仕様を実装しました。

* キーボードの「A」ボタンを押すと、caps lockのLEDが点灯し、5秒後に消灯する。消灯するまでは、「A」キー押下を無視する。

キー入力検出とタイマ検出は、EventDetectorインタフェースを共通の基底クラスとすることで、同一インタフェースで使えるようになりました。
今回は、LEDへの異なる操作を、同一インタフェースで使えるようにして、さらにプログラムの拡張性を高めます。

## LED操作をどうしたいか

今のLEDドライバには、LEDを操作する3つの関数がある。

```c:led_driver.h
void TurnOnLed(LedDriver self);
void TurnOffLed(LedDriver self);
void ToggleLed(LedDriver self);
```

これらの3つを同じインタフェースで使用し、main関数を誤魔化しのない状態にしたい。

```c:main.c
  for(int i = 0; detectors[i] != NULL; i++) {
    StartEventDetector(detectors[i]);
    // イベント検出まで待つ
    while(CheckEvent(detectors[i]) != DETECTOR_EVENT_DETECTED) {}

    ToggleLed(caps_led);  // ここで共通インタフェースを呼び出し、On/Offを正しく切り替えたい
    // 仕様を満たすためには、本当は下のように書かなければならない。
    // if (i == 0) TurnOnLed(caps_led);
    // else if (i == 1) TurnOffLed(caps_led);
  }
```

## Commandパターン

そこで、LEDの操作をCommandパターンとして実装する。
Commandパターンは、『命令』をインスタンスとして表現できるデザインパターンだ。

Commandパターンは笑ってしまうほど単純だ（と言ってもC言語だとぼちぼちの量になる）。

```c:command.h
typedef struct CommandInterfaceStruct *CommandInterface;
typedef struct CommandStruct *Command;

typedef struct CommandStruct {
  CommandInterface vtable;
} CommandStruct;

// インタフェースはExecute()だけ
typedef struct CommandInterfaceStruct {
  void (*Execute)(Command);
} CommandInterfaceStruct;

void CommandExecute(Command cmd);
```

Commandインタフェースを継承するクラスは、Execute()だけを実装していれば良い。
ただ、この単純な実装に、びっくりするほどの柔軟性がある。

## LED操作Commandの実装

いつも通り、テストから考えていこう。

```cpp
// LEDをOnするCommandを生成、実行するテスト
TEST_F(LedOperatorTest, LedTrunOnOperationCallsIoWriteWithOne) {
  // driver_はLedDriverのインスタンス
  Command command = LedOperatorFactory(driver_, OP_LED_TURN_ON);
  EXPECT_CALL(*mock_io, IO_WRITE(kFd, StrEq("1\n"), 2)).Times(1);
  CommandExecute(command);
}
```

少なくとも、On/Off/Toggleの3つのLED操作Commandが必要なことが分かっている。
そこで、FactoryMethodパターンを用意して、引数で生成インスタンスを切り替えることにした。

まず、LED操作の派生クラスは次のようにした。
Commandインタフェースを継承する以外は、LedDriverのインスタンスがあるだけだ。

```c:led_operator_factory.c
typedef struct LedOperatorStruct {
  CommandStruct base;
  LedDriver driver;
} LedOperatorStruct;

typedef struct LedOperatorStruct *LedOperator;
```

LEDをOnするExecute()の実装は、次のようになる。

```c:led_operator_factory.c
static void LedTurnOn(Command super) {
  LedOperator self = (LedOperator)super;
  TurnOnLed(self->driver);
}

static CommandInterfaceStruct interface = {
  .Execute = LedTurnOn
};
```

後は、インスタンスを作ってあげるだけだ。
この時点では、LED操作を切り替える引数は使っていないが、この後すぐ実装する。

```c:led_operator_factory.c
Command LedOperatorFactory(LedDriver driver, int32_t op_id) {
  if (driver == NULL) return NULL;
  LedOperator command = calloc(1, sizeof(LedOperatorStruct));
  command->base.vtable = &interface;
  command->driver = driver;

  return (Command)command;
}
```

ここまで作れば、LEDをOnするテストが通るようになる。

少し説明が雑になるが、順次、次のテストを用意し、実装を進めていった。

```cpp
// OffするCommandを作生成、実行するテスト
TEST_F(LedOperatorTest, LedTrunOffOperationCallsIoWriteWithZero) {
  Command command = LedOperatorFactory(driver_, OP_LED_TURN_OFF);
  EXPECT_CALL(*mock_io, IO_WRITE(kFd, StrEq("0\n"), 2)).Times(1);
  CommandExecute(command);
}

// ToggleするCommandを生成、実行するテスト
TEST_F(LedOperatorTest, LedToggleOperationTogglesIoWrite) {
  Command command = LedOperatorFactory(driver_, OP_LED_TOGGLE);

  InSequence s;
  EXPECT_CALL(*mock_io, IO_WRITE(kFd, StrEq("1\n"), 2)).Times(1);
  EXPECT_CALL(*mock_io, IO_WRITE(kFd, StrEq("0\n"), 2)).Times(1);
  EXPECT_CALL(*mock_io, IO_WRITE(kFd, StrEq("1\n"), 2)).Times(1);

  CommandExecute(command);
  CommandExecute(command);
  CommandExecute(command);
}

// FactoryがCommand生成に失敗するテスト
TEST_F(LedOperatorTest, FatoryReturnsNullIfFailed) {
  Command command = LedOperatorFactory(nullptr, OP_LED_TURN_ON);
  EXPECT_EQ(nullptr, command);

  command = LedOperatorFactory(driver_, -1);
  EXPECT_EQ(nullptr, command);

  command = LedOperatorFactory(driver_, OP_MAX_FACTORY_ID);
  EXPECT_EQ(nullptr, command);
}
```

最終的なプロダクトコードは次のようになる。

```c:led_operator_factory.c
static void LedTurnOn(Command super) {
  LedOperator self = (LedOperator)super;
  TurnOnLed(self->driver);
}

static void LedTurnOff(Command super) {
  LedOperator self = (LedOperator)super;
  TurnOffLed(self->driver);
}

static void LedToggle(Command super) {
  LedOperator self = (LedOperator)super;
  ToggleLed(self->driver);
}

static CommandInterfaceStruct interface[OP_MAX_FACTORY_ID] = {
  { .Execute = LedTurnOn },
  { .Execute = LedTurnOff },
  { .Execute = LedToggle }
};

Command LedOperatorFactory(LedDriver driver, int32_t op_id) {
  if (driver == NULL) return NULL;
  if (op_id <= -1 || OP_MAX_FACTORY_ID <= op_id) return NULL;

  LedOperator command = calloc(1, sizeof(LedOperatorStruct));
  command->base.vtable = &interface[op_id];
  command->driver = driver;

  return (Command)command;
}
```

これで、LEDのOnだろうが、Offだろうが、Toggleだろうが、全て、Commandインタフェースから実行できるようになった。

## プロダクトコード

最終的なプロダクトコードは次の通りだ。

```c:main.c
int main(void) {
  struct timeval kTime = {};
  const struct input_event kPressA = {kTime, EV_KEY, KEY_A, INPUT_KEY_PRESSED};

  EventDetector detectors[NUM_OPERATION_ON_DETECTION];
  detectors[0] = CreateKeyInputDetector(KEYBOARD_DEVICE, &kPressA);
  detectors[1] = CreateTimeOutDetector(5000, TIMER_ONE_SHOT);
  
  LedDriver caps_led = CreateLedDriver();
  if (InitLedDriver(caps_led, LED_DEVICE) != LED_DRIVER_SUCCESS) {
    DEBUG_LOG("Fail to init led device\n");
    exit(1);
  }

  Command operators[NUM_OPERATION_ON_DETECTION];
  operators[0] = LedOperatorFactory(caps_led, OP_LED_TURN_ON);
  operators[1] = LedOperatorFactory(caps_led, OP_LED_TURN_OFF);

  // EventDetectorとCommandインタフェースだけで、仕様を実現している
  for(int i = 0; i < NUM_OPERATION_ON_DETECTION; i++) {
    StartEventDetector(detectors[i]);
    while(CheckEvent(detectors[i]) != DETECTOR_EVENT_DETECTED) {}

    CommandExecute(operators[i]);
  }
// 終了処理は省略
}
```

ここまでできれば、様々な種類のイベント検出し、何らかの操作をする、という機能が、全て同じインタフェースで実装できる。

## 2秒のあいだにボタンが3回押されたことを検出する

次の問題を実装する（ただし、レギュレーションはけっこう無視する）。
[(問題) 2秒のあいだにボタンが3回押されたかで、真・偽を返す関数を実装してください。](https://qiita.com/mt08/items/8de342efd25effa8822a)

上記の問題では、2秒経過をタイマで計りながら、ボタン押下を検出する。
個々の要素は大したことないが、2つのことを同時にやる必要がある。

今回は、簡易な並列処理のデザインパターンであるActiveObjectパターンを使って、この問題を解いてみる。

話が前後してしまうため、テストの記載は省略しますが、これ以降も全てTDDで開発しています。
ActiveObjectに関するテストはこちら。
[active_object_test.c](https://github.com/tomoyuki-nakabayashi/TDDforEmbeddedSystem/blob/master/led_controller/test/active_object_test.cpp)

## ActiveObjectパターン

このパターンは、APIとコアとなる実装を見た方が、理解しやすいと思う。
大雑把にいうと、実行したいCommandを複数追加しておいて、Run()で一気に実行するだけだ。

```c:active_object_engine.h
// engineにCommandを追加する
void FuelEngine(ActiveObjectEngine engine, Command cmd);

// engineに搭載されているCommandを実行する
void EngineRuns(ActiveObjectEngine engine);
```

```c:active_object_engine.c
typedef struct ActiveObjectEngineStruct {
  // glibのリストを拝借。FuelEngineで追加されたCommandリストを保持する。
  GSList *commands;
} ActiveObjectEngineStruct;

void FuelEngine(ActiveObjectEngine engine, Command cmd) {
  if ((engine == NULL) || (cmd == NULL)) return;
  // Commandをengineに追加する
  engine->commands = g_slist_append(engine->commands, (gpointer)cmd);
}

void EngineRuns(ActiveObjectEngine engine) {
  while(g_slist_length(engine->commands) > 0) {
    // engineにCommandが存在する間、Commandを実行し続ける。
    Command cmd = (Command)g_slist_nth_data(engine->commands, 0);
    CommandExecute(cmd);
    // 一度実行したコマンドはengineから除く
    engine->commands = g_slist_remove(engine->commands, (gpointer)cmd);
  }
}
```

ここまで見る限りは、なんてことないように見える。
ActiveObjectの本領は、**Commandがengineに自分自身を追加し始めてからだ**。

```c:detect_chain.c
// このDetectChainは、後程コナミコマンドを検出するために使用する。
// イベントを検出するとwakeup Commandを実行するCommand
Command CreateDetectChain(EventDetector detector,
                          // 自分を実行するengineを引数に取る
                          ActiveObjectEngine engine,
                          // イベント検出時にengineに追加するコマンド
                          Command wakeup) {
  DetectChain self = calloc(1, sizeof(DetectChainStruct));
  self->base.vtable = &interface;
  self->detector = detector;
  self->wakeup = wakeup;
}

static void DetectChainExecute(Command super) {
  DetectChain self = (DetectChain)super;

  if (CheckEvent(self->detector) == DETECTOR_EVENT_DETECTED) {
    // イベントが検出されると、wakeup Commandをengineに追加する
    FuelEngine(self->engine, self->wakeup);
    self->detector_started = false;
    CleanupEventDetector(self->detector);
  } else {
    // イベントが検出されるまでは自分自身をengineに戻す
    FuelEngine(self->engine, (Command)self);
  }
}

static CommandInterfaceStruct interface = {
  .Execute = DetectChainExecute
};
```

なんとなく見えてきただろうか？

つまり、2秒経過検出でengineを止めるCommandと、ボタン押下検出をカウントするCommandをengineに追加してあげれば、2つのCommandが同時に動き続ける。
engineが停止した段階で、ボタン押下カウンタの値を取り出してあげれば完成だ。

ActiveObjectは、同時に動くオブジェクトは1つだけ、という並列処理のパターンだ。
個人的には、かなりお気に入りのパターンだが、本当にマルチスレッドが必要とされるような場合には使えない。
フットプリントが軽いので、貧弱な環境では十分使えるはずだ。

## 2秒のあいだにボタンが3回押されたかで、真・偽を返す実装

プログラム実行直後から、2秒の間に、「A」ボタンが何回押されたか、を出力するようにした。

```:実行結果
sudo led_controller/three_times_in_two_sec
Press A key 3 times in two seconds
```

以下、重要な部分のみ抜粋。

```c:three_times_in_two_sec.c
int main(void) {
  struct timeval kTime = {};
  const struct input_event kPressA = {kTime, EV_KEY, KEY_A, INPUT_KEY_PRESSED};

  ActiveObjectEngine engine = CreateActiveObjectEngine();

  // Create components.
  EventDetector press_a = CreateKeyInputDetector(KEYBOARD_DEVICE, &kPressA);
  EventDetector two_sec = CreateTimeOutDetector(2000, TIMER_ONE_SHOT);
  Command total = CreateCountTotal();
  Command halt = CreateHaltEngine(engine);

  TriggerActionPair one = CreateTriggerActionPair(press_a, total);
  TriggerActionPair two = CreateTriggerActionPair(two_sec, halt);

  Command cmd_one = CreateActionOnTriggerChain(one, engine, LOOP_CHAIN);
  Command cmd_two = CreateActionOnTriggerChain(two, engine, ONE_SHOT_CHAIN);
  FuelEngine(engine, cmd_one);
  FuelEngine(engine, cmd_two);

  EngineRuns(engine);

  // 3と比較すれば、真偽が返る
  printf("Press A key %d times in two seconds\n.", TotalIs(total));

  // 終了処理
  return 0;
}
```

```c:action_on_trigger.c
// イベント検出時、所定のCommandを実行するCommand
typedef struct TriggerActionPairStruct {
  EventDetector detector;
  Command command;
} TriggerActionPairStruct;

typedef struct ActionOnTriggerChainStruct {
  CommandStruct base;
  TriggerActionPair chain;
  ActiveObjectEngine engine;
  int32_t loop_flag;
  bool started;
} ActionOnTriggerChainStruct;
typedef struct ActionOnTriggerChainStruct *ActionOnTriggerChain;

static void ExecuteActionOnTrigger(Command super) {
  ActionOnTriggerChain self = (ActionOnTriggerChain)super;

  if (!self->started) {
    StartEventDetector(self->chain->detector);
    self->started = true;
  }

  // イベント検出時
  if (CheckEvent(self->chain->detector) == DETECTOR_EVENT_DETECTED) {
    FuelEngine(self->engine, self->chain->command);
    CleanupEventDetector(self->chain->detector);
    self->started = false;
    if (self->loop_flag == ONE_SHOT_CHAIN)
      return;  // Finish this chain by avoiding FuelEngine().
  }

  FuelEngine(self->engine, (Command)self);
}

static CommandInterfaceStruct interface = {
  .Execute = ExecuteActionOnTrigger
};

TriggerActionPair CreateTriggerActionPair(EventDetector detector, Command command) {
  TriggerActionPair pair = calloc(1, sizeof(TriggerActionPairStruct));
  pair->detector = detector;
  pair->command = command;
  return pair;
}

// Should give ActiveObjectEngine.
Command CreateActionOnTriggerChain(TriggerActionPair chain,
                                   ActiveObjectEngine engine,
                                   int32_t loop_flag) {
  ActionOnTriggerChain self = calloc(1, sizeof(ActionOnTriggerChainStruct));
  self->base.vtable = &interface;
  self->chain = chain;
  self->engine = engine;
  self->loop_flag = loop_flag;
  self->started = false;

  return (Command)self;
}
```

残りの細かい部分は、GitHubを見てほしい。
[ソースコード全体](https://github.com/tomoyuki-nakabayashi/TDDforEmbeddedSystem/tree/master/led_controller/src)
**three_times_in_two_sec.c**がmainを含むソースコード。

## コナミコマンドを検出する

先ほど紹介した、DetectChainを使って、コナミコマンドを検出する。
コマンドを検出すると、caps lockのLEDを点灯して終了する。途中で間違えるとプログラムは何もせず終了する。
検出するイベントが多いので、少し下準備が長くなっている。
マトリョーシカのようにDetectChain Commandを作っていけば、あとはActiveObjectEngineを動かすだけだ。

```c:konami_command.c
int main(void) {
  struct timeval kTime = {};
  const struct input_event kPressUp = {kTime, EV_KEY, KEY_UP, INPUT_KEY_PRESSED};
  const struct input_event kPressDown = {kTime, EV_KEY, KEY_DOWN, INPUT_KEY_PRESSED};
  const struct input_event kPressLeft = {kTime, EV_KEY, KEY_LEFT, INPUT_KEY_PRESSED};
  const struct input_event kPressRight = {kTime, EV_KEY, KEY_RIGHT, INPUT_KEY_PRESSED};
  const struct input_event kPressA = {kTime, EV_KEY, KEY_A, INPUT_KEY_PRESSED};
  const struct input_event kPressB = {kTime, EV_KEY, KEY_B, INPUT_KEY_PRESSED};

  LedDriver caps_led = CreateLedDriver();
  if (InitLedDriver(caps_led, LED_DEVICE) != LED_DRIVER_SUCCESS) {
    DEBUG_LOG("Fail to init led device\n");
    exit(1);
  }

  // Create components.
  EventDetector press_up = CreateKeyInputDetector(KEYBOARD_DEVICE, &kPressUp);
  EventDetector press_down = CreateKeyInputDetector(KEYBOARD_DEVICE, &kPressDown);
  EventDetector press_left = CreateKeyInputDetector(KEYBOARD_DEVICE, &kPressLeft);
  EventDetector press_right = CreateKeyInputDetector(KEYBOARD_DEVICE, &kPressRight);
  EventDetector press_a = CreateKeyInputDetector(KEYBOARD_DEVICE, &kPressA);
  EventDetector press_b = CreateKeyInputDetector(KEYBOARD_DEVICE, &kPressB);
  Command caps_on = LedOperatorFactory(caps_led, OP_LED_TURN_ON);

  ActiveObjectEngine engine = CreateActiveObjectEngine();
  Command acceptted = CreateDetectChain(press_a, engine, caps_on);
  Command uuddlrlrb = CreateDetectChain(press_b, engine, acceptted);
  Command uuddlrlr = CreateDetectChain(press_right, engine, uuddlrlrb);
  Command uuddlrl = CreateDetectChain(press_left, engine, uuddlrlr);
  Command uuddlr = CreateDetectChain(press_right, engine, uuddlrl);
  Command uuddl = CreateDetectChain(press_left, engine, uuddlr);
  Command uudd = CreateDetectChain(press_down, engine, uuddl);
  Command uud = CreateDetectChain(press_down, engine, uudd);
  Command uu = CreateDetectChain(press_up, engine, uud);
  Command start = CreateDetectChain(press_up, engine, uu);

  FuelEngine(engine, start);

  EngineRuns(engine);

  return 0;
}
```

2秒で3回ボタン押下検出にせよ、コナミコマンド検出にせよ、これまでに作ったキー入力検出、タイマ、LED操作のモジュールには一切変更を加えていない。
これが大きなポイントとなる。

## 最後に

@mt08 さん、おもしろい問題を（タイムリーに）提供して頂き、ありがとうございました。
だいぶレギュレーションを無視していますが、かっこいい実装になっていますでしょうか？

組込みにちかいものをTDDで開発してみる、は一旦ここまでとさせて頂きます。
モチベーションが回復すれば、ラズパイあたりに移植して動かしてみます。
最後の方、細かいことが説明しきれなくなって、色々端折ってしまいました…。

後は、コメントで質問やマサカリ頂けば嬉しいです。