marc
/
epd-waveshare
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

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

digi-v2-tests
Christoph Groß 5 years ago
parent
e5a1e3bf25
commit
cd98033204
12 changed files with 578 additions and 644 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 11
      src/drawing/color.rs
  2. 39
      src/drawing/font.rs
  3. 297
      src/drawing/mod.rs
  4. 117
      src/epd1in54/mod.rs
  5. 119
      src/epd2in9/mod.rs
  6. 287
      src/epd4in2/command.rs
  7. 2
      src/epd4in2/constants.rs
  8. 22
      src/epd4in2/mod.rs
  9. 91
      src/interface/connection_interface.rs
  10. 72
      src/interface/mod.rs
  11. 55
      src/lib.rs
  12. 110
      src/type_a/command.rs

11
src/drawing/color.rs
Unescape View File

@ -1,7 +1,7 @@
/// Only for the B/W Displays atm
pub enum Color {
Black,
White
White,
}
impl Color {
@ -9,7 +9,7 @@ impl Color {
pub fn get_bit_value(&self) -> u8 {
match self {
Color::White => 1u8,
Color::Black => 0u8,
Color::Black => 0u8,
}
}
@ -21,9 +21,8 @@ impl Color {
}
}
/// Get the color encoding of a specific bit in a byte
///
///
/// input is the byte where one bit is gonna be selected
/// pos is counted from the left (highest value) from 0 to 7
/// remember: 1 is white, 0 is black
@ -61,7 +60,7 @@ impl Color {
//TODO: does basically the same as get_color, so remove one of them?
pub(crate) fn convert_color(input: u8, pos: u8, foreground_color: &Color) -> Color {
//match color:
//match color:
// - white for "nothing to draw"/background drawing
// - black for pixel to draw
//
@ -72,4 +71,4 @@ impl Color {
Color::inverse_color(foreground_color)
}
}
}
}

39
src/drawing/font.rs
Unescape 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];
@ -90,7 +100,7 @@ mod tests {
let first_value = [0x00, 0x00, 0x5F, 0x00, 0x00, 0x00, 0x00, 0x00];
let last_value = [0x00, 0x41, 0x36, 0x08, 0x00, 0x00, 0x00, 0x00];
assert_eq!(bitmap_8x8('&'), and);
assert_eq!(bitmap_8x8('&'), and);
assert_eq!(bitmap_8x8('ß'), zero);
assert_eq!(bitmap_8x8('°'), zero);
@ -98,13 +108,10 @@ mod tests {
assert_eq!(bitmap_8x8('!'), first_value);
assert_eq!(bitmap_8x8('}'), last_value);
assert_eq!(bitmap_8x8('0')[1], 0x3E);
assert_eq!(bitmap_8x8('0')[1], 0x3E);
}
}
//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] {

