private void AddProperty(BacnetPropertyIds id, BacnetPropertyValue val)
{
//var id = BacnetPropertyIds.PROP_OBJECT_IDENTIFIER;
//var val = new BacnetValue(object_id);
if (!BACnetObject.SupportedPropertyIds.Contains(id))
{
return;
}
var prop = new BACnetProperty(this, id, val);
addProp(id, prop);
//if id == BacnetPropertyIds.
//if (BACnetObject.RequiredPropertyIds.Contains(id)) //don't keep required properties separate anymore.....
// RequiredProperties[id] = prop; //TODO: could put option to not overwrite, I guess...
//else
//{
//var kvp = new KeyValuePair<BacnetPropertyIds, BACnetProperty>(id, prop);
//BacnetProperties.Add(kvp);
}
public void ReadPropertyMultiple(BacnetObjectId object_id, ICollection <BacnetPropertyReference> properties, out IList <BacnetPropertyValue> values)
{
BacnetPropertyValue[] values_ret = new BacnetPropertyValue[properties.Count];
int count = 0;
foreach (BacnetPropertyReference entry in properties)
{
BacnetPropertyValue new_entry = new BacnetPropertyValue();
new_entry.property = entry;
ErrorCodes error = ReadProperty(object_id, (BacnetPropertyIds)entry.propertyIdentifier, entry.propertyArrayIndex, out new_entry.value);
if (error == ErrorCodes.UnKnownObject)
{
new_entry.value = new BacnetValue[] { new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ERROR, new BacnetError(BacnetErrorClasses.ERROR_CLASS_OBJECT, BacnetErrorCodes.ERROR_CODE_UNKNOWN_OBJECT)) }
}
;
else if (error == ErrorCodes.NotExist)
{
new_entry.value = new BacnetValue[] { new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ERROR, new BacnetError(BacnetErrorClasses.ERROR_CLASS_PROPERTY, BacnetErrorCodes.ERROR_CODE_UNKNOWN_PROPERTY)) }
}
;
values_ret[count] = new_entry;
count++;
}
values = values_ret;
}
public bool ReadPropertyAll(BacnetObjectId objectId, out IList <BacnetPropertyValue> values)
{
//find
var obj = FindObject(objectId);
if (obj == null)
{
values = null;
return(false);
}
//build
var propertyValues = new BacnetPropertyValue[obj.Properties.Length];
for (var i = 0; i < obj.Properties.Length; i++)
{
var newEntry = new BacnetPropertyValue
{
property = new BacnetPropertyReference((uint)obj.Properties[i].Id, Serialize.ASN1.BACNET_ARRAY_ALL)
};
if (ReadProperty(objectId, obj.Properties[i].Id, Serialize.ASN1.BACNET_ARRAY_ALL, out newEntry.value) != ErrorCodes.Good)
{
var bacnetError = new BacnetError(BacnetErrorClasses.ERROR_CLASS_OBJECT, BacnetErrorCodes.ERROR_CODE_UNKNOWN_PROPERTY);
newEntry.value = new[] { new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ERROR, bacnetError) };
}
propertyValues[i] = newEntry;
}
values = propertyValues;
return(true);
}
public void ReadPropertyMultiple(BacnetObjectId objectId, ICollection <BacnetPropertyReference> properties, out IList <BacnetPropertyValue> values)
{
var valuesRet = new List <BacnetPropertyValue>();
foreach (var entry in properties)
{
var newEntry = new BacnetPropertyValue {
property = entry
};
switch (ReadProperty(objectId, (BacnetPropertyIds)entry.propertyIdentifier, entry.propertyArrayIndex, out newEntry.value))
{
case ErrorCodes.UnknownObject:
newEntry.value = new[]
{
new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ERROR,
new BacnetError(BacnetErrorClasses.ERROR_CLASS_OBJECT, BacnetErrorCodes.ERROR_CODE_UNKNOWN_OBJECT))
};
break;
case ErrorCodes.NotExist:
newEntry.value = new[]
{
new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ERROR,
new BacnetError(BacnetErrorClasses.ERROR_CLASS_PROPERTY, BacnetErrorCodes.ERROR_CODE_UNKNOWN_PROPERTY))
};
break;
}
valuesRet.Add(newEntry);
}
values = valuesRet;
}
public bool ReadPropertyAll(BacnetObjectId object_id, out IList <BacnetPropertyValue> values)
{
values = null;
//find
Object obj = FindObject(object_id);
if (obj == null)
{
return(false);
}
//build
ErrorCodes[] ret = new ErrorCodes[obj.Properties.Length];
BacnetPropertyValue[] _values = new BacnetPropertyValue[obj.Properties.Length];
for (int i = 0; i < obj.Properties.Length; i++)
{
BacnetPropertyValue new_entry = new BacnetPropertyValue();
new_entry.property = new BacnetPropertyReference((uint)obj.Properties[i].Id, System.IO.BACnet.Serialize.ASN1.BACNET_ARRAY_ALL);
if (ReadProperty(object_id, obj.Properties[i].Id, System.IO.BACnet.Serialize.ASN1.BACNET_ARRAY_ALL, out new_entry.value) != ErrorCodes.Good)
{
new_entry.value = new BacnetValue[] { new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ERROR, new BacnetError(BacnetErrorClasses.ERROR_CLASS_OBJECT, BacnetErrorCodes.ERROR_CODE_UNKNOWN_PROPERTY)) }
}
;
_values[i] = new_entry;
}
values = _values;
return(true);
}
private void SetName() //don't call in the middle of FetchProperties... actually, now it's fine because of bypass refresh
{
try
{
BacnetPropertyValue namePropVal = (BacnetPropertyValue)GetBacnetProperty(BacnetPropertyIds.PROP_OBJECT_NAME, true).BacnetPropertyValue;
//careful - don't call GetBacnetProperty internally, or else it will keep trying to refresh properties since AllPropertiesFetched is still false
Name = namePropVal.value[0].ToString(); //BacnetValue.Value.ToString();
}
catch (Exception ex)
{
//leave it alone?
}
}
/*****************************************************************************************************/
static void handler_OnCOVManagementNotify(BaCSharpObject sender, BacnetPropertyIds propId)
{
System.Threading.ThreadPool.QueueUserWorkItem((o) =>
{
lock (device)
{
//remove old leftovers
SubscriptionManager.RemoveOldSubscriptions();
//find subscription
List <Subscription> subs = SubscriptionManager.GetSubscriptionsForObject(sender.PROP_OBJECT_IDENTIFIER);
if (subs == null)
{
return; // nobody
}
//Read the property
IList <BacnetValue> value;
BacnetPropertyReference br = new BacnetPropertyReference((uint)propId, (uint)System.IO.BACnet.Serialize.ASN1.BACNET_ARRAY_ALL);
ErrorCodes error = sender.ReadPropertyValue(br, out value);
List <BacnetPropertyValue> values = new List <BacnetPropertyValue>();
BacnetPropertyValue tmp = new BacnetPropertyValue();
tmp.value = value;
tmp.property = br;
values.Add(tmp);
//send to all
foreach (Subscription sub in subs)
{
if (sub.monitoredProperty.propertyIdentifier == (uint)BacnetPropertyIds.PROP_ALL || sub.monitoredProperty.propertyIdentifier == (uint)propId)
{
tmp.property = sub.monitoredProperty;
if (!sub.reciever.Notify(sub.reciever_address, sub.subscriberProcessIdentifier, deviceId, sub.monitoredObjectIdentifier, (uint)sub.GetTimeRemaining(), sub.issueConfirmedNotifications, values))
{
SubscriptionManager.RemoveReceiver(sub.reciever_address);
}
}
}
}
}, null);
}
public bool ReadValue()
{
var comm = BacnetObject.BacnetDevice.BacnetNetwork.BacnetClient;
var adr = BacnetObject.BacnetDevice.BacnetAddress;
var object_id = BacnetObject.BacnetObjectId;
var property_id = BacnetPropertyId;
var array_index = arrayIndex;
BacnetPropertyValue new_entry = new BacnetPropertyValue();
new_entry.property = new BacnetPropertyReference((uint)property_id); //, array_index); //don't need this. Already have.
IList <BacnetValue> value;
try
{
if (!comm.ReadPropertyRequest(adr, object_id, property_id, out value)) //, 0, array_index)) //TODO: do we ever need array index?
{
return(false); //ignore
}
}
catch
{
return(false); //ignore
}
new_entry.value = value;
this.BacnetPropertyValue = new_entry;
//if (value.Count == 1)
// this.BacnetValue = value[0]; //this should never be called on object groups or structured views, so will only contain one value....
//else
// this.BacnetValues = value; //otherwise leave value as Null, since we can't handle multiples here...
//this.BacnetValues = value; //will this list always only contain one? What about possible properties?
//new_entry.value = value;
//values.Add(new_entry);
return(true);
}
private async void SendTelemtry(BacnetPropertyValue value, BacnetObjectId monitoredObjectIdentifier)
{
var l_telemetry = new TelemetryMessage()
{
GatewaySource = "WinBerry3",
MessageSource = monitoredObjectIdentifier.instance.ToString(),
MessageType = monitoredObjectIdentifier.Type.ToString(),
Value = value.value[0].Value.ToString(),
GatewayTimeStampUtc = DateTime.Now.ToUniversalTime()
};
var l_outBoundMessage = new Message(Serialize(l_telemetry));
if (m_azureDeviceClient != null)
{
await m_azureDeviceClient.SendEventAsync(l_outBoundMessage);
}
Debug.WriteLine($"Sent telemetry data to IoT Suite \t Object{monitoredObjectIdentifier.Instance} \t Data={value.value[0].Value}");
}
public void ReadPropertyMultiple(BacnetObjectId object_id, ICollection <BacnetPropertyReference> properties, out IList <BacnetPropertyValue> values)
{
var valuesRet = new List <BacnetPropertyValue>();
foreach (var entry in properties)
{
var newEntry = new BacnetPropertyValue {
property = entry
};
if (ReadProperty(object_id, (BacnetPropertyIds)entry.propertyIdentifier, entry.propertyArrayIndex, out newEntry.value) != ErrorCodes.Good)
{
var bacnetError = new BacnetError(BacnetErrorClasses.ERROR_CLASS_OBJECT, BacnetErrorCodes.ERROR_CODE_UNKNOWN_PROPERTY);
newEntry.value = new[] { new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ERROR, bacnetError) };
}
valuesRet.Add(newEntry);
}
values = valuesRet;
}
public bool ReadPropertyMultiple(BacnetClient sender, BacnetAddress adr, IList <BacnetPropertyReference> properties, out IList <BacnetPropertyValue> values)
{
values = new BacnetPropertyValue[properties.Count];
int count = 0;
foreach (BacnetPropertyReference entry in properties)
{
BacnetPropertyValue new_entry = new BacnetPropertyValue();
new_entry.property = entry;
if (ReadPropertyValue(sender, adr, entry, out new_entry.value) != ErrorCodes.Good)
{
new_entry.value = new BacnetValue[] { new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ERROR, new BacnetError(BacnetErrorClasses.ERROR_CLASS_OBJECT, BacnetErrorCodes.ERROR_CODE_UNKNOWN_PROPERTY)) }
}
;
values[count] = new_entry;
count++;
}
return(true);
}
public void FetchRequiredProperties() //honesty could just fetch all properties and then add them in appropriately...
{
var object_id = this.BacnetObjectId;
BacnetPropertyValue new_entry = new BacnetPropertyValue();
new_entry.property = new BacnetPropertyReference((uint)BacnetPropertyIds.PROP_OBJECT_IDENTIFIER); //, System.IO.BACnet.Serialize.ASN1.BACNET_ARRAY_ALL);
new_entry.value = new BacnetValue[] { new BacnetValue(object_id) };
AddProperty(BacnetPropertyIds.PROP_OBJECT_IDENTIFIER, new_entry);
//AddProperty(BacnetPropertyIds.PROP_OBJECT_IDENTIFIER, new BacnetValue(object_id));
// ReadProperty(comm, adr, object_id, BacnetPropertyIds.PROP_OBJECT_TYPE, ref values);
// No need to query it, known value
new_entry = new BacnetPropertyValue();
new_entry.property = new BacnetPropertyReference((uint)BacnetPropertyIds.PROP_OBJECT_TYPE, System.IO.BACnet.Serialize.ASN1.BACNET_ARRAY_ALL);
new_entry.value = new BacnetValue[] { new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ENUMERATED, (uint)object_id.type) };
//values.Add(new_entry);
AddProperty(BacnetPropertyIds.PROP_OBJECT_TYPE, new_entry);
//AddProperty(BacnetPropertyIds.PROP_OBJECT_TYPE, new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ENUMERATED, (uint)object_id.type));
// We do not know the value here
//ReadProperty(comm, adr, object_id, BacnetPropertyIds.PROP_OBJECT_NAME, ref values);
AddProperty(BacnetPropertyIds.PROP_OBJECT_NAME); //not known, so it will get.
SetName();
//Name = RequiredProperties[BacnetPropertyIds.PROP_OBJECT_NAME].BacnetValue.Value.ToString();
}
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);
}
private static void OnSubscribeCOVProperty(BacnetClient sender, BacnetAddress adr, byte invoke_id, uint subscriberProcessIdentifier, BacnetObjectId monitoredObjectIdentifier, BacnetPropertyReference monitoredProperty, bool cancellationRequest, bool issueConfirmedNotifications, uint lifetime, float covIncrement, BacnetMaxSegments max_segments)
{
lock (m_lockObject)
{
try
{
//create
Subscription sub = HandleSubscriptionRequest(sender, adr, invoke_id, subscriberProcessIdentifier, monitoredObjectIdentifier, (uint)BacnetPropertyIds.PROP_ALL, cancellationRequest, issueConfirmedNotifications, lifetime, covIncrement);
//send confirm
sender.SimpleAckResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_SUBSCRIBE_COV_PROPERTY, invoke_id);
//also send first values
if (!cancellationRequest)
{
System.Threading.ThreadPool.QueueUserWorkItem((o) =>
{
IList <BacnetValue> _values;
m_storage.ReadProperty(sub.monitoredObjectIdentifier, (BacnetPropertyIds)sub.monitoredProperty.propertyIdentifier, sub.monitoredProperty.propertyArrayIndex, out _values);
List <BacnetPropertyValue> values = new List <BacnetPropertyValue>();
BacnetPropertyValue tmp = new BacnetPropertyValue();
tmp.property = sub.monitoredProperty;
tmp.value = _values;
values.Add(tmp);
if (!sender.Notify(adr, sub.subscriberProcessIdentifier, m_storage.DeviceId, sub.monitoredObjectIdentifier, (uint)sub.GetTimeRemaining(), sub.issueConfirmedNotifications, values))
{
Trace.TraceError("Couldn't send notify");
}
}, null);
}
}
catch (Exception)
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_SUBSCRIBE_COV_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_OTHER);
}
}
}
/*****************************************************************************************************/
static void handler_OnSubscribeCOVProperty(BacnetClient sender, BacnetAddress adr, byte invoke_id, uint subscriberProcessIdentifier, BacnetObjectId monitoredObjectIdentifier, BacnetPropertyReference monitoredProperty, bool cancellationRequest, bool issueConfirmedNotifications, uint lifetime, float covIncrement, BacnetMaxSegments max_segments)
{
lock (device)
{
BaCSharpObject bacobj = device.FindBacnetObject(monitoredObjectIdentifier);
if (bacobj != null)
{
//create
Subscription sub = SubscriptionManager.HandleSubscriptionRequest(sender, adr, invoke_id, subscriberProcessIdentifier, monitoredObjectIdentifier, monitoredProperty.propertyIdentifier, cancellationRequest, issueConfirmedNotifications, lifetime, covIncrement);
//send confirm
sender.SimpleAckResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_SUBSCRIBE_COV_PROPERTY, invoke_id);
//also send first values
if (!cancellationRequest)
{
System.Threading.ThreadPool.QueueUserWorkItem((o) =>
{
IList <BacnetValue> _values;
bacobj.ReadPropertyValue(sender, adr, monitoredProperty, out _values);
List <BacnetPropertyValue> values = new List <BacnetPropertyValue>();
BacnetPropertyValue tmp = new BacnetPropertyValue();
tmp.property = sub.monitoredProperty;
tmp.value = _values;
values.Add(tmp);
sender.Notify(adr, sub.subscriberProcessIdentifier, deviceId, sub.monitoredObjectIdentifier, (uint)sub.GetTimeRemaining(), sub.issueConfirmedNotifications, values);
}, null);
}
}
else
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_SUBSCRIBE_COV_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_OTHER);
}
}
}
// Copy the Present value into each reference properties value
protected virtual void DoDispatchValue()
{
if ((m_PROP_LIST_OF_OBJECT_PROPERTY_REFERENCES.references == null) || (Mydevice == null))
{
return;
}
foreach (object obj in m_PROP_LIST_OF_OBJECT_PROPERTY_REFERENCES.references)
{
BacnetDeviceObjectPropertyReference reference = (BacnetDeviceObjectPropertyReference)obj;
// reference.deviceIndentifier.type is not set to OBJECT_DEVICE for local object reference
if (reference.deviceIndentifier.type != BacnetObjectTypes.OBJECT_DEVICE) // local object
{
BaCSharpObject bcs = Mydevice.FindBacnetObject(reference.objectIdentifier);
if (bcs != null)
{
BacnetPropertyValue value = new BacnetPropertyValue();
if (m_PROP_PRIORITY == 0)
{
value.priority = (byte)16;
}
else
{
value.priority = (byte)m_PROP_PRIORITY;
}
value.property = new BacnetPropertyReference((uint)reference.propertyIdentifier, reference.arrayIndex);
value.value = new BacnetValue[] { new BacnetValue(m_PROP_PRESENT_VALUE) };
bcs.WritePropertyValue(value, false);
}
}
else
{
KeyValuePair <BacnetClient, BacnetAddress>?recipient = null;
try
{
// SuroundingDevices is updated with Iam messages
recipient = Mydevice.SuroundingDevices[reference.deviceIndentifier.instance];
}
catch { }
if (recipient == null)
{
return;
}
BacnetValue[] value = new BacnetValue[] { new BacnetValue(m_PROP_PRESENT_VALUE) };
uint wp = m_PROP_PRIORITY;
System.Threading.ThreadPool.QueueUserWorkItem((o) =>
{
recipient.Value.Key.WritePriority = wp;
recipient.Value.Key.BeginWritePropertyRequest(recipient.Value.Value, reference.objectIdentifier, (BacnetPropertyIds)reference.propertyIdentifier, value, false);
}
, null);
}
}
}
private static void OnWritePropertyRequest(BacnetClient sender, BacnetAddress adr, byte invoke_id, BacnetObjectId object_id, BacnetPropertyValue value, BacnetMaxSegments max_segments)
{
lock (m_lockObject)
{
try
{
// Modif FC
DeviceStorage.ErrorCodes code = m_storage.WriteCommandableProperty(object_id, (BacnetPropertyIds)value.property.propertyIdentifier, value.value[0], value.priority);
if (code == DeviceStorage.ErrorCodes.NotForMe)
{
code = m_storage.WriteProperty(object_id, (BacnetPropertyIds)value.property.propertyIdentifier, value.property.propertyArrayIndex, value.value);
}
if (code == DeviceStorage.ErrorCodes.Good)
{
sender.SimpleAckResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id);
}
else
if (code == DeviceStorage.ErrorCodes.WriteAccessDenied)
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_WRITE_ACCESS_DENIED);
}
else
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_OTHER);
}
}
catch (Exception)
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_OTHER);
}
}
}
private void AddProperty(BacnetPropertyValue val)
{
var id = (BacnetPropertyIds)val.property.propertyIdentifier;
AddProperty(id, val);
}
/*****************************************************************************************************/
static void handler_OnWritePropertyRequest(BacnetClient sender, BacnetAddress adr, byte invoke_id, BacnetObjectId object_id, BacnetPropertyValue value, BacnetMaxSegments max_segments)
{
// only OBJECT_ANALOG_VALUE:0.PROP_PRESENT_VALUE could be write in this sample code
if ((object_id.type != BacnetObjectTypes.OBJECT_ANALOG_VALUE) || (object_id.instance != 0) || ((BacnetPropertyIds)value.property.propertyIdentifier != BacnetPropertyIds.PROP_PRESENT_VALUE))
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_WRITE_ACCESS_DENIED);
return;
}
lock (m_storage)
{
try
{
DeviceStorage.ErrorCodes code = m_storage.WriteCommandableProperty(object_id, (BacnetPropertyIds)value.property.propertyIdentifier, value.value[0], value.priority);
if (code == DeviceStorage.ErrorCodes.NotForMe)
{
code = m_storage.WriteProperty(object_id, (BacnetPropertyIds)value.property.propertyIdentifier, value.property.propertyArrayIndex, value.value);
}
if (code == DeviceStorage.ErrorCodes.Good)
{
sender.SimpleAckResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id);
}
else
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_OTHER);
}
}
catch (Exception)
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_OTHER);
}
}
}
private void btnSchedule_Click(object sender, EventArgs e)
{
Int32 liDeviceID = Convert.ToInt32(ddlScheduleDevice.SelectedValue);
Int32 liObjectID = Convert.ToInt32(Convert.ToString(ddlScheduleObject.SelectedValue).Split('|')[1]);
string lsNewPresentvalue = Convert.ToString(txtScheduleValue.Text);
Int32 liDaySelected = Convert.ToInt32(ddlScheduleDay.SelectedValue);
if (liDeviceID > -1 && liObjectID > -1 && !string.IsNullOrEmpty(lsNewPresentvalue) &&
!string.IsNullOrEmpty(txtScheduleHours.Text) &&
!string.IsNullOrEmpty(txtScheduleMinutes.Text) &&
!string.IsNullOrEmpty(txtScheduleSeconds.Text))
{
using (var loESDLutronEntities = new ESDLutronEntities())
{
var loBACnetDeviceDetail = loESDLutronEntities.BACnetDevices
.Where(x => x.device_id == liDeviceID &&
x.object_type.ToUpper() == LutronFloorObjectType.Device)
.Select(x => x).FirstOrDefault();
int?liTopInstanceID = loESDLutronEntities.BACnetDevices
.Where(x => x.device_id == liDeviceID &&
x.object_type.ToUpper() == LutronFloorObjectType.SCHEDULE)
.Select(x => x.object_instance).OrderByDescending(x => x.Value).FirstOrDefault();
BacnetAddress loBacnetAddress;
loBacnetAddress = new BacnetAddress(BacnetAddressTypes.IP, loBACnetDeviceDetail.network_id);
loBacnetAddress.RoutedSource = new BacnetAddress(BacnetAddressTypes.IP, loBACnetDeviceDetail.routed_source, (ushort)loBACnetDeviceDetail.routed_net);
//var deviceObjId = new BacnetObjectId(BacnetObjectTypes.OBJECT_DEVICE, (uint)liDeviceID);
//var objectIdList = await moBacnetClient.ReadPropertyAsync(loBacnetAddress, deviceObjId, BacnetPropertyIds.PROP_OBJECT_LIST);
//IList<BacnetValue> loDeviceObject;
//moBacnetClient.ReadPropertyRequest(loBacnetAddress, new BacnetObjectId(BacnetObjectTypes.OBJECT_DEVICE, (uint)liDeviceID), BacnetPropertyIds.PROP_OBJECT_LIST, out loDeviceObject);
//IList<BacnetValue> loScheduleValues;
//moBacnetClient.ReadPropertyRequest(loBacnetAddress, new BacnetObjectId(BacnetObjectTypes.OBJECT_SCHEDULE, (uint)11), BacnetPropertyIds.PROP_LIST_OF_OBJECT_PROPERTY_REFERENCES, out loScheduleValues);
//IList<BacnetValue> loWeekValues;
//moBacnetClient.ReadPropertyRequest(loBacnetAddress, new BacnetObjectId(BacnetObjectTypes.OBJECT_SCHEDULE, (uint)11), BacnetPropertyIds.PROP_WEEKLY_SCHEDULE, out loWeekValues);
//IList<BacnetValue> loObjectName;
//moBacnetClient.ReadPropertyRequest(loBacnetAddress, new BacnetObjectId(BacnetObjectTypes.OBJECT_SCHEDULE, (uint)11), BacnetPropertyIds.PROP_OBJECT_NAME, out loObjectName);
//var loData = values
// .Where(x => ((BacnetObjectId)values[0].Value).Type == BacnetObjectTypes.OBJECT_SCHEDULE)
// .Select(x => x.Value.GetType().GetProperty("Instance"))
IList <BacnetValue> loScheduleValues;
moBacnetClient.ReadPropertyRequest(loBacnetAddress, new BacnetObjectId(BacnetObjectTypes.OBJECT_SCHEDULE, (uint)2), BacnetPropertyIds.PROP_EXCEPTION_SCHEDULE, out loScheduleValues);
ICollection <BacnetPropertyValue> loBacnetPropertyValueList = new List <BacnetPropertyValue>();
BacnetPropertyValue loNewPropertyValue = new BacnetPropertyValue();
List <BacnetValue> loBacnetValue = new List <BacnetValue>();
#region set schedule
//// Create new instance id based on largest available
//if(liTopInstanceID)
liTopInstanceID = liTopInstanceID != null ? liTopInstanceID + 1 : 1;
//// Set schedule object name
loBacnetValue = new List <BacnetValue>();
loNewPropertyValue = new BacnetPropertyValue();
loBacnetValue.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_CHARACTER_STRING, "Schedule" + " " + liTopInstanceID));
loNewPropertyValue.value = loBacnetValue;
loNewPropertyValue.property = new BacnetPropertyReference((uint)BacnetPropertyIds.PROP_OBJECT_NAME, ASN1.BACNET_ARRAY_ALL);
loBacnetPropertyValueList.Add(loNewPropertyValue);
//// Set effective period for schedule object
loBacnetValue = new List <BacnetValue>();
loNewPropertyValue = new BacnetPropertyValue();
loBacnetValue.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_DATE, DateTime.Today.AddDays(-1)));
loBacnetValue.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_DATE, DateTime.Today.AddMonths(1)));
loNewPropertyValue.value = loBacnetValue;
loNewPropertyValue.property = new BacnetPropertyReference((uint)BacnetPropertyIds.PROP_EFFECTIVE_PERIOD, ASN1.BACNET_ARRAY_ALL);
loBacnetPropertyValueList.Add(loNewPropertyValue);
#endregion
//// Set object reference to update it's value with schedule object
loBacnetValue = new List <BacnetValue>();
loNewPropertyValue = new BacnetPropertyValue();
BacnetDeviceObjectPropertyReference loPropertyReference = new BacnetDeviceObjectPropertyReference();
//BACnetCalendarEntry loBACnetCalendarEntry = new BACnetCalendarEntry();
//// Add AV 1 present value change
loPropertyReference.ArrayIndex = -1;
loPropertyReference.DeviceId = new BacnetObjectId(BacnetObjectTypes.OBJECT_DEVICE, (uint)liDeviceID);
loPropertyReference.ObjectId = new BacnetObjectId(BacnetObjectTypes.OBJECT_ANALOG_VALUE, (uint)liObjectID);
loPropertyReference.PropertyId = BacnetPropertyIds.PROP_PRESENT_VALUE;
loBacnetValue.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_OBJECT_PROPERTY_REFERENCE,
loPropertyReference));
// Add AV 2 present value change
loPropertyReference = new BacnetDeviceObjectPropertyReference();
loPropertyReference.ArrayIndex = -1;
loPropertyReference.DeviceId = new BacnetObjectId(BacnetObjectTypes.OBJECT_DEVICE, (uint)liDeviceID);
loPropertyReference.ObjectId = new BacnetObjectId(BacnetObjectTypes.OBJECT_ANALOG_VALUE, (uint)2);
loPropertyReference.PropertyId = BacnetPropertyIds.PROP_PRESENT_VALUE;
loBacnetValue.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_OBJECT_PROPERTY_REFERENCE,
loPropertyReference));
loNewPropertyValue.value = loBacnetValue;
loNewPropertyValue.property = new BacnetPropertyReference((uint)BacnetPropertyIds.PROP_LIST_OF_OBJECT_PROPERTY_REFERENCES, ASN1.BACNET_ARRAY_ALL);
loBacnetPropertyValueList.Add(loNewPropertyValue);
//// Add weekly schedule for object
loBacnetValue = new List <BacnetValue>();
loNewPropertyValue = new BacnetPropertyValue();
//// setup weekday to add schedule (0 = Monday, 1 = Tuesday ....., 6 = Sunday)
BacnetWeeklySchedule loBacnetWeeklySchedule = new BacnetWeeklySchedule();
loBacnetWeeklySchedule.days[liDaySelected] = new List <DaySchedule>();
//// Schedule to update AV 1,2 at specified time
loBacnetWeeklySchedule.days[liDaySelected].Add(
new DaySchedule(new DateTime(1, 1, 1, Convert.ToInt32(txtScheduleHours.Text),
Convert.ToInt32(txtScheduleMinutes.Text), Convert.ToInt32(txtScheduleSeconds.Text)),
Convert.ToSingle((new Random()).Next(100, 999))));
//// Schedule to update AV 1,2 after 5 mins of schedule
loBacnetWeeklySchedule.days[liDaySelected].Add(new DaySchedule(DateTime.Now.AddMinutes(1), Convert.ToSingle(lsNewPresentvalue)));
loBacnetValue.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_WEEKLY_SCHEDULE, loBacnetWeeklySchedule));
loNewPropertyValue.value = loBacnetValue;
loNewPropertyValue.property = new BacnetPropertyReference((uint)BacnetPropertyIds.PROP_WEEKLY_SCHEDULE, ASN1.BACNET_ARRAY_ALL);
loBacnetPropertyValueList.Add(loNewPropertyValue);
//// Add exception schedule
//loBacnetValue = new List<BacnetValue>();
//loNewPropertyValue = new BacnetPropertyValue();
//loBacnetValue.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_TIME, new DateTime(2017,9,11,15,10,0)));
//loBacnetValue.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_REAL, 333));
//loBacnetValue.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_DATE, DateTime.Today.Date));
//loNewPropertyValue.value = loBacnetValue;
//loNewPropertyValue.property = new BacnetPropertyReference((uint)BacnetPropertyIds.PROP_EXCEPTION_SCHEDULE, ASN1.BACNET_ARRAY_ALL);
//loBacnetPropertyValueList.Add(loNewPropertyValue);
loBacnetValue = new List <BacnetValue>();
loNewPropertyValue = new BacnetPropertyValue();
BacnetWeeklyExceptionSchedule loBacnetWeeklyExceptionSchedule = new BacnetWeeklyExceptionSchedule();
List <ExceptionScheduleTimeValue>[] loExceptionSchedulTimeValue = new List <ExceptionScheduleTimeValue> [1];
loExceptionSchedulTimeValue[0] = new List <ExceptionScheduleTimeValue>();
loExceptionSchedulTimeValue[0].Add(new ExceptionScheduleTimeValue(DateTime.Now.AddMinutes(2), Convert.ToSingle(111)));
loBacnetWeeklyExceptionSchedule.loExceptionScheduleArray = new List <ExceptionScheduleArray> [1];
loBacnetWeeklyExceptionSchedule.loExceptionScheduleArray[0] = new List <ExceptionScheduleArray>();
loBacnetWeeklyExceptionSchedule.loExceptionScheduleArray[0].Add(new ExceptionScheduleArray(new DateTime(1, 1, 1, 18, 30, 1), loExceptionSchedulTimeValue));
loBacnetValue.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_SPECIAL_EVENT, loBacnetWeeklyExceptionSchedule));
loNewPropertyValue.value = loBacnetValue;
loNewPropertyValue.property = new BacnetPropertyReference((uint)BacnetPropertyIds.PROP_EXCEPTION_SCHEDULE, ASN1.BACNET_ARRAY_ALL);
loBacnetPropertyValueList.Add(loNewPropertyValue);
moBacnetClient.CreateObjectRequest(loBacnetAddress, new BacnetObjectId(BacnetObjectTypes.OBJECT_SCHEDULE, (uint)liTopInstanceID), loBacnetPropertyValueList);
}
}
else
{
if (liDeviceID < 0)
{
MessageBox.Show("Please select device");
}
else if (liObjectID < 0)
{
MessageBox.Show("Please select object");
}
else
{
MessageBox.Show("Schedule is not setup properly, please review.");
}
}
}
private static void OnWritePropertyRequest(BacnetClient sender, BacnetAddress adr, byte invoke_id, BacnetObjectId object_id, BacnetPropertyValue value, BacnetMaxSegments max_segments)
{
BacnetPropertyIds PropId = (BacnetPropertyIds)value.property.propertyIdentifier;
bool AllowWrite =
(object_id.Equals("OBJECT_ANALOG_VALUE:0") && (PropId == BacnetPropertyIds.PROP_OUT_OF_SERVICE)) ||
(object_id.Equals("OBJECT_ANALOG_VALUE:0") && (PropId == BacnetPropertyIds.PROP_PRESENT_VALUE)) ||
(object_id.Equals("OBJECT_ANALOG_VALUE:1") && (PropId == BacnetPropertyIds.PROP_PRESENT_VALUE)) ||
(object_id.Equals("OBJECT_ANALOG_VALUE:2") && (PropId == BacnetPropertyIds.PROP_PRESENT_VALUE)) ||
(object_id.Equals("OBJECT_ANALOG_VALUE:3") && (PropId == BacnetPropertyIds.PROP_PRESENT_VALUE)) ||
(object_id.Equals("OBJECT_CHARACTERSTRING_VALUE:1") && (PropId == BacnetPropertyIds.PROP_PRESENT_VALUE)) ||
(object_id.Equals("OBJECT_CHARACTERSTRING_VALUE:2") && (PropId == BacnetPropertyIds.PROP_PRESENT_VALUE)) ||
(object_id.Equals("OBJECT_CHARACTERSTRING_VALUE:3") && (PropId == BacnetPropertyIds.PROP_PRESENT_VALUE)) ||
(object_id.Equals("OBJECT_MULTI_STATE_VALUE:0") && (PropId == BacnetPropertyIds.PROP_PRESENT_VALUE));
if (AllowWrite == false)
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_WRITE_ACCESS_DENIED);
return;
}
lock (m_lockObject)
{
try
{
// Modif FC
DeviceStorage.ErrorCodes code = m_storage.WriteCommandableProperty(object_id, (BacnetPropertyIds)value.property.propertyIdentifier, value.value[0], value.priority);
if (code == DeviceStorage.ErrorCodes.NotForMe)
{
code = m_storage.WriteProperty(object_id, (BacnetPropertyIds)value.property.propertyIdentifier, value.property.propertyArrayIndex, value.value);
}
if (code == DeviceStorage.ErrorCodes.Good)
{
sender.SimpleAckResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id);
}
else
if (code == DeviceStorage.ErrorCodes.WriteAccessDenied)
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_WRITE_ACCESS_DENIED);
}
else
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_OTHER);
}
}
catch (Exception)
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_OTHER);
}
}
}
// Ici les remplacement de la lecture de quelques élements
private static void m_storage_ReadOverride(BacnetObjectId object_id, BacnetPropertyIds property_id, uint array_index, out IList <BacnetValue> value, out DeviceStorage.ErrorCodes status, out bool handled)
{
handled = true;
value = new BacnetValue[0];
status = DeviceStorage.ErrorCodes.Good;
if (object_id.type == BacnetObjectTypes.OBJECT_DEVICE && property_id == BacnetPropertyIds.PROP_OBJECT_LIST)
{
if (array_index == 0)
{
//object list count
value = new BacnetValue[] { new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_UNSIGNED_INT, (uint)m_storage.Objects.Length) };
}
else if (array_index != System.IO.BACnet.Serialize.ASN1.BACNET_ARRAY_ALL)
{
//object list index
value = new BacnetValue[] { new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_OBJECT_ID, new BacnetObjectId(m_storage.Objects[array_index - 1].Type, m_storage.Objects[array_index - 1].Instance)) };
}
else
{
//object list whole
BacnetValue[] list = new BacnetValue[m_storage.Objects.Length];
for (int i = 0; i < list.Length; i++)
{
list[i].Tag = BacnetApplicationTags.BACNET_APPLICATION_TAG_OBJECT_ID;
list[i].Value = new BacnetObjectId(m_storage.Objects[i].Type, m_storage.Objects[i].Instance);
}
value = list;
}
}
else if (object_id.type == BacnetObjectTypes.OBJECT_DEVICE && object_id.instance == m_storage.DeviceId && property_id == BacnetPropertyIds.PROP_PROTOCOL_OBJECT_TYPES_SUPPORTED)
{
BacnetValue v = new BacnetValue();
v.Tag = BacnetApplicationTags.BACNET_APPLICATION_TAG_BIT_STRING;
BacnetBitString b = new BacnetBitString();
b.SetBit((byte)BacnetObjectTypes.MAX_ASHRAE_OBJECT_TYPE, false); //set all false
b.SetBit((byte)BacnetObjectTypes.OBJECT_ANALOG_INPUT, true);
b.SetBit((byte)BacnetObjectTypes.OBJECT_DEVICE, true);
b.SetBit((byte)BacnetObjectTypes.OBJECT_ANALOG_VALUE, true);
b.SetBit((byte)BacnetObjectTypes.OBJECT_CHARACTERSTRING_VALUE, true);
b.SetBit((byte)BacnetObjectTypes.OBJECT_MULTI_STATE_VALUE, true);
b.SetBit((byte)BacnetObjectTypes.OBJECT_BINARY_VALUE, true);
v.Value = b;
value = new BacnetValue[] { v };
}
else if (object_id.type == BacnetObjectTypes.OBJECT_DEVICE && object_id.instance == m_storage.DeviceId && property_id == BacnetPropertyIds.PROP_PROTOCOL_SERVICES_SUPPORTED)
{
BacnetValue v = new BacnetValue();
v.Tag = BacnetApplicationTags.BACNET_APPLICATION_TAG_BIT_STRING;
BacnetBitString b = new BacnetBitString();
b.SetBit((byte)BacnetServicesSupported.MAX_BACNET_SERVICES_SUPPORTED, false); //set all false
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_SUBSCRIBE_COV, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_I_AM, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_WHO_IS, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_READ_PROP_MULTIPLE, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_READ_PROPERTY, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_WRITE_PROPERTY, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_CONFIRMED_COV_NOTIFICATION, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_UNCONFIRMED_COV_NOTIFICATION, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_SUBSCRIBE_COV_PROPERTY, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_REINITIALIZE_DEVICE, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_DEVICE_COMMUNICATION_CONTROL, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_TIME_SYNCHRONIZATION, true);
b.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_UTC_TIME_SYNCHRONIZATION, true);
v.Value = b;
value = new BacnetValue[] { v };
}
else if (object_id.type == BacnetObjectTypes.OBJECT_DEVICE && object_id.instance == m_storage.DeviceId && property_id == BacnetPropertyIds.PROP_SEGMENTATION_SUPPORTED)
{
BacnetValue v = new BacnetValue();
v.Tag = BacnetApplicationTags.BACNET_APPLICATION_TAG_ENUMERATED;
v.Value = (uint)BacnetSegmentations.SEGMENTATION_BOTH;
value = new BacnetValue[] { v };
}
else if (object_id.type == BacnetObjectTypes.OBJECT_DEVICE && object_id.instance == m_storage.DeviceId && property_id == BacnetPropertyIds.PROP_SYSTEM_STATUS)
{
BacnetValue v = new BacnetValue();
v.Tag = BacnetApplicationTags.BACNET_APPLICATION_TAG_ENUMERATED;
v.Value = (uint)BacnetDeviceStatus.OPERATIONAL; //can we be in any other mode I wonder?
value = new BacnetValue[] { v };
}
else if (object_id.type == BacnetObjectTypes.OBJECT_DEVICE && object_id.instance == m_storage.DeviceId && property_id == BacnetPropertyIds.PROP_ACTIVE_COV_SUBSCRIPTIONS)
{
List <BacnetValue> list = new List <BacnetValue>();
foreach (KeyValuePair <BacnetObjectId, List <Subscription> > entry in m_subscriptions)
{
foreach (Subscription sub in entry.Value)
{
//encode
System.IO.BACnet.Serialize.EncodeBuffer buffer = new System.IO.BACnet.Serialize.EncodeBuffer();
BacnetCOVSubscription cov = new BacnetCOVSubscription();
cov.Recipient = sub.reciever_address;
cov.subscriptionProcessIdentifier = sub.subscriberProcessIdentifier;
cov.monitoredObjectIdentifier = sub.monitoredObjectIdentifier;
cov.monitoredProperty = sub.monitoredProperty;
cov.IssueConfirmedNotifications = sub.issueConfirmedNotifications;
cov.TimeRemaining = (uint)sub.lifetime - (uint)(DateTime.Now - sub.start).TotalMinutes;
cov.COVIncrement = sub.covIncrement;
System.IO.BACnet.Serialize.ASN1.encode_cov_subscription(buffer, cov);
//add
BacnetValue v = new BacnetValue();
v.Tag = BacnetApplicationTags.BACNET_APPLICATION_TAG_COV_SUBSCRIPTION;
v.Value = buffer.ToArray();
list.Add(v);
}
}
value = list;
}
else if (object_id.type == BacnetObjectTypes.OBJECT_OCTETSTRING_VALUE && object_id.instance == 0 && property_id == BacnetPropertyIds.PROP_PRESENT_VALUE)
{
//this is our huge blob
BacnetValue v = new BacnetValue();
v.Tag = BacnetApplicationTags.BACNET_APPLICATION_TAG_OCTET_STRING;
byte[] blob = new byte[2000];
for (int i = 0; i < blob.Length; i++)
{
blob[i] = (i % 2 == 0) ? (byte)'A' : (byte)'B';
}
v.Value = blob;
value = new BacnetValue[] { v };
}
else if (object_id.type == BacnetObjectTypes.OBJECT_GROUP && property_id == BacnetPropertyIds.PROP_PRESENT_VALUE)
{
//get property list
IList <BacnetValue> properties;
if (m_storage.ReadProperty(object_id, BacnetPropertyIds.PROP_LIST_OF_GROUP_MEMBERS, System.IO.BACnet.Serialize.ASN1.BACNET_ARRAY_ALL, out properties) != DeviceStorage.ErrorCodes.Good)
{
value = new BacnetValue[] { new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ERROR, new BacnetError(BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_INTERNAL_ERROR)) };
}
else
{
List <BacnetValue> _value = new List <BacnetValue>();
foreach (BacnetValue p in properties)
{
if (p.Value is BacnetReadAccessSpecification)
{
BacnetReadAccessSpecification prop = (BacnetReadAccessSpecification)p.Value;
BacnetReadAccessResult result = new BacnetReadAccessResult();
result.objectIdentifier = prop.objectIdentifier;
List <BacnetPropertyValue> result_values = new List <BacnetPropertyValue>();
foreach (BacnetPropertyReference r in prop.propertyReferences)
{
BacnetPropertyValue prop_value = new BacnetPropertyValue();
prop_value.property = r;
if (m_storage.ReadProperty(prop.objectIdentifier, (BacnetPropertyIds)r.propertyIdentifier, r.propertyArrayIndex, out prop_value.value) != DeviceStorage.ErrorCodes.Good)
{
prop_value.value = new BacnetValue[] { new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_ERROR, new BacnetError(BacnetErrorClasses.ERROR_CLASS_DEVICE, BacnetErrorCodes.ERROR_CODE_INTERNAL_ERROR)) };
}
result_values.Add(prop_value);
}
result.values = result_values;
_value.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_READ_ACCESS_RESULT, result));
}
}
value = _value;
}
}
else
{
handled = false;
}
}
public ErrorCodes WritePropertyValue(BacnetClient sender, BacnetAddress adr, BacnetPropertyValue value, bool writeFromNetwork)
{
this.sender = sender;
return(WritePropertyValue(value, writeFromNetwork));
}
private void ParseValue()
{
if (this.BacnetPropertyValue == null)
{
return;
}
BacnetPropertyValue p_value = (BacnetPropertyValue)this.BacnetPropertyValue;
object value = null;
BacnetValue[] b_values = null;
if (p_value.value != null)
{
b_values = new BacnetValue[p_value.value.Count];
p_value.value.CopyTo(b_values, 0);
if (b_values.Length > 1)
{
object[] arr = new object[b_values.Length];
for (int j = 0; j < arr.Length; j++)
{
arr[j] = b_values[j].Value;
}
value = arr;
}
else if (b_values.Length == 1)
{
value = b_values[0].Value;
}
}
else
{
b_values = new BacnetValue[0];
}
var propName = GetNiceName((BacnetPropertyIds)p_value.property.propertyIdentifier);
var propRef = p_value.property;
//var readOnly = false; //may change...
var appTag = b_values.Length > 0 ? b_values[0].Tag : (BacnetApplicationTags?)null;
// Modif FC
CustomProperty cp;
Type propType = null;
Boolean readOnly;
switch ((BacnetPropertyIds)p_value.property.propertyIdentifier)
{
// PROP_RELINQUISH_DEFAULT can be write to null value
case BacnetPropertyIds.PROP_PRESENT_VALUE:
// change to the related nullable type
Type t = null;
try
{
t = value.GetType();
t = Type.GetType("System.Nullable`1[" + value.GetType().FullName + "]");
}
catch { }
propType = t != null ? t : typeof(string);
readOnly = false; //for now - in future, some properties may be
break;
default:
propType = value != null?value.GetType() : typeof(string);
readOnly = false;
break;
}
this.CustomProperty = new Utilities.CustomProperty(propName, value, propType, readOnly, "", appTag, null, propRef);
this.PropertyDescriptor = new BACnetCustomPropertyDescriptor(ref this.CustomProperty, new Attribute[] { });
//this.
//want to put in logic here so that priority array gets read as a string. Look at how property html is generated
}
/*****************************************************************************************************/
static void handler_OnWritePropertyRequest(BacnetClient sender, BacnetAddress adr, byte invoke_id, BacnetObjectId object_id, BacnetPropertyValue value, BacnetMaxSegments max_segments)
{
lock (device)
{
BaCSharpObject bacobj = device.FindBacnetObject(object_id);
if (bacobj != null)
{
ErrorCodes error = bacobj.WritePropertyValue(sender, adr, value, true);
if (error == ErrorCodes.Good)
{
sender.SimpleAckResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id);
}
else
{
BacnetErrorCodes bacEr = BacnetErrorCodes.ERROR_CODE_OTHER;
if (error == ErrorCodes.WriteAccessDenied)
{
bacEr = BacnetErrorCodes.ERROR_CODE_WRITE_ACCESS_DENIED;
}
if (error == ErrorCodes.OutOfRange)
{
bacEr = BacnetErrorCodes.ERROR_CODE_VALUE_OUT_OF_RANGE;
}
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_WRITE_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_DEVICE, bacEr);
}
}
else
{
sender.ErrorResponse(adr, BacnetConfirmedServices.SERVICE_CONFIRMED_READ_PROPERTY, invoke_id, BacnetErrorClasses.ERROR_CLASS_OBJECT, BacnetErrorCodes.ERROR_CODE_UNKNOWN_OBJECT);
}
}
}
public ErrorCodes WritePropertyValue(BacnetPropertyValue value, bool writeFromNetwork)
{
// First try to find the set2_ method in the class code
string lookup = $"set2_{value.property.ToString()}";
MethodInfo m;
if (!_writePropertyMethods.TryGetValue(lookup, out m))
{
m = GetType().GetMethod(lookup);
_writePropertyMethods.TryAdd(lookup, m);
}
try
{
if (m != null)
{
// Yes Invoke
ErrorCode_PropertyWrite = ErrorCodes.Good;
m.Invoke(this, new object[] { value.value, value.priority });
if (ErrorCode_PropertyWrite == ErrorCodes.Good)
{
if (OnWriteNotify != null)
{
OnWriteNotify(this, (BacnetPropertyIds)value.property.propertyIdentifier);
}
if (OnExternalCOVNotify != null)
{
OnExternalCOVNotify(this, (BacnetPropertyIds)value.property.propertyIdentifier);
}
}
return(ErrorCode_PropertyWrite);
}
}
catch
{
return(ErrorCodes.GenericError);
}
// Second, if not found, try to find in the programmed properties list
PropertyInfo p;
if (!_writePropertyProperties.TryGetValue(value.property.ToString(), out p))
{
p = GetType().GetProperty(value.property.ToString());
_writePropertyProperties.TryAdd(lookup, p);
}
if (p != null)
{
if (p.GetSetMethod() == null)
{
return(ErrorCodes.WriteAccessDenied);
}
try
{
// since Property cannot return error, this member could be set if a problem occure
// or an Exception can be throw
ErrorCode_PropertyWrite = ErrorCodes.Good;
try
{
if (value.value.Count == 1)
{
try
{
p.SetValue(this, value.value[0].Value, null); // The value is not a List< >
}
catch { }
}
else
{
p.SetValue(this, value.value, null); // The value is a List < >
}
}
catch
{
p.SetValue(this, value.value[0].Value, null); // The value is not a List< > but a List<> was given
}
if (ErrorCode_PropertyWrite == ErrorCodes.Good)
{
if (OnWriteNotify != null)
{
OnWriteNotify(this, (BacnetPropertyIds)value.property.propertyIdentifier);
}
if (OnExternalCOVNotify != null)
{
OnExternalCOVNotify(this, (BacnetPropertyIds)value.property.propertyIdentifier);
}
}
return(ErrorCode_PropertyWrite);
}
catch
{
return(ErrorCodes.GenericError);
}
}
return(ErrorCodes.NotExist);
}
public BACnetProperty(BACnetObject bno, BacnetPropertyIds property_id, BacnetPropertyValue property_value) //, uint array_index = System.IO.BACnet.Serialize.ASN1.BACNET_ARRAY_ALL) //this(bno, property_id, array_index)
{
Initialize(bno, property_id);
this.BacnetPropertyValue = property_value;
ParseValue();
}
