Yulou Yang / Mbed 2 deprecated KL25Z_FFT_Demo

draft

Dependencies:   FastAnalogIn HSI2RGBW_PWM NVIC_set_all_priorities mbed-dsp mbed MMA8451Q

Fork of KL25Z_FFT_Demo by Frank Vannieuwkerke

main.cpp@4:5d4bcc4751d7, 2016-04-25 (annotated)

Committer:
yangyulounk
Date:
Mon Apr 25 21:52:32 2016 +0000
Revision:
4:5d4bcc4751d7
Parent:
3:a8238ddc2868 
final_demo

Who changed what in which revision?

UserRevisionLine numberNew contents of line
frankvnk 0:0c037aff5039 1 // Audio Spectrum Display
frankvnk 0:0c037aff5039 2 // Copyright 2013 Tony DiCola (tony@tonydicola.com)
frankvnk 0:0c037aff5039 3 // Code ported from the guide at http://learn.adafruit.com/fft-fun-with-fourier-transforms?view=all
frankvnk 0:0c037aff5039 4
frankvnk 0:0c037aff5039 5 #include "mbed.h"
frankvnk 0:0c037aff5039 6 #include "NVIC_set_all_priorities.h"
frankvnk 0:0c037aff5039 7 #include <ctype.h>
frankvnk 0:0c037aff5039 8 #include "arm_math.h"
frankvnk 2:035d551759a5 9 #include "arm_const_structs.h"
frankvnk 0:0c037aff5039 10 #include "hsi2rgbw_pwm.h"
frankvnk 1:736b34e0f484 11 #include "FastAnalogIn.h"
yangyulounk 4:5d4bcc4751d7 12 #include "MMA8451Q.h"
frankvnk 0:0c037aff5039 13
frankvnk 0:0c037aff5039 14 Serial pc(USBTX, USBRX);
frankvnk 0:0c037aff5039 15
frankvnk 1:736b34e0f484 16 FastAnalogIn Audio(PTC2);
frankvnk 0:0c037aff5039 17
yangyulounk 4:5d4bcc4751d7 18
yangyulounk 4:5d4bcc4751d7 19 PinName const SDA = PTE25;
yangyulounk 4:5d4bcc4751d7 20 PinName const SCL = PTE24;
yangyulounk 4:5d4bcc4751d7 21
yangyulounk 4:5d4bcc4751d7 22 SPI spi(PTD2, PTD3, PTD1); // Arduino compatible MOSI, MISO, SCLK
yangyulounk 4:5d4bcc4751d7 23 DigitalOut cs(PTD0); // Chip select
frankvnk 0:0c037aff5039 24 //#define RGBW_ext // Disable this line when you want to use the KL25Z on-board RGB LED.
yangyulounk 4:5d4bcc4751d7 25 #define MMA8451_I2C_ADDRESS (0x1d<<1)
yangyulounk 4:5d4bcc4751d7 26 /*
frankvnk 0:0c037aff5039 27 #ifndef RGBW_ext
frankvnk 0:0c037aff5039 28 // HSI to RGB conversion with direct output to PWM channels - on-board RGB LED
frankvnk 0:0c037aff5039 29 hsi2rgbw_pwm led(LED_RED, LED_GREEN, LED_BLUE);
frankvnk 0:0c037aff5039 30 #else
frankvnk 0:0c037aff5039 31 // HSI to RGBW conversion with direct output to external PWM channels - RGBW LED
frankvnk 0:0c037aff5039 32 hsi2rgbw_pwm led(PTD4, PTA12, PTA4, PTA5); //Red, Green, Blue, White
frankvnk 0:0c037aff5039 33 #endif
yangyulounk 4:5d4bcc4751d7 34 */
frankvnk 0:0c037aff5039 35 // Dummy ISR for disabling NMI on PTA4 - !! DO NOT REMOVE THIS !!
frankvnk 0:0c037aff5039 36 // More info at https://mbed.org/questions/1387/How-can-I-access-the-FTFA_FOPT-register-/
frankvnk 0:0c037aff5039 37 extern "C" void NMI_Handler() {
frankvnk 0:0c037aff5039 38 DigitalIn test(PTA4);
frankvnk 0:0c037aff5039 39 }
frankvnk 0:0c037aff5039 40
frankvnk 0:0c037aff5039 41
frankvnk 0:0c037aff5039 42 ////////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 43 // CONFIGURATION
frankvnk 0:0c037aff5039 44 // These values can be changed to alter the behavior of the spectrum display.
frankvnk 0:0c037aff5039 45 // KL25Z limitations
frankvnk 0:0c037aff5039 46 // -----------------
frankvnk 0:0c037aff5039 47 // - When used with the Spectrogram python script :
frankvnk 0:0c037aff5039 48 // There is a substantial time lag between the music and the screen output.
frankvnk 2:035d551759a5 49 // Max allowed SAMPLE_RATE_HZ is 40000
frankvnk 2:035d551759a5 50 // Max allowed FFT_SIZE is 64
frankvnk 0:0c037aff5039 51 ////////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 52
frankvnk 2:035d551759a5 53 int SLOWDOWN = 4; // Create an optical delay in spectrumLoop - useful when only one RGB led is used.
frankvnk 0:0c037aff5039 54 // Only active when nonzero.
frankvnk 0:0c037aff5039 55 // A value >= 1000 and <= 1000 + PIXEL_COUNT fixes the output to a single frequency
frankvnk 0:0c037aff5039 56 // window = a single color.
yangyulounk 4:5d4bcc4751d7 57 int SAMPLE_RATE_HZ = 20000; // Sample rate of the audio in hertz.
frankvnk 2:035d551759a5 58 float SPECTRUM_MIN_DB = 30.0; // Audio intensity (in decibels) that maps to low LED brightness.
frankvnk 1:736b34e0f484 59 float SPECTRUM_MAX_DB = 80.0; // Audio intensity (in decibels) that maps to high LED brightness.
frankvnk 0:0c037aff5039 60 int LEDS_ENABLED = 1; // Control if the LED's should display the spectrum or not. 1 is true, 0 is false.
frankvnk 0:0c037aff5039 61 // Useful for turning the LED display on and off with commands from the serial port.
frankvnk 1:736b34e0f484 62 const int FFT_SIZE = 64; // Size of the FFT.
yangyulounk 3:a8238ddc2868 63 const int PIXEL_COUNT = 8; // Number of pixels. You should be able to increase this without
frankvnk 0:0c037aff5039 64 // any other changes to the program.
frankvnk 0:0c037aff5039 65 const int MAX_CHARS = 65; // Max size of the input command buffer
frankvnk 0:0c037aff5039 66
yangyulounk 4:5d4bcc4751d7 67 const unsigned char tempCurrentLevel[] = {0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF};
yangyulounk 3:a8238ddc2868 68
yangyulounk 3:a8238ddc2868 69
frankvnk 0:0c037aff5039 70 ////////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 71 // INTERNAL STATE
frankvnk 0:0c037aff5039 72 // These shouldn't be modified unless you know what you're doing.
frankvnk 0:0c037aff5039 73 ////////////////////////////////////////////////////////////////////////////////
frankvnk 2:035d551759a5 74 const static arm_cfft_instance_f32 *S;
frankvnk 0:0c037aff5039 75 Ticker samplingTimer;
frankvnk 0:0c037aff5039 76 float samples[FFT_SIZE*2];
frankvnk 0:0c037aff5039 77 float magnitudes[FFT_SIZE];
frankvnk 0:0c037aff5039 78 int sampleCounter = 0;
frankvnk 0:0c037aff5039 79 char commandBuffer[MAX_CHARS];
frankvnk 0:0c037aff5039 80 float frequencyWindow[PIXEL_COUNT+1];
frankvnk 0:0c037aff5039 81 float hues[PIXEL_COUNT];
frankvnk 0:0c037aff5039 82 bool commandRecv = 0;
frankvnk 0:0c037aff5039 83 ////////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 84 // UTILITY FUNCTIONS
frankvnk 0:0c037aff5039 85 ////////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 86
yangyulounk 4:5d4bcc4751d7 87 /// Send two bytes to SPI bus
yangyulounk 4:5d4bcc4751d7 88 void SPI_Write2(unsigned char MSB, unsigned char LSB)
yangyulounk 4:5d4bcc4751d7 89 {
yangyulounk 4:5d4bcc4751d7 90 cs = 0; // Set CS Low
yangyulounk 4:5d4bcc4751d7 91 spi.write(MSB); // Send two bytes
yangyulounk 4:5d4bcc4751d7 92 spi.write(LSB);
yangyulounk 4:5d4bcc4751d7 93 cs = 1; // Set CS High
yangyulounk 4:5d4bcc4751d7 94 }
yangyulounk 4:5d4bcc4751d7 95
yangyulounk 4:5d4bcc4751d7 96
yangyulounk 4:5d4bcc4751d7 97 /// MAX7219 initialisation
yangyulounk 4:5d4bcc4751d7 98 void Init_MAX7219(void)
yangyulounk 4:5d4bcc4751d7 99 {
yangyulounk 4:5d4bcc4751d7 100 SPI_Write2(0x09, 0x00); // Decoding off
yangyulounk 4:5d4bcc4751d7 101 SPI_Write2(0x0A, 0x08); // Brightness to intermediate
yangyulounk 4:5d4bcc4751d7 102 SPI_Write2(0x0B, 0x07); // Scan limit = 7
yangyulounk 4:5d4bcc4751d7 103 SPI_Write2(0x0C, 0x01); // Normal operation mode
yangyulounk 4:5d4bcc4751d7 104 SPI_Write2(0x0F, 0x0F); // Enable display test
yangyulounk 4:5d4bcc4751d7 105 wait_ms(500); // 500 ms delay
yangyulounk 4:5d4bcc4751d7 106 SPI_Write2(0x01, 0x00); // Clear row 0.
yangyulounk 4:5d4bcc4751d7 107 SPI_Write2(0x02, 0x00); // Clear row 1.
yangyulounk 4:5d4bcc4751d7 108 SPI_Write2(0x03, 0x00); // Clear row 2.
yangyulounk 4:5d4bcc4751d7 109 SPI_Write2(0x04, 0x00); // Clear row 3.
yangyulounk 4:5d4bcc4751d7 110 SPI_Write2(0x05, 0x00); // Clear row 4.
yangyulounk 4:5d4bcc4751d7 111 SPI_Write2(0x06, 0x00); // Clear row 5.
yangyulounk 4:5d4bcc4751d7 112 SPI_Write2(0x07, 0x00); // Clear row 6.
yangyulounk 4:5d4bcc4751d7 113 SPI_Write2(0x08, 0x00); // Clear row 7.
yangyulounk 4:5d4bcc4751d7 114 SPI_Write2(0x0F, 0x00); // Disable display test
yangyulounk 4:5d4bcc4751d7 115 wait_ms(500); // 500 ms delay
yangyulounk 4:5d4bcc4751d7 116 }
yangyulounk 4:5d4bcc4751d7 117 /*
frankvnk 0:0c037aff5039 118 void rxisr() {
frankvnk 0:0c037aff5039 119 char c = pc.getc();
frankvnk 0:0c037aff5039 120 // Add any characters that aren't the end of a command (semicolon) to the input buffer.
frankvnk 0:0c037aff5039 121 if (c != ';') {
frankvnk 0:0c037aff5039 122 c = toupper(c);
frankvnk 0:0c037aff5039 123 strncat(commandBuffer, &c, 1);
frankvnk 0:0c037aff5039 124 } else {
frankvnk 0:0c037aff5039 125 // Parse the command because an end of command token was encountered.
frankvnk 0:0c037aff5039 126 commandRecv = 1;
frankvnk 0:0c037aff5039 127 }
frankvnk 0:0c037aff5039 128 }
yangyulounk 4:5d4bcc4751d7 129 */
frankvnk 0:0c037aff5039 130 // Compute the average magnitude of a target frequency window vs. all other frequencies.
frankvnk 0:0c037aff5039 131 void windowMean(float* magnitudes, int lowBin, int highBin, float* windowMean, float* otherMean)
frankvnk 0:0c037aff5039 132 {
frankvnk 0:0c037aff5039 133 *windowMean = 0;
frankvnk 0:0c037aff5039 134 *otherMean = 0;
frankvnk 0:0c037aff5039 135 // Notice the first magnitude bin is skipped because it represents the
frankvnk 0:0c037aff5039 136 // average power of the signal.
frankvnk 0:0c037aff5039 137 for (int i = 1; i < FFT_SIZE/2; ++i) {
frankvnk 0:0c037aff5039 138 if (i >= lowBin && i <= highBin) {
frankvnk 0:0c037aff5039 139 *windowMean += magnitudes[i];
frankvnk 0:0c037aff5039 140 } else {
frankvnk 0:0c037aff5039 141 *otherMean += magnitudes[i];
frankvnk 0:0c037aff5039 142 }
frankvnk 0:0c037aff5039 143 }
frankvnk 0:0c037aff5039 144 *windowMean /= (highBin - lowBin) + 1;
frankvnk 0:0c037aff5039 145 *otherMean /= (FFT_SIZE / 2 - (highBin - lowBin));
frankvnk 0:0c037aff5039 146 }
frankvnk 0:0c037aff5039 147
frankvnk 0:0c037aff5039 148 // Convert a frequency to the appropriate FFT bin it will fall within.
frankvnk 0:0c037aff5039 149 int frequencyToBin(float frequency)
frankvnk 0:0c037aff5039 150 {
frankvnk 0:0c037aff5039 151 float binFrequency = float(SAMPLE_RATE_HZ) / float(FFT_SIZE);
frankvnk 0:0c037aff5039 152 return int(frequency / binFrequency);
frankvnk 0:0c037aff5039 153 }
frankvnk 0:0c037aff5039 154
frankvnk 0:0c037aff5039 155
frankvnk 0:0c037aff5039 156 ////////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 157 // SPECTRUM DISPLAY FUNCTIONS
frankvnk 0:0c037aff5039 158 ///////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 159
frankvnk 0:0c037aff5039 160 void spectrumSetup()
frankvnk 0:0c037aff5039 161 {
frankvnk 0:0c037aff5039 162 // Set the frequency window values by evenly dividing the possible frequency
frankvnk 0:0c037aff5039 163 // spectrum across the number of neo pixels.
frankvnk 0:0c037aff5039 164 float windowSize = (SAMPLE_RATE_HZ / 2.0) / float(PIXEL_COUNT);
frankvnk 0:0c037aff5039 165 for (int i = 0; i < PIXEL_COUNT+1; ++i) {
frankvnk 0:0c037aff5039 166 frequencyWindow[i] = i*windowSize;
frankvnk 0:0c037aff5039 167 }
frankvnk 0:0c037aff5039 168 // Evenly spread hues across all pixels.
frankvnk 0:0c037aff5039 169 for (int i = 0; i < PIXEL_COUNT; ++i) {
frankvnk 0:0c037aff5039 170 hues[i] = 360.0*(float(i)/float(PIXEL_COUNT-1));
frankvnk 0:0c037aff5039 171 }
frankvnk 0:0c037aff5039 172 }
frankvnk 0:0c037aff5039 173
frankvnk 0:0c037aff5039 174 void spectrumLoop()
frankvnk 0:0c037aff5039 175 {
frankvnk 0:0c037aff5039 176 // Update each LED based on the intensity of the audio
frankvnk 0:0c037aff5039 177 // in the associated frequency window.
frankvnk 0:0c037aff5039 178 static int SLrpt = 0, SLpixcnt = 0;
yangyulounk 3:a8238ddc2868 179 int SLpixend = 8;
frankvnk 0:0c037aff5039 180 float intensity, otherMean;
yangyulounk 3:a8238ddc2868 181
yangyulounk 3:a8238ddc2868 182 int intensity_4x8[32]={0};
yangyulounk 3:a8238ddc2868 183 int offset=0;
yangyulounk 3:a8238ddc2868 184
frankvnk 0:0c037aff5039 185 for (int i = SLpixcnt; i < SLpixend; ++i) {
frankvnk 0:0c037aff5039 186 windowMean(magnitudes,
frankvnk 0:0c037aff5039 187 frequencyToBin(frequencyWindow[i]),
frankvnk 0:0c037aff5039 188 frequencyToBin(frequencyWindow[i+1]),
frankvnk 0:0c037aff5039 189 &intensity,
frankvnk 0:0c037aff5039 190 &otherMean);
yangyulounk 4:5d4bcc4751d7 191 printf("%d: %d \n",i, ((int)intensity)/3);
yangyulounk 4:5d4bcc4751d7 192 int j = ((int)intensity)/5;
yangyulounk 4:5d4bcc4751d7 193 j = ((j>280) ? 280 : j)/40;
yangyulounk 4:5d4bcc4751d7 194 printf("%d \n",j);
yangyulounk 4:5d4bcc4751d7 195
yangyulounk 4:5d4bcc4751d7 196 SPI_Write2(8-i,tempCurrentLevel[j]);
yangyulounk 3:a8238ddc2868 197
yangyulounk 3:a8238ddc2868 198
yangyulounk 3:a8238ddc2868 199
frankvnk 0:0c037aff5039 200 }
yangyulounk 4:5d4bcc4751d7 201 }
frankvnk 0:0c037aff5039 202
frankvnk 0:0c037aff5039 203
frankvnk 0:0c037aff5039 204 ////////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 205 // SAMPLING FUNCTIONS
frankvnk 0:0c037aff5039 206 ////////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 207
frankvnk 0:0c037aff5039 208 void samplingCallback()
frankvnk 0:0c037aff5039 209 {
frankvnk 0:0c037aff5039 210 // Read from the ADC and store the sample data
frankvnk 1:736b34e0f484 211 samples[sampleCounter] = (1023 * Audio) - 511.0f;
frankvnk 0:0c037aff5039 212 // Complex FFT functions require a coefficient for the imaginary part of the input.
frankvnk 0:0c037aff5039 213 // Since we only have real data, set this coefficient to zero.
frankvnk 0:0c037aff5039 214 samples[sampleCounter+1] = 0.0;
frankvnk 0:0c037aff5039 215 // Update sample buffer position and stop after the buffer is filled
frankvnk 0:0c037aff5039 216 sampleCounter += 2;
frankvnk 0:0c037aff5039 217 if (sampleCounter >= FFT_SIZE*2) {
frankvnk 0:0c037aff5039 218 samplingTimer.detach();
frankvnk 0:0c037aff5039 219 }
frankvnk 0:0c037aff5039 220 }
frankvnk 0:0c037aff5039 221
frankvnk 0:0c037aff5039 222 void samplingBegin()
frankvnk 0:0c037aff5039 223 {
frankvnk 0:0c037aff5039 224 // Reset sample buffer position and start callback at necessary rate.
frankvnk 0:0c037aff5039 225 sampleCounter = 0;
frankvnk 0:0c037aff5039 226 samplingTimer.attach_us(&samplingCallback, 1000000/SAMPLE_RATE_HZ);
frankvnk 0:0c037aff5039 227 }
frankvnk 0:0c037aff5039 228
frankvnk 0:0c037aff5039 229 bool samplingIsDone()
frankvnk 0:0c037aff5039 230 {
frankvnk 0:0c037aff5039 231 return sampleCounter >= FFT_SIZE*2;
frankvnk 0:0c037aff5039 232 }
frankvnk 0:0c037aff5039 233
frankvnk 0:0c037aff5039 234
frankvnk 0:0c037aff5039 235 ////////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 236 // COMMAND PARSING FUNCTIONS
frankvnk 0:0c037aff5039 237 // These functions allow parsing simple commands input on the serial port.
frankvnk 0:0c037aff5039 238 // Commands allow reading and writing variables that control the device.
frankvnk 0:0c037aff5039 239 //
frankvnk 0:0c037aff5039 240 // All commands must end with a semicolon character.
frankvnk 0:0c037aff5039 241 //
frankvnk 0:0c037aff5039 242 // Example commands are:
frankvnk 0:0c037aff5039 243 // GET SAMPLE_RATE_HZ;
frankvnk 0:0c037aff5039 244 // - Get the sample rate of the device.
frankvnk 0:0c037aff5039 245 // SET SAMPLE_RATE_HZ 400;
frankvnk 0:0c037aff5039 246 // - Set the sample rate of the device to 400 hertz.
frankvnk 0:0c037aff5039 247 //
frankvnk 0:0c037aff5039 248 ////////////////////////////////////////////////////////////////////////////////
yangyulounk 4:5d4bcc4751d7 249 /*
frankvnk 0:0c037aff5039 250 void parseCommand(char* command)
frankvnk 0:0c037aff5039 251 {
frankvnk 0:0c037aff5039 252 if (strcmp(command, "GET MAGNITUDES") == 0) {
frankvnk 0:0c037aff5039 253 for (int i = 0; i < FFT_SIZE; ++i) {
frankvnk 0:0c037aff5039 254 printf("%f\r\n", magnitudes[i]);
frankvnk 0:0c037aff5039 255 }
frankvnk 0:0c037aff5039 256 } else if (strcmp(command, "GET SAMPLES") == 0) {
frankvnk 0:0c037aff5039 257 for (int i = 0; i < FFT_SIZE*2; i+=2) {
frankvnk 0:0c037aff5039 258 printf("%f\r\n", samples[i]);
frankvnk 0:0c037aff5039 259 }
frankvnk 0:0c037aff5039 260 } else if (strcmp(command, "GET FFT_SIZE") == 0) {
frankvnk 0:0c037aff5039 261 printf("%d\r\n", FFT_SIZE);
frankvnk 0:0c037aff5039 262 } else if (strcmp(command, "GET SAMPLE_RATE_HZ") == 0) {
frankvnk 0:0c037aff5039 263 printf("%d\r\n", SAMPLE_RATE_HZ);
frankvnk 0:0c037aff5039 264 } else if (strstr(command, "SET SAMPLE_RATE_HZ") != NULL) {
frankvnk 0:0c037aff5039 265 SAMPLE_RATE_HZ = (typeof(SAMPLE_RATE_HZ)) atof(command+(sizeof("SET SAMPLE_RATE_HZ")-1));
frankvnk 0:0c037aff5039 266 } else if (strcmp(command, "GET LEDS_ENABLED") == 0) {
frankvnk 0:0c037aff5039 267 printf("%d\r\n", LEDS_ENABLED);
frankvnk 0:0c037aff5039 268 } else if (strstr(command, "SET LEDS_ENABLED") != NULL) {
frankvnk 0:0c037aff5039 269 LEDS_ENABLED = (typeof(LEDS_ENABLED)) atof(command+(sizeof("SET LEDS_ENABLED")-1));
frankvnk 0:0c037aff5039 270 } else if (strcmp(command, "GET SPECTRUM_MIN_DB") == 0) {
frankvnk 0:0c037aff5039 271 printf("%f\r\n", SPECTRUM_MIN_DB);
frankvnk 0:0c037aff5039 272 } else if (strstr(command, "SET SPECTRUM_MIN_DB") != NULL) {
frankvnk 0:0c037aff5039 273 SPECTRUM_MIN_DB = (typeof(SPECTRUM_MIN_DB)) atof(command+(sizeof("SET SPECTRUM_MIN_DB")-1));
frankvnk 0:0c037aff5039 274 } else if (strcmp(command, "GET SPECTRUM_MAX_DB") == 0) {
frankvnk 0:0c037aff5039 275 printf("%f\r\n", SPECTRUM_MAX_DB);
frankvnk 0:0c037aff5039 276 } else if (strstr(command, "SET SPECTRUM_MAX_DB") != NULL) {
frankvnk 0:0c037aff5039 277 SPECTRUM_MAX_DB = (typeof(SPECTRUM_MAX_DB)) atof(command+(sizeof("SET SPECTRUM_MAX_DB")-1));
frankvnk 0:0c037aff5039 278 } else if (strcmp(command, "GET SLOWDOWN") == 0) {
frankvnk 0:0c037aff5039 279 printf("%d\r\n", SLOWDOWN);
frankvnk 0:0c037aff5039 280 } else if (strstr(command, "SET SLOWDOWN") != NULL) {
frankvnk 0:0c037aff5039 281 SLOWDOWN = (typeof(SLOWDOWN)) atoi(command+(sizeof("SET SLOWDOWN")-1));
frankvnk 0:0c037aff5039 282 }
frankvnk 0:0c037aff5039 283
frankvnk 0:0c037aff5039 284 // Update spectrum display values if sample rate was changed.
frankvnk 0:0c037aff5039 285 if (strstr(command, "SET SAMPLE_RATE_HZ ") != NULL) {
frankvnk 0:0c037aff5039 286 spectrumSetup();
frankvnk 0:0c037aff5039 287 }
frankvnk 0:0c037aff5039 288
frankvnk 0:0c037aff5039 289 // Turn off the LEDs if the state changed.
frankvnk 0:0c037aff5039 290 if (LEDS_ENABLED == 0) {
frankvnk 0:0c037aff5039 291 }
frankvnk 0:0c037aff5039 292 }
frankvnk 0:0c037aff5039 293
frankvnk 0:0c037aff5039 294 void parserLoop()
frankvnk 0:0c037aff5039 295 {
frankvnk 0:0c037aff5039 296 // Process any incoming characters from the serial port
frankvnk 0:0c037aff5039 297 while (pc.readable()) {
frankvnk 0:0c037aff5039 298 char c = pc.getc();
frankvnk 0:0c037aff5039 299 // Add any characters that aren't the end of a command (semicolon) to the input buffer.
frankvnk 0:0c037aff5039 300 if (c != ';') {
frankvnk 0:0c037aff5039 301 c = toupper(c);
frankvnk 0:0c037aff5039 302 strncat(commandBuffer, &c, 1);
frankvnk 0:0c037aff5039 303 } else {
frankvnk 0:0c037aff5039 304 // Parse the command because an end of command token was encountered.
frankvnk 0:0c037aff5039 305 parseCommand(commandBuffer);
frankvnk 0:0c037aff5039 306 // Clear the input buffer
frankvnk 0:0c037aff5039 307 memset(commandBuffer, 0, sizeof(commandBuffer));
frankvnk 0:0c037aff5039 308 }
frankvnk 0:0c037aff5039 309 }
frankvnk 0:0c037aff5039 310 }
yangyulounk 4:5d4bcc4751d7 311 */
frankvnk 0:0c037aff5039 312 ////////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 313 // MAIN FUNCTION
frankvnk 0:0c037aff5039 314 ////////////////////////////////////////////////////////////////////////////////
frankvnk 0:0c037aff5039 315
frankvnk 0:0c037aff5039 316 int main()
frankvnk 0:0c037aff5039 317 {
yangyulounk 4:5d4bcc4751d7 318 cs = 1; // CS initially High
yangyulounk 4:5d4bcc4751d7 319 spi.format(8,0); // 8-bit format, mode 0,0
yangyulounk 4:5d4bcc4751d7 320 spi.frequency(1000000); // SCLK = 1 MHz
yangyulounk 4:5d4bcc4751d7 321 Init_MAX7219(); // Initialize the LED controller
yangyulounk 4:5d4bcc4751d7 322 MMA8451Q acc(SDA, SCL, MMA8451_I2C_ADDRESS);
yangyulounk 4:5d4bcc4751d7 323
yangyulounk 4:5d4bcc4751d7 324 // NVIC_set_all_irq_priorities(1);
yangyulounk 4:5d4bcc4751d7 325 // NVIC_SetPriority(UART0_IRQn, 0);
frankvnk 0:0c037aff5039 326 // Set up serial port.
yangyulounk 4:5d4bcc4751d7 327 // pc.baud (9600);
yangyulounk 4:5d4bcc4751d7 328 // pc.attach(&rxisr);
yangyulounk 4:5d4bcc4751d7 329 /*
frankvnk 0:0c037aff5039 330 #ifndef RGBW_ext
frankvnk 0:0c037aff5039 331 led.invertpwm(1); //On-board KL25Z RGB LED uses common anode.
frankvnk 0:0c037aff5039 332 #endif
yangyulounk 4:5d4bcc4751d7 333 */
frankvnk 0:0c037aff5039 334 // Clear the input command buffer
yangyulounk 4:5d4bcc4751d7 335 // memset(commandBuffer, 0, sizeof(commandBuffer));
yangyulounk 4:5d4bcc4751d7 336
frankvnk 0:0c037aff5039 337 // Initialize spectrum display
yangyulounk 4:5d4bcc4751d7 338
frankvnk 0:0c037aff5039 339 spectrumSetup();
frankvnk 0:0c037aff5039 340
frankvnk 0:0c037aff5039 341 // Begin sampling audio
frankvnk 0:0c037aff5039 342 samplingBegin();
frankvnk 0:0c037aff5039 343
frankvnk 2:035d551759a5 344 // Init arm_ccft_32
frankvnk 2:035d551759a5 345 switch (FFT_SIZE)
frankvnk 2:035d551759a5 346 {
frankvnk 2:035d551759a5 347 case 16:
frankvnk 2:035d551759a5 348 S = & arm_cfft_sR_f32_len16;
frankvnk 2:035d551759a5 349 break;
frankvnk 2:035d551759a5 350 case 32:
frankvnk 2:035d551759a5 351 S = & arm_cfft_sR_f32_len32;
frankvnk 2:035d551759a5 352 break;
frankvnk 2:035d551759a5 353 case 64:
frankvnk 2:035d551759a5 354 S = & arm_cfft_sR_f32_len64;
frankvnk 2:035d551759a5 355 break;
frankvnk 2:035d551759a5 356 case 128:
frankvnk 2:035d551759a5 357 S = & arm_cfft_sR_f32_len128;
frankvnk 2:035d551759a5 358 break;
frankvnk 2:035d551759a5 359 case 256:
frankvnk 2:035d551759a5 360 S = & arm_cfft_sR_f32_len256;
frankvnk 2:035d551759a5 361 break;
frankvnk 2:035d551759a5 362 case 512:
frankvnk 2:035d551759a5 363 S = & arm_cfft_sR_f32_len512;
frankvnk 2:035d551759a5 364 break;
frankvnk 2:035d551759a5 365 case 1024:
frankvnk 2:035d551759a5 366 S = & arm_cfft_sR_f32_len1024;
frankvnk 2:035d551759a5 367 break;
frankvnk 2:035d551759a5 368 case 2048:
frankvnk 2:035d551759a5 369 S = & arm_cfft_sR_f32_len2048;
frankvnk 2:035d551759a5 370 break;
frankvnk 2:035d551759a5 371 case 4096:
frankvnk 2:035d551759a5 372 S = & arm_cfft_sR_f32_len4096;
frankvnk 2:035d551759a5 373 break;
frankvnk 2:035d551759a5 374 }
frankvnk 2:035d551759a5 375
frankvnk 0:0c037aff5039 376 while(1) {
frankvnk 0:0c037aff5039 377 // Calculate FFT if a full sample is available.
frankvnk 0:0c037aff5039 378 if (samplingIsDone()) {
frankvnk 0:0c037aff5039 379 // Run FFT on sample data.
frankvnk 2:035d551759a5 380 // Run FFT on sample data.
frankvnk 2:035d551759a5 381 arm_cfft_f32(S, samples, 0, 1);
frankvnk 0:0c037aff5039 382 // Calculate magnitude of complex numbers output by the FFT.
frankvnk 0:0c037aff5039 383 arm_cmplx_mag_f32(samples, magnitudes, FFT_SIZE);
frankvnk 0:0c037aff5039 384
frankvnk 0:0c037aff5039 385 if (LEDS_ENABLED == 1) {
frankvnk 0:0c037aff5039 386 spectrumLoop();
frankvnk 0:0c037aff5039 387 }
frankvnk 0:0c037aff5039 388
frankvnk 0:0c037aff5039 389 // Restart audio sampling.
frankvnk 0:0c037aff5039 390 samplingBegin();
frankvnk 0:0c037aff5039 391 }
yangyulounk 4:5d4bcc4751d7 392 /*
frankvnk 0:0c037aff5039 393 // Parse any pending commands.
frankvnk 0:0c037aff5039 394 if(commandRecv) {
frankvnk 0:0c037aff5039 395 // pc.attach(NULL);
frankvnk 0:0c037aff5039 396 parseCommand(commandBuffer);
frankvnk 0:0c037aff5039 397 commandRecv = 0;
frankvnk 0:0c037aff5039 398 // Clear the input buffer
frankvnk 0:0c037aff5039 399 memset(commandBuffer, 0, sizeof(commandBuffer));
frankvnk 0:0c037aff5039 400 // pc.attach(&rxisr);
frankvnk 0:0c037aff5039 401 }
yangyulounk 4:5d4bcc4751d7 402 */ }
frankvnk 0:0c037aff5039 403 }