hd44780-controller 0.1.0-alpha.2

HD44780 LCD controller with async/sync support for embedded-hal
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

mod common;
pub use common::*;

pub mod enter_4bit;
pub use enter_4bit::Enter4Bit;

pub mod write_char;
pub use write_char::WriteChar;

pub mod set_backlight;
pub use set_backlight::SetBacklight;

pub mod clear_display;
pub use clear_display::ClearDisplay;

pub mod return_home;
pub use return_home::ReturnHome;

pub mod entry_mode_set;
pub use entry_mode_set::EntryModeSet;

pub mod display_on_off;
pub use display_on_off::DisplayOnOff;

pub mod cursor_or_display_shift;
pub use cursor_or_display_shift::CursorOrDisplayShift;

pub mod function_set;
pub use function_set::FunctionSet;

pub mod set_cgram_address;
pub use set_cgram_address::SetCGRamAddress;

pub mod set_ddram_address;
pub use set_ddram_address::SetDDRamAddress;

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum Error {
    DeviceError,
}

macro_rules! define_commands {
    (
        $( $variant:ident($ty:ty) ),* $(,)?
    ) => {
        #[derive(Clone, Debug, Eq, PartialEq)]
        pub enum Commands {
            $( $variant($ty), )*
        }


        impl SyncCommand for Commands {
            type Ret = ();
            type Err = Error;

            fn execute<D: super::device::SyncDevice + ?Sized>(&self, dev: &mut D) -> Result<Self::Ret, Self::Err> {
                match self {
                    $( Commands::$variant(cmd) => cmd.execute(dev), )*
                }
            }
        }

        #[cfg(feature = "async")]
        #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
        impl AsyncCommand for Commands {
            type Ret = ();
            type Err = Error;

            async fn execute_async<D: super::device::AsyncDevice + ?Sized>(
                &self,
                dev: &mut D,
            ) -> Result<Self::Ret, Self::Err> {
                match self {
                    $( Commands::$variant(cmd) => cmd.execute_async(dev).await, )*
                }
            }
        }

        $(
            impl From<$ty> for Commands {
                fn from(cmd: $ty) -> Self {
                    Commands::$variant(cmd)
                }
            }
        )*
    };
}

define_commands! {
    Enter4Bit(Enter4Bit),
    WriteChar(WriteChar),
    SetBacklight(SetBacklight),
    ClearDisplay(ClearDisplay),
    ReturnHome(ReturnHome),
    EntryModeSet(EntryModeSet),
    DisplayOnOnff(DisplayOnOff),
    CursorOrDisplayShift(CursorOrDisplayShift),
    FunctionSet(FunctionSet),
    SetCGRamAddress(SetCGRamAddress),
    SetDDRamAddress(SetDDRamAddress),
}