0.8 Lab 3: lab  (Page 2/2)

Here are some guidelines for implementing the second-order section in C:

• make sure you size accumulators appropriately, and type cast accordingly when accumulating values.
• for a naive initial implementation of the circular buffer, let the newest element, w[n] always have the lowest array index (i.e., w_states[0]= w[n]). Copy overother values as required; order matters!
• Handle overflow errors correctly. You may find it convenient to write a helper function that handles overflow correctly. The function declaration for this may look like:

See the Troubleshooting section below for tips on how to correctly handle overflow issues.

Finally, verify that the second-order section works correctly when using both sets of the second-order coefficients. To do this:

1. In Matlab, obtain your filter coefficients by properly grouping the pole/zero pairs. A given combination will result in a pair of scaling factors (G1,G2), where G is as defined in Figure 1. The rule of thumb is that you want to pick the pole/zero pairs such that the worst-case gain, or min(G1,G2) is as close to 1 as possible.
2. From the Prelab exercise, verify that the quantized coefficients are properly scaled and acceptable.
3. In C, create buffers for each set of coefficients and intermediate states.
4. Initialize the intermediate state buffers.
5. Generate a test vector and verify your implementation. Refer to Step 9 of Lab 0 .

Part 3: cascade implementation

Once your single second-order IIR section is working properly, you can proceed to implement the cascade of second-order sections. The modular design in Part 2 should make this fairly straightforward. Make sure to apply the gain factors to the two filter inputs. Type-casting and shifting may be required!

Fixed-point processing: troubleshooting

This section contains additional information that will help you avoid common pitfalls associated with fixed-point processing.

Coefficients greater than 1:

You may have noticed that some of the coefficients you have computed for the second-order sections are larger than 1.0 in magnitude. For any stable second-order IIR section, the magnitude of the "0" and "2" coefficients (a ₀ and a ₂ for example) will always be less than or equal to 1.0 (make sure you understand why!). However, the magnitude of the "1" coefficient can be as large as 2.0. To overcome this problem, you will have to divide any coefficient larger than 1 by two prior to saving them for your DSP code. Then, in your implementation, accumulate twice to compensate for using half the coefficient value.

Handling overflow:

Overflow is really only a problem when one needs to truncate the result of an accumulation (i.e., store a 16-bit number into a buffer).

When accumulating numbers in twos-complement notation, a nice property is that the final value will be correct even if intermediate values overflow, as long as the final accumulated value is in the range of representable numbers (i.e., in between -32768 and +32767).

If the final value is outside of this range, then one solution is to saturate the value to +32767 or -32768. See Fixed-Point Quantization for more information about the different errors incurred by fixed-point processing.

Extra credit

In Part 2, we proposed an inefficient (yet simple) implementation of a circular buffer, where data elements are shifted one by one. This is clearly less efficient than circular addressing, where only a single pointer moves through the buffer and data elements remain fixed. For an extra credit point , write C code to get the compiler to implement circular addressing. You must be able to explain your C code and show the circular addressing in the assembler output. Hint: you will need an additional argument into iir_SoS() that keeps track of the current sample index.

Grading

Your grade on this lab will be split into three parts:

• 1 point: Prelab. Be prepared to show your Matlab code used to study coefficient quantization, and to compute poles and zeros.
• 3 points: Code. Your DSP code implementing the fourth-order IIR filter.
• 4 points: Written quiz. The quiz may cover differences between FIR and IIR filters, the prelab material, errors induced by fixed-point processing, and the MATLAB exercise.
• 1 point extra credit: Implementing hardware circular addressing in C; must verify using assembler output.