LCD.hh

Go to the documentation of this file.

#ifndef COSA_LCD_HH
#define COSA_LCD_HH

#include "Cosa/Types.h"
#include "Cosa/SPI.hh"
#include "Cosa/Keypad.hh"
#include "Cosa/IOStream.hh"
#include "Cosa/AnalogPin.hh"

class LCD : public IOStream {
public:

  class Device : public IOStream::Device {
  public:
    enum TextMode {
      NORMAL_TEXT_MODE = 0x00,
      INVERTED_TEXT_MODE = 0xff
    } __attribute__((packed));

    Device() :
      IOStream::Device(),
      m_x(0),
      m_y(0),
      m_tab(4),
      m_mode(0)
    {}

    virtual bool begin() = 0;

    virtual bool end() = 0;

    virtual void backlight_on() {}

    virtual void backlight_off() {}

    virtual void display_contrast(uint8_t level)
    {
      UNUSED(level);
    }

    virtual void display_on() = 0;

    virtual void display_off() = 0;

    virtual void display_normal() {}

    virtual void display_inverse() {}

    virtual void display_clear() = 0;

    void get_cursor(uint8_t& x, uint8_t& y) const
      __attribute__((always_inline))
    {
      x = m_x;
      y = m_y;
    }

    virtual void set_cursor(uint8_t x, uint8_t y) = 0;

    uint8_t get_tab_step() const
    {
      return (m_tab);
    }

    void set_tab_step(uint8_t step)
    {
      m_tab = step;
    }

    TextMode text_mode(TextMode mode)
      __attribute__((always_inline))
    {
      TextMode previous = (TextMode) m_mode;
      m_mode = mode;
      return (previous);
    }

  protected:
    uint8_t m_x;                
    uint8_t m_y;                
    uint8_t m_tab;              
    uint8_t m_mode;             
  };

  class IO {
  public:
    virtual void begin() = 0;

    virtual void end() = 0;

    virtual void write(uint8_t data) = 0;

    virtual void write(const void* buf, size_t size) = 0;
  };

  class Serial3W : public IO {
  public:
#if !defined(BOARD_ATTINY)
    Serial3W(Board::DigitalPin sdin = Board::D6,
             Board::DigitalPin sclk = Board::D7,
             Board::DigitalPin sce = Board::D9) :
      m_sdin(sdin, 0),
      m_sclk(sclk, 0),
      m_sce(sce, 1)
    {}
#else
    Serial3W(Board::DigitalPin sdin = Board::D0,
             Board::DigitalPin sclk = Board::D1,
             Board::DigitalPin sce = Board::D3) :
      m_sdin(sdin, 0),
      m_sclk(sclk, 0),
      m_sce(sce, 1)
    {}
#endif

    virtual void begin()
    {
      m_sce.clear();
    }

    virtual void end()
    {
      m_sce.set();
    }

    virtual void write(uint8_t data)
    {
      m_sdin.write(data, m_sclk);
    }

    virtual void write(const void* buf, size_t size)
    {
      uint8_t* dp = (uint8_t*) buf;
      while (size--) m_sdin.write(*dp++, m_sclk);
    }

  protected:
    OutputPin m_sdin;           
    OutputPin m_sclk;           
    OutputPin m_sce;            
  };

  class SPI3W : public IO, public SPI::Driver {
  public:
#if !defined(BOARD_ATTINY)
    SPI3W(Board::DigitalPin sce = Board::D9) : IO(), SPI::Driver(sce) {}
#else
    SPI3W(Board::DigitalPin sce = Board::D3) : IO(), SPI::Driver(sce) {}
#endif

    virtual void begin()
    {
      spi.acquire(this);
      spi.begin();
    }

    virtual void end()
    {
      spi.end();
      spi.release();
    }

    virtual void write(uint8_t data)
    {
      spi.transfer(data);
    }

    virtual void write(const void* buf, size_t size)
    {
      spi.write(buf, size);
    }
  };

  class Keypad : public ::Keypad {
  public:
    // Key index
    enum {
      NO_KEY = 0,
      SELECT_KEY,
      LEFT_KEY,
      DOWN_KEY,
      UP_KEY,
      RIGHT_KEY
    } __attribute__((packed));

    Keypad(Job::Scheduler* scheduler, Board::AnalogPin pin = Board::A0) :
      ::Keypad(scheduler, pin, m_map)
    {}

  private:
    static const uint16_t m_map[] PROGMEM;
  };
};

#endif