#dsk_app.c#

详细的OFDM设计过程

        MCBSP_FMKS(PCR, FSRM, EXTERNAL)         |
        MCBSP_FMKS(PCR, CLKXM, INPUT)           |
        MCBSP_FMKS(PCR, CLKRM, INPUT)           |
        MCBSP_FMKS(PCR, CLKSSTAT, DEFAULT)      |
        MCBSP_FMKS(PCR, DXSTAT, DEFAULT)        |
        MCBSP_FMKS(PCR, FSXP, ACTIVEHIGH)       |
        MCBSP_FMKS(PCR, FSRP, ACTIVEHIGH)       |
        MCBSP_FMKS(PCR, CLKXP, FALLING)         |
        MCBSP_FMKS(PCR, CLKRP, RISING)
};

/* Codec configuration settings */
DSK6713_AIC23_Config config = { \
    0x0017,  /* 0 DSK6713_AIC23_LEFTINVOL  Left line input channel volume */ \
    0x0017,  /* 1 DSK6713_AIC23_RIGHTINVOL Right line input channel volume */\
    0x01f9,  /* 2 DSK6713_AIC23_LEFTHPVOL  Left channel headphone volume */  \
    0x01f9,  /* 3 DSK6713_AIC23_RIGHTHPVOL Right channel headphone volume */ \
    0x0011,  /* 4 DSK6713_AIC23_ANAPATH    Analog audio path control */      \
    0x0000,  /* 5 DSK6713_AIC23_DIGPATH    Digital audio path control */     \
    0x0000,  /* 6 DSK6713_AIC23_POWERDOWN  Power down control */             \
    0x0043,  /* 7 DSK6713_AIC23_DIGIF      Digital audio interface format */ \
    0x0001,  /* 8 DSK6713_AIC23_SAMPLERATE Sample rate control */            \
    0x0001   /* 9 DSK6713_AIC23_DIGACT     Digital interface activation */   \
};


/* --------------------------- main() function -------------------------- */
/*
 *  main() - The main user task.  Performs application initialization and
 *           starts the data transfer.
 */
void main()
{
    /* Initialize Board Support Library */
    DSK6713_init();

    /* Initialize LEDs and DIP switches */
    DSK6713_LED_init();
    DSK6713_DIP_init();
	
    state_r = 1;
	frameNumber=0;    
	
	RefIndex=0;    
    loopIndex=50;
   	treshold = 100000;
     /* Clear buffers */
    memset((void *)gBufferXmtPing, 0, BUFFSIZE * 4 * 2);
    
    AIC23_setParams(&config);  // Configure the codec

    initMcbsp();               // Initialize McBSP1 for audio transfers

    IRQ_globalDisable();       // Disable global interrupts during setup

    initEdma();                // Initialize the EDMA controller

    initIrq();                 // Initialize interrupts
    
    IRQ_globalEnable();        // Re-enable global interrupts
}


/* ------------------------Helper Functions ----------------------------- */ 

/*
 *  initMcbsp() - Initialize the McBSP for codec data transfers using the
 *                configuration define at the top of this file.
 */
void initMcbsp()
{
    /* Open the codec data McBSP */
    hMcbsp1 = MCBSP_open(MCBSP_DEV1, MCBSP_OPEN_RESET);

    /* Configure the codec to match the AIC23 data format */
    MCBSP_config(hMcbsp1, &mcbspCfg1);

    /* Start the McBSP running */
    MCBSP_start(hMcbsp1, MCBSP_XMIT_START | MCBSP_RCV_START |
        MCBSP_SRGR_START | MCBSP_SRGR_FRAMESYNC, 220);
}


/*
 *  initIrq() - Initialize and enable the DMA receive interrupt using the CSL.
 *              The interrupt service routine for this interrupt is edmaHwi.
 */
void initIrq(void)
{
    /* Enable EDMA interrupts to the CPU */
    IRQ_clear(IRQ_EVT_EDMAINT);    // Clear any pending EDMA interrupts
    IRQ_enable(IRQ_EVT_EDMAINT);   // Enable EDMA interrupt
}


/*
 *  initEdma() - Initialize the DMA controller.  Use linked transfers to 
 *               automatically transition from ping to pong and visa-versa.
 */
