Permalink
Jun 17, 2016
Jun 17, 2016
Jun 17, 2016
Apr 8, 2020
Jul 8, 2016
Sep 12, 2016
Jun 24, 2019
Sep 28, 2016
Oct 29, 2017
Feb 28, 2018
Jun 13, 2019
Apr 8, 2020
Jun 14, 2019
Jun 14, 2019
Jun 17, 2016
Jun 17, 2016
Jun 24, 2016
Jun 17, 2016
Jun 17, 2016
Jun 17, 2016
Jun 24, 2016
Jun 17, 2016
Jun 17, 2016
Jun 13, 2019
Jun 17, 2016
Dec 2, 2016
Sep 18, 2016
Jun 17, 2016
Apr 8, 2020
Jun 17, 2016
Jun 13, 2019
Jun 17, 2016
Jun 13, 2019
Jun 17, 2016
Apr 8, 2020
Apr 8, 2020
Jun 24, 2019
Jun 24, 2019
Mar 5, 2020
Jun 24, 2019
Jul 10, 2016
Sep 12, 2016
Apr 19, 2017
Jun 13, 2019
May 27, 2019
Jun 24, 2019
Mar 5, 2020
Jun 24, 2019
Jun 14, 2019
Jun 17, 2016
Mar 4, 2018
Feb 28, 2018
Apr 19, 2017
Mar 1, 2018
Sep 14, 2016
Sep 28, 2016
May 28, 2019
Sep 28, 2016
Jun 15, 2019
Apr 19, 2017
Sep 13, 2016
Sep 13, 2016
Apr 19, 2017
Sep 13, 2016
May 27, 2019
Jul 10, 2016
Jul 10, 2016
Jun 13, 2019
Jun 22, 2020
Jun 22, 2020
May 27, 2019
May 27, 2019
May 27, 2019
May 28, 2019
May 18, 2019
May 18, 2019
May 18, 2019
May 18, 2019
Sep 19, 2016
Sep 19, 2016
Apr 19, 2017
Apr 19, 2017
Sep 15, 2016
Jun 24, 2019
Jun 13, 2019
Jun 13, 2019
Apr 8, 2020
Feb 26, 2018
Jun 13, 2019
Jun 13, 2019
Feb 28, 2018
Mar 1, 2018
Jun 13, 2019
Mar 1, 2018
Mar 1, 2018
Jun 13, 2019
Mar 1, 2018
Jun 13, 2019
Mar 12, 2018
Jun 22, 2020
Dec 9, 2016
Dec 9, 2016
Dec 9, 2016
Dec 9, 2016
Mar 5, 2018
Mar 5, 2018
Mar 5, 2018
Mar 5, 2018
Mar 5, 2018
Mar 5, 2018
Mar 5, 2018
Mar 5, 2018
Mar 5, 2018
Mar 5, 2018
Mar 5, 2018
Mar 5, 2018
Mar 5, 2018
Dec 9, 2016
Oct 21, 2017
Oct 29, 2017
Oct 29, 2017
Jun 14, 2019
Nov 18, 2019
Jun 14, 2019
Jun 14, 2019
Dec 2, 2019
Jun 17, 2016
Jun 14, 2019
Jun 15, 2019
Jun 22, 2020
Jun 22, 2020
Jun 22, 2020
Jun 15, 2019
Jun 22, 2020
Jun 22, 2020
Jun 22, 2020
Apr 8, 2020
Jun 17, 2016
Apr 19, 2017
Sep 13, 2016
Jun 17, 2016
Sep 13, 2016
Jun 17, 2016
Sep 13, 2016
Apr 19, 2017
Sep 14, 2016
Jun 15, 2019
Jun 15, 2019
Sep 14, 2016
Jun 17, 2019
Jun 17, 2019
Sep 14, 2016
Sep 28, 2016
Jun 22, 2019
Sep 28, 2016
Sep 28, 2016
Jun 24, 2019
Jun 24, 2019
Jun 29, 2019
Jun 29, 2019
Sep 13, 2016
Oct 29, 2017
Mar 12, 2018
Mar 13, 2018
Sep 13, 2016
Sep 28, 2016
Jun 13, 2019
Jun 17, 2019
Sep 13, 2016
Jun 22, 2020
Jun 22, 2020
Sep 14, 2016
Sep 28, 2016
Jun 13, 2019
Sep 14, 2016
Jun 17, 2019
Sep 14, 2016
Jun 22, 2020
Sep 14, 2016
Sep 28, 2016
Sep 28, 2016
Sep 14, 2016
Sep 14, 2016
Sep 28, 2016
Sep 28, 2016
Jun 22, 2020
Jun 22, 2020
Feb 28, 2018
Jun 22, 2019
Feb 28, 2018
Jun 22, 2019
Feb 28, 2018
Feb 28, 2018
Mar 12, 2018
Mar 12, 2018
Mar 12, 2018
Mar 13, 2018
Mar 13, 2018
Mar 13, 2018
Mar 13, 2018
Jun 22, 2020
Apr 19, 2017
Apr 19, 2017
Jun 22, 2020
Jun 17, 2016
Apr 19, 2017
Jun 22, 2020
Jun 22, 2020
Jun 22, 2020
Sep 14, 2016
Jun 22, 2020
Jun 22, 2020
Jun 22, 2020
Jun 22, 2020
Sep 28, 2016
Sep 28, 2016
Dec 9, 2016
Jun 24, 2016
Jun 17, 2016
Sep 14, 2016
Dec 2, 2016
Jun 24, 2019
Sep 14, 2016
Jun 17, 2016
Sep 14, 2016
Sep 14, 2016
Sep 13, 2016
Jun 22, 2020
Mar 4, 2018
Mar 4, 2018
Aug 11, 2019
Jun 22, 2020
Aug 11, 2019
Jun 22, 2020
Jun 22, 2020
Jun 22, 2020
Mar 12, 2018
Jun 22, 2020
Aug 11, 2019
Jun 22, 2020
Jun 22, 2020
Aug 11, 2019
Jun 22, 2020
Jun 22, 2020
Aug 11, 2019
Jun 22, 2020
Jun 22, 2020
Jun 22, 2020
Jun 22, 2020
Aug 11, 2019
Jun 22, 2020
Aug 11, 2019
Jun 22, 2020
Aug 11, 2019
Jun 22, 2020
Jun 22, 2020
Jun 22, 2020
Jun 22, 2020
Jun 22, 2020
Aug 11, 2019
Jun 22, 2020
Jun 22, 2020
Mar 4, 2018
Mar 4, 2018
Jun 22, 2020
Jun 17, 2019
Mar 4, 2018
Jun 17, 2019
Mar 4, 2018
Mar 4, 2018
Jun 22, 2020
Mar 4, 2018
Sep 14, 2016
Jun 22, 2019
Sep 28, 2016
Sep 12, 2016
Jul 8, 2016
Jul 6, 2016
Sep 12, 2016
Jul 6, 2016
Sep 12, 2016
Sep 13, 2016
Jul 8, 2016
Sep 13, 2016
Sep 13, 2016
Jul 8, 2016
Jul 8, 2016
Jul 6, 2016
Jul 6, 2016
Jul 6, 2016
Jul 6, 2016
Jul 6, 2016
Jul 6, 2016
Jul 6, 2016
Jul 6, 2016
Apr 19, 2017
Sep 12, 2016
Jul 6, 2016
Jul 6, 2016
Sep 13, 2016
Sep 12, 2016
Mar 26, 2018
Mar 26, 2018
Sep 12, 2016
Sep 13, 2016
Dec 22, 2016
Dec 9, 2016
Dec 9, 2016
Oct 21, 2017
Jun 17, 2016
Apr 19, 2017
Jul 6, 2016
Jul 6, 2016
Jul 6, 2016
Jun 17, 2016
Sep 12, 2016
Sep 12, 2016
Jun 17, 2016
Sep 12, 2016
Sep 12, 2016
Jul 6, 2016
Jul 6, 2016
Jul 6, 2016
Jul 6, 2016
Jul 6, 2016
Jun 17, 2016
Jul 8, 2016
Jul 8, 2016
Dec 2, 2016
Jul 8, 2016
Jul 8, 2016
Sep 12, 2016
Jul 8, 2016
Sep 12, 2016
Jun 15, 2019
Sep 12, 2016
Sep 12, 2016
Jul 8, 2016
Jul 8, 2016
Jul 8, 2016
Jul 8, 2016
Jul 8, 2016
Jul 8, 2016
Jun 17, 2016
Jul 8, 2016
Jun 13, 2019
Jun 13, 2019
Jun 13, 2019
Jun 13, 2019
Apr 8, 2020
Jun 13, 2019
Newer
100644
5570 lines (4998 sloc)
133 KB
3
#include "print_funcs.h"
6
7
#include "monome.h"
15
16
#include "main.h"
17
#include "ansible_grid.h"
18
33
static void preset_mode_exit(void);
34
35
bool follower_select;
36
bool mod_follower;
37
uint8_t follower;
38
bool kriaAltModeBlink; // flag gets flipped for the blinking
44
u8 key_times[128];
45
46
bool clock_external;
47
bool view_clock;
48
bool view_config;
51
uint32_t clock_period;
52
uint8_t clock_count;
53
uint8_t clock_mul;
54
uint8_t ext_clock_count;
55
uint8_t ext_clock_phase;
63
uint8_t tuning_track;
64
uint8_t tuning_octave;
65
int16_t tuning_octave_offset[4];
66
bool tuning_note_on[4];
67
89
} kria_modes_t;
90
91
typedef enum {
92
modNone, modLoop, modTime, modProb
93
} kria_mod_modes_t;
94
95
kria_modes_t k_mode;
96
kria_mod_modes_t k_mod_mode;
97
102
bool kria_blinks[4];
103
softTimer_t blinkTimer[4] = {
104
{ .next = NULL, .prev = NULL },
105
{ .next = NULL, .prev = NULL },
106
{ .next = NULL, .prev = NULL },
107
{ .next = NULL, .prev = NULL }
108
};
110
softTimer_t repeatTimer[4] = {
111
{ .next = NULL, .prev = NULL },
112
{ .next = NULL, .prev = NULL },
113
{ .next = NULL, .prev = NULL },
114
{ .next = NULL, .prev = NULL }
115
};
116
117
static void grid_keytimer_kria(uint8_t held_key);
118
static void kria_set_note(uint8_t trackNum);
119
static void preset_mode_handle_key(uint8_t x, uint8_t y, uint8_t z, uint8_t* glyph);
120
static kria_modes_t ii_kr_mode_for_cmd(uint8_t cmd);
121
static uint8_t ii_kr_cmd_for_mode(kria_modes_t mode);
122
134
grid_varibrightness = (f.state.grid_varibrightness == 1) ? 1 :
135
(f.state.grid_varibrightness == 4) ? 4 :
136
16;
137
138
140
case mGridKria:
142
app_event_handlers[kEventKey] = &handler_KriaKey;
143
app_event_handlers[kEventTr] = &handler_KriaTr;
144
app_event_handlers[kEventTrNormal] = &handler_KriaTrNormal;
145
app_event_handlers[kEventMonomeGridKey] = &handler_KriaGridKey;
146
app_event_handlers[kEventMonomeRefresh] = &handler_KriaRefresh;
153
break;
154
case mGridMP:
156
app_event_handlers[kEventKey] = &handler_MPKey;
157
app_event_handlers[kEventTr] = &handler_MPTr;
158
app_event_handlers[kEventTrNormal] = &handler_MPTrNormal;
159
app_event_handlers[kEventMonomeGridKey] = &handler_MPGridKey;
160
app_event_handlers[kEventMonomeRefresh] = &handler_MPRefresh;
167
break;
168
case mGridES:
169
// print_dbg("\r\n> mode grid es");
170
app_event_handlers[kEventKey] = &handler_ESKey;
171
app_event_handlers[kEventTr] = &handler_ESTr;
172
app_event_handlers[kEventTrNormal] = &handler_ESTrNormal;
173
app_event_handlers[kEventMonomeGridKey] = &handler_ESGridKey;
174
app_event_handlers[kEventMonomeRefresh] = &handler_ESRefresh;
175
clock = &clock_null;
176
clock_set(clock_period);
182
default:
183
break;
184
}
187
// app_event_handlers[kEventFrontShort] = &handler_GridFrontShort;
188
// app_event_handlers[kEventFrontLong] = &handler_GridFrontLong;
191
flashc_memset32((void*)&(f.state.none_mode), ansible_mode, 4, true);
192
flashc_memset32((void*)&(f.state.grid_mode), ansible_mode, 4, true);
193
}
194
195
static void preset_mode_exit(void) {
196
// print_dbg("\r\n> PRESET EXIT");
197
preset_mode = false;
198
flashc_memcpy((void*)f.state.followers, followers, sizeof(followers), true);
199
}
200
201
void handler_GridFrontShort(s32 data) {
205
switch (ansible_mode) {
206
case mGridKria:
207
grid_refresh = &refresh_kria;
208
break;
209
case mGridMP:
210
grid_refresh = &refresh_mp;
211
break;
212
case mGridES:
213
grid_refresh = &refresh_es;
214
break;
215
default:
216
break;
217
}
218
232
}
233
234
void handler_GridFrontLong(s32 data) {
235
switch (ansible_mode) {
236
case mGridKria:
237
set_mode(mGridMP);
238
break;
239
case mGridMP:
240
set_mode(mGridES);
241
break;
242
case mGridES:
243
set_mode(mGridKria);
244
break;
245
default:
246
break;
247
}
248
monomeFrameDirty++;
250
260
if (follower_select) {
261
for (uint8_t i = 0; i < 4; i++) {
262
monomeLedBuffer[R7 + i] = (followers[follower].track_en & (1 << i)) ? L1 : L0;
263
}
264
}
265
for (uint8_t i = 0; i < I2C_FOLLOWER_COUNT; i++) {
266
if (follower_select) {
267
monomeLedBuffer[5 + (2 + i)*16] = i == follower ? L1 : L0;
268
}
269
else {
270
monomeLedBuffer[5 + (2 + i)*16] = followers[i].active ? L1 : L0;
271
}
272
}
273
monomeLedBuffer[5 + R7] = mod_follower ? L1 : L0;
275
if (follower_select) {
276
memset(monomeLedBuffer, L0, 7);
277
monomeLedBuffer[followers[follower].oct + 3] = L1;
278
279
if (followers[follower].mode_ct > 1) {
280
memset(monomeLedBuffer + 13, L0, followers[follower].mode_ct);
281
monomeLedBuffer[13 + followers[follower].active_mode] = L1;
282
}
283
}
284
else {
285
switch(ansible_mode) {
286
case mGridMP:
287
for(i1=0;i1<8;i1++)
288
for(i2=0;i2<8;i2++)
289
if(m.glyph[i1] & (1<<i2))
290
monomeLedBuffer[i1*16+i2+8] = 9;
291
break;
292
case mGridKria:
293
for(i1=0;i1<8;i1++)
294
for(i2=0;i2<8;i2++)
295
if(k.glyph[i1] & (1<<i2))
296
monomeLedBuffer[i1*16+i2+8] = 9;
297
break;
298
case mGridES:
299
for(i1=0;i1<8;i1++)
300
for(i2=0;i2<8;i2++)
301
if(e.glyph[i1] & (1<<i2))
302
monomeLedBuffer[i1*16+i2+8] = 9;
303
break;
304
default: break;
305
}
312
void refresh_grid_tuning(void) {
313
memset(monomeLedBuffer,0,128);
314
315
for (uint8_t i = 0; i < 4; i++) {
316
monomeLedBuffer[i*16] = tuning_note_on[i] ? L1 : L0;
317
318
memset(monomeLedBuffer + i*16 + 2, L0, 12);
319
monomeLedBuffer[(int)i*16 + 2 + tuning_octave_offset[i]] += 4;
320
if (i == tuning_track) {
321
monomeLedBuffer[i*16 + 2 + tuning_octave_offset[tuning_track]] += 4;
322
}
323
}
324
327
memset(monomeLedBuffer + R5, L0, 10);
328
monomeLedBuffer[R5 + tuning_octave] = L1;
329
monomeLedBuffer[R5 + 11] = L1; // reload / longpress to restore factory default
330
monomeLedBuffer[R5 + 13] = L1; // save offsets key
331
monomeLedBuffer[R5 + 14] = L1; // save interpolated key
332
monomeLedBuffer[R5 + 15] = L1; // save as-is key
333
334
// lit key indicating position
335
uint8_t tuning_slot = (int)(tuning_octave * 12) + tuning_octave_offset[tuning_track];
336
uint8_t dac_step = tuning_table[tuning_track][tuning_slot] >> 6;
337
memset(monomeLedBuffer + R6, 3, dac_step / 16);
338
monomeLedBuffer[R6 + dac_step / 16] = dac_step % 16;
339
340
// tuning steps either direction
341
for (uint8_t i = 0; i < 8; i++) {
342
if ((DAC_10V) - tuning_table[tuning_track][tuning_slot] > (1 << i)) {
343
monomeLedBuffer[R7 + 8 + i] = 2*i + 1;
344
}
345
if (tuning_table[tuning_track][tuning_slot] > (1 << i)) {
346
monomeLedBuffer[R7 + 7 - i] = 2*i + 1;
347
}
348
}
349
}
350
351
static void restore_grid_tuning(void) {
352
tuning_octave = 0;
353
tuning_track = 0;
354
for (uint8_t i = 0; i < 4; i++) {
355
tuning_note_on[i] = true;
356
tuning_octave_offset[i] = 0;
357
dac_set_value_noslew(
358
i,
359
tuning_table[i][
360
(int)(tuning_octave * 12) +
361
tuning_octave_offset[i]
362
]);
363
set_tr(TR1 + i);
364
}
365
}
366
367
void grid_keytimer(void) {
368
for(uint8_t i1=0;i1<key_count;i1++) {
369
if(key_times[held_keys[i1]])
370
if(--key_times[held_keys[i1]]==0) {
383
flashc_memset8((void*)&(f.mp_state.sound), sound, 1, true);
384
flashc_memset8((void*)&(f.mp_state.voice_mode), voice_mode, 1, true);
395
flashc_memset8((void*)&(f.kria_state.cue_div), cue_div, 1, true);
396
flashc_memset8((void*)&(f.kria_state.cue_steps), cue_steps, 1, true);
397
flashc_memset8((void*)&(f.kria_state.meta), meta, 1, true);
404
break;
405
406
case mGridES:
407
flashc_memset8((void*)&(f.es_state.preset), preset, 1, true);
408
flashc_memcpy((void *)&f.es_state.e[preset], &e, sizeof(e), true);
420
flashc_memset32((void*)&(f.kria_state.sync_mode), kria_sync_mode, sizeof(kria_sync_mode), true);
432
// reload factory default, don't immediately save it
433
for (uint8_t i = 0; i < 4; i++) {
434
for (uint8_t j = 0; j < 120; j ++) {
435
tuning_table[i][j] = ET[j] << 2;
436
}
437
}
438
restore_grid_tuning();
439
}
440
if (x == 13) {
441
// apply fixed offset and save
442
fit_tuning(0);
443
flashc_memcpy((void*)f.tuning_table, tuning_table, sizeof(tuning_table), true);
444
restore_grid_tuning();
445
}
449
flashc_memcpy((void*)f.tuning_table, tuning_table, sizeof(tuning_table), true);
450
restore_grid_tuning();
451
}
452
if (x == 15) {
453
// save all tuning entries as-is
454
flashc_memcpy((void *)f.tuning_table, tuning_table, sizeof(tuning_table), true);
455
restore_grid_tuning();
456
}
457
}
458
}
459
466
void ii_grid(uint8_t* d, uint8_t len) {
467
// print_dbg("\r\nii/grid (");
468
// print_dbg_ulong(len);
469
// print_dbg(") ");
470
// for(int i=0;i<len;i++) {
471
// print_dbg_ulong(d[i]);
472
// print_dbg(" ");
473
// }
474
475
if (len < 1) {
476
return;
477
}
478
479
switch (d[0]) {
480
case II_GRID_KEY:
481
if ( !preset_mode
482
&& len >= 4
483
&& d[1] < 16
484
&& d[2] < 8
485
&& d[3] < 16 ) {
486
event_t e;
487
uint8_t* data = (uint8_t*)(&(e.data));
488
e.type = kEventMonomeGridKey;
489
data[0] = d[1];
490
data[1] = d[2];
491
data[2] = d[3];
492
event_post(&e);
493
}
494
break;
495
case II_GRID_KEY + II_GET: {
496
uint8_t z = 0;
497
if ( len >= 2
498
&& d[1] < 16
499
&& d[2] < 8 ) {
500
for (uint8_t i = 0; i < key_count; i++) {
501
if (held_keys[i] % 16 == d[1]
502
&& held_keys[i] / 16 == d[2]) {
503
z = 1;
504
break;
505
}
506
}
507
}
508
ii_tx_queue(z);
509
break;
510
}
511
case II_GRID_LED + II_GET: {
512
uint8_t led = 0;
513
if ( len >= 3
514
&& d[1] < 16
515
&& d[2] < 8 ) {
516
led = monomeLedBuffer[d[2] * 16 + d[1]];
517
}
518
ii_tx_queue(led);
519
break;
520
}
521
default:
522
break;
523
}
524
}
528
553
u8 activeRpt[4]; // needed for cases when triggers have a longer clock division than repeats (for viz)
554
u16 rptTicks[4]; // holds the length of a repeat
555
u8 repeats[4]; // gets decremented each repeat
556
563
uint8_t meta_pos;
564
uint8_t meta_count;
565
uint8_t meta_next;
566
uint8_t meta_edit;
570
static void kria_off(void* o);
571
static void kria_blink_off(void* o);
572
static void kria_rpt_off(void* o);
581
static void adjust_loop_start(u8 t, u8 x, u8 m);
582
static void adjust_loop_end(u8 t, u8 x, u8 m);
584
static void update_loop_start(u8 t, u8 x, u8 m);
585
static void update_loop_end(u8 t, u8 x, u8 m);
598
flashc_memset32((void*)&(f.kria_state.sync_mode), krSyncNone, sizeof(kria_sync_mode_t), true);
600
flashc_memset8((void*)&(f.kria_state.note_sync), true, 1, true);
601
flashc_memset8((void*)&(f.kria_state.loop_sync), 2, 1, true);
602
flashc_memset8((void*)&(f.kria_state.note_div_sync), false, 1, true);
603
flashc_memset8((void*)&(f.kria_state.div_sync), 0, 1, true);
604
flashc_memset8((void*)&(f.kria_state.cue_div), 0, 1, true);
605
flashc_memset8((void*)&(f.kria_state.cue_steps), 3, 1, true);
606
flashc_memset8((void*)&(f.kria_state.meta), 0, 1, true);
607
608
for(i1=0;i1<8;i1++)
609
k.glyph[i1] = 0;
610
611
memset(k.p[0].t[0].tr, 0, 16);
612
memset(k.p[0].t[0].oct, 0, 16);
613
memset(k.p[0].t[0].note, 0, 16);
624
memset(k.p[0].t[0].lstart, 0, KRIA_NUM_PARAMS);
625
memset(k.p[0].t[0].lend, 5, KRIA_NUM_PARAMS);
626
memset(k.p[0].t[0].llen, 6, KRIA_NUM_PARAMS);
627
memset(k.p[0].t[0].lswap, 0, KRIA_NUM_PARAMS);
628
memset(k.p[0].t[0].tmul, 1, KRIA_NUM_PARAMS);
629
630
k.p[0].t[1] = k.p[0].t[0];
631
k.p[0].t[2] = k.p[0].t[0];
632
k.p[0].t[3] = k.p[0].t[0];
633
k.p[0].scale = 0;
634
635
for(i1=1;i1<KRIA_NUM_PATTERNS;i1++)
636
k.p[i1] = k.p[0];
637
638
k.pattern = 0;
641
k.meta_start = 0;
642
k.meta_end = 3;
643
k.meta_len = 4;
644
k.meta_lswap = 0;
645
646
memset(k.meta_pat, 0, 64);
647
memset(k.meta_steps, 7, 64);
648
649
for(i1=0;i1<GRID_PRESETS;i1++)
650
flashc_memcpy((void *)&f.kria_state.k[i1], &k, sizeof(k), true);
681
for (int j=0;j<KRIA_NUM_PARAMS;j++) {
682
tmul[i][j] = f.kria_state.k[preset].p[k.pattern].t[i].tmul[j];
683
}
685
}
686
687
void resume_kria() {
688
grid_refresh = &refresh_kria;
689
view_clock = false;
690
view_config = false;
691
696
// re-check clock jack
697
clock_external = !gpio_get_pin_value(B10);
698
699
if(clock_external)
700
clock = &clock_null;
701
else
702
clock = &clock_kria;
713
void grid_keytimer_kria(uint8_t held_key) {
714
switch (k_mode) {
715
case mPattern:
716
if(held_key < 16) {
717
memcpy((void *)&k.p[held_key], &k.p[k.pattern], sizeof(k.p[k.pattern]));
718
k.pattern = held_key;
725
k.p[edit_pattern].t[track].rpt[held_key] -= 1;
726
k.p[edit_pattern].t[track].rptBits[held_key] = ~(0xff << k.p[edit_pattern].t[track].rpt[held_key]);
729
k.p[edit_pattern].t[track].rpt[held_key - R6] = 1;
730
k.p[edit_pattern].t[track].rptBits[held_key - R6] = 1;
746
switch (k.p[k.pattern].t[t].direction) {
747
case krDirForward:
748
if (pos[t][p] == k.p[k.pattern].t[t].lstart[p]) {
750
}
751
break;
752
case krDirReverse:
753
if (pos[t][p] == k.p[k.pattern].t[t].lend[p]) {
755
}
756
break;
757
case krDirTriangle:
758
if (pos[t][p] == k.p[k.pattern].t[t].lstart[p] || pos[t][p] == k.p[k.pattern].t[t].lend[p]) {
767
768
if (kria_sync_mode & krSyncTimeDiv) {
769
if (latch_input) {
770
tmul[t][p] = k.p[k.pattern].t[t].tmul[p];
771
}
772
}
773
else {
774
tmul[t][p] = k.p[k.pattern].t[t].tmul[p];
779
780
switch (k.p[k.pattern].t[t].direction) {
781
default:
782
case krDirForward: forward:
783
if(pos[t][p] == k.p[k.pattern].t[t].lend[p]) {
784
pos[t][p] = k.p[k.pattern].t[t].lstart[p];
785
}
786
else {
787
pos[t][p]++;
788
if(pos[t][p] > 15) {
789
pos[t][p] = 0;
790
}
791
}
792
break;
793
case krDirReverse: reverse:
794
if(pos[t][p] == k.p[k.pattern].t[t].lstart[p]) {
795
pos[t][p] = k.p[k.pattern].t[t].lend[p];
796
}
797
else {
798
pos[t][p]--;
800
pos[t][p] = 15;
801
}
802
}
803
break;
804
case krDirTriangle:
805
if (pos[t][p] == k.p[k.pattern].t[t].lend[p]) {
812
goto forward;
813
}
814
else {
815
goto reverse;
816
}
817
break;
818
case krDirDrunk:
825
case krDirRandom: {
826
uint8_t lstart = k.p[k.pattern].t[t].lstart[p];
827
uint8_t lend = k.p[k.pattern].t[t].lend[p];
828
uint8_t llen = k.p[k.pattern].t[t].llen[p];
829
830
if (lend >= lstart) {
840
switch(k.p[k.pattern].t[t].p[p][pos[t][p]]) {
841
case 0:
842
return false;
843
case 1:
847
// ~50%
848
return (rnd() & 0xff) > 128;
849
case 3:
850
return true;
851
default:
852
return true;
853
}
862
cue_sub_count++;
863
864
if(cue_sub_count >= cue_div + 1) {
865
cue_sub_count = 0;
866
cue_count++;
867
if(cue_count >= cue_steps + 1) {
868
cue_count = 0;
869
870
if(meta) {
871
meta_count++;
872
if(meta_count > k.meta_steps[meta_pos]) {
873
if(meta_next)
874
meta_pos = meta_next - 1;
875
else if(meta_pos == k.meta_end)
876
meta_pos = k.meta_start;
877
else
878
meta_pos++;
879
880
change_pattern(k.meta_pat[meta_pos]);
881
meta_next = 0;
882
meta_count = 0;
883
}
884
}
885
else if(cue_pat_next) {
897
pos[i1][i2] = k.p[k.pattern].t[i1].lend[i2];
898
pos_mul[i1][i2] = k.p[k.pattern].t[i1].tmul[i2];
919
static inline int sum_clip(int l, int r, int clip) {
920
return min(clip, max(0, l + r));
923
void clock_kria_note(kria_track* track, uint8_t trackNum) {
924
if(kria_next_step(trackNum, mDur)) {
925
f32 clock_scale = (clock_deltas[trackNum] * track->tmul[mTr]) / (f32)384.0;
926
f32 unscaled = (track->dur[pos[trackNum][mDur]]+1) * (track->dur_mul<<2);
927
dur[trackNum] = (u16)(unscaled * clock_scale);
932
}
933
if(kria_next_step(trackNum, mNote)) {
934
note[trackNum] = track->note[pos[trackNum][mNote]];
935
}
936
if(kria_next_step(trackNum, mAltNote)) {
937
alt_note[trackNum] = track->alt_note[pos[trackNum][mAltNote]];
938
}
939
if(kria_next_step(trackNum, mGlide)) {
940
glide[trackNum] = track->glide[pos[trackNum][mGlide]];
941
}
942
}
943
944
static void kria_set_note(uint8_t trackNum) {
945
u8 noteInScale = (note[trackNum] + alt_note[trackNum]) % 7; // combine both note params
946
u8 octaveBump = (note[trackNum] + alt_note[trackNum]) / 7; // if it wrapped around the octave, bump it
949
(int)cur_scale[noteInScale] +
950
scale_adj[noteInScale] +
951
(int)((oct[trackNum]+octaveBump) * 12));
955
u64 current_tick = get_ticks();
956
clock_deltas[trackNum] = (u32)(current_tick-last_ticks[trackNum]);
957
last_ticks[trackNum] = current_tick;
962
bool trNextStep = kria_next_step(trackNum, mTr);
963
bool isTrigger = track->tr[pos[trackNum][mTr]];
965
// if the track isn't in trigger_step mode, or if there is a trigger
966
// THEN we clock the other parameters
967
if (!k.p[k.pattern].t[trackNum].trigger_clocked) {
968
clock_kria_note(track, trackNum);
970
if(kria_next_step(trackNum, mRpt)) {
971
rpt[trackNum] = track->rpt[pos[trackNum][mRpt]];
982
repeats[trackNum] = rpt[trackNum] - 1;
983
timer_remove( &repeatTimer[trackNum] );
984
if ( repeats[trackNum] > 0 ) {
985
rptTicks[trackNum] = (clock_deltas[trackNum] * (u32)track->tmul[mTr] ) / rpt[trackNum];
986
timer_add( &repeatTimer[trackNum], rptTicks[trackNum], &kria_rpt_off, trackIndex );
989
if ( rptBits[trackNum] & 1 ) {
990
if (k.p[k.pattern].t[trackNum].trigger_clocked) {
991
clock_kria_note(track, trackNum);
992
}
993
kria_set_note(trackNum);
994
set_tr( TR1 + trackNum );
995
996
timer_remove( &auxTimer[trackNum]);
997
timer_add(&auxTimer[trackNum], ((u32)dur[trackNum]) / ((u32)rpt[trackNum]), &kria_off, trackIndex);
998
timer_remove( &blinkTimer[trackNum] );
999
timer_add( &blinkTimer[trackNum], max(dur[trackNum]/rpt[trackNum],31), &kria_blink_off, trackIndex );
1008
static void kria_off(void* o) {
1009
int index = *(u8*)o;
1010
timer_remove( &auxTimer[index] );
1011
clr_tr(TR1 + index);
1012
tr[index] = 0;
1015
static void kria_blink_off(void* o) {
1016
int index = *(u8*)o;
1017
timer_remove( &blinkTimer[index] );
1018
kria_blinks[index] = 0;
1024
uint8_t bit = activeRpt[index] - repeats[index];
1025
kria_track* track = &k.p[k.pattern].t[index];
1027
repeats[index]--;
1028
if ( repeats[index] <= 0 ) {
1029
timer_remove( &repeatTimer[index] );
1032
if ( track->rptBits[pos[index][mRpt]] & (1 << bit) ) {
1033
if (track->trigger_clocked) {
1034
clock_kria_note(track, index);
1035
}
1036
kria_set_note(index);
1037
set_tr( TR1 + index );
1038
tr[index] = 1;
1039
kria_blinks[index] = 1;
1040
1041
timer_remove( &auxTimer[index]);
1042
timer_add(&auxTimer[index], ((u32)dur[index]) / ((u32)rpt[index]), &kria_off, o);
1043
timer_remove( &blinkTimer[index] );
1044
timer_add( &blinkTimer[index], max(dur[index]/rpt[index],31), &kria_blink_off, o );
1045
monomeFrameDirty++;
1046
}
1049
static void kria_alt_mode_blink(void* o) {
1050
kriaAltModeBlink = !kriaAltModeBlink;
1054
static void kria_meta_lock_blink(void* o) {
1055
kriaMetaLockBlink = !kriaMetaLockBlink;
1056
monomeFrameDirty++;
1057
}
1058
1059
1068
// print_dbg("\r\nii/kria (");
1069
// print_dbg_ulong(l);
1070
// print_dbg(") ");
1071
// for(int i=0;i<l;i++) {
1072
// print_dbg_ulong(d[i]);
1073
// print_dbg(" ");
1074
// }
1075
1076
int n;
1078
1079
if(l) {
1080
switch(d[0]) {
1081
case II_KR_PRESET:
1082
if(d[1] > -1 && d[1] < 8) {
1083
preset = d[1];
1084
flashc_memset8((void*)&(f.kria_state.preset), preset, 1, true);
1085
init_kria();
1087
}
1088
break;
1089
case II_KR_PRESET + II_GET:
1090
ii_tx_queue(preset);
1091
break;
1092
case II_KR_PATTERN:
1093
if(d[1] > -1 && d[1] < 16) {
1095
}
1096
break;
1097
case II_KR_PATTERN + II_GET:
1098
ii_tx_queue(k.pattern);
1099
break;
1100
case II_KR_SCALE:
1101
if(d[1] > -1 && d[1] < 16) {
1102
k.p[k.pattern].scale = d[1];
1103
calc_scale(k.p[k.pattern].scale);
1104
}
1105
break;
1106
case II_KR_SCALE + II_GET:
1107
ii_tx_queue(k.p[k.pattern].scale);
1108
break;
1109
case II_KR_PERIOD:
1110
n = (d[1] << 8) + d[2];
1111
if(n > 19) {
1112
clock_period = n;
1113
time_rough = (clock_period - 20) / 16;
1114
time_fine = (clock_period - 20) % 16;
1115
clock_set(clock_period);
1116
}
1117
break;
1118
case II_KR_PERIOD + II_GET:
1119
ii_tx_queue(clock_period >> 8);
1120
ii_tx_queue(clock_period & 0xff);
1121
break;
1122
case II_KR_RESET:
1127
for ( int i=0; i<KRIA_NUM_TRACKS; i++ ) {
1128
for ( int j=0; j<KRIA_NUM_PARAMS; j++ ) {
1129
pos[i][j] = k.p[k.pattern].t[i].lend[j];
1130
pos_mul[i][j] = k.p[k.pattern].t[i].tmul[j];
1131
}
1135
if(track == 0) {
1136
for ( int i=0; i<KRIA_NUM_TRACKS; i++ ) {
1137
for ( int j=0; j<KRIA_NUM_PARAMS; j++ ) {
1138
pos[i][j] = k.p[k.pattern].t[i].lend[j];
1139
pos_mul[i][j] = k.p[k.pattern].t[i].tmul[j];
1140
}
1143
else if( track <= KRIA_NUM_TRACKS ) {
1144
for( int i=0; i<KRIA_NUM_PARAMS; i++ ) {
1145
pos[track-1][i] = k.p[k.pattern].t[track-1].lend[i];
1146
pos_mul[track-1][i] = k.p[k.pattern].t[track-1].tmul[i];
1151
if( track == 0 && param == 0 ) {
1152
for ( int i=0; i<KRIA_NUM_TRACKS; i++ ) {
1153
for ( int j=0; j<KRIA_NUM_PARAMS; j++ ) {
1154
pos[i][j] = k.p[k.pattern].t[i].lend[j];
1155
pos_mul[i][j] = k.p[k.pattern].t[i].tmul[j];
1156
}
1159
else if( track == 0 && param <= KRIA_NUM_PARAMS ) {
1160
for ( int i=0; i<KRIA_NUM_TRACKS; i++ ) {
1161
pos[i][param-1] = k.p[k.pattern].t[i].lend[param-1];
1162
pos_mul[i][param-1] = k.p[k.pattern].t[i].tmul[param-1];
1165
else if( param == 0 && track <= KRIA_NUM_TRACKS ) {
1166
for ( int i=0; i<KRIA_NUM_PARAMS; i++ ) {
1167
pos[track-1][i] = k.p[k.pattern].t[track-1].lend[i];
1168
pos_mul[track-1][i] = k.p[k.pattern].t[track-1].tmul[i];
1171
else if(track <= KRIA_NUM_TRACKS && param <= KRIA_NUM_PARAMS) {
1172
pos[track-1][param-1] = k.p[k.pattern].t[track-1].lend[param-1];
1173
pos_mul[track-1][param-1] = k.p[k.pattern].t[track-1].tmul[param-1];
1185
switch(loop_sync) {
1186
case 2:
1187
for(int i=0;i<4;i++)
1188
for(int j=0;j<4;j++)
1189
adjust_loop_start(i, loopStart, j);
1190
break;
1191
case 1:
1192
if(d[1] == 0) {
1193
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1194
for(int j=0;j<KRIA_NUM_PARAMS;j++)
1195
adjust_loop_start(i, loopStart, j);
1196
}
1197
else if( track <= KRIA_NUM_TRACKS ) {
1198
for(int i=0;i<KRIA_NUM_PARAMS;i++)
1199
adjust_loop_start(track-1, loopStart, i);
1200
}
1201
break;
1202
case 0:
1203
if(track == 0 && param == 0) {
1204
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1205
for(int j=0;j<KRIA_NUM_PARAMS;j++)
1206
adjust_loop_start(i, loopStart, j);
1207
}
1208
else if(track == 0 && param <= KRIA_NUM_PARAMS) {
1209
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1210
adjust_loop_start(i, loopStart, param-1);
1211
}
1212
else if(param == 0 && track <= KRIA_NUM_TRACKS) {
1213
for(int i=0;i<KRIA_NUM_PARAMS;i++)
1214
adjust_loop_start(track-1, loopStart, i);
1215
}
1216
else if(track <= KRIA_NUM_TRACKS && param <= KRIA_NUM_PARAMS) {
1217
adjust_loop_start(track-1, loopStart, param-1);
1218
}
1219
break;
1220
default:
1221
break;
1230
for(int i=0; i<KRIA_NUM_TRACKS; i++)
1231
for(int j=0;j<KRIA_NUM_PARAMS;j++)
1232
n += k.p[k.pattern].t[i].lstart[j];
1237
for(int i=0; i<KRIA_NUM_TRACKS; i++)
1238
n += k.p[k.pattern].t[i].lstart[param-1];
1252
if(d[3] < 17 && d[3] > 0) {
1253
1254
track = d[1];
1255
param = d[2];
1256
int loopLength = d[3];
1257
1258
switch(loop_sync) {
1259
case 2:
1260
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1261
for(int j=0;j<KRIA_NUM_PARAMS;j++)
1262
adjust_loop_len(i, d[3], j);
1263
break;
1264
case 1:
1265
if(track == 0) {
1266
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1267
for(int j=0;j<KRIA_NUM_PARAMS;j++)
1268
adjust_loop_len(i, loopLength, j);
1269
}
1270
else if(track <= KRIA_NUM_TRACKS) {
1271
for(int i=0;i<KRIA_NUM_PARAMS;i++)
1272
adjust_loop_len(d[1]-1, d[3], i);
1273
}
1274
break;
1275
case 0:
1276
if(track == 0 && param == 0) {
1277
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1278
for(int j=0;j<KRIA_NUM_PARAMS;j++)
1279
adjust_loop_len(i, loopLength, j);
1280
}
1281
else if(track == 0 && param <= KRIA_NUM_PARAMS) {
1282
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1283
adjust_loop_len(i, loopLength, param-1);
1284
}
1285
else if(param == 0 && track <= KRIA_NUM_TRACKS) {
1286
for(int i=0;i<KRIA_NUM_PARAMS;i++)
1287
adjust_loop_len(d[1]-1, loopLength, i);
1288
}
1289
else if(track <= KRIA_NUM_TRACKS && param < KRIA_NUM_PARAMS) {
1290
adjust_loop_len(track-1, loopLength, param-1);
1291
}
1292
break;
1293
default:
1294
break;
1303
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1304
for(int j=0;j<KRIA_NUM_PARAMS;j++)
1305
n += k.p[k.pattern].t[i].llen[j];
1325
if(d[3] < 17) {
1326
1327
track = d[1];
1328
param = d[2];
1329
int pos = d[3];
1330
1331
switch(loop_sync) {
1332
case 2:
1333
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1334
for(int j=0;j<KRIA_NUM_PARAMS;j++)
1335
jump_pos(i, pos, j);
1336
break;
1337
case 1:
1338
if(d[1] == 0) {
1339
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1340
for(int j=0;j<KRIA_NUM_PARAMS;j++)
1341
jump_pos(i, pos, j);
1342
}
1343
else if(d[1] < 5) {
1344
for(int i=0;i<KRIA_NUM_PARAMS;i++)
1345
jump_pos(d[1]-1, pos, i);
1346
}
1347
break;
1348
case 0:
1349
if(track == 0 && param == 0) {
1350
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1351
for(int j=0;j<KRIA_NUM_PARAMS;j++)
1352
jump_pos(i, pos, j);
1353
}
1354
else if(track == 0 && param <= KRIA_NUM_PARAMS) {
1355
for(int i=0;i<KRIA_NUM_TRACKS;i++)
1356
jump_pos(i, pos, param-1);
1357
}
1358
else if(param == 0 && track <= KRIA_NUM_TRACKS) {
1359
for(int i=0;i<KRIA_NUM_PARAMS;i++)
1360
jump_pos(track-1, pos, i);
1361
}
1362
else if(track <= KRIA_NUM_TRACKS && param <= KRIA_NUM_PARAMS) {
1363
jump_pos(track-1, pos, param-1);
1364
}
1365
break;
1366
default:
1367
break;
1368
}
1369
}
1370
break;
1371
case II_KR_POS + II_GET:
1372
if(d[1]==0 && d[2] == 0) {
1373
int n = 0;
1374
for(int i1=0;i1<4;i1++)
1375
for(int i2=0;i2<4;i2++)
1376
n += pos[i1][i2];
1377
ii_tx_queue(n>>4);
1378
}
1379
else if(d[1] == 0) {
1380
int n = 0;
1381
for(int i1=0;i1<4;i1++)
1382
n += pos[i1][d[2]-1];
1383
ii_tx_queue(n>>2);
1384
}
1385
else if(d[2] == 0) {
1386
int n = 0;
1387
for(int i1=0;i1<4;i1++)
1388
n += pos[d[1]-1][i1];
1389
ii_tx_queue(n>>2);
1390
}
1391
else {
1392
ii_tx_queue(pos[d[1]-1][d[2]-1]);
1393
}
1394
break;
1395
case II_KR_CV + II_GET:
1396
if (d[1] > 3) {
1397
ii_tx_queue(0);
1398
ii_tx_queue(0);
1399
break;
1400
}
1401
ii_tx_queue(dac_get_value(d[1]) >> 8);
1402
ii_tx_queue(dac_get_value(d[1]) & 0xff);
1403
break;
1404
case II_KR_MUTE:
1405
if ( d[1] == 0 ) {
1406
for ( int i=0; i<4; i++ )
1407
kria_mutes[i] = max( min( d[2], 1 ), 0 );
1408
monomeFrameDirty++;
1409
}
1410
else if ( d[1] < 5 && d[1] > 0 ) {
1411
kria_mutes[d[1]-1] = max( min( d[2], 1 ), 0 );
1412
monomeFrameDirty++;
1413
}
1414
break;
1415
case II_KR_MUTE + II_GET:
1416
if ( d[1] > 0 && d[1] < 5 ) {
1417
ii_tx_queue( kria_mutes[d[1]-1] );
1418
}
1419
break;
1421
if ( d[1] == 0 ) {
1422
for ( int i=0; i<4; i++ ) {
1423
kria_mutes[i] = !kria_mutes[i];
1424
}
1425
monomeFrameDirty++;
1426
}
1427
else if ( d[1] < 5 && d[1] > 0 ) {
1428
kria_mutes[d[1]-1] = !kria_mutes[d[1]-1];
1429
monomeFrameDirty++;
1430
}
1431
break;
1443
break;
1444
case II_KR_PAGE:
1445
if ( l >= 2 ) {
1446
kria_modes_t next_mode = ii_kr_mode_for_cmd(d[1]);
1447
if (next_mode < 0) {
1448
break;
1449
}
1450
k_mode = next_mode;
1451
if (k_mode == mPattern) {
1452
cue = true;
1453
}
1454
kria_set_alt_blink_timer(k_mode);
1455
}
1456
break;
1457
case II_KR_PAGE + II_GET:
1458
ii_tx_queue(ii_kr_cmd_for_mode(k_mode));
1459
break;
1460
case II_KR_CUE:
1461
if (!meta && l >= 2) {
1462
cue_pat_next = d[1] + 1;
1463
cue = true;
1464
}
1465
break;
1466
case II_KR_CUE + II_GET: {
1467
ii_tx_queue(cue_pat_next - 1);
1468
break;
1469
}
1470
case II_KR_DIR:
1471
if ( d[1] < 0
1472
|| d[1] > KRIA_NUM_TRACKS
1473
|| d[2] < 0
1474
|| d[2] > krDirRandom) break;
1475
if ( d[1] == 0 ) {
1476
for ( int i=0; i<KRIA_NUM_TRACKS; i++) {
1477
k.p[k.pattern].t[i].direction = d[2];
1478
}
1479
}
1480
else {
1481
k.p[k.pattern].t[d[1]-1].direction = d[2];
1482
}
1483
break;
1484
case II_KR_DIR + II_GET:
1487
if (l >= 2) {
1488
ii_tx_queue(k.p[k.pattern].t[d[1] - 1].direction);
1489
}
1490
break;
1491
case II_KR_DURATION + II_GET:
1492
if ( d[1] < 0
1493
|| d[1] >= KRIA_NUM_TRACKS) {
1494
ii_tx_queue(0);
1495
ii_tx_queue(0);
1496
break;
1497
}
1498
ii_tx_queue(dur[d[1]] >> 8);
1499
ii_tx_queue(dur[d[1]] & 0xFF);
1500
break;
1507
}
1508
1509
static kria_modes_t ii_kr_mode_for_cmd(uint8_t d) {
1510
switch (d) {
1511
case 0: return mTr;
1512
case 1: return mRpt;
1513
case 2: return mNote;
1514
case 3: return mAltNote;
1515
case 4: return mOct;
1516
case 5: return mGlide;
1517
case 6: return mDur;
1518
case 7: return -1;
1519
case 8: return mScale;
1520
case 9: return mPattern;
1521
default: return -1;
1522
}
1523
}
1524
1525
static uint8_t ii_kr_cmd_for_mode(kria_modes_t mode) {
1526
switch (mode) {
1527
case mTr: return 0;
1528
case mRpt: return 1;
1529
case mNote: return 2;
1530
case mAltNote: return 3;
1531
case mOct: return 4;
1532
case mGlide: return 5;
1533
case mDur: return 6;
1534
case mScale: return 8;
1535
case mPattern: return 9;
1536
default: return -1;
1537
}
1538
}
1539
1540
static void kria_set_alt_blink_timer(kria_modes_t mode) {
1541
if ( k_mode == mRpt || k_mode == mAltNote || k_mode == mGlide ) {
1542
timer_remove( &altBlinkTimer );
1543
timer_add( &altBlinkTimer, 100, &kria_alt_mode_blink, NULL);
1544
k_mode_is_alt = true;
1545
}
1546
else {
1547
timer_remove( &altBlinkTimer );
1548
k_mode_is_alt = false;
1549
}
1550
}
1551
1552
static void kria_set_tmul(uint8_t track, kria_modes_t mode, uint8_t new_tmul) {
1553
switch (div_sync) {
1554
case 1:
1555
if (note_div_sync) {
1557
k.p[edit_pattern].t[track].tmul[mTr] = new_tmul;
1558
k.p[edit_pattern].t[track].tmul[mNote] = new_tmul;
1560
k.p[edit_pattern].t[track].tmul[mRpt] = new_tmul;
1561
k.p[edit_pattern].t[track].tmul[mAltNote] = new_tmul;
1562
k.p[edit_pattern].t[track].tmul[mOct] = new_tmul;
1563
k.p[edit_pattern].t[track].tmul[mGlide] = new_tmul;
1564
k.p[edit_pattern].t[track].tmul[mDur] = new_tmul;
1567
k.p[edit_pattern].t[track].tmul[mTr] = new_tmul;
1568
k.p[edit_pattern].t[track].tmul[mNote] = new_tmul;
1569
k.p[edit_pattern].t[track].tmul[mRpt] = new_tmul;
1570
k.p[edit_pattern].t[track].tmul[mAltNote] = new_tmul;
1571
k.p[edit_pattern].t[track].tmul[mOct] = new_tmul;
1572
k.p[edit_pattern].t[track].tmul[mGlide] = new_tmul;
1573
k.p[edit_pattern].t[track].tmul[mDur] = new_tmul;
1574
}
1575
break;
1576
case 2:
1577
for (uint8_t i = 0; i < 4; i++) {
1578
if (note_div_sync) {
1580
k.p[edit_pattern].t[i].tmul[mTr] = new_tmul;
1581
k.p[edit_pattern].t[i].tmul[mNote] = new_tmul;
1583
k.p[edit_pattern].t[i].tmul[mRpt] = new_tmul;
1584
k.p[edit_pattern].t[i].tmul[mAltNote] = new_tmul;
1585
k.p[edit_pattern].t[i].tmul[mOct] = new_tmul;
1586
k.p[edit_pattern].t[i].tmul[mGlide] = new_tmul;
1587
k.p[edit_pattern].t[i].tmul[mDur] = new_tmul;
1590
k.p[edit_pattern].t[i].tmul[mTr] = new_tmul;
1591
k.p[edit_pattern].t[i].tmul[mNote] = new_tmul;
1592
k.p[edit_pattern].t[i].tmul[mRpt] = new_tmul;
1593
k.p[edit_pattern].t[i].tmul[mAltNote] = new_tmul;
1594
k.p[edit_pattern].t[i].tmul[mOct] = new_tmul;
1595
k.p[edit_pattern].t[i].tmul[mGlide] = new_tmul;
1596
k.p[edit_pattern].t[i].tmul[mDur] = new_tmul;
1614
1615
static void preset_mode_handle_key(u8 x, u8 y, u8 z, u8* glyph) {
1616
if (z) {
1617
if (x == 5 && y == 7) {
1618
if (follower_select) {
1619
follower_select = false;
1620
} else {
1621
mod_follower = true;
1622
}
1623
}
1624
if (follower_select) {
1625
if (y == 0) {
1626
if (x <= 6) {
1627
followers[follower].oct = x - 3;
1628
follower_change_octave(&followers[follower], followers[follower].oct);
1629
}
1630
if (followers[follower].mode_ct > 1
1631
&& x >= 13
1632
&& x <= (13 + followers[follower].mode_ct)) {
1633
follower_change_mode(&followers[follower], x - 13);
1634
}
1635
}
1636
if (y >= 2 && y <= 5) {
1637
if (x == 5) {
1638
follower = y - 2;
1639
}
1640
}
1641
if (y == 7) {
1642
if (x <= 3) {
1643
followers[follower].track_en ^= 1 << x;
1644
}
1645
}
1646
}
1647
else {
1648
if (x > 7) {
1649
glyph[y] ^= 1<<(x-8);
1650
}
1651
if (x == 5 && y >= 2 && y <= 5) {
1652
if (mod_follower) {
1653
follower = y - 2;
1654
follower_select = true;
1655
}
1656
else {
1657
toggle_follower(y - 2);
1658
}
1659
}
1660
}
1661
1662
monomeFrameDirty++;
1663
}
1664
else {
1665
if (x == 5 && y == 7) {
1666
mod_follower = false;
1667
monomeFrameDirty++;
1668
}
1669
}
1670
}
1671
1675
monome_grid_key_parse_event_data(data, &x, &y, &z);
1676
// print_dbg("\r\n monome event; x: ");
1677
// print_dbg_hex(x);
1678
// print_dbg("; y: 0x");
1679
// print_dbg_hex(y);
1680
// print_dbg("; z: 0x");
1681
// print_dbg_hex(z);
1682
1683
//// TRACK LONG PRESSES
1684
index = y*16 + x;
1685
if(z) {
1686
held_keys[key_count] = index;
1687
key_count++;
1698
1699
// FAST PRESS
1700
if(key_times[index] > 0) {
1701
// PRESET MODE FAST PRESS DETECT
1702
if(preset_mode == 1) {
1706
1712
}
1713
else if(y == preset) {
1714
// flash read
1715
flashc_memset8((void*)&(f.kria_state.preset), preset, 1, true);
1716
init_kria();
1729
if(!meta) {
1730
if(cue) {
1731
cue_pat_next = x+1;
1732
}
1733
else {
1734
change_pattern(x);
1735
}
1763
else if(view_clock) {
1764
if(z) {
1765
if(clock_external) {
1766
if(y==1) {
1767
clock_mul = x + 1;
1768
monomeFrameDirty++;
1769
}
1770
}
1771
else {
1772
if(y==1)
1773
time_rough = x;
1774
else if(y==2)
1775
time_fine = x;
1776
else if(y>=4) {
1777
if(y==4 && x >= 6 && x <= 9) {
1778
int i = 0;
1779
1780
switch(x) {
1781
case 6:
1782
i = -4;
1783
break;
1784
case 7:
1785
i = -1;
1786
break;
1787
case 8:
1788
i = 1;
1789
break;
1790
case 9:
1791
i = 4;
1792
break;
1793
default:
1794
break;
1795
}
1797
i += clock_period;
1798
if(i < 20)
1799
i = 20;
1800
if(clock_period > 265)
1801
clock_period = 265;
1802
clock_period = i;
1803
1804
time_rough = (clock_period - 20) / 16;
1805
time_fine = (clock_period - 20) % 16;
1806
}
1807
}
1808
1809
clock_period = 20 + (time_rough * 16) + time_fine;
1810
1811
clock_set(clock_period);
1812
1819
note_div_sync ^= 1;
1820
flashc_memset8((void*)&(f.kria_state.note_div_sync), note_div_sync, sizeof(note_div_sync), true);
1822
if (x >= 7 && x <= 8 && y >= 6) {
1823
kria_sync_mode ^= 1;
1824
flashc_memset8((void*)&(f.kria_state.sync_mode), kria_sync_mode, sizeof(kria_sync_mode), true);
1825
}
1826
if (x >= 12) {
1827
if (y == 5) {
1828
if (div_sync == 1) {
1829
div_sync = 0;
1830
} else {
1831
div_sync = 1;
1832
}
1833
flashc_memset8((void*)&(f.kria_state.div_sync), div_sync, sizeof(div_sync), true);
1834
}
1835
if (y == 7) {
1836
if (div_sync == 2) {
1837
div_sync = 0;
1838
} else {
1839
div_sync = 2;
1840
}
1841
flashc_memset8((void*)&(f.kria_state.div_sync), div_sync, sizeof(div_sync), true);
1842
}
1843
}
1844
1845
monomeFrameDirty++;
1846
}
1847
1848
1849
// time_rough = (clock_period - 20) / 16;
1850
// time_fine = (clock_period - 20) % 16;
1851
}
1852
else if(view_config) {
1855
note_sync ^= 1;
1856
flashc_memset8((void*)&(f.kria_state.note_sync), note_sync, 1, true);
1857
}
1858
else if(y == 0 && x < 3) {
1859
grid_varibrightness = x == 0 ? 1 :
1860
x == 1 ? 4 :
1861
16;
1862
flashc_memset8((void*)&(f.state.grid_varibrightness), grid_varibrightness, 1, true);
1863
}
1868
else loop_sync = 1;
1869
1870
flashc_memset8((void*)&(f.kria_state.loop_sync), loop_sync, 1, true);
1871
}
1872
else if(y == 5) {
1876
else loop_sync = 2;
1877
1878
flashc_memset8((void*)&(f.kria_state.loop_sync), loop_sync, 1, true);
1879
}
1880
else if (y == 7 && x == 14) {
1881
view_config = false;
1882
view_clock = false;
1883
view_tuning = true;
1884
1885
grid_refresh = &refresh_grid_tuning;
1886
restore_grid_tuning();
1887
}
1897
if (x == 0) {
1898
if (tuning_note_on[y]) {
1899
tuning_note_on[y] = false;
1900
clr_tr(TR1 + y);
1901
}
1902
else {
1903
tuning_note_on[y] = true;
1904
set_tr(TR1 + y);
1905
}
1906
}
1907
else if (x >= 2 && x <= 13) {
1908
if (y == tuning_track
1909
&& (x - 2 == tuning_octave_offset[y])) {
1910
if (tuning_note_on[y]) {
1911
tuning_note_on[y] = false;
1912
clr_tr(TR1 + y);
1913
}
1914
else {
1915
tuning_note_on[y] = true;
1916
set_tr(TR1 + y);
1917
}
1918
}
1919
else {
1920
tuning_track = y;
1921
tuning_octave_offset[y] = (int)x - 2;
1922
dac_set_value_noslew(
1923
y,
1924
tuning_table[y][
1925
(int)(tuning_octave * 12) +
1926
tuning_octave_offset[y]
1927
]);
1928
}
1929
}
1930
}
1931
else if (y == 5 && x <= 9) {
1932
tuning_octave = x;
1933
for (uint8_t i = 0; i < 4; i++) {
1934
dac_set_value_noslew(
1935
i,
1936
tuning_table[i][
1937
(int)(tuning_octave * 12) +
1938
tuning_octave_offset[i]
1939
]);
1940
}
1941
}
1942
else if (y == 6) {
1943
int tuning_slot = (int)(tuning_octave * 12) + tuning_octave_offset[tuning_track];
1944
tuning_table[tuning_track][tuning_slot] = x * ((DAC_10V) / 16);
1945
dac_set_value_noslew(
1946
tuning_track,
1947
tuning_table[tuning_track][
1948
(int)(tuning_octave * 12) +
1949
tuning_octave_offset[tuning_track]
1950
]);
1951
}
1952
else if (y == 7) {
1953
int tuning_slot = (int)(tuning_octave * 12) + tuning_octave_offset[tuning_track];
1954
if (x >= 8) {
1955
if (mod_tuning) {
1956
for (uint8_t t = 0; t < 4; t++) {
1957
for (uint8_t s = 0; s < 120; s++) {
1958
tuning_table[t][s] = sum_clip(
1959
tuning_table[t][s],
1960
1 << (x - 8),
1961
DAC_10V);
1962
}
1963
}
1964
}
1965
else {
1966
tuning_table[tuning_track][tuning_slot] = sum_clip(
1967
tuning_table[tuning_track][tuning_slot],
1968
1 << (x - 8),
1969
DAC_10V);
1970
}
1972
if (mod_tuning) {
1973
for (uint8_t t = 0; t < 4; t++) {
1974
for (uint8_t s = 0; s < 120; s++) {
1975
tuning_table[t][s] = sum_clip(
1976
tuning_table[t][s],
1977
- (1 << (8 - x)),
1978
DAC_10V);
1979
}
1980
}
1981
}
1982
else {
1983
tuning_table[tuning_track][tuning_slot] = sum_clip(
1984
tuning_table[tuning_track][tuning_slot],
1985
- (1 << (8 - x)),
1986
DAC_10V);
1987
}
1988
}
1989
1990
if (mod_tuning) {
1991
for (uint8_t t = 0; t < 4; t++) {
1992
dac_set_value_noslew(
1993
t,
1994
tuning_table[t][
1995
(int)(tuning_octave * 12) +
1996
tuning_octave_offset[t]
1997
]);
1998
}
1999
}
2000
else {
2001
dac_set_value_noslew(
2002
tuning_track,
2003
tuning_table[tuning_track][
2004
(int)(tuning_octave * 12) +
2005
tuning_octave_offset[tuning_track]
2006
]);
2017
else {
2018
// bottom row
2019
if(y == 7) {
2020
if(z) {
2021
switch(x) {
2022
case 0:
2023
case 1:
2024
case 2:
2025
case 3:
2026
if ( k_mod_mode == modLoop )
2027
kria_mutes[x] = !kria_mutes[x];
2028
else
2029
track = x;
2030
break;
2038
if ( k_mode == mNote )
2039
k_mode = mAltNote;
2040
else
2041
k_mode = mNote;
2042
break;
2044
if ( k_mode == mOct )
2045
k_mode = mGlide;
2046
else
2047
k_mode = mOct;
2048
break;
2079
default: break;
2080
}
2081
}
2082
2083
monomeFrameDirty++;
2084
}
2085
else {
2086
switch(k_mode) {
2087
case mTr:
2088
switch(k_mod_mode) {
2089
case modNone:
2090
if(z) {
2104
update_loop_start(loop_edit, loop_first, mTr);
2105
update_loop_end(loop_edit, loop_last, mTr);
2106
if (note_sync) {
2107
update_loop_start(loop_edit, loop_first, mNote);
2108
update_loop_end(loop_edit, loop_last, mNote);
2109
}
2126
} else {
2127
update_loop_start(loop_edit, loop_first, mTr);
2128
if (note_sync) {
2148
break;
2149
default: break;
2150
}
2151
2152
break;
2153
case mNote:
2154
switch(k_mod_mode) {
2155
case modNone:
2156
if(z) {
2158
if(k.p[edit_pattern].t[track].tr[x] && k.p[edit_pattern].t[track].note[x] == 6-y)
2159
k.p[edit_pattern].t[track].tr[x] = 0;
2161
k.p[edit_pattern].t[track].tr[x] = 1;
2162
k.p[edit_pattern].t[track].note[x] = 6-y;
2170
case modLoop:
2171
if(z) {
2172
if(loop_count == 0) {
2173
loop_first = x;
2174
loop_last = -1;
2178
update_loop_start(track, loop_first, mNote);
2179
update_loop_end(track, loop_last, mNote);
2180
if (note_sync) {
2181
update_loop_start(track, loop_first, mTr);
2182
update_loop_end(track, loop_last, mTr);
2183
}
2185
2186
loop_count++;
2187
}
2188
else {
2189
loop_count--;
2190
2191
if(loop_count == 0) {
2192
if(loop_last == -1) {
2200
} else {
2201
update_loop_start(track, loop_first, mNote);
2202
if (note_sync) {
2203
update_loop_start(track, loop_first, mTr);
2204
}
2222
break;
2223
default: break;
2224
}
2225
break;
2226
case mOct:
2227
switch(k_mod_mode) {
2228
case modNone:
2229
if(z) {
2237
k.p[edit_pattern].t[track].oct[x] = (int)abs_oct - (int)k.p[edit_pattern].t[track].octshift;
2241
break;
2242
case modLoop:
2243
if(z) {
2244
if(loop_count == 0) {
2245
loop_first = x;
2246
loop_last = -1;
2247
}
2248
else {
2249
loop_last = x;
2250
update_loop_start(track, loop_first, mOct);
2251
update_loop_end(track, loop_last, mOct);
2262
update_loop_start(track, loop_first, mOct);
2263
update_loop_end(track, loop_first, mOct);
2283
break;
2284
default: break;
2285
}
2286
break;
2287
case mDur:
2288
switch(k_mod_mode) {
2289
case modNone:
2290
if(z) {
2291
if(y==0)
2295
monomeFrameDirty++;
2296
}
2297
break;
2298
case modLoop:
2299
if(y>0) {
2300
if(z) {
2301
if(loop_count == 0) {
2302
loop_first = x;
2303
loop_last = -1;
2304
}
2305
else {
2306
loop_last = x;
2307
update_loop_start(track, loop_first, mDur);
2308
update_loop_end(track, loop_last, mDur);
2319
update_loop_start(track, loop_first, mDur);
2320
update_loop_end(track, loop_first, mDur);
2350
if (k.p[edit_pattern].t[track].rpt[x] < 5) {
2351
k.p[edit_pattern].t[track].rpt[x]++;
2367
if (k.p[edit_pattern].t[track].rpt[x] > 1) {
2368
k.p[edit_pattern].t[track].rpt[x]--;
2374
}
2375
break;
2376
case modLoop:
2377
if(z) {
2378
if(loop_count == 0) {
2379
loop_first = x;
2380
loop_last = -1;
2388
}
2389
else {
2390
update_loop_start(track, loop_first, mRpt);
2391
update_loop_end(track, loop_last, mRpt);
2392
}
2393
}
2394
2395
loop_count++;
2396
}
2397
else {
2398
loop_count--;
2399
2400
if(loop_count == 0) {
2401
if(loop_last == -1) {
2405
}
2406
else {
2407
update_loop_start(track, loop_first, mRpt);
2408
update_loop_end(track, loop_first, mRpt);
2409
}
2414
}
2415
monomeFrameDirty++;
2416
}
2417
}
2418
break;
2419
case modTime:
2420
if (z) {
2422
monomeFrameDirty++;
2423
}
2424
break;
2425
case modProb:
2426
if(z && y > 1 && y < 6) {
2439
monomeFrameDirty++;
2440
}
2441
break;
2442
case modLoop:
2443
if(z) {
2444
if(loop_count == 0) {
2445
loop_first = x;
2446
loop_last = -1;
2447
}
2448
else {
2449
loop_last = x;
2450
update_loop_start(track, loop_first, mAltNote);
2451
update_loop_end(track, loop_last, mAltNote);
2452
}
2453
2454
loop_count++;
2455
}
2456
else {
2457
loop_count--;
2458
2459
if(loop_count == 0) {
2460
if(loop_last == -1) {
2462
update_loop_start(track, loop_first, mAltNote);
2463
update_loop_end(track, loop_first, mAltNote);
2464
}
2465
else
2466
update_loop_start(track, loop_first, mAltNote);
2467
}
2468
monomeFrameDirty++;
2469
}
2470
}
2471
break;
2472
case modTime:
2473
if(z) {
2475
monomeFrameDirty++;
2476
}
2477
break;
2478
case modProb:
2479
if(z && y > 1 && y < 6) {
2487
case mGlide:
2488
switch(k_mod_mode) {
2489
case modNone:
2490
if(z) {
2491
// if(y>2)
2493
monomeFrameDirty++;
2494
}
2495
break;
2496
case modLoop:
2497
if(z) {
2498
if(loop_count == 0) {
2499
loop_first = x;
2500
loop_last = -1;
2501
}
2502
else {
2503
loop_last = x;
2504
update_loop_start(track, loop_first, mGlide);
2505
update_loop_end(track, loop_last, mGlide);
2506
}
2507
2508
loop_count++;
2509
}
2510
else {
2511
loop_count--;
2512
2513
if(loop_count == 0) {
2514
if(loop_last == -1) {
2516
update_loop_start(track, loop_first, mGlide);
2517
update_loop_end(track, loop_first, mGlide);
2518
}
2519
else
2520
update_loop_start(track, loop_first, mGlide);
2521
}
2522
monomeFrameDirty++;
2523
}
2524
}
2525
break;
2526
case modTime:
2527
if(z) {
2529
monomeFrameDirty++;
2530
}
2531
break;
2532
case modProb:
2533
if(z && y > 1 && y < 6) {
2565
if (held_keys[i] == 16*y + scale_data[k.p[edit_pattern].scale][6 - y] + 8) {
2566
scale_adj[6 - y] = x - 8 - scale_data[k.p[edit_pattern].scale][6 - y];
2582
if(y > 1 && y < 6) {
2583
if(z && cue) {
2584
meta_next = (y-2) * 16 + x + 1;
2585
if(meta_next - 1 > k.meta_end) {
2586
meta_next = 0;
2587
}
2588
}
2589
else if(k_mod_mode == modLoop) {
2590
if(z) {
2591
if(loop_count == 0) {
2592
loop_first = (y-2) * 16 + x;
2593
loop_last = -1;
2594
}
2595
else {
2596
loop_last = (y-2) * 16 + x;
2597
update_meta_start(loop_first);
2598
update_meta_end(loop_last);
2599
}
2600
loop_count++;
2601
}
2602
else {
2603
loop_count--;
2604
if(loop_count == 0) {
2605
if(loop_last == -1) {
2606
if(loop_first == k.meta_start) {
2607
update_meta_start(loop_first);
2608
update_meta_end(loop_first);
2609
}
2610
else
2611
update_meta_start(loop_first);
2612
}
2613
monomeFrameDirty++;
2614
}
2615
}
2616
}
2617
else if(z) {
2618
meta_edit = (y-2) * 16 + x;
2619
}
2620
}
2621
else if(z && y == 6) {
2622
if(cue) {
2623
meta ^= 1;
2625
}
2626
else {
2627
k.meta_steps[meta_edit] = x;
2628
}
2629
}
2630
else if(z && y == 1) {
2640
else if(z && y == 0) {
2641
if (cue) {
2642
if (meta) {
2643
if (meta_lock && x == edit_pattern) {
2644
meta_lock = false;
2645
timer_remove( &metaLockBlinkTimer );
2646
}
2647
else {
2648
edit_pattern = x;
2649
if (!meta_lock) {
2650
timer_add( &metaLockBlinkTimer, 100, &kria_meta_lock_blink, NULL );
2651
meta_lock = true;
2652
}
2653
}
2654
}
2655
}
2656
}
2665
}
2666
2667
static void update_meta_start(u8 x) {
2668
s16 temp;
2669
2670
temp = meta_pos - k.meta_start + x;
2671
if(temp < 0) temp += 64;
2672
else if(temp > 63) temp -= 64;
2673
meta_next = temp + 1;
2674
2675
k.meta_start = x;
2676
temp = x + k.meta_len-1;
2677
if(temp > 63) {
2678
k.meta_end = temp - 64;
2679
k.meta_lswap = 1;
2680
}
2681
else {
2682
k.meta_end = temp;
2683
k.meta_lswap = 0;
2684
}
2685
}
2686
2687
static void update_meta_end(u8 x) {
2688
s16 temp;
2689
2690
k.meta_end = x;
2691
temp = k.meta_end - k.meta_start;
2692
if(temp < 0) {
2693
k.meta_len = temp + 65;
2694
k.meta_lswap = 1;
2695
}
2696
else {
2697
k.meta_len = temp+1;
2698
k.meta_lswap = 0;
2699
}
2700
2701
temp = meta_pos;
2702
if(k.meta_lswap) {
2703
if(temp < k.meta_start && temp > k.meta_end)
2704
meta_next = k.meta_start + 1;
2705
}
2706
else {
2707
if(temp < k.meta_start || temp > k.meta_end)
2708
meta_next = k.meta_start + 1;
2709
}
2710
}
2711
2715
if (!meta_lock || edit_pattern == k.pattern) {
2716
temp = pos[t][m] - k.p[k.pattern].t[t].lstart[m] + x;
2717
if(temp < 0) temp += 16;
2718
else if(temp > 15) temp -= 16;
2719
pos[t][m] = temp;
2720
}
2722
k.p[edit_pattern].t[t].lstart[m] = x;
2723
temp = x + k.p[edit_pattern].t[t].llen[m]-1;
2725
k.p[edit_pattern].t[t].lend[m] = temp - 16;
2726
k.p[edit_pattern].t[t].lswap[m] = 1;
2731
}
2732
}
2733
2734
static void adjust_loop_end(u8 t, u8 x, u8 m) {
2735
s8 temp;
2736
2737
k.p[edit_pattern].t[t].lend[m] = x;
2738
temp = k.p[edit_pattern].t[t].lend[m] - k.p[edit_pattern].t[t].lstart[m];
2740
k.p[edit_pattern].t[t].llen[m] = temp + 17;
2741
k.p[edit_pattern].t[t].lswap[m] = 1;
2744
k.p[edit_pattern].t[t].llen[m] = temp+1;
2745
k.p[edit_pattern].t[t].lswap[m] = 0;
2748
if (!meta_lock || edit_pattern == k.pattern) {
2749
temp = pos[t][m];
2750
if(k.p[k.pattern].t[t].lswap[m]) {
2751
if(temp < k.p[k.pattern].t[t].lstart[m] && temp > k.p[k.pattern].t[t].lend[m])
2752
pos[t][m] = k.p[k.pattern].t[t].lstart[m];
2753
}
2754
else {
2755
if(temp < k.p[k.pattern].t[t].lstart[m] || temp > k.p[k.pattern].t[t].lend[m])
2756
pos[t][m] = k.p[k.pattern].t[t].lstart[m];
2757
}
2765
static void update_loop_start(u8 t, u8 x, u8 m) {
2766
int i1, i2;
2767
switch(loop_sync) {
2768
case 1:
2769
for(i1=0;i1<KRIA_NUM_PARAMS;i1++)
2770
adjust_loop_start(t,x,i1);
2771
break;
2772
case 2:
2773
for(i2=0;i2<4;i2++)
2774
for(i1=0;i1<KRIA_NUM_PARAMS;i1++)
2775
adjust_loop_start(i2,x,i1);
2776
break;
2777
case 0:
2779
break;
2780
default:
2781
break;
2782
}
2783
}
2784
2785
static void update_loop_end(u8 t, u8 x, u8 m) {
2786
int i1, i2;
2787
switch(loop_sync) {
2788
case 1:
2789
for(i1=0;i1<KRIA_NUM_PARAMS;i1++)
2790
adjust_loop_end(t,x,i1);
2791
break;
2792
case 2:
2793
for(i2=0;i2<4;i2++)
2794
for(i1=0;i1<KRIA_NUM_PARAMS;i1++)
2795
adjust_loop_end(i2,x,i1);
2796
break;
2797
case 0:
2805
static void jump_pos(u8 t, u8 x, u8 m) {
2806
pos[t][m] = (x + 15) & 0xf;
2807
}
2808
2812
2813
monome_set_quadrant_flag(0);
2814
monome_set_quadrant_flag(1);
2815
(*monome_refresh)();
2816
}
2817
}
2818
2820
// print_dbg("\r\n> kria key");
2821
// print_dbg_ulong(data);
2822
2823
switch(data) {
2824
case 0:
2825
grid_refresh = &refresh_kria;
2826
view_clock = false;
2827
break;
2828
case 1:
2829
grid_refresh = &refresh_clock;
2830
// print_dbg("\r\ntime: ");
2831
// print_dbg_ulong(time_fine);
2832
// print_dbg(" ");
2833
// print_dbg_ulong(time_rough);
2838
if (!view_tuning) {
2839
grid_refresh = &refresh_kria;
2840
view_config = false;
2841
}
2851
grid_refresh = &refresh_kria_config;
2852
view_config = true;
2853
view_clock = false;
2854
break;
2855
default:
2856
break;
2857
}
2858
2859
monomeFrameDirty++;
2860
}
2861
2863
// print_dbg("\r\n> kria tr ");
2864
// print_dbg_ulong(data);
2865
2866
switch(data) {
2867
case 0:
2868
if(clock_mul == 1)
2869
clock_kria(0);
2870
break;
2871
case 1:
2872
if(clock_mul == 1)
2873
clock_kria(1);
2874
else {
2875
ext_clock_count++;
2876
if(ext_clock_count >= clock_mul - 1) {
2877
ext_clock_count = 0;
2878
ext_clock_phase ^= 1;
2879
clock_kria(ext_clock_phase);
2880
}
2881
}
2882
break;
2883
case 3:
2894
// print_dbg("\r\n> kria tr normal ");
2895
// print_dbg_ulong(data);
2896
2897
clock_external = data;
2898
2899
if(clock_external)
2900
clock = &clock_null;
2901
else
2902
clock = &clock_kria;
2903
2904
monomeFrameDirty++;
2911
// bottom strip
2912
memset(monomeLedBuffer + R7 + 5, L0, 4);
2913
monomeLedBuffer[R7 + 10] = L0;
2914
monomeLedBuffer[R7 + 11] = L0;
2952
if (k_mode == mPattern) {
2953
monomeLedBuffer[activeModeIndex] = (meta && meta_lock && kriaMetaLockBlink) ? L1 : L2;
2954
}
2955
else {
2956
monomeLedBuffer[activeModeIndex] = (k_mode_is_alt && kriaAltModeBlink) ? L1 : L2;
2957
}
2972
refresh_kria_oct();
2973
break;
2974
case mDur:
2975
refresh_kria_dur();
2976
break;
2977
case mRpt:
2978
refresh_kria_rpt();
2979
break;
2983
case mScale:
2984
refresh_kria_scale();
2985
break;
2986
case mPattern:
2987
refresh_kria_pattern();
2988
default: break;
2989
}
2990
}
2992
bool refresh_kria_mod(void) {
2993
switch (k_mod_mode) {
2994
case modLoop:
2995
monomeLedBuffer[R7 + 10] = L1;
2996
return false;
3006
if(k.p[edit_pattern].t[track].p[k_mode][i]) {
3007
monomeLedBuffer[(5 - k.p[edit_pattern].t[track].p[k_mode][i]) * 16 + i] =
3008
(edit_pattern == k.pattern && i == pos[track][k_mode]) ? 10 : 6;
3013
return false;
3014
}
3015
}
3016
3017
void refresh_kria_tr(void) {
3018
// steps
3019
for(uint8_t i=0;i<4;i++) {
3020
for(uint8_t j=0;j<16;j++) {
3026
if (!meta_lock || edit_pattern == k.pattern) {
3027
monomeLedBuffer[i*16 + pos[i][mTr]] += 4;
3028
}
3033
if(k.p[edit_pattern].t[i].lswap[mTr]) {
3034
for(uint8_t j=0;j<k.p[edit_pattern].t[i].llen[mTr];j++)
3035
monomeLedBuffer[i*16 + (j+k.p[edit_pattern].t[i].lstart[mTr])%16] += 2 + (k_mod_mode == modLoop);
3038
for(uint8_t j=k.p[edit_pattern].t[i].lstart[mTr];j<=k.p[edit_pattern].t[i].lend[mTr];j++)
3044
void refresh_kria_note(bool isAlt) {
3045
kria_modes_t noteMode = isAlt ? mAltNote : mNote;
3046
u8 (*notesArray)[16] = isAlt ? &k.p[edit_pattern].t[track].alt_note : &k.p[edit_pattern].t[track].note;
3052
}
3053
else {
3054
for(uint8_t i=0;i<16;i++)
3055
monomeLedBuffer[i + (6 - (*notesArray)[i] ) * 16] = 3;
3056
}
3058
if (!meta_lock || edit_pattern == k.pattern) {
3059
monomeLedBuffer[pos[track][noteMode] + (6-(*notesArray)[pos[track][noteMode]])*16] += 4;
3060
}
3062
if(k.p[edit_pattern].t[track].lswap[noteMode]) {
3063
for(uint8_t i=0;i<k.p[edit_pattern].t[track].llen[noteMode];i++) {
3064
uint8_t x = (k.p[edit_pattern].t[track].lstart[noteMode] + i) % 16;
3065
uint8_t y = 6 - (*notesArray)[x];
3066
monomeLedBuffer[16*y + x] += 3 + (k_mod_mode == modLoop)*2;
3070
for(uint8_t i=k.p[edit_pattern].t[track].lstart[noteMode];i<=k.p[edit_pattern].t[track].lend[noteMode];i++)
3080
const uint8_t octshift = k.p[edit_pattern].t[track].octshift;
3081
const int8_t octsum = sum_clip(k.p[edit_pattern].t[track].oct[i], (int)octshift, 5);
3082
3083
for(uint8_t j=0;j<=5;j++) {
3084
if (octsum >= octshift) {
3085
if (j < octshift || j > octsum) continue;
3086
}
3087
else {
3088
if (j < octsum || j > octshift) continue;
3089
}
3090
monomeLedBuffer[R6-16*j+i] = grid_varibrightness < 16 ? L0 : 3;
3092
if(k.p[edit_pattern].t[track].lswap[mOct]) {
3093
if((i < k.p[edit_pattern].t[track].lstart[mOct]) && (i > k.p[edit_pattern].t[track].lend[mOct])) {
3101
if((i < k.p[edit_pattern].t[track].lstart[mOct]) || (i > k.p[edit_pattern].t[track].lend[mOct])) {
3110
3111
if (!meta_lock || edit_pattern == k.pattern) {
3112
if(i == pos[track][mOct]) {
3113
monomeLedBuffer[R6 - octsum*16 + i] += 4;
3114
}
3125
if(k.p[edit_pattern].t[track].lswap[mDur]) {
3126
if((i < k.p[edit_pattern].t[track].lstart[mDur]) && (i > k.p[edit_pattern].t[track].lend[mDur])) {
3129
else if ( k_mod_mode == modLoop ) {
3130
monomeLedBuffer[R1+16*j+i] += 1;
3131
}
3132
}
3133
else {
3134
if((i < k.p[edit_pattern].t[track].lstart[mDur]) || (i > k.p[edit_pattern].t[track].lend[mDur])) {
3135
monomeLedBuffer[R1+16*j+i] -= 2;
3136
}
3137
else if ( k_mod_mode == modLoop ) {
3138
monomeLedBuffer[R1+16*j+i] += 1;
3143
if (!meta_lock || edit_pattern == k.pattern) {
3144
if(i == pos[track][mDur])
3145
monomeLedBuffer[R1+i+16*k.p[k.pattern].t[track].dur[i]] += 4;
3146
}
3153
for ( uint8_t j=0; j<5; j++) {
3154
uint8_t led = 16*(5-j) + i;
3155
monomeLedBuffer[led] = 0;
3156
if (rptBits & (1 << j)) {
3157
monomeLedBuffer[led] = L0;
3158
}
3162
if ( k.p[edit_pattern].t[track].lswap[mRpt] ) {
3163
if ( (i < k.p[edit_pattern].t[track].lstart[mRpt]) && (i > k.p[edit_pattern].t[track].lend[mRpt]) ) {
3171
if ( (i < k.p[edit_pattern].t[track].lstart[mRpt]) || (i > k.p[edit_pattern].t[track].lend[mRpt]) ) {
3180
if (!meta_lock || edit_pattern == k.pattern) {
3181
if ( i == pos[track][mRpt]) {
3182
uint8_t y = max(1, activeRpt[track] - repeats[track]);
3183
monomeLedBuffer[R6 - y*16 + i] += (rptBits & (1 << y)) ? 4 : 2;
3184
}
3193
for(uint8_t j=0;j<=k.p[edit_pattern].t[track].glide[i];j++){
3194
monomeLedBuffer[R6-16*j+i] = L1 - (k.p[edit_pattern].t[track].glide[i]-j);
3195
if(k.p[edit_pattern].t[track].lswap[mGlide]) {
3196
if((i < k.p[edit_pattern].t[track].lstart[mGlide]) && (i > k.p[edit_pattern].t[track].lend[mGlide])) {
3206
if((i < k.p[edit_pattern].t[track].lstart[mGlide]) || (i > k.p[edit_pattern].t[track].lend[mGlide])) {
3207
monomeLedBuffer[R6-16*j+i] -= 2;
3208
}
3209
else if ( k_mod_mode == modLoop ) {
3210
monomeLedBuffer[R6-16*j+i] += 1;
3213
if (!meta_lock || edit_pattern == k.pattern) {
3214
if(i == pos[track][mGlide]) {
3215
monomeLedBuffer[R6 - k.p[k.pattern].t[track].glide[i]*16 + i] += 4;
3216
}
3225
monomeLedBuffer[0+16*y] = k.p[edit_pattern].t[y].tt_clocked ? L1 : L0;
3226
monomeLedBuffer[1+16*y] = k.p[edit_pattern].t[y].trigger_clocked ? L1 : L0;
3232
}
3233
3234
// vertical bar dividing the left and right half
3235
for(uint8_t i=0;i<7;i++)
3236
monomeLedBuffer[8+16*i] = L0;
3238
for(uint8_t i=0;i<8;i++) {
3239
monomeLedBuffer[R5 + i] = 2;
3240
monomeLedBuffer[R6 + i] = 2;
3241
}
3242
// highlight the selected scale
3243
monomeLedBuffer[R5 + (k.p[edit_pattern].scale >> 3) * 16 + (k.p[edit_pattern].scale & 0x7)] = L1;
3248
monomeLedBuffer[(int)scale_pos + scale_adj[i]] = L0;
3249
monomeLedBuffer[scale_pos] = L1;
3250
}
3251
3252
// if an active step of a track is playing a note, it brightness is incremented by one
3253
for(uint8_t i=0;i<4;i++) {
3254
if(k.p[k.pattern].t[i].tr[pos[i][mTr]])
3255
monomeLedBuffer[scale_data[k.p[k.pattern].scale][note[i]] + 8 + scale_adj[note[i]] + (6-note[i])*16]++;
3256
}
3257
}
3258
3259
void refresh_kria_pattern(void) {
3260
if(!meta) {
3261
memset(monomeLedBuffer, 3, 16);
3262
monomeLedBuffer[k.pattern] = L1;
3263
}
3264
else {
3265
// bar
3266
memset(monomeLedBuffer + 96, 3, k.meta_steps[meta_pos]+1);
3267
monomeLedBuffer[96 + meta_count] = L1;
3268
monomeLedBuffer[96 + k.meta_steps[meta_edit]] = L2;
3269
// top
3270
monomeLedBuffer[k.pattern] = L0;
3271
monomeLedBuffer[k.meta_pat[meta_edit]] = L1;
3272
// meta data
3273
if(!k.meta_lswap)
3274
memset(monomeLedBuffer + 32 + k.meta_start, 3, k.meta_len);
3275
else {
3276
memset(monomeLedBuffer + 32, 3, k.meta_end);
3277
memset(monomeLedBuffer + 32 + k.meta_start, 3, 64 - k.meta_start);
3279
monomeLedBuffer[32 + meta_pos] = L1;
3280
monomeLedBuffer[32 + meta_edit] = L2;
3281
if(meta_next) {
3282
monomeLedBuffer[32 + meta_next - 1] = L2;
3283
monomeLedBuffer[k.meta_pat[meta_next] - 1] = L2;
3289
if (meta_lock && kriaMetaLockBlink) {
3290
monomeLedBuffer[edit_pattern] += 4;
3291
}
3292
switch(k_mod_mode) {
3293
case modTime:
3294
monomeLedBuffer[16 + cue_count] = L0;
3295
monomeLedBuffer[16 + cue_div] = L1;
3296
break;
3297
default:
3298
monomeLedBuffer[16 + cue_steps] = L0;
3299
monomeLedBuffer[16 + cue_count] = L1;
3300
break;
3304
void refresh_kria_config(void) {
3305
// clear grid
3306
memset(monomeLedBuffer,0,128);
3308
memset(monomeLedBuffer,4, 3);
3309
monomeLedBuffer[R0 + (grid_varibrightness == 1 ? 0 :
3310
grid_varibrightness == 4 ? 1 :
3311
2)] = 12;
3312
3313
uint8_t i = note_sync * 4 + 3;
3314
3315
monomeLedBuffer[R2 + 2] = i;
3316
monomeLedBuffer[R2 + 3] = i;
3317
monomeLedBuffer[R2 + 4] = i;
3318
monomeLedBuffer[R2 + 5] = i;
3319
monomeLedBuffer[R3 + 2] = i;
3320
monomeLedBuffer[R3 + 5] = i;
3321
monomeLedBuffer[R4 + 2] = i;
3322
monomeLedBuffer[R4 + 5] = i;
3323
monomeLedBuffer[R5 + 2] = i;
3324
monomeLedBuffer[R5 + 3] = i;
3325
monomeLedBuffer[R5 + 4] = i;
3326
monomeLedBuffer[R5 + 5] = i;
3327
3328
i = (loop_sync == 1) * 4 + 3;
3329
3330
monomeLedBuffer[R3 + 10] = i;
3331
3332
i = (loop_sync == 2) * 4 + 3;
3333
3334
monomeLedBuffer[R5 + 10] = i;
3335
monomeLedBuffer[R5 + 11] = i;
3336
monomeLedBuffer[R5 + 12] = i;
3337
monomeLedBuffer[R5 + 13] = i;
3346
#define MP_1V 0
3347
#define MP_2V 1
3348
#define MP_4V 2
3349
#define MP_8T 3
3350
3351
3360
s8 position[8]; // current position in cycle
3361
u8 tick[8]; // position in speed countdown
3362
u8 pushed[8]; // manual key reset
3371
const u8 sign[8][8] = {{0,0,0,0,0,0,0,0}, // o
3372
{0,24,24,126,126,24,24,0}, // +
3373
{0,0,0,126,126,0,0,0}, // -
3374
{0,96,96,126,126,96,96,0}, // >
3375
{0,6,6,126,126,6,6,0}, // <
3376
{0,102,102,24,24,102,102,0}, // * rnd
3377
{0,120,120,102,102,30,30,0}, // <> up/down
3378
{0,126,126,102,102,126,126,0}}; // [] sync
3379
3388
flashc_memset8((void*)&(f.mp_state.preset), 0, 1, true);
3389
flashc_memset8((void*)&(f.mp_state.sound), 0, 1, true);
3390
flashc_memset8((void*)&(f.mp_state.voice_mode), 0, 1, true);
3393
m.count[i1] = 7+i1;
3394
m.speed[i1] = 0;
3395
m.min[i1] = 7+i1;
3396
m.max[i1] = 7+i1;
3397
m.trigger[i1] = (1<<i1);
3398
m.toggle[i1] = 0;
3399
m.rules[i1] = 1;
3400
m.rule_dests[i1] = i1;
3401
m.sync[i1] = (1<<i1);
3402
m.rule_dest_targets[i1] = 3;
3403
m.smin[i1] = 0;
3404
m.smax[i1] = 0;
3405
}
3406
3412
3413
// default scales
3414
for(i1=0;i1<7;i1++) {
3415
flashc_memset8((void*)&(f.scale[i1][0]), 0, 1, true);
3416
for(i2=0;i2<7;i2++)
3417
flashc_memset8((void*)&(f.scale[i1][i2+1]), SCALE_INT[i1][i2], 1, true);
3418
}
3419
for(i1=7;i1<16;i1++) {
3420
flashc_memset8((void*)&(f.scale[i1][0]), 0, 1, true);
3421
for(i2=0;i2<7;i2++)
3422
flashc_memset8((void*)&(f.scale[i1][i2+1]), 1, 1, true);
3423
}
3433
m = f.mp_state.m[preset];
3434
3435
// m.count[i1] = f.mp_state.m[preset].count[i1];
3436
// m.speed[i1] = f.mp_state.m[preset].speed[i1];
3437
// m.min[i1] = f.mp_state.m[preset].min[i1];
3438
// m.max[i1] = f.mp_state.m[preset].max[i1];
3439
// m.trigger[i1] = f.mp_state.m[preset].trigger[i1];
3440
// m.toggle[i1] = f.mp_state.m[preset].toggle[i1];
3441
// m.rules[i1] = f.mp_state.m[preset].rules[i1];
3442
// m.rule_dests[i1] = f.mp_state.m[preset].rule_dests[i1];
3443
// m.sync[i1] = f.mp_state.m[preset].sync[i1];
3444
// m.rule_dest_targets[i1] = f.mp_state.m[preset].rule_dest_targets[i1];
3445
// m.smin[i1] = f.mp_state.m[preset].smin[i1];
3446
// m.smax[i1] = f.mp_state.m[preset].smax[i1];
3447
3448
position[i1] = f.mp_state.m[preset].count[i1];
3449
tick[i1] = 0;
3450
pushed[i1] = 0;
3451
scount[i1] = 0;
3452
clear[i1] = 0;
3453
state[i1] = 0;
3456
// for(uint8_t i1=0;i1<8;i1++)
3457
// m.glyph[i1] = f.mp_state.m[preset].glyph[i1];
3458
3459
m.scale = f.mp_state.m[preset].scale;
3464
3465
note_now[0] = -1;
3466
note_now[1] = -1;
3467
note_now[2] = -1;
3468
note_now[3] = -1;
3471
void resume_mp() {
3472
grid_refresh = &refresh_mp;
3473
view_clock = false;
3474
view_config = false;
3479
// re-check clock jack
3480
clock_external = !gpio_get_pin_value(B10);
3481
3482
if(clock_external)
3483
clock = &clock_null;
3484
else
3485
clock = &clock_mp;
3508
}
3509
3510
if(m.trigger[i] & (1<<n)) {
3511
state[n] = 1;
3512
clear[n] = 1;
3513
}
3514
else if(m.toggle[i] & (1<<n)) {
3515
state[n] ^= 1;
3516
}
3517
}
3518
3525
// RULES
3526
if(m.rules[i] == 1) { // inc
3527
if(m.rule_dest_targets[i] & 1) {
3528
m.count[m.rule_dests[i]]++;
3529
if(m.count[m.rule_dests[i]] > m.max[m.rule_dests[i]]) {
3530
m.count[m.rule_dests[i]] = m.min[m.rule_dests[i]];
3531
}
3532
}
3533
if(m.rule_dest_targets[i] & 2) {
3534
m.speed[m.rule_dests[i]]++;
3535
if(m.speed[m.rule_dests[i]] > m.smax[m.rule_dests[i]]) {
3536
m.speed[m.rule_dests[i]] = m.smin[m.rule_dests[i]];
3537
}
3538
}
3539
}
3540
else if(m.rules[i] == 2) { // dec
3541
if(m.rule_dest_targets[i] & 1) {
3542
m.count[m.rule_dests[i]]--;
3543
if(m.count[m.rule_dests[i]] < m.min[m.rule_dests[i]]) {
3544
m.count[m.rule_dests[i]] = m.max[m.rule_dests[i]];
3545
}
3546
}
3547
if(m.rule_dest_targets[i] & 2) {
3548
m.speed[m.rule_dests[i]]--;
3549
if(m.speed[m.rule_dests[i]] < m.smin[m.rule_dests[i]]) {
3550
m.speed[m.rule_dests[i]] = m.smax[m.rule_dests[i]];
3551
}
3552
}
3553
}
3554
else if(m.rules[i] == 3) { // max
3555
if(m.rule_dest_targets[i] & 1)
3556
m.count[m.rule_dests[i]] = m.max[m.rule_dests[i]];
3557
if(m.rule_dest_targets[i] & 2)
3558
m.speed[m.rule_dests[i]] = m.smax[m.rule_dests[i]];
3559
}
3560
else if(m.rules[i] == 4) { // min
3561
if(m.rule_dest_targets[i] & 1)
3562
m.count[m.rule_dests[i]] = m.min[m.rule_dests[i]];
3563
if(m.rule_dest_targets[i] & 2)
3564
m.speed[m.rule_dests[i]] = m.smin[m.rule_dests[i]];
3565
}
3566
else if(m.rules[i] == 5) { // rnd
3567
if(m.rule_dest_targets[i] & 1)
3569
(rnd() % (m.max[m.rule_dests[i]] - m.min[m.rule_dests[i]] + 1)) + m.min[m.rule_dests[i]];
3570
if(m.rule_dest_targets[i] & 2)
3572
(rnd() % (m.smax[m.rule_dests[i]] - m.smin[m.rule_dests[i]] + 1)) + m.smin[m.rule_dests[i]];
3574
// print_dbg("\r\n RANDOM: ");
3575
// print_dbg_hex(m.count[m.rule_dests[i]]);
3576
// print_dbg_hex(rnd() % 11);
3577
}
3578
else if(m.rules[i] == 6) { // pole
3579
if(m.rule_dest_targets[i] & 1) {
3581
abs(m.count[m.rule_dests[i]] - m.max[m.rule_dests[i]]) ) {
3582
m.count[m.rule_dests[i]] = m.max[m.rule_dests[i]];
3583
}
3584
else {
3585
m.count[m.rule_dests[i]] = m.min[m.rule_dests[i]];
3586
}
3587
}
3588
if(m.rule_dest_targets[i] & 2) {
3590
abs(m.speed[m.rule_dests[i]] - m.smax[m.rule_dests[i]]) ) {
3591
m.speed[m.rule_dests[i]] = m.smax[m.rule_dests[i]];
3592
}
3593
else {
3594
m.speed[m.rule_dests[i]] = m.smin[m.rule_dests[i]];
3595
}
3596
}
3597
}
3598
else if(m.rules[i] == 7) { // stop
3599
if(m.rule_dest_targets[i] & 1)
3610
}
3611
3612
if(m.trigger[i] & (1<<n)) {
3613
state[n] = 1;
3614
clear[n] = 1;
3615
}
3616
else if(m.toggle[i] & (1<<n)) {
3617
state[n] ^= 1;
3618
}
3619
}
3620
}
3626
for(i=0;i<8;i++) {
3627
if(reset[i]) {
3628
position[i] = m.count[i];
3629
tick[i] = m.speed[i];
3630
reset[i] = 0;
3631
}
3632
}
3633
3634
for(i=0;i<8;i++)
3635
if(state[i] && !pstate[i])
3636
mp_note_on(i);
3637
// gpio_set_gpio_pin(outs[i]);
3638
else if(!state[i] && pstate[i])
3639
mp_note_off(i);
3640
// gpio_clr_gpio_pin(outs[i]);
3641
3642
monomeFrameDirty++;
3643
}
3644
else {
3645
// gpio_clr_gpio_pin(B10);
3646
3647
for(i=0;i<8;i++) {
3648
if(clear[i]) {
3650
// gpio_clr_gpio_pin(outs[i]);
3651
state[i] = 0;
3652
}
3653
clear[i] = 0;
3654
}
3655
}
3658
uint8_t get_note_slot(uint8_t v) {
3659
int8_t w = -1;
3660
3661
for(int i1=0;i1<v;i1++)
3662
note_age[i1]++;
3663
3664
// find empty
3665
for(int i1=0;i1<v;i1++)
3666
if(note_now[i1] == -1) {
3667
w = i1;
3668
break;
3669
}
3670
3671
if(w == -1) {
3672
w = 0;
3673
for(int i1=1;i1<v;i1++)
3674
if(note_age[w] < note_age[i1])
3675
w = i1;
3676
}
3677
3678
note_age[w] = 1;
3679
3680
return w;
3681
}
3682
3685
// print_dbg("\r\nmp note on: ");
3686
// print_dbg_ulong(n);
3687
switch(voice_mode) {
3688
case MP_8T:
3689
if(n < 4)
3690
set_tr(TR1 + n);
3691
else
3692
dac_set_value(n-4, DAC_10V);
3693
break;
3703
if(mp_clock_count < 2) {
3704
mp_clock_count++;
3705
w = get_note_slot(2);
3706
note_now[w] = n;
3712
if(mp_clock_count < 4) {
3713
mp_clock_count++;
3714
w = get_note_slot(4);
3715
note_now[w] = n;
3720
default:
3721
break;
3722
}
3723
}
3724
3725
void mp_note_off(uint8_t n) {
3726
// print_dbg("\r\nmp note off: ");
3727
// print_dbg_ulong(n);
3728
switch(voice_mode) {
3729
case MP_8T:
3730
if(n < 4)
3731
clr_tr(TR1 + n);
3732
else
3733
dac_set_value(n-4, 0);
3734
break;
3735
case MP_1V:
3736
if(note_now[0] == n) {
3737
note_now[0] = -1;
3738
clr_tr(TR1);
3739
}
3740
break;
3741
case MP_2V:
3742
for(int i1=0;i1<2;i1++) {
3743
if(note_now[i1] == n) {
3744
note_now[i1] = -1;
3745
clr_tr(TR1 + i1);
3746
}
3747
}
3748
break;
3749
case MP_4V:
3750
for(int i1=0;i1<4;i1++) {
3751
if(note_now[i1] == n) {
3752
note_now[i1] = -1;
3753
clr_tr(TR1 + i1);
3754
}
3755
}
3756
break;
3763
// print_dbg("\r\nii/mp (");
3764
// print_dbg_ulong(l);
3765
// print_dbg(") ");
3766
// for(int i=0;i<l;i++) {
3767
// print_dbg_ulong(d[i]);
3768
// print_dbg(" ");
3769
// }
3770
3771
int n;
3772
3773
if(l) {
3774
switch(d[0]) {
3775
case II_MP_PRESET:
3776
if(d[1] > -1 && d[1] < 8) {
3777
preset = d[1];
3778
flashc_memset8((void*)&(f.mp_state.preset), preset, 1, true);
3779
init_mp();
3780
}
3781
break;
3782
case II_MP_PRESET + II_GET:
3783
ii_tx_queue(preset);
3784
break;
3785
case II_MP_SCALE:
3786
if(d[1] > -1 && d[1] < 16) {
3787
m.scale = d[1];
3788
calc_scale(m.scale);
3789
}
3790
break;
3791
case II_MP_SCALE + II_GET:
3792
ii_tx_queue(m.scale);
3793
break;
3794
case II_MP_PERIOD:
3795
n = (d[1] << 8) + d[2];
3796
if(n > 19) {
3797
clock_period = n;
3798
time_rough = (clock_period - 20) / 16;
3799
time_fine = (clock_period - 20) % 16;
3800
clock_set(clock_period);
3801
}
3802
break;
3803
case II_MP_PERIOD + II_GET:
3804
ii_tx_queue(clock_period >> 8);
3805
ii_tx_queue(clock_period & 0xff);
3806
break;
3807
case II_MP_RESET:
3808
if(d[1] == 0) {
3809
for(int n=0;n<8;n++) {
3810
position[n] = m.count[n];
3811
tick[n] = m.speed[n];
3812
}
3813
}
3814
else if(d[1] < 9) {
3815
position[d[1]-1] = m.count[d[1]-1];
3816
tick[d[1]-1] = m.speed[d[1]-1];
3817
}
3818
break;
3819
case II_MP_STOP:
3820
if(d[1] == 0) {
3822
position[n] = -1;
3823
}
3824
else if(d[1] < 9) {
3825
position[d[1]-1] = -1;
3826
}
3827
break;
3828
case II_MP_CV + II_GET:
3829
if (d[1] > 3) {
3830
ii_tx_queue(0);
3831
ii_tx_queue(0);
3832
break;
3833
}
3834
ii_tx_queue(dac_get_value(d[1]) >> 8);
3835
ii_tx_queue(dac_get_value(d[1]) & 0xff);
3836
break;
3847
monome_grid_key_parse_event_data(data, &x, &y, &z);
3848
// print_dbg("\r\n monome event; x: ");
3849
// print_dbg_hex(x);
3850
// print_dbg("; y: 0x");
3851
// print_dbg_hex(y);
3852
// print_dbg("; z: 0x");
3853
// print_dbg_hex(z);
3854
3855
//// TRACK LONG PRESSES
3856
index = y*16 + x;
3857
if(z) {
3858
held_keys[key_count] = index;
3859
key_count++;
3860
key_times[index] = 10; //// THRESHOLD key hold time
3861
} else {
3862
found = 0; // "found"
3863
for(i1 = 0; i1<key_count; i1++) {
3867
held_keys[i1] = held_keys[i1+1];
3868
}
3869
key_count--;
3870
3871
// FAST PRESS
3872
if(key_times[index] > 0) {
3899
// print_dbg("\r\nfast press: ");
3900
// print_dbg_ulong(index);
3901
// print_dbg(": ");
3902
// print_dbg_ulong(key_times[index]);
3903
}
3904
}
3905
3909
}
3910
else if(view_clock) {
3911
if(z) {
3912
if(clock_external) {
3913
if(y==1) {
3914
clock_mul = x + 1;
3915
monomeFrameDirty++;
3916
}
3919
if(y==1)
3920
time_rough = x;
3921
else if(y==2)
3922
time_fine = x;
3923
else if(y==4) {
3924
int i = 0;
3925
3926
switch(x) {
3927
case 6:
3928
i = -4;
3929
break;
3930
case 7:
3931
i = -1;
3932
break;
3933
case 8:
3934
i = 1;
3935
break;
3936
case 9:
3937
i = 4;
3938
break;
3939
default:
3940
break;
3941
}
3942
3943
i += clock_period;
3944
if(i < 20)
3945
i = 20;
3946
if(clock_period > 265)
3947
clock_period = 265;
3948
clock_period = i;
3949
3950
time_rough = (clock_period - 20) / 16;
3951
time_fine = (clock_period - 20) % 16;
3952
}
3953
3954
clock_period = 20 + (time_rough * 16) + time_fine;
3955
3956
clock_set(clock_period);
3957
3958
// print_dbg("\r\nperiod: ");
3959
// print_dbg_ulong(clock_period);
3960
3961
monomeFrameDirty++;
3964
3965
3966
// time_rough = (clock_period - 20) / 16;
3967
// time_fine = (clock_period - 20) % 16;
3968
3969
}
3970
else if(view_config) {
3971
if(z) {
3972
if(y < 6 && x < 8) {
3973
switch(x) {
3974
case 0:
3975
case 1:
3976
case 2:
3977
case 3:
3978
if(voice_mode == MP_8T)
3979
sound ^= 1;
3980
voice_mode = MP_8T;
3981
break;
3982
case 4:
3983
if(voice_mode == MP_4V)
3984
sound ^= 1;
3985
voice_mode = MP_4V;
3986
break;
3987
case 5:
3988
if(voice_mode == MP_2V)
3989
sound ^= 1;
3990
voice_mode = MP_2V;
3991
break;
3992
case 6:
3993
case 7:
3994
if(voice_mode == MP_1V)
3995
sound ^= 1;
3996
voice_mode = MP_1V;
3997
break;
3998
default:
3999
break;
4000
}
4001
}
4002
else if(voice_mode != MP_8T) {
4003
if(x < 8) {
4004
m.scale = (y - 6) * 8 + x;
4005
}
4006
else {
4007
scale_data[m.scale][7-y] = x-8;
4008
}
4009
4017
else {
4018
prev_mode = mode;
4019
4020
// mode check
4021
if(x == 0) {
4022
kcount += (z<<1)-1;
4023
4024
if(kcount < 0)
4025
kcount = 0;
4026
4027
// print_dbg("\r\nkey count: ");
4028
// print_dbg_ulong(kcount);
4029
4030
if(kcount == 1 && z == 1)
4035
}
4036
4037
if(z == 1 && mode == 1) {
4038
edit_row = y;
4039
}
4040
}
4041
else if(x == 1 && mode != 0) {
4042
if(mode == 1 && z == 1) {
4043
mode = 2;
4044
edit_row = y;
4045
}
4046
else if(mode == 2 && z == 0)
4047
mode = 1;
4048
}
4049
// set position / minmax / stop
4050
else if(mode == 0) {
4051
scount[y] += (z<<1)-1;
4052
if(scount[y]<0) scount[y] = 0; // in case of grid glitch?
4053
4054
if(z == 1 && scount[y] == 1) {
4063
}
4064
}
4065
else if(z == 1 && scount[y] == 2) {
4066
if(x < m.count[y]) {
4067
m.min[y] = x;
4068
m.max[y] = m.count[y];
4069
}
4070
else {
4071
m.max[y] = x;
4072
m.min[y] = m.count[y];
4073
}
4074
}
4075
}
4076
// set speeds and trig/tog
4077
else if(mode == 1) {
4078
scount[y] += (z<<1)-1;
4079
if(scount[y]<0) scount[y] = 0;
4080
4081
if(z==1) {
4082
if(x > 7) {
4083
if(scount[y] == 1) {
4084
m.smin[y] = x-8;
4085
m.smax[y] = x-8;
4086
m.speed[y] = x-8;
4088
}
4089
else if(scount[y] == 2) {
4090
if(x-8 < m.smin[y]) {
4091
m.smax[y] = m.smin[y];
4092
m.smin[y] = x-8;
4093
}
4094
else
4095
m.smax[y] = x-8;
4096
}
4097
}
4098
else if(x == 5) {
4099
m.toggle[edit_row] ^= 1<<y;
4100
m.trigger[edit_row] &= ~(1<<y);
4101
}
4102
else if(x == 6) {
4103
m.trigger[edit_row] ^= 1<<y;
4104
m.toggle[edit_row] &= ~(1<<y);
4105
}
4106
else if(x == 4) {
4115
}
4116
}
4117
else if(x == 3) {
4118
m.sync[edit_row] ^= (1<<y);
4119
}
4120
}
4121
}
4122
else if(mode == 2 && z == 1) {
4123
if(x > 3 && x < 7) {
4124
m.rule_dests[edit_row] = y;
4125
m.rule_dest_targets[edit_row] = x-3;
4126
// post("\nrule_dests", edit_row, ":", rule_dests[edit_row]);
4127
}
4128
else if(x > 6) {
4129
m.rules[edit_row] = y;
4130
// post("\nrules", edit_row, ":", rules[edit_row]);
4131
}
4132
}
4133
4134
monomeFrameDirty++;
4135
}
4136
}
4137
4142
monome_set_quadrant_flag(0);
4143
monome_set_quadrant_flag(1);
4144
(*monome_refresh)();
4145
}
4146
}
4151
4152
switch(data) {
4153
case 0:
4154
grid_refresh = &refresh_mp;
4155
view_clock = false;
4156
break;
4157
case 1:
4158
grid_refresh = &refresh_clock;
4159
// print_dbg("\r\ntime: ");
4160
// print_dbg_ulong(time_fine);
4161
// print_dbg(" ");
4162
// print_dbg_ulong(time_rough);
4163
view_clock = true;
4164
view_config = false;
4165
break;
4166
case 2:
4167
grid_refresh = &refresh_mp;
4168
view_config = false;
4169
break;
4170
case 3:
4171
grid_refresh = &refresh_mp_config;
4172
view_config = true;
4173
view_clock = false;
4174
break;
4175
default:
4176
break;
4177
}
4178
4179
monomeFrameDirty++;
4180
}
4181
4183
// print_dbg("\r\n> MP tr ");
4184
// print_dbg_ulong(data);
4185
4186
switch(data) {
4187
case 0:
4192
if(clock_mul == 1)
4193
clock_mp(1);
4194
else {
4195
ext_clock_count++;
4196
if(ext_clock_count >= clock_mul - 1) {
4197
ext_clock_count = 0;
4198
ext_clock_phase ^= 1;
4199
clock_mp(ext_clock_phase);
4200
}
4201
}
4202
break;
4203
case 3:
4204
// right jack upwards: RESET
4205
for(int n=0;n<8;n++) {
4206
position[n] = m.count[n];
4207
tick[n] = m.speed[n];
4244
4245
monomeLedBuffer[R4+6] = 7;
4246
monomeLedBuffer[R4+7] = 3;
4247
monomeLedBuffer[R4+8] = 3;
4248
monomeLedBuffer[R4+9] = 7;
4249
4251
4252
if (ansible_mode == mGridKria) {
4253
uint8_t i = note_div_sync * 4 + 3;
4254
monomeLedBuffer[R4 + 0] = i;
4255
monomeLedBuffer[R5 + 0] = i;
4256
monomeLedBuffer[R6 + 0] = i;
4257
monomeLedBuffer[R7 + 0] = i;
4258
monomeLedBuffer[R4 + 1] = i;
4259
monomeLedBuffer[R4 + 2] = i;
4260
monomeLedBuffer[R4 + 3] = i;
4261
monomeLedBuffer[R5 + 3] = i;
4262
monomeLedBuffer[R6 + 3] = i;
4263
monomeLedBuffer[R7 + 3] = i;
4264
monomeLedBuffer[R7 + 2] = i;
4265
monomeLedBuffer[R7 + 1] = i;
4266
4267
i = kria_sync_mode & krSyncTimeDiv ? 7 : 3;
4268
monomeLedBuffer[R6 + 7] = i;
4269
monomeLedBuffer[R6 + 8] = i;
4270
monomeLedBuffer[R7 + 7] = i;
4271
monomeLedBuffer[R7 + 8] = i;
4272
4273
i = (div_sync == 1) * 4 + 3;
4274
monomeLedBuffer[R5 + 12] = i;
4275
4276
i = (div_sync == 2) * 4 + 3;
4277
monomeLedBuffer[R7 + 12] = i;
4278
monomeLedBuffer[R7 + 13] = i;
4279
monomeLedBuffer[R7 + 14] = i;
4280
monomeLedBuffer[R7 + 15] = i;
4281
}
4292
c = L0;
4293
if(voice_mode == MP_8T)
4294
c = L1 + (4 * sound);
4295
4296
monomeLedBuffer[R1 + 1] = c;
4297
monomeLedBuffer[R1 + 2] = c;
4298
monomeLedBuffer[R2 + 1] = c;
4299
monomeLedBuffer[R2 + 2] = c;
4300
monomeLedBuffer[R3 + 1] = c;
4301
monomeLedBuffer[R3 + 2] = c;
4302
monomeLedBuffer[R4 + 1] = c;
4303
monomeLedBuffer[R4 + 2] = c;
4304
4305
c = L0;
4306
if(voice_mode == MP_4V)
4307
c = L1 + (4 * sound);
4308
4309
monomeLedBuffer[R1 + 4] = c;
4310
monomeLedBuffer[R2 + 4] = c;
4311
monomeLedBuffer[R3 + 4] = c;
4312
monomeLedBuffer[R4 + 4] = c;
4313
4314
c = L0;
4315
if(voice_mode == MP_2V)
4316
c = L1 + (4 * sound);
4317
4318
monomeLedBuffer[R1 + 5] = c;
4319
monomeLedBuffer[R2 + 5] = c;
4320
4321
c = L0;
4322
if(voice_mode == MP_1V)
4323
c = L1 + (4 * sound);
4324
4325
monomeLedBuffer[R1 + 6] = c;
4327
// scale
4328
if(voice_mode != MP_8T) {
4329
for(i1=0;i1<8;i1++) {
4330
monomeLedBuffer[8+16*i1] = L0;
4331
monomeLedBuffer[R6 + i1] = 2;
4332
monomeLedBuffer[R7 + i1] = 2;
4333
}
4334
monomeLedBuffer[R6 + (m.scale >> 3) * 16 + (m.scale & 0x7)] = L2;
4335
4336
for(i1=0;i1<8;i1++)
4337
monomeLedBuffer[scale_data[m.scale][i1] + 8 + (7-i1)*16] = L1;
4338
}
4346
4347
// SHOW POSITIONS
4348
if(mode == 0) {
4349
for(i1=0;i1<8;i1++) {
4350
for(i2=m.min[i1];i2<=m.max[i1];i2++)
4351
monomeLedBuffer[i1*16 + i2] = L0;
4352
monomeLedBuffer[i1*16 + m.count[i1]] = L1;
4353
if(position[i1] >= 0) {
4354
monomeLedBuffer[i1*16 + position[i1]] = L2;
4357
}
4358
// SHOW SPEED
4359
else if(mode == 1) {
4360
for(i1=0;i1<8;i1++) {
4361
if(position[i1] >= 0)
4362
monomeLedBuffer[i1*16 + position[i1]] = L0;
4364
if(position[i1] != -1)
4365
monomeLedBuffer[i1*16 + 2] = 2;
4366
4367
for(i2=m.smin[i1];i2<=m.smax[i1];i2++)
4368
monomeLedBuffer[i1*16 + i2+8] = L0;
4369
4370
monomeLedBuffer[i1*16 + m.speed[i1]+8] = L1;
4371
4373
monomeLedBuffer[i1*16 + 4] = 2;
4374
4375
if(m.toggle[edit_row] & (1 << i1))
4376
monomeLedBuffer[i1*16 + 5] = L2;
4377
else
4378
monomeLedBuffer[i1*16 + 5] = L0;
4379
4380
if(m.trigger[edit_row] & (1 << i1))
4381
monomeLedBuffer[i1*16 + 6] = L2;
4382
else
4383
monomeLedBuffer[i1*16 + 6] = L0;
4384
4385
if(m.sync[edit_row] & (1<<i1))
4386
monomeLedBuffer[i1*16 + 3] = L1;
4388
monomeLedBuffer[i1*16 + 3] = L0;
4389
}
4390
4391
monomeLedBuffer[edit_row * 16] = L2;
4396
if(position[i1] >= 0)
4397
monomeLedBuffer[i1*16 + position[i1]] = L0;
4398
4399
monomeLedBuffer[edit_row * 16] = L1;
4400
monomeLedBuffer[edit_row * 16 + 1] = L1;
4401
4402
if(m.rule_dest_targets[edit_row] == 1) {
4403
monomeLedBuffer[m.rule_dests[edit_row] * 16 + 4] = L2;
4404
monomeLedBuffer[m.rule_dests[edit_row] * 16 + 5] = L0;
4405
monomeLedBuffer[m.rule_dests[edit_row] * 16 + 6] = L0;
4406
}
4407
else if (m.rule_dest_targets[edit_row] == 2) {
4408
monomeLedBuffer[m.rule_dests[edit_row] * 16 + 4] = L0;
4409
monomeLedBuffer[m.rule_dests[edit_row] * 16 + 5] = L2;
4410
monomeLedBuffer[m.rule_dests[edit_row] * 16 + 6] = L0;
4411
}
4412
else {
4413
monomeLedBuffer[m.rule_dests[edit_row] * 16 + 4] = L2;
4414
monomeLedBuffer[m.rule_dests[edit_row] * 16 + 5] = L2;
4415
monomeLedBuffer[m.rule_dests[edit_row] * 16 + 6] = L0;
4416
}
4417
4422
for(i1=0;i1<8;i1++) {
4423
i3 = sign[m.rules[edit_row]][i1];
4424
for(i2=0;i2<8;i2++) {
4425
if((i3 & (1<<i2)) != 0)
4426
monomeLedBuffer[i1*16 + 8 + i2] = L2;
4427
}
4428
}
4429
}
4443
4444
4445
////////////////////////////////////////////////////////////////////////////////
4446
// ES
4447
4448
es_mode_t es_mode;
4449
es_view_t es_view;
4450
u8 es_runes, es_edge, es_voices;
4451
4452
u32 es_tick;
4453
u16 es_pos;
4454
u8 es_blinker;
4455
es_note_t es_notes[4];
4456
u32 es_p_start, es_p_total;
4457
u8 es_ignore_arm_release;
4458
4459
softTimer_t es_blinker_timer = { .next = NULL, .prev = NULL };
4460
softTimer_t es_play_timer = { .next = NULL, .prev = NULL };
4461
softTimer_t es_play_pos_timer = { .next = NULL, .prev = NULL };
4462
4463
static void es_blinker_callback(void* o) {
4464
if (ansible_mode != mGridES) {
4465
timer_remove(&es_blinker_timer);
4466
return;
4467
}
4468
4469
es_blinker = !es_blinker;
4470
if (es_mode == es_recording) monomeFrameDirty++;
4471
}
4472
4473
static void es_note_off_i(u8 i) {
4474
//if (!es_notes[i].active) return;
4475
es_notes[i].active = 0;
4476
timer_remove(&auxTimer[i]);
4477
clr_tr(TR1 + i);
4478
}
4479
4480
static void es_note_off(s8 x, s8 y) {
4481
for (u8 i = 0; i < 4; i++)
4482
if (es_notes[i].x == x && es_notes[i].y == y) {
4483
es_note_off_i(i);
4484
//break;
4485
}
4486
}
4487
4488
static void es_note_off_callback(void* o) {
4489
u8 i = (intptr_t)o;
4490
timer_remove(&auxTimer[i]);
4491
es_note_off_i(i);
4492
monomeFrameDirty++;
4493
}
4494
4495
static void es_kill_all_notes(void) {
4496
for (u8 i = 0; i < 4; i++) es_note_off_i(i);
4497
monomeFrameDirty++;
4498
}
4499
4500
static void es_note_on(s8 x, s8 y, u8 from_pattern, u16 timer, u8 voices) {
4501
u8 note = 255;
4502
for (u8 i = 0; i < 4; i++)
4503
if ((voices & (1 << i)) && (!es_notes[i].active || (es_notes[i].x == x && es_notes[i].y == y))) {
4504
note = i;
4505
break;
4506
}
4507
4508
if (note == 255) {
4509
u32 earliest = 0xffffffff;
4510
for (u8 i = 0; i < 4; i++)
4511
if ((voices & (1 << i)) && es_notes[i].start < earliest) {
4512
earliest = es_notes[i].start;
4513
note = i;
4514
}
4515
}
4516
4517
if (note == 255) return;
4518
4519
es_note_off_i(note);
4520
4521
es_notes[note].active = 1;
4522
es_notes[note].x = x;
4523
es_notes[note].y = y;
4524
es_notes[note].start = get_ticks();
4525
es_notes[note].from_pattern = from_pattern;
4526
4527
s16 note_index = x + (7 - y) * 5 - 1;
4528
if (note_index < 0)
4529
note_index = 0;
4530
else if (note_index > 119)
4531
note_index = 119;
4533
dac_update_now();
4534
set_tr(TR1 + note);
4535
4536
if (timer) timer_add(&auxTimer[note], timer, &es_note_off_callback, (void *)(intptr_t)note);
4537
}
4538
4539
/*
4540
static void es_update_pitches(void) {
4541
u8 first_note_x = e.p[e.p_select].e[0].index & 15;
4542
u8 first_note_y = e.p[e.p_select].e[0].index >> 4;
4543
4544
s16 x, y, note_index;
4545
for (u8 i = 0; i < 4; i++) {
4546
es_notes[i].x = x = es_notes[i].x + e.p[e.p_select].root_x - first_note_x;
4547
es_notes[i].y = y = es_notes[i].y + e.p[e.p_select].root_y - first_note_y;
4548
note_index = x + (7 - y) * 5 - 1;
4549
if (note_index < 0)
4550
note_index = 0;
4551
else if (note_index > 119)
4552
note_index = 119;
4554
dac_update_now();
4555
}
4556
}
4557
*/
4558
4559
static void es_complete_recording(void) {
4560
if (!e.p[e.p_select].length) return;
4561
4562
e.p[e.p_select].e[e.p[e.p_select].length - 1].interval = get_ticks() - es_tick;
4563
4564
for (u16 i = 0; i < e.p[e.p_select].length; i++) {
4565
if (e.p[e.p_select].e[i].interval > ES_CHORD_THRESHOLD) {
4566
e.p[e.p_select].interval_ind = i;
4567
break;
4568
}
4569
}
4570
}
4571
4572
static void es_record_pattern_note(u8 x, u8 y, u8 on) {
4573
u16 l = e.p[e.p_select].length;
4574
if (l >= ES_EVENTS_PER_PATTERN) {
4575
es_complete_recording(); // will update interval for the last event
4576
return;
4577
}
4578
4579
if (!l) {
4580
e.p[e.p_select].root_x = x;
4581
e.p[e.p_select].root_y = y;
4582
}
4583
4584
if (l) e.p[e.p_select].e[l - 1].interval = get_ticks() - es_tick;
4585
es_tick = get_ticks();
4586
4587
e.p[e.p_select].e[l].index = x + (y << 4);
4588
if (x == 15 && y == 0) // rest
4589
e.p[e.p_select].e[l].on = on ? 3 : 2;
4590
else
4591
e.p[e.p_select].e[l].on = on ? 1 : 0;
4592
e.p[e.p_select].length++;
4593
}
4594
4595
static void es_play_pattern_note(void) {
4596
u16 i = e.p[e.p_select].dir ? e.p[e.p_select].length - 1 : 0;
4597
u8 first_note_x = e.p[e.p_select].e[i].index & 15;
4598
u8 first_note_y = e.p[e.p_select].e[i].index >> 4;
4599
s16 x = (e.p[e.p_select].e[es_pos].index & 15) + e.p[e.p_select].root_x - first_note_x;
4600
s16 y = (e.p[e.p_select].e[es_pos].index >> 4) + e.p[e.p_select].root_y - first_note_y;
4601
4602
if (e.p[e.p_select].e[es_pos].on == 1)
4603
es_note_on(x, y, 1,
4604
e.p[e.p_select].edge == ES_EDGE_FIXED ? e.p[e.p_select].edge_time : 0,
4605
e.p[e.p_select].voices);
4606
else if (e.p[e.p_select].e[es_pos].on == 0 && e.p[e.p_select].edge == ES_EDGE_PATTERN)
4607
es_note_off(x, y);
4608
monomeFrameDirty++;
4609
}
4610
4611
static void es_kill_pattern_notes(void) {
4612
for (u8 i = 0; i < 4; i++)
4613
if (es_notes[i].from_pattern) es_note_off_i(i);
4614
monomeFrameDirty++;
4615
}
4616
4617
static void es_update_total_time(void) {
4618
u16 interval;
4619
es_p_total = 0;
4620
for (u16 i = 0; i < e.p[e.p_select].length; i++) {
4621
interval = e.p[e.p_select].e[i].interval;
4622
if (e.p[e.p_select].linearize) {
4623
if (interval < ES_CHORD_THRESHOLD)
4624
interval = 1;
4625
else
4626
interval = e.p[e.p_select].e[e.p[e.p_select].interval_ind].interval;
4627
}
4628
es_p_total += interval;
4629
}
4630
}
4631
4632
static void es_play_pos_callback(void* o) {
4633
if (ansible_mode != mGridES) {
4634
timer_remove(&es_play_pos_timer);
4635
return;
4636
}
4637
4638
if (es_mode == es_playing) monomeFrameDirty++;
4639
}
4640
4641
static u8 es_next_note(void) {
4642
if (++es_pos >= e.p[e.p_select].length) {
4643
es_pos = 0;
4644
es_p_start = get_ticks();
4645
if (!e.p[e.p_select].loop) {
4646
es_kill_pattern_notes();
4647
timer_remove(&es_play_pos_timer);
4648
es_mode = es_stopped;
4649
return 1;
4650
}
4651
}
4652
return 0;
4653
}
4654
4655
static void es_play_callback(void* o) {
4656
timer_remove(&es_play_timer);
4657
if (ansible_mode != mGridES) {
4658
es_mode = es_stopped;
4659
return;
4660
}
4661
4662
if (clock_external) return;
4663
4664
if (es_next_note()) return;
4665
4666
u16 interval = e.p[e.p_select].e[es_pos].interval;
4667
if (e.p[e.p_select].linearize) {
4668
if (interval < ES_CHORD_THRESHOLD)
4669
interval = 1;
4670
else
4671
interval = e.p[e.p_select].e[e.p[e.p_select].interval_ind].interval;
4672
}
4673
if (!interval) interval = 1;
4674
timer_add(&es_play_timer, interval, &es_play_callback, NULL);
4675
es_play_pattern_note();
4676
}
4677
4678
static void es_stop_playback(void) {
4679
timer_remove(&es_play_timer);
4680
timer_remove(&es_play_pos_timer);
4681
es_mode = es_stopped;
4682
es_kill_pattern_notes();
4683
}
4684
4685
static void es_start_playback(u8 pos) {
4686
if (es_mode == es_playing) es_stop_playback();
4687
else if (es_mode == es_recording) es_complete_recording();
4688
4689
if (!e.p[e.p_select].length) {
4690
es_mode = es_stopped;
4691
monomeFrameDirty++;
4692
return;
4693
}
4694
4695
if (es_mode == es_playing) es_kill_pattern_notes();
4696
es_mode = es_playing;
4697
4698
u32 interval;
4699
4700
if (pos) {
4701
u32 start = (es_p_total * pos) >> 4;
4702
u32 tick = 0;
4703
for (es_pos = 0; es_pos < e.p[e.p_select].length; es_pos++) {
4704
interval = e.p[e.p_select].e[es_pos].interval;
4705
if (e.p[e.p_select].linearize) {
4706
if (interval < ES_CHORD_THRESHOLD)
4707
interval = 1;
4708
else
4709
interval = e.p[e.p_select].e[e.p[e.p_select].interval_ind].interval;
4710
}
4711
if (tick + interval > start) break;
4712
tick += interval;
4713
}
4714
if (es_pos >= e.p[e.p_select].length) {
4715
es_pos = e.p[e.p_select].length - 1;
4716
interval = 1;
4717
} else {
4718
interval = tick + interval - start;
4719
if (!interval) interval = 1;
4720
}
4721
4722
if (clock_external) return;
4723
4724
es_p_start = get_ticks() - start;
4725
timer_add(&es_play_pos_timer, 25, &es_play_pos_callback, NULL);
4726
timer_add(&es_play_timer, interval, &es_play_callback, NULL );
4727
return;
4728
}
4729
4730
es_pos = 0;
4731
es_p_start = get_ticks();
4732
es_update_total_time();
4733
4734
if (clock_external) return;
4735
4736
interval = e.p[e.p_select].e[0].interval;
4737
if (e.p[e.p_select].linearize) {
4738
if (interval < ES_CHORD_THRESHOLD)
4739
interval = 1;
4740
else
4741
interval = e.p[e.p_select].e[e.p[e.p_select].interval_ind].interval;
4742
}
4743
if (!interval) interval = 1;
4744
timer_add(&es_play_pos_timer, 25, &es_play_pos_callback, NULL);
4745
timer_add(&es_play_timer, interval, &es_play_callback, NULL );
4746
es_play_pattern_note();
4747
}
4748
4749
static void es_start_recording(void) {
4750
e.p[e.p_select].length = 0;
4751
e.p[e.p_select].start = 0;
4752
e.p[e.p_select].end = 15;
4753
e.p[e.p_select].dir = 0;
4754
es_mode = es_recording;
4755
monomeFrameDirty++;
4756
}
4757
4758
static u8 is_arm_pressed(void) {
4759
u8 found = 0;
4760
for (u8 i = 0; i < key_count; i++) {
4761
if (held_keys[i] == 32) found = 1;
4762
break;
4763
}
4764
return found;
4765
}
4766
4767
/*
4768
static s8 top_row_pressed(void) {
4769
s8 found = -1;
4770
for (u8 i = 0; i < key_count; i++) {
4771
if (held_keys[i] < 16) {
4772
found = held_keys[i];
4773
break;
4774
}
4775
}
4776
return found;
4777
}
4778
*/
4779
4780
static u8 rest_pressed(void) {
4781
for (u8 i = 0; i < key_count; i++) {
4782
if (held_keys[i] == 15) return 1;
4783
}
4784
return 0;
4785
}
4786
4787
static void es_prev_pattern(void) {
4788
if (!e.p_select) return;
4789
e.p_select--;
4790
es_start_playback(0);
4791
}
4792
4793
static void es_next_pattern(void) {
4794
if (e.p_select >= 15) return;
4795
e.p_select++;
4796
es_start_playback(0);
4797
}
4798
4799
static void es_double_speed(void) {
4800
for (u16 i = 0; i < e.p[e.p_select].length; i++) {
4801
if (e.p[e.p_select].e[i].interval > (ES_CHORD_THRESHOLD << 1))
4802
e.p[e.p_select].e[i].interval >>= 1;
4803
else if (e.p[e.p_select].e[i].interval > ES_CHORD_THRESHOLD)
4804
e.p[e.p_select].e[i].interval = ES_CHORD_THRESHOLD + 1;
4805
}
4806
es_update_total_time();
4807
}
4808
4809
static void es_half_speed(void) {
4810
u16 interval;
4811
for (u16 i = 0; i < e.p[e.p_select].length; i++)
4812
if (e.p[e.p_select].e[i].interval > ES_CHORD_THRESHOLD) {
4813
interval = e.p[e.p_select].e[i].interval << 1;
4814
if (interval > e.p[e.p_select].e[i].interval) e.p[e.p_select].e[i].interval = interval;
4815
}
4816
es_update_total_time();
4817
}
4818
4819
static void es_reverse(void) {
4820
u16 l = e.p[e.p_select].length;
4821
if (!l) return;
4822
4823
es_event_t te[ES_EVENTS_PER_PATTERN];
4824
4825
for (u16 i = 0; i < l; i++) {
4826
te[i] = e.p[e.p_select].e[i];
4827
if (te[i].on == 3)
4828
te[i].on = 2;
4829
else if (te[i].on == 2)
4830
te[i].on = 3;
4831
else if (te[i].on == 1)
4832
te[i].on = 0;
4833
else if (te[i].on == 0)
4834
te[i].on = 1;
4835
}
4836
4837
for (u16 i = 0; i < l; i++)
4838
e.p[e.p_select].e[i] = te[l - i - 1];
4839
for (u16 i = 0; i < l - 1; i++)
4840
e.p[e.p_select].e[i].interval = te[l - i - 2].interval;
4841
4842
e.p[e.p_select].e[l - 1].interval = te[l - 1].interval;
4843
4844
if (e.p[e.p_select].dir) {
4845
for (s16 i = e.p[e.p_select].length - 1; i >= 0; i--)
4846
if ((e.p[e.p_select].e[i].on == 3 || e.p[e.p_select].e[i].on == 1)
4847
&& e.p[e.p_select].e[i].interval > ES_CHORD_THRESHOLD) {
4848
e.p[e.p_select].interval_ind = i;
4849
break;
4850
}
4851
} else {
4852
for (u16 i = 0; i < e.p[e.p_select].length; i++)
4853
if ((e.p[e.p_select].e[i].on == 3 || e.p[e.p_select].e[i].on == 1)
4854
&& e.p[e.p_select].e[i].interval > ES_CHORD_THRESHOLD) {
4855
e.p[e.p_select].interval_ind = i;
4856
break;
4857
}
4858
}
4859
}
4860
4861
// init functions
4862
4863
void default_es(void) {
4864
uint8_t i;
4865
flashc_memset8((void*)&(f.es_state.preset), 0, 1, true);
4866
for (i = 0; i < 8; i++) {
4867
e.arp = 0;
4868
e.p_select = 0;
4869
e.voices = 0b1111;
4870
e.octave = 0;
4871
for (u8 j = 0; j < 128; j++)
4872
e.keymap[i] = 0;
4873
e.scale = 16;
4874
for (u8 j = 0; j < 16; j++) {
4875
e.p[i].interval_ind = 0;
4876
e.p[i].length = 0;
4877
e.p[i].loop = 0;
4878
e.p[i].edge = ES_EDGE_PATTERN;
4879
e.p[i].edge_time = 16;
4880
e.p[i].voices = 0b1111;
4881
e.p[i].dir = 0;
4882
e.p[i].linearize = 0;
4883
e.p[i].start = 0;
4884
e.p[i].end = 15;
4885
}
4886
e.glyph[i] = 0;
4887
}
4888
for (i = 0; i < GRID_PRESETS; i++)
4889
flashc_memcpy((void *)&f.es_state.e[i], &e, sizeof(e), true);
4890
}
4891
4892
void init_es(void) {
4893
preset = f.es_state.preset;
4894
e = f.es_state.e[preset];
4895
es_mode = es_stopped;
4896
es_view = es_main;
4897
4898
memcpy(scale_data, f.scale, sizeof(scale_data));
4899
if (e.scale < 16) calc_scale(e.scale);
4900
}
4901
4902
void resume_es(void) {
4903
es_mode = es_stopped;
4904
es_view = es_main;
4905
4906
preset_mode = false;
4907
grid_refresh = &refresh_es;
4908
4909
// re-check clock jack
4910
clock_external = !gpio_get_pin_value(B10);
4911
clock = &clock_null;
4912
4914
for (u8 i = 0; i < 4; i++) {
4915
es_notes[i].active = 0;
4916
}
4917
4918
timer_remove(&es_blinker_timer);
4919
timer_add(&es_blinker_timer, 288, &es_blinker_callback, NULL);
4920
timer_remove(&es_play_timer);
4921
timer_remove(&es_play_pos_timer);
4922
4923
monomeFrameDirty++;
4924
}
4925
4926
static void es_load_preset(void) {
4927
flashc_memset8((void*)&(f.es_state.preset), preset, 1, true);
4928
init_es();
4929
resume_es();
4930
}
4931
4932
// handlers
4933
4934
void handler_ESRefresh(s32 data) {
4935
if(monomeFrameDirty) {
4936
grid_refresh();
4937
monome_set_quadrant_flag(0);
4938
monome_set_quadrant_flag(1);
4939
(*monome_refresh)();
4940
}
4941
}
4942
4943
void handler_ESKey(s32 data) {
4944
switch(data) {
4945
case 0: // button 1 released
4946
break;
4947
case 1: // button 1 pressed
4948
es_prev_pattern();
4949
break;
4950
case 2: // button 2 released
4951
es_next_pattern();
4952
break;
4953
case 3: // button 2 released
4954
break;
4955
default:
4956
break;
4957
}
4958
}
4959
4960
void handler_ESTr(s32 data) {
4961
u8 i;
4962
switch(data) {
4963
case 0: // input 1 low
4964
break;
4965
case 1: // input 1 high
4966
if (es_mode != es_playing) break;
4967
i = e.p[e.p_select].length;
4968
while (i > 0) {
4969
i--;
4970
es_play_pattern_note();
4971
if (e.p[e.p_select].e[es_pos].interval > ES_CHORD_THRESHOLD) break;
4972
if (++es_pos >= e.p[e.p_select].length) {
4973
es_pos--;
4974
break;
4975
}
4976
}
4977
if (++es_pos >= e.p[e.p_select].length) {
4978
es_pos = 0;
4979
if (!e.p[e.p_select].loop) {
4980
es_kill_pattern_notes();
4981
es_mode = es_stopped;
4982
}
4983
}
4984
break;
4985
case 2: // input 2 low
4986
break;
4987
case 3: // input 2 high
4988
if (es_mode != es_armed && es_mode != es_recording) es_start_playback(0);
4989
break;
4990
default:
4991
break;
4992
}
4993
}
4994
4995
void handler_ESTrNormal(s32 data) {
4996
clock_external = data;
4997
if (es_mode != es_playing) return;
4998
4999
es_kill_pattern_notes();
5000
if (clock_external) {
5001
timer_remove(&es_play_timer);
5002
timer_remove(&es_play_pos_timer);
5003
} else {
5004
timer_add(&es_play_pos_timer, 25, &es_play_pos_callback, NULL);
5005
es_play_callback(NULL);
5006
}
5007
}
5008
5009
void handler_ESGridKey(s32 data) {
5010
u8 x, y, z;
5011
monome_grid_key_parse_event_data(data, &x, &y, &z);
5012
u8 index = (y << 4) + x;
5013
5014
// track held keys and long presses
5015
if (z) {
5016
held_keys[key_count] = index;
5017
if (key_count < MAX_HELD_KEYS) key_count++;
5018
key_times[index] = 10;
5019
} else {
5020
u8 found = 0;
5021
for (u8 i = 0; i < key_count; i++) {
5022
if (held_keys[i] == index) found++;
5023
if (found) held_keys[i] = held_keys[i + 1];
5024
}
5025
if (found) key_count--;
5026
}
5027
5028
// preset screen
5029
if (preset_mode) {
5030
preset_mode_handle_key(x, y, z, e.glyph);
5031
if (z == 0) {
5032
if (x == 0 && !follower_select) {
5033
if (y != preset) {
5034
preset = y;
5035
for (u8 i = 0; i < GRID_PRESETS; i++)
5036
e.glyph[i] = f.es_state.e[preset].glyph[i];
5037
} else {
5038
// flash read
5039
es_load_preset();
5040
}
5041
}
5042
}
5043
5044
monomeFrameDirty++;
5045
return;
5046
}
5047
5048
if (x == 0) {
5049
if (z && y == 0) { // start/stop
5050
if (es_view == es_patterns_held) {
5051
es_view = es_patterns;
5052
} else if (es_mode == es_stopped || es_mode == es_armed) {
5053
es_start_playback(0);
5054
if (is_arm_pressed()) es_ignore_arm_release = 1;
5055
} else if (es_mode == es_recording) {
5056
e.p[e.p_select].loop = 1;
5057
es_start_playback(0);
5058
} else if (es_mode == es_playing) {
5059
if (is_arm_pressed()) {
5060
es_start_playback(0);
5061
es_ignore_arm_release = 1;
5062
} else
5063
es_stop_playback();
5064
}
5065
} else if (y == 1) { // p_select
5066
if (z && es_mode == es_recording) {
5067
es_complete_recording();
5068
es_mode = es_stopped;
5069
}
5070
if (z && es_view == es_patterns)
5071
es_view = es_main;
5072
else if (z && es_view == es_main)
5073
es_view = es_patterns_held;
5074
else if (!z && es_view == es_patterns_held)
5075
es_view = es_main;
5076
} else if (y == 2) { // arm
5077
es_view = es_main;
5078
if (z) {
5079
if (es_mode == es_armed) {
5080
es_mode = es_stopped;
5081
es_ignore_arm_release = 1;
5082
} else if (es_mode == es_recording) {
5083
es_complete_recording();
5084
es_mode = es_stopped;
5085
es_ignore_arm_release = 1;
5086
}
5087
} else {
5088
if (es_ignore_arm_release) {
5089
es_ignore_arm_release = 0;
5090
return;
5091
}
5092
if (es_mode == es_stopped) {
5093
es_mode = es_armed;
5094
} else if (es_mode == es_playing) {
5095
es_stop_playback();
5096
es_mode = es_armed;
5097
}
5098
}
5099
} else if (z && y == 3) { // loop
5100
e.p[e.p_select].loop = !e.p[e.p_select].loop;
5101
} else if (z && y == 4) { // arp
5102
e.arp = !e.arp;
5103
} else if (y == 5) { // edge mode
5104
es_edge = z;
5105
} else if (y == 6) { // runes
5106
es_runes = z;
5107
} else if (y == 7) { // voices
5108
es_voices = z;
5109
}
5110
5111
if (!es_edge) {
5112
monomeFrameDirty++;
5113
return;
5114
}
5115
}
5116
5117
if (es_runes) {
5118
if (!z) return;
5119
5120
if (x > 1 && x < 5 && y > 1 && y < 5) {
5121
e.p[e.p_select].linearize = !e.p[e.p_select].linearize;
5122
es_update_total_time();
5123
} else if (x > 5 && x < 8 && y > 1 && y < 5) {
5124
if (e.p[e.p_select].dir != 1) es_reverse();
5125
e.p[e.p_select].dir = 1;
5126
if (es_mode == es_playing) es_kill_pattern_notes();
5127
} else if (x > 8 && x < 11 && y > 1 && y < 5) {
5128
if (e.p[e.p_select].dir != 0) es_reverse();
5129
e.p[e.p_select].dir = 0;
5130
if (es_mode == es_playing) es_kill_pattern_notes();
5131
} else if (x > 11 && x < 15 && y > 0 && y < 3)
5132
es_double_speed();
5133
else if (x > 11 && x < 15 && y > 3 && y < 6)
5134
es_half_speed();
5135
5136
monomeFrameDirty++;
5137
return;
5138
}
5139
5140
if (es_edge) {
5141
if (!z) return;
5142
5143
if (y == 7) {
5144
e.p[e.p_select].edge = ES_EDGE_FIXED;
5145
e.p[e.p_select].edge_time = (x + 1) << 4;
5146
es_kill_all_notes();
5147
} else {
5148
if (x) {
5149
if (x < 6) {
5150
e.p[e.p_select].edge = ES_EDGE_PATTERN;
5151
es_kill_all_notes();
5152
} else if (x < 11) {
5153
e.p[e.p_select].edge = ES_EDGE_FIXED;
5154
es_kill_all_notes();
5155
} else {
5156
e.p[e.p_select].edge = ES_EDGE_DRONE;
5157
}
5158
}
5159
}
5160
5161
monomeFrameDirty++;
5162
return;
5163
}
5164
5165
if (es_voices) {
5166
if (!z) return;
5167
5168
u8 voice = 1 << (y - 2);
5169
if (x == 3 && y > 1 && y < 6) {
5170
// if (e.voices && voice) es_note_off_i(y - 2);
5171
e.voices ^= voice;
5172
} else if (x == 2 && y > 1 && y < 6) {
5173
// if (e.p[e.p_select].voices && voice) es_note_off_i(y - 2);
5174
e.p[e.p_select].voices ^= voice;
5175
} else if (y == 7 && x == 2 && e.octave) {
5176
e.octave--;
5177
} else if (y == 7 && x == 3 && e.octave < 5) {
5178
e.octave++;
5179
}
5180
es_kill_all_notes();
5181
monomeFrameDirty++;
5182
return;
5183
}
5184
5185
if (es_view == es_patterns_held || es_view == es_patterns) {
5186
if (!z) return;
5187
5188
if (x > 7 && y > 2 && y < 5) {
5189
// scale selection
5190
u8 scale = x - 8 + ((y - 3) << 3);
5191
if (scale == e.scale)
5192
e.scale = 16;
5193
else {
5194
e.scale = scale;
5195
calc_scale(e.scale);
5196
}
5197
monomeFrameDirty++;
5198
}
5199
5200
if (x < 2 || x > 5 || y < 2 || y > 5) return;
5201
e.p_select = (x - 2) + ((y - 2) << 2);
5202
if (es_view == es_patterns) es_start_playback(0);
5203
monomeFrameDirty++;
5204
return;
5205
}
5206
5207
if (y == 0 && es_mode == es_playing) {
5208
if (!z) return;
5209
es_start_playback(e.p[e.p_select].dir ? 15 - x : x);
5210
/*
5211
s8 start = top_row_pressed();
5212
if (start == -1 || start == x) {
5213
es_start_playback(x);
5214
} else {
5215
e.p[e.p_select].start = min(x, start);
5216
e.p[e.p_select].end = max(x, start);
5217
}
5218
*/
5219
monomeFrameDirty++;
5220
return;
5221
}
5222
5223
if (x == 0) return;
5224
5225
if (es_mode == es_armed) es_start_recording(); // will change es_mode to es_recording
5226
if (es_mode == es_recording) es_record_pattern_note(x, y, z);
5227
5228
if (e.arp && es_mode != es_recording) {
5229
if (!z) return;
5230
e.p[e.p_select].root_x = x;
5231
e.p[e.p_select].root_y = y;
5232
es_start_playback(0);
5233
// es_update_pitches();
5234
} else if (es_mode == es_stopped && rest_pressed() && z) {
5235
// keymap
5236
e.keymap[(y << 4) + x] = (e.keymap[(y << 4) + x] + 1) % 3;
5237
} else {
5238
if (e.p[e.p_select].edge == ES_EDGE_DRONE) {
5239
if (z) {
5240
u8 found = 0;
5241
for (u8 i = 0; i < 4; i++)
5242
if (x == es_notes[i].x && y == es_notes[i].y && es_notes[i].active) {
5243
es_note_off(x, y);
5244
found = 1;
5245
}
5246
if (!found) es_note_on(x, y, 0, 0, e.voices);
5247
}
5248
} else {
5249
if (z) {
5250
if (x != 15 || y != 0)
5251
es_note_on(x, y, 0, 0, es_mode == es_recording ? e.p[e.p_select].voices : e.voices);
5252
} else es_note_off(x, y);
5253
}
5254
}
5255
5256
monomeFrameDirty++;
5257
}
5258
5259
void refresh_es(void) {
5260
memset(monomeLedBuffer, 0, MONOME_MAX_LED_BYTES);
5261
5262
for (u8 i = 0; i < 8; i++)
5263
monomeLedBuffer[i << 4] = 2;
5264
5265
if (es_mode == es_playing)
5266
monomeLedBuffer[0] = 15;
5267
else if (e.p[e.p_select].length)
5268
monomeLedBuffer[0] = 8;
5269
5270
if (es_view == es_patterns) monomeLedBuffer[16] = 15;
5271
5272
if (es_mode == es_recording)
5273
monomeLedBuffer[32] = 11 + (es_blinker ? 0 : 4);
5274
else if (es_mode == es_armed)
5275
monomeLedBuffer[32] = 7;
5276
5277
if (e.p[e.p_select].loop) monomeLedBuffer[48] = 11;
5278
if (e.arp) monomeLedBuffer[64] = 11;
5279
5280
if (es_mode == es_playing) {
5281
//for (u8 i = e.p[e.p_select].start; i <= e.p[e.p_select].end; i++)
5282
// monomeLedBuffer[i] = 4;
5283
u8 pos;
5284
if (clock_external)
5285
pos = e.p[e.p_select].length ? (es_pos << 4) / (e.p[e.p_select].length - 1) : 0;
5286
else
5287
pos = ((get_ticks() - es_p_start) << 4) / es_p_total;
5288
if (e.p[e.p_select].dir) pos = 15 - pos;
5289
for (u8 i = 1; i < 16; i++)
5290
if (i <= pos) monomeLedBuffer[i] = 8;
5291
}
5292
5293
u8 l;
5294
if (es_runes) {
5295
l = e.p[e.p_select].linearize ? 15 : 7;
5296
5297
// linearize
5298
monomeLedBuffer[34] = l;
5299
monomeLedBuffer[36] = l;
5300
monomeLedBuffer[66] = l;
5301
monomeLedBuffer[68] = l;
5302
5303
l = e.p[e.p_select].dir ? 15 : 7;
5304
// reverse
5305
monomeLedBuffer[39] = l;
5306
monomeLedBuffer[54] = l;
5307
monomeLedBuffer[71] = l;
5308
5309
l = e.p[e.p_select].dir ? 7 : 15;
5310
// forward
5311
monomeLedBuffer[41] = l;
5312
monomeLedBuffer[58] = l;
5313
monomeLedBuffer[73] = l;
5314
5315
l = 8;
5316
// double speed
5317
monomeLedBuffer[29] = l;
5318
monomeLedBuffer[44] = l;
5319
monomeLedBuffer[46] = l;
5320
5321
// half speed
5322
monomeLedBuffer[76] = l;
5323
monomeLedBuffer[78] = l;
5324
monomeLedBuffer[93] = l;
5325
5326
return;
5327
}
5328
5329
if (es_edge) {
5330
l = e.p[e.p_select].edge == ES_EDGE_PATTERN ? 15 : 7;
5331
monomeLedBuffer[34] = l;
5332
monomeLedBuffer[35] = l;
5333
monomeLedBuffer[36] = l;
5334
monomeLedBuffer[50] = l;
5335
monomeLedBuffer[52] = l;
5336
monomeLedBuffer[66] = l;
5337
monomeLedBuffer[68] = l;
5338
monomeLedBuffer[82] = l;
5339
monomeLedBuffer[84] = l;
5340
monomeLedBuffer[85] = l;
5341
5342
l = e.p[e.p_select].edge == ES_EDGE_FIXED ? 15 : 7;
5343
monomeLedBuffer[39] = l;
5344
monomeLedBuffer[40] = l;
5345
monomeLedBuffer[41] = l;
5346
monomeLedBuffer[42] = l;
5347
monomeLedBuffer[55] = l;
5348
monomeLedBuffer[58] = l;
5349
monomeLedBuffer[71] = l;
5350
monomeLedBuffer[74] = l;
5351
monomeLedBuffer[87] = l;
5352
monomeLedBuffer[90] = l;
5353
5354
l = e.p[e.p_select].edge == ES_EDGE_DRONE ? 15 : 7;
5355
monomeLedBuffer[44] = l;
5356
monomeLedBuffer[45] = l;
5357
monomeLedBuffer[46] = l;
5358
monomeLedBuffer[47] = l;
5359
5360
if (e.p[e.p_select].edge == ES_EDGE_FIXED) {
5361
for (u8 i = 0; i < 16; i++)
5362
monomeLedBuffer[112 + i] = 4;
5363
u8 edge_index = 111 + (e.p[e.p_select].edge_time >> 4);
5364
if (edge_index <= 127) monomeLedBuffer[edge_index] = 11;
5365
}
5366
5367
return;
5368
}
5369
5370
if (es_voices) {
5371
for (u8 i = 0; i < 4; i++) {
5372
monomeLedBuffer[35 + (i << 4)] = e.voices & (1 << i) ? 15 : 4;
5373
monomeLedBuffer[34 + (i << 4)] = e.p[e.p_select].voices & (1 << i) ? 15 : 4;
5374
}
5375
5376
monomeLedBuffer[e.octave ? 115 : 114] = 10 + e.octave;
5377
return;
5378
}
5379
5380
s16 index, x, y;
5381
if (es_view == es_main) {
5382
if (e.scale == 16) {
5383
for (u8 i = 0; i < 128; i++)
5384
if (e.keymap[i]) monomeLedBuffer[i] = e.keymap[i] << 1;
5385
} else {
5386
u8 in_scale;
5387
for (x = 1; x < 16; x++)
5388
for (y = es_mode == es_playing ? 1 : 0; y < 8; y++) {
5389
index = x + (7 - y) * 5 - 1;
5390
in_scale = 0;
5391
for (u8 sc = 0; sc < 8; sc++) {
5392
for (u8 oct = 0; oct < 5; oct++) {
5393
if (index == cur_scale[sc] + oct * 12) {
5394
monomeLedBuffer[(y << 4) + x] = sc == 0 ? 4 : 2;
5395
in_scale = 1;
5396
break;
5397
}
5398
}
5399
if (in_scale) break;
5400
}
5401
}
5402
}
5403
5404
if (e.arp)
5405
monomeLedBuffer[e.p[e.p_select].root_x + (e.p[e.p_select].root_y << 4)] = 7;
5406
for (u8 i = 0; i < 4; i++)
5407
if (es_notes[i].active) {
5408
x = es_notes[i].x;
5409
y = es_notes[i].y;
5410
while (x < 0) {
5411
y++;
5412
x += 5;
5413
}
5414
while (x > 15) {
5415
y--;
5416
x -= 5;
5417
}
5418
index = (y << 4) + x;
5419
if (index >= 0 && index <= MONOME_MAX_LED_BYTES && (index & 15) != 0)
5420
monomeLedBuffer[index] = 15;
5421
}
5422
} else { // pattern view
5423
for (u8 i = 0; i < 16; i++)
5424
monomeLedBuffer[(i & 3) + 34 + ((i >> 2) << 4)] = e.p[i].length ? 7 : 4;
5425
monomeLedBuffer[(e.p_select & 3) + 34 + ((e.p_select >> 2) << 4)] = 15;
5426
5427
// scale
5428
for (x = 8; x < 16; x++)
5429
for (y = 3; y < 5; y++)
5430
monomeLedBuffer[x + (y << 4)] = 4;
5431
5432
if (e.scale != 16)
5433
monomeLedBuffer[(e.scale & 7) + 8 + ((3 + (e.scale >> 3)) << 4)] = 15;
5434
}
5435
}
5436
5437
void ii_es(uint8_t *data, uint8_t l) {
5438
if (!l) return;
5439
5440
s16 d = (data[1] << 8) | data[2];
5441
u8 value;
5442
5443
switch(data[0]) {
5444
case ES_PRESET:
5445
if (d >= 0 && d < GRID_PRESETS) {
5446
preset = d;
5447
es_load_preset();
5448
monomeFrameDirty++;
5449
}
5450
break;
5451
5452
case ES_PATTERN:
5453
if (d >= 0 && d < 16) {
5454
e.p_select = d;
5455
monomeFrameDirty++;
5456
}
5457
break;
5458
5459
case ES_CLOCK:
5460
value = e.p[e.p_select].length;
5461
while (value > 0) {
5462
value--;
5463
es_play_pattern_note();
5464
if (e.p[e.p_select].e[es_pos].interval > ES_CHORD_THRESHOLD) break;
5465
if (++es_pos >= e.p[e.p_select].length) {
5466
es_pos--;
5467
break;
5468
}
5469
}
5470
if (++es_pos >= e.p[e.p_select].length) {
5471
es_pos = 0;
5472
if (!e.p[e.p_select].loop) {
5473
es_kill_pattern_notes();
5474
es_mode = es_stopped;
5475
}
5476
}
5477
break;
5478
5479
case ES_RESET:
5480
value = d;
5481
if (value > 15) value = 15;
5482
es_start_playback(value);
5483
break;
5484
5485
case ES_STOP:
5486
es_stop_playback();
5487
break;
5488
5489
case ES_TRANS:
5490
if (d > 0) {
5491
for (u8 i = 0; i < d; i++) {
5492
if (e.p[e.p_select].root_y == 1 && e.p[e.p_select].root_x == 15) break;
5493
e.p[e.p_select].root_x++;
5494
if (e.p[e.p_select].root_x == 16)
5495
{
5496
e.p[e.p_select].root_x = 11;
5497
e.p[e.p_select].root_y--;
5498
}
5499
}
5500
} else {
5501
for (u8 i = 0; i < abs(d); i++) {
5502
if (e.p[e.p_select].root_y == 7 && e.p[e.p_select].root_x == 1) break;
5503
e.p[e.p_select].root_x--;
5504
if (e.p[e.p_select].root_x == 0)
5505
{
5506
e.p[e.p_select].root_x = 5;
5507
e.p[e.p_select].root_y++;
5508
}
5509
}
5510
}
5511
es_start_playback(0);
5512
monomeFrameDirty++;
5513
break;
5514
5515
case ES_MAGIC:
5516
switch (d) {
5517
case 1:
5518
es_half_speed();
5519
break;
5520
5521
case 2:
5522
es_double_speed();
5523
break;
5524
5525
case 3:
5526
e.p[e.p_select].linearize = 1;
5527
es_update_total_time();
5528
break;
5529
5530
case 4:
5531
e.p[e.p_select].linearize = 0;
5532
es_update_total_time();
5533
break;
5534
5535
case 5:
5536
if (e.p[e.p_select].dir) es_reverse();
5537
e.p[e.p_select].dir = 0;
5538
if (es_mode == es_playing) es_kill_pattern_notes();
5539
break;
5540
5541
case 6:
5542
if (!e.p[e.p_select].dir) es_reverse();
5543
e.p[e.p_select].dir = 1;
5544
if (es_mode == es_playing) es_kill_pattern_notes();
5545
break;
5546
}
5547
monomeFrameDirty++;
5548
break;
5549
5550
case ES_MODE:
5551
if (d < 0 || d >= 16) {
5552
e.p[e.p_select].edge = ES_EDGE_PATTERN;
5553
es_kill_all_notes();
5554
} else if (d == 0) {
5555
e.p[e.p_select].edge = ES_EDGE_DRONE;
5556
} else {
5557
u8 fixed = d;
5558
if (fixed > 15) fixed = 15;
5559
e.p[e.p_select].edge = ES_EDGE_FIXED;
5560
e.p[e.p_select].edge_time = (fixed + 1) << 4;
5561
es_kill_all_notes();
5562
}
5563
monomeFrameDirty++;
5564
break;