Template:Raspberry Pi Guides for SPI e-Paper

Working With Raspberry Pi

Provide BCM2835, WiringPi, file IO, RPI (Python) library demos.

Hardware connection

When connecting the Raspberry Pi, if the driver board has a 40pin header, you can directly plug it into the 40PIN header of the Raspberry Pi, and pay attention to the pins. If you choose to connect with an 8PIN cable, please refer to the pin correspondence table below
For the 1.02inch e-paper Module, the pin header is used, and the wiring needs to be connected according to the following table

Correspondence between connecting pins of Raspberry Pi

e-Paper	Raspberry Pi
	BCM2835 encoding	Board physical pin number
VCC	3.3V	3.3V
GND	GND	GND
DIN	MOSI	19
CLK	SCLK	23
CS	CE0	24
DC	25	22
RST	17	11
BUSY	24	18

Take the 7.5inch HD e-Paper (B) connected to the e-paper Driver HAT as an example, just plug it directly into the Raspberry Pi:

Enable SPI Interface

• Open the Raspberry Pi terminal and enter the following command in the config interface:

sudo raspi-config
Choose Interfacing Options -> SPI -> Yes Enable SPI interface

Then reboot your Raspberry Pi:

sudo reboot

• Check /boot/config.txt, and you can see 'dtparam=spi=on' was written in.

• To make sure SPI is not occupied, it is recommended to close other drivers' coverage. You can use ls /dev/spi* to check whether SPI is occupied. If the terminal outputs /dev/spidev0.1 and /dev/spidev0.1, SPI is not occupied.

Install Library

PS: When using the system of the Bullseye branch, it is recommended to use "apt" instead of "apt-get"; and the system of the Bullseye branch only supports Python3.

Install BCM2835

#Open the Raspberry Pi terminal and run the following command
wget http://www.airspayce.com/mikem/bcm2835/bcm2835-1.71.tar.gz
tar zxvf bcm2835-1.71.tar.gz
cd bcm2835-1.71/
sudo ./configure && sudo make && sudo make check && sudo make install
# For more information, please refer to the official website: http://www.airspayce.com/mikem/bcm2835/

• Install WiringPi

#Open the Raspberry Pi terminal and run the following command
cd
sudo apt-get install wiringpi
#For Raspberry Pi systems after May 2019 (earlier ones do not need to be executed), an upgrade may be required:
wget https://project-downloads.drogon.net/wiringpi-latest.deb
sudo dpkg -i wiringpi-latest.deb
gpio -v
# Run gpio -v and version 2.52 will appear if there is no installation error

The #Bullseye branch system uses the following commands:
git clone https://github.com/WiringPi/WiringPi
cd WiringPi
./build
gpio -v
# Run gpio -v and version 2.70 will appear if there is no installation error

Install Python Library

#python2
sudo apt-get update
sudo apt-get install python-pip
sudo apt-get install python-pil
sudo apt-get install python-numpy
sudo pip install RPi.GPIO
sudo pip install spidev
#python3
sudo apt-get update
sudo apt-get install python3-pip
sudo apt-get install python3-pil
sudo apt-get install python3-numpy
sudo pip3 install RPi.GPIO
sudo pip3 install spidev

Download Test Demo

Open the terminal of the Raspberry Pi and execute:
Method 1: Download from our official website:

sudo apt-get install p7zip-full
wget  https://www.waveshare.net/w/upload/3/39/E-Paper_code.7z
7z x E-Paper_code.7z -O./e-Paper
cd e-Paper/RaspberryPi_JetsonNano/

Method 2: use Github:

git clone https://github.com/waveshare/e-Paper
cd e-Paper/RaspberryPi_JetsonNano/

Run the Test Demo

Please execute the following commands under RaspberryPi_JetsonNano, otherwise the directory will not be indexed;

C

• Open main.c and choose the corresponding screen.

cd c
sudo nano examples/main.c 

If you are using 2.7inch e-paper, then remove the // in front of the EPD_2IN7_test() function, then press ctrl+c, then press Y and press Enter to save and exit, as shown in the picture: (the picture may not be updated Timely, subject to demo)

1.02inch（128 × 80）：

EPD_1in02d_test()：Example for 1.02inch e-Paper/1.02inch e-Paper Module

1.54inch（1.54inch e-paper c：152 × 152，others：200 × 200）：

EPD_1in54_test()： Example for 1.54inch e-paper V1（Balck/White）: This version was discontinued.
EPD_1in54_V2_test(): Example for 1.54inch e-paper V2（Balck/White): Purchase date later than November 2019 is the V2 version, the current shipping version has the V2 logo on the back.
EPD_1in54b_test()： Example for 1.54inch e-paper B（Black/White/Red). It is currently out of production.
EPD_1in54b_V2_test(): Example for 1.54inch e-Paper B V2 (Black/White/Red). The purchase date later than November 2019 is the V2 version, the current shipping version has the V2 logo on the back;
EPD_1in54c_test()： Example for 1.54inch e-paper C（Black/White/Red）;

