Mech - User contributions [en]

File:IFFTwaveforms2.png

2010-05-20T18:30:42Z

AndrewDai:

PIC32MX: FFT of Analog Input

2010-05-20T18:30:35Z

AndrewDai: /* IFFT Example Plot */

== Overview ==
A fast Fourier transform (FFT) is a method to calculate a discrete Fourier transform (DFT). More information about [http://en.wikipedia.org/wiki/Fast_Fourier_transform FFTs] and [http://en.wikipedia.org/wiki/Discrete_Fourier_transform DFTs] can be found on wikipedia (linked).
The following circuit and code allow a user to put a signal into a PIC32, perform an FFT on that signal, output the data to Matlab via RS-232, and view a plot showing the raw signal, the FFT as calculated by the PIC, and the FFT as calculated by Matlab. Viewing the Matlab calculation is for verification only and can be commented out of the Matlab code.

Commented C code and Matlab code for a FFT are provided in the FFT Code section of this page and can be downloaded [[Media: Lab5FFTcode.zip | here]].

With the PIC32, an inverse FFT can also be computed. Inverse FFT is a function that converts a frequency domain signal into a time domain signal. Inverse FFTs actually use the same algorithm as FFTs except with some scaling and conjugation or time reversal (depending on the algorithm). The second half of this page shows how you can create an analog signal, takes the FFT of that signal, and then take the inverse FFT of the result to try and obtain the original waveform back. The data is all sent to MATLAB via RS232 and compared to MATLAB's computational results for accuracy.

The C code and Matlab code for this program can be downloaded [[Media: IFFTcode2.zip | here]].

== FFT Circuit ==

Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

*RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
*RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
*Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection.

[[Image:FftSchematic.png]]

== FFT Code ==
The following is the source code to be programmed onto the PIC. If unfamiliar, see [[HelloWorld_PIC32 | here]] for a guide to creating a .hex file with MPLAB and [[Directions_to_Load_Files_to_PIC32_with_HID_Bootloader | here]] for directions to load files to the PIC. It first establishes inputs, outputs and RS-232 communication. When prompted with a 'p' (as written, it is prompted automatically by Matlab), the PIC computes the FFT then sends the magnitude portion of the single-sided FFT and the raw samples to Matlab.

<pre>
/* Sam Bobb, Daniel Cornew, Ryan Deeter
Fast Fourier Transform (FFT) Example
ME 333, Lab 5
Feb 2010
*/

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include <plib.h>
#include "dsplib_dsp.h"
#include "fftc.h"

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define LOOP_TIME_PIN LATAbits.LATA14

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

// To modify the number of samples:
#define fftc fft16c256 //from fftc.h, for N = 256 use fft16c256, for N = 1024 use fft16c1024
#define N 256 // Also change the log2N variable below!!

// To modify the sampling frequency
#define SAMPLE_FREQ 10000
// Also change the timer interupt setup in initInterruptController!

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void computeFFT(void); //sets up function to compute FFT

/** Global Variables *******************************************/

int computeFFTflag = FALSE; //used to indicate that an fft computation has been requested over rs232

int sampleIndex = 0; //keeps track of where we're putting our ADC reading

/** establish variables for FFT calculation*/
// -----
// this has to be changed for different values of N
int log2N = 8; // log2(256) = 8
//int log2N = 10; // log2(1024) = 10
// -----

int16c sampleBuffer[N]; //initialize buffer to collect samples
int16c calcBuffer[N]; // initialize buffer to hold old samples
int16c scratch[N];
int16c dout[N]; //holds computed FFT until transmission

long int singleSidedFFT[N];
long int freqVector[N];

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;

// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);

TRISAbits.TRISA14 = 0;

// Allow vector interrupts
INTEnableSystemMultiVectoredInt();

mInitAllLEDs();

initInterruptController();

initUART2(pbClk);

// Configure the proper PB frequency and the number of wait states
SYSTEMConfigPerformance(SYS_FREQ);

// -------- Set Up ADC --------
// configure and enable the ADC
CloseADC10(); // ensure the ADC is off before setting the configuration

// define setup parameters for OpenADC10
// Turn module on | output in integer | trigger mode auto | enable autosample
#define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG16 | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON

// define setup parameters for OpenADC10
// ADC ref external | disable offset test | enable scan mode | perform 2 samples | use one buffer | use MUXA mode
#define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_2 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF

// define setup parameters for OpenADC10
// use ADC internal clock | set sample time
#define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_15

// define setup parameters for OpenADC10
// set AN4
#define PARAM4 ENABLE_AN4_ANA

// define setup parameters for OpenADC10
// do not assign channels to scan
#define PARAM5 SKIP_SCAN_AN0 | SKIP_SCAN_AN1 | SKIP_SCAN_AN2 | SKIP_SCAN_AN3 | SKIP_SCAN_AN5 | SKIP_SCAN_AN6 | SKIP_SCAN_AN7 | SKIP_SCAN_AN8 | SKIP_SCAN_AN9 | SKIP_SCAN_AN10 | SKIP_SCAN_AN11 | SKIP_SCAN_AN12 | SKIP_SCAN_AN13 | SKIP_SCAN_AN14 | SKIP_SCAN_AN15

// use ground as neg ref for A | use AN4 (B4) for input A
// configure to sample AN4
SetChanADC10( ADC_CH0_NEG_SAMPLEA_NVREF); // configure to sample AN4
OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4, PARAM5 ); // configure ADC using parameter define above

EnableADC10(); // Enable the ADC

while ( ! mAD1GetIntFlag() ) { } // wait for the first conversion to complete so there will be valid data in ADC result registers
// ------ DONE SETTING UP ADC ------

// zero the freqVector and singleSidedFFT
for (i=0; i<N; i++)
{
freqVector[i] = 0;
singleSidedFFT[i] = 0;
}

// generate frequency vector
// this is the x-axis of your single sided fft
for (i=0; i<N/2; i++)
{
freqVector[i] = i*(SAMPLE_FREQ/2)/((N/2) - 1);
}

// wait around until you get an fft command from rs232
// then call computeFFT to generate an fft of the last block of samples
// then send out rs232.
// If you want to use FFT without rs232, you can call computeFFT when ever you want in your program.
while(1)
{
if (computeFFTflag == TRUE)
{
computeFFT();
sendDataRS232();
}
}

CloseOC1();

} //end main

/** Interrupt Handlers *****************************************/
// interrput code for the timer 3
void __ISR( _TIMER_3_VECTOR, ipl7) T3Interrupt( void)
{
int i;
//LOOP_TIME_PIN = TRUE;
// When we used the loop time pin to measure the length of this ISR,
// we measured 400 ns, so you could sample at over 1 MHz.

sampleBuffer[sampleIndex].re = ReadADC10(0); // read the ADC into the real part of the samplebuffer
sampleBuffer[sampleIndex].im = 0; // the imaginary value is 0.

// you could shave a little time off this ISR by just zeroing the .im value once, outside the ISR

// increment the sampleIndex
if (sampleIndex == (N-1))
{
sampleIndex = 0;
}
else
{
sampleIndex++;
}

//LOOP_TIME_PIN = FALSE;

// clear interrupt flag and exit
mT3ClearIntFlag();
} // T3 Interrupt

// UART 2 interrupt handler
// it is set at priority level 2
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
char data;

// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data = ReadUART2();
// Echo what we just received.
putcUART2(data);

switch(data)
{

case 'p': // compute and output the FFT
computeFFTflag = TRUE;
break;
}

// Toggle LED to indicate UART activity
mLED_0_Toggle();

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initInterruptController(void)
{
// init Timer3 mode and period (PR3)
OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, 0x1F40); // produces 100 ms period
// sampling frequency = 10 kHz

mT3SetIntPriority( 7); // set Timer3 Interrupt Priority
mT3ClearIntFlag(); // clear interrupt flag
mT3IntEnable( 1); // enable timer3 interrupts
}

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void sendDataRS232()
{
int i;
char RS232_Out_Buffer[32]; // max characters per line (line feed and carriage return count)

sprintf(RS232_Out_Buffer,"\n\rSTART\n\r"); //print START. MATLAB uses this as a start delimiter
putsUART2(RS232_Out_Buffer);

sprintf(RS232_Out_Buffer,"ROWS=%d\n\r", N); //print the number of rows, so matlab can make the correct sized buffer
putsUART2(RS232_Out_Buffer);

for(i = 0; i < N; i++)
{
// output: frequency vector, the calculated fft, raw samples
sprintf(RS232_Out_Buffer,"%d %d %d\n\r",freqVector[i], singleSidedFFT[i], calcBuffer[i].re);
putsUART2(RS232_Out_Buffer);
}

sprintf(RS232_Out_Buffer,"END\n\r"); //output end so matlab knows we're done
putsUART2(RS232_Out_Buffer);

}

void computeFFT()
{
// when using 256 samples, we measured this function to take about 500 microseconds
// (not including the time to send rs232 data)
int i;

mT3IntEnable(0); //turns off interrupt while computing FFT

LOOP_TIME_PIN = TRUE;

for (i=0; i<N; i++)
{
if (i<sampleIndex)
{
// old chunk
calcBuffer[i+(N-sampleIndex)] = sampleBuffer[i];
}
else // i >= sampleIndex
{
// new chunk
calcBuffer[i-sampleIndex] = sampleBuffer[i];
}

}

// load complex input data into din
mips_fft16(dout, calcBuffer, fftc, scratch, log2N);

// compute single sided fft
for(i = 0; i < N/2; i++)
{
singleSidedFFT[i] = 2 * ((dout[i].re*dout[i].re) + (dout[i].im*dout[i].im));
}

LOOP_TIME_PIN = FALSE;

computeFFTflag = FALSE;

// do something with dout
mT3IntEnable(1); //turn interrupt back on
}

</pre>

The following Matlab code computes its own FFT with the raw samples. It then plots the input signal, the PIC calculated FFT, and the Matlab calculated FFT, for comparison.

<pre>

% fftserial interface v 2

%Sam Bobb, Daniel Cornew, Ryan Deeter
%ME 333 Lab 5: FFT of Analog Input, Winter 2010

%This code receives the single sided magnitude FFT calculated on the PIC
%and the raw samples through serial communication. Matlab calculates its
%own FFT of the raw samples, then plots the input signal, PIC calculated
%FFT, and Matlab calculated FFT.

Fs = 10000; % Sampling frequency
T = 1/Fs; % Sample time
L = 256; % Length of signal
t = (0:L-1)*T; % Time vector

%for runtimes=1:100 %UNCOMMENT FOR CONTINUOUS FFT

columns = 3;

%check if the serial port already exists
%if it does, close it, it probably means something bad happened last run
if exist('COM','var')
disp('closing old port instance');
fclose(COM)
delete(COM)
clear COM
disp('port closed');
end

% open the serial port
COM = serial('COM6');
set(COM,'BaudRate',19200);
fopen(COM)

disp('port opened');

% send the command to print data
fprintf(COM,'p')

%there's usually some garbage at the beginning (like the echoed p
%character command and line breaks); this reads lines in until we find
%the start line
text = fscanf(COM, '%s');
while isempty(strfind(text, 'START'))
text = fscanf(COM, '%s');
end

% read number of rows
rowstext = fscanf(COM, '%s');
pat = 'ROWS=';
split = regexp(rowstext, pat, 'split');
rows = str2double(split(2));

DATA = zeros(rows,columns);

%generate the fscanf format argument
%repeate the formatchar character for the number of columns
formatchar = '%d';
serialpat = '';

%establishing fscanf format
for j = 1:columns
serialpat = [serialpat ' ' formatchar];
end

%reads serial data and puts it into DATA
for j = 1:rows
DATA(j, :) = fscanf(COM, serialpat, [columns 1]);
%disp(COM.BytesAvailable)

end

%reads last line
last = fscanf(COM, '%s');

%verifies that last line read is the last line
if strcmp(last,'END')
disp('Success')
else
disp('Problem')
end

%disp(COM.BytesAvailable) %for debugging

%plotting input signal
subplot(3, 1, 1)
plot(DATA(:,3))
title('Time Domain Signal')

%plotting PIC calculated FFT
subplot(3, 1, 2)
plot(DATA(:,1), DATA(:,2))
title('Single Sided FFT Calculated on the PIC')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')
axis([0 Fs/2 0 2e5])

%calculating FFT in Matlab
NFFT = 2^nextpow2(L); % Next power of 2 from length of y
Y = fft(DATA(:,3),NFFT)/L;

%Y = DATA(:,1) + DATA(:,2)*1i;

f = Fs/2*linspace(0,1,NFFT/2+1);

% Plot Matlab's single-sided amplitude spectrum.
subplot(3, 1, 3)
plot(f,2*abs(Y(1:NFFT/2+1)))
title('Single Sided FFT Calculated with MATLAB')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')

%pause(2) %UNCOMMENT FOR CONTINOUS FFT

%end %UNCOMMENT FOR CONTINUOUS FFT

%closes serial port
fclose(COM)
delete(COM)
clear COM
disp('port closed');

</pre>

==FFT Example Plots==
Here is an example using a 500 Hz sine wave input.
[[Image: FFT_500_sin.jpg|border|700px]]

This example uses a 1 kHz sine wave.
[[Image: FFT_1K_sin.jpg|border|700px]]

This example is still at 1 kHz, but with a square wave.
[[Image: FFT_1K_square.jpg|border|700px]]

This example shows a 2 kHz sine wave.
[[Image: FFT_2K_sin.jpg|border|700px]]

This example, still at 2 kHz, is a square wave.
[[Image: FFT_2K_square.jpg|border|700px]]

The final example is a 3 kHz sine wave.
[[Image: FFT_3K_sin.jpg|border|700px]]

== IFFT Circuit ==

This circuit is very similar to the preview FFT circuit, except that it includes a low pass filter. This filter integrates the PWM signal that is output from pin D0 and creates a continuous, analog signal.

[[Image:IFftSchematic.png|border|700px]]

== IFFT Code ==

The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode2.zip | here]]. The code is very similar to the code found above. There are two main differences:

1. There is now an "analog output." This is basically a PWM that is filtered through a low pass filter. The pulse widths are modified very quickly, with the width of the pulse directly related to the amplitude of the output. Thus, a very short pulse is the same as the trough of the sine wave and a long pulse is the same as the peak of the wave.

2. This is more of a tip, but after the analog inputs are stored in the sample array, they are scaled up by a factor, in this case, 256. All this does is increase the range of the values. I found this to give results that align much better with MATLAB's results. The reason for this is that the mips_fft16 algorithm accepts int16 and int32 data the best. However, int data types can lose information since they round to the nearest integer. Thus, we can scale all the inputs to make them larger, thus yielding more accuracy (it is as if we added a few more decimal places).

== IFFT Example Plot ==

This waveform is a 30Hz sine wave superimposed on a 40Hz sine wave with the same amplitude and phase. As one can see, the FFT amplitude line up almost exactly. The phase graph has some discrepancy, but this can be easily fixed by changing the FFT phase vector to float, rather than int16. It is ok to use int16 here because the vector is not being inputted into the mips_fft algorithm. And finally, the inverse FFT matches up very nicely with the original signal, very little information is lost.

[[Image: IFFTwaveforms2.png|border|700px]]

PIC32MX: FFT of Analog Input

2010-05-20T18:30:04Z

AndrewDai: /* Overview */

File:IFFTcode2.zip

2010-05-20T18:29:50Z

AndrewDai:

PIC32MX: FFT of Analog Input

2010-05-20T18:29:39Z

AndrewDai: /* IFFT Code */

== Overview ==
A fast Fourier transform (FFT) is a method to calculate a discrete Fourier transform (DFT). More information about [http://en.wikipedia.org/wiki/Fast_Fourier_transform FFTs] and [http://en.wikipedia.org/wiki/Discrete_Fourier_transform DFTs] can be found on wikipedia (linked).
The following circuit and code allow a user to put a signal into a PIC32, perform an FFT on that signal, output the data to Matlab via RS-232, and view a plot showing the raw signal, the FFT as calculated by the PIC, and the FFT as calculated by Matlab. Viewing the Matlab calculation is for verification only and can be commented out of the Matlab code.

Commented C code and Matlab code for a FFT are provided in the FFT Code section of this page and can be downloaded [[Media: Lab5FFTcode.zip | here]].

With the PIC32, an inverse FFT can also be computed. Inverse FFT is a function that converts a frequency domain signal into a time domain signal. Inverse FFTs actually use the same algorithm as FFTs except with some scaling and conjugation or time reversal (depending on the algorithm). The second half of this page shows how you can create an analog signal, takes the FFT of that signal, and then take the inverse FFT of the result to try and obtain the original waveform back. The data is all sent to MATLAB via RS232 and compared to MATLAB's computational results for accuracy.

The C code and Matlab code for this program can be downloaded [[Media: IFFTcode.zip | here]].

== FFT Circuit ==

Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

*RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
*RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
*Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection.

[[Image:FftSchematic.png]]

== FFT Code ==
The following is the source code to be programmed onto the PIC. If unfamiliar, see [[HelloWorld_PIC32 | here]] for a guide to creating a .hex file with MPLAB and [[Directions_to_Load_Files_to_PIC32_with_HID_Bootloader | here]] for directions to load files to the PIC. It first establishes inputs, outputs and RS-232 communication. When prompted with a 'p' (as written, it is prompted automatically by Matlab), the PIC computes the FFT then sends the magnitude portion of the single-sided FFT and the raw samples to Matlab.

<pre>
/* Sam Bobb, Daniel Cornew, Ryan Deeter
Fast Fourier Transform (FFT) Example
ME 333, Lab 5
Feb 2010
*/

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include <plib.h>
#include "dsplib_dsp.h"
#include "fftc.h"

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define LOOP_TIME_PIN LATAbits.LATA14

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

// To modify the number of samples:
#define fftc fft16c256 //from fftc.h, for N = 256 use fft16c256, for N = 1024 use fft16c1024
#define N 256 // Also change the log2N variable below!!

// To modify the sampling frequency
#define SAMPLE_FREQ 10000
// Also change the timer interupt setup in initInterruptController!

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void computeFFT(void); //sets up function to compute FFT

/** Global Variables *******************************************/

int computeFFTflag = FALSE; //used to indicate that an fft computation has been requested over rs232

int sampleIndex = 0; //keeps track of where we're putting our ADC reading

/** establish variables for FFT calculation*/
// -----
// this has to be changed for different values of N
int log2N = 8; // log2(256) = 8
//int log2N = 10; // log2(1024) = 10
// -----

int16c sampleBuffer[N]; //initialize buffer to collect samples
int16c calcBuffer[N]; // initialize buffer to hold old samples
int16c scratch[N];
int16c dout[N]; //holds computed FFT until transmission

long int singleSidedFFT[N];
long int freqVector[N];

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;

// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);

TRISAbits.TRISA14 = 0;

// Allow vector interrupts
INTEnableSystemMultiVectoredInt();

mInitAllLEDs();

initInterruptController();

initUART2(pbClk);

// Configure the proper PB frequency and the number of wait states
SYSTEMConfigPerformance(SYS_FREQ);

// -------- Set Up ADC --------
// configure and enable the ADC
CloseADC10(); // ensure the ADC is off before setting the configuration

// define setup parameters for OpenADC10
// Turn module on | output in integer | trigger mode auto | enable autosample
#define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG16 | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON

// define setup parameters for OpenADC10
// ADC ref external | disable offset test | enable scan mode | perform 2 samples | use one buffer | use MUXA mode
#define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_2 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF

// define setup parameters for OpenADC10
// use ADC internal clock | set sample time
#define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_15

// define setup parameters for OpenADC10
// set AN4
#define PARAM4 ENABLE_AN4_ANA

// define setup parameters for OpenADC10
// do not assign channels to scan
#define PARAM5 SKIP_SCAN_AN0 | SKIP_SCAN_AN1 | SKIP_SCAN_AN2 | SKIP_SCAN_AN3 | SKIP_SCAN_AN5 | SKIP_SCAN_AN6 | SKIP_SCAN_AN7 | SKIP_SCAN_AN8 | SKIP_SCAN_AN9 | SKIP_SCAN_AN10 | SKIP_SCAN_AN11 | SKIP_SCAN_AN12 | SKIP_SCAN_AN13 | SKIP_SCAN_AN14 | SKIP_SCAN_AN15

// use ground as neg ref for A | use AN4 (B4) for input A
// configure to sample AN4
SetChanADC10( ADC_CH0_NEG_SAMPLEA_NVREF); // configure to sample AN4
OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4, PARAM5 ); // configure ADC using parameter define above

