private async Task <ErrorCode> SetBusAddressAsyncInternal(uint uuid, int busAddress, bool sync) { var request = new BusRequest(); request.Write((byte)0x00); request.Write((byte)0x00); request.Write(uuid); request.Write((byte)0x00); request.Write((byte)busAddress); var result = sync ? TransceiveBroadcast(request, 1) : await TransceiveBroadcastAsync(request, 1); if (result.Success) { if (result.Response.ReadByte() == 1) { return(ErrorCode.Success); } else { return(ErrorCode.DeviceRejectedBusAddress); } } else { return(result.TransportError); } }
/// <summary> /// Sends a broadcast to all devices which does nothing, but can be used to wake up devices which were put /// to sleep with GoToSleep. /// </summary> /// <returns>Error code describing the result of the call.</returns> public ErrorCode SendNopBroadcast() { var request = new BusRequest(); request.Write((byte)0x00); return(SendBroadcast(request)); }
/// <summary> /// Sends a broadcast to all devices which does nothing, but can be used to wake up devices which were put /// to sleep with GoToSleep. /// </summary> /// <returns>A task representing the asynchronous operation. /// Contains an error code describing the result of the call.</returns> public Task <ErrorCode> SendNopBroadcastAsync() { var request = new BusRequest(); request.Write((byte)0x00); return(SendBroadcastAsync(request)); }
private async Task <(ErrorCode, string)> GetCommandNameAsyncInternal(byte key, bool sync) { (ErrorCode commandNameLengthError, byte length) = sync ? GetCommandNameLength(key) : await GetCommandNameLengthAsync(key); if (commandNameLengthError != ErrorCode.Success) { Log.Logger?.Error("unable to retrieve command name length", this); return(commandNameLengthError, null); } BusRequest request = new BusRequest(); request.Write(key); request.Write((byte)CommandKey.CommandInfoGetName); request.Write((byte)CommandKey.CommandInfoGetName); request.Write((byte)CommandKey.CommandInfoGetName); BusTransceiveResult result = sync ? Transceive(request, length) : await TransceiveAsync(request, length); if (result.Success) { return(ErrorCode.Success, Encoding.UTF8.GetString(result.Response.ReadBytes(length))); } else { return(result.TransportError, null); } }
private async Task SendRequestAsync(string queueName, BusRequest request, CancellationToken cancellationToken = default) { await using var sender = _client.CreateSender(queueName); var input = JsonSerializer.SerializeToUtf8Bytes(request, request.GetType()); await sender.SendMessageAsync(new ServiceBusMessage(input), cancellationToken); }
private async Task <ErrorCode> SetFloatValueAsyncInternal(byte key, float value, bool sync) { if (CommandSet == null) { Log.Logger?.Error("commandSet not populated", this); return(ErrorCode.DeviceNotInitialized); } if (key > CommandSet.Length || key == 0) { Log.Logger?.Error("key not within commandSetLength", this); return(ErrorCode.StellantriebInvalidKey); } CommandInternal command = commandSet[key - 1]; if (command.CommandLength == Command.Length.None || command.CommandLength == Command.Length.NoneAsText) { Log.Logger?.Error("%s: key not supported", this); return(ErrorCode.StellantriebInvalidKey); } if (command.AccessMode != Command.Access.WriteAccess) { Log.Logger?.Error("key not writable", this); return(ErrorCode.StellantriebValueReadOnly); } if (command.IsControlValue) { Log.Logger?.Error("value with key %u is not floating point, which was requested", this); return(ErrorCode.StellantriebInvalidKey); } command.bufferValid = false; BusRequest request = new BusRequest(); request.Write(key); switch (command.CommandLength) { case Command.Length.Byte: request.Write((byte)(value / command.Factor)); return(sync ? Transceive(request, 0).TransportError : (await TransceiveAsync(request, 0)).TransportError); case Command.Length.Short: request.Write((Int16)(value / command.Factor)); return(sync ? Transceive(request, 0).TransportError : (await TransceiveAsync(request, 0)).TransportError); case Command.Length.Long: request.Write((Int32)(value / command.Factor)); return(sync ? Transceive(request, 0).TransportError : (await TransceiveAsync(request, 0)).TransportError); case Command.Length.Float: request.Write(value / command.Factor); return(sync ? Transceive(request, 0).TransportError : (await TransceiveAsync(request, 0)).TransportError); default: return(ErrorCode.Unspecified); } }
/// <summary> /// Disable bus neighbours of available devices. /// </summary> /// <returns>Error code describing the result of the call.</returns> public ErrorCode DisableBusNeighbours() { var broadcast = new BusRequest(); broadcast.Write((byte)0x00); broadcast.Write((byte)0x02); return(SendBroadcast(broadcast)); }
/// <summary> /// Disable bus neighbours of available devices. /// </summary> /// <returns>A task representing the asynchronous operation. /// Contains an error code describing the result of the call.</returns> public Task <ErrorCode> DisableBusNeighboursAsync() { var broadcast = new BusRequest(); broadcast.Write((byte)0x00); broadcast.Write((byte)0x02); return(SendBroadcastAsync(broadcast)); }
/// <summary> /// Requests all available devices to enter a powerdown mode. /// </summary> /// <returns>Error code describing the result of the call.</returns> public ErrorCode GoToSleep() { var broadcast = new BusRequest(); broadcast.Write((byte)0x00); broadcast.Write((byte)0x06); return(SendBroadcast(broadcast)); }
/// <summary> /// Requests all available devices to enter a powerdown mode. /// </summary> /// <returns>A task representing the asynchronous operation. /// Contains an error code describing the result of the call.</returns> public Task <ErrorCode> GoToSleepAsync() { var broadcast = new BusRequest(); broadcast.Write((byte)0x00); broadcast.Write((byte)0x06); return(SendBroadcastAsync(broadcast)); }
/// <summary> /// Resets the bus address of all available devices. /// </summary> /// <returns>A task representing the asynchronous operation. /// Contains an error code describing the result of the call.</returns> public Task <ErrorCode> ResetAllBusAddressesAsync() { var broadcast = new BusRequest(); broadcast.Write((byte)0x00); broadcast.Write((byte)0x03); return(SendBroadcastAsync(broadcast)); }
/// <summary> /// Resets the bus address of all available devices. /// </summary> /// <returns>Error code describing the result of the call.</returns> public ErrorCode ResetAllBusAddresses() { var broadcast = new BusRequest(); broadcast.Write((byte)0x00); broadcast.Write((byte)0x03); return(SendBroadcast(broadcast)); }
/// <summary> /// Pings the device with the given UUID. /// </summary> /// <param name="uuid">UUID of the device to ping.</param> /// <returns>Error code describing the result of the call.</returns> public ErrorCode SendUuidPing(uint uuid) { var request = new BusRequest(); request.Write((byte)0x00); request.Write((byte)0x00); request.Write(uuid); return(TransceiveBroadcast(request, 0).TransportError); }
/// <summary> /// Pings the device with the given UUID. /// </summary> /// <param name="uuid">UUID of the device to ping.</param> /// <returns>A task representing the asynchronous operation. /// Contains an error code describing the result of the call.</returns> public async Task <ErrorCode> SendUuidPingAsync(uint uuid) { var request = new BusRequest(); request.Write((byte)0x00); request.Write((byte)0x00); request.Write(uuid); return((await TransceiveBroadcastAsync(request, 0)).TransportError); }
private async Task <ErrorCode> ResetBusAddressAsyncInternal(uint uuid, bool sync) { var request = new BusRequest(); request.Write((byte)0x00); request.Write((byte)0x00); request.Write(uuid); request.Write((byte)0x01); var result = sync ? TransceiveBroadcast(request, 0) : await TransceiveBroadcastAsync(request, 0); return(result.TransportError); }
private async Task <ErrorCode> PopulateCommandSetAsyncInternal(bool sync) { (ErrorCode commandSetLengthError, uint commandSetLength) = sync ? GetCommandsetLength() : await GetCommandsetLengthAsync(); if (commandSetLengthError != ErrorCode.Success) { Log.Logger?.Error("unable to retrieve command set length", this); return(commandSetLengthError); } if (commandSetLength == 0) { Log.Logger?.Error("command set length of 0 is unsupported", this); return(ErrorCode.StellantriebCommandLengthZero); } CommandInternal[] tempCommandSet = new CommandInternal[commandSetLength]; for (int i = 0; i < commandSetLength; ++i) { BusRequest request = new BusRequest(); request.Write((byte)(i + 1)); request.Write((byte)CommandKey.CommandInfoGet); request.Write((byte)CommandKey.CommandInfoGet); request.Write((byte)CommandKey.CommandInfoGet); BusTransceiveResult result = sync ? Transceive(request, 6) : await TransceiveAsync(request, 6); if (!result.Success) { return(result.TransportError); } tempCommandSet[i] = new CommandInternal( (Command.Access)result.Response.ReadByte(), (Command.Length)result.Response.ReadByte(), result.Response.ReadSingle()); } commandSet = tempCommandSet; return(ErrorCode.Success); }
private async Task <(ErrorCode, uint uuid)> SendBroadcastPingAsyncInternal(bool sync) { var request = new BusRequest(); request.Write((byte)0x00); request.Write((byte)0x00); var result = sync ? TransceiveBroadcast(request, 4) : await TransceiveBroadcastAsync(request, 4); if (result.Success) { return(result.TransportError, result.Response.ReadUInt32()); } else { return(result.TransportError, 0); } }
private async Task <(ErrorCode, byte)> GetCommandNameLengthAsyncInternal(byte key, bool sync) { BusRequest request = new BusRequest(); request.Write(key); request.Write((byte)CommandKey.CommandInfoGetNameLength); request.Write((byte)CommandKey.CommandInfoGetNameLength); request.Write((byte)CommandKey.CommandInfoGetNameLength); BusTransceiveResult result = sync ? Transceive(request, 1) : await TransceiveAsync(request, 1); if (result.Success) { return(ErrorCode.Success, result.Response.ReadByte()); } else { return(result.TransportError, 0); } }
private async Task <(ErrorCode, int busAddress)> ReceiveBusAddressAsyncInternal(uint uuid, bool sync) { var request = new BusRequest(); request.Write((byte)0x00); request.Write((byte)0x00); request.Write(uuid); request.Write((byte)0x00); var result = sync ? TransceiveBroadcast(request, 1) : await TransceiveBroadcastAsync(request, 1); if (result.Success) { return(result.TransportError, result.Response.ReadByte()); } else { return(result.TransportError, 0); } }
/// <summary> /// Transmits a broadcast. /// </summary> /// <param name="broadcast">Broadcast containing the packet data, excluding address and checksum.</param> /// <returns>A task representing the asynchronous operation. /// Contains an error code describing the result of the call.</returns> protected Task <ErrorCode> SendBroadcastAsync(BusRequest broadcast) { return(SendBroadcastAsyncInternal(broadcast, sync: false)); }
/// <summary> /// Transmits a broadcast. /// </summary> /// <param name="broadcast">Broadcast containing the packet data, excluding address and checksum.</param> /// <returns>Error code describing the result of the call.</returns> protected ErrorCode SendBroadcast(BusRequest broadcast) { return(SendBroadcastAsyncInternal(broadcast, sync: true).GetAwaiter().GetResult()); }
/// <summary> /// Transmit a broadcast and attempt to receive a response. This function is equivalent to calling /// TransceiveAsync(), passing BroadcastAddress as the target address. /// </summary> /// <param name="broadcastRequest">Request containing the packet data, excluding address and checksum.</param> /// <param name="responseSize">Expected response data size, not counting address and checksum.</param> /// <param name="attempts">Number of unsuccessful transceive attempts before an error code /// is returned.</param> /// <returns>A task representing the asynchronous operation. /// Contains an object containing an error code and the received data.</returns> protected Task <BusTransceiveResult> TransceiveBroadcastAsync(BusRequest broadcastRequest, int responseSize, int attempts = DefaultAttempts) { return(TransceiveAsyncInternal(BroadcastAddress, broadcastRequest, responseSize, attempts, sync: false)); }
/// <summary> /// Transmit a broadcast and attempt to receive a response. This function is equivalent to calling /// Transceive(), passing BroadcastAddress as the target address. /// </summary> /// <param name="broadcastRequest">Request containing the packet data, excluding address and checksum.</param> /// <param name="responseSize">Expected response data size, not counting address and checksum.</param> /// <param name="attempts">Number of unsuccessful transceive attempts before an error code /// is returned.</param> /// <returns>An object containing an error code and the received data.</returns> protected BusTransceiveResult TransceiveBroadcast(BusRequest broadcastRequest, int responseSize, int attempts = DefaultAttempts) { return(TransceiveAsyncInternal(BroadcastAddress, broadcastRequest, responseSize, attempts, sync: true).GetAwaiter().GetResult()); }
private async Task <ErrorCode> SetIntValueAsyncInternal(byte key, int value, bool sync) { if (CommandSet == null) { Log.Logger?.Error("commandSet not populated", this); return(ErrorCode.DeviceNotInitialized); } if (key > CommandSet.Length || key == 0) { Log.Logger?.Error("key not within commandSetLength", this); return(ErrorCode.StellantriebInvalidKey); } CommandInternal command = commandSet[key - 1]; if (command.CommandLength == Command.Length.None || command.CommandLength == Command.Length.NoneAsText) { Log.Logger?.Error("%s: key not supported", this); return(ErrorCode.StellantriebInvalidKey); } if (command.AccessMode != Command.Access.WriteAccess) { Log.Logger?.Error("key not writable", this); return(ErrorCode.StellantriebValueReadOnly); } if (!command.IsControlValue) { Log.Logger?.Error("value with key %u is floating point, which was not requested", this); return(ErrorCode.StellantriebInvalidKey); } command.bufferValid = false; BusRequest request = new BusRequest(); request.Write(key); switch (command.CommandLength) { case Command.Length.Byte: request.Write((byte)(value)); return(sync ? Transceive(request, 0).TransportError : (await TransceiveAsync(request, 0)).TransportError); case Command.Length.Short: request.Write((short)(value)); return(sync ? Transceive(request, 0).TransportError : (await TransceiveAsync(request, 0)).TransportError); case Command.Length.Long: request.Write((Int32)(value)); return(sync ? Transceive(request, 0).TransportError : (await TransceiveAsync(request, 0)).TransportError); case Command.Length.Float: // this actually does not make sense. But the problem ist that the configuration is // invalid in the first place. request.Write((float)value); return(sync ? Transceive(request, 0).TransportError : (await TransceiveAsync(request, 0)).TransportError); default: return(ErrorCode.Unspecified); } }