mirror of
https://github.com/yuri91/ili9341-rs.git
synced 2024-06-02 09:50:10 +00:00
Compare commits
47 commits
Author | SHA1 | Date | |
---|---|---|---|
7fa69abd72 | |||
693f0bdd8f | |||
7318f971cf | |||
ac73c3ba40 | |||
aa0003d0a4 | |||
32ca78087c | |||
0cdd4e7c2e | |||
df5ea50076 | |||
00a50a13cc | |||
99f6e63918 | |||
a5e7f6498a | |||
bfb77647d5 | |||
1f47f5797e | |||
d896467aec | |||
6e8c814156 | |||
d933649c19 | |||
d4e883ce8d | |||
6e1fab6da7 | |||
b0f3b14664 | |||
8aeefc4abc | |||
11661b20b6 | |||
c3d0d08a3c | |||
8a4aee95c2 | |||
19efa445bf | |||
634558b18e | |||
e33b10c885 | |||
ddffec49c6 | |||
7c2e3e27fb | |||
115fec7703 | |||
47d4a07469 | |||
c93637abfd | |||
510d0c9a03 | |||
535feb236c | |||
be44c24eea | |||
954d111959 | |||
d9f35775d6 | |||
a68c0530ec | |||
ea9cb59bff | |||
8884885ca0 | |||
2b7ee112fb | |||
e350936d82 | |||
509060bb5d | |||
b5077900be | |||
64963398c7 | |||
6adc0191d1 | |||
81377dfddf | |||
afbfd98f9d |
28
Cargo.toml
28
Cargo.toml
|
@ -1,6 +1,8 @@
|
|||
# Copyright 2022 Arm Limited and/or its affiliates <open-source-office@arm.com>
|
||||
|
||||
[package]
|
||||
name = "ili9341"
|
||||
version = "0.4.0"
|
||||
version = "0.6.0"
|
||||
description = "A platform agnostic driver to interface with the ILI9341 (ald ILI9340C) TFT LCD display"
|
||||
authors = ["Yuri Iozzelli <y.iozzelli@gmail.com>"]
|
||||
categories = ["embedded", "hardware-support", "no-std"]
|
||||
|
@ -11,13 +13,27 @@ edition = "2018"
|
|||
|
||||
|
||||
[dependencies]
|
||||
display-interface = "0.4.0"
|
||||
embedded-hal = "0.2.4"
|
||||
display-interface = "0.5"
|
||||
embedded-hal = "1.0.0"
|
||||
|
||||
[dependencies.embedded-graphics]
|
||||
[dependencies.embedded-graphics-core]
|
||||
optional = true
|
||||
version = "0.6.2"
|
||||
version = "0.4"
|
||||
|
||||
[dev-dependencies]
|
||||
cortex-m-rtic = "1.0.0"
|
||||
cortex-m = "0.7.3"
|
||||
cortex-m-rt = "0.7.0"
|
||||
defmt-rtt = "0.3.0"
|
||||
panic-semihosting = "0.6"
|
||||
|
||||
[dev-dependencies.stm32f4xx-hal]
|
||||
version = "0.12.0"
|
||||
features = ["stm32f411"]
|
||||
|
||||
[features]
|
||||
default = ["graphics"]
|
||||
graphics = ["embedded-graphics"]
|
||||
graphics = ["embedded-graphics-core"]
|
||||
|
||||
[[example]]
|
||||
name = "rtic"
|
||||
|
|
|
@ -1,5 +1,9 @@
|
|||
# `ili9341`
|
||||
|
||||
[![Crates.io](https://img.shields.io/crates/d/ili9341.svg)](https://crates.io/crates/ili9341)
|
||||
[![Crates.io](https://img.shields.io/crates/v/ili9341.svg)](https://crates.io/crates/ili9341)
|
||||
[![Released API docs](https://docs.rs/ili9341/badge.svg)](https://docs.rs/ili9341)
|
||||
|
||||
> A platform agnostic driver to interface with the ILI9341 (and ILI9340C) TFT
|
||||
> LCD display
|
||||
|
||||
|
@ -7,12 +11,12 @@
|
|||
|
||||
- Putting pixels on the screen
|
||||
- Change the screen orientation
|
||||
- Hardware scrolling
|
||||
- Compatible with [embedded-graphics](https://docs.rs/embedded-graphics)
|
||||
|
||||
## TODO
|
||||
|
||||
- [ ] Expose more configuration options
|
||||
- [ ] Scrolling
|
||||
- [ ] Read video memory
|
||||
- [ ] DMA API
|
||||
- ???
|
||||
|
|
109
examples/rtic.rs
Normal file
109
examples/rtic.rs
Normal file
|
@ -0,0 +1,109 @@
|
|||
//! cortex-m-rtic example
|
||||
//! Tested on BlackPill dev board with stm32f411ceu microcontroller
|
||||
//! The LCD RESET pin was hard puled to Vcc therefore
|
||||
//! DummyOutputPin was used as the reset pin
|
||||
|
||||
#![no_main]
|
||||
#![no_std]
|
||||
|
||||
#[rtic::app(device = stm32f4xx_hal::pac)]
|
||||
mod app {
|
||||
use display_interface_spi::SPIInterface;
|
||||
use embedded_graphics::{
|
||||
mono_font::{ascii::FONT_6X10, MonoTextStyle},
|
||||
pixelcolor::Rgb565,
|
||||
prelude::*,
|
||||
text::{Alignment, Text},
|
||||
};
|
||||
use embedded_hal::digital::{blocking::OutputPin, ErrorType, PinState};
|
||||
use ili9341::{DisplaySize240x320, Ili9341, Orientation};
|
||||
use stm32f4xx_hal::{
|
||||
prelude::*,
|
||||
spi::{Mode, NoMiso, Phase, Polarity},
|
||||
timer::Channel,
|
||||
};
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct DummyOutputPin;
|
||||
impl ErrorType for DummyOutputPin {
|
||||
type Error = ();
|
||||
}
|
||||
|
||||
impl OutputPin for DummyOutputPin {
|
||||
fn set_low(&mut self) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn set_high(&mut self) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
fn set_state(&mut self, _state: PinState) -> Result<(), Self::Error> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[shared]
|
||||
struct Shared {}
|
||||
|
||||
#[local]
|
||||
struct Local {}
|
||||
|
||||
#[init]
|
||||
fn init(ctx: init::Context) -> (Shared, Local, init::Monotonics) {
|
||||
let dp = ctx.device;
|
||||
|
||||
let rcc = dp.RCC.constrain();
|
||||
let clocks = rcc.cfgr.use_hse(25.MHz()).sysclk(100.MHz()).freeze();
|
||||
|
||||
let gpioa = dp.GPIOA.split();
|
||||
let gpiob = dp.GPIOB.split();
|
||||
|
||||
/*
|
||||
* The ILI9341 driver
|
||||
*/
|
||||
let lcd_clk = gpiob.pb0.into_alternate();
|
||||
let lcd_miso = NoMiso {};
|
||||
let lcd_mosi = gpioa.pa10.into_alternate().internal_pull_up(true);
|
||||
let lcd_dc = gpiob.pb1.into_push_pull_output();
|
||||
let lcd_cs = gpiob.pb2.into_push_pull_output();
|
||||
let mode = Mode {
|
||||
polarity: Polarity::IdleLow,
|
||||
phase: Phase::CaptureOnFirstTransition,
|
||||
};
|
||||
let lcd_spi = dp
|
||||
.SPI5
|
||||
.spi((lcd_clk, lcd_miso, lcd_mosi), mode, 2.MHz(), &clocks);
|
||||
let spi_iface = SPIInterface::new(lcd_spi, lcd_dc, lcd_cs);
|
||||
let dummy_reset = DummyOutputPin::default();
|
||||
let mut delay = dp.TIM1.delay_us(&clocks);
|
||||
let mut lcd = Ili9341::new(
|
||||
spi_iface,
|
||||
dummy_reset,
|
||||
&mut delay,
|
||||
Orientation::PortraitFlipped,
|
||||
DisplaySize240x320,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// Create a new character style
|
||||
let style = MonoTextStyle::new(&FONT_6X10, Rgb565::RED);
|
||||
|
||||
// Create a text at position (20, 30) and draw it using the previously defined style
|
||||
Text::with_alignment(
|
||||
"First line\nSecond line",
|
||||
Point::new(20, 30),
|
||||
style,
|
||||
Alignment::Center,
|
||||
)
|
||||
.draw(&mut lcd)
|
||||
.unwrap();
|
||||
|
||||
(Shared {}, Local {}, init::Monotonics())
|
||||
}
|
||||
|
||||
#[idle(local = [])]
|
||||
fn idle(cx: idle::Context) -> ! {
|
||||
loop {
|
||||
cortex_m::asm::nop();
|
||||
}
|
||||
}
|
||||
}
|
|
@ -1,94 +0,0 @@
|
|||
use crate::{Ili9341, OutputPin};
|
||||
|
||||
use core::{fmt::Debug, iter};
|
||||
|
||||
use embedded_graphics::{
|
||||
drawable::Pixel,
|
||||
geometry::{Point, Size},
|
||||
pixelcolor::{
|
||||
raw::{RawData, RawU16},
|
||||
Rgb565,
|
||||
},
|
||||
primitives::Rectangle,
|
||||
style::{PrimitiveStyle, Styled},
|
||||
DrawTarget,
|
||||
};
|
||||
|
||||
impl<PinE, IFACE, RESET> DrawTarget<Rgb565> for Ili9341<IFACE, RESET>
|
||||
where
|
||||
IFACE: display_interface::WriteOnlyDataCommand,
|
||||
RESET: OutputPin<Error = PinE>,
|
||||
PinE: Debug,
|
||||
{
|
||||
type Error = crate::Error<PinE>;
|
||||
|
||||
fn size(&self) -> Size {
|
||||
Size::new(self.width as u32, self.height as u32)
|
||||
}
|
||||
|
||||
fn draw_pixel(&mut self, pixel: Pixel<Rgb565>) -> Result<(), Self::Error> {
|
||||
let Pixel(pos, color) = pixel;
|
||||
|
||||
if pos.x < 0 || pos.y < 0 || pos.x >= self.width as i32 || pos.y >= self.height as i32 {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
self.draw_raw(
|
||||
pos.x as u16,
|
||||
pos.y as u16,
|
||||
pos.x as u16,
|
||||
pos.y as u16,
|
||||
&[RawU16::from(color).into_inner()],
|
||||
)
|
||||
}
|
||||
|
||||
fn draw_rectangle(
|
||||
&mut self,
|
||||
item: &Styled<Rectangle, PrimitiveStyle<Rgb565>>,
|
||||
) -> Result<(), Self::Error> {
|
||||
let Point { x: x0, y: y0 } = item.primitive.top_left;
|
||||
let Point { x: x1, y: y1 } = item.primitive.bottom_right;
|
||||
let w = self.width as i32;
|
||||
let h = self.height as i32;
|
||||
if x0 >= w || y0 >= h {
|
||||
return Ok(());
|
||||
}
|
||||
fn clamp(v: i32, max: i32) -> u16 {
|
||||
if v < 0 {
|
||||
0
|
||||
} else if v > max {
|
||||
max as u16
|
||||
} else {
|
||||
v as u16
|
||||
}
|
||||
}
|
||||
let x0 = clamp(x0, w - 1);
|
||||
let y0 = clamp(y0, h - 1);
|
||||
let x1 = clamp(x1, w - 1);
|
||||
let y1 = clamp(y1, h - 1);
|
||||
self.draw_iter(
|
||||
x0,
|
||||
y0,
|
||||
x1,
|
||||
y1,
|
||||
item.into_iter()
|
||||
.filter(|p| {
|
||||
let Point { x, y } = p.0;
|
||||
x >= 0 && y >= 0 && x < w && y < h
|
||||
})
|
||||
.map(|p| RawU16::from(p.1).into_inner()),
|
||||
)
|
||||
}
|
||||
|
||||
fn clear(&mut self, color: Rgb565) -> Result<(), Self::Error> {
|
||||
let color = RawU16::from(color).into_inner();
|
||||
|
||||
self.draw_iter(
|
||||
0,
|
||||
0,
|
||||
(self.width - 1) as u16,
|
||||
(self.height - 1) as u16,
|
||||
iter::repeat(color).take(self.width * self.height),
|
||||
)
|
||||
}
|
||||
}
|
82
src/graphics_core.rs
Normal file
82
src/graphics_core.rs
Normal file
|
@ -0,0 +1,82 @@
|
|||
use crate::Ili9341;
|
||||
use embedded_graphics_core::{
|
||||
pixelcolor::{raw::RawU16, Rgb565},
|
||||
prelude::*,
|
||||
primitives::Rectangle,
|
||||
};
|
||||
|
||||
impl<IFACE, RESET> OriginDimensions for Ili9341<IFACE, RESET> {
|
||||
fn size(&self) -> Size {
|
||||
Size::new(self.width() as u32, self.height() as u32)
|
||||
}
|
||||
}
|
||||
|
||||
impl<IFACE, RESET> DrawTarget for Ili9341<IFACE, RESET>
|
||||
where
|
||||
IFACE: display_interface::WriteOnlyDataCommand,
|
||||
{
|
||||
type Error = display_interface::DisplayError;
|
||||
|
||||
type Color = Rgb565;
|
||||
|
||||
fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
|
||||
where
|
||||
I: IntoIterator<Item = Pixel<Self::Color>>,
|
||||
{
|
||||
for Pixel(point, color) in pixels {
|
||||
if self.bounding_box().contains(point) {
|
||||
let x = point.x as u16;
|
||||
let y = point.y as u16;
|
||||
let color = RawU16::from(color).into_inner();
|
||||
self.draw_raw_slice(x, y, x, y, &[color])?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn fill_contiguous<I>(&mut self, area: &Rectangle, colors: I) -> Result<(), Self::Error>
|
||||
where
|
||||
I: IntoIterator<Item = Self::Color>,
|
||||
{
|
||||
let drawable_area = area.intersection(&self.bounding_box());
|
||||
|
||||
if let Some(drawable_bottom_right) = drawable_area.bottom_right() {
|
||||
let x0 = drawable_area.top_left.x as u16;
|
||||
let y0 = drawable_area.top_left.y as u16;
|
||||
let x1 = drawable_bottom_right.x as u16;
|
||||
let y1 = drawable_bottom_right.y as u16;
|
||||
|
||||
if area == &drawable_area {
|
||||
// All pixels are on screen
|
||||
self.draw_raw_iter(
|
||||
x0,
|
||||
y0,
|
||||
x1,
|
||||
y1,
|
||||
area.points()
|
||||
.zip(colors)
|
||||
.map(|(_, color)| RawU16::from(color).into_inner()),
|
||||
)
|
||||
} else {
|
||||
// Some pixels are on screen
|
||||
self.draw_raw_iter(
|
||||
x0,
|
||||
y0,
|
||||
x1,
|
||||
y1,
|
||||
area.points()
|
||||
.zip(colors)
|
||||
.filter(|(point, _)| drawable_area.contains(*point))
|
||||
.map(|(_, color)| RawU16::from(color).into_inner()),
|
||||
)
|
||||
}
|
||||
} else {
|
||||
// No pixels are on screen
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error> {
|
||||
self.clear_screen(RawU16::from(color).into_inner())
|
||||
}
|
||||
}
|
435
src/lib.rs
435
src/lib.rs
|
@ -1,49 +1,82 @@
|
|||
#![no_std]
|
||||
|
||||
#[cfg(feature = "graphics")]
|
||||
extern crate embedded_graphics;
|
||||
//! ILI9341 Display Driver
|
||||
//!
|
||||
//! ### Usage
|
||||
//!
|
||||
//! To control the display you need to set up:
|
||||
//!
|
||||
//! * Interface for communicating with display ([display-interface-spi crate] for SPI)
|
||||
//! * Configuration (reset pin, delay, orientation and size) for display
|
||||
//!
|
||||
//! ```ignore
|
||||
//! let iface = SPIInterface::new(spi, dc, cs);
|
||||
//!
|
||||
//! let mut display = Ili9341::new(
|
||||
//! iface,
|
||||
//! reset_gpio,
|
||||
//! &mut delay,
|
||||
//! Orientation::Landscape,
|
||||
//! ili9341::DisplaySize240x320,
|
||||
//! )
|
||||
//! .unwrap();
|
||||
//!
|
||||
//! display.clear(Rgb565::RED).unwrap()
|
||||
//! ```
|
||||
//!
|
||||
//! [display-interface-spi crate]: https://crates.io/crates/display-interface-spi
|
||||
use embedded_hal::delay::DelayNs;
|
||||
use embedded_hal::digital::OutputPin;
|
||||
|
||||
use embedded_hal::blocking::delay::DelayMs;
|
||||
use embedded_hal::digital::v2::OutputPin;
|
||||
|
||||
use core::iter::once;
|
||||
use display_interface::DataFormat::{U16BEIter, U8Iter};
|
||||
use display_interface::DataFormat;
|
||||
use display_interface::WriteOnlyDataCommand;
|
||||
|
||||
pub mod spi;
|
||||
#[cfg(feature = "graphics")]
|
||||
mod graphics_core;
|
||||
|
||||
/// Trait representing the interface to the hardware.
|
||||
pub use embedded_hal::spi::MODE_0 as SPI_MODE;
|
||||
|
||||
pub use display_interface::DisplayError;
|
||||
|
||||
type Result<T = (), E = DisplayError> = core::result::Result<T, E>;
|
||||
|
||||
/// Trait that defines display size information
|
||||
pub trait DisplaySize {
|
||||
/// Width in pixels
|
||||
const WIDTH: usize;
|
||||
/// Height in pixels
|
||||
const HEIGHT: usize;
|
||||
}
|
||||
|
||||
/// Generic display size of 240x320 pixels
|
||||
pub struct DisplaySize240x320;
|
||||
|
||||
impl DisplaySize for DisplaySize240x320 {
|
||||
const WIDTH: usize = 240;
|
||||
const HEIGHT: usize = 320;
|
||||
}
|
||||
|
||||
/// Generic display size of 320x480 pixels
|
||||
pub struct DisplaySize320x480;
|
||||
|
||||
impl DisplaySize for DisplaySize320x480 {
|
||||
const WIDTH: usize = 320;
|
||||
const HEIGHT: usize = 480;
|
||||
}
|
||||
|
||||
/// For quite a few boards (ESP32-S2-Kaluga-1, M5Stack, M5Core2 and others),
|
||||
/// the ILI9341 initialization command arguments are slightly different
|
||||
///
|
||||
/// Intended to abstract the various buses (SPI, MPU 8/9/16-bit) from the Controller code.
|
||||
pub trait Interface {
|
||||
type Error;
|
||||
/// This trait provides the flexibility for users to define their own
|
||||
/// initialization command arguments suitable for the particular board they are using
|
||||
pub trait Mode {
|
||||
fn mode(&self) -> u8;
|
||||
|
||||
/// Sends a command with a sequence of 8-bit arguments
|
||||
///
|
||||
/// Mostly used for sending configuration commands
|
||||
fn write(&mut self, command: u8, data: &[u8]) -> Result<(), Self::Error>;
|
||||
|
||||
/// Sends a command with a sequence of 16-bit data words
|
||||
///
|
||||
/// Mostly used for sending MemoryWrite command and other commands
|
||||
/// with 16-bit arguments
|
||||
fn write_iter(
|
||||
&mut self,
|
||||
command: u8,
|
||||
data: impl IntoIterator<Item = u16>,
|
||||
) -> Result<(), Self::Error>;
|
||||
fn is_landscape(&self) -> bool;
|
||||
}
|
||||
|
||||
const WIDTH: usize = 240;
|
||||
const HEIGHT: usize = 320;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum Error<PinE> {
|
||||
Interface,
|
||||
OutputPin(PinE),
|
||||
}
|
||||
|
||||
/// The default orientation is Portrait
|
||||
/// The default implementation of the Mode trait from above
|
||||
/// Should work for most (but not all) boards
|
||||
pub enum Orientation {
|
||||
Portrait,
|
||||
PortraitFlipped,
|
||||
|
@ -51,9 +84,32 @@ pub enum Orientation {
|
|||
LandscapeFlipped,
|
||||
}
|
||||
|
||||
impl Mode for Orientation {
|
||||
fn mode(&self) -> u8 {
|
||||
match self {
|
||||
Self::Portrait => 0x40 | 0x08,
|
||||
Self::Landscape => 0x20 | 0x08,
|
||||
Self::PortraitFlipped => 0x80 | 0x08,
|
||||
Self::LandscapeFlipped => 0x40 | 0x80 | 0x20 | 0x08,
|
||||
}
|
||||
}
|
||||
|
||||
fn is_landscape(&self) -> bool {
|
||||
match self {
|
||||
Self::Landscape | Self::LandscapeFlipped => true,
|
||||
Self::Portrait | Self::PortraitFlipped => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Specify state of specific mode of operation
|
||||
pub enum ModeState {
|
||||
On,
|
||||
Off,
|
||||
}
|
||||
|
||||
/// There are two method for drawing to the screen:
|
||||
/// [draw_raw](struct.Ili9341.html#method.draw_raw) and
|
||||
/// [draw_iter](struct.Ili9341.html#method.draw_iter).
|
||||
/// [Ili9341::draw_raw_iter] and [Ili9341::draw_raw_slice]
|
||||
///
|
||||
/// In both cases the expected pixel format is rgb565.
|
||||
///
|
||||
|
@ -72,74 +128,91 @@ pub struct Ili9341<IFACE, RESET> {
|
|||
reset: RESET,
|
||||
width: usize,
|
||||
height: usize,
|
||||
landscape: bool,
|
||||
}
|
||||
|
||||
impl<PinE, IFACE, RESET> Ili9341<IFACE, RESET>
|
||||
impl<IFACE, RESET> Ili9341<IFACE, RESET>
|
||||
where
|
||||
IFACE: WriteOnlyDataCommand,
|
||||
RESET: OutputPin<Error = PinE>,
|
||||
RESET: OutputPin,
|
||||
{
|
||||
pub fn new<DELAY: DelayMs<u16>>(
|
||||
pub fn new<DELAY, SIZE, MODE>(
|
||||
interface: IFACE,
|
||||
reset: RESET,
|
||||
delay: &mut DELAY,
|
||||
) -> Result<Self, Error<PinE>> {
|
||||
mode: MODE,
|
||||
_display_size: SIZE,
|
||||
) -> Result<Self>
|
||||
where
|
||||
DELAY: DelayNs,
|
||||
SIZE: DisplaySize,
|
||||
MODE: Mode,
|
||||
{
|
||||
let mut ili9341 = Ili9341 {
|
||||
interface,
|
||||
reset,
|
||||
width: WIDTH,
|
||||
height: HEIGHT,
|
||||
width: SIZE::WIDTH,
|
||||
height: SIZE::HEIGHT,
|
||||
landscape: false,
|
||||
};
|
||||
|
||||
// Do hardware reset by holding reset low for at least 10us
|
||||
ili9341.reset.set_low().map_err(Error::OutputPin)?;
|
||||
delay.delay_ms(1);
|
||||
ili9341.reset.set_low().map_err(|_| DisplayError::RSError)?;
|
||||
let _ = delay.delay_ms(1);
|
||||
// Set high for normal operation
|
||||
ili9341.reset.set_high().map_err(Error::OutputPin)?;
|
||||
ili9341
|
||||
.reset
|
||||
.set_high()
|
||||
.map_err(|_| DisplayError::RSError)?;
|
||||
|
||||
// Wait 5ms after reset before sending commands
|
||||
// and 120ms before sending Sleep Out
|
||||
delay.delay_ms(5);
|
||||
let _ = delay.delay_ms(5);
|
||||
|
||||
// Do software reset
|
||||
ili9341.command(Command::SoftwareReset, &[])?;
|
||||
|
||||
// Wait 5ms after reset before sending commands
|
||||
// and 120ms before sending Sleep Out
|
||||
delay.delay_ms(120);
|
||||
let _ = delay.delay_ms(120);
|
||||
|
||||
ili9341.set_orientation(Orientation::Portrait)?;
|
||||
ili9341.set_orientation(mode)?;
|
||||
|
||||
// Set pixel format to 16 bits per pixel
|
||||
ili9341.command(Command::PixelFormatSet, &[0x55])?;
|
||||
|
||||
ili9341.command(Command::SleepOut, &[])?;
|
||||
ili9341.sleep_mode(ModeState::Off)?;
|
||||
|
||||
// Wait 5ms after Sleep Out before sending commands
|
||||
delay.delay_ms(5);
|
||||
let _ = delay.delay_ms(5);
|
||||
|
||||
ili9341.command(Command::DisplayOn, &[])?;
|
||||
ili9341.display_mode(ModeState::On)?;
|
||||
|
||||
Ok(ili9341)
|
||||
}
|
||||
}
|
||||
|
||||
fn command(&mut self, cmd: Command, args: &[u8]) -> Result<(), Error<PinE>> {
|
||||
self.interface
|
||||
.send_commands(U8Iter(&mut once(cmd as u8)))
|
||||
.map_err(|_| Error::Interface)?;
|
||||
self.interface
|
||||
.send_data(U8Iter(&mut args.iter().cloned()))
|
||||
.map_err(|_| Error::Interface)
|
||||
impl<IFACE, RESET> Ili9341<IFACE, RESET>
|
||||
where
|
||||
IFACE: WriteOnlyDataCommand,
|
||||
{
|
||||
fn command(&mut self, cmd: Command, args: &[u8]) -> Result {
|
||||
self.interface.send_commands(DataFormat::U8(&[cmd as u8]))?;
|
||||
self.interface.send_data(DataFormat::U8(args))
|
||||
}
|
||||
|
||||
fn write_iter<I: IntoIterator<Item = u16>>(&mut self, data: I) -> Result<(), Error<PinE>> {
|
||||
fn write_iter<I: IntoIterator<Item = u16>>(&mut self, data: I) -> Result {
|
||||
self.command(Command::MemoryWrite, &[])?;
|
||||
self.interface
|
||||
.send_data(U16BEIter(&mut data.into_iter()))
|
||||
.map_err(|_| Error::Interface)
|
||||
use DataFormat::U16BEIter;
|
||||
self.interface.send_data(U16BEIter(&mut data.into_iter()))
|
||||
}
|
||||
|
||||
fn set_window(&mut self, x0: u16, y0: u16, x1: u16, y1: u16) -> Result<(), Error<PinE>> {
|
||||
fn write_slice(&mut self, data: &[u16]) -> Result {
|
||||
self.command(Command::MemoryWrite, &[])?;
|
||||
self.interface.send_data(DataFormat::U16(data))
|
||||
}
|
||||
|
||||
fn set_window(&mut self, x0: u16, y0: u16, x1: u16, y1: u16) -> Result {
|
||||
self.command(
|
||||
Command::ColumnAddressSet,
|
||||
&[
|
||||
|
@ -157,8 +230,51 @@ where
|
|||
(y1 >> 8) as u8,
|
||||
(y1 & 0xff) as u8,
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
/// Configures the screen for hardware-accelerated vertical scrolling.
|
||||
pub fn configure_vertical_scroll(
|
||||
&mut self,
|
||||
fixed_top_lines: u16,
|
||||
fixed_bottom_lines: u16,
|
||||
) -> Result<Scroller> {
|
||||
let height = if self.landscape {
|
||||
self.width
|
||||
} else {
|
||||
self.height
|
||||
} as u16;
|
||||
let scroll_lines = height as u16 - fixed_top_lines - fixed_bottom_lines;
|
||||
|
||||
self.command(
|
||||
Command::VerticalScrollDefine,
|
||||
&[
|
||||
(fixed_top_lines >> 8) as u8,
|
||||
(fixed_top_lines & 0xff) as u8,
|
||||
(scroll_lines >> 8) as u8,
|
||||
(scroll_lines & 0xff) as u8,
|
||||
(fixed_bottom_lines >> 8) as u8,
|
||||
(fixed_bottom_lines & 0xff) as u8,
|
||||
],
|
||||
)?;
|
||||
Ok(())
|
||||
|
||||
Ok(Scroller::new(fixed_top_lines, fixed_bottom_lines, height))
|
||||
}
|
||||
|
||||
pub fn scroll_vertically(&mut self, scroller: &mut Scroller, num_lines: u16) -> Result {
|
||||
scroller.top_offset += num_lines;
|
||||
if scroller.top_offset > (scroller.height - scroller.fixed_bottom_lines) {
|
||||
scroller.top_offset = scroller.fixed_top_lines
|
||||
+ (scroller.top_offset + scroller.fixed_bottom_lines - scroller.height)
|
||||
}
|
||||
|
||||
self.command(
|
||||
Command::VerticalScrollAddr,
|
||||
&[
|
||||
(scroller.top_offset >> 8) as u8,
|
||||
(scroller.top_offset & 0xff) as u8,
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
/// Draw a rectangle on the screen, represented by top-left corner (x0, y0)
|
||||
|
@ -170,14 +286,14 @@ where
|
|||
///
|
||||
/// The iterator is useful to avoid wasting memory by holding a buffer for
|
||||
/// the whole screen when it is not necessary.
|
||||
pub fn draw_iter<I: IntoIterator<Item = u16>>(
|
||||
pub fn draw_raw_iter<I: IntoIterator<Item = u16>>(
|
||||
&mut self,
|
||||
x0: u16,
|
||||
y0: u16,
|
||||
x1: u16,
|
||||
y1: u16,
|
||||
data: I,
|
||||
) -> Result<(), Error<PinE>> {
|
||||
) -> Result {
|
||||
self.set_window(x0, y0, x1, y1)?;
|
||||
self.write_iter(data)
|
||||
}
|
||||
|
@ -191,44 +307,96 @@ where
|
|||
/// video memory.
|
||||
///
|
||||
/// The expected format is rgb565.
|
||||
pub fn draw_raw(
|
||||
&mut self,
|
||||
x0: u16,
|
||||
y0: u16,
|
||||
x1: u16,
|
||||
y1: u16,
|
||||
data: &[u16],
|
||||
) -> Result<(), Error<PinE>> {
|
||||
pub fn draw_raw_slice(&mut self, x0: u16, y0: u16, x1: u16, y1: u16, data: &[u16]) -> Result {
|
||||
self.set_window(x0, y0, x1, y1)?;
|
||||
self.write_iter(data.iter().cloned())
|
||||
self.write_slice(data)
|
||||
}
|
||||
|
||||
/// Change the orientation of the screen
|
||||
pub fn set_orientation(&mut self, mode: Orientation) -> Result<(), Error<PinE>> {
|
||||
pub fn set_orientation<MODE>(&mut self, mode: MODE) -> Result
|
||||
where
|
||||
MODE: Mode,
|
||||
{
|
||||
self.command(Command::MemoryAccessControl, &[mode.mode()])?;
|
||||
|
||||
if self.landscape ^ mode.is_landscape() {
|
||||
core::mem::swap(&mut self.height, &mut self.width);
|
||||
}
|
||||
self.landscape = mode.is_landscape();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Fill entire screen with specfied color u16 value
|
||||
pub fn clear_screen(&mut self, color: u16) -> Result {
|
||||
let color = core::iter::repeat(color).take(self.width * self.height);
|
||||
self.draw_raw_iter(0, 0, self.width as u16, self.height as u16, color)
|
||||
}
|
||||
|
||||
/// Control the screen sleep mode:
|
||||
pub fn sleep_mode(&mut self, mode: ModeState) -> Result {
|
||||
match mode {
|
||||
Orientation::Portrait => {
|
||||
self.width = WIDTH;
|
||||
self.height = HEIGHT;
|
||||
self.command(Command::MemoryAccessControl, &[0x40 | 0x08])
|
||||
}
|
||||
Orientation::Landscape => {
|
||||
self.width = HEIGHT;
|
||||
self.height = WIDTH;
|
||||
self.command(Command::MemoryAccessControl, &[0x20 | 0x08])
|
||||
}
|
||||
Orientation::PortraitFlipped => {
|
||||
self.width = WIDTH;
|
||||
self.height = HEIGHT;
|
||||
self.command(Command::MemoryAccessControl, &[0x80 | 0x08])
|
||||
}
|
||||
Orientation::LandscapeFlipped => {
|
||||
self.width = HEIGHT;
|
||||
self.height = WIDTH;
|
||||
self.command(Command::MemoryAccessControl, &[0x40 | 0x80 | 0x20 | 0x08])
|
||||
}
|
||||
ModeState::On => self.command(Command::SleepModeOn, &[]),
|
||||
ModeState::Off => self.command(Command::SleepModeOff, &[]),
|
||||
}
|
||||
}
|
||||
|
||||
/// Control the screen display mode
|
||||
pub fn display_mode(&mut self, mode: ModeState) -> Result {
|
||||
match mode {
|
||||
ModeState::On => self.command(Command::DisplayOn, &[]),
|
||||
ModeState::Off => self.command(Command::DisplayOff, &[]),
|
||||
}
|
||||
}
|
||||
|
||||
/// Invert the pixel color on screen
|
||||
pub fn invert_mode(&mut self, mode: ModeState) -> Result {
|
||||
match mode {
|
||||
ModeState::On => self.command(Command::InvertOn, &[]),
|
||||
ModeState::Off => self.command(Command::InvertOff, &[]),
|
||||
}
|
||||
}
|
||||
|
||||
/// Idle mode reduces the number of colors to 8
|
||||
pub fn idle_mode(&mut self, mode: ModeState) -> Result {
|
||||
match mode {
|
||||
ModeState::On => self.command(Command::IdleModeOn, &[]),
|
||||
ModeState::Off => self.command(Command::IdleModeOff, &[]),
|
||||
}
|
||||
}
|
||||
|
||||
/// Set display brightness to the value between 0 and 255
|
||||
pub fn brightness(&mut self, brightness: u8) -> Result {
|
||||
self.command(Command::SetBrightness, &[brightness])
|
||||
}
|
||||
|
||||
/// Set adaptive brightness value equal to [AdaptiveBrightness]
|
||||
pub fn content_adaptive_brightness(&mut self, value: AdaptiveBrightness) -> Result {
|
||||
self.command(Command::ContentAdaptiveBrightness, &[value as _])
|
||||
}
|
||||
|
||||
/// Configure [FrameRateClockDivision] and [FrameRate] in normal mode
|
||||
pub fn normal_mode_frame_rate(
|
||||
&mut self,
|
||||
clk_div: FrameRateClockDivision,
|
||||
frame_rate: FrameRate,
|
||||
) -> Result {
|
||||
self.command(
|
||||
Command::NormalModeFrameRate,
|
||||
&[clk_div as _, frame_rate as _],
|
||||
)
|
||||
}
|
||||
|
||||
/// Configure [FrameRateClockDivision] and [FrameRate] in idle mode
|
||||
pub fn idle_mode_frame_rate(
|
||||
&mut self,
|
||||
clk_div: FrameRateClockDivision,
|
||||
frame_rate: FrameRate,
|
||||
) -> Result {
|
||||
self.command(Command::IdleModeFrameRate, &[clk_div as _, frame_rate as _])
|
||||
}
|
||||
}
|
||||
|
||||
impl<IFACE, RESET> Ili9341<IFACE, RESET> {
|
||||
/// Get the current screen width. It can change based on the current orientation
|
||||
pub fn width(&self) -> usize {
|
||||
self.width
|
||||
|
@ -240,17 +408,82 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "graphics")]
|
||||
mod graphics;
|
||||
/// Scroller must be provided in order to scroll the screen. It can only be obtained
|
||||
/// by configuring the screen for scrolling.
|
||||
pub struct Scroller {
|
||||
top_offset: u16,
|
||||
fixed_bottom_lines: u16,
|
||||
fixed_top_lines: u16,
|
||||
height: u16,
|
||||
}
|
||||
|
||||
impl Scroller {
|
||||
fn new(fixed_top_lines: u16, fixed_bottom_lines: u16, height: u16) -> Scroller {
|
||||
Scroller {
|
||||
top_offset: fixed_top_lines,
|
||||
fixed_top_lines,
|
||||
fixed_bottom_lines,
|
||||
height,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Available Adaptive Brightness values
|
||||
pub enum AdaptiveBrightness {
|
||||
Off = 0x00,
|
||||
UserInterfaceImage = 0x01,
|
||||
StillPicture = 0x02,
|
||||
MovingImage = 0x03,
|
||||
}
|
||||
|
||||
/// Available frame rate in Hz
|
||||
pub enum FrameRate {
|
||||
FrameRate119 = 0x10,
|
||||
FrameRate112 = 0x11,
|
||||
FrameRate106 = 0x12,
|
||||
FrameRate100 = 0x13,
|
||||
FrameRate95 = 0x14,
|
||||
FrameRate90 = 0x15,
|
||||
FrameRate86 = 0x16,
|
||||
FrameRate83 = 0x17,
|
||||
FrameRate79 = 0x18,
|
||||
FrameRate76 = 0x19,
|
||||
FrameRate73 = 0x1a,
|
||||
FrameRate70 = 0x1b,
|
||||
FrameRate68 = 0x1c,
|
||||
FrameRate65 = 0x1d,
|
||||
FrameRate63 = 0x1e,
|
||||
FrameRate61 = 0x1f,
|
||||
}
|
||||
|
||||
/// Frame rate clock division
|
||||
pub enum FrameRateClockDivision {
|
||||
Fosc = 0x00,
|
||||
FoscDiv2 = 0x01,
|
||||
FoscDiv4 = 0x02,
|
||||
FoscDiv8 = 0x03,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
enum Command {
|
||||
SoftwareReset = 0x01,
|
||||
MemoryAccessControl = 0x36,
|
||||
PixelFormatSet = 0x3a,
|
||||
SleepOut = 0x11,
|
||||
SleepModeOn = 0x10,
|
||||
SleepModeOff = 0x11,
|
||||
InvertOff = 0x20,
|
||||
InvertOn = 0x21,
|
||||
DisplayOff = 0x28,
|
||||
DisplayOn = 0x29,
|
||||
ColumnAddressSet = 0x2a,
|
||||
PageAddressSet = 0x2b,
|
||||
MemoryWrite = 0x2c,
|
||||
VerticalScrollDefine = 0x33,
|
||||
VerticalScrollAddr = 0x37,
|
||||
IdleModeOff = 0x38,
|
||||
IdleModeOn = 0x39,
|
||||
SetBrightness = 0x51,
|
||||
ContentAdaptiveBrightness = 0x55,
|
||||
NormalModeFrameRate = 0xb1,
|
||||
IdleModeFrameRate = 0xb2,
|
||||
}
|
||||
|
|
|
@ -1,7 +0,0 @@
|
|||
use embedded_hal::spi::{Mode, Phase, Polarity};
|
||||
|
||||
/// SPI mode
|
||||
pub const MODE: Mode = Mode {
|
||||
polarity: Polarity::IdleLow,
|
||||
phase: Phase::CaptureOnFirstTransition,
|
||||
};
|
Loading…
Reference in a new issue