Add RandomNoteCV module

Author: aaronstatic

README.md

@@ -27,7 +27,18 @@ If the chord is a triad (3 notes), the 4th 1v/oct output will be the bass note +
 ## ScaleCV
 ![ChordCV](https://i.imgur.com/GHhsEgZ.jpg "ScaleCV")
 
-Generates a scale and outputs a polyphonic 1v/oct signal with 8 notes.
+Generates a scale and outputs a polyphonic 1v/oct signal with 7 notes.
 
 * **Root**: Chooses the root note (1v/oct, input range -4v to 4v)
 * **Mode**: Chooses the scale mode (input range -4v to 4v)
+
+## RandomNoteCV
+![RandomNoteCV](https://i.imgur.com/5rybov5.jpg "RandomNoteCV")
+
+Generates a random note when triggered within the selected range and outputs a 1v/oct signal. If a polyphonic input is connected the note is selected from the provided notes (they are quantized).
+
+This module is best used when combined with the above modules.
+
+* **Trigger**: Triggers a new note to be selected
+* **Root Bias**: How often should the root (first) note be forced (0-100%, input range -4v to 4v, only valid if polyphonic input is connected)
+* **Range**: Range in octaves (Minimum=1, input range -4v to 4v)

plugin.json

@@ -24,6 +24,12 @@
         "name": "ScaleCV",
         "description": "Generates a scale",
         "tags": ["Polyphonic","Tuner"]
+    },
+    {
+        "slug": "RandomNoteCV",
+        "name": "RandomNoteCV",
+        "description": "Generates a random note when triggered",
+        "tags": ["Polyphonic","Tuner"]
     }
   ]
 }

res/RandomNoteCV.svg

