First Commit

Tone_Shift.ino

@@ -0,0 +1,207 @@
+#include <Audio.h>
+#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);
+}

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);
+}
+
+

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 <Arduino.h>
+
+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