EnableADC10(); // Enable the ADC

while ( ! mAD1GetIntFlag() ) { } // wait for the first conversion to complete so there will be valid data in ADC result registers
// ------ DONE SETTING UP ADC ------

// zero the freqVector and singleSidedFFT
for (i=0; i<N; i++)
{
freqVector[i] = 0;
singleSidedFFT[i] = 0;
}

// generate frequency vector
// this is the x-axis of your single sided fft
for (i=0; i<N/2; i++)
{
freqVector[i] = i*(SAMPLE_FREQ/2)/((N/2) - 1);
}

// wait around until you get an fft command from rs232
// then call computeFFT to generate an fft of the last block of samples
// then send out rs232.
// If you want to use FFT without rs232, you can call computeFFT when ever you want in your program.
while(1)
{
if (computeFFTflag == TRUE)
{
computeFFT();
sendDataRS232();
}
}

CloseOC1();

} //end main

/** Interrupt Handlers *****************************************/
// interrput code for the timer 3
void __ISR( _TIMER_3_VECTOR, ipl7) T3Interrupt( void)
{
int i;
//LOOP_TIME_PIN = TRUE;
// When we used the loop time pin to measure the length of this ISR,
// we measured 400 ns, so you could sample at over 1 MHz.

sampleBuffer[sampleIndex].re = ReadADC10(0); // read the ADC into the real part of the samplebuffer
sampleBuffer[sampleIndex].im = 0; // the imaginary value is 0.

// you could shave a little time off this ISR by just zeroing the .im value once, outside the ISR

// increment the sampleIndex
if (sampleIndex == (N-1))
{
sampleIndex = 0;
}
else
{
sampleIndex++;
}

//LOOP_TIME_PIN = FALSE;

// clear interrupt flag and exit
mT3ClearIntFlag();
} // T3 Interrupt

// UART 2 interrupt handler
// it is set at priority level 2
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
char data;

// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data = ReadUART2();
// Echo what we just received.
putcUART2(data);

switch(data)
{

case 'p': // compute and output the FFT
computeFFTflag = TRUE;
break;
}

// Toggle LED to indicate UART activity
mLED_0_Toggle();

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initInterruptController(void)
{
// init Timer3 mode and period (PR3)
OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, 0x1F40); // produces 100 ms period
// sampling frequency = 10 kHz

mT3SetIntPriority( 7); // set Timer3 Interrupt Priority
mT3ClearIntFlag(); // clear interrupt flag
mT3IntEnable( 1); // enable timer3 interrupts
}

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void sendDataRS232()
{
int i;
char RS232_Out_Buffer[32]; // max characters per line (line feed and carriage return count)

sprintf(RS232_Out_Buffer,"\n\rSTART\n\r"); //print START. MATLAB uses this as a start delimiter
putsUART2(RS232_Out_Buffer);

sprintf(RS232_Out_Buffer,"ROWS=%d\n\r", N); //print the number of rows, so matlab can make the correct sized buffer
putsUART2(RS232_Out_Buffer);

for(i = 0; i < N; i++)
{
// output: frequency vector, the calculated fft, raw samples
sprintf(RS232_Out_Buffer,"%d %d %d\n\r",freqVector[i], singleSidedFFT[i], calcBuffer[i].re);
putsUART2(RS232_Out_Buffer);
}

sprintf(RS232_Out_Buffer,"END\n\r"); //output end so matlab knows we're done
putsUART2(RS232_Out_Buffer);

}

void computeFFT()
{
// when using 256 samples, we measured this function to take about 500 microseconds
// (not including the time to send rs232 data)
int i;

mT3IntEnable(0); //turns off interrupt while computing FFT

LOOP_TIME_PIN = TRUE;

for (i=0; i<N; i++)
{
if (i<sampleIndex)
{
// old chunk
calcBuffer[i+(N-sampleIndex)] = sampleBuffer[i];
}
else // i >= sampleIndex
{
// new chunk
calcBuffer[i-sampleIndex] = sampleBuffer[i];
}

}

// load complex input data into din
mips_fft16(dout, calcBuffer, fftc, scratch, log2N);

// compute single sided fft
for(i = 0; i < N/2; i++)
{
singleSidedFFT[i] = 2 * ((dout[i].re*dout[i].re) + (dout[i].im*dout[i].im));
}

LOOP_TIME_PIN = FALSE;

computeFFTflag = FALSE;

// do something with dout
mT3IntEnable(1); //turn interrupt back on
}

</pre>

The following Matlab code computes its own FFT with the raw samples. It then plots the input signal, the PIC calculated FFT, and the Matlab calculated FFT, for comparison.

<pre>

% fftserial interface v 2

%Sam Bobb, Daniel Cornew, Ryan Deeter
%ME 333 Lab 5: FFT of Analog Input, Winter 2010

%This code receives the single sided magnitude FFT calculated on the PIC
%and the raw samples through serial communication. Matlab calculates its
%own FFT of the raw samples, then plots the input signal, PIC calculated
%FFT, and Matlab calculated FFT.

Fs = 10000; % Sampling frequency
T = 1/Fs; % Sample time
L = 256; % Length of signal
t = (0:L-1)*T; % Time vector

%for runtimes=1:100 %UNCOMMENT FOR CONTINUOUS FFT

columns = 3;

%check if the serial port already exists
%if it does, close it, it probably means something bad happened last run
if exist('COM','var')
disp('closing old port instance');
fclose(COM)
delete(COM)
clear COM
disp('port closed');
end

% open the serial port
COM = serial('COM6');
set(COM,'BaudRate',19200);
fopen(COM)

disp('port opened');

% send the command to print data
fprintf(COM,'p')

%there's usually some garbage at the beginning (like the echoed p
%character command and line breaks); this reads lines in until we find
%the start line
text = fscanf(COM, '%s');
while isempty(strfind(text, 'START'))
text = fscanf(COM, '%s');
end

% read number of rows
rowstext = fscanf(COM, '%s');
pat = 'ROWS=';
split = regexp(rowstext, pat, 'split');
rows = str2double(split(2));

DATA = zeros(rows,columns);

%generate the fscanf format argument
%repeate the formatchar character for the number of columns
formatchar = '%d';
serialpat = '';

%establishing fscanf format
for j = 1:columns
serialpat = [serialpat ' ' formatchar];
end

%reads serial data and puts it into DATA
for j = 1:rows
DATA(j, :) = fscanf(COM, serialpat, [columns 1]);
%disp(COM.BytesAvailable)

end

%reads last line
last = fscanf(COM, '%s');

%verifies that last line read is the last line
if strcmp(last,'END')
disp('Success')
else
disp('Problem')
end

%disp(COM.BytesAvailable) %for debugging

%plotting input signal
subplot(3, 1, 1)
plot(DATA(:,3))
title('Time Domain Signal')

%plotting PIC calculated FFT
subplot(3, 1, 2)
plot(DATA(:,1), DATA(:,2))
title('Single Sided FFT Calculated on the PIC')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')
axis([0 Fs/2 0 2e5])

%calculating FFT in Matlab
NFFT = 2^nextpow2(L); % Next power of 2 from length of y
Y = fft(DATA(:,3),NFFT)/L;

%Y = DATA(:,1) + DATA(:,2)*1i;

f = Fs/2*linspace(0,1,NFFT/2+1);

% Plot Matlab's single-sided amplitude spectrum.
subplot(3, 1, 3)
plot(f,2*abs(Y(1:NFFT/2+1)))
title('Single Sided FFT Calculated with MATLAB')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')

%pause(2) %UNCOMMENT FOR CONTINOUS FFT

%end %UNCOMMENT FOR CONTINUOUS FFT

%closes serial port
fclose(COM)
delete(COM)
clear COM
disp('port closed');

</pre>

==FFT Example Plots==
Here is an example using a 500 Hz sine wave input.
[[Image: FFT_500_sin.jpg|border|700px]]

This example uses a 1 kHz sine wave.
[[Image: FFT_1K_sin.jpg|border|700px]]

This example is still at 1 kHz, but with a square wave.
[[Image: FFT_1K_square.jpg|border|700px]]

This example shows a 2 kHz sine wave.
[[Image: FFT_2K_sin.jpg|border|700px]]

This example, still at 2 kHz, is a square wave.
[[Image: FFT_2K_square.jpg|border|700px]]

The final example is a 3 kHz sine wave.
[[Image: FFT_3K_sin.jpg|border|700px]]

== IFFT Circuit ==

This circuit is very similar to the preview FFT circuit, except that it includes a low pass filter. This filter integrates the PWM signal that is output from pin D0 and creates a continuous, analog signal.

[[Image:IFftSchematic.png|border|700px]]

== IFFT Code ==

The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode2.zip | here]]. The code is very similar to the code found above. There are two main differences:

1. There is now an "analog output." This is basically a PWM that is filtered through a low pass filter. The pulse widths are modified very quickly, with the width of the pulse directly related to the amplitude of the output. Thus, a very short pulse is the same as the trough of the sine wave and a long pulse is the same as the peak of the wave.

2. This is more of a tip, but after the analog inputs are stored in the sample array, they are scaled up by a factor, in this case, 256. All this does is increase the range of the values. I found this to give results that align much better with MATLAB's results. The reason for this is that the mips_fft16 algorithm accepts int16 and int32 data the best. However, int data types can lose information since they round to the nearest integer. Thus, we can scale all the inputs to make them larger, thus yielding more accuracy (it is as if we added a few more decimal places).

== IFFT Example Plot ==

This waveform is a 30Hz sine wave superimposed on a 40Hz sine wave with the same amplitude and phase. As one can see, the FFT amplitude line up almost exactly. The phase graph has some discrepancy, but this can be easily fixed by changing the FFT phase vector to float, rather than int16. It is ok to use int16 here because the vector is not being inputted into the mips_fft algorithm. And finally, the inverse FFT matches up very nicely with the original signal, very little information is lost.

[[Image: IFFTwaveforms.png|border|700px]]

File:IFFTwaveforms.png

2010-05-20T18:27:43Z

AndrewDai: uploaded a new version of "Image:IFFTwaveforms.png": Reverted to version as of 18:22, 20 May 2010

File:IFFTwaveforms.png

2010-05-20T18:27:04Z

AndrewDai: uploaded a new version of "Image:IFFTwaveforms.png": Reverted to version as of 18:21, 20 May 2010

File:IFFTwaveforms.png

2010-05-20T18:26:31Z

AndrewDai: uploaded a new version of "Image:IFFTwaveforms.png"

File:IFFTwaveforms.png

2010-05-20T18:22:25Z

AndrewDai: uploaded a new version of "Image:IFFTwaveforms.png"

File:IFFTwaveforms.png

2010-05-20T18:21:35Z

AndrewDai: uploaded a new version of "Image:IFFTwaveforms.png"

PIC32MX: FFT of Analog Input

2010-05-20T17:54:39Z

AndrewDai: /* IFFT Example Plot */

== Overview ==
A fast Fourier transform (FFT) is a method to calculate a discrete Fourier transform (DFT). More information about [http://en.wikipedia.org/wiki/Fast_Fourier_transform FFTs] and [http://en.wikipedia.org/wiki/Discrete_Fourier_transform DFTs] can be found on wikipedia (linked).
The following circuit and code allow a user to put a signal into a PIC32, perform an FFT on that signal, output the data to Matlab via RS-232, and view a plot showing the raw signal, the FFT as calculated by the PIC, and the FFT as calculated by Matlab. Viewing the Matlab calculation is for verification only and can be commented out of the Matlab code.

Commented C code and Matlab code for a FFT are provided in the FFT Code section of this page and can be downloaded [[Media: Lab5FFTcode.zip | here]].

With the PIC32, an inverse FFT can also be computed. Inverse FFT is a function that converts a frequency domain signal into a time domain signal. Inverse FFTs actually use the same algorithm as FFTs except with some scaling and conjugation or time reversal (depending on the algorithm). The second half of this page shows how you can create an analog signal, takes the FFT of that signal, and then take the inverse FFT of the result to try and obtain the original waveform back. The data is all sent to MATLAB via RS232 and compared to MATLAB's computational results for accuracy.

The C code and Matlab code for this program can be downloaded [[Media: IFFTcode.zip | here]].

== FFT Circuit ==

Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

*RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
*RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
*Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection.

[[Image:FftSchematic.png]]

== FFT Code ==
The following is the source code to be programmed onto the PIC. If unfamiliar, see [[HelloWorld_PIC32 | here]] for a guide to creating a .hex file with MPLAB and [[Directions_to_Load_Files_to_PIC32_with_HID_Bootloader | here]] for directions to load files to the PIC. It first establishes inputs, outputs and RS-232 communication. When prompted with a 'p' (as written, it is prompted automatically by Matlab), the PIC computes the FFT then sends the magnitude portion of the single-sided FFT and the raw samples to Matlab.

<pre>
/* Sam Bobb, Daniel Cornew, Ryan Deeter
Fast Fourier Transform (FFT) Example
ME 333, Lab 5
Feb 2010
*/

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include <plib.h>
#include "dsplib_dsp.h"
#include "fftc.h"

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define LOOP_TIME_PIN LATAbits.LATA14

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

// To modify the number of samples:
#define fftc fft16c256 //from fftc.h, for N = 256 use fft16c256, for N = 1024 use fft16c1024
#define N 256 // Also change the log2N variable below!!

// To modify the sampling frequency
#define SAMPLE_FREQ 10000
// Also change the timer interupt setup in initInterruptController!

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void computeFFT(void); //sets up function to compute FFT

/** Global Variables *******************************************/

int computeFFTflag = FALSE; //used to indicate that an fft computation has been requested over rs232

int sampleIndex = 0; //keeps track of where we're putting our ADC reading

/** establish variables for FFT calculation*/
// -----
// this has to be changed for different values of N
int log2N = 8; // log2(256) = 8
//int log2N = 10; // log2(1024) = 10
// -----

int16c sampleBuffer[N]; //initialize buffer to collect samples
int16c calcBuffer[N]; // initialize buffer to hold old samples
int16c scratch[N];
int16c dout[N]; //holds computed FFT until transmission

long int singleSidedFFT[N];
long int freqVector[N];

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;

// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);

TRISAbits.TRISA14 = 0;

// Allow vector interrupts
INTEnableSystemMultiVectoredInt();

mInitAllLEDs();

initInterruptController();

initUART2(pbClk);

// Configure the proper PB frequency and the number of wait states
SYSTEMConfigPerformance(SYS_FREQ);

// -------- Set Up ADC --------
// configure and enable the ADC
CloseADC10(); // ensure the ADC is off before setting the configuration

// define setup parameters for OpenADC10
// Turn module on | output in integer | trigger mode auto | enable autosample
#define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG16 | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON

// define setup parameters for OpenADC10
// ADC ref external | disable offset test | enable scan mode | perform 2 samples | use one buffer | use MUXA mode
#define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_2 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF

// define setup parameters for OpenADC10
// use ADC internal clock | set sample time
#define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_15

// define setup parameters for OpenADC10
// set AN4
#define PARAM4 ENABLE_AN4_ANA

// define setup parameters for OpenADC10
// do not assign channels to scan
#define PARAM5 SKIP_SCAN_AN0 | SKIP_SCAN_AN1 | SKIP_SCAN_AN2 | SKIP_SCAN_AN3 | SKIP_SCAN_AN5 | SKIP_SCAN_AN6 | SKIP_SCAN_AN7 | SKIP_SCAN_AN8 | SKIP_SCAN_AN9 | SKIP_SCAN_AN10 | SKIP_SCAN_AN11 | SKIP_SCAN_AN12 | SKIP_SCAN_AN13 | SKIP_SCAN_AN14 | SKIP_SCAN_AN15

// use ground as neg ref for A | use AN4 (B4) for input A
// configure to sample AN4
SetChanADC10( ADC_CH0_NEG_SAMPLEA_NVREF); // configure to sample AN4
OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4, PARAM5 ); // configure ADC using parameter define above

EnableADC10(); // Enable the ADC

while ( ! mAD1GetIntFlag() ) { } // wait for the first conversion to complete so there will be valid data in ADC result registers
// ------ DONE SETTING UP ADC ------

// zero the freqVector and singleSidedFFT
for (i=0; i<N; i++)
{
freqVector[i] = 0;
singleSidedFFT[i] = 0;
}

// generate frequency vector
// this is the x-axis of your single sided fft
for (i=0; i<N/2; i++)
{
freqVector[i] = i*(SAMPLE_FREQ/2)/((N/2) - 1);
}

