Put tips and info and links for tuning the envelope and accents and glide and so on here! Thanks in advance!

[01GOD]

Hi!

Seems good to make a thread with a bunch of tips and info and links for tuning the envelope and accents and glide and so on, so here it is! There is more to tuning the envelope generator and accents and glide and so on properly than some may expect. And somewhat annoying how much precision was involved.

I will start this thread by posting a useful page that has some good info for tuning Accent:
https://modwiggler.com/forum/viewtopic.php?t=10885

People are welcome to reply with more such info to make a thorough and exact finalized THIS IS EXACTLY HOW TO (generally, because there is variation in analog synths of same model anyway, haha) thread to have as a reference.

[copych]

ESP32 Performance notes.

About Arduino and FreeRTOS tasks. Actually, Arduino core runs on top of FreeRTOS, and all these functions are already use RTOS tasks. What you get when running tasks manually is the second ESP32's core which roughly doubles the computing power (you can see in Arduino IDE in tools menu the options to select on which core to run Arduino and Events), another thing is that you can manually set the task stack size in bytes.

About types: float, double and int. ESP32 and ESP32S3 have a dedicated single precision FPU, for better understanding here are the benchmark results which are common for both:

Type and operation	MOP/s	CPI
Integer Addition	239.772217	1.000482
Integer Multiply	239.826126	1.000561
Integer Division	119.944527	2.000431
Integer Multiply-Add	239.826126	1.000509
Float Addition	239.808151	1.000586
Float Multiply	239.808151	1.000573
Float Division	$${\color{red}5.04324}$$	1.394347
Float Multiply-Add	479.544434	1.000682
Double Addition	6.629294	1.760988
Double Multiply	2.260351	1.620783
Double Division	0.487446	1.590582
Double Multiply-Add	5.771100	1.858178

As one can see, int and float have very similar performance except for float division, also FPU gives extra force to float Multiply-Add.
Float division is unacceptably slow. And all the double operations are just from another world and we can't take them into account.
So finally we have a general performance receipt.

• Use float or int, don't use double
• Not that obvious, but confirmed: use native int type instead of int8_t or other smaller types, if you prefer speed over storage, believe that the difference is very noticeable
• MINIMIZE using of float division, where possible pre-calculate the reciprocal and use multiplication
• There are ASM routines optimized for ESP32/ESP32S3 SIMD instruction sets, containing useful functions like FFT, DCT, Biquad, FIR, matrix operations etc. More info here https://github.com/espressif/esp-dsp/ They are also available through the ESP Arduino core
• If you don't need WiFi and Bluetooth, you can stop them to free CPU cycles for your needs

[01GOD]

Saw now. Great info! Thanks👍🏻

[copych]

Open303 project
https://www.kvraudio.com/forum/viewtopic.php?t=262829 -- pearls are randomly spread over the 1153 posts there.
https://github.com/RobinSchmidt/Open303 -- repository by the author

Open303 ESP32 port
https://github.com/copych/ESP32_Open303

[01GOD]

By the way, open303 is a generally vanilla emulation without any overdrive effects or bass boost or reverb or delay?

[copych]

Correct, almost no fx, but added some controls compared to the original tb303. You can check jc303 repo for open303 vst plugin.

[01GOD]

Phoscyon has a nice accent dec parameter. Sounds nice and I guess accent usually sets env dec to minimum, so it's nice to have control of that.

[01GOD]

I was aiming for the simplest way to generate a PCM saw wave on a DAC connected to an S3 today and thankfully got this code running:
`
#include "driver/i2s.h"

#define SAMPLE_RATE 44100
#define WAVE_FREQ 70
#define AMPLITUDE 3000
#define I2S_PORT I2S_NUM_0

const int bufferLen = SAMPLE_RATE / WAVE_FREQ;
int16_t buffer[bufferLen];

void setup() {
// Configure I2S
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX),
.sample_rate = SAMPLE_RATE,
.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
.communication_format = I2S_COMM_FORMAT_I2S_MSB,
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64,
.use_apll = false,
.tx_desc_auto_clear = true,
.fixed_mclk = 0
};

i2s_pin_config_t pin_config = {
    .bck_io_num = 42,       // Bit Clock
    .ws_io_num = 2,        // Word Select (L/R)
    .data_out_num = 41,     // Data Out
    .data_in_num = I2S_PIN_NO_CHANGE
};

i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
i2s_set_pin(I2S_PORT, &pin_config);

}

void loop() {
// Generate a saw wave
for (int i = 0; i < bufferLen; i++) {
buffer[i] = (AMPLITUDE * i) / bufferLen;
}

// Continuously write the saw wave to the I2S interface
size_t bytes_written;
i2s_write(I2S_PORT, buffer, bufferLen * sizeof(int16_t), &bytes_written, portMAX_DELAY);

}
`

