[ スマートフォン表示モード ]で表示しています。デスクトップパソコンやタブレットでの閲覧をお勧めします。

[ デジタルエフェクターの制作 ]

デジタル・エフェクターのプログラム

  1. // coding : UTF-8
  2. /*
  3. 内部ADC及び外部DACを使ったエフェクター
  4. エフェクター
  5. 0:ディレイ
  6. 1:ショート・ディレイ
  7. 2:リバーブ
  8. 3:コーラス
  9. 4:ディメンションC 1
  10. 5:ディメンションC 2
  11. 6:フランジャー
  12. 7:ディメンションC + ディレイ
  13. 8:
  14. 9:リミッター
  15. A:オーバードライブ
  16. B:ディレイ付きオーバードライブ
  17. C:ディストーション
  18. D:ディレイ付きディストーション
  19. E:ノイズゲート
  20. F:いろいろ
  21. none:スルー
  22. */
  23.  
  24. //This program runs on Rasberry Pi Pico
  25. //
  26. //ARDUINO IDE BOARD
  27. //Raspberry Pi Pico/RP2040 by Earle F. Philhower, III
  28. //Version 3.6.1
  29. //
  30. //ADDITIONAL BOARD MANAGER URL is
  31. //https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json
  32. //
  33. //INFORMATION
  34. //https://github.com/earlephilhower/arduino-pico
  35. //
  36. //PROGRAM DEVELOPMENT HAS BEEN DONE USING
  37. //Arduino IDE 2.2.1
  38. //
  39.  
  40. /*
  41. When I2S system runs on core0, the output waveform has pulse noise.
  42. Therefore, the I2S system must run on core 1.
  43. */
  44.  
  45. /*
  46. 使用できるアナログピンは一本だけである。
  47. analogReadは当然に使えないしADCInputで二本目を使ってもトラブルが発生する。
  48. This program will not work properly if you use the second analog input pin.
  49. */
  50.  
  51. #include <Arduino.h>
  52. #include <I2S.h>
  53. #include <ADCInput.h>
  54.  
  55. //I2S OUTPUT
  56. #define PIN_I2S_OUTPUT_BCLK 20
  57. #define PIN_I2S_OUTPUT_LRCLK (PIN_I2S_OUTPUT_BCLK + 1)
  58. #define PIN_I2S_DOUT 22
  59.  
  60. #define NUMBER_OF_BUFFERS_INPUT 10   //32
  61. #define NUMBER_OF_BUFFERS_OUTPUT 10  //32  //This number must be 3 or greater.
  62. #define SIZE_OF_BUFFER_INPUT 8
  63. #define SIZE_OF_BUFFER_OUTPUT 8  //This number must be 8 or greater.
  64.  
  65. #define WARNING_VALUE 0x7000  //Amplitude alarm value for input signal
  66.  
  67. #define P_I 3.141592653
  68.  
  69. #define PIN_FOOT_SWITCH 0
  70. #define PIN_OVER_LOAD 1
  71. #define PIN_EFFECTOR_TYPE_1 2
  72. #define PIN_EFFECTOR_TYPE_2 3
  73. #define PIN_EFFECTOR_TYPE_4 4
  74. #define PIN_EFFECTOR_TYPE_8 5
  75. #define PIN_R_1_1 10
  76. #define PIN_R_1_2 11
  77. #define PIN_R_1_3 12
  78. #define PIN_R_1_4 13
  79. #define PIN_R_1_5 14
  80. #define PIN_R_2_1 15
  81. #define PIN_R_2_2 16
  82. #define PIN_R_2_3 17
  83. #define PIN_R_2_4 18
  84. #define PIN_R_2_5 19
  85.  
  86. ADCInput adc_input(A0);  //A0=GP26=31st pin
  87. I2S i2s_output(OUTPUT);
  88. //ADCInput adc_parameter(A1, A2);
  89.  
  90. uint32_t const SAMPLE_RATE = 50000;  //Setting the sample rate to 50kHz stabilizes this effector.
  91. //サンプリング周波数を50kHzにするとなぜか安定する。
  92. uint16_t const SAMPLE_RANGE = 1000;
  93. int16_t INPUT_VALUE;
  94. uint16_t EFFECTOR_TYPE = 0;
  95. boolean FLAG_SWITCH = true;
  96. boolean FLAG_SetUpHasBeenCompleted = false;
  97. float EFFECT_GAIN = 16.0;
  98.  
  99. //delay : variable-parameters
  100. uint16_t DELAY_FEEDBACK = 2;  //reciprocal number of feedback
  101. uint16_t DELAY_TIME = 20000;  //time
  102. //reverb
  103. uint16_t DELAY_TIME1 = 5000;                            //time
  104. uint16_t DELAY_TIME2 = 12000;                           //time
  105. uint16_t DELAY_TIME3 = 22000;                           //time
  106. uint16_t DELAY_TIME4 = 25555;                           //time
  107. uint16_t DELAY_TIME5 = 31553;                           //time
  108. int16_t CENTRAL_DELAY_VALUE = 15 * SAMPLE_RATE / 1000;  //15ms*SAMPLE_RATE/1000=750
  109. int16_t DELAY_WIDTH1 = 1 * (SAMPLE_RATE / 1000);        //1ms*50=50
  110. int16_t DELAY_WIDTH2 = 2 * (SAMPLE_RATE / 1000);        //2ms*50=100
  111. int16_t DELAY_WIDTH3 = 3 * (SAMPLE_RATE / 1000);        //3ms*50=150
  112. int16_t DELAY_WIDTH4 = 4 * (SAMPLE_RATE / 1000);        //4ms*50=200
  113. int16_t DELAY_WIDTH5 = 5 * (SAMPLE_RATE / 1000);        //5ms*50=250
  114. uint16_t FEEDBACK_VALUE = 29;
  115. uint16_t VIBRATION_RATE_PARAMETER1 = 10;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/5=10, frequency=5Hz
  116. uint16_t VIBRATION_RATE_PARAMETER2 = 10;
  117. uint16_t VIBRATION_RATE_PARAMETER3 = 10;
  118. uint16_t VIBRATION_RATE_PARAMETER4 = 10;
  119. uint16_t DELAY_WIDTH_NUMBER1 = 3;
  120. uint16_t DELAY_WIDTH_NUMBER2 = 1;
  121. uint16_t DELAY_WIDTH_NUMBER3 = 2;
  122. uint16_t DELAY_WIDTH_NUMBER4 = 3;
  123. //over drive : variable-parameters
  124. uint16_t OVER_DRIVE_GAIN = 16;
  125. uint16_t OVER_DRIVE_LEVEL = 16;
  126. //limitter : variable-parameters
  127. int16_t LIMIT_TH = 0x5000;  //limitter threshold
  128. int16_t LIMIT_RATE = 2;     //limitter threshold
  129. //etc
  130. uint16_t ETC = 0;
  131. //noise gate
  132. uint16_t NOISE_GATE_OPEN_LEVEL = 50000;
  133. int32_t DECAYED_SOUND = 0;
  134. uint16_t NOISE_GATE_DECAY_SPEED = 1;
  135. uint16_t NOISE_GATE_THRESHOLD = 500;
  136.  
  137. void TITLE(void) {
  138.   Serial.println("< Digital effector >");
  139.   Serial.println("Program : digital_effector01_000_01.ino");
  140.   Serial.println("Version : 01.000.01");
  141.   Serial.println("Copyright : Guy in Ogikubo");
  142.   Serial.print("Sample rate : ");
  143.   Serial.print(SAMPLE_RATE);
  144.   Serial.println("Hz");
  145.   Serial.println("DATE : 2023_10_16");
  146.   Serial.println("VERSION UP DATE : 2023_12_2");
  147.   Serial.println("This program runs on Raspberry Pi Pico.");
  148.   Serial.flush();
  149. }
  150.  
  151. void setup1() {
  152.   Serial.begin(115200);
  153.   uint16_t SERIAL_COUNT = 0;
  154.   while (!Serial && (SERIAL_COUNT < 2500)) {
  155.     delay(1);
  156.     SERIAL_COUNT++;
  157.   }
  158.   if (Serial) {
  159.     TITLE();
  160.   }
  161.   while (!FLAG_SetUpHasBeenCompleted) delay(1);
  162.   if (Serial) {
  163.     Serial.print("Effector type = ");
  164.     Serial.println(EFFECTOR_TYPE, HEX);
  165.     Serial.println(" ");
  166.     Serial.println("Enjoy your music!");
  167.     Serial.println("");
  168.     Serial.flush();
  169.   }
  170.   setup_output();
  171.   setup_input();
  172. }
  173.  
  174. void loop1() {
  175.   //delay or short delay
  176.   if (EFFECTOR_TYPE == 0 || EFFECTOR_TYPE == 1) {
  177.     int16_t DELAY_BUFFER[0x8000];
  178.     for (uint16_t i = 0; i < 0x8000; i++) DELAY_BUFFER[i] = 0;
  179.     int32_t OUTPUT_VALUE;
  180.     int32_t DELAY_BUFFER_VALUE;
  181.     uint16_t CNT_NOW = 0;  //This variable must be unsigned.
  182.     i2s_output.begin(SAMPLE_RATE);
  183.     adc_input.begin(SAMPLE_RATE);
  184.     while (true) {
  185.       INPUT_VALUE = adc_input.read();
  186.       INPUT_VALUE = (INPUT_VALUE << 4) + 0x8000;
  187.       if (abs(INPUT_VALUE) > WARNING_VALUE) digitalWrite(PIN_OVER_LOAD, HIGH);
  188.       if (EFFECT_GAIN >= 0.0) {
  189.         OUTPUT_VALUE = (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_TIME) & 0x7FFF];
  190.         OUTPUT_VALUE = OUTPUT_VALUE * (1 << (uint16_t)round(EFFECT_GAIN));
  191.       } else
  192.         OUTPUT_VALUE = 1;              //If OUTPUT_VALUE is set to completely zero, pulse noise will occur when switching.
  193.       i2s_output.write(OUTPUT_VALUE);  // L channel
  194.       i2s_output.write(OUTPUT_VALUE);  // R channel
  195.       OUTPUT_VALUE = OUTPUT_VALUE >> 16;
  196.       DELAY_BUFFER_VALUE = 0;
  197.       for (uint16_t i = 0; i < DELAY_FEEDBACK; i++) DELAY_BUFFER_VALUE += OUTPUT_VALUE;
  198.       DELAY_BUFFER_VALUE = DELAY_BUFFER_VALUE / 8 + INPUT_VALUE / 2;
  199.       DELAY_BUFFER[CNT_NOW] = (int16_t)DELAY_BUFFER_VALUE;
  200.       CNT_NOW++;
  201.       CNT_NOW = CNT_NOW & 0x7FFF;
  202.       if (!FLAG_SWITCH) {
  203.         EFFECT_GAIN = EFFECT_GAIN - 0.0005;
  204.         if (EFFECT_GAIN < 0.0) EFFECT_GAIN = -0.0005;
  205.       } else {
  206.         EFFECT_GAIN = EFFECT_GAIN + 0.0005;
  207.         if (EFFECT_GAIN > 16)
  208.           EFFECT_GAIN = 16.0;
  209.       }
  210.       digitalWrite(PIN_OVER_LOAD, LOW);
  211.     }
  212.   }
  213.   //delay or short delay ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  214.  
  215.   //reverb
  216.   if (EFFECTOR_TYPE == 2) {
  217.     int16_t DELAY_BUFFER[0x8000];
  218.     for (uint16_t i = 0; i < 0x8000; i++) DELAY_BUFFER[i] = 0;
  219.     int32_t OUTPUT_VALUE;
  220.     int32_t DELAY_BUFFER_VALUE;
  221.     uint16_t CNT_NOW = 0;  //This variable must be unsigned.
  222.     i2s_output.begin(SAMPLE_RATE);
  223.     adc_input.begin(SAMPLE_RATE);
  224.     while (true) {
  225.       INPUT_VALUE = adc_input.read();
  226.       INPUT_VALUE = (INPUT_VALUE << 4) + 0x8000;
  227.       if (abs(INPUT_VALUE) > WARNING_VALUE) digitalWrite(PIN_OVER_LOAD, HIGH);
  228.       if (EFFECT_GAIN >= 0.0) {
  229.         OUTPUT_VALUE = (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_TIME1) & 0x7FFF] * (1 << 15);
  230.         OUTPUT_VALUE -= (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_TIME2) & 0x7FFF] * (1 << 14);
  231.         OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_TIME3) & 0x7FFF] * (1 << 13);
  232.         OUTPUT_VALUE -= (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_TIME4) & 0x7FFF] * (1 << 12);
  233.         OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_TIME5) & 0x7FFF] * (1 << 11);
  234.         OUTPUT_VALUE = OUTPUT_VALUE * (1 >> (uint16_t)round(16.0 - EFFECT_GAIN));
  235.       } else
  236.         OUTPUT_VALUE = 1;              //If OUTPUT_VALUE is set to completely zero, pulse noise will occur when switching.
  237.       i2s_output.write(OUTPUT_VALUE);  // L channel
  238.       i2s_output.write(OUTPUT_VALUE);  // R channel
  239.  
  240.       OUTPUT_VALUE = OUTPUT_VALUE >> 16;
  241.       DELAY_BUFFER_VALUE = 0;
  242.       for (uint16_t i = 0; i < DELAY_FEEDBACK; i++) DELAY_BUFFER_VALUE += OUTPUT_VALUE;
  243.       DELAY_BUFFER_VALUE = DELAY_BUFFER_VALUE / 8 + INPUT_VALUE / 2;
  244.       DELAY_BUFFER[CNT_NOW] = (int16_t)DELAY_BUFFER_VALUE;
  245.       CNT_NOW++;
  246.       CNT_NOW = CNT_NOW & 0x7FFF;
  247.       if (!FLAG_SWITCH) {
  248.         EFFECT_GAIN = EFFECT_GAIN - 0.0005;
  249.         if (EFFECT_GAIN < 0.0) EFFECT_GAIN = -0.0005;
  250.       } else {
  251.         EFFECT_GAIN = EFFECT_GAIN + 0.0005;
  252.         if (EFFECT_GAIN > 16)
  253.           EFFECT_GAIN = 16.0;
  254.       }
  255.       digitalWrite(PIN_OVER_LOAD, LOW);
  256.     }
  257.   }
  258.   //reverb ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  259.  
  260.  
  261.   //space effect
  262.   if (EFFECTOR_TYPE == 3 || EFFECTOR_TYPE == 4 || EFFECTOR_TYPE == 5 || EFFECTOR_TYPE == 6) {
  263.     int16_t DELAY_SWING1[SAMPLE_RANGE];
  264.     for (uint16_t i = 0; i < SAMPLE_RANGE; i++) DELAY_SWING1[i] = DELAY_WIDTH1 * sin(2 * P_I * i / SAMPLE_RANGE);
  265.     int16_t DELAY_SWING2[SAMPLE_RANGE];
  266.     for (uint16_t i = 0; i < SAMPLE_RANGE; i++) DELAY_SWING2[i] = DELAY_WIDTH2 * sin(2 * P_I * i / SAMPLE_RANGE);
  267.     int16_t DELAY_SWING3[SAMPLE_RANGE];
  268.     for (uint16_t i = 0; i < SAMPLE_RANGE; i++) DELAY_SWING3[i] = DELAY_WIDTH3 * sin(2 * P_I * i / SAMPLE_RANGE);
  269.     int16_t DELAY_SWING4[SAMPLE_RANGE];
  270.     for (uint16_t i = 0; i < SAMPLE_RANGE; i++) DELAY_SWING4[i] = DELAY_WIDTH4 * sin(2 * P_I * i / SAMPLE_RANGE);
  271.     int16_t DELAY_SWING5[SAMPLE_RANGE];
  272.     for (uint16_t i = 0; i < SAMPLE_RANGE; i++) DELAY_SWING5[i] = DELAY_WIDTH5 * sin(2 * P_I * i / SAMPLE_RANGE);
  273.  
  274.     int16_t DELAY_VALUE1;
  275.     int16_t DELAY_VALUE2;  //dimention C
  276.     int16_t DELAY_VALUE3;  //dimention C
  277.     int16_t DELAY_VALUE4;  //dimention C
  278.     int32_t DELAY_BUFFER_VALUE;
  279.     int16_t DELAY_BUFFER[0x1000];
  280.     for (uint16_t i = 0; i < 0x1000; i++) DELAY_BUFFER[i] = 0;
  281.     uint16_t CNT_NOW = 0;  //This variable must be unsigned.
  282.     int32_t OUTPUT_VALUE;
  283.     uint16_t i_1 = 0;
  284.     uint16_t j_1 = 0;
  285.     uint16_t i_2 = 0;
  286.     uint16_t j_2 = 0;
  287.     uint16_t i_3 = 0;
  288.     uint16_t j_3 = 0;
  289.     uint16_t i_4 = 0;
  290.     uint16_t j_4 = 0;
  291.     i2s_output.begin(SAMPLE_RATE);
  292.     adc_input.begin(SAMPLE_RATE);
  293.     while (true) {
  294.       INPUT_VALUE = adc_input.read();  //INPUT_VALUE : int16_t
  295.       INPUT_VALUE = (INPUT_VALUE << 4) + 0x8000;
  296.       if (abs(INPUT_VALUE) > WARNING_VALUE) digitalWrite(PIN_OVER_LOAD, HIGH);
  297.       if (EFFECT_GAIN >= 0.0) {
  298.         OUTPUT_VALUE = (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_VALUE1) & 0xFFF];  //OUTPUT_VALUE : int32_t
  299.         if (EFFECTOR_TYPE == 4) {                                                //dimention C
  300.           OUTPUT_VALUE = OUTPUT_VALUE / 2;
  301.           OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_VALUE2) & 0xFFF] / 2;
  302.         }
  303.         if (EFFECTOR_TYPE == 5) {  //dimention C+
  304.           OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_VALUE2) & 0xFFF];
  305.           OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_VALUE3) & 0xFFF];
  306.           OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_VALUE4) & 0xFFF];
  307.           OUTPUT_VALUE = OUTPUT_VALUE / 4;
  308.         }
  309.         OUTPUT_VALUE = OUTPUT_VALUE * (1 << (uint16_t)round(EFFECT_GAIN));
  310.       } else
  311.         OUTPUT_VALUE = 1;              //If OUTPUT_VALUE is set to completely zero, pulse noise will occur when switching.
  312.       i2s_output.write(OUTPUT_VALUE);  // L channel
  313.       i2s_output.write(OUTPUT_VALUE);  // R channel
  314.       OUTPUT_VALUE = OUTPUT_VALUE >> 16;
  315.       DELAY_BUFFER_VALUE = 0;
  316.       if (EFFECTOR_TYPE == 6) {  //flanger
  317.         for (uint16_t i = 0; i < FEEDBACK_VALUE; i++) DELAY_BUFFER_VALUE += OUTPUT_VALUE;
  318.         DELAY_BUFFER_VALUE = DELAY_BUFFER_VALUE / 32;
  319.         DELAY_BUFFER_VALUE -= INPUT_VALUE / 8;  //4=>8
  320.       } else DELAY_BUFFER_VALUE += INPUT_VALUE;       //chorus or dimention C
  321.  
  322.       DELAY_BUFFER[CNT_NOW] = (int16_t)DELAY_BUFFER_VALUE;
  323.       CNT_NOW++;
  324.       CNT_NOW = CNT_NOW & 0xFFF;
  325.       if (DELAY_WIDTH_NUMBER1 == 1) DELAY_VALUE1 = CENTRAL_DELAY_VALUE + DELAY_SWING1[i_1];
  326.       if (DELAY_WIDTH_NUMBER1 == 2) DELAY_VALUE1 = CENTRAL_DELAY_VALUE + DELAY_SWING2[i_1];
  327.       if (DELAY_WIDTH_NUMBER1 == 3) DELAY_VALUE1 = CENTRAL_DELAY_VALUE + DELAY_SWING3[i_1];
  328.       if (DELAY_WIDTH_NUMBER1 == 4) DELAY_VALUE1 = CENTRAL_DELAY_VALUE + DELAY_SWING4[i_1];
  329.       if (DELAY_WIDTH_NUMBER1 == 5) DELAY_VALUE1 = CENTRAL_DELAY_VALUE + DELAY_SWING5[i_1];
  330.  
  331.       if (EFFECTOR_TYPE == 4)  //dimention C
  332.       {
  333.         if (DELAY_WIDTH_NUMBER1 == 1) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING1[i_1];
  334.         if (DELAY_WIDTH_NUMBER1 == 2) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING2[i_1];
  335.         if (DELAY_WIDTH_NUMBER1 == 3) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING3[i_1];
  336.         if (DELAY_WIDTH_NUMBER1 == 4) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING4[i_1];
  337.         if (DELAY_WIDTH_NUMBER1 == 5) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING5[i_1];
  338.       }
  339.  
  340.       if (EFFECTOR_TYPE == 5)  //dimention C+
  341.       {
  342.         if (DELAY_WIDTH_NUMBER2 == 1) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING1[i_2];
  343.         if (DELAY_WIDTH_NUMBER2 == 2) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING2[i_2];
  344.         if (DELAY_WIDTH_NUMBER2 == 3) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING3[i_2];
  345.         if (DELAY_WIDTH_NUMBER2 == 4) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING4[i_2];
  346.         if (DELAY_WIDTH_NUMBER2 == 5) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING5[i_2];
  347.  
  348.         if (DELAY_WIDTH_NUMBER3 == 1) DELAY_VALUE3 = CENTRAL_DELAY_VALUE + DELAY_SWING1[i_3];
  349.         if (DELAY_WIDTH_NUMBER3 == 2) DELAY_VALUE3 = CENTRAL_DELAY_VALUE + DELAY_SWING2[i_3];
  350.         if (DELAY_WIDTH_NUMBER3 == 3) DELAY_VALUE3 = CENTRAL_DELAY_VALUE + DELAY_SWING3[i_3];
  351.         if (DELAY_WIDTH_NUMBER3 == 4) DELAY_VALUE3 = CENTRAL_DELAY_VALUE + DELAY_SWING4[i_3];
  352.         if (DELAY_WIDTH_NUMBER3 == 5) DELAY_VALUE3 = CENTRAL_DELAY_VALUE + DELAY_SWING5[i_3];
  353.  
  354.         if (DELAY_WIDTH_NUMBER4 == 1) DELAY_VALUE4 = CENTRAL_DELAY_VALUE - DELAY_SWING1[i_4];
  355.         if (DELAY_WIDTH_NUMBER4 == 2) DELAY_VALUE4 = CENTRAL_DELAY_VALUE - DELAY_SWING2[i_4];
  356.         if (DELAY_WIDTH_NUMBER4 == 3) DELAY_VALUE4 = CENTRAL_DELAY_VALUE - DELAY_SWING3[i_4];
  357.         if (DELAY_WIDTH_NUMBER4 == 4) DELAY_VALUE4 = CENTRAL_DELAY_VALUE - DELAY_SWING4[i_4];
  358.         if (DELAY_WIDTH_NUMBER4 == 5) DELAY_VALUE4 = CENTRAL_DELAY_VALUE - DELAY_SWING5[i_4];
  359.       }
  360.       //
  361.       j_1++;
  362.       if (j_1 >= VIBRATION_RATE_PARAMETER1) {
  363.         j_1 = 0;
  364.         i_1++;
  365.         if (i_1 >= SAMPLE_RANGE) i_1 = 0;
  366.       }
  367.  
  368.       if (EFFECTOR_TYPE == 5) {
  369.         j_2++;
  370.         if (j_2 >= VIBRATION_RATE_PARAMETER2) {
  371.           j_2 = 0;
  372.           i_2++;
  373.           if (i_2 >= SAMPLE_RANGE) i_2 = 0;
  374.         }
  375.  
  376.         j_3++;
  377.         if (j_3 >= VIBRATION_RATE_PARAMETER3) {
  378.           j_3 = 0;
  379.           i_3++;
  380.           if (i_3 >= SAMPLE_RANGE) i_3 = 0;
  381.         }
  382.  
  383.         j_4++;
  384.         if (j_4 >= VIBRATION_RATE_PARAMETER4) {
  385.           j_4 = 0;
  386.           i_4++;
  387.           if (i_4 >= SAMPLE_RANGE) i_4 = 0;
  388.         }
  389.       }
  390.  
  391.       if (!FLAG_SWITCH) {
  392.         EFFECT_GAIN = EFFECT_GAIN - 0.0005;
  393.         if (EFFECT_GAIN < 0.0) EFFECT_GAIN = -0.0005;
  394.       } else {
  395.         EFFECT_GAIN = EFFECT_GAIN + 0.0005;
  396.         if (EFFECT_GAIN > 16)
  397.           EFFECT_GAIN = 16.0;
  398.       }
  399.       digitalWrite(PIN_OVER_LOAD, LOW);
  400.     }
  401.   }
  402.   //space effect ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  403.  
  404.  
  405.   //dimention C 2 + delay
  406.   if (EFFECTOR_TYPE == 7) {
  407.     int16_t DELAY_SWING1[SAMPLE_RANGE];
  408.     for (uint16_t i = 0; i < SAMPLE_RANGE; i++) DELAY_SWING1[i] = DELAY_WIDTH1 * sin(2 * P_I * i / SAMPLE_RANGE);
  409.     int16_t DELAY_SWING2[SAMPLE_RANGE];
  410.     for (uint16_t i = 0; i < SAMPLE_RANGE; i++) DELAY_SWING2[i] = DELAY_WIDTH2 * sin(2 * P_I * i / SAMPLE_RANGE);
  411.     int16_t DELAY_SWING3[SAMPLE_RANGE];
  412.     for (uint16_t i = 0; i < SAMPLE_RANGE; i++) DELAY_SWING3[i] = DELAY_WIDTH3 * sin(2 * P_I * i / SAMPLE_RANGE);
  413.     int16_t DELAY_SWING4[SAMPLE_RANGE];
  414.     for (uint16_t i = 0; i < SAMPLE_RANGE; i++) DELAY_SWING4[i] = DELAY_WIDTH4 * sin(2 * P_I * i / SAMPLE_RANGE);
  415.     int16_t DELAY_SWING5[SAMPLE_RANGE];
  416.     for (uint16_t i = 0; i < SAMPLE_RANGE; i++) DELAY_SWING5[i] = DELAY_WIDTH5 * sin(2 * P_I * i / SAMPLE_RANGE);
  417.  
  418.     int16_t DELAY_VALUE1, DELAY_VALUE2, DELAY_VALUE3, DELAY_VALUE4;
  419.     int16_t DELAY_BUFFER[0x8000];
  420.     for (uint16_t i = 0; i < 0x8000; i++) DELAY_BUFFER[i] = 0;
  421.     uint16_t CNT_NOW = 0;  //This variable must be unsigned.
  422.     int32_t OUTPUT_VALUE;
  423.     uint16_t i1 = 0;
  424.     uint16_t j1 = 0;
  425.     uint16_t i2 = 0;
  426.     uint16_t j2 = 0;
  427.     uint16_t i3 = 0;
  428.     uint16_t j3 = 0;
  429.     uint16_t i4 = 0;
  430.     uint16_t j4 = 0;
  431.  
  432.     i2s_output.begin(SAMPLE_RATE);
  433.     adc_input.begin(SAMPLE_RATE);
  434.     while (true) {
  435.       INPUT_VALUE = adc_input.read();  //INPUT_VALUE : int16_t
  436.       INPUT_VALUE = (INPUT_VALUE << 4) + 0x8000;
  437.       if (abs(INPUT_VALUE) > WARNING_VALUE) digitalWrite(PIN_OVER_LOAD, HIGH);
  438.       if (EFFECT_GAIN >= 0.0) {
  439.         OUTPUT_VALUE = (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_VALUE1) & 0x7FFF];
  440.         OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_VALUE2) & 0x7FFF];
  441.         OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_VALUE3) & 0x7FFF];
  442.         OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_VALUE4) & 0x7FFF];
  443.         OUTPUT_VALUE -= (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_TIME) & 0x7FFF];
  444.         //OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - 0x7FFF) & 0x7FFF] / 2;  //不要ではないか！！！！！！！！！！！
  445.         OUTPUT_VALUE = (OUTPUT_VALUE / 8) * (1 << (uint16_t)round(EFFECT_GAIN));
  446.       } else
  447.         OUTPUT_VALUE = 1;              //If OUTPUT_VALUE is set to completely zero, pulse noise will occur when switching.
  448.       i2s_output.write(OUTPUT_VALUE);  // L channel
  449.       i2s_output.write(OUTPUT_VALUE);  // R channel
  450.       DELAY_BUFFER[CNT_NOW] = INPUT_VALUE;
  451.       CNT_NOW++;
  452.       CNT_NOW = CNT_NOW & 0x7FFF;
  453.       if (DELAY_WIDTH_NUMBER1 == 1) DELAY_VALUE1 = CENTRAL_DELAY_VALUE + DELAY_SWING1[i1];
  454.       if (DELAY_WIDTH_NUMBER1 == 2) DELAY_VALUE1 = CENTRAL_DELAY_VALUE + DELAY_SWING2[i1];
  455.       if (DELAY_WIDTH_NUMBER1 == 3) DELAY_VALUE1 = CENTRAL_DELAY_VALUE + DELAY_SWING3[i1];
  456.       if (DELAY_WIDTH_NUMBER1 == 4) DELAY_VALUE1 = CENTRAL_DELAY_VALUE + DELAY_SWING4[i1];
  457.       if (DELAY_WIDTH_NUMBER1 == 5) DELAY_VALUE1 = CENTRAL_DELAY_VALUE + DELAY_SWING5[i1];
  458.  
  459.       if (DELAY_WIDTH_NUMBER2 == 1) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING1[i2];
  460.       if (DELAY_WIDTH_NUMBER2 == 2) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING2[i2];
  461.       if (DELAY_WIDTH_NUMBER2 == 3) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING3[i2];
  462.       if (DELAY_WIDTH_NUMBER2 == 4) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING4[i2];
  463.       if (DELAY_WIDTH_NUMBER2 == 5) DELAY_VALUE2 = CENTRAL_DELAY_VALUE - DELAY_SWING5[i2];
  464.  
  465.       if (DELAY_WIDTH_NUMBER3 == 1) DELAY_VALUE3 = CENTRAL_DELAY_VALUE + DELAY_SWING1[i3];
  466.       if (DELAY_WIDTH_NUMBER3 == 2) DELAY_VALUE3 = CENTRAL_DELAY_VALUE + DELAY_SWING2[i3];
  467.       if (DELAY_WIDTH_NUMBER3 == 3) DELAY_VALUE3 = CENTRAL_DELAY_VALUE + DELAY_SWING3[i3];
  468.       if (DELAY_WIDTH_NUMBER3 == 4) DELAY_VALUE3 = CENTRAL_DELAY_VALUE + DELAY_SWING4[i3];
  469.       if (DELAY_WIDTH_NUMBER3 == 5) DELAY_VALUE3 = CENTRAL_DELAY_VALUE + DELAY_SWING5[i3];
  470.  
  471.       if (DELAY_WIDTH_NUMBER4 == 1) DELAY_VALUE4 = CENTRAL_DELAY_VALUE - DELAY_SWING1[i4];
  472.       if (DELAY_WIDTH_NUMBER4 == 2) DELAY_VALUE4 = CENTRAL_DELAY_VALUE - DELAY_SWING2[i4];
  473.       if (DELAY_WIDTH_NUMBER4 == 3) DELAY_VALUE4 = CENTRAL_DELAY_VALUE - DELAY_SWING3[i4];
  474.       if (DELAY_WIDTH_NUMBER4 == 4) DELAY_VALUE4 = CENTRAL_DELAY_VALUE - DELAY_SWING4[i4];
  475.       if (DELAY_WIDTH_NUMBER4 == 5) DELAY_VALUE4 = CENTRAL_DELAY_VALUE - DELAY_SWING5[i4];
  476.  
  477.       //
  478.       j1++;
  479.       if (j1 >= VIBRATION_RATE_PARAMETER1) {
  480.         j1 = 0;
  481.         i1++;
  482.         if (i1 >= SAMPLE_RANGE) i1 = 0;
  483.       }
  484.       j2++;
  485.       if (j2 >= VIBRATION_RATE_PARAMETER2) {
  486.         j2 = 0;
  487.         i2++;
  488.         if (i2 >= SAMPLE_RANGE) i2 = 0;
  489.       }
  490.  
  491.       j3++;
  492.       if (j3 >= VIBRATION_RATE_PARAMETER3) {
  493.         j3 = 0;
  494.         i3++;
  495.         if (i3 >= SAMPLE_RANGE) i3 = 0;
  496.       }
  497.  
  498.       j4++;
  499.       if (j4 >= VIBRATION_RATE_PARAMETER4) {
  500.         j4 = 0;
  501.         i4++;
  502.         if (i4 >= SAMPLE_RANGE) i4 = 0;
  503.       }
  504.  
  505.       if (!FLAG_SWITCH) {
  506.         EFFECT_GAIN = EFFECT_GAIN - 0.0005;
  507.         if (EFFECT_GAIN < 0.0) EFFECT_GAIN = -0.0005;
  508.       } else {
  509.         EFFECT_GAIN = EFFECT_GAIN + 0.0005;
  510.         if (EFFECT_GAIN > 16)
  511.           EFFECT_GAIN = 16.0;
  512.       }
  513.       digitalWrite(PIN_OVER_LOAD, LOW);
  514.     }
  515.   }
  516.   //dimention C 2 +delay ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  517.  
  518.  
  519.   //EFFECTOR_TYPE 8 has no program, please make it yourself.
  520.  
  521.  
  522.   //limitter with delay
  523.   //right rotary switch : limitation threshold
  524.   //left rotary switch : limitation rate
  525.   if (EFFECTOR_TYPE == 9) {
  526.  
  527.  
  528.     //If you want delay,
  529.     //rewrite the variables as follows:
  530.     //DELAY_FEEDBACK = 1,2,3, ... or 7;
  531.     //boolean FLAG_LIMIT_DELAY = true;
  532.     DELAY_TIME = 415 * 50;  //415ms
  533.     DELAY_FEEDBACK = 0;
  534.     boolean FLAG_LIMIT_DELAY = false;
  535.  
  536.     int16_t DELAY_BUFFER[0x8000];
  537.     for (uint16_t i = 0; i < 0x8000; i++) DELAY_BUFFER[i] = 0;
  538.     int32_t OUTPUT_VALUE;
  539.     int32_t DELAY_BUFFER_VALUE;
  540.     uint16_t CNT_NOW = 0;  //This variable must be unsigned.
  541.     int16_t LIMIT_TH2, LIMIT_TH3;
  542.     i2s_output.begin(SAMPLE_RATE);
  543.     adc_input.begin(SAMPLE_RATE);
  544.     while (true) {
  545.       INPUT_VALUE = adc_input.read();
  546.       INPUT_VALUE = (INPUT_VALUE << 4) + 0x8000;
  547.       if (abs(INPUT_VALUE) > WARNING_VALUE) digitalWrite(PIN_OVER_LOAD, HIGH);
  548.       OUTPUT_VALUE = (int32_t)INPUT_VALUE;
  549.       if (OUTPUT_VALUE >= LIMIT_TH) OUTPUT_VALUE = (OUTPUT_VALUE - LIMIT_TH) / LIMIT_RATE + LIMIT_TH;
  550.       if (OUTPUT_VALUE <= -LIMIT_TH) OUTPUT_VALUE = (OUTPUT_VALUE + LIMIT_TH) / LIMIT_RATE - LIMIT_TH;
  551.  
  552.       if (EFFECT_GAIN >= 0.0) {
  553.         OUTPUT_VALUE = (OUTPUT_VALUE + OUTPUT_VALUE + OUTPUT_VALUE) / 4;
  554.         OUTPUT_VALUE = OUTPUT_VALUE * (1 << (uint16_t)round(EFFECT_GAIN));
  555.         OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_TIME) & 0x7FFF] * 0x10000;
  556.         OUTPUT_VALUE += (int32_t)INPUT_VALUE * (0x10000 >> (uint16_t)round(EFFECT_GAIN));
  557.       } else
  558.         OUTPUT_VALUE = (int32_t)INPUT_VALUE * 0x10000;
  559.       i2s_output.write(OUTPUT_VALUE);  // L channel
  560.       i2s_output.write(OUTPUT_VALUE);  // R channel
  561.       OUTPUT_VALUE = OUTPUT_VALUE >> 16;
  562.       DELAY_BUFFER_VALUE = 0;
  563.       for (uint16_t i = 0; i < DELAY_FEEDBACK; i++) DELAY_BUFFER_VALUE += OUTPUT_VALUE;
  564.       DELAY_BUFFER_VALUE = DELAY_BUFFER_VALUE / 8;
  565.       DELAY_BUFFER[CNT_NOW] = (int16_t)DELAY_BUFFER_VALUE;
  566.       CNT_NOW++;
  567.       CNT_NOW = CNT_NOW & 0x7FFF;
  568.       if (!FLAG_SWITCH) {
  569.         EFFECT_GAIN = EFFECT_GAIN - 0.005;
  570.         if (EFFECT_GAIN < 0.0) EFFECT_GAIN = -1;
  571.       } else {
  572.         EFFECT_GAIN = EFFECT_GAIN + 0.005;
  573.         if (EFFECT_GAIN > 16)
  574.           EFFECT_GAIN = 16.0;
  575.       }
  576.       digitalWrite(PIN_OVER_LOAD, LOW);
  577.     }
  578.   }
  579.   //limitter with delay ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  580.  
  581.  
  582.   //over drive with delay or distortion with delay
  583.   //right rotary switch : OVER_DRIVE_GAIN
  584.   //left rotary switch : OVER_DRIVE_LEVEL
  585.   if (EFFECTOR_TYPE == 0xA || EFFECTOR_TYPE == 0xB || EFFECTOR_TYPE == 0xC || EFFECTOR_TYPE == 0xD) {
  586.     if (EFFECTOR_TYPE == 0xB || EFFECTOR_TYPE == 0xD) {
  587.       DELAY_FEEDBACK = 2;
  588.       DELAY_TIME = 430 * 50;  //430ms
  589.     }
  590.     int16_t DELAY_BUFFER[0x8000];
  591.     for (uint16_t i = 0; i < 0x8000; i++) DELAY_BUFFER[i] = 0;
  592.     int32_t OUTPUT_VALUE;
  593.     int32_t OUTPUT_VALUE_spare;
  594.     int32_t DELAY_BUFFER_VALUE;
  595.     uint16_t CNT_NOW = 0;  //This variable must be unsigned.
  596.     int32_t OVER_DRIVEN;
  597.     i2s_output.begin(SAMPLE_RATE);
  598.     adc_input.begin(SAMPLE_RATE);
  599.     while (true) {
  600.       INPUT_VALUE = adc_input.read();
  601.       INPUT_VALUE = (INPUT_VALUE << 4) + 0x8000;
  602.       if (abs(INPUT_VALUE) > WARNING_VALUE) digitalWrite(PIN_OVER_LOAD, HIGH);
  603.       OVER_DRIVEN = INPUT_VALUE * OVER_DRIVE_GAIN;
  604.       if (EFFECTOR_TYPE == 0xA || EFFECTOR_TYPE == 0xB) {
  605.         if (OVER_DRIVEN >= 15260) OVER_DRIVEN = (OVER_DRIVEN - 15260) / 2 + 15260;
  606.         if (OVER_DRIVEN <= -15260) OVER_DRIVEN = (OVER_DRIVEN + 15260) / 2 - 15260;
  607.         if (OVER_DRIVEN >= 25260) OVER_DRIVEN = (OVER_DRIVEN - 25260) / 2 + 25260;
  608.         if (OVER_DRIVEN <= -25260) OVER_DRIVEN = (OVER_DRIVEN + 25260) / 2 - 25260;
  609.         if (OVER_DRIVEN >= 30260) OVER_DRIVEN = (OVER_DRIVEN - 30260) / 2 + 30260;
  610.         if (OVER_DRIVEN <= -30260) OVER_DRIVEN = (OVER_DRIVEN + 30260) / 2 - 30260;
  611.         if (OVER_DRIVEN >= 32760) OVER_DRIVEN = 32760;
  612.         if (OVER_DRIVEN <= -32760) OVER_DRIVEN = 0 - 32760;
  613.       }
  614.       if (EFFECTOR_TYPE == 0xC || EFFECTOR_TYPE == 0xD) {
  615.         if (OVER_DRIVEN >= 15260) OVER_DRIVEN = 15260;
  616.         if (OVER_DRIVEN <= -15260) OVER_DRIVEN = -15260;
  617.       }
  618.  
  619.       if (EFFECT_GAIN >= 0.0) {
  620.         if (EFFECTOR_TYPE == 0xA || EFFECTOR_TYPE == 0xC) OUTPUT_VALUE = OVER_DRIVEN;
  621.         if (EFFECTOR_TYPE == 0xB || EFFECTOR_TYPE == 0xD) {
  622.           OUTPUT_VALUE = (OVER_DRIVEN + OVER_DRIVEN + OVER_DRIVEN) / 4;
  623.           OUTPUT_VALUE += (int32_t)DELAY_BUFFER[(CNT_NOW - DELAY_TIME) & 0x7FFF];
  624.         }
  625.         OUTPUT_VALUE = OUTPUT_VALUE * (1 << (uint16_t)round(EFFECT_GAIN));
  626.         OUTPUT_VALUE_spare = OUTPUT_VALUE;
  627.         OUTPUT_VALUE = OUTPUT_VALUE / OVER_DRIVE_LEVEL;
  628.         OUTPUT_VALUE += (int32_t)INPUT_VALUE * (0x10000 >> (uint16_t)round(EFFECT_GAIN));
  629.       } else
  630.         OUTPUT_VALUE = (int32_t)INPUT_VALUE * 0x10000;
  631.       i2s_output.write(OUTPUT_VALUE);  // L channel
  632.       i2s_output.write(OUTPUT_VALUE);  // R channel
  633.       if (EFFECTOR_TYPE == 0xB || EFFECTOR_TYPE == 0xD) {
  634.         OUTPUT_VALUE_spare = OUTPUT_VALUE_spare >> 16;
  635.         DELAY_BUFFER_VALUE = 0;
  636.         for (uint16_t i = 0; i < DELAY_FEEDBACK; i++) DELAY_BUFFER_VALUE += OUTPUT_VALUE_spare;
  637.         DELAY_BUFFER_VALUE = DELAY_BUFFER_VALUE / 8;
  638.         DELAY_BUFFER[CNT_NOW] = (int16_t)DELAY_BUFFER_VALUE;
  639.       }
  640.       CNT_NOW++;
  641.       CNT_NOW = CNT_NOW & 0x7FFF;
  642.       if (!FLAG_SWITCH) {
  643.         EFFECT_GAIN = EFFECT_GAIN - 0.005;
  644.         if (EFFECT_GAIN < 0.0) EFFECT_GAIN = -1;
  645.       } else {
  646.         EFFECT_GAIN = EFFECT_GAIN + 0.005;
  647.         if (EFFECT_GAIN > 16)
  648.           EFFECT_GAIN = 16.0;
  649.       }
  650.       digitalWrite(PIN_OVER_LOAD, LOW);
  651.     }
  652.   }
  653.   //over drive with delay  or distortion with delay^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  654.  
  655.  
  656.   //noise gate
  657.   if (EFFECTOR_TYPE == 0xE) {
  658.     int32_t OUTPUT_VALUE;
  659.     int16_t DELAY_BUFFER[0x8000];
  660.     for (uint16_t i = 0; i < 0x8000; i++) DELAY_BUFFER[i] = 0;
  661.     uint16_t CNT_NOW = 0;  //This variable must be unsigned.
  662.     i2s_output.begin(SAMPLE_RATE);
  663.     adc_input.begin(SAMPLE_RATE);
  664.     while (true) {
  665.       INPUT_VALUE = adc_input.read();
  666.       INPUT_VALUE = (INPUT_VALUE << 4) + 0x8000;
  667.       if (abs(INPUT_VALUE) > WARNING_VALUE) digitalWrite(PIN_OVER_LOAD, HIGH);
  668.  
  669.       if (abs(INPUT_VALUE) <= NOISE_GATE_THRESHOLD) NOISE_GATE_OPEN_LEVEL -= NOISE_GATE_DECAY_SPEED;
  670.       else NOISE_GATE_OPEN_LEVEL += 2500;
  671.       if (NOISE_GATE_OPEN_LEVEL > 50000) NOISE_GATE_OPEN_LEVEL = 50000;
  672.       DECAYED_SOUND = (int32_t)INPUT_VALUE * 16;
  673.       if (NOISE_GATE_OPEN_LEVEL < 35000) DECAYED_SOUND -= INPUT_VALUE;
  674.       if (NOISE_GATE_OPEN_LEVEL < 32500) DECAYED_SOUND -= INPUT_VALUE;
  675.       if (NOISE_GATE_OPEN_LEVEL < 30000) DECAYED_SOUND -= INPUT_VALUE;
  676.       if (NOISE_GATE_OPEN_LEVEL < 27500) DECAYED_SOUND -= INPUT_VALUE;
  677.       if (NOISE_GATE_OPEN_LEVEL < 25000) DECAYED_SOUND -= INPUT_VALUE;
  678.       if (NOISE_GATE_OPEN_LEVEL < 22500) DECAYED_SOUND -= INPUT_VALUE;
  679.       if (NOISE_GATE_OPEN_LEVEL < 20000) DECAYED_SOUND -= INPUT_VALUE;
  680.       if (NOISE_GATE_OPEN_LEVEL < 17500) DECAYED_SOUND -= INPUT_VALUE;
  681.       if (NOISE_GATE_OPEN_LEVEL < 15000) DECAYED_SOUND -= INPUT_VALUE;
  682.       if (NOISE_GATE_OPEN_LEVEL < 12500) DECAYED_SOUND -= INPUT_VALUE;
  683.       if (NOISE_GATE_OPEN_LEVEL < 10000) DECAYED_SOUND -= INPUT_VALUE;
  684.       if (NOISE_GATE_OPEN_LEVEL < 7500) DECAYED_SOUND -= INPUT_VALUE;
  685.       if (NOISE_GATE_OPEN_LEVEL < 5000) DECAYED_SOUND -= INPUT_VALUE;
  686.       if (NOISE_GATE_OPEN_LEVEL < 2500) DECAYED_SOUND -= INPUT_VALUE;
  687.       if (NOISE_GATE_OPEN_LEVEL < 1250) DECAYED_SOUND -= INPUT_VALUE;
  688.       if (NOISE_GATE_OPEN_LEVEL < 600) DECAYED_SOUND = INPUT_VALUE / 2;
  689.       if (NOISE_GATE_OPEN_LEVEL < 300) DECAYED_SOUND = DECAYED_SOUND / 2;
  690.       if (NOISE_GATE_OPEN_LEVEL < 150) {
  691.         DECAYED_SOUND = 0;
  692.         NOISE_GATE_OPEN_LEVEL = 149;
  693.       }
  694.       OUTPUT_VALUE = DECAYED_SOUND / 16;
  695.  
  696.       if (EFFECT_GAIN >= 0.0) {
  697.         OUTPUT_VALUE = OUTPUT_VALUE * (1 << (uint16_t)round(EFFECT_GAIN));
  698.         OUTPUT_VALUE += (int32_t)INPUT_VALUE * (0x10000 >> (uint16_t)round(EFFECT_GAIN));
  699.       } else
  700.         OUTPUT_VALUE = (int32_t)INPUT_VALUE * 0x10000;
  701.       i2s_output.write(OUTPUT_VALUE);  // L channel
  702.       i2s_output.write(OUTPUT_VALUE);  // R channel
  703.  
  704.       DELAY_BUFFER[CNT_NOW] = (int16_t)OUTPUT_VALUE / 0x10000;
  705.       CNT_NOW++;
  706.       CNT_NOW = CNT_NOW & 0x7FFF;
  707.       if (!FLAG_SWITCH) {
  708.         EFFECT_GAIN = EFFECT_GAIN - 0.005;
  709.         if (EFFECT_GAIN < 0.0) EFFECT_GAIN = -1;
  710.       } else {
  711.         EFFECT_GAIN = EFFECT_GAIN + 0.005;
  712.         if (EFFECT_GAIN > 16)
  713.           EFFECT_GAIN = 16.0;
  714.       }
  715.       digitalWrite(PIN_OVER_LOAD, LOW);
  716.     }
  717.   }
  718.   //NOISE GATE^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  719.  
  720.  
  721.   //etc
  722.   //right rotary switch : 1st digit
  723.   //left rotary switch : 2nd digit
  724.   if (EFFECTOR_TYPE == 0xF) {
  725.     int32_t OUTPUT_VALUE;
  726.     int16_t DELAY_BUFFER[0x8000];
  727.     for (uint16_t i = 0; i < 0x8000; i++) DELAY_BUFFER[i] = 0;
  728.     uint16_t CNT_NOW = 0;  //This variable must be unsigned.
  729.     int16_t SOFT_FUZZ_THRESHOLD = 0x1000;
  730.     int16_t HARD_FUZZ_THRESHOLD = 0x800;
  731.     int16_t ULTRA_HARD_FUZZ_THRESHOLD = 0x400;
  732.     byte WAVE_PHASE = 3;
  733.  
  734.     //wave generator
  735.     uint16_t MAX_VALUE_SIN440_11 = SAMPLE_RATE * 11 / 440;  //clocks of 11 cycles under 440Hz
  736.     int16_t SIN440_11[MAX_VALUE_SIN440_11];
  737.     for (uint16_t j = 0; j < MAX_VALUE_SIN440_11; j++) SIN440_11[j] = 0x7FF0 * sin(2 * P_I * j * 440 / SAMPLE_RATE);
  738.     uint16_t CLOCK_SIN440_11 = 0;
  739.  
  740.     i2s_output.begin(SAMPLE_RATE);
  741.     adc_input.begin(SAMPLE_RATE);
  742.     while (true) {
  743.       INPUT_VALUE = adc_input.read();
  744.       INPUT_VALUE = (INPUT_VALUE << 4) + 0x8000;
  745.       if (abs(INPUT_VALUE) > WARNING_VALUE) digitalWrite(PIN_OVER_LOAD, HIGH);
  746.  
  747.       if (ETC == 0) { OUTPUT_VALUE = abs(INPUT_VALUE); }
  748.       if (ETC == 1) {
  749.         if (INPUT_VALUE < 0) OUTPUT_VALUE = 0;
  750.         else OUTPUT_VALUE = INPUT_VALUE;
  751.       }
  752.       if (ETC == 2) {
  753.         if (INPUT_VALUE > 0) {
  754.           if (INPUT_VALUE > 0x1000) OUTPUT_VALUE = 0x1000 - (INPUT_VALUE - 0x1000);
  755.           else OUTPUT_VALUE = INPUT_VALUE;
  756.         }
  757.         if (INPUT_VALUE <= 0) {
  758.           if (INPUT_VALUE < -0x1000) OUTPUT_VALUE = -0x1000 - (INPUT_VALUE + 0x1000);
  759.           else OUTPUT_VALUE = INPUT_VALUE;
  760.         }
  761.       }
  762.       if (ETC == 3) {
  763.         OUTPUT_VALUE = INPUT_VALUE;
  764.         if (OUTPUT_VALUE >= 0) OUTPUT_VALUE = OUTPUT_VALUE / 2;
  765.       }
  766.       if (ETC == 4) {
  767.         if (INPUT_VALUE > 0) {
  768.           OUTPUT_VALUE = INPUT_VALUE - 0x1000;
  769.           if (OUTPUT_VALUE < 0) OUTPUT_VALUE = 0;
  770.         }
  771.         if (INPUT_VALUE <= 0) {
  772.           OUTPUT_VALUE = INPUT_VALUE + 0x1000;
  773.           if (OUTPUT_VALUE > 0) OUTPUT_VALUE = 0;
  774.         }
  775.       }
  776.       if (ETC == 10) {  //周波数特性にクセのあるLow-pass filter 1
  777.         OUTPUT_VALUE = INPUT_VALUE;
  778.         for (uint16_t j = 1; j < 16; j++) OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - j) & 0x7FFF];
  779.         OUTPUT_VALUE = OUTPUT_VALUE / 16;
  780.       }
  781.  
  782.       if (ETC == 11) {  //周波数特性にクセのあるLow-pass filter 2
  783.         OUTPUT_VALUE = INPUT_VALUE;
  784.         for (uint16_t j = 1; j < 32; j++) OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - j) & 0x7FFF];
  785.         OUTPUT_VALUE = OUTPUT_VALUE / 32;
  786.       }
  787.  
  788.       if (ETC == 12) {  //周波数特性にクセのあるLow-pass filter 3
  789.         OUTPUT_VALUE = INPUT_VALUE * 4 + INPUT_VALUE;
  790.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 1) & 0x7FFF] * 2;
  791.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 2) & 0x7FFF];
  792.         OUTPUT_VALUE = OUTPUT_VALUE / 8;
  793.       }
  794.  
  795.       if (ETC == 13) {  //周波数特性にクセのあるLow-pass filter 4
  796.         OUTPUT_VALUE = INPUT_VALUE * 16 + INPUT_VALUE;
  797.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 1) & 0x7FFF] * 8;
  798.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 2) & 0x7FFF] * 4;
  799.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 3) & 0x7FFF] * 2;
  800.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 4) & 0x7FFF];
  801.         OUTPUT_VALUE = OUTPUT_VALUE / 32;
  802.       }
  803.  
  804.       if (ETC == 14) {  //周波数特性にクセのあるLow-pass filter 5
  805.         OUTPUT_VALUE = INPUT_VALUE * 64 + INPUT_VALUE;
  806.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 1) & 0x7FFF] * 32;
  807.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 2) & 0x7FFF] * 16;
  808.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 3) & 0x7FFF] * 8;
  809.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 4) & 0x7FFF] * 4;
  810.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 5) & 0x7FFF] * 2;
  811.         OUTPUT_VALUE += DELAY_BUFFER[(CNT_NOW - 6) & 0x7FFF];
  812.         OUTPUT_VALUE = OUTPUT_VALUE / 128;
  813.       }
  814.  
  815.  
  816.       if (ETC == 20) {  //soft fuzz
  817.         OUTPUT_VALUE = abs(INPUT_VALUE);
  818.         if (OUTPUT_VALUE > SOFT_FUZZ_THRESHOLD) OUTPUT_VALUE = SOFT_FUZZ_THRESHOLD;
  819.         OUTPUT_VALUE = OUTPUT_VALUE * 2;
  820.       }
  821.  
  822.       if (ETC == 21) {  //fuzz
  823.         OUTPUT_VALUE = abs(INPUT_VALUE);
  824.         if (OUTPUT_VALUE > HARD_FUZZ_THRESHOLD) OUTPUT_VALUE = HARD_FUZZ_THRESHOLD;
  825.         OUTPUT_VALUE = OUTPUT_VALUE * 4;
  826.       }
  827.  
  828.       if (ETC == 22) {  //hard fuzz
  829.         OUTPUT_VALUE = abs(INPUT_VALUE);
  830.         if (OUTPUT_VALUE > HARD_FUZZ_THRESHOLD) OUTPUT_VALUE = HARD_FUZZ_THRESHOLD - OUTPUT_VALUE;
  831.         if (OUTPUT_VALUE < 0) OUTPUT_VALUE = 0 - OUTPUT_VALUE;
  832.         OUTPUT_VALUE = OUTPUT_VALUE * 4;
  833.       }
  834.  
  835.       if (ETC == 23) {  //ultra hard fuzz
  836.         OUTPUT_VALUE = abs(INPUT_VALUE);
  837.         if (OUTPUT_VALUE > ULTRA_HARD_FUZZ_THRESHOLD) OUTPUT_VALUE = ULTRA_HARD_FUZZ_THRESHOLD - OUTPUT_VALUE;
  838.         OUTPUT_VALUE = OUTPUT_VALUE * 4;
  839.       }
  840.  
  841.       if (ETC == 24) {  //super ultra hard fuzz
  842.         OUTPUT_VALUE = abs(INPUT_VALUE);
  843.         if (OUTPUT_VALUE > ULTRA_HARD_FUZZ_THRESHOLD) OUTPUT_VALUE = ULTRA_HARD_FUZZ_THRESHOLD - OUTPUT_VALUE;
  844.         if (OUTPUT_VALUE < 0) OUTPUT_VALUE = 0 - OUTPUT_VALUE;
  845.         if (OUTPUT_VALUE > ULTRA_HARD_FUZZ_THRESHOLD) OUTPUT_VALUE = ULTRA_HARD_FUZZ_THRESHOLD - OUTPUT_VALUE;
  846.         if (OUTPUT_VALUE < 0) OUTPUT_VALUE = 0 - OUTPUT_VALUE;
  847.         OUTPUT_VALUE = OUTPUT_VALUE * 4;
  848.       }
  849.  
  850.       if (ETC == 30) {  //octaver A < 1 octave lower >
  851.         OUTPUT_VALUE = (int32_t)INPUT_VALUE * 256;
  852.         if (WAVE_PHASE >= 3 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 0; }
  853.         if (WAVE_PHASE == 0 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 1; }
  854.         if (WAVE_PHASE == 1 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 2; }
  855.         if (WAVE_PHASE == 2 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 3; }
  856.         if (WAVE_PHASE == 0) OUTPUT_VALUE = 0x1800;
  857.         if (WAVE_PHASE == 1) OUTPUT_VALUE = 0x1800;
  858.         if (WAVE_PHASE == 2) OUTPUT_VALUE = -0x1800;
  859.         if (WAVE_PHASE == 3) OUTPUT_VALUE = -0x1800;
  860.         OUTPUT_VALUE = OUTPUT_VALUE / 2;  // volume adjustment
  861.       }
  862.  
  863.  
  864.       if (ETC == 31) {  //octaver B < 2 octave lower >
  865.         OUTPUT_VALUE = (int32_t)INPUT_VALUE * 256;
  866.         if (WAVE_PHASE >= 7 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 0; }
  867.         if (WAVE_PHASE == 0 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 1; }
  868.         if (WAVE_PHASE == 1 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 2; }
  869.         if (WAVE_PHASE == 2 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 3; }
  870.         if (WAVE_PHASE == 3 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 4; }
  871.         if (WAVE_PHASE == 4 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 5; }
  872.         if (WAVE_PHASE == 5 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 6; }
  873.         if (WAVE_PHASE == 6 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 7; }
  874.         if (WAVE_PHASE == 0) OUTPUT_VALUE = 0x1800;
  875.         if (WAVE_PHASE == 1) OUTPUT_VALUE = 0x1800;
  876.         if (WAVE_PHASE == 2) OUTPUT_VALUE = 0x1800;
  877.         if (WAVE_PHASE == 3) OUTPUT_VALUE = 0x1800;
  878.         if (WAVE_PHASE == 4) OUTPUT_VALUE = -0x1800;
  879.         if (WAVE_PHASE == 5) OUTPUT_VALUE = -0x1800;
  880.         if (WAVE_PHASE == 6) OUTPUT_VALUE = -0x1800;
  881.         if (WAVE_PHASE == 7) OUTPUT_VALUE = -0x1800;
  882.         OUTPUT_VALUE = OUTPUT_VALUE / 2;  // volume adjustment
  883.       }
  884.  
  885.  
  886.       if (ETC == 32) {  //octaver C < 1 and 2 octaves lower >
  887.         OUTPUT_VALUE = (int32_t)INPUT_VALUE * 256;
  888.         if (WAVE_PHASE >= 7 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 0; }
  889.         if (WAVE_PHASE == 0 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 1; }
  890.         if (WAVE_PHASE == 1 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 2; }
  891.         if (WAVE_PHASE == 2 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 3; }
  892.         if (WAVE_PHASE == 3 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 4; }
  893.         if (WAVE_PHASE == 4 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 5; }
  894.         if (WAVE_PHASE == 5 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 6; }
  895.         if (WAVE_PHASE == 6 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 7; }
  896.         if (WAVE_PHASE == 0) OUTPUT_VALUE = 0x1800;
  897.         if (WAVE_PHASE == 1) OUTPUT_VALUE = 0x1800;
  898.         if (WAVE_PHASE == 2) OUTPUT_VALUE = 0;
  899.         if (WAVE_PHASE == 3) OUTPUT_VALUE = 0;
  900.         if (WAVE_PHASE == 4) OUTPUT_VALUE = 0;
  901.         if (WAVE_PHASE == 5) OUTPUT_VALUE = 0;
  902.         if (WAVE_PHASE == 6) OUTPUT_VALUE = -0x1800;
  903.         if (WAVE_PHASE == 7) OUTPUT_VALUE = -0x1800;
  904.         OUTPUT_VALUE = OUTPUT_VALUE / 2;  // volume adjustment
  905.       }
  906.  
  907.       if (ETC == 33) {  //octaver D < 0 and 1 and 2 octaves lower >
  908.         OUTPUT_VALUE = (int32_t)INPUT_VALUE * 256;
  909.         if (WAVE_PHASE >= 7 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 0; }
  910.         if (WAVE_PHASE == 0 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 1; }
  911.         if (WAVE_PHASE == 1 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 2; }
  912.         if (WAVE_PHASE == 2 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 3; }
  913.         if (WAVE_PHASE == 3 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 4; }
  914.         if (WAVE_PHASE == 4 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 5; }
  915.         if (WAVE_PHASE == 5 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 6; }
  916.         if (WAVE_PHASE == 6 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 7; }
  917.         if (WAVE_PHASE == 0) OUTPUT_VALUE = 0x1800;
  918.         if (WAVE_PHASE == 1) OUTPUT_VALUE = 0x800;
  919.         if (WAVE_PHASE == 2) OUTPUT_VALUE = 0x800;
  920.         if (WAVE_PHASE == 3) OUTPUT_VALUE = -0x800;
  921.         if (WAVE_PHASE == 4) OUTPUT_VALUE = 0x800;
  922.         if (WAVE_PHASE == 5) OUTPUT_VALUE = -0x800;
  923.         if (WAVE_PHASE == 6) OUTPUT_VALUE = -0x800;
  924.         if (WAVE_PHASE == 7) OUTPUT_VALUE = -0x1800;
  925.         OUTPUT_VALUE = OUTPUT_VALUE / 2;  // volume adjustment
  926.       }
  927.  
  928.       if (ETC == 34) {  //octaver E < 3 octave lower
  929.         OUTPUT_VALUE = (int32_t)INPUT_VALUE * 256;
  930.         if (WAVE_PHASE >= 15 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 0; }
  931.         if (WAVE_PHASE == 0 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 1; }
  932.         if (WAVE_PHASE == 1 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 2; }
  933.         if (WAVE_PHASE == 2 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 3; }
  934.         if (WAVE_PHASE == 3 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 4; }
  935.         if (WAVE_PHASE == 4 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 5; }
  936.         if (WAVE_PHASE == 5 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 6; }
  937.         if (WAVE_PHASE == 6 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 7; }
  938.         if (WAVE_PHASE == 7 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 8; }
  939.         if (WAVE_PHASE == 8 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 9; }
  940.         if (WAVE_PHASE == 9 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 10; }
  941.         if (WAVE_PHASE == 10 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 11; }
  942.         if (WAVE_PHASE == 11 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 12; }
  943.         if (WAVE_PHASE == 12 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 13; }
  944.         if (WAVE_PHASE == 13 && OUTPUT_VALUE >= 0x7EEE) { WAVE_PHASE = 14; }
  945.         if (WAVE_PHASE == 14 && OUTPUT_VALUE <= -0x7EEE) { WAVE_PHASE = 15; }
  946.  
  947.         if (WAVE_PHASE == 0) OUTPUT_VALUE = 0x1800;
  948.         if (WAVE_PHASE == 1) OUTPUT_VALUE = 0x1800;
  949.         if (WAVE_PHASE == 2) OUTPUT_VALUE = 0x1800;
  950.         if (WAVE_PHASE == 3) OUTPUT_VALUE = 0x1800;
  951.         if (WAVE_PHASE == 4) OUTPUT_VALUE = 0x1800;
  952.         if (WAVE_PHASE == 5) OUTPUT_VALUE = 0x1800;
  953.         if (WAVE_PHASE == 6) OUTPUT_VALUE = 0x1800;
  954.         if (WAVE_PHASE == 7) OUTPUT_VALUE = 0x1800;
  955.         if (WAVE_PHASE == 8) OUTPUT_VALUE = -0x1800;
  956.         if (WAVE_PHASE == 9) OUTPUT_VALUE = -0x1800;
  957.         if (WAVE_PHASE == 10) OUTPUT_VALUE = -0x1800;
  958.         if (WAVE_PHASE == 11) OUTPUT_VALUE = -0x1800;
  959.         if (WAVE_PHASE == 12) OUTPUT_VALUE = -0x1800;
  960.         if (WAVE_PHASE == 13) OUTPUT_VALUE = -0x1800;
  961.         if (WAVE_PHASE == 14) OUTPUT_VALUE = -0x1800;
  962.         if (WAVE_PHASE == 15) OUTPUT_VALUE = -0x1800;
  963.         OUTPUT_VALUE = OUTPUT_VALUE / 2;  // volume adjustment
  964.       }
  965.  
  966.  
  967.       if (ETC == 40) {  //differential
  968.         OUTPUT_VALUE = (int32_t)(INPUT_VALUE - DELAY_BUFFER[(CNT_NOW - 1) & 0x7FFF]);
  969.         if (OUTPUT_VALUE >= 0x7FFF) OUTPUT_VALUE = 0x7FFF;
  970.         if (OUTPUT_VALUE <= -0x8000) OUTPUT_VALUE = -0x8000;
  971.       }
  972.  
  973.  
  974.       if (ETC == 41 || ETC == 42 || ETC == 43) {               //noise gate
  975.         if (abs(INPUT_VALUE) <= 700) NOISE_GATE_OPEN_LEVEL--;  //Based on my experience, around 500 is the minimum threshold.
  976.         else NOISE_GATE_OPEN_LEVEL += 2500;
  977.         if (NOISE_GATE_OPEN_LEVEL > 50000) NOISE_GATE_OPEN_LEVEL = 50000;
  978.         DECAYED_SOUND = (int32_t)INPUT_VALUE * 8;
  979.         if (NOISE_GATE_OPEN_LEVEL < 35000) DECAYED_SOUND -= INPUT_VALUE;
  980.         if (NOISE_GATE_OPEN_LEVEL < 30000) DECAYED_SOUND -= INPUT_VALUE;
  981.         if (NOISE_GATE_OPEN_LEVEL < 25000) DECAYED_SOUND -= INPUT_VALUE;
  982.         if (NOISE_GATE_OPEN_LEVEL < 20000) DECAYED_SOUND -= INPUT_VALUE;
  983.         if (NOISE_GATE_OPEN_LEVEL < 15000) DECAYED_SOUND -= INPUT_VALUE;
  984.         if (NOISE_GATE_OPEN_LEVEL < 10000) DECAYED_SOUND -= INPUT_VALUE;
  985.         if (NOISE_GATE_OPEN_LEVEL < 5000) DECAYED_SOUND -= INPUT_VALUE;
  986.         if (NOISE_GATE_OPEN_LEVEL < 2500) DECAYED_SOUND = INPUT_VALUE / 2;
  987.         if (NOISE_GATE_OPEN_LEVEL < 1250) DECAYED_SOUND = DECAYED_SOUND / 2;
  988.         if (NOISE_GATE_OPEN_LEVEL < 600) {
  989.           DECAYED_SOUND = 0;
  990.           NOISE_GATE_OPEN_LEVEL = 550;
  991.         }
  992.         INPUT_VALUE = DECAYED_SOUND / 8;
  993.         OUTPUT_VALUE = INPUT_VALUE;
  994.       }
  995.  
  996.       if (ETC == 42) {  //kind of distortion
  997.         if (INPUT_VALUE > 0) OUTPUT_VALUE = (int32_t)(INPUT_VALUE) + 0x500;
  998.         if (INPUT_VALUE == 0) OUTPUT_VALUE = 0;
  999.         if (INPUT_VALUE < 0) OUTPUT_VALUE = (int32_t)(INPUT_VALUE)-0x500;
  1000.         if (OUTPUT_VALUE >= 0x7FFF) OUTPUT_VALUE = 0x7FFF;
  1001.         if (OUTPUT_VALUE <= -0x8000) OUTPUT_VALUE = -0x8000;
  1002.       }
  1003.  
  1004.       if (ETC == 43) {  //kind of distortion
  1005.         if (INPUT_VALUE > 0) OUTPUT_VALUE = -(int32_t)(INPUT_VALUE) + 0x500;
  1006.         if (INPUT_VALUE == 0) OUTPUT_VALUE = 0;
  1007.         if (INPUT_VALUE < 0) OUTPUT_VALUE = -(int32_t)(INPUT_VALUE)-0x500;
  1008.       }
  1009.  
  1010.       if (ETC == 44) {  //440Hz sine wave generator
  1011.         OUTPUT_VALUE = SIN440_11[CLOCK_SIN440_11] / 32;
  1012.         CLOCK_SIN440_11++;
  1013.         if (CLOCK_SIN440_11 >= MAX_VALUE_SIN440_11) CLOCK_SIN440_11 = 0;
  1014.       }
  1015.  
  1016.       if (EFFECT_GAIN >= 0.0) {
  1017.         OUTPUT_VALUE = OUTPUT_VALUE * (1 << (uint16_t)round(EFFECT_GAIN));
  1018.         OUTPUT_VALUE += (int32_t)INPUT_VALUE * (0x10000 >> (uint16_t)round(EFFECT_GAIN));
  1019.       } else
  1020.         OUTPUT_VALUE = (int32_t)INPUT_VALUE * 0x10000;
  1021.       i2s_output.write(OUTPUT_VALUE);  // L channel
  1022.       i2s_output.write(OUTPUT_VALUE);  // R channel
  1023.  
  1024.       DELAY_BUFFER[CNT_NOW] = (int16_t)OUTPUT_VALUE / 0x10000;
  1025.       CNT_NOW++;
  1026.       CNT_NOW = CNT_NOW & 0x7FFF;
  1027.       if (!FLAG_SWITCH) {
  1028.         EFFECT_GAIN = EFFECT_GAIN - 0.005;
  1029.         if (EFFECT_GAIN < 0.0) EFFECT_GAIN = -1;
  1030.       } else {
  1031.         EFFECT_GAIN = EFFECT_GAIN + 0.005;
  1032.         if (EFFECT_GAIN > 16)
  1033.           EFFECT_GAIN = 16.0;
  1034.       }
  1035.       digitalWrite(PIN_OVER_LOAD, LOW);
  1036.     }
  1037.   }
  1038.   //etc^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  1039.  
  1040.  
  1041.   //In case the corresponding number is not found
  1042.   i2s_output.begin(SAMPLE_RATE);
  1043.   adc_input.begin(SAMPLE_RATE);
  1044.   while (true) {
  1045.     INPUT_VALUE = adc_input.read();
  1046.     INPUT_VALUE = (INPUT_VALUE << 4) + 0x8000;
  1047.     if (abs(INPUT_VALUE) > WARNING_VALUE) digitalWrite(PIN_OVER_LOAD, HIGH);
  1048.     i2s_output.write((int32_t)(INPUT_VALUE << 16));  // L channel
  1049.     i2s_output.write((int32_t)(INPUT_VALUE << 16));  // R channel
  1050.     digitalWrite(PIN_OVER_LOAD, LOW);
  1051.   }
  1052. }
  1053.  
  1054. void setup() {
  1055.   pinMode(PIN_FOOT_SWITCH, INPUT_PULLUP);
  1056.   pinMode(PIN_OVER_LOAD, OUTPUT);
  1057.   digitalWrite(PIN_OVER_LOAD, LOW);
  1058.   pinMode(PIN_EFFECTOR_TYPE_1, INPUT_PULLUP);
  1059.   pinMode(PIN_EFFECTOR_TYPE_2, INPUT_PULLUP);
  1060.   pinMode(PIN_EFFECTOR_TYPE_4, INPUT_PULLUP);
  1061.   pinMode(PIN_EFFECTOR_TYPE_8, INPUT_PULLUP);
  1062.   pinMode(PIN_R_1_1, INPUT_PULLUP);
  1063.   pinMode(PIN_R_1_2, INPUT_PULLUP);
  1064.   pinMode(PIN_R_1_3, INPUT_PULLUP);
  1065.   pinMode(PIN_R_1_4, INPUT_PULLUP);
  1066.   pinMode(PIN_R_1_5, INPUT_PULLUP);
  1067.   pinMode(PIN_R_2_1, INPUT_PULLUP);
  1068.   pinMode(PIN_R_2_2, INPUT_PULLUP);
  1069.   pinMode(PIN_R_2_3, INPUT_PULLUP);
  1070.   pinMode(PIN_R_2_4, INPUT_PULLUP);
  1071.   pinMode(PIN_R_2_5, INPUT_PULLUP);
  1072.   delay(100);
  1073.   if (!digitalRead(PIN_EFFECTOR_TYPE_1)) EFFECTOR_TYPE = 1;
  1074.   if (!digitalRead(PIN_EFFECTOR_TYPE_2)) EFFECTOR_TYPE = EFFECTOR_TYPE + 2;
  1075.   if (!digitalRead(PIN_EFFECTOR_TYPE_4)) EFFECTOR_TYPE = EFFECTOR_TYPE + 4;
  1076.   if (!digitalRead(PIN_EFFECTOR_TYPE_8)) EFFECTOR_TYPE = EFFECTOR_TYPE + 8;
  1077.  
  1078.   FLAG_SWITCH = digitalRead(PIN_FOOT_SWITCH);
  1079. }
  1080.  
  1081. void loop() {  //Use delay() frequently to avoid continuous load on core.
  1082.   delay(1);
  1083.   if (digitalRead(PIN_FOOT_SWITCH)) {
  1084.     delay(1);
  1085.     FLAG_SWITCH = true;
  1086.     delay(1);
  1087.   } else {
  1088.     delay(1);
  1089.     FLAG_SWITCH = false;
  1090.     delay(1);
  1091.   }
  1092.   delay(1);
  1093.   if (EFFECTOR_TYPE == 0) {  //delay
  1094.     delay(1);
  1095.     if (!digitalRead(PIN_R_1_5)) DELAY_FEEDBACK = 6;
  1096.     delay(1);
  1097.     if (!digitalRead(PIN_R_1_4)) DELAY_FEEDBACK = 4;
  1098.     delay(1);
  1099.     if (!digitalRead(PIN_R_1_3)) DELAY_FEEDBACK = 2;
  1100.     delay(1);
  1101.     if (!digitalRead(PIN_R_1_2)) DELAY_FEEDBACK = 1;
  1102.     delay(1);
  1103.     if (!digitalRead(PIN_R_1_1)) DELAY_FEEDBACK = 0;
  1104.     delay(1);
  1105.     if (!digitalRead(PIN_R_2_5)) DELAY_TIME = 0x7FFF;  //655ms
  1106.     delay(1);
  1107.     if (!digitalRead(PIN_R_2_4)) DELAY_TIME = 25000;  //500ms
  1108.     delay(1);
  1109.     if (!digitalRead(PIN_R_2_3)) DELAY_TIME = 20000;  //400ms
  1110.     delay(1);
  1111.     if (!digitalRead(PIN_R_2_2)) DELAY_TIME = 15000;  //300ms
  1112.     delay(1);
  1113.     if (!digitalRead(PIN_R_2_1)) DELAY_TIME = 10000;  //200ms
  1114.     delay(1);
  1115.   }
  1116.   delay(1);
  1117.   if (EFFECTOR_TYPE == 1) {  //short delay
  1118.     delay(1);
  1119.     if (!digitalRead(PIN_R_1_5)) DELAY_FEEDBACK = 6;
  1120.     delay(1);
  1121.     if (!digitalRead(PIN_R_1_4)) DELAY_FEEDBACK = 4;
  1122.     delay(1);
  1123.     if (!digitalRead(PIN_R_1_3)) DELAY_FEEDBACK = 2;
  1124.     delay(1);
  1125.     if (!digitalRead(PIN_R_1_2)) DELAY_FEEDBACK = 1;
  1126.     delay(1);
  1127.     if (!digitalRead(PIN_R_1_1)) DELAY_FEEDBACK = 0;
  1128.     delay(1);
  1129.     if (!digitalRead(PIN_R_2_5)) DELAY_TIME = 5000;  //100ms
  1130.     delay(1);
  1131.     if (!digitalRead(PIN_R_2_4)) DELAY_TIME = 4000;  //80ms
  1132.     delay(1);
  1133.     if (!digitalRead(PIN_R_2_3)) DELAY_TIME = 3000;  //60ms
  1134.     delay(1);
  1135.     if (!digitalRead(PIN_R_2_2)) DELAY_TIME = 2000;  //40ms
  1136.     delay(1);
  1137.     if (!digitalRead(PIN_R_2_1)) DELAY_TIME = 1000;  //20ms
  1138.     delay(1);
  1139.   }
  1140.  
  1141.   delay(1);
  1142.   if (EFFECTOR_TYPE == 2) {  //reverb
  1143.     delay(1);
  1144.     if (!digitalRead(PIN_R_1_5)) DELAY_FEEDBACK = 6;
  1145.     delay(1);
  1146.     if (!digitalRead(PIN_R_1_4)) DELAY_FEEDBACK = 4;
  1147.     delay(1);
  1148.     if (!digitalRead(PIN_R_1_3)) DELAY_FEEDBACK = 2;
  1149.     delay(1);
  1150.     if (!digitalRead(PIN_R_1_2)) DELAY_FEEDBACK = 1;
  1151.     delay(1);
  1152.     if (!digitalRead(PIN_R_1_1)) DELAY_FEEDBACK = 0;
  1153.     delay(1);
  1154.     if (!digitalRead(PIN_R_2_5)) {  //large hall
  1155.       delay(1);
  1156.       DELAY_TIME1 = 21500;  //430ms
  1157.       delay(1);
  1158.       DELAY_TIME2 = 22500;  //450ms
  1159.       delay(1);
  1160.       DELAY_TIME3 = 23000;  //460ms
  1161.       delay(1);
  1162.       DELAY_TIME4 = 23600;  //472ms
  1163.       delay(1);
  1164.       DELAY_TIME5 = 32000;  //640ms
  1165.       delay(1);
  1166.     }
  1167.     delay(1);
  1168.     if (!digitalRead(PIN_R_2_4)) {  //hall
  1169.       delay(1);
  1170.       DELAY_TIME1 = 10000;  //200ms
  1171.       delay(1);
  1172.       DELAY_TIME2 = 11500;  //230ms
  1173.       delay(1);
  1174.       DELAY_TIME3 = 15000;  //300ms
  1175.       delay(1);
  1176.       DELAY_TIME4 = 21500;  //430ms
  1177.       delay(1);
  1178.       DELAY_TIME5 = 31000;  //620ms
  1179.       delay(1);
  1180.     }
  1181.     delay(1);
  1182.     if (!digitalRead(PIN_R_2_3)) {  //small hall
  1183.       delay(1);
  1184.       DELAY_TIME1 = 5000;  //100ms
  1185.       delay(1);
  1186.       DELAY_TIME2 = 6500;  //130ms
  1187.       delay(1);
  1188.       DELAY_TIME3 = 7150;  //143ms
  1189.       delay(1);
  1190.       DELAY_TIME4 = 7500;  //150ms
  1191.       delay(1);
  1192.       DELAY_TIME5 = 8100;  //162ms
  1193.       delay(1);
  1194.     }
  1195.     delay(1);
  1196.     if (!digitalRead(PIN_R_2_2)) {  //room
  1197.       delay(1);
  1198.       DELAY_TIME1 = 1500;  //30ms
  1199.       delay(1);
  1200.       DELAY_TIME2 = 2000;  //40ms
  1201.       delay(1);
  1202.       DELAY_TIME3 = 4000;  //80ms
  1203.       delay(1);
  1204.       DELAY_TIME4 = 8000;  //160ms
  1205.       delay(1);
  1206.       DELAY_TIME5 = 16000;  //320ms
  1207.       delay(1);
  1208.     }
  1209.     delay(1);
  1210.     if (!digitalRead(PIN_R_2_1)) {  //small room
  1211.       delay(1);
  1212.       DELAY_TIME1 = 750;  //15ms
  1213.       delay(1);
  1214.       DELAY_TIME2 = 1500;  //30ms
  1215.       delay(1);
  1216.       DELAY_TIME3 = 3000;  //60ms
  1217.       delay(1);
  1218.       DELAY_TIME4 = 6000;  //120ms
  1219.       delay(1);
  1220.       DELAY_TIME5 = 12000;  //240ms
  1221.       delay(1);
  1222.     }
  1223.     delay(1);
  1224.   }
  1225.  
  1226.   if (EFFECTOR_TYPE == 3 || EFFECTOR_TYPE == 4) {  //chorus or dimention C
  1227.     delay(1);
  1228.     //CENTRAL_DELAY_VALUE > DELAY_WIDTH
  1229.     CENTRAL_DELAY_VALUE = 500;  //10(ms)*SAMPLE_RATE/1000=10*50000/1000=500
  1230.     delay(1);
  1231.     DELAY_WIDTH5 = 200;  //=DELAY_WIDTH*SAMPLERATE/1000, 4(ms)*50000/1000
  1232.     delay(1);
  1233.     DELAY_WIDTH4 = 150;  //=DELAY_WIDTH*SAMPLERATE/1000
  1234.     delay(1);
  1235.     DELAY_WIDTH3 = 100;  //=DELAY_WIDTH*SAMPLERATE/1000
  1236.     delay(1);
  1237.     DELAY_WIDTH2 = 80;  //=DELAY_WIDTH*SAMPLERATE/1000
  1238.     delay(1);
  1239.     DELAY_WIDTH1 = 40;  //=DELAY_WIDTH*SAMPLERATE/1000
  1240.  
  1241.     delay(1);
  1242.     FEEDBACK_VALUE = 0;
  1243.     delay(1);
  1244.     if (!digitalRead(PIN_R_1_5)) DELAY_WIDTH_NUMBER1 = 5;
  1245.     delay(1);
  1246.     if (!digitalRead(PIN_R_1_4)) DELAY_WIDTH_NUMBER1 = 4;
  1247.     delay(1);
  1248.     if (!digitalRead(PIN_R_1_3)) DELAY_WIDTH_NUMBER1 = 3;
  1249.     delay(1);
  1250.     if (!digitalRead(PIN_R_1_2)) DELAY_WIDTH_NUMBER1 = 2;
  1251.     delay(1);
  1252.     if (!digitalRead(PIN_R_1_1)) DELAY_WIDTH_NUMBER1 = 1;
  1253.     delay(1);
  1254.  
  1255.  
  1256.     if (!digitalRead(PIN_R_2_5)) VIBRATION_RATE_PARAMETER1 = 13;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/4=13
  1257.     delay(1);
  1258.     if (!digitalRead(PIN_R_2_4)) VIBRATION_RATE_PARAMETER1 = 17;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/3=17
  1259.     delay(1);
  1260.     if (!digitalRead(PIN_R_2_3)) VIBRATION_RATE_PARAMETER1 = 25;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/2=25
  1261.     delay(1);
  1262.     if (!digitalRead(PIN_R_2_2)) VIBRATION_RATE_PARAMETER1 = 50;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/1=50
  1263.     delay(1);
  1264.     if (!digitalRead(PIN_R_2_1)) VIBRATION_RATE_PARAMETER1 = 100;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/0.5=100
  1265.     delay(1);
  1266.   }
  1267.  
  1268.   delay(1);
  1269.   if (EFFECTOR_TYPE == 5) {  //dimention C 2
  1270.     delay(1);
  1271.     //CENTRAL_DELAY_VALUE > DELAY_WIDTH
  1272.     CENTRAL_DELAY_VALUE = 500;  //10(ms)*50000/1000=500
  1273.  
  1274.     delay(1);
  1275.     DELAY_WIDTH5 = 200;  //=DELAY_WIDTH*SAMPLERATE/1000, 4(ms)*50000/1000
  1276.     delay(1);
  1277.     DELAY_WIDTH4 = 150;  //=DELAY_WIDTH*SAMPLERATE/1000
  1278.     delay(1);
  1279.     DELAY_WIDTH3 = 100;  //=DELAY_WIDTH*SAMPLERATE/1000
  1280.     delay(1);
  1281.     DELAY_WIDTH2 = 80;  //=DELAY_WIDTH*SAMPLERATE/1000
  1282.     delay(1);
  1283.     DELAY_WIDTH1 = 40;  //=DELAY_WIDTH*SAMPLERATE/1000
  1284.  
  1285.     delay(1);
  1286.     if (!digitalRead(PIN_R_1_5)) {
  1287.       delay(1);
  1288.       DELAY_WIDTH_NUMBER1 = 3;
  1289.       delay(1);
  1290.       VIBRATION_RATE_PARAMETER1 = 50;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/1=50
  1291.       delay(1);
  1292.       DELAY_WIDTH_NUMBER2 = 3;
  1293.       delay(1);
  1294.       VIBRATION_RATE_PARAMETER2 = 50;  //1Hz
  1295.       delay(1);
  1296.       DELAY_WIDTH_NUMBER3 = 2;
  1297.       delay(1);
  1298.       VIBRATION_RATE_PARAMETER3 = 100;  //0.5Hz
  1299.       delay(1);
  1300.       DELAY_WIDTH_NUMBER4 = 2;
  1301.       delay(1);
  1302.       VIBRATION_RATE_PARAMETER4 = 100;  //0.5Hz
  1303.       delay(1);
  1304.     }
  1305.     delay(1);
  1306.     if (!digitalRead(PIN_R_1_4)) {
  1307.       delay(1);
  1308.       DELAY_WIDTH_NUMBER1 = 1;
  1309.       delay(1);
  1310.       VIBRATION_RATE_PARAMETER1 = 50;  //1Hz
  1311.       delay(1);
  1312.       DELAY_WIDTH_NUMBER2 = 2;
  1313.       delay(1);
  1314.       VIBRATION_RATE_PARAMETER2 = 50;  //1Hz
  1315.       delay(1);
  1316.       DELAY_WIDTH_NUMBER3 = 3;
  1317.       delay(1);
  1318.       VIBRATION_RATE_PARAMETER3 = 50;  //1Hz
  1319.  
  1320.       DELAY_WIDTH_NUMBER4 = 4;
  1321.       delay(1);
  1322.       VIBRATION_RATE_PARAMETER4 = 50;  //1Hz
  1323.       delay(1);
  1324.     }
  1325.     delay(1);
  1326.     if (!digitalRead(PIN_R_1_3)) {
  1327.       delay(1);
  1328.       DELAY_WIDTH_NUMBER1 = 3;
  1329.       delay(1);
  1330.       VIBRATION_RATE_PARAMETER1 = 100;  //0.5Hz
  1331.       delay(1);
  1332.       DELAY_WIDTH_NUMBER2 = 3;
  1333.       delay(1);
  1334.       VIBRATION_RATE_PARAMETER2 = 33;  //1.5Hz
  1335.       delay(1);
  1336.       DELAY_WIDTH_NUMBER3 = 3;
  1337.       delay(1);
  1338.       VIBRATION_RATE_PARAMETER3 = 156;  //0.33Hz
  1339.       delay(1);
  1340.       DELAY_WIDTH_NUMBER4 = 3;
  1341.       delay(1);
  1342.       VIBRATION_RATE_PARAMETER4 = 63;  //0.8Hz
  1343.       delay(1);
  1344.     }
  1345.     delay(1);
  1346.     if (!digitalRead(PIN_R_1_2)) {
  1347.       delay(1);
  1348.       DELAY_WIDTH_NUMBER1 = 1;
  1349.       delay(1);
  1350.       VIBRATION_RATE_PARAMETER1 = 100;  //0.5Hz
  1351.       delay(1);
  1352.       DELAY_WIDTH_NUMBER2 = 2;
  1353.       delay(1);
  1354.       VIBRATION_RATE_PARAMETER2 = 75;  //0.666Hz
  1355.       delay(1);
  1356.       DELAY_WIDTH_NUMBER3 = 3;
  1357.       delay(1);
  1358.       VIBRATION_RATE_PARAMETER3 = 139;  //0.3597Hz
  1359.       delay(1);
  1360.       DELAY_WIDTH_NUMBER4 = 5;
  1361.       delay(1);
  1362.       VIBRATION_RATE_PARAMETER4 = 43;  //1.162Hz
  1363.       delay(1);
  1364.     }
  1365.     delay(1);
  1366.     if (!digitalRead(PIN_R_1_1)) {
  1367.       delay(1);
  1368.       DELAY_WIDTH_NUMBER1 = 1;
  1369.       delay(1);
  1370.       VIBRATION_RATE_PARAMETER1 = 15;  //3.333Hz
  1371.       delay(1);
  1372.       DELAY_WIDTH_NUMBER2 = 5;
  1373.       delay(1);
  1374.       VIBRATION_RATE_PARAMETER2 = 200;  //0.25Hz
  1375.       delay(1);
  1376.       DELAY_WIDTH_NUMBER3 = 3;
  1377.       delay(1);
  1378.       VIBRATION_RATE_PARAMETER3 = 85;  //0.5882Hz
  1379.       delay(1);
  1380.       DELAY_WIDTH_NUMBER4 = 4;
  1381.       delay(1);
  1382.       VIBRATION_RATE_PARAMETER4 = 45;  //1.111Hz
  1383.       delay(1);
  1384.     }
  1385.     delay(1);
  1386.   }
  1387.  
  1388.   delay(1);
  1389.   if (EFFECTOR_TYPE == 6) {  //flanger
  1390.     delay(1);
  1391.     //CENTRAL_DELAY_VALUE > DELAY_WIDTH
  1392.     CENTRAL_DELAY_VALUE = 150;  //3(ms)*SAMPLE_RATE/1000=150
  1393.     delay(1);
  1394.     DELAY_WIDTH1 = 100;  //=DELAY_WIDTH*SAMPLERATE/1000, 2(ms)*50000/1000
  1395.     delay(1);
  1396.     DELAY_WIDTH2 = 100;  //=DELAY_WIDTH*SAMPLERATE/1000
  1397.     delay(1);
  1398.     DELAY_WIDTH3 = 100;  //=DELAY_WIDTH*SAMPLERATE/1000
  1399.     delay(1);
  1400.     DELAY_WIDTH4 = 100;  //=DELAY_WIDTH*SAMPLERATE/1000
  1401.     delay(1);
  1402.     DELAY_WIDTH5 = 100;  //=DELAY_WIDTH*SAMPLERATE/1000
  1403.  
  1404.     delay(1);
  1405.     DELAY_WIDTH_NUMBER1 = 1;
  1406.  
  1407.     delay(1);
  1408.     if (!digitalRead(PIN_R_1_5)) FEEDBACK_VALUE = 31;
  1409.     delay(1);
  1410.     if (!digitalRead(PIN_R_1_4)) FEEDBACK_VALUE = 30;
  1411.     delay(1);
  1412.     if (!digitalRead(PIN_R_1_3)) FEEDBACK_VALUE = 29;
  1413.     delay(1);
  1414.     if (!digitalRead(PIN_R_1_2)) FEEDBACK_VALUE = 28;
  1415.     delay(1);
  1416.     if (!digitalRead(PIN_R_1_1)) FEEDBACK_VALUE = 27;
  1417.     delay(1);
  1418.  
  1419.  
  1420.     delay(1);
  1421.     if (!digitalRead(PIN_R_2_5)) VIBRATION_RATE_PARAMETER1 = 25;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/2=25
  1422.     delay(1);
  1423.     if (!digitalRead(PIN_R_2_4)) VIBRATION_RATE_PARAMETER1 = 50;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/1=50
  1424.     delay(1);
  1425.     if (!digitalRead(PIN_R_2_3)) VIBRATION_RATE_PARAMETER1 = 71;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/0.7=71
  1426.     delay(1);
  1427.     if (!digitalRead(PIN_R_2_2)) VIBRATION_RATE_PARAMETER1 = 100;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/0.5=100
  1428.     delay(1);
  1429.     if (!digitalRead(PIN_R_2_1)) VIBRATION_RATE_PARAMETER1 = 167;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/0.3=167
  1430.     delay(1);
  1431.   }  //flanger ^^^^^^^^^^^^^^^^^^^^^^
  1432.  
  1433.  
  1434.  
  1435.  
  1436.   delay(1);
  1437.   if (EFFECTOR_TYPE == 7) {  //dimention C 2 + delay
  1438.     delay(1);
  1439.     //CENTRAL_DELAY_VALUE > DELAY_WIDTH
  1440.     CENTRAL_DELAY_VALUE = 500;  //10(ms)*50000/1000=500
  1441.  
  1442.     delay(1);
  1443.     DELAY_WIDTH5 = 200;  //=DELAY_WIDTH*SAMPLERATE/1000, 4(ms)*50000/1000
  1444.     delay(1);
  1445.     DELAY_WIDTH4 = 150;  //=DELAY_WIDTH*SAMPLERATE/1000, 3ms
  1446.     delay(1);
  1447.     DELAY_WIDTH3 = 100;  //=DELAY_WIDTH*SAMPLERATE/1000, 2ms
  1448.     delay(1);
  1449.     DELAY_WIDTH2 = 80;  //=DELAY_WIDTH*SAMPLERATE/1000, 1.6ms
  1450.     delay(1);
  1451.     DELAY_WIDTH1 = 40;  //=DELAY_WIDTH*SAMPLERATE/1000, 0.8ms
  1452.  
  1453.     delay(1);
  1454.     if (!digitalRead(PIN_R_1_5)) {
  1455.       delay(1);
  1456.       DELAY_WIDTH_NUMBER1 = 3;
  1457.       delay(1);
  1458.       VIBRATION_RATE_PARAMETER1 = 50;  //SAMPLE_RATE/SAMPLE_RANGE/frequency=50000/1000/1=50
  1459.       delay(1);
  1460.       DELAY_WIDTH_NUMBER2 = 3;
  1461.       delay(1);
  1462.       VIBRATION_RATE_PARAMETER2 = 50;  //1Hz
  1463.       delay(1);
  1464.       DELAY_WIDTH_NUMBER3 = 2;
  1465.       delay(1);
  1466.       VIBRATION_RATE_PARAMETER3 = 100;  //0.5Hz
  1467.       delay(1);
  1468.       DELAY_WIDTH_NUMBER4 = 2;
  1469.       delay(1);
  1470.       VIBRATION_RATE_PARAMETER4 = 100;  //0.5Hz
  1471.       delay(1);
  1472.     }
  1473.     delay(1);
  1474.     if (!digitalRead(PIN_R_1_4)) {
  1475.       delay(1);
  1476.       DELAY_WIDTH_NUMBER1 = 1;
  1477.       delay(1);
  1478.       VIBRATION_RATE_PARAMETER1 = 50;  //1Hz
  1479.       delay(1);
  1480.       DELAY_WIDTH_NUMBER2 = 2;
  1481.       delay(1);
  1482.       VIBRATION_RATE_PARAMETER2 = 50;
  1483.       delay(1);
  1484.       DELAY_WIDTH_NUMBER3 = 3;
  1485.       delay(1);
  1486.       VIBRATION_RATE_PARAMETER3 = 50;
  1487.  
  1488.       DELAY_WIDTH_NUMBER4 = 4;
  1489.       delay(1);
  1490.       VIBRATION_RATE_PARAMETER4 = 50;
  1491.       delay(1);
  1492.     }
  1493.     delay(1);
  1494.     if (!digitalRead(PIN_R_1_3)) {
  1495.       delay(1);
  1496.       DELAY_WIDTH_NUMBER1 = 3;
  1497.       delay(1);
  1498.       VIBRATION_RATE_PARAMETER1 = 100;  //0.5Hz
  1499.       delay(1);
  1500.       DELAY_WIDTH_NUMBER2 = 3;
  1501.       delay(1);
  1502.       VIBRATION_RATE_PARAMETER2 = 33;  //1.5Hz
  1503.       delay(1);
  1504.       DELAY_WIDTH_NUMBER3 = 3;
  1505.       delay(1);
  1506.       VIBRATION_RATE_PARAMETER3 = 156;  //0.33Hz
  1507.       delay(1);
  1508.       DELAY_WIDTH_NUMBER4 = 3;
  1509.       delay(1);
  1510.       VIBRATION_RATE_PARAMETER4 = 63;  //0.8Hz
  1511.       delay(1);
  1512.     }
  1513.     delay(1);
  1514.     if (!digitalRead(PIN_R_1_2)) {
  1515.       delay(1);
  1516.       DELAY_WIDTH_NUMBER1 = 1;
  1517.       delay(1);
  1518.       VIBRATION_RATE_PARAMETER1 = 100;  //0.5Hz
  1519.       delay(1);
  1520.       DELAY_WIDTH_NUMBER2 = 2;
  1521.       delay(1);
  1522.       VIBRATION_RATE_PARAMETER2 = 75;  //0.6666Hz
  1523.       delay(1);
  1524.       DELAY_WIDTH_NUMBER3 = 3;
  1525.       delay(1);
  1526.       VIBRATION_RATE_PARAMETER3 = 139;  //0.3597Hz
  1527.       delay(1);
  1528.       DELAY_WIDTH_NUMBER4 = 5;
  1529.       delay(1);
  1530.       VIBRATION_RATE_PARAMETER4 = 43;  //1.16Hz
  1531.       delay(1);
  1532.     }
  1533.     delay(1);
  1534.     if (!digitalRead(PIN_R_1_1)) {
  1535.       delay(1);
  1536.       DELAY_WIDTH_NUMBER1 = 1;
  1537.       delay(1);
  1538.       VIBRATION_RATE_PARAMETER1 = 15;  //3.333Hz
  1539.       delay(1);
  1540.       DELAY_WIDTH_NUMBER2 = 5;
  1541.       delay(1);
  1542.       VIBRATION_RATE_PARAMETER2 = 200;  //0.25Hz
  1543.       delay(1);
  1544.       DELAY_WIDTH_NUMBER3 = 3;
  1545.       delay(1);
  1546.       VIBRATION_RATE_PARAMETER3 = 85;  //0.588Hz
  1547.       delay(1);
  1548.       DELAY_WIDTH_NUMBER4 = 4;
  1549.       delay(1);
  1550.       VIBRATION_RATE_PARAMETER4 = 45;  //1.111Hz
  1551.       delay(1);
  1552.     }
  1553.     delay(1);  //DELAY_TIMEは0x7FFFでも一発入るので
  1554.  
  1555.     if (!digitalRead(PIN_R_2_5)) DELAY_TIME = 25000;  //500ms
  1556.     delay(1);
  1557.     if (!digitalRead(PIN_R_2_4)) DELAY_TIME = 22500;  //450ms
  1558.     delay(1);
  1559.     if (!digitalRead(PIN_R_2_3)) DELAY_TIME = 20000;  //400ms
  1560.     delay(1);
  1561.     if (!digitalRead(PIN_R_2_2)) DELAY_TIME = 15000;  //300ms
  1562.     delay(1);
  1563.     if (!digitalRead(PIN_R_2_1)) DELAY_TIME = 10000;  //200ms
  1564.     delay(1);
  1565.   }
  1566.  
  1567.  
  1568.  
  1569.   delay(1);
  1570.   if (EFFECTOR_TYPE == 9) {  //limitter with delay
  1571.  
  1572.     //right rotary switch : limitation threshold
  1573.     //left rotary switch : limitation rate
  1574.     delay(1);
  1575.     if (!digitalRead(PIN_R_1_5)) LIMIT_RATE = 32;
  1576.     delay(1);
  1577.     if (!digitalRead(PIN_R_1_4)) LIMIT_RATE = 16;
  1578.     delay(1);
  1579.     if (!digitalRead(PIN_R_1_3)) LIMIT_RATE = 8;
  1580.     delay(1);
  1581.     if (!digitalRead(PIN_R_1_2)) LIMIT_RATE = 4;
  1582.     delay(1);
  1583.     if (!digitalRead(PIN_R_1_1)) LIMIT_RATE = 2;
  1584.     delay(1);
  1585.     if (!digitalRead(PIN_R_2_5)) LIMIT_TH = 0x3000;
  1586.     delay(1);
  1587.     if (!digitalRead(PIN_R_2_4)) LIMIT_TH = 0x4000;
  1588.     delay(1);
  1589.     if (!digitalRead(PIN_R_2_3)) LIMIT_TH = 0x5000;
  1590.     delay(1);
  1591.     if (!digitalRead(PIN_R_2_2)) LIMIT_TH = 0x6000;
  1592.     delay(1);
  1593.     if (!digitalRead(PIN_R_2_1)) LIMIT_TH = 0x7000;
  1594.     delay(1);
  1595.   }
  1596.  
  1597.   delay(1);
  1598.   if (EFFECTOR_TYPE == 0xA || EFFECTOR_TYPE == 0xB || EFFECTOR_TYPE == 0xC || EFFECTOR_TYPE == 0xD) {  //over drive with delay or distortion with delay
  1599.     delay(1);
  1600.     //OVER_DRIVE_LEVEL=1, 2, 4, 8, 16, 32, 64,...,2^N  N:natural number
  1601.     if (!digitalRead(PIN_R_1_5)) OVER_DRIVE_LEVEL = 4;  // 1/4
  1602.     delay(1);
  1603.     if (!digitalRead(PIN_R_1_4)) OVER_DRIVE_LEVEL = 8;  // 1/8
  1604.     delay(1);
  1605.     if (!digitalRead(PIN_R_1_3)) OVER_DRIVE_LEVEL = 16;  // 1/16
  1606.     delay(1);
  1607.     if (!digitalRead(PIN_R_1_2)) OVER_DRIVE_LEVEL = 32;  // 1/32
  1608.     delay(1);
  1609.     if (!digitalRead(PIN_R_1_1)) OVER_DRIVE_LEVEL = 64;  // 1/64
  1610.     delay(1);
  1611.     //OVER_DRIVE_GAIN=1, 2, 4, 8, 16, 32, 64,...,2^N  N:natural number
  1612.     if (!digitalRead(PIN_R_2_5)) OVER_DRIVE_GAIN = 256;
  1613.     delay(1);
  1614.     if (!digitalRead(PIN_R_2_4)) OVER_DRIVE_GAIN = 128;
  1615.     delay(1);
  1616.     if (!digitalRead(PIN_R_2_3)) OVER_DRIVE_GAIN = 64;
  1617.     delay(1);
  1618.     if (!digitalRead(PIN_R_2_2)) OVER_DRIVE_GAIN = 32;
  1619.     delay(1);
  1620.     if (!digitalRead(PIN_R_2_1)) OVER_DRIVE_GAIN = 16;
  1621.     delay(1);
  1622.   }
  1623.  
  1624.  
  1625.   delay(1);
  1626.   if (EFFECTOR_TYPE == 0xE) {  //NOISE GATE
  1627.     delay(1);
  1628.     if (!digitalRead(PIN_R_1_5)) NOISE_GATE_DECAY_SPEED = 1;
  1629.     delay(1);
  1630.     if (!digitalRead(PIN_R_1_4)) NOISE_GATE_DECAY_SPEED = 2;
  1631.     delay(1);
  1632.     if (!digitalRead(PIN_R_1_3)) NOISE_GATE_DECAY_SPEED = 3;
  1633.     delay(1);
  1634.     if (!digitalRead(PIN_R_1_2)) NOISE_GATE_DECAY_SPEED = 4;
  1635.     delay(1);
  1636.     if (!digitalRead(PIN_R_1_1)) NOISE_GATE_DECAY_SPEED = 5;
  1637.     //
  1638.     delay(1);
  1639.     if (!digitalRead(PIN_R_2_5)) NOISE_GATE_THRESHOLD = 2000;
  1640.     delay(1);
  1641.     if (!digitalRead(PIN_R_2_4)) NOISE_GATE_THRESHOLD = 1500;
  1642.     delay(1);
  1643.     if (!digitalRead(PIN_R_2_3)) NOISE_GATE_THRESHOLD = 1000;
  1644.     delay(1);
  1645.     if (!digitalRead(PIN_R_2_2)) NOISE_GATE_THRESHOLD = 750;
  1646.     delay(1);
  1647.     if (!digitalRead(PIN_R_2_1)) NOISE_GATE_THRESHOLD = 500;
  1648.   }
  1649.  
  1650.  
  1651.  
  1652.   delay(1);
  1653.   if (EFFECTOR_TYPE == 0xF) {  //ETC
  1654.     delay(1);
  1655.     uint16_t A = 0;
  1656.     delay(1);
  1657.     uint16_t B = 0;
  1658.     delay(1);
  1659.     if (!digitalRead(PIN_R_1_5)) A = 40;
  1660.     delay(1);
  1661.     if (!digitalRead(PIN_R_1_4)) A = 30;
  1662.     delay(1);
  1663.     if (!digitalRead(PIN_R_1_3)) A = 20;
  1664.     delay(1);
  1665.     if (!digitalRead(PIN_R_1_2)) A = 10;
  1666.     delay(1);
  1667.     if (!digitalRead(PIN_R_1_1)) A = 0;
  1668.     delay(1);
  1669.  
  1670.     if (!digitalRead(PIN_R_2_5)) B = 4;
  1671.     delay(1);
  1672.     if (!digitalRead(PIN_R_2_4)) B = 3;
  1673.     delay(1);
  1674.     if (!digitalRead(PIN_R_2_3)) B = 2;
  1675.     delay(1);
  1676.     if (!digitalRead(PIN_R_2_2)) B = 1;
  1677.     delay(1);
  1678.     if (!digitalRead(PIN_R_2_1)) B = 0;
  1679.     delay(1);
  1680.     ETC = A + B;
  1681.     delay(1);
  1682.   }
  1683.  
  1684.  
  1685.   delay(1);
  1686.   FLAG_SetUpHasBeenCompleted = true;
  1687.   delay(1);
  1688.   uint16_t EFFECTOR_TYPE2 = 0;
  1689.   delay(1);
  1690.   if (!digitalRead(PIN_EFFECTOR_TYPE_1)) EFFECTOR_TYPE2 = 1;
  1691.   delay(1);
  1692.   if (!digitalRead(PIN_EFFECTOR_TYPE_2)) EFFECTOR_TYPE2 += 2;
  1693.   delay(1);
  1694.   if (!digitalRead(PIN_EFFECTOR_TYPE_4)) EFFECTOR_TYPE2 += 4;
  1695.   delay(1);
  1696.   if (!digitalRead(PIN_EFFECTOR_TYPE_8)) EFFECTOR_TYPE2 += 8;
  1697.   delay(1);
  1698.   if (EFFECTOR_TYPE != EFFECTOR_TYPE2) {  //Has effector type changed?
  1699.     delay(1);
  1700.     if (Serial) Serial.println("Reboot!");
  1701.     delay(1000);
  1702.     rp2040.reboot();  //reboot raspberry pi pico
  1703.   }
  1704.   delay(100);
  1705. }
  1706.  
  1707. void setup_output(void) {
  1708.   i2s_output.setBCLK(PIN_I2S_OUTPUT_BCLK);
  1709.   i2s_output.setDATA(PIN_I2S_DOUT);
  1710.   i2s_output.setBitsPerSample(32);  //number of bits per channel
  1711.   i2s_output.setBuffers(NUMBER_OF_BUFFERS_OUTPUT, SIZE_OF_BUFFER_OUTPUT, 0);
  1712. }
  1713.  
  1714. void setup_input(void) {
  1715.   analogReadResolution(12);  // ADCのフルスケールを12ビットに設定
  1716.   adc_input.setBuffers(NUMBER_OF_BUFFERS_INPUT, SIZE_OF_BUFFER_INPUT);
  1717. }
  1718. /*修正点
  1719. VERSION 01.000.01(2023.12.02)
  1720. line319
  1721. DELAY_BUFFER_VALUE += (0 - INPUT_VALUE / 4);=>DELAY_BUFFER_VALUE -=INPUT_VALUE / 8;
  1722. 入力信号が大きい場合に歪むことがあったので
  1723. */

「小型マイコンを使ったデジタル・エフェクターの制作例」に戻る

「エフェクターの制作例」に戻る

「ホーム」に戻る