単体版無半音キーボード

ほったらかしにされているのを検知するためには、 最後にキーが押されなくなってから現在までの経過時間を知る必要があります。 検知すべき時間は、５分とします。

この時間もリアルタイム割り込み(Real-Time Interrupt: RTI)を 使って検出します。 リアルタイム割り込みは、キーの検出でも使うため、周期は32ミリ秒です。 ここから5分間（300秒間）を検出するには、リアルタイム割り込みの 回数を約9000回数えれば良い計算になります。

マイコンは、クロックに従って、プログラムの処理を行います。 そのため、クロックが動いていれば、マイコンは電力を消費します。 低消費電力にするためには、ぜひともクロックを止める必要があります。

不要なときにマイコンのクロックを止めるための命令が、 WAITとSTOPです。

WAIT命令は、CPUのクロックを停止させますが、 周辺デバイスのクロックは停止させません。 このため、PWMは動作を続けることができます。 PWMで音を出す必要があるときには、この命令を使ってCPUを止めます。

STOP命令は、CPUと周辺デバイスのクロックを停止させます。 リアルタイム割り込みやキー入力を待つ時に音を出す必要が無いのであれば、 この命令を使ったほうが低消費電力になります。

まず、プロジェクトパネルの"Cpu"をクリックして、 "Bean Inspector"パネルに"Cpu"ビーンを呼び出します。 次に以下のように属性を変更します。

最終的に属性は以下のようになります。

WAITとSTOPは、メソッドから呼び出されます。 以下のメソッドを有効にします。

最終的にメソッドは以下のようになります。

PORTBには、ByteIOビーンを割り当てます。 "Bean Selector"から "CPU Internal Peripherals → Port I/O → ByteIO"を ダブルクリックで呼び出したら、 以下の項目を設定します。

最終的に属性は以下のようになります。

PTA1には、BitIOビーンを割り当てます。 "Bean Selector"から "CPU Internal Peripherals → Port I/O → BitIO"を ダブルクリックで呼び出したら、 以下の項目を設定します。

最終的に属性は以下のようになります。

まず、"Bean Selector"から "CPU Internal Peripherals → Timer → PPG"を ダブルクリックで呼び出します。

次に以下の項目について設定しますが、 一部、デフォルトの状態では表示されない項目があります。 これらの項目を表示させるために、"Bean Inspector"パネルの下のほうにある "EXPERT"ボタンをクリックしてから設定を始めます。

ここで最初のパルス幅として設定した１ミリ秒は、 最初の周期500Hz（２ミリ秒）のちょうど半分に相当する値です。

周期の部分は、 ボタンを クリックしてダイアログを出して詳細な設定を行います。

最終的に属性は以下のようになります。

以上の設定で、プログラムの実行中にPPGの周波数を 400Hzから1200Hzの範囲で変更することができるようになります。

次にアプリケーションに必要なメソッド有効にし、 不要なメソッドを無効にします。

以下の表を参考にメソッドを有効あるいは無効にしてください。

最終的にメソッドは以下のようになります。

PPGの周波数設定メソッドは結構複雑な計算をします。 そのため、スタックの領域を広げなくてはなりませんでした。

PPGに周波数を与えると、そこからPWM周期のクロック数を計算して PWMの周期を決定してくれます。 この時に１秒のクロック数8000000を周波数、 例えば、500で割る演算を行います。 すると、割られる数のビット数が多いため、 "Processor Expert"はこの計算を行うために、 64ビットの数値演算を行おうとします。 64ビットの数値演算は、純粋な8ビットマイコンであるHC08にとっては 重労働なので、スタック領域をたっぷり使ってしまい、 デフォルトで用意されたスタック領域では足りなくなってしまうというわけです。

スタック領域を広げるためには、 "Cpu"ビーンの"Build Options"タブの設定を変更します。

デフォルトでは、64バイトであったところを96バイトに拡張しました。

この問題は、マイコンにプログラムを書き込んでしばらくすると 暴走してしまうという現象になって現れます。 しかも再現性がかなり悪いのです。