Now really want to use some of the filters and effects from: https://github.com/PaulBatchelor/Soundpipe/tree/master

I used those in iOS/iPadOS/macOS apps through AudioKit, but it seems like it SHOULD BE VERY EASY to adapt those effects to use on an embedded C based platform, such as ESP32.

Been trying to do that tonight, so collaborators on that mission are welcome. There are A LOT of filters and effects in that library, and it would be GREAT to be able to use those in electronics projects.

[copych]

The simplest way of generating saw wave is not the most efficient, unfortunately. There's a strong disadvantage known as aliasing. Initial saw has infinite spectrum and when being resampled, all the spectrum above Nyquist freq will produce well audible parasite sub frequencies.
There are a number of methods to produce band limited saw wave, but all of them require either additional storage or CPU. You can google 'BLEP', 'mipmap' or 'oversample'. AcidBox uses neither of them, but phase reset. Sub frequences are still there, but they are like exactly integer number octaves down. And higher registers are not that fine tuned.

[01GOD]

Yikes! Didn't expect that would cause excessive aliasing. If synching a saw for loop to exactly the Nyquist frequency interval, then no aliasing noise?

Want something as satisfyingly logical as an astable multivibrator circuit as the oscillator basis, rather than something that obscures the simplicity. Although I like the simplicity of a reverse avalanche transistor oscillator, I don't fully understand what that is doing. In comparison, an astable multivibrator is LOGICAL. I can more easily expand advance things I more fully understand.

[copych]

If synching a saw for loop to exactly the Nyquist frequency interval, then no aliasing noise?

In this case parasite frequencies will be less audible as their periods become an integer products of base wave period (used in AcidBox)

[01GOD]

If synching a saw for loop to exactly the Nyquist frequency interval, then no aliasing noise?
In this case parasite frequencies will be less audible as their periods become an integer products of base wave period (used in AcidBox)

Oh, cool. Glad to hear that is possible and that it is part of that synth also. I truly value purity and transparency. So much better than unnecessary complexity is for understanding how things function.

[01GOD]

