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); }