SN74HC595GPO.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_COMMON_SN74HC595GPO_HXX_
#define _FREERTOS_DRIVERS_COMMON_SN74HC595GPO_HXX_
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <fcntl.h>
#include <unistd.h>
 
#include "SPI.hxx"
 
#include "os/Gpio.hxx"
#include "os/OS.hxx"
 
template <uint8_t N = 1> class SN74HC595GPO;
 
template <uint8_t N = 1> class SN74HC595 : public OSThread
{
public:
    SN74HC595(void (*request_refresh_operation)(void))
        : requestRefreshOperation_(request_refresh_operation)
        , spiFd_(-1)
        , sem_()
        , ioPending_(false)
    {
        HASSERT(N > 0);
        for (unsigned i = 0; i < N; ++i)
        {
            gpoData_[i] = 0;
        }
    }
 
    void init(const char *spi_name, int priority = get_priority_max())
    {
        spiFd_ = ::open(spi_name, O_WRONLY);
        HASSERT(spiFd_ >= 0);
 
        // configure SPI bus settings
        uint8_t spi_mode = SPI_MODE_0;
        uint8_t spi_bpw = 8;
        uint32_t spi_max_speed_hz = SPI_MAX_SPEED_HZ;
        ::ioctl(spiFd_, SPI_IOC_WR_MODE, &spi_mode);
        ::ioctl(spiFd_, SPI_IOC_WR_BITS_PER_WORD, &spi_bpw);
        ::ioctl(spiFd_, SPI_IOC_WR_MAX_SPEED_HZ, &spi_max_speed_hz);
 
        requestRefreshOperation_();
 
        // start the thread at the highest priority in the system
        start("SN74HC595", priority, 384 + N);
    }
 
    void refresh(bool from_isr = false)
    {
        if (!ioPending_)
        {
            ioPending_ = true;
            if (from_isr)
            {
                int woken;
                sem_.post_from_isr(&woken);
            }
            else
            {
                sem_.post();
            }
        }
    }
 
private:
    static constexpr uint32_t SPI_MAX_SPEED_HZ = 4000000;
 
    void *entry() override
    {
        for ( ; /* forever */ ; )
        {
            sem_.wait();
            if (ioPending_)
            {
                ioPending_ = false;
                uint8_t data[N];
                for (unsigned i = 0; i < N; ++i)
                {
                    data[i] = gpoData_[i];
                }
                ::write(spiFd_, data, N);
            }
        }
    }
 
    void (*requestRefreshOperation_)(void);
 
    int spiFd_; 
    OSSem sem_; 
    uint8_t ioPending_ : 1; 
 
    std::atomic<uint8_t> gpoData_[N];
 
    friend class SN74HC595GPO<N>;
 
    DISALLOW_COPY_AND_ASSIGN(SN74HC595);
};
 
template <uint8_t N> class SN74HC595GPO : public Gpio
{
public:
    constexpr SN74HC595GPO(SN74HC595<N> *instance, uint8_t chip_index, uint8_t bit)
        : Gpio()
        , instance_(instance)
        , chipIndex_(chip_index)
        , bit_(bit)
    {
#ifndef __PIC32MX__
        HASSERT(bit < 8);
        HASSERT(chip_index < sizeof(instance->gpoData_));
        HASSERT(N == sizeof(instance->gpoData_));
#endif
    }
 
    void write(Value new_state) const override
    {
        new_state ? set() : clr();
    }
 
    Value read() const override
    {
        return instance_->gpoData_[chipIndex_] & (0x1 << bit_) ?
                   Gpio::SET : Gpio::CLR;
    }
 
    void set() const override
    {
        if (!(instance_->gpoData_[chipIndex_] & (0x1 << bit_)))
        {
            instance_->gpoData_[chipIndex_] |= 0x1 << bit_;
            instance_->requestRefreshOperation_();
        }
    }
 
    void clr() const override
    {
        if ((instance_->gpoData_[chipIndex_] & (0x1 << bit_)))
        {
            instance_->gpoData_[chipIndex_] &= ~(0x1 << bit_);
            instance_->requestRefreshOperation_();
        }
    }
 
    void set_direction(Gpio::Direction dir) const override
    {
        HASSERT(dir == Gpio::Direction::DOUTPUT);
    }
 
    Direction direction() const override
    {
        return Gpio::Direction::DOUTPUT;
    }
 
private:
    SN74HC595<N> * const instance_;
 
    const uint8_t chipIndex_;
 
    const uint8_t bit_;
 
    DISALLOW_COPY_AND_ASSIGN(SN74HC595GPO);
};
 
#endif // _FREERTOS_DRIVERS_COMMON_SN74HC595GPO_HXX_