LinuxPWM.hxx

Go to the documentation of this file.

 
#ifndef _OS_LINUXPWM_HXX_
#define _OS_LINUXPWM_HXX_
 
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
 
#include "freertos_drivers/common/PWM.hxx"
#include "utils/FileUtils.hxx"
#include "utils/StringPrintf.hxx"
#include "utils/format_utils.hxx"
 
class LinuxPWM : public PWM
{
public:
    LinuxPWM(int chip, int channel)
        : chip_(chip)
        , channel_(channel)
        , pwmdir_(
              StringPrintf("/sys/class/pwm/pwmchip%d/pwm%d/", chip, channel))
    {
    }
 
    void export_pin()
    {
        if (access((pwmdir_ + PERIOD_FILE).c_str(), F_OK) != -1)
        {
            set_period(1);
            return;
        }
 
        string export_file =
            StringPrintf("/sys/class/pwm/pwmchip%d/export", chip_);
        if (access(export_file.c_str(), W_OK) < 0) 
        {
            int err = errno;
            LOG_ERROR("Cannot write to %s: %s\n",export_file.c_str(),
                      strerror(errno));
            exit(err);
        }
        write_string_to_file(export_file, integer_to_string(channel_) + "\n");
        // 50ms delay IS needed while kernel changes ownership of created GPIO directory
        usleep(50000); 
        set_period(1);
    }
 
    void set_period(uint32_t counts) override
    {
 
        set_sysfs_file_value(PERIOD_FILE, counts);
        if (counts > 0)
        {
 
 
            enable();
        }
        else
        {
            disable();
        }
    }
 
    uint32_t get_period() override
    {
 
        return get_sysfs_file_value(PERIOD_FILE);
 
    }
 
    void set_duty(uint32_t counts) override
    {
 
        set_sysfs_file_value(DUTY_CYCLE_FILE, counts);
        if (counts > 0)
        {
 
            enable();
        }
        else
        {
            disable();
        }
    }
 
    uint32_t get_duty() override
    {
 
        return get_sysfs_file_value(DUTY_CYCLE_FILE);
 
    }
 
    uint32_t get_period_max() override
    {
        return 0xffffffff;
    }
 
    uint32_t get_period_min() override
    {
        return 1;
    }
 
 
    void enable()
    {
        set_sysfs_file_value(ENABLE_FILE, 1);
    }
 
    void disable()
    {
        set_sysfs_file_value(ENABLE_FILE, 0);
    }
 
    bool enabled()
    {
        return get_sysfs_file_value(ENABLE_FILE) == 1;
 
 
    }
 
private:
    static constexpr const char *ENABLE_FILE = "enable";
    static constexpr const char *PERIOD_FILE = "period";
    static constexpr const char *DUTY_CYCLE_FILE = "duty_cycle";
 
    const uint32_t chip_;
    const uint32_t channel_;
    const string pwmdir_;
 
    uint32_t get_sysfs_file_value(const char *basename)
    {
        string filename(pwmdir_);
        filename += basename;
        uint32_t value = 0;
        FILE *fp = fopen(filename.c_str(), "r");
        if (fp == NULL)
        {
            int err = errno;
            LOG_ERROR("Cannot read from %s: %s\n",filename.c_str(),
                      strerror(errno));
            exit(err);
        }
        fscanf(fp, "%d", &value);
        fclose(fp);
        return value;
    }
 
    void set_sysfs_file_value(const char *basename, uint32_t value)
    {
        string filename(pwmdir_);
        filename += basename;
        FILE *fp = fopen(filename.c_str(), "w");
        if (fp == NULL)
        {
            int err = errno;
            LOG_ERROR("Cannot write to %s: %s\n",filename.c_str(),
                      strerror(errno));
            exit(err);
        }
        fprintf(fp, "%d\n", value);
 
        fclose(fp);
    }
};
 
#endif // _OS_LINUXPWM_HXX_