tft-rs 0.1.0

An interfacing library for several TFT LCD displays
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use crate::drivers::DisplayDriver;
use crate::Error;
use embedded_graphics_core::draw_target::DrawTarget;
use embedded_graphics_core::geometry::Dimensions;
use embedded_graphics_core::prelude::*;
use embedded_graphics_core::primitives::Rectangle;
use embedded_graphics_core::Pixel;
use embedded_hal::delay::DelayNs;
use embedded_hal::digital::OutputPin;
use embedded_hal::spi::SpiDevice;

pub struct Display<DI: DisplayInterface, BL, DRIVER> {
    di: DI,
    bl: Option<BL>,
    driver: DRIVER,
}

impl<SPI, DC, RST, DELAY, BL, DRIVER> Display<DisplayInterfaceImpl<SPI, DC, RST, DELAY>, BL, DRIVER>
where
    BL: OutputPin,
    DRIVER: DisplayDriver,
    SPI: SpiDevice,
    DC: OutputPin,
    RST: OutputPin,
    DELAY: DelayNs,
{
    pub fn new(
        spi: SPI,
        dc: DC,
        rst: RST,
        bl: Option<BL>,
        delay: DELAY,
        driver: DRIVER,
    ) -> Result<Self, Error> {
        let di = DisplayInterfaceImpl {
            spi,
            dc,
            rst,
            delay,
        };
        let mut device = Self { di, bl, driver };
        device.driver.init(&mut device.di)?;
        if let Some(bl) = &mut device.bl {
            bl.set_high().map_err(|_| Error::GPIO)?;
        }
        Ok(device)
    }
}

pub struct DisplayInterfaceImpl<SPI: SpiDevice, DC: OutputPin, RST: OutputPin, DELAY: DelayNs> {
    spi: SPI,
    dc: DC,
    rst: RST,
    delay: DELAY,
}

pub trait DisplayInterface {
    fn spi(&mut self) -> &mut impl SpiDevice;
    fn dc(&mut self) -> &mut impl OutputPin;
    fn reset(&mut self) -> &mut impl OutputPin;
    fn delay(&mut self) -> &mut impl DelayNs;
}

impl<SPI: SpiDevice, DC: OutputPin, RST: OutputPin, DELAY: DelayNs> DisplayInterface
    for DisplayInterfaceImpl<SPI, DC, RST, DELAY>
{
    fn spi(&mut self) -> &mut impl SpiDevice {
        &mut self.spi
    }

    fn dc(&mut self) -> &mut impl OutputPin {
        &mut self.dc
    }

    fn reset(&mut self) -> &mut impl OutputPin {
        &mut self.rst
    }

    fn delay(&mut self) -> &mut impl DelayNs {
        &mut self.delay
    }
}

impl<DI: DisplayInterface, BL, DRIVER: DisplayDriver> Dimensions for Display<DI, BL, DRIVER> {
    fn bounding_box(&self) -> Rectangle {
        Rectangle::new(Point::new(0, 0), self.driver.bounding_box().size)
    }
}

impl<DI: DisplayInterface, BL, DRIVER: DisplayDriver> DrawTarget for Display<DI, BL, DRIVER> {
    type Color = DRIVER::Color;
    type Error = Error;

    fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
    where
        I: IntoIterator<Item = Pixel<Self::Color>>,
    {
        for Pixel(p, c) in pixels {
            if !(self.bounding_box().contains(p)) {
                continue;
            }
            self.driver
                .set_draw_area(&mut self.di, &Rectangle::new(p, Size::new(2, 2)))?;
            self.driver.write_color_data(&mut self.di, [c])?
        }
        Ok(())
    }

    fn fill_contiguous<I>(&mut self, area: &Rectangle, colors: I) -> Result<(), Self::Error>
    where
        I: IntoIterator<Item = Self::Color>,
    {
        let bb = self.bounding_box();
        let area = self.bounding_box().intersection(area);
        self.driver.set_draw_area(&mut self.di, &area)?;
        let iter = area
            .points()
            .zip(colors)
            .filter(|(p, _)| bb.contains(*p))
            .map(|x| x.1);
        self.driver.write_color_data(&mut self.di, iter)
    }
}