public DeviceAction(byte[] array, int startIndex = 0) { var stack = new SimpleStack(array, startIndex); _device = stack.PopName(); _action = stack.PopString(); _values = stack.PopArray(); }
public NodeInfo(byte[] data) { if (data == null) throw new ArgumentNullException("data"); if (data.Length < 28) throw new ArgumentException("data length not sufficient to fill NodeInfo"); var stack = new SimpleStack(data); Name = stack.PopName(); Description = stack.PopString(); Location = stack.PopString(); Address = stack.PopAddress(); Type = stack.PopString(); Hardware = stack.PopName(); Version = stack.PopName(); DigitalInputs = stack.PopByte(); DigitalOutputs = stack.PopByte(); AnalogInputs = stack.PopByte(); CounterInputs = stack.PopByte(); PwmOutputs = stack.PopByte(); WiresCount = stack.PopByte(); DevicesCount = stack.PopByte(); SensorsCount = stack.PopByte(); ResetPin = stack.PopByte(); }
public PinEvent(byte[] array, int startIndex = 0) { var stack = new SimpleStack(array, startIndex); _pin = stack.PopName(); _value = stack.PopInt32(); _isActive = stack.PopByte() == 1; }
public SensorRead(byte[] array) { var stack = new SimpleStack(array); Name = stack.PopName(); Time = stack.PopUInt32(); Value = stack.PopSingle(); }
public PinStatus(byte[] array, int start = 0) : this() { if (array == null || array.Length < start) return; var stack = new SimpleStack(array, start); Index = stack.PopByte(); Pin = stack.PopName(); Value = stack.PopUInt32(); }
public DeviceStatus(byte[] array, int start = 0) : this() { if (array == null || array.Length < start) return; var stack = new SimpleStack(array, start); Index = stack.PopByte(); Device = stack.PopName(); Status = stack.PopString(); }
public byte[] ToArray() { var stack = new SimpleStack(); stack.Push(Index); stack.PushName(Pin); stack.Push(Value); return stack.Data; }
public byte[] ToArray() { var stack = new SimpleStack(); stack.PushName(_device); stack.Push(_action); stack.Push(_values); return stack.Data; }
public byte[] ToArray() { var stack = new SimpleStack(); stack.PushName(_pin); stack.Push(_value); stack.Push((byte)(_isActive ? 1 : 0)); return stack.Data; }
public byte[] ToArray() { var stack = new SimpleStack(); stack.Push(Index); stack.PushName(Device); stack.Push(Status); return stack.Data; }
public byte[] ToArray() { var stack = new SimpleStack(); stack.PushName(_device); stack.Push(_event); stack.Push(_status); stack.Push(_time); stack.Push(_values); return stack.Data; }
public DeviceEvent(byte[] array, int startIndex = 0) { if (array != null) { var stack = new SimpleStack(array, startIndex); _device = stack.PopName(); _event = stack.PopString(); _status = stack.PopString(); _time = stack.PopUInt32(); _values = stack.PopArray(); } else { _device = string.Empty; _event = string.Empty; _status = string.Empty; _time = 0; _values = null; } }
public byte[] ToArray() { var stack = new SimpleStack(); stack.PushName(Name); stack.Push(Description); stack.Push(Location); stack.Push(Address); stack.Push(Type); stack.PushName(Hardware); stack.PushName(Version); stack.Push(DigitalInputs); stack.Push(DigitalOutputs); stack.Push(AnalogInputs); stack.Push(CounterInputs); stack.Push(PwmOutputs); stack.Push(WiresCount); stack.Push(DevicesCount); stack.Push(SensorsCount); //stack.Push(SupportedCommands); stack.Push(ResetPin); return stack.Data; }
/// <summary> /// HBus compatible constructor /// </summary> /// <param name="data"></param> /// <param name="index"></param> public DeviceInfo(byte[] data, int index = 0) : this() { var stack = new SimpleStack(data, index); Index = stack.PopByte(); Name = stack.PopName(); //Address = stack.PopAddress(); Description = stack.PopString(); Location = stack.PopString(); Class = stack.PopString(); Hardware = stack.PopString(); Version = stack.PopString(); Actions = stack.PopStringArray(); }
/// <summary> /// Serialize node status to byte array /// </summary> /// <returns>data stream (byte array)</returns> public byte[] ToArray() { var stack = new SimpleStack(); //Node global status stack.Push(Mask); stack.Push(Time); stack.Push((byte)NodeStatus); stack.Push((byte)BusStatus); stack.Push((byte)LastError); stack.Push(TotalErrors); stack.Push((byte)(Inputs!= null ? Inputs.Length : 0)); stack.Push((byte)(Outputs != null ? Outputs.Length : 0)); stack.Push((byte)(Analogs != null ? Analogs.Length : 0)); stack.Push((byte)(Counters != null ? Counters.Length : 0)); stack.Push((byte)(Pwms != null ? Pwms.Length : 0)); stack.Push((byte)(Devices != null ? Devices.Length : 0)); stack.Push((byte)(Sensors != null ? Sensors.Length : 0)); stack.PushName(LastActivatedInput); stack.PushName(LastActivatedOutput); //Inputs if ((Mask & 0x01) != 0 && Inputs != null && Inputs.Length > 0) foreach (var input in Inputs) stack.Push(input); //Outputs if ((Mask & 0x02) != 0 && Outputs != null && Outputs.Length > 0) foreach (var output in Outputs) stack.Push(output); //Analogs if ((Mask & 0x04) != 0 && Analogs != null && Analogs.Length > 0) foreach (var analog in Analogs) stack.Push(analog); //Counters if ((Mask & 0x08) != 0 && Counters != null && Counters.Length > 0) foreach (var counter in Counters) stack.Push(counter); //Pwms if ((Mask & 0x10) != 0 && Pwms != null && Pwms.Length > 0) foreach (var pwm in Pwms) stack.Push(pwm); //Devices if ((Mask & 0x20) != 0 && Devices != null && Devices.Length > 0) foreach (var device in Devices) stack.Push(device); //Sensors if ((Mask & 0x40) != 0 && Sensors != null && Sensors.Length > 0) foreach (var sensor in Sensors) stack.Push(sensor); return stack.Data; }
private IList<Wire> GetWires(IEnumerable<XElement> elements, Node node, BusController bus) { var wires = new List<Wire>(); foreach (var xwire in elements) { var input = xwire.Attribute("input").Value; var pin = node.Pins.FirstOrDefault(p => p.Name == input); if (pin == null) throw new WireException("Input pin not found"); var index = Convert.ToByte(xwire.Attribute("index").Value); var address = xwire.Attribute("address") != null && !string.IsNullOrEmpty(xwire.Attribute("address").Value) ? Address.Parse(Convert.ToUInt32(xwire.Attribute("address").Value)) : Address.Empty; var useInputData = xwire.Attribute("useInputData") != null && !string.IsNullOrEmpty(xwire.Attribute("useInputData").Value) && Convert.ToBoolean(xwire.Attribute("useInputData").Value); var cmdText = xwire.Attribute("command").Value.ToUpperInvariant(); byte cmd = 0; #region parse command name switch (cmdText) { case "PING": cmd = NodeCommands.CMD_PING; break; case "RESET": cmd = NodeCommands.CMD_RESET; break; case "READ_CONFIG": cmd = NodeCommands.CMD_READ_CONFIG; break; case "START": cmd = NodeCommands.CMD_START; break; case "STOP": cmd = NodeCommands.CMD_STOP; break; //Pins case "CHANGE_DIGITAL": cmd = NodeCommands.CMD_CHANGE_DIGITAL; break; case "TOGGLE_DIGITAL": cmd = NodeCommands.CMD_TOGGLE_DIGITAL; break; case "TIMED_DIGITAL": cmd = NodeCommands.CMD_TIMED_DIGITAL; break; case "DELAY_DIGITAL": cmd = NodeCommands.CMD_DELAY_DIGITAL; break; case "PULSE_DIGITAL": cmd = NodeCommands.CMD_PULSE_DIGITAL; break; case "CYCLE_DIGITAL": cmd = NodeCommands.CMD_CYCLE_DIGITAL; break; case "CHANGE_ALL_DIGITAL": cmd = NodeCommands.CMD_CHANGE_ALL_DIGITAL; break; case "CHANGE_PWM": cmd = NodeCommands.CMD_CHANGE_PWM; break; case "CHANGE_PIN": cmd = NodeCommands.CMD_CHANGE_PIN; break; case "DELAY_TOGGLE_DIGITAL": cmd = NodeCommands.CMD_DELAY_TOGGLE_DIGITAL; break; case "DELTA_PWM": cmd = NodeCommands.CMD_DELTA_PWM; break; case "FADE_PWM": cmd = NodeCommands.CMD_FADE_PWM; break; case "ACTIVATE": cmd = NodeCommands.CMD_ACTIVATE; break; case "DEACTIVATE": cmd = NodeCommands.CMD_DEACTIVATE; break; case "EXECUTE_DEVICE_ACTION": cmd = NodeCommands.CMD_EXECUTE_DEVICE_ACTION; break; case "PUSH_SENSOR_READ": cmd = NodeCommands.CMD_READ_SENSOR; break; } #endregion var dataText = xwire.Attribute("data") != null ? xwire.Attribute("data").Value : string.Empty; var data = Csv.CsvToList<byte>(dataText).ToArray(); //var trgText = xwire.Attribute("trigger") != null ? xwire.Attribute("trigger").Value : string.Empty; //var trgs = Csv.CsvToList<string>(trgText).ToArray(); //var trigger = WireTriggers.None; //foreach (var trg in trgs) //{ // trigger |= trg != null && Enum.IsDefined(typeof (WireTriggers), trg) // ? (WireTriggers) Enum.Parse(typeof (WireTriggers), trg) // : WireTriggers.None; //} var wire = new Wire(pin) { Index = index, Command = cmd, Address = address, UseInputData = useInputData, Parameters = data }; //Add wire trigger event //TODO configurable on Activate/deactivate/change wire.OnWireTriggered += (sender, args) => { var w = (Wire)sender; var stack = new SimpleStack(w.Parameters); if (w.UseInputData) { stack.Push(args.Source.Value); } if (w.Address == Address.Empty || w.Address == bus.Address) node.Execute(w.Address, w.Command, stack.Data); else bus.SendImmediate(w.Command, w.Address, stack.Data); }; wires.Add(wire); } Log.Debug(string.Format("Configured {0} wires", wires.Count)); return wires; }
public NodeStatusInfo(byte[] data) { var stack = new SimpleStack(data); //Bit Mask: //---------- //00: Inputs //01: Outputs //02: Analogs //04: Counters //08: Pwms //16: Devices //32: Sensors Mask = stack.PopByte(); //Node global status Time = stack.PopUInt32(); NodeStatus = (NodeStatusValues)stack.PopByte(); BusStatus = (BusStatus)stack.PopByte(); LastError = (NodeErrorCodes)stack.PopByte(); TotalErrors = stack.PopUInt32(); var size = stack.PopByte(); Inputs = size > 0 ? new byte[size] : null; size = stack.PopByte(); Outputs = size > 0 ? new byte[size] : null; size = stack.PopByte(); Analogs = size > 0 ? new ushort[size] : null; size = stack.PopByte(); Counters = size > 0 ? new uint[size] : null; size = stack.PopByte(); Pwms = size > 0 ? new ushort[size] : null; size = stack.PopByte(); Devices = size > 0 ? new string[size] : null; size = stack.PopByte(); Sensors = size > 0 ? new float[size] : null; LastActivatedInput = stack.PopName(); LastActivatedOutput = stack.PopName(); //Inputs if ((Mask & 0x01) != 0 && Inputs!=null) for (var i = 0; i < Inputs.Length; i++) Inputs[i] = stack.PopByte(); //Outputs if ((Mask & 0x02) != 0 && Outputs != null) for (var i = 0; i < Outputs.Length; i++) Outputs[i] = stack.PopByte(); //Analogs if ((Mask & 0x04) != 0 && Analogs != null) for (var i = 0; i < Analogs.Length; i++) Analogs[i] = stack.PopUInt16(); //Counters if ((Mask & 0x08) != 0 && Counters != null) for (var i = 0; i < Counters.Length; i++) Counters[i] = stack.PopUInt32(); //Pwms if ((Mask & 0x10) != 0 && Pwms != null) for (var i = 0; i < Pwms.Length; i++) Pwms[i] = stack.PopUInt16(); //Devices if ((Mask & 0x20) != 0 && Devices!= null) for (var i = 0; i < Devices.Length; i++) //Get status string Devices[i] = stack.PopString(); //Sensors if ((Mask & 0x40) != 0 && Sensors != null) for (var i = 0; i < Sensors.Length; i++) //Get last sensor read Sensors[i] = stack.PopSingle(); }
private bool OnCommandReceived(object sender, Message message, int port) { //if (Status.NodeStatus != NodeStatusValues.Active) return false; //Clear bus & node errors _bus.ClearErrors(); Status.LastError = 0; //Most common parameters var stack = new SimpleStack(message.Data); stack.ClearRead(); Log.Debug(string.Format("received command from node {0}", message.Source)); return Execute(message.Source, message.Command, message.Data); }
/// <summary> /// Execute node command /// </summary> /// <param name="source">Source of command</param> /// <param name="command">HBus command</param> /// <param name="datain">Command data</param> /// <returns>true if command is executed</returns> public bool Execute(Address source, byte command, byte[] datain) { try { byte index; int value; byte delay; byte width; string name; Pin pin; Sensor sensor; Device device; var stack = new SimpleStack(datain); var dataOut = new List<byte>(); var done = false; switch (command) { #region Bus commands case NodeCommands.CMD_PING: dataOut.AddRange(FixedString.ToArray(Name, HBusSettings.NameLength)); _bus.Payload = dataOut.ToArray(); done = true; break; #endregion #region Node commands case NodeCommands.CMD_RESET: index = stack.PopByte(); //1 = full reset Reset(index == 1); done = true; break; case NodeCommands.CMD_START: Start(); done = true; break; case NodeCommands.CMD_STOP: Stop(); done = true; break; case NodeCommands.CMD_FACTORY_DEFAULT: LoadConfiguration(true); done = true; break; case NodeCommands.CMD_READ_CONFIG: LoadConfiguration(false); done = true; break; case NodeCommands.CMD_WRITE_CONFIG: SaveConfiguration(); done = true; break; case NodeCommands.CMD_ADD_NODE_LISTENER: //index = stack.PopByte(); //mask //Add pin to subscriptions if (!_nodeSubscribers.ContainsKey(source)) { _nodeSubscribers.Add(source, 0); SubscribeAll(); done = true; } break; case NodeCommands.CMD_DELETE_NODE_LISTENER: if (_nodeSubscribers.ContainsKey(source)) { _nodeSubscribers.Remove(source); UnsubscribeAll(); done = true; } break; #endregion #region information commands case NodeCommands.CMD_READ_ALL: value = stack.PopByte(); //mask UpdateNodeStatus((byte)value); _bus.Payload = Status.ToArray(); done = true; break; case NodeCommands.CMD_GET_INFO: UpdateNodeInfo(); var array = NodeSerializer.Serialize(this); _bus.Payload = array; done = true; break; case NodeCommands.CMD_GET_NAME_INFO: //Subnode info name = stack.PopName(); var node = GetSubnode(name); if (node != null) { _bus.Payload = node.ToArray(); done = true; } break; #endregion #region General pin commands case NodeCommands.CMD_ACTIVATE: name = stack.PopName(); pin = GetPin(name); if (pin != null) { pin.Activate(); done = true; } break; case NodeCommands.CMD_DEACTIVATE: name = stack.PopName(); pin = GetPin(name); if (pin != null) { pin.Deactivate(); done = true; } break; case NodeCommands.CMD_SET_PIN: pin = new Pin(_hal, _scheduler); PinSerializer.DeSerialize(datain, ref pin); //pin = new Pin(datain, _hal, _scheduler); var oldPin = Pins.FirstOrDefault(p => p.Index == pin.Index); if (oldPin != null) Pins.Remove(oldPin); Pins.Add(pin); done = true; break; case NodeCommands.CMD_CONNECT: //var wire = new Wire(datain, this, _bus); var wire = new Wire(); WireSerializer.DeSerialize(datain, ref wire); wire.Input = Pins.FirstOrDefault(p => p.Name == wire.Input.Name); var oldWire = Wires.FirstOrDefault(w => w.Index == wire.Index); if (oldWire != null) Wires.Remove(oldWire); Wires.Add(wire); done = true; break; case NodeCommands.CMD_ADD_PIN_LISTENER: //Device name name = stack.PopName(); pin = GetPin(name); if (pin != null) { //Add pin to subscriptions if (!_pinSubscribers.ContainsKey(source + "." + name)) _pinSubscribers.Add(source + "." + name, pin); done = true; } break; case NodeCommands.CMD_DELETE_PIN_LISTENER: //Device name name = stack.PopName(); pin = GetPin(name); if (pin != null) { //Add pin to subscriptions if (_pinSubscribers.ContainsKey(source + "." + name)) _pinSubscribers.Remove(source + "." + name); done = true; } break; case NodeCommands.CMD_PUSH_PIN_EVENT: if (OnPinEvent != null) { OnPinEvent(source, new PinEvent(datain)); } done = true; break; #endregion #region Pins digital write commands case NodeCommands.CMD_CHANGE_ALL_DIGITAL: value = stack.PopByte(); foreach (var p in Pins) { p.Change(value); } done = true; break; case NodeCommands.CMD_CHANGE_DIGITAL: index = stack.PopByte(); value = stack.PopByte(); pin = GetPin(index, PinTypes.Output); if (pin != null) { pin.Change(value); done = true; } break; case NodeCommands.CMD_TOGGLE_DIGITAL: index = stack.PopByte(); pin = GetPin(index, PinTypes.Output); if (pin != null) { pin.Toggle(); done = true; } break; case NodeCommands.CMD_TIMED_DIGITAL: index = stack.PopByte(); width = stack.PopByte(); value = stack.PopByte(); pin = GetPin(index, PinTypes.Output); if (pin != null) { pin.TimedOutput(width, value); done = true; } break; case NodeCommands.CMD_DELAY_DIGITAL: index = stack.PopByte(); delay = stack.PopByte(); value = stack.PopByte(); pin = GetPin(index, PinTypes.Output); if (pin != null) { pin.DelayOutput(delay, value); done = true; } break; case NodeCommands.CMD_DELAY_TOGGLE_DIGITAL: index = stack.PopByte(); delay = stack.PopByte(); pin = GetPin(index, PinTypes.Output); if (pin != null) { pin.DelayToggle(delay); done = true; } break; case NodeCommands.CMD_PULSE_DIGITAL: index = stack.PopByte(); delay = stack.PopByte(); width = stack.PopByte(); value = stack.PopByte(); pin = GetPin(index, PinTypes.Output); if (pin != null) { pin.PulsedOutput(delay, width, value); done = true; } break; case NodeCommands.CMD_CYCLE_DIGITAL: index = stack.PopByte(); delay = stack.PopByte(); width = stack.PopByte(); value = stack.PopByte(); //cycles pin = GetPin(index, PinTypes.Output); if (pin != null) { pin.CycledOutput(delay, width, value); done = true; } break; #endregion #region Pins analog/pwm write commands case NodeCommands.CMD_CHANGE_PWM: index = stack.PopByte(); delay = stack.PopByte(); //high pulse width = stack.PopByte(); //total pulse pin = GetPin(index, PinTypes.Pwm); if (pin != null) { pin.ChangePwm(delay, width); done = true; } break; case NodeCommands.CMD_DELTA_PWM: index = stack.PopByte(); value = stack.PopInt16(); pin = GetPin(index, PinTypes.Pwm); if (pin != null) { pin.ChangeDelta(value); done = true; } break; case NodeCommands.CMD_FADE_PWM: index = stack.PopByte(); //type = (PinTypes)stack.PopByte(); var startValue = stack.PopUInt16(); var endValue = stack.PopUInt16(); value = stack.PopByte(); //steps delay = stack.PopByte(); pin = GetPin(index, PinTypes.Pwm); if (pin != null) { pin.Fade(startValue, endValue, (byte)value, delay); done = true; } break; case NodeCommands.CMD_CHANGE_PIN: name = stack.PopName(); value = stack.PopInt32(); pin = GetPin(name); if (pin != null) { pin.Change(value); done = true; } break; #endregion #region Pins read commands case NodeCommands.CMD_GET_PIN_INFO: index = stack.PopByte(); value = stack.PopByte(); pin = GetPin(index, (PinTypes)value); if (pin != null) { _bus.Payload = PinSerializer.Serialize(pin); done = true; } break; case NodeCommands.CMD_GET_CONNECT_INFO: index = stack.PopByte(); wire = Wires.FirstOrDefault(w => w.Index == index); if (wire != null) { array = WireSerializer.Serialize(wire); _bus.Payload = array; done = true; } break; case NodeCommands.CMD_READ_PIN: name = stack.PopName(); pin = GetPin(name); if (pin != null) { //Get pin value var evt = new PinEvent(name, pin.Read(), pin.IsActive()); _bus.Payload = evt.ToArray(); done = true; } break; case NodeCommands.CMD_READ_LAST_INPUT: dataOut.AddRange(FixedString.ToPaddedArray(Status.LastActivatedInput, HBusSettings.NameLength, ' ')); _bus.Payload = dataOut.ToArray(); done = true; break; case NodeCommands.CMD_READ_LAST_ACTIVE: dataOut.AddRange(FixedString.ToPaddedArray(Status.LastActivatedOutput, HBusSettings.NameLength, ' ')); _bus.Payload = dataOut.ToArray(); done = true; break; #endregion #region Device commands case NodeCommands.CMD_GET_DEVICE_INFO: index = stack.PopByte(); device = GetDevice(index); if (device != null) { array = DeviceSerializer.Serialize(device); _bus.Payload = array; done = true; } break; case NodeCommands.CMD_GET_DEVICE_STATUS: name = stack.PopName(); device = GetDevice(name); if (device != null) { var status = new DeviceStatus(device.Index, device.Name, device.Status); _bus.Payload = status.ToArray(); done = true; } break; case NodeCommands.CMD_EXECUTE_DEVICE_ACTION: //Device name var action = new DeviceAction(datain); device = GetDevice(action.Device); //Execute action if (device != null) { device.ExecuteAction(action); done = true; } break; case NodeCommands.CMD_ADD_DEVICE_LISTENER: //Device name name = stack.PopName(); device = GetDevice(name); //Execute action if (device != null) { if (!_deviceSubscribers.ContainsKey(source + "." + name)) _deviceSubscribers.Add(source + "." + name, device); done = true; } break; case NodeCommands.CMD_DELETE_DEVICE_LISTENER: //Device name name = stack.PopName(); device = GetDevice(name); //Execute action if (device != null) { if (_deviceSubscribers.ContainsKey(source + "." + name)) _deviceSubscribers.Remove(source + "." + name); done = true; } break; case NodeCommands.CMD_PUSH_DEVICE_EVENT: if (OnDeviceEvent != null) { var evt = new DeviceEvent(datain); OnDeviceEvent(source, evt); done = true; } break; #endregion #region Sensor commands case NodeCommands.CMD_GET_SENSOR_INFO: index = stack.PopByte(); sensor = GetSensor(index); if (sensor != null) { array = SensorSerializer.Serialize(sensor); _bus.Payload = array; done = true; } break; case NodeCommands.CMD_READ_SENSOR: //Sensor name name = stack.PopName(); sensor = GetSensor(name); if (sensor != null) { _bus.Payload = sensor.Read().ToArray(); done = true; } break; case NodeCommands.CMD_RESET_SENSOR: //Sensor name name = stack.PopName(); sensor = GetSensor(name); if (sensor != null) { sensor.Reset(); done = true; } break; case NodeCommands.CMD_ADD_SENSOR_LISTENER: //Sensor name name = stack.PopName(); var interval = stack.PopByte(); //interval var expire = stack.PopUInt16(); //Expires sensor = GetSensor(name); if (sensor != null) { if (_sensorSubscribers.All(s => s.Sensor != sensor)) _sensorSubscribers.Add(new SensorSubscriber(source, sensor, interval, expire)); done = true; } break; case NodeCommands.CMD_DELETE_SENSOR_LISTENER: //Sensor name name = stack.PopName(); sensor = GetSensor(name); if (sensor != null) { var sub = _sensorSubscribers.FirstOrDefault(s => s.Address == source); if (sub.Sensor != null) _sensorSubscribers.Remove(sub); done = true; } break; case NodeCommands.CMD_PUSH_SENSOR_READ: if (OnSensorRead != null) { OnSensorRead(source, new SensorRead(datain)); } done = true; break; #endregion #region Obolete / unsupported commands //case NodeCommands.CMD_MULTI_ACTIVATE: // //delay = stack.PopByte(); // //var names = stack.PopNames(); // //MultiActivateOutput(names, delay); // SetError(NodeErrorCodes.CommandNotSupported); // break; //case NodeCommands.CMD_READ_KEY: // //value = GetKeyPressed(); // //_bus.Payload = new[] { (byte)value }; // SetError(NodeErrorCodes.CommandNotSupported); // break; #endregion default: SetError(NodeErrorCodes.CommandNotSupported); break; } return done; } catch (Exception ex) { SetError(NodeErrorCodes.GenericError); Log.Error(string.Format("error occurred while processing command {0} for main node {1}", command, Name), ex); } return false; }
public HBusProcessor(BusController hbus) { _bus = hbus; _bus.CommandReceived += OnCommandReceived; _bus.AckReceived += OnAckReceived; _scheduler = Scheduler.GetScheduler(); _hbusEvents = new Dictionary<string, IList<Event>>(); //Event from ep source OnSourceEvent = (@event, point) => { if (@event.Channel != Channel && !string.IsNullOrEmpty(@event.Channel)) return; var address = !string.IsNullOrEmpty(@event.Address) ? Address.Parse(@event.Address) : Address.BroadcastAddress; var stack = new SimpleStack(); ////Create new page event list //if (!_hbusEvents.ContainsKey(@event.Subscriber)) // _hbusEvents.Add(@event.Subscriber, new List<Event>()); switch (@event.Name) { case "node-subscribe": _bus.SendCommand(NodeCommands.CMD_ADD_NODE_LISTENER, address); break; case "node-unsubscribe": _bus.SendCommand(NodeCommands.CMD_DELETE_NODE_LISTENER, address); break; case "pin-activate": stack.PushName(@event.Source); _bus.SendCommand(NodeCommands.CMD_ACTIVATE, address, stack.Data); break; case "pin-deactivate": stack.PushName(@event.Source); _bus.SendCommand(NodeCommands.CMD_DEACTIVATE, address, stack.Data); break; case "pin-subscribe": stack.PushName(@event.Source); _bus.SendCommand(NodeCommands.CMD_ADD_PIN_LISTENER, address, stack.Data); break; case "pin-unsubscribe": stack.PushName(@event.Source); _bus.SendCommand(NodeCommands.CMD_DELETE_PIN_LISTENER, address, stack.Data); break; case "device-subscribe": stack.PushName(@event.Source); _bus.SendCommand(NodeCommands.CMD_ADD_DEVICE_LISTENER, address, stack.Data); break; case "device-unsubscribe": stack.PushName(@event.Source); _bus.SendCommand(NodeCommands.CMD_DELETE_DEVICE_LISTENER, address, stack.Data); break; case "sensor-subscribe": //This is extracted only for explantion //@event.Data could be used as it is var interval = @event.Data[0]; var expires = (ushort) (@event.Data[2] << 8 + @event.Data[1]); stack.PushName(@event.Source); stack.Push(interval); stack.Push(expires); _bus.SendCommand(NodeCommands.CMD_ADD_SENSOR_LISTENER, address, stack.Data); break; case "sensor-unsubscribe": stack.PushName(@event.Source); _bus.SendCommand(NodeCommands.CMD_DELETE_SENSOR_LISTENER, address, stack.Data); break; case "sensor-read": stack.PushName(@event.Source); _bus.SendCommand(NodeCommands.CMD_READ_SENSOR, address, stack.Data); break; //TODO: other HBus commands default: if (@event.Name.IndexOf("device-") == 0) { //Send device action var devaction = new DeviceAction(@event.Source, @event.Name.Substring(7), @event.Data); _bus.SendCommand(NodeCommands.CMD_EXECUTE_DEVICE_ACTION, address, devaction.ToArray()); } break; } }; //Error from ep source OnSourceError = (exception, sender) => { Log.Error("Error from source endpoint", exception); }; //Close connection with ep source OnSourceClose = (sender) => { //Close HBus endpoint Stop(); Log.Debug("closed on source close"); }; }
/// <summary> /// Convert shared information /// to transmit to other devices /// </summary> /// <returns></returns> public byte[] ToArray() { var stack = new SimpleStack(); stack.Push(Index); stack.PushName(Name); //stack.Push(Address); stack.Push(Description); stack.Push(Location); stack.Push(Class); stack.Push(Hardware); stack.Push(Version); stack.PushStringArray(Actions); return stack.Data; }