オリジナルワンダーライドブックをつくる 〜逢魔降臨暦ワンダーライドブック〜

//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);

// U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);

const unsigned char gImage_01kuga[2048] = { /* 0X30,0X01,0X00,0X80,0X00,0X80, */
0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,
0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,
0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,
...
0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,
};

////////// 基本定義 ////////////////////////////////////////////////////////////

// #include "M5Atom.h"
#include "M5StickC.h" 

#include "BLEDevice.h"
#include "BLEServer.h"
#include "BLEUtils.h"

#define LOOP_DELAY_MS 10

#define MP3_RX_PIN      32
#define MP3_TX_PIN      26
#define I2C_SDA_PIN     22 
#define I2C_SCL_PIN     19   
#define BOTTOM_SW_PIN   25
#define SIDE_SW_PIN     21
#define BACK_SW_PIN     33
#define HALL_SENSOR_PIN 23

#define ON  LOW
#define OFF HIGH

#define OPEN  LOW
#define CLOSE HIGH

uint8_t bottom_sw   = OFF;
uint8_t side_sw     = OFF;
uint8_t back_sw     = OFF;
uint8_t hall_sensor = CLOSE;

uint8_t prev_bottom_sw   = OFF;
uint8_t prev_side_sw     = OFF;
uint8_t prev_back_sw     = OFF;
uint8_t prev_hall_sensor = CLOSE;

#define BOTTOM_SW_LONG_PRESS_MS 300
unsigned long bottom_sw_long_press_start_time = 0;
boolean is_bottom_sw_pressing = false;

#define back_sw_LONG_PRESS_MS 1000
unsigned long back_sw_long_press_start_time = 0;
boolean is_back_sw_pressing = false;

#define SWORD_MODE_HOLY 0 // 聖剣ソードライバー
#define SWORD_MODE_EVIL 1 // 邪剣カリバードライバー
uint8_t sword_mode = SWORD_MODE_HOLY;

// 1秒以内にDRIVE_IN -> DRIVER_OPEN -> DRIVER_PUSH -> DRIVER_OPEN
// の状態遷移が起こったときに、通常とは異なる音声を再生させる
#define SPECIAL_SWORD_TIMER_MS 1000 
unsigned long special_sword_timer_start_time = 0;

#define STATE_INIT           0
#define STATE_TITLE          1
#define STATE_DRIVER_IN      2
#define STATE_DRIVER_OPEN    3
#define STATE_DRIVER_CLOSE   4
#define STATE_DRIVER_PUSH    5
#define STATE_STORY          6
#define STATE_READING        7
#define STATE_READING_NEXT   8

uint8_t state      = STATE_INIT;
uint8_t prev_state = STATE_INIT;

void print_state(){
  if(prev_state != state){
    switch(state){
    case STATE_INIT:         Serial.println(F("STATE_INIT"));         break;
    case STATE_TITLE:        Serial.println(F("STATE_TITLE"));        break;
    case STATE_DRIVER_IN:    Serial.println(F("STATE_DRIVER_IN"));    break;
    case STATE_DRIVER_OPEN:  Serial.println(F("STATE_DRIVER_OPEN"));  break;
    case STATE_DRIVER_CLOSE: Serial.println(F("STATE_DRIVER_CLOSE")); break;
    case STATE_DRIVER_PUSH:  Serial.println(F("STATE_DRIVER_PUSH"));  break;
    case STATE_STORY:        Serial.println(F("STATE_STORY"));        break;
    case STATE_READING:      Serial.println(F("STATE_READING"));      break;
    case STATE_READING_NEXT: Serial.println(F("STATE_READING_NEXT")); break;
    default: ;
    }
  }  
}

#define NUM_HEISEI_RIDERS 20
// プログラム上、アギト〜ビルドの定義は不要。ブレイドはプッシュ必殺技の関係で定義
#define PAGE_TOP     0
#define PAGE_KUGA    1
#define PAGE_BLADE   5
#define PAGE_ZIO    20

uint8_t page = PAGE_TOP;

boolean legend_read[NUM_HEISEI_RIDERS];

void reset_legend_read(){
  for(uint8_t i=0;i<NUM_HEISEI_RIDERS;i++){
    legend_read[i] = false;
  }
}

boolean check_read_all_legend(){
  boolean flag_read_all = true;
  for(uint8_t i=0;i<NUM_HEISEI_RIDERS;i++){
    if(legend_read[i] == false){
      flag_read_all = false;
      break; 
    }
  }
  return flag_read_all; 
}

////////// 描画処理 //////////////////////////////////////////////////////

// 使用モジュールはZio Qwiic 1.5インチ
// https://www.smart-prototyping.com/blog/Zio-Qwiic-1.5in-OLED-Display-Qwiic-Start-Guide
// https://github.com/olikraus/u8g2/wiki/u8g2reference

#include <U8g2lib.h>
#include <Wire.h>
#include "riders_crest.h" // クレストのバイナリデータは全てこちらに記述

//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 

#define cross_width  128
#define cross_height 128

void clear_display(){
  u8g2.clearDisplay();
}

void draw_riders_crest(uint8_t page){
  u8g2.firstPage();  
  do{
    u8g2.drawXBM(0,0,cross_width,cross_height,riders_crest[page-1]);
  }while(u8g2.nextPage());
}

