Fixed-point arithmetic for embedded DSP in Signal Processing - Step-by-Step Execution

Concept Flow - Fixed-point arithmetic for embedded DSP

Start with integer input

↓

Scale input by factor (e.g., 2^N)

↓

Store as fixed-point integer

↓

Perform arithmetic (add, multiply) on fixed-point

↓

Adjust result scale (shift right by N)

↓

Convert back to float or output fixed-point

↓

End

Fixed-point arithmetic scales numbers to integers for DSP, performs math, then rescales results.

Execution Sample

Signal Processing

input_val = 0.75
scale = 256  # 2^8
fixed_val = int(input_val * scale)
result = (fixed_val * 512) >> 8  # 512 = fixed-point 2.0
output = result / scale

Convert float 0.75 to fixed-point, multiply by fixed-point 2.0, then convert back to float.

Execution Table

Step	Variable	Value	Operation	Result
1	input_val	0.75	Initial float input	0.75
2	scale	256	Set scale factor (2^8)	256
3	fixed_val	192	Multiply input_val * scale and convert to int	0.75 * 256 = 192
4	fixed_val * 512	98304	Multiply fixed_val by fixed-point 2.0 (512)	192 * 512 = 98304
5	(fixed_val * 512) >> 8	384	Shift right by 8 bits (divide by 256)	98304 >> 8 = 384
6	output	1.5	Divide by scale to get float	384 / 256 = 1.5
7	-	-	End of computation	-

💡 Computation ends after converting fixed-point result back to float.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	After Step 6
input_val	0.75	0.75	0.75	0.75	0.75
scale	256	256	256	256	256
fixed_val	N/A	192	192	192	192
fixed_product (fixed_val*512)	N/A	N/A	98304	98304	98304
result shifted	N/A	N/A	N/A	384	384
output	N/A	N/A	N/A	N/A	1.5

Key Moments - 3 Insights

Why do we multiply the float input by 256 before converting to int?

Multiplying by 256 scales the float to an integer range, preserving precision as fixed-point. See execution_table step 3.

Why do we shift right by 8 bits after multiplication?

Shifting right by 8 bits divides by 256, adjusting the scale back after multiplication. See execution_table step 5.

What is the final output and why?

1.5, because 0.75 * 2 = 1.5. The fixed-point operations correctly scale, multiply, rescale, preserving accuracy. See execution_table steps 4-6.

Visual Quiz - 3 Questions

Look at the execution table at step 3. What is the value of fixed_val?

A 256

B 192

C 0.75

D 384

💡 Hint

Check the 'Value' column at step 3 in the execution_table.

At which step does the code perform the scale adjustment after multiplication?

A Step 5

B Step 6

C Step 4

D Step 3

💡 Hint

Look for the right shift operation in the execution_table.

If we change scale from 256 to 512, what happens to fixed_val at step 3?

A It halves to 96

B It stays 192

C It doubles to 384

D It becomes 512

💡 Hint

fixed_val = input_val * scale, so doubling scale doubles fixed_val (see variable_tracker).

Concept Snapshot

Fixed-point arithmetic stores floats as scaled integers.
Multiply float by 2^N, convert to int.
Perform math on integers.
Shift right by N bits to rescale.
Convert back to float if needed.
Used in embedded DSP for fast, precise math.

Full Transcript

Fixed-point arithmetic converts floating-point numbers into scaled integers by multiplying by a power of two, such as 256 (2^8). This scaling preserves precision while allowing integer math. The code example starts with input_val 0.75, multiplies by 256 to get fixed_val 192. Then it multiplies fixed_val by 512 (fixed-point 2.0), resulting in 98304. To adjust the scale back, it shifts right by 8 bits (divides by 256), yielding 384. Finally, dividing by 256 converts back to float, giving 1.5. This process is common in embedded DSP to perform fast arithmetic without floating-point hardware. Key moments include understanding why scaling and shifting are needed to maintain precision and scale. The visual quiz checks understanding of these steps and the effect of changing scale.

Practice

1. What is the main reason to use fixed-point arithmetic in embedded DSP systems?

easy

A. To increase the precision beyond floating-point numbers

B. To perform fast math on devices without floating-point hardware

C. To simplify programming by avoiding scaling

D. To use more memory for storing numbers

Solution

1. Step 1: Understand fixed-point arithmetic purpose

   Fixed-point arithmetic is used to perform calculations efficiently on devices that lack floating-point hardware.

2. Step 2: Compare options with this purpose

   To perform fast math on devices without floating-point hardware correctly states the main reason: fast math on devices without floating-point units. Other options are incorrect because fixed-point does not increase precision beyond floating-point, does not simplify programming by avoiding scaling, and does not use more memory.

3. Final Answer:

   To perform fast math on devices without floating-point hardware -> Option B