void initEdma(void)
{
    /* Configure transmit channel */
    hEdmaXmt = EDMA_open(EDMA_CHA_XEVT1, EDMA_OPEN_RESET);  // get hEdmaXmt handle and reset channel
    hEdmaReloadXmtPing = EDMA_allocTable(-1);               // get hEdmaReloadXmtPing handle
    hEdmaReloadXmtPong = EDMA_allocTable(-1);               // get hEdmaReloadXmtPong handle
    
    gEdmaConfigXmt.dst = MCBSP_getXmtAddr(hMcbsp1);         // set the desination address to McBSP1 DXR
        
    gXmtChan = EDMA_intAlloc(-1);                           // get an open TCC
    gEdmaConfigXmt.opt |= EDMA_FMK(OPT,TCC,gXmtChan);       // set TCC to gXmtChan
        
    EDMA_config(hEdmaXmt, &gEdmaConfigXmt);                 // then configure the registers
    EDMA_config(hEdmaReloadXmtPing, &gEdmaConfigXmt);       // and the reload for Ping
    
    gEdmaConfigXmt.src = EDMA_SRC_OF(gBufferXmtPong);       // change the structure to have a source of Pong
    EDMA_config(hEdmaReloadXmtPong, &gEdmaConfigXmt);       // and configure the reload for Pong        
    
    EDMA_link(hEdmaXmt,hEdmaReloadXmtPong);                 // link the regs to Pong
    EDMA_link(hEdmaReloadXmtPong,hEdmaReloadXmtPing);       // link Pong to Ping
    EDMA_link(hEdmaReloadXmtPing,hEdmaReloadXmtPong);       // and link Ping to Pong    
        
    /* Configure receive channel */
    hEdmaRcv = EDMA_open(EDMA_CHA_REVT1, EDMA_OPEN_RESET);  // get hEdmaRcv handle and reset channel
    hEdmaReloadRcvPing = EDMA_allocTable(-1);               // get hEdmaReloadRcvPing handle
    hEdmaReloadRcvPong = EDMA_allocTable(-1);               // get hEdmaReloadRcvPong handle
    
    gEdmaConfigRcv.src = MCBSP_getRcvAddr(hMcbsp1);         // and the desination address to McBSP1 DXR
        
    gRcvChan = EDMA_intAlloc(-1);                           // get an open TCC
    gEdmaConfigRcv.opt |= EDMA_FMK(OPT,TCC,gRcvChan);       // set TCC to gRcvChan

    EDMA_config(hEdmaRcv, &gEdmaConfigRcv);                 // then configure the registers
    EDMA_config(hEdmaReloadRcvPing, &gEdmaConfigRcv);       // and the reload for Ping
    
    gEdmaConfigRcv.dst = EDMA_DST_OF(gBufferRcvPong);       // change the structure to have a destination of Pong
    EDMA_config(hEdmaReloadRcvPong, &gEdmaConfigRcv);       // and configure the reload for Pong
    
    EDMA_link(hEdmaRcv,hEdmaReloadRcvPong);                 // link the regs to Pong
    EDMA_link(hEdmaReloadRcvPong,hEdmaReloadRcvPing);       // link Pong to Ping
    EDMA_link(hEdmaReloadRcvPing,hEdmaReloadRcvPong);       // and link Ping to Pong
        
    /* Enable interrupts in the EDMA controller */
    EDMA_intClear(gXmtChan);    
    EDMA_intClear(gRcvChan);                                // clear any possible spurious interrupts

    EDMA_intEnable(gXmtChan);                               // enable EDMA interrupts (CIER)
    EDMA_intEnable(gRcvChan);                               // enable EDMA interrupts (CIER)

    EDMA_enableChannel(hEdmaXmt);                           // enable EDMA channel
    EDMA_enableChannel(hEdmaRcv);                           // enable EDMA channel
    
    /* Do a dummy write to generate the first McBSP transmit event */
    MCBSP_write(hMcbsp1, 0);
}


/*
 *  copyData() - Copy one buffer with length elements to another.
 */
void copyData(short *inbuf, short *outbuf, short length)
{
  short i = 0;
  
  for (i = 0; i < length; i++) {                      
    outbuf[i]  = inbuf[i];
  }
}


/* ---------------------- Interrupt Service Routines -------------------- */

