HD44780.h

Go to the documentation of this file.

#ifndef HD44780_H
#define HD44780_H

#include "LCD.h"

class HD44780 : public LCD::Device {
public:
  class Adapter {
  public:
    virtual bool setup()
    {
      return (false);
    }

    virtual void write4b(uint8_t data) = 0;

    virtual void write8b(uint8_t data)
    {
      write4b(data >> 4);
      write4b(data);
    }

    virtual void write8n(const void* buf, size_t size)
    {
      const uint8_t* bp = (const uint8_t*) buf;
      while (size--) write8b(*bp++);
    }

    virtual void set_mode(uint8_t flag) = 0;

    virtual void set_backlight(uint8_t flag) = 0;
  };

  static const uint8_t BITMAP_MAX = 8;

  const uint8_t WIDTH;

  const uint8_t HEIGHT;

  HD44780(Adapter& io, uint8_t width = 16, uint8_t height = 2) :
    LCD::Device(),
    WIDTH(width),
    HEIGHT(height),
    m_io(io),
    m_mode(ENTRY_MODE_SET | INCREMENT),
    m_cntl(CONTROL_SET),
    m_func(FUNCTION_SET | DATA_LENGTH_4BITS | NR_LINES_2 | FONT_5X8DOTS),
    m_offset(NULL)
  {}

  virtual bool begin()
  {
    // Initiate display; See fig. 24, 4-bit interface, pp. 46.
    // http://web.alfredstate.edu/weimandn/lcd/lcd_initialization/-
    // LCD%204-bit%20Initialization%20v06.pdf
    static const uint8_t offset0[] PROGMEM = { 0x00, 0x40, 0x14, 0x54 };
    static const uint8_t offset1[] PROGMEM = { 0x00, 0x40, 0x10, 0x50 };
    m_offset = ((HEIGHT == 4) && (WIDTH == 16) ? offset1 : offset0);
    const uint8_t FS0 = (FUNCTION_SET | DATA_LENGTH_8BITS);
    const uint8_t FS1 = (FUNCTION_SET | DATA_LENGTH_4BITS);
    bool mode = m_io.setup();
    delay(POWER_ON_TIME);
    // 4-bit initialization mode
    if (!mode) {
      m_io.write4b(FS0 >> 4);
      delayMicroseconds(INIT0_TIME);
      m_io.write4b(FS0 >> 4);
      delayMicroseconds(INIT1_TIME);
      m_io.write4b(FS0 >> 4);
      delayMicroseconds(INIT1_TIME);
      m_io.write4b(FS1 >> 4);
      delayMicroseconds(INIT1_TIME);
    }
    // 8-bit initialization mode
    else {
      m_io.write8b(m_func |= DATA_LENGTH_8BITS);
    }

    // Initialization with the function, control and mode setting
    m_io.write8b(m_func);
    m_io.write8b(m_cntl);

    // Initialization completed. Turn on the display and backlight
    text_normal_mode();
    display_on();
    backlight_on();
    display_clear();
    return (true);
  }

  virtual void backlight_on()
  {
    m_io.set_backlight(true);
  }

  virtual void backlight_off()
  {
    m_io.set_backlight(false);
  }

  virtual void display_on()
  {
    m_io.write8b(m_cntl |= DISPLAY_ON);
  }

  virtual void display_off()
  {
    m_io.write8b(m_cntl &= ~DISPLAY_ON);
  }

  virtual void display_clear()
  {
    m_io.write8b(CLEAR_DISPLAY);
    m_x = 0;
    m_y = 0;
    m_mode |= INCREMENT;
    delayMicroseconds(LONG_EXEC_TIME);
  }

  virtual void cursor_blink_on()
  {
    m_io.write8b(m_cntl |= BLINK_ON);
  }

  virtual void cursor_blink_off()
  {
    m_io.write8b(m_cntl &= ~BLINK_ON);
  }

  virtual void cursor_set(uint8_t x, uint8_t y)
  {
    if (x >= WIDTH) x = 0;
    if (y >= HEIGHT) y = 0;
    uint8_t offset = (uint8_t) pgm_read_byte(&m_offset[y]);
    m_io.write8b(SET_DDRAM_ADDR | ((x + offset) & SET_DDRAM_MASK));
    m_x = x;
    m_y = y;
  }

  virtual void cursor_home()
  {
    m_io.write8b(RETURN_HOME);
    m_x = 0;
    m_y = 0;
    delayMicroseconds(LONG_EXEC_TIME);
  }

  void display_scroll_left()
    __attribute__((always_inline))
  {
    m_io.write8b(SHIFT_SET | DISPLAY_MOVE | MOVE_LEFT);
  }

  void display_scroll_right()
    __attribute__((always_inline))
  {
    m_io.write8b(SHIFT_SET | DISPLAY_MOVE | MOVE_RIGHT);
  }

  void cursor_underline_on()
    __attribute__((always_inline))
  {
    m_io.write8b(m_cntl |= CURSOR_ON);
  }

