Update stream/channel identifiers

Source/Devices/AnalogIO.cpp

@@ -28,20 +28,21 @@ AnalogIO::AnalogIO(String name, const oni_dev_idx_t deviceIdx_, std::shared_ptr<
 	StreamInfo analogInputStream = StreamInfo(
 		OnixDevice::createStreamName({ getHeadstageName(), name, "AnalogInput" }),
 		"Analog Input data",
-		"onix-analogio.data.input",
-		12,
+		getStreamIdentifier(),
+		getNumChannels(),
 		std::floor(AnalogIOFrequencyHz / framesToAverage),
 		"AnalogInput",
 		ContinuousChannel::Type::ADC,
-		20.0f / numberOfDivisions, // NB: +/- 10 Volts
+		getVoltsPerDivision(AnalogIOVoltageRange::TenVolts), // NB: +/- 10 Volts
 		"V",
-		{});
+		{},
+		{ "input" });
 	streamInfos.add(analogInputStream);
 
 	for (int i = 0; i < numFrames; i++)
 		eventCodes[i] = 0;
 
-	for (int i = 0; i < numChannels; i += 1)
+	for (int i = 0; i < numChannels; i++)
 	{
 		channelDirection[i] = AnalogIODirection::Input;
 		channelVoltageRange[i] = AnalogIOVoltageRange::TenVolts;
@@ -61,23 +62,23 @@ bool AnalogIO::updateSettings()
 {
 	int rc = 0;
 
-	for (int i = 0; i < numChannels; i += 1)
+	for (int i = 0; i < numChannels; i++)
 	{
-		rc = deviceContext->writeRegister(deviceIdx, (oni_reg_addr_t)AnalogIORegisters::CH00_IN_RANGE + i, (oni_reg_val_t)channelVoltageRange[i]); 
+		rc = deviceContext->writeRegister(deviceIdx, (oni_reg_addr_t)AnalogIORegisters::CH00_IN_RANGE + i, (oni_reg_val_t)channelVoltageRange[i]);
 		if (rc != ONI_ESUCCESS) return false;
 	}
 
 	uint32_t ioReg = 0;
 
-	for (int i = 0; i < numChannels; i += 1)
+	for (int i = 0; i < numChannels; i++)
 	{
 		ioReg = (ioReg & ~((uint32_t)1 << i)) | ((uint32_t)(channelDirection[i]) << i);
 	}
 
 	rc = deviceContext->writeRegister(deviceIdx, (oni_reg_addr_t)AnalogIORegisters::CHDIR, ioReg);
 	if (rc != ONI_ESUCCESS) return false;
 
-	for (int i = 0; i < numChannels; i += 1)
+	for (int i = 0; i < numChannels; i++)
 	{
 		voltsPerDivision[i] = getVoltsPerDivision(channelVoltageRange[i]);
 	}
@@ -146,19 +147,19 @@ void AnalogIO::processFrames()
 
 		int dataOffset = 4;
 
-		for (int i = 0; i < numChannels; i += 1)
+		for (int i = 0; i < numChannels; i++)
 		{
 			if (dataType == AnalogIODataType::S16)
 				analogInputSamples[currentFrame + i * numFrames] += *(dataPtr + dataOffset + i);
 			else
 				analogInputSamples[currentFrame + i * numFrames] += *(dataPtr + dataOffset + i) * voltsPerDivision[i];
 		}
 
-		currentAverageFrame += 1;
+		currentAverageFrame++;
 
 		if (currentAverageFrame >= framesToAverage)
 		{
-			for (int i = 0; i < numChannels; i += 1)
+			for (int i = 0; i < numChannels; i++)
 			{
 				analogInputSamples[currentFrame + i * numFrames] /= framesToAverage;
 			}

Source/Devices/Bno055.cpp

@@ -25,72 +25,86 @@
 Bno055::Bno055(String name, String headstageName, const oni_dev_idx_t deviceIdx_, std::shared_ptr<Onix1> ctx)
 	: OnixDevice(name, headstageName, OnixDeviceType::BNO, deviceIdx_, ctx)
 {
-	const float bitVolts = 1.0;
+	auto streamIdentifier = getStreamIdentifier();
 
 	String port = PortController::getPortName(PortController::getPortFromIndex(deviceIdx));
 	StreamInfo eulerAngleStream = StreamInfo(
 		OnixDevice::createStreamName({ port, getHeadstageName(), getName(), "Euler" }),
 		"Bosch Bno055 9-axis inertial measurement unit (IMU) Euler angle",
-		"onix-bno055.data.euler",
+		streamIdentifier,
 		3,
 		sampleRate,
-		"Euler",
+		"Eul",
 		ContinuousChannel::Type::AUX,
-		bitVolts,
+		eulerAngleScale,
 		"Degrees",
-		{ "Yaw", "Roll", "Pitch" });
+		{ "Y", "R", "P" },
+		"euler",
+		{ "y", "r", "p" }
+	);
 	streamInfos.add(eulerAngleStream);
 
 	StreamInfo quaternionStream = StreamInfo(
 		OnixDevice::createStreamName({ port, getHeadstageName(), getName(), "Quaternion" }),
 		"Bosch Bno055 9-axis inertial measurement unit (IMU) Quaternion",
-		"onix-bno055.data.quat",
+		streamIdentifier,
 		4,
 		sampleRate,
-		"Quaternion",
+		"Quat",
 		ContinuousChannel::Type::AUX,
-		bitVolts,
-		"u",
-		{ "W", "X", "Y", "Z" });
+		quaternionScale,
+		"u", // NB: Quaternion data is unitless by definition
+		{ "W", "X", "Y", "Z" },
+		"quaternion",
+		{ "w", "x", "y", "z" }
+	);
 	streamInfos.add(quaternionStream);
 
 	StreamInfo accelerationStream = StreamInfo(
 		OnixDevice::createStreamName({ port, getHeadstageName(), getName(), "Acceleration" }),
 		"Bosch Bno055 9-axis inertial measurement unit (IMU) Acceleration",
-		"onix-bno055.data.acc",
+		streamIdentifier,
 		3,
 		sampleRate,
-		"Acceleration",
+		"Acc",
 		ContinuousChannel::Type::AUX,
-		bitVolts,
-		"m / s ^ 2",
-		{ "X", "Y", "Z" });
+		accelerationScale,
+		"m/s^2",
+		{ "X", "Y", "Z" },
+		"acceleration",
+		{ "x","y","z" }
+	);
 	streamInfos.add(accelerationStream);
 
 	StreamInfo gravityStream = StreamInfo(
 		OnixDevice::createStreamName({ port, getHeadstageName(), getName(), "Gravity" }),
 		"Bosch Bno055 9-axis inertial measurement unit (IMU) Gravity",
-		"onix-bno055.data.grav",
+		streamIdentifier + ".gravity",
 		3,
 		sampleRate,
-		"Gravity",
+		"Grav",
 		ContinuousChannel::Type::AUX,
-		bitVolts,
+		accelerationScale,
 		"m/s^2",
-		{ "X", "Y", "Z" });
+		{ "X", "Y", "Z" },
+		"gravity",
+		{ "x", "y", "z" }
+	);
 	streamInfos.add(gravityStream);
 
 	StreamInfo temperatureStream = StreamInfo(
 		OnixDevice::createStreamName({ port, getHeadstageName(), getName(), "Temperature" }),
 		"Bosch Bno055 9-axis inertial measurement unit (IMU) Temperature",
-		"onix-bno055.data.temp",
+		streamIdentifier,
 		1,
 		sampleRate,
-		"Temperature",
+		"Temp",
 		ContinuousChannel::Type::AUX,
-		bitVolts,
+		1.0f,
 		"Celsius",
-		{ "" });
+		{ "" },
+		"temperature"
+	);
 	streamInfos.add(temperatureStream);
 
 	// TODO: Add calibration stream here?