@@ -0,0 +1,183 @@
+#include "plugin.hpp"
+#include "musiclib.hpp"
+
+struct RandomNoteCV : Module {
+	enum ParamIds {
+		TRIGGER_PARAM,
+		BIAS_PARAM,
+		RANGE_PARAM,
+		NUM_PARAMS
+	};
+	enum InputIds {
+		POLY_INPUT,
+		TRIGGER_INPUT,
+		BIAS_INPUT,
+		RANGE_INPUT,
+		NUM_INPUTS
+	};
+	enum OutputIds {
+		NOTE_OUTPUT,
+		NUM_OUTPUTS
+	};
+	enum LightIds {
+		TRIGGER_LIGHT,
+		NUM_LIGHTS
+	};
+
+	Trigger randomTrigger;
+	int playing_note = 48;
+	float playing_voltage = note_to_voltage(playing_note);
+	float triggerLight = 0.0f;
+	float range = 1.0f;
+	float bias = 0.5f;
+	double sampleTime;
+	float polyNotes_v[16] = {0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f,0.0f};
+	int polyNotes[16] = {48,48,48,48,48,48,48,48,48,48,48,48,48,48,48,48};
+	int polyChannels = 0;
+
+	bool hasPoly = false;
+
+	RefreshCounter refresh;
+
+	RandomNoteCV() {
+		config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS);
+		configButton(TRIGGER_PARAM);
+		configParam(BIAS_PARAM, -4.0, 4.0, 0.0, "Root Bias");
+		configParam(RANGE_PARAM, -4.0, 4.0, -3.0, "Range");
+
+		configInput(POLY_INPUT, "1V/oct Poly");
+		configInput(TRIGGER_INPUT, "Trigger");
+		configInput(BIAS_INPUT, "Root Bias");
+		configInput(RANGE_INPUT, "Range");
+
+		configOutput(NOTE_OUTPUT, "1v/oct");
+	}
+
+	void process(const ProcessArgs& args) override;
+};
+
+void RandomNoteCV::process(const ProcessArgs &args){
+	sampleTime = 1.0 / (double)(APP->engine->getSampleRate());
+
+	if (refresh.processInputs()) {
+		if(inputs[POLY_INPUT].isConnected()){
+			hasPoly = true;
+			polyChannels = inputs[POLY_INPUT].getChannels();
+			for (int c = 0; c < 16; c++) {
+				float v = inputs[POLY_INPUT].getVoltage(c);
+				polyNotes_v[c] = v;
+				polyNotes[c] = voltage_to_note_int(v);
+			}
+		}else{
+			hasPoly = false;
+		}
+
+		float range_v = params[RANGE_PARAM].getValue();
+		if(inputs[RANGE_INPUT].isConnected()){
+			range_v = inputs[RANGE_INPUT].getVoltage();
+		}
+		range = 1.0f + (range_v + 4.0f);
+
+		float bias_v = params[BIAS_PARAM].getValue();
+		if(inputs[BIAS_INPUT].isConnected()){
+			bias_v = inputs[BIAS_INPUT].getVoltage();
+		}
+		bias = (bias_v + 4.0f) / 8.0f;
+	}
+
+	if (randomTrigger.process(inputs[TRIGGER_INPUT].getVoltage() + params[TRIGGER_PARAM].getValue())) {
+		triggerLight = 1.0f;
+		//Select a new note
+		if(!hasPoly){
+			playing_note = 36 + (int)round(random::uniform() * (range * 12.0f));
+			playing_voltage = note_to_voltage(playing_note);
+		}else{
+			float root_octave = round(polyNotes_v[0]) + 4.0f;
+			int index = (int)round(random::uniform() * (float)polyChannels);
+			if(bias > 0.0f && random::uniform() < bias){
+				index = 0;
+			}
+			int octave = (int)root_octave + (int)round(random::uniform() * range);
+			playing_note = polyNotes[index] + (12 * octave);
+			playing_voltage = note_to_voltage(playing_note);
+		}
+	}
+
+	// lights
+	if (refresh.processLights()) {
+		// Trigger light
+		lights[TRIGGER_LIGHT].setSmoothBrightness(triggerLight, (float)sampleTime * (RefreshCounter::displayRefreshStepSkips >> 2));
+		triggerLight = 0.0f;
+	}
+
+	outputs[NOTE_OUTPUT].setVoltage(playing_voltage);
+}
+
+
+struct RandomNoteCVWidget : ModuleWidget {
+	struct NoteDisplayWidget : TransparentWidget {
+		RandomNoteCV* module;
+		std::shared_ptr<Font> font;
+		char text[2];
+
+		NoteDisplayWidget(Vec _pos, Vec _size, RandomNoteCV* _module) {
+			box.size = _size;
+			box.pos = _pos.minus(_size.div(2));
+			module = _module;
+			font = APP->window->loadFont(asset::plugin(pluginInstance, "res/fonts/PixelOperator.ttf"));
+		}
+
+		void draw(const DrawArgs &args) override {
+			NVGcolor textColor = prepareDisplay(args.vg, &box, 22);
+			nvgFontFaceId(args.vg, font->handle);
+			nvgTextLetterSpacing(args.vg, -1.5);
+			nvgTextAlign(args.vg, NVG_ALIGN_CENTER);
+
+			Vec textPos = Vec(box.size.x/2, 21.0f);
+			nvgFillColor(args.vg, textColor);
+
+			if (module != NULL){
+				get_note_name(module->playing_note,text);
+			}else{
+				snprintf(text, 1, " ");
+			}
+
+			nvgText(args.vg, textPos.x, textPos.y, text, NULL);
+		}
+
+	};
+
+	RandomNoteCVWidget(RandomNoteCV* module) {
+		setModule(module);
+		setPanel(APP->window->loadSvg(asset::plugin(pluginInstance, "res/RandomNoteCV.svg")));
+
+		addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, 0)));
+		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, 0)));
+		addChild(createWidget<ScrewSilver>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));
+		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 2 * RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));
+
+		const int centerX = box.size.x / 2;
+
+		NoteDisplayWidget* display = new NoteDisplayWidget(Vec(centerX, 55), Vec(76, 29), module);
+		addChild(display);
+
+		const int offsetXL = 40;
+
+		addInput(createInputCentered<PJ301MPort>(Vec(centerX, 95), module, RandomNoteCV::POLY_INPUT));
+
+		addParam(createParamCentered<LEDBezel>(Vec(centerX,155), module, RandomNoteCV::TRIGGER_PARAM));
+		addChild(createLightCentered<LEDBezelLight<GreenLight>>(Vec(centerX,155), module, RandomNoteCV::TRIGGER_LIGHT));
+		addInput(createInputCentered<PJ301MPort>(Vec(centerX - offsetXL, 155), module, RandomNoteCV::TRIGGER_INPUT));
+
+		addParam(createParamCentered<Rogan2PWhite>(Vec(centerX,200), module, RandomNoteCV::BIAS_PARAM));
+		addInput(createInputCentered<PJ301MPort>(Vec(centerX - offsetXL, 200), module, RandomNoteCV::BIAS_INPUT));
+
+		addParam(createParamCentered<Rogan2PWhite>(Vec(centerX,245), module, RandomNoteCV::RANGE_PARAM));
+		addInput(createInputCentered<PJ301MPort>(Vec(centerX - offsetXL, 245), module, RandomNoteCV::RANGE_INPUT));
+
+		addOutput(createOutputCentered<PJ301MPort>(Vec(centerX, 330), module, RandomNoteCV::NOTE_OUTPUT));
+	}
+};
+
+
+Model* modelRandomNoteCV = createModel<RandomNoteCV, RandomNoteCVWidget>("RandomNoteCV");

src/RandomNoteCV.cpp

