max72xx_matrix.h

// max72xx_matrix.h - 8x8 led matrix controller by MAX7219 or MAX7221 module driver
 
#pragma once
 
#include <Adafruit_GFX.h>
#include "max72xx.h"
 
namespace ustd {
 
class Max72xxMatrix : public Adafruit_GFX {
  private:
    // hardware configuration
    Max72XX driver;
 
    // runtime - pixel and module logic
    uint8_t hDisplays;
    uint8_t *bitmap;
    uint8_t bitmapSize;
    uint8_t *matrixPosition;
    uint8_t *matrixRotation;
    uint8_t *outputBuffer;
 
  public:
    Max72xxMatrix(uint8_t csPin, uint8_t hDisplays = 1, uint8_t vDisplays = 1, uint8_t rotation = 0)
        : Adafruit_GFX(hDisplays << 3, vDisplays << 3), driver(csPin, hDisplays * vDisplays),
          hDisplays(hDisplays) {
        uint8_t displays = hDisplays * vDisplays;
        bitmapSize = displays * 8;
        bitmap = (uint8_t *)malloc(bitmapSize + (4 * displays));
        matrixPosition = bitmap + bitmapSize;
        matrixRotation = matrixPosition + displays;
        outputBuffer = matrixRotation + displays;
 
        for (uint8_t display = 0; display < displays; display++) {
            matrixPosition[display] = display;
            matrixRotation[display] = rotation;
        }
    }
 
    virtual ~Max72xxMatrix() {
        free(bitmap);
    }
 
    void begin() {
        if (bitmap != nullptr) {
            // Initialize hardware
            driver.begin();
            driver.setTestMode(false);
            driver.setScanLimit(8);
            driver.setDecodeMode(B00000000);
 
            // Clear the display
            fillScreen(0);
            write();
        }
    }
 
    inline void setPowerSave(bool powersave) {
        driver.setPowerSave(powersave);
    }
 
    inline void setIntensity(uint8_t intensity) {
        driver.setIntensity(intensity);
    }
 
    inline void setTestMode(bool testmode) {
        driver.setTestMode(testmode);
    }
 
    void write() {
        if (bitmap != nullptr) {
            for (uint8_t opcode = Max72XX::digit7; opcode >= Max72XX::digit0; opcode--) {
                uint16_t endOffset = opcode - Max72XX::digit0;
                uint16_t startOffset = bitmapSize + endOffset;
                uint8_t *pPtr = outputBuffer;
                do {
                    startOffset -= 8;
                    pPtr[0] = opcode;
                    pPtr[1] = bitmap[startOffset];
                    pPtr += 2;
                } while (startOffset > endOffset);
                driver.sendBlock(outputBuffer, bitmapSize / 4);
            }
        }
    }
 
    void setPosition(uint8_t display, uint8_t x, uint8_t y) {
        if (bitmap != nullptr) {
            matrixPosition[x + hDisplays * y] = display;
        }
    }
 
    void setRotation(uint8_t display, uint8_t rotation) {
        if (bitmap != nullptr) {
            matrixRotation[display] = rotation;
        }
    }
 
    inline bool getTextWrap() const {
        return wrap;
    }
 
    inline int16_t getCursorX() const {
        return cursor_x;
    }
 
    inline int16_t getCursorY() const {
        return cursor_y;
    };
 
    void getCharBounds(unsigned char c, int16_t *x, int16_t *y, int16_t *minx, int16_t *miny,
                       int16_t *maxx, int16_t *maxy) {
        charBounds(c, x, y, minx, miny, maxx, maxy);
    }
 
    bool printFormatted(int16_t x, int16_t y, int16_t w, int16_t align, String content,
                        uint8_t baseLine, uint8_t yAdvance = 0) {
        int16_t xx = 0, yy = 0;
        uint16_t ww = 0, hh = 0;
        bool old_wrap = wrap;
        wrap = false;
        getTextBounds(content, 0, 0, &xx, &yy, &ww, &hh);
        wrap = old_wrap;
 
        switch (align) {
        default:
        case 0:
            // left
            xx = 0;
            break;
        case 1:
            // center
            xx = (w - ww) / 2;
            break;
        case 2:
            // right
            xx = w - ww;
            break;
        }
        if (yAdvance && (hh % yAdvance)) {
            hh = ((hh / yAdvance) + 1) * yAdvance;
        }
        GFXcanvas1 tmp(w, hh);
        if (gfxFont) {
            tmp.setFont(gfxFont);
        }
        tmp.fillScreen(textbgcolor);
        tmp.setTextWrap(false);
        tmp.setCursor(xx, baseLine ? baseLine : -1 * yy);
        tmp.setTextColor(textcolor, textbgcolor);
        tmp.print(content);
        // fillRect(x, y, w, hh, textbgcolor);
        drawBitmap(x, y, tmp.getBuffer(), w, hh, textcolor, textbgcolor);
        // set cursor after last printed character
        setCursor(x + tmp.getCursorX(), y + (baseLine ? baseLine : -1 * yy));
        return w >= (int16_t)ww;
    }
 
  public:
    // overrides of virtual functions
 
    virtual void fillScreen(uint16_t color) {
        if (bitmap != nullptr) {
            memset(bitmap, color ? 0xff : 0, bitmapSize);
        }
    }
 
    void drawPixel(int16_t xx, int16_t yy, uint16_t color) {
        if (bitmap == nullptr) {
            return;
        }
 
        // Operating in bytes is faster and takes less code to run. We don't
        // need values above 200, so switch from 16 bit ints to 8 bit unsigned
        // ints (bytes).
        // Keep xx as int16_t so fix 16 panel limit
        int16_t x = xx;
        uint8_t y = yy;
        uint8_t tmp;
 
        if (rotation) {
            // Implement Adafruit's rotation.
            if (rotation >= 2) {
                // rotation == 2 || rotation == 3
                x = _width - 1 - x;
            }
 
            if (rotation == 1 || rotation == 2) {
                // rotation == 1 || rotation == 2
                y = _height - 1 - y;
            }
 
            if (rotation & 1) {
                // rotation == 1 || rotation == 3
                tmp = x;
                x = y;
                y = tmp;
            }
        }
 
        if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) {
            // Ignore pixels outside the canvas.
            return;
        }
 
        // Translate the x, y coordinate according to the layout of the
        // displays. They can be ordered and rotated (0, 90, 180, 270).
 
        uint8_t display = matrixPosition[(x >> 3) + hDisplays * (y >> 3)];
        x &= 0b111;
        y &= 0b111;
 
        uint8_t r = matrixRotation[display];
        if (r >= 2) {
            // 180 or 270 degrees
            x = 7 - x;
        }
        if (r == 1 || r == 2) {
            // 90 or 180 degrees
            y = 7 - y;
        }
        if (r & 1) {
            // 90 or 270 degrees
            tmp = x;
            x = y;
            y = tmp;
        }
 
        uint8_t d = display / hDisplays;
        x += (display - d * hDisplays) << 3;  // x += (display % hDisplays) * 8
        y += d << 3;                          // y += (display / hDisplays) * 8
 
        // Update the color bit in our bitmap buffer.
 
        uint8_t *ptr = bitmap + x + WIDTH * (y >> 3);
        uint8_t val = 1 << (y & 0b111);
 
        if (color) {
            *ptr |= val;
        } else {
            *ptr &= ~val;
        }
    }
};
}  // namespace ustd