@@ -162,31 +176,31 @@ void Bno055::processFrames()
 		{
 			bnoSamples[currentFrame + channelOffset * numFrames] = float(*(dataPtr + dataOffset)) * eulerAngleScale;
 			dataOffset++;
-			channelOffset += 1;
+			channelOffset++;
 		}
 
 		// Quaternion
 		for (int i = 0; i < 4; i++)
 		{
 			bnoSamples[currentFrame + channelOffset * numFrames] = float(*(dataPtr + dataOffset)) * quaternionScale;
 			dataOffset++;
-			channelOffset += 1;
+			channelOffset++;
 		}
 
 		// Acceleration
 		for (int i = 0; i < 3; i++)
 		{
 			bnoSamples[currentFrame + channelOffset * numFrames] = float(*(dataPtr + dataOffset)) * accelerationScale;
 			dataOffset++;
-			channelOffset += 1;
+			channelOffset++;
 		}
 
 		// Gravity
 		for (int i = 0; i < 3; i++)
 		{
 			bnoSamples[currentFrame + channelOffset * numFrames] = float(*(dataPtr + dataOffset)) * accelerationScale;
 			dataOffset++;
-			channelOffset += 1;
+			channelOffset++;
 		}
 
 		// Temperature

Source/Devices/DigitalIO.cpp

