nemunaire/waveshareteam-e-Paper
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add the raspberry Pi program: 1.64inch e-Paper (G), 3inch e-Paper (G) and 7.3inch e-Paper (G)

Browse source
This commit is contained in:
SSYYL 2022-07-28 17:44:36 +08:00
parent c2b5d0f72f
commit 8c37291d2b
49 changed files with 3858 additions and 10 deletions
Download patch file Download diff file Expand all files Collapse all files

169
RaspberryPi_JetsonNano/c/examples/EPD_1in64g_test.c Normal file
View file

@ -0,0 +1,169 @@
/*****************************************************************************
* | File : EPD_1in64g_test.c
* | Author : Waveshare team
* | Function : 1.64inch e-paper (G) test demo
* | Info :
*----------------
* | This version: V1.0
* | Date : 2022-07-22
* | Info :
#
# 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 "EPD_Test.h"
#include "EPD_1in64g.h"
#include "time.h"
int EPD_1in64g_test(void)
{
printf("EPD_1IN64G_test Demo\r\n");
if(DEV_Module_Init()!=0){
return -1;
}
printf("e-Paper Init and Clear...\r\n");
EPD_1IN64G_Init();
printf("Black \r\n");
struct timespec start={0,0}, finish={0,0};
clock_gettime(CLOCK_REALTIME, &start);
EPD_1IN64G_Clear(EPD_1IN64G_WHITE); // While
clock_gettime(CLOCK_REALTIME, &finish);
printf("%ld S\r\n", finish.tv_sec-start.tv_sec);
DEV_Delay_ms(2000);
//Create a new image cache
UBYTE *BlackImage;
UWORD Imagesize = ((EPD_1IN64G_WIDTH % 4 == 0)? (EPD_1IN64G_WIDTH / 4 ): (EPD_1IN64G_WIDTH / 4 + 1)) * EPD_1IN64G_HEIGHT;
if((BlackImage = (UBYTE *)malloc(Imagesize)) == NULL) {
printf("Failed to apply for black memory...\r\n");
return -1;
}
printf("Paint_NewImage\r\n");
Paint_NewImage(BlackImage, EPD_1IN64G_WIDTH, EPD_1IN64G_HEIGHT, 0, EPD_1IN64G_WHITE);
Paint_SetScale(4);
#if 1 // show bmp
printf("show BMP-----------------\r\n");
Paint_SelectImage(BlackImage);
GUI_ReadBmp_RGB_4Color("./pic/1.64inch-2.bmp", 0, 0);
EPD_1IN64G_Display(BlackImage);
DEV_Delay_ms(2000);
#endif
#if 1 // Drawing on the image
//1.Select Image
printf("SelectImage:BlackImage\r\n");
Paint_SelectImage(BlackImage);
Paint_Clear(0x55);
// 2.Drawing on the image
printf("Drawing:BlackImage\r\n");
Paint_DrawPoint(10, 80, Red_4Color, DOT_PIXEL_1X1, DOT_STYLE_DFT);
Paint_DrawPoint(10, 90, Yellow_4Color, DOT_PIXEL_2X2, DOT_STYLE_DFT);
Paint_DrawPoint(10, 100, Black_4Color, DOT_PIXEL_3X3, DOT_STYLE_DFT);
Paint_DrawLine(20, 70, 70, 120, Red_4Color, DOT_PIXEL_1X1, LINE_STYLE_SOLID);
Paint_DrawLine(70, 70, 20, 120, Red_4Color, DOT_PIXEL_1X1, LINE_STYLE_SOLID);
Paint_DrawRectangle(20, 70, 70, 120, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_EMPTY);
Paint_DrawRectangle(80, 70, 130, 120, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawCircle(45, 95, 20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_EMPTY);
Paint_DrawCircle(105, 95, 20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawLine(85, 95, 125, 95, Red_4Color, DOT_PIXEL_1X1, LINE_STYLE_DOTTED);
Paint_DrawLine(105, 75, 105, 115, Yellow_4Color, DOT_PIXEL_1X1, LINE_STYLE_DOTTED);
Paint_DrawString_EN(10, 0, "Red, yellow, white and black_4Color", &Font16, Red_4Color, Yellow_4Color);
Paint_DrawString_EN(10, 35, "Four color e-Paper", &Font12, Yellow_4Color, Black_4Color);
Paint_DrawString_CN(10, 125, "΢ѩ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>", &Font24CN, Red_4Color, White_4Color);
Paint_DrawNum(10, 50, 123456, &Font12, Red_4Color, White_4Color);
printf("EPD_Display\r\n");
EPD_1IN64G_Display(BlackImage);
DEV_Delay_ms(3000);
#endif
#if 1 // Drawing on the image
//1.Select Image
printf("SelectImage:BlackImage\r\n");
Paint_SelectImage(BlackImage);
Paint_Clear(0x55);
// 2.Drawing on the image
printf("Drawing:BlackImage\r\n");
Paint_DrawRectangle(1, 1, 168, 55, Red_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(1, 112, 167, 167, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(59, 1, 109, 167, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
printf("EPD_Display\r\n");
EPD_1IN64G_Display(BlackImage);
DEV_Delay_ms(3000);
#endif
#if 1 // Drawing on the image
//1.Select Image
printf("SelectImage:BlackImage\r\n");
Paint_SelectImage(BlackImage);
Paint_Clear(0x55);
int wNumber, lNumber;
wNumber = (EPD_1IN64G_WIDTH/80)==0 ? (EPD_1IN64G_WIDTH/80) : (EPD_1IN64G_WIDTH/80)+1;
lNumber = (EPD_1IN64G_HEIGHT/20)==0 ? (EPD_1IN64G_HEIGHT/20) : (EPD_1IN64G_HEIGHT/20)+1;
// 2.Drawing on the image
printf("Drawing:BlackImage\r\n");
for(int j=0; j<lNumber; j++) {
if(j%2 == 0) {
for(int i=0; i<wNumber; i++) {
Paint_DrawRectangle(1+i*80, 1+j*20, 20+i*80, 20+j*20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(21+i*80, 1+j*20, 40+i*80, 20+j*20, White_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(41+i*80, 1+j*20, 60+i*80, 20+j*20, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(61+i*80, 1+j*20, 80+i*80, 20+j*20, Red_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
}
}
else {
for(int i=0; i<wNumber; i++) {
Paint_DrawRectangle(1+i*80, 1+j*20, 20+i*80, 20+j*20, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(21+i*80, 1+j*20, 40+i*80, 20+j*20, Red_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(41+i*80, 1+j*20, 60+i*80, 20+j*20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(61+i*80, 1+j*20, 80+i*80, 20+j*20, White_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
}
}
}
printf("EPD_Display\r\n");
EPD_1IN64G_Display(BlackImage);
DEV_Delay_ms(3000);
#endif
printf("Clear...\r\n");
EPD_1IN64G_Clear(EPD_1IN64G_WHITE);
printf("Goto Sleep...\r\n");
EPD_1IN64G_Sleep();
free(BlackImage);
BlackImage = NULL;
DEV_Delay_ms(2000);//important, at least 2s
// close 5V
printf("close 5V, Module enters 0 power consumption ...\r\n");
DEV_Module_Exit();
return 0;
}

175
RaspberryPi_JetsonNano/c/examples/EPD_3in0g_test.c Normal file
View file

@ -0,0 +1,175 @@
/*****************************************************************************
* | File : EPD_3in0g_test.c
* | Author : Waveshare team
* | Function : 3inch e-paper (G) test demo
* | Info :
*----------------
* | This version: V1.0
* | Date : 2022-07-15
* | Info :
#
# 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 "EPD_Test.h"
#include "EPD_3in0g.h"
#include "time.h"
int EPD_3in0g_test(void)
{
printf("EPD_3IN0G_test Demo\r\n");
if(DEV_Module_Init()!=0){
return -1;
}
printf("e-Paper Init and Clear...\r\n");
EPD_3IN0G_Init();
printf("Black \r\n");
struct timespec start={0,0}, finish={0,0};
clock_gettime(CLOCK_REALTIME, &start);
EPD_3IN0G_Clear(EPD_3IN0G_WHITE); // White
clock_gettime(CLOCK_REALTIME, &finish);
printf("%ld S\r\n", finish.tv_sec-start.tv_sec);
DEV_Delay_ms(2000);
//Create a new image cache
UBYTE *BlackImage;
UWORD Imagesize = ((EPD_3IN0G_WIDTH % 4 == 0)? (EPD_3IN0G_WIDTH / 4 ): (EPD_3IN0G_WIDTH / 4 + 1)) * EPD_3IN0G_HEIGHT;
if((BlackImage = (UBYTE *)malloc(Imagesize)) == NULL) {
printf("Failed to apply for black memory...\r\n");
return -1;
}
printf("Paint_NewImage\r\n");
Paint_NewImage(BlackImage, EPD_3IN0G_WIDTH, EPD_3IN0G_HEIGHT, 0, EPD_3IN0G_WHITE);
Paint_SetScale(4);
#if 1 // show bmp
printf("show BMP-----------------\r\n");
EPD_3IN0G_Init();
Paint_SelectImage(BlackImage);
GUI_ReadBmp_RGB_4Color("./pic/3inch-3.bmp", 0, 0);
EPD_3IN0G_Display(BlackImage);
DEV_Delay_ms(2000);
#endif
#if 1 // Drawing on the image
//1.Select Image
EPD_3IN0G_Init();
printf("SelectImage:BlackImage\r\n");
Paint_SelectImage(BlackImage);
Paint_Clear(0x55);
// 2.Drawing on the image
printf("Drawing:BlackImage\r\n");
Paint_DrawPoint(10, 80, Red_4Color, DOT_PIXEL_1X1, DOT_STYLE_DFT);
Paint_DrawPoint(10, 90, Yellow_4Color, DOT_PIXEL_2X2, DOT_STYLE_DFT);
Paint_DrawPoint(10, 100, Black_4Color, DOT_PIXEL_3X3, DOT_STYLE_DFT);
Paint_DrawLine(20, 70, 70, 120, Red_4Color, DOT_PIXEL_1X1, LINE_STYLE_SOLID);
Paint_DrawLine(70, 70, 20, 120, Red_4Color, DOT_PIXEL_1X1, LINE_STYLE_SOLID);
Paint_DrawRectangle(20, 70, 70, 120, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_EMPTY);
Paint_DrawRectangle(80, 70, 130, 120, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawCircle(45, 95, 20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_EMPTY);
Paint_DrawCircle(105, 95, 20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawLine(85, 95, 125, 95, Red_4Color, DOT_PIXEL_1X1, LINE_STYLE_DOTTED);
Paint_DrawLine(105, 75, 105, 115, Yellow_4Color, DOT_PIXEL_1X1, LINE_STYLE_DOTTED);
Paint_DrawString_EN(10, 0, "Red, yellow, white and black", &Font16, Red_4Color, Yellow_4Color);
Paint_DrawString_EN(10, 35, "Four color e-Paper", &Font12, Yellow_4Color, Black_4Color);
Paint_DrawString_CN(10, 125, "΢ѩ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>", &Font24CN, Red_4Color, White_4Color);
Paint_DrawNum(10, 50, 123456, &Font12, Red_4Color, White_4Color);
printf("EPD_Display\r\n");
EPD_3IN0G_Display(BlackImage);
DEV_Delay_ms(3000);
#endif
#if 1 // Drawing on the image
//1.Select Image
EPD_3IN0G_Init();
printf("SelectImage:BlackImage\r\n");
Paint_SelectImage(BlackImage);
Paint_Clear(0x55);
// 2.Drawing on the image
printf("Drawing:BlackImage\r\n");
Paint_DrawRectangle(1, 1, 167, 86, Red_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(1, 314, 167, 399, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(59, 1, 109, 399, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
printf("EPD_Display\r\n");
EPD_3IN0G_Display(BlackImage);
DEV_Delay_ms(3000);
#endif
#if 1 // Drawing on the image
//1.Select Image
EPD_3IN0G_Init();
printf("SelectImage:BlackImage\r\n");
Paint_SelectImage(BlackImage);
Paint_Clear(0x55);
int wNumber, lNumber;
wNumber = (EPD_3IN0G_WIDTH/80)==0 ? (EPD_3IN0G_WIDTH/80) : (EPD_3IN0G_WIDTH/80)+1;
lNumber = (EPD_3IN0G_HEIGHT/20)==0 ? (EPD_3IN0G_HEIGHT/20) : (EPD_3IN0G_HEIGHT/20)+1;
// 2.Drawing on the image
printf("Drawing:BlackImage\r\n");
for(int j=0; j<lNumber; j++) {
if(j%2 == 0) {
for(int i=0; i<wNumber; i++) {
Paint_DrawRectangle(1+i*80, 1+j*20, 20+i*80, 20+j*20, Red_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(21+i*80, 1+j*20, 40+i*80, 20+j*20, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(41+i*80, 1+j*20, 60+i*80, 20+j*20, White_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(61+i*80, 1+j*20, 80+i*80, 20+j*20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
}
}
else {
for(int i=0; i<wNumber; i++) {
Paint_DrawRectangle(1+i*80, 1+j*20, 20+i*80, 20+j*20, White_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(21+i*80, 1+j*20, 40+i*80, 20+j*20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(41+i*80, 1+j*20, 60+i*80, 20+j*20, Red_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(61+i*80, 1+j*20, 80+i*80, 20+j*20, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
}
}
}
printf("EPD_Display\r\n");
EPD_3IN0G_Display(BlackImage);
DEV_Delay_ms(3000);
#endif
EPD_3IN0G_Init();
printf("Clear...\r\n");
EPD_3IN0G_Clear(EPD_3IN0G_WHITE);
printf("Goto Sleep...\r\n");
EPD_3IN0G_Sleep();
free(BlackImage);
BlackImage = NULL;
DEV_Delay_ms(2000);//important, at least 2s
// close 5V
printf("close 5V, Module enters 0 power consumption ...\r\n");
DEV_Module_Exit();
return 0;
}

151
RaspberryPi_JetsonNano/c/examples/EPD_3in52_test.c Normal file
View file

@ -0,0 +1,151 @@
/*****************************************************************************
* | File : EPD_3IN52_test.c
* | Author : Waveshare team
* | Function : 3.52inch e-paper test demo
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-07-16
* | Info :
#
# 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 "EPD_Test.h"
#include "EPD_3in52.h"
#include <time.h>
int EPD_3in52_test(void)
{
printf("EPD_3IN52_test Demo\r\n");
if(DEV_Module_Init()!=0){
return -1;
}
printf("e-Paper Init and Clear...\r\n");
EPD_3IN52_Init();
struct timespec start={0,0}, finish={0,0};
clock_gettime(CLOCK_REALTIME,&start);
EPD_3IN52_display_NUM(EPD_3IN52_WHITE);
EPD_3IN52_lut_GC();
EPD_3IN52_refresh();
clock_gettime(CLOCK_REALTIME,&finish);
printf("%ld S\r\n",finish.tv_sec-start.tv_sec);
EPD_3IN52_SendCommand(0x50);
EPD_3IN52_SendData(0x17);
DEV_Delay_ms(500);
//Create a new image cache
UBYTE *BlackImage;
UWORD Imagesize = ((EPD_3IN52_WIDTH % 8 == 0)? (EPD_3IN52_WIDTH / 8 ): (EPD_3IN52_WIDTH / 8 + 1)) * EPD_3IN52_HEIGHT;
if((BlackImage = (UBYTE *)malloc(Imagesize)) == NULL) {
printf("Failed to apply for black memory...\r\n");
return -1;
}
printf("Paint_NewImage\r\n");
Paint_NewImage(BlackImage, EPD_3IN52_WIDTH, EPD_3IN52_HEIGHT, 270, WHITE);
Paint_Clear(WHITE);
#if 1 // GC waveform refresh
Paint_SelectImage(BlackImage);
Paint_Clear(WHITE);
GUI_ReadBmp("./pic/3in52-1.bmp", 0, 0);
EPD_3IN52_display(BlackImage);
EPD_3IN52_lut_GC();
EPD_3IN52_refresh();
DEV_Delay_ms(2000);
Paint_Clear(WHITE);
GUI_ReadBmp("./pic/3in52-2.bmp", 0, 0);
EPD_3IN52_display(BlackImage);
EPD_3IN52_lut_GC();
EPD_3IN52_refresh();
DEV_Delay_ms(2000);
#endif
#if 0 //DU waveform refresh
printf("Quick refresh is supported, but the refresh effect is not good, but it is not recommended\r\n");
Paint_SelectImage(BlackImage);
Paint_Clear(WHITE);
GUI_ReadBmp("./pic/3in52-3.bmp", 0, 0);
EPD_3IN52_display(BlackImage);
EPD_3IN52_lut_DU();
EPD_3IN52_refresh();
DEV_Delay_ms(2000);
Paint_Clear(WHITE);
GUI_ReadBmp("./pic/3in52-4.bmp", 0, 0);
EPD_3IN52_display(BlackImage);
EPD_3IN52_lut_DU();
EPD_3IN52_refresh();
DEV_Delay_ms(2000);
#endif
#if 1
printf("SelectImage:BlackImage\r\n");
Paint_SelectImage(BlackImage);
Paint_Clear(WHITE);
printf("Drawing:BlackImage\r\n");
Paint_DrawPoint(10, 80, BLACK, DOT_PIXEL_1X1, DOT_STYLE_DFT);
Paint_DrawPoint(10, 90, BLACK, DOT_PIXEL_2X2, DOT_STYLE_DFT);
Paint_DrawPoint(10, 100, BLACK, DOT_PIXEL_3X3, DOT_STYLE_DFT);
Paint_DrawLine(20, 70, 70, 120, BLACK, DOT_PIXEL_1X1, LINE_STYLE_SOLID);
Paint_DrawLine(70, 70, 20, 120, BLACK, DOT_PIXEL_1X1, LINE_STYLE_SOLID);
Paint_DrawRectangle(20, 70, 70, 120, BLACK, DOT_PIXEL_1X1, DRAW_FILL_EMPTY);
Paint_DrawRectangle(80, 70, 130, 120, BLACK, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawCircle(45, 95, 20, BLACK, DOT_PIXEL_1X1, DRAW_FILL_EMPTY);
Paint_DrawCircle(105, 95, 20, WHITE, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawLine(85, 95, 125, 95, BLACK, DOT_PIXEL_1X1, LINE_STYLE_DOTTED);
Paint_DrawLine(105, 75, 105, 115, BLACK, DOT_PIXEL_1X1, LINE_STYLE_DOTTED);
Paint_DrawString_EN(10, 0, "waveshare", &Font16, BLACK, WHITE);
Paint_DrawString_EN(10, 20, "hello world", &Font12, WHITE, BLACK);
Paint_DrawNum(10, 33, 123456789, &Font12, BLACK, WHITE);
Paint_DrawNum(10, 50, 987654321, &Font16, WHITE, BLACK);
printf("EPD_Display\r\n");
EPD_3IN52_display(BlackImage);
EPD_3IN52_lut_GC();
EPD_3IN52_refresh();
DEV_Delay_ms(2000);
#endif
printf("Clear...\r\n");
EPD_3IN52_Clear();
// Sleep & close 5V
printf("Goto Sleep...\r\n");
EPD_3IN52_sleep();
free(BlackImage);
BlackImage = NULL;
DEV_Delay_ms(2000);//important, at least 2s
printf("close 5V, Module enters 0 power consumption ...\r\n");
DEV_Module_Exit();
return 0;
}

178
RaspberryPi_JetsonNano/c/examples/EPD_7in3g_test.c Normal file
View file

@ -0,0 +1,178 @@
/*****************************************************************************
* | File : EPD_7in3g_test.c
* | Author : Waveshare team
* | Function : 7.3inch e-paper (G) test demo
* | Info :
*----------------
* | This version: V1.0
* | Date : 2022-07-22
* | Info :
#
# 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 "EPD_Test.h"
#include "EPD_7in3g.h"
#include "time.h"
int EPD_7in3g_test(void)
{
printf("EPD_7IN3G_test Demo\r\n");
if(DEV_Module_Init()!=0){
return -1;
}
printf("e-Paper Init and Clear...\r\n");
EPD_7IN3G_Init();
printf("Black \r\n");
struct timespec start={0,0}, finish={0,0};
clock_gettime(CLOCK_REALTIME, &start);
EPD_7IN3G_Clear(EPD_7IN3G_WHITE); // WHITE
clock_gettime(CLOCK_REALTIME, &finish);
printf("%ld S\r\n", finish.tv_sec-start.tv_sec);
DEV_Delay_ms(2000);
//Create a new image cache
UBYTE *BlackImage;
UDOUBLE Imagesize = ((EPD_7IN3G_WIDTH % 4 == 0)? (EPD_7IN3G_WIDTH / 4 ): (EPD_7IN3G_WIDTH / 4 + 1)) * EPD_7IN3G_HEIGHT;
if((BlackImage = (UBYTE *)malloc(Imagesize)) == NULL) {
printf("Failed to apply for black memory...\r\n");
return -1;
}
printf("Paint_NewImage\r\n");
Paint_NewImage(BlackImage, EPD_7IN3G_WIDTH, EPD_7IN3G_HEIGHT, 0, EPD_7IN3G_WHITE);
Paint_SetScale(4);
#if 1 // show bmp
printf("show BMP-----------------\r\n");
Paint_SelectImage(BlackImage);
GUI_ReadBmp_RGB_4Color("./pic/7.3inch-1.bmp", 0, 0);
EPD_7IN3G_Display(BlackImage);
DEV_Delay_ms(2000);
#endif
#if 1 // Drawing on the image
//1.Select Image
printf("SelectImage:BlackImage\r\n");
Paint_SelectImage(BlackImage);
Paint_Clear(0x55);
// 2.Drawing on the image
printf("Drawing:BlackImage\r\n");
Paint_DrawPoint(10, 80, Red_4Color, DOT_PIXEL_1X1, DOT_STYLE_DFT);
Paint_DrawPoint(10, 90, Yellow_4Color, DOT_PIXEL_2X2, DOT_STYLE_DFT);
Paint_DrawPoint(10, 100, Black_4Color, DOT_PIXEL_3X3, DOT_STYLE_DFT);
Paint_DrawLine(20, 70, 70, 120, Red_4Color, DOT_PIXEL_1X1, LINE_STYLE_SOLID);
Paint_DrawLine(70, 70, 20, 120, Red_4Color, DOT_PIXEL_1X1, LINE_STYLE_SOLID);
Paint_DrawRectangle(20, 70, 70, 120, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_EMPTY);
Paint_DrawRectangle(80, 70, 130, 120, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawCircle(45, 95, 20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_EMPTY);
Paint_DrawCircle(105, 95, 20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawLine(85, 95, 125, 95, Red_4Color, DOT_PIXEL_1X1, LINE_STYLE_DOTTED);
Paint_DrawLine(105, 75, 105, 115, Yellow_4Color, DOT_PIXEL_1X1, LINE_STYLE_DOTTED);
Paint_DrawString_EN(10, 0, "Red, yellow, white and black", &Font16, Red_4Color, Yellow_4Color);
Paint_DrawString_EN(10, 35, "Four color e-Paper", &Font12, Yellow_4Color, Black_4Color);
Paint_DrawString_CN(10, 125, "΢ѩ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>", &Font24CN, Red_4Color, White_4Color);
Paint_DrawNum(10, 50, 123456, &Font12, Red_4Color, White_4Color);
printf("EPD_Display\r\n");
EPD_7IN3G_Display(BlackImage);
DEV_Delay_ms(3000);
#endif
#if 1 // Drawing on the image
//1.Select Image
printf("SelectImage:BlackImage\r\n");
Paint_SelectImage(BlackImage);
Paint_Clear(0x55);
// 2.Drawing on the image
printf("Drawing:BlackImage\r\n");
// Paint_DrawRectangle(1, 1, 121, 368, Red_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
// Paint_DrawRectangle(392, 1, 512, 368, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
// Paint_DrawRectangle(1, 112, 512, 256, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
UBYTE iWidth = EPD_7IN3G_WIDTH/8;
UBYTE iHeight = EPD_7IN3G_HEIGHT/8;
for(UBYTE i=0; i<8; i++) {
if(i%2 == 0)
Paint_DrawRectangle(1, 1+(i*iHeight), 800, (i+1)*iHeight, Red_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
else
Paint_DrawRectangle(1+(i*iWidth), 1, (i+1)*iWidth, 480, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
}
printf("EPD_Display\r\n");
EPD_7IN3G_Display(BlackImage);
DEV_Delay_ms(3000);
#endif
#if 1 // Drawing on the image
//1.Select Image
printf("SelectImage:BlackImage\r\n");
Paint_SelectImage(BlackImage);
Paint_Clear(0x55);
int wNumber, lNumber;
wNumber = (EPD_7IN3G_WIDTH/80)==0 ? (EPD_7IN3G_WIDTH/80) : (EPD_7IN3G_WIDTH/80)+1;
lNumber = (EPD_7IN3G_HEIGHT/20)==0 ? (EPD_7IN3G_HEIGHT/20) : (EPD_7IN3G_HEIGHT/20)+1;
// 2.Drawing on the image
printf("Drawing:BlackImage\r\n");
for(int j=0; j<lNumber; j++) {
if(j%2 == 0) {
for(int i=0; i<wNumber; i++) {
Paint_DrawRectangle(1+i*80, 1+j*20, 20+i*80, 20+j*20, Red_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(21+i*80, 1+j*20, 40+i*80, 20+j*20, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(41+i*80, 1+j*20, 60+i*80, 20+j*20, White_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(61+i*80, 1+j*20, 80+i*80, 20+j*20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
}
}
else {
for(int i=0; i<wNumber; i++) {
Paint_DrawRectangle(1+i*80, 1+j*20, 20+i*80, 20+j*20, White_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(21+i*80, 1+j*20, 40+i*80, 20+j*20, Black_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(41+i*80, 1+j*20, 60+i*80, 20+j*20, Red_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawRectangle(61+i*80, 1+j*20, 80+i*80, 20+j*20, Yellow_4Color, DOT_PIXEL_1X1, DRAW_FILL_FULL);
}
}
}
printf("EPD_Display\r\n");
EPD_7IN3G_Display(BlackImage);
DEV_Delay_ms(3000);
#endif
printf("Clear...\r\n");
EPD_7IN3G_Clear(EPD_7IN3G_WHITE);
printf("Goto Sleep...\r\n");
EPD_7IN3G_Sleep();
free(BlackImage);
BlackImage = NULL;
DEV_Delay_ms(2000);//important, at least 2s
// close 5V
printf("close 5V, Module enters 0 power consumption ...\r\n");
DEV_Module_Exit();
return 0;
}

10
RaspberryPi_JetsonNano/c/examples/EPD_Test.h
View file

@ -4,8 +4,8 @@
* | Function : e-Paper test Demo
* | Info :
*----------------
* | This version: V1.0
* | Date : 2019-06-11
* | This version: V1.1
* | Date : 2022-07-28
* | Info :
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
@ -37,6 +37,10 @@
#include "Debug.h"
#include <stdlib.h> // malloc() free()
int EPD_1in64g_test(void);
int EPD_3in0g_test(void);
int EPD_7in3g_test(void);
int EPD_1in54_DES_test(void);
int EPD_2in13_DES_test(void);
int EPD_2in9_DES_test(void);
@ -70,6 +74,8 @@ int EPD_2in13b_V3_test(void);
int EPD_2in13b_V4_test(void);
int EPD_2in13d_test(void);
int EPD_3in52_test(void);
int EPD_3in7_test(void);
int EPD_4in01f_test(void);

5
RaspberryPi_JetsonNano/c/examples/main.c
View file

@ -16,6 +16,10 @@ int main(void)
// Exception handling:ctrl + c
signal(SIGINT, Handler);
// EPD_1in64g_test();
// EPD_3in0g_test();
// EPD_7in3g_test();
// EPD_1in54_DES_test();
// EPD_2in13_DES_test();
// EPD_2in9_DES_test();
@ -50,6 +54,7 @@ int main(void)
// EPD_2in13b_V4_test();
// EPD_2in13d_test();
// EPD_3in52_test();
// EPD_3in7_test();
// EPD_4in01f_test();

78
RaspberryPi_JetsonNano/c/lib/GUI/GUI_BMPfile.c
View file

@ -6,10 +6,12 @@
* Used to shield the underlying layers of each master
* and enhance portability
*----------------
* | This version: V2.2
* | Date : 2020-07-08
* | This version: V2.3
* | Date : 2022-07-27
* | Info :
* -----------------------------------------------------------------------------
* V2.3(2022-07-27):
* 1.Add GUI_ReadBmp_RGB_4Color()
* V2.2(2020-07-08):
* 1.Add GUI_ReadBmp_RGB_7Color()
* V2.1(2019-10-10):
@ -283,4 +285,76 @@ UBYTE GUI_ReadBmp_RGB_7Color(const char *path, UWORD Xstart, UWORD Ystart)
return 0;
}
UBYTE GUI_ReadBmp_RGB_4Color(const char *path, UWORD Xstart, UWORD Ystart)
{
FILE *fp; //Define a file pointer
BMPFILEHEADER bmpFileHeader; //Define a bmp file header structure
BMPINFOHEADER bmpInfoHeader; //Define a bmp info header structure
// Binary file open
if((fp = fopen(path, "rb")) == NULL) {
Debug("Cann't open the file!\n");
exit(0);
}
// Set the file pointer from the beginning
fseek(fp, 0, SEEK_SET);
fread(&bmpFileHeader, sizeof(BMPFILEHEADER), 1, fp); //sizeof(BMPFILEHEADER) must be 14
fread(&bmpInfoHeader, sizeof(BMPINFOHEADER), 1, fp); //sizeof(BMPFILEHEADER) must be 50
printf("pixel = %d * %d\r\n", bmpInfoHeader.biWidth, bmpInfoHeader.biHeight);
UDOUBLE Image_Byte = bmpInfoHeader.biWidth * bmpInfoHeader.biHeight * 3;
UBYTE Image[Image_Byte];
memset(Image, 0xFF, Image_Byte);
// Determine if it is a monochrome bitmap
int readbyte = bmpInfoHeader.biBitCount;
if(readbyte != 24){
Debug("Bmp image is not 24 bitmap!\n");
exit(0);
}
// Read image data into the cache
UWORD x, y;
UBYTE Rdata[3];
fseek(fp, bmpFileHeader.bOffset, SEEK_SET);
for(y = 0; y < bmpInfoHeader.biHeight; y++) {//Total display column
for(x = 0; x < bmpInfoHeader.biWidth ; x++) {//Show a line in the line
if(fread((char *)Rdata, 1, 1, fp) != 1) {
perror("get bmpdata:\r\n");
break;
}
if(fread((char *)Rdata+1, 1, 1, fp) != 1) {
perror("get bmpdata:\r\n");
break;
}
if(fread((char *)Rdata+2, 1, 1, fp) != 1) {
perror("get bmpdata:\r\n");
break;
}
if(Rdata[0] < 128 && Rdata[1] < 128 && Rdata[2] < 128){
Image[x+(y* bmpInfoHeader.biWidth )] = 0;//Black
}else if(Rdata[0] > 127 && Rdata[1] > 127 && Rdata[2] > 127){
Image[x+(y* bmpInfoHeader.biWidth )] = 1;//White
}else if(Rdata[0] < 128 && Rdata[1] > 127 && Rdata[2] > 127){
Image[x+(y* bmpInfoHeader.biWidth )] = 2;//Yellow
}else if(Rdata[0] < 128 && Rdata[1] < 128 && Rdata[2] > 127){
Image[x+(y* bmpInfoHeader.biWidth )] = 3;//Red
}
}
}
fclose(fp);
// Refresh the image to the display buffer based on the displayed orientation
for(y = 0; y < bmpInfoHeader.biHeight; y++) {
for(x = 0; x < bmpInfoHeader.biWidth; x++) {
if(x > Paint.Width || y > Paint.Height) {
break;
}
Paint_SetPixel(Xstart + x, Ystart + y, Image[bmpInfoHeader.biHeight * bmpInfoHeader.biWidth - 1 -(bmpInfoHeader.biWidth-x-1+(y* bmpInfoHeader.biWidth))]);
}
}
return 0;
}

7
RaspberryPi_JetsonNano/c/lib/GUI/GUI_BMPfile.h
View file

@ -6,10 +6,12 @@
* Used to shield the underlying layers of each master
* and enhance portability
*----------------
* | This version: V2.2
* | Date : 2020-07-08
* | This version: V2.3
* | Date : 2020-07-27
* | Info :
* -----------------------------------------------------------------------------
* V2.3(2022-07-27):
* 1.Add GUI_ReadBmp_RGB_4Color()
* V2.2(2020-07-08):
* 1.Add GUI_ReadBmp_RGB_7Color()
* V2.1(2019-10-10):
@ -85,5 +87,6 @@ typedef struct RGB_QUAD {
UBYTE GUI_ReadBmp(const char *path, UWORD Xstart, UWORD Ystart);
UBYTE GUI_ReadBmp_4Gray(const char *path, UWORD Xstart, UWORD Ystart);
UBYTE GUI_ReadBmp_RGB_4Color(const char *path, UWORD Xstart, UWORD Ystart);
UBYTE GUI_ReadBmp_RGB_7Color(const char *path, UWORD Xstart, UWORD Ystart);
#endif

8
RaspberryPi_JetsonNano/c/lib/GUI/GUI_Paint.h
View file

@ -126,6 +126,14 @@ typedef enum {
#define GRAY2 0x02
#define GRAY3 0x01 //gray
#define GRAY4 0x00 //white
//colour
#define Black_4Color 0x00
#define White_4Color 0x01
#define Yellow_4Color 0x02
#define Red_4Color 0x03
/**
* The size of the point
**/

