rtttl.cpp

Go to the documentation of this file.

#include "rtttl.h"
#include <cmath>
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
#include "esphome/core/progmem.h"
 
namespace esphome::rtttl {
 
static const char *const TAG = "rtttl";
 
// These values can also be found as constants in the Tone library (Tone.h)
static const uint16_t NOTES[] = {0,    262,  277,  294,  311,  330,  349,  370,  392,  415,  440,  466,  494,
                                 523,  554,  587,  622,  659,  698,  740,  784,  831,  880,  932,  988,  1047,
                                 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1976, 2093, 2217,
                                 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951};
 
#if defined(USE_OUTPUT) || defined(USE_SPEAKER)
static const uint32_t DOUBLE_NOTE_GAP_MS = 10;
#endif  // USE_OUTPUT || USE_SPEAKER
 
#ifdef USE_SPEAKER
static const size_t SAMPLE_BUFFER_SIZE = 2048;
 
struct SpeakerSample {
  int8_t left{0};
  int8_t right{0};
};
 
inline double deg2rad(double degrees) {
  static const double PI_ON_180 = 4.0 * atan(1.0) / 180.0;
  return degrees * PI_ON_180;
}
#endif  // USE_SPEAKER
 
#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
// RTTTL state strings indexed by State enum (0-4): STOPPED, INIT, STARTING, RUNNING, STOPPING, plus UNKNOWN fallback
PROGMEM_STRING_TABLE(RtttlStateStrings, "State::STOPPED", "State::INIT", "State::STARTING", "State::RUNNING",
                     "State::STOPPING", "UNKNOWN");
 
static const LogString *state_to_string(State state) {
  return RtttlStateStrings::get_log_str(static_cast<uint8_t>(state), RtttlStateStrings::LAST_INDEX);
}
#endif  // ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
 
static uint8_t note_index_from_char(char note) {
  switch (note) {
    case 'c':
      return 1;
    // 'c#': 2
    case 'd':
      return 3;
    // 'd#': 4
    case 'e':
      return 5;
    case 'f':
      return 6;
    // 'f#': 7
    case 'g':
      return 8;
    // 'g#': 9
    case 'a':
      return 10;
    // 'a#': 11
    // Support both 'b' (English notation for B natural) and 'h' (German notation for B natural)
    case 'b':
    case 'h':
      return 12;
    case 'p':
    default:
      return 0;
  }
}
 
void Rtttl::dump_config() {
  ESP_LOGCONFIG(TAG,
                "Rtttl:\n"
                "  Gain: %f",
                this->gain_);
}
 
void Rtttl::loop() {
  if (this->state_ == State::STOPPED) {
    this->disable_loop();
    return;
  }
 
#ifdef USE_OUTPUT
  if (this->output_ != nullptr && millis() - this->last_note_ < this->note_duration_) {
    return;
  }
#endif  // USE_OUTPUT
 
#ifdef USE_SPEAKER
  if (this->speaker_ != nullptr) {
    if (this->state_ == State::STOPPING) {
      if (this->speaker_->is_stopped()) {
        this->set_state_(State::STOPPED);
      } else {
        return;
      }
    } else if (this->state_ == State::INIT) {
      if (this->speaker_->is_stopped()) {
        this->speaker_->start();
        this->set_state_(State::STARTING);
      }
    } else if (this->state_ == State::STARTING) {
      if (this->speaker_->is_running()) {
        this->set_state_(State::RUNNING);
      }
    }
    if (!this->speaker_->is_running()) {
      return;
    }
    if (this->samples_sent_ != this->samples_count_) {
      SpeakerSample sample[SAMPLE_BUFFER_SIZE + 2];
      int x = 0;
      double rem = 0.0;
 
      while (true) {
        // Try and send out the remainder of the existing note, one per loop()
 
        if (this->samples_per_wave_ != 0 && this->samples_sent_ >= this->samples_gap_) {  // Play note//
          rem = ((this->samples_sent_ << 10) % this->samples_per_wave_) * (360.0 / this->samples_per_wave_);
 
          int16_t val = (127 * this->gain_) * sin(deg2rad(rem));  // 16bit = 49152
 
          sample[x].left = val;
          sample[x].right = val;
 
        } else {
          sample[x].left = 0;
          sample[x].right = 0;
        }
 
        if (static_cast<size_t>(x) >= SAMPLE_BUFFER_SIZE || this->samples_sent_ >= this->samples_count_) {
          break;
        }
        this->samples_sent_++;
        x++;
      }
      if (x > 0) {
        size_t bytes_to_send = x * sizeof(SpeakerSample);
        size_t send = this->speaker_->play((uint8_t *) (&sample), bytes_to_send);
        if (send != bytes_to_send) {
          this->samples_sent_ -= (x - (send / sizeof(SpeakerSample)));
        }
        return;
      }
    }
  }
#endif  // USE_SPEAKER
 
  if (this->position_ >= this->rtttl_.length()) {
    this->finish_();
    return;
  }
 
  // align to note: most rtttl's out there does not add and space after the ',' separator but just in case...
  while (this->rtttl_[this->position_] == ',' || this->rtttl_[this->position_] == ' ') {
    this->position_++;
  }
 
  // first, get note duration, if available
  uint8_t num = this->get_integer_();
 
  if (num) {
    this->note_duration_ = this->wholenote_ / num;
  } else {
    this->note_duration_ =
        this->wholenote_ / this->default_duration_;  // we will need to check if we are a dotted note after
  }
 
  uint8_t note = note_index_from_char(this->rtttl_[this->position_]);
 
  this->position_++;
 
  // now, get optional '#' sharp
  if (this->rtttl_[this->position_] == '#') {
    note++;
    this->position_++;
  }
 
  // now, get scale
  uint8_t scale = this->get_integer_();
  if (scale == 0) {
    scale = this->default_octave_;
  }
 
  if (scale < 4 || scale > 7) {
    ESP_LOGE(TAG, "Octave must be between 4 and 7 (it is %d)", scale);
    this->finish_();
    return;
  }
 
  // now, get optional '.' dotted note
  if (this->rtttl_[this->position_] == '.') {
    this->note_duration_ += this->note_duration_ / 2;
    this->position_++;
  }
 
  // Now play the note
  bool need_note_gap = false;
  if (note) {
    auto note_index = (scale - 4) * 12 + note;
    if (note_index < 0 || note_index >= (int) (sizeof(NOTES) / sizeof(NOTES[0]))) {
      ESP_LOGE(TAG, "Note out of range (note: %d, scale: %d, index: %d, max: %d)", note, scale, note_index,
               (int) (sizeof(NOTES) / sizeof(NOTES[0])));
      this->finish_();
      return;
    }
    auto freq = NOTES[note_index];
    need_note_gap = freq == this->output_freq_;
 
    // Add small silence gap between same note
    this->output_freq_ = freq;
 
    ESP_LOGVV(TAG, "playing note: %d for %dms", note, this->note_duration_);
  } else {
    ESP_LOGVV(TAG, "waiting: %dms", this->note_duration_);
    this->output_freq_ = 0;
  }
 
#ifdef USE_OUTPUT
  if (this->output_ != nullptr) {
    if (need_note_gap && this->note_duration_ > DOUBLE_NOTE_GAP_MS) {
      this->output_->set_level(0.0);
      delay(DOUBLE_NOTE_GAP_MS);
      this->note_duration_ -= DOUBLE_NOTE_GAP_MS;
    }
    if (this->output_freq_ != 0) {
      this->output_->update_frequency(this->output_freq_);
      this->output_->set_level(this->gain_);
    } else {
      this->output_->set_level(0.0);
    }
  }
#endif  // USE_OUTPUT
 
#ifdef USE_SPEAKER
  if (this->speaker_ != nullptr) {
    this->samples_sent_ = 0;
    this->samples_gap_ = 0;
    this->samples_per_wave_ = 0;
    this->samples_count_ = (this->sample_rate_ * this->note_duration_) / 1000;
    if (need_note_gap) {
      this->samples_gap_ = (this->sample_rate_ * DOUBLE_NOTE_GAP_MS) / 1000;
    }
    if (this->output_freq_ != 0) {
      // make sure there is enough samples to add a full last sinus.
 
      uint16_t samples_wish = this->samples_count_;
      this->samples_per_wave_ = (this->sample_rate_ << 10) / this->output_freq_;
 
      uint16_t division = ((this->samples_count_ << 10) / this->samples_per_wave_) + 1;
 
      this->samples_count_ = (division * this->samples_per_wave_);
      this->samples_count_ = this->samples_count_ >> 10;
      ESP_LOGVV(TAG, "- Calc play time: wish: %d gets: %d (div: %d spw: %d)", samples_wish, this->samples_count_,
                division, this->samples_per_wave_);
    }
    // Convert from frequency in Hz to high and low samples in fixed point
  }
#endif  // USE_SPEAKER
 
  this->last_note_ = millis();
}
 
void Rtttl::play(std::string rtttl) {
  if (this->state_ != State::STOPPED && this->state_ != State::STOPPING) {
    size_t pos = this->rtttl_.find(':');
    size_t len = (pos != std::string::npos) ? pos : this->rtttl_.length();
    ESP_LOGW(TAG, "Already playing: %.*s", (int) len, this->rtttl_.c_str());
    return;
  }
 
  this->rtttl_ = std::move(rtttl);
 
  this->default_duration_ = 4;
  this->default_octave_ = 6;
  this->note_duration_ = 0;
 
  int bpm = 63;
  uint16_t num;
 
  // Get name
  this->position_ = this->rtttl_.find(':');
 
  // it's somewhat documented to be up to 10 characters but let's be a bit flexible here
  if (this->position_ == std::string::npos || this->position_ > 15) {
    ESP_LOGE(TAG, "Unable to determine name; missing ':'");
    return;
  }
 
  ESP_LOGD(TAG, "Playing song %.*s", (int) this->position_, this->rtttl_.c_str());
 
  // get default duration
  this->position_ = this->rtttl_.find("d=", this->position_);
  if (this->position_ == std::string::npos) {
    ESP_LOGE(TAG, "Missing 'd='");
    return;
  }
  this->position_ += 2;
  num = this->get_integer_();
  if (num > 0) {
    this->default_duration_ = num;
  }
 
  // get default octave
  this->position_ = this->rtttl_.find("o=", this->position_);
  if (this->position_ == std::string::npos) {
    ESP_LOGE(TAG, "Missing 'o=");
    return;
  }
  this->position_ += 2;
  num = this->get_integer_();
  if (num >= 3 && num <= 7) {
    this->default_octave_ = num;
  }
 
  // get BPM
  this->position_ = this->rtttl_.find("b=", this->position_);
  if (this->position_ == std::string::npos) {
    ESP_LOGE(TAG, "Missing b=");
    return;
  }
  this->position_ += 2;
  num = this->get_integer_();
  if (num != 0) {
    bpm = num;
  }
 
  this->position_ = this->rtttl_.find(':', this->position_);
  if (this->position_ == std::string::npos) {
    ESP_LOGE(TAG, "Missing second ':'");
    return;
  }
  this->position_++;
 
  // BPM usually expresses the number of quarter notes per minute
  this->wholenote_ = 60 * 1000L * 4 / bpm;  // this is the time for whole note (in milliseconds)
 
  this->output_freq_ = 0;
  this->last_note_ = millis();
  this->note_duration_ = 1;
 
#ifdef USE_OUTPUT
  if (this->output_ != nullptr) {
    this->set_state_(State::RUNNING);
  }
#endif  // USE_OUTPUT
 
#ifdef USE_SPEAKER
  if (this->speaker_ != nullptr) {
    this->set_state_(State::INIT);
    this->samples_sent_ = 0;
    this->samples_count_ = 0;
  }
#endif  // USE_SPEAKER
}
 
void Rtttl::stop() {
#ifdef USE_OUTPUT
  if (this->output_ != nullptr) {
    this->output_->set_level(0.0);
    this->set_state_(State::STOPPED);
  }
#endif  // USE_OUTPUT
 
#ifdef USE_SPEAKER
  if (this->speaker_ != nullptr) {
    if (this->speaker_->is_running()) {
      this->speaker_->stop();
    }
    this->set_state_(State::STOPPING);
  }
#endif  // USE_SPEAKER
 
  this->position_ = this->rtttl_.length();
  this->note_duration_ = 0;
}
 
void Rtttl::finish_() {
  ESP_LOGV(TAG, "Rtttl::finish_()");
 
#ifdef USE_OUTPUT
  if (this->output_ != nullptr) {
    this->output_->set_level(0.0);
    this->set_state_(State::STOPPED);
  }
#endif  // USE_OUTPUT
 
#ifdef USE_SPEAKER
  if (this->speaker_ != nullptr) {
    SpeakerSample sample[2];
    sample[0].left = 0;
    sample[0].right = 0;
    sample[1].left = 0;
    sample[1].right = 0;
    this->speaker_->play((uint8_t *) (&sample), sizeof(sample));
    this->speaker_->finish();
    this->set_state_(State::STOPPING);
  }
#endif  // USE_SPEAKER
 
  // Ensure no more notes are played in case finish_() is called for an error.
  this->position_ = this->rtttl_.length();
  this->note_duration_ = 0;
}
 
void Rtttl::set_state_(State state) {
  State old_state = this->state_;
  this->state_ = state;
  ESP_LOGV(TAG, "State changed from %s to %s", LOG_STR_ARG(state_to_string(old_state)),
           LOG_STR_ARG(state_to_string(state)));
 
  // Clear loop_done when transitioning from `State::STOPPED` to any other state
  if (state == State::STOPPED) {
    this->disable_loop();
    this->on_finished_playback_callback_.call();
    ESP_LOGD(TAG, "Playback finished");
  } else if (old_state == State::STOPPED) {
    this->enable_loop();
  }
}
 
}  // namespace esphome::rtttl