VPF::Реализация цифрового аудио фильтра на DSP

overmet

Дата 16.3.2011, 11:46 (ссылка)

(нет голосов)

Загрузка ...

Шустрый

Профиль
Группа: Участник
Сообщений: 83
Регистрация: 15.8.2009
Где: Gomel

Репутация: нет
Всего: -2

Дипломный проект(второй), уже скачал Code Composer Studio v4 и т.д. Теории много, и т.д. Надо реализовать что-то вроде GEFEN Digital audio translator, или звуковой карты на DSP, ФЧХ и АЧХ как у фильтра Беселя.

Нужны исходники похожих проектов для TMC320, F2812, TM 321... , и Code Composer Studio v4 кряк. И если можно, советы.

overmet

Дата 16.3.2011, 23:01 (ссылка)

(нет голосов)

Загрузка ...

Шустрый

Профиль
Группа: Участник
Сообщений: 83
Регистрация: 15.8.2009
Где: Gomel

Репутация: нет
Всего: -2

VisualDSP++ скачал для работы с сигнальными процессорами, не запускается...Multisim 8,ISIS 7,MicroCap работают, жаль на них максимум что с контроллерами можно работать. Что еще посоветуете?
Единственные исходники нашел подназванием USB_Stick_AudioFilter DSP

Файлов много в исходнике, но не все понятно, обычный код С++ понятен...

17,03,2011 VisualDSP++ уже заработал, нужен был license.dat

Все файлы связаны, общие extern переменные и т.д. Пытаюсь понять алгоритм

Код


#include "data_types.h"
#include "register_dma.h"
#include "register_cpu.h"
#include "dma_bypass1.h"
#include "ref_data_bypass.h"


#define AUTO_RELOAD     1

extern Uint16 fSineWave;

Uint32 RxL1_DMA_address;
Uint32 RxL2_DMA_address;
Uint32 RxR1_DMA_address;
Uint32 RxR2_DMA_address;
Uint32 TxL1_DMA_address;
Uint32 TxL2_DMA_address;
Uint32 TxR1_DMA_address;
Uint32 TxR2_DMA_address;

Uint16 CurrentRxL_DMAChannel =1;
Uint16 CurrentRxR_DMAChannel =1;
// 1: L1, R1 channel
// 2: L2, R2 channel 

Uint16 CurrentTxL_DMAChannel =1;
Uint16 CurrentTxR_DMAChannel =1;
// 1: L1, R1 channel
// 2: L2, R2 channel 
Uint16 RunFilterForL =0;
Uint16 RunFilterForR =0;

extern Int16 XmitL1[];
extern Int16 XmitR1[];

