Long read about how and why things work

[01GOD]

Tonight stripped out 1 of the synths and after that was functioning nicely, had a go at adding a GUI by merging a functional LVGL GUI ui.ino file with that functional AcidBox.ino. Sadly that caused Me to find out about what a horrible mess the Arduino IDE can apparently be, as the IDE stopped being able to include the code in the other AcidBox files. Apparently it's a known problem with #includes in some Arduino projects. First the compiler couldn't find function definitions in the other files, then when renamed that other file to .c and added an #include statement for that file, then it couldn't find #define preprocessor directives in config.h. And it sadly seemed to be a HUGE LONG MESS of similar compiler disaster after that.

Some info:
https://forum.arduino.cc/t/define-and-include-directives-in-arduino-ide/187059/32

Here is the AcidBox.ino that the Arduino IDE was having problems with. I thought it was going to be (IT SHOULD HAVE BEEN!!!) vastly easier to simply merge in that ui.ino, before that compiler mess happened:

#include "config.h"
     // I see no reasom to set more than 2 DMA buffers, but...
/*

  AcidBox
  ESP32 acid combo of 303 + 303 + 808 like synths. MIDI driven. I2S output to DAC. No indication. Uses both cores of ESP32.

  To build the thing
  You will need an ESP32 with PSRAM (ESP32 WROVER module). Preferrable an external DAC, like PCM5102. In ArduinoIDE Tools menu select:

* * Board: "ESP32 Dev Module" or "ESP32S3 Dev Module"
* * Partition scheme: No OTA (1MB APP/ 3MB SPIFFS)
* * PSRAM: "enabled" or "OPI PSRAM" or what type you have


  !!!!!!!! ATTENTION !!!!!!!!!
  You will need to upload samples from /data folder to the ESP32 flash, otherwise you'll only have 40kB samples from samples.h. 
  To upload samples follow the instructions:
  
  https://github.com/lorol/LITTLEFS#arduino-esp32-littlefs-filesystem-upload-tool
  And then use Tools -> ESP32 Sketch Data Upload

*/
//START OF NEW CAP TOUCH GUI SECTION:
#include "touch.h"
#include "ui.h"
#include <Arduino_GFX_Library.h>

#define GFX_BL DF_GFX_BL // default backlight pin, you may replace DF_GFX_BL to actual backlight pin

/* More dev device declaration: https://github.com/moononournation/Arduino_GFX/wiki/Dev-Device-Declaration */
#if defined(DISPLAY_DEV_KIT)
Arduino_GFX *gfx = create_default_Arduino_GFX();
#else /* !defined(DISPLAY_DEV_KIT) */


#define GFX_BL 1
Arduino_DataBus *bus = new Arduino_ESP32QSPI(
  45 /* cs */, 47 /* sck */, 21 /* d0 */, 48 /* d1 */, 40 /* d2 */, 39 /* d3 */);
Arduino_GFX *g = new Arduino_NV3041A(bus, GFX_NOT_DEFINED /* RST */, 0 /* rotation */, true /* IPS */);
Arduino_GFX *gfx = new Arduino_Canvas(480 /* width */, 272 /* height */, g);
#define CANVAS


#endif /* !defined(DISPLAY_DEV_KIT) */

/* Change to your screen resolution */
static uint32_t screenWidth;
static uint32_t screenHeight;
static uint32_t bufSize;
static lv_disp_draw_buf_t draw_buf;
static lv_color_t *disp_draw_buf;
static lv_disp_drv_t disp_drv;
/*******************************************************************************
* End of Arduino_GFX setting
******************************************************************************/
//--------END OF NEW CAP TOUCH GUI SECTION

#include "general.c"
#include "fx_delay.h"
#ifndef NO_PSRAM
#include "fx_reverb.h"
#endif
#include "compressor.h"
#include "synthvoice.h"
#include "sampler.h"
#include <Wire.h>

#if defined MIDI_VIA_SERIAL2 || defined MIDI_VIA_SERIAL
#include <MIDI.h>
#endif

#ifdef MIDI_VIA_SERIAL
// default settings for Hairless midi is 115200 8-N-1
struct CustomBaudRateSettings : public MIDI_NAMESPACE::DefaultSerialSettings {
  static const long BaudRate = 115200;
};
struct SerialMIDISettings : public midi::DefaultSettings {
  static const long BaudRate = 115200;
  static const bool Use1ByteParsing = false;
};
MIDI_NAMESPACE::SerialMIDI<HardwareSerial, CustomBaudRateSettings> serialMIDI(Serial);
MIDI_NAMESPACE::MidiInterface<MIDI_NAMESPACE::SerialMIDI<HardwareSerial, SerialMIDISettings>> MIDI((MIDI_NAMESPACE::SerialMIDI<HardwareSerial, SerialMIDISettings>&)serialMIDI);
#endif

#ifdef MIDI_VIA_SERIAL2
// MIDI port on UART2,   pins 16 (RX) and 17 (TX) prohibited, as they are used for PSRAM
struct Serial2MIDISettings : public midi::DefaultSettings {
  static const long BaudRate = 31250;
  static const int8_t RxPin  = MIDIRX_PIN;
  static const int8_t TxPin  = MIDITX_PIN;
  static const bool Use1ByteParsing = false;
};
MIDI_NAMESPACE::SerialMIDI<HardwareSerial> Serial2MIDI2(Serial2);
MIDI_NAMESPACE::MidiInterface<MIDI_NAMESPACE::SerialMIDI<HardwareSerial, Serial2MIDISettings>> MIDI2((MIDI_NAMESPACE::SerialMIDI<HardwareSerial, Serial2MIDISettings>&)Serial2MIDI2);
#endif


// lookuptables
static float midi_pitches[128];
static float midi_phase_steps[128];
static float midi_tbl_steps[128];
static float exp_square_tbl[TABLE_SIZE+1];
//static float square_tbl[TABLE_SIZE+1];
static float saw_tbl[TABLE_SIZE+1];
static float exp_tbl[TABLE_SIZE+1];
static float knob_tbl[TABLE_SIZE+1]; // exp-like curve
static float shaper_tbl[TABLE_SIZE+1]; // illinear tanh()-like curve
static float sin_tbl[TABLE_SIZE+1];
static float norm1_tbl[16][16]; // cutoff-reso pair gain compensation
static float norm2_tbl[16][16]; // wavefolder-overdrive gain compensation
//static float (*tables[])[TABLE_SIZE+1] = {&exp_square_tbl, &square_tbl, &saw_tbl, &exp_tbl};

// service variables and arrays
volatile uint32_t s1t, s2t, drt, fxt, s1T, s2T, drT, fxT, art, arT, c0t, c0T, c1t, c1T; // debug timing: if we use less vars, compiler optimizes them
volatile uint32_t prescaler;
static  uint32_t  last_reset = 0;
static  float     param[POT_NUM];
static uint8_t    ctrl_hold_notes;


// Audio buffers of all kinds
volatile uint8_t current_gen_buf = 0; // set of buffers for generation
volatile uint8_t current_out_buf = 1 - 0; // set of buffers for output
static float synth1_buf[2][DMA_BUF_LEN];    // synth1 mono
static float synth2_buf[2][DMA_BUF_LEN];    // synth2 mono
static float drums_buf_l[2][DMA_BUF_LEN];   // drums L
static float drums_buf_r[2][DMA_BUF_LEN];   // drums R
static float mix_buf_l[2][DMA_BUF_LEN];     // mix L channel
static float mix_buf_r[2][DMA_BUF_LEN];     // mix R channel
static union {                              // a dirty trick, instead of true converting
  int16_t _signed[DMA_BUF_LEN * 2];
  uint16_t _unsigned[DMA_BUF_LEN * 2];
} out_buf[2];                               // i2s L+R output buffer
size_t bytes_written;                       // i2s result

