heck
/
heck_daisy_osp
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
Browse Source

update for libdizzy moved into own namespace

master
heck 8 months ago
parent
51bb0adae1
commit
ffecf54f90
10 changed files with 80 additions and 71 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      src/instr_bd2.cc
  2. 2
      src/instr_fm.cc
  3. 6
      src/instr_grainlet.cc
  4. 6
      src/instr_hihat.cc
  5. 8
      src/instr_kick.cc
  6. 8
      src/instr_zosc.cc
  7. 95
      src/main_osp.cc
  8. 7
      src/main_osp.hh
  9. 2
      src/osp_types.hh
  10. 9
      src/track.hh

8
src/instr_bd2.cc
View File

@ -30,16 +30,16 @@ namespace Heck::OSP {
{ {
switch (ctl_nr) { switch (ctl_nr) {
case 0: { case 0: {
bd2.SetFreq(scalen_min_max(val, 40, 180)); bd2.SetFreq( dz::scalen_min_max(val, 40, 180));
} break; } break;
case 1: { case 1: {
bd2.SetDecay(scalen_min_max(val,0,1)); bd2.SetDecay( dz::scalen_min_max(val,0,1));
} break; } break;
case 2: { case 2: {
bd2.SetFmEnvelopeAmount(scalen_min_max(val,0,1)); bd2.SetFmEnvelopeAmount( dz::scalen_min_max(val,0,1));
} break; } break;
case 3: { case 3: {
bd2.SetFmEnvelopeDecay(scalen_min_max(val,0,1)); bd2.SetFmEnvelopeDecay( dz::scalen_min_max(val,0,1));
} break; } break;
} }
} }

2
src/instr_fm.cc
View File

@ -32,7 +32,7 @@ namespace Heck::OSP {
case 1: case 1:
break; break;
case 2: { case 2: {
float ratio_val = scalen_min_max(val, 1., 3.); float ratio_val = dz::scalen_min_max(val, 1., 3.);
osc.SetRatio(ratio_val); osc.SetRatio(ratio_val);
} break; } break;
case 3: case 3:

6
src/instr_grainlet.cc
View File

@ -23,16 +23,16 @@ namespace Heck::OSP {
{ {
switch (ctl_nr) { switch (ctl_nr) {
case 0: { case 0: {
grainlet.SetFreq(scalen_min_max(val, 40, 400)); grainlet.SetFreq( dz::scalen_min_max(val, 40, 400));
} break; } break;
case 1: { case 1: {
} break; } break;
case 2: { case 2: {
grainlet.SetFormantFreq(scalen_min_max(val, 400, 2000)); grainlet.SetFormantFreq( dz::scalen_min_max(val, 400, 2000));
} break; } break;
case 3: { case 3: {
grainlet.SetShape(scalen_min_max(val, 0, 1)); grainlet.SetShape( dz::scalen_min_max(val, 0, 1));
} break; } break;
} }
} }

6
src/instr_hihat.cc
View File

@ -25,16 +25,16 @@ namespace Heck::OSP {
{ {
switch (ctl_nr) { switch (ctl_nr) {
case 0: { case 0: {
hihat.SetFreq(scalen_min_max(val, 800, 2000)); hihat.SetFreq( dz::scalen_min_max(val, 800, 2000));
} break; } break;
case 1: { case 1: {
} break; } break;
case 2: { case 2: {
hihat.SetTone(scalen_min_max(val, 0, 1)); hihat.SetTone( dz::scalen_min_max(val, 0, 1));
} break; } break;
case 3: { case 3: {
hihat.SetNoisiness(scalen_min_max(val, 0, 1)); hihat.SetNoisiness( dz::scalen_min_max(val, 0, 1));
} break; } break;
} }
} }

8
src/instr_kick.cc
View File

@ -39,19 +39,19 @@ namespace Heck::OSP {
{ {
switch (ctl_nr) { switch (ctl_nr) {
case 0: { case 0: {
float relpitch = scalen_min_max(val, 40, 400); float relpitch = dz::scalen_min_max(val, 40, 400);
osc.SetFreq(relpitch); osc.SetFreq(relpitch);
pitchEnv.SetMax(relpitch * 0.03); pitchEnv.SetMax(relpitch * 0.03);
pitchEnv.SetMin(relpitch); pitchEnv.SetMin(relpitch);
} break; } break;
case 1: { case 1: {
// pitchEnv.SetTime(dsp::ADSR_SEG_DECAY, scalen_min_max(val, 0.01, 0.4)); // pitchEnv.SetTime(dsp::ADSR_SEG_DECAY, dz::scalen_min_max(val, 0.01, 0.4));
} break; } break;
case 2: { case 2: {
osc.SetPw(scalen_min_max(val, 0, 1)); osc.SetPw(dz::scalen_min_max(val, 0, 1));
} break; } break;
case 3: { case 3: {
chorus.SetDelay(scalen_min_max(val, 0.1, 0.9)); chorus.SetDelay(dz::scalen_min_max(val, 0.1, 0.9));
} break; } break;
} }
} }

8
src/instr_zosc.cc
View File

@ -24,16 +24,16 @@ namespace Heck::OSP {
{ {
switch (ctl_nr) { switch (ctl_nr) {
case 0: { case 0: {
zosc.SetFreq(scalen_min_max(val, 40, 180)); zosc.SetFreq(dz::scalen_min_max(val, 40, 180));
} break; } break;
case 1: { case 1: {
// zosc.SetDecay(scalen_min_max(val,0,1)); // zosc.SetDecay( dz::scalen_min_max(val,0,1));
} break; } break;
case 2: { case 2: {
zosc.SetFormantFreq(scalen_min_max(val, 200, 800)); zosc.SetFormantFreq(dz::scalen_min_max(val, 200, 800));
} break; } break;
case 3: { case 3: {
zosc.SetShape(1. - scalen_min_max(val, 0, 1)); zosc.SetShape(1. - dz::scalen_min_max(val, 0, 1));
} break; } break;
} }
} }

95
src/main_osp.cc
View File

@ -14,7 +14,14 @@
#include "instr_hihat.hh" #include "instr_hihat.hh"
#include "instr_zosc.hh" #include "instr_zosc.hh"
namespace Heck { // DTCM_MEM_SECTION
// DMA_BUFFER_MEM_SECTION
// DSY_SDRAM_DATA
// DSY_SDRAM_BSS
float DSY_SDRAM_BSS sdram_block1[4000000];
namespace Heck::OSP {
namespace State { namespace State {
bool record_mode{ false }; bool record_mode{ false };
bool clear_mode{ false }; bool clear_mode{ false };
@ -88,43 +95,45 @@ namespace Heck {
// ============================================================================================= // =============================================================================================
void audio_callback(ld::AudioHandle::InputBuffer in, ld::AudioHandle::OutputBuffer out, size_t size) Sig::RingBuffer<30000> buff1{};
Sig::Delay101<30000> dly1{};
volatile float sig_in[Constants::AUDIO_BUFFERSIZE];
volatile float sig_out[Constants::AUDIO_BUFFERSIZE];
volatile float delaytime{};
volatile float delayfb{};
float sig_dly1{};
float sig_osp{};
float sig_bus{};
void process_signals()
{ {
float sig_out{}; for (size_t i = 0; i < Constants::AUDIO_BUFFERSIZE; i++) {
for (size_t i = 0; i < size; i++) { sig_osp = tracks[0].nextsample();
for (int i = 0; i < Constants::TRACK_COUNT; i++) { sig_osp += tracks[1].nextsample();
sig_out += tracks[i].nextsample(); sig_osp += tracks[2].nextsample();
} sig_osp += tracks[3].nextsample();
sig_out *= 0.1;
out[0][i] = sig_out; sig_bus = sig_osp + sig_in[i];
dly1.delayfb_ = delayfb;
dly1.delaytime_ = delaytime;
sig_bus += dly1.process(sig_bus);
sig_out[i] = sig_bus;
} }
} }
void audio_callback(ld::AudioHandle::InputBuffer in, ld::AudioHandle::OutputBuffer out, size_t size) void audio_callback(ld::AudioHandle::InputBuffer in, ld::AudioHandle::OutputBuffer out, size_t size)
{ {
// Output 1 for (size_t i = 0; i < size; i++) {
{ sig_in[i] = in[0][i];
float sig_out{};
float sig_osp{};
float sig_ext_in_1{};
float sig_ext_in_2{};
for (size_t i = 0; i < size; i++) {
for (int i = 0; i < Constants::TRACK_COUNT; i++) {
sig_osp += tracks[i].nextsample();
}
sig_osp /= Constants::TRACK_COUNT;
sig_ext_in_1 = in[0][i];
sig_ext_in_2 = in[1][i];
out[0][i] = sig_osp + sig_ext_in_1 + sig_ext_in_2 / 3.;
out[1][i] = out[0][i];
}
} }
// Output 2 process_signals();
if constexpr (false) {
for (size_t i = 0; i < size; i++) { for (size_t i = 0; i < size; i++) {
out[1][i] = in[1][i]; out[0][i] = sig_out[i];
} out[1][i] = sig_out[i];
} }
} }
@ -153,7 +162,7 @@ namespace Heck {
} }
} }
void midi_in_from_uart_polling(ld::MidiEvent msg, bool from_seq) void midi_dispatch(ld::MidiEvent msg, bool from_seq)
{ {
switch (msg.type) { switch (msg.type) {
case ld::MidiMessageType::NoteOn: { case ld::MidiMessageType::NoteOn: {
@ -188,9 +197,11 @@ namespace Heck {
break; break;
case Constants::MIDI_Mapping::TRACK_FILTER: case Constants::MIDI_Mapping::TRACK_FILTER:
tracks[cc.channel].filter(val_normalized); tracks[cc.channel].filter(val_normalized);
delaytime = val_normalized;
break; break;
case Constants::MIDI_Mapping::TRACK_DRIVE: case Constants::MIDI_Mapping::TRACK_DRIVE:
tracks[cc.channel].drive(val_normalized); tracks[cc.channel].drive(val_normalized);
delayfb = val_normalized;
break; break;
case Constants::MIDI_Mapping::TRACK_VOLUME: case Constants::MIDI_Mapping::TRACK_VOLUME:
tracks[cc.channel].volume(val_normalized); tracks[cc.channel].volume(val_normalized);
@ -216,20 +227,20 @@ namespace Heck {
} }
} }
void midi_in_from_uart_interrupt() void midi_from_uart()
{ {
while (midi.HasEvents()) { while (midi.HasEvents()) {
ld::MidiEvent msg = midi.PopEvent(); ld::MidiEvent msg = midi.PopEvent();
event_log.PushBack(msg); event_log.PushBack(msg);
midi_in_from_uart_polling(msg, false); midi_dispatch(msg, false);
} }
} }
void midi_in_from_sequencer() void midi_from_sequencer()
{ {
std::vector<ld::MidiEvent> queue = sequencer.midi_out(); std::vector<ld::MidiEvent> queue = sequencer.midi_out();
for (ld::MidiEvent msg : queue) { for (ld::MidiEvent msg : queue) {
midi_in_from_uart_polling(msg, true); midi_dispatch(msg, true);
} }
} }
@ -240,14 +251,14 @@ namespace Heck {
bool heartbeat_led_state{ false }; bool heartbeat_led_state{ false };
SWTimer heartbeat{}; dz::SWTimer heartbeat{};
heartbeat.set_period(100); heartbeat.set_period(100);
heartbeat.set_callback([&heartbeat_led_state](u32 time_now) { heartbeat.set_callback([&heartbeat_led_state](u32 time_now) {
heartbeat_led_state = !heartbeat_led_state; heartbeat_led_state = !heartbeat_led_state;
seed.SetLed(heartbeat_led_state); seed.SetLed(heartbeat_led_state);
}); });
SWTimer async_log_tx{}; dz::SWTimer async_log_tx{};
async_log_tx.set_period(5); async_log_tx.set_period(5);
async_log_tx.set_callback([](u32 time_now) { async_log_tx.set_callback([](u32 time_now) {
if (!event_log.IsEmpty()) { if (!event_log.IsEmpty()) {
@ -257,7 +268,7 @@ namespace Heck {
if constexpr (Constants::Developer::LOG_MIDI_REALTIME) { if constexpr (Constants::Developer::LOG_MIDI_REALTIME) {
char outstr[256]; char outstr[256];
char rttype_str[32]; char rttype_str[32];
GetMidiRTTypeAsString(msg, rttype_str); dz::GetMidiRTTypeAsString(msg, rttype_str);
sprintf(outstr, "RT: type: %s\n", rttype_str); sprintf(outstr, "RT: type: %s\n", rttype_str);
if (msg.srt_type != ld::TimingClock) { if (msg.srt_type != ld::TimingClock) {
seed.PrintLine("%s", outstr); seed.PrintLine("%s", outstr);
@ -270,7 +281,7 @@ namespace Heck {
if constexpr (Constants::Developer::LOG_MIDI_NOTESANDCC) { if constexpr (Constants::Developer::LOG_MIDI_NOTESANDCC) {
char outstr[256]; char outstr[256];
char type_str[32]; char type_str[32];
GetMidiTypeAsString(msg, type_str); dz::GetMidiTypeAsString(msg, type_str);
sprintf( sprintf(
outstr, outstr,
"time-last:\t%ld\ttype: %s\tChannel: %d\tData MSB: " "time-last:\t%ld\ttype: %s\tChannel: %d\tData MSB: "
@ -302,6 +313,8 @@ namespace Heck {
int clock_16n_new{}; int clock_16n_new{};
int clock_16n_current{}; int clock_16n_current{};
buff1.init(sdram_block1);
dly1.init(&buff1);
while (1) { while (1) {
// Get current values for state // Get current values for state
@ -332,8 +345,8 @@ namespace Heck {
sequencer.next_step(); sequencer.next_step();
} }
midi_in_from_sequencer(); midi_from_sequencer();
midi_in_from_uart_interrupt(); midi_from_uart();
// REC // REC
but_rec.Debounce(); but_rec.Debounce();

7
src/main_osp.hh
View File

@ -1,10 +1,7 @@
#ifndef HECK_OSP_GLOBALS_HH #ifndef HECK_OSP_GLOBALS_HH
#define HECK_OSP_GLOBALS_HH #define HECK_OSP_GLOBALS_HH
#include <cstdint> #include "dizzy.hh"
#include "daisy_seed.h"
#include "daisysp.h"
#include "osp_types.hh"
namespace Heck::OSP { namespace Heck::OSP {
namespace Constants { namespace Constants {
@ -15,7 +12,7 @@ namespace Heck::OSP {
constexpr bool CPU_BOOST480MHZ = false; constexpr bool CPU_BOOST480MHZ = false;
constexpr int AUDIO_BUFFERSIZE = 4; constexpr int AUDIO_BUFFERSIZE = 4;
constexpr Samplerate AUDIO_SAMPLERATE = Samplerate::SAI_48KHZ; constexpr dz::Samplerate AUDIO_SAMPLERATE = dz::Samplerate::SAI_48KHZ;
constexpr int TRACK_COUNT = 4; constexpr int TRACK_COUNT = 4;
namespace MIDI_Mapping { namespace MIDI_Mapping {

2
src/osp_types.hh
View File

@ -1,6 +1,6 @@
#ifndef HECK_OSP_TYPES_HH #ifndef HECK_OSP_TYPES_HH
#define HECK_OSP_TYPES_HH #define HECK_OSP_TYPES_HH
#include "types.hh" #include "dizzy_types.hh"
#endif #endif

9
src/track.hh
View File

@ -1,9 +1,8 @@
#ifndef HECK_OSP_TRACK_HH #ifndef HECK_OSP_TRACK_HH
#define HECK_OSP_TRACK_HH #define HECK_OSP_TRACK_HH
#include "daisysp.h"
#include "instr_interface.hh" #include "instr_interface.hh"
#include "osp_utils.hh" #include "dizzy.hh"
#include "main_osp.hh" #include "main_osp.hh"
namespace Heck::OSP { namespace Heck::OSP {
@ -65,14 +64,14 @@ namespace Heck::OSP {
void filter(float val) void filter(float val)
{ {
val *= val; // val *= val;
float ladder_freq = 80. + (val * 30000.); float ladder_freq = 5. + ((Constants::AUDIO_SAMPLERATE / 2.F) * val);
ladder_.SetFreq(ladder_freq); ladder_.SetFreq(ladder_freq);
} }
void drive(float amt) void drive(float amt)
{ {
od_.SetDrive(scalen_min_max(amt, 0.35, 0.5)); od_.SetDrive(dz::scalen_min_max(amt, 0.35, 0.5));
} }
// range: 0-1 // range: 0-1

Write Preview
Loading…
Cancel
Save