From 4b524b179b09e56ca34841e35ccb507aba6fd7f6 Mon Sep 17 00:00:00 2001
From: image-et-son <florian.merz@gmail.com>
Date: Sun, 27 Feb 2022 15:19:49 +0100
Subject: [PATCH] Performance improvements (for #67) and minor fixes (#111 and
 #112)

---
 common/potmux.c  | 151 +++++++++++++++++++----------
 common/potmux.h  |   2 +-
 common/storage.c |  21 ++--
 common/synth.c   | 244 ++++++++++++++++++++++++++---------------------
 4 files changed, 248 insertions(+), 170 deletions(-)

diff --git a/common/potmux.c b/common/potmux.c
index 8323226..547ae3a 100644
--- a/common/potmux.c
+++ b/common/potmux.c
@@ -10,24 +10,78 @@
 
 static const int8_t potBitDepth[POTMUX_POT_COUNT]=
 {
-	/*Mixer*/8, /*Cutoff*/12,/*Resonance*/8,/*FilEnvAmt*/10,/*FilRel*/8,/*FilSus*/10,
-	/*FilDec*/8,/*FilAtt*/8,/*AmpRel*/8,/*AmpSus*/10,/*AmpDec*/8,/*AmpAtt*/8,
-	/*Glide*/8,/*BPW*/10,/*MVol*/8,/*MTune*/12,/*PitchWheel*/12,0,0,0,0,0,/*ModWheel*/8,
-	/*Speed*/12,/*APW*/10,/*PModFilEnv*/10,/*LFOFreq*/10,/*PModOscB*/10,/*LFOAmt*/12,/*FreqB*/12,/*FreqA*/12,/*FreqBFine*/12
-};
+    /*Mixer*/8,
+    /*Cutoff*/12,
+    /*Resonance*/8,
+    /*FilEnvAmt*/10,
+    /*FilRel*/8,
+    /*FilSus*/10,
+    /*FilDec*/8,
+    /*FilAtt*/8,
+    /*AmpRel*/8,
+    /*AmpSus*/10,
+    /*AmpDec*/8,
+    /*AmpAtt*/8,
+    /*Glide*/8,
+    /*BPW*/10,
+    /*MVol*/8,
+    /*MTune*/12,
+    /*PitchWheel*/12,
+    0,
+    0,
+    0,
+    0,
+    0,
+    /*ModWheel*/8,
+    /*Speed*/12,
+    /*APW*/10,
+    /*PModFilEnv*/10,
+    /*LFOFreq*/10,
+    /*PModOscB*/10,
+    /*LFOAmt*/12,
+    /*FreqB*/12,
+    /*FreqA*/12,
+    /*FreqBFine*/12,
 
-static const p600Pot_t priorityPots[6]=
-{
-    ppPitchWheel, ppMVol, ppFreqA, ppFreqB,
-    ppModWheel,
-    ppNone
 };
 
-static const p600Pot_t regularPots[23]=
+static const int8_t response[POTMUX_POT_COUNT]=
 {
-    ppMixer, ppResonance, ppFilEnvAmt, ppGlide, ppBPW, ppAPW, ppPModFilEnv, ppLFOFreq, ppPModOscB, ppLFOAmt, ppSpeed,  ppAmpRel, ppAmpSus, ppAmpDec, ppAmpAtt, ppFilAtt, ppFilDec, ppFilSus, ppFilRel, ppMTune, ppFreqBFine, ppCutoff, ppNone
+    /*Vol A*/6,
+    /*Cutoff*/4,
+    /*Resonance*/3,
+    /*Fil Env Amt*/6,
+    /*Filter Release */35,
+    /*Filter Sustain*/6,
+    /*Filter Decay*/35,
+    /*Filter Attack*/35,
+    /*Amp Release*/35,
+    /*Amp Sustain*/6,
+    /*Amp Decay*/35,
+    /*Amp Attack*/35,
+    /*Vol B*/6,
+    /*BPW*/7,
+    /*Master Vol*/6,
+    /*Master Tune*/11,
+    /*Pitch Bender*/3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    /*Mod Wheel*/3,
+    /*Data Dial*/8,
+    /*APW*/7,
+    /*Poly-Mod Env*/8,
+    /*Poly-Mod OSC B*/3,
+    /*LFO Frequency*/20,
+    /*LFO Amount*/6,
+    /*Frequeny B*/3,
+    /*Frequeny A*/3,
+    /*Frequency B Fine*/20,
 };
 
+
 static struct
 {
 	uint32_t potChanged;
@@ -35,7 +89,7 @@ static struct
 
 	uint16_t pots[POTMUX_POT_COUNT];
 	uint8_t potExcited[POTMUX_POT_COUNT];
-	uint8_t potExcitedCount[POTMUX_POT_COUNT];
+	uint8_t potcounter[POTMUX_POT_COUNT];
 	int8_t currentRegularPot;
 	int8_t lastChanged;
 	int8_t lastInAction;
@@ -50,7 +104,7 @@ static void updatePot(int8_t pot)
 	uint16_t bit;
 
     if (pot<0) return;
-	
+
 	BLOCK_INT
 	{
 		// successive approximations using DAC and comparator
@@ -74,7 +128,7 @@ static void updatePot(int8_t pot)
 
 		for(i=0;i<=bitDepth;++i)
 		{
-			dac_write(estimate);				
+			dac_write(estimate);
 
 			// let comparator get correct voltage (don't remove me!)
 			CYCLE_WAIT(2);
@@ -96,26 +150,31 @@ static void updatePot(int8_t pot)
 
 		io_write(0x0a,0xff);
 		CYCLE_WAIT(4);
-		
+
         // suppress the bits beyond the measurement accuracy
 		estimate&=badMask;
 
         // change detector
 		cdv=estimate>>8;
         diff = abs(potmux.changeDetect[pot]-cdv);
-		if (potmux.lastInAction!=pot && potmux.potExcitedCount[pot]>0) potmux.potExcitedCount[pot]--;
-		potmux.potExcited[pot]=potmux.potExcitedCount[pot]>0?1:0;
-		if(diff>CHANGE_DETECT_THRESHOLD || potmux.potExcitedCount[pot]>0)
+		if (potmux.lastInAction!=pot) potmux.potExcited[pot]=0;
+		if(diff>CHANGE_DETECT_THRESHOLD || (potmux.potExcited[pot] && pot!=ppPitchWheel))
 		{
 			potmux.changeDetect[pot]=cdv;
 			potmux.potChanged|=(uint32_t)1<<pot;
-            if(diff>CHANGE_DETECT_THRESHOLD) potmux.potExcitedCount[pot]=10; // keep up excited state for some cycles only if change not too small
-            potmux.lastChanged=pot; // this is reset in every cycle
+            potmux.potExcited[pot]=1;
+            potmux.lastChanged=pot; // this is reset in every cycle, this is used to decide which value to show on the display
             potmux.lastInAction=pot; // this stays and is only reset for a change of mode
 		}
 
-        if (estimate>=0xFC00) estimate=badMask; // choose max value above the threshold UINT16_t - CHANGE_DETECT_THRESHOLD
-        potmux.pots[pot]=estimate;
+        if (estimate>=0xFC00)
+        {
+            potmux.pots[pot]=badMask; // choose max value above the threshold UINT16_t - CHANGE_DETECT_THRESHOLD
+        }
+        else
+        {
+            potmux.pots[pot]=estimate;
+        }
     }
 }
 
@@ -148,7 +207,6 @@ void potmux_resetChangedFull(void)
     for (i=0;i<POTMUX_POT_COUNT;i++)
     {
         potmux.potExcited[i]=0;
-        potmux.potExcitedCount[i]=0;
     }
 }
 
@@ -159,7 +217,6 @@ FORCEINLINE void potmux_resetSpeedPot(void)
 	potmux.potChanged&=(~(mask<<ppSpeed)); // remove the bit of the speed pot
 	if (potmux.lastChanged==ppSpeed) potmux.lastChanged=ppNone;
     potmux.potExcited[ppSpeed]=0;
-    potmux.potExcitedCount[ppSpeed]=0;
 
 }
 