まず、"Bean Selector"から "CPU Internal Peripherals → Timer → TimerInt"を ダブルクリックで呼び出します。

次に"Bean Inspector"パネルで以下の項目について設定します。

最終的に属性は以下のようになります。

まずは、PROLOGUE状態とEPILOGUE状態を 考えます。 これらの状態には、以下の共通点があります。

• ある楽譜を演奏する
• 楽譜の終わりまで達したら別の状態に遷移する

そこで、楽譜の演奏をする共通部分をくくりだして、 同時に実装します。

/*
    PROLOGUE state procedures
*/
const byte prologue_score[] = {
  12,  T_DO+O_3,
  12,  T_MI+O_3,
  12,  T_SO+O_3,
  48,  T_DO+O_4,
  12,  0,
  0
};

void prologue_init(void) {
  state_code = PROLOGUE_STATE;  // (A) Specify state.
  score_init(prologue_score);   // (B) Provide a score.
}

void prologue_proc(void) {
  if (play_by_score()) {        // (C) Play and check score.
    idle_init();                // (D) Transition to IDLE.
  }
}

/*
    EPILOGUE state procedures
*/
const byte epilogue_score[] = {
  12,  T_DO+O_4,
  12,  T_SO+O_3,
  12,  T_MI+O_3,
  48,  T_DO+O_3,
  12,  0,
  0
};

void epilogue_init(void) {
  state_code = EPILOGUE_STATE;  // (A) Specify state.
  score_init(epilogue_score);   // (B) Provide a score.
}

void epilogue_proc(void) {
  if (play_by_score()) {        // (C) Play and check score.
    stop_init();                // (D) Transition to STOP.
  }
}

上の二組の関数は、良く似ていますが、少し異なっています。

• 演奏する楽譜が違う。

  これらの状態で演奏する楽譜は、(B)の部分で "score_init(const byte [])"に渡すbyte型の配列で 与えられます。 PROLOGUE状態ではprologue_score[]を EPILOGUE状態ではepilogue_score[]を 使っています。

• 楽譜の演奏が終わった後の遷移先が違う。

  (C)の部分で楽譜の演奏が終わったら、 "play_by_score(void)"がTRUEを返してきます。 この時に(D)の部分で遷移先を指定するのですが、 PROLOGUE状態では"idle_init(void)"関数を呼び出して IDLE状態に遷移し、 EPILOGUE状態では"stop_init(void)"関数を呼び出して STOP状態に遷移します。

それぞれの関数に関する詳細は、以下に続きます。

楽譜の演奏を行うプログラムは、 演奏する楽譜を指定する関数"score_init(const byte * const)"と 一定時間ごとに指定された楽譜をなぞる 関数"play_by_score(void)"からなっています。

/*
    SCORE manager.
*/
const byte    *score;           // Score to be played.
byte          sono_index;       // Pointer for a score.
byte          sono_count;       // Sound length counter.

void score_init(const byte * const score_p) {
  score = score_p;              // (A) Store a score to be played.
  sono_index = 0;               // (B) Point top of the score.
  sono_count = 1;               // (C) Set sound length counter.
}

bool play_by_score(void) {  
  if (--sono_count <= 0) {      // (D) sound length exceeded ?
    sono_count = score[sono_index];   // (E) Get sound length.
    if (sono_count == 0) {      // (F) Zero-length means score ends.
      return TRUE;              // (G) Return to indicate score ends.
    }
    sono_index++;               // (H) Adjust to point sound key.
    play_by_key(score[sono_index++]); // (J) Play with a sound key.
  } 
  return FALSE;                 // (K) Return FALSE to indicate not completed
}

この部分では、三つの大域変数が使用されています。

const byte *score

"score_init(const byte * const)"関数で 与えられた楽譜を保存する変数です。

"score"という変数そのものは、プログラムの実行中に更新されますが、 "score"変数が指し示す楽譜そのものは変更されません。 そのため、"const byte *"という修飾子がついています。

