All information in a BACnet system is represented in terms of objects. An object is an abstract concept that
allows us to talk about and organize information relating to physical inputs and outputs, as well as non-physical
concepts like software, or calculations.
Objects may represent single physical "points", or logical groupings or collections of points which perform a
specific function. For example, an object might represent a physical input device like a temperature sensor or thermostat,
or an output device like a fan or pump or valve position. Objects can also represent non-physical concepts like program
logic, schedules and historical data.
All objects in BACnet provide a set of properties that are used to get information from the object, or give
information and commands to an object. You can think of an object's properties as a table with two columns. On the
left is the name or identifier for the property, and on the right is the property's value. Some properties are read-only
meaning that you can look at the property value, but not change it. Some properties can be changed (written).
Here is an example of a temperature sensor, which might be represented as a BACnet Analog Input object. The
example shows a few of the properties that might be available with this object, although in practice there would be
many more properties than those shown.
The object has a name property ("SPACE TEMP") and an object type (ANALOG INPUT). The Present_Value property tells us
what the temperature sensor is reading at this moment (72.3 degrees). Other properties show us other information about
the sensor object, such as whether it appears to be functioning normally, or High and Low Limits for alarming purposes.
Although there are many potentially useful object types that might be found in building automation, BACnet
defines 23 standard object types in some detail. A BACnet standard object is one whose behavior, in terms of which
properties it provides and what they do, is defined in the BACnet standard.
This set of standard objects represents much of the functionality found in typical building automation and controls
systems today. BACnet devices are only required to implement the Device object. Other objects are included as
appropriate to the device's functions.
Each of the standard objects in BACnet defines a set of required properties and a set of optional properties.
Required properties must be implemented for each object of a given type which purports to be a BACnet standard
object of that type. An optional property does not have to be implemented, but if the vendor claims that it is
implemented, then it must behave as the standard describes.
Here is an example of a few of the required and optional properties for an analog input object.
It is also possible, and expected, that some vendors will implement their own non-standard properties for some
objects. BACnet allows vendors to implement any number of non-standard properties, with whatever behavior the vendor
It is also possible, and encouraged, for vendors to implement their own additional object types. These non-standard
object types may include whatever properties the vendor chooses.
Whether an object type is non-standard or not, and whether a property is proprietary or not, the object property is
read or written in the same manner. All you need to know is the existence of a property and what its purpose is, and
you can use it just like any of the standard properties. This key fact allows vendors to extend BACnet and add
functionality into BACnet arbitrarily into the future, without ever changing the standard itself.
As new technology and techniques are invented, new object types can be used
to represent the key parameters or information from and control of those objects. Innovation can proceed without
interference from BACnet!
It is important to understand that non-standard objects and/or properties are not a bad thing. In fact, this feature
may be the single most important aspect of BACnet because it allows new functionality to be incorporated into a vendor's
product without requiring a change to the standard, or anyone's "permission", and without breaking existing implementations.
Having said this, it is also important to note that not all implementations of non-standard properties and objects will be
useable by all BACnet Systems automatically. In particular, only properties with primitive data types such as Booleans,
integers, Reals, character strings and so forth, can be assured a wide range of interoperability.