├── README.md ├── additive_synth ├── additive_synth.ino └── setScale.ino ├── bubb ├── bubb.ino └── bubbleModel.ino ├── filtered_NOISE └── filtered_NOISE.ino ├── flush ├── callsMod.ino └── flush.ino ├── formantSynth ├── FormantSynth_classic.ino ├── FormantSynth_dynFilter.ino ├── formantSynth.ino └── scaleS.ino ├── percussive ├── percMod.ino ├── percMod_2.ino └── percussive.ino ├── rhythm_ └── rhythm_.ino ├── rhythm_autonomous └── rhythm_autonomous.ino ├── simil_Brass ├── model.ino └── simil_Brass.ino ├── simil_water └── simil_water.ino └── triggerNoisePulse_simple └── triggerNoisePulse_simple.ino /README.md: -------------------------------------------------------------------------------- 1 | # Arduino_AudioSynth_Mozzi 2 | Several real-time audio synthesis sketches made with the help of the Mozzi library for Arduino 3 | 4 | For running those sketches you need the Mozzi sound synthesis library for Arduino. 5 | Download this great Library from http://sensorium.github.io/Mozzi/ 6 | 7 | Tested on Arduino UNO, Arduino Mini 8 | 9 | Developed at STEIM, 2015. 10 | -------------------------------------------------------------------------------- /additive_synth/additive_synth.ino: -------------------------------------------------------------------------------- 1 | //additive synthesis 2 | 3 | // button - envelope 4 | // pot 1 - modulation 5 | 6 | #include 7 | #include // oscillator template 8 | #include 9 | #include // sine table for oscillator 10 | #include 11 | #include 12 | #include 13 | #include 14 | // use: Oscil oscilName (wavetable), look in .h file of table #included above 15 | Oscil aSin0(COS2048_DATA); 16 | Oscil aSin1(COS2048_DATA); 17 | Oscil aSin2(COS2048_DATA); 18 | Oscil aSin3(COS2048_DATA); 19 | Oscil aSin4(COS2048_DATA); 20 | Oscil aSin5(COS2048_DATA); 21 | Oscil aSin6(COS2048_DATA); 22 | Oscil aSin7(COS2048_DATA); 23 | 24 | Oscil aMod(SIN2048_DATA); 25 | 26 | Ead kEnvelope(CONTROL_RATE); 27 | int gain; 28 | 29 | // use #define for CONTROL_RATE, not a constant 30 | #define CONTROL_RATE 128 // powers of 2 please 31 | 32 | const int sensorPin = 1; 33 | const int sensorPinD = 4; 34 | 35 | boolean trigger = false; 36 | 37 | 38 | void setup(){ 39 | startMozzi(CONTROL_RATE); // set a control rate of 64 (powers of 2 please) 40 | pinMode(sensorPinD, INPUT); 41 | randSeed(); 42 | Serial.begin(115200); 43 | } 44 | 45 | 46 | void updateControl(){ 47 | // put changing controls in here 48 | float val1 = mozziAnalogRead(sensorPin); 49 | //int main_freq = 120; 50 | int sensorD = digitalRead(sensorPinD); 51 | 52 | selectScale(2, val1); 53 | float note = selScale(); 54 | 55 | aMod.setFreq(note); 56 | 57 | float main_freq = 440; 58 | 59 | if (sensorD == 1) { 60 | if (!trigger) { 61 | unsigned int duration = rand(500u)+200; 62 | unsigned int attack = rand(75)+5; // +5 so the internal step size is more likely to be >0 63 | unsigned int decay = duration - attack; 64 | kEnvelope.start(attack,decay); 65 | trigger = true; 66 | } else { 67 | trigger = false; 68 | } 69 | } 70 | Serial.println(sensorD); 71 | 72 | gain = (int) kEnvelope.next(); 73 | 74 | float freq1 = main_freq * 0; 75 | float freq2 = main_freq * 1; 76 | float freq3 = main_freq * 2; 77 | float freq4 = main_freq * 3; 78 | float freq5 = main_freq * 4; 79 | float freq6 = main_freq * 5; 80 | float freq7 = main_freq * 6; 81 | float freq8 = main_freq * 8; 82 | 83 | aSin0.setFreq(freq1); 84 | aSin1.setFreq(freq2); 85 | aSin2.setFreq(freq3); 86 | aSin3.setFreq(freq4); // set the frequency 87 | aSin4.setFreq(freq5); 88 | aSin5.setFreq(freq6); 89 | aSin6.setFreq(freq7); 90 | aSin7.setFreq(freq8); // set the frequency 91 | 92 | 93 | 94 | 95 | } 96 | 97 | 98 | int updateAudio(){ 99 | int asig; 100 | //asig = (uint8_t)aSin0.next(); 101 | 102 | uint8_t sinu1 = aSin0.next() * 1; 103 | uint8_t sinu2 = aSin1.next() * 0.7; 104 | uint8_t sinu3 = aSin2.next() * 0.5; 105 | uint8_t sinu4 = aSin3.next() * 0.4; 106 | uint8_t sinu5 = aSin4.next() * 0.3; 107 | uint8_t sinu6 = aSin5.next() * 0.3; 108 | //uint8_t sinu7 = aSin6.next() * 0.2; 109 | //uint8_t sinu8 = aSin7.next() * 0.1; 110 | 111 | 112 | //asig = sinu1 + sinu2 + sinu3 + sinu4 + sinu5; // + sinu6 + sinu7 + sinu8; 113 | //asig = sinu3 + sinu4 + sinu5 + sinu6 + sinu7 + sinu8; 114 | asig = aMod.phMod((aSin1.next() + aSin2.next() + aSin3.next() + aSin4.next() + aSin5.next()));//*aMod.next(); 115 | 116 | int asig_out = gain*asig;// * 0.4; 117 | //return aSin.next(); // return an int signal centred around 0 118 | return asig_out>>5; //without gain* >>1 119 | 120 | } 121 | 122 | 123 | void loop(){ 124 | audioHook(); // required here 125 | } 126 | 127 | 128 | 129 | 130 | 131 | -------------------------------------------------------------------------------- /additive_synth/setScale.ino: -------------------------------------------------------------------------------- 1 | AutoMap mapFreq(0, 1023, 5, 100); 2 | AutoMap mapFT(0, 1023, 0, 12); 3 | AutoMap mapSet(0, 1023, 4, 64); 4 | 5 | int tuneArraySel; 6 | 7 | int tuneArrI; 8 | 9 | int selected_scale; 10 | 11 | 12 | void selectScale(int sel_array, float fundamental) { 13 | 14 | float tunedArray[6][13] = { 15 | {1, 1.285, 1.5, 1.75, 2, 2.25, 2.57, 2.8, 3, 3.11, 3.5, 3.857, 4}, // 0 overtone series 16 | {1, 1.166, 1.33, 1.5, 1.75, 2, 2.332, 2.66, 3.0, 3.5, 4, 4.664, 6}, // 1 pentatonic 17 | {1, 1.166, 1.5, 2, 2.33, 3.0, 4, 4.66, 6.0, 8, 9.33, 12, 16}, // 2 minor 18 | {1, 1.25, 1.5, 2, 2.5, 3.0, 4, 5.0, 6.0, 8, 10, 12, 16}, // 3 major 19 | {1, 1.25, 1.56, 2, 2.5, 3.12, 4, 5.0, 6.24, 8, 10, 12.48, 16 }, // 4 augmented arpeggio 20 | {1, 1.071, 1.25, 1.33, 1.5, 1.56, 1.890, 2.0, 2.142, 2.5, 2.66, 3.0, 3.12} // 5 hicaz - arab scale 21 | }; 22 | 23 | tuneArraySel = sel_array; 24 | 25 | fundamental = mapFreq(fundamental); 26 | 27 | tuneArrI = mapFT(fundamental); //tuning array index 28 | 29 | selected_scale = tunedArray[tuneArraySel][tuneArrI] * 44; //the fundamental 30 | 31 | } 32 | 33 | 34 | //retrun the pitch/scale 35 | 36 | int selScale() { 37 | 38 | return selected_scale; 39 | 40 | } 41 | 42 | -------------------------------------------------------------------------------- /bubb/bubb.ino: -------------------------------------------------------------------------------- 1 | //A sort of 'bubble' 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | 17 | #include 18 | 19 | 20 | #define CONTROL_RATE 256 21 | 22 | const int PIN_0 = 0; // set freq 23 | const int PIN_1 = 1; // set the input for trigger 24 | const int PIN_2 = 2; 25 | const int PIN_3 = 3; 26 | const int PIN_4 = 4; 27 | const int PIN_5 = 5; 28 | 29 | const int GATE = 4; 30 | 31 | //Sensor values 32 | int pin0_val = 0; //int 33 | int pin1_val = 0; 34 | int pin2_val = 0; 35 | int pin3_val = 0; 36 | int pin4_val = 0; 37 | int pin5_val = 0; 38 | 39 | int button_in = 0; 40 | 41 | int byteSh = 0; //shift byte - audio final 42 | 43 | EventDelay kGainChangeDelay; 44 | 45 | int valu; 46 | 47 | void setup() { 48 | 49 | startMozzi(CONTROL_RATE); 50 | 51 | pinMode(GATE, INPUT); 52 | 53 | Serial.begin(115200); 54 | 55 | } 56 | 57 | void loop() { 58 | 59 | audioHook(); 60 | 61 | } 62 | 63 | void updateControl() { 64 | 65 | button_in = digitalRead(GATE); 66 | 67 | pin1_val = mozziAnalogRead(PIN_1); 68 | 69 | int topValu = 20; //mozziAnalogRead(PIN_1); 70 | 71 | Serial.println(pin1_val); 72 | 73 | bubbleControl(pin1_val, topValu, button_in, 100, 10, 10, 100); 74 | 75 | 76 | } 77 | 78 | int updateAudio() { 79 | 80 | bubbleAudio(); 81 | 82 | } 83 | -------------------------------------------------------------------------------- /bubb/bubbleModel.ino: -------------------------------------------------------------------------------- 1 | 2 | Oscil bCos(COS2048_DATA); 3 | Oscil bCos_2(COS2048_DATA); 4 | 5 | Ead envelope_1(AUDIO_RATE); 6 | Ead envelope_2(CONTROL_RATE); 7 | 8 | //StateVariable hpf; 9 | StateVariable lpf; 10 | 11 | AutoMap map1(0, 1023, 0, 600); 12 | 13 | boolean trigg = false; 14 | 15 | void bubbleControl(int the_freq, int centreFreq, int checkButton, int attack_1, int decay_1, int attack_2, int decay_2) { 16 | 17 | if(checkButton == 1) { 18 | if(!trigg) { 19 | envelope_1.start(attack_1,decay_1); 20 | envelope_2.start(attack_2,decay_2); 21 | trigg = true; 22 | } else { 23 | trigg = false; 24 | } 25 | } 26 | 27 | the_freq = map1.next(the_freq); //it works good with very low or very high values 28 | 29 | bCos.setFreq((the_freq)*envelope_1.next()); //600 30 | 31 | bCos_2.setFreq((120)*envelope_2.next()); //120 32 | 33 | //hpf.setResonance(50); 34 | //hpf.setCentreFreq(centreFreq); 35 | 36 | lpf.setResonance(250); //50 37 | lpf.setCentreFreq(550); //250 38 | 39 | 40 | } 41 | 42 | 43 | int bubbleAudio() { 44 | 45 | //return hpf.next(bCos_2.next()*(bCos.next()+bCos.next())>>6); //high 46 | return lpf.next(bCos_2.next()*(bCos.next()+bCos.next())>>7); //low 47 | } 48 | -------------------------------------------------------------------------------- /filtered_NOISE/filtered_NOISE.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include // oscillator template 3 | #include // recorded audio wavetable 4 | #include // exponential attack decay 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #define CONTROL_RATE 64 // powers of 2 please 13 | 14 | Oscil aNoise(BROWNNOISE8192_DATA); 15 | //Oscil aModDepth(COS2048_DATA); 16 | Oscil aModDepth(TRIANGLE2048_DATA); 17 | 18 | EventDelay kDelay; // for triggering envelope start 19 | 20 | Ead kEnvelope(CONTROL_RATE); // resolution will be CONTROL_RATE 21 | 22 | LowPassFilter lpf; 23 | 24 | int gain; 25 | 26 | AutoMap map1(0, 1023, 0, 500); 27 | AutoMap map2(0, 1023, 0, 3000); 28 | AutoMap map3(0, 1023, 0, 1000); 29 | 30 | const int pin1 = 1; 31 | const int pin2 = 2; 32 | const int pin3 = 3; 33 | 34 | int val1 = 0; 35 | int val2 = 0; 36 | int val3 = 0; 37 | 38 | 39 | void setup() { 40 | 41 | aNoise.setFreq((float)AUDIO_RATE/BROWNNOISE8192_SAMPLERATE); 42 | startMozzi(CONTROL_RATE); 43 | lpf.setResonance(100); 44 | 45 | } 46 | 47 | void updateControl() { 48 | 49 | // jump around in audio noise table to disrupt obvious looping 50 | aNoise.setPhase(rand((unsigned int)BROWNNOISE8192_NUM_CELLS)); 51 | 52 | val1 = mozziAnalogRead(pin1); 53 | val1 = map1.next(val1); 54 | 55 | val2 = mozziAnalogRead(pin2); 56 | val2 = map2.next(val2); 57 | 58 | val3 = mozziAnalogRead(pin3); 59 | val3 = map3.next(val3); 60 | 61 | aModDepth.setFreq(val3); 62 | 63 | //lpf.setCutoffFreq(val3); 64 | lpf.setCutoffFreq(aModDepth.next()); 65 | 66 | 67 | if(kDelay.ready()) { 68 | // set random parameters // change these set up to vary tempo 69 | unsigned int delay = rand(2000); 70 | 71 | unsigned int attack = val1; //rand(500); 72 | unsigned int decay = val2; //rand(3000); 73 | 74 | kEnvelope.start(500+attack,2000+decay); 75 | kDelay.start(5000+delay); 76 | } 77 | 78 | gain = (int) kEnvelope.next(); 79 | 80 | } 81 | 82 | int updateAudio() { 83 | 84 | int filtered = (int)lpf.next(aNoise.next()); 85 | return (gain*filtered)>>8; //without filter >>8 86 | 87 | } 88 | 89 | void loop(){ 90 | 91 | audioHook(); // required here 92 | 93 | } 94 | 95 | -------------------------------------------------------------------------------- /flush/callsMod.ino: -------------------------------------------------------------------------------- 1 | /* 2 | Oscil fOsc_1(COS2048_DATA); 3 | Oscil fOsc_2(COS2048_DATA); 4 | Oscil fOsc_3(COS2048_DATA); 5 | 6 | AutoMap mapF_1(0, 1023, 0, 600); 7 | AutoMap mapF_2(0, 1023, 0, 600); 8 | AutoMap mapCentF(0, 1023, 0, 500); 9 | 10 | StateVariable bpf_1; 11 | StateVariable bpf_2; 12 | 13 | LowPassFilter lpf; 14 | 15 | int final_sig; 16 | 17 | 18 | void modControl(int f_1, int f_2, int val_1, int val_2, int val_3, int centreFr) { 19 | 20 | f_1 = mapF_1.next(f_1); 21 | f_2 = mapF_2.next(f_2); 22 | 23 | fOsc_1.setFreq(220);//f_1); 24 | fOsc_2.setFreq(440);//f_2); 25 | 26 | int glue_1 = (fOsc_1.next()*fOsc_2.next()); 27 | 28 | int brew_1 = glue_1 * val_1; 29 | int brew_2 = brew_1 * val_2; 30 | int frul_1 = brew_2 + val_3; 31 | 32 | fOsc_3.setFreq(frul_1); 33 | 34 | bpf_1.setResonance(100); 35 | centreFr = mapCentF.next(centreFr); 36 | bpf_1.setCentreFreq(centreFr); 37 | 38 | 39 | 40 | } 41 | 42 | int modAudio() { 43 | 44 | int glue_2 = bpf_1.next(fOsc_3.next()); 45 | 46 | lpf.setResonance(100); 47 | lpf.setCutoffFreq(500); 48 | 49 | final_sig = lpf.next(glue_2); 50 | 51 | return (final_sig+final_sig)>>3; 52 | 53 | } 54 | */ 55 | -------------------------------------------------------------------------------- /flush/flush.ino: -------------------------------------------------------------------------------- 1 | //pot 3 - filter cutoff freq 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #include 19 | 20 | 21 | #define CONTROL_RATE 256 22 | 23 | const int PIN_0 = 0; // set freq 24 | const int PIN_1 = 1; // set the input for trigger 25 | const int PIN_2 = 2; 26 | const int PIN_3 = 3; 27 | const int PIN_4 = 4; 28 | const int PIN_5 = 5; 29 | 30 | const int GATE = 4; 31 | 32 | //Sensor values 33 | int pin0_val = 0; //int 34 | int pin1_val = 0; 35 | int pin2_val = 0; 36 | int pin3_val = 0; 37 | int pin4_val = 0; 38 | int pin5_val = 0; 39 | 40 | int button_in = 0; 41 | 42 | int byteSh = 0; //shift byte - audio final 43 | 44 | EventDelay kGainChangeDelay; 45 | 46 | int valu; 47 | 48 | // 49 | Oscil fOsc_1(COS2048_DATA); 50 | Oscil fOsc_2(COS2048_DATA); 51 | Oscil fOsc_3(COS2048_DATA); 52 | 53 | AutoMap mapF_1(0, 1023, 0, 600); 54 | AutoMap mapF_2(0, 1023, 0, 600); 55 | AutoMap mapCentF(0, 1023, 0, 500); 56 | 57 | StateVariable bpf_1; 58 | StateVariable bpf_2; 59 | 60 | LowPassFilter lpf; 61 | 62 | Ead aEnvelope(CONTROL_RATE); 63 | 64 | int final_sig; 65 | // 66 | 67 | 68 | boolean triggered_1 = false; 69 | 70 | 71 | void setup() { 72 | 73 | startMozzi(CONTROL_RATE); 74 | 75 | pinMode(GATE, INPUT); 76 | 77 | Serial.begin(115200); 78 | 79 | } 80 | 81 | void loop() { 82 | 83 | audioHook(); 84 | 85 | } 86 | 87 | void updateControl() { 88 | 89 | button_in = digitalRead(GATE); 90 | 91 | pin1_val = mozziAnalogRead(PIN_1); 92 | pin2_val = mozziAnalogRead(PIN_2); 93 | pin3_val = mozziAnalogRead(PIN_3); 94 | 95 | //modControl(pin1_val, pin2_val, 2, 12, 24, pin3_val); 96 | 97 | Serial.println(pin1_val); 98 | 99 | if (button_in == 1) { //&& env_sel_2 == 1) 100 | if(!triggered_1) { 101 | aEnvelope.start(10,100); 102 | triggered_1 = true; 103 | } else { 104 | triggered_1 = false; 105 | } 106 | } 107 | 108 | fOsc_1.setFreq(100);//f_1); 109 | fOsc_2.setFreq(100);//f_2); 110 | 111 | float glue_1 = (aEnvelope.next()*fOsc_1.next())*(aEnvelope.next()*fOsc_2.next()); 112 | 113 | float brew_1 = glue_1 * 2.5; 114 | float brew_2 = brew_1 * 2.5; 115 | float frul_1 = brew_2 + 10; 116 | 117 | fOsc_3.setFreq(frul_1); 118 | 119 | bpf_1.setResonance(20); 120 | //centreFr = mapCentF.next(pin3_val); 121 | bpf_1.setCentreFreq(pin3_val); 122 | 123 | 124 | 125 | 126 | } 127 | 128 | int updateAudio() { 129 | 130 | //modAudio(); 131 | 132 | int glue_2 = (int)bpf_1.next(fOsc_3.next()); 133 | 134 | lpf.setResonance(100); 135 | lpf.setCutoffFreq(1000); 136 | 137 | final_sig = lpf.next(glue_2); 138 | 139 | return (final_sig+final_sig)>>3; 140 | 141 | } 142 | -------------------------------------------------------------------------------- /formantSynth/FormantSynth_classic.ino: -------------------------------------------------------------------------------- 1 | /* 2 | NOTES : 3 | - it sounds very distorted! 4 | -'O' is not recognizable 5 | */ 6 | 7 | Line aGain; 8 | 9 | Ead mainEnvelope_1(CONTROL_RATE); 10 | 11 | // Tables to be read 12 | Oscil aVoice_1(PHASOR256_DATA); 13 | Oscil aMod_1(SIN2048_DATA); 14 | 15 | // Band pass filter 16 | StateVariable bp_f1_1; //formant filters 17 | StateVariable bp_f2_1; // '' 18 | StateVariable bp_f3_1; // '' 19 | 20 | // Auto Maps 21 | //good to have it here, edit the proper and desired mapping 22 | AutoMap voiceMap_1(0,1023,0,100); 23 | AutoMap selMap_1(0,1023,0,100); 24 | AutoMap modMap_1(0,1023,0.0f,200.0f); 25 | 26 | AutoMap map_f1_1(0,1023,400,1000); 27 | AutoMap map_f2_1(0,1023,900,2000); 28 | 29 | // Values 30 | boolean triggered_1 = false; 31 | 32 | int mainEvelopeGain_1 = 0; //start at zero 33 | 34 | int f1_1, f2_1, f3_1; //formant filters freq 35 | 36 | int final_voice_1; 37 | 38 | int final_1; 39 | 40 | float intensity = 100.0; 41 | 42 | int soundSource; 43 | 44 | 45 | 46 | // set function 47 | void setFormantSynth_1() { 48 | 49 | //aVoice.setFreq(100); // to set 50 | 51 | } 52 | 53 | 54 | void updateFormantSynthControl_1(int sel_vowel_1, int voice_freq_1, float mod_freq_1, int trigger, int attack_main_1, int decay_main_1) { 55 | 56 | 57 | if (trigger == 1) { 58 | if (!triggered_1) { 59 | mainEnvelope_1.start(attack_main_1, decay_main_1); 60 | //vEnvelope.start(voice_attack, voice_decay); 61 | triggered_1 = true; 62 | } 63 | } else { 64 | triggered_1 = false; 65 | } 66 | 67 | //Select Scale 68 | //0 overtone - 1 pentatonic - 2 minor - 3 major - 4 arpeggio - 5 arab scale 69 | selectScale(5, voice_freq_1); 70 | 71 | //int freqVoice = voiceMap.next(voice_freq); //int voice_freq 72 | 73 | aVoice_1.setFreq(selScale());//voice_freq_1); 74 | 75 | mod_freq_1 = modMap_1.next(mod_freq_1); 76 | aMod_1.setFreq(mod_freq_1); 77 | 78 | 79 | /* 80 | //Modulation of the source - tremolo 81 | 82 | unsigned int vibrato = (128u + aMod_1.next())<<8;//(int)aMod_1.next(); 83 | aGain.set(vibrato, AUDIO_RATE / CONTROL_RATE); 84 | soundSource = (aVoice_1.next()*aGain.next())>>8; 85 | 86 | //put 'soundSource' instead of 'aVoice_1.next()' in 'updateAudio' 87 | */ 88 | 89 | int vowel_selection_1 = sel_vowel_1; 90 | 91 | switch(vowel_selection_1) { // sel_vowel 92 | 93 | //A 94 | case 0: 95 | f1_1 = 710; 96 | f2_1 = 1100; 97 | f3_1 = 2640; 98 | break; 99 | 100 | //E 101 | case 10: 102 | f1_1 = 550; 103 | f2_1 = 1770; 104 | f3_1 = 2490; 105 | break; 106 | 107 | //I 108 | case 20: 109 | f1_1 = 400; 110 | f2_1 = 1900; 111 | f3_1 = 2550; 112 | break; 113 | 114 | //O 115 | case 30: 116 | f1_1 = 440; 117 | f2_1 = 1000; 118 | f3_1 = 2250; 119 | break; 120 | 121 | //U 122 | case 40: 123 | f1_1 = 450; 124 | f2_1 = 1030; 125 | f3_1 = 2380; 126 | break; 127 | 128 | } 129 | 130 | 131 | 132 | mainEvelopeGain_1 = (int) mainEnvelope_1.next()>>3; 133 | 134 | bp_f1_1.setResonance(100); //resonance 100 135 | bp_f1_1.setCentreFreq(f1_1); //f1); 136 | 137 | bp_f2_1.setResonance(100); 138 | bp_f2_1.setCentreFreq(f2_1); //f2); 139 | 140 | bp_f3_1.setResonance(50); 141 | bp_f3_1.setCentreFreq(f3_1); //f3); 142 | 143 | //mainEvelopeGain_1 = (int) mainEnvelope_1.next()>>3; 144 | 145 | } 146 | 147 | 148 | int updateFormantSynthAudio_1() { 149 | 150 | //final = (bp_f1.next(aVoice.next()*0.1)+bp_f2.next(aVoice.next()*0.1)+bp_f3.next(aVoice.next()*0.1)); 151 | //final_1 = mainEvelopeGain_1*((bp_f1_1.next(aVoice_1.next()*0.1)+bp_f2_1.next(aVoice_1.next())*0.1+bp_f3_1.next(aVoice_1.next())*0.1)); 152 | int modular = aMod_1.next()>>8; 153 | final_1 = mainEvelopeGain_1*((((bp_f1_1.next(aVoice_1.next())*0.1)+bp_f2_1.next(aVoice_1.next())*0.1+bp_f3_1.next(aVoice_1.next())*0.1))*modular); 154 | //mainEvelopeGain_1*(bp_f1.next(aVoice.next()*0.1)+bp_f2.next(aVoice.next())*0.1); 155 | return final_1>>3;//* mainEvelopeGain; 156 | 157 | //return finalAmp(mainEvelopeGain, (bp_f1.next(aVoice.next())+bp_f2.next(aVoice.next())+bp_f3.next(aVoice.next()))>>1); 158 | 159 | } 160 | -------------------------------------------------------------------------------- /formantSynth/FormantSynth_dynFilter.ino: -------------------------------------------------------------------------------- 1 | /* 2 | NOTES : 3 | - it sounds very distorted! 4 | -'O' is not recognizable 5 | */ 6 | 7 | Ead mainEnvelope(CONTROL_RATE); 8 | 9 | // Tables to be read 10 | Oscil aVoice(PHASOR256_DATA); 11 | 12 | // Band pass filter 13 | StateVariable bp_f1; //formant filters 14 | StateVariable bp_f2; // * 15 | StateVariable bp_f3; // * 16 | 17 | // Auto Maps 18 | //good to have it here, edit the proper and desired mapping 19 | AutoMap voiceMap(0,1023,0,1000); 20 | AutoMap selMap(0,1023,0,100); 21 | 22 | AutoMap map_f1(0,1023,400,1000); 23 | AutoMap map_f2(0,1023,900,2000); 24 | 25 | // Values 26 | boolean triggered = false; 27 | 28 | int mainEvelopeGain = 0; //start at zero 29 | 30 | int f1, f2, f3; //formant filters freq 31 | 32 | int final_voice; 33 | 34 | int final; 35 | 36 | 37 | 38 | // set function 39 | void setFormantSynth() { 40 | 41 | //aVoice.setFreq(100); // to set 42 | 43 | 44 | } 45 | 46 | 47 | //removed : int voice_attack, int voice_decay, 48 | /* 49 | void updateFormantSynthControl(int sel_vowel, int voice_freq, int attack_main_2, int decay_main_2) { /*, //int 50 | int threshold_2, int trigger_2, 51 | int attack_main_2, int decay_main_2) {*/ 52 | 53 | /*if (trigger_2 > threshold_2) { 54 | if (!triggered_2) { 55 | mainEnvelope_2.start(attack_main_2, decay_main_2); 56 | //vEnvelope.start(voice_attack, voice_decay); 57 | triggered_2 = true; 58 | } 59 | } else { 60 | triggered_2 = false; 61 | } 62 | */ 63 | /* 64 | if (attack_main_2 = 1) { 65 | if (!triggered_2) { 66 | mainEnvelope_2.start(100, 1000); 67 | //vEnvelope.start(voice_attack, voice_decay); 68 | triggered_2 = true; 69 | } 70 | } else { 71 | triggered_2 = false; 72 | } 73 | 74 | //Serial.println(attack_main_2); 75 | 76 | //aInterpolate.set(voice_freq, AUDIO_STEPS_PER_CONTROL); 77 | 78 | //Q16n16 interpolatedFreq = aInterpolate.next(); 79 | 80 | //int freqVoice = voiceMap.next(interpolatedFreq); 81 | 82 | //mainEnvelope_2.start(attack_main_2, decay_main_2); 83 | 84 | int smoothedFreq = aSmooth.next(voice_freq); 85 | 86 | int freqVoice = voiceMap.next(smoothedFreq); //int voice_freq 87 | 88 | aVoice.setFreq(freqVoice); 89 | 90 | int vowel_selection = selMap.next(sel_vowel); 91 | 92 | switch(vowel_selection) { // sel_vowel 93 | 94 | //A 95 | case 0: 96 | f1 = 710; f2 = 1100; f3 = 2640; 97 | break; 98 | 99 | //E 100 | case 10: 101 | f1 = 550; f2 = 1770; f3 = 2490; 102 | break; 103 | 104 | //I 105 | case 20: 106 | f1 = 400; f2 = 1900; f3 = 2550; 107 | break; 108 | 109 | //O 110 | case 30: 111 | f1 = 440; f2 = 1000; f3 = 2250; 112 | break; 113 | 114 | //U 115 | case 40: 116 | f1 = 450; f2 = 1030; f3 = 2380; 117 | break; 118 | 119 | } 120 | 121 | 122 | bp_f1.setResonance(100); //resonance 100 123 | bp_f1.setCentreFreq(f1); //f1); 124 | 125 | bp_f2.setResonance(100); 126 | bp_f2.setCentreFreq(f2); //f2); 127 | 128 | bp_f3.setResonance(50); 129 | bp_f3.setCentreFreq(f3); //f3); 130 | 131 | 132 | mainEvelopeGain = (int) mainEnvelope_2.next()>>3; 133 | 134 | //final_voice = (bp_f1.next(aVoice.next())+bp_f2.next(aVoice.next())+bp_f3.next(aVoice.next()))>>8; 135 | 136 | } 137 | */ 138 | 139 | void updateFormantSynthControl(int voice_freq, int sel_f1, int sel_f2, int attack_main) { 140 | 141 | if (attack_main == 1) { 142 | if (!triggered) { 143 | mainEnvelope.start(100, 1000); 144 | //vEnvelope.start(voice_attack, voice_decay); 145 | triggered = true; 146 | } 147 | } else { 148 | triggered = false; 149 | } 150 | 151 | 152 | //int freqVoice = voiceMap.next(voice_freq); //int voice_freq 153 | 154 | aVoice.setFreq(voice_freq); 155 | 156 | f1 = map_f1.next(sel_f1); 157 | 158 | f2 = map_f2.next(sel_f2); 159 | 160 | 161 | bp_f1.setResonance(100); //resonance 100 162 | bp_f1.setCentreFreq(f1); //f1); 163 | 164 | bp_f2.setResonance(100); 165 | bp_f2.setCentreFreq(f2); //f2); 166 | 167 | //bp_f3.setResonance(50); 168 | //bp_f3.setCentreFreq(2500); //f3); 169 | 170 | mainEvelopeGain = (int) mainEnvelope.next(); 171 | 172 | } 173 | 174 | 175 | int updateFormantSynthAudio() { 176 | 177 | //final = (bp_f1.next(aVoice.next()*0.1)+bp_f2.next(aVoice.next()*0.1)+bp_f3.next(aVoice.next()*0.1)); 178 | final = mainEvelopeGain*(bp_f1.next(aVoice.next()*0.1)+bp_f2.next(aVoice.next())*0.1); 179 | return final;//* mainEvelopeGain; 180 | //return finalAmp(mainEvelopeGain, (bp_f1.next(aVoice.next())+bp_f2.next(aVoice.next())+bp_f3.next(aVoice.next()))>>1); 181 | 182 | } 183 | -------------------------------------------------------------------------------- /formantSynth/formantSynth.ino: -------------------------------------------------------------------------------- 1 | //------------------------------------------- 2 | 3 | //Formant Synth 4 | 5 | //connections: 6 | //button --> pin D4 (env) 7 | //Pot1 --> A1 (sel vowel) 8 | //Pot2 --> A2 (pitch) 9 | //Pot3 --> A3 (modulation/tremolo) 10 | 11 | //-------------------------------------------- 12 | 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | 27 | #include 28 | #include 29 | #include 30 | 31 | #define CONTROL_RATE 256 32 | 33 | const int PIN_0 = 0; // set freq 34 | const int PIN_1 = 1; // set the input for trigger 35 | const int PIN_2 = 2; 36 | const int PIN_3 = 3; 37 | const int PIN_4 = 4; 38 | const int PIN_5 = 5; 39 | 40 | const int GATE = 4; 41 | 42 | //Sensor values 43 | int pin0_val = 0; //int 44 | int pin1_val = 0; 45 | int pin2_val = 0; 46 | int pin3_val = 0; 47 | int pin4_val = 0; 48 | int pin5_val = 0; 49 | 50 | int button_in = 0; 51 | 52 | int byteSh = 0; //shift byte - audio final 53 | 54 | EventDelay kGainChangeDelay; 55 | 56 | int valu; 57 | 58 | void setup() { 59 | 60 | startMozzi(CONTROL_RATE); 61 | 62 | //setFormantSynth(); 63 | //setFormantSynth_1(); 64 | 65 | randSeed(); 66 | 67 | pinMode(GATE, INPUT); 68 | 69 | kGainChangeDelay.set(100); 70 | 71 | //Serial.begin(115200); 72 | } 73 | 74 | 75 | 76 | void updateControl() { 77 | 78 | pin1_val = mozziAnalogRead(PIN1); 79 | pin2_val = mozziAnalogRead(PIN2); 80 | pin3_val = mozziAnalogRead(PIN3); 81 | 82 | button_in = digitalRead(GATE); 83 | 84 | pin1_val = map(pin1_val, 0, 1023, 0, 50); 85 | 86 | //pin2_val = map(pin2_val, 0, 1023, 60, 220); 87 | 88 | if(kGainChangeDelay.ready()){ 89 | valu = rand(5); 90 | 91 | kGainChangeDelay.start(); 92 | } 93 | 94 | //updateFormantSynthControl(); 95 | updateFormantSynthControl_1(pin1_val, pin2_val, pin3_val, button_in, 10, 5000); 96 | 97 | 98 | //Serial.println(pin3_val); 99 | 100 | } 101 | 102 | int updateAudio() { 103 | 104 | //updateFormantSynthAudio(); 105 | updateFormantSynthAudio_1(); 106 | 107 | } 108 | 109 | 110 | void loop() { 111 | 112 | audioHook(); 113 | 114 | } 115 | -------------------------------------------------------------------------------- /formantSynth/scaleS.ino: -------------------------------------------------------------------------------- 1 | //---------------------- 2 | // Select Array : 3 | // 0 overtone series - 1 pentatonic - 2 minor - 3 major - 4 augmented arpeggio - 5 arab scale 4 | //---------------------- 5 | 6 | AutoMap mapFreq(0, 1023, 5, 100); 7 | AutoMap mapFT(0, 1023, 0, 12); 8 | AutoMap mapSet(0, 1023, 4, 64); 9 | 10 | int tuneArraySel; 11 | int tuneArrI; 12 | 13 | int selected_scale; 14 | 15 | 16 | 17 | void selectScale(int sel_array, float fundamental) { 18 | 19 | float tunedArray[6][13] = { 20 | 21 | {1, 1.285, 1.5, 1.75, 2, 2.25, 2.57, 2.8, 3, 3.11, 3.5, 3.857, 4}, // 0 overtone series 22 | {1, 1.166, 1.33, 1.5, 1.75, 2, 2.332, 2.66, 3.0, 3.5, 4, 4.664, 6}, // 1 pentatonic 23 | {1, 1.166, 1.5, 2, 2.33, 3.0, 4, 4.66, 6.0, 8, 9.33, 12, 16}, // 2 minor 24 | {1, 1.25, 1.5, 2, 2.5, 3.0, 4, 5.0, 6.0, 8, 10, 12, 16}, // 3 major 25 | {1, 1.25, 1.56, 2, 2.5, 3.12, 4, 5.0, 6.24, 8, 10, 12.48, 16 }, // 4 augmented arpeggio 26 | {1, 1.071, 1.25, 1.33, 1.5, 1.56, 1.890, 2.0, 2.142, 2.5, 2.66, 3.0, 3.12} // 5 hicaz - arab scale 27 | 28 | }; 29 | 30 | tuneArraySel = sel_array; 31 | 32 | fundamental = mapFreq(fundamental); 33 | 34 | tuneArrI = mapFT(fundamental); //tuning array index 35 | 36 | selected_scale = tunedArray[tuneArraySel][tuneArrI] * 44; //the fundamental 37 | 38 | } 39 | 40 | 41 | //retrun the pitch/scale 42 | 43 | int selScale() { 44 | 45 | return selected_scale; 46 | 47 | } 48 | 49 | -------------------------------------------------------------------------------- /percussive/percMod.ino: -------------------------------------------------------------------------------- 1 | 2 | Oscil bNoise (BROWNNOISE8192_DATA); 3 | Oscil bMod(COS2048_DATA); 4 | Oscil bCos(COS2048_DATA); 5 | 6 | StateVariable ntf; 7 | StateVariable hpf; 8 | 9 | Ead bPercEnv(CONTROL_RATE); 10 | Ead bPercFreqEnv(CONTROL_RATE); 11 | 12 | AutoMap mapFreq(0, 1023, 0.f, 400.f); //255 13 | AutoMap mapMod(0, 1023, 0.f, 100.f);//0, 4000) 14 | AutoMap mapMod2(0, 1023, 0.f, 100.f); 15 | 16 | boolean trigger = false; 17 | 18 | int genAmp; 19 | 20 | void updateControlPercussiVe(int freq_val, int filter_val, int filter_val2, int trigger_val, int attack_val, int decay_val) { 21 | 22 | if (trigger_val == 1) { 23 | if(!trigger) { 24 | bPercEnv.start(attack_val, decay_val); 25 | bPercFreqEnv.start(10, 1000); //10 1000 26 | trigger = true; 27 | } 28 | } else { 29 | trigger = false; 30 | } 31 | 32 | hpf.setResonance(10); 33 | filter_val2 = mapMod2.next(filter_val2); 34 | hpf.setCentreFreq(filter_val2); 35 | 36 | freq_val = mapFreq.next(freq_val); 37 | //bNoise.setFreq((int)bPercFreqEnv.next()+freq_val); 38 | bNoise.setFreq((genAmp)+freq_val);//bNoise.setFreq((genAmp*2)*70); 39 | 40 | ntf.setResonance(70); 41 | filter_val = mapMod.next(filter_val); 42 | bMod.setFreq(filter_val); 43 | ntf.setCentreFreq((int)bMod.next());//filter_val); 44 | 45 | genAmp = (int)bPercEnv.next()>>2; 46 | 47 | } 48 | 49 | 50 | int updateAudioPercussiVe() { 51 | 52 | //return genAmp*(ntf.next(bNoise.next())>>3); //(ntf.next(bNoise.next()+bNoise.next()))*bPercEnv.next(); 53 | return genAmp*(ntf.next(hpf.next(bNoise.next()))>>8);//bNoise.next())>>8); 54 | } 55 | -------------------------------------------------------------------------------- /percussive/percMod_2.ino: -------------------------------------------------------------------------------- 1 | Oscil bCos_1(COS2048_DATA); 2 | Oscil bMod_1(COS2048_DATA); 3 | 4 | 5 | LowPassFilter lpf; 6 | 7 | Ead bPercEnv_1(CONTROL_RATE); 8 | Ead bPercFreqEnv_1(CONTROL_RATE); 9 | 10 | AutoMap mapFreq_1(0, 1023, 0.f, 400.f); //255 11 | AutoMap mapMod_1(0, 1023, 0.f, 100.f);//0, 4000) 12 | AutoMap mapMod2_1(0, 1023, 0.f, 100.f); 13 | 14 | boolean trigger_1 = false; 15 | 16 | int genAmp_1; 17 | 18 | void updateControlPercussiVe_1(int freq_val_1, int filter_val_1, int filter_val2_1, int trigger_val_1, int attack_val_1, int decay_val_1) { 19 | 20 | if (trigger_val_1 == 1) { 21 | if(!trigger_1) { 22 | bPercEnv_1.start(attack_val_1, decay_val_1); 23 | bPercFreqEnv_1.start(10, 2000); //10 1000 24 | trigger_1 = true; 25 | } 26 | } else { 27 | trigger_1 = false; 28 | } 29 | 30 | filter_val_1 = mapMod.next(filter_val_1); 31 | bMod_1.setFreq(filter_val_1); 32 | 33 | freq_val_1 = mapFreq_1.next(freq_val_1); 34 | //bNoise.setFreq((int)bPercFreqEnv.next()+freq_val); 35 | bCos_1.setFreq(freq_val_1);//bNoise.setFreq((genAmp*2)*70); 36 | 37 | lpf.setResonance(50); 38 | lpf.setCutoffFreq(bPercFreqEnv_1.next()*bMod_1.next());//filter_val); 39 | 40 | genAmp_1 = (int)bPercEnv_1.next(); 41 | 42 | } 43 | 44 | 45 | int updateAudioPercussiVe_1() { 46 | 47 | //return genAmp*(ntf.next(bNoise.next())>>3); //(ntf.next(bNoise.next()+bNoise.next()))*bPercEnv.next(); 48 | //return genAmp*(ntf.next(hpf.next(bNoise.next()))>>8);//bNoise.next())>>8); 49 | return genAmp_1*(lpf.next(bCos_1.next())>>8); 50 | } 51 | -------------------------------------------------------------------------------- /percussive/percussive.ino: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #include 15 | #include 16 | 17 | #define CONTROL_RATE 64 18 | 19 | // Analog in 20 | const int pin_1 = 1; 21 | const int pin_2 = 2; 22 | const int pin_3 = 3; 23 | 24 | // Digital in/out 25 | const int button_4 = 4; 26 | 27 | // Sensor values 28 | int val_1 = 0; 29 | int val_2 = 0; 30 | int val_3 = 0; 31 | 32 | // 33 | int buttonVal_4 = 0; 34 | 35 | 36 | void setup() { 37 | 38 | startMozzi(CONTROL_RATE); 39 | 40 | pinMode(button_4, INPUT); 41 | 42 | //Serial.begin(115200); 43 | 44 | } 45 | 46 | void loop() { 47 | 48 | audioHook(); 49 | 50 | } 51 | 52 | void updateControl() { 53 | 54 | val_1 = mozziAnalogRead(pin_1); 55 | val_2 = mozziAnalogRead(pin_2); 56 | val_3 = mozziAnalogRead(pin_3); 57 | 58 | buttonVal_4 = digitalRead(button_4); 59 | 60 | //updateControlPercussiVe(val_1, val_2, val_3, buttonVal_4, 10, 2000); //2000 61 | //attack 100 dec 10 - freqEnv at 10 dec 1000 more close noisy 62 | // 10 2000 - 10 1000 63 | 64 | updateControlPercussiVe_1(val_1, val_2, val_3, buttonVal_4, 10, 2000); 65 | 66 | //Serial.println(); 67 | 68 | } 69 | 70 | int updateAudio() { 71 | 72 | //updateAudioPercussiVe(); 73 | updateAudioPercussiVe_1(); 74 | 75 | } 76 | -------------------------------------------------------------------------------- /rhythm_/rhythm_.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #include 12 | #include 13 | 14 | Oscil aCos (COS2048_DATA); 15 | Oscil aTri (TRIANGLE2048_DATA); 16 | 17 | LowPassFilter lpf; 18 | 19 | const char NUM_SAMPLES = 5; 20 | 21 | const int PIN_1 = 1; 22 | const int PIN_2 = 2; 23 | const int PIN_3 = 3; 24 | const int PIN_5 = 5; 25 | 26 | const int pin13 = 13; 27 | const int PIN_4 = 4; 28 | 29 | int valo_1 = 0; 30 | int valo_2 = 0; 31 | int valo_3 = 0; //float valo_3 = 0; 32 | int valo_5 = 0; 33 | 34 | AutoMap mapVal1(0, 1023, 0, 500); 35 | AutoMap mapVal2(0, 1023, 0, 500); 36 | AutoMap mapVal3(0, 1023, 0, 400);//mapVal3(0, 1023, 0.f, 6000.f); 37 | AutoMap mapVal5(0, 1023, 0, 255); 38 | 39 | Metronome kMetro(800); // enough delay so samples don't overlap, because the load would be too much 40 | 41 | int aFreq = 0; 42 | int bFreq = 0; 43 | 44 | void setup() { 45 | 46 | startMozzi(); 47 | 48 | Serial.begin(115200); 49 | 50 | pinMode(pin13, OUTPUT); 51 | 52 | lpf.setResonance(150); 53 | 54 | } 55 | 56 | 57 | 58 | void updateControl(){ 59 | 60 | static unsigned int counter; 61 | 62 | float valo_3 = mozziAnalogRead(PIN_3); 63 | int val_4 = digitalRead(PIN_4); 64 | valo_3 = mapVal3.next(valo_3); 65 | 66 | /*if (valo_3 > 100){ 67 | kMetro.setBPM(10.f); 68 | } if (valo_3 < 350) { 69 | kMetro.setBPM(100.f); 70 | }*/ 71 | 72 | counter++; 73 | 74 | if (val_4==0){ 75 | kMetro.setBPM(250+valo_3); 76 | } if (val_4==1) { 77 | kMetro.setBPM(550-(valo_3)); 78 | } 79 | 80 | 81 | 82 | int valo_1 = mozziAnalogRead(PIN_1); 83 | int valo_2 = mozziAnalogRead(PIN_2); 84 | 85 | int valo_5 = mozziAnalogRead(PIN_5); 86 | valo_5 = mapVal5.next(valo_5); 87 | 88 | lpf.setCutoffFreq(valo_5); 89 | 90 | valo_1 = mapVal1.next(valo_1); 91 | valo_2 = mapVal2.next(valo_2); 92 | 93 | if (counter==120) { 94 | //if (counter==val_4) 95 | //if(valo_1>100) //if(counter==valo_1) 96 | kMetro.stop(); 97 | digitalWrite(pin13, LOW); 98 | 99 | } 100 | if(counter==133) { 101 | //if(counter==val_4) 102 | //if(valo_2<300)//if(counter==valo_2) 103 | 104 | kMetro.start(); 105 | counter = 0; 106 | digitalWrite(pin13, HIGH); 107 | 108 | } 109 | 110 | 111 | 112 | //Serial.println(counter); 113 | //Serial.print("-"); 114 | Serial.println(counter); 115 | 116 | if(kMetro.ready()) { 117 | 118 | switch(rand(NUM_SAMPLES)) { 119 | 120 | case 0: 121 | aFreq = 350+valo_1; 122 | bFreq = 0; 123 | break; 124 | 125 | case 1: 126 | aFreq = 85; 127 | bFreq = 100; 128 | break; 129 | 130 | case 2: 131 | aFreq = 220; 132 | bFreq = 0; 133 | break; 134 | 135 | case 3: 136 | aFreq = 100+valo_1; 137 | bFreq = 220; 138 | break; 139 | 140 | case 4: 141 | aFreq = 300; 142 | bFreq = 0; 143 | break; 144 | } 145 | } 146 | 147 | aCos.setFreq(aFreq); 148 | aTri.setFreq(bFreq); 149 | 150 | } 151 | 152 | 153 | int updateAudio(){ 154 | int asig = (int) 155 | lpf.next(aCos.next()+aTri.next()); 156 | return asig; 157 | } 158 | 159 | 160 | void loop() { 161 | audioHook(); 162 | } 163 | -------------------------------------------------------------------------------- /rhythm_autonomous/rhythm_autonomous.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #include 12 | #include 13 | 14 | Oscil aCos (COS2048_DATA); 15 | Oscil aTri (TRIANGLE2048_DATA); 16 | 17 | LowPassFilter lpf; 18 | 19 | const char NUM_SAMPLES = 5; 20 | 21 | //const int PIN_1 = 1; 22 | //const int PIN_2 = 2; 23 | const int PIN_3 = 1; 24 | //const int PIN_5 = 5; 25 | 26 | const int pin13 = 13; 27 | //const int PIN_4 = 4; 28 | 29 | int valo_1 = 100; 30 | int valo_2 = 200; 31 | int valo_3 = 300; //float valo_3 = 0; 32 | int valo_5 = 100; 33 | 34 | AutoMap mapVal1(0, 1023, 0, 500); 35 | AutoMap mapVal2(0, 1023, 0, 500); 36 | AutoMap mapVal3(0, 1023, 0, 400);//mapVal3(0, 1023, 0.f, 6000.f); 37 | AutoMap mapVal5(0, 1023, 0, 255); 38 | 39 | Metronome kMetro(800); // enough delay so samples don't overlap, because the load would be too much 40 | 41 | int aFreq = 0; 42 | int bFreq = 0; 43 | 44 | void setup() { 45 | 46 | startMozzi(); 47 | 48 | Serial.begin(115200); 49 | 50 | pinMode(pin13, OUTPUT); 51 | 52 | lpf.setResonance(150); 53 | 54 | } 55 | 56 | 57 | 58 | void updateControl(){ 59 | 60 | static unsigned int counter; 61 | 62 | float valo_3 = mozziAnalogRead(PIN_3); 63 | //int val_4 = digitalRead(PIN_4); 64 | valo_3 = mapVal3.next(valo_3); 65 | 66 | /*if (valo_3 > 100){ 67 | kMetro.setBPM(10.f); 68 | } if (valo_3 < 350) { 69 | kMetro.setBPM(100.f); 70 | }*/ 71 | 72 | counter++; 73 | 74 | if (valo_3 > 250){ 75 | kMetro.setBPM(250+valo_3); 76 | } else {//(val_4==1) { 77 | kMetro.setBPM(550-(valo_3)); 78 | } 79 | 80 | 81 | 82 | //int valo_1 = mozziAnalogRead(PIN_1); 83 | //int valo_2 = mozziAnalogRead(PIN_2); 84 | 85 | //int valo_5 = mozziAnalogRead(PIN_5); 86 | //valo_5 = mapVal5.next(valo_5); 87 | 88 | lpf.setCutoffFreq(valo_5); 89 | 90 | //valo_1 = mapVal1.next(valo_1); 91 | //valo_2 = mapVal2.next(valo_2); 92 | 93 | if (counter==120) { 94 | //if (counter==val_4) 95 | //if(valo_1>100) //if(counter==valo_1) 96 | kMetro.stop(); 97 | digitalWrite(pin13, LOW); 98 | 99 | } 100 | if(counter==133) { 101 | //if(counter==val_4) 102 | //if(valo_2<300)//if(counter==valo_2) 103 | 104 | kMetro.start(); 105 | counter = 0; 106 | digitalWrite(pin13, HIGH); 107 | 108 | } 109 | 110 | 111 | 112 | //Serial.println(counter); 113 | //Serial.print("-"); 114 | Serial.println(counter); 115 | 116 | if(kMetro.ready()) { 117 | 118 | switch(rand(NUM_SAMPLES)) { 119 | 120 | case 0: 121 | aFreq = 350+valo_1; 122 | bFreq = 0; 123 | break; 124 | 125 | case 1: 126 | aFreq = 85; 127 | bFreq = 100; 128 | break; 129 | 130 | case 2: 131 | aFreq = 220; 132 | bFreq = 0; 133 | break; 134 | 135 | case 3: 136 | aFreq = 100+valo_1; 137 | bFreq = 220; 138 | break; 139 | 140 | case 4: 141 | aFreq = 300; 142 | bFreq = 0; 143 | break; 144 | } 145 | } 146 | 147 | aCos.setFreq(aFreq); 148 | aTri.setFreq(bFreq); 149 | 150 | } 151 | 152 | 153 | int updateAudio(){ 154 | int asig = (int) 155 | lpf.next(aCos.next()+aTri.next())*2; 156 | return asig>>8; 157 | } 158 | 159 | 160 | void loop() { 161 | audioHook(); 162 | } 163 | -------------------------------------------------------------------------------- /simil_Brass/model.ino: -------------------------------------------------------------------------------- 1 | // Tables to be read 2 | Oscil aTr(PHASOR256_DATA); 3 | Oscil aMod(COS2048_DATA); 4 | 5 | LowPassFilter lpf; 6 | 7 | AutoMap mapPitch(0, 1023, 0, 1000); 8 | AutoMap mapPitch_1(0, 1023, 0, 2000); 9 | 10 | Ead envelope(CONTROL_RATE); 11 | 12 | Q24n8 pitch_f; 13 | 14 | int gain, modGain; 15 | 16 | boolean trigg = false; 17 | 18 | 19 | void modelControl(int pitch_val, int pitch_val_1, int duration, int attack, int checkThis) { 20 | 21 | pitch_val = mapPitch.next(pitch_val); 22 | pitch_val_1 = mapPitch_1.next(pitch_val); 23 | 24 | //Q16n16 note_pitch = float_to_Q16n16(pitch_val); 25 | //Q16n16 midi_note = note_pitch; 26 | //pitch_f = Q16n16_to_Q24n8(Q16n16_mtof(midi_note)); 27 | 28 | aTr.setFreq(pitch_val+1); //_Q24n8(pitch_f); 29 | aMod.setFreq(pitch_val); //_Q24n8(pitch_f); 30 | 31 | if(pitch_val > 10) { 32 | if(!trigg) { 33 | int decay = duration - attack; 34 | envelope.start(attack,decay); 35 | trigg = true; 36 | } else { 37 | trigg = false; 38 | } 39 | } 40 | 41 | //gain = (int)envelope.next(); 42 | 43 | modGain = aMod.next(); 44 | 45 | lpf.setResonance(100); 46 | lpf.setCutoffFreq(modGain); 47 | 48 | 49 | } 50 | 51 | int modelAudio() { 52 | 53 | //long signal = aTr.next(); 54 | return lpf.next(aTr.next());//(gain*(lpf.next(aTr.next())>>8)); //without gain* lpf.next(aTr.next()) 55 | //envelope.next()*(aMod.next()+aMod.next());//modGain; 56 | //lpf.next(signal)>>3; 57 | 58 | } 59 | -------------------------------------------------------------------------------- /simil_Brass/simil_Brass.ino: -------------------------------------------------------------------------------- 1 | //A sort of brass-like sound 2 | //---------------------------- 3 | //sensors: 4 | // pot 1 (optional pot 2) 5 | //----------------------- 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | 22 | #include 23 | #include 24 | 25 | #define CONTROL_RATE 256 26 | 27 | const int PIN_0 = 0; // set freq 28 | const int PIN_1 = 1; // set the input for trigger 29 | const int PIN_2 = 2; 30 | const int PIN_3 = 3; 31 | const int PIN_4 = 4; 32 | const int PIN_5 = 5; 33 | 34 | const int GATE = 4; 35 | 36 | //Sensor values 37 | int pin0_val = 0; //int 38 | int pin1_val = 0; 39 | int pin2_val = 0; 40 | int pin3_val = 0; 41 | int pin4_val = 0; 42 | int pin5_val = 0; 43 | 44 | int button_in = 0; 45 | 46 | int byteSh = 0; //shift byte - audio final 47 | 48 | EventDelay kGainChangeDelay; 49 | 50 | int valu; 51 | 52 | 53 | 54 | void setup() { 55 | 56 | startMozzi(CONTROL_RATE); 57 | 58 | pinMode(GATE, INPUT); 59 | 60 | Serial.begin(115200); 61 | 62 | } 63 | 64 | 65 | 66 | void loop() { 67 | 68 | audioHook(); 69 | 70 | } 71 | 72 | 73 | void updateControl() { 74 | 75 | button_in = digitalRead(GATE); 76 | 77 | pin1_val = mozziAnalogRead(PIN_1); 78 | 79 | pin2_val = mozziAnalogRead(PIN_2); 80 | 81 | Serial.println(button_in); 82 | 83 | modelControl(pin1_val, pin2_val, 800, 10, button_in); 84 | 85 | 86 | } 87 | 88 | int updateAudio() { 89 | 90 | modelAudio(); 91 | 92 | } 93 | 94 | 95 | -------------------------------------------------------------------------------- /simil_water/simil_water.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #define CONTROL_RATE 64 13 | 14 | Oscil aCos (COS2048_DATA); 15 | 16 | StateVariable bp1; 17 | StateVariable bp2; 18 | StateVariable bp3; 19 | 20 | Ead env_1(CONTROL_RATE); 21 | 22 | AutoMap mapModVal(0, 1023, 0, 255); 23 | 24 | const int pin_1 = 1; 25 | const int pin_2 = 2; 26 | const int pin_3 = 3; 27 | 28 | const int pin_4 = 4; 29 | 30 | int val_1 = 0; 31 | int val_2 = 0; 32 | int val_3 = 0; 33 | int valou = 0; 34 | int b_val = 0; 35 | 36 | boolean triggered = false; 37 | 38 | int finalSign; 39 | 40 | 41 | void setup() { 42 | 43 | startMozzi(CONTROL_RATE); 44 | randSeed(); 45 | //Serial.begin(115200); 46 | 47 | } 48 | 49 | 50 | void loop() { 51 | 52 | audioHook(); 53 | 54 | } 55 | 56 | void updateControl() { 57 | 58 | val_1 = mozziAnalogRead(pin_1); 59 | b_val = digitalRead(pin_4); 60 | 61 | val_2 = mozziAnalogRead(pin_2); 62 | val_3 = mozziAnalogRead(pin_3); 63 | 64 | val_2 = map(val_2, 0, 1023, 0, 100); 65 | val_3 = map(val_3, 0, 1023, 0, 1000); 66 | 67 | int freqVal = rand(1600); 68 | aCos.setFreq((freqVal+800)*val_2); 69 | 70 | bp1.setResonance(30); 71 | bp1.setCentreFreq(val_2);//(2200); 72 | bp2.setResonance(30); 73 | bp2.setCentreFreq(val_3);//(3300); 74 | 75 | } 76 | 77 | int updateAudio() { 78 | 79 | return bp2.next(aCos.next()); 80 | 81 | } 82 | 83 | 84 | -------------------------------------------------------------------------------- /triggerNoisePulse_simple/triggerNoisePulse_simple.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include // wavetable 4 | #include // wavetable 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #define CONTROL_RATE 64 13 | 14 | Oscil wNoise (WHITENOISE8192_DATA); 15 | Oscil pHasor (PHASOR256_DATA); 16 | Oscil kFreq(COS2048_DATA); 17 | Oscil oscL(COS2048_DATA); 18 | 19 | StateVariable hip; 20 | StateVariable bp1; 21 | StateVariable bp2; 22 | StateVariable bp3; 23 | StateVariable bp4; 24 | StateVariable bp5; 25 | 26 | Ead envPh(CONTROL_RATE); 27 | Ead envVol(CONTROL_RATE); 28 | 29 | AutoMap mapModVal(0, 1023, 0, 255); 30 | 31 | AudioDelay <256> aDel; 32 | int del_samps; 33 | 34 | const int pin_1 = 1; 35 | const int pin_2 = 2; 36 | const int pin_3 = 3; 37 | 38 | const int pin_4 = 4; 39 | 40 | int val_1 = 0; 41 | int val_2 = 0; 42 | int val_3 = 0; 43 | 44 | int valou = 0; 45 | 46 | int b_val = 0; 47 | 48 | boolean triggered = false; 49 | 50 | int finalSig; 51 | 52 | int harmFiltered; 53 | 54 | int noiseFiltered; 55 | 56 | int noiseSignal; 57 | 58 | int modul; 59 | 60 | 61 | void setup() { 62 | 63 | startMozzi(CONTROL_RATE); 64 | Serial.begin(115200); 65 | kFreq.setFreq(.63f); 66 | 67 | } 68 | 69 | 70 | void loop() { 71 | 72 | audioHook(); 73 | 74 | } 75 | 76 | void updateControl() { 77 | 78 | val_1 = mozziAnalogRead(pin_1); 79 | b_val = digitalRead(pin_4); 80 | 81 | val_2 = mozziAnalogRead(pin_2); 82 | val_3 = mozziAnalogRead(pin_3); 83 | 84 | valou = mozziAnalogRead(pin_3); 85 | 86 | val_2 = map(val_2, 0, 1023, 0, 1000); 87 | val_3 = map(val_3, 0, 1023, 0, 1000); 88 | 89 | Serial.println(val_2); 90 | 91 | //controlProcess(val_1, b_val, 10, 100, 10, 100); 92 | 93 | if(b_val == 1) { 94 | if (!triggered) { 95 | envPh.start(10, 1000); 96 | envVol.start(100, 10); 97 | triggered = true; 98 | } else { 99 | triggered = false; 100 | } 101 | } 102 | 103 | /// 104 | 105 | wNoise.setFreq(1000); 106 | 107 | hip.setResonance(150); //fix 108 | hip.setCentreFreq(val_2);//(100); //fix 109 | 110 | bp1.setResonance(30); 111 | bp1.setCentreFreq(val_3+200);//(2200); 112 | bp2.setResonance(30); 113 | bp2.setCentreFreq(val_3+1200);//(3300); 114 | bp3.setResonance(30); 115 | bp3.setCentreFreq(val_3+2200);//(4200); 116 | bp4.setResonance(30); 117 | bp4.setCentreFreq(val_3+3200);//(6500); 118 | bp5.setResonance(30); 119 | bp5.setCentreFreq(val_3+4200);//(9600); 120 | 121 | noiseFiltered = hip.next(wNoise.next()); //hip.next(wNoise.next()); 122 | 123 | //harmFiltered = bp1.next(noiseFiltered)+ bp2.next(noiseFiltered);//*0.1 + bp3.next(noiseFiltered)*0.1 + bp4.next(noiseFiltered)*0.1 + bp5.next(noiseFiltered)*0.1); 124 | 125 | int firstEnvelope = (int)envVol.next(); 126 | 127 | noiseSignal = (noiseFiltered*firstEnvelope)>>6; 128 | //noiseSignal = (wNoise.next()*firstEnvelope)>>6;//harmFiltered * firstEnvelope; 129 | 130 | int modVal_1 = mapModVal.next(val_1); 131 | 132 | int freqEnv = (int)(envPh.next()*(modVal_1)); 133 | 134 | pHasor.setFreq((float)freqEnv); 135 | 136 | //// 137 | 138 | modul = pHasor.phMod(noiseSignal);//(int)(noiseSignal>>3)*(pHasor.next()>>3); 139 | 140 | finalSig = modul * envPh.next(); 141 | 142 | del_samps = 128+kFreq.next(); 143 | 144 | } 145 | 146 | int updateAudio() { 147 | 148 | //audioProcess(); 149 | 150 | //return finalSig; 151 | 152 | return aDel.next(modul, del_samps); 153 | 154 | 155 | } 156 | 157 | 158 | //void controlProcess(int modVal, int trigEnv, int attack_a, int decay_a, int attack_b, int decay_b) { 159 | 160 | //// 161 | /* 162 | if(trigEnv == 1) { 163 | if (!triggered) { 164 | envPh.start(attack_b, decay_b); 165 | envVol.start(attack_a, decay_a); 166 | triggered = true; 167 | } else { 168 | triggered = false; 169 | } 170 | } 171 | 172 | /// 173 | 174 | wNoise.setFreq(220); 175 | 176 | hip.setResonance(100); //fix 177 | hip.setCentreFreq(1000); //fix 178 | 179 | bp1.setResonance(30); 180 | bp1.setCentreFreq(2200); 181 | bp2.setResonance(30); 182 | bp2.setCentreFreq(3300); 183 | bp3.setResonance(30); 184 | bp3.setCentreFreq(4200); 185 | bp4.setResonance(30); 186 | bp4.setCentreFreq(6500); 187 | bp5.setResonance(30); 188 | bp5.setCentreFreq(9600); 189 | 190 | int noiseFiltered = hip.next(wNoise.next()); 191 | 192 | int harmFiltered = bp1.next(noiseFiltered) + bp2.next(noiseFiltered) + bp3.next(noiseFiltered) + bp4.next(noiseFiltered) + bp5.next(noiseFiltered); 193 | 194 | envVol.start(attack_a, decay_a); 195 | 196 | int firstEnvelope = (int) envVol.next(); 197 | 198 | int noiseSignal = harmFiltered * firstEnvelope; 199 | 200 | 201 | int modVal_1 = mapModVal.next(modVal); 202 | 203 | 204 | int freqEnv = (int)(envPh.next()*(modVal_1)); 205 | 206 | 207 | pHasor.setFreq((float)freqEnv); 208 | 209 | //// 210 | 211 | 212 | int modul = noiseSignal*pHasor.next(); 213 | 214 | finalSig = modul * envPh.next(); 215 | */ 216 | 217 | //} 218 | 219 | /* 220 | int audioProcess() { 221 | 222 | return finalSig; 223 | 224 | } 225 | */ 226 | --------------------------------------------------------------------------------