volatile boolean processing = false;
#ifndef NO_PSRAM
volatile float rvb_k1, rvb_k2, rvb_k3;
#endif
volatile float dly_k1, dly_k2, dly_k3;

// tasks for Core0 and Core1
TaskHandle_t SynthTask1;
TaskHandle_t SynthTask2;

// 303-like synths
SynthVoice Synth1(0); // instance 0 to recognize from the inside
// SynthVoice Synth2(1); // instance 1 to recognize from the inside

// 808-like drums
Sampler Drums( DEFAULT_DRUMKIT ); // argument: starting drumset [0 .. total-1]

// Global effects
FxDelay Delay;
#ifndef NO_PSRAM
FxReverb Reverb;
#endif
Compressor Comp;

hw_timer_t * timer1 = NULL;            // Timer variables
hw_timer_t * timer2 = NULL;            // Timer variables
portMUX_TYPE timer1Mux = portMUX_INITIALIZER_UNLOCKED; 
portMUX_TYPE timer2Mux = portMUX_INITIALIZER_UNLOCKED; 
volatile boolean timer1_fired = false;   // Update battery icon flag
volatile boolean timer2_fired = false;   // Update battery icon flag


//START OF NEW CAP TOUCH GUI SECTION:
/* Display flushing */
void my_disp_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p)
{
#ifndef DIRECT_MODE
  uint32_t w = (area->x2 - area->x1 + 1);
  uint32_t h = (area->y2 - area->y1 + 1);
  
#if (LV_COLOR_16_SWAP != 0)
  gfx->draw16bitBeRGBBitmap(area->x1, area->y1, (uint16_t *)&color_p->full, w, h);
#else
  gfx->draw16bitRGBBitmap(area->x1, area->y1, (uint16_t *)&color_p->full, w, h);
#endif
#endif // #ifndef DIRECT_MODE
  
  lv_disp_flush_ready(disp);
}

void my_touchpad_read(lv_indev_drv_t *indev_driver, lv_indev_data_t *data)
{
  if (touch_has_signal())
    {
      if (touch_touched())
        {
          data->state = LV_INDEV_STATE_PR;
          
          /*Set the coordinates*/
          data->point.x = touch_last_x;
          data->point.y = touch_last_y;
        }
      else if (touch_released())
        {
          data->state = LV_INDEV_STATE_REL;
        }
    }
  else
    {
      data->state = LV_INDEV_STATE_REL;
    }
}
//--------END OF NEW CAP TOUCH GUI SECTION

/*
 * Timer interrupt handler **********************************************************************************************************************************
*/

void IRAM_ATTR onTimer1() {
   portENTER_CRITICAL_ISR(&timer1Mux);
   timer1_fired = true;
   portEXIT_CRITICAL_ISR(&timer1Mux);
}

void IRAM_ATTR onTimer2() {
   portENTER_CRITICAL_ISR(&timer2Mux);
   timer2_fired = true;
   portEXIT_CRITICAL_ISR(&timer2Mux);
}



/* 
 * Core Tasks ************************************************************************************************************************
*/
// forward declaration
static void IRAM_ATTR mixer() ;
// Core0 task 
// static void audio_task1(void *userData) {
static void IRAM_ATTR audio_task1(void *userData) {
  
  while (true) {
    taskYIELD(); 
    if (ulTaskNotifyTake(pdTRUE, portMAX_DELAY)) { // we need all the generators to fill the buffers here, so we wait
      c0t = micros();
      
//      taskYIELD(); 
      
      current_gen_buf = current_out_buf;      // swap buffers
      current_out_buf = 1 - current_gen_buf;
      
      xTaskNotifyGive(SynthTask2);            // if we are here, then we've already received a notification from task2
      
      s1t = micros();
      synth1_generate();
      s1T = micros() - s1t;
      
  //    taskYIELD(); 

      drt = micros();
      drums_generate();
      drT = micros() - drt;

    }
    
   // taskYIELD();

    taskYIELD();

    c0T = micros() - c0t;
  }
}

// task for Core1, which tipically runs user's code on ESP32
// static void IRAM_ATTR audio_task2(void *userData) {
static void IRAM_ATTR audio_task2(void *userData) {
  while (true) {
    taskYIELD();
    
    if (ulTaskNotifyTake(pdTRUE, portMAX_DELAY)) { // wait for the notification from the SynthTask1
      c1t = micros();
      fxt = micros();
      mixer(); 
      i2s_output();
      fxT = micros() - fxt;
      
      taskYIELD();
    
      s2t = micros();
      synth2_generate();
      s2T = micros() - s2t;
      
      xTaskNotifyGive(SynthTask1); 
    }    
    
    c1T = micros() - c1t;

    art = micros();
    
    if (timer2_fired) {
      timer2_fired = false;

#ifdef TEST_POTS      
       readPots();
#endif
       
#ifdef DEBUG_TIMING
        DEBF ("synt1=%dus synt2=%dus drums=%dus mixer=%dus DMA_BUF=%dus\r\n" , s1T, s2T, drT, fxT, DMA_BUF_TIME);
        //    DEBF ("TaskCore0=%dus TaskCore1=%dus DMA_BUF=%dus\r\n" , c0T , c1T , DMA_BUF_TIME);
        //    DEBF ("AllTheRestCore1=%dus\r\n" , arT);
#endif
    }    
    
//    taskYIELD();
    arT = micros() - art;
  }
}


/* 
 *  Quite an ordinary SETUP() *******************************************************************************************************************************
*/

