Mity CPU Platforms » MityDSP-L138 (ARM9 Based Platforms)

/**

 * @file 		DAC5672.h

 * @author		James Thesing <james.thesing@criticallink.com>

 * @version		1.0

 *

 * @section LICENSE

 *

 *

 *    o  0

 *    | /       Copyright (c) 2005-2011

 *  (CL)---o   Critical Link, LLC

 *    \

 *     O

 *

 *

 * @section DESCRIPTION

 *

 * This class handles exercising the DAC5672 on the DSP. Input data is

 * generated by the DSPAPP and then sent over upp to the DAC. Output

 * is generated as two analog signals to two coaxial outputs.

 */

#include "DAC5672.h"

#include "core/DspUpp.h"

#include "core/DspSyscfg.h"

#include "core/chipconfig.h"

#include "core/cl_ipc_inbound.h"

#include "core/cl_ipc_outbound.h"

#include <std.h>

#include <tsk.h>

#include <clk.h>

#include <vector>

#include <string>

#include <cmath>

#include <stdio.h>

#include <string.h>

#include <sstream>

using namespace std;

using namespace MityDSP;

const int SAMPLE_SIZE = 32000;

//set up buffers

#pragma DATA_ALIGN( 64 );

int16_t buff1[ SAMPLE_SIZE ];

int16_t buff2[ SAMPLE_SIZE ];

int16_t buff3[ SAMPLE_SIZE ];

//set up data

int16_t data[32000];

static int32_t FREQUENCY = 1000000;

static float AMPLITUDE = .5;

// Forward declarations

void init();

void debugPrint( char *buffer );

int handleInboundMessage( void *apBuffer, uint32_t anLength, void *apUserArg ) ;

// Object for sending debug messages (these are received and printed to stdout by tcDspApp)

tcCL_IPCOutbound* 	gpDebug;

// Object for sending GPPMSGQ1 messages that the ARM will receive

tcCL_IPCOutbound* 	gpOutbound;

// Object for receiving DSPMSGQ0 messages that the DSP will receive

tcCL_IPCInbound* 	gpInbound;

// Initialize static member variables

DAC5672* DAC5672::mpDAC5672 = NULL;

#define CORE_DAWG_MODULE	0x66000180

// uPP configuration record

static const tcDspUpp::tsDspUppConfig gsUppConfig =

	{

	4, // Interrupt level. Must be between 4 and 15.

	9, // Chan A DMA thread handling priority

	9, // Chan B DMA thread handling priority

	tcDspUpp::eeTransmit, // Directionality of Channel A.

	tcDspUpp::eeReceive, // Directionality of Channel B.

	tcDspUpp::ee16Bit, // Chan A data bit width.

	tcDspUpp::ee16Bit, // Chan B data bit width.

	false, // Use XData[7:0] for ChanA[15:8] even if ChanB is

	// disabled. See Table 3 in uPP User's Guide for details.

	4, // Size of MBX for Channel A.

	4, // Size of MBX for Channel B.

	0, // Clock divider for Channel A (75 MHz output clock)

	// (only in transmit mode). See Section 2.1.1 in uPP User's

	// Guide for details. Value must be between 1 and 16.

	0, // Clock divider for Channel B

	// (only in transmit mode). See Section 2.1.1 in uPP User's

	// Guide for details. Value must be between 1 and 16.

	tcDspUpp::ee256Bytes, // Chan A Transmit Thresh

	tcDspUpp::ee256Bytes, // Chan A Receive Thresh

	tcDspUpp::ee256Bytes, // Chan B Transmit Thresh

	tcDspUpp::ee256Bytes, // Chan B Receive Thresh

	false, // Do not use Chan A start signal

	false, // Do not use Chan B start signal

	//tcDspUpp::eeUPP_2xTXCLK, // Using external 2xTxClk for Transmit

	tcDspUpp::eePLL0_SYSCLK2,

	0 // uPP DMA Master Priority

	};

/**

 * Private Constructor - initializes the digital output logic

 */

DAC5672::DAC5672()

: mpDspUpp(NULL)

, meXmitChan(tcDspUpp::eeChanA)

, mhXmitMbx(NULL)

, meRecvChan(tcDspUpp::eeChanB)

, mhRecvMbx(NULL)

, filled(false)

{

	// Get instance of DspUpp

	mpDspUpp = tcDspUpp::getInstance();

	// Configure uPP

	if (0 != mpDspUpp->initialize(&gsUppConfig))

	{

	char debug1[] = "failed configuring upp";

	debugPrint(debug1);

	}

	else

	{

	// Get the receive and transmit mailboxes

	mhXmitMbx = mpDspUpp->getMBX(meXmitChan);

	mhRecvMbx = mpDspUpp->getMBX(meRecvChan);

	}

}

/**

 * Initializes the DSP link and registers message handler

 */

void init()

