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

RaspberryPi_JetsonNano/c/examples/EPD_1in64g_test.c

@@ -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, "΢ѩ����", &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;
+}
+

RaspberryPi_JetsonNano/c/examples/EPD_3in0g_test.c

@@ -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, "΢ѩ����", &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;
+}
+

RaspberryPi_JetsonNano/c/examples/EPD_3in52_test.c

@@ -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;
+}
+

RaspberryPi_JetsonNano/c/examples/EPD_7in3g_test.c

@@ -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, "΢ѩ����", &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;
+}
+

RaspberryPi_JetsonNano/c/examples/EPD_Test.h

@@ -1,11 +1,11 @@
 /*****************************************************************************
-* | File      	:	  EPD_Test.h
+* | File      	:	EPD_Test.h
 * | Author      :   Waveshare team
 * | 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);

RaspberryPi_JetsonNano/c/examples/main.c

@@ -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();

RaspberryPi_JetsonNano/c/lib/GUI/GUI_BMPfile.c

@@ -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):
@@ -149,7 +151,7 @@ UBYTE GUI_ReadBmp_4Gray(const char *path, UWORD Xstart, UWORD Ystart)
         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
@@ -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;
+}
+
 

RaspberryPi_JetsonNano/c/lib/GUI/GUI_BMPfile.h

@@ -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

RaspberryPi_JetsonNano/c/lib/GUI/GUI_Paint.h

@@ -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
 **/

RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in64g.c

@@ -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);
+}
+

RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in64g.h

@@ -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

RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_3in0g.c

@@ -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);
+}
+

RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_3in0g.h

@@ -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

RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_3in52.c

@@ -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);
+}
+
+
+

RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_3in52.h

@@ -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

RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in3g.c

@@ -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);
+}
+

RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in3g.h

@@ -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

RaspberryPi_JetsonNano/python/examples/epd_1in64g_test.py

@@ -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()

RaspberryPi_JetsonNano/python/examples/epd_3in0g_test.py

@@ -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()

RaspberryPi_JetsonNano/python/examples/epd_3in52_test.py

@@ -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()

RaspberryPi_JetsonNano/python/examples/epd_7in3g_test.py

@@ -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()

RaspberryPi_JetsonNano/python/lib/waveshare_epd/epd1in64g.py

@@ -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 ###
+

RaspberryPi_JetsonNano/python/lib/waveshare_epd/epd3in0g.py

@@ -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 ###
+

RaspberryPi_JetsonNano/python/lib/waveshare_epd/epd3in52.py

@@ -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 ###
+

RaspberryPi_JetsonNano/python/lib/waveshare_epd/epd7in3g.py

@@ -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 ###
+

Version_CN.txt

@@ -26,4 +26,8 @@
 2021-02-22：添加新程序2.7inch B V2 e-Paper例程。
 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-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例程。

Version_EN.txt

@@ -25,4 +25,8 @@
 2021-02-22: Added new program 2.7inch B V2 e-Paper routine.
 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-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.