visus
/
teensy-audio
Beobachten 1
Favorisieren 0
Fork 0
Code Issues 0 Pull-Requests 0 Releases 0 Wiki Aktivität
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
711 Commits
2 Branches
Struktur: eba5e06a9a
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „eba5e06a9a“
${ noResults }
teensy-audio/examples/Synthesis/Wavetable/Zelda/Zelda.ino

349 Zeilen
11KB
Originalformat Blame Verlauf 

  1. /* Play Zelda music.

  2. 

  3.    Requires Teensy 3.6 due to 520 kbytes of wavetable data

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

  5. */

  6. 

  7. #include <Bounce.h>

  8. #include <Audio.h>

  9. #include <Wire.h>

  10. #include <SPI.h>

  11. #include <SD.h>

  12. #include <SerialFlash.h>

  13. 

  14. #include "Pizzicato_samples.h"

  15. #include "FrenchHorns_samples.h"

  16. #include "Viola_samples.h"

  17. #include "BasicFlute1_samples.h"

  18. #include "PlaySynthMusic.h"

  19. 

  20. //#define DEBUG_ALLOC

  21. 

  22. unsigned char *sp = score;

  23. 

  24. const int TOTAL_VOICES = 64;

  25. const int TOTAL_MIXERS = 21;

  26. const int SECONDARY_MIXERS = 4;

  27. 

  28. AudioControlSGTL5000 sgtl5000_1;

  29. AudioSynthWavetable wavetable[TOTAL_VOICES];

  30. AudioMixer4 mixer[TOTAL_MIXERS];

  31. AudioOutputI2S i2s1;

  32. AudioConnection patchCord[] = {

  33. 	{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},

  34. 	{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},

  35. 	{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},

  36. 	{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},

  37. 	{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},

  38. 	{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},

  39. 	{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},

  40. 	{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},

  41. 	{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},

  42. 	{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},

  43. 	{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},

  44. 	{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},

  45. 	{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},

  46. 	{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},

  47. 	{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},

  48. 	{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},

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

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

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

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

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

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

  55. };

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

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

  58. 

  59. void guitarHeroMode();

  60. void printVoices();

  61. void setVolume() {

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

  63. }

  64. 

  65. struct voice_t {

  66. 	int wavetable_id;

  67. 	byte channel;

  68. 	byte note;

  69. };

  70. voice_t voices[TOTAL_VOICES];

  71. 

  72. IntervalTimer midiMapTimer;

  73. IntervalTimer guitarHeroTimer;

  74. IntervalTimer volumeTimer;

  75. 

  76. void setup() {

  77. 	Serial.begin(115200);

  78. 

  79. 

  80. 	pinMode(0, INPUT_PULLUP);

  81. 	pinMode(1, INPUT_PULLUP);

  82. 	pinMode(2, INPUT_PULLUP);

  83. 

  84. 	AudioMemory(120);

  85. 

  86. 	sgtl5000_1.enable();

  87. 	sgtl5000_1.volume(0.8);

  88. 

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

  90. 		wavetable[i].setInstrument(Pizzicato);

  91. 		wavetable[i].amplitude(1);

  92. 		voices[i].wavetable_id = i;

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

  94. 	}

  95. 

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

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

  98. 			mixer[i].gain(j, 0.25);

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

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

  101. 	

  102. 	usbMIDI.setHandleNoteOn(OnNoteOn);

  103. 	usbMIDI.setHandleNoteOff(OnNoteOff);

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

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

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

  107. 

  108.   delay(2000);

  109. }

  110. 

  111. void loop() {

  112.   unsigned char c,opcode,chan;

  113.   unsigned long d_time;

  114.   

  115.   // Volume control

  116.   //  uncomment if you have a volume pot soldered to your audio shield

  117.   /*

  118.   int n = analogRead(15);

  119.   if (n != volume) {

  120.     volume = n;

  121.     codec.volume((float)n / 1023);

  122.   }

  123.   */

  124.   

  125.   // read the next note from the table

  126.   c = *sp++;

  127.   opcode = c & 0xF0;

  128.   chan = c & 0x0F;

  129. 

  130.   if(c < 0x80) {

  131.     // Delay

  132.     d_time = (c << 8) | *sp++;

  133.     delay(d_time);

  134.     return;

  135.   }

  136.   if(*sp == CMD_STOP) {

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

  138.       wavetable[chan].stop();

  139.     }

  140.     while(1);

  141.   }

  142. 

  143.   // It is a command

  144. 

  145.   //Change the instrument for generator

  146.   if(opcode == CMD_CHANGEINST) {

  147.     unsigned char inst = *sp++;

  148.     wavetable[chan].stop();

  149.     switch(inst) {

  150.       case 48:

  151.         wavetable[chan].setInstrument(Viola);

  152.         break;

  153.       case 57:

  154.         wavetable[chan].setInstrument(BasicFlute1);

  155.         break;

  156.       default:

  157.         wavetable[chan].setInstrument(FrenchHorns);

  158.         break;

  159.     }

  160.     return;

  161.   }

  162.   

  163.   // Stop the note on 'chan'

  164.   if(opcode == CMD_STOPNOTE) {

  165.     wavetable[chan].stop();

  166.     return;

  167.   }

  168.   

  169.   // Play the note on 'chan'

  170.   if(opcode == CMD_PLAYNOTE) {

  171.     unsigned char note = *sp++;

  172.     unsigned char velocity = *sp++;

  173.     wavetable[chan].playNote((byte)note);

  174.     //OnNoteOn(chan, (byte)note, (byte)velocity);

  175.     return;

  176.   }

  177. 

  178.   // replay the tune

  179.   if(opcode == CMD_RESTART) {

  180.     sp = score;

  181.     return;

  182.   }

  183. 

  184. 	usbMIDI.read();

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

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

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

  188. 	//	midiMapTimer.end();

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

  190. 	//}

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

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

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

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

  195. }

  196. 

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

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

  199. void freeVoices();

  200. 

  201. int used_voices = 0;

  202. int stopped_voices = 0;

  203. int evict_voice = 0;

  204. int notes_played = 0;

  205. 

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

  207. 	notes_played++;

  208. #ifdef DEBUG_ALLOC

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

  210. 	printVoices();

  211. #endif //DEBUG_ALLOC

  212. 	freeVoices();

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

  214.   switch (channel) {

  215.     case 1:

  216.       wavetable[wavetable_id].setInstrument(Pizzicato);

  217.       break;

  218.     case 2:

  219.       wavetable[wavetable_id].setInstrument(Pizzicato);

  220.       break;

  221.     case 3:

  222.       wavetable[wavetable_id].setInstrument(Pizzicato);

  223.       break;

  224.     case 4:

  225.       wavetable[wavetable_id].setInstrument(Pizzicato);

  226.       break;

  227.     case 5:

  228.       wavetable[wavetable_id].setInstrument(Pizzicato);

  229.       break;

  230.     default:

  231.       wavetable[wavetable_id].setInstrument(Pizzicato);

  232.       break;

  233.   }

  234. 	wavetable[wavetable_id].playNote(note);

  235. #ifdef DEBUG_ALLOC

  236. 	printVoices();

  237. #endif //DEBUG_ALLOC

  238. }

  239. 

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

  241. #ifdef DEBUG_ALLOC

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

  243. 	printVoices();

  244. #endif //DEBUG_ALLOC

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

  246. 	if (wavetable_id != TOTAL_VOICES)

  247. 		wavetable[wavetable_id].stop();

  248. #ifdef DEBUG_ALLOC

  249. 	printVoices();

  250. #endif //DEBUG_ALLOC

  251. }

  252. 

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

  254. 	int i;

  255. 	int nonfree_voices = stopped_voices + used_voices;

  256. 	if (nonfree_voices < TOTAL_VOICES) {

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

  258. 		if (i < TOTAL_VOICES) {

  259. 			voice_t temp = voices[i];

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

  261. 			voices[nonfree_voices] = temp;

  262. 		}

  263. 		i = nonfree_voices;

  264. 		used_voices++;

  265. 	} else {

  266. 		if (stopped_voices) {

  267. 			i = evict_voice % stopped_voices;

  268. 			voice_t temp = voices[i];

  269. 			stopped_voices--;

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

  271. 			voices[stopped_voices] = temp;

  272. 			used_voices++;

  273. 			i = stopped_voices;

  274. 		}

  275. 		else

  276. 			i = evict_voice;

  277. 	}

  278. 

  279. 	voices[i].channel = channel;

  280. 	voices[i].note = note;

  281. 

  282. 	evict_voice++;

  283. 	evict_voice %= TOTAL_VOICES;

  284. 

  285. 	return voices[i].wavetable_id;

  286. }

  287. 

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

  289. 	int i;

  290. 	//find match

  291. 	int nonfree_voices = stopped_voices + used_voices;

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

  293. 	//return TOTAL_VOICES if no match

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

  295. 

  296. 	voice_t temp = voices[i];

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

  298. 	voices[stopped_voices] = temp;

  299. 	--used_voices;

  300. 

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

  302. }

  303. 

  304. void freeVoices() {

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

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

  307. 			voice_t temp = voices[i];

  308. 			--stopped_voices;

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

  310. 			int nonfree_voices = stopped_voices + used_voices;

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

  312. 			voices[nonfree_voices] = temp;

  313. 		}

  314. }

  315. 

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

  317. 	const int RESET = 4;

  318. 	const int MIDI_NOTES = 128;

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

  320. 	static int accumulated = 0;

  321. 	if (!accumulated) {

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

  323. 		++accumulated;

  324. 	}

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

  326. 	if (accumulated == RESET) {

  327. 		Serial.println(line);

  328. 		accumulated = 0;

  329. 	} else {

  330. 		++accumulated;

  331. 	}

  332. }

  333. 

  334. const char* note_map[] = {

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

  336. };

  337. 

  338. void printVoices() {

  339. 	static int last_notes_played = notes_played;

  340. 	if (last_notes_played == notes_played)

  341. 		return;

  342. 	last_notes_played = notes_played;

  343. 	int usage = AudioProcessorUsage();

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

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

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

  347. 

  348. }