static byte[] CreateMessage(PhotometryDataFrame frame, HarpMessage message)
{
var counter = frame.FrameCounter;
return(new byte[]
{
(byte)MessageType.Event, // message type
18, // message length = 3 bytes header + 14 bytes payload + 1 byte checksum
Registers.Photometry, // header address
(byte)message.Port, // header port
(byte)PayloadType.TimestampedS64, // header payload type
message.MessageBytes[5], // timestamp byte 0
message.MessageBytes[6], // timestamp byte 1
message.MessageBytes[7], // timestamp byte 2
message.MessageBytes[8], // timestamp byte 3
message.MessageBytes[9], // timestamp byte 4
message.MessageBytes[10], // timestamp byte 5
(byte)(counter >> (8 * 0)), // frame counter byte 0
(byte)(counter >> (8 * 1)), // frame counter byte 1
(byte)(counter >> (8 * 2)), // frame counter byte 2
(byte)(counter >> (8 * 3)), // frame counter byte 3
(byte)(counter >> (8 * 4)), // frame counter byte 4
(byte)(counter >> (8 * 5)), // frame counter byte 5
(byte)(counter >> (8 * 6)), // frame counter byte 6
(byte)(counter >> (8 * 7)), // frame counter byte 7
0 // checksum, will be updated by constructor
});
}
static double ProcessTimestamp(HarpMessage input)
{
if (input.Error)
{
throw new InvalidOperationException("The Harp message is an error report.");
}
return(input.GetTimestamp());
}
internal PhotometryHarpMessage(PhotometryDataFrame frame, HarpMessage message)
: base(true, CreateMessage(frame, message))
{
var payload = message.GetTimestampedPayloadUInt16();
frame.Flags = (FrameFlags)payload.Value;
frame.Timestamp = payload.Seconds;
PhotometryData = frame;
TriggerData = message;
}
public void FromByte_TimestampedValue_PayloadHasValue()
{
byte value = 23;
var timestamp = GetTimestamp();
var message = HarpMessage.FromByte(DefaultAddress, timestamp, MessageType.Write, value);
AssertIsValid(message);
var(payload, actualTimestamp) = message.GetTimestampedPayloadByte();
AssertTimestamp(timestamp, actualTimestamp);
Assert.AreEqual(value, payload);
}
public void FromInt32_TimestampedValue_PayloadHasValue()
{
int value = -123456789;
var timestamp = GetTimestamp();
var message = HarpMessage.FromInt32(DefaultAddress, timestamp, MessageType.Write, value);
AssertIsValid(message);
var(payload, actualTimestamp) = message.GetTimestampedPayloadInt32();
AssertTimestamp(timestamp, actualTimestamp);
Assert.AreEqual(value, payload);
}
public void FromSingle_TimestampedValue_PayloadHasValue()
{
float value = (float)Math.E;
var timestamp = GetTimestamp();
var message = HarpMessage.FromSingle(DefaultAddress, timestamp, MessageType.Write, value);
AssertIsValid(message);
var(payload, actualTimestamp) = message.GetTimestampedPayloadSingle();
AssertTimestamp(timestamp, actualTimestamp);
Assert.AreEqual(value, payload);
}
public void FromInt64_TimestampedValue_PayloadHasValue()
{
long value = -int.MaxValue * 2u;
var timestamp = GetTimestamp();
var message = HarpMessage.FromInt64(DefaultAddress, timestamp, MessageType.Write, value);
AssertIsValid(message);
var(payload, actualTimestamp) = message.GetTimestampedPayloadInt64();
AssertTimestamp(timestamp, actualTimestamp);
Assert.AreEqual(value, payload);
}
public void FromUInt16_TimestampedValue_PayloadHasValue()
{
ushort value = 1024;
var timestamp = GetTimestamp();
var message = HarpMessage.FromUInt16(DefaultAddress, timestamp, MessageType.Write, value);
AssertIsValid(message);
var(payload, actualTimestamp) = message.GetTimestampedPayloadUInt16();
AssertTimestamp(timestamp, actualTimestamp);
Assert.AreEqual(value, payload);
}
public void FromInt16_TimestampedArray_PayloadHasValue()
{
var value = new short[] { 512, -2048 };
var timestamp = GetTimestamp();
var message = HarpMessage.FromInt16(DefaultAddress, timestamp, MessageType.Write, value);
AssertIsValid(message);
var(payload, actualTimestamp) = message.GetTimestampedPayloadArray <short>();
AssertTimestamp(timestamp, actualTimestamp);
AssertArrayEqual(value, payload);
Assert.AreEqual(value[1], message.GetTimestampedPayloadInt16(1).Value);
}
public void FromUInt32_TimestampedArray_PayloadHasValue()
{
var value = new uint[] { uint.MaxValue / 2, 123456789 };
var timestamp = GetTimestamp();
var message = HarpMessage.FromUInt32(DefaultAddress, timestamp, MessageType.Write, value);
AssertIsValid(message);
var(payload, actualTimestamp) = message.GetTimestampedPayloadArray <uint>();
AssertTimestamp(timestamp, actualTimestamp);
AssertArrayEqual(value, payload);
Assert.AreEqual(value[1], message.GetTimestampedPayloadUInt32(1).Value);
}
public void FromInt64_TimestampedArray_PayloadHasValue()
{
var value = new long[] { int.MaxValue * -2u, 123456789 };
var timestamp = GetTimestamp();
var message = HarpMessage.FromInt64(DefaultAddress, timestamp, MessageType.Write, value);
AssertIsValid(message);
var(payload, actualTimestamp) = message.GetTimestampedPayloadArray <long>();
AssertTimestamp(timestamp, actualTimestamp);
AssertArrayEqual(value, payload);
Assert.AreEqual(value[1], message.GetTimestampedPayloadInt64(1).Value);
}
public void FromSingle_TimestampedArray_PayloadHasValue()
{
var value = new float[] { (float)Math.PI, 1 / 3f };
var timestamp = GetTimestamp();
var message = HarpMessage.FromSingle(DefaultAddress, timestamp, MessageType.Write, value);
AssertIsValid(message);
var(payload, actualTimestamp) = message.GetTimestampedPayloadArray <float>();
AssertTimestamp(timestamp, actualTimestamp);
AssertArrayEqual(value, payload);
Assert.AreEqual(value[1], message.GetTimestampedPayloadSingle(1).Value);
}
public void FromSByte_TimestampedArray_PayloadHasValue()
{
var value = new sbyte[] { 4, -23 };
var timestamp = GetTimestamp();
var message = HarpMessage.FromSByte(DefaultAddress, timestamp, MessageType.Write, value);
AssertIsValid(message);
var(payload, actualTimestamp) = message.GetTimestampedPayloadArray <sbyte>();
AssertTimestamp(timestamp, actualTimestamp);
AssertArrayEqual(value, payload);
Assert.AreEqual(value[1], message.GetTimestampedPayloadSByte(1).Value);
}
static bool is_evt55(HarpMessage input)
{
if (input.Address == 60)
{
REG_MOTOR_MAXIMUM = BitConverter.ToUInt16(input.MessageBytes, 11);
REG_MOTOR_MAXIMUM_available = true;
}
if (REG_MOTOR_MAXIMUM_available == false)
{
return(false);
}
return((input.Address == 55) && (input.Error == false) && (input.MessageType == MessageType.Event));
}
/// <summary>
/// Sends a command to the Harp device and awaits the response as an asynchronous operation.
/// </summary>
/// <param name="command">The <see cref="HarpMessage"/> specifying the command to send.</param>
/// <returns>
/// The task object representing the asynchronous operation. The value of the <see cref="Task{TResult}.Result"/>
/// parameter contains the message representing the response of the device to the asynchronous command.
/// </returns>
public async Task <HarpMessage> CommandAsync(HarpMessage command)
{
var reply = response.FirstAsync(message =>
{
var match = message.IsMatch(command.Address, command.MessageType);
if (match && message.Error)
{
throw new HarpException(message);
}
return(match);
}).GetAwaiter();
transport.Write(command);
return(await reply);
}
static string GetErrorMessage(HarpMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var payloadType = message.PayloadType & ~PayloadType.Timestamp;
if (message.MessageType == MessageType.Write)
{
string payload;
switch (payloadType)
{
case PayloadType.U8: payload = GetPayloadString <byte>(message); break;
case PayloadType.S8: payload = GetPayloadString <sbyte>(message); break;
case PayloadType.U16: payload = GetPayloadString <ushort>(message); break;
case PayloadType.S16: payload = GetPayloadString <short>(message); break;
case PayloadType.U32: payload = GetPayloadString <uint>(message); break;
case PayloadType.S32: payload = GetPayloadString <int>(message); break;
case PayloadType.U64: payload = GetPayloadString <ulong>(message); break;
case PayloadType.S64: payload = GetPayloadString <long>(message); break;
case PayloadType.Float: payload = GetPayloadString <float>(message); break;
default: payload = string.Empty; break;
}
return($"The device reported an erroneous write command.\nPayload: {payload}, Address: {message.Address}, Type: {payloadType}.");
}
else
{
var payload = message.GetPayload();
if (payload.Count == 0)
{
return($"The device reported an erroneous read command.\nType not correct for address {message.Address}.");
}
return($"The device reported an erroneous read command.\nAddress: {message.Address}, Type: {payloadType}.");
}
}
static void CheckErrors(HarpMessage input, PayloadType typeExpected)
{
if (input.Error)
{
throw new InvalidOperationException("The Harp message is an error report.");
}
var payloadLength = input.GetPayload().Count;
if (payloadLength == 0)
{
throw new InvalidOperationException("The Harp message doesn't have a payload.");
}
if ((input.PayloadType & ~PayloadType.Timestamp) != typeExpected)
{
throw new InvalidOperationException("Payload type mismatch.");
}
}
/// <summary>
/// Returns a <see cref="HarpMessage"/> write command with the specified address, and a
/// single value 32-bit signed integer payload.
/// </summary>
/// <param name="address">The address of the register to which the Harp message refers to.</param>
/// <param name="value">The value to be stored in the payload.</param>
/// <returns>
/// A valid <see cref="HarpMessage"/> write command with the specified address and payload.
/// </returns>
public static HarpMessage WriteInt32(int address, int value)
{
return(HarpMessage.FromInt32(address, MessageType.Write, value));
}
/// <summary>
/// Returns a <see cref="HarpMessage"/> write command with the specified address, and an
/// array payload of 64-bit signed integers.
/// </summary>
/// <param name="address">The address of the register to which the Harp message refers to.</param>
/// <param name="values">The values to be stored in the payload.</param>
/// <returns>
/// A valid <see cref="HarpMessage"/> write command with the specified address and payload.
/// </returns>
public static HarpMessage WriteInt64(int address, params long[] values)
{
return(HarpMessage.FromInt64(address, MessageType.Write, values));
}
static bool is_evt32_And_NotQuiet(HarpMessage input)
{
return((input.Address == 32) && (input.Error == false) && (input.MessageType == MessageType.Event) && (input.MessageBytes[11] > 1));
}
/// <summary>
/// Returns a <see cref="HarpMessage"/> write command with the specified address, and an
/// array payload of single-precision floating point numbers.
/// </summary>
/// <param name="address">The address of the register to which the Harp message refers to.</param>
/// <param name="values">The values to be stored in the payload.</param>
/// <returns>
/// A valid <see cref="HarpMessage"/> write command with the specified address and payload.
/// </returns>
public static HarpMessage WriteSingle(int address, params float[] values)
{
return(HarpMessage.FromSingle(address, MessageType.Write, values));
}
/// <summary>
/// Returns a <see cref="HarpMessage"/> read command for the specified address and payload type.
/// </summary>
/// <param name="address">The address of the register to read.</param>
/// <param name="payloadType">The type of data available in the register.</param>
/// <returns>
/// A valid <see cref="HarpMessage"/> read command with the specified address and payload type.
/// </returns>
public static HarpMessage Read(int address, PayloadType payloadType)
{
return(HarpMessage.FromPayload(address, MessageType.Read, payloadType));
}
/// <summary>
/// Returns a <see cref="HarpMessage"/> read command for an 8-bit signed integer
/// register with the specified address.
/// </summary>
/// <param name="address">The address of the register to read.</param>
/// <returns>
/// A valid <see cref="HarpMessage"/> read command for an 8-bit signed integer
/// register with the specified address.
/// </returns>
public static HarpMessage ReadSByte(int address)
{
return(HarpMessage.FromSByte(address, MessageType.Read));
}
/// <summary>
/// Returns a <see cref="HarpMessage"/> read command for a 16-bit unsigned integer
/// register with the specified address.
/// </summary>
/// <param name="address">The address of the register to read.</param>
/// <returns>
/// A valid <see cref="HarpMessage"/> read command for a 16-bit unsigned integer
/// register with the specified address.
/// </returns>
public static HarpMessage ReadUInt16(int address)
{
return(HarpMessage.FromUInt16(address, MessageType.Read));
}
public static IObservable <HarpMessage> FillMissing(this IObservable <HarpMessage> source, HarpMessage defaultValue)
{
return(Observable.Create <HarpMessage>(observer =>
{
bool first = true;
long multiplier = 0;
ushort previousIndex = 0;
var sourceObserver = Observer.Create <HarpMessage>(
value =>
{
var currentIndex = value.GetPayloadUInt16(1);
if (first)
{
first = false;
}
else
{
var totalPreviousIndex = multiplier * ushort.MaxValue + previousIndex;
var delta = currentIndex - previousIndex;
if (delta < 0)
{
multiplier++;
}
var totalIndex = multiplier * ushort.MaxValue + currentIndex;
var missingValues = totalIndex - totalPreviousIndex - 1;
while (missingValues-- > 0)
{
observer.OnNext(defaultValue);
}
}
observer.OnNext(value);
previousIndex = currentIndex;
},
observer.OnError,
observer.OnCompleted);
return source.SubscribeSafe(sourceObserver);
}));
}
private static bool IsReadMessage(HarpMessage message)
{
return(message.MessageType == MessageType.Read);
}
private void ReadRegister(HarpMessage message)
{
switch (message.Address)
{
case ConfigurationRegisters.Config:
configuration.Config = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.WhoAmI:
configuration.WhoAmI = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.HardwareVersionHigh:
configuration.HardwareVersionHigh = message.GetPayloadByte();
break;
case ConfigurationRegisters.HardwareVersionLow:
configuration.HardwareVersionLow = message.GetPayloadByte();
break;
case ConfigurationRegisters.FirmwareVersionHigh:
configuration.FirmwareVersionHigh = message.GetPayloadByte();
break;
case ConfigurationRegisters.FirmwareVersionLow:
configuration.FirmwareVersionLow = message.GetPayloadByte();
break;
case ConfigurationRegisters.SerialNumber:
configuration.SerialNumber = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.ScreenBrightness:
configuration.ScreenBrightness = message.GetPayloadByte();
break;
case ConfigurationRegisters.TriggerState:
var triggerState = message.GetPayloadArray <byte>();
configuration.TriggerState = TriggerHelper.ToFrameFlags(triggerState);
break;
case ConfigurationRegisters.TriggerStateLength:
var triggerStateLength = message.GetPayloadByte();
if (configuration.TriggerState?.Length != triggerStateLength)
{
var array = configuration.TriggerState;
Array.Resize(ref array, triggerStateLength);
configuration.TriggerState = array;
}
triggerStateView.BeginInvoke((Action)SetTriggerState);
break;
case ConfigurationRegisters.TriggerPeriod:
configuration.TriggerPeriod = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.TriggerTimeUpdateOutputs:
configuration.DwellTime = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.DacL415:
configuration.L415 = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.DacL470:
configuration.L470 = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.DacL560:
configuration.L560 = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.DacLaser:
configuration.LaserAmplitude = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.Out0Conf:
configuration.DigitalOutput0 = (DigitalOutputConfiguration)message.GetPayloadByte();
break;
case ConfigurationRegisters.Out1Conf:
configuration.DigitalOutput1 = (DigitalOutputConfiguration)message.GetPayloadByte();
break;
case ConfigurationRegisters.In0Conf:
configuration.DigitalInput0 = (DigitalInputConfiguration)message.GetPayloadByte();
break;
case ConfigurationRegisters.In1Conf:
configuration.DigitalInput1 = (DigitalInputConfiguration)message.GetPayloadByte();
break;
case ConfigurationRegisters.StimWavelength:
configuration.LaserWavelength = message.GetPayloadUInt16();
setupLaserButton.BeginInvoke((Action)SetLaserCalibrationState);
break;
case ConfigurationRegisters.StimPeriod:
configuration.PulsePeriod = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.StimOn:
configuration.PulseWidth = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.StimReps:
configuration.PulseCount = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.TriggerLaserOn:
configuration.TriggerLaserOn = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.TriggerLaserOff:
configuration.TriggerLaserOff = message.GetPayloadUInt16();
break;
case ConfigurationRegisters.CameraSerialNumber:
if (message.PayloadType == PayloadType.TimestampedU64)
{
configuration.CameraSerialNumber = message.GetPayloadUInt64();
}
break;
default:
break;
}
}
/// <summary>
/// Returns a <see cref="HarpMessage"/> write command with the specified address, and a
/// single value 64-bit signed integer payload.
/// </summary>
/// <param name="address">The address of the register to which the Harp message refers to.</param>
/// <param name="value">The value to be stored in the payload.</param>
/// <returns>
/// A valid <see cref="HarpMessage"/> write command with the specified address and payload.
/// </returns>
public static HarpMessage WriteInt64(int address, long value)
{
return(HarpMessage.FromInt64(address, MessageType.Write, value));
}
static bool is_evt34(HarpMessage input)
{
return((input.Address == 34) && (input.Error == false) && (input.MessageType == MessageType.Event));
}
void AssertIsValid(HarpMessage message)
{
Assert.IsTrue(message.IsValid);
}
