Chip Audette
8 years ago
parent
d46ab56ed7
commit
81492cc5ac
@ -0,0 +1,82 @@ |
||||
/*
|
||||
* fir_filterbank.cpp |
||||
*
|
||||
* Created: Chip Audette, Creare LLC, Feb 2017 |
||||
* Primarly built upon CHAPRO "Generic Hearing Aid" from
|
||||
* Boys Town National Research Hospital (BTNRH): https://github.com/BTNRH/chapro
|
||||
*
|
||||
* License: MIT License. Use at your own risk. |
||||
*
|
||||
*/ |
||||
|
||||
#include "AudioConfigFIRFilterBank_F32.h" |
||||
#include "utility/BTNRH_rfft.h" |
||||
|
||||
void AudioConfigFIRFilterBank_F32::fir_filterbank(float *bb, float *cf, const int nc, const int nw_orig, const int wt, const float sr) |
||||
{ |
||||
double p, w, a = 0.16, sm = 0; |
||||
float *ww, *bk, *xx, *yy; |
||||
int j, k, kk, nt, nf, ns, *be; |
||||
|
||||
int nw = nextPowerOfTwo(nw_orig); |
||||
//Serial.print("AudioConfigFIRFilterBank: fir_filterbank: nw_orig = "); Serial.print(nw_orig);
|
||||
//Serial.print(", nw = "); Serial.println(nw);
|
||||
|
||||
nt = nw * 2; //we're going to do an fft that's twice as long (zero padded)
|
||||
nf = nw + 1; //number of bins to nyquist in the zero-padded FFT. Also nf = nt/2+1
|
||||
ns = nf * 2; |
||||
be = (int *) calloc(nc + 1, sizeof(int)); |
||||
ww = (float *) calloc(nw, sizeof(float)); |
||||
xx = (float *) calloc(ns, sizeof(float)); |
||||
yy = (float *) calloc(ns, sizeof(float)); |
||||
|
||||
// window
|
||||
for (j = 0; j < nw; j++) ww[j]=0.0f; //clear
|
||||
for (j = 0; j < nw_orig; j++) { |
||||
p = M_PI * (2.0 * j - nw_orig) / nw_orig; |
||||
if (wt == 0) { |
||||
w = 0.54 + 0.46 * cos(p); // Hamming
|
||||
} else if (wt==1) { |
||||
w = (1 - a + cos(p) + a * cos(2 * p)) / 2; // Blackman
|
||||
} else { |
||||
//win = (1 - cos(2*pi*[1:N]/(N+1)))/2; //WEA's matlab call, indexing starts from 1, not zero
|
||||
w = (1.0 - cosf(2.0*M_PI*((float)(j))/((float)(nw_orig-1))))/2.0;
|
||||
} |
||||
sm += w; |
||||
ww[j] = (float) w; |
||||
} |
||||
|
||||
// frequency bands...add the DC-facing band and add the Nyquist-facing band
|
||||
be[0] = 0; |
||||
for (k = 1; k < nc; k++) { |
||||
kk = round(nf * cf[k - 1] * (2 / sr)); //original
|
||||
be[k] = (kk > nf) ? nf : kk; |
||||
} |
||||
be[nc] = nf; |
||||
|
||||
// channel tranfer functions
|
||||
fzero(xx, ns); |
||||
xx[nw_orig / 2] = 1; //make a single-sample impulse centered on our eventual window
|
||||
BTNRH_FFT::cha_fft_rc(xx, nt); |
||||
for (k = 0; k < nc; k++) { |
||||
fzero(yy, ns); //zero the temporary output
|
||||
//int nbins = (be[k + 1] - be[k]) * 2; Serial.print("fir_filterbank: chan ");Serial.print(k); Serial.print(", nbins = ");Serial.println(nbins);
|
||||
fcopy(yy + be[k] * 2, xx + be[k] * 2, (be[k + 1] - be[k]) * 2); //copy just our passband
|
||||
BTNRH_FFT::cha_fft_cr(yy, nt); //IFFT back into the time domain
|
||||
|
||||
// apply window to iFFT of bandpass
|
||||
for (j = 0; j < nw; j++) { |
||||
yy[j] *= ww[j]; |
||||
} |
||||
|
||||
bk = bb + k * nw_orig; //pointer to location in output array
|
||||
fcopy(bk, yy, nw_orig); //copy the filter coefficients to the output array
|
||||
|
||||
//print out the coefficients
|
||||
//for (int i=0; i<nw; i++) { Serial.print(yy[i]*1000.0f);Serial.print(" "); }; Serial.println();
|
||||
} |
||||
free(be); |
||||
free(ww); |
||||
free(xx); |
||||
free(yy); |
||||
} |
||||
@ -0,0 +1,101 @@ |
||||
|
||||
#include "AudioControlTester.h" |
||||
|
||||
void AudioTestSignalGenerator_F32::update(void) { |
||||
//receive the input audio data
|
||||
audio_block_f32_t *in_block = AudioStream_F32::receiveReadOnly_f32(); |
||||
if (!in_block) return; |
||||
|
||||
//if we're not testing, just transmit the block
|
||||
if (!is_testing) { |
||||
AudioStream_F32::transmit(in_block); // send the FIR output
|
||||
AudioStream_F32::release(in_block); |
||||
return; |
||||
} |
||||
|
||||
//if we are testing, we're going to substitute a new signal,
|
||||
//so we can release the block for the original signal
|
||||
AudioStream_F32::release(in_block); |
||||
|
||||
//allocate memory for block that we'll send
|
||||
audio_block_f32_t *out_block = allocate_f32(); |
||||
if (!out_block) return; |
||||
|
||||
//now generate the new siginal
|
||||
sine_gen.begin(); record_queue.begin(); //activate
|
||||
sine_gen.update(); sine_gen.end(); |
||||
gain_alg.update(); |
||||
record_queue.update(); record_queue.end(); |
||||
audio_block_f32_t *queue_block = record_queue.getAudioBlock(); |
||||
|
||||
//copy to out_block (why can't I just send the queue_block? I tried. It doesn't seem to work. try it again later!
|
||||
for (int i=0; i < queue_block->length; i++) out_block->data[i] = queue_block->data[i]; |
||||
record_queue.freeAudioBlock(); |
||||
|
||||
//send the data
|
||||
AudioStream_F32::transmit(out_block); // send the FIR output
|
||||
AudioStream_F32::release(out_block); |
||||
} |
||||
|
||||
|
||||
void AudioTestSignalMeasurement_F32::update(void) { |
||||
|
||||
//if we're not testing, just return
|
||||
if (!is_testing) { |
||||
return; |
||||
} |
||||
|
||||
//receive the input audio data...the baseline and the test
|
||||
audio_block_f32_t *in_block_baseline = AudioStream_F32::receiveReadOnly_f32(0); |
||||
if (!in_block_baseline) return; |
||||
audio_block_f32_t *in_block_test = AudioStream_F32::receiveReadOnly_f32(1); |
||||
if (!in_block_test) { |
||||
AudioStream_F32::release(in_block_baseline); |
||||
return; |
||||
} |
||||
|
||||
//compute the rms of both signals
|
||||
float baseline_rms = computeRMS(in_block_baseline->data, in_block_baseline->length); |
||||
float test_rms = computeRMS(in_block_test->data, in_block_test->length); |
||||
|
||||
//Release memory
|
||||
AudioStream_F32::release(in_block_baseline); |
||||
AudioStream_F32::release(in_block_test); |
||||
|
||||
//notify controller
|
||||
if (testController != NULL) testController->transferRMSValues(baseline_rms, test_rms); |
||||
} |
||||
|
||||
void AudioTestSignalMeasurementMulti_F32::update(void) { |
||||
|
||||
//if we're not testing, just return
|
||||
if (!is_testing) { |
||||
return; |
||||
} |
||||
|
||||
//receive the input audio data...the baseline and the test
|
||||
audio_block_f32_t *in_block_baseline = AudioStream_F32::receiveReadOnly_f32(0); |
||||
if (in_block_baseline==NULL) return; |
||||
float baseline_rms = computeRMS(in_block_baseline->data, in_block_baseline->length); |
||||
AudioStream_F32::release(in_block_baseline); |
||||
|
||||
//loop over each of the test data connections
|
||||
float test_rms[num_test_values]; |
||||
int n_with_data = 0; |
||||
for (int Ichan=0; Ichan < num_test_values; Ichan++) { |
||||
audio_block_f32_t *in_block_test = AudioStream_F32::receiveReadOnly_f32(1+Ichan); |
||||
if (in_block_test==NULL) { |
||||
//no data
|
||||
test_rms[Ichan]=0.0f; |
||||
} else { |
||||
//process data
|
||||
n_with_data = Ichan+1; |
||||
test_rms[Ichan]=computeRMS(in_block_test->data, in_block_test->length); |
||||
AudioStream_F32::release(in_block_test); |
||||
} |
||||
} |
||||
|
||||
|
||||
//notify controller
|
||||
if (testController != NULL) testController->transferRMSValues(baseline_rms, test_rms, n_with_data); |
||||
} |
||||
@ -0,0 +1,538 @@ |
||||
|
||||
#ifndef _AudioControlTester_h |
||||
#define _AudioControlTester_h |
||||
|
||||
//include <Tympan_Library.h>
|
||||
#include <OpenAudio_ArduinoLibrary.h> |
||||
|
||||
|
||||
#define max_steps 64 |
||||
#define max_num_chan 16 //max number of test signal inputs to the AudioTestSignalMeasurementMulti_F32
|
||||
|
||||
//prototypes
|
||||
class AudioTestSignalGenerator_F32; |
||||
class AudioTestSignalMeasurementInterface_F32; |
||||
class AudioTestSignalMeasurement_F32; |
||||
class AudioTestSignalMeasurementMulti_F32; |
||||
class AudioControlSignalTesterInterface_F32; |
||||
class AudioControlSignalTester_F32; |
||||
class AudioControlTestAmpSweep_F32; |
||||
class AudioControlTestFreqSweep_F32; |
||||
|
||||
// class definitions
|
||||
class AudioTestSignalGenerator_F32 : public AudioStream_F32 |
||||
{ |
||||
//GUI: inputs:1, outputs:1 //this line used for automatic generation of GUI node
|
||||
//GUI: shortName: testSignGen
|
||||
public: |
||||
AudioTestSignalGenerator_F32(void): AudioStream_F32(1,inputQueueArray) { |
||||
setSampleRate_Hz(AUDIO_SAMPLE_RATE); |
||||
setDefaultValues(); |
||||
makeConnections(); |
||||
} |
||||
AudioTestSignalGenerator_F32(const AudioSettings_F32 &settings): AudioStream_F32(1,inputQueueArray) { |
||||
setAudioSettings(settings); |
||||
setDefaultValues(); |
||||
makeConnections(); |
||||
} |
||||
~AudioTestSignalGenerator_F32(void) { |
||||
if (patchCord1 != NULL) delete patchCord1; |
||||
} |
||||
void setAudioSettings(const AudioSettings_F32 &settings) { |
||||
setSampleRate_Hz(settings.sample_rate_Hz); |
||||
} |
||||
void setSampleRate_Hz(const float _fs_Hz) { |
||||
//pass this data on to its components that care
|
||||
sine_gen.setSampleRate_Hz(_fs_Hz); |
||||
} |
||||
void makeConnections(void) { |
||||
patchCord1 = new AudioConnection_F32(sine_gen, 0, gain_alg, 0); |
||||
patchCord2 = new AudioConnection_F32(gain_alg, 0, record_queue, 0); |
||||
} |
||||
|
||||
virtual void update(void); |
||||
void begin(void) { |
||||
is_testing = true; |
||||
//if (Serial) Serial.println("AudioTestSignalGenerator_F32: begin(): ...");
|
||||
} |
||||
void end(void) { is_testing = false; } |
||||
|
||||
AudioSynthWaveformSine_F32 sine_gen; |
||||
AudioEffectGain_F32 gain_alg; |
||||
AudioRecordQueue_F32 record_queue; |
||||
AudioConnection_F32 *patchCord1; |
||||
AudioConnection_F32 *patchCord2; |
||||
|
||||
void amplitude(float val) { |
||||
sine_gen.amplitude(1.0); |
||||
gain_alg.setGain(val); |
||||
} |
||||
void frequency(float val) { |
||||
sine_gen.frequency(val); |
||||
} |
||||
|
||||
virtual void setSignalAmplitude_dBFS(float val_dBFS) { |
||||
amplitude(sqrtf(2.0)*sqrtf(powf(10.0f,0.1*val_dBFS))); |
||||
}; |
||||
virtual void setSignalFrequency_Hz(float val_Hz) { |
||||
frequency(val_Hz); |
||||
} |
||||
|
||||
private: |
||||
bool is_testing = false; |
||||
audio_block_f32_t *inputQueueArray[1]; |
||||
|
||||
void setDefaultValues(void) { |
||||
sine_gen.end(); //disable it for now
|
||||
record_queue.end(); //disable it for now;
|
||||
is_testing = false; |
||||
frequency(1000.f); |
||||
amplitude(0.0f); |
||||
} |
||||
}; |
||||
|
||||
|
||||
// //////////////////////////////////////////////////////////////////////////
|
||||
class AudioTestSignalMeasurementInterface_F32 { |
||||
public: |
||||
AudioTestSignalMeasurementInterface_F32 (void) {}; |
||||
|
||||
void setAudioSettings(const AudioSettings_F32 &settings) { |
||||
setSampleRate_Hz(settings.sample_rate_Hz); |
||||
} |
||||
void setSampleRate_Hz(const float _fs_Hz) { |
||||
//pass this data on to its components that care. None care right now.
|
||||
} |
||||
virtual void update(void); |
||||
virtual float computeRMS(float data[], int n) { |
||||
float rms_value; |
||||
arm_rms_f32 (data, n, &rms_value); |
||||
return rms_value; |
||||
} |
||||
virtual void begin(AudioControlSignalTester_F32 *p_controller) { |
||||
//if (Serial) Serial.println("AudioTestSignalMeasurement_F32: begin(): ...");
|
||||
testController = p_controller; |
||||
is_testing = true; |
||||
} |
||||
virtual void end(void) { |
||||
//if (Serial) Serial.println("AudioTestSignalMeasurement_F32: end(): ...");
|
||||
testController = NULL; |
||||
is_testing = false; |
||||
} |
||||
protected: |
||||
bool is_testing = false; |
||||
//audio_block_f32_t *inputQueueArray[2];
|
||||
AudioControlSignalTester_F32 *testController = NULL; |
||||
|
||||
virtual void setDefaultValues(void) { |
||||
is_testing = false; |
||||
} |
||||
}; |
||||
|
||||
class AudioTestSignalMeasurement_F32 : public AudioStream_F32, public AudioTestSignalMeasurementInterface_F32 |
||||
{ |
||||
//GUI: inputs:2, outputs:0 //this line used for automatic generation of GUI node
|
||||
//GUI: shortName: testSigMeas
|
||||
public: |
||||
AudioTestSignalMeasurement_F32(void): AudioStream_F32(2,inputQueueArray) { |
||||
setSampleRate_Hz(AUDIO_SAMPLE_RATE); |
||||
setDefaultValues(); |
||||
} |
||||
AudioTestSignalMeasurement_F32(const AudioSettings_F32 &settings): AudioStream_F32(2,inputQueueArray) { |
||||
setAudioSettings(settings); |
||||
setDefaultValues(); |
||||
} |
||||
void update(void); |
||||
|
||||
private: |
||||
audio_block_f32_t *inputQueueArray[2]; |
||||
|
||||
}; |
||||
|
||||
class AudioTestSignalMeasurementMulti_F32 : public AudioStream_F32, public AudioTestSignalMeasurementInterface_F32 |
||||
{ |
||||
//GUI: inputs:10, outputs:0 //this line used for automatic generation of GUI node
|
||||
//GUI: shortName: testSigMeas
|
||||
public: |
||||
AudioTestSignalMeasurementMulti_F32(void): AudioStream_F32(max_num_chan+1,inputQueueArray) { |
||||
setSampleRate_Hz(AUDIO_SAMPLE_RATE); |
||||
setDefaultValues(); |
||||
} |
||||
AudioTestSignalMeasurementMulti_F32(const AudioSettings_F32 &settings): AudioStream_F32(max_num_chan+1,inputQueueArray) { |
||||
setAudioSettings(settings); |
||||
setDefaultValues(); |
||||
} |
||||
void update(void); |
||||
|
||||
private: |
||||
//int num_input_connections = max_num_chan+1;
|
||||
int num_test_values = max_num_chan; |
||||
audio_block_f32_t *inputQueueArray[max_num_chan+1]; |
||||
}; |
||||
|
||||
|
||||
// ///////////////////////////////////////////////////////////////////////////////////
|
||||
class AudioControlSignalTesterInterface_F32 { |
||||
public: |
||||
AudioControlSignalTesterInterface_F32(void) {}; |
||||
//virtual void setAudioBlockSamples(void) = 0;
|
||||
//virtual void setSampleRate_hz(void) = 0;
|
||||
virtual void begin(void) = 0; |
||||
virtual void end(void) = 0; |
||||
virtual void setStepPattern(float, float, float) = 0; |
||||
virtual void transferRMSValues(float, float) = 0; |
||||
virtual void transferRMSValues(float, float *, int) = 0; |
||||
virtual bool available(void) = 0; |
||||
}; |
||||
|
||||
|
||||
class AudioControlSignalTester_F32 : public AudioControlSignalTesterInterface_F32 |
||||
{ |
||||
//GUI: inputs:0, outputs:0 //this line used for automatic generation of GUI node
|
||||
//GUI: shortName: sigTest(Abstract)
|
||||
public:
|
||||
AudioControlSignalTester_F32(AudioSettings_F32 &settings, AudioTestSignalGenerator_F32 &_sig_gen, AudioTestSignalMeasurementInterface_F32 &_sig_meas)
|
||||
: AudioControlSignalTesterInterface_F32(), sig_gen(_sig_gen), sig_meas(_sig_meas) { |
||||
|
||||
setAudioBlockSamples(settings.audio_block_samples); |
||||
setSampleRate_Hz(settings.sample_rate_Hz); |
||||
resetState(); |
||||
} |
||||
virtual void begin(void) { |
||||
Serial.println("AudioControlSignalTester_F32: begin(): ..."); |
||||
recomputeTargetCountsPerStep(); //not needed, just to print some debugging messages
|
||||
|
||||
//activate the instrumentation
|
||||
sig_gen.begin(); |
||||
sig_meas.begin(this); |
||||
|
||||
//start the test
|
||||
resetState(); |
||||
gotoNextStep(); |
||||
} |
||||
|
||||
//use this to cancel the test
|
||||
virtual void end(void) { |
||||
finishTest(); |
||||
} |
||||
|
||||
void setAudioSettings(AudioSettings_F32 audio_settings) { |
||||
setAudioBlockSamples(audio_settings.audio_block_samples); |
||||
setSampleRate_Hz(audio_settings.sample_rate_Hz); |
||||
} |
||||
void setAudioBlockSamples(int block_samples) { |
||||
audio_block_samples = block_samples; |
||||
recomputeTargetCountsPerStep(); |
||||
} |
||||
void setSampleRate_Hz(float fs_Hz) { |
||||
sample_rate_Hz = fs_Hz; |
||||
recomputeTargetCountsPerStep(); |
||||
} |
||||
|
||||
//define how long (seconds) to spend at each step of the test
|
||||
void setTargetDurPerStep_sec(float sec) { |
||||
if (sec > 0.001) { |
||||
target_dur_per_step_sec = sec; |
||||
recomputeTargetCountsPerStep(); |
||||
} else { |
||||
Serial.print(F("AudioControlSignalTester_F32: setTargetDurPerStep_sec: given duration too short: ")); |
||||
Serial.print(target_dur_per_step_sec); |
||||
Serial.print(F(". Ignoring...")); |
||||
return; |
||||
} |
||||
} |
||||
virtual void setStepPattern(float _start_val, float _end_val, float _step_val) { |
||||
start_val = _start_val; end_val = _end_val; step_val = _step_val; |
||||
recomputeTargetNumberOfSteps(); |
||||
} |
||||
|
||||
virtual void transferRMSValues(float baseline_rms, float test_rms) { |
||||
transferRMSValues(baseline_rms, &test_rms, 1); |
||||
} |
||||
virtual void transferRMSValues(float baseline_rms, float *test_rms, int num_chan) { |
||||
if (counter_ignore > 0) { |
||||
//ignore this reading
|
||||
counter_ignore--; |
||||
return; |
||||
} |
||||
given_num_chan = num_chan; |
||||
if (given_num_chan > max_num_chan) { |
||||
Serial.println(F("AudioControlSignalTester_F32: transferRMSValues: *** ERROR ***")); |
||||
Serial.print(F(" : num_chan (")); Serial.print(num_chan); Serial.print(")"); |
||||
Serial.print(F(" is bigger max_num_chan (")); Serial.println(max_num_chan); |
||||
Serial.println(F(" : Skipping...")); |
||||
return; |
||||
} |
||||
|
||||
//add this number
|
||||
sum_sig_pow_baseline[counter_step] += (baseline_rms*baseline_rms); |
||||
for (int Ichan=0; Ichan < num_chan; Ichan++) { |
||||
sum_sig_pow_test[counter_step][Ichan] += (test_rms[Ichan]*test_rms[Ichan]); |
||||
} |
||||
freq_at_each_step_Hz[counter_step] = signal_frequency_Hz; |
||||
counter_sum[counter_step]++; |
||||
|
||||
//have all the channels checked in?
|
||||
if (counter_sum[counter_step] >= target_counts_per_step) { |
||||
gotoNextStep(); |
||||
} |
||||
} |
||||
|
||||
virtual void setSignalFrequency_Hz(float freq_Hz) { |
||||
signal_frequency_Hz = freq_Hz; |
||||
sig_gen.setSignalFrequency_Hz(signal_frequency_Hz); |
||||
} |
||||
virtual void setSignalAmplitude_dBFS(float amp_dBFS) { |
||||
signal_amplitude_dBFS = amp_dBFS; |
||||
sig_gen.setSignalAmplitude_dBFS(amp_dBFS); |
||||
} |
||||
virtual void printTableOfResults(Stream *s) { |
||||
float ave1_dBFS, ave2_dBFS, ave3_dBFS, gain_dB, total_pow, total_wav, foo_pow; |
||||
s->println(" : Freq (Hz), Input (dBFS), Per-Chan Output (dBFS), Total Gain (inc) (dB), Total Gain (coh) (dB)"); |
||||
//s->print(" : given_num_chan = ");s->println(given_num_chan);
|
||||
for (int i=0; i < target_n_steps; i++) { |
||||
ave1_dBFS = 10.f*log10f(sum_sig_pow_baseline[i]/counter_sum[i]); |
||||
s->print(" "); s->print(freq_at_each_step_Hz[i],0); |
||||
s->print(", "); s->print(ave1_dBFS,1); |
||||
|
||||
total_pow = 0.0f; |
||||
total_wav = 0.0f; |
||||
for (int Ichan=0; Ichan < given_num_chan; Ichan++) { |
||||
if (Ichan==0) { |
||||
s->print(", "); |
||||
} else { |
||||
s->print(", "); |
||||
} |
||||
foo_pow = sum_sig_pow_test[i][Ichan]/counter_sum[i]; |
||||
ave2_dBFS = 10.f*log10f(foo_pow); |
||||
s->print(ave2_dBFS,1); |
||||
|
||||
total_pow += foo_pow; //sum as if it's noise being recombined incoherently
|
||||
total_wav += sqrtf(foo_pow); //sum as it it's a in-phase tone being combined coherently
|
||||
} |
||||
ave2_dBFS = 10.f*log10f(total_pow); |
||||
gain_dB = ave2_dBFS - ave1_dBFS; |
||||
s->print(", "); s->print(gain_dB,2); |
||||
|
||||
ave3_dBFS = 20.f*log10f(total_wav); |
||||
gain_dB = ave3_dBFS - ave1_dBFS; |
||||
s->print(", "); s->println(gain_dB,2); |
||||
} |
||||
} |
||||
|
||||
bool isDataAvailable = false; |
||||
bool available(void) { return isDataAvailable; } |
||||
|
||||
protected: |
||||
AudioTestSignalGenerator_F32 &sig_gen; |
||||
AudioTestSignalMeasurementInterface_F32 &sig_meas; |
||||
float signal_frequency_Hz = 1000.f; |
||||
float signal_amplitude_dBFS = -50.0f; |
||||
int counter_ignore = 0; |
||||
//bool is_testing = 0;
|
||||
|
||||
int audio_block_samples = AUDIO_BLOCK_SAMPLES; |
||||
float sample_rate_Hz = AUDIO_SAMPLE_RATE_EXACT; |
||||
float target_dur_per_step_sec = 0.2; |
||||
int target_counts_per_step = 1; |
||||
|
||||
//const int max_steps = 64;
|
||||
float start_val = 0, end_val = 1.f, step_val = 1.f; |
||||
int target_n_steps = 1; |
||||
int given_num_chan = max_num_chan; |
||||
|
||||
float sum_sig_pow_baseline[max_steps]; |
||||
float sum_sig_pow_test[max_steps][max_num_chan]; |
||||
float freq_at_each_step_Hz[max_steps]; |
||||
int counter_sum[max_steps], counter_step=-1; |
||||
|
||||
int recomputeTargetCountsPerStep(void) { |
||||
target_counts_per_step = max(1,(int)((target_dur_per_step_sec * sample_rate_Hz / ((float)audio_block_samples))+0.5)); //round
|
||||
// if (Serial) {
|
||||
// Serial.println("AudioControlSignalTester_F32: recomputeTargetCountsPerStep: ");
|
||||
// Serial.print(" : target_dur_per_step_sec = "); Serial.println(target_dur_per_step_sec);
|
||||
// Serial.print(" : sample_rate_Hz = "); Serial.println(sample_rate_Hz);
|
||||
// Serial.print(" : audio_block_samples = "); Serial.println(audio_block_samples);
|
||||
// Serial.print(" : target_counts_per_step = "); Serial.println(target_counts_per_step);
|
||||
// }
|
||||
return target_counts_per_step;
|
||||
} |
||||
virtual int recomputeTargetNumberOfSteps(void) { |
||||
return target_n_steps = (int)((end_val - start_val)/step_val + 0.5)+1; //round
|
||||
} |
||||
|
||||
virtual void resetState(void) { |
||||
isDataAvailable = false; |
||||
for (int i=0; i<max_steps; i++) { |
||||
sum_sig_pow_baseline[i]=0.0f; |
||||
for (int Ichan=0; Ichan<max_num_chan; Ichan++) sum_sig_pow_test[i][Ichan]=0.0f; |
||||
counter_sum[i] = 0; |
||||
} |
||||
counter_step = -1; |
||||
} |
||||
virtual void gotoNextStep(void) { |
||||
counter_step++; |
||||
//Serial.print("AudioControlSignalTester_F32: gotoNextStep: starting step ");
|
||||
//Serial.println(counter_step);
|
||||
if (counter_step >= target_n_steps) { |
||||
finishTest(); |
||||
return; |
||||
} else { |
||||
counter_ignore = 10; //ignore first 10 packets
|
||||
counter_sum[counter_step]=0; |
||||
sum_sig_pow_baseline[counter_step]=0.0f; |
||||
for (int Ichan=0; Ichan < max_num_chan; Ichan++) sum_sig_pow_test[counter_step][Ichan]=0.0f; |
||||
updateSignalGenerator(); |
||||
freq_at_each_step_Hz[counter_step]=0.0f; |
||||
|
||||
} |
||||
} |
||||
virtual void updateSignalGenerator(void)
|
||||
{ |
||||
//if (Serial) Serial.println("AudioControlSignalTester_F32: updateSignalGenerator(): did the child version get called?");
|
||||
} //override this is a child class!
|
||||
|
||||
virtual void finishTest(void) { |
||||
//Serial.println("AudioControlSignalTester_F32: finishTest()...");
|
||||
//disable the test instrumentation
|
||||
sig_gen.end(); |
||||
sig_meas.end(); |
||||
|
||||
//let listeners know that data is available
|
||||
isDataAvailable = true; |
||||
} |
||||
}; |
||||
|
||||
// //////////////////////////////////////////////////////////////////////////
|
||||
class AudioControlTestAmpSweep_F32 : public AudioControlSignalTester_F32 |
||||
{ |
||||
//GUI: inputs:0, outputs:0 //this line used for automatic generation of GUI node
|
||||
//GUI: shortName: ampSweepTester
|
||||
public: |
||||
AudioControlTestAmpSweep_F32(AudioSettings_F32 &settings, AudioTestSignalGenerator_F32 &_sig_gen, AudioTestSignalMeasurementInterface_F32 &_sig_meas)
|
||||
: AudioControlSignalTester_F32(settings, _sig_gen,_sig_meas) |
||||
{ |
||||
float start_amp_dB = -100.0f, end_amp_dB = 0.0f, step_amp_dB = 2.5f; |
||||
setStepPattern(start_amp_dB, end_amp_dB, step_amp_dB); |
||||
setTargetDurPerStep_sec(0.25); |
||||
resetState(); |
||||
} |
||||
void begin(void) { |
||||
//activate the instrumentation
|
||||
sig_gen.begin(); |
||||
sig_meas.begin(this); |
||||
|
||||
//start the test
|
||||
resetState(); |
||||
gotoNextStep(); |
||||
} |
||||
|
||||
//use this to cancel the test
|
||||
//void end(void) {
|
||||
// finishTest();
|
||||
//}
|
||||
|
||||
void printTableOfResults(Stream *s) { |
||||
s->println("AudioControlTestAmpSweep_F32: Start Table of Results..."); |
||||
AudioControlSignalTester_F32::printTableOfResults(s); |
||||
s->println("AudioControlTestAmpSweep_F32: End Table of Results..."); |
||||
} |
||||
|
||||
protected: |
||||
|
||||
virtual void updateSignalGenerator(void) { |
||||
float new_amp_dB = start_val + ((float)counter_step)*step_val; //start_val and step_val are in parent class
|
||||
Serial.print("AudioControlTestAmpSweep_F32: updateSignalGenerator(): setting amplitude to (dBFS) "); |
||||
Serial.println(new_amp_dB); |
||||
setSignalAmplitude_dBFS(new_amp_dB); |
||||
} |
||||
void finishTest(void) {
|
||||
//disable the test instrumentation
|
||||
setSignalAmplitude_dBFS(-1000.0f); //some very quiet value
|
||||
|
||||
//do all of the common actions
|
||||
AudioControlSignalTester_F32::finishTest(); |
||||
|
||||
//print results
|
||||
printTableOfResults(&Serial); |
||||
} |
||||
|
||||
//void resetState(void) {
|
||||
// AudioControlSignalTester_F32::resetState();
|
||||
//}
|
||||
}; |
||||
|
||||
|
||||
// //////////////////////////////////////////////////////////////////////////
|
||||
class AudioControlTestFreqSweep_F32 : public AudioControlSignalTester_F32 |
||||
{ |
||||
//GUI: inputs:0, outputs:0 //this line used for automatic generation of GUI node
|
||||
//GUI: shortName: freqSweepTester
|
||||
public: |
||||
AudioControlTestFreqSweep_F32(AudioSettings_F32 &settings, AudioTestSignalGenerator_F32 &_sig_gen, AudioTestSignalMeasurementInterface_F32 &_sig_meas)
|
||||
: AudioControlSignalTester_F32(settings, _sig_gen,_sig_meas) |
||||
{ |
||||
float start_freq_Hz = 125.f, end_freq_Hz = 16000.f, step_freq_octave = sqrtf(2.0); |
||||
setStepPattern(start_freq_Hz, end_freq_Hz, step_freq_octave); |
||||
setTargetDurPerStep_sec(0.25); |
||||
resetState(); |
||||
} |
||||
void begin(void) { |
||||
//activate the instrumentation
|
||||
sig_gen.begin(); |
||||
sig_meas.begin(this); |
||||
|
||||
//start the test
|
||||
resetState(); |
||||
recomputeTargetNumberOfSteps(); |
||||
gotoNextStep(); |
||||
} |
||||
|
||||
//use this to cancel the test
|
||||
//void end(void) {
|
||||
// finishTest();
|
||||
//}
|
||||
|
||||
void printTableOfResults(Stream *s) { |
||||
s->println("AudioControlTestFreqSweep_F32: Start Table of Results..."); |
||||
AudioControlSignalTester_F32::printTableOfResults(s); |
||||
s->println("AudioControlTestFreqSweep_F32: End Table of Results..."); |
||||
} |
||||
|
||||
|
||||
protected: |
||||
float signal_frequency_Hz = 1000.f; |
||||
float signal_amplitude_dBFS = -50.0f; |
||||
|
||||
virtual int recomputeTargetNumberOfSteps(void) { |
||||
return target_n_steps = (int)(log10f(end_val/start_val)/log10f(step_val)+0.5) + 1; //round
|
||||
}
|
||||
|
||||
virtual void updateSignalGenerator(void) { |
||||
//logarithmically step the frequency
|
||||
float new_freq_Hz = start_val * powf(step_val,counter_step); |
||||
Serial.print("AudioControlTestFreqSweep_F32: updateSignalGenerator(): setting freq to "); |
||||
Serial.println(new_freq_Hz); |
||||
setSignalFrequency_Hz(new_freq_Hz); |
||||
} |
||||
void finishTest(void) { |
||||
|
||||
//disable the test instrumentation
|
||||
setSignalAmplitude_dBFS(-1000.0f); //some very quiet value
|
||||
setSignalFrequency_Hz(1000.f); |
||||
|
||||
//do all of the common actions
|
||||
AudioControlSignalTester_F32::finishTest(); |
||||
|
||||
//print results
|
||||
printTableOfResults(&Serial); |
||||
} |
||||
|
||||
//void resetState(void) {
|
||||
// AudioControlSignalTester_F32::resetState();
|
||||
//}
|
||||
}; |
||||
|
||||
|
||||
|
||||
#endif |
||||