Struct ColorTemperatureObject 

pub struct ColorTemperatureObject { /* private fields */ }

BACnet Color Temperature object (type 64).

Holds a correlated colour temperature in kelvin, 1000 to 30000 and within Min_Pres_Value and Max_Pres_Value. It isn’t commandable: Present_Value takes a write with no priority array, clamping a value between 1000 and Min_Pres_Value up to the minimum, and one between Max_Pres_Value and 30000 down to the maximum (Clause 12.Y.4).

Color_Command takes a BACnetColorCommand whose operation is FADE_TO_CCT, RAMP_TO_CCT, STEP_UP_CCT, STEP_DOWN_CCT or STOP (see set_color_command) and carries it out (#1474). FADE_TO_CCT and RAMP_TO_CCT set Present_Value to the target, clamped to the limits, and move Tracking_Value to it from where it stands, over the command’s fade time or at its ramp rate (the defaults when it carries none), with In_Progress FADE_ACTIVE or RAMP_ACTIVE until it arrives. The step operations set Present_Value at once to Tracking_Value plus or minus the step increment, clamped to the limits. STOP ends a fade or ramp there, and Present_Value takes the temperature it reached. A Present_Value write halts a fade or ramp too, then moves to the new temperature as Transition says: at once for NONE, a fade over Default_Fade_Time for FADE, or a ramp at Default_Ramp_Rate for RAMP.

Fades and ramps run on the monotonic clock the database binds, as a Color object’s fades do.

Cloning copies served state into an in-memory object. Tags persistence and pending saves remain solely with the original; cloning or dropping the copy never saves, corrects, settles, or waits on the original writer.

Implementations

impl ColorTemperatureObject

pub fn new(instance: u32, name: impl Into<String>) -> Result<Self, Error>

Create a Color Temperature object at 4000 K (neutral white), which is also its Default_Color_Temperature.

Min_Pres_Value and Max_Pres_Value start at the full 1000 to 30000 K range, Default_Fade_Time at 100 ms (as a Color object’s does), Default_Ramp_Rate at 100 K/s, Default_Step_Increment at 50 K and Transition at NONE.

pub fn with_output_persistence( self, persistence: Arc<dyn ColorOutputPersistence>, ) -> Result<Self, Error>

Keep Present_Value in persistence (#1526), and take the temperature it saved for this object, if any, as Present_Value, clamped to Min_Pres_Value and Max_Pres_Value. Call it right after building the object, before anything writes Present_Value.

Saving works as on a Color object (ColorObject::with_output_persistence). With a Default_Color_Temperature of 0, the device’s start keeps the saved temperature (Clause 12.Y.4).

Fails with storage’s error when what it holds can’t be loaded, and when it holds an xy colour or a temperature outside 1000 to 30000 K.

pub fn output_restored(&self) -> bool

Whether Present_Value came back from storage (with_output_persistence).

pub fn output_save_counters(&self) -> Option<ColorOutputSaveCounters>

The Present_Value save counters, shared with the object, or None without storage. Take them before the object joins a database.

pub fn wait_for_output_saves(&self)

Block until the Present_Value saves queued so far have run. Dropping the object waits for them too.

pub fn default_color_temperature(&self) -> u32

Default_Color_Temperature in kelvin: the temperature the device’s start drives the output to, or 0 to keep the one from before the restart.

pub fn set_default_color_temperature( &mut self, kelvin: u32, ) -> Result<(), Error>

Set Default_Color_Temperature, as a WriteProperty of it would: 0, or 1000 to 30000 K clamped to Min_Pres_Value and Max_Pres_Value (Clause 12.Y.8). Any other value is refused with VALUE_OUT_OF_RANGE.

pub fn start_output(&mut self)

Drive the output as the device’s start does (#1526), as a Color object’s start_output does.

A non-zero Default_Color_Temperature becomes Present_Value at once, whatever was set before the start. With a default of 0 the output keeps, in order: the temperature restored from storage; else one set before the start; else nothing, and In_Progress reads NOT_CONTROLLED until a Present_Value or Color_Command write drives it (Clause 12.Y.4). Either value is clamped to Min_Pres_Value and Max_Pres_Value as they stand at the start.

pub fn set_value_source_tracking(&mut self, enabled: bool)

Track Value_Source (Clause 19.5, #1552), as a Color object’s set_value_source_tracking does. A set_min_max that moves Present_Value leaves no source either.

pub fn with_tags_persistence( instance: u32, name: impl Into<String>, persistence: Arc<dyn TagsPersistence>, ) -> Result<Self, Error>

Build with application-owned Tags storage. Saved Tags override configured Tags only while set_profile provisions the row. Loaded data must satisfy the normal Tags rules and the opt-in 1 MiB snapshot limit.

pub fn wait_for_tag_saves(&self)

Wait for queued save attempts to finish. This is not a success receipt; writes report their own save outcomes. Unstaged local writes block.

pub fn set_profile(&mut self, profile: ObjectProfile) -> Result<(), Error>

Provision the optional Tags, Profile_Location and Profile_Name rows before registration (#1553; see ObjectProfile). Tags takes writes; the profile rows are read-only over the network. A profile that fails ObjectProfile::check is refused and changes nothing.

pub fn set_audit_policy(&mut self, policy: ObjectAuditPolicy)

Provision the optional Audit_Level and Auditable_Operations rows before registration, as a Color object’s are (#1525). Table 12-Y has no Audit_Priority_Filter either, so a priority filter in policy is left out.

pub fn set_present_value(&mut self, kelvin: u32) -> Result<(), Error>

Set Present_Value in kelvin, as a WriteProperty of it would.

A value outside 1000 to 30000 is refused with VALUE_OUT_OF_RANGE and changes nothing; one inside is clamped to Min_Pres_Value and Max_Pres_Value (Clause 12.Y.4). A fade or ramp in progress is then halted, and the output moves to the value as Transition says.

pub fn set_min_max(&mut self, min: u32, max: u32) -> Result<(), Error>

Set Min_Pres_Value and Max_Pres_Value, in kelvin.

Clauses 12.Y.13 and 12.Y.14 keep them within 1000 to 30000; a minimum below 1000, a maximum above 30000 or a minimum above the maximum is refused with VALUE_OUT_OF_RANGE and changes nothing. A Present_Value outside the new limits moves to the nearer one at once, halting any fade or ramp, and a non-zero Default_Color_Temperature is clamped the same way.

pub fn color_command(&self) -> BACnetColorCommand

The last command written to Color_Command, or operation NONE with no other field before any write.

pub fn set_color_command( &mut self, command: BACnetColorCommand, ) -> Result<(), Error>

Set Color_Command and carry the command out, as a WriteProperty of the encoded command would.

The command is checked against the Color Temperature object’s table of colour commands (Addendum 135-2020ca, Table 12-Y2): FADE_TO_CCT, RAMP_TO_CCT, STEP_UP_CCT, STEP_DOWN_CCT and STOP are taken. FADE_TO_CCT and RAMP_TO_CCT need a target colour temperature of 1000 to 30000 K. A field the operation uses must be in range: fade time (FADE_TO_CCT) 100 to 86,400,000 ms, ramp rate (RAMP_TO_CCT) 1 to 30000 K/s, step increment (the step operations) 1 to 30000 K. Fields the operation doesn’t use are kept unchecked. A refusal is VALUE_OUT_OF_RANGE and leaves the object unchanged.

Trait Implementations

impl BACnetObject for ColorTemperatureObject

fn object_identifier(&self) -> ObjectIdentifier

The object’s identifier (type + instance).

fn object_name(&self) -> &str

The object’s name.

fn read_property( &self, property: PropertyIdentifier, array_index: Option<u32>, ) -> Result<PropertyValue, Error>

Read a property value.

fn write_property( &mut self, property: PropertyIdentifier, array_index: Option<u32>, value: PropertyValue, priority: Option<u8>, ) -> Result<(), Error>

Write a property value.

fn write_property_from( &mut self, property: PropertyIdentifier, array_index: Option<u32>, value: PropertyValue, priority: Option<u8>, origin: &CommandOrigin, ) -> Result<(), Error>

Write with explicit actual command provenance. Standalone callers assert the origin; server boundaries additionally validate ingress or membership. Decorators must forward this hook without discarding the origin. The default preserves custom/unaffected object behavior. First-party source-tracked commands require this hook and deny context-free writing.

fn property_metadata(&self) -> Cow<'_, [PropertyMetadata]>

Return canonical metadata for this object’s effective property rows.

fn property_list(&self) -> Cow<'static, [PropertyIdentifier]>

List all properties this object supports in the legacy projection.

fn supports_cov(&self) -> bool

Whether this object type supports COV notifications.

fn is_writable_property(&self, property: PropertyIdentifier) -> bool

Whether a property write route can accept property for this object.

fn is_array_property(&self, property: PropertyIdentifier) -> bool

Whether property accepts an array index on this object.

fn is_list_property(&self, property: PropertyIdentifier) -> bool

Whether property is a BACnetLIST on this object.

fn is_createable(&self) -> bool

Whether this object type can be created at runtime via CreateObject.

fn creation_only_properties(&self) -> &'static [PropertyIdentifier]

The properties whose whole value a CreateObject initial value may set on this object although WriteProperty can’t change it afterwards.

fn initialize_property( &mut self, _property: PropertyIdentifier, _value: PropertyValue, ) -> Result<(), Error>

Apply a CreateObject initial value to one of Self::creation_only_properties, written whole.

fn is_deleteable(&self) -> bool

Whether this object type can be deleted at runtime via DeleteObject.

fn required_properties(&self) -> Cow<'static, [PropertyIdentifier]>

List the REQUIRED properties for this object type.

fn supports_subscribe_cov_property(&self) -> bool

Whether SubscribeCOVProperty and SubscribeCOVPropertyMultiple may monitor this object’s properties.

fn supports_cov_property(&self, property: PropertyIdentifier) -> bool

Whether a readable property supports property-specific COV.

fn cov_increment(&self) -> Option<f64>

COV increment for this object (objects with a COV_Increment property).

fn cov_reported_properties(&self) -> &'static [CovReportedProperty]

Properties a whole-object (SubscribeCOV) notification reports after its leading value and Status_Flags, in report order.

fn set_overridden(&mut self, _overridden: bool)

Set the OVERRIDDEN bit in StatusFlags.

fn evaluate_intrinsic_reporting(&mut self) -> Option<TransitionOutcome>

Evaluate intrinsic reporting after a present_value change.

fn tick_intrinsic_reporting(&mut self) -> Option<TransitionOutcome>

Advance the Time_Delay countdown for a pending transition.

fn tick_schedule( &mut self, _today: SpecificDate, _time: Time, _calendar_active: &dyn Fn(ObjectIdentifier) -> bool, ) -> Option<ScheduleWrite>

Evaluate this object’s schedule at time on today (Clause 12.24.4).

fn take_owed_schedule_writes(&mut self) -> Vec<ScheduleWrite>

Take the writes this schedule owes its targets apart from its calculation, each once, in order: a NULL to every priority slot a change of List_Of_Object_Property_References or Priority_For_Writing left behind (#1088), then the Present_Value owed out of service, for a client’s write (Clause 12.24.14) or a change of those two properties.

fn complete_schedule_write( &mut self, _write: &ScheduleWrite, _outcomes: &[ScheduleTargetOutcome], ) -> bool

Report how each target took write, one of this schedule’s writes: outcomes holds one entry per member of write.references, in order.

fn retry_refusals_naming( &self, _target: ObjectIdentifier, ) -> Option<ScheduleWrite>

The retry of the current value to the references whose last write was refused and that name target, an object just added to the database (#1440), so the refusal can clear without waiting for the next pass. None when no such refusal stands, or when the pass itself would retry nothing: out of service, outside Effective_Period, or with a NULL Present_Value. Only meaningful for Schedule objects; default returns None.

fn acknowledge_alarm( &mut self, _transition_bit: EventTransitionBits, ) -> Result<(), Error>

Acknowledge an alarm transition. Sets the transition_bit flags in acked_transitions. Returns Ok(()) if the object supports event detection, Err otherwise.

fn apply_life_safety_operation( &mut self, _operation: LifeSafetyOperation, ) -> Result<LifeSafetyOperationOutcome, Error>

Apply a LifeSafetyOperation atomically to this object.

fn set_life_safety_operation_expected_internal( &mut self, _operation: LifeSafetyOperation, ) -> Result<(), Error>

Set the next LifeSafetyOperation expected by trusted local logic.

fn set_event_state_internal(&mut self, _state: EventState) -> Result<(), Error>

Apply an internally-detected Event_State transition.

fn enrollment_eval_state_internal(&self) -> Option<EventEnrollmentEvalState>

Snapshot this object’s Event Enrollment evaluation state, if it models one.

fn set_enrollment_eval_state_internal( &mut self, _state: EventEnrollmentEvalState, ) -> Result<(), Error>

Store this object’s Event Enrollment evaluation state.

fn enrollment_eval_source_internal( &self, ) -> Option<Option<EventEnrollmentMonitoredSource>>

Snapshot the monitored source that owns Event Enrollment private state.

fn set_enrollment_eval_source_internal( &mut self, _source: Option<EventEnrollmentMonitoredSource>, ) -> Result<(), Error>

Store or clear the monitored source that owns Event Enrollment state.

fn set_acked_transitions_internal( &mut self, _transition_bit: EventTransitionBits, _acknowledged: bool, ) -> Result<(), Error>

Set or clear one Acked_Transitions bit on a received event-state transition.

fn evaluate_reliability_internal( &mut self, ) -> Result<ReliabilityEvaluation, Error>

Evaluate and, when necessary, mutate this object’s Reliability.

fn set_reliability_internal( &mut self, _reliability: Reliability, ) -> Result<(), Error>

Apply an internally-derived Reliability value.

fn set_present_value_internal( &mut self, _value: PropertyValue, ) -> Result<(), Error>

Apply the logical Present_Value supplied by the local application.

fn set_present_value_from_internal( &mut self, value: PropertyValue, _origin: &CommandOrigin, ) -> Result<(), Error>

set_present_value_internal on behalf of origin, the local Device the application runs in.

fn set_tracking_value_internal( &mut self, _value: PropertyValue, ) -> Result<(), Error>

Apply the Tracking_Value the local application derived.

fn report_access_input_internal( &mut self, _input: AccessControlInput, ) -> Result<(), Error>

Apply an input the application reports for an access-control object the server holds (#1132): an Access Point’s access event, a Credential Data Input’s read or an Access Door’s hardware state, each a record whose values change together. See AccessControlInput.

fn set_controlled_variable_value_internal( &mut self, _value: PropertyValue, ) -> Result<(), Error>

Apply the Controlled_Variable_Value measured by the local application.

fn add_averaging_sample_internal( &mut self, _sample: Option<PropertyValue>, ) -> Result<(), Error>

Record one sample for an Averaging object.

fn audit_log_storage_internal(&self) -> Option<&dyn AuditLogStorage>

Borrow this object’s Audit Log query storage, if it has any.

fn audit_log_notification_sink_internal( &mut self, ) -> Option<&mut dyn AuditLogNotificationSink>

Mutably borrow this object’s Audit notification receiver capability.

fn file_storage_internal(&self) -> Option<&dyn FileStorage>

Borrow this object’s File storage, if it has any.

fn file_storage_internal_mut(&mut self) -> Option<&mut dyn FileStorage>

Mutably borrow this object’s File storage, if it has any.

fn log_record_identities_internal(&self) -> Option<Vec<LogRecordIdentity>>

Return stable identities aligned with this object’s resident log records.

fn log_buffer_internal(&self) -> Option<&dyn LogBufferRecords>

Borrow this object’s Log_Buffer records as ReadRange pages them.

fn add_trend_record(&mut self, _record: BACnetLogRecord) -> Result<(), Error>

Submit a trend record to an object’s log lifecycle.

fn add_trend_multiple_record( &mut self, _record: BACnetLogMultipleRecord, ) -> Result<(), Error>

Submit a Trend Log Multiple record, one value per monitored member, to an object’s log lifecycle.

fn add_event_log_record( &mut self, _record: BACnetEventLogRecord, ) -> Result<(), Error>

Submit an Event Log record to an object’s log lifecycle.

impl Clone for ColorTemperatureObject

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.