dataprocessing.c

使用5509A的usb的程序代码

#include "DspSyscfg.h"

#include <math.h>
#include <tms320.h>
#include <dsplib.h>
#include <test.h>

#include "DspBoard_const.h"

int ii ;
int jj ;


Bool   bOverFlow ;   

Int16  dataMax ;
Int32  dataMean ;
DATA  *dbptr = &db[0];

extern Int16 databuffer0[];
extern Int16 databuffer1[];

extern Uint32 mcaData[];
extern Uint32 mcaData512[];
extern Uint32 mcaData1024[];
extern Uint32 mcaData2048[];

extern Uint32 nRecordCorrect  ;
extern Uint32 nRecordOverFlow  ;

extern Uint16 iBufferReady;

/*  Processing Method  */
extern Uint16 indicatorOfProcMeth ;

/*   intput polarity */
extern Uint16 indicatorOfPolarity ;

Int16 indexMax ;
Int16 Y16temp1;
Int16 Y32temp1;
Int32 Y32temp2;
float Yfltemp1;

Void GetPosTopValue( Int16 * pDataBuffer) ;
Void GetNegTopValue( Int16 * pDataBuffer) ;
Void GetPosTrValue( Int16 * pDataBuffer ) ;
Void GetNegTrValue( Int16 * pDataBuffer ) ;        
Void GetPos3ptValue( Int16 * pDataBuffer ) ;        
Void GetNeg3ptValue( Int16 * pDataBuffer ) ;        


/*************************************************************/
    // LifeTime    : ---Idle---;---Transfer---;---Idle---;----Processing----;---Idle---    
    // iBufferReady:    Ready  Written-----------------------------------Ready    
    // bDMAOn      :    False  True----------False
    //
    // flag   : Int should be with iBufferReady,   
    //                     iBufferReady==Ready--> ok to start DMA
    //        : ProcessFunc should be use iBuffer&bDMAOn
    //                     iBufferReady==Written,bDMAOn==False--> ok to process
/*************************************************************/

Void Buffer0Processing()
{
    if ( indicatorOfProcMeth == PROCESSING_TOP_VALUE )
    {
        if ( indicatorOfPolarity == POLARITY_POS )
            GetPosTopValue( databuffer0 ) ;
        else if ( indicatorOfPolarity == POLARITY_NEG )
            GetNegTopValue( databuffer0 ) ;
    }    
    else if ( indicatorOfProcMeth == PROCESSING_TR_FILTER )
    {
        if ( indicatorOfPolarity == POLARITY_POS )
            GetPosTrValue( databuffer0 ) ;
        else if ( indicatorOfPolarity == POLARITY_NEG )
            GetNegTrValue( databuffer0 ) ;
    }    
    else if ( indicatorOfProcMeth == PROCESSING_3PT_FITTING )
    {
        if ( indicatorOfPolarity == POLARITY_POS )
            GetPos3ptValue( databuffer0 ) ;
        else if ( indicatorOfPolarity == POLARITY_NEG )
            GetNeg3ptValue( databuffer0 ) ;
    }
       
    iBufferReady = iBufferReady & BUFFER_0_READY ;
}


Void Buffer1Processing()
{
    if ( indicatorOfProcMeth == PROCESSING_TOP_VALUE )
    {
        if ( indicatorOfPolarity == POLARITY_POS )
            GetPosTopValue( databuffer1 ) ;
        else if ( indicatorOfPolarity == POLARITY_NEG )
            GetNegTopValue( databuffer1 ) ;
    }    
    else if ( indicatorOfProcMeth == PROCESSING_TR_FILTER )
    {
        if ( indicatorOfPolarity == POLARITY_POS )
            GetPosTrValue( databuffer1 ) ;
        else if ( indicatorOfPolarity == POLARITY_NEG )
            GetNegTrValue( databuffer1 ) ;
    }
    else if ( indicatorOfProcMeth == PROCESSING_3PT_FITTING )
    {
        if ( indicatorOfPolarity == POLARITY_POS )
            GetPos3ptValue( databuffer1 ) ;
        else if ( indicatorOfPolarity == POLARITY_NEG )
            GetNeg3ptValue( databuffer1 ) ;
    }
    
    iBufferReady = iBufferReady & BUFFER_1_READY ;
}