Admittedly tonight been trying to get chatgpt to port that diode ladder filter from soundpipe (that was ported from Will Pirkle's emulation seemingly) so I don't have to wade through the soundpipe code to figure out what it's doing before making anything useful.

After A LOT of attempts, it seems as though I maybe should wade through that soundpipe code some. Obviously that would be more educational for DSP learning. Was hoping chatgpt could churn out an edition that was functional so I can study that filter that way, rather than with added soundpipe complexity involved.

Here is maybe the best edition it output tonight. The issue is that, without adding proper envelope generators, and a sequencer, it's not so easy to know if it's correctly ported that filter. It's maybe a correct-ish port of that filter, although admittedly too tired to sift through the code. Some of it did look a little suspect when it assigned all of the alpha and beta mLPF1c_ the same vals. Anyway, here is that code. Maybe it's useful regardless of if a correct port or not:

#include "driver/i2s.h"
#include <cmath>

// Define sample rate, wave frequency, and amplitude
#define SAMPLE_RATE     44100
#define WAVE_FREQ       40
#define AMPLITUDE       3000
#define I2S_PORT        I2S_NUM_0

const int bufferLen = SAMPLE_RATE / WAVE_FREQ;
int16_t buffer[bufferLen];

// Diode Ladder Filter Parameters
float filterCutoff = 20.0;  // Cutoff frequency in Hz
float filterQ = 10.0;         // Resonance (Q) factor

// Diode Ladder Filter State
typedef struct {
    float mLPF1c_alpha;
    float mLPF1c_beta;
    float mLPF1c_delta;
    float mLPF1c_gamma;
    float mLPF1c_epsilon;

    float mLPF2c_alpha;
    float mLPF2c_beta;
    float mLPF2c_delta;
    float mLPF2c_gamma;
    float mLPF2c_epsilon;

    float mLPF3c_alpha;
    float mLPF3c_beta;
    float mLPF3c_delta;
    float mLPF3c_gamma;
    float mLPF3c_epsilon;

    float mLPF4c_alpha;
    float mLPF4c_beta;
    float mLPF4c_delta;
    float mLPF4c_gamma;
    float mLPF4c_epsilon;

    float mSG1;
    float mSG2;
    float mSG3;
    float mSG4;
} DiodeLadderFilter;

// Update Diode Ladder Filter Coefficients
void updateFilterCoefficients(DiodeLadderFilter *filter, float sampleRate, float cutoffHz, float q) {
    float RC = 1.0 / (2.0 * 3.14159 * cutoffHz);
    float dt = 1.0 / sampleRate;
    float alpha = dt / (RC + dt);

    filter->mLPF1c_alpha = alpha;
    filter->mLPF1c_beta = 1.0 - alpha;

    filter->mLPF2c_alpha = alpha;
    filter->mLPF2c_beta = 1.0 - alpha;

    filter->mLPF3c_alpha = alpha;
    filter->mLPF3c_beta = 1.0 - alpha;

    filter->mLPF4c_alpha = alpha;
    filter->mLPF4c_beta = 1.0 - alpha;

    filter->mSG1 = filter->mSG2 = filter->mSG3 = filter->mSG4 = 0.0;
}

// Process through Diode Ladder Filter
float processDiodeLadderFilter(DiodeLadderFilter *filter, float input) {
    float lpf1_output = filter->mLPF1c_alpha * input + filter->mLPF1c_beta * filter->mSG1;
    float lpf2_output = filter->mLPF2c_alpha * lpf1_output + filter->mLPF2c_beta * filter->mSG2;
    float lpf3_output = filter->mLPF3c_alpha * lpf2_output + filter->mLPF3c_beta * filter->mSG3;
    float lpf4_output = filter->mLPF4c_alpha * lpf3_output + filter->mLPF4c_beta * filter->mSG4;

    filter->mSG1 = lpf1_output;
    filter->mSG2 = lpf2_output;
    filter->mSG3 = lpf3_output;
    filter->mSG4 = lpf4_output;

    return lpf4_output;
}

void setup() {
    // Configure I2S
    i2s_config_t i2s_config = {
        .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX),
        .sample_rate = SAMPLE_RATE,
        .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
        .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
        .communication_format = I2S_COMM_FORMAT_I2S_MSB,
        .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
        .dma_buf_count = 8,
        .dma_buf_len = 64,
        .use_apll = false,
        .tx_desc_auto_clear = true,
        .fixed_mclk = 0
    };

    i2s_pin_config_t pin_config = {
        .bck_io_num = 42,       // Bit Clock
        .ws_io_num = 2,         // Word Select (L/R)
        .data_out_num = 41,     // Data Out
        .data_in_num = I2S_PIN_NO_CHANGE
    };

    i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
    i2s_set_pin(I2S_PORT, &pin_config);
}

