I'm trying to build a code for SPI-FFT system.
I referred a example from TI for both.
However, I am not sure it is correctly built.
My system has a flow like this. RFreciever (SI4463-Silabs) -> FFT(TMS320F28377D-TI)
Please if someone who can evaluate my code is here, help me!
<code>
//*****************************************************************************
// includes
//*****************************************************************************
#include "fpu_rfft.h"
#include "math.h"
#include "examples_setup.h"
#include "F28x_Project.h"
#include <stdio.h>
#include <inttypes.h>
//*****************************************************************************
// defines
//*****************************************************************************
#define RFFT_STAGES 8
#define RFFT_SIZE (1 << RFFT_STAGES)
#define EPSILON 0.01
#define WORDLENGTH 0x7 // 8 bit chars
void delay_loop(void);
void error(void);
//user
void spi_init_test(void);
void spi_init(void);
void spi_receive(void);
void spi_xmit(void);
volatile uint16_t sampleIndex = 0; //brief Index into the FFT input buffer
//*****************************************************************************
// globals
//*****************************************************************************
#pragma DATA_SECTION(RFFTin1Buff,"RFFTdata1")
#pragma DATA_SECTION(RFFTmagBuff,"RFFTdata2")
#pragma DATA_SECTION(RFFToutBuff,"RFFTdata3")
#pragma DATA_SECTION(RFFTF32Coef,"RFFTdata4")
float RFFTin1Buff[RFFT_SIZE];
float RFFTmagBuff[RFFT_SIZE/2+1];
float RFFToutBuff[RFFT_SIZE];
float RFFTF32Coef[RFFT_SIZE];
RFFT_F32_STRUCT rfft;
RFFT_F32_STRUCT_Handle hnd_rfft = &rfft;
uint16_t pass = 0;
uint16_t fail = 0;
//uint16_t rdata;
//uint16_t sdata; // send data
uint16_t rdata; // received data
//*****************************************************************************
// SPI function
//*****************************************************************************
void spi_xmit()
{
SpiaRegs.SPITXBUF=0x0044;
}
void spi_receive()
{
SpiaRegs.SPIRXBUF=0x0044; //receiving value from the buffer?
}
void spi_fifo_init()
{ // Initialize SPI FIFO registers
SpiaRegs.SPIFFTX.all=0xE040;
SpiaRegs.SPIFFRX.all=0x2044;
SpiaRegs.SPIFFCT.all=0x0;
}
void spi_fifo_init_test()
{
//SpiaRegs.SPIFFTX.bit.SPIRST = 0; //TX FIFO SPI Reset
SpiaRegs.SPIFFTX.bit.SPIFFENA = 0; //TX FIFO enhancements (what is that?)
SpiaRegs.SPIFFTX.bit.TXFFIENA = 0; //TX FIFO enable (0 = disable; 1 = enabled)
SpiaRegs.SPIFFTX.bit.TXFFIL = 0; //Transmit FIFO Interrupt Level Bits
SpiaRegs.SPIFFTX.bit.TXFFINT = 0; //TX FIFO Interrupt Bit (Read only)
SpiaRegs.SPIFFTX.bit.TXFFINTCLR = 0; //TX FIFO Interrupt Clear
//SpiaRegs.SPIFFTX.bit.SPIRST = 1; //TX FIFO SPI Reset CLEAR
//SpiaRegs.SPIFFTX.bit.TXFFST //TX FIFO status (tells you how many words there are (4 max) )
//SpiaRegs.SPIFFTX.bit.TXFIFO //TX FIFO reset
SpiaRegs.SPIFFRX.bit.RXFFIENA = 0; //RX FIFO Interrupt Enabler (0 = disable; 1 = enabled)
//SpiaRegs.SPIFFRX.bit.RXFFIL = //RX FIFO Interrupt Level Bits
SpiaRegs.SPIFFRX.bit.RXFFINT = 0; //RX FIFO Interrupt Flag
SpiaRegs.SPIFFRX.bit.RXFFINTCLR = 0; //RX FIFO Interrupt Flag Clear
//SpiaRegs.SPIFFRX.bit.RXFFOVF = //RX FIFO overflow flag
//SpiaRegs.SPIFFRX.bit.RXFFOVFCLR = //RX FIFO overflow flag Clear
//SpiaRegs.SPIFFRX.bit.RXFFST = //RX FIFO Receive status
SpiaRegs.SPIFFRX.bit.RXFIFORESET = 1; //RX FIFO Reset
SpiaRegs.SPIFFCT.bit.TXDLY = 0; //SPI FIFO Control Register
}
void spi_init()
{
SpiaRegs.SPICCR.all =0x000F; // Reset on, rising edge, 16-bit char bits
SpiaRegs.SPICTL.all =0x0006; // Enable master mode, normal phase,
SpiaRegs.SPIBRR.all =0x007F; // enable talk, and SPI int disabled.
SpiaRegs.SPICCR.all =0x009F; // Relinquish SPI from Reset
SpiaRegs.SPIPRI.bit.FREE = 1; // Set so breakpoints don't disturb xmission
}
void spi_init_test() //Configure the SPI configuration register bits
{
SpiaRegs.SPICCR.bit.SPISWRESET = 0; //SPI reset initialization
SpiaRegs.SPICCR.bit.CLKPOLARITY = 0; // controls the shift clock polarity refer to page 1990 of the technical documentation for more info
SpiaRegs.SPICCR.bit.HS_MODE = 0; // high speed mode SPI protocol
//SpiaRegs.SPICCR.bit.SPICHAR = ?? // Character length control bits (currently set the SPI loopback to 0)
SpiaRegs.SPICCR.bit.SPILBK = 0; //SPI Loopback Mode Select
SpiaRegs.SPICCR.bit.SPICHAR = 0x000F; //The number of characters to be shifted in and out as a single character during one shift sequence
SpiaRegs.SPICCR.bit.SPISWRESET = 1; //Relinquish SPI from Reset
//SPI Operation Control Register
SpiaRegs.SPICTL.bit.CLK_PHASE = 0; //help control the CLKPOLARITY sequence
SpiaRegs.SPICTL.bit.MASTER_SLAVE = 1; //Master mode = 1, Slave mode = 0
SpiaRegs.SPICTL.bit.OVERRUNINTENA = 0; //Overrun Interrupt Enable
SpiaRegs.SPICTL.bit.SPIINTENA = 0; //control whether SPI will run in ISR or not
SpiaRegs.SPICTL.bit.TALK = 1; //Transmit Enable
//enables 4-pin option, ensure to enable the receiver's SPISTEn input pin --> technical documents notes page 1903
//SCLK speed (Baud rate)
SpiaRegs.SPIBRR.bit.SPI_BIT_RATE = 0x00007F; //set the SPI baud rate
//7Fh (R/W) = SPI Baud Rate = LSPCLK/128
}
/*
void delay_loop()
{
long i;
for (i = 0; i < 1000000; i++) {}
}
void spare_code()
{
}
void error(void)
{
asm(" ESTOP0"); // Test failed!! Stop!
for (;;);
}
*/
//*****************************************************************************
// Main (FFT Cal)
//*****************************************************************************
void main(void)
{
// Locals
uint16_t i;
InitSysCtrl();
InitSpiaGpio();
DINT;
InitPieCtrl();
IER = 0x0000;
IFR = 0x0000;
InitPieVectTable();
spi_fifo_init(); //Initialize the Spi FIFO
spi_init_test(); //Initialize user SPI
//sdata = 1001;
Uint16 SPIbyte1;
for(i=0; i < 100; i++)
{
//RFFTin1Buff[i] = sin(Rad) + cos(Rad*2.3567); //Real input signal
//Rad = Rad + RadStep
//spi_receive(cos(2.3567));
SPIbyte1 = SpiaRegs.SPIRXBUF;
RFFTin1Buff[i] = (float) SPIbyte1;
}
//spi_xmit(sdata); //Wait until data is received
#ifdef FLASH
EALLOW;
Flash0EccRegs.ECC_ENABLE.bit.ENABLE = 0;
memcpy((uint32_t *)&RamfuncsRunStart, (uint32_t *)&RamfuncsLoadStart,
(uint32_t)&RamfuncsLoadSize );
FPU_initFlash();
#endif //FLASH
FPU_initSystemClocks();
FPU_initEpie();
for(i=0; i < RFFT_SIZE; i++){ // Clear input buffers:
RFFTin1Buff[i] = 0.0f;
}
//Rad = 0.0f; // Generate sample waveforms:
hnd_rfft->FFTSize = RFFT_SIZE;
hnd_rfft->FFTStages = RFFT_STAGES;
hnd_rfft->InBuf = &RFFTin1Buff[0]; //Input buffer
hnd_rfft->OutBuf = &RFFToutBuff[0]; //Output buffer
hnd_rfft->MagBuf = &RFFTmagBuff[0]; //Magnitude buffer
hnd_rfft->CosSinBuf = &RFFTF32Coef[0]; //Twiddle factor buffer
RFFT_f32_sincostable(hnd_rfft); //Calculate twiddle factor
for (i=0; i < RFFT_SIZE; i++){
RFFToutBuff[i] = 0; //Clean up output buffer
}
for (i=0; i <= RFFT_SIZE/2; i++){
RFFTmagBuff[i] = 0; //Clean up magnitude buffer
}
RFFT_f32(hnd_rfft); //Calculate real FFT
RFFT_f32_mag(hnd_rfft); //Calculate magnitude
hnd_rfft->PhaseBuf = &RFFTmagBuff[0]; //Use magnitude buffer
done();
//return 1; // Execution never reaches this point
}
Thank you.
