Q7 到 Q15 转换

Question

I want to convert number in Q7 format to number in Q15 format using function available in CMSIS Library (void arm_q7_to_q15). Here is the beginning of this function:

/**    
 * @brief Converts the elements of the Q7 vector to Q15 vector.    
 * @param[in]       *pSrc points to the Q7 input vector    
 * @param[out]      *pDst points to the Q15 output vector   
 * @param[in]       blockSize length of the input vector    
 * @return none.    
*/

void arm_q7_to_q15(
  q7_t * pSrc,
  q15_t * pDst,
  uint32_t blockSize)

I don't know how to define variables for this function. I'd tried to define them like this:

q7_t a = 0.78125; //what number should I define here 0.78125 or 01100100 (in q7)?
q15_t b;
uint32_t bs; //bs=? what number should I define here?

My main function:

int main (void)
{
arm_q7_to_q15(a,b,bs);
}

Thank you for helping me.

Answer 1

Pointer to psrc must be a vector of size bs by type q7 . (exactly is q7_t a[bs] ) bs must be unsigned 32 bit integer. What sholud be a ? This must be between -1 to 1, since it have only one bit just for sign. and its precision <7> indicate It's absolute minimum value is 1/(2^7).

It mean's a=1 will consequence in q7 a become actually 1/(2^7).

Stored decimal->  Stored bin  ->fractional

a=1           -> `0b00000001` -> 1/(2^7)=0.0078125

a=2           -> `0b00000010` -> 2/(2^7)

a=3           -> `0b00000011` -> 3/(2^7)

...

a=n           -> `0b00000000` -> n/(2^7)

a=128         -> `0b01111111` -> (128/(2^7))=1

And your must not exceed 2^7 you can test what will and q7_t is in compiler known by int8_t. Because of this you can estimate what will hppen if a exceed 2^7. And since 1 of 8 bit's assigned to sign. The fraction presicion become 7. And it called Q1.7 and Q7 for shorthand. (1 in Q is part for sign and integer value)

If you want to convert your data you must first convert to float (using cast or mathematical operation between float varibales) then convert them to Q by support function. And note float number can be even larger than one, the float are scientific view on number in base of two, x*2^f, memory have three part s,x,f and s is sign. Other note is that Q's are always round to floor!(as I've perceived)

There is a good example for better understanding:

  float32_t arrf[6]={0.01,0.1,1,10,100,1000};
  float32_t arrf2[6];
  q15_t     arrq[6]={1,10,100,1000,10000,
          0b0111111111111111/*32767*/};
  q15_t     arrq2[6];
  q15_t     arrq3[6];
  q15_t     arrq4[6];
  q15_t     arrq5[6];
  q15_t     arrq6[6];

  uint16_t  arru[6]={0};

  arm_scale_f32(arrf,0.7,arrf2,6);
  arm_scale_q15(arrq,1024,0,arrq2,6);
  arm_scale_q15(arrq,1,15,arrq3,6);
  arm_scale_q15(arrq,4000,0,arrq4,6);
  arm_scale_q15(arrq,8000,0,arrq5,6);
  arm_scale_q15(arrq,32767,0,arrq6,6);

Answer:

arrf2= 0.00699999975,0.0700000003,0.699999988,7,70.700 arrq2= 0,0,3,31,312,1023 arrq3= 1,10,100,1000,10000,32767 arrq4= 0,1,12,122,1220,3999 arrq5= 0,2,24,244,2441,7999 arrq6= 0,9,99,999,9999,32766

And it's important to know: