wirtz
/
OpenAudio_ArduinoLibrary
mirror of https://github.com/chipaudette/OpenAudio_ArduinoLibrary.git
1
0
Fork 0
Code Issues Releases Wiki Activity

add analyze_fft256_iq_F32 and examples/TestFFT256iq

Browse Source
pull/6/merge
boblark 4 years ago
parent 86b0b29a20
commit ce4e8fb292
3 changed files with 803 additions and 0 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 261
      analyze_fft256_iq_F32.cpp
  2. 491
      analyze_fft256_iq_F32.h
  3. 51
      examples/TestFFT256iq/TestFFT256iq.ino

261
analyze_fft256_iq_F32.cpp
Unescape View File

@ -0,0 +1,261 @@
/* analyze_fft_iq_F32.cpp
*
* Converted to F32 floating point input and also extended
* for complex I and Q inputs
* * Adapted all I/O to be F32 floating point for OpenAudio_ArduinoLibrary
* * Future: Add outputs for I & Q FFT x2 for overlapped FFT
* * Windowing None, Hann, Kaiser and Blackman-Harris.
*
* Conversion Copyright (c) 2021 Bob Larkin
* Same MIT license as PJRC:
*
* Audio Library for Teensy 3.X
* Copyright (c) 2014, Paul Stoffregen, paul@pjrc.com
*
* Development of this audio library was funded by PJRC.COM, LLC by sales of
* Teensy and Audio Adaptor boards. Please support PJRC's efforts to develop
* open source software by purchasing Teensy or other PJRC products.
*
* 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 <Arduino.h>
#include "analyze_fft256_iq_F32.h"
// Move audio data from audio_block_f32_t to the interleaved FFT instance buffer.
static void copy_to_fft_buffer1(void *destination, const void *sourceI, const void *sourceQ) {
const float *srcI = (const float *)sourceI;
const float *srcQ = (const float *)sourceQ;
float *dst = (float *)destination;
for (int i=0; i < AUDIO_BLOCK_SAMPLES; i++) {
*dst++ = *srcI++; // real sample, interleave
//*dst++ = 0.0f;
*dst++ = *srcQ++; // imag
//*dst++ = 0.0f;
}
}
static void apply_window_to_fft_buffer1(void *fft_buffer, const void *window) {
float *buf = (float *)fft_buffer; // 0th entry is real (do window) 1th is imag
const float *win = (float *)window;
for (int i=0; i < 256; i++) {
buf[2*i] *= *win++; // real
buf[2*i + 1] *= *win++; // imag
}
}
void AudioAnalyzeFFT256_IQ_F32::update(void) {
audio_block_f32_t *block_i,*block_q;
block_i = receiveReadOnly_f32(0);
if (!block_i) return;
block_q = receiveReadOnly_f32(1);
if (!block_q) {
release(block_i);
return;
}
// Here with two new blocks of data
// prevblock_i and _q are pointers to the IQ data collected last update()
if (!prevblock_i || !prevblock_q) { // Startup
prevblock_i = block_i;
prevblock_q = block_q;
return; // Nothing to release
}
// FFT is 256 and blocks are 128, so we need 2 blocks. We still do
// this every 128 samples to get 50% overlap on FFT data to roughly
// compensate for windowing.
// ( dest, i-source, q-source )
copy_to_fft_buffer1(fft_buffer, prevblock_i->data, prevblock_q->data);
copy_to_fft_buffer1(fft_buffer+256, block_i->data, block_q->data);
if (pWin)
apply_window_to_fft_buffer1(fft_buffer, window);
arm_cfft_radix4_f32(&fft_inst, fft_buffer); // Finally the FFT
count++;
for (int i=0; i < 256; i++) {
float ss = fft_buffer[2*i]*fft_buffer[2*i] + fft_buffer[2*i+1]*fft_buffer[2*i+1];
if(count==1) // Starting new average
sumsq[i] = ss;
else if (count <= nAverage) // Adding on to average
sumsq[i] += ss;
}
if (count >= nAverage) { // Average is finished
count = 0;
float inAf = 1.0f/(float)nAverage;
for (int i=0; i < 256; i++) {
int ii = 255 - (i ^ 128);
if(outputType==FFT_RMS)
output[ii] = sqrtf(inAf*sumsq[ii]);
else if(outputType==FFT_POWER)
output[ii] = inAf*sumsq[ii];
else if(outputType==FFT_DBFS)
output[ii] = 10.0f*log10f(inAf*sumsq[ii])-42.1442f; // Scaled to FS sine wave
else
output[ii] = 0.0f;
}
}
outputflag = true;
release(prevblock_i); // Release the 2 blocks that were block_i
release(prevblock_q); // and block_q on last time through update()
prevblock_i = block_i; // We will use these 2 blocks on next update()
prevblock_q = block_q; // Just change pointers
}
#if 0
==============================================================
==============================================================
/* analyze_fft1024_F32.cpp Converted from Teensy I16 Audio Library
* This version uses float F32 inputs. See comments at analyze_fft1024_F32.h
*
* Conversion parts copyright (c) Bob Larkin 2021
*
* Audio Library for Teensy 3.X
* Copyright (c) 2014, Paul Stoffregen, paul@pjrc.com
*
* Development of this audio library was funded by PJRC.COM, LLC by sales of
* Teensy and Audio Adaptor boards. Please support PJRC's efforts to develop
* open source software by purchasing Teensy or other PJRC products.
*
* 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 <Arduino.h>
#include "analyze_fft1024_F32.h"
// #include "utility/dspinst.h"
// Move audio data from an audio_block_f32_t to the FFT instance buffer.
static void copy_to_fft_buffer(void *destination, const void *source)
{
const float *src = (const float *)source;
float *dst = (float *)destination;
for (int i=0; i < AUDIO_BLOCK_SAMPLES; i++) {
*dst++ = *src++; // real sample
*dst++ = 0.0f; // 0 for Imag
}
}
static void apply_window_to_fft_buffer(void *buffer, const void *window)
{
float *buf = (float *)buffer; // 0th entry is real (do window) 1th is imag
const float *win = (float *)window;
for (int i=0; i < 1024; i++)
buf[2*i] *= *win++;
}
void AudioAnalyzeFFT1024_F32::update(void)
{
audio_block_f32_t *block;
block = receiveReadOnly_f32();
if (!block) return;
// What all does 7EM cover??
#if defined(__ARM_ARCH_7EM__)
switch (state) {
case 0:
blocklist[0] = block;
state = 1;
break;
case 1:
blocklist[1] = block;
state = 2;
break;
case 2:
blocklist[2] = block;
state = 3;
break;
case 3:
blocklist[3] = block;
state = 4;
break;
case 4:
blocklist[4] = block;
state = 5;
break;
case 5:
blocklist[5] = block;
state = 6;
break;
case 6:
blocklist[6] = block;
state = 7;
break;
case 7:
blocklist[7] = block;
copy_to_fft_buffer(fft_buffer+0x000, blocklist[0]->data);
copy_to_fft_buffer(fft_buffer+0x100, blocklist[1]->data);
copy_to_fft_buffer(fft_buffer+0x200, blocklist[2]->data);
copy_to_fft_buffer(fft_buffer+0x300, blocklist[3]->data);
copy_to_fft_buffer(fft_buffer+0x400, blocklist[4]->data);
copy_to_fft_buffer(fft_buffer+0x500, blocklist[5]->data);
copy_to_fft_buffer(fft_buffer+0x600, blocklist[6]->data);
copy_to_fft_buffer(fft_buffer+0x700, blocklist[7]->data);
if (pWin)
apply_window_to_fft_buffer(fft_buffer, window);
arm_cfft_radix4_f32(&fft_inst, fft_buffer);
for (int i=0; i < 512; i++) {
float magsq = fft_buffer[2*i]*fft_buffer[2*i] + fft_buffer[2*i+1]*fft_buffer[2*i+1];
if(outputType==FFT_RMS)
output[i] = sqrtf(magsq);
else if(outputType==FFT_POWER)
output[i] = magsq;
else if(outputType==FFT_DBFS)
output[i] = 10.0f*log10f(magsq)-54.1854f; // Scaled to FS sine wave
else
output[i] = 0.0f;
}
outputflag = true;
release(blocklist[0]);
release(blocklist[1]);
release(blocklist[2]);
release(blocklist[3]);
blocklist[0] = blocklist[4];
blocklist[1] = blocklist[5];
blocklist[2] = blocklist[6];
blocklist[3] = blocklist[7];
state = 4;
break;
}
#else
release(block);
#endif
}
#endif

491
analyze_fft256_iq_F32.h
Unescape View File

@ -0,0 +1,491 @@
/* analyze_fft_iq_F32.h
*
* Converted to F32 floating point input and also extended
* for complex I and Q inputs
* * Adapted all I/O to be F32 floating point for OpenAudio_ArduinoLibrary
* * Future: Add outputs for I & Q FFT x2 for overlapped FFT
* * Windowing None, Hann, Kaiser and Blackman-Harris.
*
* Conversion Copyright (c) 2021 Bob Larkin
* Same MIT license as PJRC:
*
*
* Audio Library for Teensy 3.X
* Copyright (c) 2014, Paul Stoffregen, paul@pjrc.com
*
* Development of this audio library was funded by PJRC.COM, LLC by sales of
* Teensy and Audio Adaptor boards. Please support PJRC's efforts to develop
* open source software by purchasing Teensy or other PJRC products.
*
* 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.
*/
/* Does complex input FFT of 1024 points. Output is not audio, and is magnitude
* only. Multiple output formats of RMS (same as I16 version, and default),
* Power or dBFS (full scale). Output can be bin by bin or a pointer to
* the output array is available. Several window functions are provided by
* in-class design, or a custom window can be provided from the INO.
*
* Functions (See comments below and #defines above:
* bool available()
* float read(unsigned int binNumber)
* float read(unsigned int binFirst, unsigned int binLast)
* int windowFunction(int wNum)
* int windowFunction(int wNum, float _kdb) // Kaiser only
* float* getData(void)
* float* getWindow(void)
* void putWindow(float *pwin)
* void setOutputType(int _type)
*
* Timing, max is longest update() time:
* T3.6 Windowed, RMS out, - uSec max
* T3.6 Windowed, Power Out, - uSec max
* T3.6 Windowed, dBFS out, - uSec max
* No Window saves 60 uSec on T3.6 for any output.
* T4.0 Windowed, RMS Out, - uSec
*
* Scaling:
* Full scale for floating point DSP is a nebulous concept. Normally the
* full scale is -1.0 to +1.0. This is an unscaled FFT and for a sine
* wave centered in frequency on a bin and of FS amplitude, the power
* at that center bin will grow by 1024^2/4 = 262144 without windowing.
* Windowing loss cuts this down. The RMS level can grow to sqrt(262144)
* or 512. The dBFS has been scaled to make this max value 0 dBFS by
* removing 54.2 dB. With floating point, the dynamic range is maintained
* no matter how it is scaled, but this factor needs to be considered
* when building the INO.
*/
#ifndef analyze_fft256iq_h_
#define analyze_fft256iq_h_
//#include "AudioStream.h"
//#include "arm_math.h"
#include "Arduino.h"
#include "AudioStream_F32.h"
#include "arm_math.h"
#include "mathDSP_F32.h"
#define FFT_RMS 0
#define FFT_POWER 1
#define FFT_DBFS 2
#define NO_WINDOW 0
#define AudioWindowNone 0
#define AudioWindowHanning256 1
#define AudioWindowKaiser256 2
#define AudioWindowBlackmanHarris256 3
class AudioAnalyzeFFT256_IQ_F32 : public AudioStream_F32 {
//GUI: inputs:2, outputs:4 //this line used for automatic generation of GUI node
//GUI: shortName:AnalyzeFFT256IQ
public:
AudioAnalyzeFFT256_IQ_F32() : AudioStream_F32(2, inputQueueArray) { // NEEDS SETTINGS etc <<<<<<<<
arm_cfft_radix4_init_f32(&fft_inst, 256, 0, 1);
useHanningWindow();
}
bool available() {
if (outputflag == true) {
outputflag = false;
return true;
}
return false;
}
float read(unsigned int binNumber) {
if (binNumber>511 || binNumber<0) return 0.0;
return output[binNumber];
}
// Return sum of several bins. Normally use with power output.
// This produces the equivalent of bigger bins.
float read(unsigned int binFirst, unsigned int binLast) {
if (binFirst > binLast) {
unsigned int tmp = binLast;
binLast = binFirst;
binFirst = tmp;
}
if (binFirst > 511) return 0.0;
if (binLast > 511) binLast = 511;
uint32_t sum = 0;
do {
sum += output[binFirst++];
} while (binFirst <= binLast);
return (float)sum * (1.0 / 16384.0);
}
int windowFunction(int wNum) {
if(wNum == AudioWindowKaiser256)
return -1; // Kaiser needs the kdb
windowFunction(wNum, 0.0f);
return 0;
}
int windowFunction(int wNum, float _kdb) {
float kd;
pWin = window;
if(wNum == NO_WINDOW)
pWin = NULL;
else if (wNum == AudioWindowKaiser256) {
if(_kdb<20.0f)
kd = 20.0f;
else
kd = _kdb;
useKaiserWindow(kd);
}
else if (wNum == AudioWindowBlackmanHarris256)
useBHWindow();
else
useHanningWindow(); // Default
return 0;
}
// Fast pointer transfer. Be aware that the data will go away
// after the next 256 data points occur.
float* getData(void) {
return output;
}
// You can use this to design windows
float* getWindow(void) {
return window;
}
// Bring custom window from the INO
void putWindow(float *pwin) {
float *p = window;
for(int i=0; i<256; i++)
*p++ = *pwin++; // Copy for the FFT
}
// Output RMS (default) Power or dBFS
void setOutputType(int _type) {
outputType = _type;
}
virtual void update(void);
private:
float output[256];
float window[256];
float *pWin = window;
float fft_buffer[512];
float sumsq[256]; // Avoid re-use of output[]
uint8_t state = 0;
bool outputflag = false;
audio_block_f32_t *inputQueueArray[2];
audio_block_f32_t *prevblock_i,*prevblock_q;
arm_cfft_radix4_instance_f32 fft_inst;
int outputType = FFT_RMS; //Same type as I16 version init
int count = 0;
int nAverage = 1;
// The Hann window is a good all-around window
void useHanningWindow(void) {
for (int i=0; i < 256; i++) {
// 2*PI/255 = 0.0246399424
window[i] = 0.5*(1.0 - cosf(0.0246399424*(float)i));
}
}
// Blackman-Harris produces a first sidelobe more than 90 dB down.
// The price is a bandwidth of about 2 bins. Very useful at times.
void useBHWindow(void) {
for (int i=0; i < 256; i++) {
float kx = 0.0246399424; // 2*PI/255
int ix = (float) i;
window[i] = 0.35875 -
0.48829*cosf( kx*ix) +
0.14128*cosf(2.0f*kx*ix) -
0.01168*cosf(3.0f*kx*ix);
}
}
/* The windowing function here is that of James Kaiser. This has a number
* of desirable features. The sidelobes drop off as the frequency away from a transition.
* Also, the tradeoff of sidelobe level versus cutoff rate is variable.
* Here we specify it in terms of kdb, the highest sidelobe, in dB, next to a sharp cutoff. For
* calculating the windowing vector, we need a parameter beta, found as follows:
*/
void useKaiserWindow(float kdb) {
float32_t beta, kbes, xn2;
mathDSP_F32 mathEqualizer; // For Bessel function
if (kdb < 20.0f)
beta = 0.0;
else
beta = -2.17+0.17153*kdb-0.0002841*kdb*kdb; // Within a dB or so
// Note: i0f is the fp zero'th order modified Bessel function (see mathDSP_F32.h)
kbes = 1.0f / mathEqualizer.i0f(beta); // An additional derived parameter used in loop
for (int n=0; n<128; n++) {
xn2 = 0.5f+(float32_t)n;
// 4/(1023^2)=0.00000382215877f
// xn2 = 0.00000382215877f*xn2*xn2;
// 4/(255^2)=0.000061514802f
xn2 = 0.000061514802f*xn2*xn2;
window[127 - n]=kbes*(mathEqualizer.i0f(beta*sqrtf(1.0-xn2)));
window[128 + n] = window[255 - n];
}
}
};
#endif
#if 0
//==================================================
//====================================================
/* analyze_fft1024_F32.h Converted from Teensy I16 Audio Library
*
* Audio Library for Teensy 3.X
* Copyright (c) 2014, Paul Stoffregen, paul@pjrc.com
*
* Development of this audio library was funded by PJRC.COM, LLC by sales of
* Teensy and Audio Adaptor boards. Please support PJRC's efforts to develop
* open source software by purchasing Teensy or other PJRC products.
*
* 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.
*/
/* Moved directly I16 to F32. Bob Larkin 16 Feb 2021
* Does real input FFT of 1024 points. Output is not audio, and is magnitude
* only. Multiple output formats of RMS (same as I16 version, and default),
* Power or dBFS (full scale). Output can be bin by bin or a pointer to
* the output array is available. Several window functions are provided by
* in-class design, or a custom window can be provided from the INO.
*
* Functions (See comments below and #defines above:
* bool available()
* float read(unsigned int binNumber)
* float read(unsigned int binFirst, unsigned int binLast)
* int windowFunction(int wNum)
* int windowFunction(int wNum, float _kdb) // Kaiser only
* float* getData(void)
* float* getWindow(void)
* void putWindow(float *pwin)
* void setOutputType(int _type)
*
* Timing, max is longest update() time:
* T3.6 Windowed, RMS out, 1016 uSec max
* T3.6 Windowed, Power Out, 975 uSec max
* T3.6 Windowed, dBFS out, 1591 uSec max
* No Window saves 60 uSec on T3.6 for any output.
* T4.0 Windowed, RMS Out, 149 uSec
*
* Scaling:
* Full scale for floating point DSP is a nebulous concept. Normally the
* full scale is -1.0 to +1.0. This is an unscaled FFT and for a sine
* wave centered in frequency on a bin and of FS amplitude, the power
* at that center bin will grow by 1024^2/4 = 262144 without windowing.
* Windowing loss cuts this down. The RMS level can grow to sqrt(262144)
* or 512. The dBFS has been scaled to make this max value 0 dBFS by
* removing 54.2 dB. With floating point, the dynamic range is maintained
* no matter how it is scaled, but this factor needs to be considered
* when building the INO.
*/
#ifndef analyze_fft256iq_F32_h_
#define analyze_fft256iq_F32_h_
#include "Arduino.h"
#include "AudioStream_F32.h"
#include "arm_math.h"
#include "mathDSP_F32.h"
#define FFT_RMS 0
#define FFT_POWER 1
#define FFT_DBFS 2
#define NO_WINDOW 0
#define AudioWindowNone 0
#define AudioWindowHanning1024 1
#define AudioWindowKaiser1024 2
#define AudioWindowBlackmanHarris1024 3
class AudioAnalyzeFFT1024_F32 : public AudioStream_F32 {
//GUI: inputs:1, outputs:0 //this line used for automatic generation of GUI node
//GUI: shortName:AnalyzeFFT1024
public:
AudioAnalyzeFFT1024_F32() : AudioStream_F32(1, inputQueueArray) {
arm_cfft_radix4_init_f32(&fft_inst, 1024, 0, 1);
useHanningWindow(); // Revisit this for more flexibility <<<<<
}
bool available() {
if (outputflag == true) {
outputflag = false;
return true;
}
return false;
}
float read(unsigned int binNumber) {
if (binNumber>511 || binNumber<0) return 0.0;
return output[binNumber];
}
// Return sum of several bins. Normally use with power output.
// This produces the equivalent of bigger bins.
float read(unsigned int binFirst, unsigned int binLast) {
if (binFirst > binLast) {
unsigned int tmp = binLast;
binLast = binFirst;
binFirst = tmp;
}
if (binFirst > 511) return 0.0;
if (binLast > 511) binLast = 511;
uint32_t sum = 0;
do {
sum += output[binFirst++];
} while (binFirst <= binLast);
return (float)sum * (1.0 / 16384.0);
}
int windowFunction(int wNum) {
if(wNum == AudioWindowKaiser1024)
return -1; // Kaiser needs the kdb
windowFunction(wNum, 0.0f);
return 0;
}
int windowFunction(int wNum, float _kdb) {
float kd;
pWin = window;
if(wNum == NO_WINDOW)
pWin = NULL;
else if (wNum == AudioWindowKaiser1024) {
if(_kdb<20.0f)
kd = 20.0f;
else
kd = _kdb;
useKaiserWindow(kd);
}
else if (wNum == AudioWindowBlackmanHarris1024)
useBHWindow();
else
useHanningWindow(); // Default
return 0;
}
// Fast pointer transfer. Be aware that the data will go away
// after the next 512 data points occur.
float* getData(void) {
return output;
}
// You can use this to design windows
float* getWindow(void) {
return window;
}
// Bring custom window from the INO
void putWindow(float *pwin) {
float *p = window;
for(int i=0; i<1024; i++)
*p++ = *pwin++;
}
// Output RMS (default) Power or dBFS
void setOutputType(int _type) {
outputType = _type;
}
virtual void update(void);
private:
float output[512];
float window[1024];
float *pWin = window;
audio_block_f32_t *blocklist[8];
float fft_buffer[2048];
uint8_t state = 0;
bool outputflag = false;
audio_block_f32_t *inputQueueArray[1];
arm_cfft_radix4_instance_f32 fft_inst;
int outputType = FFT_RMS; //Same type as I16 version init
// The Hann window is a good all-around window
void useHanningWindow(void) {
for (int i=0; i < 1024; i++) {
// 2*PI/1023 = 0.006141921
window[i] = 0.5*(1.0 - cosf(0.006141921f*(float)i));
}
}
// Blackman-Harris produces a first sidelobe more than 90 dB down.
// The price is a bandwidth of about 2 bins. Very useful at times.
void useBHWindow(void) {
for (int i=0; i < 1024; i++) {
float kx = 0.006141921; // 2*PI/1023
int ix = (float) i;
window[i] = 0.35875 -
0.48829*cosf( kx*ix) +
0.14128*cosf(2.0f*kx*ix) -
0.01168*cosf(3.0f*kx*ix);
}
}
/* The windowing function here is that of James Kaiser. This has a number
* of desirable features. The sidelobes drop off as the frequency away from a transition.
* Also, the tradeoff of sidelobe level versus cutoff rate is variable.
* Here we specify it in terms of kdb, the highest sidelobe, in dB, next to a sharp cutoff. For
* calculating the windowing vector, we need a parameter beta, found as follows:
*/
void useKaiserWindow(float kdb) {
float32_t beta, kbes, xn2;
mathDSP_F32 mathEqualizer; // For Bessel function
if (kdb < 20.0f)
beta = 0.0;
else
beta = -2.17+0.17153*kdb-0.0002841*kdb*kdb; // Within a dB or so
// Note: i0f is the fp zero'th order modified Bessel function (see mathDSP_F32.h)
kbes = 1.0f / mathEqualizer.i0f(beta); // An additional derived parameter used in loop
for (int n=0; n<512; n++) {
xn2 = 0.5f+(float32_t)n;
// 4/(1023^2)=0.00000382215877f
xn2 = 0.00000382215877f*xn2*xn2;
window[511 - n]=kbes*(mathEqualizer.i0f(beta*sqrtf(1.0-xn2)));
window[512 + n] = window[511 - n];
}
}
};
#endif
#endif

