Help needed with eINK display driver!
MCU/Processor/Board + compiler
I am using an nRF52840-DK board with Adafruit-BSP for Arduino framework with arm-gcc-none-eabi.
What do you want to achieve?
So basically I am trying to get LVGL running on my nRF52840 + SSD1608 eINK display for a wearable project. My C++ is quite weak so have been drowning a little (although I have learned a lot so far! Lots of ahas!).
LVGL itself is running now, but my display driver appears to be malfunctioning.
What have you tried so far?
So I’ve tried commenting out the function declarations to bypass my set_cb and round_cb functions in case the pointer arithmetic was incorrect, and the garbage output does change, but it’s still garbage.
Initially the display wouldn’t even work, so I had to heavily modify the Waveshare driver to cater for SSD1608. This most likely works fine as the display refreshes fine, if I set it to fill the screen with black and then white, it does this correctly. The display also definitely works because I have tested it with Adafruit library.
Display is monochrome, as per my understanding WaveShare driver will take a byte, each bit is representing state of one pixel along x axis. So each byte updates an 8x1 pixel region, going along to the right, then jumps down to second line etc…
I may be wrong though.
Code to reproduce
main.cpp (the main offender)
#include "Wire.h"
#include "lvgl.h"
#include "lv_demo.h"
#include "epd1in54.h"
#include "gpio.h"
#include "SEGGER_RTT.h"
#define SCK 27
#define MISO 26
#define MOSI 40
#define EPD_CS 39
#define EPD_DC 38
#define SRAM_CS 37
#define EPD_RESET 36 // can set to -1 and share with microcontroller Reset!
#define EPD_BUSY 35 // can set to -1 to not use a pin (will wait a fixed delay)
Epd epd;
void epd_flush( lv_disp_drv_t*, const lv_area_t*, lv_color_t* );
void epd_set_px_cb(lv_disp_drv_t*, uint8_t*, lv_coord_t, lv_coord_t, lv_coord_t, lv_color_t, lv_opa_t);
void epd_rounder( lv_disp_drv_t*, lv_area_t*);
static void button_reader( lv_indev_drv_t*, lv_indev_data_t* );
uint8_t button_interface();
static const uint8_t screenWidth = 200;
static const uint8_t screenHeight = 200;
static lv_disp_draw_buf_t draw_buf;
static lv_color_t buf[ screenWidth * screenHeight / 8 ];
#if LV_USE_LOG != 0
/* Serial debugging */
void my_print( lv_log_level_t level, const char * file, uint32_t line, const char * fn_name, const char * dsc )
{
Serial.printf( "%s(%s)@%d->%s\r\n", file, fn_name, line, dsc );
Serial.flush();
}
#endif
void epd_flush( lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p )
{
uint8_t x_end, y_end;
uint8_t *buffer = (uint8_t*) color_p;
x_end = area->x2 >= epd.width ? epd.width-1 : area->x2 -1;
y_end = area->y2 >= epd.height ? epd.height-1 : area->y2-1;
epd.SetMemoryArea(area->x1, area->y1, x_end, y_end);
epd.SetMemoryPointer(area->x1, area->y1);
epd.SendCommand(WRITE_RAM);
for (int j = 0; j < y_end - area->y1 + 1; j++) {
for (int i = 0; i < (x_end - area->x1 + 1) / 8; i++) {
epd.SendData(buffer[i + j * ((x_end - area->x1 + 1) / 8)]);
}
}
//epd.SetFrameMemory(buffer, area->x1, area->y1, area->x2 - area->x1 + 1, area->y2-area->y1+1);
if(lv_disp_flush_is_last(disp))
{
epd.DisplayFrame();
//epd.WaitUntilIdle();
}
lv_disp_flush_ready(disp);
}
void epd_set_px_cb(lv_disp_drv_t *disp, uint8_t *buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y, lv_color_t color, lv_opa_t opa)
{
unsigned char bitIndex, a;
uint16_t byteIndex = ((y*200)-1)+(x&0xF8);
bitIndex = x-(x&0xF8);
a = 1;
if(lv_color_brightness(color) > 128)
{
buf[byteIndex] |= a << bitIndex;
}
else{
buf[byteIndex] &= ~(a << bitIndex);
}
}
void my_print(const char *);
void my_print(const char* buf)
{
Serial.println(buf);
}
void epd_rounder( lv_disp_drv_t *disp, lv_area_t *area)
{
area->x1 &= 0xF8;
area->x2 &= 0xF8;
}
uint8_t button_interface()
{
if(READ_ENTER==1||READ_ESC==1||READ_NEXT==1||READ_PREVIOUS==1)
{
delay(20);
if(READ_ENTER==1) return ENTER_PRESSED;
if(READ_ESC==1) return ESC_PRESSED;
if(READ_NEXT==1) return NEXT_PRESSED;
if(READ_PREVIOUS==1) return PREVIOUS_PRESSED;
}
}
static void event_handler(lv_event_t * e)
{
lv_event_code_t code = lv_event_get_code(e);
if(code == LV_EVENT_CLICKED) {
LV_LOG_USER("Clicked");
}
else if(code == LV_EVENT_VALUE_CHANGED) {
LV_LOG_USER("Toggled");
}
}
void button_reader(lv_indev_drv_t* drv, lv_indev_data_t* data)
{
//This is quickly coded as touchscreen will likely be implemented, so this code may be thrown away.
uint8_t receivedKey = button_interface();
static uint8_t lastKey = 0;
if(receivedKey!=0)
{
data->state = LV_INDEV_STATE_PR;
switch(receivedKey)
{
case ENTER_PRESSED:
receivedKey = LV_KEY_ENTER;
case ESC_PRESSED:
receivedKey = LV_KEY_ESC;
case NEXT_PRESSED:
receivedKey = LV_KEY_NEXT;
case PREVIOUS_PRESSED:
receivedKey = LV_KEY_PREV;
}
lastKey = receivedKey;
}
else
{
data->state = LV_INDEV_STATE_REL;
}
data->key = lastKey;
}
lv_obj_t *label2, *label1;
void setup()
{
pinMode(11, INPUT);
pinMode(12, INPUT);
pinMode(24, INPUT);
pinMode(25, INPUT);
pinMode(14, OUTPUT);
Serial.begin( 9600 ); /* prepare for possible serial debug */
//while ( !Serial ) delay(10);
Serial.println( "Hello Arduino! (V8.0.X)" );
Serial.println( "I am LVGL_Arduino" );
if (epd.Init(lut_full_update) != 0) {
digitalWrite(14, LOW);
Serial.print("e-Paper init failed");
return;
}
Serial.print("e-Paper init success");
epd.ClearFrameMemory(0xFF);
epd.DisplayFrame();
delay(1000);
epd.ClearFrameMemory(0x00);
epd.DisplayFrame();
delay(1000);
digitalWrite(14, HIGH);
lv_init();
#if LV_USE_LOG != 0
lv_log_register_print_cb( my_print ); /* register print function for debugging */
#endif
lv_disp_draw_buf_init( &draw_buf, buf, NULL, screenWidth * screenHeight / 8 );
/*Initialising display*/
static lv_disp_drv_t disp_drv;
lv_disp_drv_init( &disp_drv );
disp_drv.draw_buf = &draw_buf;
disp_drv.flush_cb = epd_flush;
disp_drv.set_px_cb = epd_set_px_cb;
disp_drv.rounder_cb = epd_rounder;
disp_drv.hor_res = screenWidth;
disp_drv.ver_res = screenHeight;
lv_disp_t* disp;
disp = lv_disp_drv_register( &disp_drv );
//KEYPAD Initialisation. ToDo - refactor into nice methods once eInk operational.
static lv_indev_drv_t indev_drv;
lv_indev_drv_init( &indev_drv );
indev_drv.type = LV_INDEV_TYPE_KEYPAD;
indev_drv.read_cb = button_reader;
lv_indev_drv_register( &indev_drv );
#if 1
// Create simple label
lv_obj_t *label = lv_label_create( lv_scr_act() );
lv_label_set_text( label, "Hello Arduino! (V8.0.X)" );
lv_obj_align( label, LV_ALIGN_CENTER, 0, 0 );
#else
/* Try an example from the lv_examples Arduino library
make sure to include it as written above.
lv_example_btn_1();
*/
// uncomment one of these demos
//lv_demo_widgets(); // OK
// lv_demo_benchmark(); // OK
lv_demo_keypad_encoder(); // works, but I haven't an encoder
// lv_demo_music(); // NOK
// lv_demo_printer();
// lv_demo_stress(); // seems to be OK
#endif
Serial.println( "Setup done" );
}
void loop()
{
lv_timer_handler(); /* let the GUI do its work */
delay( 1 );
lv_tick_inc(1);
}
epd1in54.h
#ifndef EPD1IN54_H
#define EPD1IN54_H
#include "epdif.h"
// Display resolution
#define EPD_WIDTH 200
#define EPD_HEIGHT 200
// EPD1IN54 commands
#define DRIVER_OUTPUT_CONTROL 0x01
#define BOOSTER_SOFT_START_CONTROL 0x0C
#define GATE_SCAN_START_POSITION 0x0F
#define DEEP_SLEEP_MODE 0x10
#define DATA_ENTRY_MODE_SETTING 0x11
#define SW_RESET 0x12
#define TEMPERATURE_SENSOR_CONTROL 0x1A
#define MASTER_ACTIVATION 0x20
#define DISPLAY_UPDATE_CONTROL_1 0x21
#define DISPLAY_UPDATE_CONTROL_2 0x22
#define WRITE_RAM 0x24
#define WRITE_VCOM_REGISTER 0x2C
#define WRITE_LUT_REGISTER 0x32
#define SET_DUMMY_LINE_PERIOD 0x3A
#define SET_GATE_TIME 0x3B
#define BORDER_WAVEFORM_CONTROL 0x3C
#define SET_RAM_X_ADDRESS_START_END_POSITION 0x44
#define SET_RAM_Y_ADDRESS_START_END_POSITION 0x45
#define SET_RAM_X_ADDRESS_COUNTER 0x4E
#define SET_RAM_Y_ADDRESS_COUNTER 0x4F
#define TERMINATE_FRAME_READ_WRITE 0xFF
extern const unsigned char lut_full_update[];
extern const unsigned char lut_partial_update[];
class Epd : EpdIf {
public:
unsigned long width;
unsigned long height;
Epd();
~Epd();
int Init(const unsigned char* lut);
void SendCommand(unsigned char command);
void SendData(unsigned char data);
void WaitUntilIdle(void);
void Reset(void);
void SetFrameMemory(
const unsigned char* image_buffer,
int x,
int y,
int image_width,
int image_height
);
void SetFrameMemory(const unsigned char* image_buffer);
void ClearFrameMemory(unsigned char color);
void DisplayFrame(void);
void Sleep(void);
void SetLut(const unsigned char* lut);
void SetMemoryArea(int x_start, int y_start, int x_end, int y_end);
void SetMemoryPointer(int x, int y);
private:
unsigned int reset_pin;
unsigned int dc_pin;
unsigned int cs_pin;
unsigned int busy_pin;
const unsigned char* lut;
};
#endif /* EPD1IN54_H */
/* END OF FILE */
epd1in54.cpp (modified)
#include <stdlib.h>
#include "epd1in54.h"
Epd::~Epd() {
};
Epd::Epd() {
reset_pin = RST_PIN;
dc_pin = DC_PIN;
cs_pin = CS_PIN;
busy_pin = BUSY_PIN;
width = EPD_WIDTH;
height = EPD_HEIGHT;
};
int Epd::Init(const unsigned char* lut) {
/* this calls the peripheral hardware interface, see epdif */
if (IfInit() != 0) {
return -1;
}
/* EPD hardware init start */
this->lut = lut;
Reset();
WaitUntilIdle();
SendCommand(SW_RESET);
WaitUntilIdle();
SendCommand(DRIVER_OUTPUT_CONTROL);
SendData(EPD_HEIGHT - 1);
SendData((EPD_HEIGHT - 1) >> 8);
SendData(0x00);
SendCommand(SET_DUMMY_LINE_PERIOD);
SendData(0x1B);
SendCommand(SET_GATE_TIME);
SendData(0x0B);
SendCommand(DATA_ENTRY_MODE_SETTING);
SendData(0x03); // X increment; Y increment
SendCommand(SET_RAM_X_ADDRESS_START_END_POSITION);
SendData(0x00);
SendData(EPD_WIDTH / 8 - 1);
SendCommand(SET_RAM_Y_ADDRESS_START_END_POSITION);
SendData(0x00);
SendData(0x00);
SendData(EPD_HEIGHT - 1);
SendData((EPD_HEIGHT - 1) >> 8);
/*
SendCommand(BOOSTER_SOFT_START_CONTROL);
SendData(0xD7);
SendData(0xD6);
SendData(0x9D);
*/
SendCommand(WRITE_VCOM_REGISTER);
SendData(0x70); // VCOM 7C
SetLut(this->lut);
/* EPD hardware init end */
return 0;
}
/**
* @brief: basic function for sending commands
*/
void Epd::SendCommand(unsigned char command) {
DigitalWrite(dc_pin, LOW);
SpiTransfer(command);
}
/**
* @brief: basic function for sending data
*/
void Epd::SendData(unsigned char data) {
DigitalWrite(dc_pin, HIGH);
SpiTransfer(data);
}
/**
* @brief: Wait until the busy_pin goes LOW
*/
void Epd::WaitUntilIdle(void) {
while(DigitalRead(busy_pin) == HIGH) { //LOW: idle, HIGH: busy
DelayMs(10);
}
}
/**
* @brief: module reset.
* often used to awaken the module in deep sleep,
* see Epd::Sleep();
*/
void Epd::Reset(void) {
DigitalWrite(reset_pin, HIGH);
DelayMs(20);
DigitalWrite(reset_pin, LOW); //module reset
DelayMs(20);
DigitalWrite(reset_pin, HIGH);
DelayMs(20);
}
/**
* @brief: set the look-up table register
*/
void Epd::SetLut(const unsigned char* lut) {
this->lut = lut;
SendCommand(WRITE_LUT_REGISTER);
/* the length of look-up table is 30 bytes */
for (int i = 0; i < 30; i++) {
SendData(this->lut[i]);
}
}
/**
* @brief: put an image buffer to the frame memory.
* this won't update the display.
*/
void Epd::SetFrameMemory(
const unsigned char* image_buffer,
int x,
int y,
int image_width,
int image_height
) {
int x_end;
int y_end;
if (
image_buffer == NULL ||
x < 0 || image_width < 0 ||
y < 0 || image_height < 0
) {
return;
}
/* x point must be the multiple of 8 or the last 3 bits will be ignored */
x &= 0xF8;
image_width &= 0xF8;
if (x + image_width >= this->width) {
x_end = this->width - 1;
} else {
x_end = x + image_width - 1;
}
if (y + image_height >= this->height) {
y_end = this->height - 1;
} else {
y_end = y + image_height - 1;
}
SetMemoryArea(x, y, x_end, y_end);
SetMemoryPointer(x, y);
SendCommand(WRITE_RAM);
/* send the image data */
for (int j = 0; j < y_end - y + 1; j++) {
for (int i = 0; i < (x_end - x + 1) / 8; i++) {
SendData(image_buffer[i + j * (image_width / 8)]);
}
}
}
/**
* @brief: put an image buffer to the frame memory.
* this won't update the display.
*
* Question: When do you use this function instead of
* void SetFrameMemory(
* const unsigned char* image_buffer,
* int x,
* int y,
* int image_width,
* int image_height
* );
* Answer: SetFrameMemory with parameters only reads image data
* from the RAM but not from the flash in AVR chips (for AVR chips,
* you have to use the function pgm_read_byte to read buffers
* from the flash).
*/
void Epd::SetFrameMemory(const unsigned char* image_buffer) {
SetMemoryArea(0, 0, this->width - 1, this->height - 1);
SetMemoryPointer(0, 0);
SendCommand(WRITE_RAM);
/* send the image data */
for (int i = 0; i < this->width / 8 * this->height; i++) {
SendData(pgm_read_byte(&image_buffer[i]));
}
}
/**
* @brief: clear the frame memory with the specified color.
* this won't update the display.
*/
void Epd::ClearFrameMemory(unsigned char color) {
SetMemoryArea(0, 0, this->width - 1, this->height - 1);
SetMemoryPointer(0, 0);
SendCommand(WRITE_RAM);
/* send the color data */
for (int i = 0; i < this->width / 8 * this->height; i++) {
SendData(color);
}
}
/**
* @brief: update the display
* there are 2 memory areas embedded in the e-paper display
* but once this function is called,
* the the next action of SetFrameMemory or ClearFrame will
* set the other memory area.
*/
void Epd::DisplayFrame(void) {
SendCommand(DISPLAY_UPDATE_CONTROL_2);
SendData(0xC7);
SendCommand(MASTER_ACTIVATION);
WaitUntilIdle();
}
/**
* @brief: private function to specify the memory area for data R/W
*/
void Epd::SetMemoryArea(int x_start, int y_start, int x_end, int y_end) {
SendCommand(SET_RAM_X_ADDRESS_START_END_POSITION);
/* x point must be the multiple of 8 or the last 3 bits will be ignored */
SendData((x_start >> 3) & 0xFF);
SendData((x_end >> 3) & 0xFF);
SendCommand(SET_RAM_Y_ADDRESS_START_END_POSITION);
SendData(y_start & 0xFF);
SendData((y_start >> 8) & 0xFF);
SendData(y_end & 0xFF);
SendData((y_end >> 8) & 0xFF);
}
/**
* @brief: private function to specify the start point for data R/W
*/
void Epd::SetMemoryPointer(int x, int y) {
SendCommand(SET_RAM_X_ADDRESS_COUNTER);
/* x point must be the multiple of 8 or the last 3 bits will be ignored */
SendData((x >> 3) & 0xFF);
SendCommand(SET_RAM_Y_ADDRESS_COUNTER);
SendData(y & 0xFF);
SendData((y >> 8) & 0xFF);
WaitUntilIdle();
}
/**
* @brief: After this command is transmitted, the chip would enter the
* deep-sleep mode to save power.
* The deep sleep mode would return to standby by hardware reset.
* You can use Epd::Init() to awaken
*/
void Epd::Sleep() {
SendCommand(DEEP_SLEEP_MODE);
SendData(0x01);
WaitUntilIdle();
DigitalWrite(reset_pin, LOW);
}
const unsigned char lut_full_update[] =
{
0x02, 0x02, 0x01, 0x11, 0x12, 0x12, 0x22, 0x22,
0x66, 0x69, 0x69, 0x59, 0x58, 0x99, 0x99, 0x88,
0x00, 0x00, 0x00, 0x00, 0xF8, 0xB4, 0x13, 0x51,
0x35, 0x51, 0x51, 0x19, 0x01, 0x00
};
const unsigned char lut_partial_update[] =
{
0x10, 0x18, 0x18, 0x08, 0x18, 0x18, 0x08, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x13, 0x14, 0x44, 0x12,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/* END OF FILE */
epdif.cpp
/**
* @filename : epdif.cpp
* @brief : Implements EPD interface functions
* Users have to implement all the functions in epdif.cpp
* @author : Yehui from Waveshare
*
* Copyright (C) Waveshare August 10 2017
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documnetation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "epdif.h"
#include "SPI.h"
EpdIf::EpdIf() {
};
EpdIf::~EpdIf() {
};
void EpdIf::DigitalWrite(int pin, int value) {
digitalWrite(pin, value);
}
int EpdIf::DigitalRead(int pin) {
return digitalRead(pin);
}
void EpdIf::DelayMs(unsigned int delaytime) {
delay(delaytime);
}
void EpdIf::SpiTransfer(unsigned char data) {
digitalWrite(CS_PIN, LOW);
SPI.transfer(data);
digitalWrite(CS_PIN, HIGH);
}
int EpdIf::IfInit(void) {
pinMode(CS_PIN, OUTPUT);
pinMode(RST_PIN, OUTPUT);
pinMode(DC_PIN, OUTPUT);
pinMode(BUSY_PIN, INPUT);
SPI.begin();
SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));
return 0;
}
epdif.h
/**
* @filename : epdif.h
* @brief : Header file of epdif.cpp providing EPD interface functions
* Users have to implement all the functions in epdif.cpp
* @author : Yehui from Waveshare
*
* Copyright (C) Waveshare August 10 2017
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documnetation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS OR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef EPDIF_H
#define EPDIF_H
#include <Arduino.h>
// Pin definition
#define RST_PIN 36
#define DC_PIN 38
#define CS_PIN 39 //EPD-CS, not SRAM-CS as SRAM will not be used on the final product.
#define BUSY_PIN 35
class EpdIf {
public:
EpdIf(void);
~EpdIf(void);
static int IfInit(void);
static void DigitalWrite(int pin, int value);
static int DigitalRead(int pin);
static void DelayMs(unsigned int delaytime);
static void SpiTransfer(unsigned char data);
};
#endif
These along with lv_conf.h below are all the core files that I have modified or required for this to get to where it is now.
Help greatly, greatly appreciated!!
Pictures
Thanks
Yuvraj
