Added "Octave" mode, smoothed spectrogram, created chromagram

Author: connornishijima

src/EMOTISCOPE_FIRMWARE.ino

@@ -48,6 +48,7 @@
 #include "microphone.h" // ........ For gathering audio chunks from the microphone
 #include "vu.h" // ................ Tracks music loudness from moment to moment
 #include "goertzel.h" // .......... GDFT or God Damn Fast Transform is implemented here
+#include "key_detection.h"
 #include "tempo.h" // ............. Comupation of (and syncronization) to the music tempo
 #include "audio_debug.h" // ....... Print audio data over UART
 #include "screensaver.h" // ....... Colorful dots play on screen when no audio is present

src/EMOTISCOPE_FIRMWARE.ino.cpp

@@ -0,0 +1,84 @@
+# 1 "C:\\Users\\conno\\AppData\\Local\\Temp\\tmplnu7fsj8"
+#include <Arduino.h>
+# 1 "C:/Users/conno/Emotiscope/src/EMOTISCOPE_FIRMWARE.ino"
+# 14 "C:/Users/conno/Emotiscope/src/EMOTISCOPE_FIRMWARE.ino"
+#define VERSION_MAJOR ( 1 )
+#define VERSION_MINOR ( 0 )
+#define VERSION_PATCH ( 0 )
+
+
+
+
+
+
+#include <PsychicHttp.h>
+#include <HTTPClient.h>
+#include <ESPmDNS.h>
+#include <Ticker.h>
+#include <WiFi.h>
+#include <esp_dsp.h>
+#include <esp_wifi.h>
+
+
+#include "secrets.h"
+#include "global_defines.h"
+#include "types.h"
+#include "profiler.h"
+#include "sliders.h"
+#include "toggles.h"
+#include "menu_toggles.h"
+#include "filesystem.h"
+#include "configuration.h"
+#include "utilities.h"
+#include "system.h"
+#include "touch.h"
+#include "indicator.h"
+#include "led_driver.h"
+#include "leds.h"
+#include "ui.h"
+#include "microphone.h"
+#include "vu.h"
+#include "goertzel.h"
+#include "key_detection.h"
+#include "tempo.h"
+#include "audio_debug.h"
+#include "screensaver.h"
+#include "standby.h"
+#include "lightshow_modes.h"
+#include "commands.h"
+#include "wireless.h"
+
+
+#include "cpu_core.h"
+#include "gpu_core.h"
+#include "web_core.h"
+
+
+#include "notes.h"
+
+
+#include "secrets.h"
+void loop();
+void loop_gpu(void *param);
+void setup();
+#line 75 "C:/Users/conno/Emotiscope/src/EMOTISCOPE_FIRMWARE.ino"
+void loop() {
+ run_cpu();
+ run_web();
+}
+
+
+void loop_gpu(void *param) {
+ for (;;) {
+  run_gpu();
+ }
+}
+
+
+void setup() {
+
+ init_system();
+
+
+ (void)xTaskCreatePinnedToCore(loop_gpu, "loop_gpu", 8192, NULL, 0, NULL, 0);
+}

src/commands.h

@@ -133,13 +133,13 @@ void parse_command(uint32_t t_now_ms, command com) {
 
 			update_ui(UI_NEEDLE_EVENT, configuration.saturation);
 		}