// wait around until you get an fft command from rs232
// then call computeFFT to generate an fft of the last block of samples
// then send out rs232.
// If you want to use FFT without rs232, you can call computeFFT when ever you want in your program.
while(1)
{
if (computeFFTflag == TRUE)
{
computeFFT();
sendDataRS232();
}
}

CloseOC1();

} //end main

/** Interrupt Handlers *****************************************/
// interrput code for the timer 3
void __ISR( _TIMER_3_VECTOR, ipl7) T3Interrupt( void)
{
int i;
//LOOP_TIME_PIN = TRUE;
// When we used the loop time pin to measure the length of this ISR,
// we measured 400 ns, so you could sample at over 1 MHz.

sampleBuffer[sampleIndex].re = ReadADC10(0); // read the ADC into the real part of the samplebuffer
sampleBuffer[sampleIndex].im = 0; // the imaginary value is 0.

// you could shave a little time off this ISR by just zeroing the .im value once, outside the ISR

// increment the sampleIndex
if (sampleIndex == (N-1))
{
sampleIndex = 0;
}
else
{
sampleIndex++;
}

//LOOP_TIME_PIN = FALSE;

// clear interrupt flag and exit
mT3ClearIntFlag();
} // T3 Interrupt

// UART 2 interrupt handler
// it is set at priority level 2
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
char data;

// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data = ReadUART2();
// Echo what we just received.
putcUART2(data);

switch(data)
{

case 'p': // compute and output the FFT
computeFFTflag = TRUE;
break;
}

// Toggle LED to indicate UART activity
mLED_0_Toggle();

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initInterruptController(void)
{
// init Timer3 mode and period (PR3)
OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, 0x1F40); // produces 100 ms period
// sampling frequency = 10 kHz

mT3SetIntPriority( 7); // set Timer3 Interrupt Priority
mT3ClearIntFlag(); // clear interrupt flag
mT3IntEnable( 1); // enable timer3 interrupts
}

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void sendDataRS232()
{
int i;
char RS232_Out_Buffer[32]; // max characters per line (line feed and carriage return count)

sprintf(RS232_Out_Buffer,"\n\rSTART\n\r"); //print START. MATLAB uses this as a start delimiter
putsUART2(RS232_Out_Buffer);

sprintf(RS232_Out_Buffer,"ROWS=%d\n\r", N); //print the number of rows, so matlab can make the correct sized buffer
putsUART2(RS232_Out_Buffer);

for(i = 0; i < N; i++)
{
// output: frequency vector, the calculated fft, raw samples
sprintf(RS232_Out_Buffer,"%d %d %d\n\r",freqVector[i], singleSidedFFT[i], calcBuffer[i].re);
putsUART2(RS232_Out_Buffer);
}

sprintf(RS232_Out_Buffer,"END\n\r"); //output end so matlab knows we're done
putsUART2(RS232_Out_Buffer);

}

void computeFFT()
{
// when using 256 samples, we measured this function to take about 500 microseconds
// (not including the time to send rs232 data)
int i;

mT3IntEnable(0); //turns off interrupt while computing FFT

LOOP_TIME_PIN = TRUE;

for (i=0; i<N; i++)
{
if (i<sampleIndex)
{
// old chunk
calcBuffer[i+(N-sampleIndex)] = sampleBuffer[i];
}
else // i >= sampleIndex
{
// new chunk
calcBuffer[i-sampleIndex] = sampleBuffer[i];
}

}

// load complex input data into din
mips_fft16(dout, calcBuffer, fftc, scratch, log2N);

// compute single sided fft
for(i = 0; i < N/2; i++)
{
singleSidedFFT[i] = 2 * ((dout[i].re*dout[i].re) + (dout[i].im*dout[i].im));
}

LOOP_TIME_PIN = FALSE;

computeFFTflag = FALSE;

// do something with dout
mT3IntEnable(1); //turn interrupt back on
}

</pre>

The following Matlab code computes its own FFT with the raw samples. It then plots the input signal, the PIC calculated FFT, and the Matlab calculated FFT, for comparison.

<pre>

% fftserial interface v 2

%Sam Bobb, Daniel Cornew, Ryan Deeter
%ME 333 Lab 5: FFT of Analog Input, Winter 2010

%This code receives the single sided magnitude FFT calculated on the PIC
%and the raw samples through serial communication. Matlab calculates its
%own FFT of the raw samples, then plots the input signal, PIC calculated
%FFT, and Matlab calculated FFT.

Fs = 10000; % Sampling frequency
T = 1/Fs; % Sample time
L = 256; % Length of signal
t = (0:L-1)*T; % Time vector

%for runtimes=1:100 %UNCOMMENT FOR CONTINUOUS FFT

columns = 3;

%check if the serial port already exists
%if it does, close it, it probably means something bad happened last run
if exist('COM','var')
disp('closing old port instance');
fclose(COM)
delete(COM)
clear COM
disp('port closed');
end

% open the serial port
COM = serial('COM6');
set(COM,'BaudRate',19200);
fopen(COM)

disp('port opened');

% send the command to print data
fprintf(COM,'p')

%there's usually some garbage at the beginning (like the echoed p
%character command and line breaks); this reads lines in until we find
%the start line
text = fscanf(COM, '%s');
while isempty(strfind(text, 'START'))
text = fscanf(COM, '%s');
end

% read number of rows
rowstext = fscanf(COM, '%s');
pat = 'ROWS=';
split = regexp(rowstext, pat, 'split');
rows = str2double(split(2));

DATA = zeros(rows,columns);

%generate the fscanf format argument
%repeate the formatchar character for the number of columns
formatchar = '%d';
serialpat = '';

%establishing fscanf format
for j = 1:columns
serialpat = [serialpat ' ' formatchar];
end

%reads serial data and puts it into DATA
for j = 1:rows
DATA(j, :) = fscanf(COM, serialpat, [columns 1]);
%disp(COM.BytesAvailable)

end

%reads last line
last = fscanf(COM, '%s');

%verifies that last line read is the last line
if strcmp(last,'END')
disp('Success')
else
disp('Problem')
end

%disp(COM.BytesAvailable) %for debugging

%plotting input signal
subplot(3, 1, 1)
plot(DATA(:,3))
title('Time Domain Signal')

%plotting PIC calculated FFT
subplot(3, 1, 2)
plot(DATA(:,1), DATA(:,2))
title('Single Sided FFT Calculated on the PIC')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')
axis([0 Fs/2 0 2e5])

%calculating FFT in Matlab
NFFT = 2^nextpow2(L); % Next power of 2 from length of y
Y = fft(DATA(:,3),NFFT)/L;

%Y = DATA(:,1) + DATA(:,2)*1i;

f = Fs/2*linspace(0,1,NFFT/2+1);

% Plot Matlab's single-sided amplitude spectrum.
subplot(3, 1, 3)
plot(f,2*abs(Y(1:NFFT/2+1)))
title('Single Sided FFT Calculated with MATLAB')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')

%pause(2) %UNCOMMENT FOR CONTINOUS FFT

%end %UNCOMMENT FOR CONTINUOUS FFT

%closes serial port
fclose(COM)
delete(COM)
clear COM
disp('port closed');

</pre>

==FFT Example Plots==
Here is an example using a 500 Hz sine wave input.
[[Image: FFT_500_sin.jpg|border|700px]]

This example uses a 1 kHz sine wave.
[[Image: FFT_1K_sin.jpg|border|700px]]

This example is still at 1 kHz, but with a square wave.
[[Image: FFT_1K_square.jpg|border|700px]]

This example shows a 2 kHz sine wave.
[[Image: FFT_2K_sin.jpg|border|700px]]

This example, still at 2 kHz, is a square wave.
[[Image: FFT_2K_square.jpg|border|700px]]

The final example is a 3 kHz sine wave.
[[Image: FFT_3K_sin.jpg|border|700px]]

== IFFT Circuit ==

This circuit is very similar to the preview FFT circuit, except that it includes a low pass filter. This filter integrates the PWM signal that is output from pin D0 and creates a continuous, analog signal.

[[Image:IFftSchematic.png|border|700px]]

== IFFT Code ==

The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]]. The code is very similar to the code found above. There are two main differences:

1. There is now an "analog output." This is basically a PWM that is filtered through a low pass filter. The pulse widths are modified very quickly, with the width of the pulse directly related to the amplitude of the output. Thus, a very short pulse is the same as the trough of the sine wave and a long pulse is the same as the peak of the wave.

2. This is more of a tip, but after the analog inputs are stored in the sample array, they are scaled up by a factor, in this case, 256. All this does is increase the range of the values. I found this to give results that align much better with MATLAB's results. The reason for this is that the mips_fft16 algorithm accepts int16 and int32 data the best. However, int data types can lose information since they round to the nearest integer. Thus, we can scale all the inputs to make them larger, thus yielding more accuracy (it is as if we added a few more decimal places).

== IFFT Example Plot ==

This waveform is a 30Hz sine wave superimposed on a 40Hz sine wave with the same amplitude and phase. As one can see, the FFT amplitude line up almost exactly. The phase graph has some discrepancy, but this can be easily fixed by changing the FFT phase vector to float, rather than int16. It is ok to use int16 here because the vector is not being inputted into the mips_fft algorithm. And finally, the inverse FFT matches up very nicely with the original signal, very little information is lost.

[[Image: IFFTwaveforms.png|border|700px]]

PIC32MX: FFT of Analog Input

2010-05-20T17:54:23Z

AndrewDai: /* IFFT Code */

== Overview ==
A fast Fourier transform (FFT) is a method to calculate a discrete Fourier transform (DFT). More information about [http://en.wikipedia.org/wiki/Fast_Fourier_transform FFTs] and [http://en.wikipedia.org/wiki/Discrete_Fourier_transform DFTs] can be found on wikipedia (linked).
The following circuit and code allow a user to put a signal into a PIC32, perform an FFT on that signal, output the data to Matlab via RS-232, and view a plot showing the raw signal, the FFT as calculated by the PIC, and the FFT as calculated by Matlab. Viewing the Matlab calculation is for verification only and can be commented out of the Matlab code.

Commented C code and Matlab code for a FFT are provided in the FFT Code section of this page and can be downloaded [[Media: Lab5FFTcode.zip | here]].

With the PIC32, an inverse FFT can also be computed. Inverse FFT is a function that converts a frequency domain signal into a time domain signal. Inverse FFTs actually use the same algorithm as FFTs except with some scaling and conjugation or time reversal (depending on the algorithm). The second half of this page shows how you can create an analog signal, takes the FFT of that signal, and then take the inverse FFT of the result to try and obtain the original waveform back. The data is all sent to MATLAB via RS232 and compared to MATLAB's computational results for accuracy.

The C code and Matlab code for this program can be downloaded [[Media: IFFTcode.zip | here]].

== FFT Circuit ==

Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

*RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
*RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
*Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection.

[[Image:FftSchematic.png]]

== FFT Code ==
The following is the source code to be programmed onto the PIC. If unfamiliar, see [[HelloWorld_PIC32 | here]] for a guide to creating a .hex file with MPLAB and [[Directions_to_Load_Files_to_PIC32_with_HID_Bootloader | here]] for directions to load files to the PIC. It first establishes inputs, outputs and RS-232 communication. When prompted with a 'p' (as written, it is prompted automatically by Matlab), the PIC computes the FFT then sends the magnitude portion of the single-sided FFT and the raw samples to Matlab.

<pre>
/* Sam Bobb, Daniel Cornew, Ryan Deeter
Fast Fourier Transform (FFT) Example
ME 333, Lab 5
Feb 2010
*/

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include <plib.h>
#include "dsplib_dsp.h"
#include "fftc.h"

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define LOOP_TIME_PIN LATAbits.LATA14

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

// To modify the number of samples:
#define fftc fft16c256 //from fftc.h, for N = 256 use fft16c256, for N = 1024 use fft16c1024
#define N 256 // Also change the log2N variable below!!

// To modify the sampling frequency
#define SAMPLE_FREQ 10000
// Also change the timer interupt setup in initInterruptController!

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void computeFFT(void); //sets up function to compute FFT

/** Global Variables *******************************************/

int computeFFTflag = FALSE; //used to indicate that an fft computation has been requested over rs232

int sampleIndex = 0; //keeps track of where we're putting our ADC reading

/** establish variables for FFT calculation*/
// -----
// this has to be changed for different values of N
int log2N = 8; // log2(256) = 8
//int log2N = 10; // log2(1024) = 10
// -----

int16c sampleBuffer[N]; //initialize buffer to collect samples
int16c calcBuffer[N]; // initialize buffer to hold old samples
int16c scratch[N];
int16c dout[N]; //holds computed FFT until transmission

long int singleSidedFFT[N];
long int freqVector[N];

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;

// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);

TRISAbits.TRISA14 = 0;

// Allow vector interrupts
INTEnableSystemMultiVectoredInt();

mInitAllLEDs();

initInterruptController();

initUART2(pbClk);

// Configure the proper PB frequency and the number of wait states
SYSTEMConfigPerformance(SYS_FREQ);

// -------- Set Up ADC --------
// configure and enable the ADC
CloseADC10(); // ensure the ADC is off before setting the configuration

// define setup parameters for OpenADC10
// Turn module on | output in integer | trigger mode auto | enable autosample
#define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG16 | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON

// define setup parameters for OpenADC10
// ADC ref external | disable offset test | enable scan mode | perform 2 samples | use one buffer | use MUXA mode
#define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_2 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF

// define setup parameters for OpenADC10
// use ADC internal clock | set sample time
#define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_15

// define setup parameters for OpenADC10
// set AN4
#define PARAM4 ENABLE_AN4_ANA

// define setup parameters for OpenADC10
// do not assign channels to scan
#define PARAM5 SKIP_SCAN_AN0 | SKIP_SCAN_AN1 | SKIP_SCAN_AN2 | SKIP_SCAN_AN3 | SKIP_SCAN_AN5 | SKIP_SCAN_AN6 | SKIP_SCAN_AN7 | SKIP_SCAN_AN8 | SKIP_SCAN_AN9 | SKIP_SCAN_AN10 | SKIP_SCAN_AN11 | SKIP_SCAN_AN12 | SKIP_SCAN_AN13 | SKIP_SCAN_AN14 | SKIP_SCAN_AN15

// use ground as neg ref for A | use AN4 (B4) for input A
// configure to sample AN4
SetChanADC10( ADC_CH0_NEG_SAMPLEA_NVREF); // configure to sample AN4
OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4, PARAM5 ); // configure ADC using parameter define above

EnableADC10(); // Enable the ADC

while ( ! mAD1GetIntFlag() ) { } // wait for the first conversion to complete so there will be valid data in ADC result registers
// ------ DONE SETTING UP ADC ------

// zero the freqVector and singleSidedFFT
for (i=0; i<N; i++)
{
freqVector[i] = 0;
singleSidedFFT[i] = 0;
}

// generate frequency vector
// this is the x-axis of your single sided fft
for (i=0; i<N/2; i++)
{
freqVector[i] = i*(SAMPLE_FREQ/2)/((N/2) - 1);
}

// wait around until you get an fft command from rs232
// then call computeFFT to generate an fft of the last block of samples
// then send out rs232.
// If you want to use FFT without rs232, you can call computeFFT when ever you want in your program.
while(1)
{
if (computeFFTflag == TRUE)
{
computeFFT();
sendDataRS232();
}
}

CloseOC1();

} //end main

/** Interrupt Handlers *****************************************/
// interrput code for the timer 3
void __ISR( _TIMER_3_VECTOR, ipl7) T3Interrupt( void)
{
int i;
//LOOP_TIME_PIN = TRUE;
// When we used the loop time pin to measure the length of this ISR,
// we measured 400 ns, so you could sample at over 1 MHz.

sampleBuffer[sampleIndex].re = ReadADC10(0); // read the ADC into the real part of the samplebuffer
sampleBuffer[sampleIndex].im = 0; // the imaginary value is 0.

// you could shave a little time off this ISR by just zeroing the .im value once, outside the ISR

// increment the sampleIndex
if (sampleIndex == (N-1))
{
sampleIndex = 0;
}
else
{
sampleIndex++;
}

//LOOP_TIME_PIN = FALSE;

// clear interrupt flag and exit
mT3ClearIntFlag();
} // T3 Interrupt

// UART 2 interrupt handler
// it is set at priority level 2
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
char data;

// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data = ReadUART2();
// Echo what we just received.
putcUART2(data);

switch(data)
{

case 'p': // compute and output the FFT
computeFFTflag = TRUE;
break;
}

// Toggle LED to indicate UART activity
mLED_0_Toggle();

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initInterruptController(void)
{
// init Timer3 mode and period (PR3)
OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, 0x1F40); // produces 100 ms period
// sampling frequency = 10 kHz

mT3SetIntPriority( 7); // set Timer3 Interrupt Priority
mT3ClearIntFlag(); // clear interrupt flag
mT3IntEnable( 1); // enable timer3 interrupts
}

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void sendDataRS232()
{
int i;
char RS232_Out_Buffer[32]; // max characters per line (line feed and carriage return count)

sprintf(RS232_Out_Buffer,"\n\rSTART\n\r"); //print START. MATLAB uses this as a start delimiter
putsUART2(RS232_Out_Buffer);

sprintf(RS232_Out_Buffer,"ROWS=%d\n\r", N); //print the number of rows, so matlab can make the correct sized buffer
putsUART2(RS232_Out_Buffer);

for(i = 0; i < N; i++)
{
// output: frequency vector, the calculated fft, raw samples
sprintf(RS232_Out_Buffer,"%d %d %d\n\r",freqVector[i], singleSidedFFT[i], calcBuffer[i].re);
putsUART2(RS232_Out_Buffer);
}

sprintf(RS232_Out_Buffer,"END\n\r"); //output end so matlab knows we're done
putsUART2(RS232_Out_Buffer);

}

void computeFFT()
{
// when using 256 samples, we measured this function to take about 500 microseconds
// (not including the time to send rs232 data)
int i;

mT3IntEnable(0); //turns off interrupt while computing FFT

LOOP_TIME_PIN = TRUE;

for (i=0; i<N; i++)
{
if (i<sampleIndex)
{
// old chunk
calcBuffer[i+(N-sampleIndex)] = sampleBuffer[i];
}
else // i >= sampleIndex
{
// new chunk
calcBuffer[i-sampleIndex] = sampleBuffer[i];
}

}

// load complex input data into din
mips_fft16(dout, calcBuffer, fftc, scratch, log2N);

// compute single sided fft
for(i = 0; i < N/2; i++)
{
singleSidedFFT[i] = 2 * ((dout[i].re*dout[i].re) + (dout[i].im*dout[i].im));
}

LOOP_TIME_PIN = FALSE;

computeFFTflag = FALSE;

// do something with dout
mT3IntEnable(1); //turn interrupt back on
}