1.64inch（168 × 168）

EPD_1in64g_test(): Example for 1.64inch e-paper G (Black/White/Red/Yellow)

2.7inch（264 × 176）

EPD_2in7_test(): Example for 2.7inch e-paper（Black/White）;
EPD_2in7b_test(): Example for 2.7inch e-paper B（Black/White/Red）;
EPD_2in7b_V2_test(): Example for 2.7inch e-paper B V2（Black/White/Red). The purchase date is later than February 2021 is the V2 version, the current shipping version has the V2 logo on the back;

2.9inch (296 × 128)

EPD_2in9_test(): Example for 2.9inch e-paper (Black/White), this version was discontinued.
EPD_2in9_V2_test(): Example for 2.9inch e-paper V2（Black/White）; The purchase date is later than December 2020 is the V2 version, the current shipping version has the V2 logo on the back;
EPD_2in9bc_test(): Example for 2.9inch e-paper B（Balck/White/Red） and 2.9inch e-paper C（Black/White/Yellow）;
EPD_2in9b_V3_test(): Example for 2.9inch e-paper B V3 （Balck/White/Red）; Purchase date later than July 2020 is the V3 version, the current shipping version has the V3 logo on the back;
EPD_2in9d_test(): Example for 2.9inch e-paper D（Black/White）;

2.13inch（2.13inch e-Paper：250 × 122，others：212 × 104）：

EPD_2in13_test(): Example for 2.13inch e-paper V1（Black/White）, this version was discontinued.
EPD_2in13_V2_test(): Example for 2.13inch e-paper V2（Black/White）. The purchase date is later than May 2019, the V2 version is currently discontinued, and the V2 logo is affixed on the back;
EPD_2in13_V3_test(): Example for 2.13inch e-paper V3（Black/White） This is the current version with sticker V3 on the backside (2020-07-29)；
EPD_2in13bc_test()：Example for 2.13inch e-paper B（Black/White/Red）and 2.13inch e-paper C（Blackj/White/Yellow）;
EPD_2in13b_V3_test()：Example for 2.13inch e-paper B V3（Black/White/Red）Purchase date later than April 2020 is the V3 version, the current shipping version has the V3 logo on the back;
EPD_2in13d_test()： Example for 2.13inch e-paper D（Black/White）;

2.66inch (152 × 296)

EPD_2in66_test(): Example for 2.66inch e-Paper (Black/White);
EPD_2in66b_test(): Example for 2.66inch e-Paper B (Black/White/Red);

3inch (400 × 168)

EPD_3in0g_test(): Example for 3inch e-Paper G(Black/White/Red/Yellow);

3.52inch (360 × 240)

EPD_3in52_test(): Example for 3.52inch e-Paper (Black/White);

3.7inch (280 × 480)

EPD_3in7_test(): Example for 3.7inch e-Paper(Black/White);

4.01inch (640 × 400)

EPD_4in01_test(): Example for the 4.01inch e-Paper HAT (F) (Black/White/Green/Blue/Red/Yellow/Orange);

4.2inch（400 × 300）

EPD_4in2_test()： Example for 4.2inch e-paper（Black/White）；
EPD_4in2bc_test()： Example for 4.2inch e-paper B（Black/White/Red）；
EPD_4in2b_V2_test()： Example for 4.2inch e-paper B V2（Black/White/Red）. The purchase date is later than November 2020, it is the V2 version, and the current shipping version has the V2 logo on the back;

5.65inch (600 × 558)

EPD_5in65f_test(): Example for for 5.65inch e-Paper F (Black/White/Green/Blue/Red/Yellow/Orange);

5.83inch（600 × 448）：

EPD_5in83_test()： Example for 5.83inch e-paper（Black/White）, It is currently out of production.
EPD_5in83_V2_test()： Example for 5.83inch e-paper V2（Black/White）, The purchase date is later than December 2020 is the V2 version, the current shipping version, with the V2 logo on the back.
EPD_5in83bc_test()： Example for 5.83inch e-paper B（Black/White/Red）and 5.83inch e-paper C（Black/White/Yellow）;
EPD_5in83b_V2_test()： Example for 5.83inch e-paper B V2（Black/White/Red). The purchase date is later than August 2020 for the V2 version, the current shipping version, with the V2 logo on the back.

7.3inch (800 × 480)

epd_7in3g_test.py: Example for 7inch3 e-paper G (Black/White/Red/Yellow).

