diff --git a/Source/Devices/AnalogIO.cpp b/Source/Devices/AnalogIO.cpp
index 0e47eee..ba5138d 100644
--- a/Source/Devices/AnalogIO.cpp
+++ b/Source/Devices/AnalogIO.cpp
@@ -165,7 +165,7 @@ void AnalogIO::processFrames()
 
 			currentAverageFrame = 0;
 
-			timestamps[currentFrame] = frame->time;
+			timestamps[currentFrame] = deviceContext->convertTimestampToSeconds(frame->time);
 			sampleNumbers[currentFrame] = sampleNumber++;
 
 			currentFrame++;
diff --git a/Source/Devices/AnalogIO.h b/Source/Devices/AnalogIO.h
index d74466a..e21eacb 100644
--- a/Source/Devices/AnalogIO.h
+++ b/Source/Devices/AnalogIO.h
@@ -99,6 +99,19 @@ class AnalogIO : public OnixDevice
 		return channelDirection[channelNumber];
 	}
 
+	static String getChannelDirection(AnalogIODirection direction)
+	{
+		switch (direction)
+		{
+		case AnalogIODirection::Input:
+			return "Input";
+		case AnalogIODirection::Output:
+			return "Output";
+		default:
+			return "";
+		}
+	}
+
 	void setChannelDirection(int channelNumber, AnalogIODirection direction)
 	{
 		if (channelNumber > numChannels || channelNumber < 0)
@@ -121,21 +134,8 @@ class AnalogIO : public OnixDevice
 		return channelVoltageRange[channelNumber];
 	}
 
-	void setChannelVoltageRange(int channelNumber, AnalogIOVoltageRange direction)
-	{
-		if (channelNumber > numChannels || channelNumber < 0)
-		{
-			LOGE("Channel number must be between 0 and " + String(channelNumber));
-			return;
-		}
-
-		channelVoltageRange[channelNumber] = direction;
-	}
-
 	AnalogIODataType getDataType() const { return dataType; }
 
-	void setDataType(AnalogIODataType type) { dataType = type; }
-
 	int getNumChannels() { return numChannels; }
 
 private:
@@ -174,5 +174,18 @@ class AnalogIO : public OnixDevice
 
 	static float getVoltsPerDivision(AnalogIOVoltageRange voltageRange);
 
+	void setChannelVoltageRange(int channelNumber, AnalogIOVoltageRange direction)
+	{
+		if (channelNumber > numChannels || channelNumber < 0)
+		{
+			LOGE("Channel number must be between 0 and " + String(channelNumber));
+			return;
+		}
+
+		channelVoltageRange[channelNumber] = direction;
+	}
+
+	void setDataType(AnalogIODataType type) { dataType = type; }
+
 	JUCE_LEAK_DETECTOR(AnalogIO);
 };
diff --git a/Source/Devices/Bno055.cpp b/Source/Devices/Bno055.cpp
index 636ee56..9fd92fa 100644
--- a/Source/Devices/Bno055.cpp
+++ b/Source/Devices/Bno055.cpp
@@ -151,7 +151,7 @@ void Bno055::processFrames()
 
 		int16_t* dataPtr = (int16_t*)frame->data;
 
-		bnoTimestamps[currentFrame] = frame->time;
+		bnoTimestamps[currentFrame] = deviceContext->convertTimestampToSeconds(frame->time);
 
 		int dataOffset = 4;
 
diff --git a/Source/Devices/DigitalIO.cpp b/Source/Devices/DigitalIO.cpp
index 8685ba2..5340024 100644
--- a/Source/Devices/DigitalIO.cpp
+++ b/Source/Devices/DigitalIO.cpp
@@ -82,7 +82,7 @@ void DigitalIO::processFrames()
 		oni_frame_t* frame = frameArray.removeAndReturn(0);
 
 		uint16_t* dataPtr = (uint16_t*)frame->data;
-		uint64_t timestamp = frame->time;
+		uint64_t timestamp = deviceContext->convertTimestampToSeconds(frame->time);
 
 		int dataOffset = 4;
 
diff --git a/Source/Devices/HarpSyncInput.cpp b/Source/Devices/HarpSyncInput.cpp
index e7ec571..b9fd6c4 100644
--- a/Source/Devices/HarpSyncInput.cpp
+++ b/Source/Devices/HarpSyncInput.cpp
@@ -97,7 +97,7 @@ void HarpSyncInput::processFrames()
 
 		uint32_t* dataPtr = (uint32_t*)frame->data;
 
-		timestamps[currentFrame] = frame->time;
+		timestamps[currentFrame] = deviceContext->convertTimestampToSeconds(frame->time);
 
 		harpTimeSamples[currentFrame] = *(dataPtr + 2) + 1;
 
diff --git a/Source/Devices/MemoryMonitor.cpp b/Source/Devices/MemoryMonitor.cpp
index 6fc5da7..8229e31 100644
--- a/Source/Devices/MemoryMonitor.cpp
+++ b/Source/Devices/MemoryMonitor.cpp
@@ -147,9 +147,8 @@ void MemoryMonitor::processFrames()
 		oni_frame_t* frame = frameArray.removeAndReturn(0);
 
 		uint32_t* dataPtr = (uint32_t*)frame->data;
-		uint64_t timestamp = frame->time;
 
-		timestamps[currentFrame] = frame->time;
+		timestamps[currentFrame] = deviceContext->convertTimestampToSeconds(frame->time);
 
 		percentUsedSamples[currentFrame] = 100.0f * float(*(dataPtr + 2)) / totalMemory;
 
diff --git a/Source/Devices/Neuropixels2e.cpp b/Source/Devices/Neuropixels2e.cpp
index e8b10d7..d733cce 100644
--- a/Source/Devices/Neuropixels2e.cpp
+++ b/Source/Devices/Neuropixels2e.cpp
@@ -621,7 +621,7 @@ void Neuropixels2e::processFrames()
 		uint16_t* amplifierData = dataPtr + 9;
 
 		sampleNumbers[frameCount] = sampleNumber;
-		timestamps[frameCount] = frame->time;
+		timestamps[frameCount] = deviceContext->convertTimestampToSeconds(frame->time);
 
 		for (int i = 0; i < FramesPerSuperFrame; i++)
 		{
diff --git a/Source/Devices/Neuropixels_1.cpp b/Source/Devices/Neuropixels_1.cpp
index 91f31ef..d1aa745 100644
--- a/Source/Devices/Neuropixels_1.cpp
+++ b/Source/Devices/Neuropixels_1.cpp
@@ -472,7 +472,7 @@ void Neuropixels_1::processFrames()
 
 		uint16_t* dataPtr = (uint16_t*)frame->data;
 
-		apTimestamps[superFrameCount] = frame->time;
+		apTimestamps[superFrameCount] = deviceContext->convertTimestampToSeconds(frame->time);
 		apSampleNumbers[superFrameCount] = apSampleNumber++;
 
 		for (int i = 0; i < framesPerSuperFrame; i++)
diff --git a/Source/Devices/OutputClock.h b/Source/Devices/OutputClock.h
index 9c3ab5b..08a45a3 100644
--- a/Source/Devices/OutputClock.h
+++ b/Source/Devices/OutputClock.h
@@ -62,17 +62,17 @@ class OutputClock : public OnixDevice
 
 	void processFrames() override {};
 
-	float getFrequencyHz() const { return frequencyHz; }
+	double getFrequencyHz() const { return frequencyHz; }
 
-	void setFrequencyHz(float frequency) { frequencyHz = frequency; }
+	void setFrequencyHz(double frequency) { frequencyHz = frequency; }
 
-	uint32_t getDutyCycle() const { return dutyCycle; }
+	int32_t getDutyCycle() const { return dutyCycle; }
 
-	void setDutyCycle(uint32_t dutyCycle_) { dutyCycle = dutyCycle_; }
+	void setDutyCycle(int32_t dutyCycle_) { dutyCycle = dutyCycle_; }
 
-	uint32_t getDelay() const { return delay; }
+	int32_t getDelay() const { return delay; }
 
-	void setDelay(uint32_t delay_) { delay = delay_; }
+	void setDelay(int32_t delay_) { delay = delay_; }
 
 	bool getGateRun() const { return gateRun; }
 
@@ -85,8 +85,8 @@ class OutputClock : public OnixDevice
 private:
 
 	double frequencyHz = 1e6;
-	uint32_t dutyCycle = 50;
-	uint32_t delay = 0;
+	int32_t dutyCycle = 50;
+	int32_t delay = 0;
 
 	bool gateRun = true;
 
diff --git a/Source/Devices/PolledBno055.cpp b/Source/Devices/PolledBno055.cpp
index 4936f02..8de1482 100644
--- a/Source/Devices/PolledBno055.cpp
+++ b/Source/Devices/PolledBno055.cpp
@@ -261,7 +261,7 @@ void PolledBno055::hiResTimerCallback()
 	rc = (uint64_t)deviceContext->readRegister(deviceIdx, DS90UB9x::LASTI2CH, &timestampH);
 	if (rc != ONI_ESUCCESS) return;
 
-	bnoTimestamps[currentFrame] = (uint64_t(timestampH) << 32) | uint64_t(timestampL);
+	bnoTimestamps[currentFrame] = deviceContext->convertTimestampToSeconds((uint64_t(timestampH) << 32) | uint64_t(timestampL));
 
 	sampleNumbers[currentFrame] = sampleNumber++;
 
diff --git a/Source/Onix1.cpp b/Source/Onix1.cpp
index a63ac47..cdd99ac 100644
--- a/Source/Onix1.cpp
+++ b/Source/Onix1.cpp
@@ -35,6 +35,10 @@ Onix1::Onix1(int hostIndex)
 		throw error_t(rc);
 
 	oni_version(&major, &minor, &patch);
+
+	rc = getOption(ONI_OPT_ACQCLKHZ, &ACQ_CLK_HZ);
+	if (rc != ONI_ESUCCESS)
+		throw error_t(rc);
 }
 
 Onix1::~Onix1()
diff --git a/Source/Onix1.h b/Source/Onix1.h
index dc7e9cd..9a0ec8f 100644
--- a/Source/Onix1.h
+++ b/Source/Onix1.h
@@ -88,7 +88,9 @@ class Onix1
 
 	int issueReset() { int val = 1; int rc = setOption(ONI_OPT_RESET, val); return rc; }
 
-	String getVersion() { return String(major) + "." + String(minor) + "." + String(patch); }
+	std::string getVersion() const { return std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(patch); }
+
+	double convertTimestampToSeconds(uint32_t timestamp) const { return static_cast<double>(timestamp) / ACQ_CLK_HZ; }
 
 private:
 
@@ -99,6 +101,8 @@ class Onix1
 	int minor;
 	int patch;
 
+	uint32_t ACQ_CLK_HZ;
+
 	device_map_t deviceTable;
 
 	template<typename opt_t>