</pre>

The following Matlab code computes its own FFT with the raw samples. It then plots the input signal, the PIC calculated FFT, and the Matlab calculated FFT, for comparison.

<pre>

% fftserial interface v 2

%Sam Bobb, Daniel Cornew, Ryan Deeter
%ME 333 Lab 5: FFT of Analog Input, Winter 2010

%This code receives the single sided magnitude FFT calculated on the PIC
%and the raw samples through serial communication. Matlab calculates its
%own FFT of the raw samples, then plots the input signal, PIC calculated
%FFT, and Matlab calculated FFT.

Fs = 10000; % Sampling frequency
T = 1/Fs; % Sample time
L = 256; % Length of signal
t = (0:L-1)*T; % Time vector

%for runtimes=1:100 %UNCOMMENT FOR CONTINUOUS FFT

columns = 3;

%check if the serial port already exists
%if it does, close it, it probably means something bad happened last run
if exist('COM','var')
disp('closing old port instance');
fclose(COM)
delete(COM)
clear COM
disp('port closed');
end

% open the serial port
COM = serial('COM6');
set(COM,'BaudRate',19200);
fopen(COM)

disp('port opened');

% send the command to print data
fprintf(COM,'p')

%there's usually some garbage at the beginning (like the echoed p
%character command and line breaks); this reads lines in until we find
%the start line
text = fscanf(COM, '%s');
while isempty(strfind(text, 'START'))
text = fscanf(COM, '%s');
end

% read number of rows
rowstext = fscanf(COM, '%s');
pat = 'ROWS=';
split = regexp(rowstext, pat, 'split');
rows = str2double(split(2));

DATA = zeros(rows,columns);

%generate the fscanf format argument
%repeate the formatchar character for the number of columns
formatchar = '%d';
serialpat = '';

%establishing fscanf format
for j = 1:columns
serialpat = [serialpat ' ' formatchar];
end

%reads serial data and puts it into DATA
for j = 1:rows
DATA(j, :) = fscanf(COM, serialpat, [columns 1]);
%disp(COM.BytesAvailable)

end

%reads last line
last = fscanf(COM, '%s');

%verifies that last line read is the last line
if strcmp(last,'END')
disp('Success')
else
disp('Problem')
end

%disp(COM.BytesAvailable) %for debugging

%plotting input signal
subplot(3, 1, 1)
plot(DATA(:,3))
title('Time Domain Signal')

%plotting PIC calculated FFT
subplot(3, 1, 2)
plot(DATA(:,1), DATA(:,2))
title('Single Sided FFT Calculated on the PIC')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')
axis([0 Fs/2 0 2e5])

%calculating FFT in Matlab
NFFT = 2^nextpow2(L); % Next power of 2 from length of y
Y = fft(DATA(:,3),NFFT)/L;

%Y = DATA(:,1) + DATA(:,2)*1i;

f = Fs/2*linspace(0,1,NFFT/2+1);

% Plot Matlab's single-sided amplitude spectrum.
subplot(3, 1, 3)
plot(f,2*abs(Y(1:NFFT/2+1)))
title('Single Sided FFT Calculated with MATLAB')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')

%pause(2) %UNCOMMENT FOR CONTINOUS FFT

%end %UNCOMMENT FOR CONTINUOUS FFT

%closes serial port
fclose(COM)
delete(COM)
clear COM
disp('port closed');

</pre>

==FFT Example Plots==
Here is an example using a 500 Hz sine wave input.
[[Image: FFT_500_sin.jpg|border|700px]]

This example uses a 1 kHz sine wave.
[[Image: FFT_1K_sin.jpg|border|700px]]

This example is still at 1 kHz, but with a square wave.
[[Image: FFT_1K_square.jpg|border|700px]]

This example shows a 2 kHz sine wave.
[[Image: FFT_2K_sin.jpg|border|700px]]

This example, still at 2 kHz, is a square wave.
[[Image: FFT_2K_square.jpg|border|700px]]

The final example is a 3 kHz sine wave.
[[Image: FFT_3K_sin.jpg|border|700px]]

== IFFT Circuit ==

This circuit is very similar to the preview FFT circuit, except that it includes a low pass filter. This filter integrates the PWM signal that is output from pin D0 and creates a continuous, analog signal.

[[Image:IFftSchematic.png|border|700px]]

== IFFT Code ==

The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]]. The code is very similar to the code found above. There are two main differences:

1. There is now an "analog output." This is basically a PWM that is filtered through a low pass filter. The pulse widths are modified very quickly, with the width of the pulse directly related to the amplitude of the output. Thus, a very short pulse is the same as the trough of the sine wave and a long pulse is the same as the peak of the wave.

2. This is more of a tip, but after the analog inputs are stored in the sample array, they are scaled up by a factor, in this case, 256. All this does is increase the range of the values. I found this to give results that align much better with MATLAB's results. The reason for this is that the mips_fft16 algorithm accepts int16 and int32 data the best. However, int data types can lose information since they round to the nearest integer. Thus, we can scale all the inputs to make them larger, thus yielding more accuracy (it is as if we added a few more decimal places).

== IFFT Example Plot ==

PIC32MX: FFT of Analog Input

2010-05-20T17:53:41Z

AndrewDai: /* IFFT Circuit */

== Overview ==
A fast Fourier transform (FFT) is a method to calculate a discrete Fourier transform (DFT). More information about [http://en.wikipedia.org/wiki/Fast_Fourier_transform FFTs] and [http://en.wikipedia.org/wiki/Discrete_Fourier_transform DFTs] can be found on wikipedia (linked).
The following circuit and code allow a user to put a signal into a PIC32, perform an FFT on that signal, output the data to Matlab via RS-232, and view a plot showing the raw signal, the FFT as calculated by the PIC, and the FFT as calculated by Matlab. Viewing the Matlab calculation is for verification only and can be commented out of the Matlab code.

Commented C code and Matlab code for a FFT are provided in the FFT Code section of this page and can be downloaded [[Media: Lab5FFTcode.zip | here]].

With the PIC32, an inverse FFT can also be computed. Inverse FFT is a function that converts a frequency domain signal into a time domain signal. Inverse FFTs actually use the same algorithm as FFTs except with some scaling and conjugation or time reversal (depending on the algorithm). The second half of this page shows how you can create an analog signal, takes the FFT of that signal, and then take the inverse FFT of the result to try and obtain the original waveform back. The data is all sent to MATLAB via RS232 and compared to MATLAB's computational results for accuracy.

The C code and Matlab code for this program can be downloaded [[Media: IFFTcode.zip | here]].

== FFT Circuit ==

Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

*RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
*RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
*Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection.

[[Image:FftSchematic.png]]

== FFT Code ==
The following is the source code to be programmed onto the PIC. If unfamiliar, see [[HelloWorld_PIC32 | here]] for a guide to creating a .hex file with MPLAB and [[Directions_to_Load_Files_to_PIC32_with_HID_Bootloader | here]] for directions to load files to the PIC. It first establishes inputs, outputs and RS-232 communication. When prompted with a 'p' (as written, it is prompted automatically by Matlab), the PIC computes the FFT then sends the magnitude portion of the single-sided FFT and the raw samples to Matlab.

<pre>
/* Sam Bobb, Daniel Cornew, Ryan Deeter
Fast Fourier Transform (FFT) Example
ME 333, Lab 5
Feb 2010
*/

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include <plib.h>
#include "dsplib_dsp.h"
#include "fftc.h"

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define LOOP_TIME_PIN LATAbits.LATA14

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

// To modify the number of samples:
#define fftc fft16c256 //from fftc.h, for N = 256 use fft16c256, for N = 1024 use fft16c1024
#define N 256 // Also change the log2N variable below!!

// To modify the sampling frequency
#define SAMPLE_FREQ 10000
// Also change the timer interupt setup in initInterruptController!

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void computeFFT(void); //sets up function to compute FFT

/** Global Variables *******************************************/

int computeFFTflag = FALSE; //used to indicate that an fft computation has been requested over rs232

int sampleIndex = 0; //keeps track of where we're putting our ADC reading

/** establish variables for FFT calculation*/
// -----
// this has to be changed for different values of N
int log2N = 8; // log2(256) = 8
//int log2N = 10; // log2(1024) = 10
// -----

int16c sampleBuffer[N]; //initialize buffer to collect samples
int16c calcBuffer[N]; // initialize buffer to hold old samples
int16c scratch[N];
int16c dout[N]; //holds computed FFT until transmission

long int singleSidedFFT[N];
long int freqVector[N];

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;

// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);

TRISAbits.TRISA14 = 0;

// Allow vector interrupts
INTEnableSystemMultiVectoredInt();

mInitAllLEDs();

initInterruptController();

initUART2(pbClk);

// Configure the proper PB frequency and the number of wait states
SYSTEMConfigPerformance(SYS_FREQ);

// -------- Set Up ADC --------
// configure and enable the ADC
CloseADC10(); // ensure the ADC is off before setting the configuration

// define setup parameters for OpenADC10
// Turn module on | output in integer | trigger mode auto | enable autosample
#define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG16 | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON

// define setup parameters for OpenADC10
// ADC ref external | disable offset test | enable scan mode | perform 2 samples | use one buffer | use MUXA mode
#define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_2 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF

// define setup parameters for OpenADC10
// use ADC internal clock | set sample time
#define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_15

// define setup parameters for OpenADC10
// set AN4
#define PARAM4 ENABLE_AN4_ANA

// define setup parameters for OpenADC10
// do not assign channels to scan
#define PARAM5 SKIP_SCAN_AN0 | SKIP_SCAN_AN1 | SKIP_SCAN_AN2 | SKIP_SCAN_AN3 | SKIP_SCAN_AN5 | SKIP_SCAN_AN6 | SKIP_SCAN_AN7 | SKIP_SCAN_AN8 | SKIP_SCAN_AN9 | SKIP_SCAN_AN10 | SKIP_SCAN_AN11 | SKIP_SCAN_AN12 | SKIP_SCAN_AN13 | SKIP_SCAN_AN14 | SKIP_SCAN_AN15

// use ground as neg ref for A | use AN4 (B4) for input A
// configure to sample AN4
SetChanADC10( ADC_CH0_NEG_SAMPLEA_NVREF); // configure to sample AN4
OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4, PARAM5 ); // configure ADC using parameter define above

EnableADC10(); // Enable the ADC

while ( ! mAD1GetIntFlag() ) { } // wait for the first conversion to complete so there will be valid data in ADC result registers
// ------ DONE SETTING UP ADC ------

// zero the freqVector and singleSidedFFT
for (i=0; i<N; i++)
{
freqVector[i] = 0;
singleSidedFFT[i] = 0;
}

// generate frequency vector
// this is the x-axis of your single sided fft
for (i=0; i<N/2; i++)
{
freqVector[i] = i*(SAMPLE_FREQ/2)/((N/2) - 1);
}

// wait around until you get an fft command from rs232
// then call computeFFT to generate an fft of the last block of samples
// then send out rs232.
// If you want to use FFT without rs232, you can call computeFFT when ever you want in your program.
while(1)
{
if (computeFFTflag == TRUE)
{
computeFFT();
sendDataRS232();
}
}

CloseOC1();

} //end main

/** Interrupt Handlers *****************************************/
// interrput code for the timer 3
void __ISR( _TIMER_3_VECTOR, ipl7) T3Interrupt( void)
{
int i;
//LOOP_TIME_PIN = TRUE;
// When we used the loop time pin to measure the length of this ISR,
// we measured 400 ns, so you could sample at over 1 MHz.

sampleBuffer[sampleIndex].re = ReadADC10(0); // read the ADC into the real part of the samplebuffer
sampleBuffer[sampleIndex].im = 0; // the imaginary value is 0.

// you could shave a little time off this ISR by just zeroing the .im value once, outside the ISR

// increment the sampleIndex
if (sampleIndex == (N-1))
{
sampleIndex = 0;
}
else
{
sampleIndex++;
}

//LOOP_TIME_PIN = FALSE;

// clear interrupt flag and exit
mT3ClearIntFlag();
} // T3 Interrupt

// UART 2 interrupt handler
// it is set at priority level 2
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
char data;

// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data = ReadUART2();
// Echo what we just received.
putcUART2(data);

switch(data)
{

case 'p': // compute and output the FFT
computeFFTflag = TRUE;
break;
}

// Toggle LED to indicate UART activity
mLED_0_Toggle();

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initInterruptController(void)
{
// init Timer3 mode and period (PR3)
OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, 0x1F40); // produces 100 ms period
// sampling frequency = 10 kHz

mT3SetIntPriority( 7); // set Timer3 Interrupt Priority
mT3ClearIntFlag(); // clear interrupt flag
mT3IntEnable( 1); // enable timer3 interrupts
}

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void sendDataRS232()
{
int i;
char RS232_Out_Buffer[32]; // max characters per line (line feed and carriage return count)

sprintf(RS232_Out_Buffer,"\n\rSTART\n\r"); //print START. MATLAB uses this as a start delimiter
putsUART2(RS232_Out_Buffer);

sprintf(RS232_Out_Buffer,"ROWS=%d\n\r", N); //print the number of rows, so matlab can make the correct sized buffer
putsUART2(RS232_Out_Buffer);

for(i = 0; i < N; i++)
{
// output: frequency vector, the calculated fft, raw samples
sprintf(RS232_Out_Buffer,"%d %d %d\n\r",freqVector[i], singleSidedFFT[i], calcBuffer[i].re);
putsUART2(RS232_Out_Buffer);
}

sprintf(RS232_Out_Buffer,"END\n\r"); //output end so matlab knows we're done
putsUART2(RS232_Out_Buffer);

}

void computeFFT()
{
// when using 256 samples, we measured this function to take about 500 microseconds
// (not including the time to send rs232 data)
int i;

mT3IntEnable(0); //turns off interrupt while computing FFT

LOOP_TIME_PIN = TRUE;

for (i=0; i<N; i++)
{
if (i<sampleIndex)
{
// old chunk
calcBuffer[i+(N-sampleIndex)] = sampleBuffer[i];
}
else // i >= sampleIndex
{
// new chunk
calcBuffer[i-sampleIndex] = sampleBuffer[i];
}

}

// load complex input data into din
mips_fft16(dout, calcBuffer, fftc, scratch, log2N);

// compute single sided fft
for(i = 0; i < N/2; i++)
{
singleSidedFFT[i] = 2 * ((dout[i].re*dout[i].re) + (dout[i].im*dout[i].im));
}

LOOP_TIME_PIN = FALSE;

computeFFTflag = FALSE;

// do something with dout
mT3IntEnable(1); //turn interrupt back on
}

</pre>

The following Matlab code computes its own FFT with the raw samples. It then plots the input signal, the PIC calculated FFT, and the Matlab calculated FFT, for comparison.

<pre>

% fftserial interface v 2

%Sam Bobb, Daniel Cornew, Ryan Deeter
%ME 333 Lab 5: FFT of Analog Input, Winter 2010

%This code receives the single sided magnitude FFT calculated on the PIC
%and the raw samples through serial communication. Matlab calculates its
%own FFT of the raw samples, then plots the input signal, PIC calculated
%FFT, and Matlab calculated FFT.

Fs = 10000; % Sampling frequency
T = 1/Fs; % Sample time
L = 256; % Length of signal
t = (0:L-1)*T; % Time vector

%for runtimes=1:100 %UNCOMMENT FOR CONTINUOUS FFT

columns = 3;

%check if the serial port already exists
%if it does, close it, it probably means something bad happened last run
if exist('COM','var')
disp('closing old port instance');
fclose(COM)
delete(COM)
clear COM
disp('port closed');
end

% open the serial port
COM = serial('COM6');
set(COM,'BaudRate',19200);
fopen(COM)

disp('port opened');

% send the command to print data
fprintf(COM,'p')

%there's usually some garbage at the beginning (like the echoed p
%character command and line breaks); this reads lines in until we find
%the start line
text = fscanf(COM, '%s');
while isempty(strfind(text, 'START'))
text = fscanf(COM, '%s');
end

% read number of rows
rowstext = fscanf(COM, '%s');
pat = 'ROWS=';
split = regexp(rowstext, pat, 'split');
rows = str2double(split(2));

DATA = zeros(rows,columns);

%generate the fscanf format argument
%repeate the formatchar character for the number of columns
formatchar = '%d';
serialpat = '';

%establishing fscanf format
for j = 1:columns
serialpat = [serialpat ' ' formatchar];
end

%reads serial data and puts it into DATA
for j = 1:rows
DATA(j, :) = fscanf(COM, serialpat, [columns 1]);
%disp(COM.BytesAvailable)

end

%reads last line
last = fscanf(COM, '%s');

%verifies that last line read is the last line
if strcmp(last,'END')
disp('Success')
else
disp('Problem')
end

%disp(COM.BytesAvailable) %for debugging

%plotting input signal
subplot(3, 1, 1)
plot(DATA(:,3))
title('Time Domain Signal')

%plotting PIC calculated FFT
subplot(3, 1, 2)
plot(DATA(:,1), DATA(:,2))
title('Single Sided FFT Calculated on the PIC')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')
axis([0 Fs/2 0 2e5])

%calculating FFT in Matlab
NFFT = 2^nextpow2(L); % Next power of 2 from length of y
Y = fft(DATA(:,3),NFFT)/L;

%Y = DATA(:,1) + DATA(:,2)*1i;

f = Fs/2*linspace(0,1,NFFT/2+1);

% Plot Matlab's single-sided amplitude spectrum.
subplot(3, 1, 3)
plot(f,2*abs(Y(1:NFFT/2+1)))
title('Single Sided FFT Calculated with MATLAB')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')

%pause(2) %UNCOMMENT FOR CONTINOUS FFT

%end %UNCOMMENT FOR CONTINUOUS FFT

%closes serial port
fclose(COM)
delete(COM)
clear COM
disp('port closed');

</pre>

==FFT Example Plots==
Here is an example using a 500 Hz sine wave input.
[[Image: FFT_500_sin.jpg|border|700px]]

This example uses a 1 kHz sine wave.
[[Image: FFT_1K_sin.jpg|border|700px]]