void control_display(){
  if(prev_state != state){
    if((prev_state == STATE_TITLE        && state == STATE_INIT) ||
       (prev_state == STATE_DRIVER_IN    && state == STATE_DRIVER_CLOSE) || 
       (prev_state == STATE_DRIVER_OPEN  && state == STATE_DRIVER_CLOSE) || 
       (prev_state == STATE_READING_NEXT && state == STATE_READING) ){
        if(page == PAGE_TOP){
          clear_display();
        }else{
          draw_riders_crest(page);
        }
    }
  }
}

////////// 音声処理 /////////////////////////////////////////////////////////////

//#include <DFRobotDFPlayerMini.h>
// DFRobot提供のライブラリを使ってESP32のハードウェアシリアルで動作させようとすると
// なぜか動作不安定になるため、別の方が作成されたDFPlayer Mini Fastライブラリを使用する
// https://github.com/PowerBroker2/DFPlayerMini_Fast

#include <DFPlayerMini_Fast.h>

HardwareSerial hs_mp3_player(1);
DFPlayerMini_Fast mp3_player;

#define SOUND_VOLUME_DEFAULT 20 // 0〜30 20

#define SOUND_BUTTON                       1
#define SOUND_PUSH                         2
#define SOUND_INSERT                       3
#define SOUND_EJECT                        4
#define SOUND_CLOSE                        5
#define SOUND_PUSH_STORY_LEGEND            6
#define SOUND_ADD_LEGEND                   7
#define SOUND_READ_HOLY                    8
#define SOUND_LEARNED_HOLY                 9
#define SOUND_OHMA_ZIO_UNDERSTANDING_HOLY 10
#define SOUND_LEARNED_OHMA_ZIO_HOLY       11
#define SOUND_EVIL_READ_ANOTHER_RIDER     12
#define SOUND_READ_EVIL                   13
#define SOUND_LEARNED_EVIL                14
#define SOUND_OHMA_ZIO_UNDERSTANDING_EVIL 15
#define SOUND_LEARNED_OHMA_ZIO_EVIL       16
#define SOUND_SKILL_BLADE_A               17
#define SOUND_SKILL_BLADE_B               18
#define SOUND_SKILL_BLADE_C               19

#define SOUND_OFFSET_RIDER_TIME_CHANGE                 20
#define SOUND_OFFSET_PUSH_STORY                        40
#define SOUND_OFFSET_CHANGE_WAITING                    60
#define SOUND_OFFSET_RIDER_NAME_CHANGE                 80
#define SOUND_OFFSET_SKILL                            100
#define SOUND_OFFSET_RIDER_TIME_UNDERSTANDING         120
#define SOUND_OFFSET_RIDER_NAME_CRITICAL              140
#define SOUND_OFFSET_ANOTHER_RIDER_NAME_CHANGE        160
#define SOUND_OFFSET_ANOTHER_RIDER_TIME_UNDERSTANDING 180
#define SOUND_OFFSET_ANOTHER_RIDER_NAME_CRITICAL      200

#define WAIT_SOUND_STATE_INIT                              0
#define WAIT_SOUND_STATE_RIDER_TIME_CHANGE                 1
#define WAIT_SOUND_STATE_RIDER_NAME_CRITICAL               2
#define WAIT_SOUND_STATE_ANOTHER_RIDER_NAME_CRITICAL       3
#define WAIT_SOUND_STATE_CHANGE_WAITING                    4
#define WAIT_SOUND_STATE_ADD_LEGEND                        5
#define WAIT_SOUND_STATE_RIDER_NAME_CHANGE                 6
#define WAIT_SOUND_STATE_EVIL_READ                         7
#define WAIT_SOUND_STATE_ANOTHER_RIDER_NAME_CHANGE         8
#define WAIT_SOUND_STATE_RIDER_NAME_CHANGE_FROM_CLOSE      9
#define WAIT_SOUND_STATE_SKILL                            10
#define WAIT_SOUND_STATE_LEARNED_HOLY                     11
#define WAIT_SOUND_STATE_LEARNED_EVIL                     12
#define WAIT_SOUND_STATE_RIDER_TIME_UNDERSTANDING         13
#define WAIT_SOUND_STATE_ANOTHER_RIDER_TIME_UNDERSTANDING 14

#define WAIT_SOUND_RIDER_TIME_CHANGE_MS                1800
#define WAIT_SOUND_RIDER_NAME_CRITICAL_MS              2000
#define WAIT_SOUND_ANOTHER_RIDER_NAME_CRITICAL_MS      2000
#define WAIT_SOUND_CHANGE_WAITING_MS                   1200
#define WAIT_SOUND_ADD_LEGENGD_MS                     19000
#define WAIT_SOUND_RIDER_NAME_CHANGE_MS               15500
#define WAIT_SOUND_EVIL_READ_MS                        1200
#define WAIT_SOUND_ANOTHER_RIDER_NAME_CHANGE_MS        4500
#define WAIT_SOUND_RIDER_NAME_CHANGE_FROM_CLOSE_MS     1800
#define WAIT_SOUND_SKILL_MS                            1800
#define WAIT_SOUND_RIDER_TIME_UNDERSTANDING_MS         1500
#define WAIT_SOUND_ANOTHER_RIDER_TIME_UNDERSTANDING_MS 4300

uint8_t wait_sound_state = WAIT_SOUND_STATE_INIT;
unsigned long sound_wait_start_time = 0;

