So I wrote a reply and it never appeared.
Anyway I will send the code again.
#define BUFFER_SIZE 8
#define FILTER_TAP_NUM 256
#define SAMPLING_FREQUENCY_HZ 48000.0f
__attribute__((aligned(32))) int32_t adcData[BUFFER_SIZE];
__attribute__((aligned(32))) int32_t dacData[BUFFER_SIZE];
static volatile __attribute__((aligned(32))) int32_t *inBufPtr;
static volatile __attribute__((aligned(32))) int32_t *outBufPtr;
static float firdata [FILTER_TAP_NUM];
static int firptr [FILTER_TAP_NUM];
static int fir_w_ptr = 0;
float Calc_FIR (float inSample) {
float inSampleF = inSample;
float outdata = 0;
for (int i = 0; i < FILTER_TAP_NUM; i++) {
outdata += (firdata[i]*cabinetIR[firptr[i]]); // cabinetIR is the FFT
firptr[i]++;
}
firdata[fir_w_ptr] = inSampleF;
firptr[fir_w_ptr] = 0;
fir_w_ptr++;
if (fir_w_ptr == FILTER_TAP_NUM) fir_w_ptr=0;
return outdata;
}
void Process_HalfBuffer() {
// Input samples
static float leftIn = 0.0f;
static float leftProcessed = 0.0f;
// Loop through half of audio buffer (double buffering), convert int->float, apply processing, convert float->int, set output buffers
for (uint16_t i = 0; i < (BUFFER_SIZE/2); i += 2) {
/*
* Convert current input samples (24-bits) to floats (two I2S data lines, two channels per data line)
*/
// Extract 24-bits via bit mask
inBufPtr[i] &= 0xFFFFFF;
inBufPtr[i + 1] &= 0xFFFFFF;
// Check if number is negative (sign bit)
if (inBufPtr[i] & 0x800000) {
inBufPtr[i] |= ~0xFFFFFF;
}
if (inBufPtr[i + 1] & 0x800000) {
inBufPtr[i + 1] |= ~0xFFFFFF;
}
// Normalise to float (-1.0, +1.0)
leftIn = (float) inBufPtr[i] / (float) (0x7FFFFF);
/*
* Apply processing
*/
//leftProcessed = leftIn; // Passthru
//leftProcessed = (1.0f - wet) * leftIn + wet * Do_Reverb(leftIn); // Reverb
//x = *DWT_CYCCNT;
leftProcessed = Calc_FIR(leftIn);
//y = *DWT_CYCCNT;
//cycles = y - x;
leftProcessed *= 1.5f; // Volume
// Ensure output samples are within [-1.0,+1.0] range
if (leftProcessed < -1.0f) {
leftProcessed = -1.0f;
} else if (leftProcessed > 1.0f) {
leftProcessed = 1.0f;
}
// Scale to 24-bit signed integer and set output buffer
outBufPtr[i] = (int32_t)(leftProcessed * 0x7FFFFF);
}
dataReadyFlag = 0;
}
void HAL_I2SEx_TxRxHalfCpltCallback(I2S_HandleTypeDef *hi2s)
{
inBufPtr = &(adcData[0]);
outBufPtr = &(dacData[0]);
//Process_HalfBuffer();
dataReadyFlag = 1;
}
void HAL_I2SEx_TxRxCpltCallback(I2S_HandleTypeDef *hi2s)
{
inBufPtr = &(adcData[BUFFER_SIZE/2]);
outBufPtr = &(dacData[BUFFER_SIZE/2]);
//Process_HalfBuffer();
dataReadyFlag = 1;
}
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MPU Configuration--------------------------------------------------------*/
MPU_Config();
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_SPI4_Init();
MX_I2S3_Init();
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
CS4272_Init();
HAL_I2SEx_TransmitReceive_DMA(&hi2s3, (uint16_t *)&dacData[0], (uint16_t *)&adcData[0], BUFFER_SIZE);
while (1)
{
if(dataReadyFlag) {
Process_HalfBuffer();
}
}
/* USER CODE END 3 */
}
And here is a screenshot of the waveform.
So I added a few lines to measure the cycles for the calculation, using the DWT_CYCCNT.
I changed the BUFFER_SIZE to 256 and FILTER_TAPS to 256 and the cycles for the Calc_FIR() function are ~45700.
And this is the resulting waveform.
If I lower the BUFFER_SIZE to 8 then this is the resulting waveform. Cycles are ~50000.
No, the H7 at 400 or 600MHz (H7S3) will be much faster than a F411.
The difference to a "real" DSP is ...
https://en.wikipedia.org/wiki/Digital_signal_processor
...and just see, whats in the "cpu" (-> soc: Snapdragon 636) of my 6y old $160 mobile phone, for only the audio processing there is a "small" DSP : Hexagon 680 , running at 500MHz , with full 4 cores;
these could run a Linux system on their own, without the other main cpu's on the chip.
Just read a little about this "small" DSP,
...then you know, whats the difference "cpu with some dsp instructions" to a "dsp with VLIW instuctions and many (!) ALUs on each of its cores....
The more recent versions -> Hexagon 698 DSP capable of 15 trillion operations per second (TOPS)
Compare this to fast cpu like H7 , doing 500 million OPS .... speed is about 0,003 % of the Hexagon698.
And its just the "helping co-processor" for audio etc , for the 8 ARM main cores at 2 GHz or so.
