/// <summary> /// Starts the database manager. This will call the ZigBeeNetworkDataStore to retrieve the list of nodes, and /// then read all the nodes from the store, adding them to the ZigBeeNetworkManager. /// </summary> public void Startup() { if (DataStore == null) { Log.Debug("Data store: Undefined so network is not restored."); return; } ISet <IeeeAddress> nodes = DataStore.ReadNetworkNodes(); foreach (IeeeAddress nodeAddress in nodes) { ZigBeeNode node = new ZigBeeNode(_networkManager, nodeAddress); ZigBeeNodeDao nodeDao = DataStore.ReadNode(nodeAddress); if (nodeDao == null) { Log.Debug("{IeeeAddress}: Data store: Node was not found in database.", nodeAddress); continue; } node.SetDao(nodeDao); Log.Debug("{IeeeAddress}: Data store: Node was restored.", nodeAddress); _networkManager.UpdateNode(node); } _nodesToSave = new BlockingCollection <ZigBeeNode>(); //The consumer task that process the nodes produced by the elapsed timers //This ensure all write are done using a single thread. Task.Factory.StartNew(WriteNodeLoop, TaskCreationOptions.LongRunning); _networkManager.AddNetworkNodeListener(this); }
protected void StartDiscovery(ZigBeeNode node) { ZigBeeNodeServiceDiscoverer nodeDiscoverer = new ZigBeeNodeServiceDiscoverer(_networkManager, node); _nodeDiscovery[node.IeeeAddress] = nodeDiscoverer; nodeDiscoverer.StartDiscovery(); }
public void NodeAdded(ZigBeeNode node) { Console.WriteLine("Node " + node.IeeeAddress + " added " + node); if (node.NetworkAddress != 0) { } }
public ZclOnOffClusterTest() { var node = new ZigBeeNode(); var endpoint = new ZigBeeEndpoint(node, 0); _cluster = new ZclOnOffCluster(endpoint); }
public void NodeAdded(ZigBeeNode node) { lock (_nodeDiscovery) { StartDiscoveryIfNecessary(node); } }
protected void StopDiscovery(ZigBeeNode node) { if (_nodeDiscovery.TryRemove(node.IeeeAddress, out ZigBeeNodeServiceDiscoverer discoverer)) { discoverer.StopDiscovery(); } }
public void TestSetIeeeAddress() { ZigBeeNode node = new ZigBeeNode(); node.IeeeAddress = new IeeeAddress("17880100dc880b"); Assert.Equal(new IeeeAddress("17880100dc880b"), node.IeeeAddress); }
/// <summary> /// Updates ZigBeeNode and adds it to the ZigBeeNetworkManager /// /// <param name="ieeeAddress">the <see cref="IeeeAddress"> of the newly announced node</param> /// <param name="networkAddress">the network address of the newly announced node</param> /// </summary> private void AddNode(IeeeAddress ieeeAddress, ushort networkAddress) { Log.Debug("{IeeeAddress}: NWK Discovery add node {NetworkAddress}", ieeeAddress, networkAddress); ZigBeeNode node = new ZigBeeNode(_networkManager, ieeeAddress, networkAddress); node.SetNodeState(ZigBeeNodeState.ONLINE); _networkManager.UpdateNode(node); }
/// <summary> /// Performs node service discovery. This discovers node level attributes such as the endpoints and /// descriptors, as well as updating routing and neighbor tables - as needed. /// /// If any of the tasks requested are already in the queue, they will not be added again. /// /// If the worker thread is not running, it will be started. /// /// <param name="newTasks">a set of <see cref="NodeDiscoveryTask"/>s to be performed</param> /// </summary> private async Task StartDiscoveryAsync(List <NodeDiscoveryTask> newTasks) { // Tasks are managed in a queue. The worker thread will only remove the task from the queue once the task is // complete. When no tasks are left in the queue, the worker thread will exit. lock (DiscoveryTasks) { Log.Debug("{IeeeAddress}: Node SVC Discovery: starting new tasks {NewTasks}", Node.IeeeAddress, newTasks); // Remove router/coordinator-only tasks if the device is possibly an end node. bool isPossibleEndDevice = IsPossibleEndDevice(); if (!_supportsManagementLqi || isPossibleEndDevice) { newTasks.Remove(NodeDiscoveryTask.NEIGHBORS); } if (!_supportsManagementRouting || isPossibleEndDevice) { newTasks.Remove(NodeDiscoveryTask.ROUTES); } // Make sure there are still tasks to perform if (newTasks.Count == 0) { Log.Debug("{IeeeAddress}: Node SVC Discovery: has no new tasks to perform", Node.IeeeAddress); return; } // Check the current list of tasks to decide if we need to start the worker // This prevents restarting if we didn't add new tasks, which might overload the system bool startWorker = DiscoveryTasks.Count == 0; //||(_futureTask == null); // Add new tasks, avoiding any duplication foreach (NodeDiscoveryTask newTask in newTasks) { if (!DiscoveryTasks.Contains(newTask)) { DiscoveryTasks.Enqueue(newTask); } } if (!startWorker) { Log.Debug("{IeeeAddress}: Node SVC Discovery: already scheduled or running", Node.IeeeAddress); } else { // Create a new node to store the data from this update. // We set the network address so that we can detect the change later if needed. _updatedNode = new ZigBeeNode(NetworkManager, Node.IeeeAddress, Node.NetworkAddress); LastDiscoveryStarted = DateTime.UtcNow; } } Log.Debug("{IeeeAddress}: Node SVC Discovery: scheduled {Task}", Node.IeeeAddress, DiscoveryTasks); await GetNodeServiceDiscoveryTask(); }
public void NodeRemoved(ZigBeeNode node) { Log.Debug("DISCOVERY Extension: Removing discoverer for {IeeeAddress}", node.IeeeAddress); if (_nodeDiscovery.TryRemove(node.IeeeAddress, out ZigBeeNodeServiceDiscoverer discoverer)) { StopDiscovery(node); } }
public void NodeUpdated(ZigBeeNode node) { if (DataStore == null) { return; } SaveNode(node); }
/// <summary> /// Creates the discovery class /// /// <param name="networkManager">the <see cref="ZigBeeNetworkManager"/> for the network</param> /// <param name="node">the <see cref="ZigBeeNode"/> whose services we want to discover</param> /// </summary> public ZigBeeNodeServiceDiscoverer(ZigBeeNetworkManager networkManager, ZigBeeNode node) { this.NetworkManager = networkManager; this.Node = node; _retryPeriod = DEFAULT_RETRY_PERIOD + new Random().Next(RETRY_RANDOM_TIME); _cancellationTokenSource = new CancellationTokenSource(); }
public void NodeRemoved(ZigBeeNode node) { if (DataStore == null) { return; } DataStore.RemoveNode(node.IeeeAddress); }
public void NodeAdded(ZigBeeNode node) { Console.WriteLine("Node " + node.IeeeAddress + " added " + node); //if (node.NetworkAddress != 0) //{ // ZclOnOffCluster onOff = new ZclOnOffCluster(node.GetEndpoint(0)); // onOff.ToggleCommand(); //} }
protected void StartDiscovery(ZigBeeNode node) { lock (_nodeDiscovery) { ZigBeeNodeServiceDiscoverer nodeDiscoverer = new ZigBeeNodeServiceDiscoverer(_networkManager, node); nodeDiscoverer.MeshUpdateTasks = MeshUpdateTasks; _nodeDiscovery[node.IeeeAddress] = nodeDiscoverer; nodeDiscoverer.StartDiscovery(); } }
public void NodeAdded(ZigBeeNode node) { foreach (ZigBeeEndpoint endpoint in node.GetEndpoints()) { if (endpoint.GetInputCluster(ZclIasZoneCluster.CLUSTER_ID) != null) { endpoint.AddApplication(new ZclIasZoneClient(networkManager, networkManager.LocalIeeeAddress, 0)); break; } } }
public void NodeAdded(ZigBeeNode node) { if (_nodeDiscovery.ContainsKey(node.IeeeAddress)) { return; } Log.Debug("DISCOVERY Extension: Adding discoverer for {IeeeAddress}", node.IeeeAddress); StartDiscovery(node); }
public void NodeUpdated(ZigBeeNode node) { if (node.NodeState == ZigBeeNodeState.ONLINE && !_nodeDiscovery.ContainsKey(node.IeeeAddress)) { // If the state is ONLINE, then ensure discovery is running StartDiscovery(node); } else if (node.NodeState != ZigBeeNodeState.ONLINE && _nodeDiscovery.ContainsKey(node.IeeeAddress)) { // If state is not ONLINE, then stop discovery StopDiscovery(node); } }
public void NodeAdded(ZigBeeNode node) { if (nodeDiscovery.ContainsKey(node.IeeeAddress)) { return; } _logger.Debug("DISCOVERY Extension: Adding discoverer for {IeeeAddress}", node.IeeeAddress); ZigBeeNodeServiceDiscoverer nodeDiscoverer = new ZigBeeNodeServiceDiscoverer(_networkManager, node); nodeDiscovery[node.IeeeAddress] = nodeDiscoverer; nodeDiscoverer.StartDiscovery(); }
public void NodeUpdated(ZigBeeNode node) { lock (_nodeDiscovery) { if (node.NodeState == ZigBeeNodeState.ONLINE && !_nodeDiscovery.ContainsKey(node.IeeeAddress)) { Log.Debug("{IeeeAddress}: DISCOVERY Extension: Adding discoverer for updated node", node.IeeeAddress); // If the state is ONLINE, then ensure discovery is running StartDiscovery(node); } else if (node.NodeState != ZigBeeNodeState.ONLINE && _nodeDiscovery.ContainsKey(node.IeeeAddress)) { // If state is not ONLINE, then stop discovery StopDiscovery(node); } } }
private void StartDiscoveryIfNecessary(ZigBeeNode node) { _nodeDiscovery.TryGetValue(node.IeeeAddress, out ZigBeeNodeServiceDiscoverer nodeDiscoverer); // either there is no node discoverer or it has finished its tasks unsuccessfully if (nodeDiscoverer == null || (nodeDiscoverer.IsFinished && !nodeDiscoverer.IsSuccessful)) { Log.Debug("{IeeeAddress}: DISCOVERY Extension: Adding discoverer for node", node.IeeeAddress); StartDiscovery(node); } else if (!nodeDiscoverer.IsFinished) { // kill old node discoverer and create a new one Log.Debug("{IeeeAddress}: DISCOVERY Extension: Creating new discoverer for node", node.IeeeAddress); StopDiscovery(node); StartDiscovery(node); } }
/** * Updates {@link ZigBeeNode} and adds it to the {@link ZigBeeNetworkManager} * * @param ieeeAddress the {@link IeeeAddress} of the newly announced node * @param networkAddress the network address of the newly announced node */ private void AddNode(IeeeAddress ieeeAddress, ushort networkAddress) { ZigBeeNode node = _networkManager.GetNode(ieeeAddress); if (node != null) { if (node.NetworkAddress != networkAddress) { _logger.Debug("{IeeeAddress}: Network address updated to {NetworkAddress}", ieeeAddress, networkAddress); } node.NetworkAddress = networkAddress; _networkManager.UpdateNode(node); return; } node = new ZigBeeNode(_networkManager, ieeeAddress); node.NetworkAddress = networkAddress; // Add the node to the network... _networkManager.AddNode(node); }
public void Deserialize(ZigBeeNetworkManager networkManager) { if (File.Exists(_filename) == false) { return; } List <ZigBeeNodeDao> nodes = JsonConvert.DeserializeObject <List <ZigBeeNodeDao> >(File.ReadAllText(_filename)); if (nodes == null) { return; } foreach (var nodeDao in nodes) { ZigBeeNode node = new ZigBeeNode(networkManager, new IeeeAddress(nodeDao.IeeeAddress)); node.SetDao(nodeDao); networkManager.AddNode(node); } }
private void SaveNode(ZigBeeNode node) { int deferredDelay = _deferredWriteTime; lock (_deferredWriteTimers) { DeferedWritetimer timer; if (_deferredWriteTimers.TryGetValue(node.IeeeAddress, out timer)) { if (DateTime.Now - timer.CreatedTime > TimeSpan.FromMilliseconds(_deferredWriteTimeout)) { Log.Debug("{IeeeAddress}: Data store: Maximum deferred time reached.", node.IeeeAddress); // Run the write immediately. deferredDelay = 1; } timer.Interval = deferredDelay; timer.Start(); } else { // First deferred write - save the time timer = new DeferedWritetimer(); timer.Node = node; timer.CreatedTime = DateTime.Now; timer.AutoReset = false; timer.Interval = deferredDelay; timer.Elapsed += new ElapsedEventHandler(OnDeferedWriteTimerElapsedEvent); _deferredWriteTimers.TryAdd(node.IeeeAddress, timer); timer.Start(); } Log.Debug("{IeeeAddress}: Data store: Deferring write for {deferredDelay}ms.", node.IeeeAddress, deferredDelay); } }
public void NodeUpdated(ZigBeeNode node) { }
public void NodeRemoved(ZigBeeNode node) { Log.Debug("{IeeeAddress}: DISCOVERY Extension: Removing discoverer", node.IeeeAddress); StopDiscovery(node); }
public void NodeRemoved(ZigBeeNode node) { _logger.Debug("DISCOVERY Extension: Removing discoverer for {IeeeAddress}", node.IeeeAddress); nodeDiscovery.TryRemove(node.IeeeAddress, out ZigBeeNodeServiceDiscoverer ignored); }
public void NodeUpdated(ZigBeeNode node) { // Not used }
public void NodeRemoved(ZigBeeNode node) { }
static void Main(string[] args) { _nodes = new List <ZigBeeNode>(); // Configure Serilog Log.Logger = new LoggerConfiguration() .MinimumLevel.Debug() .WriteTo.Console() .CreateLogger(); try { TransportConfig transportOptions = new TransportConfig(); Console.Write("Please enter your COM Port: "); var port = Console.ReadLine(); ZigBeeSerialPort zigbeePort = new ZigBeeSerialPort(port); IZigBeeTransportTransmit dongle = new ZigBeeDongleTiCc2531(zigbeePort); ZigBeeNetworkManager networkManager = new ZigBeeNetworkManager(dongle); ZigBeeDiscoveryExtension discoveryExtension = new ZigBeeDiscoveryExtension(); discoveryExtension.setUpdatePeriod(60); networkManager.AddExtension(discoveryExtension); // Initialise the network networkManager.Initialize(); networkManager.AddCommandListener(new ConsoleCommandListener()); networkManager.AddNetworkNodeListener(new ConsoleNetworkNodeListener()); Log.Logger.Information("PAN ID: {PanId}", networkManager.ZigBeePanId); Log.Logger.Information("Extended PAN ID: {ExtendenPanId}", networkManager.ZigBeeExtendedPanId); Log.Logger.Information("Channel: {Channel}", networkManager.ZigbeeChannel); byte channel = 11; byte pan = 1; ExtendedPanId extendedPan = new ExtendedPanId(); ZigBeeKey nwkKey = ZigBeeKey.CreateRandom(); ZigBeeKey linkKey = new ZigBeeKey(new byte[] { 0x5A, 0x69, 0x67, 0x42, 0x65, 0x65, 0x41, 0x6C, 0x6C, 0x69, 0x61, 0x6E, 0x63, 0x65, 0x30, 0x39 }); Console.WriteLine("*** Resetting network"); Console.WriteLine(" * Channel = " + channel); Console.WriteLine(" * PAN ID = " + pan); Console.WriteLine(" * Extended PAN ID = " + extendedPan); Console.WriteLine(" * Link Key = " + linkKey); networkManager.SetZigBeeChannel((ZigBeeChannel)channel); networkManager.SetZigBeePanId(pan); networkManager.SetZigBeeExtendedPanId(extendedPan); networkManager.SetZigBeeNetworkKey(nwkKey); networkManager.SetZigBeeLinkKey(linkKey); transportOptions.AddOption(TransportConfigOption.TRUST_CENTRE_LINK_KEY, new ZigBeeKey(new byte[] { 0x5A, 0x69, 0x67, 0x42, 0x65, 0x65, 0x41, 0x6C, 0x6C, 0x69, 0x61, 0x6E, 0x63, 0x65, 0x30, 0x39 })); dongle.UpdateTransportConfig(transportOptions); networkManager.AddSupportedCluster(0x06); ZigBeeStatus startupSucceded = networkManager.Startup(false); if (startupSucceded == ZigBeeStatus.SUCCESS) { Log.Logger.Information("ZigBee console starting up ... [OK]"); } else { Log.Logger.Information("ZigBee console starting up ... [FAIL]"); return; } ZigBeeNode coord = networkManager.GetNode(0); coord.PermitJoin(true); Console.WriteLine("Joining enabled..."); string cmd = Console.ReadLine(); while (cmd != "exit") { if (cmd == "toggle") { Console.WriteLine("Destination Address: "); string nwkAddr = Console.ReadLine(); if (ushort.TryParse(nwkAddr, out ushort addr)) { var node = networkManager.GetNode(addr); if (node != null) { ZigBeeEndpoint ep = new ZigBeeEndpoint(node, 0); node.AddEndpoint(ep); ZclOnOffCluster onOff = new ZclOnOffCluster(node.GetEndpoint(0)); onOff.ToggleCommand(); } } } cmd = Console.ReadLine(); } } catch (Exception ex) { Console.WriteLine(ex.ToString()); } }