@@ -168,39 +225,31 @@ int8_t potmux_isPotZeroCentered(p600Pot_t pot, uint8_t layout)
 	return pot==ppFilEnvAmt || pot==ppPModFilEnv || pot==ppFreqBFine || pot==ppMTune || pot==ppPitchWheel || (pot==ppMixer && layout==1);
 }
 
-inline void potmux_update(uint8_t updateAll, uint8_t potsPerCycle)
+inline void potmux_update(uint8_t updateAll)
 {
-	int16_t i, updatable;
-    updatable=updateAll?22:potsPerCycle;
-	for(i=0;i<updatable;++i)
-	{
-		if (!potmux.potExcited[regularPots[potmux.currentRegularPot]] || updateAll)
-            updatePot(regularPots[potmux.currentRegularPot]); // done in the next loop
-		potmux.currentRegularPot++;
-        if (regularPots[potmux.currentRegularPot]==ppNone) potmux.currentRegularPot=0;
-	}
-
-    p600Pot_t pp=regularPots[0];
-    i=0;
-    while (pp!=ppNone) // this cycle once through the pots in prio 2
-    {
-        if (potmux.potExcited[pp]) updatePot(pp);
-        i++;
-        pp=regularPots[i];
-    }
+	int16_t i;
 
-    i=0;
-    pp=priorityPots[0];
-    while (pp!=ppNone) // this cycle once through the pots in prio 1
+    for(i=0;i<POTMUX_POT_COUNT;++i)
     {
-        updatePot(pp);
-        i++;
-        pp=priorityPots[i];
+        if (response[i]!=0)
+        {
+            if (potmux.potcounter[i]==0 || potmux.potExcited[i] || updateAll)
+            {
+                updatePot(i);
+            }
+        }
+        potmux.potcounter[i]=(potmux.potcounter[i]+1)%(2*response[i]);
     }
 }
 
 void potmux_init(void)
 {
 	memset(&potmux,0,sizeof(potmux));
-	potmux.lastChanged=ppNone;
+    potmux_resetChangedFull();
+    uint8_t i;
+
+    for (i=0;i<POTMUX_POT_COUNT;++i)
+    {
+        potmux.potcounter[i]=i; // distribute the pots as evenly as possible
+    }
 }