238
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in64g.c Normal file
View file

@ -0,0 +1,238 @@
/*****************************************************************************
* | File : EPD_1in64_g.c
* | Author : Waveshare team
* | Function : 1.64inch e-paper (G)
* | Info :
*----------------
* | This version: V1.0
* | Date : 2022-07-22
* | Info :
* -----------------------------------------------------------------------------
# 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 "EPD_1in64g.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_1IN64G_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(20);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(1);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(20);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_1IN64G_SendCommand(UBYTE Reg)
{
DEV_Digital_Write(EPD_DC_PIN, 0);
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_SPI_WriteByte(Reg);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : send data
parameter:
Data : Write data
******************************************************************************/
static void EPD_1IN64G_SendData(UBYTE Data)
{
DEV_Digital_Write(EPD_DC_PIN, 1);
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_SPI_WriteByte(Data);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : Wait until the busy_pin goes LOW
parameter:
******************************************************************************/
static void EPD_1IN64G_ReadBusyH(void)
{
Debug("e-Paper busy H\r\n");
while(!DEV_Digital_Read(EPD_BUSY_PIN)) { //LOW: idle, HIGH: busy
DEV_Delay_ms(5);
}
Debug("e-Paper busy H release\r\n");
}
static void EPD_1IN64G_ReadBusyL(void)
{
Debug("e-Paper busy L\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN)) { //LOW: idle, HIGH: busy
DEV_Delay_ms(5);
}
Debug("e-Paper busy L release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_1IN64G_TurnOnDisplay(void)
{
EPD_1IN64G_SendCommand(0x12); // DISPLAY_REFRESH
EPD_1IN64G_SendData(0x01);
EPD_1IN64G_ReadBusyH();
EPD_1IN64G_SendCommand(0x02); // POWER_OFF
EPD_1IN64G_SendData(0X00);
EPD_1IN64G_ReadBusyH();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_1IN64G_Init(void)
{
EPD_1IN64G_Reset();
EPD_1IN64G_SendCommand(0x66);
EPD_1IN64G_SendData(0x49);
EPD_1IN64G_SendData(0x55);
EPD_1IN64G_SendData(0x13);
EPD_1IN64G_SendData(0x5D);
EPD_1IN64G_SendCommand(0x66);
EPD_1IN64G_SendData(0x49);
EPD_1IN64G_SendData(0x55);
EPD_1IN64G_SendCommand(0xB0);
EPD_1IN64G_SendData(0x03);//1 boost 20211113
EPD_1IN64G_SendCommand(0x00);
EPD_1IN64G_SendData(0x4F);
EPD_1IN64G_SendData(0x6B);
EPD_1IN64G_SendCommand(0x03);
EPD_1IN64G_SendData(0x00);
EPD_1IN64G_SendCommand(0xF0);
EPD_1IN64G_SendData(0xF6);
EPD_1IN64G_SendData(0x0D);
EPD_1IN64G_SendData(0x00);
EPD_1IN64G_SendData(0x00);
EPD_1IN64G_SendData(0x00);
//20220303
EPD_1IN64G_SendCommand(0x06);
EPD_1IN64G_SendData(0xCF);
EPD_1IN64G_SendData(0xDF);
EPD_1IN64G_SendData(0x0F);
EPD_1IN64G_SendCommand(0x41);
EPD_1IN64G_SendData(0x00);
EPD_1IN64G_SendCommand(0x50);
EPD_1IN64G_SendData(0x30);
EPD_1IN64G_SendCommand(0x60);
EPD_1IN64G_SendData(0x0C);
EPD_1IN64G_SendData(0x05);
EPD_1IN64G_SendCommand(0x61);
EPD_1IN64G_SendData(0xA8);
EPD_1IN64G_SendData(0x00);
EPD_1IN64G_SendData(0xA8);
EPD_1IN64G_SendCommand(0x84);
EPD_1IN64G_SendData(0x01);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_1IN64G_Clear(UBYTE color)
{
UWORD Width, Height;
Width = (EPD_1IN64G_WIDTH % 4 == 0)? (EPD_1IN64G_WIDTH / 4 ): (EPD_1IN64G_WIDTH / 4 + 1);
Height = EPD_1IN64G_HEIGHT;
EPD_1IN64G_SendCommand(0x68);
EPD_1IN64G_SendData(0x01);
EPD_1IN64G_SendCommand(0x04);
EPD_1IN64G_ReadBusyH();
EPD_1IN64G_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
for(UBYTE k = 0; k < 4; k++) {
EPD_1IN64G_SendData(color);
}
}
}
EPD_1IN64G_SendCommand(0x68);
EPD_1IN64G_SendData(0x00);
EPD_1IN64G_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_1IN64G_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_1IN64G_WIDTH % 4 == 0)? (EPD_1IN64G_WIDTH / 4 ): (EPD_1IN64G_WIDTH / 4 + 1);
Height = EPD_1IN64G_HEIGHT;
EPD_1IN64G_SendCommand(0x68);
EPD_1IN64G_SendData(0x01);
EPD_1IN64G_SendCommand(0x04);
EPD_1IN64G_ReadBusyH();
EPD_1IN64G_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_1IN64G_SendData(Image[i + j * Width]);
}
}
EPD_1IN64G_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_1IN64G_Sleep(void)
{
EPD_1IN64G_SendCommand(0x02); // POWER_OFF
EPD_1IN64G_SendData(0X00);
EPD_1IN64G_SendCommand(0x07); // DEEP_SLEEP
EPD_1IN64G_SendData(0XA5);
}

32
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in64g.h Normal file
View file

@ -0,0 +1,32 @@
/*****************************************************************************
* | File : EPD_1in64g.h
* | Author : Waveshare team
* | Function : 1.64inch e-paper(G)
* | Info :
*----------------
* | This version: V1.0
* | Date : 2022-07-14
* | Info :
* -----------------------------------------------------------------------------
******************************************************************************/
#ifndef __EPD_1IN64G_H_
#define __EPD_1IN64G_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_1IN64G_WIDTH 168
#define EPD_1IN64G_HEIGHT 168
//colour
#define EPD_1IN64G_BLACK 0x00
#define EPD_1IN64G_WHITE 0x55
#define EPD_1IN64G_YELLOW 0xAA
#define EPD_1IN64G_RED 0xFF
void EPD_1IN64G_Init(void);
void EPD_1IN64G_Clear(UBYTE color);
void EPD_1IN64G_Display(UBYTE *Image);
void EPD_1IN64G_Sleep(void);
#endif

220
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_3in0g.c Normal file
View file

@ -0,0 +1,220 @@
/*****************************************************************************
* | File : EPD_3in0_g.c
* | Author : Waveshare team
* | Function : 3inch e-paper (G)
* | Info :
*----------------
* | This version: V1.0
* | Date : 2022-07-15
* | Info :
* -----------------------------------------------------------------------------
#
# 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 "EPD_3in0g.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_3IN0G_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(20);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(2);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(20);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_3IN0G_SendCommand(UBYTE Reg)
{
DEV_Digital_Write(EPD_DC_PIN, 0);
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_SPI_WriteByte(Reg);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : send data
parameter:
Data : Write data
******************************************************************************/
static void EPD_3IN0G_SendData(UBYTE Data)
{
DEV_Digital_Write(EPD_DC_PIN, 1);
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_SPI_WriteByte(Data);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : Wait until the busy_pin goes LOW
parameter:
******************************************************************************/
static void EPD_3IN0G_ReadBusyH(void)
{
Debug("e-Paper busy H\r\n");
while(!DEV_Digital_Read(EPD_BUSY_PIN)) { //LOW: idle, HIGH: busy
DEV_Delay_ms(5);
}
Debug("e-Paper busy H release\r\n");
}
static void EPD_3IN0G_ReadBusyL(void)
{
Debug("e-Paper busy L\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN)) { //LOW: idle, HIGH: busy
DEV_Delay_ms(5);
}
Debug("e-Paper busy L release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_3IN0G_TurnOnDisplay(void)
{
EPD_3IN0G_SendCommand(0x12); // DISPLAY_REFRESH
EPD_3IN0G_SendData(0x00);
EPD_3IN0G_ReadBusyH();
EPD_3IN0G_SendCommand(0x02); // POWER_OFF
EPD_3IN0G_SendData(0X00);
EPD_3IN0G_ReadBusyH();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_3IN0G_Init(void)
{
EPD_3IN0G_Reset();
EPD_3IN0G_SendCommand(0x66);
EPD_3IN0G_SendData(0x49);
EPD_3IN0G_SendData(0x55);
EPD_3IN0G_SendData(0x13);
EPD_3IN0G_SendData(0x5D);
EPD_3IN0G_SendData(0x05);
EPD_3IN0G_SendData(0x10);
EPD_3IN0G_SendCommand(0xB0);
EPD_3IN0G_SendData(0x00);//1 boost
EPD_3IN0G_SendCommand(0x01);
EPD_3IN0G_SendData(0x0F);
EPD_3IN0G_SendData(0x00);
EPD_3IN0G_SendCommand(0x00);
EPD_3IN0G_SendData(0x4F);
EPD_3IN0G_SendData(0x6B);
EPD_3IN0G_SendCommand(0x06);
EPD_3IN0G_SendData(0xD7);
EPD_3IN0G_SendData(0xDE);
EPD_3IN0G_SendData(0x12);
EPD_3IN0G_SendCommand(0x61);
EPD_3IN0G_SendData(0x00);
EPD_3IN0G_SendData(0xA8);
EPD_3IN0G_SendData(0x01);
EPD_3IN0G_SendData(0x90);
EPD_3IN0G_SendCommand(0x50);
EPD_3IN0G_SendData(0x37);
EPD_3IN0G_SendCommand(0x60);
EPD_3IN0G_SendData(0x0C);
EPD_3IN0G_SendData(0x05);
EPD_3IN0G_SendCommand(0xE3);
EPD_3IN0G_SendData(0xFF);
EPD_3IN0G_SendCommand(0x84);
EPD_3IN0G_SendData(0x00);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_3IN0G_Clear(UBYTE color)
{
UWORD Width, Height;
Width = (EPD_3IN0G_WIDTH % 4 == 0)? (EPD_3IN0G_WIDTH / 4 ): (EPD_3IN0G_WIDTH / 4 + 1);
Height = EPD_3IN0G_HEIGHT;
EPD_3IN0G_SendCommand(0x04);
EPD_3IN0G_ReadBusyH();
EPD_3IN0G_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_3IN0G_SendData(color);
}
}
EPD_3IN0G_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_3IN0G_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_3IN0G_WIDTH % 4 == 0)? (EPD_3IN0G_WIDTH / 4 ): (EPD_3IN0G_WIDTH / 4 + 1);
Height = EPD_3IN0G_HEIGHT;
EPD_3IN0G_SendCommand(0x04);
EPD_3IN0G_ReadBusyH();
EPD_3IN0G_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_3IN0G_SendData(Image[i + j * Width]);
}
}
EPD_3IN0G_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_3IN0G_Sleep(void)
{
EPD_3IN0G_SendCommand(0x02); // POWER_OFF
EPD_3IN0G_SendData(0X00);
EPD_3IN0G_SendCommand(0x07); // DEEP_SLEEP
EPD_3IN0G_SendData(0XA5);
}

32
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_3in0g.h Normal file
View file

@ -0,0 +1,32 @@
/*****************************************************************************
* | File : EPD_3in0g.h
* | Author : Waveshare team
* | Function : 3inch e-paper (G)
* | Info :
*----------------
* | This version: V1.0
* | Date : 2022-07-15
* | Info :
* -----------------------------------------------------------------------------
******************************************************************************/
#ifndef __EPD_3IN0G_H_
#define __EPD_3IN0G_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_3IN0G_WIDTH 168
#define EPD_3IN0G_HEIGHT 400
//colour
#define EPD_3IN0G_BLACK 0x00
#define EPD_3IN0G_WHITE 0x55
#define EPD_3IN0G_YELLOW 0xAA
#define EPD_3IN0G_RED 0xFF
void EPD_3IN0G_Init(void);
void EPD_3IN0G_Clear(UBYTE color);
void EPD_3IN0G_Display(UBYTE *Image);
void EPD_3IN0G_Sleep(void);
#endif

588
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_3in52.c Normal file
View file

@ -0,0 +1,588 @@
/*****************************************************************************
* | File : EPD_3IN52.C
* | Author : Waveshare team
* | Function : 3.52inch e-paper
* | Info :
*----------------
* | This version: V1.0
* | Date : 2022-05-07
* | Info :
* -----------------------------------------------------------------------------
#
# 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 "EPD_3in52.h"
#include "Debug.h"
//GC 0.9S
static const UBYTE EPD_3IN52_lut_R20_GC[] =
{
0x01,0x0f,0x0f,0x0f,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_R21_GC[] =
{
0x01,0x4f,0x8f,0x0f,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_R22_GC[] =
{
0x01,0x0f,0x8f,0x0f,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_R23_GC[] =
{
0x01,0x4f,0x8f,0x4f,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_R24_GC[] =
{
0x01,0x0f,0x8f,0x4f,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
// DU 0.3s
static const UBYTE EPD_3IN52_lut_R20_DU[] =
{
0x01,0x0f,0x01,0x00,0x00,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_R21_DU[] =
{
0x01,0x0f,0x01,0x00,0x00,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_R22_DU[] =
{
0x01,0x8f,0x01,0x00,0x00,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_R23_DU[] =
{
0x01,0x4f,0x01,0x00,0x00,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_R24_DU[] =
{
0x01,0x0f,0x01,0x00,0x00,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
//
static const UBYTE EPD_3IN52_lut_vcom[] =
{
0x01,0x19,0x19,0x19,0x19,0x01,0x01,
0x01,0x19,0x19,0x19,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_ww[] =
{
0x01,0x59,0x99,0x59,0x99,0x01,0x01,
0x01,0x59,0x99,0x19,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_bw[] =
{
0x01,0x59,0x99,0x59,0x99,0x01,0x01,
0x01,0x59,0x99,0x19,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_wb[] =
{
0x01,0x19,0x99,0x59,0x99,0x01,0x01,
0x01,0x59,0x99,0x59,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
static const UBYTE EPD_3IN52_lut_bb[] =
{
0x01,0x19,0x99,0x59,0x99,0x01,0x01,
0x01,0x59,0x99,0x59,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
unsigned char EPD_3IN52_Flag = 0;
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
void EPD_3IN52_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(200);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(2);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(200);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
void EPD_3IN52_SendCommand(UBYTE Reg)
{
DEV_Digital_Write(EPD_DC_PIN, 0);
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_SPI_WriteByte(Reg);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : send data
parameter:
Data : Write data
******************************************************************************/
void EPD_3IN52_SendData(UBYTE Data)
{
DEV_Digital_Write(EPD_DC_PIN, 1);
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_SPI_WriteByte(Data);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : Read Busy
parameter:
******************************************************************************/
void EPD_3IN52_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
UBYTE busy;
do {
busy = DEV_Digital_Read(EPD_BUSY_PIN);
} while(!busy);
DEV_Delay_ms(200);
Debug("e-Paper busy release\r\n");
}
/**
* @brief
*
*/
void EPD_3IN52_lut(void)
{
UBYTE count;
EPD_3IN52_SendCommand(0x20); // vcom
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_vcom[count]);
}
EPD_3IN52_SendCommand(0x21); // ww --
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_ww[count]);
}
EPD_3IN52_SendCommand(0x22); // bw r
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_bw[count]);
}
EPD_3IN52_SendCommand(0x23); // wb w
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_bb[count]);
}
EPD_3IN52_SendCommand(0x24); // bb b
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_wb[count]);
}
}
/**
* @brief
*
*/
void EPD_3IN52_refresh(void)
{
EPD_3IN52_SendCommand(0x17);
EPD_3IN52_SendData(0xA5);
EPD_3IN52_ReadBusy();
DEV_Delay_ms(200);
}
// LUT download
void EPD_3IN52_lut_GC(void)
{
UBYTE count;
EPD_3IN52_SendCommand(0x20); // vcom
for(count = 0; count < 56 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R20_GC[count]);
}
EPD_3IN52_SendCommand(0x21); // red not use
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R21_GC[count]);
}
EPD_3IN52_SendCommand(0x24); // bb b
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R24_GC[count]);
}
if(EPD_3IN52_Flag == 0)
{
EPD_3IN52_SendCommand(0x22); // bw r
for(count = 0; count < 56 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R22_GC[count]);
}
EPD_3IN52_SendCommand(0x23); // wb w
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R23_GC[count]);
}
EPD_3IN52_Flag = 1;
}
else
{
EPD_3IN52_SendCommand(0x22); // bw r
for(count = 0; count < 56 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R23_GC[count]);
}
EPD_3IN52_SendCommand(0x23); // wb w
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R22_GC[count]);
}
EPD_3IN52_Flag = 0;
}
}
// LUT download
void EPD_3IN52_lut_DU(void)
{
UBYTE count;
EPD_3IN52_SendCommand(0x20); // vcom
for(count = 0; count < 56 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R20_DU[count]);
}
EPD_3IN52_SendCommand(0x21); // red not use
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R21_DU[count]);
}
EPD_3IN52_SendCommand(0x24); // bb b
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R24_DU[count]);
}
if(EPD_3IN52_Flag == 0)
{
EPD_3IN52_SendCommand(0x22); // bw r
for(count = 0; count < 56 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R22_DU[count]);
}
EPD_3IN52_SendCommand(0x23); // wb w
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R23_DU[count]);
}
EPD_3IN52_Flag = 1;
}
else
{
EPD_3IN52_SendCommand(0x22); // bw r
for(count = 0; count < 56 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R23_DU[count]);
}
EPD_3IN52_SendCommand(0x23); // wb w
for(count = 0; count < 42 ; count++)
{
EPD_3IN52_SendData(EPD_3IN52_lut_R22_DU[count]);
}
EPD_3IN52_Flag = 0;
}
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_3IN52_Init(void)
{
EPD_3IN52_Flag = 0;
EPD_3IN52_Reset();
EPD_3IN52_SendCommand(0x00); // panel setting PSR
EPD_3IN52_SendData(0xFF); // RES1 RES0 REG KW/R UD SHL SHD_N RST_N
EPD_3IN52_SendData(0x01); // x x x VCMZ TS_AUTO TIGE NORG VC_LUTZ
EPD_3IN52_SendCommand(0x01); // POWER SETTING PWR
EPD_3IN52_SendData(0x03); // x x x x x x VDS_EN VDG_EN
EPD_3IN52_SendData(0x10); // x x x VCOM_SLWE VGH[3:0] VGH=20V, VGL=-20V
EPD_3IN52_SendData(0x3F); // x x VSH[5:0] VSH = 15V
EPD_3IN52_SendData(0x3F); // x x VSL[5:0] VSL=-15V
EPD_3IN52_SendData(0x03); // OPTEN VDHR[6:0] VHDR=6.4V
// T_VDS_OFF[1:0] 00=1 frame; 01=2 frame; 10=3 frame; 11=4 frame
EPD_3IN52_SendCommand(0x06); // booster soft start BTST
EPD_3IN52_SendData(0x37); // BT_PHA[7:0]
EPD_3IN52_SendData(0x3D); // BT_PHB[7:0]
EPD_3IN52_SendData(0x3D); // x x BT_PHC[5:0]
EPD_3IN52_SendCommand(0x60); // TCON setting TCON
EPD_3IN52_SendData(0x22); // S2G[3:0] G2S[3:0] non-overlap = 12
EPD_3IN52_SendCommand(0x82); // VCOM_DC setting VDCS
EPD_3IN52_SendData(0x07); // x VDCS[6:0] VCOM_DC value= -1.9v 00~3f,0x12=-1.9v
EPD_3IN52_SendCommand(0x30);
EPD_3IN52_SendData(0x09);
EPD_3IN52_SendCommand(0xe3); // power saving PWS
EPD_3IN52_SendData(0x88); // VCOM_W[3:0] SD_W[3:0]
EPD_3IN52_SendCommand(0x61); // resoultion setting
EPD_3IN52_SendData(0xf0); // HRES[7:3] 0 0 0
EPD_3IN52_SendData(0x01); // x x x x x x x VRES[8]
EPD_3IN52_SendData(0x68); // VRES[7:0]
EPD_3IN52_SendCommand(0x50);
EPD_3IN52_SendData(0xB7);
}
void EPD_3IN52_display(UBYTE* picData)
{
UWORD i;
EPD_3IN52_SendCommand(0x13); //Transfer new data
for(i=0;i<(EPD_3IN52_WIDTH*EPD_3IN52_HEIGHT/8);i++)
{
EPD_3IN52_SendData(*picData);
picData++;
}
}
void EPD_3IN52_display_NUM(UBYTE NUM)
{
UWORD row, column;
// UWORD pcnt = 0;
EPD_3IN52_SendCommand(0x13); //Transfer new data
for(column=0; column<EPD_3IN52_HEIGHT; column++)
{
for(row=0; row<EPD_3IN52_WIDTH/8; row++)
{
switch (NUM)
{
case EPD_3IN52_WHITE:
EPD_3IN52_SendData(0xFF);
break;
case EPD_3IN52_BLACK:
EPD_3IN52_SendData(0x00);
break;
case EPD_3IN52_Source_Line:
EPD_3IN52_SendData(0xAA);
break;
case EPD_3IN52_Gate_Line:
if(column%2)
EPD_3IN52_SendData(0xff); //An odd number of Gate line
else
EPD_3IN52_SendData(0x00); //The even line Gate
break;
case EPD_3IN52_Chessboard:
if(row>=(EPD_3IN52_WIDTH/8/2)&&column>=(EPD_3IN52_HEIGHT/2))
EPD_3IN52_SendData(0xff);
else if(row<(EPD_3IN52_WIDTH/8/2)&&column<(EPD_3IN52_HEIGHT/2))
EPD_3IN52_SendData(0xff);
else
EPD_3IN52_SendData(0x00);
break;
case EPD_3IN52_LEFT_BLACK_RIGHT_WHITE:
if(row>=(EPD_3IN52_WIDTH/8/2))
EPD_3IN52_SendData(0xff);
else
EPD_3IN52_SendData(0x00);
break;
case EPD_3IN52_UP_BLACK_DOWN_WHITE:
if(column>=(EPD_3IN52_HEIGHT/2))
EPD_3IN52_SendData(0xFF);
else
EPD_3IN52_SendData(0x00);
break;
case EPD_3IN52_Frame:
if(column==0||column==(EPD_3IN52_HEIGHT-1))
EPD_3IN52_SendData(0x00);
else if(row==0)
EPD_3IN52_SendData(0x7F);
else if(row==(EPD_3IN52_WIDTH/8-1))
EPD_3IN52_SendData(0xFE);
else
EPD_3IN52_SendData(0xFF);
break;
case EPD_3IN52_Crosstalk:
if((row>=(EPD_3IN52_WIDTH/8/3)&&row<=(EPD_3IN52_WIDTH/8/3*2)&&column<=(EPD_3IN52_HEIGHT/3))||(row>=(EPD_3IN52_WIDTH/8/3)&&row<=(EPD_3IN52_WIDTH/8/3*2)&&column>=(EPD_3IN52_HEIGHT/3*2)))
EPD_3IN52_SendData(0x00);
else
EPD_3IN52_SendData(0xFF);
break;
case EPD_3IN52_Image:
//EPD_3IN52_SendData(gImage_1[pcnt++]);
break;
default:
break;
}
}
}
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_3IN52_Clear(void)
{
UWORD i;
EPD_3IN52_SendCommand(0x13); //Transfer new data
for(i=0;i<(EPD_3IN52_WIDTH*EPD_3IN52_HEIGHT/8);i++)
{
EPD_3IN52_SendData(0xFF);
}
EPD_3IN52_lut_GC();
EPD_3IN52_refresh();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_3IN52_sleep(void)
{
EPD_3IN52_SendCommand(0X07); //deep sleep
EPD_3IN52_SendData(0xA5);
}

70
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_3in52.h Normal file
View file

@ -0,0 +1,70 @@
/*****************************************************************************
* | File : EPD_3IN52.h
* | Author : Waveshare team
* | Function : 3.52inch e-paper
* | Info :
*----------------
* | This version: V1.0
* | Date : 2022-05-07
* | Info :
* -----------------------------------------------------------------------------
#
# 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 __EPD_3IN52_H_
#define __EPD_3IN52_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_3IN52_WIDTH 240
#define EPD_3IN52_HEIGHT 360
#define LUTGC_TEST //
#define LUTDU_TEST //
#define EPD_3IN52_WHITE 0xFF //
#define EPD_3IN52_BLACK 0x00 //
#define EPD_3IN52_Source_Line 0xAA //
#define EPD_3IN52_Gate_Line 0x55 //
#define EPD_3IN52_UP_BLACK_DOWN_WHITE 0xF0 //
#define EPD_3IN52_LEFT_BLACK_RIGHT_WHITE 0x0F //
#define EPD_3IN52_Frame 0x01 //
#define EPD_3IN52_Crosstalk 0x02 //
#define EPD_3IN52_Chessboard 0x03 //
#define EPD_3IN52_Image 0x04 //
extern unsigned char EPD_3IN52_Flag;
void EPD_3IN52_SendCommand(UBYTE Reg);
void EPD_3IN52_SendData(UBYTE Data);
void EPD_3IN52_refresh(void);
void EPD_3IN52_lut_GC(void);
void EPD_3IN52_lut_DU(void);
void EPD_3IN52_Init(void);
void EPD_3IN52_display(UBYTE* picData);
void EPD_3IN52_display_NUM(UBYTE NUM);
void EPD_3IN52_Clear(void);
void EPD_3IN52_sleep(void);
#endif

246
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in3g.c Normal file
View file

@ -0,0 +1,246 @@
/*****************************************************************************
* | File : EPD_7in3g.c
* | Author : Waveshare team
* | Function : 7.3inch e-paper (G)
* | Info :
*----------------
* | This version: V1.0
* | Date : 2022-07-22
* | Info :
* -----------------------------------------------------------------------------
#
# 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 "EPD_7in3g.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_7IN3G_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(20);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(2);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(20);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_7IN3G_SendCommand(UBYTE Reg)
{
DEV_Digital_Write(EPD_DC_PIN, 0);
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_SPI_WriteByte(Reg);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : send data
parameter:
Data : Write data
******************************************************************************/
static void EPD_7IN3G_SendData(UBYTE Data)
{
DEV_Digital_Write(EPD_DC_PIN, 1);
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_SPI_WriteByte(Data);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : Wait until the busy_pin goes LOW
parameter:
******************************************************************************/
static void EPD_7IN3G_ReadBusyH(void)
{
Debug("e-Paper busy H\r\n");
while(!DEV_Digital_Read(EPD_BUSY_PIN)) { //LOW: idle, HIGH: busy
DEV_Delay_ms(5);
}
Debug("e-Paper busy H release\r\n");
}
static void EPD_7IN3G_ReadBusyL(void)
{
Debug("e-Paper busy L\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN)) { //LOW: idle, HIGH: busy
DEV_Delay_ms(5);
}
Debug("e-Paper busy L release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_7IN3G_TurnOnDisplay(void)
{
EPD_7IN3G_SendCommand(0x12); // DISPLAY_REFRESH
EPD_7IN3G_SendData(0x00);
EPD_7IN3G_ReadBusyH();
EPD_7IN3G_SendCommand(0x02); // POWER_OFF
EPD_7IN3G_SendData(0X00);
EPD_7IN3G_ReadBusyH();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_7IN3G_Init(void)
{
EPD_7IN3G_Reset();
EPD_7IN3G_ReadBusyH();
DEV_Delay_ms(30);
EPD_7IN3G_SendCommand(0xAA);
EPD_7IN3G_SendData(0x49);
EPD_7IN3G_SendData(0x55);
EPD_7IN3G_SendData(0x20);
EPD_7IN3G_SendData(0x08);
EPD_7IN3G_SendData(0x09);
EPD_7IN3G_SendData(0x18);
EPD_7IN3G_SendCommand(0x01);
EPD_7IN3G_SendData(0x3F);
EPD_7IN3G_SendCommand(0x00);
EPD_7IN3G_SendData(0x4F);
EPD_7IN3G_SendData(0x69);
EPD_7IN3G_SendCommand(0x05);
EPD_7IN3G_SendData(0x40);
EPD_7IN3G_SendData(0x1F);
EPD_7IN3G_SendData(0x1F);
EPD_7IN3G_SendData(0x2C);
EPD_7IN3G_SendCommand(0x08);
EPD_7IN3G_SendData(0x6F);
EPD_7IN3G_SendData(0x1F);
EPD_7IN3G_SendData(0x1F);
EPD_7IN3G_SendData(0x22);
//===================
//20211212
//First setting
EPD_7IN3G_SendCommand(0x06);
EPD_7IN3G_SendData(0x6F);
EPD_7IN3G_SendData(0x1F);
EPD_7IN3G_SendData(0x14);
EPD_7IN3G_SendData(0x14);
//===================
EPD_7IN3G_SendCommand(0x03);
EPD_7IN3G_SendData(0x00);
EPD_7IN3G_SendData(0x54);
EPD_7IN3G_SendData(0x00);
EPD_7IN3G_SendData(0x44);
EPD_7IN3G_SendCommand(0x60);
EPD_7IN3G_SendData(0x02);
EPD_7IN3G_SendData(0x00);
//Please notice that PLL must be set for version 2 IC
EPD_7IN3G_SendCommand(0x30);
EPD_7IN3G_SendData(0x08);
EPD_7IN3G_SendCommand(0x50);
EPD_7IN3G_SendData(0x3F);
EPD_7IN3G_SendCommand(0x61);
EPD_7IN3G_SendData(0x03);
EPD_7IN3G_SendData(0x20);
EPD_7IN3G_SendData(0x01);
EPD_7IN3G_SendData(0xE0);
EPD_7IN3G_SendCommand(0xE3);
EPD_7IN3G_SendData(0x2F);
EPD_7IN3G_SendCommand(0x84);
EPD_7IN3G_SendData(0x01);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_7IN3G_Clear(UBYTE color)
{
UWORD Width, Height;
Width = (EPD_7IN3G_WIDTH % 4 == 0)? (EPD_7IN3G_WIDTH / 4 ): (EPD_7IN3G_WIDTH / 4 + 1);
Height = EPD_7IN3G_HEIGHT;
EPD_7IN3G_SendCommand(0x04);
EPD_7IN3G_ReadBusyH();
EPD_7IN3G_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_7IN3G_SendData(color);
}
}
EPD_7IN3G_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_7IN3G_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_7IN3G_WIDTH % 4 == 0)? (EPD_7IN3G_WIDTH / 4 ): (EPD_7IN3G_WIDTH / 4 + 1);
Height = EPD_7IN3G_HEIGHT;
EPD_7IN3G_SendCommand(0x04);
EPD_7IN3G_ReadBusyH();
EPD_7IN3G_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_7IN3G_SendData(Image[i + j * Width]);
}
}
EPD_7IN3G_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_7IN3G_Sleep(void)
{
EPD_7IN3G_SendCommand(0x02); // POWER_OFF
EPD_7IN3G_SendData(0X00);
EPD_7IN3G_SendCommand(0x07); // DEEP_SLEEP
EPD_7IN3G_SendData(0XA5);
}

52
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in3g.h Normal file
View file

@ -0,0 +1,52 @@
/*****************************************************************************
* | File : EPD_7in3g.h
* | Author : Waveshare team
* | Function : 7.3inchg e-paper (G)
* | Info :
*----------------
* | This version: V1.0
* | Date : 2022-07-22
* | Info :
* -----------------------------------------------------------------------------
#
# 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 __EPD_7IN3G_H_
#define __EPD_7IN3G_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_7IN3G_WIDTH 800
#define EPD_7IN3G_HEIGHT 480
//colour
#define EPD_7IN3G_BLACK 0x00
#define EPD_7IN3G_WHITE 0x55
#define EPD_7IN3G_YELLOW 0xAA
#define EPD_7IN3G_RED 0xFF
void EPD_7IN3G_Init(void);
void EPD_7IN3G_Clear(UBYTE color);
void EPD_7IN3G_Display(UBYTE *Image);
void EPD_7IN3G_Sleep(void);
#endif

BIN
RaspberryPi_JetsonNano/c/pic/1.64inch-1.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 83 KiB

BIN
RaspberryPi_JetsonNano/c/pic/1.64inch-2.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 83 KiB

BIN
RaspberryPi_JetsonNano/c/pic/3in52-1.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 11 KiB

BIN
RaspberryPi_JetsonNano/c/pic/3in52-2.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 11 KiB

BIN
RaspberryPi_JetsonNano/c/pic/3in52-3.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 11 KiB

BIN
RaspberryPi_JetsonNano/c/pic/3inch-1.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 197 KiB

BIN
RaspberryPi_JetsonNano/c/pic/3inch-2.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 197 KiB

BIN
RaspberryPi_JetsonNano/c/pic/3inch-3.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 197 KiB

BIN
RaspberryPi_JetsonNano/c/pic/7.3inch-1.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 1.1 MiB

BIN
RaspberryPi_JetsonNano/c/pic/7.3inch-2.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 1.1 MiB

BIN
RaspberryPi_JetsonNano/c/pic/7.3inch-3.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 1.1 MiB

74
RaspberryPi_JetsonNano/python/examples/epd_1in64g_test.py Normal file
View file

@ -0,0 +1,74 @@
#!/usr/bin/python
# -*- coding:utf-8 -*-
import sys
import os
picdir = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'pic')
libdir = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'lib')
if os.path.exists(libdir):
sys.path.append(libdir)
import logging
from waveshare_epd import epd1in64g
import time
from PIL import Image,ImageDraw,ImageFont
import traceback
logging.basicConfig(level=logging.DEBUG)
try:
logging.info("epd1in64g Demo")
BLACK = 0x00
WHITE = 0x55
YELLOW = 0xAA
RED = 0xFF
epd = epd1in64g.EPD()
logging.info("init and Clear")
epd.init()
epd.Clear(WHITE)
font24 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 24)
font18 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 18)
font30 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 40)
# Drawing on the image
logging.info("1.Drawing on the image...")
Himage = Image.new('RGB', (epd.width, epd.height), 0xffffff)
draw = ImageDraw.Draw(Himage)
draw.text((5, 0), 'hello world', font = font18, fill = epd.RED)
draw.text((5, 20), '1.64inch e-Paper', font = font18, fill = epd.YELLOW)
draw.text((5, 40), u'微雪电子', font = font30, fill = epd.BLACK)
draw.line((5, 90, 45, 160), fill = epd.RED)
draw.line((45, 90, 5, 160), fill = epd.YELLOW)
draw.rectangle((5, 90, 45, 160), outline = epd.BLACK)
draw.rectangle((55, 90, 95, 160), fill = epd.BLACK)
draw.arc((115, 90, 150, 125), 0, 360, fill = epd.BLACK)
draw.chord((115, 130, 150, 165), 0, 360, fill = epd.BLACK)
epd.display(epd.getbuffer(Himage))
time.sleep(3)
# read bmp file
logging.info("3.read bmp file")
Himage = Image.open(os.path.join(picdir, '1.64inch-1.bmp'))
epd.display(epd.getbuffer(Himage))
time.sleep(3)
logging.info("3.read bmp file")
Himage = Image.open(os.path.join(picdir, '1.64inch-2.bmp'))
epd.display(epd.getbuffer(Himage))
time.sleep(3)
logging.info("Clear...")
epd.Clear(WHITE)
logging.info("Goto Sleep...")
epd.sleep()
except IOError as e:
logging.info(e)
except KeyboardInterrupt:
logging.info("ctrl + c:")
epd1in64g.epdconfig.module_exit()
exit()

105
RaspberryPi_JetsonNano/python/examples/epd_3in0g_test.py Normal file
View file

@ -0,0 +1,105 @@
#!/usr/bin/python
# -*- coding:utf-8 -*-
import sys
import os
picdir = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'pic')
libdir = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'lib')
if os.path.exists(libdir):
sys.path.append(libdir)
import logging
from waveshare_epd import epd3in0g
import time
from PIL import Image,ImageDraw,ImageFont
import traceback
logging.basicConfig(level=logging.DEBUG)
try:
logging.info("epd3in0g Demo")
BLACK = 0x00
WHITE = 0x55
YELLOW = 0xAA
RED = 0xFF
epd = epd3in0g.EPD()
logging.info("init and Clear")
epd.init()
epd.Clear(WHITE)
font24 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 24)
font18 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 18)
font30 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 40)
# Drawing on the image
epd.init()
logging.info("1.Drawing on the image...")
Himage = Image.new('RGB', (epd.width, epd.height), 0xffffff)
draw = ImageDraw.Draw(Himage)
draw.text((5, 0), 'hello world', font = font18, fill = epd.RED)
draw.text((5, 20), '3inch e-Paper', font = font24, fill = epd.YELLOW)
draw.text((5, 45), u'微雪电子', font = font30, fill = epd.BLACK)
draw.text((5, 85), u'微雪电子', font = font30, fill = epd.YELLOW)
draw.text((5, 125), u'微雪电子', font = font30, fill = epd.RED)
draw.line((5, 170, 80, 245), fill = epd.RED)
draw.line((80, 170, 5, 245), fill = epd.YELLOW)
draw.rectangle((5, 170, 80, 245), outline = epd.BLACK)
draw.rectangle((90, 170, 165, 245), fill = epd.YELLOW)
draw.arc((5, 250, 80, 325), 0, 360, fill = epd.BLACK)
draw.chord((90, 250, 165, 325), 0, 360, fill = epd.RED)
epd.display(epd.getbuffer(Himage))
time.sleep(3)
# Switch width and height for landscape display
epd.init()
logging.info("1.Drawing on the image...")
Himage = Image.new('RGB', (epd.height, epd.width), 0xffffff)
draw = ImageDraw.Draw(Himage)
draw.text((5, 0), 'hello world', font = font18, fill = epd.RED)
draw.text((5, 20), '3inch e-Paper', font = font24, fill = epd.YELLOW)
draw.text((5, 45), u'微雪电子', font = font30, fill = epd.BLACK)
draw.text((5, 85), u'微雪电子', font = font30, fill = epd.YELLOW)
draw.text((5, 125), u'微雪电子', font = font30, fill = epd.RED)
draw.line((205, 5, 295, 65), fill = epd.RED)
draw.line((295, 5, 205, 65), fill = epd.YELLOW)
draw.rectangle((205, 5, 295, 65), outline = epd.BLACK)
draw.rectangle((305, 5, 395, 65), fill = epd.RED)
draw.arc((205, 75, 295, 165), 0, 360, fill = epd.BLACK)
draw.chord((305, 75, 395, 165), 0, 360, fill = epd.YELLOW)
epd.display(epd.getbuffer(Himage))
time.sleep(3)
# read bmp file
epd.init()
logging.info("3.read bmp file")
Himage = Image.open(os.path.join(picdir, '3inch-1.bmp'))
epd.display(epd.getbuffer(Himage))
time.sleep(3)
epd.init()
logging.info("3.read bmp file")
Himage = Image.open(os.path.join(picdir, '3inch-2.bmp'))
epd.display(epd.getbuffer(Himage))
time.sleep(3)
epd.init()
logging.info("3.read bmp file")
Himage = Image.open(os.path.join(picdir, '3inch-3.bmp'))
epd.display(epd.getbuffer(Himage))
time.sleep(3)
epd.init()
logging.info("Clear...")
epd.Clear(WHITE)
logging.info("Goto Sleep...")
epd.sleep()
except IOError as e:
logging.info(e)
except KeyboardInterrupt:
logging.info("ctrl + c:")
epd3in0g.epdconfig.module_exit()
exit()

119
RaspberryPi_JetsonNano/python/examples/epd_3in52_test.py Normal file
View file

@ -0,0 +1,119 @@
#!/usr/bin/python
# -*- coding:utf-8 -*-
import sys
import os
picdir = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'pic')
libdir = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'lib')
if os.path.exists(libdir):
sys.path.append(libdir)
import logging
from waveshare_epd import epd3in52
import time
from PIL import Image,ImageDraw,ImageFont
import traceback
logging.basicConfig(level=logging.DEBUG)
try:
logging.info("epd2in9 Demo")
epd = epd3in52.EPD()
logging.info("init and Clear")
epd.init()
epd.display_NUM(epd.WHITE)
epd.lut_GC()
epd.refresh()
epd.send_command(0x50)
epd.send_data(0x17)
time.sleep(2)
font24 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 24)
font18 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 18)
font30 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 40)
# Drawing on the Horizontal image
logging.info("1.Drawing on the Horizontal image...")
Himage = Image.new('1', (epd.height, epd.width), 255) # 255: clear the frame
draw = ImageDraw.Draw(Himage)
draw.text((10, 0), 'hello world', font = font24, fill = 0)
draw.text((10, 20), '3.52inch e-Paper', font = font24, fill = 0)
draw.text((150, 0), u'微雪电子', font = font24, fill = 0)
draw.line((20, 50, 70, 100), fill = 0)
draw.line((70, 50, 20, 100), fill = 0)
draw.rectangle((20, 50, 70, 100), outline = 0)
draw.line((165, 50, 165, 100), fill = 0)
draw.line((140, 75, 190, 75), fill = 0)
draw.arc((140, 50, 190, 100), 0, 360, fill = 0)
draw.rectangle((80, 50, 130, 100), fill = 0)
draw.chord((200, 50, 250, 100), 0, 360, fill = 0)
epd.display(epd.getbuffer(Himage))
epd.lut_GC()
epd.refresh()
time.sleep(2)
# Drawing on the Vertical image
logging.info("2.Drawing on the Vertical image...")
Limage = Image.new('1', (epd.width, epd.height), 255) # 255: clear the frame
draw = ImageDraw.Draw(Limage)
draw.text((2, 0), 'hello world', font = font18, fill = 0)
draw.text((2, 20), '3.52inch e-Paper', font = font18, fill = 0)
draw.text((20, 50), u'微雪电子', font = font18, fill = 0)
draw.line((10, 90, 60, 140), fill = 0)
draw.line((60, 90, 10, 140), fill = 0)
draw.rectangle((10, 90, 60, 140), outline = 0)
draw.line((95, 90, 95, 140), fill = 0)
draw.line((70, 115, 120, 115), fill = 0)
draw.arc((70, 90, 120, 140), 0, 360, fill = 0)
draw.rectangle((10, 150, 60, 200), fill = 0)
draw.chord((70, 150, 120, 200), 0, 360, fill = 0)
epd.display(epd.getbuffer(Limage))
epd.lut_GC()
epd.refresh()
time.sleep(2)
logging.info("3.read bmp file")
Himage = Image.open(os.path.join(picdir, '3in52-1.bmp'))
epd.display(epd.getbuffer(Himage))
epd.lut_GC()
epd.refresh()
time.sleep(2)
logging.info("4.read bmp file on window")
Himage2 = Image.new('1', (epd.height, epd.width), 255) # 255: clear the frame
bmp = Image.open(os.path.join(picdir, '100x100.bmp'))
Himage2.paste(bmp, (50,10))
epd.display(epd.getbuffer(Himage2))
epd.lut_GC()
epd.refresh()
time.sleep(2)
# print("Quick refresh is supported, but the refresh effect is not good, but it is not recommended")
# Himage = Image.open(os.path.join(picdir, '3in52-2.bmp'))
# epd.display(epd.getbuffer(Himage))
# epd.lut_DU()
# epd.refresh()
# time.sleep(2)
# Himage = Image.open(os.path.join(picdir, '3in52-3.bmp'))
# epd.display(epd.getbuffer(Himage))
# epd.lut_DU()
# epd.refresh()
# time.sleep(2)
logging.info("Clear...")
epd.Clear()
logging.info("Goto Sleep...")
epd.sleep()
except IOError as e:
logging.info(e)
except KeyboardInterrupt:
logging.info("ctrl + c:")
epd3in52.epdconfig.module_exit()
exit()

81
RaspberryPi_JetsonNano/python/examples/epd_7in3g_test.py Normal file
View file

@ -0,0 +1,81 @@
#!/usr/bin/python
# -*- coding:utf-8 -*-
import sys
import os
picdir = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'pic')
libdir = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__file__))), 'lib')
if os.path.exists(libdir):
sys.path.append(libdir)
import logging
from waveshare_epd import epd7in3g
import time
from PIL import Image,ImageDraw,ImageFont
import traceback
logging.basicConfig(level=logging.DEBUG)
try:
logging.info("epd1in64g Demo")
BLACK = 0x00
WHITE = 0x55
YELLOW = 0xAA
RED = 0xFF
epd = epd7in3g.EPD()
logging.info("init and Clear")
epd.init()
epd.Clear(WHITE)
font24 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 24)
font18 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 18)
font30 = ImageFont.truetype(os.path.join(picdir, 'Font.ttc'), 40)
# Drawing on the image
logging.info("1.Drawing on the image...")
Himage = Image.new('RGB', (epd.width, epd.height), 0xffffff) # 255: clear the frame
draw = ImageDraw.Draw(Himage)
draw.text((5, 0), 'hello world', font = font18, fill = epd.RED)
draw.text((5, 20), '7.3inch e-Paper', font = font24, fill = epd.YELLOW)
draw.text((5, 45), u'微雪电子', font = font30, fill = epd.BLACK)
draw.text((5, 85), u'微雪电子', font = font30, fill = epd.YELLOW)
draw.text((5, 125), u'微雪电子', font = font30, fill = epd.RED)
draw.line((5, 170, 80, 245), fill = epd.RED)
draw.line((80, 170, 5, 245), fill = epd.YELLOW)
draw.rectangle((5, 170, 80, 245), outline = epd.BLACK)
draw.rectangle((90, 170, 165, 245), fill = epd.YELLOW)
draw.arc((5, 250, 80, 325), 0, 360, fill = epd.BLACK)
draw.chord((90, 250, 165, 325), 0, 360, fill = epd.RED)
epd.display(epd.getbuffer(Himage))
time.sleep(3)
# read bmp file
logging.info("3.read bmp file")
Himage = Image.open(os.path.join(picdir, '7.3inch-1.bmp'))
epd.display(epd.getbuffer(Himage))
time.sleep(3)
logging.info("3.read bmp file")
Himage = Image.open(os.path.join(picdir, '7.3inch-2.bmp'))
epd.display(epd.getbuffer(Himage))
time.sleep(3)
logging.info("3.read bmp file")
Himage = Image.open(os.path.join(picdir, '7.3inch-3.bmp'))
epd.display(epd.getbuffer(Himage))
time.sleep(3)
logging.info("Clear...")
epd.Clear(WHITE)
logging.info("Goto Sleep...")
epd.sleep()
except IOError as e:
logging.info(e)
except KeyboardInterrupt:
logging.info("ctrl + c:")
epd7in3g.epdconfig.module_exit()
exit()

242
RaspberryPi_JetsonNano/python/lib/waveshare_epd/epd1in64g.py Normal file
View file

@ -0,0 +1,242 @@
# *****************************************************************************
# * | File : epd1in64g.py
# * | Author : Waveshare team
# * | Function : Electronic paper driver
# * | Info :
# *----------------
# * | This version: V1
# * | Date : 2022-07-20
# # | Info : python demo
# -----------------------------------------------------------------------------
# ******************************************************************************/
# 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.
#
import logging
from . import epdconfig
import PIL
from PIL import Image
import io
# Display resolution
EPD_WIDTH = 168
EPD_HEIGHT = 168
logger = logging.getLogger(__name__)
class EPD:
def __init__(self):
self.reset_pin = epdconfig.RST_PIN
self.dc_pin = epdconfig.DC_PIN
self.busy_pin = epdconfig.BUSY_PIN
self.cs_pin = epdconfig.CS_PIN
self.width = EPD_WIDTH
self.height = EPD_HEIGHT
self.BLACK = 0x000000 # 00 BGR
self.WHITE = 0xffffff # 01
self.YELLOW = 0x00ffff # 10
self.RED = 0x0000ff # 11
# Hardware reset
def reset(self):
epdconfig.digital_write(self.reset_pin, 1)
epdconfig.delay_ms(200)
epdconfig.digital_write(self.reset_pin, 0) # module reset
epdconfig.delay_ms(2)
epdconfig.digital_write(self.reset_pin, 1)
epdconfig.delay_ms(200)
def send_command(self, command):
epdconfig.digital_write(self.dc_pin, 0)
epdconfig.digital_write(self.cs_pin, 0)
epdconfig.spi_writebyte([command])
epdconfig.digital_write(self.cs_pin, 1)
def send_data(self, data):
epdconfig.digital_write(self.dc_pin, 1)
epdconfig.digital_write(self.cs_pin, 0)
epdconfig.spi_writebyte([data])
epdconfig.digital_write(self.cs_pin, 1)
def ReadBusyH(self):
logger.debug("e-Paper busy H")
while(epdconfig.digital_read(self.busy_pin) == 0): # 0: idle, 1: busy
epdconfig.delay_ms(5)
logger.debug("e-Paper busy H release")
def ReadBusyL(self):
logger.debug("e-Paper busy L")
while(epdconfig.digital_read(self.busy_pin) == 1): # 0: busy, 1: idle
epdconfig.delay_ms(5)
logger.debug("e-Paper busy L release")
def TurnOnDisplay(self):
self.send_command(0x12) # DISPLAY_REFRESH
self.send_data(0x01)
self.ReadBusyH()
self.send_command(0x02) # POWER_OFF
self.send_data(0X00)
self.ReadBusyH()
def init(self):
if (epdconfig.module_init() != 0):
return -1
# EPD hardware init start
self.reset()
self.send_command(0x66)
self.send_data(0x49)
self.send_data(0x55)
self.send_data(0x13)
self.send_data(0x5D)
self.send_command(0x66)
self.send_data(0x49)
self.send_data(0x55)
self.send_command(0xB0)
self.send_data(0x03)
self.send_command(0x00)
self.send_data(0x4F)
self.send_data(0x6B)
self.send_command(0x03)
self.send_data(0x00)
self.send_command(0xF0)
self.send_data(0xF6)
self.send_data(0x0D)
self.send_data(0x00)
self.send_data(0x00)
self.send_data(0x00)
self.send_command(0x06)
self.send_data(0xCF)
self.send_data(0xDF)
self.send_data(0x0F)
self.send_command(0x41)
self.send_data(0x00)
self.send_command(0x50)
self.send_data(0x30)
self.send_command(0x60)
self.send_data(0x0C)
self.send_data(0x05)
self.send_command(0x61)
self.send_data(0xA8)
self.send_data(0x00)
self.send_data(0xA8)
self.send_command(0x84)
self.send_data(0x01)
return 0
def getbuffer(self, image):
# Create a pallette with the 4 colors supported by the panel
pal_image = Image.new("P", (1,1))
pal_image.putpalette( (0,0,0, 255,255,255, 255,255,0, 255,0,0) + (0,0,0)*252)
# Check if we need to rotate the image
imwidth, imheight = image.size
if(imwidth == self.width and imheight == self.height):
image_temp = image
elif(imwidth == self.height and imheight == self.width):
image_temp = image.rotate(90, expand=True)
else:
logger.warning("Invalid image dimensions: %d x %d, expected %d x %d" % (imwidth, imheight, self.width, self.height))
# Convert the soruce image to the 4 colors, dithering if needed
image_4color = image_temp.convert("RGB").quantize(palette=pal_image)
buf_4color = bytearray(image_4color.tobytes('raw'))
# into a single byte to transfer to the panel
buf = [0x00] * int(self.width * self.height / 4)
idx = 0
for i in range(0, len(buf_4color), 4):
buf[idx] = (buf_4color[i] << 6) + (buf_4color[i+1] << 4) + (buf_4color[i+2] << 2) + buf_4color[i+3]
idx += 1
return buf
def display(self, image):
if self.width % 4 == 0 :
Width = self.width // 4
else :
Width = self.width // 4 + 1
Height = self.height
self.send_command(0x68)
self.send_data(0x01)
self.send_command(0x04)
self.ReadBusyH()
self.send_command(0x10)
for j in range(0, Height):
for i in range(0, Width):
self.send_data(image[i + j * Width])
self.TurnOnDisplay()
def Clear(self, color):
if self.width % 4 == 0 :
Width = self.width // 4
else :
Width = self.width // 4 + 1
Height = self.height
self.send_command(0x68)
self.send_data(0x01)
self.send_command(0x04)
self.ReadBusyH()
self.send_command(0x10)
for j in range(0, Height):
for i in range(0, Width):
for k in range(0, 4):
self.send_data(color)
self.send_command(0x68)
self.send_data(0x00)
self.TurnOnDisplay()
def sleep(self):
self.send_command(0x02) # POWER_OFF
self.send_data(0x00)
self.send_command(0x07) # DEEP_SLEEP
self.send_data(0XA5)
epdconfig.delay_ms(2000)
epdconfig.module_exit()
### END OF FILE ###

236
RaspberryPi_JetsonNano/python/lib/waveshare_epd/epd3in0g.py Normal file
View file

@ -0,0 +1,236 @@
# *****************************************************************************
# * | File : epd3in0g.py
# * | Author : Waveshare team
# * | Function : Electronic paper driver
# * | Info :
# *----------------
# * | This version: V1
# * | Date : 2022-07-20
# # | Info : python demo
# -----------------------------------------------------------------------------
# ******************************************************************************/
# 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.
#
import logging
from . import epdconfig
import PIL
from PIL import Image
import io
# Display resolution
EPD_WIDTH = 168
EPD_HEIGHT = 400
logger = logging.getLogger(__name__)
class EPD:
def __init__(self):
self.reset_pin = epdconfig.RST_PIN
self.dc_pin = epdconfig.DC_PIN
self.busy_pin = epdconfig.BUSY_PIN
self.cs_pin = epdconfig.CS_PIN
self.width = EPD_WIDTH
self.height = EPD_HEIGHT
self.BLACK = 0x000000 # 00 BGR
self.WHITE = 0xffffff # 01
self.YELLOW = 0x00ffff # 10
self.RED = 0x0000ff # 11
# Hardware reset
def reset(self):
epdconfig.digital_write(self.reset_pin, 1)
epdconfig.delay_ms(200)
epdconfig.digital_write(self.reset_pin, 0) # module reset
epdconfig.delay_ms(2)
epdconfig.digital_write(self.reset_pin, 1)
epdconfig.delay_ms(200)
def send_command(self, command):
epdconfig.digital_write(self.dc_pin, 0)
epdconfig.digital_write(self.cs_pin, 0)
epdconfig.spi_writebyte([command])
epdconfig.digital_write(self.cs_pin, 1)
def send_data(self, data):
epdconfig.digital_write(self.dc_pin, 1)
epdconfig.digital_write(self.cs_pin, 0)
epdconfig.spi_writebyte([data])
epdconfig.digital_write(self.cs_pin, 1)
def ReadBusyH(self):
logger.debug("e-Paper busy H")
while(epdconfig.digital_read(self.busy_pin) == 0): # 0: idle, 1: busy
epdconfig.delay_ms(5)
logger.debug("e-Paper busy H release")
def ReadBusyL(self):
logger.debug("e-Paper busy L")
while(epdconfig.digital_read(self.busy_pin) == 1): # 0: busy, 1: idle
epdconfig.delay_ms(5)
logger.debug("e-Paper busy L release")
def TurnOnDisplay(self):
self.send_command(0x12) # DISPLAY_REFRESH
self.send_data(0x01)
self.ReadBusyH()
self.send_command(0x02) # POWER_OFF
self.send_data(0X00)
self.ReadBusyH()
def init(self):
if (epdconfig.module_init() != 0):
return -1
# EPD hardware init start
self.reset()
self.send_command(0x66)
self.send_data(0x49)
self.send_data(0x55)
self.send_data(0x13)
self.send_data(0x5D)
self.send_data(0x05)
self.send_data(0x10)
self.send_command(0xB0)
self.send_data(0x00) # 1 boost
self.send_command(0x01)
self.send_data(0x0F)
self.send_data(0x00)
self.send_command(0x00)
self.send_data(0x4F)
self.send_data(0x6B)
self.send_command(0x06)
self.send_data(0xD7)
self.send_data(0xDE)
self.send_data(0x12)
self.send_command(0x61)
self.send_data(0x00)
self.send_data(0xA8)
self.send_data(0x01)
self.send_data(0x90)
self.send_command(0x50)
self.send_data(0x37)
self.send_command(0x60)
self.send_data(0x0C)
self.send_data(0x05)
self.send_command(0xE3)
self.send_data(0xFF)
self.send_command(0x84)
self.send_data(0x00)
return 0
def getbuffer(self, image):
# Create a pallette with the 4 colors supported by the panel
pal_image = Image.new("P", (1,1))
pal_image.putpalette( (0,0,0, 255,255,255, 255,255,0, 255,0,0) + (0,0,0)*252)
# Check if we need to rotate the image
imwidth, imheight = image.size
if(imwidth == self.width and imheight == self.height):
image_temp = image
elif(imwidth == self.height and imheight == self.width):
image_temp = image.rotate(90, expand=True)
else:
logger.warning("Invalid image dimensions: %d x %d, expected %d x %d" % (imwidth, imheight, self.width, self.height))
# Convert the soruce image to the 7 colors, dithering if needed
image_4color = image_temp.convert("RGB").quantize(palette=pal_image)
buf_4color = bytearray(image_4color.tobytes('raw'))
# into a single byte to transfer to the panel
buf = [0x00] * int(self.width * self.height / 4)
idx = 0
for i in range(0, len(buf_4color), 4):
buf[idx] = (buf_4color[i] << 6) + (buf_4color[i+1] << 4) + (buf_4color[i+2] << 2) + buf_4color[i+3]
idx += 1
return buf
def display(self, image):
if self.width % 4 == 0 :
Width = self.width // 4
else :
Width = self.width // 4 + 1
Height = self.height
self.send_command(0x68)
self.send_data(0x01)
self.send_command(0x04)
self.ReadBusyH()
self.send_command(0x10)
for j in range(0, Height):
for i in range(0, Width):
self.send_data(image[i + j * Width])
self.TurnOnDisplay()
def Clear(self, color):
if self.width % 4 == 0 :
Width = self.width // 4
else :
Width = self.width // 4 + 1
Height = self.height
self.send_command(0x68)
self.send_data(0x01)
self.send_command(0x04)
self.ReadBusyH()
self.send_command(0x10)
for j in range(0, Height):
for i in range(0, Width):
for k in range(0, 4):
self.send_data(color)
self.send_command(0x68)
self.send_data(0x00)
self.TurnOnDisplay()
def sleep(self):
self.send_command(0x02) # POWER_OFF
self.send_data(0x00)
self.send_command(0x07) # DEEP_SLEEP
self.send_data(0XA5)
epdconfig.delay_ms(2000)
epdconfig.module_exit()
### END OF FILE ###

473
RaspberryPi_JetsonNano/python/lib/waveshare_epd/epd3in52.py Normal file
View file

@ -0,0 +1,473 @@
# *****************************************************************************
# * | File : epd3in52.py
# * | Author : Waveshare team
# * | Function : Electronic paper driver
# * | Info :
# *----------------
# * | This version: V1.0
# * | Date : 2022-07-20
# # | Info : python demo
# -----------------------------------------------------------------------------
# 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.
#
import logging
from multiprocessing.reduction import recv_handle
from . import epdconfig
# Display resolution
EPD_width = 240
EPD_height = 360
logger = logging.getLogger(__name__)
class EPD:
def __init__(self):
self.reset_pin = epdconfig.RST_PIN
self.dc_pin = epdconfig.DC_PIN
self.busy_pin = epdconfig.BUSY_PIN
self.cs_pin = epdconfig.CS_PIN
self.width = EPD_width
self.height = EPD_height
self.Flag = 0
self.WHITE = 0xFF
self.BLACK = 0x00
self.Source_Line = 0xAA
self.Gate_Line = 0x55
self.UP_BLACK_DOWN_WHITE = 0xF0
self.LEFT_BLACK_RIGHT_WHITE = 0x0F
self.Frame = 0x01
self.Crosstalk = 0x02
self.Chessboard = 0x03
self.Image = 0x04
# GC 0.9S
lut_R20_GC = [
0x01,0x0f,0x0f,0x0f,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_R21_GC = [
0x01,0x4f,0x8f,0x0f,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_R22_GC = [
0x01,0x0f,0x8f,0x0f,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_R23_GC = [
0x01,0x4f,0x8f,0x4f,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_R24_GC = [
0x01,0x0f,0x8f,0x4f,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
# DU 0.3s
lut_R20_DU = [
0x01,0x0f,0x01,0x00,0x00,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_R21_DU = [
0x01,0x0f,0x01,0x00,0x00,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_R22_DU = [
0x01,0x8f,0x01,0x00,0x00,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_R23_DU = [
0x01,0x4f,0x01,0x00,0x00,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_R24_DU = [
0x01,0x0f,0x01,0x00,0x00,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_vcom = [
0x01,0x19,0x19,0x19,0x19,0x01,0x01,
0x01,0x19,0x19,0x19,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_ww = [
0x01,0x59,0x99,0x59,0x99,0x01,0x01,
0x01,0x59,0x99,0x19,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_bw = [
0x01,0x59,0x99,0x59,0x99,0x01,0x01,
0x01,0x59,0x99,0x19,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_wb = [
0x01,0x19,0x99,0x59,0x99,0x01,0x01,
0x01,0x59,0x99,0x59,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
lut_bb = [
0x01,0x19,0x99,0x59,0x99,0x01,0x01,
0x01,0x59,0x99,0x59,0x01,0x01,0x01,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00
]
# Hardware reset
def reset(self):
epdconfig.digital_write(self.reset_pin, 1)
epdconfig.delay_ms(200)
epdconfig.digital_write(self.reset_pin, 0)
epdconfig.delay_ms(5)
epdconfig.digital_write(self.reset_pin, 1)
epdconfig.delay_ms(200)
def send_command(self, command):
epdconfig.digital_write(self.dc_pin, 0)
epdconfig.digital_write(self.cs_pin, 0)
epdconfig.spi_writebyte([command])
epdconfig.digital_write(self.cs_pin, 1)
def send_data(self, data):
epdconfig.digital_write(self.dc_pin, 1)
epdconfig.digital_write(self.cs_pin, 0)
epdconfig.spi_writebyte([data])
epdconfig.digital_write(self.cs_pin, 1)
def ReadBusy(self):
logger.debug("e-Paper busy")
while(epdconfig.digital_read(self.busy_pin) == 0): # 0: busy, 1: idle
epdconfig.delay_ms(5)
logger.debug("e-Paper busy release")
def lut(self) :
self.send_command(0x20) # vcom
for count in range(0 ,42):
self.send_data(self.lut_vcom[count])
self.send_command(0x21) # ww --
for count in range(0 ,42):
self.send_data(self.lut_ww[count])
self.send_command(0x22) # bw r
for count in range(0 ,42):
self.send_data(self.lut_bw[count])
self.send_command(0x23) # wb w
for count in range(0 ,42):
self.send_data(self.lut_bb[count])
self.send_command(0x24) # bb b
for count in range(0 ,42):
self.send_data(self.lut_wb[count])
def refresh(self):
self.send_command(0x17)
self.send_data(0xA5)
self.ReadBusy()
epdconfig.delay_ms(200)
# LUT download
def lut_GC(self):
self.send_command(0x20); # vcom
for count in range(0 ,56):
self.send_data(self.lut_R20_GC[count])
self.send_command(0x21); # red not use
for count in range(0 ,42):
self.send_data(self.lut_R21_GC[count])
self.send_command(0x24); # bb b
for count in range(0 ,42):
self.send_data(self.lut_R24_GC[count])
if(self.Flag == 0) :
self.send_command(0x22); # bw r
for count in range(0 ,56):
self.send_data(self.lut_R22_GC[count])
self.send_command(0x23); # wb w
for count in range(0 ,42):
self.send_data(self.lut_R23_GC[count])
self.Flag = 1
else :
self.send_command(0x22); # bw r
for count in range(0 ,56):
self.send_data(self.lut_R23_GC[count])
self.send_command(0x23); # wb w
for count in range(0 ,42):
self.send_data(self.lut_R22_GC[count])
self.Flag = 0
# LUT download
def lut_DU(self):
self.send_command(0x20); # vcom
for count in range(0 ,56):
self.send_data(self.lut_R20_DU[count])
self.send_command(0x21); # red not use
for count in range(0 ,42):
self.send_data(self.lut_R21_DU[count])
self.send_command(0x24); # bb b
for count in range(0 ,42):
self.send_data(self.lut_R24_DU[count])
if(self.Flag == 0) :
self.send_command(0x22); # bw r
for count in range(0 ,56):
self.send_data(self.lut_R22_DU[count])
self.send_command(0x23); # wb w
for count in range(0 ,42):
self.send_data(self.lut_R23_DU[count])
self.Flag = 1
else :
self.send_command(0x22); # bw r
for count in range(0 ,56):
self.send_data(self.lut_R23_DU[count])
self.send_command(0x23); # wb w
for count in range(0 ,42):
self.send_data(self.lut_R22_DU[count])
self.Flag = 0
def init(self):
if (epdconfig.module_init() != 0):
return -1
# EPD hardware init start
self.Flag = 0
self.reset()
self.send_command(0x00) # panel setting PSR
self.send_data(0xFF) # RES1 RES0 REG KW/R UD SHL SHD_N RST_N
self.send_data(0x01) # x x x VCMZ TS_AUTO TIGE NORG VC_LUTZ
self.send_command(0x01) # POWER SETTING PWR
self.send_data(0x03) # x x x x x x VDS_EN VDG_EN
self.send_data(0x10) # x x x VCOM_SLWE VGH[3:0] VGH=20V, VGL=-20V
self.send_data(0x3F) # x x VSH[5:0] VSH = 15V
self.send_data(0x3F) # x x VSL[5:0] VSL=-15V
self.send_data(0x03) # OPTEN VDHR[6:0] VHDR=6.4V
# T_VDS_OFF[1:0] 00=1 frame; 01=2 frame; 10=3 frame; 11=4 frame
self.send_command(0x06) # booster soft start BTST
self.send_data(0x37) # BT_PHA[7:0]
self.send_data(0x3D) # BT_PHB[7:0]
self.send_data(0x3D) # x x BT_PHC[5:0]
self.send_command(0x60) # TCON setting TCON
self.send_data(0x22) # S2G[3:0] G2S[3:0] non-overlap = 12
self.send_command(0x82) # VCOM_DC setting VDCS
self.send_data(0x07) # x VDCS[6:0] VCOM_DC value= -1.9v 00~3f,0x12=-1.9v
self.send_command(0x30)
self.send_data(0x09)
self.send_command(0xe3) # power saving PWS
self.send_data(0x88) # VCOM_W[3:0] SD_W[3:0]
self.send_command(0x61) # resoultion setting
self.send_data(0xf0) # HRES[7:3] 0 0 0
self.send_data(0x01) # x x x x x x x VRES[8]
self.send_data(0x68) # VRES[7:0]
self.send_command(0x50);
self.send_data(0xB7);
return 0
def getbuffer(self, image):
# logger.debug("bufsiz = ",int(self.width/8) * self.height)
buf = [0xFF] * (int(self.width/8) * self.height)
image_monocolor = image.convert('1')
imwidth, imheight = image_monocolor.size
pixels = image_monocolor.load()
# logger.debug("imwidth = %d, imheight = %d",imwidth,imheight)
if(imwidth == self.width and imheight == self.height):
logger.debug("Vertical")
for y in range(imheight):
for x in range(imwidth):
# Set the bits for the column of pixels at the current position.
if pixels[x, y] == 0:
buf[int((x + y * self.width) / 8)] &= ~(0x80 >> (x % 8))
elif(imwidth == self.height and imheight == self.width):
logger.debug("Horizontal")
for y in range(imheight):
for x in range(imwidth):
newx = y
newy = self.height - x - 1
if pixels[x, y] == 0:
buf[int((newx + newy*self.width) / 8)] &= ~(0x80 >> (y % 8))
return buf
def display(self, image):
if (image == None):
return
self.send_command(0x13); # Transfer new data
for i in range(0, self.width * self.height / 8) :
self.send_data(image[i])
def display_NUM(self, NUM):
# pcnt = 0
self.send_command(0x13); #Transfer new data
for column in range(0, self.height):
for row in range(0, self.width/8):
if NUM == self.WHITE:
self.send_data(0xFF)
elif NUM == self.BLACK:
self.send_data(0x00)
elif NUM == self.Source_Line:
self.send_data(0xAA)
elif NUM == self.Gate_Line:
if(column%2):
self.send_data(0xff) # An odd number of Gate line
else:
self.send_data(0x00) # The even line Gate
elif NUM == self.Chessboard:
if(row>=(self.width/8/2) and column>=(self.height/2)):
self.send_data(0xff)
elif(row<(self.width/8/2) and column<(self.height/2)):
self.send_data(0xff)
else:
self.send_data(0x00)
elif NUM == self.LEFT_BLACK_RIGHT_WHITE:
if(row>=(self.width/8/2)):
self.send_data(0xff)
else:
self.send_data(0x00)
elif NUM == self.UP_BLACK_DOWN_WHITE:
if(column>=(self.height/2)):
self.send_data(0xFF)
else:
self.send_data(0x00)
elif NUM == self.Frame:
if(column==0 or column==(self.height-1)):
self.send_data(0x00)
elif(row==0):
self.send_data(0x7F)
elif(row==(self.width/8-1)):
self.send_data(0xFE);
else:
self.send_data(0xFF);
elif NUM == self.Crosstalk:
if((row>=(self.width/8/3) and row<=(self.width/8/3*2) and column<=(self.height/3)) or (row>=(self.width/8/3) and row<=(self.width/8/3*2) and column>=(self.height/3*2))):
self.send_data(0x00)
else:
self.send_data(0xFF)
elif NUM == self.Image:
epdconfig.delay_ms(1)
# self.send_data(gImage_1[pcnt++])
def Clear(self):
self.send_command(0x13); # Transfer new data
for i in range(0, self.width * self.height / 8) :
self.send_data(0xFF)
self.lut_GC()
self.refresh()
def sleep(self):
self.send_command(0X07) # DEEP_SLEEP_MODE
self.send_data(0xA5)
epdconfig.delay_ms(2000)
epdconfig.module_exit()
### END OF FILE ###

263
RaspberryPi_JetsonNano/python/lib/waveshare_epd/epd7in3g.py Normal file
View file

@ -0,0 +1,263 @@
# *****************************************************************************
# * | File : epd7in3g.py
# * | Author : Waveshare team
# * | Function : Electronic paper driver
# * | Info :
# *----------------
# * | This version: V1
# * | Date : 2022-07-20
# # | Info : python demo
# -----------------------------------------------------------------------------
# ******************************************************************************/
# 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.
#
import logging
from . import epdconfig
import PIL
from PIL import Image
import io
# Display resolution
EPD_WIDTH = 800
EPD_HEIGHT = 480
logger = logging.getLogger(__name__)
class EPD:
def __init__(self):
self.reset_pin = epdconfig.RST_PIN
self.dc_pin = epdconfig.DC_PIN
self.busy_pin = epdconfig.BUSY_PIN
self.cs_pin = epdconfig.CS_PIN
self.width = EPD_WIDTH
self.height = EPD_HEIGHT
self.BLACK = 0x000000 # 00 BGR
self.WHITE = 0xffffff # 01
self.YELLOW = 0x00ffff # 10
self.RED = 0x0000ff # 11
# Hardware reset
def reset(self):
epdconfig.digital_write(self.reset_pin, 1)
epdconfig.delay_ms(200)
epdconfig.digital_write(self.reset_pin, 0) # module reset
epdconfig.delay_ms(2)
epdconfig.digital_write(self.reset_pin, 1)
epdconfig.delay_ms(200)
def send_command(self, command):
epdconfig.digital_write(self.dc_pin, 0)
epdconfig.digital_write(self.cs_pin, 0)
epdconfig.spi_writebyte([command])
epdconfig.digital_write(self.cs_pin, 1)
def send_data(self, data):
epdconfig.digital_write(self.dc_pin, 1)
epdconfig.digital_write(self.cs_pin, 0)
epdconfig.spi_writebyte([data])
epdconfig.digital_write(self.cs_pin, 1)
def ReadBusyH(self):
logger.debug("e-Paper busy H")
while(epdconfig.digital_read(self.busy_pin) == 0): # 0: idle, 1: busy
epdconfig.delay_ms(5)
logger.debug("e-Paper busy H release")
def ReadBusyL(self):
logger.debug("e-Paper busy L")
while(epdconfig.digital_read(self.busy_pin) == 1): # 0: busy, 1: idle
epdconfig.delay_ms(5)
logger.debug("e-Paper busy L release")
def TurnOnDisplay(self):
self.send_command(0x12) # DISPLAY_REFRESH
self.send_data(0x01)
self.ReadBusyH()
self.send_command(0x02) # POWER_OFF
self.send_data(0X00)
self.ReadBusyH()
def init(self):
if (epdconfig.module_init() != 0):
return -1
# EPD hardware init start
self.reset()
self.ReadBusyH()
epdconfig.delay_ms(30)
self.send_command(0xAA)
self.send_data(0x49)
self.send_data(0x55)
self.send_data(0x20)
self.send_data(0x08)
self.send_data(0x09)
self.send_data(0x18)
self.send_command(0x01)
self.send_data(0x3F)
self.send_command(0x00)
self.send_data(0x4F)
self.send_data(0x69)
self.send_command(0x05)
self.send_data(0x40)
self.send_data(0x1F)
self.send_data(0x1F)
self.send_data(0x2C)
self.send_command(0x08)
self.send_data(0x6F)
self.send_data(0x1F)
self.send_data(0x1F)
self.send_data(0x22)
# ===================
# 20211212
# First setting
self.send_command(0x06)
self.send_data(0x6F)
self.send_data(0x1F)
self.send_data(0x14)
self.send_data(0x14)
# ===================
self.send_command(0x03)
self.send_data(0x00)
self.send_data(0x54)
self.send_data(0x00)
self.send_data(0x44)
self.send_command(0x60)
self.send_data(0x02)
self.send_data(0x00)
# Please notice that PLL must be set for version 2 IC
self.send_command(0x30)
self.send_data(0x08)
self.send_command(0x50)
self.send_data(0x3F)
self.send_command(0x61)
self.send_data(0x03)
self.send_data(0x20)
self.send_data(0x01)
self.send_data(0xE0)
self.send_command(0xE3)
self.send_data(0x2F)
self.send_command(0x84)
self.send_data(0x01)
return 0
def getbuffer(self, image):
# Create a pallette with the 4 colors supported by the panel
pal_image = Image.new("P", (1,1))
pal_image.putpalette( (0,0,0, 255,255,255, 255,255,0, 255,0,0) + (0,0,0)*252)
# Check if we need to rotate the image
imwidth, imheight = image.size
if(imwidth == self.width and imheight == self.height):
image_temp = image
elif(imwidth == self.height and imheight == self.width):
image_temp = image.rotate(90, expand=True)
else:
logger.warning("Invalid image dimensions: %d x %d, expected %d x %d" % (imwidth, imheight, self.width, self.height))
# Convert the soruce image to the 4 colors, dithering if needed
image_4color = image_temp.convert("RGB").quantize(palette=pal_image)
buf_4color = bytearray(image_4color.tobytes('raw'))
# into a single byte to transfer to the panel
buf = [0x00] * int(self.width * self.height / 4)
idx = 0
for i in range(0, len(buf_4color), 4):
buf[idx] = (buf_4color[i] << 6) + (buf_4color[i+1] << 4) + (buf_4color[i+2] << 2) + buf_4color[i+3]
idx += 1
return buf
def display(self, image):
if self.width % 4 == 0 :
Width = self.width // 4
else :
Width = self.width // 4 + 1
Height = self.height
self.send_command(0x68)
self.send_data(0x01)
self.send_command(0x04)
self.ReadBusyH()
self.send_command(0x10)
for j in range(0, Height):
for i in range(0, Width):
self.send_data(image[i + j * Width])
self.TurnOnDisplay()
def Clear(self, color):
if self.width % 4 == 0 :
Width = self.width // 4
else :
Width = self.width // 4 + 1
Height = self.height
self.send_command(0x68)
self.send_data(0x01)
self.send_command(0x04)
self.ReadBusyH()
self.send_command(0x10)
for j in range(0, Height):
for i in range(0, Width):
for k in range(0, 4):
self.send_data(color)
self.send_command(0x68)
self.send_data(0x00)
self.TurnOnDisplay()
def sleep(self):
self.send_command(0x02) # POWER_OFF
self.send_data(0x00)
self.send_command(0x07) # DEEP_SLEEP
self.send_data(0XA5)
epdconfig.delay_ms(2000)
epdconfig.module_exit()
### END OF FILE ###

BIN
RaspberryPi_JetsonNano/python/pic/1.64inch-1.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 83 KiB

BIN
RaspberryPi_JetsonNano/python/pic/1.64inch-2.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 83 KiB

BIN
RaspberryPi_JetsonNano/python/pic/3in52-1.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 11 KiB

BIN
RaspberryPi_JetsonNano/python/pic/3in52-2.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 11 KiB

BIN
RaspberryPi_JetsonNano/python/pic/3in52-3.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 11 KiB

BIN
RaspberryPi_JetsonNano/python/pic/3inch-1.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 197 KiB

BIN
RaspberryPi_JetsonNano/python/pic/3inch-2.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 197 KiB

BIN
RaspberryPi_JetsonNano/python/pic/3inch-3.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 197 KiB

BIN
RaspberryPi_JetsonNano/python/pic/7.3inch-1.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 1.1 MiB

BIN
RaspberryPi_JetsonNano/python/pic/7.3inch-2.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 1.1 MiB

BIN
RaspberryPi_JetsonNano/python/pic/7.3inch-3.bmp Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 1.1 MiB

4
Version_CN.txt
View file

@ -27,3 +27,7 @@
2021-07-19：1.54V2、2.13V3、2.9V2、7.5V2程序均采用外部波形，并提升了刷新速度
2021-11-01：添加新程序2.13inch V3 e-Paper例程。
2022-04-26：添加新程序2.13inch B V4 e-Paper例程。
2022-07-22：添加新程序1.64inch (G) e-Paper例程。
2022-07-22：添加新程序3inch (G) e-Paper例程。
2022-07-22：添加新程序7.3inch (G) e-Paper例程。
2022-07-22：添加新程序3.52inch e-Paper例程。

4
Version_EN.txt
View file

@ -26,3 +26,7 @@
2021-07-19: 1.54v2, 2.13v3, 2.9v2, and 7.5v2 programs all use external waveforms and have improved refresh speed.
2021-11-01: Added new program 2.13inch V3 e-Paper routine.
2022-04-26: Added new program 2.13inch B V4 e-Paper routine.
2022-07-22: Added new programs 1.64inch (G) e-Paper routine.
2022-07-22: Added new programs 3inch (G) e-Paper routine.
2022-07-22: Added new programs 7.3inch (G) e-Paper routine.
2022-07-22: Added new programs 3.52inch e-Paper routine.