7.5inch（V1：640 × 384， V2：800 × 480）：

EPD_7in5_test()： Example for 7.5inch e-paper（Black/White）. The purchase date is earlier than 2019-12-07 as the V1 version, which is currently discontinued.
EPD_7in5bc_test()： For example for 7.5inch e-paper B（Black/White/Red）and 7.5inch e-paper C（Black/White/Yellow）, The purchase date later than 2019-12-07 is the V2 version, and the current shipping version has the V2 logo on the back;
EPD_7in5_V2_test()： Example for 7.5inch e-paper V2（Black/White）. The purchase date of 7.5inch e-paper B is earlier than 2019-12-07, which is the V1 version, which is currently discontinued, and 7.5inch e-paper C is normally available.
EPD_7in5bc_V2_test()： Example for 7.5inch e-paper B V2（Black/White/Red）; The purchase date is later than 2019-12-07 is the V2 version, with the V2 logo on the back; the purchase date is later than March 2021 is the V3 version, the current 7.5inch e-paper B shipping version, with the V3 logo on the back, the same use this program;

7.5inch (880 × 528)

EPD_7in5_HD_test(): Example for 7.5inch e-Paper HD (Black/White);
EPD_7in5b_HD_test(): Example for 7.5inch e-Paper B HD (Black/White/Red);

• Note: The above time is for reference only, please refer to the screen logo for the specific version.
• Recompile and take a few seconds.

Return to the c directory and run the following commands:
make clean
make
sudo ./epd

Python

PS: The system of the Bullseye branch only supports Python3.

Enter the python program directory and run the command ls -al:

cd python/examples
ls -al

You can view the test programs for all screen sizes, classified by size:

1.02inch（128×80）：

epd_1in02_test.py：Example for 1.02inch e-Paper/1.02inch e-Paper Module

1.54inch（1.54inch e-paper c：152×152，others：200×200）：

epd_1in54_test.py： Example for 1.54inch e-paper V1（Balck/White）: This version is stopped production which can be bought before 2019-11-22；
epd_1in54_V2_test.py： Example for 1.54inch e-paper V2（Balck/White): This is the current version which can be bought now (2020-07-29). The e-Paper has V2 sticker on the backside.
epd_1in54b_test.py： Example for 1.54inch e-paper B（Black/White/Red). It is currently out of production.
epd_1in54b_V2_test.py： Example for 1.54inch e-paper B V2 (Black/White/Red). The purchase date is later than April 2020 is the V2 version, the current shipping version has the V2 logo on the back;
epd_1in54c_test.py： Example for 1.54inch e-paper C（Black/White/Red).

1.64inch（168 × 168）

epd_1in64g_test.py: Example for 1.64inch e-paper G (Black/White/Red/Yellow)

2.7inch（264×176）：

epd_2in7_test.py： Example for 2.7inch e-paper（Black/White）;
epd_2in7b_test.py： Example for 2.7inch e-paper B（Black/White/Red）;
epd_2in7b_V2_test.py： Example for 2.7inch e-paper B V2 (Black/White/Red). The purchase date is later than February 2021 is the V2 version, the current shipping version has the V2 logo on the back;

2.9inch（296×128）：

epd_2in9_test.py: Example for 2.9inch e-paper（Black/White）; It is currently out of production.
epd_2in9_V2_test.py: Example for 2.9inch e-paper V2（Black/White）; The purchase date is later than December 2020 is the V2 version, the current shipping version, with the V2 logo on the back.
epd_2in9bc_test.py： Example for 2.9inch e-paper B（Balck/White/Red） and 2.9inch e-paper C（Black/White/Yellow）;
epd_2in9b_V3_test.py： Example for 2.9inch e-paper B V3（Balck/White/Red; The purchase date later than July 2020 is the V3 version, the current shipping version has the V3 logo on the back;
epd_2in9d_test.py： Example for 2.9inch e-paper D（Black/White）;

2.13inch（2.13inch e-Paper：250×122，others：212×104）：

epd_2in13_test.py： Example for 2.13inch e-paper V1（Black/White）, this version is stopped production and it can be bought before 019-05-15;
epd_2in13_V2_test.py： Example for 2.13inch e-paper V2（Black/White） This is the current version with sticker V2 on the backside (2020-07-29)；
epd_2in13_V3_test.py: Example for 2.13inch e-paper V3（Black/White）, The purchase date later than February 2022 is the V3 version, the current shipping version, with the V3 logo on the back.
epd_2in13bc_test.py： Example for 2.13inch e-paper B（Black/White/Red）and 2.13inch e-paper C（Black/White/Yellow）;
epd_2in13b_V3_test.py： Example for 2.13inch e-paper B V3（Black/White/Red）
epd_2in13d_test.py： Example for 2.13inch e-paper D（Black/White）;

