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]

EDITED because still comparing sound and adjusting parameters.

[01GOD]

Edited again: Sigh...tuning filters and envelopes on such synths is such a delicate art.
When I made that iPad app, I think I pushed resonance up to right before it would self-oscillate (think that was the point where that filter emulation would "explode"). Resonance seems to be the auditory "crispiness" filter parameter above a certain setting.

[copych]

To make the synth tuning more convenient it would be wise to exclude multiple compilings just to change some variable a bit. For that case there is a void paramChange(uint8_t paramNum, float paramVal) in the Acidbox.ino where paramNum is a pot number (currently 0 to 2), and paramVal is pot value (0 to 1.0). This function is regularly called with the updated values.

[01GOD]

To make the synth tuning more convenient it would be wise to exclude multiple compilings just to change some variable a bit. For that case there is a void paramChange(uint8_t paramNum, float paramVal) in the Acidbox.ino where paramNum is a pot number (currently 0 to 2), and paramVal is pot value (0 to 1.0). This function is regularly called with the updated values.

Thanks! Yes, I use that. I plan to shoosh on the parameter tuning recommendations until I tune most of them better. There is obviously some interplay, so tuning such filters and envelopes is a relatively precise art.

[01GOD]

Actually seems that the resonance control has a cap to prevent it from going beyond a certain point, so about 1.0 to 1.5 seems to be max possible. There is likely a line I can change somewhere in the filter or synthvoice to allow more reso though.

[copych]

It must be an indirect limitation, cause if i remember correctly, i have added some limitations for the filter coefficients so they won't overflow float type

[01GOD]

Ah. Seems the max resonance of that LP18 filter (as it is in the code) maybe isn't enough resonance (a tight enough resonance peak?) to accurately emulate that roland. However, it could be the shape of the envelope that is the issue.

