/**
 * @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);
	}
}