This example is still at 1 kHz, but with a square wave.
[[Image: FFT_1K_square.jpg|border|700px]]

This example shows a 2 kHz sine wave.
[[Image: FFT_2K_sin.jpg|border|700px]]

This example, still at 2 kHz, is a square wave.
[[Image: FFT_2K_square.jpg|border|700px]]

The final example is a 3 kHz sine wave.
[[Image: FFT_3K_sin.jpg|border|700px]]

== IFFT Circuit ==

This circuit is very similar to the preview FFT circuit, except that it includes a low pass filter. This filter integrates the PWM signal that is output from pin D0 and creates a continuous, analog signal.

[[Image:IFftSchematic.png|border|700px]]

== IFFT Code ==

== IFFT Example Plot ==

PIC32MX: FFT of Analog Input

2010-05-20T17:50:06Z

AndrewDai: /* Overview */

== Overview ==
A fast Fourier transform (FFT) is a method to calculate a discrete Fourier transform (DFT). More information about [http://en.wikipedia.org/wiki/Fast_Fourier_transform FFTs] and [http://en.wikipedia.org/wiki/Discrete_Fourier_transform DFTs] can be found on wikipedia (linked).
The following circuit and code allow a user to put a signal into a PIC32, perform an FFT on that signal, output the data to Matlab via RS-232, and view a plot showing the raw signal, the FFT as calculated by the PIC, and the FFT as calculated by Matlab. Viewing the Matlab calculation is for verification only and can be commented out of the Matlab code.

Commented C code and Matlab code for a FFT are provided in the FFT Code section of this page and can be downloaded [[Media: Lab5FFTcode.zip | here]].

With the PIC32, an inverse FFT can also be computed. Inverse FFT is a function that converts a frequency domain signal into a time domain signal. Inverse FFTs actually use the same algorithm as FFTs except with some scaling and conjugation or time reversal (depending on the algorithm). The second half of this page shows how you can create an analog signal, takes the FFT of that signal, and then take the inverse FFT of the result to try and obtain the original waveform back. The data is all sent to MATLAB via RS232 and compared to MATLAB's computational results for accuracy.

The C code and Matlab code for this program can be downloaded [[Media: IFFTcode.zip | here]].

== FFT Circuit ==

Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

*RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
*RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
*Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection.

[[Image:FftSchematic.png]]

== FFT Code ==
The following is the source code to be programmed onto the PIC. If unfamiliar, see [[HelloWorld_PIC32 | here]] for a guide to creating a .hex file with MPLAB and [[Directions_to_Load_Files_to_PIC32_with_HID_Bootloader | here]] for directions to load files to the PIC. It first establishes inputs, outputs and RS-232 communication. When prompted with a 'p' (as written, it is prompted automatically by Matlab), the PIC computes the FFT then sends the magnitude portion of the single-sided FFT and the raw samples to Matlab.

<pre>
/* Sam Bobb, Daniel Cornew, Ryan Deeter
Fast Fourier Transform (FFT) Example
ME 333, Lab 5
Feb 2010
*/

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include <plib.h>
#include "dsplib_dsp.h"
#include "fftc.h"

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define LOOP_TIME_PIN LATAbits.LATA14

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

// To modify the number of samples:
#define fftc fft16c256 //from fftc.h, for N = 256 use fft16c256, for N = 1024 use fft16c1024
#define N 256 // Also change the log2N variable below!!

// To modify the sampling frequency
#define SAMPLE_FREQ 10000
// Also change the timer interupt setup in initInterruptController!

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void computeFFT(void); //sets up function to compute FFT

/** Global Variables *******************************************/

int computeFFTflag = FALSE; //used to indicate that an fft computation has been requested over rs232

int sampleIndex = 0; //keeps track of where we're putting our ADC reading

/** establish variables for FFT calculation*/
// -----
// this has to be changed for different values of N
int log2N = 8; // log2(256) = 8
//int log2N = 10; // log2(1024) = 10
// -----

int16c sampleBuffer[N]; //initialize buffer to collect samples
int16c calcBuffer[N]; // initialize buffer to hold old samples
int16c scratch[N];
int16c dout[N]; //holds computed FFT until transmission

long int singleSidedFFT[N];
long int freqVector[N];

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;

// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);

TRISAbits.TRISA14 = 0;

// Allow vector interrupts
INTEnableSystemMultiVectoredInt();

mInitAllLEDs();

initInterruptController();

initUART2(pbClk);

// Configure the proper PB frequency and the number of wait states
SYSTEMConfigPerformance(SYS_FREQ);

// -------- Set Up ADC --------
// configure and enable the ADC
CloseADC10(); // ensure the ADC is off before setting the configuration

// define setup parameters for OpenADC10
// Turn module on | output in integer | trigger mode auto | enable autosample
#define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG16 | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON

// define setup parameters for OpenADC10
// ADC ref external | disable offset test | enable scan mode | perform 2 samples | use one buffer | use MUXA mode
#define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_2 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF

// define setup parameters for OpenADC10
// use ADC internal clock | set sample time
#define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_15

// define setup parameters for OpenADC10
// set AN4
#define PARAM4 ENABLE_AN4_ANA

// define setup parameters for OpenADC10
// do not assign channels to scan
#define PARAM5 SKIP_SCAN_AN0 | SKIP_SCAN_AN1 | SKIP_SCAN_AN2 | SKIP_SCAN_AN3 | SKIP_SCAN_AN5 | SKIP_SCAN_AN6 | SKIP_SCAN_AN7 | SKIP_SCAN_AN8 | SKIP_SCAN_AN9 | SKIP_SCAN_AN10 | SKIP_SCAN_AN11 | SKIP_SCAN_AN12 | SKIP_SCAN_AN13 | SKIP_SCAN_AN14 | SKIP_SCAN_AN15

// use ground as neg ref for A | use AN4 (B4) for input A
// configure to sample AN4
SetChanADC10( ADC_CH0_NEG_SAMPLEA_NVREF); // configure to sample AN4
OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4, PARAM5 ); // configure ADC using parameter define above

EnableADC10(); // Enable the ADC

while ( ! mAD1GetIntFlag() ) { } // wait for the first conversion to complete so there will be valid data in ADC result registers
// ------ DONE SETTING UP ADC ------

// zero the freqVector and singleSidedFFT
for (i=0; i<N; i++)
{
freqVector[i] = 0;
singleSidedFFT[i] = 0;
}

// generate frequency vector
// this is the x-axis of your single sided fft
for (i=0; i<N/2; i++)
{
freqVector[i] = i*(SAMPLE_FREQ/2)/((N/2) - 1);
}

// wait around until you get an fft command from rs232
// then call computeFFT to generate an fft of the last block of samples
// then send out rs232.
// If you want to use FFT without rs232, you can call computeFFT when ever you want in your program.
while(1)
{
if (computeFFTflag == TRUE)
{
computeFFT();
sendDataRS232();
}
}

CloseOC1();

} //end main

/** Interrupt Handlers *****************************************/
// interrput code for the timer 3
void __ISR( _TIMER_3_VECTOR, ipl7) T3Interrupt( void)
{
int i;
//LOOP_TIME_PIN = TRUE;
// When we used the loop time pin to measure the length of this ISR,
// we measured 400 ns, so you could sample at over 1 MHz.

sampleBuffer[sampleIndex].re = ReadADC10(0); // read the ADC into the real part of the samplebuffer
sampleBuffer[sampleIndex].im = 0; // the imaginary value is 0.

// you could shave a little time off this ISR by just zeroing the .im value once, outside the ISR

// increment the sampleIndex
if (sampleIndex == (N-1))
{
sampleIndex = 0;
}
else
{
sampleIndex++;
}

//LOOP_TIME_PIN = FALSE;

// clear interrupt flag and exit
mT3ClearIntFlag();
} // T3 Interrupt

// UART 2 interrupt handler
// it is set at priority level 2
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
char data;

// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data = ReadUART2();
// Echo what we just received.
putcUART2(data);

switch(data)
{

case 'p': // compute and output the FFT
computeFFTflag = TRUE;
break;
}

// Toggle LED to indicate UART activity
mLED_0_Toggle();

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initInterruptController(void)
{
// init Timer3 mode and period (PR3)
OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, 0x1F40); // produces 100 ms period
// sampling frequency = 10 kHz

mT3SetIntPriority( 7); // set Timer3 Interrupt Priority
mT3ClearIntFlag(); // clear interrupt flag
mT3IntEnable( 1); // enable timer3 interrupts
}

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void sendDataRS232()
{
int i;
char RS232_Out_Buffer[32]; // max characters per line (line feed and carriage return count)

sprintf(RS232_Out_Buffer,"\n\rSTART\n\r"); //print START. MATLAB uses this as a start delimiter
putsUART2(RS232_Out_Buffer);

sprintf(RS232_Out_Buffer,"ROWS=%d\n\r", N); //print the number of rows, so matlab can make the correct sized buffer
putsUART2(RS232_Out_Buffer);

for(i = 0; i < N; i++)
{
// output: frequency vector, the calculated fft, raw samples
sprintf(RS232_Out_Buffer,"%d %d %d\n\r",freqVector[i], singleSidedFFT[i], calcBuffer[i].re);
putsUART2(RS232_Out_Buffer);
}

sprintf(RS232_Out_Buffer,"END\n\r"); //output end so matlab knows we're done
putsUART2(RS232_Out_Buffer);

}

void computeFFT()
{
// when using 256 samples, we measured this function to take about 500 microseconds
// (not including the time to send rs232 data)
int i;

mT3IntEnable(0); //turns off interrupt while computing FFT

LOOP_TIME_PIN = TRUE;

for (i=0; i<N; i++)
{
if (i<sampleIndex)
{
// old chunk
calcBuffer[i+(N-sampleIndex)] = sampleBuffer[i];
}
else // i >= sampleIndex
{
// new chunk
calcBuffer[i-sampleIndex] = sampleBuffer[i];
}

}

// load complex input data into din
mips_fft16(dout, calcBuffer, fftc, scratch, log2N);

// compute single sided fft
for(i = 0; i < N/2; i++)
{
singleSidedFFT[i] = 2 * ((dout[i].re*dout[i].re) + (dout[i].im*dout[i].im));
}

LOOP_TIME_PIN = FALSE;

computeFFTflag = FALSE;

// do something with dout
mT3IntEnable(1); //turn interrupt back on
}

</pre>

The following Matlab code computes its own FFT with the raw samples. It then plots the input signal, the PIC calculated FFT, and the Matlab calculated FFT, for comparison.

<pre>

% fftserial interface v 2

%Sam Bobb, Daniel Cornew, Ryan Deeter
%ME 333 Lab 5: FFT of Analog Input, Winter 2010

%This code receives the single sided magnitude FFT calculated on the PIC
%and the raw samples through serial communication. Matlab calculates its
%own FFT of the raw samples, then plots the input signal, PIC calculated
%FFT, and Matlab calculated FFT.

Fs = 10000; % Sampling frequency
T = 1/Fs; % Sample time
L = 256; % Length of signal
t = (0:L-1)*T; % Time vector

%for runtimes=1:100 %UNCOMMENT FOR CONTINUOUS FFT

columns = 3;

%check if the serial port already exists
%if it does, close it, it probably means something bad happened last run
if exist('COM','var')
disp('closing old port instance');
fclose(COM)
delete(COM)
clear COM
disp('port closed');
end

% open the serial port
COM = serial('COM6');
set(COM,'BaudRate',19200);
fopen(COM)

disp('port opened');

% send the command to print data
fprintf(COM,'p')

%there's usually some garbage at the beginning (like the echoed p
%character command and line breaks); this reads lines in until we find
%the start line
text = fscanf(COM, '%s');
while isempty(strfind(text, 'START'))
text = fscanf(COM, '%s');
end

% read number of rows
rowstext = fscanf(COM, '%s');
pat = 'ROWS=';
split = regexp(rowstext, pat, 'split');
rows = str2double(split(2));

DATA = zeros(rows,columns);

%generate the fscanf format argument
%repeate the formatchar character for the number of columns
formatchar = '%d';
serialpat = '';

%establishing fscanf format
for j = 1:columns
serialpat = [serialpat ' ' formatchar];
end

%reads serial data and puts it into DATA
for j = 1:rows
DATA(j, :) = fscanf(COM, serialpat, [columns 1]);
%disp(COM.BytesAvailable)

end

%reads last line
last = fscanf(COM, '%s');

%verifies that last line read is the last line
if strcmp(last,'END')
disp('Success')
else
disp('Problem')
end

%disp(COM.BytesAvailable) %for debugging

%plotting input signal
subplot(3, 1, 1)
plot(DATA(:,3))
title('Time Domain Signal')

%plotting PIC calculated FFT
subplot(3, 1, 2)
plot(DATA(:,1), DATA(:,2))
title('Single Sided FFT Calculated on the PIC')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')
axis([0 Fs/2 0 2e5])

%calculating FFT in Matlab
NFFT = 2^nextpow2(L); % Next power of 2 from length of y
Y = fft(DATA(:,3),NFFT)/L;

%Y = DATA(:,1) + DATA(:,2)*1i;

f = Fs/2*linspace(0,1,NFFT/2+1);

% Plot Matlab's single-sided amplitude spectrum.
subplot(3, 1, 3)
plot(f,2*abs(Y(1:NFFT/2+1)))
title('Single Sided FFT Calculated with MATLAB')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')

%pause(2) %UNCOMMENT FOR CONTINOUS FFT

%end %UNCOMMENT FOR CONTINUOUS FFT

%closes serial port
fclose(COM)
delete(COM)
clear COM
disp('port closed');

</pre>

==FFT Example Plots==
Here is an example using a 500 Hz sine wave input.
[[Image: FFT_500_sin.jpg|border|700px]]

This example uses a 1 kHz sine wave.
[[Image: FFT_1K_sin.jpg|border|700px]]

This example is still at 1 kHz, but with a square wave.
[[Image: FFT_1K_square.jpg|border|700px]]

This example shows a 2 kHz sine wave.
[[Image: FFT_2K_sin.jpg|border|700px]]

This example, still at 2 kHz, is a square wave.
[[Image: FFT_2K_square.jpg|border|700px]]

The final example is a 3 kHz sine wave.
[[Image: FFT_3K_sin.jpg|border|700px]]

== IFFT Circuit ==

== IFFT Code ==

== IFFT Example Plot ==

PIC32MX: FFT of Analog Input

2010-05-20T17:46:16Z

AndrewDai:

== Overview ==
A fast Fourier transform (FFT) is a method to calculate a discrete Fourier transform (DFT). More information about [http://en.wikipedia.org/wiki/Fast_Fourier_transform FFTs] and [http://en.wikipedia.org/wiki/Discrete_Fourier_transform DFTs] can be found on wikipedia (linked).
The following circuit and code allow a user to put a signal into a PIC32, perform an FFT on that signal, output the data to Matlab via RS-232, and view a plot showing the raw signal, the FFT as calculated by the PIC, and the FFT as calculated by Matlab. Viewing the Matlab calculation is for verification only and can be commented out of the Matlab code.

Commented C code and Matlab code are provided at the bottom of this page and can be downloaded [[Media: Lab5FFTcode.zip | here]].

== FFT Circuit ==

Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

*RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
*RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
*Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection.

[[Image:FftSchematic.png]]

== FFT Code ==
The following is the source code to be programmed onto the PIC. If unfamiliar, see [[HelloWorld_PIC32 | here]] for a guide to creating a .hex file with MPLAB and [[Directions_to_Load_Files_to_PIC32_with_HID_Bootloader | here]] for directions to load files to the PIC. It first establishes inputs, outputs and RS-232 communication. When prompted with a 'p' (as written, it is prompted automatically by Matlab), the PIC computes the FFT then sends the magnitude portion of the single-sided FFT and the raw samples to Matlab.

<pre>
/* Sam Bobb, Daniel Cornew, Ryan Deeter
Fast Fourier Transform (FFT) Example
ME 333, Lab 5
Feb 2010
*/

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include <plib.h>
#include "dsplib_dsp.h"
#include "fftc.h"

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define LOOP_TIME_PIN LATAbits.LATA14

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

// To modify the number of samples:
#define fftc fft16c256 //from fftc.h, for N = 256 use fft16c256, for N = 1024 use fft16c1024
#define N 256 // Also change the log2N variable below!!

// To modify the sampling frequency
#define SAMPLE_FREQ 10000
// Also change the timer interupt setup in initInterruptController!

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void computeFFT(void); //sets up function to compute FFT

/** Global Variables *******************************************/

int computeFFTflag = FALSE; //used to indicate that an fft computation has been requested over rs232

int sampleIndex = 0; //keeps track of where we're putting our ADC reading

/** establish variables for FFT calculation*/
// -----
// this has to be changed for different values of N
int log2N = 8; // log2(256) = 8
//int log2N = 10; // log2(1024) = 10
// -----

int16c sampleBuffer[N]; //initialize buffer to collect samples
int16c calcBuffer[N]; // initialize buffer to hold old samples
int16c scratch[N];
int16c dout[N]; //holds computed FFT until transmission

long int singleSidedFFT[N];
long int freqVector[N];

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;

// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);

TRISAbits.TRISA14 = 0;

// Allow vector interrupts
INTEnableSystemMultiVectoredInt();

mInitAllLEDs();

initInterruptController();

initUART2(pbClk);

// Configure the proper PB frequency and the number of wait states
SYSTEMConfigPerformance(SYS_FREQ);

// -------- Set Up ADC --------
// configure and enable the ADC
CloseADC10(); // ensure the ADC is off before setting the configuration

// define setup parameters for OpenADC10
// Turn module on | output in integer | trigger mode auto | enable autosample
#define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG16 | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON

// define setup parameters for OpenADC10
// ADC ref external | disable offset test | enable scan mode | perform 2 samples | use one buffer | use MUXA mode
#define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_2 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF

// define setup parameters for OpenADC10
// use ADC internal clock | set sample time
#define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_15

// define setup parameters for OpenADC10
// set AN4
#define PARAM4 ENABLE_AN4_ANA

// define setup parameters for OpenADC10
// do not assign channels to scan
#define PARAM5 SKIP_SCAN_AN0 | SKIP_SCAN_AN1 | SKIP_SCAN_AN2 | SKIP_SCAN_AN3 | SKIP_SCAN_AN5 | SKIP_SCAN_AN6 | SKIP_SCAN_AN7 | SKIP_SCAN_AN8 | SKIP_SCAN_AN9 | SKIP_SCAN_AN10 | SKIP_SCAN_AN11 | SKIP_SCAN_AN12 | SKIP_SCAN_AN13 | SKIP_SCAN_AN14 | SKIP_SCAN_AN15

// use ground as neg ref for A | use AN4 (B4) for input A
// configure to sample AN4
SetChanADC10( ADC_CH0_NEG_SAMPLEA_NVREF); // configure to sample AN4
OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4, PARAM5 ); // configure ADC using parameter define above

