src/main/osd/osd_warnings.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <ctype.h>
  26 #include <math.h>
  27
  28 #include "platform.h"
  29
  30 #ifdef USE_OSD
  31
  32 #include "config/config.h"
  33 #include "config/feature.h"
  34
  35 #include "common/maths.h"
  36 #include "common/printf.h"
  37
  38 #include "drivers/display.h"
  39 #include "drivers/osd_symbols.h"
  40 #include "drivers/time.h"
  41 #include "drivers/dshot.h"
  42
  43 #include "fc/core.h"
  44 #include "fc/rc.h"
  45 #include "fc/rc_modes.h"
  46 #include "fc/runtime_config.h"
  47
  48 #include "flight/failsafe.h"
  49 #include "flight/gps_rescue.h"
  50 #include "flight/imu.h"
  51 #include "flight/mixer.h"
  52 #include "flight/pid.h"
  53
  54 #include "io/beeper.h"
  55
  56 #include "osd/osd.h"
  57 #include "osd/osd_elements.h"
  58 #include "osd/osd_warnings.h"
  59
  60 #include "rx/rx.h"
  61
  62 #include "sensors/acceleration.h"
  63 #include "sensors/adcinternal.h"
  64 #include "sensors/battery.h"
  65 #include "sensors/sensors.h"
  66
  67 const char CRASH_FLIP_WARNING[] = "> CRASH FLIP <";
  68
  69 void renderOsdWarning(char *warningText, bool *blinking, uint8_t *displayAttr)
  70 {
  71     const batteryState_e batteryState = getBatteryState();
  72     const timeUs_t currentTimeUs = micros();
  73
  74     static timeUs_t armingDisabledUpdateTimeUs;
  75     static unsigned armingDisabledDisplayIndex;
  76
  77     warningText[0] = '\0';
  78     *displayAttr = DISPLAYPORT_ATTR_NONE;
  79     *blinking = false;
  80
  81     // Cycle through the arming disabled reasons
  82     if (osdWarnGetState(OSD_WARNING_ARMING_DISABLE)) {
  83         if (IS_RC_MODE_ACTIVE(BOXARM) && isArmingDisabled()) {
  84             const armingDisableFlags_e armSwitchOnlyFlag = 1 << (ARMING_DISABLE_FLAGS_COUNT - 1);
  85             armingDisableFlags_e flags = getArmingDisableFlags();
  86
  87             // Remove the ARMSWITCH flag unless it's the only one
  88             if ((flags & armSwitchOnlyFlag) && (flags != armSwitchOnlyFlag)) {
  89                 flags -= armSwitchOnlyFlag;
  90             }
  91
  92             // Rotate to the next arming disabled reason after a 0.5 second time delay
  93             // or if the current flag is no longer set
  94             if ((currentTimeUs - armingDisabledUpdateTimeUs > 5e5) || !(flags & (1 << armingDisabledDisplayIndex))) {
  95                 if (armingDisabledUpdateTimeUs == 0) {
  96                     armingDisabledDisplayIndex = ARMING_DISABLE_FLAGS_COUNT - 1;
  97                 }
  98                 armingDisabledUpdateTimeUs = currentTimeUs;
  99
 100                 do {
 101                     if (++armingDisabledDisplayIndex >= ARMING_DISABLE_FLAGS_COUNT) {
 102                         armingDisabledDisplayIndex = 0;
 103                     }
 104                 } while (!(flags & (1 << armingDisabledDisplayIndex)));
 105             }
 106
 107             tfp_sprintf(warningText, "%s", armingDisableFlagNames[armingDisabledDisplayIndex]);
 108             *displayAttr = DISPLAYPORT_ATTR_WARNING;
 109             return;
 110         } else {
 111             armingDisabledUpdateTimeUs = 0;
 112         }
 113     }
 114
 115 #ifdef USE_DSHOT
 116     if (isTryingToArm() && !ARMING_FLAG(ARMED)) {
 117         int armingDelayTime = (getLastDshotBeaconCommandTimeUs() + DSHOT_BEACON_GUARD_DELAY_US - currentTimeUs) / 1e5;
 118         if (armingDelayTime < 0) {
 119             armingDelayTime = 0;
 120         }
 121         if (armingDelayTime >= (DSHOT_BEACON_GUARD_DELAY_US / 1e5 - 5)) {
 122             tfp_sprintf(warningText, " BEACON ON"); // Display this message for the first 0.5 seconds
 123         } else {
 124             tfp_sprintf(warningText, "ARM IN %d.%d", armingDelayTime / 10, armingDelayTime % 10);
 125         }
 126         *displayAttr = DISPLAYPORT_ATTR_INFO;
 127         return;
 128     }
 129 #endif // USE_DSHOT
 130     if (osdWarnGetState(OSD_WARNING_FAIL_SAFE) && failsafeIsActive()) {
 131         tfp_sprintf(warningText, "FAIL SAFE");
 132         *displayAttr = DISPLAYPORT_ATTR_CRITICAL;
 133         *blinking = true;
 134         return;
 135     }
 136
 137     // Warn when in flip over after crash mode
 138     if (osdWarnGetState(OSD_WARNING_CRASH_FLIP) && IS_RC_MODE_ACTIVE(BOXFLIPOVERAFTERCRASH)) {
 139         if (isFlipOverAfterCrashActive()) { // if was armed in crash flip mode
 140             tfp_sprintf(warningText, CRASH_FLIP_WARNING);
 141             *displayAttr = DISPLAYPORT_ATTR_INFO;
 142             return;
 143         } else if (!ARMING_FLAG(ARMED)) { // if disarmed, but crash flip mode is activated
 144             tfp_sprintf(warningText, "CRASH FLIP SWITCH");
 145             *displayAttr = DISPLAYPORT_ATTR_INFO;
 146             return;
 147         }
 148     }
 149
 150 #ifdef USE_LAUNCH_CONTROL
 151     // Warn when in launch control mode
 152     if (osdWarnGetState(OSD_WARNING_LAUNCH_CONTROL) && isLaunchControlActive()) {
 153 #ifdef USE_ACC
 154         if (sensors(SENSOR_ACC)) {
 155             const int pitchAngle = constrain((attitude.raw[FD_PITCH] - accelerometerConfig()->accelerometerTrims.raw[FD_PITCH]) / 10, -90, 90);
 156             tfp_sprintf(warningText, "LAUNCH %d", pitchAngle);
 157         } else
 158 #endif // USE_ACC
 159         {
 160             tfp_sprintf(warningText, "LAUNCH");
 161         }
 162
 163         // Blink the message if the throttle is within 10% of the launch setting
 164         if ( calculateThrottlePercent() >= MAX(currentPidProfile->launchControlThrottlePercent - 10, 0)) {
 165             *blinking = true;
 166         }
 167
 168         *displayAttr = DISPLAYPORT_ATTR_INFO;
 169         return;
 170     }
 171 #endif // USE_LAUNCH_CONTROL
 172
 173     // RSSI
 174     if (osdWarnGetState(OSD_WARNING_RSSI) && (getRssiPercent() < osdConfig()->rssi_alarm)) {
 175         tfp_sprintf(warningText, "RSSI LOW");
 176         *displayAttr = DISPLAYPORT_ATTR_WARNING;
 177         *blinking = true;
 178         return;
 179     }
 180 #ifdef USE_RX_RSSI_DBM
 181     // rssi dbm
 182     if (osdWarnGetState(OSD_WARNING_RSSI_DBM) && (getRssiDbm() < osdConfig()->rssi_dbm_alarm)) {
 183         tfp_sprintf(warningText, "RSSI DBM");
 184         *displayAttr = DISPLAYPORT_ATTR_WARNING;
 185         *blinking = true;
 186         return;
 187     }
 188 #endif // USE_RX_RSSI_DBM
 189
 190 #ifdef USE_RX_LINK_QUALITY_INFO
 191     // Link Quality
 192     if (osdWarnGetState(OSD_WARNING_LINK_QUALITY) && (rxGetLinkQualityPercent() < osdConfig()->link_quality_alarm)) {
 193         tfp_sprintf(warningText, "LINK QUALITY");
 194         *displayAttr = DISPLAYPORT_ATTR_WARNING;
 195         *blinking = true;
 196         return;
 197     }
 198 #endif // USE_RX_LINK_QUALITY_INFO
 199
 200     if (osdWarnGetState(OSD_WARNING_BATTERY_CRITICAL) && batteryState == BATTERY_CRITICAL) {
 201         tfp_sprintf(warningText, " LAND NOW");
 202         *displayAttr = DISPLAYPORT_ATTR_CRITICAL;
 203         *blinking = true;
 204         return;
 205     }
 206
 207 #ifdef USE_GPS_RESCUE
 208     if (osdWarnGetState(OSD_WARNING_GPS_RESCUE_UNAVAILABLE) &&
 209        ARMING_FLAG(ARMED) &&
 210        gpsRescueIsConfigured() &&
 211        !gpsRescueIsDisabled() &&
 212        !gpsRescueIsAvailable()) {
 213         tfp_sprintf(warningText, "RESCUE N/A");
 214         *displayAttr = DISPLAYPORT_ATTR_WARNING;
 215         *blinking = true;
 216         return;
 217     }
 218
 219     if (osdWarnGetState(OSD_WARNING_GPS_RESCUE_DISABLED) &&
 220        ARMING_FLAG(ARMED) &&
 221        gpsRescueIsConfigured() &&
 222        gpsRescueIsDisabled()) {
 223
 224         statistic_t *stats = osdGetStats();
 225         if (cmpTimeUs(stats->armed_time, OSD_GPS_RESCUE_DISABLED_WARNING_DURATION_US) < 0) {
 226             tfp_sprintf(warningText, "RESCUE OFF");
 227             *displayAttr = DISPLAYPORT_ATTR_WARNING;
 228             *blinking = true;
 229             return;
 230         }
 231     }
 232
 233 #endif // USE_GPS_RESCUE
 234
 235     // Show warning if in HEADFREE flight mode
 236     if (FLIGHT_MODE(HEADFREE_MODE)) {
 237         tfp_sprintf(warningText, "HEADFREE");
 238         *displayAttr = DISPLAYPORT_ATTR_WARNING;
 239         *blinking = true;
 240         return;
 241     }
 242
 243 #ifdef USE_ADC_INTERNAL
 244     const int16_t coreTemperature = getCoreTemperatureCelsius();
 245     if (osdWarnGetState(OSD_WARNING_CORE_TEMPERATURE) && coreTemperature >= osdConfig()->core_temp_alarm) {
 246         tfp_sprintf(warningText, "CORE %c: %3d%c", SYM_TEMPERATURE, osdConvertTemperatureToSelectedUnit(coreTemperature), osdGetTemperatureSymbolForSelectedUnit());
 247         *displayAttr = DISPLAYPORT_ATTR_WARNING;
 248         *blinking = true;
 249         return;
 250     }
 251 #endif // USE_ADC_INTERNAL
 252
 253 #ifdef USE_ESC_SENSOR
 254     // Show warning if we lose motor output, the ESC is overheating or excessive current draw
 255     if (featureIsEnabled(FEATURE_ESC_SENSOR) && osdWarnGetState(OSD_WARNING_ESC_FAIL)) {
 256         char escWarningMsg[OSD_FORMAT_MESSAGE_BUFFER_SIZE];
 257         unsigned pos = 0;
 258
 259         const char *title = "ESC";
 260
 261         // center justify message
 262         while (pos < (OSD_WARNINGS_MAX_SIZE - (strlen(title) + getMotorCount())) / 2) {
 263             escWarningMsg[pos++] = ' ';
 264         }
 265
 266         strcpy(escWarningMsg + pos, title);
 267         pos += strlen(title);
 268
 269         unsigned i = 0;
 270         unsigned escWarningCount = 0;
 271         while (i < getMotorCount() && pos < OSD_FORMAT_MESSAGE_BUFFER_SIZE - 1) {
 272             escSensorData_t *escData = getEscSensorData(i);
 273             const char motorNumber = '1' + i;
 274             // if everything is OK just display motor number else R, T or C
 275             char warnFlag = motorNumber;
 276             if (ARMING_FLAG(ARMED) && osdConfig()->esc_rpm_alarm != ESC_RPM_ALARM_OFF && calcEscRpm(escData->rpm) <= osdConfig()->esc_rpm_alarm) {
 277                 warnFlag = 'R';
 278             }
 279             if (osdConfig()->esc_temp_alarm != ESC_TEMP_ALARM_OFF && escData->temperature >= osdConfig()->esc_temp_alarm) {
 280                 warnFlag = 'T';
 281             }
 282             if (ARMING_FLAG(ARMED) && osdConfig()->esc_current_alarm != ESC_CURRENT_ALARM_OFF && escData->current >= osdConfig()->esc_current_alarm) {
 283                 warnFlag = 'C';
 284             }
 285
 286             escWarningMsg[pos++] = warnFlag;
 287
 288             if (warnFlag != motorNumber) {
 289                 escWarningCount++;
 290             }
 291
 292             i++;
 293         }
 294
 295         escWarningMsg[pos] = '\0';
 296
 297         if (escWarningCount > 0) {
 298             tfp_sprintf(warningText, "%s", escWarningMsg);
 299             *displayAttr = DISPLAYPORT_ATTR_WARNING;
 300             *blinking = true;
 301             return;
 302         }
 303     }
 304 #endif // USE_ESC_SENSOR
 305
 306 #if defined(USE_DSHOT) && defined(USE_DSHOT_TELEMETRY)
 307     // Show esc error
 308     if (osdWarnGetState(OSD_WARNING_ESC_FAIL)) {
 309         uint32_t dshotEscErrorLengthMotorBegin;
 310         uint32_t dshotEscErrorLength = 0;
 311
 312         // Write 'ESC'
 313         warningText[dshotEscErrorLength++] = 'E';
 314         warningText[dshotEscErrorLength++] = 'S';
 315         warningText[dshotEscErrorLength++] = 'C';
 316
 317         for (uint8_t k = 0; k < getMotorCount(); k++) {
 318             // Skip if no extended telemetry at all
 319             if ((dshotTelemetryState.motorState[k].telemetryTypes & DSHOT_EXTENDED_TELEMETRY_MASK) == 0) {
 320                 continue;
 321             }
 322
 323             // Remember text index before writing warnings
 324             dshotEscErrorLengthMotorBegin = dshotEscErrorLength;
 325
 326             // Write ESC nr
 327             warningText[dshotEscErrorLength++] = ' ';
 328             warningText[dshotEscErrorLength++] = '0' + k + 1;
 329
 330             // Add esc warnings
 331             if (ARMING_FLAG(ARMED) && osdConfig()->esc_rpm_alarm != ESC_RPM_ALARM_OFF
 332                     && (dshotTelemetryState.motorState[k].telemetryTypes & (1 << DSHOT_TELEMETRY_TYPE_eRPM)) != 0
 333                     && (dshotTelemetryState.motorState[k].telemetryData[DSHOT_TELEMETRY_TYPE_eRPM] * 100 * 2 / motorConfig()->motorPoleCount) <= osdConfig()->esc_rpm_alarm) {
 334                 warningText[dshotEscErrorLength++] = 'R';
 335             }
 336             if (osdConfig()->esc_temp_alarm != ESC_TEMP_ALARM_OFF
 337                     && (dshotTelemetryState.motorState[k].telemetryTypes & (1 << DSHOT_TELEMETRY_TYPE_TEMPERATURE)) != 0
 338                     && dshotTelemetryState.motorState[k].telemetryData[DSHOT_TELEMETRY_TYPE_TEMPERATURE] >= osdConfig()->esc_temp_alarm) {
 339                 warningText[dshotEscErrorLength++] = 'T';
 340             }
 341             if (ARMING_FLAG(ARMED) && osdConfig()->esc_current_alarm != ESC_CURRENT_ALARM_OFF
 342                     && (dshotTelemetryState.motorState[k].telemetryTypes & (1 << DSHOT_TELEMETRY_TYPE_CURRENT)) != 0
 343                     && dshotTelemetryState.motorState[k].telemetryData[DSHOT_TELEMETRY_TYPE_CURRENT] >= osdConfig()->esc_current_alarm) {
 344                 warningText[dshotEscErrorLength++] = 'C';
 345             }
 346
 347             // If no esc warning data undo esc nr (esc telemetry data types depends on the esc hw/sw)
 348             if (dshotEscErrorLengthMotorBegin + 2 == dshotEscErrorLength)
 349                 dshotEscErrorLength = dshotEscErrorLengthMotorBegin;
 350         }
 351
 352         // If warning exists then notify, otherwise clear warning message
 353         if (dshotEscErrorLength > 3) {
 354             warningText[dshotEscErrorLength] = 0;        // End string
 355             *displayAttr = DISPLAYPORT_ATTR_WARNING;
 356             *blinking = true;
 357             return;
 358         } else {
 359             warningText[0] = 0;
 360         }
 361     }
 362 #endif
 363
 364     if (osdWarnGetState(OSD_WARNING_BATTERY_WARNING) && batteryState == BATTERY_WARNING) {
 365         tfp_sprintf(warningText, "LOW BATTERY");
 366         *displayAttr = DISPLAYPORT_ATTR_WARNING;
 367         *blinking = true;
 368         return;
 369     }
 370
 371 #ifdef USE_RC_SMOOTHING_FILTER
 372     // Show warning if rc smoothing hasn't initialized the filters
 373     if (osdWarnGetState(OSD_WARNING_RC_SMOOTHING) && ARMING_FLAG(ARMED) && !rcSmoothingInitializationComplete()) {
 374         tfp_sprintf(warningText, "RCSMOOTHING");
 375         *displayAttr = DISPLAYPORT_ATTR_WARNING;
 376         *blinking = true;
 377         return;
 378     }
 379 #endif // USE_RC_SMOOTHING_FILTER
 380
 381     // Show warning if mah consumed is over the configured limit
 382     if (osdWarnGetState(OSD_WARNING_OVER_CAP) && ARMING_FLAG(ARMED) && osdConfig()->cap_alarm > 0 && getMAhDrawn() >= osdConfig()->cap_alarm) {
 383         tfp_sprintf(warningText, "OVER CAP");
 384         *displayAttr = DISPLAYPORT_ATTR_WARNING;
 385         *blinking = true;
 386         return;
 387     }
 388
 389 #ifdef USE_BATTERY_CONTINUE
 390     // Show warning if battery is not fresh and battery continue is active
 391     if (hasUsedMAh()) {
 392         tfp_sprintf(warningText, "BATTERY CONTINUE");
 393         *displayAttr = DISPLAYPORT_ATTR_INFO;
 394         return;
 395     }
 396 #endif // USE_BATTERY_CONTINUE
 397
 398     // Show warning if battery is not fresh
 399     if (osdWarnGetState(OSD_WARNING_BATTERY_NOT_FULL) && !(ARMING_FLAG(ARMED) || ARMING_FLAG(WAS_EVER_ARMED)) && (getBatteryState() == BATTERY_OK)
 400           && getBatteryAverageCellVoltage() < batteryConfig()->vbatfullcellvoltage) {
 401         tfp_sprintf(warningText, "BATT < FULL");
 402         *displayAttr = DISPLAYPORT_ATTR_INFO;
 403         return;
 404     }
 405
 406     // Visual beeper
 407     if (osdWarnGetState(OSD_WARNING_VISUAL_BEEPER) && osdGetVisualBeeperState()) {
 408         tfp_sprintf(warningText, "  * * * *");
 409         *displayAttr = DISPLAYPORT_ATTR_INFO;
 410         osdSetVisualBeeperState(false);
 411         return;
 412     }
 413
 414 }
 415
 416 #endif // USE_OSD