diff --git a/Source/OnixSourceCanvas.cpp b/Source/OnixSourceCanvas.cpp
index 072f4d2..520a175 100644
--- a/Source/OnixSourceCanvas.cpp
+++ b/Source/OnixSourceCanvas.cpp
@@ -158,8 +158,10 @@ void OnixSourceCanvas::updateSettingsInterfaceDataSource(std::shared_ptr<OnixDev
 
 	for (int j = 0; j < settingsInterfaces.size(); j++)
 	{
-		if (device->getDeviceIdx() == settingsInterfaces[j]->device->getDeviceIdx() &&
-			compareDeviceNames(device->getName(), settingsInterfaces[j]->device->getName()))
+		auto selectedDevice = settingsInterfaces[j]->getDevice();
+
+		if (device->getDeviceIdx() == selectedDevice->getDeviceIdx() &&
+			compareDeviceNames(device->getName(), selectedDevice->getName()))
 		{
 			ind = j;
 			break;
@@ -174,10 +176,12 @@ void OnixSourceCanvas::updateSettingsInterfaceDataSource(std::shared_ptr<OnixDev
 		return;
 	}
 
+	auto selectedDevice = settingsInterfaces[ind]->getDevice();
+
 	if (device->type == OnixDeviceType::NEUROPIXELS_1)
 	{
 		auto npx1Found = std::static_pointer_cast<Neuropixels_1>(device);
-		auto npx1Selected = std::static_pointer_cast<Neuropixels_1>(settingsInterfaces[ind]->device);
+		auto npx1Selected = std::static_pointer_cast<Neuropixels_1>(selectedDevice);
 		npx1Found->setSettings(npx1Selected->settings[0].get());
 		npx1Found->adcCalibrationFilePath = npx1Selected->adcCalibrationFilePath;
 		npx1Found->gainCalibrationFilePath = npx1Selected->gainCalibrationFilePath;
@@ -186,7 +190,7 @@ void OnixSourceCanvas::updateSettingsInterfaceDataSource(std::shared_ptr<OnixDev
 	else if (device->type == OnixDeviceType::OUTPUTCLOCK)
 	{
 		auto outputClockFound = std::static_pointer_cast<OutputClock>(device);
-		auto outputClockSelected = std::static_pointer_cast<OutputClock>(settingsInterfaces[ind]->device);
+		auto outputClockSelected = std::static_pointer_cast<OutputClock>(selectedDevice);
 		outputClockFound->setDelay(outputClockSelected->getDelay());
 		outputClockFound->setDutyCycle(outputClockSelected->getDutyCycle());
 		outputClockFound->setFrequencyHz(outputClockSelected->getFrequencyHz());
@@ -195,7 +199,7 @@ void OnixSourceCanvas::updateSettingsInterfaceDataSource(std::shared_ptr<OnixDev
 	else if (device->type == OnixDeviceType::ANALOGIO)
 	{
 		auto analogIOFound = std::static_pointer_cast<AnalogIO>(device);
-		auto analogIOSelected = std::static_pointer_cast<AnalogIO>(settingsInterfaces[ind]->device);
+		auto analogIOSelected = std::static_pointer_cast<AnalogIO>(selectedDevice);
 		for (int i = 0; i < analogIOFound->getNumChannels(); i++)
 		{
 			analogIOFound->setChannelDirection(i, analogIOSelected->getChannelDirection(i));
@@ -204,7 +208,7 @@ void OnixSourceCanvas::updateSettingsInterfaceDataSource(std::shared_ptr<OnixDev
 	else if (device->type == OnixDeviceType::NEUROPIXELSV2E)
 	{
 		auto npx2Found = std::static_pointer_cast<Neuropixels2e>(device);
-		auto npx2Selected = std::static_pointer_cast<Neuropixels2e>(settingsInterfaces[ind]->device);
+		auto npx2Selected = std::static_pointer_cast<Neuropixels2e>(selectedDevice);
 		npx2Found->setSettings(npx2Selected->settings[0].get(), 0);
 		npx2Found->setSettings(npx2Selected->settings[1].get(), 1);
 		npx2Found->setGainCorrectionFile(0, npx2Selected->getGainCorrectionFile(0));
@@ -213,9 +217,8 @@ void OnixSourceCanvas::updateSettingsInterfaceDataSource(std::shared_ptr<OnixDev
 		std::static_pointer_cast<NeuropixelsV2eInterface>(settingsInterfaces[ind])->updateDevice(npx2Found);
 	}
 
-	device->setEnabled(settingsInterfaces[ind]->device->isEnabled());
-	settingsInterfaces[ind]->device.reset();
-	settingsInterfaces[ind]->device = device;
+	device->setEnabled(selectedDevice->isEnabled());
+	settingsInterfaces[ind]->setDevice(device);
 }
 
 String OnixSourceCanvas::getTopLevelTabName(PortName port, String headstage)
@@ -263,7 +266,9 @@ void OnixSourceCanvas::removeTabs(PortName port)
 
 	for (int i = settingsInterfaces.size() - 1; i >= 0; i -= 1)
 	{
-		if ((settingsInterfaces[i]->device->getDeviceIdx() & offset) > 0)
+		auto selectedDevice = settingsInterfaces[i]->getDevice();
+
+		if ((selectedDevice->getDeviceIdx() & offset) > 0)
 		{
 			settingsInterfaces.erase(settingsInterfaces.begin() + i);
 			tabExists = true;
@@ -293,7 +298,9 @@ std::map<int, OnixDeviceType> OnixSourceCanvas::createSelectedMap(std::vector<st
 
 	for (const auto& settings : interfaces)
 	{
-		tabMap.insert({ settings->device->getDeviceIdx(), settings->device->type });
+		auto device = settings->getDevice();
+
+		tabMap.insert({ device->getDeviceIdx(), device->type });
 	}
 
 	return tabMap;
@@ -512,10 +519,7 @@ void OnixSourceCanvas::startAcquisition()
 {
 	for (const auto& settingsInterface : settingsInterfaces)
 	{
-		if (settingsInterface->device != nullptr && settingsInterface->device->isEnabled())
-		{
-			settingsInterface->startAcquisition();
-		}
+		settingsInterface->startAcquisition();
 	}
 }
 
@@ -523,21 +527,18 @@ void OnixSourceCanvas::stopAcquisition()
 {
 	for (const auto& settingsInterface : settingsInterfaces)
 	{
-		if (settingsInterface->device != nullptr && settingsInterface->device->isEnabled())
-		{
-			settingsInterface->stopAcquisition();
-		}
+		settingsInterface->stopAcquisition();
 	}
 }
 
 void OnixSourceCanvas::saveCustomParametersToXml(XmlElement* xml)
 {
-	//for (int i = 0; i < settingsInterfaces.size(); i++)
-	//	settingsInterfaces[i]->saveParameters(xml);
+	for (int i = 0; i < settingsInterfaces.size(); i++)
+		settingsInterfaces[i]->saveParameters(xml);
 }
 
 void OnixSourceCanvas::loadCustomParametersFromXml(XmlElement* xml)
 {
-	//for (int i = 0; i < settingsInterfaces.size(); i++)
-	//	settingsInterfaces[i]->loadParameters(xml);
+	for (int i = 0; i < settingsInterfaces.size(); i++)
+		settingsInterfaces[i]->loadParameters(xml);
 }
diff --git a/Source/OnixSourceEditor.cpp b/Source/OnixSourceEditor.cpp
index 963c7a0..f36b6ad 100644
--- a/Source/OnixSourceEditor.cpp
+++ b/Source/OnixSourceEditor.cpp
@@ -24,7 +24,7 @@
 #include "OnixSource.h"
 
 OnixSourceEditor::OnixSourceEditor(GenericProcessor* parentNode, OnixSource* source_)
-	: VisualizerEditor(parentNode, "Onix Source", 240), source(source_)
+	: VisualizerEditor(parentNode, "Onix Source", 250), source(source_)
 {
 	canvas = nullptr;
 
@@ -38,8 +38,16 @@ OnixSourceEditor::OnixSourceEditor(GenericProcessor* parentNode, OnixSource* sou
 
 	if (source->isContextInitialized())
 	{
+		portStatusA = std::make_unique<DrawableRectangle>();
+		portStatusA->setRectangle(Rectangle<float>(memoryUsage->getRight() + 4, memoryUsage->getY(), 10, 10));
+		portStatusA->setCornerSize(Point<float>(5,5));
+		portStatusA->setFill(fillDisconnected);
+		portStatusA->setStrokeFill(statusIndicatorStrokeColor);
+		portStatusA->setStrokeThickness(statusIndicatorStrokeThickness);
+		addAndMakeVisible(portStatusA.get());
+
 		portLabelA = std::make_unique<Label>("portLabelA", "Port A:");
-		portLabelA->setBounds(memoryUsage->getRight() + 5, memoryUsage->getY(), 60, 16);
+		portLabelA->setBounds(portStatusA->getRight(), portStatusA->getY(), 60, 16);
 		portLabelA->setFont(fontOptionTitle);
 		addAndMakeVisible(portLabelA.get());
 
@@ -73,8 +81,16 @@ OnixSourceEditor::OnixSourceEditor(GenericProcessor* parentNode, OnixSource* sou
 		lastVoltageSetA->setTooltip("Records the last voltage set for Port A. Useful for displaying what the automated voltage discovery algorithm settled on.");
 		addAndMakeVisible(lastVoltageSetA.get());
 
+		portStatusB = std::make_unique<DrawableRectangle>();
+		portStatusB->setRectangle(Rectangle<float>(portStatusA->getX(), portVoltageOverrideLabelA->getBottom() + 3, 10, 10));
+		portStatusB->setCornerSize(portStatusA->getCornerSize());
+		portStatusB->setFill(portStatusA->getFill());
+		portStatusB->setStrokeFill(portStatusA->getStrokeFill());
+		portStatusB->setStrokeThickness(statusIndicatorStrokeThickness);
+		addAndMakeVisible(portStatusB.get());
+
 		portLabelB = std::make_unique<Label>("portLabelB", "Port B:");
-		portLabelB->setBounds(portLabelA->getX(), portVoltageOverrideLabelA->getBottom() + 3, portLabelA->getWidth(), portLabelA->getHeight());
+		portLabelB->setBounds(portStatusB->getRight(), portStatusB->getY(), portLabelA->getWidth(), portLabelA->getHeight());
 		portLabelB->setFont(fontOptionTitle);
 		addAndMakeVisible(portLabelB.get());
 
@@ -133,16 +149,13 @@ void OnixSourceEditor::addHeadstageComboBoxOptions(ComboBox* comboBox)
 	comboBox->addSeparator();
 	comboBox->addItem(NEUROPIXELSV1F_HEADSTAGE_NAME, 2);
 	comboBox->addItem(NEUROPIXELSV2E_HEADSTAGE_NAME, 3);
-	// TODO: Add list of available devices here
-	// TODO: Create const char* for the headstage names so they are shared across the plugin
 }
 
 void OnixSourceEditor::labelTextChanged(Label* l)
 {
-	// TODO: Add headstage specific parameters to limit voltage within safe levels
 	if (l == portVoltageValueA.get())
 	{
-		if (l->getText() == "")
+		if (l->getText() == "" || l->getText() == "Auto")
 		{
 			l->setText("Auto", dontSendNotification);
 			return;
@@ -161,7 +174,7 @@ void OnixSourceEditor::labelTextChanged(Label* l)
 	}
 	else if (l == portVoltageValueB.get())
 	{
-		if (l->getText() == "")
+		if (l->getText() == "" || l->getText() == "Auto")
 		{
 			l->setText("Auto", dontSendNotification);
 			return;
@@ -199,14 +212,22 @@ void OnixSourceEditor::setConnectedStatus(bool connected)
 		// NB: Configure port voltages, using either the automated voltage discovery algorithm, or the explicit voltage value given
 		if (isHeadstageSelected(PortName::PortA) || portVoltageValueA->getText() != "Auto")
 		{
+			portStatusA->setFill(fillSearching);
+
 			if (!source->configurePortVoltage(PortName::PortA, portVoltageValueA->getText()))
 			{
 				CoreServices::sendStatusMessage("Unable to acquire communication lock on Port A.");
+				portStatusA->setFill(fillDisconnected);
+			}
+			else
+			{
+				portStatusA->setFill(fillConnected);
 			}
 		}
 		else
 		{
 			source->setPortVoltage(PortName::PortA, 0);
+			portStatusA->setFill(fillDisconnected);
 		}
 
 		lastVoltageSetA->setText(String(source->getLastVoltageSet(PortName::PortA)) + " V", dontSendNotification);
@@ -215,14 +236,22 @@ void OnixSourceEditor::setConnectedStatus(bool connected)
 
 		if (isHeadstageSelected(PortName::PortB) || portVoltageValueB->getText() != "Auto")
 		{
+			portStatusB->setFill(fillSearching);
+
 			if (!source->configurePortVoltage(PortName::PortB, portVoltageValueB->getText()))
 			{
 				CoreServices::sendStatusMessage("Unable to acquire communication lock on Port B.");
+				portStatusB->setFill(fillDisconnected);
+			}
+			else
+			{
+				portStatusB->setFill(fillConnected);
 			}
 		}
 		else
 		{
 			source->setPortVoltage(PortName::PortB, 0);
+			portStatusB->setFill(fillDisconnected);
 		}
 
 		lastVoltageSetB->setText(String(source->getLastVoltageSet(PortName::PortB)) + " V", dontSendNotification);
@@ -249,6 +278,9 @@ void OnixSourceEditor::setConnectedStatus(bool connected)
 		lastVoltageSetA->setText(String(source->getLastVoltageSet(PortName::PortA)) + " V", dontSendNotification);
 		lastVoltageSetB->setText(String(source->getLastVoltageSet(PortName::PortB)) + " V", dontSendNotification);
 
+		portStatusA->setFill(fillDisconnected);
+		portStatusB->setFill(fillDisconnected);
+
 		source->disconnectDevices(true);
 		connectButton->setLabel("CONNECT");
 
@@ -319,6 +351,43 @@ void OnixSourceEditor::updateComboBox(ComboBox* cb)
 	}
 
 	source->getParameter(passthroughName)->setNextValue(passthroughValue);
+
+	String voltage = isPortA ? portVoltageValueA->getText() : portVoltageValueB->getText();
+
+	if (voltage != "Auto")
+	{
+		if (!currentHeadstageSelected)
+		{
+			if (isPortA)
+				portVoltageValueA->setText("", sendNotification);
+			else
+				portVoltageValueB->setText("", sendNotification);
+		}
+		else
+		{
+			int result = AlertWindow::show(MessageBoxOptions()
+				.withIconType(MessageBoxIconType::InfoIcon)
+				.withTitle("Voltage Override")
+				.withMessage(String("There is currently a voltage override selected for this port. Would you like to keep this voltage [Keep Voltage] ") +
+					"or allow the automated voltage discovery algorithm [Automated Discovery] to determine the best voltage for the new headstage selected?")
+				.withButton("Keep Voltage")
+				.withButton("Automated Discovery"));
+
+			switch (result)
+			{
+			case 1: // Keep Voltage
+				break;
+			case 0: // Automated Discovery
+				if (isPortA)
+					portVoltageValueA->setText("", sendNotification);
+				else
+					portVoltageValueB->setText("", sendNotification);
+				break;
+			default:
+				break;
+			}
+		}
+	}
 }
 
 void OnixSourceEditor::updateSettings()
@@ -327,10 +396,17 @@ void OnixSourceEditor::updateSettings()
 		canvas->update();
 }
 
+void OnixSourceEditor::setInterfaceEnabledState(bool newState)
+{
+	connectButton->setEnabled(newState);
+
+	portVoltageValueA->setEnabled(newState);
+	portVoltageValueB->setEnabled(newState);
+}
+
 void OnixSourceEditor::startAcquisition()
 {
-	// TODO: Disable all UI elements that should not be changed during acquisition...
-	connectButton->setEnabled(false);
+	setInterfaceEnabledState(false);
 
 	for (const auto& source : source->getDataSources())
 	{
@@ -341,12 +417,14 @@ void OnixSourceEditor::startAcquisition()
 			break;
 		}
 	}
+
+	if (canvas != nullptr)
+		canvas->startAcquisition();
 }
 
 void OnixSourceEditor::stopAcquisition()
 {
-	// TODO: Re-enable all of the UI elements 
-	connectButton->setEnabled(true);
+	setInterfaceEnabledState(true);
 
 	for (const auto& source : source->getDataSources())
 	{
@@ -356,6 +434,9 @@ void OnixSourceEditor::stopAcquisition()
 			break;
 		}
 	}
+
+	if (canvas != nullptr)
+		canvas->stopAcquisition();
 }
 
 Visualizer* OnixSourceEditor::createNewCanvas(void)
@@ -439,9 +520,12 @@ void OnixSourceEditor::setComboBoxSelection(ComboBox* comboBox, String headstage
 	{
 		if (headstage.contains(comboBox->getItemText(i)))
 		{
-			comboBox->setSelectedItemIndex(i, dontSendNotification);
+			comboBox->setSelectedItemIndex(i, dontSendNotification); // TODO: double check this indexing
+			return;
 		}
 	}
+
+	comboBox->setSelectedItemIndex(0, dontSendNotification);
 }
 
 void OnixSourceEditor::refreshComboBoxSelection()
@@ -474,3 +558,28 @@ std::map<int, OnixDeviceType> OnixSourceEditor::createTabMapFromCanvas()
 {
 	return canvas->createSelectedMap(canvas->settingsInterfaces);
 }
+
+void OnixSourceEditor::saveVisualizerEditorParameters(XmlElement* xml)
+{
+	LOGD("Saving OnixSourceEditor settings.");
+
+	xml->setAttribute("headstagePortA", headstageComboBoxA->getText());
+	xml->setAttribute("headstagePortB", headstageComboBoxB->getText());
+
+	xml->setAttribute("portVoltageA", portVoltageValueA->getText());
+	xml->setAttribute("portVoltageB", portVoltageValueB->getText());
+}
+
+void OnixSourceEditor::loadVisualizerEditorParameters(XmlElement* xml)
+{
+	LOGD("Loading OnixSourceEditor settings.");
+
+	setComboBoxSelection(headstageComboBoxA.get(), xml->getStringAttribute("headstagePortA"));
+	updateComboBox(headstageComboBoxA.get());
+
+	setComboBoxSelection(headstageComboBoxB.get(), xml->getStringAttribute("headstagePortB"));
+	updateComboBox(headstageComboBoxB.get());
+
+	portVoltageValueA->setText(xml->getStringAttribute("portVoltageA"), sendNotification);
+	portVoltageValueB->setText(xml->getStringAttribute("portVoltageB"), sendNotification);
+}
diff --git a/Source/OnixSourceEditor.h b/Source/OnixSourceEditor.h
index e27305a..13e5fda 100644
--- a/Source/OnixSourceEditor.h
+++ b/Source/OnixSourceEditor.h
@@ -56,12 +56,18 @@ class OnixSourceEditor : public VisualizerEditor,
 
     void updateSettings() override;
 
+    void setInterfaceEnabledState(bool newState);
+
     void startAcquisition() override;
 
     void stopAcquisition() override;
 
     Visualizer* createNewCanvas(void) override;
 
+    void saveVisualizerEditorParameters(XmlElement* xml) override;
+
+    void loadVisualizerEditorParameters(XmlElement* xml) override;
+
     void checkCanvas() { checkForCanvas(); };
 
     void resetCanvas();
@@ -72,7 +78,6 @@ class OnixSourceEditor : public VisualizerEditor,
 
     String getHeadstageSelected(PortName port);
 
-    /** Updates the combo boxes based on the headstages found in the canvas tabs */
     void refreshComboBoxSelection();
 
     std::map<int, OnixDeviceType> createTabMapFromCanvas();
@@ -84,6 +89,17 @@ class OnixSourceEditor : public VisualizerEditor,
     OnixSourceCanvas* canvas;
     OnixSource* source;
 
+    const FillType fillDisconnected = FillType(Colours::transparentBlack);
+    const FillType fillSearching = FillType(Colour::fromFloatRGBA(0.0f, 1.0f, 87.0f / 255, 1.0f));
+    const FillType fillConnected = FillType(Colour::fromFloatRGBA(184.0f / 255, 0.0f, 252.0f / 255, 1.0f));
+
+    const Colour statusIndicatorStrokeColor = Colours::black;
+
+    const float statusIndicatorStrokeThickness = 1.0f;
+
+    std::unique_ptr<DrawableRectangle> portStatusA;
+    std::unique_ptr<DrawableRectangle> portStatusB;
+
     std::unique_ptr<Label> portLabelA;
     std::unique_ptr<Label> portLabelB;
 
diff --git a/Source/UI/AnalogIOInterface.cpp b/Source/UI/AnalogIOInterface.cpp
index 7d304c0..0b44880 100644
--- a/Source/UI/AnalogIOInterface.cpp
+++ b/Source/UI/AnalogIOInterface.cpp
@@ -50,11 +50,6 @@ AnalogIOInterface::AnalogIOInterface(std::shared_ptr<AnalogIO> d, OnixSourceEdit
 		directionList.add("Input");
 		directionList.add("Output");
 
-		StringArray voltageRangeList;
-		voltageRangeList.add("+/- 2.5 V");
-		voltageRangeList.add("+/- 5.0 V");
-		voltageRangeList.add("+/- 10.0 V");
-
 		for (int i = 0; i < numChannels; i += 1)
 		{
 			channelDirectionLabels[i] = std::make_unique<Label>("channelDirectionLabel" + String(i), "Channel " + String(i) + String(": Direction"));
@@ -69,18 +64,46 @@ AnalogIOInterface::AnalogIOInterface(std::shared_ptr<AnalogIO> d, OnixSourceEdit
 			channelDirectionComboBoxes[i]->addListener(this);
 			channelDirectionComboBoxes[i]->setTooltip("Sets the direction of Channel " + String(i));
 			channelDirectionComboBoxes[i]->addItemList(directionList, 1);
-			channelDirectionComboBoxes[i]->setSelectedId(getChannelDirectionId(std::static_pointer_cast<AnalogIO>(device), i), dontSendNotification);
+			channelDirectionComboBoxes[i]->setSelectedId(1, dontSendNotification);
 			addAndMakeVisible(channelDirectionComboBoxes[i].get());
 
 			prevComboBoxRectangle = channelDirectionComboBoxes[i]->getBounds();
 		}
 
 		updateInfoString();
+
+		updateSettings();
 	}
 
 	type = SettingsInterface::Type::ANALOGIO_SETTINGS_INTERFACE;
 }
 
+void AnalogIOInterface::setInterfaceEnabledState(bool newState)
+{
+	if (deviceEnableButton != nullptr)
+		deviceEnableButton->setEnabled(newState);
+
+	for (int i = 0; i < numChannels; i++)
+	{
+		if (channelDirectionComboBoxes[i] != nullptr)
+			channelDirectionComboBoxes[i]->setEnabled(newState);
+	}
+}
+
+void AnalogIOInterface::updateSettings()
+{
+	if (device == nullptr) return;
+
+	deviceEnableButton->setToggleState(device->isEnabled(), sendNotification);
+
+	auto analogIO = std::static_pointer_cast<AnalogIO>(device);
+
+	for (int i = 0; i < numChannels; i++)
+	{
+		channelDirectionComboBoxes[i]->setSelectedId(getChannelDirectionId(analogIO, i), dontSendNotification);
+	}
+}
+
 void AnalogIOInterface::buttonClicked(Button* button)
 {
 	if (button == deviceEnableButton.get())
@@ -107,13 +130,25 @@ void AnalogIOInterface::comboBoxChanged(ComboBox* cb)
 	{
 		if (cb == channelDirectionComboBoxes[i].get())
 		{
-			AnalogIODirection newDirection = channelDirectionComboBoxes[i]->getText() == "Input" ? AnalogIODirection::Input : AnalogIODirection::Output;
+			AnalogIODirection newDirection = getChannelDirectionFromString(channelDirectionComboBoxes[i]->getText());
 			std::static_pointer_cast<AnalogIO>(device)->setChannelDirection(i, newDirection);
 			return;
 		}
 	}
 }
 
+AnalogIODirection AnalogIOInterface::getChannelDirectionFromString(String direction)
+{
+	if (direction == "Input")
+		return AnalogIODirection::Input;
+	else if (direction == "Output")
+		return AnalogIODirection::Output;
+	else
+		LOGE("Invalid direction given.");
+
+	return AnalogIODirection::Input;
+}
+
 int AnalogIOInterface::getChannelDirectionId(std::shared_ptr<AnalogIO> device, int channelNumber)
 {
 	switch (device->getChannelDirection(channelNumber))
@@ -154,3 +189,59 @@ int AnalogIOInterface::getDataTypeId(std::shared_ptr<AnalogIO> device)
 		return 0;
 	}
 }
+
+void AnalogIOInterface::saveParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	auto analogIO = std::static_pointer_cast<AnalogIO>(device);
+
+	LOGD("Saving AnalogIO settings.");
+
+	XmlElement* xmlNode = xml->createNewChildElement("ANALOGIO");
+
+	xmlNode->setAttribute("isEnabled", device->isEnabled());
+
+	XmlElement* channelDirectionNode = xmlNode->createNewChildElement("CHANNEL_DIRECTION");
+
+	for (int i = 0; i < numChannels; i++)
+	{
+		channelDirectionNode->setAttribute("CH" + String(i), AnalogIO::getChannelDirection(analogIO->getChannelDirection(i)));
+	}
+}
+
+void AnalogIOInterface::loadParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Loading AnalogIO settings.");
+
+	auto analogIO = std::static_pointer_cast<AnalogIO>(device);
+
+	auto xmlNode = xml->getChildByName("ANALOGIO");
+
+	if (xmlNode == nullptr)
+	{
+		LOGE("No ANALOGIO element found.");
+		return;
+	}
+
+	auto enabled = xmlNode->getBoolAttribute("isEnabled");
+	analogIO->setEnabled(enabled);
+
+	auto chDirectionNode = xmlNode->getChildByName("CHANNEL_DIRECTION");
+
+	if (chDirectionNode == nullptr)
+	{
+		LOGE("No CHANNEL_DIRECTION element found");
+		return;
+	}
+
+	for (int i = 0; i < numChannels; i++)
+	{
+		AnalogIODirection direction = getChannelDirectionFromString(chDirectionNode->getStringAttribute("CH" + String(i)));
+		analogIO->setChannelDirection(i, direction);
+	}
+
+	updateSettings();
+}
diff --git a/Source/UI/AnalogIOInterface.h b/Source/UI/AnalogIOInterface.h
index b97529a..a9ca095 100644
--- a/Source/UI/AnalogIOInterface.h
+++ b/Source/UI/AnalogIOInterface.h
@@ -34,30 +34,23 @@ class AnalogIOInterface : public SettingsInterface,
 	public ComboBox::Listener
 {
 public:
-	/** Constructor */
 	AnalogIOInterface(std::shared_ptr<AnalogIO> d, OnixSourceEditor* e, OnixSourceCanvas* c);
 
-	/** Disables buttons and starts animation if necessary */
-	void startAcquisition() override {};
+	void saveParameters(XmlElement* xml) override;
 
-	/** Enables buttons and start animation if necessary */
-	void stopAcquisition() override {};
+	void loadParameters(XmlElement* xml) override;
 
-	/** Save parameters to XML */
-	void saveParameters(XmlElement* xml) override {};
-
-	/** Load parameters from XML */
-	void loadParameters(XmlElement* xml) override {};
-
-	/** Updates the info string on the right-hand side of the component */
 	void updateInfoString() override {};
 
-	/** Listener methods*/
+	void updateSettings() override;
+
 	void buttonClicked(Button*) override;
 	void comboBoxChanged(ComboBox* cb) override;
 
 private:
 
+	void setInterfaceEnabledState(bool newState) override;
+
 	static const int numChannels = 12;
 
 	std::array<std::unique_ptr<Label>, numChannels> channelDirectionLabels;
@@ -68,6 +61,7 @@ class AnalogIOInterface : public SettingsInterface,
 	static int getChannelDirectionId(std::shared_ptr<AnalogIO> device, int channelNumber);
 	static int getChannelVoltageRangeId(std::shared_ptr<AnalogIO> device, int channelNumber);
 	static int getDataTypeId(std::shared_ptr<AnalogIO> device);
+	static AnalogIODirection getChannelDirectionFromString(String direction);
 
 	JUCE_LEAK_DETECTOR(AnalogIOInterface);
 };
diff --git a/Source/UI/Bno055Interface.cpp b/Source/UI/Bno055Interface.cpp
index b1a2771..f73d7b6 100644
--- a/Source/UI/Bno055Interface.cpp
+++ b/Source/UI/Bno055Interface.cpp
@@ -42,6 +42,19 @@ Bno055Interface::Bno055Interface(std::shared_ptr<Bno055> d, OnixSourceEditor* e,
 	type = SettingsInterface::Type::BNO055_SETTINGS_INTERFACE;
 }
 
+void Bno055Interface::setInterfaceEnabledState(bool newState)
+{
+	if (deviceEnableButton != nullptr)
+		deviceEnableButton->setEnabled(newState);
+}
+
+void Bno055Interface::updateSettings()
+{
+	if (device == nullptr) return;
+
+	deviceEnableButton->setToggleState(device->isEnabled(), sendNotification);
+}
+
 void Bno055Interface::buttonClicked(Button* button)
 {
 	if (button == deviceEnableButton.get())
@@ -66,3 +79,49 @@ void Bno055Interface::buttonClicked(Button* button)
 		CoreServices::updateSignalChain(editor);
 	}
 }
+
+void Bno055Interface::saveParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Saving Bno055 settings.");
+
+	XmlElement* xmlNode = xml->createNewChildElement("BNO055");
+
+	xmlNode->setAttribute("name", device->getName());
+	xmlNode->setAttribute("idx", (int)device->getDeviceIdx());
+
+	xmlNode->setAttribute("isEnabled", device->isEnabled());
+}
+
+void Bno055Interface::loadParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Loading Bno055 settings.");
+
+	XmlElement* xmlNode = nullptr;
+
+	for (auto* node : xml->getChildIterator())
+	{
+		if (node->hasTagName("BNO055"))
+		{
+			if (node->getStringAttribute("name") == device->getName() &&
+				node->getIntAttribute("idx") == device->getDeviceIdx())
+			{
+				xmlNode = node;
+				break;
+			}
+		}
+	}
+
+	if (xmlNode == nullptr)
+	{
+		LOGD("No Bno055 element found.");
+		return;
+	}
+
+	device->setEnabled(xmlNode->getBoolAttribute("isEnabled"));
+
+	updateSettings();
+}
diff --git a/Source/UI/Bno055Interface.h b/Source/UI/Bno055Interface.h
index 5eeb121..c633adb 100644
--- a/Source/UI/Bno055Interface.h
+++ b/Source/UI/Bno055Interface.h
@@ -33,25 +33,18 @@ class Bno055Interface : public SettingsInterface,
 	public Button::Listener
 {
 public:
-	/** Constructor */
 	Bno055Interface(std::shared_ptr<Bno055> d, OnixSourceEditor* e, OnixSourceCanvas* c);
 
-	/** Disables buttons and starts animation if necessary */
-	void startAcquisition() override {};
+	void setInterfaceEnabledState(bool newState) override;
 
-	/** Enables buttons and start animation if necessary */
-	void stopAcquisition() override {};
+	void saveParameters(XmlElement* xml) override;
 
-	/** Save parameters to XML */
-	void saveParameters(XmlElement* xml) override {};
+	void loadParameters(XmlElement* xml) override;
 
-	/** Load parameters from XML */
-	void loadParameters(XmlElement* xml) override {};
-
-	/** Updates the info string on the right-hand side of the component */
 	void updateInfoString() override {};
 
-	/** Listener methods*/
+	void updateSettings() override;
+
 	void buttonClicked(Button*) override;
 
 private:
diff --git a/Source/UI/DigitalIOInterface.cpp b/Source/UI/DigitalIOInterface.cpp
index 46ddded..0c0d379 100644
--- a/Source/UI/DigitalIOInterface.cpp
+++ b/Source/UI/DigitalIOInterface.cpp
@@ -42,6 +42,19 @@ DigitalIOInterface::DigitalIOInterface(std::shared_ptr<DigitalIO> d, OnixSourceE
 	type = SettingsInterface::Type::DIGITALIO_SETTINGS_INTERFACE;
 }
 
+void DigitalIOInterface::setInterfaceEnabledState(bool newState)
+{
+	if (deviceEnableButton != nullptr)
+		deviceEnableButton->setEnabled(newState);
+}
+
+void DigitalIOInterface::updateSettings()
+{
+	if (device == nullptr) return;
+
+	deviceEnableButton->setToggleState(device->isEnabled(), sendNotification);
+}
+
 void DigitalIOInterface::buttonClicked(Button* button)
 {
 	if (button == deviceEnableButton.get())
@@ -61,3 +74,33 @@ void DigitalIOInterface::buttonClicked(Button* button)
 		CoreServices::updateSignalChain(editor);
 	}
 }
+
+void DigitalIOInterface::saveParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Saving DigitalIO settings.");
+
+	XmlElement* xmlNode = xml->createNewChildElement("DIGITALIO");
+
+	xmlNode->setAttribute("isEnabled", device->isEnabled());
+}
+
+void DigitalIOInterface::loadParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Loading DigitalIO settings.");
+
+	auto xmlNode = xml->getChildByName("DIGITALIO");
+
+	if (xmlNode == nullptr)
+	{
+		LOGE("No DIGITALIO element found.");
+		return;
+	}
+
+	device->setEnabled(xmlNode->getBoolAttribute("isEnabled"));
+
+	updateSettings();
+}
diff --git a/Source/UI/DigitalIOInterface.h b/Source/UI/DigitalIOInterface.h
index 168078c..c2ca20c 100644
--- a/Source/UI/DigitalIOInterface.h
+++ b/Source/UI/DigitalIOInterface.h
@@ -33,29 +33,22 @@ class DigitalIOInterface : public SettingsInterface,
 	public Button::Listener
 {
 public:
-	/** Constructor */
 	DigitalIOInterface(std::shared_ptr<DigitalIO> d, OnixSourceEditor* e, OnixSourceCanvas* c);
 
-	/** Disables buttons and starts animation if necessary */
-	void startAcquisition() override {};
+	void saveParameters(XmlElement* xml) override;
 
-	/** Enables buttons and start animation if necessary */
-	void stopAcquisition() override {};
+	void loadParameters(XmlElement* xml) override;
 
-	/** Save parameters to XML */
-	void saveParameters(XmlElement* xml) override {};
-
-	/** Load parameters from XML */
-	void loadParameters(XmlElement* xml) override {};
-
-	/** Updates the info string on the right-hand side of the component */
 	void updateInfoString() override {};
 
-	/** Listener methods*/
+	void updateSettings() override;
+
 	void buttonClicked(Button*) override;
 
 private:
 
+	void setInterfaceEnabledState(bool newState) override;
+
 	std::unique_ptr<UtilityButton> deviceEnableButton;
 
 	JUCE_LEAK_DETECTOR(DigitalIOInterface);
diff --git a/Source/UI/HarpSyncInputInterface.cpp b/Source/UI/HarpSyncInputInterface.cpp
index 58ef688..c0e78f6 100644
--- a/Source/UI/HarpSyncInputInterface.cpp
+++ b/Source/UI/HarpSyncInputInterface.cpp
@@ -42,6 +42,19 @@ HarpSyncInputInterface::HarpSyncInputInterface(std::shared_ptr<HarpSyncInput> d,
 	type = SettingsInterface::Type::HARPSYNCINPUT_SETTINGS_INTERFACE;
 }
 
+void HarpSyncInputInterface::setInterfaceEnabledState(bool newState)
+{
+	if (deviceEnableButton != nullptr)
+		deviceEnableButton->setEnabled(newState);
+}
+
+void HarpSyncInputInterface::updateSettings()
+{
+	if (device == nullptr) return;
+
+	deviceEnableButton->setToggleState(device->isEnabled(), sendNotification);
+}
+
 void HarpSyncInputInterface::buttonClicked(Button* button)
 {
 	if (button == deviceEnableButton.get())
@@ -61,3 +74,33 @@ void HarpSyncInputInterface::buttonClicked(Button* button)
 		CoreServices::updateSignalChain(editor);
 	}
 }
+
+void HarpSyncInputInterface::saveParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Saving HarpSyncInput settings.");
+
+	XmlElement* xmlNode = xml->createNewChildElement("HARPSYNCINPUT");
+
+	xmlNode->setAttribute("isEnabled", device->isEnabled());
+}
+
+void HarpSyncInputInterface::loadParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Loading HarpSyncInput settings.");
+
+	auto xmlNode = xml->getChildByName("HARPSYNCINPUT");
+
+	if (xmlNode == nullptr)
+	{
+		LOGE("No HARPSYNCINPUT element found.");
+		return;
+	}
+
+	device->setEnabled(xmlNode->getBoolAttribute("isEnabled"));
+
+	updateSettings();
+}
diff --git a/Source/UI/HarpSyncInputInterface.h b/Source/UI/HarpSyncInputInterface.h
index 7b77512..3cc9087 100644
--- a/Source/UI/HarpSyncInputInterface.h
+++ b/Source/UI/HarpSyncInputInterface.h
@@ -36,25 +36,20 @@ class HarpSyncInputInterface : public SettingsInterface,
 
 	HarpSyncInputInterface(std::shared_ptr<HarpSyncInput> d, OnixSourceEditor* e, OnixSourceCanvas* c);
 
-	/** Disables buttons and starts animation if necessary */
-	void startAcquisition() override {};
+	void saveParameters(XmlElement* xml) override;
 
-	/** Enables buttons and start animation if necessary */
-	void stopAcquisition() override {};
-
-	/** Save parameters to XML */
-	void saveParameters(XmlElement* xml) override {};
-
-	/** Load parameters from XML */
-	void loadParameters(XmlElement* xml) override {};
+	void loadParameters(XmlElement* xml) override;
 
 	void updateInfoString() override {};
 
-	/** Listener methods*/
+	void updateSettings() override;
+
 	void buttonClicked(Button*) override;
 
 private:
 
+	void setInterfaceEnabledState(bool newState) override;
+
 	std::unique_ptr<UtilityButton> deviceEnableButton;
 
 	JUCE_LEAK_DETECTOR(HarpSyncInputInterface);
diff --git a/Source/UI/NeuropixV1Interface.cpp b/Source/UI/NeuropixV1Interface.cpp
index 97905da..c6a2e55 100644
--- a/Source/UI/NeuropixV1Interface.cpp
+++ b/Source/UI/NeuropixV1Interface.cpp
@@ -520,10 +520,8 @@ NeuropixV1Interface::NeuropixV1Interface(std::shared_ptr<Neuropixels_1> d, OnixS
 #pragma endregion
 
 		addAndMakeVisible(activityViewComponent.get());
-	}
-	else
-	{
-		type = SettingsInterface::Type::UNKNOWN_SETTINGS_INTERFACE;
+
+		updateSettings();
 	}
 
 	drawLegend();
@@ -531,6 +529,21 @@ NeuropixV1Interface::NeuropixV1Interface(std::shared_ptr<Neuropixels_1> d, OnixS
 	updateInfoString();
 }
 
+void NeuropixV1Interface::updateSettings()
+{
+	if (device == nullptr) return;
+
+	auto npx1 = std::static_pointer_cast<Neuropixels_1>(device);
+
+	applyProbeSettings(npx1->settings[0].get());
+	checkForExistingChannelPreset();
+
+	deviceEnableButton->setToggleState(npx1->isEnabled(), sendNotification);
+
+	gainCalibrationFile->setText(npx1->gainCalibrationFilePath == "None" ? "" : npx1->gainCalibrationFilePath, dontSendNotification);
+	adcCalibrationFile->setText(npx1->adcCalibrationFilePath == "None" ? "" : npx1->adcCalibrationFilePath, dontSendNotification);
+}
+
 void NeuropixV1Interface::updateInfoString()
 {
 	String deviceString, infoString;
@@ -801,24 +814,15 @@ std::vector<int> NeuropixV1Interface::getSelectedElectrodes() const
 	return electrodeIndices;
 }
 
-void NeuropixV1Interface::setApGain(int index)
-{
-	apGainComboBox->setSelectedId(index + 1, true);
-}
-
-void NeuropixV1Interface::setLfpGain(int index)
+int NeuropixV1Interface::getIndexOfComboBoxItem(ComboBox* cb, String item)
 {
-	lfpGainComboBox->setSelectedId(index + 1, true);
-}
-
-void NeuropixV1Interface::setReference(int index)
-{
-	referenceComboBox->setSelectedId(index + 1, true);
-}
+	for (int i = 0; i < cb->getNumItems(); i++)
+	{
+		if (item == cb->getItemText(i))
+			return i;
+	}
 
-void NeuropixV1Interface::setApFilterState(bool state)
-{
-	filterComboBox->setSelectedId(int(!state) + 1, true);
+	return -1;
 }
 
 void NeuropixV1Interface::selectElectrodes(std::vector<int> electrodes)
@@ -851,8 +855,20 @@ void NeuropixV1Interface::setInterfaceEnabledState(bool enabledState)
 	if (referenceComboBox != nullptr)
 		referenceComboBox->setEnabled(enabledState);
 
+	if (saveJsonButton != nullptr)
+		saveJsonButton->setEnabled(enabledState);
+
 	if (loadJsonButton != nullptr)
 		loadJsonButton->setEnabled(enabledState);
+
+	if (offsetCorrectionCheckbox != nullptr)
+		offsetCorrectionCheckbox->setEnabled(enabledState);
+
+	if (adcCalibrationFileButton != nullptr)
+		adcCalibrationFileButton->setEnabled(enabledState);
+
+	if (gainCalibrationFileButton != nullptr)
+		gainCalibrationFileButton->setEnabled(enabledState);
 }
 
 void NeuropixV1Interface::startAcquisition()
@@ -902,7 +918,7 @@ void NeuropixV1Interface::drawLegend()
 	}
 }
 
-bool NeuropixV1Interface::applyProbeSettings(ProbeSettings<Neuropixels_1::numberOfChannels, Neuropixels_1::numberOfElectrodes>* p, bool shouldUpdateProbe)
+bool NeuropixV1Interface::applyProbeSettings(ProbeSettings<Neuropixels_1::numberOfChannels, Neuropixels_1::numberOfElectrodes>* p)
 {
 	auto npx = std::static_pointer_cast<Neuropixels_1>(device);
 
@@ -945,10 +961,6 @@ bool NeuropixV1Interface::applyProbeSettings(ProbeSettings<Neuropixels_1::number
 	settings->selectedElectrode = p->selectedElectrode;
 	settings->selectedShank = p->selectedShank;
 
-	if (shouldUpdateProbe)
-	{
-		CoreServices::saveRecoveryConfig();
-	}
 
 	drawLegend();
 	repaint();
@@ -958,101 +970,163 @@ bool NeuropixV1Interface::applyProbeSettings(ProbeSettings<Neuropixels_1::number
 
 void NeuropixV1Interface::saveParameters(XmlElement* xml)
 {
-	if (device != nullptr)
-	{
-		auto npx = std::static_pointer_cast<Neuropixels_1>(device);
-		auto settings = npx->settings[0].get();
+	if (device == nullptr) return;
 
-		LOGD("Saving Neuropix display.");
+	LOGD("Saving Neuropixels 1.0f settings.");
 
-		XmlElement* xmlNode = xml->createNewChildElement("NP_PROBE");
+	auto npx = std::static_pointer_cast<Neuropixels_1>(device);
+	auto settings = npx->settings[0].get();
 
-		xmlNode->setAttribute("probe_serial_number", String(npx->getProbeSerialNumber()));
-		xmlNode->setAttribute("probe_name", npx->getName());
-		xmlNode->setAttribute("num_adcs", settings->probeMetadata.num_adcs);
+	XmlElement* xmlNode = xml->createNewChildElement("NEUROPIXELSV1F");
 
-		xmlNode->setAttribute("ZoomHeight", probeBrowser->getZoomHeight());
-		xmlNode->setAttribute("ZoomOffset", probeBrowser->getZoomOffset());
+	xmlNode->setAttribute("name", npx->getName());
+	xmlNode->setAttribute("idx", (int)npx->getDeviceIdx());
+	xmlNode->setAttribute("probeSerialNumber", String(npx->getProbeSerialNumber()));
 
-		if (apGainComboBox != nullptr)
-		{
-			xmlNode->setAttribute("apGainValue", apGainComboBox->getText());
-			xmlNode->setAttribute("apGainIndex", apGainComboBox->getSelectedId() - 1);
-		}
+	xmlNode->setAttribute("isEnabled", bool(device->isEnabled()));
 
-		if (lfpGainComboBox != nullptr)
-		{
-			xmlNode->setAttribute("lfpGainValue", lfpGainComboBox->getText());
-			xmlNode->setAttribute("lfpGainIndex", lfpGainComboBox->getSelectedId() - 1);
-		}
+	xmlNode->setAttribute("adcCalibrationFile", npx->adcCalibrationFilePath);
+	xmlNode->setAttribute("gainCalibrationFile", npx->gainCalibrationFilePath);
 
-		if (electrodeConfigurationComboBox != nullptr)
-		{
-			if (electrodeConfigurationComboBox->getSelectedId() > 1)
-			{
-				xmlNode->setAttribute("electrodeConfigurationPreset", electrodeConfigurationComboBox->getText());
-			}
-			else
-			{
-				xmlNode->setAttribute("electrodeConfigurationPreset", "NONE");
-			}
-		}
+	XmlElement* probeViewerNode = xmlNode->createNewChildElement("PROBE_VIEWER");
+
+	probeViewerNode->setAttribute("zoomHeight", probeBrowser->getZoomHeight());
+	probeViewerNode->setAttribute("zoomOffset", probeBrowser->getZoomOffset());
 
-		if (referenceComboBox != nullptr)
+	probeViewerNode->setAttribute("apGain", apGainComboBox->getText());
+	probeViewerNode->setAttribute("lfpGain", lfpGainComboBox->getText());
+	probeViewerNode->setAttribute("referenceChannel", referenceComboBox->getText());
+	probeViewerNode->setAttribute("apFilter", filterComboBox->getText());
+
+	XmlElement* channelsNode = xmlNode->createNewChildElement("SELECTED_CHANNELS");
+
+	for (int i = 0; i < settings->selectedElectrode.size(); i++)
+	{
+		int globalIndex = settings->selectedElectrode[i];
+
+		channelsNode->setAttribute("CH" + String(i), String(globalIndex));
+	}
+}
+
+void NeuropixV1Interface::loadParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Loading Neuropixels 1.0f settings.");
+
+	auto npx = std::static_pointer_cast<Neuropixels_1>(device);
+	auto settings = npx->settings[0].get();
+
+	XmlElement* xmlNode = nullptr;
+
+	for (auto* node : xml->getChildIterator())
+	{
+		if (node->hasTagName("NEUROPIXELSV1F"))
 		{
-			if (referenceComboBox->getSelectedId() > 0)
+			if (node->getStringAttribute("name") == npx->getName() &&
+				node->getIntAttribute("idx") == npx->getDeviceIdx())
 			{
-				xmlNode->setAttribute("referenceChannel", referenceComboBox->getText());
-				xmlNode->setAttribute("referenceChannelIndex", referenceComboBox->getSelectedId() - 1);
-			}
-			else
-			{
-				xmlNode->setAttribute("referenceChannel", "Ext");
-				xmlNode->setAttribute("referenceChannelIndex", 0);
+				xmlNode = node;
+				break;
 			}
 		}
+	}
 
-		if (filterComboBox != nullptr)
-		{
-			xmlNode->setAttribute("filterCut", filterComboBox->getText());
-			xmlNode->setAttribute("filterCutIndex", filterComboBox->getSelectedId());
-		}
+	if (xmlNode == nullptr)
+	{
+		LOGD("No NEUROPIXELSV1F element found matching name = " + npx->getName() + ", and idx = " + npx->getDeviceIdx());
+		return;
+	}
 
-		XmlElement* channelNode = xmlNode->createNewChildElement("CHANNELS");
-		XmlElement* xposNode = xmlNode->createNewChildElement("ELECTRODE_XPOS");
-		XmlElement* yposNode = xmlNode->createNewChildElement("ELECTRODE_YPOS");
+	if (npx->getProbeSerialNumber() != 0 && xmlNode->getIntAttribute("probeSerialNumber") != npx->getProbeSerialNumber())
+	{
+		LOGC("Different serial numbers found. Current serial number is " + String(npx->getProbeSerialNumber()) + ", while the saved serial number is " + String(xmlNode->getIntAttribute("probeSerialNumber")) + ". Updating settings...");
+	}
 
-		for (int i = 0; i < settings->selectedElectrode.size(); i++)
-		{
-			int bank = int(settings->selectedBank[i]);
-			int shank = settings->selectedShank[i];
-			int electrode = settings->selectedElectrode[i];
+	npx->setEnabled(xmlNode->getBoolAttribute("isEnabled"));
 
-			String chString = String(bank);
+	npx->adcCalibrationFilePath = xmlNode->getStringAttribute("adcCalibrationFile");
+	npx->gainCalibrationFilePath = xmlNode->getStringAttribute("gainCalibrationFile");
 
-			String chId = "CH" + String(i);
+	XmlElement* probeViewerNode = xmlNode->getChildByName("PROBE_VIEWER");
 
-			channelNode->setAttribute(chId, chString);
-			xposNode->setAttribute(chId, String(settings->electrodeMetadata[electrode].xpos + 250 * shank));
-			yposNode->setAttribute(chId, String(settings->electrodeMetadata[electrode].ypos));
-		}
+	if (probeViewerNode == nullptr)
+	{
+		LOGE("No PROBE_VIEWER element found.");
+		return;
+	}
 
-		xmlNode->setAttribute("visualizationMode", (double)mode);
-		xmlNode->setAttribute("activityToView", (double)probeBrowser->activityToView);
+	probeBrowser->setZoomHeightAndOffset(probeViewerNode->getIntAttribute("zoomHeight"), probeViewerNode->getIntAttribute("zoomOffset"));
 
-		xmlNode->setAttribute("isEnabled", bool(device->isEnabled()));
+	int idx = -1;
+
+	idx = getIndexOfComboBoxItem(apGainComboBox.get(), probeViewerNode->getStringAttribute("apGain"));
+	if (idx == -1)
+	{
+		LOGE("No AP gain variable found.");
 	}
-}
+	else
+		settings->apGainIndex = idx;
 
-void NeuropixV1Interface::loadParameters(XmlElement* xml)
-{
-	auto npx = std::static_pointer_cast<Neuropixels_1>(device);
+	idx = getIndexOfComboBoxItem(lfpGainComboBox.get(), probeViewerNode->getStringAttribute("lfpGain"));
+	if (idx == -1)
+	{
+		LOGE("No LFP gain variable found.");
+	}
+	else
+		settings->lfpGainIndex = idx;
+
+	idx = getIndexOfComboBoxItem(referenceComboBox.get(), probeViewerNode->getStringAttribute("referenceChannel"));
+	if (idx == -1)
+	{
+		LOGE("No reference channel variable found.");
+	}
+	else
+		settings->referenceIndex = idx;
+
+	idx = getIndexOfComboBoxItem(filterComboBox.get(), probeViewerNode->getStringAttribute("apFilter"));
+	if (idx == -1)
+	{
+		LOGE("No AP filter variable found.");
+	}
+	else
+		settings->apFilterState = idx == 1 ? true : false;
+
+	XmlElement* channelsNode = xmlNode->getChildByName("SELECTED_CHANNELS");
 
-	if (npx != nullptr)
+	if (channelsNode == nullptr)
 	{
-		//auto npx = std::static_pointer_cast<Neuropixels_1>(device);
+		LOGE("No SELECTED_CHANNELS element found.");
+		return;
+	}
+
+	std::vector<int> selectedChannels{};
+	selectedChannels.reserve(npx->numberOfChannels);
+
+	for (int i = 0; i < npx->numberOfChannels; i++)
+	{
+		String chIdx = channelsNode->getStringAttribute("CH" + String(i), "");
+
+		if (chIdx == "")
+		{
+			LOGE("Channel #" + String(i) + " not found. Channel map will not be updated.");
+			return;
+		}
 
-		// TODO: load parameters, put them into device->settings, and then update the interface
-		//applyProbeSettings(device->settings.get(), false);
+		selectedChannels.emplace_back(std::stoi(chIdx.toStdString()));
 	}
+
+	std::sort(selectedChannels.begin(), selectedChannels.end());
+	auto last = std::unique(selectedChannels.begin(), selectedChannels.end());
+	selectedChannels.erase(last, selectedChannels.end());
+
+	if (selectedChannels.size() != npx->numberOfChannels)
+	{
+		LOGE("Invalid channel map. Wrong number of channels found. Channel map was not updated");
+		return;
+	}
+
+	selectElectrodes(selectedChannels);
+
+	updateSettings();
 }
diff --git a/Source/UI/NeuropixV1Interface.h b/Source/UI/NeuropixV1Interface.h
index 1eb8389..b114bfa 100644
--- a/Source/UI/NeuropixV1Interface.h
+++ b/Source/UI/NeuropixV1Interface.h
@@ -44,41 +44,34 @@ class NeuropixV1Interface : public SettingsInterface,
 public:
 	friend class ProbeBrowser<Neuropixels_1::numberOfChannels, Neuropixels_1::numberOfElectrodes>;
 
-	/** Constructor */
 	NeuropixV1Interface(std::shared_ptr<Neuropixels_1> d, OnixSourceEditor* e, OnixSourceCanvas* c);
-
-	/** Listener methods*/
+	
 	void buttonClicked(Button*) override;
 	void comboBoxChanged(ComboBox*) override;
 
-	/** Disables buttons and starts animation if necessary */
 	void startAcquisition() override;
 
-	/** Enables buttons and start animation if necessary */
 	void stopAcquisition() override;
 
 	/** Settings-related functions*/
-	bool applyProbeSettings(ProbeSettings<Neuropixels_1::numberOfChannels, Neuropixels_1::numberOfElectrodes>* p, bool shouldUpdateProbe = true);
+	bool applyProbeSettings(ProbeSettings<Neuropixels_1::numberOfChannels, Neuropixels_1::numberOfElectrodes>* p);
 
-	/** Save parameters to XML */
 	void saveParameters(XmlElement* xml) override;
 
-	/** Load parameters from XML */
 	void loadParameters(XmlElement* xml) override;
 
-	/** Updates the info string on the right-hand side of the component */
 	void updateInfoString() override;
 
-	/** Set parameters */
-	void setApGain(int index);
-	void setLfpGain(int index);
-	void setReference(int index);
-	void setApFilterState(bool state);
+	void updateSettings() override;
+
 	void selectElectrodes(std::vector<int> electrodes);
 
 	String getReferenceText() override { return referenceComboBox->getText(); }
 
 private:
+
+	void setInterfaceEnabledState(bool newState) override;
+
 	XmlElement neuropix_info;
 
 	bool acquisitionIsActive = false;
@@ -152,10 +145,10 @@ class NeuropixV1Interface : public SettingsInterface,
 
 	std::vector<int> getSelectedElectrodes() const;
 
-	void setInterfaceEnabledState(bool enabledState);
-
 	/** Checks if the current channel map matches an existing channel preset, and updates the combo box if it does */
 	void checkForExistingChannelPreset();
 
+	int getIndexOfComboBoxItem(ComboBox* cb, String item);
+
 	JUCE_LEAK_DETECTOR(NeuropixV1Interface);
 };
diff --git a/Source/UI/NeuropixelsV1fProbeBrowser.h b/Source/UI/NeuropixelsV1fProbeBrowser.h
index 91fbc8d..417f3c5 100644
--- a/Source/UI/NeuropixelsV1fProbeBrowser.h
+++ b/Source/UI/NeuropixelsV1fProbeBrowser.h
@@ -38,6 +38,6 @@ class NeuropixelsV1fProbeBrowser : public ProbeBrowser<NeuropixelsV1fValues::num
 
 	ProbeSettings<NeuropixelsV1fValues::numberOfChannels, NeuropixelsV1fValues::numberOfElectrodes>* getSettings() override
 	{
-		return std::static_pointer_cast<Neuropixels_1>(parent->device)->settings[0].get();
+		return std::static_pointer_cast<Neuropixels_1>(parent->getDevice())->settings[0].get();
 	}
 };
diff --git a/Source/UI/NeuropixelsV2eInterface.cpp b/Source/UI/NeuropixelsV2eInterface.cpp
index 25ccfd7..01941be 100644
--- a/Source/UI/NeuropixelsV2eInterface.cpp
+++ b/Source/UI/NeuropixelsV2eInterface.cpp
@@ -40,15 +40,15 @@ NeuropixelsV2eInterface::NeuropixelsV2eInterface(std::shared_ptr<Neuropixels2e>
 	deviceComponent = std::make_unique<Component>();
 	deviceComponent->setBounds(0, 0, 600, 40);
 
-	probeEnableButton = std::make_unique<UtilityButton>("ENABLED");
-	probeEnableButton->setFont(FontOptions("Fira Code", "Regular", 12.0f));
-	probeEnableButton->setRadius(3.0f);
-	probeEnableButton->setBounds(10, 15, 100, 22);
-	probeEnableButton->setClickingTogglesState(true);
-	probeEnableButton->setToggleState(device->isEnabled(), dontSendNotification);
-	probeEnableButton->setTooltip("If disabled, probe will not stream data during acquisition");
-	probeEnableButton->addListener(this);
-	deviceComponent->addAndMakeVisible(probeEnableButton.get());
+	deviceEnableButton = std::make_unique<UtilityButton>("ENABLED");
+	deviceEnableButton->setFont(FontOptions("Fira Code", "Regular", 12.0f));
+	deviceEnableButton->setRadius(3.0f);
+	deviceEnableButton->setBounds(10, 15, 100, 22);
+	deviceEnableButton->setClickingTogglesState(true);
+	deviceEnableButton->setToggleState(device->isEnabled(), dontSendNotification);
+	deviceEnableButton->setTooltip("If disabled, probe will not stream data during acquisition");
+	deviceEnableButton->addListener(this);
+	deviceComponent->addAndMakeVisible(deviceEnableButton.get());
 
 	addAndMakeVisible(deviceComponent.get());
 
@@ -63,7 +63,7 @@ void NeuropixelsV2eInterface::updateDevice(std::shared_ptr<Neuropixels2e> d)
 
 	for (const auto& probeInterface : probeInterfaces)
 	{
-		probeInterface->device = device;
+		probeInterface->setDevice(device);
 	}
 }
 
@@ -82,9 +82,9 @@ void NeuropixelsV2eInterface::updateInfoString()
 
 void NeuropixelsV2eInterface::buttonClicked(Button* b)
 {
-	if (b == probeEnableButton.get())
+	if (b == deviceEnableButton.get())
 	{
-		device->setEnabled(probeEnableButton->getToggleState());
+		device->setEnabled(deviceEnableButton->getToggleState());
 
 		if (canvas->foundInputSource())
 		{
@@ -94,13 +94,92 @@ void NeuropixelsV2eInterface::buttonClicked(Button* b)
 
 		if (device->isEnabled())
 		{
-			probeEnableButton->setLabel("ENABLED");
+			deviceEnableButton->setLabel("ENABLED");
 		}
 		else
 		{
-			probeEnableButton->setLabel("DISABLED");
+			deviceEnableButton->setLabel("DISABLED");
 		}
 
 		CoreServices::updateSignalChain(editor);
 	}
 }
+
+void NeuropixelsV2eInterface::updateSettings()
+{
+	if (device == nullptr) return;
+
+	deviceEnableButton->setToggleState(device->isEnabled(), sendNotification);
+
+	for (const auto& probeInterface : probeInterfaces)
+	{
+		probeInterface->updateSettings();
+	}
+}
+
+void NeuropixelsV2eInterface::setInterfaceEnabledState(bool newState)
+{
+	if (device == nullptr) return;
+
+	if (deviceEnableButton != nullptr)
+		deviceEnableButton->setEnabled(newState);
+
+	for (const auto& probeInterface : probeInterfaces)
+	{
+		probeInterface->setInterfaceEnabledState(newState);
+	}
+}
+
+void NeuropixelsV2eInterface::saveParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Saving NeuropixelsV2e settings.");
+
+	XmlElement* xmlNode = xml->createNewChildElement("NEUROPIXELSV2E");
+
+	xmlNode->setAttribute("idx", (int)device->getDeviceIdx());
+
+	xmlNode->setAttribute("isEnabled", device->isEnabled());
+
+	for (const auto& probeInterface : probeInterfaces)
+	{
+		probeInterface->saveParameters(xmlNode);
+	}
+}
+
+void NeuropixelsV2eInterface::loadParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Loading NeuropixelsV2e settings.");
+
+	XmlElement* xmlNode = nullptr;
+
+	for (auto* node : xml->getChildIterator())
+	{
+		if (node->hasTagName("NEUROPIXELSV2E"))
+		{
+			if (node->getIntAttribute("idx") == device->getDeviceIdx())
+			{
+				xmlNode = node;
+				break;
+			}
+		}
+	}
+
+	if (xmlNode == nullptr)
+	{
+		LOGD("No NeuropixelsV2e element found.");
+		return;
+	}
+
+	device->setEnabled(xmlNode->getBoolAttribute("isEnabled"));
+
+	for (const auto& probeInterface : probeInterfaces)
+	{
+		probeInterface->loadParameters(xmlNode);
+	}
+
+	updateSettings();
+}
diff --git a/Source/UI/NeuropixelsV2eInterface.h b/Source/UI/NeuropixelsV2eInterface.h
index 6064631..5e3fa2f 100644
--- a/Source/UI/NeuropixelsV2eInterface.h
+++ b/Source/UI/NeuropixelsV2eInterface.h
@@ -33,13 +33,9 @@ class NeuropixelsV2eInterface : public SettingsInterface,
 public:
 	NeuropixelsV2eInterface(std::shared_ptr<Neuropixels2e> d, OnixSourceEditor* e, OnixSourceCanvas* c);
 
-	void startAcquisition() override {};
+	void saveParameters(XmlElement* xml) override;
 
-	void stopAcquisition() override {};
-
-	void saveParameters(XmlElement* xml) override {};
-
-	void loadParameters(XmlElement* xml) override {};
+	void loadParameters(XmlElement* xml) override;
 
 	void updateInfoString() override;
 
@@ -47,13 +43,17 @@ class NeuropixelsV2eInterface : public SettingsInterface,
 
 	void buttonClicked(Button* b) override;
 
+	void updateSettings() override;
+
 	void updateDevice(std::shared_ptr<Neuropixels2e> d);
 
 private:
 
+	void setInterfaceEnabledState(bool newState) override;
+
 	std::unique_ptr<CustomTabComponent> topLevelTabComponent;
 
-	std::unique_ptr<UtilityButton> probeEnableButton;
+	std::unique_ptr<UtilityButton> deviceEnableButton;
 	std::unique_ptr<Component> deviceComponent;
 
 	static const int numProbes = 2;
diff --git a/Source/UI/NeuropixelsV2eProbeBrowser.h b/Source/UI/NeuropixelsV2eProbeBrowser.h
index 507dc28..49353b5 100644
--- a/Source/UI/NeuropixelsV2eProbeBrowser.h
+++ b/Source/UI/NeuropixelsV2eProbeBrowser.h
@@ -38,6 +38,6 @@ class NeuropixelsV2eProbeBrowser : public ProbeBrowser<NeuropixelsV2eValues::num
 
 	ProbeSettings<NeuropixelsV2eValues::numberOfChannels, NeuropixelsV2eValues::numberOfElectrodes>* getSettings() override
 	{
-		return std::static_pointer_cast<Neuropixels2e>(parent->device)->settings[probeIndex].get();
+		return std::static_pointer_cast<Neuropixels2e>(parent->getDevice())->settings[probeIndex].get();
 	}
 };
diff --git a/Source/UI/NeuropixelsV2eProbeInterface.cpp b/Source/UI/NeuropixelsV2eProbeInterface.cpp
index 7693a99..d62c836 100644
--- a/Source/UI/NeuropixelsV2eProbeInterface.cpp
+++ b/Source/UI/NeuropixelsV2eProbeInterface.cpp
@@ -183,40 +183,7 @@ NeuropixelsV2eProbeInterface::NeuropixelsV2eProbeInterface(std::shared_ptr<Neuro
 
 			currentHeight += 55;
 		}
-
-		currentHeight += 55;
-
-		activityViewButton = std::make_unique<UtilityButton>("VIEW");
-		activityViewButton->setFont(fontRegularButton);
-		activityViewButton->setRadius(3.0f);
-
-		activityViewButton->addListener(this);
-		activityViewButton->setTooltip("View peak-to-peak amplitudes for each channel");
-		addAndMakeVisible(activityViewButton.get());
-
-		activityViewComboBox = std::make_unique<ComboBox>("ActivityView Combo Box");
-
-		if (settings->availableLfpGains.size() > 0)
-		{
-			activityViewComboBox->setBounds(450, currentHeight, 65, 22);
-			activityViewComboBox->addListener(this);
-			activityViewComboBox->addItem("AP", 1);
-			activityViewComboBox->addItem("LFP", 2);
-			activityViewComboBox->setSelectedId(1, dontSendNotification);
-			addAndMakeVisible(activityViewComboBox.get());
-			activityViewButton->setBounds(530, currentHeight + 2, 45, 18);
-		}
-		else
-		{
-			activityViewButton->setBounds(450, currentHeight + 2, 45, 18);
-		}
-
-		activityViewLabel = std::make_unique<Label>("PROBE SIGNAL", "PROBE SIGNAL");
-		activityViewLabel->setFont(fontRegularLabel);
-		activityViewLabel->setBounds(446, currentHeight - 20, 180, 20);
-		addAndMakeVisible(activityViewLabel.get());
-
-		/// Draw Legends
+#pragma region Draw Legends
 
 		// ENABLE View
 		Colour colour = Colour(55, 55, 55);
@@ -336,10 +303,8 @@ NeuropixelsV2eProbeInterface::NeuropixelsV2eProbeInterface(std::shared_ptr<Neuro
 		}
 
 		addAndMakeVisible(activityViewComponent.get());
-	}
-	else
-	{
-		type = SettingsInterface::Type::UNKNOWN_SETTINGS_INTERFACE;
+
+#pragma endregion
 	}
 
 	drawLegend();
