MAX72XX.h

Go to the documentation of this file.

#ifndef MAX72XX_H
#define MAX72XX_H

#include "LCD.h"
#include "GPIO.h"
#include "SRPO.h"

template<BOARD::pin_t SCE_PIN, BOARD::pin_t SDIN_PIN, BOARD::pin_t SCLK_PIN>
class MAX72XX : public LCD::Device {
public:
  static const uint8_t WIDTH = 8;
  static const uint8_t HEIGHT = 1;

  MAX72XX(const uint8_t* font = NULL) :
    LCD::Device()
  {
    static const uint8_t default_font[] PROGMEM = {
      0b00000000, // (space)
      0b10000000, // !
      0b00100010, // "
      0b10000000, // #
      0b10000000, // $
      0b10000000, // %
      0b10000000, // &
      0b00000010, // '
      0b01001110, // (
      0b01111000, // )
      0b10000000, // *
      0b10000000, // +
      0b10000000, // ,
      0b00000001, // -
      0b10000000, // .
      0b00100100, // /
      0b01111110, // 0
      0b00110000, // 1
      0b01101101, // 2
      0b01111001, // 3
      0b00110011, // 4
      0b01011011, // 5
      0b01011111, // 6
      0b01110000, // 7
      0b01111111, // 8
      0b01111011, // 9
      0b10000000, // :
      0b10000000, // ;
      0b10000000, // <
      0b00001001, // =
      0b10000000, // >
      0b10000000, // ?
      0b10000000, // @
      0b01110111, // A
      0b00011111, // B/b
      0b01001110, // C
      0b00111101, // D/d
      0b01001111, // E
      0b01000111, // F
      0b01011110, // G
      0b00110111, // H
      0b00110000, // I
      0b00111000, // J
      0b10000000, // K
      0b00001110, // L
      0b10000000, // M
      0b11110110, // N
      0b01111110, // O
      0b01100111, // P
      0b10000000, // Q
      0b10000000, // R
      0b01011011, // S
      0b10000000, // T
      0b00111110, // U
      0b10000000, // V
      0b10000000, // W
      0b00110111, // X
      0b00110011, // Y
      0b01101101, // Z
      0b01001110, // [
      0b00010011, // "\"
      0b01111000, // ]
      0b11100010, // ^
      0b00001000, // _
      0b10000000, // `
      0b10000000, // a
      0b00011111, // b
      0b00001101, // c
      0b00111101, // d
      0b01001111, // e/E
      0b01000111, // f
      0b01111011, // g
      0b00010111, // h
      0b00010000, // i
      0b00111000, // j
      0b10000000, // k
      0b00110000, // l
      0b10000000, // m
      0b00010101, // n
      0b00011101, // o
      0b01100111, // p
      0b01110011, // q
      0b00000101, // r
      0b10000000, // s
      0b10000000, // t
      0b00011100, // u
      0b10000000, // v
      0b10000000, // w
      0b10000000, // x
      0b10000000, // y
      0b10000000, // z
      0b00110001, // {
      0b00110000, // |
      0b00000111, // }
      0b00100101, // ~
      0b00010011  // DEL
    };
    m_font = font != NULL ? font : default_font;
    m_sce.output();
    m_sce.high();
  }

  virtual bool begin()
  {
    display_off();
    set(DECODE_MODE, NO_DECODE);
    set(SCAN_LIMIT, 7);
    display_contrast(7);
    display_clear();
    display_on();
    return (true);
  }

  virtual bool end()
  {
    set(DISPLAY_MODE, SHUTDOWN_MODE);
    return (true);
  }

  virtual void display_contrast(uint8_t level)
  {
    set(INTENSITY, level & 0xF);
  }

  virtual void display_on()
  {
    set(DISPLAY_MODE, NORMAL_OPERATION);
  }

  virtual void display_off()
  {
    set(DISPLAY_MODE, SHUTDOWN_MODE);
  }

  virtual void display_clear()
  {
    for (uint8_t reg = DIGIT0; reg <= DIGIT7; reg++)
      set(reg, 0x00);
    cursor_home();
  }

  virtual void cursor_set(uint8_t x, uint8_t y)
  {
    if (x >= WIDTH) x = 0;
    if (y >= HEIGHT) y = 0;
    m_x = x;
    m_y = y;
  }

  virtual size_t write(uint8_t c)
  {
    // Check for illegal characters
    if (c > 128) return (0);

    // Check for special characters
    if (c < ' ') {
      switch (c) {
      case '\r': // Carriage-return: move to start of line
        cursor_set(0, m_y);
        break;
      case '\f': // Form-feed: clear the display or line-feed: clear line
      case '\n':
        display_clear();
        break;
      case '\t': // Horizontal tab
        {
          uint8_t x = m_x + m_tab - (m_x % m_tab);
          uint8_t y = m_y + (x >= WIDTH);
          cursor_set(x, y);
        }
        break;
      case '\b': // Back-space: move cursor back one step (if possible)
        cursor_set(m_x - 1, m_y);
        set(m_x + 1, 0);
        break;
      case '\a': // Alert: invert character mode
        m_mode = ~m_mode;
        break;
      default:
        return (0);
      }
      return (1);
    }

    // Write character; compress dot with latest character
    uint8_t segments;
    if (c == '.') {
      c = m_latest;
      segments = pgm_read_byte(m_font + c - ' ') | 0x80;
    }
    else {
      if (m_x == WIDTH) write('\n');
      m_x += 1;
      m_latest = c;
      segments = pgm_read_byte(m_font + c - ' ');
    }

    // Set the segments of the current digit
    set(m_x, segments);
    return (1);
  }

protected:
  enum {
    NOP = 0x00,                 
    DIGIT0 = 0x01,              
    DIGIT1 = 0x02,              
    DIGIT2 = 0x03,              
    DIGIT3 = 0x04,              
    DIGIT4 = 0x05,              
    DIGIT5 = 0x06,              
    DIGIT6 = 0x07,              
    DIGIT7 = 0x08,              
    DECODE_MODE = 0x09,         
    INTENSITY = 0x0a,           
    SCAN_LIMIT = 0x0b,          
    DISPLAY_MODE = 0x0c,        
    DISPLAY_TEST = 0x0f         
  } __attribute__((packed));

  void set(uint8_t reg, uint8_t value)
  {
    m_sce.toggle();
    m_srpo.write(reg);
    m_srpo.write(value);
    m_sce.toggle();
  }

  enum {
    SHUTDOWN_MODE = 0x00,       
    NORMAL_OPERATION = 0x01     
  } __attribute__((packed));

  enum {
    NO_DECODE = 0x00,           
    ALL_DECODE = 0xff           
  } __attribute__((packed));

  GPIO<SCE_PIN> m_sce;                          
  SRPO<MSBFIRST, SDIN_PIN, SCLK_PIN> m_srpo;    
  const uint8_t* m_font;                        
  char m_latest;                                

};
#endif