src/lib/BUZZER/devBuzzer.cpp

   1 #include "targets.h"
   2 #include "common.h"
   3 #include "device.h"
   4
   5 #include "helpers.h"
   6 #include "logging.h"
   7 #include "options.h"
   8
   9 // Even though we aren't using anything this keeps the PIO dependency analyzer happy!
  10 #include "POWERMGNT.h"
  11
  12 #if defined(GPIO_PIN_BUZZER)
  13
  14 static void initializeBuzzer()
  15 {
  16     pinMode(GPIO_PIN_BUZZER, OUTPUT);
  17 }
  18
  19 static const uint16_t failedTune[][2] = {{480, 200},{400, 200}};
  20 static const uint16_t crossfireTune[][2] = {{520, 150},{676, 300},{0,1000}}; // we have a dead-time to stop spamming
  21 static const uint16_t noCrossfireTune[][2] = {{676, 300},{520, 150}};
  22
  23 static uint8_t tunepos = 0;
  24 static bool callAfterComplete = false;
  25 static bool startComplete = false;
  26 static const uint16_t (*_tune)[2];
  27 static int _numTones;
  28
  29 static int playTune()
  30 {
  31     if (tunepos >= _numTones || (_tune[tunepos][0] == 0 && _tune[tunepos][1] == 0))
  32     {
  33         noTone(GPIO_PIN_BUZZER);
  34         pinMode(GPIO_PIN_BUZZER, INPUT);
  35         tunepos = 0;
  36         DBGVLN(">> end tune");
  37         return DURATION_NEVER;
  38     }
  39     if (_tune[tunepos][0] == 0)
  40     {
  41         // we have dead-time so play no-tone and just set the timeout
  42         noTone(GPIO_PIN_BUZZER);
  43     }
  44     else
  45     {
  46         tone(GPIO_PIN_BUZZER, _tune[tunepos][0], _tune[tunepos][1]);
  47     }
  48     tunepos++;
  49     return _tune[tunepos-1][1];
  50 }
  51
  52 static int startTune(const uint16_t tune[][2], int numTones)
  53 {
  54     _tune = tune;
  55     _numTones = numTones;
  56     pinMode(GPIO_PIN_BUZZER, OUTPUT);
  57     tunepos = 0;
  58     return playTune();
  59 }
  60
  61 static int updateBuzzer()
  62 {
  63     if (connectionState == radioFailed && firmwareOptions.buzzer_mode > buzzerOne)
  64     {
  65         DBGVLN(">> start failed tune");
  66         return startTune(failedTune, ARRAY_SIZE(failedTune));
  67     }
  68     else if (connectionState == noCrossfire && firmwareOptions.buzzer_mode > buzzerOne)
  69     {
  70         DBGVLN(">> start no-xfire tune");
  71         return startTune(noCrossfireTune, ARRAY_SIZE(noCrossfireTune));
  72     }
  73     else if ((connectionState == connected || connectionState == disconnected))
  74     {
  75         DBGVLN(">> start conn/disconn tune");
  76         return startTune(crossfireTune, ARRAY_SIZE(crossfireTune));
  77     }
  78     return DURATION_NEVER;
  79 }
  80
  81 static int start()
  82 {
  83     if (GPIO_PIN_BUZZER != UNDEF_PIN && firmwareOptions.buzzer_mode == buzzerTune)
  84     {
  85         DBGVLN(">> start startup tune");
  86         return startTune(firmwareOptions.buzzer_melody, ARRAY_SIZE(firmwareOptions.buzzer_melody));
  87     }
  88     return DURATION_NEVER;
  89 }
  90
  91 static int event()
  92 {
  93     if (GPIO_PIN_BUZZER == UNDEF_PIN || firmwareOptions.buzzer_mode == buzzerQuiet)
  94     {
  95         return DURATION_NEVER;
  96     }
  97     static connectionState_e lastConnectionState = MODE_STATES;
  98     if (tunepos == 0)
  99     {
 100         if (connectionState != lastConnectionState)
 101         {
 102             DBGVLN(">> starting %d -> %d", lastConnectionState, connectionState);
 103             lastConnectionState = connectionState;
 104             return updateBuzzer();
 105         }
 106         lastConnectionState = connectionState;
 107         return DURATION_NEVER;
 108     }
 109     if(!startComplete)
 110     {
 111         // if we are currently playing the startup tune then set a flag so that we trigger an update after it completes
 112         DBGVLN(">> call after");
 113         callAfterComplete = true;
 114     }
 115     else
 116     {
 117         DBGVLN(">> ignored %d -> %d", lastConnectionState, connectionState);
 118     }
 119     return DURATION_IGNORE;
 120 }
 121
 122 static int timeout()
 123 {
 124     if (GPIO_PIN_BUZZER == UNDEF_PIN || firmwareOptions.buzzer_mode == buzzerQuiet)
 125     {
 126         return DURATION_NEVER;
 127     }
 128
 129     int duration = playTune();
 130     DBGVLN(">> timeout %d", duration);
 131     if (duration == DURATION_NEVER && !startComplete)
 132     {
 133         startComplete = true;
 134         if (callAfterComplete)
 135         {
 136             // tune completed and the flag is set to start the next one
 137             callAfterComplete = false;
 138             DBGVLN(">> call after update");
 139             duration = updateBuzzer();
 140         }
 141     }
 142     return duration;
 143 }
 144
 145 device_t Buzzer_device = {
 146     .initialize = initializeBuzzer,
 147     .start = start,
 148     .event = event,
 149     .timeout = timeout
 150 };
 151
 152 #endif