-		else if (fastcmp(substring, "base_coat")) {
-			// Get base_coat value
+		else if (fastcmp(substring, "background")) {
+			// Get background value
 			load_substring_from_split_index(com.command, 2, substring, sizeof(substring));
 			float setting_value = atof(substring);
-			configuration.base_coat = setting_value;
+			configuration.background = setting_value;
 
-			update_ui(UI_NEEDLE_EVENT, configuration.base_coat);
+			update_ui(UI_NEEDLE_EVENT, configuration.background);
 		}
 		else if (fastcmp(substring, "bass")) {
 			// Get bass value

src/configuration.h

@@ -30,7 +30,7 @@ config configuration = {
 	0.00, // hue_range
 	1.00, // speed
 	1.00, // saturation
-	0.00, // base_coat
+	0.00, // background
 	0.00, // bass
 	0,    // current_mode
 	true, // mirror_mode
@@ -106,7 +106,7 @@ void sync_configuration_to_client() {
 
 	// base_coat
 	memset(config_item_buffer, 0, 120);
-	snprintf(config_item_buffer, 120, "new_config|base_coat|float|%.3f", configuration.base_coat);
+	snprintf(config_item_buffer, 120, "new_config|background|float|%.3f", configuration.background);
 	websocket_handler.sendAll(config_item_buffer);
 
 	// bass

src/cpu_core.h

@@ -27,8 +27,11 @@ void run_cpu() {
 
 		uint32_t processing_start_us = micros();
 
-		// Calculate the magnitude of the currently studied frequency set
+		// Calculate the magnitudes of the currently studied frequency set
 		calculate_magnitudes();  // (goertzel.h)
+		get_chromagram();
+
+		run_key_detection();
 
 		run_vu();
 

src/goertzel.h

@@ -42,7 +42,12 @@ uint16_t max_goertzel_block_size = 0;
 
 volatile bool magnitudes_locked = false;
 
-float magnitudes[NUM_FREQS];
+float spectrogram[NUM_FREQS];
+float chromagram[12];
+
+float spectrogram_smooth[NUM_FREQS] = { 0.0 };
+float spectrogram_average[12][NUM_FREQS];
+uint8_t spectrogram_average_index = 0;
 
 void init_goertzel(uint16_t frequency_slot, float frequency, float bandwidth) {
 	frequencies_musical[frequency_slot].block_size = SAMPLE_RATE / (bandwidth);
@@ -99,8 +104,12 @@ void init_goertzel_constants_musical() {
 void init_window_lookup() {
 	for (uint16_t i = 0; i < 2048; i++) {
 		float ratio = i / 4095.0;
-		float weighing_factor = 0.54 * (1.0 - cos(TWOPI * ratio));
-		//float weighing_factor = 0.3635819 - (0.4891775 * (cos(TWOPI * ratio))) + (0.1365995 * (cos(FOURPI * ratio))) - (0.0106411 * (cos(SIXPI * ratio)));
+
+		// Hamming window
+		//float weighing_factor = 0.54 * (1.0 - cos(TWOPI * ratio));
+
+		// Blackman-Harris window
+		float weighing_factor = 0.3635819 - (0.4891775 * (cos(TWOPI * ratio))) + (0.1365995 * (cos(FOURPI * ratio))) - (0.0106411 * (cos(SIXPI * ratio)));
 
 		window_lookup[i] = weighing_factor;
 		window_lookup[4095 - i] = weighing_factor;
@@ -288,7 +297,22 @@ void calculate_magnitudes() {
 		for (uint16_t i = 0; i < NUM_FREQS; i++) {
 			// Apply the auto-scaler
 			frequencies_musical[i].magnitude = clip_float(magnitudes_smooth[i] * autoranger_scale);
-			magnitudes[i] = frequencies_musical[i].magnitude;
+			spectrogram[i] = frequencies_musical[i].magnitude;
+		}
+
+		spectrogram_average_index++;
+		if(spectrogram_average_index >= 12){
+			spectrogram_average_index = 0;
+		}
+
+		for(uint16_t i = 0; i < NUM_FREQS; i++){
+			spectrogram_average[spectrogram_average_index][i] = spectrogram[i];
+
+			spectrogram_smooth[i] = 0;
+			for(uint16_t a = 0; a < 12; a++){
+				spectrogram_smooth[i] += spectrogram_average[a][i];
+			}
+			spectrogram_smooth[i] /= 12.0;
 		}
 
 		magnitudes_locked = false;
@@ -299,4 +323,21 @@ void start_noise_calibration() {
 	Serial.println("Starting noise cal...");
 	memset(noise_spectrum, 0, sizeof(float) * NUM_FREQS);
 	noise_calibration_active_frames_remaining = NOISE_CALIBRATION_FRAMES;
+}
+
+void get_chromagram(){
+	memset(chromagram, 0, sizeof(float) * 12);
+
+	float max_val = 0.2;
+	for(uint16_t i = 0; i < 60; i++){
+		chromagram[ i % 12 ] += (spectrogram_smooth[i] / 5.0);
+
+		max_val = max(max_val, chromagram[ i % 12 ]);
+	}
+
+	float auto_scale = 1.0 / max_val;
+
+	for(uint16_t i = 0; i < 12; i++){
+		chromagram[i] *= auto_scale;
+	}
 }

src/gpu_core.h

@@ -44,7 +44,7 @@ void run_gpu() {
 	// If silence is detected, show a blue debug LED
 	// leds[NUM_LEDS - 1] = add(leds[NUM_LEDS - 1], {0.0, 0.0, silence_level});
 
-	apply_base_coat();
+	apply_background();
 
 	// Apply an incandescent LUT to reduce harsh blue tones
 	apply_incandescent_filter(configuration.incandescent_filter);  // (leds.h)
@@ -88,6 +88,9 @@ void run_gpu() {
 
 	clip_leds();  // (leds.h)
 
+	// Apply white balance
+	multiply_CRGBF_array_by_LUT( leds, WHITE_BALANCE, NUM_LEDS );
+
 	// Quantize the image buffer with dithering, 
 	// output to the 8-bit LED strand
 	transmit_leds();

src/key_detection.h

@@ -0,0 +1,62 @@
+uint16_t musical_keys[24] = {
+    // Major scales
+    0b000010101101, // C major
+    0b000011010110, // C# major
+    0b000010110101, // D major
+    0b000010101011, // Eb major
+    0b000010110101, // E major
+    0b000010101101, // F major
+    0b000011010101, // F# major
+    0b000010101110, // G major
+    0b000011010101, // G# major
+    0b000010101011, // A major
+    0b000010110110, // Bb major
+    0b000010101101, // B major
+
+    // Minor scales
+    0b000010110110, // C minor
+    0b000010101101, // C# minor
+    0b000011011010, // D minor
+    0b000010110101, // Eb minor
+    0b000010101011, // E minor
+    0b000010110110, // F minor
+    0b000010101101, // F# minor
+    0b000011010110, // G minor
+    0b000010101101, // G# minor
+    0b000011010101, // A minor
+    0b000010101110, // Bb minor
+    0b000011010101  // B minor
+};
+
+float scale_confidence[24] = {
+	0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, // Major
+	0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0  // Minor
+};
+
+void run_key_detection(){
+	float max_confidence = 0.01;
+	for(uint16_t i = 0; i < 24; i++){
+		float total_difference = 0.00000001;
+
+		for(uint16_t n = 0; n < 12; n++){
+			float scale_note_value = (float)bitRead( musical_keys[i], n );
+			float chromagram_value = chromagram[n];
+
+			total_difference += fabs(scale_note_value - chromagram_value);
+		}
+
+		scale_confidence[i] = (total_difference / 5.0);
+
+		max_confidence = max(max_confidence, scale_confidence[i]);
+	}
+
+	float auto_scale = 1.0 / max_confidence;
+
+	for(uint16_t i = 0; i < 24; i++){
+		float confidence = scale_confidence[i] * auto_scale;
+		CRGBF color = hsv(0.0, 1.0, confidence*confidence);
+
+		//leds[(i << 1) + 0] = color;
+		//leds[(i << 1) + 1] = color;
+	}
+}

src/leds.h

@@ -18,6 +18,8 @@
 
 #define MAX_DOTS 192 
 
+CRGBF WHITE_BALANCE = { 1.0, 0.75, 0.60 };
+
 typedef enum {
 	UI_1, UI_2, UI_3, UI_4, UI_5, UI_6, UI_7, UI_8, UI_9, UI_10,
 	UI_NEEDLE,
@@ -41,7 +43,7 @@ CRGBF leds_smooth[NUM_LEDS];
 
 float rendered_debug_value = 0.0;
 
-CRGBF incandescent_lookup = {1.0000, 0.4453, 0.1562};
+CRGBF incandescent_lookup = {1.0000*1.0000, 0.4453*0.4453, 0.1562*0.1562};
 
 float note_colors[12] = {0.0000, 0.0833, 0.1666, 0.2499, 0.3333, 0.4166,
 						 0.4999, 0.5833, 0.6666, 0.7499, 0.8333, 0.9166};
@@ -471,36 +473,36 @@ void apply_brightness() {
 	scale_CRGBF_array_by_constant(leds, brightness_val*brightness_val, NUM_LEDS);
 }
 
-void apply_base_coat(){
-	if(configuration.base_coat > 0.01){
-		float base_coat_level = configuration.base_coat * 0.20; // Max 20% brightness
+void apply_background(){
+	if(configuration.background > 0.01){
+		float background_level = configuration.background * 0.20; // Max 20% brightness
 
 		if(configuration.mirror_mode == false){
-			float base_coat_inv = (1.0-base_coat_level);
+			float background_inv = (1.0-background_level);
 			for(uint16_t i = 0; i < NUM_LEDS; i++){
 				float progress = float(i) / NUM_LEDS;
-				CRGBF base_coat_color = hsv(configuration.hue + (configuration.hue_range * progress), configuration.saturation, base_coat_level*base_coat_level);
-				leds[i].r = leds[i].r * base_coat_inv + base_coat_color.r;
-				leds[i].g = leds[i].g * base_coat_inv + base_coat_color.g;
-				leds[i].b = leds[i].b * base_coat_inv + base_coat_color.b;
+				CRGBF background_color = hsv(configuration.hue + (configuration.hue_range * progress), configuration.saturation, background_level*background_level);
+				leds[i].r = leds[i].r * background_inv + background_color.r;
+				leds[i].g = leds[i].g * background_inv + background_color.g;
+				leds[i].b = leds[i].b * background_inv + background_color.b;
 			}
 		}
 		else{
-			float base_coat_inv = (1.0-base_coat_level);
+			float background_inv = (1.0-background_level);
 			for(uint16_t i = 0; i < (NUM_LEDS >> 1); i++){
 				float progress = float(i) / (NUM_LEDS>>1);
-				CRGBF base_coat_color = hsv(configuration.hue + (configuration.hue_range * progress), configuration.saturation, base_coat_level*base_coat_level);
+				CRGBF background_color = hsv(configuration.hue + (configuration.hue_range * progress), configuration.saturation, background_level*background_level);
 
 				int16_t left_index = 63-i;
 				int16_t right_index = 64+i;
 
-				leds[left_index].r = leds[left_index].r * base_coat_inv + base_coat_color.r;
-				leds[left_index].g = leds[left_index].g * base_coat_inv + base_coat_color.g;
-				leds[left_index].b = leds[left_index].b * base_coat_inv + base_coat_color.b;
+				leds[left_index].r = leds[left_index].r * background_inv + background_color.r;
+				leds[left_index].g = leds[left_index].g * background_inv + background_color.g;
+				leds[left_index].b = leds[left_index].b * background_inv + background_color.b;
 
-				leds[right_index].r = leds[right_index].r * base_coat_inv + base_coat_color.r;
-				leds[right_index].g = leds[right_index].g * base_coat_inv + base_coat_color.g;
-				leds[right_index].b = leds[right_index].b * base_coat_inv + base_coat_color.b;
+				leds[right_index].r = leds[right_index].r * background_inv + background_color.r;
+				leds[right_index].g = leds[right_index].g * background_inv + background_color.g;
+				leds[right_index].b = leds[right_index].b * background_inv + background_color.b;
 			}
 		}
 	}

src/lightshow_modes.h

@@ -12,6 +12,7 @@
 
 // The individual drawing functions for each mode are defined in these files:
 #include "lightshow_modes/spectrum.h"
+#include "lightshow_modes/octave.h"
 #include "lightshow_modes/metronome.h"
 #include "lightshow_modes/spectrum_beat.h"
 #include "lightshow_modes/hype.h"
@@ -25,10 +26,11 @@
 lightshow_mode lightshow_modes[] = {
 	{ "Analog",          &draw_analog        }, // 0
 	{ "Spectrum",        &draw_spectrum      }, // 1
-	{ "Metronome",       &draw_metronome     }, // 2
-	{ "Spectrum + Beat", &draw_spectrum_beat }, // 3
-	{ "Hype",            &draw_hype          }, // 4
-	{ "Bloom",           &draw_bloom         }, // 5
+	{ "Octave",          &draw_octave        }, // 2
+	{ "Metronome",       &draw_metronome     }, // 3
+	{ "Spectrum + Beat", &draw_spectrum_beat }, // 4
+	{ "Hype",            &draw_hype          }, // 5
+	{ "Bloom",           &draw_bloom         }, // 6
 
 	//{ "Debug",           &draw_debug         },
 };