double factor ;
Void GenerateH ( Uint16 na , Uint16 nb , Uint16 nc , Uint16 nf , Uint16 * h )
{
    factor = 1/(1-exp(-1/(double)nf)); 
    
    for ( ii = 0 ; ii < na ; ii++ )
    {
        h[ ii ] = ( factor + ii ) / na / nf;
    }
    for ( ; ii < nb ; ii++ )
    {
        h[ ii ] = 1 / nf ;
    }
    for ( ; ii < nc ; ii++ )
    {
        h[ ii ] = ( nc - ii - factor ) / na / nf;
    }
}

Void GetPosTopValue( Int16 * pDataBuffer)
{       
    for ( ii = 0 ; ii < PulseAmount ; ii ++ )  // PulseAmount == HalfFIFO/PulseSize
    {
        dataMax = 0 ; // ChannelAmount == 16384
        bOverFlow = FALSE ;
        for ( jj = 10 ; jj < PulseSize ; jj ++ ) // PulseSize ==512
        {
            if ( pDataBuffer [ ii * PulseSize + jj ] < 0 )
            {
                bOverFlow = TRUE ;                            
                jj = PulseSize ;     
            }
            else
            {
                if ( pDataBuffer [ ii * PulseSize + jj ] > dataMax ) 
                    dataMax = pDataBuffer [ ii * PulseSize + jj ] ;                            
            }
        }
                    
        if ( !bOverFlow )
        {
            // 去基线
            dataMean = 0 ;
            for ( jj = 50 ; jj < 66 ; jj ++ )
                dataMean += pDataBuffer[ ii * 512 + jj ] ; 
            dataMean = dataMean * 0.0625 ;
            dataMax = dataMax - dataMean ;
                        
            if ( ( dataMax >=0 ) && ( dataMax < RealChannelAmount ) ) // RealChannelAmount == 8192
            {
                // Note 8191 == RealChannelAmount - 1 , should take care                
                mcaData[ dataMax ] = mcaData[ dataMax ] + 1 ;
                dataMax = (int)( dataMax / 4  );
                mcaData2048[ dataMax ] = mcaData2048[ dataMax ] + 1 ;
                dataMax = (int)( dataMax / 2  );
                mcaData1024[ dataMax ] = mcaData1024[ dataMax ] + 1 ;
                dataMax = (int)( dataMax / 2  );
                mcaData512[ dataMax ] = mcaData512[ dataMax ] + 1 ;
                nRecordCorrect ++ ;
            }   
            else
            {
                nRecordOverFlow ++ ;
            }                     
        }
        else
        {
            nRecordOverFlow ++ ;
        }                    
    }             
}

Void GetNegTopValue( Int16 * pDataBuffer) 
{
    for ( ii = 0 ; ii < PulseAmount ; ii ++ )  // PulseAmount == HalfFIFO/PulseSize
    {
        dataMax = ChannelAmount ; // ChannelAmount == 16384
        bOverFlow = FALSE ;
        for ( jj = 10 ; jj < PulseSize ; jj ++ ) // PulseSize ==512
        {
            if ( pDataBuffer [ ii * PulseSize + jj ] < 0 )
            {
                bOverFlow = TRUE ;                            
                jj = PulseSize ;     
            }
            else
            {
                if ( pDataBuffer [ ii * PulseSize + jj ] < dataMax ) 
                    dataMax = pDataBuffer [ ii * PulseSize + jj ] ;                            
            }
        }
                    
        if ( !bOverFlow )
        {
            // 去基线
            dataMean = 0 ;
            for ( jj = 50 ; jj < 66 ; jj ++ )
                dataMean += pDataBuffer[ ii * 512 + jj ] ; 
            dataMean = dataMean * 0.0625 ;
            dataMax = dataMean - dataMax ;
            
            if ( ( dataMax >=0 ) && ( dataMax < RealChannelAmount ) ) // RealChannelAmount == 8192
            {
                // Note 8191 == RealChannelAmount - 1 , should take care                
                mcaData[ dataMax ] = mcaData[ dataMax ] + 1 ;
                dataMax = (int)( dataMax / 4  );
                mcaData2048[ dataMax ] = mcaData2048[ dataMax ] + 1 ;
                dataMax = (int)( dataMax / 2  );
                mcaData1024[ dataMax ] = mcaData1024[ dataMax ] + 1 ;
                dataMax = (int)( dataMax / 2  );
                mcaData512[ dataMax ] = mcaData512[ dataMax ] + 1 ;
                nRecordCorrect ++ ;
            }   
            else
            {
                nRecordOverFlow ++ ;
            }                     
        }
        else
        {
            nRecordOverFlow ++ ;
        }                    
    }                
}