EnableADC10(); // Enable the ADC

while ( ! mAD1GetIntFlag() ) { } // wait for the first conversion to complete so there will be valid data in ADC result registers
// ------ DONE SETTING UP ADC ------

// zero the freqVector and singleSidedFFT
for (i=0; i<N; i++)
{
freqVector[i] = 0;
singleSidedFFT[i] = 0;
}

// generate frequency vector
// this is the x-axis of your single sided fft
for (i=0; i<N/2; i++)
{
freqVector[i] = i*(SAMPLE_FREQ/2)/((N/2) - 1);
}

// wait around until you get an fft command from rs232
// then call computeFFT to generate an fft of the last block of samples
// then send out rs232.
// If you want to use FFT without rs232, you can call computeFFT when ever you want in your program.
while(1)
{
if (computeFFTflag == TRUE)
{
computeFFT();
sendDataRS232();
}
}

CloseOC1();

} //end main

/** Interrupt Handlers *****************************************/
// interrput code for the timer 3
void __ISR( _TIMER_3_VECTOR, ipl7) T3Interrupt( void)
{
int i;
//LOOP_TIME_PIN = TRUE;
// When we used the loop time pin to measure the length of this ISR,
// we measured 400 ns, so you could sample at over 1 MHz.

sampleBuffer[sampleIndex].re = ReadADC10(0); // read the ADC into the real part of the samplebuffer
sampleBuffer[sampleIndex].im = 0; // the imaginary value is 0.

// you could shave a little time off this ISR by just zeroing the .im value once, outside the ISR

// increment the sampleIndex
if (sampleIndex == (N-1))
{
sampleIndex = 0;
}
else
{
sampleIndex++;
}

//LOOP_TIME_PIN = FALSE;

// clear interrupt flag and exit
mT3ClearIntFlag();
} // T3 Interrupt

// UART 2 interrupt handler
// it is set at priority level 2
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
char data;

// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data = ReadUART2();
// Echo what we just received.
putcUART2(data);

switch(data)
{

case 'p': // compute and output the FFT
computeFFTflag = TRUE;
break;
}

// Toggle LED to indicate UART activity
mLED_0_Toggle();

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initInterruptController(void)
{
// init Timer3 mode and period (PR3)
OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, 0x1F40); // produces 100 ms period
// sampling frequency = 10 kHz

mT3SetIntPriority( 7); // set Timer3 Interrupt Priority
mT3ClearIntFlag(); // clear interrupt flag
mT3IntEnable( 1); // enable timer3 interrupts
}

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void sendDataRS232()
{
int i;
char RS232_Out_Buffer[32]; // max characters per line (line feed and carriage return count)

sprintf(RS232_Out_Buffer,"\n\rSTART\n\r"); //print START. MATLAB uses this as a start delimiter
putsUART2(RS232_Out_Buffer);

sprintf(RS232_Out_Buffer,"ROWS=%d\n\r", N); //print the number of rows, so matlab can make the correct sized buffer
putsUART2(RS232_Out_Buffer);

for(i = 0; i < N; i++)
{
// output: frequency vector, the calculated fft, raw samples
sprintf(RS232_Out_Buffer,"%d %d %d\n\r",freqVector[i], singleSidedFFT[i], calcBuffer[i].re);
putsUART2(RS232_Out_Buffer);
}

sprintf(RS232_Out_Buffer,"END\n\r"); //output end so matlab knows we're done
putsUART2(RS232_Out_Buffer);

}

void computeFFT()
{
// when using 256 samples, we measured this function to take about 500 microseconds
// (not including the time to send rs232 data)
int i;

mT3IntEnable(0); //turns off interrupt while computing FFT

LOOP_TIME_PIN = TRUE;

for (i=0; i<N; i++)
{
if (i<sampleIndex)
{
// old chunk
calcBuffer[i+(N-sampleIndex)] = sampleBuffer[i];
}
else // i >= sampleIndex
{
// new chunk
calcBuffer[i-sampleIndex] = sampleBuffer[i];
}

}

// load complex input data into din
mips_fft16(dout, calcBuffer, fftc, scratch, log2N);

// compute single sided fft
for(i = 0; i < N/2; i++)
{
singleSidedFFT[i] = 2 * ((dout[i].re*dout[i].re) + (dout[i].im*dout[i].im));
}

LOOP_TIME_PIN = FALSE;

computeFFTflag = FALSE;

// do something with dout
mT3IntEnable(1); //turn interrupt back on
}

</pre>

The following Matlab code computes its own FFT with the raw samples. It then plots the input signal, the PIC calculated FFT, and the Matlab calculated FFT, for comparison.

<pre>

% fftserial interface v 2

%Sam Bobb, Daniel Cornew, Ryan Deeter
%ME 333 Lab 5: FFT of Analog Input, Winter 2010

%This code receives the single sided magnitude FFT calculated on the PIC
%and the raw samples through serial communication. Matlab calculates its
%own FFT of the raw samples, then plots the input signal, PIC calculated
%FFT, and Matlab calculated FFT.

Fs = 10000; % Sampling frequency
T = 1/Fs; % Sample time
L = 256; % Length of signal
t = (0:L-1)*T; % Time vector

%for runtimes=1:100 %UNCOMMENT FOR CONTINUOUS FFT

columns = 3;

%check if the serial port already exists
%if it does, close it, it probably means something bad happened last run
if exist('COM','var')
disp('closing old port instance');
fclose(COM)
delete(COM)
clear COM
disp('port closed');
end

% open the serial port
COM = serial('COM6');
set(COM,'BaudRate',19200);
fopen(COM)

disp('port opened');

% send the command to print data
fprintf(COM,'p')

%there's usually some garbage at the beginning (like the echoed p
%character command and line breaks); this reads lines in until we find
%the start line
text = fscanf(COM, '%s');
while isempty(strfind(text, 'START'))
text = fscanf(COM, '%s');
end

% read number of rows
rowstext = fscanf(COM, '%s');
pat = 'ROWS=';
split = regexp(rowstext, pat, 'split');
rows = str2double(split(2));

DATA = zeros(rows,columns);

%generate the fscanf format argument
%repeate the formatchar character for the number of columns
formatchar = '%d';
serialpat = '';

%establishing fscanf format
for j = 1:columns
serialpat = [serialpat ' ' formatchar];
end

%reads serial data and puts it into DATA
for j = 1:rows
DATA(j, :) = fscanf(COM, serialpat, [columns 1]);
%disp(COM.BytesAvailable)

end

%reads last line
last = fscanf(COM, '%s');

%verifies that last line read is the last line
if strcmp(last,'END')
disp('Success')
else
disp('Problem')
end

%disp(COM.BytesAvailable) %for debugging

%plotting input signal
subplot(3, 1, 1)
plot(DATA(:,3))
title('Time Domain Signal')

%plotting PIC calculated FFT
subplot(3, 1, 2)
plot(DATA(:,1), DATA(:,2))
title('Single Sided FFT Calculated on the PIC')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')
axis([0 Fs/2 0 2e5])

%calculating FFT in Matlab
NFFT = 2^nextpow2(L); % Next power of 2 from length of y
Y = fft(DATA(:,3),NFFT)/L;

%Y = DATA(:,1) + DATA(:,2)*1i;

f = Fs/2*linspace(0,1,NFFT/2+1);

% Plot Matlab's single-sided amplitude spectrum.
subplot(3, 1, 3)
plot(f,2*abs(Y(1:NFFT/2+1)))
title('Single Sided FFT Calculated with MATLAB')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')

%pause(2) %UNCOMMENT FOR CONTINOUS FFT

%end %UNCOMMENT FOR CONTINUOUS FFT

%closes serial port
fclose(COM)
delete(COM)
clear COM
disp('port closed');

</pre>

==FFT Example Plots==
Here is an example using a 500 Hz sine wave input.
[[Image: FFT_500_sin.jpg|border|700px]]

This example uses a 1 kHz sine wave.
[[Image: FFT_1K_sin.jpg|border|700px]]

This example is still at 1 kHz, but with a square wave.
[[Image: FFT_1K_square.jpg|border|700px]]

This example shows a 2 kHz sine wave.
[[Image: FFT_2K_sin.jpg|border|700px]]

This example, still at 2 kHz, is a square wave.
[[Image: FFT_2K_square.jpg|border|700px]]

The final example is a 3 kHz sine wave.
[[Image: FFT_3K_sin.jpg|border|700px]]

== IFFT Circuit ==

== IFFT Code ==

== IFFT Example Plot ==

PIC32MX: FFT of Analog Input

2010-05-20T17:45:32Z

AndrewDai:

== Overview ==
A fast Fourier transform (FFT) is a method to calculate a discrete Fourier transform (DFT). More information about [http://en.wikipedia.org/wiki/Fast_Fourier_transform FFTs] and [http://en.wikipedia.org/wiki/Discrete_Fourier_transform DFTs] can be found on wikipedia (linked).
The following circuit and code allow a user to put a signal into a PIC32, perform an FFT on that signal, output the data to Matlab via RS-232, and view a plot showing the raw signal, the FFT as calculated by the PIC, and the FFT as calculated by Matlab. Viewing the Matlab calculation is for verification only and can be commented out of the Matlab code.

Commented C code and Matlab code are provided at the bottom of this page and can be downloaded [[Media: Lab5FFTcode.zip | here]].

== FFT Circuit ==

Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

*RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
*RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
*Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection.

[[Image:FftSchematic.png]]

== FFT Code ==
The following is the source code to be programmed onto the PIC. If unfamiliar, see [[HelloWorld_PIC32 | here]] for a guide to creating a .hex file with MPLAB and [[Directions_to_Load_Files_to_PIC32_with_HID_Bootloader | here]] for directions to load files to the PIC. It first establishes inputs, outputs and RS-232 communication. When prompted with a 'p' (as written, it is prompted automatically by Matlab), the PIC computes the FFT then sends the magnitude portion of the single-sided FFT and the raw samples to Matlab.

<pre>
/* Sam Bobb, Daniel Cornew, Ryan Deeter
Fast Fourier Transform (FFT) Example
ME 333, Lab 5
Feb 2010
*/

/** INCLUDES ***************************************************/
#include "HardwareProfile.h"
#include <plib.h>
#include "dsplib_dsp.h"
#include "fftc.h"

/** Constants **************************************************/

#define TRUE 1
#define FALSE 0

#define LOOP_TIME_PIN LATAbits.LATA14

#define DESIRED_BAUDRATE (19200) // The desired BaudRate

// To modify the number of samples:
#define fftc fft16c256 //from fftc.h, for N = 256 use fft16c256, for N = 1024 use fft16c1024
#define N 256 // Also change the log2N variable below!!

// To modify the sampling frequency
#define SAMPLE_FREQ 10000
// Also change the timer interupt setup in initInterruptController!

/** Function Declarations **************************************/
void initInterruptController();

void initUART2(int pbClk);

void sendDataRS232(void);

void computeFFT(void); //sets up function to compute FFT

/** Global Variables *******************************************/

int computeFFTflag = FALSE; //used to indicate that an fft computation has been requested over rs232

int sampleIndex = 0; //keeps track of where we're putting our ADC reading

/** establish variables for FFT calculation*/
// -----
// this has to be changed for different values of N
int log2N = 8; // log2(256) = 8
//int log2N = 10; // log2(1024) = 10
// -----

int16c sampleBuffer[N]; //initialize buffer to collect samples
int16c calcBuffer[N]; // initialize buffer to hold old samples
int16c scratch[N];
int16c dout[N]; //holds computed FFT until transmission

long int singleSidedFFT[N];
long int freqVector[N];

/** Main Function **********************************************/

int main(void)
{
int pbClk;
int i;

// Configure the proper PB frequency and the number of wait states
pbClk = SYSTEMConfigPerformance(SYS_FREQ);

TRISAbits.TRISA14 = 0;

// Allow vector interrupts
INTEnableSystemMultiVectoredInt();

mInitAllLEDs();

initInterruptController();

initUART2(pbClk);

// Configure the proper PB frequency and the number of wait states
SYSTEMConfigPerformance(SYS_FREQ);

// -------- Set Up ADC --------
// configure and enable the ADC
CloseADC10(); // ensure the ADC is off before setting the configuration

// define setup parameters for OpenADC10
// Turn module on | output in integer | trigger mode auto | enable autosample
#define PARAM1 ADC_MODULE_ON | ADC_FORMAT_INTG16 | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_ON

// define setup parameters for OpenADC10
// ADC ref external | disable offset test | enable scan mode | perform 2 samples | use one buffer | use MUXA mode
#define PARAM2 ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_ON | ADC_SAMPLES_PER_INT_2 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF

// define setup parameters for OpenADC10
// use ADC internal clock | set sample time
#define PARAM3 ADC_CONV_CLK_INTERNAL_RC | ADC_SAMPLE_TIME_15

// define setup parameters for OpenADC10
// set AN4
#define PARAM4 ENABLE_AN4_ANA

// define setup parameters for OpenADC10
// do not assign channels to scan
#define PARAM5 SKIP_SCAN_AN0 | SKIP_SCAN_AN1 | SKIP_SCAN_AN2 | SKIP_SCAN_AN3 | SKIP_SCAN_AN5 | SKIP_SCAN_AN6 | SKIP_SCAN_AN7 | SKIP_SCAN_AN8 | SKIP_SCAN_AN9 | SKIP_SCAN_AN10 | SKIP_SCAN_AN11 | SKIP_SCAN_AN12 | SKIP_SCAN_AN13 | SKIP_SCAN_AN14 | SKIP_SCAN_AN15

// use ground as neg ref for A | use AN4 (B4) for input A
// configure to sample AN4
SetChanADC10( ADC_CH0_NEG_SAMPLEA_NVREF); // configure to sample AN4
OpenADC10( PARAM1, PARAM2, PARAM3, PARAM4, PARAM5 ); // configure ADC using parameter define above

EnableADC10(); // Enable the ADC

while ( ! mAD1GetIntFlag() ) { } // wait for the first conversion to complete so there will be valid data in ADC result registers
// ------ DONE SETTING UP ADC ------

// zero the freqVector and singleSidedFFT
for (i=0; i<N; i++)
{
freqVector[i] = 0;
singleSidedFFT[i] = 0;
}

// generate frequency vector
// this is the x-axis of your single sided fft
for (i=0; i<N/2; i++)
{
freqVector[i] = i*(SAMPLE_FREQ/2)/((N/2) - 1);
}

// wait around until you get an fft command from rs232
// then call computeFFT to generate an fft of the last block of samples
// then send out rs232.
// If you want to use FFT without rs232, you can call computeFFT when ever you want in your program.
while(1)
{
if (computeFFTflag == TRUE)
{
computeFFT();
sendDataRS232();
}
}

CloseOC1();

} //end main

/** Interrupt Handlers *****************************************/
// interrput code for the timer 3
void __ISR( _TIMER_3_VECTOR, ipl7) T3Interrupt( void)
{
int i;
//LOOP_TIME_PIN = TRUE;
// When we used the loop time pin to measure the length of this ISR,
// we measured 400 ns, so you could sample at over 1 MHz.

sampleBuffer[sampleIndex].re = ReadADC10(0); // read the ADC into the real part of the samplebuffer
sampleBuffer[sampleIndex].im = 0; // the imaginary value is 0.

// you could shave a little time off this ISR by just zeroing the .im value once, outside the ISR

// increment the sampleIndex
if (sampleIndex == (N-1))
{
sampleIndex = 0;
}
else
{
sampleIndex++;
}

//LOOP_TIME_PIN = FALSE;

// clear interrupt flag and exit
mT3ClearIntFlag();
} // T3 Interrupt

// UART 2 interrupt handler
// it is set at priority level 2
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
{
char data;

// Is this an RX interrupt?
if(mU2RXGetIntFlag())
{
// Clear the RX interrupt Flag
mU2RXClearIntFlag();

data = ReadUART2();
// Echo what we just received.
putcUART2(data);

switch(data)
{

case 'p': // compute and output the FFT
computeFFTflag = TRUE;
break;
}

// Toggle LED to indicate UART activity
mLED_0_Toggle();

}

// We don't care about TX interrupt
if ( mU2TXGetIntFlag() )
{
mU2TXClearIntFlag();
}
}

/** Other Functions ********************************************/

void initInterruptController(void)
{
// init Timer3 mode and period (PR3)
OpenTimer3( T3_ON | T3_PS_1_1 | T3_SOURCE_INT, 0x1F40); // produces 100 ms period
// sampling frequency = 10 kHz

mT3SetIntPriority( 7); // set Timer3 Interrupt Priority
mT3ClearIntFlag(); // clear interrupt flag
mT3IntEnable( 1); // enable timer3 interrupts
}

void initUART2(int pbClk)
{
// define setup Configuration 1 for OpenUARTx
// Module Enable
// Work in IDLE mode
// Communication through usual pins
// Disable wake-up
// Loop back disabled
// Input to Capture module from ICx pin
// no parity 8 bit
// 1 stop bit
// IRDA encoder and decoder disabled
// CTS and RTS pins are disabled
// UxRX idle state is '1'
// 16x baud clock - normal speed
#define config1 UART_EN | UART_IDLE_CON | UART_RX_TX | UART_DIS_WAKE | UART_DIS_LOOPBACK | UART_DIS_ABAUD | UART_NO_PAR_8BIT | UART_1STOPBIT | UART_IRDA_DIS | UART_DIS_BCLK_CTS_RTS| UART_NORMAL_RX | UART_BRGH_SIXTEEN

// define setup Configuration 2 for OpenUARTx
// IrDA encoded UxTX idle state is '0'
// Enable UxRX pin
// Enable UxTX pin
// Interrupt on transfer of every character to TSR
// Interrupt on every char received
// Disable 9-bit address detect
// Rx Buffer Over run status bit clear
#define config2 UART_TX_PIN_LOW | UART_RX_ENABLE | UART_TX_ENABLE | UART_INT_TX | UART_INT_RX_CHAR | UART_ADR_DETECT_DIS | UART_RX_OVERRUN_CLEAR

// Open UART2 with config1 and config2
OpenUART2( config1, config2, pbClk/16/DESIRED_BAUDRATE-1); // calculate actual BAUD generate value.

// Configure UART2 RX Interrupt with priority 2
ConfigIntUART2(UART_INT_PR2 | UART_RX_INT_EN);
}

void sendDataRS232()
{
int i;
char RS232_Out_Buffer[32]; // max characters per line (line feed and carriage return count)

sprintf(RS232_Out_Buffer,"\n\rSTART\n\r"); //print START. MATLAB uses this as a start delimiter
putsUART2(RS232_Out_Buffer);

sprintf(RS232_Out_Buffer,"ROWS=%d\n\r", N); //print the number of rows, so matlab can make the correct sized buffer
putsUART2(RS232_Out_Buffer);

for(i = 0; i < N; i++)
{
// output: frequency vector, the calculated fft, raw samples
sprintf(RS232_Out_Buffer,"%d %d %d\n\r",freqVector[i], singleSidedFFT[i], calcBuffer[i].re);
putsUART2(RS232_Out_Buffer);
}

sprintf(RS232_Out_Buffer,"END\n\r"); //output end so matlab knows we're done
putsUART2(RS232_Out_Buffer);

}

void computeFFT()
{
// when using 256 samples, we measured this function to take about 500 microseconds
// (not including the time to send rs232 data)
int i;

mT3IntEnable(0); //turns off interrupt while computing FFT

LOOP_TIME_PIN = TRUE;

for (i=0; i<N; i++)
{
if (i<sampleIndex)
{
// old chunk
calcBuffer[i+(N-sampleIndex)] = sampleBuffer[i];
}
else // i >= sampleIndex
{
// new chunk
calcBuffer[i-sampleIndex] = sampleBuffer[i];
}

}

// load complex input data into din
mips_fft16(dout, calcBuffer, fftc, scratch, log2N);

// compute single sided fft
for(i = 0; i < N/2; i++)
{
singleSidedFFT[i] = 2 * ((dout[i].re*dout[i].re) + (dout[i].im*dout[i].im));
}

LOOP_TIME_PIN = FALSE;

computeFFTflag = FALSE;

// do something with dout
mT3IntEnable(1); //turn interrupt back on
}

</pre>

The following Matlab code computes its own FFT with the raw samples. It then plots the input signal, the PIC calculated FFT, and the Matlab calculated FFT, for comparison.

<pre>

% fftserial interface v 2

%Sam Bobb, Daniel Cornew, Ryan Deeter
%ME 333 Lab 5: FFT of Analog Input, Winter 2010

%This code receives the single sided magnitude FFT calculated on the PIC
%and the raw samples through serial communication. Matlab calculates its
%own FFT of the raw samples, then plots the input signal, PIC calculated
%FFT, and Matlab calculated FFT.

Fs = 10000; % Sampling frequency
T = 1/Fs; % Sample time
L = 256; % Length of signal
t = (0:L-1)*T; % Time vector

%for runtimes=1:100 %UNCOMMENT FOR CONTINUOUS FFT

columns = 3;

%check if the serial port already exists
%if it does, close it, it probably means something bad happened last run
if exist('COM','var')
disp('closing old port instance');
fclose(COM)
delete(COM)
clear COM
disp('port closed');
end

% open the serial port
COM = serial('COM6');
set(COM,'BaudRate',19200);
fopen(COM)

disp('port opened');

% send the command to print data
fprintf(COM,'p')

%there's usually some garbage at the beginning (like the echoed p
%character command and line breaks); this reads lines in until we find
%the start line
text = fscanf(COM, '%s');
while isempty(strfind(text, 'START'))
text = fscanf(COM, '%s');
end