2.66inch (152 x 296)

epd_2in66_test.py: Example for 2.66inch e-Paper (Black/White);
epd_2in66b_test.py: Example for 2.66inch e-Paoer (Black/White/Red);

3inch (400 × 168)

EPD_3in0g_test.py: Example for 3inch e-Paper G(Black/White/Red/Yellow);

3.52inch (360 × 240)

EPD_3in52_test.py: Example for 3.52inch e-Paper (Black/White);

3.7inch (280 x 480)

epd_3in7_test.py: Example for 3.7inch e-Paper (Black/White);

4.01inch (640x400)

epd_4in01f_test.py: Example for 4.01inch e-Paper (Seven-color);

4.2inch（400×300）

epd_4in2_test.py： Example for 4.2inch e-paper（Black/White）；
epd_4in2bc_test.py： Example for 4.2inch e-paper B（Black/White/Red）；
epd_4in2b_V2_test.py： Example for 4.2inch e-paper B V2（Black/White/Red). The purchase date is later than November 2020, it is the V2 version, and the current shipping version has the V2 logo on the back;

5.65inch (600x558)

epd_5in65f_test.py: Example for 5.65inch e-Paper F (Seven-color);

5.83inch（600×448）：

epd_5in83_test.py： Example for 5.83inch e-paper（Black/White). It is currently out of production.
epd_5in83_V2_test.py： Example for 5.83inch e-paper V2（Black/White); The purchase date is later than December 2020 is the V2 version, the current shipping version has the V2 logo on the back;
epd_5in83bc_test.py： Example for 5.83inch e-paper B（Black/White/Red）and 5.83inch e-paper C（Black/White/Yellow）;
epd_5in83b_V2_test.py： Example for 5.83inch e-paper B V2（Black/White/Red). The purchase date is later than August 2020 is the V2 version, the current shipping version has the V2 logo on the back;

7.3inch (400 × 168)

epd_7in3g_test.py: Example for 7inch3 e-paper G (Black/White/Red/Yellow).

7.5inch（V1：640×384， V2：800×480）：

epd_7in5_test.py： Example for 7.5inch e-paper（Black/White）, this version is stopped production and it can be bought before 2019-12-07；
epd_7in5_V2_test.py： Example for 7.5inch e-paper V2（Black/White）, This is the current version with V2 sticker on the backside (2020-07-29)
epd_7in5bc_test.py： Example for 7.5inch e-paper B（Black/White/Red）and 7.5inch e-paper C（Black/White/Yellow）, 7.5inch e-paper B V1 version is stopped production and it can be bought before 2019-12-07;
epd_7in5b_V2_test.py： Example for 7.5inch e-paper B V2（Black/White/Red）. The purchase date later than 2019-12-07 is the V2 version, with the V2 logo on the back; the purchase date later than March 2021 is the V3 version, the current 7.5inch e-paper B shipping version, with the V3 logo on the back, the same use this program.

7.5inch (HD 880 x 528)

epd_7in5_HD_test.py: Example for 7.5inch e-Paper HD (Black/White);
epd_7in5b_HD_test.py: Example for 7.5inch e-Paper B HD (Black/White/Red);
Note: The above time is for reference only, please refer to the screen logo for the specific version.
Just run the program corresponding to the screen, the program supports python2/3, take 1.54 V2 as an example:

#python2
sudo python2.7 epd_1in54_V2_test.py
#python3
sudo python3 epd_1in54_V2_test.py

API

RaspberryPi and Jetson nano share a set of programs because they are both embedded systems with strong compatibility.
The program is divided into the underlying hardware interface, the middle layer ink screen driver, and the upper layer application;

C

Bottom Hardware Interface

We have carried out the underlying packaging. Because the hardware platform is different, the internal implementation is different. If you need to know the internal implementation, you can check it in the corresponding directory.
You can see many definitions in DEV_Config.c(.h), in the directory: RaspberryPi_JetsonNano\c\lib\Config.
C language uses two ways to drive: BCM2835 library and WiringPi library
By default, the BCM2835 library is used for operation. If you need to use the WiringPi library to drive, you can open RaspberryPi_JetsonNano\c\Makefile and modify lines 13-14.

• Data type:

#define UBYTE   uint8_t
#define UWORD   uint16_t
#define UDOUBLE uint32_t

• Module initialization and how to exit:

void DEV_Module_Init(void);
void DEV_Module_Exit(void);
Note:
1. Here are some GPIO processing before and after using the ink screen.
2. For the PCB with Rev2.1, the whole module will enter low power consumption after DEV_Module_Exit(), and the power consumption is basically 0 after testing.

• GPIO read and write:

