Repo unification

firmware/tests/ut_logic/ut_coil.c

@@ -0,0 +1,86 @@
+#include "ut_coil.h"
+#include "..\..\src\logic\coil.h"
+
+static int ut_coil_target(uint8_t force, uint8_t hbrake_act, int16_t exp_out)
+{
+    int16_t out = coil_target(force, hbrake_act);
+
+    printf("Force:%d Handbrake:%d \n", force, hbrake_act);
+    printf("Output:%d Expected:%d\n", out, exp_out);
+
+    if(out==exp_out)
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_coil_target_test(void)
+{
+    printf("******************************************************\n");
+    printf("int16_t coil_target(uint8_t force, uint8_t hbrake_act)\n");
+
+    int test_res;
+    int pass = 1;
+
+    uint8_t force;
+    uint8_t hbrake;
+
+    int16_t exp_out;
+
+    force = 0;
+    hbrake = 0;
+    exp_out = 0;
+    test_res = ut_coil_target(force, hbrake, exp_out);
+    if(!test_res) pass = 0;
+
+    force = 50;
+    hbrake = 0;
+    exp_out = COIL_LOCK_VOLTAGE/2;
+    test_res = ut_coil_target(force, hbrake, exp_out);
+    if(!test_res) pass = 0;
+
+    force = 100;
+    hbrake = 0;
+    exp_out = COIL_LOCK_VOLTAGE;
+    test_res = ut_coil_target(force, hbrake, exp_out);
+    if(!test_res) pass = 0;
+
+    force = 255;
+    hbrake = 0;
+    exp_out = COIL_LOCK_VOLTAGE;
+    test_res = ut_coil_target(force, hbrake, exp_out);
+    if(!test_res) pass = 0;
+
+    force = 0;
+    hbrake = 1;
+    exp_out = COIL_TARGET_HANDBRAKE;
+    test_res = ut_coil_target(force, hbrake, exp_out);
+    if(!test_res) pass = 0;
+
+    force = 50;
+    hbrake = 1;
+    exp_out = COIL_TARGET_HANDBRAKE;
+    test_res = ut_coil_target(force, hbrake, exp_out);
+    if(!test_res) pass = 0;
+
+    force = 100;
+    hbrake = 1;
+    exp_out = COIL_TARGET_HANDBRAKE;
+    test_res = ut_coil_target(force, hbrake, exp_out);
+    if(!test_res) pass = 0;
+
+    force = 255;
+    hbrake = 1;
+    exp_out = COIL_TARGET_HANDBRAKE;
+    test_res = ut_coil_target(force, hbrake, exp_out);
+    if(!test_res) pass = 0;
+
+    return pass;
+}
+

firmware/tests/ut_logic/ut_coil.h

@@ -0,0 +1,9 @@
+#ifndef UT_COIL_H_
+#define UT_COIL_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int ut_coil_target_test(void);
+
+#endif /* UT_COIL_H_ */

firmware/tests/ut_logic/ut_display.c

@@ -0,0 +1,552 @@
+#include "ut_display.h"
+#include "..\..\src\logic\display.h"
+
+static const uint8_t BACKLIGHT_DIMM = DSP_BACKLIGHT_DIMM_PERCENT;
+static const uint8_t BACKLIGHT_BRIGTH = DSP_BACKLIGHT_BRIGTH_PERCENT;
+
+static int ut_dsp_init_ctrl(dsp_ctrl_t* ctrl, dsp_ctrl_t* exp_ctrl)
+{
+    printf("   Input: lock:%d act-image:%x \n", ctrl->img_lock, ctrl->act_img);
+
+    dsp_init_ctrl(ctrl);
+
+    printf("  Output: lock:%d act-image:%x \n", ctrl->img_lock, ctrl->act_img);
+    printf("Expected: lock:%d act-image:%x \n", exp_ctrl->img_lock, exp_ctrl->act_img);
+
+    if((ctrl->img_lock==exp_ctrl->img_lock)&&(ctrl->act_img==exp_ctrl->act_img))
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_dsp_init_ctrl_test(void)
+{
+    printf("******************************************************\n");
+    printf("void dsp_init_ctrl(dsp_ctrl_t* ctrl) \n");
+
+    int test_res;
+    int pass = 1;
+
+    dsp_ctrl_t ctrl;
+    dsp_ctrl_t exp_ctrl;
+
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0;
+    exp_ctrl.img_lock = 0;
+    exp_ctrl.act_img = 0x00;
+    test_res = ut_dsp_init_ctrl(&ctrl, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    ctrl.img_lock = 1;
+    ctrl.act_img = 0xAA;
+    exp_ctrl.img_lock = 0;
+    exp_ctrl.act_img = 0x00;
+    test_res = ut_dsp_init_ctrl(&ctrl, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    return pass;
+}
+
+static int ut_dsp_set_lock(dsp_ctrl_t* ctrl, dsp_ctrl_t* exp_ctrl)
+{
+    printf("   Input: lock:%d act-image:%x \n", ctrl->img_lock, ctrl->act_img);
+
+    dsp_set_lock(ctrl);
+
+    printf("  Output: lock:%d act-image:%x \n", ctrl->img_lock, ctrl->act_img);
+    printf("Expected: lock:%d act-image:%x \n", exp_ctrl->img_lock, exp_ctrl->act_img);
+
+    if((ctrl->img_lock==exp_ctrl->img_lock)&&(ctrl->act_img==exp_ctrl->act_img))
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_dsp_set_lock_test(void)
+{
+    printf("******************************************************\n");
+    printf("void dsp_set_lock(dsp_ctrl_t* ctrl)\n");
+
+    int test_res;
+    int pass = 1;
+
+    dsp_ctrl_t ctrl;
+    dsp_ctrl_t exp_ctrl;
+
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x18;
+    exp_ctrl.img_lock = 1;
+    exp_ctrl.act_img = 0x18;
+    test_res = ut_dsp_set_lock(&ctrl, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    ctrl.img_lock = 1;
+    ctrl.act_img = 0x3F;
+    exp_ctrl.img_lock = 1;
+    exp_ctrl.act_img = 0x3F;
+    test_res = ut_dsp_set_lock(&ctrl, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    return pass;
+}
+
+static int ut_dsp_reset_lock(dsp_ctrl_t* ctrl, dsp_ctrl_t* exp_ctrl)
+{
+    printf("   Input: lock:%d act-image:%x \n", ctrl->img_lock, ctrl->act_img);
+
+    dsp_reset_lock(ctrl);
+
+    printf("  Output: lock:%d act-image:%x \n", ctrl->img_lock, ctrl->act_img);
+    printf("Expected: lock:%d act-image:%x \n", exp_ctrl->img_lock, exp_ctrl->act_img);
+
+    if((ctrl->img_lock==exp_ctrl->img_lock)&&(ctrl->act_img==exp_ctrl->act_img))
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_dsp_reset_lock_test(void)
+{
+    printf("******************************************************\n");
+    printf("void dsp_reset_lock(dsp_ctrl_t* ctrl)\n");
+
+    int test_res;
+    int pass = 1;
+
+   dsp_ctrl_t ctrl;
+    dsp_ctrl_t exp_ctrl;
+
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x18;
+    exp_ctrl.img_lock = 0;
+    exp_ctrl.act_img = 0x18;
+    test_res = ut_dsp_reset_lock(&ctrl, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    ctrl.img_lock = 1;
+    ctrl.act_img = 0x18;
+    exp_ctrl.img_lock = 0;
+    exp_ctrl.act_img = 0x18;
+    test_res = ut_dsp_reset_lock(&ctrl, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    return pass;
+}
+
+static int ut_dsp_img_percent(uint8_t value, dsp_style_t style, dsp_ctrl_t* ctrl, uint8_t exp_out, dsp_ctrl_t* exp_ctrl)
+{
+    printf("   Input: Percent:%d Style:%d lock:%d act-image:%x \n", value, style, ctrl->img_lock, ctrl->act_img);
+
+    uint8_t out = dsp_img_percent(value, style, ctrl);
+
+    printf("  Output: image:%x lock:%d act-image:%x \n", out, ctrl->img_lock, ctrl->act_img);
+    printf("Expected: image:%x lock:%d act-image:%x \n", exp_out, exp_ctrl->img_lock, exp_ctrl->act_img);
+
+    if((out==exp_out)&&(ctrl->img_lock==exp_ctrl->img_lock)&&(ctrl->act_img==exp_ctrl->act_img))
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_dsp_img_percent_test(void)
+{
+    printf("******************************************************\n");
+    printf("uint8_t dsp_img_percent(uint8_t value, dsp_style_t style, dsp_ctrl_t* ctrl)\n");
+
+    int test_res;
+    int pass = 1;
+
+    uint8_t value;
+    dsp_style_t style;
+    dsp_ctrl_t ctrl;
+    uint8_t exp_out;
+    dsp_ctrl_t exp_ctrl;
+
+    // Test lock
+    value = 50;
+    style = LED_DSP_BAR;
+    ctrl.img_lock = 1;
+    ctrl.act_img = 0x2A;
+    exp_out = 0x2A;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test styles
+    value = 50;
+    style = LED_DSP_BAR;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x07;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test styles
+    value = 50;
+    style = LED_DSP_DOT20;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x04;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test styles
+    value = 50;
+    style = LED_DSP_DOT10;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x0C;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test values
+    value = 0;
+    style = LED_DSP_DOT10;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x01;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test values
+    value = 10;
+    style = LED_DSP_DOT10;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x03;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test values
+    value = 20;
+    style = LED_DSP_DOT10;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x02;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test values
+    value = 30;
+    style = LED_DSP_DOT10;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x06;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test values
+    value = 40;
+    style = LED_DSP_DOT10;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x04;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test values
+    value = 50;
+    style = LED_DSP_DOT10;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x0C;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test values
+    value = 60;
+    style = LED_DSP_DOT10;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x08;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test values
+    value = 80;
+    style = LED_DSP_DOT10;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x10;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test values
+    value = 90;
+    style = LED_DSP_DOT10;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x30;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test values
+    value = 110;
+    style = LED_DSP_DOT10;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x20;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_percent(value, style, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    return pass;
+}
+
+static int ut_dsp_img_raw(uint8_t image, dsp_ctrl_t* ctrl, uint8_t exp_out, dsp_ctrl_t* exp_ctrl)
+{
+    printf("   Input: Image:%x lock:%d act-image:%x \n", image, ctrl->img_lock, ctrl->act_img);
+
+    uint8_t out = dsp_img_raw(image, ctrl);
+
+    printf("  Output: image:%x lock:%d act-image:%x \n", out, ctrl->img_lock, ctrl->act_img);
+    printf("Expected: image:%x lock:%d act-image:%x \n", exp_out, exp_ctrl->img_lock, exp_ctrl->act_img);
+
+    if((out==exp_out)&&(ctrl->img_lock==exp_ctrl->img_lock)&&(ctrl->act_img==exp_ctrl->act_img))
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_dsp_img_raw_test(void)
+{
+    printf("******************************************************\n");
+    printf("uint8_t dsp_img_raw(int8_t image, dsp_ctrl_t* ctrl)\n");
+
+    int test_res;
+    int pass = 1;
+
+    uint8_t image;
+    dsp_ctrl_t ctrl;
+    uint8_t exp_out;
+    dsp_ctrl_t exp_ctrl;
+
+    // Test lock
+    image = 0x17;
+    ctrl.img_lock = 1;
+    ctrl.act_img = 0x2A;
+    exp_out = 0x2A;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_raw(image, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test normal
+    image = 0x17;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x17;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_raw(image, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test limit
+    image = 0xAA;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x2A;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_raw(image, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test limit
+    image = 0xCC;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x00;
+    exp_out = 0x0C;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_img_raw(image, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    return pass;
+}
+
+static int ut_dsp_get_act_img(dsp_ctrl_t* ctrl, uint8_t exp_out, dsp_ctrl_t* exp_ctrl)
+{
+    printf("   Input: lock:%d act-image:%x \n", ctrl->img_lock, ctrl->act_img);
+
+    uint8_t out = dsp_get_act_img(ctrl);
+
+    printf("  Output: image:%x lock:%d act-image:%x \n", out, ctrl->img_lock, ctrl->act_img);
+    printf("Expected: image:%x lock:%d act-image:%x \n", exp_out, exp_ctrl->img_lock, exp_ctrl->act_img);
+
+    if((out==exp_out)&&(ctrl->img_lock==exp_ctrl->img_lock)&&(ctrl->act_img==exp_ctrl->act_img))
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_dsp_get_act_img_test(void)
+{
+    printf("******************************************************\n");
+    printf("uint8_t dsp_get_act_img(void)\n");
+
+    int test_res;
+    int pass = 1;
+
+    dsp_ctrl_t ctrl;
+    uint8_t exp_out;
+    dsp_ctrl_t exp_ctrl;
+
+    // Test
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x2A;
+    exp_out = 0x2A;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_get_act_img(&ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test
+    ctrl.img_lock = 1;
+    ctrl.act_img = 0x3F;
+    exp_out = 0x3F;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = exp_out;
+    test_res = ut_dsp_get_act_img(&ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    return pass;
+}
+
+static int ut_dsp_backlight(uint8_t dimm_act, dsp_ctrl_t* ctrl, uint8_t exp_out, dsp_ctrl_t* exp_ctrl)
+{
+    printf("   Input: dimm-act:%d lock:%d act-image:%x \n", dimm_act, ctrl->img_lock, ctrl->act_img);
+
+    uint8_t out = dsp_backlight(dimm_act);
+
+    printf("  Output: percent:%x lock:%d act-image:%x \n", out, ctrl->img_lock, ctrl->act_img);
+    printf("Expected: percent:%x lock:%d act-image:%x \n", exp_out, exp_ctrl->img_lock, exp_ctrl->act_img);
+
+    if((out==exp_out)&&(ctrl->img_lock==exp_ctrl->img_lock)&&(ctrl->act_img==exp_ctrl->act_img))
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_dsp_backlight_test(void)
+{
+    printf("******************************************************\n");
+    printf("uint8_t dsp_backlight(uint8_t dimm_act)\n");
+
+    int test_res;
+    int pass = 1;
+
+    uint8_t dimm_act;
+    dsp_ctrl_t ctrl;
+    uint8_t exp_out;
+    dsp_ctrl_t exp_ctrl;
+
+    // Test
+    dimm_act = 0;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x2A;
+    exp_out = DSP_BACKLIGHT_BRIGTH_PERCENT;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = ctrl.act_img;
+    test_res = ut_dsp_backlight(dimm_act, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test
+    dimm_act = 1;
+    ctrl.img_lock = 0;
+    ctrl.act_img = 0x2A;
+    exp_out = DSP_BACKLIGHT_DIMM_PERCENT;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = ctrl.act_img;
+    test_res = ut_dsp_backlight(dimm_act, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test lock ignore
+    dimm_act = 0;
+    ctrl.img_lock = 1;
+    ctrl.act_img = 0x2A;
+    exp_out = DSP_BACKLIGHT_BRIGTH_PERCENT;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = ctrl.act_img;
+    test_res = ut_dsp_backlight(dimm_act, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    // Test lock ignore
+    dimm_act = 1;
+    ctrl.img_lock = 1;
+    ctrl.act_img = 0x2A;
+    exp_out = DSP_BACKLIGHT_DIMM_PERCENT;
+    exp_ctrl.img_lock = ctrl.img_lock;
+    exp_ctrl.act_img = ctrl.act_img;
+    test_res = ut_dsp_backlight(dimm_act, &ctrl, exp_out, &exp_ctrl);
+    if(!test_res) pass = 0;
+
+    return pass;
+}

firmware/tests/ut_logic/ut_display.h

@@ -0,0 +1,19 @@
+#ifndef UT_DISPLAY_H_
+#define UT_DISPLAY_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+int ut_dsp_init_ctrl_test(void);
+
+int ut_dsp_set_lock_test(void);
+int ut_dsp_reset_lock_test(void);
+
+int ut_dsp_img_percent_test(void);
+
+int ut_dsp_img_raw_test(void);
+
+int ut_dsp_get_act_img_test(void);
+
+int ut_dsp_backlight_test(void);
+
+#endif /* UT_DISPLAY_H_ */

firmware/tests/ut_logic/ut_force.c

@@ -0,0 +1,170 @@
+#include "ut_force.h"
+#include "..\..\src\logic\force.h"
+
+static int ut_force_cycle_bmode(fbrake_mode_t bmode, fbrake_mode_t exp_out)
+{
+    fbrake_mode_t out = force_cycle_bmode(bmode);
+
+    printf("Brake mode:%d\n", bmode);
+    printf("Output:%d Expected:%d\n", out, exp_out);
+
+    if(out==exp_out)
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_force_cycle_bmode_test(void)
+{
+    printf("******************************************************\n");
+    printf("fbrake_mode_t force_cycle_bmode(fbrake_mode_t bmode)\n");
+
+    int test_res;
+    int pass = 1;
+
+    fbrake_mode_t bmode;
+
+    fbrake_mode_t exp_out;
+
+    bmode = FORCE_BMODE_OPEN;
+    exp_out = FORCE_BMODE_KEEP;
+    test_res = ut_force_cycle_bmode(bmode,exp_out);
+    if(!test_res) pass = 0;
+
+    bmode = FORCE_BMODE_KEEP;
+    exp_out = FORCE_BMODE_LOCK;
+    test_res = ut_force_cycle_bmode(bmode,exp_out);
+    if(!test_res) pass = 0;
+
+    bmode = FORCE_BMODE_LOCK;
+    exp_out = FORCE_BMODE_OPEN;
+    test_res = ut_force_cycle_bmode(bmode,exp_out);
+    if(!test_res) pass = 0;
+
+    return pass;
+}
+
+static  int ut_force_next(uint8_t handbrake, uint8_t brakes, fbrake_mode_t bmode, uint8_t user_force, uint16_t hbarke_act_time, uint8_t exp_out)
+{
+    uint8_t out = force_next(handbrake, brakes, bmode, user_force, hbarke_act_time);
+
+    printf("Handbrake:%d Brakes:%d Brake-Mode:%d User-Force:%d Handbrake-time:%d\n", handbrake, brakes, bmode, user_force, hbarke_act_time);
+    printf("Output:%d Expected:%d\n", out, exp_out);
+
+    if(out==exp_out)
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_force_next_test(void)
+{
+    printf("******************************************************\n");
+    printf("uint8_t force_next(uint8_t handbrake, uint8_t brakes, fbrake_mode_t bmode, uint8_t user_force, uint16_t hbarke_act_time)\n");
+
+    int test_res;
+    int pass = 1;
+
+    uint8_t handbrake;
+    uint8_t brakes;
+    fbrake_mode_t bmode;
+    uint8_t user_force;
+    uint16_t hbarke_act_time;
+
+    uint8_t exp_out;
+
+    handbrake = 0;
+    brakes = 0;
+    bmode = FORCE_BMODE_OPEN;
+    user_force = 0;
+    hbarke_act_time = 0;
+    exp_out = 0;
+    test_res = ut_force_next(handbrake, brakes, bmode, user_force, hbarke_act_time, exp_out);
+    if(!test_res) pass = 0;
+
+    handbrake = 0;
+    brakes = 0;
+    bmode = FORCE_BMODE_OPEN;
+    user_force = 99;
+    hbarke_act_time = 0;
+    exp_out = 99;
+    test_res = ut_force_next(handbrake, brakes, bmode, user_force, hbarke_act_time, exp_out);
+    if(!test_res) pass = 0;
+
+    handbrake = 0;
+    brakes = 1;
+    bmode = FORCE_BMODE_OPEN;
+    user_force = 99;
+    hbarke_act_time = 0;
+    exp_out = 0;
+    test_res = ut_force_next(handbrake, brakes, bmode, user_force, hbarke_act_time, exp_out);
+    if(!test_res) pass = 0;
+
+    handbrake = 0;
+    brakes = 1;
+    bmode = FORCE_BMODE_KEEP;
+    user_force = 99;
+    hbarke_act_time = 0;
+    exp_out = 99;
+    test_res = ut_force_next(handbrake, brakes, bmode, user_force, hbarke_act_time, exp_out);
+    if(!test_res) pass = 0;
+
+    handbrake = 0;
+    brakes = 1;
+    bmode = FORCE_BMODE_LOCK;
+    user_force = 99;
+    hbarke_act_time = 0;
+    exp_out = 100;
+    test_res = ut_force_next(handbrake, brakes, bmode, user_force, hbarke_act_time, exp_out);
+    if(!test_res) pass = 0;
+
+    handbrake = 1;
+    brakes = 1;
+    bmode = FORCE_BMODE_LOCK;
+    user_force = 99;
+    hbarke_act_time = 0;
+    exp_out = 0;
+    test_res = ut_force_next(handbrake, brakes, bmode, user_force, hbarke_act_time, exp_out);
+    if(!test_res) pass = 0;
+
+    handbrake = 1;
+    brakes = 1;
+    bmode = FORCE_BMODE_LOCK;
+    user_force = 99;
+    hbarke_act_time = FORCE_MAX_HBRAKE_HOLD_TIME-1;
+    exp_out = 0;
+    test_res = ut_force_next(handbrake, brakes, bmode, user_force, hbarke_act_time, exp_out);
+    if(!test_res) pass = 0;
+
+    handbrake = 1;
+    brakes = 1;
+    bmode = FORCE_BMODE_LOCK;
+    user_force = 99;
+    hbarke_act_time = FORCE_MAX_HBRAKE_HOLD_TIME;
+    exp_out = 100;
+    test_res = ut_force_next(handbrake, brakes, bmode, user_force, hbarke_act_time, exp_out);
+    if(!test_res) pass = 0;
+
+    handbrake = 1;
+    brakes = 1;
+    bmode = FORCE_BMODE_LOCK;
+    user_force = 99;
+    hbarke_act_time = FORCE_MAX_HBRAKE_HOLD_TIME+1;
+    exp_out = 100;
+    test_res = ut_force_next(handbrake, brakes, bmode, user_force, hbarke_act_time, exp_out);
+    if(!test_res) pass = 0;
+
+    return pass;
+}

firmware/tests/ut_logic/ut_force.h

@@ -0,0 +1,10 @@
+#ifndef UT_FORCE_H_
+#define UT_FORCE_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int ut_force_cycle_bmode_test(void);
+int ut_force_next_test(void);
+
+#endif /* UT_FORCE_H_ */

firmware/tests/ut_logic/ut_pot.c

@@ -0,0 +1,100 @@
+#include "ut_pot.h"
+#include "..\..\src\logic\pot.h"
+
+static int ut_pot_mv_to_percent(uint16_t value, pot_cfg_t* cfg, uint8_t exp_out)
+{
+    uint8_t out = pot_mv_to_percent(value, cfg);
+
+    printf("Value:%d Reference:%d Deadband:%d \n", value, cfg->reference, cfg->deadband);
+    printf("Output:%d Expected:%d\n", out, exp_out);
+
+    if(out==exp_out)
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_pot_mv_to_percent_test(void)
+{
+    printf("******************************************************\n");
+    printf("uint8_t pot_mv_to_percent(uint16_t value, pot_cfg_t* cfg)\n");
+
+    int test_res;
+    int pass = 1;
+
+    uint16_t value;
+    pot_cfg_t cfg;
+
+    uint8_t exp_out;
+
+    value = 0;
+    cfg.deadband = 500;
+    cfg.reference = 5000;
+    exp_out = 0;
+    test_res = ut_pot_mv_to_percent(value, &cfg, exp_out);
+    if(!test_res) pass = 0;
+
+    value = 499;
+    cfg.deadband = 500;
+    cfg.reference = 5000;
+    exp_out = 0;
+    test_res = ut_pot_mv_to_percent(value, &cfg, exp_out);
+    if(!test_res) pass = 0;
+
+    value = 500;
+    cfg.deadband = 500;
+    cfg.reference = 5000;
+    exp_out = 0;
+    test_res = ut_pot_mv_to_percent(value, &cfg, exp_out);
+    if(!test_res) pass = 0;
+
+    value = 1500;
+    cfg.deadband = 500;
+    cfg.reference = 5000;
+    exp_out = 25;
+    test_res = ut_pot_mv_to_percent(value, &cfg, exp_out);
+    if(!test_res) pass = 0;
+
+    value = 2500;
+    cfg.deadband = 500;
+    cfg.reference = 5000;
+    exp_out = 50;
+    test_res = ut_pot_mv_to_percent(value, &cfg, exp_out);
+    if(!test_res) pass = 0;
+
+    value = 3500;
+    cfg.deadband = 500;
+    cfg.reference = 5000;
+    exp_out = 75;
+    test_res = ut_pot_mv_to_percent(value, &cfg, exp_out);
+    if(!test_res) pass = 0;
+
+    value = 4500;
+    cfg.deadband = 500;
+    cfg.reference = 5000;
+    exp_out = 100;
+    test_res = ut_pot_mv_to_percent(value, &cfg, exp_out);
+    if(!test_res) pass = 0;
+
+    value = 4501;
+    cfg.deadband = 500;
+    cfg.reference = 5000;
+    exp_out = 100;
+    test_res = ut_pot_mv_to_percent(value, &cfg, exp_out);
+    if(!test_res) pass = 0;
+
+    value = 5000;
+    cfg.deadband = 500;
+    cfg.reference = 5000;
+    exp_out = 100;
+    test_res = ut_pot_mv_to_percent(value, &cfg, exp_out);
+    if(!test_res) pass = 0;
+
+    return pass;
+}

firmware/tests/ut_logic/ut_pot.h

@@ -0,0 +1,9 @@
+#ifndef UT_POT_H_
+#define UT_POT_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int ut_pot_mv_to_percent_test(void);
+
+#endif /* UT_POT_H_ */

firmware/tests/ut_logic/ut_user_force.c

@@ -0,0 +1,419 @@
+#include "ut_user_force.h"
+#include "..\..\src\logic\user_force.h"
+
+static int ut_user_force_btn(uint8_t prev_force, uint8_t up_act, uint8_t down_act, uint8_t delta, uint8_t exp_out)
+{
+    uint8_t out = user_force_btn(prev_force, up_act, down_act, delta);
+
+    printf("Prev-Force:%d Up-act:%d Down-act:%d Delta:%d\n", prev_force, up_act, down_act, delta);
+    printf("Output:%d Expected:%d\n", out, exp_out);
+
+    if(out==exp_out)
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_user_force_btn_test(void)
+{
+    printf("******************************************************\n");
+    printf("uint8_t user_force_btn(uint8_t prev_force, uint8_t up_act, uint8_t down_act, uint8_t delta)\n");
+
+    int test_res;
+    int pass = 1;
+
+    uint8_t prev_force;
+    uint8_t up_act;
+    uint8_t down_act;
+    uint8_t delta;
+
+    uint8_t exp_out;
+
+    // No change
+    prev_force = 0;
+    up_act = 0;
+    down_act = 0;
+    delta = 5;
+    exp_out = 0;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = USER_FORCE_MIN_PERCENT-1;
+    up_act = 0;
+    down_act = 0;
+    delta = 5;
+    exp_out = 0;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 50;
+    up_act = 0;
+    down_act = 0;
+    delta = 5;
+    exp_out = 50;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = USER_FORCE_MAX_PERCENT+1;
+    up_act = 0;
+    down_act = 0;
+    delta = 5;
+    exp_out = 100;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 100;
+    up_act = 0;
+    down_act = 0;
+    delta = 5;
+    exp_out = 100;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    // Start 0
+    prev_force = 0;
+    up_act = 1;
+    down_act = 0;
+    delta = 5;
+    exp_out = USER_FORCE_MIN_PERCENT;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 0;
+    up_act = 0;
+    down_act = 1;
+    delta = 5;
+    exp_out = 0;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 0;
+    up_act = 1;
+    down_act = 1;
+    delta = 5;
+    exp_out = 0;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 0;
+    up_act = 1;
+    down_act = 0;
+    delta = USER_FORCE_MIN_PERCENT+1;
+    exp_out = USER_FORCE_MIN_PERCENT+1;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    // Start 100
+    prev_force = 100;
+    up_act = 1;
+    down_act = 0;
+    delta = 5;
+    exp_out = 100;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 100;
+    up_act = 0;
+    down_act = 1;
+    delta = 5;
+    exp_out = USER_FORCE_MAX_PERCENT;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 100;
+    up_act = 1;
+    down_act = 1;
+    delta = 5;
+    exp_out = USER_FORCE_MAX_PERCENT;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 100;
+    up_act = 0;
+    down_act = 1;
+    delta = 100-USER_FORCE_MAX_PERCENT+1;
+    exp_out = USER_FORCE_MAX_PERCENT-1;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    // Start 50
+    prev_force = 50;
+    up_act = 1;
+    down_act = 0;
+    delta = 5;
+    exp_out = 55;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 50;
+    up_act = 0;
+    down_act = 1;
+    delta = 5;
+    exp_out = 45;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 50;
+    up_act = 1;
+    down_act = 1;
+    delta = 5;
+    exp_out = 45;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 50;
+    up_act = 1;
+    down_act = 0;
+    delta = 10;
+    exp_out = 60;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 50;
+    up_act = 0;
+    down_act = 1;
+    delta = 10;
+    exp_out = 40;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    // Start MIN_PERCENT+1
+    prev_force = USER_FORCE_MIN_PERCENT+1;
+    up_act = 1;
+    down_act = 0;
+    delta = 5;
+    exp_out = prev_force+delta;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = USER_FORCE_MIN_PERCENT+1;
+    up_act = 0;
+    down_act = 1;
+    delta = 5;
+    exp_out = 0;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = USER_FORCE_MIN_PERCENT+1;
+    up_act = 1;
+    down_act = 1;
+    delta = 5;
+    exp_out = 0;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    // Start MAX_PERCENT-1
+    prev_force = USER_FORCE_MAX_PERCENT-1;
+    up_act = 1;
+    down_act = 0;
+    delta = 5;
+    exp_out = 100;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = USER_FORCE_MAX_PERCENT-1;
+    up_act = 0;
+    down_act = 1;
+    delta = 5;
+    exp_out = prev_force-delta;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = USER_FORCE_MAX_PERCENT-1;
+    up_act = 1;
+    down_act = 1;
+    delta = 5;
+    exp_out = prev_force-delta;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    // Up down seq
+    prev_force = 0;
+    up_act = 1;
+    down_act = 0;
+    delta = 20;
+    exp_out = 20;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 20;
+    up_act = 1;
+    down_act = 0;
+    delta = 20;
+    exp_out = 40;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 40;
+    up_act = 1;
+    down_act = 0;
+    delta = 20;
+    exp_out = 60;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 60;
+    up_act = 1;
+    down_act = 0;
+    delta = 20;
+    exp_out = 80;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 80;
+    up_act = 1;
+    down_act = 0;
+    delta = 20;
+    exp_out = 100;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 100;
+    up_act = 1;
+    down_act = 0;
+    delta = 20;
+    exp_out = 100;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 100;
+    up_act = 0;
+    down_act = 1;
+    delta = 20;
+    exp_out = 80;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 80;
+    up_act = 0;
+    down_act = 1;
+    delta = 20;
+    exp_out = 60;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 60;
+    up_act = 0;
+    down_act = 1;
+    delta = 20;
+    exp_out = 40;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 40;
+    up_act = 0;
+    down_act = 1;
+    delta = 20;
+    exp_out = 20;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 20;
+    up_act = 0;
+    down_act = 1;
+    delta = 20;
+    exp_out = 0;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 0;
+    up_act = 0;
+    down_act = 1;
+    delta = 20;
+    exp_out = 0;
+    test_res = ut_user_force_btn(prev_force, up_act, down_act, delta, exp_out);
+    if(!test_res) pass = 0;
+
+    return pass;
+}
+
+static int ut_user_force_pot(uint8_t prev_force, uint8_t pot, uint8_t hyst, uint8_t exp_out)
+{
+    uint8_t out = user_force_pot(prev_force, pot, hyst);
+
+    printf("Prev-Force:%d Pot-percent:%d Hysteresis:%d \n", prev_force, pot, hyst);
+    printf("Output:%d Expected:%d\n", out, exp_out);
+
+    if(out==exp_out)
+    {
+        printf("PASS\n\n");
+        return 1;
+    }
+    else
+    {
+        printf("FAIL\n\n");
+        return 0;
+    }
+}
+
+int ut_user_force_pot_test(void)
+{
+    printf("******************************************************\n");
+    printf("uint8_t user_force_pot(uint8_t prev_force, uint8_t pot, uint8_t hyst)\n");
+
+    int test_res;
+    int pass = 1;
+
+    uint8_t prev_force;
+    uint8_t pot;
+    uint8_t hyst;
+
+    uint8_t exp_out;
+
+    prev_force = 50;
+    pot = 0;
+    hyst = 10;
+    exp_out = 0;
+    test_res = ut_user_force_pot(prev_force, pot, hyst, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 50;
+    pot = USER_FORCE_MIN_PERCENT-1;
+    hyst = 10;
+    exp_out = 0;
+    test_res = ut_user_force_pot(prev_force, pot, hyst, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 50;
+    pot = USER_FORCE_MIN_PERCENT;
+    hyst = 10;
+    exp_out = USER_FORCE_MIN_PERCENT;
+    test_res = ut_user_force_pot(prev_force, pot, hyst, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 50;
+    pot = 50;
+    hyst = 10;
+    exp_out = 50;
+    test_res = ut_user_force_pot(prev_force, pot, hyst, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 50;
+    pot = USER_FORCE_MAX_PERCENT;
+    hyst = 10;
+    exp_out = USER_FORCE_MAX_PERCENT;
+    test_res = ut_user_force_pot(prev_force, pot, hyst, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 50;
+    pot = USER_FORCE_MAX_PERCENT+1;
+    hyst = 10;
+    exp_out = 100;
+    test_res = ut_user_force_pot(prev_force, pot, hyst, exp_out);
+    if(!test_res) pass = 0;
+
+    prev_force = 50;
+    pot = 100;
+    hyst = 10;
+    exp_out = 100;
+    test_res = ut_user_force_pot(prev_force, pot, hyst, exp_out);
+    if(!test_res) pass = 0;
+
+    return pass;
+}

firmware/tests/ut_logic/ut_user_force.h

@@ -0,0 +1,10 @@
+#ifndef UT_USER_FORCE_H_
+#define UT_USER_FORCE_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int ut_user_force_btn_test(void);
+int ut_user_force_pot_test(void);
+
+#endif /* UT_USER_FORCE_H_ */