src/lib/POWERMGNT/POWERMGNT.cpp

   1 #include "targets.h"
   2 #include "logging.h"
   3 #include "POWERMGNT.h"
   4
   5 uint8_t powerToCrsfPower(PowerLevels_e Power)
   6 {
   7     // Crossfire's power levels as defined in opentx:radio/src/telemetry/crossfire.cpp
   8     //static const int32_t power_values[] = { 0, 10, 25, 100, 500, 1000, 2000, 250, 50 };
   9     switch (Power)
  10     {
  11     case PWR_10mW: return 1;
  12     case PWR_25mW: return 2;
  13     case PWR_50mW: return 8;
  14     case PWR_100mW: return 3;
  15     case PWR_250mW: return 7;
  16     case PWR_500mW: return 4;
  17     case PWR_1000mW: return 5;
  18     case PWR_2000mW: return 6;
  19     default:
  20         return 0;
  21     }
  22 }
  23
  24 PowerLevels_e crsfPowerToPower(uint8_t crsfpower)
  25 {
  26     switch (crsfpower)
  27     {
  28     case 1: return PWR_10mW;
  29     case 2: return PWR_25mW;
  30     case 3: return PWR_100mW;
  31     case 4: return PWR_500mW;
  32     case 5: return PWR_1000mW;
  33     case 6: return PWR_2000mW;
  34     case 7: return PWR_250mW;
  35     case 8: return PWR_50mW;
  36     default:
  37         return PWR_10mW;
  38     }
  39 }
  40
  41 #ifndef UNIT_TEST
  42
  43 #include "common.h"
  44 #include "device.h"
  45 #include "helpers.h"
  46
  47 /*
  48  * Moves the power management values and special cases out of the main code and into `targets.h`.
  49  *
  50  * TX Targets
  51  * ***********
  52  *
  53  * A new target now just needs to define
  54  * - `MinPower`, the minimum power level supported
  55  * - `MaxPower`, the absolute maximum power level supported
  56  * - `POWER_OUTPUT_VALUES` array of values to be used to set appropriate power level from `MinPower` to `MaxPower`
  57  *
  58  * A target can also define one of the following to configure how the output power is set, the value given to the function
  59  * is the value from the `POWER_OUTPUT_VALUES` array.
  60  *
  61  * - `POWER_OUTPUT_DAC` to use i2c DAC specify the address of the DAC in this define
  62  * - `POWER_OUTPUT_DACWRITE` to use `dacWrite` function
  63  * - `POWER_OUTPUT_ANALOG` to use `analogWrite` function
  64  * - `POWER_OUTPUT_FIXED` which will provide the value to `Radio.SetOutputPower` function
  65  * - default is to use `Radio.SetOutputPower` function
  66  *
  67  * RX Targets
  68  * **********
  69  *
  70  * Can define `POWER_OUTPUT_FIXED` which will provide the value to `Radio.SetOutputPower` function.
  71  * If nothing is defined then the default method `Radio.SetOutputPowerMax` will be used, which sets the value to
  72  * 13 on SX1280 (~12.5dBm) or 15 on SX127x (~17dBm)
  73  */
  74
  75 PowerLevels_e PowerLevelContainer::CurrentPower = PWR_COUNT; // default "undefined" initial value
  76 PowerLevels_e POWERMGNT::FanEnableThreshold = PWR_250mW;
  77 int8_t POWERMGNT::CurrentSX1280Power = 0;
  78
  79 static const int16_t *powerValues;
  80 static const int16_t *powerValuesDual;
  81
  82 static int8_t powerCaliValues[PWR_COUNT] = {0};
  83
  84 #if defined(PLATFORM_ESP32)
  85 nvs_handle POWERMGNT::handle = 0;
  86 #endif
  87
  88 PowerLevels_e POWERMGNT::incPower()
  89 {
  90     if (CurrentPower < getMaxPower())
  91     {
  92         setPower((PowerLevels_e)((uint8_t)CurrentPower + 1));
  93     }
  94     return CurrentPower;
  95 }
  96
  97 PowerLevels_e POWERMGNT::decPower()
  98 {
  99     if (CurrentPower > MinPower)
 100     {
 101         setPower((PowerLevels_e)((uint8_t)CurrentPower - 1));
 102     }
 103     return CurrentPower;
 104 }
 105
 106 void POWERMGNT::incSX1280Output()
 107 {
 108     // Power adjustment is capped to within +-3dB of the target power level to prevent power run-away
 109     if (CurrentSX1280Power < 13 && CurrentSX1280Power < powerValues[CurrentPower] + 3)
 110     {
 111         CurrentSX1280Power++;
 112         Radio.SetOutputPower(CurrentSX1280Power);
 113     }
 114 }
 115
 116 void POWERMGNT::decSX1280Output()
 117 {
 118     // Power adjustment is capped to within +-3dB of the target power level to prevent power run-away
 119     if (CurrentSX1280Power > -18 && CurrentSX1280Power > powerValues[CurrentPower] - 3)
 120     {
 121         CurrentSX1280Power--;
 122         Radio.SetOutputPower(CurrentSX1280Power);
 123     }
 124 }
 125
 126 int8_t POWERMGNT::currentSX1280Output()
 127 {
 128     return CurrentSX1280Power;
 129 }
 130
 131 uint8_t POWERMGNT::getPowerIndBm()
 132 {
 133     switch (CurrentPower)
 134     {
 135     case PWR_10mW: return 10;
 136     case PWR_25mW: return 14;
 137     case PWR_50mW: return 17;
 138     case PWR_100mW: return 20;
 139     case PWR_250mW: return 24;
 140     case PWR_500mW: return 27;
 141     case PWR_1000mW: return 30;
 142     case PWR_2000mW: return 33;
 143     default:
 144         return 0;
 145     }
 146 }
 147
 148 void POWERMGNT::SetPowerCaliValues(int8_t *values, size_t size)
 149 {
 150     bool isUpdate = false;
 151     for(size_t i=0 ; i<size ; i++)
 152     {
 153         if(powerCaliValues[i] != values[i])
 154         {
 155             powerCaliValues[i] = values[i];
 156             isUpdate = true;
 157         }
 158     }
 159 #if defined(PLATFORM_ESP32)
 160     if (isUpdate)
 161     {
 162         nvs_set_blob(handle, "powercali", &powerCaliValues, sizeof(powerCaliValues));
 163     }
 164     nvs_commit(handle);
 165 #else
 166     UNUSED(isUpdate);
 167 #endif
 168 }
 169
 170 void POWERMGNT::GetPowerCaliValues(int8_t *values, size_t size)
 171 {
 172     for(size_t i=0 ; i<size ; i++)
 173     {
 174         *(values + i) = powerCaliValues[i];
 175     }
 176 }
 177
 178 void POWERMGNT::LoadCalibration()
 179 {
 180 #if defined(PLATFORM_ESP32)
 181     // Initialize NVS
 182     esp_err_t err = nvs_flash_init();
 183     if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND)
 184     {
 185         ESP_ERROR_CHECK(nvs_flash_erase());
 186         err = nvs_flash_init();
 187     }
 188     ESP_ERROR_CHECK( err );
 189     ESP_ERROR_CHECK(nvs_open("PWRCALI", NVS_READWRITE, &handle));
 190
 191     uint32_t version;
 192     if(nvs_get_u32(handle, "calversion", &version) != ESP_ERR_NVS_NOT_FOUND
 193         && version == (uint32_t)(CALIBRATION_VERSION | CALIBRATION_MAGIC))
 194     {
 195         size_t size = sizeof(powerCaliValues);
 196         nvs_get_blob(handle, "powercali", &powerCaliValues, &size);
 197     }
 198     else
 199     {
 200         nvs_set_blob(handle, "powercali", &powerCaliValues, sizeof(powerCaliValues));
 201         nvs_set_u32(handle, "calversion", CALIBRATION_VERSION | CALIBRATION_MAGIC);
 202         nvs_commit(handle);
 203     }
 204 #else
 205     memset(powerCaliValues, 0, sizeof(powerCaliValues));
 206 #endif
 207 }
 208
 209
 210 void POWERMGNT::init()
 211 {
 212     PowerLevelContainer::CurrentPower = PWR_COUNT;
 213
 214     powerValues = POWER_OUTPUT_VALUES;
 215     if (POWER_OUTPUT_VALUES_DUAL != nullptr)
 216     {
 217         powerValuesDual = POWER_OUTPUT_VALUES_DUAL;
 218     }
 219     LoadCalibration();
 220     setDefaultPower();
 221 }
 222
 223 PowerLevels_e POWERMGNT::getDefaultPower()
 224 {
 225     if (MinPower > DefaultPower)
 226     {
 227         return MinPower;
 228     }
 229     if (getMaxPower() < DefaultPower)
 230     {
 231         return getMaxPower();
 232     }
 233     return DefaultPower;
 234 }
 235
 236 void POWERMGNT::setDefaultPower()
 237 {
 238     setPower(getDefaultPower());
 239 }
 240
 241 void POWERMGNT::setPower(PowerLevels_e Power)
 242 {
 243     Power = constrain(Power, getMinPower(), getMaxPower());
 244     if (Power == CurrentPower)
 245         return;
 246
 247     if (POWER_OUTPUT_DACWRITE)
 248     {
 249         if (POWER_OUTPUT_VALUES2 != nullptr)
 250         {
 251             Radio.SetOutputPower(POWER_OUTPUT_VALUES2[Power - MinPower]);
 252         }
 253         #if defined(PLATFORM_ESP32_S3) || defined(PLATFORM_ESP32_C3) || defined(PLATFORM_ESP8266)
 254         ERRLN("ESP32-S3/C3 and ESP8285 MCUs do not have a DAC");
 255         #else
 256         dacWrite(GPIO_PIN_RFamp_APC2, powerValues[Power - MinPower]);
 257         #endif
 258     }
 259     else
 260     {
 261         CurrentSX1280Power = powerValues[Power - MinPower] + powerCaliValues[Power];
 262         Radio.SetOutputPower(CurrentSX1280Power);
 263     }
 264
 265 #if defined(RADIO_LR1121)
 266     if (POWER_OUTPUT_VALUES_DUAL != nullptr)
 267     {
 268         Radio.SetOutputPower(powerValuesDual[Power - MinPower], false); // Set the high frequency power setting.
 269     }
 270 #endif
 271
 272     CurrentPower = Power;
 273     devicesTriggerEvent();
 274 }
 275
 276 #endif /* !UNIT_TEST */