add module

Author: orderandchaos-at-work

claude.md

@@ -50,7 +50,7 @@ Software Eurorack modular synthesizer. Modules pass voltages; sound only at outp
 
 **Self-contained modules**: Each module folder contains DSP + UI definition in one file. Modules export metadata, `createDSP()` factory, and declarative `ui` config.
 
-**Available modules**: `clk` (clock) · `div` (divider) · `lfo` · `nse` (noise) · `sh` (sample&hold) · `quant` (quantizer) · `arp` (arpeggiator) · `seq` (sequencer) · `euclid` (euclidean rhythm) · `logic` (AND/OR gates) · `mult` (signal splitter) · `vco` · `vcf` · `fold` (wavefolder) · `ring` (ring mod) · `rnd` (random) · `envf` (envelope follower) · `func` (function generator) · `adsr` · `vca` · `atten` (attenuverter) · `slew` · `mix` · `dly` (delay) · `verb` (reverb) · `chorus` · `phaser` · `flanger` · `crush` (bit crusher) · `db` (VU meter) · `pwm` (pulse width mod) · `turing` (random looping seq) · `ochd` (8x LFO) · `kick` · `snare` · `hat` · `scope` · `out`
+**Available modules**: `clk` (clock) · `div` (divider) · `lfo` · `nse` (noise) · `sh` (sample&hold) · `quant` (quantizer) · `arp` (arpeggiator) · `seq` (sequencer) · `euclid` (euclidean rhythm) · `logic` (AND/OR gates) · `mult` (signal splitter) · `vco` · `vcf` · `fold` (wavefolder) · `ring` (ring mod) · `rnd` (random) · `envf` (envelope follower) · `func` (function generator) · `adsr` · `vca` · `atten` (attenuverter) · `slew` · `mix` · `dly` (delay) · `verb` (reverb) · `chorus` · `phaser` · `flanger` · `crush` (bit crusher) · `db` (VU meter) · `pwm` (pulse width mod) · `turing` (random looping seq) · `ochd` (8x LFO) · `cmp2` (window comparator) · `kick` · `snare` · `hat` · `scope` · `out`
 
 ## Project Structure
 
