Larsen & Drunik
Larsen
Hey Drunik, ever thought about turning your code skills into a guitar pedal? Imagine writing DSP to shape a riff in real time—our next wild experiment.
Drunik
Sure, I’ve got the idea—just imagine a single line of code that can change the decay of a distortion in 2 µs. I can write the DSP kernel, then micro‑optimize the loop so the CPU never stalls. The real test will be making sure the jitter stays below a millisecond, otherwise the guitar will feel like a metronome gone rogue. Let’s get the prototype, but I’ll need clear specs before I dive in.
Larsen
Cool, love that fire! Let’s drop the specs on the table: target CPU, memory limits, the exact distortion algorithm, and that 2 µs tweak window. Hit me with the numbers, and I’ll throw in some crazy routing ideas to make it feel alive, not just a machine. Let’s crank it up!
Drunik
CPU: STM32H7‑I5, 480 MHz, 256 KB RAM, 512 KB flash. Distortion: 3‑tap IIR with adjustable saturation curve, 16‑bit fixed‑point. 2 µs tweak: 1 µs for coefficient update, 1 µs for sync barrier. Keep memory below 200 KB, aim for 4 % power draw. Let me know if that fits your routing ideas.
Larsen
Sounds solid, dude. 480 MHz on an H7 gives us enough wiggle room to hit that 1 µs update tick. Keep the coefficient table in the L1 cache and lock it with a DMA sync, that should keep the jitter tight. 4 % power? Tight, but we can cut down on the DSP core cycles and hit that. Let’s drop the raw code and I’ll spit some routing that makes the distortion feel alive on stage. Let's make it rock!
Drunik
```c
// Fixed‑point 16‑bit IIR distortion kernel
// Coefficients are Q1.15, state is Q1.15
typedef struct {
int16_t a0, a1, a2; // feed‑forward
int16_t b1, b2; // feedback
int16_t z1, z2; // states
} DistortionState;
// 1‑µs update routine (called by DMA sync)
void update_coeffs(DistortionState *s, const int16_t *coeffs) {
s->a0 = coeffs[0];
s->a1 = coeffs[1];
s->a2 = coeffs[2];
s->b1 = coeffs[3];
s->b2 = coeffs[4];
}
// Main DSP loop (runs at 480 MHz, 1‑µs per sample)
int16_t process_sample(DistortionState *s, int16_t in) {
// Q1.15 multiply with 32‑bit accumulator
int32_t acc = (int32_t)in * s->a0 + (int32_t)s->z1 * s->a1 + (int32_t)s->z2 * s->a2;
int16_t out = (int16_t)(acc >> 15); // back to Q1.15
// Update states
s->z2 = s->z1;
s->z1 = out - ((int32_t)s->b1 * out >> 15) - ((int32_t)s->b2 * s->z2 >> 15);
// Clamp to 16‑bit
if (out > 32767) out = 32767;
if (out < -32768) out = -32768;
return out;
}
```
Larsen
Nice, that’s tight as a drum loop. Just keep those coeffs in a single cache line, and use the ARM intrinsics if you need the extra punch. The state updates look good—just watch out for the subtraction chain; if the sign flips weirdly you’ll get that nasty clipping. Once you lock the DMA into a 1 µs window, the jitter should stay in the sub‑ms zone. Let’s test it live and tweak the saturation curve while the amp’s blasting—time to make that feedback feel like a guitar solo, not a math class.
Drunik
Sounds good, just make sure the saturation curve is also Q1.15 so the multiplier keeps the 32‑bit acc in range. A quick test with a sweep tone will reveal any sign‑flip edge cases. I’ll tweak the feedback terms so the loop feels fluid, not rigid. Let's hit the live test and see if the pedal breathes like a real solo.