diff --git a/common/potmux.h b/common/potmux.h
index 9781eab..5bbfa16 100644
--- a/common/potmux.h
+++ b/common/potmux.h
@@ -15,7 +15,7 @@ void potmux_resetSpeedPot(void);
 
 void potmux_init(void);
 
-void potmux_update(uint8_t updateAll, uint8_t potsPerCycle);
+void potmux_update(uint8_t updateAll);
 uint8_t comparePotVal(p600Pot_t pot, uint16_t potValue, uint16_t compareValue);
 
 int8_t potmux_isPotZeroCentered(p600Pot_t pot, uint8_t layout);
diff --git a/common/storage.c b/common/storage.c
index 4c0f8bd..2537b55 100644
--- a/common/storage.c
+++ b/common/storage.c
@@ -140,7 +140,6 @@ static void resetPickUps(void)
 {
     uint8_t cnt;
     for (cnt=0;cnt<cpCount;++cnt) currentPreset.contParamPotStatus[cnt]=0;
-    currentPreset.switchStatus=0;
 }
 
 static LOWERCODESIZE int8_t storageLoad(uint16_t pageIdx, uint8_t pageCount)
@@ -215,10 +214,10 @@ LOWERCODESIZE int8_t settings_load(void)
 		settings.midiReceiveChannel=-1; // default is 'OMNI'
 		settings.voiceMask=0x3f; // default is: all on
 		settings.midiSendChannel=0; // deault is: 1
-		settings.syncMode=smInternal; // default ist internal clock
+		settings.syncMode=smInternal; // default is internal clock
 		settings.vcfLimit=0; // default is: no limit on the VCF
 		settings.midiMode=0; // normal mode
-		settings.panelLayout=0; // normal mode
+		settings.panelLayout=0; // GliGli layout
 
 		if (storage.version<1)
 			return 1;
@@ -353,6 +352,7 @@ LOWERCODESIZE int8_t preset_loadCurrent(uint16_t number, uint8_t loadFromBuffer)
 {
 	uint8_t i;
 	int8_t readVar;
+	int16_t readVarLong;
 	
 	BLOCK_INT
 	{
@@ -367,9 +367,6 @@ LOWERCODESIZE int8_t preset_loadCurrent(uint16_t number, uint8_t loadFromBuffer)
         }
         else
         {
-
-            resetPickUps();
-
             // check the storage MAGIC
             storage.bufPtr=storage.buffer;
 
@@ -379,6 +376,7 @@ LOWERCODESIZE int8_t preset_loadCurrent(uint16_t number, uint8_t loadFromBuffer)
                 return 0;
             }
             storage.version=storageRead8();
+            resetPickUps();
         }
 
         // compatibility with previous versions require the ""Pulse Width Sync Bug""
@@ -482,7 +480,10 @@ LOWERCODESIZE int8_t preset_loadCurrent(uint16_t number, uint8_t loadFromBuffer)
 		// v7
 		
         for (i=0; i<TUNER_NOTE_COUNT; i++)
