static RCCResult
run(RCCWorker *self, RCCBoolean timedOut, RCCBoolean *newRunCondition) {
(void)timedOut;(void)newRunCondition;
Comparator_complexProperties *p = self->properties;
printf("In comparator::runComplexTest\n");
RCCPort
*in_unit_test = &self->ports[COMPARATOR_COMPLEX_IN_UNIT_TEST],
*in_expected = &self->ports[COMPARATOR_COMPLEX_IN_EXPECTED],
*out_delta = &self->ports[COMPARATOR_COMPLEX_OUT_DELTA],
*out_actual = &self->ports[COMPARATOR_COMPLEX_OUT_ACTUAL];
Comparator_complexIn_unit_testIq
*inUTData = in_unit_test->current.data,
*inEXData = in_expected->current.data,
*outActualData = out_actual->current.data;
int16_t
*outDeltaData = out_delta->current.data;
if ( in_unit_test->input.length != in_expected->input.length ) {
printf("/n/n The data length coming from the unit under test and the expected results file differ\n");
printf("UUT data length = %zu, expected data length = %zu\n", in_unit_test->input.length , in_expected->input.length );
printf("This will cause the test to fail. The output of the UUT and the expected results data should be identical\n");
p->passed = 0;
}
size_t len = byteLen2Complex( in_unit_test->input.length );
size_t i;
if (real2bytes(len) > out_delta->current.maxLength)
return self->container.setError("Delta output buffer size %zu, but %zu is required",
out_delta->current.maxLength, real2bytes(len));
for ( i=0; i<len; i++ ) {
double delta = fabs( scabs(inUTData->data[i].I, inUTData->data[i].Q) -
scabs(inEXData->data[i].I, inEXData->data[i].Q) );
// printf("Calculated delta = %f \n", delta );
if ( delta > p->deviation ) {
p->passed = 0;
}
outDeltaData[i] = Scale( delta );
}
out_delta->output.u.operation = 0;
out_delta->output.length = Complex2bytes(len);
memcpy( outActualData, inUTData, in_unit_test->input.length);
out_actual->output.u.operation = in_unit_test->input.u.operation;
out_actual->output.length = in_unit_test->input.length;
return RCC_ADVANCE;
}
static RCCResult
run(RCCWorker *self, RCCBoolean timedOut, RCCBoolean *newRunCondition) {
(void)timedOut;(void)newRunCondition;
MyState *s = self->memories[0];
Cic_hpfilter_complexProperties *p = self->properties;
RCCPort
*in = &self->ports[CIC_HPFILTER_COMPLEX_IN],
*out = &self->ports[CIC_HPFILTER_COMPLEX_OUT];
Cic_hpfilter_complexInIq
*inData = in->current.data,
*outData = out->current.data;
out->output.u.operation = in->input.u.operation;
out->output.length = in->input.length;
switch( in->input.u.operation ) {
case CIC_HPFILTER_COMPLEX_IN_IQ:
{
unsigned out_idx = 0;
unsigned len = byteLen2Complex(in->input.length);
unsigned i, samp;
#ifndef NDEBUG
printf("%s got %zu bytes of data\n", __FILE__, in->input.length);
#endif
// We may need to generate more output data from the last input
unsigned max_out = byteLen2Complex(out->current.maxLength);
if ( s->remainder ) {
for ( i=0; (i<s->remainder) && (out_idx<max_out); i++, out_idx++ ) {
outData->data[out_idx].I = s->fast_acc[II][STAGES];
outData->data[out_idx].Q = s->fast_acc[QQ][STAGES];
}
s->remainder -= i;
if ( out_idx >= max_out ) {
return sendOutput( self, s, out, s->input_idx, byteLen2Complex(in->input.length));
}
}
len = min(len,max_out);
for ( samp=s->input_idx; samp<len; samp++ ) {
// I
s->slow_acc[II][0] = inData->data[samp].I;
s->fast_acc[II][0] = s->fast_acc[II][0] + s->slow_acc[II][STAGES];
for ( i=0; i<STAGES; i++ ) {
s->slow_acc[II][i+1] = s->slow_acc[II][i] - s->slow_del[II][i];
s->slow_del[II][i] = s->slow_acc[II][i];
}
for ( i=1; i<=STAGES; i++ ) {
s->fast_acc[II][i] = s->fast_acc[II][i] + s->fast_acc[II][i-1];
}
// Q
s->slow_acc[QQ][0] = inData->data[samp].Q;
s->fast_acc[QQ][0] = s->fast_acc[QQ][0] + s->slow_acc[QQ][STAGES];
for ( i=0; i<STAGES; i++ ) {
s->slow_acc[QQ][i+1] = s->slow_acc[QQ][i] - s->slow_del[QQ][i];
s->slow_del[QQ][i] = s->slow_acc[QQ][i];
}
for ( i=1; i<=STAGES; i++ ) {
s->fast_acc[QQ][i] = s->fast_acc[QQ][i] + s->fast_acc[QQ][i-1];
}
// Generate the interpolated output
// We are not really interpolating here, just copying the last calculated value
for ( i=0; i<p->M; i++, out_idx++ ) {
if ( out_idx >= max_out ) {
s->remainder = p->M-i;
return sendOutput( self, s, out, samp, byteLen2Complex(in->input.length));
}
double gain = Gain( p->gain);
outData->data[out_idx].I = Scale( Uscale(s->fast_acc[II][STAGES]) * gain);
outData->data[out_idx].Q = Scale( Uscale(s->fast_acc[QQ][STAGES]) * gain);
double v = scabs( outData->data[out_idx].I, outData->data[out_idx].Q );
if ( v > Uscale( p->peakDetect ) ) {
p->peakDetect = Scale( v );
}
}
}
return sendOutput( self, s, out, samp, byteLen2Complex(in->input.length));
}
break;
case CIC_HPFILTER_COMPLEX_IN_SYNC:
sync( self );
case CIC_HPFILTER_COMPLEX_IN_TIME:
self->container.send( out, &in->current, in->input.u.operation, in->input.length);
break;
}
return RCC_OK;
}
