main_perkons.cc - structure

src/main_perkons.cc

@@ -75,7 +75,7 @@ namespace Heck {
     {
         hw.Configure();
         hw.Init();
-        hw.StartLog();
+        hw.StartLog(true);
 
         but_rec.Init(hw.GetPin(28), 0);
 
@@ -112,24 +112,8 @@ namespace Heck {
         hw.PrintLine("Setting up MIDI");
         ld::MidiUartHandler::Config midi_config{};
         midi.Init(midi_config);
-        u32 systick_last_rt_msg{};
-        midi.realtime_callback = [&systick_last_rt_msg](ld::MidiEvent& msg) {
-            u32 systick_now = ld::System::GetNow();
-            u32 systick_since_last = systick_now - systick_last_rt_msg;
-            systick_last_rt_msg = systick_now;
-
-            char outstr[128];
-            char rttype_str[32];
-            GetMidiRTTypeAsString(msg, rttype_str);
-
-            //        sprintf(
-            //            outstr,
-            //            "RT: systick: %i\ttimedelta: %i\ttype: %s\n",
-            //            (unsigned int)systick_now,
-            //            (unsigned int)systick_since_last,
-            //            rttype_str);
-            //        hw.PrintLine("%s", outstr);
-        };
+
+        midi.realtime_callback = &midi_realtime_handler;
 
         hw.PrintLine("Starting MIDI Receive");
         midi.StartReceive();
@@ -174,30 +158,40 @@ namespace Heck {
         }
     }
 
-    void mainloop()
+    void midi_realtime_handler(ld::MidiEvent& msg)
     {
-        u32 now = ld::System::GetNow();
-        u32 log_time{};
-        bool heartbeat_led_state{ false };
-        u32 heartbeat_time{};
-
-        bool seq_recording{false};
-
-
-        while (1) {
-            now = ld::System::GetNow();
-
-            but_rec.Debounce();
-            seq_recording = but_rec.Pressed();
+        event_log.PushBack(msg);
+        switch (msg.srt_type) {
+            case daisy::TimingClock:
+                clock.advance();
+                break;
+            case daisy::Start: {
+                clock.reset();
+                clock.enable(true);
+            } break;
+            case daisy::Stop: {
+                clock.enable(false);
+                clock.reset();
+            } break;
+            case daisy::Reset:
+                break;
+            case daisy::Continue:
+                break;
+        }
+    }
 
-            while (midi.HasEvents()) {
-                ld::MidiEvent msg = midi.PopEvent();
-                if (msg.type == ld::MidiMessageType::NoteOn) {
+    void midi_async_handler()
+    {
+        while (midi.HasEvents()) {
+            ld::MidiEvent msg = midi.PopEvent();
+            event_log.PushBack(msg);
+            switch (msg.type) {
+                case ld::MidiMessageType::NoteOn: {
                     if (msg.channel >= 0 && msg.channel < Constants::TRACK_COUNT) {
                         tracks[msg.channel].instrument->trigger();
                     }
-                } else if (msg.type == ld::MidiMessageType::ControlChange) {
-                    event_log.PushBack(msg);
+                } break;
+                case ld::MidiMessageType::ControlChange: {
                     ld::ControlChangeEvent cc = msg.AsControlChange();
                     float val_normalized = cc.value / 127.;
                     switch (cc.control_number) {
@@ -236,38 +230,103 @@ namespace Heck {
                         default:
                             break;
                     }
+                } break;
+                default: {
+                    // Other MIDI message
+                } break;
+            }
+        }
+    }
 
-                } else {
+    void mainloop()
+    {
+        u32 systick_now = ld::System::GetNow();
+        u32 midi_log_systick_last{};
+
+        bool heartbeat_led_state{ false };
+        u32 heartbeat_systick_last{};
+
+        bool seq_recording_new{ false };
+        bool seq_recording_current{ false };
+
+        int clock_time_new{};
+        int clock_time_current{};
+
+
+        while (1) {
+            // Get current values for state
+            // if update is different
+            // Update state
+            // handle change
+
+            systick_now = ld::System::GetNow();
+
+            clock_time_new = clock.gettime();
+            if (clock_time_current != clock_time_new) {
+                clock_time_current = clock_time_new;
+                if (0) {
+                    hw.PrintLine("CLOCK:%i", clock_time_current);
                 }
             }
 
-            if (now - log_time > 100) {
-                log_time = now;
-                if(seq_recording) {
-                    hw.PrintLine("REC");
+            midi_async_handler();
+
+            // REC
+            but_rec.Debounce();
+            seq_recording_new = but_rec.Pressed();
+            if (seq_recording_current != seq_recording_new) {
+                seq_recording_current = seq_recording_new;
+                if (seq_recording_current) {
+                    hw.PrintLine("RECORDING ON");
+                } else {
+                    hw.PrintLine("RECORDING OFF");
                 }
+            }
+
+            if (systick_now - midi_log_systick_last > 5) {
+                midi_log_systick_last = systick_now;
                 if (!event_log.IsEmpty()) {
                     auto msg = event_log.PopFront();
-                    char outstr[128];
-                    char type_str[32];
-                    GetMidiTypeAsString(msg, type_str);
-                    sprintf(
-                        outstr,
-                        "time-last:\t%ld\ttype: %s\tChannel:  %d\tData MSB: "
-                        "%d\tData LSB: %d\n",
-                        now,
-                        type_str,
-                        msg.channel,
-                        msg.data[0],
-                        msg.data[1]);
-                    hw.PrintLine(outstr);
+                    //                    hw.PrintLine("fsfs");
+                    switch (msg.type) {
+                        case ld::MidiMessageType::SystemRealTime: {
+                            if (0) {
+                                char outstr[256];
+                                char rttype_str[32];
+                                GetMidiRTTypeAsString(msg, rttype_str);
+                                sprintf(outstr, "RT: type: %s\n", rttype_str);
+                                if (msg.srt_type != daisy::TimingClock) {
+                                    hw.PrintLine("%s", outstr);
+                                }
+                            }
+                        } break;
+                        case ld::NoteOn:
+                        case ld::NoteOff:
+                        case ld::MidiMessageType::ControlChange: {
+                            if (1) {
+                                char outstr[256];
+                                char type_str[32];
+                                GetMidiTypeAsString(msg, type_str);
+                                sprintf(
+                                    outstr,
+                                    "time-last:\t%ld\ttype: %s\tChannel:  %d\tData MSB: "
+                                    "%d\tData LSB: %d\n",
+                                    systick_now,
+                                    type_str,
+                                    msg.channel,
+                                    msg.data[0],
+                                    msg.data[1]);
+                                hw.PrintLine("%s", outstr);
+                            }
+                        } break;
+                    }
                 }
             }
 
-            if (now - heartbeat_time > 500) {
-                heartbeat_time = now;
-                hw.SetLed(heartbeat_led_state);
+            if (systick_now - heartbeat_systick_last > 500) {
+                heartbeat_systick_last = systick_now;
                 heartbeat_led_state = !heartbeat_led_state;
+                hw.SetLed(heartbeat_led_state);
             }
         }
     }