/*****************************************************************************************************/
static void StartActivity()
{
// Bacnet on UDP/IP/Ethernet
// to bind to a specific network interface such as 100.75.35.6
// bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false, false, 1472, "100.75.35.6"));
// otherwise the default interface is open ... sometimes OK, sometimes not !
bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false));
// Or Bacnet Ethernet
// bacnet_client = new BacnetClient(new BacnetEthernetProtocolTransport("Connexion au réseau local"));
// Or Bacnet on IPV6, default interface
// bacnet_client = new BacnetClient(new BacnetIpV6UdpProtocolTransport(0xBAC0));
// If BacnetTransportSerial.cs is added to this project one can use for instance :
// Bacnet Mstp on COM4 à 38400 bps, own master id 8
// m_bacnet_client = new BacnetClient(new BacnetMstpProtocolTransport("COM4", 38400, 8);
bacnet_client.Start(); // go
// Send WhoIs in order to get back all the Iam responses :
bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
bacnet_client.WhoIs();
/* Optional Remote Registration as A Foreign Device on a BBMD at @192.168.1.1 on the default 0xBAC0 port
*
* bacnet_client.RegisterAsForeignDevice("192.168.1.1", 60);
* Thread.Sleep(20);
* bacnet_client.RemoteWhoIs("192.168.1.1");
*/
}
/*****************************************************************************************************/
static void StartActivity()
{
// Bacnet on UDP/IP/Ethernet
bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false));
// or Bacnet Mstp on COM4 à 38400 bps, own master id 8
// m_bacnet_client = new BacnetClient(new BacnetMstpProtocolTransport("COM4", 38400, 8);
// Or Bacnet Ethernet
// bacnet_client = new BacnetClient(new BacnetEthernetProtocolTransport("Connexion au réseau local"));
// Or Bacnet on IPV6
// bacnet_client = new BacnetClient(new BacnetIpV6UdpProtocolTransport(0xBAC0));
bacnet_client.Start(); // go
// Send WhoIs in order to get back all the Iam responses :
bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
bacnet_client.WhoIs();
/* Optional Remote Registration as A Foreign Device on a BBMD at @192.168.1.1 on the default 0xBAC0 port
*
* bacnet_client.RegisterAsForeignDevice("192.168.1.1", 60);
* Thread.Sleep(20);
* bacnet_client.RemoteWhoIs("192.168.1.1");
*/
}
/*****************************************************************************************************/
static void StartActivity()
{
using (var loggerFactory = LoggerFactory.Create(b =>
{
b.AddConsole(c =>
{
c.TimestampFormat = "[yyyy-MM-dd HH:mm:ss] ";
});
}))
{
// Bacnet on UDP/IP/Ethernet
bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(port: 0xBAC0, loggerFactory: loggerFactory, useExclusivePort: false), loggerFactory: loggerFactory);
}
// or Bacnet Mstp on COM4 à 38400 bps, own master id 8
// m_bacnet_client = new BacnetClient(new BacnetMstpProtocolTransport("COM4", 38400, 8);
// Or Bacnet Ethernet
// bacnet_client = new BacnetClient(new BacnetEthernetProtocolTransport("Connexion au réseau local"));
// Or Bacnet on IPV6
// bacnet_client = new BacnetClient(new BacnetIpV6UdpProtocolTransport(0xBAC0));
bacnet_client.Start(); // go
// Send WhoIs in order to get back all the Iam responses :
bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
bacnet_client.WhoIs();
/* Optional Remote Registration as A Foreign Device on a BBMD at @192.168.1.1 on the default 0xBAC0 port
*
* bacnet_client.RegisterAsForeignDevice("192.168.1.1", 60);
* Thread.Sleep(20);
* bacnet_client.RemoteWhoIs("192.168.1.1");
*/
}
/*****************************************************************************************************/
static void StartActivity()
{
// Load the device descriptor from the embedded resource file
// Get myId as own device id
m_storage = DeviceStorage.Load("BasicServer.DeviceDescriptor.xml");
var transport = new BacnetIpUdpProtocolTransport(0xBAC0, false);
transport.Log = new ConsoleLogger();
// Bacnet on UDP/IP/Ethernet
bacnet_client = new BacnetClient(transport);
bacnet_client.Log = new ConsoleLogger();
// or Bacnet Mstp on COM4 à 38400 bps, own master id 8
// m_bacnet_client = new BacnetClient(new BacnetMstpProtocolTransport("COM4", 38400, 8);
// Or Bacnet Ethernet
// bacnet_client = new BacnetClient(new BacnetEthernetProtocolTransport("Connexion au réseau local"));
// Or Bacnet on IPV6
// bacnet_client = new BacnetClient(new BacnetIpV6UdpProtocolTransport(0xBAC0));
bacnet_client.OnWhoIs += new BacnetClient.WhoIsHandler(handler_OnWhoIs);
bacnet_client.OnIam += new BacnetClient.IamHandler(bacnet_client_OnIam);
bacnet_client.OnReadPropertyRequest += new BacnetClient.ReadPropertyRequestHandler(handler_OnReadPropertyRequest);
bacnet_client.OnReadPropertyMultipleRequest += new BacnetClient.ReadPropertyMultipleRequestHandler(handler_OnReadPropertyMultipleRequest);
bacnet_client.OnWritePropertyRequest += new BacnetClient.WritePropertyRequestHandler(handler_OnWritePropertyRequest);
bacnet_client.Start(); // go
// Send Iam
bacnet_client.Iam(m_storage.DeviceId, new BacnetSegmentations());
bacnet_client.WhoIs();
}
static void Main(string[] args)
{
Bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(47808));
Bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
Bacnet_client.Start();
Bacnet_client.WhoIs();
Console.Read();
Console.WriteLine("Begin Scan Device");
foreach (var device in DevicesList)
{
var count = GetDeviceArrayIndexCount(device);
ScanPointsBatch(device, count);
}
foreach (var device in DevicesList)
{
System.IO.File.WriteAllText($"{device.DeviceId}.json", Newtonsoft.Json.JsonConvert.SerializeObject(device));
}
Console.WriteLine("Begin Scan Properties");
foreach (var device in DevicesList)
{
ScanSubProperties(device);
}
foreach (var device in DevicesList)
{
System.IO.File.WriteAllText($"{device.DeviceId}pppp.json", Newtonsoft.Json.JsonConvert.SerializeObject(device));
}
Console.WriteLine("Scan Finished");
}
private static void Main()
{
var transport = new BacnetIpUdpProtocolTransport(0xBAC0, true);
var client = new BacnetClient(transport);
client.OnIam += OnIAm;
client.Start();
client.WhoIs();
Console.ReadLine();
}
protected override void OnStart()
{
base.OnStart();
tv.Text = "";
bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
// Send WhoIs in order to get back all the Iam responses :
bacnet_client.WhoIs();
}
/*****************************************************************************************************/
static void StartActivity()
{
// Bacnet on UDP/IP/Ethernet
bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false));
// or Bacnet Mstp on COM4 à 38400 bps, own master id 8 : BacnetTransportSerial.cs must be added to this project
// m_bacnet_client = new BacnetClient(new BacnetMstpProtocolTransport("COM4", 38400, 8);
bacnet_client.Start(); // go
// Send WhoIs in order to get back all the Iam responses :
bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
bacnet_client.WhoIs();
}
/// <summary>
/// Start bacnet client and setup handler
/// </summary>
static void StartBACnetServerActivity()
{
//// Bacnet on UDP/IP/Ethernet
moBacnetClient = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false));
//// or Bacnet Mstp on COM4 à 38400 bps, own master id 8
//// m_bacnet_client = new BacnetClient(new BacnetMstpProtocolTransport("COM4", 38400, 8);
moBacnetClient.Start(); // go
//// Send WhoIs in order to get back all the Iam responses :
moBacnetClient.OnIam += new BacnetClient.IamHandler(handler_OnIam);
moBacnetClient.WhoIs();
}
public static void StartActivity()
{
// Bacnet on UDP/IP/Ethernet
bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false), 3000, 3);
// or Bacnet Mstp on COM4 à 38400 bps, own master id 8
// m_bacnet_client = new BacnetClient(new BacnetMstpProtocolTransport("COM4", 38400, 8);
// Or Bacnet Ethernet
// bacnet_client = new BacnetClient(new BacnetEthernetProtocolTransport("Connexion au réseau local"));
bacnet_client.Start();//go
// Send WhoIs in order to get back all the Iam responses :
bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
bacnet_client.WhoIs();
}
private void BACnetControl_Load(object sender, EventArgs e)
{
Bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(47808, false));
Bacnet_client.OnIam -= new BacnetClient.IamHandler(handler_OnIam);
Bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
Bacnet_client.Start();
Bacnet_client.WhoIs();
Task.Run(async() =>
{
for (int i = 0; i < 10; i++)
{
await Task.Delay(100);
Log($"等待扫描...[{9 - i}]");
}
Scan();
});
}
public static void StartActivity(DeviceObject _device)
{
deviceId = _device.PROP_OBJECT_IDENTIFIER.Instance;
device = _device;
using (var loggerFactory = LoggerFactory.Create(b =>
{
b.AddConsole(c =>
{
c.TimestampFormat = "[yyyy-MM-dd HH:mm:ss] ";
});
}))
{
// Bacnet on UDP/IP/Ethernet
bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, loggerFactory: loggerFactory), loggerFactory: loggerFactory);
}
bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
bacnet_client.OnReadPropertyRequest += new BacnetClient.ReadPropertyRequestHandler(handler_OnReadPropertyRequest);
bacnet_client.OnReadPropertyMultipleRequest += new BacnetClient.ReadPropertyMultipleRequestHandler(handler_OnReadPropertyMultipleRequest);
bacnet_client.OnWritePropertyRequest += new BacnetClient.WritePropertyRequestHandler(handler_OnWritePropertyRequest);
bacnet_client.OnSubscribeCOV += new BacnetClient.SubscribeCOVRequestHandler(handler_OnSubscribeCOV);
bacnet_client.OnSubscribeCOVProperty += new BacnetClient.SubscribeCOVPropertyRequestHandler(handler_OnSubscribeCOVProperty);
bacnet_client.OnReadRange += new BacnetClient.ReadRangeHandler(handler_OnReadRange);
bacnet_client.OnAtomicWriteFileRequest += new BacnetClient.AtomicWriteFileRequestHandler(handler_OnAtomicWriteFileRequest);
bacnet_client.OnAtomicReadFileRequest += new BacnetClient.AtomicReadFileRequestHandler(handler_OnAtomicReadFileRequest);
// A sample to shows CreateObject & DeleteObject
bacnet_client.OnCreateObjectRequest += new BacnetClient.CreateObjectRequestHandler(handler_OnCreateObjectRequest);
device.m_PROP_PROTOCOL_SERVICES_SUPPORTED = device.m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_CREATE_OBJECT, true);
bacnet_client.OnDeleteObjectRequest += new BacnetClient.DeleteObjectRequestHandler(handler_OnDeleteObjectRequest);
device.m_PROP_PROTOCOL_SERVICES_SUPPORTED = device.m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_DELETE_OBJECT, true);
BaCSharpObject.OnExternalCOVNotify += new BaCSharpObject.WriteNotificationCallbackHandler(handler_OnCOVManagementNotify);
bacnet_client.Start(); // go
// Send Iam
bacnet_client.Iam(deviceId, new BacnetSegmentations());
bacnet_client.OnWhoIs += new BacnetClient.WhoIsHandler(handler_OnWhoIs);
if ((_device.FindBacnetObjectType(BacnetObjectTypes.OBJECT_NOTIFICATION_CLASS)) || (_device.FindBacnetObjectType(BacnetObjectTypes.OBJECT_SCHEDULE)))
{
bacnet_client.WhoIs(); // Send WhoIs : needed BY Notification & Schedule for deviceId<->IP endpoint
device.SetIpEndpoint(bacnet_client); // Register the endpoint for IP Notification usage with IP:Port
}
}
/// <summary>
/// InIt bacnet and UI
/// </summary>
public LutronLightFloor()
{
InitializeComponent();
//// Bacnet on UDP/IP/Ethernet
moBacnetClient = new BacnetClient(new BacnetIpUdpProtocolTransport(47808, false));// (0xBAC0, false));
//// Below 2 are needed for alarm event
moBacnetClient.OnEventNotify += new BacnetClient.EventNotificationCallbackHandler(handler_OnEventNotify);
moBacnetClient.OnWhoIs += new BacnetClient.WhoIsHandler(handler_OnWhoIs);
moBacnetClient.OnCreateObjectRequest += new BacnetClient.CreateObjectRequestHandler(handler_OnCreateObjectRequest);
moBacnetClient.Start(); // go
moBacnetClient.WhoIs(); // go
FillDropDown();
FillAvailableDevicesForSchedule();
}
public void StartActivity(DeviceObject _device)
{
deviceId = _device.PROP_OBJECT_IDENTIFIER.instance;
device = _device;
// Bacnet on UDP/IP/Ethernet
bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false));
bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
bacnet_client.OnReadPropertyRequest += new BacnetClient.ReadPropertyRequestHandler(handler_OnReadPropertyRequest);
bacnet_client.OnReadPropertyMultipleRequest += new BacnetClient.ReadPropertyMultipleRequestHandler(handler_OnReadPropertyMultipleRequest);
bacnet_client.OnWritePropertyRequest += new BacnetClient.WritePropertyRequestHandler(handler_OnWritePropertyRequest);
bacnet_client.OnSubscribeCOV += new BacnetClient.SubscribeCOVRequestHandler(handler_OnSubscribeCOV);
bacnet_client.OnSubscribeCOVProperty += new BacnetClient.SubscribeCOVPropertyRequestHandler(handler_OnSubscribeCOVProperty);
bacnet_client.OnReadRange += new BacnetClient.ReadRangeHandler(handler_OnReadRange);
// A sample to shows CreateObject & DeleteObject
bacnet_client.OnCreateObjectRequest += new BacnetClient.CreateObjectRequestHandler(handler_OnCreateObjectRequest);
device.m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_CREATE_OBJECT, true);
bacnet_client.OnDeleteObjectRequest += new BacnetClient.DeleteObjectRequestHandler(handler_OnDeleteObjectRequest);
device.m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_DELETE_OBJECT, true);
BaCSharpObject.OnExternalCOVNotify += new BaCSharpObject.WriteNotificationCallbackHandler(handler_OnCOVManagementNotify);
try
{
bacnet_client.Start(); // go
// Send Iam
bacnet_client.Iam(deviceId, BacnetSegmentations.SEGMENTATION_BOTH, 61440);
bacnet_client.OnWhoIs += new BacnetClient.WhoIsHandler(handler_OnWhoIs);
if ((_device.FindBacnetObjectType(BacnetObjectTypes.OBJECT_NOTIFICATION_CLASS)) || (_device.FindBacnetObjectType(BacnetObjectTypes.OBJECT_SCHEDULE)))
{
bacnet_client.WhoIs(); // Send WhoIs : needed BY Notification & Schedule for deviceId<->IP endpoint
device.SetIpEndpoint(bacnet_client); // Register the endpoint for IP Notification usage with IP:Port
}
}
catch
{
if (Environment.UserInteractive)
{
Console.WriteLine("\nSocket Error, Udp Port already in used in exclusive mode ?");
}
}
}
private void button1_Click_1(object sender, EventArgs e)
{
txt_msgList.Text = string.Empty;
button1.Enabled = false;
devicesList = new List <BacNode>();
listBox1.Items.Clear();
Bacnet_client.WhoIs();
Task.Run(async() =>
{
//Log("准备扫描...");
for (int i = 0; i < 10; i++)
{
await Task.Delay(100);
Log($"等待扫描...[{9 - i}]");
}
Scan();
button1.Enabled = true;
});
}
private static void Main()
{
using (var loggerFactory = LoggerFactory.Create(b =>
{
b.AddConsole(c =>
{
c.TimestampFormat = "[yyyy-MM-dd HH:mm:ss] ";
});
}))
{
var transport = new BacnetIpUdpProtocolTransport(port: 0xBAC0, loggerFactory: loggerFactory, useExclusivePort: true);
var client = new BacnetClient(transport, loggerFactory: loggerFactory);
client.OnIam += OnIAm;
client.Start();
client.WhoIs();
Console.ReadLine();
}
}
private void InitCOVClient_Click(object sender, RoutedEventArgs e)
{
UiLogItem("Init Client");
var selectedLocalHost = (LocalHostItem)AdapterList.SelectedItem;
if (selectedLocalHost == null)
{
UiLogItem("Please select an address / adapter.");
return;
}
bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false, false, 1472, selectedLocalHost.LocalHost.CanonicalName), 1000, 3);
bacnet_client.Start();
// Send WhoIs in order to get back all the Iam responses :
bacnet_client.OnIam += handler_OnIam;
bacnet_client.OnCOVNotification += handler_OnCOVNotification;
bacnet_client.WhoIs();
}
public void Run(IBackgroundTaskInstance taskInstance)
{
this.m_backgroundTaskDeferral = taskInstance.GetDeferral();
taskInstance.Canceled += TaskInstance_Canceled;
this.m_azureDeviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, TransportType.Amqp);
// Set-up COV Subscription - Create a timer that run each second and changes the value
subscriptionRenewalTimer = ThreadPoolTimer.CreatePeriodicTimer(subscriptionRenewalTimer_Tick, TimeSpan.FromSeconds(Subscriptions_ReplacementPollingPeriod / 2));
m_bacnetClient = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false, false, 1472, "192.168.1.117"), 1000, 3);
m_bacnetClient.Start();
// Send WhoIs in order to get back all the Iam responses :
m_bacnetClient.OnIam += handler_OnIam;
m_bacnetClient.OnCOVNotification += handler_OnCOVNotification;
m_bacnetClient.WhoIs();
ThreadPoolTimer.CreateTimer(DelayLoadSubscriptions, TimeSpan.FromSeconds(5));
}
private static void StartActivity()
{
m_storage = DeviceStorage.Load("Ths_BTLServer.DeviceDescriptor.xml", null);
m_storage.ChangeOfValue += new DeviceStorage.ChangeOfValueHandler(Program.m_storage_ChangeOfValue);
m_subscriptions = new Dictionary <BacnetObjectId, List <Subscription> >();
bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false));
bacnet_client.OnWhoIs += new BacnetClient.WhoIsHandler(Program.handler_OnWhoIs);
bacnet_client.OnIam += new BacnetClient.IamHandler(bacnet_client_OnIam);
bacnet_client.OnWhoHas += new BacnetClient.WhoHasHandler(Program.bacnet_client_OnWhoHas);
bacnet_client.OnReadPropertyRequest += new BacnetClient.ReadPropertyRequestHandler(Program.handler_OnReadPropertyRequest);
bacnet_client.OnReadPropertyMultipleRequest += new BacnetClient.ReadPropertyMultipleRequestHandler(Program.handler_OnReadPropertyMultipleRequest);
bacnet_client.OnWritePropertyRequest += new BacnetClient.WritePropertyRequestHandler(Program.handler_OnWritePropertyRequest);
bacnet_client.OnSubscribeCOV += new BacnetClient.SubscribeCOVRequestHandler(Program.bacnet_client_OnSubscribeCOV);
bacnet_client.OnSubscribeCOVProperty += new BacnetClient.SubscribeCOVPropertyRequestHandler(Program.bacnet_client_OnSubscribeCOVProperty);
bacnet_client.Retries = 10;
bacnet_client.Start();
uint deviceId = m_storage.DeviceId;
bacnet_client.WhoIs(-1, -1, null);
bacnet_client.Iam(m_storage.DeviceId, BacnetSegmentations.SEGMENTATION_BOTH);
}
/*****************************************************************************************************/
private async void StartActivity()
{
// Bacnet on UDP/IP/Ethernet
//bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false));
// Replaced ConnectionString for UDP local adapter
// bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false, false, 1472, "192.168.127.1"), 1000, 3);
bacnet_client = new BacnetClient(new BACNetLib.IO.BACnet.BacnetIpUdpProtocolTransport(0xBAC0, false, false, 1472, "192.168.1.21"), 1000, 3);
// or Bacnet Mstp on COM4 à 38400 bps, own master id 8
// m_bacnet_client = new BacnetClient(new BacnetMstpProtocolTransport("COM4", 38400, 8);
// Or Bacnet Ethernet
// bacnet_client = new BacnetClient(new BacnetEthernetProtocolTransport("Connexion au réseau local"));
// Or Bacnet on IPV6
// bacnet_client = new BacnetClient(new BacnetIpV6UdpProtocolTransport(0xBAC0));
bacnet_client.Start(); // go
// Send WhoIs in order to get back all the Iam responses :
bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
bacnet_client.WhoIs();
await PutTaskDelay();
}
public static void Start()
{
Config();
Stop();
if (bacnetClient == null)
{
// Bacnet on UDP/IP/Ethernet
bacnetClient = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false));
// or Bacnet Mstp on COM4 à 38400 bps, own master id 8
// m_bacnet_client = new BacnetClient(new BacnetMstpProtocolTransport("COM4", 38400, 8);
// Or Bacnet Ethernet
// bacnetClient = new BacnetClient(new BacnetEthernetProtocolTransport("Connexion au réseau local"));
// Or Bacnet on IPV6
// bacnetClient = new BacnetClient(new BacnetIpV6UdpProtocolTransport(0xBAC0));
}
bacnetClient.OnIam += Handler_OnIam;
bacnetClient.Start();
bacnetClient.WhoIs();
LogHelper.Log("bacnetClient start IpUdpProtocol 0xBAC0: " + bacnetClient.ToString());
}
/// <summary>
/// Start Bacnet protocol.
/// </summary>
public static void StartBackNetService()
{
if (bacNetClient == null)
{
BacnetIpUdpProtocolTransport newPort = new BacnetIpUdpProtocolTransport(0xBAC0, false);
bacNetClient = new BacnetClient(newPort);
//bacNetClient.Dispose();
// Thread.Sleep(1000);
bacNetClient.Start();
bacNetClient.OnIam += new BacnetClient.IamHandler(BacNetService.Handler_OmIam);
bacNetClient.OnWhoIs += new BacnetClient.WhoIsHandler(BacNetService.handler_OnWhoIs);
bacNetClient.WhoIs();
}
else
{
bacNetClient.OnIam -= new BacnetClient.IamHandler(BacNetService.Handler_OmIam);
bacNetClient.OnWhoIs -= new BacnetClient.WhoIsHandler(BacNetService.handler_OnWhoIs);
}
Thread.Sleep(5000);
}
/*****************************************************************************************************/
static void StartActivity()
{
using (var loggerFactory = LoggerFactory.Create(b =>
{
b.AddConsole(c =>
{
c.TimestampFormat = "[yyyy-MM-dd HH:mm:ss] ";
});
}))
{
// Bacnet on UDP/IP/Ethernet
bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, loggerFactory: loggerFactory), loggerFactory: loggerFactory);
}
// or Bacnet Mstp on COM4 à 38400 bps, own master id 8
// m_bacnet_client = new BacnetClient(new BacnetMstpProtocolTransport("COM4", 38400, 8);
bacnet_client.Start(); // go
// Send WhoIs in order to get back all the Iam responses :
bacnet_client.OnIam += new BacnetClient.IamHandler(handler_OnIam);
bacnet_client.WhoIs();
}
public void GetDevices()
{
try
{
//var bne = new BACnetNetworkEvents(this);
//start BACnet
BacnetClient.ProposedWindowSize = Yabe.Properties.Settings.Default.Segments_ProposedWindowSize;
BacnetClient.Retries = (int)Yabe.Properties.Settings.Default.DefaultRetries;
BacnetClient.Timeout = (int)Yabe.Properties.Settings.Default.DefaultTimeout;
BacnetClient.MaxSegments = BacnetClient.GetSegmentsCount(Yabe.Properties.Settings.Default.Segments_Max);
if (Yabe.Properties.Settings.Default.YabeDeviceId >= 0) // If Yabe get a Device id
{
if (BACnetGlobalNetwork.m_storage == null)
{
lock (BACnetGlobalNetwork.m_storage)
{
// Load descriptor from the embedded xml resource
BACnetGlobalNetwork.m_storage = DeviceStorage.Load("Yabe.YabeDeviceDescriptor.xml", (uint)Yabe.Properties.Settings.Default.YabeDeviceId);
// A fast way to change the PROP_OBJECT_LIST
Property Prop = Array.Find <Property>(BACnetGlobalNetwork.m_storage.Objects[0].Properties, p => p.Id == BacnetPropertyIds.PROP_OBJECT_LIST);
Prop.Value[0] = "OBJECT_DEVICE:" + Yabe.Properties.Settings.Default.YabeDeviceId.ToString();
// change PROP_FIRMWARE_REVISION
Prop = Array.Find <Property>(BACnetGlobalNetwork.m_storage.Objects[0].Properties, p => p.Id == BacnetPropertyIds.PROP_FIRMWARE_REVISION);
Prop.Value[0] = this.GetType().Assembly.GetName().Version.ToString();
// change PROP_APPLICATION_SOFTWARE_VERSION
Prop = Array.Find <Property>(BACnetGlobalNetwork.m_storage.Objects[0].Properties, p => p.Id == BacnetPropertyIds.PROP_APPLICATION_SOFTWARE_VERSION);
Prop.Value[0] = this.GetType().Assembly.GetName().Version.ToString();
}
}
BacnetClient.OnWhoIs += new BacnetClient.WhoIsHandler(OnWhoIs); //maybe this can't be static...does anything need to be stored in it?
BacnetClient.OnReadPropertyRequest += new BacnetClient.ReadPropertyRequestHandler(OnReadPropertyRequest);
BacnetClient.OnReadPropertyMultipleRequest += new BacnetClient.ReadPropertyMultipleRequestHandler(OnReadPropertyMultipleRequest);
}
else
{
BacnetClient.OnWhoIs += new BacnetClient.WhoIsHandler(OnWhoIsIgnore);
}
BacnetClient.OnIam += new BacnetClient.IamHandler(OnIam);
// Not sure if we need these; implement later
//BacnetClient.OnCOVNotification += new BacnetClient.COVNotificationHandler(bne.OnCOVNotification);
//BacnetClient.OnEventNotify += new BacnetClient.EventNotificationCallbackHandler(bne.OnEventNotify);
BacnetClient.Start();
Console.WriteLine("type:" + BacnetClient.Transport.Type);
//start search
if (BacnetClient.Transport.Type == BacnetAddressTypes.IP || BacnetClient.Transport.Type == BacnetAddressTypes.Ethernet ||
BacnetClient.Transport.Type == BacnetAddressTypes.IPV6 ||
(BacnetClient.Transport is BacnetMstpProtocolTransport && ((BacnetMstpProtocolTransport)BacnetClient.Transport).SourceAddress != -1) ||
BacnetClient.Transport.Type == BacnetAddressTypes.PTP)
{
Console.WriteLine("Starting device search");
System.Threading.ThreadPool.QueueUserWorkItem((o) =>
{
for (int i = 0; i < BacnetClient.Retries; i++)
{
BacnetClient.WhoIs();
Console.WriteLine("Sent WhoIs"); //OK, So we do WhoIs, write this line, and then sleep
System.Threading.Thread.Sleep(BacnetClient.Timeout);
}
}, null);
}
//special MSTP auto discovery
if (BacnetClient.Transport is BacnetMstpProtocolTransport)
{
//not sure this is needed...
//((BacnetMstpProtocolTransport)BacnetClient.Transport).FrameRecieved += new BacnetMstpProtocolTransport.FrameRecievedHandler(bne.MSTP_FrameRecieved);
}
}
catch (Exception ex)
{
Console.WriteLine("Error getting devices:" + ex.Message + "\n" + ex.StackTrace);
Instance.hspi.Log("BACnetDevice Exception in GetDevices " + ex.Message, 2);
//m_devices.Remove(bacnetClient);
//node.Remove();
//MessageBox.Show(this, "Couldn't start Bacnet bacnetClientunication: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//BacnetClient.WhoIs();
//System.Threading.Thread.Sleep(BacnetClient.Timeout);
//not actually waiting for this, just getting here right away
Console.WriteLine("Done getting devices");
}
private void SendSearch()
{
bacnet_client.WhoIs();
}
