PCD8544.h

Go to the documentation of this file.

#ifndef PCD8544_H
#define PCD8544_H

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

#ifndef CHARBITS
#define CHARBITS 8
#endif

template<BOARD::pin_t SCE_PIN,
         BOARD::pin_t DC_PIN,
         BOARD::pin_t SDIN_PIN,
         BOARD::pin_t SCLK_PIN>
class PCD8544 : public LCD::Device {
public:
  static const uint8_t FONT_WIDTH = 6;
  static const uint8_t FONT_HEIGHT = 8;
  static const uint8_t WIDTH = 84 / FONT_WIDTH;
  static const uint8_t HEIGHT = 48 / FONT_HEIGHT;

  PCD8544(const uint8_t* font = NULL) :
    LCD::Device()
  {
    static const uint8_t default_font[] PROGMEM = {
      0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x5F, 0x00, 0x00,
      0x00, 0x07, 0x00, 0x07, 0x00,
      0x14, 0x7F, 0x14, 0x7F, 0x14,
      0x24, 0x2A, 0x7F, 0x2A, 0x12,
      0x23, 0x13, 0x08, 0x64, 0x62,
      0x36, 0x49, 0x56, 0x20, 0x50,
      0x00, 0x08, 0x07, 0x03, 0x00,
      0x00, 0x1C, 0x22, 0x41, 0x00,
      0x00, 0x41, 0x22, 0x1C, 0x00,
      0x2A, 0x1C, 0x7F, 0x1C, 0x2A,
      0x08, 0x08, 0x3E, 0x08, 0x08,
      0x00, 0x80, 0x70, 0x30, 0x00,
      0x08, 0x08, 0x08, 0x08, 0x08,
      0x00, 0x00, 0x60, 0x60, 0x00,
      0x20, 0x10, 0x08, 0x04, 0x02,
      0x3E, 0x51, 0x49, 0x45, 0x3E,
      0x00, 0x42, 0x7F, 0x40, 0x00,
      0x72, 0x49, 0x49, 0x49, 0x46,
      0x21, 0x41, 0x49, 0x4D, 0x33,
      0x18, 0x14, 0x12, 0x7F, 0x10,
      0x27, 0x45, 0x45, 0x45, 0x39,
      0x3C, 0x4A, 0x49, 0x49, 0x31,
      0x41, 0x21, 0x11, 0x09, 0x07,
      0x36, 0x49, 0x49, 0x49, 0x36,
      0x46, 0x49, 0x49, 0x29, 0x1E,
      0x00, 0x00, 0x14, 0x00, 0x00,
      0x00, 0x40, 0x34, 0x00, 0x00,
      0x00, 0x08, 0x14, 0x22, 0x41,
      0x14, 0x14, 0x14, 0x14, 0x14,
      0x00, 0x41, 0x22, 0x14, 0x08,
      0x02, 0x01, 0x59, 0x09, 0x06,
      0x3E, 0x41, 0x5D, 0x59, 0x4E,
      0x7C, 0x12, 0x11, 0x12, 0x7C,
      0x7F, 0x49, 0x49, 0x49, 0x36,
      0x3E, 0x41, 0x41, 0x41, 0x22,
      0x7F, 0x41, 0x41, 0x41, 0x3E,
      0x7F, 0x49, 0x49, 0x49, 0x41,
      0x7F, 0x09, 0x09, 0x09, 0x01,
      0x3E, 0x41, 0x41, 0x51, 0x73,
      0x7F, 0x08, 0x08, 0x08, 0x7F,
      0x00, 0x41, 0x7F, 0x41, 0x00,
      0x20, 0x40, 0x41, 0x3F, 0x01,
      0x7F, 0x08, 0x14, 0x22, 0x41,
      0x7F, 0x40, 0x40, 0x40, 0x40,
      0x7F, 0x02, 0x1C, 0x02, 0x7F,
      0x7F, 0x04, 0x08, 0x10, 0x7F,
      0x3E, 0x41, 0x41, 0x41, 0x3E,
      0x7F, 0x09, 0x09, 0x09, 0x06,
      0x3E, 0x41, 0x51, 0x21, 0x5E,
      0x7F, 0x09, 0x19, 0x29, 0x46,
      0x26, 0x49, 0x49, 0x49, 0x32,
      0x03, 0x01, 0x7F, 0x01, 0x03,
      0x3F, 0x40, 0x40, 0x40, 0x3F,
      0x1F, 0x20, 0x40, 0x20, 0x1F,
      0x3F, 0x40, 0x38, 0x40, 0x3F,
      0x63, 0x14, 0x08, 0x14, 0x63,
      0x03, 0x04, 0x78, 0x04, 0x03,
      0x61, 0x59, 0x49, 0x4D, 0x43,
      0x00, 0x7F, 0x41, 0x41, 0x41,
      0x02, 0x04, 0x08, 0x10, 0x20,
      0x00, 0x41, 0x41, 0x41, 0x7F,
      0x04, 0x02, 0x01, 0x02, 0x04,
      0x40, 0x40, 0x40, 0x40, 0x40,
      0x00, 0x03, 0x07, 0x08, 0x00,
      0x20, 0x54, 0x54, 0x78, 0x40,
      0x7F, 0x28, 0x44, 0x44, 0x38,
      0x38, 0x44, 0x44, 0x44, 0x28,
      0x38, 0x44, 0x44, 0x28, 0x7F,
      0x38, 0x54, 0x54, 0x54, 0x18,
      0x00, 0x08, 0x7E, 0x09, 0x02,
      0x18, 0xA4, 0xA4, 0x9C, 0x78,
      0x7F, 0x08, 0x04, 0x04, 0x78,
      0x00, 0x44, 0x7D, 0x40, 0x00,
      0x20, 0x40, 0x40, 0x3D, 0x00,
      0x7F, 0x10, 0x28, 0x44, 0x00,
      0x00, 0x41, 0x7F, 0x40, 0x00,
      0x7C, 0x04, 0x78, 0x04, 0x78,
      0x7C, 0x08, 0x04, 0x04, 0x78,
      0x38, 0x44, 0x44, 0x44, 0x38,
      0xFC, 0x18, 0x24, 0x24, 0x18,
      0x18, 0x24, 0x24, 0x18, 0xFC,
      0x7C, 0x08, 0x04, 0x04, 0x08,
      0x48, 0x54, 0x54, 0x54, 0x24,
      0x04, 0x04, 0x3F, 0x44, 0x24,
      0x3C, 0x40, 0x40, 0x20, 0x7C,
      0x1C, 0x20, 0x40, 0x20, 0x1C,
      0x3C, 0x40, 0x30, 0x40, 0x3C,
      0x44, 0x28, 0x10, 0x28, 0x44,
      0x4C, 0x90, 0x90, 0x90, 0x7C,
      0x44, 0x64, 0x54, 0x4C, 0x44,
      0x00, 0x08, 0x36, 0x41, 0x00,
      0x00, 0x00, 0x77, 0x00, 0x00,
      0x00, 0x41, 0x36, 0x08, 0x00,
      0x02, 0x01, 0x02, 0x04, 0x02,
      0x3C, 0x26, 0x23, 0x26, 0x3C,
    };
    m_font = font != NULL ? font : default_font;
    m_sce.output();
    m_dc.output();
  }

