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

2020-12-10

Browse source
This commit is contained in:
hnwangkg-ezio 2020-12-11 14:36:30 +08:00
commit 04d4621789
493 changed files with 128806 additions and 689 deletions
Download patch file Download diff file Expand all files Collapse all files

391
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in02d.c Normal file
View file

@ -0,0 +1,391 @@
/*****************************************************************************
* | File : EPD_1IN02_1in02.c
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V1.0
* | Date : 2019-09-27
* | 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_1in02d.h"
/**
* full screen update LUT
**/
const unsigned char lut_w1[] =
{
0x60 ,0x5A ,0x5A ,0x00 ,0x00 ,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 ,
};
const unsigned char lut_b1[] =
{
0x90 ,0x5A ,0x5A ,0x00 ,0x00 ,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 ,
};
/**
* partial screen update LUT
**/
const unsigned char lut_w[] =
{
0x60 ,0x01 ,0x01 ,0x00 ,0x00 ,0x01 ,
0x80 ,0x1f ,0x00 ,0x00 ,0x00 ,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 ,
};
const unsigned char lut_b[] =
{
0x90 ,0x01 ,0x01 ,0x00 ,0x00 ,0x01 ,
0x40 ,0x1f ,0x00 ,0x00 ,0x00 ,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 ,
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_1IN02_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(20);
DEV_Digital_Write(EPD_RST_PIN, 0);// Module reset
DEV_Delay_ms(2);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(20);
}
/******************************************************************************
function : send command
parameter:
command : Command register
******************************************************************************/
static void EPD_1IN02_SendCommand(UBYTE command)
{
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_Digital_Write(EPD_DC_PIN, 0);// command write
DEV_SPI_WriteByte(command);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : send data
parameter:
Data : Write data
******************************************************************************/
static void EPD_1IN02_SendData(UBYTE Data)
{
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_Digital_Write(EPD_DC_PIN, 1); // command write
DEV_SPI_WriteByte(Data);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : LUT download
******************************************************************************/
void EPD_1IN02_SetFulltReg(void)
{
unsigned int count;
EPD_1IN02_SendCommand(0x23);
for(count=0;count<42;count++)
{EPD_1IN02_SendData(lut_w1[count]);}
EPD_1IN02_SendCommand(0x24);
for(count=0;count<42;count++)
{EPD_1IN02_SendData(lut_b1[count]);}
}
/******************************************************************************
function : LUT download
******************************************************************************/
void EPD_1IN02_SetPartReg(void)
{
unsigned int count;
EPD_1IN02_SendCommand(0x23);
for(count=0;count<42;count++){
EPD_1IN02_SendData(lut_w[count]);
}
EPD_1IN02_SendCommand(0x24);
for(count=0;count<42;count++){
EPD_1IN02_SendData(lut_b[count]);
}
}
/******************************************************************************
function : Wait until the busy_pin goes LOW
******************************************************************************/
void EPD_1IN02_WaitUntilIdle(void)
{
unsigned char busy;
do
{
EPD_1IN02_SendCommand(0x71);
busy = DEV_Digital_Read(EPD_BUSY_PIN);
busy =!(busy & 0x01);
}
while(busy);
DEV_Delay_ms(800);
}
/******************************************************************************
function : Turn On Display
******************************************************************************/
void EPD_1IN02_TurnOnDisplay(void)
{
// EPD_1IN02_SendCommand(0x04); //power on
// EPD_1IN02_WaitUntilIdle();
EPD_1IN02_SendCommand(0x12); //Start refreshing the screen
DEV_Delay_ms(10);
EPD_1IN02_WaitUntilIdle();
// EPD_1IN02_SendCommand(0x02);
// EPD_1IN02_WaitUntilIdle(); //power off
}
/******************************************************************************
function :Initialize the e-Paper register
******************************************************************************/
UBYTE EPD_1IN02_Init(void)
{
EPD_1IN02_Reset();
EPD_1IN02_SendCommand(0xD2);
EPD_1IN02_SendData(0x3F);
EPD_1IN02_SendCommand(0x00);
EPD_1IN02_SendData (0x6F); //from outside
EPD_1IN02_SendCommand(0x01); //power setting
EPD_1IN02_SendData (0x03);
EPD_1IN02_SendData (0x00);
EPD_1IN02_SendData (0x2b);
EPD_1IN02_SendData (0x2b);
EPD_1IN02_SendCommand(0x06); //Configuring the charge pump
EPD_1IN02_SendData(0x3f);
EPD_1IN02_SendCommand(0x2A); //Setting XON and the options of LUT
EPD_1IN02_SendData(0x00);
EPD_1IN02_SendData(0x00);
EPD_1IN02_SendCommand(0x30); //Set the clock frequency
EPD_1IN02_SendData(0x17); //50Hz
EPD_1IN02_SendCommand(0x50); //Set VCOM and data output interval
EPD_1IN02_SendData(0x57);
EPD_1IN02_SendCommand(0x60); //Set The non-overlapping period of Gate and Source.
EPD_1IN02_SendData(0x22);
EPD_1IN02_SendCommand(0x61); //resolution setting
EPD_1IN02_SendData (0x50); //source 128
EPD_1IN02_SendData (0x80);
EPD_1IN02_SendCommand(0x82); //sets VCOM_DC value
EPD_1IN02_SendData(0x12); //-1v
EPD_1IN02_SendCommand(0xe3);//Set POWER SAVING
EPD_1IN02_SendData(0x33);
EPD_1IN02_SetFulltReg();
EPD_1IN02_SendCommand(0x04); //power on
EPD_1IN02_WaitUntilIdle();
return 0;
}
/******************************************************************************
function :Partial refresh initialization e-paper
******************************************************************************/
void EPD_1IN02_Part_Init(void)
{
EPD_1IN02_Reset();
EPD_1IN02_SendCommand(0xD2);
EPD_1IN02_SendData(0x3F);
EPD_1IN02_SendCommand(0x00);
EPD_1IN02_SendData (0x6F); //from outside
EPD_1IN02_SendCommand(0x01); //power setting
EPD_1IN02_SendData (0x03);
EPD_1IN02_SendData (0x00);
EPD_1IN02_SendData (0x2b);
EPD_1IN02_SendData (0x2b);
EPD_1IN02_SendCommand(0x06); //Configuring the charge pump
EPD_1IN02_SendData(0x3f);
EPD_1IN02_SendCommand(0x2A); //Setting XON and the options of LUT
EPD_1IN02_SendData(0x00);
EPD_1IN02_SendData(0x00);
EPD_1IN02_SendCommand(0x30); //Set the clock frequency
EPD_1IN02_SendData(0x17);
EPD_1IN02_SendCommand(0x50); //Set VCOM and data output interval
EPD_1IN02_SendData(0xf2);
EPD_1IN02_SendCommand(0x60); //Set The non-overlapping period of Gate and Source.
EPD_1IN02_SendData(0x22);
EPD_1IN02_SendCommand(0x82); //Set VCOM_DC value
EPD_1IN02_SendData(0x12);//-1v
EPD_1IN02_SendCommand(0xe3);//Set POWER SAVING
EPD_1IN02_SendData(0x33);
EPD_1IN02_SetPartReg();
EPD_1IN02_SendCommand(0x04);//Set POWER SAVING
EPD_1IN02_WaitUntilIdle();
}
/******************************************************************************
function : Clear screen
******************************************************************************/
void EPD_1IN02_Clear(void)
{
unsigned int i;
EPD_1IN02_SendCommand(0x10);
for(i=0;i<1280;i++){
EPD_1IN02_SendData(0X00);
}
EPD_1IN02_SendCommand(0x13); //Transfer new data
for(i=0;i<1280;i++){
EPD_1IN02_SendData(0xff);
}
EPD_1IN02_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
Image :Displayed data
******************************************************************************/
void EPD_1IN02_Display(UBYTE *Image)
{
UWORD Width;
Width = (EPD_1IN02_WIDTH % 8 == 0)? (EPD_1IN02_WIDTH / 8 ): (EPD_1IN02_WIDTH / 8 + 1);
//EPD_1IN02_Init();
EPD_1IN02_SendCommand(0x10);
for (UWORD j = 0; j < EPD_1IN02_HEIGHT; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_1IN02_SendData(0xff);
}
}
EPD_1IN02_SendCommand(0x13);
for (UWORD j = 0; j < EPD_1IN02_HEIGHT; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_1IN02_SendData(Image[i + j * Width]);
}
}
EPD_1IN02_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
old_Image: Last displayed data
Image2 : New data
******************************************************************************/
void EPD_1IN02_DisplayPartial(UBYTE *old_Image, UBYTE *Image)
{
/* Set partial Windows */
EPD_1IN02_SendCommand(0x91); //This command makes the display enter partial mode
EPD_1IN02_SendCommand(0x90); //resolution setting
EPD_1IN02_SendData(0); //x-start
EPD_1IN02_SendData(79); //x-end
EPD_1IN02_SendData(0);
EPD_1IN02_SendData(127); //y-end
EPD_1IN02_SendData(0x00);
UWORD Width;
Width = (EPD_1IN02_WIDTH % 8 == 0)? (EPD_1IN02_WIDTH / 8 ): (EPD_1IN02_WIDTH / 8 + 1);
/* send data */
EPD_1IN02_SendCommand(0x10);
for (UWORD j = 0; j < EPD_1IN02_HEIGHT; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_1IN02_SendData(old_Image[i + j * Width]);
}
}
EPD_1IN02_SendCommand(0x13);
for (UWORD j = 0; j < EPD_1IN02_HEIGHT; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_1IN02_SendData(Image[i + j * Width]);
}
}
/* Set partial refresh */
EPD_1IN02_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
******************************************************************************/
void EPD_1IN02_Sleep(void)
{
EPD_1IN02_SendCommand(0X50);
EPD_1IN02_SendData(0xf7);
EPD_1IN02_SendCommand(0X02); //power off
EPD_1IN02_WaitUntilIdle();
EPD_1IN02_SendCommand(0X07); //deep sleep
EPD_1IN02_SendData(0xA5);
DEV_Delay_ms(200);
printf("Turn off the power!!! \r\n");
DEV_Digital_Write(EPD_RST_PIN, 0);// Module reset
}

47
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in02d.h Normal file
View file

@ -0,0 +1,47 @@
/*****************************************************************************
* | File : EPD_1IN02_1in02.h
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V1.0
* | Date : 2019-09-27
* | 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_1IN02_H_
#define _EPD_1IN02_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_1IN02_WIDTH 80
#define EPD_1IN02_HEIGHT 128
UBYTE EPD_1IN02_Init(void);
void EPD_1IN02_Clear(void);
void EPD_1IN02_Display(UBYTE *Image);
void EPD_1IN02_DisplayPartial(UBYTE *Image1, UBYTE *Image2);
void EPD_1IN02_Sleep(void);
void EPD_1IN02_Part_Init(void);
#endif

300
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in54.c Normal file
View file

@ -0,0 +1,300 @@
/*****************************************************************************
* | File : EPD_1in54.C
* | Author : Waveshare team
* | Function : 1.54inch e-paper
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* 1.Change:
* lut_full_update[] => EPD_1IN54_lut_full_update[]
* lut_partial_update[] => EPD_1IN54_lut_partial_update[]
* EPD_Reset() => EPD_1IN54_Reset()
* EPD_SendCommand() => EPD_1IN54_SendCommand()
* EPD_SendData() => EPD_1IN54_SendData()
* EPD_WaitUntilIdle() => EPD_1IN54_ReadBusy()
* EPD_SetLut() => EPD_1IN54_SetLut()
* EPD_SetWindow() => EPD_1IN54_SetWindow()
* EPD_SetCursor() => EPD_1IN54_SetCursor()
* EPD_TurnOnDisplay() => EPD_1IN54_TurnOnDisplay()
* EPD_Init() => EPD_1IN54_Init()
* EPD_Clear() => EPD_1IN54_Clear()
* EPD_Display() => EPD_1IN54_Display()
* EPD_Sleep() => EPD_1IN54_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SOURCE_AND_GATE_START_SETTING 0x62
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* -----------------------------------------------------------------------------
* V2.0(2018-10-30):
* 1.Remove:ImageBuff[EPD_1IN54_HEIGHT * EPD_1IN54_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_1in54.h"
#include "Debug.h"
static const unsigned char EPD_1IN54_lut_full_update[] = {
0x02, 0x02, 0x01, 0x11, 0x12, 0x12, 0x22, 0x22,
0x66, 0x69, 0x69, 0x59, 0x58, 0x99, 0x99, 0x88,
0x00, 0x00, 0x00, 0x00, 0xF8, 0xB4, 0x13, 0x51,
0x35, 0x51, 0x51, 0x19, 0x01, 0x00
};
static const unsigned char EPD_1IN54_lut_partial_update[] = {
0x10, 0x18, 0x18, 0x08, 0x18, 0x18, 0x08, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x13, 0x14, 0x44, 0x12,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_1IN54_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
******************************************************************************/
static void EPD_1IN54_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_1IN54_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:
******************************************************************************/
void EPD_1IN54_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 1) { //LOW: idle, HIGH: busy
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Setting the display window
parameter:
******************************************************************************/
static void EPD_1IN54_SetWindow(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend)
{
EPD_1IN54_SendCommand(0x44); // SET_RAM_X_ADDRESS_START_END_POSITION
EPD_1IN54_SendData((Xstart >> 3) & 0xFF);
EPD_1IN54_SendData((Xend >> 3) & 0xFF);
EPD_1IN54_SendCommand(0x45); // SET_RAM_Y_ADDRESS_START_END_POSITION
EPD_1IN54_SendData(Ystart & 0xFF);
EPD_1IN54_SendData((Ystart >> 8) & 0xFF);
EPD_1IN54_SendData(Yend & 0xFF);
EPD_1IN54_SendData((Yend >> 8) & 0xFF);
}
/******************************************************************************
function : Set Cursor
parameter:
******************************************************************************/
static void EPD_1IN54_SetCursor(UWORD Xstart, UWORD Ystart)
{
EPD_1IN54_SendCommand(0x4E); // SET_RAM_X_ADDRESS_COUNTER
EPD_1IN54_SendData((Xstart >> 3) & 0xFF);
EPD_1IN54_SendCommand(0x4F); // SET_RAM_Y_ADDRESS_COUNTER
EPD_1IN54_SendData(Ystart & 0xFF);
EPD_1IN54_SendData((Ystart >> 8) & 0xFF);
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_1IN54_TurnOnDisplay(void)
{
EPD_1IN54_SendCommand(0x22); // DISPLAY_UPDATE_CONTROL_2
EPD_1IN54_SendData(0xC4);
EPD_1IN54_SendCommand(0x20); // MASTER_ACTIVATION
EPD_1IN54_SendCommand(0xFF); // TERMINATE_FRAME_READ_WRITE
EPD_1IN54_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_1IN54_Init(UBYTE Mode)
{
EPD_1IN54_Reset();
EPD_1IN54_SendCommand(0x01); // DRIVER_OUTPUT_CONTROL
EPD_1IN54_SendData((EPD_1IN54_HEIGHT - 1) & 0xFF);
EPD_1IN54_SendData(((EPD_1IN54_HEIGHT - 1) >> 8) & 0xFF);
EPD_1IN54_SendData(0x00); // GD = 0; SM = 0; TB = 0;
EPD_1IN54_SendCommand(0x0C); // BOOSTER_SOFT_START_CONTROL
EPD_1IN54_SendData(0xD7);
EPD_1IN54_SendData(0xD6);
EPD_1IN54_SendData(0x9D);
EPD_1IN54_SendCommand(0x2C); // WRITE_VCOM_REGISTER
EPD_1IN54_SendData(0xA8); // VCOM 7C
EPD_1IN54_SendCommand(0x3A); // SET_DUMMY_LINE_PERIOD
EPD_1IN54_SendData(0x1A); // 4 dummy lines per gate
EPD_1IN54_SendCommand(0x3B); // SET_GATE_TIME
EPD_1IN54_SendData(0x08); // 2us per line
EPD_1IN54_SendCommand(0x11);
EPD_1IN54_SendData(0x03);
//set the look-up table register
EPD_1IN54_SendCommand(0x32);
if(Mode == EPD_1IN54_FULL){
for (UWORD i = 0; i < 30; i++) {
EPD_1IN54_SendData(EPD_1IN54_lut_full_update[i]);
}
}else if(Mode == EPD_1IN54_PART){
for (UWORD i = 0; i < 30; i++) {
EPD_1IN54_SendData(EPD_1IN54_lut_partial_update[i]);
}
}else{
Debug("error, the Mode is EPD_1IN54_FULL or EPD_1IN54_PART");
}
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_1IN54_Clear(void)
{
UWORD Width, Height;
Width = (EPD_1IN54_WIDTH % 8 == 0)? (EPD_1IN54_WIDTH / 8 ): (EPD_1IN54_WIDTH / 8 + 1);
Height = EPD_1IN54_HEIGHT;
EPD_1IN54_SetWindow(0, 0, EPD_1IN54_WIDTH, EPD_1IN54_HEIGHT);
for (UWORD j = 0; j < Height; j++) {
EPD_1IN54_SetCursor(0, j);
EPD_1IN54_SendCommand(0x24);
for (UWORD i = 0; i < Width; i++) {
EPD_1IN54_SendData(0XFF);
}
}
EPD_1IN54_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_1IN54_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_1IN54_WIDTH % 8 == 0)? (EPD_1IN54_WIDTH / 8 ): (EPD_1IN54_WIDTH / 8 + 1);
Height = EPD_1IN54_HEIGHT;
UDOUBLE Addr = 0;
// UDOUBLE Offset = ImageName;
EPD_1IN54_SetWindow(0, 0, EPD_1IN54_WIDTH, EPD_1IN54_HEIGHT);
for (UWORD j = 0; j < Height; j++) {
EPD_1IN54_SetCursor(0, j);
EPD_1IN54_SendCommand(0x24);
for (UWORD i = 0; i < Width; i++) {
Addr = i + j * Width;
EPD_1IN54_SendData(Image[Addr]);
}
}
EPD_1IN54_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_1IN54_Sleep(void)
{
EPD_1IN54_SendCommand(0x10);
EPD_1IN54_SendData(0x01);
}

104
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in54.h Normal file
View file

@ -0,0 +1,104 @@
/*****************************************************************************
* | File : EPD_1in54.h
* | Author : Waveshare team
* | Function : 1.54inch e-paper
* | Info :
*----------------
* | This version: V3.1
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.1(2019-06-12):
* 1.Change:
* lut_full_update[] => EPD_1IN54_lut_full_update[]
* lut_partial_update[] => EPD_1IN54_lut_partial_update[]
* EPD_Reset() => EPD_1IN54_Reset()
* EPD_SendCommand() => EPD_1IN54_SendCommand()
* EPD_SendData() => EPD_1IN54_SendData()
* EPD_WaitUntilIdle() => EPD_1IN54_ReadBusy()
* EPD_SetLut() => EPD_1IN54_SetLut()
* EPD_SetWindow() => EPD_1IN54_SetWindow()
* EPD_SetCursor() => EPD_1IN54_SetCursor()
* EPD_TurnOnDisplay() => EPD_1IN54_TurnOnDisplay()
* EPD_Init() => EPD_1IN54_Init()
* EPD_Clear() => EPD_1IN54_Clear()
* EPD_Display() => EPD_1IN54_Display()
* EPD_Sleep() => EPD_1IN54_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SOURCE_AND_GATE_START_SETTING 0x62
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* -----------------------------------------------------------------------------
* V2.0(2018-10-30):
* 1.Remove:ImageBuff[EPD_1IN54_HEIGHT * EPD_1IN54_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_1IN54_H_
#define __EPD_1IN54_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_1IN54_WIDTH 200
#define EPD_1IN54_HEIGHT 200
#define EPD_1IN54_FULL 0
#define EPD_1IN54_PART 1
void EPD_1IN54_Init(UBYTE Mode);
void EPD_1IN54_Clear(void);
void EPD_1IN54_Display(UBYTE *Image);
void EPD_1IN54_Sleep(void);
#endif

269
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in54_V2.c Normal file
View file

@ -0,0 +1,269 @@
/*****************************************************************************
* | File : EPD_1in54_V2.c
* | Author : Waveshare team
* | Function : 1.54inch e-paper V2
* | Info :
*----------------
* | This version: V1.0
* | Date : 2019-06-11
* | 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_1in54_V2.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_1IN54_V2_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
******************************************************************************/
static void EPD_1IN54_V2_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_1IN54_V2_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_1IN54_V2_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 1) { //LOW: idle, HIGH: busy
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display full
parameter:
******************************************************************************/
static void EPD_1IN54_V2_TurnOnDisplay(void)
{
EPD_1IN54_V2_SendCommand(0x22);
EPD_1IN54_V2_SendData(0xF7);
EPD_1IN54_V2_SendCommand(0x20);
EPD_1IN54_V2_ReadBusy();
}
/******************************************************************************
function : Turn On Display part
parameter:
******************************************************************************/
static void EPD_1IN54_V2_TurnOnDisplayPart(void)
{
EPD_1IN54_V2_SendCommand(0x22);
EPD_1IN54_V2_SendData(0xFF);
EPD_1IN54_V2_SendCommand(0x20);
EPD_1IN54_V2_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_1IN54_V2_Init(void)
{
EPD_1IN54_V2_Reset();
EPD_1IN54_V2_ReadBusy();
EPD_1IN54_V2_SendCommand(0x12); //SWRESET
EPD_1IN54_V2_ReadBusy();
EPD_1IN54_V2_SendCommand(0x01); //Driver output control
EPD_1IN54_V2_SendData(0xC7);
EPD_1IN54_V2_SendData(0x00);
EPD_1IN54_V2_SendData(0x01);
EPD_1IN54_V2_SendCommand(0x11); //data entry mode
EPD_1IN54_V2_SendData(0x01);
EPD_1IN54_V2_SendCommand(0x44); //set Ram-X address start/end position
EPD_1IN54_V2_SendData(0x00);
EPD_1IN54_V2_SendData(0x18); //0x0C-->(18+1)*8=200
EPD_1IN54_V2_SendCommand(0x45); //set Ram-Y address start/end position
EPD_1IN54_V2_SendData(0xC7); //0xC7-->(199+1)=200
EPD_1IN54_V2_SendData(0x00);
EPD_1IN54_V2_SendData(0x00);
EPD_1IN54_V2_SendData(0x00);
EPD_1IN54_V2_SendCommand(0x3C); //BorderWavefrom
EPD_1IN54_V2_SendData(0x01);
EPD_1IN54_V2_SendCommand(0x18);
EPD_1IN54_V2_SendData(0x80);
EPD_1IN54_V2_SendCommand(0x22); // //Load Temperature and waveform setting.
EPD_1IN54_V2_SendData(0XB1);
EPD_1IN54_V2_SendCommand(0x20);
EPD_1IN54_V2_SendCommand(0x4E); // set RAM x address count to 0;
EPD_1IN54_V2_SendData(0x00);
EPD_1IN54_V2_SendCommand(0x4F); // set RAM y address count to 0X199;
EPD_1IN54_V2_SendData(0xC7);
EPD_1IN54_V2_SendData(0x00);
EPD_1IN54_V2_ReadBusy();
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_1IN54_V2_Clear(void)
{
UWORD Width, Height;
Width = (EPD_1IN54_V2_WIDTH % 8 == 0)? (EPD_1IN54_V2_WIDTH / 8 ): (EPD_1IN54_V2_WIDTH / 8 + 1);
Height = EPD_1IN54_V2_HEIGHT;
EPD_1IN54_V2_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_1IN54_V2_SendData(0XFF);
}
}
EPD_1IN54_V2_SendCommand(0x26);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_1IN54_V2_SendData(0XFF);
}
}
EPD_1IN54_V2_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_1IN54_V2_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_1IN54_V2_WIDTH % 8 == 0)? (EPD_1IN54_V2_WIDTH / 8 ): (EPD_1IN54_V2_WIDTH / 8 + 1);
Height = EPD_1IN54_V2_HEIGHT;
UDOUBLE Addr = 0;
EPD_1IN54_V2_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
Addr = i + j * Width;
EPD_1IN54_V2_SendData(Image[Addr]);
}
}
EPD_1IN54_V2_TurnOnDisplay();
}
/******************************************************************************
function : The image of the previous frame must be uploaded, otherwise the
first few seconds will display an exception.
parameter:
******************************************************************************/
void EPD_1IN54_V2_DisplayPartBaseImage(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_1IN54_V2_WIDTH % 8 == 0)? (EPD_1IN54_V2_WIDTH / 8 ): (EPD_1IN54_V2_WIDTH / 8 + 1);
Height = EPD_1IN54_V2_HEIGHT;
UDOUBLE Addr = 0;
EPD_1IN54_V2_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
Addr = i + j * Width;
EPD_1IN54_V2_SendData(Image[Addr]);
}
}
EPD_1IN54_V2_SendCommand(0x26);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
Addr = i + j * Width;
EPD_1IN54_V2_SendData(Image[Addr]);
}
}
EPD_1IN54_V2_TurnOnDisplayPart();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_1IN54_V2_DisplayPart(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_1IN54_V2_WIDTH % 8 == 0)? (EPD_1IN54_V2_WIDTH / 8 ): (EPD_1IN54_V2_WIDTH / 8 + 1);
Height = EPD_1IN54_V2_HEIGHT;
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(10);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(10);
EPD_1IN54_V2_SendCommand(0x3C); //BorderWavefrom
EPD_1IN54_V2_SendData(0x80);
UDOUBLE Addr = 0;
EPD_1IN54_V2_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
Addr = i + j * Width;
EPD_1IN54_V2_SendData(Image[Addr]);
}
}
EPD_1IN54_V2_TurnOnDisplayPart();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_1IN54_V2_Sleep(void)
{
EPD_1IN54_V2_SendCommand(0x10); //enter deep sleep
EPD_1IN54_V2_SendData(0x01);
DEV_Delay_ms(100);
}

46
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in54_V2.h Normal file
View file

@ -0,0 +1,46 @@
/*****************************************************************************
* | File : EPD_1in54_V2.h
* | Author : Waveshare team
* | Function : 1.54inch e-paper V2
* | Info :
*----------------
* | This version: V1.0
* | Date : 2019-06-11
* | 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_1IN54_V2_H_
#define __EPD_1IN54_V2_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_1IN54_V2_WIDTH 200
#define EPD_1IN54_V2_HEIGHT 200
void EPD_1IN54_V2_Init(void);
void EPD_1IN54_V2_Clear(void);
void EPD_1IN54_V2_Display(UBYTE *Image);
void EPD_1IN54_V2_DisplayPartBaseImage(UBYTE *Image);
void EPD_1IN54_V2_DisplayPart(UBYTE *Image);
void EPD_1IN54_V2_Sleep(void);
#endif

348
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in54b.c Normal file
View file

@ -0,0 +1,348 @@
/*****************************************************************************
* | File : EPD_1in54b.c
* | Author : Waveshare team
* | Function : 1.54inch e-paper b
* | Info :
*----------------
* | This version: V3.1
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.1(2019-06-12):
* 1.Change:
* lut_vcom0[] => EPD_1IN54_lut_vcom0[]
* lut_w[] => EPD_1IN54_lut_w[]
* lut_b[] => EPD_1IN54B_lut_b[]
* lut_g1[] => EPD_1IN54B_lut_g1[]
* lut_g2[] => EPD_1IN54B_lut_g2[]
* lut_vcom1[] => EPD_1IN54B_lut_vcom1[]
* lut_red0[] => EPD_1IN54B_lut_red0[]
* lut_red1[] => EPD_1IN54B_lut_red1[]
* EPD_Reset() => EPD_1IN54B_Reset()
* EPD_SendCommand() => EPD_1IN54B_SendCommand()
* EPD_SendData() => EPD_1IN54B_SendData()
* EPD_WaitUntilIdle() => EPD_1IN54B_ReadBusy()
* EPD_SetLutBw() => EPD_1IN54B_SetLutBw()
* EPD_SetLutBw => EPD_1IN54B_SetLutBw()
* EPD_Init() => EPD_1IN54B_Init()
* EPD_Clear() => EPD_1IN54B_Clear()
* EPD_Display() => EPD_1IN54B_Display()
* EPD_Sleep() => EPD_1IN54B_Sleep()
* -----------------------------------------------------------------------------
* V3.0(2019-04-24):
* 1.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SOURCE_AND_GATE_START_SETTING 0x62
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
*
* -----------------------------------------------------------------------------
* V2.0(2018-10-30):
* 1.Remove:ImageBuff[EPD_1IN54B_HEIGHT * EPD_1IN54B_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_1in54b.h"
#include "Debug.h"
const unsigned char EPD_1IN54B_lut_vcom0[] = {0x0E, 0x14, 0x01, 0x0A, 0x06, 0x04, 0x0A, 0x0A, 0x0F, 0x03, 0x03, 0x0C, 0x06, 0x0A, 0x00};
const unsigned char EPD_1IN54B_lut_w[] = {0x0E, 0x14, 0x01, 0x0A, 0x46, 0x04, 0x8A, 0x4A, 0x0F, 0x83, 0x43, 0x0C, 0x86, 0x0A, 0x04};
const unsigned char EPD_1IN54B_lut_b[] = {0x0E, 0x14, 0x01, 0x8A, 0x06, 0x04, 0x8A, 0x4A, 0x0F, 0x83, 0x43, 0x0C, 0x06, 0x4A, 0x04};
const unsigned char EPD_1IN54B_lut_g1[] = {0x8E, 0x94, 0x01, 0x8A, 0x06, 0x04, 0x8A, 0x4A, 0x0F, 0x83, 0x43, 0x0C, 0x06, 0x0A, 0x04};
const unsigned char EPD_1IN54B_lut_g2[] = {0x8E, 0x94, 0x01, 0x8A, 0x06, 0x04, 0x8A, 0x4A, 0x0F, 0x83, 0x43, 0x0C, 0x06, 0x0A, 0x04};
const unsigned char EPD_1IN54B_lut_vcom1[] = {0x03, 0x1D, 0x01, 0x01, 0x08, 0x23, 0x37, 0x37, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
const unsigned char EPD_1IN54B_lut_red0[] = {0x83, 0x5D, 0x01, 0x81, 0x48, 0x23, 0x77, 0x77, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
const unsigned char EPD_1IN54B_lut_red1[] = {0x03, 0x1D, 0x01, 0x01, 0x08, 0x23, 0x37, 0x37, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_1IN54B_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(100);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(2);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(100);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_1IN54B_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_1IN54B_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_1IN54B_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(1) {
if(DEV_Digital_Read(EPD_BUSY_PIN) == 1)
break;
}
DEV_Delay_ms(200);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Set the look-up black and white tables
parameter:
******************************************************************************/
static void EPD_1IN54B_SetLutBw(void)
{
UWORD count;
EPD_1IN54B_SendCommand(0x20);// g vcom
for(count = 0; count < 15; count++) {
EPD_1IN54B_SendData(EPD_1IN54B_lut_vcom0[count]);
}
EPD_1IN54B_SendCommand(0x21);// g ww --
for(count = 0; count < 15; count++) {
EPD_1IN54B_SendData(EPD_1IN54B_lut_w[count]);
}
EPD_1IN54B_SendCommand(0x22);// g bw r
for(count = 0; count < 15; count++) {
EPD_1IN54B_SendData(EPD_1IN54B_lut_b[count]);
}
EPD_1IN54B_SendCommand(0x23);// g wb w
for(count = 0; count < 15; count++) {
EPD_1IN54B_SendData(EPD_1IN54B_lut_g1[count]);
}
EPD_1IN54B_SendCommand(0x24);// g bb b
for(count = 0; count < 15; count++) {
EPD_1IN54B_SendData(EPD_1IN54B_lut_g2[count]);
}
}
/******************************************************************************
function : Set the look-up red tables
parameter:
******************************************************************************/
static void EPD_1IN54B_SetLutRed(void)
{
UWORD count;
EPD_1IN54B_SendCommand(0x25);
for(count = 0; count < 15; count++) {
EPD_1IN54B_SendData(EPD_1IN54B_lut_vcom1[count]);
}
EPD_1IN54B_SendCommand(0x26);
for(count = 0; count < 15; count++) {
EPD_1IN54B_SendData(EPD_1IN54B_lut_red0[count]);
}
EPD_1IN54B_SendCommand(0x27);
for(count = 0; count < 15; count++) {
EPD_1IN54B_SendData(EPD_1IN54B_lut_red1[count]);
}
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_1IN54B_Init(void)
{
EPD_1IN54B_Reset();
EPD_1IN54B_SendCommand(0x01);// POWER_SETTING
EPD_1IN54B_SendData(0x07);
EPD_1IN54B_SendData(0x00);
EPD_1IN54B_SendData(0x08);
EPD_1IN54B_SendData(0x00);
EPD_1IN54B_SendCommand(0x06);// BOOSTER_SOFT_START
EPD_1IN54B_SendData(0x07);
EPD_1IN54B_SendData(0x07);
EPD_1IN54B_SendData(0x07);
EPD_1IN54B_SendCommand(0x04);// POWER_ON
EPD_1IN54B_ReadBusy();
EPD_1IN54B_SendCommand(0X00);// PANEL_SETTING
EPD_1IN54B_SendData(0xcf);
EPD_1IN54B_SendCommand(0X50);// VCOM_AND_DATA_INTERVAL_SETTING
EPD_1IN54B_SendData(0x37);// 0xF0
EPD_1IN54B_SendCommand(0x30);// PLL_CONTROL
EPD_1IN54B_SendData(0x39);
EPD_1IN54B_SendCommand(0x61);// TCON_RESOLUTION set x and y
EPD_1IN54B_SendData(0xC8);// 200
EPD_1IN54B_SendData(0x00);// y High eight: 0
EPD_1IN54B_SendData(0xC8);// y Low eight: 200
EPD_1IN54B_SendCommand(0x82);// VCM_DC_SETTING_REGISTER
EPD_1IN54B_SendData(0x0E);
EPD_1IN54B_SetLutBw();
EPD_1IN54B_SetLutRed();
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_1IN54B_Clear(void)
{
UWORD Width, Height;
Width = (EPD_1IN54B_WIDTH % 8 == 0)? (EPD_1IN54B_WIDTH / 8 ): (EPD_1IN54B_WIDTH / 8 + 1);
Height = EPD_1IN54B_HEIGHT;
//send black data
EPD_1IN54B_SendCommand(0x10);// DATA_START_TRANSMISSION_1
DEV_Delay_ms(2);
for(UWORD i = 0; i < Height; i++) {
for(UWORD i = 0; i < Width; i++) {
EPD_1IN54B_SendData(0xFF);
EPD_1IN54B_SendData(0xFF);
}
}
DEV_Delay_ms(2);
//send red data
EPD_1IN54B_SendCommand(0x13);// DATA_START_TRANSMISSION_2
DEV_Delay_ms(2);
for(UWORD i = 0; i < Height; i++) {
for(UWORD i = 0; i < Width; i++) {
EPD_1IN54B_SendData(0xFF);
}
}
DEV_Delay_ms(2);
EPD_1IN54B_SendCommand(0x12);// DISPLAY_REFRESH
EPD_1IN54B_ReadBusy();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_1IN54B_Display(const UBYTE *blackimage, const UBYTE *redimage)
{
UBYTE Temp = 0x00;
UWORD Width, Height;
Width = (EPD_1IN54B_WIDTH % 8 == 0)? (EPD_1IN54B_WIDTH / 8 ): (EPD_1IN54B_WIDTH / 8 + 1);
Height = EPD_1IN54B_HEIGHT;
EPD_1IN54B_SendCommand(0x10);// DATA_START_TRANSMISSION_1
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
Temp = 0x00;
for (int bit = 0; bit < 4; bit++) {
if ((blackimage[i + j * Width] & (0x80 >> bit)) != 0) {
Temp |= 0xC0 >> (bit * 2);
}
}
EPD_1IN54B_SendData(Temp);
Temp = 0x00;
for (int bit = 4; bit < 8; bit++) {
if ((blackimage[i + j * Width] & (0x80 >> bit)) != 0) {
Temp |= 0xC0 >> ((bit - 4) * 2);
}
}
EPD_1IN54B_SendData(Temp);
}
}
DEV_Delay_ms(2);
EPD_1IN54B_SendCommand(0x13);// DATA_START_TRANSMISSION_2
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_1IN54B_SendData(redimage[i + j * Width]);
}
}
DEV_Delay_ms(2);
//Display refresh
EPD_1IN54B_SendCommand(0x12);// DISPLAY_REFRESH
EPD_1IN54B_ReadBusy();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_1IN54B_Sleep(void)
{
EPD_1IN54B_SendCommand(0x50);// VCOM_AND_DATA_INTERVAL_SETTING
EPD_1IN54B_SendData(0x17);
EPD_1IN54B_SendCommand(0x82);// VCM_DC_SETTING_REGISTER
EPD_1IN54B_SendData(0x00);
EPD_1IN54B_SendCommand(0x01);// POWER_SETTING
EPD_1IN54B_SendData(0x02);
EPD_1IN54B_SendData(0x00);
EPD_1IN54B_SendData(0x00);
EPD_1IN54B_SendData(0x00);
EPD_1IN54B_ReadBusy();
DEV_Delay_ms(1000);
EPD_1IN54B_SendCommand(0x02);// POWER_OFF
}

108
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in54b.h Normal file
View file

@ -0,0 +1,108 @@
/*****************************************************************************
* | File : EPD_1in54b.h
* | Author : Waveshare team
* | Function : 1.54inch e-paper b
* | Info :
*----------------
* | This version: V3.1
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.1(2019-06-12):
* 1.Change:
* lut_vcom0[] => EPD_1IN54_lut_vcom0[]
* lut_w[] => EPD_1IN54_lut_w[]
* lut_b[] => EPD_1IN54B_lut_b[]
* lut_g1[] => EPD_1IN54B_lut_g1[]
* lut_g2[] => EPD_1IN54B_lut_g2[]
* lut_vcom1[] => EPD_1IN54B_lut_vcom1[]
* lut_red0[] => EPD_1IN54B_lut_red0[]
* lut_red1[] => EPD_1IN54B_lut_red1[]
* EPD_Reset() => EPD_1IN54B_Reset()
* EPD_SendCommand() => EPD_1IN54B_SendCommand()
* EPD_SendData() => EPD_1IN54B_SendData()
* EPD_WaitUntilIdle() => EPD_1IN54B_ReadBusy()
* EPD_SetLutBw() => EPD_1IN54B_SetLutBw()
* EPD_SetLutBw => EPD_1IN54B_SetLutBw()
* EPD_Init() => EPD_1IN54B_Init()
* EPD_Clear() => EPD_1IN54B_Clear()
* EPD_Display() => EPD_1IN54B_Display()
* EPD_Sleep() => EPD_1IN54B_Sleep()
* -----------------------------------------------------------------------------
* V3.0(2019-04-24):
* 1.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SOURCE_AND_GATE_START_SETTING 0x62
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
*
* -----------------------------------------------------------------------------
* V2.0(2018-10-30):
* 1.Remove:ImageBuff[EPD_1IN54B_HEIGHT * EPD_1IN54B_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_1IN54B_H_
#define __EPD_1IN54B_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_1IN54B_WIDTH 200
#define EPD_1IN54B_HEIGHT 200
void EPD_1IN54B_Init(void);
void EPD_1IN54B_Clear(void);
void EPD_1IN54B_Display(const UBYTE *blackimage, const UBYTE *redimage);
void EPD_1IN54B_Sleep(void);
#endif

194
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in54b_V2.c Normal file
View file

@ -0,0 +1,194 @@
/*****************************************************************************
* | File : EPD_1in54b_V2.h
* | Author : Waveshare team
* | Function : 1.54inch e-paper b V2
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-04-02
* | 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_1in54b_V2.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_1IN54B_V2_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(100);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(2);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(100);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_1IN54B_V2_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_1IN54B_V2_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_1IN54B_V2_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(1) {
if(DEV_Digital_Read(EPD_BUSY_PIN) == 0)
break;
}
DEV_Delay_ms(200);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_1IN54B_V2_Init(void)
{
EPD_1IN54B_V2_Reset();
EPD_1IN54B_V2_ReadBusy();
EPD_1IN54B_V2_SendCommand(0x12); //SWRESET
EPD_1IN54B_V2_ReadBusy();
EPD_1IN54B_V2_SendCommand(0x01); //Driver output control
EPD_1IN54B_V2_SendData(0xC7);
EPD_1IN54B_V2_SendData(0x00);
EPD_1IN54B_V2_SendData(0x01);
EPD_1IN54B_V2_SendCommand(0x11); //data entry mode
EPD_1IN54B_V2_SendData(0x01);
EPD_1IN54B_V2_SendCommand(0x44); //set Ram-X address start/end position
EPD_1IN54B_V2_SendData(0x00);
EPD_1IN54B_V2_SendData(0x18); //0x18-->(24+1)*8=200
EPD_1IN54B_V2_SendCommand(0x45); //set Ram-Y address start/end position
EPD_1IN54B_V2_SendData(0xC7); //0xC7-->(199+1)=200
EPD_1IN54B_V2_SendData(0x00);
EPD_1IN54B_V2_SendData(0x00);
EPD_1IN54B_V2_SendData(0x00);
EPD_1IN54B_V2_SendCommand(0x3C); //BorderWavefrom
EPD_1IN54B_V2_SendData(0x05);
EPD_1IN54B_V2_SendCommand(0x18); //Read built-in temperature sensor
EPD_1IN54B_V2_SendData(0x80);
EPD_1IN54B_V2_SendCommand(0x4E); // set RAM x address count to 0;
EPD_1IN54B_V2_SendData(0x00);
EPD_1IN54B_V2_SendCommand(0x4F); // set RAM y address count to 0X199;
EPD_1IN54B_V2_SendData(0xC7);
EPD_1IN54B_V2_SendData(0x00);
EPD_1IN54B_V2_ReadBusy();
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_1IN54B_V2_Clear(void)
{
unsigned int i;
EPD_1IN54B_V2_SendCommand(0x24); //write RAM for black(0)/white (1)
for(i=0;i<5000;i++)
{
EPD_1IN54B_V2_SendData(0xff);
}
EPD_1IN54B_V2_SendCommand(0x26); //write RAM for black(0)/white (1)
for(i=0;i<5000;i++)
{
EPD_1IN54B_V2_SendData(0x00);
}
EPD_1IN54B_V2_SendCommand(0x22); //Display Update Control
EPD_1IN54B_V2_SendData(0xF7);
EPD_1IN54B_V2_SendCommand(0x20); //Activate Display Update Sequence
EPD_1IN54B_V2_ReadBusy();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_1IN54B_V2_Display(const UBYTE *blackimage, const UBYTE *redimage)
{
UWORD Width, Height;
Width = (EPD_1IN54B_V2_WIDTH % 8 == 0)? (EPD_1IN54B_V2_WIDTH / 8 ): (EPD_1IN54B_V2_WIDTH / 8 + 1);
Height = EPD_1IN54B_V2_HEIGHT;
unsigned int i;
EPD_1IN54B_V2_SendCommand(0x24); //write RAM for black(0)/white (1)
for(i=0;i<Width*Height;i++)
{
EPD_1IN54B_V2_SendData(blackimage[i]);
}
EPD_1IN54B_V2_SendCommand(0x26); //write RAM for black(0)/white (1)
for(i=0;i<Width*Height;i++)
{
EPD_1IN54B_V2_SendData(~redimage[i]);
}
EPD_1IN54B_V2_SendCommand(0x22); //Display Update Control
EPD_1IN54B_V2_SendData(0xF7);
EPD_1IN54B_V2_SendCommand(0x20); //Activate Display Update Sequence
EPD_1IN54B_V2_ReadBusy();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_1IN54B_V2_Sleep(void)
{
EPD_1IN54B_V2_SendCommand(0x10); //enter deep sleep
EPD_1IN54B_V2_SendData(0x01);
DEV_Delay_ms(100);
}

45
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in54b_V2.h Normal file
View file

@ -0,0 +1,45 @@
/*****************************************************************************
* | File : EPD_1in54b_V2.h
* | Author : Waveshare team
* | Function : 1.54inch e-paper b V2
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-04-02
* | 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_1IN54B_V2_H_
#define __EPD_1IN54B_V2_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_1IN54B_V2_WIDTH 200
#define EPD_1IN54B_V2_HEIGHT 200
void EPD_1IN54B_V2_Init(void);
void EPD_1IN54B_V2_Clear(void);
void EPD_1IN54B_V2_Display(const UBYTE *blackimage, const UBYTE *redimage);
void EPD_1IN54B_V2_Sleep(void);
#endif

240
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in54c.c Normal file
View file

@ -0,0 +1,240 @@
/*****************************************************************************
* | File : EPD_1in54c.C
* | Author : Waveshare team
* | Function : 1.54inch e-paper c
* | Info :
*----------------
* | This version: V3.1
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.1(2019-06-12):
* 1.Change:
* EPD_Reset() => EPD_1IN54C_Reset()
* EPD_SendCommand() => EPD_1IN54C_SendCommand()
* EPD_SendData() => EPD_1IN54C_SendData()
* EPD_WaitUntilIdle() => EPD_1IN54C_ReadBusy()
* EPD_Init() => EPD_1IN54C_Init()
* EPD_Clear() => EPD_1IN54C_Clear()
* EPD_Display() => EPD_1IN54C_Display()
* EPD_Sleep() => EPD_1IN54C_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SOURCE_AND_GATE_START_SETTING 0x62
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* -----------------------------------------------------------------------------
* V2.0(2018-11-14):
* 1.Remove:ImageBuff[EPD_1IN54C_HEIGHT * EPD_1IN54C_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_1in54c.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_1IN54C_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(10);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(2);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(10);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_1IN54C_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_1IN54C_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_1IN54C_ReadBusy(void)
{
unsigned char busy;
do {
EPD_1IN54C_SendCommand(0x71);
busy = DEV_Digital_Read(EPD_BUSY_PIN);
busy =!(busy & 0x01);
} while(busy);
DEV_Delay_ms(200);
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_1IN54C_Init(void)
{
EPD_1IN54C_Reset();
EPD_1IN54C_SendCommand(0x06); //boost soft start
EPD_1IN54C_SendData(0x17);
EPD_1IN54C_SendData(0x17);
EPD_1IN54C_SendData(0x17);
EPD_1IN54C_SendCommand(0x04);
EPD_1IN54C_ReadBusy();
EPD_1IN54C_SendCommand(0x00); //panel setting
EPD_1IN54C_SendData(0x0f); //LUT from OTP£¬160x296
EPD_1IN54C_SendData(0x0d); //VCOM to 0V fast
EPD_1IN54C_SendCommand(0x61); //resolution setting
EPD_1IN54C_SendData(0x98); //152
EPD_1IN54C_SendData(0x00); //152
EPD_1IN54C_SendData(0x98);
EPD_1IN54C_SendCommand(0X50); //VCOM AND DATA INTERVAL SETTING
EPD_1IN54C_SendData(0x77); //WBmode:VBDF 17|D7 VBDW 97 VBDB 57 WBRmode:VBDF F7 VBDW 77 VBDB 37 VBDR B7
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_1IN54C_Clear(void)
{
UWORD Width, Height;
Width = (EPD_1IN54C_WIDTH % 8 == 0)? (EPD_1IN54C_WIDTH / 8 ): (EPD_1IN54C_WIDTH / 8 + 1);
Height = EPD_1IN54C_HEIGHT;
//send black data
EPD_1IN54C_SendCommand(0x10);
for(UWORD i = 0; i < Height; i++) {
for(UWORD i = 0; i < Width; i++) {
EPD_1IN54C_SendData(0xFF);
}
}
//send red data
EPD_1IN54C_SendCommand(0x13);
for(UWORD i = 0; i < Height; i++) {
for(UWORD i = 0; i < Width; i++) {
EPD_1IN54C_SendData(0xFF);
}
}
//Display refresh
EPD_1IN54C_SendCommand(0x12);
EPD_1IN54C_ReadBusy();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_1IN54C_Display(const UBYTE *blackimage, const UBYTE *redimage)
{
UWORD Width, Height;
Width = (EPD_1IN54C_WIDTH % 8 == 0)? (EPD_1IN54C_WIDTH / 8 ): (EPD_1IN54C_WIDTH / 8 + 1);
Height = EPD_1IN54C_HEIGHT;
//send black data
EPD_1IN54C_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_1IN54C_SendData(blackimage[i + j * Width]);
}
}
//send red data
EPD_1IN54C_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_1IN54C_SendData(redimage[i + j * Width]);
}
}
//Display refresh
EPD_1IN54C_SendCommand(0x12);
EPD_1IN54C_ReadBusy();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_1IN54C_Sleep(void)
{
EPD_1IN54C_SendCommand(0X02); //power off
EPD_1IN54C_ReadBusy();
EPD_1IN54C_SendCommand(0X07); //deep sleep
EPD_1IN54C_SendData(0xA5);
}

95
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_1in54c.h Normal file
View file

@ -0,0 +1,95 @@
/*****************************************************************************
* | File : EPD_1in54c.h
* | Author : Waveshare team
* | Function : 1.54inch e-paper c
* | Info :
*----------------
* | This version: V3.1
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.1(2019-06-12):
* 1.Change:
* EPD_Reset() => EPD_1IN54C_Reset()
* EPD_SendCommand() => EPD_1IN54C_SendCommand()
* EPD_SendData() => EPD_1IN54C_SendData()
* EPD_WaitUntilIdle() => EPD_1IN54C_ReadBusy()
* EPD_Init() => EPD_1IN54C_Init()
* EPD_Clear() => EPD_1IN54C_Clear()
* EPD_Display() => EPD_1IN54C_Display()
* EPD_Sleep() => EPD_1IN54C_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SOURCE_AND_GATE_START_SETTING 0x62
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* -----------------------------------------------------------------------------
* V2.0(2018-11-14):
* 1.Remove:ImageBuff[EPD_1IN54C_HEIGHT * EPD_1IN54C_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_1IN54C_H_
#define __EPD_1IN54C_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_1IN54C_WIDTH 152
#define EPD_1IN54C_HEIGHT 152
void EPD_1IN54C_Init(void);
void EPD_1IN54C_Clear(void);
void EPD_1IN54C_Display(const UBYTE *blackimage, const UBYTE *redimage);
void EPD_1IN54C_Sleep(void);
#endif

255
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in13.c Normal file
View file

@ -0,0 +1,255 @@
/*****************************************************************************
* | File : EPD_2IN13.c
* | Author : Waveshare team
* | Function : 2.13inch e-paper
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* 1.Change:
* EPD_Reset() => EPD_2IN13_Reset()
* EPD_SendCommand() => EPD_2IN13_SendCommand()
* EPD_SendData() => EPD_2IN13_SendData()
* EPD_WaitUntilIdle() => EPD_2IN13_ReadBusy()
* EPD_Init() => EPD_2IN13_Init()
* EPD_Clear() => EPD_2IN13_Clear()
* EPD_Display() => EPD_2IN13_Display()
* EPD_Sleep() => EPD_2IN13_Sleep()
* -----------------------------------------------------------------------------
* V2.0(2019-01-03):
* 1.Remove:ImageBuff[EPD_2IN13_HEIGHT * EPD_2IN13_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_2in13.h"
#include "Debug.h"
const unsigned char EPD_2IN13_lut_full_update[] = {
0x22, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x11,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00
};
const unsigned char EPD_2IN13_lut_partial_update[] = {
0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x0F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN13_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
******************************************************************************/
static void EPD_2IN13_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_2IN13_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:
******************************************************************************/
void EPD_2IN13_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 1) { //LOW: idle, HIGH: busy
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN13_TurnOnDisplay(void)
{
EPD_2IN13_SendCommand(0x22); // DISPLAY_UPDATE_CONTROL_2
EPD_2IN13_SendData(0xC4);
EPD_2IN13_SendCommand(0X20); // MASTER_ACTIVATION
EPD_2IN13_SendCommand(0xFF); // TERMINATE_FRAME_READ_WRITE
EPD_2IN13_ReadBusy();
}
static void EPD_2IN13_SetWindows(int x_start, int y_start, int x_end, int y_end)
{
EPD_2IN13_SendCommand(0x44);
/* x point must be the multiple of 8 or the last 3 bits will be ignored */
EPD_2IN13_SendData((x_start >> 3) & 0xFF);
EPD_2IN13_SendData((x_end >> 3) & 0xFF);
EPD_2IN13_SendCommand(0x45);
EPD_2IN13_SendData(y_start & 0xFF);
EPD_2IN13_SendData((y_start >> 8) & 0xFF);
EPD_2IN13_SendData(y_end & 0xFF);
EPD_2IN13_SendData((y_end >> 8) & 0xFF);
}
static void EPD_2IN13_SetCursor(int x, int y)
{
EPD_2IN13_SendCommand(0x4E);
/* x point must be the multiple of 8 or the last 3 bits will be ignored */
EPD_2IN13_SendData((x >> 3) & 0xFF);
EPD_2IN13_SendCommand(0x4F);
EPD_2IN13_SendData(y & 0xFF);
EPD_2IN13_SendData((y >> 8) & 0xFF);
// EPD_2IN13_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN13_Init(UBYTE Mode)
{
EPD_2IN13_Reset();
EPD_2IN13_SendCommand(0x01); // DRIVER_OUTPUT_CONTROL
EPD_2IN13_SendData((EPD_2IN13_HEIGHT - 1) & 0xFF);
EPD_2IN13_SendData(((EPD_2IN13_HEIGHT - 1) >> 8) & 0xFF);
EPD_2IN13_SendData(0x00); // GD = 0; SM = 0; TB = 0;
EPD_2IN13_SendCommand(0x0C); // BOOSTER_SOFT_START_CONTROL
EPD_2IN13_SendData(0xD7);
EPD_2IN13_SendData(0xD6);
EPD_2IN13_SendData(0x9D);
EPD_2IN13_SendCommand(0x2C); // WRITE_VCOM_REGISTER
EPD_2IN13_SendData(0xA8); // VCOM 7C
EPD_2IN13_SendCommand(0x3A); // SET_DUMMY_LINE_PERIOD
EPD_2IN13_SendData(0x1A); // 4 dummy lines per gate
EPD_2IN13_SendCommand(0x3B); // SET_GATE_TIME
EPD_2IN13_SendData(0x08); // 2us per line
EPD_2IN13_SendCommand(0X3C); // BORDER_WAVEFORM_CONTROL
EPD_2IN13_SendData(0x63);
EPD_2IN13_SendCommand(0X11); // DATA_ENTRY_MODE_SETTING
EPD_2IN13_SendData(0x03); // X increment; Y increment
//set the look-up table register
EPD_2IN13_SendCommand(0x32);
if(Mode == EPD_2IN13_FULL) {
for (UWORD i = 0; i < 30; i++) {
EPD_2IN13_SendData(EPD_2IN13_lut_full_update[i]);
}
} else if(Mode == EPD_2IN13_PART) {
for (UWORD i = 0; i < 30; i++) {
EPD_2IN13_SendData(EPD_2IN13_lut_partial_update[i]);
}
} else {
Debug("error, the Mode is EPD_2IN13_FULL or EPD_2IN13_PART");
}
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN13_Clear(void)
{
UWORD Width, Height;
Width = (EPD_2IN13_WIDTH % 8 == 0)? (EPD_2IN13_WIDTH / 8 ): (EPD_2IN13_WIDTH / 8 + 1);
Height = EPD_2IN13_HEIGHT;
EPD_2IN13_SetWindows(0, 0, EPD_2IN13_WIDTH, EPD_2IN13_HEIGHT);
for (UWORD j = 0; j < Height; j++) {
EPD_2IN13_SetCursor(0, j);
EPD_2IN13_SendCommand(0x24);
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13_SendData(0Xff);
}
}
EPD_2IN13_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN13_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_2IN13_WIDTH % 8 == 0)? (EPD_2IN13_WIDTH / 8 ): (EPD_2IN13_WIDTH / 8 + 1);
Height = EPD_2IN13_HEIGHT;
EPD_2IN13_SetWindows(0, 0, EPD_2IN13_WIDTH, EPD_2IN13_HEIGHT);
for (UWORD j = 0; j < Height; j++) {
EPD_2IN13_SetCursor(0, j);
EPD_2IN13_SendCommand(0x24);
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13_SendData(Image[i + j * Width]);
}
}
EPD_2IN13_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN13_Sleep(void)
{
EPD_2IN13_SendCommand(0x10); //DEEP_SLEEP_MODE
EPD_2IN13_SendData(0x01);
}

68
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in13.h Normal file
View file

@ -0,0 +1,68 @@
/*****************************************************************************
* | File : EPD_2IN13.h
* | Author : Waveshare team
* | Function : 2.13inch e-paper
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* 1.Change:
* EPD_Reset() => EPD_2IN13_Reset()
* EPD_SendCommand() => EPD_2IN13_SendCommand()
* EPD_SendData() => EPD_2IN13_SendData()
* EPD_WaitUntilIdle() => EPD_2IN13_ReadBusy()
* EPD_Init() => EPD_2IN13_Init()
* EPD_Clear() => EPD_2IN13_Clear()
* EPD_Display() => EPD_2IN13_Display()
* EPD_Sleep() => EPD_2IN13_Sleep()
* -----------------------------------------------------------------------------
* V2.0(2019-01-03):
* 1.Remove:ImageBuff[EPD_2IN13_HEIGHT * EPD_2IN13_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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 _EPD2IN13_H
#define _EPD2IN13_H
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN13_WIDTH 122
#define EPD_2IN13_HEIGHT 250
#define EPD_2IN13_FULL 0
#define EPD_2IN13_PART 1
void EPD_2IN13_Init(UBYTE Mode);
void EPD_2IN13_Clear(void);
void EPD_2IN13_Display(UBYTE *Image);
void EPD_2IN13_Sleep(void);
#endif

364
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in13_V2.c Normal file
View file

@ -0,0 +1,364 @@
/*****************************************************************************
* | File : EPD_2in13_V2.c
* | Author : Waveshare team
* | Function : 2.13inch e-paper V2
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change name:
* EPD_Reset() => EPD_2IN13_V2_Reset()
* EPD_SendCommand() => EPD_2IN13_V2_SendCommand()
* EPD_SendData() => EPD_2IN13_V2_SendData()
* EPD_WaitUntilIdle() => EPD_2IN13_V2_ReadBusy()
* EPD_Init() => EPD_2IN13_V2_Init()
* EPD_Clear() => EPD_2IN13_V2_Clear()
* EPD_Display() => EPD_2IN13_V2_Display()
* EPD_Sleep() => EPD_2IN13_V2_Sleep()
* 2.add:
* EPD_2IN13_V2_DisplayPartBaseImage()
* -----------------------------------------------------------------------------
* V2.0(2018-11-14):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_2IN13_V2_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_2in13_V2.h"
#include "Debug.h"
const unsigned char EPD_2IN13_V2_lut_full_update[]= {
0x80,0x60,0x40,0x00,0x00,0x00,0x00, //LUT0: BB: VS 0 ~7
0x10,0x60,0x20,0x00,0x00,0x00,0x00, //LUT1: BW: VS 0 ~7
0x80,0x60,0x40,0x00,0x00,0x00,0x00, //LUT2: WB: VS 0 ~7
0x10,0x60,0x20,0x00,0x00,0x00,0x00, //LUT3: WW: VS 0 ~7
0x00,0x00,0x00,0x00,0x00,0x00,0x00, //LUT4: VCOM: VS 0 ~7
0x03,0x03,0x00,0x00,0x02, // TP0 A~D RP0
0x09,0x09,0x00,0x00,0x02, // TP1 A~D RP1
0x03,0x03,0x00,0x00,0x02, // TP2 A~D RP2
0x00,0x00,0x00,0x00,0x00, // TP3 A~D RP3
0x00,0x00,0x00,0x00,0x00, // TP4 A~D RP4
0x00,0x00,0x00,0x00,0x00, // TP5 A~D RP5
0x00,0x00,0x00,0x00,0x00, // TP6 A~D RP6
0x15,0x41,0xA8,0x32,0x30,0x0A,
};
const unsigned char EPD_2IN13_V2_lut_partial_update[]= { //20 bytes
0x00,0x00,0x00,0x00,0x00,0x00,0x00, //LUT0: BB: VS 0 ~7
0x80,0x00,0x00,0x00,0x00,0x00,0x00, //LUT1: BW: VS 0 ~7
0x40,0x00,0x00,0x00,0x00,0x00,0x00, //LUT2: WB: VS 0 ~7
0x00,0x00,0x00,0x00,0x00,0x00,0x00, //LUT3: WW: VS 0 ~7
0x00,0x00,0x00,0x00,0x00,0x00,0x00, //LUT4: VCOM: VS 0 ~7
0x0A,0x00,0x00,0x00,0x00, // TP0 A~D RP0
0x00,0x00,0x00,0x00,0x00, // TP1 A~D RP1
0x00,0x00,0x00,0x00,0x00, // TP2 A~D RP2
0x00,0x00,0x00,0x00,0x00, // TP3 A~D RP3
0x00,0x00,0x00,0x00,0x00, // TP4 A~D RP4
0x00,0x00,0x00,0x00,0x00, // TP5 A~D RP5
0x00,0x00,0x00,0x00,0x00, // TP6 A~D RP6
0x15,0x41,0xA8,0x32,0x30,0x0A,
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN13_V2_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
******************************************************************************/
static void EPD_2IN13_V2_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_2IN13_V2_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:
******************************************************************************/
void EPD_2IN13_V2_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 1) { //LOW: idle, HIGH: busy
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN13_V2_TurnOnDisplay(void)
{
EPD_2IN13_V2_SendCommand(0x22);
EPD_2IN13_V2_SendData(0xC7);
EPD_2IN13_V2_SendCommand(0x20);
EPD_2IN13_V2_ReadBusy();
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN13_V2_TurnOnDisplayPart(void)
{
EPD_2IN13_V2_SendCommand(0x22);
EPD_2IN13_V2_SendData(0x0C);
EPD_2IN13_V2_SendCommand(0x20);
EPD_2IN13_V2_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN13_V2_Init(UBYTE Mode)
{
UBYTE count;
EPD_2IN13_V2_Reset();
if(Mode == EPD_2IN13_V2_FULL) {
EPD_2IN13_V2_ReadBusy();
EPD_2IN13_V2_SendCommand(0x12); // soft reset
EPD_2IN13_V2_ReadBusy();
EPD_2IN13_V2_SendCommand(0x74); //set analog block control
EPD_2IN13_V2_SendData(0x54);
EPD_2IN13_V2_SendCommand(0x7E); //set digital block control
EPD_2IN13_V2_SendData(0x3B);
EPD_2IN13_V2_SendCommand(0x01); //Driver output control
EPD_2IN13_V2_SendData(0xF9);
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendCommand(0x11); //data entry mode
EPD_2IN13_V2_SendData(0x01);
EPD_2IN13_V2_SendCommand(0x44); //set Ram-X address start/end position
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendData(0x0F); //0x0C-->(15+1)*8=128
EPD_2IN13_V2_SendCommand(0x45); //set Ram-Y address start/end position
EPD_2IN13_V2_SendData(0xF9); //0xF9-->(249+1)=250
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendCommand(0x3C); //BorderWavefrom
EPD_2IN13_V2_SendData(0x03);
EPD_2IN13_V2_SendCommand(0x2C); //VCOM Voltage
EPD_2IN13_V2_SendData(0x55); //
EPD_2IN13_V2_SendCommand(0x03);
EPD_2IN13_V2_SendData(EPD_2IN13_V2_lut_full_update[70]);
EPD_2IN13_V2_SendCommand(0x04); //
EPD_2IN13_V2_SendData(EPD_2IN13_V2_lut_full_update[71]);
EPD_2IN13_V2_SendData(EPD_2IN13_V2_lut_full_update[72]);
EPD_2IN13_V2_SendData(EPD_2IN13_V2_lut_full_update[73]);
EPD_2IN13_V2_SendCommand(0x3A); //Dummy Line
EPD_2IN13_V2_SendData(EPD_2IN13_V2_lut_full_update[74]);
EPD_2IN13_V2_SendCommand(0x3B); //Gate time
EPD_2IN13_V2_SendData(EPD_2IN13_V2_lut_full_update[75]);
EPD_2IN13_V2_SendCommand(0x32);
for(count = 0; count < 70; count++) {
EPD_2IN13_V2_SendData(EPD_2IN13_V2_lut_full_update[count]);
}
EPD_2IN13_V2_SendCommand(0x4E); // set RAM x address count to 0;
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendCommand(0x4F); // set RAM y address count to 0X127;
EPD_2IN13_V2_SendData(0xF9);
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_ReadBusy();
} else if(Mode == EPD_2IN13_V2_PART) {
EPD_2IN13_V2_SendCommand(0x2C); //VCOM Voltage
EPD_2IN13_V2_SendData(0x26);
EPD_2IN13_V2_ReadBusy();
EPD_2IN13_V2_SendCommand(0x32);
for(count = 0; count < 70; count++) {
EPD_2IN13_V2_SendData(EPD_2IN13_V2_lut_partial_update[count]);
}
EPD_2IN13_V2_SendCommand(0x37);
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendData(0x40);
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendData(0x00);
EPD_2IN13_V2_SendCommand(0x22);
EPD_2IN13_V2_SendData(0xC0);
EPD_2IN13_V2_SendCommand(0x20);
EPD_2IN13_V2_ReadBusy();
EPD_2IN13_V2_SendCommand(0x3C); //BorderWavefrom
EPD_2IN13_V2_SendData(0x01);
} else {
Debug("error, the Mode is EPD_2IN13_FULL or EPD_2IN13_PART");
}
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN13_V2_Clear(void)
{
UWORD Width, Height;
Width = (EPD_2IN13_V2_WIDTH % 8 == 0)? (EPD_2IN13_V2_WIDTH / 8 ): (EPD_2IN13_V2_WIDTH / 8 + 1);
Height = EPD_2IN13_V2_HEIGHT;
EPD_2IN13_V2_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13_V2_SendData(0XFF);
}
}
EPD_2IN13_V2_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN13_V2_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_2IN13_V2_WIDTH % 8 == 0)? (EPD_2IN13_V2_WIDTH / 8 ): (EPD_2IN13_V2_WIDTH / 8 + 1);
Height = EPD_2IN13_V2_HEIGHT;
EPD_2IN13_V2_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13_V2_SendData(Image[i + j * Width]);
}
}
EPD_2IN13_V2_TurnOnDisplay();
}
/******************************************************************************
function : The image of the previous frame must be uploaded, otherwise the
first few seconds will display an exception.
parameter:
******************************************************************************/
void EPD_2IN13_V2_DisplayPartBaseImage(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_2IN13_V2_WIDTH % 8 == 0)? (EPD_2IN13_V2_WIDTH / 8 ): (EPD_2IN13_V2_WIDTH / 8 + 1);
Height = EPD_2IN13_V2_HEIGHT;
UDOUBLE Addr = 0;
EPD_2IN13_V2_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
Addr = i + j * Width;
EPD_2IN13_V2_SendData(Image[Addr]);
}
}
EPD_2IN13_V2_SendCommand(0x26);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
Addr = i + j * Width;
EPD_2IN13_V2_SendData(Image[Addr]);
}
}
EPD_2IN13_V2_TurnOnDisplay();
}
void EPD_2IN13_V2_DisplayPart(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_2IN13_V2_WIDTH % 8 == 0)? (EPD_2IN13_V2_WIDTH / 8 ): (EPD_2IN13_V2_WIDTH / 8 + 1);
Height = EPD_2IN13_V2_HEIGHT;
EPD_2IN13_V2_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13_V2_SendData(Image[i + j * Width]);
}
}
EPD_2IN13_V2_TurnOnDisplayPart();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN13_V2_Sleep(void)
{
EPD_2IN13_V2_SendCommand(0x22); //POWER OFF
EPD_2IN13_V2_SendData(0xC3);
EPD_2IN13_V2_SendCommand(0x20);
EPD_2IN13_V2_SendCommand(0x10); //enter deep sleep
EPD_2IN13_V2_SendData(0x01);
DEV_Delay_ms(100);
}

72
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in13_V2.h Normal file
View file

@ -0,0 +1,72 @@
/*****************************************************************************
* | File : EPD_2in13_V2.h
* | Author : Waveshare team
* | Function : 2.13inch e-paper V2
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change name:
* EPD_Reset() => EPD_2IN13_V2_Reset()
* EPD_SendCommand() => EPD_2IN13_V2_SendCommand()
* EPD_SendData() => EPD_2IN13_V2_SendData()
* EPD_WaitUntilIdle() => EPD_2IN13_V2_ReadBusy()
* EPD_Init() => EPD_2IN13_V2_Init()
* EPD_Clear() => EPD_2IN13_V2_Clear()
* EPD_Display() => EPD_2IN13_V2_Display()
* EPD_Sleep() => EPD_2IN13_V2_Sleep()
* 2.add:
* EPD_2IN13_V2_DisplayPartBaseImage()
* -----------------------------------------------------------------------------
* V2.0(2018-11-14):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_2IN13_V2_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_2IN13_V2_H_
#define _EPD_2IN13_V2_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN13_V2_WIDTH 122
#define EPD_2IN13_V2_HEIGHT 250
#define EPD_2IN13_V2_FULL 0
#define EPD_2IN13_V2_PART 1
void EPD_2IN13_V2_Init(UBYTE Mode);
void EPD_2IN13_V2_Clear(void);
void EPD_2IN13_V2_Display(UBYTE *Image);
void EPD_2IN13_V2_DisplayPart(UBYTE *Image);
void EPD_2IN13_V2_DisplayPartBaseImage(UBYTE *Image);
void EPD_2IN13_V2_Sleep(void);
#endif

197
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in13b_V3.c Normal file
View file

@ -0,0 +1,197 @@
/*****************************************************************************
* | File : EPD_2in13b_V3.c
* | Author : Waveshare team
* | Function : 2.13inch e-paper b V3
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-04-13
* | 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_2in13b_V3.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN13B_V3_Reset(void)
{
DEV_Digital_Write(EPD_CS_PIN, 1);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(10);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(2);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(10);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_2IN13B_V3_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_2IN13B_V3_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:
******************************************************************************/
void EPD_2IN13B_V3_ReadBusy(void)
{
UBYTE busy;
Debug("e-Paper busy\r\n");
do{
EPD_2IN13B_V3_SendCommand(0x71);
busy = DEV_Digital_Read(EPD_BUSY_PIN);
busy =!(busy & 0x01);
}while(busy);
Debug("e-Paper busy release\r\n");
DEV_Delay_ms(200);
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN13B_V3_TurnOnDisplay(void)
{
EPD_2IN13B_V3_SendCommand(0x12); //DISPLAY REFRESH
DEV_Delay_ms(100);
EPD_2IN13B_V3_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN13B_V3_Init(void)
{
EPD_2IN13B_V3_Reset();
DEV_Delay_ms(10);
EPD_2IN13B_V3_SendCommand(0x04);
EPD_2IN13B_V3_ReadBusy();//waiting for the electronic paper IC to release the idle signal
EPD_2IN13B_V3_SendCommand(0x00);//panel setting
EPD_2IN13B_V3_SendData(0x0f);//LUT from OTP，128x296
EPD_2IN13B_V3_SendData(0x89);//Temperature sensor, boost and other related timing settings
EPD_2IN13B_V3_SendCommand(0x61);//resolution setting
EPD_2IN13B_V3_SendData (0x68);
EPD_2IN13B_V3_SendData (0x00);
EPD_2IN13B_V3_SendData (0xD4);
EPD_2IN13B_V3_SendCommand(0X50);//VCOM AND DATA INTERVAL SETTING
EPD_2IN13B_V3_SendData(0x77);//WBmode:VBDF 17|D7 VBDW 97 VBDB 57
//WBRmode:VBDF F7 VBDW 77 VBDB 37 VBDR B7;
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN13B_V3_Clear(void)
{
UWORD Width = (EPD_2IN13B_V3_WIDTH % 8 == 0)? (EPD_2IN13B_V3_WIDTH / 8 ): (EPD_2IN13B_V3_WIDTH / 8 + 1);
UWORD Height = EPD_2IN13B_V3_HEIGHT;
//send black data
EPD_2IN13B_V3_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13B_V3_SendData(0xFF);
}
}
//send red data
EPD_2IN13B_V3_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13B_V3_SendData(0xFF);
}
}
EPD_2IN13B_V3_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN13B_V3_Display(const UBYTE *blackimage, const UBYTE *ryimage)
{
UWORD Width, Height;
Width = (EPD_2IN13B_V3_WIDTH % 8 == 0)? (EPD_2IN13B_V3_WIDTH / 8 ): (EPD_2IN13B_V3_WIDTH / 8 + 1);
Height = EPD_2IN13B_V3_HEIGHT;
EPD_2IN13B_V3_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13B_V3_SendData(blackimage[i + j * Width]);
}
}
EPD_2IN13B_V3_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13B_V3_SendData(ryimage[i + j * Width]);
}
}
EPD_2IN13B_V3_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN13B_V3_Sleep(void)
{
EPD_2IN13B_V3_SendCommand(0X50);
EPD_2IN13B_V3_SendData(0xf7);
EPD_2IN13B_V3_SendCommand(0X02); //power off
EPD_2IN13B_V3_ReadBusy(); //waiting for the electronic paper IC to release the idle signal
EPD_2IN13B_V3_SendCommand(0X07); //deep sleep
EPD_2IN13B_V3_SendData(0xA5);
}

45
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in13b_V3.h Normal file
View file

@ -0,0 +1,45 @@
/*****************************************************************************
* | File : EPD_2in13b_V3.h
* | Author : Waveshare team
* | Function : 2.13inch e-paper b V3
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-04-13
* | 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_2IN13B_V3_H_
#define __EPD_2IN13B_V3_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN13B_V3_WIDTH 104
#define EPD_2IN13B_V3_HEIGHT 212
void EPD_2IN13B_V3_Init(void);
void EPD_2IN13B_V3_Clear(void);
void EPD_2IN13B_V3_Display(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_2IN13B_V3_Sleep(void);
#endif

247
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in13bc.c Normal file
View file

@ -0,0 +1,247 @@
/*****************************************************************************
* | File : EPD_2in13bc.c
* | Author : Waveshare team
* | Function : 2.13inch e-paper b&c
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_2IN13BC_Reset()
* EPD_SendCommand() => EPD_2IN13BC_SendCommand()
* EPD_SendData() => EPD_2IN13BC_SendData()
* EPD_WaitUntilIdle() => EPD_2IN13BC_ReadBusy()
* EPD_Init() => EPD_2IN13BC_Init()
* EPD_Clear() => EPD_2IN13BC_Clear()
* EPD_Display() => EPD_2IN13BC_Display()
* EPD_Sleep() => EPD_2IN13BC_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define VCOM_LUT 0x20
* #define W2W_LUT 0x21
* #define B2W_LUT 0x22
* #define W2B_LUT 0x23
* #define B2B_LUT 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_CALIBRATION 0x40
* #define TEMPERATURE_SENSOR_SELECTION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define RESOLUTION_SETTING 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* V2.0(2018-11-13):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_2in13bc.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN13BC_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
******************************************************************************/
static void EPD_2IN13BC_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_2IN13BC_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:
******************************************************************************/
void EPD_2IN13BC_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 0) {
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN13BC_TurnOnDisplay(void)
{
EPD_2IN13BC_SendCommand(0x12); //DISPLAY REFRESH
DEV_Delay_ms(10);
EPD_2IN13BC_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN13BC_Init(void)
{
EPD_2IN13BC_Reset();
EPD_2IN13BC_SendCommand(0x06); // BOOSTER_SOFT_START
EPD_2IN13BC_SendData(0x17);
EPD_2IN13BC_SendData(0x17);
EPD_2IN13BC_SendData(0x17);
EPD_2IN13BC_SendCommand(0x04); // POWER_ON
EPD_2IN13BC_ReadBusy();
EPD_2IN13BC_SendCommand(0x00); // PANEL_SETTING
EPD_2IN13BC_SendData(0x8F);
EPD_2IN13BC_SendCommand(0x50); // VCOM_AND_DATA_INTERVAL_SETTING
EPD_2IN13BC_SendData(0xF0);
EPD_2IN13BC_SendCommand(0x61); // RESOLUTION_SETTING
EPD_2IN13BC_SendData(EPD_2IN13BC_WIDTH); // width: 104
EPD_2IN13BC_SendData(EPD_2IN13BC_HEIGHT >> 8); // height: 212
EPD_2IN13BC_SendData(EPD_2IN13BC_HEIGHT & 0xFF);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN13BC_Clear(void)
{
UWORD Width = (EPD_2IN13BC_WIDTH % 8 == 0)? (EPD_2IN13BC_WIDTH / 8 ): (EPD_2IN13BC_WIDTH / 8 + 1);
UWORD Height = EPD_2IN13BC_HEIGHT;
//send black data
EPD_2IN13BC_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13BC_SendData(0xFF);
}
}
EPD_2IN13BC_SendCommand(0x92);
//send red data
EPD_2IN13BC_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13BC_SendData(0xFF);
}
}
EPD_2IN13BC_SendCommand(0x92);
EPD_2IN13BC_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN13BC_Display(const UBYTE *blackimage, const UBYTE *ryimage)
{
UWORD Width, Height;
Width = (EPD_2IN13BC_WIDTH % 8 == 0)? (EPD_2IN13BC_WIDTH / 8 ): (EPD_2IN13BC_WIDTH / 8 + 1);
Height = EPD_2IN13BC_HEIGHT;
EPD_2IN13BC_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13BC_SendData(blackimage[i + j * Width]);
}
}
EPD_2IN13BC_SendCommand(0x92);
EPD_2IN13BC_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13BC_SendData(ryimage[i + j * Width]);
}
}
EPD_2IN13BC_SendCommand(0x92);
EPD_2IN13BC_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN13BC_Sleep(void)
{
EPD_2IN13BC_SendCommand(0x02); // POWER_OFF
EPD_2IN13BC_ReadBusy();
EPD_2IN13BC_SendCommand(0x07); // DEEP_SLEEP
EPD_2IN13BC_SendData(0xA5); // check code
}

97
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in13bc.h Normal file
View file

@ -0,0 +1,97 @@
/*****************************************************************************
* | File : EPD_2in13bc.h
* | Author : Waveshare team
* | Function : 2.13inch e-paper b&c
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_2IN13BC_Reset()
* EPD_SendCommand() => EPD_2IN13BC_SendCommand()
* EPD_SendData() => EPD_2IN13BC_SendData()
* EPD_WaitUntilIdle() => EPD_2IN13BC_ReadBusy()
* EPD_Init() => EPD_2IN13BC_Init()
* EPD_Clear() => EPD_2IN13BC_Clear()
* EPD_Display() => EPD_2IN13BC_Display()
* EPD_Sleep() => EPD_2IN13BC_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define VCOM_LUT 0x20
* #define W2W_LUT 0x21
* #define B2W_LUT 0x22
* #define W2B_LUT 0x23
* #define B2B_LUT 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_CALIBRATION 0x40
* #define TEMPERATURE_SENSOR_SELECTION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define RESOLUTION_SETTING 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* V2.0(2018-11-13):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_2IN13BC_H_
#define __EPD_2IN13BC_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN13BC_WIDTH 104
#define EPD_2IN13BC_HEIGHT 212
void EPD_2IN13BC_Init(void);
void EPD_2IN13BC_Clear(void);
void EPD_2IN13BC_Display(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_2IN13BC_Sleep(void);
#endif

461
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in13d.c Normal file
View file

@ -0,0 +1,461 @@
/*****************************************************************************
* | File : EPD_2in13d.c
* | Author : Waveshare team
* | Function : 2.13inch e-paper d
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* 1.Change:
* lut_vcomDC[] => EPD_2IN13D_lut_vcomDC[]
* lut_ww[] => EPD_2IN13D_lut_ww[]
* lut_bw[] => EPD_2IN13D_lut_bw[]
* lut_wb[] => EPD_2IN13D_lut_wb[]
* lut_bb[] => EPD_2IN13D_lut_bb[]
* lut_vcom1[] => EPD_2IN13D_lut_vcom1[]
* lut_ww1[] => EPD_2IN13D_lut_ww1[]
* lut_bw1[] => EPD_2IN13D_lut_bw1[]
* lut_wb1[] => EPD_2IN13D_lut_wb1[]
* lut_bb1[] => EPD_2IN13D_lut_bb1[]
* EPD_Reset() => EPD_2IN13D_Reset()
* EPD_SendCommand() => EPD_2IN13D_SendCommand()
* EPD_SendData() => EPD_2IN13D_SendData()
* EPD_WaitUntilIdle() => EPD_2IN13D_ReadBusy()
* EPD_SetFullReg() => EPD_2IN13D_SetFullReg()
* EPD_SetPartReg() => EPD_2IN13D_SetPartReg()
* EPD_TurnOnDisplay() => EPD_2IN13D_TurnOnDisplay()
* EPD_Init() => EPD_2IN13D_Init()
* EPD_Clear() => EPD_2IN13D_Clear()
* EPD_Display() => EPD_2IN13D_Display()
* EPD_Sleep() => EPD_2IN13D_Sleep()
* V2.0(2018-11-13):
* 1.Remove:ImageBuff[EPD_2IN13D_HEIGHT * EPD_2IN13D_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_2in13d.h"
#include "Debug.h"
/**
* full screen update LUT
**/
static const unsigned char EPD_2IN13D_lut_vcomDC[] = {
0x00, 0x08, 0x00, 0x00, 0x00, 0x02,
0x60, 0x28, 0x28, 0x00, 0x00, 0x01,
0x00, 0x14, 0x00, 0x00, 0x00, 0x01,
0x00, 0x12, 0x12, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00,
};
static const unsigned char EPD_2IN13D_lut_ww[] = {
0x40, 0x08, 0x00, 0x00, 0x00, 0x02,
0x90, 0x28, 0x28, 0x00, 0x00, 0x01,
0x40, 0x14, 0x00, 0x00, 0x00, 0x01,
0xA0, 0x12, 0x12, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const unsigned char EPD_2IN13D_lut_bw[] = {
0x40, 0x17, 0x00, 0x00, 0x00, 0x02,
0x90, 0x0F, 0x0F, 0x00, 0x00, 0x03,
0x40, 0x0A, 0x01, 0x00, 0x00, 0x01,
0xA0, 0x0E, 0x0E, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const unsigned char EPD_2IN13D_lut_wb[] = {
0x80, 0x08, 0x00, 0x00, 0x00, 0x02,
0x90, 0x28, 0x28, 0x00, 0x00, 0x01,
0x80, 0x14, 0x00, 0x00, 0x00, 0x01,
0x50, 0x12, 0x12, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const unsigned char EPD_2IN13D_lut_bb[] = {
0x80, 0x08, 0x00, 0x00, 0x00, 0x02,
0x90, 0x28, 0x28, 0x00, 0x00, 0x01,
0x80, 0x14, 0x00, 0x00, 0x00, 0x01,
0x50, 0x12, 0x12, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
/**
* partial screen update LUT
**/
static const unsigned char EPD_2IN13D_lut_vcom1[] = {
0x00, 0x19, 0x01, 0x00, 0x00, 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,
};
static const unsigned char EPD_2IN13D_lut_ww1[] = {
0x00, 0x19, 0x01, 0x00, 0x00, 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,
};
static const unsigned char EPD_2IN13D_lut_bw1[] = {
0x80, 0x19, 0x01, 0x00, 0x00, 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,
};
static const unsigned char EPD_2IN13D_lut_wb1[] = {
0x40, 0x19, 0x01, 0x00, 0x00, 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,
};
static const unsigned char EPD_2IN13D_lut_bb1[] = {
0x00, 0x19, 0x01, 0x00, 0x00, 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,
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN13D_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
******************************************************************************/
static void EPD_2IN13D_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_2IN13D_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_2IN13D_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
UBYTE busy;
do {
EPD_2IN13D_SendCommand(0x71);
busy = DEV_Digital_Read(EPD_BUSY_PIN);
busy =!(busy & 0x01);
} while(busy);
DEV_Delay_ms(200);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : LUT download
parameter:
******************************************************************************/
static void EPD_2IN13D_SetFullReg(void)
{
EPD_2IN13D_SendCommand(0X50); //VCOM AND DATA INTERVAL SETTING
EPD_2IN13D_SendData(0xb7); //WBmode:VBDF 17|D7 VBDW 97 VBDB 57 WBRmode:VBDF F7 VBDW 77 VBDB 37 VBDR B7
unsigned int count;
EPD_2IN13D_SendCommand(0x20);
for(count=0; count<44; count++) {
EPD_2IN13D_SendData(EPD_2IN13D_lut_vcomDC[count]);
}
EPD_2IN13D_SendCommand(0x21);
for(count=0; count<42; count++) {
EPD_2IN13D_SendData(EPD_2IN13D_lut_ww[count]);
}
EPD_2IN13D_SendCommand(0x22);
for(count=0; count<42; count++) {
EPD_2IN13D_SendData(EPD_2IN13D_lut_bw[count]);
}
EPD_2IN13D_SendCommand(0x23);
for(count=0; count<42; count++) {
EPD_2IN13D_SendData(EPD_2IN13D_lut_wb[count]);
}
EPD_2IN13D_SendCommand(0x24);
for(count=0; count<42; count++) {
EPD_2IN13D_SendData(EPD_2IN13D_lut_bb[count]);
}
}
/******************************************************************************
function : LUT download
parameter:
******************************************************************************/
static void EPD_2IN13D_SetPartReg(void)
{
EPD_2IN13D_SendCommand(0x82); //vcom_DC setting
EPD_2IN13D_SendData(0x00);
EPD_2IN13D_SendCommand(0X50);
EPD_2IN13D_SendData(0xb7);
unsigned int count;
EPD_2IN13D_SendCommand(0x20);
for(count=0; count<44; count++) {
EPD_2IN13D_SendData(EPD_2IN13D_lut_vcom1[count]);
}
EPD_2IN13D_SendCommand(0x21);
for(count=0; count<42; count++) {
EPD_2IN13D_SendData(EPD_2IN13D_lut_ww1[count]);
}
EPD_2IN13D_SendCommand(0x22);
for(count=0; count<42; count++) {
EPD_2IN13D_SendData(EPD_2IN13D_lut_bw1[count]);
}
EPD_2IN13D_SendCommand(0x23);
for(count=0; count<42; count++) {
EPD_2IN13D_SendData(EPD_2IN13D_lut_wb1[count]);
}
EPD_2IN13D_SendCommand(0x24);
for(count=0; count<42; count++) {
EPD_2IN13D_SendData(EPD_2IN13D_lut_bb1[count]);
}
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN13D_TurnOnDisplay(void)
{
EPD_2IN13D_SendCommand(0x12); //DISPLAY REFRESH
DEV_Delay_ms(100); //!!!The delay here is necessary, 200uS at least!!!
EPD_2IN13D_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN13D_Init()
{
EPD_2IN13D_Reset();
EPD_2IN13D_SendCommand(0x01); //POWER SETTING
EPD_2IN13D_SendData(0x03);
EPD_2IN13D_SendData(0x00);
EPD_2IN13D_SendData(0x2b);
EPD_2IN13D_SendData(0x2b);
EPD_2IN13D_SendData(0x03);
EPD_2IN13D_SendCommand(0x06); //boost soft start
EPD_2IN13D_SendData(0x17); //A
EPD_2IN13D_SendData(0x17); //B
EPD_2IN13D_SendData(0x17); //C
EPD_2IN13D_SendCommand(0x04);
EPD_2IN13D_ReadBusy();
EPD_2IN13D_SendCommand(0x00); //panel setting
EPD_2IN13D_SendData(0xbf); //LUT from OTP，128x296
EPD_2IN13D_SendData(0x0e); //VCOM to 0V fast
EPD_2IN13D_SendCommand(0x30); //PLL setting
EPD_2IN13D_SendData(0x3a); // 3a 100HZ 29 150Hz 39 200HZ 31 171HZ
EPD_2IN13D_SendCommand(0x61); //resolution setting
EPD_2IN13D_SendData(EPD_2IN13D_WIDTH);
EPD_2IN13D_SendData((EPD_2IN13D_HEIGHT >> 8) & 0xff);
EPD_2IN13D_SendData(EPD_2IN13D_HEIGHT& 0xff);
EPD_2IN13D_SendCommand(0x82); //vcom_DC setting
EPD_2IN13D_SendData(0x28);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN13D_Clear(void)
{
UWORD Width, Height;
Width = (EPD_2IN13D_WIDTH % 8 == 0)? (EPD_2IN13D_WIDTH / 8 ): (EPD_2IN13D_WIDTH / 8 + 1);
Height = EPD_2IN13D_HEIGHT;
EPD_2IN13D_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13D_SendData(0x00);
}
}
EPD_2IN13D_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13D_SendData(0xff);
}
}
EPD_2IN13D_SetFullReg();
EPD_2IN13D_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN13D_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_2IN13D_WIDTH % 8 == 0)? (EPD_2IN13D_WIDTH / 8 ): (EPD_2IN13D_WIDTH / 8 + 1);
Height = EPD_2IN13D_HEIGHT;
EPD_2IN13D_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13D_SendData(0x00);
}
}
// Dev_Delay_ms(10);
EPD_2IN13D_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13D_SendData(Image[i + j * Width]);
}
}
// Dev_Delay_ms(10);
EPD_2IN13D_SetFullReg();
EPD_2IN13D_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN13D_DisplayPart(UBYTE *Image)
{
/* Set partial Windows */
EPD_2IN13D_SendCommand(0x91); //This command makes the display enter partial mode
EPD_2IN13D_SendCommand(0x90); //resolution setting
EPD_2IN13D_SendData(0); //x-start
EPD_2IN13D_SendData(EPD_2IN13D_WIDTH - 1); //x-end
EPD_2IN13D_SendData(0);
EPD_2IN13D_SendData(0); //y-start
EPD_2IN13D_SendData(EPD_2IN13D_HEIGHT / 256);
EPD_2IN13D_SendData(EPD_2IN13D_HEIGHT % 256 - 1); //y-end
EPD_2IN13D_SendData(0x28);
UWORD Width;
Width = (EPD_2IN13D_WIDTH % 8 == 0)? (EPD_2IN13D_WIDTH / 8 ): (EPD_2IN13D_WIDTH / 8 + 1);
/* send data */
EPD_2IN13D_SendCommand(0x10);
for (UWORD j = 0; j < EPD_2IN13D_HEIGHT; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13D_SendData(~Image[i + j * Width]);
}
}
EPD_2IN13D_SendCommand(0x13);
for (UWORD j = 0; j < EPD_2IN13D_HEIGHT; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN13D_SendData(Image[i + j * Width]);
}
}
EPD_2IN13D_SetPartReg();
/* Set partial refresh */
EPD_2IN13D_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN13D_Sleep(void)
{
EPD_2IN13D_SendCommand(0X50);
EPD_2IN13D_SendData(0xf7);
EPD_2IN13D_SendCommand(0X02); //power off
EPD_2IN13D_SendCommand(0X07); //deep sleep
EPD_2IN13D_SendData(0xA5);
}

78
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in13d.h Normal file
View file

@ -0,0 +1,78 @@
/*****************************************************************************
* | File : EPD_2in13d.h
* | Author : Waveshare team
* | Function : 2.13inch e-paper d
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* 1.Change:
* lut_vcomDC[] => EPD_2IN13D_lut_vcomDC[]
* lut_ww[] => EPD_2IN13D_lut_ww[]
* lut_bw[] => EPD_2IN13D_lut_bw[]
* lut_wb[] => EPD_2IN13D_lut_wb[]
* lut_bb[] => EPD_2IN13D_lut_bb[]
* lut_vcom1[] => EPD_2IN13D_lut_vcom1[]
* lut_ww1[] => EPD_2IN13D_lut_ww1[]
* lut_bw1[] => EPD_2IN13D_lut_bw1[]
* lut_wb1[] => EPD_2IN13D_lut_wb1[]
* lut_bb1[] => EPD_2IN13D_lut_bb1[]
* EPD_Reset() => EPD_2IN13D_Reset()
* EPD_SendCommand() => EPD_2IN13D_SendCommand()
* EPD_SendData() => EPD_2IN13D_SendData()
* EPD_WaitUntilIdle() => EPD_2IN13D_ReadBusy()
* EPD_SetFullReg() => EPD_2IN13D_SetFullReg()
* EPD_SetPartReg() => EPD_2IN13D_SetPartReg()
* EPD_TurnOnDisplay() => EPD_2IN13D_TurnOnDisplay()
* EPD_Init() => EPD_2IN13D_Init()
* EPD_Clear() => EPD_2IN13D_Clear()
* EPD_Display() => EPD_2IN13D_Display()
* EPD_Sleep() => EPD_2IN13D_Sleep()
* V2.0(2018-11-13):
* 1.Remove:ImageBuff[EPD_2IN13D_HEIGHT * EPD_2IN13D_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_2IN13D_H_
#define __EPD_2IN13D_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN13D_WIDTH 104
#define EPD_2IN13D_HEIGHT 212
void EPD_2IN13D_Init(void);
void EPD_2IN13D_Clear(void);
void EPD_2IN13D_Display(UBYTE *Image);
void EPD_2IN13D_DisplayPart(UBYTE *Image);
void EPD_2IN13D_Sleep(void);
#endif

278
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in66.c Normal file
View file

@ -0,0 +1,278 @@
/*****************************************************************************
* | File : EPD_2in66.c
* | Author : Waveshare team
* | Function : 2.66inch e-paper
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-07-21
* | 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_2in66.h"
#include "Debug.h"
const unsigned char WF_PARTIAL[159] ={
0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x80,0x80,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x40,0x40,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x0A,0x00,0x00,0x00,0x00,0x00,0x02,0x01,0x00,0x00,
0x00,0x00,0x00,0x00,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,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x22,0x22,0x22,0x22,0x22,0x22,
0x00,0x00,0x00,0x22,0x17,0x41,0xB0,0x32,0x36,
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN66_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
******************************************************************************/
static void EPD_2IN66_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_2IN66_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_2IN66_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
DEV_Delay_ms(200);
while(DEV_Digital_Read(EPD_BUSY_PIN) == 1) { //LOW: idle, HIGH: busy
DEV_Delay_ms(5);
}
DEV_Delay_ms(100);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Send LUT
parameter:
******************************************************************************/
static void EPD_2IN66_SetLUA(void)
{
UWORD count;
EPD_2IN66_SendCommand(0x32);
for(count=0;count<153;count++){
EPD_2IN66_SendData(WF_PARTIAL[count]);
}
EPD_2IN66_ReadBusy();
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN66_TurnOnDisplay(void)
{
EPD_2IN66_SendCommand(0x20);
EPD_2IN66_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN66_Init(void)
{
EPD_2IN66_Reset();
EPD_2IN66_ReadBusy();
EPD_2IN66_SendCommand(0x12);//soft reset
EPD_2IN66_ReadBusy();
/* Y increment, X increment */
EPD_2IN66_SendCommand(0x11);
EPD_2IN66_SendData(0x03);
/* Set RamX-address Start/End position */
EPD_2IN66_SendCommand(0x44);
EPD_2IN66_SendData(0x01);
EPD_2IN66_SendData((EPD_2IN66_WIDTH % 8 == 0)? (EPD_2IN66_WIDTH / 8 ): (EPD_2IN66_WIDTH / 8 + 1) );
/* Set RamY-address Start/End position */
EPD_2IN66_SendCommand(0x45);
EPD_2IN66_SendData(0);
EPD_2IN66_SendData(0);
EPD_2IN66_SendData((EPD_2IN66_HEIGHT&0xff));
EPD_2IN66_SendData((EPD_2IN66_HEIGHT&0x100)>>8);
EPD_2IN66_SendCommand(0x3C); // Border 设置 黑白一般设置为跟随白波形即 0x01 Border setting
EPD_2IN66_SendData(0x01);
}
/******************************************************************************
function : Initialize the e-Paper register (Partial display)
parameter:
******************************************************************************/
void EPD_2IN66_Init_partial(void)
{
EPD_2IN66_Reset();
EPD_2IN66_ReadBusy();
EPD_2IN66_SendCommand(0x12);//soft reset
EPD_2IN66_ReadBusy();
EPD_2IN66_SetLUA();
EPD_2IN66_SendCommand(0x37);
EPD_2IN66_SendData(0x00);
EPD_2IN66_SendData(0x00);
EPD_2IN66_SendData(0x00);
EPD_2IN66_SendData(0x00);
EPD_2IN66_SendData(0x00);
EPD_2IN66_SendData(0x40);
EPD_2IN66_SendData(0x00);
EPD_2IN66_SendData(0x00);
EPD_2IN66_SendData(0x00);
EPD_2IN66_SendData(0x00);
/* Y increment, X increment */
EPD_2IN66_SendCommand(0x11);
EPD_2IN66_SendData(0x03);
/* Set RamX-address Start/End position */
EPD_2IN66_SendCommand(0x44);
EPD_2IN66_SendData(0x01);
EPD_2IN66_SendData((EPD_2IN66_WIDTH % 8 == 0)? (EPD_2IN66_WIDTH / 8 ): (EPD_2IN66_WIDTH / 8 + 1) );
/* Set RamY-address Start/End position */
EPD_2IN66_SendCommand(0x45);
EPD_2IN66_SendData(0);
EPD_2IN66_SendData(0);
EPD_2IN66_SendData((EPD_2IN66_HEIGHT&0xff));
EPD_2IN66_SendData((EPD_2IN66_HEIGHT&0x100)>>8);
EPD_2IN66_SendCommand(0x3C);
EPD_2IN66_SendData(0x80);
EPD_2IN66_SendCommand(0x22);
EPD_2IN66_SendData(0xcf);
EPD_2IN66_SendCommand(0x20);
EPD_2IN66_ReadBusy();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN66_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_2IN66_WIDTH % 8 == 0)? (EPD_2IN66_WIDTH / 8 ): (EPD_2IN66_WIDTH / 8 + 1);
Height = EPD_2IN66_HEIGHT;
EPD_2IN66_SendCommand(0x4E);
EPD_2IN66_SendData(0x01);
EPD_2IN66_SendCommand(0x4F);
EPD_2IN66_SendData(0x27);
EPD_2IN66_SendData(0x01);
EPD_2IN66_ReadBusy();
EPD_2IN66_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN66_SendData(Image[i + j * Width]);
}
}
EPD_2IN66_TurnOnDisplay();
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN66_Clear(void)
{
UWORD Width, Height;
Width = (EPD_2IN66_WIDTH % 8 == 0)? (EPD_2IN66_WIDTH / 8 ): (EPD_2IN66_WIDTH / 8 + 1);
Height = EPD_2IN66_HEIGHT;
EPD_2IN66_SendCommand(0x4E);
EPD_2IN66_SendData(0x01);
EPD_2IN66_SendCommand(0x4F);
EPD_2IN66_SendData(0x27);
EPD_2IN66_SendData(0x01);
EPD_2IN66_ReadBusy();
EPD_2IN66_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN66_SendData(0xff);
}
}
EPD_2IN66_SendCommand(0x26);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN66_SendData(0xff);
}
}
EPD_2IN66_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN66_Sleep(void)
{
EPD_2IN66_SendCommand(0x10);
EPD_2IN66_SendData(0x01);
}

47
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in66.h Normal file
View file

@ -0,0 +1,47 @@
/*****************************************************************************
* | File : EPD_2in66.h
* | Author : Waveshare team
* | Function : 2.66inch e-paper
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-07-21
* | 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_2IN66_H_
#define __EPD_2IN66_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN66_WIDTH 152
#define EPD_2IN66_HEIGHT 296
void EPD_2IN66_Init(void);
void EPD_2IN66_Display(UBYTE *Image);
void EPD_2IN66_Clear(void);
void EPD_2IN66_Init_partial();
void EPD_2IN66_Sleep(void);
#endif

213
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in66b.c Normal file
View file

@ -0,0 +1,213 @@
/*****************************************************************************
* | File : EPD_2in66b.c
* | Author : Waveshare team
* | Function : 2.66inch e-paper b
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-11-13
* | 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_2in66b.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN66B_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
******************************************************************************/
static void EPD_2IN66B_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_2IN66B_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_2IN66B_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
DEV_Delay_ms(50);
while(DEV_Digital_Read(EPD_BUSY_PIN) == 1) { //LOW: idle, HIGH: busy
DEV_Delay_ms(10);
}
DEV_Delay_ms(50);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN66B_TurnOnDisplay(void)
{
EPD_2IN66B_SendCommand(0x20);
EPD_2IN66B_ReadBusy();
}
/******************************************************************************
function : Setting the display window
parameter:
******************************************************************************/
static void EPD_2IN66B_SetWindows(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend)
{
EPD_2IN66B_SendCommand(0x44); // SET_RAM_X_ADDRESS_START_END_POSITION
EPD_2IN66B_SendData((Xstart>>3) & 0x1F);
EPD_2IN66B_SendData((Xend>>3) & 0x1F);
EPD_2IN66B_SendCommand(0x45); // SET_RAM_Y_ADDRESS_START_END_POSITION
EPD_2IN66B_SendData(Ystart & 0xFF);
EPD_2IN66B_SendData((Ystart >> 8) & 0x01);
EPD_2IN66B_SendData(Yend & 0xFF);
EPD_2IN66B_SendData((Yend >> 8) & 0x01);
}
/******************************************************************************
function : Set Cursor
parameter:
******************************************************************************/
static void EPD_2IN66B_SetCursor(UWORD Xstart, UWORD Ystart)
{
EPD_2IN66B_SendCommand(0x4E); // SET_RAM_X_ADDRESS_COUNTER
EPD_2IN66B_SendData(Xstart & 0x1F);
EPD_2IN66B_SendCommand(0x4F); // SET_RAM_Y_ADDRESS_COUNTER
EPD_2IN66B_SendData(Ystart & 0xFF);
EPD_2IN66B_SendData((Ystart >> 8) & 0x01);
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN66B_Init(void)
{
EPD_2IN66B_Reset();
EPD_2IN66B_ReadBusy();
EPD_2IN66B_SendCommand(0x12);//soft reset
EPD_2IN66B_ReadBusy();
EPD_2IN66B_SendCommand(0x11); //data entry mode
EPD_2IN66B_SendData(0x03);
EPD_2IN66B_SetWindows(0, 0, EPD_2IN66B_WIDTH-1, EPD_2IN66B_HEIGHT-1);
EPD_2IN66B_SendCommand(0x21); // Display update control
EPD_2IN66B_SendData(0x00);
EPD_2IN66B_SendData(0x80);
EPD_2IN66B_SetCursor(0, 0);
EPD_2IN66B_ReadBusy();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN66B_Display(UBYTE *ImageBlack, UBYTE*ImageRed)
{
UWORD Width, Height;
Width = (EPD_2IN66B_WIDTH % 8 == 0)? (EPD_2IN66B_WIDTH / 8 ): (EPD_2IN66B_WIDTH / 8 + 1);
Height = EPD_2IN66B_HEIGHT;
EPD_2IN66B_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN66B_SendData(ImageBlack[i + j * Width]);
}
}
EPD_2IN66B_SendCommand(0x26);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN66B_SendData(~ImageRed[i + j * Width]);
}
}
EPD_2IN66B_TurnOnDisplay();
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN66B_Clear(void)
{
UWORD Width, Height;
Width = (EPD_2IN66B_WIDTH % 8 == 0)? (EPD_2IN66B_WIDTH / 8 ): (EPD_2IN66B_WIDTH / 8 + 1);
Height = EPD_2IN66B_HEIGHT;
EPD_2IN66B_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN66B_SendData(0xff);
}
}
EPD_2IN66B_SendCommand(0x26);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN66B_SendData(0x00);
}
}
EPD_2IN66B_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN66B_Sleep(void)
{
EPD_2IN66B_SendCommand(0x10);
EPD_2IN66B_SendData(0x01);
}

44
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in66b.h Normal file
View file

@ -0,0 +1,44 @@
/*****************************************************************************
* | File : EPD_2in66b.h
* | Author : Waveshare team
* | Function : 2.66inch e-paper b
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-11-13
* | 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_2IN66B_H_
#define __EPD_2IN66B_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN66B_WIDTH 152
#define EPD_2IN66B_HEIGHT 296
void EPD_2IN66B_Init(void);
void EPD_2IN66B_Display(UBYTE *ImageBlack, UBYTE*ImageRed);
void EPD_2IN66B_Clear(void);
void EPD_2IN66B_Sleep(void);
#endif

611
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in7.c Normal file
View file

@ -0,0 +1,611 @@
/*****************************************************************************
* | File : EPD_2in7.c
* | Author : Waveshare team
* | Function : 2.7inch e-paper
* | Info :
*----------------
* | This version: V3.1
* | Date : 2019-10-10
* | Info :
* -----------------------------------------------------------------------------
* V3.1(2019-10-10):
* 1. Add 4 grayscale display
* Add EPD_2in7_gray_lut_vcom[]
* Add EPD_2in7_gray_lut_ww[]
* Add EPD_2in7_gray_lut_bw[]
* Add EPD_2in7_gray_lut_wb[]
* Add EPD_2in7_gray_lut_bb[]
* Add EPD_2in7_gray_SetLut()
* Add EPD_2IN7_Init_4Gray()
* Add EPD_2IN7_4GrayDisplay()
* V3.0(2019-06-12):
* 1.Change:
* lut_vcom_dc[] => EPD_2in7_lut_vcom_dc[]
* lut_ww[] => EPD_2in7_lut_ww[]
* lut_bw[] => EPD_2in7_lut_bw[]
* lut_bb[] => EPD_2in7_lut_bb[]
* lut_wb[] => EPD_2in7_lut_wb[]
* EPD_Reset() => EPD_2in7_Reset()
* EPD_SendCommand() => EPD_2in7_SendCommand()
* EPD_SendData() => EPD_2in7_SendData()
* EPD_WaitUntilIdle() => EPD_2in7_ReadBusy()
* EPD_SetLut() => EPD_2in7_SetLut()
* EPD_Init() => EPD_2in7_Init()
* EPD_Clear() => EPD_2in7_Clear()
* EPD_Display() => EPD_2in7_Display()
* EPD_Sleep() => EPD_2in7_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SOURCE_AND_GATE_START_SETTING 0x62
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* -----------------------------------------------------------------------------
* V2.0(2018-11-06):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_2in7.h"
#include "Debug.h"
static const unsigned char EPD_2in7_lut_vcom_dc[] = {
0x00 ,0x00,
0x00 ,0x08 ,0x00 ,0x00 ,0x00 ,0x02,
0x60 ,0x28 ,0x28 ,0x00 ,0x00 ,0x01,
0x00 ,0x14 ,0x00 ,0x00 ,0x00 ,0x01,
0x00 ,0x12 ,0x12 ,0x00 ,0x00 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
};
static const unsigned char EPD_2in7_lut_ww[] = {
0x40 ,0x08 ,0x00 ,0x00 ,0x00 ,0x02,
0x90 ,0x28 ,0x28 ,0x00 ,0x00 ,0x01,
0x40 ,0x14 ,0x00 ,0x00 ,0x00 ,0x01,
0xA0 ,0x12 ,0x12 ,0x00 ,0x00 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
static const unsigned char EPD_2in7_lut_bw[] = {
0x40 ,0x08 ,0x00 ,0x00 ,0x00 ,0x02,
0x90 ,0x28 ,0x28 ,0x00 ,0x00 ,0x01,
0x40 ,0x14 ,0x00 ,0x00 ,0x00 ,0x01,
0xA0 ,0x12 ,0x12 ,0x00 ,0x00 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
static const unsigned char EPD_2in7_lut_bb[] = {
0x80 ,0x08 ,0x00 ,0x00 ,0x00 ,0x02,
0x90 ,0x28 ,0x28 ,0x00 ,0x00 ,0x01,
0x80 ,0x14 ,0x00 ,0x00 ,0x00 ,0x01,
0x50 ,0x12 ,0x12 ,0x00 ,0x00 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
static const unsigned char EPD_2in7_lut_wb[] = {
0x80 ,0x08 ,0x00 ,0x00 ,0x00 ,0x02,
0x90 ,0x28 ,0x28 ,0x00 ,0x00 ,0x01,
0x80 ,0x14 ,0x00 ,0x00 ,0x00 ,0x01,
0x50 ,0x12 ,0x12 ,0x00 ,0x00 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
//////////////////////////////////////full screen update LUT////////////////////////////////////////////
//0~3 gray
static const unsigned char EPD_2in7_gray_lut_vcom[] = {
0x00 ,0x00,
0x00 ,0x0A ,0x00 ,0x00 ,0x00 ,0x01,
0x60 ,0x14 ,0x14 ,0x00 ,0x00 ,0x01,
0x00 ,0x14 ,0x00 ,0x00 ,0x00 ,0x01,
0x00 ,0x13 ,0x0A ,0x01 ,0x00 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
//R21
static const unsigned char EPD_2in7_gray_lut_ww[] = {
0x40 ,0x0A ,0x00 ,0x00 ,0x00 ,0x01,
0x90 ,0x14 ,0x14 ,0x00 ,0x00 ,0x01,
0x10 ,0x14 ,0x0A ,0x00 ,0x00 ,0x01,
0xA0 ,0x13 ,0x01 ,0x00 ,0x00 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
//R22H r
static const unsigned char EPD_2in7_gray_lut_bw[] = {
0x40 ,0x0A ,0x00 ,0x00 ,0x00 ,0x01,
0x90 ,0x14 ,0x14 ,0x00 ,0x00 ,0x01,
0x00 ,0x14 ,0x0A ,0x00 ,0x00 ,0x01,
0x99 ,0x0C ,0x01 ,0x03 ,0x04 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
//R23H w
static const unsigned char EPD_2in7_gray_lut_wb[] = {
0x40 ,0x0A ,0x00 ,0x00 ,0x00 ,0x01,
0x90 ,0x14 ,0x14 ,0x00 ,0x00 ,0x01,
0x00 ,0x14 ,0x0A ,0x00 ,0x00 ,0x01,
0x99 ,0x0B ,0x04 ,0x04 ,0x01 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
//R24H b
static const unsigned char EPD_2in7_gray_lut_bb[] = {
0x80 ,0x0A ,0x00 ,0x00 ,0x00 ,0x01,
0x90 ,0x14 ,0x14 ,0x00 ,0x00 ,0x01,
0x20 ,0x14 ,0x0A ,0x00 ,0x00 ,0x01,
0x50 ,0x13 ,0x01 ,0x00 ,0x00 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2in7_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
******************************************************************************/
static void EPD_2in7_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_2in7_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_2in7_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
UBYTE busy;
do {
EPD_2in7_SendCommand(0x71);
busy = DEV_Digital_Read(EPD_BUSY_PIN);
busy =!(busy & 0x01);
} while(busy);
DEV_Delay_ms(200);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : set the look-up tables
parameter:
******************************************************************************/
static void EPD_2in7_SetLut(void)
{
unsigned int count;
EPD_2in7_SendCommand(0x20); //vcom
for(count = 0; count < 44; count++) {
EPD_2in7_SendData(EPD_2in7_lut_vcom_dc[count]);
}
EPD_2in7_SendCommand(0x21); //ww --
for(count = 0; count < 42; count++) {
EPD_2in7_SendData(EPD_2in7_lut_ww[count]);
}
EPD_2in7_SendCommand(0x22); //bw r
for(count = 0; count < 42; count++) {
EPD_2in7_SendData(EPD_2in7_lut_bw[count]);
}
EPD_2in7_SendCommand(0x23); //wb w
for(count = 0; count < 42; count++) {
EPD_2in7_SendData(EPD_2in7_lut_bb[count]);
}
EPD_2in7_SendCommand(0x24); //bb b
for(count = 0; count < 42; count++) {
EPD_2in7_SendData(EPD_2in7_lut_wb[count]);
}
}
void EPD_2in7_gray_SetLut(void)
{
unsigned int count;
EPD_2in7_SendCommand(0x20); //vcom
for(count=0; count<44; count++) {
EPD_2in7_SendData(EPD_2in7_gray_lut_vcom[count]);
}
EPD_2in7_SendCommand(0x21); //red not use
for(count=0; count<42; count++) {
EPD_2in7_SendData(EPD_2in7_gray_lut_ww[count]);
}
EPD_2in7_SendCommand(0x22); //bw r
for(count=0; count<42; count++) {
EPD_2in7_SendData(EPD_2in7_gray_lut_bw[count]);
}
EPD_2in7_SendCommand(0x23); //wb w
for(count=0; count<42; count++) {
EPD_2in7_SendData(EPD_2in7_gray_lut_wb[count]);
}
EPD_2in7_SendCommand(0x24); //bb b
for(count=0; count<42; count++) {
EPD_2in7_SendData(EPD_2in7_gray_lut_bb[count]);
}
EPD_2in7_SendCommand(0x25); //vcom
for(count=0; count<42; count++) {
EPD_2in7_SendData(EPD_2in7_gray_lut_ww[count]);
}
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN7_Init(void)
{
EPD_2in7_Reset();
EPD_2in7_SendCommand(0x01); // POWER_SETTING
EPD_2in7_SendData(0x03); // VDS_EN, VDG_EN
EPD_2in7_SendData(0x00); // VCOM_HV, VGHL_LV[1], VGHL_LV[0]
EPD_2in7_SendData(0x2b); // VDH
EPD_2in7_SendData(0x2b); // VDL
EPD_2in7_SendData(0x09); // VDHR
EPD_2in7_SendCommand(0x06); // BOOSTER_SOFT_START
EPD_2in7_SendData(0x07);
EPD_2in7_SendData(0x07);
EPD_2in7_SendData(0x17);
// Power optimization
EPD_2in7_SendCommand(0xF8);
EPD_2in7_SendData(0x60);
EPD_2in7_SendData(0xA5);
// Power optimization
EPD_2in7_SendCommand(0xF8);
EPD_2in7_SendData(0x89);
EPD_2in7_SendData(0xA5);
// Power optimization
EPD_2in7_SendCommand(0xF8);
EPD_2in7_SendData(0x90);
EPD_2in7_SendData(0x00);
// Power optimization
EPD_2in7_SendCommand(0xF8);
EPD_2in7_SendData(0x93);
EPD_2in7_SendData(0x2A);
// Power optimization
EPD_2in7_SendCommand(0xF8);
EPD_2in7_SendData(0xA0);
EPD_2in7_SendData(0xA5);
// Power optimization
EPD_2in7_SendCommand(0xF8);
EPD_2in7_SendData(0xA1);
EPD_2in7_SendData(0x00);
// Power optimization
EPD_2in7_SendCommand(0xF8);
EPD_2in7_SendData(0x73);
EPD_2in7_SendData(0x41);
EPD_2in7_SendCommand(0x16); // PARTIAL_DISPLAY_REFRESH
EPD_2in7_SendData(0x00);
EPD_2in7_SendCommand(0x04); // POWER_ON
EPD_2in7_ReadBusy();
EPD_2in7_SendCommand(0x00); // PANEL_SETTING
EPD_2in7_SendData(0xAF); // KW-BF KWR-AF BWROTP 0f
EPD_2in7_SendCommand(0x30); // PLL_CONTROL
EPD_2in7_SendData(0x3A); // 3A 100HZ 29 150Hz 39 200HZ 31 171HZ
EPD_2in7_SendCommand(0x82); // VCM_DC_SETTING_REGISTER
EPD_2in7_SendData(0x12);
EPD_2in7_SetLut();
}
void EPD_2IN7_Init_4Gray(void)
{
EPD_2in7_Reset();
EPD_2in7_SendCommand(0x01); //POWER SETTING
EPD_2in7_SendData (0x03);
EPD_2in7_SendData (0x00);
EPD_2in7_SendData (0x2b);
EPD_2in7_SendData (0x2b);
EPD_2in7_SendCommand(0x06); //booster soft start
EPD_2in7_SendData (0x07); //A
EPD_2in7_SendData (0x07); //B
EPD_2in7_SendData (0x17); //C
EPD_2in7_SendCommand(0xF8); //boost??
EPD_2in7_SendData (0x60);
EPD_2in7_SendData (0xA5);
EPD_2in7_SendCommand(0xF8); //boost??
EPD_2in7_SendData (0x89);
EPD_2in7_SendData (0xA5);
EPD_2in7_SendCommand(0xF8); //boost??
EPD_2in7_SendData (0x90);
EPD_2in7_SendData (0x00);
EPD_2in7_SendCommand(0xF8); //boost??
EPD_2in7_SendData (0x93);
EPD_2in7_SendData (0x2A);
EPD_2in7_SendCommand(0xF8); //boost??
EPD_2in7_SendData (0xa0);
EPD_2in7_SendData (0xa5);
EPD_2in7_SendCommand(0xF8); //boost??
EPD_2in7_SendData (0xa1);
EPD_2in7_SendData (0x00);
EPD_2in7_SendCommand(0xF8); //boost??
EPD_2in7_SendData (0x73);
EPD_2in7_SendData (0x41);
EPD_2in7_SendCommand(0x16);
EPD_2in7_SendData(0x00);
EPD_2in7_SendCommand(0x04);
EPD_2in7_ReadBusy();
EPD_2in7_SendCommand(0x00); //panel setting
EPD_2in7_SendData(0xbf); //KW-BF KWR-AF BWROTP 0f
EPD_2in7_SendCommand(0x30); //PLL setting
EPD_2in7_SendData (0x90); //100hz
EPD_2in7_SendCommand(0x61); //resolution setting
EPD_2in7_SendData (0x00); //176
EPD_2in7_SendData (0xb0);
EPD_2in7_SendData (0x01); //264
EPD_2in7_SendData (0x08);
EPD_2in7_SendCommand(0x82); //vcom_DC setting
EPD_2in7_SendData (0x12);
EPD_2in7_SendCommand(0X50); //VCOM AND DATA INTERVAL SETTING
EPD_2in7_SendData(0x97);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN7_Clear(void)
{
UWORD Width, Height;
Width = (EPD_2IN7_WIDTH % 8 == 0)? (EPD_2IN7_WIDTH / 8 ): (EPD_2IN7_WIDTH / 8 + 1);
Height = EPD_2IN7_HEIGHT;
EPD_2in7_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2in7_SendData(0XFF);
}
}
EPD_2in7_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2in7_SendData(0XFF);
}
}
EPD_2in7_SendCommand(0x12);
EPD_2in7_ReadBusy();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN7_Display(const UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_2IN7_WIDTH % 8 == 0)? (EPD_2IN7_WIDTH / 8 ): (EPD_2IN7_WIDTH / 8 + 1);
Height = EPD_2IN7_HEIGHT;
/* EPD_2in7_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2in7_SendData(0XFF);
}
}
*/
EPD_2in7_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2in7_SendData(Image[i + j * Width]);
}
}
EPD_2in7_SendCommand(0x12);
EPD_2in7_ReadBusy();
}
void EPD_2IN7_4GrayDisplay(const UBYTE *Image)
{
UDOUBLE i,j,k;
UBYTE temp1,temp2,temp3;
// old data
EPD_2in7_SendCommand(0x10);
for(i=0; i<5808; i++) { //5808*4 46464
temp3=0;
for(j=0; j<2; j++) {
temp1 = Image[i*2+j];
for(k=0; k<2; k++) {
temp2 = temp1&0xC0;
if(temp2 == 0xC0)
temp3 |= 0x01;//white
else if(temp2 == 0x00)
temp3 |= 0x00; //black
else if(temp2 == 0x80)
temp3 |= 0x01; //gray1
else //0x40
temp3 |= 0x00; //gray2
temp3 <<= 1;
temp1 <<= 2;
temp2 = temp1&0xC0 ;
if(temp2 == 0xC0) //white
temp3 |= 0x01;
else if(temp2 == 0x00) //black
temp3 |= 0x00;
else if(temp2 == 0x80)
temp3 |= 0x01; //gray1
else //0x40
temp3 |= 0x00; //gray2
if(j!=1 || k!=1)
temp3 <<= 1;
temp1 <<= 2;
}
}
EPD_2in7_SendData(temp3);
}
// new data
EPD_2in7_SendCommand(0x13);
for(i=0; i<5808; i++) { //5808*4 46464
temp3=0;
for(j=0; j<2; j++) {
temp1 = Image[i*2+j];
for(k=0; k<2; k++) {
temp2 = temp1&0xC0 ;
if(temp2 == 0xC0)
temp3 |= 0x01;//white
else if(temp2 == 0x00)
temp3 |= 0x00; //black
else if(temp2 == 0x80)
temp3 |= 0x00; //gray1
else //0x40
temp3 |= 0x01; //gray2
temp3 <<= 1;
temp1 <<= 2;
temp2 = temp1&0xC0 ;
if(temp2 == 0xC0) //white
temp3 |= 0x01;
else if(temp2 == 0x00) //black
temp3 |= 0x00;
else if(temp2 == 0x80)
temp3 |= 0x00; //gray1
else //0x40
temp3 |= 0x01; //gray2
if(j!=1 || k!=1)
temp3 <<= 1;
temp1 <<= 2;
}
}
EPD_2in7_SendData(temp3);
}
EPD_2in7_gray_SetLut();
EPD_2in7_SendCommand(0x12);
DEV_Delay_ms(200);
EPD_2in7_ReadBusy();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN7_Sleep(void)
{
EPD_2in7_SendCommand(0X50);
EPD_2in7_SendData(0xf7);
EPD_2in7_SendCommand(0X02); //power off
EPD_2in7_SendCommand(0X07); //deep sleep
EPD_2in7_SendData(0xA5);
}

111
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in7.h Normal file
View file

@ -0,0 +1,111 @@
/*****************************************************************************
* | File : EPD_2in7.h
* | Author : Waveshare team
* | Function : 2.7inch e-paper
* | Info :
*----------------
* | This version: V3.1
* | Date : 2019-10-10
* | Info :
* -----------------------------------------------------------------------------
* V3.1(2019-10-10):
* 1. Add 4 grayscale display
* Add EPD_2in7_gray_lut_vcom[]
* Add EPD_2in7_gray_lut_ww[]
* Add EPD_2in7_gray_lut_bw[]
* Add EPD_2in7_gray_lut_wb[]
* Add EPD_2in7_gray_lut_bb[]
* Add EPD_2in7_gray_SetLut()
* Add EPD_2IN7_Init_4Gray()
* Add EPD_2IN7_4GrayDisplay()
*
* V3.0(2019-06-12):
* 1.Change:
* lut_vcom_dc[] => EPD_2in7_lut_vcom_dc[]
* lut_ww[] => EPD_2in7_lut_ww[]
* lut_bw[] => EPD_2in7_lut_bw[]
* lut_bb[] => EPD_2in7_lut_bb[]
* lut_wb[] => EPD_2in7_lut_wb[]
* EPD_Reset() => EPD_2in7_Reset()
* EPD_SendCommand() => EPD_2in7_SendCommand()
* EPD_SendData() => EPD_2in7_SendData()
* EPD_WaitUntilIdle() => EPD_2in7_ReadBusy()
* EPD_SetLut() => EPD_2in7_SetLut()
* EPD_Init() => EPD_2in7_Init()
* EPD_Clear() => EPD_2in7_Clear()
* EPD_Display() => EPD_2in7_Display()
* EPD_Sleep() => EPD_2in7_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SOURCE_AND_GATE_START_SETTING 0x62
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* -----------------------------------------------------------------------------
* V2.0(2018-11-06):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_2IN7_H_
#define __EPD_2IN7_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN7_WIDTH 176
#define EPD_2IN7_HEIGHT 264 //46464
void EPD_2IN7_Init(void);
void EPD_2IN7_Clear(void);
void EPD_2IN7_Display(const UBYTE *Image);
void EPD_2IN7_Sleep(void);
void EPD_2IN7_Init_4Gray(void);
void EPD_2IN7_4GrayDisplay(const UBYTE *Image);
#endif

348
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in7b.c Normal file
View file

@ -0,0 +1,348 @@
/*****************************************************************************
* | File : EPD_2in7b.c
* | Author : Waveshare team
* | Function : 2.7inch e-paper b
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* lut_vcom_dc[] => EPD_2in7B_lut_vcom_dc[]
* lut_ww[] => EPD_2in7B_lut_ww[]
* lut_bw[] => EPD_2in7B_lut_bw[]
* lut_bb[] => EPD_2in7B_lut_bb[]
* lut_wb[] => EPD_2in7B_lut_wb[]
* EPD_Reset() => EPD_2in7B_Reset()
* EPD_2IN7B_SendCommand() => EPD_2in7B_SendCommand()
* EPD_2IN7B_SendData() => EPD_2in7B_SendData()
* EPD_2IN7B_ReadBusy() => EPD_2in7B_ReadBusy()
* EPD_SetLut() => EPD_2in7B_SetLut()
* EPD_Init() => EPD_2in7B_Init()
* EPD_Clear() => EPD_2in7B_Clear()
* EPD_Display() => EPD_2in7B_Display()
* EPD_Sleep() => EPD_2in7B_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PARTIAL_DATA_START_TRANSMISSION_1 0x14
* #define PARTIAL_DATA_START_TRANSMISSION_2 0x15
* #define PARTIAL_DISPLAY_REFRESH 0x16
* #define LUT_FOR_VCOM 0x20
* #define LUT_WHITE_TO_WHITE 0x21
* #define LUT_BLACK_TO_WHITE 0x22
* #define LUT_WHITE_TO_BLACK 0x23
* #define LUT_BLACK_TO_BLACK 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SOURCE_AND_GATE_START_SETTING 0x62
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* -----------------------------------------------------------------------------
* V2.0(2018-10-30):
* 1.Remove:ImageBuff[EPD_2IN7B_HEIGHT * EPD_2IN7B_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_2in7b.h"
#include "Debug.h"
static const unsigned char EPD_2IN7B_lut_vcom_dc[] = {
0x00, 0x00,
0x00, 0x1A, 0x1A, 0x00, 0x00, 0x01,
0x00, 0x0A, 0x0A, 0x00, 0x00, 0x08,
0x00, 0x0E, 0x01, 0x0E, 0x01, 0x10,
0x00, 0x0A, 0x0A, 0x00, 0x00, 0x08,
0x00, 0x04, 0x10, 0x00, 0x00, 0x05,
0x00, 0x03, 0x0E, 0x00, 0x00, 0x0A,
0x00, 0x23, 0x00, 0x00, 0x00, 0x01
};
//R21H
static const unsigned char EPD_2IN7B_lut_ww[] = {
0x90, 0x1A, 0x1A, 0x00, 0x00, 0x01,
0x40, 0x0A, 0x0A, 0x00, 0x00, 0x08,
0x84, 0x0E, 0x01, 0x0E, 0x01, 0x10,
0x80, 0x0A, 0x0A, 0x00, 0x00, 0x08,
0x00, 0x04, 0x10, 0x00, 0x00, 0x05,
0x00, 0x03, 0x0E, 0x00, 0x00, 0x0A,
0x00, 0x23, 0x00, 0x00, 0x00, 0x01
};
//R22H r
static const unsigned char EPD_2IN7B_lut_bw[] = {
0xA0, 0x1A, 0x1A, 0x00, 0x00, 0x01,
0x00, 0x0A, 0x0A, 0x00, 0x00, 0x08,
0x84, 0x0E, 0x01, 0x0E, 0x01, 0x10,
0x90, 0x0A, 0x0A, 0x00, 0x00, 0x08,
0xB0, 0x04, 0x10, 0x00, 0x00, 0x05,
0xB0, 0x03, 0x0E, 0x00, 0x00, 0x0A,
0xC0, 0x23, 0x00, 0x00, 0x00, 0x01
};
//R23H w
static const unsigned char EPD_2IN7B_lut_bb[] = {
0x90, 0x1A, 0x1A, 0x00, 0x00, 0x01,
0x40, 0x0A, 0x0A, 0x00, 0x00, 0x08,
0x84, 0x0E, 0x01, 0x0E, 0x01, 0x10,
0x80, 0x0A, 0x0A, 0x00, 0x00, 0x08,
0x00, 0x04, 0x10, 0x00, 0x00, 0x05,
0x00, 0x03, 0x0E, 0x00, 0x00, 0x0A,
0x00, 0x23, 0x00, 0x00, 0x00, 0x01
};
//R24H b
static const unsigned char EPD_2IN7B_lut_wb[] = {
0x90, 0x1A, 0x1A, 0x00, 0x00, 0x01,
0x20, 0x0A, 0x0A, 0x00, 0x00, 0x08,
0x84, 0x0E, 0x01, 0x0E, 0x01, 0x10,
0x10, 0x0A, 0x0A, 0x00, 0x00, 0x08,
0x00, 0x04, 0x10, 0x00, 0x00, 0x05,
0x00, 0x03, 0x0E, 0x00, 0x00, 0x0A,
0x00, 0x23, 0x00, 0x00, 0x00, 0x01
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN7B_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
******************************************************************************/
static void EPD_2IN7B_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_2IN7B_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_2IN7B_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 0) { //0: busy, 1: idle
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : set the look-up tables
parameter:
******************************************************************************/
static void EPD_2IN7B_SetLut(void)
{
unsigned int count;
EPD_2IN7B_SendCommand(0x20); //vcom
for(count = 0; count < 44; count++) {
EPD_2IN7B_SendData(EPD_2IN7B_lut_vcom_dc[count]);
}
EPD_2IN7B_SendCommand(0x21); //ww --
for(count = 0; count < 42; count++) {
EPD_2IN7B_SendData(EPD_2IN7B_lut_ww[count]);
}
EPD_2IN7B_SendCommand(0x22); //bw r
for(count = 0; count < 42; count++) {
EPD_2IN7B_SendData(EPD_2IN7B_lut_bw[count]);
}
EPD_2IN7B_SendCommand(0x23); //wb w
for(count = 0; count < 42; count++) {
EPD_2IN7B_SendData(EPD_2IN7B_lut_bb[count]);
}
EPD_2IN7B_SendCommand(0x24); //bb b
for(count = 0; count < 42; count++) {
EPD_2IN7B_SendData(EPD_2IN7B_lut_wb[count]);
}
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN7B_Init(void)
{
EPD_2IN7B_Reset();
EPD_2IN7B_SendCommand(0x06); //boost soft start
EPD_2IN7B_SendData (0x07); //A
EPD_2IN7B_SendData (0x07); //B
EPD_2IN7B_SendData (0x17); //C
EPD_2IN7B_SendCommand(0x04);
EPD_2IN7B_ReadBusy();//waiting for the electronic paper IC to release the idle signal
EPD_2IN7B_SendCommand(0x00); //panel setting
EPD_2IN7B_SendData(0x0f); //LUT from OTP￡?128x296
EPD_2IN7B_SendCommand(0x16);
EPD_2IN7B_SendData(0x00); //KW-BF KWR-AF BWROTP 0f
EPD_2IN7B_SendCommand(0xF8); //boostéè?¨
EPD_2IN7B_SendData (0x60);
EPD_2IN7B_SendData(0xa5);
EPD_2IN7B_SendCommand(0xF8); //boostéè?¨
EPD_2IN7B_SendData (0x90);
EPD_2IN7B_SendData (0x00);
EPD_2IN7B_SendCommand(0xF8); //boostéè?¨
EPD_2IN7B_SendData (0x93);
EPD_2IN7B_SendData(0x2A);
EPD_2IN7B_SendCommand(0x01); // PANEL_SETTING
EPD_2IN7B_SendData(0x03); // VDS_EN, VDG_EN
EPD_2IN7B_SendData(0x00); // VCOM_HV, VGHL_LV[1], VGHL_LV[0]
EPD_2IN7B_SendData(0x2b); // VDH
EPD_2IN7B_SendData(0x2b); // VDL
EPD_2IN7B_SendData(0x2b); // VDHR
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN7B_Clear(void)
{
UWORD Width, Height;
Width = (EPD_2IN7B_WIDTH % 8 == 0)? (EPD_2IN7B_WIDTH / 8 ): (EPD_2IN7B_WIDTH / 8 + 1);
Height = EPD_2IN7B_HEIGHT;
EPD_2IN7B_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN7B_SendData(0X00);
}
}
EPD_2IN7B_SendCommand(0x11); // DATA_STOP
EPD_2IN7B_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN7B_SendData(0X00);
}
}
EPD_2IN7B_SendCommand(0x11); // DATA_STOP
EPD_2IN7B_SendCommand(0x12);
EPD_2IN7B_ReadBusy();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN7B_Display(UBYTE *Imageblack, UBYTE *Imagered)
{
UWORD Width, Height;
Width = (EPD_2IN7B_WIDTH % 8 == 0)? (EPD_2IN7B_WIDTH / 8 ): (EPD_2IN7B_WIDTH / 8 + 1);
Height = EPD_2IN7B_HEIGHT;
EPD_2IN7B_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN7B_SendData(~Imageblack[i + j * Width]);
}
}
EPD_2IN7B_SendCommand(0x11); // DATA_STOP
EPD_2IN7B_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN7B_SendData(~Imagered[i + j * Width]);
}
}
EPD_2IN7B_SendCommand(0x11); // DATA_STOP
EPD_2IN7B_SendCommand(0x12);
EPD_2IN7B_ReadBusy();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN7B_Sleep(void)
{
EPD_2IN7B_SendCommand(0X50);
EPD_2IN7B_SendData(0xf7);
EPD_2IN7B_SendCommand(0X02); //power off
EPD_2IN7B_SendCommand(0X07); //deep sleep
EPD_2IN7B_SendData(0xA5);
}

103
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in7b.h Normal file
View file

@ -0,0 +1,103 @@
/*****************************************************************************
* | File : EPD_2in7b.h
* | Author : Waveshare team
* | Function : 2.7inch e-paper b
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* lut_vcom_dc[] => EPD_2in7B_lut_vcom_dc[]
* lut_ww[] => EPD_2in7B_lut_ww[]
* lut_bw[] => EPD_2in7B_lut_bw[]
* lut_bb[] => EPD_2in7B_lut_bb[]
* lut_wb[] => EPD_2in7B_lut_wb[]
* EPD_Reset() => EPD_2in7B_Reset()
* EPD_SendCommand() => EPD_2in7B_SendCommand()
* EPD_SendData() => EPD_2in7B_SendData()
* EPD_WaitUntilIdle() => EPD_2in7B_ReadBusy()
* EPD_SetLut() => EPD_2in7B_SetLut()
* EPD_Init() => EPD_2in7B_Init()
* EPD_Clear() => EPD_2in7B_Clear()
* EPD_Display() => EPD_2in7B_Display()
* EPD_Sleep() => EPD_2in7B_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PARTIAL_DATA_START_TRANSMISSION_1 0x14
* #define PARTIAL_DATA_START_TRANSMISSION_2 0x15
* #define PARTIAL_DISPLAY_REFRESH 0x16
* #define LUT_FOR_VCOM 0x20
* #define LUT_WHITE_TO_WHITE 0x21
* #define LUT_BLACK_TO_WHITE 0x22
* #define LUT_WHITE_TO_BLACK 0x23
* #define LUT_BLACK_TO_BLACK 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SOURCE_AND_GATE_START_SETTING 0x62
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* -----------------------------------------------------------------------------
* V2.0(2018-10-30):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_2IN7B_H_
#define __EPD_2IN7B_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN7B_WIDTH 176
#define EPD_2IN7B_HEIGHT 264
void EPD_2IN7B_Init(void);
void EPD_2IN7B_Clear(void);
void EPD_2IN7B_Display(UBYTE *Imageblack, UBYTE *Imagered);
void EPD_2IN7B_Sleep(void);
#endif

228
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in7b_V2.c Normal file
View file

@ -0,0 +1,228 @@
/*****************************************************************************
* | File : EPD_2in7b_V2.c
* | Author : Waveshare team
* | Function : 2.7inch e-paper b V2
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-10-20
* | 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_2in7b_V2.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN7B_V2_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
******************************************************************************/
static void EPD_2IN7B_V2_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_2IN7B_V2_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_2IN7B_V2_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 0) { //0: busy, 1: idle
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN7B_V2_Init(void)
{
EPD_2IN7B_V2_Reset();
EPD_2IN7B_V2_ReadBusy();
EPD_2IN7B_V2_SendCommand(0x4D);
EPD_2IN7B_V2_SendData(0xAA);
EPD_2IN7B_V2_SendCommand(0x87);
EPD_2IN7B_V2_SendData(0x28);
EPD_2IN7B_V2_SendCommand(0x84);
EPD_2IN7B_V2_SendData(0x00);
EPD_2IN7B_V2_SendCommand(0x83);
EPD_2IN7B_V2_SendData(0x05);
EPD_2IN7B_V2_SendCommand(0xA8);
EPD_2IN7B_V2_SendData(0xDF);
EPD_2IN7B_V2_SendCommand(0xA9);
EPD_2IN7B_V2_SendData(0x05);
EPD_2IN7B_V2_SendCommand(0xB1);
EPD_2IN7B_V2_SendData(0xE8);
EPD_2IN7B_V2_SendCommand(0xAB);
EPD_2IN7B_V2_SendData(0xA1);
EPD_2IN7B_V2_SendCommand(0xB9);
EPD_2IN7B_V2_SendData(0x10);
EPD_2IN7B_V2_SendCommand(0x88);
EPD_2IN7B_V2_SendData(0x80);
EPD_2IN7B_V2_SendCommand(0x90);
EPD_2IN7B_V2_SendData(0x02);
EPD_2IN7B_V2_SendCommand(0x86);
EPD_2IN7B_V2_SendData(0x15);
EPD_2IN7B_V2_SendCommand(0x91);
EPD_2IN7B_V2_SendData(0x8D);
EPD_2IN7B_V2_SendCommand(0x50);
EPD_2IN7B_V2_SendData(0x57);
EPD_2IN7B_V2_SendCommand(0xAA);
EPD_2IN7B_V2_SendData(0x0F);
EPD_2IN7B_V2_SendCommand(0x00);
EPD_2IN7B_V2_SendData(0x8f);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN7B_V2_Clear(void)
{
UWORD Width, Height;
Width = (EPD_2IN7B_V2_WIDTH % 8 == 0)? (EPD_2IN7B_V2_WIDTH / 8 ): (EPD_2IN7B_V2_WIDTH / 8 + 1);
Height = EPD_2IN7B_V2_HEIGHT;
EPD_2IN7B_V2_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN7B_V2_SendData(0Xff);
}
}
EPD_2IN7B_V2_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN7B_V2_SendData(0X00);
}
}
EPD_2IN7B_V2_SendCommand(0x04); // Power ON
EPD_2IN7B_V2_ReadBusy();
DEV_Delay_ms(10);
EPD_2IN7B_V2_SendCommand(0x12); // Display Refresh
EPD_2IN7B_V2_ReadBusy();
DEV_Delay_ms(10);
EPD_2IN7B_V2_SendCommand(0x02); // Power OFF
EPD_2IN7B_V2_ReadBusy();
DEV_Delay_ms(20);
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN7B_V2_Display(UBYTE *Imageblack, UBYTE *Imagered)
{
UWORD Width, Height;
Width = (EPD_2IN7B_V2_WIDTH % 8 == 0)? (EPD_2IN7B_V2_WIDTH / 8 ): (EPD_2IN7B_V2_WIDTH / 8 + 1);
Height = EPD_2IN7B_V2_HEIGHT;
EPD_2IN7B_V2_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN7B_V2_SendData(Imageblack[i + j * Width]);
}
}
EPD_2IN7B_V2_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN7B_V2_SendData(~Imagered[i + j * Width]);
}
}
EPD_2IN7B_V2_SendCommand(0x04); // Power ON
EPD_2IN7B_V2_ReadBusy();
DEV_Delay_ms(10);
EPD_2IN7B_V2_SendCommand(0x12); // Display Refresh
EPD_2IN7B_V2_ReadBusy();
DEV_Delay_ms(10);
EPD_2IN7B_V2_SendCommand(0x02); // Power OFF
EPD_2IN7B_V2_ReadBusy();
DEV_Delay_ms(20);
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN7B_V2_Sleep(void)
{
EPD_2IN7B_V2_SendCommand(0x07); // Deep sleep
EPD_2IN7B_V2_SendData(0xA5);
}

45
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in7b_V2.h Normal file
View file

@ -0,0 +1,45 @@
/*****************************************************************************
* | File : EPD_2in7b_V2.h
* | Author : Waveshare team
* | Function : 2.7inch e-paper b V2
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-10-20
* | 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_2IN7B_V2_H_
#define __EPD_2IN7B_V2_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN7B_V2_WIDTH 176
#define EPD_2IN7B_V2_HEIGHT 264
void EPD_2IN7B_V2_Init(void);
void EPD_2IN7B_V2_Clear(void);
void EPD_2IN7B_V2_Display(UBYTE *Imageblack, UBYTE *Imagered);
void EPD_2IN7B_V2_Sleep(void);
#endif

298
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in9.c Normal file
View file

@ -0,0 +1,298 @@
/*****************************************************************************
* | File : EPD_2in9.c
* | Author : Waveshare team
* | Function : 2.9inch e-paper
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* 1.Change:
* lut_full_update[] => EPD_2IN9_lut_full_update[]
* lut_partial_update[] => EPD_2IN9_lut_partial_update[]
* EPD_Reset() => EPD_2IN9_Reset()
* EPD_SendCommand() => EPD_2IN9_SendCommand()
* EPD_SendData() => EPD_2IN9_SendData()
* EPD_WaitUntilIdle() => EPD_2IN9_ReadBusy()
* EPD_SetLut() => EPD_2IN9_SetLut()
* EPD_SetWindow() => EPD_2IN9_SetWindow()
* EPD_SetCursor() => EPD_2IN9_SetCursor()
* EPD_TurnOnDisplay() => EPD_2IN9_TurnOnDisplay()
* EPD_Init() => EPD_2IN9_Init()
* EPD_Clear() => EPD_2IN9_Clear()
* EPD_Display() => EPD_2IN9_Display()
* EPD_Sleep() => EPD_2IN9_Sleep()
* 2.remove commands define:
* #define DRIVER_OUTPUT_CONTROL 0x01
* #define BOOSTER_SOFT_START_CONTROL 0x0C
* #define GATE_SCAN_START_POSITION 0x0F
* #define DEEP_SLEEP_MODE 0x10
* #define DATA_ENTRY_MODE_SETTING 0x11
* #define SW_RESET 0x12
* #define TEMPERATURE_SENSOR_CONTROL 0x1A
* #define MASTER_ACTIVATION 0x20
* #define DISPLAY_UPDATE_CONTROL_1 0x21
* #define DISPLAY_UPDATE_CONTROL_2 0x22
* #define WRITE_RAM 0x24
* #define WRITE_VCOM_REGISTER 0x2C
* #define WRITE_LUT_REGISTER 0x32
* #define SET_DUMMY_LINE_PERIOD 0x3A
* #define SET_GATE_TIME 0x3B
* #define BORDER_WAVEFORM_CONTROL 0x3C
* #define SET_RAM_X_ADDRESS_START_END_POSITION 0x44
* #define SET_RAM_Y_ADDRESS_START_END_POSITION 0x45
* #define SET_RAM_X_ADDRESS_COUNTER 0x4E
* #define SET_RAM_Y_ADDRESS_COUNTER 0x4F
* #define TERMINATE_FRAME_READ_WRITE 0xFF
* -----------------------------------------------------------------------------
* V2.0(2018-11-06):
* 1.Remove:ImageBuff[EPD_2IN9_HEIGHT * EPD_2IN9_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_2in9.h"
#include "Debug.h"
const unsigned char EPD_2IN9_lut_full_update[] = {
0x50, 0xAA, 0x55, 0xAA, 0x11, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xFF, 0xFF, 0x1F, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
const unsigned char EPD_2IN9_lut_partial_update[] = {
0x10, 0x18, 0x18, 0x08, 0x18, 0x18,
0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x13, 0x14, 0x44, 0x12,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN9_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
******************************************************************************/
static void EPD_2IN9_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_2IN9_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:
******************************************************************************/
void EPD_2IN9_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
DEV_Delay_ms(100);
while(DEV_Digital_Read(EPD_BUSY_PIN) == 1) { //LOW: idle, HIGH: busy
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Setting the display window
parameter:
******************************************************************************/
static void EPD_2IN9_SetWindows(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend)
{
EPD_2IN9_SendCommand(0x44); // SET_RAM_X_ADDRESS_START_END_POSITION
EPD_2IN9_SendData((Xstart >> 3) & 0xFF);
EPD_2IN9_SendData((Xend >> 3) & 0xFF);
EPD_2IN9_SendCommand(0x45); // SET_RAM_Y_ADDRESS_START_END_POSITION
EPD_2IN9_SendData(Ystart & 0xFF);
EPD_2IN9_SendData((Ystart >> 8) & 0xFF);
EPD_2IN9_SendData(Yend & 0xFF);
EPD_2IN9_SendData((Yend >> 8) & 0xFF);
}
/******************************************************************************
function : Set Cursor
parameter:
******************************************************************************/
static void EPD_2IN9_SetCursor(UWORD Xstart, UWORD Ystart)
{
EPD_2IN9_SendCommand(0x4E); // SET_RAM_X_ADDRESS_COUNTER
EPD_2IN9_SendData((Xstart >> 3) & 0xFF);
EPD_2IN9_SendCommand(0x4F); // SET_RAM_Y_ADDRESS_COUNTER
EPD_2IN9_SendData(Ystart & 0xFF);
EPD_2IN9_SendData((Ystart >> 8) & 0xFF);
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN9_TurnOnDisplay(void)
{
EPD_2IN9_SendCommand(0x22); // DISPLAY_UPDATE_CONTROL_2
EPD_2IN9_SendData(0xC4);
EPD_2IN9_SendCommand(0x20); // MASTER_ACTIVATION
EPD_2IN9_SendCommand(0xFF); // TERMINATE_FRAME_READ_WRITE
EPD_2IN9_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN9_Init(UBYTE Mode)
{
EPD_2IN9_Reset();
EPD_2IN9_SendCommand(0x01); // DRIVER_OUTPUT_CONTROL
EPD_2IN9_SendData((EPD_2IN9_HEIGHT - 1) & 0xFF);
EPD_2IN9_SendData(((EPD_2IN9_HEIGHT - 1) >> 8) & 0xFF);
EPD_2IN9_SendData(0x00); // GD = 0; SM = 0; TB = 0;
EPD_2IN9_SendCommand(0x0C); // BOOSTER_SOFT_START_CONTROL
EPD_2IN9_SendData(0xD7);
EPD_2IN9_SendData(0xD6);
EPD_2IN9_SendData(0x9D);
EPD_2IN9_SendCommand(0x2C); // WRITE_VCOM_REGISTER
EPD_2IN9_SendData(0xA8); // VCOM 7C
EPD_2IN9_SendCommand(0x3A); // SET_DUMMY_LINE_PERIOD
EPD_2IN9_SendData(0x1A); // 4 dummy lines per gate
EPD_2IN9_SendCommand(0x3B); // SET_GATE_TIME
EPD_2IN9_SendData(0x08); // 2us per line
EPD_2IN9_SendCommand(0x3C); // BORDER_WAVEFORM_CONTROL
EPD_2IN9_SendData(0x03);
EPD_2IN9_SendCommand(0x11); // DATA_ENTRY_MODE_SETTING
EPD_2IN9_SendData(0x03);
//set the look-up table register
EPD_2IN9_SendCommand(0x32); // WRITE_LUT_REGISTER
if(Mode == EPD_2IN9_FULL){
for (UWORD i = 0; i < 30; i++) {
EPD_2IN9_SendData(EPD_2IN9_lut_full_update[i]);
}
}else if(Mode == EPD_2IN9_PART){
for (UWORD i = 0; i < 30; i++) {
EPD_2IN9_SendData(EPD_2IN9_lut_partial_update[i]);
}
}else{
Debug("error, the Mode is EPD_2IN9_FULL or EPD_2IN9_PART");
}
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN9_Clear(void)
{
UWORD Width, Height;
Width = (EPD_2IN9_WIDTH % 8 == 0)? (EPD_2IN9_WIDTH / 8 ): (EPD_2IN9_WIDTH / 8 + 1);
Height = EPD_2IN9_HEIGHT;
EPD_2IN9_SetWindows(0, 0, EPD_2IN9_WIDTH, EPD_2IN9_HEIGHT);
for (UWORD j = 0; j < Height; j++) {
EPD_2IN9_SetCursor(0, j);
EPD_2IN9_SendCommand(0x24);
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9_SendData(0XFF);
}
}
EPD_2IN9_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN9_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_2IN9_WIDTH % 8 == 0)? (EPD_2IN9_WIDTH / 8 ): (EPD_2IN9_WIDTH / 8 + 1);
Height = EPD_2IN9_HEIGHT;
UDOUBLE Addr = 0;
// UDOUBLE Offset = ImageName;
EPD_2IN9_SetWindows(0, 0, EPD_2IN9_WIDTH, EPD_2IN9_HEIGHT);
for (UWORD j = 0; j < Height; j++) {
EPD_2IN9_SetCursor(0, j);
EPD_2IN9_SendCommand(0x24);
for (UWORD i = 0; i < Width; i++) {
Addr = i + j * Width;
EPD_2IN9_SendData(Image[Addr]);
}
}
EPD_2IN9_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN9_Sleep(void)
{
EPD_2IN9_SendCommand(0x10);
EPD_2IN9_SendData(0x01);
// EPD_2IN9_ReadBusy();
}

96
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in9.h Normal file
View file

@ -0,0 +1,96 @@
/*****************************************************************************
* | File : EPD_2in9.h
* | Author : Waveshare team
* | Function : 2.9inch e-paper
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* 1.Change:
* lut_full_update[] => EPD_2IN9_lut_full_update[]
* lut_partial_update[] => EPD_2IN9_lut_partial_update[]
* EPD_Reset() => EPD_2IN9_Reset()
* EPD_SendCommand() => EPD_2IN9_SendCommand()
* EPD_SendData() => EPD_2IN9_SendData()
* EPD_WaitUntilIdle() => EPD_2IN9_ReadBusy()
* EPD_SetLut() => EPD_2IN9_SetLut()
* EPD_SetWindow() => EPD_2IN9_SetWindow()
* EPD_SetCursor() => EPD_2IN9_SetCursor()
* EPD_TurnOnDisplay() => EPD_2IN9_TurnOnDisplay()
* EPD_Init() => EPD_2IN9_Init()
* EPD_Clear() => EPD_2IN9_Clear()
* EPD_Display() => EPD_2IN9_Display()
* EPD_Sleep() => EPD_2IN9_Sleep()
* 2.remove commands define:
* #define DRIVER_OUTPUT_CONTROL 0x01
* #define BOOSTER_SOFT_START_CONTROL 0x0C
* #define GATE_SCAN_START_POSITION 0x0F
* #define DEEP_SLEEP_MODE 0x10
* #define DATA_ENTRY_MODE_SETTING 0x11
* #define SW_RESET 0x12
* #define TEMPERATURE_SENSOR_CONTROL 0x1A
* #define MASTER_ACTIVATION 0x20
* #define DISPLAY_UPDATE_CONTROL_1 0x21
* #define DISPLAY_UPDATE_CONTROL_2 0x22
* #define WRITE_RAM 0x24
* #define WRITE_VCOM_REGISTER 0x2C
* #define WRITE_LUT_REGISTER 0x32
* #define SET_DUMMY_LINE_PERIOD 0x3A
* #define SET_GATE_TIME 0x3B
* #define BORDER_WAVEFORM_CONTROL 0x3C
* #define SET_RAM_X_ADDRESS_START_END_POSITION 0x44
* #define SET_RAM_Y_ADDRESS_START_END_POSITION 0x45
* #define SET_RAM_X_ADDRESS_COUNTER 0x4E
* #define SET_RAM_Y_ADDRESS_COUNTER 0x4F
* #define TERMINATE_FRAME_READ_WRITE 0xFF
* -----------------------------------------------------------------------------
* V2.0(2018-11-06):
* 1.Remove:ImageBuff[EPD_2IN9_HEIGHT * EPD_2IN9_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_2IN9_H_
#define __EPD_2IN9_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN9_WIDTH 128
#define EPD_2IN9_HEIGHT 296
#define EPD_2IN9_FULL 0
#define EPD_2IN9_PART 1
void EPD_2IN9_Init(UBYTE Mode);
void EPD_2IN9_Clear(void);
void EPD_2IN9_Display(UBYTE *Image);
void EPD_2IN9_Sleep(void);
#endif

360
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in9_V2.c Normal file
View file

@ -0,0 +1,360 @@
/*****************************************************************************
* | File : EPD_2in9_V2.c
* | Author : Waveshare team
* | Function : 2.9inch e-paper V2
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-10-20
* | 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_2in9_V2.h"
#include "Debug.h"
UBYTE _WF_PARTIAL_2IN9[159] =
{
0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x80,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x40,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0A,0x0,0x0,0x0,0x0,0x0,0x2,
0x1,0x0,0x0,0x0,0x0,0x0,0x0,
0x1,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,
0x22,0x22,0x22,0x22,0x22,0x22,0x0,0x0,0x0,
0x22,0x17,0x41,0xB0,0x32,0x36,
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN9_V2_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(100);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(2);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(100);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_2IN9_V2_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_2IN9_V2_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:
******************************************************************************/
void EPD_2IN9_V2_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(1)
{ //=1 BUSY
if(DEV_Digital_Read(EPD_BUSY_PIN)==0)
break;
DEV_Delay_ms(50);
}
DEV_Delay_ms(50);
Debug("e-Paper busy release\r\n");
}
static void _EPD_2IN9_V2_LUT(void)
{
UBYTE count;
EPD_2IN9_V2_SendCommand(0x32);
for(count=0; count<153; count++)
EPD_2IN9_V2_SendData(_WF_PARTIAL_2IN9[count]);
EPD_2IN9_V2_ReadBusy();
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN9_V2_TurnOnDisplay(void)
{
EPD_2IN9_V2_SendCommand(0x22); //Display Update Control
EPD_2IN9_V2_SendData(0xF7);
EPD_2IN9_V2_SendCommand(0x20); //Activate Display Update Sequence
EPD_2IN9_V2_ReadBusy();
}
static void EPD_2IN9_V2_TurnOnDisplay_Partial(void)
{
EPD_2IN9_V2_SendCommand(0x22); //Display Update Control
EPD_2IN9_V2_SendData(0xFF);
EPD_2IN9_V2_SendCommand(0x20); //Activate Display Update Sequence
EPD_2IN9_V2_ReadBusy();
}
static void _EPD_2IN9_V2_TurnOnDisplay_Partial(void)
{
EPD_2IN9_V2_SendCommand(0x22); //Display Update Control
EPD_2IN9_V2_SendData(0x0F);
EPD_2IN9_V2_SendCommand(0x20); //Activate Display Update Sequence
EPD_2IN9_V2_ReadBusy();
}
/******************************************************************************
function : Setting the display window
parameter:
******************************************************************************/
static void EPD_2IN9_V2_SetWindows(UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend)
{
EPD_2IN9_V2_SendCommand(0x44); // SET_RAM_X_ADDRESS_START_END_POSITION
EPD_2IN9_V2_SendData((Xstart>>3) & 0xFF);
EPD_2IN9_V2_SendData((Xend>>3) & 0xFF);
EPD_2IN9_V2_SendCommand(0x45); // SET_RAM_Y_ADDRESS_START_END_POSITION
EPD_2IN9_V2_SendData(Ystart & 0xFF);
EPD_2IN9_V2_SendData((Ystart >> 8) & 0xFF);
EPD_2IN9_V2_SendData(Yend & 0xFF);
EPD_2IN9_V2_SendData((Yend >> 8) & 0xFF);
}
/******************************************************************************
function : Set Cursor
parameter:
******************************************************************************/
static void EPD_2IN9_V2_SetCursor(UWORD Xstart, UWORD Ystart)
{
EPD_2IN9_V2_SendCommand(0x4E); // SET_RAM_X_ADDRESS_COUNTER
EPD_2IN9_V2_SendData(Xstart & 0xFF);
EPD_2IN9_V2_SendCommand(0x4F); // SET_RAM_Y_ADDRESS_COUNTER
EPD_2IN9_V2_SendData(Ystart & 0xFF);
EPD_2IN9_V2_SendData((Ystart >> 8) & 0xFF);
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN9_V2_Init(void)
{
EPD_2IN9_V2_Reset();
DEV_Delay_ms(100);
EPD_2IN9_V2_ReadBusy();
EPD_2IN9_V2_SendCommand(0x12); //SWRESET
EPD_2IN9_V2_ReadBusy();
EPD_2IN9_V2_SendCommand(0x01); //Driver output control
EPD_2IN9_V2_SendData(0x27);
EPD_2IN9_V2_SendData(0x01);
EPD_2IN9_V2_SendData(0x00);
EPD_2IN9_V2_SendCommand(0x11); //data entry mode
EPD_2IN9_V2_SendData(0x03);
EPD_2IN9_V2_SetWindows(0, 0, EPD_2IN9_V2_WIDTH-1, EPD_2IN9_V2_HEIGHT-1);
EPD_2IN9_V2_SendCommand(0x3C); //BorderWavefrom
EPD_2IN9_V2_SendData(0x05);
EPD_2IN9_V2_SendCommand(0x21); // Display update control
EPD_2IN9_V2_SendData(0x00);
EPD_2IN9_V2_SendData(0x80);
EPD_2IN9_V2_SendCommand(0x18); //Read built-in temperature sensor
EPD_2IN9_V2_SendData(0x80);
EPD_2IN9_V2_SetCursor(0, 0);
EPD_2IN9_V2_ReadBusy();
}
void _EPD_2IN9_V2_Init(void)
{
EPD_2IN9_V2_Reset();
DEV_Delay_ms(100);
EPD_2IN9_V2_ReadBusy();
EPD_2IN9_V2_SendCommand(0x12); // soft reset
EPD_2IN9_V2_ReadBusy();
EPD_2IN9_V2_SendCommand(0x11); //data entry mode
EPD_2IN9_V2_SendData(0x03);
EPD_2IN9_V2_SetWindows(0, 0, EPD_2IN9_V2_WIDTH-1, EPD_2IN9_V2_HEIGHT-1);
EPD_2IN9_V2_SetCursor(0, 0);
EPD_2IN9_V2_ReadBusy();
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN9_V2_Clear(void)
{
UWORD i;
EPD_2IN9_V2_SendCommand(0x24); //write RAM for black(0)/white (1)
for(i=0;i<4736;i++)
{
EPD_2IN9_V2_SendData(0xff);
}
EPD_2IN9_V2_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN9_V2_Display(UBYTE *Image)
{
UWORD i;
EPD_2IN9_V2_SendCommand(0x24); //write RAM for black(0)/white (1)
for(i=0;i<4736;i++)
{
EPD_2IN9_V2_SendData(Image[i]);
}
EPD_2IN9_V2_TurnOnDisplay();
}
void EPD_2IN9_V2_Display_Base(UBYTE *Image)
{
UWORD i;
EPD_2IN9_V2_SendCommand(0x24); //Write Black and White image to RAM
for(i=0;i<4736;i++)
{
EPD_2IN9_V2_SendData(Image[i]);
}
EPD_2IN9_V2_SendCommand(0x26); //Write Black and White image to RAM
for(i=0;i<4736;i++)
{
EPD_2IN9_V2_SendData(Image[i]);
}
EPD_2IN9_V2_TurnOnDisplay();
}
void EPD_2IN9_V2_Display_Partial(UBYTE *Image)
{
UWORD i;
//Reset
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(5);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(10);
EPD_2IN9_V2_SendCommand(0x3C); //BorderWavefrom
EPD_2IN9_V2_SendData(0x80);
EPD_2IN9_V2_SetWindows(0, 0, EPD_2IN9_V2_WIDTH-1, EPD_2IN9_V2_HEIGHT-1);
EPD_2IN9_V2_SetCursor(0, 0);
EPD_2IN9_V2_SendCommand(0x24); //Write Black and White image to RAM
for(i=0;i<4736;i++)
{
EPD_2IN9_V2_SendData(Image[i]);
}
EPD_2IN9_V2_TurnOnDisplay_Partial();
}
void _EPD_2IN9_V2_Display_Partial(UBYTE *Image)
{
UWORD i;
//Reset
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(5);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(10);
_EPD_2IN9_V2_LUT();
EPD_2IN9_V2_SendCommand(0x37);
EPD_2IN9_V2_SendData(0x00);
EPD_2IN9_V2_SendData(0x00);
EPD_2IN9_V2_SendData(0x00);
EPD_2IN9_V2_SendData(0x00);
EPD_2IN9_V2_SendData(0x00);
EPD_2IN9_V2_SendData(0x40);
EPD_2IN9_V2_SendData(0x00);
EPD_2IN9_V2_SendData(0x00);
EPD_2IN9_V2_SendData(0x00);
EPD_2IN9_V2_SendData(0x00);
EPD_2IN9_V2_SendCommand(0x3C); //BorderWavefrom
EPD_2IN9_V2_SendData(0x80);
EPD_2IN9_V2_SendCommand(0x22);
EPD_2IN9_V2_SendData(0xC0);
EPD_2IN9_V2_SendCommand(0x20);
EPD_2IN9_V2_ReadBusy();
EPD_2IN9_V2_SetWindows(0, 0, EPD_2IN9_V2_WIDTH-1, EPD_2IN9_V2_HEIGHT-1);
EPD_2IN9_V2_SetCursor(0, 0);
EPD_2IN9_V2_SendCommand(0x24); //Write Black and White image to RAM
for(i=0;i<4736;i++)
{
EPD_2IN9_V2_SendData(Image[i]);
}
_EPD_2IN9_V2_TurnOnDisplay_Partial();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN9_V2_Sleep(void)
{
EPD_2IN9_V2_SendCommand(0x10); //enter deep sleep
EPD_2IN9_V2_SendData(0x01);
DEV_Delay_ms(100);
}

49
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in9_V2.h Normal file
View file

@ -0,0 +1,49 @@
/*****************************************************************************
* | File : EPD_2in9_V2.h
* | Author : Waveshare team
* | Function : 2.9inch e-paper V2
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-10-20
* | 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_2IN9_V2_H_
#define __EPD_2IN9_V2_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN9_V2_WIDTH 128
#define EPD_2IN9_V2_HEIGHT 296
void EPD_2IN9_V2_Init(void);
void _EPD_2IN9_V2_Init(void);
void EPD_2IN9_V2_Clear(void);
void EPD_2IN9_V2_Display(UBYTE *Image);
void EPD_2IN9_V2_Display_Base(UBYTE *Image);
void EPD_2IN9_V2_Display_Partial(UBYTE *Image);
void _EPD_2IN9_V2_Display_Partial(UBYTE *Image);
void EPD_2IN9_V2_Sleep(void);
#endif

187
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in9b_V3.c Normal file
View file

@ -0,0 +1,187 @@
/*****************************************************************************
* | File : EPD_2in9b_V3.c
* | Author : Waveshare team
* | Function : 2.9inch e-paper b V3
* | Info :
*----------------
* | This version: V1.1
* | Date : 2020-12-03
* | 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_2in9b_V3.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN9B_V3_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
******************************************************************************/
static void EPD_2IN9B_V3_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_2IN9B_V3_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:
******************************************************************************/
void EPD_2IN9B_V3_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
UBYTE busy;
do
{
EPD_2IN9B_V3_SendCommand(0x71);
busy = DEV_Digital_Read(EPD_BUSY_PIN);
busy =!(busy & 0x01);
}
while(busy);
Debug("e-Paper busy release\r\n");
DEV_Delay_ms(200);
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN9B_V3_Init(void)
{
EPD_2IN9B_V3_Reset();
EPD_2IN9B_V3_SendCommand(0x04);
EPD_2IN9B_V3_ReadBusy();//waiting for the electronic paper IC to release the idle signal
EPD_2IN9B_V3_SendCommand(0x00);//panel setting
EPD_2IN9B_V3_SendData(0x0f);//LUT from OTP，128x296
EPD_2IN9B_V3_SendData(0x89);//Temperature sensor, boost and other related timing settings
EPD_2IN9B_V3_SendCommand(0x61);//resolution setting
EPD_2IN9B_V3_SendData (0x80);
EPD_2IN9B_V3_SendData (0x01);
EPD_2IN9B_V3_SendData (0x28);
EPD_2IN9B_V3_SendCommand(0X50);//VCOM AND DATA INTERVAL SETTING
EPD_2IN9B_V3_SendData(0x77);//WBmode:VBDF 17|D7 VBDW 97 VBDB 57
//WBRmode:VBDF F7 VBDW 77 VBDB 37 VBDR B7
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN9B_V3_Clear(void)
{
UWORD Width = (EPD_2IN9B_V3_WIDTH % 8 == 0)? (EPD_2IN9B_V3_WIDTH / 8 ): (EPD_2IN9B_V3_WIDTH / 8 + 1);
UWORD Height = EPD_2IN9B_V3_HEIGHT;
//send black data
EPD_2IN9B_V3_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9B_V3_SendData(0xFF);
}
}
//send red data
EPD_2IN9B_V3_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9B_V3_SendData(0xFF);
}
}
EPD_2IN9B_V3_SendCommand(0x12);
EPD_2IN9B_V3_ReadBusy();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN9B_V3_Display(const UBYTE *blackimage, const UBYTE *ryimage)
{
UWORD Width, Height;
Width = (EPD_2IN9B_V3_WIDTH % 8 == 0)? (EPD_2IN9B_V3_WIDTH / 8 ): (EPD_2IN9B_V3_WIDTH / 8 + 1);
Height = EPD_2IN9B_V3_HEIGHT;
EPD_2IN9B_V3_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9B_V3_SendData(blackimage[i + j * Width]);
}
}
EPD_2IN9B_V3_SendCommand(0x92);
EPD_2IN9B_V3_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9B_V3_SendData(ryimage[i + j * Width]);
}
}
EPD_2IN9B_V3_SendCommand(0x92);
EPD_2IN9B_V3_SendCommand(0x12);
EPD_2IN9B_V3_ReadBusy();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN9B_V3_Sleep(void)
{
EPD_2IN9B_V3_SendCommand(0x02); // POWER_OFF
EPD_2IN9B_V3_ReadBusy();
EPD_2IN9B_V3_SendCommand(0x07); // DEEP_SLEEP
EPD_2IN9B_V3_SendData(0xA5); // check code
}

45
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in9b_V3.h Normal file
View file

@ -0,0 +1,45 @@
/*****************************************************************************
* | File : EPD_2in9b V3.h
* | Author : Waveshare team
* | Function : 2.9inch e-paper b V3
* | Info :
*----------------
* | This version: V1.1
* | Date : 2020-12-03
* | 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_2IN9B_V3_H_
#define __EPD_2IN9B_V3_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN9B_V3_WIDTH 128
#define EPD_2IN9B_V3_HEIGHT 296
void EPD_2IN9B_V3_Init(void);
void EPD_2IN9B_V3_Clear(void);
void EPD_2IN9B_V3_Display(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_2IN9B_V3_Sleep(void);
#endif

240
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in9bc.c Normal file
View file

@ -0,0 +1,240 @@
/*****************************************************************************
* | File : EPD_2in9bc.c
* | Author : Waveshare team
* | Function : 2.9inch e-paper b&c
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* 1.Change:
* EPD_Reset() => EPD_2IN9BC_Reset()
* EPD_SendCommand() => EPD_2IN9BC_SendCommand()
* EPD_SendData() => EPD_2IN9BC_SendData()
* EPD_WaitUntilIdle() => EPD_2IN9BC_ReadBusy()
* EPD_Init() => EPD_2IN9BC_Init()
* EPD_Clear() => EPD_2IN9BC_Clear()
* EPD_Display() => EPD_2IN9BC_Display()
* EPD_Sleep() => EPD_2IN9BC_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* -----------------------------------------------------------------------------
* V2.0(2018-11-06):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_2in9bc.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN9BC_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
******************************************************************************/
static void EPD_2IN9BC_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_2IN9BC_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:
******************************************************************************/
void EPD_2IN9BC_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 0) { //LOW: idle, HIGH: busy
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN9BC_Init(void)
{
EPD_2IN9BC_Reset();
EPD_2IN9BC_SendCommand(0x06); // BOOSTER_SOFT_START
EPD_2IN9BC_SendData(0x17);
EPD_2IN9BC_SendData(0x17);
EPD_2IN9BC_SendData(0x17);
EPD_2IN9BC_SendCommand(0x04); // POWER_ON
EPD_2IN9BC_ReadBusy();
EPD_2IN9BC_SendCommand(0x00); // PANEL_SETTING
EPD_2IN9BC_SendData(0x8F);
EPD_2IN9BC_SendCommand(0x50); // VCOM_AND_DATA_INTERVAL_SETTING
EPD_2IN9BC_SendData(0x77);
EPD_2IN9BC_SendCommand(0x61); // TCON_RESOLUTION
EPD_2IN9BC_SendData(0x80);
EPD_2IN9BC_SendData(0x01);
EPD_2IN9BC_SendData(0x28);
EPD_2IN9BC_SendCommand(0x82); // VCM_DC_SETTING_REGISTER
EPD_2IN9BC_SendData(0X0A);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN9BC_Clear(void)
{
UWORD Width = (EPD_2IN9BC_WIDTH % 8 == 0)? (EPD_2IN9BC_WIDTH / 8 ): (EPD_2IN9BC_WIDTH / 8 + 1);
UWORD Height = EPD_2IN9BC_HEIGHT;
//send black data
EPD_2IN9BC_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9BC_SendData(0xFF);
}
}
//send red data
EPD_2IN9BC_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9BC_SendData(0xFF);
}
}
EPD_2IN9BC_SendCommand(0x12);
EPD_2IN9BC_ReadBusy();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN9BC_Display(const UBYTE *blackimage, const UBYTE *ryimage)
{
UWORD Width, Height;
Width = (EPD_2IN9BC_WIDTH % 8 == 0)? (EPD_2IN9BC_WIDTH / 8 ): (EPD_2IN9BC_WIDTH / 8 + 1);
Height = EPD_2IN9BC_HEIGHT;
EPD_2IN9BC_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9BC_SendData(blackimage[i + j * Width]);
}
}
EPD_2IN9BC_SendCommand(0x92);
EPD_2IN9BC_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9BC_SendData(ryimage[i + j * Width]);
}
}
EPD_2IN9BC_SendCommand(0x92);
EPD_2IN9BC_SendCommand(0x12);
EPD_2IN9BC_ReadBusy();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN9BC_Sleep(void)
{
EPD_2IN9BC_SendCommand(0x02); // POWER_OFF
EPD_2IN9BC_ReadBusy();
EPD_2IN9BC_SendCommand(0x07); // DEEP_SLEEP
EPD_2IN9BC_SendData(0xA5); // check code
}

98
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in9bc.h Normal file
View file

@ -0,0 +1,98 @@
/*****************************************************************************
* | File : EPD_2in9bc.h
* | Author : Waveshare team
* | Function : 2.9inch e-paper b&c
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* 1.Change:
* EPD_Reset() => EPD_2IN9BC_Reset()
* EPD_SendCommand() => EPD_2IN9BC_SendCommand()
* EPD_SendData() => EPD_2IN9BC_SendData()
* EPD_WaitUntilIdle() => EPD_2IN9BC_ReadBusy()
* EPD_Init() => EPD_2IN9BC_Init()
* EPD_Clear() => EPD_2IN9BC_Clear()
* EPD_Display() => EPD_2IN9BC_Display()
* EPD_Sleep() => EPD_2IN9BC_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_SENSOR_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define VCOM_VALUE 0x81
* #define VCM_DC_SETTING_REGISTER 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* -----------------------------------------------------------------------------
* V2.0(2018-11-06):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
* 3.Change:
* EPD_RST -> EPD_RST_PIN
* EPD_DC -> EPD_DC_PIN
* EPD_CS -> EPD_CS_PIN
* EPD_BUSY -> EPD_BUSY_PIN
#
# 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_2IN9BC_H_
#define __EPD_2IN9BC_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN9BC_WIDTH 128
#define EPD_2IN9BC_HEIGHT 296
void EPD_2IN9BC_Init(void);
void EPD_2IN9BC_Clear(void);
void EPD_2IN9BC_Display(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_2IN9BC_Sleep(void);
#endif

446
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in9d.c Normal file
View file

@ -0,0 +1,446 @@
/*****************************************************************************
* | File : EPD_2in9d.c
* | Author : Waveshare team
* | Function : 2.9inch e-paper d
* | Info :
*----------------
* | This version: V2.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* 1.Change:
* lut_vcomDC[] => EPD_2IN9D_lut_vcomDC[]
* lut_ww[] => EPD_2IN9D_lut_ww[]
* lut_bw[] => EPD_2IN9D_lut_bw[]
* lut_wb[] => EPD_2IN9D_lut_wb[]
* lut_bb[] => EPD_2IN9D_lut_bb[]
* lut_vcom1[] => EPD_2IN9D_lut_vcom1[]
* lut_ww1[] => EPD_2IN9D_lut_ww1[]
* lut_bw1[] => EPD_2IN9D_lut_bw1[]
* lut_wb1[] => EPD_2IN9D_lut_wb1[]
* lut_bb1[] => EPD_2IN9D_lut_bb1[]
* EPD_Reset() => EPD_2IN9D_Reset()
* EPD_SendCommand() => EPD_2IN9D_SendCommand()
* EPD_SendData() => EPD_2IN9D_SendData()
* EPD_WaitUntilIdle() => EPD_2IN9D_ReadBusy()
* EPD_SetFullReg() => EPD_2IN9D_SetFullReg()
* EPD_SetPartReg() => EPD_2IN9D_SetPartReg()
* EPD_TurnOnDisplay() => EPD_2IN9D_TurnOnDisplay()
* EPD_Init() => EPD_2IN9D_Init()
* EPD_Clear() => EPD_2IN9D_Clear()
* EPD_Display() => EPD_2IN9D_Display()
* EPD_Sleep() => EPD_2IN9D_Sleep()
*
# 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_2in9d.h"
#include "Debug.h"
/**
* full screen update LUT
**/
const unsigned char EPD_2IN9D_lut_vcomDC[] = {
0x00, 0x08, 0x00, 0x00, 0x00, 0x02,
0x60, 0x28, 0x28, 0x00, 0x00, 0x01,
0x00, 0x14, 0x00, 0x00, 0x00, 0x01,
0x00, 0x12, 0x12, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00,
};
const unsigned char EPD_2IN9D_lut_ww[] = {
0x40, 0x08, 0x00, 0x00, 0x00, 0x02,
0x90, 0x28, 0x28, 0x00, 0x00, 0x01,
0x40, 0x14, 0x00, 0x00, 0x00, 0x01,
0xA0, 0x12, 0x12, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
const unsigned char EPD_2IN9D_lut_bw[] = {
0x40, 0x17, 0x00, 0x00, 0x00, 0x02,
0x90, 0x0F, 0x0F, 0x00, 0x00, 0x03,
0x40, 0x0A, 0x01, 0x00, 0x00, 0x01,
0xA0, 0x0E, 0x0E, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
const unsigned char EPD_2IN9D_lut_wb[] = {
0x80, 0x08, 0x00, 0x00, 0x00, 0x02,
0x90, 0x28, 0x28, 0x00, 0x00, 0x01,
0x80, 0x14, 0x00, 0x00, 0x00, 0x01,
0x50, 0x12, 0x12, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
const unsigned char EPD_2IN9D_lut_bb[] = {
0x80, 0x08, 0x00, 0x00, 0x00, 0x02,
0x90, 0x28, 0x28, 0x00, 0x00, 0x01,
0x80, 0x14, 0x00, 0x00, 0x00, 0x01,
0x50, 0x12, 0x12, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
/**
* partial screen update LUT
**/
const unsigned char EPD_2IN9D_lut_vcom1[] = {
0x00, 0x19, 0x01, 0x00, 0x00, 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,
};
const unsigned char EPD_2IN9D_lut_ww1[] = {
0x00, 0x19, 0x01, 0x00, 0x00, 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,
};
const unsigned char EPD_2IN9D_lut_bw1[] = {
0x80, 0x19, 0x01, 0x00, 0x00, 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,
};
const unsigned char EPD_2IN9D_lut_wb1[] = {
0x40, 0x19, 0x01, 0x00, 0x00, 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,
};
const unsigned char EPD_2IN9D_lut_bb1[] = {
0x00, 0x19, 0x01, 0x00, 0x00, 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,
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_2IN9D_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
******************************************************************************/
static void EPD_2IN9D_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_2IN9D_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:
******************************************************************************/
void EPD_2IN9D_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
UBYTE busy;
do {
EPD_2IN9D_SendCommand(0x71);
busy = DEV_Digital_Read(EPD_BUSY_PIN);
busy =!(busy & 0x01);
} while(busy);
DEV_Delay_ms(200);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : LUT download
parameter:
******************************************************************************/
static void EPD_SetFullReg(void)
{
EPD_2IN9D_SendCommand(0X50); //VCOM AND DATA INTERVAL SETTING
EPD_2IN9D_SendData(0xb7); //WBmode:VBDF 17|D7 VBDW 97 VBDB 57 WBRmode:VBDF F7 VBDW 77 VBDB 37 VBDR B7
unsigned int count;
EPD_2IN9D_SendCommand(0x20);
for(count=0; count<44; count++) {
EPD_2IN9D_SendData(EPD_2IN9D_lut_vcomDC[count]);
}
EPD_2IN9D_SendCommand(0x21);
for(count=0; count<42; count++) {
EPD_2IN9D_SendData(EPD_2IN9D_lut_ww[count]);
}
EPD_2IN9D_SendCommand(0x22);
for(count=0; count<42; count++) {
EPD_2IN9D_SendData(EPD_2IN9D_lut_bw[count]);
}
EPD_2IN9D_SendCommand(0x23);
for(count=0; count<42; count++) {
EPD_2IN9D_SendData(EPD_2IN9D_lut_wb[count]);
}
EPD_2IN9D_SendCommand(0x24);
for(count=0; count<42; count++) {
EPD_2IN9D_SendData(EPD_2IN9D_lut_bb[count]);
}
}
/******************************************************************************
function : LUT download
parameter:
******************************************************************************/
static void EPD_2IN9D_SetPartReg(void)
{
EPD_2IN9D_SendCommand(0x82); //vcom_DC setting
EPD_2IN9D_SendData(0x00);
EPD_2IN9D_SendCommand(0X50);
EPD_2IN9D_SendData(0xb7);
unsigned int count;
EPD_2IN9D_SendCommand(0x20);
for(count=0; count<44; count++) {
EPD_2IN9D_SendData(EPD_2IN9D_lut_vcom1[count]);
}
EPD_2IN9D_SendCommand(0x21);
for(count=0; count<42; count++) {
EPD_2IN9D_SendData(EPD_2IN9D_lut_ww1[count]);
}
EPD_2IN9D_SendCommand(0x22);
for(count=0; count<42; count++) {
EPD_2IN9D_SendData(EPD_2IN9D_lut_bw1[count]);
}
EPD_2IN9D_SendCommand(0x23);
for(count=0; count<42; count++) {
EPD_2IN9D_SendData(EPD_2IN9D_lut_wb1[count]);
}
EPD_2IN9D_SendCommand(0x24);
for(count=0; count<42; count++) {
EPD_2IN9D_SendData(EPD_2IN9D_lut_bb1[count]);
}
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_2IN9D_TurnOnDisplay(void)
{
EPD_2IN9D_SendCommand(0x12); //DISPLAY REFRESH
DEV_Delay_ms(10); //!!!The delay here is necessary, 200uS at least!!!
EPD_2IN9D_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_2IN9D_Init(void)
{
EPD_2IN9D_Reset();
EPD_2IN9D_SendCommand(0x01); //POWER SETTING
EPD_2IN9D_SendData(0x03);
EPD_2IN9D_SendData(0x00);
EPD_2IN9D_SendData(0x2b);
EPD_2IN9D_SendData(0x2b);
EPD_2IN9D_SendData(0x03);
EPD_2IN9D_SendCommand(0x06); //boost soft start
EPD_2IN9D_SendData(0x17); //A
EPD_2IN9D_SendData(0x17); //B
EPD_2IN9D_SendData(0x17); //C
EPD_2IN9D_SendCommand(0x04);
EPD_2IN9D_ReadBusy();
EPD_2IN9D_SendCommand(0x00); //panel setting
EPD_2IN9D_SendData(0xbf); //LUT from OTP，128x296
EPD_2IN9D_SendData(0x0e); //VCOM to 0V fast
EPD_2IN9D_SendCommand(0x30); //PLL setting
EPD_2IN9D_SendData(0x3a); // 3a 100HZ 29 150Hz 39 200HZ 31 171HZ
EPD_2IN9D_SendCommand(0x61); //resolution setting
EPD_2IN9D_SendData(EPD_2IN9D_WIDTH);
EPD_2IN9D_SendData((EPD_2IN9D_HEIGHT >> 8) & 0xff);
EPD_2IN9D_SendData(EPD_2IN9D_HEIGHT & 0xff);
EPD_2IN9D_SendCommand(0x82); //vcom_DC setting
EPD_2IN9D_SendData(0x28);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_2IN9D_Clear(void)
{
UWORD Width, Height;
Width = (EPD_2IN9D_WIDTH % 8 == 0)? (EPD_2IN9D_WIDTH / 8 ): (EPD_2IN9D_WIDTH / 8 + 1);
Height = EPD_2IN9D_HEIGHT;
EPD_2IN9D_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9D_SendData(0x00);
}
}
EPD_2IN9D_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9D_SendData(0xFF);
}
}
EPD_SetFullReg();
EPD_2IN9D_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN9D_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_2IN9D_WIDTH % 8 == 0)? (EPD_2IN9D_WIDTH / 8 ): (EPD_2IN9D_WIDTH / 8 + 1);
Height = EPD_2IN9D_HEIGHT;
EPD_2IN9D_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9D_SendData(0x00);
}
}
// Dev_Delay_ms(10);
EPD_2IN9D_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9D_SendData(Image[i + j * Width]);
}
}
// Dev_Delay_ms(10);
EPD_SetFullReg();
EPD_2IN9D_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_2IN9D_DisplayPart(UBYTE *Image)
{
/* Set partial Windows */
EPD_2IN9D_SetPartReg();
EPD_2IN9D_SendCommand(0x91); //This command makes the display enter partial mode
EPD_2IN9D_SendCommand(0x90); //resolution setting
EPD_2IN9D_SendData(0); //x-start
EPD_2IN9D_SendData(EPD_2IN9D_WIDTH - 1); //x-end
EPD_2IN9D_SendData(0);
EPD_2IN9D_SendData(0); //y-start
EPD_2IN9D_SendData(EPD_2IN9D_HEIGHT / 256);
EPD_2IN9D_SendData(EPD_2IN9D_HEIGHT % 256 - 1); //y-end
EPD_2IN9D_SendData(0x28);
UWORD Width;
Width = (EPD_2IN9D_WIDTH % 8 == 0)? (EPD_2IN9D_WIDTH / 8 ): (EPD_2IN9D_WIDTH / 8 + 1);
/* send data */
EPD_2IN9D_SendCommand(0x13);
for (UWORD j = 0; j < EPD_2IN9D_HEIGHT; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_2IN9D_SendData(Image[i + j * Width]);
}
}
/* Set partial refresh */
EPD_2IN9D_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_2IN9D_Sleep(void)
{
EPD_2IN9D_SendCommand(0X50);
EPD_2IN9D_SendData(0xf7);
EPD_2IN9D_SendCommand(0X02); //power off
EPD_2IN9D_ReadBusy();
EPD_2IN9D_SendCommand(0X07); //deep sleep
EPD_2IN9D_SendData(0xA5);
}

69
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_2in9d.h Normal file
View file

@ -0,0 +1,69 @@
/*****************************************************************************
* | File : EPD_2in9d.c
* | Author : Waveshare team
* | Function : 2.9inch e-paper d
* | Info :
*----------------
* | This version: V2.0
* | Date : 2019-06-12
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-12):
* 1.Change:
* lut_vcomDC[] => EPD_2IN9D_lut_vcomDC[]
* lut_ww[] => EPD_2IN9D_lut_ww[]
* lut_bw[] => EPD_2IN9D_lut_bw[]
* lut_wb[] => EPD_2IN9D_lut_wb[]
* lut_bb[] => EPD_2IN9D_lut_bb[]
* lut_vcom1[] => EPD_2IN9D_lut_vcom1[]
* lut_ww1[] => EPD_2IN9D_lut_ww1[]
* lut_bw1[] => EPD_2IN9D_lut_bw1[]
* lut_wb1[] => EPD_2IN9D_lut_wb1[]
* lut_bb1[] => EPD_2IN9D_lut_bb1[]
* EPD_Reset() => EPD_2IN9D_Reset()
* EPD_SendCommand() => EPD_2IN9D_SendCommand()
* EPD_SendData() => EPD_2IN9D_SendData()
* EPD_WaitUntilIdle() => EPD_2IN9D_ReadBusy()
* EPD_SetFullReg() => EPD_2IN9D_SetFullReg()
* EPD_SetPartReg() => EPD_2IN9D_SetPartReg()
* EPD_TurnOnDisplay() => EPD_2IN9D_TurnOnDisplay()
* EPD_Init() => EPD_2IN9D_Init()
* EPD_Clear() => EPD_2IN9D_Clear()
* EPD_Display() => EPD_2IN9D_Display()
* EPD_Sleep() => EPD_2IN9D_Sleep()
*
# 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_2IN9D_H_
#define __EPD_2IN9D_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_2IN9D_WIDTH 128
#define EPD_2IN9D_HEIGHT 296
void EPD_2IN9D_Init(void);
void EPD_2IN9D_Clear(void);
void EPD_2IN9D_Display(UBYTE *Image);
void EPD_2IN9D_DisplayPart(UBYTE *Image);
void EPD_2IN9D_Sleep(void);
#endif

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

@ -0,0 +1,588 @@
/*****************************************************************************
* | File : EPD_3IN7.C
* | Author : Waveshare team
* | Function : 3.7inch e-paper
* | 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_3in7.h"
#include "Debug.h"
static const UBYTE lut_4Gray_GC[] =
{
0x2A,0x06,0x15,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//1
0x28,0x06,0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//2
0x20,0x06,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//3
0x14,0x06,0x28,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//4
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//5
0x00,0x02,0x02,0x0A,0x00,0x00,0x00,0x08,0x08,0x02,//6
0x00,0x02,0x02,0x0A,0x00,0x00,0x00,0x00,0x00,0x00,//7
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//8
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//9
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//10
0x22,0x22,0x22,0x22,0x22
};
static const UBYTE lut_1Gray_GC[] =
{
0x2A,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//1
0x05,0x2A,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//2
0x2A,0x15,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//3
0x05,0x0A,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//4
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//5
0x00,0x02,0x03,0x0A,0x00,0x02,0x06,0x0A,0x05,0x00,//6
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//7
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//8
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//9
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//10
0x22,0x22,0x22,0x22,0x22
};
static const UBYTE lut_1Gray_DU[] =
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//1
0x01,0x2A,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x0A,0x55,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//3
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//5
0x00,0x00,0x05,0x05,0x00,0x05,0x03,0x05,0x05,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//7
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//9
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x22,0x22,0x22,0x22,0x22
};
static const UBYTE lut_1Gray_A2[] =
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //1
0x0A,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //2
0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //3
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //4
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //5
0x00,0x00,0x03,0x05,0x00,0x00,0x00,0x00,0x00,0x00, //6
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //7
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //8
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //9
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //10
0x22,0x22,0x22,0x22,0x22
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_3IN7_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(30);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(3);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(30);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_3IN7_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_3IN7_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);
}
static void EPD_3IN7_ReadBusy_HIGH(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");
}
/******************************************************************************
function : set the look-up tables
parameter:
******************************************************************************/
void EPD_3IN7_Load_LUT(UBYTE lut)
{
UWORD i;
EPD_3IN7_SendCommand(0x32);
for (i = 0; i < 105; i++)
{
if(lut == 0)
EPD_3IN7_SendData(lut_4Gray_GC[i]);
else if(lut == 1)
EPD_3IN7_SendData(lut_1Gray_GC[i]);
else if(lut == 2)
EPD_3IN7_SendData(lut_1Gray_DU[i]);
else if(lut == 3)
EPD_3IN7_SendData(lut_1Gray_A2[i]);
else
Debug("There is no such lut \r\n");
}
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_3IN7_4Gray_Init(void)
{
EPD_3IN7_Reset();
EPD_3IN7_SendCommand(0x12);
DEV_Delay_ms(300);
EPD_3IN7_SendCommand(0x46);
EPD_3IN7_SendData(0xF7);
EPD_3IN7_ReadBusy_HIGH();
EPD_3IN7_SendCommand(0x47);
EPD_3IN7_SendData(0xF7);
EPD_3IN7_ReadBusy_HIGH();
EPD_3IN7_SendCommand(0x01); // setting gaet number
EPD_3IN7_SendData(0xDF);
EPD_3IN7_SendData(0x01);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x03); // set gate voltage
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x04); // set source voltage
EPD_3IN7_SendData(0x41);
EPD_3IN7_SendData(0xA8);
EPD_3IN7_SendData(0x32);
EPD_3IN7_SendCommand(0x11); // set data entry sequence
EPD_3IN7_SendData(0x03);
EPD_3IN7_SendCommand(0x3C); // set border
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x0C); // set booster strength
EPD_3IN7_SendData(0xAE);
EPD_3IN7_SendData(0xC7);
EPD_3IN7_SendData(0xC3);
EPD_3IN7_SendData(0xC0);
EPD_3IN7_SendData(0xC0);
EPD_3IN7_SendCommand(0x18); // set internal sensor on
EPD_3IN7_SendData(0x80);
EPD_3IN7_SendCommand(0x2C); // set vcom value
EPD_3IN7_SendData(0x44);
EPD_3IN7_SendCommand(0x37); // set display option, these setting turn on previous function
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x44); // setting X direction start/end position of RAM
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x17);
EPD_3IN7_SendData(0x01);
EPD_3IN7_SendCommand(0x45); // setting Y direction start/end position of RAM
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0xDF);
EPD_3IN7_SendData(0x01);
EPD_3IN7_SendCommand(0x22); // Display Update Control 2
EPD_3IN7_SendData(0xCF);
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_3IN7_1Gray_Init(void)
{
EPD_3IN7_Reset();
EPD_3IN7_SendCommand(0x12);
DEV_Delay_ms(300);
EPD_3IN7_SendCommand(0x46);
EPD_3IN7_SendData(0xF7);
EPD_3IN7_ReadBusy_HIGH();
EPD_3IN7_SendCommand(0x47);
EPD_3IN7_SendData(0xF7);
EPD_3IN7_ReadBusy_HIGH();
EPD_3IN7_SendCommand(0x01); // setting gaet number
EPD_3IN7_SendData(0xDF);
EPD_3IN7_SendData(0x01);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x03); // set gate voltage
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x04); // set source voltage
EPD_3IN7_SendData(0x41);
EPD_3IN7_SendData(0xA8);
EPD_3IN7_SendData(0x32);
EPD_3IN7_SendCommand(0x11); // set data entry sequence
EPD_3IN7_SendData(0x03);
EPD_3IN7_SendCommand(0x3C); // set border
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x0C); // set booster strength
EPD_3IN7_SendData(0xAE);
EPD_3IN7_SendData(0xC7);
EPD_3IN7_SendData(0xC3);
EPD_3IN7_SendData(0xC0);
EPD_3IN7_SendData(0xC0);
EPD_3IN7_SendCommand(0x18); // set internal sensor on
EPD_3IN7_SendData(0x80);
EPD_3IN7_SendCommand(0x2C); // set vcom value
EPD_3IN7_SendData(0x44);
EPD_3IN7_SendCommand(0x37); // set display option, these setting turn on previous function
EPD_3IN7_SendData(0x00); //can switch 1 gray or 4 gray
EPD_3IN7_SendData(0xFF);
EPD_3IN7_SendData(0xFF);
EPD_3IN7_SendData(0xFF);
EPD_3IN7_SendData(0xFF);
EPD_3IN7_SendData(0x4F);
EPD_3IN7_SendData(0xFF);
EPD_3IN7_SendData(0xFF);
EPD_3IN7_SendData(0xFF);
EPD_3IN7_SendData(0xFF);
EPD_3IN7_SendCommand(0x44); // setting X direction start/end position of RAM
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x17);
EPD_3IN7_SendData(0x01);
EPD_3IN7_SendCommand(0x45); // setting Y direction start/end position of RAM
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0xDF);
EPD_3IN7_SendData(0x01);
EPD_3IN7_SendCommand(0x22); // Display Update Control 2
EPD_3IN7_SendData(0xCF);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_3IN7_4Gray_Clear(void)
{
UWORD Width, Height;
Width = (EPD_3IN7_WIDTH % 8 == 0)? (EPD_3IN7_WIDTH / 8 ): (EPD_3IN7_WIDTH / 8 + 1);
Height = EPD_3IN7_HEIGHT;
EPD_3IN7_SendCommand(0x49);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x4E);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x4F);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x24);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_3IN7_SendData(0xff);
}
}
EPD_3IN7_SendCommand(0x4E);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x4F);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x26);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_3IN7_SendData(0xff);
}
}
EPD_3IN7_Load_LUT(0);
EPD_3IN7_SendCommand(0x22);
EPD_3IN7_SendData(0xC7);
EPD_3IN7_SendCommand(0x20);
EPD_3IN7_ReadBusy_HIGH();
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_3IN7_1Gray_Clear(void)
{
UWORD i;
UWORD IMAGE_COUNTER = EPD_3IN7_WIDTH * EPD_3IN7_HEIGHT / 8;
EPD_3IN7_SendCommand(0x4E);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x4F);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x24);
for (i = 0; i < IMAGE_COUNTER; i++)
{
EPD_3IN7_SendData(0xff);
}
EPD_3IN7_Load_LUT(2);
EPD_3IN7_SendCommand(0x20);
EPD_3IN7_ReadBusy_HIGH();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_3IN7_4Gray_Display(const UBYTE *Image)
{
UDOUBLE i,j,k;
UBYTE temp1,temp2,temp3;
EPD_3IN7_SendCommand(0x49);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x4E);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x4F);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x24);
for(i=0;i<16800;i++){
temp3=0;
for(j=0; j<2; j++) {
temp1 = Image[i*2+j];
for(k=0; k<2; k++) {
temp2 = temp1&0xC0;
if(temp2 == 0xC0)
temp3 |= 0x01;//white
else if(temp2 == 0x00)
temp3 |= 0x00; //black
else if(temp2 == 0x80)
temp3 |= 0x00; //gray1
else //0x40
temp3 |= 0x01; //gray2
temp3 <<= 1;
temp1 <<= 2;
temp2 = temp1&0xC0 ;
if(temp2 == 0xC0) //white
temp3 |= 0x01;
else if(temp2 == 0x00) //black
temp3 |= 0x00;
else if(temp2 == 0x80)
temp3 |= 0x00; //gray1
else //0x40
temp3 |= 0x01; //gray2
if(j!=1 || k!=1)
temp3 <<= 1;
temp1 <<= 2;
}
}
EPD_3IN7_SendData(temp3);
}
// new data
EPD_3IN7_SendCommand(0x4E);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x4F);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x26);
for(i=0; i<16800; i++) {
temp3=0;
for(j=0; j<2; j++) {
temp1 = Image[i*2+j];
for(k=0; k<2; k++) {
temp2 = temp1&0xC0 ;
if(temp2 == 0xC0)
temp3 |= 0x01;//white
else if(temp2 == 0x00)
temp3 |= 0x00; //black
else if(temp2 == 0x80)
temp3 |= 0x01; //gray1
else //0x40
temp3 |= 0x00; //gray2
temp3 <<= 1;
temp1 <<= 2;
temp2 = temp1&0xC0 ;
if(temp2 == 0xC0) //white
temp3 |= 0x01;
else if(temp2 == 0x00) //black
temp3 |= 0x00;
else if(temp2 == 0x80)
temp3 |= 0x01; //gray1
else //0x40
temp3 |= 0x00; //gray2
if(j!=1 || k!=1)
temp3 <<= 1;
temp1 <<= 2;
}
}
EPD_3IN7_SendData(temp3);
}
EPD_3IN7_Load_LUT(0);
EPD_3IN7_SendCommand(0x22);
EPD_3IN7_SendData(0xC7);
EPD_3IN7_SendCommand(0x20);
EPD_3IN7_ReadBusy_HIGH();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_3IN7_1Gray_Display(const UBYTE *Image)
{
UWORD i;
UWORD IMAGE_COUNTER = EPD_3IN7_WIDTH * EPD_3IN7_HEIGHT / 8;
EPD_3IN7_SendCommand(0x4E);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x4F);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendData(0x00);
EPD_3IN7_SendCommand(0x24);
for (i = 0; i < IMAGE_COUNTER; i++)
{
EPD_3IN7_SendData(Image[i]);
}
EPD_3IN7_Load_LUT(2);
EPD_3IN7_SendCommand(0x20);
EPD_3IN7_ReadBusy_HIGH();
}
/******************************************************************************
function : Sends part the image buffer in RAM to e-Paper and displays
notes:
You can send a part of data to e-Paper,But this function is not recommended
1.Xsize must be as big as EPD_3IN7_WIDTH
2.Ypointer must be start at 0
******************************************************************************/
void EPD_3IN7_1Gray_Display_Part(const UBYTE *Image, UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend)
{
UWORD i, Width;
Width = (Xend-Xstart)%8 == 0 ? (Xend-Xstart)/8 : (Xend-Xstart)/8+1;
UWORD IMAGE_COUNTER = Width * (Yend-Ystart);
EPD_3IN7_SendCommand(0x44);
EPD_3IN7_SendData(Xstart & 0xff);
EPD_3IN7_SendData((Xstart>>8) & 0x03);
EPD_3IN7_SendData(Xend & 0xff);
EPD_3IN7_SendData((Xend>>8) & 0x03);
EPD_3IN7_SendCommand(0x45);
EPD_3IN7_SendData(Ystart & 0xff);
EPD_3IN7_SendData((Ystart>>8) & 0x03);
EPD_3IN7_SendData(Yend & 0xff);
EPD_3IN7_SendData((Yend>>8) & 0x03);
EPD_3IN7_SendCommand(0x24);
for (i = 0; i < IMAGE_COUNTER; i++)
{
EPD_3IN7_SendData(Image[i]);
}
EPD_3IN7_Load_LUT(2);
EPD_3IN7_SendCommand(0x20);
EPD_3IN7_ReadBusy_HIGH();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_3IN7_Sleep(void)
{
EPD_3IN7_SendCommand(0X50);
EPD_3IN7_SendData(0xf7);
EPD_3IN7_SendCommand(0X02); //power off
EPD_3IN7_SendCommand(0X07); //deep sleep
EPD_3IN7_SendData(0xA5);
}

51
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_3in7.h Normal file
View file

@ -0,0 +1,51 @@
/*****************************************************************************
* | File : EPD_3IN7.h
* | Author : Waveshare team
* | Function : 3.7inch e-paper
* | 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.
#
******************************************************************************/
#ifndef __EPD_3IN7_H_
#define __EPD_3IN7_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_3IN7_WIDTH 280
#define EPD_3IN7_HEIGHT 480
void EPD_3IN7_4Gray_Clear(void);
void EPD_3IN7_4Gray_Init(void);
void EPD_3IN7_4Gray_Display(const UBYTE *Image);
void EPD_3IN7_1Gray_Clear(void);
void EPD_3IN7_1Gray_Init(void);
void EPD_3IN7_1Gray_Display(const UBYTE *Image);
void EPD_3IN7_1Gray_Display_Part(const UBYTE *Image, UWORD Xstart, UWORD Ystart, UWORD Xend, UWORD Yend);
void EPD_3IN7_Sleep(void);
#endif

271
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_4in01f.c Normal file
View file

@ -0,0 +1,271 @@
/*****************************************************************************
* | File : EPD_4in01f.c
* | Author : Waveshare team
* | Function : 4.01inch e-paper
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-11-06
* | 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_4in01f.h"
/******************************************************************************
function:
hardware reset
******************************************************************************/
static void EPD_4IN01F_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(200);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(5);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(200);
}
/******************************************************************************
function:
send Command
******************************************************************************/
static void EPD_4IN01F_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
******************************************************************************/
static void EPD_4IN01F_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:
io busy
******************************************************************************/
static void EPD_4IN01F_BusyHigh(void)// If BUSYN=0 then waiting
{
printf("e-Paper busy \r\n");
while(!(DEV_Digital_Read(EPD_BUSY_PIN)))
DEV_Delay_ms(500);
printf("e-Paper busy release \r\n");
}
static void EPD_4IN01F_BusyLow(void)// If BUSYN=1 then waiting
{
printf("e-Paper busy \r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN))
DEV_Delay_ms(500);
printf("e-Paper busy release \r\n");
}
/******************************************************************************
function:
module init
******************************************************************************/
void EPD_4IN01F_Init(void)
{
EPD_4IN01F_Reset();
EPD_4IN01F_BusyHigh();
EPD_4IN01F_SendCommand(0x00);
EPD_4IN01F_SendData(0x2f);
EPD_4IN01F_SendData(0x00);
EPD_4IN01F_SendCommand(0x01);
EPD_4IN01F_SendData(0x37);
EPD_4IN01F_SendData(0x00);
EPD_4IN01F_SendData(0x05);
EPD_4IN01F_SendData(0x05);
EPD_4IN01F_SendCommand(0x03);
EPD_4IN01F_SendData(0x00);
EPD_4IN01F_SendCommand(0x06);
EPD_4IN01F_SendData(0xC7);
EPD_4IN01F_SendData(0xC7);
EPD_4IN01F_SendData(0x1D);
EPD_4IN01F_SendCommand(0x41);
EPD_4IN01F_SendData(0x00);
EPD_4IN01F_SendCommand(0x50);
EPD_4IN01F_SendData(0x37);
EPD_4IN01F_SendCommand(0x60);
EPD_4IN01F_SendData(0x22);
EPD_4IN01F_SendCommand(0x61);
EPD_4IN01F_SendData(0x02);
EPD_4IN01F_SendData(0x80);
EPD_4IN01F_SendData(0x01);
EPD_4IN01F_SendData(0x90);
EPD_4IN01F_SendCommand(0xE3);
EPD_4IN01F_SendData(0xAA);
}
/******************************************************************************
function:
clear display
******************************************************************************/
void EPD_4IN01F_Clear(UBYTE color)
{
EPD_4IN01F_SendCommand(0x61);//Set Resolution setting
EPD_4IN01F_SendData(0x02);
EPD_4IN01F_SendData(0x80);
EPD_4IN01F_SendData(0x01);
EPD_4IN01F_SendData(0x90);
EPD_4IN01F_SendCommand(0x10);
for(int i=0; i<EPD_4IN01F_HEIGHT; i++) {
for(int j=0; j<EPD_4IN01F_WIDTH/2; j++)
EPD_4IN01F_SendData((color<<4)|color);
}
EPD_4IN01F_SendCommand(0x04);//0x04
EPD_4IN01F_BusyHigh();
EPD_4IN01F_SendCommand(0x12);//0x12
EPD_4IN01F_BusyHigh();
EPD_4IN01F_SendCommand(0x02); //0x02
EPD_4IN01F_BusyLow();
DEV_Delay_ms(500);
}
/******************************************************************************
function:
show 7 kind of color block
******************************************************************************/
void EPD_4IN01F_Show7Block(void)
{
unsigned long i,j,k;
unsigned char const Color_seven[8] =
{EPD_4IN01F_BLACK,EPD_4IN01F_BLUE,EPD_4IN01F_GREEN,EPD_4IN01F_ORANGE,
EPD_4IN01F_RED,EPD_4IN01F_YELLOW,EPD_4IN01F_WHITE,EPD_4IN01F_WHITE};
EPD_4IN01F_SendCommand(0x61);//Set Resolution setting
EPD_4IN01F_SendData(0x02);
EPD_4IN01F_SendData(0x80);
EPD_4IN01F_SendData(0x01);
EPD_4IN01F_SendData(0x90);
EPD_4IN01F_SendCommand(0x10);
for(i=0; i<224; i++) {
for(k = 0 ; k < 4; k ++) {
for(j = 0 ; j < 75; j ++) {
EPD_4IN01F_SendData((Color_seven[k]<<4) |Color_seven[k]);
}
}
}
for(i=0; i<224; i++) {
for(k = 4 ; k < 8; k ++) {
for(j = 0 ; j < 75; j ++) {
EPD_4IN01F_SendData((Color_seven[k]<<4) |Color_seven[k]);
}
}
}
EPD_4IN01F_SendCommand(0x04);//0x04
EPD_4IN01F_BusyHigh();
EPD_4IN01F_SendCommand(0x12);//0x12
EPD_4IN01F_BusyHigh();
EPD_4IN01F_SendCommand(0x02); //0x02
EPD_4IN01F_BusyLow();
DEV_Delay_ms(200);
}
/******************************************************************************
function:
refresh display
******************************************************************************/
void EPD_4IN01F_Display(const UBYTE *image)
{
unsigned long i, j;
// UBYTE k = 0;
EPD_4IN01F_SendCommand(0x61);//Set Resolution setting
EPD_4IN01F_SendData(0x02);
EPD_4IN01F_SendData(0x80);
EPD_4IN01F_SendData(0x01);
EPD_4IN01F_SendData(0x90);
EPD_4IN01F_SendCommand(0x10);
for(i=0; i<EPD_4IN01F_HEIGHT; i++) {
for(j=0; j<EPD_4IN01F_WIDTH/2; j++) {
EPD_4IN01F_SendData(image[j+((EPD_4IN01F_WIDTH/2)*i)]);
// printf("0x%x, ", image[j+((EPD_4IN01F_WIDTH/2)*i)]);
// k++;
// if(k == 16) {
// printf("\n");
// k = 0;
// }
}
}
EPD_4IN01F_SendCommand(0x04);//0x04
EPD_4IN01F_BusyHigh();
EPD_4IN01F_SendCommand(0x12);//0x12
EPD_4IN01F_BusyHigh();
EPD_4IN01F_SendCommand(0x02); //0x02
EPD_4IN01F_BusyLow();
DEV_Delay_ms(200);
}
void EPD_4IN01F_Display_part(const UBYTE *image, UWORD xstart, UWORD ystart,
UWORD image_width, UWORD image_heigh)
{
unsigned long i, j;
// UBYTE k = 0;
EPD_4IN01F_SendCommand(0x61);//Set Resolution setting
EPD_4IN01F_SendData(0x02);
EPD_4IN01F_SendData(0x80);
EPD_4IN01F_SendData(0x01);
EPD_4IN01F_SendData(0x90);
EPD_4IN01F_SendCommand(0x10);
for(i=0; i<EPD_4IN01F_HEIGHT; i++) {
for(j=0; j< EPD_4IN01F_WIDTH/2; j++) {
if(i<image_heigh+ystart && i>=ystart && j<(image_width+xstart)/2 && j>=xstart/2) {
EPD_4IN01F_SendData(image[(j-xstart/2) + (image_width/2*(i-ystart))]);
// printf("0x%x, ", image[j+((EPD_4IN01F_WIDTH/2)*i)]);
// k++;
// if(k == 16) {
// printf("\r\n");
// k = 0;
// }
}
else {
EPD_4IN01F_SendData(0x11);
}
}
}
EPD_4IN01F_SendCommand(0x04);//0x04
EPD_4IN01F_BusyHigh();
EPD_4IN01F_SendCommand(0x12);//0x12
EPD_4IN01F_BusyHigh();
EPD_4IN01F_SendCommand(0x02); //0x02
EPD_4IN01F_BusyLow();
DEV_Delay_ms(200);
}
/******************************************************************************
function:
Sleep
******************************************************************************/
void EPD_4IN01F_Sleep(void)
{
DEV_Delay_ms(100);
EPD_4IN01F_SendCommand(0x07);
EPD_4IN01F_SendData(0xA5);
}

62
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_4in01f.h Normal file
View file

@ -0,0 +1,62 @@
/*****************************************************************************
* | File : EPD_4in01f.h
* | Author : Waveshare team
* | Function : 4.01inch e-paper
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-11-06
* | 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_4IN01F_H__
#define __EPD_4IN01F_H__
#include "DEV_Config.h"
/**********************************
Color Index
**********************************/
#define EPD_4IN01F_BLACK 0x0 /// 000
#define EPD_4IN01F_WHITE 0x1 /// 001
#define EPD_4IN01F_GREEN 0x2 /// 010
#define EPD_4IN01F_BLUE 0x3 /// 011
#define EPD_4IN01F_RED 0x4 /// 100
#define EPD_4IN01F_YELLOW 0x5 /// 101
#define EPD_4IN01F_ORANGE 0x6 /// 110
#define EPD_4IN01F_CLEAN 0x7 /// 111 unavailable Afterimage
#define EPD_4IN01F_WIDTH 640
#define EPD_4IN01F_HEIGHT 400
void EPD_4IN01F_Clear(UBYTE color);
void EPD_4IN01F_Sleep(void);
void EPD_Init(void);
void EPD_4IN01F_Show7Block(void);
void EPD_4IN01F_Display(const UBYTE *image);
void EPD_4IN01F_Init(void);
void EPD_4IN01F_Display_part(const UBYTE *image, UWORD xstart, UWORD ystart,
UWORD image_width, UWORD image_heigh);
#endif

702
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_4in2.c Normal file
View file

@ -0,0 +1,702 @@
/*****************************************************************************
* | File : EPD_4in2.c
* | Author : Waveshare team
* | Function : 4.2inch e-paper
* | Info :
*----------------
* | This version: V3.1
* | Date : 2019-11-14
* | Info :
* -----------------------------------------------------------------------------
* V3.1(2019-11-14):
* 1.Add 4 grayscale drive and display program
* Add EPD_4IN2_4Gray_lut_vcom[]
* Add EPD_4IN2_4Gray_lut_ww[]
* Add EPD_4IN2_4Gray_lut_bw[]
* Add EPD_4IN2_4Gray_lut_wb
* Add EPD_4IN2_4Gray_lut_bb
* Add EPD_4IN2_Partial_SetLut()
* Add EPD_4IN2_4Gray_lut()
* Add EPD_4IN2_Init_4Gray()
* Add EPD_4IN2_4GrayDisplay(....)
* 2.Add partial refresh display
* Add EPD_4IN2_Partial_lut_vcom1[]
* Add EPD_4IN2_Partial_lut_ww1[]
* Add EPD_4IN2_Partial_lut_bw1[]
* Add EPD_4IN2_Partial_lut_wb1[]
* Add EPD_4IN2_Partial_lut_bb1[]
* Add EPD_4IN2_Partial_SetLut()
* Add EPD_4IN2_PartialDisplay(...)
* Poor display, no display function by default
*
* V3.0(2019-06-13):
* 1.Change:
* lut_vcomDC[] => EPD_4IN2_lut_vcomDC[]
* lut_ww[] => EPD_4IN2_lut_ww[]
* lut_bw[] => EPD_4IN2_lut_bw[]
* lut_wb[] => EPD_4IN2_lut_wb[]
* lut_bb[] => EPD_4IN2_lut_bb[]
* EPD_Reset() => EPD_4IN2_Reset()
* EPD_SendCommand() => EPD_4IN2_SendCommand()
* EPD_SendData() => EPD_4IN2_SendData()
* EPD_WaitUntilIdle() => EPD_4IN2_ReadBusy()
* EPD_SetFullReg() => EPD_4IN2_SetFullReg()
* EPD_SetPartReg() => EPD_4IN2_SetPartReg()
* EPD_TurnOnDisplay() => EPD_4IN2_TurnOnDisplay()
* EPD_Init() => EPD_4IN2_Init()
* EPD_Clear() => EPD_4IN2_Clear()
* EPD_Display() => EPD_4IN2_Display()
* EPD_Sleep() => EPD_4IN2_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define VCOM_LUT 0x20
* #define W2W_LUT 0x21
* #define B2W_LUT 0x22
* #define W2B_LUT 0x23
* #define B2B_LUT 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_CALIBRATION 0x40
* #define TEMPERATURE_SENSOR_SELECTION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define RESOLUTION_SETTING 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* V2.0(2018-10-30):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_4in2.h"
#include "Debug.h"
static const unsigned char EPD_4IN2_lut_vcom0[] = {
0x00, 0x17, 0x00, 0x00, 0x00, 0x02,
0x00, 0x17, 0x17, 0x00, 0x00, 0x02,
0x00, 0x0A, 0x01, 0x00, 0x00, 0x01,
0x00, 0x0E, 0x0E, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const unsigned char EPD_4IN2_lut_ww[] = {
0x40, 0x17, 0x00, 0x00, 0x00, 0x02,
0x90, 0x17, 0x17, 0x00, 0x00, 0x02,
0x40, 0x0A, 0x01, 0x00, 0x00, 0x01,
0xA0, 0x0E, 0x0E, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const unsigned char EPD_4IN2_lut_bw[] = {
0x40, 0x17, 0x00, 0x00, 0x00, 0x02,
0x90, 0x17, 0x17, 0x00, 0x00, 0x02,
0x40, 0x0A, 0x01, 0x00, 0x00, 0x01,
0xA0, 0x0E, 0x0E, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const unsigned char EPD_4IN2_lut_wb[] = {
0x80, 0x17, 0x00, 0x00, 0x00, 0x02,
0x90, 0x17, 0x17, 0x00, 0x00, 0x02,
0x80, 0x0A, 0x01, 0x00, 0x00, 0x01,
0x50, 0x0E, 0x0E, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static const unsigned char EPD_4IN2_lut_bb[] = {
0x80, 0x17, 0x00, 0x00, 0x00, 0x02,
0x90, 0x17, 0x17, 0x00, 0x00, 0x02,
0x80, 0x0A, 0x01, 0x00, 0x00, 0x01,
0x50, 0x0E, 0x0E, 0x00, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
/******************************partial screen update LUT*********************************/
const unsigned char EPD_4IN2_Partial_lut_vcom1[] ={
0x00 ,0x19 ,0x01 ,0x00 ,0x00 ,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, };
const unsigned char EPD_4IN2_Partial_lut_ww1[] ={
0x00 ,0x19 ,0x01 ,0x00 ,0x00 ,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,};
const unsigned char EPD_4IN2_Partial_lut_bw1[] ={
0x80 ,0x19 ,0x01 ,0x00 ,0x00 ,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, };
const unsigned char EPD_4IN2_Partial_lut_wb1[] ={
0x40 ,0x19 ,0x01 ,0x00 ,0x00 ,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, };
const unsigned char EPD_4IN2_Partial_lut_bb1[] ={
0x00 ,0x19 ,0x01 ,0x00 ,0x00 ,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, };
/******************************gray*********************************/
//0~3 gray
const unsigned char EPD_4IN2_4Gray_lut_vcom[] =
{
0x00 ,0x0A ,0x00 ,0x00 ,0x00 ,0x01,
0x60 ,0x14 ,0x14 ,0x00 ,0x00 ,0x01,
0x00 ,0x14 ,0x00 ,0x00 ,0x00 ,0x01,
0x00 ,0x13 ,0x0A ,0x01 ,0x00 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00
};
//R21
const unsigned char EPD_4IN2_4Gray_lut_ww[] ={
0x40 ,0x0A ,0x00 ,0x00 ,0x00 ,0x01,
0x90 ,0x14 ,0x14 ,0x00 ,0x00 ,0x01,
0x10 ,0x14 ,0x0A ,0x00 ,0x00 ,0x01,
0xA0 ,0x13 ,0x01 ,0x00 ,0x00 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
//R22H r
const unsigned char EPD_4IN2_4Gray_lut_bw[] ={
0x40 ,0x0A ,0x00 ,0x00 ,0x00 ,0x01,
0x90 ,0x14 ,0x14 ,0x00 ,0x00 ,0x01,
0x00 ,0x14 ,0x0A ,0x00 ,0x00 ,0x01,
0x99 ,0x0C ,0x01 ,0x03 ,0x04 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
//R23H w
const unsigned char EPD_4IN2_4Gray_lut_wb[] ={
0x40 ,0x0A ,0x00 ,0x00 ,0x00 ,0x01,
0x90 ,0x14 ,0x14 ,0x00 ,0x00 ,0x01,
0x00 ,0x14 ,0x0A ,0x00 ,0x00 ,0x01,
0x99 ,0x0B ,0x04 ,0x04 ,0x01 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
//R24H b
const unsigned char EPD_4IN2_4Gray_lut_bb[] ={
0x80 ,0x0A ,0x00 ,0x00 ,0x00 ,0x01,
0x90 ,0x14 ,0x14 ,0x00 ,0x00 ,0x01,
0x20 ,0x14 ,0x0A ,0x00 ,0x00 ,0x01,
0x50 ,0x13 ,0x01 ,0x00 ,0x00 ,0x01,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
0x00 ,0x00 ,0x00 ,0x00 ,0x00 ,0x00,
};
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_4IN2_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
******************************************************************************/
static void EPD_4IN2_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_4IN2_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:
******************************************************************************/
void EPD_4IN2_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
EPD_4IN2_SendCommand(0x71);
while(DEV_Digital_Read(EPD_BUSY_PIN) == 0) { //LOW: idle, HIGH: busy
EPD_4IN2_SendCommand(0x71);
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_4IN2_TurnOnDisplay(void)
{
EPD_4IN2_SendCommand(0x12);
DEV_Delay_ms(100);
EPD_4IN2_ReadBusy();
}
/******************************************************************************
function : set the look-up tables
parameter:
******************************************************************************/
static void EPD_4IN2_SetLut(void)
{
UWORD count;
EPD_4IN2_SendCommand(0x20); //g vcom
for(count=0; count<44; count++) {
EPD_4IN2_SendData(EPD_4IN2_lut_vcom0[count]);
}
EPD_4IN2_SendCommand(0x21);
for(count=0; count<42; count++) {
EPD_4IN2_SendData(EPD_4IN2_lut_ww[count]);
}
EPD_4IN2_SendCommand(0x22);
for(count=0; count<42; count++) {
EPD_4IN2_SendData(EPD_4IN2_lut_bw[count]);
}
EPD_4IN2_SendCommand(0x23);
for(count=0; count<42; count++) {
EPD_4IN2_SendData(EPD_4IN2_lut_wb[count]);
}
EPD_4IN2_SendCommand(0x24);
for(count=0; count<42; count++) {
EPD_4IN2_SendData(EPD_4IN2_lut_bb[count]);
}
}
static void EPD_4IN2_Partial_SetLut(void)
{
unsigned int count;
EPD_4IN2_SendCommand(0x20);
for(count=0;count<44;count++)
{EPD_4IN2_SendData(EPD_4IN2_Partial_lut_vcom1[count]);}
EPD_4IN2_SendCommand(0x21);
for(count=0;count<42;count++)
{EPD_4IN2_SendData(EPD_4IN2_Partial_lut_ww1[count]);}
EPD_4IN2_SendCommand(0x22);
for(count=0;count<42;count++)
{EPD_4IN2_SendData(EPD_4IN2_Partial_lut_bw1[count]);}
EPD_4IN2_SendCommand(0x23);
for(count=0;count<42;count++)
{EPD_4IN2_SendData(EPD_4IN2_Partial_lut_wb1[count]);}
EPD_4IN2_SendCommand(0x24);
for(count=0;count<42;count++)
{EPD_4IN2_SendData(EPD_4IN2_Partial_lut_bb1[count]);}
}
//LUT download
static void EPD_4IN2_4Gray_lut(void)
{
unsigned int count;
{
EPD_4IN2_SendCommand(0x20); //vcom
for(count=0;count<42;count++)
{EPD_4IN2_SendData(EPD_4IN2_4Gray_lut_vcom[count]);}
EPD_4IN2_SendCommand(0x21); //red not use
for(count=0;count<42;count++)
{EPD_4IN2_SendData(EPD_4IN2_4Gray_lut_ww[count]);}
EPD_4IN2_SendCommand(0x22); //bw r
for(count=0;count<42;count++)
{EPD_4IN2_SendData(EPD_4IN2_4Gray_lut_bw[count]);}
EPD_4IN2_SendCommand(0x23); //wb w
for(count=0;count<42;count++)
{EPD_4IN2_SendData(EPD_4IN2_4Gray_lut_wb[count]);}
EPD_4IN2_SendCommand(0x24); //bb b
for(count=0;count<42;count++)
{EPD_4IN2_SendData(EPD_4IN2_4Gray_lut_bb[count]);}
EPD_4IN2_SendCommand(0x25); //vcom
for(count=0;count<42;count++)
{EPD_4IN2_SendData(EPD_4IN2_4Gray_lut_ww[count]);}
}
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_4IN2_Init(void)
{
EPD_4IN2_Reset();
EPD_4IN2_SendCommand(0x01); // POWER SETTING
EPD_4IN2_SendData(0x03);
EPD_4IN2_SendData(0x00);
EPD_4IN2_SendData(0x2b);
EPD_4IN2_SendData(0x2b);
EPD_4IN2_SendCommand(0x06); // boost soft start
EPD_4IN2_SendData(0x17); //A
EPD_4IN2_SendData(0x17); //B
EPD_4IN2_SendData(0x17); //C
EPD_4IN2_SendCommand(0x04); // POWER_ON
EPD_4IN2_ReadBusy();
EPD_4IN2_SendCommand(0x00); // panel setting
EPD_4IN2_SendData(0xbf); // KW-BF KWR-AF BWROTP 0f BWOTP 1f
EPD_4IN2_SendData(0x0d);
EPD_4IN2_SendCommand(0x30); // PLL setting
EPD_4IN2_SendData(0x3C); // 3A 100HZ 29 150Hz 39 200HZ 31 171HZ
EPD_4IN2_SendCommand(0x61); // resolution setting
EPD_4IN2_SendData(0x01);
EPD_4IN2_SendData(0x90); //128
EPD_4IN2_SendData(0x01); //
EPD_4IN2_SendData(0x2c);
EPD_4IN2_SendCommand(0x82); // vcom_DC setting
EPD_4IN2_SendData(0x28);
EPD_4IN2_SendCommand(0X50); // VCOM AND DATA INTERVAL SETTING
EPD_4IN2_SendData(0x97); // 97white border 77black border VBDF 17|D7 VBDW 97 VBDB 57 VBDF F7 VBDW 77 VBDB 37 VBDR B7
EPD_4IN2_SetLut();
}
void EPD_4IN2_Init_4Gray(void)
{
EPD_4IN2_Reset();
EPD_4IN2_SendCommand(0x01); //POWER SETTING
EPD_4IN2_SendData (0x03);
EPD_4IN2_SendData (0x00); //VGH=20V,VGL=-20V
EPD_4IN2_SendData (0x2b); //VDH=15V
EPD_4IN2_SendData (0x2b); //VDL=-15V
EPD_4IN2_SendData (0x13);
EPD_4IN2_SendCommand(0x06); //booster soft start
EPD_4IN2_SendData (0x17); //A
EPD_4IN2_SendData (0x17); //B
EPD_4IN2_SendData (0x17); //C
EPD_4IN2_SendCommand(0x04);
EPD_4IN2_ReadBusy();
EPD_4IN2_SendCommand(0x00); //panel setting
EPD_4IN2_SendData(0x3f); //KW-3f KWR-2F BWROTP 0f BWOTP 1f
EPD_4IN2_SendCommand(0x30); //PLL setting
EPD_4IN2_SendData (0x3c); //100hz
EPD_4IN2_SendCommand(0x61); //resolution setting
EPD_4IN2_SendData (0x01); //400
EPD_4IN2_SendData (0x90);
EPD_4IN2_SendData (0x01); //300
EPD_4IN2_SendData (0x2c);
EPD_4IN2_SendCommand(0x82); //vcom_DC setting
EPD_4IN2_SendData (0x12);
EPD_4IN2_SendCommand(0X50); //VCOM AND DATA INTERVAL SETTING
EPD_4IN2_SendData(0x97);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_4IN2_Clear(void)
{
UWORD Width, Height;
Width = (EPD_4IN2_WIDTH % 8 == 0)? (EPD_4IN2_WIDTH / 8 ): (EPD_4IN2_WIDTH / 8 + 1);
Height = EPD_4IN2_HEIGHT;
EPD_4IN2_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_4IN2_SendData(0xFF);
}
}
EPD_4IN2_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_4IN2_SendData(0xFF);
}
}
EPD_4IN2_SendCommand(0x12); //DISPLAY REFRESH
DEV_Delay_ms(10);
EPD_4IN2_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_4IN2_Display(UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_4IN2_WIDTH % 8 == 0)? (EPD_4IN2_WIDTH / 8 ): (EPD_4IN2_WIDTH / 8 + 1);
Height = EPD_4IN2_HEIGHT;
EPD_4IN2_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_4IN2_SendData(Image[i + j * Width]);
}
}
EPD_4IN2_TurnOnDisplay();
}
void EPD_4IN2_PartialDisplay(UWORD X_start,UWORD Y_start,UWORD X_end,UWORD Y_end, UBYTE *Image)
{
UWORD Width, Height;
Width = (EPD_4IN2_WIDTH % 8 == 0)? (EPD_4IN2_WIDTH / 8 ): (EPD_4IN2_WIDTH / 8 + 1);
Height = EPD_4IN2_HEIGHT;
X_start = (X_start % 8 == 0)? (X_start): (X_start/8*8+8);
X_end = (X_end % 8 == 0)? (X_end): (X_end/8*8+8);
EPD_4IN2_SendCommand(0X50);
EPD_4IN2_SendData(0xf7);
DEV_Delay_ms(100);
EPD_4IN2_SendCommand(0x82); //vcom_DC setting
EPD_4IN2_SendData (0x08);
EPD_4IN2_SendCommand(0X50);
EPD_4IN2_SendData(0x47);
EPD_4IN2_Partial_SetLut();
EPD_4IN2_SendCommand(0x91); //This command makes the display enter partial mode
EPD_4IN2_SendCommand(0x90); //resolution setting
EPD_4IN2_SendData ((X_start)/256);
EPD_4IN2_SendData ((X_start)%256); //x-start
EPD_4IN2_SendData ((X_end )/256);
EPD_4IN2_SendData ((X_end )%256-1); //x-end
EPD_4IN2_SendData (Y_start/256);
EPD_4IN2_SendData (Y_start%256); //y-start
EPD_4IN2_SendData (Y_end/256);
EPD_4IN2_SendData (Y_end%256-1); //y-end
EPD_4IN2_SendData (0x28);
EPD_4IN2_SendCommand(0x10); //writes Old data to SRAM for programming
for (UWORD j = 0; j < Y_end - Y_start; j++) {
for (UWORD i = 0; i < (X_end - X_start)/8; i++) {
EPD_4IN2_SendData(Image[(Y_start + j)*Width + X_start/8 + i]);
}
}
EPD_4IN2_SendCommand(0x13); //writes New data to SRAM.
for (UWORD j = 0; j < Y_end - Y_start; j++) {
for (UWORD i = 0; i < (X_end - X_start)/8; i++) {
EPD_4IN2_SendData(~Image[(Y_start + j)*Width + X_start/8 + i]);
}
}
EPD_4IN2_SendCommand(0x12); //DISPLAY REFRESH
DEV_Delay_ms(10); //The delay here is necessary, 200uS at least!!!
EPD_4IN2_TurnOnDisplay();
}
void EPD_4IN2_4GrayDisplay(const UBYTE *Image)
{
UDOUBLE i,j,k,m;
UBYTE temp1,temp2,temp3;
/****Color display description****
white gray1 gray2 black
0x10| 01 01 00 00
0x13| 01 00 01 00
*********************************/
EPD_4IN2_SendCommand(0x10);
// EPD_4IN2_HEIGHT
// EPD_4IN2_WIDTH
for(m = 0; m<EPD_4IN2_HEIGHT;m++)
for(i=0;i<EPD_4IN2_WIDTH/8;i++)
{
temp3=0;
for(j=0;j<2;j++)
{
temp1 = Image[(m*(EPD_4IN2_WIDTH/8)+i)*2+j];
for(k=0;k<2;k++)
{
temp2 = temp1&0xC0 ;
if(temp2 == 0xC0)
temp3 |= 0x01;//white
else if(temp2 == 0x00)
temp3 |= 0x00; //black
else if(temp2 == 0x80)
temp3 |= 0x01; //gray1
else //0x40
temp3 |= 0x00; //gray2
temp3 <<= 1;
temp1 <<= 2;
temp2 = temp1&0xC0 ;
if(temp2 == 0xC0) //white
temp3 |= 0x01;
else if(temp2 == 0x00) //black
temp3 |= 0x00;
else if(temp2 == 0x80)
temp3 |= 0x01; //gray1
else //0x40
temp3 |= 0x00; //gray2
if(j!=1 || k!=1)
temp3 <<= 1;
temp1 <<= 2;
}
}
EPD_4IN2_SendData(temp3);
}
// new data
EPD_4IN2_SendCommand(0x13);
for(m = 0; m<EPD_4IN2_HEIGHT;m++)
for(i=0;i<EPD_4IN2_WIDTH/8;i++)
{
temp3=0;
for(j=0;j<2;j++)
{
temp1 = Image[(m*(EPD_4IN2_WIDTH/8)+i)*2+j];
for(k=0;k<2;k++)
{
temp2 = temp1&0xC0 ;
if(temp2 == 0xC0)
temp3 |= 0x01;//white
else if(temp2 == 0x00)
temp3 |= 0x00; //black
else if(temp2 == 0x80)
temp3 |= 0x00; //gray1
else //0x40
temp3 |= 0x01; //gray2
temp3 <<= 1;
temp1 <<= 2;
temp2 = temp1&0xC0 ;
if(temp2 == 0xC0) //white
temp3 |= 0x01;
else if(temp2 == 0x00) //black
temp3 |= 0x00;
else if(temp2 == 0x80)
temp3 |= 0x00; //gray1
else //0x40
temp3 |= 0x01; //gray2
if(j!=1 || k!=1)
temp3 <<= 1;
temp1 <<= 2;
}
}
EPD_4IN2_SendData(temp3);
}
EPD_4IN2_4Gray_lut();
EPD_4IN2_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_4IN2_Sleep(void)
{
// EPD_4IN2_SendCommand(0x02); // POWER_OFF
// EPD_4IN2_ReadBusy();
EPD_4IN2_SendCommand(0x07); // DEEP_SLEEP
EPD_4IN2_SendData(0XA5);
}

129
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_4in2.h Normal file
View file

@ -0,0 +1,129 @@
/*****************************************************************************
* | File : EPD_4in2.h
* | Author : Waveshare team
* | Function : 4.2inch e-paper
* | Info :
*----------------
* | This version: V3.1
* | Date : 2019-11-14
* | Info :
* -----------------------------------------------------------------------------
* V3.1(2019-11-14):
* 1.Add 4 grayscale drive and display program
* Add EPD_4IN2_4Gray_lut_vcom[]
* Add EPD_4IN2_4Gray_lut_ww[]
* Add EPD_4IN2_4Gray_lut_bw[]
* Add EPD_4IN2_4Gray_lut_wb
* Add EPD_4IN2_4Gray_lut_bb
* Add EPD_4IN2_Partial_SetLut()
* Add EPD_4IN2_4Gray_lut()
* Add EPD_4IN2_Init_4Gray()
* Add EPD_4IN2_4GrayDisplay(....)
* 2.Add partial refresh display
* Add EPD_4IN2_Partial_lut_vcom1[]
* Add EPD_4IN2_Partial_lut_ww1[]
* Add EPD_4IN2_Partial_lut_bw1[]
* Add EPD_4IN2_Partial_lut_wb1[]
* Add EPD_4IN2_Partial_lut_bb1[]
* Add EPD_4IN2_Partial_SetLut()
* Add EPD_4IN2_PartialDisplay(...)
* Poor display, no display function by default
*
* V3.0(2019-06-13):
* 1.Change:
* lut_vcomDC[] => EPD_4IN2_lut_vcomDC[]
* lut_ww[] => EPD_4IN2_lut_ww[]
* lut_bw[] => EPD_4IN2_lut_bw[]
* lut_wb[] => EPD_4IN2_lut_wb[]
* lut_bb[] => EPD_4IN2_lut_bb[]
* EPD_Reset() => EPD_4IN2_Reset()
* EPD_SendCommand() => EPD_4IN2_SendCommand()
* EPD_SendData() => EPD_4IN2_SendData()
* EPD_WaitUntilIdle() => EPD_4IN2_ReadBusy()
* EPD_SetFullReg() => EPD_4IN2_SetFullReg()
* EPD_SetPartReg() => EPD_4IN2_SetPartReg()
* EPD_TurnOnDisplay() => EPD_4IN2_TurnOnDisplay()
* EPD_Init() => EPD_4IN2_Init()
* EPD_Clear() => EPD_4IN2_Clear()
* EPD_Display() => EPD_4IN2_Display()
* EPD_Sleep() => EPD_4IN2_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define VCOM_LUT 0x20
* #define W2W_LUT 0x21
* #define B2W_LUT 0x22
* #define W2B_LUT 0x23
* #define B2B_LUT 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_CALIBRATION 0x40
* #define TEMPERATURE_SENSOR_SELECTION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define RESOLUTION_SETTING 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* V2.0(2018-10-30):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_4IN2_H_
#define _EPD_4IN2_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_4IN2_WIDTH 400
#define EPD_4IN2_HEIGHT 300
void EPD_4IN2_Init(void);
void EPD_4IN2_Clear(void);
void EPD_4IN2_Display(UBYTE *Image);
void EPD_4IN2_Sleep(void);
void EPD_4IN2_PartialDisplay(UWORD X_start,UWORD Y_start,UWORD X_end,UWORD Y_end, UBYTE *Image);
void EPD_4IN2_Init_4Gray(void);
void EPD_4IN2_4GrayDisplay(const UBYTE *Image);
#endif

182
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_4in2b_V2.c Normal file
View file

@ -0,0 +1,182 @@
/*****************************************************************************
* | File : EPD_4in2b_V2.c
* | Author : Waveshare team
* | Function : 4.2inch e-paper b V2
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-04-23
* | 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_4in2b_V2.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_4IN2B_V2_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
******************************************************************************/
static void EPD_4IN2B_V2_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_4IN2B_V2_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:
******************************************************************************/
void EPD_4IN2B_V2_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
do{
EPD_4IN2B_V2_SendCommand(0x71);
DEV_Delay_ms(50);
}while(!(DEV_Digital_Read(EPD_BUSY_PIN)));
Debug("e-Paper busy release\r\n");
DEV_Delay_ms(50);
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_4IN2B_V2_TurnOnDisplay(void)
{
EPD_4IN2B_V2_SendCommand(0x12); // DISPLAY_REFRESH
DEV_Delay_ms(100);
EPD_4IN2B_V2_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_4IN2B_V2_Init(void)
{
EPD_4IN2B_V2_Reset();
EPD_4IN2B_V2_SendCommand(0x04);
EPD_4IN2B_V2_ReadBusy();
EPD_4IN2B_V2_SendCommand(0x00);
EPD_4IN2B_V2_SendData(0x0f);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_4IN2B_V2_Clear(void)
{
UWORD Width, Height;
Width = (EPD_4IN2B_V2_WIDTH % 8 == 0)? (EPD_4IN2B_V2_WIDTH / 8 ): (EPD_4IN2B_V2_WIDTH / 8 + 1);
Height = EPD_4IN2B_V2_HEIGHT;
EPD_4IN2B_V2_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_4IN2B_V2_SendData(0xFF);
}
}
EPD_4IN2B_V2_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_4IN2B_V2_SendData(0xFF);
}
}
EPD_4IN2B_V2_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_4IN2B_V2_Display(const UBYTE *blackimage, const UBYTE *ryimage)
{
UWORD Width, Height;
Width = (EPD_4IN2B_V2_WIDTH % 8 == 0)? (EPD_4IN2B_V2_WIDTH / 8 ): (EPD_4IN2B_V2_WIDTH / 8 + 1);
Height = EPD_4IN2B_V2_HEIGHT;
EPD_4IN2B_V2_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_4IN2B_V2_SendData(blackimage[i + j * Width]);
}
}
EPD_4IN2B_V2_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_4IN2B_V2_SendData(ryimage[i + j * Width]);
}
}
EPD_4IN2B_V2_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_4IN2B_V2_Sleep(void)
{
EPD_4IN2B_V2_SendCommand(0X50);
EPD_4IN2B_V2_SendData(0xf7); //border floating
EPD_4IN2B_V2_SendCommand(0X02); //power off
EPD_4IN2B_V2_ReadBusy(); //waiting for the electronic paper IC to release the idle signal
EPD_4IN2B_V2_SendCommand(0X07); //deep sleep
EPD_4IN2B_V2_SendData(0xA5);
}

45
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_4in2b_V2.h Normal file
View file

@ -0,0 +1,45 @@
/*****************************************************************************
* | File : EPD_4in2b_V2.h
* | Author : Waveshare team
* | Function : 4.2inch e-paper b&c
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-04-23
* | 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_4IN2B_V2_H_
#define __EPD_4IN2B_V2_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_4IN2B_V2_WIDTH 400
#define EPD_4IN2B_V2_HEIGHT 300
void EPD_4IN2B_V2_Init(void);
void EPD_4IN2B_V2_Clear(void);
void EPD_4IN2B_V2_Display(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_4IN2B_V2_Sleep(void);
#endif

233
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_4in2bc.c Normal file
View file

@ -0,0 +1,233 @@
/*****************************************************************************
* | File : EPD_4in2b.c
* | Author : Waveshare team
* | Function : 4.2inch e-paper b&c
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_4IN2BC_Reset()
* EPD_SendCommand() => EPD_4IN2BC_SendCommand()
* EPD_SendData() => EPD_4IN2BC_SendData()
* EPD_WaitUntilIdle() => EPD_4IN2BC_ReadBusy()
* EPD_Init() => EPD_4IN2BC_Init()
* EPD_Clear() => EPD_4IN2BC_Clear()
* EPD_Display() => EPD_4IN2BC_Display()
* EPD_Sleep() => EPD_4IN2BC_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define VCOM_LUT 0x20
* #define W2W_LUT 0x21
* #define B2W_LUT 0x22
* #define W2B_LUT 0x23
* #define B2B_LUT 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_CALIBRATION 0x40
* #define TEMPERATURE_SENSOR_SELECTION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define RESOLUTION_SETTING 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* -----------------------------------------------------------------------------
* V2.0(2018-11-09):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_4in2bc.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_4IN2BC_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
******************************************************************************/
static void EPD_4IN2BC_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_4IN2BC_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:
******************************************************************************/
void EPD_4IN2BC_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 0) { //0: busy, 1: idle
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_4IN2BC_TurnOnDisplay(void)
{
EPD_4IN2BC_SendCommand(0x12); // DISPLAY_REFRESH
DEV_Delay_ms(100);
EPD_4IN2BC_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_4IN2BC_Init(void)
{
EPD_4IN2BC_Reset();
EPD_4IN2BC_SendCommand(0x06); // BOOSTER_SOFT_START
EPD_4IN2BC_SendData(0x17);
EPD_4IN2BC_SendData(0x17);
EPD_4IN2BC_SendData(0x17); // 07 0f 17 1f 27 2F 37 2f
EPD_4IN2BC_SendCommand(0x04); // POWER_ON
EPD_4IN2BC_ReadBusy();
EPD_4IN2BC_SendCommand(0x00); // PANEL_SETTING
EPD_4IN2BC_SendData(0x0F); // LUT from OTP
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_4IN2BC_Clear(void)
{
UWORD Width, Height;
Width = (EPD_4IN2BC_WIDTH % 8 == 0)? (EPD_4IN2BC_WIDTH / 8 ): (EPD_4IN2BC_WIDTH / 8 + 1);
Height = EPD_4IN2BC_HEIGHT;
EPD_4IN2BC_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_4IN2BC_SendData(0xFF);
}
}
EPD_4IN2BC_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_4IN2BC_SendData(0xFF);
}
}
EPD_4IN2BC_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_4IN2BC_Display(const UBYTE *blackimage, const UBYTE *ryimage)
{
UWORD Width, Height;
Width = (EPD_4IN2BC_WIDTH % 8 == 0)? (EPD_4IN2BC_WIDTH / 8 ): (EPD_4IN2BC_WIDTH / 8 + 1);
Height = EPD_4IN2BC_HEIGHT;
EPD_4IN2BC_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_4IN2BC_SendData(blackimage[i + j * Width]);
}
}
EPD_4IN2BC_SendCommand(0x13);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
EPD_4IN2BC_SendData(ryimage[i + j * Width]);
}
}
EPD_4IN2BC_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_4IN2BC_Sleep(void)
{
EPD_4IN2BC_SendCommand(0x02); // POWER_OFF
EPD_4IN2BC_ReadBusy();
EPD_4IN2BC_SendCommand(0x07); // DEEP_SLEEP
EPD_4IN2BC_SendData(0XA5);
}

98
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_4in2bc.h Normal file
View file

@ -0,0 +1,98 @@
/*****************************************************************************
* | File : EPD_4in2b.h
* | Author : Waveshare team
* | Function : 4.2inch e-paper b&c
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_4IN2BC_Reset()
* EPD_SendCommand() => EPD_4IN2BC_SendCommand()
* EPD_SendData() => EPD_4IN2BC_SendData()
* EPD_WaitUntilIdle() => EPD_4IN2BC_ReadBusy()
* EPD_Init() => EPD_4IN2BC_Init()
* EPD_Clear() => EPD_4IN2BC_Clear()
* EPD_Display() => EPD_4IN2BC_Display()
* EPD_Sleep() => EPD_4IN2BC_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define VCOM_LUT 0x20
* #define W2W_LUT 0x21
* #define B2W_LUT 0x22
* #define W2B_LUT 0x23
* #define B2B_LUT 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_CALIBRATION 0x40
* #define TEMPERATURE_SENSOR_SELECTION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define RESOLUTION_SETTING 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* -----------------------------------------------------------------------------
* V2.0(2018-11-09):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_4IN2BC_H_
#define __EPD_4IN2BC_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_4IN2BC_WIDTH 400
#define EPD_4IN2BC_HEIGHT 300
void EPD_4IN2BC_Init(void);
void EPD_4IN2BC_Clear(void);
void EPD_4IN2BC_Display(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_4IN2BC_Sleep(void);
#endif

275
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_5in65f.c Normal file
View file

@ -0,0 +1,275 @@
/*****************************************************************************
* | File : EPD_5in65f.c
* | Author : Waveshare team
* | Function : 5.65inch e-paper
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-07-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_5in65f.h"
/******************************************************************************
function:
hardware reset
******************************************************************************/
static void EPD_5IN65F_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
******************************************************************************/
static void EPD_5IN65F_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
******************************************************************************/
static void EPD_5IN65F_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:
io busy
******************************************************************************/
static void EPD_5IN65F_BusyHigh(void)// If BUSYN=0 then waiting
{
while(!(DEV_Digital_Read(EPD_BUSY_PIN)));
}
static void EPD_5IN65F_BusyLow(void)// If BUSYN=1 then waiting
{
while(DEV_Digital_Read(EPD_BUSY_PIN));
}
/******************************************************************************
function:
module init
******************************************************************************/
void EPD_5IN65F_Init(void)
{
EPD_5IN65F_Reset();
EPD_5IN65F_BusyHigh();
EPD_5IN65F_SendCommand(0x00);
EPD_5IN65F_SendData(0xEF);
EPD_5IN65F_SendData(0x08);
EPD_5IN65F_SendCommand(0x01);
EPD_5IN65F_SendData(0x37);
EPD_5IN65F_SendData(0x00);
EPD_5IN65F_SendData(0x23);
EPD_5IN65F_SendData(0x23);
EPD_5IN65F_SendCommand(0x03);
EPD_5IN65F_SendData(0x00);
EPD_5IN65F_SendCommand(0x06);
EPD_5IN65F_SendData(0xC7);
EPD_5IN65F_SendData(0xC7);
EPD_5IN65F_SendData(0x1D);
EPD_5IN65F_SendCommand(0x30);
EPD_5IN65F_SendData(0x3C);
EPD_5IN65F_SendCommand(0x40);
EPD_5IN65F_SendData(0x00);
EPD_5IN65F_SendCommand(0x50);
EPD_5IN65F_SendData(0x37);
EPD_5IN65F_SendCommand(0x60);
EPD_5IN65F_SendData(0x22);
EPD_5IN65F_SendCommand(0x61);
EPD_5IN65F_SendData(0x02);
EPD_5IN65F_SendData(0x58);
EPD_5IN65F_SendData(0x01);
EPD_5IN65F_SendData(0xC0);
EPD_5IN65F_SendCommand(0xE3);
EPD_5IN65F_SendData(0xAA);
DEV_Delay_ms(100);
EPD_5IN65F_SendCommand(0x50);
EPD_5IN65F_SendData(0x37);
}
/******************************************************************************
function:
clear display
******************************************************************************/
void EPD_5IN65F_Clear(UBYTE color)
{
EPD_5IN65F_SendCommand(0x61);//Set Resolution setting
EPD_5IN65F_SendData(0x02);
EPD_5IN65F_SendData(0x58);
EPD_5IN65F_SendData(0x01);
EPD_5IN65F_SendData(0xC0);
EPD_5IN65F_SendCommand(0x10);
for(int i=0; i<EPD_5IN65F_HEIGHT; i++) {
for(int j=0; j<EPD_5IN65F_WIDTH/2; j++)
EPD_5IN65F_SendData((color<<4)|color);
}
EPD_5IN65F_SendCommand(0x04);//0x04
EPD_5IN65F_BusyHigh();
EPD_5IN65F_SendCommand(0x12);//0x12
EPD_5IN65F_BusyHigh();
EPD_5IN65F_SendCommand(0x02); //0x02
EPD_5IN65F_BusyLow();
DEV_Delay_ms(500);
}
/******************************************************************************
function:
show 7 kind of color block
******************************************************************************/
void EPD_5IN65F_Show7Block(void)
{
unsigned long i,j,k;
unsigned char const Color_seven[8] =
{EPD_5IN65F_BLACK,EPD_5IN65F_BLUE,EPD_5IN65F_GREEN,EPD_5IN65F_ORANGE,
EPD_5IN65F_RED,EPD_5IN65F_YELLOW,EPD_5IN65F_WHITE,EPD_5IN65F_WHITE};
EPD_5IN65F_SendCommand(0x61);//Set Resolution setting
EPD_5IN65F_SendData(0x02);
EPD_5IN65F_SendData(0x58);
EPD_5IN65F_SendData(0x01);
EPD_5IN65F_SendData(0xC0);
EPD_5IN65F_SendCommand(0x10);
for(i=0; i<224; i++) {
for(k = 0 ; k < 4; k ++) {
for(j = 0 ; j < 75; j ++) {
EPD_5IN65F_SendData((Color_seven[k]<<4) |Color_seven[k]);
}
}
}
for(i=0; i<224; i++) {
for(k = 4 ; k < 8; k ++) {
for(j = 0 ; j < 75; j ++) {
EPD_5IN65F_SendData((Color_seven[k]<<4) |Color_seven[k]);
}
}
}
EPD_5IN65F_SendCommand(0x04);//0x04
EPD_5IN65F_BusyHigh();
EPD_5IN65F_SendCommand(0x12);//0x12
EPD_5IN65F_BusyHigh();
EPD_5IN65F_SendCommand(0x02); //0x02
EPD_5IN65F_BusyLow();
DEV_Delay_ms(200);
}
/******************************************************************************
function:
refresh display
******************************************************************************/
void EPD_5IN65F_Display(const UBYTE *image)
{
unsigned long i, j;
// UBYTE k = 0;
EPD_5IN65F_SendCommand(0x61);//Set Resolution setting
EPD_5IN65F_SendData(0x02);
EPD_5IN65F_SendData(0x58);
EPD_5IN65F_SendData(0x01);
EPD_5IN65F_SendData(0xC0);
EPD_5IN65F_SendCommand(0x10);
for(i=0; i<EPD_5IN65F_HEIGHT; i++) {
for(j=0; j<EPD_5IN65F_WIDTH/2; j++) {
EPD_5IN65F_SendData(image[j+((EPD_5IN65F_WIDTH/2)*i)]);
// printf("0x%x, ", image[j+((EPD_5IN65F_WIDTH/2)*i)]);
// k++;
// if(k == 16) {
// printf("\n");
// k = 0;
// }
}
}
EPD_5IN65F_SendCommand(0x04);//0x04
EPD_5IN65F_BusyHigh();
EPD_5IN65F_SendCommand(0x12);//0x12
EPD_5IN65F_BusyHigh();
EPD_5IN65F_SendCommand(0x02); //0x02
EPD_5IN65F_BusyLow();
DEV_Delay_ms(200);
}
void EPD_5IN65F_Display_part(const UBYTE *image, UWORD xstart, UWORD ystart,
UWORD image_width, UWORD image_heigh)
{
unsigned long i, j;
// UBYTE k = 0;
EPD_5IN65F_SendCommand(0x61);//Set Resolution setting
EPD_5IN65F_SendData(0x02);
EPD_5IN65F_SendData(0x58);
EPD_5IN65F_SendData(0x01);
EPD_5IN65F_SendData(0xC0);
EPD_5IN65F_SendCommand(0x10);
for(i=0; i<EPD_5IN65F_HEIGHT; i++) {
for(j=0; j< EPD_5IN65F_WIDTH/2; j++) {
if(i<image_heigh+ystart && i>=ystart && j<(image_width+xstart)/2 && j>=xstart/2) {
EPD_5IN65F_SendData(image[(j-xstart/2) + (image_width/2*(i-ystart))]);
// printf("0x%x, ", image[j+((EPD_5IN65F_WIDTH/2)*i)]);
// k++;
// if(k == 16) {
// printf("\r\n");
// k = 0;
// }
}
else {
EPD_5IN65F_SendData(0x11);
}
}
}
EPD_5IN65F_SendCommand(0x04);//0x04
EPD_5IN65F_BusyHigh();
EPD_5IN65F_SendCommand(0x12);//0x12
EPD_5IN65F_BusyHigh();
EPD_5IN65F_SendCommand(0x02); //0x02
EPD_5IN65F_BusyLow();
DEV_Delay_ms(200);
}
/******************************************************************************
function:
Sleep
******************************************************************************/
void EPD_5IN65F_Sleep(void)
{
DEV_Delay_ms(100);
EPD_5IN65F_SendCommand(0x07);
EPD_5IN65F_SendData(0xA5);
DEV_Delay_ms(100);
DEV_Digital_Write(EPD_RST_PIN, 0); // Reset
}

62
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_5in65f.h Normal file
View file

@ -0,0 +1,62 @@
/*****************************************************************************
* | File : EPD_5in65f.h
* | Author : Waveshare team
* | Function : 5.65inch e-paper
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-07-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_5IN65F_H__
#define __EPD_5IN65F_H__
#include "DEV_Config.h"
/**********************************
Color Index
**********************************/
#define EPD_5IN65F_BLACK 0x0 /// 000
#define EPD_5IN65F_WHITE 0x1 /// 001
#define EPD_5IN65F_GREEN 0x2 /// 010
#define EPD_5IN65F_BLUE 0x3 /// 011
#define EPD_5IN65F_RED 0x4 /// 100
#define EPD_5IN65F_YELLOW 0x5 /// 101
#define EPD_5IN65F_ORANGE 0x6 /// 110
#define EPD_5IN65F_CLEAN 0x7 /// 111 unavailable Afterimage
#define EPD_5IN65F_WIDTH 600
#define EPD_5IN65F_HEIGHT 448
void EPD_5IN65F_Clear(UBYTE color);
void EPD_5IN65F_Sleep(void);
void EPD_Init(void);
void EPD_5IN65F_Show7Block(void);
void EPD_5IN65F_Display(const UBYTE *image);
void EPD_5IN65F_Init(void);
void EPD_5IN65F_Display_part(const UBYTE *image, UWORD xstart, UWORD ystart,
UWORD image_width, UWORD image_heigh);
#endif

270
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_5in83.c Normal file
View file

@ -0,0 +1,270 @@
/*****************************************************************************
* | File : EPD_5in83.c
* | Author : Waveshare team
* | Function : 5.83inch e-paper
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_5IN83_Reset()
* EPD_SendCommand() => EPD_5IN83_SendCommand()
* EPD_SendData() => EPD_5IN83_SendData()
* EPD_WaitUntilIdle() => EPD_5IN83_ReadBusy()
* EPD_SetFullReg() => EPD_5IN83_SetFullReg()
* EPD_SetPartReg() => EPD_5IN83_SetPartReg()
* EPD_TurnOnDisplay() => EPD_5IN83_TurnOnDisplay()
* EPD_Init() => EPD_5IN83_Init()
* EPD_Clear() => EPD_5IN83_Clear()
* EPD_Display() => EPD_5IN83_Display()
* EPD_Sleep() => EPD_5IN83_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define VCOM_LUT 0x20
* #define W2W_LUT 0x21
* #define B2W_LUT 0x22
* #define W2B_LUT 0x23
* #define B2B_LUT 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_CALIBRATION 0x40
* #define TEMPERATURE_SENSOR_SELECTION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define RESOLUTION_SETTING 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* -----------------------------------------------------------------------------
* V2.0(2018-11-09):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_5in83.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_5IN83_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
******************************************************************************/
static void EPD_5IN83_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_5IN83_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_5IN83_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 0) { //LOW: idle, HIGH: busy
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_5IN83_TurnOnDisplay(void)
{
EPD_5IN83_SendCommand(0x12); // DISPLAY_REFRESH
DEV_Delay_ms(100);
EPD_5IN83_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_5IN83_Init(void)
{
EPD_5IN83_Reset();
EPD_5IN83_SendCommand(0x01); // POWER_SETTING
EPD_5IN83_SendData(0x37);
EPD_5IN83_SendData(0x00);
EPD_5IN83_SendCommand(0x00); // PANEL_SETTING
EPD_5IN83_SendData(0xCF);
EPD_5IN83_SendData(0x08);
EPD_5IN83_SendCommand(0x06); // BOOSTER_SOFT_START
EPD_5IN83_SendData(0xc7);
EPD_5IN83_SendData(0xcc);
EPD_5IN83_SendData(0x28);
EPD_5IN83_SendCommand(0x04); // POWER_ON
EPD_5IN83_ReadBusy();
EPD_5IN83_SendCommand(0x30); // PLL_CONTROL
EPD_5IN83_SendData(0x3c);
EPD_5IN83_SendCommand(0x41); // TEMPERATURE_CALIBRATION
EPD_5IN83_SendData(0x00);
EPD_5IN83_SendCommand(0x50); // VCOM_AND_DATA_INTERVAL_SETTING
EPD_5IN83_SendData(0x77);
EPD_5IN83_SendCommand(0x60); // TCON_SETTING
EPD_5IN83_SendData(0x22);
EPD_5IN83_SendCommand(0x61); // TCON_RESOLUTION
EPD_5IN83_SendData(EPD_5IN83_WIDTH >> 8); // source 600
EPD_5IN83_SendData(EPD_5IN83_WIDTH & 0xff);
EPD_5IN83_SendData(EPD_5IN83_HEIGHT >> 8); // gate 448
EPD_5IN83_SendData(EPD_5IN83_HEIGHT & 0xff);
EPD_5IN83_SendCommand(0x82); // VCM_DC_SETTING
EPD_5IN83_SendData(0x1E); // decide by LUT file
EPD_5IN83_SendCommand(0xe5); // FLASH MODE
EPD_5IN83_SendData(0x03);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_5IN83_Clear(void)
{
UWORD Width, Height;
Width = (EPD_5IN83_WIDTH % 8 == 0)? (EPD_5IN83_WIDTH / 8 ): (EPD_5IN83_WIDTH / 8 + 1);
Height = EPD_5IN83_HEIGHT;
EPD_5IN83_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
for(UBYTE k = 0; k < 4; k++) {
EPD_5IN83_SendData(0x33);
}
}
}
EPD_5IN83_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_5IN83_Display(UBYTE *Image)
{
UBYTE Data_Black, Data;
UWORD Width, Height;
Width = (EPD_5IN83_WIDTH % 8 == 0)? (EPD_5IN83_WIDTH / 8 ): (EPD_5IN83_WIDTH / 8 + 1);
Height = EPD_5IN83_HEIGHT;
EPD_5IN83_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
Data_Black = ~Image[i + j * Width];
for(UBYTE k = 0; k < 8; k++) {
if(Data_Black & 0x80)
Data = 0x00;
else
Data = 0x03;
Data <<= 4;
Data_Black <<= 1;
k++;
if(Data_Black & 0x80)
Data |= 0x00;
else
Data |= 0x03;
Data_Black <<= 1;
EPD_5IN83_SendData(Data);
}
}
}
EPD_5IN83_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_5IN83_Sleep(void)
{
EPD_5IN83_SendCommand(0x02); // POWER_OFF
EPD_5IN83_ReadBusy();
EPD_5IN83_SendCommand(0x07); // DEEP_SLEEP
EPD_5IN83_SendData(0XA5);
}

101
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_5in83.h Normal file
View file

@ -0,0 +1,101 @@
/*****************************************************************************
* | File : EPD_5in83.h
* | Author : Waveshare team
* | Function : 5.83inch e-paper
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_5IN83_Reset()
* EPD_SendCommand() => EPD_5IN83_SendCommand()
* EPD_SendData() => EPD_5IN83_SendData()
* EPD_WaitUntilIdle() => EPD_5IN83_ReadBusy()
* EPD_SetFullReg() => EPD_5IN83_SetFullReg()
* EPD_SetPartReg() => EPD_5IN83_SetPartReg()
* EPD_TurnOnDisplay() => EPD_5IN83_TurnOnDisplay()
* EPD_Init() => EPD_5IN83_Init()
* EPD_Clear() => EPD_5IN83_Clear()
* EPD_Display() => EPD_5IN83_Display()
* EPD_Sleep() => EPD_5IN83_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define VCOM_LUT 0x20
* #define W2W_LUT 0x21
* #define B2W_LUT 0x22
* #define W2B_LUT 0x23
* #define B2B_LUT 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_CALIBRATION 0x40
* #define TEMPERATURE_SENSOR_SELECTION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define RESOLUTION_SETTING 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* -----------------------------------------------------------------------------
* V2.0(2018-11-09):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_5IN83_H_
#define __EPD_5IN83_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_5IN83_WIDTH 600
#define EPD_5IN83_HEIGHT 448
void EPD_5IN83_Init(void);
void EPD_5IN83_Clear(void);
void EPD_5IN83_Display(UBYTE *Image);
void EPD_5IN83_Sleep(void);
#endif

196
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_5in83_V2.c Normal file
View file

@ -0,0 +1,196 @@
/*****************************************************************************
* | File : EPD_5in83_V2.c
* | Author : Waveshare team
* | Function : 5.83inch e-paper V2
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-11-23
* | 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_5in83_V2.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_5in83_V2_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(200);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(5);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(200);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_5in83_V2_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_5in83_V2_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_5in83_V2_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
do {
EPD_5in83_V2_SendCommand(0x71);
DEV_Delay_ms(50);
}
while(!DEV_Digital_Read(EPD_BUSY_PIN));
Debug("e-Paper busy release\r\n");
DEV_Delay_ms(50);
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_5in83_V2_TurnOnDisplay(void)
{
EPD_5in83_V2_SendCommand(0x12); //DISPLAY REFRESH
DEV_Delay_ms(100); //!!!The delay here is necessary, 200uS at least!!!
EPD_5in83_V2_ReadBusy(); //waiting for the electronic paper IC to release the idle signal
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_5in83_V2_Init(void)
{
EPD_5in83_V2_Reset();
EPD_5in83_V2_SendCommand(0x01); //POWER SETTING
EPD_5in83_V2_SendData (0x07);
EPD_5in83_V2_SendData (0x07); //VGH=20V,VGL=-20V
EPD_5in83_V2_SendData (0x3f); //VDH=15V
EPD_5in83_V2_SendData (0x3f); //VDL=-15V
EPD_5in83_V2_SendCommand(0x04); //POWER ON
DEV_Delay_ms(100);
EPD_5in83_V2_ReadBusy(); //waiting for the electronic paper IC to release the idle signal
EPD_5in83_V2_SendCommand(0X00); //PANNEL SETTING
EPD_5in83_V2_SendData(0x1F); //KW-3f KWR-2F BWROTP 0f BWOTP 1f
EPD_5in83_V2_SendCommand(0x61); //tres
EPD_5in83_V2_SendData (0x02); //source 648
EPD_5in83_V2_SendData (0x88);
EPD_5in83_V2_SendData (0x01); //gate 480
EPD_5in83_V2_SendData (0xE0);
EPD_5in83_V2_SendCommand(0X15);
EPD_5in83_V2_SendData(0x00);
EPD_5in83_V2_SendCommand(0X50); //VCOM AND DATA INTERVAL SETTING
EPD_5in83_V2_SendData(0x10);
EPD_5in83_V2_SendData(0x07);
EPD_5in83_V2_SendCommand(0X60); //TCON SETTING
EPD_5in83_V2_SendData(0x22);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_5in83_V2_Clear(void)
{
UWORD Width, Height, i;
Width = (EPD_5in83_V2_WIDTH % 8 == 0)? (EPD_5in83_V2_WIDTH / 8 ): (EPD_5in83_V2_WIDTH / 8 + 1);
Height = EPD_5in83_V2_HEIGHT;
EPD_5in83_V2_SendCommand(0x10);
for(i=0; i<Width*Height; i++) {
EPD_5in83_V2_SendData(0x00);
}
EPD_5in83_V2_SendCommand(0x13);
for(i=0; i<Width*Height; i++) {
EPD_5in83_V2_SendData(0x00);
}
EPD_5in83_V2_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_5in83_V2_Display(UBYTE *Image)
{
UWORD Width, Height, i, j;
Width = (EPD_5in83_V2_WIDTH % 8 == 0)? (EPD_5in83_V2_WIDTH / 8 ): (EPD_5in83_V2_WIDTH / 8 + 1);
Height = EPD_5in83_V2_HEIGHT;
EPD_5in83_V2_SendCommand(0x10);
for(i=0;i<Height;i++) {
for(j=0; j<Width; j++) {
EPD_5in83_V2_SendData(0x00);
}
}
EPD_5in83_V2_SendCommand(0x13);
for(i=0;i<Height;i++) {
for(j=0; j<Width; j++) {
EPD_5in83_V2_SendData(~Image[i*Width + j]);
}
}
EPD_5in83_V2_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_5in83_V2_Sleep(void)
{
EPD_5in83_V2_SendCommand(0X02); //power off
EPD_5in83_V2_ReadBusy(); //waiting for the electronic paper IC to release the idle signal
EPD_5in83_V2_SendCommand(0X07); //deep sleep
EPD_5in83_V2_SendData(0xA5);
}

44
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_5in83_V2.h Normal file
View file

@ -0,0 +1,44 @@
/*****************************************************************************
* | File : EPD_5in83_V2.h
* | Author : Waveshare team
* | Function : 5.83inch e-paper V2
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-11-23
* | 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_5in83_V2_H_
#define __EPD_5in83_V2_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_5in83_V2_WIDTH 648
#define EPD_5in83_V2_HEIGHT 480
void EPD_5in83_V2_Init(void);
void EPD_5in83_V2_Clear(void);
void EPD_5in83_V2_Display(UBYTE *Image);
void EPD_5in83_V2_Sleep(void);
#endif

204
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_5in83b_V2.c Normal file
View file

@ -0,0 +1,204 @@
/*****************************************************************************
* | File : EPD_5in83b_V2.c
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-07-04
* | 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_5in83b_V2.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_5IN83B_V2_Reset(void)
{
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(200);
DEV_Digital_Write(EPD_RST_PIN, 0);
DEV_Delay_ms(1);
DEV_Digital_Write(EPD_RST_PIN, 1);
DEV_Delay_ms(200);
}
/******************************************************************************
function : send command
parameter:
Reg : Command register
******************************************************************************/
static void EPD_5IN83B_V2_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_5IN83B_V2_SendData(UBYTE Data)
{
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_Digital_Write(EPD_DC_PIN, 1);
DEV_SPI_WriteByte(Data);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : Wait until the busy_pin goes LOW
parameter:
******************************************************************************/
void EPD_5IN83B_V2_WaitUntilIdle(void)
{
Debug("e-Paper busy\r\n");
UBYTE busy;
do
{
EPD_5IN83B_V2_SendCommand(0x71);
busy = DEV_Digital_Read(EPD_BUSY_PIN);
busy =!(busy & 0x01);
}
while(busy);
DEV_Delay_ms(200);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_5IN83B_V2_TurnOnDisplay(void)
{
EPD_5IN83B_V2_SendCommand(0x12); //DISPLAY REFRESH
DEV_Delay_ms(100); //!!!The delay here is necessary, 200uS at least!!!
EPD_5IN83B_V2_WaitUntilIdle(); //waiting for the electronic paper IC to release the idle signal
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
UBYTE EPD_5IN83B_V2_Init(void)
{
EPD_5IN83B_V2_Reset();
EPD_5IN83B_V2_SendCommand(0x01); //POWER SETTING
EPD_5IN83B_V2_SendData (0x07);
EPD_5IN83B_V2_SendData (0x07); //VGH=20V,VGL=-20V
EPD_5IN83B_V2_SendData (0x3f); //VDH=15V
EPD_5IN83B_V2_SendData (0x3f); //VDL=-15V
EPD_5IN83B_V2_SendCommand(0x04); //POWER ON
DEV_Delay_ms(100);
EPD_5IN83B_V2_WaitUntilIdle(); //waiting for the electronic paper IC to release the idle signal
EPD_5IN83B_V2_SendCommand(0X00); //PANNEL SETTING
EPD_5IN83B_V2_SendData(0x0F); //KW-3f KWR-2F BWROTP 0f BWOTP 1f
EPD_5IN83B_V2_SendCommand(0x61); //tres
EPD_5IN83B_V2_SendData (0x02); //source 648
EPD_5IN83B_V2_SendData (0x88);
EPD_5IN83B_V2_SendData (0x01); //gate 480
EPD_5IN83B_V2_SendData (0xe0);
EPD_5IN83B_V2_SendCommand(0X15);
EPD_5IN83B_V2_SendData(0x00);
EPD_5IN83B_V2_SendCommand(0X50); //VCOM AND DATA INTERVAL SETTING
EPD_5IN83B_V2_SendData(0x11);
EPD_5IN83B_V2_SendData(0x07);
EPD_5IN83B_V2_SendCommand(0X60); //TCON SETTING
EPD_5IN83B_V2_SendData(0x22);
return 0;
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_5IN83B_V2_Clear(void)
{
UWORD Width, Height;
Width =(EPD_5IN83B_V2_WIDTH % 8 == 0)?(EPD_5IN83B_V2_WIDTH / 8 ):(EPD_5IN83B_V2_WIDTH / 8 + 1);
Height = EPD_5IN83B_V2_HEIGHT;
UWORD i;
EPD_5IN83B_V2_SendCommand(0x10);
for(i=0; i<Width*Height; i++) {
EPD_5IN83B_V2_SendData(0xff);
}
EPD_5IN83B_V2_SendCommand(0x13);
for(i=0; i<Width*Height; i++) {
EPD_5IN83B_V2_SendData(0x00);
}
EPD_5IN83B_V2_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_5IN83B_V2_Display(const UBYTE *blackimage, const UBYTE *ryimage)
{
UDOUBLE Width, Height;
Width =(EPD_5IN83B_V2_WIDTH % 8 == 0)?(EPD_5IN83B_V2_WIDTH / 8 ):(EPD_5IN83B_V2_WIDTH / 8 + 1);
Height = EPD_5IN83B_V2_HEIGHT;
//send black data
EPD_5IN83B_V2_SendCommand(0x10);
for (UDOUBLE j = 0; j < Height; j++) {
for (UDOUBLE i = 0; i < Width; i++) {
EPD_5IN83B_V2_SendData(blackimage[i + j * Width]);
}
}
//send red data
EPD_5IN83B_V2_SendCommand(0x13);
for (UDOUBLE j = 0; j < Height; j++) {
for (UDOUBLE i = 0; i < Width; i++) {
EPD_5IN83B_V2_SendData(~ryimage[i + j * Width]);
}
}
EPD_5IN83B_V2_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_5IN83B_V2_Sleep(void)
{
EPD_5IN83B_V2_SendCommand(0X02); //power off
EPD_5IN83B_V2_WaitUntilIdle(); //waiting for the electronic paper IC to release the idle signal
EPD_5IN83B_V2_SendCommand(0X07); //deep sleep
EPD_5IN83B_V2_SendData(0xA5);
}

46
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_5in83b_V2.h Normal file
View file

@ -0,0 +1,46 @@
/*****************************************************************************
* | File : EPD_5in83b_V2.h
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-07-04
* | 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_5IN83B_V2_h_
#define _EPD_5IN83B_V2_h_
#include "DEV_Config.h"
// Display resolution
#define EPD_5IN83B_V2_WIDTH 648
#define EPD_5IN83B_V2_HEIGHT 480
UBYTE EPD_5IN83B_V2_Init(void);
void EPD_5IN83B_V2_Clear(void);
void EPD_5IN83B_V2_Display(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_5IN83B_V2_Sleep(void);
#endif

337
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_5in83bc.c Normal file
View file

@ -0,0 +1,337 @@
/*****************************************************************************
* | File : EPD_5IN83BC.c
* | Author : Waveshare team
* | Function : 5.83inch e-paper b&c
* | Info :
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_5IN83BC_Reset()
* EPD_SendCommand() => EPD_5IN83BC_SendCommand()
* EPD_SendData() => EPD_5IN83BC_SendData()
* EPD_WaitUntilIdle() => EPD_5IN83BC_ReadBusy()
* EPD_Init() => EPD_5IN83BC_Init()
* EPD_Clear() => EPD_5IN83BC_Clear()
* EPD_Display() => EPD_5IN83BC_Display()
* EPD_Sleep() => EPD_5IN83BC_Sleep()
* 2.Remove:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define IMAGE_PROCESS 0x13
* #define LUT_FOR_VCOM 0x20
* #define LUT_BLUE 0x21
* #define LUT_WHITE 0x22
* #define LUT_GRAY_1 0x23
* #define LUT_GRAY_2 0x24
* #define LUT_RED_0 0x25
* #define LUT_RED_1 0x26
* #define LUT_RED_2 0x27
* #define LUT_RED_3 0x28
* #define LUT_XON 0x29
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SPI_FLASH_CONTROL 0x65
* #define REVISION 0x70
* #define GET_STATUS 0x71
* #define AUTO_MEASUREMENT_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* 3.add:
* EPD_5IN83BC_DisplayHalfScreen()
* -----------------------------------------------------------------------------
* V2.0(2018-11-09):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_5in83bc.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_5IN83BC_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
******************************************************************************/
static void EPD_5IN83BC_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_5IN83BC_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:
******************************************************************************/
void EPD_5IN83BC_ReadBusy(void)
{
UBYTE busy;
Debug("e-Paper busy\r\n");
do {
EPD_5IN83BC_SendCommand(0x71);
busy = DEV_Digital_Read(EPD_BUSY_PIN);
busy =!(busy & 0x01);
} while(busy);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_5IN83BC_TurnOnDisplay(void)
{
EPD_5IN83BC_SendCommand(0x04); // POWER ON
EPD_5IN83BC_ReadBusy();
EPD_5IN83BC_SendCommand(0x12); // display refresh
DEV_Delay_ms(100);
EPD_5IN83BC_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_5IN83BC_Init(void)
{
EPD_5IN83BC_Reset();
EPD_5IN83BC_SendCommand(0x01); // POWER_SETTING
EPD_5IN83BC_SendData(0x37);
EPD_5IN83BC_SendData(0x00);
EPD_5IN83BC_SendCommand(0x00); // PANEL_SETTING
EPD_5IN83BC_SendData(0xCF);
EPD_5IN83BC_SendData(0x08);
EPD_5IN83BC_SendCommand(0x30); // PLL_CONTROL
EPD_5IN83BC_SendData(0x3A); //PLL: 0-15:0x3C, 15+:0x3A
EPD_5IN83BC_SendCommand(0x82); // VCM_DC_SETTING
EPD_5IN83BC_SendData(0x28); //all temperature range
EPD_5IN83BC_SendCommand(0x06); // BOOSTER_SOFT_START
EPD_5IN83BC_SendData (0xc7);
EPD_5IN83BC_SendData (0xcc);
EPD_5IN83BC_SendData (0x15);
EPD_5IN83BC_SendCommand(0x50); // VCOM AND DATA INTERVAL SETTING
EPD_5IN83BC_SendData(0x77);
EPD_5IN83BC_SendCommand(0x60); // TCON_SETTING
EPD_5IN83BC_SendData(0x22);
EPD_5IN83BC_SendCommand(0x65); // FLASH CONTROL
EPD_5IN83BC_SendData(0x00);
EPD_5IN83BC_SendCommand(0x61); // TCON_RESOLUTION
EPD_5IN83BC_SendData (0x02); // source 600
EPD_5IN83BC_SendData (0x58);
EPD_5IN83BC_SendData (0x01); // gate 448
EPD_5IN83BC_SendData (0xc0);
EPD_5IN83BC_SendCommand(0xe5); // FLASH MODE
EPD_5IN83BC_SendData(0x03);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_5IN83BC_Clear(void)
{
UWORD Width, Height;
Width = (EPD_5IN83BC_WIDTH % 8 == 0)? (EPD_5IN83BC_WIDTH / 8): (EPD_5IN83BC_WIDTH / 8 + 1);
Height = EPD_5IN83BC_HEIGHT;
EPD_5IN83BC_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
for(UBYTE k = 0; k < 4; k++) {
EPD_5IN83BC_SendData(0x33);
}
}
}
EPD_5IN83BC_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_5IN83BC_Display(const UBYTE *blackimage, const UBYTE *ryimage)
{
UBYTE Data_Black, Data_RY, Data;
UDOUBLE i, j, Width, Height;
Width = (EPD_5IN83BC_WIDTH % 8 == 0)? (EPD_5IN83BC_WIDTH / 8 ): (EPD_5IN83BC_WIDTH / 8 + 1);
Height = EPD_5IN83BC_HEIGHT;
EPD_5IN83BC_SendCommand(0x10);
for (j = 0; j < Height; j++) {
for (i = 0; i < Width; i++) {
Data_Black = blackimage[i + j * Width];
Data_RY = ryimage[i + j * Width]; // red or yellow
for(UBYTE k = 0; k < 8; k++) {
if ((Data_RY & 0x80) == 0x00) {
Data = 0x04; //red
} else if ((Data_Black & 0x80) == 0x00) {
Data = 0x00; //black
} else {
Data = 0x03; //white
}
Data = (Data << 4) & 0xFF;
Data_Black = (Data_Black << 1) & 0xFF;
Data_RY = (Data_RY << 1) & 0xFF;
k += 1;
if((Data_RY & 0x80) == 0x00) {
Data |= 0x04; //red
} else if ((Data_Black & 0x80) == 0x00) {
Data |= 0x00; //black
} else {
Data |= 0x03; //white
}
Data_Black = (Data_Black << 1) & 0xFF;
Data_RY = (Data_RY << 1) & 0xFF;
EPD_5IN83BC_SendData(Data);
}
}
}
EPD_5IN83BC_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_5IN83BC_DisplayHalfScreen(const UBYTE *blackimage, const UBYTE *ryimage)
{
UBYTE Data_Black, Data_RY, Data;
UDOUBLE i, j, Width, Height;
Width = (EPD_5IN83BC_WIDTH % 8 == 0)? (EPD_5IN83BC_WIDTH / 8 ): (EPD_5IN83BC_WIDTH / 8 + 1);
Height = EPD_5IN83BC_HEIGHT;
EPD_5IN83BC_SendCommand(0x10);
for (j = 0; j < Height / 2; j++) {
for (i = 0; i < Width; i++) {
Data_Black = blackimage[i + j * Width];
Data_RY = ryimage[i + j * Width]; // red or yellow
for(UBYTE k = 0; k < 8; k++) {
if ((Data_RY & 0x80) == 0x00) {
Data = 0x04; //red
} else if ((Data_Black & 0x80) == 0x00) {
Data = 0x00; //black
} else {
Data = 0x03; //white
}
Data = (Data << 4) & 0xFF;
Data_Black = (Data_Black << 1) & 0xFF;
Data_RY = (Data_RY << 1) & 0xFF;
k += 1;
if((Data_RY & 0x80) == 0x00) {
Data |= 0x04; //red
} else if ((Data_Black & 0x80) == 0x00) {
Data |= 0x00; //black
} else {
Data |= 0x03; //white
}
Data_Black = (Data_Black << 1) & 0xFF;
Data_RY = (Data_RY << 1) & 0xFF;
EPD_5IN83BC_SendData(Data);
}
}
}
for (j = 0; j < Height / 2; j++) {
for (i = 0; i < Width; i++) {
for(UBYTE k = 0; k < 4; k++) {
EPD_5IN83BC_SendData(0x33);
}
}
}
EPD_5IN83BC_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_5IN83BC_Sleep(void)
{
EPD_5IN83BC_SendCommand(0x02); // POWER_OFF
EPD_5IN83BC_ReadBusy();
EPD_5IN83BC_SendCommand(0x07); // DEEP_SLEEP
EPD_5IN83BC_SendData(0XA5);
}

100
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_5in83bc.h Normal file
View file

@ -0,0 +1,100 @@
/*****************************************************************************
* | File : EPD_5IN83BC.h
* | Author : Waveshare team
* | Function : 5.83inch e-paper b&c
* | Info :
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_5IN83BC_Reset()
* EPD_SendCommand() => EPD_5IN83BC_SendCommand()
* EPD_SendData() => EPD_5IN83BC_SendData()
* EPD_WaitUntilIdle() => EPD_5IN83BC_ReadBusy()
* EPD_Init() => EPD_5IN83BC_Init()
* EPD_Clear() => EPD_5IN83BC_Clear()
* EPD_Display() => EPD_5IN83BC_Display()
* EPD_Sleep() => EPD_5IN83BC_Sleep()
* 2.Remove:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define IMAGE_PROCESS 0x13
* #define LUT_FOR_VCOM 0x20
* #define LUT_BLUE 0x21
* #define LUT_WHITE 0x22
* #define LUT_GRAY_1 0x23
* #define LUT_GRAY_2 0x24
* #define LUT_RED_0 0x25
* #define LUT_RED_1 0x26
* #define LUT_RED_2 0x27
* #define LUT_RED_3 0x28
* #define LUT_XON 0x29
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SPI_FLASH_CONTROL 0x65
* #define REVISION 0x70
* #define GET_STATUS 0x71
* #define AUTO_MEASUREMENT_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* 3.add:
* EPD_5IN83BC_DisplayHalfScreen()
* -----------------------------------------------------------------------------
* V2.0(2018-11-09):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_5IN83BC_H_
#define __EPD_5IN83BC_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_5IN83BC_WIDTH 600
#define EPD_5IN83BC_HEIGHT 448
void EPD_5IN83BC_Init(void);
void EPD_5IN83BC_Clear(void);
void EPD_5IN83BC_Display(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_5IN83BC_DisplayHalfScreen(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_5IN83BC_Sleep(void);
#endif

271
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5.c Normal file
View file

@ -0,0 +1,271 @@
/*****************************************************************************
* | File : EPD_7IN5.c
* | Author : Waveshare team
* | Function : 7.5inch e-paper
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_7IN5_Reset()
* EPD_SendCommand() => EPD_7IN5_SendCommand()
* EPD_SendData() => EPD_7IN5_SendData()
* EPD_WaitUntilIdle() => EPD_7IN5_ReadBusy()
* EPD_SetFullReg() => EPD_7IN5_SetFullReg()
* EPD_SetPartReg() => EPD_7IN5_SetPartReg()
* EPD_TurnOnDisplay() => EPD_7IN5_TurnOnDisplay()
* EPD_Init() => EPD_7IN5_Init()
* EPD_Clear() => EPD_7IN5_Clear()
* EPD_Display() => EPD_7IN5_Display()
* EPD_Sleep() => EPD_7IN5_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define VCOM_LUT 0x20
* #define W2W_LUT 0x21
* #define B2W_LUT 0x22
* #define W2B_LUT 0x23
* #define B2B_LUT 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_CALIBRATION 0x40
* #define TEMPERATURE_SENSOR_SELECTION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define RESOLUTION_SETTING 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* -----------------------------------------------------------------------------
* V2.0(2018-11-09):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_7in5.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_7IN5_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
******************************************************************************/
static void EPD_7IN5_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_7IN5_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:
******************************************************************************/
void EPD_7IN5_ReadBusy(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN) == 0) { //LOW: idle, HIGH: busy
DEV_Delay_ms(100);
}
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_7IN5_TurnOnDisplay(void)
{
EPD_7IN5_SendCommand(0x12); // DISPLAY_REFRESH
DEV_Delay_ms(100);
EPD_7IN5_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_7IN5_Init(void)
{
EPD_7IN5_Reset();
EPD_7IN5_SendCommand(0x01); // POWER_SETTING
EPD_7IN5_SendData(0x37);
EPD_7IN5_SendData(0x00);
EPD_7IN5_SendCommand(0x00); // PANEL_SETTING
EPD_7IN5_SendData(0xCF);
EPD_7IN5_SendData(0x08);
EPD_7IN5_SendCommand(0x06); // BOOSTER_SOFT_START
EPD_7IN5_SendData(0xc7);
EPD_7IN5_SendData(0xcc);
EPD_7IN5_SendData(0x28);
EPD_7IN5_SendCommand(0x04); // POWER_ON
EPD_7IN5_ReadBusy();
EPD_7IN5_SendCommand(0x30); // PLL_CONTROL
EPD_7IN5_SendData(0x3c);
EPD_7IN5_SendCommand(0x41); // TEMPERATURE_CALIBRATION
EPD_7IN5_SendData(0x00);
EPD_7IN5_SendCommand(0x50); // VCOM_AND_DATA_INTERVAL_SETTING
EPD_7IN5_SendData(0x77);
EPD_7IN5_SendCommand(0x60); // TCON_SETTING
EPD_7IN5_SendData(0x22);
EPD_7IN5_SendCommand(0x61); // TCON_RESOLUTION
EPD_7IN5_SendData(EPD_7IN5_WIDTH >> 8); // source 640
EPD_7IN5_SendData(EPD_7IN5_WIDTH & 0xff);
EPD_7IN5_SendData(EPD_7IN5_HEIGHT >> 8); // gate 384
EPD_7IN5_SendData(EPD_7IN5_HEIGHT & 0xff);
EPD_7IN5_SendCommand(0x82); // VCM_DC_SETTING
EPD_7IN5_SendData(0x1E); // decide by LUT file
EPD_7IN5_SendCommand(0xe5); // FLASH MODE
EPD_7IN5_SendData(0x03);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_7IN5_Clear(void)
{
UWORD Width, Height;
Width = (EPD_7IN5_WIDTH % 8 == 0)? (EPD_7IN5_WIDTH / 8 ): (EPD_7IN5_WIDTH / 8 + 1);
Height = EPD_7IN5_HEIGHT;
EPD_7IN5_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
for(UBYTE k = 0; k < 4; k++) {
EPD_7IN5_SendData(0x33);
}
}
}
EPD_7IN5_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_7IN5_Display(UBYTE *Image)
{
UBYTE Data_Black, Data;
UWORD Width, Height;
Width = (EPD_7IN5_WIDTH % 8 == 0)? (EPD_7IN5_WIDTH / 8 ): (EPD_7IN5_WIDTH / 8 + 1);
Height = EPD_7IN5_HEIGHT;
EPD_7IN5_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
Data_Black = ~Image[i + j * Width];
for(UBYTE k = 0; k < 8; k++) {
if(Data_Black & 0x80)
Data = 0x00;
else
Data = 0x03;
Data <<= 4;
Data_Black <<= 1;
k++;
if(Data_Black & 0x80)
Data |= 0x00;
else
Data |= 0x03;
Data_Black <<= 1;
EPD_7IN5_SendData(Data);
}
}
}
EPD_7IN5_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_7IN5_Sleep(void)
{
EPD_7IN5_SendCommand(0x02); // POWER_OFF
EPD_7IN5_ReadBusy();
EPD_7IN5_SendCommand(0x07); // DEEP_SLEEP
EPD_7IN5_SendData(0XA5);;
}

101
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5.h Normal file
View file

@ -0,0 +1,101 @@
/*****************************************************************************
* | File : EPD_7IN5.h
* | Author : Waveshare team
* | Function : 7.5inch e-paper
* | Info :
*----------------
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_7IN5_Reset()
* EPD_SendCommand() => EPD_7IN5_SendCommand()
* EPD_SendData() => EPD_7IN5_SendData()
* EPD_WaitUntilIdle() => EPD_7IN5_ReadBusy()
* EPD_SetFullReg() => EPD_7IN5_SetFullReg()
* EPD_SetPartReg() => EPD_7IN5_SetPartReg()
* EPD_TurnOnDisplay() => EPD_7IN5_TurnOnDisplay()
* EPD_Init() => EPD_7IN5_Init()
* EPD_Clear() => EPD_7IN5_Clear()
* EPD_Display() => EPD_7IN5_Display()
* EPD_Sleep() => EPD_7IN5_Sleep()
* 2.remove commands define:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define DATA_START_TRANSMISSION_2 0x13
* #define VCOM_LUT 0x20
* #define W2W_LUT 0x21
* #define B2W_LUT 0x22
* #define W2B_LUT 0x23
* #define B2B_LUT 0x24
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_CALIBRATION 0x40
* #define TEMPERATURE_SENSOR_SELECTION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define RESOLUTION_SETTING 0x61
* #define GET_STATUS 0x71
* #define AUTO_MEASURE_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* #define PARTIAL_WINDOW 0x90
* #define PARTIAL_IN 0x91
* #define PARTIAL_OUT 0x92
* #define PROGRAM_MODE 0xA0
* #define ACTIVE_PROGRAM 0xA1
* #define READ_OTP_DATA 0xA2
* #define POWER_SAVING 0xE3
* -----------------------------------------------------------------------------
* V2.0(2018-11-09):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_7IN5_H_
#define __EPD_7IN5_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_7IN5_WIDTH 640
#define EPD_7IN5_HEIGHT 384
void EPD_7IN5_Init(void);
void EPD_7IN5_Clear(void);
void EPD_7IN5_Display(UBYTE *Image);
void EPD_7IN5_Sleep(void);
#endif

233
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5_HD.c Normal file
View file

@ -0,0 +1,233 @@
/*****************************************************************************
* | File : EPD_7in5_HD.c
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-04-25
* | 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_7in5_HD.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_7IN5_HD_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
******************************************************************************/
static void EPD_7IN5_HD_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_7IN5_HD_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_7IN5_HD_WaitUntilIdle(void)
{
Debug("e-Paper busy\r\n");
do{
DEV_Delay_ms(10);
}while(DEV_Digital_Read(EPD_BUSY_PIN) == 1);
DEV_Delay_ms(200);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_7IN5_HD_Init(void)
{
EPD_7IN5_HD_Reset();
EPD_7IN5_HD_WaitUntilIdle();
EPD_7IN5_HD_SendCommand(0x12); //SWRESET
EPD_7IN5_HD_WaitUntilIdle();
EPD_7IN5_HD_SendCommand(0x46); // Auto Write Red RAM
EPD_7IN5_HD_SendData(0xf7);
EPD_7IN5_HD_WaitUntilIdle();
EPD_7IN5_HD_SendCommand(0x47); // Auto Write B/W RAM
EPD_7IN5_HD_SendData(0xf7);
EPD_7IN5_HD_WaitUntilIdle();
EPD_7IN5_HD_SendCommand(0x0C); // Soft start setting
EPD_7IN5_HD_SendData(0xAE);
EPD_7IN5_HD_SendData(0xC7);
EPD_7IN5_HD_SendData(0xC3);
EPD_7IN5_HD_SendData(0xC0);
EPD_7IN5_HD_SendData(0x40);
EPD_7IN5_HD_SendCommand(0x01); // Set MUX as 527
EPD_7IN5_HD_SendData(0xAF);
EPD_7IN5_HD_SendData(0x02);
EPD_7IN5_HD_SendData(0x01);//0x01
EPD_7IN5_HD_SendCommand(0x11); // Data entry mode
EPD_7IN5_HD_SendData(0x01);
EPD_7IN5_HD_SendCommand(0x44);
EPD_7IN5_HD_SendData(0x00); // RAM x address start at 0
EPD_7IN5_HD_SendData(0x00);
EPD_7IN5_HD_SendData(0x6F);
EPD_7IN5_HD_SendData(0x03);
EPD_7IN5_HD_SendCommand(0x45);
EPD_7IN5_HD_SendData(0xFF);
EPD_7IN5_HD_SendData(0x03);
EPD_7IN5_HD_SendData(0x00);
EPD_7IN5_HD_SendData(0x00);
EPD_7IN5_HD_SendCommand(0x3C); // VBD
EPD_7IN5_HD_SendData(0x05); // LUT1, for white
EPD_7IN5_HD_SendCommand(0x18);
EPD_7IN5_HD_SendData(0X80);
EPD_7IN5_HD_SendCommand(0x22);
EPD_7IN5_HD_SendData(0XB1); //Load Temperature and waveform setting.
EPD_7IN5_HD_SendCommand(0x20);
EPD_7IN5_HD_WaitUntilIdle();
EPD_7IN5_HD_SendCommand(0x4E); // set RAM x address count to 0;
EPD_7IN5_HD_SendData(0x00);
EPD_7IN5_HD_SendData(0x00);
EPD_7IN5_HD_SendCommand(0x4F);
EPD_7IN5_HD_SendData(0x00);
EPD_7IN5_HD_SendData(0x00);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_7IN5_HD_Clear(void)
{
UDOUBLE Width, Height;
Width =(EPD_7IN5_HD_WIDTH % 8 == 0)?(EPD_7IN5_HD_WIDTH / 8 ):(EPD_7IN5_HD_WIDTH / 8 + 1);
Height = EPD_7IN5_HD_HEIGHT;
EPD_7IN5_HD_SendCommand(0x4F);
EPD_7IN5_HD_SendData(0x00);
EPD_7IN5_HD_SendData(0x00);
EPD_7IN5_HD_SendCommand(0x24);
UDOUBLE i;
for(i=0; i<58080; i++) {
EPD_7IN5_HD_SendData(0xff);
}
EPD_7IN5_HD_SendCommand(0x26);
for(i=0; i<Height*Width; i++){
EPD_7IN5_HD_SendData(0xff);
}
EPD_7IN5_HD_SendCommand(0x22);
EPD_7IN5_HD_SendData(0xF7);//Load LUT from MCU(0x32)
EPD_7IN5_HD_SendCommand(0x20);
DEV_Delay_ms(10);
EPD_7IN5_HD_WaitUntilIdle();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_7IN5_HD_Display(const UBYTE *blackimage)
{
UDOUBLE Width, Height;
Width =(EPD_7IN5_HD_WIDTH % 8 == 0)?(EPD_7IN5_HD_WIDTH / 8 ):(EPD_7IN5_HD_WIDTH / 8 + 1);
Height = EPD_7IN5_HD_HEIGHT;
EPD_7IN5_HD_SendCommand(0x4F);
EPD_7IN5_HD_SendData(0x00);
EPD_7IN5_HD_SendData(0x00);
EPD_7IN5_HD_SendCommand(0x24);
UDOUBLE i;
for (UDOUBLE j = 0; j < Height; j++) {
for (UDOUBLE i = 0; i < Width; i++) {
EPD_7IN5_HD_SendData(blackimage[i + j * Width]);
}
}
EPD_7IN5_HD_SendCommand(0x26);
for(i=0; i<Height*Width; i++) {
EPD_7IN5_HD_SendData(0xff);
}
EPD_7IN5_HD_SendCommand(0x22);
EPD_7IN5_HD_SendData(0xF7);//Load LUT from MCU(0x32)
EPD_7IN5_HD_SendCommand(0x20);
DEV_Delay_ms(10);
EPD_7IN5_HD_WaitUntilIdle();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_7IN5_HD_Sleep(void)
{
EPD_7IN5_HD_SendCommand(0x10);
EPD_7IN5_HD_SendData(0x01);
}

47
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5_HD.h Normal file
View file

@ -0,0 +1,47 @@
/*****************************************************************************
* | File : EPD_7in5_HD.h
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-04-25
* | 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_7IN5_HD_H_
#define _EPD_7IN5_HD_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_7IN5_HD_WIDTH 880
#define EPD_7IN5_HD_HEIGHT 528
void EPD_7IN5_HD_Init(void);
void EPD_7IN5_HD_Clear(void);
void EPD_7IN5_HD_ClearBlack(void);
void EPD_7IN5_HD_Display(const UBYTE *blackimage);
void EPD_7IN5_HD_Sleep(void);
#endif

229
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5_V2.c Normal file
View file

@ -0,0 +1,229 @@
/*****************************************************************************
* | File : EPD_7in5.c
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V2.0
* | Date : 2018-11-09
* | 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_7in5_V2.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_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
******************************************************************************/
static void EPD_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_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_WaitUntilIdle(void)
{
Debug("e-Paper busy\r\n");
do{
EPD_SendCommand(0x71);
DEV_Delay_ms(20);
}while(!(DEV_Digital_Read(EPD_BUSY_PIN)));
DEV_Delay_ms(100);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_7IN5_V2_TurnOnDisplay(void)
{
EPD_SendCommand(0x12); //DISPLAY REFRESH
DEV_Delay_ms(100); //!!!The delay here is necessary, 200uS at least!!!
EPD_WaitUntilIdle();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
UBYTE EPD_7IN5_V2_Init(void)
{
EPD_Reset();
EPD_SendCommand(0x01); //POWER SETTING
EPD_SendData(0x07);
EPD_SendData(0x07); //VGH=20V,VGL=-20V
EPD_SendData(0x3f); //VDH=15V
EPD_SendData(0x3f); //VDL=-15V
EPD_SendCommand(0x04); //POWER ON
DEV_Delay_ms(100);
EPD_WaitUntilIdle();
EPD_SendCommand(0X00); //PANNEL SETTING
EPD_SendData(0x1F); //KW-3f KWR-2F BWROTP 0f BWOTP 1f
EPD_SendCommand(0x61); //tres
EPD_SendData(0x03); //source 800
EPD_SendData(0x20);
EPD_SendData(0x01); //gate 480
EPD_SendData(0xE0);
// EPD_SendCommand(0x06);
// EPD_SendData(0xff);
// EPD_SendData(0xff);
// EPD_SendData(0xff);
// EPD_SendData(0xff);
EPD_SendCommand(0X15);
EPD_SendData(0x00);
EPD_SendCommand(0X50); //VCOM AND DATA INTERVAL SETTING
EPD_SendData(0x10);
EPD_SendData(0x00);
EPD_SendCommand(0X60); //TCON SETTING
EPD_SendData(0x22);
EPD_SendCommand(0x65); // Resolution setting
EPD_SendData(0x00);
EPD_SendData(0x00);//800*480
EPD_SendData(0x00);
EPD_SendData(0x00);
return 0;
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_7IN5_V2_Clear(void)
{
UWORD Width, Height;
Width =(EPD_7IN5_V2_WIDTH % 8 == 0)?(EPD_7IN5_V2_WIDTH / 8 ):(EPD_7IN5_V2_WIDTH / 8 + 1);
Height = EPD_7IN5_V2_HEIGHT;
UWORD i;
EPD_SendCommand(0x10);
for(i=0; i<Height*Width; i++) {
EPD_SendData(0xFF);
}
EPD_SendCommand(0x13);
for(i=0; i<Height*Width; i++) {
EPD_SendData(0x00);
}
EPD_7IN5_V2_TurnOnDisplay();
}
void EPD_7IN5_V2_ClearBlack(void)
{
UWORD Width, Height;
Width =(EPD_7IN5_V2_WIDTH % 8 == 0)?(EPD_7IN5_V2_WIDTH / 8 ):(EPD_7IN5_V2_WIDTH / 8 + 1);
Height = EPD_7IN5_V2_HEIGHT;
UWORD i;
EPD_SendCommand(0x10);
for(i=0; i<Height*Width; i++) {
EPD_SendData(0x00);
}
EPD_SendCommand(0x13);
for(i=0; i<Height*Width; i++) {
EPD_SendData(0xFF);
}
EPD_7IN5_V2_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_7IN5_V2_Display(const UBYTE *blackimage)
{
UDOUBLE Width, Height;
Width =(EPD_7IN5_V2_WIDTH % 8 == 0)?(EPD_7IN5_V2_WIDTH / 8 ):(EPD_7IN5_V2_WIDTH / 8 + 1);
Height = EPD_7IN5_V2_HEIGHT;
EPD_SendCommand(0x10);
for (UDOUBLE j = 0; j < Height; j++) {
for (UDOUBLE i = 0; i < Width; i++) {
EPD_SendData(blackimage[i + j * Width]);
}
}
EPD_SendCommand(0x13);
for (UDOUBLE j = 0; j < Height; j++) {
for (UDOUBLE i = 0; i < Width; i++) {
EPD_SendData(~blackimage[i + j * Width]);
}
}
EPD_7IN5_V2_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_7IN5_V2_Sleep(void)
{
EPD_SendCommand(0X02); //power off
EPD_WaitUntilIdle();
EPD_SendCommand(0X07); //deep sleep
EPD_SendData(0xA5);
}

49
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5_V2.h Normal file
View file

@ -0,0 +1,49 @@
/*****************************************************************************
* | File : EPD_7in5_V2.h
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V2.0
* | Date : 2018-11-09
* | Info :
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_7IN5_V2_H_
#define _EPD_7IN5_V2_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_7IN5_V2_WIDTH 800
#define EPD_7IN5_V2_HEIGHT 480
UBYTE EPD_7IN5_V2_Init(void);
void EPD_7IN5_V2_Clear(void);
void EPD_7IN5_V2_ClearBlack(void);
void EPD_7IN5_V2_Display(const UBYTE *blackimage);
void EPD_7IN5_V2_Sleep(void);
#endif

279
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5b_HD.c Normal file
View file

@ -0,0 +1,279 @@
/*****************************************************************************
* | File : EPD_7IN5B_HD.c
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-04-27
* | 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_7in5b_HD.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_7IN5B_HD_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
******************************************************************************/
static void EPD_7IN5B_HD_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_7IN5B_HD_SendData(UBYTE Data)
{
DEV_Digital_Write(EPD_CS_PIN, 0);
DEV_Digital_Write(EPD_DC_PIN, 1);
DEV_SPI_WriteByte(Data);
DEV_Digital_Write(EPD_CS_PIN, 1);
}
/******************************************************************************
function : Wait until the busy_pin goes LOW
parameter:
******************************************************************************/
void EPD_7IN5B_HD_WaitUntilIdle(void)
{
Debug("e-Paper busy\r\n");
while(DEV_Digital_Read(EPD_BUSY_PIN)){
DEV_Delay_ms(10);
}
DEV_Delay_ms(200);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_7IN5B_HD_TurnOnDisplay(void)
{
EPD_7IN5B_HD_SendCommand(0x22);
EPD_7IN5B_HD_SendData(0xC7); //Load LUT from MCU(0x32)
EPD_7IN5B_HD_SendCommand(0x20);
DEV_Delay_ms(200); //!!!The delay here is necessary, 200uS at least!!!
EPD_7IN5B_HD_WaitUntilIdle(); //waiting for the electronic paper IC to release the idle signal
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
UBYTE EPD_7IN5B_HD_Init(void)
{
EPD_7IN5B_HD_Reset();
EPD_7IN5B_HD_SendCommand(0x12); //SWRESET
EPD_7IN5B_HD_WaitUntilIdle(); //waiting for the electronic paper IC to release the idle signal
EPD_7IN5B_HD_SendCommand(0x46); // Auto Write RAM
EPD_7IN5B_HD_SendData(0xF7);
EPD_7IN5B_HD_WaitUntilIdle(); //waiting for the electronic paper IC to release the idle signal
EPD_7IN5B_HD_SendCommand(0x47); // Auto Write RAM
EPD_7IN5B_HD_SendData(0xF7);
EPD_7IN5B_HD_WaitUntilIdle(); //waiting for the electronic paper IC to release the idle signal
EPD_7IN5B_HD_SendCommand(0x0C); // Soft start setting
EPD_7IN5B_HD_SendData(0xAE);
EPD_7IN5B_HD_SendData(0xC7);
EPD_7IN5B_HD_SendData(0xC3);
EPD_7IN5B_HD_SendData(0xC0);
EPD_7IN5B_HD_SendData(0x40);
EPD_7IN5B_HD_SendCommand(0x01); // Set MUX as 527
EPD_7IN5B_HD_SendData(0xAF);
EPD_7IN5B_HD_SendData(0x02);
EPD_7IN5B_HD_SendData(0x01);
EPD_7IN5B_HD_SendCommand(0x11); // Data entry mode
EPD_7IN5B_HD_SendData(0x01);
EPD_7IN5B_HD_SendCommand(0x44);
EPD_7IN5B_HD_SendData(0x00); // RAM x address start at 0
EPD_7IN5B_HD_SendData(0x00);
EPD_7IN5B_HD_SendData(0x6F); // RAM x address end at 36Fh -> 879
EPD_7IN5B_HD_SendData(0x03);
EPD_7IN5B_HD_SendCommand(0x45);
EPD_7IN5B_HD_SendData(0xAF); // RAM y address start at 20Fh;
EPD_7IN5B_HD_SendData(0x02);
EPD_7IN5B_HD_SendData(0x00); // RAM y address end at 00h;
EPD_7IN5B_HD_SendData(0x00);
EPD_7IN5B_HD_SendCommand(0x3C); // VBD
EPD_7IN5B_HD_SendData(0x01); // LUT1, for white
EPD_7IN5B_HD_SendCommand(0x18);
EPD_7IN5B_HD_SendData(0X80);
EPD_7IN5B_HD_SendCommand(0x22);
EPD_7IN5B_HD_SendData(0XB1); //Load Temperature and waveform setting.
EPD_7IN5B_HD_SendCommand(0x20);
EPD_7IN5B_HD_WaitUntilIdle(); //waiting for the electronic paper IC to release the idle signal
EPD_7IN5B_HD_SendCommand(0x4E);
EPD_7IN5B_HD_SendData(0x00);
EPD_7IN5B_HD_SendData(0x00);
EPD_7IN5B_HD_SendCommand(0x4F);
EPD_7IN5B_HD_SendData(0xAF);
EPD_7IN5B_HD_SendData(0x02);
return 0;
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_7IN5B_HD_Clear(void)
{
UWORD Width, Height;
Width =(EPD_7IN5B_HD_WIDTH % 8 == 0)?(EPD_7IN5B_HD_WIDTH / 8 ):(EPD_7IN5B_HD_WIDTH / 8 + 1);
Height = EPD_7IN5B_HD_HEIGHT;
EPD_7IN5B_HD_SendCommand(0x4F);
EPD_7IN5B_HD_SendData(0xAf);
EPD_7IN5B_HD_SendData(0x02);
UWORD i;
EPD_7IN5B_HD_SendCommand(0x24);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_HD_SendData(0xff);
}
EPD_7IN5B_HD_SendCommand(0x26);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_HD_SendData(0x00);
}
EPD_7IN5B_HD_TurnOnDisplay();
}
void EPD_7IN5B_HD_ClearRed(void)
{
UWORD Width, Height;
Width =(EPD_7IN5B_HD_WIDTH % 8 == 0)?(EPD_7IN5B_HD_WIDTH / 8 ):(EPD_7IN5B_HD_WIDTH / 8 + 1);
Height = EPD_7IN5B_HD_HEIGHT;
UWORD i;
EPD_7IN5B_HD_SendCommand(0x4F);
EPD_7IN5B_HD_SendData(0xAF);
EPD_7IN5B_HD_SendData(0x02);
EPD_7IN5B_HD_SendCommand(0x24);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_HD_SendData(0xff);
}
EPD_7IN5B_HD_SendCommand(0x26);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_HD_SendData(0xff);
}
EPD_7IN5B_HD_TurnOnDisplay();
}
void EPD_7IN5B_HD_ClearBlack(void)
{
UWORD Width, Height;
Width =(EPD_7IN5B_HD_WIDTH % 8 == 0)?(EPD_7IN5B_HD_WIDTH / 8 ):(EPD_7IN5B_HD_WIDTH / 8 + 1);
Height = EPD_7IN5B_HD_HEIGHT;
UWORD i;
EPD_7IN5B_HD_SendCommand(0x4F);
EPD_7IN5B_HD_SendData(0xAF);
EPD_7IN5B_HD_SendData(0x02);
EPD_7IN5B_HD_SendCommand(0x24);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_HD_SendData(0x00);
}
EPD_7IN5B_HD_SendCommand(0x26);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_HD_SendData(0x00);
}
EPD_7IN5B_HD_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_7IN5B_HD_Display(const UBYTE *blackimage, const UBYTE *ryimage)
{
UDOUBLE Width, Height;
Width =(EPD_7IN5B_HD_WIDTH % 8 == 0)?(EPD_7IN5B_HD_WIDTH / 8 ):(EPD_7IN5B_HD_WIDTH / 8 + 1);
Height = EPD_7IN5B_HD_HEIGHT;
EPD_7IN5B_HD_SendCommand(0x4F);
EPD_7IN5B_HD_SendData(0xAF);
EPD_7IN5B_HD_SendData(0x02);
//send black data
EPD_7IN5B_HD_SendCommand(0x24);
for (UDOUBLE j = 0; j < Height; j++) {
for (UDOUBLE i = 0; i < Width; i++) {
EPD_7IN5B_HD_SendData(blackimage[i + j * Width]);
}
}
//send red data
EPD_7IN5B_HD_SendCommand(0x26);
for (UDOUBLE j = 0; j < Height; j++) {
for (UDOUBLE i = 0; i < Width; i++) {
EPD_7IN5B_HD_SendData(~ryimage[i + j * Width]);
}
}
EPD_7IN5B_HD_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_7IN5B_HD_Sleep(void)
{
EPD_7IN5B_HD_SendCommand(0x10); //deep sleep
EPD_7IN5B_HD_SendData(0x01);
}

48
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5b_HD.h Normal file
View file

@ -0,0 +1,48 @@
/*****************************************************************************
* | File : EPD_7in5b_HD.h
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-04-27
* | 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_7IN5B_HD_H_
#define _EPD_7IN5B_HD_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_7IN5B_HD_WIDTH 880
#define EPD_7IN5B_HD_HEIGHT 528
UBYTE EPD_7IN5B_HD_Init(void);
void EPD_7IN5B_HD_Clear(void);
void EPD_7IN5B_HD_ClearRed(void);
void EPD_7IN5B_HD_ClearBlack(void);
void EPD_7IN5B_HD_Display(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_7IN5B_HD_Sleep(void);
#endif

247
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5b_V2.c Normal file
View file

@ -0,0 +1,247 @@
/*****************************************************************************
* | File : EPD_7IN5B_V2.c
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V1.0
* | Date : 2020-11-30
* | 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_7in5b_V2.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_7IN5B_V2_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
******************************************************************************/
static void EPD_7IN5B_V2_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_7IN5B_V2_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:
******************************************************************************/
void EPD_7IN5B_V2_WaitUntilIdle(void)
{
Debug("e-Paper busy\r\n");
do {
DEV_Delay_ms(20);
}while(!(DEV_Digital_Read(EPD_BUSY_PIN)));
DEV_Delay_ms(20);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_7IN5B_V2_TurnOnDisplay(void)
{
EPD_7IN5B_V2_SendCommand(0x12); //DISPLAY REFRESH
DEV_Delay_ms(100); //!!!The delay here is necessary, 200uS at least!!!
EPD_7IN5B_V2_WaitUntilIdle();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
UBYTE EPD_7IN5B_V2_Init(void)
{
EPD_7IN5B_V2_Reset();
EPD_7IN5B_V2_SendCommand(0x01); //POWER SETTING
EPD_7IN5B_V2_SendData(0x07);
EPD_7IN5B_V2_SendData(0x07); //VGH=20V,VGL=-20V
EPD_7IN5B_V2_SendData(0x3f); //VDH=15V
EPD_7IN5B_V2_SendData(0x3f); //VDL=-15V
EPD_7IN5B_V2_SendCommand(0x04); //POWER ON
DEV_Delay_ms(100);
EPD_7IN5B_V2_WaitUntilIdle();
EPD_7IN5B_V2_SendCommand(0X00); //PANNEL SETTING
EPD_7IN5B_V2_SendData(0x0F); //KW-3f KWR-2F BWROTP 0f BWOTP 1f
EPD_7IN5B_V2_SendCommand(0x61); //tres
EPD_7IN5B_V2_SendData(0x03); //source 800
EPD_7IN5B_V2_SendData(0x20);
EPD_7IN5B_V2_SendData(0x01); //gate 480
EPD_7IN5B_V2_SendData(0xE0);
EPD_7IN5B_V2_SendCommand(0X15);
EPD_7IN5B_V2_SendData(0x00);
EPD_7IN5B_V2_SendCommand(0X50); //VCOM AND DATA INTERVAL SETTING
EPD_7IN5B_V2_SendData(0x11);
EPD_7IN5B_V2_SendData(0x07);
EPD_7IN5B_V2_SendCommand(0X60); //TCON SETTING
EPD_7IN5B_V2_SendData(0x22);
EPD_7IN5B_V2_SendCommand(0x65); // Resolution setting
EPD_7IN5B_V2_SendData(0x00);
EPD_7IN5B_V2_SendData(0x00);//800*480
EPD_7IN5B_V2_SendData(0x00);
EPD_7IN5B_V2_SendData(0x00);
return 0;
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_7IN5B_V2_Clear(void)
{
UWORD Width, Height;
Width =(EPD_7IN5B_V2_WIDTH % 8 == 0)?(EPD_7IN5B_V2_WIDTH / 8 ):(EPD_7IN5B_V2_WIDTH / 8 + 1);
Height = EPD_7IN5B_V2_HEIGHT;
UWORD i;
EPD_7IN5B_V2_SendCommand(0x10);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_V2_SendData(0xff);
}
EPD_7IN5B_V2_SendCommand(0x13);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_V2_SendData(0x00);
}
EPD_7IN5B_V2_TurnOnDisplay();
}
void EPD_7IN5B_V2_ClearRed(void)
{
UWORD Width, Height;
Width =(EPD_7IN5B_V2_WIDTH % 8 == 0)?(EPD_7IN5B_V2_WIDTH / 8 ):(EPD_7IN5B_V2_WIDTH / 8 + 1);
Height = EPD_7IN5B_V2_HEIGHT;
UWORD i;
EPD_7IN5B_V2_SendCommand(0x10);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_V2_SendData(0xff);
}
EPD_7IN5B_V2_SendCommand(0x13);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_V2_SendData(0xff);
}
EPD_7IN5B_V2_TurnOnDisplay();
}
void EPD_7IN5B_V2_ClearBlack(void)
{
UWORD Width, Height;
Width =(EPD_7IN5B_V2_WIDTH % 8 == 0)?(EPD_7IN5B_V2_WIDTH / 8 ):(EPD_7IN5B_V2_WIDTH / 8 + 1);
Height = EPD_7IN5B_V2_HEIGHT;
UWORD i;
EPD_7IN5B_V2_SendCommand(0x10);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_V2_SendData(0x00);
}
EPD_7IN5B_V2_SendCommand(0x13);
for(i=0; i<Width*Height; i++) {
EPD_7IN5B_V2_SendData(0x00);
}
EPD_7IN5B_V2_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_7IN5B_V2_Display(const UBYTE *blackimage, const UBYTE *ryimage)
{
UDOUBLE Width, Height;
Width =(EPD_7IN5B_V2_WIDTH % 8 == 0)?(EPD_7IN5B_V2_WIDTH / 8 ):(EPD_7IN5B_V2_WIDTH / 8 + 1);
Height = EPD_7IN5B_V2_HEIGHT;
//send black data
EPD_7IN5B_V2_SendCommand(0x10);
for (UDOUBLE j = 0; j < Height; j++) {
for (UDOUBLE i = 0; i < Width; i++) {
EPD_7IN5B_V2_SendData(blackimage[i + j * Width]);
}
}
//send red data
EPD_7IN5B_V2_SendCommand(0x13);
for (UDOUBLE j = 0; j < Height; j++) {
for (UDOUBLE i = 0; i < Width; i++) {
EPD_7IN5B_V2_SendData(~ryimage[i + j * Width]);
}
}
EPD_7IN5B_V2_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_7IN5B_V2_Sleep(void)
{
EPD_7IN5B_V2_SendCommand(0X02); //power off
EPD_7IN5B_V2_WaitUntilIdle();
EPD_7IN5B_V2_SendCommand(0X07); //deep sleep
EPD_7IN5B_V2_SendData(0xA5);
}

50
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5b_V2.h Normal file
View file

@ -0,0 +1,50 @@
/*****************************************************************************
* | File : EPD_7in5.h
* | Author : Waveshare team
* | Function : Electronic paper driver
* | Info :
*----------------
* | This version: V2.0
* | Date : 2018-11-09
* | Info :
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_7IN5B_V2_H_
#define _EPD_7IN5B_V2_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_7IN5B_V2_WIDTH 800
#define EPD_7IN5B_V2_HEIGHT 480
UBYTE EPD_7IN5B_V2_Init(void);
void EPD_7IN5B_V2_Clear(void);
void EPD_7IN5B_V2_ClearRed(void);
void EPD_7IN5B_V2_ClearBlack(void);
void EPD_7IN5B_V2_Display(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_7IN5B_V2_Sleep(void);
#endif

331
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5bc.c Normal file
View file

@ -0,0 +1,331 @@
/*****************************************************************************
* | File : EPD_7IN5BC.h
* | Author : Waveshare team
* | Function : 7.5inch e-paper b&c
* | Info :
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_7IN5BC_Reset()
* EPD_SendCommand() => EPD_7IN5BC_SendCommand()
* EPD_SendData() => EPD_7IN5BC_SendData()
* EPD_WaitUntilIdle() => EPD_7IN5BC_ReadBusy()
* EPD_Init() => EPD_7IN5BC_Init()
* EPD_Clear() => EPD_7IN5BC_Clear()
* EPD_Display() => EPD_7IN5BC_Display()
* EPD_Sleep() => EPD_7IN5BC_Sleep()
* 2.Remove:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define IMAGE_PROCESS 0x13
* #define LUT_FOR_VCOM 0x20
* #define LUT_BLUE 0x21
* #define LUT_WHITE 0x22
* #define LUT_GRAY_1 0x23
* #define LUT_GRAY_2 0x24
* #define LUT_RED_0 0x25
* #define LUT_RED_1 0x26
* #define LUT_RED_2 0x27
* #define LUT_RED_3 0x28
* #define LUT_XON 0x29
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SPI_FLASH_CONTROL 0x65
* #define REVISION 0x70
* #define GET_STATUS 0x71
* #define AUTO_MEASUREMENT_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* 3.add:
* EPD_7IN5BC_DisplayHalfScreen()
* -----------------------------------------------------------------------------
* V2.0(2018-11-09):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_7in5bc.h"
#include "Debug.h"
/******************************************************************************
function : Software reset
parameter:
******************************************************************************/
static void EPD_7IN5BC_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
******************************************************************************/
static void EPD_7IN5BC_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_7IN5BC_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:
******************************************************************************/
void EPD_7IN5BC_ReadBusy(void)
{
UBYTE busy;
Debug("e-Paper busy\r\n");
do {
EPD_7IN5BC_SendCommand(0x71);
busy = DEV_Digital_Read(EPD_BUSY_PIN);
busy =!(busy & 0x01);
} while(busy);
Debug("e-Paper busy release\r\n");
}
/******************************************************************************
function : Turn On Display
parameter:
******************************************************************************/
static void EPD_7IN5BC_TurnOnDisplay(void)
{
EPD_7IN5BC_SendCommand(0x04); // POWER ON
EPD_7IN5BC_ReadBusy();
EPD_7IN5BC_SendCommand(0x12); // display refresh
DEV_Delay_ms(100);
EPD_7IN5BC_ReadBusy();
}
/******************************************************************************
function : Initialize the e-Paper register
parameter:
******************************************************************************/
void EPD_7IN5BC_Init(void)
{
EPD_7IN5BC_Reset();
EPD_7IN5BC_SendCommand(0x01); // POWER_SETTING
EPD_7IN5BC_SendData(0x37);
EPD_7IN5BC_SendData(0x00);
EPD_7IN5BC_SendCommand(0x00); // PANEL_SETTING
EPD_7IN5BC_SendData(0xCF);
EPD_7IN5BC_SendData(0x08);
EPD_7IN5BC_SendCommand(0x30); // PLL_CONTROL
EPD_7IN5BC_SendData(0x3A); // PLL: 0-15:0x3C, 15+:0x3A
EPD_7IN5BC_SendCommand(0x82); // VCM_DC_SETTING
EPD_7IN5BC_SendData(0x28); //all temperature range
EPD_7IN5BC_SendCommand(0x06); // BOOSTER_SOFT_START
EPD_7IN5BC_SendData (0xc7);
EPD_7IN5BC_SendData (0xcc);
EPD_7IN5BC_SendData (0x15);
EPD_7IN5BC_SendCommand(0x50); // VCOM AND DATA INTERVAL SETTING
EPD_7IN5BC_SendData(0x77);
EPD_7IN5BC_SendCommand(0x60); // TCON_SETTING
EPD_7IN5BC_SendData(0x22);
EPD_7IN5BC_SendCommand(0x65); // FLASH CONTROL
EPD_7IN5BC_SendData(0x00);
EPD_7IN5BC_SendCommand(0x61); // TCON_RESOLUTION
EPD_7IN5BC_SendData(EPD_7IN5BC_WIDTH >> 8); // source 640
EPD_7IN5BC_SendData(EPD_7IN5BC_WIDTH & 0xff);
EPD_7IN5BC_SendData(EPD_7IN5BC_HEIGHT >> 8); // gate 384
EPD_7IN5BC_SendData(EPD_7IN5BC_HEIGHT & 0xff);
EPD_7IN5BC_SendCommand(0xe5); // FLASH MODE
EPD_7IN5BC_SendData(0x03);
}
/******************************************************************************
function : Clear screen
parameter:
******************************************************************************/
void EPD_7IN5BC_Clear(void)
{
UWORD Width, Height;
Width = (EPD_7IN5BC_WIDTH % 8 == 0)? (EPD_7IN5BC_WIDTH / 8): (EPD_7IN5BC_WIDTH / 8 + 1);
Height = EPD_7IN5BC_HEIGHT;
EPD_7IN5BC_SendCommand(0x10);
for (UWORD j = 0; j < Height; j++) {
for (UWORD i = 0; i < Width; i++) {
for(UBYTE k = 0; k < 4; k++) {
EPD_7IN5BC_SendData(0x33);
}
}
}
EPD_7IN5BC_TurnOnDisplay();
}
/******************************************************************************
function : Sends the image buffer in RAM to e-Paper and displays
parameter:
******************************************************************************/
void EPD_7IN5BC_Display(const UBYTE *blackimage, const UBYTE *ryimage)
{
UBYTE Data_Black, Data_RY, Data;
UDOUBLE i, j, Width, Height;
Width = (EPD_7IN5BC_WIDTH % 8 == 0)? (EPD_7IN5BC_WIDTH / 8 ): (EPD_7IN5BC_WIDTH / 8 + 1);
Height = EPD_7IN5BC_HEIGHT;
EPD_7IN5BC_SendCommand(0x10);
for (j = 0; j < Height; j++) {
for (i = 0; i < Width; i++) {
Data_Black = blackimage[i + j * Width];
Data_RY = ryimage[i + j * Width]; // red or yellow
for(UBYTE k = 0; k < 8; k++) {
if ((Data_RY & 0x80) == 0x00) {
Data = 0x04; //red
} else if ((Data_Black & 0x80) == 0x00) {
Data = 0x00; //black
} else {
Data = 0x03; //white
}
Data = (Data << 4) & 0xFF;
Data_Black = (Data_Black << 1) & 0xFF;
Data_RY = (Data_RY << 1) & 0xFF;
k += 1;
if((Data_RY & 0x80) == 0x00) {
Data |= 0x04; //red
} else if ((Data_Black & 0x80) == 0x00) {
Data |= 0x00; //black
} else {
Data |= 0x03; //white
}
Data_Black = (Data_Black << 1) & 0xFF;
Data_RY = (Data_RY << 1) & 0xFF;
EPD_7IN5BC_SendData(Data);
}
}
}
EPD_7IN5BC_TurnOnDisplay();
}
void EPD_7IN5BC_DisplayHalfScreen(const UBYTE *blackimage, const UBYTE *ryimage)
{
UBYTE Data_Black, Data_RY, Data;
UDOUBLE i, j, Width, Height;
Width = (EPD_7IN5BC_WIDTH % 8 == 0)? (EPD_7IN5BC_WIDTH / 8 ): (EPD_7IN5BC_WIDTH / 8 + 1);
Height = EPD_7IN5BC_HEIGHT;
EPD_7IN5BC_SendCommand(0x10);
for (j = 0; j < Height / 2; j++) {
for (i = 0; i < Width; i++) {
Data_Black = blackimage[i + j * Width];
Data_RY = ryimage[i + j * Width]; // red or yellow
for(UBYTE k = 0; k < 8; k++) {
if ((Data_RY & 0x80) == 0x00) {
Data = 0x04; //red
} else if ((Data_Black & 0x80) == 0x00) {
Data = 0x00; //black
} else {
Data = 0x03; //white
}
Data = (Data << 4) & 0xFF;
Data_Black = (Data_Black << 1) & 0xFF;
Data_RY = (Data_RY << 1) & 0xFF;
k += 1;
if((Data_RY & 0x80) == 0x00) {
Data |= 0x04; //red
} else if ((Data_Black & 0x80) == 0x00) {
Data |= 0x00; //black
} else {
Data |= 0x03; //white
}
Data_Black = (Data_Black << 1) & 0xFF;
Data_RY = (Data_RY << 1) & 0xFF;
EPD_7IN5BC_SendData(Data);
}
}
}
for (j = 0; j < Height / 2; j++) {
for (i = 0; i < Width; i++) {
for(UBYTE k = 0; k < 4; k++) {
EPD_7IN5BC_SendData(Data);
}
}
}
EPD_7IN5BC_TurnOnDisplay();
}
/******************************************************************************
function : Enter sleep mode
parameter:
******************************************************************************/
void EPD_7IN5BC_Sleep(void)
{
EPD_7IN5BC_SendCommand(0x02); // POWER_OFF
EPD_7IN5BC_ReadBusy();
EPD_7IN5BC_SendCommand(0x07); // DEEP_SLEEP
EPD_7IN5BC_SendData(0XA5);
}

100
RaspberryPi_JetsonNano/c/lib/e-Paper/EPD_7in5bc.h Normal file
View file

@ -0,0 +1,100 @@
/*****************************************************************************
* | File : EPD_7IN5BC.h
* | Author : Waveshare team
* | Function : 7.5inch e-paper b&c
* | Info :
* | This version: V3.0
* | Date : 2019-06-13
* | Info :
* -----------------------------------------------------------------------------
* V3.0(2019-06-13):
* 1.Change:
* EPD_Reset() => EPD_7IN5BC_Reset()
* EPD_SendCommand() => EPD_7IN5BC_SendCommand()
* EPD_SendData() => EPD_7IN5BC_SendData()
* EPD_WaitUntilIdle() => EPD_7IN5BC_ReadBusy()
* EPD_Init() => EPD_7IN5BC_Init()
* EPD_Clear() => EPD_7IN5BC_Clear()
* EPD_Display() => EPD_7IN5BC_Display()
* EPD_Sleep() => EPD_7IN5BC_Sleep()
* 2.Remove:
* #define PANEL_SETTING 0x00
* #define POWER_SETTING 0x01
* #define POWER_OFF 0x02
* #define POWER_OFF_SEQUENCE_SETTING 0x03
* #define POWER_ON 0x04
* #define POWER_ON_MEASURE 0x05
* #define BOOSTER_SOFT_START 0x06
* #define DEEP_SLEEP 0x07
* #define DATA_START_TRANSMISSION_1 0x10
* #define DATA_STOP 0x11
* #define DISPLAY_REFRESH 0x12
* #define IMAGE_PROCESS 0x13
* #define LUT_FOR_VCOM 0x20
* #define LUT_BLUE 0x21
* #define LUT_WHITE 0x22
* #define LUT_GRAY_1 0x23
* #define LUT_GRAY_2 0x24
* #define LUT_RED_0 0x25
* #define LUT_RED_1 0x26
* #define LUT_RED_2 0x27
* #define LUT_RED_3 0x28
* #define LUT_XON 0x29
* #define PLL_CONTROL 0x30
* #define TEMPERATURE_SENSOR_COMMAND 0x40
* #define TEMPERATURE_CALIBRATION 0x41
* #define TEMPERATURE_SENSOR_WRITE 0x42
* #define TEMPERATURE_SENSOR_READ 0x43
* #define VCOM_AND_DATA_INTERVAL_SETTING 0x50
* #define LOW_POWER_DETECTION 0x51
* #define TCON_SETTING 0x60
* #define TCON_RESOLUTION 0x61
* #define SPI_FLASH_CONTROL 0x65
* #define REVISION 0x70
* #define GET_STATUS 0x71
* #define AUTO_MEASUREMENT_VCOM 0x80
* #define READ_VCOM_VALUE 0x81
* #define VCM_DC_SETTING 0x82
* 3.add:
* EPD_7IN5BC_DisplayHalfScreen()
* -----------------------------------------------------------------------------
* V2.0(2018-11-09):
* 1.Remove:ImageBuff[EPD_HEIGHT * EPD_WIDTH / 8]
* 2.Change:EPD_Display(UBYTE *Image)
* Need to pass parameters: pointer to cached data
#
# 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_7IN5BC_H_
#define __EPD_7IN5BC_H_
#include "DEV_Config.h"
// Display resolution
#define EPD_7IN5BC_WIDTH 640
#define EPD_7IN5BC_HEIGHT 384
void EPD_7IN5BC_Init(void);
void EPD_7IN5BC_Clear(void);
void EPD_7IN5BC_Display(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_7IN5BC_DisplayHalfScreen(const UBYTE *blackimage, const UBYTE *ryimage);
void EPD_7IN5BC_Sleep(void);
#endif