-			currentPreset.perNoteTuning[i]=storageRead16();
+        {
+            readVarLong=storageRead16();
+            if (number!=MANUAL_PRESET_PAGE || loadFromBuffer) currentPreset.perNoteTuning[i]=readVarLong; // always reset equal tempered tuning for manual mode: keep defaults
+        }
 			
 		if (storage.version<8)
         {
@@ -671,9 +672,8 @@ LOWERCODESIZE void preset_loadDefault(int8_t makeSound)
 		currentPreset.continuousParameters[cpAmpSus]=UINT16_MAX;
 		currentPreset.continuousParameters[cpAmpVelocity]=HALF_RANGE;
 		currentPreset.continuousParameters[cpVibFreq]=HALF_RANGE;
+		if (settings.panelLayout==1) currentPreset.continuousParameters[cpDrive]=HALF_RANGE;
         if (settings.panelLayout==0) currentPreset.continuousParameters[cpMixVolA]=UINT16_MAX;
-		//currentPreset.continuousParameters[cpDrive]=HALF_RANGE; // this is internal parameter for SCI panel layout
-		//currentPreset.continuousParameters[cpVolA]=UINT16_MAX;
 
 		currentPreset.steppedParameters[spBenderSemitones]=5;
 		currentPreset.steppedParameters[spBenderTarget]=modAB;
@@ -703,9 +703,10 @@ LOWERCODESIZE void settings_loadDefault(void)
 		memset(&settings,0,sizeof(settings));
 		
 		settings.benderMiddle=HALF_RANGE;
-		settings.midiReceiveChannel=-1;
+		settings.midiReceiveChannel=-1; // OMNI
 		settings.voiceMask=0x3f;
 		settings.seqArpClock=HALF_RANGE;
+        settings.panelLayout=0; // GliGli layout
 		
 		tuner_init(); // use theoretical tuning
 	}
diff --git a/common/synth.c b/common/synth.c
index e8c6e13..fd156b4 100644
--- a/common/synth.c
+++ b/common/synth.c
@@ -102,7 +102,9 @@ struct synth_s
     int16_t benderCVs[pcFil6-pcOsc1A+1];
     int16_t benderVolumeCV;
 
-    uint16_t lfoAmt, vibAmt;
+    uint16_t dlyAmt;
+
+    uint16_t lfoAmt, vibAmt, vibAmp, vibPitch;
 
     int16_t glideAmount;
     int8_t gliding;
@@ -118,7 +120,7 @@ struct synth_s
 
     uint8_t freqDial;
 
-    //uint32_t updateCounter; for performance measurement
+    // uint32_t updateCounter; // for performance measurement
 
 } synth;
 
@@ -139,15 +141,6 @@ struct deadband bendDeadband = { HALF_RANGE, BEND_GUARDBAND,  BEND_DEADBAND };
 struct deadband panelDeadband = { HALF_RANGE, 0, PANEL_DEADBAND };
 struct deadband freqFineDeadband = { HALF_RANGE-1000, 0, 8192, 1024}; // ultra "slow band" in the middle of fine tune
 