  virtual bool begin()
  {
    // Display setup script
    static const uint8_t script[] PROGMEM = {
      SET_FUNC       | EXTENDED_INST,
      SET_VOP        | 0x3f,
      SET_TEMP_COEFF | 0x00,
      SET_BIAS_SYS   | 0x02,
      SET_FUNC       | BASIC_INST   | HORIZONTAL_ADDR,
      DISPLAY_CNTL   | NORMAL_MODE
    };

    // Initiate display setting
    m_sce.high();
    write_command_P(script, sizeof(script));
    text_normal_mode();
    display_clear();
    backlight_on();
    return (true);
  }

  virtual bool end()
  {
    display_clear();
    write_command(SET_FUNC | BASIC_INST | POWER_DOWN_MODE);
    backlight_off();
    return (true);
  }

  virtual void display_contrast(uint8_t level)
  {
    write_command(SET_FUNC | EXTENDED_INST);
    write_command(SET_VOP  | (level & VOP_MASK));
    write_command(SET_FUNC | BASIC_INST | HORIZONTAL_ADDR);
  }

  virtual void display_on()
  {
    write_command(DISPLAY_CNTL | NORMAL_MODE);
  }

  virtual void display_off()
  {
    write_command(DISPLAY_CNTL | DISPLAY_OFF);
  }