void play_sound(uint8_t sound_num){
  mp3_player.playFromMP3Folder(sound_num);
  Serial.print(F("Play sound: "));
  Serial.println(sound_num);
}

void pause_sound(){
  mp3_player.pause();
}

void control_sound(){
  unsigned long now_ms = millis();
  
  if(prev_state != state){ // 状態遷移直後の処理

    // 状態変化が起きれば待ちのステータスはリセットする
    wait_sound_state = WAIT_SOUND_STATE_INIT;
    
    switch(state){
    case STATE_INIT:
      switch(prev_state){
      case STATE_TITLE:
        play_sound(SOUND_BUTTON);
        wait_sound_state = WAIT_SOUND_STATE_RIDER_TIME_CHANGE;
        sound_wait_start_time = now_ms;
        break;
      case STATE_STORY:
        break;
      case STATE_DRIVER_IN:
      case STATE_DRIVER_OPEN:
      case STATE_DRIVER_CLOSE:  
        play_sound(SOUND_EJECT);
        break;
      case STATE_DRIVER_PUSH: 
        if(page == PAGE_TOP){
          play_sound(SOUND_PUSH_STORY_LEGEND);
        }else{
          play_sound(SOUND_OFFSET_PUSH_STORY + page);
        }
        break;
      case STATE_READING:
        if(sword_mode == SWORD_MODE_HOLY){
          if(check_read_all_legend()){
            play_sound(SOUND_LEARNED_OHMA_ZIO_HOLY);
          }else{
            if(page != PAGE_TOP){
              play_sound(SOUND_LEARNED_HOLY);
            }
            wait_sound_state = WAIT_SOUND_STATE_RIDER_NAME_CRITICAL;
            sound_wait_start_time = now_ms;     
          }
        }else{
          if(check_read_all_legend()){
            play_sound(SOUND_LEARNED_OHMA_ZIO_EVIL);
          }else{
            if(page != PAGE_TOP){
              play_sound(SOUND_LEARNED_EVIL);
            }
            wait_sound_state = WAIT_SOUND_STATE_ANOTHER_RIDER_NAME_CRITICAL;
            sound_wait_start_time = now_ms;     
          }  
        }
        break;
      default:
        ;
      }
      break;
    case STATE_TITLE:
      ;
      break;
    case STATE_DRIVER_IN:
      switch(prev_state){
      case STATE_TITLE:
        play_sound(SOUND_INSERT);
        wait_sound_state = WAIT_SOUND_STATE_CHANGE_WAITING;
        sound_wait_start_time = now_ms;
        break;
      default:
        ;
      }
      break;
    case STATE_DRIVER_OPEN:
      switch(prev_state){
      case STATE_DRIVER_IN:
        if(sword_mode == SWORD_MODE_HOLY){
          pause_sound();
          wait_sound_state = WAIT_SOUND_STATE_ADD_LEGEND;
        }else{
          pause_sound();
          wait_sound_state = WAIT_SOUND_STATE_EVIL_READ;
        }
        sound_wait_start_time = now_ms;
        break;
      case STATE_DRIVER_CLOSE:
        play_sound(SOUND_BUTTON);
        wait_sound_state = WAIT_SOUND_STATE_RIDER_NAME_CHANGE_FROM_CLOSE;
        sound_wait_start_time = now_ms;
        break;
      case STATE_DRIVER_PUSH:
        if(now_ms - special_sword_timer_start_time <= SPECIAL_SWORD_TIMER_MS){
          // 特殊聖剣用の特殊音声再生ルート
          sword_mode = SWORD_MODE_HOLY; // スイッチ位置の関係で邪剣モードになっているのを、聖剣モードに戻す
          play_sound(SOUND_BUTTON);
          wait_sound_state = WAIT_SOUND_STATE_RIDER_NAME_CHANGE_FROM_CLOSE;
        }else{
          play_sound(SOUND_BUTTON);
          wait_sound_state = WAIT_SOUND_STATE_SKILL;
        }
        sound_wait_start_time = now_ms;
        break;
      default:
        ;
      }
      break;
    case STATE_DRIVER_CLOSE:
      switch(prev_state){
      case STATE_DRIVER_IN:
      case STATE_DRIVER_OPEN:
        play_sound(SOUND_CLOSE);
        wait_sound_state = WAIT_SOUND_STATE_CHANGE_WAITING;
        sound_wait_start_time = now_ms;
        break;
      default:
        ;
      }
      break;
    case STATE_DRIVER_PUSH:
      pause_sound();
      break;      
    case STATE_STORY:
      if(prev_state == STATE_INIT){
        if(page == PAGE_TOP){
          play_sound(SOUND_PUSH_STORY_LEGEND);
        }else{
          play_sound(SOUND_OFFSET_PUSH_STORY + page);
        }
      }else{
        pause_sound();
      }
      break;
    case STATE_READING:
      switch(prev_state){
      case STATE_INIT:
        if(sword_mode == SWORD_MODE_HOLY){
          play_sound(SOUND_READ_HOLY);
          wait_sound_state = WAIT_SOUND_STATE_RIDER_TIME_UNDERSTANDING;
        }else{
          play_sound(SOUND_READ_EVIL);
          wait_sound_state = WAIT_SOUND_STATE_ANOTHER_RIDER_TIME_UNDERSTANDING;
        }
        sound_wait_start_time = now_ms; 
        break;
      case STATE_READING_NEXT:
        if(sword_mode == SWORD_MODE_HOLY){
          play_sound(SOUND_READ_HOLY);
          wait_sound_state = WAIT_SOUND_STATE_RIDER_TIME_UNDERSTANDING;
        }else{
          play_sound(SOUND_READ_EVIL);
          wait_sound_state = WAIT_SOUND_STATE_ANOTHER_RIDER_TIME_UNDERSTANDING;
        }
        sound_wait_start_time = now_ms;
        break;
      default:
        ;
      }
      break;
    case STATE_READING_NEXT:
      pause_sound();
      break;
    default:
      ;
    }
  }else{ // 状態遷移後の時間経過処理
    switch(wait_sound_state){
    case WAIT_SOUND_STATE_INIT:
      break;
    case WAIT_SOUND_STATE_RIDER_TIME_CHANGE:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_RIDER_TIME_CHANGE_MS){
        play_sound(SOUND_OFFSET_RIDER_TIME_CHANGE + page);
        wait_sound_state = WAIT_SOUND_STATE_INIT;
      }
      break;
    case WAIT_SOUND_STATE_RIDER_NAME_CRITICAL:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_RIDER_NAME_CRITICAL_MS){
        if(page != PAGE_TOP){
          play_sound(SOUND_OFFSET_RIDER_NAME_CRITICAL + page);
        }
        wait_sound_state = WAIT_SOUND_STATE_INIT;
      }
      break;
    case WAIT_SOUND_STATE_ANOTHER_RIDER_NAME_CRITICAL:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_ANOTHER_RIDER_NAME_CRITICAL_MS){
        if(page != PAGE_TOP){
          play_sound(SOUND_OFFSET_ANOTHER_RIDER_NAME_CRITICAL + page);
        }
        wait_sound_state = WAIT_SOUND_STATE_INIT;
      }
      break;
    case WAIT_SOUND_STATE_CHANGE_WAITING:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_CHANGE_WAITING_MS){
        if(page != PAGE_TOP){
          play_sound(SOUND_OFFSET_CHANGE_WAITING + page);
        }
        wait_sound_state = WAIT_SOUND_STATE_INIT;
      }
      break;
    case WAIT_SOUND_STATE_ADD_LEGEND:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_ADD_LEGENGD_MS){
        play_sound(SOUND_ADD_LEGEND);
        wait_sound_state = WAIT_SOUND_STATE_RIDER_NAME_CHANGE;
        sound_wait_start_time = now_ms;
      }
      break;
    case WAIT_SOUND_STATE_RIDER_NAME_CHANGE:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_RIDER_NAME_CHANGE_MS){
        if(page != PAGE_TOP){
          play_sound(SOUND_OFFSET_RIDER_NAME_CHANGE + page);
        }
        wait_sound_state = WAIT_SOUND_STATE_INIT;
      }
      break;
    case WAIT_SOUND_STATE_EVIL_READ:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_EVIL_READ_MS){
        play_sound(SOUND_EVIL_READ_ANOTHER_RIDER);
        wait_sound_state = WAIT_SOUND_STATE_ANOTHER_RIDER_NAME_CHANGE;
        sound_wait_start_time = now_ms;
      }
      break;
    case WAIT_SOUND_STATE_ANOTHER_RIDER_NAME_CHANGE:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_ANOTHER_RIDER_NAME_CHANGE_MS){
        if(page != PAGE_TOP){
          play_sound(SOUND_OFFSET_ANOTHER_RIDER_NAME_CHANGE + page);
        }
        wait_sound_state = WAIT_SOUND_STATE_INIT;
      }
      break;
    case WAIT_SOUND_STATE_RIDER_NAME_CHANGE_FROM_CLOSE:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_RIDER_NAME_CHANGE_FROM_CLOSE_MS){
        if(sword_mode == SWORD_MODE_HOLY){
          play_sound(SOUND_OFFSET_RIDER_NAME_CHANGE + page);
        }else{
          play_sound(SOUND_OFFSET_ANOTHER_RIDER_NAME_CHANGE + page);
        }
        wait_sound_state = WAIT_SOUND_STATE_INIT;
      }
      break;
    case WAIT_SOUND_STATE_SKILL:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_SKILL_MS){
        if(page == PAGE_TOP){
          ;
        }else if(page == PAGE_BLADE){
          play_sound(random(SOUND_SKILL_BLADE_A, SOUND_SKILL_BLADE_C+1));
        }else{
          play_sound(SOUND_OFFSET_SKILL + page);
        }
        wait_sound_state = WAIT_SOUND_STATE_INIT;
      }
      break;
    case WAIT_SOUND_STATE_RIDER_TIME_UNDERSTANDING:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_RIDER_TIME_UNDERSTANDING_MS){
        if(check_read_all_legend()){
          play_sound(SOUND_OHMA_ZIO_UNDERSTANDING_HOLY);
        }else{
          if(page != PAGE_TOP){
            play_sound(SOUND_OFFSET_RIDER_TIME_UNDERSTANDING + page);
          }
        }
        wait_sound_state = WAIT_SOUND_STATE_INIT;
      }
      break;
    case WAIT_SOUND_STATE_ANOTHER_RIDER_TIME_UNDERSTANDING:
      if(now_ms - sound_wait_start_time >= WAIT_SOUND_ANOTHER_RIDER_TIME_UNDERSTANDING_MS){
        if(check_read_all_legend()){
          if(page != PAGE_TOP){
            play_sound(SOUND_OHMA_ZIO_UNDERSTANDING_EVIL);
          }
        }else{
          play_sound(SOUND_OFFSET_ANOTHER_RIDER_TIME_UNDERSTANDING + page);
        }       
        wait_sound_state = WAIT_SOUND_STATE_INIT;
      }
      break;
    default :
      ;
    }
  }
}

