MAX7219_Base.hpp

Go to the documentation of this file.

/* ✔ */
 
#pragma once
 
#include <AH/Settings/Warnings.hpp>
AH_DIAGNOSTIC_WERROR() // Enable errors on warnings
 
#include <AH/Hardware/ExtendedInputOutput/ExtendedInputOutput.hpp>
 
AH_DIAGNOSTIC_EXTERNAL_HEADER()
#include <SPI.h>
AH_DIAGNOSTIC_POP()
 
BEGIN_AH_NAMESPACE
 
class MAX7219_Base {
  public:
    MAX7219_Base(pin_t loadPin, uint8_t chainlength = 1)
        : loadPin(loadPin), chainlength(chainlength) {}
 
    static constexpr uint8_t DECODEMODE = 9;
    static constexpr uint8_t INTENSITY = 10;
    static constexpr uint8_t SCANLIMIT = 11;
    static constexpr uint8_t SHUTDOWN = 12;
    static constexpr uint8_t DISPLAYTEST = 15;
 
    void init() {
        ExtIO::digitalWrite(loadPin, HIGH);
        ExtIO::pinMode(loadPin, OUTPUT);
        SPI.begin();
        sendRawAll(DISPLAYTEST, 0); // Normal operation, no test mode
        sendRawAll(SCANLIMIT, 7);   // Scan all 8 digits
        sendRawAll(DECODEMODE, 0);  // Raw LED addressing
        sendRawAll(INTENSITY, 0xF); // Maximum intensity
        clear();
        sendRawAll(SHUTDOWN, 1); // Enable the display
    }
 
    void clear() {
        for (uint8_t j = 1; j < 8 + 1; j++)
            sendRawAll(j, 0);
    }
 
    void send(uint8_t digit, uint8_t value, uint8_t chip = 0) {
        sendRaw((digit & 0x7) + 1, value, chip);
    }
 
    void sendRowAll(uint8_t digit, const uint8_t *values,
                    uint8_t leading_dim = 1) {
        uint8_t opcode = (digit & 0x7) + 1;
        ExtIO::digitalWrite(loadPin, LOW);
        SPI.beginTransaction(settings);
        for (uint8_t i = 0; i < chainlength; ++i) {
            SPI.transfer(opcode);
            SPI.transfer(values[uint16_t(i) * leading_dim]);
        }
        ExtIO::digitalWrite(loadPin, HIGH);
        SPI.endTransaction();
    }
 
    void sendAll(const uint8_t *values) {
        for (uint8_t row = 0; row < 8; ++row)
            sendRowAll(row, values + row, 8);
    }
 
    void sendRawAll(uint8_t opcode, uint8_t value) {
        ExtIO::digitalWrite(loadPin, LOW);
        SPI.beginTransaction(settings);
        for (uint8_t i = 0; i < chainlength; ++i) {
            SPI.transfer(opcode);
            SPI.transfer(value);
        }
        ExtIO::digitalWrite(loadPin, HIGH);
        SPI.endTransaction();
    }
 
    void sendRaw(uint8_t opcode, uint8_t value, uint8_t chip = 0) {
        if (chip >= chainlength)
            return; // Should I throw an error?
        ExtIO::digitalWrite(loadPin, LOW);
        SPI.beginTransaction(settings);
        uint8_t c = 0;
        for (; c < chip; c++) {
            SPI.transfer(0x00); // No-Op
            SPI.transfer(0x00);
        }
        SPI.transfer(opcode);
        SPI.transfer(value);
        for (c++; c < chainlength; c++) {
            SPI.transfer(0x00); // No-Op
            SPI.transfer(0x00);
        }
        ExtIO::digitalWrite(loadPin, HIGH);
        SPI.endTransaction();
    }
 
    void setIntensity(uint8_t intensity) {
        sendRawAll(INTENSITY, intensity & 0xF);
    }
 
    void setIntensity(uint8_t intensity, uint8_t chip) {
        sendRaw(INTENSITY, intensity & 0xF, chip);
    }
 
    uint8_t getChainLength() const {
        return chainlength;
    }
 
  private:
    pin_t loadPin;
    uint8_t chainlength;
    SPISettings settings = {SPI_MAX_SPEED, MSBFIRST, SPI_MODE0};
};
 
END_AH_NAMESPACE
 
AH_DIAGNOSTIC_POP()