From 1b2ccda033bf13841a36d0dfd200f140766363dc Mon Sep 17 00:00:00 2001 From: Blackaddr Audio Date: Wed, 17 Oct 2018 19:06:34 -0400 Subject: [PATCH] Feature/add lfo (#1) * Basic working tremolo * LFO now works as a vector * Added standard tremolo demo --- examples/Modulation/TemoloDemo/TemoloDemo.ino | 131 ++++++++++++ examples/Modulation/TemoloDemo/name.c | 19 ++ .../TremoloDemoExpansion.ino | 192 ++++++++++++++++++ src/AudioEffectTremolo.h | 126 ++++++++++++ src/BAEffects.h | 1 + src/LibBasicFunctions.h | 59 ++++++ src/common/LowFrequencyOscillator.cpp | 145 +++++++++++++ ...ernal.cpp => AudioEffectDelayExternal.cpp} | 0 src/effects/AudioEffectTremolo.cpp | 163 +++++++++++++++ 9 files changed, 836 insertions(+) create mode 100644 examples/Modulation/TemoloDemo/TemoloDemo.ino create mode 100644 examples/Modulation/TemoloDemo/name.c create mode 100644 examples/Modulation/TremoloDemoExpansion/TremoloDemoExpansion.ino create mode 100644 src/AudioEffectTremolo.h create mode 100644 src/common/LowFrequencyOscillator.cpp rename src/effects/{BAAudioEffectDelayExternal.cpp => AudioEffectDelayExternal.cpp} (100%) create mode 100644 src/effects/AudioEffectTremolo.cpp diff --git a/examples/Modulation/TemoloDemo/TemoloDemo.ino b/examples/Modulation/TemoloDemo/TemoloDemo.ino new file mode 100644 index 0000000..d20ea2c --- /dev/null +++ b/examples/Modulation/TemoloDemo/TemoloDemo.ino @@ -0,0 +1,131 @@ +/************************************************************************* + * This demo uses the BALibrary library to provide enhanced control of + * the TGA Pro board. + * + * The latest copy of the BA Guitar library can be obtained from + * https://github.com/Blackaddr/BALibrary + * + * This example demonstrates teh AudioEffectsTremolo effect. It can + * be controlled using USB MIDI. You can get a free USB MIDI Controller + * appliation at + * http://www.blackaddr.com/downloads/BAMidiTester/ + * or the source code at + * https://github.com/Blackaddr/BAMidiTester + * + * Even if you don't control the guitar effect with USB MIDI, you must set + * the Arduino IDE USB-Type under Tools to "Serial + MIDI" + */ + #include +#include "BALibrary.h" +#include "BAEffects.h" + +using namespace midi; +using namespace BAEffects; +using namespace BALibrary; + +AudioInputI2S i2sIn; +AudioOutputI2S i2sOut; +BAAudioControlWM8731 codec; + +/// IMPORTANT ///// +// YOU MUST USE TEENSYDUINO 1.41 or greater +// YOU MUST COMPILE THIS DEMO USING Serial + Midi + +//#define USE_EXT // uncomment this line to use External MEM0 +#define MIDI_DEBUG // uncomment to see raw MIDI info in terminal + +AudioEffectTremolo tremolo; + +AudioFilterBiquad cabFilter; // We'll want something to cut out the highs and smooth the tone, just like a guitar cab. + +// Simply connect the input to the tremolo, and the output +// to both i2s channels +AudioConnection input(i2sIn,0, tremolo,0); +AudioConnection tremoloOut(tremolo, 0, cabFilter, 0); +AudioConnection leftOut(cabFilter,0, i2sOut, 0); +AudioConnection rightOut(cabFilter,0, i2sOut, 1); + +int loopCount = 0; + +void setup() { + delay(100); + Serial.begin(57600); // Start the serial port + + // Disable the codec first + codec.disable(); + delay(100); + AudioMemory(128); + delay(5); + + // Enable the codec + Serial.println("Enabling codec...\n"); + codec.enable(); + delay(100); + + // Configure which MIDI CC's will control the effect parameters + tremolo.mapMidiControl(AudioEffectTremolo::BYPASS,16); + tremolo.mapMidiControl(AudioEffectTremolo::RATE,20); + tremolo.mapMidiControl(AudioEffectTremolo::DEPTH,21); + tremolo.mapMidiControl(AudioEffectTremolo::VOLUME,22); + + // Besure to enable the tremolo. When disabled, audio is is completely blocked + // to minimize resources to nearly zero. + tremolo.enable(); + + // Set some default values. + // These can be changed by sending MIDI CC messages over the USB using + // the BAMidiTester application. + tremolo.rate(0.5f); // initial LFO rate of 1/2 max which is about 10 Hz + tremolo.bypass(false); + tremolo.depth(0.5f); // 50% depth modulation + + // Setup 2-stages of LPF, cutoff 4500 Hz, Q-factor 0.7071 (a 'normal' Q-factor) + cabFilter.setLowpass(0, 4500, .7071); + cabFilter.setLowpass(1, 4500, .7071); +} + +void OnControlChange(byte channel, byte control, byte value) { + tremolo.processMidi(channel, control, value); + #ifdef MIDI_DEBUG + Serial.print("Control Change, ch="); + Serial.print(channel, DEC); + Serial.print(", control="); + Serial.print(control, DEC); + Serial.print(", value="); + Serial.print(value, DEC); + Serial.println(); + #endif +} + +void loop() { + // usbMIDI.read() needs to be called rapidly from loop(). When + // each MIDI messages arrives, it return true. The message must + // be fully processed before usbMIDI.read() is called again. + + if (loopCount % 524288 == 0) { + Serial.print("Processor Usage, Total: "); Serial.print(AudioProcessorUsage()); + Serial.print("% "); + Serial.print(" tremolo: "); Serial.print(tremolo.processorUsage()); + Serial.println("%"); + } + loopCount++; + + // check for new MIDI from USB + if (usbMIDI.read()) { + // this code entered only if new MIDI received + byte type, channel, data1, data2, cable; + type = usbMIDI.getType(); // which MIDI message, 128-255 + channel = usbMIDI.getChannel(); // which MIDI channel, 1-16 + data1 = usbMIDI.getData1(); // first data byte of message, 0-127 + data2 = usbMIDI.getData2(); // second data byte of message, 0-127 + Serial.println(String("Received a MIDI message on channel ") + channel); + + if (type == MidiType::ControlChange) { + // if type is 3, it's a CC MIDI Message + // Note: the Arduino MIDI library encodes channels as 1-16 instead + // of 0 to 15 as it should, so we must subtract one. + OnControlChange(channel-1, data1, data2); + } + } + +} diff --git a/examples/Modulation/TemoloDemo/name.c b/examples/Modulation/TemoloDemo/name.c new file mode 100644 index 0000000..5ea00fe --- /dev/null +++ b/examples/Modulation/TemoloDemo/name.c @@ -0,0 +1,19 @@ +// To give your project a unique name, this code must be +// placed into a .c file (its own tab). It can not be in +// a .cpp file or your main sketch (the .ino file). + +#include "usb_names.h" + +// Edit these lines to create your own name. The length must +// match the number of characters in your custom name. + +#define MIDI_NAME {'B','l','a','c','k','a','d','d','r',' ','A','u','d','i','o',' ','T','G','A',' ','P','r','o'} +#define MIDI_NAME_LEN 23 + +// Do not change this part. This exact format is required by USB. + +struct usb_string_descriptor_struct usb_string_product_name = { + 2 + MIDI_NAME_LEN * 2, + 3, + MIDI_NAME +}; diff --git a/examples/Modulation/TremoloDemoExpansion/TremoloDemoExpansion.ino b/examples/Modulation/TremoloDemoExpansion/TremoloDemoExpansion.ino new file mode 100644 index 0000000..6892fe2 --- /dev/null +++ b/examples/Modulation/TremoloDemoExpansion/TremoloDemoExpansion.ino @@ -0,0 +1,192 @@ +/************************************************************************* + * This demo uses the BALibrary library to provide enhanced control of + * the TGA Pro board. + * + * The latest copy of the BA Guitar library can be obtained from + * https://github.com/Blackaddr/BALibrary + * + * This example demonstrates teh BAAudioEffectsTremolo effect. It can + * be controlled using the Blackaddr Audio "Expansion Control Board". + * + * POT1 (left) controls amount of delay + * POT2 (right) controls amount of feedback + * POT3 (center) controls the wet/dry mix + * SW1 will enable/bypass the audio effect. LED1 will be on when effect is enabled. + * SW2 will cycle through the 3 pre-programmed analog filters. LED2 will be on when SW2 is pressed. + * + * + * Using the Serial Montitor, send 'u' and 'd' characters to increase or decrease + * the headphone volume between values of 0 and 9. + */ +#define TGA_PRO_REVB // Set which hardware revision of the TGA Pro we're using +#define TGA_PRO_EXPAND_REV2 // pull in the pin definitions for the Blackaddr Audio Expansion Board. + +#include "BALibrary.h" +#include "BAEffects.h" + +using namespace BAEffects; +using namespace BALibrary; + +AudioInputI2S i2sIn; +AudioOutputI2S i2sOut; +BAAudioControlWM8731 codec; + +AudioEffectTremolo tremolo; + +AudioFilterBiquad cabFilter; // We'll want something to cut out the highs and smooth the tone, just like a guitar cab. + +// Simply connect the input to the delay, and the output +// to both i2s channels +AudioConnection input(i2sIn,0, tremolo,0); +AudioConnection delayOut(tremolo, 0, cabFilter, 0); +AudioConnection leftOut(cabFilter,0, i2sOut, 0); +AudioConnection rightOut(cabFilter,0, i2sOut, 1); + + +////////////////////////////////////////// +// SETUP PHYSICAL CONTROLS +// - POT1 (left) will control the rate +// - POT2 (right) will control the depth +// - POT3 (centre) will control the volume +// - SW1 (left) will be used as a bypass control +// - LED1 (left) will be illuminated when the effect is ON (not bypass) +// - SW2 (right) will be used to cycle through the the waveforms +// - LED2 (right) will illuminate when pressing SW2. +////////////////////////////////////////// +// To get the calibration values for your particular board, first run the +// BAExpansionCalibrate.ino example and +constexpr int potCalibMin = 1; +constexpr int potCalibMax = 1018; +constexpr bool potSwapDirection = true; + +// Create a control object using the number of switches, pots, encoders and outputs on the +// Blackaddr Audio Expansion Board. +BAPhysicalControls controls(BA_EXPAND_NUM_SW, BA_EXPAND_NUM_POT, BA_EXPAND_NUM_ENC, BA_EXPAND_NUM_LED); + +int loopCount = 0; +unsigned waveformIndex = 0; // variable for storing which analog filter we're currently using. +constexpr unsigned MAX_HEADPHONE_VOL = 10; +unsigned headphoneVolume = 8; // control headphone volume from 0 to 10. + +// BAPhysicalControls returns a handle when you register a new control. We'll uses these handles when working with the controls. +int bypassHandle, waveformHandle, rateHandle, depthHandle, volumeHandle, led1Handle, led2Handle; // Handles for the various controls + +void setup() { + delay(100); // wait a bit for serial to be available + Serial.begin(57600); // Start the serial port + delay(100); + + // Setup the controls. The return value is the handle to use when checking for control changes, etc. + // pushbuttons + bypassHandle = controls.addSwitch(BA_EXPAND_SW1_PIN); // will be used for bypass control + waveformHandle = controls.addSwitch(BA_EXPAND_SW2_PIN); // will be used for stepping through filters + // pots + rateHandle = controls.addPot(BA_EXPAND_POT1_PIN, potCalibMin, potCalibMax, potSwapDirection); // control the amount of delay + depthHandle = controls.addPot(BA_EXPAND_POT2_PIN, potCalibMin, potCalibMax, potSwapDirection); + volumeHandle = controls.addPot(BA_EXPAND_POT3_PIN, potCalibMin, potCalibMax, potSwapDirection); + // leds + led1Handle = controls.addOutput(BA_EXPAND_LED1_PIN); + led2Handle = controls.addOutput(BA_EXPAND_LED2_PIN); // will illuminate when pressing SW2 + + // Disable the audio codec first + codec.disable(); + AudioMemory(128); + + // Enable and configure the codec + Serial.println("Enabling codec...\n"); + codec.enable(); + codec.setHeadphoneVolume(1.0f); // Max headphone volume + + // Besure to enable the tremolo. When disabled, audio is is completely blocked by the effect + // to minimize resource usage to nearly to nearly zero. + tremolo.enable(); + + // Set some default values. + // These can be changed using the controls on the Blackaddr Audio Expansion Board + tremolo.bypass(false); + tremolo.rate(0.0f); + tremolo.depth(1.0f); + + ////////////////////////////////// + // Waveform selection // + // These are commented out, in this example we'll use SW2 to cycle through the different filters + //tremolo.setWaveform(Waveform::SINE); // The default waveform + + // Guitar cabinet: Setup 2-stages of LPF, cutoff 4500 Hz, Q-factor 0.7071 (a 'normal' Q-factor) + cabFilter.setLowpass(0, 4500, .7071); + cabFilter.setLowpass(1, 4500, .7071); +} + +void loop() { + + float potValue; + + // Check if SW1 has been toggled (pushed) + if (controls.isSwitchToggled(bypassHandle)) { + bool bypass = tremolo.isBypass(); // get the current state + bypass = !bypass; // change it + tremolo.bypass(bypass); // set the new state + controls.setOutput(led1Handle, !bypass); // Set the LED when NOT bypassed + Serial.println(String("BYPASS is ") + bypass); + } + + // Use SW2 to cycle through the waveforms + controls.setOutput(led2Handle, controls.getSwitchValue(led2Handle)); + if (controls.isSwitchToggled(waveformHandle)) { + waveformIndex = (waveformIndex + 1) % static_cast(Waveform::NUM_WAVEFORMS); + // cast the index + tremolo.setWaveform(static_cast(waveformIndex)); + Serial.println(String("Waveform set to ") + waveformIndex); + } + + // Use POT1 (left) to control the rate setting + if (controls.checkPotValue(rateHandle, potValue)) { + // Pot has changed + Serial.println(String("New RATE setting: ") + potValue); + tremolo.rate(potValue); + } + + // Use POT2 (right) to control the depth setting + if (controls.checkPotValue(depthHandle, potValue)) { + // Pot has changed + Serial.println(String("New DEPTH setting: ") + potValue); + tremolo.depth(potValue); + } + + // Use POT3 (centre) to control the volume setting + if (controls.checkPotValue(volumeHandle, potValue)) { + // Pot has changed + Serial.println(String("New VOLUME setting: ") + potValue); + tremolo.volume(potValue); + } + + // Use the 'u' and 'd' keys to adjust volume across ten levels. + if (Serial) { + if (Serial.available() > 0) { + while (Serial.available()) { + char key = Serial.read(); + if (key == 'u') { + headphoneVolume = (headphoneVolume + 1) % MAX_HEADPHONE_VOL; + Serial.println(String("Increasing HEADPHONE volume to ") + headphoneVolume); + } + else if (key == 'd') { + headphoneVolume = (headphoneVolume - 1) % MAX_HEADPHONE_VOL; + Serial.println(String("Decreasing HEADPHONE volume to ") + headphoneVolume); + } + codec.setHeadphoneVolume(static_cast(headphoneVolume) / static_cast(MAX_HEADPHONE_VOL)); + } + } + } + + // Use the loopCounter to roughly measure human timescales. Every few seconds, print the CPU usage + // to the serial port. About 500,000 loops! + //if (loopCount % 524288 == 0) { + if (loopCount % 25000 == 0) { + Serial.print("Processor Usage, Total: "); Serial.print(AudioProcessorUsage()); + Serial.print("% "); + Serial.print(" tremolo: "); Serial.print(tremolo.processorUsage()); + Serial.println("%"); + } + loopCount++; + +} diff --git a/src/AudioEffectTremolo.h b/src/AudioEffectTremolo.h new file mode 100644 index 0000000..58de0cd --- /dev/null +++ b/src/AudioEffectTremolo.h @@ -0,0 +1,126 @@ +/**************************************************************************//** + * @file + * @author Steve Lascos + * @company Blackaddr Audio + * + * Tremolo is a classic volume modulate effect. + * + * @copyright This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version.* + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY__BAEFFECTS_AUDIOEFFECTDELAYEXTERNAL_H; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + *****************************************************************************/ + +#ifndef __BAEFFECTS_AUDIOEFFECTTREMOLO_H +#define __BAEFFECTS_AUDIOEFFECTTREMOLO_H + +#include +#include "LibBasicFunctions.h" + +namespace BAEffects { + +/**************************************************************************//** + * AudioEffectTremolo + *****************************************************************************/ +class AudioEffectTremolo : public AudioStream { +public: + + ///< List of AudioEffectTremolo MIDI controllable parameters + enum { + BYPASS = 0, ///< controls effect bypass + RATE, ///< controls the rate of the modulation + DEPTH, ///< controls the depth of the modulation + WAVEFORM, ///< select the modulation waveform + VOLUME, ///< controls the output volume level + NUM_CONTROLS ///< this can be used as an alias for the number of MIDI controls + }; + + // *** CONSTRUCTORS *** + AudioEffectTremolo(); + + virtual ~AudioEffectTremolo(); ///< Destructor + + // *** PARAMETERS *** + void rate(float rateValue); + + void depth(float depthValue) { m_depth = depthValue; } + + void setWaveform(BALibrary::Waveform waveform); + + + /// Bypass the effect. + /// @param byp when true, bypass wil disable the effect, when false, effect is enabled. + /// Note that audio still passes through when bypass is enabled. + void bypass(bool byp) { m_bypass = byp; } + + /// Get if the effect is bypassed + /// @returns true if bypassed, false if not bypassed + bool isBypass() { return m_bypass; } + + /// Toggle the bypass effect + void toggleBypass() { m_bypass = !m_bypass; } + + /// Set the output volume. This affect both the wet and dry signals. + /// @details The default is 1.0. + /// @param vol Sets the output volume between -1.0 and +1.0 + void volume(float vol) {m_volume = vol; } + + // ** ENABLE / DISABLE ** + + /// Enables audio processing. Note: when not enabled, CPU load is nearly zero. + void enable() { m_enable = true; } + + /// Disables audio process. When disabled, CPU load is nearly zero. + void disable() { m_enable = false; } + + // ** MIDI ** + + /// Sets whether MIDI OMNI channel is processig on or off. When on, + /// all midi channels are used for matching CCs. + /// @param isOmni when true, all channels are processed, when false, channel + /// must match configured value. + void setMidiOmni(bool isOmni) { m_isOmni = isOmni; } + + /// Configure an effect parameter to be controlled by a MIDI CC + /// number on a particular channel. + /// @param parameter one of the parameter names in the class enum + /// @param midiCC the CC number from 0 to 127 + /// @param midiChannel the effect will only response to the CC on this channel + /// when OMNI mode is off. + void mapMidiControl(int parameter, int midiCC, int midiChannel = 0); + + /// process a MIDI Continous-Controller (CC) message + /// @param channel the MIDI channel from 0 to 15) + /// @param midiCC the CC number from 0 to 127 + /// @param value the CC value from 0 to 127 + void processMidi(int channel, int midiCC, int value); + + + virtual void update(void); ///< update automatically called by the Teesny Audio Library + +private: + audio_block_t *m_inputQueueArray[1]; + BALibrary::LowFrequencyOscillatorVector m_osc; + int m_midiConfig[NUM_CONTROLS][2]; // stores the midi parameter mapping + bool m_isOmni = false; + bool m_bypass = true; + bool m_enable = false; + + float m_rate = 0.0f; + float m_depth = 0.0f; + BALibrary::Waveform m_waveform = BALibrary::Waveform::SINE; + float m_volume = 1.0f; + +}; + +} + +#endif /* __BAEFFECTS_AUDIOEFFECTTREMOLO_H */ diff --git a/src/BAEffects.h b/src/BAEffects.h index 4b906a4..50b92b0 100644 --- a/src/BAEffects.h +++ b/src/BAEffects.h @@ -25,5 +25,6 @@ #include "BAAudioEffectDelayExternal.h" #include "AudioEffectAnalogDelay.h" #include "AudioEffectSOS.h" +#include "AudioEffectTremolo.h" #endif /* __BAEFFECTS_H */ diff --git a/src/LibBasicFunctions.h b/src/LibBasicFunctions.h index 25439c2..5022038 100644 --- a/src/LibBasicFunctions.h +++ b/src/LibBasicFunctions.h @@ -22,6 +22,7 @@ #include #include +#include #include #include "Arduino.h" @@ -396,6 +397,64 @@ private: bool m_running = false; }; +/// Supported LFO waveforms +enum class Waveform : unsigned { + SINE, ///< sinewave + TRIANGLE, ///< triangle wave + SQUARE, ///< square wave + SAWTOOTH, ///< sawtooth wave + RANDOM, ///< a non-repeating random waveform + NUM_WAVEFORMS, ///< the number of defined waveforms +}; + + +/**************************************************************************//** + * The LFO is commonly used on modulation effects where some parameter (delay, + * volume, etc.) is modulated via waveform at a frequency below 20 Hz. Waveforms + * vary between -1.0f and +1.0f. + * @details this LFO is for operating on vectors of audio block samples. + *****************************************************************************/ +template +class LowFrequencyOscillatorVector { +public: + /// Default constructor, uses SINE as default waveform + LowFrequencyOscillatorVector() {} + + /// Specifies the desired waveform at construction time. + /// @param waveform specifies desired waveform + LowFrequencyOscillatorVector(Waveform waveform) : m_waveform(waveform) {}; + /// Default destructor + ~LowFrequencyOscillatorVector() {} + + /// Change the waveform + /// @param waveform specifies desired waveform + void setWaveform(Waveform waveform) { m_waveform = waveform; } + + /// Set the LFO rate in Hertz + /// @param frequencyHz the LFO frequency in Hertz + void setRateAudio(float frequencyHz); + + /// Set the LFO rate as a fraction + /// @param ratio the radians/sample will be 2*pi*ratio + void setRateRatio(float ratio); + + /// Get the next waveform value + /// @returns the next vector of phase values + T *getNextVector(); + +private: + void m_updatePhase(); ///< called internally when updating the phase vector + void m_initPhase(T radiansPerSample); ///< called internally to reset phase upon rate change + Waveform m_waveform = Waveform::SINE; ///< LFO waveform + T m_phaseVec[AUDIO_BLOCK_SAMPLES]; ///< the vector of next phase values + T m_radiansPerBlock = 0.0f; ///< stores the change in radians over one block of data + T m_outputVec[AUDIO_BLOCK_SAMPLES]; ///< stores the output LFO values + std::atomic_flag m_phaseLock = ATOMIC_FLAG_INIT; ///< used for thread-safety on m_phaseVec + const T PI_F = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899; ///< 2*PI + const T TWO_PI_F = 2.0 * 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899; ///< 2*PI + const T PI_DIV2_F = 0.5 * 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899; ///< PI/2 +}; + } // BALibrary diff --git a/src/common/LowFrequencyOscillator.cpp b/src/common/LowFrequencyOscillator.cpp new file mode 100644 index 0000000..44924f3 --- /dev/null +++ b/src/common/LowFrequencyOscillator.cpp @@ -0,0 +1,145 @@ +/* + * LowFrequencyOscillator.cpp + * + * Created on: October 12, 2018 + * Author: Steve Lascos + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version.* + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . +*/ + +#include +#include "Audio.h" +#include "LibBasicFunctions.h" + +namespace BALibrary { + +template +void LowFrequencyOscillatorVector::m_initPhase(T radiansPerSample) +{ + // Initialize the phase vector starting at 0 radians, and incrementing + // by radiansPerSample for each element in the vector. + T initialPhase[AUDIO_BLOCK_SAMPLES]; + for (auto i=0; i +void LowFrequencyOscillatorVector::setRateAudio(float frequencyHz) +{ + T radiansPerSample; + if (frequencyHz == 0) { + radiansPerSample = 0; + } else { + T periodSamples = AUDIO_SAMPLE_RATE_EXACT / frequencyHz; + radiansPerSample = (T)TWO_PI_F / periodSamples; + } + m_initPhase(radiansPerSample); +} + + +// This function is used when the LFO is being called at some rate other than +// the audio rate. Here you can manually set the radians per sample as a fraction +// of 2*PI +template +void LowFrequencyOscillatorVector::setRateRatio(float ratio) +{ + T radiansPerSample; + if (ratio == 0) { + radiansPerSample = 0; + } else { + radiansPerSample = (T)TWO_PI_F * ratio; + } + m_initPhase(radiansPerSample); +} + +// When this function is called, it will update the phase vector by incrementing by +// radians per block which is radians per sample * block size. +template +inline void LowFrequencyOscillatorVector::m_updatePhase() +{ + if (m_phaseLock.test_and_set()) { return; } + + if (m_phaseVec[0] > TWO_PI_F) { + arm_offset_f32(m_phaseVec, -TWO_PI_F + m_radiansPerBlock, m_phaseVec, AUDIO_BLOCK_SAMPLES); + } else { + arm_offset_f32(m_phaseVec, m_radiansPerBlock, m_phaseVec, AUDIO_BLOCK_SAMPLES); + } + m_phaseLock.clear(); +} + +// This function will compute the vector of samples for the output waveform using +// the current phase vector. +template +T *LowFrequencyOscillatorVector::getNextVector() +{ + switch(m_waveform) { + case Waveform::SINE : + for (auto i=0; i 3*PI_F) { + m_outputVec[i] = 0.0f; + } + else if (m_phaseVec[i] > 2*PI_F) { + m_outputVec[i] = 1.0f; + } + else if (m_phaseVec[i] > PI_F) { + m_outputVec[i] = 0.0f; + } else { + m_outputVec[i] = 1.0f; + } + } + break; + case Waveform::TRIANGLE : +// for (auto i=0; i 3*PI_F) { +// m_outputVec[i] = ; +// } +// else if (m_phaseVec[i] > 2*PI_F) { +// m_outputVec[i] = 1.0f; +// } +// else if (m_phaseVec[i] > PI_F) { +// m_outputVec[i] = 0.0f; +// } else { +// m_outputVec[i] = 1.0f; +// } +// } + break; + case Waveform::RANDOM : + break; + default : + assert(0); // This occurs if a Waveform type is missing from the switch statement + } + + m_updatePhase(); + return m_outputVec; +} + +template class LowFrequencyOscillatorVector; + +} // namespace BALibrary + diff --git a/src/effects/BAAudioEffectDelayExternal.cpp b/src/effects/AudioEffectDelayExternal.cpp similarity index 100% rename from src/effects/BAAudioEffectDelayExternal.cpp rename to src/effects/AudioEffectDelayExternal.cpp diff --git a/src/effects/AudioEffectTremolo.cpp b/src/effects/AudioEffectTremolo.cpp new file mode 100644 index 0000000..0bb4d67 --- /dev/null +++ b/src/effects/AudioEffectTremolo.cpp @@ -0,0 +1,163 @@ +/* + * AudioEffectTremolo.cpp + * + * Created on: Jan 7, 2018 + * Author: slascos + */ +#include // std::roundf +#include "AudioEffectTremolo.h" + +using namespace BALibrary; + +namespace BAEffects { + +constexpr int MIDI_CHANNEL = 0; +constexpr int MIDI_CONTROL = 1; + +constexpr float MAX_RATE_HZ = 20.0f; + +AudioEffectTremolo::AudioEffectTremolo() +: AudioStream(1, m_inputQueueArray) +{ + m_osc.setWaveform(m_waveform); +} + +AudioEffectTremolo::~AudioEffectTremolo() +{ +} + +void AudioEffectTremolo::update(void) +{ + audio_block_t *inputAudioBlock = receiveWritable(); // get the next block of input samples + + // Check is block is disabled + if (m_enable == false) { + // do not transmit or process any audio, return as quickly as possible. + if (inputAudioBlock) release(inputAudioBlock); + return; + } + + // Check is block is bypassed, if so either transmit input directly or create silence + if (m_bypass == true) { + // transmit the input directly + if (!inputAudioBlock) { + // create silence + inputAudioBlock = allocate(); + if (!inputAudioBlock) { return; } // failed to allocate + else { + clearAudioBlock(inputAudioBlock); + } + } + transmit(inputAudioBlock, 0); + release(inputAudioBlock); + return; + } + + // DO PROCESSING + // apply modulation wave + float *mod = m_osc.getNextVector(); + for (auto i=0; idata[i]); + inputAudioBlock->data[i] = (int16_t)sample; + } + //Serial.println(String("mod: ") + mod[0]); + + + + //float mod = (m_osc.getNext()+1.0f)/2.0f; // value between -1.0 and +1.0f + //float modVolume = (1.0f - m_depth) + mod*m_depth; // value between 0 to depth + //float finalVolume = m_volume * modVolume; + + // Set the output volume + //gainAdjust(inputAudioBlock, inputAudioBlock, finalVolume, 1); + + transmit(inputAudioBlock); + release(inputAudioBlock); +} + +void AudioEffectTremolo::rate(float rateValue) +{ + float rateAudioBlock = rateValue * MAX_RATE_HZ; + m_osc.setRateAudio(rateAudioBlock); +} + +void AudioEffectTremolo::setWaveform(Waveform waveform) +{ + m_waveform = waveform; + m_osc.setWaveform(waveform); +} + +void AudioEffectTremolo::processMidi(int channel, int control, int value) +{ + + float val = (float)value / 127.0f; + + if ((m_midiConfig[BYPASS][MIDI_CHANNEL] == channel) && + (m_midiConfig[BYPASS][MIDI_CONTROL] == control)) { + // Bypass + if (value >= 65) { bypass(false); Serial.println(String("AudioEffectTremolo::not bypassed -> ON") + value); } + else { bypass(true); Serial.println(String("AudioEffectTremolo::bypassed -> OFF") + value); } + return; + } + + if ((m_midiConfig[RATE][MIDI_CHANNEL] == channel) && + (m_midiConfig[RATE][MIDI_CONTROL] == control)) { + // Rate + rate(val); + Serial.println(String("AudioEffectTremolo::rate: ") + m_rate); + return; + } + + if ((m_midiConfig[DEPTH][MIDI_CHANNEL] == channel) && + (m_midiConfig[DEPTH][MIDI_CONTROL] == control)) { + // Depth + depth(val); + Serial.println(String("AudioEffectTremolo::depth: ") + m_depth); + return; + } + + if ((m_midiConfig[WAVEFORM][MIDI_CHANNEL] == channel) && + (m_midiConfig[WAVEFORM][MIDI_CONTROL] == control)) { + // Waveform + if (value < 16) { + m_waveform = Waveform::SINE; + } else if (value < 32) { + m_waveform = Waveform::TRIANGLE; + } else if (value < 48) { + m_waveform = Waveform::SQUARE; + } else if (value < 64) { + m_waveform = Waveform::SAWTOOTH; + } else if (value < 80) { + m_waveform = Waveform::RANDOM; + } + + Serial.println(String("AudioEffectTremolo::waveform: ") + static_cast(m_waveform)); + return; + } + + if ((m_midiConfig[VOLUME][MIDI_CHANNEL] == channel) && + (m_midiConfig[VOLUME][MIDI_CONTROL] == control)) { + // Volume + Serial.println(String("AudioEffectTremolo::volume: ") + 100*val + String("%")); + volume(val); + return; + } + +} + +void AudioEffectTremolo::mapMidiControl(int parameter, int midiCC, int midiChannel) +{ + if (parameter >= NUM_CONTROLS) { + return ; // Invalid midi parameter + } + m_midiConfig[parameter][MIDI_CHANNEL] = midiChannel; + m_midiConfig[parameter][MIDI_CONTROL] = midiCC; +} + +} + + +