[Elegoo：11] キーパッドでミュージックボックス

概要 (Overview)

• キーパッド[メンブレン(膜)スイッチモジュール]について学ぶ
• ユーザーに押されたキー別にメロディを鳴らすミュージックボックスを作る

使用する電子部品 (Component Required)

電子種別	電子部品	個数
マイコン	Elegoo UNO R3 マイコンボード	1
	USBケーブル	1
能動	パッシブブザー	1
機構	4×4マトリックス メンブレンキーパッド(＃27899)	1
	ジャンプワイヤ(黒)[オス-メス]	1
	ジャンプワイヤ(赤)[オス-メス]	1
	ジャンプワイヤ(白)[オス-オス]	2
	ジャンプワイヤ(青)[オス-オス]	2
	ジャンプワイヤ(緑)[オス-オス]	2
	ジャンプワイヤ(黄)[オス-オス]	2

電子部品について (Component Introduction)

マトリクスキーパッド

使用するキーパッドには16個のキー(0-9, A-D, *, #)がある。
リニアキーパッドではキー総数分とグランドピン１本の出力ピンが必要だが
マトリクス不等号化式キーパッドは、行列各4ピンの計8ピンと配線が少なくて済む。
まずは4列（ピン1〜4）を一度にローまたはハイにしてから、4行（ピン5〜8）の状態をポーリングして 列の状態に応じて押されたキーを認識する

《データシート》
最大定格	24VDC/30mA
インターフェース	4×4マトリックスへの8ピンアクセス
使用温度	0〜50℃

《端子とキー配列》
白／黒	4 ↓	3 ↓	2 ↓	1 ↓
8 →	1	2	3	A
7 →	4	5	6	B
6 →	7	8	9	C
5 →	*	0	#	D

電子回路 (Electronic Circuit)

回路図 (Schematic)

実体配線図 (Wiring Diagram)

実践 (To Practice)

配線写真 (Example Picture)

プログラム (Code)

KeyPadライブラリ

書式	引数	説明
Keypad::Keypad(char userKeymap,  byte rowPins, byte colPins,  byte rows, byte cols)	userKeymap：キー配列 rowPins：行ピンNo配列 colPins：列ピンNo配列 rows：行数 cols：列数	KeyPadオブジェクトを作成し、 ピンを割り当てる
Keypad::makeKeymap(char hexKeymap)	hexKeymap：キー配列	キーマップ作成
char Keypad::getKey()		押されたキーを取得

音階の周波数(Hz)
pitches.h

/*************************************************
 * pitches.h : 音階(NOTE_B0 - DS8)の周波数(Hz)を定義
 * https://www.arduino.cc/en/Tutorial/ToneMelody
 * Public Constants 
 *************************************************/

#define NOTE_B0    31
#define NOTE_C1    33
#define NOTE_CS1  35
　　     …

#define NOTE_CS8  4435
#define NOTE_D8    4699
#define NOTE_DS8  4978

メロディ リスト
melodyList.h

/*************************************************
 * 【melodyList.h】 メロディ リスト
 *    [0] 音階     [ NOTE_xx, 0:休符 ]
 *    [1] 音の長さ[ 4:四分音符, 8:八分音符 ]
 *-------------------------------------------------
 *      ①ドレミの歌 [ドレミファソラシド]
 *      ②きらきらぼし
 *      ③ゆかいな牧場
 *      ④にんげんっていいな
 *      ⑤おもちゃのチャチャチャ
 ************************************************/

// 音階の周波数(Hz)
#include "pitches.h"

#define NOTE      0       // 音階
#define DURATIONS 1       // 音の長さ

//-------------------------------------------------
// ドレミの歌
//-------------------------------------------------
// ド[C]
int aryMelodyC[][7] = {
  { NOTE_C4, NOTE_D4, NOTE_E4, NOTE_C4, NOTE_E4, NOTE_C4, NOTE_E4 },
  { 2, 4, 2, 4, 2, 2, 2 }
};
// レ[D]
int aryMelodyD[][7] = {
  { NOTE_D4, NOTE_E4, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_D4, NOTE_F4 },
  { 2, 4, 2, 4, 2, 2, 2 }
};
// ミ[E]
int aryMelodyE[][7] = {
  { NOTE_E4, NOTE_F4, NOTE_G4, NOTE_E4, NOTE_G4, NOTE_E4, NOTE_G4 },
  { 2, 4, 2, 4, 2, 2, 2 }
};
// ファ[F]
int aryMelodyF[][7] = {
  { NOTE_F4, NOTE_G4, NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4, NOTE_A4 },
  { 2, 4, 8, 8, 8, 8, 2 }
};
// ソ[G]
int aryMelodyG[][7] = {
  { NOTE_G4, NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4 },
  { 2, 4, 8, 8, 8, 8, 2 }
};
// ラ[A]
int aryMelodyA[][7] = {
  { NOTE_A4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4 },
  { 2, 4, 8, 8, 8, 8, 2 }
};
// シ[B]
int aryMelodyB[][7] = {
  { NOTE_B4, NOTE_E4, NOTE_FS4, NOTE_GS4, NOTE_A4, NOTE_B4, NOTE_C5 },
  { 2, 4, 8, 8, 8, 8, 2 }
};
// ド[C5]
int aryMelodyC5[][7] = {
  { NOTE_B4, NOTE_B4, NOTE_A4, NOTE_F4, NOTE_B4, NOTE_G4, NOTE_C5 },
  { 8, 8, 4, 4, 4, 4, 2 }
};
// C4 -> C5
int aryMelodyC4_C5[][8] = {
  { NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5 },
  { 4, 4, 4, 4, 4, 4, 4, 4 }
};
// C5 -> C4
int aryMelodyC5_C4[][8] = {
  { NOTE_C5, NOTE_B4, NOTE_A4, NOTE_G4, NOTE_F4, NOTE_E4, NOTE_D4, NOTE_C4 },
  { 4, 4, 4, 4, 4, 4, 4, 4 }
};

//-------------------------------------------------
// きらきらぼし
//-------------------------------------------------
int aryMelodyStar[][14] = {
  { NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_A4, NOTE_G4, 
    NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_C4},
  { 4, 4, 4, 4, 4, 4, 2,
    4, 4, 4, 4, 4, 4, 2 }
};

//-------------------------------------------------
// ゆかいな牧場
//-------------------------------------------------
int aryMelodyCow[][13] = {
  { NOTE_G4, NOTE_G4, NOTE_G4, NOTE_D4, NOTE_E4, NOTE_E4, NOTE_D4,
    0,       NOTE_B4, NOTE_B4, NOTE_A4, NOTE_A4, NOTE_G4 },
  { 8, 8, 8, 8, 8, 8, 2,
    8, 8, 8, 8, 8, 2 }
};

//-------------------------------------------------
// にんげんっていいな
//-------------------------------------------------
int aryMelodyHuman[][14] = {
  { NOTE_G4, NOTE_F4, NOTE_E4, NOTE_F4, NOTE_D4, NOTE_C4, 0,
    NOTE_E4, NOTE_E4, 0,       NOTE_G4, NOTE_F4, NOTE_D4, NOTE_E4 },
  { 4, 4,  4, 4, 4, 4, 8,
    2, 4, 16, 8, 4, 4, 4 }
};

//-------------------------------------------------
// おもちゃのチャチャチャ
//-------------------------------------------------
int aryMelodyCha[][24] = {
  { NOTE_C4, NOTE_C4, NOTE_C4, NOTE_E4, NOTE_A4, NOTE_A4, NOTE_A4,
    NOTE_D4, NOTE_D4, NOTE_D4, NOTE_F4, NOTE_G4, NOTE_G4, NOTE_G4,
    NOTE_G4, NOTE_G4, NOTE_GS4, NOTE_A4, NOTE_A4, NOTE_A4, NOTE_GS4,
    NOTE_G4, NOTE_B4, NOTE_C5 },
  { 8, 8, 8, 8, 8, 8, 2,
    8, 8, 8, 8, 8, 8, 2,
    8, 8, 8, 8, 8, 8, 8,
    8, 8, 8 }
};

スケッチ

/**************************************************
 * 【 Elegoo：11 】膜(メンブレイン)スイッチモジュール
 *    キーパッドでミュージックボックス
 *************************************************/

/*--------------------------------------------*/
/* Keypadライブラリ                            */
/*--------------------------------------------*/
#include <keypad .h>
// 行列数
const byte bytRows = 4;                  // 行数
const byte bytCols = 4;                  // 列数
// 行列ピンNo
byte aryRowPins[bytRows] = {9, 8, 7, 6}; // 行ピンNo
byte aryColPins[bytCols] = {5, 4, 3, 2}; // 列ピンNo
// キー配列
char hexKeymap[bytRows][bytCols] = {     
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
// Keypadオブジェクトを作成
Keypad objKeypad = Keypad( makeKeymap(hexKeymap),   // キーマップ作成
                           aryRowPins, aryColPins,  // 行列ピンNo
                           bytRows, bytCols         // 行列数
                          );

/*--------------------------------------------*/
/* ブザー                                     */
/*--------------------------------------------*/
// ピンの定義
#define BUZZER    12      // D12

/*--------------------------------------------*/
/* メロディ                                   */
/*--------------------------------------------*/
#include "pitches.h"      // 音階の周波数(Hz)
#include "melodyList.h"   // メロディリスト

/*****************************************/
/* 関数名：メロディ 出力                   */
/* 　引数：rAryNote      [音階   ]        */
/*      ：rAryDurations [音の長さ]        */
/*      ：rBytNoteNum   [音階総数]        */
/*****************************************/
void outputMelody( int *rAryNote, int *rAryDurations, byte rBytNoteNum){

  // --------------------------------------------------
  //  音階数の周波数を音の長さだけ出力する 
  // --------------------------------------------------
  for( int i = 0; i < rBytNoteNum; i++){
    tone( BUZZER, rAryNote[i],( 1000 / rAryDurations[i] ) );
    delay( 500 );   //演奏速度
  }

  // --------------------------------------------------
  // 周波数の出力を停止する
  // --------------------------------------------------
  noTone( BUZZER );
  delay( 500 );
}


/********/
/* loop */
/********/
void loop() {
  byte bytNoteNum;    // 音階総数

   // 押されたキーを取得する
  char chrKey = objKeypad.getKey();

  // --------------------------------------------------
  // 押されたキー別にメロディを出力する
  //    メロディ[0] 音階
  //    メロディ[1] 音の長さ
  // --------------------------------------------------
  if (chrKey){
    switch(chrKey){
      // --------------------------------------------------
      // 1:ド
      case '1':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyC[NOTE] ) / sizeof( aryMelodyC[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyC[NOTE], aryMelodyC[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // 2:レ
      case '2':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyD[NOTE] ) / sizeof( aryMelodyD[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyD[NOTE], aryMelodyD[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // 3:ミ
      case '3':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyE[NOTE] ) / sizeof( aryMelodyE[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyE[NOTE], aryMelodyE[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // 4:ファ
      case '4':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyF[NOTE] ) / sizeof( aryMelodyF[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyF[NOTE], aryMelodyF[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // 5:ソ
      case '5':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyG[NOTE] ) / sizeof( aryMelodyG[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyG[NOTE], aryMelodyG[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // 6:ラ
      case '6':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyA[NOTE] ) / sizeof( aryMelodyA[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyA[NOTE], aryMelodyA[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // 7:シ
      case '7':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyB[NOTE] ) / sizeof( aryMelodyB[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyB[NOTE], aryMelodyB[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // 8:ド
      case '8':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyC5[NOTE] ) / sizeof( aryMelodyC5[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyC5[NOTE], aryMelodyC5[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // 9:ド[C4 -> C5]
      case '9':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyC4_C5[NOTE] ) / sizeof( aryMelodyC4_C5[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyC4_C5[NOTE], aryMelodyC4_C5[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // 0:ド[C5 -> C4]
      case '0':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyC5_C4[NOTE] ) / sizeof( aryMelodyC5_C4[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyC5_C4[NOTE], aryMelodyC5_C4[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // A:きらきらぼし
      case 'A':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyStar[NOTE] ) / sizeof( aryMelodyStar[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyStar[NOTE], aryMelodyStar[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // B:ゆかいな牧場
      case 'B':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyCow[NOTE] ) / sizeof( aryMelodyCow[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyCow[NOTE], aryMelodyCow[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // C:にんげんっていいな
      case 'C':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyHuman[NOTE] ) / sizeof( aryMelodyHuman[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyHuman[NOTE], aryMelodyHuman[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // D:おもちゃのチャチャチャ
      case 'D':
        // 音階総数
        bytNoteNum = sizeof( aryMelodyCha[NOTE] ) / sizeof( aryMelodyCha[NOTE][0] );
        // メロディ 出力
        outputMelody( aryMelodyCha[NOTE], aryMelodyCha[DURATIONS], bytNoteNum ); 
      break;
      // --------------------------------------------------
      // その他：シリアルモニタに表示
      default:
        Serial.println(chrKey);
    }
  }
}


/*********/
/* setup */
/*********/
void setup(){
  // pinの設定
  pinMode( BUZZER, OUTPUT );  // BUZZER : 出力用

  // シリアルモニタ開始
  Serial.begin( 9600 );
}

結果(動画)・モニタリング

動画

ドレミの歌
ボタン１→２→３→４：ド→レ→ミ→ファ


 ボタンA：きらきらぼし
ボタンB：ゆかいな牧場
ボタンD:おもちゃのチャチャチャ