void DEV_Digital_Write(UWORD Pin, UBYTE Value);
UBYTE DEV_Digital_Read(UWORD Pin);

• SPI write data:

void DEV_SPI_WriteByte(UBYTE Value);

EPD Driver

The driver file are saved under RaspberryPi&JetsonNano\c\lib\e-Paper

Open .h to see the following functions

• After the initialization, called when the screen starts working and after exiting sleep mode

//1.54inch e-Paper, 1.54inch e-Paper V2, 2.13inch e-Paper, 2.13inch e-Paper V2, 2.13inch e-Paper (D), 2.9inch e-Paper, 2.9inch e-Paper (D )
void EPD_xxx_Init(UBYTE Mode); // Mode = 0 global refresh initialization, Mode = 1 local refresh initialization
//other models
void EPD_xxx_Init(void);

Where xxx represents the model. If it is 2.13D, the full screen initialization is EPD_2IN13D_Init(0), the partial refresh initialization EPD_2IN13D_Init(1); if it is 1.54 V2, then EPD_1IN54_V2_Init(); if it is 7.5B, it is EPD_7IN5BC_Init(), because 7.5B and 7.5C are common The driver code, but the color displayed is different

• Clear the screen, brush the ink screen to white

void EPD_xxx_Clear(void);

Where xxx represents the ink screen model. If it is 2.13D, then it is EPD_2IN9D_Clear(); if it is 7.5B, it is EPD_7IN5_Clear(), because 7.5B and 7.5C share the driver code, but the color displayed is different

• Transfer a frame of picture data and open the display

//Black and white two-color ink screen
void EPD_xxx_Display(UBYTE *Image);
//Black and white red or black and white yellow ink screen
void EPD_xxx_Display(const UBYTE *blackimage, const UBYTE *ryimage);

Note that the following are special cases:

//For 2.13inch e-paper (D), 2.9inch e-paper (D) two flexible screens, partial refresh
void EPD_2IN13D_DisplayPart(UBYTE *Image);
void EPD_2IN9D_DisplayPart(UBYTE *Image);

//For 1.54inch e-paper V2 and 2.13inch e-paper V2, due to the upgrade of the control chip, for partial refresh, it is necessary to call EPD_xxx_DisplayPartBaseImage to display the static background image, that is, to perform partial refresh based on this image, and then call the dynamic EPD_xxx_DisplayPart ()

void EPD_1IN54_V2_DisplayPartBaseImage(UBYTE *Image);
void EPD_1IN54_V2_DisplayPart(UBYTE *Image);
void EPD_2IN13_V2_DisplayPart(UBYTE *Image);
void EPD_2IN13_V2_DisplayPartBaseImage(UBYTE *Image);

• Enter sleep mode

void EPD_xxx_Sleep(void);

Note that after entering sleep mode, there are only two ways to work again: the first is a hardware reset, and the second is to call the initialization function again.
Where xxx represents the ink screen model. If it is 2.13D, then it is EPD_2IN13D_Sleep(); if it is 7.5B, it is EPD_7IN5BC_Sleep(), because 7.5B and 7.5C share the driver code, but the color displayed is different

GUI functions

GUI files can be found in RaspberryPi&JetsonNano\c\lib\GUI\GUI_Paint.c(.h) directory

The fonts can be found in the RaspberryPi&JetsonNano\c\lib\Fonts directory

Create an image buffer

void Paint_NewImage(UBYTE *image, UWORD Width, UWORD Height, UWORD Rotate, UWORD Color)

• Image: the Image buffer
• Width: width of the image
• Height: Height of the image
• Rotate: Rotate angle
• Color: Color of the image

Select image buffer

void Paint_SelectImage(UBYTE *image)

• The image buffer, it is a pointer of image buffer's first address

Rotate image

This function should be used after Paint_SelectImage()

void Paint_SetRotate(UWORD Rotate)

• Rotate: The angle rotated. It should be ROTATE_0, ROTATE_90, ROTATE_180, ROTATE_270
• Note: For different orientation, the position of the first pixel is different, here we take 1.54inch as example

Mirroring

void Paint_SetMirroring(UBYTE mirror)

• mirror: The type of mirroring. (MIRROR_NONE, MIRROR_HORIZONTAL、MIRROR_VERTICAL、MIRROR_ORIGIN)

Set Pixel

This function is used to set the position and types of the pixel

void Paint_SetPixel(UWORD Xpoint, UWORD Ypoint, UWORD Color)

• Xpoint: The x-axis coordination of pixel
• Ypoint: The y-axis coordination of pixel
• Color: The color of the pixel

Clear

This function is used to clear the e-Paper

void Paint_Clear(UWORD Color)

• Color: The color of the display

Clear window

This function is used to clear a partial area

void Paint_ClearWindows(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend, UWORD Color)