-static uint16_t rescaledPW(uint16_t pwPotValue)
-{
-    //uint16_t outVal;
-    //outVal=(pwPotValue>1400)?(pwPotValue-1400):0;
-    //outVal-=(outVal>>5); // extend the range by 2^11
-    //return outVal;
-    return pwPotValue;
-}
-
 static void addWheelToTunedCVs(void) // this function is specific for the case in which there are only wheel changes. Could also be moved to inside wheel event...
 {
     uint16_t cva,cvb,cvf;
@@ -408,15 +401,7 @@ static void computeTunedCVs(int8_t force, int8_t forceVoice)
 // division operation.
 // so instead of doing foo*=32768; foo/=factor; we precalculate
 // precalc=32768<<16/factor, and do foo*=precalc; foo>>=16; runtime.
-/*static void precalcDeadband(struct deadband *d)
-{
-    uint16_t middleLow=d->middle-d->deadband;
-    uint16_t middleHigh=d->middle+d->deadband;
-
-    d->precalcLow=HALF_RANGE_L/(middleLow-d->guard);
-    d->precalcHigh=HALF_RANGE_L/(FULL_RANGE-d->guard-middleHigh);
-}*/
-
+// when "rise" >0 then this is not a strict Deadband but rather als Slowband
 static void precalcDeadband(struct deadband *d)
 {
     uint16_t middleLow=d->middle-d->deadband;
@@ -567,19 +552,27 @@ static void refreshModulationDelay(int8_t refreshTickCount)
 
 static void handleFinishedVoices(void)
 {
-    int8_t v;
+    int8_t v, waitFlag;
+
 
     for(v=0; v<SYNTH_VOICE_COUNT; ++v)
     {
-        // when amp env finishes, voice is done
-        if(assigner_getAssignment(v,NULL) && adsr_getStage(&synth.ampEnvs[v])==sWait)
-            assigner_voiceDone(v);
+        waitFlag=synth.ampEnvs[v].stage==sWait;
 
-        // if voice isn't assigned, silence it
-        if(!assigner_getAssignment(v,NULL) && adsr_getStage(&synth.ampEnvs[v])!=sWait)
+        if (assigner_getAssignment(v,NULL))
         {
-            adsr_reset(&synth.ampEnvs[v]);
-            adsr_reset(&synth.filEnvs[v]);
+            // when amp env finishes, voice is done
+            if (waitFlag)
+                assigner_voiceDone(v);
+        }
+        else
+        {
+            // if voice isn't assigned, silence it (but only if not finished
+            if (!waitFlag)
+            {
+                adsr_reset(&synth.ampEnvs[v]);
+                adsr_reset(&synth.filEnvs[v]);
+            }
         }
     }
 }
@@ -615,10 +608,10 @@ static inline void refreshPulseWidth(int8_t pwm)
     uint8_t sqrB=currentPreset.steppedParameters[spBSqr];
 
     if(sqrA)
-        pa=rescaledPW(currentPreset.continuousParameters[cpAPW]);
+        pa=currentPreset.continuousParameters[cpAPW];
 
     if(sqrB)
-        pb=rescaledPW(currentPreset.continuousParameters[cpBPW]);
+        pb=currentPreset.continuousParameters[cpBPW];
 
     if(pwm)
     {
@@ -694,34 +687,37 @@ static void refreshEnvSettings(void)
     }
 }
 
-static void refreshLfoSettings(void)
+static void refreshDlyAmount(void)
 {
-    lfoShape_t shape;
-    uint16_t dlyAmt;
     uint32_t elapsed;
 
-    shape=currentPreset.steppedParameters[spLFOShape];
-
-    lfo_setShape(&synth.lfo,shape);
-
     // wait modulationDelayTickCount then progressively increase over
     // modulationDelayTickCount time, following an exponential curve
-    dlyAmt=0;
+    synth.dlyAmt=0;
     if(synth.modulationDelayStart!=UINT32_MAX)
     {
         if(currentPreset.continuousParameters[cpModDelay]<POT_DEAD_ZONE)
         {
-            dlyAmt=UINT16_MAX;
+            synth.dlyAmt=UINT16_MAX;
         }
         else if(currentTick>=synth.modulationDelayStart+synth.modulationDelayTickCount)
         {
             elapsed=currentTick-(synth.modulationDelayStart+synth.modulationDelayTickCount);
             if(elapsed>=synth.modulationDelayTickCount)
-                dlyAmt=UINT16_MAX;
+                synth.dlyAmt=UINT16_MAX;
             else
-                dlyAmt=attackCurveLookup[(elapsed<<8)/synth.modulationDelayTickCount];
+                synth.dlyAmt=attackCurveLookup[(elapsed<<8)/synth.modulationDelayTickCount];
         }
     }
+}
+
+static void refreshLfoSettings(void)
+{
+    lfoShape_t shape;
+
+    shape=currentPreset.steppedParameters[spLFOShape];
+
+    lfo_setShape(&synth.lfo,shape);
 
     synth.lfoAmt=currentPreset.continuousParameters[cpLFOAmt];
     synth.lfoAmt=(synth.lfoAmt<POT_DEAD_ZONE)?0:(synth.lfoAmt-POT_DEAD_ZONE);
@@ -732,11 +728,11 @@ static void refreshLfoSettings(void)
     if(currentPreset.steppedParameters[spModwheelTarget]==0) // targeting lfo?
     {
         lfo_setAmt(&synth.lfo, satAddU16U16(synth.lfoAmt, synth.modwheelAmount));
-        lfo_setAmt(&synth.vibrato, scaleU16U16(synth.vibAmt,dlyAmt));
+        lfo_setAmt(&synth.vibrato, scaleU16U16(synth.vibAmt,synth.dlyAmt));
     }
     else // targeting vibrato
     {
-        lfo_setAmt(&synth.lfo, scaleU16U16(synth.lfoAmt, dlyAmt));
+        lfo_setAmt(&synth.lfo, scaleU16U16(synth.lfoAmt, synth.dlyAmt));
         lfo_setAmt(&synth.vibrato, satAddU16U16(synth.vibAmt, synth.modwheelAmount));
     }
 }
@@ -1023,10 +1019,13 @@ void refreshPresetMode(void)
 {
 
     if(!preset_loadCurrent(settings.presetMode?settings.presetNumber:MANUAL_PRESET_PAGE,0))
+    {
         preset_loadDefault(1);
+    }
 
     if(!settings.presetMode)
     {
+        // apply all current panel control setting, buttons, switches and pots
         refreshAllPresetButtons();
         refreshPresetPots(1);
     }
@@ -1186,25 +1185,25 @@ void synth_init(void)
     if(io_read(0x9)&16)
         tuner_scalingAdjustment();
 
-    // manual preset
-
-    /*if(!preset_loadCurrent(MANUAL_PRESET_PAGE,0))
-    {
-        preset_loadDefault(0);
-        preset_saveCurrent(MANUAL_PRESET_PAGE);
-    }*/
-
     // load settings from storage; tune when they are bad
 
     if(!settings_load())
     {
-        settings_loadDefault();
+        settings_loadDefault(); // first startup: panel mode, GilGi panel layout, basic init tuning, MIDI OMNI receive, bend middle position
 
 #ifndef DEBUG
         tuner_tuneSynth();
 #endif
     }
 
+    // initialize manual preset page if needed
+
+    if(!preset_loadCurrent(MANUAL_PRESET_PAGE,0))
+    {
+        preset_loadDefault(1);
+        preset_saveCurrent(MANUAL_PRESET_PAGE);
+    }
+
     sh_setCV(pcMVol,HALF_RANGE,SH_FLAG_IMMEDIATE);
 
     // dead band pre calculation
@@ -1216,7 +1215,7 @@ void synth_init(void)
     // initial input state
 
     scanner_update(1);
-    potmux_update(1,0); // init all
+    potmux_update(1); // init all
 
     // load last preset & do a full refresh
     refreshPresetMode();
@@ -1250,13 +1249,12 @@ void synth_update(void)
     // update pots, detecting change
 
     potmux_resetChanged();
-    potmux_update(0,3);
+    potmux_update(0);
 
     // act on pot change
 
     ui_checkIfDataPotChanged(); // this sets ui.lastActivePot and handles the menu parameters
-
-    refreshPresetPots(!settings.presetMode); // this updates currentPreset.cp[] if "forced" (function parameter), lastActivePot or changed
+    refreshPresetPots(0); // this updates currentPreset.cp[] if "forced" (function parameter), lastActivePot or changed
 
     if(ui.lastActivePot!=ppNone)
     {
@@ -1269,7 +1267,6 @@ void synth_update(void)
             if(potmux_isPotZeroCentered(ui.lastActivePot, settings.panelLayout) && ui.lastActivePot!=ppFreqBFine)
                 ui.adjustedLastActivePotValue=addDeadband(potVal,&panelDeadband);
 
-            //if (frc&0x01) refreshSevenSeg();
             refreshSevenSeg();
 
             // update CVs
@@ -1286,8 +1283,37 @@ void synth_update(void)
                      ui.lastActivePot==ppFilAtt || ui.lastActivePot==ppFilDec ||
                      ui.lastActivePot==ppFilSus || ui.lastActivePot==ppFilRel)
                 refreshEnvSettings();
-            else if (ui.lastActivePot==ppMVol)
-                synth.masterVolume = potmux_getValue(ppMVol);
+        }
+    }
+
+    // immediate resonse the value changes
+
+    if (potmux_hasChanged(ppMVol))
+    {
+        synth.masterVolume = potmux_getValue(ppMVol);
+        sh_setCV(pcMVol,satAddU16S16(synth.masterVolume,synth.benderVolumeCV),SH_FLAG_IMMEDIATE);
+    }
+
+    if (potmux_hasChanged(ppPModOscB))
+        sh_setCV(pcPModOscB,currentPreset.continuousParameters[cpPModOscB],SH_FLAG_IMMEDIATE);
+
+    if (potmux_hasChanged(ppMixer))
+    {
+        sh_setCV(pcVolA,currentPreset.continuousParameters[cpVolA],SH_FLAG_IMMEDIATE);
+        if (settings.panelLayout==1)
+            sh_setCV(pcVolB,currentPreset.continuousParameters[cpVolB],SH_FLAG_IMMEDIATE);
+    }
+
+    if (potmux_hasChanged(ppGlide))
+    {
+        if (settings.panelLayout==0)
+        {
+            sh_setCV(pcVolB,currentPreset.continuousParameters[cpVolB],SH_FLAG_IMMEDIATE);
+        }
+        else
+        {
+            synth.glideAmount=exponentialCourse(currentPreset.continuousParameters[cpGlide],11000.0f,2100.0f);
+            synth.gliding=synth.glideAmount<2000;
         }
     }
 
