iicd/Inkycal
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
3d691837a8d81bd45d9038731d8485e1d4a15e4e
Inkycal/inkycal/display/drivers/parallel_drivers/examples/example.c

892 lines
34 KiB
C
Raw Normal View History

modify parallel epd run file
2022-04-10 02:27:44 +02:00
#include "example.h"
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include "../lib/e-Paper/EPD_IT8951.h"
#include "../lib/GUI/GUI_Paint.h"
#include "../lib/GUI/GUI_BMPfile.h"
#include "../lib/Config/Debug.h"
UBYTE *Refresh_Frame_Buf = NULL;
UBYTE *Panel_Frame_Buf = NULL;
UBYTE *Panel_Area_Frame_Buf = NULL;
bool Four_Byte_Align = false;
extern int epd_mode;
extern UWORD VCOM;
extern UBYTE isColor;
/******************************************************************************
function: Change direction of display, Called after Paint_NewImage()
parameter:
mode: display mode
******************************************************************************/
static void Epd_Mode(int mode)
{
if(mode == 3) {
Paint_SetRotate(ROTATE_0);
Paint_SetMirroring(MIRROR_NONE);
isColor = 1;
}else if(mode == 2) {
Paint_SetRotate(ROTATE_0);
Paint_SetMirroring(MIRROR_HORIZONTAL);
}else if(mode == 1) {
Paint_SetRotate(ROTATE_0);
Paint_SetMirroring(MIRROR_HORIZONTAL);
}else {
Paint_SetRotate(ROTATE_0);
Paint_SetMirroring(MIRROR_NONE);
}
}
/******************************************************************************
function: Display_ColorPalette_Example
parameter:
Panel_Width: Width of the panel
Panel_Height: Height of the panel
Init_Target_Memory_Addr: Memory address of IT8951 target memory address
******************************************************************************/
UBYTE Display_ColorPalette_Example(UWORD Panel_Width, UWORD Panel_Height, UDOUBLE Init_Target_Memory_Addr){
UWORD In_4bp_Refresh_Area_Width;
if(Four_Byte_Align == true){
In_4bp_Refresh_Area_Width = Panel_Width - (Panel_Width % 32);
}else{
In_4bp_Refresh_Area_Width = Panel_Width;
}
UWORD In_4bp_Refresh_Area_Height = Panel_Height/16;
UDOUBLE Imagesize;
clock_t In_4bp_Refresh_Start, In_4bp_Refresh_Finish;
double In_4bp_Refresh_Duration;
Imagesize = ((In_4bp_Refresh_Area_Width*4 % 8 == 0)? (In_4bp_Refresh_Area_Width*4 / 8 ): (In_4bp_Refresh_Area_Width*4 / 8 + 1)) * In_4bp_Refresh_Area_Height;
if((Refresh_Frame_Buf = (UBYTE *)malloc(Imagesize)) == NULL) {
Debug("Failed to apply for black memory...\r\n");
return -1;
}
Debug("Start to demostrate 4bpp palette example\r\n");
In_4bp_Refresh_Start = clock();
UBYTE SixteenColorPattern[16] = {0xFF,0xEE,0xDD,0xCC,0xBB,0xAA,0x99,0x88,0x77,0x66,0x55,0x44,0x33,0x22,0x11,0x00};
for(int i=0; i < 16; i++){
memset(Refresh_Frame_Buf, SixteenColorPattern[i], Imagesize);
EPD_IT8951_4bp_Refresh(Refresh_Frame_Buf, 0, i * In_4bp_Refresh_Area_Height, In_4bp_Refresh_Area_Width, In_4bp_Refresh_Area_Height, false, Init_Target_Memory_Addr, false);
}
In_4bp_Refresh_Finish = clock();
In_4bp_Refresh_Duration = (double)(In_4bp_Refresh_Finish - In_4bp_Refresh_Start) / CLOCKS_PER_SEC;
Debug( "Write and Show 4bp occupy %f second\n", In_4bp_Refresh_Duration );
if(Refresh_Frame_Buf != NULL){
free(Refresh_Frame_Buf);
Refresh_Frame_Buf = NULL;
}
return 0;
}
/******************************************************************************
function: Display_CharacterPattern_Example
parameter:
Panel_Width: Width of the panel
Panel_Height: Height of the panel
Init_Target_Memory_Addr: Memory address of IT8951 target memory address
BitsPerPixel: Bits Per Pixel, 2^BitsPerPixel = grayscale
******************************************************************************/
UBYTE Display_CharacterPattern_Example(UWORD Panel_Width, UWORD Panel_Height, UDOUBLE Init_Target_Memory_Addr, UBYTE BitsPerPixel){
UWORD Display_Area_Width;
if(Four_Byte_Align == true){
Display_Area_Width = Panel_Width - (Panel_Width % 32);
}else{
Display_Area_Width = Panel_Width;
}
UWORD Display_Area_Height = Panel_Height;
UWORD Display_Area_Sub_Width = Display_Area_Width / 5;
UWORD Display_Area_Sub_Height = Display_Area_Height / 5;
UDOUBLE Imagesize;
Imagesize = ((Display_Area_Width * BitsPerPixel % 8 == 0)? (Display_Area_Width * BitsPerPixel / 8 ): (Display_Area_Width * BitsPerPixel / 8 + 1)) * Display_Area_Height;
if((Refresh_Frame_Buf = (UBYTE *)malloc(Imagesize)) == NULL) {
Debug("Failed to apply for image memory...\r\n");
return -1;
}
Paint_NewImage(Refresh_Frame_Buf, Display_Area_Width, Display_Area_Height, 0, BLACK);
Paint_SelectImage(Refresh_Frame_Buf);
Epd_Mode(epd_mode);
Paint_SetBitsPerPixel(BitsPerPixel);
Paint_Clear(WHITE);
for(int y=20; y<Display_Area_Height - Display_Area_Sub_Height; y += Display_Area_Sub_Height )//To prevent arrays from going out of bounds
{
for(int x=20; x<Display_Area_Width - Display_Area_Sub_Width; x += Display_Area_Sub_Width )//To prevent arrays from going out of bounds
{
//For color definition of all BitsPerPixel, you can refer to GUI_Paint.h
Paint_DrawPoint(x+Display_Area_Sub_Width*3/8, y+Display_Area_Sub_Height*3/8, 0x10, DOT_PIXEL_7X7, DOT_STYLE_DFT);
Paint_DrawPoint(x+Display_Area_Sub_Width*5/8, y+Display_Area_Sub_Height*3/8, 0x30, DOT_PIXEL_7X7, DOT_STYLE_DFT);
Paint_DrawLine(x+Display_Area_Sub_Width*3/8, y+Display_Area_Sub_Height*5/8, x+Display_Area_Sub_Width*5/8, y+Display_Area_Sub_Height*5/8, 0x50, DOT_PIXEL_3X3, LINE_STYLE_SOLID);
Paint_DrawRectangle(x, y, x+Display_Area_Sub_Width, y+Display_Area_Sub_Height, 0x00, DOT_PIXEL_3X3, DRAW_FILL_EMPTY);
Paint_DrawCircle(x + Display_Area_Sub_Width/2, y + Display_Area_Sub_Height/2, Display_Area_Sub_Height/2, 0x50, DOT_PIXEL_2X2, DRAW_FILL_EMPTY);
Paint_DrawNum(x+Display_Area_Sub_Width*3/10, y+Display_Area_Sub_Height*1/4, 1234567890, &Font16, 0x20, 0xE0);
Paint_DrawString_EN(x+Display_Area_Sub_Width*3/10, y+Display_Area_Sub_Height*3/4, "hello world", &Font16, 0x30, 0xD0);
}
}
switch(BitsPerPixel){
case BitsPerPixel_8:{
EPD_IT8951_8bp_Refresh(Refresh_Frame_Buf, 0, 0, Display_Area_Width, Display_Area_Height, false, Init_Target_Memory_Addr);
break;
}
case BitsPerPixel_4:{
EPD_IT8951_4bp_Refresh(Refresh_Frame_Buf, 0, 0, Display_Area_Width, Display_Area_Height, false, Init_Target_Memory_Addr,false);
break;
}
case BitsPerPixel_2:{
EPD_IT8951_2bp_Refresh(Refresh_Frame_Buf, 0, 0, Display_Area_Width, Display_Area_Height, false, Init_Target_Memory_Addr,false);
break;
}
case BitsPerPixel_1:{
EPD_IT8951_1bp_Refresh(Refresh_Frame_Buf, 0, 0, Display_Area_Width, Display_Area_Height, A2_Mode, Init_Target_Memory_Addr,false);
break;
}
}
if(Refresh_Frame_Buf != NULL){
free(Refresh_Frame_Buf);
Refresh_Frame_Buf = NULL;
}
return 0;
}
/******************************************************************************
function: Display_BMP_Example
parameter:
Panel_Width: Width of the panel
Panel_Height: Height of the panel
Init_Target_Memory_Addr: Memory address of IT8951 target memory address
BitsPerPixel: Bits Per Pixel, 2^BitsPerPixel = grayscale
******************************************************************************/
UBYTE Display_BMP_Example(UWORD Panel_Width, UWORD Panel_Height, UDOUBLE Init_Target_Memory_Addr, UBYTE BitsPerPixel, char *Path){
UWORD WIDTH;
if(Four_Byte_Align == true){
WIDTH = Panel_Width - (Panel_Width % 32);
}else{
WIDTH = Panel_Width;
}
UWORD HEIGHT = Panel_Height;
UDOUBLE Imagesize;
Imagesize = ((WIDTH * BitsPerPixel % 8 == 0)? (WIDTH * BitsPerPixel / 8 ): (WIDTH * BitsPerPixel / 8 + 1)) * HEIGHT;
if((Refresh_Frame_Buf = (UBYTE *)malloc(Imagesize)) == NULL) {
Debug("Failed to apply for black memory...\r\n");
return -1;
}
Paint_NewImage(Refresh_Frame_Buf, WIDTH, HEIGHT, 0, BLACK);
Paint_SelectImage(Refresh_Frame_Buf);
Epd_Mode(epd_mode);
Paint_SetBitsPerPixel(BitsPerPixel);
Paint_Clear(WHITE);
// sprintf(Path,"./pic/%dx%d_0.bmp", WIDTH, HEIGHT);
GUI_ReadBmp(Path, 0, 0);
//you can draw your character and pattern on the image, for color definition of all BitsPerPixel, you can refer to GUI_Paint.h,
//Paint_DrawRectangle(50, 50, WIDTH/2, HEIGHT/2, 0x30, DOT_PIXEL_3X3, DRAW_FILL_EMPTY);
//Paint_DrawCircle(WIDTH*3/4, HEIGHT/4, 100, 0xF0, DOT_PIXEL_2X2, DRAW_FILL_EMPTY);
//Paint_DrawNum(WIDTH/4, HEIGHT/5, 709, &Font20, 0x30, 0xB0);
switch(BitsPerPixel){
case BitsPerPixel_8:{
Paint_DrawString_EN(10, 10, "8 bits per pixel 16 grayscale", &Font24, 0xF0, 0x00);
EPD_IT8951_8bp_Refresh(Refresh_Frame_Buf, 0, 0, WIDTH, HEIGHT, false, Init_Target_Memory_Addr);
break;
}
case BitsPerPixel_4:{
add tests for parallel displays
2022-04-10 04:24:42 +02:00
//Paint_DrawString_EN(10, 10, "4 bits per pixel 16 grayscale", &Font24, 0xF0, 0x00);
modify parallel epd run file
2022-04-10 02:27:44 +02:00
EPD_IT8951_4bp_Refresh(Refresh_Frame_Buf, 0, 0, WIDTH, HEIGHT, false, Init_Target_Memory_Addr,false);
break;
}
case BitsPerPixel_2:{
Paint_DrawString_EN(10, 10, "2 bits per pixel 4 grayscale", &Font24, 0xC0, 0x00);
EPD_IT8951_2bp_Refresh(Refresh_Frame_Buf, 0, 0, WIDTH, HEIGHT, false, Init_Target_Memory_Addr,false);
break;
}
case BitsPerPixel_1:{
Paint_DrawString_EN(10, 10, "1 bit per pixel 2 grayscale", &Font24, 0x80, 0x00);
EPD_IT8951_1bp_Refresh(Refresh_Frame_Buf, 0, 0, WIDTH, HEIGHT, A2_Mode, Init_Target_Memory_Addr,false);
break;
}
}
if(Refresh_Frame_Buf != NULL){
free(Refresh_Frame_Buf);
Refresh_Frame_Buf = NULL;
}
DEV_Delay_ms(5000);
return 0;
}
/******************************************************************************
function: Dynamic_Refresh_Example
parameter:
Dev_Info: Information structure read from IT8951
Init_Target_Memory_Addr: Memory address of IT8951 target memory address
******************************************************************************/
UBYTE Dynamic_Refresh_Example(IT8951_Dev_Info Dev_Info, UDOUBLE Init_Target_Memory_Addr){
UWORD Panel_Width = Dev_Info.Panel_W;
UWORD Panel_Height = Dev_Info.Panel_H;
UWORD Dynamic_Area_Width = 96;
UWORD Dynamic_Area_Height = 48;
UDOUBLE Imagesize;
UWORD Start_X = 0,Start_Y = 0;
UWORD Dynamic_Area_Count = 0;
UWORD Repeat_Area_Times = 0;
//malloc enough memory for 1bp picture first
Imagesize = ((Panel_Width * 1 % 8 == 0)? (Panel_Width * 1 / 8 ): (Panel_Width * 1 / 8 + 1)) * Panel_Height;
if((Refresh_Frame_Buf = (UBYTE *)malloc(Imagesize)) == NULL){
Debug("Failed to apply for picture memory...\r\n");
return -1;
}
clock_t Dynamic_Area_Start, Dynamic_Area_Finish;
double Dynamic_Area_Duration;
while(1)
{
Dynamic_Area_Width = 128;
Dynamic_Area_Height = 96;
Start_X = 0;
Start_Y = 0;
Dynamic_Area_Count = 0;
Dynamic_Area_Start = clock();
Debug("Start to dynamic display...\r\n");
for(Dynamic_Area_Width = 96, Dynamic_Area_Height = 64; (Dynamic_Area_Width < Panel_Width - 32) && (Dynamic_Area_Height < Panel_Height - 24); Dynamic_Area_Width += 32, Dynamic_Area_Height += 24)
{
Imagesize = ((Dynamic_Area_Width % 8 == 0)? (Dynamic_Area_Width / 8 ): (Dynamic_Area_Width / 8 + 1)) * Dynamic_Area_Height;
Paint_NewImage(Refresh_Frame_Buf, Dynamic_Area_Width, Dynamic_Area_Height, 0, BLACK);
Paint_SelectImage(Refresh_Frame_Buf);
Epd_Mode(epd_mode);
Paint_SetBitsPerPixel(1);
for(int y=Start_Y; y< Panel_Height - Dynamic_Area_Height; y += Dynamic_Area_Height)
{
for(int x=Start_X; x< Panel_Width - Dynamic_Area_Width; x += Dynamic_Area_Width)
{
Paint_Clear(WHITE);
//For color definition of all BitsPerPixel, you can refer to GUI_Paint.h
Paint_DrawRectangle(0, 0, Dynamic_Area_Width-1, Dynamic_Area_Height, 0x00, DOT_PIXEL_2X2, DRAW_FILL_EMPTY);
Paint_DrawCircle(Dynamic_Area_Width*3/4, Dynamic_Area_Height*3/4, 5, 0x00, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawNum(Dynamic_Area_Width/4, Dynamic_Area_Height/4, ++Dynamic_Area_Count, &Font20, 0x00, 0xF0);
if(epd_mode == 2)
EPD_IT8951_1bp_Refresh(Refresh_Frame_Buf, 1280-Dynamic_Area_Width-x, y, Dynamic_Area_Width, Dynamic_Area_Height, A2_Mode, Init_Target_Memory_Addr, true);
else if(epd_mode == 1)
EPD_IT8951_1bp_Refresh(Refresh_Frame_Buf, Panel_Width-Dynamic_Area_Width-x-16, y, Dynamic_Area_Width, Dynamic_Area_Height, A2_Mode, Init_Target_Memory_Addr, true);
else
EPD_IT8951_1bp_Refresh(Refresh_Frame_Buf, x, y, Dynamic_Area_Width, Dynamic_Area_Height, A2_Mode, Init_Target_Memory_Addr, true);
}
}
Start_X += 32;
Start_Y += 24;
}
Dynamic_Area_Finish = clock();
Dynamic_Area_Duration = (double)(Dynamic_Area_Finish - Dynamic_Area_Start) / CLOCKS_PER_SEC;
Debug( "Write and Show occupy %f second\n", Dynamic_Area_Duration );
Repeat_Area_Times ++;
if(Repeat_Area_Times > 0){
break;
}
}
if(Refresh_Frame_Buf != NULL){
free(Refresh_Frame_Buf);
Refresh_Frame_Buf = NULL;
}
return 0;
}
/******************************************************************************
function: Dynamic_GIF_Example
parameter:
Panel_Width: Width of the panel
Panel_Height: Height of the panel
Init_Target_Memory_Addr: Memory address of IT8951 target memory address
BitsPerPixel: Bits Per Pixel, 2^BitsPerPixel = grayscale
******************************************************************************/
UBYTE Dynamic_GIF_Example(UWORD Panel_Width, UWORD Panel_Height, UDOUBLE Init_Target_Memory_Addr){
UWORD Animation_Start_X = 0;
UWORD Animation_Start_Y = 0;
UWORD Animation_Area_Width = 800;
UWORD Animation_Area_Height = 600;
if(Animation_Area_Width > Panel_Width){
return -1;
}
if(Animation_Area_Height > Panel_Height){
return -1;
}
UDOUBLE Imagesize;
UBYTE Pic_Count = 0;
UBYTE Pic_Num = 7;
char Path[30];
UDOUBLE Basical_Memory_Addr = Init_Target_Memory_Addr;
UDOUBLE Target_Memory_Addr = Basical_Memory_Addr;
UWORD Repeat_Animation_Times = 0;
clock_t Animation_Test_Start, Animation_Test_Finish;
double Animation_Test_Duration;
Imagesize = ((Animation_Area_Width * 1 % 8 == 0)? (Animation_Area_Width * 1 / 8 ): (Animation_Area_Width * 1 / 8 + 1)) * Animation_Area_Height;
if((Refresh_Frame_Buf = (UBYTE *)malloc(Imagesize)) == NULL){
Debug("Failed to apply for image memory...\r\n");
return -1;
}
Paint_NewImage(Refresh_Frame_Buf, Animation_Area_Width, Animation_Area_Height, 0, BLACK);
Paint_SelectImage(Refresh_Frame_Buf);
Epd_Mode(epd_mode);
Paint_SetBitsPerPixel(1);
Debug("Start to write a animation\r\n");
Animation_Test_Start = clock();
for(int i=0; i < Pic_Num; i += 1){
Paint_Clear(WHITE);
sprintf(Path,"./pic/800x600_gif_%d.bmp",Pic_Count++);
GUI_ReadBmp(Path, 0, 0);
//For color definition of all BitsPerPixel, you can refer to GUI_Paint.h
Paint_DrawNum(10, 10, i+1, &Font16, 0x00, 0xF0);
if(epd_mode == 2)
EPD_IT8951_1bp_Multi_Frame_Write(Refresh_Frame_Buf, 1280-Animation_Area_Width+Animation_Start_X, Animation_Start_Y, Animation_Area_Width, Animation_Area_Height, Target_Memory_Addr,false);
else if(epd_mode == 1)
EPD_IT8951_1bp_Multi_Frame_Write(Refresh_Frame_Buf, Panel_Width-Animation_Area_Width+Animation_Start_X-16, Animation_Start_Y, Animation_Area_Width, Animation_Area_Height, Target_Memory_Addr,false);
else
EPD_IT8951_1bp_Multi_Frame_Write(Refresh_Frame_Buf, Animation_Start_X, Animation_Start_Y, Animation_Area_Width, Animation_Area_Height, Target_Memory_Addr,false);
Target_Memory_Addr += Imagesize;
}
Animation_Test_Finish = clock();
Animation_Test_Duration = (double)(Animation_Test_Finish - Animation_Test_Start) / CLOCKS_PER_SEC;
Debug( "Write all frame occupy %f second\r\n", Animation_Test_Duration);
Target_Memory_Addr = Basical_Memory_Addr;
while(1){
Debug("Start to show a animation\r\n");
Animation_Test_Start = clock();
for(int i=0; i< Pic_Num; i += 1){
if(epd_mode == 2)
EPD_IT8951_1bp_Multi_Frame_Refresh(Panel_Width-Animation_Area_Width+Animation_Start_X, Animation_Start_Y, Animation_Area_Width, Animation_Area_Height, Target_Memory_Addr);
else if(epd_mode == 1)
EPD_IT8951_1bp_Multi_Frame_Refresh(Panel_Width-Animation_Area_Width+Animation_Start_X-16, Animation_Start_Y, Animation_Area_Width, Animation_Area_Height, Target_Memory_Addr);
else
EPD_IT8951_1bp_Multi_Frame_Refresh(Animation_Start_X, Animation_Start_Y, Animation_Area_Width, Animation_Area_Height, Target_Memory_Addr);
Target_Memory_Addr += Imagesize;
}
Target_Memory_Addr = Basical_Memory_Addr;
Animation_Test_Finish = clock();
Animation_Test_Duration = (double)(Animation_Test_Finish - Animation_Test_Start) / CLOCKS_PER_SEC;
Debug( "Show all frame occupy %f second\r\n", Animation_Test_Duration );
Repeat_Animation_Times ++;
if(Repeat_Animation_Times >15){
break;
}
}
if(Refresh_Frame_Buf != NULL){
free(Refresh_Frame_Buf);
Refresh_Frame_Buf = NULL;
}
return 0;
}
/******************************************************************************
function: Check_FrameRate_Example
parameter:
Panel_Width: Width of the panel
Panel_Height: Height of the panel
Init_Target_Memory_Addr: Memory address of IT8951 target memory address
BitsPerPixel: Bits Per Pixel, 2^BitsPerPixel = grayscale
******************************************************************************/
UBYTE Check_FrameRate_Example(UWORD Panel_Width, UWORD Panel_Height, UDOUBLE Target_Memory_Addr, UBYTE BitsPerPixel){
UWORD Frame_Rate_Test_Width;
if(Four_Byte_Align == true){
Frame_Rate_Test_Width = Panel_Width - (Panel_Width % 32);
}else{
Frame_Rate_Test_Width = Panel_Width;
}
UWORD Frame_Rate_Test_Height = Panel_Height;
UDOUBLE Imagesize;
UBYTE *Refresh_FrameRate_Buf = NULL;
UBYTE Count = 0;
clock_t Frame_Rate_Test_Start, Frame_Rate_Test_Finish;
double Frame_Rate_Test_Duration;
Imagesize = ((Frame_Rate_Test_Width * BitsPerPixel % 8 == 0)? (Frame_Rate_Test_Width * BitsPerPixel / 8 ): (Frame_Rate_Test_Width * BitsPerPixel / 8 + 1)) * Frame_Rate_Test_Height;
if((Refresh_FrameRate_Buf = (UBYTE *)malloc(Imagesize)) == NULL) {
Debug("Failed to apply for image memory...\r\n");
return -1;
}
Paint_NewImage(Refresh_FrameRate_Buf, Frame_Rate_Test_Width, Frame_Rate_Test_Height, 0, BLACK);
Paint_SelectImage(Refresh_FrameRate_Buf);
Epd_Mode(epd_mode);
Paint_SetBitsPerPixel(BitsPerPixel);
Debug("Start to test Frame Rate\r\n");
Frame_Rate_Test_Start = clock();
for(int i=0; i<10; i++){
Paint_Clear(WHITE);
//For color definition of all BitsPerPixel, you can refer to GUI_Paint.h
Paint_DrawRectangle(20, 20, Frame_Rate_Test_Width-20, Frame_Rate_Test_Height-20, 0x00, DOT_PIXEL_4X4, DRAW_FILL_EMPTY);//To prevent arrays from going out of bounds
Paint_DrawNum(Frame_Rate_Test_Width/2, Frame_Rate_Test_Height/2, ++Count, &Font24, 0x00, 0xF0);
Paint_DrawString_EN(Frame_Rate_Test_Width/2, Frame_Rate_Test_Height/4, "frame rate test", &Font20, 0xF0, 0x00);
Paint_DrawString_EN(Frame_Rate_Test_Width/2, Frame_Rate_Test_Height*3/4, "frame rate test", &Font20, 0xF0, 0x00);
switch(BitsPerPixel){
case 8:{
if(epd_mode == 2)
EPD_IT8951_8bp_Refresh(Refresh_FrameRate_Buf, 1280-Frame_Rate_Test_Width, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, false, Target_Memory_Addr);
else if(epd_mode == 1)
EPD_IT8951_8bp_Refresh(Refresh_FrameRate_Buf, 1872-Frame_Rate_Test_Width-16, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, false, Target_Memory_Addr);
else
EPD_IT8951_8bp_Refresh(Refresh_FrameRate_Buf, 0, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, false, Target_Memory_Addr);
break;
}
case 4:{
if(epd_mode == 2)
EPD_IT8951_4bp_Refresh(Refresh_FrameRate_Buf, 1280-Frame_Rate_Test_Width, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, false, Target_Memory_Addr,false);
else if(epd_mode == 1)
EPD_IT8951_4bp_Refresh(Refresh_FrameRate_Buf, 1872-Frame_Rate_Test_Width-16, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, false, Target_Memory_Addr,false);
else
EPD_IT8951_4bp_Refresh(Refresh_FrameRate_Buf, 0, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, false, Target_Memory_Addr,false);
break;
}
case 2:{
if(epd_mode == 2)
EPD_IT8951_2bp_Refresh(Refresh_FrameRate_Buf, 1280-Frame_Rate_Test_Width, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, false, Target_Memory_Addr,false);
else if(epd_mode == 1)
EPD_IT8951_2bp_Refresh(Refresh_FrameRate_Buf, 1872-Frame_Rate_Test_Width-16, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, false, Target_Memory_Addr,false);
else
EPD_IT8951_2bp_Refresh(Refresh_FrameRate_Buf, 0, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, false, Target_Memory_Addr,false);
break;
}
case 1:{
if(epd_mode == 2)
EPD_IT8951_1bp_Refresh(Refresh_FrameRate_Buf, 1280-Frame_Rate_Test_Width, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, A2_Mode, Target_Memory_Addr,false);
else if(epd_mode == 1)
EPD_IT8951_1bp_Refresh(Refresh_FrameRate_Buf, 1872-Frame_Rate_Test_Width-16, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, A2_Mode, Target_Memory_Addr,false);
else
EPD_IT8951_1bp_Refresh(Refresh_FrameRate_Buf, 0, 0, Frame_Rate_Test_Width, Frame_Rate_Test_Height, A2_Mode, Target_Memory_Addr,false);
break;
}
}
}
Frame_Rate_Test_Finish = clock();
Frame_Rate_Test_Duration = (double)(Frame_Rate_Test_Finish - Frame_Rate_Test_Start) / CLOCKS_PER_SEC;
Debug( "Write and Show 10 Frame occupy %f second\r\n", Frame_Rate_Test_Duration);
Debug( "The frame rate is: %lf fps\r\n", 10/Frame_Rate_Test_Duration);
if(Refresh_FrameRate_Buf != NULL){
free(Refresh_FrameRate_Buf);
Refresh_FrameRate_Buf = NULL;
}
return 0;
}
/******************************************************************************
function: TouchPanel_ePaper_Example
parameter:
Panel_Width: Width of the panel
Panel_Height: Height of the panel
Init_Target_Memory_Addr: Memory address of IT8951 target memory address
******************************************************************************/
UBYTE TouchPanel_ePaper_Example(UWORD Panel_Width, UWORD Panel_Height, UDOUBLE Init_Target_Memory_Addr){
int ret,fd;
UWORD Touch_Pannel_Area_Width;
if(Four_Byte_Align == true){
Touch_Pannel_Area_Width = Panel_Width - (Panel_Width % 32);
}else{
Touch_Pannel_Area_Width = Panel_Width;
}
UWORD Touch_Pannel_Area_Height = Panel_Height;
UDOUBLE Imagesize;
UWORD Touch_Point0[2];
UWORD Touch_X = 0,Touch_Y = 0;
UWORD Touch_X_Old = 0,Touch_Y_Old = 0;
UWORD Min_X = Panel_Width, Max_X = 0;
UWORD Min_Y = Panel_Height, Max_Y = 0;
UWORD X_Start, X_End, Y_Start, Y_End, Width, Height;
UBYTE First_Point_Flag = 1;
UWORD Panel_Frame_Buf_WidthByte;
UWORD Panel_Area_Frame_Buf_WidthByte;
if(access("/home/pi/FIFO",F_OK)){
ret = mkfifo("/home/pi/FIFO",0777);
if(ret == -1){
Debug("mkfifo error!\n");
exit(0);
}
}
fd = open("/home/pi/FIFO",O_RDWR|O_NONBLOCK);
if( fd == -1 )
{
Debug("Open error\r\n");
exit(0);
}
Panel_Frame_Buf_WidthByte = (Touch_Pannel_Area_Width * 1 % 8 == 0) ? (Touch_Pannel_Area_Width * 1 / 8 ): (Touch_Pannel_Area_Width * 1 / 8 + 1);
Imagesize = ((Touch_Pannel_Area_Width * 1 % 8 == 0) ? (Touch_Pannel_Area_Width * 1 / 8 ): (Touch_Pannel_Area_Width *1 / 8 + 1)) * Touch_Pannel_Area_Height;
if((Panel_Frame_Buf = (UBYTE *)malloc(Imagesize)) == NULL) {
Debug("Failed to apply for Panel_Frame_Buf memory...\r\n");
return -1;
}
//Assume the entire screen is refreshed
if((Panel_Area_Frame_Buf = (UBYTE *)malloc(Imagesize)) == NULL) {
Debug("Failed to apply for Panel_Area_Frame_Buf memory...\r\n");
return -1;
}
Paint_NewImage(Panel_Frame_Buf, Touch_Pannel_Area_Width, Touch_Pannel_Area_Height, 0, BLACK);
Paint_SelectImage(Panel_Frame_Buf);
Epd_Mode(epd_mode);
Paint_SetBitsPerPixel(1);
Paint_Clear(WHITE);
while(1)
{
Min_X = Panel_Width;
Max_X = 0;
Min_Y = Panel_Height;
Max_Y = 0;
First_Point_Flag = 1;
ret = read(fd,Touch_Point0,sizeof(Touch_Point0));
//Prepare the image
while(ret == 4){
Touch_X = Touch_Point0[0];
Touch_Y = Touch_Point0[1];
Paint_NewImage(Panel_Frame_Buf, Touch_Pannel_Area_Width, Touch_Pannel_Area_Height, 0, BLACK);
Paint_SelectImage(Panel_Frame_Buf);
Paint_SetBitsPerPixel(1);
if(First_Point_Flag == 0)
{
//For color definition of all BitsPerPixel, you can refer to GUI_Paint.h
Paint_DrawLine(Touch_X_Old, Touch_Y_Old, Touch_X, Touch_Y, 0x00, DOT_PIXEL_3X3, LINE_STYLE_SOLID);
}
Touch_X_Old = Touch_X;
Touch_Y_Old = Touch_Y;
First_Point_Flag = 0;
if(Touch_X < Min_X){
Min_X = Touch_X;
}
if(Touch_X > Max_X){
Max_X = Touch_X;
}
if(Touch_Y < Min_Y){
Min_Y = Touch_Y;
}
if(Touch_Y > Max_Y){
Max_Y = Touch_Y;
}
DEV_Delay_ms(15);
Debug("Touch_X:%d\r\n",Touch_X);
Debug("Touch_Y:%d\r\n",Touch_Y);
ret = read(fd,Touch_Point0,sizeof(Touch_Point0));
Debug("Stop ret:%d\r\n",ret);
}
//If Min < Max, then Indicates that there is a refresh area
if( (Min_X<Max_X)||(Min_Y<Max_Y) )
{
//----------Calculate Data, please be cautious that the width must be 32-bit aligned----------
Debug("Min_X - Max_X Output:%d~%d\r\n",Min_X,Max_X);
Debug("Min_Y - Max_Y Output:%d~%d\r\n",Min_Y,Max_Y);
X_Start = Min_X < 32 ? 0 : Min_X - (Min_X % 32);
Debug("X_Start:%d\r\n",X_Start);
X_End = ( Max_X + (32 - (Max_X % 32)) ) > Touch_Pannel_Area_Width ? ( Max_X - (Max_X % 32) ) : ( Max_X + (32 - (Max_X % 32)) );
Debug("X_End:%d\r\n",X_End);
Y_Start = Min_Y;
Debug("Y_Start:%d\r\n",Y_Start);
Y_End = Max_Y;
Debug("Y_Start:%d\r\n",Y_End);
Width = X_End - X_Start;
if(Width<=0){
Width = 32;
}
Debug("Width:%d\r\n",Width);
Height = Y_End-Y_Start;
if(Height<=0){
Height = 32;
}
Debug("Height:%d\r\n",Height);
//----------Prepare Image----------
Paint_NewImage(Panel_Area_Frame_Buf, Width, Height, 0, BLACK);
Paint_SelectImage(Panel_Area_Frame_Buf);
Epd_Mode(epd_mode);
Paint_Clear(WHITE);
Panel_Area_Frame_Buf_WidthByte = (Width % 8 == 0) ? (Width / 8 ): (Width / 8 + 1);
for(int y = 0; y< Height; y++){
memcpy(Panel_Area_Frame_Buf + (y * Panel_Area_Frame_Buf_WidthByte), Panel_Frame_Buf + ((Y_Start + y) * Panel_Frame_Buf_WidthByte) + X_Start/8 , Panel_Area_Frame_Buf_WidthByte);
}
//----------Display Image----------
EPD_IT8951_1bp_Refresh(Panel_Area_Frame_Buf, X_Start, Y_Start, Width, Height, A2_Mode, Init_Target_Memory_Addr, true);
}
}
if( Panel_Area_Frame_Buf != NULL ){
free(Panel_Area_Frame_Buf);
Panel_Area_Frame_Buf = NULL;
}
if( Panel_Frame_Buf != NULL ){
free(Panel_Frame_Buf);
Panel_Frame_Buf = NULL;
}
return 0;
}
static UBYTE BMP_Test(UWORD Panel_Width, UWORD Panel_Height, UDOUBLE Init_Target_Memory_Addr, UBYTE BitsPerPixel, UBYTE Pic_Count)
{
UWORD WIDTH;
if(Four_Byte_Align == true){
WIDTH = Panel_Width - (Panel_Width % 32);
}else{
WIDTH = Panel_Width;
}
UWORD HEIGHT = Panel_Height;
UDOUBLE Imagesize;
Imagesize = ((WIDTH * BitsPerPixel % 8 == 0)? (WIDTH * BitsPerPixel / 8 ): (WIDTH * BitsPerPixel / 8 + 1)) * HEIGHT;
if((Refresh_Frame_Buf = (UBYTE *)malloc(Imagesize)) == NULL) {
Debug("Failed to apply for black memory...\r\n");
return -1;
}
Paint_NewImage(Refresh_Frame_Buf, WIDTH, HEIGHT, 0, BLACK);
Paint_SelectImage(Refresh_Frame_Buf);
Epd_Mode(epd_mode);
Paint_SetBitsPerPixel(BitsPerPixel);
Paint_Clear(WHITE);
char Path[30];
sprintf(Path,"./pic/%dx%d_%d.bmp", WIDTH, HEIGHT, Pic_Count);
GUI_ReadBmp(Path, 0, 0);
switch(BitsPerPixel){
case BitsPerPixel_8:{
Paint_DrawString_EN(10, 10, "8 bits per pixel 16 grayscale", &Font24, 0xF0, 0x00);
EPD_IT8951_8bp_Refresh(Refresh_Frame_Buf, 0, 0, WIDTH, HEIGHT, false, Init_Target_Memory_Addr);
break;
}
case BitsPerPixel_4:{
Paint_DrawString_EN(10, 10, "4 bits per pixel 16 grayscale", &Font24, 0xF0, 0x00);
EPD_IT8951_4bp_Refresh(Refresh_Frame_Buf, 0, 0, WIDTH, HEIGHT, false, Init_Target_Memory_Addr,false);
break;
}
case BitsPerPixel_2:{
Paint_DrawString_EN(10, 10, "2 bits per pixel 4 grayscale", &Font24, 0xC0, 0x00);
EPD_IT8951_2bp_Refresh(Refresh_Frame_Buf, 0, 0, WIDTH, HEIGHT, false, Init_Target_Memory_Addr,false);
break;
}
case BitsPerPixel_1:{
Paint_DrawString_EN(10, 10, "1 bit per pixel 2 grayscale", &Font24, 0x80, 0x00);
EPD_IT8951_1bp_Refresh(Refresh_Frame_Buf, 0, 0, WIDTH, HEIGHT, A2_Mode, Init_Target_Memory_Addr,false);
break;
}
}
if(Refresh_Frame_Buf != NULL){
free(Refresh_Frame_Buf);
Refresh_Frame_Buf = NULL;
}
DEV_Delay_ms(5000);
return 0;
}
void Factory_Test_Only(IT8951_Dev_Info Dev_Info, UDOUBLE Init_Target_Memory_Addr)
{
while(1)
{
for(int i=0; i < 4; i++){
EPD_IT8951_SystemRun();
EPD_IT8951_Clear_Refresh(Dev_Info, Init_Target_Memory_Addr, GC16_Mode);
// BMP_Test(Dev_Info.Panel_W, Dev_Info.Panel_H, Init_Target_Memory_Addr, BitsPerPixel_1, i);
// BMP_Test(Dev_Info.Panel_W, Dev_Info.Panel_H, Init_Target_Memory_Addr, BitsPerPixel_2, i);
BMP_Test(Dev_Info.Panel_W, Dev_Info.Panel_H, Init_Target_Memory_Addr, BitsPerPixel_4, i);
// BMP_Test(Dev_Info.Panel_W, Dev_Info.Panel_H, Init_Target_Memory_Addr, BitsPerPixel_8, i);
EPD_IT8951_Clear_Refresh(Dev_Info, Init_Target_Memory_Addr, GC16_Mode);
EPD_IT8951_Sleep();
DEV_Delay_ms(5000);
}
EPD_IT8951_SystemRun();
EPD_IT8951_Clear_Refresh(Dev_Info, Init_Target_Memory_Addr, A2_Mode);
Dynamic_Refresh_Example(Dev_Info,Init_Target_Memory_Addr);
EPD_IT8951_Clear_Refresh(Dev_Info, Init_Target_Memory_Addr, A2_Mode);
if(isColor)
Color_Test(Dev_Info, Init_Target_Memory_Addr);
EPD_IT8951_Sleep();
DEV_Delay_ms(5000);
}
}
void Color_Test(IT8951_Dev_Info Dev_Info, UDOUBLE Init_Target_Memory_Addr)
{
PAINT_TIME Time = {2020, 9, 30, 18, 10, 34};
while(1)
{
UWORD Panel_Width = Dev_Info.Panel_W;
UWORD Panel_Height = Dev_Info.Panel_H;
UDOUBLE Imagesize;
//malloc enough memory for 1bp picture first
Imagesize = ((Panel_Width * 1 % 8 == 0)? (Panel_Width * 1 / 8 ): (Panel_Width * 1 / 8 + 1)) * Panel_Height;
if((Refresh_Frame_Buf = (UBYTE *)malloc(Imagesize*4)) == NULL) {
Debug("Failed to apply for picture memory...\r\n");
}
Paint_NewImage(Refresh_Frame_Buf, Panel_Width, Panel_Height, 0, BLACK);
Paint_SelectImage(Refresh_Frame_Buf);
Epd_Mode(epd_mode);
Paint_SetBitsPerPixel(4);
Paint_Clear(WHITE);
if(0) {
Paint_DrawRectangle(100, 100, 300, 300, 0x0f00, DOT_PIXEL_1X1, DRAW_FILL_FULL); //Red
Paint_DrawRectangle(100, 400, 300, 600, 0x00f0, DOT_PIXEL_1X1, DRAW_FILL_FULL); //Green
Paint_DrawRectangle(100, 700, 300, 900, 0x000f, DOT_PIXEL_1X1, DRAW_FILL_FULL); //Bule
Paint_DrawCircle(500, 200, 100, 0x00ff, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawCircle(500, 500, 100, 0x0f0f, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawCircle(500, 800, 100, 0x0ff0, DOT_PIXEL_1X1, DRAW_FILL_FULL);
Paint_DrawLine(1000, 200, 1100, 200, 0x055a, 10, LINE_STYLE_SOLID);
Paint_DrawLine(1000, 300, 1100, 300, 0x05a5, 20, LINE_STYLE_SOLID);
Paint_DrawLine(1000, 400, 1100, 400, 0x0a55, 30, LINE_STYLE_SOLID);
Paint_DrawString_EN(1000, 500, "Hello, World!", &Font24, 0x0aa5, 0x0fff);
Paint_DrawString_EN(1000, 600, "Hello, World!", &Font24, 0x0a5a, 0x0fff);
Paint_DrawString_EN(1000, 700, "Hello, World!", &Font24, 0x05aa, 0x0fff);
Paint_DrawString_CN(700, 400, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD> ΢ѩ<CEA2><D1A9><EFBFBD><EFBFBD>", &Font24CN, 0x00fa, 0x0000);
Paint_DrawNum(700, 500, 123456789, &Font24, 0x0a0f, 0x0fff);
Paint_DrawTime(700, 600, &Time, &Font24, 0x0fa0, 0x0fff);
}else {
for(UWORD j=0; j<14; j++) {
for(UWORD i=0; i<19; i++) {
Paint_DrawRectangle(i*72, j*72+1, (i+1)*72-1, (j+1)*72, (i+j*19)*15, DOT_PIXEL_1X1, DRAW_FILL_FULL);
}
}
}
EPD_IT8951_4bp_Refresh(Refresh_Frame_Buf, 0, 0, Panel_Width, Panel_Height, false, Init_Target_Memory_Addr, false);
if(Refresh_Frame_Buf != NULL) {
free(Refresh_Frame_Buf);
Refresh_Frame_Buf = NULL;
}
DEV_Delay_ms(5000);
break;
}
}
Reference in New Issue Copy Permalink