rocktaves.ino

/* File: Rocktaves
 *
 * By: Andrew Tuline
 *
 * Date: June, 2021
 *
 * This is just a proof of concept sketch that uses an ESP32 running Arduino C, along with the arduinoFFT and FastLED libraries. It creates consistent colours for the same note in different octaves, with
 * a range of C3 (or 133Hz) to about B7 (at 3951Hz). For example, C3 could be a 'red', as would be C4, C5, C6 and C7.
 *
 * For the C3 octave, we see that the frequency range is:
 *
 * C3 = 131Hz
 * B3 = 247Hz
 *
 * Looking at a notes/frequency table, we also see that octaves are 'double' in frequency from the next one down. As a result, let's divide the resultant loudest frequency value by 2 while the
 * resultant value > 247. We'll call that 'folding the octaves'. Probably isn't, but that's what I'll call it anyways.
 *
 * Since the starting frequency is 131Hz for C3, and we've already 'folded' down our FFT calculated frequency value to fit in the C3 octave, let's subtract 131 from the resultant value. The absolute value of
 * that should range between 0 and 116 (or about 247-131). Let's multiply that by a fudge factor so that the resultant value ranges from 0 to 255, which we can now use as an index into an 8 bit colour range.
 *
 * As for the volume, let's find min and max values and scale accordingly. Turns out the max value goes up to about 65535, so we'll divide by 256 and get an 8 bit volume value. We'll need to
 * squelch out background noise though. I ended up digitizing the resultant brightness so that LED's are ON or OFF, with no in between.
 *
 * Caveat: With the exception of the FFT library, these are just simple calculations. I doubt this would stand up to rigorous testing. Certainly, the DSP dudes would be scoffing.
 *
 *
 * Reference:
 *
 * https://www.szynalski.com/tone-generator/
 * https://pages.mtu.edu/~suits/notefreqs.html
 *
 *
 * Hardware used:
 *
 * ESP32 (LOLIN D32)
 * INMP401 or MAX9814 or MAX4466 microphones  (and NOT, I repeat NOT sound sensors)
 * WS2812 addressable LED's
 *
 *
 * Libraries used:
 *
 * Arduino FFT         https://github.com/kosme/arduinoFFT
 * FastLED             https://github.com/FastLED/FastLED
 *
 */


#include <FastLED.h>
#include <arduinoFFT.h>

#define MIC_PIN    36                                       // Analog port for microphone.
#define DC_OFFSET  500                                      // DC offset in mic signal. You may need to change this. I have not added an 'auto-leveller' to this proof of concept routine.

#define LED_DT 2
#define NUM_LEDS 30

uint8_t max_bright = 128;

struct CRGB leds[NUM_LEDS];

arduinoFFT FFT = arduinoFFT();                                // Create FFT object.

const uint16_t samples = 512;                                  // This value MUST ALWAYS be a power of 2.
const double samplingFrequency = 10240;                        // Keep it <10000 due to sampling method used.

unsigned int sampling_period_us;
unsigned long microseconds;

double vReal[samples];                                        // These are the input and output vectors. Input vectors receive computed results from FFT.
double vImag[samples];


void setup() {
  Serial.begin(115200);
  LEDS.addLeds<WS2812, LED_DT, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(max_bright);
  sampling_period_us = round(1000000*(1.0/samplingFrequency));
} // setup()


void loop() {

  fadeToBlackBy(leds,NUM_LEDS,64);

  microseconds = micros();                                            // Sampling timer.

  for(int i=0; i<samples; i++) {                                      // We could create a task for core 0, but I'm too lazy to do that here.
      vReal[i] = analogRead(MIC_PIN) - DC_OFFSET;                     // Sampling from ADC. That offset is a PITA though.
      vImag[i] = 0;
      while(micros() - microseconds < sampling_period_us){ }
        microseconds += sampling_period_us;
  } // for

  FFT.Windowing(vReal, samples, FFT_WIN_TYP_HAMMING, FFT_FORWARD);    // Weigh data.
  FFT.Compute(vReal, vImag, samples, FFT_FORWARD);                    // Compute FFT.
  FFT.ComplexToMagnitude(vReal, vImag, samples);                      // Compute magnitudes.

  double freq;
  double vol;

  FFT.MajorPeak(vReal, samples, samplingFrequency, &freq, &vol);

  double frTemp = freq;
  uint8_t octCount = 0;             // Octave counter.
  uint8_t volTemp = 0;
  if (vol > 500) volTemp = 255;    // We need to squelch out the background noise.

  while ( frTemp > 249 ) {
    octCount++;                     // This should go up to 5.
    frTemp = frTemp/2;
  }
    frTemp -=132;                    // This should give us a base musical note of C3
    frTemp = abs(frTemp * 2.1);       // Fudge factors to compress octave range starting at 0 and going to 255;

    Serial.print(frTemp); Serial.print("\t"); Serial.print(volTemp); Serial.print("\t");Serial.print(octCount); Serial.print("\t"); Serial.println(vol);
    leds[beatsin8(8+octCount*4,0,NUM_LEDS-1,0,octCount*8)] = CHSV((uint8_t)frTemp,255,volTemp);                 // Back and forth with different frequencies and phase shift depending on current octave.

  FastLED.show();
} // loop()