Clemens Valens / SoundEngine

This is a part of the Kinetiszer project.

Dependencies:   inc

Dependents:   kinetisizer

hardware.c@1:8ae4ab73ca6a, 2014-10-28 (annotated)

Committer:
Clemo
Date:
Tue Oct 28 20:09:12 2014 +0000
Revision:
1:8ae4ab73ca6a
Parent:
0:cb80470434eb 
First publication (untested)

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Clemo 0:cb80470434eb 1 #include "atmegatron.h"
Clemo 0:cb80470434eb 2 #include "lcd.h"
Clemo 0:cb80470434eb 3
Clemo 0:cb80470434eb 4 #define LOCKOUT 3000 //time between ctrl stop moving and locking it out
Clemo 0:cb80470434eb 5 #define HOLDLENGTH 2000 //time required to hold function button for hold functions (e.g. patch save)
Clemo 0:cb80470434eb 6
Clemo 0:cb80470434eb 7 //const uint16_t bg_select_store[16] = {1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768}; //values used to light single led of led array
Clemo 0:cb80470434eb 8 //const uint16_t bg_fill_store[16] = {1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; //values used to fill leds between 0-x of led array
Clemo 0:cb80470434eb 9 const uint16_t envADR_store[16] = {0,8,23,48,88,151,245,381,574,845,1217,1722,2399,3297,4476,6013}; //times used for attack, decay and release of envelopes
Clemo 0:cb80470434eb 10 const uchar envS_store[16] = {0,17,34,51,68,85,102,119,136,153,170,187,204,221,238,255}; //levels used for sustain of envelope1 (unipolar for amplitude)
Clemo 0:cb80470434eb 11 const signed char fenvS_store[16] = {0,8,17,25,34,42,51,59,68,76,85,93,102,110,119,127}; //levels used for sustain of envelope2 (bipolar for filter)
Clemo 0:cb80470434eb 12 const uint16_t speed_store[16] = {32767,16383,8191,6143,5460,4095,3071,2730,2047,1535,1023,767,511,383,255,127}; //values used for speeds of LFO and arpeggiator
Clemo 0:cb80470434eb 13 const uint16_t porta_store[16] = {0,5,14,27,46,77,123,195,306,477,740,1145,1768,2728,4207,6484}; //values for portamento speeds
Clemo 0:cb80470434eb 14
Clemo 0:cb80470434eb 15 //lets and gets (not all letable or getable at pres)
Clemo 0:cb80470434eb 16 byte hard_func = 255; //current selected function. 255 to allow reset in Init_Hardware
Clemo 0:cb80470434eb 17 byte hard_val[16]; //current select value for each function.
Clemo 0:cb80470434eb 18 byte hard_ctrl[2][6]; //current value for each digital control [bank][control]
Clemo 0:cb80470434eb 19 boolean hard_shift[16]; //current value of shift for each function (red/green mode)
Clemo 0:cb80470434eb 20
Clemo 0:cb80470434eb 21 //long lastval; //last value of value rotary encoder
Clemo 0:cb80470434eb 22 byte maxval = 15; //maximum value that is selectable on the value dial (normally 15 apart from user wave mode)
Clemo 0:cb80470434eb 23 boolean testbutdown = false; //test button (value encoder button)
Clemo 0:cb80470434eb 24 byte hard_curctrlbank = 0; //current value of ctrl bank (red/green mode of controls)
Clemo 0:cb80470434eb 25 byte hard_curctrl = 1; //current control being read. Only 1 control is read in each pass. read order: 0,1,0,2,0,3,0,4 etc, so cutoff is smooth as poss
Clemo 0:cb80470434eb 26 byte hard_nextctrl = 1; //sets next control to be read after cutoff.
Clemo 0:cb80470434eb 27 byte lastfuncbut = 0; //last value of function button input
Clemo 0:cb80470434eb 28 byte lastvalbut = 0; //last value of value button input
Clemo 0:cb80470434eb 29 byte lastbank = 0; //last value of ctrl bank button input
Clemo 0:cb80470434eb 30 byte lastctrl[6]; //last value read of each ctrl
Clemo 0:cb80470434eb 31 boolean movingctrl[6]; //is a ctrl moving (i.e. is user turning it)
Clemo 0:cb80470434eb 32 unsigned long stopmovingtick[6]; //tick when ctrl will lock out (to stop jitter) assuming user has stopped moving it
Clemo 0:cb80470434eb 33 unsigned long butstarttick = 0; //tick when button was pressed
Clemo 0:cb80470434eb 34 boolean finishedhold = false; //used by function button for function that require 2 sec hold (e.g. patch save)
Clemo 0:cb80470434eb 35 boolean MIDIchannelmode = false;
Clemo 0:cb80470434eb 36
Clemo 0:cb80470434eb 37
Clemo 0:cb80470434eb 38 void Hardware_Adjust_Value(byte func, byte val);
Clemo 0:cb80470434eb 39 void Hardware_Adjust_Shift(byte func, boolean val);
Clemo 0:cb80470434eb 40 boolean IsFuncFill(byte func);
Clemo 0:cb80470434eb 41 boolean IsShiftHold(byte func);
Clemo 0:cb80470434eb 42 void Hardware_Let_CtrlBank(byte value);
Clemo 0:cb80470434eb 43 void Hardware_Refresh_FuncBG(void);
Clemo 0:cb80470434eb 44 void Hardware_Refresh_ValBG(void);
Clemo 0:cb80470434eb 45 int Hardware_Ctrl_Update(byte shift, byte index, int value);
Clemo 0:cb80470434eb 46
Clemo 0:cb80470434eb 47
Clemo 0:cb80470434eb 48 // Here you can remap the rotary encoders in case you don't like
Clemo 0:cb80470434eb 49 // the way they are set up.
Clemo 0:cb80470434eb 50 //#define LEFT_HANDED
Clemo 0:cb80470434eb 51 // 0 <-> 1
Clemo 0:cb80470434eb 52 // 2 <-> 7
Clemo 0:cb80470434eb 53 // 3 <-> 6
Clemo 0:cb80470434eb 54 // 4 <-> 5
Clemo 0:cb80470434eb 55 uint8_t encoder_to_ctrl[8] =
Clemo 0:cb80470434eb 56 {
Clemo 0:cb80470434eb 57 #if defined LEFT_HANDED
Clemo 0:cb80470434eb 58 0, // function encoder
Clemo 0:cb80470434eb 59 1, // value encoder
Clemo 0:cb80470434eb 60 2, // filter cut-off
Clemo 0:cb80470434eb 61 7, // filter resonance
Clemo 0:cb80470434eb 62 3, // filter envelope (red) / pitch envelope (green)
Clemo 0:cb80470434eb 63 4, // filter lfo (red) / pitch lfo (green)
Clemo 0:cb80470434eb 64 5, // amplitude lfo (red) / pulse width lfo (green)
Clemo 0:cb80470434eb 65 6 // distortion (red) / phase lfo (green)
Clemo 0:cb80470434eb 66 #else
Clemo 0:cb80470434eb 67 0, // function encoder
Clemo 0:cb80470434eb 68 1, // value encoder
Clemo 0:cb80470434eb 69 7, // filter cut-off
Clemo 0:cb80470434eb 70 2, // filter resonance
Clemo 0:cb80470434eb 71 6, // filter envelope (red) / pitch envelope (green)
Clemo 0:cb80470434eb 72 5, // filter lfo (red) / pitch lfo (green)
Clemo 0:cb80470434eb 73 4, // amplitude lfo (red) / pulse width lfo (green)
Clemo 0:cb80470434eb 74 3 // distortion (red) / phase lfo (green)
Clemo 0:cb80470434eb 75 #endif // LEFT_HANDED
Clemo 0:cb80470434eb 76 };
Clemo 0:cb80470434eb 77
Clemo 0:cb80470434eb 78 #define ENCODER_FUNCTION encoder_to_ctrl[0]
Clemo 0:cb80470434eb 79 #define ENCODER_VALUE encoder_to_ctrl[1]
Clemo 0:cb80470434eb 80
Clemo 0:cb80470434eb 81
Clemo 0:cb80470434eb 82 //Hardware setup, only run once
Clemo 0:cb80470434eb 83 void Init_Hardware(void)
Clemo 0:cb80470434eb 84 {
Clemo 0:cb80470434eb 85 byte i;
Clemo 0:cb80470434eb 86 byte newctrl;
Clemo 0:cb80470434eb 87 //int ctrlread;
Clemo 0:cb80470434eb 88
Clemo 0:cb80470434eb 89 memset(hard_shift,0,sizeof(hard_shift)); // Set everything to RED.
Clemo 0:cb80470434eb 90
Clemo 0:cb80470434eb 91 Hardware_Let_Function(0); //initialise function dial to 0
Clemo 0:cb80470434eb 92
Clemo 0:cb80470434eb 93 //Hardware_LED_SetState(3,HIGH); //initialise value encoder LED to red
Clemo 0:cb80470434eb 94 //Hardware_LED_SetState(2,LOW);
Clemo 0:cb80470434eb 95 Hardware_BicolorLED_SetState(2,2,1);
Clemo 0:cb80470434eb 96
Clemo 0:cb80470434eb 97 Hardware_Refresh_ValBG(); //refresh value dial LED array
Clemo 0:cb80470434eb 98
Clemo 0:cb80470434eb 99 Hardware_Let_CtrlBank(0); //initialise ctrl bank to 0 (red mode)
Clemo 0:cb80470434eb 100
Clemo 0:cb80470434eb 101 //READ FUNCTION ENCODER BUTTON to see if setting MIDI channel number
Clemo 0:cb80470434eb 102 newctrl = keyboard_get_pushbutton(ENCODER_FUNCTION,false);
Clemo 0:cb80470434eb 103 // If function button down, then MIDI channel mode.
Clemo 0:cb80470434eb 104 if (newctrl>0)
Clemo 0:cb80470434eb 105 {
Clemo 0:cb80470434eb 106 MIDIchannelmode = true;
Clemo 0:cb80470434eb 107 //initialise value encoder LED to yellow (woo)
Clemo 0:cb80470434eb 108 //Hardware_LED_SetState(3,HIGH);
Clemo 0:cb80470434eb 109 //Hardware_LED_SetState(2,HIGH);
Clemo 0:cb80470434eb 110 Hardware_BicolorLED_SetState(2,1,1);
Clemo 0:cb80470434eb 111 Hardware_Let_Value(FUNC_MEM,Memory_Channel_Read());
Clemo 0:cb80470434eb 112 }
Clemo 0:cb80470434eb 113
Clemo 0:cb80470434eb 114 for (i=0; i<=5; i++)
Clemo 0:cb80470434eb 115 {
Clemo 0:cb80470434eb 116 //ctrlread = analogRead(i); //initialise lastctrl array. use analogread, coz speed not important
Clemo 0:cb80470434eb 117 //newctrl = ctrlread >> 2; //all ctrls are stored as byte (0-255) not ints
Clemo 0:cb80470434eb 118 //lastctrl[i] = newctrl;
Clemo 0:cb80470434eb 119 lastctrl[i] = 128; // TODO: should get these values from EEPROM.
Clemo 0:cb80470434eb 120 }
Clemo 0:cb80470434eb 121
Clemo 0:cb80470434eb 122 hard_curctrl = 0;
Clemo 0:cb80470434eb 123 }
Clemo 0:cb80470434eb 124
Clemo 0:cb80470434eb 125
Clemo 0:cb80470434eb 126 //*************POLL HARDWARE***********************
Clemo 0:cb80470434eb 127 void Hardware_Poll(void)
Clemo 0:cb80470434eb 128 {
Clemo 0:cb80470434eb 129 int newval;
Clemo 0:cb80470434eb 130 int newfunc;
Clemo 0:cb80470434eb 131 int temp;
Clemo 0:cb80470434eb 132 //byte r;
Clemo 0:cb80470434eb 133 byte newbut, newfuncbut, i, newvalbut;
Clemo 0:cb80470434eb 134 //int newctrl;
Clemo 0:cb80470434eb 135 //byte diff;
Clemo 0:cb80470434eb 136 unsigned long butcurtick;
Clemo 0:cb80470434eb 137 //uint8_t low, high;
Clemo 0:cb80470434eb 138 uint8_t ctrl;
Clemo 0:cb80470434eb 139
Clemo 0:cb80470434eb 140 // READ FUNCTION ENCODER
Clemo 0:cb80470434eb 141 newfunc = keyboard_get_rotary_encoder_value(ENCODER_FUNCTION);
Clemo 0:cb80470434eb 142 if (newfunc!=0)
Clemo 0:cb80470434eb 143 {
Clemo 0:cb80470434eb 144 // Grab display focus if needed.
Clemo 0:cb80470434eb 145 if (display_page_set(PAGE_FUNCTION)==0)
Clemo 0:cb80470434eb 146 {
Clemo 0:cb80470434eb 147 newfunc += hard_func;
Clemo 0:cb80470434eb 148 if (newfunc>15) newfunc = 0;
Clemo 0:cb80470434eb 149 else if (newfunc<0) newfunc = 15;
Clemo 0:cb80470434eb 150 Hardware_Let_Function(newfunc);
Clemo 0:cb80470434eb 151 }
Clemo 0:cb80470434eb 152 keyboard_set_rotary_encoder_value(ENCODER_FUNCTION,0);
Clemo 0:cb80470434eb 153 }
Clemo 0:cb80470434eb 154
Clemo 0:cb80470434eb 155 /*newfunc = re3_value;
Clemo 0:cb80470434eb 156 if (newfunc>0)
Clemo 0:cb80470434eb 157 {
Clemo 0:cb80470434eb 158 if (hard_func==15)
Clemo 0:cb80470434eb 159 {
Clemo 0:cb80470434eb 160 // Increment function.
Clemo 0:cb80470434eb 161 Hardware_Let_Function(0);
Clemo 0:cb80470434eb 162 }
Clemo 0:cb80470434eb 163 else
Clemo 0:cb80470434eb 164 {
Clemo 0:cb80470434eb 165 Hardware_Let_Function(hard_func+1);
Clemo 0:cb80470434eb 166 }
Clemo 0:cb80470434eb 167 // Set encoder pulse number back to 0.
Clemo 0:cb80470434eb 168 re3_value = 0;
Clemo 0:cb80470434eb 169 }
Clemo 0:cb80470434eb 170 // Same as above but for anti-clockwise.
Clemo 0:cb80470434eb 171 else if (newfunc<0)
Clemo 0:cb80470434eb 172 {
Clemo 0:cb80470434eb 173 if (hard_func==0)
Clemo 0:cb80470434eb 174 {
Clemo 0:cb80470434eb 175 Hardware_Let_Function(15);
Clemo 0:cb80470434eb 176 }
Clemo 0:cb80470434eb 177 else
Clemo 0:cb80470434eb 178 {
Clemo 0:cb80470434eb 179 Hardware_Let_Function(hard_func-1);
Clemo 0:cb80470434eb 180 }
Clemo 0:cb80470434eb 181 // Set encoder pulse number back to 0.
Clemo 0:cb80470434eb 182 re3_value = 0;
Clemo 0:cb80470434eb 183 }*/
Clemo 0:cb80470434eb 184
Clemo 0:cb80470434eb 185 // READ VALUE ENCODER
Clemo 0:cb80470434eb 186 newval = keyboard_get_rotary_encoder_value(ENCODER_VALUE);
Clemo 0:cb80470434eb 187 if (newval!=0)
Clemo 0:cb80470434eb 188 {
Clemo 0:cb80470434eb 189 // Grab display focus if needed.
Clemo 0:cb80470434eb 190 if (display_page_set(PAGE_FUNCTION)==0)
Clemo 0:cb80470434eb 191 {
Clemo 0:cb80470434eb 192 // Has encoder moved at all?
Clemo 0:cb80470434eb 193 if (newval!=0)
Clemo 0:cb80470434eb 194 {
Clemo 0:cb80470434eb 195 if (testbutdown==true)
Clemo 0:cb80470434eb 196 {
Clemo 0:cb80470434eb 197 // If value encoder button is down, change test note pitch.
Clemo 0:cb80470434eb 198 //if (newval>lastval)
Clemo 0:cb80470434eb 199 if (newval>0)
Clemo 0:cb80470434eb 200 {
Clemo 0:cb80470434eb 201 MIDI_TestButtonInc();
Clemo 0:cb80470434eb 202 }
Clemo 0:cb80470434eb 203 //if (newval<lastval)
Clemo 0:cb80470434eb 204 if (newval<0)
Clemo 0:cb80470434eb 205 {
Clemo 0:cb80470434eb 206 MIDI_TestButtonDec();
Clemo 0:cb80470434eb 207 }
Clemo 0:cb80470434eb 208 //lastval = newval;
Clemo 0:cb80470434eb 209 }
Clemo 0:cb80470434eb 210 else
Clemo 0:cb80470434eb 211 {
Clemo 0:cb80470434eb 212 // Allow roll-over of all functions (forget about "fill" functions).
Clemo 0:cb80470434eb 213 newval += hard_val[hard_func];
Clemo 0:cb80470434eb 214 if (newval>maxval) newval = 0;
Clemo 0:cb80470434eb 215 else if (newval<0) newval = maxval;
Clemo 0:cb80470434eb 216 Hardware_Let_Value(hard_func,newval);
Clemo 0:cb80470434eb 217
Clemo 0:cb80470434eb 218 // Has encoder moved one click?
Clemo 0:cb80470434eb 219 /*if (newval>0)
Clemo 0:cb80470434eb 220 {
Clemo 0:cb80470434eb 221 // If not a fill function (fill functions are A,D,S,R & portamento) and value at max
Clemo 0:cb80470434eb 222 if (hard_val[hard_func]==maxval && IsFuncFill(hard_func)==false)
Clemo 0:cb80470434eb 223 {
Clemo 0:cb80470434eb 224 // Go back to 0.
Clemo 0:cb80470434eb 225 Hardware_Let_Value(hard_func,0);
Clemo 0:cb80470434eb 226 }
Clemo 0:cb80470434eb 227 // Otherwise increment value.
Clemo 0:cb80470434eb 228 else if (hard_val[hard_func]<maxval)
Clemo 0:cb80470434eb 229 {
Clemo 0:cb80470434eb 230 Hardware_Let_Value(hard_func,hard_val[hard_func]+1);
Clemo 0:cb80470434eb 231 }
Clemo 0:cb80470434eb 232 }
Clemo 0:cb80470434eb 233 else if (newval<0)
Clemo 0:cb80470434eb 234 {
Clemo 0:cb80470434eb 235 // Same as above but for anti-clockwise.
Clemo 0:cb80470434eb 236 if (hard_val[hard_func]==0 && IsFuncFill(hard_func)==false)
Clemo 0:cb80470434eb 237 {
Clemo 0:cb80470434eb 238 Hardware_Let_Value(hard_func,maxval);
Clemo 0:cb80470434eb 239 }
Clemo 0:cb80470434eb 240 else if (hard_val[hard_func]>0)
Clemo 0:cb80470434eb 241 {
Clemo 0:cb80470434eb 242 Hardware_Let_Value(hard_func,hard_val[hard_func]-1);
Clemo 0:cb80470434eb 243 }
Clemo 0:cb80470434eb 244 }*/
Clemo 0:cb80470434eb 245 }
Clemo 0:cb80470434eb 246 }
Clemo 0:cb80470434eb 247 }
Clemo 0:cb80470434eb 248 keyboard_set_rotary_encoder_value(ENCODER_VALUE,0);
Clemo 0:cb80470434eb 249 }
Clemo 0:cb80470434eb 250
Clemo 0:cb80470434eb 251 //READ CTRL BANK BUTTON (red/green mode)
Clemo 0:cb80470434eb 252 newbut = keyboard_get_pushbutton(BOARD_KEYBOARD_ISP,false);
Clemo 0:cb80470434eb 253 // Has a button just been pressed - do nothing on release
Clemo 0:cb80470434eb 254 if (lastbank!=newbut && newbut>0)
Clemo 0:cb80470434eb 255 {
Clemo 0:cb80470434eb 256 // Toggle ctrl bank.
Clemo 0:cb80470434eb 257 if (hard_curctrlbank==0)
Clemo 0:cb80470434eb 258 {
Clemo 0:cb80470434eb 259 Hardware_Let_CtrlBank(1);
Clemo 0:cb80470434eb 260 }
Clemo 0:cb80470434eb 261 else
Clemo 0:cb80470434eb 262 {
Clemo 0:cb80470434eb 263 Hardware_Let_CtrlBank(0);
Clemo 0:cb80470434eb 264 }
Clemo 0:cb80470434eb 265 // Set all ctrls to not moving, just in case last thing you did was move ctrl in other bank and not locked out.
Clemo 0:cb80470434eb 266 for (i=0; i<6; i++)
Clemo 0:cb80470434eb 267 {
Clemo 0:cb80470434eb 268 movingctrl[i] = false;
Clemo 0:cb80470434eb 269 stopmovingtick[i] = master_tick + LOCKOUT;
Clemo 0:cb80470434eb 270 }
Clemo 0:cb80470434eb 271 display_invalidate();
Clemo 0:cb80470434eb 272 }
Clemo 0:cb80470434eb 273 // Store last state of button.
Clemo 0:cb80470434eb 274 lastbank = newbut;
Clemo 0:cb80470434eb 275
Clemo 0:cb80470434eb 276 //READ FUNCTION ENCODER BUTTON
Clemo 0:cb80470434eb 277 newfuncbut = keyboard_get_pushbutton(ENCODER_FUNCTION,false);
Clemo 0:cb80470434eb 278 // Are we on a function that requires function button to be held (e.g. save patch)?
Clemo 0:cb80470434eb 279 if (IsShiftHold(hard_func)==true)
Clemo 0:cb80470434eb 280 {
Clemo 0:cb80470434eb 281 //********SAVE AND LOAD IS DONE HERE**********
Clemo 0:cb80470434eb 282 //button pressed down, go green and wait
Clemo 0:cb80470434eb 283 if (lastfuncbut==0 && newfuncbut>0)
Clemo 0:cb80470434eb 284 {
Clemo 0:cb80470434eb 285 butstarttick = master_tick;
Clemo 0:cb80470434eb 286 Hard_Let_Shift(hard_func, true);
Clemo 0:cb80470434eb 287 finishedhold = false;
Clemo 0:cb80470434eb 288 }
Clemo 0:cb80470434eb 289 //is button still held
Clemo 0:cb80470434eb 290 else if (lastfuncbut>0 && newfuncbut>0)
Clemo 0:cb80470434eb 291 {
Clemo 0:cb80470434eb 292 butcurtick = master_tick - butstarttick;
Clemo 0:cb80470434eb 293 // Has button been held down for longer than hold length?
Clemo 0:cb80470434eb 294 if (butcurtick>=HOLDLENGTH && finishedhold==false)
Clemo 0:cb80470434eb 295 {
Clemo 0:cb80470434eb 296 switch (hard_func)
Clemo 0:cb80470434eb 297 {
Clemo 0:cb80470434eb 298 case FUNC_WAVE:
Clemo 0:cb80470434eb 299 // then do userwave write
Clemo 0:cb80470434eb 300 Memory_UserWave_Write(hard_val[FUNC_WAVE]);
Clemo 0:cb80470434eb 301 break;
Clemo 0:cb80470434eb 302
Clemo 0:cb80470434eb 303 case FUNC_AENVA:
Clemo 0:cb80470434eb 304 // then write patch to sysex
Clemo 0:cb80470434eb 305 MIDI_SYSEX_write_patch();
Clemo 0:cb80470434eb 306 break;
Clemo 0:cb80470434eb 307
Clemo 0:cb80470434eb 308 case FUNC_AENVR:
Clemo 0:cb80470434eb 309 // then start sysex mem dump
Clemo 0:cb80470434eb 310 Memory_SYSEX_write_mem();
Clemo 0:cb80470434eb 311 break;
Clemo 0:cb80470434eb 312
Clemo 0:cb80470434eb 313 case FUNC_MEM:
Clemo 0:cb80470434eb 314 if (MIDIchannelmode==true)
Clemo 0:cb80470434eb 315 {
Clemo 0:cb80470434eb 316 MIDI_Set_Channel(hard_val[hard_func]);
Clemo 0:cb80470434eb 317 }
Clemo 0:cb80470434eb 318 else
Clemo 0:cb80470434eb 319 {
Clemo 0:cb80470434eb 320 lcd_cursor(1,0);
Clemo 0:cb80470434eb 321 lcd_puts("Saving...");
Clemo 0:cb80470434eb 322 SysTick_Delay(100);
Clemo 0:cb80470434eb 323 // then save patch
Clemo 0:cb80470434eb 324 Memory_Save(hard_val[hard_func]);
Clemo 0:cb80470434eb 325 }
Clemo 0:cb80470434eb 326 break;
Clemo 0:cb80470434eb 327 }
Clemo 0:cb80470434eb 328 // completed operation (to prevent refires)
Clemo 0:cb80470434eb 329 finishedhold = true;
Clemo 0:cb80470434eb 330 Hard_Let_Shift(hard_func, false);
Clemo 0:cb80470434eb 331 // make encoder flash
Clemo 0:cb80470434eb 332 Hardware_LED_StartFlash(0,7);
Clemo 0:cb80470434eb 333 }
Clemo 0:cb80470434eb 334 }
Clemo 0:cb80470434eb 335 // Has button been released...
Clemo 0:cb80470434eb 336 else if (newfuncbut==0 && Hard_Get_Shift(hard_func)==true)
Clemo 0:cb80470434eb 337 {
Clemo 0:cb80470434eb 338 butcurtick = master_tick - butstarttick;
Clemo 0:cb80470434eb 339 // and it's been held less time than hold length...
Clemo 0:cb80470434eb 340 if (butcurtick < HOLDLENGTH)
Clemo 0:cb80470434eb 341 {
Clemo 0:cb80470434eb 342 switch (hard_func)
Clemo 0:cb80470434eb 343 {
Clemo 0:cb80470434eb 344 case FUNC_WAVE:
Clemo 0:cb80470434eb 345 // ...then toggle user wave mode
Clemo 0:cb80470434eb 346 Memory_UserWave_Read(hard_val[FUNC_WAVE]);
Clemo 0:cb80470434eb 347 break;
Clemo 0:cb80470434eb 348
Clemo 0:cb80470434eb 349 case FUNC_MEM:
Clemo 0:cb80470434eb 350 lcd_cursor(1,0);
Clemo 0:cb80470434eb 351 // then load patch
Clemo 0:cb80470434eb 352 if (Memory_Load(hard_val[hard_func])==true)
Clemo 0:cb80470434eb 353 {
Clemo 0:cb80470434eb 354 lcd_puts("Loading...");
Clemo 0:cb80470434eb 355 }
Clemo 0:cb80470434eb 356 else
Clemo 0:cb80470434eb 357 {
Clemo 0:cb80470434eb 358 lcd_puts("Empty...");
Clemo 0:cb80470434eb 359 }
Clemo 0:cb80470434eb 360 SysTick_Delay(100);
Clemo 0:cb80470434eb 361 for (i=0; i<6; i++)
Clemo 0:cb80470434eb 362 {
Clemo 0:cb80470434eb 363 // stop knob jitter from overriding loaded patch
Clemo 0:cb80470434eb 364 movingctrl[i] = false;
Clemo 0:cb80470434eb 365 }
Clemo 0:cb80470434eb 366 break;
Clemo 0:cb80470434eb 367 }
Clemo 0:cb80470434eb 368 }
Clemo 0:cb80470434eb 369 // Set shift back to false, LED red (red mode).
Clemo 0:cb80470434eb 370 Hard_Let_Shift(hard_func, false);
Clemo 0:cb80470434eb 371 }
Clemo 0:cb80470434eb 372 }
Clemo 0:cb80470434eb 373 else
Clemo 0:cb80470434eb 374 {
Clemo 0:cb80470434eb 375 // Button pressed, but not hold function.
Clemo 0:cb80470434eb 376 if (lastfuncbut!=newfuncbut && newfuncbut>0)
Clemo 0:cb80470434eb 377 {
Clemo 0:cb80470434eb 378 // ...then toggle shift (red/green mode)
Clemo 0:cb80470434eb 379 Hard_Let_Shift(hard_func, !Hard_Get_Shift(hard_func));
Clemo 0:cb80470434eb 380 }
Clemo 0:cb80470434eb 381 }
Clemo 0:cb80470434eb 382 //store last button state
Clemo 0:cb80470434eb 383 lastfuncbut = newfuncbut;
Clemo 0:cb80470434eb 384
Clemo 0:cb80470434eb 385 //READ VALUE ENCODER BUTTON
Clemo 0:cb80470434eb 386 newvalbut = keyboard_get_pushbutton(ENCODER_VALUE,false);
Clemo 0:cb80470434eb 387 //has button been pressed down
Clemo 0:cb80470434eb 388 if (lastvalbut==0 && newvalbut>0)
Clemo 0:cb80470434eb 389 {
Clemo 0:cb80470434eb 390 //midi test note on
Clemo 0:cb80470434eb 391 MIDI_TestButtonDown();
Clemo 0:cb80470434eb 392 testbutdown = true;
Clemo 0:cb80470434eb 393 //reset encoder pulse, because different ranges for midi test note mode.
Clemo 0:cb80470434eb 394 keyboard_set_rotary_encoder_value(ENCODER_VALUE,0);
Clemo 0:cb80470434eb 395 //knob goes green -> cpv red
Clemo 0:cb80470434eb 396 //Hardware_BicolorLED_SetState(1,2,1);
Clemo 0:cb80470434eb 397 //Hardware_LED_SetState(2,HIGH);
Clemo 0:cb80470434eb 398 //Hardware_LED_SetState(3,LOW);
Clemo 0:cb80470434eb 399 }
Clemo 0:cb80470434eb 400 //has button been released
Clemo 0:cb80470434eb 401 if (newvalbut==0 && lastvalbut>0)
Clemo 0:cb80470434eb 402 {
Clemo 0:cb80470434eb 403 //midi test note off
Clemo 0:cb80470434eb 404 MIDI_TestButtonUp();
Clemo 0:cb80470434eb 405 testbutdown = false;
Clemo 0:cb80470434eb 406 //reset encoder pulse again, to stop possible value dial jump
Clemo 0:cb80470434eb 407 keyboard_set_rotary_encoder_value(ENCODER_VALUE,0);
Clemo 0:cb80470434eb 408 //knob back to red -> cpv back to off
Clemo 0:cb80470434eb 409 //Hardware_BicolorLED_SetState(1,2,0);
Clemo 0:cb80470434eb 410 }
Clemo 0:cb80470434eb 411 //store last button state
Clemo 0:cb80470434eb 412 lastvalbut = newvalbut;
Clemo 0:cb80470434eb 413
Clemo 0:cb80470434eb 414 // READ CTRL KNOBS
Clemo 0:cb80470434eb 415 ctrl = 0;
Clemo 0:cb80470434eb 416 // Skip Function & Value encoders.
Clemo 0:cb80470434eb 417 for (i=2; i<8; i++)
Clemo 0:cb80470434eb 418 {
Clemo 0:cb80470434eb 419 if (keyboard_get_pushbutton(encoder_to_ctrl[i],false)>0)
Clemo 0:cb80470434eb 420 {
Clemo 0:cb80470434eb 421 // Reset rotary encoder.
Clemo 0:cb80470434eb 422 Hardware_Ctrl_Update(hard_curctrlbank,ctrl,0);
Clemo 0:cb80470434eb 423 display_page_set(PAGE_CTRL);
Clemo 0:cb80470434eb 424 display_invalidate();
Clemo 0:cb80470434eb 425 }
Clemo 0:cb80470434eb 426 temp = keyboard_get_rotary_encoder_value(encoder_to_ctrl[i]);
Clemo 0:cb80470434eb 427 temp *= keyboard_get_rotary_encoder_accelerator(encoder_to_ctrl[i]);
Clemo 0:cb80470434eb 428 if (temp!=0)
Clemo 0:cb80470434eb 429 {
Clemo 0:cb80470434eb 430 temp += Hardware_Get_Ctrl(hard_curctrlbank,ctrl);
Clemo 0:cb80470434eb 431 // Grab display focus if needed.
Clemo 0:cb80470434eb 432 if (display_page_set(PAGE_CTRL)==0)
Clemo 0:cb80470434eb 433 {
Clemo 0:cb80470434eb 434 // No page change, we can update the control.
Clemo 0:cb80470434eb 435 Hardware_Ctrl_Update(hard_curctrlbank,ctrl,temp);
Clemo 0:cb80470434eb 436 }
Clemo 0:cb80470434eb 437 keyboard_set_rotary_encoder_value(encoder_to_ctrl[i],0);
Clemo 0:cb80470434eb 438 }
Clemo 0:cb80470434eb 439 // Next control.
Clemo 0:cb80470434eb 440 ctrl += 1;
Clemo 0:cb80470434eb 441 }
Clemo 0:cb80470434eb 442 //firstly has enough time passed to lock ctrl (to prevent jitter in DA readings effecting value)
Clemo 0:cb80470434eb 443 /*if (master_tick >= stopmovingtick[hard_curctrl])
Clemo 0:cb80470434eb 444 {
Clemo 0:cb80470434eb 445 movingctrl[hard_curctrl] = false;
Clemo 0:cb80470434eb 446 }
Clemo 0:cb80470434eb 447 //is reading from DA is ready
Clemo 0:cb80470434eb 448 if (bit_is_set(ADCSRA, ADSC)==false)
Clemo 0:cb80470434eb 449 {
Clemo 0:cb80470434eb 450 low = ADCL;
Clemo 0:cb80470434eb 451 high = ADCH;
Clemo 0:cb80470434eb 452 //new reading of ctrl
Clemo 0:cb80470434eb 453 newctrl = ((high << 8) | low) >> 2;
Clemo 0:cb80470434eb 454 //calculate difference between new reading and old
Clemo 0:cb80470434eb 455 if (newctrl > lastctrl[hard_curctrl])
Clemo 0:cb80470434eb 456 {
Clemo 0:cb80470434eb 457 diff = newctrl-lastctrl[hard_curctrl];
Clemo 0:cb80470434eb 458 }
Clemo 0:cb80470434eb 459 else
Clemo 0:cb80470434eb 460 {
Clemo 0:cb80470434eb 461 diff = lastctrl[hard_curctrl]-newctrl;
Clemo 0:cb80470434eb 462 }
Clemo 0:cb80470434eb 463 //if difference > x then ctrl is being moved. ctrl lockout sensitivity set here (default = 4)
Clemo 0:cb80470434eb 464 if (diff > 4)
Clemo 0:cb80470434eb 465 {
Clemo 0:cb80470434eb 466 movingctrl[hard_curctrl] = true;
Clemo 0:cb80470434eb 467 //ctrl is moving, so reset lockout time
Clemo 0:cb80470434eb 468 stopmovingtick[hard_curctrl] = master_tick + LOCKOUT;
Clemo 0:cb80470434eb 469 }
Clemo 0:cb80470434eb 470 if (movingctrl[hard_curctrl] == true)
Clemo 0:cb80470434eb 471 {
Clemo 0:cb80470434eb 472 Hardware_Let_Ctrl(hard_curctrlbank, hard_curctrl, newctrl); //pass new value to ctrl parameter
Clemo 0:cb80470434eb 473 lastctrl[hard_curctrl] = newctrl; //store last ctrl state
Clemo 0:cb80470434eb 474 }
Clemo 0:cb80470434eb 475
Clemo 0:cb80470434eb 476 //increment current ctrl to read. order is: 0,1,0,2,0,3,0,4.. so filter cutoff ctrl is smooth
Clemo 0:cb80470434eb 477 if (hard_curctrl==0)
Clemo 0:cb80470434eb 478 {
Clemo 0:cb80470434eb 479 hard_curctrl = hard_nextctrl;
Clemo 0:cb80470434eb 480 hard_nextctrl++;
Clemo 0:cb80470434eb 481 if (hard_nextctrl>5)
Clemo 0:cb80470434eb 482 {
Clemo 0:cb80470434eb 483 hard_nextctrl = 1;
Clemo 0:cb80470434eb 484 }
Clemo 0:cb80470434eb 485 }
Clemo 0:cb80470434eb 486 else
Clemo 0:cb80470434eb 487 {
Clemo 0:cb80470434eb 488 hard_curctrl = 0;
Clemo 0:cb80470434eb 489 }
Clemo 0:cb80470434eb 490 //start DA conversion of next ctrl going
Clemo 0:cb80470434eb 491 ADMUX = (1 << 6) | (hard_curctrl & 0x07);
Clemo 0:cb80470434eb 492 sbi(ADCSRA, ADSC);
Clemo 0:cb80470434eb 493 }*/
Clemo 0:cb80470434eb 494
Clemo 0:cb80470434eb 495 //update LEDs that may be flashing
Clemo 0:cb80470434eb 496 //Hardware_LED_RefreshFlash();
Clemo 0:cb80470434eb 497 }
Clemo 0:cb80470434eb 498
Clemo 0:cb80470434eb 499
Clemo 0:cb80470434eb 500 int Hardware_Ctrl_Update(byte shift, byte index, int value)
Clemo 0:cb80470434eb 501 {
Clemo 0:cb80470434eb 502 if (value<0)
Clemo 0:cb80470434eb 503 {
Clemo 0:cb80470434eb 504 //value = 255;
Clemo 0:cb80470434eb 505 value = 0;
Clemo 0:cb80470434eb 506 }
Clemo 0:cb80470434eb 507 else if (value>255)
Clemo 0:cb80470434eb 508 {
Clemo 0:cb80470434eb 509 //value = 0;
Clemo 0:cb80470434eb 510 value = 255;
Clemo 0:cb80470434eb 511 }
Clemo 0:cb80470434eb 512 Hardware_Let_Ctrl(shift,index,value);
Clemo 0:cb80470434eb 513 display_invalidate();
Clemo 0:cb80470434eb 514 return value;
Clemo 0:cb80470434eb 515 }
Clemo 0:cb80470434eb 516
Clemo 0:cb80470434eb 517
Clemo 0:cb80470434eb 518 void Hardware_Let_Ctrl(byte shift, byte index, byte value)
Clemo 0:cb80470434eb 519 {
Clemo 0:cb80470434eb 520 switch (index)
Clemo 0:cb80470434eb 521 {
Clemo 0:cb80470434eb 522 case CTRL_FILT: //Filter Cutoff frequency (same in red and green mode)
Clemo 0:cb80470434eb 523 hard_ctrl[0][index] = value;
Clemo 0:cb80470434eb 524 hard_ctrl[1][index] = value;
Clemo 0:cb80470434eb 525 Filt_Let_Fc(value);
Clemo 0:cb80470434eb 526 break;
Clemo 0:cb80470434eb 527
Clemo 0:cb80470434eb 528 case CTRL_Q: //Filter resonance (same in red and green mode)
Clemo 0:cb80470434eb 529 hard_ctrl[0][index] = value;
Clemo 0:cb80470434eb 530 hard_ctrl[1][index] = value;
Clemo 0:cb80470434eb 531 Filt_Let_Q(value);
Clemo 0:cb80470434eb 532 break;
Clemo 0:cb80470434eb 533
Clemo 0:cb80470434eb 534 case CTRL_ENV:
Clemo 0:cb80470434eb 535 hard_ctrl[shift][index] = value;
Clemo 0:cb80470434eb 536 if (shift==0)
Clemo 0:cb80470434eb 537 {
Clemo 0:cb80470434eb 538 Filt_Let_FenvAmt(value); //Filter envelope amount
Clemo 0:cb80470434eb 539 }
Clemo 0:cb80470434eb 540 else
Clemo 0:cb80470434eb 541 {
Clemo 0:cb80470434eb 542 Pitch_Let_FenvAmt(value); //Pitch envelope amount
Clemo 0:cb80470434eb 543 }
Clemo 0:cb80470434eb 544 break;
Clemo 0:cb80470434eb 545
Clemo 0:cb80470434eb 546 case CTRL_LFO:
Clemo 0:cb80470434eb 547 hard_ctrl[shift][index] = value;
Clemo 0:cb80470434eb 548 if (shift==0)
Clemo 0:cb80470434eb 549 {
Clemo 0:cb80470434eb 550 Filt_Let_LFOAmt(value); //Filter LFO amount
Clemo 0:cb80470434eb 551 }
Clemo 0:cb80470434eb 552 else
Clemo 0:cb80470434eb 553 {
Clemo 0:cb80470434eb 554 Pitch_Let_LFOAmt(value); //Pitch LFO amount
Clemo 0:cb80470434eb 555 }
Clemo 0:cb80470434eb 556 break;
Clemo 0:cb80470434eb 557
Clemo 0:cb80470434eb 558 case CTRL_AMP:
Clemo 0:cb80470434eb 559 hard_ctrl[shift][index] = value;
Clemo 0:cb80470434eb 560 if (shift==0)
Clemo 0:cb80470434eb 561 {
Clemo 0:cb80470434eb 562 Amplitude_Let_LFOAmt(value); //Amplitude LFO amount
Clemo 0:cb80470434eb 563 }
Clemo 0:cb80470434eb 564 else
Clemo 0:cb80470434eb 565 {
Clemo 0:cb80470434eb 566 PWM_Let_LFOAmt(value>>3); //Pulse width modulation amount
Clemo 0:cb80470434eb 567 }
Clemo 0:cb80470434eb 568 break;
Clemo 0:cb80470434eb 569
Clemo 0:cb80470434eb 570 case CTRL_FX:
Clemo 0:cb80470434eb 571 hard_ctrl[shift][index] = value;
Clemo 0:cb80470434eb 572 if (shift==0)
Clemo 0:cb80470434eb 573 {
Clemo 0:cb80470434eb 574 Distortion_Let_Amt(value>>5); //Distortion (takes values 0-7)
Clemo 0:cb80470434eb 575 }
Clemo 0:cb80470434eb 576 else
Clemo 0:cb80470434eb 577 {
Clemo 0:cb80470434eb 578 Flange_Let_LFOAmt(value>>3); //Phaser (takes values 0-31)
Clemo 0:cb80470434eb 579 }
Clemo 0:cb80470434eb 580 break;
Clemo 0:cb80470434eb 581 }
Clemo 0:cb80470434eb 582 }
Clemo 0:cb80470434eb 583
Clemo 0:cb80470434eb 584
Clemo 0:cb80470434eb 585 byte Hardware_Get_Ctrl(byte shift, byte index)
Clemo 0:cb80470434eb 586 {
Clemo 0:cb80470434eb 587 return hard_ctrl[shift][index];
Clemo 0:cb80470434eb 588 }
Clemo 0:cb80470434eb 589
Clemo 0:cb80470434eb 590
Clemo 0:cb80470434eb 591 byte Hardware_Get_Ctrl_Shift(void)
Clemo 0:cb80470434eb 592 {
Clemo 0:cb80470434eb 593 return hard_curctrlbank;
Clemo 0:cb80470434eb 594 }
Clemo 0:cb80470434eb 595
Clemo 0:cb80470434eb 596
Clemo 0:cb80470434eb 597 //**************FUNCTION KNOB*******************
Clemo 0:cb80470434eb 598 //set current function
Clemo 0:cb80470434eb 599 void Hardware_Let_Function(byte newfunc)
Clemo 0:cb80470434eb 600 {
Clemo 0:cb80470434eb 601 if (newfunc!=hard_func)
Clemo 0:cb80470434eb 602 {
Clemo 0:cb80470434eb 603 //if new value is different to current
Clemo 0:cb80470434eb 604 hard_func = newfunc;
Clemo 0:cb80470434eb 605 display_invalidate();
Clemo 0:cb80470434eb 606 //Hardware_Refresh_FuncBG(); //refresh function dial LED array
Clemo 0:cb80470434eb 607 //Hardware_Refresh_ValBG(); //refresh value dial LED array (to show val of new func)
Clemo 0:cb80470434eb 608 // Hardware_Refresh_ShiftLED(hard_func); //refresh shift (red/green) mode (to show shift mode of new func)
Clemo 0:cb80470434eb 609 if (hard_shift[FUNC_AENVS]==true && hard_func==FUNC_WAVE)
Clemo 0:cb80470434eb 610 {
Clemo 0:cb80470434eb 611 //set max value of value dial (normally 15)
Clemo 0:cb80470434eb 612 maxval = 5;
Clemo 0:cb80470434eb 613 }
Clemo 0:cb80470434eb 614 else
Clemo 0:cb80470434eb 615 {
Clemo 0:cb80470434eb 616 maxval = 15;
Clemo 0:cb80470434eb 617 }
Clemo 0:cb80470434eb 618 }
Clemo 0:cb80470434eb 619 }
Clemo 0:cb80470434eb 620
Clemo 0:cb80470434eb 621
Clemo 0:cb80470434eb 622 byte Hardware_Get_Function()
Clemo 0:cb80470434eb 623 {
Clemo 0:cb80470434eb 624 //get current function
Clemo 0:cb80470434eb 625 return hard_func;
Clemo 0:cb80470434eb 626 }
Clemo 0:cb80470434eb 627
Clemo 0:cb80470434eb 628
Clemo 0:cb80470434eb 629 void Hardware_Refresh_FuncBG(void)
Clemo 0:cb80470434eb 630 {
Clemo 0:cb80470434eb 631 //user_interface_print_function(hard_func,hard_shift[hard_func]);
Clemo 0:cb80470434eb 632 display_invalidate();
Clemo 0:cb80470434eb 633 }
Clemo 0:cb80470434eb 634
Clemo 0:cb80470434eb 635
Clemo 0:cb80470434eb 636 //*************VALUE KNOB***********************
Clemo 0:cb80470434eb 637 //set new value of function
Clemo 0:cb80470434eb 638 void Hardware_Let_Value(byte func, byte newval)
Clemo 0:cb80470434eb 639 {
Clemo 0:cb80470434eb 640 if (newval!=hard_val[func])
Clemo 0:cb80470434eb 641 { //is new value different to current value
Clemo 0:cb80470434eb 642 hard_val[func] = newval;
Clemo 0:cb80470434eb 643 Hardware_Adjust_Value(func, hard_val[func]); //the meat of how the new value effects the sound
Clemo 0:cb80470434eb 644 if (func==hard_func)
Clemo 0:cb80470434eb 645 {
Clemo 0:cb80470434eb 646 Hardware_Refresh_ValBG(); //refresh the value dial LED array
Clemo 0:cb80470434eb 647 }
Clemo 0:cb80470434eb 648 }
Clemo 0:cb80470434eb 649 }
Clemo 0:cb80470434eb 650
Clemo 0:cb80470434eb 651
Clemo 0:cb80470434eb 652 void Hardware_Adjust_Value(byte func, byte val)
Clemo 0:cb80470434eb 653 { //the meat of how a new value effects the sound
Clemo 0:cb80470434eb 654 switch (func) {
Clemo 0:cb80470434eb 655 case FUNC_WAVE:
Clemo 0:cb80470434eb 656 if (hard_shift[FUNC_AENVS]==false){ //if not user wave mode
Clemo 0:cb80470434eb 657 Wave_Let_Table(val); //select waveform
Clemo 0:cb80470434eb 658 }
Clemo 0:cb80470434eb 659 break;
Clemo 0:cb80470434eb 660 case FUNC_FILT:
Clemo 0:cb80470434eb 661 Filt_Let_Type(val); //set filter type
Clemo 0:cb80470434eb 662 break;
Clemo 0:cb80470434eb 663 case FUNC_FENVA:
Clemo 0:cb80470434eb 664 Fenv_Let_A(envADR_store[val]); //set filter/pitch envelope attack time (stored in PROGMEM)
Clemo 0:cb80470434eb 665 break;
Clemo 0:cb80470434eb 666 case FUNC_FENVDR:
Clemo 0:cb80470434eb 667 Fenv_Let_DR(envADR_store[val]); //set filter/pitch envelope decay time
Clemo 0:cb80470434eb 668 break;
Clemo 0:cb80470434eb 669 case FUNC_FENVS:
Clemo 0:cb80470434eb 670 Fenv_Let_S(fenvS_store[val]); //set filter/pitch envelope sustain level
Clemo 0:cb80470434eb 671 break;
Clemo 0:cb80470434eb 672 case FUNC_AENVA:
Clemo 0:cb80470434eb 673 Aenv_Let_A(envADR_store[val]); //set amplitude envelope attack time
Clemo 0:cb80470434eb 674 break;
Clemo 0:cb80470434eb 675 case FUNC_AENVD:
Clemo 0:cb80470434eb 676 Aenv_Let_D(envADR_store[val]); //set amplitude envelope decay time
Clemo 0:cb80470434eb 677 break;
Clemo 0:cb80470434eb 678 case FUNC_AENVS:
Clemo 0:cb80470434eb 679 Aenv_Let_S(envS_store[val]); //set amplitude envelope sustain level
Clemo 0:cb80470434eb 680 break;
Clemo 0:cb80470434eb 681 case FUNC_AENVR:
Clemo 0:cb80470434eb 682 Aenv_Let_R(envADR_store[val]); //set amplitude envelope release time
Clemo 0:cb80470434eb 683 break;
Clemo 0:cb80470434eb 684 case FUNC_LFOTYPE:
Clemo 0:cb80470434eb 685 LFO_Let_Type(val); //select lfo waveform
Clemo 0:cb80470434eb 686 break;
Clemo 0:cb80470434eb 687 case FUNC_LFOSPEED:
Clemo 0:cb80470434eb 688 LFO_Let_Speed(speed_store[val]);//select lfo speed (stored in PROGMEM)
Clemo 0:cb80470434eb 689 break;
Clemo 0:cb80470434eb 690 #ifdef __HAS_ARPEGGIATOR__
Clemo 0:cb80470434eb 691 case FUNC_ARPTYPE: //select arpeggiator pattern
Clemo 0:cb80470434eb 692 Arp_Let_Type(val);
Clemo 0:cb80470434eb 693 if (val==0)
Clemo 0:cb80470434eb 694 {
Clemo 0:cb80470434eb 695 // Make sure that both LEDs are on when the arpeggiator is switched off.
Clemo 0:cb80470434eb 696 if (Hardware_Get_Ctrl_Shift()==GREEN)
Clemo 0:cb80470434eb 697 {
Clemo 0:cb80470434eb 698 Hardware_BicolorLED_SetState(1,1,2);
Clemo 0:cb80470434eb 699 Hardware_BicolorLED_SetState(2,1,2);
Clemo 0:cb80470434eb 700 }
Clemo 0:cb80470434eb 701 else
Clemo 0:cb80470434eb 702 {
Clemo 0:cb80470434eb 703 Hardware_BicolorLED_SetState(1,2,1);
Clemo 0:cb80470434eb 704 Hardware_BicolorLED_SetState(2,2,1);
Clemo 0:cb80470434eb 705 }
Clemo 0:cb80470434eb 706 }
Clemo 0:cb80470434eb 707 break;
Clemo 0:cb80470434eb 708 case FUNC_ARPSPEED:
Clemo 0:cb80470434eb 709 Arp_Let_Speed(speed_store[val]); //set arpeggiator speed when free running
Clemo 0:cb80470434eb 710 MIDI_Let_ClockArpSpeed(speed_store[val]); //set arpeggiator speed when MIDI clock synced
Clemo 0:cb80470434eb 711 break;
Clemo 0:cb80470434eb 712 #endif // __HAS_ARPEGGIATOR__
Clemo 0:cb80470434eb 713 case FUNC_PORTA:
Clemo 0:cb80470434eb 714 Pitch_Let_Porta(porta_store[val]); //set portamento time
Clemo 0:cb80470434eb 715 break;
Clemo 0:cb80470434eb 716 case FUNC_BITCRUSH:
Clemo 0:cb80470434eb 717 BitCrush_Let_Type(val); //set wave crusher setting
Clemo 0:cb80470434eb 718 break;
Clemo 0:cb80470434eb 719 case FUNC_MEM: //this is a hold function, so do nothing (patch save)
Clemo 0:cb80470434eb 720 break;
Clemo 0:cb80470434eb 721 }
Clemo 0:cb80470434eb 722 }
Clemo 0:cb80470434eb 723
Clemo 0:cb80470434eb 724
Clemo 0:cb80470434eb 725 void Hardware_Refresh_ValBG(void)
Clemo 0:cb80470434eb 726 {
Clemo 0:cb80470434eb 727 //user_interface_print_value(0,13,hard_val[hard_func],true);
Clemo 0:cb80470434eb 728 display_invalidate();
Clemo 0:cb80470434eb 729 }
Clemo 0:cb80470434eb 730
Clemo 0:cb80470434eb 731
Clemo 0:cb80470434eb 732 byte Hardware_Get_Value(byte func)
Clemo 0:cb80470434eb 733 {
Clemo 0:cb80470434eb 734 return hard_val[func];
Clemo 0:cb80470434eb 735 }
Clemo 0:cb80470434eb 736
Clemo 0:cb80470434eb 737
Clemo 0:cb80470434eb 738 void Hard_Let_Shift(byte func, boolean newshift)
Clemo 0:cb80470434eb 739 {
Clemo 0:cb80470434eb 740 if (newshift!=hard_shift[func])
Clemo 0:cb80470434eb 741 {
Clemo 0:cb80470434eb 742 switch (func)
Clemo 0:cb80470434eb 743 {
Clemo 0:cb80470434eb 744 // Tie filter/pitch envelope shifts together (envelope invert mode).
Clemo 0:cb80470434eb 745 case FUNC_FENVA:
Clemo 0:cb80470434eb 746 case FUNC_FENVDR:
Clemo 0:cb80470434eb 747 case FUNC_FENVS:
Clemo 0:cb80470434eb 748 hard_shift[FUNC_FENVA] = newshift;
Clemo 0:cb80470434eb 749 hard_shift[FUNC_FENVDR] = newshift;
Clemo 0:cb80470434eb 750 hard_shift[FUNC_FENVS] = newshift;
Clemo 0:cb80470434eb 751 break;
Clemo 0:cb80470434eb 752
Clemo 0:cb80470434eb 753 // Tie LFO shifts together (LFO invert mode).
Clemo 0:cb80470434eb 754 case FUNC_LFOTYPE:
Clemo 0:cb80470434eb 755 case FUNC_LFOSPEED:
Clemo 0:cb80470434eb 756 hard_shift[FUNC_LFOTYPE] = newshift;
Clemo 0:cb80470434eb 757 hard_shift[FUNC_LFOSPEED] = newshift;
Clemo 0:cb80470434eb 758 break;
Clemo 0:cb80470434eb 759
Clemo 0:cb80470434eb 760 #ifdef __HAS_ARPEGGIATOR__
Clemo 0:cb80470434eb 761 // Tie arpeggiator shifts together (arpeggiator ping pong mode).
Clemo 0:cb80470434eb 762 case FUNC_ARPTYPE:
Clemo 0:cb80470434eb 763 case FUNC_ARPSPEED:
Clemo 0:cb80470434eb 764 hard_shift[FUNC_ARPTYPE] = newshift;
Clemo 0:cb80470434eb 765 hard_shift[FUNC_ARPSPEED] = newshift;
Clemo 0:cb80470434eb 766 break;
Clemo 0:cb80470434eb 767 #endif // __HAS_ARPEGGIATOR__
Clemo 0:cb80470434eb 768
Clemo 0:cb80470434eb 769 default:
Clemo 0:cb80470434eb 770 hard_shift[func] = newshift;
Clemo 0:cb80470434eb 771 }
Clemo 0:cb80470434eb 772 // Meat of how shift affects sound.
Clemo 0:cb80470434eb 773 Hardware_Adjust_Shift(func, newshift);
Clemo 0:cb80470434eb 774 if (func==hard_func)
Clemo 0:cb80470434eb 775 {
Clemo 0:cb80470434eb 776 // Hardware_Refresh_ShiftLED(func); //refresh function knob LED colour
Clemo 0:cb80470434eb 777 Hardware_Refresh_FuncBG();
Clemo 0:cb80470434eb 778 }
Clemo 0:cb80470434eb 779 // Update display.
Clemo 0:cb80470434eb 780 display_invalidate();
Clemo 0:cb80470434eb 781 }
Clemo 0:cb80470434eb 782 }
Clemo 0:cb80470434eb 783
Clemo 0:cb80470434eb 784
Clemo 0:cb80470434eb 785 boolean Hard_Get_Shift(byte func)
Clemo 0:cb80470434eb 786 {
Clemo 0:cb80470434eb 787 return hard_shift[func];
Clemo 0:cb80470434eb 788 }
Clemo 0:cb80470434eb 789
Clemo 0:cb80470434eb 790
Clemo 0:cb80470434eb 791 // Meat of how shift affects sound.
Clemo 0:cb80470434eb 792 void Hardware_Adjust_Shift(byte func, boolean val)
Clemo 0:cb80470434eb 793 {
Clemo 0:cb80470434eb 794 //byte i;
Clemo 0:cb80470434eb 795 switch (func)
Clemo 0:cb80470434eb 796 {
Clemo 0:cb80470434eb 797 case FUNC_WAVE:
Clemo 0:cb80470434eb 798 if (hard_shift[FUNC_AENVS]==false)
Clemo 0:cb80470434eb 799 {
Clemo 0:cb80470434eb 800 if (val==true)
Clemo 0:cb80470434eb 801 {
Clemo 0:cb80470434eb 802 Wave_Let_Bank(1); //set waveform bank
Clemo 0:cb80470434eb 803 }
Clemo 0:cb80470434eb 804 else
Clemo 0:cb80470434eb 805 {
Clemo 0:cb80470434eb 806 Wave_Let_Bank(0);
Clemo 0:cb80470434eb 807 }
Clemo 0:cb80470434eb 808 }
Clemo 0:cb80470434eb 809 break;
Clemo 0:cb80470434eb 810
Clemo 0:cb80470434eb 811 case FUNC_FILT:
Clemo 0:cb80470434eb 812 Filt_Let_GainAdj(val); //set filter normalise mode
Clemo 0:cb80470434eb 813 break;
Clemo 0:cb80470434eb 814
Clemo 0:cb80470434eb 815 case FUNC_FENVA:
Clemo 0:cb80470434eb 816 case FUNC_FENVDR:
Clemo 0:cb80470434eb 817 case FUNC_FENVS:
Clemo 0:cb80470434eb 818 Fenv_Let_Invert(!Fenv_Get_Invert()); //set filter/pitch envelope invert mode
Clemo 0:cb80470434eb 819 break;
Clemo 0:cb80470434eb 820
Clemo 0:cb80470434eb 821 case FUNC_AENVA: //hold function, so do nothing here (SEE Hardware_Poll)
Clemo 0:cb80470434eb 822 break;
Clemo 0:cb80470434eb 823
Clemo 0:cb80470434eb 824 case FUNC_AENVD:
Clemo 0:cb80470434eb 825 MIDI_Let_SYSEXRead(val); //set sysex read mode
Clemo 0:cb80470434eb 826 break;
Clemo 0:cb80470434eb 827
Clemo 0:cb80470434eb 828 case FUNC_AENVS:
Clemo 0:cb80470434eb 829 Wave_Let_UserMode(val); //set user wave mode
Clemo 0:cb80470434eb 830 if (val==true && hard_val[FUNC_WAVE]>5)
Clemo 0:cb80470434eb 831 {
Clemo 0:cb80470434eb 832 Hardware_Let_Value(FUNC_WAVE,5);
Clemo 0:cb80470434eb 833 }
Clemo 0:cb80470434eb 834 break;
Clemo 0:cb80470434eb 835
Clemo 0:cb80470434eb 836 case FUNC_AENVR: //hold function, so do nothing here (SEE Hardware_Poll)
Clemo 0:cb80470434eb 837 break;
Clemo 0:cb80470434eb 838
Clemo 0:cb80470434eb 839 case FUNC_LFOTYPE:
Clemo 0:cb80470434eb 840 case FUNC_LFOSPEED:
Clemo 0:cb80470434eb 841 LFO_Let_Invert(val); //set LFO invert mode
Clemo 0:cb80470434eb 842 break;
Clemo 0:cb80470434eb 843
Clemo 0:cb80470434eb 844 #ifdef __HAS_ARPEGGIATOR__
Clemo 0:cb80470434eb 845 case FUNC_ARPTYPE:
Clemo 0:cb80470434eb 846 case FUNC_ARPSPEED:
Clemo 0:cb80470434eb 847 Arp_Let_PingPong(val); //set arpeggiator ping pong mode
Clemo 0:cb80470434eb 848 break;
Clemo 0:cb80470434eb 849 #endif // __HAS_ARPEGGIATOR__
Clemo 0:cb80470434eb 850
Clemo 0:cb80470434eb 851 case FUNC_PORTA:
Clemo 0:cb80470434eb 852 Pitch_Let_PropPorta(val); //set proportional portamento mode
Clemo 0:cb80470434eb 853 break;
Clemo 0:cb80470434eb 854
Clemo 0:cb80470434eb 855 case FUNC_BITCRUSH:
Clemo 0:cb80470434eb 856 BitCrush_Let_PreFilt(val); //set wave crusher pre-filter mode
Clemo 0:cb80470434eb 857
Clemo 0:cb80470434eb 858 // CPV: no break???
Clemo 0:cb80470434eb 859
Clemo 0:cb80470434eb 860 case FUNC_MEM: //hold function, so do nothing here (SEE Hardware_Poll)
Clemo 0:cb80470434eb 861 break;
Clemo 0:cb80470434eb 862 }
Clemo 0:cb80470434eb 863 }
Clemo 0:cb80470434eb 864
Clemo 0:cb80470434eb 865
Clemo 0:cb80470434eb 866 //*************CTRL BANK BUTTON***********************
Clemo 0:cb80470434eb 867 //set ctrl bank (red/green mode)
Clemo 0:cb80470434eb 868 void Hardware_Let_CtrlBank(byte value)
Clemo 0:cb80470434eb 869 {
Clemo 0:cb80470434eb 870 hard_curctrlbank = value;
Clemo 0:cb80470434eb 871 //Hardware_Refresh_CtrlBankLED(); //refresh LED color
Clemo 0:cb80470434eb 872 Hardware_BicolorLED_SetState(1,hard_curctrlbank!=0?1:0,hard_curctrlbank==0?1:0);
Clemo 0:cb80470434eb 873 Hardware_BicolorLED_SetState(2,hard_curctrlbank!=0?1:0,hard_curctrlbank==0?1:0);
Clemo 0:cb80470434eb 874 /*if (hard_curctrlbank==0)
Clemo 0:cb80470434eb 875 {
Clemo 0:cb80470434eb 876 Hardware_BicolorLED_SetState(false,true);
Clemo 0:cb80470434eb 877 //Hardware_LED_SetState(2,false);
Clemo 0:cb80470434eb 878 //Hardware_LED_SetState(3,true);
Clemo 0:cb80470434eb 879 }
Clemo 0:cb80470434eb 880 else
Clemo 0:cb80470434eb 881 {
Clemo 0:cb80470434eb 882 Hardware_BicolorLED_SetState(true,false);
Clemo 0:cb80470434eb 883 //Hardware_LED_SetState(2,true);
Clemo 0:cb80470434eb 884 //Hardware_LED_SetState(3,false);
Clemo 0:cb80470434eb 885 }*/
Clemo 0:cb80470434eb 886 }
Clemo 0:cb80470434eb 887
Clemo 0:cb80470434eb 888
Clemo 0:cb80470434eb 889 void Hardware_LED_SetState(byte LEDnum, byte LEDstate)
Clemo 0:cb80470434eb 890 {
Clemo 0:cb80470434eb 891 if (LEDnum==BOARD_LED2_GREEN)
Clemo 0:cb80470434eb 892 {
Clemo 0:cb80470434eb 893 // Board_LED_Set(BOARD_LED2_GREEN,LEDstate==HIGH?BOARD_LED_ON:BOARD_LED_OFF);
Clemo 0:cb80470434eb 894 }
Clemo 0:cb80470434eb 895 else if (LEDnum==BOARD_LED2_RED)
Clemo 0:cb80470434eb 896 {
Clemo 0:cb80470434eb 897 // Board_LED_Set(BOARD_LED2_RED,LEDstate==HIGH?BOARD_LED_ON:BOARD_LED_OFF);
Clemo 0:cb80470434eb 898 }
Clemo 0:cb80470434eb 899 else if (LEDnum==BOARD_LED3)
Clemo 0:cb80470434eb 900 {
Clemo 0:cb80470434eb 901 // MIDI LED.
Clemo 0:cb80470434eb 902 Board_LED_Set(BOARD_LED3,LEDstate);
Clemo 0:cb80470434eb 903 }
Clemo 0:cb80470434eb 904 }
Clemo 0:cb80470434eb 905
Clemo 0:cb80470434eb 906
Clemo 0:cb80470434eb 907 void Hardware_BicolorLED_SetState(uint8_t led, uint8_t green, uint8_t red)
Clemo 0:cb80470434eb 908 {
Clemo 0:cb80470434eb 909 if (led==1)
Clemo 0:cb80470434eb 910 {
Clemo 0:cb80470434eb 911 if (green<2) Board_LED_Set(BOARD_LED1_GREEN,green==1?BOARD_LED_ON:BOARD_LED_OFF);
Clemo 0:cb80470434eb 912 if (red<2) Board_LED_Set(BOARD_LED1_RED,red==1?BOARD_LED_ON:BOARD_LED_OFF);
Clemo 0:cb80470434eb 913 }
Clemo 0:cb80470434eb 914 else if (led==2)
Clemo 0:cb80470434eb 915 {
Clemo 0:cb80470434eb 916 if (green<2) Board_LED_Set(BOARD_LED2_GREEN,green==1?BOARD_LED_ON:BOARD_LED_OFF);
Clemo 0:cb80470434eb 917 if (red<2) Board_LED_Set(BOARD_LED2_RED,red==1?BOARD_LED_ON:BOARD_LED_OFF);
Clemo 0:cb80470434eb 918 }
Clemo 0:cb80470434eb 919 }
Clemo 0:cb80470434eb 920
Clemo 0:cb80470434eb 921
Clemo 0:cb80470434eb 922 void Hardware_LED_StartFlash(byte LEDnum, byte FlashTimes)
Clemo 0:cb80470434eb 923 {
Clemo 0:cb80470434eb 924 //SysTick_LED_Flash(LEDnum==0?BOARD_LED1_GREEN:BOARD_LED1_RED,10);
Clemo 0:cb80470434eb 925 if (LEDnum==4)
Clemo 0:cb80470434eb 926 {
Clemo 0:cb80470434eb 927 SysTick_LED_Flash(BOARD_LED3,10);
Clemo 0:cb80470434eb 928 }
Clemo 0:cb80470434eb 929 }
Clemo 0:cb80470434eb 930
Clemo 0:cb80470434eb 931
Clemo 0:cb80470434eb 932 /*boolean IsFuncFill(byte func)
Clemo 0:cb80470434eb 933 {
Clemo 0:cb80470434eb 934 //returns true for functions where value dial fills up
Clemo 0:cb80470434eb 935 switch (func) {
Clemo 0:cb80470434eb 936 case FUNC_WAVE:
Clemo 0:cb80470434eb 937 case FUNC_FILT:
Clemo 0:cb80470434eb 938 case FUNC_LFOTYPE:
Clemo 0:cb80470434eb 939 case FUNC_LFOSPEED:
Clemo 0:cb80470434eb 940 case FUNC_ARPTYPE:
Clemo 0:cb80470434eb 941 case FUNC_ARPSPEED:
Clemo 0:cb80470434eb 942 case FUNC_BITCRUSH:
Clemo 0:cb80470434eb 943 case FUNC_MEM:
Clemo 0:cb80470434eb 944 return false;
Clemo 0:cb80470434eb 945 break;
Clemo 0:cb80470434eb 946 default:
Clemo 0:cb80470434eb 947 return true;
Clemo 0:cb80470434eb 948 }
Clemo 0:cb80470434eb 949 }*/
Clemo 0:cb80470434eb 950
Clemo 0:cb80470434eb 951
Clemo 0:cb80470434eb 952 boolean IsShiftHold(byte func)
Clemo 0:cb80470434eb 953 {
Clemo 0:cb80470434eb 954 //returns true for functions where encoder button should be held down
Clemo 0:cb80470434eb 955 switch (func) {
Clemo 0:cb80470434eb 956 case FUNC_WAVE:
Clemo 0:cb80470434eb 957 return hard_shift[FUNC_AENVS];
Clemo 0:cb80470434eb 958 //break;
Clemo 0:cb80470434eb 959 case FUNC_AENVA:
Clemo 0:cb80470434eb 960 case FUNC_AENVR:
Clemo 0:cb80470434eb 961 case FUNC_MEM:
Clemo 0:cb80470434eb 962 return true;
Clemo 0:cb80470434eb 963 //break;
Clemo 0:cb80470434eb 964 default:
Clemo 0:cb80470434eb 965 return false;
Clemo 0:cb80470434eb 966 }
Clemo 0:cb80470434eb 967 }
Clemo 0:cb80470434eb 968