• Xstart: The x-axis coordination of the start point
• Ystart: The y-axis coordination of the start point
• Xend: The x-axis coordination of the end point
• Yend: The y-axis coordination of the end point
• Color: The color of the windows

Draw point

This function is used to draw point.

void Paint_DrawPoint(UWORD Xpoint, UWORD Ypoint, UWORD Color, DOT_PIXEL Dot_Pixel, DOT_STYLE Dot_Style)

• Xpoint: The x-axis coordination of point
• Ypoint: The y-axis coordination of point
• Dot_Pixel: The size of the point

 	 	 typedef enum {
 	 	 	 DOT_PIXEL_1X1  = 1,	// 1 x 1
 	 	 	 DOT_PIXEL_2X2  , 		// 2 X 2
 	 	 	 DOT_PIXEL_3X3  , 	 	// 3 X 3
 	 	 	 DOT_PIXEL_4X4  , 	 	// 4 X 4
 	 	 	 DOT_PIXEL_5X5  , 		// 5 X 5
 	 	 	 DOT_PIXEL_6X6  , 		// 6 X 6
 	 	 	 DOT_PIXEL_7X7  , 		// 7 X 7
 	 	 	 DOT_PIXEL_8X8  , 		// 8 X 8
 	 	} DOT_PIXEL;

• Dot_Style: The style of the point

 	 	typedef enum {
 	 	   DOT_FILL_AROUND  = 1,		
 	 	   DOT_FILL_RIGHTUP,
 	 	} DOT_STYLE;

Drawn Line

void Paint_DrawLine(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend, UWORD Color, LINE_STYLE Line_Style , LINE_STYLE Line_Style)

This function is used to draw a line

• Xstart: The start x-axis coordination of the line
• Ystart: The start y-axis coordination of the line
• Xend: The end x-axis coordination of the line
• Yend: The end y-axis coordination of the line
• Line_width: The width of the line

 	 	typedef enum {
 	 	 	 DOT_PIXEL_1X1  = 1,	// 1 x 1
 	 	 	 DOT_PIXEL_2X2  , 		// 2 X 2
 	 	 	 DOT_PIXEL_3X3  ,		// 3 X 3
 	 	 	 DOT_PIXEL_4X4  ,		// 4 X 4
 	 	 	 DOT_PIXEL_5X5  , 		// 5 X 5
 	 	 	 DOT_PIXEL_6X6  , 		// 6 X 6
 	 	 	 DOT_PIXEL_7X7  , 		// 7 X 7
 	 	 	 DOT_PIXEL_8X8  , 		// 8 X 8
 	 	} DOT_PIXEL;

• Line_style: The style of the line

 	 	typedef enum {
 	 	 	 LINE_STYLE_SOLID = 0,
 	 	 	 LINE_STYLE_DOTTED,
 	 	} LINE_STYLE;

Draw rectangle

Draw a rectangle from (Xstart, Ystart) to (Xend, Yend).

void Paint_DrawRectangle(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend, UWORD Color, DOT_PIXEL Line_width, DRAW_FILL Draw_Fill)

• Xstart: Start coordinate of X-axes of the rectangle
• Ystart: Start coordinate of Y-axes of the rectangle
• Xend: End coordinate of X-end of the rectangle
• Yend: End coordinate of Y-end of the rectangle
• Color: color of the rectangle
• Line_width: The width of edges, 8 sides are available;

 	 	typedef enum {
 	 	 	 DOT_PIXEL_1X1  = 1,	// 1 x 1
 	 	 	 DOT_PIXEL_2X2  , 		// 2 X 2
 	 	 	 DOT_PIXEL_3X3  ,		// 3 X 3
 	 	 	 DOT_PIXEL_4X4  ,		// 4 X 4
 	 	 	 DOT_PIXEL_5X5  , 		// 5 X 5
 	 	 	 DOT_PIXEL_6X6  , 		// 6 X 6
 	 	 	 DOT_PIXEL_7X7  , 		// 7 X 7
 	 	 	 DOT_PIXEL_8X8  , 		// 8 X 8
 	 	} DOT_PIXEL;
 	

• Draw_Fill: set the rectangle full or empty.

typedef enum {
 	DRAW_FILL_EMPTY = 0,
 	DRAW_FILL_FULL,
} DRAW_FILL;

Draw circle

Draw a circle: In the image cache, with (X_Center Y_Center) as the center, draw a circle with a radius of Radius, you can choose the color, the width of the line, whether to fill the inside of the circle

