wirtz
/
MicroDexed
mirror of https://codeberg.org/dcoredump/MicroDexed.git
1
1
Fork 0
Code Issues Releases Wiki Activity

Merge pull request 'Live Recording fixes: fixed note double triggering' (#74) from positionhigh/MicroDexed:dev into dev

Browse Source 
Reviewed-on: https://codeberg.org/dcoredump/MicroDexed/pulls/74
pull/76/head
Holger Wirtz 3 years ago
parent c631d60eea db599940d7
commit 07b4e28671
7 changed files with 2156 additions and 2157 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 383
      MicroDexed.ino
  2. 62
      UI.hpp
  3. 31
      UI_FX_T4.h
  4. 5
      dexed_sd.cpp
  5. 6
      midi_devices.hpp
  6. 49
      sequencer.cpp
  7. 25
      sequencer.h

383
MicroDexed.ino
Unescape View File

@ -367,7 +367,7 @@ BiquadCoef graphic_eq(7);
extern void getNoteName(char* noteName, uint8_t noteNumber);
PeriodicTimer timer1;
extern char seq_chord_names[6][4];
extern char seq_chord_names[7][4];
/***********************************************************************
SETUP
@ -641,13 +641,11 @@ void setup()
#endif
LCDML.OTHER_jumpToFunc(UI_func_voice_select);
timer1.begin(sequencer, 90000, false);
}
timer1.begin(sequencer, 74'000,false);
}
void loop()
{
void loop()
{
// MIDI input handling
check_midi_devices();
@ -663,7 +661,7 @@ void setup()
{
if (seq_step != seq_UI_last_step)
{
seq_UI_last_step=seq_step;
seq_UI_last_step = seq_step;
if (LCDML.FUNC_getID() == LCDML.OTHER_getIDFromFunction(UI_func_sequencer)) //is in UI of Sequencer
{
lcd.setCursor(seq_step, 1);
@ -683,10 +681,10 @@ void setup()
else if (LCDML.FUNC_getID() == LCDML.OTHER_getIDFromFunction(UI_func_arpeggio)) //is in UI of Arpeggiator
{
lcd.setCursor(7, 0);
lcd.print( seq_chord_names[arp_chord - 200][0]);
lcd.print( seq_chord_names[arp_chord - 200][1]);
lcd.print( seq_chord_names[arp_chord - 200][2]);
lcd.print( seq_chord_names[arp_chord - 200][3]);
lcd.print( seq_chord_names[arp_chord][0]);
lcd.print( seq_chord_names[arp_chord][1]);
lcd.print( seq_chord_names[arp_chord][2]);
lcd.print( seq_chord_names[arp_chord][3]);
}
}
}
@ -767,12 +765,15 @@ void setup()
show_cpu_and_mem_usage();
}
#endif
}
}
/******************************************************************************
/******************************************************************************
MIDI MESSAGE HANDLER
******************************************************************************/
void handleNoteOn(byte inChannel, byte inNumber, byte inVelocity)
******************************************************************************/
void handleNoteOn(byte inChannel, byte inNumber, byte inVelocity)
{
//Ignore the note when playing & recording the same note into the sequencer
if (seq_recording == false || (seq_recording && inNumber != seq_note_in ))
{
// Check for MicroDexed
for (uint8_t instance_id = 0; instance_id < NUM_DEXED; instance_id++)
@ -823,7 +824,6 @@ void setup()
Serial.print(F("]: "));
Serial.println(note_name);
#endif
for (uint8_t d = 0; d < NUM_DRUMSET_CONFIG; d++)
{
if (inNumber == drum_config[d].midinote)
@ -861,10 +861,11 @@ void setup()
}
#endif
}
}
#if NUM_DRUMS > 0
uint8_t drum_get_slot(uint8_t dt)
{
uint8_t drum_get_slot(uint8_t dt)
{
for (uint8_t i = 0; i < NUM_DRUMS; i++)
{
if (!Drum[i]->isPlaying())
@ -891,11 +892,11 @@ void setup()
drum_type[drum_counter % 4] = dt;
drum_counter++;
return (drum_counter - 1 % 4);
}
}
#endif
void handleNoteOff(byte inChannel, byte inNumber, byte inVelocity)
{
void handleNoteOff(byte inChannel, byte inNumber, byte inVelocity)
{
for (uint8_t instance_id = 0; instance_id < NUM_DEXED; instance_id++)
{
if (checkMidiChannel(inChannel, instance_id))
@ -920,10 +921,10 @@ void setup()
}
}
}
}
}
void handleControlChange(byte inChannel, byte inCtrl, byte inValue)
{
void handleControlChange(byte inChannel, byte inCtrl, byte inValue)
{
inCtrl = constrain(inCtrl, 0, 127);
inValue = constrain(inValue, 0, 127);
@ -1136,10 +1137,10 @@ void setup()
}
}
}
}
}
void handleAfterTouch(byte inChannel, byte inPressure)
{
void handleAfterTouch(byte inChannel, byte inPressure)
{
for (uint8_t instance_id = 0; instance_id < NUM_DEXED; instance_id++)
{
if (checkMidiChannel(inChannel, instance_id))
@ -1148,10 +1149,10 @@ void setup()
MicroDexed[instance_id]->ControllersRefresh();
}
}
}
}
void handlePitchBend(byte inChannel, int inPitch)
{
void handlePitchBend(byte inChannel, int inPitch)
{
for (uint8_t instance_id = 0; instance_id < NUM_DEXED; instance_id++)
{
if (checkMidiChannel(inChannel, instance_id))
@ -1159,10 +1160,10 @@ void setup()
MicroDexed[instance_id]->setPitchbend(inPitch);
}
}
}
}
void handleProgramChange(byte inChannel, byte inProgram)
{
void handleProgramChange(byte inChannel, byte inProgram)
{
for (uint8_t instance_id = 0; instance_id < NUM_DEXED; instance_id++)
{
if (checkMidiChannel(inChannel, instance_id))
@ -1182,10 +1183,10 @@ void setup()
}
}
}
}
}
void handleSystemExclusive(byte * sysex, uint len)
{
void handleSystemExclusive(byte * sysex, uint len)
{
for (uint8_t instance_id = 0; instance_id < NUM_DEXED; instance_id++)
{
if (!checkMidiChannel((sysex[2] & 0x0f) + 1 , instance_id))
@ -1584,30 +1585,30 @@ void setup()
Serial.println(F("E: SysEx parameter length wrong."));
#endif
}
}
}
void handleTimeCodeQuarterFrame(byte data)
{
void handleTimeCodeQuarterFrame(byte data)
{
;
}
}
void handleAfterTouchPoly(byte inChannel, byte inNumber, byte inVelocity)
{
void handleAfterTouchPoly(byte inChannel, byte inNumber, byte inVelocity)
{
;
}
}
void handleSongSelect(byte inSong)
{
void handleSongSelect(byte inSong)
{
;
}
}
void handleTuneRequest(void)
{
void handleTuneRequest(void)
{
;
}
}
void handleClock(void)
{
void handleClock(void)
{
if (midi_bpm_counter % 24 == 0)
{
midi_bpm = (60000.0f / float(midi_bpm_timer) + 0.5);
@ -1658,32 +1659,32 @@ void setup()
}
midi_bpm_counter++;
}
}
void handleStart(void)
{
void handleStart(void)
{
midi_bpm_timer = 0;
midi_bpm_counter = 0;
_midi_bpm = -1;
}
}
void handleContinue(void)
{
void handleContinue(void)
{
;
}
}
void handleStop(void)
{
void handleStop(void)
{
;
}
}
void handleActiveSensing(void)
{
void handleActiveSensing(void)
{
;
}
}
void handleSystemReset(void)
{
void handleSystemReset(void)
{
for (uint8_t instance_id = 0; instance_id < NUM_DEXED; instance_id++)
{
#ifdef DEBUG
@ -1693,13 +1694,13 @@ void setup()
MicroDexed[instance_id]->panic();
MicroDexed[instance_id]->resetControllers();
}
}
}
/******************************************************************************
/******************************************************************************
MIDI HELPER
******************************************************************************/
bool checkMidiChannel(byte inChannel, uint8_t instance_id)
{
******************************************************************************/
bool checkMidiChannel(byte inChannel, uint8_t instance_id)
{
// check for MIDI channel
if (configuration.dexed[instance_id].midi_channel == MIDI_CHANNEL_OMNI)
{
@ -1719,10 +1720,10 @@ void setup()
return (false);
}
return (true);
}
}
void init_MIDI_send_CC(void)
{
void init_MIDI_send_CC(void)
{
#ifdef DEBUG
Serial.println("init_MIDI_send_CC():");
#endif
@ -1736,14 +1737,14 @@ void setup()
MD_sendControlChange(configuration.dexed[selected_instance_id].midi_channel, 105, configuration.fx.delay_time[selected_instance_id]);
MD_sendControlChange(configuration.dexed[selected_instance_id].midi_channel, 106, configuration.fx.delay_feedback[selected_instance_id]);
MD_sendControlChange(configuration.dexed[selected_instance_id].midi_channel, 107, configuration.fx.delay_level[selected_instance_id]);
}
}
/******************************************************************************
/******************************************************************************
VOLUME HELPER
******************************************************************************/
******************************************************************************/
void set_volume(uint8_t v, uint8_t m)
{
void set_volume(uint8_t v, uint8_t m)
{
configuration.sys.vol = v;
if (configuration.sys.vol > 100)
@ -1784,14 +1785,14 @@ void setup()
mono2stereo[instance_id]->panorama(mapfloat(PANORAMA_MIN, PANORAMA_MIN, PANORAMA_MAX, -1.0, 1.0));
break;
}
}
}
/******************************************************************************
/******************************************************************************
EEPROM HELPER
******************************************************************************/
******************************************************************************/
void initial_values_from_eeprom(bool init)
{
void initial_values_from_eeprom(bool init)
{
uint16_t _m_;
if (init == true)
@ -1838,28 +1839,28 @@ void setup()
#ifdef DEBUG
show_configuration();
#endif
}
}
void check_configuration(void)
{
void check_configuration(void)
{
check_configuration_sys();
check_configuration_fx();
check_configuration_performance();
for (uint8_t instance_id = 0; instance_id < NUM_DEXED; instance_id++)
check_configuration_dexed(instance_id);
}
}
void check_configuration_sys(void)
{
void check_configuration_sys(void)
{
configuration.sys.instances = constrain(configuration.sys.instances, INSTANCES_MIN, INSTANCES_MAX);
configuration.sys.vol = constrain(configuration.sys.vol, VOLUME_MIN, VOLUME_MAX);
configuration.sys.mono = constrain(configuration.sys.mono, MONO_MIN, MONO_MAX);
configuration.sys.soft_midi_thru = constrain(configuration.sys.soft_midi_thru, SOFT_MIDI_THRU_MIN, SOFT_MIDI_THRU_MAX);
configuration.sys.performance_number = constrain(configuration.sys.performance_number, PERFORMANCE_NUM_MIN, PERFORMANCE_NUM_MAX);
}
}
void check_configuration_fx(void)
{
void check_configuration_fx(void)
{
#ifdef USE_PLATEREVERB
configuration.fx.reverb_lowpass = constrain(configuration.fx.reverb_lowpass, REVERB_LOWPASS_MIN, REVERB_LOWPASS_MAX);
configuration.fx.reverb_lodamp = constrain(configuration.fx.reverb_lodamp, REVERB_LODAMP_MIN, REVERB_LODAMP_MAX);
@ -1885,10 +1886,10 @@ void setup()
configuration.fx.delay_sync[instance_id] = constrain(configuration.fx.delay_sync[instance_id], DELAY_SYNC_MIN, DELAY_SYNC_MAX);
configuration.fx.reverb_send[instance_id] = constrain(configuration.fx.reverb_send[instance_id], REVERB_SEND_MIN, REVERB_SEND_MAX);
}
}
}
void check_configuration_performance(void)
{
void check_configuration_performance(void)
{
configuration.performance.fx_number = constrain(configuration.performance.fx_number, FX_NUM_MIN, FX_NUM_MAX);
for (uint8_t instance_id = 0; instance_id < NUM_DEXED; instance_id++)
@ -1897,10 +1898,10 @@ void setup()
configuration.performance.voice[instance_id] = constrain(configuration.performance.voice[instance_id], 0, MAX_VOICES - 1);
configuration.performance.voiceconfig_number[instance_id] = constrain(configuration.performance.voiceconfig_number[instance_id], VOICECONFIG_NUM_MIN, VOICECONFIG_NUM_MAX);
}
}
}
void check_configuration_dexed(uint8_t instance_id)
{
void check_configuration_dexed(uint8_t instance_id)
{
configuration.dexed[instance_id].midi_channel = constrain(configuration.dexed[instance_id].midi_channel, MIDI_CHANNEL_MIN, MIDI_CHANNEL_MAX);
configuration.dexed[instance_id].lowest_note = constrain(configuration.dexed[instance_id].lowest_note, INSTANCE_LOWEST_NOTE_MIN, INSTANCE_LOWEST_NOTE_MAX);
configuration.dexed[instance_id].highest_note = constrain(configuration.dexed[instance_id].highest_note, INSTANCE_HIGHEST_NOTE_MIN, INSTANCE_HIGHEST_NOTE_MAX);
@ -1930,10 +1931,10 @@ void setup()
configuration.dexed[instance_id].portamento_glissando = constrain(configuration.dexed[instance_id].portamento_glissando, PORTAMENTO_GLISSANDO_MIN, PORTAMENTO_GLISSANDO_MAX);
configuration.dexed[instance_id].portamento_time = constrain(configuration.dexed[instance_id].portamento_time, PORTAMENTO_TIME_MIN, PORTAMENTO_TIME_MAX);
configuration.dexed[instance_id].op_enabled = constrain(configuration.dexed[instance_id].op_enabled, OP_ENABLED_MIN, OP_ENABLED_MAX);
}
}
void init_configuration(void)
{
void init_configuration(void)
{
#ifdef DEBUG
Serial.println(F("INITIALIZING CONFIGURATION"));
#endif
@ -2017,17 +2018,17 @@ void setup()
set_volume(configuration.sys.vol, configuration.sys.mono);
eeprom_update();
}
}
void eeprom_update(void)
{
void eeprom_update(void)
{
uint8_t* c = (uint8_t*)&configuration;
for (uint16_t i = 0; i < sizeof(configuration); i++)
EEPROM.update(EEPROM_START_ADDRESS + i, c[i]);
}
}
void eeprom_update_sys(void)
{
void eeprom_update_sys(void)
{
uint8_t* c = (uint8_t*)&configuration.sys;
for (uint16_t i = 0; i < sizeof(configuration.sys); i++)
@ -2036,16 +2037,16 @@ void setup()
#ifdef DEBUG
Serial.println(F("Updating EEPROM sys."));
#endif
}
}
bool eeprom_get_sys(void)
{
bool eeprom_get_sys(void)
{
EEPROM.get(EEPROM_START_ADDRESS + offsetof(configuration_s, sys), configuration.sys);
return (true);
}
}
void eeprom_update_fx(void)
{
void eeprom_update_fx(void)
{
uint8_t* c = (uint8_t*)&configuration.fx;
for (uint16_t i = 0; i < sizeof(configuration.fx); i++)
@ -2054,16 +2055,16 @@ void setup()
#ifdef DEBUG
Serial.println(F("Updating EEPROM fx."));
#endif
}
}
bool eeprom_get_fx(void)
{
bool eeprom_get_fx(void)
{
EEPROM.get(EEPROM_START_ADDRESS + offsetof(configuration_s, fx), configuration.fx);
return (true);
}
}
void eeprom_update_dexed(uint8_t instance_id)
{
void eeprom_update_dexed(uint8_t instance_id)
{
#if NUM_DEXED == 1
uint8_t* c = (uint8_t*)&configuration.dexed[0];
@ -2091,10 +2092,10 @@ void setup()
Serial.print(instance_id);
Serial.println(F(")."));
#endif
}
}
bool eeprom_get_dexed(uint8_t instance_id)
{
bool eeprom_get_dexed(uint8_t instance_id)
{
for (uint8_t instance_id = 0; instance_id < MAX_DEXED; instance_id++)
{
if (instance_id == 0)
@ -2103,31 +2104,31 @@ void setup()
EEPROM.get(EEPROM_START_ADDRESS + offsetof(configuration_s, dexed[1]), configuration.dexed[1]);
}
return (true);
}
}
void eeprom_update_performance()
{
void eeprom_update_performance()
{
EEPROM.put(EEPROM_START_ADDRESS + offsetof(configuration_s, performance), configuration.performance);
#ifdef DEBUG
Serial.println(F("Updating EEPROM performance."));
#endif
}
}
bool eeprom_get_performance()
{
bool eeprom_get_performance()
{
EEPROM.get(EEPROM_START_ADDRESS + offsetof(configuration_s, performance), configuration.performance);
#ifdef DEBUG
Serial.println(F("Getting EEPROM performance."));
#endif
return (true);
}
}
/******************************************************************************
/******************************************************************************
PARAMETER-HELPERS
******************************************************************************/
******************************************************************************/
void set_fx_params(void)
{
void set_fx_params(void)
{
#if defined(USE_FX)
for (uint8_t instance_id = 0; instance_id < NUM_DEXED; instance_id++)
{
@ -2214,10 +2215,10 @@ void setup()
#endif
init_MIDI_send_CC();
}
}
void set_voiceconfig_params(uint8_t instance_id)
{
void set_voiceconfig_params(uint8_t instance_id)
{
// INIT PEAK MIXER
microdexed_peak_mixer.gain(instance_id, 1.0);
@ -2238,36 +2239,36 @@ void setup()
// PANORAMA
mono2stereo[instance_id]->panorama(mapfloat(configuration.dexed[instance_id].pan, PANORAMA_MIN, PANORAMA_MAX, -1.0, 1.0));
}
}
void set_sys_params(void)
{
void set_sys_params(void)
{
// set initial volume
set_volume(configuration.sys.vol, configuration.sys.mono);
}
}
/******************************************************************************
/******************************************************************************
HELPERS
******************************************************************************/
******************************************************************************/
// https://www.reddit.com/r/Teensy/comments/7r19uk/reset_and_reboot_teensy_lc_via_code/
// https://www.reddit.com/r/Teensy/comments/7r19uk/reset_and_reboot_teensy_lc_via_code/
#define SCB_AIRCR (*(volatile uint32_t *)0xE000ED0C) // Application Interrupt and Reset Control location
void _softRestart(void)
{
void _softRestart(void)
{
Serial.end(); //clears the serial monitor if used
SCB_AIRCR = 0x05FA0004; //write value for restart
}
}
float pseudo_log_curve(float value)
{
float pseudo_log_curve(float value)
{
//return (mapfloat(_pseudo_log * arm_sin_f32(value), 0.0, _pseudo_log * arm_sin_f32(1.0), 0.0, 1.0));
//return (1 - sqrt(1 - value * value));
//return (pow(2, value) - 1);
return (pow(value, 2.2));
}
}
uint32_t crc32(byte * calc_start, uint16_t calc_bytes) // base code from https://www.arduino.cc/en/Tutorial/EEPROMCrc
{
uint32_t crc32(byte * calc_start, uint16_t calc_bytes) // base code from https://www.arduino.cc/en/Tutorial/EEPROMCrc
{
const uint32_t crc_table[16] =
{
0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
@ -2285,10 +2286,10 @@ void setup()
}
return (crc);
}
}
void generate_version_string(char* buffer, uint8_t len)
{
void generate_version_string(char* buffer, uint8_t len)
{
char tmp[3];
memset(buffer, 0, len);
@ -2308,21 +2309,21 @@ void setup()
itoa (MAX_NOTES, tmp, 10);
strncat(buffer, tmp, 2);
#endif
}
}
#ifdef DISPLAY_LCD_SPI
void change_disp_sd(bool disp)
{
void change_disp_sd(bool disp)
{
if (sd_card > 0)
{
digitalWrite(sd_card, disp);
digitalWrite(U8X8_CS_PIN, !disp);
}
}
}
#endif
uint8_t check_sd_cards(void)
{
uint8_t check_sd_cards(void)
{
uint8_t ret = 0;
memset(sd_string, 0, sizeof(sd_string));
@ -2420,10 +2421,10 @@ void setup()
#endif
return (ret);
}
}
void check_and_create_directories(void)
{
void check_and_create_directories(void)
{
if (sd_card > 0)
{
uint8_t i;
@ -2531,14 +2532,14 @@ void setup()
Serial.println(F("No SD card for directory check available."));
#endif
}
}
}
/******************************************************************************
/******************************************************************************
DEBUG HELPER
******************************************************************************/
******************************************************************************/
#if defined (DEBUG) && defined (SHOW_CPU_LOAD_MSEC)
void show_cpu_and_mem_usage(void)
{
void show_cpu_and_mem_usage(void)
{
uint32_t sum_xrun = 0;
uint16_t sum_render_time_max = 0;
@ -2608,12 +2609,12 @@ void setup()
#endif
AudioProcessorUsageMaxReset();
AudioMemoryUsageMaxReset();
}
}
#endif
#ifdef DEBUG
void show_configuration(void)
{
void show_configuration(void)
{
Serial.println();
Serial.println(F("CONFIGURATION:"));
Serial.println(F("System"));
@ -2689,10 +2690,10 @@ void setup()
Serial.println();
Serial.flush();
}
}
void show_patch(uint8_t instance_id)
{
void show_patch(uint8_t instance_id)
{
char vn[VOICE_NAME_LEN];
Serial.print(F("INSTANCE "));
@ -2797,30 +2798,30 @@ void setup()
Serial.println(F(" |"));
Serial.println(F("+=========+=========+=========+=========+==========+==========+=========+==================================+"));
Serial.println(F("+==========================================================================================================+"));
}
}
void SerialPrintFormatInt3(uint8_t num)
{
void SerialPrintFormatInt3(uint8_t num)
{
char buf[4];
sprintf(buf, "%3d", num);
Serial.print(buf);
}
}
#ifdef TEENSY3_6
/* From: https://forum.pjrc.com/threads/33443-How-to-display-free-ram */
extern "C" char* sbrk(int incr);
uint32_t FreeMem(void)
{
/* From: https://forum.pjrc.com/threads/33443-How-to-display-free-ram */
extern "C" char* sbrk(int incr);
uint32_t FreeMem(void)
{
char top;
return &top - reinterpret_cast<char*>(sbrk(0));
}
}
#else
/* From: https://forum.pjrc.com/threads/33443-How-to-display-free-ram */
extern unsigned long _heap_end;
extern char *__brkval;
int FreeMem(void)
{
/* From: https://forum.pjrc.com/threads/33443-How-to-display-free-ram */
extern unsigned long _heap_end;
extern char *__brkval;
int FreeMem(void)
{
return (char *)&_heap_end - __brkval;
}
}
#endif
#endif

62
UI.hpp
Unescape View File

@ -100,6 +100,7 @@ extern uint8_t arp_oct_usersetting;
extern uint8_t arp_style;
extern uint8_t arp_speed;
extern char arp_style_names[4][3];
extern char seq_chord_names[7][4];
#endif
#ifdef DISPLAY_LCD_SPI
@ -4243,7 +4244,6 @@ void UI_func_seq_vel_editor(uint8_t param)
else if (seq_vel[seq_active_track][seq_menu - 1] == 203) lcd.print("Aug" );
else if (seq_vel[seq_active_track][seq_menu - 1] == 204) lcd.print("Dim" );
else if (seq_vel[seq_active_track][seq_menu - 1] == 205) lcd.print("Mj7" );
}
}
}
@ -4301,8 +4301,6 @@ void arp_refresh_display_play_status()
}
}
void UI_func_sequencer(uint8_t param)
{
if (LCDML.FUNC_setup()) // ****** SETUP *********
@ -4786,17 +4784,19 @@ void UI_func_arpeggio(uint8_t param)
if (LCDML.FUNC_setup()) // ****** SETUP *********
{
encoderDir[ENC_R].reset();
seq_temp_active_menu = 0;
seq_temp_select_menu=0;
seq_temp_active_menu=0;
lcd.setCursor( 0, 0);
lcd.print("Oct");
lcd.setCursor(7, 0);
lcd.print( seq_chord_names[arp_chord][0]);
lcd.print( seq_chord_names[arp_chord][1]);
lcd.print( seq_chord_names[arp_chord][2]);
lcd.print( seq_chord_names[arp_chord][3]);
lcd.setCursor( 0, 1);
lcd.print("Style");
lcd.setCursor( 7, 0);
lcd.print("Maj");
lcd.setCursor( 11, 1);
lcd.print("1/16");
lcd.setCursor( 7, 0);
lcd.print(" ");
arp_refresh_display_play_status();
}
if (LCDML.FUNC_loop()) // ****** LOOP *********
@ -4830,6 +4830,7 @@ void UI_func_arpeggio(uint8_t param)
else if (LCDML.BT_checkUp())
arp_speed = constrain(arp_speed - ENCODER[ENC_R].speed(), 0, 1);
}
if (LCDML.BT_checkEnter()) //handle button presses during menu >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
{
if ( seq_temp_select_menu == 0 && seq_temp_active_menu == 0 )
@ -4849,7 +4850,6 @@ void UI_func_arpeggio(uint8_t param)
seq_temp_active_menu = 0;
}
//else if ( seq_temp_select_menu == 2 && seq_temp_active_menu == 0 )
else if ( seq_temp_select_menu == 2 )
{
@ -4880,6 +4880,8 @@ void UI_func_arpeggio(uint8_t param)
}
}
}
lcd.setCursor( 4, 0);
lcd.print(arp_oct_usersetting);
lcd.setCursor( 6, 1);
@ -4894,10 +4896,6 @@ void UI_func_arpeggio(uint8_t param)
lcd.print("[");
lcd.setCursor( 5, 0);
lcd.print("]");
lcd.setCursor( 11, 0);
lcd.print(" ");
lcd.setCursor( 15, 0);
lcd.print(" ");
lcd.setCursor( 5, 1);
lcd.print(" ");
lcd.setCursor( 9, 1);
@ -4910,6 +4908,11 @@ void UI_func_arpeggio(uint8_t param)
}
else if (seq_temp_select_menu == 1)
{
lcd.setCursor( 5, 1);
lcd.print("[");
lcd.setCursor( 9, 1);
lcd.print("]");
lcd.setCursor( 3, 0);
lcd.print(" ");
lcd.setCursor( 5, 0);
@ -4918,10 +4921,6 @@ void UI_func_arpeggio(uint8_t param)
lcd.print(" ");
lcd.setCursor( 15, 0);
lcd.print(" ");
lcd.setCursor( 5, 1);
lcd.print("[");
lcd.setCursor( 9, 1);
lcd.print("]");
}
else if (seq_temp_select_menu == 2)
{
@ -4929,14 +4928,14 @@ void UI_func_arpeggio(uint8_t param)
lcd.print(" ");
lcd.setCursor( 9, 1);
lcd.print(" ");
lcd.setCursor( 10, 1);
lcd.print(" ");
lcd.setCursor( 15, 1);
lcd.print(" ");
lcd.setCursor( 11, 0);
lcd.print("[");
lcd.setCursor( 15, 0);
lcd.print("]");
lcd.setCursor( 10, 1);
lcd.print(" ");
lcd.setCursor( 15, 1);
lcd.print(" ");
}
else if (seq_temp_select_menu == 3)
{
@ -4944,15 +4943,16 @@ void UI_func_arpeggio(uint8_t param)
lcd.print(" ");
lcd.setCursor( 15, 0);
lcd.print(" ");
lcd.setCursor( 3, 0);
lcd.print(" ");
lcd.setCursor( 5, 0);
lcd.print(" ");
lcd.setCursor( 10, 1);
lcd.print("[");
lcd.setCursor( 15, 1);
lcd.print("]");
lcd.setCursor( 3, 0);
lcd.print(" ");
lcd.setCursor( 5, 0);
lcd.print(" ");
}
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
{
@ -4965,7 +4965,8 @@ void UI_func_seq_pat_chain(uint8_t param)
if (LCDML.FUNC_setup()) // ****** SETUP *********
{
// setup function
seq_temp_select_menu = 0;
seq_temp_active_menu = 99;
lcd.setCursor( 12, 0);
lcd.print(seq_chain_active_chainstep + 1);
lcd.setCursor( 13, 0);
@ -4974,22 +4975,22 @@ void UI_func_seq_pat_chain(uint8_t param)
lcd.print(seq_chain_lenght + 1);
lcd.setCursor(0 , 0);
if (seq_track_type[0] == 0 ) lcd.print("D"); else lcd.print("I");
if (seq_track_type[0] == 0 ) lcd.print("D"); else if (seq_track_type[0] == 1 ) lcd.print("I"); else if (seq_track_type[0] == 2 ) lcd.print("C"); else lcd.print("A");
lcd.setCursor(2 , 0);
lcd.print( seq_patternchain[seq_chain_active_chainstep][0]);
lcd.setCursor(0 , 1);
if (seq_track_type[1] == 0 )lcd.print("D"); else lcd.print("I");
if (seq_track_type[1] == 0 ) lcd.print("D"); else if (seq_track_type[1] == 1 ) lcd.print("I"); else if (seq_track_type[1] == 2 ) lcd.print("C"); else lcd.print("A");
lcd.setCursor(2 , 1);
lcd.print( seq_patternchain[seq_chain_active_chainstep][1]);
lcd.setCursor(6 , 0);
if (seq_track_type[2] == 0 ) lcd.print("D"); else lcd.print("I");
if (seq_track_type[2] == 0 ) lcd.print("D"); else if (seq_track_type[2] == 1 ) lcd.print("I"); else if (seq_track_type[2] == 2 ) lcd.print("C"); else lcd.print("A");
lcd.setCursor(8 , 0);
lcd.print( seq_patternchain[seq_chain_active_chainstep][2]);
lcd.setCursor(6 , 1);
if (seq_track_type[3] == 0 )lcd.print("D"); else lcd.print("I");
if (seq_track_type[3] == 0 ) lcd.print("D"); else if (seq_track_type[3] == 1 ) lcd.print("I"); else if (seq_track_type[3] == 2 ) lcd.print("C"); else lcd.print("A");
lcd.setCursor(8 , 1);
lcd.print( seq_patternchain[seq_chain_active_chainstep][3]);
}
@ -5021,6 +5022,7 @@ void UI_func_seq_pat_chain(uint8_t param)
seq_patternchain[seq_chain_active_chainstep][seq_temp_active_menu] = constrain(seq_patternchain[seq_chain_active_chainstep][seq_temp_active_menu] - 1, 0, 9);
}
}
if (seq_temp_select_menu == 0 && seq_temp_active_menu == 99) // Drum 0
{
lcd.setCursor(1 , 0);

31
UI_FX_T4.h
Unescape View File

@ -124,19 +124,20 @@ LCDML_add(90, LCDML_0, 5, "Sequencer", NULL);
LCDML_add(91, LCDML_0_5, 1, "Sequencer", UI_func_sequencer);
LCDML_add(92, LCDML_0_5, 2, "Vel./Chrd Edit", UI_func_seq_vel_editor);
LCDML_add(93, LCDML_0_5, 3, "Pattern Chain", UI_func_seq_pat_chain);
LCDML_add(94, LCDML_0_5, 4, "Seq. Length", UI_func_seq_lenght);
LCDML_add(95, LCDML_0_5, 5, "Tempo", UI_func_seq_tempo);
LCDML_add(96, LCDML_0_5, 6, "L.Transp.Key", UI_func_seq_live_transpose_oct);
LCDML_add(97, LCDML_0_5, 7, "Track Setup", UI_func_seq_track_setup);
LCDML_add(98, LCDML_0_5, 8, "Seq.Disp.Style", UI_func_seq_display_style);
LCDML_add(99, LCDML_0_5, 9, "LOAD Patterns", UI_func_seq_pattern_load);
LCDML_add(100, LCDML_0_5, 10, "SAVE Patterns", UI_func_seq_pattern_save);
LCDML_add(101, LCDML_0, 6, "System", NULL);
LCDML_add(102, LCDML_0_6, 1, "Stereo/Mono", UI_func_stereo_mono);
LCDML_add(103, LCDML_0_6, 2, "MIDI Soft THRU", UI_func_midi_soft_thru);
LCDML_add(104, LCDML_0_6, 3, "Favorites", UI_func_favorites);
LCDML_add(105, LCDML_0_6, 4, "EEPROM Reset", UI_func_eeprom_reset);
LCDML_add(106, LCDML_0, 7, "Info", UI_func_information);
LCDML_addAdvanced(107, LCDML_0, 8, COND_hide, "Volume", UI_func_volume, 0, _LCDML_TYPE_default);
#define _LCDML_DISP_cnt 107
LCDML_add(94, LCDML_0_5, 4, "Arpeggio", UI_func_arpeggio);
LCDML_add(95, LCDML_0_5, 5, "Seq. Length", UI_func_seq_lenght);
LCDML_add(96, LCDML_0_5, 6, "Tempo", UI_func_seq_tempo);
LCDML_add(97, LCDML_0_5, 7, "L.Transp.Key", UI_func_seq_live_transpose_oct);
LCDML_add(98, LCDML_0_5, 8, "Track Setup", UI_func_seq_track_setup);
LCDML_add(99, LCDML_0_5, 9, "Seq.Disp.Style", UI_func_seq_display_style);
LCDML_add(100, LCDML_0_5, 10, "LOAD Patterns", UI_func_seq_pattern_load);
LCDML_add(101, LCDML_0_5, 11, "SAVE Patterns", UI_func_seq_pattern_save);
LCDML_add(102, LCDML_0, 6, "System", NULL);
LCDML_add(103, LCDML_0_6, 1, "Stereo/Mono", UI_func_stereo_mono);
LCDML_add(104, LCDML_0_6, 2, "MIDI Soft THRU", UI_func_midi_soft_thru);
LCDML_add(105, LCDML_0_6, 3, "Favorites", UI_func_favorites);
LCDML_add(106, LCDML_0_6, 4, "EEPROM Reset", UI_func_eeprom_reset);
LCDML_add(107, LCDML_0, 7, "Info", UI_func_information);
LCDML_addAdvanced(108, LCDML_0, 8, COND_hide, "Volume", UI_func_volume, 0, _LCDML_TYPE_default);
#define _LCDML_DISP_cnt 108
#endif

5
dexed_sd.cpp
Unescape View File

@ -830,8 +830,6 @@ bool save_sd_seq_json(uint8_t seq_number)
for (uint8_t i = 0; i < MAX_DEXED; i++)
{
data_json["reverb_send"][i] = configuration.fx.reverb_send[i];
data_json["perform_attack_mod"][i] = perform_attack_mod[i];
data_json["perform_release_mod"][i] = perform_release_mod[i];
}
data_json["reverb_roomsize"] = configuration.fx.reverb_roomsize;
@ -955,9 +953,6 @@ bool load_sd_seq_json(uint8_t seq_number)
for (uint8_t i = 0; i < MAX_DEXED; i++)
{
configuration.fx.reverb_send[i] = data_json["reverb_send"][i];
//perform_attack_mod[i] = data_json["perform_attack_mod"][i];
//perform_release_mod[i] = data_json["perform_release_mod"][i];
}
configuration.fx.reverb_roomsize = data_json["reverb_roomsize"];
configuration.fx.reverb_damping = data_json["reverb_damping"];

6
midi_devices.hpp
Unescape View File

@ -83,10 +83,10 @@ void MD_sendControlChange(uint8_t channel, uint8_t cc, uint8_t value);
#ifdef MIDI_DEVICE_DIN
void handleNoteOn_MIDI_DEVICE_DIN(byte inChannel, byte inNumber, byte inVelocity)
{
handleNoteOn(inChannel, inNumber, inVelocity);
seq_note_in=inNumber;
seq_note_in_velocity=inVelocity;
#ifdef DEBUG
handleNoteOn(inChannel, inNumber, inVelocity);
#ifdef DEBUG
Serial.print(F("[MIDI_DIN] NoteOn"));
#endif
if (configuration.sys.soft_midi_thru == 1)
@ -584,9 +584,9 @@ void handleSystemReset_MIDI_DEVICE_DIN(void)
#ifdef MIDI_DEVICE_USB_HOST
void handleNoteOn_MIDI_DEVICE_USB_HOST(byte inChannel, byte inNumber, byte inVelocity)
{
handleNoteOn(inChannel, inNumber, inVelocity);
seq_note_in=inNumber;
seq_note_in_velocity=inVelocity;
handleNoteOn(inChannel, inNumber, inVelocity);
#ifdef DEBUG
Serial.print(F("[MIDI_USB_HOST] NoteOn"));
#endif

49
sequencer.cpp
Unescape View File

@ -25,18 +25,13 @@ void sequencer_part1(void)
//seq_note_in = 0;
//}
// if (LCDML.FUNC_getID() == LCDML.OTHER_getIDFromFunction(UI_func_sequencer)) { //is in UI of Sequencer
//write to sequencer if in sequencer menu
// if (seq_note_in > 0 && seq_recording == true) {
//
// // if ( seq_content_type[ seq_patternchain[seq_chain_active_step][active_track] ] == 1) handleNoteOff(configuration.dexed[0].midi_channel, seq_data[active_track][seq_step] + seq_transpose , 0);
//
// seq_data[seq_active_track][seq_step] = seq_note_in;
// seq_vel[seq_active_track][seq_step] = seq_note_in_velocity;
// seq_note_in = 0;
// seq_note_in_velocity = 0;
// }
//record to sequencer if sequencer menu is active and recording is active
if (seq_note_in > 0 && seq_recording == true && LCDML.FUNC_getID() == LCDML.OTHER_getIDFromFunction(UI_func_sequencer)) {
seq_data[seq_active_track][seq_step] = seq_note_in;
seq_vel[seq_active_track][seq_step] = seq_note_in_velocity;
seq_note_in = 0;
seq_note_in_velocity = 0;
}
for (uint8_t d = 0; d < 4; d++)
{
@ -49,7 +44,7 @@ void sequencer_part1(void)
else {
if (seq_data[ seq_patternchain[seq_chain_active_step][d] ][seq_step] > 0 && seq_vel[ seq_patternchain[seq_chain_active_step][d] ][seq_step] > 0) // instrument track
{
if (seq_track_type[d] == 1 || seq_track_type[d] == 3 )
if (seq_track_type[d] == 1 || (seq_track_type[d] == 3 && arp_play_basenote) )
{
handleNoteOn(configuration.dexed[seq_inst_dexed[d]].midi_channel, seq_data[ seq_patternchain[seq_chain_active_step][d] ][seq_step] + seq_transpose , seq_vel[ seq_patternchain[seq_chain_active_step][d] ][seq_step]);
}
@ -68,36 +63,37 @@ void sequencer_part1(void)
arp_step = 0;
arp_counter = 0;
arp_note = seq_data[ seq_patternchain[seq_chain_active_step][d] ][seq_step] + seq_transpose;
arp_chord = seq_vel[ seq_patternchain[seq_chain_active_step][d] ][seq_step];
if (seq_vel[ seq_patternchain[seq_chain_active_step][d] ][seq_step] - 200 >= 0)
arp_chord = seq_vel[ seq_patternchain[seq_chain_active_step][d] ][seq_step] - 200;
}
}
}
if (seq_track_type[d] == 3)
{ //Arp
if (arp_speed == 0 || (arp_speed == 1 && arp_counter == 2) ) {
if (arp_step == 0 ) {
if (arp_speed == 0 || (arp_speed == 1 && arp_counter == 0) ) {
if (arp_step % 8 == 0 ) {
handleNoteOn(configuration.dexed[seq_chord_dexed_inst].midi_channel, arp_note + arp_octave * 12 , seq_chord_velocity);
arp_note_prev = arp_note + arp_octave * 12;
}
else
{ if (arp_style == 0) { //arp up
handleNoteOn(configuration.dexed[seq_chord_dexed_inst].midi_channel, arp_note + seq_chords[arp_chord - 200][arp_step - 1] + arp_octave * 12, seq_chord_velocity);
arp_note_prev = arp_note + seq_chords[arp_chord - 200][arp_step - 1] + arp_octave * 12;
handleNoteOn(configuration.dexed[seq_chord_dexed_inst].midi_channel, arp_note + seq_chords[arp_chord][arp_step] + arp_octave * 12, seq_chord_velocity);
arp_note_prev = arp_note + seq_chords[arp_chord][arp_step] + arp_octave * 12;
}
else if (arp_style == 3) { //arp random
uint8_t rnd1 = random(4);
uint8_t rnd2 = random(arp_oct_usersetting + 1) * 12;
handleNoteOn(configuration.dexed[seq_chord_dexed_inst].midi_channel, arp_note + seq_chords[arp_chord - 200][rnd1] + rnd2, seq_chord_velocity);
arp_note_prev = arp_note + seq_chords[arp_chord - 200][rnd1] + rnd2;
handleNoteOn(configuration.dexed[seq_chord_dexed_inst].midi_channel, arp_note + seq_chords[arp_chord][rnd1] + rnd2, seq_chord_velocity);
arp_note_prev = arp_note + seq_chords[arp_chord][rnd1] + rnd2;
}
}
}
}
seq_noteoffsent[d] = false;
}
arp_counter++;
seq_step++;
if (arp_speed == 0) // Arp Speed 1/16
{
arp_step++;
@ -110,13 +106,14 @@ void sequencer_part1(void)
arp_counter = 0;
arp_step++;
}
arp_counter++;
}
}
if (arp_step > 3 || seq_chords[arp_chord - 200][arp_step] == 0 ) {
//if (arp_step > 3 || seq_chords[arp_chord][arp_step] == 0 ) {
if (arp_step > 3 || seq_chords[arp_chord][arp_step] == 0 ) {
arp_step = 0;
arp_octave++;
if (arp_octave > arp_oct_usersetting) arp_octave = 0;
if (arp_octave >= arp_oct_usersetting) arp_octave = 0;
}
if (seq_step > 15) {
seq_step = 0;
@ -134,7 +131,7 @@ void sequencer_part2(void)
{
for (uint8_t d = 0; d < 4; d++)
{
if ( seq_noteoffsent[d] == false) {
if (seq_noteoffsent[d] == false) {
if ( seq_prev_note[d] > 0 && seq_track_type[d] > 0)
{
handleNoteOff(configuration.dexed[seq_inst_dexed[d]].midi_channel, seq_prev_note[d] , 0);

25
sequencer.h
Unescape View File

@ -9,23 +9,25 @@ bool seq_recording = false;
uint8_t seq_note_in;
uint8_t seq_note_in_velocity;
int seq_transpose;
uint8_t seq_inst_dexed[4] = { 0, 0, 0, 1 };
uint8_t seq_inst_dexed[4] = { 0, 0, 1, 1 };
uint8_t seq_chord_dexed_inst = 0;
uint8_t seq_chord_velocity = 50;
uint8_t arp_style = 0; // up, down, up&down, random
uint8_t seq_chords[6][4] = { 4, 7, 12, 0, //major
3, 7, 12, 0, //minor
4, 7, 10, 12, //seventh
4, 8, 12, 0, //augmented
3, 6, 12, 0, //dim
4, 7, 11 , 0 //maj7,
uint8_t seq_chords[7][4] = { 4, 7, 0, 0, //major
3, 7, 0, 0, //minor
4, 7, 10, 0, //seventh
4, 8, 0, 0, //augmented
3, 6, 0 , 0, //dim
4, 7, 11, 0, //maj7,
0, 0, 0 , 0 //no Chord
};
char seq_chord_names[6][4] = { 'M', 'a', 'j', ' ' , //major
char seq_chord_names[7][4] = { 'M', 'a', 'j', ' ' , //major
'M', 'i', 'n', ' ' ,
's', 'e', 'v', ' ' ,
'a', 'u', 'g', ' ' ,
'd', 'i', 'm', ' ' ,
'M', 'a', 'j', '7' ,
'N', 'o', 'C', 'd' ,
};
@ -39,13 +41,14 @@ int seq_bpm = 102;
uint8_t seq_temp_select_menu;
uint8_t seq_temp_active_menu = 99;
uint8_t seq_chain_active_chainstep;
uint8_t seq_chain_lenght = 3; // 0 = 16 steps, 1 = 32 Steps, 2 = 46 Steps, 3 = 64 Steps
uint8_t seq_chain_lenght = 0; // 0 = 16 steps, 1 = 32 Steps, 2 = 46 Steps, 3 = 64 Steps
uint8_t seq_chain_active_step = 0;
uint8_t seq_prev_note[4]; // note_offs for every (instr.) track
uint8_t seq_prev_vel[4];
uint8_t arp_step;
uint8_t arp_note;
uint8_t arp_chord;
uint8_t arp_chord = 6;
bool arp_play_basenote=true;
uint8_t arp_note_prev;
uint8_t arp_octave;
uint8_t arp_prev_oct;
@ -78,7 +81,7 @@ uint8_t seq_vel[10][16] = {120, 0, 0, 0, 120, 0, 0, 0, 120, 0, 0, 0, 120, 0, 0,
uint8_t seq_patternchain[4][4] = { 0 , 1 , 6 , 9 , 0 , 1 , 5 , 8 , 0 , 1 , 6 , 9 , 2 , 1 , 5 , 7
};
uint8_t seq_content_type[10] = { 0, 0, 0, 0 , 1, 1, 1 , 1 , 1 , 1 }; // 0 = track is Drumtrack, 1= Instrumenttrack, 2= Chord or Arpeggio
uint8_t seq_track_type[4] = { 0, 0, 1, 1 }; // 0 = track is Drumtrack, 1 = Instrumenttrack, 2 = Chord, 3 = Arp
uint8_t seq_track_type[4] = { 0, 0, 0, 1 }; // 0 = track is Drumtrack, 1 = Instrumenttrack, 2 = Chord, 3 = Arp
//uint8_t seq_reverb[4][16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// 0, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 0,

Write Preview
Loading…
Cancel
Save