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

prototype state of course

Makefile

@@ -3,7 +3,7 @@
 all: flash
 
 lib:
-	$(MAKE) -C src
+	$(MAKE) -C src lib
 
 example: lib
 	$(MAKE) -C examples

examples/main_adc.cc

@@ -13,15 +13,17 @@ namespace Heck {
             seed.Init(Constants::CPU_BOOST480MHZ);
             seed.StartLog(Constants::Developer::LOG_BLOCKS_BOOT);
 
-            ld::AdcChannelConfig adc_cfg[3];
+            { // ADC config
-            adc_cfg[0].InitSingle(ld::DaisySeed::GetPin(Constants::Hardware::PIN_POT_1));
+                ld::AdcChannelConfig adc_cfg[1];
+                adc_cfg[0].InitSingle(ld::DaisySeed::GetPin(Constants::Hardware::PIN_POT_1));
 
-            seed.adc.Init(adc_cfg, 1);
+                seed.adc.Init(adc_cfg, 1);
-            seed.adc.Start();
+                seed.adc.Start();
+            }
 
             scan_pots.set_period(10);
             scan_pots.set_callback([]() {
-                pot1.on_change_fuzzy(seed.adc.Get(0), 10, [](int val) {
+                pot1.on_change_fuzzy(seed.adc.Get(0), 20, [](int val) {
                     seed.PrintLine("POT_1: %d", val);
                 });
             });

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

examples/main_template_full.cc

@@ -1,8 +1,6 @@
-// Hecks perkons extension
-
-#include <functional>
 #include "main_template_full.hh"
 #include "utils.hh"
+#include <functional>
 
 namespace Heck {
     namespace { // anonymous namespace for internal linkage
@@ -13,12 +11,14 @@ namespace Heck {
 
         static ld::MidiUartHandler midi{};
 
+        Observer<int> pot1{};
+        SWTimer scan_pots{};
+
         // function prototypes
         void audio_callback(
             ld::AudioHandle::InputBuffer in,
             ld::AudioHandle::OutputBuffer out,
-            size_t size)
+            size_t size);
-            ;
         void midi_realtime_handler(const ld::MidiEvent& msg);
 
         void init()
@@ -27,6 +27,14 @@ namespace Heck {
             seed.Init(Constants::CPU_BOOST480MHZ);
             seed.StartLog(Constants::Developer::LOG_BLOCKS_BOOT);
 
+            {
+                ld::AdcChannelConfig adc_cfg[1];
+                adc_cfg[0].InitSingle(ld::DaisySeed::GetPin(Constants::Hardware::PIN_POT_1));
+
+                seed.adc.Init(adc_cfg, 1);
+                seed.adc.Start();
+            }
+
             seed.PrintLine("Setting Blocksize: %i", Constants::AUDIO_BUFFERSIZE);
             seed.SetAudioBlockSize(Constants::AUDIO_BUFFERSIZE);
 
@@ -91,7 +99,16 @@ namespace Heck {
         void mainloop()
         {
             seed.PrintLine("Entering MainLoop");
-            u32 systick_now{};
+            u32 time_boot_ms{};
+
+
+            scan_pots.set_period(10);
+            scan_pots.set_callback([]() {
+                pot1.on_change_fuzzy(seed.adc.Get(0), 10, [](int val) {
+                    seed.PrintLine("POT_1: %d", val);
+                });
+            });
+
 
             bool heartbeat_led_state{ false };
 
@@ -104,13 +121,14 @@ namespace Heck {
             });
 
             while (true) {
-                systick_now = ld::System::GetNow();
+                time_boot_ms = ld::System::GetNow();
 
                 while (midi.HasEvents()) {
                     midi_async_handler(midi.PopEvent());
                 }
 
-                heartbeat.is_it_already_time_again(systick_now);
+                scan_pots.is_it_already_time_again(time_boot_ms);
+                heartbeat.is_it_already_time_again(time_boot_ms);
             }
         }
     } // namespace

examples/main_template_full.hh

@@ -1,5 +1,5 @@
-#ifndef HECK_DAISY_GLOBALS_HH
+#ifndef HECK_LIBDIZZY_MAIN_TEMPLATE_FULL_HH
-#define HECK_DAISY_GLOBALS_HH
+#define HECK_LIBDIZZY_MAIN_TEMPLATE_FULL_HH
 
 #include <cstdint>
 #include "daisy_seed.h"
@@ -10,6 +10,7 @@ namespace Heck {
     namespace Constants {
         namespace Hardware {
 //            constexpr int PIN_BUTTON_RECORD = 28;
+            constexpr int PIN_POT_1 = 15;
         }
 
         constexpr bool CPU_BOOST480MHZ = false;

src/density.cc

@@ -1,7 +1,11 @@
 #include "density.hh"
 namespace Heck {
 
-    void Density::process(const f32 *inSourceP, f32 *inDestP, u32 size)
+    namespace Constants {
+        constexpr Samplerate AUDIO_SAMPLERATE = Samplerate::SAI_48KHZ;
+    }
+
+    void Density::process(const float *inSourceP, float *inDestP, u32 size)
     {
         UInt32 nSampleFrames = size;
         const Float32 *sourceP = inSourceP;

src/density.hh

@@ -4,22 +4,17 @@
 #include "types.hh"
 #include <array>
 
-namespace Heck::Constants {
-    constexpr Samplerate AUDIO_SAMPLERATE = Samplerate::SAI_48KHZ;
-}
-
 namespace Heck {
-
     struct Density {
         using Float32 = f32;
         using Float64 = f64;
         using UInt32 = u32;
 
-        static constexpr bool DO_DITHER{ false };
+        static constexpr bool DO_DITHER{ true };
 
-        std::array<f64, 4> params{ 0., 0., 1., 1. };
+        std::array<float, 4> params{ 0., 0., 1., 1. };
 
-        void process(const f32 * const inSourceP, f32 *inDestP, u32 size);
+        void process(const float *inSourceP, float *inDestP, u32 size);
 
     private:
         Float64 iirSampleA;

src/utils.hh

@@ -54,7 +54,7 @@ namespace Heck {
         }
 
     private:
-        static inline T val_current_{};
+        T val_current_{};
     };
 } // namespace Heck
 #endif // HECK_DAISY_UTILS_HH