@@ -58,8 +58,8 @@ void ScaleCV::process(const ProcessArgs &args){
 	//Make the scale
 	struct scale s = get_scale(root_note, mode);
 
-	outputs[POLY_OUTPUT].setChannels(8);
-	for(int t=0; t<8; t++){
+	outputs[POLY_OUTPUT].setChannels(7);
+	for(int t=0; t<7; t++){
 		outputs[POLY_OUTPUT].setVoltage(note_to_voltage(s.notes[t]),t);
 	}
 }

src/ScaleCV.cpp

@@ -162,6 +162,10 @@ void get_chord_name(int root_semi, int chord_type, bool inverted, int bass_note,
     sprintf(text, "%s%s%s", NOTE_NAMES[root_semi], CHORD_TYPE_NAMES[chord_type], inv);
 }
 
+void get_note_name(int note, char* text) {
+    sprintf(text, "%s", NOTE_NAMES[note % 12]);
+}
+
 //Scales
 static const char * MODE_NAMES[] = {
   "",
@@ -178,13 +182,13 @@ void get_scale_name(int root_semi, int mode, char* text) {
 }
 
 static const int MODE_DEGREES[7][7] = {
-    {2,2,1,2,2,2,1}, //Major (Ionian)
-    {2,1,2,2,2,1,2}, //Dorian
-    {1,2,2,2,1,2,2}, //Phrygian
-    {2,2,2,1,2,2,1}, //Lydian
-    {2,2,1,2,2,1,2}, //Mixolydian
-    {2,1,2,2,1,2,2}, //Minor (Aeolian)
-    {1,2,2,1,2,2,2}, //Locrian
+    {2,2,1,2,2,2}, //Major (Ionian)
+    {2,1,2,2,2,1}, //Dorian
+    {1,2,2,2,1,2}, //Phrygian
+    {2,2,2,1,2,2}, //Lydian
+    {2,2,1,2,2,1}, //Mixolydian
+    {2,1,2,2,1,2}, //Minor (Aeolian)
+    {1,2,2,1,2,2}, //Locrian
 };
 
 struct scale get_scale(int root_note, int mode){
@@ -196,7 +200,7 @@ struct scale get_scale(int root_note, int mode){
     int current_note = root_note;
 
     int t;
-    for(t=1; t<8; t++){
+    for(t=1; t<7; t++){
         current_note += degrees[t-1];
         return_scale.notes[t] = current_note;
     }

src/musiclib.cpp

@@ -1,10 +1,57 @@
 #pragma once
+#include "rack.hpp"
+
+using namespace rack;
 
 //Note <-> Voltage conversion
 float note_to_voltage(int v);
 float voltage_to_note(float value);
 int voltage_to_note_int(float value);
 
+//DSP Stuff (credit Marc Boule / Impromptu Modular)
+struct Trigger : dsp::SchmittTrigger {
+	// implements a 0.1V - 1.0V SchmittTrigger (see include/dsp/digital.hpp) instead of
+	//   calling SchmittTriggerInstance.process(math::rescale(in, 0.1f, 1.f, 0.f, 1.f))
+	bool process(float in) {
+		if (state) {
+			// HIGH to LOW
+			if (in <= 0.1f) {
+				state = false;
+			}
+		}
+		else {
+			// LOW to HIGH
+			if (in >= 1.0f) {
+				state = true;
+				return true;
+			}
+		}
+		return false;
+	}
+};
+
+struct RefreshCounter {
+	// Note: because of stagger, and asyncronous dataFromJson, should not assume this processInputs() will return true on first run
+	// of module::process()
+	static const unsigned int displayRefreshStepSkips = 256;
+	static const unsigned int userInputsStepSkipMask = 0xF;// sub interval of displayRefreshStepSkips, since inputs should be more responsive than lights
+	// above value should make it such that inputs are sampled > 1kHz so as to not miss 1ms triggers
+
+	unsigned int refreshCounter = (random::u32() % displayRefreshStepSkips);// stagger start values to avoid processing peaks when many Geo and Impromptu modules in the patch
+
+	bool processInputs() {
+		return ((refreshCounter & userInputsStepSkipMask) == 0);
+	}
+	bool processLights() {// this must be called even if module has no lights, since counter is decremented here
+		refreshCounter++;
+		bool process = refreshCounter >= displayRefreshStepSkips;
+		if (process) {
+			refreshCounter = 0;
+		}
+		return process;
+	}
+};
+
 //Chords
 struct chord {
     int num_notes;
@@ -16,7 +63,10 @@ void get_chord_name(int root_semi, int chord_type, bool inverted, int bass_note,
 
 //Scales
 struct scale {
-    int notes[8];
+    int notes[7];
 };
 void get_scale_name(int root_semi, int mode, char* text);
 struct scale get_scale(int root_note, int mode);
+
+//Notes
+void get_note_name(int note, char* text);

src/musiclib.hpp

@@ -11,6 +11,7 @@ void init(Plugin* p) {
 	// p->addModel(modelMyModule);
 	p->addModel(modelChordCV);
 	p->addModel(modelScaleCV);
+	p->addModel(modelRandomNoteCV);
 
 	// Any other plugin initialization may go here.
 	// As an alternative, consider lazy-loading assets and lookup tables when your module is created to reduce startup times of Rack.

src/plugin.cpp

@@ -11,6 +11,7 @@ extern Plugin* pluginInstance;
 // extern Model* modelMyModule;
 extern Model* modelChordCV;
 extern Model* modelScaleCV;
+extern Model* modelRandomNoteCV;
 
 static const int displayAlpha = 23;
 NVGcolor prepareDisplay(NVGcontext *vg, Rect *box, int fontSize);