{

	// Message to ARM core.

	char lpReturnMessage[] = "DSP Initialization finished.";

	// Buffer for return message

	char* lpMessageBuffer = NULL;

	//adjust clock divisor for the EMIF clock in FPGA to be 0.

	*(unsigned short*)(0x66000180+2) = 0x000;

	// Create the outbound debug link

	gpDebug = new tcCL_IPCOutbound("debug");

	// Create the inbound link for messages to the DSP

   	gpInbound = new tcCL_IPCInbound();

   	gpInbound->Open("DSPMSGQ0", 8);

	// Create the outbound controller for sending messages to the ARM

   	gpOutbound = new tcCL_IPCOutbound("GPPMSGQ1");

	if (NULL != gpInbound)

	{

		// Register a callback function to handle messages from the ARM

   		gpInbound->RegisterCallback(handleInboundMessage, (void*)NULL);

	}

	// Now that initialization is complete, let the ARM know with a message

	// Obtain a dsplink buffer for the return message

	lpMessageBuffer = (char*)gpOutbound->GetBuffer(strlen(lpReturnMessage) + 1);

	// Make sure we received a valid buffer

	if (NULL != lpMessageBuffer)

	{

		// Copy our message to the buffer

		strcpy(lpMessageBuffer, lpReturnMessage);

		// Send the message back to the ARM

		gpOutbound->SendMessage(lpMessageBuffer);

	}

}

/**

 * Generates a 14bit signwave from given paramaters

 * @param amplitude amplitude of sine wave (0,1]

 * @param frequency frequency of sine wave

 * @param data data table that is filled

 */

void DAC5672::fillData( float amplitude, int32_t frequency, int16_t *data){

	// Buffer for return message

	char* lpMessageBuffer = NULL;

	string tdebug1 = "The max sign value is: ";

	string tdebug2 = "The min sign value is: ";

	float temp;

	float maxSign = 0;

    float minSign = 0;

    if(!filled)

	{

		/*for( int i = 0; i <SAMPLE_SIZE/2; i++ )

		{

			data[i] = i;

		}

		int r = 0;

		for( int i = SAMPLE_SIZE/2; i < SAMPLE_SIZE; i++ )

		{

			data[i] = r;

			r++;

		}*/

		const double PI = 4.0*atan(1.0);

		for( int i = 0; i < SAMPLE_SIZE; i++){	

			temp = amplitude;

			temp *= (1<<13-1);

			//the 40 MHz used to be uppClock. There is a n issue with timing with the fpga,

			//which requires the generation of the wave to be based on the fpga's sampling frequency.

			temp *= 1.0+sin(2.0f * PI * ( ( float ) 500000 / 40000000 ) * i);

			//remember min and max values

			if (temp > maxSign)

			{

				maxSign = temp;

			}

			if (temp < minSign)

			{

				minSign = temp;

			}

			data[i] = temp;

			//send back sample debug to ARM

#if 0

			stringstream sARM;

			sARM << i;

			sARM << ": ";

			sARM << data[i];

			std::string currentSample = sARM.str();

			char* samplebuffer = (char*)currentSample.c_str();

			// Obtain a dsplink buffer for the return message

        		lpMessageBuffer = (char*)gpOutbound->GetBuffer(strlen(samplebuffer) + 1);

        		// Make sure we received a valid buffer

        		if (NULL != lpMessageBuffer)

        		{

                		// Copy our message to the buffer

                		strcpy(lpMessageBuffer, samplebuffer);

                		// Send the message back to the ARM

                		gpOutbound->SendMessage(lpMessageBuffer);

		        }

#endif

		}

	}

	//format min and max value in dps -> arm message

	stringstream s1;

	stringstream s2;

	s1 << maxSign;

	std::string t = s1.str();

	tdebug1.append( t );

	//tdebug1.append( "\n" ); //don't need this

	s2 << minSign;

	t = s2.str();

	tdebug2.append( t );

	//tdebug2.append( "\n" ); //don't need this

	char *debug1 = (char*)tdebug1.c_str();

	char *debug2 = (char*)tdebug2.c_str();

	// Obtain a dsplink buffer for the return message

	lpMessageBuffer = (char*)gpOutbound->GetBuffer(strlen(debug1) + 1);

	// Make sure we received a valid buffer

	if (NULL != lpMessageBuffer)

	{

		// Copy our message to the buffer

		strcpy(lpMessageBuffer, debug1);

		// Send the message back to the ARM

		gpOutbound->SendMessage(lpMessageBuffer);

	}

	// Obtain a dsplink buffer for the return message

	lpMessageBuffer = (char*)gpOutbound->GetBuffer(strlen(debug2) + 1);

	if (NULL != lpMessageBuffer)

	{

		// Copy our message to the buffer

		strcpy(lpMessageBuffer, debug2);

		// Send the message back to the ARM

		gpOutbound->SendMessage(lpMessageBuffer);

	}

	filled = true;

}

/**

 * sends data to DAC continuously through upp

 * @param buff1 - buffer used to send data to upp

 * @param buff2 - buffer used to send data to upp

 * @param buff3 - buffer used to send data to upp

 * @param data - table of data to copy to buffer

 */