That filter envelope has exponential dec curve?
(I guess I can look through the filter table, but visualizing that curve by simply looking at the numbers doesn't sound fun.)

[01GOD]

Estimating that reso is capped at maybe about 2/3 of what max should be.

[01GOD]

So tired of the jooz' wars. Sigh...2 of them happening in different parts of the World. That international cabal MUST BE STOPPED!!!

(Edited to prevent any from that cabal from false flagging the thread, as they sadly have rampantly censored youtube and so on)

[copych]

Perfect sense, Part 1 (Roger Waters)

[01GOD]

Saw some of his talks on that topic before. Thanks. I unplugged from the joo-tricks some calendar years ago. Prior to then I was skeptical, then saw how BLATANTLY OBVIOUS so much of it has been.

I can't tolerate them causing these wars and so on anymore. Sadly both Trump and Putin wore yamulkas at some point, thus sadly neither of them seems to be against that cabal enough to end it completely. And that total mess called kamala is a puppet that is literally married to a member of that corrupt, deceitful international cabal. Somewhat of a false dichotomy of candidates, as most AMERICANS hate israel and don't want to be involved in either of those joo scam wars. Those are literally international scams.

Anyway, I could rant about that for hours. I am partially tuning this synth today to try to ignore all of that today.

[01GOD]

So is that resonance code to edit to get more resonance likely inline void SetReso(float lvl) {_reso = constrain(lvl, 0.0f, 1.0f); Filter.SetResonance(_reso); }; in synthvoice.h, or some code in rosic_TeeBeeFilter.h and rosic_TeeBeeFilter.ino, or in the following code in config.h?:

float cutoff_reso[16][16] = { // k-weigted mean quad
{6.434804, 4.714645, 3.947374, 2.694166, 2.351397, 2.500912, 2.929582, 2.654394, 2.284407, 1.838856, 2.644853, 2.766961, 2.814959, 2.350692, 1.996572, 2.199751},
{6.612917, 5.302139, 3.893952, 2.907703, 2.001597, 2.857677, 2.988061, 3.030843, 2.442840, 2.147922, 2.721878, 2.790063, 2.963842, 2.972988, 2.489201, 2.509848},
{7.350744, 5.508491, 4.067600, 2.890480, 2.176190, 2.566737, 2.546578, 2.596522, 2.278280, 1.956051, 2.581862, 2.548600, 3.036592, 2.538826, 2.439919, 1.898532},
{8.183912, 5.427793, 4.194474, 2.903769, 2.359180, 2.242266, 2.286241, 3.119573, 3.544204, 3.191301, 2.518959, 2.913494, 4.572999, 5.861769, 4.722514, 3.665691},
{7.280022, 4.675759, 3.778736, 3.111181, 2.431638, 2.358587, 2.270216, 2.901183, 3.002531, 2.652288, 1.998837, 2.844437, 3.059708, 3.341244, 2.923321, 2.497309},
{6.960493, 4.442485, 3.891997, 3.066457, 2.455318, 1.855044, 2.421693, 2.687097, 2.769465, 2.300333, 2.023683, 2.392432, 2.613516, 2.961050, 2.950050, 2.489161},
{6.600060, 4.763449, 4.023485, 3.143195, 2.520189, 1.899933, 2.254261, 2.552054, 2.955580, 3.250866, 2.693074, 2.982439, 2.930238, 4.417704, 5.190308, 4.485150},
{5.806700, 5.164190, 3.994584, 3.393530, 2.460938, 2.048136, 2.080137, 2.109953, 2.448718, 2.548533, 2.194179, 2.070688, 3.086098, 4.052840, 4.070950, 3.569471},
{6.268085, 4.558399, 3.507618, 2.848771, 2.446060, 1.948153, 2.073992, 2.101269, 2.966322, 3.262701, 3.049813, 2.411024, 3.578253, 4.676841, 5.917085, 5.060090},
{6.759351, 4.216856, 3.118927, 2.793170, 2.484806, 2.031502, 1.679651, 2.196030, 2.861528, 3.392502, 3.039659, 2.682046, 3.355549, 3.709728, 4.872293, 5.756225},
{6.830225, 4.422283, 3.082938, 2.982032, 2.476420, 2.165540, 1.598023, 2.144882, 2.456352, 2.995122, 2.919489, 2.632485, 3.150194, 3.483125, 5.059742, 6.296432},
{7.835934, 3.491278, 3.291606, 2.806850, 2.564085, 2.023950, 1.767282, 1.784284, 1.954406, 2.394825, 2.952084, 2.615514, 2.811204, 3.472478, 5.163306, 6.343526},
{8.392389, 3.504093, 3.044849, 2.386751, 2.225955, 1.887471, 1.583561, 1.604031, 1.729157, 2.363731, 2.771977, 2.687573, 2.257057, 3.599182, 5.251308, 6.766300},
{8.595600, 3.864176, 2.557690, 1.968429, 1.866560, 1.764059, 1.478550, 1.335737, 1.606975, 2.199224, 2.646084, 2.557677, 2.242978, 3.037829, 3.686971, 5.391070},
{9.063289, 3.624348, 2.342058, 1.823246, 1.851653, 1.604091, 1.497541, 1.124157, 1.500818, 1.905059, 2.288400, 2.217282, 2.097532, 2.477182, 2.971320, 4.915813},
{9.551075, 3.699403, 1.972151, 1.721147, 1.624085, 1.514310, 1.259587, 1.062701, 1.170411, 1.331594, 1.649718, 2.004076, 1.807243, 2.236462, 2.674345, 4.867586},
};
const float cutoff_reso_avg = 3.19f;

[copych]

nope these figures are to compensate volume only, no affect on timbre

[01GOD]

Ah. There is some burly looking maths code inside of rosic_TeeBeeFilter that I don't want to sit through hours of compiling to figure out what to modify.

So the "constrain" part of that code only does audio volume limiting to range of 0.0 to 1.0?:
inline void SetReso(float lvl) {_reso = constrain(lvl, 0.0f, 1.0f); Filter.SetResonance(_reso); }; in synthvoice.h

I tried 2.0 and it admittedly maybe was only making the whistling sound louder (instead of making the saw wave chirp sound "crispier") when reso was boosted past 1.0 or so after modified that line.

[01GOD]

Ah, pushed that and it basically made the filter go into some kinda weird spacey sounding mode, maybe interesting for some ambient music...

I am vaguely considering porting that diode.c (diode ladder emulation) from soundpipe again. That one sounds so properly "crispy".

[01GOD]

Some of today sounded like the last scene of "close encounters of the third kind" where one synth was teaching another synth how to talk.

[01GOD]

Sigh...tuning an emulation of that analog synth is kind of silly beyond a certain point, because most of the analog synths sound slightly different anyway.

When I changed something to make it sound more "accurate", sometimes I maybe don't actually LIKE how it sounds more than how it did before. Regardless of it being a more "accurate" emulation.

[copych]

So the "constrain" part of that code only does audio volume limiting to range of 0.0 to 1.0?:
inline void SetReso(float lvl) {_reso = constrain(lvl, 0.0f, 1.0f); Filter.SetResonance(_reso); }; in synthvoice.h

Yes, this guarantees that the whole midi cc range 0-127 will fully map to 0-1 range for the filter input.

Line 102 of rosic_TeeBeeFilter.ino

  resonanceSkewed = (1.0f - exp(-3.0f * resonanceRaw)) / (1.0f - exp(-3.0f));

you can try to push the limit and apply some multiplicator to the resulting resonanceSkewed, which will then be used to calc the filter coeffitients. BUT in realtime it uses calculateCoefficientsApprox4(), and I am not sure if the polynomial interpolation does extrapolation well.

PS. I've tested it with a pot, and my ceiling was about 1.02f for the mentioned multiplier, after that it became unstable. Difference though isn't that great

[01GOD]

Ah, alright. Thanks for notifying. Yesterday had worked on tuning that filter and envelopes for hours, and it seems that on this emulation the accentation and env mod may need to be adjusted together to produce a similar effect as the "accent" alone does on the analog synths (and some other emulations) of this kind.

Also wondering if maybe the env mod knob adjusts the dec of the envelope (to shorter) when its val is increased on those analog synths, because the best emulator I know of makes the filter have a short chirp kind of sound when env mod is at max.

Anyway, when used together in wider ranges on this emulation, the accent and env mod can make some interesting sounds.

[01GOD]

Thanks! I may have a look at that later today.

[01GOD]

Recommend easiest way to add a boost to the amp envelope on accented notes in GetAmpEnv()?

[01GOD]

Added the following before the "break;" in the INIT stage, so hopefully that will do it:

if (_accent) {
        _ampEnvVal = _ampEnvVal *= 1.2;
      }

[copych]

This won't help.
Instead you should change 0.3f to some bigger value here at line 247:

      _k_acc = (1.0f + 0.3f * _accentation);

note, that current value of 0.3 means _k_acc = 1.3 when accent is ON, and 1.0 when OFF (assuming acc knob is all way CW).

[01GOD]

Ah, thanks for clarifying that. I had multiplied _accentation by a 2.x multiplier somewhere before, so maybe it was there. I rebooted into other OS for some other tasks, so I can have a look at if it was that line later. Also boosted env mod by A LOT in the ParseCC call. That one is kinda a "flavor to taste" multiplier though.

Honestly annoying how sensitive some of the parameters of such synths are. I had gotten a TD-3-MO to try for a little while and learned there how nicely tuned the ranges were on that historical roland. Pretty easy to make the TD-3-MO sound not so great.

By the way, what is that mysterious "_k_acc" parameter anyway?

[copych]

_k_acc ... let's say it stands for Accent Coeffitient . k is often used in math and physics for linear coeffitients, and acc, well, is shortened accent

[01GOD]

Ah, OK. I think I had seen some k vars in some other filter emulation also. Thanks for explaining that.

[01GOD]

Here is a screenshot of a series of accented C3 notes in the best emulator I know of (CO, reso, and dec at max, env mod at min, accent at max, and tuning at center). Can the envelope model in acidbox can make that shape currently? It loos as though there is an SR curve instead of an AD curve. I don't think I have seen an A stage in any of that other emulator's output (neither filter or amp) actually.:

[01GOD]

A large reason people like such synths is likely because there is basically no (or almost no) A stage of the envelope. Thus it sounds very plucky or rubber ball style bouncy. Kinda similar to a kick drum transient.

[copych]

Please don't confuse the two envelopes. AcidBox' filter envelope is AD, while the amp envelope is full ADSR. With the default ADSR settings, and noteoffs at 1/32's weak counts (2nd, 4th, 6th, 8th etc.) the amp shape should look similar, I suppose.

[01GOD]

Ah, thankful there are 2 envelopes! Didn't notice that before. Glad there are!

By the way, admittedly didn't notice those pesky midi control sends in that do_midi_start() at first. LOL. That had seemingly been the reason the resonance hadn't sounded like it was enough.

[01GOD]

Is setting that CC dec at 30 in do_midi_start() an estimate of dec at max on a standard roland, or...?

[copych]

Nope, just a starting value. You'd better comment all these lines out...

[01GOD]

Ah. Seems the dec does need some tuning then. I think 30 sounds similar to max on a roland maybe. I can do a comparison with that other emulator later.

[01GOD]

Does a note with a slide on it, and either a 0 note or the same note on next step do the same thing as a td-3's whole note?

I guess by default all the notes in acidbox are whole notes. I added half notes, and it seems likely that using a slide that way should make a "whole note". Seems weird that roland would have included a whole note option if slide did that already though.

[01GOD]

Been more than 4 or 5 HOURS of work (and annoyingly slow compiling) to mod what is left of acidbanger to simply get it to noteOff normal notes at 32nd intervals, and not mess with sliding notes, but make accented notes stay on a full 16th step.

I guess I should overhaul it some more so it's a more logical sequencer without those HORRIBLY ANNOYING reverse order bitwise int16 bool "arrays". I'm like "is it little endian or big endian, and those are ACTUALLY big startian and little startian and so on...really not the kind of thing I want to be hassling with in calendar year 2024.

[copych]

Hahah.. That's why I've started my own sequencer one day, and it's working and it's more OOP approach than AcidBox, and it has more midi connection, and it even has 'swing' param. But I don't like it cause it's generative and live performance abilities are really weak, so I stay with Acidbanger yet.

[copych]

I think Aciduino is worth trying one more time

[01GOD]

Basically I want the slide on a step to make it slide into the next note, REGARDLESS OF IF THE SLIDE IS OFF OR NOTE IS OFF ON NEXT STEP. Right now it sadly doesn't.

At this point I've told it to slide properly on conditionals before EVERY noteoff() call in acidbanger.ino, but it sadly still hasn't done so. Thus, to get it to slide first 3 steps together, have to add a slide to 3rd step...

That's alright when there is a non-slide note between slide notes, but NOT alright when there are 2 slide notes in a row.

Anyway, at this point I don't know if that is in the original acidbanger.ino logic, or some issue that started after I modified it. So not asking why. However, if notice a reason that could be happening, thanks in advance for notifying.

I feel as though I have told a sequencer robot to not do something 50 times, and it's still doing it, so I feel like throwing that robot through a window now.

[01GOD]

Hahah.. That's why I've started my own sequencer one day, and it's working and it's more OOP approach than AcidBox, and it has more midi connection, and it even has 'swing' param. But I don't like it cause it's generative and live performance abilities are really weak, so I stay with Acidbanger yet.

Ah, alright.

I think Aciduino is worth trying one more time

Seems so. I think maybe that issue with it not sliding as expected is maybe in that instr_noteon_raw function near where this comment is:
"// All instruments are monophonic, so noteoff before noteon"

I may look at why more closely tonight.

[01GOD]

Wow, the call list to play a note, starting at acidbox.ino, is about 9 or 10 functions deep. I guess there was a lot of "separation of concerns" going on in that code.

[01GOD]

While working on making the slide function as it seemingly should (where slide on a step causes slide through next step), I decided to modify the original noteOff function directly to bypass whatever other logic could have been an issue.

How does this look?:

static void instr_noteoff(byte instr) {
  Instrument *ins = &instruments[instr];

  if ((ins->playing_note != 0) && ((OMNI_memories[0].patterns[0].glide >> (midi_step)) & 1) != 1 && ((OMNI_memories[0].patterns[0].glide >> (past_midi_step)) & 1) != 1){
    if (ins->noteoff != NULL)
      ins->noteoff(ins->midi_channel, ins->playing_note);
    ins->playing_note = 0;
  }
}

[01GOD]

Sadly that didn't function as I had hoped. Basically the notes don't turn off. I had put the following code in sequencer_step() to update a byte type var called past_midi_step, so theoretically it SHOULD FUNCTION. Don't know why it hasn't yet:
if (midi_step==0){ past_midi_step=15; }else{ past_midi_step=midi_step-1; }

[copych]

I tried to implement the logics described here https://www.antonsavov.net/articles/303andmidi/ . AcidBanger at first was chosen just because it already could produce a lot of different events to test the sound and to debug AcidBox. I suspect that you'll have to either double the pattern to 32 steps, or at least to double the midi ticking, cause AFAIR I've minimized it to the 1 tick per 1/16 note... (but maybe not)

[01GOD]

Ah, I changed that to 2 and added a conditional to do a noteOff when it's 1. Seems maybe there is some sort of issue in C when using bitwise operators in conditionals that has been causing the problems.

[copych]

BTW, it seems that I've managed to fit all the stuff onto a single core, so it opens a field for experiments.

[01GOD]

Oh, nice! Thanks for notifying!

Sadly this BIZARRELY doesn't ever seem to call ins->noteoff:

But it does when I manually set both of those vars to 1. Totally bizarre. Sigh...been working on solving that for at least 8 hours already. BOTH of those are definitely 1 at certain points in the patterns, but as soon as any of the patterns hits a slide, no notes turn off after that. So bizarre.

[01GOD]

Tried it with only one of those bools (!glidePastStep) and it functions...for a while...then it stops turning off notes...HOW???
So completely bizarre!

[01GOD]

Seems to happen when 2 notes are slid together sequentially, because it doesn't happen when one note is slid. Hmmmm...I certainly wonder why...