This is the integer math version:

#define nelems(x) sizeof(x)/sizeof(*x)

const int Fs = 5000; // Sample Rate

const int D = 5; // Down sampling factor

float T = 1.0; // Acquisition Time sec

double meanValue = 0.0;

double stdValue = 0.0;

int volatile sampleInd = 0; // Global Buffer Location

int * volatile rawSignal; // Acquisition RAM Buffer

int * polySignal[D]; // PolySignal branches

int * polyIQ[2]; // Quadrature filtered, downsampled, demodulated signals

unsigned int * polyResult; // Reconstructed, LP filtered signal

// I-Q quadrature oscillations

const float I[D] = {2.0, 0.61803398,-1.61803398,-1.61803398, 0.61803398};// Cosine

const float Q[D] = {0.0, 1.90211303, 1.17557050,-1.17557050,-1.90211303};// Sine

// AntiAliasing filter coefficients :: FIR window Kaiser, Fs=5000, Fc=300

const float AAF[15] = {0.01786240,0.03388546,0.05089129,0.06751284,0.08232631,0.09400803,0.10148476,0.10405780,0.10148476,0.09400803,0.08232631,0.06751284,0.05089129,0.03388546,0.01786240};

float * polyAAF[D]; // Polyphase downsampled impulse responses

// LP filter coefficients :: FIR window Kaiser, Fs=1000, Fc=15

const float LP[21] = {0.04144742,0.04320807,0.04483017,0.04629891,0.04760078,0.04872372,0.04965724,0.05039261,0.05092289,0.05124307,0.05135014,0.05124307,0.05092289,0.05039261,0.04965724,0.04872372,0.04760078,0.04629891,0.04483017,0.04320807,0.04144742};

void computeOutput(){

timemicros = micros();

rawSignal[0] = rawSignal[5]; // First value adjust

int offset = 0; // Offset

for(int h=0;h<Fs*T;h++)

offset+=rawSignal[h];

offset/=Fs*T;

for (int i=0;i<Fs*T/D;i++) // Initialize arrays

{

polyIQ[0][i] = 0;

polyIQ[1][i] = 0;

}

for (int j=0;j<D;j++)

{

// DownSampling

for (int i=j;i<Fs*T;i+=5)

polySignal[j][i/5] = rawSignal[i]-offset; // Downsampling and offset removal

for (int i=j;i<nelems(AAF);i+=5)

polyAAF[j][i/5] = AAF[i];

// AntiAlias Filtering

filter(polyAAF[j],nelems(AAF)/D,polySignal[j],(int) Fs*T/D);

// Quadrature Demodulation

for (int i=0;i<Fs*T/D;i++)

{

polyIQ[0][i] += I[j]*(polySignal[j][i]);

polyIQ[1][i] += Q[j]*(polySignal[j][i]);

}

}

// Norm calculation :: sqrt(I^2+Q^2)

for (int i=0;i<Fs*T/D;i++)

polyResult[i] = (unsigned int) sqrt(polyIQ[0][i]*polyIQ[0][i] + polyIQ[1][i]*polyIQ[1][i]);

// LP filtering

filter((float *) LP,nelems(LP),(int*) polyResult,(int) Fs*T/D);

// Elaborate stats

statistics();

double convFactor = 2.0*4.0/65535.0; // 2 * FullScale / (2^16-1)

meanValue *= convFactor;

stdValue *= convFactor;

printResults();

polyFreeAlloc();

timemicros=micros()-timemicros;

Serial.println(timemicros);

}

bool polyAlloc()

{

if(NULL != rawSignal)

{

free(rawSignal); // Deallocate buffer memory

free(polyResult);

rawSignal = NULL;

polyResult= NULL;

}

rawSignal = (int *)malloc(Fs*T*sizeof(int)); // Dynamic Memory Allocation

polyResult = (unsigned int *)malloc(Fs*T/D*sizeof(int));

polyIQ[0] = (int *)malloc(Fs*T/D*sizeof(int));

polyIQ[1] = (int *)malloc(Fs*T/D*sizeof(int));

bool polys = true;

for (int j=0;j<D;j++)

{

polySignal[j]= (int *)malloc(Fs*T/D*sizeof(int));

polyAAF[j] = (float *)malloc(nelems(AAF)/D*sizeof(float));

polys &= polySignal[j] != NULL && polyAAF[j] != NULL;

}

return (rawSignal[0] != NULL && polyIQ[0] != NULL && polyIQ[1] != NULL && polyResult != NULL && polys);

}

void filter(float *Num, int n, int *vect, int vLen)

{

int average = 0; // Initial conditions calculation

for(int h=0;h<vLen;h++)

average+=vect[h];

average/=vLen;

int numbuf[n]; // Initialize FIFO FIR buffer

for(int h=0;h<n;h++)

numbuf[h]=average;

for (int h=0;h<vLen;h++){ // Filtering cycle

int FIR = 0;

for (int k=n-1;k>0;k--) // Cycle FIR buffer elements

numbuf[k]=numbuf[k-1];

numbuf[0] = vect[h]; // Push new element inside FIR buffer

for (int j=0;j<n;j++) // FIR convolution

FIR += (int) numbuf[j]*Num[j];

vect[h] = FIR; // Output calculation

}

}