  void cursor_underline_off()
    __attribute__((always_inline))
  {
    m_io.write8b(m_cntl &= ~CURSOR_ON);
  }


  void text_flow_right_to_left()
    __attribute__((always_inline))
  {
    m_io.write8b(m_cntl &= ~INCREMENT);
  }

  void text_scroll_left_adjust()
    __attribute__((always_inline))
  {
    m_io.write8b(m_cntl |= DISPLAY_SHIFT);
  }

  void text_scroll_right_adjust()
    __attribute__((always_inline))
  {
    m_io.write8b(m_cntl &= ~DISPLAY_SHIFT);
  }

  void set_custom_char(uint8_t id, const uint8_t* bitmap)
  {
    m_io.write8b(SET_CGRAM_ADDR | ((id << 3) & SET_CGRAM_MASK));
    m_io.set_mode(true);
    for (uint8_t i = 0; i < BITMAP_MAX; i++)
      m_io.write8b(*bitmap++);
    m_io.set_mode(false);
  }

  void set_custom_char_P(uint8_t id, const uint8_t* bitmap)
  {
    m_io.write8b(SET_CGRAM_ADDR | ((id << 3) & SET_CGRAM_MASK));
    m_io.set_mode(true);
    for (uint8_t i = 0; i < BITMAP_MAX; i++, bitmap++)
      m_io.write8b(pgm_read_byte(bitmap));
    m_io.set_mode(false);
  }

  virtual size_t write(uint8_t c)
  {
    // Check for special characters
    if (c < ' ') {
      switch (c) {
      case '\a': // Alert: invert text mode
        m_mode = ~m_mode;
        return (1);
      case '\b': // Back-space: move cursor back one step (if possible)
        cursor_set(m_x - 1, m_y);
        write(' ');
        cursor_set(m_x - 1, m_y);
        return (1);
      case '\f': // Form-feed: clear the display
        display_clear();
        return (1);
      case '\n': // New-line: clear line
        {
          cursor_set(0, m_y + 1);
          m_io.set_mode(true);
          for (uint8_t i = 0; i < WIDTH; i++) write(' ');
          m_io.set_mode(false);
          cursor_set(m_x, m_y);
        }
        return (1);
      case '\r': // Carriage-return: move to start of line
        cursor_set(0, m_y);
        return (1);
      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);
        }
        return (1);
      default:
        return (0);
      }
    }

    // Write character
    if (m_x == WIDTH) write('\n');
    m_x += 1;
    m_io.set_mode(true);
    m_io.write8b(c);
    m_io.set_mode(false);
    return (c & 0xff);
  }

protected:
  static const uint16_t LONG_EXEC_TIME = 1600;
  static const uint16_t POWER_ON_TIME = 48;
  static const uint16_t INIT0_TIME = 4500;
  static const uint16_t INIT1_TIME = 150;

  enum {
    CLEAR_DISPLAY = 0x01,       
    RETURN_HOME = 0x02,         
    ENTRY_MODE_SET = 0x04,      
    CONTROL_SET = 0x08,         
    SHIFT_SET = 0x10,           
    FUNCTION_SET = 0x20,        
    SET_CGRAM_ADDR = 0x40,      
    SET_CGRAM_MASK = 0x3f,      
    SET_DDRAM_ADDR = 0x80,      
    SET_DDRAM_MASK = 0x7f,      
    BIAS_RESISTOR_SET = 0x04,   
    BIAS_RESISTOR_MASK = 0x03,  
    COM_SEG_SET = 0x40,         
    COM_SET_MASK = 0x0f,        
    SET_DDATA_LENGTH = 0x80,    
    SET_DDATA_MASK = 0x7f       
  } __attribute__((packed));

  enum {
    DISPLAY_SHIFT = 0x01,       
    INCREMENT = 0x02,           
    DECREMENT = 0x00            
  } __attribute__((packed));

  enum {
    BLINK_ON = 0x01,            
    CURSOR_ON = 0x02,           
    DISPLAY_ON = 0x04,          
  } __attribute__((packed));

  enum {
    MOVE_LEFT = 0x00,           
    MOVE_RIGHT = 0x04,          
    CURSOR_MODE = 0x00,
    DISPLAY_MOVE = 0x08
  } __attribute__((packed));

  enum {
    DATA_LENGTH_4BITS = 0x00,   
    DATA_LENGTH_8BITS = 0x10,   
    NR_LINES_1 = 0x00,          
    NR_LINES_2 = 0x08,          
    FONT_5X8DOTS = 0x00,        
    FONT_5X10DOTS = 0x04,       
    BASIC_SET = 0x00,           
    EXTENDED_SET = 0x04         
  } __attribute__((packed));

  Adapter& m_io;                
  uint8_t m_mode;               
  uint8_t m_cntl;               
  uint8_t m_func;               
  const uint8_t* m_offset;      
};
#endif