void Paint_DrawCircle(UWORD X_Center, UWORD Y_Center, UWORD Radius, UWORD Color, DOT_PIXEL Line_width, DRAW_FILL Draw_Fill)
parameter:
 X_Center: X coordinate of the center of the circle
 Y_Center: Y coordinate of the center of the circle
 Radius: the radius of the circle
 Color: fill color
 Line_width: the width of the arc, providing 8 default widths
 typedef enum {
                 DOT_PIXEL_1X1 = 1, // 1 x 1
                 DOT_PIXEL_2X2 , // 2 X 2
                 DOT_PIXEL_3X3 , // 3 X 3
                 DOT_PIXEL_4X4 , // 4 X 4
                 DOT_PIXEL_5X5 , // 5 X 5
                 DOT_PIXEL_6X6 , // 6 X 6
                 DOT_PIXEL_7X7 , // 7 X 7
                 DOT_PIXEL_8X8 , // 8 X 8
 } DOT_PIXEL;
 Draw_Fill: Fill, whether to fill the inside of the circle
          typedef enum {
                        DRAW_FILL_EMPTY = 0,
                        DRAW_FILL_FULL,
 } DRAW_FILL;

Draw character (ASCII)

Set(Xstart Ystart) as letf-top point, draw a ASCII character.

void Paint_DrawChar(UWORD Xstart, UWORD Ystart, const char Ascii_Char, sFONT* Font, UWORD Color_Foreground, UWORD Color_Background)

Parameter:

• Xstart: X coordinate of the left-top pixel of character;
• Ystart: Y coordinate of the left-top pixel of character;
• Ascii_Char：Ascii character;
• Font: 5 fonts are available;

  font12：7*12

  font16：11*16

  font20：14*20

  font24：17*24

• Color_Foreground: color of character;
• Color_Background: color of background;

Draw String

Set point (Xstart Ystart) as the left-top pixel, draw a string.

void Paint_DrawString_EN(UWORD Xstart, UWORD Ystart, const char * pString, sFONT* Font, UWORD Color_Foreground, UWORD Color_Background)

Parameters:

• Xstart: X coordinate of left-top pixel of characters;
• Ystart: Y coordinate of left-top pixel of characters;
• pString：Pointer of string
• Font: 5 fonts are available:

  font8：5*8

  font12：7*12

  font16：11*16

  font20：14*20

  font24：17*24

• Color_Foreground: color of string
• Color_Background: color of the background

Draw Chinese characters

this function is used to draw Chinese fonts based ON GB2312 fonts.

void Paint_DrawString_CN(UWORD Xstart, UWORD Ystart, const char * pString, cFONT* font, UWORD Color_Foreground, UWORD Color_Background)

Parameters:

• Xstart: Coordinate of left-top pixel of characters;
• Ystart: Coordinate of left-top pixel of characters;
• pString：Pointer of string;
• Font: GB2312 fonts：

  font12CN：11*21(ascii)，16*21 (Chinese)

  font24CN：24*41(ascii)，32*41 (Chinese)

• Color_Foreground: color of string
• Color_Background: color of the background

Draw number

Draw a string of numbers, (Xstart, Ystart) is the left-top pixel.

void Paint_DrawNum(UWORD Xpoint, UWORD Ypoint, int32_t Nummber, sFONT* Font, UWORD Color_Foreground, UWORD Color_Background)

Parameter:

• Xstart: X coordinate of left-top pixel;
• Ystart: Y coordicate of left-to pixel;
• Nummber: the numbers displayed. the numbers are saved in int format, the maximum is 2147483647;
• Font: 5 fonts are available：

  font8：5*8

  font12：7*12

  font16：11*16

  font20：14*20

  font24：17*24

• Color_Foreground: color of font;
• Color_Background: color of background;

Draw image

Send image data of BMP file to buffer

void Paint_DrawBitMap(const unsigned char* image_buffer)

Parameters:

• image_buffer: adrress of image data in buffer

Read local bmp picture and write it to buffer

Linux platform like Jetson Nano and Raspberry Pi support to directly operate bmp pictures Raspberry Pi & Jetson Nano：RaspberryPi&JetsonNano\c\lib\GUI\GUI_BMPfile.c(.h)

UBYTE GUI_ReadBmp(const char *path, UWORD Xstart, UWORD Ystart)

Parameters:

• path：The path of BMP pictures
• Xstart: X coordination of left-top of picture, default 0;
• Ystart: Y coordination of left-top of picture, default 0;

Testing Code

The first three chapters introduce the classic linux three-layer code structure, here is a little explanation of the user test code
For Raspberry Pi and Jetson Nano, in the directory: RaspberryPi_JetsonNano\c\examples, for all test codes, multiple shields can be made in main.c in this directory;
If you need to run the 7.5inch e-paper test program, you need to remove the 42 line shield

//EPD_5in65f_test();

to

EPD_5in65f_test();

Then compile it again and run

make clean
make
sudo ./epd

Python