297
src/drawing/mod.rs
Unescape 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`
@ -78,16 +78,18 @@ impl<'a> Graphics<'a> {
}
/// Draw a single Pixel with `color`
///
///
/// 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() {
@ -96,8 +98,8 @@ impl<'a> Graphics<'a> {
match color {
Color::Black => {
self.buffer[idx] &= !bit;
},
self.buffer[idx] &= !bit;
}
Color::White => {
self.buffer[idx] |= bit;
}
@ -105,15 +107,17 @@ impl<'a> Graphics<'a> {
}
/// Draw a single Pixel with `color`
///
///
/// limited to i16::max images (buffer_size) at the moment
#[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() {
@ -122,7 +126,7 @@ impl<'a> Graphics<'a> {
match color {
Color::Black => {
self.buffer[idx] = !filling;
self.buffer[idx] = !filling;
},
Color::White => {
self.buffer[idx] = filling;
@ -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,18 +159,17 @@ 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),
);
self.draw_pixel(
x0 + u16::from(width_counter),
y0 + row_counter,
&Color::get_color(elem, width_counter % 8, color));
//Widthcounter shows how far we are in x direction
//Widthcounter shows how far we are in x direction
width_counter += 1;
// if we have reached
if width_counter >= char_width {
@ -185,39 +187,48 @@ 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;
}
}
/// Draws Strings with 8x8 Chars (1 pixel padding included)
///
///
/// Is quite small for the 400x300 E-Ink
///
///
/// 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 */
// 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 */
// }
// }
// 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 */
// }
// }
//bresenham algorithm for lines
/// draw line
/// draw line
pub fn draw_line(&mut self, x0: u16, y0: u16, x1: u16, y1: u16, color: &Color) {
let mut x0 = x0 as i16;
let x1 = x1 as i16;
@ -227,9 +238,9 @@ 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;
loop {
@ -239,7 +250,7 @@ impl<'a> Graphics<'a> {
break;
}
let e2 = 2*err;
let e2 = 2 * err;
if e2 >= dy {
err += dy;
@ -253,7 +264,7 @@ impl<'a> Graphics<'a> {
}
}
/// Draw a horizontal line
/// Draw a horizontal line
/// TODO: maybe optimize by grouping up the bytes? But is it worth the longer and more complicated function? is it even faster?
pub fn draw_horizontal_line(&mut self, x: u16, y: u16, length: u16, color: &Color) {
for i in 0..length {
@ -297,69 +308,63 @@ impl<'a> Graphics<'a> {
}
}
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;
let mut dy = 1;
let mut err: i16 = dx - 2 * radius as i16;
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;
let mut dy = 1;
let mut err: i16 = dx - 2 * radius as i16;
while x >= y {
if filled {
self.circle_helper_filled_putpixel(x0, y0, x, y, color);
} else {
self.circle_helper_putpixel(x0, y0, x, y, color);
}
while x >= y {
if filled {
self.circle_helper_filled_putpixel(x0, y0, x, y, color);
} else {
self.circle_helper_putpixel(x0, y0, x, y, color);
}
if err <= 0 {
y += 1;
err += dy;
dy += 2;
}
if err <= 0 {
y += 1;
err += dy;
dy += 2;
}
if err > 0 {
x -= 1;
dx += 2;
err += dx - 2 * radius as i16;
if err > 0 {
x -= 1;
dx += 2;
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);
// 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_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_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_pixel(buffer, x0 - y, y0 - x, color);
// self.draw_pixel(buffer, x0 + y, y0 - 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);
//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);
self.draw_pixel(x0 - x, y0 + y, 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);
self.draw_pixel(x0 + x, y0 - 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_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_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) {
self.draw_pixel(x0 + x, y0 + y, color);
self.draw_pixel(x0 + y, y0 + x, color);
self.draw_pixel(x0 - y, y0 + x, color);
self.draw_pixel(x0 - x, y0 + y, 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);
self.draw_pixel(x0 + x, y0 - y, color);
}
///TODO: test if circle looks good
/// Draws a circle
@ -373,7 +378,7 @@ fn circle_helper_filled_putpixel(&mut self, x0: u16, y0: u16, x: u16, y: u16, c
let radius = radius as i16;
let x_mid = x as i16;
let y_mid = y as i16;
let mut x_pos: i16 = 0 - radius;
let mut x_pos: i16 = 0 - radius;
let mut y_pos = 0;
let mut err: i16 = 2 - 2 * radius;
@ -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::*;
@ -435,15 +434,12 @@ mod graphics {
let mut buffer = [Color::White.get_byte_value(); 150];
let mut graphics = Graphics::new(40, 30, &mut buffer);
graphics.draw_filled_rectangle(0, 0, 40, 30, &Color::Black);
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
@ -452,12 +448,12 @@ mod graphics {
let mut buffer = [Color::White.get_byte_value(); 8];
let mut graphics = Graphics::new(8, 8, &mut buffer);
graphics.draw_filled_rectangle(0, 0, 4, 4, &Color::Black);
assert_eq!(graphics.buffer[0], 0x0f);
let mut counter = 0;
for &elem in graphics.buffer.iter() {
counter += 1;
counter += 1;
if counter <= 4 {
assert_eq!(elem, 0x0f);
@ -465,8 +461,6 @@ mod graphics {
assert_eq!(elem, Color::White.get_byte_value());
}
}
}
#[test]
@ -474,7 +468,7 @@ mod graphics {
let mut buffer = [Color::White.get_byte_value(); 4];
let mut graphics = Graphics::new(16, 2, &mut buffer);
graphics.draw_horizontal_line(1, 0, 14, &Color::Black);
assert_eq!(graphics.buffer[0], 0x80);
assert_eq!(graphics.buffer[1], 0x01);
assert_eq!(graphics.buffer[2], Color::White.get_byte_value());
@ -488,12 +482,10 @@ mod graphics {
graphics.draw_vertical_line(0, 0, 8, &Color::Black);
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);
}
}
@ -509,9 +501,9 @@ mod graphics {
let mut buffer2 = [Color::White.get_byte_value(); 8];
let mut graphics2 = Graphics::new(8, 8, &mut buffer2);
graphics2.draw_line(5, 0, 5, 8, &Color::Black);
graphics2.draw_line(5, 0, 5, 8, &Color::Black);
for i in 0..graphics.buffer.len() {
for i in 0..graphics.buffer.len() {
assert_eq!(graphics.buffer[i], graphics2.buffer[i]);
}
}
@ -525,9 +517,9 @@ mod graphics {
let mut buffer2 = [Color::White.get_byte_value(); 4];
let mut graphics2 = Graphics::new(16, 2, &mut buffer2);
graphics2.draw_line(1, 0, 14, 0, &Color::Black);
graphics2.draw_line(1, 0, 14, 0, &Color::Black);
for i in 0..graphics.buffer.len() {
for i in 0..graphics.buffer.len() {
assert_eq!(graphics.buffer[i], graphics2.buffer[i]);
}
}
@ -538,15 +530,13 @@ mod graphics {
let mut buffer = [Color::White.get_byte_value(); 8];
let mut graphics = Graphics::new(8, 8, &mut buffer);
graphics.draw_line(0, 0, 16, 16, &Color::Black);
graphics.draw_line(0, 0, 16, 16, &Color::Black);
for i in 0..graphics.buffer.len() {
for i in 0..graphics.buffer.len() {
assert_eq!(graphics.buffer[i], !(0x80 >> i % 8));
}
}
#[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);
@ -573,15 +562,14 @@ mod graphics {
for i in 1..graphics.buffer.len() {
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);
@ -592,8 +580,7 @@ mod graphics {
}
assert_eq!(graphics.buffer[5], Color::White.get_byte_value());
assert_eq!(graphics.buffer[6], !0x20);
assert_eq!(graphics.buffer[7], Color::White.get_byte_value());
assert_eq!(graphics.buffer[7], Color::White.get_byte_value());
// Test H
let mut buffer = [Color::White.get_byte_value(); 8];
@ -603,36 +590,34 @@ mod graphics {
for i in 0..3 {
assert_eq!(graphics.buffer[i], !0x88);
}
assert_eq!(graphics.buffer[3], !0xF8);
assert_eq!(graphics.buffer[3], !0xF8);
for i in 4..7 {
assert_eq!(graphics.buffer[i], !0x88);
}
assert_eq!(graphics.buffer[7], Color::White.get_byte_value());
assert_eq!(graphics.buffer[7], Color::White.get_byte_value());
}
#[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());
}
}
}

117
src/epd1in54/mod.rs
Unescape View File

@ -1,5 +1,5 @@
//! A simple Driver for the Waveshare 1.54" E-Ink Display via SPI
//!
//!
//!
//! # Examples from the 4.2" Display. It should work the same for the 1.54" one.
//!
@ -7,15 +7,15 @@
//! let mut epd4in2 = EPD4in2::new(spi, cs, busy, dc, rst, delay).unwrap();
//!
//! let mut buffer = [0u8, epd4in2.get_width() / 8 * epd4in2.get_height()];
//!
//!
//! // draw something into the buffer
//!
//!
//! epd4in2.display_and_transfer_buffer(buffer, None);
//!
//!
//! // wait and look at the image
//!
//!
//! epd4in2.clear_frame(None);
//!
//!
//! epd4in2.sleep();
//! ```
@ -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> {
@ -58,33 +45,29 @@ pub struct EPD1in54<SPI, CS, BUSY, DataCommand, RST, Delay> {
/// EPD (width, height)
//epd: EPD,
/// Color
background_color: Color,
background_color: Color,
}
impl<SPI, CS, BUSY, DataCommand, RST, Delay, E> EPD1in54<SPI, CS, BUSY, DataCommand, RST, Delay>
where
where
SPI: Write<u8, Error = E>,
CS: OutputPin,
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 EPD1in54<SPI, CS, BUSY, DataCommand, RST, Delay>
where
where
SPI: Write<u8, Error = E>,
CS: OutputPin,
BUSY: InputPin,
DataCommand: OutputPin,
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,32 +185,29 @@ 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
let color = self.background_color.get_byte_value();
self.interface.send_command(Command::WRITE_RAM)?;
self.interface.send_command(Command::WRITE_RAM)?;
self.interface.send_data_x_times(color, WIDTH / 8 * HEIGHT)
}
/// 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>
where
where
SPI: Write<u8, Error = E>,
CS: OutputPin,
BUSY: InputPin,
@ -239,21 +218,27 @@ where
fn wait_until_idle(&mut self) {
self.interface.wait_until_idle(false);
}
pub(crate) fn use_full_frame(&mut self) -> Result<(), E> {
// choose full frame/ram
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);
// x is positioned in bytes, so the last 3 bits which show the position inside a byte in the ram
// aren't relevant
// aren't relevant
self.interface.send_command(Command::SET_RAM_X_ADDRESS_START_END_POSITION)?;
self.interface.send_data((start_x >> 3) as u8)?;
self.interface.send_data((end_x >> 3) as u8)?;
@ -281,12 +266,12 @@ where
Ok(())
}
/// Uses the slower full update
/// Uses the slower full update
pub fn set_lut(&mut self) -> Result<(), E> {
self.set_lut_helper(&LUT_FULL_UPDATE)
}
/// Uses the quick partial refresh
/// Uses the quick partial refresh
pub fn set_lut_quick(&mut self) -> Result<(), E> {
self.set_lut_helper(&LUT_PARTIAL_UPDATE)
}
@ -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)
}
}
}