void loop() {
    static DiodeLadderFilter filter;
    static bool filterInitialized = false;

    // Initialize filter if not done
    if (!filterInitialized) {
        updateFilterCoefficients(&filter, SAMPLE_RATE, filterCutoff, filterQ);
        filterInitialized = true;
    }
//New: 
    // for (int i = 20; i < 20000; i++) {
      // if (wait != true){
        if (filterCutoff<2000){
     filterCutoff+=10;
        }else{
              filterCutoff=20;
 
        }
//     // //  wait = !wait; 
//     //   // }
    // }
    // Dynamically update filter parameters
    updateFilterCoefficients(&filter, SAMPLE_RATE, filterCutoff, filterQ);

    // Generate and filter the saw wave
    for (int i = 0; i < bufferLen; i++) {
        // Generate a saw wave
        float sawWave = (2.0 * i / bufferLen - 1.0) * AMPLITUDE;

        // Process through diode ladder filter
        float filteredSignal = processDiodeLadderFilter(&filter, sawWave);

        // Convert to 16-bit and fill buffer
        buffer[i] = (int16_t)filteredSignal;
    }

[01GOD]

Here is the Stanford chugin with Will Pirkle listed as either author or it is based on the documentation (and derivation?) in the book or research papers he wrote.
https://github.com/ccrma/chugins/blob/main/WPDiodeLadder/VADiodeLadderFilter.cpp
And another edition of that in another repo:
https://github.com/olilarkin/PirkleFiltersSOUL/blob/main/VATester.soul

[copych]

Check this collection https://github.com/ddiakopoulos/MoogLadders I've tested some of these, and Krajeski was the default one for some time.

[copych]

AcidBox todo

• I am actually looking for cpu effective simulation of RAT or MXR distortion, cause this is also a valuable contribution into the famous sound. It's simple as an amplifier and a diode clipper, but the exact non-linearity curve is a question for me yet. I need to conduct some experiments anyway.
• Some time ago we discussed assisted jukebox mode with one of the contributors, but I haven't moved it forward, partly because I waited for the new USB host implementation on ESP32S3, partly because I was busy with the "ESP SD sampler". Assistance means keyboard input processing, switching patterns, mute/unmute, randomize and so on.

Any input is welcomed.

[01GOD]

The one in soundpipe sounds correct, although don't know how CPU efficient that is: https://github.com/paulbatchelor/soundpipe

Been trying for much of the past day to port that diode ladder also and will be nice to have that diode clipper to accompany it. That is basically the flavor I like. More MXR style.

DSP learning was coming along until chatgpt apparently was sadly unable to comprehend that finding if the current sample in a lowpass filter had to be attenuated required knowing the amplitude of the past sample(s). Maybe there is some other special way to calculate that using angular frequency and sample rate and so on, without looking at past sample, but I doubt that. Anyway, so then was on to youtube. Did read some of Will Pirkle book about DSP in C++ yesterday though and he said that diode ladder is the MOST complex filter in that book. There is a lot of interconnection between filter stages in that filter. I assume there is some easy way to throw a wave cycle buffer into it and get it to output a filtered edition, although it didn't seem as straight forward to integrate into that saw wave generator as I had hoped. Certainly thankful it's there though, because there seems to be A LOT of math in that transfer function of that filter. Actually kinda tired of analog emulation because of such overcomplicated hassles. Directly modifying a wave programmatically seems SO MUCH easier than trying to emulate analog circuits that can vary.

About that jukebox, I usually only play and sequence White keys, to avoid any drama. I compose based on frequency relationships, so I do admittedly include one sharp sometimes. That is only because it's the closest to a whole frequency interval though.

[copych]

About filtering, there are 2 general aproaches: FIR and IIR, both operates with series of samples. And if basically we are talking about frequencies, there must appear something like derivatives, so at least 2 samples we have to take into account.

[01GOD]

Yeah, was easy to see that chatgpt was most probably spouting nonsense. Sometimes it has found some gems from github or reddit, stackoverflow, etcetera, though.

[01GOD]

Realized today that the diode clipper sound sounds "GOOD" and loud, because it basically makes a louder saw wave. Basically the initial peak of that saw is still sudden, but it plays at loudest level longer.

Wrote one today that grabs that saw wave array from a saw wave for loop and processes it, including amplitude compensation.
Here is how that looks. Note that the peak amplitude of that saw wave was 3000.:

for (int i = 0; i < bufferLen; i++) {
    if (buffer[i]>2500){
        buffer[i] = 2500; 
      }
  }
  for (int i = 0; i < bufferLen; i++) {
    buffer[i]+=buffer[i]+500; 
  }

[01GOD]

Here is a link to the soundpipe clipper. Oddly didn't seem to be in the main soundpipe, although maybe it was that "clipping saturation" in there.

https://github.com/AudioKit/SoundpipeAudioKit/blob/main/Sources/CSoundpipeAudioKit/Effects/ClipperDSP.mm

And here is a link to the soundpipe docs: https://paulbatchelor.github.io/res/soundpipe/docs/
Seems as though using soundpipe may be the best way to make synths more easily on embedded platforms.

[01GOD]

Here is the original diode ladder (the code the soundpipe diode ladder was supposedly based on) chugin from the stanford ccrma. That plugin was maybe the first of those that Will Pirkle is listed as the author of. Looks maybe easier to port:
https://github.com/01GOD/Stanford-CCRMA-chugins/blob/main/WPDiodeLadder/VADiodeLadderFilter.cpp

Thankfully found the notes Will Pirkle apparently made about that filter:
https://web.archive.org/web/20211130062751/http://www.willpirkle.com/Downloads/AN-6DiodeLadderFilter.pdf

[copych]

I've posted already, but check this link, there's a collection of moogladders in C++. It also contains afilter called Oberheim by Pirkle.

[01GOD]

Cool. Was finishing an ESP32 PCB design the past day, so excuse the delayed reply.

[01GOD]

Saw those jungle samples in that project dir. I've been wanting to make a standalone MPC style quantized jungle performance dealio.
Basically a sample player that syncs to a specified tempo and ONLY starts output quantized. So can say, map a bunch of drum loops to MPC style pads and then regardless of how accurate the finger drumming is, those drum loops start quantized to grid.
And of course there has to be non-destructive time-stretching to stretch the loops to BPM. Could make one that does 160BPM without that timestretching feature though.
Will be nice to have that on ESP32 or other MCU. I may work on that later this calendar year.

[copych]

Check my another repo https://github.com/copych/ESP32_S3_Sampler

[01GOD]

Nice! Thanks!

[01GOD]

By the way, decoupling cap between 3.3 and gnd on that breadboard seems unnecessary. If want to be cautious, can put one between 5V and GND though.

[copych]

The cap on the pic is between 3V3 and EN of the particular ESP32 board. This makes flashing more stable and won't require pushing 'boot' when uploading firmware.

[01GOD]

Ah! OK.

[01GOD]

Been working on a GUI that utilizes LVGL library mainly. That is functioning by itself. And also the AcidBox app functions by itself.

But sadly after added that GUI, the sound was very distorted. Not in the noise overly way like it was before, but more of a harshly distorted choppy sound. And the GUI wasn't responsive either, and although the general GUI outline showed, the colors were not correct.

Wondering if maybe it's a multiple i2s issue or why that is happening. Any good clues or recommendations?

I should maybe try it with that open303 port to see if it functions better with that.

[copych]

I am quite sure that there's no more CPU ticks left for the GUI. If you want such comprehensive GUI you should run it on a separate MCU and only send MIDI messages to AcidBox. Open303 has a whole CPU core to run GUI.

[01GOD]

Ah. Sigh...

Seems that 2 CPU cores at 240 MHz should be able to handle all of that pretty easily. Especially with an efficient RTOS.

So that open303 port has an entire unused CPU core available to run GUI on?

I hope so!

[01GOD]

I suppose it was maybe naive to assume that USB serial MIDI with AcidBox meant that it could receive MIDI messages through USB from a laptop. Is that MIDI only through direct connections via USB to some MIDI controllers, or...?

[copych]

It's possible to receive midi messages from a laptop with help of Hairless Midi. Also you'll need some luck to compile with correct naming of the ports of your particular board. (For me it's always a headache to determine wheather it's USBSerial or Serial or Serial0 etc.)

[01GOD]

Ah! Thanks for advising on that👍🏻

[01GOD]

Tonight been battling and working for MORE THAN 4 HOURS to simply get a diode ladder filter emulation ported. Here is the .ino so far. Can have a look at it and force it to function? I mainly programmed in languages other than C++, so I imagine it's simply language semantics. This is the HORRIBLY FORMATTED (sadly) PDF it is ported from: https://web.archive.org/web/20211130062751/http://www.willpirkle.com/Downloads/AN-6DiodeLadderFilter.pdf
And here is that .ino that I have been working on:

#include "driver/i2s.h"

#define SAMPLE_RATE     44100
#define WAVE_FREQ       70
#define AMPLITUDE       3000
#define I2S_PORT        I2S_NUM_0

const int bufferLen = SAMPLE_RATE / WAVE_FREQ;
int16_t buffer[bufferLen];

//Adding diode ladder filter: 
#define PI 3.14159265358979323846
class CVAOnePoleFilterEx
{
public:
       CVAOnePoleFilterEx(void);
       ~CVAOnePoleFilterEx(void);
       // common variables
       double m_dSampleRate;
       double m_dFc;
/* sample rate*/
/* cutoff frequency */
// Trapezoidal Integrator Components
// variables
double m_dAlpha; // Feed Forward coeff
double m_dBeta; // Feed Back coeff from s + FB_IN
// extended functionality variables
double m_dGamma;
double m_dDelta;
double m_dEpsilon;
double m_da0;
double m_dFeedback;
// Pre-Gain
// FB_IN Coeff
// extra factor for local FB
// filter gain
// Feed Back storage register (not a delay register)
// provide access to our feedback output
double getFeedbackOutput();
// provide access to set our feedback input
void setFeedback(double fb){m_dFeedback = fb;}
// for s_N only; not used in the Diode Ladder
double getStorageValue(){return m_dZ1;}
// flush buffer
void reset(){m_dZ1 = 0;}
   // do the filter
   double doFilter(double xn);
//protected:
   
double m_dZ1;
// our z-1 storage location
};
// Add your code here: ------------------------------------------------- //
CVAOnePoleFilterEx m_LPF1;
CVAOnePoleFilterEx m_LPF2;
CVAOnePoleFilterEx m_LPF3;
CVAOnePoleFilterEx m_LPF4;
double m_dGAMMA; // Gamma see App Note
// our feedback S values (global)
double m_dSG1;
double m_dSG2;
double m_dSG3;
double m_dSG4;
void reset()
{
   m_LPF1.reset(); m_LPF2.reset();
   m_LPF3.reset(); m_LPF4.reset();
   m_LPF1.setFeedback(0.0); m_LPF2.setFeedback(0.0);
   m_LPF3.setFeedback(0.0); m_LPF4.setFeedback(0.0);

}
// recalc the coeffs
void updateFilter();
// do the filter
double doFilter(double xn);
// END OF USER CODE ---------------------------------------------------- //

CVADiodeLadderFilter::CVADiodeLadderFilter()
{
   // Finish initializations here
   m_dGAMMA = 0.0;
   m_dK = 0.0;
   // our feedback S values (global)
   m_dSG1 = 0.0;
   m_dSG2 = 0.0;
   m_dSG3 = 0.0;
   m_dSG4 = 0.0;
   // Filter coeffs that are constant
   // set a0s
   m_LPF1.m_da0 = 1.0;
   m_LPF2.m_da0 = 0.5;
   m_LPF3.m_da0 = 0.5;
   m_LPF4.m_da0 = 0.5;
   // last LPF has no feedback path
   m_LPF4.m_dGamma = 1.0;
   m_LPF4.m_dDelta = 0.0;
   m_LPF4.m_dEpsilon = 0.0;
   m_LPF4.setFeedback(0.0);
}
//prepareForPlay()
//- reset the filters
//- update the filters for the initial state (fc, Q)
bool CVADiodeLadderFilter::prepareForPlay()
{
   reset();
   // set the initial coeffs
   updateFilter();
   // this flushes all storage registers in filters including feedback register
   return true;

}

// }

void CVADiodeLadderFilter::updateFilter()
{
   // calculate alphas
   double wd = 2*pi*m_dFc;
   double T  = 1/(float)m_nSampleRate;
   double wa = (2/T)*tan(wd*T/2);
   double g = wa*T/2;
   // Big G's
   double G1, G2, G3, G4;
   G4 = 0.5*g/(1.0 + g);
   G3 = 0.5*g/(1.0 + g - 0.5*g*G4);
   G2 = 0.5*g/(1.0 + g - 0.5*g*G3);
   G1 = g/(1.0 + g - g*G2);
   // our big G value GAMMA
   m_dGAMMA = G4*G3*G2*G1;
   m_dSG1 =  G4*G3*G2;
   m_dSG2 =  G4*G3;
   m_dSG3 =  G4;
   m_dSG4 =  1.0;
   // set alphas
   m_LPF1.m_dAlpha = g/(1.0 + g);
   m_LPF2.m_dAlpha = g/(1.0 + g);
   m_LPF3.m_dAlpha = g/(1.0 + g);
   m_LPF4.m_dAlpha = g/(1.0 + g);
   // set betas
   m_LPF1.m_dBeta = 1.0/(1.0 + g - g*G2);
   m_LPF2.m_dBeta = 1.0/(1.0 + g - 0.5*g*G3);
   m_LPF3.m_dBeta = 1.0/(1.0 + g - 0.5*g*G4);
   m_LPF4.m_dBeta = 1.0/(1.0 + g);
   // set gammas
   m_LPF1.m_dGamma = 1.0 + G1*G2;
   m_LPF2.m_dGamma = 1.0 + G2*G3;
   m_LPF3.m_dGamma = 1.0 + G3*G4;
   // m_LPF4.m_dGamma = 1.0; // constant - done in constructor
   // set deltas
   m_LPF1.m_dDelta = g;
   m_LPF2.m_dDelta = 0.5*g;
   m_LPF3.m_dDelta = 0.5*g;
   // m_LPF4.m_dDelta = 0.0; // constant - done in constructor
   // set epsilons
   m_LPF1.m_dEpsilon = G2;
   m_LPF2.m_dEpsilon = G3;
   m_LPF3.m_dEpsilon = G4;
   // m_LPF4.m_dEpsilon = 0.0; // constant - done in constructor
}

double CVADiodeLadderFilter::doFilter(double xn)
{
   // m_LPF4.setFeedback(0.0); // constant - done in constructor
   m_LPF3.setFeedback(m_LPF4.getFeedbackOutput());
   m_LPF2.setFeedback(m_LPF3.getFeedbackOutput());
   m_LPF1.setFeedback(m_LPF2.getFeedbackOutput());
   // form input
   double SIGMA = m_dSG1*m_LPF1.getFeedbackOutput() + m_dSG2*m_LPF2.getFeedbackOutput() +m_dSG3*m_LPF3.getFeedbackOutput() + m_dSG4*m_LPF4.getFeedbackOutput();
   // "cheap" nonlinear model; just process input
   if(m_NonLinearProcessing == ON)
      {
         // Normalized Version
         if(m_uNLPType == NORM)
            xn = (1.0/tanh(m_dSaturation))*tanh(m_dSaturation*xn);
         else
            xn = tanh(m_dSaturation*xn);
         }
   
   
   // form the input to the loop
   double un = (xn - m_dK*SIGMA)/(1 + m_dK*m_dGAMMA);
   // cascade of series filters
   return m_LPF4.doFilter(m_LPF3.doFilter(m_LPF2.doFilter(m_LPF1.doFilter(un))));

}
/////////////

// void diodeClipper(auto *bufferInput){

// for (int i = 0; i < bufferLen; i++) {
//     if (bufferInput[i]>2500){
//         bufferInput[i] = 2500; 
//       }
//   }
//   for (int i = 0; i < bufferLen; i++) {
//     bufferInput[i]+=bufferInput[i]+500; 
//   }
// }
//

void setup() {

//VAdiodeladder stuff: 
CVADiodeLadderFilter filter;
filter.prepareForPlay();
filter.m_LPF1.m_dSampleRate = 44100.0;
filter.m_LPF1.m_dFc = 100.0;
filter.updateFilter();
    // Configure I2S
    i2s_config_t i2s_config = {
        .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX),
        .sample_rate = SAMPLE_RATE,
        .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
        .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
        .communication_format = I2S_COMM_FORMAT_I2S_MSB,
        .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
        .dma_buf_count = 8,
        .dma_buf_len = 64,
        .use_apll = false,
        .tx_desc_auto_clear = true,
        .fixed_mclk = 0
    };

    i2s_pin_config_t pin_config = {
        .bck_io_num = 42,       // Bit Clock
        .ws_io_num = 2,        // Word Select (L/R)
        .data_out_num = 41,     // Data Out
        .data_in_num = I2S_PIN_NO_CHANGE
    };

    i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
    i2s_set_pin(I2S_PORT, &pin_config);
}

