Arpeggino - MIDI Arpeggiator, Sequencer, Recorder and Looper

1#include <Controlino.h>
2#include <LiquidCrystal.h>
3#include <Midier.h>
4
5#include  <assert.h>
6
7namespace arpeggino
8{
9
10namespace utils
11{
12
13struct  Timer
14{
15    // control
16
17    void start() // start (or restart)
18    {
19        _millis = millis();
20    }
21
22    void reset() // restart only if  ticking
23    {
24        if (ticking())
25        {
26            start();
27        }
28    }
29
30    void stop()
31    {
32        _millis = -1;
33    }
34
35    // query
36
37    bool elapsed(unsigned ms) const // only if  ticking
38    {
39        return ticking() && millis() - _millis >= ms;
40    }
41
42    bool ticking() const
43    {
44        return _millis != -1;
45    }
46
47private:
48    unsigned long _millis = -1;
49};
50
51} // utils
52
53namespace state
54{
55
56midier::Layers<8>  layers; // the number of layers chosen will affect the global variable size
57midier::Sequencer  sequencer(layers);
58
59} // state
60
61namespace io
62{
63
64// here we  declare all I/O controls with their corresponding pin numbers
65
66controlino::Selector  Selector(/* s0 = */ 6, /* s1 = */ 5, /* s2 = */ 4, /* s3 = */ 3);
67controlino::Multiplexer  Multiplexer(/* sig = */ 2, Selector);
68
69controlino::Potentiometer BPM(A0, /*  min = */ 20, /* max = */ 230); // we limit the value of BPM to [20,230]
70
71//  all configuration keys are behind the multiplexer
72controlino::Key Note(Multiplexer,  7);
73controlino::Key Mode(Multiplexer, 6);
74controlino::Key Octave(Multiplexer,  5);
75controlino::Key Perm(Multiplexer, 4);
76controlino::Key Steps(Multiplexer,  3);
77controlino::Key Rhythm(Multiplexer, 2);
78
79struct LCD : LiquidCrystal
80{
81    LCD(uint8_t rs, uint8_t e, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7) :  LiquidCrystal(rs, e, d4, d5, d6, d7)
82    {}
83
84    template <typename T>
85    char print(const T & arg)
86    {
87        return LiquidCrystal::print(arg);
88    }
89
90    template <typename T>
91    char print(char col, char row, const  T & arg)
92    {
93        setCursor(col, row);
94        return print(arg);
95    }
96
97    template <typename T>
98    char print(char col, char row, char  max, const T & arg)
99    {
100        const auto written = print(col, row, arg);
101
102        for (unsigned i = 0; i < max - written; ++i)
103        {
104            write('  '); // make sure the non-used characters are clear
105        }
106
107        return  written;
108    }
109};
110
111LCD lcd(/* rs = */ 7, /* e = */ 8,  /* d4 = */ 9,  /* d5 = */ 10, /* d6 = */ 11, /* d7 = */ 12);
112
113} // io
114
115namespace configurer
116{
117
118enum  class Action
119{
120    None,
121
122    Summary,
123    Focus,
124};
125
126//  a configurer is responsible for updating a single configuration
127// parameter  according to changes of an I/O control
128
129struct Configurer
130{
131    Action(*check)();
132    void(*update)();
133};
134
135Configurer BPM =
136    {
137        .check =  []()
138            {
139                if (io::BPM.check() == controlino::Potentiometer::Event::Changed)
140                {
141                    return Action::Summary;
142                }
143
144                return Action::None;
145            },
146        .update = []()
147            {
148                state::sequencer.bpm = io::BPM.read();
149            },
150    };
151
152Configurer Note =
153    {
154        .check = []()
155            {
156                if (io::Note.check() == controlino::Key::Event::Down)
157                {
158                    return Action::Summary;
159                }
160
161                return  Action::None;
162            },
163        .update = []()
164            {
165                auto  & config = state::sequencer.config; // a shortcut
166
167                if (config.accidental()  == midier::Accidental::Flat)
168                {
169                    config.accidental(midier::Accidental::Natural);
170                }
171                else if (config.accidental() == midier::Accidental::Natural)
172                {
173                    config.accidental(midier::Accidental::Sharp);
174                }
175                else if (config.accidental() == midier::Accidental::Sharp)
176                {
177                    config.accidental(midier::Accidental::Flat);
178
179                    if      (config.note() == midier::Note::C) { config.note(midier::Note::D);  }
180                    else if (config.note() == midier::Note::D) { config.note(midier::Note::E);  }
181                    else if (config.note() == midier::Note::E) { config.note(midier::Note::F);  }
182                    else if (config.note() == midier::Note::F) { config.note(midier::Note::G);  }
183                    else if (config.note() == midier::Note::G) { config.note(midier::Note::A);  }
184                    else if (config.note() == midier::Note::A) { config.note(midier::Note::B);  }
185                    else if (config.note() == midier::Note::B) { config.note(midier::Note::C);  }
186                }
187            },
188    };
189
190Configurer Mode =
191    {
192        .check = []()
193            {
194                if (io::Mode.check()  == controlino::Key::Event::Down)
195                {
196                    return  Action::Focus;
197                }
198
199                return Action::None;
200            },
201        .update = []()
202            {
203                const  auto current = state::sequencer.config.mode();
204                const auto next  = (midier::Mode)(((unsigned)current + 1) % (unsigned)midier::Mode::Count);
205
206                state::sequencer.config.mode(next);
207            },
208    };
209
210Configurer  Octave =
211    {
212        .check = []()
213            {
214                if  (io::Octave.check() == controlino::Key::Event::Down)
215                {
216                    return  Action::Summary;
217                }
218
219                return Action::None;
220            },
221        .update = []()
222            {
223                const  auto current = state::sequencer.config.octave();
224                const auto next  = (current % 7) + 1;
225
226                state::sequencer.config.octave(next);
227            },
228    };
229
230Configurer Perm =
231    {
232        .check = []()
233            {
234                if (io::Perm.check() == controlino::Key::Event::Down)
235                {
236                    return Action::Focus;
237                }
238
239                return Action::None;
240            },
241        .update = []()
242            {
243                const auto current = state::sequencer.config.perm();
244                const auto next = (current + 1) % midier::style::count(state::sequencer.config.steps());
245
246                state::sequencer.config.perm(next);
247            },
248    };
249
250Configurer  Steps =
251    {
252        .check = []()
253            {
254                if  (io::Steps.check() == controlino::Key::Event::Down)
255                {
256                    return  Action::Focus;
257                }
258
259                return Action::None;
260            },
261        .update = []()
262            {
263                auto  & config = state::sequencer.config; // a shortcut
264
265                if (config.looped()  == false) // we set to loop if currently not looping
266                {
267                    config.looped(true);
268                }
269                else
270                {
271                    unsigned  steps = config.steps() + 1;
272
273                    if (steps > 6)
274                    {
275                        steps = 3;
276                    }
277
278                    config.steps(steps);
279                    config.perm(0); // reset the permutation
280                    config.looped(false);  // set as non looping
281                }
282            },
283    };
284
285Configurer  Rhythm =
286    {
287        .check = []()
288            {
289                if  (io::Rhythm.check() == controlino::Key::Event::Down)
290                {
291                    return  Action::Focus;
292                }
293
294                return Action::None;
295            },
296        .update = []()
297            {
298                const  auto current = state::sequencer.config.rhythm();
299                const auto next  = (midier::Rhythm)(((unsigned)current + 1) % (unsigned)midier::Rhythm::Count);
300
301                state::sequencer.config.rhythm(next);
302            }
303    };
304
305}  // configurer
306
307namespace viewer
308{
309
310enum class What
311{
312    Title,
313    Data,
314};
315
316enum class How
317{
318    Summary,
319    Focus,
320};
321
322using  Viewer = void(*)(What, How);
323
324struct : utils::Timer
325{
326    // query
327    bool operator==(Viewer other) const { return _viewer == other; }
328    bool  operator!=(Viewer other) const { return _viewer != other; }
329
330    // assignment
331    void operator=(Viewer other) { _viewer = other; }
332
333    // access
334    void  print(What what, How how) { _viewer(what, how); }
335
336private:
337    Viewer  _viewer = nullptr;
338} focused;
339
340void BPM(What what, How how)
341{
342    assert(how  == How::Summary);
343
344    if (what == What::Title)
345    {
346        io::lcd.print(13,  1, "bpm");
347    }
348
349    if (what == What::Data)
350    {
351        io::lcd.print(9,  1, 3, state::sequencer.bpm);
352    }
353}
354
355void Note(What what, How how)
356{
357    assert(how == How::Summary);
358
359    if (what == What::Data)
360    {
361        io::lcd.setCursor(0, 0);
362
363        const auto & config = state::sequencer.config;  // a shortcut
364
365        if      (config.note() == midier::Note::A) { io::lcd.print('A');  }
366        else if (config.note() == midier::Note::B) { io::lcd.print('B'); }
367        else if (config.note() == midier::Note::C) { io::lcd.print('C'); }
368        else  if (config.note() == midier::Note::D) { io::lcd.print('D'); }
369        else if  (config.note() == midier::Note::E) { io::lcd.print('E'); }
370        else if (config.note()  == midier::Note::F) { io::lcd.print('F'); }
371        else if (config.note() ==  midier::Note::G) { io::lcd.print('G'); }
372
373        if      (config.accidental()  == midier::Accidental::Flat)    { io::lcd.print('b'); }
374        else if (config.accidental()  == midier::Accidental::Natural) { io::lcd.print(' '); }
375        else if (config.accidental()  == midier::Accidental::Sharp)   { io::lcd.print('#'); }
376    }
377}
378
379void  Mode(What what, How how)
380{
381    if (what == What::Data)
382    {
383        midier::mode::Name  name;
384        midier::mode::name(state::sequencer.config.mode(), /* out */ name);
385
386        if (how == How::Summary)
387        {
388            name[3] = '\\0'; //  trim the full name into a 3-letter shortcut
389            io::lcd.print(0, 1, name);
390        }
391        else if (how == How::Focus)
392        {
393            io::lcd.print(0,  1, sizeof(name), name);
394        }
395    }
396    else if (what == What::Title  && how == How::Focus)
397    {
398        io::lcd.print(0, 0, "Mode: ");
399    }
400}
401
402void  Octave(What what, How how)
403{
404    assert(how == How::Summary);
405
406    if  (what == What::Title)
407    {
408        io::lcd.print(3, 0, 'O');
409    }
410    else if (what == What::Data)
411    {
412        io::lcd.print(4, 0, state::sequencer.config.octave());
413    }
414}
415
416void Style(What what, How how)
417{
418    if (how == How::Summary)
419    {
420        if (what == What::Title)
421        {
422            io::lcd.print(6,  0, 'S');
423        }
424        else if (what == What::Data)
425        {
426            const  auto & config = state::sequencer.config; // a shortcut
427
428            io::lcd.print(7,  0, config.steps());
429            io::lcd.print(8, 0, config.looped() ? '+' : '-');
430            io::lcd.print(9, 0, 3, config.perm() + 1);
431        }
432    }
433    else if (how == How::Focus)
434    {
435        if (what == What::Title)
436        {
437            io::lcd.print(0, 0, "Style: ");
438        }
439        else  if (what == What::Data)
440        {
441            const auto & config = state::sequencer.config;  // a shortcut
442
443            io::lcd.print(7, 0, config.steps());
444            io::lcd.print(8,  0, config.looped() ? '+' : '-');
445            io::lcd.print(9, 0, 3, config.perm()  + 1);
446
447            midier::style::Description desc;
448            midier::style::description(config.steps(),  config.perm(), /* out */ desc);
449            io::lcd.print(0, 1, 16, desc); //  all columns in the LCD
450
451            if (config.looped())
452            {
453                io::lcd.setCursor(strlen(desc) + 1, 1);
454
455                for  (unsigned i = 0; i < 3; ++i)
456                {
457                    io::lcd.print('.');
458                }
459            }
460        }
461    }
462}
463
464void Rhythm(What  what, How how)
465{
466    if (how == How::Summary)
467    {
468        if (what  == What::Title)
469        {
470            io::lcd.print(4, 1, 'R');
471        }
472        else if (what == What::Data)
473        {
474            io::lcd.print(5,  1, 2, (unsigned)state::sequencer.config.rhythm() + 1);
475        }
476    }
477    else if (how == How::Focus)
478    {
479        if (what == What::Title)
480        {
481            io::lcd.print(0, 0, "Rhythm #");
482        }
483        else  if (what == What::Data)
484        {
485            io::lcd.print(8, 0, 2, (unsigned)state::sequencer.config.rhythm()  + 1);
486
487            midier::rhythm::Description desc;
488            midier::rhythm::description(state::sequencer.config.rhythm(),  /* out */ desc);
489            io::lcd.print(0, 1, desc);
490        }
491    }
492}
493
494}  // viewer
495
496namespace component
497{
498
499struct Component
500{
501    configurer::Configurer  configurer;
502    viewer::Viewer viewer;
503};
504
505Component All[] =
506    {
507        { configurer::BPM, viewer::BPM },
508        { configurer::Note, viewer::Note  },
509        { configurer::Mode, viewer::Mode },
510        { configurer::Octave,  viewer::Octave },
511        { configurer::Perm, viewer::Style },
512        { configurer::Steps,  viewer::Style },
513        { configurer::Rhythm, viewer::Rhythm },
514    };
515
516}  // component
517
518namespace control
519{
520
521namespace view
522{
523
524void  summary(viewer::Viewer viewer = nullptr) // 'nullptr' means all components
525{
526    if (viewer::focused != nullptr) // some viewer is currently in focus
527    {
528        viewer::focused.stop(); // stop the timer
529        viewer::focused = nullptr;  // mark as there's no viewer currently in focus
530        io::lcd.clear(); // clear  the screen entirely
531        viewer = nullptr; // mark to print all titles and  values
532    }
533
534    if (viewer == nullptr)
535    {
536        for (const  auto & component : component::All)
537        {
538            component.viewer(viewer::What::Title,  viewer::How::Summary);
539            component.viewer(viewer::What::Data, viewer::How::Summary);
540        }
541    }
542    else
543    {
544        viewer(viewer::What::Data, viewer::How::Summary);
545    }
546}
547
548void focus(viewer::Viewer viewer)
549{
550    if (viewer::focused  != viewer) // either in summary mode or another viewer is currently in focus
551    {
552        io::lcd.clear(); // clear the screen entirely
553        viewer::focused  = viewer; // mark this viewer as the one being in focus
554        viewer::focused.print(viewer::What::Title,  viewer::How::Focus); // print the title (only if just became the one in focus)
555    }
556
557    viewer::focused.print(viewer::What::Data, viewer::How::Focus);  // print the data anyways
558    viewer::focused.start(); // start the timer or  restart it if ticking already
559}
560
561} // view
562
563} // control
564
565namespace  handle
566{
567
568void focus()
569{
570    if (viewer::focused.elapsed(3200))
571    {
572        control::view::summary(); // go back to summary view
573    }
574}
575
576void  components()
577{
578    // components will update the configuration on I/O events
579
580    for (const auto & component : component::All)
581    {
582        const auto  action = component.configurer.check();
583
584        if (action == configurer::Action::None)
585        {
586            continue; // nothing to do
587        }
588
589        //  update the configuration only if in summary mode or if this configurer is in focus
590
591        if ((action == configurer::Action::Summary && viewer::focused == nullptr)  ||
592            (action == configurer::Action::Focus && viewer::focused == component.viewer))
593        {
594            component.configurer.update();
595        }
596
597        if  (action == configurer::Action::Summary)
598        {
599            control::view::summary(component.viewer);
600        }
601        else if (action == configurer::Action::Focus)
602        {
603            control::view::focus(component.viewer);
604        }
605    }
606}
607
608void  keys()
609{
610    // we extend `controlino::Key` so we could hold a Midier handle  with every key
611    struct Key : controlino::Key
612    {
613        Key(char  pin) : controlino::Key(io::Multiplexer, pin) // keys are behind the multiplexer
614        {}
615
616        midier::Sequencer::Handle h;
617    };
618
619    static  Key __keys[] = { 15, 14, 13, 12, 11, 10, 9, 8 }; // channel numbers of the multiplexer
620
621    for (auto i = 0; i < sizeof(__keys) / sizeof(Key); ++i)
622    {
623        auto  & key = __keys[i];
624
625        const auto event = key.check();
626
627        if  (event == Key::Event::None)
628        {
629            continue; // nothing has  changed
630        }
631
632        if (event == Key::Event::Down) // a key was  pressed
633        {
634            key.h = state::sequencer.start(i + 1); // start  playing an arpeggio of the respective scale degree
635        }
636        else  if (event == Key::Event::Up) // a key was released
637        {
638            state::sequencer.stop(key.h);  // stop playing the arpeggio
639        }
640    }
641}
642
643void click()
644{
645    // actually click Midier for it to play the MIDI notes
646    state::sequencer.click(midier::Sequencer::Run::Async);
647}
648
649}  // handle
650
651extern "C" void setup()
652{
653    // initialize the Arduino  "Serial" module and set the baud rate
654    // to the same value you are using  in your software.
655    // if connected physically using a MIDI 5-DIN connection,  use 31250.
656    Serial.begin(9600);
657
658    // initialize the LCD
659    io::lcd.begin(16,  2);
660
661    // print the initial configuration
662    control::view::summary();
663}
664
665extern  "C" void loop()
666{
667    handle::focus();
668    handle::components();
669    handle::keys();
670    handle::click();
671}
672
673} // arpeggino
674

