PCA9685PWM.hxx

Go to the documentation of this file.

 
#include <fcntl.h>
#include <unistd.h>
#include "stropts.h"
#include "i2c.h"
#include "i2c-dev.h"
 
#include "PWM.hxx"
 
 
#include "os/OS.hxx"
 
class PCA9685PWMBit;
 
class PCA9685PWM : public OSThread
{
public:
    static constexpr size_t NUM_CHANNELS = 16;
 
    static constexpr size_t MAX_PWM_COUNTS = 4096;
 
    PCA9685PWM()
        : sem_(0)
        , i2c_(-1)
        , dirty_(0)
        , i2cAddress_(0)
    {
        duty_.fill(0);
    }
 
    void init(const char * name, uint8_t i2c_address,
              uint16_t pwm_freq = 200, int32_t external_clock_freq = -1)
    {
        uint32_t clock_freq = external_clock_freq >= 0 ? external_clock_freq :
                                                         25000000;
        i2cAddress_ = i2c_address;
 
        i2c_ = ::open(name, O_RDWR);
        HASSERT(i2c_ >= 0);
        ::ioctl(i2c_, I2C_SLAVE, i2cAddress_);
 
        HASSERT(clock_freq <= 50000000);
        HASSERT(pwm_freq < (clock_freq / (4096 * 4)));
 
        Mode1 mode1;
        mode1.aI = 1;
        mode1.sleep = 1;
        mode1.allCall = 0;
        register_write(MODE1, mode1.byte);
 
        uint8_t prescaler = (clock_freq / (4096 * (uint32_t)pwm_freq)) - 1;
        register_write(PRE_SCALE, prescaler);
 
        if (external_clock_freq < 0)
        {
            /* if using internal clock */
            mode1.sleep = 0;
            register_write(MODE1, mode1.byte);
        }
 
        Mode2 mode2;
        mode2.och = 1;
        register_write(MODE2, mode2.byte);
 
        /* start the thread at the highest priority in the system */
        start(name, configMAX_PRIORITIES - 1, 1024);
    }
 
    ~PCA9685PWM()
    {
    }
 
private:
    enum Registers
    {
        MODE1 = 0, 
        MODE2, 
 
        LED0_ON_L = 6, 
 
        PRE_SCALE = 254, 
    };
 
    union Mode1
    {
        Mode1()
            : byte(0x01)
        {
        }
 
        uint8_t byte; 
        struct
        {
            uint8_t allCall : 1; 
            uint8_t sub3    : 1; 
            uint8_t sub2    : 1; 
            uint8_t sub1    : 1; 
            uint8_t sleep   : 1; 
            uint8_t aI      : 1; 
            uint8_t extClk  : 1; 
            uint8_t restart : 1; 
        };
    };
 
    union Mode2
    {
        Mode2()
            : byte(0x04)
        {
        }
 
        uint8_t byte; 
        struct
        {
            uint8_t outNE  : 2; 
            uint8_t outDrv : 1; 
            uint8_t och    : 1; 
            uint8_t invert : 1; 
            uint8_t unused : 3; 
        };
    };
 
    struct LedCtl
    {
        union On
        {
            On()
                : word(0x0000)
            {
            }
            uint16_t word; 
            struct
            {
                uint16_t counts : 12; 
                uint16_t fullOn :  1; 
                uint16_t unused :  3; 
            };
        };
        union Off
        {
            Off()
                : word(0x1000)
            {
            }
            uint16_t word; 
            struct
            {
                uint16_t counts  : 12; 
                uint16_t fullOff :  1; 
                uint16_t unused  :  3; 
            };
        };
        On on; 
        Off off; 
    };
 
    void *entry() override;
 
    void bit_modify(Registers address, uint8_t data, uint8_t mask)
    {
        uint8_t addr = address;
        uint8_t rd_data;
        struct i2c_msg msgs[] =
        {
            {
                .addr = i2cAddress_,
                .flags = 0,
                .len = 1,
                .buf = &addr
            },
            {
                .addr = i2cAddress_,
                .flags = I2C_M_RD,
                .len = 1,
                .buf = &rd_data
            }
        };
        
        struct i2c_rdwr_ioctl_data ioctl_data =
            {.msgs = msgs, .nmsgs = ARRAYSIZE(msgs)};
 
        ::ioctl(i2c_, I2C_RDWR, &ioctl_data);
 
        rd_data &= ~mask;
        rd_data |= (data & mask);
 
        register_write(address, rd_data);
    }
 
    void set_pwm_duty(unsigned channel, uint16_t counts)
    {
        HASSERT(channel < NUM_CHANNELS);
        duty_[channel] = counts;
 
        portENTER_CRITICAL();
        dirty_ |= 0x1 << channel;
        portEXIT_CRITICAL();
 
        sem_.post();
    }
 
    uint16_t get_pwm_duty(unsigned channel)
    {
        HASSERT(channel < NUM_CHANNELS);
        return duty_[channel];
    }
 
    void write_pwm_duty(unsigned channel, uint16_t counts)
    {
        LedCtl ctl;
        if (counts >= MAX_PWM_COUNTS)
        {
            ctl.on.fullOn = 1;
            ctl.off.fullOff = 0;
        }
        else if (counts == 0)
        {
            ctl.on.fullOn = 0;
            ctl.off.fullOff = 1;
        }
        else
        {
            // the "256" count offset is to help average the current accross
            // all 16 channels when the duty cycle is low
            ctl.on.counts = (channel * 256);
            ctl.off.counts = (counts + (channel * 256)) % 0x1000;
        }
 
        htole16(ctl.on.word);
        htole16(ctl.off.word);
 
        Registers offset = (Registers)(LED0_ON_L + (channel * 4));
        register_write_multiple(offset, &ctl, sizeof(ctl));
    }
 
    void register_write(Registers address, uint8_t data)
    {
        uint8_t payload[] = {address, data};
        ::write(i2c_, payload, sizeof(payload));
    }
 
    void register_write_multiple(Registers address, void *data, size_t count)
    {
        uint8_t payload[count + 1];
        payload[0] = address;
        memcpy(payload + 1, data, count);
        ::write(i2c_, payload, sizeof(payload));
    }
 
    friend PCA9685PWMBit;
 
    OSSem sem_;
 
    int i2c_;
 
    std::array<uint16_t, NUM_CHANNELS> duty_;
 
    uint16_t dirty_;
 
    uint8_t i2cAddress_;
 
    DISALLOW_COPY_AND_ASSIGN(PCA9685PWM);
};
 
class PCA9685PWMBit : public PWM
{
public:
    PCA9685PWMBit(PCA9685PWM *instance, unsigned index)
        : PWM()
        , instance_(instance)
        , index_(index)
    {
        HASSERT(index < PCA9685PWM::NUM_CHANNELS);
    }
 
    ~PCA9685PWMBit()
    {
    }
 
private:
    void set_period(uint32_t counts) override
    {
        HASSERT(counts == PCA9685PWM::MAX_PWM_COUNTS);
    };
 
    uint32_t get_period() override
    {
        return PCA9685PWM::MAX_PWM_COUNTS;
    }
 
    void set_duty(uint32_t counts) override
    {
        instance_->set_pwm_duty(index_, counts);
    }
 
    uint32_t get_duty() override
    {
        return instance_->get_pwm_duty(index_);
    }
 
    uint32_t get_period_max() override
    {
        return get_period();
    }
 
    uint32_t get_period_min() override
    {
        return get_period();
    }
 
    PCA9685PWM *instance_;
 
    unsigned index_;
 
    DISALLOW_COPY_AND_ASSIGN(PCA9685PWMBit);
};