void DAC5672::communicate(int16_t* buff1, int16_t* buff2, int16_t* buff3, int16_t *data  ){

	tcDspUpp::tsMbxMsg lsXmitMbxMsg;

	//tcDspUpp::tsMbxMsg lsRecvMbxMsg;

	int rv;

	char* lpMessageBuffer = NULL;

	char debug1[] = "transmitFailure\n";

	char debug2[] = "failure to communicate with ARM";

	lpMessageBuffer = (char*)gpOutbound->GetBuffer(strlen(debug1) + 1);

	if (NULL != lpMessageBuffer)

	{

		// Copy our message to the buffer

		strcpy(lpMessageBuffer, debug1);

	}

	else

	{

		debugPrint( debug2 );

	}

	// fill buffers

	memcpy(buff1, data, sizeof(int16_t)*SAMPLE_SIZE);

	memcpy(buff2, data, sizeof(int16_t)*SAMPLE_SIZE);

	memcpy(buff3, data, sizeof(int16_t)*SAMPLE_SIZE);

	//transmit

	rv = mpDspUpp->transmit(meXmitChan , (uint8_t*)buff1, (uint16_t)(SAMPLE_SIZE * 2) );

	if (rv != 0){

		gpOutbound->SendMessage( lpMessageBuffer );

		return;

	}

	rv = mpDspUpp->transmit(meXmitChan, (uint8_t*)buff2, (uint16_t)(SAMPLE_SIZE * 2) );

	if( rv != 0)

	{

		gpOutbound->SendMessage( lpMessageBuffer );

		return;

	}

	rv = mpDspUpp->transmit(meXmitChan, (uint8_t*)buff3, (uint16_t)(SAMPLE_SIZE * 2) );

	if( rv !=0)

	{

		gpOutbound->SendMessage( lpMessageBuffer );

		return;

	}

	//wait for buffers, fill, transmit

	while(true){

		MBX_pend(mhXmitMbx, &lsXmitMbxMsg, SYS_FOREVER);

		memcpy((void*)lsXmitMbxMsg.pBufPtr, data, sizeof(int16_t)*SAMPLE_SIZE );

		rv = mpDspUpp->transmit(meXmitChan,(uint8_t*)lsXmitMbxMsg.pBufPtr, (uint16_t)(SAMPLE_SIZE * 2 ));

		if( rv != 0 )

		{

			gpOutbound->SendMessage( lpMessageBuffer );

			return;

		}

	}

}

/**

 * Return instance of object or create one to enforce

 * singleton use

 */

DAC5672*

DAC5672::getInstance()

{

	if (NULL == mpDAC5672)

		mpDAC5672 = new DAC5672();

	return mpDAC5672;

}

/**

 * Destructor

 */

DAC5672::~DAC5672()

{

}

/**

 * Main routine for DSPAPP

 */

int main(int argc, char* argv[])

{

	// initialize the DSPLink system

	tcCL_IPCInit::GetInstance();

	// Launch an initialization task

	TSK_Attrs* lpAttrs = new TSK_Attrs;

	*lpAttrs           = TSK_ATTRS;

	lpAttrs->name      = "Initialize";

	lpAttrs->stacksize = 8192*2;

	lpAttrs->priority  = 5;

	TSK_create((Fxn)init,lpAttrs);

    return 0;

}

/**

 * handles messages received from the arm

 * @param apBuffer buffer location of message

 * @param anLength length of buffer used

 * @param apUserArg user given arguments

 * @return 0;

 */

int handleInboundMessage(void* apBuffer, uint32_t anLength, void* apUserArg)

{

	//char buffer[50];

	string str = (const char*)apBuffer;

	string cmp = "convert";

	AMPLITUDE = 1;

	if (strcmp(str.c_str(), cmp.c_str()))

	{

		AMPLITUDE = atof( (const char*)apBuffer );

	}

	DAC5672* mhDAC5672 = DAC5672::getInstance();

	mhDAC5672->fillData(AMPLITUDE, FREQUENCY, data);

	mhDAC5672->communicate(buff1, buff2, buff3, data);

	return 0;

}

/**

 * prints a character array through a debug IPC object

 * output is: "[DSP] <msg>"

 * @param pMsg - character array of message to print

 */

void debugPrint(char* pMsg)

{

	// The length of the message to be sent

	int len = strlen(pMsg);

   	// Pointer to dsplink buffer where to write the message

	char* pBuffer;

	// Make sure the debug IPC outbound object has been initialized

	if (gpDebug == NULL)

		return;

	// Get a buffer for the message

	pBuffer = (char *)gpDebug->GetBuffer(len+1);

	// Check that the buffer is valid

	if (pBuffer)

	{

		// Copy the message to the buffer

		strcpy(pBuffer, pMsg);

		// Send the message

		gpDebug->SendMessage(pBuffer);

	}

}