////////// BLE処理 ////////////////////////////////////////////////////////////

// Service UUID
// Macのターミナルの"uuidgen"コマンドで生成
#define SERVICE_UUID "9D264561-039A-4EE9-B1B9-52116066B59C"

#define WAIT_BLE_ADVERTISE_STATE_NONE                         0
#define WAIT_BLE_ADVERTISE_STATE_READY_NAME_CHANGE            1
#define WAIT_BLE_ADVERTISE_STATE_READY_NAME_CHANGE_FROM_CLOSE 2
#define WAIT_BLE_ADVERTISE_STATE_READY_READING                3
#define WAIT_BLE_ADVERTISE_STATE_ADVERTISING                  4
uint8_t wait_ble_advertise_state = WAIT_BLE_ADVERTISE_STATE_NONE;

#define WAIT_BLE_ADVERTISE_FOR_END_MS 200
unsigned long const WAIT_BLE_ADVERTISE_FOR_NAME_CHANGE_MS = WAIT_SOUND_ADD_LEGENGD_MS + WAIT_SOUND_RIDER_NAME_CHANGE_MS;
unsigned long const WAIT_BLE_ADVERTISE_FOR_NAME_CHANGE_FROM_CLOSE_MS = WAIT_SOUND_RIDER_NAME_CHANGE_FROM_CLOSE_MS;
unsigned long const WAIT_BLE_ADVERTISE_FOR_READING_MS = WAIT_SOUND_RIDER_TIME_UNDERSTANDING_MS;
unsigned long ble_advertise_wait_start_time = 0;

