|
|
@@ -0,0 +1,534 @@ |
|
|
|
/*!
|
|
|
|
* \file drv/liquid_crystal.h
|
|
|
|
* \brief
|
|
|
|
* A liquid crystal display driver
|
|
|
|
*
|
|
|
|
* \copyright Copyright (C) 2021 Christos Choutouridis <christos@choutouridis.net>
|
|
|
|
*
|
|
|
|
* <dl class=\"section copyright\"><dt>License</dt><dd>
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
|
|
* copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
* SOFTWARE.
|
|
|
|
* </dd></dl>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef TBX_DRV_LIQUID_CRYSTAL_H_
|
|
|
|
#define TBX_DRV_LIQUID_CRYSTAL_H_
|
|
|
|
|
|
|
|
#include <core/core.h>
|
|
|
|
#include <core/crtp.h>
|
|
|
|
#include <utils/print.h>
|
|
|
|
|
|
|
|
#include <type_traits>
|
|
|
|
#include <ctime>
|
|
|
|
|
|
|
|
namespace tbx {
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \class liquid_crystal
|
|
|
|
* \brief
|
|
|
|
* A CRTP driver class for liquid crystal display with parallel interface,
|
|
|
|
* based on Hitachi HD44780 (Samsung KS0066U, or compatible).
|
|
|
|
*
|
|
|
|
* The driver inherits from Print
|
|
|
|
* The Implementation requirements are:
|
|
|
|
* - void bus_impl(data); To set the 4bit/8bit bus
|
|
|
|
* - void rs_pin_impl(state); To set/clear RS pin
|
|
|
|
* - void en_pin_impl(state); To set/clear EN pin
|
|
|
|
* - void power_pin_impl(state); To set/clear PWR pin
|
|
|
|
* - void bl_pin_impl(state); To set/clear BackLight pin
|
|
|
|
* - void delay_usec_impl(usec); To provide delay in usec
|
|
|
|
*
|
|
|
|
* \tparam Impl_t The derived class
|
|
|
|
* \tparam Lines The lines of the LCD
|
|
|
|
* \tparam Columns The coluns of the LCD
|
|
|
|
*/
|
|
|
|
template <typename Impl_t, size_t Lines, size_t Columns, size_t BusSize =4>
|
|
|
|
class liquid_crystal : public Print<liquid_crystal<Impl_t, Lines, Columns, BusSize>, char>{
|
|
|
|
friend Print<liquid_crystal, char>;
|
|
|
|
_CRTP_IMPL(Impl_t);
|
|
|
|
static_assert((BusSize == 4) || (BusSize == 8), "BusSize must be either 4 or 8.");
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* Public enumerator to be used as argument to the init() function.
|
|
|
|
* Selects the font size and thus the number of active lines
|
|
|
|
*/
|
|
|
|
enum class FontSize :uint8_t { dots_5x8, dots_5x10 };
|
|
|
|
private:
|
|
|
|
|
|
|
|
// Commands
|
|
|
|
constexpr static uint8_t Cmd_cls = 0x01;
|
|
|
|
constexpr static uint8_t Cmd_RetHome = 0x02;
|
|
|
|
constexpr static uint8_t Cmd_EntryMode = 0x04;
|
|
|
|
constexpr static uint8_t Cmd_DispCtrl = 0x08;
|
|
|
|
constexpr static uint8_t Cmd_Shift = 0x10;
|
|
|
|
constexpr static uint8_t Cmd_FunSet = 0x20;
|
|
|
|
constexpr static uint8_t Cmd_SetGRamAddr= 0x40;
|
|
|
|
constexpr static uint8_t Cmd_SetDRamAddr= 0x80;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Entry Mode Set -----> 0 0 0 0 0 1 I/D S
|
|
|
|
* ----------------------------------------------------
|
|
|
|
* I/D = 1 Increment Curs
|
|
|
|
* 0 Decrement
|
|
|
|
* S = 1 Display shift
|
|
|
|
* 0 Not
|
|
|
|
*/
|
|
|
|
constexpr static uint8_t Entry_Right = 0x00;
|
|
|
|
constexpr static uint8_t Entry_Left = 0x02;
|
|
|
|
constexpr static uint8_t Entry_ShiftInc = 0x01;
|
|
|
|
constexpr static uint8_t Entry_ShiftDec = 0x00;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DispOnOffControll --> 0 0 0 0 1 D C B
|
|
|
|
* -------------------------------------------------
|
|
|
|
* D = Display On
|
|
|
|
* C = Cursor On
|
|
|
|
* B = Blinking On
|
|
|
|
*/
|
|
|
|
constexpr static uint8_t Display_On = 0x04;
|
|
|
|
constexpr static uint8_t Display_Off = 0x00;
|
|
|
|
constexpr static uint8_t Cursor_On = 0x02;
|
|
|
|
constexpr static uint8_t Cursor_Off = 0x00;
|
|
|
|
constexpr static uint8_t Blink_On = 0x01;
|
|
|
|
constexpr static uint8_t Blink_Off = 0x00;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cursor/Display Shift --> 0 0 0 1 S/C R/L x x
|
|
|
|
* ---------------------------------------------------
|
|
|
|
* S/C = 1 Display Shift
|
|
|
|
* 0 Cursor Shift
|
|
|
|
* R/L = 1 Shift Right
|
|
|
|
* 0 Shift left
|
|
|
|
*/
|
|
|
|
constexpr static uint8_t DisMove_Display= 0x08;
|
|
|
|
constexpr static uint8_t DisMove_Cursor = 0x00;
|
|
|
|
constexpr static uint8_t DisMove_Right = 0x04;
|
|
|
|
constexpr static uint8_t DisMove_Left = 0x00;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* FunctionSet ------> 0 0 1 DL N F x x
|
|
|
|
* ---------------------------------------------------
|
|
|
|
* DL = 1 8bit
|
|
|
|
* 0 4bit
|
|
|
|
* N = 1 2 lines
|
|
|
|
* 0 1 line
|
|
|
|
* F = 1 5x10 dots
|
|
|
|
* 0 5x8 dots
|
|
|
|
*/
|
|
|
|
constexpr static uint8_t FunSet_8bitMode= 0x10;
|
|
|
|
constexpr static uint8_t FunSet_4bitMode= 0x00;
|
|
|
|
constexpr static uint8_t FunSet_2Line = 0x08;
|
|
|
|
constexpr static uint8_t FunSet_1Line = 0x00;
|
|
|
|
constexpr static uint8_t FunSet_5x10dots= 0x04;
|
|
|
|
constexpr static uint8_t FunSet_5x8dots = 0x00;
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief
|
|
|
|
* Helper class to keep track of the display cursor. As we dont read the cursor
|
|
|
|
* position on the display, in order to implement backspace operation we need to
|
|
|
|
* keep track the cursor position manually.
|
|
|
|
*/
|
|
|
|
struct Cursor {
|
|
|
|
uint8_t inc_x() noexcept {
|
|
|
|
if (++x_ > Columns) x_ =1;
|
|
|
|
return x_;
|
|
|
|
}
|
|
|
|
uint8_t dec_x() noexcept {
|
|
|
|
if (--x_ < 1) x_ =Columns;
|
|
|
|
return x_;
|
|
|
|
}
|
|
|
|
uint8_t inc_y () noexcept {
|
|
|
|
if (++y_ > max_lines) y_ =1;
|
|
|
|
return y_;
|
|
|
|
}
|
|
|
|
uint8_t dec_y () noexcept {
|
|
|
|
if (--y_ < 1) y_ =max_lines;
|
|
|
|
return y_;
|
|
|
|
}
|
|
|
|
uint8_t operator++() noexcept { return inc_x(); }
|
|
|
|
uint8_t operator--() noexcept { return dec_x(); }
|
|
|
|
void set(uint8_t x, uint8_t y) noexcept {
|
|
|
|
x_ = x;
|
|
|
|
y_ = y;
|
|
|
|
}
|
|
|
|
uint8_t get_x() noexcept { return x_; }
|
|
|
|
uint8_t get_y() noexcept { return y_; }
|
|
|
|
void set_lines (uint8_t l) noexcept { max_lines = l; }
|
|
|
|
private:
|
|
|
|
uint8_t x_, y_;
|
|
|
|
uint8_t max_lines;
|
|
|
|
};
|
|
|
|
private:
|
|
|
|
//! \name Implementation requirements
|
|
|
|
//! @{
|
|
|
|
void BUS (uint8_t data) { impl().bus_impl(data); }
|
|
|
|
void RS_Pin (bool state) { impl().rs_pin_impl(state); }
|
|
|
|
void EN_Pin (bool state) { impl().en_pin_impl(state); }
|
|
|
|
void PWR_Pin (bool state) { impl().power_pin_impl(state); }
|
|
|
|
void BL_Pin (bool state) { impl().bl_pin_impl(state); }
|
|
|
|
void delay_usec(size_t usec) {
|
|
|
|
impl().delay_usec_impl(usec);
|
|
|
|
}
|
|
|
|
//! @}
|
|
|
|
|
|
|
|
//! \name Print interface requirements
|
|
|
|
//! @{
|
|
|
|
size_t write_impl (const char* str, size_t size) {
|
|
|
|
size_t ret =0;
|
|
|
|
while (*str && ret < size) {
|
|
|
|
putchar (*str++);
|
|
|
|
++ret;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
size_t write_impl (const char ch) {
|
|
|
|
return (putchar(ch) == ch) ? 1:0;
|
|
|
|
}
|
|
|
|
//! @}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
//! \name Object lifetime
|
|
|
|
//! @{
|
|
|
|
liquid_crystal() noexcept = default; //!< Construct from derived only
|
|
|
|
//~liquid_crystal() = default;
|
|
|
|
liquid_crystal(const liquid_crystal&) = delete; //!< No copies
|
|
|
|
liquid_crystal& operator= (const liquid_crystal&) = delete; //!< No copies
|
|
|
|
//! @}
|
|
|
|
|
|
|
|
private:
|
|
|
|
//! Send enable pulse to display
|
|
|
|
void pulse_enable () {
|
|
|
|
EN_Pin(0);
|
|
|
|
delay_usec (2); // time to settle BUS pin voltages
|
|
|
|
EN_Pin(1);
|
|
|
|
delay_usec (2); // >450 [nsec]
|
|
|
|
EN_Pin(0);
|
|
|
|
delay_usec (50); // > 37 [usec]
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Writes 4/8bit data to display and pulse the EN pin
|
|
|
|
//! \param data The data to write
|
|
|
|
void write_bits (uint8_t data) {
|
|
|
|
if constexpr (BusSize == 4) BUS (data & 0x0F);
|
|
|
|
else BUS (data);
|
|
|
|
pulse_enable ();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief
|
|
|
|
* Sends commands or character to display by controlling RS pin
|
|
|
|
* \param data The data to send
|
|
|
|
* \param mode Character/command mode (RS pin state)
|
|
|
|
*/
|
|
|
|
void send (uint8_t data, uint8_t mode) {
|
|
|
|
RS_Pin (mode);
|
|
|
|
if constexpr (BusSize == 4) {
|
|
|
|
write_bits (data >> 4);
|
|
|
|
write_bits (data & 0x0F);
|
|
|
|
} else {
|
|
|
|
write_bits (data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//! Send a command to display
|
|
|
|
void command (uint8_t c) { send(c, 0); }
|
|
|
|
//! Send a character to display
|
|
|
|
void character (uint8_t c) { send(c, 1); }
|
|
|
|
|
|
|
|
public:
|
|
|
|
//! \name Public API
|
|
|
|
//! @{
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief
|
|
|
|
* Initialize the display. After construction the object is valid but reflects the init state
|
|
|
|
* of display configuration. In order for the display to be functional it needs initialization.
|
|
|
|
* So the user has to call this function. This function requires a settled environment, so usually
|
|
|
|
* its called after main().
|
|
|
|
* \param mode 4bit or 8bit mode
|
|
|
|
* \param fontSize 5x8 or 5x10 dots font size.
|
|
|
|
*/
|
|
|
|
void init (FontSize fontSize =FontSize::dots_5x8) {
|
|
|
|
disp_mode_ = disp_mode_init_; // Set values to LCD's startup configuration
|
|
|
|
disp_control_ = disp_control_init_;
|
|
|
|
disp_function_=disp_function_init_;
|
|
|
|
|
|
|
|
// Read user configuration
|
|
|
|
if constexpr (BusSize == 4)
|
|
|
|
// note: keep this runtime, so the disp_function reflects lcd's configuration state
|
|
|
|
disp_function_ &= ~FunSet_8bitMode;
|
|
|
|
else
|
|
|
|
disp_function_ |= FunSet_8bitMode;
|
|
|
|
|
|
|
|
if (fontSize == FontSize::dots_5x10) {
|
|
|
|
disp_function_ |= FunSet_5x10dots;
|
|
|
|
disp_function_ &= ~FunSet_2Line;
|
|
|
|
cursor_.set_lines(Lines>>1);
|
|
|
|
} else {
|
|
|
|
disp_function_ &= ~FunSet_5x10dots;
|
|
|
|
disp_function_ |= FunSet_2Line;
|
|
|
|
cursor_.set_lines(Lines);
|
|
|
|
}
|
|
|
|
|
|
|
|
// start with All-zeros
|
|
|
|
BUS (0); EN_Pin(0); RS_Pin(0); BL_Pin(0);
|
|
|
|
|
|
|
|
delay_usec(100000);
|
|
|
|
if constexpr (BusSize == 4) {
|
|
|
|
// 4bit BUS
|
|
|
|
write_bits (0x03); // 1t try
|
|
|
|
delay_usec(20000);
|
|
|
|
write_bits (0x03); // 2nd try
|
|
|
|
delay_usec(5000);
|
|
|
|
write_bits (0x03); // 3rd try
|
|
|
|
delay_usec(5000);
|
|
|
|
write_bits (0x02); // We set 4 bit interface
|
|
|
|
delay_usec (10000);
|
|
|
|
} else {
|
|
|
|
// 8bit BUS
|
|
|
|
write_bits (Cmd_FunSet | disp_function_); // 1st try
|
|
|
|
delay_usec(20000);
|
|
|
|
write_bits (Cmd_FunSet | disp_function_); // 2nd try
|
|
|
|
delay_usec(5000);
|
|
|
|
write_bits (Cmd_FunSet | disp_function_); // 3rd try
|
|
|
|
delay_usec(5000);
|
|
|
|
}
|
|
|
|
command (Cmd_FunSet | disp_function_); // Finally we set #lines and font size
|
|
|
|
delay_usec(5000);
|
|
|
|
|
|
|
|
command (Cmd_DispCtrl | Display_Off); // Display off
|
|
|
|
delay_usec(5000);
|
|
|
|
command (Cmd_cls); // Clear screen
|
|
|
|
delay_usec(5000);
|
|
|
|
command (Cmd_EntryMode | disp_mode_); // Entry mode set
|
|
|
|
delay_usec(5000);
|
|
|
|
|
|
|
|
command (Cmd_RetHome); // Return home
|
|
|
|
delay_usec(10000);
|
|
|
|
display(true); // Finally display On, done.
|
|
|
|
cursor_.set(1, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Utility function to enable/disable power to display. This has an effect IFF there is a
|
|
|
|
//! power pin on the board
|
|
|
|
void power (bool en) {
|
|
|
|
PWR_Pin(en);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Utility function to enable/disable backlight. This has an effect IFF there is a
|
|
|
|
//! backlight pin on the board
|
|
|
|
void backlight (bool en) {
|
|
|
|
BL_Pin(en);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Utility function to send on/off command to display.
|
|
|
|
void display (bool en) {
|
|
|
|
if (en) disp_control_ |= Display_On;
|
|
|
|
else disp_control_ &= ~Display_On;
|
|
|
|
|
|
|
|
command (Cmd_DispCtrl | disp_control_);
|
|
|
|
delay_usec(100);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Utility function to enable/disable display cursor.
|
|
|
|
void cursor (bool en) {
|
|
|
|
if (en) disp_control_ |= Cursor_On;
|
|
|
|
else disp_control_ &= ~Cursor_On;
|
|
|
|
|
|
|
|
command (Cmd_DispCtrl | disp_control_);
|
|
|
|
delay_usec(100);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Utility function to enable/disable cursor blinking.
|
|
|
|
void blink (bool en) {
|
|
|
|
if (en) disp_control_ |= Blink_On;
|
|
|
|
else disp_control_ &= ~Blink_On;
|
|
|
|
|
|
|
|
command (Cmd_DispCtrl | disp_control_);
|
|
|
|
delay_usec(100);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Utility function to enable/disable autoscroll.
|
|
|
|
void autoscroll (bool en) {
|
|
|
|
if (en) disp_mode_ |= Entry_ShiftInc;
|
|
|
|
else disp_mode_ &= ~Entry_ShiftInc;
|
|
|
|
|
|
|
|
command (Cmd_EntryMode | disp_mode_);
|
|
|
|
delay_usec(100);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief
|
|
|
|
* Tool to set display cursor
|
|
|
|
* \param x The column position (starting with 1)
|
|
|
|
* \param y The line position (starting with 1 at the top of the display)
|
|
|
|
*/
|
|
|
|
void set_cursor (uint8_t x, uint8_t y) {
|
|
|
|
uint8_t offset;
|
|
|
|
switch (y) {
|
|
|
|
default:
|
|
|
|
case 1: offset = 0x0; break;
|
|
|
|
case 2: offset = 0x40; break;
|
|
|
|
case 3: offset = 0x0 + Columns; break;
|
|
|
|
case 4: offset = 0x40 + Columns; break;
|
|
|
|
}
|
|
|
|
command( Cmd_SetDRamAddr | offset | (x-1));
|
|
|
|
cursor_.set(x, y);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Utility function to set left to right entry mode.
|
|
|
|
//! \note
|
|
|
|
//! This is the default
|
|
|
|
void set_left_to_right () {
|
|
|
|
disp_mode_ |= Entry_Left;
|
|
|
|
command (Cmd_EntryMode | disp_mode_);
|
|
|
|
delay_usec(100);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Utility function to set right to left entry mode.
|
|
|
|
void set_right_to_left () {
|
|
|
|
disp_mode_ &= ~Entry_Left;
|
|
|
|
command (Cmd_EntryMode | disp_mode_);
|
|
|
|
delay_usec(100);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Command to scroll display left one position
|
|
|
|
void scroll_left () {
|
|
|
|
command (Cmd_Shift | DisMove_Display | DisMove_Left);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Command to scroll display right one position
|
|
|
|
void scroll_right () {
|
|
|
|
command (Cmd_Shift | DisMove_Display | DisMove_Right);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Clears the display and return home
|
|
|
|
void clear() {
|
|
|
|
command (Cmd_cls);
|
|
|
|
cursor_.set(1, 1);
|
|
|
|
delay_usec(2000);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! return home without clearing the display
|
|
|
|
void home() {
|
|
|
|
command (Cmd_RetHome);
|
|
|
|
cursor_.set(1, 1);
|
|
|
|
delay_usec(2000);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief
|
|
|
|
* Create custom character and store it to LCD.
|
|
|
|
* \param location The location to store the character [0..7] allowed
|
|
|
|
* \param charmap The character map buffer with the font
|
|
|
|
*/
|
|
|
|
void create_char (uint8_t location, uint8_t charmap[]) {
|
|
|
|
location &= 0x7; // we only have 8 locations 0-7
|
|
|
|
command(Cmd_SetGRamAddr | (location << 3));
|
|
|
|
for (size_t i=0; i<8; ++i) {
|
|
|
|
character(charmap[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief
|
|
|
|
* Send an ascii character to liquid crystal display.
|
|
|
|
* \param ch the character to send
|
|
|
|
* \return the character send.
|
|
|
|
*
|
|
|
|
* \note
|
|
|
|
* This is the driver's "putchar()" functionality to glue.
|
|
|
|
* Tailor this function to redirect stdout to display.
|
|
|
|
*/
|
|
|
|
int putchar (int ch) {
|
|
|
|
// LCD Character dispatcher
|
|
|
|
switch (ch) {
|
|
|
|
case 0:
|
|
|
|
// don't send null termination to device
|
|
|
|
break;
|
|
|
|
case '\n':
|
|
|
|
cursor_.inc_y();
|
|
|
|
set_cursor (1, cursor_.get_y());
|
|
|
|
break;
|
|
|
|
case '\r':
|
|
|
|
set_cursor (1, cursor_.get_y());
|
|
|
|
break;
|
|
|
|
case '\v':
|
|
|
|
home ();
|
|
|
|
break;
|
|
|
|
case '\f':
|
|
|
|
set_cursor (1, 1);
|
|
|
|
break;
|
|
|
|
case '\b':
|
|
|
|
--cursor_;
|
|
|
|
set_cursor (cursor_.get_x(), cursor_.get_y());
|
|
|
|
character (' ');
|
|
|
|
--cursor_;
|
|
|
|
set_cursor (cursor_.get_x(), cursor_.get_y());
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
character (ch);
|
|
|
|
++cursor_;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
//ANSI C (C99) compatible mode
|
|
|
|
return ch;
|
|
|
|
}
|
|
|
|
//! @}
|
|
|
|
|
|
|
|
private:
|
|
|
|
//! \name Data members
|
|
|
|
//! @{
|
|
|
|
|
|
|
|
//! The init entry mode of the display after power up
|
|
|
|
static constexpr uint8_t disp_mode_init_ = Entry_Left | Entry_ShiftDec;
|
|
|
|
//! The init control mode of the display after power up
|
|
|
|
static constexpr uint8_t disp_control_init_ = Display_Off | Cursor_Off | Blink_Off;
|
|
|
|
//! The init function set of the display after power up
|
|
|
|
static constexpr uint8_t disp_function_init_= FunSet_8bitMode | FunSet_1Line | FunSet_5x8dots;
|
|
|
|
|
|
|
|
Cursor cursor_{};
|
|
|
|
uint8_t disp_mode_ {disp_mode_init_};
|
|
|
|
uint8_t disp_control_ {disp_control_init_};
|
|
|
|
uint8_t disp_function_ {disp_function_init_};
|
|
|
|
/*!
|
|
|
|
* \note
|
|
|
|
* When the display powers up, it is configured as follows:
|
|
|
|
* 1. Display clear
|
|
|
|
* 2. Function set: 0x10
|
|
|
|
* DL = 1; 8-bit interface data
|
|
|
|
* N = 0; 1-line display
|
|
|
|
* F = 0; 5x8 dot character font
|
|
|
|
* 3. Display on/off control: 0x00
|
|
|
|
* D = 0; Display off
|
|
|
|
* C = 0; Cursor off
|
|
|
|
* B = 0; Blinking off
|
|
|
|
* 4. Entry mode set: 0x02
|
|
|
|
* I/D = 1; Increment by 1
|
|
|
|
* S = 0; No shift
|
|
|
|
*/
|
|
|
|
|
|
|
|
//! @}
|
|
|
|
};
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* TBX_DRV_LIQUID_CRYSTAL_H_ */
|