public BacnetLogRecord(BacnetTrendLogValueType type, object value, DateTime stamp, uint status)
{
this.type = type;
timestamp = stamp;
statusFlags = BacnetBitString.ConvertFromInt(status);
any_value = null;
Value = value;
}
public BinaryObject(BacnetObjectId ObjId, string ObjName, string Description, bool InitialValue)
: base(ObjId, ObjName, Description)
{
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)0, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)1, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)2, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)3, false);
m_PROP_PRESENT_VALUE = InitialValue == true ? (uint)1 : 0;
}
public TrendLog(int ObjId, string ObjName, string Description, uint Logsize, BacnetTrendLogValueType DefaultValueType)
: base(new BacnetObjectId(BacnetObjectTypes.OBJECT_TRENDLOG, (uint)ObjId), ObjName, Description)
{
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)0, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)1, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)2, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)3, false);
this.DefaultValueType = DefaultValueType;
m_PROP_BUFFER_SIZE = Logsize;
}
public Schedule(int ObjId, string ObjName, string Description)
: base(new BacnetObjectId(BacnetObjectTypes.OBJECT_SCHEDULE, (uint)ObjId), ObjName, Description)
{
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)0, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)1, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)2, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)3, false);
m_PROP_EFFECTIVE_PERIOD.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_DATE, DateTime.Now));
m_PROP_EFFECTIVE_PERIOD.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_DATE, DateTime.Now.AddYears(10)));
}
public CharacterString(int ObjId, string ObjName, string Description, string InitialValue, bool ReadOnly)
: base(new BacnetObjectId(BacnetObjectTypes.OBJECT_CHARACTERSTRING_VALUE, (uint)ObjId), ObjName, Description)
{
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)0, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)1, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)2, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)3, false);
m_PRESENT_VALUE_ReadOnly = ReadOnly;
m_PROP_PRESENT_VALUE = InitialValue;
}
public RecipientUserCtrl(TabPage myTab, DeviceReportingRecipient?recipient = null)
{
InitializeComponent();
this.myTab = myTab;
if (recipient == null)
{
for (byte i = 0; i < 7; i++)
{
WeekOfDay.SetBit(i, true);
}
for (byte i = 0; i < 3; i++)
{
EventType.SetBit(i, true);
}
return;
}
if (recipient.Value.adr != null)
{
adr = recipient.Value.adr;
Device.Text = adr.ToString();
}
else
{
deviceid = recipient.Value.Id.instance;
Device.Text = deviceid.ToString();
}
AckRequired.Checked = recipient.Value.Ack_Required;
ProcessId.Text = recipient.Value.processIdentifier.ToString();
WeekOfDay = recipient.Value.WeekofDay;
// dispatch the days
Monday.Checked = ((WeekOfDay.value[0] & 1) == 1);
Tuesday.Checked = ((WeekOfDay.value[0] & 2) == 2);
Wedesnday.Checked = ((WeekOfDay.value[0] & 4) == 4);
Thursday.Checked = ((WeekOfDay.value[0] & 8) == 8);
Friday.Checked = ((WeekOfDay.value[0] & 16) == 16);
Saturday.Checked = ((WeekOfDay.value[0] & 32) == 32);
Sunday.Checked = ((WeekOfDay.value[0] & 64) == 64);
EventType = recipient.Value.evenType;
// dispatch the event types
To_OffNormal.Checked = ((EventType.value[0] & 1) == 1);
To_Fault.Checked = ((EventType.value[0] & 2) == 2);
To_Normal.Checked = ((EventType.value[0] & 4) == 4);
// Some problems when date is 0 in the original values (readed for the device)
// so toTime.Value=toTime cannot be done
toTime.Value = new DateTime(2000, 1, 1, recipient.Value.toTime.Hour, recipient.Value.toTime.Minute, recipient.Value.toTime.Second);
fromTime.Value = new DateTime(2000, 1, 1, recipient.Value.fromTime.Hour, recipient.Value.fromTime.Minute, recipient.Value.fromTime.Second);
}
public override object ConvertFrom(ITypeDescriptorContext context,
CultureInfo culture, object value)
{
if (value is string)
{
try
{
return(BacnetBitString.Parse(value as String));
}
catch { return(null); }
}
return(base.ConvertFrom(context, culture, value));
}
public NotificationClass(int ObjId, string ObjName, string Description, BacnetObjectId Device)
: base(new BacnetObjectId(BacnetObjectTypes.OBJECT_NOTIFICATION_CLASS, (uint)ObjId), ObjName, Description)
{
this.Device = Device;
for (int i = 0; i < 3; i++)
{
m_PROP_PRIORITY[i] = new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_UNSIGNED_INT, (uint)127);
}
m_PROP_ACK_REQUIRED = m_PROP_ACK_REQUIRED.SetBit((byte)0, false);
m_PROP_ACK_REQUIRED = m_PROP_ACK_REQUIRED.SetBit((byte)1, false);
m_PROP_ACK_REQUIRED = m_PROP_ACK_REQUIRED.SetBit((byte)2, false);
}
public AnalogObject(BacnetObjectId ObjId, string ObjName, string Description, T InitialValue, BacnetUnitsId Unit)
: base(ObjId, ObjName, Description)
{
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)0, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)1, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)2, false);
m_PROP_STATUS_FLAGS = m_PROP_STATUS_FLAGS.SetBit((byte)3, false);
m_PROP_UNITS = (uint)Unit;
m_PROP_PRESENT_VALUE = InitialValue;
AnalogObjectEvent();
}
public void Enable_Reporting(bool State, uint NotificationClassId = 0)
{
// INTRINSIC_REPORTING
m_PROP_LIMIT_ENABLE = m_PROP_LIMIT_ENABLE.SetBit((byte)0, State); // Low Limit enabled
m_PROP_LIMIT_ENABLE = m_PROP_LIMIT_ENABLE.SetBit((byte)1, State); // High Limit enabled
m_PROP_EVENT_ENABLE = m_PROP_EVENT_ENABLE.SetBit((byte)0, State); // TO_OFFNORMAL (High or Low)
m_PROP_EVENT_ENABLE = m_PROP_EVENT_ENABLE.SetBit((byte)1, State); // TO_FAULT (not used here)
m_PROP_EVENT_ENABLE = m_PROP_EVENT_ENABLE.SetBit((byte)2, State); // TO_NORMAL (back to a good value)
m_PROP_ACKED_TRANSITIONS = m_PROP_ACKED_TRANSITIONS.SetBit((byte)0, true);
m_PROP_ACKED_TRANSITIONS = m_PROP_ACKED_TRANSITIONS.SetBit((byte)1, true);
m_PROP_ACKED_TRANSITIONS = m_PROP_ACKED_TRANSITIONS.SetBit((byte)2, true);
m_PROP_NOTIFICATION_CLASS = NotificationClassId;
IntrinsicReportingManagement();
}
// Each object provided by the server must be added one by one to the DeviceObject
public virtual void AddBacnetObject(BaCSharpObject newObj)
{
ObjectsList.Add(newObj);
newObj.deviceOwner = this;
// Update OBJECT_TYPES_SUPPORTED
m_PROP_PROTOCOL_OBJECT_TYPES_SUPPORTED = m_PROP_PROTOCOL_OBJECT_TYPES_SUPPORTED.SetBit((byte)newObj.PROP_OBJECT_IDENTIFIER.Type, true);
// Update OBJECT_LIST
m_PROP_OBJECT_LIST.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_OBJECT_ID, newObj.PROP_OBJECT_IDENTIFIER));
// Update the structured object list
// but only if the caller is not a view
// check by caller method type class appartenance
MethodBase m = new StackFrame(1).GetMethod();
bool CallerIsView = (m.DeclaringType.Name == "StructuredView");
if (!CallerIsView)
{
m_PROP_STRUCTURED_OBJECT_LIST.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_OBJECT_ID, newObj.PROP_OBJECT_IDENTIFIER));
}
}
} // for NewtonJson
public DeviceObject(uint Id, string DeviceName, string Description, bool UseStructuredView)
: base(new BacnetObjectId(BacnetObjectTypes.OBJECT_DEVICE, Id), DeviceName, Description)
{
this.UseStructuredView = UseStructuredView;
m_PROP_OBJECT_LIST.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_OBJECT_ID, m_PROP_OBJECT_IDENTIFIER));
m_PROP_STRUCTURED_OBJECT_LIST.Add(new BacnetValue(BacnetApplicationTags.BACNET_APPLICATION_TAG_OBJECT_ID, m_PROP_OBJECT_IDENTIFIER));
m_PROP_PROTOCOL_OBJECT_TYPES_SUPPORTED = m_PROP_PROTOCOL_OBJECT_TYPES_SUPPORTED.SetBit((byte)BacnetObjectTypes.OBJECT_DEVICE, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.MAX_BACNET_SERVICES_SUPPORTED, false); //set all false
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_I_AM, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_WHO_IS, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_READ_PROP_MULTIPLE, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_READ_PROPERTY, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_WRITE_PROPERTY, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_SUBSCRIBE_COV, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_SUBSCRIBE_COV_PROPERTY, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_CONFIRMED_COV_NOTIFICATION, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_UNCONFIRMED_COV_NOTIFICATION, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_READ_RANGE, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_ATOMIC_READ_FILE, true);
m_PROP_PROTOCOL_SERVICES_SUPPORTED = m_PROP_PROTOCOL_SERVICES_SUPPORTED.SetBit((byte)BacnetServicesSupported.SERVICE_SUPPORTED_ATOMIC_WRITE_FILE, true);
}
public static BacnetValue DeserializeValue(string value, BacnetApplicationTags type)
{
switch (type)
{
case BacnetApplicationTags.BACNET_APPLICATION_TAG_NULL:
if (value == "")
{
return(new BacnetValue(type, null)); // Modif FC
}
else
{
return(new BacnetValue(value));
}
case BacnetApplicationTags.BACNET_APPLICATION_TAG_BOOLEAN:
return(new BacnetValue(type, bool.Parse(value)));
case BacnetApplicationTags.BACNET_APPLICATION_TAG_UNSIGNED_INT:
return(new BacnetValue(type, uint.Parse(value)));
case BacnetApplicationTags.BACNET_APPLICATION_TAG_SIGNED_INT:
return(new BacnetValue(type, int.Parse(value)));
case BacnetApplicationTags.BACNET_APPLICATION_TAG_REAL:
return(new BacnetValue(type, float.Parse(value, System.Globalization.CultureInfo.InvariantCulture)));
case BacnetApplicationTags.BACNET_APPLICATION_TAG_DOUBLE:
return(new BacnetValue(type, double.Parse(value, System.Globalization.CultureInfo.InvariantCulture)));
case BacnetApplicationTags.BACNET_APPLICATION_TAG_OCTET_STRING:
try
{
return(new BacnetValue(type, Convert.FromBase64String(value)));
}
catch
{
return(new BacnetValue(type, value));
}
case BacnetApplicationTags.BACNET_APPLICATION_TAG_CONTEXT_SPECIFIC_DECODED:
try
{
return(new BacnetValue(type, Convert.FromBase64String(value)));
}
catch
{
return(new BacnetValue(type, value));
}
case BacnetApplicationTags.BACNET_APPLICATION_TAG_CHARACTER_STRING:
return(new BacnetValue(type, value));
case BacnetApplicationTags.BACNET_APPLICATION_TAG_BIT_STRING:
return(new BacnetValue(type, BacnetBitString.Parse(value)));
case BacnetApplicationTags.BACNET_APPLICATION_TAG_ENUMERATED:
return(new BacnetValue(type, uint.Parse(value)));
case BacnetApplicationTags.BACNET_APPLICATION_TAG_DATE:
return(new BacnetValue(type, DateTime.Parse(value)));
case BacnetApplicationTags.BACNET_APPLICATION_TAG_TIME:
return(new BacnetValue(type, DateTime.Parse(value)));
case BacnetApplicationTags.BACNET_APPLICATION_TAG_OBJECT_ID:
return(new BacnetValue(type, BacnetObjectId.Parse(value)));
case BacnetApplicationTags.BACNET_APPLICATION_TAG_READ_ACCESS_SPECIFICATION:
return(new BacnetValue(type, BacnetReadAccessSpecification.Parse(value)));
default:
return(new BacnetValue(type, null));
}
}
// 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;
}
}
/*****************************************************************************************************/
static void InitDeviceObjects()
{
// create the device object with StructuredView acceptation
device = new DeviceObject(deviceId, "Device test", "A test Device", true);
// ANALOG_INPUT:0 uint
// initial value 0
ana0 = new AnalogInput <double>
(
0,
"Ana0 Sin double",
"Ana0 Sin double",
0,
BacnetUnitsId.UNITS_AMPERES
);
ana0.m_PROP_HIGH_LIMIT = 50;
ana0.m_PROP_LOW_LIMIT = -50;
ana0.m_PROP_DEADBAND = 5;
ana0.Enable_Reporting(true, 0);
device.AddBacnetObject(ana0); // don't forget to do this
// Binary Output
device.AddBacnetObject(new BinaryOutput(0, "Bin Out", "An output", false));
// Create A StructuredView
StructuredView s = new StructuredView(0, "Content", "A View");
// register it
device.AddBacnetObject(s); // don't forget to do this
BaCSharpObject b;
// ANALOG_VALUE:0 double with Priority Array
//
b = new AnalogValue <double>
(
0,
"Ana0 Double",
"Ana0 Double",
5465.23,
BacnetUnitsId.UNITS_BARS,
true
);
s.AddBacnetObject(b); // Put it in the view
b.OnWriteNotify += new BaCSharpObject.WriteNotificationCallbackHandler(handler_OnWriteNotify);
// ANALOG_OUTPUT:1 int with Priority Array on Present Value
b = new AnalogOutput <int>
(
1,
"Ana1 int",
"Ana1 int",
(int)56,
BacnetUnitsId.UNITS_DEGREES_CELSIUS
);
s.AddBacnetObject(b); // Put it in the view
b.OnWriteNotify += new BaCSharpObject.WriteNotificationCallbackHandler(handler_OnWriteNotify);
// MULTI_STATE_OUTPUT:4 with 6 states
MultiStateOutput m = new MultiStateOutput
(
4,
"MultiStates",
"MultiStates",
1,
6
);
for (int i = 1; i < 7; i++)
{
m.m_PROP_STATE_TEXT[i - 1] = new BacnetValue("Text Level " + i.ToString());
}
s.AddBacnetObject(m); // in the view
StructuredView s2 = new StructuredView(1, "Complex objects", "Complex objects");
s.AddBacnetObject(s2);
// TREND_LOG:0 with int values
// new TrendLog can be changed by new TrendLogCustom
trend0 = new TrendLog(0, "Trend signed int", "Trend signed int", 200, BacnetTrendLogValueType.TL_TYPE_SIGN);
s2.AddBacnetObject(trend0); // in the second level view
// fill Log with more values than the size
for (int i = 0; i < 300; i++)
{
DateTime current = DateTime.Now.AddSeconds(-300 + i);
if ((i > 200) && (i < 210)) // simulate some errors in the trend
{
trend0.AddValue(new BacnetError(), current, 0, BacnetTrendLogValueType.TL_TYPE_ERROR);
}
else
{
trend0.AddValue((int)(i * Math.Sin((float)i / 0.01)), current, 0);
}
}
trend0.AddValue(new BacnetError(), DateTime.Now, 0, BacnetTrendLogValueType.TL_TYPE_ERROR);
// BACFILE:0
// File access right me be allowed to the current user
// for read and for write if any
b = new BacnetFile
(
0,
"A file",
"File description",
"c:\\RemoteObject.xml",
false
);
s2.AddBacnetObject(b); // in the second level view
NotificationClass nc = new NotificationClass
(
0,
"An alarm sender",
"Alarm description",
device.PROP_OBJECT_IDENTIFIER
);
device.AddBacnetObject(nc);
// Put two elements into the NC recipient List
// Valid Day
BacnetBitString week = new BacnetBitString();
for (int i = 0; i < 7; i++)
{
week.SetBit((byte)i, true); // Monday to Sunday
}
// transition
BacnetBitString transition = new BacnetBitString();
transition.SetBit(0, true); // To OffNormal
transition.SetBit(1, true); // To Fault
transition.SetBit(2, true); // To Normal
DeviceReportingRecipient r = new DeviceReportingRecipient
(
week, // week days
DateTime.MinValue.AddDays(10), // fromTime
DateTime.MaxValue, // toTime
new BacnetObjectId(BacnetObjectTypes.OBJECT_DEVICE, 4000),
(uint)4, // processid
true, // Ack required
transition // transition
);
nc.AddReportingRecipient(r);
r = new DeviceReportingRecipient
(
week,
DateTime.MinValue.AddDays(10),
DateTime.MaxValue,
new BacnetAddress(BacnetAddressTypes.IP, 0, new Byte[6] {
255, 255, 255, 255, 0xBA, 0xC0
}),
(uint)4,
true,
transition
);
nc.AddReportingRecipient(r);
// Create a Schedule
Schedule sch = new Schedule(0, "Schedule", "Schedule");
// MUST be added to the device list before modification
device.AddBacnetObject(sch);
// a link to the internal analog output
sch.AddPropertyReference(new BacnetDeviceObjectPropertyReference
(
new BacnetObjectId(BacnetObjectTypes.OBJECT_ANALOG_OUTPUT, 1),
BacnetPropertyIds.PROP_PRESENT_VALUE)
);
// a link to analog output through the network : could be on another device than itself
sch.AddPropertyReference(new BacnetDeviceObjectPropertyReference
(
new BacnetObjectId(BacnetObjectTypes.OBJECT_ANALOG_OUTPUT, 1),
BacnetPropertyIds.PROP_PRESENT_VALUE,
new BacnetObjectId(BacnetObjectTypes.OBJECT_DEVICE, 4000))
);
sch.PROP_SCHEDULE_DEFAULT = (int)452;
// Schedule a change today in 60 seconds
sch.AddSchedule
(
DateTime.Now.DayOfWeek == 0 ? 6 : (int)DateTime.Now.DayOfWeek - 1, // Monday=0, Sunday=6
DateTime.Now.AddSeconds(10), (int)900
);
sch.PROP_OUT_OF_SERVICE = false; // needed after all initialization to start the service
// One empty Calendar, could be fullfill with yabe
Calendar cal = new Calendar(0, "Test Calendar", "A Yabe calendar");
device.AddBacnetObject(cal);
}