byte sono_index

楽譜の中の現在の演奏箇所を示します。

楽譜は、二組の"byte"で一つの音を表現しており、 一つ目が音の長さを二つ目が音程をあらわしています。 "sono_index"は、通常は音の長さの部分を指しているので、 偶数になります。

byte sono_count

現在発している音の残り時間を示します。

この値が"0"になったら、次の音に移ります。

二つの関数は、以下のように動作しています。

"score_init(const byte * const)"関数

ここでは、受け取った楽譜をもとに 三つの大域変数の初期化を行います。

(A)では、与えられた楽譜を"score"に格納します。 また、(B)で楽譜上の演奏位置"sono_index"を楽譜の最初に、 (C)で現在出している音の残り時間"sono_count"を"1"としています。 残り時間を"1"とすることで、 次に"play_by_score(void)"関数を実行したときに 楽譜の最初から演奏が始まるという仕掛けです。

"play_by_score(void)"関数

ここでは、 一単位時間だけ楽譜を進めます。 一単位時間は、この関数が呼び出される時間のことで、 このプログラムの場合は、リアルタイム割り込みの周期に相当します。

(D)で現在出している音の残り時間が"0"になったかどうかを調べます。 残り時間がまだあるのであれば、 (K)から呼び出し元のプログラムに戻ります。 (E)では、楽譜から次の音の長さを取り出し、 続いて(F)で音の長さが"0"であるかどうかを調べます。 この楽譜では、長さが"0"の音で楽譜の最後を示すので、 (G)から呼び出し元のプログラムに戻ります。 音の長さが"0"ではない時には、(H)で楽譜を先に進め、 (J)で楽譜から取り出した音を "void play_by_key(const byte)"関数を使って出します。

このプログラムでは、呼び出し元に戻る方法が(G)と(K)の二種類あります。 これらには、(G)はTRUEを返し、 (K)はFALSEを返しているという違いがあります。 ここで返す値によって、 楽譜の演奏が終了したかを呼び出し元に教えることができるので、 "prologue_proc(void)"関数と"epilogue_proc(void)"関数での 条件分岐に使えるというわけです。

楽譜を演奏するプログラムでは、 音を出すために"void play_by_key(const byte)"関数を 使用しています。 また、押されたキーに対応した音を出力するのもこの関数の仕事です。

この関数は、音の高さを8ビットのコードとして受け取り、 PPGビーン周波数として渡す役割をします。

音の高さコードは、平均律に従って、 １増えるごとに半音上がる構成になっています。 また、コード45が440Hzになるように調整されています。

/*
    Play a sound with a KEY
*/
const word freq_by_tone[] = {
  4186, // DO
  4435, // DO#
  4698, // RE
  4978, // RE#
  5274, // MI
  5588, // FA
  5920, // FA#
  6272, // SO
  6645, // SO#
  7040, // RA
  7459, // RA#
  7902, // SI
  8372  // DO
};

byte          lastKey = 0;      // Last key code.

void play_by_key(const byte key) {
  byte octave;                  // Octave part of the key code.
  byte tone;                    // Tone part of the key code.
  word freq;                    // Frequency according to the key code.
  
  if (key == lastKey) return;   // (A) return if key not changed.
  octave = key / 12;            // (B) Calculate octave code.
  tone = (byte)(key % 12);      // (C) Calculate tone code.
  (void)PPG1_Disable();         // (D) Stop PPG
  if (octave > 0) {             // (E) Octave code grater than 0 ?
    freq = freq_by_tone[tone] >> (byte)(7 - octave);
                                // (F) Calculate frequency.
    (void)PPG1_SetFreqHz(freq); // (G) Specify PPG's frequency.
    (void)PPG1_Enable();        // (H) Start PPG
  }
  lastKey = key;                // (J) Update last key code.
}

このプログラムでは、lastKeyという大域変数を使って、 現在出している音を記憶しています。 (A)では、要求された音コードkeyが、 現在出している音のコードlastKeuと等しいかどうかが 最初に調べられ、同じ音コードが要求されていた場合には、 何もせずに関数の呼び出し元に戻ります。

