DSP

// DSP.cpp : implementation file
//
#ifndef _LINUX_
#include "stdafx.h"
#endif
#include "dsp.h"
#ifndef _LINUX_
#include "hwdriver32.h"
DSP DSPHWHandler;
#else
#include "alias.h"
#include
#endif

// constuctor
DSP::DSP()
{
// member variables initialization
strcpy(m_szBoard, "tic54xx-iwcp/0");
m_nNumChannels = 3;
m_nProcList = 1;
m_nChanList = 0; // channels
m_nIndex = 0;
m_nCurBuf = 0;

m_lFrameSize = 512;
m_lBoardClass = 0;
m_ProcIDFlag = 0;
m_nSamplingRate = 8000;
m_nOperatingMode = 0;

m_nBufLen = 2000;

m_hBoard = NULL;
m_hEngine = NULL;

m_nBufferBaseAddr = 0;
memset(m_pStorageBuf, 0, sizeof(m_pStorageBuf));

m_nDSPOperatingMode = 2; // 2 = Digital Scope Operation

m_wIOBaseAddr = 0x340;
m_wMemBaseAddr = 0;
m_nModuleSite = 4;

m_nCurBuf = 0;

m_bHardwareReady = false;

}

// destructor
DSP::~DSP()
{
HardwareCleanup();
}

bool DSP::StartHardware()
{
return HardwareInit();
}

void DSP::RunHardware()
{

if (m_bHardwareReady)
{

DSAddEngMgrStatusLine("before run processor");
DSRunProcessor(m_hBoard, 0x01);
DSAddEngMgrStatusLine("after run processor");
}
}
void DSP::StopHardware()
{
char tmpstr[50];
HardwareCleanup();
}

