/*
Fast Fourier Transform (FFT).
Using 8 points, takes about 1.2 ms to execute one FFT.
Sets up General Purpose Timer 1 to generate events at 10 kHz.
Will produce 10 kHz output on T1PWM and T1PWM pins.
*/

#include "system.h"
#include "eva.h"
#include "io2407.h"
#include "adc.h"
#include "interrup.h"

#include "fftcmplx.h" /* Complex structure definition*/

extern void FFT(COMPLEX *Y, int N); /* FFT Function */

/* The following define gives the number of samples. */
/* It should divide exactly into 512 */
/* Should N be increased, to say to 32, then the execution */
/* time of the FFT would increase */

#define N 8

unsigned int perform_fft = 0; /* Flag driven by interrupt */

/*************************************************************/
/*
Initialise General Purpose Timers GPT1 and GPT2
*/
/*************************************************************/

/* Initialise General Purpose Timer 1. */

void init_GPT1(void)
{
MCRA |= T1PWM; /* Turn on T1PWM */
T1CON = 0x8142; /* Turn off GPT1 */
GPTCONA = 0x0041; /* Active low. */
T1PR = 1475; /* Sample at 10 kHz */
T1CMPR = 0; /* Duty = 0% */
T1CNT = 0xFFFE; /* Set to -2 */
T1CON = 0x9142; /* Start timer 1 */

EVAIFRA = 0xFFFF; /* Clear any pending interrupts */
EVAIMRA |= T1PINT_FLAG; /* Enable T1 period interrupt */
}

/* Initialise General Purpose Timer 2 */

void init_GPT2(void)
{
MCRA |= T2PWM; /* Turn on T2PWM */
T2CON = 0x8142; /* Turn off GPT2 */
GPTCONA |= 0x0008; /* Controlled from GPT1 */
T2PR = 1475; /* Sample at 10 kHz */
T2CMPR = 0; /* Duty cycle 0% decimal */
T2CNT = 0xFFFE; /* Set to -2 */
T2CON = 0x9142; /* Start timer 2 */
}

/**************************************************************/

void init_ADC()
{
/* Non Cascade for 8 measurements. */
/* Will affect RESULT0 to RESULT7 only */

ADCCTRL1 = (ADC_SOFT | ADC_CPS /*| ADC_ACQ_PS3 | ADC_ACQ_PS2*/ );

CHSELSEQ1 = 0x3210; /* 8 measurements 0 */
CHSELSEQ2 = 0x0000;
CHSELSEQ3 = 0xFFFF;
CHSELSEQ4 = 0xFFFF;
MAX_CONV = 0x0007; /* 8 measurements, not 0 */

/* Reset sequence at zero and software start of conversion */

ADCCTRL2 = ( RST_SEQ1 | SOC_SEQ1);

} /* No semicolon here */

/***********************************************************/

int input_buffer[N] = {8191, 8191, 8191, 8191, 0, 0, 0, 0};

COMPLEX y[N]; /* Variable passed to FFT and modified */

/***********************************************************/
/*
Shuffle input buffer along one place.
Put latest input from ADC into first buffer location.
Input from ADCIN2 lies in range 0 to FFC0h (65472 decimal).
Divide by 8 to limit range from 0 to 8184.
*/
/***********************************************************/

void shuffle_and_read(void)
{
signed int i;

for ( i = N-1 ; i > 0 ; i--)
{
input_buffer[i] = input_buffer[i-1];
}

input_buffer[0] = (RESULT2 >> 3);
}

/***********************************************************/
/*
Copy from input buffer to complex structure.
When FFT is performed, the complex structure is overwritten
by the return values.
*/
/***********************************************************/

void copy_input_to_complex(void)
{
unsigned int i;

for ( i = 0 ; i < N; i++)
{
(y[i]).real = input_buffer[i];
(y[i]).imag = 0;
}
}

/***********************************************************/
/*
Main program
Uses timers to read analog input on ADCIN2 into a buffer
and then perform an 8-point FFT on it.
*/
/**********************************************************/

void main(void)
{
signed int output1, output2;
signed int x; /* General purpose variable. */
signed int i; /* Counter */
signed long temp;

init_system(); /* Initialize variables and hardware */

init_ADC(); /* Initialise ADC */
init_GPT1(); /* Turn on timer 1 */
init_GPT2(); /* Turn on timer 2 */

MCRB &= 0xFFFE; /* I/O on IOPC0 for monitoring purposes */

IMR |= INT2; /* Turn on INT 2 */

asm(" CLRC INTM"); /* Turn on maskable interrupts */

for ( ;; )
{
if ( perform_fft != 0 )
{
perform_fft = 0; /* Clear flag used to start fft */

PCDATDIR = 0x0101; /* IOPC0 high */

ADCCTRL2 |= SOC_SEQ1; /* Start next conversion*/

copy_input_to_complex(); /* Copy inputs from receive buffer */

FFT(y,8); /* Calls generic FFT function*/

/* Determine magnitude of (y[0]).real */
/* output1 lies in range 0 to 32736 */

if ( (y[0]).real > 0)
output1 = (y[0]).real;
else
output1 = -(y[0]).real;

/* Determine magnitude of (y[0]).real */
/* output2 lies in range -32736 to 32736 */

if ( (y[2]).real > 0)
output2 = (y[2]).real;
else
output2 = -(y[2]).real;

/* Scale output in range 0 to 1475 */

temp = (signed long)(output1 * 2952);
output1 = (signed int)(temp >> 16);

T1CMPR = output1;

temp = (signed long)( output2 * 2952);
output2 = (signed int)(temp >> 16);

T2CMPR = output1;

shuffle_and_read(); /* Read in latest value from ADC */
/* and put into buffer */

PCDATDIR = 0x0100; /* IOPC0 low */

} /* End if */

} /* End for */

} /* End main() */

/************************************************************/

/* Interrupt routine */
/* The interrupt occurs once every 0.1 ms.
/* Will make perform_fft = 1 once every 20 * 0.1 ms = 2 ms */

void c_int2(void)
{
static unsigned int x;

if ( 0x0027 == PIVR)
{
EVAIFRA |= T1PINT_FLAG; /* Clear GPT1 period interrupt */

if ( x < 19 ) /* Increase if FFT with more points */
{
x++;
}
else
{
x = 0;
perform_fft = 1; /* Global flag to start FFT */
}

}
}

/* End of fft.c */