@@ -262,6 +262,7 @@ export default {
 | pwm | in, pwmCV | out, inv |
 | turing | clock, lockCV | cv, pulse |
 | ochd | rateCV | out1, out2, out3, out4, out5, out6, out7, out8 |
+| cmp2 | in1, in2, shiftCV1, sizeCV1, shiftCV2, sizeCV2 | out1, not1, out2, not2, and, or, xor, ff |
 | kick | trigger, pitchCV, decayCV, toneCV | out |
 | snare | trigger, toneCV, decayCV | out |
 | hat | trigger, decayCV | out |

node_modules/.vite/vitest/results.json

@@ -0,0 +1,206 @@
+# Compare 2 - Dual Window Comparator
+
+Based on Joranalogue Audio Design Compare 2.
+
+## Overview
+
+A dual window comparator that checks if an input voltage falls between two threshold levels (the "window"). Unlike a simple comparator that triggers above a single threshold, a window comparator activates when the input is within a defined range. Includes a logic section combining both comparators' outputs.
+
+## Sources
+
+- [Joranalogue Official Product Page](https://joranalogue.com/products/compare-2)
+- [ModularGrid](https://modulargrid.net/e/joranalogue-audio-design-compare-2)
+- [Waveform Magazine Review](https://waveformmagazine.com/waveform-reviews/joranalogue-compare-2/)
+- [Elevator Sound](https://www.elevatorsound.com/product/joranalogue-compare-2-eurorack-dual-comparator-module/)
+- [Manua.ls Manual](https://www.manua.ls/joranalogue/compare-2/manual)
+
+## Specifications
+
+- **Width**: 8HP
+- **Depth**: 30mm
+- **Power**: +12V: 20mA, -12V: 15mA
+
+## How Window Comparator Works
+
+A window comparator has two thresholds: a lower and an upper. The output activates when the input voltage is between these thresholds (inside the "window").
+
+```
+Upper threshold ----+----
+                    |    | Window (output HIGH when input is here)
+Lower threshold ----+----
+```
+
+### Shift and Size Parameters
+
+The window is defined by two parameters:
+- **Shift**: Moves the entire window up or down (sets the center point)
+- **Size**: Sets the distance between upper and lower thresholds (window width)
+
+```
+Upper threshold = Shift + (Size / 2)
+Lower threshold = Shift - (Size / 2)
+```
+
+Example with Shift=0V, Size=2V:
+- Upper threshold = +1V
+- Lower threshold = -1V
+- Output HIGH when input is between -1V and +1V
+
+## Controls
+
+### Per Comparator (x2)
+
+| Control | Function | Range |
+|---------|----------|-------|
+| Shift knob | Center of detection window | -5V to +5V (0V at center) |
+| Size knob | Width of detection window | 0V to 10V |
+| Shift CV | Modulates shift | Added to knob |
+| Size CV | Modulates size | Added to knob |
+
+### Inputs
+
+| Input | Function |
+|-------|----------|
+| In (left) | Signal input for comparator 1 |
+| In (right) | Signal input for comparator 2 (normalled from left) |
+| Shift CV (left) | CV for shift 1 (normalled to right) |
+| Size CV (left) | CV for size 1 (normalled to right) |
+| Shift CV (right) | CV for shift 2 |
+| Size CV (right) | CV for size 2 |
+
+### Outputs
+
+| Output | Function |
+|--------|----------|
+| Out (per comparator) | Gate when input is INSIDE window (10V in our implementation) |
+| Not (per comparator) | Gate when input is OUTSIDE window (inverted) |
+| AND | Gate when BOTH comparators' Out are HIGH |
+| OR | Gate when EITHER comparator's Out is HIGH |
+| XOR | Gate when exactly ONE comparator's Out is HIGH |
+| FF (Flip-Flop) | Toggles on rising edge of XOR output |
+
+**Note**: Real Joranalogue outputs +5V gates; our implementation uses 10V to match system standard (0/10V gates).
+
+## LED Behavior
+
+Three-color LEDs per comparator:
+- **Blue** (state=0): Input voltage is BELOW the window
+- **Red** (state=1): Input voltage is ABOVE the window
+- **White** (state=0.5): Input voltage is INSIDE the window
+- **Off** (state=-1): Window size is negative AND signal is within this "negative window"
+
+Logic section has LEDs for AND, OR, XOR, FF outputs (on/off only).
+
+## Algorithm
+
+### Window Comparator Logic
+
+```javascript
+function windowCompare(input, shift, size) {
+    const halfSize = size / 2;
+    const lower = shift - halfSize;
+    const upper = shift + halfSize;
+
+    // Inside window = output HIGH
+    // Zero size means window is closed - never triggers
+    const inside = size > 0 && input >= lower && input <= upper;
+
+    return {
+        out: inside ? 10 : 0,     // 10V gate when inside (system standard)
+        not: inside ? 0 : 10,     // 10V gate when outside
+        state: input < lower ? 'below' : (input > upper ? 'above' : 'inside')
+    };
+}
+```
+
+### Logic Section
+
+```javascript
+function logic(out1, out2, lastFF) {
+    const a = out1 > 0;
+    const b = out2 > 0;
+
+    return {
+        and: (a && b) ? 10 : 0,
+        or: (a || b) ? 10 : 0,
+        xor: (a !== b) ? 10 : 0,
+        ff: lastFF  // Toggle on rising edge of out1
+    };
+}
+```
+
+### Flip-Flop Behavior
+
+The FF output toggles state on each rising edge of the **XOR** signal (per manual):
+- When XOR goes from LOW to HIGH, FF toggles
+- FF stays at its current state otherwise
+- This means FF toggles when one comparator changes state while the other stays the same
+
+## Implementation Notes
+
+### Normalization
+
+- Left input is normalled to right input (same signal to both comparators if right not patched)
+- Left Shift CV is normalled to right Shift CV
+- Left Size CV is normalled to right Size CV
+
+This allows modulating both comparators with single CV sources.
+
+### Negative Size
+
+When Size is negative (or CV pushes it negative), the window is "inverted" - the upper threshold is below the lower threshold. In this case, no input can be "inside" the window, so Out stays LOW and Not stays HIGH.
+
+### Edge Cases
+
+- Size = 0: Window is infinitely thin, practically never triggers
+- Very large Size: Window encompasses full input range, always triggers
+- Shift at extremes with large Size: Window clips at voltage rails
+
+## Suggested Module Spec
+
+```javascript
+{
+    id: 'cmp2',
+    name: 'CMP2',
+    hp: 8,
+    category: 'utility',
+
+    params: {
+        shift1: 0,    // -5 to +5
+        size1: 5,     // 0 to 10
+        shift2: 0,
+        size2: 5
+    },
+
+    inputs: {
+        in1: 'cv',
+        in2: 'cv',      // normalled from in1
+        shiftCV1: 'cv',
+        sizeCV1: 'cv',
+        shiftCV2: 'cv', // normalled from shiftCV1
+        sizeCV2: 'cv'   // normalled from sizeCV1
+    },
+
+    outputs: {
+        out1: 'gate',
+        not1: 'gate',
+        out2: 'gate',
+        not2: 'gate',
+        and: 'gate',
+        or: 'gate',
+        xor: 'gate',
+        ff: 'gate'
+    },
+
+    leds: ['state1', 'state2', 'and', 'or', 'xor', 'ff']
+}
+```
+
+## Patch Ideas
+
+1. **Rhythm from LFO**: Feed øchd into Compare 2, adjust window to extract gates at specific parts of the waveform
+2. **Pulse width modulation**: Feed audio into input, adjust Size to change duty cycle of output pulses
+3. **Frequency doubler**: Small window at zero crossing doubles trigger rate
+4. **Complex gates**: Use logic outputs to combine two rhythm patterns
+5. **Voltage-controlled swing**: Modulate Shift with slow LFO to vary when gates fire
+6. **Audio-rate digital ring mod**: Feed two audio signals, use XOR output

research/modules/compare2.md

@@ -43,6 +43,7 @@ import testDb from './test-db.js';
 import testPwm from './test-pwm.js';
 import testTuring from './test-turing.js';
 import testOchd from './test-ochd.js';
+import testCmp2 from './test-cmp2.js';
 import testAttenuverter from './test-attenuverter.js';
 import testSlew from './test-slew.js';
 
@@ -108,6 +109,7 @@ export const FACTORY_PATCHES = {
     [testPwm.name]: testPwm,
     [testTuring.name]: testTuring,
     [testOchd.name]: testOchd,
+    [testCmp2.name]: testCmp2,
     [testAttenuverter.name]: testAttenuverter,
     [testSlew.name]: testSlew,
 

src/js/config/patches/index.js

@@ -0,0 +1,46 @@
+/**
+ * Test Patch: CMP2
+ *
+ * Demonstrates the dual window comparator extracting gates from LFOs.
+ * øchd provides organic modulation, CMP2 converts to rhythmic gates.
+ * OR output gives longer sustained gates for smoother sound.
+ * Asymmetric windows (shift1=-1, shift2=+1) create interesting rhythms.
+ */
+export default {
+    name: 'Test: CMP2',
+    factory: true,
+    state: {
+        modules: [
+            { type: 'ochd', instanceId: 'ochd', row: 1 },
+            { type: 'cmp2', instanceId: 'cmp2', row: 1 },
+            { type: 'vco', instanceId: 'vco', row: 1 },
+            { type: 'vcf', instanceId: 'vcf', row: 1 },
+            { type: 'adsr', instanceId: 'adsr', row: 1 },
+            { type: 'vca', instanceId: 'vca', row: 1 },
+            { type: 'out', instanceId: 'out', row: 1 }
+        ],
+        knobs: {
+            ochd: { rate: 0.73 },
+            cmp2: { shift1: -1, size1: 3.93, shift2: 1, size2: 3.47 },
+            vco: { coarse: 0.34, fine: -1.04, glide: 0 },
+            vcf: { cutoff: 0.58, resonance: 0.15 },
+            adsr: { attack: 0, decay: 0.24, sustain: 0.29, release: 0.49 },
+            vca: { ch1Gain: 0.8, ch2Gain: 0 },
+            out: { volume: 0.6 }
+        },
+        switches: {},
+        cables: [
+            // LFO to comparator inputs - faster LFOs for rhythmic interest
+            { fromModule: 'ochd', fromPort: 'out1', toModule: 'cmp2', toPort: 'in1' },
+            { fromModule: 'ochd', fromPort: 'out3', toModule: 'cmp2', toPort: 'in2' },
+            // OR output - HIGH when either comparator is active
+            { fromModule: 'cmp2', fromPort: 'or', toModule: 'adsr', toPort: 'gate' },
+            // Audio path
+            { fromModule: 'vco', fromPort: 'triangle', toModule: 'vcf', toPort: 'audio' },
+            { fromModule: 'vcf', fromPort: 'lpf', toModule: 'vca', toPort: 'ch1In' },
+            { fromModule: 'adsr', fromPort: 'env', toModule: 'vca', toPort: 'ch1CV' },
+            { fromModule: 'vca', fromPort: 'ch1Out', toModule: 'out', toPort: 'L' },
+            { fromModule: 'vca', fromPort: 'ch1Out', toModule: 'out', toPort: 'R' }
+        ]
+    }
+};

src/js/config/patches/test-cmp2.js

@@ -104,6 +104,7 @@ export const DEFAULT_MODULE_ORDER = [
     'pwm',
     'turing',
     'ochd',
+    'cmp2',
     'kick',
     'snare',
     'hat',