add main_density - my fav airwindows plugin ported to stm32 \o/

prototype state of course

examples/main_density.cc

@@ -0,0 +1,194 @@
+#include "main_density.hh"
+#include "utils.hh"
+#include <functional>
+#include "density.hh"
+
+namespace Heck {
+    namespace { // anonymous namespace for internal linkage
+        // =============================================================================================
+        // INIT
+        // =============================================================================================
+        ld::DaisySeed seed{};
+
+        static ld::MidiUartHandler midi{};
+
+        std::array<float, 4> pots_value{};
+
+        Observer<int> pot1{};
+        Observer<int> pot2{};
+        Observer<int> pot3{};
+        Observer<int> pot4{};
+
+        SWTimer scan_pots{};
+
+        Density density{};
+
+        // function prototypes
+        void audio_callback(
+            ld::AudioHandle::InputBuffer in,
+            ld::AudioHandle::OutputBuffer out,
+            size_t size);
+
+
+        void midi_realtime_handler(const ld::MidiEvent& msg);
+
+        void init()
+        {
+            seed.Configure();
+            seed.Init(Constants::CPU_BOOST480MHZ);
+            seed.StartLog(Constants::Developer::LOG_BLOCKS_BOOT);
+
+            {
+                ld::AdcChannelConfig adc_cfg[4];
+                adc_cfg[0].InitSingle(ld::DaisySeed::GetPin(Constants::Hardware::PIN_POT_1));
+                adc_cfg[1].InitSingle(ld::DaisySeed::GetPin(Constants::Hardware::PIN_POT_2));
+                adc_cfg[2].InitSingle(ld::DaisySeed::GetPin(Constants::Hardware::PIN_POT_3));
+                adc_cfg[3].InitSingle(ld::DaisySeed::GetPin(Constants::Hardware::PIN_POT_4));
+
+                seed.adc.Init(adc_cfg, 4);
+                seed.adc.Start();
+            }
+
+            seed.PrintLine("Setting Blocksize: %i", Constants::AUDIO_BUFFERSIZE);
+            seed.SetAudioBlockSize(Constants::AUDIO_BUFFERSIZE);
+
+            seed.PrintLine("Setting Samplerate: %i", Constants::AUDIO_SAMPLERATE);
+            seed.SetAudioSampleRate(Constants::AUDIO_SAMPLERATE);
+
+            seed.PrintLine("Initializing MIDI");
+            ld::MidiUartHandler::Config midi_config{};
+            midi.Init(midi_config);
+
+            seed.PrintLine("Starting MIDI Receive");
+            midi.StartReceiveRt(&midi_realtime_handler);
+            midi.Listen();
+
+            seed.PrintLine("Starting Audio");
+            seed.StartAudio(audio_callback);
+        }
+
+
+        // =============================================================================================
+        // RUN
+        // =============================================================================================
+
+        void audio_callback(ld::AudioHandle::InputBuffer in, ld::AudioHandle::OutputBuffer out, size_t size)
+        {
+
+            float sig{};
+            float sig2{};
+            float sig3{};
+            // sum to dual mono
+//            for (size_t i = 0; i == 0; i++) {
+//                sig = in[0][i];
+//                sig += in[1][i];
+
+//                sig2 = sig;
+                density.process(in[0], out[0], size);
+
+                //                sig *= pots_value
+
+//                out[0][i] = sig3;
+//                out[1][i] = sig3;
+//            }
+
+            // Channel 1
+            //            float sig_out{};
+            //            // sum to dual mono
+            //            for (size_t i = 0; i < size; i++) {
+            //                sig_out = in[0][i];
+            //                sig_out += in[1][i];
+            //
+            //                sig_out *= pot1_value;
+            //
+            //                out[0][i] = sig_out;
+            //                out[1][i] = sig_out;
+            //            }
+        }
+
+
+        void midi_realtime_handler(const ld::MidiEvent& msg)
+        {
+            switch (msg.srt_type) {
+                case ld::TimingClock: {
+                } break;
+                case ld::Start: {
+                } break;
+                case ld::Stop: {
+                } break;
+                case ld::Reset: {
+                } break;
+                case ld::Continue: {
+                } break;
+            }
+        }
+
+        void midi_async_handler(const ld::MidiEvent& msg)
+        {
+            char strbuf[128];
+            GetMidiTypeAsString(msg, &strbuf[0]);
+            seed.PrintLine("%s", strbuf);
+            return;
+        }
+
+        void mainloop()
+        {
+            seed.PrintLine("Entering MainLoop");
+            u32 time_boot_ms{};
+
+
+            scan_pots.set_period(10);
+            scan_pots.set_callback([]() {
+                pot1.on_change_fuzzy(seed.adc.Get(0), 10, [](int val) {
+                    pots_value[0] = float(val) / (float)std::numeric_limits<u16>::max();
+                    density.params[0] =  (pots_value[0] * 5.f) - 1.f;
+                    seed.PrintLine("POT_0: %d", (int)(pots_value[0] * 100.));
+                });
+                pot2.on_change_fuzzy(seed.adc.Get(1), 10, [](int val) {
+                    pots_value[1] = float(val) / (float)std::numeric_limits<u16>::max();
+                    density.params[1] = pots_value[1];
+                    seed.PrintLine("POT_1: %d", (int)(pots_value[1] * 100.));
+                });
+                pot3.on_change_fuzzy(seed.adc.Get(2), 10, [](int val) {
+                    pots_value[2] = float(val) / (float)std::numeric_limits<u16>::max();
+                    density.params[2] = pots_value[2];
+                    seed.PrintLine("POT_2: %d", (int)(pots_value[2] * 100.));
+                });
+                pot4.on_change_fuzzy(seed.adc.Get(3), 10, [](int val) {
+                    pots_value[3] = float(val) / (float)std::numeric_limits<u16>::max();
+                    density.params[3] = pots_value[3];
+                    seed.PrintLine("POT_3: %d", (int)(pots_value[3] * 100.));
+                });
+            });
+
+
+            bool heartbeat_led_state{ false };
+
+            SWTimer heartbeat{};
+            heartbeat.set_period(100);
+            heartbeat.set_callback([&heartbeat_led_state]() {
+                heartbeat_led_state = !heartbeat_led_state;
+                seed.SetLed(heartbeat_led_state);
+                return;
+            });
+
+            while (true) {
+                time_boot_ms = ld::System::GetNow();
+
+                while (midi.HasEvents()) {
+                    midi_async_handler(midi.PopEvent());
+                }
+
+                scan_pots.is_it_already_time_again(time_boot_ms);
+                heartbeat.is_it_already_time_again(time_boot_ms);
+            }
+        }
+    } // namespace
+} // namespace Heck
+
+
+int main()
+{
+    Heck::init();
+    Heck::mainloop();
+}

examples/main_density.hh

@@ -0,0 +1,34 @@
+#ifndef HECK_LIBDIZZY_MAIN_DENSITY_HH
+#define HECK_LIBDIZZY_MAIN_DENSITY_HH
+
+#include <cstdint>
+#include "daisy_seed.h"
+#include "daisysp.h"
+#include "types.hh"
+
+namespace Heck {
+    namespace Constants {
+        namespace Hardware {
+            //            constexpr int PIN_BUTTON_RECORD = 28;
+            constexpr int PIN_POT_1 = 15;
+            constexpr int PIN_POT_2 = 16;
+            constexpr int PIN_POT_3 = 17;
+            constexpr int PIN_POT_4 = 18;
+        } // namespace Hardware
+
+        constexpr bool CPU_BOOST480MHZ = false;
+        constexpr int AUDIO_BUFFERSIZE = 4;
+        constexpr Samplerate AUDIO_SAMPLERATE = Samplerate::SAI_48KHZ;
+
+        namespace Developer {
+            constexpr bool LOG_BLOCKS_BOOT = false;
+        }
+    } // namespace Constants
+
+    //Hardware
+    extern ld::DaisySeed seed;
+    //    extern ld::Switch but_rec;
+} // namespace Heck
+
+
+#endif