Mike/hachikit cleanup

.gitignore

@@ -131,3 +131,9 @@ MyProjects/
 .cortex-debug.registers.state.json
 .cortex-debug.peripherals.state.json
 
+
+
+**/build
+**/.vscode
+
+

optic/HachiKit/AhdEnv.cpp

@@ -0,0 +1,40 @@
+#include "AhdEnv.h"
+#include "Utility.h"
+
+using namespace daisy;
+using namespace daisysp;
+
+void AhdEnv::Init(float sample_rate) {
+    ad.Init(sample_rate);
+    adsr.Init(sample_rate);
+    adsr.SetTime(ADSR_SEG_DECAY, 0.001);
+    adsr.SetSustainLevel(0.5);
+}
+
+float AhdEnv::Process() {
+    // The AD envelope is used to count off the gate time of the ADSR, providing the hold time.
+    ad.Process();
+    return adsr.Process(ad.IsRunning());
+}
+
+void AhdEnv::Trigger() {
+    ad.Trigger();
+    adsr.Retrigger(true);
+}
+
+void AhdEnv::SetAttack(float time) {
+    ad.SetTime(ADENV_SEG_ATTACK, time);
+    adsr.SetTime(ADSR_SEG_ATTACK, time);
+}
+
+void AhdEnv::SetHold(float time) {
+    ad.SetTime(ADENV_SEG_DECAY, time);
+}
+
+void AhdEnv::SetDecay(float time) {
+    adsr.SetTime(ADSR_SEG_RELEASE, time);
+}
+
+bool AhdEnv::IsRunning() const {
+    return adsr.IsRunning();
+}

optic/HachiKit/AhdEnv.h

@@ -0,0 +1,29 @@
+#ifndef AHDENV_H
+#define AHDENV_H
+
+#include "daisy_patch.h"
+#include "daisysp.h"
+
+using namespace daisy;
+using namespace daisysp;
+
+class AhdEnv {
+
+    public:
+        void Init(float sample_rate);
+        float Process();
+        void Trigger();
+        void SetAttack(float time);
+        void SetHold(float time);
+        void SetDecay(float time);
+        void SetCurve(float scalar);
+        bool IsRunning() const;
+
+    private:
+        AdEnv ad;
+        Adsr adsr;
+};
+
+
+
+#endif

optic/HachiKit/Bd8.cpp

