Check Port Status during acquisition

Source/Devices/Bno055.cpp

@@ -93,11 +93,9 @@ Bno055::~Bno055()
 
 int Bno055::configureDevice()
 {
-	int result = oni_write_reg(ctx, deviceIdx, (uint32_t)Bno055Registers::ENABLE, isEnabled() ? (oni_reg_val_t)1 : (oni_reg_val_t)0);
+	ONI_OK_RETURN_INT(oni_write_reg(ctx, deviceIdx, (uint32_t)Bno055Registers::ENABLE, isEnabled() ? (oni_reg_val_t)1 : (oni_reg_val_t)0));
 
-	if (result != ONI_ESUCCESS) LOGE(oni_error_str(result));
-
-	return result;
+	return 0;
 }
 
 int Bno055::updateSettings()

Source/Devices/DeviceList.h

@@ -3,3 +3,4 @@
 #include "HeadStageEEPROM.h"
 #include "Neuropixels_1.h"
 #include "Neuropixels2e.h"
+#include "PortController.h"

Source/Devices/Neuropixels_1.cpp

@@ -36,7 +36,10 @@ BackgroundUpdaterWithProgressWindow::~BackgroundUpdaterWithProgressWindow()
 
 int BackgroundUpdaterWithProgressWindow::updateSettings()
 {
-	runThread();
+	if (device->isEnabled())
+		runThread();
+	else
+		return 0;
 
 	return result;
 }

Source/Devices/PortController.cpp

