public HomeController(LakeLabDbContext context, ValueStorage vs, DeviceStorage ds, UserManager <AppUser> um)
{
_dbContext = context;
_valueStorage = vs;
_deviceStorage = ds;
_userManager = um;
}
public apiController(LakeLabDbContext context, LoggingDbContext logginContext, ValueStorage vs, DeviceStorage ds)
{
_dbContext = context;
_loggingDbContext = logginContext;
_valueStorage = vs;
_deviceStorage = ds;
}
/*****************************************************************************************************/
static void StartActivity()
{
// Load the device descriptor from the external file
m_storage = DeviceStorage.Load("DeviceDescriptor.xml");
RaspberryGpioConfig();
// Bacnet on UDP/IP/Ethernet
bacnet_client = new BacnetClient(new BacnetIpUdpProtocolTransport(0xBAC0, false));
// Bacnet Mstp using an Usb to Rs485 adapter :
// bacnet_client = new BacnetClient(new BacnetMstpProtocolTransport("/dev/ttyUSB0", 38400,4,10));
// Master id 4, Max master 10, usb adapter attached on ttyUSB0
// For MSTP, you should :
// 1) avoid using the JIT compiler (since token passing timing will be unpredicable when accessing the first time bacnet objects)
// for that provide a native code in place of the CLI one using this command line :
// mono --aot ./RaspberrySample.exe
// this will create a file RaspberrySample.exe.so, let it close to the original CLI .exe code
// 2) launch the process with a high priority :
// sudo nice --20 mono ./RaspberrySample.exe or LANG="en-US.UTF8" sudo nice --20 mono ./RaspberrySample.exe
// Tested with Ftdi Usb/Rs485 adapter, Trane UC800 devices & Contemporary Control Bacnet router
// ... sometimes Rs845 activity is lost ! So not fiable today, only for learing purpose.
bacnet_client.OnWhoIs += new BacnetClient.WhoIsHandler(handler_OnWhoIs);
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.OnTimeSynchronize += new BacnetClient.TimeSynchronizeHandler(handler_OnTimeSynchronize);
bacnet_client.Start(); // go
// Send Iam
bacnet_client.Iam(m_storage.DeviceId);
}
/*****************************************************************************************************/
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");
// 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.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());
}
public List <ModuleModel> GenerateModuleModel(string deviceName)
{
var mModel = new List <ModuleModel>();
foreach (var m in DeviceStorage.GetDeviceByName(deviceName).Modules)
{
var buf = new ModuleModel();
buf.module = m;
buf.DeviceName = deviceName;
if (buf.module is Trigger)
{
buf.Type = "Simple Trigger";
buf.StrVal = Utility.UnWrapStates((buf.module as Trigger).State);
}
if (buf.module is VariadicTrigger)
{
buf.Type = "Variadic Trigger";
buf.StrVal = (buf.module as VariadicTrigger).State.ToString();
}
if (buf.module is Sensor)
{
buf.Type = (buf.module as Sensor).State.ToString();
}
mModel.Add(buf);
// mModel[0].Module.
}
return(mModel);
}
public IActionResult Register(string deviceName)
{
DeviceStorage.RegisterDevice(DeviceStorage.GetDeviceByName(deviceName));
ViewData["Message"] = "Settings general page.";
return(View("Devices", DevModelHandler.deviceModel));
}
/*****************************************************************************************************/
static void StartActivity()
{
// Load the device descriptor from the embedded resource file
// Get myId as own device id
m_storage = DeviceStorage.Load("BasicAlarmListener.DeviceDescriptor.xml", myId);
// A fast way to change the PROP_OBJECT_LIST
Property Prop = Array.Find <Property>(m_storage.Objects[0].Properties, p => p.Id == BacnetPropertyIds.PROP_OBJECT_LIST);
Prop.Value[0] = "OBJECT_DEVICE:" + myId.ToString();
// 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);
bacnet_client.OnWhoIs += new BacnetClient.WhoIsHandler(handler_OnWhoIs);
bacnet_client.OnEventNotify += new BacnetClient.EventNotificationCallbackHandler(handler_OnEventNotify);
// ReadProperties handlers are not absolutly required. Only whois (... and event !) handlers could be used,
// and m_storage object could be removed in this case.
bacnet_client.OnReadPropertyRequest += new BacnetClient.ReadPropertyRequestHandler(handler_OnReadPropertyRequest);
bacnet_client.OnReadPropertyMultipleRequest += new BacnetClient.ReadPropertyMultipleRequestHandler(handler_OnReadPropertyMultipleRequest);
bacnet_client.Start(); // go
}
// Quite all the code here came from DemoServer
// Only COV, Write & Files operations have been commented
// To activate BBMD services and Foreign Devices Acceptation
// the only thinks to do is to call udp_transport.Bvlc.AddBBMDPeer(BBMD, Mask);
// at least one time
static BacnetActivity()
{
try
{
// resource is embedded in the project
m_storage = DeviceStorage.Load("DemoBBMD.DeviceStorage.xml");
m_storage.ChangeOfValue += new DeviceStorage.ChangeOfValueHandler(m_storage_ChangeOfValue);
m_storage.ReadOverride += new DeviceStorage.ReadOverrideHandler(m_storage_ReadOverride);
// create udp service point
// certainly here exclusive_port usage could be set to true
// in order to be sure to be accepted by all the BBMD who are checking the
// endpoint where the requests are arriving and or sending to preconfigured port
// Needed with Wago 750-830, Contemporary Controls, Newron, ...
// not specifying the local_endpoint_ip is a little bugy problem for broadcast when exists multiple active interfaces
// with some chance it's Ok !
using (var loggerFactory = LoggerFactory.Create(b =>
{
b.AddConsole(c =>
{
c.TimestampFormat = "[yyyy-MM-dd HH:mm:ss] ";
});
}))
{
udp_transport = new BacnetIpUdpProtocolTransport(port: 0xBAC0, loggerFactory: loggerFactory, useExclusivePort: true);
// For IPV6, uncomment this, and comment out the previous line
// 187 is the device id : see DeviceStorage.xml
//udp_transportV6 = new BacnetIpV6UdpProtocolTransport(0xBAC0, 187, true);
m_ip_server = new BacnetClient(udp_transport, loggerFactory: loggerFactory);
}
m_ip_server.OnWhoIs += new BacnetClient.WhoIsHandler(OnWhoIs);
m_ip_server.OnReadPropertyRequest += new BacnetClient.ReadPropertyRequestHandler(OnReadPropertyRequest);
//m_ip_server.OnWritePropertyRequest += new BacnetClient.WritePropertyRequestHandler(OnWritePropertyRequest);
m_ip_server.OnReadPropertyMultipleRequest += new BacnetClient.ReadPropertyMultipleRequestHandler(OnReadPropertyMultipleRequest);
//m_ip_server.OnWritePropertyMultipleRequest += new BacnetClient.WritePropertyMultipleRequestHandler(OnWritePropertyMultipleRequest);
//m_ip_server.OnAtomicWriteFileRequest += new BacnetClient.AtomicWriteFileRequestHandler(OnAtomicWriteFileRequest);
//m_ip_server.OnAtomicReadFileRequest += new BacnetClient.AtomicReadFileRequestHandler(OnAtomicReadFileRequest);
//m_ip_server.OnSubscribeCOV += new BacnetClient.SubscribeCOVRequestHandler(OnSubscribeCOV);
//m_ip_server.OnSubscribeCOVProperty += new BacnetClient.SubscribeCOVPropertyRequestHandler(OnSubscribeCOVProperty);
m_ip_server.OnTimeSynchronize += new BacnetClient.TimeSynchronizeHandler(OnTimeSynchronize);
m_ip_server.OnDeviceCommunicationControl += new BacnetClient.DeviceCommunicationControlRequestHandler(OnDeviceCommunicationControl);
m_ip_server.OnReinitializedDevice += new BacnetClient.ReinitializedRequestHandler(OnReinitializedDevice);
m_ip_server.Start();
//send greeting
m_ip_server.Iam(m_storage.DeviceId, m_supported_segmentation);
}
catch
{
OpenError = true;
}
}
public AdminController(UserManager <AppUser> usrMgr, IUserValidator <AppUser> userValid, IPasswordValidator <AppUser> passValid, IPasswordHasher <AppUser> passwordHash, LakeLabDbContext dbContext, DeviceStorage deviceStorage)
{
_userManager = usrMgr;
_userValidator = userValid;
_passwordValidator = passValid;
_passwordHasher = passwordHash;
_dbContext = dbContext;
_deviceStorage = deviceStorage;
}
static BacnetActivity()
{
try
{
//init
PhysicalAddress macAddr =
(
from netiface in NetworkInterface.GetAllNetworkInterfaces()
where ((netiface.OperationalStatus == OperationalStatus.Up) && ((netiface.NetworkInterfaceType == NetworkInterfaceType.Ethernet) || (netiface.NetworkInterfaceType == NetworkInterfaceType.Wireless80211)))
select netiface.GetPhysicalAddress()
).FirstOrDefault();
if (macAddr != null)
{
byte[] mac = macAddr.GetAddressBytes();
DeviceId = ((uint)mac[5] + (uint)((mac[4] << 8) & 0x3F)) << 6;
}
if (App.Current.CurrentCulture == "fr")
{
Storage = DeviceStorage.Load("RoomSimulator.DeviceStorage.xml", DeviceId);
}
else
{
Storage = DeviceStorage.Load("RoomSimulator.DeviceStorageUs.xml", DeviceId);
}
Storage.ChangeOfValue += new DeviceStorage.ChangeOfValueHandler(m_storage_ChangeOfValue);
Storage.ReadOverride += new DeviceStorage.ReadOverrideHandler(m_storage_ReadOverride);
//create udp service point
var udp_transport = new BacnetIpUdpProtocolTransport(0xBAC0, false); //set to true to force "single socket" usage
udp_transport.Log = new DebugLogger();
m_ip_server = new BacnetClient(udp_transport);
m_ip_server.Log = new DebugLogger();
m_ip_server.OnWhoIs += new BacnetClient.WhoIsHandler(OnWhoIs);
m_ip_server.OnReadPropertyRequest += new BacnetClient.ReadPropertyRequestHandler(OnReadPropertyRequest);
m_ip_server.OnWritePropertyRequest += new BacnetClient.WritePropertyRequestHandler(OnWritePropertyRequest);
m_ip_server.OnReadPropertyMultipleRequest += new BacnetClient.ReadPropertyMultipleRequestHandler(OnReadPropertyMultipleRequest);
m_ip_server.OnSubscribeCOV += new BacnetClient.SubscribeCOVRequestHandler(OnSubscribeCOV);
m_ip_server.OnSubscribeCOVProperty += new BacnetClient.SubscribeCOVPropertyRequestHandler(OnSubscribeCOVProperty);
m_ip_server.OnTimeSynchronize += new BacnetClient.TimeSynchronizeHandler(OnTimeSynchronize);
m_ip_server.OnDeviceCommunicationControl += new BacnetClient.DeviceCommunicationControlRequestHandler(OnDeviceCommunicationControl);
m_ip_server.OnReinitializedDevice += new BacnetClient.ReinitializedRequestHandler(OnReinitializedDevice);
m_ip_server.Start();
//send greeting
m_ip_server.Iam(Storage.DeviceId, m_supported_segmentation);
}
catch (Exception e)
{
throw e;
}
}
public IActionResult SaveName(string deviceName, string IP)
{
DevModelHandler.deviceModel.Find(x => x.DeviceInfo.Device.Name == deviceName).EditShow = false;
DeviceStorage.ChangeExternalNameOfDevice(deviceName, IP);
// DevModelHandler.deviceModel.Find(x => x.DeviceInfo.Device.Name == deviceName).DeviceInfo.Device.ExternalName = "Tesst";
//var test = Request
ViewData["Message"] = "Settings general page.";
return(View("Devices", DevModelHandler.deviceModel));
}
public IActionResult DeleteDevice(string deviceName)
{
var tr = DevModelHandler.deviceModel.Find(x => x.DeviceInfo.Device.Name == deviceName);
DevModelHandler.deviceModel.Remove(tr);
DeviceStorage.DeleteDevice(deviceName);
ViewData["Message"] = "Modules";
return(View("Devices", DevModelHandler.deviceModel));
}
static BacnetActivity()
{
try
{
//init
PhysicalAddress macAddr =
(
from netiface in NetworkInterface.GetAllNetworkInterfaces()
where ((netiface.OperationalStatus == OperationalStatus.Up) && ((netiface.NetworkInterfaceType == NetworkInterfaceType.Ethernet) || (netiface.NetworkInterfaceType == NetworkInterfaceType.Wireless80211)))
select netiface.GetPhysicalAddress()
).FirstOrDefault();
if (macAddr != null)
{
byte[] mac = macAddr.GetAddressBytes();
deviceId = (uint)mac[5] + (uint)((mac[4] << 8) << 6);
}
// Un bricollage du dimanche vite fait ici !
deviceId = deviceId + ((uint)(Program.Count & 0x3F));
if (Application.CurrentCulture.TwoLetterISOLanguageName == "fr")
{
m_storage = DeviceStorage.Load("Bacnet.Room.Simulator.DeviceStorage.xml", deviceId);
}
else
{
m_storage = DeviceStorage.Load("Bacnet.Room.Simulator.DeviceStorageUs.xml", deviceId);
}
m_storage.ChangeOfValue += new DeviceStorage.ChangeOfValueHandler(m_storage_ChangeOfValue);
m_storage.ReadOverride += new DeviceStorage.ReadOverrideHandler(m_storage_ReadOverride);
//create udp service point
BacnetIpUdpProtocolTransport udp_transport = new BacnetIpUdpProtocolTransport(0xBAC0, false); //set to true to force "single socket" usage
m_ip_server = new BacnetClient(udp_transport);
m_ip_server.OnWhoIs += new BacnetClient.WhoIsHandler(OnWhoIs);
m_ip_server.OnReadPropertyRequest += new BacnetClient.ReadPropertyRequestHandler(OnReadPropertyRequest);
m_ip_server.OnWritePropertyRequest += new BacnetClient.WritePropertyRequestHandler(OnWritePropertyRequest);
m_ip_server.OnReadPropertyMultipleRequest += new BacnetClient.ReadPropertyMultipleRequestHandler(OnReadPropertyMultipleRequest);
m_ip_server.OnSubscribeCOV += new BacnetClient.SubscribeCOVRequestHandler(OnSubscribeCOV);
m_ip_server.OnSubscribeCOVProperty += new BacnetClient.SubscribeCOVPropertyRequestHandler(OnSubscribeCOVProperty);
m_ip_server.OnTimeSynchronize += new BacnetClient.TimeSynchronizeHandler(OnTimeSynchronize);
m_ip_server.OnDeviceCommunicationControl += new BacnetClient.DeviceCommunicationControlRequestHandler(OnDeviceCommunicationControl);
m_ip_server.OnReinitializedDevice += new BacnetClient.ReinitializedRequestHandler(OnReinitializedDevice);
m_ip_server.Start();
//send greeting
m_ip_server.Iam(m_storage.DeviceId, m_supported_segmentation);
}
catch
{
}
}
/// <summary>
/// 启动服务
/// </summary>
public void Start()
{
try
{
//init
PhysicalAddress macAddr =
(
from netiface in NetworkInterface.GetAllNetworkInterfaces()
where ((netiface.OperationalStatus == OperationalStatus.Up) && ((netiface.NetworkInterfaceType == NetworkInterfaceType.Ethernet) || (netiface.NetworkInterfaceType == NetworkInterfaceType.Wireless80211)))
select netiface.GetPhysicalAddress()
).FirstOrDefault();
if (macAddr != null)
{
byte[] mac = macAddr.GetAddressBytes();
deviceId = ((uint)mac[5] + (uint)((mac[4] << 8) & 0x3F)) << 6;
}
// Un bricollage du dimanche vite fait ici !
deviceId = deviceId + increaseId++;
m_storage = DeviceStorage.Load("IoTServer.DeviceStorage.xml", deviceId);
var str = JsonConvert.SerializeObject(m_storage);
m_storage.ChangeOfValue += new DeviceStorage.ChangeOfValueHandler(m_storage_ChangeOfValue);
m_storage.ReadOverride += new DeviceStorage.ReadOverrideHandler(m_storage_ReadOverride);
//create udp service point
BacnetIpUdpProtocolTransport udp_transport = new BacnetIpUdpProtocolTransport(47808, false); //set to true to force "single socket" usage
m_ip_server = new BacnetClient(udp_transport);
m_ip_server.OnWhoIs += new BacnetClient.WhoIsHandler(OnWhoIs);
m_ip_server.OnReadPropertyRequest += new BacnetClient.ReadPropertyRequestHandler(OnReadPropertyRequest);
m_ip_server.OnWritePropertyRequest += new BacnetClient.WritePropertyRequestHandler(OnWritePropertyRequest);
m_ip_server.OnReadPropertyMultipleRequest += new BacnetClient.ReadPropertyMultipleRequestHandler(OnReadPropertyMultipleRequest);
m_ip_server.OnSubscribeCOV += new BacnetClient.SubscribeCOVRequestHandler(OnSubscribeCOV);
m_ip_server.OnSubscribeCOVProperty += new BacnetClient.SubscribeCOVPropertyRequestHandler(OnSubscribeCOVProperty);
m_ip_server.OnTimeSynchronize += new BacnetClient.TimeSynchronizeHandler(OnTimeSynchronize);
m_ip_server.OnDeviceCommunicationControl += new BacnetClient.DeviceCommunicationControlRequestHandler(OnDeviceCommunicationControl);
m_ip_server.OnReinitializedDevice += new BacnetClient.ReinitializedRequestHandler(OnReinitializedDevice);
m_ip_server.Start();
//send greeting
m_ip_server.Iam(m_storage.DeviceId, m_supported_segmentation);
}
catch (Exception e)
{
}
}
public IActionResult ScheduleTimeBased(string deviceName, string moduleName)
{
var module = DeviceStorage.GetDeviceByName(deviceName).GetModuleByName(moduleName);
Random rand = new Random();
SmSEvent smSEvent = new TimeEvent("AutoGeneratedEvent", module, rand.Next(1, 250));
var time = DateTime.Now.AddSeconds(5);
(smSEvent as TimeEvent).TriggerAt(time);
Scheduler.AddEvent(smSEvent);
// DevModelHandler.deviceModel.Find(x => x.DeviceInfo.Device.Name == deviceName).DeviceInfo.Device.ExternalName = "Tesst";
//var test = Request
ViewData["Message"] = "Settings general page.";
return(View("Devices", DevModelHandler.deviceModel));
}
public static void Main(string[] args)
{
DeviceStorage.LoadDevicesFromDb();
new Thread(() =>
{
TcpServer server = new TcpServer(5555);
}).Start();
new Thread(() =>
{
while (true)
{
Scheduler.InvokeReadyEvents();
Thread.Sleep(500);
}
}).Start();
BuildWebHost(args).Run();
}
private string HandleDump()
{
Device buf = new Device(_headers["device_name"], "Empty");
buf.CurrentTime = Int64.Parse(_headers["local_time"]);
if (!DeviceStorage.Contains(_headers["device_name"]))
{
_resultInfo.Code = 404;
_resultInfo.Message = "Device not found";
}
else
{
buf = DeviceStorage.GetDeviceByName(_headers["device_name"]);
if (!_headers.ContainsKey("auth"))
{
_resultInfo.Code = (int)RetCodes.UNAUTHORIZED;
_resultInfo.Message = "No auth header";
}
else
{
if (_headers["auth"] == buf.AuthToken)
{
var modules = ParseModulesFromHeaders();
foreach (var m in modules)
{
if (buf.IsModuleExist(m.Name))
{
buf.ChangeModuleFromDevice(buf.GetModuleByName(m.Name), m);
}
else
{
buf.AddModule(m);
}
}
_resultInfo.Code = (int)RetCodes.OK;
_resultInfo.Message = "Ok";
}
else
{
_resultInfo.Code = (int)RetCodes.UNAUTHORIZED;
_resultInfo.Message = "Auth token is wrong.";
}
}
}
return(buf.GetQueueMessage() + BuildValidationString(buf));
}
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 string HandleAck()
{
Device buf = new Device(_headers["device_name"], "Empty");
buf.LastSync = DateTime.Now;
if (DeviceStorage.Contains(_headers["device_name"]))
{
buf = DeviceStorage.GetDeviceByName(_headers["device_name"]);
}
else
{
if (DatabaseWrapper.IsDeviceExist(_headers["device_name"]))
{
buf = DatabaseWrapper.LoadDeviceFromDB(_headers["device_name"]).Device;
}
}
buf.CurrentTime = Int64.Parse(_headers["local_time"]);
var modules = ParseModulesFromHeaders();
foreach (var m in modules)
{
if (buf.IsModuleExist(m.Name))
{
buf.ChangeModuleFromDevice(buf.GetModuleByName(m.Name), m);
}
else
{
buf.AddModule(m);
}
}
if (!DeviceStorage.DeviceExists(_headers["device_name"]))
{
DeviceStorage.AddDevice(buf);
}
_resultInfo.Code = (int)RetCodes.OK;
_resultInfo.Message = "Ok";
return(buf.GetQueueMessage());
}
private static void m_storage_ChangeOfValue(DeviceStorage sender, BacnetObjectId object_id, BacnetPropertyIds property_id, uint array_index, IList <BacnetValue> value)
{
System.Threading.ThreadPool.QueueUserWorkItem((o) =>
{
lock (m_lockObject)
{
//remove old leftovers
RemoveOldSubscriptions();
//find subscription
if (!m_subscriptions.ContainsKey(object_id))
{
return;
}
List <Subscription> subs = m_subscriptions[object_id];
//convert
List <BacnetPropertyValue> values = new List <BacnetPropertyValue>();
BacnetPropertyValue tmp = new BacnetPropertyValue();
tmp.property = new BacnetPropertyReference((uint)property_id, array_index);
tmp.value = value;
values.Add(tmp);
//send to all
foreach (Subscription sub in subs)
{
if (sub.monitoredProperty.propertyIdentifier == (uint)BacnetPropertyIds.PROP_ALL || sub.monitoredProperty.propertyIdentifier == (uint)property_id)
{
//send notify
if (!sub.reciever.Notify(sub.reciever_address, sub.subscriberProcessIdentifier, m_storage.DeviceId, sub.monitoredObjectIdentifier, (uint)sub.GetTimeRemaining(), sub.issueConfirmedNotifications, values))
{
Trace.TraceError("Couldn't send notify");
}
}
}
}
}, null);
}
public DevicesController(DeviceStorage deviceStorage)
{
Storage = deviceStorage;
}
public DevicesController(DeviceStorage storage)
{
Storage = storage;
}
public DevicesController(LakeLabDbContext context, AppIdentityDbContext identityDbContext, DeviceStorage deviceStorage)
{
_dbContext = context;
_identityDbContext = identityDbContext;
_deviceStorage = deviceStorage;
}
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");
}