@@ -370,64 +335,22 @@ void NeuropixelsV2eProbeInterface::updateInfoString()
 
 void NeuropixelsV2eProbeInterface::comboBoxChanged(ComboBox* comboBox)
 {
-	if (!editor->acquisitionIsActive)
-	{
-		auto npx = std::static_pointer_cast<Neuropixels2e>(device);
-
-		if (comboBox == electrodeConfigurationComboBox.get())
-		{
-			String preset = electrodeConfigurationComboBox->getText();
+	auto npx = std::static_pointer_cast<Neuropixels2e>(device);
 
-			auto selection = npx->selectElectrodeConfiguration(preset);
+	if (comboBox == electrodeConfigurationComboBox.get())
+	{
+		String preset = electrodeConfigurationComboBox->getText();
 
-			selectElectrodes(selection);
-		}
-		else if (comboBox == referenceComboBox.get())
-		{
-			npx->settings[probeIndex]->referenceIndex = referenceComboBox->getSelectedItemIndex();
-		}
-		else if (comboBox == activityViewComboBox.get())
-		{
-			if (comboBox->getSelectedId() == 1)
-			{
-				probeBrowser->activityToView = ActivityToView::APVIEW;
-				ColourScheme::setColourScheme(ColourSchemeId::PLASMA);
-				probeBrowser->maxPeakToPeakAmplitude = 250.0f;
-			}
-			else
-			{
-				probeBrowser->activityToView = ActivityToView::LFPVIEW;
-				ColourScheme::setColourScheme(ColourSchemeId::VIRIDIS);
-				probeBrowser->maxPeakToPeakAmplitude = 500.0f;
-			}
-		}
+		auto selection = npx->selectElectrodeConfiguration(preset);
 
-		repaint();
+		selectElectrodes(selection);
 	}
-	else
+	else if (comboBox == referenceComboBox.get())
 	{
-		if (comboBox == activityViewComboBox.get())
-		{
-			if (comboBox->getSelectedId() == 1)
-			{
-				probeBrowser->activityToView = ActivityToView::APVIEW;
-				ColourScheme::setColourScheme(ColourSchemeId::PLASMA);
-				probeBrowser->maxPeakToPeakAmplitude = 250.0f;
-			}
-			else
-			{
-				probeBrowser->activityToView = ActivityToView::LFPVIEW;
-				ColourScheme::setColourScheme(ColourSchemeId::VIRIDIS);
-				probeBrowser->maxPeakToPeakAmplitude = 500.0f;
-			}
-
-			repaint();
-		}
-		else
-		{
-			CoreServices::sendStatusMessage("Cannot update parameters while acquisition is active"); // no parameter change while acquisition is active
-		}
+		npx->settings[probeIndex]->referenceIndex = referenceComboBox->getSelectedItemIndex();
 	}
+
+	repaint();
 }
 
 void NeuropixelsV2eProbeInterface::checkForExistingChannelPreset()
@@ -445,7 +368,7 @@ void NeuropixelsV2eProbeInterface::checkForExistingChannelPreset()
 
 		for (int j = 0; j < selection.size(); j++)
 		{
-			channelMap[settings->electrodeMetadata[j].channel] = selection[j];
+			channelMap[settings->electrodeMetadata[selection[j]].channel] = selection[j];
 		}
 
 		if (std::equal(channelMap.cbegin(), channelMap.cend(), settings->selectedElectrode.cbegin(), settings->selectedElectrode.cend()))
@@ -476,16 +399,6 @@ void NeuropixelsV2eProbeInterface::buttonClicked(Button* button)
 		drawLegend();
 		repaint();
 	}