4. Quick Check:

   Fixed-point speeds math on limited hardware = A [OK]

Hint: Fixed-point is for speed on limited hardware [OK]

Common Mistakes:

• Thinking fixed-point increases precision beyond floating-point
• Assuming fixed-point uses more memory
• Believing fixed-point avoids scaling complexity

2. Which of the following is the correct way to represent a fixed-point number with 8 fractional bits in C?

easy

A. int16_t fixed = value << 8;

B. int16_t fixed = value >> 8;

C. int16_t fixed = value * 8;

D. int16_t fixed = value / 8;

Solution

1. Step 1: Understand fixed-point scaling

   For 8 fractional bits, multiply the integer value by 2^8 (which is shifting left by 8) to convert to fixed-point.

2. Step 2: Match with options

   int16_t fixed = value << 8; shifts left by 8 bits, correctly scaling the value. int16_t fixed = value >> 8; shifts right (wrong direction), A divides by 8 (wrong), C multiplies by 8 (not 256).

3. Final Answer:

   int16_t fixed = value << 8; -> Option A

4. Quick Check:

   Shift left by fractional bits to scale = D [OK]

Hint: Shift left by fractional bits to convert to fixed-point [OK]

Common Mistakes:

• Shifting right instead of left
• Multiplying/dividing by wrong powers of two
• Confusing fractional bits with decimal places

3. Given two fixed-point numbers with 8 fractional bits: a = 0x0100 (1.0) and b = 0x0200 (2.0), what is the fixed-point result of c = (a * b) >> 8;?

medium

A. 0x0400 (4.0)

B. 0x0300 (3.0)

C. 0x0200 (2.0)

D. 0x0100 (1.0)

Solution

1. Step 1: Multiply fixed-point values

   a * b = 0x0100 * 0x0200 = 256 * 512 = 131072 (decimal)

2. Step 2: Adjust scale by shifting right 8 bits

   c = 131072 >> 8 = 131072 / 256 = 512 decimal = 0x0200

3. Step 3: Recalculate carefully

   Wait, 0x0100 = 256 decimal, 0x0200 = 512 decimal. Multiplying: 256 * 512 = 131072 decimal. Shifting right 8 bits divides by 256: 131072 / 256 = 512 decimal = 0x0200. So c = 0x0200 (2.0).

4. Final Answer:

   0x0200 (2.0) -> Option C

5. Quick Check:

   (1.0 * 2.0) = 2.0 fixed-point = 0x0200 [OK]

Hint: Multiply then shift right by fractional bits to rescale [OK]

Common Mistakes:

• Forgetting to shift right after multiplication
• Misinterpreting hex values as decimal
• Incorrect bit shift amount

4. Identify the error in this fixed-point multiplication code snippet with 8 fractional bits:

int16_t a = 0x0100; // 1.0
int16_t b = 0x0200; // 2.0
int16_t c = a * b;

medium

A. Missing right shift to rescale after multiplication

B. Variables should be float, not int16_t

C. Should shift left before multiplication

D. No error, code is correct

Solution

1. Step 1: Understand fixed-point multiplication scaling

   Multiplying two fixed-point numbers doubles the fractional bits, so the result must be shifted right by the fractional bit count to rescale.

2. Step 2: Analyze given code

   The code multiplies a and b but does not shift right by 8 bits, so the scale is incorrect.

3. Final Answer:

   Missing right shift to rescale after multiplication -> Option A

4. Quick Check:

   Shift right after multiply to fix scale = C [OK]

Hint: Always shift right after fixed-point multiply [OK]

Common Mistakes:

• Not shifting right after multiplication
• Using float instead of fixed-point on embedded
• Shifting left instead of right

5. You have a fixed-point format with 12 fractional bits. You want to multiply two numbers and keep the result in the same format without overflow. Which approach is best?

hard

A. Multiply, then shift left by 12 bits, and store in a 16-bit integer

B. Shift right by 12 bits before multiplying, store in 16-bit integer

C. Multiply without shifting, store in 16-bit integer

D. Multiply, then shift right by 12 bits, and store in a 32-bit integer

Solution

1. Step 1: Understand fixed-point multiplication with 12 fractional bits

   Multiplying two fixed-point numbers doubles fractional bits (24 bits), so shifting right by 12 bits rescales back to 12 fractional bits.

2. Step 2: Prevent overflow by using wider integer

   Multiplying two 16-bit numbers can overflow 16 bits, so use a 32-bit integer to hold the intermediate product safely.

3. Final Answer:

   Multiply, then shift right by 12 bits, and store in a 32-bit integer -> Option D

4. Quick Check:

   Shift right after multiply and use wider int = B [OK]

Hint: Use wider int and shift right after multiply [OK]

Common Mistakes:

• Not using wider integer causing overflow
• Shifting left instead of right after multiply
• Shifting before multiply losing precision