Add power Modeling functions to all components

src/colorDetection/ColorDetection.cpp

@@ -13,28 +13,31 @@ void ColorDetection::begin(void){
 };
 void ColorDetection::configure(VEML_CONFIG config) {
   uint8_t configRegister = 0;
-    switch(config.exposureTime)
+  switch (config.exposureTime) {
-    {
   case MS40:
-            configRegister = 0x00;break;
+    configRegister = 0x00;
+    break;
   case MS80:
-            configRegister = 0x01;break;
+    configRegister = 0x01;
+    break;
   case MS160:
-            configRegister = 0x02;break;
+    configRegister = 0x02;
+    break;
   case MS320:
-            configRegister = 0x03;break;
+    configRegister = 0x03;
+    break;
   case MS640:
-            configRegister = 0x04;break;
+    configRegister = 0x04;
+    break;
   case MS1280:
-            configRegister = 0x05;break;
+    configRegister = 0x05;
+    break;
   }
   configRegister = configRegister << 4;
-    if(config.mode == MANUAL)
+  if (config.mode == MANUAL) {
-    {
     configRegister = configRegister | (0x01 << 1);
   }
-    if(!config.enabled)
+  if (!config.enabled) {
-    {
     configRegister = configRegister | 1;
   }
   ColorDetection::writeDoubleRegister(CMD_CONFIG, (uint16_t)configRegister);
@@ -42,8 +45,7 @@ void ColorDetection::configure(VEML_CONFIG config){
 
 uint16_t ColorDetection::getColorValue(color color) {
 
-    switch(color)
+  switch (color) {
-    {
   case VEML_RED:
     return readDoubleRegister(REG_RED);
     break;
@@ -89,3 +91,13 @@ void ColorDetection::writeDoubleRegister(uint8_t regAddr, uint16_t data){
     Serial.printf("Reading Register %d failed", regAddr);
   }
 };
+
+
+float ColorDetection::modelCurrentConsumption() {
+  return PowerParameters::CurrentConsumptions::CURRENT_SENSOR_RGBW;
+};
+
+float ColorDetection::modelChargeConsumption(uint16_t durationMs) {
+  return PowerParameters::CurrentConsumptions::CURRENT_SENSOR_RGBW *
+         durationMs * 10e6;
+}

src/colorDetection/ColorDetection.h

@@ -65,6 +65,27 @@ public:
     void begin(void);
     void configure(VEML_CONFIG config);
     uint16_t getColorValue(color color);
+
+    /**
+     * @brief Current consumtion of the sensor
+     * @note May not be accurate, as it is not known if the consumption is
+     * constant, or only if sensor is active. Could not be measured.
+     * 
+     * @return 
+     */
+    float modelCurrentConsumption();
+
+
+    /**
+     * @brief Estimates charge consumption of the sensor for the given duration
+     * @note May not be accurate, as it is not known if the consumption is
+     * constant, or only if sensor is active. Could not be measured.
+     *
+     * @param durationMs
+     * @return float
+     */
+    float modelChargeConsumption(uint16_t durationMs);
+
   protected:
     uint16_t readDoubleRegister(uint8_t regAddr);
     void writeDoubleRegister(uint8_t regAddr, uint16_t data);

src/display/Display.cpp

@@ -179,3 +179,11 @@ void Display::invertColor(void){
     }
     this->colorInverted = !this->colorInverted;
 };
+
+float modelCurrentConsumption() {
+    return PowerParameters::CurrentConsumptions::CURRENT_DISPLAY;
+};
+
+float modelChargeConsumptionOn(uint16_t durationMs) {
+    return PowerParameters::CurrentConsumptions::CURRENT_DISPLAY * durationMs * 10e6;
+};

src/display/Display.h

@@ -127,6 +127,19 @@ class Display{
          * 
          */
         void invertColor(void);
+
+        /**
+         * @brief Estimate the current consumption of the display
+         * @return consumed current in milliamperes
+         */
+        float modelCurrentConsumption();
+
+        /**
+         * @brief Estimate the energy consumption of the display
+         * @param durationMs time the display will be on
+         * @return consumed energy in coloumbs
+         */
+        float modelChargeConsumptionOn(uint16_t durationMs);
 };
 
 

src/infraredLight/InfraredLED.cpp

@@ -4,6 +4,7 @@
 #define IR_FRONT_PIN 14
 #define IR_BOTTOM_PIN 13
 #define DUTY_RESOLUTION LEDC_TIMER_10_BIT
+#define DUTY_CYCLE_FREQUENCY 512
 
 InfraredLED::InfraredLED(uint8_t pin,ledc_timer_t timer, ledc_channel_t channel){
     this->ledPin = pin;
@@ -78,27 +79,53 @@ void InfraredLED::setState(bool state){
 };
 
 void InfraredLED::sendFrequency(uint16_t frequency){
-  constexpr uint32_t duty = 512;
+  constexpr uint32_t duty = DUTY_CYCLE_FREQUENCY;
   // Float to force float division without casting
   constexpr float resolution = 1 << DUTY_RESOLUTION;
   if (this->ledPin == IR_BOTTOM_PIN) {
-    float currentConsumption =
-        (duty / resolution) *
-        PowerParameters::CurrentConsumptions::CURRENT_LED_IR_BOTTOM;
     Power::waitForCurrentAllowance(
         PowerParameters::PowerConsumers::LED_IR_BOTTOM,
-        currentConsumption,
+        this->modelCurrentConsumption(duty), IR_LED_MAX_EXECUTION_DELAY_MS,
-        IR_LED_MAX_EXECUTION_DELAY_MS, NULL);
+        NULL);
   } else if (this->ledPin == IR_FRONT_PIN) {
-    float currentConsumption =
-        (duty / resolution) *
-        PowerParameters::CurrentConsumptions::CURRENT_LED_IR_FRONT;
     Power::waitForCurrentAllowance(
         PowerParameters::PowerConsumers::LED_IR_FRONT,
-        currentConsumption,
+        this->modelCurrentConsumption(duty), IR_LED_MAX_EXECUTION_DELAY_MS,
-        IR_LED_MAX_EXECUTION_DELAY_MS, NULL);
+        NULL);
   }
     ledc_set_freq(pwmSpeedMode,timer,frequency);
     ledc_set_duty(pwmSpeedMode,channel,duty);
     ledc_update_duty(pwmSpeedMode,channel);
 };
+
+float InfraredLED::modelCurrentConsumption(uint32_t duty){
+    // Float to force float division without casting
+    constexpr float max_value = 1 << DUTY_RESOLUTION;
+    const float duty_factor = duty / max_value;
+    if (this->ledPin == IR_BOTTOM_PIN) {
+        return duty_factor * PowerParameters::CurrentConsumptions::CURRENT_LED_IR_BOTTOM;
+    } else if (this->ledPin == IR_FRONT_PIN) {
+        return duty_factor * PowerParameters::CurrentConsumptions::CURRENT_LED_IR_FRONT;
+    }
+    return NAN;
+};
+
+float InfraredLED::modelChargeConsumptionOn(uint16_t durationMs) {
+  // Float to force float division without casting
+  constexpr float resolution = 1 << DUTY_RESOLUTION;
+  if (this->ledPin == IR_BOTTOM_PIN) {
+    return durationMs *
+           PowerParameters::CurrentConsumptions::CURRENT_LED_IR_BOTTOM * 10e6;
+  } else if (this->ledPin == IR_FRONT_PIN) {
+    return durationMs *
+           PowerParameters::CurrentConsumptions::CURRENT_LED_IR_FRONT *  10e6;
+  }
+  return NAN;
+}
+
+float InfraredLED::modelChargeConsumptionSendFrequency(uint16_t durationMs) {
+  // Float to force float division without casting
+
+  return durationMs * this->modelCurrentConsumption(DUTY_CYCLE_FREQUENCY) *
+         10e6;
+}

src/infraredLight/InfraredLight.h

@@ -48,6 +48,31 @@ class InfraredLED{
          * @param frequency 
          */
         void sendFrequency(uint16_t frequency);
+
+        /**
+         * @brief Estimate the current consumption of setting the specified led to the
+         * passed duty cycle
+         * @param duty the duty cycle of the led
+         * @return consumed current in milliamperes
+         */
+        float modelCurrentConsumption(uint32_t duty);
+
+        /**
+         * @brief Estimate the energy consumption of turning the infrared led on
+         * @param durationMs time the led will be on
+         * @return consumed energy in coloumbs
+         */
+        float modelChargeConsumptionOn(uint16_t durationMs);
+
+        /**
+         * @brief Estimate the energy consumption of sending a frequency on the
+         * infrared led
+         * @param durationMs time the led will be on
+         * @param frequency the frequency the led will be flashing
+         * @return consumed energy in coloumbs
+         */
+        float modelChargeConsumptionSendFrequency(uint16_t durationMs);
+
       protected:
         uint8_t ledPin;
         ledc_timer_t timer;

src/lightDetection/LightDetection.h

@@ -78,6 +78,22 @@ public:
      * @return the average of all taken meaurments
      */
     static uint32_t getAverageValue(photoTransistors sensor, uint32_t measurments, uint32_t timeBetween);
+
+    /**
+     * @brief Get current consumption of the selected PTs
+     *
+     * @return float the current consumption of the PTs
+     */
+    static float modelCurrentConsumption(void);
+
+    /**
+     * @brief Estimate the energy consumption of setting the specified led to
+     * the passed color
+     * @param durationMs time the led will be on
+     * @return consumed energy in coloumbs
+     */
+    float modelChargeConsumptionOn(uint16_t durationMs);
+
   protected: 
     static const uint8_t IR_PT_FRONT_ADC = 3;
     static const uint8_t IR_PT_LEFT_ADC = 4;

src/motion/Motion.h

@@ -56,6 +56,24 @@ class Motor{
          * @return current speedvalue of the motor
          */
         uint16_t getSpeed(void); 
+
+        /**
+         * @brief Get the current consumption of the motor at specified speed
+         * 
+         * @param duty the duty cyle that should be considered, can be between 0-8192
+         *
+         * @return current consumption in milliamperes
+         */
+        float modelCurrentConsumption(uint16_t duty);
+
+        /**
+         * @brief Estimate the energy consumption of the display
+         * @param durationMs time the display will be on
+         * @return consumed energy in coloumbs
+         */
+        float modelChargeConsumptionOn(uint16_t duty, uint16_t durationMs);
+
+
     protected:
         uint8_t pin;
         ledc_timer_t timer;

src/motion/Motor.cpp

@@ -25,9 +25,7 @@ void Motor::begin(void) {
 };
 
 bool Motor::setSpeed(uint16_t duty) {
-  const float dutyFactor = duty / static_cast<float>(1 << DUTY_RES);
+  const float current = this->modelCurrentConsumption(duty);
-  const float current =
-      PowerParameters::CurrentConsumptions::CURRENT_MOTOR_T_ON * dutyFactor;
   if (this->pin == MOTOR_LEFT_PIN) {
     if (!Power::waitForCurrentAllowance(
             PowerParameters::PowerConsumers::MOTOR_LEFT, current,
@@ -69,3 +67,12 @@ bool Motor::setSpeed(uint16_t duty) {
 };
 
 uint16_t Motor::getSpeed(void) { return this->duty; };
+
+float modelCurrentConsumption(uint16_t duty) {
+  const float dutyFactor = duty / static_cast<float>(1 << DUTY_RES);
+  return PowerParameters::CurrentConsumptions::CURRENT_MOTOR_T_ON * dutyFactor;
+}
+
+float modelChargeConsumptionOn(uint16_t duty, uint16_t durationMs) {
+  return modelCurrentConsumption(duty) * durationMs * 10e6;
+}

src/motionDetection/MotionDetection.cpp

@@ -294,3 +294,12 @@ void MotionDetection::writeRegister(uint8_t reg, uint8_t value){
     delayMicroseconds(10);
     handler->endTransaction();
 };
+
+float MotionDetection::modelCurrentConsumption(){
+    return PowerParameters::CurrentConsumptions::CURRENT_IMU;
+}
+
+
+float MotionDetection::modelChargeConsumption(uint16_t durationMs){
+    return this->modelCurrentConsumption() * durationMs * 10e6;
+}

src/motionDetection/MotionDetection.h

@@ -187,5 +187,21 @@ public:
      * @return the amount of acutally fetched packages 
     */
     uint getDataFromFIFO(FIFO_Package* buffer);
+
+    /**
+     * @brief Current consumtion of the sensor
+     * 
+     * @return 
+     */
+     float modelCurrentConsumption();
+
+
+     /**
+      * @brief Estimates charge consumption of the sensor for the given duration
+      *
+      * @param durationMs
+      * @return float
+      */
+     float modelChargeConsumption(uint16_t durationMs);
 };
 #endif //MotionDetection

src/multiColorLight/MultiColorLight.cpp

@@ -1,13 +1,23 @@
 #include "MultiColorLight.h"
 
-MultiColorLight::MultiColorLight():rgbLeds(ledAmount,ledPin){
+MultiColorLight::MultiColorLight()
+    : rgbLeds(ledAmount, ledPin) {
 
       };
 
 void MultiColorLight::begin(void) {
-    if(!Power::waitForCurrentAllowance(PowerParameters::PowerConsumers::LED_RGB_TOP_LEFT, PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_BASE, MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL) &&
+  if (!Power::waitForCurrentAllowance(
-    Power::waitForCurrentAllowance(PowerParameters::PowerConsumers::LED_RGB_TOP_RIGHT, PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_BASE, MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL) &&
+          PowerParameters::PowerConsumers::LED_RGB_TOP_LEFT,
-    Power::waitForCurrentAllowance(PowerParameters::PowerConsumers::LED_RGB_BOTTOM, PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_BASE, MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL) ){
+          PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_BASE,
+          MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL) &&
+      Power::waitForCurrentAllowance(
+          PowerParameters::PowerConsumers::LED_RGB_TOP_RIGHT,
+          PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_BASE,
+          MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL) &&
+      Power::waitForCurrentAllowance(
+          PowerParameters::PowerConsumers::LED_RGB_BOTTOM,
+          PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_BASE,
+          MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL)) {
     ESP_LOGE(TAG, "Could not get power for MultiColorLight");
     Serial.println("Could not get power for MultiColorLight");
   }
@@ -15,35 +25,43 @@ void MultiColorLight::begin(void){
   this->turnOffLed();
 };
 
-
 void MultiColorLight::setLed(uint8_t index, uint32_t color) {
   if (index > ledAmount - 1) {
     // TODO: logging
   }
   uint32_t normalizedColor = normalizeColor(color);
-    uint16_t colorComponentRed = (normalizedColor & 0x00FF0000) >> 16;
+  float totalConsumption = modelCurrentConsumption(normalizedColor);
-    uint16_t colorComponentGreen = (normalizedColor & 0x0000FF00) >> 8;
-    uint16_t colorComponentBlue = (normalizedColor & 0x000000FF);
-    float redChannelConsumption = (colorComponentRed/255.0) * PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_CHAN_T_ON;
-    float greenChannelConsumption = (colorComponentGreen/255.0) * PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_CHAN_T_ON;
-    float blueChannelConsumption = (colorComponentBlue/255.0) * PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_CHAN_T_ON;
-    float totalConsumption = redChannelConsumption + greenChannelConsumption + blueChannelConsumption + PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_BASE;
   switch (index) {
   case 0:
-            if(!Power::waitForCurrentAllowance(PowerParameters::PowerConsumers::LED_RGB_TOP_RIGHT, totalConsumption, MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL)){
+    if (!Power::waitForCurrentAllowance(
-                ESP_LOGW(TAG,  "Power to set LED RGB TOP RIGHT to color %d not granted in time. Skipping.", color);
+            PowerParameters::PowerConsumers::LED_RGB_TOP_RIGHT,
+            totalConsumption, MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL)) {
+      ESP_LOGW(TAG,
+               "Power to set LED RGB TOP RIGHT to color 0x%.8X not granted in "
+               "time. Skipping.",
+               normalizedColor);
       return;
     }
     break;
   case 1:
-            if(!Power::waitForCurrentAllowance(PowerParameters::PowerConsumers::LED_RGB_TOP_LEFT, totalConsumption, MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL)){
+    if (!Power::waitForCurrentAllowance(
-                ESP_LOGW(TAG,  "Power to set LED RGB TOP LEFT to color %d not granted in time. Skipping.", color);
+            PowerParameters::PowerConsumers::LED_RGB_TOP_LEFT, totalConsumption,
+            MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL)) {
+      ESP_LOGW(TAG,
+               "Power to set LED RGB TOP LEFT to color 0x%.8X not granted in "
+               "time. Skipping.",
+               normalizedColor);
       return;
     }
     break;
   case 2:
-            if(!Power::waitForCurrentAllowance(PowerParameters::PowerConsumers::LED_RGB_BOTTOM, totalConsumption, MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL)){
+    if (!Power::waitForCurrentAllowance(
-                ESP_LOGW(TAG,  "Power to set LED RGB BOTTOM to color %d not granted in time. Skipping.", color);
+            PowerParameters::PowerConsumers::LED_RGB_BOTTOM, totalConsumption,
+            MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS, NULL)) {
+      ESP_LOGW(TAG,
+               "Power to set LED RGB BOTTOM to color 0x%.8X not granted in "
+               "time. Skipping.",
+               normalizedColor);
       return;
     }
     break;
@@ -52,35 +70,38 @@ void MultiColorLight::setLed(uint8_t index , uint32_t color){
   rgbLeds.show();
 };
 
-
 void MultiColorLight::setLed(leds leds, uint32_t color) {
   switch (leds) {
   case TOP_LEFT:
-            MultiColorLight::setLed(1,color);break;
+    MultiColorLight::setLed(1, color);
+    break;
   case TOP_RIGHT:
-            MultiColorLight::setLed(0,color);break;
+    MultiColorLight::setLed(0, color);
+    break;
   case BOTTOM:
-            MultiColorLight::setLed(2,color);break;
+    MultiColorLight::setLed(2, color);
+    break;
   case TOP:
     for (int index = 0; index < 2; index++) {
       MultiColorLight::setLed(index, color);
-            }break;
+    }
+    break;
   case ALL:
     for (int index = 0; index < ledAmount; index++) {
       MultiColorLight::setLed(index, color);
-            }break;
+    }
+    break;
   default:
     // TODO logging
     break;
   }
-
 };
 
-void MultiColorLight::setLed(leds leds, uint8_t red, uint8_t green, uint8_t blue){
+void MultiColorLight::setLed(leds leds, uint8_t red, uint8_t green,
+                             uint8_t blue) {
   MultiColorLight::setLed(leds, MultiColorLight::color(red, green, blue));
 };
 
-
 void MultiColorLight::setTopLeds(uint32_t color) {
   MultiColorLight::setLed(TOP, color);
 };
@@ -89,7 +110,8 @@ void MultiColorLight::setTopLeds(uint8_t red, uint8_t green, uint8_t blue){
   MultiColorLight::setTopLeds(MultiColorLight::color(red, green, blue));
 };
 
-void MultiColorLight::blink(uint16_t amount,uint32_t color, leds leds, uint32_t interval){
+void MultiColorLight::blink(uint16_t amount, uint32_t color, leds leds,
+                            uint32_t interval) {
   for (uint16_t index = 0; index < amount; index++) {
     MultiColorLight::setLed(leds, color);
     vTaskDelay(interval);
@@ -101,19 +123,24 @@ void MultiColorLight::blink(uint16_t amount,uint32_t color, leds leds, uint32_t
 void MultiColorLight::turnOffLed(leds leds) {
   switch (leds) {
   case TOP_LEFT:
-            MultiColorLight::setLed(1,0);break;
+    MultiColorLight::setLed(1, 0);
+    break;
   case TOP_RIGHT:
-            MultiColorLight::setLed(0,0);break;
+    MultiColorLight::setLed(0, 0);
+    break;
   case BOTTOM:
-            MultiColorLight::setLed(2,0);break;
+    MultiColorLight::setLed(2, 0);
+    break;
   case TOP:
     for (int index = 0; index < 2; index++) {
       MultiColorLight::setLed(index, 0);
-            }break;
+    }
+    break;
   case ALL:
     for (int index = 0; index < 3; index++) {
       MultiColorLight::setLed(index, 0);
-            }break;
+    }
+    break;
   default:
     // TODO logging
     break;
@@ -125,7 +152,8 @@ uint32_t MultiColorLight::color(uint8_t r, uint8_t g, uint8_t b){
 };
 
 // PRIVATE
-uint32_t MultiColorLight::normalizeColor(uint32_t color,uint8_t maxBrightness){
+uint32_t MultiColorLight::normalizeColor(uint32_t color,
+                                         uint8_t maxBrightness) {
   uint8_t red = (color & 0x00FF0000) >> 16;
   uint8_t green = (color & 0x0000FF00) >> 8;
   uint8_t blue = (color & 0x000000FF);
@@ -139,4 +167,79 @@ uint32_t MultiColorLight::normalizeColor(uint32_t color,uint8_t maxBrightness){
     blue = maxBrightness - 50;
   }
   return MultiColorLight::color(red, green, blue);
+};
+
+float MultiColorLight::modelCurrentConsumption(uint32_t color) {
+  uint32_t normalizedColor = normalizeColor(color);
+  uint16_t colorComponentRed = (normalizedColor & 0x00FF0000) >> 16;
+  uint16_t colorComponentGreen = (normalizedColor & 0x0000FF00) >> 8;
+  uint16_t colorComponentBlue = (normalizedColor & 0x000000FF);
+  float redChannelConsumption =
+      (colorComponentRed / 255.0) *
+      PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_CHAN_T_ON;
+  float greenChannelConsumption =
+      (colorComponentGreen / 255.0) *
+      PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_CHAN_T_ON;
+  float blueChannelConsumption =
+      (colorComponentBlue / 255.0) *
+      PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_CHAN_T_ON;
+  return redChannelConsumption + greenChannelConsumption +
+         blueChannelConsumption +
+         PowerParameters::CurrentConsumptions::CURRENT_LED_RGB_BASE;
+};
+
+float MultiColorLight::modelCurrentConsumption(uint8_t red, uint8_t green,
+                                               uint8_t blue) {
+  return modelCurrentConsumption(MultiColorLight::color(red, green, blue));
+};
+
+float MultiColorLight::modelChargeConsumption(uint8_t index, uint32_t color,
+                                                 uint16_t durationMs) {
+  if (index > ledAmount - 1) {
+    // TODO: logging
   }
+  uint32_t normalizedColor = normalizeColor(color);
+  float ledConsumption = modelCurrentConsumption(normalizedColor);
+  return ledConsumption * durationMs * 10e6;
+};
+
+float MultiColorLight::modelChargeConsumption(leds leds, uint32_t color,
+                                                 uint16_t durationMs) {
+  float ledsConsumption = 0;
+  switch (leds) {
+  case TOP_LEFT:
+    ledsConsumption =
+        MultiColorLight::modelChargeConsumption(1, color, durationMs);
+    break;
+  case TOP_RIGHT:
+    ledsConsumption =
+        MultiColorLight::modelChargeConsumption(0, color, durationMs);
+    break;
+  case BOTTOM:
+    ledsConsumption =
+        MultiColorLight::modelChargeConsumption(2, color, durationMs);
+    break;
+  case TOP:
+    for (int index = 0; index < 2; index++) {
+      ledsConsumption +=
+          MultiColorLight::modelChargeConsumption(index, color, durationMs);
+    }
+    break;
+  case ALL:
+    for (int index = 0; index < ledAmount; index++) {
+      ledsConsumption +=
+          MultiColorLight::modelChargeConsumption(index, color, durationMs);
+    }
+    break;
+  default:
+    // TODO logging
+    break;
+  }
+};
+
+float MultiColorLight::modelChargeConsumption(leds leds, uint8_t red,
+                                                 uint8_t green, uint8_t blue,
+                                                 uint16_t durationMs) {
+  return MultiColorLight::modelChargeConsumption(
+      leds, MultiColorLight::color(red, green, blue), durationMs);
+};

src/multiColorLight/MultiColorLight.h

@@ -1,7 +1,8 @@
 /**
  * @file MultiColorLight.h
  * @author Saskia Duebener, Hans Haupt
- * @brief This component controls the ability to show multicolored light, using the RGB-LEDs
+ * @brief This component controls the ability to show multicolored light, using
+ * the RGB-LEDs
  * @version 0.2
  * @date 2023-11-25
  *
@@ -10,24 +11,19 @@
  */
 #ifndef MultiColorLight_h
 #define MultiColorLight_h
-#include <Adafruit_NeoPixel.h>
-#include "ColorConstants.h"
 #include "../power/Power.h"
+#include "ColorConstants.h"
+#include <Adafruit_NeoPixel.h>
 
 #define MULTI_COLOR_LIGHT_MAX_EXECUTION_DELAY_MS 20
 
 /**
  * @brief Describes combinations of leds on the Dezibot.
- * With the Robot in Front of you, when the robot drives away from you, the left LED is TOP_LEFT 
+ * With the Robot in Front of you, when the robot drives away from you, the left
+ * LED is TOP_LEFT
  *
  */
-enum leds{
+enum leds { TOP_LEFT, TOP_RIGHT, BOTTOM, TOP, ALL };
-    TOP_LEFT,
-    TOP_RIGHT,
-    BOTTOM,
-    TOP,
-    ALL
-};
 
 #define TAG "MultiColorLight"
 
@@ -38,8 +34,8 @@ protected:
   static const uint8_t maxBrightness = 150;
   Adafruit_NeoPixel rgbLeds;
   static constexpr int maximumExecutionDelayMs = 10;
-public:
 
+public:
   MultiColorLight();
   /**
    * @brief initialize the multicolor component
@@ -52,7 +48,8 @@ public:
    * @param index ranging from 0-2, 0: Right, 1: Left, 2: Bottom
    * @param color A 32-bit unsigned integer representing the color in the format
    *               0x00RRGGBB, where RR is the red component, GG is the green
-    *               component, and BB is the blue component. Each color can range between 0 to 100
+   *               component, and BB is the blue component. Each color can range
+   * between 0 to 100
    */
   void setLed(uint8_t index, uint32_t color);
 
@@ -62,7 +59,8 @@ public:
    * @param leds which leds should be updated
    * @param color A 32-bit unsigned integer representing the color in the format
    *               0x00RRGGBB, where RR is the red component, GG is the green
-    *               component, and BB is the blue component. Each color can range between 0 to 100
+   *               component, and BB is the blue component. Each color can range
+   * between 0 to 100
    */
   void setLed(leds leds, uint32_t color);
 
@@ -76,12 +74,74 @@ public:
    */
   void setLed(leds leds, uint8_t red, uint8_t green, uint8_t blue);
 
+  /**
+   * @brief calculates the current consumption of an LED with the given color
+   *
+   * @param color A 32-bit unsigned integer representing the color in the
+   * format 0x00RRGGBB, where RR is the red component, GG is the green
+   *               component, and BB is the blue component.
+   * @return float the current consumption in mA
+   */
+  float modelCurrentConsumption(uint32_t color);
+
+  /**
+   * @brief calculates the current consumption of an LED with the given color
+   * @note color is not normalized in this function
+   *
+   * @param red brightness of red
+   * @param green brightness of green
+   * @param blue brightness of blue
+   * @return float the current consumption in mA
+   */
+  float modelCurrentConsumption(uint8_t red, uint8_t green, uint8_t blue);
+
+  /**
+   * @brief Estimate the energy consumption of setting the specified led to the
+   * passed color
+   * @param index ranging from 0-2, 0: Right, 1: Left, 2: Bottom
+   * @param color A 32-bit unsigned integer representing the color in the
+   * format 0x00RRGGBB, where RR is the red component, GG is the green
+   *               component, and BB is the blue component. Each color can
+   * range between 0 to 100
+   * @return consumed energy in coloumbs
+   */
+  float modelChargeConsumption(uint8_t index, uint32_t color,
+                                  uint16_t durationMs);
+
+  /**
+   * @brief Estimate the energy consumption of setting the specified leds to the
+   * passed color value
+   *
+   * @param leds which leds should be considered
+   * @param color A 32-bit unsigned integer representing the color in the
+   * format 0x00RRGGBB, where RR is the red component, GG is the green
+   *               component, and BB is the blue component. Each color can
+   * range between 0 to 100
+   * @return consumed energy in coloumbs
+   */
+  float modelChargeConsumption(leds leds, uint32_t color,
+                                  uint16_t durationMs);
+
+  /**
+   * @brief Estimate the energy consumption of setting the specified leds to the
+   * passed color value
+   *
+   * @param leds which leds should be considered
+   * @param red brightness of red, is normalized in the function
+   * @param green brightness of green, is normalized in the function
+   * @param blue brightness of blue, is normalized in the function
+   * @return consumed energy in coloumbs
+   */
+  float modelChargeConsumption(leds leds, uint8_t red, uint8_t green,
+                                  uint8_t blue, uint16_t durationMs);
+
   /**
    * @brief sets the two leds on the top of the robot to the specified color
    *
    * @param color A 32-bit unsigned integer representing the color in the format
    *               0x00RRGGBB, where RR is the red component, GG is the green
-    *               component, and BB is the blue component. Each color can range between 0 to 100
+   *               component, and BB is the blue component. Each color can range
+   * between 0 to 100
    */
   void setTopLeds(uint32_t color);
 
@@ -106,7 +166,8 @@ public:
    * @param leds which LEDs should blink, default is TOP
    * @param interval how many miliseconds the led is on, defaults to 1s
    */
-    void blink(uint16_t amount,uint32_t color = 0x00006400,leds leds=TOP, uint32_t interval=1000);
+  void blink(uint16_t amount, uint32_t color = 0x00006400, leds leds = TOP,
+             uint32_t interval = 1000);
 
   /**
    * @brief turn off the given leds
@@ -134,13 +195,15 @@ private:
    * @param color A 32-bit unsigned integer representing the color in the format
    *               0x00RRGGBB, where RR is the red component, GG is the green
    *               component, and BB is the blue component.
-    * @param maxBrigthness maximal level of brightness that is allowed for each color
+   * @param maxBrigthness maximal level of brightness that is allowed for each
-    * @return uint32_t A 32-bit unsigned integer representing the color in the format
+   * color
-        *               0x00RRGGBB, where RR is the red component, GG is the green
+   * @return uint32_t A 32-bit unsigned integer representing the color in the
-        *               component, and BB is the blue component. Where each component can be
+   * format 0x00RRGGBB, where RR is the red component, GG is the green
-        *               between 0 - maxBrightness
+   *               component, and BB is the blue component. Where each component
+   * can be between 0 - maxBrightness
    */
-    uint32_t normalizeColor(uint32_t color, uint8_t maxBrigthness=maxBrightness);
+  uint32_t normalizeColor(uint32_t color,
+                          uint8_t maxBrigthness = maxBrightness);
 };
 
 #endif // MultiColorLight_h