@@ -0,0 +1,141 @@
+#include "Bd8.h"
+#include "Utility.h"
+
+using namespace daisy;
+using namespace daisysp;
+
+void Bd8::Init(std::string slot, float sample_rate) {
+    Init(slot, sample_rate, 78, 0.001, 4.0, 0.001, 0.1, 0.95);
+}
+
+void Bd8::Init(std::string slot, float sample_rate, float frequency, float ampAttack, float ampDecay, float pitchAttack, float pitchDecay, float modAmount) {
+
+    this->slot = slot;
+
+    // oscillator settings
+    osc.Init(sample_rate);
+    SetParam(PARAM_FREQUENCY, frequency);
+    osc.SetWaveform(Oscillator::WAVE_SIN);
+
+    // ampEnv settings
+    ampEnv.Init(sample_rate);
+    ampEnv.SetMax(1);
+    ampEnv.SetMin(0);
+    ampEnv.SetCurve(-100);
+    SetParam(PARAM_AMP_ATTACK, ampAttack);
+    SetParam(PARAM_AMP_DECAY, ampDecay);
+
+    // pitchEnv settings
+    pitchEnv.Init(sample_rate);
+    pitchEnv.SetMax(1);
+    pitchEnv.SetMin(0);
+    pitchEnv.SetCurve(-100);
+    SetParam(PARAM_PITCH_ATTACK, pitchAttack);
+    SetParam(PARAM_PITCH_DECAY, pitchDecay);
+    SetParam(PARAM_MOD_AMT, modAmount);
+}
+
+float Bd8::Process() {
+    float psig = pitchEnv.Process();
+    osc.SetFreq(parameters[PARAM_FREQUENCY].GetScaledValue() + parameters[PARAM_MOD_AMT].GetScaledValue() * psig);
+    // osc.SetFreq(parameters[PARAM_FREQUENCY].GetScaledValue());
+    return 2 * velocity * osc.Process() * ampEnv.Process();
+}
+
+void Bd8::Trigger(float velocity) {
+    this->velocity = Utility::Limit(velocity);
+    if (this->velocity > 0) {
+        osc.Reset();
+        ampEnv.Trigger();
+        pitchEnv.Trigger();
+    }
+}
+
+float Bd8::GetParam(uint8_t param) {
+    return param < PARAM_COUNT ? parameters[param].GetScaledValue() : 0.0f;
+}
+
+std::string Bd8::GetParamString(uint8_t param) {
+    if (param < PARAM_COUNT) {
+        switch (param) {
+            case PARAM_FREQUENCY: 
+            case PARAM_MOD_AMT: 
+                return std::to_string((int)GetParam(param));// + "hz";
+            case PARAM_AMP_ATTACK: 
+            case PARAM_AMP_DECAY: 
+            case PARAM_PITCH_ATTACK: 
+            case PARAM_PITCH_DECAY: 
+                return std::to_string((int)(GetParam(param) * 1000));// + "ms";
+        }
+    }
+   return "";
+ }
+
+float Bd8::UpdateParam(uint8_t param, float raw) {
+    float scaled = raw;
+    if (param < PARAM_COUNT) {
+        switch (param) {
+            case PARAM_FREQUENCY: 
+                scaled = parameters[param].Update(raw, Utility::ScaleFloat(raw, 20, 5000, Parameter::EXPONENTIAL));
+                break;
+            case PARAM_AMP_ATTACK: 
+                scaled = parameters[param].Update(raw, Utility::ScaleFloat(raw, 0.01, 5, Parameter::EXPONENTIAL));
+                ampEnv.SetTime(ADENV_SEG_ATTACK, scaled);
+                break;
+            case PARAM_AMP_DECAY: 
+                scaled = parameters[param].Update(raw, Utility::ScaleFloat(raw, 0.01, 5, Parameter::EXPONENTIAL));
+                ampEnv.SetTime(ADENV_SEG_DECAY, scaled);
+                break;
+            case PARAM_PITCH_ATTACK: 
+                scaled = parameters[param].Update(raw, Utility::ScaleFloat(raw, 0.01, 5, Parameter::EXPONENTIAL));
+                pitchEnv.SetTime(ADENV_SEG_ATTACK, scaled);
+                break;
+            case PARAM_PITCH_DECAY: 
+                scaled = parameters[param].Update(raw, Utility::ScaleFloat(raw, 0.01, 5, Parameter::EXPONENTIAL));
+                pitchEnv.SetTime(ADENV_SEG_DECAY, scaled);
+                break;
+            case PARAM_MOD_AMT: 
+                scaled = parameters[param].Update(raw, Utility::ScaleFloat(raw, 0, 2000, Parameter::EXPONENTIAL));
+                break;
+        }
+    }
+
+    return scaled;    
+}
+
+void Bd8::ResetParams() {
+    for (u8 param = 0; param < PARAM_COUNT; param++) {
+        parameters[param].Reset();
+    }
+}
+
+void Bd8::SetParam(uint8_t param, float scaled) {
+    if (param < PARAM_COUNT) {
+        switch (param) {
+            case PARAM_FREQUENCY: 
+                parameters[param].SetScaledValue(scaled);
+                break;
+            case PARAM_AMP_ATTACK: 
+                parameters[param].SetScaledValue(scaled);
+                ampEnv.SetTime(ADENV_SEG_ATTACK, scaled);
+                break;
+            case PARAM_AMP_DECAY: 
+                parameters[param].SetScaledValue(scaled);
+                ampEnv.SetTime(ADENV_SEG_DECAY, scaled);
+                break;
+            case PARAM_PITCH_ATTACK: 
+                parameters[param].SetScaledValue(scaled);
+                pitchEnv.SetTime(ADENV_SEG_ATTACK, scaled);
+                break;
+            case PARAM_PITCH_DECAY: 
+                parameters[param].SetScaledValue(scaled);
+                pitchEnv.SetTime(ADENV_SEG_DECAY, scaled);
+                break;
+            case PARAM_MOD_AMT: 
+                parameters[param].SetScaledValue(scaled);
+                break;
+        }
+    }
+
+}
+

optic/HachiKit/Bd8.h

@@ -0,0 +1,56 @@
+#ifndef BD8_H
+#define BD8_H
+
+#include "daisy_patch.h"
+#include "daisysp.h"
+#include <string>
+#include "IDrum.h"
+#include "Utility.h"
+#include "Param.h"
+
+using namespace daisy;
+using namespace daisysp;
+
+class Bd8: public IDrum {
+
+    public:
+        // Number of settable parameters for this model.
+        static const uint8_t PARAM_COUNT = 6;
+        // This is the order params will appear in the UI.
+        static const uint8_t PARAM_FREQUENCY = 0;
+        static const uint8_t PARAM_MOD_AMT = 1;
+        static const uint8_t PARAM_AMP_DECAY = 2;
+        static const uint8_t PARAM_PITCH_DECAY = 3;
+        static const uint8_t PARAM_AMP_ATTACK = 4;
+        static const uint8_t PARAM_PITCH_ATTACK = 5;
+        // TODO: add aCurve and pCurve
+
+        void Init(std::string slot, float sample_rate);
+        void Init(std::string slot, float sample_rate, float frequency, float ampAttack, float ampDecay, float pitchAttack, float pitchDecay, float modAmount);
+        float Process();
+        void Trigger(float velocity);
+
+        float GetParam(uint8_t param);
+        std::string GetParamString(uint8_t param);
+        float UpdateParam(uint8_t param, float value);
+        void SetParam(uint8_t param, float value);
+        void ResetParams();
+
+        std::string Name() { return "Bd8"; }
+        std::string Slot() { return slot; }
+        std::string GetParamName(uint8_t param) { return param < PARAM_COUNT ? paramNames[param] : ""; }
+
+    private:
+        std::string paramNames[PARAM_COUNT] = { "Freq", "Mod", "aDcy", "pDcy", "aAtk", "pAtk" };
+        std::string slot;
+        Param parameters[PARAM_COUNT];
+        Oscillator osc;
+        AdEnv ampEnv;
+        AdEnv pitchEnv;
+        float velocity;
+
+};
+
+
+
+#endif