Knob Expander

firmware/CMakeLists.txt

@@ -195,15 +195,15 @@ endif()
 
 add_custom_target(
   bootloader
-  COMMAND make --no-print-directory BOARD_CONF=../board_conf/mmp11_conf.hh ${BOOTLOADER_TOOLCHAIN_OPT}
+  COMMAND make --no-print-directory BOARD_CONF=../board_conf/mmp11_with_expanders_conf.hh ${BOOTLOADER_TOOLCHAIN_OPT}
   COMMENT "Building MP1-Boot (FSBL)"
   WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/bootloader/mp1-boot
   VERBATIM
 )
 
 add_custom_target(
   bootloader-dfu
-  COMMAND make --no-print-directory BOARD_CONF=board_conf/mmp11_conf.hh ${BOOTLOADER_TOOLCHAIN_OPT}
+  COMMAND make --no-print-directory BOARD_CONF=board_conf/mmp11_with_expanders_conf.hh ${BOOTLOADER_TOOLCHAIN_OPT}
   COMMENT "Building DFU Bootloader"
   WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/bootloader/mp1-usb-dfu
   VERBATIM

firmware/bootloader/board_conf/mmp11_with_expanders_conf.hh

@@ -0,0 +1,46 @@
+#pragma once
+#include "drivers/clocks.hh"
+#include "drivers/i2c_conf.hh"
+#include "drivers/leds.hh"
+
+namespace Board
+{
+
+using RedLED = Led<GPIO::E, PinNum::_14, LedActive::Low>;	// button LED red
+using GreenLED = Led<GPIO::B, PinNum::_15, LedActive::Low>; // button LED green
+using RedLED2 = RedLED;
+using GreenLED2 = GreenLED;
+
+using OrangeLED = RedLED2;
+using BlueLED = Led<GPIO::A, PinNum::_9, LedActive::Low>; // button LED blue
+
+// Boot Select pin: press Rotary encoder to select DFU USB
+constexpr bool UseBootSelect = true;
+constexpr PinConf BootSelectPin{GPIO::E, PinNum::_15};
+
+// Freeze mode: jumper on debug header (left-most column)
+constexpr bool UseFreezePin = true;
+constexpr PinConf FreezePin{GPIO::D, PinNum::_3}; //DEBUG1 of debug header
+
+constexpr uint32_t ConsoleUART = UART7_BASE;
+constexpr PinConf UartRX{GPIO::B, PinNum::_3, PinAF::AF_13};
+constexpr PinConf UartTX{GPIO::B, PinNum::_4, PinAF::AF_13};
+
+namespace NORFlash
+{
+constexpr bool HasNORFlash = true;
+constexpr PinConf d2{GPIO::F, PinNum::_7, PinAF::AF_9};
+constexpr PinConf d3{GPIO::A, PinNum::_1, PinAF::AF_9};
+} // namespace NORFlash
+
+namespace PMIC
+{
+constexpr bool HasSTPMIC = false;
+constexpr I2C_Config I2C_config{};
+} // namespace PMIC
+
+constexpr uint32_t HSE_Clock_Hz = 24000000;
+constexpr uint32_t MPU_MHz = 800;
+constexpr auto ClockType = SystemClocks::HSEClockSource::Resonator;
+
+} // namespace Board

firmware/src/CMakeLists.txt

@@ -122,6 +122,7 @@ add_executable(
   ${FWDIR}/src/gui/elements/element_name.cc
   ${FWDIR}/src/gui/slsexport/ui_local.cc
   ${FWDIR}/src/gui/fonts/fonts.cc
+  ${FWDIR}/src/params/expanders.cc
   #
   ${FWDIR}/src/dynload/dynloader.cc
   ${FWDIR}/metamodule-plugin-sdk/version.cc

firmware/src/audio/audio.cc

@@ -1,5 +1,8 @@
 #include "audio/audio.hh"
+#include "CoreModules/hub/audio_expander_defs.hh"
+#include "CoreModules/hub/knob_expander_defs.hh"
 #include "audio/audio_test_signals.hh"
+#include "calibrate/calibration_data_reader.hh"
 #include "conf/audio_settings.hh"
 #include "conf/hsem_conf.hh"
 #include "conf/jack_sense_conf.hh"
@@ -8,6 +11,7 @@
 #include "drivers/arch.hh"
 #include "drivers/cache.hh"
 #include "drivers/hsem.hh"
+#include "expanders.hh"
 #include "param_block.hh"
 #include "patch_play/patch_mods.hh"
 #include "patch_play/patch_player.hh"
@@ -54,12 +58,21 @@ AudioStream::AudioStream(PatchPlayer &patchplayer,
 	codec_.set_rx_buffer(audio_blocks[0].in_codec, block_size_);
 
 	if (codec_ext_.init() == CodecT::CODEC_NO_ERR) {
+		ext_cal.reset_to_default();
 		ext_audio_connected = true;
 		codec_ext_.set_tx_buffer(audio_blocks[0].out_ext_codec, block_size_);
 		codec_ext_.set_rx_buffer(audio_blocks[0].in_ext_codec, block_size_);
+		Expanders::ext_audio_found(true);
+
+		if (!CalibrationDataReader::read_calibration(&ext_cal, Hardware::codec_ext_memory, 0)) {
+			ext_cal.reset_to_default();
+			Hardware::codec_ext_memory.write(ext_cal);
+		}
+
 		pr_info("Audio Expander detected\n");
 	} else {
 		ext_audio_connected = false;
+		Expanders::ext_audio_found(false);
 		pr_info("No Audio Expander detected\n");
 	}
 
@@ -105,6 +118,11 @@ AudioStream::AudioStream(PatchPlayer &patchplayer,
 
 	for (auto &s : smoothed_ins)
 		s.set_size(block_size_);
+
+	for (auto &expander : exp_knobs) {
+		for (auto &knobs : expander)
+			knobs.set_num_updates(block_size_);
+	}
 }
 
 void AudioStream::start() {
@@ -118,6 +136,12 @@ AudioConf::SampleT AudioStream::get_audio_output(int output_id) {
 	return MathTools::signed_saturate(cal.out_cal[output_id].adjust(output_volts), 24);
 }
 
+AudioConf::SampleT AudioStream::get_ext_audio_output(int output_id) {
+	output_id = AudioExpander::out_order[output_id];
+	float output_volts = player.get_panel_output(output_id + PanelDef::NumAudioOut) * output_fade_amt;
+	return MathTools::signed_saturate(ext_cal.out_cal[output_id].adjust(output_volts), 24);
+}
+
 bool AudioStream::is_playing_patch() {
 	if (patch_loader.should_fade_down_audio()) {
 		output_fade_delta = -1.f / (sample_rate_ * 0.02f);
@@ -153,16 +177,20 @@ void AudioStream::handle_patch_just_loaded() {
 void AudioStream::process(CombinedAudioBlock &audio_block, ParamBlock &param_block) {
 	handle_patch_mod_queue();
 
-	// TODO: handle second codec
-	if (ext_audio_connected)
-		AudioTestSignal::passthrough(audio_block.in_ext_codec, audio_block.out_ext_codec);
-
 	param_block.metaparams.midi_poly_chans = player.get_midi_poly_num();
 
-	// for (auto [in, out, params] : zip(audio_block.in_codec, audio_block.out_codec, param_block.params)) {
+	for (auto exp_i = 0u; exp_i < param_block.metaparams.num_knob_expanders_found; exp_i++) {
+		for (auto knob_i = 0u; knob_i < param_block.metaparams.exp_knobs[exp_i].size(); knob_i++) {
+			float reading = param_block.metaparams.exp_knobs[exp_i][knob_i];
+			exp_knobs[exp_i][knob_i].set_new_value(reading);
+		}
+	}
+
 	for (auto idx = 0u; auto const &in : audio_block.in_codec) {
 		auto &out = audio_block.out_codec[idx];
-		auto &params = param_block.params[idx];
+		auto const &params = param_block.params[idx];
+		auto &ext_out = audio_block.out_ext_codec[idx];
+		auto const &ext_in = audio_block.out_ext_codec[idx];
 		idx++;
 
 		// Audio inputs
@@ -176,19 +204,33 @@ void AudioStream::process(CombinedAudioBlock &audio_block, ParamBlock &param_blo
 
 			player.set_panel_input(panel_jack_i, calibrated_input);
 
-			// Send smoothed sigals to other core via metaparams
+			// Send smoothed sigals to other core
 			smoothed_ins[panel_jack_i].add_val(calibrated_input);
 		}
 
+		if (ext_audio_connected) {
+			for (auto [panel_jack_i, inchan] : zip(AudioExpander::in_order, ext_in.chan)) {
+
+				// Skip unpatched jacks
+				if (!AudioExpander::jack_is_patched(param_state.jack_senses, panel_jack_i))
+					continue;
+
+				float calibrated_input = ext_cal.in_cal[panel_jack_i].adjust(AudioInFrame::sign_extend(inchan));
+
+				player.set_panel_input(panel_jack_i, calibrated_input);
+			}
+		}
+
 		// Gate inputs
 		for (auto [i, gatein, sync_gatein] : countzip(params.gate_ins, param_state.gate_ins)) {
 
-			if (!jack_is_patched(param_state.jack_senses, i + FirstGateInput)) {
-				gatein = false;
-			} else
+			bool gate = false;
+			if (jack_is_patched(param_state.jack_senses, i + FirstGateInput)) {
+				gate = gatein;
 				player.set_panel_input(i + FirstGateInput, gatein ? 8.f : 0.f);
+			}
 
-			sync_gatein.register_state(gatein);
+			sync_gatein.register_state(gate);
 		}
 
 		// Pass Knob values to modules
@@ -208,6 +250,28 @@ void AudioStream::process(CombinedAudioBlock &audio_block, ParamBlock &param_blo
 
 		for (auto [i, outchan] : countzip(out.chan))
 			outchan = get_audio_output(i);
+
+		// Ext audio modules:
+		if (ext_audio_connected) {
+			for (auto [i, extoutchan] : countzip(ext_out.chan))
+				extoutchan = get_ext_audio_output(i);
+		}
+
+		// Button Expanders:
+		if (param_block.metaparams.num_button_expanders_found > 0) {
+			handle_button_events(param_block.metaparams.ext_buttons_pressed_event, 1.f);
+			handle_button_events(param_block.metaparams.ext_buttons_released_event, 0.f);
+
+			param_block.metaparams.button_leds = player.get_button_leds();
+		}
+
+		unsigned param_id = FirstExpKnob;
+		for (auto exp_i = 0u; exp_i < param_block.metaparams.num_knob_expanders_found; exp_i++) {
+			for (auto &knob : exp_knobs[exp_i]) {
+				player.set_panel_param(param_id, knob.next());
+				param_id++;
+			}
+		}
 	}
 
 	for (auto [m, s] : zip(param_block.metaparams.ins, smoothed_ins)) {
@@ -221,7 +285,6 @@ void AudioStream::process(CombinedAudioBlock &audio_block, ParamBlock &param_blo
 void AudioStream::process_nopatch(CombinedAudioBlock &audio_block, ParamBlock &param_block) {
 	param_state.jack_senses = param_block.params[0].jack_senses;
 
-	// for (auto [in, out, params] : zip(audio_block.in_codec, audio_block.out_codec, param_block.params)) {
 	for (auto idx = 0u; auto const &in : audio_block.in_codec) {
 		auto &out = audio_block.out_codec[idx];
 		auto &params = param_block.params[idx];
@@ -296,6 +359,16 @@ void AudioStream::handle_midi(bool is_connected, Midi::Event const &event, unsig
 	}
 }
 
+void AudioStream::handle_button_events(uint32_t event_bitmask, bool pressed) {
+	unsigned i = 0;
+	while (event_bitmask) {
+		if (event_bitmask & 0b1) {
+			player.set_panel_param(i + FirstButton, pressed ? 1 : 0);
+		}
+		event_bitmask >>= 1;
+		i++;
+	}
+}
 void AudioStream::propagate_sense_pins(Params &params) {
 	for (unsigned i = 0; auto &plug_detect : plug_detects) {
 		bool sense = jack_is_patched(params.jack_senses, i);
@@ -360,6 +433,9 @@ void AudioStream::return_cached_params(unsigned block) {
 
 	// copy midi_poly_chans back so Controls can read it
 	param_blocks[block].metaparams.midi_poly_chans = local_params.metaparams.midi_poly_chans;
+
+	// copy button_leds back so Controls can light them
+	param_blocks[block].metaparams.button_leds = local_params.metaparams.button_leds;
 }
 
 void AudioStream::set_block_spans() {
@@ -392,11 +468,18 @@ void AudioStream::update_audio_settings() {
 
 			if (block_size != block_size_) {
 				block_size_ = block_size;
+				param_blocks[0].metaparams.block_size = block_size;
+				param_blocks[1].metaparams.block_size = block_size;
 
 				set_block_spans();
 
 				for (auto &s : smoothed_ins)
 					s.set_size(block_size_);
+
+				for (auto &expander : exp_knobs) {
+					for (auto &knobs : expander)
+						knobs.set_num_updates(block_size_);
+				}
 			}
 
 		} else {

firmware/src/audio/audio.hh

@@ -17,6 +17,7 @@
 #include "util/calibrator.hh"
 #include "util/edge_detector.hh"
 #include "util/filter.hh"
+#include "util/interp_param.hh"
 #include "util/math.hh"
 #include <array>
 
@@ -67,8 +68,12 @@ private:
 	CalData cal_stash;
 	EdgeStateDetector plug_detects[PanelDef::NumJacks];
 
+	CalData ext_cal{};
+
 	std::array<ResizingOversampler, PanelDef::NumAudioIn> smoothed_ins;
 
+	std::array<std::array<InterpParamVariable<float>, 8>, 4> exp_knobs;
+
 	PatchPlayer &player;
 	mdrivlib::CycleCounter load_measure;
 	float load_lpf = 0.f;
@@ -82,11 +87,14 @@ private:
 	bool midi_last_connected = false;
 
 	AudioConf::SampleT get_audio_output(int output_id);
+	AudioConf::SampleT get_ext_audio_output(int output_id);
 	void set_input(int input_id, AudioConf::SampleT in);
 	bool check_patch_change(int motion);
 	void send_zeros_to_patch();
 	void propagate_sense_pins(Params &params);
 	void handle_midi(bool is_connected, Midi::Event const &event, unsigned poly_num);
+	void handle_button_events(uint32_t event_bitmask, bool pressed);
+
 	void process_nopatch(CombinedAudioBlock &audio_block, ParamBlock &param_block);
 	bool is_playing_patch();
 	void handle_patch_just_loaded();

firmware/src/calibrate/calibration_data.hh

@@ -104,4 +104,6 @@ struct CalData {
 	}
 };
 
+static constexpr size_t CalDataSize = sizeof(CalData);
+
 } // namespace MetaModule

firmware/src/calibrate/calibration_data_reader.hh

@@ -12,17 +12,11 @@ namespace MetaModule
 {
 
 class CalibrationDataReader {
-	FlashLoader &loader;
-
 public:
-	CalibrationDataReader(FlashLoader &loader)
-		: loader{loader} {
-	}
-
-	CalData read_calibration_or_defaults() {
+	static CalData read_calibration_or_defaults(auto &&loader, uint32_t address) {
 		CalData caldata;
 
-		auto valid = read_calibration(&caldata);
+		auto valid = read_calibration(&caldata, std::move(loader), address);
 		if (!valid) {
 			caldata.reset_to_default();
 			pr_info("No Calibration data found, using defaults\n");
@@ -32,10 +26,10 @@ public:
 		return caldata;
 	}
 
-	bool read_calibration(CalData *caldata) {
-		pr_dbg("Read Calibration at %x\n", CalDataFlashOffset);
+	static bool read_calibration(CalData *caldata, auto &&loader, uint32_t address) {
+		pr_dbg("Read Calibration at %x\n", address);
 
-		if (loader.read_sectors(CalDataFlashOffset, {reinterpret_cast<uint8_t *>(caldata), sizeof(CalData)})) {
+		if (loader.read(address, {reinterpret_cast<uint8_t *>(caldata), sizeof(CalData)})) {
 
 			if (caldata->validate()) {
 				pr_info("Calibration data read and validated\n");

firmware/src/calibrate/calibration_message_handler.hh

@@ -13,8 +13,7 @@ class CalibrationMessageHandler {
 
 public:
 	CalibrationMessageHandler(FlashLoader &loader)
-		: loader{loader}
-		, reader{loader} {
+		: loader{loader} {
 	}
 
 	std::optional<IntercoreStorageMessage> handle_message(const IntercoreStorageMessage &message) {
@@ -28,7 +27,7 @@ public:
 				if (message.buffer.data() && message.buffer.size() >= sizeof(CalData)) {
 
 					auto *caldata = new (message.buffer.data()) CalData;
-					if (!reader.read_calibration(caldata))
+					if (!reader.read_calibration(caldata, loader, CalDataFlashOffset))
 						caldata->reset_to_default();
 
 					return IntercoreStorageMessage{.message_type = ReadFlashOk, .bytes_read = sizeof(CalData)};