rtttl.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/component.h"
#include "esphome/core/defines.h"
#include "esphome/core/helpers.h"
#include "esphome/core/progmem.h"
 
#ifdef USE_OUTPUT
#include "esphome/components/output/float_output.h"
#endif  // USE_OUTPUT
 
#ifdef USE_SPEAKER
#include "esphome/components/speaker/speaker.h"
#endif  // USE_SPEAKER
 
namespace esphome::rtttl {
 
namespace testing {
class RtttlParserAccess;
}  // namespace testing
 
inline constexpr uint8_t DEFAULT_NOTE_DENOMINATOR = 4;  // Default note-denominator (quarter note)
inline constexpr uint8_t DEFAULT_OCTAVE =
    6;  // Default octave for a note (see: `MIN_OCTAVE`, `MAX_OCTAVE` in `rtttl.cpp`)
 
enum class State : uint8_t {
  STOPPED = 0,
  INIT,
  STARTING,
  RUNNING,
  STOPPING,
};
 
struct StaticSong {
  ProgmemStr rtttl;
};
 
class Rtttl final : public Component {
 public:
#ifdef USE_OUTPUT
  void set_output(output::FloatOutput *output) { this->output_ = output; }
#endif  // USE_OUTPUT
 
#ifdef USE_SPEAKER
  void set_speaker(speaker::Speaker *speaker) { this->speaker_ = speaker; }
#endif  // USE_SPEAKER
 
  void dump_config() override;
  void loop() override;
  void play(std::string rtttl);
  void play(StaticSong song);
  void stop();
 
  float get_gain() { return this->gain_; }
  void set_gain(float gain) { this->gain_ = clamp(gain, 0.0f, 1.0f); }
 
  bool is_playing() { return this->state_ != State::STOPPED; }
 
#ifdef USE_RTTTL_FINISHED_PLAYBACK_CALLBACK
  template<typename F> void add_on_finished_playback_callback(F &&callback) {
    this->on_finished_playback_callback_.add(std::forward<F>(callback));
  }
#endif
 
 protected:
  inline uint16_t get_integer_() {
    uint16_t ret = 0;
    while (isdigit(this->song_at_(this->position_))) {
      ret = (ret * 10) + (this->song_at_(this->position_++) - '0');
    }
    return ret;
  }
  char song_at_(size_t pos) const {
    if (pos >= this->song_len_)
      return '\0';
    return static_cast<char>(progmem_read_byte(reinterpret_cast<const uint8_t *>(this->song_) + pos));
  }
  size_t song_find_(char c, size_t from, size_t end) const;
  size_t song_find_control_(char key, size_t from, size_t end) const;
  void song_name_(char *buf, size_t size, size_t name_len) const;
  void set_song_(const char *song, size_t len);
  void start_();
  bool is_busy_() const;
  void finish_();
  void set_state_(State state);
 
  const char *song_{nullptr};
  std::string owned_song_;
  uint32_t last_note_start_time_;
  uint32_t output_freq_{0};
  float gain_{0.6f};
  uint16_t song_len_{0};
  uint16_t position_{0};
  uint16_t note_duration_{0};
  uint16_t wholenote_duration_;
  uint8_t default_note_denominator_{DEFAULT_NOTE_DENOMINATOR};
  uint8_t default_octave_{DEFAULT_OCTAVE};
  State state_{State::STOPPED};
 
#ifdef USE_OUTPUT
  output::FloatOutput *output_{nullptr};
#endif  // USE_OUTPUT
 
#ifdef USE_SPEAKER
  speaker::Speaker *speaker_{nullptr};
  uint32_t samples_per_wave_{0};
  uint32_t samples_sent_{0};
  uint32_t samples_count_{0};
  uint32_t samples_gap_{0};
#endif  // USE_SPEAKER
 
#ifdef USE_RTTTL_FINISHED_PLAYBACK_CALLBACK
  CallbackManager<void()> on_finished_playback_callback_;
#endif
 
  friend class testing::RtttlParserAccess;
};
 
}  // namespace esphome::rtttl