MD_MAX72xx.h

Go to the documentation of this file.

#pragma once
 
#if defined(__MBED__) && !defined(ARDUINO)
#include "mbed.h"
#define delay ThisThread::sleep_for
#ifndef PROGMEM
#define PROGMEM
#endif
#ifndef boolean
#define boolean bool
#endif
#ifndef bitRead
#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
#endif
#ifndef bitSet
#define bitSet(value, bit) ((value) |= (1UL << (bit)))
#endif
#ifndef bitClear
#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
#endif
#ifndef bitWrite
#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
#endif
#ifndef pgm_read_byte
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#endif
#ifndef pgm_read_word
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#endif
#ifndef pgm_read_dword
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#endif
#else
#include <Arduino.h>
#endif
#include <SPI.h>
 
#ifndef USE_LOCAL_FONT
#define USE_LOCAL_FONT 1
#endif
 
// Display parameter constants
// Defined values that are used throughout the library to define physical limits
#define ROW_SIZE      8   
#define COL_SIZE      8   
#define MAX_INTENSITY 0xf 
#define MAX_SCANLIMIT 7   
 
class MD_MAX72XX
{
  public:
    enum moduleType_t
    {
        GENERIC_HW,   
        FC16_HW,      
        PAROLA_HW,    
        ICSTATION_HW, 
 
        DR0CR0RR0_HW, 
        DR0CR0RR1_HW, 
        DR0CR1RR0_HW, 
        DR0CR1RR1_HW, 
        DR1CR0RR0_HW, 
        DR1CR0RR1_HW, 
        DR1CR1RR0_HW, 
        DR1CR1RR1_HW  
    };
 
#if USE_LOCAL_FONT
    typedef const uint8_t fontType_t;
#endif
 
    enum controlRequest_t
    {
        SHUTDOWN = 0,  
        SCANLIMIT = 1, 
        INTENSITY = 2, 
        TEST = 3,      
        DECODE = 4,    
        UPDATE = 10, 
        WRAPAROUND = 11 
    };
 
    enum controlValue_t
    {
        OFF = 0, 
        ON = 1   
    };
 
    enum transformType_t
    {
        TSL,  
        TSR,  
        TSU,  
        TSD,  
        TFLR, 
        TFUD, 
        TRC,  
        TINV  
    };
 
    MD_MAX72XX(moduleType_t mod, uint8_t dataPin, uint8_t clkPin, uint8_t csPin, uint8_t numDevices = 1);
 
    MD_MAX72XX(moduleType_t mod, uint8_t csPin, uint8_t numDevices = 1);
 
    MD_MAX72XX(moduleType_t mod, SPIClass &spi, uint8_t csPin, uint8_t numDevices = 1);
 
    void begin(void);
 
    ~MD_MAX72XX();
 
    //--------------------------------------------------------------
    bool control(uint8_t dev, controlRequest_t mode, int value);
 
    inline void control(controlRequest_t mode, int value)
    {
        control(0, getDeviceCount() - 1, mode, value);
    };
 
    bool control(uint8_t startDev, uint8_t endDev, controlRequest_t mode, int value);
 
    uint8_t getDeviceCount(void)
    {
        return (_maxDevices);
    };
 
    uint16_t getColumnCount(void)
    {
        return (_maxDevices * COL_SIZE);
    };
 
    void setModuleType(moduleType_t mod)
    {
        setModuleParameters(mod);
    };
 
    void setShiftDataInCallback(uint8_t (*cb)(uint8_t dev, transformType_t t))
    {
        _cbShiftDataIn = cb;
    };
 
    void setShiftDataOutCallback(void (*cb)(uint8_t dev, transformType_t t, uint8_t colData))
    {
        _cbShiftDataOut = cb;
    };
 
    //--------------------------------------------------------------
    inline void clear(void)
    {
        clear(0, getDeviceCount() - 1);
    };
 
    void clear(uint8_t startDev, uint8_t endDev);
 
    bool getBuffer(uint16_t col, uint8_t size, uint8_t *pd);
 
    uint8_t getColumn(uint8_t c)
    {
        return getColumn((c / COL_SIZE), c % COL_SIZE);
    };
 
    bool getPoint(uint8_t r, uint16_t c);
 
    bool setBuffer(uint16_t col, uint8_t size, uint8_t *pd);
 
    bool setColumn(uint16_t c, uint8_t value)
    {
        // c = c + 1 > COL_SIZE - 1 ? 0 : c + 1;
        return setColumn((c / COL_SIZE), c % COL_SIZE, value);
    };
 
    bool setPoint(uint8_t r, uint16_t c, bool state);
 
    inline bool setRow(uint8_t r, uint8_t value)
    {
        return setRow(0, getDeviceCount() - 1, r, value);
    };
 
    bool setRow(uint8_t startDev, uint8_t endDev, uint8_t r, uint8_t value);
 
    inline bool transform(transformType_t ttype)
    {
        return transform(0, getDeviceCount() - 1, ttype);
    };
 
    bool transform(uint8_t startDev, uint8_t endDev, transformType_t ttype);
 
    void update(controlValue_t mode)
    {
        control(UPDATE, mode);
    };
 
    void update(void)
    {
        flushBufferAll();
    };
 
    void wraparound(controlValue_t mode)
    {
        control(WRAPAROUND, mode);
    };
    //--------------------------------------------------------------
    bool clear(uint8_t buf);
 
    uint8_t getColumn(uint8_t buf, uint8_t c);
 