BLEServer *pServer;
BLEAdvertising *pAdvertising;

void setAdvData(BLEAdvertising *pAdvertising, uint8_t value){
  BLEAdvertisementData oAdvertisementData = BLEAdvertisementData();
  
  // アドバタイズはペイロードとして全体で31バイトまでデータを詰め込める。
  // 「長さ(1 byte)＋AD Type(1 byte)+AD Data(X byte)」（＝AD structure）を繰り返す形で格納する。
  // 「長さ」は、AD TypeとAD Dataを足した長さ。
  // 以下は１行で一つのAD structureを設定している

  // Flags ... AD Type:0x01 デバイスの発見や機能についての設定
  //  ESP_BLE_ADV_FLAG_LIMIT_DISC         ... ビット0 ... LE Limited Discoverable Mode（デバイスの発見に時間制限がある場合）
  //  ESP_BLE_ADV_FLAG_GEN_DISC           ... ビット1 ... LE General Discoverable Mode（通常はこのモードを使用）
  //  ESP_BLE_ADV_FLAG_BREDR_NOT_SPT      ... ビット2 ... BR/EDR Not Supported（BLEのみをサポートする場合）
  //  ESP_BLE_ADV_FLAG_DMT_CONTROLLER_SPT ... ビット3 ... Simultaneous LE and BR/EDR to Same Device Capable (Controller)
  //  ESP_BLE_ADV_FLAG_DMT_HOST_SPT       ... ビット4 ... Simultaneous LE and BR/EDR to Same Device Capble (Host)
  oAdvertisementData.setFlags(ESP_BLE_ADV_FLAG_BREDR_NOT_SPT || ESP_BLE_ADV_FLAG_GEN_DISC); // 1+1+1=3 byte

  // Complete local name ... AD Type:0x09 デバイスの完全な名前
  // 完全な名前が長くなりそうなときは、AD Type:0x08のShortened local nameを使う（setShortName）  
  oAdvertisementData.setName("WRB"); // 1+1+3=5 byte

  // ServiceUUIDの設定（※長さとAD Typeの値は関数内で自動設定される）
  oAdvertisementData.setCompleteServices(BLEUUID(SERVICE_UUID)); // 1+1+16=18 byte

  // Manufacture specific dataの設定 ... AD Type:0xFF
  //  先頭2バイトは企業の識別子の設定が必要。テスト用には0xFFFFを設定して良い
  std::string strManufacturerData = "";
  strManufacturerData += (char)0xff; // Manufaucture ID
  strManufacturerData += (char)0xff; // Manufaucture ID
  strManufacturerData += (char)value;
  oAdvertisementData.setManufacturerData(strManufacturerData); // 1+1+3=5 byte

  // 計 3+5+18+5=31
  pAdvertising->setAdvertisementData(oAdvertisementData);
}

void ble_advertise_start(uint8_t value){
  Serial.println(F("BLE Advertise Start."));
  setAdvData(pAdvertising, value);
  pAdvertising->start();
}

void ble_advertise_stop(){
  pAdvertising->stop();
  Serial.println(F("BLE Advertise Stop."));
}