int waitBetweenFXWavesCounter=0;

void loop() {
 // Generate a saw wave
    for (int i = bufferLen; --i > 0; ) {
      //Normalized with maximum volume being AMPLITUDE var val 
        buffer[i] = (AMPLITUDE * i) / bufferLen;
    }
    for (int i = 0; i < bufferLen; i++) {
buffer[i]= filter.doFilter(buffer[i]);
size_t bytes_written;
    i2s_write(I2S_PORT, buffer, bufferLen * sizeof(int16_t), &bytes_written, portMAX_DELAY);
}

    }

[01GOD]

I put a more proper edition of that work-in-progress port here today:
https://github.com/01GOD/Porting_VADiodeLadderFilter_To_Embedded_C

[01GOD]

Tried that diode ladder filter emulation posted by karrikuh on kvr more than a calendar decade ago? Yesterday read that thread on kvr.

[01GOD]

Also found this today for USB MIDI on S3:
https://github.com/shorepine/tulipcc/blob/f3a0037d6bfdaf75cfd93f1e553fe1f6771e7845/tulip/shared/midi.c

[01GOD]

By the way, a seemingly nice tutorial on dual core ESP32 programming:
https://www.youtube.com/watch?v=w5YigjvSaF4

Seems it should be possible to put drums on one core and synth on other or some similar config.

[01GOD]

Actually seems interesting to put all the sound stuff on one core and all the MIDI on the other core. Seems people are running displays on a second ESP32, but that likely isn't necessary. Seems likely there is an easy way to strip out second synth, but I haven't looked at that. Maybe there is a #define flag somewhere for that. Anyway, having only one synth and putting MIDI on second core with display seems like that can make it all run on one ESP32-S3.