    uint8_t getRow(uint8_t buf, uint8_t r);
 
    bool setColumn(uint8_t buf, uint8_t c, uint8_t value);
 
    bool setRow(uint8_t buf, uint8_t r, uint8_t value);
 
    bool transform(uint8_t buf, transformType_t ttype);
 
    void update(uint8_t buf)
    {
        flushBuffer(buf);
    };
#if USE_LOCAL_FONT
    //--------------------------------------------------------------
    uint8_t getChar(uint16_t c, uint8_t size, uint8_t *buf);
 
    uint8_t setChar(uint16_t col, uint16_t c);
 
    bool setFont(fontType_t *f);
 
    uint8_t getMaxFontWidth(void)
    {
        return (_fontInfo.widthMax);
    };
 
    uint8_t getFontHeight(void)
    {
        return (_fontInfo.height);
    };
 
    fontType_t *getFont(void)
    {
        return (_fontData);
    };
#endif // USE_LOCAL_FONT
  private:
    typedef struct
    {
        uint8_t dig[ROW_SIZE]; // data for each digit of the MAX72xx (DIG0-DIG7)
        uint8_t changed;       // one bit for each digit changed ('dirty bit')
    } deviceInfo_t;
 
    // LED module wiring parameters defined by hardware type
    moduleType_t _mod; // The module type from the available list
    bool _hwDigRows;   // MAX72xx digits are mapped to rows in on the matrix
    bool _hwRevCols;   // Normal orientation is col 0 on the right. Set to true if reversed
    bool _hwRevRows;   // Normal orientation is row 0 at the top. Set to true if reversed
 
    uint8_t _dataPin;  // DATA is shifted out of this pin ...
    uint8_t _clkPin;   // ... signaled by a CLOCK on this pin ...
    uint8_t _csPin;    // ... and LOADed when the chip select pin is driven HIGH to LOW
    bool _hardwareSPI; // true if SPI interface is the hardware interface
    SPIClass &_spiRef; // reference to the SPI object to use for hardware comms
 
    // Device buffer data
    uint8_t _maxDevices;    // maximum number of devices in use
    deviceInfo_t *_matrix;  // the current status of the LED matrix (buffers) 
    uint8_t *_spiData;      // data buffer for writing to SPI interface
 
    // User callback function for shifting operations
    uint8_t (*_cbShiftDataIn)(uint8_t dev, transformType_t t);
    void (*_cbShiftDataOut)(uint8_t dev, transformType_t t, uint8_t colData);
 
    // Control data for the library
    bool _updateEnabled; // update the display when this is true, suspend otherwise
    bool _wrapAround;    // when shifting, wrap left to right and vice versa (circular buffer)
 
    // SPI interface data
#if defined(__MBED__) && !defined(ARDUINO)
    SPI _spi; // Mbed SPI object
    DigitalOut _cs;
#endif
 
#if USE_LOCAL_FONT
    // Font properties info structure
    typedef struct
    {
        uint8_t version;     // (v1) font definition version number (for compliance)
        uint8_t height;      // (v1) font height in pixels
        uint8_t widthMax;    // (v1) font maximum width in pixels (widest character)
        uint16_t firstASCII; // (v1,2) the first character code in the font table
        uint16_t lastASCII;  // (v1,2) the last character code in the font table
        uint16_t dataOffset; // (v1) offset from the start of table to first character definition
    } fontInfo_t;
 
    // Font related data
    fontType_t *_fontData; // pointer to the current font data being used
    fontInfo_t _fontInfo;  // properties of the current font table
 
    void setFontInfoDefault(void);         // set the default parameters for the font info file
    void loadFontInfo(void);               // load the font info block from the font data
    uint8_t getFontWidth(void);            // get the maximum font width by inspecting the font table
    int32_t getFontCharOffset(uint16_t c); // find the character in the font data. If not there, return -1
#endif
 
    // Private functions
    void spiSend(void);                                                  // do the actual physical communications task
    inline void spiClearBuffer(void);                                    // clear the SPI send buffer
    void controlHardware(uint8_t dev, controlRequest_t mode, int value); // set hardware control commands
    void controlLibrary(controlRequest_t mode, int value);               // set internal control commands
 
    void flushBuffer(uint8_t buf); // determine what needs to be sent for one device and transmit
    void flushBufferAll(void);     // determine what needs to be sent for all devices and transmit
 
    uint8_t bitReverse(uint8_t b);                            // reverse the order of bits in the byte
    bool transformBuffer(uint8_t buf, transformType_t ttype); // internal transform function
 
    bool copyRow(uint8_t buf, uint8_t rSrc, uint8_t rDest);    // copy a row from Src to Dest
    bool copyColumn(uint8_t buf, uint8_t cSrc, uint8_t cDest); // copy a row from Src to Dest
 
    void setModuleParameters(moduleType_t mod); // setup parameters based on module type
 
    // _hwDigRev switched function for internal use
    bool copyC(uint8_t buf, uint8_t cSrc, uint8_t cDest);
    bool copyR(uint8_t buf, uint8_t rSrc, uint8_t rDest);
    uint8_t getC(uint8_t buf, uint8_t c);
    uint8_t getR(uint8_t buf, uint8_t r);
    bool setC(uint8_t buf, uint8_t c, uint8_t value);
    bool setR(uint8_t buf, uint8_t r, uint8_t value);
 
    void printBinary(uint8_t inByte);
};