119
src/epd2in9/mod.rs
Unescape View File

@ -1,5 +1,5 @@
//! A simple Driver for the Waveshare 2.9" E-Ink Display via SPI
//!
//!
//!
//! # Examples from the 4.2" Display. It should work the same for the 2.9" one.
//!
@ -7,15 +7,15 @@
//! let mut epd4in2 = EPD4in2::new(spi, cs, busy, dc, rst, delay).unwrap();
//!
//! let mut buffer = [0u8, epd4in2.get_width() / 8 * epd4in2.get_height()];
//!
//!
//! // draw something into the buffer
//!
//!
//! epd4in2.display_and_transfer_buffer(buffer, None);
//!
//!
//! // wait and look at the image
//!
//!
//! epd4in2.clear_frame(None);
//!
//!
//! epd4in2.sleep();
//! ```
@ -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> {
@ -58,33 +44,30 @@ pub struct EPD2in9<SPI, CS, BUSY, DataCommand, RST, Delay> {
/// EPD (width, height)
//epd: EPD,
/// Color
background_color: Color,
background_color: Color,
}
impl<SPI, CS, BUSY, DataCommand, RST, Delay, E> EPD2in9<SPI, CS, BUSY, DataCommand, RST, Delay>
where
where
SPI: Write<u8, Error = E>,
CS: OutputPin,
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
where
SPI: Write<u8, Error = E>,
CS: OutputPin,
BUSY: InputPin,
DataCommand: OutputPin,
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],