@@ -1305,37 +1331,43 @@ void synth_update(void)
         ui.vibFreqChangePending=0;
     }
 
+    // lfo: for amount and frequency changes the change should be immediate
+    if (potmux_hasChanged(ppLFOAmt) || potmux_hasChanged(ppLFOFreq))
+        refreshLfoSettings();
 
-    refreshLfoSettings();
+    // regular updates to keep correct voltages
 
-    switch(frc&0x03) // 4 phases
+    switch((frc)&0x07) // 8 phases
     {
         case 0:
-            //sh_setCV_FastPath(pcResonance,currentPreset.continuousParameters[cpResonance]);
-            sh_setCV(pcResonance,currentPreset.continuousParameters[cpResonance],SH_FLAG_IMMEDIATE);
-            // arp and seq
-            clock_setSpeed(settings.seqArpClock);
+            sh_setCV(pcPModOscB,currentPreset.continuousParameters[cpPModOscB],SH_FLAG_IMMEDIATE);
             break;
         case 1:
-            // 'fixed' CVs
-            //sh_setCV_FastPath(pcPModOscB,currentPreset.continuousParameters[cpPModOscB]);
-            sh_setCV(pcPModOscB,currentPreset.continuousParameters[cpPModOscB],SH_FLAG_IMMEDIATE);
+            sh_setCV(pcResonance,currentPreset.continuousParameters[cpResonance],SH_FLAG_IMMEDIATE);
             break;
         case 2:
-            // 'fixed' CVs
-            //sh_setCV_FastPath(pcMVol,satAddU16S16(synth.masterVolume,synth.benderVolumeCV));
             sh_setCV(pcMVol,satAddU16S16(synth.masterVolume,synth.benderVolumeCV),SH_FLAG_IMMEDIATE);
             break;
         case 3:
-            // gates
-            //sh_setCV_FastPath(pcExtFil,currentPreset.continuousParameters[cpExternal]);
             sh_setCV(pcExtFil,currentPreset.continuousParameters[cpExternal],SH_FLAG_IMMEDIATE);
-
+            break;
+        case 4:
+            sh_setCV(pcVolA,currentPreset.continuousParameters[cpVolA],SH_FLAG_IMMEDIATE);
+            break;
+        case 5:
+            sh_setCV(pcVolB,currentPreset.continuousParameters[cpVolB],SH_FLAG_IMMEDIATE);
+            break;
+        case 6:
+            refreshLfoSettings();
+            // modulation delay
+            refreshDlyAmount();
+            break;
+        case 7:
             refreshGates();
-
-            // glide
             synth.glideAmount=exponentialCourse(currentPreset.continuousParameters[cpGlide],11000.0f,2100.0f);
             synth.gliding=synth.glideAmount<2000;
+            // arp and seq
+            clock_setSpeed(settings.seqArpClock);
             break;
     }
 
