HD44780.hh

Go to the documentation of this file.

#ifndef COSA_HD44780_HH
#define COSA_HD44780_HH

#include "Cosa/SPI.hh"
#include "Cosa/LCD.hh"
#include "Cosa/OutputPin.hh"

class HD44780 : public LCD::Device {
public:
  class IO {
  public:
    virtual bool setup() = 0;

    virtual void write4b(uint8_t data) = 0;

    virtual void write8b(uint8_t data);

    virtual void write8n(const void* buf, size_t size);

    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(IO* 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((height == 4) && (width == 16) ? offset1 : offset0)
  {}

  virtual bool begin();

  virtual bool end();

  virtual void backlight_on();

  virtual void backlight_off();

  virtual void display_on();

  virtual void display_off();

  void display_scroll_left()
    __attribute__((always_inline))
  {
    write(SHIFT_SET | DISPLAY_MOVE | MOVE_LEFT);
  }

  void display_scroll_right()
    __attribute__((always_inline))
  {
    write(SHIFT_SET | DISPLAY_MOVE |  MOVE_RIGHT);
  }

  virtual void display_clear();

  void line_clear()
  {
    while (m_x < WIDTH) putchar(' ');
  }

  void cursor_home();

  void cursor_underline_on()
    __attribute__((always_inline))
  {
    set(m_cntl, CURSOR_ON);
  }

  void cursor_underline_off()
    __attribute__((always_inline))
  {
    clear(m_cntl, CURSOR_ON);
  }

  void cursor_blink_on()
    __attribute__((always_inline))
  {
    set(m_cntl, BLINK_ON);
  }

  void cursor_blink_off()
    __attribute__((always_inline))
  {
    clear(m_cntl, BLINK_ON);
  }

  virtual void set_cursor(uint8_t x, uint8_t y);

  void text_flow_left_to_right()
    __attribute__((always_inline))
  {
    set(m_mode, INCREMENT);
  }

  void text_flow_right_to_left()
    __attribute__((always_inline))
  {
    clear(m_mode, INCREMENT);
  }

  void text_scroll_left_adjust()
    __attribute__((always_inline))
  {
    set(m_mode, DISPLAY_SHIFT);
  }

  void text_scroll_right_adjust()
    __attribute__((always_inline))
  {
    clear(m_mode, DISPLAY_SHIFT);
  }

  void set_custom_char(uint8_t id, const uint8_t* bitmap);

  void set_custom_char_P(uint8_t id, const uint8_t* bitmap);

  virtual int putchar(char c);

  using IOStream::Device::write;

  virtual int write(const void* buf, size_t size);

#if !defined(BOARD_ATTINYX5)

  class Port4b : public IO {
  public:
    Port4b(Board::DigitalPin d0 = Board::D4,
           Board::DigitalPin d1 = Board::D5,
           Board::DigitalPin d2 = Board::D6,
           Board::DigitalPin d3 = Board::D7,
           Board::DigitalPin rs = Board::D8,
           Board::DigitalPin en = Board::D9,
           Board::DigitalPin bt = Board::D10) :
      m_d0(d0, 0),
      m_d1(d1, 0),
      m_d2(d2, 0),
      m_d3(d3, 0),
      m_rs(rs, 0),
      m_en(en, 0),
      m_bt(bt, 1)
    {}

    virtual bool setup();

    virtual void write4b(uint8_t data);

    virtual void write8b(uint8_t data);

    virtual void set_mode(uint8_t flag);

    virtual void set_backlight(uint8_t flag);

  protected:
    static const uint16_t SHORT_EXEC_TIME = 32;

    OutputPin m_d0;             
    OutputPin m_d1;             
    OutputPin m_d2;             
    OutputPin m_d3;             
    OutputPin m_rs;             
    OutputPin m_en;             
    OutputPin m_bt;             
  };
#endif

  class SR3W : public IO {
  public:
#if !defined(BOARD_ATTINY)
    SR3W(Board::DigitalPin sda = Board::D7,
         Board::DigitalPin scl = Board::D6,
         Board::DigitalPin en = Board::D5);
#else
    SR3W(Board::DigitalPin sda = Board::D1,
         Board::DigitalPin scl = Board::D2,
         Board::DigitalPin en = Board::D3);
#endif

    virtual bool setup();

    virtual void write4b(uint8_t data);

    virtual void write8b(uint8_t data);

    virtual void set_mode(uint8_t flag);

    virtual void set_backlight(uint8_t flag);

  protected:
    static const uint16_t SHORT_EXEC_TIME = 20;

    union port_t {
      uint8_t as_uint8;         
      struct {
        uint8_t data:4;         
        uint8_t rs:1;           
        uint8_t bt:1;           
        uint8_t app2:1;         
        uint8_t app1:1;         
      };
      operator uint8_t()
      {
        return (as_uint8);
      }
      port_t()
      {
        as_uint8 = 0;
      }
    };
    port_t m_port;              
    OutputPin m_sda;            
    OutputPin m_scl;            
    OutputPin m_en;             
  };

  class SR3WSPI : public IO, public SPI::Driver {
  public:
#if !defined(BOARD_ATTINY)
    SR3WSPI(Board::DigitalPin en = Board::D5);
#else
    SR3WSPI(Board::DigitalPin en = Board::D3);
#endif

    virtual bool setup();

    virtual void write4b(uint8_t data);

    virtual void write8b(uint8_t data);

    virtual void set_mode(uint8_t flag);

    virtual void set_backlight(uint8_t flag);

  protected:
#if !defined(BOARD_ATTINY)
    static const uint16_t SHORT_EXEC_TIME = 24;
#else
    static const uint16_t SHORT_EXEC_TIME = 8;
#endif

    union port_t {
      uint8_t as_uint8;         
      struct {
        uint8_t data:4;         
        uint8_t rs:1;           
        uint8_t bt:1;           
        uint8_t app2:1;         
        uint8_t app1:1;         
      };
      operator uint8_t()
      {
        return (as_uint8);
      }
      port_t()
      {
        as_uint8 = 0;
      }
    };
    port_t m_port;              
  };

  class SR4W : public IO {
  public:
#if !defined(BOARD_ATTINY)
    SR4W(Board::DigitalPin sda = Board::D7,
         Board::DigitalPin scl = Board::D6,
         Board::DigitalPin en = Board::D5,
         Board::DigitalPin bt = Board::D4);
#else
    SR4W(Board::DigitalPin sda = Board::D1,
         Board::DigitalPin scl = Board::D2,
         Board::DigitalPin en = Board::D3,
         Board::DigitalPin bt = Board::D4);
#endif

    virtual bool setup();

    virtual void write4b(uint8_t data);

    virtual void write8b(uint8_t data);

    virtual void set_mode(uint8_t flag);

    virtual void set_backlight(uint8_t flag);

  protected:
    static const uint16_t SHORT_EXEC_TIME = 16;

    OutputPin m_sda;            
    OutputPin m_scl;            
    OutputPin m_en;             
    OutputPin m_bt;             
    uint8_t m_rs;               
  };

  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));

  static const uint8_t offset0[] PROGMEM;
  static const uint8_t offset1[] PROGMEM;

  IO* m_io;                     
  uint8_t m_mode;               
  uint8_t m_cntl;               
  uint8_t m_func;               
  const uint8_t* m_offset;      

  void write(uint8_t data)
    __attribute__((always_inline))
  {
    m_io->write8b(data);
  }

  void set(uint8_t& cmd, uint8_t mask)
    __attribute__((always_inline))
  {
    m_io->write8b(cmd |= mask);
  }

  void clear(uint8_t& cmd, uint8_t mask)
    __attribute__((always_inline))
  {
    m_io->write8b(cmd &= ~mask);
  }

  void set_data_mode()
    __attribute__((always_inline))
  {
    m_io->set_mode(1);
  }

  void set_instruction_mode()
    __attribute__((always_inline))
  {
    m_io->set_mode(0);
  }
};
#endif