1#include <Controlino.h>
2#include <LiquidCrystal.h>
3#include <Midier.h>
4
5#include  <assert.h>
6
7namespace arpeggino
8{
9
10namespace utils
11{
12
13struct  Timer
14{
15    // control
16
17    void start() // start (or restart)
18    {
19        _millis = millis();
20    }
21
22    void reset() // restart only if  ticking
23    {
24        if (ticking())
25        {
26            start();
27        }
28    }
29
30    void stop()
31    {
32        _millis = -1;
33    }
34
35    // query
36
37    bool elapsed(unsigned ms) const // only if  ticking
38    {
39        return ticking() && millis() - _millis >= ms;
40    }
41
42    bool ticking() const
43    {
44        return _millis != -1;
45    }
46
47private:
48    unsigned long _millis = -1;
49};
50
51} // utils
52
53namespace state
54{
55
56midier::Layers<8>  layers; // the number of layers chosen will affect the global variable size
57midier::Sequencer  sequencer(layers);
58
59struct : utils::Timer
60{
61    midier::Layer * layer  = nullptr;
62    unsigned char id;
63} layer;
64
65midier::Config * config =  &sequencer.config;
66
67} // state
68
69namespace io
70{
71
72// here we  declare all I/O controls with their corresponding pin numbers
73
74controlino::Selector  Selector(/* s0 = */ 6, /* s1 = */ 5, /* s2 = */ 4, /* s3 = */ 3);
75controlino::Multiplexer  Multiplexer(/* sig = */ 2, Selector);
76
77controlino::Potentiometer BPM(A0, /*  min = */ 20, /* max = */ 230); // we limit the value of BPM to [20,230]
78
79//  all configuration keys are behind the multiplexer
80controlino::Key Note(Multiplexer,  7);
81controlino::Key Mode(Multiplexer, 6);
82controlino::Key Octave(Multiplexer,  5);
83controlino::Key Perm(Multiplexer, 4);
84controlino::Key Steps(Multiplexer,  3);
85controlino::Key Rhythm(Multiplexer, 2);
86
87// control buttons
88controlino::Button  Layer(Multiplexer, 1);
89controlino::Button Record(Multiplexer, 0);
90
91struct  LCD : LiquidCrystal
92{
93    LCD(uint8_t rs, uint8_t e, uint8_t d4, uint8_t d5,  uint8_t d6, uint8_t d7) : LiquidCrystal(rs, e, d4, d5, d6, d7)
94    {}
95
96    template <typename T>
97    char print(const T & arg)
98    {
99        return  LiquidCrystal::print(arg);
100    }
101
102    template <typename T>
103    char  print(char col, char row, const T & arg)
104    {
105        setCursor(col, row);
106        return print(arg);
107    }
108
109    template <typename T>
110    char  print(char col, char row, char max, const T & arg)
111    {
112        const auto  written = print(col, row, arg);
113
114        for (unsigned i = 0; i < max - written;  ++i)
115        {
116            write(' '); // make sure the non-used characters  are clear
117        }
118
119        return written;
120    }
121};
122
123LCD  lcd(/* rs = */ 7, /* e = */ 8,  /* d4 = */ 9, /* d5 = */ 10, /* d6 = */ 11, /* d7  = */ 12);
124
125utils::Timer flashing;
126
127} // io
128
129namespace configurer
130{
131
132enum  class Action
133{
134    None,
135
136    Summary,
137    Focus,
138};
139
140//  a configurer is responsible for updating a single configuration
141// parameter  according to changes of an I/O control
142
143struct Configurer
144{
145    Action(*check)();
146    void(*update)();
147};
148
149Configurer BPM =
150    {
151        .check =  []()
152            {
153                if (io::BPM.check() == controlino::Potentiometer::Event::Changed)
154                {
155                    return Action::Summary;
156                }
157
158                return Action::None;
159            },
160        .update = []()
161            {
162                state::sequencer.bpm = io::BPM.read();
163            },
164    };
165
166Configurer Note =
167    {
168        .check = []()
169            {
170                if (io::Note.check() == controlino::Key::Event::Down)
171                {
172                    return Action::Summary;
173                }
174
175                return  Action::None;
176            },
177        .update = []()
178            {
179                if  (state::config->accidental() == midier::Accidental::Flat)
180                {
181                    state::config->accidental(midier::Accidental::Natural);
182                }
183                else if (state::config->accidental() == midier::Accidental::Natural)
184                {
185                    state::config->accidental(midier::Accidental::Sharp);
186                }
187                else if (state::config->accidental() == midier::Accidental::Sharp)
188                {
189                    state::config->accidental(midier::Accidental::Flat);
190
191                    if      (state::config->note() == midier::Note::C) { state::config->note(midier::Note::D);  }
192                    else if (state::config->note() == midier::Note::D) { state::config->note(midier::Note::E);  }
193                    else if (state::config->note() == midier::Note::E) { state::config->note(midier::Note::F);  }
194                    else if (state::config->note() == midier::Note::F) { state::config->note(midier::Note::G);  }
195                    else if (state::config->note() == midier::Note::G) { state::config->note(midier::Note::A);  }
196                    else if (state::config->note() == midier::Note::A) { state::config->note(midier::Note::B);  }
197                    else if (state::config->note() == midier::Note::B) { state::config->note(midier::Note::C);  }
198                }
199            },
200    };
201
202Configurer Mode =
203    {
204        .check = []()
205            {
206                if (io::Mode.check()  == controlino::Key::Event::Down)
207                {
208                    return  Action::Focus;
209                }
210
211                return Action::None;
212            },
213        .update = []()
214            {
215                const  auto current = state::config->mode();
216                const auto next = (midier::Mode)(((unsigned)current  + 1) % (unsigned)midier::Mode::Count);
217
218                state::config->mode(next);
219            },
220    };
221
222Configurer Octave =
223    {
224        .check =  []()
225            {
226                if (io::Octave.check() == controlino::Key::Event::Down)
227                {
228                    return Action::Summary;
229                }
230
231                return Action::None;
232            },
233        .update = []()
234            {
235                const auto current = state::config->octave();
236                const auto next = (current % 7) + 1;
237
238                state::config->octave(next);
239            },
240    };
241
242Configurer Perm =
243    {
244        .check = []()
245            {
246                if (io::Perm.check() == controlino::Key::Event::Down)
247                {
248                    return Action::Focus;
249                }
250
251                return Action::None;
252            },
253        .update = []()
254            {
255                const auto current = state::config->perm();
256                const auto next = (current + 1) % midier::style::count(state::config->steps());
257
258                state::config->perm(next);
259            },
260    };
261
262Configurer  Steps =
263    {
264        .check = []()
265            {
266                if  (io::Steps.check() == controlino::Key::Event::Down)
267                {
268                    return  Action::Focus;
269                }
270
271                return Action::None;
272            },
273        .update = []()
274            {
275                if  (state::config->looped() == false) // we set to loop if currently not looping
276                {
277                    state::config->looped(true);
278                }
279                else
280                {
281                    unsigned steps  = state::config->steps() + 1;
282
283                    if (steps > 6)
284                    {
285                        steps = 3;
286                    }
287
288                    state::config->steps(steps);
289                    state::config->perm(0); // reset the permutation
290                    state::config->looped(false);  // set as non looping
291                }
292            },
293    };
294
295Configurer  Rhythm =
296    {
297        .check = []()
298            {
299                if  (io::Rhythm.check() == controlino::Key::Event::Down)
300                {
301                    return  Action::Focus;
302                }
303
304                return Action::None;
305            },
306        .update = []()
307            {
308                const  auto current = state::config->rhythm();
309                const auto next = (midier::Rhythm)(((unsigned)current  + 1) % (unsigned)midier::Rhythm::Count);
310
311                state::config->rhythm(next);
312            }
313    };
314
315} // configurer
316
317namespace viewer
318{
319
320enum  class What
321{
322    Title,
323    Data,
324};
325
326enum class How
327{
328    Summary,
329    Focus,
330};
331
332using Viewer = void(*)(What, How);
333
334struct  : utils::Timer
335{
336    // query
337    bool operator==(Viewer other) const {  return _viewer == other; }
338    bool operator!=(Viewer other) const { return _viewer  != other; }
339
340    // assignment
341    void operator=(Viewer other) { _viewer  = other; }
342
343    // access
344    void print(What what, How how) { _viewer(what,  how); }
345
346private:
347    Viewer _viewer = nullptr;
348} focused;
349
350void  BPM(What what, How how)
351{
352    assert(how == How::Summary);
353
354    if (what  == What::Title)
355    {
356        io::lcd.print(13, 1, "bpm");
357    }
358
359    if (what == What::Data)
360    {
361        io::lcd.print(9, 1, 3, state::sequencer.bpm);
362    }
363}
364
365void Note(What what, How how)
366{
367    assert(how == How::Summary);
368
369    if (what == What::Data)
370    {
371        io::lcd.setCursor(0, 0);
372
373        if      (state::config->note() == midier::Note::A) { io::lcd.print('A');  }
374        else if (state::config->note() == midier::Note::B) { io::lcd.print('B');  }
375        else if (state::config->note() == midier::Note::C) { io::lcd.print('C');  }
376        else if (state::config->note() == midier::Note::D) { io::lcd.print('D');  }
377        else if (state::config->note() == midier::Note::E) { io::lcd.print('E');  }
378        else if (state::config->note() == midier::Note::F) { io::lcd.print('F');  }
379        else if (state::config->note() == midier::Note::G) { io::lcd.print('G');  }
380
381        if      (state::config->accidental() == midier::Accidental::Flat)    { io::lcd.print('b'); }
382        else if (state::config->accidental() == midier::Accidental::Natural)  { io::lcd.print(' '); }
383        else if (state::config->accidental() == midier::Accidental::Sharp)   { io::lcd.print('#'); }
384    }
385}
386
387void Mode(What what, How how)
388{
389    if (what == What::Data)
390    {
391        midier::mode::Name name;
392        midier::mode::name(state::config->mode(),  /* out */ name);
393
394        if (how == How::Summary)
395        {
396            name[3]  = '\\0'; // trim the full name into a 3-letter shortcut
397            io::lcd.print(0,  1, name);
398        }
399        else if (how == How::Focus)
400        {
401            io::lcd.print(0,  1, sizeof(name), name);
402        }
403    }
404    else if (what == What::Title  && how == How::Focus)
405    {
406        io::lcd.print(0, 0, "Mode: ");
407    }
408}
409
410void  Octave(What what, How how)
411{
412    assert(how == How::Summary);
413
414    if  (what == What::Title)
415    {
416        io::lcd.print(3, 0, 'O');
417    }
418    else if (what == What::Data)
419    {
420        io::lcd.print(4, 0, state::config->octave());
421    }
422}
423
424void Style(What what, How how)
425{
426    if (how == How::Summary)
427    {
428        if (what == What::Title)
429        {
430            io::lcd.print(6,  0, 'S');
431        }
432        else if (what == What::Data)
433        {
434            io::lcd.print(7,  0, state::config->steps());
435            io::lcd.print(8, 0, state::config->looped()  ? '+' : '-');
436            io::lcd.print(9, 0, 3, state::config->perm() + 1);
437        }
438    }
439    else if (how == How::Focus)
440    {
441        if (what  == What::Title)
442        {
443            io::lcd.print(0, 0, "Style: ");
444        }
445        else if (what == What::Data)
446        {
447            io::lcd.print(7,  0, state::config->steps());
448            io::lcd.print(8, 0, state::config->looped()  ? '+' : '-');
449            io::lcd.print(9, 0, 3, state::config->perm() + 1);
450
451            midier::style::Description desc;
452            midier::style::description(state::config->steps(),  state::config->perm(), /* out */ desc);
453            io::lcd.print(0, 1, 16, desc);  // all columns in the LCD
454
455            if (state::config->looped())
456            {
457                io::lcd.setCursor(strlen(desc) + 1, 1);
458
459                for  (unsigned i = 0; i < 3; ++i)
460                {
461                    io::lcd.print('.');
462                }
463            }
464        }
465    }
466}
467
468void Rhythm(What  what, How how)
469{
470    if (how == How::Summary)
471    {
472        if (what  == What::Title)
473        {
474            io::lcd.print(4, 1, 'R');
475        }
476        else if (what == What::Data)
477        {
478            io::lcd.print(5,  1, 2, (unsigned)state::config->rhythm() + 1);
479        }
480    }
481    else  if (how == How::Focus)
482    {
483        if (what == What::Title)
484        {
485            io::lcd.print(0, 0, "Rhythm #");
486        }
487        else if (what  == What::Data)
488        {
489            io::lcd.print(8, 0, 2, (unsigned)state::config->rhythm()  + 1);
490
491            midier::rhythm::Description desc;
492            midier::rhythm::description(state::config->rhythm(),  /* out */ desc);
493            io::lcd.print(0, 1, desc);
494        }
495    }
496}
497
498}  // viewer
499
500namespace component
501{
502
503struct Component
504{
505    configurer::Configurer  configurer;
506    viewer::Viewer viewer;
507};
508
509Component All[] =
510    {
511        { configurer::BPM, viewer::BPM },
512        { configurer::Note, viewer::Note  },
513        { configurer::Mode, viewer::Mode },
514        { configurer::Octave,  viewer::Octave },
515        { configurer::Perm, viewer::Style },
516        { configurer::Steps,  viewer::Style },
517        { configurer::Rhythm, viewer::Rhythm },
518    };
519
520}  // component
521
522namespace control
523{
524
525void flash()
526{
527    if (io::flashing.ticking())
528    {
529        return; // already flashing
530    }
531
532    digitalWrite(13,  HIGH);
533    io::flashing.start();
534}
535
536namespace view
537{
538
539void  summary(viewer::Viewer viewer = nullptr) // 'nullptr' means all components
540{
541    if (viewer::focused != nullptr) // some viewer is currently in focus
542    {
543        viewer::focused.stop(); // stop the timer
544        viewer::focused = nullptr;  // mark as there's no viewer currently in focus
545        io::lcd.clear(); // clear  the screen entirely
546        viewer = nullptr; // mark to print all titles and  values
547    }
548
549    if (viewer == nullptr)
550    {
551        for (const  auto & component : component::All)
552        {
553            component.viewer(viewer::What::Title,  viewer::How::Summary);
554            component.viewer(viewer::What::Data, viewer::How::Summary);
555        }
556
557        // layers and bars
558
559        io::lcd.setCursor(13,  0);
560
561        char written = 0;
562
563        if (state::layer.layer != nullptr)
564        {
565            written += io::lcd.print('L');
566            written +=  io::lcd.print(state::layer.id);
567        }
568
569        while (written++ < 3)
570        {
571            io::lcd.write(' ');
572        }
573    }
574    else
575    {
576        viewer(viewer::What::Data, viewer::How::Summary);
577    }
578}
579
580void  focus(viewer::Viewer viewer)
581{
582    if (viewer::focused != viewer) // either  in summary mode or another viewer is currently in focus
583    {
584        io::lcd.clear();  // clear the screen entirely
585        viewer::focused = viewer; // mark this viewer  as the one being in focus
586        viewer::focused.print(viewer::What::Title,  viewer::How::Focus); // print the title (only if just became the one in focus)
587    }
588
589    viewer::focused.print(viewer::What::Data, viewer::How::Focus);  // print the data anyways
590    viewer::focused.start(); // start the timer or  restart it if ticking already
591}
592
593void bar(midier::Sequencer::Bar bar)
594{
595    io::lcd.setCursor(14, 0);
596
597    char written = 0;
598
599    if (bar !=  midier::Sequencer::Bar::None)
600    {
601        written = io::lcd.print((unsigned)bar);
602    }
603
604    while (written++ < 2)
605    {
606        io::lcd.write(' ');
607    }
608}
609
610} // view
611
612namespace config
613{
614
615void layer(midier::Layer  * layer, unsigned char id) // `nullptr` means go back to global
616{
617    if (state::layer.layer  == nullptr && layer == nullptr)
618    {
619        return; // nothing to do
620    }
621
622    // we allow setting the same layer for updating its config and  the timer
623
624    state::layer.layer = layer;
625    state::layer.id = id;
626
627    if (layer == nullptr)
628    {
629        // increase the volume of all layers
630        state::sequencer.layers.eval([](midier::Layer & layer)
631            {
632                layer.velocity = midier::midi::Velocity::High;
633            });
634
635        state::layer.stop(); // stop the timer
636        state::config = &state::sequencer.config;  // point to global configuration
637    }
638    else
639    {
640        // lower  the volume of all layers
641        state::sequencer.layers.eval([](midier::Layer  & layer)
642            {
643                layer.velocity = midier::midi::Velocity::Low;
644            });
645
646        // increase the volume of the selected layer
647        state::layer.layer->velocity = midier::midi::Velocity::High;
648
649        state::layer.start();  // start ticking
650        state::config = layer->config.view(); // point to this  layer's configuration
651    }
652
653    control::view::summary();
654}
655
656void  global()
657{
658    layer(nullptr, 0);
659}
660
661} // config
662
663} // control
664
665namespace  handle
666{
667
668void flashing()
669{
670    if (io::flashing.elapsed(70))
671    {
672        digitalWrite(13, LOW);
673        io::flashing.stop();
674    }
675}
676
677void  recording()
678{
679    static bool __recording = false;
680
681    const auto recording  = state::sequencer.recording(); // is recording at the moment?
682
683    if (__recording  != recording)
684    {
685        digitalWrite(A1, recording ? HIGH : LOW);
686        __recording = recording;
687    }
688}
689
690void focus()
691{
692    if  (viewer::focused.elapsed(3200))
693    {
694        state::layer.reset(); // restart  the layer timer
695
696        control::view::summary(); // go back to summary view
697    }
698}
699
700void components()
701{
702    // components will update the configuration  on I/O events
703
704    for (const auto & component : component::All)
705    {
706        const auto action = component.configurer.check();
707
708        if (action  == configurer::Action::None)
709        {
710            continue; // nothing to  do
711        }
712
713        const auto layered = (state::layer.layer != nullptr)  && (component.viewer != viewer::BPM); // all configurers but BPM are per layer
714
715        if (layered)
716        {
717            state::layer.start(); // start  ticking
718        }
719
720        // update the configuration only if in summary  mode or if this configurer is in focus
721
722        if ((action == configurer::Action::Summary  && viewer::focused == nullptr) ||
723            (action == configurer::Action::Focus  && viewer::focused == component.viewer))
724        {
725            if (layered  && state::layer.layer->config.outer())
726            {
727                // the  selected layer should now detach from the global configuration as
728                //  it is being configured specifically.
729                state::layer.layer->config  = state::sequencer.config; // deep copy the global configuration
730
731                //  we also need to point to the configuration of this layer
732                state::config  = state::layer.layer->config.view();
733            }
734
735            component.configurer.update();
736        }
737
738        if (action == configurer::Action::Summary)
739        {
740            control::view::summary(component.viewer);
741        }
742        else  if (action == configurer::Action::Focus)
743        {
744            control::view::focus(component.viewer);
745        }
746    }
747}
748
749void keys()
750{
751    // we extend `controlino::Key`  so we could hold a Midier handle with every key
752    struct Key : controlino::Key
753    {
754        Key(char pin) : controlino::Key(io::Multiplexer, pin) // keys are  behind the multiplexer
755        {}
756
757        midier::Sequencer::Handle h;
758    };
759
760    static Key __keys[] = { 15, 14, 13, 12, 11, 10, 9, 8 }; // channel  numbers of the multiplexer
761
762    for (auto i = 0; i < sizeof(__keys) / sizeof(Key);  ++i)
763    {
764        auto & key = __keys[i];
765
766        const auto event  = key.check();
767
768        if (event == Key::Event::None)
769        {
770            continue;  // nothing has changed
771        }
772
773        if (event == Key::Event::Down)  // a key was pressed
774        {
775            control::config::global(); // go  back to global configutarion when playing new layers
776
777            key.h =  state::sequencer.start(i + 1); // start playing an arpeggio of the respective scale  degree
778        }
779        else if (event == Key::Event::Up) // a key was released
780        {
781            state::sequencer.stop(key.h); // stop playing the arpeggio
782        }
783    }
784}
785
786void record()
787{
788    const auto event = io::Record.check();
789
790    if (event == controlino::Button::Event::Click)
791    {
792        state::sequencer.record();
793    }
794    else if (event == controlino::Button::Event::Press)
795    {
796        if  (state::layer.layer == nullptr)
797        {
798            state::sequencer.revoke();  // revoke the last recorded layer as no layer is selected
799        }
800        else
801        {
802            state::layer.layer->revoke(); // revoke the selected layer
803        }
804    }
805    else if (event == controlino::Button::Event::ClickPress)
806    {
807        state::sequencer.wander();
808    }
809    else
810    {
811        return;
812    }
813
814    control::config::global(); // go back to global configuration
815}
816
817void  layer()
818{
819    if (state::layer.elapsed(6000))
820    {
821        control::config::global();  // go back to global configuration after 6 seconds
822    }
823    else
824    {
825        const auto event = io::Layer.check();
826
827        if (event == controlino::Button::Event::Click)  // iterate layers
828        {
829            if (viewer::focused != nullptr)
830            {
831                state::layer.reset(); // reset the layer timer  only if there's one selected currently
832
833                control::view::summary();  // go back to summary view
834            }
835            else
836            {
837                static const auto __count = state::sequencer.layers.count();
838
839                static unsigned char __index = 0;
840
841                if (state::layer.layer  == nullptr || __index >= __count)
842                {
843                    __index  = 0; // search from the start again
844                }
845
846                midier::Layer  * layer = nullptr;
847
848                while (__index < __count)
849                {
850                    midier::Layer & prospect = state::sequencer.layers[__index++];
851
852                    if (prospect.running())
853                    {
854                        layer  = &prospect;
855                        break;
856                    }
857                }
858
859                if (layer == nullptr)
860                {
861                    control::config::global();
862                }
863                else
864                {
865                    control::config::layer(layer,  __index);
866                }
867            }
868        }
869        else if  (event == controlino::Button::Event::Press)
870        {
871            if (state::layer.layer  != nullptr) // a layer is selected
872            {
873                if (state::layer.layer->config.inner())
874                {
875                    // we make it point to the global configuration
876                    state::layer.layer->config = state::config = &state::sequencer.config;
877
878                    // reset the timer
879                    state::layer.reset();
880
881                    // print the new (global) configuration
882                    control::view::summary();
883                }
884            }
885            else // no layer is selected
886            {
887                // making all previous dynamic layers static
888
889                state::sequencer.layers.eval([](midier::Layer & layer)
890                    {
891                        if (layer.config.outer())
892                        {
893                            layer.config = state::sequencer.config; // make it static  and copy the current global configuration
894                        }
895                    });
896            }
897        }
898        else if (event == controlino::Button::Event::ClickPress)
899        {
900            // set all layers to be dynamically configured
901
902            state::sequencer.layers.eval([](midier::Layer & layer)
903                {
904                    layer.config = &state::sequencer.config;
905                });
906
907            control::config::global();
908        }
909    }
910}
911
912void click()
913{
914    // actually click Midier for it to play the MIDI notes
915    const auto bar  = state::sequencer.click(midier::Sequencer::Run::Async);
916
917    if (bar != midier::Sequencer::Bar::Same)
918    {
919        control::flash();
920
921        if (viewer::focused == nullptr  && state::layer.layer == nullptr)
922        {
923            control::view::bar(bar);
924        }
925    }
926}
927
928} // handle
929
930extern "C" void setup()
931{
932    // initialize the Arduino "Serial" module and set the baud rate
933    //  to the same value you are using in your software.
934    // if connected physically  using a MIDI 5-DIN connection, use 31250.
935    Serial.begin(9600);
936
937    //  initialize the LEDs
938    pinMode(13, OUTPUT);
939    pinMode(A1, OUTPUT);
940
941    // initialize the LCD
942    io::lcd.begin(16, 2);
943
944    // print the initial  configuration
945    control::view::summary();
946}
947
948extern "C" void loop()
949{
950    handle::flashing();
951    handle::recording();
952    handle::focus();
953    handle::components();
954    handle::keys();
955    handle::record();
956    handle::layer();
957    handle::click();
958}
959
960} // arpeggino
961