quantum/audio/audio_arm.c

   1 /* Copyright 2016 Jack Humbert
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 #include "audio.h"
  18 #include "ch.h"
  19 #include "hal.h"
  20
  21 #include <string.h>
  22 #include "print.h"
  23 #include "keymap.h"
  24
  25 #include "eeconfig.h"
  26
  27 // -----------------------------------------------------------------------------
  28
  29 int voices = 0;
  30 int voice_place = 0;
  31 float frequency = 0;
  32 float frequency_alt = 0;
  33 int volume = 0;
  34 long position = 0;
  35
  36 float frequencies[8] = {0, 0, 0, 0, 0, 0, 0, 0};
  37 int volumes[8] = {0, 0, 0, 0, 0, 0, 0, 0};
  38 bool sliding = false;
  39
  40 float place = 0;
  41
  42 uint8_t * sample;
  43 uint16_t sample_length = 0;
  44
  45 bool     playing_notes = false;
  46 bool     playing_note = false;
  47 float    note_frequency = 0;
  48 float    note_length = 0;
  49 uint8_t  note_tempo = TEMPO_DEFAULT;
  50 float    note_timbre = TIMBRE_DEFAULT;
  51 uint16_t note_position = 0;
  52 float (* notes_pointer)[][2];
  53 uint16_t notes_count;
  54 bool     notes_repeat;
  55 bool     note_resting = false;
  56
  57 uint8_t current_note = 0;
  58 uint8_t rest_counter = 0;
  59
  60 #ifdef VIBRATO_ENABLE
  61 float vibrato_counter = 0;
  62 float vibrato_strength = .5;
  63 float vibrato_rate = 0.125;
  64 #endif
  65
  66 float polyphony_rate = 0;
  67
  68 static bool audio_initialized = false;
  69
  70 audio_config_t audio_config;
  71
  72 uint16_t envelope_index = 0;
  73 bool glissando = true;
  74
  75 #ifndef STARTUP_SONG
  76     #define STARTUP_SONG SONG(STARTUP_SOUND)
  77 #endif
  78 float startup_song[][2] = STARTUP_SONG;
  79
  80 static void gpt_cb8(GPTDriver *gptp);
  81
  82 #define DAC_BUFFER_SIZE 720
  83
  84 #define START_CHANNEL_1() gptStart(&GPTD6, &gpt6cfg1); \
  85     gptStartContinuous(&GPTD6, 2U)
  86 #define START_CHANNEL_2() gptStart(&GPTD7, &gpt7cfg1); \
  87     gptStartContinuous(&GPTD7, 2U)
  88 #define STOP_CHANNEL_1() gptStopTimer(&GPTD6)
  89 #define STOP_CHANNEL_2() gptStopTimer(&GPTD7)
  90 #define RESTART_CHANNEL_1() STOP_CHANNEL_1(); \
  91     START_CHANNEL_1()
  92 #define RESTART_CHANNEL_2() STOP_CHANNEL_2(); \
  93     START_CHANNEL_2()
  94 #define UPDATE_CHANNEL_1_FREQ(freq) gpt6cfg1.frequency = freq * DAC_BUFFER_SIZE; \
  95     RESTART_CHANNEL_1()
  96 #define UPDATE_CHANNEL_2_FREQ(freq) gpt7cfg1.frequency = freq * DAC_BUFFER_SIZE; \
  97     RESTART_CHANNEL_2()
  98 #define GET_CHANNEL_1_FREQ gpt6cfg1.frequency
  99 #define GET_CHANNEL_2_FREQ gpt7cfg1.frequency
 100
 101
 102 /*
 103  * GPT6 configuration.
 104  */
 105 // static const GPTConfig gpt6cfg1 = {
 106 //   .frequency    = 1000000U,
 107 //   .callback     = NULL,
 108 //   .cr2          = TIM_CR2_MMS_1,    /* MMS = 010 = TRGO on Update Event.    */
 109 //   .dier         = 0U
 110 // };
 111
 112 GPTConfig gpt6cfg1 = {
 113   .frequency    = 440U*DAC_BUFFER_SIZE,
 114   .callback     = NULL,
 115   .cr2          = TIM_CR2_MMS_1,    /* MMS = 010 = TRGO on Update Event.    */
 116   .dier         = 0U
 117 };
 118
 119 GPTConfig gpt7cfg1 = {
 120   .frequency    = 440U*DAC_BUFFER_SIZE,
 121   .callback     = NULL,
 122   .cr2          = TIM_CR2_MMS_1,    /* MMS = 010 = TRGO on Update Event.    */
 123   .dier         = 0U
 124 };
 125
 126 GPTConfig gpt8cfg1 = {
 127   .frequency    = 10,
 128   .callback     = gpt_cb8,
 129   .cr2          = TIM_CR2_MMS_1,    /* MMS = 010 = TRGO on Update Event.    */
 130   .dier         = 0U
 131 };
 132
 133
 134 /*
 135  * DAC test buffer (sine wave).
 136  */
 137 // static const dacsample_t dac_buffer[DAC_BUFFER_SIZE] = {
 138 //   2047, 2082, 2118, 2154, 2189, 2225, 2260, 2296, 2331, 2367, 2402, 2437,
 139 //   2472, 2507, 2542, 2576, 2611, 2645, 2679, 2713, 2747, 2780, 2813, 2846,
 140 //   2879, 2912, 2944, 2976, 3008, 3039, 3070, 3101, 3131, 3161, 3191, 3221,
 141 //   3250, 3278, 3307, 3335, 3362, 3389, 3416, 3443, 3468, 3494, 3519, 3544,
 142 //   3568, 3591, 3615, 3637, 3660, 3681, 3703, 3723, 3744, 3763, 3782, 3801,
 143 //   3819, 3837, 3854, 3870, 3886, 3902, 3917, 3931, 3944, 3958, 3970, 3982,
 144 //   3993, 4004, 4014, 4024, 4033, 4041, 4049, 4056, 4062, 4068, 4074, 4078,
 145 //   4082, 4086, 4089, 4091, 4092, 4093, 4094, 4093, 4092, 4091, 4089, 4086,
 146 //   4082, 4078, 4074, 4068, 4062, 4056, 4049, 4041, 4033, 4024, 4014, 4004,
 147 //   3993, 3982, 3970, 3958, 3944, 3931, 3917, 3902, 3886, 3870, 3854, 3837,
 148 //   3819, 3801, 3782, 3763, 3744, 3723, 3703, 3681, 3660, 3637, 3615, 3591,
 149 //   3568, 3544, 3519, 3494, 3468, 3443, 3416, 3389, 3362, 3335, 3307, 3278,
 150 //   3250, 3221, 3191, 3161, 3131, 3101, 3070, 3039, 3008, 2976, 2944, 2912,
 151 //   2879, 2846, 2813, 2780, 2747, 2713, 2679, 2645, 2611, 2576, 2542, 2507,
 152 //   2472, 2437, 2402, 2367, 2331, 2296, 2260, 2225, 2189, 2154, 2118, 2082,
 153 //   2047, 2012, 1976, 1940, 1905, 1869, 1834, 1798, 1763, 1727, 1692, 1657,
 154 //   1622, 1587, 1552, 1518, 1483, 1449, 1415, 1381, 1347, 1314, 1281, 1248,
 155 //   1215, 1182, 1150, 1118, 1086, 1055, 1024,  993,  963,  933,  903,  873,
 156 //    844,  816,  787,  759,  732,  705,  678,  651,  626,  600,  575,  550,
 157 //    526,  503,  479,  457,  434,  413,  391,  371,  350,  331,  312,  293,
 158 //    275,  257,  240,  224,  208,  192,  177,  163,  150,  136,  124,  112,
 159 //    101,   90,   80,   70,   61,   53,   45,   38,   32,   26,   20,   16,
 160 //     12,    8,    5,    3,    2,    1,    0,    1,    2,    3,    5,    8,
 161 //     12,   16,   20,   26,   32,   38,   45,   53,   61,   70,   80,   90,
 162 //    101,  112,  124,  136,  150,  163,  177,  192,  208,  224,  240,  257,
 163 //    275,  293,  312,  331,  350,  371,  391,  413,  434,  457,  479,  503,
 164 //    526,  550,  575,  600,  626,  651,  678,  705,  732,  759,  787,  816,
 165 //    844,  873,  903,  933,  963,  993, 1024, 1055, 1086, 1118, 1150, 1182,
 166 //   1215, 1248, 1281, 1314, 1347, 1381, 1415, 1449, 1483, 1518, 1552, 1587,
 167 //   1622, 1657, 1692, 1727, 1763, 1798, 1834, 1869, 1905, 1940, 1976, 2012
 168 // };
 169
 170 // static const dacsample_t dac_buffer_2[DAC_BUFFER_SIZE] = {
 171 //     12,    8,    5,    3,    2,    1,    0,    1,    2,    3,    5,    8,
 172 //     12,   16,   20,   26,   32,   38,   45,   53,   61,   70,   80,   90,
 173 //    101,  112,  124,  136,  150,  163,  177,  192,  208,  224,  240,  257,
 174 //    275,  293,  312,  331,  350,  371,  391,  413,  434,  457,  479,  503,
 175 //    526,  550,  575,  600,  626,  651,  678,  705,  732,  759,  787,  816,
 176 //    844,  873,  903,  933,  963,  993, 1024, 1055, 1086, 1118, 1150, 1182,
 177 //   1215, 1248, 1281, 1314, 1347, 1381, 1415, 1449, 1483, 1518, 1552, 1587,
 178 //   1622, 1657, 1692, 1727, 1763, 1798, 1834, 1869, 1905, 1940, 1976, 2012,
 179 //   2047, 2082, 2118, 2154, 2189, 2225, 2260, 2296, 2331, 2367, 2402, 2437,
 180 //   2472, 2507, 2542, 2576, 2611, 2645, 2679, 2713, 2747, 2780, 2813, 2846,
 181 //   2879, 2912, 2944, 2976, 3008, 3039, 3070, 3101, 3131, 3161, 3191, 3221,
 182 //   3250, 3278, 3307, 3335, 3362, 3389, 3416, 3443, 3468, 3494, 3519, 3544,
 183 //   3568, 3591, 3615, 3637, 3660, 3681, 3703, 3723, 3744, 3763, 3782, 3801,
 184 //   3819, 3837, 3854, 3870, 3886, 3902, 3917, 3931, 3944, 3958, 3970, 3982,
 185 //   3993, 4004, 4014, 4024, 4033, 4041, 4049, 4056, 4062, 4068, 4074, 4078,
 186 //   4082, 4086, 4089, 4091, 4092, 4093, 4094, 4093, 4092, 4091, 4089, 4086,
 187 //   4082, 4078, 4074, 4068, 4062, 4056, 4049, 4041, 4033, 4024, 4014, 4004,
 188 //   3993, 3982, 3970, 3958, 3944, 3931, 3917, 3902, 3886, 3870, 3854, 3837,
 189 //   3819, 3801, 3782, 3763, 3744, 3723, 3703, 3681, 3660, 3637, 3615, 3591,
 190 //   3568, 3544, 3519, 3494, 3468, 3443, 3416, 3389, 3362, 3335, 3307, 3278,
 191 //   3250, 3221, 3191, 3161, 3131, 3101, 3070, 3039, 3008, 2976, 2944, 2912,
 192 //   2879, 2846, 2813, 2780, 2747, 2713, 2679, 2645, 2611, 2576, 2542, 2507,
 193 //   2472, 2437, 2402, 2367, 2331, 2296, 2260, 2225, 2189, 2154, 2118, 2082,
 194 //   2047, 2012, 1976, 1940, 1905, 1869, 1834, 1798, 1763, 1727, 1692, 1657,
 195 //   1622, 1587, 1552, 1518, 1483, 1449, 1415, 1381, 1347, 1314, 1281, 1248,
 196 //   1215, 1182, 1150, 1118, 1086, 1055, 1024,  993,  963,  933,  903,  873,
 197 //    844,  816,  787,  759,  732,  705,  678,  651,  626,  600,  575,  550,
 198 //    526,  503,  479,  457,  434,  413,  391,  371,  350,  331,  312,  293,
 199 //    275,  257,  240,  224,  208,  192,  177,  163,  150,  136,  124,  112,
 200 //    101,   90,   80,   70,   61,   53,   45,   38,   32,   26,   20,   16
 201 // };
 202
 203 // squarewave
 204 static const dacsample_t dac_buffer[DAC_BUFFER_SIZE] = {
 205   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 206   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 207   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 208   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 209   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 210   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 211   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 212   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 213   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 214   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 215   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 216   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 217   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 218   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 219   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 220   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 221   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 222   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 223   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 224   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 225   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 226   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 227   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 228   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 229   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 230   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 231   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 232   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 233   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 234   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 235
 236   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 237   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 238   0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,
 239    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 240    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 241    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 242    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 243     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 244     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 245    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 246    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 247    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 248    0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,
 249   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 250   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 251   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 252   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 253   0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,
 254    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 255    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 256    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 257    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 258     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 259     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 260    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 261    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 262    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 263    0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,
 264   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 265   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 266 };
 267
 268 // squarewave
 269 static const dacsample_t dac_buffer_2[DAC_BUFFER_SIZE] = {
 270
 271   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 272   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 273   0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,
 274    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 275    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 276    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 277    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 278     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 279     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 280    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 281    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 282    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 283    0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,
 284   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 285   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 286   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 287   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 288   0, 0, 0, 0, 0, 0, 0,  0,  0,  0,  0,  0,
 289    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 290    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 291    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 292    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 293     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 294     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 295    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 296    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 297    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 298    0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, 0,
 299   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 300   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 301   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 302   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 303   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 304   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 305   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 306   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 307   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 308   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 309   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 310   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 311   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 312   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 313   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 314   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 315   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 316   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 317   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 318   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 319   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 320   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 321   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 322   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 323   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 324   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 325   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 326   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 327   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 328   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 329   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047,
 330   2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047, 2047
 331 };
 332
 333 /*
 334  * DAC streaming callback.
 335  */
 336 size_t nx = 0, ny = 0, nz = 0;
 337 static void end_cb1(DACDriver *dacp, dacsample_t *buffer, size_t n) {
 338
 339   (void)dacp;
 340
 341   nz++;
 342   if (dac_buffer == buffer) {
 343     nx += n;
 344   }
 345   else {
 346     ny += n;
 347   }
 348
 349   if ((nz % 1000) == 0) {
 350     // palTogglePad(GPIOD, GPIOD_LED3);
 351   }
 352 }
 353
 354 /*
 355  * DAC error callback.
 356  */
 357 static void error_cb1(DACDriver *dacp, dacerror_t err) {
 358
 359   (void)dacp;
 360   (void)err;
 361
 362   chSysHalt("DAC failure");
 363 }
 364
 365 static const DACConfig dac1cfg1 = {
 366   .init         = 2047U,
 367   .datamode     = DAC_DHRM_12BIT_RIGHT
 368 };
 369
 370 static const DACConversionGroup dacgrpcfg1 = {
 371   .num_channels = 1U,
 372   .end_cb       = end_cb1,
 373   .error_cb     = error_cb1,
 374   .trigger      = DAC_TRG(0)
 375 };
 376
 377 static const DACConfig dac1cfg2 = {
 378   .init         = 2047U,
 379   .datamode     = DAC_DHRM_12BIT_RIGHT
 380 };
 381
 382 static const DACConversionGroup dacgrpcfg2 = {
 383   .num_channels = 1U,
 384   .end_cb       = end_cb1,
 385   .error_cb     = error_cb1,
 386   .trigger      = DAC_TRG(0)
 387 };
 388
 389 void audio_init()
 390 {
 391
 392     if (audio_initialized)
 393         return;
 394
 395     // Check EEPROM
 396     // if (!eeconfig_is_enabled())
 397     // {
 398     //     eeconfig_init();
 399     // }
 400     // audio_config.raw = eeconfig_read_audio();
 401     audio_config.enable = true;
 402
 403   /*
 404    * Starting DAC1 driver, setting up the output pin as analog as suggested
 405    * by the Reference Manual.
 406    */
 407   palSetPadMode(GPIOA, 4, PAL_MODE_INPUT_ANALOG);
 408   palSetPadMode(GPIOA, 5, PAL_MODE_INPUT_ANALOG);
 409   dacStart(&DACD1, &dac1cfg1);
 410   dacStart(&DACD2, &dac1cfg2);
 411
 412   /*
 413    * Starting GPT6/7 driver, it is used for triggering the DAC.
 414    */
 415   START_CHANNEL_1();
 416   START_CHANNEL_2();
 417
 418   /*
 419    * Starting a continuous conversion.
 420    */
 421   dacStartConversion(&DACD1, &dacgrpcfg1, (dacsample_t *)dac_buffer, DAC_BUFFER_SIZE);
 422   dacStartConversion(&DACD2, &dacgrpcfg2, (dacsample_t *)dac_buffer_2, DAC_BUFFER_SIZE);
 423
 424     audio_initialized = true;
 425
 426     if (audio_config.enable) {
 427         PLAY_SONG(startup_song);
 428     }
 429
 430 }
 431
 432 void stop_all_notes()
 433 {
 434     dprintf("audio stop all notes");
 435
 436     if (!audio_initialized) {
 437         audio_init();
 438     }
 439     voices = 0;
 440
 441     gptStopTimer(&GPTD6);
 442     gptStopTimer(&GPTD7);
 443     gptStopTimer(&GPTD8);
 444
 445     playing_notes = false;
 446     playing_note = false;
 447     frequency = 0;
 448     frequency_alt = 0;
 449     volume = 0;
 450
 451     for (uint8_t i = 0; i < 8; i++)
 452     {
 453         frequencies[i] = 0;
 454         volumes[i] = 0;
 455     }
 456 }
 457
 458 void stop_note(float freq)
 459 {
 460     dprintf("audio stop note freq=%d", (int)freq);
 461
 462     if (playing_note) {
 463         if (!audio_initialized) {
 464             audio_init();
 465         }
 466         for (int i = 7; i >= 0; i--) {
 467             if (frequencies[i] == freq) {
 468                 frequencies[i] = 0;
 469                 volumes[i] = 0;
 470                 for (int j = i; (j < 7); j++) {
 471                     frequencies[j] = frequencies[j+1];
 472                     frequencies[j+1] = 0;
 473                     volumes[j] = volumes[j+1];
 474                     volumes[j+1] = 0;
 475                 }
 476                 break;
 477             }
 478         }
 479         voices--;
 480         if (voices < 0)
 481             voices = 0;
 482         if (voice_place >= voices) {
 483             voice_place = 0;
 484         }
 485         if (voices == 0) {
 486             STOP_CHANNEL_1();
 487             STOP_CHANNEL_2();
 488             gptStopTimer(&GPTD8);
 489             frequency = 0;
 490             frequency_alt = 0;
 491             volume = 0;
 492             playing_note = false;
 493         }
 494     }
 495 }
 496
 497 #ifdef VIBRATO_ENABLE
 498
 499 float mod(float a, int b)
 500 {
 501     float r = fmod(a, b);
 502     return r < 0 ? r + b : r;
 503 }
 504
 505 float vibrato(float average_freq) {
 506     #ifdef VIBRATO_STRENGTH_ENABLE
 507         float vibrated_freq = average_freq * pow(vibrato_lut[(int)vibrato_counter], vibrato_strength);
 508     #else
 509         float vibrated_freq = average_freq * vibrato_lut[(int)vibrato_counter];
 510     #endif
 511     vibrato_counter = mod((vibrato_counter + vibrato_rate * (1.0 + 440.0/average_freq)), VIBRATO_LUT_LENGTH);
 512     return vibrated_freq;
 513 }
 514
 515 #endif
 516
 517 static void gpt_cb8(GPTDriver *gptp) {
 518     float freq;
 519
 520     if (playing_note) {
 521         if (voices > 0) {
 522
 523             float freq_alt = 0;
 524                 if (voices > 1) {
 525                     if (polyphony_rate == 0) {
 526                         if (glissando) {
 527                             if (frequency_alt != 0 && frequency_alt < frequencies[voices - 2] && frequency_alt < frequencies[voices - 2] * pow(2, -440/frequencies[voices - 2]/12/2)) {
 528                                 frequency_alt = frequency_alt * pow(2, 440/frequency_alt/12/2);
 529                             } else if (frequency_alt != 0 && frequency_alt > frequencies[voices - 2] && frequency_alt > frequencies[voices - 2] * pow(2, 440/frequencies[voices - 2]/12/2)) {
 530                                 frequency_alt = frequency_alt * pow(2, -440/frequency_alt/12/2);
 531                             } else {
 532                                 frequency_alt = frequencies[voices - 2];
 533                             }
 534                         } else {
 535                             frequency_alt = frequencies[voices - 2];
 536                         }
 537
 538                         #ifdef VIBRATO_ENABLE
 539                             if (vibrato_strength > 0) {
 540                                 freq_alt = vibrato(frequency_alt);
 541                             } else {
 542                                 freq_alt = frequency_alt;
 543                             }
 544                         #else
 545                             freq_alt = frequency_alt;
 546                         #endif
 547                     }
 548
 549                     if (envelope_index < 65535) {
 550                         envelope_index++;
 551                     }
 552
 553                     freq_alt = voice_envelope(freq_alt);
 554
 555                     if (freq_alt < 30.517578125) {
 556                         freq_alt = 30.52;
 557                     }
 558
 559                     if (GET_CHANNEL_2_FREQ != (uint16_t)freq_alt) {
 560                         UPDATE_CHANNEL_2_FREQ(freq_alt);
 561                     } else {
 562                         RESTART_CHANNEL_2();
 563                     }
 564                     //note_timbre;
 565                 }
 566
 567             if (polyphony_rate > 0) {
 568                 if (voices > 1) {
 569                     voice_place %= voices;
 570                     if (place++ > (frequencies[voice_place] / polyphony_rate)) {
 571                         voice_place = (voice_place + 1) % voices;
 572                         place = 0.0;
 573                     }
 574                 }
 575
 576                 #ifdef VIBRATO_ENABLE
 577                     if (vibrato_strength > 0) {
 578                         freq = vibrato(frequencies[voice_place]);
 579                     } else {
 580                         freq = frequencies[voice_place];
 581                     }
 582                 #else
 583                     freq = frequencies[voice_place];
 584                 #endif
 585             } else {
 586                 if (glissando) {
 587                     if (frequency != 0 && frequency < frequencies[voices - 1] && frequency < frequencies[voices - 1] * pow(2, -440/frequencies[voices - 1]/12/2)) {
 588                         frequency = frequency * pow(2, 440/frequency/12/2);
 589                     } else if (frequency != 0 && frequency > frequencies[voices - 1] && frequency > frequencies[voices - 1] * pow(2, 440/frequencies[voices - 1]/12/2)) {
 590                         frequency = frequency * pow(2, -440/frequency/12/2);
 591                     } else {
 592                         frequency = frequencies[voices - 1];
 593                     }
 594                 } else {
 595                     frequency = frequencies[voices - 1];
 596                 }
 597
 598                 #ifdef VIBRATO_ENABLE
 599                     if (vibrato_strength > 0) {
 600                         freq = vibrato(frequency);
 601                     } else {
 602                         freq = frequency;
 603                     }
 604                 #else
 605                     freq = frequency;
 606                 #endif
 607             }
 608
 609             if (envelope_index < 65535) {
 610                 envelope_index++;
 611             }
 612
 613             freq = voice_envelope(freq);
 614
 615             if (freq < 30.517578125) {
 616                 freq = 30.52;
 617             }
 618
 619
 620             if (GET_CHANNEL_1_FREQ != (uint16_t)freq) {
 621                 UPDATE_CHANNEL_1_FREQ(freq);
 622             } else {
 623                 RESTART_CHANNEL_1();
 624             }
 625             //note_timbre;
 626         }
 627     }
 628
 629     if (playing_notes) {
 630         if (note_frequency > 0) {
 631             #ifdef VIBRATO_ENABLE
 632                 if (vibrato_strength > 0) {
 633                     freq = vibrato(note_frequency);
 634                 } else {
 635                     freq = note_frequency;
 636                 }
 637             #else
 638                     freq = note_frequency;
 639             #endif
 640
 641             if (envelope_index < 65535) {
 642                 envelope_index++;
 643             }
 644             freq = voice_envelope(freq);
 645
 646
 647             if (GET_CHANNEL_1_FREQ != (uint16_t)freq) {
 648                 UPDATE_CHANNEL_1_FREQ(freq);
 649                 UPDATE_CHANNEL_2_FREQ(freq);
 650             }
 651             //note_timbre;
 652         } else {
 653             // gptStopTimer(&GPTD6);
 654             // gptStopTimer(&GPTD7);
 655         }
 656
 657         note_position++;
 658         bool end_of_note = false;
 659         if (GET_CHANNEL_1_FREQ > 0) {
 660             if (!note_resting)
 661                 end_of_note = (note_position >= (note_length*8 - 1));
 662             else
 663                 end_of_note = (note_position >= (note_length*8));
 664         } else {
 665             end_of_note = (note_position >= (note_length*8));
 666         }
 667
 668         if (end_of_note) {
 669             current_note++;
 670             if (current_note >= notes_count) {
 671                 if (notes_repeat) {
 672                     current_note = 0;
 673                 } else {
 674                     STOP_CHANNEL_1();
 675                     STOP_CHANNEL_2();
 676                     // gptStopTimer(&GPTD8);
 677                     playing_notes = false;
 678                     return;
 679                 }
 680             }
 681             if (!note_resting) {
 682                 note_resting = true;
 683                 current_note--;
 684                 if ((*notes_pointer)[current_note][0] == (*notes_pointer)[current_note + 1][0]) {
 685                     note_frequency = 0;
 686                     note_length = 1;
 687                 } else {
 688                     note_frequency = (*notes_pointer)[current_note][0];
 689                     note_length = 1;
 690                 }
 691             } else {
 692                 note_resting = false;
 693                 envelope_index = 0;
 694                 note_frequency = (*notes_pointer)[current_note][0];
 695                 note_length = ((*notes_pointer)[current_note][1] / 4) * (((float)note_tempo) / 100);
 696             }
 697
 698             note_position = 0;
 699         }
 700     }
 701
 702     if (!audio_config.enable) {
 703         playing_notes = false;
 704         playing_note = false;
 705     }
 706 }
 707
 708 void play_note(float freq, int vol) {
 709
 710     dprintf("audio play note freq=%d vol=%d", (int)freq, vol);
 711
 712     if (!audio_initialized) {
 713         audio_init();
 714     }
 715
 716     if (audio_config.enable && voices < 8) {
 717
 718
 719         // Cancel notes if notes are playing
 720         if (playing_notes)
 721             stop_all_notes();
 722
 723         playing_note = true;
 724
 725         envelope_index = 0;
 726
 727         if (freq > 0) {
 728             frequencies[voices] = freq;
 729             volumes[voices] = vol;
 730             voices++;
 731         }
 732
 733         gptStart(&GPTD8, &gpt8cfg1);
 734         gptStartContinuous(&GPTD8, 2U);
 735         RESTART_CHANNEL_1();
 736         RESTART_CHANNEL_2();
 737     }
 738
 739 }
 740
 741 void play_notes(float (*np)[][2], uint16_t n_count, bool n_repeat)
 742 {
 743
 744     if (!audio_initialized) {
 745         audio_init();
 746     }
 747
 748     if (audio_config.enable) {
 749
 750         // Cancel note if a note is playing
 751         if (playing_note)
 752             stop_all_notes();
 753
 754         playing_notes = true;
 755
 756         notes_pointer = np;
 757         notes_count = n_count;
 758         notes_repeat = n_repeat;
 759
 760         place = 0;
 761         current_note = 0;
 762
 763         note_frequency = (*notes_pointer)[current_note][0];
 764         note_length = ((*notes_pointer)[current_note][1] / 4) * (((float)note_tempo) / 100);
 765         note_position = 0;
 766
 767         gptStart(&GPTD8, &gpt8cfg1);
 768         gptStartContinuous(&GPTD8, 2U);
 769         RESTART_CHANNEL_1();
 770         RESTART_CHANNEL_2();
 771     }
 772
 773 }
 774
 775 bool is_playing_notes(void) {
 776     return playing_notes;
 777 }
 778
 779 bool is_audio_on(void) {
 780     return (audio_config.enable != 0);
 781 }
 782
 783 void audio_toggle(void) {
 784     audio_config.enable ^= 1;
 785     eeconfig_update_audio(audio_config.raw);
 786     if (audio_config.enable)
 787         audio_on_user();
 788 }
 789
 790 void audio_on(void) {
 791     audio_config.enable = 1;
 792     eeconfig_update_audio(audio_config.raw);
 793     audio_on_user();
 794 }
 795
 796 void audio_off(void) {
 797     audio_config.enable = 0;
 798     eeconfig_update_audio(audio_config.raw);
 799 }
 800
 801 #ifdef VIBRATO_ENABLE
 802
 803 // Vibrato rate functions
 804
 805 void set_vibrato_rate(float rate) {
 806     vibrato_rate = rate;
 807 }
 808
 809 void increase_vibrato_rate(float change) {
 810     vibrato_rate *= change;
 811 }
 812
 813 void decrease_vibrato_rate(float change) {
 814     vibrato_rate /= change;
 815 }
 816
 817 #ifdef VIBRATO_STRENGTH_ENABLE
 818
 819 void set_vibrato_strength(float strength) {
 820     vibrato_strength = strength;
 821 }
 822
 823 void increase_vibrato_strength(float change) {
 824     vibrato_strength *= change;
 825 }
 826
 827 void decrease_vibrato_strength(float change) {
 828     vibrato_strength /= change;
 829 }
 830
 831 #endif  /* VIBRATO_STRENGTH_ENABLE */
 832
 833 #endif /* VIBRATO_ENABLE */
 834
 835 // Polyphony functions
 836
 837 void set_polyphony_rate(float rate) {
 838     polyphony_rate = rate;
 839 }
 840
 841 void enable_polyphony() {
 842     polyphony_rate = 5;
 843 }
 844
 845 void disable_polyphony() {
 846     polyphony_rate = 0;
 847 }
 848
 849 void increase_polyphony_rate(float change) {
 850     polyphony_rate *= change;
 851 }
 852
 853 void decrease_polyphony_rate(float change) {
 854     polyphony_rate /= change;
 855 }
 856
 857 // Timbre function
 858
 859 void set_timbre(float timbre) {
 860     note_timbre = timbre;
 861 }
 862
 863 // Tempo functions
 864
 865 void set_tempo(uint8_t tempo) {
 866     note_tempo = tempo;
 867 }
 868
 869 void decrease_tempo(uint8_t tempo_change) {
 870     note_tempo += tempo_change;
 871 }
 872
 873 void increase_tempo(uint8_t tempo_change) {
 874     if (note_tempo - tempo_change < 10) {
 875         note_tempo = 10;
 876     } else {
 877         note_tempo -= tempo_change;
 878     }
 879 }