/// <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());
}
}