/*
 *  edmaHwi() - Interrupt service routine for the DMA transfer.  It is
 *              triggered when a complete DMA receive frame has been
 *              transferred.   The edmaHwi ISR is inserted into the interrupt
 *              vector table at compile time through a setting in the DSP/BIOS
 *              configuration under Scheduling --> HWI --> HWI_INT8.  edmaHwi
 *              uses the DSP/BIOS Dispatcher to save register state and make
 *              sure the ISR co-exists with other DSP/BIOS functions.
 */
void edmaHwi(void)
{
  static Uint32 pingOrPong = PING;  // Ping-pong state variable
  static short xmtdone = 0, rcvdone = 0;
  
  /* Check CIPR to see which transfer completed */
  if (EDMA_intTest(gXmtChan))
    {
      EDMA_intClear(gXmtChan);
        xmtdone = 1;
    }
  if (EDMA_intTest(gRcvChan))
    {
      EDMA_intClear(gRcvChan);
      rcvdone = 1;
    }
  
  /* If both transfers complete, signal processBufferSwi to handle */
  if (xmtdone && rcvdone)
    {
        if (pingOrPong==PING)
	  {
            SWI_or(&processBufferSwi, PING);
            pingOrPong = PONG;
	  } else
        {
	  SWI_or(&processBufferSwi, PONG);
	  pingOrPong = PING;
        }
        rcvdone = 0;
        xmtdone = 0;
    }
}


/* ------------------------------- Threads ------------------------------ */

/*
 *  processBuffer() - Process audio data once it has been received.            
 */
void processBuffer(void)
{
  Uint32 pingPong;
  
  /* Get contents of mailbox posted by edmaHwi */
  pingPong =  SWI_getmbox();

  /* Copy data from transmit to receive, could process audio here */
  if (pingPong == PING) { 
    /* Toggle LED #3 as a visual cue */
    DSK6713_LED_toggle(3);
        
    copy2Data(gBufferRcvPing, ProcessBuffer, BUFFSIZE);      
    
    processData(ProcessBuffer, BUFFSIZE);
    
    //        createTrig(ProcessBuffer, BUFFSIZE);
    
    /* Copy receive PING buffer to transmit PING buffer */
    //        copyData2x2(ProcessBuffer, gBufferXmtPing, BUFFSIZE);
  } else {
    /* Toggle LED #2 as a visual cue */
    DSK6713_LED_toggle(2);
    
    /* Copy receive PONG buffer to transmit PONG buffer */
    copy2Data(gBufferRcvPong, ProcessBuffer, BUFFSIZE);
        
    processData(ProcessBuffer, BUFFSIZE);
    
    //        createTrig(ProcessBuffer, BUFFSIZE);      
    /* Copy receive PING buffer to transmit PING buffer */
    //        copyData2x2(ProcessBuffer, gBufferXmtPong, BUFFSIZE);
  }
}

/* 
 *  Process the recieved data 
 */
void processData(short *databuf, short length)
{
	// Find beginning of first frame:
	short startindex[2];

	switch(state_r){
		case 1:              // Wait for first synchronizing signal
			framesync(databuf, startindex, length);
			slask = startindex[0] - loopIndex;
			//	energydetect(databuf, startindex, length);

			if(startindex[0] != 0)
			{
				if((RefIndex+10)==startindex[0]) 
		   			DSK6713_LED_toggle(1);
	
				if(((RefIndex-10)<startindex[0]) && ((RefIndex+40)>startindex[0]))
    				DSK6713_LED_toggle(0);
			//	DSK6713_LED_toggle(1);
				RefIndex = startindex[0];
				// Initialize processing of first frame!
				if(startindex[0]<(BUFFSIZE-FRAMELEN)){
					copyData(&databuf[startindex[0]+48], framebuffer, FRAMELEN);
					extractFrame(framebuffer, frameNumber, FRAMELEN);
					nextFrame = startindex[0]+48+FRAMELEN;
					frameNumber++;
					state_r = 2;
				} else {  // Fucking bastards! The frame overlaps the buffer borders..
					copyData(&databuf[startindex[0]+48], framebuffer, (BUFFSIZE-startindex[0]-48));
					nextFrame = FRAMELEN-(BUFFSIZE-startindex[0]-48);	
							
					state_r = 3;
				}
				break;
			} else {			// Wait for sync in next buffer