-	else if (button == activityViewButton.get())
-	{
-		mode = VisualizationMode::ACTIVITY_VIEW;
-
-		if (acquisitionIsActive)
-			probeBrowser->startTimer(100);
-
-		drawLegend();
-		repaint();
-	}
 	else if (button == enableButton.get())
 	{
 		auto selection = getSelectedElectrodes();
@@ -586,6 +499,12 @@ void NeuropixelsV2eProbeInterface::setInterfaceEnabledState(bool enabledState)
 
 	if (loadJsonButton != nullptr)
 		loadJsonButton->setEnabled(enabledState);
+
+	if (saveJsonButton != nullptr)
+		saveJsonButton->setEnabled(enabledState);
+
+	if (gainCorrectionFileButton != nullptr)
+		gainCorrectionFileButton->setEnabled(enabledState);
 }
 
 void NeuropixelsV2eProbeInterface::startAcquisition()
@@ -627,6 +546,18 @@ void NeuropixelsV2eProbeInterface::drawLegend()
 	}
 }
 
+void NeuropixelsV2eProbeInterface::updateSettings()
+{
+	if (device == nullptr) return;
+
+	auto npx = std::static_pointer_cast<Neuropixels2e>(device);
+
+	applyProbeSettings(npx->settings[probeIndex].get());
+	checkForExistingChannelPreset();
+
+	gainCorrectionFile->setText(npx->getGainCorrectionFile(probeIndex) == "None" ? "" : npx->getGainCorrectionFile(probeIndex), dontSendNotification);
+}
+
 bool NeuropixelsV2eProbeInterface::applyProbeSettings(ProbeSettings<Neuropixels2e::numberOfChannels, Neuropixels2e::numberOfElectrodes>* p, bool shouldUpdateProbe)
 {
 	if (electrodeConfigurationComboBox != 0)
@@ -669,83 +600,137 @@ bool NeuropixelsV2eProbeInterface::applyProbeSettings(ProbeSettings<Neuropixels2
 	return true;
 }
 
-void NeuropixelsV2eProbeInterface::saveParameters(XmlElement* xml)
+int NeuropixelsV2eProbeInterface::getIndexOfComboBoxItem(ComboBox* cb, String item)
 {
-	/*if (device != nullptr)
+	for (int i = 0; i < cb->getNumItems(); i++)
 	{
-		auto npx = std::static_pointer_cast<Neuropixels2e>(device);
-		auto settings = npx->settings[probeIndex].get();
+		if (item == cb->getItemText(i))
+			return i;
+	}
 
-		LOGD("Saving Neuropix display.");
+	return -1;
+}
 
-		XmlElement* xmlNode = xml->createNewChildElement("NP_PROBE");
+void NeuropixelsV2eProbeInterface::saveParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
 
-		xmlNode->setAttribute("probe_serial_number", String(npx->getProbeSerialNumber(probeIndex)));
-		xmlNode->setAttribute("probe_name", npx->getName());
-		xmlNode->setAttribute("num_adcs", settings->probeMetadata.num_adcs);
+	LOGD("Saving Neuropixels 2.0e settings.");
 
-		xmlNode->setAttribute("ZoomHeight", probeBrowser->getZoomHeight());
-		xmlNode->setAttribute("ZoomOffset", probeBrowser->getZoomOffset());
+	auto npx = std::static_pointer_cast<Neuropixels2e>(device);
+	auto settings = npx->settings[probeIndex].get();
 
-		if (electrodeConfigurationComboBox != nullptr)
-		{
-			if (electrodeConfigurationComboBox->getSelectedId() > 1)
-			{
-				xmlNode->setAttribute("electrodeConfigurationPreset", electrodeConfigurationComboBox->getText());
-			}
-			else
-			{
-				xmlNode->setAttribute("electrodeConfigurationPreset", "NONE");
-			}
-		}
+	XmlElement* xmlNode = xml->createNewChildElement("PROBE" + String(probeIndex));
 
-		if (referenceComboBox != nullptr)
-		{
-			if (referenceComboBox->getSelectedId() > 0)
-			{
-				xmlNode->setAttribute("referenceChannel", referenceComboBox->getText());
-				xmlNode->setAttribute("referenceChannelIndex", referenceComboBox->getSelectedId() - 1);
-			}
-			else
-			{
-				xmlNode->setAttribute("referenceChannel", "Ext");
-				xmlNode->setAttribute("referenceChannelIndex", 0);
-			}
-		}
+	xmlNode->setAttribute("probeSerialNumber", String(npx->getProbeSerialNumber(probeIndex)));
 
-		XmlElement* channelNode = xmlNode->createNewChildElement("CHANNELS");
-		XmlElement* xposNode = xmlNode->createNewChildElement("ELECTRODE_XPOS");
-		XmlElement* yposNode = xmlNode->createNewChildElement("ELECTRODE_YPOS");
+	xmlNode->setAttribute("gainCorrectionFile", npx->getGainCorrectionFile(probeIndex));
 
-		for (int i = 0; i < settings->selectedElectrode.size(); i++)
-		{
-			int bank = int(settings->selectedBank[i]);
-			int shank = settings->selectedShank[i];
-			int elec = settings->selectedElectrode[i];
+	XmlElement* probeViewerNode = xmlNode->createNewChildElement("PROBE_VIEWER");
 
-			String chString = String(bank);
+	probeViewerNode->setAttribute("zoomHeight", probeBrowser->getZoomHeight());
+	probeViewerNode->setAttribute("zoomOffset", probeBrowser->getZoomOffset());
 
-			String chId = "CH" + String(i);
+	probeViewerNode->setAttribute("referenceChannel", referenceComboBox->getText());
 
-			channelNode->setAttribute(chId, chString);
-			xposNode->setAttribute(chId, String(settings->electrodeMetadata[elec].xpos + 250 * shank));
-			yposNode->setAttribute(chId, String(settings->electrodeMetadata[elec].ypos));
-		}
+	XmlElement* channelsNode = xmlNode->createNewChildElement("SELECTED_CHANNELS");
 
-		xmlNode->setAttribute("visualizationMode", (double)mode);
-		xmlNode->setAttribute("activityToView", (double)probeBrowser->activityToView);
+	for (int i = 0; i < settings->selectedElectrode.size(); i++)
+	{
+		int globalIndex = settings->selectedElectrode[i];
 
-		xmlNode->setAttribute("isEnabled", bool(device->isEnabled()));
-	}*/
+		channelsNode->setAttribute("CH" + String(i), String(globalIndex));
+	}
 }
 
 void NeuropixelsV2eProbeInterface::loadParameters(XmlElement* xml)
 {
-	if (device != nullptr)
+	if (device == nullptr) return;
+
+	LOGD("Loading Neuropixels 2.0e settings.");
+
+	auto npx = std::static_pointer_cast<Neuropixels2e>(device);
+	auto settings = npx->settings[probeIndex].get();
+
+	XmlElement* xmlNode = nullptr;
+
+	for (auto* node : xml->getChildIterator())
+	{
+		if (node->hasTagName("PROBE" + String(probeIndex)))
+		{
+			xmlNode = node;
+			break;
+		}
+	}
+
+	if (xmlNode == nullptr)
 	{
-		//auto npx = std::static_pointer_cast<Neuropixels2e>(device);
+		LOGD("No PROBE" + String(probeIndex) + " element found");
+		return;
+	}
 
-		// TODO: load parameters, put them into device->settings, and then update the interface
-		//applyProbeSettings(device->settings.get(), false);
+	if (npx->getProbeSerialNumber(probeIndex) != 0 && xmlNode->getIntAttribute("probeSerialNumber") != npx->getProbeSerialNumber(probeIndex))
+	{
+		LOGC("Different serial numbers found. Current serial number is " + String(npx->getProbeSerialNumber(probeIndex)) + ", while the saved serial number is " + String(xmlNode->getIntAttribute("probeSerialNumber")) + ". Updating settings...");
+	}
+
+	npx->setGainCorrectionFile(probeIndex, xmlNode->getStringAttribute("gainCorrectionFile"));
+
+	XmlElement* probeViewerNode = xmlNode->getChildByName("PROBE_VIEWER");
+
+	if (probeViewerNode == nullptr)
+	{
+		LOGE("No PROBE_VIEWER element found.");
+		return;
 	}
+
+	probeBrowser->setZoomHeightAndOffset(probeViewerNode->getIntAttribute("zoomHeight"), probeViewerNode->getIntAttribute("zoomOffset"));
+
+	int idx = -1;
+
+	idx = getIndexOfComboBoxItem(referenceComboBox.get(), probeViewerNode->getStringAttribute("referenceChannel"));
+	if (idx == -1)
+	{
+		LOGE("No reference channel variable found.");
+	}
+	else
+		settings->referenceIndex = idx;
+
+	XmlElement* channelsNode = xmlNode->getChildByName("SELECTED_CHANNELS");
+
+	if (channelsNode == nullptr)
+	{
+		LOGE("No SELECTED_CHANNELS element found.");
+		return;
+	}
+
+	std::vector<int> selectedChannels{};
+	selectedChannels.reserve(npx->numberOfChannels);
+
+	for (int i = 0; i < npx->numberOfChannels; i++)
+	{
+		String chIdx = channelsNode->getStringAttribute("CH" + String(i), "");
+
+		if (chIdx == "")
+		{
+			LOGE("Channel #" + String(i) + " not found. Channel map will not be updated.");
+			return;
+		}
+
+		selectedChannels.emplace_back(std::stoi(chIdx.toStdString()));
+	}
+
+	std::sort(selectedChannels.begin(), selectedChannels.end());
+	auto last = std::unique(selectedChannels.begin(), selectedChannels.end());
+	selectedChannels.erase(last, selectedChannels.end());
+
+	if (selectedChannels.size() != npx->numberOfChannels)
+	{
+		LOGE("Invalid channel map. Wrong number of channels found. Channel map was not updated");
+		return;
+	}
+
+	selectElectrodes(selectedChannels);
+
+	updateSettings();
 }