For Jetson Nano\Raspberry Pi, based on python2.7 and python3
For python, its calls are not as complicated as C
Raspberry Pi and Jetson Nano: RaspberryPi_JetsonNano\python\lib\

Bottom Interface

The epdconfig.py file encapsulates the underlying interface

• Initialize module and exit handle：

def module_init()
def module_exit()

Note:
1. The functions are used to set GPIP before and after driving e-Paper
2. If the board you have is printed with Rev2.1, module enter low-ultra mode after Module_Exit(). (as we test, the current is about 0 in this mode);

• GPIO Read/Write：

def  digital_write(pin, value)
def  digital_read(pin)

• SPI Write data:

def spi_writebyte(data)

Driver Interface

epdxxx.py (xxx means size, if it is 2.13inch e-paper, it is epd2in13.py, and so on)

• Initailize e-paper: this function should be used at the begining. It can also be used to wake up e-Paper from Sleep mode.

#For 2.13inch e-Paper、2.9inch e-Paper
def init(self, update) #  Choose lut_full_update or lut_partial_update
#Other type
def init(self)

• Clear e-paper: This function is used to clear e-Paper to white;

def Clear(self)
def Clear(self, color) # Some types of e-Paper should use this function to clear screen

• Convert image to arrays

def getbuffer(self, image)

• Transmit one frame of image data and display

#For two-color e-paper
def display(self, image)

#Because that controllers of 2.13inch e-paper are updated, when partial refresh, they should first use displayPartBaseImage() to display static background, then use displayPart() to dynamaticlly display.
def displayPartBaseImage(self, image)
def displayPart(self, image)

• Enter sleep mode

def sleep(self)

Testing Function

epd_xxx_test.py (xxx means dimension)python examples are saved in directory：
Raspberry Pi and Jetson Nano：RaspberryPi&JetsonNano\python\examples\

If the python installed in your OS is python2, you should run examples like below：

sudo python epd_2in13_V2_test.py

If it is python3, the commands should be:

sudo python3 epd_2in13-V2_test.py

Orientation

To rotate the display, you can use transpose function like blackimage = blackimage.transpose(Image.ROTATE_270):

blackimage = blackimage.transpose(Image.ROTATE_270) 
redimage = redimage.transpose(Image.ROTATE_270)
#Support ROTATE_90, ROTATE_180, ROTATE_270

The rotation effect, taking 1.54B as an example, is 0°, 90°, 180°, 270° in sequence

GUI

Python has a powerful PIL library, which can be used directly to drawing figures. Here we use it for drawing

• Install the library firstly

sudo apt-get install python3-pil 

Import the library

from PIL import Image,ImageDraw,ImageFont

Image: library; ImageDraw: drawing function; ImageFont: fonts

• Set image buffer for drawing.

image = Image.new('1', (epd.width, epd.height), 255)  # 255: clear the frame

The first parameter is the depth of color, 1 means 2 grayscale. The second parameter is a tuple of image size. The third parameter is color of the image, 0 is black and 255 is white.

• Create an image object.

draw = ImageDraw.Draw(image)

• Draw rectangle

draw.rectangle((0, 10, 200, 34), fill = 0)

The first parameter is a tuple of coordination. 0, 10 is the top-left point of rectangle, 200, 34) is the right-bottom point. fille = 0 set the filled color to black.

• Draw line

draw.line((16, 60, 56, 60), fill = 0)

The first parameter is a type of coordination, 16, 60 is the begin point, 200, 34 is the end point. fill=0 set the line to black

• Draw circle

draw.arc((90, 60, 150, 120), 0, 360, fill = 0)

This function is used to draw a encircle of a square. The first parameter is a tuple of coordination of the square. the degree of the circle is 0 to 360 °, fille=0 set the circle to black.
If the figure is not square according to the coordination, you will get an ellipse.。

Besides the arc function, you can also use the chord function for drawing solid circle.

draw.chord((90, 130, 150, 190), 0, 360, fill = 0)

The first parameter is the coordination of the enclosing rectangle. The second and third parameters are the beginning and end degrees of the circle. The fourth parameter is the fill color of the circle.

• Character

You can directkt import ImageFont model for drawing characters:

font = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 24)

You can use the fonts of Windows or other fonts which is in ttc format.

To draw English character, you can directly use the fonts; for Chinese character, you need to add a symbol u:

draw.text((8, 12), 'hello world', font = font, fill = 255)
draw.text((8, 36), u'微雪电子', font = font, fill = 0)

The first parameter is a tuple of coordination of character, the second parameter is the font and las one is set the color.

• Read local picture

image = Image.open(os.path.join(picdir, 'lin54.bmp'))

The parameter is the path of picture.

• Other functions.

For more information about the PIL library, you can search online.