Void GetPosTrValue( Int16 * pDataBuffer ) 
{
    for ( ii = 0 ; ii < 4 ; ii ++ )
    {
        // 先去基线
        dataMean = 0 ;
        for ( jj = 50 ; jj < 66 ; jj ++ )
            dataMean += pDataBuffer[ ii * 512 + jj ] ; 
        dataMean = dataMean * 0.0625 ;
                    
        // 梯形成形
        for ( jj = 0 ; jj < 512 ; jj++ )
             pDataBuffer[ ii * 512 + jj ] =  pDataBuffer [ ii * 512 + jj ] - dataMean ;        
                    
        fir2( &pDataBuffer[ ii * 512 ] , h, r, dbptr, NX, NH);
                    
        dataMax = r [ 100 ] ;
        for ( jj = 100 ; jj < 240 ; jj ++ )
            if ( dataMax < r[  jj ] )
                dataMax = r[  jj ];
                                        
        if ( dataMax >= 0 && dataMax < 8192 )
        {
            mcaData[ dataMax ] = mcaData[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 4  );
            mcaData2048[ dataMax ] = mcaData2048[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 2  );
            mcaData1024[ dataMax ] = mcaData1024[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 2  );
            mcaData512[ dataMax ] = mcaData512[ dataMax ] + 1 ;
            
            nRecordCorrect ++ ;
        }
        else
        {
            nRecordOverFlow ++ ;
        }                                         
    }                
}


Void GetNegTrValue( Int16 * pDataBuffer ) 
{
    for ( ii = 0 ; ii < 4 ; ii ++ )
    {
        // 先去基线
        dataMean = 0 ;
        for ( jj = 50 ; jj < 66 ; jj ++ )
            dataMean += pDataBuffer[ ii * 512 + jj ] ; 
        dataMean = dataMean * 0.0625 ;
                    
        // 梯形成形
        for ( jj = 0 ; jj < 512 ; jj++ )
             pDataBuffer[ ii * 512 + jj ] = dataMean - pDataBuffer [ ii * 512 + jj ] ;        
                    
        fir2( &pDataBuffer[ ii * 512 ] , h, r, dbptr, NX, NH);
                    
        dataMax = r [ 100 ] ;
        for ( jj = 100 ; jj < 240 ; jj ++ )
            if ( dataMax < r[  jj ] )
                dataMax = r[  jj ];
                                        
        if ( dataMax >= 0 && dataMax < 8192 )
        {
            mcaData[ dataMax ] = mcaData[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 4  );
            mcaData2048[ dataMax ] = mcaData2048[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 2  );
            mcaData1024[ dataMax ] = mcaData1024[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 2  );
            mcaData512[ dataMax ] = mcaData512[ dataMax ] + 1 ;
            
            nRecordCorrect ++ ;
        }
        else
        {
            nRecordOverFlow ++ ;
        }                                         
    }                
}