diff --git a/Source/UI/NeuropixelsV2eProbeInterface.h b/Source/UI/NeuropixelsV2eProbeInterface.h
index 3cbf0da..13aef8a 100644
--- a/Source/UI/NeuropixelsV2eProbeInterface.h
+++ b/Source/UI/NeuropixelsV2eProbeInterface.h
@@ -44,36 +44,32 @@ class NeuropixelsV2eProbeInterface : public SettingsInterface,
 {
 public:
 	friend class ProbeBrowser<Neuropixels2e::numberOfChannels, Neuropixels2e::numberOfElectrodes>;
+	friend class NeuropixelsV2eInterface;
 
-	/** Constructor */
 	NeuropixelsV2eProbeInterface(std::shared_ptr<Neuropixels2e> d, int ind, OnixSourceEditor* e, OnixSourceCanvas* c);
 
-	/** Listener methods*/
 	void buttonClicked(Button*) override;
 	void comboBoxChanged(ComboBox*) override;
 
-	/** Disables buttons and starts animation if necessary */
 	void startAcquisition() override;
 
-	/** Enables buttons and start animation if necessary */
 	void stopAcquisition() override;
 
-	/** Settings-related functions*/
 	bool applyProbeSettings(ProbeSettings<Neuropixels2e::numberOfChannels, Neuropixels2e::numberOfElectrodes>* p, bool shouldUpdateProbe = true);
 
-	/** Save parameters to XML */
 	void saveParameters(XmlElement* xml) override;
 
-	/** Load parameters from XML */
 	void loadParameters(XmlElement* xml) override;
 
-	/** Updates the info string on the right-hand side of the component */
 	void updateInfoString() override;
 
-	/** Set parameters */
+	void updateSettings() override;
+
 	void setReference(int index);
 	void selectElectrodes(std::vector<int> electrodes);
 
+	String getReferenceText() override { return referenceComboBox->getText(); }
+
 private:
 	XmlElement neuropix_info;
 
@@ -81,37 +77,30 @@ class NeuropixelsV2eProbeInterface : public SettingsInterface,
 
 	const int probeIndex;
 
-	// Combo box - probe-specific settings
 	std::unique_ptr<ComboBox> electrodeConfigurationComboBox;
 	std::unique_ptr<ComboBox> referenceComboBox;
-	std::unique_ptr<ComboBox> activityViewComboBox;
 
-	// LABELS
 	std::unique_ptr<Label> deviceLabel;
 	std::unique_ptr<Label> infoLabel;
 	std::unique_ptr<Label> electrodesLabel;
 	std::unique_ptr<Label> electrodePresetLabel;
 	std::unique_ptr<Label> referenceLabel;
-	std::unique_ptr<Label> activityViewLabel;
 
 	std::unique_ptr<Label> gainCorrectionFileLabel;
+	std::unique_ptr<UtilityButton> gainCorrectionFileButton;
+	std::unique_ptr<FileChooser> gainCorrectionFileChooser;
+	std::unique_ptr<TextEditor> gainCorrectionFile;
 
-	// BUTTONS
 	std::unique_ptr<UtilityButton> enableButton;
 
 	std::unique_ptr<UtilityButton> enableViewButton;
 	std::unique_ptr<UtilityButton> referenceViewButton;
-	std::unique_ptr<UtilityButton> activityViewButton;
 
 	std::unique_ptr<DrawableRectangle> probeInterfaceRectangle;
 	std::unique_ptr<Label> probeInterfaceLabel;
 	std::unique_ptr<UtilityButton> loadJsonButton;
 	std::unique_ptr<UtilityButton> saveJsonButton;
 
-	std::unique_ptr<UtilityButton> gainCorrectionFileButton;
-	std::unique_ptr<FileChooser> gainCorrectionFileChooser;
-	std::unique_ptr<TextEditor> gainCorrectionFile;
-
 	std::unique_ptr<ProbeBrowser<Neuropixels2e::numberOfChannels, Neuropixels2e::numberOfElectrodes>> probeBrowser;
 
 	std::unique_ptr<Component> enableViewComponent;
@@ -130,10 +119,11 @@ class NeuropixelsV2eProbeInterface : public SettingsInterface,
 
 	std::vector<int> getSelectedElectrodes();
 
-	void setInterfaceEnabledState(bool enabledState);
+	void setInterfaceEnabledState(bool enabledState) override;
 
-	/** Checks if the current channel map matches an existing channel preset, and updates the combo box if it does */
 	void checkForExistingChannelPreset();
 
+	int getIndexOfComboBoxItem(ComboBox* cb, String item);
+
 	JUCE_LEAK_DETECTOR(NeuropixelsV2eProbeInterface);
 };
