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