БИХ-фильтр на 16-битном микроконтроллере (PIC24F)

Я не слишком углублялся в дизайн вашего фильтра, но просто взглянув на исходный код, я обнаружил пару вещей. Например, эти строки:

aux1 = ((long)b0*xn) << 1;
aux2 = ((long)a1*y) << 1;
y = ((aux1 + aux2) >> 16);

Первая проблема, которую я вижу, это ((long)b0*xn). Я встречал компиляторы, которые неправильно компилировали бы это как ((long)(b0*xn)), что совершенно неверно. На всякий случай я бы написал это как (((long)b0)*((long)xn)). Безусловно, это параноидальное программирование, но...

Затем, когда вы делаете "<<1", это НЕ то же самое, что "*2". Для большинства вещей это близко, но не для DSP. Это связано с тем, как MCU/DSP обрабатывает условия переполнения, расширения знака и т. д. Но даже если он работает как *2, вы удаляете один бит разрешения, который вам не нужно удалять. Если вам действительно нужно сделать *2, тогда сделайте *2 и дайте компилятору выяснить, может ли он вместо этого заменить <<1.

>>16 также проблематичен. Внезапно я не знаю, произойдёт ли это логический или арифметический сдвиг. Вам нужен арифметический сдвиг. Арифметические сдвиги правильно обработают бит знака, тогда как логический сдвиг будет вставлять нули для новых битов. Кроме того, вы можете сэкономить биты разрешения, избавившись от <<1 и изменив >>16 на >>15. Ну и изменение всего этого на нормальное умножение и деление.

Итак, вот код, который я бы использовал:

aux1 = ((long)b0) * ((long)xn);
aux2 = ((long)a1) * ((long)y);
y = (short)((aux1+aux2) / 32768);

Я не утверждаю, что это решит вашу проблему. Это может или не может, но это улучшает ваш код.

Я предлагаю вам заменить «короткий» на «int16_t» и «длинный» на «int32_t». Сохраните «short», «int», «long» и т. д. для мест, где размер не имеет большого значения, например, для циклических индексов.

Тогда алгоритм будет работать так же, если вы компилируете на своем настольном компьютере. На рабочем столе будет намного проще отлаживать. Когда он будет удовлетворительно работать на рабочем столе, тогда переместите его на микропроцессор. Чтобы упростить задачу, разместите хитрую подпрограмму в отдельном файле. Вы, вероятно, захотите написать простую функцию main() для рабочего стола, которая выполняет процедуру и завершает работу с нулем (в случае успеха) или ненулевым значением (в случае неудачи).

Затем интегрируйте сборку и запуск теста в систему сборки вашего проекта. Любая система разработки, которую стоит рассмотреть, позволит вам сделать это, но вам, возможно, придется прочитать руководство. Мне нравится GNU Make .

Дэвид Кесснер упомянул, что >> 16 ненадежен, и это правда. Я был укушен этим раньше, поэтому теперь у меня всегда есть статическое утверждение в моем коде, которое проверяет, что >> работает так, как я ожидаю.

Вместо этого он предложил фактический разрыв. Но вот как сделать правильную арифметику >> 16, если выяснится, что у вас нет.

union
{
     int16_t i16s[2];
    uint16_t i16u[2];

     int32_t i32s;
    uint32_t i32u;
}union32;

union32 x;
x.i32s = -809041920;

// now to divide by 65536

x.i16u[0] = x.i16u[1];        // The shift happens in one go.

                              // Now we do the sign extension
if (x.i16u[0] & 0x8000)       // Was this a negative number?
    x.i16u[1] = 0xFFFF;       // Then make sure the final result is still negative
else
    x.i16u[1] = 0x0000;       // Otherwise make sure the final result is still positive

// Now x.i32s = -12345

Убедитесь, что ваш компилятор генерирует хороший код для (x.i16u[0] & 0x8000). Компиляторы Microchip не всегда используют инструкции PIC BTFSC в подобных случаях. Особенно 8-битные компиляторы. Иногда мне приходится писать это на ассемблере, когда мне действительно нужна производительность.

Выполнение сдвига таким образом намного быстрее на PIC, которые могут выполнять сдвиги только по одному биту за раз.

Использование dsPIC вместо PIC24 может значительно упростить задачу (они совместимы по выводам). Компилятор dsPIC поставляется с библиотекой DSP, которая включает IIR-фильтры, а аппаратное обеспечение напрямую поддерживает арифметику с фиксированной точкой.

Похоже, вы никогда не цените себя, прежде чем использовать его. Вы используете y в вычислении для aux2, что правильно, потому что это отфильтрованный предыдущий образец, но вы понятия не имеете, что он запустится, как в этой ситуации.

Я бы посоветовал вам взять образец ADC, прежде чем вы войдете в цикл while (1). Присвойте это значение y, задержите 5 мс, затем войдите в свой цикл. Это позволит вашему фильтру работать нормально.

Я бы также порекомендовал вам пойти дальше и сменить шорты на более длинные переменные. Если у вас мало места, у вас будет гораздо более простой код, если вам не нужно вводить приведение типов в каждом цикле.

Многие ранние микроконтроллеры даже не имели инструкции умножения, не говоря уже о делении. БИХ-фильтр с магическим значением K = 1/2^8 был специально разработан для таких микроконтроллеров.

// filter implements
// y(n)=K*x(n)+y(n-1)*(1-K)
// with K = 1/2^8.
// based on ideas from
// http://techref.massmind.org/techref/microchip/math/filter.htm
// WARNING: untested code.
// Uses no multiplies or divides.
// Eventually y converges to a kind of "average" of the x values.
short average; // global variable
// (...)
while(1){
    short xn = readADC(adc_ch);
    // hope that we don't overflow the subtract --
    // -- perhaps use saturating arithmetic here?
    short aux1 = xn - average;
    short aux2 = aux1 / 256;
    // compiler should use an arithmetic shift,
    // or perhaps an unaligned byte read, not an actual divide
    average += aux2;
    delay_ms(5);
}