Anshorei
/
epd-waveshare
mirror of https://github.com/Anshorei/epd-waveshare
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

first steps to rustfmt althought it sometimes doesn#t exactly looks good

embedded-hal-1.0
Christoph Groß 2018-08-07 16:00:13 +02:00
parent e5a1e3bf25
commit cd98033204
12 changed files with 593 additions and 659 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/drawing/color.rs
View File

@ -1,7 +1,7 @@
/// Only for the B/W Displays atm
pub enum Color {
Black,
White
White,
}
impl Color {
@ -21,7 +21,6 @@ impl Color {
}
}
/// Get the color encoding of a specific bit in a byte
///
/// input is the byte where one bit is gonna be selected

35
src/drawing/font.rs
View File

@ -11,20 +11,33 @@ pub struct Font<'a> {
first_char: u8,
last_char: u8,
bitmap: &'a [u8],
widthmap: &'a [u8]
widthmap: &'a [u8],
}
impl<'a> Font<'a> {
/// Panics if either Bitmap or Widthmap of the Font are to small for the amount and size of chars
pub fn new(width: u8, height: u8, first_char: u8, last_char: u8, bitmap: &'a [u8], widthmap: &'a [u8]) -> Font<'a> {
pub fn new(
width: u8,
height: u8,
first_char: u8,
last_char: u8,
bitmap: &'a [u8],
widthmap: &'a [u8],
) -> Font<'a> {
//Assertion so it shouldn't be able to panic later
let length_of_char = width as usize / 8 * height as usize;
let amount_of_chars = last_char as usize - first_char as usize + 1;
assert!(bitmap.len() >= amount_of_chars * length_of_char);
assert!(widthmap.len() >= amount_of_chars);
Font {width, height, first_char, last_char, bitmap, widthmap }
Font {
width,
height,
first_char,
last_char,
bitmap,
widthmap,
}
}
fn get_length_of_char(&self) -> usize {
@ -40,7 +53,7 @@ impl<'a> Font<'a> {
let start_pos = self.get_char_pos(input) * self.get_length_of_char();
let end_pos = start_pos + self.get_length_of_char();
&self.bitmap[start_pos .. end_pos]
&self.bitmap[start_pos..end_pos]
}
/// Can panic, when get_char_pos > widthmap.len(), should be caught in Font::new already
@ -49,7 +62,6 @@ impl<'a> Font<'a> {
}
}
#[cfg(test)]
mod tests {
use super::*;
@ -64,9 +76,10 @@ mod tests {
0x00, 0x00, 0x5F, 0x00, 0x00, 0x00, 0x00, 0x00, // '!'
0x00, 0x07, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, // '"'
0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00, 0x00, 0x00, // '#'
0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00, 0x00, 0x00]; // '$'
0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00, 0x00, 0x00, // '$'
];
let widthmap = [8,8,8,8];
let widthmap = [8, 8, 8, 8];
let font = Font::new(8, 8, '!' as u8, '$' as u8, &bitmap, &widthmap);
@ -80,9 +93,6 @@ mod tests {
assert_eq!(font.get_char_width('$'), widthmap[3]);
}
#[test]
fn bitmap_8x8_test() {
let and = [0x36, 0x49, 0x55, 0x22, 0x50, 0x00, 0x00, 0x00];
@ -102,9 +112,6 @@ mod tests {
}
}
//bad font as the order is not the one we want to use
//goes from bottom left -> up -> right
pub(crate) fn bitmap_8x8(input: char) -> [u8; 8] {

163
src/drawing/mod.rs
View File

@ -1,11 +1,9 @@
pub mod font;
use self::font::Font;
pub mod color;
use self::color::Color;
#[derive(Clone, Copy)]
pub enum Displayorientation {
/// No rotation
@ -42,28 +40,30 @@ impl Display {
/// - Neccessary Buffersize
pub fn get_dimensions(&self) -> (u16, u16, u16) {
match self {
Display::Eink42BlackWhite => (400, 300, 15000)
Display::Eink42BlackWhite => (400, 300, 15000),
}
}
}
#[allow(dead_code)]
pub struct Graphics<'a> {
width: u16,
height: u16,
rotation: Displayorientation,
buffer: &'a mut [u8]
//buffer: Box<u8>//[u8; 15000],
buffer: &'a mut [u8], //buffer: Box<u8>//[u8; 15000]
}
impl<'a> Graphics<'a> {
/// width needs to be a multiple of 8!
pub fn new(width: u16, height: u16, buffer: &'a mut [u8]) -> Graphics<'a>{
pub fn new(width: u16, height: u16, buffer: &'a mut [u8]) -> Graphics<'a> {
let len = buffer.len();
assert!(width / 8 * height >= len as u16);
Graphics {width, height, rotation: Displayorientation::Rotate0, buffer}
Graphics {
width,
height,
rotation: Displayorientation::Rotate0,
buffer,
}
}
/// Clears/Fills the full buffer with `color`
@ -82,12 +82,14 @@ impl<'a> Graphics<'a> {
/// limited to i16::max images (buffer_size) at the moment
pub fn draw_pixel(&mut self, x: u16, y: u16, color: &Color) {
let (idx, bit) = match self.rotation {
Displayorientation::Rotate0 | Displayorientation::Rotate180
=> ((x as usize / 8 + (self.width as usize / 8) * y as usize) ,
0x80 >> (x % 8)),
Displayorientation::Rotate90 | Displayorientation::Rotate270
=> (y as usize / 8 * self.width as usize + x as usize,
0x80 >> (y % 8)),
Displayorientation::Rotate0 | Displayorientation::Rotate180 => (
(x as usize / 8 + (self.width as usize / 8) * y as usize),
0x80 >> (x % 8),
),
Displayorientation::Rotate90 | Displayorientation::Rotate270 => (
y as usize / 8 * self.width as usize + x as usize,
0x80 >> (y % 8),
),
};
if idx >= self.buffer.len() {
@ -97,7 +99,7 @@ impl<'a> Graphics<'a> {
match color {
Color::Black => {
self.buffer[idx] &= !bit;
},
}
Color::White => {
self.buffer[idx] |= bit;
}
@ -110,10 +112,12 @@ impl<'a> Graphics<'a> {
#[allow(dead_code)]
fn draw_byte(&mut self, x: u16, y: u16, filling: u8, color: &Color) {
let idx = match self.rotation {
Displayorientation::Rotate0 | Displayorientation::Rotate180
=> x as usize / 8 + (self.width as usize / 8) * y as usize,
Displayorientation::Rotate90 | Displayorientation::Rotate270
=> y as usize / 8 + (self.width as usize / 8) * x as usize,
Displayorientation::Rotate0 | Displayorientation::Rotate180 => {
x as usize / 8 + (self.width as usize / 8) * y as usize
},
Displayorientation::Rotate90 | Displayorientation::Rotate270 => {
y as usize / 8 + (self.width as usize / 8) * x as usize
},
};
if idx >= self.buffer.len() {
@ -145,7 +149,6 @@ impl<'a> Graphics<'a> {
}
}
//TODO: add support for font_height = 0
//TODO: add support for char offset in y direction to reduce font file size
fn draw_char_helper(&mut self, x0: u16, y0: u16, input: char, font: &Font, color: &Color) {
@ -156,16 +159,15 @@ impl<'a> Graphics<'a> {
let buff = font.get_char(input);
let char_width = font.get_char_width(input);
let mut row_counter = 0;
let mut width_counter = 0u8;
for &elem in buff.iter() {
for _ in 0..8 {
self.draw_pixel(
x0 + u16::from(width_counter),
y0 + row_counter,
&Color::get_color(elem, width_counter % 8, color));
&Color::get_color(elem, width_counter % 8, color),
);
//Widthcounter shows how far we are in x direction
width_counter += 1;
@ -185,7 +187,11 @@ impl<'a> Graphics<'a> {
// includes special draw_char instructions as this one is ordered columnwise and not rowwise (first byte == first 8 pixel columnwise)
for &elem in (&font::bitmap_8x8(input)).iter() {
for i in 0..8u8 {
self.draw_pixel(x0 + counter, y0 + 7 - u16::from(i), &Color::convert_color(elem, i, color))
self.draw_pixel(
x0 + counter,
y0 + 7 - u16::from(i),
&Color::convert_color(elem, i, color),
)
}
counter += 1;
}
@ -198,24 +204,29 @@ impl<'a> Graphics<'a> {
/// no autobreak line yet
pub fn draw_string_8x8(&mut self, x0: u16, y0: u16, input: &str, color: &Color) {
for (counter, input_char) in input.chars().enumerate() {
self.draw_char_8x8(x0 + counter as u16*8, y0, input_char, color);
self.draw_char_8x8(
x0 + counter as u16 * 8,
y0,
input_char,
color,
);
}
}
// void plotLine(int x0, int y0, int x1, int y1)
// {
// int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
// int dy = -abs(y1-y0), sy = y0<y1 ? 1 : -1;
// int err = dx+dy, e2; /* error value e_xy */
// void plotLine(int x0, int y0, int x1, int y1)
// {
// int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
// int dy = -abs(y1-y0), sy = y0<y1 ? 1 : -1;
// int err = dx+dy, e2; /* error value e_xy */
// for(;;){ /* loop */
// setPixel(x0,y0);
// if (x0==x1 && y0==y1) break;
// e2 = 2*err;
// if (e2 >= dy) { err += dy; x0 += sx; } /* e_xy+e_x > 0 */
// if (e2 <= dx) { err += dx; y0 += sy; } /* e_xy+e_y < 0 */
// }
// }
// for(;;){ /* loop */
// setPixel(x0,y0);
// if (x0==x1 && y0==y1) break;
// e2 = 2*err;
// if (e2 >= dy) { err += dy; x0 += sx; } /* e_xy+e_x > 0 */
// if (e2 <= dx) { err += dx; y0 += sy; } /* e_xy+e_y < 0 */
// }
// }
//bresenham algorithm for lines
/// draw line
pub fn draw_line(&mut self, x0: u16, y0: u16, x1: u16, y1: u16, color: &Color) {
@ -227,7 +238,7 @@ impl<'a> Graphics<'a> {
let dx = i16::abs(x1 - x0);
let sx = if x0 < x1 { 1 } else { -1 };
let dy = - i16::abs(y1 - y0);
let dy = -i16::abs(y1 - y0);
let sy = if y0 < y1 { 1 } else { -1 };
let mut err = dx + dy;
@ -239,7 +250,7 @@ impl<'a> Graphics<'a> {
break;
}
let e2 = 2*err;
let e2 = 2 * err;
if e2 >= dy {
err += dy;
@ -297,8 +308,7 @@ impl<'a> Graphics<'a> {
}
}
fn draw_circle_helper(&mut self, x0: u16, y0: u16, radius: u16, filled: bool, color: &Color) {
fn draw_circle_helper(&mut self, x0: u16, y0: u16, radius: u16, filled: bool, color: &Color) {
let mut x = radius - 1;
let mut y = 0;
let mut dx = 1;
@ -324,30 +334,28 @@ fn draw_circle_helper(&mut self, x0: u16, y0: u16, radius: u16, filled: bool, co
err += dx - 2 * radius as i16;
}
}
}
}
fn circle_helper_putpixel(&mut self, x0: u16, y0: u16, x: u16, y: u16, color: &Color) {
self.draw_horizontal_line(x0 - x, y0 + y, 2*x, color);
fn circle_helper_putpixel(&mut self, x0: u16, y0: u16, x: u16, y: u16, color: &Color) {
self.draw_horizontal_line(x0 - x, y0 + y, 2 * x, color);
// self.draw_pixel(buffer, x0 + x, y0 + y, color);
// self.draw_pixel(buffer, x0 - x, y0 + y, color);
self.draw_horizontal_line(x0 - y, y0 + x, 2*y, color);
self.draw_horizontal_line(x0 - y, y0 + x, 2 * y, color);
// self.draw_pixel(buffer, x0 + y, y0 + x, color);
// self.draw_pixel(buffer, x0 - y, y0 + x, color);
self.draw_horizontal_line(x0 - x, y0 - y, 2*x, color);
self.draw_horizontal_line(x0 - x, y0 - y, 2 * x, color);
// self.draw_pixel(buffer, x0 - x, y0 - y, color);
// self.draw_pixel(buffer, x0 + x, y0 - y, color);
self.draw_horizontal_line(x0 - y, y0 - y, 2*y, color);
self.draw_horizontal_line(x0 - y, y0 - y, 2 * y, color);
// self.draw_pixel(buffer, x0 - y, y0 - x, color);
// self.draw_pixel(buffer, x0 + y, y0 - x, color);
}
}
//TODO: Test
fn circle_helper_filled_putpixel(&mut self, x0: u16, y0: u16, x: u16, y: u16, color: &Color) {
//TODO: Test
fn circle_helper_filled_putpixel(&mut self, x0: u16, y0: u16, x: u16, y: u16, color: &Color) {
self.draw_pixel(x0 + x, y0 + y, color);
self.draw_pixel(x0 + y, y0 + x, color);
self.draw_pixel(x0 - y, y0 + x, color);
@ -356,10 +364,7 @@ fn circle_helper_filled_putpixel(&mut self, x0: u16, y0: u16, x: u16, y: u16, c
self.draw_pixel(x0 - y, y0 - x, color);
self.draw_pixel(x0 + y, y0 - x, color);
self.draw_pixel(x0 + x, y0 - y, color);
}
}
///TODO: test if circle looks good
/// Draws a circle
@ -387,12 +392,12 @@ fn circle_helper_filled_putpixel(&mut self, x0: u16, y0: u16, x: u16, y: u16, c
if radius <= y_pos {
y_pos += 1;
err += y_pos*2 + 1;
err += y_pos * 2 + 1;
}
if radius > x_pos || err > y_pos {
x_pos += 1;
err += x_pos*2 + 1;
err += x_pos * 2 + 1;
}
if x_pos >= 0 {
@ -401,16 +406,12 @@ fn circle_helper_filled_putpixel(&mut self, x0: u16, y0: u16, x: u16, y: u16, c
}
}
///TODO: test!
pub fn draw_filled_circle(&mut self, x0: u16, y0: u16, radius: u16, color: &Color) {
self.draw_circle_helper(x0, y0, radius, true, color);
}
}
/*
############ ############ ############ ############
@ -424,8 +425,6 @@ fn circle_helper_filled_putpixel(&mut self, x0: u16, y0: u16, x: u16, y: u16, c
*/
#[cfg(test)]
mod graphics {
use super::*;
@ -439,11 +438,8 @@ mod graphics {
assert_eq!(graphics.buffer[0], Color::Black.get_byte_value());
for &elem in graphics.buffer.iter() {
assert_eq!(elem, Color::Black.get_byte_value());
}
}
/// draw a 4x4 in the top left corner
@ -465,8 +461,6 @@ mod graphics {
assert_eq!(elem, Color::White.get_byte_value());
}
}
}
#[test]
@ -489,11 +483,9 @@ mod graphics {
graphics.draw_vertical_line(5, 0, 8, &Color::Black);
assert_eq!(graphics.buffer[0], 0x7b);
for &elem in graphics.buffer.iter() {
assert_eq!(elem, 0x7bu8);
}
}
@ -545,8 +537,6 @@ mod graphics {
}
}
#[test]
fn test_pixel() {
let mut buffer = [Color::White.get_byte_value(); 8];
@ -555,7 +545,6 @@ mod graphics {
assert_eq!(graphics.buffer[0], !0x40);
let mut buffer = [Color::White.get_byte_value(); 16];
let mut graphics = Graphics::new(16, 8, &mut buffer);
graphics.draw_pixel(9, 0, &Color::Black);
@ -575,13 +564,12 @@ mod graphics {
assert_eq!(graphics.buffer[i], Color::White.get_byte_value());
}
graphics.draw_byte(0, 0, 0x5A, &Color::Black) ;
graphics.draw_byte(0, 0, 0x5A, &Color::Black);
assert_eq!(graphics.buffer[0], !0x5A);
}
#[test]
fn test_char_with_8x8_font() {
// Test !
let mut buffer = [Color::White.get_byte_value(); 8];
let mut graphics = Graphics::new(8, 8, &mut buffer);
@ -594,7 +582,6 @@ mod graphics {
assert_eq!(graphics.buffer[6], !0x20);
assert_eq!(graphics.buffer[7], Color::White.get_byte_value());
// Test H
let mut buffer = [Color::White.get_byte_value(); 8];
let mut graphics = Graphics::new(8, 8, &mut buffer);
@ -612,27 +599,25 @@ mod graphics {
#[test]
fn test_string_with_8x8_font() {
// Test !H
let mut buffer = [Color::White.get_byte_value(); 16];
let mut graphics = Graphics::new(16, 8, &mut buffer);
graphics.draw_string_8x8(0, 0, "!H", &Color::Black);
for i in 0..5 {
assert_eq!(graphics.buffer[i*2], !0x20);
assert_eq!(graphics.buffer[i * 2], !0x20);
}
assert_eq!(graphics.buffer[5*2], Color::White.get_byte_value());
assert_eq!(graphics.buffer[6*2], !0x20);
assert_eq!(graphics.buffer[7*2], Color::White.get_byte_value());
assert_eq!(graphics.buffer[5 * 2], Color::White.get_byte_value());
assert_eq!(graphics.buffer[6 * 2], !0x20);
assert_eq!(graphics.buffer[7 * 2], Color::White.get_byte_value());
for i in 0..3 {
assert_eq!(graphics.buffer[i*2 + 1], !0x88);
assert_eq!(graphics.buffer[i * 2 + 1], !0x88);
}
assert_eq!(graphics.buffer[3*2 + 1], !0xF8);
assert_eq!(graphics.buffer[3 * 2 + 1], !0xF8);
for i in 4..7 {
assert_eq!(graphics.buffer[i*2 + 1], !0x88);
assert_eq!(graphics.buffer[i * 2 + 1], !0x88);
}
assert_eq!(graphics.buffer[7*2 + 1], Color::White.get_byte_value());
assert_eq!(graphics.buffer[7 * 2 + 1], Color::White.get_byte_value());
}
}

79
src/epd1in54/mod.rs
View File

@ -25,31 +25,18 @@ const HEIGHT: u16 = 200;
const DEFAULT_BACKGROUND_COLOR: Color = Color::White;
use hal::{
blocking::{
spi::Write,
delay::*
},
digital::*
blocking::{delay::*, spi::Write},
digital::*,
};
use type_a::{
LUT_FULL_UPDATE,
LUT_PARTIAL_UPDATE,
command::Command
};
use type_a::{command::Command, LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE};
use drawing::color::Color;
use interface::*;
use interface::connection_interface::ConnectionInterface;
/// EPD1in54 driver
///
pub struct EPD1in54<SPI, CS, BUSY, DataCommand, RST, Delay> {
@ -68,11 +55,8 @@ where
BUSY: InputPin,
DataCommand: OutputPin,
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>
{
}
Delay: DelayUs<u16> + DelayMs<u16>,
{}
impl<SPI, CS, BUSY, DataCommand, RST, Delay, E> WaveshareInterface<SPI, CS, BUSY, DataCommand, RST, Delay, E>
for EPD1in54<SPI, CS, BUSY, DataCommand, RST, Delay>
@ -84,7 +68,6 @@ where
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>,
{
fn get_width(&self) -> u16 {
WIDTH
}
@ -93,23 +76,20 @@ where
HEIGHT
}
fn new(
interface: ConnectionInterface<SPI, CS, BUSY, DataCommand, RST, Delay>
interface: ConnectionInterface<SPI, CS, BUSY, DataCommand, RST, Delay>,
) -> Result<Self, E> {
let mut epd = EPD1in54 {interface, background_color: DEFAULT_BACKGROUND_COLOR};
let mut epd = EPD1in54 {
interface,
background_color: DEFAULT_BACKGROUND_COLOR,
};
epd.init()?;
Ok(epd)
}
fn init(&mut self) -> Result<(), E> {
self.reset();
// 3 Databytes:
@ -153,7 +133,6 @@ where
}
fn sleep(&mut self) -> Result<(), E> {
self.interface.send_command(Command::DEEP_SLEEP_MODE)?;
// 0x00 for Normal mode (Power on Reset), 0x01 for Deep Sleep Mode
//TODO: is 0x00 needed here?
@ -163,7 +142,6 @@ where
Ok(())
}
fn reset(&mut self) {
self.interface.reset()
}
@ -172,9 +150,7 @@ where
self.interface.delay_ms(delay)
}
fn update_frame(&mut self, buffer: &[u8]) -> Result<(), E>{
fn update_frame(&mut self, buffer: &[u8]) -> Result<(), E> {
self.use_full_frame()?;
self.interface.send_command(Command::WRITE_RAM)?;
@ -182,7 +158,14 @@ where
}
//TODO: update description: last 3 bits will be ignored for width and x_pos
fn update_partial_frame(&mut self, buffer: &[u8], x: u16, y: u16, width: u16, height: u16) -> Result<(), E>{
fn update_partial_frame(
&mut self,
buffer: &[u8],
x: u16,
y: u16,
width: u16,
height: u16,
) -> Result<(), E> {
self.set_ram_area(x, y, x + width, y + height)?;
self.set_ram_counter(x, y)?;
@ -190,8 +173,7 @@ where
self.interface.send_multiple_data(buffer)
}
fn display_frame(&mut self) -> Result<(), E>{
fn display_frame(&mut self) -> Result<(), E> {
// enable clock signal, enable cp, display pattern -> 0xC4 (tested with the arduino version)
//TODO: test control_1 or control_2 with default value 0xFF (from the datasheet)
self.interface.send_command(Command::DISPLAY_UPDATE_CONTROL_2)?;
@ -203,14 +185,12 @@ where
self.interface.send_command(Command::TERMINATE_COMMANDS_AND_FRAME_WRITE)
}
fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), E>{
fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), E> {
self.update_frame(buffer)?;
self.display_frame()
}
fn clear_frame(&mut self) -> Result<(), E>{
fn clear_frame(&mut self) -> Result<(), E> {
self.use_full_frame()?;
// clear the ram with the background color
@ -221,10 +201,9 @@ where
}
/// Sets the backgroundcolor for various commands like [WaveshareInterface::clear_frame()](clear_frame())
fn set_background_color(&mut self, background_color: Color){
fn set_background_color(&mut self, background_color: Color) {
self.background_color = background_color;
}
}
impl<SPI, CS, BUSY, DC, RST, D, E> EPD1in54<SPI, CS, BUSY, DC, RST, D>
@ -245,10 +224,16 @@ where
self.set_ram_area(0, 0, WIDTH - 1, HEIGHT - 1)?;
// start from the beginning
self.set_ram_counter(0,0)
self.set_ram_counter(0, 0)
}
pub(crate) fn set_ram_area(&mut self, start_x: u16, start_y: u16, end_x: u16, end_y: u16) -> Result<(), E> {
pub(crate) fn set_ram_area(
&mut self,
start_x: u16,
start_y: u16,
end_x: u16,
end_y: u16,
) -> Result<(), E> {
assert!(start_x < end_x);
assert!(start_y < end_y);
@ -296,11 +281,9 @@ where
// self.set_lut_helper(buffer)
//}
fn set_lut_helper(&mut self, buffer: &[u8]) -> Result<(), E> {
assert!(buffer.len() == 30);
self.interface.send_command(Command::WRITE_LUT_REGISTER)?;
self.interface.send_multiple_data(buffer)
}
}

83
src/epd2in9/mod.rs
View File

@ -24,32 +24,18 @@ const HEIGHT: u16 = 296;
const DEFAULT_BACKGROUND_COLOR: Color = Color::White;
use hal::{
blocking::{
spi::Write,
delay::*
},
digital::*
blocking::{delay::*, spi::Write},
digital::*,
};
use type_a::{
LUT_FULL_UPDATE,
LUT_PARTIAL_UPDATE,
command::Command
};
use type_a::{command::Command, LUT_FULL_UPDATE, LUT_PARTIAL_UPDATE};
use drawing::color::Color;
use interface::*;
use interface::connection_interface::ConnectionInterface;
/// EPD2in9 driver
///
pub struct EPD2in9<SPI, CS, BUSY, DataCommand, RST, Delay> {
@ -68,13 +54,11 @@ where
BUSY: InputPin,
DataCommand: OutputPin,
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>
{
Delay: DelayUs<u16> + DelayMs<u16>,
{}
}
impl<SPI, CS, BUSY, DataCommand, RST, Delay, E> WaveshareInterface<SPI, CS, BUSY, DataCommand, RST, Delay, E>
impl<SPI, CS, BUSY, DataCommand, RST, Delay, E>
WaveshareInterface<SPI, CS, BUSY, DataCommand, RST, Delay, E>
for EPD2in9<SPI, CS, BUSY, DataCommand, RST, Delay>
where
SPI: Write<u8, Error = E>,
@ -84,7 +68,6 @@ where
RST: OutputPin,
Delay: DelayUs<u16> + DelayMs<u16>,
{
fn get_width(&self) -> u16 {
WIDTH
}
@ -93,26 +76,23 @@ where
HEIGHT
}
fn new(
interface: ConnectionInterface<SPI, CS, BUSY, DataCommand, RST, Delay>
interface: ConnectionInterface<SPI, CS, BUSY, DataCommand, RST, Delay>,
) -> Result<Self, E> {
//let epd = EPD::new(WIDTH, HEIGHT);
//let background_color = Color::White;
let mut epd = EPD2in9 {interface, background_color: DEFAULT_BACKGROUND_COLOR};
let mut epd = EPD2in9 {
interface,
background_color: DEFAULT_BACKGROUND_COLOR,
};
epd.init()?;
Ok(epd)
}
fn init(&mut self) -> Result<(), E> {
self.reset();
// 3 Databytes:
@ -156,7 +136,6 @@ where
}
fn sleep(&mut self) -> Result<(), E> {
self.interface.send_command(Command::DEEP_SLEEP_MODE)?;
// 0x00 for Normal mode (Power on Reset), 0x01 for Deep Sleep Mode
//TODO: is 0x00 needed here?
@ -166,7 +145,6 @@ where
Ok(())
}
fn reset(&mut self) {
self.interface.reset()
}
@ -175,9 +153,7 @@ where
self.interface.delay_ms(delay)
}
fn update_frame(&mut self, buffer: &[u8]) -> Result<(), E>{
fn update_frame(&mut self, buffer: &[u8]) -> Result<(), E> {
self.use_full_frame()?;
self.interface.send_command(Command::WRITE_RAM)?;
@ -185,7 +161,14 @@ where
}
//TODO: update description: last 3 bits will be ignored for width and x_pos
fn update_partial_frame(&mut self, buffer: &[u8], x: u16, y: u16, width: u16, height: u16) -> Result<(), E>{
fn update_partial_frame(
&mut self,
buffer: &[u8],
x: u16,
y: u16,
width: u16,
height: u16,
) -> Result<(), E> {
self.set_ram_area(x, y, x + width, y + height)?;
self.set_ram_counter(x, y)?;
@ -193,8 +176,7 @@ where
self.interface.send_multiple_data(buffer)
}
fn display_frame(&mut self) -> Result<(), E>{
fn display_frame(&mut self) -> Result<(), E> {
// enable clock signal, enable cp, display pattern -> 0xC4 (tested with the arduino version)
//TODO: test control_1 or control_2 with default value 0xFF (from the datasheet)
self.interface.send_command(Command::DISPLAY_UPDATE_CONTROL_2)?;
@ -206,14 +188,12 @@ where
self.interface.send_command(Command::TERMINATE_COMMANDS_AND_FRAME_WRITE)
}
fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), E>{
fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), E> {
self.update_frame(buffer)?;
self.display_frame()
}
fn clear_frame(&mut self) -> Result<(), E>{
fn clear_frame(&mut self) -> Result<(), E> {
self.use_full_frame()?;
// clear the ram with the background color
@ -224,10 +204,9 @@ where
}
/// Sets the backgroundcolor for various commands like [WaveshareInterface::clear_frame()](clear_frame())
fn set_background_color(&mut self, background_color: Color){
fn set_background_color(&mut self, background_color: Color) {
self.background_color = background_color;
}
}
impl<SPI, CS, BUSY, DC, RST, D, E> EPD2in9<SPI, CS, BUSY, DC, RST, D>
@ -248,10 +227,16 @@ where
self.set_ram_area(0, 0, WIDTH - 1, HEIGHT - 1)?;
// start from the beginning
self.set_ram_counter(0,0)
self.set_ram_counter(0, 0)
}
pub(crate) fn set_ram_area(&mut self, start_x: u16, start_y: u16, end_x: u16, end_y: u16) -> Result<(), E> {
pub(crate) fn set_ram_area(
&mut self,
start_x: u16,
start_y: u16,
end_x: u16,
end_y: u16,
) -> Result<(), E> {
assert!(start_x < end_x);
assert!(start_y < end_y);
@ -299,11 +284,9 @@ where
// self.set_lut_helper(buffer)
//}
fn set_lut_helper(&mut self, buffer: &[u8]) -> Result<(), E> {
assert!(buffer.len() == 30);
self.interface.send_command(Command::WRITE_LUT_REGISTER)?;
self.interface.send_multiple_data(buffer)
}
}

3
src/epd4in2/command.rs
View File

@ -144,8 +144,6 @@ pub(crate) enum Command {
POWER_SAVING = 0xE3,
}
impl interface::Command for Command {
/// Returns the address of the command
fn address(self) -> u8 {
@ -153,7 +151,6 @@ impl interface::Command for Command {
}
}
#[cfg(test)]
mod tests {
use super::*;

14
src/epd4in2/mod.rs
View File

@ -62,11 +62,9 @@ use drawing::color::Color;
pub mod command;
use self::command::Command;
/// EPD4in2 driver
///
pub struct EPD4in2<SPI, CS, BUSY, DC, RST, D>
{
pub struct EPD4in2<SPI, CS, BUSY, DC, RST, D> {
/// Connection Interface
interface: ConnectionInterface<SPI, CS, BUSY, DC, RST, D>,
/// Width
@ -77,9 +75,8 @@ pub struct EPD4in2<SPI, CS, BUSY, DC, RST, D>
color: Color,
}
impl<SPI, CS, BUSY, DataCommand, RST, Delay, SpiError> WaveshareInterface<SPI, CS, BUSY, DataCommand, RST, Delay, SpiError>
impl<SPI, CS, BUSY, DataCommand, RST, Delay, SpiError>
WaveshareInterface<SPI, CS, BUSY, DataCommand, RST, Delay, SpiError>
for EPD4in2<SPI, CS, BUSY, DataCommand, RST, Delay>
where
SPI: Write<u8, Error = SpiError>,
@ -116,7 +113,6 @@ where
let width = WIDTH as u16;
let height = HEIGHT as u16;
let color = Color::White;
let mut epd = EPD4in2 {
interface,
@ -243,7 +239,6 @@ where
width: u16,
height: u16,
) -> Result<(), SpiError> {
if buffer.len() as u16 != width / 8 * height {
//TODO: panic!! or sth like that
//return Err("Wrong buffersize");
@ -279,12 +274,11 @@ where
self.send_command(Command::PARTIAL_OUT)
}
fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), SpiError>{
fn update_and_display_frame(&mut self, buffer: &[u8]) -> Result<(), SpiError> {
self.update_frame(buffer)?;
self.display_frame()
}
fn display_frame(&mut self) -> Result<(), SpiError> {
self.send_command(Command::DISPLAY_REFRESH)?;

41
src/interface/connection_interface.rs
View File

@ -1,9 +1,6 @@
use hal::{
blocking::{
spi::Write,
delay::*
},
digital::*
blocking::{delay::*, spi::Write},
digital::*,
};
use interface::Command;
@ -25,8 +22,8 @@ pub struct ConnectionInterface<SPI, CS, BUSY, DC, RST, D> {
delay: D,
}
impl<SPI, CS, BUSY, DataCommand, RST, Delay, ErrorSpeziale> ConnectionInterface<SPI, CS, BUSY, DataCommand, RST, Delay>
impl<SPI, CS, BUSY, DataCommand, RST, Delay, ErrorSpeziale>
ConnectionInterface<SPI, CS, BUSY, DataCommand, RST, Delay>
where
SPI: Write<u8, Error = ErrorSpeziale>,
CS: OutputPin,
@ -36,7 +33,14 @@ where
Delay: DelayUs<u16> + DelayMs<u16>,
{
pub fn new(spi: SPI, cs: CS, busy: BUSY, dc: DataCommand, rst: RST, delay: Delay) -> Self {
ConnectionInterface {spi, cs, busy, dc, rst, delay }
ConnectionInterface {
spi,
cs,
busy,
dc,
rst,
delay,
}
}
/// Basic function for sending [Commands](Command).
@ -49,9 +53,7 @@ where
self.dc.set_low();
// Transfer the command over spi
self.with_cs(|epd| {
epd.spi.write(&[command.address()])
})
self.with_cs(|epd| epd.spi.write(&[command.address()]))
}
/// Basic function for sending a single u8 of data over spi
@ -65,9 +67,7 @@ where
self.dc.set_high();
// Transfer data (u8) over spi
self.with_cs(|epd| {
epd.spi.write(&[val])
})
self.with_cs(|epd| epd.spi.write(&[val]))
}
/// Basic function for sending a single u8 of data over spi
@ -76,7 +76,11 @@ where
///
/// Should rarely be needed!
/// //TODO: make public?
pub(crate) fn send_data_x_times(&mut self, val: u8, repetitions: u16) -> Result<(), ErrorSpeziale> {
pub(crate) fn send_data_x_times(
&mut self,
val: u8,
repetitions: u16,
) -> Result<(), ErrorSpeziale> {
// high for data
self.dc.set_high();
@ -100,9 +104,7 @@ where
self.dc.set_high();
// Transfer data (u8-array) over spi
self.with_cs(|epd| {
epd.spi.write(data)
})
self.with_cs(|epd| epd.spi.write(data))
}
// spi write helper/abstraction function
@ -120,7 +122,6 @@ where
result
}
/// Waits until device isn't busy anymore (busy == HIGH)
///
/// This is normally handled by the more complicated commands themselves,
@ -142,7 +143,6 @@ where
}
}
/// Abstraction of setting the delay for simpler calls
///
/// maximum delay ~65 seconds (u16:max in ms)
@ -166,5 +166,4 @@ where
//TODO: same as 3 lines above
self.delay_ms(200);
}
}

34
src/interface/mod.rs
View File

@ -1,11 +1,8 @@
use hal::{
blocking::{
spi::Write,
delay::*
},
digital::*
};
use core::marker::Sized;
use hal::{
blocking::{delay::*, spi::Write},
digital::*,
};
use drawing::color::Color;
@ -13,16 +10,12 @@ use drawing::color::Color;
pub mod connection_interface;
use self::connection_interface::ConnectionInterface;
/// All commands need to have this trait which gives the address of the command
/// which needs to be send via SPI with activated CommandsPin (Data/Command Pin in CommandMode)
pub(crate) trait Command {
fn address(self) -> u8;
}
//TODO: add LUT trait with set_fast_lut and set_manual_lut and set_normal_lut or sth like that?
// for partial updates
trait LUTSupport<Error> {
@ -31,9 +24,8 @@ trait LUTSupport<Error> {
fn set_lut_manual(&mut self, data: &[u8]) -> Result<(), Error>;
}
pub trait WaveshareInterface<SPI, CS, BUSY, DataCommand, RST, Delay, Error>
where
where
SPI: Write<u8>,
CS: OutputPin,
BUSY: InputPin,
@ -51,9 +43,10 @@ pub trait WaveshareInterface<SPI, CS, BUSY, DataCommand, RST, Delay, Error>
///
/// This already initialises the device. That means [init()](WaveshareInterface::init()) isn't needed directly afterwards
fn new(
interface: ConnectionInterface<SPI, CS, BUSY, DataCommand, RST, Delay>
interface: ConnectionInterface<SPI, CS, BUSY, DataCommand, RST, Delay>,
) -> Result<Self, Error>
where Self: Sized;
where
Self: Sized;
/// This initialises the EPD and powers it up
///
@ -64,7 +57,6 @@ pub trait WaveshareInterface<SPI, CS, BUSY, DataCommand, RST, Delay, Error>
/// after setting it to sleep.
fn init(&mut self) -> Result<(), Error>;
// void DisplayFrame(const unsigned char* frame_buffer);
/// Transmit a full frame to the SRAM of the DPD
///
@ -78,7 +70,14 @@ pub trait WaveshareInterface<SPI, CS, BUSY, DataCommand, RST, Delay, Error>
/// Normally it should be dtm2, so use false
///
/// BUFFER needs to be of size: w / 8 * l !
fn update_partial_frame(&mut self, buffer: &[u8], x: u16, y: u16, width: u16, height: u16) -> Result<(), Error>;
fn update_partial_frame(
&mut self,
buffer: &[u8],
x: u16,
y: u16,
width: u16,
height: u16,
) -> Result<(), Error>;
/// Displays the frame data from SRAM
fn display_frame(&mut self) -> Result<(), Error>;
@ -94,7 +93,6 @@ pub trait WaveshareInterface<SPI, CS, BUSY, DataCommand, RST, Delay, Error>
/// Sets the backgroundcolor for various commands like [clear_frame()](WaveshareInterface::clear_frame())
fn set_background_color(&mut self, color: Color);
/// Let the device enter deep-sleep mode to save power.
///
/// The deep sleep mode returns to standby with a hardware reset.

25
src/lib.rs
View File

@ -43,42 +43,35 @@
//TODO: Make more assertions about buffersizes?
extern crate embedded_hal as hal;
use hal::{
spi::{Mode, Phase, Polarity},
};
use hal::spi::{Mode, Phase, Polarity};
pub mod drawing;
mod interface;
pub use interface::{
WaveshareInterface,
connection_interface::ConnectionInterface};
pub use interface::{connection_interface::ConnectionInterface, WaveshareInterface};
#[cfg(feature="epd4in2")]
#[cfg(feature = "epd4in2")]
mod epd4in2;
#[cfg(feature="epd4in2")]
#[cfg(feature = "epd4in2")]
pub use epd4in2::EPD4in2;
#[cfg(feature="epd1in54")]
#[cfg(feature = "epd1in54")]
mod epd1in54;
#[cfg(feature="epd1in54")]
#[cfg(feature = "epd1in54")]
pub use epd1in54::EPD1in54;
#[cfg(feature="epd2in9")]
#[cfg(feature = "epd2in9")]
mod epd2in9;
///2in9 eink
#[cfg(feature="epd2in9")]
#[cfg(feature = "epd2in9")]
///2in9 eink
pub use epd2in9::EPD2in9;
#[cfg(any(feature="epd1in54", feature="epd2in9"))]
#[cfg(any(feature = "epd1in54", feature = "epd2in9"))]
pub mod type_a;
//TODO: test spi mode
/// SPI mode -
/// For more infos see [Requirements: SPI](index.html#spi)

6
src/type_a/command.rs
View File

@ -2,7 +2,6 @@
use interface;
/// EPD1in54 and EPD2IN9 commands
///
/// Should rarely (never?) be needed directly.
@ -69,11 +68,9 @@ pub(crate) enum Command {
SET_RAM_Y_ADDRESS_COUNTER = 0x4F,
TERMINATE_COMMANDS_AND_FRAME_WRITE = 0xFF
TERMINATE_COMMANDS_AND_FRAME_WRITE = 0xFF,
}
impl interface::Command for Command {
/// Returns the address of the command
fn address(self) -> u8 {
@ -81,7 +78,6 @@ impl interface::Command for Command {
}
}
#[cfg(test)]
mod tests {
use super::Command;