void setup(void) {

//#ifdef DEBUG_ON
//#ifndef MIDI_VIA_SERIAL
  Serial.begin(115200);
//#endif
//#endif
  

  btStop(); // we don't want bluetooth to consume our precious cpu time 

  MidiInit(); // init midi input and handling of midi events

  /*
    for (int i = 0; i < GPIO_BUTTONS; i++) {
    pinMode(buttonGPIOs[i], INPUT_PULLDOWN);
    }
  */

  buildTables();

  for (int i = 0; i < POT_NUM; i++) pinMode( POT_PINS[i] , INPUT);

  Synth1.Init();
  // Synth2.Init();
  Drums.Init();
#ifndef NO_PSRAM
  Reverb.Init();
#endif
  Delay.Init();
  Comp.Init(SAMPLE_RATE);
#ifdef JUKEBOX
  init_midi(); // AcidBanger function
#endif

  // silence while we haven't loaded anything reasonable
  for (int i = 0; i < DMA_BUF_LEN; i++) {
    drums_buf_l[current_gen_buf][i] = 0.0f ;
    drums_buf_r[current_gen_buf][i] = 0.0f ;
    synth1_buf[current_gen_buf][i] = 0.0f ;
    synth2_buf[current_gen_buf][i] = 0.0f ;
    out_buf[current_out_buf]._signed[i * 2] = 0 ;
    out_buf[current_out_buf]._signed[i * 2 + 1] = 0 ;
    mix_buf_l[current_out_buf][i] = 0.0f;
    mix_buf_r[current_out_buf][i] = 0.0f;
  }

  i2sInit();
  // i2s_write(i2s_num, out_buf[current_out_buf]._signed, sizeof(out_buf[current_out_buf]._signed), &bytes_written, portMAX_DELAY);

  //xTaskCreatePinnedToCore( audio_task1, "SynthTask1", 8000, NULL, (1 | portPRIVILEGE_BIT), &SynthTask1, 0 );
  //xTaskCreatePinnedToCore( audio_task2, "SynthTask2", 8000, NULL, (1 | portPRIVILEGE_BIT), &SynthTask2, 1 );
  xTaskCreatePinnedToCore( audio_task1, "SynthTask1", 5000, NULL, 1, &SynthTask1, 0 );
  xTaskCreatePinnedToCore( audio_task2, "SynthTask2", 5000, NULL, 1, &SynthTask2, 1 );

  // somehow we should allow tasks to run
  xTaskNotifyGive(SynthTask1);
  //  xTaskNotifyGive(SynthTask2);
  processing = true;

#if ESP_ARDUINO_VERSION_MAJOR < 3 
  // timer interrupt
  /*
  timer1 = timerBegin(0, 80, true);               // Setup timer for midi
  timerAttachInterrupt(timer1, &onTimer1, true);  // Attach callback
  timerAlarmWrite(timer1, 4000, true);            // 4000us, autoreload
  timerAlarmEnable(timer1);
  */
  timer2 = timerBegin(1, 80, true);               // Setup general purpose timer
  timerAttachInterrupt(timer2, &onTimer2, true);  // Attach callback
  timerAlarmWrite(timer2, 200000, true);          // 200ms, autoreload
  timerAlarmEnable(timer2);
#else 
  timer2 = timerBegin(1000000);               // Setup general purpose timer
  timerAttachInterrupt(timer2, &onTimer2);  // Attach callback
  timerAlarm(timer2, 200000, true, 0);          // 200ms, autoreload
#endif
  
  //START OF NEW CAP TOUCH GUI SECTION:
#ifdef GFX_EXTRA_PRE_INIT
  GFX_EXTRA_PRE_INIT();
#endif
  
  // Init Display
  if (!gfx->begin())
    {
      Serial.println("gfx->begin() failed!");
    }
  gfx->fillScreen(BLACK);
  
#ifdef GFX_BL
  pinMode(GFX_BL, OUTPUT);
  digitalWrite(GFX_BL, HIGH);
#endif
  
  
  
  // Init touch device
  touch_init(gfx->width(), gfx->height(), gfx->getRotation());
  
  lv_init();
  
  screenWidth = gfx->width();
  screenHeight = gfx->height();
  
  
  
#ifdef DIRECT_MODE
  bufSize = screenWidth * screenHeight;
#else
  bufSize = screenWidth * 40;
#endif
  
#ifdef ESP32
  disp_draw_buf = (lv_color_t *)heap_caps_malloc(sizeof(lv_color_t) * bufSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
  if (!disp_draw_buf)
    {
      // remove MALLOC_CAP_INTERNAL flag try again
      disp_draw_buf = (lv_color_t *)heap_caps_malloc(sizeof(lv_color_t) * bufSize, MALLOC_CAP_8BIT);
    }
#else
  disp_draw_buf = (lv_color_t *)malloc(sizeof(lv_color_t) * bufSize);
#endif
  if (!disp_draw_buf)
    {
      Serial.println("LVGL disp_draw_buf allocate failed!");
    }
  else
    {
      lv_disp_draw_buf_init(&draw_buf, disp_draw_buf, NULL, bufSize);
      
      /* Initialize the display */
      lv_disp_drv_init(&disp_drv);
      /* Change the following line to your display resolution */
      disp_drv.hor_res = screenWidth;
      disp_drv.ver_res = screenHeight;
      disp_drv.flush_cb = my_disp_flush;
      disp_drv.draw_buf = &draw_buf;
#ifdef DIRECT_MODE
      disp_drv.direct_mode = true;
#endif
      lv_disp_drv_register(&disp_drv);
      
      /* Initialize the (dummy) input device driver */
      static lv_indev_drv_t indev_drv;
      lv_indev_drv_init(&indev_drv);
      indev_drv.type = LV_INDEV_TYPE_POINTER;
      indev_drv.read_cb = my_touchpad_read;
      lv_indev_drv_register(&indev_drv);
      
      
      //    gfx->fillScreen(RED);
      //    gfx->flush();
      //    //delay(1000);
      //    gfx->fillScreen(GREEN);
      //    gfx->flush();
      //    //delay(1000);
      //    gfx->fillScreen(BLUE);
      //    gfx->flush();
      //    //delay(1000);
      
      ui_init();
      
      Serial.println("GUI setup done");
  //--------END OF NEW CAP TOUCH GUI SECTION

}

static uint32_t last_ms = micros();

/* 
 *  Finally, the LOOP () ***********************************************************************************************************
*/

void loop() { // default loopTask running on the Core1
  // you can still place some of your code here
  // or   vTaskDelete(NULL);
  
  // processButtons();
  regular_checks();    
  taskYIELD(); // this can wait
  //START OF NEW CAP TOUCH GUI SECTION:
  lv_timer_handler(); /* let the GUI do its work */
  
#ifdef DIRECT_MODE
#if (LV_COLOR_16_SWAP != 0)
  gfx->draw16bitBeRGBBitmap(0, 0, (uint16_t *)disp_draw_buf, screenWidth, screenHeight);
#else
  gfx->draw16bitRGBBitmap(0, 0, (uint16_t *)disp_draw_buf, screenWidth, screenHeight);
#endif
#endif // #ifdef DIRECT_MODE
  
#ifdef CANVAS
  gfx->flush();
#endif
  
  delay(5);
  //--------END OF NEW CAP TOUCH GUI SECTION

}

/* 
 *  Some debug and service routines *****************************************************************************************************************************
*/

void readPots() {
  static const float snap = 0.003f;
  static uint8_t i = 0;
  static float tmp;
  static const float NORMALIZE_ADC = 1.0f / 4096.0f;
//read one pot per call
  tmp = (float)analogRead(POT_PINS[i]) * NORMALIZE_ADC;
  if (fabs(tmp - param[i]) > snap) {
    param[i] = tmp;
    paramChange(i, tmp);
  }

  i++;
  // if (i >= POT_NUM) i=0;
  i %= POT_NUM;
}

void paramChange(uint8_t paramNum, float paramVal) {
  // paramVal === param[paramNum];
  DEBF ("param %d val %0.4f\r\n" , paramNum, paramVal);
  paramVal *= 127.0;
  // switch (paramNum) {
  //   case 0:
  //     //set_bpm( 40.0f + (paramVal * 160.0f));
  //     Synth2.ParseCC(CC_303_CUTOFF, paramVal);
  //     break;
  //   case 1:
  //     Synth2.ParseCC(CC_303_RESO, paramVal);
  //     break;
  //   case 2:
  //     Synth2.ParseCC(CC_303_OVERDRIVE, paramVal);
  //     Synth2.ParseCC(CC_303_DISTORTION, paramVal);
  //     break;
  //   case 3:
  //     Synth2.ParseCC(CC_303_ENVMOD_LVL, paramVal);
  //     break;
  //   case 4:
  //     Synth2.ParseCC(CC_303_ACCENT_LVL, paramVal);
  //     break;
  //   default:
  //     {}
  // }
}


#ifdef JUKEBOX
void jukebox_tick() {
  run_tick();
  myRandomAddEntropy((uint16_t)(micros() & 0x0000FFFF));
}
#endif


void regular_checks() {
  timer1_fired = false;
  
#ifdef MIDI_VIA_SERIAL
  MIDI.read();
#endif

#ifdef MIDI_VIA_SERIAL2
  MIDI2.read();
#endif
  
#ifdef JUKEBOX
  jukebox_tick();
#endif


}

[copych]

I am definitely not able of debugging the provided code, but I can roughly describe the process of building an Arduino project. All the ino modules are joined into one file. First goes the file with the project name, all the others are joined in alphabetical order. Header files are processed after processing # directives, so #defines should be in effect already. C and cpp files are processed separately. Libraries can be cross-referenced directly from each other.

[01GOD]

The posts I read on some forums included adding some -D directives straight into the compiler bypassing the IDE, because supposedly the IDE attempts to synthesize .h files sometimes. It's an overly technical compiler mess that I may try to solve tomorrow. It's possible that, if all the includes are listed alphabetically and all the #define statements are in all the files that reference them, that may solve that...but it's such a hassle compiling and waiting to see what the next error is when there have been so many...sigh...

[01GOD]

I am definitely not able of debugging the provided code, but I can roughly describe the process of building an Arduino project. All the ino modules are joined into one file. First goes the file with the project name, all the others are joined in alphabetical order. Header files are processed after processing # directives, so #defines should be in effect already. C and cpp files are processed separately. Libraries can be cross-referenced directly from each other.

Tried the entire merge of that again 3 times tonight. Both the other project and the AcidBox project were confirmed functional AGAIN. Then simply merged one file from each and BOOM a huge compiler mess for no logical reason whatsoever. And every compiler error is related to this project. I guess that is because there are a lot of included #define statements and so on. Anyway, that is maybe the worst IDE problem mess I have ever seen, and I did native Apple platform software engineering in Xcode for numerous calendar years.

Simply kept on trying until past 2:30am tonight, because I assumed FOR SURE that it would function and thought maybe I had missed something the first 2 times when merging those. But no, I didn't. Really don't want to study that IDE in depth to learn extensive workarounds to IDE problems. I mean, it's the Arduino IDE. LOL. I can't even mention that IDE in an interview. Sigh...but platformIO seems to be the best alternative....better than learning 2 or 3 more proprietary IDE.

[01GOD]

For example, the first compiler error:
Compilation error: 'synth1_generate' was not declared in this scope

So I renamed general.ino to general.c and added some declarations, but then general.c couldn't find "Drums" after that in the AcidBox.ino because I guess .c files don't automatically get access to .ino files or some such nonsense. Really the Arduino IDE should get rid of the .ino format seemingly. That format seems to cause coding messes.

[copych]

About the mentioned error, I see some ways of fixing.

1. you can use forward declaration before the first use like this:

static void synth1_generate() ;

2. you can rename it back to .ino, so that it would work as before (.c and .cpp files are linked separately, and .cpp require "extern C" statement)
3. not the right way, but you can place the functions with their bodies (for small inline ones it's more or less forgivable) within the header files.

[01GOD]

UPDATE!!! SOLVED!!! COMPILED! It's so slow it sounds like dub, but I like nice electronic dub. Haha. Seems reordering some of the code based on what the "yield" and delay statements are doing can speed that up.

Certainly still seems good to change all the other .ino files to .c and add headers for all of them, so I plan to make a script on chatgpt to do that at some point.

Did notice the moog filter was ported from soundpipe, so that is hopefully a nice reference to use for porting that diodeladder filter I mentioned before. I plan to have a look at that also later. I have already written most of such a synth before anyway, although admittedly porting it from Swift to C doesn't sound fun.

[01GOD]

About the mentioned error, I see some ways of fixing.

1. you can use forward declaration before the first use like this:

static void synth1_generate() ;

2. you can rename it back to .ino, so that it would work as before (.c and .cpp files are linked separately, and .cpp require "extern C" statement)
3. not the right way, but you can place the functions with their bodies (for small inline ones it's more or less forgivable) within the header files.

Tonight THANKFULLY got one synth running (after removing ALL of the effects and drums) at relatively normal speed (and now weirdly it runs FASTER when an onscreen slider is moved....).

However, sadly there is a weird vibrato noise in the background ("amp noise"?) that gets louder and quieter as the synth does. And yes, it triggers with the note on. Was digging through the code to try to find why, but still haven't found the reason.

Recommendation on how to solve that? Thanks in advance. It's very near functional now...after 3 straight full days of work.

[01GOD]

Alright, I stripped it down to only one synth and discovered that the slowness is seemingly an issue with assigning tasks to different cores.
Basically the GUI must (obviously) be run on a separate core from the synthesizer. Running them on same core "blocks the main thread" (as it would be called in iOS software engineering) when a slider is moved.

I don't know if touchscreen synth sliders and knobs are possible on ESP32 in Arduino IDE because of that limitation, unless using RTOS tasks assigned to specific cores. That is A LOT more involved than I had hoped and it seems maybe easier to simply port that diodeladder filter from soundpipe and make a more efficient synth with that and a diode clipper and basic reverb and delay.

Anyway, wish the results had been better. I imagine it will run on an ESP32-P4 touchscreen, although still likely necessary to put GUI on another core for touchscreen sliders and knobs to function properly at full app speed.

[copych]

To my mind, touch gui is too much for the single esp32. I'd add another mcu for gui and control. Communication can be midi or whatever.

[01GOD]

To my mind, touch gui is too much for the single esp32. I'd add another mcu for gui and control. Communication can be midi or whatever.

That is an option, although a relatively major hassle of an option. Tonight tried to add a simple toggle button (in another .c file) based on midi_is_playing and woah, that has been VASTLY more work than expected. Really learned to hate the .ino/C/C++ combo mess of Arduino IDE.

[01GOD]

That "vibrato" frequency of the noise in background of the synth (oddly ONLY when amp is on and it changes in volume with the synth) is turning on and off at the interval the display GUI refreshes. Still hoping there is some way to use one of the amp declickers or other parameter in the project to solve that, so recommendations on how to are welcome. Tomorrow may look at putting the GUI on whatever core the synth isn't running on.

[copych]

I think that under the hood GUI library also creates RTOS tasks with some given priority, so they compete for the processor ticks. And if you want them to run on one ESP32, you'll have to figure out what task runs where.
Moogladder filter that you refer to is probably is out of use, see #defines at the top of synthvoice.h file.

[01GOD]

I did try that moog ladder filter yesterday. Sounded better (more appropriate than expected, although maybe because of the overdrive and wavefolder). I don't know what the wavefolder does, although it sounds pretty similar to a diode clipper when combined with that overdrive. Honestly that diode ladder filter emulation and diode clipper that were ported to soundpipe are likely more efficient when those are used together solo, to produce a similar sound. I am being more kind to My body today and this weekend, so I may have a go at porting one or both of those later in the weekend or next week.

Yesterday I also tried putting the GUI calls on audiotask1 and then audiotask2 also, but neither actually ran. Had put it in before the while loops, so maybe that wasn't the correct place. Anyway, later today may do some experiments with putting processes on specific cores. I assume if I put the synth's audiotask on the same core as the ESP tasks, then the GUI code would run on the core I assign to run the arduino code. That should eliminate the periodic silent points in that background noise, but I don't know where that background "amp noise" is coming from. Any theories?

Although I already deactivated a lot of things and looked through a lot of that code, I am not a DSP expert yet so there were some things I am still learning about. I am thankfully pretty expert at music production and synthesis though, and have built an electronic synth (and various oscillators) from scratch, so I suppose learning DSP style C for a week is a worthwhile investment so I can make synths without having to trudge through codebases. I know that a transfer function is basically mapping a change in frequency amplitudes (and phase offsets?), but I am still learning how to do that with discreet samples.

[copych]

I recommend you to look through this example https://github.com/copych/ESP32-dualcore-i2s . This is what I wrote to understand how to use both cores for sound synthesis.

[01GOD]

Oh, thanks! Added an RTOS task based on a tutorial. I can have a look at that also.

[01GOD]

Tonight THANKFULLY got that functioning after made a new GUI task and put it on one core and the synth on the other core.

OBVIOUSLY have looked through most of the codebase, but still haven't found WHERE to find that HORRIBLE automated volume level in acidbanger. WHERE THE F is that??? That volume modulation is SO annoying. I don't know if I know of any popular commercial song that has ever changed the volume of such a synth dynamically. Usually there is CO knob modulation, but NOT the volume knob. Partially because the volume knob included overdrive at the top of the volume.

By the way, most club sound systems (pretty sure anyway) are monophonic.

[copych]

Probably this is a compressor gained by a sidechain. Check the end of the mixing routines.

[01GOD]

Thanks! Added an encoder tonight, so been fine tuning the sound of the synth. Honestly don't know how much of the synth I will keep in it. The parameter ranges definitely need to be retuned if they are supposed to be 0 to 1. The env mod is still supposed to trigger some when it's at 0 conceptually, although it is nice to have the option to turn it off like that. Is the env mod range supposed to be from 0.5 to 1.0 maybe?

Also, there is already a method to stop that drum sampler sequencer in that jukebox?

[01GOD]

Oh, and what is the accent doing currently? I seem to remember it should set the dec to 0, and increase then act like a boosted filter envelope with a slight volume boost.

By the way, "attack" sucks on such synths generally. Accent dec control is a nice feature to have though.

[01GOD]

I mapped an encoder to Synth1.SetCutoff(); and that is thankfully functioning. I tried mapping the SetAccentLevel, but it didn't seem to do anything in the 0 to 1.0 range. Is the range much larger or does the jukebox very rarely add any accented notes?

And is already a function to change the entire volume level of the Sampler (Drums)?

Thanks in advance👍🏻

[copych]

Accent level should affect both timing (shorten) and the level of envelopes. Sampler.setVolume(float lvl) should work also, but this is a subject to check. There might be something unfinished.

[01GOD]

Ah. Right, I remembered shortening the envelopes in that other synth also. I think I had added a resonance envelope for accent also maybe.

I hope there is a Sampler.setVolume(float lvl). I looked around in the code for that tonight, but I forced Myself to rest.

Any example of a known good function in the codebase for setting the MIDI CC parameters that have #define statements? (or are those not linked to any functions anyway yet?)

[copych]

Check midi_config.h for the assignments

[01GOD]

Thanks! Actually seems that Synth1.ParseCC() does function for controlling MIDI CC.

[01GOD]

Recommend how best to adjust the compressor or filter so it doesn't do the standard bass/volume attenuation when resonance is high? Some filter emulations have a bool or var to control that seemingly. Most producers use a compressor.

And yes, talking about when the CO knob is turned up and reso is high.

[01GOD]

By the way, now with control over the CO and od and disto, it sounds nice generally (aside from some attenuation when reso is high, but that is what the analog circuit sadly does also...thus compressors).

Main thing that seems to need to be tuned sound-wise is the accent. Can explain some about how the accent emulation is designed? Saw there is Accent Level and "accentation". What are those?

By the way, the worst part of the Korg volca bass is the added "attack" control. Recommend removing that ramp from acidbanger, because changing that param from 0 or near 0 certainly doesn't seem to make "bangers".

[01GOD]

Confirmed now in ABL3 and also on the Donner B1 (clone-ish analog) the ENV MOD knob does affect ACCENT, but the DEC knob doesn't affect ACCENT in any way.

Having a second ACCENT_DEC control would be nice though, with minimum setting at correct emulation fixed length. In the Phoscyon soft synth there is an ACCENT_DEC control and that is a nice control to have. Likely easier to make that a control while tuning it to proper fixed length anyway.

[01GOD]

Obviously a little annoying that ENV_MOD affects ACCENT also, but I guess having 2 envelopes with ENV_MOD controlling the scalar of both is a solution for that.

(Accented notes get routed to normal envelope, accented notes get routed to accent envelope.)

[01GOD]

New DEC min length is too long also. Original could go all the way to 0, and that was cool. Setting the original to about 0.1 (10 or so in MIDI) had nice results that sounded more correct.

[01GOD]

How about simplifying the envelopes like this to make them easier to deal with?:

1. Calculate duration of A stage and D stage based on BPM and DEC control. (only BPM calc for A stage)
2. Divide those durations by number of samples in each stage.
3. Calculate number of steps between current CO offset and peak CO offset of envelope, based on number of samples.
4. Make a counter that iterates up (each sample, or 2nd sample, or 10th sample) to that CO offset (up to peak envelope frequency) for the A stage, so it's like a "for loop" that steps ever sample (or 2nd or 10th).
5. Do similar for the D stage, but the other direction.

That seems simpler, and thus easier to adjust and fine tune later.

[01GOD]

On the prior edition of Synthvoice (before that new AD), I had added this scalar to make the ENV_MOD sound more correct:
case CC_303_ENVMOD_LVL:
_envMod = (7.0 * ((float)cc_value * MIDI_NORM));
break;

[01GOD]

This thing in synthvoice.ino in S3-Regular branch seems weird:
inline void SynthVoice::SetEnvModLevel(float normalized_val) {
_envMod = normalized_val;
_filter_freq_cut = knobMap( normalized_val, _filter_freq, _filter_freq_mod);
};

[01GOD]

And this in synthvoice.h:
float _cutoff = 0.0f; // 0..1 normalized freq range. Keep in mind that EnvMod set to max practically doubles this range
float _filter_freq = 250.0f; // cutoff freq, Hz
float _filter_freq_mod = 2740.0f;
float _filter_freq_cut = 250.0f;
float _filt_avg = 400.0f;

[copych]

I can't get focused on the problem right now, and I can't remember what are those corrections for different cutoff values causing unwanted coupling.
This version in general is quite naive and straight forward. In base it has 2 envelope generators: ADSR for amp and AD for filter cutoff.
You can freely comment/strip out what you don't like and hear the effect.
Also there's a 2D compensation matrices intended for decoupling level dependency on CUTOFF/RESO and DIST/OVDR, which would be wise to turn off during initial sound tuning, and then build the new ones as a final step (if needed).

[01GOD]

Ah. Yeah, it's kinda burly to sift through and modify.
Today found and modified this in noteOn, expecting that setting it to constant vals would eliminate the ENV_DEC control changing the accented notes...but it sadly and surprisingly didn't:
if (_accent) {
_accentation = _accentLevel;
AmpEnv.setReleaseTimeMs(_ampReleaseMs * 50.0f);
FltEnv.setDecayTimeMs(200);
// FltEnv.setDecayTimeMs(_filterAccentDecayMs );
FltEnv.setAttackTimeMs(10);
} else {

[01GOD]

Guess I should make another instance of that AD class and link that to accent with the ENV_MOD scalar applied to both.

[01GOD]

Any quick advice on how to set minimum envelope dec range controllable from the MIDI ENV_DEC control? (On prior edition that could be set all the way to 0 length seemingly)

[01GOD]

Oh, found it (was MUCH easier there than doing that elsewhere):
case CC_303_DECAY: // Env release
tmp = (float)cc_value * MIDI_NORM;
_filterDecayMs = knobMap(tmp, 20.0f, 2000.0f);
//_ampDecayMs = knobMap(tmp, 15.0f, 7500.0f);
break;

[copych]

yes, exactly SynthVoice::ParseCC() is the correct place to modify or add MIDI interaction.

[01GOD]

Thanks for confirming that. Massaged the code some hours more today, and now it sounds much closer to how I wanted it to. Still planning to add a second envelope for Accent though, as it's simply not supposed to be affected by ENV_DEC and because I like having a control for Accent anyway.

Thanks again for posting that code and maintaining these nice projects!

[01GOD]

Hi! Today been working for hours to eliminate those short click sounds. What I have figured out is that those click sounds seem to only occur on some slide/glide notes (which slide notes may vary depending on BPM). So not seemingly related to accented notes. Only notes that are slide/glide notes.

Currently trying different solutions. Any recommendation?

[01GOD]

Wow, "mipmap oscillator" sounds impressive! It's possible that logic making the clicks is in the sequencer code I wrote. I replaced most of acidbanger, but I should refactor the sequencer because it was a bit of a mess after doing that. Today was modifying a noteOn function in the sequencer to try to remove what seems to be an envelope trigger after a note with glide (possibly that click sound). That noteOn function wasn't behaving logically, so it seems like I should refactor it to make it behave logically.

[01GOD]

The 2024 style ENV stages made it easier to figure out what was happening and at what point. Sounded about the same, but the accent sounds better in the June 2025 S3-Regular. Happen to know what made the accent better in that, so I can modify the 2024 main edition to make it sound more like that?
Was it mainly the A and D durations in the accent filter envelope, or is the June 2025 accent envelope modifying different parameters?
Thanks in advance for advising what is different on those, if possible.

[01GOD]

By the way, using END_FAST instead of END_NOW in SynthVoice::note_on() thankfully has removed MOST of the tiny click sounds. I imagine a slightly longer ramp would eliminate those completely.

if (mva1.n == 1 || !AmpEnv.isRunning()) { // Retrigger for first note or if envelope is off
if (_accent) {
_accentation = _accentLevel;
AmpEnv.setReleaseTimeMs(_ampReleaseMs * 50.0f);
FltEnv.setDecayTimeMs(200);
FltEnv.setAttackTimeMs(_filterAccentAttackMs);
} else {
_accentation = 0.0f;
AmpEnv.setReleaseTimeMs(_ampReleaseMs);
FltEnv.setDecayTimeMs(_filterDecayMs);
FltEnv.setAttackTimeMs(_filterAttackMs);
}

// AmpEnv.retrigger(Adsr::END_NOW); // Ensure envelope retriggers
AmpEnv.retrigger(Adsr::END_FAST);
FltEnv.retrigger(false);

}

[01GOD]

PS: I know "delta" is a change and "k" is a coefficient, but honestly var names that are self-documenting would be appreciated and are recommendable. Worst thing about soundpipe is probably how cryptic the names of some things are in the code.

[01GOD]

For example, there is literally a var named "x_" in the ADSR code. LOL...
Sometimes I think of things such as self-documenting var and function names as like Me doing a favor now for Me later when I look at the code some months or calendar years later.

[01GOD]

And why do this?:
'
AmpEnv.retrigger(Adsr::END_NOW);
FltEnv.retrigger(false);
'
When should there ever be a VCA envelope retrigger without a VCF envelope retrigger?

[01GOD]

Been surprisingly challenging to get that last thing done in the sequencer:
Glide/Slide on note 1 makes it portamento glide (pitch bend) into next note WITHOUT retriggering the envelope on the next note (REGARDLESS of if the next note has glide on).

All of the other basics are done (aside from switching between short/long notes, but those aren't in most emulations and some hardware anyway). Right now, the sequencer only portamento slides 2 notes if BOTH are set to slide/glide. And when slide is on only 1 note, then it simply makes that note long (in its step). That prevents multiple slide notes in a row though (slide on 1, off on 2, slide on 3, etcetera). Think that was maybe a problem the Donner B1 hardware synth had in its first firmware also.

[01GOD]

For example, in void SynthVoice::note_on() in the June 2025 edition of S3-Regular:
'if (_slide) {
_deltaStep = (_effectiveStep - _currentStep) * (1000.0f * DIV_SAMPLE_RATE / _slideMs );
}
'
That seems to be the ONLY logic for slide in there...so how does it know to not retrigger the next note's envelopes?

[copych]

This is not the only logic behind slides. Check the routines to run on noteOn.

[01GOD]

Did about 9 hours of work on this today to simply try to get that glide behavior functioning proper. Made an elaborate explanation for 3 of the most popular AI models and they all failed HORRIBLY (numerous times). At one point grok 3 did a long analysis for more than 4 minutes and then posted functional (after I edited it), but very wrong code.

I made an explainer (without AI) to map the sequence of function calls, so I could isolate where the glides and noteoffs and so on happen.
Had very explicitly explained the goal behavior to those various AI and asked the AI to analyze it and find the solution. I know it's easy coding, but FINDING WHERE and what SPECIFICALLY to modify in this EXTREMELY long and complicated sequence of function calls was the main reason for asking the AI to analyze it and find that.
Sadly all of those AI LLMs failed so HORRIBLY.

Anyway, here is that map of the sequence of function calls I made before asking the AI to analyze it:
Flow of glides:

1. Start button calls: startButtonPatternLoader() and OMNI_do_midi_start()
2. ‘startButtonPatternLoader()’ calls ‘OMNI_Load_A_Synth_Pattern_Logic(pending_pattern)’ to load a pattern
3. ‘OMNI_do_midi_start()’ sets ‘midi_playing = 1;’
4. ‘OMNI_run_tick()’ is called from ‘OMNI_regular_checks()’ that is called in ‘loop()’, and that ‘OMNI_run_tick()’ uses ‘midi_playing’ as a conditional in it to run ‘OMNI_do_midi_tick()’
5. ‘OMNI_do_midi_tick()’ conditionally calls ‘instr_noteoff(0)’ based on ‘if (midi_tick == 1 && ins->playing_note && OMNI_memories[OMNI_cur_memory].patterns[0].glides[midi_step] != 1)’
6. ‘OMNI_do_midi_tick()’ calls ‘OMNI_sequencer_step(midi_step)’
7. ‘OMNI_sequencer_step(midi_step)’ calls ‘instr_noteon()’ and that calls ‘instr_noteon_raw()’ or ‘instr_noteoff(i)’ based on conditional ‘noteNum > 0’
8. instr_noteon_raw() calls ins->noteon and that is a function pointer alias of send_midi_noteon()
9. If MIDI is internal (not through external MIDI USB), send_midi_noteon() calls handleNoteOn( chan, note, vol)
10. handleNoteOn( chan, note, vol) calls Synth1.on_midi_noteON(inNote, inVelocity)
11. Synth1.on_midi_noteON() calls ‘mva_note_on(&mva1, note, (velocity >= 80))’ (Note: that is actually: ‘SynthVoice::mva_note_on()’) and ‘note_on(note, slide, accent)’ (Note: That is actually: ‘SynthVoice::note_on() and it’s maybe th emost important noteOn function as it does A LOT)
12. Synth1.on_midi_noteON() also sets these: ‘bool slide = (mva1.n > 1)’ , bool accent = (mva1.accents[0])’ , ‘note = mva1.notes[0] ‘
13. SynthVoice::note_on() does A LOT, including conditional ‘AmpEnv.retrigger(Adsr::END_FAST)’ and ‘FltEnv.retrigger(false)’ based on conditional ‘(mva1.n == 1 || !AmpEnv.isRunning())’
    That SynthVoice::note_on() function also contains:
    ‘
    if (slide) {
    deltaStep = (effectiveStep - currentStep) * (1000.0f * DIV_SAMPLE_RATE / slideMs );
    } else {
    currentStep = effectiveStep;
    deltaStep = 0.0f;
    phaze = 0.0f;
    }
    k_acc = (1.0f + 0.6f * accentation);
    ‘
    Here are ‘Adsr::retrigger()’ (ADSR) and ‘FltEnv.retrigger()’ (AD only):
    ‘void Adsr::retrigger(eEnd_t hardness) {
    //DEBF("ADSR: %0.10f %0.10f %0.10f %0.10f\r\n", attackD0, decayD0, sus_level, releaseD0);
    gate = true;
    mode = ADSR_SEG_ATTACK;
    switch (hardness) {
    case END_NOW:
    x = 0.0f;
    D0 = attackD0;
    break;
    case END_FAST:
    case END_SEMI_FAST:
    case END_REGULAR:
    default:
    D0 = attackD0;
    }
    }’

‘void AD_env::retrigger(bool hard) {
gate_ = true;
mode_ = AD_SEG_ATTACK;
if (hard) {
x_ = 0.0f;
D0_ = attackD0_;
peakLevel_ = 1.0f;
attackTarget_ = peakLevel_ + 0.1f;
} else {
D0_ = attackD0_;
peakLevel_ = 1.0f + (fast_shape( x_ ));
attackTarget_ = peakLevel_ + 0.1f ;
}
}
‘

FUNCTIONS:

static void OMNI_do_midi_start() {
midi_playing = 1;
midi_tick = MIDI_TICKS_PER_16TH - 1;
midi_step = -1;

//send_midi_start(); actually seems to only have been declared, so it doesn’t seem to do anything
send_midi_start();
}

void OMNI_run_tick() {
/* Run button scan at 250 Hz */
now = millis();

/* If MIDI is playing, then check for tick /
if (midi_playing && (now - last_midi_tick) >= midi_tick_ms) {
OMNI_do_midi_tick();
last_midi_tick += midi_tick_ms;
if (last_midi_tick < now) {
/ we are at least one tick late, give up */
last_midi_tick = now;
}
}
}

static void OMNI_do_midi_tick() {
doing_MIDI_Tick = 1;

midi_tick++;

//OMNI EDIT: ADDING noteOff halfway between 16th notes:
Instrument *ins = &instruments[0];
((OMNI_memories[0].patterns[0].accent >> (midi_step)) & 1) != 1) {

//OMNI EDIT 03272025:
if (midi_tick == 1 && ins->playing_note && OMNI_memories[OMNI_cur_memory].patterns[0].glides[midi_step] != 1) {

instr_noteoff(0);

}

if (midi_tick >= MIDI_TICKS_PER_16TH) {
midi_tick = 0;
midi_step++;

if (midi_step >= PatternLength) {
  bar_current++;
  midi_step = 0;
  
}
OMNI_sequencer_step(midi_step);
if (midi_step==0){
  past_midi_step=15;
}else{
past_midi_step=midi_step-1; 
}

}
doing_MIDI_Tick = 0;

}

‘OMNI_sequencer_step(byte step)’ contains this conditional:
if (noteNum > 0){
instr_noteon(i, noteNum, glide, accent);
}else{
instr_noteoff(i);
}

MOST IMPORTANT FOR GLIDES SEEMINGLY:

static void instr_noteon_raw(byte instr, byte note, byte vol, byte do_glide) {
Instrument *ins = &instruments[instr];
// All instruments are monophonic, so noteoff before noteon
if (ins->playing_note != 0) {
//OMNI EDIT HERE TO MAKE SLIDE FUNCTION PROPERLY SEEMINGLY:
if ((do_glide || OMNI_memories[0].patterns[0].glides[past_midi_step] == 1) && !ins->is_drum){

  // Implement glide by playing two notes at once. Also known as "fingered glide"
  if (ins->noteon != NULL)
    ins->noteon(ins->midi_channel, note, vol);
    //OMNI EDIT: 11 four, hoping commenting this next line will make slide function properly: 
  instr_noteoff(instr);
  ins->playing_note = note;
  return;
}
instr_noteoff(instr);

}
if (ins->noteon != NULL)
ins->noteon(ins->midi_channel, note, vol);
ins->playing_note = note;
}

static void send_midi_noteon(byte chan, byte note, byte vol) {
#ifdef MIDI_VIA_SERIAL
MIDI.sendNoteOn(note, vol, chan);
#endif
#ifdef MIDI_VIA_SERIAL2
MIDI2.sendNoteOn(note, vol, chan);
#endif
handleNoteOn( chan, note, vol) ;
}

inline void handleNoteOn(uint8_t inChannel, uint8_t inNote, uint8_t inVelocity) {
#ifdef DEBUG_MIDI
DEB("MIDI note on ");
DEBUG(inNote);
#endif
if (inChannel == DRUM_MIDI_CHAN ) {Drums.NoteOn(inNote, inVelocity);}
else if (inChannel == SYNTH1_MIDI_CHAN ) {Synth1.on_midi_noteON(inNote, inVelocity);}
// else if (inChannel == SYNTH2_MIDI_CHAN ) {Synth2.on_midi_noteON(inNote, inVelocity);}
}

inline void SynthVoice::on_midi_noteON(uint8_t note, uint8_t velocity)
{
mva_note_on(&mva1, note, (velocity >= 80));

bool slide = (mva1.n > 1);
bool accent = (mva1.accents[0]);
note = mva1.notes[0] ;
note_on(note, slide, accent);
}

void SynthVoice::mva_note_on(mva_data *p, uint8_t note, uint8_t accent)
{
uint8_t s = 0;
uint8_t i = 0;

// shift all notes back
uint8_t m = p->n + 1;
m = (m > MIDI_MVA_SZ ? MIDI_MVA_SZ : m);
s = m;
i = m;
while (i > 0)
{
--s;
p->notes[i] = p->notes[s];
p->accents[i] = p->accents[s];
i = s;
}
// put the new note first
p->notes[0] = note;
p->accents[0] = accent;
// update the voice counter
p->n = m;
}

This is seemingly the most important noteOn function:
void SynthVoice::note_on(uint8_t midiNote, bool slide, bool accent) {
_accent = accent;
_slide = slide || _portamento;
_targetStep = midi_tbl_steps[midiNote];
_effectiveStep = _targetStep * _tuning * _pitchbend;

// if(OMNI_memories[0].patterns[0].glides[past_midi_step] == 0){
//Put this in a conditional based on if past step was a glide:
if (mva1.n == 1 || !AmpEnv.isRunning()) { // Retrigger for first note or if envelope is off
if (_accent) {
_accentation = _accentLevel;
AmpEnv.setReleaseTimeMs(_ampReleaseMs * 50.0f);
FltEnv.setDecayTimeMs(200);
FltEnv.setAttackTimeMs(_filterAccentAttackMs);
} else {
_accentation = 0.0f;
AmpEnv.setReleaseTimeMs(_ampReleaseMs);
FltEnv.setDecayTimeMs(_filterDecayMs);
FltEnv.setAttackTimeMs(_filterAttackMs);
}
//OMNI EDIT 081025: Seemingly eliminated the click sounds:
AmpEnv.retrigger(Adsr::END_FAST);
//ORIGINAL:

// AmpEnv.retrigger(Adsr::END_NOW); // Ensure envelope retriggers

//------
FltEnv.retrigger(false);

}
AmpEnv.setAttackTimeMs(_ampAttackMs);
AmpEnv.setDecayTimeMs(_ampDecayMs);
// }
//----------------
if (_slide) {
_deltaStep = (_effectiveStep - _currentStep) * (1000.0f * DIV_SAMPLE_RATE / _slideMs );
} else {
_currentStep = _effectiveStep;
_deltaStep = 0.0f;
_phaze = 0.0f;
}
_k_acc = (1.0f + 0.6f * _accentation);
}

static void instr_noteon_raw(byte instr, byte note, byte vol, byte do_glide) {
Instrument *ins = &instruments[instr];
// if (do_glide==0 && !ins->is_drum) {
// // currentNoteSlideOn=0;
// // printf("CurrentNoteSlideOn is set to 0\n");
// }

// All instruments are monophonic, so noteoff before noteon
if (ins->playing_note != 0) {
//OMNI EDIT HERE TO MAKE SLIDE FUNCTION PROPERLY SEEMINGLY:
if ((do_glide || OMNI_memories[0].patterns[0].glides[past_midi_step] == 1) && !ins->is_drum){
//ORIGINAL HOPEFULLY:
// if (do_glide && !ins->is_drum) {

  // currentNoteSlideOn=1;
  // printf("CurrentNoteSlideOn is set to 1\n");
  // Implement glide by playing two notes at once. Also known as "fingered glide"
  if (ins->noteon != NULL)
    ins->noteon(ins->midi_channel, note, vol);
    //OMNI EDIT: 11 four, hoping commenting this next line will make slide function properly: 
  instr_noteoff(instr);
  ins->playing_note = note;
  return;
}
instr_noteoff(instr);

}
if (ins->noteon != NULL)
ins->noteon(ins->midi_channel, note, vol);
ins->playing_note = note;
}

[01GOD]

A full day of actual work with no substantial progress SUCKED. Tonight the resulting code is literally from yesterday night so far. I guess I shouldn't expect that an AI LLM can analyze something so complex logically.

[01GOD]

Been stepping through that function call sequence and editing each function along the way that is related to glide (perfectionist maniac? Maybe).

Commenting out this first 'instr_noteoff(instr)' (the one inside the "if glide is on for current or last note" conditional) seems to cause no noteOff to ever trigger...and that has been so illogical. Why would it cause that?:

static void instr_noteon_raw(byte instr, byte note, byte vol, byte do_glide) {
Instrument *ins = &instruments[instr];
// All instruments are monophonic, so noteoff before noteon
if (ins->playing_note != 0) {
//OMNI EDIT HERE TO MAKE SLIDE FUNCTION PROPERLY SEEMINGLY:
if ((do_glide || OMNI_memories[0].patterns[0].glides[past_midi_step] == 1) && !ins->is_drum){
// Implement glide by playing two notes at once. Also known as "fingered glide"
if (ins->noteon != NULL)
ins->noteon(ins->midi_channel, note, vol);
//OMNI EDIT: 11 four, hoping commenting this next line will make slide function properly:
instr_noteoff(instr);
ins->playing_note = note;
return;
}
instr_noteoff(instr);
}
if (ins->noteon != NULL)
ins->noteon(ins->midi_channel, note, vol);
ins->playing_note = note;
}

[copych]

Ouch. It's Acidbanger code. It is certainly requires refactoring. Probably it's not the right place to search for logic...

[01GOD]

LOL. There is still a little of ab in there. I should remove it later. At this point kinda wish I had simply removed all of it aside from the "midi tick" part when I started.

[01GOD]

Observations at this point (prior to the mip-map oscillator on S3-regular):

1. Recommendable to revert to the pre-mip-map-oscillators edition of that repo, and change that release envelope to what I recommended earlier, to eliminate those prior click sounds. Because generally, aside from envelope fine tuning that can be done, it sounds good. Obviously that mip-map oscillator is likely cool and maybe doesn't alias. I am simply saying that it's seemingly not necessary though.
2. The glide functionality is seemingly correct in that June edition, and it seems I had been incorrectly trying to make the sequencer more like ABL3 than hardware synths.

[01GOD]

Something important to remember when doing the envelopes is that the synth product had been designed as a replacement for a bassist (in the era of when "tokyo pop" was basically a japanese copy of disco). So slap bass kinda sounds were surprisingly what it's supposed to be doing, thus the transients on the envelopes are supposed to be kinda strong.

[01GOD]

Ah, I see now that clicks happen in that June edition of S3-regular repo when envelope ramps are too fast over a large range.
Does that happen in that newer edition with mip-map oscillator?

[01GOD]

That simple diode clipper I made sounds good on saw waves, but not on square waves. I suppose that is because the waves that are more square have more upper harmonics and maybe those are "folding back into" the output samples as fake (alias) lower frequency waves.

[copych]

The matter is that simple clipper has almost no affect on a square signal, cause clipping by its nature is making any signal square, while square signal is already of this kind.

[01GOD]

Right, but this square wave isn’t so square if it’s an accurate emulation. Is it actually a normal square wave in this emulation? Using a soft clipper had more of a consistent effect on both waves, although hard clipper sounds better on saw wave. May make a toggle to switch between those, for now.

…

On Sat, Aug 16, 2025 at 5:20 PM copych ***@***.***> wrote: The matter is that simple clipper has almost no affect on a square signal, cause clipping by its nature is making any signal square, while square signal is already of this kind. — Reply to this email directly, view it on GitHub <#30 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ACJ7JDSWM5X4NU4OG4MYRMD3N3STZAVCNFSM6AAAAAB7P2HRIGVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTIMJSGQ3TAOI> . You are receiving this because you were mentioned.Message ID: ***@***.***>

[copych]

No, not quite. And even further, after any filtering it becomes less square. This is the place where makeup filters matter.

[01GOD]

Hi! Today tried adding this to SynthVoice::getSample() to boost the reso on accented notes, but it seems maybe that is too much for the CPU to handle. Is that why didn't include accent modulation of resonance before?:
' if (_accentation) {
Synth1.ParseCC(CC_303_RESO, (127.0 * (_reso + (1.0 * filtEnv))));
}'

[01GOD]

Actually that was in 'SynthVoice::getSample()'

[copych]

You shouldn't compute this for every sample, just set this in control thread on noteOn

[01GOD]

I had tried that also. and it was still a little noisy. I guess I can remove the MIDI CC middleman call to make it more efficient and see how that sounds though. Obviously the P4 should make it possible to do that on every sample, add more effects, and A LOT more than that also.

…

On Mon, Aug 25, 2025 at 7:05 PM copych ***@***.***> wrote: You shouldn't compute this for every sample, just set this in control thread on noteOn — Reply to this email directly, view it on GitHub <#30 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ACJ7JDSFHODBOAQRLNAKBKD3PLNW7AVCNFSM6AAAAAB7P2HRIGVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTIMRQHEYDAOA> . You are receiving this because you were mentioned.Message ID: ***@***.***>

[01GOD]

By the way, if have any friends in russia with access to buttons to launch nukes to nuke china, tell them that sadly too many chinese are evil and china ABSOLUTELY should be nuked TODAY.
I so wish that russia was invading china instead of ukraine, as chinese are the main enemy of russians in this part of the World.

[01GOD]

One of My dreams is for the US and russia to team up together to eradicate the governments of china, north korea, and israel.
Nuking beijing and pyongyang would be SO AWESOME AND WONDERFUL for this part of the World. Actually many south korean males are also corrupt lying scumbags, so wouldn't be a big loss for the World if accidentally nuked south korea also.