579 lines
19 KiB
Rust
579 lines
19 KiB
Rust
use hcl::platform::PeripheralRef;
|
|
use hcl::platform::Location;
|
|
use hcl::platform::spi;
|
|
use hcl::platform::gpio;
|
|
|
|
use systick::delay_ms;
|
|
|
|
const DEFAULT_WIDTH : u8 = 128;
|
|
// for 1.44" display
|
|
const DEFAULT_HEIGHT_144 : u8 = 128;
|
|
// for 1.8" display
|
|
const DEFAULT_HEIGHT_18 : u8 = 160;
|
|
|
|
pub enum DisplayType {
|
|
BLUE,
|
|
RED_18_GREENTAB,
|
|
RED_18_REDTAB,
|
|
RED_18_BLACKTAB,
|
|
RED144_GREENTAB
|
|
}
|
|
|
|
|
|
// ST7735 commands
|
|
enum Command {
|
|
NOP,
|
|
SWRESET,
|
|
RDDID,
|
|
RDDST,
|
|
|
|
SLPIN,
|
|
SLPOUT,
|
|
PTLON,
|
|
NORON,
|
|
|
|
INVOFF,
|
|
INVON,
|
|
DISPOFF,
|
|
DISPON,
|
|
CASET([u8; 4]),
|
|
RASET([u8; 4]),
|
|
RAMWR,
|
|
RAMRD,
|
|
|
|
PTLAR,
|
|
COLMOD(u8),
|
|
MADCTL(u8),
|
|
|
|
FRMCTR1([u8; 3]),
|
|
FRMCTR2([u8; 3]),
|
|
FRMCTR3([u8; 6]),
|
|
INVCTR(u8),
|
|
DISSET5([u8; 2]),
|
|
|
|
PWCTR1([u8; 2]),
|
|
PWCTR2(u8),
|
|
PWCTR3([u8; 2]),
|
|
PWCTR4([u8; 2]),
|
|
PWCTR5([u8; 2]),
|
|
PWCTR6([u8; 2]),
|
|
VMCTR1([u8; 2]),
|
|
|
|
RDID1,
|
|
RDID2,
|
|
RDID3,
|
|
RDID4,
|
|
|
|
GMCTRP1([u8; 16]),
|
|
GMCTRN1([u8; 16]),
|
|
}
|
|
|
|
fn command_to_byte(cmd : &Command) -> u8 {
|
|
match cmd {
|
|
Command::NOP => 0x00,
|
|
Command::SWRESET => 0x01,
|
|
Command::RDDID => 0x04,
|
|
Command::RDDST => 0x09,
|
|
|
|
Command::SLPIN => 0x10,
|
|
Command::SLPOUT => 0x11,
|
|
Command::PTLON => 0x12,
|
|
Command::NORON => 0x13,
|
|
|
|
Command::INVOFF => 0x20,
|
|
Command::INVON => 0x21,
|
|
Command::DISPOFF => 0x28,
|
|
Command::DISPON => 0x29,
|
|
Command::CASET(_) => 0x2A,
|
|
Command::RASET(_) => 0x2B,
|
|
Command::RAMWR => 0x2C,
|
|
Command::RAMRD => 0x2E,
|
|
|
|
Command::PTLAR => 0x30,
|
|
Command::COLMOD(_) => 0x3A,
|
|
Command::MADCTL(_) => 0x36,
|
|
|
|
Command::FRMCTR1(_) => 0xB1,
|
|
Command::FRMCTR2(_) => 0xB2,
|
|
Command::FRMCTR3(_) => 0xB3,
|
|
Command::INVCTR(_) => 0xB4,
|
|
Command::DISSET5(_) => 0xB6,
|
|
|
|
Command::PWCTR1(_) => 0xC0,
|
|
Command::PWCTR2(_) => 0xC1,
|
|
Command::PWCTR3(_) => 0xC2,
|
|
Command::PWCTR4(_) => 0xC3,
|
|
Command::PWCTR5(_) => 0xC4,
|
|
Command::PWCTR6(_) => 0xFC,
|
|
Command::VMCTR1(_) => 0xC5,
|
|
|
|
Command::RDID1 => 0xDA,
|
|
Command::RDID2 => 0xDB,
|
|
Command::RDID3 => 0xDC,
|
|
Command::RDID4 => 0xDD,
|
|
|
|
Command::GMCTRP1(_) => 0xE0,
|
|
Command::GMCTRN1(_) => 0xE1
|
|
}
|
|
}
|
|
|
|
|
|
// Initialization commands for 7735B screens
|
|
const ST7735_BLUE_INIT : [(Command, u32); 18] = [
|
|
(Command::SWRESET, 50), // 1: Software reset, 50 ms delay
|
|
(Command::SLPOUT, 500), // 2: Out of sleep mode, 500ms delay
|
|
(Command::COLMOD(0x05), 10), // 3: Set color mode, 16-bit color, 10ms delay
|
|
(Command::FRMCTR1([0x00, 0x06, 0x03]), 10), // 4: Frame rate control,
|
|
// fastest refresh,
|
|
// 6 lines front porch,
|
|
// 3 lines back porch
|
|
// 10ms delay
|
|
(Command::MADCTL(0x08), 0), // 5: Memory access ctrl (directions)
|
|
// Row addr/col addr, bottom to top refresh
|
|
(Command::DISSET5([0x15,0x02]), 0), // 6: Display settings #5,
|
|
// 1 clk cycle nonoverlap, 2 cycle gate
|
|
// Fix on VTL
|
|
(Command::INVCTR(0x00), 0), // 7: Display inversion control,
|
|
// Line inversion
|
|
(Command::PWCTR1([0x02, 0x07]), 10), // 8: Power control,
|
|
// GVDD = 4.7V
|
|
// 1.0uA
|
|
// 10 ms delay
|
|
(Command::PWCTR2(0x05), 0), // 9: Power control,
|
|
// GH = 14.7V, VGL = -7.35V
|
|
(Command::PWCTR3([0x01, 0x02]), 0), // 10: Power control,
|
|
// Opamp current small
|
|
// Boost frequency
|
|
(Command::VMCTR1([0x3C, 0x38]), 10), // 11: Power control
|
|
// VCOMH = 4V
|
|
// VCOML = -1.1V
|
|
// 10 ms delay
|
|
(Command::PWCTR6([0x11, 0x15]), 0), // 12: Power control
|
|
(Command::GMCTRP1([0x09, 0x16, 0x09, 0x20, // 13: Magical unicorn dust
|
|
0x21, 0x1B, 0x13, 0x19,
|
|
0x17, 0x15, 0x1E, 0x2B,
|
|
0x04, 0x05, 0x02, 0x0E]), 0),
|
|
(Command::GMCTRN1([0x0B, 0x14, 0x08, 0x1E, // 14: Sparkles and rainbows
|
|
0x22, 0x1D, 0x18, 0x1E,
|
|
0x1B, 0x1A, 0x24, 0x2B,
|
|
0x06, 0x06, 0x02, 0x0F]), 10), // 10ms delay
|
|
(Command::CASET([0x00, 0x02, 0x00, 0x81]), 0), // 15: Column addr set
|
|
// XSTART = 2
|
|
// XEND = 129
|
|
(Command::RASET([0x00, 0x02, 0x00, 0x81]), 0), // 16: Row addr set
|
|
// XSTART = 1
|
|
// XEND = 160
|
|
(Command::NORON, 10), // 17: Normal display on, 10ms delay
|
|
(Command::DISPON, 500) // 18: Main screen turn on, 500ms delay
|
|
];
|
|
|
|
|
|
// Init for 7735R, part 1 (red or green tab)
|
|
const ST7735_RED_INIT1 : [(Command, u32); 15] = [
|
|
(Command::SWRESET, 150), // 1: Software reset, 150ms delay
|
|
(Command::SLPOUT, 500), // 2: Out of sleep mode
|
|
(Command::FRMCTR1([0x01, 0x2C, 0x2D]), 0), // 3: Frame rate ctrl - normal mode
|
|
// Rate = fosc/(1x2+40) * (LINE+2C+2D)
|
|
(Command::FRMCTR2([0x01, 0x2C, 0x2D]), 0), // 4: Frame rate control - idle mode
|
|
// Rate = fosc/(1x2+40) * (LINE+2C+2D)
|
|
(Command::FRMCTR3([0x01, 0x2C, 0x2D, // 5: Frame rate ctrl - partial mode
|
|
0x01, 0x2C, 0x2D]), 0), // Dot inversion mode
|
|
// Line inversion mode
|
|
(Command::INVCTR(0x07), 0), // 6: Display inversion ctrl
|
|
// No inversion
|
|
(Command::PWCTR1([0xA2, 0x02]), 0), // 7: Power control, -4.6V AUTO mode
|
|
(Command::PWCTR2(0xC5), 0), // 8: Power control
|
|
// VGH25 = 2.4C VGSEL = -10 VGH = 3 * AVDD
|
|
(Command::PWCTR3([0x0A, 0x00]), 0), // 9: Power control:
|
|
// Opamp current small
|
|
// Boost frequency
|
|
(Command::PWCTR4([0x8A, 0x2A]),0), // 10: Power control, 2 args, no delay:
|
|
// BCLK/2, Opamp current small & Medium low
|
|
(Command::PWCTR5([0x8A, 0xEE]), 0), // 11: Power control
|
|
(Command::VMCTR1([0x0E, 0x4D]), 0), // 12: Power control
|
|
|
|
(Command::INVOFF, 0), // 13: Don't invert display
|
|
(Command::MADCTL(0xC8), 0), // 14: Memory access control (directions), 1 arg:
|
|
// row addr/col addr, bottom to top refresh
|
|
(Command::COLMOD(0x05), 0) // 15: set color mode, 1 arg, no delay:
|
|
// 16-bit color
|
|
];
|
|
|
|
|
|
// Init for 7735R, part 2 (green tab only)
|
|
const ST7735_RED_INIT_GREEN2 : [(Command, u32); 2] = [
|
|
(Command::CASET([0x00, 0x02, 0x00, 0x7F+0x02]), 0), // 1: Column addr set
|
|
// XSTART = 0
|
|
// XEND = 127
|
|
(Command::RASET([0x00, 0x01, 0x00, 0x9F+0x01]), 0) // 2: Row addr set
|
|
// XSTART = 0
|
|
// XEND = 159
|
|
];
|
|
|
|
// Init for 7735R, part 2 (red tab only)
|
|
const ST7735_RED_INIT_RED2 : [(Command, u32); 2] = [
|
|
(Command::CASET([0x00, 0x00, 0x00, 0x7F]), 0), // 1: Column addr set, 4 args, no delay:
|
|
// XSTART = 0
|
|
// XEND = 127
|
|
(Command::RASET([0x00, 0x00, 0x00, 0x9F]),0) // 2: Row addr set, 4 args, no delay:
|
|
// XSTART = 0
|
|
// XEND = 159
|
|
];
|
|
|
|
// Init for 7735R, part 2 (green 1.44 tab)
|
|
const ST7735_RED_INIT_GREEN1442 : [(Command, u32); 2] = [
|
|
(Command::CASET([0x00, 0x00, 0x00, 0x7F]), 0), // 1: Column addr set, 4 args, no delay:
|
|
// XSTART = 0
|
|
// XEND = 127
|
|
(Command::RASET([0x00, 0x00, 0x00, 0x7F]), 0) // 2: Row addr set, 4 args, no delay:
|
|
// XSTART = 0
|
|
// XEND = 127
|
|
];
|
|
|
|
// Init for 7735R, part 3 (red or green tab)
|
|
const ST7735_RED_INIT3: [(Command, u32); 4] = [
|
|
(Command::GMCTRP1([0x02, 0x1c, 0x07, 0x12, // 1: Magical unicorn dust
|
|
0x37, 0x32, 0x29, 0x2d,
|
|
0x29, 0x25, 0x2B, 0x39,
|
|
0x00, 0x01, 0x03, 0x10]), 0),
|
|
(Command::GMCTRN1([0x03, 0x1d, 0x07, 0x06, // 2: Sparkles and rainbows
|
|
0x2E, 0x2C, 0x29, 0x2D,
|
|
0x2E, 0x2E, 0x37, 0x3F,
|
|
0x00, 0x00, 0x02, 0x10]), 0),
|
|
(Command::NORON, 10), // 3: Normal display, 10 ms delay
|
|
(Command::DISPON, 100) // 4: Main screen turn on, 100 ms delay
|
|
];
|
|
|
|
|
|
pub struct St7735 {
|
|
display_type : DisplayType,
|
|
column_start : u8,
|
|
row_start : u8,
|
|
width : u8,
|
|
height : u8,
|
|
|
|
cs_pin : u32,
|
|
rst_pin : u32,
|
|
rs_pin : u32,
|
|
led_pin : u32
|
|
}
|
|
|
|
pub struct St7735IO<SPIAddr, GPIOAddr>
|
|
where SPIAddr: Location,
|
|
GPIOAddr: Location {
|
|
st7735 : St7735,
|
|
spi : PeripheralRef<spi::SPI, SPIAddr>,
|
|
gpio : PeripheralRef<gpio::GPIO, GPIOAddr>,
|
|
}
|
|
|
|
|
|
impl St7735 {
|
|
pub fn new(display_type : DisplayType, cs_pin : u32, rst_pin : u32, rs_pin : u32, led_pin : u32) -> St7735 {
|
|
match display_type {
|
|
DisplayType::BLUE => St7735 {
|
|
display_type : display_type,
|
|
cs_pin : cs_pin,
|
|
rst_pin : rst_pin,
|
|
rs_pin : rs_pin,
|
|
led_pin: led_pin,
|
|
column_start : 0,
|
|
row_start: 0,
|
|
width: DEFAULT_WIDTH,
|
|
height: DEFAULT_HEIGHT_18,
|
|
},
|
|
DisplayType::RED_18_GREENTAB => St7735 {
|
|
display_type : display_type,
|
|
cs_pin : cs_pin,
|
|
rst_pin : rst_pin,
|
|
rs_pin : rs_pin,
|
|
led_pin: led_pin,
|
|
column_start : 2,
|
|
row_start: 1,
|
|
width: DEFAULT_WIDTH,
|
|
height: DEFAULT_HEIGHT_18,
|
|
},
|
|
DisplayType::RED_18_REDTAB => St7735 {
|
|
display_type : display_type,
|
|
cs_pin : cs_pin,
|
|
rst_pin : rst_pin,
|
|
rs_pin : rs_pin,
|
|
led_pin: led_pin,
|
|
column_start : 0,
|
|
row_start: 0,
|
|
width: DEFAULT_WIDTH,
|
|
height: DEFAULT_HEIGHT_18,
|
|
},
|
|
DisplayType::RED_18_BLACKTAB => St7735 {
|
|
display_type : display_type,
|
|
cs_pin : cs_pin,
|
|
rst_pin : rst_pin,
|
|
rs_pin : rs_pin,
|
|
led_pin: led_pin,
|
|
column_start : 0,
|
|
row_start: 0,
|
|
width: DEFAULT_WIDTH,
|
|
height: DEFAULT_HEIGHT_18,
|
|
},
|
|
DisplayType::RED144_GREENTAB => St7735 {
|
|
display_type : display_type,
|
|
cs_pin : cs_pin,
|
|
rst_pin : rst_pin,
|
|
rs_pin : rs_pin,
|
|
led_pin: led_pin,
|
|
column_start : 2,
|
|
row_start: 3,
|
|
width: DEFAULT_WIDTH,
|
|
height: DEFAULT_HEIGHT_144,
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn start<SPIAddr, GPIOAddr>(self, spi : PeripheralRef<spi::SPI, SPIAddr>, gpio : PeripheralRef<gpio::GPIO, GPIOAddr>)
|
|
-> St7735IO<SPIAddr, GPIOAddr>
|
|
where SPIAddr: Location,
|
|
GPIOAddr: Location {
|
|
St7735IO::start(self, spi, gpio)
|
|
}
|
|
}
|
|
|
|
|
|
impl<SPIAddr, GPIOAddr> St7735IO<SPIAddr, GPIOAddr>
|
|
where SPIAddr: Location,
|
|
GPIOAddr: Location {
|
|
|
|
pub fn start(st7735 : St7735, mut spi : PeripheralRef<spi::SPI, SPIAddr>, gpio : PeripheralRef<gpio::GPIO, GPIOAddr>)
|
|
-> St7735IO<SPIAddr, GPIOAddr>
|
|
where SPIAddr: Location,
|
|
GPIOAddr: Location {
|
|
|
|
spi.configure(|s| {
|
|
s.set_master_mode(true)
|
|
.set_software_slave_select(true)
|
|
.set_clock_divider(8)
|
|
// required for master mode, even if ss is done manually
|
|
.set_slave_select_output_enabled(true)
|
|
});
|
|
|
|
let mut io = St7735IO {
|
|
st7735: st7735,
|
|
spi : spi,
|
|
gpio : gpio
|
|
};
|
|
|
|
io.set_cs();
|
|
|
|
io
|
|
}
|
|
|
|
fn set_rs(&mut self) {
|
|
self.gpio.set_bit(self.st7735.rs_pin);
|
|
}
|
|
|
|
fn reset_rs(&mut self) {
|
|
self.gpio.reset_bit(self.st7735.rs_pin);
|
|
}
|
|
|
|
fn set_rst(&mut self) {
|
|
self.gpio.set_bit(self.st7735.rst_pin);
|
|
}
|
|
|
|
fn reset_rst(&mut self) {
|
|
self.gpio.reset_bit(self.st7735.rst_pin);
|
|
}
|
|
|
|
fn set_cs(&mut self) {
|
|
self.gpio.set_bit(self.st7735.cs_pin);
|
|
}
|
|
|
|
fn reset_cs(&mut self) {
|
|
self.gpio.reset_bit(self.st7735.cs_pin);
|
|
}
|
|
|
|
fn enable_led(&mut self) {
|
|
self.gpio.set_bit(self.st7735.led_pin);
|
|
}
|
|
|
|
fn disable_led(&mut self) {
|
|
self.gpio.reset_bit(self.st7735.led_pin);
|
|
}
|
|
|
|
fn reset(&mut self) {
|
|
self.reset_cs();
|
|
self.set_rst();
|
|
delay_ms(500);
|
|
self.reset_rst();
|
|
delay_ms(500);
|
|
self.set_rst();
|
|
delay_ms(500);
|
|
}
|
|
|
|
fn write_byte(&mut self, byte : u8) {
|
|
self.spi.set_enabled(true);
|
|
self.spi.set_data(byte as u32);
|
|
while !self.spi.rx_buffer_not_empty() {}
|
|
while self.spi.busy() {}
|
|
self.spi.set_enabled(false);
|
|
}
|
|
|
|
pub fn write_data_byte(&mut self, data : u8) {
|
|
self.set_rs();
|
|
|
|
self.reset_cs();
|
|
self.write_byte(data);
|
|
self.set_cs();
|
|
}
|
|
|
|
pub fn write_color_bytes(&mut self, data0 : u8, data1 : u8) {
|
|
self.set_rs();
|
|
|
|
self.reset_cs();
|
|
self.write_byte(data0);
|
|
self.write_byte(data1);
|
|
self.set_cs();
|
|
}
|
|
|
|
fn write_command_byte(&mut self, cmd : u8) {
|
|
self.reset_rs();
|
|
|
|
self.reset_cs();
|
|
self.write_byte(cmd);
|
|
self.set_cs();
|
|
}
|
|
|
|
pub fn write_command(&mut self, cmd : &Command) {
|
|
let cmd_byte = command_to_byte(cmd);
|
|
self.write_command_byte(cmd_byte);
|
|
|
|
match cmd {
|
|
Command::COLMOD(arg) |
|
|
Command::MADCTL(arg) |
|
|
Command::INVCTR(arg) |
|
|
Command::PWCTR2(arg) => self.write_data_byte(*arg),
|
|
|
|
Command::DISSET5(args) |
|
|
Command::PWCTR3(args) |
|
|
Command::PWCTR4(args) |
|
|
Command::PWCTR5(args) |
|
|
Command::PWCTR6(args) |
|
|
Command::VMCTR1(args) |
|
|
Command::PWCTR1(args) => {
|
|
for &arg in args.iter() {
|
|
self.write_data_byte(arg);
|
|
}
|
|
},
|
|
|
|
Command::CASET(args) |
|
|
Command::RASET(args) => {
|
|
for &arg in args.iter() {
|
|
self.write_data_byte(arg);
|
|
}
|
|
},
|
|
|
|
Command::FRMCTR1(args) |
|
|
Command::FRMCTR2(args) => {
|
|
for &arg in args.iter() {
|
|
self.write_data_byte(arg);
|
|
}
|
|
},
|
|
|
|
Command::FRMCTR3(args) => {
|
|
for &arg in args.iter() {
|
|
self.write_data_byte(arg);
|
|
}
|
|
},
|
|
|
|
Command::GMCTRP1(args) |
|
|
Command::GMCTRN1(args) => {
|
|
for &arg in args.iter() {
|
|
self.write_data_byte(arg);
|
|
}
|
|
},
|
|
|
|
_ => ()
|
|
}
|
|
}
|
|
|
|
fn run_commands(&mut self, cmds: &[(Command, u32)]) {
|
|
for &(ref cmd, ref delay) in cmds.iter() {
|
|
self.write_command(cmd);
|
|
delay_ms(*delay);
|
|
}
|
|
}
|
|
|
|
|
|
pub fn init(&mut self) {
|
|
|
|
self.enable_led();
|
|
self.reset();
|
|
|
|
match self.st7735.display_type {
|
|
DisplayType::BLUE => {
|
|
self.run_commands(&ST7735_BLUE_INIT);
|
|
},
|
|
DisplayType::RED_18_GREENTAB => {
|
|
self.run_commands(&ST7735_RED_INIT1);
|
|
self.run_commands(&ST7735_RED_INIT_GREEN2);
|
|
self.run_commands(&ST7735_RED_INIT3);
|
|
},
|
|
DisplayType::RED_18_REDTAB => {
|
|
self.run_commands(&ST7735_RED_INIT1);
|
|
self.run_commands(&ST7735_RED_INIT_RED2);
|
|
self.run_commands(&ST7735_RED_INIT3);
|
|
},
|
|
DisplayType::RED_18_BLACKTAB => {
|
|
self.run_commands(&ST7735_RED_INIT1);
|
|
self.run_commands(&ST7735_RED_INIT_RED2);
|
|
self.run_commands(&ST7735_RED_INIT3);
|
|
// Change MADCTL color filter for black
|
|
self.write_command(&Command::MADCTL(0xC0));
|
|
},
|
|
DisplayType::RED144_GREENTAB => {
|
|
self.run_commands(&ST7735_RED_INIT1);
|
|
self.run_commands(&ST7735_RED_INIT_GREEN1442);
|
|
self.run_commands(&ST7735_RED_INIT3);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn set_addr_win(&mut self, x0 : u8, y0 : u8, x1 : u8, y1 : u8) {
|
|
let xstart = x0 + self.st7735.column_start;
|
|
let xend = x1 + self.st7735.column_start;
|
|
self.write_command(&Command::CASET([0x00,
|
|
xstart,
|
|
0x00,
|
|
xend])); // Column addr set
|
|
|
|
let ystart = y0 + self.st7735.row_start;
|
|
let yend = y1 + self.st7735.row_start;
|
|
self.write_command(&Command::RASET([0x00,
|
|
ystart,
|
|
0x00,
|
|
yend])); // Column addr set
|
|
|
|
self.write_command(&Command::RAMWR); // write to RAM
|
|
}
|
|
|
|
pub fn fill_rect(&mut self, x : u8, y : u8, w : u8, h : u8, c1 : u8, c2 : u8) {
|
|
|
|
self.set_addr_win(x, y, x + w - 1, y + h - 1);
|
|
|
|
self.set_rs();
|
|
self.reset_cs();
|
|
|
|
for i in 0..h {
|
|
for j in 0..w {
|
|
self.write_byte(c1);
|
|
self.write_byte(c2);
|
|
}
|
|
}
|
|
|
|
self.set_cs();
|
|
}
|
|
|
|
|
|
pub fn done(mut self) -> (St7735, PeripheralRef<spi::SPI, SPIAddr>, PeripheralRef<gpio::GPIO, GPIOAddr>) {
|
|
self.set_cs();
|
|
(self.st7735, self.spi, self.gpio)
|
|
}
|
|
}
|