(B)と(C)では、 音コードをoctaveとtoneの 二つの部分に分ける処理を行っています。 このプログラムでは、これら二つの値から周波数を計算して PPGモジュールに渡しています。

以下の処理で、PPGに設定する周波数を変更するため、 (D)では、あらかじめPPGの出力を停止しておきます。

octaveが0になる音コードは、 音を停止するコードとして使用しています。 これを判定するのが、(E)のif文です。 音の周波数を決めている(F)から(H)までの処理は、 octaveが0よりも大きい時に限り処理されるため、 octaveが0の場合には、(D)で出力が停止したままになります。

(F)では、周波数を計算しています。 freq_by_tone[]は、 toneの値から上４点の周波数を割り出す配列です。 この配列から返された上４点の周波数を(7 - octave)の 数だけ右シフトすると与えられた音コードに相当する周波数が得られるという 仕組みです。

計算された周波数は、(G)でPPGに渡され、 (H)でPPGの出力が始まります。

最後の(J)では、現在出力している音のコードを更新しています。

次は、IDLE状態を考えます。

/*
    IDLE state procedures
*/
word  idle_count;               // IDLE timer count.

void idle_init(void) {
  state_code = IDLE_STATE;      // (A) Specify state.
  play_by_key(0);               // (B) Stop sound.
  idle_count = 0;               // (C) Clear IDLE timer count.
}

void idle_proc(void) {
  if (key_detected()) {         // (D) A key pushed ?
    run_init();                 // (E) Transition to RUN.
  } else if (idle_count > IDLE_TIME) {
                                // (F) IDLE timer expired ?
    epilogue_init();            // (G) Transition to EPILOGUE.
  } else {
    idle_count++;               // (H) Increment IDLE timer.
  }
}

IDLE状態に遷移したら、 まず、"void idle_init(void)"関数で初期状態を設定します。 最初に(A)で状態変数を設定します。 次に(B)で"play_by_key(const byte)"関数を使って、 PPGが出している音を止めます。 そして、(C)でidle_countという変数をクリアします。 この変数は、IDLE状態がどれだけ長く続いているかを 示すタイマとして使用しています。

"void idle_proc(void)"関数では、 IDLE状態での仕事が記述されています。

(D)では、押しボタンが押されたかどうかを調べています。 押しボタンが押されていた場合には、 PPGから音を出すために、 (E)でRUN状態に遷移します。

(F)では、ほったらかし状態を判定します。 IDLE状態がIDLE_TIMEを超えて 長く続いた場合には、 「ほったらかし」にされたと判断します。 その場合には、(G)でEPILOGUE状態に遷移し、 最終的にSTOP状態に遷移します。 IDLE_TIMEは、以下のように宣言されています。

/*
    Time descriptions.
*/
const  word   IDLE_TIME      = 30*30;  // 30sec

IDLE_TIMEの単位は、 RTIの周期と等しく32msec、約1/30秒です。 そのため、「30*30」を計算して約30秒の設定にしています。

(H)では、タイマカウンタを進めてほったらかし時間を計ります。

"bool key_detected(void)"関数は、 いずれかのキーが押されたかどうかをbool型の 値で示します。

/*
    Key detection routine.
    Returns TRUE if any key pressed.
*/
bool key_detected(void) {
  if (Byte1_GetVal() != 0b11111111) return TRUE;
  if (!Bit1_GetVal()) return TRUE;
  return FALSE;
}

まず、"Byte1_GetVal()"関数でPORTBの8本の端子につながっている キーの状態を調べます。 キーが押されていなければ、この関数は"0b11111111"を返します。 そうでない時には、「PORTBのいずれかのキーが押された」と判断し、 関数の呼び出し元にTRUEを返します。

次に"Bit1_GetVal()"関数でPTA1端子につながっているキーの状態を調べます。 キーが押されていない場合、この関数は"TRUE"を返します。 そうでない場合には、「PTA1のキーが押された」と判断し、 関数の呼び出し元にTRUEを返します。

