set the correct adc settings

add the current calculation
change the name of get_uv_voltage to get_uv_current
return the Uint16 uv_current_ma in the GetHepaUVState response message

hepa-uv/firmware/uv_control_task/uv_control_hardware.cpp

@@ -4,6 +4,6 @@
 
 using namespace uv_control_hardware;
 
-auto UVControlHardware::get_uv_light_voltage() -> uint32_t {
-    return get_uv_light_voltage_reading();
+auto UVControlHardware::get_uv_light_current() -> uint16_t {
+    return get_uv_current_reading();
 }

hepa-uv/firmware/uv_hardware.c

@@ -64,8 +64,8 @@ static void MX_ADC_Init(ADC_TypeDef* adc, uint32_t channel) {
     // Configure Regular Channel
     hadc_sConfig->Channel = channel;
     hadc_sConfig->Rank = ADC_REGULAR_RANK_1;
-    hadc_sConfig->SamplingTime = ADC_SAMPLETIME_2CYCLES_5;
-    hadc_sConfig->SingleDiff = ADC_DIFFERENTIAL_ENDED;
+    hadc_sConfig->SamplingTime = ADC_SAMPLETIME_12CYCLES_5;
+    hadc_sConfig->SingleDiff = ADC_SINGLE_ENDED;
     hadc_sConfig->OffsetNumber = ADC_OFFSET_NONE;
     hadc_sConfig->Offset = 0;
     if (HAL_ADC_ConfigChannel(hadc, hadc_sConfig) != HAL_OK)
@@ -75,15 +75,20 @@ static void MX_ADC_Init(ADC_TypeDef* adc, uint32_t channel) {
 }
 
 uint32_t get_adc_reading(ADC_HandleTypeDef* hadc, uint32_t channel) {
-    // Calibrate the ADC to get more accurate reading
-    if (HAL_ADCEx_Calibration_Start(hadc, ADC_DIFFERENTIAL_ENDED) != HAL_OK) Error_Handler();
+    ADC_ChannelConfTypeDef* hadc_sConfig;
+    if (hadc->Instance == ADC1) {
+        hadc_sConfig = &hadc1_sConfig;
+    } else {
+        Error_Handler();
+        return 0;
+    }
+
+    // Calibrate the ADC to get a more accurate reading
+    if (HAL_ADCEx_Calibration_Start(hadc, ADC_SINGLE_ENDED) != HAL_OK) Error_Handler();
 
     // Configure the Channel
-    ADC_ChannelConfTypeDef sConfig = {0};
-    sConfig.Channel = channel;
-    sConfig.Rank = ADC_REGULAR_RANK_1;
-    sConfig.SamplingTime = ADC_SAMPLETIME_6CYCLES_5;
-    if (HAL_ADC_ConfigChannel(hadc, &sConfig) != HAL_OK) Error_Handler();
+    hadc_sConfig->Channel = channel;
+    if (HAL_ADC_ConfigChannel(hadc, hadc_sConfig) != HAL_OK) Error_Handler();
 
     // Start The adc
     if (HAL_ADC_Start(hadc) != HAL_OK) Error_Handler();
@@ -94,10 +99,13 @@ uint32_t get_adc_reading(ADC_HandleTypeDef* hadc, uint32_t channel) {
     return HAL_ADC_GetValue(hadc);
 }
 
-uint32_t get_uv_light_voltage_reading(void) {
+uint16_t get_uv_current_reading(void) {
     uint32_t adc_reading = get_adc_reading(&hadc1, ADC_CHANNEL_1);
-    // mvolts = (ADC Reading * System mV) / 12-bit adc resolution
-    return (uint32_t)(adc_reading*3300)/4095;;
+    /*
+    We calculate the current in mA the uv ballast is drawing as followed
+    current mA = (ADC Reading * System mV) / 12-bit adc resolution / 50 Op-amp gain / 0.025 Rsns
+    */
+    return (uint16_t)((adc_reading*3300)/4095)/50/0.025;
 }
 
 void initialize_adc_hardware() {

include/can/core/messages.hpp

@@ -1709,15 +1709,15 @@ struct GetHepaUVStateResponse
     uint32_t timeout_s;
     uint8_t uv_light_on;
     uint32_t remaining_time_s;
-    uint32_t uv_voltage_mv;
+    uint16_t uv_current_ma;
 
     template <bit_utils::ByteIterator Output, typename Limit>
     auto serialize(Output body, Limit limit) const -> uint8_t {
         auto iter = bit_utils::int_to_bytes(message_index, body, limit);
         iter = bit_utils::int_to_bytes(timeout_s, iter, limit);
         iter = bit_utils::int_to_bytes(uv_light_on, iter, limit);
         iter = bit_utils::int_to_bytes(remaining_time_s, iter, limit);
-        iter = bit_utils::int_to_bytes(uv_voltage_mv, iter, limit);
+        iter = bit_utils::int_to_bytes(uv_current_ma, iter, limit);
         return iter - body;
     }
 

include/hepa-uv/core/interfaces.hpp

@@ -46,6 +46,6 @@ class UVControlInterface {
     auto operator=(const UVControlInterface&) -> UVControlInterface& = delete;
     virtual ~UVControlInterface() = default;
 
-    virtual auto get_uv_light_voltage() -> uint32_t = 0;
+    virtual auto get_uv_light_current() -> uint16_t = 0;
 };
 }  // namespace uv_control

include/hepa-uv/core/uv_task.hpp

@@ -89,12 +89,13 @@ class UVMessageHandler {
     }
 
     void visit(const can::messages::GetHepaUVStateRequest &m) {
+        uv_current_ma = uv_hardware.get_uv_light_current();
         auto resp = can::messages::GetHepaUVStateResponse{
             .message_index = m.message_index,
             .timeout_s = uv_off_timeout_s,
             .uv_light_on = uv_light_on,
             .remaining_time_s = (_timer.get_remaining_time() / 1000),
-            .uv_voltage_mv = uv_voltage_mv};
+            .uv_current_ma = uv_current_ma};
         can_client.send_can_message(can::ids::NodeId::host, resp);
     }
 
@@ -125,7 +126,7 @@ class UVMessageHandler {
             }
             uv_push_button = false;
             uv_light_on = false;
-            uv_voltage_mv = 0;
+            uv_current_ma = 0;
             return;
         }
 
@@ -153,7 +154,7 @@ class UVMessageHandler {
         }
 
         // Update the voltage usage of the uv light
-        uv_voltage_mv = uv_hardware.get_uv_light_voltage();
+        uv_current_ma = uv_hardware.get_uv_light_current();
 
         // TODO: send state change CAN message to host
     }
@@ -164,7 +165,7 @@ class UVMessageHandler {
     bool uv_push_button = false;
     bool uv_light_on = false;
     uint32_t uv_off_timeout_s = DELAY_S;
-    uint32_t uv_voltage_mv = 0;
+    uint16_t uv_current_ma = 0;
 
     gpio_drive_hardware::GpioDrivePins &drive_pins;
     uv_control_hardware::UVControlHardware &uv_hardware;

include/hepa-uv/firmware/uv_control_hardware.hpp

@@ -17,7 +17,7 @@ class UVControlHardware : public uv_control::UVControlInterface {
     // lets migrate gpio.set/reset to it, so we can de-couple hardware
     // specific functionality from logic so we can fix simulation.
 
-    auto get_uv_light_voltage() -> uint32_t final;
+    auto get_uv_light_current() -> uint16_t final;
 };
 
 }  // namespace uv_control_hardware

include/hepa-uv/firmware/uv_hardware.h

@@ -6,7 +6,7 @@
 extern "C" {
 #endif  // __cplusplus
 
-uint32_t get_uv_light_voltage_reading(void);
+uint16_t get_uv_current_reading(void);
 
 #ifdef __cplusplus
 }  // extern "C"