// アドバタイズをするのは、以下の条件のとき
// 1. STATE_TITLEからSTATE_DRIVER_INに変化したとき（表示クリア）
// 2. STATE_DRIVER_INからSTATE_DRIVER_OPENに変化して、「ライダー名＋変身音」が鳴るとき
// 3. STATE_OPENからSTATE_CLOSEに変化したとき（表示クリア）
// 4. STATE_DRIVER_CLOSEからDTATE_DRIVER_OPENに変化して、「ライダー名＋変身音」が鳴るとき
// 5. STATE_INITからSTATE_READINGに変化して、「〜の刻＋ふむふむ＋待機音」が鳴るとき
// 6. STATE_READING_NEXTからSTATE_READINGに変化して、「〜の刻＋ふむふむ＋待機音」が鳴るとき

void control_ble(){

  unsigned long now_ms = millis();
  
  if(prev_state != state){
    // 状態遷移直後の処理    
    switch(state){
    case STATE_DRIVER_IN:
      ble_advertise_start(PAGE_TOP);
      wait_ble_advertise_state = WAIT_BLE_ADVERTISE_STATE_ADVERTISING;
      ble_advertise_wait_start_time = now_ms;
      break;
    case STATE_DRIVER_OPEN:
      if(prev_state == STATE_DRIVER_IN){
        ble_advertise_wait_start_time = now_ms;
        wait_ble_advertise_state = WAIT_BLE_ADVERTISE_STATE_READY_NAME_CHANGE;
      }else if(prev_state == STATE_DRIVER_CLOSE){
        ble_advertise_wait_start_time = now_ms;
        wait_ble_advertise_state = WAIT_BLE_ADVERTISE_STATE_READY_NAME_CHANGE_FROM_CLOSE;
      }
      break;
    case STATE_DRIVER_CLOSE:
      ble_advertise_start(PAGE_TOP);
      wait_ble_advertise_state = WAIT_BLE_ADVERTISE_STATE_ADVERTISING;
      ble_advertise_wait_start_time = now_ms;
      break;
    case STATE_READING:
      ble_advertise_wait_start_time = now_ms;
      wait_ble_advertise_state = WAIT_BLE_ADVERTISE_STATE_READY_READING;
      break;
    default:
      ;
    }
  }else{
    switch(wait_ble_advertise_state){
    case WAIT_BLE_ADVERTISE_STATE_NONE:
      break;
    case WAIT_BLE_ADVERTISE_STATE_READY_NAME_CHANGE:
      if(now_ms - ble_advertise_wait_start_time >= WAIT_BLE_ADVERTISE_FOR_NAME_CHANGE_MS){
        ble_advertise_start(page);
        wait_ble_advertise_state = WAIT_BLE_ADVERTISE_STATE_ADVERTISING;
        ble_advertise_wait_start_time = now_ms;
      }
      break;
    case WAIT_BLE_ADVERTISE_STATE_READY_NAME_CHANGE_FROM_CLOSE:
      if(now_ms - ble_advertise_wait_start_time >= WAIT_BLE_ADVERTISE_FOR_NAME_CHANGE_FROM_CLOSE_MS){
        ble_advertise_start(page);
        wait_ble_advertise_state = WAIT_BLE_ADVERTISE_STATE_ADVERTISING;
        ble_advertise_wait_start_time = now_ms;
      }
      break;
    case WAIT_BLE_ADVERTISE_STATE_READY_READING:
      if(now_ms - ble_advertise_wait_start_time >= WAIT_BLE_ADVERTISE_FOR_READING_MS){
        ble_advertise_start(page);
        wait_ble_advertise_state = WAIT_BLE_ADVERTISE_STATE_ADVERTISING;
        ble_advertise_wait_start_time = now_ms;
      }
      break;
    case WAIT_BLE_ADVERTISE_STATE_ADVERTISING:
      if(now_ms - ble_advertise_wait_start_time >= WAIT_BLE_ADVERTISE_FOR_END_MS){
        ble_advertise_stop();
        wait_ble_advertise_state = WAIT_BLE_ADVERTISE_STATE_NONE; 
      }
      break;
    default:
      ;
    }
  }
}


////////// メイン処理 ////////////////////////////////////////////////////////////

void setup(){
  M5.begin();
  
  Serial.begin(115200);
  pinMode(BOTTOM_SW_PIN,   INPUT_PULLUP);
  pinMode(SIDE_SW_PIN,     INPUT_PULLUP);
  pinMode(BACK_SW_PIN,     INPUT_PULLUP);
  pinMode(HALL_SENSOR_PIN, INPUT);

  //---------- ディスプレイ ----------
  delay(100);
  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
  u8g2.begin();
  u8g2.clearBuffer();
  u8g2.setBitmapMode(false);
  u8g2.setDrawColor(1);

  //---------- MP3プレイヤー ----------
  hs_mp3_player.begin(9600, SERIAL_8N1, MP3_RX_PIN, MP3_TX_PIN);
  
  if(!mp3_player.begin(hs_mp3_player)) {
    Serial.println(F("Unable to begin music_player:"));
    Serial.println(F("1.Please recheck the connection!"));
    Serial.println(F("2.Please insert the SD card!"));
    while(true);
  }
  
  Serial.println(F("mp3_player online."));
  delay(100);
  mp3_player.volume(SOUND_VOLUME_DEFAULT); 

  // BLEアドバタイズ準備
  BLEDevice::init("WRB");
  pServer = BLEDevice::createServer(); 
  pAdvertising = pServer->getAdvertising();
}