% read number of rows
rowstext = fscanf(COM, '%s');
pat = 'ROWS=';
split = regexp(rowstext, pat, 'split');
rows = str2double(split(2));

DATA = zeros(rows,columns);

%generate the fscanf format argument
%repeate the formatchar character for the number of columns
formatchar = '%d';
serialpat = '';

%establishing fscanf format
for j = 1:columns
serialpat = [serialpat ' ' formatchar];
end

%reads serial data and puts it into DATA
for j = 1:rows
DATA(j, :) = fscanf(COM, serialpat, [columns 1]);
%disp(COM.BytesAvailable)

end

%reads last line
last = fscanf(COM, '%s');

%verifies that last line read is the last line
if strcmp(last,'END')
disp('Success')
else
disp('Problem')
end

%disp(COM.BytesAvailable) %for debugging

%plotting input signal
subplot(3, 1, 1)
plot(DATA(:,3))
title('Time Domain Signal')

%plotting PIC calculated FFT
subplot(3, 1, 2)
plot(DATA(:,1), DATA(:,2))
title('Single Sided FFT Calculated on the PIC')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')
axis([0 Fs/2 0 2e5])

%calculating FFT in Matlab
NFFT = 2^nextpow2(L); % Next power of 2 from length of y
Y = fft(DATA(:,3),NFFT)/L;

%Y = DATA(:,1) + DATA(:,2)*1i;

f = Fs/2*linspace(0,1,NFFT/2+1);

% Plot Matlab's single-sided amplitude spectrum.
subplot(3, 1, 3)
plot(f,2*abs(Y(1:NFFT/2+1)))
title('Single Sided FFT Calculated with MATLAB')
xlabel('Frequency (Hz)')
ylabel('|Y(f)|')

%pause(2) %UNCOMMENT FOR CONTINOUS FFT

%end %UNCOMMENT FOR CONTINUOUS FFT

%closes serial port
fclose(COM)
delete(COM)
clear COM
disp('port closed');

</pre>

==FFT Example Plots==
Here is an example using a 500 Hz sine wave input.
[[Image: FFT_500_sin.jpg|border|700px]]

This example uses a 1 kHz sine wave.
[[Image: FFT_1K_sin.jpg|border|700px]]

This example is still at 1 kHz, but with a square wave.
[[Image: FFT_1K_square.jpg|border|700px]]

This example shows a 2 kHz sine wave.
[[Image: FFT_2K_sin.jpg|border|700px]]

This example, still at 2 kHz, is a square wave.
[[Image: FFT_2K_square.jpg|border|700px]]

The final example is a 3 kHz sine wave.
[[Image: FFT_3K_sin.jpg|border|700px]]

Microchip PICs

2010-05-20T17:40:30Z

AndrewDai: /* Using the PIC32MX Series */

'''Note: Most code on this page was written using the CCS compiler. Microchip's MPLAB is also occasionally used.'''

[http://peshkin.mech.northwestern.edu/pic/code Link to all sample code here.]
*[[Sample code for most PIC18F4520 operations]]
*[http://www.ccsinfo.com/forum/ CCS user forum]
 
__TOC__
== Using the PIC18F4520 ==
*[[4520 Board intro]]
*[[4520 Board construction]]
*[[4520 Board use]]
*[[Microcontroller PIC18F4520]]
*[[PIC MCUs: Capabilities of PIC18F4520]]
**[[PIC18F4520: PWM Motor Control]]
**[[PIC18F4520: Digital Outputs]]
**[[PIC18F4520: Digital Inputs]]
**[[PIC18F4520: Serial Digital-to-Analog Conversion]]
**[[PIC18F4520: Analog Inputs]]
**[[PIC18F4520: Timers]]
**[[PIC18F4520: Comparator]]

== Example Code in C for PIC18F4520==
*[[C Example: Parallel Interfacing with LCDs]]
*[[C Example: Digital Inputs]]
*[[C Example: PWM Motor Control]]
*[[C Example: Comparators]]
*[[C Example: Digital Outputs]]
*[[C Example: Analog Inputs]]
*[[C Example: Digital Outputs (Ports)]]
*[[C Example: Bi-Directional PWM Motor Control]]
*[[C Example: Serial LCD]]

== Using the PIC32MX Series ==
*[[Introduction to the PIC32]]
*[[Getting Started with PIC32]] (includes NU32 development board)
** Download PIC32 Tutorial Files [[Media: PIC32_TutorialFiles.zip|here]].
** [[ME 333 Lab 2]] - Includes Digital IO, Analog Input, Parallel LCD and RS232 Com
** [[ME 333 Lab 4]] - Includes PWM and Encoder Motor Control
*[[Microcontroller PIC32MX460F512L]]
*[[Programming HID Bootloader on PIC32]]
*[[HelloWorld PIC32|Directions to code HelloWorld]]
*[[Directions to Load Files to PIC32 with HID Bootloader]]

*[[PIC MCUs: Capabilities of PIC32MX]]
**[[Programming HID Bootloader on PIC32 |PIC32MX: Bootloader]]
**Simple Programs
***[[PIC32MX: Digital Inputs]]
***[[PIC32MX: Digital Outputs]]
***[[PIC32MX: Analog Inputs]]
**Communication
***[[PIC32MX: Parallel LCD]]
***[[PIC32MX: RS232]]
***[[PIC32MX: USB Communication with a PC]]
***[[PIC32MX: SPI External RAM]]
***[[PIC32MX: I2C DAC]]
***[[PIC32MX: I2C EEPROM]]
***[[PIC32MX: SPI EEPROM]]
***[[PIC32MX: I2C Communication between PIC32s]]
***[[PIC32MX: SPI Communication between PIC32s]]
**Motor Control
***[[PIC32MX: PWM Motor Control|PIC32MX: PWM Motor Control]]
***[[PIC32MX: Encoder Motor Control|PIC32MX: Encoder Motor Control]]
***[[PIC32MX: Servo Control|PIC32MX: Servo Control]]
***[[PIC32MX: Driving a Stepper Motor]]
**Capabilities
***[[PIC32MX: Benchmarking Mathematical Operations]]
***[[PIC32MX: FFT of Analog Input]]
***[[PIC32MX: Sinusoidal Analog Output]]
***[[PIC32MX: XBee Wireless Round-trip Latency]]
***[[PIC32MX: Interfacing with Force Sensors from a Scale]]
***[[PIC32MX: Storing Data in Flash Memory (Run-Time Self Programming)]]

==Other PIC Resources ==

*[[PIC PWM Motor Driver]]
*[[Writing Code with the C18 Compiler]]
*[[Controlling a seven segment display]]
*[[PIC Microcontrollers with C18 Compiler]]
*[[PIC Motor Control and Serial Port Example]]
*[[PIC16F684]]
*[[PIC Microcontrollers with CCS Compiler]]
*[[Stepper motor control with the PIC]]
*[[PIC/C18 Compiler Tips and Troubleshooting]]
*[[CCS C]]
*[[Analog Input]]
*[[PIC MCUs: Hardware and Connections]]
*[[Storing constant data in program memory]]
*[[PIC Analog-Digital-Converter Example]]
*[[PIC Microcontroller]]
*[[Digital inputs & outputs]]
*[[Debugging C on a PIC]]
*[[Analog Output]]
*[[PIC MCUs: Software]]
*[[Interfacing to External EEPROM]]
*[[CCS IDE]]
*[[Interrupts]]
*[[PIC16F684 Registers]]
*[[Waveform Generation with AD9833]]
*[[Waveform Generation with AD9833, and SPI]]
*[[PIC computation time benchmarks]]
*[[PICkit 1]]
*[[PIC MCUs: 4520 Board]]
*[[More debugging tips]]
*[[Example Writeup: Analog Input]]
*[[LED Drivers]]
*[[Embedded Programming Tips for CCS C]]
*[[Wireless PIC bootloading]]
*[[PIC 18f4553]]
*[[I2C Motor Controller]]
*[[Driving a piezo speaker with a PIC]]
*[[PIC Servo Controller]]
*[[Watchdog timer]]
*[[Interfacing PIC with SPI memory]]
*[[Using the LS7166 Quadrature Counter]]

==Programming the PIC with Microchip's MPLAB==

Microchip PICs

2010-05-20T17:39:58Z

AndrewDai: /* Using the PIC32MX Series */

'''Note: Most code on this page was written using the CCS compiler. Microchip's MPLAB is also occasionally used.'''

[http://peshkin.mech.northwestern.edu/pic/code Link to all sample code here.]
*[[Sample code for most PIC18F4520 operations]]
*[http://www.ccsinfo.com/forum/ CCS user forum]
 
__TOC__
== Using the PIC18F4520 ==
*[[4520 Board intro]]
*[[4520 Board construction]]
*[[4520 Board use]]
*[[Microcontroller PIC18F4520]]
*[[PIC MCUs: Capabilities of PIC18F4520]]
**[[PIC18F4520: PWM Motor Control]]
**[[PIC18F4520: Digital Outputs]]
**[[PIC18F4520: Digital Inputs]]
**[[PIC18F4520: Serial Digital-to-Analog Conversion]]
**[[PIC18F4520: Analog Inputs]]
**[[PIC18F4520: Timers]]
**[[PIC18F4520: Comparator]]

== Example Code in C for PIC18F4520==
*[[C Example: Parallel Interfacing with LCDs]]
*[[C Example: Digital Inputs]]
*[[C Example: PWM Motor Control]]
*[[C Example: Comparators]]
*[[C Example: Digital Outputs]]
*[[C Example: Analog Inputs]]
*[[C Example: Digital Outputs (Ports)]]
*[[C Example: Bi-Directional PWM Motor Control]]
*[[C Example: Serial LCD]]

== Using the PIC32MX Series ==
*[[Introduction to the PIC32]]
*[[Getting Started with PIC32]] (includes NU32 development board)
** Download PIC32 Tutorial Files [[Media: PIC32_TutorialFiles.zip|here]].
** [[ME 333 Lab 2]] - Includes Digital IO, Analog Input, Parallel LCD and RS232 Com
** [[ME 333 Lab 4]] - Includes PWM and Encoder Motor Control
*[[Microcontroller PIC32MX460F512L]]
*[[Programming HID Bootloader on PIC32]]
*[[HelloWorld PIC32|Directions to code HelloWorld]]
*[[Directions to Load Files to PIC32 with HID Bootloader]]

*[[PIC MCUs: Capabilities of PIC32MX]]
**[[Programming HID Bootloader on PIC32 |PIC32MX: Bootloader]]
**Simple Programs
***[[PIC32MX: Digital Inputs]]
***[[PIC32MX: Digital Outputs]]
***[[PIC32MX: Analog Inputs]]
**Communication
***[[PIC32MX: Parallel LCD]]
***[[PIC32MX: RS232]]
***[[PIC32MX: USB Communication with a PC]]
***[[PIC32MX: SPI External RAM]]
***[[PIC32MX: I2C DAC]]
***[[PIC32MX: I2C EEPROM]]
***[[PIC32MX: SPI EEPROM]]
***[[PIC32MX: I2C Communication between PIC32s]]
***[[PIC32MX: SPI Communication between PIC32s]]
**Motor Control
***[[PIC32MX: PWM Motor Control|PIC32MX: PWM Motor Control]]
***[[PIC32MX: Encoder Motor Control|PIC32MX: Encoder Motor Control]]
***[[PIC32MX: Servo Control|PIC32MX: Servo Control]]
***[[PIC32MX: Driving a Stepper Motor]]
**Capabilities
***[[PIC32MX: Benchmarking Mathematical Operations]]
***[[PIC32MX: FFT and IFFT of Analog Input]]
***[[PIC32MX: Sinusoidal Analog Output]]
***[[PIC32MX: XBee Wireless Round-trip Latency]]
***[[PIC32MX: Interfacing with Force Sensors from a Scale]]
***[[PIC32MX: Storing Data in Flash Memory (Run-Time Self Programming)]]

==Other PIC Resources ==

*[[PIC PWM Motor Driver]]
*[[Writing Code with the C18 Compiler]]
*[[Controlling a seven segment display]]
*[[PIC Microcontrollers with C18 Compiler]]
*[[PIC Motor Control and Serial Port Example]]
*[[PIC16F684]]
*[[PIC Microcontrollers with CCS Compiler]]
*[[Stepper motor control with the PIC]]
*[[PIC/C18 Compiler Tips and Troubleshooting]]
*[[CCS C]]
*[[Analog Input]]
*[[PIC MCUs: Hardware and Connections]]
*[[Storing constant data in program memory]]
*[[PIC Analog-Digital-Converter Example]]
*[[PIC Microcontroller]]
*[[Digital inputs & outputs]]
*[[Debugging C on a PIC]]
*[[Analog Output]]
*[[PIC MCUs: Software]]
*[[Interfacing to External EEPROM]]
*[[CCS IDE]]
*[[Interrupts]]
*[[PIC16F684 Registers]]
*[[Waveform Generation with AD9833]]
*[[Waveform Generation with AD9833, and SPI]]
*[[PIC computation time benchmarks]]
*[[PICkit 1]]
*[[PIC MCUs: 4520 Board]]
*[[More debugging tips]]
*[[Example Writeup: Analog Input]]
*[[LED Drivers]]
*[[Embedded Programming Tips for CCS C]]
*[[Wireless PIC bootloading]]
*[[PIC 18f4553]]
*[[I2C Motor Controller]]
*[[Driving a piezo speaker with a PIC]]
*[[PIC Servo Controller]]
*[[Watchdog timer]]
*[[Interfacing PIC with SPI memory]]
*[[Using the LS7166 Quadrature Counter]]

==Programming the PIC with Microchip's MPLAB==

File:IFFTcode.zip

2010-04-18T18:40:14Z

AndrewDai: uploaded a new version of "Image:IFFTcode.zip"

This code is for the PIC32, and contains a C source file and a MATLAB .m file. The code implements a PWM output, a FFT, and an inverse FFT.

PIC32MX: Inverse FFT

2010-04-18T18:39:11Z

AndrewDai:

== Overview ==
An inverse FFT is a function that converts a frequency domain signal into a time domain signal. Inverse FFTs actually use the same algorithm as FFTs except with some scaling and conjugation or time reversal (depending on the algorithm). FFT information can be found at [[PIC32MX: FFT of Analog Input]]. The following circuit and code implements a program on the PIC32 that creates an analog signal, takes the FFT of that signal, and then takes the inverse FFT of the result to try and obtain the original waveform back. The data is all sent to MATLAB via RS232 and compared to MATLAB's computational results for accuracy.

The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]].

== Circuit ==
Much of this circuit is the same as the one found in the [[PIC32MX: FFT of Analog Input]] page. Here is a recap:

"Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently *configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

* RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
* RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
* Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection."

The only thing different about this circuit is that it includes a low pass filter. This filter integrates the PWM signal that is output from pin D0 and creates a continuous, analog signal.

[[Image:IFftSchematic.png|border|700px]]

== Code ==
The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]]. The code is very similar to the code found in the [[PIC32MX: FFT of Analog Input]] page. There are two main differences:

1. There is now an "analog output." This is basically a PWM that is filtered through a low pass filter. The pulse widths are modified very quickly, with the width of the pulse directly related to the amplitude of the output. Thus, a very short pulse is the same as the trough of the sine wave and a long pulse is the same as the peak of the wave.

2. This is more of a tip, but after the analog inputs are stored in the sample array, they are scaled up by a factor, in this case, 256. All this does is increase the range of the values. I found this to give results that align much better with MATLAB's results. The reason for this is that the mips_fft16 algorithm accepts int16 and int32 data the best. However, int data types can lose information since they round to the nearest integer. Thus, we can scale all the inputs to make them larger, thus yielding more accuracy (it is as if we added a few more decimal places).

== Example Plot ==

This waveform is a 30Hz sine wave superimposed on a 40Hz sine wave with the same amplitude and phase. As one can see, the FFT amplitude line up almost exactly. The phase graph has some discrepancy, but this can be easily fixed by changing the FFT phase vector to float, rather than int16. It is ok to use int16 here because the vector is not being inputted into the mips_fft algorithm. And finally, the inverse FFT matches up very nicely with the original signal, very little information is lost.

[[Image: IFFTwaveforms.png|border|700px]]

PIC32MX: Inverse FFT

2010-04-18T18:38:39Z

AndrewDai: /* Circuit */

== Overview ==
An inverse FFT is a function that converts a frequency domain signal into a time domain signal. Inverse FFTs actually use the same algorithm as FFTs except with some scaling and conjugation or time reversal (depending on the algorithm). FFT information can be found at [[PIC32MX: FFT of Analog Input]]. The following circuit and code implements a program on the PIC32 that creates an analog signal, takes the FFT of that signal, and then takes the inverse FFT of the result to try and obtain the original waveform back. The data is all sent to MATLAB via RS232 and compared to MATLAB's computational results for accuracy.

The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]].

== Circuit ==
Much of this circuit is the same as the one found in the [[PIC32MX: FFT of Analog Input]] page. Here is a recap:

"Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently *configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

* RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
* RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
* Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection."

The only thing different about this circuit is that it includes a low pass filter. This filter integrates the PWM signal that is output from pin D0 and creates a continuous, analog signal.

[[Image:IFftSchematic.png]]

== Code ==
The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]]. The code is very similar to the code found in the [[PIC32MX: FFT of Analog Input]] page. There are two main differences:

1. There is now an "analog output." This is basically a PWM that is filtered through a low pass filter. The pulse widths are modified very quickly, with the width of the pulse directly related to the amplitude of the output. Thus, a very short pulse is the same as the trough of the sine wave and a long pulse is the same as the peak of the wave.

2. This is more of a tip, but after the analog inputs are stored in the sample array, they are scaled up by a factor, in this case, 256. All this does is increase the range of the values. I found this to give results that align much better with MATLAB's results. The reason for this is that the mips_fft16 algorithm accepts int16 and int32 data the best. However, int data types can lose information since they round to the nearest integer. Thus, we can scale all the inputs to make them larger, thus yielding more accuracy (it is as if we added a few more decimal places).

== Example Plot ==

This waveform is a 30Hz sine wave superimposed on a 40Hz sine wave with the same amplitude and phase. As one can see, the FFT amplitude line up almost exactly. The phase graph has some discrepancy, but this can be easily fixed by changing the FFT phase vector to float, rather than int16. It is ok to use int16 here because the vector is not being inputted into the mips_fft algorithm. And finally, the inverse FFT matches up very nicely with the original signal, very little information is lost.

[[Image: IFFTwaveforms.png|border|700px]]

PIC32MX: Inverse FFT

2010-04-18T18:37:59Z

AndrewDai: /* Circuit */

== Overview ==
An inverse FFT is a function that converts a frequency domain signal into a time domain signal. Inverse FFTs actually use the same algorithm as FFTs except with some scaling and conjugation or time reversal (depending on the algorithm). FFT information can be found at [[PIC32MX: FFT of Analog Input]]. The following circuit and code implements a program on the PIC32 that creates an analog signal, takes the FFT of that signal, and then takes the inverse FFT of the result to try and obtain the original waveform back. The data is all sent to MATLAB via RS232 and compared to MATLAB's computational results for accuracy.

The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]].

== Circuit ==
Much of this circuit is the same as the one found in the [[PIC32MX: FFT of Analog Input]] page. Here is a recap:

*Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently *configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

* * RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
* * RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
* * Black RS-232 wire to ground

*The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the *calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

*The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection.

The only thing different about this circuit is that it includes a low pass filter. This filter integrates the PWM signal that is output from pin D0 and creates a continuous, analog signal.

[[Image:IFftSchematic.png]]

== Code ==
The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]]. The code is very similar to the code found in the [[PIC32MX: FFT of Analog Input]] page. There are two main differences:

1. There is now an "analog output." This is basically a PWM that is filtered through a low pass filter. The pulse widths are modified very quickly, with the width of the pulse directly related to the amplitude of the output. Thus, a very short pulse is the same as the trough of the sine wave and a long pulse is the same as the peak of the wave.

2. This is more of a tip, but after the analog inputs are stored in the sample array, they are scaled up by a factor, in this case, 256. All this does is increase the range of the values. I found this to give results that align much better with MATLAB's results. The reason for this is that the mips_fft16 algorithm accepts int16 and int32 data the best. However, int data types can lose information since they round to the nearest integer. Thus, we can scale all the inputs to make them larger, thus yielding more accuracy (it is as if we added a few more decimal places).

== Example Plot ==

This waveform is a 30Hz sine wave superimposed on a 40Hz sine wave with the same amplitude and phase. As one can see, the FFT amplitude line up almost exactly. The phase graph has some discrepancy, but this can be easily fixed by changing the FFT phase vector to float, rather than int16. It is ok to use int16 here because the vector is not being inputted into the mips_fft algorithm. And finally, the inverse FFT matches up very nicely with the original signal, very little information is lost.

[[Image: IFFTwaveforms.png|border|700px]]

PIC32MX: Inverse FFT

2010-04-18T18:35:08Z

AndrewDai: /* Example Plot */

== Overview ==
An inverse FFT is a function that converts a frequency domain signal into a time domain signal. Inverse FFTs actually use the same algorithm as FFTs except with some scaling and conjugation or time reversal (depending on the algorithm). FFT information can be found at [[PIC32MX: FFT of Analog Input]]. The following circuit and code implements a program on the PIC32 that creates an analog signal, takes the FFT of that signal, and then takes the inverse FFT of the result to try and obtain the original waveform back. The data is all sent to MATLAB via RS232 and compared to MATLAB's computational results for accuracy.

The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]].

== Circuit ==
Much of this circuit is the same as the one found in the [[PIC32MX: FFT of Analog Input]] page. Here is a recap:

"Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

* RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
* RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
* Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection."

The only thing different about this circuit is that it includes a low pass filter. This filter integrates the PWM signal that is output from pin D0 and creates a continuous, analog signal.

[[Image:IFftSchematic.png]]

== Code ==
The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]]. The code is very similar to the code found in the [[PIC32MX: FFT of Analog Input]] page. There are two main differences:

1. There is now an "analog output." This is basically a PWM that is filtered through a low pass filter. The pulse widths are modified very quickly, with the width of the pulse directly related to the amplitude of the output. Thus, a very short pulse is the same as the trough of the sine wave and a long pulse is the same as the peak of the wave.

2. This is more of a tip, but after the analog inputs are stored in the sample array, they are scaled up by a factor, in this case, 256. All this does is increase the range of the values. I found this to give results that align much better with MATLAB's results. The reason for this is that the mips_fft16 algorithm accepts int16 and int32 data the best. However, int data types can lose information since they round to the nearest integer. Thus, we can scale all the inputs to make them larger, thus yielding more accuracy (it is as if we added a few more decimal places).

== Example Plot ==

This waveform is a 30Hz sine wave superimposed on a 40Hz sine wave with the same amplitude and phase. As one can see, the FFT amplitude line up almost exactly. The phase graph has some discrepancy, but this can be easily fixed by changing the FFT phase vector to float, rather than int16. It is ok to use int16 here because the vector is not being inputted into the mips_fft algorithm. And finally, the inverse FFT matches up very nicely with the original signal, very little information is lost.

[[Image: IFFTwaveforms.png|border|700px]]

File:IFFTwaveforms.png

2010-04-18T18:34:40Z

AndrewDai:

PIC32MX: Inverse FFT

2010-04-18T18:33:37Z

AndrewDai:

== Overview ==
An inverse FFT is a function that converts a frequency domain signal into a time domain signal. Inverse FFTs actually use the same algorithm as FFTs except with some scaling and conjugation or time reversal (depending on the algorithm). FFT information can be found at [[PIC32MX: FFT of Analog Input]]. The following circuit and code implements a program on the PIC32 that creates an analog signal, takes the FFT of that signal, and then takes the inverse FFT of the result to try and obtain the original waveform back. The data is all sent to MATLAB via RS232 and compared to MATLAB's computational results for accuracy.

The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]].

== Circuit ==
Much of this circuit is the same as the one found in the [[PIC32MX: FFT of Analog Input]] page. Here is a recap:

"Beyond simple inputs and outputs, there is no special circuitry required for computing FFTs. The signal is inserted into pin B4 on the PIC and must be below VREF on the PIC (currently configured to 3.3 V). For data output, the PIC uses RS-232 communication. Three connections need to be made with the RS-232:

* RS-232 Tx to pin F4 on the PIC (orange connection in diagram)
* RS-232 Rx to pin F5 on the PIC (yellow connection in diagram)
* Black RS-232 wire to ground

The remaining connection is not essential for FFT caclulation but allows the user to monitor the calculation time. Pin A14 goes high during calculation and goes back low when the calculation is completed. This feature lets the calculation time be monitored on an oscilloscope.

The following circuit diagram illustrates the signal generator to PIC connection, the RS-232 connections, and the optional oscilloscope connection."

The only thing different about this circuit is that it includes a low pass filter. This filter integrates the PWM signal that is output from pin D0 and creates a continuous, analog signal.

[[Image:IFftSchematic.png]]

== Code ==
The code for both MATLAB and the PIC32 can be found [[Media: IFFTcode.zip | here]]. The code is very similar to the code found in the [[PIC32MX: FFT of Analog Input]] page. There are two main differences:

1. There is now an "analog output." This is basically a PWM that is filtered through a low pass filter. The pulse widths are modified very quickly, with the width of the pulse directly related to the amplitude of the output. Thus, a very short pulse is the same as the trough of the sine wave and a long pulse is the same as the peak of the wave.

2. This is more of a tip, but after the analog inputs are stored in the sample array, they are scaled up by a factor, in this case, 256. All this does is increase the range of the values. I found this to give results that align much better with MATLAB's results. The reason for this is that the mips_fft16 algorithm accepts int16 and int32 data the best. However, int data types can lose information since they round to the nearest integer. Thus, we can scale all the inputs to make them larger, thus yielding more accuracy (it is as if we added a few more decimal places).

== Example Plot ==

This waveform is a 30Hz sine wave superimposed on a 40Hz sine wave with the same amplitude and phase. As one can see, the FFT amplitude line up almost exactly. You can download the [[Media: IFFTwaveforms.fig | MATLAB fig]] file for further examination. The phase graph has some discrepancy, but this can be easily fixed by changing the FFT phase vector to float, rather than int16. It is ok to use int16 here because the vector is not being inputted into the mips_fft algorithm. And finally, the inverse FFT matches up very nicely with the original signal, very little information is lost.

[[Image: IFFTwaveforms.png|border|700px]]

PIC32MX: Inverse FFT

2010-04-18T18:18:13Z

AndrewDai:

File:IFftSchematic.png

2010-04-18T18:16:47Z

AndrewDai: Schematic for the IFFT code.

Schematic for the IFFT code.

PIC32MX: Inverse FFT

2010-04-18T18:16:07Z

AndrewDai:

PIC32MX: Inverse FFT

2010-04-18T18:15:54Z

AndrewDai:

File:IFFTcode.zip

2010-04-18T18:11:45Z

AndrewDai: This code is for the PIC32, and contains a C source file and a MATLAB .m file. The code implements a PWM output, a FFT, and an inverse FFT.

This code is for the PIC32, and contains a C source file and a MATLAB .m file. The code implements a PWM output, a FFT, and an inverse FFT.

PIC32MX: Inverse FFT

2010-04-17T20:26:50Z

AndrewDai:

PIC32MX: Inverse FFT

2010-04-17T20:26:39Z

AndrewDai:

PIC32MX: Inverse FFT

2010-04-17T20:20:01Z

AndrewDai:

PIC32MX: Inverse FFT

2010-04-17T20:19:43Z

AndrewDai:

PIC32MX: Inverse FFT

2010-04-17T20:08:16Z

AndrewDai:

== Overview ==
An inverse FFT is a function that converts a frequency domain signal into a time domain signal.

== Circuit ==

PIC32MX: Inverse FFT

2010-04-17T20:07:24Z

AndrewDai: Calculate the inverse FFT of a frequency domain signal

An inverse FFT is a function that converts a frequency domain signal into a time domain signal.

Microchip PICs

2010-04-17T20:03:21Z

AndrewDai: /* Using the PIC32MX Series */

'''Note: Most code on this page was written using the CCS compiler. Microchip's MPLAB is also occasionally used.'''

[http://peshkin.mech.northwestern.edu/pic/code Link to all sample code here.]
*[[Sample code for most PIC18F4520 operations]]
*[http://www.ccsinfo.com/forum/ CCS user forum]
 
__TOC__
== Using the PIC18F4520 ==
*[[4520 Board intro]]
*[[4520 Board construction]]
*[[4520 Board use]]
*[[Microcontroller PIC18F4520]]
*[[PIC MCUs: Capabilities of PIC18F4520]]
**[[PIC18F4520: PWM Motor Control]]
**[[PIC18F4520: Digital Outputs]]
**[[PIC18F4520: Digital Inputs]]
**[[PIC18F4520: Serial Digital-to-Analog Conversion]]
**[[PIC18F4520: Analog Inputs]]
**[[PIC18F4520: Timers]]
**[[PIC18F4520: Comparator]]

== Example Code in C for PIC18F4520==
*[[C Example: Parallel Interfacing with LCDs]]
*[[C Example: Digital Inputs]]
*[[C Example: PWM Motor Control]]
*[[C Example: Comparators]]
*[[C Example: Digital Outputs]]
*[[C Example: Analog Inputs]]
*[[C Example: Digital Outputs (Ports)]]
*[[C Example: Bi-Directional PWM Motor Control]]
*[[C Example: Serial LCD]]

== Using the PIC32MX Series ==
*[[Introduction to the PIC32]]
*[[Getting Started with PIC32]] (includes NU32 development board)
** [[ME 333 Lab 2]] - Includes Digital IO, Analog Input, Parallel LCD and RS232 Com
** [[ME 333 Lab 4]] - Includes PWM and Encoder Motor Control
*[[Microcontroller PIC32MX460F512L]]
*[[Programming HID Bootloader on PIC32]]
*[[HelloWorld PIC32|Directions to code HelloWorld]]
*[[Directions to Load Files to PIC32 with HID Bootloader]]

*[[PIC MCUs: Capabilities of PIC32MX]]
**[[Programming HID Bootloader on PIC32 |PIC32MX: Bootloader]]
**Simple Programs
***[[PIC32MX: Digital Inputs]]
***[[PIC32MX: Digital Outputs]]
***[[PIC32MX: Analog Inputs]]
**Communication
***[[PIC32MX: Parallel LCD]]
***[[PIC32MX: RS232]]
***[[PIC32MX: USB Communication with a PC]]
***[[PIC32MX: SPI External RAM]]
***[[PIC32MX: I2C DAC]]
***[[PIC32MX: I2C EEPROM]]
***[[PIC32MX: SPI EEPROM]]
***[[PIC32MX: I2C Communication between PIC32s]]
***[[PIC32MX: SPI Communication between PIC32s]]
**Motor Control
***[[PIC32MX: PWM Motor Control|PIC32MX: PWM Motor Control]]
***[[PIC32MX: Encoder Motor Control|PIC32MX: Encoder Motor Control]]
***[[PIC32MX: Servo Control|PIC32MX: Servo Control]]
***[[PIC32MX: Driving a Stepper Motor]]
**Capabilities
***[[PIC32MX: Benchmarking Mathematical Operations]]
***[[PIC32MX: FFT of Analog Input]]
***[[PIC32MX: Inverse FFT]]
***[[PIC32MX: XBee Wireless Round-trip Latency]]
***[[PIC32MX: Interfacing with Force Sensors from a Scale]]

==Other PIC Resources ==

*[[PIC PWM Motor Driver]]
*[[Writing Code with the C18 Compiler]]
*[[Controlling a seven segment display]]
*[[PIC Microcontrollers with C18 Compiler]]
*[[PIC Motor Control and Serial Port Example]]
*[[PIC16F684]]
*[[PIC Microcontrollers with CCS Compiler]]
*[[Stepper motor control with the PIC]]
*[[PIC/C18 Compiler Tips and Troubleshooting]]
*[[CCS C]]
*[[Analog Input]]
*[[PIC MCUs: Hardware and Connections]]
*[[Storing constant data in program memory]]
*[[PIC Analog-Digital-Converter Example]]
*[[PIC Microcontroller]]
*[[Digital inputs & outputs]]
*[[Debugging C on a PIC]]
*[[Analog Output]]
*[[PIC MCUs: Software]]
*[[Interfacing to External EEPROM]]
*[[CCS IDE]]
*[[Interrupts]]
*[[PIC16F684 Registers]]
*[[Waveform Generation with AD9833]]
*[[Waveform Generation with AD9833, and SPI]]
*[[PIC computation time benchmarks]]
*[[PICkit 1]]
*[[PIC MCUs: 4520 Board]]
*[[More debugging tips]]
*[[Example Writeup: Analog Input]]
*[[LED Drivers]]
*[[Embedded Programming Tips for CCS C]]
*[[Wireless PIC bootloading]]
*[[PIC 18f4553]]
*[[I2C Motor Controller]]
*[[Driving a piezo speaker with a PIC]]
*[[PIC Servo Controller]]
*[[Watchdog timer]]
*[[Interfacing PIC with SPI memory]]

==Programming the PIC with Microchip's MPLAB==