private void ValueDispatchToRule(IDispatchable dispatchable, object o, Guid toRule, RuleInterfaceInstance toInterface) { lock (_lock) { Task.Run(async() => { await _ruleInstanceVisuNotifier.NotifyValueChanged(toInterface, o); }).ConfigureAwait(false); foreach (var rule in _logicInstancesStore.Dictionary()) { if (rule.Key.ObjId == toRule) { try { SystemLogger.Instance.LogDebug( $"ValueDispatchToRule: {dispatchable.Name} write value {o} to {toInterface.This2RuleInterfaceTemplateNavigation.Name}"); var ruleResults = rule.Value.ValueChanged(toInterface, dispatchable, o); foreach (var result in ruleResults) { Task.Run(async() => { await _dispatcher.DispatchValue(result.Instance, result.Value); }).ConfigureAwait(false); } } catch (Exception e) { SystemLogger.Instance.LogError(e, $"Error writing value ({o}) to {dispatchable.Name}"); } } } } }
protected override object ConvertFromBus(IDispatchable source, byte[] value) { var intValue = BitConverter.ToUInt64(value, 0); intValue = ((UInt64)(intValue / Factor) + (UInt64)Offset); return(intValue); }
public sealed override object ConvertValueFromBus(IDispatchable source, ushort[] value) { var bytes = new List <byte>(); foreach (var va in value) { bytes.AddRange(BitConverter.GetBytes(va)); } switch (ByteOrder) { case ModBus4ByteOrder.AB_CD: break; case ModBus4ByteOrder.CD_AB: WordSwap(ref bytes); break; case ModBus4ByteOrder.BA_DC: ByteSwap(ref bytes); // break; case ModBus4ByteOrder.DC_BA: ByteSwap(ref bytes); WordSwap(ref bytes); break; } var correctValue = ConvertFromBus(source, bytes.ToArray()); return(correctValue); }
public override async Task WriteValue(IDispatchable source, object value) { if (bool.TryParse(value.ToString(), out bool bolValue)) { if (bolValue) { var dg = new RadioErp1Packet(Rorg.Rps, new ReadOnlyMemory <byte>(new byte[] { 0x10 })); await Driver.SendTelegram(dg); await Task.Delay(150); dg = new RadioErp1Packet(Rorg.Rps, new ReadOnlyMemory <byte>(new byte[] { 0x00 })); await Driver.SendTelegram(dg); } else { var dg = new RadioErp1Packet(Rorg.Rps, new ReadOnlyMemory <byte>(new byte[] { 0x30 })); await Driver.SendTelegram(dg); await Task.Delay(150); dg = new RadioErp1Packet(Rorg.Rps, new ReadOnlyMemory <byte>(new byte[] { 0x20 })); await Driver.SendTelegram(dg); } } }
public sealed override object ConvertValueFromBus(IDispatchable source, ushort[] value) { var bytes = new List <byte>(); foreach (var va in value) { bytes.AddRange(BitConverter.GetBytes(va)); } switch (ByteOrder) { case ModBus8ByteOrder.AB_CD_EF_GH: WordSwap(ref bytes); break; case ModBus8ByteOrder.GH_EF_CD_AB: break; case ModBus8ByteOrder.BA_DC_FE_HG: bytes.Reverse(); break; case ModBus8ByteOrder.HF_FE_DC_BA: ByteSwap(ref bytes); break; } return(ConvertFromBus(source, bytes.ToArray())); }
public override Task WriteValue(IDispatchable source, object value) { var shortValue = _attribute.ConvertValueToBus(source, value); DriverContext.Logger.LogInformation($"Get value ({value} - {String.Join("-", shortValue)}) from {source.Id} to {_parent.Name + $"(-{_parent.DeviceId}-)" + Name} (Register: {_attribute.Register}, Lenght: {_attribute.RegisterLength}, Table: {_attribute.Table})"); switch (_attribute.Table) { case ModBusTable.Coil: Driver.SetCoil(_parent.DeviceId, _attribute.Register, shortValue[0] == 1); return(Task.CompletedTask); case ModBusTable.DiscreteInput: Driver.SetDiscreteInput(_parent.DeviceId, _attribute.Register, shortValue[0] == 1); return(Task.CompletedTask); } for (int i = 0; i < _attribute.RegisterLength; i++) { var registerAddress = (ushort)(_attribute.Register + i); switch (_attribute.Table) { case ModBusTable.HoldingRegister: Driver.SetHoldingRegister(_parent.DeviceId, registerAddress, shortValue[i]); break; case ModBusTable.InputRegister: Driver.SetInputRegister(_parent.DeviceId, registerAddress, shortValue[i]); break; } } DispatchValue(value); return(base.WriteValue(source, value)); }
protected virtual Task DispatchValueInternal(IDispatchable self, object value, Action <IDispatchable, object> dis) { return(Task.Run(() => { dis(self, value); })); }
protected override byte[] ConvertToBus(IDispatchable source, object value) { try { var intValue = Convert.ToUInt64(value); intValue = ((UInt64)(intValue * Factor) - (UInt64)Offset); var firstQ = (ushort)(intValue >> 48); var secondQ = (ushort)(intValue >> 32); var thirdQ = (ushort)(intValue >> 16); var fourthQ = (ushort)(intValue & 0xffff); var bytes = new List <byte>(); bytes.AddRange(BitConverter.GetBytes(firstQ)); bytes.AddRange(BitConverter.GetBytes(secondQ)); bytes.AddRange(BitConverter.GetBytes(thirdQ)); bytes.AddRange(BitConverter.GetBytes(fourthQ)); return(bytes.ToArray()); } catch (Exception e) { DriverContext.Logger.LogError(e, $"Could not convert {value} to int64"); throw new InvalidInputValueException(e); } }
private Task ExecuteDispatch(IDispatchable self, object value, IList <Action <IDispatchable, object> > dispatch, Action <IDispatchable, object, Action <IDispatchable, object> > dispatchAction) { foreach (var dis in dispatch) { if (!_hopCounts[self.Id].ContainsKey(dis)) { _hopCounts[self.Id].Add(dis, 0); } try { if (_hopCounts[self.Id][dis] > 10) { _hopCounts.Clear(); throw new DispatchLoopDetectedException(self); } IncrementHopCount(self, dis); dispatchAction.Invoke(self, value, dis); ResetHopCount(self, dis); } catch (DispatchLoopDetectedException dlde) { _logger.LogError(dlde, $"Detected a dispatch loop while dispatching {dlde.Dispatchable.Id}-{dlde.Dispatchable.Name}"); throw; } catch (Exception e) { _logger.LogError($"Error while dispatching {self.Id}-{self.Name}. {e}"); } } return(Task.CompletedTask); }
public override Task WriteValue(IDispatchable source, object value) { WriteReceived = true; DispatchValue(value); return(Task.CompletedTask); }
protected override object ConvertFromBus(IDispatchable source, byte[] value) { var dblValue = BitConverter.ToDouble(value, 0); dblValue = dblValue / Factor + Offset; return(dblValue); }
public sealed override ushort[] ConvertValueToBus(IDispatchable source, object value) { var bytes = ConvertToBus(source, value); switch (ByteOrder) { case ModBus8ByteOrder.AB_CD_EF_GH: case ModBus8ByteOrder.GH_EF_CD_AB: break; case ModBus8ByteOrder.BA_DC_FE_HG: case ModBus8ByteOrder.HF_FE_DC_BA: { var b1 = bytes[0]; var b2 = bytes[1]; var b3 = bytes[2]; var b4 = bytes[3]; var b5 = bytes[4]; var b6 = bytes[5]; var b7 = bytes[6]; var b8 = bytes[7]; bytes[0] = b2; bytes[1] = b1; bytes[3] = b3; bytes[2] = b4; bytes[5] = b5; bytes[4] = b6; bytes[7] = b7; bytes[6] = b8; } break; } var v1 = BitConverter.ToUInt16(new[] { bytes[0], bytes[1] }, 0); var v2 = BitConverter.ToUInt16(new[] { bytes[2], bytes[3] }, 0); var v3 = BitConverter.ToUInt16(new[] { bytes[4], bytes[5] }, 0); var v4 = BitConverter.ToUInt16(new[] { bytes[6], bytes[7] }, 0); switch (ByteOrder) { case ModBus8ByteOrder.AB_CD_EF_GH: case ModBus8ByteOrder.BA_DC_FE_HG: return(new[] { v1, v2, v3, v4 }); case ModBus8ByteOrder.GH_EF_CD_AB: case ModBus8ByteOrder.HF_FE_DC_BA: return(new[] { v4, v3, v2, v1 }); } throw new InvalidInputValueException(); }
public override object ConvertValueFromBus(IDispatchable source, ushort[] value) { if (value.Length == 1) { return(value[0] == 1); } throw new ArgumentException(nameof(value)); }
public override Task WriteValue(IDispatchable source, object value) { var writeValue = ConvertValue(value); Characteristic.Value = writeValue; Driver.WriteCharacteristic(Characteristic); return(Task.FromResult(true)); }
public override Task WriteValue(IDispatchable source, object value) { var strValue = Convert.ToString(value); _value = strValue; Container.Gateway.Driver.SetColor(Container.DeviceId, strValue); return(base.WriteValue(source, value)); }
public override Task WriteValue(IDispatchable source, object value) { if (value is System.DateTime) { var solarTimes = new SolarTimes((System.DateTime)value, Latitude, Longitude); DispatchValue(_getValueFunc(solarTimes, (System.DateTime)value)); } return(base.WriteValue(source, value)); }
public override Task WriteValue(IDispatchable source, object value) { var intValue = Convert.ToInt32(value); _value = intValue; Container.Gateway.Driver.SetDimmer(Container.DeviceId, intValue); return(base.WriteValue(source, intValue)); }
public override Task WriteValue(IDispatchable source, object value) { var parent = (HueOnOffNode)Parent; var boolValue = Convert.ToBoolean(value); Driver.SetLightState(parent.LightNumber, new HueBridge.Data.HueSwitchLightData(boolValue, boolValue ? 100 : 0)); DispatchValue(value); return(base.WriteValue(source, value)); }
protected override object ConvertFromBus(IDispatchable source, byte[] value) { var bytes = new[] { value[2], value[3], value[0], value[1] }; var intValue = BitConverter.ToUInt32(bytes, 0); intValue = (uint)(intValue / Factor + Offset); return(intValue); }
private void DataCallback(IDispatchable dispatchable, object value) { if (_recorders.ContainsKey(dispatchable.Id)) { foreach (var rec in _recorders[dispatchable.Id]) { rec.ValueChanged(value, dispatchable.Name); } } }
protected override IList <IRuleOutputChanged> InputValueChanged(RuleInterfaceInstance instance, IDispatchable source, object value) { if (instance == _input) { return(ValueChanged(_output, value)); } return(new List <IRuleOutputChanged>()); }
internal void _handleInternal(IDispatchable eventToHandle) { HandlerMethodInfo handlerMethodInfo = null; _handlerMethods.TryGetValue(eventToHandle.GetType(), out handlerMethodInfo); if (handlerMethodInfo != null && eventToHandle != null) { handlerMethodInfo.Method.Invoke(handlerMethodInfo.Target, new object[] { eventToHandle }); } }
protected override IList <IRuleOutputChanged> InputValueChanged(RuleInterfaceInstance instance, IDispatchable source, object value) { WriteReceived = true; return(new List <IRuleOutputChanged>() { new RuleOutputChanged(Output, true) }); }
public override Task WriteValue(IDispatchable source, object value) { var newValue = Convert.ToDouble(value); DispatchValue(newValue); _value = newValue; Driver.Write(GroupAddress, ConvertToBus(newValue)); return(Task.CompletedTask); }
public async Task DispatchValue(IDispatchable dispatchable, object value) { var topic = $"{RemoteTopicConstants.DISPATCHER_TOPIC}/{dispatchable.Type}/{dispatchable.Id}"; await _mqttServer.PublishAsync(new MqttApplicationMessage() { Topic = topic, QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce, Payload = BinarySerializer.Serialize(value), Retain = true }); }
private void ValueDispatched(IDispatchable dispatchable, object o, Guid to) { foreach (var node in _coreServer.DriverNodes) { if (node.Id == to) { SystemLogger.Instance.LogDebug($"ValueDispatched: {dispatchable.Name} write value {o} to {node.Name}-{node.Id}"); node.WriteValue(dispatchable, o); } } }
private async Task Dispatch(IDispatchable self, object value, Action <IDispatchable, object, Action <IDispatchable, object> > dispatchAction) { StoreValue(self, value); if (!_hopCounts.ContainsKey(self.Id)) { _hopCounts.Add(self.Id, new ConcurrentDictionary <Action <IDispatchable, object>, int>()); } _logger.LogInformation($"Driver {self.Id}-{self.Name} dispatched value {value}"); if (_registrationMap.ContainsKey(self.Type) && _registrationMap[self.Type].ContainsKey(self.Id)) { var dispatch = _registrationMap[self.Type][self.Id]; foreach (var dis in dispatch) { if (!_hopCounts[self.Id].ContainsKey(dis)) { _hopCounts[self.Id].Add(dis, 0); } try { if (_hopCounts[self.Id][dis] > 10) { _hopCounts.Clear(); throw new DispatchLoopDetectedException(self); } IncrementHopCount(self, dis); dispatchAction.Invoke(self, value, dis); ResetHopCount(self, dis); } catch (DispatchLoopDetectedException dlde) { _logger.LogError(dlde, $"Detected a dispatch loop while dispatching {dlde.Dispatchable.Id}-{dlde.Dispatchable.Name}"); throw; } catch (Exception e) { _logger.LogError($"Error while dispatching {self.Id}-{self.Name}. {e}"); } } } else if (self.Source != DispatchableSource.Remote) { _logger.LogInformation($"Dispatch value via mqtt dispatcher"); await _remoteSender.DispatchValue(self, value); } await _dataBroadcast.DispatchValue(self.Type, self.Id, value); }
public override Task WriteValue(IDispatchable source, object value) { if (_value == value) { return(Task.CompletedTask); } _value = value; DriverContext.Logger.LogDebug($"WriteValue {value}"); DispatchValue(value); return(Task.CompletedTask); }
protected override void ParamterValueChanged(RuleInterfaceInstance instance, IDispatchable source, object value) { if (instance.This2RuleInterfaceTemplate == DelayedOffRuleFactory.RuleParamDelay) { _delay = Convert.ToInt64(value); if (_timerRunning) { StartStopTimer(); } } base.ParamterValueChanged(instance, source, value); }
public override Task WriteValue(IDispatchable source, object value) { var boolValue = Convert.ToBoolean(value); if (boolValue != Value) { _parent.WriteToBus(); } Value = boolValue; return(Task.CompletedTask); }