diff --git a/Source/UI/OutputClockInterface.cpp b/Source/UI/OutputClockInterface.cpp
index e30c8dc..0a07da7 100644
--- a/Source/UI/OutputClockInterface.cpp
+++ b/Source/UI/OutputClockInterface.cpp
@@ -22,7 +22,7 @@
 
 #include "OutputClockInterface.h"
 
-OutputClockInterface::OutputClockInterface(std::shared_ptr<OutputClock> d, OnixSourceEditor* e, OnixSourceCanvas* c) : 
+OutputClockInterface::OutputClockInterface(std::shared_ptr<OutputClock> d, OnixSourceEditor* e, OnixSourceCanvas* c) :
 	SettingsInterface(d, e, c)
 {
 	if (device != nullptr)
@@ -31,7 +31,7 @@ OutputClockInterface::OutputClockInterface(std::shared_ptr<OutputClock> d, OnixS
 		frequencyHzLabel->setBounds(50, 40, 130, 20);
 		addAndMakeVisible(frequencyHzLabel.get());
 
-		frequencyHzValue = std::make_unique<Label>("frequencyHzValue", String(std::static_pointer_cast<OutputClock>(device)->getFrequencyHz()));
+		frequencyHzValue = std::make_unique<Label>("frequencyHzValue", String(1e6));
 		frequencyHzValue->setEditable(true);
 		frequencyHzValue->setBounds(frequencyHzLabel->getRight() + 3, frequencyHzLabel->getY(), 50, 20);
 		frequencyHzValue->setTooltip("Sets the output clock frequency in Hz. Must be between 0.1 Hz and 10 MHz.");
@@ -44,7 +44,7 @@ OutputClockInterface::OutputClockInterface(std::shared_ptr<OutputClock> d, OnixS
 		dutyCycleLabel->setBounds(frequencyHzLabel->getX(), frequencyHzLabel->getBottom() + 10, 130, 20);
 		addAndMakeVisible(dutyCycleLabel.get());
 
-		dutyCycleValue = std::make_unique<Label>("dutyCycleValue", String(std::static_pointer_cast<OutputClock>(device)->getDutyCycle()));
+		dutyCycleValue = std::make_unique<Label>("dutyCycleValue", "50");
 		dutyCycleValue->setEditable(true);
 		dutyCycleValue->setBounds(dutyCycleLabel->getRight() + 3, dutyCycleLabel->getY(), 50, 20);
 		dutyCycleValue->setTooltip("Sets the output clock duty cycle in percent. Values must be between 10 and 90.");
@@ -57,7 +57,7 @@ OutputClockInterface::OutputClockInterface(std::shared_ptr<OutputClock> d, OnixS
 		delayLabel->setBounds(dutyCycleLabel->getX(), dutyCycleLabel->getBottom() + 10, 130, 20);
 		addAndMakeVisible(delayLabel.get());
 
-		delayValue = std::make_unique<Label>("delayValue", String(std::static_pointer_cast<OutputClock>(device)->getDelay()));
+		delayValue = std::make_unique<Label>("delayValue", "0");
 		delayValue->setEditable(true);
 		delayValue->setBounds(delayLabel->getRight() + 3, delayLabel->getY(), 50, 20);
 		delayValue->setTooltip("Sets the delay after acquisition commences before the clock becomes active, in seconds. Values must be between 0 and 3600 seconds.");
@@ -70,67 +70,134 @@ OutputClockInterface::OutputClockInterface(std::shared_ptr<OutputClock> d, OnixS
 		gateRunButton->setBounds(delayLabel->getX(), delayLabel->getBottom() + 5, 250, 22);
 		gateRunButton->setClickingTogglesState(true);
 		gateRunButton->setToggleState(std::static_pointer_cast<OutputClock>(device)->getGateRun(), dontSendNotification);
-		gateRunButton->setTooltip("Toggles the output clock gate. If checked, the clock output will follow the acquisition status." + 
+		gateRunButton->setTooltip("Toggles the output clock gate. If checked, the clock output will follow the acquisition status." +
 			String(" If unchecked, the clock output will run continuously."));
 		gateRunButton->addListener(this);
 		addAndMakeVisible(gateRunButton.get());
+
+		updateSettings();
 	}
 
 	type = Type::OUTPUTCLOCK_SETTINGS_INTERFACE;
 }
 
+void OutputClockInterface::setInterfaceEnabledState(bool newState)
+{
+	if (frequencyHzValue != nullptr)
+		frequencyHzValue->setEnabled(newState);
+
+	if (dutyCycleValue != nullptr)
+		dutyCycleValue->setEnabled(newState);
+
+	if (delayValue != nullptr)
+		delayValue->setEnabled(newState);
+
+	if (gateRunButton != nullptr)
+		gateRunButton->setEnabled(newState);
+}
+
+void OutputClockInterface::updateSettings()
+{
+	if (device == nullptr) return;
+
+	auto outputClock = std::static_pointer_cast<OutputClock>(device);
+
+	frequencyHzValue->setText(String(outputClock->getFrequencyHz()), dontSendNotification);
+	dutyCycleValue->setText(String(outputClock->getDutyCycle()), dontSendNotification);
+	delayValue->setText(String(outputClock->getDelay()), dontSendNotification);
+	gateRunButton->setToggleState(outputClock->getGateRun(), dontSendNotification);
+}
+
 void OutputClockInterface::buttonClicked(Button* b)
 {
+	auto outputClock = std::static_pointer_cast<OutputClock>(device);
+
 	if (b == gateRunButton.get())
 	{
-		auto clockOutput = std::static_pointer_cast<OutputClock>(device);
-
-		clockOutput->setGateRun(gateRunButton->getToggleState(), editor->acquisitionIsActive);
+		outputClock->setGateRun(gateRunButton->getToggleState(), editor->acquisitionIsActive);
 	}
 }
 
 void OutputClockInterface::labelTextChanged(Label* l)
 {
+	auto outputClock = std::static_pointer_cast<OutputClock>(device);
+
 	if (l == frequencyHzValue.get())
 	{
-		auto d = std::static_pointer_cast<OutputClock>(device);
-
 		auto rate = l->getText().getFloatValue();
 
 		if (rate < MinFrequencyHz || rate > MaxFrequencyHz)
 		{
-			l->setText(String(d->getFrequencyHz()), dontSendNotification);
+			l->setText(String(outputClock->getFrequencyHz()), dontSendNotification);
 			return;
 		}
 
-		d->setFrequencyHz(rate);
+		outputClock->setFrequencyHz(rate);
 	}
 	else if (l == dutyCycleValue.get())
 	{
-		auto d = std::static_pointer_cast<OutputClock>(device);
-
 		uint32_t rate = l->getText().getIntValue();
 
 		if (rate < MinDutyCyclePercent || rate > MaxDutyCyclePercent)
 		{
-			l->setText(String(d->getDutyCycle()), dontSendNotification);
+			l->setText(String(outputClock->getDutyCycle()), dontSendNotification);
 			return;
 		}
 
-		d->setDutyCycle(rate);
+		outputClock->setDutyCycle(rate);
 	}
 	else if (l == delayValue.get())
 	{
-		auto d = std::static_pointer_cast<OutputClock>(device);
-
 		uint32_t rate = l->getText().getIntValue();
 
 		if (rate < MinDelaySeconds || rate > MaxDelaySeconds)
 		{
-			l->setText(String(d->getDelay()), dontSendNotification);
+			l->setText(String(outputClock->getDelay()), dontSendNotification);
 			return;
 		}
 
-		d->setDelay(rate);
+		outputClock->setDelay(rate);
 	}
 }
+
+void OutputClockInterface::saveParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	auto outputClock = std::static_pointer_cast<OutputClock>(device);
+
+	LOGD("Saving Output Clock settings.");
+
+	XmlElement* xmlNode = xml->createNewChildElement("OUTPUTCLOCK");
+
+	xmlNode->setAttribute("frequencyHz", outputClock->getFrequencyHz());
+	xmlNode->setAttribute("dutyCycle", outputClock->getDutyCycle());
+	xmlNode->setAttribute("delay", outputClock->getDelay());
+	xmlNode->setAttribute("gateRun", outputClock->getGateRun());
+}
+
+void OutputClockInterface::loadParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Loading OutputClock settings.");
+
+	auto outputClock = std::static_pointer_cast<OutputClock>(device);
+
+	auto xmlNode = xml->getChildByName("OUTPUTCLOCK");
+
+	if (xmlNode == nullptr)
+	{
+		LOGE("No OUTPUTCLOCK element found.");
+		return;
+	}
+
+	outputClock->setEnabled(true);
+
+	outputClock->setFrequencyHz(xmlNode->getDoubleAttribute("frequencyHz"));
+	outputClock->setDutyCycle(xmlNode->getIntAttribute("dutyCycle"));
+	outputClock->setDelay(xmlNode->getIntAttribute("delay"));
+	outputClock->setGateRun(xmlNode->getIntAttribute("gateRun"));
+
+	updateSettings();
+}
diff --git a/Source/UI/OutputClockInterface.h b/Source/UI/OutputClockInterface.h
index 089f47e..03c2dfd 100644
--- a/Source/UI/OutputClockInterface.h
+++ b/Source/UI/OutputClockInterface.h
@@ -37,27 +37,21 @@ class OutputClockInterface : public SettingsInterface,
 
 	OutputClockInterface(std::shared_ptr<OutputClock> d, OnixSourceEditor* e, OnixSourceCanvas* c);
 
-	/** Disables buttons and starts animation if necessary */
-	void startAcquisition() override {};
+	void saveParameters(XmlElement* xml) override;
 
-	/** Enables buttons and start animation if necessary */
-	void stopAcquisition() override {};
+	void loadParameters(XmlElement* xml) override;
 
-	/** Save parameters to XML */
-	void saveParameters(XmlElement* xml) override {};
-
-	/** Load parameters from XML */
-	void loadParameters(XmlElement* xml) override {};
-
-	/** Updates the info string on the right-hand side of the component */
 	void updateInfoString() override {};
 
-	/** Listener methods*/
+	void updateSettings() override;
+
 	void buttonClicked(Button*) override;
 	void labelTextChanged(Label* l) override;
 
 private:
 
+	void setInterfaceEnabledState(bool newState) override;
+
 	std::unique_ptr<Label> frequencyHzLabel;
 	std::unique_ptr<Label> frequencyHzValue;
 
diff --git a/Source/UI/PolledBno055Interface.cpp b/Source/UI/PolledBno055Interface.cpp
index 725c001..f600bab 100644
--- a/Source/UI/PolledBno055Interface.cpp
+++ b/Source/UI/PolledBno055Interface.cpp
@@ -67,3 +67,62 @@ void PolledBno055Interface::buttonClicked(Button* button)
 		CoreServices::updateSignalChain(editor);
 	}
 }