51
examples/TestFFT256iq/TestFFT256iq.ino
Unescape View File

@ -0,0 +1,51 @@
// TestFFT256iq.ino
#include "OpenAudio_ArduinoLibrary.h"
#include "AudioStream_F32.h"
#include <Audio.h>
#include <Wire.h>
#include <SPI.h>
#include <SD.h>
#include <SerialFlash.h>
// GUItool: begin automatically generated code
AudioSynthSineCosine_F32 sine_cos1; //xy=76,532
AudioAnalyzeFFT256_IQ_F32 FFT256iq1; //xy=243,532
AudioOutputI2S_F32 audioOutI2S1; //xy=246,591
AudioConnection_F32 patchCord1(sine_cos1, 0, FFT256iq1, 0);
AudioConnection_F32 patchCord2(sine_cos1, 1, FFT256iq1, 1);
//AudioControlSGTL5000 sgtl5000_1;
// GUItool: end automatically generated code
void setup(void) {
float* pPwr;
Serial.begin(9600);
delay(1000);
AudioMemory_F32(20);
Serial.println("FFT256IQ Test");
// sgtl5000_1.enable(); //start the audio board
// sgtl5000_1.inputSelect(AUDIO_INPUT_LINEIN); // or AUDIO_INPUT_MIC
sine_cos1.amplitude(0.5); // Initialize Waveform Generator
// bin spacing = 44117.648/256 = 172.335 172.3 * 4 = 689.335 Hz (T3.6)
// Half bin higher is 775.3 for testing windows
//sine_cos1.frequency(689.34f);
sine_cos1.frequency(1723.35f);
FFT256iq1.setOutputType(FFT_DBFS);
FFT256iq1.windowFunction(AudioWindowBlackmanHarris256);
//float* pw = FFT256iq1.getWindow(); // Print window
//for (int i=0; i<256; i++) Serial.println(pw[i], 4);
delay(1000);
if( FFT256iq1.available() )
pPwr = FFT256iq1.getData();
for(int i=0; i<256; i++)
Serial.println(*(pPwr + i), 8 );
}
void loop(void) {
}
Write Preview
Loading…
Cancel
Save