public async void SetAnswer(DeviceCommands obj, string childPath) { var firebase = new FirebaseClient(Maps.LunaUrl); await firebase .Child(childPath) .PutAsync(obj); }
//private static string bright = "10001000"; //private static string dim = "10011000"; public static string GetMessage(int deviceNumber, DeviceCommands command) { if (deviceNumber < 1 || deviceNumber > 8) { throw new ArgumentException("Invalid Device Requested"); } string message = header + codeA; switch (command) { case DeviceCommands.On: message += onCommands[deviceNumber]; break; case DeviceCommands.Off: message += offCommands[deviceNumber]; break; default: throw new ArgumentException("Invalid Command Requested"); } message += footer; return(message); }
public Device(PhysicalDevice physicalDevice, DeviceCreateInfo info) { if (physicalDevice == null) { throw new ArgumentNullException(nameof(physicalDevice)); } if (info == null) { throw new ArgumentNullException(nameof(info)); } PhysicalDevice = physicalDevice; Instance = physicalDevice.Instance; queues = new Dictionary <QueueID, Queue>(); if (info.extensions == null) { Extensions = new List <string>(); } else { Extensions = new List <string>(info.extensions); } ValidateExtensions(); CreateDevice(info); Vulkan.Load(ref getDeviceProcAddr, Instance); Commands = new DeviceCommands(this); }
public byte ExecuteCommand(DeviceCommands deviceCommand) { return(ExceptionExtensions.ExecuteFunction(_logger, () => { CanExecuteCommand(deviceCommand); byte[] sendBuffer = new byte[1], receiveBuffer = new byte[1]; sendBuffer[0] = (byte)deviceCommand; if (_logger.IsTraceEnabled) { _logger.TraceFormat("ExecuteCommand {0} BufferData: {1}", deviceCommand, sendBuffer.Aggregate("", (current, part) => current + part.ToString("X").PadLeft(2, '0'))); } lock (SyncRoot) { _spiDevice.TransferFullDuplex(sendBuffer, receiveBuffer); } if (_logger.IsTraceEnabled) { _logger.TraceFormat("ExecuteCommand result Status Register: {0}", receiveBuffer[0]); } return receiveBuffer[0]; })); }
public void SendCommand(int device, DeviceCommands command) { var message = MessageGenerator.GetMessage(device, command); Commander.SendCommand(message); Console.WriteLine("{0} - Device: {1}, Command: {2}", DateTime.Now.ToString("G"), device.ToString(), command.ToString()); }
void Start() { Command lockCommand = new Command("Lock"); lockCommand.OnProcessCommand += Lock; Command unlockCommand = new Command("Unlock"); unlockCommand.OnProcessCommand += Unlock; DeviceCommands.Add(lockCommand); DeviceCommands.Add(unlockCommand); }
public void NewCommand(DeviceCommands obj, string path) { if (obj.Answer == "0") { //its a new command if (AliasBox.InvokeRequired) { AliasBox.Invoke(new MethodInvoker(delegate { AliasBox.Text += "Command: " + obj.CommandText + " FROM: " + obj.From; })); } obj.Answer = commands.ExecuteCommand(obj.CommandName); SetAnswer(obj, path); } }
private void CanExecuteCommand(DeviceCommands deviceCommand) { ExceptionExtensions.ExecuteFunction(_logger, () => { OperatingModes?operatingMode = GetOperatingMode?.Invoke(); if (CheckOperatingMode && operatingMode.HasValue && (deviceCommand == DeviceCommands.W_REGISTER && !(operatingMode == OperatingModes.StandBy || operatingMode == OperatingModes.PowerDown))) { throw new InvalidOperationException( "Writing to registers should only happen in Standby or PowerDown mode"); } }); }
void Start() { animator = GetComponent <Animator>(); OnPowerConnectionLost(); if (powerGrid) { powerGrid.ConnectRecieverToGrid(this); } Command unlock = new Command("Unlock"); unlock.OnProcessCommand += UnlockDoor; DeviceCommands.Add(unlock); }
public DeviceAdapter(IDevice device) { _device = device.ThrowIfNull(nameof(device)); _device.ConnectionError += Device_ConnectionError; _commands = new DeviceCommands(this); Calibration = (device as ICalibrate) ?? NullDeviceCalibration.Instance; Configurator = CreateConfigurator(device); Observables = DeviceObservables.CreateForDevice(this, _device); _states = CreateStateMachine(); }
public byte[] ExecuteCommand(DeviceCommands deviceCommand, byte address, byte[] value, bool autoRevert = true) { return ExceptionExtensions.ExecuteFunction(_logger, () => { CanExecuteCommand(deviceCommand); // Create send and receive buffers int resultLength = value.Length, bufferLength = resultLength + 1; byte[] result = new byte[resultLength]; byte[] sendBuffer = new byte[bufferLength], receiveBuffer = new byte[bufferLength]; // Populate send buffer with command and value to write sendBuffer[0] = (byte) ((byte) deviceCommand | address); if (value.Length > 1 && autoRevert && _revertBytes) for (int i = 0; i < resultLength; i++) sendBuffer[resultLength - i] = value[i]; else Array.Copy(value, 0, sendBuffer, 1, resultLength); // Send and Receive if (_logger.IsTraceEnabled) _logger.TraceFormat("ExecuteCommand: {0} Address: {1} Value: {2} BufferData: {3}", deviceCommand, address, value.Aggregate("", (current, part) => current + part.ToString("X").PadLeft(2, '0')), sendBuffer.Aggregate("", (current, part) => current + part.ToString("X").PadLeft(2, '0'))); lock (SyncRoot) { _spiDevice.TransferFullDuplex(sendBuffer, receiveBuffer); } Task.Delay(1).Wait(); if (_logger.IsTraceEnabled) _logger.TraceFormat("ExecuteCommand result Status Register: {0}", receiveBuffer[0]); // The STATUS register value is returned at first byte on each SPI call LoadStatusRegister?.Invoke(new[] {receiveBuffer[0]}); // Populate result with the rest of the receive buffer if (value.Length > 1 && autoRevert && _revertBytes) for (int i = 0; i < result.Length; i++) result[i] = receiveBuffer[bufferLength - (i + 1)]; else Array.Copy(receiveBuffer, 1, result, 0, bufferLength - 1); return result; }); }
public void ScheduleOneTimeItem(DateTime time, int device, DeviceCommands command) { var scheduleItem = new ScheduleItem() { Device = device, Command = command, Info = new ScheduleInfo() { EventTime = time, Type = ScheduleType.Once, }, IsEnabled = true, ScheduleSet = "", }; schedule.Add(scheduleItem); }
public byte ExecuteCommand(DeviceCommands deviceCommand) { return ExecuteCommandReturns[0]; }
public byte ExecuteCommand(DeviceCommands deviceCommand, byte address) { return(ExecuteCommandReturns[0]); }
private byte[] SendCommand(byte nOfParameters, DeviceID deviceId, DeviceCommands command, byte[] par) { switch (deviceId) { case DeviceID.DecAltMotor: case DeviceID.RaAzmMotor: return this.MotorCommands(nOfParameters, command, par); case DeviceID.HC: default: return "#".ToBytes(); } }
private byte[] MotorCommands(byte nOfParameters, DeviceCommands command, byte[] par) { switch (command) { case DeviceCommands.GET_VER: return "12#".ToBytes(); case DeviceCommands.MC_GET_POSITION: return new byte[] { 0, 1, 2, 4, (byte)(char)GeneralCommands.TERMINATOR }; case DeviceCommands.MC_GOTO_FAST: case DeviceCommands.MC_GOTO_SLOW: return "#".ToBytes(); case DeviceCommands.MC_SET_POS_FIXED_GUIDERATE: case DeviceCommands.MC_SET_NEG_FIXED_GUIDERATE: return "#".ToBytes(); case DeviceCommands.MC_SET_POS_VARIABLE_GUIDERATE: case DeviceCommands.MC_SET_NEG_VARIABLE_GUIDERATE: return "#".ToBytes(); case DeviceCommands.MC_SET_POSITION: return "#".ToBytes(); case DeviceCommands.MC_SET_AUTOGUIDE_RATE: return "#".ToBytes(); case DeviceCommands.MC_GET_AUTOGUIDE_RATE: return new byte[] { 0x0, 0x1, 0x2, 0x3, (byte)(char)GeneralCommands.TERMINATOR }; case DeviceCommands.MC_SLEW_DONE: return new byte[] { 0xff, (byte)(char)GeneralCommands.TERMINATOR }; default: return "#".ToBytes(); } }
public byte[] ExecuteCommand(DeviceCommands deviceCommand, byte address, byte[] value, bool autoRevert = true) { return(ExecuteCommandReturns); }
public override async Task <int> SaveChangesAsync(CancellationToken cancellationToken) { //Limit Log Table Size const int maxLogSize = 2000; var addedLogEntryCount = ChangeTracker.Entries <LogEntry>().Count(p => p.State == EntityState.Added); if (addedLogEntryCount > 0) { if (addedLogEntryCount > maxLogSize) { var numberToRemove = addedLogEntryCount - maxLogSize; var doNotAdd = ChangeTracker.Entries <LogEntry>() .Where(p => p.State == EntityState.Added) .OrderBy(o => o.Entity.Datetime).Take(numberToRemove); foreach (var entry in doNotAdd) { entry.State = EntityState.Detached; } } var currentLogEntryCount = await LogEntries.CountAsync(cancellationToken); var toRemove = (currentLogEntryCount + addedLogEntryCount) - maxLogSize; if (toRemove > 0) { var toBeRemoved = await LogEntries.OrderBy(o => o.Datetime).Take(toRemove).ToListAsync(cancellationToken); LogEntries.RemoveRange(toBeRemoved); } } //Update Run Scene Command Scene Name upon Scene Name update var sceneIdsOfUpdatedNames = ChangeTracker.Entries <Scene>().Where(p => p.State == EntityState.Modified && p.Property("Name").IsModified).Select(o => o.Entity.Id.ToString(CultureInfo.InvariantCulture)).ToList(); Expression <Func <IStoredCommand, bool> > sceneCmdPredicate = o => o.Command.UniqueIdentifier == "RUN_SCENE" && sceneIdsOfUpdatedNames.Contains(o.Argument); foreach (var cmd in await SceneStoredCommands.Where(sceneCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await DeviceValueTriggers.Where(sceneCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await ScheduledTasks.Where(sceneCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } //Update Activate Group Command Scene Name upon Group Name update var groupIdsOfUpdatedNames = ChangeTracker.Entries <Group>().Where(p => p.State == EntityState.Modified && p.Property("Name").IsModified).Select(o => o.Entity.Id.ToString(CultureInfo.InvariantCulture)).ToList(); Expression <Func <IStoredCommand, bool> > groupPredicate = o => (o.Command.UniqueIdentifier == "GROUP_ON" || o.Command.UniqueIdentifier == "GROUP_OFF") && groupIdsOfUpdatedNames.Contains(o.Argument); foreach (var cmd in await SceneStoredCommands.Where(groupPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await DeviceValueTriggers.Where(groupPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await ScheduledTasks.Where(groupPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } //Update cmd descriptions on JavaScriptCommand name changes var javescriptIdsOfUpdatedNameIds = ChangeTracker.Entries <JavaScriptCommand>().Where(p => p.State == EntityState.Modified && p.Property("Name").IsModified).Select(o => o.Entity.Id).ToList(); Expression <Func <IStoredCommand, bool> > jsCmdPredicate = o => o.Command is JavaScriptCommand && javescriptIdsOfUpdatedNameIds.Contains(o.Command.Id); foreach (var cmd in await SceneStoredCommands.Where(jsCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await DeviceValueTriggers.Where(jsCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await ScheduledTasks.Where(jsCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } //Update trigger descriptions on device value name changes var deviceValueIdsOfUpdatedNames = ChangeTracker.Entries <DeviceValue>().Where(p => p.State == EntityState.Modified && p.Property("Name").IsModified).Select(o => o.Entity.Id).ToList(); var triggers = await DeviceValueTriggers.Include(o => o.DeviceValue).Include(o => o.DeviceValue.Device).Where(o => deviceValueIdsOfUpdatedNames.Contains(o.DeviceValue.Id)).ToListAsync(cancellationToken); foreach (var trigger in triggers) { trigger.SetDescription(); } //Update commands on device name changes var deviceIdsOfUpdatedNames = ChangeTracker.Entries <Device>().Where(p => p.State == EntityState.Modified && (p.Property("Name").IsModified || p.Property("Location").IsModified)).Select(o => o.Entity.Id).ToList(); var deviceIdsStrOfUpdatedNames = deviceIdsOfUpdatedNames.Select(o => o.ToString()); var deviceTriggers = await DeviceValueTriggers.Include(o => o.DeviceValue).Include(o => o.DeviceValue.Device).Where(o => deviceIdsOfUpdatedNames.Contains(o.DeviceValue.DeviceId)).ToListAsync(cancellationToken); foreach (var trigger in deviceTriggers) { trigger.SetDescription(); } //Update repoll commands Expression <Func <IStoredCommand, bool> > repollCmdPredicate = o => o.Command.UniqueIdentifier == "REPOLL_ME" && deviceIdsStrOfUpdatedNames.Contains(o.Argument); foreach (var cmd in await SceneStoredCommands.Where(repollCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await DeviceValueTriggers.Where(repollCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await ScheduledTasks.Where(repollCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } Expression <Func <IStoredCommand, bool> > deviceTypeCmdPredicate = o => o.Command is DeviceTypeCommand && deviceIdsStrOfUpdatedNames.Contains(o.Argument2); foreach (var cmd in await SceneStoredCommands.Where(deviceTypeCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await DeviceValueTriggers.Where(deviceTypeCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await ScheduledTasks.Where(deviceTypeCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } var deviceCommandIds = await DeviceCommands.Where(o => deviceIdsOfUpdatedNames.Contains(o.DeviceId)).Select(o => o.Id).ToListAsync(cancellationToken); Expression <Func <IStoredCommand, bool> > deviceCmdPredicate = o => o.Command is DeviceCommand && deviceCommandIds.Contains(o.Command.Id); foreach (var cmd in await SceneStoredCommands.Where(deviceCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await DeviceValueTriggers.Where(deviceCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } foreach (var cmd in await ScheduledTasks.Where(deviceCmdPredicate).ToListAsync(cancellationToken)) { await cmd.SetTargetObjectNameAsync(this); } //Automatically store history when a device value is changed. var history = ChangeTracker.Entries <DeviceValue>() .Where(p => p.State == EntityState.Modified && p.Property("Value").IsModified) .Select( o => new DeviceValueHistory { DeviceValueId = o.Entity.Id, Value = o.Entity.Value }).ToList(); DeviceValueHistories.AddRange(history); return(await base.SaveChangesAsync(cancellationToken)); }
public byte[] ExecuteCommand(DeviceCommands deviceCommand, byte address, byte[] value, bool autoRevert = true) { return(ExceptionExtensions.ExecuteFunction(_logger, () => { CanExecuteCommand(deviceCommand); // Create send and receive buffers int resultLength = value.Length, bufferLength = resultLength + 1; byte[] result = new byte[resultLength]; byte[] sendBuffer = new byte[bufferLength], receiveBuffer = new byte[bufferLength]; // Populate send buffer with command and value to write sendBuffer[0] = (byte)((byte)deviceCommand | address); if (value.Length > 1 && autoRevert && _revertBytes) { for (int i = 0; i < resultLength; i++) { sendBuffer[resultLength - i] = value[i]; } } else { Array.Copy(value, 0, sendBuffer, 1, resultLength); } // Send and Receive if (_logger.IsTraceEnabled) { _logger.TraceFormat("ExecuteCommand: {0} Address: {1} Value: {2} BufferData: {3}", deviceCommand, address, value.Aggregate("", (current, part) => current + part.ToString("X").PadLeft(2, '0')), sendBuffer.Aggregate("", (current, part) => current + part.ToString("X").PadLeft(2, '0'))); } lock (SyncRoot) { _spiDevice.TransferFullDuplex(sendBuffer, receiveBuffer); } Task.Delay(1).Wait(); if (_logger.IsTraceEnabled) { _logger.TraceFormat("ExecuteCommand result Status Register: {0}", receiveBuffer[0]); } // The STATUS register value is returned at first byte on each SPI call LoadStatusRegister?.Invoke(new[] { receiveBuffer[0] }); // Populate result with the rest of the receive buffer if (value.Length > 1 && autoRevert && _revertBytes) { for (int i = 0; i < result.Length; i++) { result[i] = receiveBuffer[bufferLength - (i + 1)]; } } else { Array.Copy(receiveBuffer, 1, result, 0, bufferLength - 1); } return result; })); }
public byte ExecuteCommand(DeviceCommands deviceCommand) { return(ExecuteCommandReturns[0]); }
public byte ExecuteCommand(DeviceCommands deviceCommand, byte address) { return ExecuteCommandReturns[0]; }
private void CanExecuteCommand(DeviceCommands deviceCommand) { ExceptionExtensions.ExecuteFunction(_logger, () => { OperatingModes? operatingMode = GetOperatingMode?.Invoke(); if (CheckOperatingMode && operatingMode.HasValue && (deviceCommand == DeviceCommands.W_REGISTER && !(operatingMode == OperatingModes.StandBy || operatingMode == OperatingModes.PowerDown))) throw new InvalidOperationException( "Writing to registers should only happen in Standby or PowerDown mode"); }); }
public byte ExecuteCommand(DeviceCommands deviceCommand, byte address) { return ExceptionExtensions.ExecuteFunction(_logger, () => { CanExecuteCommand(deviceCommand); byte[] sendBuffer = new byte[1], receiveBuffer = new byte[1]; sendBuffer[0] = (byte) ((byte) deviceCommand | address); if (_logger.IsTraceEnabled) _logger.TraceFormat("ExecuteCommand: {0} Address: {1} BufferData: {2}", deviceCommand, address, sendBuffer.Aggregate("", (current, part) => current + part.ToString("X").PadLeft(2, '0'))); lock (SyncRoot) { _spiDevice.TransferFullDuplex(sendBuffer, receiveBuffer); } if (_logger.IsTraceEnabled) _logger.TraceFormat("ExecuteCommand result Status Register: {0}", receiveBuffer[0]); return receiveBuffer[0]; }); }
public byte[] ExecuteCommand(DeviceCommands deviceCommand, byte address, byte[] value, bool autoRevert = true) { return ExecuteCommandReturns; }
public DeviceCommandAttribute(DeviceCommands cmd) { command = cmd; }