以上、二組のポートを調べてキーが押されていないと判断される場合には、 この関数は、"FALSE"を返します。

RUN状態を考えます。

/*
    RUN state procedures
*/
byte  pressed_key;              // Pressed key code.

void run_init(void) {
  state_code = RUN_STATE;       // (A) Specify state.
  pressed_key = get_pressed_key();
                                // (B) Get pressed key code.
  play_by_key(pressed_key);     // (C) Start sound.
}

void run_proc(void) {
  if (pressed_key != get_pressed_key()) {
                                // (D) Key code changed ?
    idle_init();                // (E) Transition to IDLE.
  }
}

RUN状態に遷移したら、"void run_init(void)"関数で 初期状態を設定します。 最初に(A)で状態変数を設定します。 次に(B)で押されているキーのコードを "byte get_pressed_key(void)"関数から取得し、 pressed_key変数に格納します。 最後に(C)で"play_by_key(const byte)"関数を使って、 pressed_keyのコードに相当する音を PPGから出し始めます。

"void run_proc(void)"関数では、 まず(D)でキーが押されている状態に変化が無いかを調べます。 pressed_key変数にはキーコードが格納されていますので、 "byte get_pressed_key(void)"関数が返すキーコードと比較して、 変化がないかどうかを判断します。 そして、変化があった場合には、IDLE状態に遷移し、 キーの状態によって動作を決めます。

"byte get_pressed_key(void)"関数は、 押されたキーに相当するキーコードを返します。

/*
    Pressed key search routine.
    Returns KEY code which is equal to TONE code.
    or 0 if no key pressed.
*/
byte get_pressed_key(void) {
  if (!Byte1_GetBit(7)) return T_DO+O_3;
  if (!Byte1_GetBit(6)) return T_RE+O_3;
  if (!Byte1_GetBit(5)) return T_MI+O_3;
  if (!Byte1_GetBit(4)) return T_FA+O_3;
  if (!Byte1_GetBit(3)) return T_SO+O_3;
  if (!Byte1_GetBit(2)) return T_RA+O_3;
  if (!Byte1_GetBit(1)) return T_SI+O_3;
  if (!Byte1_GetBit(0)) return T_DO+O_4;
  if (!Bit1_GetVal())   return T_RE+O_4;
  return 0;
}

このプログラムは、 無半音キーボードで作成した キー入力プログラムとそっくりですが、 返す値が異なっています。

無半音キーボードでは、 単純に1から9までのコードを割り当てていたのですが、 このプログラムでは、コードそのものが音階をあらわすように 作成されています。 ただ、コードそのままでは可読性に欠けるので、 以下のような定数宣言を行って可読性を上げています。

/*
    Key code table.
      Key codes are consisting of a SUM of
      Octave code and Tone code
*/
const byte    O_3  = 12*4;    // Octave = 3
const byte    O_4  = 12*5;    // Octave = 4
const byte    T_DO = 0;       // Tone = DO
const byte    T_RE = 2;       // Tone = RE
const byte    T_MI = 4;       // Tone = MI
const byte    T_FA = 5;       // Tone = FA
const byte    T_SO = 7;       // Tone = SO
const byte    T_RA = 9;       // Tone = RA
const byte    T_SI = 11;      // Tone = SI

最後にSTOP状態を考えます。

/*
    STOP state procedures
*/
void stop_init(void) {
  state_code = STOP_STATE;      // (A) Specify state.
}

void stop_proc(void) {
  if (key_detected()) {         // (B) Key pressed ?
    prologue_init();            // (C) Transition to PROLOGUE.
  }
}

STOP状態に遷移したら、 "void stop_init(void)"関数で初期状態を設定します。 ここでは、(A)で状態変数を設定しているのみです。

"void stop_proc(void)"関数では、 (B)でキーが押されているかどうかを調べます。 そして、キーが押されていた場合には、 (C)でPROLOGUE状態に遷移します。