+
+void PolledBno055Interface::updateSettings()
+{
+	if (device == nullptr) return;
+
+	deviceEnableButton->setToggleState(device->isEnabled(), sendNotification);
+}
+
+void PolledBno055Interface::setInterfaceEnabledState(bool newState)
+{
+	if (deviceEnableButton != nullptr)
+		deviceEnableButton->setEnabled(newState);
+}
+
+void PolledBno055Interface::saveParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Saving PolledBno055 settings.");
+
+	XmlElement* xmlNode = xml->createNewChildElement("POLLEDBNO055");
+
+	xmlNode->setAttribute("name", device->getName());
+	xmlNode->setAttribute("idx", (int)device->getDeviceIdx());
+
+	xmlNode->setAttribute("isEnabled", device->isEnabled());
+}
+
+void PolledBno055Interface::loadParameters(XmlElement* xml)
+{
+	if (device == nullptr) return;
+
+	LOGD("Loading PolledBno055 settings.");
+
+	XmlElement* xmlNode = nullptr;
+
+	for (auto* node : xml->getChildIterator())
+	{
+		if (node->hasTagName("POLLEDBNO055"))
+		{
+			if (node->getStringAttribute("name") == device->getName() &&
+				node->getIntAttribute("idx") == device->getDeviceIdx())
+			{
+				xmlNode = node;
+				break;
+			}
+		}
+	}
+
+	if (xmlNode == nullptr)
+	{
+		LOGD("No PolledBno055 element found.");
+		return;
+	}
+
+	device->setEnabled(xmlNode->getBoolAttribute("isEnabled"));
+
+	updateSettings();
+}
diff --git a/Source/UI/PolledBno055Interface.h b/Source/UI/PolledBno055Interface.h
index a8701d2..037f8c6 100644
--- a/Source/UI/PolledBno055Interface.h
+++ b/Source/UI/PolledBno055Interface.h
@@ -33,27 +33,20 @@ class PolledBno055Interface : public SettingsInterface,
 	public Button::Listener
 {
 public:
-	/** Constructor */
 	PolledBno055Interface(std::shared_ptr<PolledBno055> d, OnixSourceEditor* e, OnixSourceCanvas* c);
 
-	/** Disables buttons and starts animation if necessary */
-	void startAcquisition() override {};
+	void saveParameters(XmlElement* xml) override;
 
-	/** Enables buttons and start animation if necessary */
-	void stopAcquisition() override {};
+	void loadParameters(XmlElement* xml) override;
 
-	/** Save parameters to XML */
-	void saveParameters(XmlElement* xml) override {};
-
-	/** Load parameters from XML */
-	void loadParameters(XmlElement* xml) override {};
-
-	/** Updates the info string on the right-hand side of the component */
 	void updateInfoString() override {};
 
-	/** Listener methods*/
 	void buttonClicked(Button*) override;
 
+	void updateSettings() override;
+
+	void setInterfaceEnabledState(bool newState) override;
+
 private:
 
 	std::unique_ptr<UtilityButton> deviceEnableButton;
diff --git a/Source/UI/ProbeBrowser.h b/Source/UI/ProbeBrowser.h
index 1df7979..76bf67d 100644
--- a/Source/UI/ProbeBrowser.h
+++ b/Source/UI/ProbeBrowser.h
@@ -566,7 +566,7 @@ class ProbeBrowser : public Component,
 		if (newHeight >= minZoomHeight && newHeight <= maxZoomHeight)
 		{
 			zoomHeight = newHeight;
-			zoomOffset = 0;
+			zoomOffset = newOffset;
 		}
 	}
 
