visus
/
framework-arduinoteensy-cxx20
Suivre 1
Ajouter aux favoris 0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
2 Révisions
1 Branche
Aborescence: daa7cc5a30
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de 'daa7cc5a30'
${ noResults }
framework-arduinoteensy-cxx20/libraries/Audio/examples/Synthesis/Wavetable/MidiSynthLarge/MidiSynthLarge.ino

343 lines
13KB
Brut Annotations Historique 

  1. /* Play notes when your computer sends USB MIDI messages.

  2. 

  3.    To use this example, you must run software on your computer which

  4.    sends MIDI.  Tools > USB Type must be set to MIDI when uploading.

  5. 

  6.    Requires Teensy 3.6 due to 820 kbytes of wavetable data

  7.    Requires Audio Shield: https://www.pjrc.com/store/teensy3_audio.html

  8. */

  9. 

  10. #include "bassoon_samples.h"

  11. #include "clarinet_samples.h"

  12. #include "distortiongt_samples.h"

  13. #include "epiano_samples.h"

  14. #include "flute_samples.h"

  15. #include "frenchhorn_samples.h"

  16. #include "glockenspiel_samples.h"

  17. #include "gtfretnoise_samples.h"

  18. #include "harmonica_samples.h"

  19. #include "harp_samples.h"

  20. #include "mutedgtr_samples.h"

  21. #include "nylonstrgtr_samples.h"

  22. #include "oboe_samples.h"

  23. #include "overdrivegt_samples.h"

  24. #include "recorder_samples.h"

  25. #include "standard_DRUMS_samples.h"

  26. #include "steelstrgtr_samples.h"

  27. #include "strings_samples.h"

  28. #include "timpani_samples.h"

  29. #include "trombone_samples.h"

  30. #include "trumpet_samples.h"

  31. #include "tuba_samples.h"

  32. #include "piano_samples.h"

  33. #include "vibraphone_samples.h"

  34. 

  35. #include <Bounce.h>

  36. #include <Audio.h>

  37. #include <Wire.h>

  38. #include <SPI.h>

  39. #include <SD.h>

  40. #include <SerialFlash.h>

  41. 

  42. //#define DEBUG_ALLOC

  43. 

  44. const int TOTAL_VOICES = 64;

  45. const int TOTAL_MIXERS = 21;

  46. const int SECONDARY_MIXERS = 4;

  47. 

  48. AudioControlSGTL5000 sgtl5000_1;

  49. AudioSynthWavetable wavetable[TOTAL_VOICES];

  50. AudioMixer4 mixer[TOTAL_MIXERS];

  51. AudioOutputI2S i2s1;

  52. AudioConnection patchCord[] = {

  53.   {wavetable[0], 0, mixer[0], 0}, {wavetable[1], 0, mixer[0], 1}, {wavetable[2], 0, mixer[0],  2}, {wavetable[3], 0, mixer[0],  3}, {mixer[0], 0, mixer[TOTAL_MIXERS - 2], 0},

  54.   {wavetable[4], 0, mixer[1], 0}, {wavetable[5], 0, mixer[1], 1}, {wavetable[6], 0, mixer[1],  2}, {wavetable[7], 0, mixer[1],  3}, {mixer[1], 0, mixer[TOTAL_MIXERS - 2], 1},

  55.   {wavetable[8], 0, mixer[2], 0}, {wavetable[9], 0, mixer[2], 1}, {wavetable[10], 0, mixer[2],  2}, {wavetable[11], 0, mixer[2],  3}, {mixer[2], 0, mixer[TOTAL_MIXERS - 2], 2},

  56.   {wavetable[12], 0, mixer[3], 0}, {wavetable[13], 0, mixer[3], 1}, {wavetable[14], 0, mixer[3],  2}, {wavetable[15], 0, mixer[3],  3}, {mixer[3], 0, mixer[TOTAL_MIXERS - 2], 3},

  57.   {wavetable[16], 0, mixer[4], 0}, {wavetable[17], 0, mixer[4], 1}, {wavetable[18], 0, mixer[4],  2}, {wavetable[19], 0, mixer[4],  3}, {mixer[4], 0, mixer[TOTAL_MIXERS - 3], 0},

  58.   {wavetable[20], 0, mixer[5], 0}, {wavetable[21], 0, mixer[5], 1}, {wavetable[22], 0, mixer[5],  2}, {wavetable[23], 0, mixer[5],  3}, {mixer[5], 0, mixer[TOTAL_MIXERS - 3], 1},

  59.   {wavetable[24], 0, mixer[6], 0}, {wavetable[25], 0, mixer[6], 1}, {wavetable[26], 0, mixer[6],  2}, {wavetable[27], 0, mixer[6],  3}, {mixer[6], 0, mixer[TOTAL_MIXERS - 3], 2},

  60.   {wavetable[28], 0, mixer[7], 0}, {wavetable[29], 0, mixer[7], 1}, {wavetable[30], 0, mixer[7],  2}, {wavetable[31], 0, mixer[7],  3}, {mixer[7], 0, mixer[TOTAL_MIXERS - 3], 3},

  61.   {wavetable[32], 0, mixer[8], 0}, {wavetable[33], 0, mixer[8], 1}, {wavetable[34], 0, mixer[8],  2}, {wavetable[35], 0, mixer[8],  3}, {mixer[8], 0, mixer[TOTAL_MIXERS - 4], 0},

  62.   {wavetable[36], 0, mixer[9], 0}, {wavetable[37], 0, mixer[9], 1}, {wavetable[38], 0, mixer[9],  2}, {wavetable[39], 0, mixer[9],  3}, {mixer[9], 0, mixer[TOTAL_MIXERS - 4], 1},

  63.   {wavetable[40], 0, mixer[10], 0}, {wavetable[41], 0, mixer[10], 1}, {wavetable[42], 0, mixer[10], 2}, {wavetable[43], 0, mixer[10], 3}, {mixer[10], 0, mixer[TOTAL_MIXERS - 4], 2},

  64.   {wavetable[44], 0, mixer[11], 0}, {wavetable[45], 0, mixer[11], 1}, {wavetable[46], 0, mixer[11], 2}, {wavetable[47], 0, mixer[11], 3}, {mixer[11], 0, mixer[TOTAL_MIXERS - 4], 3},

  65.   {wavetable[48], 0, mixer[12], 0}, {wavetable[49], 0, mixer[12], 1}, {wavetable[50], 0, mixer[12], 2}, {wavetable[51], 0, mixer[12], 3}, {mixer[12], 0, mixer[TOTAL_MIXERS - 5], 0},

  66.   {wavetable[52], 0, mixer[13], 0}, {wavetable[53], 0, mixer[13], 1}, {wavetable[54], 0, mixer[13], 2}, {wavetable[55], 0, mixer[13], 3}, {mixer[13], 0, mixer[TOTAL_MIXERS - 5], 1},

  67.   {wavetable[56], 0, mixer[14], 0}, {wavetable[57], 0, mixer[14], 1}, {wavetable[58], 0, mixer[14], 2}, {wavetable[59], 0, mixer[14], 3}, {mixer[14], 0, mixer[TOTAL_MIXERS - 5], 2},

  68.   {wavetable[60], 0, mixer[15], 0}, {wavetable[61], 0, mixer[15], 1}, {wavetable[62], 0, mixer[15], 2}, {wavetable[63], 0, mixer[15], 3}, {mixer[15], 0, mixer[TOTAL_MIXERS - 5], 3},

  69.   {mixer[TOTAL_MIXERS - 2], 0, mixer[TOTAL_MIXERS - 1], 0},

  70.   {mixer[TOTAL_MIXERS - 3], 0, mixer[TOTAL_MIXERS - 1], 1},

  71.   {mixer[TOTAL_MIXERS - 4], 0, mixer[TOTAL_MIXERS - 1], 2},

  72.   {mixer[TOTAL_MIXERS - 5], 0, mixer[TOTAL_MIXERS - 1], 3},

  73.   {mixer[TOTAL_MIXERS - 1], 0, i2s1, 0},

  74.   {mixer[TOTAL_MIXERS - 1], 0, i2s1, 1},

  75. };

  76. Bounce buttons[] = { {0, 15}, {1, 15}, {2, 15}, };

  77. const int TOTAL_BUTTONS = sizeof(buttons) / sizeof(Bounce);

  78. 

  79. void guitarHeroMode();

  80. void printVoices();

  81. void setVolume() {

  82. 	sgtl5000_1.volume(0.8*(analogRead(PIN_A2) - 1) / 1022.0);

  83. }

  84. 

  85. struct voice_t {

  86. 	int wavetable_id;

  87. 	byte channel;

  88. 	byte note;

  89. };

  90. voice_t voices[TOTAL_VOICES];

  91. 

  92. IntervalTimer midiMapTimer;

  93. IntervalTimer guitarHeroTimer;

  94. IntervalTimer volumeTimer;

  95. 

  96. void setup() {

  97. 	Serial.begin(115200);

  98. 

  99. 	pinMode(0, INPUT_PULLUP);

  100. 	pinMode(1, INPUT_PULLUP);

  101. 	pinMode(2, INPUT_PULLUP);

  102. 

  103. 	AudioMemory(120);

  104. 

  105. 	sgtl5000_1.enable();

  106. 	sgtl5000_1.volume(0.8);

  107. 

  108. 	for (int i = 0; i < TOTAL_VOICES; ++i) {

  109. 		wavetable[i].setInstrument(nylonstrgtr);

  110. 		voices[i].wavetable_id = i;

  111. 		voices[i].channel = voices[i].note = 0xFF;

  112. 	}

  113. 

  114. 	for (int i = 0; i < TOTAL_MIXERS - 1; ++i)

  115. 		for (int j = 0; j < 4; ++j)

  116. 			mixer[i].gain(j, 0.50);

  117. 	for (int i = 0; i < 4; ++i)

  118. 		mixer[TOTAL_MIXERS - 1].gain(i, i < SECONDARY_MIXERS ? 2.0 / SECONDARY_MIXERS : 0.0);

  119. 

  120. 	usbMIDI.setHandleNoteOn(OnNoteOn);

  121. 	usbMIDI.setHandleNoteOff(OnNoteOff);

  122. 	usbMIDI.setHandleProgramChange(OnProgramChange);

  123. 	usbMIDI.setHandleControlChange(OnControlChange);

  124. 	//volumeTimer.begin(setVolume, 100000);

  125. 	//guitarHeroTimer.begin(guitarHeroMode, 1000000 / 120);

  126. 	//midiMapTimer.begin(printVoices, 5000);

  127. 

  128. 	delay(2000);

  129. }

  130. 

  131. void loop() {

  132. 	usbMIDI.read();

  133. 	//for (int i = 0; i < TOTAL_BUTTONS; ++i) buttons[i].update();

  134. 	//if (buttons[0].fallingEdge()) AudioSynthWavetable::print_performance();

  135. 	//if (buttons[1].risingEdge()) {

  136. 	//  midiMapTimer.end();

  137. 	//  Serial.print('\n');

  138. 	//}

  139. 	//if (buttons[1].fallingEdge()) midiMapTimer.begin(printVoices, 5000);

  140. 	//if (buttons[2].risingEdge()) guitarHeroTimer.end();

  141. 	//if (buttons[2].fallingEdge())

  142. 	//  guitarHeroTimer.begin(guitarHeroMode, 1000000/60);

  143. }

  144. 

  145. int allocateVoice(byte channel, byte note);

  146. int findVoice(byte channel, byte note);

  147. void freeVoices();

  148. 

  149. int used_voices = 0;

  150. int stopped_voices = 0;

  151. int evict_voice = 0;

  152. int notes_played = 0;

  153. 

  154. void OnPress(int key)

  155. {

  156. 	Serial.print("key '");

  157. 	Serial.print((char)key);

  158. 	Serial.print("'  ");

  159. 	Serial.println(key);

  160. 	//Serial.print("key ");

  161. 	//Serial.print((char)keyboard1.getKey());

  162. 	//Serial.print("  ");

  163. 	//Serial.print((char)keyboard2.getKey());

  164. 	//Serial.println();

  165. }

  166. 

  167. const AudioSynthWavetable::instrument_data * const midi_map[] = {

  168. 	&piano, &piano, &piano, &piano, &piano, &piano, &piano, &piano, // 000: pianos

  169. 	&vibraphone, &vibraphone, &vibraphone, &vibraphone, &vibraphone, &vibraphone, &vibraphone, &vibraphone, // 008: chrom percus

  170. 	&harmonica, &harmonica, &harmonica, &harmonica, &harmonica, &harmonica, &harmonica, &harmonica, // 016: organs

  171. 	&nylonstrgtr, &steelstrgtr, &nylonstrgtr, &nylonstrgtr, &mutedgtr, &overdrivegt, &distortiongt, &nylonstrgtr, // 024: guitars

  172. 	&piano, &piano, &piano, &piano, &piano, &piano, &piano, &piano, // 032: bass

  173. 	&strings, &strings, &strings, &strings, &strings, &strings, &harp, &timpani, // 040: strings

  174. 	&strings, &strings, &strings, &strings, &strings, &strings, &strings, &strings, // 048: ensemble

  175. 	&trumpet, &trombone, &tuba, &frenchhorn, &frenchhorn, &frenchhorn, &frenchhorn, &frenchhorn, // 056: brass

  176. 	&oboe, &oboe, &oboe, &oboe, &oboe, &oboe, &bassoon, &clarinet, // 064: reed

  177. 	&flute, &flute, &recorder, &flute, &flute, &flute, &flute, &flute, // 072: pipe

  178. 	&piano, &piano, &piano, &piano, &piano, &piano, &piano, &piano, // 080: synth lead

  179. 	&piano, &piano, &piano, &piano, &piano, &piano, &piano, &piano, // 088: synth pad

  180. 	&piano, &piano, &piano, &piano, &piano, &piano, &piano, &piano, // 096: synth effect

  181. 	&piano, &piano, &piano, &piano, &piano, &piano, &piano, &piano, // 104: ethnic

  182. 	&timpani, &timpani, &timpani, &timpani, &timpani, &timpani, &timpani, &timpani, // 112: percussive

  183. 	&gtfretnoise, &gtfretnoise, &gtfretnoise, &gtfretnoise, &gtfretnoise, &gtfretnoise, &gtfretnoise, &gtfretnoise, // 120: sound effects

  184. };

  185. 

  186. const AudioSynthWavetable::instrument_data * channel_map[17] = {

  187. 	&piano, &piano, &piano, &piano, &piano, &piano, &piano, &piano, &piano, &piano, &standard_DRUMS, &piano, &piano, &piano, &piano, &piano, &piano,

  188. };

  189. 

  190. int channel_vol[] = {

  191. 	90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 

  192. };

  193. 

  194. void OnControlChange(byte channel, byte control, byte value)

  195. {

  196. 	switch (control) {

  197. 	case 7: //volume

  198. 		channel_vol[channel] = value;

  199. 		break;

  200. 	default:

  201. 		break;

  202. 	}

  203. 	Serial.print("Control Change, ch=");

  204. 	Serial.print(channel);

  205. 	Serial.print(", control=");

  206. 	Serial.print(control);

  207. 	Serial.print(", value=");

  208. 	Serial.print(value);

  209. 	Serial.println();

  210. }

  211. 

  212. 

  213. void OnProgramChange(byte channel, byte program) {

  214. 	channel_map[channel] = channel != 10 ? midi_map[program] : &standard_DRUMS;

  215. }

  216. 

  217. void OnNoteOn(byte channel, byte note, byte velocity) {

  218. 	notes_played++;

  219. #ifdef DEBUG_ALLOC

  220. 	//Serial.printf("**** NoteOn: channel==%hhu,note==%hhu ****\n", channel, note);

  221. 	printVoices();

  222. #endif //DEBUG_ALLOC

  223. 	freeVoices();

  224. 	int wavetable_id = allocateVoice(channel, note);

  225. 	wavetable[wavetable_id].setInstrument(*channel_map[channel]);

  226. 	wavetable[wavetable_id].playNote(note, (velocity*channel_vol[channel] + 0x80) >> 7);

  227. #ifdef DEBUG_ALLOC

  228. 	printVoices();

  229. #endif //DEBUG_ALLOC

  230. }

  231. 

  232. void OnNoteOff(byte channel, byte note, byte velocity) {

  233. #ifdef DEBUG_ALLOC

  234. 	//Serial.printf("\n**** NoteOff: channel==%hhu,note==%hhu ****", channel, note);

  235. 	printVoices();

  236. #endif //DEBUG_ALLOC

  237. 	int wavetable_id = findVoice(channel, note);

  238. 	if (wavetable_id != TOTAL_VOICES)

  239. 		wavetable[wavetable_id].stop();

  240. #ifdef DEBUG_ALLOC

  241. 	printVoices();

  242. #endif //DEBUG_ALLOC

  243. }

  244. 

  245. int allocateVoice(byte channel, byte note) {

  246. 	int i;

  247. 	int nonfree_voices = stopped_voices + used_voices;

  248. 	if (nonfree_voices < TOTAL_VOICES) {

  249. 		for (i = nonfree_voices; i < TOTAL_VOICES && voices[i].channel != channel; ++i);

  250. 		if (i < TOTAL_VOICES) {

  251. 			voice_t temp = voices[i];

  252. 			voices[i] = voices[nonfree_voices];

  253. 			voices[nonfree_voices] = temp;

  254. 		}

  255. 		i = nonfree_voices;

  256. 		used_voices++;

  257. 	}

  258. 	else {

  259. 		if (stopped_voices) {

  260. 			i = evict_voice % stopped_voices;

  261. 			voice_t temp = voices[i];

  262. 			stopped_voices--;

  263. 			voices[i] = voices[stopped_voices];

  264. 			voices[stopped_voices] = temp;

  265. 			used_voices++;

  266. 			i = stopped_voices;

  267. 		}

  268. 		else

  269. 			i = evict_voice;

  270. 	}

  271. 

  272. 	voices[i].channel = channel;

  273. 	voices[i].note = note;

  274. 

  275. 	evict_voice++;

  276. 	evict_voice %= TOTAL_VOICES;

  277. 

  278. 	return voices[i].wavetable_id;

  279. }

  280. 

  281. int findVoice(byte channel, byte note) {

  282. 	int i;

  283. 	//find match

  284. 	int nonfree_voices = stopped_voices + used_voices;

  285. 	for (i = stopped_voices; i < nonfree_voices && !(voices[i].channel == channel && voices[i].note == note); ++i);

  286. 	//return TOTAL_VOICES if no match

  287. 	if (i == (nonfree_voices)) return TOTAL_VOICES;

  288. 

  289. 	voice_t temp = voices[i];

  290. 	voices[i] = voices[stopped_voices];

  291. 	voices[stopped_voices] = temp;

  292. 	--used_voices;

  293. 

  294. 	return voices[stopped_voices++].wavetable_id;

  295. }

  296. 

  297. void freeVoices() {

  298. 	for (int i = 0; i < stopped_voices; i++)

  299. 		if (wavetable[voices[i].wavetable_id].isPlaying() == false) {

  300. 			voice_t temp = voices[i];

  301. 			--stopped_voices;

  302. 			voices[i] = voices[stopped_voices];

  303. 			int nonfree_voices = stopped_voices + used_voices;

  304. 			voices[stopped_voices] = voices[nonfree_voices];

  305. 			voices[nonfree_voices] = temp;

  306. 		}

  307. }

  308. 

  309. void guitarHeroMode() { // now unicorn friendly

  310. 	const int RESET = 4;

  311. 	const int MIDI_NOTES = 128;

  312. 	static char line[MIDI_NOTES + 1] = { 0 };

  313. 	static int accumulated = 0;

  314. 	if (!accumulated) {

  315. 		for (int i = 0; i < MIDI_NOTES; ++i) line[i] = '-';

  316. 		++accumulated;

  317. 	}

  318. 	for (int i = stopped_voices; i < used_voices + stopped_voices; ++i) line[voices[i].note] = '*';

  319. 	if (accumulated == RESET) {

  320. 		Serial.println(line);

  321. 		accumulated = 0;

  322. 	}

  323. 	else {

  324. 		++accumulated;

  325. 	}

  326. }

  327. 

  328. const char* note_map[] = {

  329.   "C","C#","D","D#","E","F","F#","G","G#","A","A#","B"

  330. };

  331. 

  332. void printVoices() {

  333. 	static int last_notes_played = notes_played;

  334. 	if (last_notes_played == notes_played)

  335. 		return;

  336. 	last_notes_played = notes_played;

  337. 	int usage = AudioProcessorUsage();

  338. 	Serial.printf("\nCPU:%03i voices:%02i CPU/Voice:%02i evict:%02i", usage, used_voices, usage / used_voices, evict_voice);

  339. 	for (int i = 0; i < used_voices; ++i)

  340. 		Serial.printf(" %02hhu %-2s", voices[i].channel, note_map[voices[i].note % 12]);

  341. 

  342. }