time for _IQ() function?

Hi Prakash,

It really depends on how you are using the ADC results.  Do you really want them as integers or do you want the hex values to represent fractions?  IQ provides a convenient method to manage fractional scaling and _IQ() converts the value to the global scaling value

The ADC results are right-shifted in the results register.

For integer such as Q0, all 32 bits for integer representation, then read into a 32-bit variable with no shift.

For fractional such as Q31 (0 bits for integer, 31 bits for fractional representation), read the 12-bits of the ADC result into a 32-bit variable left-shifted to bits 30-19, with bit 31 left as zero to represent a positive number.

There is a section on this in the workshop student guides, see page 6-14 of this guide:  .

For MotorWare, we read the 12-bits as an integer and then use _IQ12mpy() to multiply the ADC results with an IQ12 value (scale factor in this case) to get an IQ12 result.  There are many options you can use.

Reading the ADC results:

//! \brief Reads the specified ADC result (i.e. value)

//! \param[in] adcHandle The ADC handle

//! \param[in] resultNumber The result number for the ADCRESULT registers

//! \return The ADC result

static inline uint_least16_t ADC_readResult(ADC_Handle adcHandle,const ADC_ResultNumber_e resultNumber)

{

ADC_Obj *adc = (ADC_Obj *)adcHandle;

return(adc->ADCRESULT[resultNumber]);

} // end of ADC_read() function

Converting to IQ12

// convert current A

// sample the first sample twice due to errata sprz342f, ignore the first sample

value = (_iq)ADC_readResult(obj->adcHandle,ADC_ResultNumber_1);

value = _IQ12mpy(value,current_sf) - obj->adcBias.I.value[0]; // divide by 2^numAdcBits = 2^12

pAdcData->I.value[0] = value;

Jeff

Hi Prakash,

I agree with you, 20us for (7) iterations of the _IQ() seems high.  Let's break-down what is happening when the _IQ() is called, actually not called since it is a macro.

1.  _IQ() is replaced by "#define   _IQ(A)  _IQ15(A)", since you have IQ15 set as your global IQ scaling.  This occurs in IQmathLib.h.

2.  _IQ15(A) is replaced with "(long) ((A) * 32768.0L)" 

So your question really comes down to, how long does it take to do (7) 32b mutliplies (32b * 32b).  This will depend on the ASM code generated by the compiler, which depends on the compiler settings and version of the compiler.  A key dependency is the optimizer setting.

Have you looked at the generated ASM code to understand the output of the compiler?  Have you tried different optimizer settings?

Please take a look at this and share this info.

Thanks,

Jeff

What processor and clock you are using? The time depend on the clock at which it is running.
_IQ is a macro, available in iqmath.h, it is a simple left shift or multiplication, both takes 1 cycle only..
Being IQ15, it is a left shift by 15, for 12 bit ADC result. You can use very well x<<=15 instead. Check the macro, it is same only.
The shift operation take just 1 cycle at most. So IQ cannot add any visible time in the total time.
As Guatam suggested, use profile clock, very accurate and simple.

Check the code above, _IQ is redefined as only shifting.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------

I think it is not an issue with function but problem in understanding.

When used with constants it translate by the pre-processor during compilation.

It is a macro to convert small float values at the stage of initialisation, say: gain = _IQ(0.001).

But with a variable inside code, 

_IQ takes a float values as parameter, so it is a float multiplication, so will take many cycles being it is a fixed point dsp.

I have never used or required to use _IQ macro inside a control/ computation loop. 

So, modify your code without using _IQ in any of the time critical loops, we cannot expect 1 cycle float operation with software float library.

I am sure it is easy to use shift operation wherever required to convert from one IQ base to another.

Hi Prakash,

You can see the ASM code from the Disassembly window (access from the View menu).  As Joy described the _IQ() function results in a simple shift that is built into the 32-bit move instruction (MOVL).  

I did a quite test using CPU Timer0 and a couple breakpoints on the following code:

gPwmData.Tabc.value[0] = _IQ(0.0);
gPwmData.Tabc.value[1] = _IQ(4.0);
gPwmData.Tabc.value[2] = _IQ(0.0);

The ASM code generated is:

706 gPwmData.Tabc.value[0] = _IQ(0.0);
008240: 0200 MOVB ACC, #0
008241: 8F40884C MOVL XAR5, #0x00884c
008243: 1EC5 MOVL *+XAR5[0], ACC

707 gPwmData.Tabc.value[1] = _IQ(4.0);
008244: FF2F0800 MOV ACC, #0x800 << 15
008246: 1ED5 MOVL *+XAR5[2], ACC

708 gPwmData.Tabc.value[2] = _IQ(0.0);
008247: 0200 MOVB ACC, #0
008248: 1EE5 MOVL *+XAR5[4], ACC

It took 4 cycles for the _IQ(4.0) and 3 cycles for the _IQ(0.0).  Compiler (6.2.3) is set for: -v28 -ml -mt -O2.

Jeff