  virtual void display_normal()
  {
    write_command(DISPLAY_CNTL | NORMAL_MODE);
  }

  virtual void display_inverse()
  {
    write_command(DISPLAY_CNTL | INVERSE_MODE);
  }

  virtual void display_clear()
  {
    cursor_home();
    write_data(BACKGROUND, WIDTH * FONT_WIDTH * HEIGHT);
    cursor_home();
  }

  virtual void cursor_set(uint8_t x, uint8_t y)
  {
    if (x >= WIDTH) x = 0;
    if (y >= HEIGHT) y = 0;
    write_command(SET_X_ADDR | ((x * FONT_WIDTH) & X_ADDR_MASK));
    write_command(SET_Y_ADDR | (y & Y_ADDR_MASK));
    m_x = x;
    m_y = y;
  }

  virtual size_t write(uint8_t c)
  {
    // Check for special characters
    if (c < ' ') {
      switch (c) {
      case '\a': // Check for special character: alert
        m_mode = ~m_mode;
        return (1);
      case '\b': // Check for special character: back-space
        cursor_set(m_x - 1, m_y);
        write_data(BACKGROUND, FONT_WIDTH);
        return (1);
      case '\f': // Check for special character: form-feed
        display_clear();
        return (1);
      case '\n': // Check for line-feed: clear new line
        cursor_set(0, m_y + 1);
        write_data(BACKGROUND, FONT_WIDTH * WIDTH);
      case '\r': // Carriage-return: move to start of line
        cursor_set(0, m_y);
        return (1);
      case '\t': // Check for horizontal tab
        {
          uint8_t x = m_x + m_tab - (m_x % m_tab);
          uint8_t y = m_y + (x >= WIDTH);
          cursor_set(x, y);
        }
        return (1);
      default:
        return (0);
      }
    }

    // Check that the character is not clipped
    if (m_x == WIDTH) write('\n');
    m_x += 1;

    // Access font for character width and bitmap
    uint8_t width = FONT_WIDTH - 1;
    const uint8_t* fp = m_font + ((c - ' ') * width);

    // Write character to the display memory and an extra byte
    do write_data(m_mode ^ pgm_read_byte(fp++)); while (--width);
    write_data(m_mode);
    return (1);
  }

protected:
  enum {
    NOP = 0x00,                 
    SET_FUNC = 0x20,            
      BASIC_INST = 0x00,        
      EXTENDED_INST = 0x01,     
      HORIZONTAL_ADDR = 0x00,   
      VERTICAL_ADDR = 0x02,     
      POWER_UP_MODE = 0x00,     
      POWER_DOWN_MODE = 0x04,   
    DISPLAY_CNTL = 0x08,        
      DISPLAY_OFF = 0x00,       
      DISPLAY_ON = 0x01,        
      NORMAL_MODE = 0x04,       
      INVERSE_MODE = 0x05,      
    SET_Y_ADDR = 0x40,          
      Y_ADDR_MASK = 0x07,       
    SET_X_ADDR = 0x80,          
      X_ADDR_MASK = 0x7f,       
    SET_TEMP_COEFF = 0x04,      
    SET_BIAS_SYS = 0x10,        
    SET_VOP = 0x80,             
      VOP_MASK = 0x7f,          
    SCRIPT_END = 0xff           
  } __attribute__((packed));

  static const uint8_t BACKGROUND = 0x00;

  GPIO<SCE_PIN> m_sce;

  GPIO<DC_PIN> m_dc;

  SRPO<MSBFIRST, SDIN_PIN, SCLK_PIN> m_srpo;

  const uint8_t* m_font;

  void write_data(uint8_t value)
  {
    m_sce.low();
    m_srpo.write(value);
    m_sce.high();
  }

  void write_data(uint8_t value, size_t count)
  {
    if (count == 0) return;
    m_sce.low();
    do m_srpo.write(value); while (--count);
    m_sce.high();
  }

  void write_command(uint8_t value)
  {
    m_dc.low();
    m_sce.low();
    m_srpo.write(value);
    m_sce.high();
    m_dc.high();
  }

  void write_command_P(const uint8_t* buf, size_t count)
  {
    if (count == 0) return;
    m_dc.low();
    m_sce.low();
    do m_srpo.write(pgm_read_byte(buf++)); while (--count);
    m_sce.high();
    m_dc.high();
  }
};

#endif