From e9f52fb210062c77d51433196541e6258a974fdf Mon Sep 17 00:00:00 2001 From: gfvalvo Date: Tue, 15 Jan 2019 21:56:23 -0500 Subject: [PATCH] First Commit --- Tone_Shift.ino | 207 +++++++++++++++++++++++++++++++++++++++++++++ mod-delay-gain.cpp | 141 ++++++++++++++++++++++++++++++ mod-delay-gain.h | 91 ++++++++++++++++++++ 3 files changed, 439 insertions(+) create mode 100644 Tone_Shift.ino create mode 100644 mod-delay-gain.cpp create mode 100644 mod-delay-gain.h diff --git a/Tone_Shift.ino b/Tone_Shift.ino new file mode 100644 index 0000000..d486b5a --- /dev/null +++ b/Tone_Shift.ino @@ -0,0 +1,207 @@ +#include +#include "mod-delay-gain.h" +#include "NewEncoder.h" + +void configureShift(void), setOutputMix(void); + +const int8_t minToneShift = -50; +const int8_t maxToneShift = 50; +const uint8_t shiftEncoderPinA = 2; +const uint8_t shiftEncoderPinB = 3; + +const int8_t minOutputMix = 0; +const int8_t maxOutputMix = 25; +const uint8_t mixEncoderPinA = 4; +const uint8_t mixEncoderPinB = 5; + +const uint16_t overlap = 16; // Overlap between complementry delay ramps +const uint16_t rampLength = 128 + overlap; +const uint16_t waveformSize = 256; +const int32_t delayBufferLength = 4500; + +int16_t rampDown[waveformSize], rampUp[waveformSize], window[waveformSize]; +int16_t delayBuf1[delayBufferLength]; +int16_t delayBuf2[delayBufferLength]; +int16_t *currentRamp = rampDown; +float modFreq = 0.0, outputMix = 0.0; + +NewEncoder toneShiftEncoder(shiftEncoderPinA, shiftEncoderPinB, minToneShift, maxToneShift, 0); +NewEncoder mixingEncoder(mixEncoderPinA, mixEncoderPinB, minOutputMix, maxOutputMix, 0); + +AudioInputI2S i2sIn; //xy=82,429 +AudioMixer4 inputGain; //xy=282,475 + +AudioSynthWaveform delaySweep1; //xy=261,323 +AudioSynthWaveform envelope1; //xy=268,375 +AudioSynthWaveform delaySweep2; //xy=289,539 +AudioSynthWaveform envelope2; //xy=301,590 + +AudioEffectModDelayGain modulatedDelay1; //xy=511,329 +AudioEffectModDelayGain modulatedDelay2; //xy=515,547 + +AudioMixer4 outputMixer; //xy=752,420 +AudioOutputI2S i2sOut; //xy=973,422 +AudioAnalyzeRMS outputLevel; //xy=989,475 + +AudioConnection patchCord1(i2sIn, 0, inputGain, 0); +AudioConnection patchCord2(inputGain, 0, outputMixer, 2); + +AudioConnection patchCord5(inputGain, 0, modulatedDelay1, 0); +AudioConnection patchCord3(delaySweep1, 0, modulatedDelay1, 1); +AudioConnection patchCord4(envelope1, 0, modulatedDelay1, 2); + +AudioConnection patchCord6(inputGain, 0, modulatedDelay2, 0); +AudioConnection patchCord7(delaySweep2, 0, modulatedDelay2, 1); +AudioConnection patchCord8(envelope2, 0, modulatedDelay2, 2); + +AudioConnection patchCord9(modulatedDelay1, 0, outputMixer, 0); +AudioConnection patchCord10(modulatedDelay2, 0, outputMixer, 1); + +AudioConnection patchCord11(outputMixer, 0, i2sOut, 0); +AudioConnection patchCord12(outputMixer, 0, i2sOut, 1); +AudioConnection patchCord13(outputMixer, outputLevel); + +void setup() { + double decrement, increment, delayValue, windowValue; + uint16_t index1, temp1; + + Serial.begin(115200); + delay(2000); + Serial.println("Starting"); + + if (!toneShiftEncoder.begin()) { + Serial.println( + F("Tone Shift Encoder failed to initialize. Check pin assignments and available interrupts. Aborting")); + while (1) { + } + } + + if (!mixingEncoder.begin()) { + Serial.println( + F("Mixing Encoder failed to initialize. Check pin assignments and available interrupts. Aborting")); + while (1) { + } + } + + AudioNoInterrupts(); + AudioMemory(20); + + // create the arrays to ramp delay value + decrement = (double) 32767.0 / (double) (rampLength - 1); + delayValue = 32767.0; + for (index1 = 0; index1 < rampLength; index1++) { + rampDown[index1] = (delayValue + 0.5 > 0) ? delayValue + 0.5 : 0; + rampUp[index1] = 32767 - rampDown[index1]; + delayValue -= decrement; + } + //for (; index1 < 256; index1++) { + for (; index1 < waveformSize; index1++) { + rampDown[index1] = 0; + rampUp[index1] = 32767; + } + + // create the amplitude window array + increment = 1.0 / (double) (overlap - 1); + windowValue = 0.0; + //for (index1 = 127; index1 < 256; index1++) { + for (index1 = 0; index1 < waveformSize; index1++) { + window[index1] = 0; + } + for (index1 = 0; index1 < overlap; index1++) { + temp1 = sqrt(windowValue) * 32767 + 0.5; + temp1 = (temp1 < 32768) ? temp1 : 32767; + window[index1] = temp1; + //window[127 + overlap - index1] = temp1; + window[waveformSize / 2 - 1 + overlap - index1] = temp1; + windowValue += increment; + } + //for (; index1 <= 127; index1++) { + for (; index1 < waveformSize / 2; index1++) { + window[index1] = 32767; + } + + modulatedDelay1.setbuf(delayBufferLength, delayBuf1); + modulatedDelay2.setbuf(delayBufferLength, delayBuf2); + + //outputMixer.gain(0, 1.0); + //outputMixer.gain(1, 1.0); + //outputMixer.gain(2, 0.0); + outputMixer.gain(3, 0.0); + setOutputMix(); + + inputGain.gain(0, 5.0); + inputGain.gain(1, 0.0); + inputGain.gain(2, 0.0); + inputGain.gain(3, 0.0); + + configureShift(); +} + +void loop() { + static elapsedMillis fps; + static int16_t lastToneShiftDecoderPosition = -5000; + static int16_t lastMixDecoderPosition = -5000; + int16_t currentDecoderPosition; + + if (fps > 24) { + if (outputLevel.available()) { + fps = 0; + int monoPeak = outputLevel.read() * 30.0; + Serial.print("|"); + for (int cnt = 0; cnt < monoPeak; cnt++) { + Serial.print(">"); + } + Serial.println(); + } + } + + currentDecoderPosition = toneShiftEncoder; + if (currentDecoderPosition != lastToneShiftDecoderPosition) { + lastToneShiftDecoderPosition = currentDecoderPosition; + Serial.print("New Tone Shift Position = "); + Serial.println(currentDecoderPosition); + if (currentDecoderPosition >= 0) { + modFreq = 5.0 * currentDecoderPosition / maxToneShift; + currentRamp = rampDown; + } else { + modFreq = 2.5 * currentDecoderPosition / minToneShift; + currentRamp = rampUp; + } + configureShift(); + } + + currentDecoderPosition = mixingEncoder; + if (currentDecoderPosition != lastMixDecoderPosition) { + lastMixDecoderPosition = currentDecoderPosition; + Serial.print("New Mix Position = "); + Serial.print(currentDecoderPosition); + outputMix = (float) currentDecoderPosition / (maxOutputMix - minOutputMix) + minOutputMix; + Serial.print(" ----> "); + Serial.println(outputMix); + setOutputMix(); + } +} + +void configureShift() { + AudioNoInterrupts(); + + delaySweep1.begin(1, modFreq, WAVEFORM_ARBITRARY); + delaySweep1.arbitraryWaveform(currentRamp, 100); + delaySweep2.begin(1, modFreq, WAVEFORM_ARBITRARY); + delaySweep2.arbitraryWaveform(currentRamp, 100); + delaySweep2.phase(180.0); + + envelope1.begin(1, modFreq, WAVEFORM_ARBITRARY); + envelope1.arbitraryWaveform(window, 100); + envelope2.begin(1, modFreq, WAVEFORM_ARBITRARY); + envelope2.arbitraryWaveform(window, 100); + envelope2.phase(180.0); + + AudioInterrupts(); +} + +void setOutputMix() { + outputMixer.gain(0, (1.0 - outputMix) / 2.0); + outputMixer.gain(1, (1.0 - outputMix) / 2.0); + outputMixer.gain(2, outputMix); +} diff --git a/mod-delay-gain.cpp b/mod-delay-gain.cpp new file mode 100644 index 0000000..15be65b --- /dev/null +++ b/mod-delay-gain.cpp @@ -0,0 +1,141 @@ +/* Modulated delay line + + Inspired by; + http://musicdsp.org/showArchiveComment.php?ArchiveID=154 + + But details changed for Teensy Audio. + No feedback within the class, just done externally + so we can add filters and stuff to the loop. + + Delay time is a signal input to the block, and functions from 0 to 0x7fff, + scaling the delay time accordingly. +*/ +/* + Copyright (c) 2016, Byron Jacquot, SparkFun Electronics + SparkFun code, firmware, and software is released under + the MIT License(http://opensource.org/licenses/MIT). + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice, development funding notice, and this permission + notice shall be included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. + + +*/ + + +#include "mod-delay-gain.h" + +#define INTERPOLATE (1) + +void AudioEffectModDelayGain::update(void) +{ + audio_block_t *audioblock, *controlblockDelay, *controlblockGain; + int16_t *data, *end, *ctrlDelay, *ctrlGain; + + int32_t extract_index; + int32_t temp; + +#ifdef INTERPOLATE + int32_t interp_delta; + int32_t next; + int16_t calc; +#endif + + if (buffer_length == 0) + return; + + audioblock = receiveWritable(0); + if (!audioblock) return; + + controlblockDelay = receiveReadOnly(1); + if (!controlblockDelay) { + release(audioblock); + return; + } + + controlblockGain = receiveReadOnly(2); + if (!controlblockGain) { + release(audioblock); + release(controlblockDelay); + return; + } + + data = audioblock->data; + end = audioblock->data + AUDIO_BLOCK_SAMPLES; + + ctrlDelay = controlblockDelay->data; + + ctrlGain = controlblockGain->data; + + do + { + delayline_p[insert_index] = *data; + insert_index++; + if (insert_index >= buffer_length) + { + insert_index = 0; + } + +#ifdef INTERPOLATE + // + interp_delta = (buffer_length * (*ctrlDelay)); + delay_delta = interp_delta >> 15; // MSB's for delay len + interp_delta &= 0x7fff; //LSBs for interp distance +#else + delay_delta = (buffer_length * (*ctrlDelay)) >> 15; +#endif + + extract_index = insert_index - delay_delta; + + if (extract_index < 0) + { + extract_index = buffer_length + extract_index; + } + +#ifdef INTERPOLATE + // Use the fractional part to interpolate between samples + next = extract_index + 1; + if (next >= buffer_length) + { + next = 0; + } + + calc = delayline_p[next] - delayline_p[extract_index]; + + calc = (calc * interp_delta ) >> 15; + calc += delayline_p[extract_index]; + + //*data = calc; + temp = (int32_t)calc * (*ctrlGain); + *data = temp >> 15; +#else + //data = delayline_p[extract_index]; + temp = (int32_t)delayline_p[extract_index] * (*ctrlGain); + *data = temp >> 15; +#endif + + data++; + ctrlDelay++; + ctrlGain++; + } while (data < end); + transmit(audioblock); + release(audioblock); + release(controlblockDelay); + release(controlblockGain); +} + + diff --git a/mod-delay-gain.h b/mod-delay-gain.h new file mode 100644 index 0000000..3a2c948 --- /dev/null +++ b/mod-delay-gain.h @@ -0,0 +1,91 @@ +/* Modulated delay line + + Inspired by; + http://musicdsp.org/showArchiveComment.php?ArchiveID=154 + + But details changed for Teensy Audio. + No feedback within the class, just done externally + so we can add filters and stuff to the loop. + + Delay time is a signal input to the block, and functions from 0 to 0x7fff, + scaling the delay time accordingly. +*/ +/* + Copyright (c) 2016, Byron Jacquot, SparkFun Electronics + SparkFun code, firmware, and software is released under + the MIT License(http://opensource.org/licenses/MIT). + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice, development funding notice, and this permission + notice shall be included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. + + +*/ + +#pragma once + +#ifndef _mod_delay_h_ +#define _mod_delay_h_ + + +#include "AudioStream.h" +#include + +class AudioEffectModDelayGain: public AudioStream +{ + public: + AudioEffectModDelayGain (void) : AudioStream(3, inputQueueArray) + { + buffer_length = 0; + } + + virtual void update(void); + + // Set the parameters + void setbuf(int32_t delay_len, int16_t* delay_buf ) + { + delayline_p = delay_buf; + insert_index = 0; + buffer_length = delay_len; + + for (int32_t i = 0; i < buffer_length; i++) + { + delayline_p[i] = 0; + } + }; + + void inspect(void) + { + Serial.print(insert_index, HEX); + Serial.print(' '); + Serial.print(delay_delta, HEX); + Serial.print(' '); + Serial.println(buffer_length, HEX); + + }; + + private: + audio_block_t *inputQueueArray[3]; + + int16_t *delayline_p; + + int32_t insert_index; + int32_t buffer_length; + int32_t delay_delta; +}; + +#endif