void loop(){

  unsigned long now_ms = millis();

  //////////////////// 状態遷移管理 ////////////////////
  bottom_sw   = digitalRead(BOTTOM_SW_PIN);
  side_sw     = digitalRead(SIDE_SW_PIN);
  back_sw     = digitalRead(BACK_SW_PIN);
  hall_sensor = digitalRead(HALL_SENSOR_PIN);

  switch(state){
  case STATE_INIT:
    if(prev_bottom_sw == OFF && prev_side_sw == OFF){
      if(bottom_sw == ON && side_sw == OFF){
        state = STATE_TITLE;
        is_bottom_sw_pressing = true; // 下部ボタン長押し認識開始
        bottom_sw_long_press_start_time = now_ms;
      }else if(bottom_sw == OFF && side_sw == ON){
        state = STATE_STORY;
      }else if(bottom_sw == ON && side_sw == ON){
        state = STATE_DRIVER_PUSH;
      }else if(prev_back_sw == OFF && back_sw == ON){
        is_back_sw_pressing = true; // 追加ボタン長押し認識開始
        back_sw_long_press_start_time = now_ms;
      }
    }
    break;
  case STATE_TITLE:
    // STATE_DRIVER_INへの遷移は時間経過なので別処理
    if(prev_bottom_sw == ON && prev_side_sw == OFF){
      if(bottom_sw == OFF && side_sw == OFF){
        state = STATE_INIT;
        is_bottom_sw_pressing = false; // 下部ボタン長押し認識終了
      }else if(bottom_sw == ON && side_sw == ON){
        state = STATE_DRIVER_PUSH;
        is_bottom_sw_pressing = false; // 下部ボタン長押し認識終了
      }   
    }
    break;
  case STATE_DRIVER_IN:
    if(prev_bottom_sw == ON && prev_side_sw == OFF){
      if(bottom_sw == OFF && side_sw == OFF){
        state = STATE_INIT;
      }else if(prev_hall_sensor == CLOSE && hall_sensor == OPEN){
        state = STATE_DRIVER_OPEN;
        special_sword_timer_start_time = now_ms; // 特殊聖剣用のタイマー
      }else if(prev_hall_sensor == OPEN && hall_sensor == CLOSE){
        state = STATE_DRIVER_CLOSE;
      }
    }
    break;
  case STATE_DRIVER_OPEN:
    if(prev_bottom_sw == ON && prev_hall_sensor == OPEN){
      if(bottom_sw == OFF && hall_sensor == OPEN){
        state = STATE_INIT;
      }else if(bottom_sw == ON && side_sw == ON){
        state = STATE_DRIVER_PUSH;
      }else if(bottom_sw == ON && hall_sensor == CLOSE){
        state = STATE_DRIVER_CLOSE;
      }
    }
    break;
  case STATE_DRIVER_CLOSE:
    if(prev_bottom_sw == ON && prev_hall_sensor == CLOSE){
      if(bottom_sw == OFF && hall_sensor == CLOSE){
        state = STATE_INIT;
      }else if(bottom_sw == ON && hall_sensor == OPEN){
        state = STATE_DRIVER_OPEN;
      }
    }
    break;
  case STATE_DRIVER_PUSH:
    if(prev_bottom_sw == ON && prev_side_sw == ON){
      if(bottom_sw == OFF && side_sw == OFF){
        state = STATE_INIT;
      }else if(bottom_sw == ON && side_sw == OFF){
        state = STATE_DRIVER_OPEN;
      }else if(bottom_sw == OFF && side_sw == ON){
        state = STATE_STORY;
      }
    }
    break;
  case STATE_STORY:
    if(prev_bottom_sw == OFF && prev_side_sw == ON){
      if(bottom_sw == OFF && side_sw == OFF){
        state = STATE_INIT;
      }else if(bottom_sw == ON && side_sw == ON){
        state = STATE_DRIVER_PUSH;
      }
    }
    break;
  case STATE_READING:
    if(prev_bottom_sw == OFF && prev_back_sw == ON){
      if(bottom_sw == OFF && back_sw == OFF){
        state = STATE_INIT;
      }else if(bottom_sw == ON && back_sw == ON){
        state = STATE_READING_NEXT;
      }
    }
    break;
  case STATE_READING_NEXT:
    if(prev_bottom_sw == ON && prev_back_sw == ON){
      if(bottom_sw == ON && back_sw == OFF){
        state = STATE_INIT;
      }else if(bottom_sw == OFF && back_sw == ON){
        state = STATE_READING;
      }
    }
    break;
  default:
    ;
  }

  //---------- bottom_sw 長押し処理 ----------//
  if(is_bottom_sw_pressing && now_ms - bottom_sw_long_press_start_time >= BOTTOM_SW_LONG_PRESS_MS){
    state = STATE_DRIVER_IN;
    is_bottom_sw_pressing = false;    // 下部ボタン長押し認識終了

    // このタイミングで、聖剣か邪剣かを判定する
    if(back_sw == OFF){
      sword_mode = SWORD_MODE_HOLY;
    }else{
      sword_mode = SWORD_MODE_EVIL;
    }
  }

  //---------- back_sw 長押し処理 ----------//
  if(prev_back_sw == ON && back_sw == OFF){
    is_back_sw_pressing = false;
  }

  if(is_back_sw_pressing && now_ms - back_sw_long_press_start_time >= back_sw_LONG_PRESS_MS){
    if(state == STATE_INIT){
      state = STATE_READING;
    }
    is_back_sw_pressing = false;    // 追加ボタン長押し認識終了
  }
  
  //---------- ページ送り処理 ----------//
  if((prev_state == STATE_TITLE        && state == STATE_INIT) || 
     (prev_state == STATE_DRIVER_IN    && state == STATE_DRIVER_CLOSE) || 
     (prev_state == STATE_DRIVER_OPEN  && state == STATE_DRIVER_CLOSE) || 
     (prev_state == STATE_READING_NEXT && state == STATE_READING) ){
    page++;
    if(page > PAGE_ZIO){
      page = PAGE_KUGA;  
    }
    Serial.print(F("Page No."));
    Serial.println(page);
  }
  
  ////////// 必殺技用ページ読取管理１ /////////////
  if((prev_state == STATE_INIT || prev_state == STATE_READING_NEXT) && state == STATE_READING){
    if(page != PAGE_TOP){
      legend_read[page-1] = true;
    }
  }

  ////////// 音声再生処理 ////////////////////
  control_sound();

  ////////// 必殺技ページ読取管理2（リセット） /////////////
  if((prev_state == STATE_READING || prev_state == STATE_READING_NEXT) && state == STATE_INIT){
    reset_legend_read();
  }

  ////////// ディスプレイ処理 ////////////////////
  control_display();
  
  ////////// BLE処理 ///////////////////////
  control_ble();
  
  ////////// デバッグ処理 ////////////////////
  print_state();

  ////////// 処理状態の保持 //////////////////
  prev_bottom_sw   = bottom_sw;
  prev_side_sw     = side_sw;
  prev_back_sw     = back_sw;
  prev_hall_sensor = hall_sensor;
  prev_state       = state;

  delay(LOOP_DELAY_MS);
}