@@ -0,0 +1,171 @@
+/*
+	------------------------------------------------------------------
+
+	This file is part of the Open Ephys GUI
+	Copyright (C) 2023 Allen Institute for Brain Science and Open Ephys
+
+	------------------------------------------------------------------
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "PortController.h"
+
+PortController::PortController(PortName port_, oni_ctx ctx_) :
+	OnixDevice(getPortNameString(port_), OnixDeviceType::PORT_CONTROL, (oni_dev_idx_t)port_, ctx_),
+	port(port_)
+{
+}
+
+PortController::~PortController()
+{
+}
+
+int PortController::configureDevice()
+{
+	ONI_OK_RETURN_INT(oni_write_reg(ctx, deviceIdx, (uint32_t)PortControllerRegister::ENABLE, (uint32_t)1))
+
+	return 0;
+}
+
+void PortController::startAcquisition()
+{
+	errorFlag = false;
+}
+
+void PortController::stopAcquisition()
+{
+	while (!frameArray.isEmpty())
+	{
+		const GenericScopedLock<CriticalSection> frameLock(frameArray.getLock());
+		oni_destroy_frame(frameArray.removeAndReturn(0));
+	}
+}
+
+void PortController::addFrame(oni_frame_t* frame)
+{
+	const GenericScopedLock<CriticalSection> frameLock(frameArray.getLock());
+	frameArray.add(frame);
+}
+
+void PortController::processFrames()
+{
+	while (!frameArray.isEmpty())
+	{
+		const GenericScopedLock<CriticalSection> frameLock(frameArray.getLock());
+		oni_frame_t* frame = frameArray.removeAndReturn(0);
+
+		int8_t* dataPtr = (int8_t*)frame->data;
+
+		int dataOffset = 8;
+
+		uint32_t code = (uint32_t) *(dataPtr + dataOffset);
+		uint32_t data = (uint32_t) *(dataPtr + dataOffset + 1);
+
+		errorFlag = errorFlag || ((uint32_t)data & LINKSTATE_SL) == 0;
+
+		oni_destroy_frame(frame);
+
+		LOGE("Port status changed for " + getName() + ".");
+	}
+}
+
+void PortController::updateDiscoveryParameters(DiscoveryParameters parameters)
+{
+	discoveryParameters = parameters;
+}
+
+DiscoveryParameters PortController::getHeadstageDiscoveryParameters(String headstage)
+{
+	if (headstage == "Neuropixels 1.0f")
+	{
+		return DiscoveryParameters(5.0f, 7.0f, 1.0f, 0.2f);
+	}
+
+	return DiscoveryParameters();
+}
+
+bool PortController::configureVoltage(float voltage)
+{
+	if (ctx == NULL) return false;
+
+	if (voltage == defaultVoltage)
+	{
+		if (discoveryParameters == DiscoveryParameters()) return false;
+
+		for (voltage = discoveryParameters.minVoltage; voltage <= discoveryParameters.maxVoltage; voltage += discoveryParameters.voltageIncrement)
+		{
+			setVoltage(voltage);
+
+			if (checkLinkState())
+			{
+				setVoltage(voltage + discoveryParameters.voltageOffset);
+				return checkLinkState();
+			}
+		}
+	}
+	else
+	{
+		setVoltage(voltage);
+
+		return checkLinkState();
+	}
+
+	return false;
+}
+
+void PortController::setVoltageOverride(float voltage, bool waitToSettle)
+{
+	if (ctx == NULL) return;
+
+	ONI_OK(oni_write_reg(ctx, (oni_dev_idx_t)port, (oni_reg_addr_t)PortControllerRegister::PORTVOLTAGE, (oni_reg_val_t)(voltage * 10)));
+	if (waitToSettle) sleep_for(std::chrono::milliseconds(500));
+}
+
+void PortController::setVoltage(float voltage)
+{
+	if (ctx == NULL) return;
+
+	ONI_OK(oni_write_reg(ctx, (oni_dev_idx_t)port, (oni_reg_addr_t)PortControllerRegister::PORTVOLTAGE, 0));
+	sleep_for(std::chrono::milliseconds(300));
+
+	ONI_OK(oni_write_reg(ctx, (oni_dev_idx_t)port, (oni_reg_addr_t)PortControllerRegister::PORTVOLTAGE, (oni_reg_val_t)(voltage * 10)));
+	sleep_for(std::chrono::milliseconds(500));
+}
+
+bool PortController::checkLinkState() const
+{
+	if (ctx == NULL) return false;
+
+	oni_reg_val_t linkState;
+	int result = oni_read_reg(ctx, (oni_dev_idx_t)port, (oni_reg_addr_t)PortControllerRegister::LINKSTATE, &linkState);
+
+	if (result != 0) { LOGE(oni_error_str(result)); return false; }
+	else if ((linkState & LINKSTATE_SL) == 0) { LOGE("Unable to acquire communication lock."); return false; }
+	else return true;
+}
+
+String PortController::getPortNameString(PortName portName)
+{
+	switch (portName)
+	{
+	case PortName::PortA:
+		return "Port A";
+	case PortName::PortB:
+		return "Port B";
+	default:
+		break;
+	}
+}

Source/Devices/PortController.h

@@ -0,0 +1,137 @@
+/*
+	------------------------------------------------------------------
+
+	This file is part of the Open Ephys GUI
+	Copyright (C) 2023 Allen Institute for Brain Science and Open Ephys
+
+	------------------------------------------------------------------
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef __PORTCONTROLLER_H__
+#define __PORTCONTROLLER_H__
+
+#include <thread>
+#include <chrono>
+
+#include "oni.h"
+#include "../OnixDevice.h"
+
+using namespace std::this_thread;
+
+enum class PortControllerRegister : uint32_t
+{
+	ENABLE = 0,
+	GPOSTATE = 1,
+	DESPWR = 2,
+	PORTVOLTAGE = 3,
+	SAVEVOLTAGE = 4,
+	LINKSTATE = 5
+};
+
+enum class PortStatusCode : uint32_t
+{
+	SerdesLock = 0x0001,
+	SerdesParityPass = 0x0002,
+	CrcError = 0x0100,
+	TooManyDevices = 0x0200,
+	InitializationError = 0x0400,
+	BadPacketFormat = 0x0800,
+	InitializationCrcError = 0x1000,
+};
+
+class DiscoveryParameters
+{
+public:
+	float minVoltage = 0.0f;
+	float maxVoltage = 0.0f;
+	float voltageOffset = 0.0f;
+	float voltageIncrement = 0.0f;
+
+	DiscoveryParameters() {};
+
+	DiscoveryParameters(float minVoltage_, float maxVoltage_, float voltageOffset_, float voltageIncrement_)
+	{
+		minVoltage = minVoltage_;
+		maxVoltage = maxVoltage_;
+		voltageOffset = voltageOffset_;
+		voltageIncrement = voltageIncrement_;
+	}
+
+	~DiscoveryParameters() {};
+
+	bool operator==(const DiscoveryParameters& rhs) const
+	{
+		return rhs.minVoltage == minVoltage && rhs.maxVoltage == maxVoltage && rhs.voltageOffset == voltageOffset && rhs.voltageIncrement == voltageIncrement;
+	}
+};
+
+class PortController : public OnixDevice
+{
+public:
+	PortController(PortName port_, const oni_ctx ctx_);
+
+	~PortController();
+
+	int configureDevice() override;
+
+	int updateSettings() override { return 0; }
+
+	void startAcquisition() override;
+
+	void stopAcquisition() override;
+
+	void addFrame(oni_frame_t*) override;
+
+	void processFrames() override;
+
+	void addSourceBuffers(OwnedArray<DataBuffer>& sourceBuffers) override {};
+
+	void updateDiscoveryParameters(DiscoveryParameters parameters);
+
+	bool configureVoltage(float voltage = defaultVoltage);
+
+	/** Sets the voltage to the given value, after setting the voltage to zero */
+	void setVoltage(float voltage);
+
+	/** Overrides the voltage setting and directly sets it to the given voltage */
+	void setVoltageOverride(float voltage, bool waitToSettle = true);
+
+	bool checkLinkState() const;
+
+	String getPortNameString(PortName portName);
+
+	static DiscoveryParameters getHeadstageDiscoveryParameters(String headstage);
+
+	/** Check if the port status changed and there is an error reported */
+	bool getErrorFlag() { return errorFlag; }
+
+private:
+	Array<oni_frame_t*, CriticalSection, 10> frameArray;
+
+	const PortName port;
+
+	static constexpr float defaultVoltage = -1.0f;
+
+	const uint32_t LINKSTATE_PP = 0x2; // parity check pass bit
+	const uint32_t LINKSTATE_SL = 0x1; // SERDES lock bit
+
+	DiscoveryParameters discoveryParameters;
+
+	std::atomic<bool> errorFlag = false;
+};
+
+#endif // !__PORTCONTROLLER_H__

