commit too many things in prototyping stage

examples/Makefile

@@ -10,22 +10,23 @@ CXXFLAGS += -I$(LIBDIZZY_DIR)
 LDFLAGS += -L$(LIBDIZZY_DIR)
 LDFLAGS += -ldizzy
 
-SRC_EXCLUDED := \
-  main_adc_direct.cc \
-  main_memtest1.cc \
-  main_minimal.c \
-  main_cpuload.cc
-#  main_adc.cc \
-#  main_blink.cc \
-#  main_cli.cc \
-#  main_density.cc \
-#  main_framework_proto1.cc \
-#  main_framework_proto2.cc \
-#  main_memtest1.cc \
-#  main_minimal.cc \
-#  main_template_full.cc \
-#  main_testtone.cc \
-#  main_usbhost.cc \
+SRC_EXCLUDED :=
+#SRC_EXCLUDED += main_adc.cc
+SRC_EXCLUDED += main_adc_direct.cc
+#SRC_EXCLUDED += main_console.cc
+#SRC_EXCLUDED += main_cli.cc
+SRC_EXCLUDED += main_memtest1.cc
+SRC_EXCLUDED += main_minimal.c
+SRC_EXCLUDED += main_cpuload.cc
+#SRC_EXCLUDED += main_blink.cc
+#SRC_EXCLUDED += main_density.cc
+SRC_EXCLUDED += main_framework_proto1.cc
+SRC_EXCLUDED += main_framework_proto2.cc
+SRC_EXCLUDED += main_memtest1.cc
+SRC_EXCLUDED += main_minimal.cc
+SRC_EXCLUDED += main_template_full.cc
+SRC_EXCLUDED += main_testtone.cc
+SRC_EXCLUDED += main_usbhost.cc
 
 
 SOURCES := $(wildcard *)

examples/main_adc.cc

@@ -1,18 +1,21 @@
 #include "main_adc.hh"
