WIP: Add script to generate quantizer tables, currently 12EDO only

Author: aquaticsarah

tools/generate_scales.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2021 Alethea Katherine Flowers.
+# Published under the standard MIT License.
+# Full text available at: https://opensource.org/licenses/MIT
+
+import math
+
+from libgemini.gemini import Gemini
+from libgemini.gem_quantizer import GemQuantizerConfig
+
+### Example scales
+
+# Build a scale based on equally divided octaves
+# Special case: 12 notes per octave gives the standard Western 12-tone equal tempered scale
+def build_edo_scale(notes_per_octave):
+    # Gemini supports 7 octaves, including the "C" at both ends
+    num_notes = 7 * notes_per_octave + 1
+    volts_per_note = 1. / notes_per_octave
+
+    scale = []
+    for note in range(num_notes):
+        note_voltage = note * volts_per_note
+        threshold = note_voltage - (volts_per_note / 2.)
+        scale.append((threshold, note_voltage))
+
+    return GemQuantizerConfig(scale=scale)
+
+def read_scale(gemini):
+    print("Reading scale")
+    quantizer = gemini.read_quantizer()
+    print("Hysteresis:", quantizer.hysteresis)
+    print("Num notes:", len(quantizer.scale))
+    print("First note:", repr(quantizer.scale[0]))
+    print("Last note:", repr(quantizer.scale[-1]))
+
+def write_scale(gemini, scale):
+    print("Writing scale")
+    gemini.save_quantizer(scale)
+
+def main():
+    gemini = Gemini()
+    if 0:
+        scale = build_edo_scale(12)
+        write_scale(gemini, scale)
+        read_scale(gemini)
+    else:
+        read_scale(gemini)
+
+if __name__ == "__main__":
+    main()

tools/libgemini/gem_quantizer.py

@@ -0,0 +1,70 @@
+# TODO: Auto-generate this with `structy`
+# For now it is hand-written
+
+from dataclasses import dataclass
+from typing import ClassVar, List, Tuple
+
+import structy
+import struct
+
+MAX_NOTES = 255 # Needs to match MAX_QUANTIZER_TABLE_SIZE in firmware/src/gem_quantizer.h
+
+def unpack_one(fmt, value):
+    return struct.unpack(fmt, value)[0]
+
+FIX16_MIN = -(1 << 31)
+FIX16_MAX = (1 << 31) - 1
+
+def clamp(value, lo, hi):
+    if value < lo:
+        return lo
+    elif value > hi:
+        return hi
+    else:
+        return value
+
+def clamp_fix16(value):
+    return clamp(value, FIX16_MIN, FIX16_MAX)
+
+# Convert from a Python float to a Gemini-compatible `fix16` integer
+# This is a 32-bit format with 16 fractional bits
+def float_to_fix16(value):
+    value = value * 0x00010000
+    value += 0.5 if value >= 0 else -0.5
+    return clamp_fix16(int(value))
+
+def fix16_to_float(value):
+    return float(value) / float(0x00010000)
+
+@dataclass
+class GemQuantizerConfig:
+    scale: List[Tuple[float, float]]
+    hysteresis: float = 0.005
+
+    def pack(self):
+        num_notes = len(self.scale)
+        assert num_notes <= MAX_NOTES
+        buffer = bytearray()
+        buffer.extend(struct.pack(">i", float_to_fix16(self.hysteresis)))
+        buffer.extend(struct.pack(">B", num_notes))
+
+        for (threshold, output) in self.scale:
+            buffer.extend(struct.pack(">i", float_to_fix16(threshold)))
+            buffer.extend(struct.pack(">i", float_to_fix16(output)))
+
+        return buffer
+
+    @classmethod
+    def unpack(buffer):
+        hysteresis = fix16_to_float(unpack_one(">i", buffer[0:4]))
+        num_notes = unpack_one(">B", buffer[4])
+
+        buffer = buffer[5:]
+        scale = []
+        for i in range(num_notes):
+            threshold = fix16_to_float(unpack_one(">i", buffer[0:4]))
+            output = fix16_to_float(unpack_one(">i", buffer[4:8]))
+            scale.append((threshold, output))
+            buffer = buffer[8:]
+
+        return scale

tools/libgemini/gemini.py

@@ -10,7 +10,7 @@
 
 from wintertools import midi, teeth
 
-from libgemini import gem_settings
+from libgemini import gem_settings, gem_quantizer
 
 
 class SysExCommands(enum.IntEnum):
@@ -25,6 +25,9 @@ class SysExCommands(enum.IntEnum):
     RESET_SETTINGS = 0x07
     READ_SETTINGS = 0x18
     WRITE_SETTINGS = 0x19
+    RESET_QUANTIZER = 0x08
+    READ_QUANTIZER = 0x1A
+    WRITE_QUANTIZER = 0x1B
     #WRITE_LUT_ENTRY = 0x0A
     #WRITE_LUT = 0x0B
     #ERASE_LUT = 0x0C
@@ -72,6 +75,22 @@ def save_settings(self, settings):
             SysExCommands.WRITE_SETTINGS, settings_buf, encode=True, response=True
         )
 
+    def reset_quantizer(self):
+        self.sysex(SysExCommands.RESET_QUANTIZER)
+
+    def read_quantizer(self):
+        quantizer_buf = self.sysex(
+            SysExCommands.READ_QUANTIZER, response=True, decode=True
+        )
+        quantizer = gem_quantizer.GemQuantizerConfig.unpack(quantizer_buf)
+        return quantizer
+
+    def save_quantizer(self, quantizer):
+        quantizer_buf = quantizer.pack()
+        self.sysex(
+            SysExCommands.WRITE_QUANTIZER, quantizer_buf, encode=True, response=True
+        )
+
     def soft_reset(self):
         self.sysex(SysExCommands.SOFT_RESET)