Source/FrameReader.cpp

@@ -23,7 +23,7 @@
 
 #include "FrameReader.h"
 
-FrameReader::FrameReader(OwnedArray<OnixDevice>& sources_, oni_ctx ctx_)
+FrameReader::FrameReader(Array<OnixDevice*> sources_, oni_ctx ctx_)
 	: Thread("FrameReader"),
 	sources(sources_),
 	ctx(ctx_)
@@ -62,6 +62,7 @@ void FrameReader::run()
 			{
 				source->addFrame(frame);
 				destroyFrame = false;
+				break;
 			}
 		}
 

Source/FrameReader.h

@@ -32,15 +32,15 @@
 class FrameReader : public Thread
 {
 public:
-	FrameReader(OwnedArray<OnixDevice>& sources_, oni_ctx ctx_);
+	FrameReader(Array<OnixDevice*> sources_, oni_ctx ctx_);
 
 	~FrameReader();
 
 	void run() override;
 
 private:
 
-	OwnedArray<OnixDevice>& sources;
+	Array<OnixDevice*> sources;
 	oni_ctx ctx;
 };
 

Source/OnixDevice.h

@@ -39,7 +39,7 @@
 
 #define ONI_OK(exp) {int res = exp; if (res != ONI_ESUCCESS){LOGD(oni_error_str(res));}}
 #define ONI_OK_RETURN_BOOL(exp) {int res = exp; if (res != ONI_ESUCCESS){LOGD(oni_error_str(res));return false;}}
-#define ONI_OK_RETURN_INT(exp, val) {int res = exp; if (res != ONI_ESUCCESS){LOGD(oni_error_str(res));return val;}}
+#define ONI_OK_RETURN_INT(exp) {int res = exp; if (res != ONI_ESUCCESS){LOGD(oni_error_str(res));return res;}}
 
 using namespace std::chrono;
 
@@ -54,7 +54,8 @@ enum class OnixDeviceType {
 	BNO,
 	NEUROPIXELS_1,
 	NEUROPIXELS_2,
-	ADC
+	ADC,
+	PORT_CONTROL
 };
 
 struct StreamInfo {