src/lib/LED/devLED.cpp

   1 #include "targets.h"
   2 #include "common.h"
   3 #include "devLED.h"
   4
   5 #include "crsf_protocol.h"
   6 #include "POWERMGNT.h"
   7
   8 #ifdef HAS_LED
   9
  10 /* Set red led to default */
  11 #ifndef GPIO_PIN_LED_RED
  12 #ifdef GPIO_PIN_LED
  13 #define GPIO_PIN_LED_RED GPIO_PIN_LED
  14 #else
  15 #define GPIO_PIN_LED_RED UNDEF_PIN
  16 #endif
  17 #endif
  18 #ifndef GPIO_PIN_LED
  19 #define GPIO_PIN_LED GPIO_PIN_LED_RED
  20 #endif
  21 #ifndef GPIO_PIN_LED_GREEN
  22 #define GPIO_PIN_LED_GREEN UNDEF_PIN
  23 #endif
  24 #ifndef GPIO_PIN_LED_BLUE
  25 #define GPIO_PIN_LED_BLUE UNDEF_PIN
  26 #endif
  27 #ifndef GPIO_LED_RED_INVERTED
  28 #define GPIO_LED_RED_INVERTED 0
  29 #endif
  30 #ifndef GPIO_LED_GREEN_INVERTED
  31 #define GPIO_LED_GREEN_INVERTED 0
  32 #endif
  33 #ifndef GPIO_LED_BLUE_INVERTED
  34 #define GPIO_LED_BLUE_INVERTED 0
  35 #endif
  36
  37 #if defined(TARGET_RX)
  38 extern bool connectionHasModelMatch;
  39 #endif
  40
  41 constexpr uint8_t LEDSEQ_RADIO_FAILED[] = { 20, 100 }; // 200ms on, 1000ms off
  42 constexpr uint8_t LEDSEQ_DISCONNECTED[] = { 50, 50 };  // 500ms on, 500ms off
  43 constexpr uint8_t LEDSEQ_WIFI_UPDATE[] = { 2, 3 };     // 20ms on, 30ms off
  44 constexpr uint8_t LEDSEQ_BINDING[] = { 10, 10, 10, 100 };   // 2x 100ms blink, 1s pause
  45 constexpr uint8_t LEDSEQ_MODEL_MISMATCH[] = { 10, 10, 10, 10, 10, 100 };   // 3x 100ms blink, 1s pause
  46 constexpr uint8_t LEDSEQ_UPDATE[] = { 20, 5, 5, 5, 5, 40 };   // 200ms on, 2x 50ms off/on, 400ms off
  47
  48 static uint8_t _pin = -1;
  49 static uint8_t _pin_inverted;
  50 static const uint8_t *_durations;
  51 static uint8_t _count;
  52 static uint8_t _counter = 0;
  53 static bool hasRGBLeds = false;
  54 #if defined(TARGET_TX)
  55 static bool hasGBLeds = false;
  56 #endif
  57
  58 static uint16_t updateLED()
  59 {
  60     if (_pin == UNDEF_PIN)
  61     {
  62         return DURATION_NEVER;
  63     }
  64     if(_counter % 2 == 1)
  65         digitalWrite(_pin, LOW ^ _pin_inverted);
  66     else
  67         digitalWrite(_pin, HIGH ^ _pin_inverted);
  68     if (_counter >= _count)
  69     {
  70         _counter = 0;
  71     }
  72     return _durations[_counter++] * 10;
  73 }
  74
  75 static uint16_t flashLED(uint8_t pin, uint8_t pin_inverted, const uint8_t durations[], uint8_t count)
  76 {
  77     _counter = 0;
  78     _pin = pin;
  79     _pin_inverted = pin_inverted;
  80     _durations = durations;
  81     _count = count;
  82     return updateLED();
  83 }
  84
  85 static void initialize()
  86 {
  87     // TODO for future PR, remove TARGET_TX, TARGET_RX, and TARGET_TX_FM30 defines.
  88     #if defined(TARGET_TX)
  89         if (GPIO_PIN_LED_BLUE != UNDEF_PIN)
  90         {
  91             pinMode(GPIO_PIN_LED_BLUE, OUTPUT);
  92             digitalWrite(GPIO_PIN_LED_BLUE, LOW ^ GPIO_LED_BLUE_INVERTED);
  93         }
  94         if (GPIO_PIN_LED_GREEN != UNDEF_PIN)
  95         {
  96             pinMode(GPIO_PIN_LED_GREEN, OUTPUT);
  97             digitalWrite(GPIO_PIN_LED_GREEN, HIGH ^ GPIO_LED_GREEN_INVERTED);
  98         }
  99         if (GPIO_PIN_LED_RED != UNDEF_PIN)
 100         {
 101             pinMode(GPIO_PIN_LED_RED, OUTPUT);
 102             digitalWrite(GPIO_PIN_LED_RED, LOW ^ GPIO_LED_RED_INVERTED);
 103         }
 104         if (GPIO_PIN_LED_BLUE != UNDEF_PIN && GPIO_PIN_LED_GREEN != UNDEF_PIN && GPIO_PIN_LED_RED != UNDEF_PIN)
 105         {
 106             hasRGBLeds = true;
 107             digitalWrite(GPIO_PIN_LED_GREEN, LOW);
 108             digitalWrite(GPIO_PIN_LED_RED, HIGH);
 109             digitalWrite(GPIO_PIN_LED_BLUE, LOW);
 110         }
 111         else if (GPIO_PIN_LED_BLUE != UNDEF_PIN && GPIO_PIN_LED_GREEN != UNDEF_PIN && GPIO_PIN_LED_RED == UNDEF_PIN)
 112         {
 113             hasGBLeds = true;
 114         }
 115         #if defined(TARGET_TX_FM30)
 116             pinMode(GPIO_PIN_LED_RED_GREEN, OUTPUT); // Green LED on "Red" LED (off)
 117             digitalWrite(GPIO_PIN_LED_RED_GREEN, HIGH);
 118             pinMode(GPIO_PIN_LED_GREEN_RED, OUTPUT); // Red LED on "Green" LED (off)
 119             digitalWrite(GPIO_PIN_LED_GREEN_RED, HIGH);
 120         #endif
 121     #endif
 122     #if defined(TARGET_RX)
 123         if (GPIO_PIN_LED_GREEN != UNDEF_PIN)
 124         {
 125             pinMode(GPIO_PIN_LED_GREEN, OUTPUT);
 126             digitalWrite(GPIO_PIN_LED_GREEN, LOW ^ GPIO_LED_GREEN_INVERTED);
 127         }
 128         if (GPIO_PIN_LED_RED != UNDEF_PIN)
 129         {
 130             pinMode(GPIO_PIN_LED_RED, OUTPUT);
 131             digitalWrite(GPIO_PIN_LED_RED, LOW ^ GPIO_LED_RED_INVERTED);
 132         }
 133         if (GPIO_PIN_LED != UNDEF_PIN)
 134         {
 135             pinMode(GPIO_PIN_LED, OUTPUT);
 136             digitalWrite(GPIO_PIN_LED, LOW ^ GPIO_LED_RED_INVERTED);
 137         }
 138     #endif
 139 }
 140
 141 static int timeout()
 142 {
 143     return updateLED();
 144 }
 145
 146 #if !defined(TARGET_RX)
 147 static void setPowerLEDs()
 148 {
 149     if (hasGBLeds)
 150     {
 151         switch (POWERMGNT::currPower())
 152         {
 153         case PWR_250mW:
 154             digitalWrite(GPIO_PIN_LED_BLUE, HIGH);
 155             digitalWrite(GPIO_PIN_LED_GREEN, HIGH);
 156             break;
 157         case PWR_500mW:
 158             digitalWrite(GPIO_PIN_LED_BLUE, LOW);
 159             digitalWrite(GPIO_PIN_LED_GREEN, HIGH);
 160             break;
 161         case PWR_10mW:
 162         case PWR_25mW:
 163         case PWR_50mW:
 164         case PWR_100mW:
 165         default:
 166             digitalWrite(GPIO_PIN_LED_BLUE, HIGH);
 167             digitalWrite(GPIO_PIN_LED_GREEN, LOW);
 168             break;
 169         }
 170     }
 171 }
 172 #endif
 173
 174 static int event()
 175 {
 176     #if defined(TARGET_RX)
 177         if (InBindingMode && GPIO_PIN_LED != UNDEF_PIN)
 178         {
 179             return flashLED(GPIO_PIN_LED, GPIO_LED_RED_INVERTED, LEDSEQ_BINDING, sizeof(LEDSEQ_BINDING));
 180         }
 181     #else
 182         setPowerLEDs();
 183     #endif
 184     switch (connectionState)
 185     {
 186     case connected:
 187         #if defined(TARGET_TX)
 188             if (hasRGBLeds)
 189             {
 190                 digitalWrite(GPIO_PIN_LED_GREEN, HIGH);
 191                 digitalWrite(GPIO_PIN_LED_RED, LOW);
 192                 digitalWrite(GPIO_PIN_LED_BLUE, LOW);
 193             }
 194             else if (GPIO_PIN_LED_RED != UNDEF_PIN)
 195             {
 196                 digitalWrite(GPIO_PIN_LED_RED, HIGH ^ GPIO_LED_RED_INVERTED);
 197             }
 198         #endif
 199         #if defined(TARGET_RX)
 200             if (GPIO_PIN_LED_GREEN != UNDEF_PIN)
 201             {
 202                 digitalWrite(GPIO_PIN_LED_GREEN, HIGH ^ GPIO_LED_GREEN_INVERTED);
 203             }
 204
 205             if (GPIO_PIN_LED_RED != UNDEF_PIN)
 206             {
 207                 digitalWrite(GPIO_PIN_LED_RED, HIGH ^ GPIO_LED_RED_INVERTED);
 208             }
 209
 210             if (GPIO_PIN_LED != UNDEF_PIN)
 211             {
 212                 if (!connectionHasModelMatch || !teamraceHasModelMatch)
 213                 {
 214                     return flashLED(GPIO_PIN_LED, GPIO_LED_RED_INVERTED, LEDSEQ_MODEL_MISMATCH, sizeof(LEDSEQ_MODEL_MISMATCH));
 215                 }
 216                 else
 217                 {
 218                     digitalWrite(GPIO_PIN_LED, HIGH ^ GPIO_LED_RED_INVERTED); // turn on led
 219                 }
 220             }
 221         #endif
 222         return DURATION_NEVER;
 223     case disconnected:
 224         #if defined(TARGET_TX)
 225             if (hasRGBLeds)
 226             {
 227                 digitalWrite(GPIO_PIN_LED_GREEN, LOW);
 228                 digitalWrite(GPIO_PIN_LED_BLUE, LOW);
 229                 return flashLED(GPIO_PIN_LED_RED, GPIO_LED_RED_INVERTED, LEDSEQ_DISCONNECTED, sizeof(LEDSEQ_DISCONNECTED));
 230             }
 231             else if (GPIO_PIN_LED_RED != UNDEF_PIN)
 232             {
 233                 digitalWrite(GPIO_PIN_LED_RED, LOW ^ GPIO_LED_RED_INVERTED);
 234             }
 235         #endif
 236         #if defined(TARGET_RX)
 237             if (GPIO_PIN_LED_GREEN != UNDEF_PIN)
 238             {
 239                 digitalWrite(GPIO_PIN_LED_GREEN, LOW ^ GPIO_LED_GREEN_INVERTED);
 240             }
 241             if (GPIO_PIN_LED_RED != UNDEF_PIN)
 242             {
 243                 digitalWrite(GPIO_PIN_LED_RED, LOW ^ GPIO_LED_RED_INVERTED);
 244             }
 245             if (GPIO_PIN_LED != UNDEF_PIN)
 246             {
 247                 return flashLED(GPIO_PIN_LED, GPIO_LED_RED_INVERTED, LEDSEQ_DISCONNECTED, sizeof(LEDSEQ_DISCONNECTED));
 248             }
 249             else if (GPIO_PIN_LED_GREEN != UNDEF_PIN)
 250             {
 251                 return flashLED(GPIO_PIN_LED_GREEN, GPIO_LED_GREEN_INVERTED, LEDSEQ_DISCONNECTED, sizeof(LEDSEQ_DISCONNECTED));
 252             }
 253         #endif
 254         return DURATION_NEVER;
 255     case wifiUpdate:
 256         #if defined(TARGET_TX)
 257             if (hasRGBLeds)
 258             {
 259                 digitalWrite(GPIO_PIN_LED_GREEN, LOW);
 260                 digitalWrite(GPIO_PIN_LED_RED, LOW);
 261                 return flashLED(GPIO_PIN_LED_BLUE, GPIO_LED_BLUE_INVERTED, LEDSEQ_WIFI_UPDATE, sizeof(LEDSEQ_WIFI_UPDATE));
 262             }
 263             else if (GPIO_PIN_LED_RED != UNDEF_PIN)
 264             {
 265                 return flashLED(GPIO_PIN_LED_RED, GPIO_LED_RED_INVERTED, LEDSEQ_WIFI_UPDATE, sizeof(LEDSEQ_WIFI_UPDATE));
 266             }
 267             return DURATION_NEVER;
 268         #endif
 269         #if defined(TARGET_RX)
 270             if (GPIO_PIN_LED != UNDEF_PIN)
 271             {
 272                 return flashLED(GPIO_PIN_LED, GPIO_LED_RED_INVERTED, LEDSEQ_WIFI_UPDATE, sizeof(LEDSEQ_WIFI_UPDATE));
 273             }
 274         #else
 275             return DURATION_NEVER;
 276         #endif
 277     case radioFailed:
 278         if (hasRGBLeds)
 279         {
 280             digitalWrite(GPIO_PIN_LED_GREEN, LOW);
 281             digitalWrite(GPIO_PIN_LED_BLUE, LOW);
 282             return flashLED(GPIO_PIN_LED_RED, GPIO_LED_RED_INVERTED, LEDSEQ_RADIO_FAILED, sizeof(LEDSEQ_RADIO_FAILED));
 283         }
 284         else if (GPIO_PIN_LED_GREEN != UNDEF_PIN)
 285         {
 286             digitalWrite(GPIO_PIN_LED_GREEN, LOW ^ GPIO_LED_GREEN_INVERTED);
 287         }
 288         if (GPIO_PIN_LED_RED != UNDEF_PIN)
 289         {
 290             return flashLED(GPIO_PIN_LED_RED, GPIO_LED_RED_INVERTED, LEDSEQ_RADIO_FAILED, sizeof(LEDSEQ_RADIO_FAILED));
 291         }
 292         else if (GPIO_PIN_LED != UNDEF_PIN)
 293         {
 294             return flashLED(GPIO_PIN_LED, GPIO_LED_RED_INVERTED, LEDSEQ_RADIO_FAILED, sizeof(LEDSEQ_RADIO_FAILED));
 295         }
 296         return DURATION_NEVER;
 297     case noCrossfire:
 298         if (GPIO_PIN_LED_RED != UNDEF_PIN)
 299         {
 300             // technically nocrossfire is {10,100} but {20,100} is close enough
 301             return flashLED(GPIO_PIN_LED_RED, GPIO_LED_RED_INVERTED, LEDSEQ_RADIO_FAILED, sizeof(LEDSEQ_RADIO_FAILED));
 302         }
 303         else if (GPIO_PIN_LED != UNDEF_PIN)
 304         {
 305             return flashLED(GPIO_PIN_LED, GPIO_LED_RED_INVERTED, LEDSEQ_RADIO_FAILED, sizeof(LEDSEQ_RADIO_FAILED));
 306         }
 307     case serialUpdate:
 308         if (GPIO_PIN_LED_RED != UNDEF_PIN)
 309         {
 310             return flashLED(GPIO_PIN_LED_RED, GPIO_LED_RED_INVERTED, LEDSEQ_UPDATE, sizeof(LEDSEQ_UPDATE));
 311         }
 312     default:
 313         return DURATION_NEVER;
 314     }
 315 }
 316
 317 device_t LED_device = {
 318     .initialize = initialize,
 319     .start = event,
 320     .event = event,
 321     .timeout = timeout
 322 };
 323
 324 #endif