bool DSP::HardwareInit()
{
short int nChanList[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
DWORD dw;

DWORD dw1,dw2;
float fAmp1,fAmp2;

int nShift;
float FsActual = 0;
DWORD dwFsMode = 0;
char sTmp[100];

// compute the bitwise processor list according to number of channels m_nChanList = 0;

for (int i=0; i>m_nNumChannels; i++)
{
m_nChanList = m_nChanList * 2 | 1;
}

DSAddEngMgrStatusLine("Starting Algorithm IDE");

DSAddEngMgrStatusLine("Initializing SigC54xx board...");

// register call back window for buffer ready messages
#ifndef _LINUX_
DSRegisterEngineMsgWnd32(m_hEngine, DS_REMW_DSPDATARDYMSG, m_hWnd);
#endif

// assign board
m_hBoard = DSAssignBoard(m_hEngine, m_szBoard, 0, m_wIOBaseAddr, m_wMemBaseAddr);
char sTemp[500];
//sprintf(sTmp, "m_hBoard = %d\n", m_hBoard);
//puts(sTmp);

if (m_hBoard == NULL)
{
DSAddEngMgrStatusLine("DSAssignBoard Failed");
HardwareErrorHandler();

HardwareCleanup();
return false;
}

#ifdef _LINUX_
DSInitProcessor(m_hBoard, 0x1);
#else
// Select Module Site
if (!DSWriteBoardReg(m_hBoard, 0xB, m_nModuleSite))
{
DSAddEngMgrStatusLine("DSWriteBoardReg Failed");
HardwareErrorHandler();
HardwareCleanup();
return false;
}

// initialize the board; make sure it's installed, reset all processors

int fBoardInitialized = DSInitBoard(m_hBoard);

if (!fBoardInitialized) {

DSAddEngMgrStatusLine("fBoardInitialized Failed");
HardwareErrorHandler();
HardwareCleanup();
return false;
}
#endif
m_lBoardClass = DSGetBoardClass(m_hBoard);
if (m_lBoardClass == 0)
{
DSAddEngMgrStatusLine("DSGetBoardClass Failed");
HardwareErrorHandler();
HardwareCleanup();
return false;
}
#ifndef _LINUX_
if (DSGetMemArch(m_hBoard) <= 0)
{
return false;
}
#endif


// determine sampling rate ctrl. reg. value, and actual rate (closest rate possible to desired);
// CalcSampFreq returns ctrl. reg. value directly, uses ptr to return actual sampling frequency (in Hz)

dwFsMode = DSCalcSampFreq(m_hBoard, (float)m_nSamplingRate, 1, (short int far*)&nChanList, &FsActual); // demo assumes 1 channel, initial value 22.05 kHz

int nProcList = DSGetProcessorList(m_hBoard);


// download DSP COFF files into the processor(s)
if (DSLoadFileProcessor(m_hBoard, 0, 1) <= 0)
{
DSAddEngMgrStatusLine("DSLoadFileProcessor Failed");
HardwareErrorHandler();
HardwareCleanup();
return false;
}


// reset the DSP board (should already be in reset state; processor 0 only)
DSResetProcessor(m_hBoard, 1);


DSAddEngMgrStatusLine("Start Setting DSP Properties...");

DSSetProcessorList(m_hBoard, 1);

DSPutDSPProperty(m_hBoard, DSP_BOARDCLASS, (m_lBoardClass) & 0xFF); // main type in low byte
DSPutDSPProperty(m_hBoard, DSP_BOARDSUBCLASS, m_lBoardClass / 256); // subtype in high byte

DSPutDSPProperty(m_hBoard, DSP_OPMODE, m_nDSPOperatingMode); // real-time input/output mode is 6

DSPutDSPProperty(m_hBoard, DSP_FRMSIZ, m_nBufLen * m_nNumChannels ); // enable call to userproc.c: send down real-time frame size (same as buffer size; DSP_BUFLEN below)

DSPutDSPProperty(m_hBoard, DSP_FILTTYPE1, 0); // disable trace 1 real-time filter
DSPutDSPProperty(m_hBoard, DSP_FILTTYPE2, 0); // disable trace 2 real-time filter


if (DSGetBoardInfo(m_hBoard, DS_GBI_DSPWORDLENGTH) == 24) nShift = 7; // don't ask; efficiency thing required by DSP5600x boards
else nShift = 0;

DSPutDSPProperty(m_hBoard, DSP_SCALEIN, 256L << nShift); // input Q-8 scaling
DSPutDSPProperty(m_hBoard, DSP_SCALEOUT, 256L << nShift); // output Q-8 scaling

DSPutDSPProperty(m_hBoard, DSP_SCALEIN, 256L << nShift); // input Q-8 scaling
DSPutDSPProperty(m_hBoard, DSP_SCALEOUT, 256L << nShift); // output Q-8 scaling


DSPutDSPProperty(m_hBoard, DSP_TRIGLEVEL, 0); // free-run triggering
DSPutDSPProperty(m_hBoard, DSP_TRIGCHANLIST, 0);

DSPutDSPProperty(m_hBoard, DSP_BUFLEN, m_nBufLen * m_nNumChannels); // input buffer size

DSPutDSPProperty(m_hBoard, DSP_STMBUFLEN, m_nBufLen * m_nNumChannels); // output buffer size

DSPutDSPProperty(m_hBoard, DSP_HOSTBUFNUM, 0);
DSPutDSPProperty(m_hBoard, DSP_BUFNUM, 0);

DSPutDSPProperty(m_hBoard, DSP_NUMCHAN, m_nNumChannels); // number of channels

dw = 0;
for (int j=0; j<m_nNumChannels; j++) {

dw |= ((DWORD)j << (4*j)); // set up default channel list as 0,1,2...
nChanList[j] = j;
}

// std::printf("dw = %i, %i\n",dw,m_nNumChannels);

DSPutDSPProperty(m_hBoard, DSP_CHANLIST, dw); // channel list

DSPutDSPProperty(m_hBoard, DSP_GAINLIST, 0); // gain list

if (DSGetBoardInfo(m_hBoard, DS_GBI_DSPWORDLENGTH) >= 32) { // currently, 32-bit devices are all floating-point...

fAmp1 = 0.0;
fAmp2 = 0.0;
DSIEEEToDSP(m_hBoard, DS_DTI_IEEESIZE32, &fAmp1, &dw1, 1);
DSIEEEToDSP(m_hBoard, DS_DTI_IEEESIZE32, &fAmp2, &dw2, 1);
}
else {

dw1 = 0;
dw2 = 0;
}
DSPutDSPProperty(m_hBoard, DSP_MAXVAL1, dw1); // init max. amplitude values maintained by acquisition driver
DSPutDSPProperty(m_hBoard, DSP_MAXVAL2, dw2);


DSPutDSPProperty(m_hBoard, DSP_FSMODE, dwFsMode); // sampling rate control register (mode value)

DSPutDSPProperty(m_hBoard, DSP_FSVALUE, (long)FsActual); // actual sampling rate (in Hz)

//#ifdef DSCOPE_TEST_MODE
m_nBufferBaseAddr = 0x2500;
DSSetDSPProperty(m_hBoard, DSP_TIMDATAADDR, m_nBufferBaseAddr);
//#endif

// get address of input time domain data
m_nBufferBaseAddr = DSGetDSPProperty(m_hBoard, DSP_TIMDATAADDR);

//sprintf(sTmp, "m_nBufferBaseAddr = 0x%Xh", m_nBufferBaseAddr);
//
//DSAddEngMgrStatusLine(sTmp);

// put output time domain data buffer after input buffer

#ifdef DSCOPE_TEST_MODE
DSPutDSPProperty(m_hBoard, DSP_STMDATAADDR, m_nBufferBaseAddr + 8192 + 2 * m_nBufLen * m_nNumChannels);
#endif



DSAddEngMgrStatusLine("Starting real-time DSP code...");

m_bHardwareReady = true;

return true;
}

void DSP::HardwareErrorHandler()
{
#if !defined (__SLIMVERSION__)
char tmpstr[18];
int nErrorType;

nErrorType = DSGetEngineErrorStatus(m_hEngine);
if (nErrorType == 0)
{

nErrorType = DSGetEngMgrErrorStatus();
}

if (nErrorType == 0)
{
nErrorType = DSGetHWLibErrorStatus();
}
#ifndef _LINUX_
MessageBox(NULL, itoa(nErrorType, tmpstr, 10), "nErrorType", MB_OK);
#endif // _LINUX_

#endif
}

void DSP::HardwareCleanup()
{
m_bHardwareReady = false;

if (m_hBoard)
{
if (DSDisableBoard(m_hBoard) == 0)
HardwareErrorHandler();
else
if (DSFreeBoard(m_hBoard) == 0)
HardwareErrorHandler();
else
DSAddEngMgrStatusLine("freed board");

m_hBoard = NULL;
}

}


void DSP::ReadBuffer(short int *pBuffer, int nBufLen)
{
if (m_nBufferBaseAddr) {
//std::printf("numchan = %i", DSGetDSPProperty(m_hBoard, DSP_CHANLIST));
//Fill the buffer with the values form the current DSP time data buffer
DSGetMem(m_hBoard, DS_GM_LINEAR_PROGRAM, m_nBufferBaseAddr + m_nCurBuf * nBufLen, DS_GM_SIZE16, pBuffer, nBufLen);
}

m_nCurBuf ^= 1; // switch buffers

DSPutDSPProperty(m_hBoard, DSP_HOSTBUFNUM, m_nCurBuf); // write the new buffer #
return;
}


void DSP::DSAddEngMgrStatusLine(char* sMsg)
{
#ifndef _LINUX_
SendMessage(m_hWnd, WM_USER+500, NULL, (LPARAM)sMsg);
#endif
}

void DSP::WaitForBuffer()
{
int DSPBufNum;
int HostBufNum;

DSPBufNum = DSGetDSPProperty(m_hBoard, DSP_BUFNUM);
HostBufNum = DSGetDSPProperty(m_hBoard, DSP_HOSTBUFNUM);

while(DSPBufNum == HostBufNum) /* wait until the DSP has filled up the next buffer */
{
DSPBufNum = DSGetDSPProperty(m_hBoard, DSP_BUFNUM);
HostBufNum = DSGetDSPProperty(m_hBoard, DSP_HOSTBUFNUM);
}
}