-#include "utils.hh"
+#include "dizzy.hh"
 
 namespace Heck {
     namespace { // anonymous namespace for internal linkage
         ld::DaisySeed seed{};
 
-        Cache<u16> pot1{ []() { return seed.adc.Get(0); },
-                         [](Cache<u16>& cache) { seed.PrintLine("POT_1: %d", cache.read()); } };
+        dz::Cache<u16> pot1{ []() { return seed.adc.Get(0); },
+                             [](dz::Cache<u16>& cache) {
+                                 seed.PrintLine("POT_1: %d", cache.read());
+                             } };
 
-        void scan_pots(u32) {
+        void scan_pots(u32)
+        {
             pot1.update_and_notify_change();
         }
 
-        PeriodicTaskCT<scan_pots, 10> task_scan_pots{};
+        dz::PeriodicTaskCT<scan_pots, 10> task_scan_pots{};
 
         void init()
         {

examples/main_adc.hh

@@ -1,8 +1,7 @@
 #ifndef HECK_MAIN_ADC_HH
 #define HECK_MAIN_ADC_HH
 
-#include <functional>
-#include "types.hh"
+#include "dizzy.hh"
 
 namespace Heck {
     namespace Constants {

examples/main_blink.cc

@@ -1,5 +1,4 @@
-#include "daisy_seed.h"
-#include "types.hh"
+#include "dizzy.hh"
 
 namespace Heck {
     namespace Constants {

examples/main_cli.cc

@@ -0,0 +1,16 @@
+#include "dizzy.hh"
+
+ld::DaisySeed seed{};
+
+int main()
+{
+    seed.Init();
+    ld::DaisySeed::StartLog(true);
+    ld::DaisySeed::PrintLine("booting...");
+    dz::CLI::init(seed);
+
+    while (true) {
+        dz::CLI::process();
+    }
+
+}

examples/main_console.cc

@@ -0,0 +1,58 @@
+#include "dizzy.hh"
+
+ld::DaisySeed seed{};
+
+struct Time {
+    Time()
+    {
+        msec = seed.system.GetNow();
+        usec = seed.system.GetUs();
+        tick = seed.system.GetTick();
+    }
+
+    u32 msec;
+    u32 usec;
+    u32 tick;
+};
+
+
+std::string to_string(Time &obj)
+{
+    std::string ret{ "Time: " };
+    ret += std::to_string(obj.msec);
+    ret += " / ";
+    ret += std::to_string(obj.usec);
+    ret += "  / ";
+    ret += std::to_string(obj.tick);
+    return ret;
+}
+
+void print_uptime(u32 time)
+{
+    Time t{};
+    std::string str{ to_string(t) + "\n\r" };
+    dz::Console::tx(str.c_str(), str.size());
+}
+
+dz::PeriodicTaskCT<print_uptime, 1000> task1{};
+
+int main(void)
+{
+    seed.Init();
+
+    dz::Console::init();
+    while (!dz::Console::has_next()) {};
+
+    std::string motd{ "dizzy console\n" };
+    dz::Console::tx(motd.c_str(), motd.size());
+
+    while (true) {
+        Time time_mainloop_begin{};
+        while (dz::Console::has_next()) {
+            char b = dz::Console::rx();
+            dz::Console::tx(&b, 1);
+        }
+
+        task1.run_pending(time_mainloop_begin.msec);
+    }
+}

examples/main_density.cc

@@ -1,7 +1,5 @@
 #include "main_density.hh"
-#include "utils.hh"
 #include <functional>
-#include "density.hh"
 
 namespace Heck {
     namespace { // anonymous namespace for internal linkage
@@ -14,14 +12,14 @@ namespace Heck {
 
         std::array<float, 4> pots_value{};
 
-        Observer<int> pot1{};
-        Observer<int> pot2{};
-        Observer<int> pot3{};
-        Observer<int> pot4{};
+        dz::Observer<int> pot1{};
+        dz::Observer<int> pot2{};
+        dz::Observer<int> pot3{};
+        dz::Observer<int> pot4{};
 
-        SWTimer scan_pots{};
+        dz::SWTimer scan_pots{};
 
-        Density density{};
+        dz::Density density{};
 
         // function prototypes
         void audio_callback(
@@ -109,7 +107,7 @@ namespace Heck {
         void midi_async_handler(const ld::MidiEvent& msg)
         {
             char strbuf[128];
-            GetMidiTypeAsString(msg, &strbuf[0]);
+            dz::GetMidiTypeAsString(msg, &strbuf[0]);
             seed.PrintLine("%s", strbuf);
             return;
         }
@@ -147,7 +145,7 @@ namespace Heck {
 
             bool heartbeat_led_state{ false };
 
-            SWTimer heartbeat{};
+            dz::SWTimer heartbeat{};
             heartbeat.set_period(100);
             heartbeat.set_callback([&heartbeat_led_state](u32 time_now) {
                 heartbeat_led_state = !heartbeat_led_state;

examples/main_density.hh

@@ -1,15 +1,11 @@
 #ifndef HECK_LIBDIZZY_MAIN_DENSITY_HH
 #define HECK_LIBDIZZY_MAIN_DENSITY_HH
 
-#include <cstdint>
-#include "daisy_seed.h"
-#include "daisysp.h"
-#include "types.hh"
+#include "dizzy.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;
@@ -18,7 +14,7 @@ namespace Heck {
 
         constexpr bool CPU_BOOST480MHZ = false;
         constexpr int AUDIO_BUFFERSIZE = 4;
-        constexpr Samplerate AUDIO_SAMPLERATE = Samplerate::SAI_48KHZ;
+        constexpr dz::Samplerate AUDIO_SAMPLERATE = dz::Samplerate::SAI_48KHZ;
 
         namespace Developer {
             constexpr bool LOG_BLOCKS_BOOT = false;
@@ -27,7 +23,6 @@ namespace Heck {
 
     //Hardware
     extern ld::DaisySeed seed;
-    //    extern ld::Switch but_rec;
 } // namespace Heck
 
 

src/cli.hh

@@ -0,0 +1,58 @@
+#ifndef HECK_DIZZY_CLI_HH
+#define HECK_DIZZY_CLI_HH
+
+#include <map>
+#include <functional>
+#include "dizzy_types.hh"
+#include "console.hh"
+#include <string>
+
+
+namespace Heck::Dizzy {
+    namespace CLI {
+        using command_function = std::function<void()>;
+
+        inline std::string command_buf;
+        inline std::map<std::string, command_function> command_table;
+
+        inline void command_test()
+        {
+            ld::DaisySeed::PrintLine("test");
+        }
+
+        inline void init(ld::DaisySeed& seed)
+        {
+            Console::init();
+            ld::DaisySeed::PrintLine("Dizzy-CLI");
+            ld::DaisySeed::Print("> ");
+            command_table.emplace("test", &command_test);
+        }
+
+        inline void process()
+        {
+            while (Console::has_next()) {
+                u8 c = Console::rx();
+                if (c == 13) { //Enter
+                    //echo
+                    ld::DaisySeed::PrintLine("");
+                    if (!command_buf.empty()) {
+                        command_function func = command_table[command_buf];
+                        if (func) {
+                            ld::DaisySeed::PrintLine("running command: %s", command_buf.data());
+                            func();
+                        } else {
+                            ld::DaisySeed::PrintLine("error: unknown command: %s", command_buf.data());
+                        }
+                        command_buf.clear();
+                    }
+                    ld::DaisySeed::Print("> ");
+                } else {
+                    //echo
+                    ld::DaisySeed::Print("%c", c);
+                    command_buf.push_back(static_cast<char>(c));
+                }
+            }
+        }
+    } // namespace CLI
+} // namespace Heck::Dizzy
+#endif

src/console.cc

@@ -0,0 +1,52 @@
+#include "console.hh"
+#include <deque>
+#include "hid/usb.h"
+
+namespace Heck::Dizzy {
+    namespace Console {
+
+        struct Session {
+            std::deque<char> rx_buff;
+            daisy::UsbHandle usb_handle;
+        };
+
+        static Session session_{};
+
+
+        extern "C" void usb_rx_callback(u8* buff, u32* length)
+        {
+            if (buff && length) {
+                for (u32 i = 0; i < *length; i++) {
+                    session_.rx_buff.emplace_back(buff[i]);
+                }
+            }
+        }
+
+        void init()
+        {
+            session_.usb_handle.Init(daisy::UsbHandle::FS_INTERNAL);
+            session_.usb_handle.SetReceiveCallback(
+                usb_rx_callback,
+                daisy::UsbHandle::UsbPeriph::FS_INTERNAL);
+        }
+
+        bool has_next()
+        {
+            return !session_.rx_buff.empty();
+        }
+
+        char rx()
+        {
+            char ret{ session_.rx_buff.front() };
+            session_.rx_buff.pop_front();
+            return ret;
+        }
+
+        bool tx(const char* buffer, size_t len)
+        {
+            return daisy::UsbHandle::Result::OK ==
+                   session_.usb_handle.TransmitInternal((uint8_t*)buffer, len);
+        }
+
+    } // namespace Console
+} // namespace Heck::Dizzy

src/console.hh

@@ -0,0 +1,15 @@
+#ifndef HECK_DIZZY_CONSOLE_HH
+#define HECK_DIZZY_CONSOLE_HH
+
+#include "dizzy_types.hh"
+
+namespace Heck::Dizzy {
+    namespace Console {
+        void init();
+        bool has_next();
+        char rx();
+        bool tx(const char *buffer, size_t len);
+    } // namespace Console
+} // namespace Heck::Dizzy
+
+#endif

src/density.cc

@@ -1,5 +1,5 @@
 #include "density.hh"
-namespace Heck {
+namespace Heck::Dizzy {
 
     namespace Constants {
         constexpr Samplerate AUDIO_SAMPLERATE = Samplerate::SAI_48KHZ;
@@ -111,4 +111,4 @@ namespace Heck {
             destP++;
         }
     }
-} // namespace Heck
+} // namespace Heck::Dizzy

src/density.hh

@@ -1,10 +1,10 @@
-#ifndef HECK_OSP_DENSITY
-#define HECK_OSP_DENSITY
+#ifndef HECK_DIZZY_DENSITY_HH
+#define HECK_DIZZY_DENSITY_HH
 
-#include "types.hh"
+#include "dizzy_types.hh"
 #include <array>
 
-namespace Heck {
+namespace Heck::Dizzy {
     struct Density {
         using Float32 = f32;
         using Float64 = f64;
@@ -24,5 +24,5 @@ namespace Heck {
     };
 
 
-} // namespace Heck
+} // namespace Heck::Dizzy
 #endif

src/dizzy.hh

@@ -0,0 +1,12 @@
+#ifndef HECK_DIZZY_HH
+#define HECK_DIZZY_HH
+
+#include "dizzy_types.hh"
+#include "utils.hh"
+#include "console.hh"
+#include "cli.hh"
+#include "density.hh"
+
+namespace dz = Heck::Dizzy;
+
+#endif

src/dizzy_types.hh

@@ -0,0 +1,16 @@
+#ifndef HECK_DIZZY_TYPES_HH
+#define HECK_DIZZY_TYPES_HH
+
+#include "heck_types.hh"
+#include "daisy_seed.h"
+#include "daisysp.h"
+
+namespace ld = daisy;
+namespace dsp = daisysp;
+using namespace Heck::Types;
+
+namespace Heck::Dizzy {
+    using Samplerate = ld::SaiHandle::Config::SampleRate;
+} // namespace Heck::Dizzy
+
+#endif

src/heck_types.hh

@@ -0,0 +1,22 @@
+#ifndef HECK_TYPES_HH
+#define HECK_TYPES_HH
+
+#include <cstdint>
+
+namespace Heck::Types {
+    // fundamental types
+    using u8 = uint8_t;
+    using u16 = uint16_t;
+    using u32 = uint32_t;
+    using u64 = uint64_t;
+
+    using i8 = int8_t;
+    using i16 = int16_t;
+    using i32 = int32_t;
+    using i64 = int64_t;
+
+    using f32 = float;
+    using f64 = double;
+} // namespace Heck::Types
+
+#endif

src/types.hh

@@ -1,36 +0,0 @@
-#ifndef HECK_DAISY_TYPES_HH
-#define HECK_DAISY_TYPES_HH
-
-#include <cstdint>
-#include "daisy_seed.h"
-#include "daisysp.h"
-
-namespace Heck {
-    namespace Types {
-        // fundamental types
-        using u8 = uint8_t;
-        using u16 = uint16_t;
-        using u32 = uint32_t;
-        using u64 = uint64_t;
-
-        using i8 = int8_t;
-        using i16 = int16_t;
-        using i32 = int32_t;
-        using i64 = int64_t;
-
-        using f32 = float;
-        using f64 = double;
-    }
-
-    using namespace Types;
-    // namespace aliases
-    namespace ld = daisy;
-    namespace dsp = daisysp;
-
-    // type aliases from libs
-    using Samplerate = ld::SaiHandle::Config::SampleRate;
-
-} // namespace Heck
-
-
-#endif

src/utils.cc

@@ -1,6 +1,6 @@
 #include "utils.hh"
 
-namespace Heck {
+namespace Heck::Dizzy {
 
     void GetMidiTypeAsString(const ld::MidiEvent& msg, char* str)
     {
@@ -91,9 +91,9 @@ namespace Heck {
         float ret = min + (val * range);
         return ret;
     }
-} // namespace Heck
+} // namespace Heck::Dizzy
 
-namespace Heck {
+namespace Heck::Dizzy {
     void SWTimer::set_period(u32 time_units)
     {
         time_period_ = time_units;
@@ -116,4 +116,4 @@ namespace Heck {
         }
         return false;
     }
-} // namespace Heck
+} // namespace Heck::Dizzy

src/utils.hh

@@ -1,19 +1,31 @@
-#ifndef HECK_DAISY_UTILS_HH
-#define HECK_DAISY_UTILS_HH
+#ifndef HECK_DIZZY_UTILS_HH
+#define HECK_DIZZY_UTILS_HH
 
-#include "daisy_seed.h"
-#include "types.hh"
+#include "dizzy_types.hh"
 
-namespace Heck {
+
+// ---------------------------------------------------------
+// String representations
+// ---------------------------------------------------------
+namespace Heck::Dizzy {
     void GetMidiTypeAsString(const ld::MidiEvent& msg, char* str);
     void GetMidiRTTypeAsString(const ld::MidiEvent& msg, char* str);
+} // namespace Heck::Dizzy
 
+// ---------------------------------------------------------
+// Scaling
+// ---------------------------------------------------------
+namespace Heck::Dizzy {
     float scalen_min_max(float val, float min, float max);
     float scalen_center_range(float val, float center, float range);
-} // namespace Heck
+} // namespace Heck::Dizzy
+
 
 
-namespace Heck {
+// ---------------------------------------------------------
+// SWTimer
+// ---------------------------------------------------------
+namespace Heck::Dizzy {
     class SWTimer {
     public:
         using Callback = std::function<void(u32 time)>;
@@ -28,6 +40,47 @@ namespace Heck {
         u32 time_period_{};
     };
 
+    // !!!
+    // constexpr function pointer
+    // !!!
+//    template<auto F>
+//    struct FunctionPtr {
+//        constexpr FunctionPtr() = default;
+//        static void call()
+//        {
+//            F();
+//        }
+//    };
+
+
+
+    template<void (*TASK)(u32), int PERIOD>
+    class PeriodicTaskCT {
+    public:
+        PeriodicTaskCT() = default;
+
+        PeriodicTaskCT(PeriodicTaskCT&) = delete;
+        PeriodicTaskCT& operator=(PeriodicTaskCT&) = delete;
+
+        PeriodicTaskCT(PeriodicTaskCT&&) = delete;
+        PeriodicTaskCT& operator=(PeriodicTaskCT&&) = delete;
+
+        ~PeriodicTaskCT() = default;
+
+        bool run_pending(u32 time_now)
+        {
+            if (time_now - time_last_exec_ >= PERIOD) {
+                time_last_exec_ = time_now;
+                TASK(time_now);
+                return true;
+            }
+            return false;
+        }
+
+    private:
+        u32 time_last_exec_{};
+    };
+
     class PeriodicTask {
     public:
         using Task = std::function<void(u32 time)>;
@@ -80,10 +133,15 @@ namespace Heck {
         u32 time_last_exec_{};
         u32 time_period_{};
     };
-} // namespace Heck
+} // namespace Heck::Dizzy
 
-namespace Heck {
-    template<typename T> class Observer {
+
+// ---------------------------------------------------------
+// Observer
+// ---------------------------------------------------------
+namespace Heck::Dizzy {
+    template<typename T>
+    class Observer {
 
     public:
         bool on_change(T val_new, std::function<void(T val_current)> fn)
@@ -110,7 +168,8 @@ namespace Heck {
         T val_current_{};
     };
 
-    template<typename T> class PollingObserver {
+    template<typename T>
+    class PollingObserver {
 
     public:
         using FetchCallback = std::function<T(void)>;
@@ -173,28 +232,33 @@ namespace Heck {
         FetchCallback fetch_cb_{};
         DeliverCallback deliver_cb_{};
     };
-} // namespace Heck
+} // namespace Heck::Dizzy
+
 
-namespace Heck {
-    template<typename T> class Cache {
+// ---------------------------------------------------------
+// Cache
+// ---------------------------------------------------------
+namespace Heck::Dizzy {
+    template<typename T>
+    class Cache {
 
     public:
         using UpdateCallback = std::function<T(void)>;
         using NotifyChangeCallback = std::function<void(Cache<T>&)>;
 
-        Cache() = delete;
-        ~Cache() = default;
 
         explicit Cache(UpdateCallback update_cb, NotifyChangeCallback notify_change_cb)
         {
             init(update_cb, notify_change_cb);
         }
 
+        Cache() = delete;
         Cache(Cache&) = delete;
         Cache& operator=(Cache) = delete;
 
         Cache(Cache&&) = delete;
         Cache& operator=(Cache&&) = delete;
+        ~Cache() = default;
 
         T read()
         {
@@ -245,6 +309,12 @@ namespace Heck {
         NotifyChangeCallback notify_change_cb_{};
     };
 
+} // namespace Heck::Dizzy
+
+// ---------------------------------------------------------
+// DigitalIn
+// ---------------------------------------------------------
+namespace Heck::Dizzy {
     struct DigitalIn {
     public:
         DigitalIn() = default;
@@ -279,5 +349,5 @@ namespace Heck {
     };
 
 
-} // namespace Heck
+} // namespace Heck::Dizzy
 #endif // HECK_DAISY_UTILS_HH`