@@ -59,7 +59,7 @@ EventChannel::Settings DigitalIO::getEventChannelSettings()
 		EventChannel::Type::TTL,
 		OnixDevice::createStreamName({getHeadstageName(), getName(), "Events"}),
 		"Digital inputs and breakout button states coming from a DigitalIO device",
-		"onix-digitalio.events",
+		getStreamIdentifier() + ".event.digital",
 		nullptr,
 		numButtons + numDigitalInputs
 	};

Source/Devices/HarpSyncInput.cpp

@@ -30,14 +30,16 @@ HarpSyncInput::HarpSyncInput(String name, const oni_dev_idx_t deviceIdx_, std::s
 	StreamInfo harpTimeStream = StreamInfo(
 		OnixDevice::createStreamName({ getHeadstageName(), getName(), "HarpTime" }),
 		"Harp clock time corresponding to the local acquisition ONIX clock count",
-		"onix-harpsyncinput.data.harptime",
+		getStreamIdentifier(),
 		1,
 		1,
 		"HarpTime",
 		ContinuousChannel::Type::AUX,
 		1.0f,
 		"s",
-		{""});
+		{ "" },
+		"harptime"
+	);
 	streamInfos.add(harpTimeStream);
 
 	for (int i = 0; i < numFrames; i++)

Source/Devices/MemoryMonitor.cpp

@@ -61,14 +61,16 @@ MemoryMonitor::MemoryMonitor(String name, const oni_dev_idx_t deviceIdx_, std::s
 	StreamInfo percentUsedStream = StreamInfo(
 		OnixDevice::createStreamName({ getHeadstageName(), getName(), "PercentUsed" }),
 		"Percent of available memory that is currently used",
-		"onix - memorymonitor.data.percentused",
+		getStreamIdentifier(),
 		1,
 		samplesPerSecond,
 		"Percent",
 		ContinuousChannel::Type::AUX,
 		1.0f,
 		"%",
-		{ "" });
+		{ "" },
+		"percent"
+	);
 	streamInfos.add(percentUsedStream);
 
 	for (int i = 0; i < numFrames; i++)

Source/Devices/Neuropixels2e.cpp

@@ -44,14 +44,16 @@ void Neuropixels2e::createDataStream(int n)
 	StreamInfo apStream = StreamInfo(
 		OnixDevice::createStreamName({ PortController::getPortName(PortController::getPortFromIndex(deviceIdx)), getHeadstageName(), "Probe" + String(n) }),
 		"Neuropixels 2.0 data stream",
-		"onix-neuropixels2.data",
+		getStreamIdentifier(),
 		numberOfChannels,
 		sampleRate,
 		"CH",
 		ContinuousChannel::Type::ELECTRODE,
 		0.195f,
 		CharPointer_UTF8("\xc2\xb5V"),
-		{});
+		{},
+		"ap"
+	);
 	streamInfos.add(apStream);
 }
 

Source/Devices/Neuropixels_1.cpp

@@ -174,30 +174,36 @@ Neuropixels_1::Neuropixels_1(String name, const oni_dev_idx_t deviceIdx_, std::s
 	INeuropixel(NeuropixelsV1fValues::numberOfSettings, NeuropixelsV1fValues::numberOfShanks)
 {
 	String port = PortController::getPortName(PortController::getPortFromIndex(deviceIdx));
+	auto streamIdentifier = getStreamIdentifier();
+
 	StreamInfo apStream = StreamInfo(
 		OnixDevice::createStreamName({ port, getHeadstageName(), getName(), "AP" }),
 		"Neuropixels 1.0 AP band data stream",
-		"onix-neuropixels1.data.ap",
+		streamIdentifier,
 		numberOfChannels,
 		apSampleRate,
 		"AP",
 		ContinuousChannel::Type::ELECTRODE,
 		0.195f,
 		CharPointer_UTF8("\xc2\xb5V"),
-		{});
+		{},
+		"ap"
+	);
 	streamInfos.add(apStream);
 
 	StreamInfo lfpStream = StreamInfo(
 		OnixDevice::createStreamName({ port, getHeadstageName(), getName(), "LFP" }),
 		"Neuropixels 1.0 LFP band data stream",
-		"onix-neuropixels1.data.lfp",
+		streamIdentifier,
 		numberOfChannels,
 		lfpSampleRate,
 		"LFP",
 		ContinuousChannel::Type::ELECTRODE,
 		0.195f,
 		CharPointer_UTF8("\xc2\xb5V"),
-		{});
+		{},
+		"lfp"
+	);
 	streamInfos.add(lfpStream);
 
 	defineMetadata(settings[0].get());