max72xx.h

Go to the documentation of this file.

 
#pragma once
 
#include <PropWare/serial/spi/spi.h>
 
namespace PropWare {
 
class MAX72xx {
    public:
        // Addresses start at 0x10 to avoid conflicts with MAX695x devices
        enum class Register {                    NO_OP,                                                       DIGIT_ZERO   = 0x11,                                                   DIGIT_ONE    = 0x12,                                                   DIGIT_TWO    = 0x13,                                                   DIGIT_THREE  = 0x14,                                                   DIGIT_FOUR   = 0x15,                                                   DIGIT_FIVE   = 0x16,                                                   DIGIT_SIX    = 0x17,                                                      DIGIT_SEVEN  = 0x18, DECODE_MODE  = 0x19,                                  INTENSITY    = 0x1A,                                    SCAN_LIMIT   = 0x1B,                               SHUTDOWN     = 0x1C,                                 DISPLAY_TEST = 0x1D
        };
 
        enum class BcdCharacter {
                ZERO,
                ONE,
                TWO,
                THREE,
                FOUR,
                FIVE,
                SIX,
                SEVEN,
                EIGHT,
                NINE,
                DASH,
                E,
                H,
                L,
                P,
                BLANK
        };
 
        static const SPI::Mode SPI_MODE                = SPI::Mode::MODE_1;
        static const uint8_t   DEFAULT_INTENSITY       = 15;
        static const uint8_t   DEFAULT_SCAN_LIMIT      = 7;
        static const uint8_t   DEFAULT_BCD_DECODE_BITS = 0xFF;
        static const uint8_t   DECIMAL_POINT           = BIT_7;
 
    public:
        static Register to_register (unsigned int zeroIndexedDigit) {
            return static_cast<Register>(static_cast<unsigned int>(Register::DIGIT_ZERO) + zeroIndexedDigit);
        }
 
    public:
        MAX72xx (SPI &bus, const Pin::Mask csMask, const bool alwaysSetSPIMode = false)
            : m_bus(&bus),
              m_cs(csMask, Pin::Dir::OUT),
              m_alwaysSetMode(alwaysSetSPIMode) {
            if (!alwaysSetSPIMode)
                this->m_bus->set_mode(SPI_MODE);
            this->m_cs.set();
        }
 
        MAX72xx (const Pin::Mask csMask, const bool alwaysSetSPIMode = true)
            : m_bus(&SPI::get_instance()),
              m_cs(csMask, Pin::Dir::OUT),
              m_alwaysSetMode(alwaysSetSPIMode) {
            if (!alwaysSetSPIMode)
                this->m_bus->set_mode(SPI::Mode::MODE_1);
            this->m_cs.set();
        }
 
        void always_set_spi_mode (const bool alwaysSetMode) {
            this->m_alwaysSetMode = alwaysSetMode;
        }
 
        void start (const uint8_t intensity = DEFAULT_INTENSITY, const uint8_t scanLimit = DEFAULT_SCAN_LIMIT,
                    const uint8_t bcdDecodeBits = DEFAULT_BCD_DECODE_BITS) const {
            this->set_intensity(intensity);
            this->set_scan_limit(scanLimit);
            this->set_decode_mode(bcdDecodeBits);
            this->set_test_mode(false);
            this->clear();
            this->write(Register::SHUTDOWN, 1);
        }
 
        void shutdown () const {
            this->write(Register::SHUTDOWN, 0);
        }
 
        void set_intensity (const uint8_t intensity) const {
            if (16 > intensity)
                this->write(Register::INTENSITY, intensity);
        }
 
        void set_scan_limit (const uint8_t scanLimit) const {
            if (8 > scanLimit)
                this->write(Register::SCAN_LIMIT, scanLimit);
        }
 
        void set_decode_mode (const uint8_t bcdDecodeBits) const {
            this->write(Register::DECODE_MODE, bcdDecodeBits);
        }
 
        void set_test_mode (const bool enableTestMode) const {
            this->write(Register::DISPLAY_TEST, static_cast<const uint8_t>(enableTestMode));
        }
 
        void put_int (int32_t x, const BcdCharacter fillChar = BcdCharacter::BLANK, unsigned int width = 0) const {
            if (width > 8)
                width = 8;
 
            const bool isNegative = 0 > x;
            if (isNegative) {
                x = abs(x);
            }
 
            uint_fast8_t i = 0;
            do {
                const uint8_t digit = static_cast<const uint8_t>(x % 10);
                if (x)
                    this->write(to_register(i), digit);
                x /= 10;
                ++i;
            } while (x && 8 > i);
 
            if (isNegative) {
                if (width)
                    --width;
                while (width > i) {
                    this->write(to_register(i++), static_cast<const uint8_t>(fillChar));
                }
                if (8 > i)
                    this->write(to_register(i), static_cast<const uint8_t>(BcdCharacter::DASH));
            } else {
                while (width > i) {
                    this->write(to_register(i), static_cast<const uint8_t>(fillChar));
                    ++i;
                }
            }
        }
 
        void clear () const {
            for (uint8_t i = 0; i < 8; ++i)
                this->write(to_register(i), static_cast<const uint8_t>(BcdCharacter::BLANK));
        }
 
        void write (const Register address, const uint8_t value, const bool decimal = false) const {
            if (this->m_alwaysSetMode)
                this->m_bus->set_mode(SPI_MODE);
 
            this->m_cs.clear();
            this->m_bus->shift_out(8, static_cast<uint32_t>(address));
            if (decimal)
                this->m_bus->shift_out(8, value | DECIMAL_POINT);
            else
                this->m_bus->shift_out(8, value);
            this->m_cs.set();
        }
 
    private:
        SPI       *m_bus;
        const Pin m_cs;
        bool      m_alwaysSetMode;
};
 
}