void setDMA_address(void)
{

#if 1 // double buffer with filtering    
    RxL1_DMA_address = (Uint32)RcvL1;   
    RxL1_DMA_address = (RxL1_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA

    RxL2_DMA_address = (Uint32)RcvL2;   
    RxL2_DMA_address = (RxL2_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA

    RxR1_DMA_address = (Uint32)RcvR1;   
    RxR1_DMA_address = (RxR1_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA

    RxR2_DMA_address = (Uint32)RcvR2;   
    RxR2_DMA_address = (RxR2_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA

    TxL1_DMA_address = (Uint32)FilterOutL1;   
    TxL1_DMA_address = (TxL1_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA

    TxL2_DMA_address = (Uint32)FilterOutL2;   
    TxL2_DMA_address = (TxL2_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA
    
    TxR1_DMA_address = (Uint32)FilterOutR1;   
    TxR1_DMA_address = (TxR1_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA
    
    TxR2_DMA_address = (Uint32)FilterOutR2;   
    TxR2_DMA_address = (TxR2_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA      

#else
    // just bypass with double buffering, for checking ping-pong buffer 
    RxL1_DMA_address = (Uint32)RcvL1;   
    RxL1_DMA_address = (RxL1_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA

    RxL2_DMA_address = (Uint32)RcvL2;   
    RxL2_DMA_address = (RxL2_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA

    RxR1_DMA_address = (Uint32)RcvR1;   
    RxR1_DMA_address = (RxR1_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA

    RxR2_DMA_address = (Uint32)RcvR2;   
    RxR2_DMA_address = (RxR2_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA

    TxL1_DMA_address = (Uint32)RcvL2;   
    TxL1_DMA_address = (TxL1_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA

    TxL2_DMA_address = (Uint32)RcvL1;   
    TxL2_DMA_address = (TxL2_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA
    
    TxR1_DMA_address = (Uint32)RcvR2;   
    TxR1_DMA_address = (TxR1_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA
    
    TxR2_DMA_address = (Uint32)RcvR1;   
    TxR2_DMA_address = (TxR2_DMA_address<<1) + 0x10000;        // change word address to byte address and add DARAM offset for DMA      

#endif
    
}

void set_dma0_ch0_stop(void)
{
    Uint16 temp;
//  DMA stop
    temp = DMA0_CH0_TC_MSW;
    temp &= 0x7FFF;
    DMA0_CH0_TC_MSW = temp;    
}

void set_dma0_ch1_stop(void)
{
    Uint16 temp;
//  DMA stop
    temp = DMA0_CH1_TC_MSW;
    temp &= 0x7FFF;
    DMA0_CH1_TC_MSW = temp;    
}

void set_dma0_ch2_stop(void)
{
    Uint16 temp;
//  DMA stop
    temp = DMA0_CH2_TC_MSW;
    temp &= 0x7FFF;
    DMA0_CH2_TC_MSW = temp;    
}

void set_dma0_ch3_stop(void)
{
    Uint16 temp;
//  DMA stop
    temp = DMA0_CH3_TC_MSW;
    temp &= 0x7FFF;
    DMA0_CH3_TC_MSW = temp;    
}

Uint16 set_dma0_ch0_i2s0_Lout(void)
{
    Uint16 temp; 

    DMA0_CH0_TC_LSW = XMIT_BUFF_SIZE*2;

#if(AUTO_RELOAD ==1)        
    DMA0_CH0_TC_MSW = 0x3204;     //src incre, destination fix, sync, auto, int 
#else
    DMA0_CH0_TC_MSW = 0x2204;     //src incre, destination fix, sync, No auto, int
#endif
                
    temp = DMA0_CH10_EVENT_SRC;
    DMA0_CH10_EVENT_SRC = temp | 0x0001;   // I2S2 transmit event
    
    DMA0_CH0_SRC_LSW = (Uint16)TxL1_DMA_address;
    DMA0_CH0_SRC_MSW = 0xFFFF & (TxL1_DMA_address >> 16);
    
    DMA0_CH0_DST_LSW = 0x2808;      // is20 transmit left data register lsw
    DMA0_CH0_DST_MSW = 0;

    CurrentTxL_DMAChannel =1;    
//  DMA starts   
    temp = DMA0_CH0_TC_MSW;
    temp |= 0x8000;
    DMA0_CH0_TC_MSW = temp;

    return SUCCESS;
}

Uint16 set_dma0_ch1_i2s0_Rout(void)
{    
    Uint16 temp;

    DMA0_CH1_TC_LSW = XMIT_BUFF_SIZE*2;
//    DMA0_CH1_TC_LSW = 8;

#if(AUTO_RELOAD ==1)            
    DMA0_CH1_TC_MSW = 0x3204;     //src incre, destination fix, sync, auto
#else    
    DMA0_CH1_TC_MSW = 0x2204;     //src incre, destination fix, sync, No auto
#endif
            
    temp = DMA0_CH10_EVENT_SRC;
    DMA0_CH10_EVENT_SRC = temp | 0x0100;   // I2S2 transmit event
    
    DMA0_CH1_SRC_LSW = (Uint16)TxR1_DMA_address;
    DMA0_CH1_SRC_MSW = 0xFFFF & (TxR1_DMA_address >> 16);
    
    DMA0_CH1_DST_LSW = 0x280C;      // is20 transmit right data register lsw
    DMA0_CH1_DST_MSW =0;
    
    CurrentTxR_DMAChannel =1;
// DMA starts    
    temp = DMA0_CH1_TC_MSW;
    temp |= 0x8000;
    DMA0_CH1_TC_MSW = temp;


    return SUCCESS;
}

Uint16 set_dma0_ch2_i2s0_Lin(void)
{
    Uint16 temp; 

    DMA0_CH2_TC_LSW = XMIT_BUFF_SIZE*2;

#if(AUTO_RELOAD ==1)        
    DMA0_CH2_TC_MSW = 0x3084;     //src fix, destination increase, sync, auto, int 
#else
    DMA0_CH2_TC_MSW = 0x2084;     //src fix, destination increase,, No auto, int
#endif
                
    temp = DMA0_CH32_EVENT_SRC;
    DMA0_CH32_EVENT_SRC = temp | 0x0002;   // I2S2 receive event

    DMA0_CH2_DST_LSW = (Uint16)RxL1_DMA_address;
    DMA0_CH2_DST_MSW = 0xFFFF & (RxL1_DMA_address >> 16);
    
    DMA0_CH2_SRC_LSW = 0x2828;      // is22 receive left data register lsw
    DMA0_CH2_SRC_MSW = 0;

    CurrentRxL_DMAChannel =1;
//  DMA starts   
    temp = DMA0_CH2_TC_MSW;
    temp |= 0x8000;
    DMA0_CH2_TC_MSW = temp;

    return SUCCESS;
}

Uint16 set_dma0_ch3_i2s0_Rin(void)
{
    Uint16 temp; 

    DMA0_CH3_TC_LSW = XMIT_BUFF_SIZE*2;

#if(AUTO_RELOAD ==1)        
    DMA0_CH3_TC_MSW = 0x3084;     //src fix, destination increase, sync, auto , int
#else
    DMA0_CH3_TC_MSW = 0x2084;     //src fix, destination increase,, No auto, int  
#endif
                
    temp = DMA0_CH32_EVENT_SRC;
    DMA0_CH32_EVENT_SRC = temp | 0x0200;   // I2S2 receive event
    
    DMA0_CH3_DST_LSW = (Uint16)RxR1_DMA_address;
    DMA0_CH3_DST_MSW = 0xFFFF & (RxR1_DMA_address >> 16);
    
    DMA0_CH3_SRC_LSW = 0x282C;      // is22 receive right data register lsw
    DMA0_CH3_SRC_MSW = 0;

    CurrentRxR_DMAChannel =1;
//  DMA starts   
    temp = DMA0_CH3_TC_MSW;
    temp |= 0x8000;
    DMA0_CH3_TC_MSW = temp;

    return SUCCESS;
}






void enable_dma_int(void)
{
    // interrupt order: TxL -> TxR -> RxL -> RxR
    // enable only TxR (channel 1) and RxR (channel 3).
    //DMA_MSK = 0x00F0;     // enable DMA1, channel 3 and channel 1 interrupts
    DMA_MSK = 0x000F;     // enable DMA interrupts
    DMA_IFR = 0xFFFF;     // clear interrupt flags
}


interrupt void DMA_Isr(void)
{   
    Uint16 temp;//, dma_start;
    
    temp = IFR0;
    IFR0 = temp;  

    temp = DMA_IFR;
//    DMA_IFR = temp;     // clear interrupt flags

    if(temp&0x0001)
    {
        // DMA TxL interrupt (channel 0)
        if(CurrentTxL_DMAChannel ==1)
        {
            CurrentTxL_DMAChannel =2;
            DMA0_CH0_SRC_LSW = (Uint16)TxL2_DMA_address;
            DMA0_CH0_SRC_MSW = 0xFFFF & (TxL2_DMA_address >> 16);
        
                
        }
        else
        {
            CurrentTxL_DMAChannel =1;
            DMA0_CH0_SRC_LSW = (Uint16)TxL1_DMA_address;
            DMA0_CH0_SRC_MSW = 0xFFFF & (TxL1_DMA_address >> 16);
        }
        DMA_IFR = 0x0001;     // clear interrupt flags
        //dma_start = DMA1_CH0_TC_MSW;
        //dma_start |= 0x8000;
        //DMA1_CH0_TC_MSW = dma_start;
    } 
    else if(temp&0x0002)
    {
        // DMA TxR interrupt (channel 1)
        if(CurrentTxR_DMAChannel ==1)
        {
            CurrentTxR_DMAChannel =2;
            DMA0_CH1_SRC_LSW = (Uint16)TxR2_DMA_address;
            DMA0_CH1_SRC_MSW = 0xFFFF & (TxR2_DMA_address >> 16);
        }
        else
        {
            CurrentTxR_DMAChannel =1;
            DMA0_CH1_SRC_LSW = (Uint16)TxR1_DMA_address;
            DMA0_CH1_SRC_MSW = 0xFFFF & (TxR1_DMA_address >> 16);
        }
        DMA_IFR = 0x0002;     // clear interrupt flags        
        //dma_start = DMA1_CH1_TC_MSW;
        //dma_start |= 0x8000;
        //DMA1_CH1_TC_MSW = dma_start;        
    }
    else if(temp&0x0004)
    {
        RunFilterForL =1;        
        // DMA RxL interrupt (channel 2)
        if(CurrentRxL_DMAChannel ==1)
        {
            // change DMA Tx SRC address
            CurrentRxL_DMAChannel =2;

            DMA0_CH2_DST_LSW = (Uint16)RxL2_DMA_address;
            DMA0_CH2_DST_MSW = 0xFFFF & (RxL2_DMA_address >> 16);
        }
        else
        {
            CurrentRxL_DMAChannel =1;

            DMA0_CH2_DST_LSW = (Uint16)RxL1_DMA_address;
            DMA0_CH2_DST_MSW = 0xFFFF & (RxL1_DMA_address >> 16);
        }
        DMA_IFR = 0x0004;     // clear interrupt flags        
        //dma_start = DMA1_CH2_TC_MSW;
        //dma_start |= 0x8000;
        //DMA1_CH2_TC_MSW = dma_start;        
    }
    else if(temp&0x0008)
    {
        RunFilterForR =1;                
        // DMA RxR interrupt (channel 3)
        if(CurrentRxR_DMAChannel ==1)
        {
            // change DMA Tx SRC address
            CurrentRxR_DMAChannel =2;

            DMA0_CH3_DST_LSW = (Uint16)RxR2_DMA_address;
            DMA0_CH3_DST_MSW = 0xFFFF & (RxR2_DMA_address >> 16);
        }
        else
        {
            CurrentRxR_DMAChannel =1;

            DMA0_CH3_DST_LSW = (Uint16)RxR1_DMA_address;
            DMA0_CH3_DST_MSW = 0xFFFF & (RxR1_DMA_address >> 16);
        }
        DMA_IFR = 0x0008;     // clear interrupt flags        
        //dma_start = DMA1_CH3_TC_MSW;
        //dma_start |= 0x8000;
        //DMA1_CH3_TC_MSW = dma_start;        
    }
}

Нашел, как вам алгоритм?

Код


// coeffbin - вычисление биноминальных коэффициентыов
// o - нормированная частота
for (k = 0; k <= N; k++) b[k] = coeffbin(N, k)*o;
for (k = 0; k <= N; k++) {
for (l = 0; l <= k; l++) {
for(j = 0; j <= (N - k); j++) {
q = l + j;
x = pow(-1,l)*coeffbin(k, l)*coeffbin(N - k, j);
x *= d[k];
x *= pow(y,k);
a[q] += x;
}
}
}
//d[k] - коэффициенты передаточной ф-ции H(s) = d0/Bn(s) - n - порядок
//фильтра; Bn = SUMMA(0-n)dk*s^k; dk = (2n-k)!/2^(n-k)/k!/(n-k)!;
//b и a - коэфф. передат. ф-ции
//H(z) = (b[0]+ b[1]*z...b[n]*z^n)/(a[0]+a[1]*z+...a[n]*z^n)

Это сообщение отредактировал(а) overmet - 18.3.2011, 11:31

0 Пользователей читают эту тему (0 Гостей и 0 Скрытых Пользователей)
0 Пользователей:
« Предыдущая тема \| Микроконтроллеры (MCU) и микропроцессоры (MPU) \| Следующая тема »