diff --git a/Source/UI/SettingsInterface.h b/Source/UI/SettingsInterface.h
index c42d2a8..29cbc66 100644
--- a/Source/UI/SettingsInterface.h
+++ b/Source/UI/SettingsInterface.h
@@ -69,10 +69,10 @@ class SettingsInterface : public Component
     }
 
     /** Called when acquisition begins */
-    virtual void startAcquisition() = 0;
+    virtual void startAcquisition() { setInterfaceEnabledState(false); }
 
     /** Called when acquisition ends */
-    virtual void stopAcquisition() = 0;
+    virtual void stopAcquisition() { setInterfaceEnabledState(true); }
 
     /** Saves settings */
     virtual void saveParameters (XmlElement* xml) = 0;
@@ -83,19 +83,32 @@ class SettingsInterface : public Component
     /** Updates the string with info about the underlying data source*/
     virtual void updateInfoString() = 0;
 
+    /** Updates the UI elements based on the current device settings */
+    virtual void updateSettings() = 0;
+
+    std::shared_ptr<OnixDevice> getDevice() { return device; }
+
+    void setDevice(std::shared_ptr<OnixDevice> dev) { device.reset(); device = dev; }
+
+    VisualizationMode getMode() const { return mode; }
+
     virtual String getReferenceText() { return ""; }
 
-    /** Default type */
-    Type type = Type::UNKNOWN_SETTINGS_INTERFACE;
+protected:
 
     /** Pointer to the data source*/
     std::shared_ptr<OnixDevice> device = nullptr;
 
-    VisualizationMode getMode() const { return mode; }
+    Type type = Type::UNKNOWN_SETTINGS_INTERFACE;
 
-protected:
     OnixSourceEditor* editor;
     OnixSourceCanvas* canvas;
 
     VisualizationMode mode = VisualizationMode::ENABLE_VIEW;
+
+private:
+
+    /** Enables or disables all UI elements that should not be changed during acquisition */
+    virtual void setInterfaceEnabledState(bool newState) = 0;
+
 };