Void GetPos3ptValue( Int16 * pDataBuffer ) 
{
    for ( ii = 0 ; ii < 4 ; ii ++ )
    {
        // 先去基线
        dataMean = 0 ;
        for ( jj = 50 ; jj < 66 ; jj ++ )
            dataMean += pDataBuffer[ ii * 512 + jj ] ; 
        dataMean = dataMean * 0.0625 ;
                
        for ( jj = 99 ; jj < 161 ; jj++ )
             pDataBuffer[ ii * 512 + jj ] =  pDataBuffer [ ii * 512 + jj ] - dataMean  ; // 正输入
                      
        dataMax = pDataBuffer [ ii * 512 + 100 ] ;
        indexMax = 100 ;
        for ( jj = 100 ; jj < 160 ; jj ++ )
        {
            if ( dataMax < pDataBuffer[  ii * 512 + jj ] )
            {
                dataMax = pDataBuffer[  ii * 512 + jj ];
                indexMax = jj ;
            }
        }
        
        Y16temp1 = pDataBuffer[ ii * 512 + indexMax+1 ] - pDataBuffer[ ii * 512 + indexMax-1 ] ;
        Y32temp1 = (long) Y16temp1 * Y16temp1 ;
        Y16temp1 = 2*pDataBuffer[ ii * 512 + indexMax ] - pDataBuffer[ ii * 512 + indexMax+1 ] - pDataBuffer[ ii * 512 + indexMax-1 ] ;
        Y32temp2 = Y16temp1 * 8 ;
        Yfltemp1 = (float)Y32temp1 / Y32temp2 ;
        dataMax = pDataBuffer[ ii * 512 + indexMax ] + (Int16) (Yfltemp1+0.5) ; 
        
                                        
        if ( dataMax >= 0 && dataMax < 8192 )
        {
            mcaData[ dataMax ] = mcaData[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 4  );
            mcaData2048[ dataMax ] = mcaData2048[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 2  );
            mcaData1024[ dataMax ] = mcaData1024[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 2  );
            mcaData512[ dataMax ] = mcaData512[ dataMax ] + 1 ;
            
            nRecordCorrect ++ ;
        }
        else
        {
            nRecordOverFlow ++ ;
        }                                         
    }  
}       


Void GetNeg3ptValue( Int16 * pDataBuffer ) 
{
    for ( ii = 0 ; ii < 4 ; ii ++ )
    {
        // 先去基线
        dataMean = 0 ;
        for ( jj = 50 ; jj < 66 ; jj ++ )
            dataMean += pDataBuffer[ ii * 512 + jj ] ; 
        dataMean = dataMean * 0.0625 ;
                
        for ( jj = 99 ; jj < 161 ; jj++ )
             pDataBuffer[ ii * 512 + jj ] =  dataMean - pDataBuffer [ ii * 512 + jj ]   ; // 负输入
                      
        dataMax = pDataBuffer [ ii * 512 + 100 ] ;
        indexMax = 100 ;
        for ( jj = 100 ; jj < 160 ; jj ++ )
        {
            if ( dataMax < pDataBuffer[  ii * 512 + jj ] )
            {
                dataMax = pDataBuffer[  ii * 512 + jj ];
                indexMax = jj ;
            }
        }
        
        Y16temp1 = pDataBuffer[ ii * 512 + indexMax+1 ] - pDataBuffer[ ii * 512 + indexMax-1 ] ;
        Y32temp1 = (long) Y16temp1 * Y16temp1 ;
        Y16temp1 = 2*pDataBuffer[ ii * 512 + indexMax ] - pDataBuffer[ ii * 512 + indexMax+1 ] - pDataBuffer[ ii * 512 + indexMax-1 ] ;
        Y32temp2 = Y16temp1 * 8 ;
        Yfltemp1 = (float)Y32temp1 / Y32temp2 ;
        dataMax = pDataBuffer[ ii * 512 + indexMax ] + (Int16) (Yfltemp1+0.5) ; 
        
                                        
        if ( dataMax >= 0 && dataMax < 8192 )
        {
            mcaData[ dataMax ] = mcaData[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 4  );
            mcaData2048[ dataMax ] = mcaData2048[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 2  );
            mcaData1024[ dataMax ] = mcaData1024[ dataMax ] + 1 ;
            dataMax = (int)( dataMax / 2  );
            mcaData512[ dataMax ] = mcaData512[ dataMax ] + 1 ;
            
            nRecordCorrect ++ ;
        }
        else
        {
            nRecordOverFlow ++ ;
        }                                         
    }                
}