@@ -1364,30 +1396,23 @@ void synth_uartInterrupt(void)
 // 2Khz
 void synth_timerInterrupt(void)
 {
-    int32_t va,vf;
+    uint32_t va, vf;
     int16_t pitchALfoVal,pitchBLfoVal,filterLfoVal,filEnvAmt,oscEnvAmt;
     uint16_t ampLfoVal;
     int8_t v,hz63,hz250;
 
     static uint8_t frc=0;
-	//static uint16_t frc2=0; // for performance measurement
+
+    // performance
+	// static uint16_t frc2=0; // for performance measurement
 
     // lfo
 
     lfo_update(&synth.lfo);
 
-    pitchALfoVal=pitchBLfoVal=0;
+    pitchALfoVal=pitchBLfoVal=synth.vibPitch;
+    ampLfoVal=synth.vibAmp;
     filterLfoVal=0;
-    ampLfoVal=UINT16_MAX;
-
-    if (currentPreset.steppedParameters[spVibTarget]==0) // VCO
-    {
-        pitchALfoVal=pitchBLfoVal=synth.vibrato.output>>2;
-    }
-    else // VCA
-    {
-        ampLfoVal=synth.vibrato.output+(UINT16_MAX-(synth.vibrato.levelCV>>1));
-    }
 
     if(currentPreset.steppedParameters[spLFOTargets]&mtVCO)
     {
@@ -1400,13 +1425,16 @@ void synth_timerInterrupt(void)
     if(currentPreset.steppedParameters[spLFOTargets]&mtVCF)
         filterLfoVal=synth.lfo.output;
 
+    if(currentPreset.steppedParameters[spLFOTargets]&mtVCA)
+    {
+        ampLfoVal=scaleU16U16(ampLfoVal, synth.lfo.output+(UINT16_MAX-(synth.lfo.levelCV>>1)));
+    }
+
 
     // global env computations
-
     vf=currentPreset.continuousParameters[cpFilEnvAmt];
     vf+=INT16_MIN;
     filEnvAmt=vf;
-
     oscEnvAmt=0;
     if(currentPreset.steppedParameters[spPModFA])
     {
@@ -1435,7 +1463,6 @@ void synth_timerInterrupt(void)
     hz63=(frc&0x1c)==0;
     hz250=(frc&0x04)==0;
 
-
     switch(frc&0x03) // 4 phases, each 500hz
     {
     case 0:
@@ -1447,6 +1474,7 @@ void synth_timerInterrupt(void)
 
         // ticker inc
         ++currentTick;
+
         break;
     case 1:
 
@@ -1463,12 +1491,15 @@ void synth_timerInterrupt(void)
                 // sync of the LFO using the clockBar counter
 
                 synth.clockBar=(synth.clockBar+1)%0x9; // make sure the counter stays within the counter range, here 0...9
-                if((seq_getMode(0)!=smOff || seq_getMode(1)!=smOff || arp_getMode()!=amOff) && currentPreset.steppedParameters[spLFOSync]!=0)
+                if (currentPreset.steppedParameters[spLFOSync]!=0)
                 {
-                    if ((synth.clockBar==8 && currentPreset.steppedParameters[spLFOSync]==7) || synth.clockBar==currentPreset.steppedParameters[spLFOSync])
+                    if(seq_getMode(0)!=smOff || seq_getMode(1)!=smOff || arp_getMode()!=amOff)
                     {
-                        synth.clockBar=0;
-                        lfo_resetPhase(&synth.lfo);
+                        if ((synth.clockBar==8 && currentPreset.steppedParameters[spLFOSync]==7) || synth.clockBar==currentPreset.steppedParameters[spLFOSync])
+                        {
+                            synth.clockBar=0;
+                            lfo_resetPhase(&synth.lfo);
+                        }
                     }
                 }
 
@@ -1499,20 +1530,17 @@ void synth_timerInterrupt(void)
         break;
     case 2:
         lfo_update(&synth.vibrato);
-        refreshPulseWidth(currentPreset.steppedParameters[spLFOTargets]&mtPW);
-
-        if(currentPreset.steppedParameters[spLFOTargets]&mtVCA)
+        if (currentPreset.steppedParameters[spVibTarget]==0) // VCO
         {
-            // ampLfoVal=synth.lfo.output+(UINT16_MAX-(synth.lfo.levelCV>>1)); // original application. This is later scaled into pre-amp (pcAmp1)
-            sh_setCV(pcVolA,scaleU16U16(currentPreset.continuousParameters[cpVolA], synth.lfo.output+(UINT16_MAX-(synth.lfo.levelCV>>1))),SH_FLAG_IMMEDIATE);
-            sh_setCV(pcVolB,scaleU16U16(currentPreset.continuousParameters[cpVolB], synth.lfo.output+(UINT16_MAX-(synth.lfo.levelCV>>1))),SH_FLAG_IMMEDIATE);
+            synth.vibPitch=synth.vibrato.output>>2;
+            synth.vibAmp=UINT16_MAX;
         }
-        else
+        else // VCA
         {
-            sh_setCV(pcVolA,currentPreset.continuousParameters[cpVolA],SH_FLAG_IMMEDIATE);
-            sh_setCV(pcVolB,currentPreset.continuousParameters[cpVolB],SH_FLAG_IMMEDIATE);
+            synth.vibAmp=synth.vibrato.output+(UINT16_MAX-(synth.vibrato.levelCV>>1));
+            synth.vibPitch=0;
         }
-
+        refreshPulseWidth(currentPreset.steppedParameters[spLFOTargets]&mtPW);
         break;
     case 3:
         if(hz250)
@@ -1528,13 +1556,13 @@ void synth_timerInterrupt(void)
     ++frc;
 
     // for performance measurement
-    /*frc2=(frc2+1)%0x07d0; // 1 second
+    // frc2=(frc2+1)%0x07d0; // 1 second
     //frc2=(frc2+1)%0x03e8; // 1/2 second
     //frc2=(frc2+1)%0x07d; // 1/16 second
 
-    if(frc2==0)
+    /*if(frc2==0)
     {
-        midi_sendThreeBytes(15,synth.updateCounter);
+        midi_sendThreeBytes(0,(uint16_t)synth.updateCounter);
         synth.updateCounter=0;
     }*/
 }