bsp_pwm.hpp

#pragma once
 
#include <unistd.h>
 
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <semaphore>
#include <string>
#include <thread>
 
class PWM {
 public:
  // NOLINTNEXTLINE
  enum class NoteName { C = 0, Cs, D, Ds, E, F, Fs, G, Gs, A, As, B };
 
  PWM(int channel, int frequency_hz = 1000, float duty_percent = 0.0f,
      int chip = 2)
      : channel_(channel), period_ns_(static_cast<int>(1e9 / frequency_hz)) {
    chip_path_ = "/sys/class/pwm/pwmchip" + std::to_string(chip);
    pwm_path_ = chip_path_ + "/pwm" + std::to_string(channel);
 
    // Export the PWM channel if it has not been exported yet.
    if (access(pwm_path_.c_str(), F_OK) != 0) {
      FILE* fp = fopen((chip_path_ + "/export").c_str(), "w");
      if (fp) {
        (void)(fprintf(fp, "%d", channel));
        (void)(fclose(fp));
        usleep(100000);  // Allow sysfs to initialize.
      }
    }
 
    WriteSysfs(pwm_path_ + "/period", period_ns_);
    SetDutyCycle(duty_percent);
    Enable();
 
    // Launch background thread to play notes asynchronously.
    note_thread_ = std::thread([this]() {
      while (true) {
        note_sem_.acquire();
        float midi = static_cast<float>(note_) +
                     (static_cast<float>(octave_) + 1.0f) * 12.0f;
        float freq = 440.0f * std::pow(2.0f, (midi - 69.0f) / 12.0f);
        Beep(static_cast<uint32_t>(freq), duration_ms_);
      }
    });
  }
 
  ~PWM() { Disable(); }
 
  void SetFrequency(uint32_t hz) {
    period_ns_ = static_cast<int>(1e9 / hz);
    WriteSysfs(pwm_path_ + "/period", period_ns_);
  }
 
  void SetDutyCycle(float percent) {
    int duty_ns = static_cast<int>(percent * static_cast<float>(period_ns_));
    WriteSysfs(pwm_path_ + "/duty_cycle", duty_ns);
  }
 
  void Enable() { WriteSysfs(pwm_path_ + "/enable", 1); }
 
  void Disable() { WriteSysfs(pwm_path_ + "/enable", 0); }
 
  void Beep(uint32_t freq, uint32_t duration_ms) {
    SetFrequency(freq);
    SetDutyCycle(0.5f);
    Enable();
    usleep(duration_ms * 1000);
    Disable();
  }
 
  void PlayNote(NoteName note, uint32_t octave, uint32_t duration_ms) {
    note_ = note;
    octave_ = octave;
    duration_ms_ = duration_ms;
    note_sem_.release();
  }
 
  void SetAlarmConfig(uint32_t freq, uint32_t duration_ms, uint32_t delay_ms) {
    alarm_freq_ = freq;
    alarm_duration_ = duration_ms;
    alarm_delay_ = delay_ms;
  }
 
  void TriggerAlarm() {
    Beep(alarm_freq_, alarm_duration_);
    usleep(alarm_delay_ * 1000);
  }
 
 private:
  std::string chip_path_;  
  std::string pwm_path_;   
  int period_ns_;          
  int channel_;            
 
  uint32_t alarm_freq_ = 1500;     
  uint32_t alarm_duration_ = 300;  
  uint32_t alarm_delay_ = 300;     
 
  std::thread note_thread_;            
  NoteName note_;                      
  uint32_t octave_;                    
  uint32_t duration_ms_;               
  std::binary_semaphore note_sem_{0};  
 
  int WriteSysfs(const std::string& path, int value) const {
    FILE* fp = fopen(path.c_str(), "w");
    if (!fp) {
      return -1;
    }
    int result = fprintf(fp, "%d", value);
    (void)(fclose(fp));
    return result;
  }
};