////////// 基本定義 ////////////////////////////////////////////////////////////

#include "M5Atom.h"

#define LOOP_DELAY_MS 5
#define I2C_SDA_PIN 22 
#define I2C_SCL_PIN 19  

uint8_t page = 0;

////////// 描画処理 //////////////////////////////////////////////////////
#include "riders_crest.h" // クレストのバイナリデータは全てこちらに記述

// ESP32と純正ライブラリは相性が悪いので、以下のライブラリを使う
// https://github.com/ThingPulse/esp8266-oled-ssd1306

#include <Wire.h>  
#include "SSD1306Wire.h"
#define WIDTH 128
#define HEIGHT 64

// デフォルトではアドレスは0X3D
SSD1306Wire ssd1306(0x3D, I2C_SDA_PIN, I2C_SCL_PIN, GEOMETRY_128_64);

////////// BLE処理 ////////////////////////////////////////////////////////////

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEAdvertisedDevice.h>

// Service UUID
// Macのターミナルの"uuidgen"コマンドで生成
#define SERVICE_UUID "9D264561-039A-4EE9-B1B9-52116066B59C"

#define SCAN_DURATION_S   600 // 一旦10分間でスキャンはやめさせる
#define SCAN_INTERVAL_MS  100
#define SCAN_WINDOWS_MS   100 // Interval以下の値にする必要あり。Intervalの間の内、何msスキャンするか

BLEScan* pBLEScan;

void ble_scan_start(){
  Serial.println(F("BLE Scan Start."));
  pBLEScan->start(SCAN_DURATION_S, false);
}

void ble_scan_stop(){
  pBLEScan->clearResults();
  pBLEScan->stop();
  Serial.println(F("BLE Scan Stop."));
}

class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
    void onResult(BLEAdvertisedDevice advertisedDevice) {
      //Serial.printf("Advertised Device: %s \n", advertisedDevice.toString().c_str());
      if(advertisedDevice.haveServiceUUID() && advertisedDevice.getServiceUUID().equals(BLEUUID(SERVICE_UUID))){
        Serial.println(F("WRB Found!"));
        // サービスUUIDを見て、WRBの発するアドバタイズパケットであることを確認
        if(advertisedDevice.haveManufacturerData()){
          // ManufacturerDataが入っていれば処理
          std::string data = advertisedDevice.getManufacturerData();
          int manufacture_id = data[1] << 8 | data[0];
          if(manufacture_id == 0xffff){
            // 受信ページの認識
            page = (uint8_t)data[2];
            // 描画が終わるまで一旦スキャンを止める
            ble_scan_stop();
          }
        }
      } 
    }
};

////////// メイン処理 ////////////////////////////////////////////////////////////

void setup(){  
  M5.begin();
  Serial.begin(115200);

  // ディスプレイセットアップ
  ssd1306.init();    //ディスプレイを初期化
  ssd1306.display();   //指定された情報を描画
  
  // BLEスキャン準備
  BLEDevice::init("");
  pBLEScan = BLEDevice::getScan();
  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
  pBLEScan->setActiveScan(false); // パッシブスキャン設定
  pBLEScan->setInterval(SCAN_INTERVAL_MS);
  pBLEScan->setWindow(SCAN_WINDOWS_MS);
}

void loop(){
  ble_scan_start(); // ここで、受信までループは止まる

  // 描画処理
  ssd1306.clear();
  if(page != 0){
    ssd1306.drawFastImage(0,0,WIDTH,HEIGHT,riders_crest[page-1]);
  }
  ssd1306.display();

  delay(LOOP_DELAY_MS);
}