Bugfix/lighting-output-internal-process-api (#1086)

* Fixed Lighting_Command to ignore write priority and use its own. 

* Fixed BACnetLightingOperation reserved range.

* Refactor overridden into the lighting command module. Added Overridden status flags API.  Added Lighting Output API to implement a momentary override to the output that is cleared at the next lighting command.  Integrated lighting command overridden behavior into the lighting output object.

* Added Trim_Fade_Time, High_End_Trim, Low_End_Trim, Last_On_Value and Default_On_Value properties to lighting output.
Added TRIM_ACTIVE flag to lighting command. Added Last_On_Value and Default_On_Value to lighting command for restore and toggle.

src/bacnet/bacenum.h

@@ -2400,17 +2400,13 @@ typedef enum BACnetLightingOperation {
     BACNET_LIGHTS_WARN_OFF = 8,
     BACNET_LIGHTS_WARN_RELINQUISH = 9,
     BACNET_LIGHTS_STOP = 10,
-#if (BACNET_PROTOCOL_REVISION >= 28)
     /* Addendum cj to ANSI/ASHRAE Standard 135-2020 */
     BACNET_LIGHTS_RESTORE_ON = 11,
     BACNET_LIGHTS_DEFAULT_ON = 12,
     BACNET_LIGHTS_TOGGLE_RESTORE = 13,
     BACNET_LIGHTS_TOGGLE_DEFAULT = 14,
     BACNET_LIGHTS_RESERVED_MIN = 15,
-#else
+    BACNET_LIGHTS_RESERVED_MAX = 255,
-    BACNET_LIGHTS_RESERVED_MIN = 11,
-#endif
-    BACNET_LIGHTS_RESERVED_MAX = 63,
     /* Enumerated values 0-255 are reserved for definition by ASHRAE.
        Enumerated values 256-65535 may be used by others subject to
        the procedures and constraints described in Clause 23 */

src/bacnet/bactext.c

@@ -2222,6 +2222,10 @@ INDTEXT_DATA bacnet_lighting_operation_names[] = {
     { BACNET_LIGHTS_WARN_OFF, "warn-off" },
     { BACNET_LIGHTS_WARN_RELINQUISH, "warn-relinquish" },
     { BACNET_LIGHTS_STOP, "stop" },
+    { BACNET_LIGHTS_RESTORE_ON, "restore-on" },
+    { BACNET_LIGHTS_DEFAULT_ON, "default-on" },
+    { BACNET_LIGHTS_TOGGLE_RESTORE, "toggle-restore" },
+    { BACNET_LIGHTS_TOGGLE_DEFAULT, "toggle-default" },
     { 0, NULL }
 };
 

src/bacnet/basic/object/lo.h

@@ -45,13 +45,47 @@ bool Lighting_Output_Present_Value_Set(
 BACNET_STACK_EXPORT
 bool Lighting_Output_Present_Value_Relinquish(
     uint32_t object_instance, unsigned priority);
-
+BACNET_STACK_EXPORT
+bool Lighting_Output_Present_Value_Relinquish_All(uint32_t object_instance);
 BACNET_STACK_EXPORT
 float Lighting_Output_Relinquish_Default(uint32_t object_instance);
 BACNET_STACK_EXPORT
 bool Lighting_Output_Relinquish_Default_Set(
     uint32_t object_instance, float value);
 
+BACNET_STACK_EXPORT
+float Lighting_Output_Last_On_Value(uint32_t object_instance);
+BACNET_STACK_EXPORT
+bool Lighting_Output_Last_On_Value_Set(uint32_t object_instance, float value);
+BACNET_STACK_EXPORT
+float Lighting_Output_Default_On_Value(uint32_t object_instance);
+BACNET_STACK_EXPORT
+bool Lighting_Output_Default_On_Value_Set(
+    uint32_t object_instance, float value);
+BACNET_STACK_EXPORT
+float Lighting_Output_High_End_Trim(uint32_t object_instance);
+BACNET_STACK_EXPORT
+bool Lighting_Output_High_End_Trim_Set(uint32_t object_instance, float value);
+BACNET_STACK_EXPORT
+float Lighting_Output_Low_End_Trim(uint32_t object_instance);
+BACNET_STACK_EXPORT
+bool Lighting_Output_Low_End_Trim_Set(uint32_t object_instance, float value);
+BACNET_STACK_EXPORT
+uint32_t Lighting_Output_Trim_Fade_Time(uint32_t object_instance);
+BACNET_STACK_EXPORT
+bool Lighting_Output_Trim_Fade_Time_Set(
+    uint32_t object_instance, uint32_t value);
+
+BACNET_STACK_EXPORT
+bool Lighting_Output_Overridden_Set(uint32_t object_instance, float value);
+BACNET_STACK_EXPORT
+bool Lighting_Output_Overridden_Clear(uint32_t object_instance);
+BACNET_STACK_EXPORT
+bool Lighting_Output_Overridden_Status(uint32_t object_instance);
+BACNET_STACK_EXPORT
+bool Lighting_Output_Overridden_Momentary(
+    uint32_t object_instance, float value);
+
 BACNET_STACK_EXPORT
 bool Lighting_Output_Change_Of_Value(uint32_t instance);
 BACNET_STACK_EXPORT

src/bacnet/basic/sys/lighting_command.c

@@ -17,11 +17,11 @@
 
 /**
  * @brief call the lighting command tracking value callbacks
- * @param data - dimmer data
+ * @param data - dimmer data structure
  * @param old_value - value prior to write
  * @param value - value of the write
  */
-static void lighting_command_tracking_value_handler(
+static void lighting_command_tracking_value_notify(
     struct bacnet_lighting_command_data *data, float old_value, float value)
 {
     struct lighting_command_notification *head;
@@ -37,6 +37,7 @@ static void lighting_command_tracking_value_handler(
 
 /**
  * @brief Add a Lighting Command notification callback
+ * @param data - dimmer data structure
  * @param cb - notification callback to be added
  */
 void lighting_command_notification_add(
@@ -60,25 +61,187 @@ void lighting_command_notification_add(
 }
 
 /**
- * @brief Callback for tracking value updates
+ * @brief call the lighting command tracking value callbacks
- * @param  data - dimmer data
+ * @param data - dimmer data structure
  * @param old_value - value prior to write
  * @param value - value of the write
  */
-static void lighting_command_tracking_value_notify(
+static void lighting_command_timer_notify(
-    struct bacnet_lighting_command_data *data, float old_value, float value)
+    struct bacnet_lighting_command_data *data, uint16_t milliseconds)
+{
+    struct lighting_command_timer_notification *head;
+
+    head = &data->Timer_Notification_Head;
+    do {
+        if (head->callback) {
+            head->callback(data, milliseconds);
+        }
+        head = head->next;
+    } while (head);
+}
+
+/**
+ * @brief Add a Lighting Command notification callback
+ * @param data - dimmer data structure
+ * @param cb - notification callback to be added
+ */
+void lighting_command_timer_notfication_add(
+    struct bacnet_lighting_command_data *data,
+    struct lighting_command_timer_notification *notification)
+{
+    struct lighting_command_timer_notification *head;
+
+    head = &data->Timer_Notification_Head;
+    do {
+        if (head->next == notification) {
+            /* already here! */
+            break;
+        } else if (!head->next) {
+            /* first available free node */
+            head->next = notification;
+            break;
+        }
+        head = head->next;
+    } while (head);
+}
+
+/**
+ * @brief Clamps the step increment value
+ * @param step_increment [in] step increment value
+ * @return clamped step increment value
+ */
+float lighting_command_step_increment_clamp(float step_increment)
+{
+    if (isless(step_increment, 0.1f)) {
+        step_increment = 0.1f;
+    }
+    if (isgreater(step_increment, 100.0f)) {
+        step_increment = 100.0f;
+    }
+
+    return step_increment;
+}
+
+/**
+ * @brief Clamp the value within the operating range between low and high
+ *  end trim values.
+ * @details The Operating Range is a subset of the Normalized Range,
+ *  that represents the range of acceptable values for control of the object.
+ *  The Operating Range is defined by the High_End_Trim and Low_End_Trim
+ *  property values. When values are written outside of the Operating Range,
+ *  the Tracking_Value will reflect the actual, clamped normalized light
+ *  output while the Present_Value will reflect the original target value.
+ * @param data - dimmer data structure
+ * @param value the value that will be subject to clamping
+ */
+float lighting_command_operating_range_clamp(
+    struct bacnet_lighting_command_data *data, float value)
 {
-    if (!data->Out_Of_Service) {
     /* clamp value within trim values, if non-zero */
     if (isless(value, 1.0f)) {
         /* jump target to OFF if below normalized min */
         value = 0.0f;
     } else if (isgreater(value, data->High_Trim_Value)) {
         value = data->High_Trim_Value;
+        data->In_Progress = BACNET_LIGHTING_TRIM_ACTIVE;
     } else if (isless(value, data->Low_Trim_Value)) {
         value = data->Low_Trim_Value;
+        data->In_Progress = BACNET_LIGHTING_TRIM_ACTIVE;
     }
-        lighting_command_tracking_value_handler(data, old_value, value);
+
+    return value;
+}
+
+/**
+ * @brief Clamp the value within the normalized ON range 1% to 100%.
+ * @details The physical output level, or non-normalized range,
+ *  is specified as the linearized percentage (0..100%)
+ *  of the possible light output range with 0.0% being off,
+ *  1.0% being dimmest, and 100.0% being brightest.
+ *  The actual range represents the subset of physical output levels
+ *  defined by Min_Actual_Value and Max_Actual_Value
+ *  (or 1.0 to 100.0% if these properties are not present).
+ *  The normalized range is always 0.0 to 100.0% where
+ *  1.0% = bottom of the actual range and 100.0% = top of the actual range.
+ * @param data - dimmer data structure
+ * @param value [in] value to normalize
+ * @return normalized value within the range defined by Min_Actual_Value
+ *  and Max_Actual_Value
+ */
+float lighting_command_normalized_on_range_clamp(
+    struct bacnet_lighting_command_data *data, float value)
+{
+    /* clamp value within trim values, if non-zero */
+    if (isgreater(value, data->Max_Actual_Value)) {
+        value = data->Max_Actual_Value;
+    } else if (isless(value, data->Min_Actual_Value)) {
+        value = data->Min_Actual_Value;
+    }
+
+    return value;
+}
+
+/**
+ * @brief Normalize the value to the min/max range
+ * @details The physical output level, or non-normalized range,
+ *  is specified as the linearized percentage (0..100%)
+ *  of the possible light output range with 0.0% being off,
+ *  1.0% being dimmest, and 100.0% being brightest.
+ *  The actual range represents the subset of physical output levels
+ *  defined by Min_Actual_Value and Max_Actual_Value
+ *  (or 1.0 to 100.0% if these properties are not present).
+ *  The normalized range is always 0.0 to 100.0% where
+ *  1.0% = bottom of the actual range and 100.0% = top of the actual range.
+ * @param data - dimmer data structure
+ * @param value [in] value to normalize
+ * @return normalized value within the range defined by
+ *  0.0%, Min_Actual_Value, and Max_Actual_Value
+ */
+float lighting_command_normalized_range_clamp(
+    struct bacnet_lighting_command_data *data, float value)
+{
+    float normalized_value;
+
+    /* clamp value within normalized values, if non-zero */
+    if (isless(value, 1.0f)) {
+        /* jump target to OFF if below normalized min */
+        normalized_value = 0.0f;
+    } else if (isgreater(value, data->Max_Actual_Value)) {
+        normalized_value = data->Max_Actual_Value;
+    } else if (isless(value, data->Min_Actual_Value)) {
+        normalized_value = data->Min_Actual_Value;
+    } else {
+        normalized_value = value;
+    }
+
+    return normalized_value;
+}
+
+/**
+ * @brief Callback for tracking value updates
+ * @param data - dimmer data structure
+ * @param  old_value - value prior to write
+ * @param  value - value of the write
+ */
+static void lighting_command_tracking_value_event(
+    struct bacnet_lighting_command_data *data, float old_value, float value)
+{
+    if (data->Overridden) {
+        value = lighting_command_operating_range_clamp(data, value);
+        if (isgreaterequal(value, 1.0)) {
+            data->Last_On_Value = value;
+        }
+        lighting_command_tracking_value_notify(data, old_value, value);
+        if (data->Overridden_Momentary) {
+            data->Overridden = false;
+        }
+    } else if (!data->Out_Of_Service) {
+        data->Overridden_Momentary = false;
+        value = lighting_command_operating_range_clamp(data, value);
+        if (isgreaterequal(value, 1.0)) {
+            data->Last_On_Value = value;
+        }
+        lighting_command_tracking_value_notify(data, old_value, value);
     } else {
         debug_printf(
             "Lighting-Command[%lu]-Out-of-Service\n", (unsigned long)data->Key);
@@ -88,7 +251,7 @@ static void lighting_command_tracking_value_notify(
 /**
  * Handles the timing for a single Lighting Output object Fade
  *
- * @param data [in] dimmer data
+ * @param data - dimmer data structure
  * @param milliseconds - number of milliseconds elapsed since previously
  * called.  Works best when called about every 10 milliseconds.
  */
@@ -97,19 +260,11 @@ static void lighting_command_fade_handler(
 {
     float old_value;
     float x1, x2, x3, y1, y3;
-    float target_value, min_value, max_value;
+    float target_value;
 
     old_value = data->Tracking_Value;
-    min_value = data->Min_Actual_Value;
+    target_value =
-    max_value = data->Max_Actual_Value;
+        lighting_command_normalized_on_range_clamp(data, data->Target_Level);
-    target_value = data->Target_Level;
-    /* clamp target within min/max */
-    if (isgreater(target_value, max_value)) {
-        target_value = max_value;
-    }
-    if (isless(target_value, min_value)) {
-        target_value = min_value;
-    }
     if ((milliseconds >= data->Fade_Time) ||
         (!islessgreater(data->Tracking_Value, target_value))) {
         /* stop fading */
@@ -127,8 +282,8 @@ static void lighting_command_fade_handler(
         x1 = 0.0f;
         x2 = (float)milliseconds;
         x3 = (float)data->Fade_Time;
-        if (isless(old_value, min_value)) {
+        if (isless(old_value, data->Min_Actual_Value)) {
-            y1 = min_value;
+            y1 = data->Min_Actual_Value;
         } else {
             y1 = old_value;
         }
@@ -137,7 +292,7 @@ static void lighting_command_fade_handler(
         data->Fade_Time -= milliseconds;
         data->In_Progress = BACNET_LIGHTING_FADE_ACTIVE;
     }
-    lighting_command_tracking_value_notify(
+    lighting_command_tracking_value_event(
         data, old_value, data->Tracking_Value);
 }
 
@@ -153,25 +308,17 @@ static void lighting_command_fade_handler(
  * progress of the ramp. <target-level> shall be clamped to
  * Min_Actual_Value and Max_Actual_Value.
  *
- * @param data [in] dimmer data
+ * @param data - dimmer data structure
  * @param milliseconds - number of milliseconds elapsed
  */
 static void lighting_command_ramp_handler(
     struct bacnet_lighting_command_data *data, uint16_t milliseconds)
 {
-    float old_value, target_value, min_value, max_value, step_value, steps;
+    float old_value, target_value, step_value, steps;
 
     old_value = data->Tracking_Value;
-    min_value = data->Min_Actual_Value;
+    target_value =
-    max_value = data->Max_Actual_Value;
+        lighting_command_normalized_on_range_clamp(data, data->Target_Level);
-    target_value = data->Target_Level;
-    /* clamp target within min/max, if needed */
-    if (isgreater(target_value, max_value)) {
-        target_value = max_value;
-    }
-    if (isless(target_value, min_value)) {
-        target_value = min_value;
-    }
     /* determine the number of steps */
     if (milliseconds <= 1000) {
         /* percent per second */
@@ -213,12 +360,8 @@ static void lighting_command_ramp_handler(
             data->Lighting_Operation = BACNET_LIGHTS_STOP;
         }
         /* clamp target within min/max, if needed */
-        if (isgreater(step_value, max_value)) {
+        step_value =
-            step_value = max_value;
+            lighting_command_normalized_on_range_clamp(data, step_value);
-        }
-        if (isless(step_value, min_value)) {
-            step_value = min_value;
-        }
         if (data->Lighting_Operation == BACNET_LIGHTS_STOP) {
             if (isless(data->Target_Level, 1.0f)) {
                 /* jump target to OFF if below normalized min */
@@ -232,28 +375,10 @@ static void lighting_command_ramp_handler(
             data->In_Progress = BACNET_LIGHTING_RAMP_ACTIVE;
         }
     }
-    lighting_command_tracking_value_notify(
+    lighting_command_tracking_value_event(
         data, old_value, data->Tracking_Value);
 }
 
-/**
- * Clamps the step increment value
- *
- * @param step_increment [in] step increment value
- * @return clamped step increment value
- */
-static float lighting_command_step_increment_clamp(float step_increment)
-{
-    if (isless(step_increment, 0.1f)) {
-        step_increment = 0.1f;
-    }
-    if (isgreater(step_increment, 100.0f)) {
-        step_increment = 100.0f;
-    }
-
-    return step_increment;
-}
-
 /**
  * Updates the object tracking value while stepping
  *
@@ -266,58 +391,22 @@ static float lighting_command_step_increment_clamp(float step_increment)
 static void
 lighting_command_step_up_handler(struct bacnet_lighting_command_data *data)
 {
-    float old_value, target_value, min_value, max_value, step_value;
+    float old_value, target_value, step_value;
 
     old_value = data->Tracking_Value;
-    min_value = data->Min_Actual_Value;
-    max_value = data->Max_Actual_Value;
     step_value = lighting_command_step_increment_clamp(data->Step_Increment);
     /* inhibit ON if the value is already OFF */
-    if (isgreaterequal(old_value, min_value)) {
+    if (isgreaterequal(old_value, data->Min_Actual_Value)) {
         target_value = old_value + step_value;
-        /* clamp target within min/max, if needed */
+        data->Tracking_Value =
-        if (isgreater(target_value, max_value)) {
+            lighting_command_normalized_on_range_clamp(data, target_value);
-            target_value = max_value;
-        }
-        if (isless(target_value, min_value)) {
-            target_value = min_value;
-        }
-        data->Tracking_Value = target_value;
         data->In_Progress = BACNET_LIGHTING_IDLE;
         data->Lighting_Operation = BACNET_LIGHTS_STOP;
-        lighting_command_tracking_value_notify(
+        lighting_command_tracking_value_event(
             data, old_value, data->Tracking_Value);
     }
 }
 
-/**
- * Normalize the value to the min/max range
- * @param value [in] value to normalize
- * @param min_value [in] minimum value
- * @param max_value [in] maximum value
- * @return normalized value
- */
-static float
-lighting_command_normalize_value(float value, float min_value, float max_value)
-{
-    float normalized_value;
-    /* clamp target within min/max, if needed */
-    if (isgreater(value, max_value)) {
-        /* clamp target within max */
-        normalized_value = max_value;
-    } else if (isless(value, 1.0f)) {
-        /* jump target to OFF if below normalized min */
-        normalized_value = 0.0f;
-    } else if (isless(value, min_value)) {
-        /* clamp target within min */
-        normalized_value = min_value;
-    } else {
-        normalized_value = value;
-    }
-
-    return normalized_value;
-}
-
 /**
  * Updates the object tracking value while stepping
  *
@@ -330,30 +419,20 @@ lighting_command_normalize_value(float value, float min_value, float max_value)
 static void
 lighting_command_step_down_handler(struct bacnet_lighting_command_data *data)
 {
-    float old_value, target_value, min_value, max_value, step_value;
+    float old_value, target_value, step_value;
 
     old_value = target_value = data->Tracking_Value;
-    min_value = data->Min_Actual_Value;
-    max_value = data->Max_Actual_Value;
     step_value = lighting_command_step_increment_clamp(data->Step_Increment);
     if (isgreaterequal(target_value, step_value)) {
         target_value -= step_value;
     } else {
-        target_value = 0.0f;
+        target_value = data->Min_Actual_Value;
     }
-    /* clamp target within min/max, if needed */
+    data->Tracking_Value =
-    if (isgreater(target_value, max_value)) {
+        lighting_command_normalized_on_range_clamp(data, target_value);
-        /* clamp target within max */
-        target_value = max_value;
-    }
-    if (isless(target_value, min_value)) {
-        /* clamp target within min */
-        target_value = min_value;
-    }
-    data->Tracking_Value = target_value;
     data->In_Progress = BACNET_LIGHTING_IDLE;
     data->Lighting_Operation = BACNET_LIGHTS_STOP;
-    lighting_command_tracking_value_notify(
+    lighting_command_tracking_value_event(
         data, old_value, data->Tracking_Value);
 }
 
@@ -369,18 +448,16 @@ lighting_command_step_down_handler(struct bacnet_lighting_command_data *data)
 static void
 lighting_command_step_on_handler(struct bacnet_lighting_command_data *data)
 {
-    float old_value, target_value, min_value, max_value, step_value;
+    float old_value, target_value, step_value;
 
     old_value = target_value = data->Tracking_Value;
-    min_value = data->Min_Actual_Value;
-    max_value = data->Max_Actual_Value;
     step_value = lighting_command_step_increment_clamp(data->Step_Increment);
     target_value += step_value;
     data->Tracking_Value =
-        lighting_command_normalize_value(target_value, min_value, max_value);
+        lighting_command_normalized_range_clamp(data, target_value);
     data->In_Progress = BACNET_LIGHTING_IDLE;
     data->Lighting_Operation = BACNET_LIGHTS_STOP;
-    lighting_command_tracking_value_notify(
+    lighting_command_tracking_value_event(
         data, old_value, data->Tracking_Value);
 }
 
@@ -396,11 +473,9 @@ lighting_command_step_on_handler(struct bacnet_lighting_command_data *data)
 static void
 lighting_command_step_off_handler(struct bacnet_lighting_command_data *data)
 {
-    float old_value, target_value, min_value, max_value, step_value;
+    float old_value, target_value, step_value;
 
     old_value = target_value = data->Tracking_Value;
-    min_value = data->Min_Actual_Value;
-    max_value = data->Max_Actual_Value;
     step_value = lighting_command_step_increment_clamp(data->Step_Increment);
     if (isgreaterequal(target_value, step_value)) {
         target_value -= step_value;
@@ -408,10 +483,10 @@ lighting_command_step_off_handler(struct bacnet_lighting_command_data *data)
         target_value = 0.0f;
     }
     data->Tracking_Value =
-        lighting_command_normalize_value(target_value, min_value, max_value);
+        lighting_command_normalized_range_clamp(data, target_value);
     data->In_Progress = BACNET_LIGHTING_IDLE;
     data->Lighting_Operation = BACNET_LIGHTS_STOP;
-    lighting_command_tracking_value_notify(
+    lighting_command_tracking_value_event(
         data, old_value, data->Tracking_Value);
 }
 
@@ -424,18 +499,17 @@ lighting_command_step_off_handler(struct bacnet_lighting_command_data *data)
  * @note The WARN, WARN_RELINQUISH, and WARN_OFF lighting
  * commands, as well as writing one of the special values to the
  * Present_Value property, cause a blink-warn notification
- * to occur at the specified priority. A blink-warn
+ * to occur. A blink-warn notification is used to warn the
- * notification is used to warn the occupants that the lights
+ * occupants that the lights are about to turn off, giving
- * are about to turn off, giving the occupants the opportunity
+ * the occupants the opportunity to exit the space or to
- * to exit the space or to override the lights for a period of time.
+ * override the lights for a period of time.
  *
  * The actual blink-warn notification mechanism shall be a local matter.
  * The physical lights may blink once, multiple times, or
  * repeatedly. They may also go bright, go dim, or signal a notification
  * through some other means. In some circumstances, no blink-warn
  * notification will occur at all. The blink-warn notification
- * shall not be reflected in the priority array or the tracking
+ * shall not be reflected in the tracking value.
- * value.
  *
  * @param data [in] dimmer data
  * @param milliseconds - number of milliseconds elapsed
@@ -443,11 +517,9 @@ lighting_command_step_off_handler(struct bacnet_lighting_command_data *data)
 static void lighting_command_blink_handler(
     struct bacnet_lighting_command_data *data, uint16_t milliseconds)
 {
-    float old_value, target_value, min_value, max_value;
+    float old_value, target_value;
 
     old_value = data->Tracking_Value;
-    min_value = data->Min_Actual_Value;
-    max_value = data->Max_Actual_Value;
     /* detect 'end' operation */
     if (data->Blink.Duration > milliseconds) {
         data->Blink.Duration -= milliseconds;
@@ -494,14 +566,30 @@ static void lighting_command_blink_handler(
             }
         }
     }
-    target_value =
+    target_value = lighting_command_normalized_range_clamp(data, target_value);
-        lighting_command_normalize_value(target_value, min_value, max_value);
     /* note: The blink-warn notifications shall not be reflected
        in the tracking value. */
     if (data->In_Progress == BACNET_LIGHTING_IDLE) {
         data->Tracking_Value = target_value;
     }
-    lighting_command_tracking_value_notify(data, old_value, target_value);
+    lighting_command_tracking_value_event(data, old_value, target_value);
+}
+
+/**
+ * @brief Overrides the current lighting command if overridden is true
+ * @param data [in] dimmer data
+ */
+void lighting_command_override(
+    struct bacnet_lighting_command_data *data, float value)
+{
+    float old_value;
+
+    if (!data) {
+        return;
+    }
+    old_value = data->Tracking_Value;
+    data->Tracking_Value = value;
+    lighting_command_tracking_value_event(data, old_value, value);
 }
 
 /**
@@ -516,6 +604,9 @@ void lighting_command_timer(
     if (!data) {
         return;
     }
+    if (data->Overridden) {
+        data->Lighting_Operation = BACNET_LIGHTS_NONE;
+    }
     switch (data->Lighting_Operation) {
         case BACNET_LIGHTS_NONE:
             data->In_Progress = BACNET_LIGHTING_IDLE;
@@ -546,13 +637,20 @@ void lighting_command_timer(
         case BACNET_LIGHTS_STOP:
             data->In_Progress = BACNET_LIGHTING_IDLE;
             break;
+        case BACNET_LIGHTS_RESTORE_ON:
+        case BACNET_LIGHTS_DEFAULT_ON:
+        case BACNET_LIGHTS_TOGGLE_RESTORE:
+        case BACNET_LIGHTS_TOGGLE_DEFAULT:
+            lighting_command_fade_handler(data, milliseconds);
+            break;
         default:
             break;
     }
+    lighting_command_timer_notify(data, milliseconds);
 }
 
 /**
- * @brief Set the lighting command if the priority is active
+ * @brief Set the lighting command to perform a fade to value operation
  * @param data [in] dimmer data
  * @param value [in] BACnet lighting value
  * @param fade_time [in] BACnet lighting fade time
@@ -586,7 +684,7 @@ void lighting_command_ramp_to(
 }
 
 /**
- * @brief Set the lighting command if the priority is active
+ * @brief Set the lighting command to perform a step increment operation
  * @param data [in] dimmer object instance
  * @param operation [in] BACnet lighting operation
  * @param step_increment [in] BACnet lighting step increment value
@@ -606,7 +704,7 @@ void lighting_command_step(
 }
 
 /**
- * @brief Set the lighting command to blink mode
+ * @brief Set the lighting command to perform a blink operation
  * @param data [in] dimmer object instance
  * @param operation [in] BACnet lighting operation for blink warn
  * @param blink [in] BACnet blink data
@@ -634,7 +732,7 @@ void lighting_command_blink_warn(
 }
 
 /**
- * @brief Set the lighting command if the priority is active
+ * @brief Set the lighting command to perform a stop operation
  * @param object [in] BACnet object instance
  * @param priority [in] BACnet priority array value 1..16
  */
@@ -647,7 +745,7 @@ void lighting_command_stop(struct bacnet_lighting_command_data *data)
 }
 
 /**
- * @brief Set the lighting command if the priority is active
+ * @brief Set the lighting command to perform no operations
  * @param object [in] BACnet object instance
  * @param priority [in] BACnet priority array value 1..16
  */
@@ -659,6 +757,82 @@ void lighting_command_none(struct bacnet_lighting_command_data *data)
     data->Lighting_Operation = BACNET_LIGHTS_NONE;
 }
 
+/**
+ * @brief Set the lighting command to perform a restore-on operation
+ * @param data [in] dimmer data
+ * @param fade_time [in] BACnet lighting fade time
+ */
+void lighting_command_restore_on(
+    struct bacnet_lighting_command_data *data, uint32_t fade_time)
+{
+    if (!data) {
+        return;
+    }
+    data->Fade_Time = fade_time;
+    data->Lighting_Operation = BACNET_LIGHTS_RESTORE_ON;
+    data->Target_Level = data->Last_On_Value;
+}
+
+/**
+ * @brief Set the lighting command to perform a default-on operation
+ * @param data [in] dimmer data
+ * @param fade_time [in] BACnet lighting fade time
+ */
+void lighting_command_default_on(
+    struct bacnet_lighting_command_data *data, uint32_t fade_time)
+{
+    if (!data) {
+        return;
+    }
+    data->Fade_Time = fade_time;
+    data->Lighting_Operation = BACNET_LIGHTS_DEFAULT_ON;
+    data->Target_Level = data->Default_On_Value;
+}
+
+/**
+ * @brief Set the lighting command to perform a toggle restore operation
+ * @param data [in] dimmer data
+ * @param fade_time [in] BACnet lighting fade time
+ */
+void lighting_command_toggle_restore(
+    struct bacnet_lighting_command_data *data, uint32_t fade_time)
+{
+    if (!data) {
+        return;
+    }
+    data->Fade_Time = fade_time;
+    data->Lighting_Operation = BACNET_LIGHTS_TOGGLE_RESTORE;
+    if (isless(data->Tracking_Value, 1.0f)) {
+        /* OFF: write the Last_On_Value */
+        data->Target_Level = data->Last_On_Value;
+    } else {
+        /* not OFF, write 0.0% */
+        data->Target_Level = 0.0f;
+    }
+}
+
+/**
+ * @brief Set the lighting command to perform a toggle default operation
+ * @param data [in] dimmer data
+ * @param fade_time [in] BACnet lighting fade time
+ */
+void lighting_command_toggle_default(
+    struct bacnet_lighting_command_data *data, uint32_t fade_time)
+{
+    if (!data) {
+        return;
+    }
+    data->Fade_Time = fade_time;
+    data->Lighting_Operation = BACNET_LIGHTS_TOGGLE_DEFAULT;
+    if (isless(data->Tracking_Value, 1.0f)) {
+        /* OFF: write the Default_On_Value */
+        data->Target_Level = data->Default_On_Value;
+    } else {
+        /* not OFF, write 0.0% */
+        data->Target_Level = 0.0f;
+    }
+}
+
 void lighting_command_init(struct bacnet_lighting_command_data *data)
 {
     if (!data) {
@@ -666,12 +840,15 @@ void lighting_command_init(struct bacnet_lighting_command_data *data)
     }
     data->Tracking_Value = 0.0f;
     data->Lighting_Operation = BACNET_LIGHTS_NONE;
-    data->In_Progress = BACNET_LIGHTING_IDLE;
+    data->In_Progress = BACNET_LIGHTING_NOT_CONTROLLED;
     data->Out_Of_Service = false;
     data->Min_Actual_Value = 1.0f;
     data->Max_Actual_Value = 100.0f;
     data->Low_Trim_Value = 1.0f;
     data->High_Trim_Value = 100.0f;
+    data->Last_On_Value = 100.0f;
+    data->Default_On_Value = 100.0f;
+    data->Overridden = false;
     data->Blink.On_Value = 100.0f;
     data->Blink.Off_Value = 0.0f;
     data->Blink.End_Value = 0.0f;

src/bacnet/basic/sys/lighting_command.h

@@ -14,6 +14,7 @@
 
 /**
  * @brief Callback for tracking value updates
+ * @param  key - key used to link to specific light
  * @param  old_value - value prior to write
  * @param  value - value of the write
  */
@@ -25,6 +26,21 @@ struct lighting_command_notification {
     lighting_command_tracking_value_callback callback;
 };
 
+/* forward prototype of the structure defined later */
+struct bacnet_lighting_command_data;
+
+/**
+ * @brief Callback for non-standard Lighting_Operation timer values
+ * @param  data - Lighting Command data structure
+ * @param  milliseconds - elapsed time in milliseconds
+ */
+typedef void (*lighting_command_timer_callback)(
+    struct bacnet_lighting_command_data *data, uint16_t milliseconds);
+struct lighting_command_timer_notification {
+    struct lighting_command_timer_notification *next;
+    lighting_command_timer_callback callback;
+};
+
 typedef struct bacnet_lighting_command_warn_data {
     /* warn */
     float On_Value;
@@ -51,12 +67,17 @@ typedef struct bacnet_lighting_command_data {
     float Max_Actual_Value;
     float High_Trim_Value;
     float Low_Trim_Value;
+    float Default_On_Value;
+    float Last_On_Value;
     BACNET_LIGHTING_COMMAND_WARN_DATA Blink;
     /* bits - in common area of structure */
     bool Out_Of_Service : 1;
+    bool Overridden : 1;
+    bool Overridden_Momentary : 1;
     /* key used with callback */
     uint32_t Key;
     struct lighting_command_notification Notification_Head;
+    struct lighting_command_timer_notification Timer_Notification_Head;
 } BACNET_LIGHTING_COMMAND_DATA;
 
 #ifdef __cplusplus
@@ -86,12 +107,45 @@ BACNET_STACK_EXPORT
 void lighting_command_stop(struct bacnet_lighting_command_data *data);
 BACNET_STACK_EXPORT
 void lighting_command_none(struct bacnet_lighting_command_data *data);
+BACNET_STACK_EXPORT
+void lighting_command_restore_on(
+    struct bacnet_lighting_command_data *data, uint32_t fade_time);
+BACNET_STACK_EXPORT
+void lighting_command_default_on(
+    struct bacnet_lighting_command_data *data, uint32_t fade_time);
+BACNET_STACK_EXPORT
+void lighting_command_toggle_restore(
+    struct bacnet_lighting_command_data *data, uint32_t fade_time);
+BACNET_STACK_EXPORT
+void lighting_command_toggle_default(
+    struct bacnet_lighting_command_data *data, uint32_t fade_time);
+
+BACNET_STACK_EXPORT
+void lighting_command_override(
+    struct bacnet_lighting_command_data *data, float value);
+
+BACNET_STACK_EXPORT
+float lighting_command_step_increment_clamp(float step_increment);
+BACNET_STACK_EXPORT
+float lighting_command_operating_range_clamp(
+    struct bacnet_lighting_command_data *data, float value);
+BACNET_STACK_EXPORT
+float lighting_command_normalized_range_clamp(
+    struct bacnet_lighting_command_data *data, float value);
+BACNET_STACK_EXPORT
+float lighting_command_normalized_on_range_clamp(
+    struct bacnet_lighting_command_data *data, float value);
+
 BACNET_STACK_EXPORT
 void lighting_command_init(struct bacnet_lighting_command_data *data);
 BACNET_STACK_EXPORT
 void lighting_command_notification_add(
     struct bacnet_lighting_command_data *data,
     struct lighting_command_notification *notification);
+BACNET_STACK_EXPORT
+void lighting_command_timer_notfication_add(
+    struct bacnet_lighting_command_data *data,
+    struct lighting_command_timer_notification *notification);
 
 #ifdef __cplusplus
 }

src/bacnet/property.c

@@ -1648,6 +1648,8 @@ static const int Lighting_Output_Properties_Required[] = {
     PROP_RELINQUISH_DEFAULT,
     PROP_LIGHTING_COMMAND_DEFAULT_PRIORITY,
     PROP_CURRENT_COMMAND_PRIORITY,
+    PROP_LAST_ON_VALUE,
+    PROP_DEFAULT_ON_VALUE,
     -1
 };
 
@@ -1670,6 +1672,12 @@ static const int Lighting_Output_Properties_Optional[] = {
     PROP_AUDIT_LEVEL,
     PROP_AUDITABLE_OPERATIONS,
     PROP_AUDIT_PRIORITY_FILTER,
+    PROP_COLOR_REFERENCE,
+    PROP_COLOR_OVERRIDE,
+    PROP_OVERRIDE_COLOR_REFERENCE,
+    PROP_HIGH_END_TRIM,
+    PROP_LOW_END_TRIM,
+    PROP_TRIM_FADE_TIME,
     PROP_TAGS,
     PROP_PROFILE_LOCATION,
     PROP_PROFILE_NAME,

test/bacnet/basic/object/lo/CMakeLists.txt

@@ -23,6 +23,7 @@ set(ZTST_DIR "${TST_DIR}/ztest/src")
 add_compile_definitions(
     BIG_ENDIAN=0
     CONFIG_ZTEST=1
+    BACNET_PROTOCOL_REVISION=28
     )
 
 include_directories(

test/bacnet/basic/object/lo/src/main.c

@@ -1,15 +1,12 @@
-/*
+/* @file
- * Copyright (c) 2020 Legrand North America, LLC.
+ * @brief test BACnet Lighting Output object APIs
- *
+ * @date 2013
+ * @author Steve Karg <skarg@users.sourceforge.net>
  * @copyright SPDX-License-Identifier: MIT
  */
-
-/* @file
- * @brief test BACnet integer encode/decode APIs
- */
-
 #include <zephyr/ztest.h>
 #include <bacnet/bactext.h>
+#include <bacnet/proplist.h>
 #include <bacnet/basic/object/lo.h>
 
 /**
@@ -17,6 +14,33 @@
  * @{
  */
 
+/**
+ * @brief compare two floating point values to 3 decimal places
+ *
+ * @param x1 - first comparison value
+ * @param x2 - second comparison value
+ * @return true if the value is the same to 3 decimal points
+ */
+static bool is_float_equal(float x1, float x2)
+{
+    return fabs(x1 - x2) < 0.001;
+}
+
+static float Test_Tracking_Value;
+/**
+ * @brief Callback for tracking value updates
+ * @param  key - key used to link to specific light
+ * @param  old_value - value prior to write
+ * @param  value - value of the write
+ */
+static void lighting_command_tracking_value_observer(
+    uint32_t key, float old_value, float value)
+{
+    (void)key;
+    (void)old_value;
+    Test_Tracking_Value = value;
+}
+
 /**
  * @brief Test
  */
@@ -36,17 +60,30 @@ static void testLightingOutput(void)
     const uint32_t instance = 123;
     BACNET_WRITE_PROPERTY_DATA wpdata = { 0 };
     bool status = false;
-    unsigned index;
+    unsigned index, count;
     uint16_t milliseconds = 10;
+    uint32_t test_instance;
     const char *test_name = NULL;
     char *sample_name = "sample";
+    BACNET_LIGHTING_COMMAND lighting_command = { 0 };
+    BACNET_LIGHTING_IN_PROGRESS in_progress;
+    float real_value, test_real;
+    uint32_t unsigned_value, test_unsigned;
+    unsigned priority, test_priority;
+    BACNET_OBJECT_ID object_id, test_object_id;
 
     Lighting_Output_Init();
     Lighting_Output_Create(instance);
     status = Lighting_Output_Valid_Instance(instance);
     zassert_true(status, NULL);
+    status = Lighting_Output_Valid_Instance(BACNET_MAX_INSTANCE);
+    zassert_false(status, NULL);
     index = Lighting_Output_Instance_To_Index(instance);
     zassert_equal(index, 0, NULL);
+    count = Lighting_Output_Count();
+    zassert_equal(count, 1, NULL);
+    test_instance = Lighting_Output_Index_To_Instance(0);
+    zassert_equal(test_instance, instance, NULL);
 
     rpdata.application_data = &apdu[0];
     rpdata.application_data_len = sizeof(apdu);
@@ -88,6 +125,27 @@ static void testLightingOutput(void)
                     "property '%s': WriteProperty Unknown!\n",
                     bactext_property_name(rpdata.object_property));
             }
+            if (property_list_commandable_member(
+                    wpdata.object_type, wpdata.object_property)) {
+                wpdata.priority = 16;
+                status = Lighting_Output_Write_Property(&wpdata);
+                zassert_true(status, NULL);
+                wpdata.application_data_len =
+                    encode_application_null(wpdata.application_data);
+                wpdata.priority = 16;
+                status = Lighting_Output_Write_Property(&wpdata);
+                zassert_true(status, NULL);
+                wpdata.priority = 6;
+                status = Lighting_Output_Write_Property(&wpdata);
+                zassert_false(status, NULL);
+                zassert_equal(
+                    wpdata.error_code, ERROR_CODE_WRITE_ACCESS_DENIED, NULL);
+                wpdata.priority = 0;
+                status = Lighting_Output_Write_Property(&wpdata);
+                zassert_false(status, NULL);
+                zassert_equal(
+                    wpdata.error_code, ERROR_CODE_VALUE_OUT_OF_RANGE, NULL);
+            }
         }
         pRequired++;
     }
@@ -129,6 +187,7 @@ static void testLightingOutput(void)
     rpdata.object_property = PROP_ALL;
     len = Lighting_Output_Read_Property(&rpdata);
     zassert_equal(len, BACNET_STATUS_ERROR, NULL);
+    wpdata.object_property = PROP_ALL;
     status = Lighting_Output_Write_Property(&wpdata);
     zassert_false(status, NULL);
     /* check the dimming/ramping/stepping engine*/
@@ -142,9 +201,268 @@ static void testLightingOutput(void)
     zassert_true(status, NULL);
     test_name = Lighting_Output_Name_ASCII(instance);
     zassert_equal(test_name, NULL, NULL);
+    /* test the ASCII description get/set */
+    status = Lighting_Output_Description_Set(instance, sample_name);
+    zassert_true(status, NULL);
+    test_name = Lighting_Output_Description(instance);
+    zassert_equal(test_name, sample_name, NULL);
+    /* test local control API */
+    lighting_command.operation = BACNET_LIGHTS_NONE;
+    do {
+        status =
+            Lighting_Output_Lighting_Command_Set(instance, &lighting_command);
+        if (status) {
+            zassert_true(status, NULL);
+        } else {
+            printf(
+                "lighting-command operation[%d] %s not supported.\n",
+                lighting_command.operation,
+                bactext_lighting_operation_name(lighting_command.operation));
+        }
+        if (lighting_command.operation == BACNET_LIGHTS_PROPRIETARY_MIN) {
+            /* skip to make testing faster */
+            lighting_command.operation = BACNET_LIGHTS_PROPRIETARY_MAX;
+        } else if (lighting_command.operation == BACNET_LIGHTS_RESERVED_MIN) {
+            /* skip to make testing faster */
+            lighting_command.operation = BACNET_LIGHTS_RESERVED_MAX;
+        } else {
+            lighting_command.operation++;
+        }
+    } while (lighting_command.operation <= BACNET_LIGHTS_PROPRIETARY_MAX);
+    /* test the present-value APIs */
+    Lighting_Output_Present_Value_Relinquish_All(instance);
+    real_value = 1.0;
+    priority = 8;
+    Lighting_Output_Present_Value_Set(instance, real_value, priority);
+    test_real = Lighting_Output_Present_Value(instance);
+    zassert_true(is_float_equal(test_real, real_value), NULL);
+    test_priority = Lighting_Output_Present_Value_Priority(instance);
+    zassert_equal(
+        priority, test_priority, "priority=%u test_priority=%u", priority,
+        test_priority);
+    Lighting_Output_Present_Value_Relinquish(instance, priority);
+    real_value = Lighting_Output_Relinquish_Default(instance);
+    test_real = Lighting_Output_Present_Value(instance);
+    zassert_true(is_float_equal(test_real, real_value), NULL);
+    /* test the present-value special values */
+    status = Lighting_Output_Default_Fade_Time_Set(instance, 100);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Default_Ramp_Rate_Set(instance, 100.0f);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Egress_Time_Set(instance, 0);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Default_Step_Increment_Set(instance, 1.0f);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Transition_Set(
+        instance, BACNET_LIGHTING_TRANSITION_NONE);
+    zassert_true(status, NULL);
+    /* WARN - start with lights on  */
+    real_value = -1.0;
+    priority = 8;
+    status = Lighting_Output_Present_Value_Set(instance, 100.0f, priority);
+    zassert_true(status, NULL);
+    Lighting_Output_Timer(instance, 10);
+    in_progress = Lighting_Output_In_Progress(instance);
+    zassert_equal(
+        in_progress, BACNET_LIGHTING_IDLE, "in_progress=%s",
+        bactext_lighting_in_progress(in_progress));
+    status = Lighting_Output_Present_Value_Set(instance, real_value, priority);
+    zassert_true(status, NULL);
+    in_progress = Lighting_Output_In_Progress(instance);
+    zassert_equal(
+        in_progress, BACNET_LIGHTING_OTHER, "in_progress=%s",
+        bactext_lighting_in_progress(in_progress));
+    Lighting_Output_Timer(instance, 10);
+    in_progress = Lighting_Output_In_Progress(instance);
+    zassert_equal(
+        in_progress, BACNET_LIGHTING_IDLE, "in_progress=%s",
+        bactext_lighting_in_progress(in_progress));
+    /* WARN RELINQUISH */
+    real_value = -2.0;
+    priority = 8;
+    Lighting_Output_Present_Value_Set(instance, real_value, priority);
+    Lighting_Output_Timer(instance, 10);
+    in_progress = Lighting_Output_In_Progress(instance);
+    zassert_equal(
+        in_progress, BACNET_LIGHTING_IDLE, "in_progress=%s",
+        bactext_lighting_in_progress(in_progress));
+    real_value = -3.0;
+    priority = 8;
+    Lighting_Output_Present_Value_Set(instance, real_value, priority);
+    Lighting_Output_Timer(instance, 10);
+    in_progress = Lighting_Output_In_Progress(instance);
+    zassert_equal(
+        in_progress, BACNET_LIGHTING_IDLE, "in_progress=%s",
+        bactext_lighting_in_progress(in_progress));
+    real_value = -4.0;
+    priority = 8;
+    Lighting_Output_Present_Value_Set(instance, real_value, priority);
+    Lighting_Output_Timer(instance, 10);
+    in_progress = Lighting_Output_In_Progress(instance);
+    zassert_equal(
+        in_progress, BACNET_LIGHTING_IDLE, "in_progress=%s",
+        bactext_lighting_in_progress(in_progress));
+    real_value = -5.0;
+    priority = 8;
+    Lighting_Output_Present_Value_Set(instance, real_value, priority);
+    Lighting_Output_Timer(instance, 10);
+    in_progress = Lighting_Output_In_Progress(instance);
+    zassert_equal(
+        in_progress, BACNET_LIGHTING_IDLE, "in_progress=%s",
+        bactext_lighting_in_progress(in_progress));
+    real_value = -6.0;
+    priority = 8;
+    Lighting_Output_Present_Value_Set(instance, real_value, priority);
+    Lighting_Output_Timer(instance, 10);
+    in_progress = Lighting_Output_In_Progress(instance);
+    zassert_equal(
+        in_progress, BACNET_LIGHTING_IDLE, "in_progress=%s",
+        bactext_lighting_in_progress(in_progress));
+    real_value = -7.0;
+    priority = 8;
+    Lighting_Output_Present_Value_Set(instance, real_value, priority);
+    Lighting_Output_Timer(instance, 10);
+    in_progress = Lighting_Output_In_Progress(instance);
+    zassert_equal(
+        in_progress, BACNET_LIGHTING_IDLE, "in_progress=%s",
+        bactext_lighting_in_progress(in_progress));
+    status = Lighting_Output_In_Progress_Set(
+        instance, BACNET_LIGHTING_NOT_CONTROLLED);
+    in_progress = Lighting_Output_In_Progress(instance);
+    zassert_equal(
+        in_progress, BACNET_LIGHTING_NOT_CONTROLLED, "in_progress=%s",
+        bactext_lighting_in_progress(in_progress));
+    /* tracking-value */
+    real_value = 100.0f;
+    status = Lighting_Output_Tracking_Value_Set(instance, real_value);
+    zassert_true(status, NULL);
+    test_real = Lighting_Output_Tracking_Value(instance);
+    zassert_true(is_float_equal(test_real, real_value), NULL);
+    /* blink-warn features */
+    status = Lighting_Output_Blink_Warn_Feature_Set(instance, 0.0f, 0, 65535);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Blink_Warn_Feature_Set(instance, -1.0f, 0, 65535);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Blink_Warn_Feature_Set(instance, 101.0f, 0, 65535);
+    zassert_true(status, NULL);
+    /* egress-time */
+    unsigned_value = 5 * 60;
+    status = Lighting_Output_Egress_Time_Set(instance, unsigned_value);
+    zassert_true(status, NULL);
+    test_unsigned = Lighting_Output_Egress_Time(instance);
+    zassert_equal(unsigned_value, test_unsigned, NULL);
+    /* default-fade-time */
+    unsigned_value = 5 * 60 * 1000;
+    status = Lighting_Output_Default_Fade_Time_Set(instance, unsigned_value);
+    zassert_true(status, NULL);
+    test_unsigned = Lighting_Output_Default_Fade_Time(instance);
+    zassert_equal(unsigned_value, test_unsigned, NULL);
+    /* default-ramp-rate */
+    real_value = 1.0f;
+    status = Lighting_Output_Default_Ramp_Rate_Set(instance, real_value);
+    zassert_true(status, NULL);
+    test_real = Lighting_Output_Default_Ramp_Rate(instance);
+    zassert_true(is_float_equal(test_real, real_value), NULL);
+    /* default-step-increment */
+    real_value = 2.0f;
+    status = Lighting_Output_Default_Step_Increment_Set(instance, real_value);
+    zassert_true(status, NULL);
+    test_real = Lighting_Output_Default_Step_Increment(instance);
+    zassert_true(is_float_equal(test_real, real_value), NULL);
+    /* relinquish-default */
+    real_value = 0.0f;
+    status = Lighting_Output_Relinquish_Default_Set(instance, real_value);
+    zassert_true(status, NULL);
+    test_real = Lighting_Output_Relinquish_Default(instance);
+    zassert_true(is_float_equal(test_real, real_value), NULL);
+    /* overridden */
+    real_value = 88.0f;
+    status = Lighting_Output_Overridden_Set(instance, real_value);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Overridden_Status(instance);
+    zassert_true(status, NULL);
+    test_real = Lighting_Output_Tracking_Value(instance);
+    zassert_true(
+        is_float_equal(test_real, real_value), "value=%f test_value=%f",
+        real_value, test_real);
+    status = Lighting_Output_Present_Value_Set(instance, 99.0f, priority);
+    zassert_true(status, NULL);
+    Lighting_Output_Timer(instance, 10);
+    test_real = Lighting_Output_Tracking_Value(instance);
+    zassert_true(
+        is_float_equal(test_real, real_value), "value=%f test_value=%f",
+        real_value, test_real);
+    real_value = Lighting_Output_Present_Value(instance);
+    status = Lighting_Output_Overridden_Clear(instance);
+    zassert_true(status, NULL);
+    Lighting_Output_Timer(instance, 10);
+    test_real = Lighting_Output_Tracking_Value(instance);
+    zassert_true(is_float_equal(test_real, real_value), NULL);
+    /* overridden-momentary */
+    real_value = 77.0f;
+    status = Lighting_Output_Overridden_Momentary(instance, real_value);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Overridden_Status(instance);
+    zassert_true(status, NULL);
+    test_real = Lighting_Output_Tracking_Value(instance);
+    zassert_true(
+        is_float_equal(test_real, real_value), "value=%f test_value=%f",
+        real_value, test_real);
+    status = Lighting_Output_Present_Value_Set(instance, 98.0f, priority);
+    Lighting_Output_Timer(instance, 10);
+    real_value = Lighting_Output_Present_Value(instance);
+    test_real = Lighting_Output_Tracking_Value(instance);
+    zassert_true(
+        is_float_equal(test_real, real_value), "value=%f test_value=%f",
+        real_value, test_real);
+    /* color-override */
+    status = Lighting_Output_Color_Override_Set(instance, true);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Color_Override(instance);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Color_Override_Set(instance, false);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Color_Override(instance);
+    zassert_false(status, NULL);
+    /* color-reference */
+    object_id.instance = 1;
+    object_id.type = OBJECT_COLOR;
+    status = Lighting_Output_Color_Reference_Set(instance, &object_id);
+    zassert_true(status, NULL);
+    status = Lighting_Output_Color_Reference(instance, &test_object_id);
+    zassert_true(status, NULL);
+    zassert_equal(object_id.instance, test_object_id.instance, NULL);
+    zassert_equal(object_id.type, test_object_id.type, NULL);
+    /* override-color-reference */
+    object_id.instance = 2;
+    object_id.type = OBJECT_COLOR;
+    status = Lighting_Output_Override_Color_Reference_Set(instance, &object_id);
+    zassert_true(status, NULL);
+    status =
+        Lighting_Output_Override_Color_Reference(instance, &test_object_id);
+    zassert_true(status, NULL);
+    zassert_equal(object_id.instance, test_object_id.instance, NULL);
+    zassert_equal(object_id.type, test_object_id.type, NULL);
+    /* tracking-value observer */
+    real_value = 95.0f;
+    Lighting_Output_Write_Present_Value_Callback_Set(
+        lighting_command_tracking_value_observer);
+    status = Lighting_Output_Present_Value_Set(instance, real_value, priority);
+    zassert_true(status, NULL);
+    Lighting_Output_Timer(instance, 10);
+    test_real = Lighting_Output_Tracking_Value(instance);
+    zassert_true(is_float_equal(test_real, real_value), NULL);
+    zassert_true(is_float_equal(Test_Tracking_Value, real_value), NULL);
+
+    /* out-of-bounds */
+    test_instance = Lighting_Output_Create(BACNET_MAX_INSTANCE + 1);
+    zassert_equal(test_instance, BACNET_MAX_INSTANCE, NULL);
     /* check the delete function */
     status = Lighting_Output_Delete(instance);
     zassert_true(status, NULL);
+    test_instance = Lighting_Output_Create(BACNET_MAX_INSTANCE);
+    zassert_equal(test_instance, 1, NULL);
+    Lighting_Output_Cleanup();
 
     return;
 }

test/bacnet/basic/sys/lighting_command/src/main.c

@@ -1,11 +1,7 @@
 /* @file
- * @brief test BACnet integer encode/decode APIs
+ * @brief test BACnet Lighting Command encode/decode APIs
  * @date June 2022
- * @brief tests sRGB to and from from CIE xy and brightness API
+ * @author Steve Karg <skarg@users.sourceforge.net>
- *
- * @section LICENSE
- * Copyright (c) 2022 Steve Karg <skarg@users.sourceforge.net>
- *
  * @copyright SPDX-License-Identifier: MIT
  */
 #include <stdint.h>
@@ -20,6 +16,7 @@
  */
 
 static float Tracking_Value;
+static uint16_t Tracking_Elapsed_Milliseconds;
 
 /**
  * @brief Callback for tracking value updates
@@ -33,6 +30,25 @@ static void dimmer_tracking_value(uint32_t key, float old_value, float value)
     Tracking_Value = value;
 }
 
+/**
+ * @brief Callback for non-standard Lighting_Operation timer values
+ * @param  data - Lighting Command data structure
+ * @param  milliseconds - elapsed time in milliseconds
+ */
+static void dimmer_timer_task(
+    struct bacnet_lighting_command_data *data, uint16_t milliseconds)
+{
+    Tracking_Elapsed_Milliseconds = milliseconds;
+    switch (data->Lighting_Operation) {
+        case BACNET_LIGHTS_PROPRIETARY_MIN:
+            break;
+        case BACNET_LIGHTS_PROPRIETARY_MAX:
+            break;
+        default:
+            break;
+    }
+}
+
 /**
  * @brief compare two floating point values to 3 decimal places
  *
@@ -127,20 +143,56 @@ static void test_lighting_command_command_unit(void)
 #endif
 {
     BACNET_LIGHTING_COMMAND_DATA data = { 0 };
+    struct lighting_command_notification observer1 = { 0 };
+    struct lighting_command_notification observer2 = { 0 };
+    struct lighting_command_timer_notification timer_observer1 = { 0 };
+    struct lighting_command_timer_notification timer_observer2 = { 0 };
     uint16_t milliseconds = 10;
     uint32_t fade_time = 1000;
     float target_level = 100.0f;
     float target_step = 1.0f;
+    float ramp_rate = 1000.0f;
+    float override_level;
 
     lighting_command_init(&data);
-    data.Notification_Head.callback = dimmer_tracking_value;
+    /* lighting command subscribe */
+    observer1.callback = dimmer_tracking_value;
+    lighting_command_notification_add(&data, &observer1);
+    /* add again to verify skipping */
+    lighting_command_notification_add(&data, &observer1);
+    /* add second tracker */
+    lighting_command_notification_add(&data, &observer2);
+
+    /* lighting command timer subscribe */
+    timer_observer1.callback = dimmer_timer_task;
+    lighting_command_timer_notfication_add(&data, &timer_observer1);
+    /* add again to verify skipping */
+    lighting_command_timer_notfication_add(&data, &timer_observer1);
+    /* add second tracker */
+    lighting_command_timer_notfication_add(&data, &timer_observer2);
+
+    /* basic STOP and NONE states */
     lighting_command_stop(&data);
     lighting_command_timer(&data, milliseconds);
     zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
     lighting_command_none(&data);
     lighting_command_timer(&data, milliseconds);
     zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+
+    /* normalized range clamp testing */
+    data.Max_Actual_Value = 95.0f;
+    data.Min_Actual_Value = 5.0f;
+    target_level = lighting_command_normalized_range_clamp(&data, 0.1f);
+    zassert_true(is_float_equal(target_level, 0.0f), NULL);
+    target_level = lighting_command_normalized_range_clamp(&data, 100.0f);
+    zassert_true(is_float_equal(target_level, data.Max_Actual_Value), NULL);
+    target_level = lighting_command_normalized_range_clamp(&data, 1.0f);
+    zassert_true(is_float_equal(target_level, data.Min_Actual_Value), NULL);
+    data.Max_Actual_Value = 100.0f;
+    data.Min_Actual_Value = 1.0f;
+
     /* fade up */
+    target_level = 100.0f;
     lighting_command_fade_to(&data, 100.0f, fade_time);
     milliseconds = fade_time / 2;
     lighting_command_timer(&data, milliseconds);
@@ -169,7 +221,7 @@ static void test_lighting_command_command_unit(void)
     milliseconds = 10;
     lighting_command_fade_to(&data, target_level, 0);
     lighting_command_timer(&data, milliseconds);
-    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_TRIM_ACTIVE, NULL);
     zassert_true(is_float_equal(Tracking_Value, data.Low_Trim_Value), NULL);
     target_level = 0.0f;
     milliseconds = 10;
@@ -184,9 +236,52 @@ static void test_lighting_command_command_unit(void)
     milliseconds = 10;
     lighting_command_fade_to(&data, target_level, 0);
     lighting_command_timer(&data, milliseconds);
-    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_TRIM_ACTIVE, NULL);
     zassert_true(is_float_equal(Tracking_Value, data.High_Trim_Value), NULL);
     data.High_Trim_Value = data.Max_Actual_Value;
+    /* override */
+    override_level = 42.0f;
+    target_level = 100.0f;
+    milliseconds = 10;
+    data.Overridden = true;
+    data.Overridden_Momentary = false;
+    lighting_command_override(&data, override_level);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(is_float_equal(Tracking_Value, override_level), NULL);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    lighting_command_fade_to(&data, target_level, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(is_float_equal(Tracking_Value, override_level), NULL);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    data.Overridden = false;
+    lighting_command_override(&data, target_level);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(is_float_equal(Tracking_Value, target_level), NULL);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    /* momentary override - self clearing flags */
+    override_level = 42.0f;
+    target_level = 100.0f;
+    milliseconds = 10;
+    data.Overridden = true;
+    data.Overridden_Momentary = true;
+    lighting_command_override(&data, override_level);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(is_float_equal(Tracking_Value, override_level), NULL);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_false(data.Overridden, NULL);
+    zassert_true(data.Overridden_Momentary, NULL);
+    lighting_command_fade_to(&data, target_level, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(is_float_equal(Tracking_Value, target_level), NULL);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_false(data.Overridden, NULL);
+    zassert_false(data.Overridden_Momentary, NULL);
+
+    /* step clamping */
+    target_step = lighting_command_step_increment_clamp(0.0f);
+    zassert_true(is_float_equal(target_step, 0.1f), NULL);
+    target_step = lighting_command_step_increment_clamp(100.1f);
+    zassert_true(is_float_equal(target_step, 100.0f), NULL);
 
     /* step UP - inhibit ON */
     target_step = 1.0f;
@@ -303,7 +398,8 @@ static void test_lighting_command_command_unit(void)
     zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
     zassert_true(is_float_equal(Tracking_Value, target_level), NULL);
     target_level = 100.0f;
-    lighting_command_ramp_to(&data, target_level, 100.0f);
+    ramp_rate = 100.0f;
+    lighting_command_ramp_to(&data, target_level, ramp_rate);
     lighting_command_timer(&data, milliseconds);
     zassert_true(
         data.In_Progress == BACNET_LIGHTING_RAMP_ACTIVE, "In_Progress=%d",
@@ -316,8 +412,9 @@ static void test_lighting_command_command_unit(void)
     /* slower ramp up */
     target_level = 100.0f;
     milliseconds = 100;
+    ramp_rate = 1.0f;
     do {
-        lighting_command_ramp_to(&data, target_level, 1.0f);
+        lighting_command_ramp_to(&data, target_level, ramp_rate);
         lighting_command_timer(&data, milliseconds);
         if (data.Lighting_Operation == BACNET_LIGHTS_RAMP_TO) {
             zassert_true(
@@ -335,8 +432,28 @@ static void test_lighting_command_command_unit(void)
     /* slower ramp down */
     target_level = data.Min_Actual_Value;
     milliseconds = 33;
+    ramp_rate = 0.1f;
     do {
-        lighting_command_ramp_to(&data, target_level, 0.1f);
+        lighting_command_ramp_to(&data, target_level, ramp_rate);
+        lighting_command_timer(&data, milliseconds);
+        if (data.Lighting_Operation == BACNET_LIGHTS_RAMP_TO) {
+            zassert_true(
+                data.In_Progress == BACNET_LIGHTING_RAMP_ACTIVE,
+                "In_Progress=%d", data.In_Progress);
+            zassert_true(
+                isgreater(data.Tracking_Value, data.Min_Actual_Value),
+                "Tracking_Value=%f", Tracking_Value);
+            zassert_true(
+                isless(data.Tracking_Value, data.Max_Actual_Value),
+                "Tracking_Value=%f", Tracking_Value);
+        }
+    } while (data.Lighting_Operation != BACNET_LIGHTS_STOP);
+    /* large elapsed timer - ramp up */
+    target_level = data.Max_Actual_Value;
+    milliseconds = 2000;
+    ramp_rate = 0.1f;
+    do {
+        lighting_command_ramp_to(&data, target_level, ramp_rate);
         lighting_command_timer(&data, milliseconds);
         if (data.Lighting_Operation == BACNET_LIGHTS_RAMP_TO) {
             zassert_true(
@@ -351,13 +468,88 @@ static void test_lighting_command_command_unit(void)
         }
     } while (data.Lighting_Operation != BACNET_LIGHTS_STOP);
 
+    /* out-of-service */
+    target_level = 100.0f;
+    milliseconds = 10;
+    data.Out_Of_Service = false;
+    lighting_command_fade_to(&data, target_level, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(is_float_equal(Tracking_Value, target_level), NULL);
+    data.Out_Of_Service = true;
+    lighting_command_fade_to(&data, 0.0f, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    /* previous target level - unchanged */
+    zassert_true(is_float_equal(Tracking_Value, target_level), NULL);
+    target_level = 0.0f;
+    data.Out_Of_Service = false;
+    lighting_command_fade_to(&data, target_level, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(is_float_equal(Tracking_Value, target_level), NULL);
+
+    /* restore-on, toggle-restore */
+    target_level = 0.0f;
+    milliseconds = 10;
+    lighting_command_fade_to(&data, target_level, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(is_float_equal(Tracking_Value, target_level), NULL);
+    lighting_command_restore_on(&data, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(is_float_equal(Tracking_Value, data.Last_On_Value), NULL);
+    lighting_command_toggle_restore(&data, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(is_float_equal(Tracking_Value, 0.0f), NULL);
+    lighting_command_toggle_restore(&data, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(is_float_equal(Tracking_Value, data.Last_On_Value), NULL);
+
+    /* default-on, toggle-default */
+    target_level = 0.0f;
+    milliseconds = 10;
+    lighting_command_fade_to(&data, target_level, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(is_float_equal(Tracking_Value, target_level), NULL);
+    lighting_command_default_on(&data, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(is_float_equal(Tracking_Value, data.Default_On_Value), NULL);
+    lighting_command_toggle_default(&data, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(is_float_equal(Tracking_Value, 0.0f), NULL);
+    lighting_command_toggle_default(&data, 0);
+    lighting_command_timer(&data, milliseconds);
+    zassert_true(data.In_Progress == BACNET_LIGHTING_IDLE, NULL);
+    zassert_true(is_float_equal(Tracking_Value, data.Default_On_Value), NULL);
+
+    /* non-standard lighting operation */
+    milliseconds = 10;
+    data.Lighting_Operation = BACNET_LIGHTS_PROPRIETARY_MIN;
+    lighting_command_timer(&data, milliseconds);
+    zassert_equal(data.Lighting_Operation, BACNET_LIGHTS_PROPRIETARY_MIN, NULL);
+    data.Lighting_Operation = BACNET_LIGHTS_PROPRIETARY_MAX;
+    lighting_command_timer(&data, milliseconds);
+    zassert_equal(data.Lighting_Operation, BACNET_LIGHTS_PROPRIETARY_MAX, NULL);
+
     /* null check code coverage */
+    lighting_command_override(NULL, override_level);
     lighting_command_fade_to(NULL, 0.0f, 0);
     lighting_command_ramp_to(NULL, 0.0f, 0.0f);
     lighting_command_step(NULL, BACNET_LIGHTS_STEP_OFF, 0.0f);
     lighting_command_blink_warn(NULL, BACNET_LIGHTS_WARN, NULL);
     lighting_command_stop(NULL);
     lighting_command_none(NULL);
+    lighting_command_restore_on(NULL, 0);
+    lighting_command_default_on(NULL, 0);
+    lighting_command_toggle_restore(NULL, 0);
+    lighting_command_toggle_default(NULL, 0);
     lighting_command_timer(NULL, 0);
     lighting_command_init(NULL);
 }